redis源码解析（三）动态字符串sds高级功能函数

一时失言乱红尘 2022-05-10 10:10 262阅读 0赞

## 一. 简介 ##

本文在上文基础上，介绍动态字符串sds的更多功能函数。

## 二. 源码分析 ##

/* Like sdscatprintf() but gets va_list instead of being variadic. */
    sds sdscatvprintf(sds s, const char *fmt, va_list ap) { 
        va_list cpy;
        char staticbuf[1024], *buf = staticbuf, *t;
        size_t buflen = strlen(fmt)*2;
    
        /* We try to start using a static buffer for speed. * If not possible we revert to heap allocation. */
        if (buflen > sizeof(staticbuf)) { 
            buf = s_malloc(buflen);
            if (buf == NULL) return NULL;
        } else { 
            buflen = sizeof(staticbuf);
        }
    
        /* Try with buffers two times bigger every time we fail to * fit the string in the current buffer size. */
        while(1) { 
            buf[buflen-2] = '\0';
            va_copy(cpy,ap);
            vsnprintf(buf, buflen, fmt, cpy);
            va_end(cpy);
            if (buf[buflen-2] != '\0') { 
                if (buf != staticbuf) s_free(buf);
                buflen *= 2;
                buf = s_malloc(buflen);
                if (buf == NULL) return NULL;
                continue;
            }
            break;
        }
    
        /* Finally concat the obtained string to the SDS string and return it. */
        t = sdscat(s, buf);
        if (buf != staticbuf) s_free(buf);
        return t;
    }

该函数主要实现了

/* 用va_list实现类Printf格式的sds创建 * Append to the sds string 's' a string obtained using printf-alike format * specifier. * * After the call, the modified sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. * * Example: * * s = sdsnew("Sum is: "); * s = sdscatprintf(s,"%d+%d = %d",a,b,a+b). * * Often you need to create a string from scratch with the printf-alike * format. When this is the need, just use sdsempty() as the target string: * * s = sdscatprintf(sdsempty(), "... your format ...", args); */
    sds sdscatprintf(sds s, const char *fmt, ...) { 
        va_list ap;
        char *t;
        va_start(ap, fmt);
        t = sdscatvprintf(s,fmt,ap);
        va_end(ap);
        return t;
    }

该函数主要实现了

/* 不依赖于sprintf()所以速度更快 * This function is similar to sdscatprintf, but much faster as it does * not rely on sprintf() family functions implemented by the libc that * are often very slow. Moreover directly handling the sds string as * new data is concatenated provides a performance improvement. * * However this function only handles an incompatible subset of printf-alike * format specifiers: * * %s - C String * %S - SDS string * %i - signed int * %I - 64 bit signed integer (long long, int64_t) * %u - unsigned int * %U - 64 bit unsigned integer (unsigned long long, uint64_t) * %% - Verbatim "%" character. */
    sds sdscatfmt(sds s, char const *fmt, ...) { 
        size_t initlen = sdslen(s);
        const char *f = fmt;
        long i;
        va_list ap;
    
        va_start(ap,fmt);
        f = fmt;    /* Next format specifier byte to process. */
        i = initlen; /* Position of the next byte to write to dest str. */
        while(*f) { 
            char next, *str;
            size_t l;
            long long num;
            unsigned long long unum;
    
            /* Make sure there is always space for at least 1 char. */
            if (sdsavail(s)==0) { 
                s = sdsMakeRoomFor(s,1);
            }
    
            switch(*f) { 
            case '%':
                next = *(f+1);
                f++;
                switch(next) { 
                case 's':
                case 'S':
                    str = va_arg(ap,char*);
                    l = (next == 's') ? strlen(str) : sdslen(str);
                    if (sdsavail(s) < l) { 
                        s = sdsMakeRoomFor(s,l);
                    }
                    memcpy(s+i,str,l);
                    sdsinclen(s,l);
                    i += l;
                    break;
                case 'i':
                case 'I':
                    if (next == 'i')
                        num = va_arg(ap,int);
                    else
                        num = va_arg(ap,long long);
                    { 
                        char buf[SDS_LLSTR_SIZE];
                        l = sdsll2str(buf,num);
                        if (sdsavail(s) < l) { 
                            s = sdsMakeRoomFor(s,l);
                        }
                        memcpy(s+i,buf,l);
                        sdsinclen(s,l);
                        i += l;
                    }
                    break;
                case 'u':
                case 'U':
                    if (next == 'u')
                        unum = va_arg(ap,unsigned int);
                    else
                        unum = va_arg(ap,unsigned long long);
                    { 
                        char buf[SDS_LLSTR_SIZE];
                        l = sdsull2str(buf,unum);
                        if (sdsavail(s) < l) { 
                            s = sdsMakeRoomFor(s,l);
                        }
                        memcpy(s+i,buf,l);
                        sdsinclen(s,l);
                        i += l;
                    }
                    break;
                default: /* Handle %% and generally %<unknown>. */
                    s[i++] = next;
                    sdsinclen(s,1);
                    break;
                }
                break;
            default:
                s[i++] = *f;
                sdsinclen(s,1);
                break;
            }
            f++;
        }
        va_end(ap);
    
        /* Add null-term */
        s[i] = '\0';
        return s;
    }

