Atrinik Server  4.0
string.c
1 /*************************************************************************
2  * Atrinik, a Multiplayer Online Role Playing Game *
3  * *
4  * Copyright (C) 2009-2014 Alex Tokar and Atrinik Development Team *
5  * *
6  * Fork from Crossfire (Multiplayer game for X-windows). *
7  * *
8  * This program is free software; you can redistribute it and/or modify *
9  * it under the terms of the GNU General Public License as published by *
10  * the Free Software Foundation; either version 2 of the License, or *
11  * (at your option) any later version. *
12  * *
13  * This program is distributed in the hope that it will be useful, *
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16  * GNU General Public License for more details. *
17  * *
18  * You should have received a copy of the GNU General Public License *
19  * along with this program; if not, write to the Free Software *
20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
21  * *
22  * The author can be reached at admin@atrinik.org *
23  ************************************************************************/
24 
25 #include <global.h>
26 #include <check.h>
27 #include <checkstd.h>
28 #include <check_proto.h>
29 #include <toolkit/string.h>
30 
31 START_TEST(test_string_replace)
32 {
33  char buf[MAX_BUF], buf2[6];
34 
35  /* Check simple replacement */
36  string_replace("hello world", "world", "Earth", buf, sizeof(buf));
37  ck_assert_str_eq(buf, "hello Earth");
38 
39  /* Try to replace spaces with nothing */
40  string_replace("hello world", " ", "", buf, sizeof(buf));
41  ck_assert_str_eq(buf, "helloworld");
42 
43  /* Make sure nothing is replaced when replacing "hello" with "world" in an
44  * empty string. */
45  string_replace("", "hello", "world", buf, sizeof(buf));
46  ck_assert_str_eq(buf, "");
47 
48  /* Make sure nothing is replaced when replacing "hello" with "world" in a
49  * string that doesn't contain "hello". */
50  string_replace("hi world", "hello", "world", buf, sizeof(buf));
51  ck_assert_str_eq(buf, "hi world");
52 
53  /* Make sure that when both key and replacement are the same, the string
54  * remains the same. */
55  string_replace("hello world", "hello", "hello", buf, sizeof(buf));
56  ck_assert_str_eq(buf, "hello world");
57 
58  /* Make sure that nothing changes when both key and replacement are an
59  * empty string. */
60  string_replace("hello world", "", "", buf, sizeof(buf));
61  ck_assert_str_eq(buf, "hello world");
62 
63  /* Make sure buffer overflow doesn't happen when the buffer is not large
64  * enough. */
65  string_replace("hello world", "world", "Earth", buf2, sizeof(buf2));
66  ck_assert_str_eq(buf2, "hello");
67 
68  /* Make sure buffer overflow doesn't happen when the buffer is not large
69  * enough, and a replacement occurs prior to reaching the buffer limit. */
70  string_replace("hello world", "hello", "", buf2, sizeof(buf2));
71  ck_assert_str_eq(buf2, " worl");
72 }
73 
74 END_TEST
75 
76 START_TEST(test_string_replace_char)
77 {
78  char *cp;
79 
80  /* Attempt to replace "a", "e" and "o" characters with spaces. */
81  cp = estrdup("hello world hello");
82  string_replace_char(cp, "aeo", ' ');
83  ck_assert_str_eq(cp, "h ll w rld h ll ");
84  efree(cp);
85 
86  /* Attempt to replace any character with space. */
87  cp = estrdup("hello world");
88  string_replace_char(cp, NULL, ' ');
89  ck_assert_str_eq(cp, " ");
90  efree(cp);
91 
92  /* Replace newlines and tabs with spaces. */
93  cp = estrdup("\thello\n\t\tworld\n");
94  string_replace_char(cp, "\n\t", ' ');
95  ck_assert_str_eq(cp, " hello world ");
96  efree(cp);
97 
98  /* Replace forward-slashes with a dollar sign. */
99  cp = estrdup("/shattered_islands/world_0112");
100  string_replace_char(cp, "/", '$');
101  ck_assert_str_eq(cp, "$shattered_islands$world_0112");
102  efree(cp);
103 }
104 
105 END_TEST
106 
107 START_TEST(test_string_split)
108 {
109  char *cp, *cps[20], *cps2[2];
110 
111  /* Attempt to split two words separated by spaces. */
112  cp = estrdup("hello world");
113  ck_assert_int_eq(string_split(cp, cps, sizeof(cps) / sizeof(*cps), ' '), 2);
114  ck_assert_str_eq(cps[0], "hello");
115  ck_assert_str_eq(cps[1], "world");
116  ck_assert_ptr_eq(cps[2], NULL);
117  efree(cp);
118 
119  /* Attempt to split several one-character words. */
120  cp = estrdup("q w e r t y");
121  ck_assert_int_eq(string_split(cp, cps, sizeof(cps) / sizeof(*cps), ' '), 6);
122  ck_assert_str_eq(cps[0], "q");
123  ck_assert_str_eq(cps[1], "w");
124  ck_assert_str_eq(cps[2], "e");
125  ck_assert_str_eq(cps[3], "r");
126  ck_assert_str_eq(cps[4], "t");
127  ck_assert_str_eq(cps[5], "y");
128  efree(cp);
129 
130  /* Attempt to split empty string. */
131  cp = estrdup("");
132  ck_assert_int_eq(string_split(cp, cps, sizeof(cps) / sizeof(*cps), ' '), 0);
133  ck_assert_ptr_eq(cps[0], NULL);
134  ck_assert_ptr_eq(cps[1], NULL);
135  efree(cp);
136 
137  /* Attempt to split several one-character words, and the result would not
138  * fit into the array. */
139  cp = estrdup("q w e r t y");
140  ck_assert_int_eq(string_split(cp, cps2, sizeof(cps2) / sizeof(*cps2), ' '),
141  2);
142  ck_assert_str_eq(cps2[0], "q");
143  ck_assert_str_eq(cps2[1], "w e r t y");
144  efree(cp);
145 }
146 
147 END_TEST
148 
149 START_TEST(test_string_replace_unprintable_char)
150 {
151  char *cp;
152 
153  /* Replace tabs with spaces. */
154  cp = estrdup("\thello\tworld");
155  string_replace_unprintable_chars(cp);
156  ck_assert_str_eq(cp, " hello world");
157  efree(cp);
158 
159  /* Replace empty string. */
160  cp = estrdup("");
161  string_replace_unprintable_chars(cp);
162  ck_assert_str_eq(cp, "");
163  efree(cp);
164 
165  /* Replace string that consists of only unprintable characters. */
166  cp = estrdup("\t\n\n\t\t\t\b\b");
167  string_replace_unprintable_chars(cp);
168  ck_assert_str_eq(cp, " ");
169  efree(cp);
170 }
171 
172 END_TEST
173 
174 START_TEST(test_string_format_number_comma)
175 {
176  ck_assert_str_eq(string_format_number_comma(100), "100");
177  ck_assert_str_eq(string_format_number_comma(1000), "1,000");
178  ck_assert_str_eq(string_format_number_comma(123456789), "123,456,789");
179  ck_assert_str_eq(string_format_number_comma(99999999999999999),
180  "99,999,999,999,999,999");
181  ck_assert_str_eq(string_format_number_comma(UINT64_MAX),
182  "18,446,744,073,709,551,615");
183 }
184 
185 END_TEST
186 
187 START_TEST(test_string_toupper)
188 {
189  char *cp;
190 
191  cp = estrdup("hello world");
192  string_toupper(cp);
193  ck_assert_str_eq(cp, "HELLO WORLD");
194  efree(cp);
195 
196  cp = estrdup("Hello");
197  string_toupper(cp);
198  ck_assert_str_eq(cp, "HELLO");
199  efree(cp);
200 
201  cp = estrdup("");
202  string_toupper(cp);
203  ck_assert_str_eq(cp, "");
204  efree(cp);
205 }
206 
207 END_TEST
208 
209 START_TEST(test_string_tolower)
210 {
211  char *cp;
212 
213  cp = estrdup("HELLO WORLD");
214  string_tolower(cp);
215  ck_assert_str_eq(cp, "hello world");
216  efree(cp);
217 
218  cp = estrdup("hELLO");
219  string_tolower(cp);
220  ck_assert_str_eq(cp, "hello");
221  efree(cp);
222 
223  cp = estrdup("");
224  string_tolower(cp);
225  ck_assert_str_eq(cp, "");
226  efree(cp);
227 }
228 
229 END_TEST
230 
231 START_TEST(test_string_whitespace_trim)
232 {
233  char *cp;
234 
235  cp = estrdup(" ");
236  string_whitespace_trim(cp);
237  ck_assert_str_eq(cp, "");
238  efree(cp);
239 
240  cp = estrdup("hello world \t\t");
241  string_whitespace_trim(cp);
242  ck_assert_str_eq(cp, "hello world");
243  efree(cp);
244 
245  cp = estrdup(" hello world");
246  string_whitespace_trim(cp);
247  ck_assert_str_eq(cp, "hello world");
248  efree(cp);
249 
250  cp = estrdup("\t hello world \t ");
251  string_whitespace_trim(cp);
252  ck_assert_str_eq(cp, "hello world");
253  efree(cp);
254 
255  cp = estrdup(" hello world ");
256  string_whitespace_trim(cp);
257  ck_assert_str_eq(cp, "hello world");
258  efree(cp);
259 }
260 
261 END_TEST
262 
263 START_TEST(test_string_whitespace_squeeze)
264 {
265  char *cp;
266 
267  cp = estrdup(" hello world ");
268  string_whitespace_squeeze(cp);
269  ck_assert_str_eq(cp, " hello world ");
270  efree(cp);
271 
272  cp = estrdup(" hello world ");
273  string_whitespace_squeeze(cp);
274  ck_assert_str_eq(cp, " hello world ");
275  efree(cp);
276 
277  cp = estrdup(" hello world ");
278  string_whitespace_squeeze(cp);
279  ck_assert_str_eq(cp, " hello world ");
280  efree(cp);
281 
282  cp = estrdup("hello world ");
283  string_whitespace_squeeze(cp);
284  ck_assert_str_eq(cp, "hello world ");
285  efree(cp);
286 }
287 
288 END_TEST
289 
290 START_TEST(test_string_newline_to_literal)
291 {
292  char *cp;
293 
294  cp = estrdup("hello\\nworld");
295  string_newline_to_literal(cp);
296  ck_assert_str_eq(cp, "hello\nworld");
297  efree(cp);
298 
299  cp = estrdup("\\n\\n\\n");
300  string_newline_to_literal(cp);
301  ck_assert_str_eq(cp, "\n\n\n");
302  efree(cp);
303 
304  cp = estrdup("");
305  string_newline_to_literal(cp);
306  ck_assert_str_eq(cp, "");
307  efree(cp);
308 }
309 
310 END_TEST
311 
312 START_TEST(test_string_get_word)
313 {
314  char *cp, word[MAX_BUF];
315  size_t pos;
316 
317  cp = estrdup("hello world");
318  pos = 0;
319  ck_assert_str_eq(string_get_word(cp, &pos, ' ', word, sizeof(word), 0),
320  "hello");
321  ck_assert_str_eq(string_get_word(cp, &pos, ' ', word, sizeof(word), 0),
322  "world");
323  ck_assert_ptr_eq(string_get_word(cp, &pos, ' ', word, sizeof(word), 0),
324  NULL);
325  efree(cp);
326 
327  cp = estrdup("/teleport 'Player Name'");
328  pos = 0;
329  ck_assert_str_eq(string_get_word(cp, &pos, ' ', word, sizeof(word), 0),
330  "/teleport");
331  ck_assert_str_eq(string_get_word(cp, &pos, ' ', word, sizeof(word), '\''),
332  "Player Name");
333  ck_assert_ptr_eq(string_get_word(cp, &pos, ' ', word, sizeof(word), 0),
334  NULL);
335  efree(cp);
336 
337  cp = estrdup("");
338  pos = 0;
339  ck_assert_ptr_eq(string_get_word(cp, &pos, ' ', word, sizeof(word), 0),
340  NULL);
341  efree(cp);
342 }
343 
344 END_TEST
345 
346 START_TEST(test_string_skip_word)
347 {
348  char *cp;
349  size_t pos;
350 
351  cp = estrdup("hello world");
352  pos = 0;
353  string_skip_word(cp, &pos, 1);
354  ck_assert_str_eq(cp + pos, " world");
355  string_skip_word(cp, &pos, 1);
356  ck_assert_str_eq(cp + pos, "");
357  efree(cp);
358 
359  cp = estrdup("hello world");
360  pos = strlen(cp);
361  string_skip_word(cp, &pos, -1);
362  ck_assert_str_eq(cp + pos, "world");
363  string_skip_word(cp, &pos, -1);
364  ck_assert_str_eq(cp + pos, "hello world");
365  string_skip_word(cp, &pos, 1);
366  ck_assert_str_eq(cp + pos, " world");
367  efree(cp);
368 }
369 
370 END_TEST
371 
372 START_TEST(test_string_isdigit)
373 {
374  ck_assert(string_isdigit("10"));
375  ck_assert(string_isdigit("10000000000000"));
376  ck_assert(string_isdigit("1234567890"));
377  ck_assert(string_isdigit("0"));
378  ck_assert(string_isdigit("1"));
379  ck_assert(!string_isdigit("x"));
380  ck_assert(!string_isdigit("hello world"));
381  ck_assert(!string_isdigit("hell0 w0rld"));
382 }
383 
384 END_TEST
385 
386 START_TEST(test_string_capitalize)
387 {
388  char *cp;
389 
390  cp = estrdup("hello world");
391  string_capitalize(cp);
392  ck_assert_str_eq(cp, "Hello world");
393  efree(cp);
394 
395  cp = estrdup("Hello World");
396  string_capitalize(cp);
397  ck_assert_str_eq(cp, "Hello world");
398  efree(cp);
399 
400  cp = estrdup("HELLO");
401  string_capitalize(cp);
402  ck_assert_str_eq(cp, "Hello");
403  efree(cp);
404 
405  cp = estrdup("MiXeD CaSe");
406  string_capitalize(cp);
407  ck_assert_str_eq(cp, "Mixed case");
408  efree(cp);
409 
410  cp = estrdup("");
411  string_capitalize(cp);
412  ck_assert_str_eq(cp, "");
413  efree(cp);
414 }
415 
416 END_TEST
417 
418 START_TEST(test_string_title)
419 {
420  char *cp;
421 
422  cp = estrdup("hello world");
423  string_title(cp);
424  ck_assert_str_eq(cp, "Hello World");
425  efree(cp);
426 
427  cp = estrdup("Hello World");
428  string_title(cp);
429  ck_assert_str_eq(cp, "Hello World");
430  efree(cp);
431 
432  cp = estrdup("HELLO");
433  string_title(cp);
434  ck_assert_str_eq(cp, "Hello");
435  efree(cp);
436 
437  cp = estrdup(" Hello ");
438  string_title(cp);
439  ck_assert_str_eq(cp, " Hello ");
440  efree(cp);
441 
442  cp = estrdup("Hello ");
443  string_title(cp);
444  ck_assert_str_eq(cp, "Hello ");
445  efree(cp);
446 
447  cp = estrdup("hello ");
448  string_title(cp);
449  ck_assert_str_eq(cp, "Hello ");
450  efree(cp);
451 
452  cp = estrdup("MiXeD CaSe");
453  string_title(cp);
454  ck_assert_str_eq(cp, "Mixed Case");
455  efree(cp);
456 
457  cp = estrdup("");
458  string_title(cp);
459  ck_assert_str_eq(cp, "");
460  efree(cp);
461 
462  cp = estrdup(" ");
463  string_title(cp);
464  ck_assert_str_eq(cp, " ");
465  efree(cp);
466 
467  cp = estrdup(" a");
468  string_title(cp);
469  ck_assert_str_eq(cp, " A");
470  efree(cp);
471 
472  cp = estrdup("fOrMaT thIs aS titLe String");
473  string_title(cp);
474  ck_assert_str_eq(cp, "Format This As Title String");
475  efree(cp);
476 
477  cp = estrdup("fOrMaT,thIs-aS*titLe;String");
478  string_title(cp);
479  ck_assert_str_eq(cp, "Format,This-As*Title;String");
480  efree(cp);
481 }
482 
483 END_TEST
484 
485 START_TEST(test_string_startswith)
486 {
487  ck_assert(string_startswith("hello world", "hello"));
488  ck_assert(!string_startswith("", ""));
489  ck_assert(!string_startswith("hello world", ""));
490  ck_assert(!string_startswith("", "hello"));
491  ck_assert(!string_startswith("hello world", "hi"));
492  ck_assert(string_startswith("hello world", "h"));
493  ck_assert(!string_startswith("hello", "hello world"));
494 }
495 
496 END_TEST
497 
498 START_TEST(test_string_endswith)
499 {
500  ck_assert(string_endswith("hello world", "world"));
501  ck_assert(string_endswith("hello world", "d"));
502  ck_assert(!string_endswith("", ""));
503  ck_assert(!string_endswith("", "world"));
504  ck_assert(!string_endswith("hello world", ""));
505  ck_assert(!string_endswith("world", "hello world"));
506  ck_assert(string_endswith("hello world", "hello world"));
507 }
508 
509 END_TEST
510 
511 START_TEST(test_string_sub)
512 {
513  char *cp;
514 
515  cp = string_sub("hello world", 1, -1);
516  ck_assert_str_eq(cp, "ello worl");
517  efree(cp);
518 
519  cp = string_sub("hello world", 0, 0);
520  ck_assert_str_eq(cp, "hello world");
521  efree(cp);
522 
523  cp = string_sub("hello world", 1, 0);
524  ck_assert_str_eq(cp, "ello world");
525  efree(cp);
526 
527  cp = string_sub("hello world", 0, -1);
528  ck_assert_str_eq(cp, "hello worl");
529  efree(cp);
530 
531  cp = string_sub("hello world", -1, -1);
532  ck_assert_str_eq(cp, "l");
533  efree(cp);
534 
535  cp = string_sub("hello world", 4, 0);
536  ck_assert_str_eq(cp, "o world");
537  efree(cp);
538 
539  cp = string_sub("hello world", -5, 0);
540  ck_assert_str_eq(cp, "world");
541  efree(cp);
542 
543  cp = string_sub("hello world", 20, 0);
544  ck_assert_str_eq(cp, "");
545  efree(cp);
546 
547  cp = string_sub("hello world", -20, -20);
548  ck_assert_str_eq(cp, "");
549  efree(cp);
550 
551  cp = string_sub("hello world", 0, -20);
552  ck_assert_str_eq(cp, "");
553  efree(cp);
554 
555  cp = string_sub("hello world", -20, 0);
556  ck_assert_str_eq(cp, "hello world");
557  efree(cp);
558 
559  cp = string_sub("hello world", -500, 2);
560  ck_assert_str_eq(cp, "he");
561  efree(cp);
562 
563  cp = string_sub("hello world", 0, -500);
564  ck_assert_str_eq(cp, "");
565  efree(cp);
566 
567  cp = string_sub("hello world", 5, -500);
568  ck_assert_str_eq(cp, "");
569  efree(cp);
570 }
571 
572 END_TEST
573 
574 START_TEST(test_string_isempty)
575 {
576  ck_assert(string_isempty(NULL));
577  ck_assert(string_isempty(""));
578  ck_assert(!string_isempty("1"));
579  ck_assert(!string_isempty("hello world"));
580  ck_assert(!string_isempty(" "));
581  ck_assert(!string_isempty(" "));
582 }
583 
584 END_TEST
585 
586 START_TEST(test_string_iswhite)
587 {
588  ck_assert(string_iswhite(NULL));
589  ck_assert(string_iswhite(" "));
590  ck_assert(string_iswhite(" "));
591  ck_assert(string_iswhite(""));
592  ck_assert(string_iswhite("\n\n "));
593  ck_assert(string_iswhite("\n \n"));
594  ck_assert(string_iswhite("\t\t\t"));
595  ck_assert(!string_iswhite("hello world"));
596  ck_assert(!string_iswhite("h i"));
597  ck_assert(!string_iswhite("\thi\t"));
598 }
599 
600 END_TEST
601 
602 START_TEST(test_char_contains)
603 {
604  ck_assert(char_contains('q', "qwerty"));
605  ck_assert(char_contains('\n', "hello\nworld"));
606  ck_assert(!char_contains('\n', "\t"));
607  ck_assert(!char_contains('Q', "qwerty"));
608  ck_assert(!char_contains('a', "qwerty"));
609  ck_assert(!char_contains('\t', "qwerty"));
610  ck_assert(!char_contains('\n', "qwerty"));
611 }
612 
613 END_TEST
614 
615 START_TEST(test_string_contains)
616 {
617  ck_assert(string_contains("hello world", "qwerty"));
618  ck_assert(string_contains("hello world", " "));
619  ck_assert(!string_contains("hello world", "\t"));
620 }
621 
622 END_TEST
623 
624 START_TEST(test_string_contains_other)
625 {
626  ck_assert(string_contains_other("Qwerty", "qwerty"));
627  ck_assert(!string_contains_other("qwerty", "qwerty"));
628  ck_assert(string_contains_other("hello world", "qwerty"));
629  ck_assert(!string_contains_other(" \t\t\n", "\t\n "));
630 }
631 
632 END_TEST
633 
634 START_TEST(test_string_create_char_range)
635 {
636  char *cp;
637 
638  cp = string_create_char_range('a', 'z');
639  ck_assert_str_eq(cp, "abcdefghijklmnopqrstuvwxyz");
640  efree(cp);
641 
642  cp = string_create_char_range('A', 'Z');
643  ck_assert_str_eq(cp, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
644  efree(cp);
645 
646  cp = string_create_char_range('0', '9');
647  ck_assert_str_eq(cp, "0123456789");
648  efree(cp);
649 }
650 
651 END_TEST
652 
653 START_TEST(test_string_join)
654 {
655  char *cp;
656 
657  cp = string_join(NULL, "hello", "world", NULL);
658  ck_assert_str_eq(cp, "helloworld");
659  efree(cp);
660 
661  cp = string_join(" ", "hello", "world", NULL);
662  ck_assert_str_eq(cp, "hello world");
663  efree(cp);
664 
665  cp = string_join(", ", "hello", "world", NULL);
666  ck_assert_str_eq(cp, "hello, world");
667  efree(cp);
668 
669  cp = string_join(NULL, "world", NULL);
670  ck_assert_str_eq(cp, "world");
671  efree(cp);
672 
673  cp = string_join("\n", "hello", NULL);
674  ck_assert_str_eq(cp, "hello");
675  efree(cp);
676 
677  cp = string_join("\n", "hello", "world", "hi", NULL);
678  ck_assert_str_eq(cp, "hello\nworld\nhi");
679  efree(cp);
680 }
681 
682 END_TEST
683 
684 START_TEST(test_string_join_array)
685 {
686  char *cp;
687  const char *cps[] = {"hello", "world"};
688  const char *cps2[] = {"hello"};
689  const char *cps3[] = {"hello", "world", "hi"};
690  const char *cps4[] = {"hello", NULL, "world"};
691 
692  cp = string_join_array(NULL, cps, arraysize(cps));
693  ck_assert_str_eq(cp, "helloworld");
694  efree(cp);
695 
696  cp = string_join_array(" ", cps, arraysize(cps));
697  ck_assert_str_eq(cp, "hello world");
698  efree(cp);
699 
700  cp = string_join_array(", ", cps, arraysize(cps));
701  ck_assert_str_eq(cp, "hello, world");
702  efree(cp);
703 
704  cp = string_join_array(NULL, cps2, arraysize(cps2));
705  ck_assert_str_eq(cp, "hello");
706  efree(cp);
707 
708  cp = string_join_array("\n", cps2, arraysize(cps2));
709  ck_assert_str_eq(cp, "hello");
710  efree(cp);
711 
712  cp = string_join_array("\n", cps3, arraysize(cps3));
713  ck_assert_str_eq(cp, "hello\nworld\nhi");
714  efree(cp);
715 
716  cp = string_join_array("\n", cps4, arraysize(cps4));
717  ck_assert_str_eq(cp, "hello\nworld");
718  efree(cp);
719 }
720 
721 END_TEST
722 
723 START_TEST(test_string_repeat)
724 {
725  char *cp;
726 
727  cp = string_repeat("hello", 5);
728  ck_assert_str_eq(cp, "hellohellohellohellohello");
729  efree(cp);
730 
731  cp = string_repeat("hello", 1);
732  ck_assert_str_eq(cp, "hello");
733  efree(cp);
734 
735  cp = string_repeat("hello", 0);
736  ck_assert_str_eq(cp, "");
737  efree(cp);
738 }
739 
740 END_TEST
741 
742 START_TEST(test_snprintfcat)
743 {
744  char buf[MAX_BUF], buf2[8];
745 
746  snprintf(buf, sizeof(buf), "%s", "hello");
747  ck_assert_int_eq(snprintfcat(buf, sizeof(buf), " %s", "world"), 11);
748  ck_assert_str_eq(buf, "hello world");
749 
750  snprintf(buf, sizeof(buf), "%s %d", "hello", 10);
751  ck_assert_int_eq(snprintfcat(buf, sizeof(buf), " %s", "world"), 14);
752  ck_assert_str_eq(buf, "hello 10 world");
753 
754  snprintf(buf, sizeof(buf), "%s", "hello");
755  ck_assert_int_eq(snprintfcat(buf, sizeof(buf), "%s", ""), 5);
756  ck_assert_str_eq(buf, "hello");
757 
758  snprintf(buf2, sizeof(buf2), "%s", "hello");
759  ck_assert_int_eq(snprintfcat(buf2, sizeof(buf2), " %s", "world"), 11);
760  ck_assert_str_eq(buf2, "hello w");
761 
762  snprintf(buf2, sizeof(buf2), "%s", "testing");
763  ck_assert_int_eq(snprintfcat(buf2, sizeof(buf2), "%s", "world"), 12);
764  ck_assert_str_eq(buf2, "testing");
765 
766  snprintf(buf2, sizeof(buf2), "%s", "testing");
767  ck_assert_int_eq(snprintfcat(buf2, sizeof(buf2), " %s", "world"), 13);
768  ck_assert_str_eq(buf2, "testing");
769 }
770 
771 END_TEST
772 
773 START_TEST(test_string_tohex)
774 {
775  char buf[MAX_BUF], buf2[5], buf3[6], buf4[7];
776  unsigned char cp[] = {0xff, 0x00, 0x03}, cp2[1] = {0x00}, cp3[] = {0x03};
777 
778  ck_assert_uint_eq(string_tohex((const unsigned char *) "hello world",
779  strlen("hello world"), buf, sizeof(buf), false),
780  strlen("68656C6C6F20776F726C64"));
781  ck_assert_str_eq(buf, "68656C6C6F20776F726C64");
782 
783  ck_assert_uint_eq(string_tohex(cp, arraysize(cp), buf, sizeof(buf), false),
784  6);
785  ck_assert_str_eq(buf, "FF0003");
786 
787  ck_assert_uint_eq(string_tohex(cp, arraysize(cp), buf, sizeof(buf), true),
788  8);
789  ck_assert_str_eq(buf, "FF:00:03");
790 
791  ck_assert_uint_eq(string_tohex(cp2, 0, buf, sizeof(buf), false), 0);
792  ck_assert_str_eq(buf, "");
793 
794  ck_assert_uint_eq(string_tohex(cp2, 0, buf, sizeof(buf), true), 0);
795  ck_assert_str_eq(buf, "");
796 
797  ck_assert_uint_eq(string_tohex(cp3, arraysize(cp3), buf, sizeof(buf), true),
798  2);
799  ck_assert_str_eq(buf, "03");
800 
801  /* Test buffer overflows. */
802  ck_assert_int_eq(string_tohex(cp, arraysize(cp), buf2, sizeof(buf2), false),
803  4);
804  ck_assert_str_eq(buf2, "FF00");
805 
806  ck_assert_uint_eq(string_tohex(cp, arraysize(cp), buf3, sizeof(buf3),
807  false), 4);
808  ck_assert_str_eq(buf3, "FF00");
809 
810  ck_assert_uint_eq(string_tohex(cp, arraysize(cp), buf4, sizeof(buf4),
811  false), 6);
812  ck_assert_str_eq(buf4, "FF0003");
813 }
814 
815 END_TEST
816 
817 START_TEST(test_string_fromhex)
818 {
819  unsigned char buf[MAX_BUF], buf2[2];
820 
821  ck_assert_uint_eq(string_fromhex("FF03", strlen("FF03"), buf,
822  arraysize(buf)), 2);
823  ck_assert(buf[0] == 0xFF && buf[1] == 0x03);
824 
825  ck_assert_uint_eq(string_fromhex("FF 03", strlen("FF 03"), buf,
826  arraysize(buf)), 2);
827  ck_assert(buf[0] == 0xFF && buf[1] == 0x03);
828 
829  ck_assert_uint_eq(string_fromhex("FF3", strlen("FF3"), buf,
830  arraysize(buf)), 1);
831  ck_assert(buf[0] == 0xFF);
832 
833  ck_assert_uint_eq(string_fromhex("FF0304", strlen("FF0304"), buf2,
834  arraysize(buf2)), 2);
835  ck_assert(buf[0] == 0xFF && buf[1] == 0x03);
836 }
837 
838 END_TEST
839 
840 START_TEST(test_string_skip_whitespace)
841 {
842  const char *str = "";
843  string_skip_whitespace(str);
844  ck_assert_str_eq(str, "");
845 
846  str = " ";
847  string_skip_whitespace(str);
848  ck_assert_str_eq(str, "");
849 
850  str = "hello world";
851  string_skip_whitespace(str);
852  ck_assert_str_eq(str, "hello world");
853 
854  str = " hello world";
855  string_skip_whitespace(str);
856  ck_assert_str_eq(str, "hello world");
857 
858  str = " hello world ";
859  string_skip_whitespace(str);
860  ck_assert_str_eq(str, "hello world ");
861 
862  str = "";
863  string_skip_whitespace(str);
864  ck_assert_str_eq(str, "");
865 
866  str = "\t\thello world";
867  string_skip_whitespace(str);
868  ck_assert_str_eq(str, "hello world");
869 
870  str = "\t\nhello world";
871  string_skip_whitespace(str);
872  ck_assert_str_eq(str, "hello world");
873 }
874 
875 END_TEST
876 
877 START_TEST(test_string_last)
878 {
879  ck_assert_ptr_eq(string_last("hello", ""), NULL);
880  ck_assert_ptr_eq(string_last("a", "hello"), NULL);
881  ck_assert_str_eq(string_last("hello", "hello"), "hello");
882  ck_assert_str_eq(string_last("hello world", "o"), "orld");
883  ck_assert_str_eq(string_last("hello world", "e"), "ello world");
884 
885  const char *str = "aaaaa";
886  ck_assert_str_eq(string_last(str, "aaa"), "aaa");
887  ck_assert_ptr_eq(string_last(str, "aaa"), str + 2);
888  ck_assert_str_eq(string_last(str, "a"), "a");
889  ck_assert_ptr_eq(string_last(str, "a"), str + 4);
890 }
891 END_TEST
892 
893 static Suite *suite(void)
894 {
895  Suite *s = suite_create("string");
896  TCase *tc_core = tcase_create("Core");
897 
898  tcase_add_unchecked_fixture(tc_core, check_setup, check_teardown);
899  tcase_add_checked_fixture(tc_core, check_test_setup, check_test_teardown);
900 
901  suite_add_tcase(s, tc_core);
902  tcase_add_test(tc_core, test_string_replace);
903  tcase_add_test(tc_core, test_string_replace_char);
904  tcase_add_test(tc_core, test_string_split);
905  tcase_add_test(tc_core, test_string_replace_unprintable_char);
906  tcase_add_test(tc_core, test_string_format_number_comma);
907  tcase_add_test(tc_core, test_string_toupper);
908  tcase_add_test(tc_core, test_string_tolower);
909  tcase_add_test(tc_core, test_string_whitespace_trim);
910  tcase_add_test(tc_core, test_string_whitespace_squeeze);
911  tcase_add_test(tc_core, test_string_newline_to_literal);
912  tcase_add_test(tc_core, test_string_get_word);
913  tcase_add_test(tc_core, test_string_skip_word);
914  tcase_add_test(tc_core, test_string_isdigit);
915  tcase_add_test(tc_core, test_string_capitalize);
916  tcase_add_test(tc_core, test_string_title);
917  tcase_add_test(tc_core, test_string_startswith);
918  tcase_add_test(tc_core, test_string_endswith);
919  tcase_add_test(tc_core, test_string_sub);
920  tcase_add_test(tc_core, test_string_isempty);
921  tcase_add_test(tc_core, test_string_iswhite);
922  tcase_add_test(tc_core, test_char_contains);
923  tcase_add_test(tc_core, test_string_contains);
924  tcase_add_test(tc_core, test_string_contains_other);
925  tcase_add_test(tc_core, test_string_create_char_range);
926  tcase_add_test(tc_core, test_string_join);
927  tcase_add_test(tc_core, test_string_join_array);
928  tcase_add_test(tc_core, test_string_repeat);
929  tcase_add_test(tc_core, test_snprintfcat);
930  tcase_add_test(tc_core, test_string_tohex);
931  tcase_add_test(tc_core, test_string_fromhex);
932  tcase_add_test(tc_core, test_string_skip_whitespace);
933  tcase_add_test(tc_core, test_string_last);
934 
935  return s;
936 }
937 
938 void check_server_string(void)
939 {
940  check_run_suite(suite(), __FILE__);
941 }