ucx: test/prop_tests.c@d2b1e67b2b48

     1 /*

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

     3  *

     4  * Copyright 2013 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 "prop_tests.h"

    31 UCX_TEST_IMPLEMENT(test_ucx_prop_new) {

    32     UcxPropParser *parser = ucx_prop_new();

    34     UCX_TEST_BEGIN

    36     UCX_TEST_ASSERT(parser != NULL, "failed");

    37     UCX_TEST_ASSERT(parser->buffer == NULL, "parser has buffer");

    38     UCX_TEST_ASSERT(parser->tmp == NULL, "parser has tmp buffer");

    40     UCX_TEST_END

    42     ucx_prop_free(parser);

    43 }

    45 UCX_TEST_IMPLEMENT(test_ucx_prop_parse) {

    46     char *tests[] = {

    47         "name = value\n",

    48         "name=value\n",

    49         "n=value\n",

    50         "name=v\n",

    51         "n=v\n",

    52         "name = value # comment\n",

    53         "#comment\nn=v\n",

    54         "# comment1\n# comment2\n\n    \n\nname = value\n",

    55         "    name     =      value\n",

    56         "name = value\n\n"

    57     };

    59     char *names[] = {

    60         "name",

    61         "name",

    62         "n",

    63         "name",

    64         "n",

    65         "name",

    66         "n",

    67         "name",

    68         "name",

    69         "name"

    70     };

    72     char *values[] = {

    73         "value",

    74         "value",

    75         "value",

    76         "v",

    77         "v",

    78         "value",

    79         "v",

    80         "value",

    81         "value",

    82         "value"

    83     };

    85     UCX_TEST_BEGIN

    87     sstr_t name;

    88     sstr_t value;

    90     for(int i=0;i<10;i++) {

    91         UcxPropParser *parser = ucx_prop_new();

    93         ucx_prop_fill(parser, tests[i], strlen(tests[i]));

    94         UCX_TEST_ASSERT(parser->buffer == tests[i], "fill failed");

    95         UCX_TEST_ASSERT(parser->buflen == strlen(tests[i]), "wrong buflen");

    97         int r = ucx_prop_parse(parser, &name, &value);

    98         sstr_t n = sstr(names[i]);

    99         sstr_t v = sstr(values[i]);

   100         UCX_TEST_ASSERT(r == 1, "parse returned 0");

   101         UCX_TEST_ASSERT((!sstrcmp(name, n)), "wrong property name");

   102         UCX_TEST_ASSERT((!sstrcmp(value, v)), "wrong property value");

   104         r = ucx_prop_parse(parser, &name, &value);

   105         UCX_TEST_ASSERT(r == 0, "parse returned 1");

   106         UCX_TEST_ASSERT(parser->tmp == NULL, "tmp not NULL");

   107         UCX_TEST_ASSERT(parser->tmpcap == 0, "tmpcap not NULL");

   108         UCX_TEST_ASSERT(parser->tmplen == 0, "tmplen not NULL");

   110         ucx_prop_free(parser);

   111     }

   113     UCX_TEST_END

   114 }

   116 UCX_TEST_IMPLEMENT(test_ucx_prop_parse_multi) {

   117     char *names[] = {

   118         "a",

   119         "b",

   120         "c",

   121         "uap",

   122         "name",

   123         "key1",

   124         "key2",

   125         "key3"

   126     };

   128     char *values[] = {

   129         "a value",

   130         "b value",

   131         "core",

   132         "core",

   133         "ucx",

   134         "value1",

   135         "value2",

   136         "value3"

   137     };

   139     char *str = "#\n"

   140         "# properties\n"

   141         "# contains key/value pairs\n"

   142         "#\n"

   143         "a = a value\n"

   144         "b = b value\n"

   145         "c = core\n"

   146         "\n# test\n"

   147         "uap = core\n"

   148         "name = ucx\n"

   149         "# no = property\n"

   150         "key1 = value1\n"

   151         "#key1 = wrong value\n"

   152         "#key2 = not value 2\n"

   153         "key2 = value2\n"

   154         "\n\n\n        \n           key3=value3\n";

   156     UcxPropParser *parser = ucx_prop_new();

   158     UCX_TEST_BEGIN

   160     ucx_prop_fill(parser, str, strlen(str));

   162     sstr_t name;

   163     sstr_t value;

   164     for(int i=0;i<8;i++) {

   165         int r = ucx_prop_parse(parser, &name, &value);

   166         UCX_TEST_ASSERT(r == 1, "parse returned 0");

   167         UCX_TEST_ASSERT((!sstrcmp(name, sstr(names[i]))), "wrong name");

   168         UCX_TEST_ASSERT((!sstrcmp(value, sstr(values[i]))), "wrong value");

   169     }

   170     int r = ucx_prop_parse(parser, &name, &value);

   171     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   173     UCX_TEST_END

   175     ucx_prop_free(parser);

   176 }

   178 UCX_TEST_IMPLEMENT(test_ucx_prop_parse_part) {

   179     UcxPropParser *parser = ucx_prop_new();

   180     char *str;

   181     int r;

   182     sstr_t name;

   183     sstr_t value;

   185     UCX_TEST_BEGIN

   187     str = "";

   188     ucx_prop_fill(parser, str, strlen(str));

   189     r = ucx_prop_parse(parser, &name, &value);

   190     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   192     str = "  \n";

   193     ucx_prop_fill(parser, str, strlen(str));

   194     r = ucx_prop_parse(parser, &name, &value);

   195     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   197     str = "name";

   198     ucx_prop_fill(parser, str, strlen(str));

   199     r = ucx_prop_parse(parser, &name, &value);

   200     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   202     str = "    ";

   203     ucx_prop_fill(parser, str, strlen(str));

   204     r = ucx_prop_parse(parser, &name, &value);

   205     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   207     str = "= ";

   208     ucx_prop_fill(parser, str, strlen(str));

   209     r = ucx_prop_parse(parser, &name, &value);

   210     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   212     str = "value";

   213     ucx_prop_fill(parser, str, strlen(str));

   214     r = ucx_prop_parse(parser, &name, &value);

   215     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   217     str = "\n";

   218     ucx_prop_fill(parser, str, strlen(str));

   219     r = ucx_prop_parse(parser, &name, &value);

   220     UCX_TEST_ASSERT(r == 1, "parse returned 0");

   221     UCX_TEST_ASSERT((!sstrcmp(name, sstr("name"))), "wrong name");

   222     UCX_TEST_ASSERT((!sstrcmp(value, sstr("value"))), "wrong value");

   224     // second round

   225     str = "#comment\n";

   226     ucx_prop_fill(parser, str, strlen(str));

   227     r = ucx_prop_parse(parser, &name, &value);

   228     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   230     str = "#comment\nname = ";

   231     ucx_prop_fill(parser, str, strlen(str));

   232     r = ucx_prop_parse(parser, &name, &value);

   233     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   235     str = "value\na = b\n";

   236     ucx_prop_fill(parser, str, strlen(str));

   237     r = ucx_prop_parse(parser, &name, &value);

   238     UCX_TEST_ASSERT(r == 1, "parse returned 0");

   239     UCX_TEST_ASSERT((!sstrcmp(name, sstr("name"))), "wrong name");

   240     UCX_TEST_ASSERT((!sstrcmp(value, sstr("value"))), "wrong value");

   242     r = ucx_prop_parse(parser, &name, &value);

   243     UCX_TEST_ASSERT(r == 1, "parse returned 0");

   244     UCX_TEST_ASSERT((!sstrcmp(name, sstr("a"))), "wrong name");

   245     UCX_TEST_ASSERT((!sstrcmp(value, sstr("b"))), "wrong value");

   247     str = "# comment\n#\n#\ntests = ";

   248     ucx_prop_fill(parser, str, strlen(str));

   249     r = ucx_prop_parse(parser, &name, &value);

   250     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   252     str = "test1 ";

   253     ucx_prop_fill(parser, str, strlen(str));

   254     r = ucx_prop_parse(parser, &name, &value);

   255     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   257     str = "test2 test3 test4\n";

   258     sstr_t testv = sstr("test1 test2 test3 test4");

   259     ucx_prop_fill(parser, str, strlen(str));

   260     r = ucx_prop_parse(parser, &name, &value);

   261     UCX_TEST_ASSERT(r == 1, "parse returned 0");

   262     UCX_TEST_ASSERT((!sstrcmp(name, sstr("tests"))), "wrong name");

   263     UCX_TEST_ASSERT((!sstrcmp(value, testv)), "wrong value");

   265     // test if parse finds a name/value after a tmp comment

   266     str = "# just a comment";

   267     ucx_prop_fill(parser, str, strlen(str));

   268     r = ucx_prop_parse(parser, &name, &value);

   269     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   271     str = " in 3";

   272     ucx_prop_fill(parser, str, strlen(str));

   273     r = ucx_prop_parse(parser, &name, &value);

   274     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   276     str = " parts\na = 1\n";

   277     ucx_prop_fill(parser, str, strlen(str));

   278     r = ucx_prop_parse(parser, &name, &value);

   279     UCX_TEST_ASSERT(r == 1, "parse returned 0");

   280     UCX_TEST_ASSERT((!sstrcmp(name, sstr("a"))), "wrong name");

   281     UCX_TEST_ASSERT((!sstrcmp(value, sstr("1"))), "wrong value");

   283     UCX_TEST_END

   285     ucx_prop_free(parser);

   286 }

   288 UCX_TEST_IMPLEMENT(test_ucx_prop_parse_long) {

   289     UcxPropParser *parser = ucx_prop_new();

   290     int r;

   291     size_t name_len = 512;

   292     char *long_name = (char*)malloc(name_len);

   293     memset(long_name, 'a', 70);

   294     memset(long_name+70, 'b', 242);

   295     memset(long_name+312, 'c', 200);

   297     size_t value_len = 2048;

   298     char *long_value = (char*)malloc(value_len);

   299     memset(long_value, 'x', 1024);

   300     memset(long_value+1024, 'y', 1024);

   302     UCX_TEST_BEGIN

   304     sstr_t name;

   305     sstr_t value;

   307     ucx_prop_fill(parser, long_name, 10);

   308     r = ucx_prop_parse(parser, &name, &value);

   309     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   311     ucx_prop_fill(parser, long_name+10, 202);

   312     r = ucx_prop_parse(parser, &name, &value);

   313     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   315     ucx_prop_fill(parser, long_name+212, 200);

   316     r = ucx_prop_parse(parser, &name, &value);

   317     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   319     ucx_prop_fill(parser, long_name+412, 100);

   320     r = ucx_prop_parse(parser, &name, &value);

   321     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   323     char *str = " = ";

   324     ucx_prop_fill(parser, str, strlen(str));

   325     r = ucx_prop_parse(parser, &name, &value);

   326     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   328     ucx_prop_fill(parser, long_value, 512);

   329     r = ucx_prop_parse(parser, &name, &value);

   330     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   332     ucx_prop_fill(parser, long_value+512, 1024);

   333     r = ucx_prop_parse(parser, &name, &value);

   334     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   336     ucx_prop_fill(parser, long_value+1536, 512);

   337     r = ucx_prop_parse(parser, &name, &value);

   338     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   340     str = "\n#comment\nkey = value\n";

   341     ucx_prop_fill(parser, str, strlen(str));

   342     r = ucx_prop_parse(parser, &name, &value);

   343     sstr_t n = sstrn(long_name, name_len);

   344     sstr_t v = sstrn(long_value, value_len);

   345     UCX_TEST_ASSERT(r == 1, "parse returned 0");

   346     UCX_TEST_ASSERT((!sstrcmp(name, n)), "wrong name");

   347     UCX_TEST_ASSERT((!sstrcmp(value, v)), "wrong value");

   349     r = ucx_prop_parse(parser, &name, &value);

   350     UCX_TEST_ASSERT(r == 1, "parse returned 0");

   351     UCX_TEST_ASSERT((!sstrcmp(name, sstr("key"))), "wrong name");

   352     UCX_TEST_ASSERT((!sstrcmp(value, sstr("value"))), "wrong value");

   354     r = ucx_prop_parse(parser, &name, &value);

   355     UCX_TEST_ASSERT(r == 0, "parse returned 1");

   357     UCX_TEST_END

   359     free(long_name);

   360     free(long_value);

   361     ucx_prop_free(parser);

   362 }

Mercurial > hg > ucx / file revision

test/prop_tests.c@d2b1e67b2b48

test/prop_tests.c