该函数主要实现了

/* 在s中删去cset字符串 * Remove the part of the string from left and from right composed just of * contiguous characters found in 'cset', that is a null terminted C string. * * After the call, the modified sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. * * Example: * * s = sdsnew("AA...AA.a.aa.aHelloWorld :::"); * s = sdstrim(s,"Aa. :"); * printf("%s\n", s); * * Output will be just "Hello World". */
    sds sdstrim(sds s, const char *cset) { 
        char *start, *end, *sp, *ep;
        size_t len;
    
        sp = start = s;
        ep = end = s+sdslen(s)-1;
        while(sp <= end && strchr(cset, *sp)) sp++;
        while(ep > sp && strchr(cset, *ep)) ep--;
        len = (sp > ep) ? 0 : ((ep-sp)+1);
        if (s != sp) memmove(s, sp, len);
        s[len] = '\0';
        sdssetlen(s,len);
        return s;
    }

该函数主要实现了

/* 根据start和end截取sds * Turn the string into a smaller (or equal) string containing only the * substring specified by the 'start' and 'end' indexes. * * start and end can be negative, where -1 means the last character of the * string, -2 the penultimate character, and so forth. * * The interval is inclusive, so the start and end characters will be part * of the resulting string. * * The string is modified in-place. * * Example: * * s = sdsnew("Hello World"); * sdsrange(s,1,-1); => "ello World" */
    void sdsrange(sds s, ssize_t start, ssize_t end) { 
        size_t newlen, len = sdslen(s);
    
        if (len == 0) return;
        if (start < 0) { 
            start = len+start;
            if (start < 0) start = 0;
        }
        if (end < 0) { 
            end = len+end;
            if (end < 0) end = 0;
        }
        newlen = (start > end) ? 0 : (end-start)+1;
        if (newlen != 0) { 
            if (start >= (ssize_t)len) { 
                newlen = 0;
            } else if (end >= (ssize_t)len) { 
                end = len-1;
                newlen = (start > end) ? 0 : (end-start)+1;
            }
        } else { 
            start = 0;
        }
        if (start && newlen) memmove(s, s+start, newlen);
        s[newlen] = 0;
        sdssetlen(s,newlen);
    }

该函数主要实现了

/* 将所有大写转化为小写 * Apply tolower() to every character of the sds string 's'. */
    void sdstolower(sds s) { 
        size_t len = sdslen(s), j;
    
        for (j = 0; j < len; j++) s[j] = tolower(s[j]);
    }
    
    /* 将所有小写转化为大写 * Apply toupper() to every character of the sds string 's'. */
    void sdstoupper(sds s) { 
        size_t len = sdslen(s), j;
    
        for (j = 0; j < len; j++) s[j] = toupper(s[j]);
    }

该函数主要实现了

/* 使用memcmp比较两个sds * Compare two sds strings s1 and s2 with memcmp(). * * Return value: * * positive if s1 > s2. * negative if s1 < s2. * 0 if s1 and s2 are exactly the same binary string. * * If two strings share exactly the same prefix, but one of the two has * additional characters, the longer string is considered to be greater than * the smaller one. */
    int sdscmp(const sds s1, const sds s2) { 
        size_t l1, l2, minlen;
        int cmp;
    
        l1 = sdslen(s1);
        l2 = sdslen(s2);
        minlen = (l1 < l2) ? l1 : l2;
        cmp = memcmp(s1,s2,minlen);
        if (cmp == 0) return l1>l2? 1: (l1<l2? -1: 0);
        return cmp;
    }

