sds和adlist一样，是redis的基础数据结构之一，是其为自身实现的字符串类型。A C dynamic strings library
sds.h
1 #ifndef __SDS_H 2 #define __SDS_H 3 4 #define SDS_MAX_PREALLOC (1024*1024) //字符串最大的预分配长度是1M 5 6 #include <sys/types.h> 7 #include <stdarg.h> 8 9 typedef char *sds; //sds本身被typedef为char*，是后续绝大部分函数的参数（之一） 10 11 struct sdshdr { 12 int len; 13 int free; 14 char buf[]; 15 }; //字符串的数据结构，记录了字符串长度、空闲字节，以及指向实际存储数据buf的指针 16 17 static inline size_t sdslen(const sds s) { 18 struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr))); 19 return sh->len; 20 } //尽管在不考虑typedef的前提下，但从函数参数来看，非引用/指针类型，但毕竟底层实现是char*，因此作者也将所有函数内不改变的参数标记为了const
//传的参数指向实际字符串，因此需要先取得数据结构头的位置，然后返回字符串长度； 21 22 static inline size_t sdsavail(const sds s) { 23 struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr))); 24 return sh->free; 25 } //同上，返回的是空闲字节数 26 27 sds sdsnewlen(const void *init, size_t initlen); 28 sds sdsnew(const char *init); 29 sds sdsempty(); //三个初始化函数 30 size_t sdslen(const sds s); //上述内联函数的函数声明 31 sds sdsdup(const sds s); //字符串复制函数 32 void sdsfree(sds s); 33 size_t sdsavail(sds s); 34 sds sdsgrowzero(sds s, size_t len); 35 sds sdscatlen(sds s, void *t, size_t len); 36 sds sdscat(sds s, char *t); 37 sds sdscatsds(sds s, sds t); 38 sds sdscpylen(sds s, char *t, size_t len); 39 sds sdscpy(sds s, char *t); 40 41 sds sdscatvprintf(sds s, const char *fmt, va_list ap); 42 #ifdef __GNUC__ 43 sds sdscatprintf(sds s, const char *fmt, ...) 44 __attribute__((format(printf, 2, 3))); 45 #else 46 sds sdscatprintf(sds s, const char *fmt, ...); 47 #endif //为啥这么写，没看懂。。非重点，暂且略过 48 49 sds sdstrim(sds s, const char *cset); 50 sds sdsrange(sds s, int start, int end); 51 void sdsupdatelen(sds s); 52 void sdsclear(sds s); 53 int sdscmp(sds s1, sds s2); 54 sds *sdssplitlen(char *s, int len, char *sep, int seplen, int *count); 55 void sdsfreesplitres(sds *tokens, int count); 56 void sdstolower(sds s); 57 void sdstoupper(sds s); 58 sds sdsfromlonglong(long long value); 59 sds sdscatrepr(sds s, char *p, size_t len); 60 sds *sdssplitargs(char *line, int *argc); 61 62 #endif
对libc的string.h库熟悉的同学，根据上述函数名也大概能猜出来函数的作用，就不一一写了，具体参见sds.c的实现部分。
sds.c
看似很长，但绝大部分代码都很通俗易懂，大家不要恐惧。
1 #define SDS_ABORT_ON_OOM //在内存不够时的默认动作是终止进程（abort） 2 3 #include <stdio.h> 4 #include <stdlib.h> 5 #include <string.h> 6 #include <ctype.h> 7 #include "sds.h" 8 #include "zmalloc.h" //同样用na个简单封装的内存分配库 9 10 static void sdsOomAbort(void) { 11 fprintf(stderr,"SDS: Out Of Memory (SDS_ABORT_ON_OOM defined)\n"); 12 abort(); 13 } //abort前作的唯一的善后工作是告诉大家自己是由于在SDS时内存不够挂掉的 14 15 sds sdsnewlen(const void *init, size_t initlen) { 16 struct sdshdr *sh; 17 18 sh = zmalloc(sizeof(struct sdshdr)+initlen+1); //所分配的长度是头的长度sizeof(struct sdshdr)+字符串长度initlen+‘\0’的一个字节
//注意这里的sizeof(struct sdshdr)长度为8，剩下的都直接存在了sh->buf上 19 #ifdef SDS_ABORT_ON_OOM 20 if (sh == NULL) sdsOomAbort(); 21 #else 22 if (sh == NULL) return NULL; //如果没有定义SDS_ABORT_ON_OOM，简单的返回NULL 23 #endif 24 sh->len = initlen; 25 sh->free = 0; //创建字符串时free的长度是0 26 if (initlen) { 27 if (init) memcpy(sh->buf, init, initlen); //若参数init不等于NULL,则拷贝initlen长度给sh->buf 28 else memset(sh->buf,0,initlen); //否则这块缓冲区被赋值为0 29 } 30 sh->buf[initlen] = '\0'; //用'\0'为字符串结尾 31 return (char*)sh->buf; //返回的是实际字符串的指针 32 } 33 34 sds sdsempty(void) { 35 return sdsnewlen("",0); //注意""字符串常量并不代表空，但0表示空了 36 } 37 38 sds sdsnew(const char *init) { 39 size_t initlen = (init == NULL) ? 0 : strlen(init); 40 return sdsnewlen(init, initlen); 41 } 42 43 sds sdsdup(const sds s) { 44 return sdsnewlen(s, sdslen(s)); 45 } //dup复制函数也是调用newlen实现的 46 47 void sdsfree(sds s) { 48 if (s == NULL) return; 49 zfree(s-sizeof(struct sdshdr)); 50 } //释放链接要先找到sds的header 51 52 void sdsupdatelen(sds s) { 53 struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr))); 54 int reallen = strlen(s); 55 sh->free += (sh->len-reallen); 56 sh->len = reallen; 57 } //更新长度是更新header的len和free两个字段 58 59 void sdsclear(sds s) { 60 struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr))); 61 sh->free += sh->len; 62 sh->len = 0; 63 sh->buf[0] = '\0'; 64 } //将所有的len都给free，但并未释放内存空间 65 66 static sds sdsMakeRoomFor(sds s, size_t addlen) { 67 struct sdshdr *sh, *newsh; 68 size_t free = sdsavail(s); 69 size_t len, newlen; 70 71 if (free >= addlen) return s; //如果剩余空间仍足够，则直接将传进来的参数s返回 72 len = sdslen(s); 73 sh = (void*) (s-(sizeof(struct sdshdr))); 74 newlen = (len+addlen); 75 if (newlen < SDS_MAX_PREALLOC) 76 newlen *= 2; 77 else 78 newlen += SDS_MAX_PREALLOC; //在为newlen增加了addlen这么长的空余空间的同时，也在这次操作中额外申请了内存空间，当newlen小于系统定义的单次最大分配内存时，额外分配的长度是newlen，负责多分配SDS_MAX_PREALLOC这么大的空间。熟悉std::vector实现的同学对这种分配机制一定似曾相识。这里基于这样一种假设，这次make room的sds，也很有可能在不久的将来再次make room，所以预先分配了空间 79 newsh = zrealloc(sh, sizeof(struct sdshdr)+newlen+1); //realloc保证原来分配空间的数据会拷贝过去，但执行此操作后，sh指针就失效了 80 #ifdef SDS_ABORT_ON_OOM 81 if (newsh == NULL) sdsOomAbort(); 82 #else 83 if (newsh == NULL) return NULL; 84 #endif 85 86 newsh->free = newlen - len; 87 return newsh->buf; 88 } 89 90 /* Grow the sds to have the specified length. Bytes that were not part of 91 * the original length of the sds will be set to zero. */ 92 sds sdsgrowzero(sds s, size_t len) { //len是一个to 参数，表示增长到 93 struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr))); 94 size_t totlen, curlen = sh->len; 95 96 if (len <= curlen) return s; //len比原sds还短，则直接返回 97 s = sdsMakeRoomFor(s,len-curlen); 98 if (s == NULL) return NULL; //只有可能在不abort时，才会返回NULL 99 100 /* Make sure added region doesn't contain garbage */ 101 sh = (void*)(s-(sizeof(struct sdshdr))); 102 memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */ //将len长度的字段都赋成0了，包括最有的'\0'也赋成0了 103 totlen = sh->len+sh->free; 104 sh->len = len; 105 sh->free = totlen-sh->len; 106 return s; //经过这个函数调用后，sds长度变成了len，只是有可能之前不足len长度的字符串被填成了0 107 } 108 109 sds sdscatlen(sds s, void *t, size_t len) { 110 struct sdshdr *sh; 111 size_t curlen = sdslen(s); 112 113 s = sdsMakeRoomFor(s,len); 114 if (s == NULL) return NULL; 115 sh = (void*) (s-(sizeof(struct sdshdr))); 116 memcpy(s+curlen, t, len); 117 sh->len = curlen+len; 118 sh->free = sh->free-len; 119 s[curlen+len] = '\0'; 120 return s; 121 } 122 123 sds sdscat(sds s, char *t) { 124 return sdscatlen(s, t, strlen(t)); 125 } 126 127 sds sdscatsds(sds s, sds t) { 128 return sdscatlen(s, t, sdslen(t)); 129 } 130 131 sds sdscpylen(sds s, char *t, size_t len) { 132 struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr))); 133 size_t totlen = sh->free+sh->len; 134 135 if (totlen < len) { 136 s = sdsMakeRoomFor(s,len-sh->len); 137 if (s == NULL) return NULL; 138 sh = (void*) (s-(sizeof(struct sdshdr))); 139 totlen = sh->free+sh->len; 140 } 141 memcpy(s, t, len); 142 s[len] = '\0'; 143 sh->len = len; 144 sh->free = totlen-len; 145 return s; 146 } 147 148 sds sdscpy(sds s, char *t) { 149 return sdscpylen(s, t, strlen(t)); 150 } 151
下面这个函数的实现很有意思，因为类printf操作，事先并不知道源串长度，因此采用了一种类似启发式的方法，从16bytes开始，按照倍数递增的方法来猜测长度，猜测长度时，是在倒数第二个字节处打了个标记（'\0'）,然后判断操作前后是否保持一致来判断是否空间够的。好好看看while循环，其实挺有意思的。 152 sds sdscatvprintf(sds s, const char *fmt, va_list ap) { 153 va_list cpy; 154 char *buf, *t; 155 size_t buflen = 16; 156 157 while(1) { 158 buf = zmalloc(buflen); 159 #ifdef SDS_ABORT_ON_OOM 160 if (buf == NULL) sdsOomAbort(); 161 #else 162 if (buf == NULL) return NULL; 163 #endif 164 buf[buflen-2] = '\0'; 165 va_copy(cpy,ap); 166 vsnprintf(buf, buflen, fmt, cpy); 167 if (buf[buflen-2] != '\0') { 168 zfree(buf); 169 buflen *= 2; 170 continue; 171 } 172 break; 173 } 174 t = sdscat(s, buf); 175 zfree(buf); 176 return t; 177 } 178 179 sds sdscatprintf(sds s, const char *fmt, ...) { 180 va_list ap; 181 char *t; 182 va_start(ap, fmt); 183 t = sdscatvprintf(s,fmt,ap); 184 va_end(ap); 185 return t; 186 } 187 188 sds sdstrim(sds s, const char *cset) { 189 struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr))); 190 char *start, *end, *sp, *ep; //sp == start pointer, ep == end pointer, sp,ep 是移动的，start end是静止的 191 size_t len; 192 193 sp = start = s; 194 ep = end = s+sdslen(s)-1; //最后一个有意义的字节，非'\0' 195 while(sp <= end && strchr(cset, *sp)) sp++; 196 while(ep > start && strchr(cset, *ep)) ep--; //将头尾出现在字符串cset中的字符都删干净, *sp和*ep都是字符而非字符指针
197 len = (sp > ep) ? 0 : ((ep-sp)+1); 198 if (sh->buf != sp) memmove(sh->buf, sp, len); //因为sp和sh->buf指向的字符串有可能重叠，所以用了memmove 199 sh->buf[len] = '\0'; 200 sh->free = sh->free+(sh->len-len); 201 sh->len = len; 202 return s; //删除特定空间后，并不释放内存，只是增大sh->free 203 } 204 205 sds sdsrange(sds s, int start, int end) { 206 struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr))); 207 size_t newlen, len = sdslen(s); 208 209 if (len == 0) return s; 210 if (start < 0) { 211 start = len+start; 212 if (start < 0) start = 0; 213 } 214 if (end < 0) { 215 end = len+end; 216 if (end < 0) end = 0; 217 } //处理start和end为负值的情况 218 newlen = (start > end) ? 0 : (end-start)+1; 219 if (newlen != 0) { 220 if (start >= (signed)len) { 221 newlen = 0; 222 } else if (end >= (signed)len) { 223 end = len-1; 224 newlen = (start > end) ? 0 : (end-start)+1; 225 } 226 } else { 227 start = 0; 228 } 229 if (start && newlen) memmove(sh->buf, sh->buf+start, newlen); //注意这个函数是在传进来的字符串上做操作的 230 sh->buf[newlen] = 0; 231 sh->free = sh->free+(sh->len-newlen); 232 sh->len = newlen; 233 return s; 234 } 235 236 void sdstolower(sds s) { 237 int len = sdslen(s), j; 238 239 for (j = 0; j < len; j++) s[j] = tolower(s[j]); 240 } //逐个字符变成小写 241 242 void sdstoupper(sds s) { 243 int len = sdslen(s), j; 244 245 for (j = 0; j < len; j++) s[j] = toupper(s[j]); 246 } //逐个字符变成大写 247 248 int sdscmp(sds s1, sds s2) { 249 size_t l1, l2, minlen; 250 int cmp; 251 252 l1 = sdslen(s1); 253 l2 = sdslen(s2); 254 minlen = (l1 < l2) ? l1 : l2; 255 cmp = memcmp(s1,s2,minlen); 256 if (cmp == 0) return l1-l2; 257 return cmp; 258 } //字符串比较，没啥好说的，只关注len，不关注free 259 260 /* Split 's' with separator in 'sep'. An array 261 * of sds strings is returned. *count will be set 262 * by reference to the number of tokens returned. 263 * 264 * On out of memory, zero length string, zero length 265 * separator, NULL is returned. 266 * 267 * Note that 'sep' is able to split a string using 268 * a multi-character separator. For example 269 * sdssplit("foo_-_bar","_-_"); will return two 270 * elements "foo" and "bar". 271 * 272 * This version of the function is binary-safe but 273 * requires length arguments. sdssplit() is just the 274 * same function but for zero-terminated strings. //其实作者根本就懒到没有在额外提供sdssplit，任何场景下都使用binary-safe的函数总是好的 275 */ 276 sds *sdssplitlen(char *s, int len, char *sep, int seplen, int *count) { 277 int elements = 0, slots = 5, start = 0, j; 278 sds *tokens; 279 280 if (seplen < 1 || len < 0) return NULL; 281 282 tokens = zmalloc(sizeof(sds)*slots); //先假设有5个tokens供返回。在这个函数里返回值叫tokens,但在后续的sdssplitargs里返回值被起名为vector，而且类型一个是sds*，一个是char**，虽说是一样的，但其实还是改的一致比较好。按道理，一个这样的不算大（关键是逻辑简单）的源文件，作者没必要交给两个不同的人写啊 283 #ifdef SDS_ABORT_ON_OOM 284 if (tokens == NULL) sdsOomAbort(); 285 #else 286 if (tokens == NULL) return NULL; 287 #endif 288 289 if (len == 0) { 290 *count = 0; 291 return tokens; 292 } 293 for (j = 0; j < (len-(seplen-1)); j++) { 294 /* make sure there is room for the next element and the final one */ 295 if (slots < elements+2) { 296 sds *newtokens; 297 298 slots *= 2; 299 newtokens = zrealloc(tokens,sizeof(sds)*slots); 300 if (newtokens == NULL) { 301 #ifdef SDS_ABORT_ON_OOM 302 sdsOomAbort(); 303 #else 304 goto cleanup; 305 #endif 306 } 307 tokens = newtokens; 308 } 309 /* search the separator */ 310 if ((seplen == 1 && *(s+j) == sep[0]) || (memcmp(s+j,sep,seplen) == 0)) { 311 tokens[elements] = sdsnewlen(s+start,j-start); 312 if (tokens[elements] == NULL) { 313 #ifdef SDS_ABORT_ON_OOM 314 sdsOomAbort(); 315 #else 316 goto cleanup; 317 #endif 318 } 319 elements++; 320 start = j+seplen; 321 j = j+seplen-1; /* skip the separator */ 322 } 323 } 324 /* Add the final element. We are sure there is room in the tokens array. */ 325 tokens[elements] = sdsnewlen(s+start,len-start); 326 if (tokens[elements] == NULL) { 327 #ifdef SDS_ABORT_ON_OOM 328 sdsOomAbort(); 329 #else 330 goto cleanup; 331 #endif 332 } 333 elements++; 334 *count = elements; 335 return tokens; 336 337 #ifndef SDS_ABORT_ON_OOM 338 cleanup: 339 { 340 int i; 341 for (i = 0; i < elements; i++) sdsfree(tokens[i]); 342 zfree(tokens); 343 return NULL; 344 } 345 #endif 346 } 347 348 void sdsfreesplitres(sds *tokens, int count) { 349 if (!tokens) return; 350 while(count--) 351 sdsfree(tokens[count]); 352 zfree(tokens); 353 } 354 355 sds sdsfromlonglong(long long value) { 356 char buf[32], *p; 357 unsigned long long v; 358 359 v = (value < 0) ? -value : value; 360 p = buf+31; /* point to the last character */ 361 do { 362 *p-- = '0'+(v%10); 363 v /= 10; 364 } while(v); 365 if (value < 0) *p-- = '-'; 366 p++; 367 return sdsnewlen(p,32-(p-buf)); 368 } //将long long转成字符串，没啥好说的 369 370 sds sdscatrepr(sds s, char *p, size_t len) { 371 s = sdscatlen(s,"\"",1); 372 while(len--) { 373 switch(*p) { 374 case '\\': 375 case '"': 376 s = sdscatprintf(s,"\\%c",*p); 377 break; 378 case '\n': s = sdscatlen(s,"\\n",2); break; 379 case '\r': s = sdscatlen(s,"\\r",2); break; 380 case '\t': s = sdscatlen(s,"\\t",2); break; 381 case '\a': s = sdscatlen(s,"\\a",2); break; 382 case '\b': s = sdscatlen(s,"\\b",2); break; 383 default: 384 if (isprint(*p)) 385 s = sdscatprintf(s,"%c",*p); 386 else 387 s = sdscatprintf(s,"\\x%02x",(unsigned char)*p); 388 break; 389 } 390 p++; 391 } 392 return sdscatlen(s,"\"",1); 393 } //这个函数将参数p原封不动（做过处理的，是计算机认为合法的）保存在一个sds里，用于协议交换 394 395 /* Helper function for sdssplitargs() that returns non zero if 'c' 396 * is a valid hex digit. */ 397 int is_hex_digit(char c) { 398 return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || 399 (c >= 'A' && c <= 'F'); 400 } 401 402 /* Helper function for sdssplitargs() that converts an hex digit into an 403 * integer from 0 to 15 */ 404 int hex_digit_to_int(char c) { 405 switch(c) { 406 case '0': return 0; 407 case '1': return 1; 408 case '2': return 2; 409 case '3': return 3; 410 case '4': return 4; 411 case '5': return 5; 412 case '6': return 6; 413 case '7': return 7; 414 case '8': return 8; 415 case '9': return 9; 416 case 'a': case 'A': return 10; 417 case 'b': case 'B': return 11; 418 case 'c': case 'C': return 12; 419 case 'd': case 'D': return 13; 420 case 'e': case 'E': return 14; 421 case 'f': case 'F': return 15; 422 default: return 0; 423 } 424 } 425 426 /* Split a line into arguments, where every argument can be in the 427 * following programming-language REPL-alike form: 428 * 429 * foo bar "newline are supported\n" and "\xff\x00otherstuff" 430 * 431 * The number of arguments is stored into *argc, and an array 432 * of sds is returned. The caller should sdsfree() all the returned 433 * strings and finally zfree() the array itself. 434 * 435 * Note that sdscatrepr() is able to convert back a string into 436 * a quoted string in the same format sdssplitargs() is able to parse. 437 */ 438 sds *sdssplitargs(char *line, int *argc) { 439 char *p = line; 440 char *current = NULL; 441 char **vector = NULL; 442 443 *argc = 0; 444 while(1) { 445 /* skip blanks */ 446 while(*p && isspace(*p)) p++; 447 if (*p) { 448 /* get a token */ 449 int inq=0; /* set to 1 if we are in "quotes" */ 450 int insq=0; /* set to 1 if we are in 'single quotes' */ 451 int done=0; 452 453 if (current == NULL) current = sdsempty(); 454 while(!done) { 455 if (inq) { 456 if (*p == '\\' && *(p+1) == 'x' && 457 is_hex_digit(*(p+2)) && 458 is_hex_digit(*(p+3))) 459 { 460 unsigned char byte; 461 462 byte = (hex_digit_to_int(*(p+2))*16)+ 463 hex_digit_to_int(*(p+3)); 464 current = sdscatlen(current,(char*)&byte,1); 465 p += 3; 466 } else if (*p == '\\' && *(p+1)) { 467 char c; 468 469 p++; 470 switch(*p) { 471 case 'n': c = '\n'; break; 472 case 'r': c = '\r'; break; 473 case 't': c = '\t'; break; 474 case 'b': c = '\b'; break; 475 case 'a': c = '\a'; break; 476 default: c = *p; break; 477 } 478 current = sdscatlen(current,&c,1); 479 } else if (*p == '"') { 480 /* closing quote must be followed by a space or 481 * nothing at all. */ 482 if (*(p+1) && !isspace(*(p+1))) goto err; 483 done=1; 484 } else if (!*p) { 485 /* unterminated quotes */ 486 goto err; 487 } else { 488 current = sdscatlen(current,p,1); 489 } 490 } else if (insq) { 491 if (*p == '\\' && *(p+1) == '\'') { 492 p++; 493 current = sdscatlen(current,"'",1); 494 } else if (*p == '\'') { 495 /* closing quote must be followed by a space or 496 * nothing at all. */ 497 if (*(p+1) && !isspace(*(p+1))) goto err; 498 done=1; 499 } else if (!*p) { 500 /* unterminated quotes */ 501 goto err; 502 } else { 503 current = sdscatlen(current,p,1); 504 } 505 } else { 506 switch(*p) { 507 case ' ': 508 case '\n': 509 case '\r': 510 case '\t': 511 case '\0': 512 done=1; 513 break; 514 case '"': 515 inq=1; 516 break; 517 case '\'': 518 insq=1; 519 break; 520 default: 521 current = sdscatlen(current,p,1); 522 break; 523 } 524 } 525 if (*p) p++; 526 } 527 /* add the token to the vector */ 528 vector = zrealloc(vector,((*argc)+1)*sizeof(char*)); 529 vector[*argc] = current; 530 (*argc)++; 531 current = NULL; 532 } else { 533 return vector; 534 } 535 } 536 537 err: 538 while((*argc)--) 539 sdsfree(vector[*argc]); 540 zfree(vector); 541 if (current) sdsfree(current); 542 return NULL; 543 } //解析参数，仔细看肯定能看懂的，但不好加注释。。 544 545 #ifdef SDS_TEST_MAIN 546 #include <stdio.h> 547 #include "testhelp.h" //testhelp是redis自带的一个tiny的做单元测试的框架，下篇日志里介绍 548 549 int main(void) { 550 { 551 sds x = sdsnew("foo"), y; 552 553 test_cond("Create a string and obtain the length", 554 sdslen(x) == 3 && memcmp(x,"foo\0",4) == 0) 555 556 sdsfree(x); 557 x = sdsnewlen("foo",2); 558 test_cond("Create a string with specified length", 559 sdslen(x) == 2 && memcmp(x,"fo\0",3) == 0) 560 561 x = sdscat(x,"bar"); 562 test_cond("Strings concatenation", 563 sdslen(x) == 5 && memcmp(x,"fobar\0",6) == 0); 564 565 x = sdscpy(x,"a"); 566 test_cond("sdscpy() against an originally longer string", 567 sdslen(x) == 1 && memcmp(x,"a\0",2) == 0) 568 569 x = sdscpy(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk"); 570 test_cond("sdscpy() against an originally shorter string", 571 sdslen(x) == 33 && 572 memcmp(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk\0",33) == 0) //^_^疑似笔误，不过测试还是可以通过的 573 574 sdsfree(x); 575 x = sdscatprintf(sdsempty(),"%d",123); 576 test_cond("sdscatprintf() seems working in the base case", 577 sdslen(x) == 3 && memcmp(x,"123\0",4) ==0) 578 579 sdsfree(x); 580 x = sdstrim(sdsnew("xxciaoyyy"),"xy"); 581 test_cond("sdstrim() correctly trims characters", 582 sdslen(x) == 4 && memcmp(x,"ciao\0",5) == 0) 583 584 y = sdsrange(sdsdup(x),1,1); 585 test_cond("sdsrange(...,1,1)", 586 sdslen(y) == 1 && memcmp(y,"i\0",2) == 0) 587 588 sdsfree(y); 589 y = sdsrange(sdsdup(x),1,-1); 590 test_cond("sdsrange(...,1,-1)", 591 sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0) 592 593 sdsfree(y); 594 y = sdsrange(sdsdup(x),-2,-1); 595 test_cond("sdsrange(...,-2,-1)", 596 sdslen(y) == 2 && memcmp(y,"ao\0",3) == 0) 597 598 sdsfree(y); 599 y = sdsrange(sdsdup(x),2,1); 600 test_cond("sdsrange(...,2,1)", 601 sdslen(y) == 0 && memcmp(y,"\0",1) == 0) 602 603 sdsfree(y); 604 y = sdsrange(sdsdup(x),1,100); 605 test_cond("sdsrange(...,1,100)", 606 sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0) 607 608 sdsfree(y); 609 y = sdsrange(sdsdup(x),100,100); 610 test_cond("sdsrange(...,100,100)", 611 sdslen(y) == 0 && memcmp(y,"\0",1) == 0) 612 613 sdsfree(y); 614 sdsfree(x); 615 x = sdsnew("foo"); 616 y = sdsnew("foa"); 617 test_cond("sdscmp(foo,foa)", sdscmp(x,y) > 0) 618 619 sdsfree(y); 620 sdsfree(x); 621 x = sdsnew("bar"); 622 y = sdsnew("bar"); 623 test_cond("sdscmp(bar,bar)", sdscmp(x,y) == 0) 624 625 sdsfree(y); 626 sdsfree(x); 627 x = sdsnew("aar"); 628 y = sdsnew("bar"); 629 test_cond("sdscmp(bar,bar)", sdscmp(x,y) < 0) 630 } 631 test_report() 632 } 633 #endif