sorcery/res_pjsip: Refactor for realtime performance
[asterisk/asterisk.git] / tests / test_strings.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2010, Digium, Inc.
5  *
6  * Mark Michelson <mmichelson@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  * \brief Dynamic string tests
22  *
23  * \author Mark Michelson <mmichelson@digium.com>
24  *
25  * This module will run some dyanmic string tests.
26  *
27  * \ingroup tests
28  */
29
30 /*** MODULEINFO
31         <depend>TEST_FRAMEWORK</depend>
32         <support_level>core</support_level>
33  ***/
34
35 #include "asterisk.h"
36
37 ASTERISK_REGISTER_FILE()
38
39 #include "asterisk/test.h"
40 #include "asterisk/utils.h"
41 #include "asterisk/strings.h"
42 #include "asterisk/module.h"
43
44 AST_TEST_DEFINE(str_test)
45 {
46         struct ast_str *stack_str;
47         struct ast_str *heap_str;
48         const char short_string1[] = "apple";
49         const char short_string2[] = "banana";
50         char short_string_cat[30];
51         const char long_string1[] = "applebananapeachmangocherrypeargrapeplumlimetangerinepomegranategravel";
52         const char long_string2[] = "passionuglinectarinepineapplekiwilemonpaintthinner";
53         char long_string_cat[200];
54         char string_limit_cat[11];
55         const int string_limit = 5;
56         int current_size;
57         enum ast_test_result_state res = AST_TEST_PASS;
58
59         switch (cmd) {
60         case TEST_INIT:
61                 info->name = "str_test";
62                 info->category = "/main/strings/";
63                 info->summary = "Test dynamic string operations";
64                 info->description = "Test setting and appending stack and heap-allocated strings";
65                 return AST_TEST_NOT_RUN;
66         case TEST_EXECUTE:
67                 break;
68         }
69         snprintf(short_string_cat, sizeof(short_string_cat), "%s%s", short_string1, short_string2);
70         snprintf(long_string_cat, sizeof(long_string_cat), "%s%s", long_string1, long_string2);
71         snprintf(string_limit_cat, string_limit, "%s", long_string1);
72         strncat(string_limit_cat, long_string2, string_limit);
73
74         if (!(stack_str = ast_str_alloca(15))) {
75                 ast_test_status_update(test, "Failed to allocate an ast_str on the stack\n");
76                 return AST_TEST_FAIL;
77         }
78
79         if (!(heap_str = ast_str_create(15))) {
80                 ast_test_status_update(test, "Failed to allocate an ast_str on the heap\n");
81         }
82
83         /* Stack string tests:
84          * Part 1: Basic tests
85          * a. set a small string
86          * b. append a small string
87          * c. clear a string
88          * Part 2: Advanced tests
89          * a. Set a string that is larger than our allocation
90          * b. Append a string that is larger than our allocation
91          */
92
93         /* Part 1a */
94         if (ast_str_set(&stack_str, 0, "%s", short_string1) < 0) {
95                 ast_test_status_update(test, "Error setting stack string\n");
96                 res = AST_TEST_FAIL;
97                 goto cleanup;
98         }
99         if (strcmp(ast_str_buffer(stack_str), short_string1)) {
100                 ast_test_status_update(test, "ast_str_set failed for stack string. Expected '%s' but"
101                                 "instead got %s\n", short_string1, ast_str_buffer(stack_str));
102                 res = AST_TEST_FAIL;
103                 goto cleanup;
104         }
105         /* Part 1b */
106         if (ast_str_append(&stack_str, 0, "%s", short_string2) < 0) {
107                 ast_test_status_update(test, "Error appending to stack string\n");
108                 res = AST_TEST_FAIL;
109                 goto cleanup;
110         }
111         if (strcmp(ast_str_buffer(stack_str), short_string_cat)) {
112                 ast_test_status_update(test, "ast_str_set failed for stack string. Expected '%s'"
113                                 "but instead got %s\n", short_string_cat, ast_str_buffer(stack_str));
114                 res = AST_TEST_FAIL;
115                 goto cleanup;
116         }
117         /* Part 1c */
118         ast_str_reset(stack_str);
119         if (ast_str_strlen(stack_str) != 0) {
120                 ast_test_status_update(test, "ast_str_reset resulted in non-zero length for stack_str\n");
121                 res = AST_TEST_FAIL;
122                 goto cleanup;
123         }
124
125         /* Part 2a */
126         if (ast_str_set(&stack_str, -1, "%s", long_string1) < 0) {
127                 ast_test_status_update(test, "Error setting stack string with long input\n");
128                 res = AST_TEST_FAIL;
129                 goto cleanup;
130         }
131         if (strncmp(ast_str_buffer(stack_str), long_string1, ast_str_strlen(stack_str))) {
132                 ast_test_status_update(test, "Stack string not set to what is expected.\n");
133                 res = AST_TEST_FAIL;
134                 goto cleanup;
135         }
136         /* Part 2b */
137         if (ast_str_append(&stack_str, -1, "%s", long_string2) < 0) {
138                 ast_test_status_update(test, "Error appending long string to full stack string buffer\n");
139                 res = AST_TEST_FAIL;
140                 goto cleanup;
141         }
142         if (strncmp(ast_str_buffer(stack_str), long_string_cat, ast_str_strlen(stack_str))) {
143                 ast_test_status_update(test, "Stack string not set to what is expected.\n");
144                 res = AST_TEST_FAIL;
145                 goto cleanup;
146         }
147
148         /* Heap string tests
149          *
150          * All stack string tests from part 1.
151          * All stack string tests 2a and 2b.
152          * Tests 2a and 2b from stack string tests, passing 0 as max_len
153          * instead of -1. This allows for the buffer to grow.
154          */
155         /* Part 1a */
156         if (ast_str_set(&heap_str, 0, "%s", short_string1) < 0) {
157                 ast_test_status_update(test, "Error setting heap string\n");
158                 res = AST_TEST_FAIL;
159                 goto cleanup;
160         }
161         if (strcmp(ast_str_buffer(heap_str), short_string1)) {
162                 ast_test_status_update(test, "ast_str_set failed for heap string. Expected '%s' but"
163                                 "instead got %s\n", short_string1, ast_str_buffer(heap_str));
164                 res = AST_TEST_FAIL;
165                 goto cleanup;
166         }
167         /* Part 1b */
168         if (ast_str_append(&heap_str, 0, "%s", short_string2) < 0) {
169                 ast_test_status_update(test, "Error appending to heap string\n");
170                 res = AST_TEST_FAIL;
171                 goto cleanup;
172         }
173         if (strcmp(ast_str_buffer(heap_str), short_string_cat)) {
174                 ast_test_status_update(test, "ast_str_set failed for stack string. Expected '%s'"
175                                 "but instead got %s\n", short_string_cat, ast_str_buffer(stack_str));
176                 res = AST_TEST_FAIL;
177                 goto cleanup;
178         }
179         /* Part 1c */
180         ast_str_reset(heap_str);
181         if (ast_str_strlen(heap_str) != 0) {
182                 ast_test_status_update(test, "ast_str_reset resulted in non-zero length for stack_str\n");
183                 res = AST_TEST_FAIL;
184                 goto cleanup;
185         }
186         /* Part 2a with -1 arg */
187         current_size = ast_str_size(heap_str);
188         if (ast_str_set(&heap_str, -1, "%s", long_string1) < 0) {
189                 ast_test_status_update(test, "Error setting heap string with long input\n");
190                 res = AST_TEST_FAIL;
191                 goto cleanup;
192         }
193         if (current_size != ast_str_size(heap_str)) {
194                 ast_test_status_update(test, "Heap string changed size during ast_str_set when it was"
195                                 "instructed not to. Was %d and now is %d\n", current_size, (int) ast_str_size(heap_str));
196                 res = AST_TEST_FAIL;
197                 goto cleanup;
198         }
199         if (strncmp(ast_str_buffer(heap_str), long_string1, ast_str_strlen(heap_str))) {
200                 ast_test_status_update(test, "Heap string not set to what is expected.\n");
201                 res = AST_TEST_FAIL;
202                 goto cleanup;
203         }
204         /* Part 2b with -1 arg */
205         current_size = ast_str_size(heap_str);
206         if (ast_str_append(&heap_str, -1, "%s", long_string2) < 0) {
207                 ast_test_status_update(test, "Error appending long string to full heap string buffer\n");
208                 res = AST_TEST_FAIL;
209                 goto cleanup;
210         }
211         if (current_size != ast_str_size(heap_str)) {
212                 ast_test_status_update(test, "Heap string changed size during ast_str_append when it was"
213                                 "instructed not to. Was %d and now is %d\n", current_size, (int) ast_str_size(heap_str));
214                 res = AST_TEST_FAIL;
215                 goto cleanup;
216         }
217         if (strncmp(ast_str_buffer(heap_str), long_string_cat, ast_str_strlen(heap_str))) {
218                 ast_test_status_update(test, "Heap string not set to what is expected.\n");
219                 res = AST_TEST_FAIL;
220                 goto cleanup;
221         }
222         /* reset string before continuing */
223         ast_str_reset(heap_str);
224         /* Part 2a with 0 arg */
225         if (ast_str_set(&heap_str, 0, "%s", long_string1) < 0) {
226                 ast_test_status_update(test, "Error setting heap string with long input\n");
227                 res = AST_TEST_FAIL;
228                 goto cleanup;
229         }
230         if (strcmp(ast_str_buffer(heap_str), long_string1)) {
231                 ast_test_status_update(test, "Heap string does not contain what was expected. Expected %s"
232                                 "but have %s instead\n", long_string1, ast_str_buffer(heap_str));
233                 res = AST_TEST_FAIL;
234                 goto cleanup;
235         }
236         /* Part 2b with 0 arg */
237         if (ast_str_append(&heap_str, 0, "%s", long_string2) < 0) {
238                 ast_test_status_update(test, "Error setting heap string with long input\n");
239                 res = AST_TEST_FAIL;
240                 goto cleanup;
241         }
242         if (strcmp(ast_str_buffer(heap_str), long_string_cat)) {
243                 ast_test_status_update(test, "Heap string does not contain what was expected. Expected %s"
244                                 "but have %s instead\n", long_string_cat, ast_str_buffer(heap_str));
245                 res = AST_TEST_FAIL;
246                 goto cleanup;
247         }
248
249 cleanup:
250         ast_free(heap_str);
251         return res;
252 }
253
254 AST_TEST_DEFINE(begins_with_test)
255 {
256         switch (cmd) {
257         case TEST_INIT:
258                 info->name = "begins_with";
259                 info->category = "/main/strings/";
260                 info->summary = "Test ast_begins_with";
261                 info->description = "Test ast_begins_with";
262                 return AST_TEST_NOT_RUN;
263         case TEST_EXECUTE:
264                 break;
265         }
266
267         // prefixes
268         ast_test_validate(test, 1 == ast_begins_with("foobar", "foobar"));
269         ast_test_validate(test, 1 == ast_begins_with("foobar", "foo"));
270         ast_test_validate(test, 1 == ast_begins_with("foobar", ""));
271         ast_test_validate(test, 1 == ast_begins_with("", ""));
272
273         // not prefixes
274         ast_test_validate(test, 0 == ast_begins_with("foobar", "bang"));
275         ast_test_validate(test, 0 == ast_begins_with("foobar", "foobat"));
276         ast_test_validate(test, 0 == ast_begins_with("boo", "boom"));
277         ast_test_validate(test, 0 == ast_begins_with("", "blitz"));
278
279         // nothing failed; we're all good!
280         return AST_TEST_PASS;
281 }
282
283 AST_TEST_DEFINE(ends_with_test)
284 {
285         switch (cmd) {
286         case TEST_INIT:
287                 info->name = "ends_with";
288                 info->category = "/main/strings/";
289                 info->summary = "Test ast_ends_with";
290                 info->description = "Test ast_ends_with";
291                 return AST_TEST_NOT_RUN;
292         case TEST_EXECUTE:
293                 break;
294         }
295
296         // prefixes
297         ast_test_validate(test, 1 == ast_ends_with("foobar", "foobar"));
298         ast_test_validate(test, 1 == ast_ends_with("foobar", "bar"));
299         ast_test_validate(test, 1 == ast_ends_with("foobar", ""));
300         ast_test_validate(test, 1 == ast_ends_with("", ""));
301
302         // not suffixes
303         ast_test_validate(test, 0 == ast_ends_with("bar", "bbar"));
304         ast_test_validate(test, 0 == ast_ends_with("foobar", "bang"));
305         ast_test_validate(test, 0 == ast_ends_with("foobar", "foobat"));
306         ast_test_validate(test, 0 == ast_ends_with("boo", "boom"));
307         ast_test_validate(test, 0 == ast_ends_with("", "blitz"));
308
309         // nothing failed; we're all good!
310         return AST_TEST_PASS;
311 }
312
313 AST_TEST_DEFINE(strsep_test)
314 {
315         char *test1, *test2, *test3;
316
317         switch (cmd) {
318         case TEST_INIT:
319                 info->name = "strsep";
320                 info->category = "/main/strings/";
321                 info->summary = "Test ast_strsep";
322                 info->description = "Test ast_strsep";
323                 return AST_TEST_NOT_RUN;
324         case TEST_EXECUTE:
325                 break;
326         }
327
328         test1 = ast_strdupa("ghi=jkl,mno='pqr,stu',abc=def, vwx = yz1 ,  vwx = yz1 ,  '"
329                 " vwx = yz1 ' ,  ' vwx , yz1 ',v\"w\"x, '\"x,v\",\"x\"' , \" i\\'m a test\""
330                 ", \" i\\'m a, test\", \" i\\'m a, test\", e\\,nd, end\\");
331
332         test2 = ast_strsep(&test1, ',', 0);
333         ast_test_validate(test, 0 == strcmp("ghi=jkl", test2));
334
335         test3 = ast_strsep(&test2, '=', 0);
336         ast_test_validate(test, 0 == strcmp("ghi", test3));
337
338         test3 = ast_strsep(&test2, '=', 0);
339         ast_test_validate(test, 0 == strcmp("jkl", test3));
340
341         test2 = ast_strsep(&test1, ',', 0);
342         ast_test_validate(test, 0 == strcmp("mno='pqr,stu'", test2));
343
344         test3 = ast_strsep(&test2, '=', 0);
345         ast_test_validate(test, 0 == strcmp("mno", test3));
346
347         test3 = ast_strsep(&test2, '=', 0);
348         ast_test_validate(test, 0 == strcmp("'pqr,stu'", test3));
349
350         test2 = ast_strsep(&test1, ',', 0);
351         ast_test_validate(test, 0 == strcmp("abc=def", test2));
352
353         test2 = ast_strsep(&test1, ',', 0);
354         ast_test_validate(test, 0 == strcmp(" vwx = yz1 ", test2));
355
356         test2 = ast_strsep(&test1, ',', AST_STRSEP_TRIM);
357         ast_test_validate(test, 0 == strcmp("vwx = yz1", test2));
358
359         test2 = ast_strsep(&test1, ',', AST_STRSEP_STRIP);
360         ast_test_validate(test, 0 == strcmp(" vwx = yz1 ", test2));
361
362         test2 = ast_strsep(&test1, ',', AST_STRSEP_STRIP | AST_STRSEP_TRIM);
363         ast_test_validate(test, 0 == strcmp("vwx , yz1", test2));
364
365         test2 = ast_strsep(&test1, ',', AST_STRSEP_STRIP | AST_STRSEP_TRIM);
366         ast_test_validate(test, 0 == strcmp("v\"w\"x", test2));
367
368         test2 = ast_strsep(&test1, ',', AST_STRSEP_TRIM);
369         ast_test_validate(test, 0 == strcmp("'\"x,v\",\"x\"'", test2));
370
371         test2 = ast_strsep(&test1, ',', AST_STRSEP_TRIM);
372         ast_test_validate(test, 0 == strcmp("\" i\\'m a test\"", test2));
373
374         test2 = ast_strsep(&test1, ',', AST_STRSEP_TRIM | AST_STRSEP_UNESCAPE);
375         ast_test_validate(test, 0 == strcmp("\" i'm a, test\"", test2));
376
377         test2 = ast_strsep(&test1, ',', AST_STRSEP_ALL);
378         ast_test_validate(test, 0 == strcmp("i'm a, test", test2));
379
380         test2 = ast_strsep(&test1, ',', AST_STRSEP_TRIM | AST_STRSEP_UNESCAPE);
381         ast_test_validate(test, 0 == strcmp("e,nd", test2));
382
383         test2 = ast_strsep(&test1, ',', AST_STRSEP_TRIM | AST_STRSEP_UNESCAPE);
384         ast_test_validate(test, 0 == strcmp("end", test2));
385
386         // nothing failed; we're all good!
387         return AST_TEST_PASS;
388 }
389
390 static int test_semi(char *string1, char *string2, int test_len)
391 {
392         char *test2 = NULL;
393
394         if (test_len > 0) {
395                 test2 = ast_alloca(test_len);
396                 *test2 = '\0';
397         } else if (test_len == 0) {
398                 test2 = "";
399         }
400         ast_escape_semicolons(string1, test2, test_len);
401         if (test2 != NULL && strcmp(string2, test2) == 0) {
402                 return 1;
403         } else {
404                 return 0;
405         }
406 }
407
408 AST_TEST_DEFINE(escape_semicolons_test)
409 {
410         switch (cmd) {
411         case TEST_INIT:
412                 info->name = "escape_semicolons";
413                 info->category = "/main/strings/";
414                 info->summary = "Test ast_escape_semicolons";
415                 info->description = "Test ast_escape_semicolons";
416                 return AST_TEST_NOT_RUN;
417         case TEST_EXECUTE:
418                 break;
419         }
420
421
422         ast_test_validate(test, test_semi("this is a ;test", "this is a \\;test", 18));
423         ast_test_validate(test, test_semi(";", "\\;", 3));
424
425         /* The following tests should return empty because there's not enough room to output
426          * an escaped ; or even a single character.
427          */
428         ast_test_validate(test, test_semi(";", "", 0));
429         ast_test_validate(test, test_semi(";", "", 1));
430         ast_test_validate(test, test_semi(";", "", 2));
431         ast_test_validate(test, test_semi("x", "", 0));
432         ast_test_validate(test, test_semi("x", "", 1));
433
434         /* At least some output should be produced now. */
435         ast_test_validate(test, test_semi("xx;xx", "x", 2));
436         ast_test_validate(test, test_semi("xx;xx", "xx", 3));
437
438         /* There's still not enough room to output \; so
439          * don't even print the \
440          */
441         ast_test_validate(test, test_semi("xx;xx", "xx", 4));
442
443         ast_test_validate(test, test_semi("xx;xx", "xx\\;", 5));
444         ast_test_validate(test, test_semi("xx;xx", "xx\\;x", 6));
445         ast_test_validate(test, test_semi("xx;xx", "xx\\;xx", 7));
446         ast_test_validate(test, test_semi("xx;xx", "xx\\;xx", 8));
447
448         /* Random stuff */
449         ast_test_validate(test, test_semi("xx;xx;this is a test", "xx\\;xx\\;this is a test", 32));
450         ast_test_validate(test, test_semi(";;;;;", "\\;\\;\\;\\;\\;", 32));
451         ast_test_validate(test, test_semi(";;;;;", "\\;\\;\\;\\;", 10));
452         ast_test_validate(test, test_semi(";;;;;", "\\;\\;\\;\\;\\;", 11));
453         ast_test_validate(test, test_semi(";;\\;;;", "\\;\\;\\\\;\\;\\;", 32));
454
455         return AST_TEST_PASS;
456 }
457
458 AST_TEST_DEFINE(escape_test)
459 {
460         char buf[128];
461
462 #define TEST_ESCAPE(s, to_escape, expected) \
463         !strcmp(ast_escape(buf, s, ARRAY_LEN(buf), to_escape), expected)
464
465 #define TEST_ESCAPE_C(s, expected) \
466         !strcmp(ast_escape_c(buf, s, ARRAY_LEN(buf)), expected)
467
468 #define TEST_ESCAPE_ALLOC(s, to_escape, expected)               \
469         ({                                                                                                      \
470                 int res = 0;                                                                    \
471                 char *a_buf = ast_escape_alloc(s, to_escape);   \
472                 if (a_buf) {                                                                    \
473                         res = !strcmp(a_buf, expected);                         \
474                         ast_free(a_buf);                                                        \
475                 }                                                                                               \
476                 res;                                                                                    \
477         })
478
479 #define TEST_ESCAPE_C_ALLOC(s, expected)                                \
480         ({                                                                                                      \
481                 int res = 0;                                                                    \
482                 char *a_buf = ast_escape_c_alloc(s);                    \
483                 if (a_buf) {                                                                    \
484                         res = !strcmp(a_buf, expected);                         \
485                         ast_free(a_buf);                                                        \
486                 }                                                                                               \
487                 res;                                                                                    \
488         })
489
490         switch (cmd) {
491         case TEST_INIT:
492                 info->name = "escape";
493                 info->category = "/main/strings/";
494                 info->summary = "Test ast_escape";
495                 info->description = "Test escaping values in a string";
496                 return AST_TEST_NOT_RUN;
497         case TEST_EXECUTE:
498                 break;
499         }
500
501         ast_test_validate(test, TEST_ESCAPE("null escape", NULL, "null escape"));
502         ast_test_validate(test, TEST_ESCAPE("empty escape", "", "empty escape"));
503         ast_test_validate(test, TEST_ESCAPE("", "Z", ""));
504         ast_test_validate(test, TEST_ESCAPE("no matching escape", "Z", "no matching escape"));
505         ast_test_validate(test, TEST_ESCAPE("escape Z", "Z", "escape \\Z"));
506         ast_test_validate(test, TEST_ESCAPE("Z", "Z", "\\Z"));
507         ast_test_validate(test, TEST_ESCAPE(";;", ";", "\\;\\;"));
508         ast_test_validate(test, TEST_ESCAPE("escape \n", "\n", "escape \\n"));
509         ast_test_validate(test, TEST_ESCAPE("escape \n again \n", "\n", "escape \\n again \\n"));
510
511         ast_test_validate(test, TEST_ESCAPE_C("", ""));
512         ast_test_validate(test, TEST_ESCAPE_C("escape \a\b\f\n\r\t\v\\\'\"\?",
513                 "escape \\a\\b\\f\\n\\r\\t\\v\\\\\\\'\\\"\\?"));
514
515         ast_test_validate(test, TEST_ESCAPE_ALLOC("", "Z", ""));
516         ast_test_validate(test, TEST_ESCAPE_ALLOC("Z", "Z", "\\Z"));
517         ast_test_validate(test, TEST_ESCAPE_ALLOC("a", "Z", "a"));
518
519         ast_test_validate(test, TEST_ESCAPE_C_ALLOC("", ""));
520         ast_test_validate(test, TEST_ESCAPE_C_ALLOC("\n", "\\n"));
521         ast_test_validate(test, TEST_ESCAPE_C_ALLOC("a", "a"));
522
523         return AST_TEST_PASS;
524 }
525
526 AST_TEST_DEFINE(strings_match)
527 {
528         switch (cmd) {
529         case TEST_INIT:
530                 info->name = "strings_match";
531                 info->category = "/main/strings/";
532                 info->summary = "Test ast_strings_match";
533                 info->description = "Test ast_strings_match";
534                 return AST_TEST_NOT_RUN;
535         case TEST_EXECUTE:
536                 break;
537         }
538
539         ast_test_validate(test, ast_strings_match("aaa", NULL, "aaa"));
540         ast_test_validate(test, ast_strings_match("aaa", "", "aaa"));
541         ast_test_validate(test, ast_strings_match("aaa", "=", "aaa"));
542         ast_test_validate(test, !ast_strings_match("aaa", "!=", "aaa"));
543         ast_test_validate(test, !ast_strings_match("aaa", NULL, "aba"));
544         ast_test_validate(test, !ast_strings_match("aaa", "", "aba"));
545         ast_test_validate(test, !ast_strings_match("aaa", "=", "aba"));
546         ast_test_validate(test, ast_strings_match("aaa", "!=", "aba"));
547
548         ast_test_validate(test, ast_strings_match("aaa", "<=", "aba"));
549         ast_test_validate(test, ast_strings_match("aaa", "<=", "aaa"));
550         ast_test_validate(test, !ast_strings_match("aaa", "<", "aaa"));
551
552         ast_test_validate(test, !ast_strings_match("aaa", ">=", "aba"));
553         ast_test_validate(test, ast_strings_match("aaa", ">=", "aaa"));
554         ast_test_validate(test, !ast_strings_match("aaa", ">", "aaa"));
555
556         ast_test_validate(test, !ast_strings_match("aaa", "=", "aa"));
557         ast_test_validate(test, ast_strings_match("aaa", ">", "aa"));
558         ast_test_validate(test, !ast_strings_match("aaa", "<", "aa"));
559
560         ast_test_validate(test, ast_strings_match("1", "=", "1"));
561         ast_test_validate(test, !ast_strings_match("1", "!=", "1"));
562         ast_test_validate(test, !ast_strings_match("2", "=", "1"));
563         ast_test_validate(test, ast_strings_match("2", ">", "1"));
564         ast_test_validate(test, ast_strings_match("2", ">=", "1"));
565         ast_test_validate(test, ast_strings_match("2", ">", "1.9888"));
566         ast_test_validate(test, ast_strings_match("2.9", ">", "1"));
567         ast_test_validate(test, ast_strings_match("2", ">", "1"));
568         ast_test_validate(test, ast_strings_match("2.999", "<", "3"));
569         ast_test_validate(test, ast_strings_match("2", ">", "#"));
570
571         ast_test_validate(test, ast_strings_match("abcccc", "like", "%a%c"));
572         ast_test_validate(test, !ast_strings_match("abcccx", "like", "%a%c"));
573         ast_test_validate(test, ast_strings_match("abcccc", "regex", "a[bc]+c"));
574         ast_test_validate(test, !ast_strings_match("abcccx", "regex", "^a[bxdfgtc]+c$"));
575
576         ast_test_validate(test, !ast_strings_match("neener-93joe", "LIKE", "%blah-%"));
577         ast_test_validate(test, ast_strings_match("blah-93joe", "LIKE", "%blah-%"));
578
579         ast_test_validate(test, !ast_strings_match("abcccx", "regex", NULL));
580         ast_test_validate(test, !ast_strings_match("abcccx", NULL, NULL));
581         ast_test_validate(test, !ast_strings_match(NULL, "regex", NULL));
582         ast_test_validate(test, !ast_strings_match(NULL, NULL, "abc"));
583         ast_test_validate(test, !ast_strings_match(NULL, NULL, NULL));
584
585         return AST_TEST_PASS;
586 }
587
588 static int unload_module(void)
589 {
590         AST_TEST_UNREGISTER(str_test);
591         AST_TEST_UNREGISTER(begins_with_test);
592         AST_TEST_UNREGISTER(ends_with_test);
593         AST_TEST_UNREGISTER(strsep_test);
594         AST_TEST_UNREGISTER(escape_semicolons_test);
595         AST_TEST_UNREGISTER(escape_test);
596         AST_TEST_UNREGISTER(strings_match);
597         return 0;
598 }
599
600 static int load_module(void)
601 {
602         AST_TEST_REGISTER(str_test);
603         AST_TEST_REGISTER(begins_with_test);
604         AST_TEST_REGISTER(ends_with_test);
605         AST_TEST_REGISTER(strsep_test);
606         AST_TEST_REGISTER(escape_semicolons_test);
607         AST_TEST_REGISTER(escape_test);
608         AST_TEST_REGISTER(strings_match);
609         return AST_MODULE_LOAD_SUCCESS;
610 }
611
612 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Dynamic string test module");