该函数主要实现了

/* 通过分隔符sep将s分隔成多段，count为段数 * Split 's' with separator in 'sep'. An array * of sds strings is returned. *count will be set * by reference to the number of tokens returned. * * On out of memory, zero length string, zero length * separator, NULL is returned. * * Note that 'sep' is able to split a string using * a multi-character separator. For example * sdssplit("foo_-_bar","_-_"); will return two * elements "foo" and "bar". * * This version of the function is binary-safe but * requires length arguments. sdssplit() is just the * same function but for zero-terminated strings. */
    sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count) { 
        int elements = 0, slots = 5;
        long start = 0, j;
        sds *tokens;
    
        if (seplen < 1 || len < 0) return NULL;
    
        tokens = s_malloc(sizeof(sds)*slots);
        if (tokens == NULL) return NULL;
    
        if (len == 0) { 
            *count = 0;
            return tokens;
        }
        for (j = 0; j < (len-(seplen-1)); j++) { 
            /* make sure there is room for the next element and the final one */
            if (slots < elements+2) { 
                sds *newtokens;
    
                slots *= 2;
                newtokens = s_realloc(tokens,sizeof(sds)*slots);
                if (newtokens == NULL) goto cleanup;
                tokens = newtokens;
            }
            /* search the separator */
            if ((seplen == 1 && *(s+j) == sep[0]) || (memcmp(s+j,sep,seplen) == 0)) { 
                tokens[elements] = sdsnewlen(s+start,j-start);
                if (tokens[elements] == NULL) goto cleanup;
                elements++;
                start = j+seplen;
                j = j+seplen-1; /* skip the separator */
            }
        }
        /* Add the final element. We are sure there is room in the tokens array. */
        tokens[elements] = sdsnewlen(s+start,len-start);
        if (tokens[elements] == NULL) goto cleanup;
        elements++;
        *count = elements;
        return tokens;
    
    cleanup:
        { 
            int i;
            for (i = 0; i < elements; i++) sdsfree(tokens[i]);
            s_free(tokens);
            *count = 0;
            return NULL;
        }
    }

该函数主要实现了

/* 释放切割后的sds资源 * Free the result returned by sdssplitlen(), or do nothing if 'tokens' is NULL. */
    void sdsfreesplitres(sds *tokens, int count) { 
        if (!tokens) return;
        while(count--)
            sdsfree(tokens[count]);
        s_free(tokens);
    }

该函数主要实现了

/* 在sds上附加其拥有的特殊符号 * Append to the sds string "s" an escaped string representation where * all the non-printable characters (tested with isprint()) are turned into * escapes in the form "\n\r\a...." or "\x<hex-number>". * * After the call, the modified sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */
    sds sdscatrepr(sds s, const char *p, size_t len) { 
        s = sdscatlen(s,"\"",1);
        while(len--) { 
            switch(*p) { 
            case '\\':
            case '"':
                s = sdscatprintf(s,"\\%c",*p);
                break;
            case '\n': s = sdscatlen(s,"\\n",2); break;
            case '\r': s = sdscatlen(s,"\\r",2); break;
            case '\t': s = sdscatlen(s,"\\t",2); break;
            case '\a': s = sdscatlen(s,"\\a",2); break;
            case '\b': s = sdscatlen(s,"\\b",2); break;
            default:
                if (isprint(*p))
                    s = sdscatprintf(s,"%c",*p);
                else
                    s = sdscatprintf(s,"\\x%02x",(unsigned char)*p);
                break;
            }
            p++;
        }
        return sdscatlen(s,"\"",1);
    }

该函数主要实现了

