wsutil/test_wsutil.c

   1 /*
   2  * Wireshark - Network traffic analyzer
   3  * By Gerald Combs <gerald@wireshark.org>
   4  * Copyright 1998 Gerald Combs
   5  *
   6  * SPDX-License-Identifier: GPL-2.0-or-later
   7  */
   8
   9 #include "config.h"
  10
  11 #include <stdio.h>
  12 #include <glib.h>
  13 #include <wsutil/utf8_entities.h>
  14 #include <wsutil/time_util.h>
  15 #include <wsutil/to_str.h>
  16
  17 #include "inet_addr.h"
  18
  19 #define PROGNAME "test_wsutil"
  20
  21 static void test_inet_pton4_test1(void)
  22 {
  23     const char *str;
  24     bool ok;
  25     ws_in4_addr result, expect;
  26
  27     str = "198.51.100.200";
  28     expect = g_htonl(3325256904);
  29     ok = ws_inet_pton4(str, &result);
  30     g_assert_true(ok);
  31     g_assert_cmpint(result, ==, expect);
  32 }
  33
  34 static void test_inet_ntop4_test1(void)
  35 {
  36     char result[WS_INET_ADDRSTRLEN];
  37     const char *expect, *ptr;
  38     ws_in4_addr addr;
  39
  40     addr = g_htonl(3325256904);
  41     expect = "198.51.100.200";
  42     ptr = ws_inet_ntop4(&addr, result, sizeof(result));
  43     g_assert_true(ptr == result);
  44     g_assert_cmpstr(result, ==, expect);
  45 }
  46
  47 struct in6_test {
  48     char str[WS_INET6_ADDRSTRLEN];
  49     ws_in6_addr addr;
  50 };
  51
  52 static const struct in6_test in6_test1 = {
  53     .str = "2001:db8:ffaa:ddbb:1199:2288:3377:1",
  54     .addr = { { 0x20, 0x01, 0x0d, 0xb8, 0xff, 0xaa, 0xdd, 0xbb,
  55                 0x11, 0x99, 0x22, 0x88, 0x33, 0x77, 0x00, 0x01 } }
  56 };
  57
  58 static void test_inet_pton6_test1(void)
  59 {
  60     bool ok;
  61     ws_in6_addr result;
  62
  63     ok = ws_inet_pton6(in6_test1.str, &result);
  64     g_assert_true(ok);
  65     g_assert_cmpmem(&result, sizeof(result), &in6_test1.addr, sizeof(in6_test1.addr));
  66 }
  67
  68 static void test_inet_ntop6_test1(void)
  69 {
  70     char result[WS_INET6_ADDRSTRLEN];
  71     const char *ptr;
  72
  73     ptr = ws_inet_ntop6(&in6_test1.addr, result, sizeof(result));
  74     g_assert_true(ptr == result);
  75     g_assert_cmpstr(result, ==, in6_test1.str);
  76 }
  77
  78 static void test_ip_addr_to_str_test1(void)
  79 {
  80     char result[WS_INET_ADDRSTRLEN];
  81     const char *expect;
  82     ws_in4_addr addr;
  83
  84     addr = g_htonl(3325256904);
  85     expect = "198.51.100.200";
  86     ip_addr_to_str_buf(&addr, result, sizeof(result));
  87
  88     g_assert_cmpstr(result, ==, expect);
  89 }
  90
  91 #include "str_util.h"
  92
  93 static void test_format_size(void)
  94 {
  95     char *str;
  96
  97     str = format_size(10000, FORMAT_SIZE_UNIT_BYTES, FORMAT_SIZE_PREFIX_SI);
  98     g_assert_cmpstr(str, ==, "10 kB");
  99     g_free(str);
 100
 101     str = format_size(100000, FORMAT_SIZE_UNIT_BYTES, FORMAT_SIZE_PREFIX_IEC);
 102     g_assert_cmpstr(str, ==, "97 KiB");
 103     g_free(str);
 104
 105     str = format_size(20971520, FORMAT_SIZE_UNIT_BITS, FORMAT_SIZE_PREFIX_IEC);
 106     g_assert_cmpstr(str, ==, "20 Mib");
 107     g_free(str);
 108 }
 109
 110 static void test_escape_string(void)
 111 {
 112     char *buf;
 113
 114     buf = ws_escape_string(NULL, "quoted \"\\\" backslash", true);
 115     g_assert_cmpstr(buf, ==, "\"quoted \\\"\\\\\\\" backslash\"");
 116     wmem_free(NULL, buf);
 117
 118     buf = ws_escape_string(NULL, "whitespace \t \n \r \f \v", true);
 119     g_assert_cmpstr(buf, ==, "\"whitespace \\t \\n \\r \\f \\v""\"");
 120     wmem_free(NULL, buf);
 121
 122     const char s1[] = { 'a', 'b', 'c', '\0', 'e', 'f', 'g'};
 123     buf = ws_escape_null(NULL, s1, sizeof(s1), true);
 124     g_assert_cmpstr(buf, ==, "\"abc\\0efg\"");
 125     wmem_free(NULL, buf);
 126
 127     const char s2[] = { 'a', 'b', 'c', '\0', '"', 'e', 'f', 'g'};
 128     buf = ws_escape_null(NULL, s2, sizeof(s2), true);
 129     g_assert_cmpstr(buf, ==, "\"abc\\0\\\"efg\"");
 130     wmem_free(NULL, buf);
 131
 132     buf = ws_escape_csv(NULL, "CSV-style \" escape", true, '"', true, false);
 133     g_assert_cmpstr(buf, ==, "\"CSV-style \"\" escape\"");
 134     wmem_free(NULL, buf);
 135 }
 136
 137 static void test_strconcat(void)
 138 {
 139     wmem_allocator_t   *allocator;
 140     char               *new_str;
 141
 142     allocator = wmem_allocator_new(WMEM_ALLOCATOR_BLOCK);
 143
 144     new_str = wmem_strconcat(allocator, "ABC", NULL);
 145     g_assert_cmpstr(new_str, ==, "ABC");
 146
 147     new_str = wmem_strconcat(allocator, "ABC", "DEF", NULL);
 148     g_assert_cmpstr(new_str, ==, "ABCDEF");
 149
 150     new_str = wmem_strconcat(allocator, "", "", "ABCDEF", "", "GH", NULL);
 151     g_assert_cmpstr(new_str, ==, "ABCDEFGH");
 152
 153     wmem_destroy_allocator(allocator);
 154 }
 155
 156 static void test_strsplit(void)
 157 {
 158     wmem_allocator_t   *allocator;
 159     char              **split_str;
 160
 161     allocator = wmem_allocator_new(WMEM_ALLOCATOR_BLOCK);
 162
 163     split_str = wmem_strsplit(allocator, "A-C", "-", 2);
 164     g_assert_cmpstr(split_str[0], ==, "A");
 165     g_assert_cmpstr(split_str[1], ==, "C");
 166     g_assert_null(split_str[2]);
 167
 168     split_str = wmem_strsplit(allocator, "A-C", "-", 0);
 169     g_assert_cmpstr(split_str[0], ==, "A");
 170     g_assert_cmpstr(split_str[1], ==, "C");
 171     g_assert_null(split_str[2]);
 172
 173     split_str = wmem_strsplit(allocator, "--aslkf-asio--asfj-as--", "-", 10);
 174     g_assert_cmpstr(split_str[0], ==, "");
 175     g_assert_cmpstr(split_str[1], ==, "");
 176     g_assert_cmpstr(split_str[2], ==, "aslkf");
 177     g_assert_cmpstr(split_str[3], ==, "asio");
 178     g_assert_cmpstr(split_str[4], ==, "");
 179     g_assert_cmpstr(split_str[5], ==, "asfj");
 180     g_assert_cmpstr(split_str[6], ==, "as");
 181     g_assert_cmpstr(split_str[7], ==, "");
 182     g_assert_cmpstr(split_str[8], ==, "");
 183     g_assert_null(split_str[9]);
 184
 185     split_str = wmem_strsplit(allocator, "--aslkf-asio--asfj-as--", "-", 5);
 186     g_assert_cmpstr(split_str[0], ==, "");
 187     g_assert_cmpstr(split_str[1], ==, "");
 188     g_assert_cmpstr(split_str[2], ==, "aslkf");
 189     g_assert_cmpstr(split_str[3], ==, "asio");
 190     g_assert_cmpstr(split_str[4], ==, "-asfj-as--");
 191     g_assert_null(split_str[5]);
 192
 193     split_str = wmem_strsplit(allocator, "", "-", -1);
 194     g_assert_null(split_str[0]);
 195
 196     wmem_destroy_allocator(allocator);
 197 }
 198
 199 static void test_str_ascii(void)
 200 {
 201     wmem_allocator_t   *allocator;
 202     const char         *orig_str;
 203     char               *new_str;
 204
 205     allocator = wmem_allocator_new(WMEM_ALLOCATOR_BLOCK);
 206
 207     orig_str = "TeStAsCiIsTrDoWn";
 208     new_str = wmem_ascii_strdown(allocator, orig_str, -1);
 209     g_assert_cmpstr(new_str, ==, "testasciistrdown");
 210
 211     wmem_destroy_allocator(allocator);
 212 }
 213
 214 static void test_format_text(void)
 215 {
 216     const char *have, *want;
 217     char *res;
 218
 219     /* ASCII */
 220     have = "abcdef";
 221     want = "abcdef";
 222     res = format_text_string(NULL, have);
 223     g_assert_cmpstr(res, ==, want);
 224     g_free(res);
 225
 226     /* ASCII with special escape characters. */
 227     have = "abc\td\fe\nf";
 228     want = "abc\\td\\fe\\nf";
 229     res = format_text_string(NULL, have);
 230     g_assert_cmpstr(res, ==, want);
 231     g_free(res);
 232
 233     /* ASCII with non-printable characters. */
 234     have = "abc \004 def";
 235     want = "abc \\004 def";
 236     res = format_text_string(NULL, have);
 237     g_assert_cmpstr(res, ==, want);
 238     g_free(res);
 239
 240     /* UTF-8 */
 241     have = u8"Γαζέες καὶ μυρτιὲς δὲν θὰ βρῶ πιὰ στὸ χρυσαφὶ ξέφωτο";
 242     want = u8"Γαζέες καὶ μυρτιὲς δὲν θὰ βρῶ πιὰ στὸ χρυσαφὶ ξέφωτο";
 243     res = format_text_string(NULL, have);
 244     g_assert_cmpstr(res, ==, want);
 245     g_free(res);
 246
 247     /* UTF-8 with non-ASCII non-printable characters. */
 248     have = u8"String with BOM \ufeff";
 249     want = u8"String with BOM \\uFEFF";
 250     res = format_text_string(NULL, have);
 251     g_assert_cmpstr(res, ==, want);
 252     g_free(res);
 253
 254 }
 255
 256 #define RESOURCE_USAGE_START get_resource_usage(&start_utime, &start_stime)
 257
 258 #define RESOURCE_USAGE_END \
 259     get_resource_usage(&end_utime, &end_stime); \
 260     utime_ms = (end_utime - start_utime) * 1000.0; \
 261     stime_ms = (end_stime - start_stime) * 1000.0
 262
 263 static void test_format_text_perf(void)
 264 {
 265 #define LOOP_COUNT (1 * 1000 * 1000)
 266     char               *str;
 267     int                 i;
 268     double              start_utime, start_stime, end_utime, end_stime, utime_ms, stime_ms;
 269
 270     const char *text = "The quick brown fox\tjumps over the lazy \001dog"UTF8_HORIZONTAL_ELLIPSIS"\n";
 271
 272     RESOURCE_USAGE_START;
 273     for (i = 0; i < LOOP_COUNT; i++) {
 274         str = format_text_string(NULL, text);
 275         g_free(str);
 276     }
 277     RESOURCE_USAGE_END;
 278     g_test_minimized_result(utime_ms + stime_ms,
 279         "format_text_string(): u %.3f ms s %.3f ms", utime_ms, stime_ms);
 280 }
 281
 282 #include "to_str.h"
 283
 284 static void test_word_to_hex(void)
 285 {
 286     static char buf[32];
 287     char *str;     /* String is not NULL terminated. */
 288
 289     str = uint8_to_hex(buf, 0x34);
 290     g_assert_true(str == buf + 2);
 291     g_assert_cmpint(str[-1], ==, '4');
 292     g_assert_cmpint(str[-2], ==, '3');
 293
 294     str = word_to_hex(buf, 0x1234);
 295     g_assert_true(str == buf + 4);
 296     g_assert_cmpint(str[-1], ==, '4');
 297     g_assert_cmpint(str[-2], ==, '3');
 298     g_assert_cmpint(str[-3], ==, '2');
 299     g_assert_cmpint(str[-4], ==, '1');
 300
 301     str = dword_to_hex(buf, 0x1234);
 302     g_assert_true(str == buf + 8);
 303     g_assert_cmpint(str[-1], ==, '4');
 304     g_assert_cmpint(str[-2], ==, '3');
 305     g_assert_cmpint(str[-3], ==, '2');
 306     g_assert_cmpint(str[-4], ==, '1');
 307     g_assert_cmpint(str[-5], ==, '0');
 308     g_assert_cmpint(str[-6], ==, '0');
 309     g_assert_cmpint(str[-7], ==, '0');
 310     g_assert_cmpint(str[-8], ==, '0');
 311
 312     str = qword_to_hex(buf, UINT64_C(0xFEDCBA987654321));
 313     g_assert_true(str == buf + 16);
 314     g_assert_cmpint(str[-1], ==, '1');
 315     g_assert_cmpint(str[-2], ==, '2');
 316     g_assert_cmpint(str[-3], ==, '3');
 317     g_assert_cmpint(str[-4], ==, '4');
 318     g_assert_cmpint(str[-5], ==, '5');
 319     g_assert_cmpint(str[-6], ==, '6');
 320     g_assert_cmpint(str[-7], ==, '7');
 321     g_assert_cmpint(str[-8], ==, '8');
 322     g_assert_cmpint(str[-9], ==, '9');
 323     g_assert_cmpint(str[-10], ==, 'a');
 324     g_assert_cmpint(str[-11], ==, 'b');
 325     g_assert_cmpint(str[-12], ==, 'c');
 326     g_assert_cmpint(str[-13], ==, 'd');
 327     g_assert_cmpint(str[-14], ==, 'e');
 328     g_assert_cmpint(str[-15], ==, 'f');
 329     g_assert_cmpint(str[-16], ==, '0');
 330 }
 331
 332 static void test_bytes_to_str(void)
 333 {
 334     char *str;
 335
 336     const uint8_t buf[] = { 1, 2, 3};
 337
 338     str = bytes_to_str(NULL, buf, sizeof(buf));
 339     g_assert_cmpstr(str, ==, "010203");
 340     g_free(str);
 341 }
 342
 343 static void test_bytes_to_str_punct(void)
 344 {
 345     char *str;
 346
 347     const uint8_t buf[] = { 1, 2, 3};
 348
 349     str = bytes_to_str_punct(NULL, buf, sizeof(buf), ':');
 350     g_assert_cmpstr(str, ==, "01:02:03");
 351     g_free(str);
 352 }
 353
 354 static void test_bytes_to_str_punct_maxlen(void)
 355 {
 356     char *str;
 357
 358     const uint8_t buf[] = { 1, 2, 3};
 359
 360     str = bytes_to_str_punct_maxlen(NULL, buf, sizeof(buf), ':', 4);
 361     g_assert_cmpstr(str, ==, "01:02:03");
 362     g_free(str);
 363
 364     str = bytes_to_str_punct_maxlen(NULL, buf, sizeof(buf), ':', 3);
 365     g_assert_cmpstr(str, ==, "01:02:03");
 366     g_free(str);
 367
 368     str = bytes_to_str_punct_maxlen(NULL, buf, sizeof(buf), ':', 2);
 369     g_assert_cmpstr(str, ==, "01:02:" UTF8_HORIZONTAL_ELLIPSIS);
 370     g_free(str);
 371
 372     str = bytes_to_str_punct_maxlen(NULL, buf, sizeof(buf), ':', 1);
 373     g_assert_cmpstr(str, ==, "01:" UTF8_HORIZONTAL_ELLIPSIS);
 374     g_free(str);
 375
 376     str = bytes_to_str_punct_maxlen(NULL, buf, sizeof(buf), ':', 0);
 377     g_assert_cmpstr(str, ==, "01:02:03");
 378     g_free(str);
 379 }
 380
 381 static void test_bytes_to_str_maxlen(void)
 382 {
 383     char *str;
 384
 385     const uint8_t buf[] = { 1, 2, 3};
 386
 387     str = bytes_to_str_maxlen(NULL, buf, sizeof(buf), 4);
 388     g_assert_cmpstr(str, ==, "010203");
 389     g_free(str);
 390
 391     str = bytes_to_str_maxlen(NULL, buf, sizeof(buf), 3);
 392     g_assert_cmpstr(str, ==, "010203");
 393     g_free(str);
 394
 395     str = bytes_to_str_maxlen(NULL, buf, sizeof(buf), 2);
 396     g_assert_cmpstr(str, ==, "0102" UTF8_HORIZONTAL_ELLIPSIS);
 397     g_free(str);
 398
 399     str = bytes_to_str_maxlen(NULL, buf, sizeof(buf), 1);
 400     g_assert_cmpstr(str, ==, "01" UTF8_HORIZONTAL_ELLIPSIS);
 401     g_free(str);
 402
 403     str = bytes_to_str_maxlen(NULL, buf, sizeof(buf), 0);
 404     g_assert_cmpstr(str, ==, "010203");
 405     g_free(str);
 406 }
 407
 408 static void test_bytes_to_string_trunc1(void)
 409 {
 410     char *str;
 411
 412     const uint8_t buf[] = {
 413         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA,
 414         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA,
 415         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA,
 416         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA,
 417         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA,
 418         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA,
 419         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA
 420     };
 421     const char *expect =
 422         "112233445566778899aa"
 423         "112233445566778899aa"
 424         "112233445566778899aa"
 425         "112233445566" UTF8_HORIZONTAL_ELLIPSIS;
 426
 427     str = bytes_to_str(NULL, buf, sizeof(buf));
 428     g_assert_cmpstr(str, ==, expect);
 429     g_free(str);
 430 }
 431
 432 static void test_bytes_to_string_punct_trunc1(void)
 433 {
 434     char *str;
 435
 436     const uint8_t buf[] = {
 437         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA,
 438         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA,
 439         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA,
 440         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA,
 441         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA,
 442         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA,
 443         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA
 444     };
 445     const char *expect =
 446         "11:22:33:44:55:66:77:88:99:aa:"
 447         "11:22:33:44:55:66:77:88:99:aa:"
 448         "11:22:33:44:" UTF8_HORIZONTAL_ELLIPSIS;
 449
 450     str = bytes_to_str_punct(NULL, buf, sizeof(buf), ':');
 451     g_assert_cmpstr(str, ==, expect);
 452     g_free(str);
 453 }
 454
 455 static char to_str_back_buf[32];
 456 #define BACK_PTR (&to_str_back_buf[31]) /* pointer to NUL string terminator */
 457
 458 static void test_oct_to_str_back(void)
 459 {
 460     char *str;
 461
 462     str = oct_to_str_back(BACK_PTR, 958769886);
 463     g_assert_cmpstr(str,  ==, "07111325336");
 464
 465     str = oct_to_str_back(BACK_PTR, 781499127);
 466     g_assert_cmpstr(str,  ==, "05645135367");
 467
 468     str = oct_to_str_back(BACK_PTR, 1177329882);
 469     g_assert_cmpstr(str, ==, "010613120332");
 470 }
 471
 472 static void test_oct64_to_str_back(void)
 473 {
 474     char *str;
 475
 476     str = oct64_to_str_back(BACK_PTR, UINT64_C(13873797580070999420));
 477     g_assert_cmpstr(str, ==, "01402115026217563452574");
 478
 479     str = oct64_to_str_back(BACK_PTR, UINT64_C(7072159458371400691));
 480     g_assert_cmpstr(str, ==, "0610452670726711271763");
 481
 482     str = oct64_to_str_back(BACK_PTR, UINT64_C(12453513102400590374));
 483     g_assert_cmpstr(str, ==, "01263236102754220511046");
 484 }
 485
 486 static void test_hex_to_str_back_len(void)
 487 {
 488     char *str;
 489
 490     str = hex_to_str_back_len(BACK_PTR, 2481, 8);
 491     g_assert_cmpstr(str, ==, "0x000009b1");
 492
 493     str = hex_to_str_back_len(BACK_PTR, 2457, 8);
 494     g_assert_cmpstr(str, ==, "0x00000999");
 495
 496     str = hex_to_str_back_len(BACK_PTR, 16230, 8);
 497     g_assert_cmpstr(str, ==, "0x00003f66");
 498 }
 499
 500 static void test_hex64_to_str_back_len(void)
 501 {
 502     char *str;
 503
 504     str = hex64_to_str_back_len(BACK_PTR, UINT64_C(1), 16);
 505     g_assert_cmpstr(str, ==, "0x0000000000000001");
 506
 507     str = hex64_to_str_back_len(BACK_PTR, UINT64_C(4294967295), 16);
 508     g_assert_cmpstr(str, ==, "0x00000000ffffffff");
 509
 510     str = hex64_to_str_back_len(BACK_PTR, UINT64_C(18446744073709551615), 16);
 511     g_assert_cmpstr(str, ==, "0xffffffffffffffff");
 512 }
 513
 514 static void test_uint_to_str_back(void)
 515 {
 516     char *str;
 517
 518     str = uint_to_str_back(BACK_PTR, 873735883);
 519     g_assert_cmpstr(str, ==, "873735883");
 520
 521     str = uint_to_str_back(BACK_PTR, 1801148094);
 522     g_assert_cmpstr(str, ==, "1801148094");
 523
 524     str = uint_to_str_back(BACK_PTR, 181787997);
 525     g_assert_cmpstr(str, ==, "181787997");
 526 }
 527
 528 static void test_uint64_to_str_back(void)
 529 {
 530     char *str;
 531
 532     str = uint64_to_str_back(BACK_PTR, UINT64_C(585143757104211265));
 533     g_assert_cmpstr(str, ==, "585143757104211265");
 534
 535     str = uint64_to_str_back(BACK_PTR, UINT64_C(7191580247919484847));
 536     g_assert_cmpstr(str, ==, "7191580247919484847");
 537
 538     str = uint64_to_str_back(BACK_PTR, UINT64_C(95778573911934485));
 539     g_assert_cmpstr(str, ==, "95778573911934485");
 540 }
 541
 542 static void test_uint_to_str_back_len(void)
 543 {
 544     char *str;
 545
 546     str = uint_to_str_back_len(BACK_PTR, 26630, 8);
 547     g_assert_cmpstr(str, ==, "00026630");
 548
 549     str = uint_to_str_back_len(BACK_PTR, 25313, 8);
 550     g_assert_cmpstr(str, ==, "00025313");
 551
 552     str = uint_to_str_back_len(BACK_PTR, 18750000, 8);
 553     g_assert_cmpstr(str, ==, "18750000");
 554 }
 555
 556 static void test_uint64_to_str_back_len(void)
 557 {
 558     char *str;
 559
 560     str = uint64_to_str_back_len(BACK_PTR, UINT64_C(1), 16);
 561     g_assert_cmpstr(str, ==, "0000000000000001");
 562
 563     str = uint64_to_str_back_len(BACK_PTR, UINT64_C(4294967295), 16);
 564     g_assert_cmpstr(str, ==, "0000004294967295");
 565
 566     str = uint64_to_str_back_len(BACK_PTR, UINT64_C(18446744073709551615), 16);
 567     g_assert_cmpstr(str, ==, "18446744073709551615");
 568 }
 569
 570 static void test_int_to_str_back(void)
 571 {
 572     char *str;
 573
 574     str = int_to_str_back(BACK_PTR, -763689611);
 575     g_assert_cmpstr(str, ==, "-763689611");
 576
 577     str = int_to_str_back(BACK_PTR, -296015954);
 578     g_assert_cmpstr(str, ==, "-296015954");
 579
 580     str = int_to_str_back(BACK_PTR, 898901469);
 581     g_assert_cmpstr(str, ==, "898901469");
 582 }
 583
 584 static void test_int64_to_str_back(void)
 585 {
 586     char *str;
 587
 588     str = int64_to_str_back(BACK_PTR, INT64_C(-9223372036854775807));
 589     g_assert_cmpstr(str, ==, "-9223372036854775807");
 590
 591     str = int64_to_str_back(BACK_PTR, INT64_C(1));
 592     g_assert_cmpstr(str, ==, "1");
 593
 594     str = int64_to_str_back(BACK_PTR, INT64_C(9223372036854775807));
 595     g_assert_cmpstr(str, ==, "9223372036854775807");
 596 }
 597
 598 #include "nstime.h"
 599 #include "time_util.h"
 600
 601 void test_nstime_from_iso8601(void)
 602 {
 603     char *str;
 604     const char *endp;
 605     nstime_t result, expect;
 606     struct tm tm1;
 607
 608     memset(&tm1, 0, sizeof(tm1));
 609     tm1.tm_sec = 25;
 610     tm1.tm_min = 45;
 611     tm1.tm_hour = 23;
 612     tm1.tm_mday = 30;
 613     tm1.tm_mon = 4; /* starts at zero */
 614     tm1.tm_year = 2013 - 1900;
 615     tm1.tm_isdst = -1;
 616
 617     /* Date and time with local time. */
 618     str = "2013-05-30T23:45:25.349124";
 619     expect.secs = mktime(&tm1);
 620     expect.nsecs = 349124 * 1000;
 621     endp = iso8601_to_nstime(&result, str, ISO8601_DATETIME_AUTO);
 622     g_assert_nonnull(endp);
 623     g_assert(*endp == '\0');
 624     g_assert_cmpint(result.secs, ==, expect.secs);
 625     g_assert_cmpint(result.nsecs, ==, expect.nsecs);
 626
 627     /* Date and time with UTC timezone. */
 628     str = "2013-05-30T23:45:25.349124Z";
 629     expect.secs = mktime_utc(&tm1);
 630     expect.nsecs = 349124 * 1000;
 631     endp = iso8601_to_nstime(&result, str, ISO8601_DATETIME_AUTO);
 632     g_assert_nonnull(endp);
 633     g_assert(*endp == '\0');
 634     g_assert_cmpint(result.secs, ==, expect.secs);
 635     g_assert_cmpint(result.nsecs, ==, expect.nsecs);
 636
 637     /* Date and time with timezone offset with separator. */
 638     str = "2013-05-30T23:45:25.349124+01:00";
 639     expect.secs = mktime_utc(&tm1) - 1 * 60 * 60;
 640     expect.nsecs = 349124 * 1000;
 641     endp = iso8601_to_nstime(&result, str, ISO8601_DATETIME_AUTO);
 642     g_assert_nonnull(endp);
 643     g_assert(*endp == '\0');
 644     g_assert_cmpint(result.secs, ==, expect.secs);
 645     g_assert_cmpint(result.nsecs, ==, expect.nsecs);
 646
 647     /* Date and time with timezone offset without separator. */
 648     str = "2013-05-30T23:45:25.349124+0100";
 649     expect.secs = mktime_utc(&tm1) - 1 * 60 * 60;
 650     expect.nsecs = 349124 * 1000;
 651     endp = iso8601_to_nstime(&result, str, ISO8601_DATETIME_AUTO);
 652     g_assert_nonnull(endp);
 653     g_assert(*endp == '\0');
 654     g_assert_cmpint(result.secs, ==, expect.secs);
 655     g_assert_cmpint(result.nsecs, ==, expect.nsecs);
 656
 657     /* Date and time with timezone offset with hours only. */
 658     str = "2013-05-30T23:45:25.349124+01";
 659     expect.secs = mktime_utc(&tm1) - 1 * 60 * 60;
 660     expect.nsecs = 349124 * 1000;
 661     endp = iso8601_to_nstime(&result, str, ISO8601_DATETIME_AUTO);
 662     g_assert_nonnull(endp);
 663     g_assert(*endp == '\0');
 664     g_assert_cmpint(result.secs, ==, expect.secs);
 665     g_assert_cmpint(result.nsecs, ==, expect.nsecs);
 666 }
 667
 668 #include "ws_getopt.h"
 669
 670 #define ARGV_MAX 31
 671
 672 static char **new_argv(int *argc_ptr, const char *args, ...)
 673 {
 674     char **argv;
 675     int argc = 0;
 676     va_list ap;
 677
 678     argv = g_malloc((ARGV_MAX + 1) * sizeof(char *));
 679
 680     va_start(ap, args);
 681     while (args != NULL) {
 682         /* Increase ARGV_MAX or use a dynamic size if this assertion fails. */
 683         g_assert_true(argc < ARGV_MAX);
 684         argv[argc++] = g_strdup(args);
 685         args = va_arg(ap, const char *);
 686     }
 687     argv[argc] = NULL;
 688     va_end(ap);
 689
 690     *argc_ptr = argc;
 691     return argv;
 692 }
 693
 694 static void free_argv(char **argv)
 695 {
 696     for (char **p = argv; *p != NULL; p++) {
 697         g_free(*p);
 698     }
 699     g_free(argv);
 700 }
 701
 702 static void test_getopt_long_basic1(void)
 703 {
 704     char **argv;
 705     int argc;
 706
 707     const char *optstring = "ab:c";
 708     argv = new_argv(&argc, "/bin/ls", "-a", "-b", "arg1", "-c", "path", (char *)NULL);
 709
 710     ws_optind = 1;
 711     int opt;
 712
 713     opt = ws_getopt_long(argc, argv, optstring, NULL, NULL);
 714     g_assert_cmpint(opt, ==, 'a');
 715     g_assert_null(ws_optarg);
 716
 717     opt = ws_getopt_long(argc, argv, optstring, NULL, NULL);
 718     g_assert_cmpint(opt, ==, 'b');
 719     g_assert_cmpstr(ws_optarg, ==, "arg1");
 720
 721     opt = ws_getopt_long(argc, argv, optstring, NULL, NULL);
 722     g_assert_cmpint(opt, ==, 'c');
 723     g_assert_null(ws_optarg);
 724
 725     opt = ws_getopt_long(argc, argv, optstring, NULL, NULL);
 726     g_assert_cmpint(opt, ==, -1);
 727
 728     free_argv(argv);
 729 }
 730
 731 static void test_getopt_long_basic2(void)
 732 {
 733     char **argv;
 734     int argc;
 735
 736     struct ws_option longopts[] = {
 737         { "opt1", ws_no_argument, NULL, '1' },
 738         { "opt2", ws_required_argument, NULL, '2' },
 739         { "opt3", ws_required_argument, NULL, '3' },
 740         { 0, 0, 0, 0 }
 741     };
 742     argv = new_argv(&argc, "/bin/ls", "--opt1", "--opt2", "arg1", "--opt3=arg2", "path", (char *)NULL);
 743
 744     ws_optind = 1;
 745     int opt;
 746
 747     opt = ws_getopt_long(argc, argv, "", longopts, NULL);
 748     g_assert_cmpint(opt, ==, '1');
 749     g_assert_null(ws_optarg);
 750
 751     opt = ws_getopt_long(argc, argv, "", longopts, NULL);
 752     g_assert_cmpint(opt, ==, '2');
 753     g_assert_cmpstr(ws_optarg, ==, "arg1");
 754
 755     opt = ws_getopt_long(argc, argv, "", longopts, NULL);
 756     g_assert_cmpint(opt, ==, '3');
 757     g_assert_cmpstr(ws_optarg, ==, "arg2");
 758
 759     opt = ws_getopt_long(argc, argv, "", longopts, NULL);
 760     g_assert_cmpint(opt, ==, -1);
 761
 762     free_argv(argv);
 763 }
 764
 765 static void test_getopt_optional_argument1(void)
 766 {
 767     char **argv;
 768     int argc;
 769     int opt;
 770
 771     struct ws_option longopts_optional[] = {
 772         { "optional", ws_optional_argument, NULL, '1' },
 773         { 0, 0, 0, 0 }
 774     };
 775
 776     argv = new_argv(&argc, "/bin/ls", "--optional=arg1", (char *)NULL);
 777
 778     ws_optreset = 1;
 779     opt = ws_getopt_long(argc, argv, "", longopts_optional, NULL);
 780     g_assert_cmpint(opt, ==, '1');
 781     g_assert_cmpstr(ws_optarg, ==, "arg1");
 782
 783     free_argv(argv);
 784     argv = new_argv(&argc, "/bin/ls", "--optional", "arg1", (char *)NULL);
 785
 786     ws_optreset = 1;
 787     opt = ws_getopt_long(argc, argv, "", longopts_optional, NULL);
 788     g_assert_cmpint(opt, ==, '1');
 789     /* Optional argument does not recognize the form "--arg param" (it's ambiguous). */
 790     g_assert_null(ws_optarg);
 791
 792     free_argv(argv);
 793     argv = new_argv(&argc, "/bin/ls", "--optional", (char *)NULL);
 794
 795     ws_optreset = 1;
 796     opt = ws_getopt_long(argc, argv, "", longopts_optional, NULL);
 797     g_assert_cmpint(opt, ==, '1');
 798     g_assert_null(ws_optarg);
 799
 800     free_argv(argv);
 801 }
 802
 803 static void test_getopt_opterr1(void)
 804 {
 805     char **argv;
 806     int argc;
 807
 808 #ifdef _WIN32
 809     g_test_skip("Not supported on Windows");
 810     return;
 811 #endif
 812
 813     if (g_test_subprocess()) {
 814         const char *optstring = "ab";
 815
 816         /*
 817          * Yes, this has a different command name from this
 818          * program's name - and from the name in the error
 819          * message that we're testing.  ws_getopt() and
 820          * ws_getopt_long() use the name set by g_set_prgname(),
 821          * not the argv[0] string, as the program name in the
 822          * error message, just as other error message routines do.
 823          */
 824         argv = new_argv(&argc, "/bin/ls", "-a", "-z", "path", (char *)NULL);
 825
 826         ws_optind = 0;
 827         ws_opterr = 1;
 828         int opt;
 829
 830         opt = ws_getopt_long(argc, argv, optstring, NULL, NULL);
 831         g_assert_cmpint(opt, ==, 'a');
 832
 833         opt = ws_getopt_long(argc, argv, optstring, NULL, NULL);
 834         g_assert_cmpint(opt, ==, '?');
 835         g_assert_cmpint(ws_optopt, ==, 'z');
 836
 837         opt = ws_getopt_long(argc, argv, optstring, NULL, NULL);
 838         g_assert_cmpint(opt, ==, -1);
 839
 840         free_argv(argv);
 841
 842         return;
 843     }
 844
 845     g_test_trap_subprocess(NULL, 0, 0);
 846     g_test_trap_assert_passed();
 847     g_test_trap_assert_stderr(PROGNAME ": unrecognized option: z\n");
 848 }
 849
 850 int main(int argc, char **argv)
 851 {
 852     int ret;
 853
 854     /* Set the program name. */
 855     g_set_prgname(PROGNAME);
 856
 857     ws_log_init(NULL);
 858
 859     g_test_init(&argc, &argv, NULL);
 860
 861     g_test_add_func("/inet_addr/inet_pton4", test_inet_pton4_test1);
 862     g_test_add_func("/inet_addr/inet_ntop4", test_inet_ntop4_test1);
 863     g_test_add_func("/inet_addr/inet_pton6", test_inet_pton6_test1);
 864     g_test_add_func("/inet_addr/inet_ntop6", test_inet_ntop6_test1);
 865
 866     g_test_add_func("/str_util/format_size", test_format_size);
 867     g_test_add_func("/str_util/escape_string", test_escape_string);
 868     g_test_add_func("/str_util/strconcat", test_strconcat);
 869     g_test_add_func("/str_util/strsplit", test_strsplit);
 870     g_test_add_func("/str_util/str_ascii", test_str_ascii);
 871     g_test_add_func("/str_util/format_text", test_format_text);
 872
 873     if (g_test_perf()) {
 874         g_test_add_func("/str_util/format_text_perf", test_format_text_perf);
 875     }
 876
 877     g_test_add_func("/to_str/word_to_hex", test_word_to_hex);
 878     g_test_add_func("/to_str/bytes_to_str", test_bytes_to_str);
 879     g_test_add_func("/to_str/bytes_to_str_punct", test_bytes_to_str_punct);
 880     g_test_add_func("/to_str/bytes_to_str_maxlen", test_bytes_to_str_maxlen);
 881     g_test_add_func("/to_str/bytes_to_str_punct_maxlen", test_bytes_to_str_punct_maxlen);
 882     g_test_add_func("/to_str/bytes_to_str_trunc1", test_bytes_to_string_trunc1);
 883     g_test_add_func("/to_str/bytes_to_str_punct_trunc1", test_bytes_to_string_punct_trunc1);
 884     g_test_add_func("/to_str/oct_to_str_back", test_oct_to_str_back);
 885     g_test_add_func("/to_str/oct64_to_str_back", test_oct64_to_str_back);
 886     g_test_add_func("/to_str/hex_to_str_back_len", test_hex_to_str_back_len);
 887     g_test_add_func("/to_str/hex64_to_str_back_len", test_hex64_to_str_back_len);
 888     g_test_add_func("/to_str/uint_to_str_back", test_uint_to_str_back);
 889     g_test_add_func("/to_str/uint64_to_str_back", test_uint64_to_str_back);
 890     g_test_add_func("/to_str/uint_to_str_back_len", test_uint_to_str_back_len);
 891     g_test_add_func("/to_str/uint64_to_str_back_len", test_uint64_to_str_back_len);
 892     g_test_add_func("/to_str/int_to_str_back", test_int_to_str_back);
 893     g_test_add_func("/to_str/int64_to_str_back", test_int64_to_str_back);
 894     g_test_add_func("/to_str/ip_addr_to_str_test1", test_ip_addr_to_str_test1);
 895
 896     g_test_add_func("/nstime/from_iso8601", test_nstime_from_iso8601);
 897
 898     g_test_add_func("/ws_getopt/basic1", test_getopt_long_basic1);
 899     g_test_add_func("/ws_getopt/basic2", test_getopt_long_basic2);
 900     g_test_add_func("/ws_getopt/optional1", test_getopt_optional_argument1);
 901     g_test_add_func("/ws_getopt/opterr1", test_getopt_opterr1);
 902
 903     ret = g_test_run();
 904
 905     return ret;
 906 }
 907
 908 /*
 909  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 910  *
 911  * Local variables:
 912  * c-basic-offset: 4
 913  * tab-width: 8
 914  * indent-tabs-mode: nil
 915  * End:
 916  *
 917  * vi: set shiftwidth=4 tabstop=8 expandtab:
 918  * :indentSize=4:tabSize=8:noTabs=true:
 919  */