ucx: test/test_string.cpp@aa51aaa907b9

     1 /*

     2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

     3  *

     4  * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.

     5  *

     6  * Redistribution and use in source and binary forms, with or without

     7  * modification, are permitted provided that the following conditions are met:

     8  *

     9  *   1. Redistributions of source code must retain the above copyright

    10  *      notice, this list of conditions and the following disclaimer.

    11  *

    12  *   2. Redistributions in binary form must reproduce the above copyright

    13  *      notice, this list of conditions and the following disclaimer in the

    14  *      documentation and/or other materials provided with the distribution.

    15  *

    16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

    17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

    20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

    21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

    22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

    23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

    24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

    25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

    26  * POSSIBILITY OF SUCH DAMAGE.

    27  */

    29 #include "cx/string.h"

    30 #include "util_allocator.h"

    32 #include <gtest/gtest.h>

    34 TEST(String, construct) {

    35     cxstring s1 = cx_str("1234");

    36     cxstring s2 = cx_strn("abcd", 2);

    37     cxmutstr s3 = cx_mutstr((char *) "1234");

    38     cxmutstr s4 = cx_mutstrn((char *) "abcd", 2);

    40     EXPECT_EQ(s1.length, 4);

    41     EXPECT_EQ(s2.length, 2);

    42     EXPECT_EQ(s3.length, 4);

    43     EXPECT_EQ(s4.length, 2);

    44 }

    46 TEST(String, strfree) {

    47     CxTestingAllocator alloc;

    48     auto test = (char *) cxMalloc(&alloc, 16);

    49     cxmutstr str = cx_mutstrn(test, 16);

    50     ASSERT_EQ(str.ptr, test);

    51     EXPECT_EQ(str.length, 16);

    52     cx_strfree_a(&alloc, &str);

    53     EXPECT_EQ(str.ptr, nullptr);

    54     EXPECT_EQ(str.length, 0);

    55     EXPECT_TRUE(alloc.verify());

    56 }

    58 TEST(String, strlen) {

    59     cxstring s1 = CX_STR("1234");

    60     cxstring s2 = CX_STR(".:.:.");

    61     cxstring s3 = CX_STR("X");

    63     size_t len0 = cx_strlen(0);

    64     size_t len1 = cx_strlen(1, s1);

    65     size_t len2 = cx_strlen(2, s1, s2);

    66     size_t len3 = cx_strlen(3, s1, s2, s3);

    68     EXPECT_EQ(len0, 0);

    69     EXPECT_EQ(len1, 4);

    70     EXPECT_EQ(len2, 9);

    71     EXPECT_EQ(len3, 10);

    72 }

    74 TEST(String, strsubs) {

    75     cxstring str = CX_STR("A test string");

    77     cxstring sub = cx_strsubs(str, 0);

    78     EXPECT_EQ(cx_strcmp(sub, str), 0);

    80     sub = cx_strsubs(str, 2);

    81     EXPECT_EQ(cx_strcmp(sub, cx_str("test string")), 0);

    83     sub = cx_strsubs(str, 7);

    84     EXPECT_EQ(cx_strcmp(sub, cx_str("string")), 0);

    86     sub = cx_strsubs(str, 15);

    87     EXPECT_EQ(cx_strcmp(sub, cx_str("")), 0);

    89     sub = cx_strsubsl(str, 2, 4);

    90     EXPECT_EQ(cx_strcmp(sub, cx_str("test")), 0);

    92     sub = cx_strsubsl(str, 7, 3);

    93     EXPECT_EQ(cx_strcmp(sub, cx_str("str")), 0);

    95     sub = cx_strsubsl(str, 7, 20);

    96     EXPECT_EQ(cx_strcmp(sub, cx_str("string")), 0);

    98     // just for coverage, call the _m variant

    99     auto m = cx_strsubs_m(cx_mutstrn(nullptr, 0), 0);

   100     EXPECT_EQ(cx_strcmp(cx_strcast(m), cx_str("")), 0);

   101 }

   103 TEST(String, strchr) {

   104     cxstring str = CX_STR("I will find you - and I will kill you");

   106     cxstring notfound = cx_strchr(str, 'x');

   107     EXPECT_EQ(notfound.length, 0);

   109     cxstring result = cx_strchr(str, 'w');

   110     EXPECT_EQ(result.length, 35);

   111     EXPECT_EQ(strcmp("will find you - and I will kill you", result.ptr), 0);

   113     // just for coverage, call the _m variant

   114     auto m = cx_strchr_m(cx_mutstrn(nullptr, 0), 'a');

   115     EXPECT_EQ(cx_strcmp(cx_strcast(m), cx_str("")), 0);

   116 }

   118 TEST(String, strrchr) {

   119     cxstring str = CX_STR("I will find you - and I will kill you");

   121     cxstring notfound = cx_strrchr(str, 'x');

   122     EXPECT_EQ(notfound.length, 0);

   124     cxstring result = cx_strrchr(str, 'w');

   125     EXPECT_EQ(result.length, 13);

   126     EXPECT_EQ(strcmp("will kill you", result.ptr), 0);

   128     // just for coverage, call the _m variant

   129     auto m = cx_strrchr_m(cx_mutstrn(nullptr, 0), 'a');

   130     EXPECT_EQ(cx_strcmp(cx_strcast(m), cx_str("")), 0);

   131 }

   133 TEST(String, strstr) {

   134     cxstring str = CX_STR("find the match in this string");

   135     cxstring longstr = CX_STR(

   136             "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl"

   137             "mnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwx"

   138             "yzabcdeababababnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghij"

   139             "klmnopqrstuvwxyzaababababababababrstuvwxyzabcdefghijklmnopqrstuv"

   140             "abababababababababababababababababababababababababababababababab"

   141             "abababababababababababababababababababababababababababababababab"

   142             "abababababababababababababababababababababababababababababababab"

   143             "abababababababababababababababababababababababababababababababab"

   144             "abababababababababababababababababababababababababababababababab"

   145             "abababababababababababababababababababababababababababababababab"

   146             "wxyz1234567890");

   147     cxstring longstrpattern = CX_STR(

   148             "abababababababababababababababababababababababababababababababab"

   149             "abababababababababababababababababababababababababababababababab"

   150             "abababababababababababababababababababababababababababababababab"

   151             "abababababababababababababababababababababababababababababababab"

   152             "abababababababababababababababababababababababababababababababab"

   153     );

   154     cxstring longstrresult = CX_STR(

   155             "abababababababababababababababababababababababababababababababab"

   156             "abababababababababababababababababababababababababababababababab"

   157             "abababababababababababababababababababababababababababababababab"

   158             "abababababababababababababababababababababababababababababababab"

   159             "abababababababababababababababababababababababababababababababab"

   160             "abababababababababababababababababababababababababababababababab"

   161             "wxyz1234567890"

   162     );

   164     cxstring notfound = cx_strstr(str, cx_str("no match"));

   165     EXPECT_EQ(notfound.length, 0);

   167     cxstring result = cx_strstr(str, cx_str("match"));

   168     EXPECT_EQ(result.length, 20);

   169     EXPECT_EQ(strcmp("match in this string", result.ptr), 0);

   171     result = cx_strstr(str, cx_str(""));

   172     EXPECT_EQ(result.length, str.length);

   173     EXPECT_EQ(strcmp(str.ptr, result.ptr), 0);

   175     result = cx_strstr(longstr, longstrpattern);

   176     EXPECT_EQ(result.length, longstrresult.length);

   177     EXPECT_EQ(strcmp(result.ptr, longstrresult.ptr), 0);

   179     // just for coverage, call the _m variant

   180     auto mstr = cx_strdup(longstr);

   181     auto m = cx_strstr_m(mstr, longstrpattern);

   182     EXPECT_EQ(m.length, longstrresult.length);

   183     EXPECT_EQ(strcmp(m.ptr, longstrresult.ptr), 0);

   184     cx_strfree(&mstr);

   185 }

   187 TEST(String, strcmp) {

   188     cxstring str = CX_STR("compare this");

   190     EXPECT_EQ(cx_strcmp(CX_STR(""), CX_STR("")), 0);

   191     EXPECT_GT(cx_strcmp(str, CX_STR("")), 0);

   192     EXPECT_EQ(cx_strcmp(str, CX_STR("compare this")), 0);

   193     EXPECT_NE(cx_strcmp(str, CX_STR("Compare This")), 0);

   194     EXPECT_LT(cx_strcmp(str, CX_STR("compare tool")), 0);

   195     EXPECT_GT(cx_strcmp(str, CX_STR("compare shit")), 0);

   196     EXPECT_LT(cx_strcmp(str, CX_STR("compare this not")), 0);

   197     EXPECT_GT(cx_strcmp(str, CX_STR("compare")), 0);

   198 }

   200 TEST(String, strcasecmp) {

   201     cxstring str = CX_STR("compare this");

   203     EXPECT_EQ(cx_strcasecmp(CX_STR(""), CX_STR("")), 0);

   204     EXPECT_GT(cx_strcasecmp(str, CX_STR("")), 0);

   205     EXPECT_EQ(cx_strcasecmp(str, CX_STR("compare this")), 0);

   206     EXPECT_EQ(cx_strcasecmp(str, CX_STR("Compare This")), 0);

   207     EXPECT_LT(cx_strcasecmp(str, CX_STR("compare tool")), 0);

   208     EXPECT_GT(cx_strcasecmp(str, CX_STR("compare shit")), 0);

   209     EXPECT_LT(cx_strcasecmp(str, CX_STR("compare this not")), 0);

   210     EXPECT_GT(cx_strcasecmp(str, CX_STR("compare")), 0);

   211 }

   214 TEST(String, strcat) {

   215     cxstring s1 = CX_STR("12");

   216     cxstring s2 = CX_STR("34");

   217     cxstring s3 = CX_STR("56");

   218     cxstring sn = {nullptr, 0};

   220     CxTestingAllocator alloc;

   222     cxmutstr t1 = cx_strcat_a(&alloc, 2, s1, s2);

   223     EXPECT_EQ(cx_strcmp(cx_strcast(t1), CX_STR("1234")), 0);

   224     cx_strfree_a(&alloc, &t1);

   226     cxmutstr t2 = cx_strcat_a(&alloc, 3, s1, s2, s3);

   227     EXPECT_EQ(cx_strcmp(cx_strcast(t2), CX_STR("123456")), 0);

   228     cx_strfree_a(&alloc, &t2);

   230     cxmutstr t3 = cx_strcat_a(&alloc, 6, s1, sn, s2, sn, s3, sn);

   231     EXPECT_EQ(cx_strcmp(cx_strcast(t3), CX_STR("123456")), 0);

   232     cx_strfree_a(&alloc, &t3);

   234     cxmutstr t4 = cx_strcat_a(&alloc, 2, sn, sn);

   235     EXPECT_EQ(cx_strcmp(cx_strcast(t4), CX_STR("")), 0);

   236     cx_strfree_a(&alloc, &t4);

   238     EXPECT_TRUE(alloc.verify());

   239 }

   241 TEST(String, strsplit) {

   243     cxstring test = cx_str("this,is,a,csv,string");

   244     size_t capa = 8;

   245     cxstring list[8];

   246     size_t n;

   248     /* special case: empty string */

   249     n = cx_strsplit(test, cx_str(""), capa, list);

   250     ASSERT_EQ(n, 1);

   251     EXPECT_EQ(cx_strcmp(list[0], test), 0);

   253     /* no delimiter occurrence */

   254     n = cx_strsplit(test, cx_str("z"), capa, list);

   255     ASSERT_EQ(n, 1);

   256     EXPECT_EQ(cx_strcmp(list[0], test), 0);

   258     /* partially matching delimiter */

   259     n = cx_strsplit(test, cx_str("is,not"), capa, list);

   260     ASSERT_EQ(n, 1);

   261     EXPECT_EQ(cx_strcmp(list[0], test), 0);

   263     /* matching single-char delimiter */

   264     n = cx_strsplit(test, cx_str(","), capa, list);

   265     ASSERT_EQ(n, 5);

   266     EXPECT_EQ(cx_strcmp(list[0], cx_str("this")), 0);

   267     EXPECT_EQ(cx_strcmp(list[1], cx_str("is")), 0);

   268     EXPECT_EQ(cx_strcmp(list[2], cx_str("a")), 0);

   269     EXPECT_EQ(cx_strcmp(list[3], cx_str("csv")), 0);

   270     EXPECT_EQ(cx_strcmp(list[4], cx_str("string")), 0);

   272     /* matching multi-char delimiter */

   273     n = cx_strsplit(test, cx_str("is"), capa, list);

   274     ASSERT_EQ(n, 3);

   275     EXPECT_EQ(cx_strcmp(list[0], cx_str("th")), 0);

   276     EXPECT_EQ(cx_strcmp(list[1], cx_str(",")), 0);

   277     EXPECT_EQ(cx_strcmp(list[2], cx_str(",a,csv,string")), 0);

   279     /* bounded list using single-char delimiter */

   280     n = cx_strsplit(test, cx_str(","), 3, list);

   281     ASSERT_EQ(n, 3);

   282     EXPECT_EQ(cx_strcmp(list[0], cx_str("this")), 0);

   283     EXPECT_EQ(cx_strcmp(list[1], cx_str("is")), 0);

   284     EXPECT_EQ(cx_strcmp(list[2], cx_str("a,csv,string")), 0);

   286     /* bounded list using multi-char delimiter */

   287     n = cx_strsplit(test, cx_str("is"), 2, list);

   288     ASSERT_EQ(n, 2);

   289     EXPECT_EQ(cx_strcmp(list[0], cx_str("th")), 0);

   290     EXPECT_EQ(cx_strcmp(list[1], cx_str(",is,a,csv,string")), 0);

   292     /* start with delimiter */

   293     n = cx_strsplit(test, cx_str("this"), capa, list);

   294     ASSERT_EQ(n, 2);

   295     EXPECT_EQ(cx_strcmp(list[0], cx_str("")), 0);

   296     EXPECT_EQ(cx_strcmp(list[1], cx_str(",is,a,csv,string")), 0);

   298     /* end with delimiter */

   299     n = cx_strsplit(test, cx_str("string"), capa, list);

   300     ASSERT_EQ(n, 2);

   301     EXPECT_EQ(cx_strcmp(list[0], cx_str("this,is,a,csv,")), 0);

   302     EXPECT_EQ(cx_strcmp(list[1], cx_str("")), 0);

   305     /* end with delimiter exceed bound */

   306     n = cx_strsplit(cx_str("a,b,c,"), cx_str(","), 3, list);

   307     ASSERT_EQ(n, 3);

   308     EXPECT_EQ(cx_strcmp(list[0], cx_str("a")), 0);

   309     EXPECT_EQ(cx_strcmp(list[1], cx_str("b")), 0);

   310     EXPECT_EQ(cx_strcmp(list[2], cx_str("c,")), 0);

   312     /* exact match */

   313     n = cx_strsplit(test, cx_str("this,is,a,csv,string"), capa, list);

   314     ASSERT_EQ(n, 2);

   315     EXPECT_EQ(cx_strcmp(list[0], cx_str("")), 0);

   316     EXPECT_EQ(cx_strcmp(list[1], cx_str("")), 0);

   318     /* string to be split is only substring */

   319     n = cx_strsplit(test, cx_str("this,is,a,csv,string,with,extension"), capa, list);

   320     ASSERT_EQ(n, 1);

   321     EXPECT_EQ(cx_strcmp(list[0], test), 0);

   323     /* subsequent encounter of delimiter (the string between is empty) */

   324     n = cx_strsplit(test, cx_str("is,"), capa, list);

   325     ASSERT_EQ(n, 3);

   326     EXPECT_EQ(cx_strcmp(list[0], cx_str("th")), 0);

   327     EXPECT_EQ(cx_strcmp(list[1], cx_str("")), 0);

   328     EXPECT_EQ(cx_strcmp(list[2], cx_str("a,csv,string")), 0);

   330     /* call the _m variant just for coverage */

   331     auto mtest = cx_strdup(test);

   332     cxmutstr mlist[4];

   333     n = cx_strsplit_m(mtest, cx_str("is,"), 4, mlist);

   334     ASSERT_EQ(n, 3);

   335     EXPECT_EQ(cx_strcmp(cx_strcast(mlist[0]), cx_str("th")), 0);

   336     EXPECT_EQ(cx_strcmp(cx_strcast(mlist[1]), cx_str("")), 0);

   337     EXPECT_EQ(cx_strcmp(cx_strcast(mlist[2]), cx_str("a,csv,string")), 0);

   338     cx_strfree(&mtest);

   339 }

   341 TEST(String, strsplit_a) {

   342     CxTestingAllocator alloc;

   344     cxstring test = cx_str("this,is,a,csv,string");

   345     size_t capa = 8;

   346     cxstring *list;

   347     size_t n;

   349     /* special case: empty string */

   350     n = cx_strsplit_a(&alloc, test, cx_str(""), capa, &list);

   351     ASSERT_EQ(n, 1);

   352     EXPECT_EQ(cx_strcmp(list[0], test), 0);

   353     cxFree(&alloc, list);

   355     /* no delimiter occurrence */

   356     n = cx_strsplit_a(&alloc, test, cx_str("z"), capa, &list);

   357     ASSERT_EQ(n, 1);

   358     EXPECT_EQ(cx_strcmp(list[0], test), 0);

   359     cxFree(&alloc, list);

   361     /* partially matching delimiter */

   362     n = cx_strsplit_a(&alloc, test, cx_str("is,not"), capa, &list);

   363     ASSERT_EQ(n, 1);

   364     EXPECT_EQ(cx_strcmp(list[0], test), 0);

   365     cxFree(&alloc, list);

   367     /* matching single-char delimiter */

   368     n = cx_strsplit_a(&alloc, test, cx_str(","), capa, &list);

   369     ASSERT_EQ(n, 5);

   370     EXPECT_EQ(cx_strcmp(list[0], cx_str("this")), 0);

   371     EXPECT_EQ(cx_strcmp(list[1], cx_str("is")), 0);

   372     EXPECT_EQ(cx_strcmp(list[2], cx_str("a")), 0);

   373     EXPECT_EQ(cx_strcmp(list[3], cx_str("csv")), 0);

   374     EXPECT_EQ(cx_strcmp(list[4], cx_str("string")), 0);

   375     cxFree(&alloc, list);

   377     /* matching multi-char delimiter */

   378     n = cx_strsplit_a(&alloc, test, cx_str("is"), capa, &list);

   379     ASSERT_EQ(n, 3);

   380     EXPECT_EQ(cx_strcmp(list[0], cx_str("th")), 0);

   381     EXPECT_EQ(cx_strcmp(list[1], cx_str(",")), 0);

   382     EXPECT_EQ(cx_strcmp(list[2], cx_str(",a,csv,string")), 0);

   383     cxFree(&alloc, list);

   385     /* bounded list using single-char delimiter */

   386     n = cx_strsplit_a(&alloc, test, cx_str(","), 3, &list);

   387     ASSERT_EQ(n, 3);

   388     EXPECT_EQ(cx_strcmp(list[0], cx_str("this")), 0);

   389     EXPECT_EQ(cx_strcmp(list[1], cx_str("is")), 0);

   390     EXPECT_EQ(cx_strcmp(list[2], cx_str("a,csv,string")), 0);

   391     cxFree(&alloc, list);

   393     /* bounded list using multi-char delimiter */

   394     n = cx_strsplit_a(&alloc, test, cx_str("is"), 2, &list);

   395     ASSERT_EQ(n, 2);

   396     EXPECT_EQ(cx_strcmp(list[0], cx_str("th")), 0);

   397     EXPECT_EQ(cx_strcmp(list[1], cx_str(",is,a,csv,string")), 0);

   398     cxFree(&alloc, list);

   400     /* start with delimiter */

   401     n = cx_strsplit_a(&alloc, test, cx_str("this"), capa, &list);

   402     ASSERT_EQ(n, 2);

   403     EXPECT_EQ(cx_strcmp(list[0], cx_str("")), 0);

   404     EXPECT_EQ(cx_strcmp(list[1], cx_str(",is,a,csv,string")), 0);

   405     cxFree(&alloc, list);

   407     /* end with delimiter */

   408     n = cx_strsplit_a(&alloc, test, cx_str("string"), capa, &list);

   409     ASSERT_EQ(n, 2);

   410     EXPECT_EQ(cx_strcmp(list[0], cx_str("this,is,a,csv,")), 0);

   411     EXPECT_EQ(cx_strcmp(list[1], cx_str("")), 0);

   412     cxFree(&alloc, list);

   414     /* end with delimiter exceed bound */

   415     n = cx_strsplit_a(&alloc, cx_str("a,b,c,"), cx_str(","), 3, &list);

   416     ASSERT_EQ(n, 3);

   417     EXPECT_EQ(cx_strcmp(list[0], cx_str("a")), 0);

   418     EXPECT_EQ(cx_strcmp(list[1], cx_str("b")), 0);

   419     EXPECT_EQ(cx_strcmp(list[2], cx_str("c,")), 0);

   420     cxFree(&alloc, list);

   422     /* exact match */

   423     n = cx_strsplit_a(&alloc, test, cx_str("this,is,a,csv,string"), capa, &list);

   424     ASSERT_EQ(n, 2);

   425     EXPECT_EQ(cx_strcmp(list[0], cx_str("")), 0);

   426     EXPECT_EQ(cx_strcmp(list[1], cx_str("")), 0);

   427     cxFree(&alloc, list);

   429     /* string to be split is only substring */

   430     n = cx_strsplit_a(&alloc, test, cx_str("this,is,a,csv,string,with,extension"), capa, &list);

   431     ASSERT_EQ(n, 1);

   432     EXPECT_EQ(cx_strcmp(list[0], test), 0);

   433     cxFree(&alloc, list);

   435     /* subsequent encounter of delimiter (the string between is empty) */

   436     n = cx_strsplit_a(&alloc, test, cx_str("is,"), capa, &list);

   437     ASSERT_EQ(n, 3);

   438     EXPECT_EQ(cx_strcmp(list[0], cx_str("th")), 0);

   439     EXPECT_EQ(cx_strcmp(list[1], cx_str("")), 0);

   440     EXPECT_EQ(cx_strcmp(list[2], cx_str("a,csv,string")), 0);

   441     cxFree(&alloc, list);

   443     /* call the _m variant just for coverage */

   444     auto mtest = cx_strdup(test);

   445     cxmutstr *mlist;

   446     n = cx_strsplit_ma(&alloc, mtest, cx_str("is,"), 4, &mlist);

   447     ASSERT_EQ(n, 3);

   448     EXPECT_EQ(cx_strcmp(cx_strcast(mlist[0]), cx_str("th")), 0);

   449     EXPECT_EQ(cx_strcmp(cx_strcast(mlist[1]), cx_str("")), 0);

   450     EXPECT_EQ(cx_strcmp(cx_strcast(mlist[2]), cx_str("a,csv,string")), 0);

   451     cxFree(&alloc, mlist);

   452     cx_strfree(&mtest);

   454     EXPECT_TRUE(alloc.verify());

   455 }

   457 TEST(String, strtrim) {

   458     cxstring t1 = cx_strtrim(cx_str("  ein test  \t "));

   459     cxstring t2 = cx_strtrim(cx_str("abc"));

   460     cxstring t3 = cx_strtrim(cx_str(" 123"));

   461     cxstring t4 = cx_strtrim(cx_str("xyz "));

   462     cxstring t5 = cx_strtrim(cx_str("   "));

   463     cxstring empty = cx_strtrim(cx_str(""));

   465     EXPECT_EQ(cx_strcmp(t1, cx_str("ein test")), 0);

   466     EXPECT_EQ(cx_strcmp(t2, cx_str("abc")), 0);

   467     EXPECT_EQ(cx_strcmp(t3, cx_str("123")), 0);

   468     EXPECT_EQ(cx_strcmp(t4, cx_str("xyz")), 0);

   469     EXPECT_EQ(cx_strcmp(t5, cx_str("")), 0);

   470     EXPECT_EQ(cx_strcmp(empty, cx_str("")), 0);

   472     /* call the _m variant just for coverage */

   473     cxmutstr m1 = cx_strtrim_m(cx_mutstr((char *) "  ein test  \t "));

   474     EXPECT_EQ(cx_strcmp(cx_strcast(m1), cx_str("ein test")), 0);

   475 }

   477 TEST(String, strprefix) {

   478     cxstring str = CX_STR("test my prefix and my suffix");

   479     cxstring empty = CX_STR("");

   480     EXPECT_FALSE(cx_strprefix(empty, cx_str("pref")));

   481     EXPECT_TRUE(cx_strprefix(str, empty));

   482     EXPECT_TRUE(cx_strprefix(empty, empty));

   483     EXPECT_TRUE(cx_strprefix(str, cx_str("test ")));

   484     EXPECT_FALSE(cx_strprefix(str, cx_str("8-) fsck ")));

   485 }

   487 TEST(String, strsuffix) {

   488     cxstring str = CX_STR("test my prefix and my suffix");

   489     cxstring empty = CX_STR("");

   490     EXPECT_FALSE(cx_strsuffix(empty, cx_str("suf")));

   491     EXPECT_TRUE(cx_strsuffix(str, empty));

   492     EXPECT_TRUE(cx_strsuffix(empty, empty));

   493     EXPECT_TRUE(cx_strsuffix(str, cx_str("fix")));

   494     EXPECT_FALSE(cx_strsuffix(str, cx_str("fox")));

   495 }

   497 TEST(String, strcaseprefix) {

   498     cxstring str = CX_STR("test my prefix and my suffix");

   499     cxstring empty = CX_STR("");

   500     EXPECT_FALSE(cx_strcaseprefix(empty, cx_str("pREf")));

   501     EXPECT_TRUE(cx_strcaseprefix(str, empty));

   502     EXPECT_TRUE(cx_strcaseprefix(empty, empty));

   503     EXPECT_TRUE(cx_strcaseprefix(str, cx_str("TEST ")));

   504     EXPECT_FALSE(cx_strcaseprefix(str, cx_str("8-) fsck ")));

   505 }

   507 TEST(String, strcasesuffix) {

   508     cxstring str = CX_STR("test my prefix and my suffix");

   509     cxstring empty = CX_STR("");

   510     EXPECT_FALSE(cx_strcasesuffix(empty, cx_str("sUf")));

   511     EXPECT_TRUE(cx_strcasesuffix(str, empty));

   512     EXPECT_TRUE(cx_strcasesuffix(empty, empty));

   513     EXPECT_TRUE(cx_strcasesuffix(str, cx_str("FIX")));

   514     EXPECT_FALSE(cx_strcasesuffix(str, cx_str("fox")));

   515 }

   517 TEST(String, strreplace) {

   518     cxstring str = CX_STR("test ababab string aba");

   519     cxstring longstr = CX_STR(

   520             "xyaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaacd");

   521     cxstring notrail = CX_STR("test abab");

   522     cxstring empty = CX_STR("");

   523     cxstring astr = CX_STR("aaaaaaaaaa");

   524     cxstring csstr = CX_STR("test AB ab TEST xyz");

   526     cxmutstr repl = cx_strreplace(str, cx_str("abab"), cx_str("muchlonger"));

   527     cxstring expected = CX_STR("test muchlongerab string aba");

   529     cxmutstr repln = cx_strreplacen(str, cx_str("ab"), cx_str("c"), 2);

   530     cxstring expectedn = CX_STR("test ccab string aba");

   532     cxmutstr longrepl = cx_strreplace(longstr, cx_str("a"), cx_str("z"));

   533     cxstring longexpect = CX_STR(

   534             "xyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzcd");

   536     cxmutstr replnotrail = cx_strreplace(notrail, cx_str("ab"), cx_str("z"));

   537     cxstring notrailexpect = CX_STR("test zz");

   539     cxmutstr repleq = cx_strreplace(str, str, cx_str("hello"));

   540     cxstring eqexpect = CX_STR("hello");

   542     cxmutstr replempty1 = cx_strreplace(empty, cx_str("ab"), cx_str("c")); // expect: empty

   543     cxmutstr replempty2 = cx_strreplace(str, cx_str("abab"), empty);

   544     cxstring emptyexpect2 = CX_STR("test ab string aba");

   546     cxmutstr replpre = cx_strreplace(str, cx_str("test "), cx_str("TEST "));

   547     cxstring preexpected = CX_STR("TEST ababab string aba");

   549     cxmutstr replan1 = cx_strreplacen(astr, cx_str("a"), cx_str("x"), 1);

   550     cxstring an1expected = CX_STR("xaaaaaaaaa");

   552     cxmutstr replan4 = cx_strreplacen(astr, cx_str("a"), cx_str("x"), 4);

   553     cxstring an4expected = CX_STR("xxxxaaaaaa");

   555     cxmutstr replan9 = cx_strreplacen(astr, cx_str("a"), cx_str("x"), 9);

   556     cxstring an9expected = CX_STR("xxxxxxxxxa");

   558     cxmutstr replan10 = cx_strreplacen(astr, cx_str("a"), cx_str("x"), 10);

   559     cxstring an10expected = CX_STR("xxxxxxxxxx");

   561     cxmutstr replcs1 = cx_strreplace(csstr, cx_str("AB"), cx_str("*"));

   562     cxstring cs1expected = CX_STR("test * ab TEST xyz");

   564     cxmutstr replcs2 = cx_strreplace(csstr, cx_str("test"), cx_str("TEST"));

   565     cxstring cs2expected = CX_STR("TEST AB ab TEST xyz");

   568     EXPECT_NE(repl.ptr, str.ptr);

   569     EXPECT_EQ(cx_strcmp(cx_strcast(repl), expected), 0);

   570     EXPECT_NE(repln.ptr, str.ptr);

   571     EXPECT_EQ(cx_strcmp(cx_strcast(repln), expectedn), 0);

   572     EXPECT_EQ(cx_strcmp(cx_strcast(longrepl), longexpect), 0);

   573     EXPECT_EQ(cx_strcmp(cx_strcast(replnotrail), notrailexpect), 0);

   574     EXPECT_EQ(cx_strcmp(cx_strcast(repleq), eqexpect), 0);

   575     EXPECT_EQ(cx_strcmp(cx_strcast(replempty1), empty), 0);

   576     EXPECT_EQ(cx_strcmp(cx_strcast(replempty2), emptyexpect2), 0);

   577     EXPECT_EQ(cx_strcmp(cx_strcast(replpre), preexpected), 0);

   578     EXPECT_EQ(cx_strcmp(cx_strcast(replan1), an1expected), 0);

   579     EXPECT_EQ(cx_strcmp(cx_strcast(replan4), an4expected), 0);

   580     EXPECT_EQ(cx_strcmp(cx_strcast(replan9), an9expected), 0);

   581     EXPECT_EQ(cx_strcmp(cx_strcast(replan10), an10expected), 0);

   582     EXPECT_EQ(cx_strcmp(cx_strcast(replcs1), cs1expected), 0);

   583     EXPECT_EQ(cx_strcmp(cx_strcast(replcs2), cs2expected), 0);

   585     cx_strfree(&repl);

   586     cx_strfree(&repln);

   587     cx_strfree(&longrepl);

   588     cx_strfree(&replnotrail);

   589     cx_strfree(&repleq);

   590     cx_strfree(&replempty1);

   591     cx_strfree(&replempty2);

   592     cx_strfree(&replpre);

   593     cx_strfree(&replan1);

   594     cx_strfree(&replan4);

   595     cx_strfree(&replan9);

   596     cx_strfree(&replan10);

   597     cx_strfree(&replcs1);

   598     cx_strfree(&replcs2);

   599 }

   601 TEST(String, strupper) {

   602     cxmutstr str = cx_strdup(cx_str("thIs 1s @ Te$t"));

   603     cx_strupper(str);

   604     EXPECT_STREQ(str.ptr, "THIS 1S @ TE$T");

   605     cx_strfree(&str);

   606 }

   608 TEST(String, strlower) {

   609     cxmutstr str = cx_strdup(cx_str("thIs 1s @ Te$t"));

   610     cx_strlower(str);

   611     EXPECT_STREQ(str.ptr, "this 1s @ te$t");

   612     cx_strfree(&str);

   613 }

Mercurial > hg > ucx / file revision

test/test_string.cpp@aa51aaa907b9

test/test_string.cpp