/* 判断是否是十六进制 * Helper function for sdssplitargs() that returns non zero if 'c' * is a valid hex digit. */
    int is_hex_digit(char c) { 
        return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
               (c >= 'A' && c <= 'F');
    }
    
    /* 十六进制转换为十进制整形 * Helper function for sdssplitargs() that converts a hex digit into an * integer from 0 to 15 */
    int hex_digit_to_int(char c) { 
        switch(c) { 
        case '0': return 0;
        case '1': return 1;
        case '2': return 2;
        case '3': return 3;
        case '4': return 4;
        case '5': return 5;
        case '6': return 6;
        case '7': return 7;
        case '8': return 8;
        case '9': return 9;
        case 'a': case 'A': return 10;
        case 'b': case 'B': return 11;
        case 'c': case 'C': return 12;
        case 'd': case 'D': return 13;
        case 'e': case 'E': return 14;
        case 'f': case 'F': return 15;
        default: return 0;
        }
    }

该函数主要实现了

/* Split a line into arguments, where every argument can be in the * following programming-language REPL-alike form: * * foo bar "newline are supported\n" and "\xff\x00otherstuff" * * The number of arguments is stored into *argc, and an array * of sds is returned. * * The caller should free the resulting array of sds strings with * sdsfreesplitres(). * * Note that sdscatrepr() is able to convert back a string into * a quoted string in the same format sdssplitargs() is able to parse. * * The function returns the allocated tokens on success, even when the * input string is empty, or NULL if the input contains unbalanced * quotes or closed quotes followed by non space characters * as in: "foo"bar or "foo' */
    sds *sdssplitargs(const char *line, int *argc) { 
        const char *p = line;
        char *current = NULL;
        char **vector = NULL;
    
        *argc = 0;
        while(1) { 
            /* skip blanks */
            while(*p && isspace(*p)) p++;
            if (*p) { 
                /* get a token */
                int inq=0;  /* set to 1 if we are in "quotes" */
                int insq=0; /* set to 1 if we are in 'single quotes' */
                int done=0;
    
                if (current == NULL) current = sdsempty();
                while(!done) { 
                    if (inq) { 
                        if (*p == '\\' && *(p+1) == 'x' &&
                                                 is_hex_digit(*(p+2)) &&
                                                 is_hex_digit(*(p+3)))
                        { 
                            unsigned char byte;
    
                            byte = (hex_digit_to_int(*(p+2))*16)+
                                    hex_digit_to_int(*(p+3));
                            current = sdscatlen(current,(char*)&byte,1);
                            p += 3;
                        } else if (*p == '\\' && *(p+1)) { 
                            char c;
    
                            p++;
                            switch(*p) { 
                            case 'n': c = '\n'; break;
                            case 'r': c = '\r'; break;
                            case 't': c = '\t'; break;
                            case 'b': c = '\b'; break;
                            case 'a': c = '\a'; break;
                            default: c = *p; break;
                            }
                            current = sdscatlen(current,&c,1);
                        } else if (*p == '"') { 
                            /* closing quote must be followed by a space or * nothing at all. */
                            if (*(p+1) && !isspace(*(p+1))) goto err;
                            done=1;
                        } else if (!*p) { 
                            /* unterminated quotes */
                            goto err;
                        } else { 
                            current = sdscatlen(current,p,1);
                        }
                    } else if (insq) { 
                        if (*p == '\\' && *(p+1) == '\'') { 
                            p++;
                            current = sdscatlen(current,"'",1);
                        } else if (*p == '\'') { 
                            /* closing quote must be followed by a space or * nothing at all. */
                            if (*(p+1) && !isspace(*(p+1))) goto err;
                            done=1;
                        } else if (!*p) { 
                            /* unterminated quotes */
                            goto err;
                        } else { 
                            current = sdscatlen(current,p,1);
                        }
                    } else { 
                        switch(*p) { 
                        case ' ':
                        case '\n':
                        case '\r':
                        case '\t':
                        case '\0':
                            done=1;
                            break;
                        case '"':
                            inq=1;
                            break;
                        case '\'':
                            insq=1;
                            break;
                        default:
                            current = sdscatlen(current,p,1);
                            break;
                        }
                    }
                    if (*p) p++;
                }
                /* add the token to the vector */
                vector = s_realloc(vector,((*argc)+1)*sizeof(char*));
                vector[*argc] = current;
                (*argc)++;
                current = NULL;
            } else { 
                /* Even on empty input string return something not NULL. */
                if (vector == NULL) vector = s_malloc(sizeof(void*));
                return vector;
            }
        }
    
    err:
        while((*argc)--)
            sdsfree(vector[*argc]);
        s_free(vector);
        if (current) sdsfree(current);
        *argc = 0;
        return NULL;
    }

