unit1664.c - quickjs-tart - quickjs-based runtime for wallet-core logic

unit1664.c (11984B)
      1 /***************************************************************************
      2  *                                  _   _ ____  _
      3  *  Project                     ___| | | |  _ \| |
      4  *                             / __| | | | |_) | |
      5  *                            | (__| |_| |  _ <| |___
      6  *                             \___|\___/|_| \_\_____|
      7  *
      8  * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
      9  *
     10  * This software is licensed as described in the file COPYING, which
     11  * you should have received as part of this distribution. The terms
     12  * are also available at https://curl.se/docs/copyright.html.
     13  *
     14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
     15  * copies of the Software, and permit persons to whom the Software is
     16  * furnished to do so, under the terms of the COPYING file.
     17  *
     18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
     19  * KIND, either express or implied.
     20  *
     21  * SPDX-License-Identifier: curl
     22  *
     23  ***************************************************************************/
     24 #include "unitcheck.h"
     25 
     26 #ifdef HAVE_NETINET_IN_H
     27 #include <netinet/in.h>
     28 #endif
     29 #ifdef HAVE_NETINET_IN6_H
     30 #include <netinet/in6.h>
     31 #endif
     32 
     33 #include "memdebug.h" /* LAST include file */
     34 
     35 static CURLcode t1664_setup(void)
     36 {
     37   CURLcode res = CURLE_OK;
     38   global_init(CURL_GLOBAL_ALL);
     39   return res;
     40 }
     41 
     42 static CURLcode test_unit1664(char *arg)
     43 {
     44   UNITTEST_BEGIN(t1664_setup())
     45 
     46   static const char *wordparse[] = {
     47     "word",
     48     "word ",
     49     " word ",
     50     "wo rd",
     51     "word(",
     52     "wor(d",
     53     "perfect",
     54     "",
     55     "longerth",
     56     NULL
     57   };
     58 
     59   int i;
     60   printf("curlx_str_word\n");
     61   for(i = 0; wordparse[i]; i++) {
     62     struct Curl_str out;
     63     const char *line = wordparse[i];
     64     const char *orgline = line;
     65     int rc = curlx_str_word(&line, &out, 7);
     66     printf("%u: (\"%s\") %d, \"%.*s\" [%d], line %d\n",
     67            i, orgline, rc, (int)out.len, out.str, (int)out.len,
     68            (int)(line - orgline));
     69   }
     70 
     71   printf("curlx_str_until\n");
     72   for(i = 0; wordparse[i]; i++) {
     73     struct Curl_str out;
     74     const char *line = wordparse[i];
     75     const char *orgline = line;
     76     int rc = curlx_str_until(&line, &out, 7, 'd');
     77     printf("%u: (\"%s\") %d, \"%.*s\" [%d], line %d\n",
     78            i, orgline, rc, (int)out.len, out.str, (int)out.len,
     79            (int)(line - orgline));
     80   }
     81 
     82   {
     83     static const char *qwords[] = {
     84       "\"word\"",
     85       "\"word",
     86       "word\"",
     87       "\"word\"\"",
     88       "\"word\" ",
     89       " \"word\"",
     90       "\"perfect\"",
     91       "\"p r e t\"",
     92       "\"perfec\\\"",
     93       "\"\"",
     94       "",
     95       "\"longerth\"",
     96       NULL
     97     };
     98 
     99     printf("curlx_str_quotedword\n");
    100     for(i = 0; qwords[i]; i++) {
    101       struct Curl_str out;
    102       const char *line = qwords[i];
    103       const char *orgline = line;
    104       int rc = curlx_str_quotedword(&line, &out, 7);
    105       printf("%u: (\"%s\") %d, \"%.*s\" [%d], line %d\n",
    106              i, orgline, rc, (int)out.len, out.str, (int)out.len,
    107              (int)(line - orgline));
    108     }
    109   }
    110 
    111   {
    112     static const char *single[] = {
    113       "a",
    114       "aa",
    115       "A",
    116       "b",
    117       "\\",
    118       " ",
    119       "",
    120       NULL
    121     };
    122     printf("curlx_str_single\n");
    123     for(i = 0; single[i]; i++) {
    124       const char *line = single[i];
    125       const char *orgline = line;
    126       int rc = curlx_str_single(&line, 'a');
    127       printf("%u: (\"%s\") %d, line %d\n",
    128              i, orgline, rc, (int)(line - orgline));
    129     }
    130   }
    131   {
    132     static const char *single[] = {
    133       "a",
    134       "aa",
    135       "A",
    136       "b",
    137       "\\",
    138       " ",
    139       "\t",
    140       "\n",
    141       "",
    142       NULL
    143     };
    144     printf("curlx_str_singlespace\n");
    145     for(i = 0; single[i]; i++) {
    146       const char *line = single[i];
    147       const char *orgline = line;
    148       int rc = curlx_str_singlespace(&line);
    149       printf("%u: (\"%s\") %d, line %d\n",
    150              i, orgline, rc, (int)(line - orgline));
    151     }
    152   }
    153 
    154   {
    155     static const char *single[] = {
    156       "a",
    157       "aa",
    158       "A",
    159       "b",
    160       "\\",
    161       " ",
    162       "",
    163       NULL
    164     };
    165     printf("curlx_str_single\n");
    166     for(i = 0; single[i]; i++) {
    167       const char *line = single[i];
    168       const char *orgline = line;
    169       int rc = curlx_str_single(&line, 'a');
    170       printf("%u: (\"%s\") %d, line %d\n",
    171              i, orgline, rc, (int)(line - orgline));
    172     }
    173   }
    174   {
    175     static const char *nums[] = {
    176       "1",
    177       "10000",
    178       "1234",
    179       "1235",
    180       "1236",
    181       "01234",
    182       "00000000000000000000000000001234",
    183       "0123 345",
    184       "0123O345",
    185       "-12",
    186       " 123",
    187       "",
    188       NULL
    189     };
    190     printf("curlx_str_number\n");
    191     for(i = 0; nums[i]; i++) {
    192       curl_off_t num;
    193       const char *line = nums[i];
    194       const char *orgline = line;
    195       int rc = curlx_str_number(&line, &num, 1235);
    196       printf("%u: (\"%s\") %d, [%u] line %d\n",
    197              i, orgline, rc, (int)num, (int)(line - orgline));
    198     }
    199   }
    200 
    201   {
    202     struct t {
    203       const char *str;
    204       curl_off_t max;
    205     };
    206     static struct t nums[] = {
    207       { "00", 8},
    208       { "1", 8},
    209       { "1", 1},
    210       { "2", 1},
    211       { "2", 2},
    212       { "5", 6},
    213       { "000000000000000000000006", 6},
    214       { "7", 6},
    215       { "8", 6},
    216       { "9", 8},
    217       { "10", 10},
    218       { "11", 10},
    219       { "12", 10},
    220       {NULL, 0}
    221     };
    222     printf("curlx_str_number varying max\n");
    223     for(i = 0; nums[i].str; i++) {
    224       curl_off_t num;
    225       const char *line = nums[i].str;
    226       const char *orgline = line;
    227       int rc = curlx_str_number(&line, &num, nums[i].max);
    228       curl_mprintf("%u: (\"%s\") max %" CURL_FORMAT_CURL_OFF_T
    229                    " == %d, [%" CURL_FORMAT_CURL_OFF_T "]\n",
    230                    i, orgline, nums[i].max, rc, num);
    231     }
    232   }
    233 
    234   {
    235     struct t {
    236       const char *str;
    237       curl_off_t max;
    238     };
    239     static struct t nums[] = {
    240       { "00", 8},
    241       { "1", 8},
    242       { "1", 1},
    243       { "2", 1},
    244       { "2", 2},
    245       { "5", 6},
    246       { "000000000000000000000006", 6},
    247       { "7", 6},
    248       { "8", 6},
    249       { "9", 8},
    250       { "a", 14},
    251       { "b", 14},
    252       { "c", 14},
    253       { "d", 14},
    254       { "e", 14},
    255       { "f", 14},
    256       { "f", 15},
    257       { "10", 16},
    258       { "11", 16},
    259       { "12", 16},
    260       {NULL, 0}
    261     };
    262     printf("curlx_str_hex varying max\n");
    263     for(i = 0; nums[i].str; i++) {
    264       curl_off_t num;
    265       const char *line = nums[i].str;
    266       const char *orgline = line;
    267       int rc = curlx_str_hex(&line, &num, nums[i].max);
    268       curl_mprintf("%u: (\"%s\") max %" CURL_FORMAT_CURL_OFF_T
    269                    " == %d, [%" CURL_FORMAT_CURL_OFF_T "]\n",
    270                    i, orgline, nums[i].max, rc, num);
    271     }
    272   }
    273 
    274   {
    275     struct t {
    276       const char *str;
    277       curl_off_t max;
    278     };
    279     static struct t nums[] = {
    280       { "00", 4},
    281       { "1", 4},
    282       { "1", 4},
    283       { "2", 4},
    284       { "3", 4},
    285       { "4", 4},
    286       { "5", 4},
    287       { "000000000000000000000006", 6},
    288       { "7", 7},
    289       { "10", 8},
    290       { "11", 8},
    291       { "11", 9},
    292       { "12", 9},
    293       { "13", 9},
    294       { "8", 10},
    295       {NULL, 0}
    296     };
    297     printf("curlx_str_octal varying max\n");
    298     for(i = 0; nums[i].str; i++) {
    299       curl_off_t num;
    300       const char *line = nums[i].str;
    301       const char *orgline = line;
    302       int rc = curlx_str_octal(&line, &num, nums[i].max);
    303       curl_mprintf("%u: (\"%s\") max %" CURL_FORMAT_CURL_OFF_T
    304                    " == %d, [%" CURL_FORMAT_CURL_OFF_T "]\n",
    305                    i, orgline, nums[i].max, rc, num);
    306     }
    307   }
    308 
    309   {
    310     /* CURL_OFF_T is typically 9223372036854775807 */
    311     static const char *nums[] = {
    312       "9223372036854775807", /* 2^63 -1 */
    313       "9223372036854775808", /* 2^63  */
    314       "18446744073709551615", /* 2^64 - 1 */
    315       "18446744073709551616", /* 2^64 */
    316       "18446744073709551617", /* 2^64 + 1 */
    317       "0123456799a",
    318       "0123456789",
    319       "123498760b",
    320       "1234987607611298232",
    321       "1111111111111111111",
    322       "2222222222222222222",
    323       "00000000000000000000000000000009223372036854775807",
    324       "3333333333333333333",
    325       "4444444444444444444",
    326       "5555555555555555555",
    327       "6666666666666666666",
    328       "7777777777777777777",
    329       "8888888888888888888",
    330       "999999999999999999",
    331       NULL
    332     };
    333     printf("curlx_str_number / max\n");
    334     for(i = 0; nums[i]; i++) {
    335       curl_off_t num;
    336       const char *line = nums[i];
    337       const char *orgline = line;
    338       int rc = curlx_str_number(&line, &num, CURL_OFF_T_MAX);
    339       curl_mprintf("%u: (\"%s\") %d, [%" CURL_FORMAT_CURL_OFF_T "] line %d\n",
    340                    i, orgline, rc, num, (int)(line - orgline));
    341     }
    342   }
    343 
    344   {
    345     static const char *newl[] = {
    346       "a",
    347       "aa",
    348       "A",
    349       "b",
    350       "\\",
    351       " ",
    352       "\n",
    353       "\r",
    354       "\r\n",
    355       "\x0c",
    356       "",
    357       NULL
    358     };
    359     printf("curlx_str_newline\n");
    360     for(i = 0; newl[i]; i++) {
    361       const char *line = newl[i];
    362       const char *orgline = line;
    363       int rc = curlx_str_newline(&line);
    364       curl_mprintf("%u: (%%%02x) %d, line %d\n",
    365                    i, *orgline, rc, (int)(line - orgline));
    366     }
    367   }
    368 
    369   {
    370     static const char *nums[] = {
    371       "1",
    372       "1000",
    373       "1234",
    374       "1235",
    375       "1236",
    376       "01234",
    377       "00000000000000000000000000001234",
    378       "0123 345",
    379       "0123O345",
    380       "-12",
    381       " 123",
    382       "",
    383       NULL
    384     };
    385     printf("curlx_str_hex\n");
    386     for(i = 0; nums[i]; i++) {
    387       curl_off_t num;
    388       const char *line = nums[i];
    389       const char *orgline = line;
    390       int rc = curlx_str_hex(&line, &num, 0x1235);
    391       curl_mprintf("%u: (\"%s\") %d, [%u] line %d\n",
    392                    i, orgline, rc, (int)num, (int)(line - orgline));
    393     }
    394   }
    395 
    396   {
    397     static const char *nums[] = {
    398       "1",
    399       "1000",
    400       "1234",
    401       "1235",
    402       "1236",
    403       "01234",
    404       "00000000000000000000000000001234",
    405       "0123 345",
    406       "0123O345",
    407       "-12",
    408       " 123",
    409       "",
    410       NULL
    411     };
    412     printf("curlx_str_octal\n");
    413     for(i = 0; nums[i]; i++) {
    414       curl_off_t num;
    415       const char *line = nums[i];
    416       const char *orgline = line;
    417       int rc = curlx_str_octal(&line, &num, 01235);
    418       curl_mprintf("%u: (\"%s\") %d, [%u] line %d\n",
    419                    i, orgline, rc, (int)num, (int)(line - orgline));
    420     }
    421   }
    422 
    423   {
    424     /* CURL_OFF_T is typically 2^63-1 */
    425     static const char *nums[] = {
    426       "777777777777777777777", /* 2^63 -1 */
    427       "1000000000000000000000", /* 2^63  */
    428       "111111111111111111111",
    429       "222222222222222222222",
    430       "333333333333333333333",
    431       "444444444444444444444",
    432       "555555555555555555555",
    433       "666666666666666666666",
    434       NULL
    435     };
    436     printf("curlx_str_octal / max\n");
    437     for(i = 0; nums[i]; i++) {
    438       curl_off_t num;
    439       const char *line = nums[i];
    440       const char *orgline = line;
    441       int rc = curlx_str_octal(&line, &num, CURL_OFF_T_MAX);
    442       curl_mprintf("%u: (\"%s\") %d, [%" CURL_FORMAT_CURL_OFF_T "] line %d\n",
    443                    i, orgline, rc, num, (int)(line - orgline));
    444     }
    445   }
    446 
    447   {
    448     /* CURL_OFF_T is typically 2^63-1 */
    449     static const char *nums[] = {
    450       "7FFFFFFFFFFFFFFF", /* 2^63 -1 */
    451       "8000000000000000", /* 2^63  */
    452       "1111111111111111",
    453       "2222222222222222",
    454       "3333333333333333",
    455       "4444444444444444",
    456       "5555555555555555",
    457       "6666666666666666",
    458       "7777777777777777",
    459       "888888888888888",
    460       "999999999999999",
    461       "aaaaaaaaAAAAAAA",
    462       "bbbbbbbbBBBBBBB",
    463       "BBBBBBBBbbbbbbb",
    464       "ccccccccCCCCCCC",
    465       "ddddddddDDDDDDD",
    466       "eeeeeeeeEEEEEEE",
    467       "ffffffffFFFFFFF",
    468       "abcdef",
    469       "ABCDEF",
    470       NULL
    471     };
    472     printf("curlx_str_hex / max\n");
    473     for(i = 0; nums[i]; i++) {
    474       curl_off_t num;
    475       const char *line = nums[i];
    476       const char *orgline = line;
    477       int rc = curlx_str_hex(&line, &num, CURL_OFF_T_MAX);
    478       curl_mprintf("%u: (\"%s\") %d, [%" CURL_FORMAT_CURL_OFF_T "] line %d\n",
    479                    i, orgline, rc, num, (int)(line - orgline));
    480     }
    481   }
    482 
    483   UNITTEST_END(curl_global_cleanup())
    484 }
	quickjs-tart quickjs-based runtime for wallet-core logic
	Log \| Files \| Refs \| README \| LICENSE