该函数主要实现了

/* 将sds中指定的from字符修改为to中指定的字符 * Modify the string substituting all the occurrences of the set of * characters specified in the 'from' string to the corresponding character * in the 'to' array. * * For instance: sdsmapchars(mystring, "ho", "01", 2) * will have the effect of turning the string "hello" into "0ell1". * * The function returns the sds string pointer, that is always the same * as the input pointer since no resize is needed. */
    sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) { 
        size_t j, i, l = sdslen(s);
    
        for (j = 0; j < l; j++) { 
            for (i = 0; i < setlen; i++) { 
                if (s[j] == from[i]) { 
                    s[j] = to[i];
                    break;
                }
            }
        }
        return s;
    }

该函数主要实现了

/* 将argv中的字符串存储在sds中 * Join an array of C strings using the specified separator (also a C string). * Returns the result as an sds string. */
    sds sdsjoin(char **argv, int argc, char *sep) { 
        sds join = sdsempty();
        int j;
    
        for (j = 0; j < argc; j++) { 
            join = sdscat(join, argv[j]);
            if (j != argc-1) join = sdscat(join,sep);
        }
        return join;
    }

该函数主要实现了

/* 拼接存储一些列sds * Like sdsjoin, but joins an array of SDS strings. */
    sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen) { 
        sds join = sdsempty();
        int j;
    
        for (j = 0; j < argc; j++) { 
            join = sdscatsds(join, argv[j]);
            if (j != argc-1) join = sdscatlen(join,sep,seplen);
        }
        return join;
    }

该函数主要实现了

/* Wrappers to the allocators used by SDS. Note that SDS will actually * just use the macros defined into sdsalloc.h in order to avoid to pay * the overhead of function calls. Here we define these wrappers only for * the programs SDS is linked to, if they want to touch the SDS internals * even if they use a different allocator. */
    void *sds_malloc(size_t size) {  return s_malloc(size); }
    void *sds_realloc(void *ptr, size_t size) {  return s_realloc(ptr,size); }
    void sds_free(void *ptr) {  s_free(ptr); }
    
    #if defined(SDS_TEST_MAIN)
    #include <stdio.h>
    #include "testhelp.h"
    #include "limits.h"
    
    /*测试用例*/
    #define UNUSED(x) (void)(x)
    int sdsTest(void) { 
        { 
            sds x = sdsnew("foo"), y;
            test_cond("Create a string and obtain the length",
                sdslen(x) == 3 && memcmp(x,"foo\0",4) == 0)
            sdsfree(x);
    		
            x = sdsnewlen("foo",2);
            test_cond("Create a string with specified length",
                sdslen(x) == 2 && memcmp(x,"fo\0",3) == 0)
    
            x = sdscat(x,"bar");
            test_cond("Strings concatenation",
                sdslen(x) == 5 && memcmp(x,"fobar\0",6) == 0);
    
            x = sdscpy(x,"a");
            test_cond("sdscpy() against an originally longer string",
                sdslen(x) == 1 && memcmp(x,"a\0",2) == 0)
    
            x = sdscpy(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk");
            test_cond("sdscpy() against an originally shorter string",
                sdslen(x) == 33 &&
                memcmp(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk\0",33) == 0)
            sdsfree(x);
    		
            x = sdscatprintf(sdsempty(),"%d",123);
            test_cond("sdscatprintf() seems working in the base case",
                sdslen(x) == 3 && memcmp(x,"123\0",4) == 0)
            sdsfree(x);
    		
            x = sdsnew("--");
            x = sdscatfmt(x, "Hello %s World %I,%I--", "Hi!", LLONG_MIN,LLONG_MAX);
            test_cond("sdscatfmt() seems working in the base case",
                sdslen(x) == 60 &&
                memcmp(x,"--Hello Hi! World -9223372036854775808,"
                         "9223372036854775807--",60) == 0)
            printf("[%s]\n",x);
    
            sdsfree(x);
            x = sdsnew("--");
            x = sdscatfmt(x, "%u,%U--", UINT_MAX, ULLONG_MAX);
            test_cond("sdscatfmt() seems working with unsigned numbers",
                sdslen(x) == 35 &&
                memcmp(x,"--4294967295,18446744073709551615--",35) == 0)
    
            sdsfree(x);
            x = sdsnew(" x ");
            sdstrim(x," x");
            test_cond("sdstrim() works when all chars match",
                sdslen(x) == 0)
    
            sdsfree(x);
            x = sdsnew(" x ");
            sdstrim(x," ");
            test_cond("sdstrim() works when a single char remains",
                sdslen(x) == 1 && x[0] == 'x')
    
            sdsfree(x);
            x = sdsnew("xxciaoyyy");
            sdstrim(x,"xy");
            test_cond("sdstrim() correctly trims characters",
                sdslen(x) == 4 && memcmp(x,"ciao\0",5) == 0)
    
            y = sdsdup(x);
            sdsrange(y,1,1);
            test_cond("sdsrange(...,1,1)",
                sdslen(y) == 1 && memcmp(y,"i\0",2) == 0)
    
            sdsfree(y);
            y = sdsdup(x);
            sdsrange(y,1,-1);
            test_cond("sdsrange(...,1,-1)",
                sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0)
    
            sdsfree(y);
            y = sdsdup(x);
            sdsrange(y,-2,-1);
            test_cond("sdsrange(...,-2,-1)",
                sdslen(y) == 2 && memcmp(y,"ao\0",3) == 0)
    
            sdsfree(y);
            y = sdsdup(x);
            sdsrange(y,2,1);
            test_cond("sdsrange(...,2,1)",
                sdslen(y) == 0 && memcmp(y,"\0",1) == 0)
    
            sdsfree(y);
            y = sdsdup(x);
            sdsrange(y,1,100);
            test_cond("sdsrange(...,1,100)",
                sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0)
    
            sdsfree(y);
            y = sdsdup(x);
            sdsrange(y,100,100);
            test_cond("sdsrange(...,100,100)",
                sdslen(y) == 0 && memcmp(y,"\0",1) == 0)
    
            sdsfree(y);
            sdsfree(x);
            x = sdsnew("foo");
            y = sdsnew("foa");
            test_cond("sdscmp(foo,foa)", sdscmp(x,y) > 0)
    
            sdsfree(y);
            sdsfree(x);
            x = sdsnew("bar");
            y = sdsnew("bar");
            test_cond("sdscmp(bar,bar)", sdscmp(x,y) == 0)
    
            sdsfree(y);
            sdsfree(x);
            x = sdsnew("aar");
            y = sdsnew("bar");
            test_cond("sdscmp(bar,bar)", sdscmp(x,y) < 0)
    
            sdsfree(y);
            sdsfree(x);
            x = sdsnewlen("\a\n\0foo\r",7);
            y = sdscatrepr(sdsempty(),x,sdslen(x));
            test_cond("sdscatrepr(...data...)",
                memcmp(y,"\"\\a\\n\\x00foo\\r\"",15) == 0)
    
            { 
                unsigned int oldfree;
                char *p;
                int step = 10, j, i;
    
                sdsfree(x);
                sdsfree(y);
                x = sdsnew("0");
                test_cond("sdsnew() free/len buffers", sdslen(x) == 1 && sdsavail(x) == 0);
    
                /* Run the test a few times in order to hit the first two * SDS header types. */
                for (i = 0; i < 10; i++) { 
                    int oldlen = sdslen(x);
                    x = sdsMakeRoomFor(x,step);
                    int type = x[-1]&SDS_TYPE_MASK;
    
                    test_cond("sdsMakeRoomFor() len", sdslen(x) == oldlen);
                    if (type != SDS_TYPE_5) { 
                        test_cond("sdsMakeRoomFor() free", sdsavail(x) >= step);
                        oldfree = sdsavail(x);
                    }
                    p = x+oldlen;
                    for (j = 0; j < step; j++) { 
                        p[j] = 'A'+j;
                    }
                    sdsIncrLen(x,step);
                }
                test_cond("sdsMakeRoomFor() content",
                    memcmp("0ABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJ",x,101) == 0);
                test_cond("sdsMakeRoomFor() final length",sdslen(x)==101);
    
                sdsfree(x);
            }
        }
        test_report()
        return 0;
    }
    #endif