test_str_from_value.c (59731B)
1 /* 2 This file is part of libmicrohttpd 3 Copyright (C) 2016 Karlson2k (Evgeny Grin) 4 5 This test tool is free software; you can redistribute it and/or 6 modify it under the terms of the GNU General Public License as 7 published by the Free Software Foundation; either version 2, or 8 (at your option) any later version. 9 10 This test tool is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public 16 License along with this library; if not, write to the Free Software 17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 18 */ 19 20 /** 21 * @file microhttpd/unit_str_test.h 22 * @brief Unit tests for mhd_str functions 23 * @author Karlson2k (Evgeny Grin) 24 */ 25 26 #include "mhd_sys_options.h" 27 #include "../mhd2/mhd_str.h" 28 #include "../mhd2/mhd_str.c" 29 #include "../mhdt_checks.h" 30 31 #include <stdio.h> 32 #include <locale.h> 33 #include <string.h> 34 #ifdef HAVE_INTTYPES_H 35 #include <inttypes.h> 36 #else /* ! HAVE_INTTYPES_H */ 37 #define PRIu64 "llu" 38 #define PRIuPTR "u" 39 #define PRIX64 "llX" 40 #endif /* ! HAVE_INTTYPES_H */ 41 #include <stdint.h> 42 #ifdef HAVE_STDLIB_H 43 #include <stdlib.h> 44 #endif /* HAVE_STDLIB_H */ 45 #include "mhd_limits.h" 46 #include "mhd_str.h" 47 #include "test_helpers.h" 48 49 50 static int verbose = 0; /* verbose level (0-3)*/ 51 52 /* Locale names to test. 53 * Functions must not depend of current current locale, 54 * so result must be the same in any locale. 55 */ 56 static const char *const locale_names[] = { 57 "C", 58 "", /* System default locale */ 59 #if defined(_WIN32) && ! defined(__CYGWIN__) 60 ".OCP", /* W32 system default OEM code page */ 61 ".ACP", /* W32 system default ANSI code page */ 62 ".65001", /* UTF-8 */ 63 ".437", 64 ".850", 65 ".857", 66 ".866", 67 ".1250", 68 ".1251", 69 ".1252", 70 "en", 71 "english", 72 "French_France", 73 "Turkish_Turkey.1254", 74 "de", 75 "zh-Hans", 76 "ru-RU.1251" 77 #if 0 /* Disabled extra checks */ 78 , 79 ".1254", 80 ".20866", /* number for KOI8-R */ 81 ".28591", /* number for ISO-8859-1 */ 82 ".28595", /* number for ISO-8859-5 */ 83 ".28599", /* number for ISO-8859-9 */ 84 ".28605", /* number for ISO-8859-15 */ 85 "en-US", 86 "English-US", 87 "en-US.437", 88 "English_United States.437", 89 "en-US.1252", 90 "English_United States.1252", 91 "English_United States.28591", 92 "English_United States.65001", 93 "fra", 94 "french", 95 "fr-FR", 96 "fr-FR.850", 97 "french_france.850", 98 "fr-FR.1252", 99 "French_france.1252", 100 "French_france.28605", 101 "French_France.65001", 102 "de-DE", 103 "de-DE.850", 104 "German_Germany.850", 105 "German_Germany.1250", 106 "de-DE.1252", 107 "German_Germany.1252", 108 "German_Germany.28605", 109 "German_Germany.65001", 110 "tr", 111 "trk", 112 "turkish", 113 "tr-TR", 114 "tr-TR.1254", 115 "tr-TR.857", 116 "Turkish_Turkey.857", 117 "Turkish_Turkey.28599", 118 "Turkish_Turkey.65001", 119 "ru", 120 "ru-RU", 121 "Russian", 122 "ru-RU.866", 123 "Russian_Russia.866", 124 "Russian_Russia.1251", 125 "Russian_Russia.20866", 126 "Russian_Russia.28595", 127 "Russian_Russia.65001", 128 "zh-Hans.936", 129 "chinese-simplified" 130 #endif /* Disabled extra checks */ 131 #else /* ! _WIN32 || __CYGWIN__ */ 132 "C.UTF-8", 133 "POSIX", 134 "en", 135 "en_US", 136 "en_US.ISO-8859-1", 137 "en_US.ISO_8859-1", 138 "en_US.ISO8859-1", 139 "en_US.iso88591", 140 "en_US.ISO-8859-15", 141 "en_US.DIS_8859-15", 142 "en_US.ISO8859-15", 143 "en_US.iso885915", 144 "en_US.1252", 145 "en_US.CP1252", 146 "en_US.UTF-8", 147 "en_US.utf8", 148 "fr", 149 "fr_FR", 150 "fr_FR.850", 151 "fr_FR.IBM850", 152 "fr_FR.1252", 153 "fr_FR.CP1252", 154 "fr_FR.ISO-8859-1", 155 "fr_FR.ISO_8859-1", 156 "fr_FR.ISO8859-1", 157 "fr_FR.iso88591", 158 "fr_FR.ISO-8859-15", 159 "fr_FR.DIS_8859-15", 160 "fr_FR.ISO8859-15", 161 "fr_FR.iso8859-15", 162 "fr_FR.UTF-8", 163 "fr_FR.utf8", 164 "de", 165 "de_DE", 166 "de_DE.850", 167 "de_DE.IBM850", 168 "de_DE.1250", 169 "de_DE.CP1250", 170 "de_DE.1252", 171 "de_DE.CP1252", 172 "de_DE.ISO-8859-1", 173 "de_DE.ISO_8859-1", 174 "de_DE.ISO8859-1", 175 "de_DE.iso88591", 176 "de_DE.ISO-8859-15", 177 "de_DE.DIS_8859-15", 178 "de_DE.ISO8859-15", 179 "de_DE.iso885915", 180 "de_DE.UTF-8", 181 "de_DE.utf8", 182 "tr", 183 "tr_TR", 184 "tr_TR.1254", 185 "tr_TR.CP1254", 186 "tr_TR.857", 187 "tr_TR.IBM857", 188 "tr_TR.ISO-8859-9", 189 "tr_TR.ISO8859-9", 190 "tr_TR.iso88599", 191 "tr_TR.UTF-8", 192 "tr_TR.utf8", 193 "ru", 194 "ru_RU", 195 "ru_RU.1251", 196 "ru_RU.CP1251", 197 "ru_RU.866", 198 "ru_RU.IBM866", 199 "ru_RU.KOI8-R", 200 "ru_RU.koi8-r", 201 "ru_RU.KOI8-RU", 202 "ru_RU.ISO-8859-5", 203 "ru_RU.ISO_8859-5", 204 "ru_RU.ISO8859-5", 205 "ru_RU.iso88595", 206 "ru_RU.UTF-8", 207 "zh_CN", 208 "zh_CN.GB2312", 209 "zh_CN.UTF-8", 210 #endif /* ! _WIN32 || __CYGWIN__ */ 211 }; 212 213 static const unsigned int locale_name_count = sizeof(locale_names) 214 / sizeof(locale_names[0]); 215 216 217 /* 218 * Helper functions 219 */ 220 221 static int 222 set_test_locale (size_t num) 223 { 224 if (num >= locale_name_count) 225 { 226 fprintf (stderr, "Unexpected number of locale.\n"); 227 exit (99); 228 } 229 if (verbose > 2) 230 printf ("Setting locale \"%s\":", locale_names[num]); 231 if (setlocale (LC_ALL, locale_names[num])) 232 { 233 if (verbose > 2) 234 printf (" succeed.\n"); 235 return 1; 236 } 237 if (verbose > 2) 238 printf (" failed.\n"); 239 return 0; 240 } 241 242 243 static const char * 244 get_current_locale_str (void) 245 { 246 char const *loc_str = setlocale (LC_ALL, NULL); 247 return loc_str ? loc_str : "unknown"; 248 } 249 250 251 struct str_with_len 252 { 253 const char *const str; 254 const size_t len; 255 }; 256 257 #define D_STR_W_LEN(s) {(s), (sizeof((s)) / sizeof(char)) - 1} 258 259 /* 260 * Digits in string -> value tests 261 */ 262 263 struct str_with_value 264 { 265 const struct str_with_len str; 266 const size_t num_of_digt; 267 const uint64_t val; 268 }; 269 270 /* valid string for conversion to unsigned integer value */ 271 static const struct str_with_value dstrs_w_values[] = { 272 /* simplest strings */ 273 {D_STR_W_LEN ("1"), 1, 1}, 274 {D_STR_W_LEN ("0"), 1, 0}, 275 {D_STR_W_LEN ("10000"), 5, 10000}, 276 277 /* all digits */ 278 {D_STR_W_LEN ("1234"), 4, 1234}, 279 {D_STR_W_LEN ("4567"), 4, 4567}, 280 {D_STR_W_LEN ("7890"), 4, 7890}, 281 {D_STR_W_LEN ("8021"), 4, 8021}, 282 {D_STR_W_LEN ("9754"), 4, 9754}, 283 {D_STR_W_LEN ("6392"), 4, 6392}, 284 285 /* various prefixes */ 286 {D_STR_W_LEN ("00000000"), 8, 0}, 287 {D_STR_W_LEN ("0755"), 4, 755}, /* not to be interpreted as octal value! */ 288 {D_STR_W_LEN ("002"), 3, 2}, 289 {D_STR_W_LEN ("0001"), 4, 1}, 290 {D_STR_W_LEN ("00000000000000000000000031295483"), 32, 31295483}, 291 292 /* numbers below and above limits */ 293 {D_STR_W_LEN ("127"), 3, 127}, /* 0x7F, SCHAR_MAX */ 294 {D_STR_W_LEN ("128"), 3, 128}, /* 0x80, SCHAR_MAX+1 */ 295 {D_STR_W_LEN ("255"), 3, 255}, /* 0xFF, UCHAR_MAX */ 296 {D_STR_W_LEN ("256"), 3, 256}, /* 0x100, UCHAR_MAX+1 */ 297 {D_STR_W_LEN ("32767"), 5, 32767}, /* 0x7FFF, INT16_MAX */ 298 {D_STR_W_LEN ("32768"), 5, 32768}, /* 0x8000, INT16_MAX+1 */ 299 {D_STR_W_LEN ("65535"), 5, 65535}, /* 0xFFFF, UINT16_MAX */ 300 {D_STR_W_LEN ("65536"), 5, 65536}, /* 0x10000, UINT16_MAX+1 */ 301 {D_STR_W_LEN ("2147483647"), 10, 2147483647}, /* 0x7FFFFFFF, INT32_MAX */ 302 {D_STR_W_LEN ("2147483648"), 10, UINT64_C (2147483648)}, /* 0x80000000, INT32_MAX+1 */ 303 {D_STR_W_LEN ("4294967295"), 10, UINT64_C (4294967295)}, /* 0xFFFFFFFF, UINT32_MAX */ 304 {D_STR_W_LEN ("4294967296"), 10, UINT64_C (4294967296)}, /* 0x100000000, UINT32_MAX+1 */ 305 {D_STR_W_LEN ("9223372036854775807"), 19, UINT64_C (9223372036854775807)}, /* 0x7FFFFFFFFFFFFFFF, INT64_MAX */ 306 {D_STR_W_LEN ("9223372036854775808"), 19, UINT64_C (9223372036854775808)}, /* 0x8000000000000000, INT64_MAX+1 */ 307 {D_STR_W_LEN ("18446744073709551615"), 20, UINT64_C (18446744073709551615)}, /* 0xFFFFFFFFFFFFFFFF, UINT64_MAX */ 308 309 /* random numbers */ 310 {D_STR_W_LEN ("10186753"), 8, 10186753}, 311 {D_STR_W_LEN ("144402566"), 9, 144402566}, 312 {D_STR_W_LEN ("151903144"), 9, 151903144}, 313 {D_STR_W_LEN ("139264621"), 9, 139264621}, 314 {D_STR_W_LEN ("730348"), 6, 730348}, 315 {D_STR_W_LEN ("21584377"), 8, 21584377}, 316 {D_STR_W_LEN ("709"), 3, 709}, 317 {D_STR_W_LEN ("54"), 2, 54}, 318 {D_STR_W_LEN ("8452"), 4, 8452}, 319 {D_STR_W_LEN ("17745098750013624977"), 20, UINT64_C (17745098750013624977)}, 320 {D_STR_W_LEN ("06786878769931678000"), 20, UINT64_C (6786878769931678000)}, 321 322 /* non-digit suffixes */ 323 {D_STR_W_LEN ("1234oa"), 4, 1234}, 324 {D_STR_W_LEN ("20h"), 2, 20}, /* not to be interpreted as hex value! */ 325 {D_STR_W_LEN ("0x1F"), 1, 0}, /* not to be interpreted as hex value! */ 326 {D_STR_W_LEN ("0564`~}"), 4, 564}, 327 {D_STR_W_LEN ("7240146.724"), 7, 7240146}, 328 {D_STR_W_LEN ("2,9"), 1, 2}, 329 {D_STR_W_LEN ("200+1"), 3, 200}, 330 {D_STR_W_LEN ("1a"), 1, 1}, 331 {D_STR_W_LEN ("2E"), 1, 2}, 332 {D_STR_W_LEN ("6c"), 1, 6}, 333 {D_STR_W_LEN ("8F"), 1, 8}, 334 {D_STR_W_LEN ("287416997! And the not too long string."), 9, 287416997} 335 }; 336 337 338 /* valid hex string for conversion to unsigned integer value */ 339 static const struct str_with_value xdstrs_w_values[] = { 340 /* simplest strings */ 341 {D_STR_W_LEN ("1"), 1, 0x1}, 342 {D_STR_W_LEN ("0"), 1, 0x0}, 343 {D_STR_W_LEN ("10000"), 5, 0x10000}, 344 345 /* all digits */ 346 {D_STR_W_LEN ("1234"), 4, 0x1234}, 347 {D_STR_W_LEN ("4567"), 4, 0x4567}, 348 {D_STR_W_LEN ("7890"), 4, 0x7890}, 349 {D_STR_W_LEN ("8021"), 4, 0x8021}, 350 {D_STR_W_LEN ("9754"), 4, 0x9754}, 351 {D_STR_W_LEN ("6392"), 4, 0x6392}, 352 {D_STR_W_LEN ("abcd"), 4, 0xABCD}, 353 {D_STR_W_LEN ("cdef"), 4, 0xCDEF}, 354 {D_STR_W_LEN ("FEAB"), 4, 0xFEAB}, 355 {D_STR_W_LEN ("BCED"), 4, 0xBCED}, 356 {D_STR_W_LEN ("bCeD"), 4, 0xBCED}, 357 {D_STR_W_LEN ("1A5F"), 4, 0x1A5F}, 358 {D_STR_W_LEN ("12AB"), 4, 0x12AB}, 359 {D_STR_W_LEN ("CD34"), 4, 0xCD34}, 360 {D_STR_W_LEN ("56EF"), 4, 0x56EF}, 361 {D_STR_W_LEN ("7a9f"), 4, 0x7A9F}, 362 363 /* various prefixes */ 364 {D_STR_W_LEN ("00000000"), 8, 0x0}, 365 {D_STR_W_LEN ("0755"), 4, 0x755}, /* not to be interpreted as octal value! */ 366 {D_STR_W_LEN ("002"), 3, 0x2}, 367 {D_STR_W_LEN ("0001"), 4, 0x1}, 368 {D_STR_W_LEN ("00a"), 3, 0xA}, 369 {D_STR_W_LEN ("0F"), 2, 0xF}, 370 {D_STR_W_LEN ("0000000000000000000000003A29e4C3"), 32, 0x3A29E4C3}, 371 372 /* numbers below and above limits */ 373 {D_STR_W_LEN ("7F"), 2, 127}, /* 0x7F, SCHAR_MAX */ 374 {D_STR_W_LEN ("7f"), 2, 127}, /* 0x7F, SCHAR_MAX */ 375 {D_STR_W_LEN ("80"), 2, 128}, /* 0x80, SCHAR_MAX+1 */ 376 {D_STR_W_LEN ("fF"), 2, 255}, /* 0xFF, UCHAR_MAX */ 377 {D_STR_W_LEN ("Ff"), 2, 255}, /* 0xFF, UCHAR_MAX */ 378 {D_STR_W_LEN ("FF"), 2, 255}, /* 0xFF, UCHAR_MAX */ 379 {D_STR_W_LEN ("ff"), 2, 255}, /* 0xFF, UCHAR_MAX */ 380 {D_STR_W_LEN ("100"), 3, 256}, /* 0x100, UCHAR_MAX+1 */ 381 {D_STR_W_LEN ("7fff"), 4, 32767}, /* 0x7FFF, INT16_MAX */ 382 {D_STR_W_LEN ("7FFF"), 4, 32767}, /* 0x7FFF, INT16_MAX */ 383 {D_STR_W_LEN ("7Fff"), 4, 32767}, /* 0x7FFF, INT16_MAX */ 384 {D_STR_W_LEN ("8000"), 4, 32768}, /* 0x8000, INT16_MAX+1 */ 385 {D_STR_W_LEN ("ffff"), 4, 65535}, /* 0xFFFF, UINT16_MAX */ 386 {D_STR_W_LEN ("FFFF"), 4, 65535}, /* 0xFFFF, UINT16_MAX */ 387 {D_STR_W_LEN ("FffF"), 4, 65535}, /* 0xFFFF, UINT16_MAX */ 388 {D_STR_W_LEN ("10000"), 5, 65536}, /* 0x10000, UINT16_MAX+1 */ 389 {D_STR_W_LEN ("7FFFFFFF"), 8, 2147483647}, /* 0x7FFFFFFF, INT32_MAX */ 390 {D_STR_W_LEN ("7fffffff"), 8, 2147483647}, /* 0x7FFFFFFF, INT32_MAX */ 391 {D_STR_W_LEN ("7FFffFff"), 8, 2147483647}, /* 0x7FFFFFFF, INT32_MAX */ 392 {D_STR_W_LEN ("80000000"), 8, UINT64_C (2147483648)}, /* 0x80000000, INT32_MAX+1 */ 393 {D_STR_W_LEN ("FFFFFFFF"), 8, UINT64_C (4294967295)}, /* 0xFFFFFFFF, UINT32_MAX */ 394 {D_STR_W_LEN ("ffffffff"), 8, UINT64_C (4294967295)}, /* 0xFFFFFFFF, UINT32_MAX */ 395 {D_STR_W_LEN ("FfFfFfFf"), 8, UINT64_C (4294967295)}, /* 0xFFFFFFFF, UINT32_MAX */ 396 {D_STR_W_LEN ("100000000"), 9, UINT64_C (4294967296)}, /* 0x100000000, UINT32_MAX+1 */ 397 {D_STR_W_LEN ("7fffffffffffffff"), 16, UINT64_C (9223372036854775807)}, /* 0x7FFFFFFFFFFFFFFF, INT64_MAX */ 398 {D_STR_W_LEN ("7FFFFFFFFFFFFFFF"), 16, UINT64_C (9223372036854775807)}, /* 0x7FFFFFFFFFFFFFFF, INT64_MAX */ 399 {D_STR_W_LEN ("7FfffFFFFffFFffF"), 16, UINT64_C (9223372036854775807)}, /* 0x7FFFFFFFFFFFFFFF, INT64_MAX */ 400 {D_STR_W_LEN ("8000000000000000"), 16, UINT64_C (9223372036854775808)}, /* 0x8000000000000000, INT64_MAX+1 */ 401 {D_STR_W_LEN ("ffffffffffffffff"), 16, UINT64_C (18446744073709551615)}, /* 0xFFFFFFFFFFFFFFFF, UINT64_MAX */ 402 {D_STR_W_LEN ("FFFFFFFFFFFFFFFF"), 16, UINT64_C (18446744073709551615)}, /* 0xFFFFFFFFFFFFFFFF, UINT64_MAX */ 403 {D_STR_W_LEN ("FffFffFFffFFfFFF"), 16, UINT64_C (18446744073709551615)}, /* 0xFFFFFFFFFFFFFFFF, UINT64_MAX */ 404 405 /* random numbers */ 406 {D_STR_W_LEN ("10186753"), 8, 0x10186753}, 407 {D_STR_W_LEN ("144402566"), 9, 0x144402566}, 408 {D_STR_W_LEN ("151903144"), 9, 0x151903144}, 409 {D_STR_W_LEN ("139264621"), 9, 0x139264621}, 410 {D_STR_W_LEN ("730348"), 6, 0x730348}, 411 {D_STR_W_LEN ("21584377"), 8, 0x21584377}, 412 {D_STR_W_LEN ("709"), 3, 0x709}, 413 {D_STR_W_LEN ("54"), 2, 0x54}, 414 {D_STR_W_LEN ("8452"), 4, 0x8452}, 415 {D_STR_W_LEN ("22353EC6"), 8, 0x22353EC6}, 416 {D_STR_W_LEN ("307F1655"), 8, 0x307F1655}, 417 {D_STR_W_LEN ("1FCB7226"), 8, 0x1FCB7226}, 418 {D_STR_W_LEN ("82480560"), 8, 0x82480560}, 419 {D_STR_W_LEN ("7386D95"), 7, 0x7386D95}, 420 {D_STR_W_LEN ("EC3AB"), 5, 0xEC3AB}, 421 {D_STR_W_LEN ("6DD05"), 5, 0x6DD05}, 422 {D_STR_W_LEN ("C5DF"), 4, 0xC5DF}, 423 {D_STR_W_LEN ("6CE"), 3, 0x6CE}, 424 {D_STR_W_LEN ("CE6"), 3, 0xCE6}, 425 {D_STR_W_LEN ("ce6"), 3, 0xCE6}, 426 {D_STR_W_LEN ("F27"), 3, 0xF27}, 427 {D_STR_W_LEN ("8497D54277D7E1"), 14, UINT64_C (37321639124785121)}, 428 {D_STR_W_LEN ("8497d54277d7e1"), 14, UINT64_C (37321639124785121)}, 429 {D_STR_W_LEN ("8497d54277d7E1"), 14, UINT64_C (37321639124785121)}, 430 {D_STR_W_LEN ("8C8112D0A06"), 11, UINT64_C (9655374645766)}, 431 {D_STR_W_LEN ("8c8112d0a06"), 11, UINT64_C (9655374645766)}, 432 {D_STR_W_LEN ("8c8112d0A06"), 11, UINT64_C (9655374645766)}, 433 {D_STR_W_LEN ("1774509875001362"), 16, UINT64_C (1690064375898968930)}, 434 {D_STR_W_LEN ("0678687876998000"), 16, UINT64_C (466237428027981824)}, 435 436 /* non-digit suffixes */ 437 {D_STR_W_LEN ("1234oa"), 4, 0x1234}, 438 {D_STR_W_LEN ("20h"), 2, 0x20}, 439 {D_STR_W_LEN ("2CH"), 2, 0x2C}, 440 {D_STR_W_LEN ("2ch"), 2, 0x2C}, 441 {D_STR_W_LEN ("0x1F"), 1, 0x0}, /* not to be interpreted as hex prefix! */ 442 {D_STR_W_LEN ("0564`~}"), 4, 0x564}, 443 {D_STR_W_LEN ("0A64`~}"), 4, 0xA64}, 444 {D_STR_W_LEN ("056c`~}"), 4, 0X56C}, 445 {D_STR_W_LEN ("7240146.724"), 7, 0x7240146}, 446 {D_STR_W_LEN ("7E4c1AB.724"), 7, 0X7E4C1AB}, 447 {D_STR_W_LEN ("F24B1B6.724"), 7, 0xF24B1B6}, 448 {D_STR_W_LEN ("2,9"), 1, 0x2}, 449 {D_STR_W_LEN ("a,9"), 1, 0xA}, 450 {D_STR_W_LEN ("200+1"), 3, 0x200}, 451 {D_STR_W_LEN ("2cc+1"), 3, 0x2CC}, 452 {D_STR_W_LEN ("2cC+1"), 3, 0x2CC}, 453 {D_STR_W_LEN ("27416997! And the not too long string."), 8, 0x27416997}, 454 {D_STR_W_LEN ("27555416997! And the not too long string."), 11, 455 0x27555416997}, 456 {D_STR_W_LEN ("416997And the not too long string."), 7, 0x416997A}, 457 {D_STR_W_LEN ("0F4C3Dabstract addition to make string even longer"), 8, 458 0xF4C3DAB} 459 }; 460 461 462 static size_t 463 check_str_from_uint16 (void) 464 { 465 size_t t_failed = 0; 466 size_t i, j; 467 char buf[70]; 468 const char *erase = 469 "-@=sd#+&(pdiren456qwe#@C3S!DAS45AOIPUQWESAdFzxcv1s*()&#$%34`" 470 "32452d098poiden45SADFFDA3S4D3SDFdfgsdfgsSADFzxdvs$*()द`" 471 "adsf##$$@&*^%*^&56qwe#3C@S!DAScFAOIP$#%#$Ad1zs3v1$*()ӌ`"; 472 int c_failed[sizeof(dstrs_w_values) 473 / sizeof(dstrs_w_values[0])]; 474 static const size_t n_checks = sizeof(c_failed) / sizeof(c_failed[0]); 475 476 memset (c_failed, 0, sizeof(c_failed)); 477 478 for (j = 0; j < locale_name_count; j++) 479 { 480 set_test_locale (j); /* setlocale() can be slow! */ 481 for (i = 0; i < n_checks; i++) 482 { 483 const struct str_with_value *const t = dstrs_w_values + i; 484 size_t b_size; 485 size_t rs; 486 487 if (c_failed[i]) 488 continue; /* skip already failed checks */ 489 490 if (t->str.len < t->num_of_digt) 491 { 492 fprintf (stderr, 493 "ERROR: dstrs_w_values[%u] has wrong num_of_digt (%u): num_of_digt is expected" 494 " to be less or equal to str.len (%u).\n", 495 (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned 496 int) t->str. 497 len); 498 exit (99); 499 } 500 if ('0' == t->str.str[0]) 501 continue; /* Skip strings prefixed with zeros */ 502 if (t->num_of_digt != t->str.len) 503 continue; /* Skip strings with suffixes */ 504 if (UINT16_MAX < t->val) 505 continue; /* Too large value to convert */ 506 if (sizeof(buf) < t->str.len + 1) 507 { 508 fprintf (stderr, 509 "ERROR: dstrs_w_values[%u] has too long (%u) string, " 510 "size of 'buf' should be increased.\n", 511 (unsigned int) i, (unsigned int) t->str.len); 512 exit (99); 513 } 514 rs = 0; /* Only to mute compiler warning */ 515 for (b_size = 0; b_size <= t->str.len + 1; ++b_size) 516 { 517 /* fill buffer with pseudo-random values */ 518 memcpy (buf, erase, sizeof(buf)); 519 520 rs = mhd_uint16_to_str ((uint16_t) t->val, buf, b_size); 521 522 if (t->num_of_digt > b_size) 523 { 524 /* Must fail, buffer is too small for result */ 525 if (0 != rs) 526 { 527 if (0 == c_failed[i]) 528 t_failed++; 529 c_failed[i] = ! 0; 530 fprintf (stderr, 531 "FAILED: mhd_uint16_to_str(%" PRIu64 ", -> buf," 532 " %d) returned %" PRIuPTR 533 ", while expecting 0." 534 " Locale: %s\n", t->val, (int) b_size, (uintptr_t) rs, 535 get_current_locale_str ()); 536 } 537 } 538 else 539 { 540 if (t->num_of_digt != rs) 541 { 542 if (0 == c_failed[i]) 543 t_failed++; 544 c_failed[i] = ! 0; 545 fprintf (stderr, 546 "FAILED: mhd_uint16_to_str(%" PRIu64 ", -> buf," 547 " %d) returned %" PRIuPTR 548 ", while expecting %d." 549 " Locale: %s\n", t->val, (int) b_size, (uintptr_t) rs, 550 (int) t->num_of_digt, get_current_locale_str ()); 551 } 552 else if (0 != memcmp (buf, t->str.str, t->num_of_digt)) 553 { 554 if (0 == c_failed[i]) 555 t_failed++; 556 c_failed[i] = ! 0; 557 fprintf (stderr, 558 "FAILED: mhd_uint16_to_str(%" PRIu64 ", -> \"%.*s\"," 559 " %d) returned %" PRIuPTR "." 560 " Locale: %s\n", t->val, (int) rs, buf, (int) b_size, 561 (uintptr_t) rs, get_current_locale_str ()); 562 } 563 else if (0 != memcmp (buf + rs, erase + rs, sizeof(buf) - rs)) 564 { 565 if (0 == c_failed[i]) 566 t_failed++; 567 c_failed[i] = ! 0; 568 fprintf (stderr, 569 "FAILED: mhd_uint16_to_str(%" PRIu64 ", -> \"%.*s\"," 570 " %d) returned %" PRIuPTR 571 " and touched data after the resulting string." 572 " Locale: %s\n", t->val, (int) rs, buf, (int) b_size, 573 (uintptr_t) rs, get_current_locale_str ()); 574 } 575 } 576 } 577 if ((verbose > 1) && (j == locale_name_count - 1) && ! c_failed[i]) 578 printf ("PASSED: mhd_uint16_to_str(%" PRIu64 ", -> \"%.*s\", %d) " 579 "== %" PRIuPTR "\n", 580 t->val, (int) rs, buf, (int) b_size - 1, (uintptr_t) rs); 581 } 582 } 583 return t_failed; 584 } 585 586 587 static size_t 588 check_str_from_uint64 (void) 589 { 590 size_t t_failed = 0; 591 size_t i, j; 592 char buf[70]; 593 const char *erase = 594 "-@=sd#+&(pdirenDSFGSe#@C&S!DAS*!AOIPUQWESAdFzxcvSs*()&#$%KH`" 595 "32452d098poiden45SADFFDA3S4D3SDFdfgsdfgsSADFzxdvs$*()द`" 596 "adsf##$$@&*^%*^&56qwe#3C@S!DAScFAOIP$#%#$Ad1zs3v1$*()ӌ`"; 597 int c_failed[sizeof(dstrs_w_values) 598 / sizeof(dstrs_w_values[0])]; 599 static const size_t n_checks = sizeof(c_failed) / sizeof(c_failed[0]); 600 601 memset (c_failed, 0, sizeof(c_failed)); 602 603 for (j = 0; j < locale_name_count; j++) 604 { 605 set_test_locale (j); /* setlocale() can be slow! */ 606 for (i = 0; i < n_checks; i++) 607 { 608 const struct str_with_value *const t = dstrs_w_values + i; 609 size_t b_size; 610 size_t rs; 611 612 if (c_failed[i]) 613 continue; /* skip already failed checks */ 614 615 if (t->str.len < t->num_of_digt) 616 { 617 fprintf (stderr, 618 "ERROR: dstrs_w_values[%u] has wrong num_of_digt (%u): num_of_digt is expected" 619 " to be less or equal to str.len (%u).\n", 620 (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned 621 int) t->str. 622 len); 623 exit (99); 624 } 625 if ('0' == t->str.str[0]) 626 continue; /* Skip strings prefixed with zeros */ 627 if (t->num_of_digt != t->str.len) 628 continue; /* Skip strings with suffixes */ 629 if (sizeof(buf) < t->str.len + 1) 630 { 631 fprintf (stderr, 632 "ERROR: dstrs_w_values[%u] has too long (%u) string, " 633 "size of 'buf' should be increased.\n", 634 (unsigned int) i, (unsigned int) t->str.len); 635 exit (99); 636 } 637 rs = 0; /* Only to mute compiler warning */ 638 for (b_size = 0; b_size <= t->str.len + 1; ++b_size) 639 { 640 /* fill buffer with pseudo-random values */ 641 memcpy (buf, erase, sizeof(buf)); 642 643 rs = mhd_uint64_to_str (t->val, buf, b_size); 644 645 if (t->num_of_digt > b_size) 646 { 647 /* Must fail, buffer is too small for result */ 648 if (0 != rs) 649 { 650 if (0 == c_failed[i]) 651 t_failed++; 652 c_failed[i] = ! 0; 653 fprintf (stderr, 654 "FAILED: mhd_uint64_to_str(%" PRIu64 ", -> buf," 655 " %d) returned %" PRIuPTR 656 ", while expecting 0." 657 " Locale: %s\n", t->val, (int) b_size, (uintptr_t) rs, 658 get_current_locale_str ()); 659 } 660 } 661 else 662 { 663 if (t->num_of_digt != rs) 664 { 665 if (0 == c_failed[i]) 666 t_failed++; 667 c_failed[i] = ! 0; 668 fprintf (stderr, 669 "FAILED: mhd_uint64_to_str(%" PRIu64 ", -> buf," 670 " %d) returned %" PRIuPTR 671 ", while expecting %d." 672 " Locale: %s\n", t->val, (int) b_size, (uintptr_t) rs, 673 (int) t->num_of_digt, get_current_locale_str ()); 674 } 675 else if (0 != memcmp (buf, t->str.str, t->num_of_digt)) 676 { 677 if (0 == c_failed[i]) 678 t_failed++; 679 c_failed[i] = ! 0; 680 fprintf (stderr, 681 "FAILED: mhd_uint64_to_str(%" PRIu64 ", -> \"%.*s\"," 682 " %d) returned %" PRIuPTR "." 683 " Locale: %s\n", t->val, (int) rs, buf, (int) b_size, 684 (uintptr_t) rs, get_current_locale_str ()); 685 } 686 else if (0 != memcmp (buf + rs, erase + rs, sizeof(buf) - rs)) 687 { 688 if (0 == c_failed[i]) 689 t_failed++; 690 c_failed[i] = ! 0; 691 fprintf (stderr, 692 "FAILED: mhd_uint64_to_str(%" PRIu64 ", -> \"%.*s\"," 693 " %d) returned %" PRIuPTR 694 " and touched data after the resulting string." 695 " Locale: %s\n", t->val, (int) rs, buf, (int) b_size, 696 (uintptr_t) rs, get_current_locale_str ()); 697 } 698 } 699 } 700 if ((verbose > 1) && (j == locale_name_count - 1) && ! c_failed[i]) 701 printf ("PASSED: mhd_uint64_to_str(%" PRIu64 ", -> \"%.*s\", %d) " 702 "== %" PRIuPTR "\n", 703 t->val, (int) rs, buf, (int) b_size - 1, (uintptr_t) rs); 704 } 705 } 706 return t_failed; 707 } 708 709 710 static size_t 711 check_strx_from_uint32 (void) 712 { 713 size_t t_failed = 0; 714 size_t i, j; 715 char buf[70]; 716 const char *erase = 717 "jrlkjssfhjfvrjntJHLJ$@%$#adsfdkj;k$##$%#$%FGDF%$#^FDFG%$#$D`" 718 ";skjdhjflsdkjhdjfalskdjhdfalkjdhf$%##%$$#%FSDGFSDDGDFSSDSDF`" 719 "#5#$%#$#$DFSFDDFSGSDFSDF354FDDSGFDFfdssfddfswqemn,.zxih,.sx`"; 720 int c_failed[sizeof(xdstrs_w_values) 721 / sizeof(xdstrs_w_values[0])]; 722 static const size_t n_checks = sizeof(c_failed) / sizeof(c_failed[0]); 723 724 memset (c_failed, 0, sizeof(c_failed)); 725 726 for (j = 0; j < locale_name_count; j++) 727 { 728 set_test_locale (j); /* setlocale() can be slow! */ 729 for (i = 0; i < n_checks; i++) 730 { 731 const struct str_with_value *const t = xdstrs_w_values + i; 732 size_t b_size; 733 size_t rs; 734 735 if (c_failed[i]) 736 continue; /* skip already failed checks */ 737 738 if (t->str.len < t->num_of_digt) 739 { 740 fprintf (stderr, 741 "ERROR: dstrs_w_values[%u] has wrong num_of_digt (%u): num_of_digt is expected" 742 " to be less or equal to str.len (%u).\n", 743 (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned 744 int) t->str. 745 len); 746 exit (99); 747 } 748 if ('0' == t->str.str[0]) 749 continue; /* Skip strings prefixed with zeros */ 750 if (t->num_of_digt != t->str.len) 751 continue; /* Skip strings with suffixes */ 752 if (UINT32_MAX < t->val) 753 continue; /* Too large value to convert */ 754 if (sizeof(buf) < t->str.len + 1) 755 { 756 fprintf (stderr, 757 "ERROR: dstrs_w_values[%u] has too long (%u) string, " 758 "size of 'buf' should be increased.\n", 759 (unsigned int) i, (unsigned int) t->str.len); 760 exit (99); 761 } 762 rs = 0; /* Only to mute compiler warning */ 763 for (b_size = 0; b_size <= t->str.len + 1; ++b_size) 764 { 765 /* fill buffer with pseudo-random values */ 766 memcpy (buf, erase, sizeof(buf)); 767 768 rs = mhd_uint32_to_strx ((uint32_t) t->val, buf, b_size); 769 770 if (t->num_of_digt > b_size) 771 { 772 /* Must fail, buffer is too small for result */ 773 if (0 != rs) 774 { 775 if (0 == c_failed[i]) 776 t_failed++; 777 c_failed[i] = ! 0; 778 fprintf (stderr, 779 "FAILED: mhd_uint32_to_strx(0x%" PRIX64 ", -> buf," 780 " %d) returned %" PRIuPTR 781 ", while expecting 0." 782 " Locale: %s\n", t->val, (int) b_size, (uintptr_t) rs, 783 get_current_locale_str ()); 784 } 785 } 786 else 787 { 788 if (t->num_of_digt != rs) 789 { 790 if (0 == c_failed[i]) 791 t_failed++; 792 c_failed[i] = ! 0; 793 fprintf (stderr, 794 "FAILED: mhd_uint32_to_strx(0x%" PRIX64 ", -> buf," 795 " %d) returned %" PRIuPTR 796 ", while expecting %d." 797 " Locale: %s\n", t->val, (int) b_size, (uintptr_t) rs, 798 (int) t->num_of_digt, get_current_locale_str ()); 799 } 800 else if (0 == mhd_str_equal_caseless_bin_n (buf, t->str.str, 801 t->num_of_digt)) 802 { 803 if (0 == c_failed[i]) 804 t_failed++; 805 c_failed[i] = ! 0; 806 fprintf (stderr, 807 "FAILED: mhd_uint32_to_strx(0x%" PRIX64 ", -> \"%.*s\"," 808 " %d) returned %" PRIuPTR "." 809 " Locale: %s\n", t->val, (int) rs, buf, (int) b_size, 810 (uintptr_t) rs, get_current_locale_str ()); 811 } 812 else if (sizeof(buf) <= rs) 813 { 814 fprintf (stderr, 815 "ERROR: dstrs_w_values[%u] has string with too many" 816 "(%u) digits, size of 'buf' should be increased.\n", 817 (unsigned int) i, (unsigned int) rs); 818 exit (99); 819 } 820 else if (0 != memcmp (buf + rs, erase + rs, sizeof(buf) - rs)) 821 { 822 if (0 == c_failed[i]) 823 t_failed++; 824 c_failed[i] = ! 0; 825 fprintf (stderr, 826 "FAILED: mhd_uint32_to_strx(0x%" PRIX64 ", -> \"%.*s\"," 827 " %d) returned %" PRIuPTR 828 " and touched data after the resulting string." 829 " Locale: %s\n", t->val, (int) rs, buf, (int) b_size, 830 (uintptr_t) rs, get_current_locale_str ()); 831 } 832 } 833 } 834 if ((verbose > 1) && (j == locale_name_count - 1) && ! c_failed[i]) 835 printf ("PASSED: mhd_uint32_to_strx(0x%" PRIX64 ", -> \"%.*s\", %d) " 836 "== %" PRIuPTR "\n", 837 t->val, (int) rs, buf, (int) b_size - 1, (uintptr_t) rs); 838 } 839 } 840 return t_failed; 841 } 842 843 844 static const struct str_with_value duint8_w_values_p1[] = { 845 {D_STR_W_LEN ("0"), 1, 0}, 846 {D_STR_W_LEN ("1"), 1, 1}, 847 {D_STR_W_LEN ("2"), 1, 2}, 848 {D_STR_W_LEN ("3"), 1, 3}, 849 {D_STR_W_LEN ("4"), 1, 4}, 850 {D_STR_W_LEN ("5"), 1, 5}, 851 {D_STR_W_LEN ("6"), 1, 6}, 852 {D_STR_W_LEN ("7"), 1, 7}, 853 {D_STR_W_LEN ("8"), 1, 8}, 854 {D_STR_W_LEN ("9"), 1, 9}, 855 {D_STR_W_LEN ("10"), 2, 10}, 856 {D_STR_W_LEN ("11"), 2, 11}, 857 {D_STR_W_LEN ("12"), 2, 12}, 858 {D_STR_W_LEN ("13"), 2, 13}, 859 {D_STR_W_LEN ("14"), 2, 14}, 860 {D_STR_W_LEN ("15"), 2, 15}, 861 {D_STR_W_LEN ("16"), 2, 16}, 862 {D_STR_W_LEN ("17"), 2, 17}, 863 {D_STR_W_LEN ("18"), 2, 18}, 864 {D_STR_W_LEN ("19"), 2, 19}, 865 {D_STR_W_LEN ("20"), 2, 20}, 866 {D_STR_W_LEN ("21"), 2, 21}, 867 {D_STR_W_LEN ("22"), 2, 22}, 868 {D_STR_W_LEN ("23"), 2, 23}, 869 {D_STR_W_LEN ("24"), 2, 24}, 870 {D_STR_W_LEN ("25"), 2, 25}, 871 {D_STR_W_LEN ("26"), 2, 26}, 872 {D_STR_W_LEN ("27"), 2, 27}, 873 {D_STR_W_LEN ("28"), 2, 28}, 874 {D_STR_W_LEN ("29"), 2, 29}, 875 {D_STR_W_LEN ("30"), 2, 30}, 876 {D_STR_W_LEN ("31"), 2, 31}, 877 {D_STR_W_LEN ("32"), 2, 32}, 878 {D_STR_W_LEN ("33"), 2, 33}, 879 {D_STR_W_LEN ("34"), 2, 34}, 880 {D_STR_W_LEN ("35"), 2, 35}, 881 {D_STR_W_LEN ("36"), 2, 36}, 882 {D_STR_W_LEN ("37"), 2, 37}, 883 {D_STR_W_LEN ("38"), 2, 38}, 884 {D_STR_W_LEN ("39"), 2, 39}, 885 {D_STR_W_LEN ("40"), 2, 40}, 886 {D_STR_W_LEN ("41"), 2, 41}, 887 {D_STR_W_LEN ("42"), 2, 42}, 888 {D_STR_W_LEN ("43"), 2, 43}, 889 {D_STR_W_LEN ("44"), 2, 44}, 890 {D_STR_W_LEN ("45"), 2, 45}, 891 {D_STR_W_LEN ("46"), 2, 46}, 892 {D_STR_W_LEN ("47"), 2, 47}, 893 {D_STR_W_LEN ("48"), 2, 48}, 894 {D_STR_W_LEN ("49"), 2, 49}, 895 {D_STR_W_LEN ("50"), 2, 50}, 896 {D_STR_W_LEN ("51"), 2, 51}, 897 {D_STR_W_LEN ("52"), 2, 52}, 898 {D_STR_W_LEN ("53"), 2, 53}, 899 {D_STR_W_LEN ("54"), 2, 54}, 900 {D_STR_W_LEN ("55"), 2, 55}, 901 {D_STR_W_LEN ("56"), 2, 56}, 902 {D_STR_W_LEN ("57"), 2, 57}, 903 {D_STR_W_LEN ("58"), 2, 58}, 904 {D_STR_W_LEN ("59"), 2, 59}, 905 {D_STR_W_LEN ("60"), 2, 60}, 906 {D_STR_W_LEN ("61"), 2, 61}, 907 {D_STR_W_LEN ("62"), 2, 62}, 908 {D_STR_W_LEN ("63"), 2, 63}, 909 {D_STR_W_LEN ("64"), 2, 64}, 910 {D_STR_W_LEN ("65"), 2, 65}, 911 {D_STR_W_LEN ("66"), 2, 66}, 912 {D_STR_W_LEN ("67"), 2, 67}, 913 {D_STR_W_LEN ("68"), 2, 68}, 914 {D_STR_W_LEN ("69"), 2, 69}, 915 {D_STR_W_LEN ("70"), 2, 70}, 916 {D_STR_W_LEN ("71"), 2, 71}, 917 {D_STR_W_LEN ("72"), 2, 72}, 918 {D_STR_W_LEN ("73"), 2, 73}, 919 {D_STR_W_LEN ("74"), 2, 74}, 920 {D_STR_W_LEN ("75"), 2, 75}, 921 {D_STR_W_LEN ("76"), 2, 76}, 922 {D_STR_W_LEN ("77"), 2, 77}, 923 {D_STR_W_LEN ("78"), 2, 78}, 924 {D_STR_W_LEN ("79"), 2, 79}, 925 {D_STR_W_LEN ("80"), 2, 80}, 926 {D_STR_W_LEN ("81"), 2, 81}, 927 {D_STR_W_LEN ("82"), 2, 82}, 928 {D_STR_W_LEN ("83"), 2, 83}, 929 {D_STR_W_LEN ("84"), 2, 84}, 930 {D_STR_W_LEN ("85"), 2, 85}, 931 {D_STR_W_LEN ("86"), 2, 86}, 932 {D_STR_W_LEN ("87"), 2, 87}, 933 {D_STR_W_LEN ("88"), 2, 88}, 934 {D_STR_W_LEN ("89"), 2, 89}, 935 {D_STR_W_LEN ("90"), 2, 90}, 936 {D_STR_W_LEN ("91"), 2, 91}, 937 {D_STR_W_LEN ("92"), 2, 92}, 938 {D_STR_W_LEN ("93"), 2, 93}, 939 {D_STR_W_LEN ("94"), 2, 94}, 940 {D_STR_W_LEN ("95"), 2, 95}, 941 {D_STR_W_LEN ("96"), 2, 96}, 942 {D_STR_W_LEN ("97"), 2, 97}, 943 {D_STR_W_LEN ("98"), 2, 98}, 944 {D_STR_W_LEN ("99"), 2, 99}, 945 {D_STR_W_LEN ("100"), 3, 100}, 946 {D_STR_W_LEN ("101"), 3, 101}, 947 {D_STR_W_LEN ("102"), 3, 102}, 948 {D_STR_W_LEN ("103"), 3, 103}, 949 {D_STR_W_LEN ("104"), 3, 104}, 950 {D_STR_W_LEN ("105"), 3, 105}, 951 {D_STR_W_LEN ("106"), 3, 106}, 952 {D_STR_W_LEN ("107"), 3, 107}, 953 {D_STR_W_LEN ("108"), 3, 108}, 954 {D_STR_W_LEN ("109"), 3, 109}, 955 {D_STR_W_LEN ("110"), 3, 110}, 956 {D_STR_W_LEN ("111"), 3, 111}, 957 {D_STR_W_LEN ("112"), 3, 112}, 958 {D_STR_W_LEN ("113"), 3, 113}, 959 {D_STR_W_LEN ("114"), 3, 114}, 960 {D_STR_W_LEN ("115"), 3, 115}, 961 {D_STR_W_LEN ("116"), 3, 116}, 962 {D_STR_W_LEN ("117"), 3, 117}, 963 {D_STR_W_LEN ("118"), 3, 118}, 964 {D_STR_W_LEN ("119"), 3, 119}, 965 {D_STR_W_LEN ("120"), 3, 120}, 966 {D_STR_W_LEN ("121"), 3, 121}, 967 {D_STR_W_LEN ("122"), 3, 122}, 968 {D_STR_W_LEN ("123"), 3, 123}, 969 {D_STR_W_LEN ("124"), 3, 124}, 970 {D_STR_W_LEN ("125"), 3, 125}, 971 {D_STR_W_LEN ("126"), 3, 126}, 972 {D_STR_W_LEN ("127"), 3, 127}, 973 {D_STR_W_LEN ("128"), 3, 128}, 974 {D_STR_W_LEN ("129"), 3, 129}, 975 {D_STR_W_LEN ("130"), 3, 130}, 976 {D_STR_W_LEN ("131"), 3, 131}, 977 {D_STR_W_LEN ("132"), 3, 132}, 978 {D_STR_W_LEN ("133"), 3, 133}, 979 {D_STR_W_LEN ("134"), 3, 134}, 980 {D_STR_W_LEN ("135"), 3, 135}, 981 {D_STR_W_LEN ("136"), 3, 136}, 982 {D_STR_W_LEN ("137"), 3, 137}, 983 {D_STR_W_LEN ("138"), 3, 138}, 984 {D_STR_W_LEN ("139"), 3, 139}, 985 {D_STR_W_LEN ("140"), 3, 140}, 986 {D_STR_W_LEN ("141"), 3, 141}, 987 {D_STR_W_LEN ("142"), 3, 142}, 988 {D_STR_W_LEN ("143"), 3, 143}, 989 {D_STR_W_LEN ("144"), 3, 144}, 990 {D_STR_W_LEN ("145"), 3, 145}, 991 {D_STR_W_LEN ("146"), 3, 146}, 992 {D_STR_W_LEN ("147"), 3, 147}, 993 {D_STR_W_LEN ("148"), 3, 148}, 994 {D_STR_W_LEN ("149"), 3, 149}, 995 {D_STR_W_LEN ("150"), 3, 150}, 996 {D_STR_W_LEN ("151"), 3, 151}, 997 {D_STR_W_LEN ("152"), 3, 152}, 998 {D_STR_W_LEN ("153"), 3, 153}, 999 {D_STR_W_LEN ("154"), 3, 154}, 1000 {D_STR_W_LEN ("155"), 3, 155}, 1001 {D_STR_W_LEN ("156"), 3, 156}, 1002 {D_STR_W_LEN ("157"), 3, 157}, 1003 {D_STR_W_LEN ("158"), 3, 158}, 1004 {D_STR_W_LEN ("159"), 3, 159}, 1005 {D_STR_W_LEN ("160"), 3, 160}, 1006 {D_STR_W_LEN ("161"), 3, 161}, 1007 {D_STR_W_LEN ("162"), 3, 162}, 1008 {D_STR_W_LEN ("163"), 3, 163}, 1009 {D_STR_W_LEN ("164"), 3, 164}, 1010 {D_STR_W_LEN ("165"), 3, 165}, 1011 {D_STR_W_LEN ("166"), 3, 166}, 1012 {D_STR_W_LEN ("167"), 3, 167}, 1013 {D_STR_W_LEN ("168"), 3, 168}, 1014 {D_STR_W_LEN ("169"), 3, 169}, 1015 {D_STR_W_LEN ("170"), 3, 170}, 1016 {D_STR_W_LEN ("171"), 3, 171}, 1017 {D_STR_W_LEN ("172"), 3, 172}, 1018 {D_STR_W_LEN ("173"), 3, 173}, 1019 {D_STR_W_LEN ("174"), 3, 174}, 1020 {D_STR_W_LEN ("175"), 3, 175}, 1021 {D_STR_W_LEN ("176"), 3, 176}, 1022 {D_STR_W_LEN ("177"), 3, 177}, 1023 {D_STR_W_LEN ("178"), 3, 178}, 1024 {D_STR_W_LEN ("179"), 3, 179}, 1025 {D_STR_W_LEN ("180"), 3, 180}, 1026 {D_STR_W_LEN ("181"), 3, 181}, 1027 {D_STR_W_LEN ("182"), 3, 182}, 1028 {D_STR_W_LEN ("183"), 3, 183}, 1029 {D_STR_W_LEN ("184"), 3, 184}, 1030 {D_STR_W_LEN ("185"), 3, 185}, 1031 {D_STR_W_LEN ("186"), 3, 186}, 1032 {D_STR_W_LEN ("187"), 3, 187}, 1033 {D_STR_W_LEN ("188"), 3, 188}, 1034 {D_STR_W_LEN ("189"), 3, 189}, 1035 {D_STR_W_LEN ("190"), 3, 190}, 1036 {D_STR_W_LEN ("191"), 3, 191}, 1037 {D_STR_W_LEN ("192"), 3, 192}, 1038 {D_STR_W_LEN ("193"), 3, 193}, 1039 {D_STR_W_LEN ("194"), 3, 194}, 1040 {D_STR_W_LEN ("195"), 3, 195}, 1041 {D_STR_W_LEN ("196"), 3, 196}, 1042 {D_STR_W_LEN ("197"), 3, 197}, 1043 {D_STR_W_LEN ("198"), 3, 198}, 1044 {D_STR_W_LEN ("199"), 3, 199}, 1045 {D_STR_W_LEN ("200"), 3, 200}, 1046 {D_STR_W_LEN ("201"), 3, 201}, 1047 {D_STR_W_LEN ("202"), 3, 202}, 1048 {D_STR_W_LEN ("203"), 3, 203}, 1049 {D_STR_W_LEN ("204"), 3, 204}, 1050 {D_STR_W_LEN ("205"), 3, 205}, 1051 {D_STR_W_LEN ("206"), 3, 206}, 1052 {D_STR_W_LEN ("207"), 3, 207}, 1053 {D_STR_W_LEN ("208"), 3, 208}, 1054 {D_STR_W_LEN ("209"), 3, 209}, 1055 {D_STR_W_LEN ("210"), 3, 210}, 1056 {D_STR_W_LEN ("211"), 3, 211}, 1057 {D_STR_W_LEN ("212"), 3, 212}, 1058 {D_STR_W_LEN ("213"), 3, 213}, 1059 {D_STR_W_LEN ("214"), 3, 214}, 1060 {D_STR_W_LEN ("215"), 3, 215}, 1061 {D_STR_W_LEN ("216"), 3, 216}, 1062 {D_STR_W_LEN ("217"), 3, 217}, 1063 {D_STR_W_LEN ("218"), 3, 218}, 1064 {D_STR_W_LEN ("219"), 3, 219}, 1065 {D_STR_W_LEN ("220"), 3, 220}, 1066 {D_STR_W_LEN ("221"), 3, 221}, 1067 {D_STR_W_LEN ("222"), 3, 222}, 1068 {D_STR_W_LEN ("223"), 3, 223}, 1069 {D_STR_W_LEN ("224"), 3, 224}, 1070 {D_STR_W_LEN ("225"), 3, 225}, 1071 {D_STR_W_LEN ("226"), 3, 226}, 1072 {D_STR_W_LEN ("227"), 3, 227}, 1073 {D_STR_W_LEN ("228"), 3, 228}, 1074 {D_STR_W_LEN ("229"), 3, 229}, 1075 {D_STR_W_LEN ("230"), 3, 230}, 1076 {D_STR_W_LEN ("231"), 3, 231}, 1077 {D_STR_W_LEN ("232"), 3, 232}, 1078 {D_STR_W_LEN ("233"), 3, 233}, 1079 {D_STR_W_LEN ("234"), 3, 234}, 1080 {D_STR_W_LEN ("235"), 3, 235}, 1081 {D_STR_W_LEN ("236"), 3, 236}, 1082 {D_STR_W_LEN ("237"), 3, 237}, 1083 {D_STR_W_LEN ("238"), 3, 238}, 1084 {D_STR_W_LEN ("239"), 3, 239}, 1085 {D_STR_W_LEN ("240"), 3, 240}, 1086 {D_STR_W_LEN ("241"), 3, 241}, 1087 {D_STR_W_LEN ("242"), 3, 242}, 1088 {D_STR_W_LEN ("243"), 3, 243}, 1089 {D_STR_W_LEN ("244"), 3, 244}, 1090 {D_STR_W_LEN ("245"), 3, 245}, 1091 {D_STR_W_LEN ("246"), 3, 246}, 1092 {D_STR_W_LEN ("247"), 3, 247}, 1093 {D_STR_W_LEN ("248"), 3, 248}, 1094 {D_STR_W_LEN ("249"), 3, 249}, 1095 {D_STR_W_LEN ("250"), 3, 250}, 1096 {D_STR_W_LEN ("251"), 3, 251}, 1097 {D_STR_W_LEN ("252"), 3, 252}, 1098 {D_STR_W_LEN ("253"), 3, 253}, 1099 {D_STR_W_LEN ("254"), 3, 254}, 1100 {D_STR_W_LEN ("255"), 3, 255}, 1101 }; 1102 1103 static const struct str_with_value duint8_w_values_p2[] = { 1104 {D_STR_W_LEN ("00"), 2, 0}, 1105 {D_STR_W_LEN ("01"), 2, 1}, 1106 {D_STR_W_LEN ("02"), 2, 2}, 1107 {D_STR_W_LEN ("03"), 2, 3}, 1108 {D_STR_W_LEN ("04"), 2, 4}, 1109 {D_STR_W_LEN ("05"), 2, 5}, 1110 {D_STR_W_LEN ("06"), 2, 6}, 1111 {D_STR_W_LEN ("07"), 2, 7}, 1112 {D_STR_W_LEN ("08"), 2, 8}, 1113 {D_STR_W_LEN ("09"), 2, 9}, 1114 {D_STR_W_LEN ("10"), 2, 10}, 1115 {D_STR_W_LEN ("11"), 2, 11}, 1116 {D_STR_W_LEN ("12"), 2, 12}, 1117 {D_STR_W_LEN ("13"), 2, 13}, 1118 {D_STR_W_LEN ("14"), 2, 14}, 1119 {D_STR_W_LEN ("15"), 2, 15}, 1120 {D_STR_W_LEN ("16"), 2, 16}, 1121 {D_STR_W_LEN ("17"), 2, 17}, 1122 {D_STR_W_LEN ("18"), 2, 18}, 1123 {D_STR_W_LEN ("19"), 2, 19}, 1124 {D_STR_W_LEN ("20"), 2, 20}, 1125 {D_STR_W_LEN ("21"), 2, 21}, 1126 {D_STR_W_LEN ("22"), 2, 22}, 1127 {D_STR_W_LEN ("23"), 2, 23}, 1128 {D_STR_W_LEN ("24"), 2, 24}, 1129 {D_STR_W_LEN ("25"), 2, 25}, 1130 {D_STR_W_LEN ("26"), 2, 26}, 1131 {D_STR_W_LEN ("27"), 2, 27}, 1132 {D_STR_W_LEN ("28"), 2, 28}, 1133 {D_STR_W_LEN ("29"), 2, 29}, 1134 {D_STR_W_LEN ("30"), 2, 30}, 1135 {D_STR_W_LEN ("31"), 2, 31}, 1136 {D_STR_W_LEN ("32"), 2, 32}, 1137 {D_STR_W_LEN ("33"), 2, 33}, 1138 {D_STR_W_LEN ("34"), 2, 34}, 1139 {D_STR_W_LEN ("35"), 2, 35}, 1140 {D_STR_W_LEN ("36"), 2, 36}, 1141 {D_STR_W_LEN ("37"), 2, 37}, 1142 {D_STR_W_LEN ("38"), 2, 38}, 1143 {D_STR_W_LEN ("39"), 2, 39}, 1144 {D_STR_W_LEN ("40"), 2, 40}, 1145 {D_STR_W_LEN ("41"), 2, 41}, 1146 {D_STR_W_LEN ("42"), 2, 42}, 1147 {D_STR_W_LEN ("43"), 2, 43}, 1148 {D_STR_W_LEN ("44"), 2, 44}, 1149 {D_STR_W_LEN ("45"), 2, 45}, 1150 {D_STR_W_LEN ("46"), 2, 46}, 1151 {D_STR_W_LEN ("47"), 2, 47}, 1152 {D_STR_W_LEN ("48"), 2, 48}, 1153 {D_STR_W_LEN ("49"), 2, 49}, 1154 {D_STR_W_LEN ("50"), 2, 50}, 1155 {D_STR_W_LEN ("51"), 2, 51}, 1156 {D_STR_W_LEN ("52"), 2, 52}, 1157 {D_STR_W_LEN ("53"), 2, 53}, 1158 {D_STR_W_LEN ("54"), 2, 54}, 1159 {D_STR_W_LEN ("55"), 2, 55}, 1160 {D_STR_W_LEN ("56"), 2, 56}, 1161 {D_STR_W_LEN ("57"), 2, 57}, 1162 {D_STR_W_LEN ("58"), 2, 58}, 1163 {D_STR_W_LEN ("59"), 2, 59}, 1164 {D_STR_W_LEN ("60"), 2, 60}, 1165 {D_STR_W_LEN ("61"), 2, 61}, 1166 {D_STR_W_LEN ("62"), 2, 62}, 1167 {D_STR_W_LEN ("63"), 2, 63}, 1168 {D_STR_W_LEN ("64"), 2, 64}, 1169 {D_STR_W_LEN ("65"), 2, 65}, 1170 {D_STR_W_LEN ("66"), 2, 66}, 1171 {D_STR_W_LEN ("67"), 2, 67}, 1172 {D_STR_W_LEN ("68"), 2, 68}, 1173 {D_STR_W_LEN ("69"), 2, 69}, 1174 {D_STR_W_LEN ("70"), 2, 70}, 1175 {D_STR_W_LEN ("71"), 2, 71}, 1176 {D_STR_W_LEN ("72"), 2, 72}, 1177 {D_STR_W_LEN ("73"), 2, 73}, 1178 {D_STR_W_LEN ("74"), 2, 74}, 1179 {D_STR_W_LEN ("75"), 2, 75}, 1180 {D_STR_W_LEN ("76"), 2, 76}, 1181 {D_STR_W_LEN ("77"), 2, 77}, 1182 {D_STR_W_LEN ("78"), 2, 78}, 1183 {D_STR_W_LEN ("79"), 2, 79}, 1184 {D_STR_W_LEN ("80"), 2, 80}, 1185 {D_STR_W_LEN ("81"), 2, 81}, 1186 {D_STR_W_LEN ("82"), 2, 82}, 1187 {D_STR_W_LEN ("83"), 2, 83}, 1188 {D_STR_W_LEN ("84"), 2, 84}, 1189 {D_STR_W_LEN ("85"), 2, 85}, 1190 {D_STR_W_LEN ("86"), 2, 86}, 1191 {D_STR_W_LEN ("87"), 2, 87}, 1192 {D_STR_W_LEN ("88"), 2, 88}, 1193 {D_STR_W_LEN ("89"), 2, 89}, 1194 {D_STR_W_LEN ("90"), 2, 90}, 1195 {D_STR_W_LEN ("91"), 2, 91}, 1196 {D_STR_W_LEN ("92"), 2, 92}, 1197 {D_STR_W_LEN ("93"), 2, 93}, 1198 {D_STR_W_LEN ("94"), 2, 94}, 1199 {D_STR_W_LEN ("95"), 2, 95}, 1200 {D_STR_W_LEN ("96"), 2, 96}, 1201 {D_STR_W_LEN ("97"), 2, 97}, 1202 {D_STR_W_LEN ("98"), 2, 98}, 1203 {D_STR_W_LEN ("99"), 2, 99}, 1204 {D_STR_W_LEN ("100"), 3, 100}, 1205 {D_STR_W_LEN ("101"), 3, 101}, 1206 {D_STR_W_LEN ("102"), 3, 102}, 1207 {D_STR_W_LEN ("103"), 3, 103}, 1208 {D_STR_W_LEN ("104"), 3, 104}, 1209 {D_STR_W_LEN ("105"), 3, 105}, 1210 {D_STR_W_LEN ("106"), 3, 106}, 1211 {D_STR_W_LEN ("107"), 3, 107}, 1212 {D_STR_W_LEN ("108"), 3, 108}, 1213 {D_STR_W_LEN ("109"), 3, 109}, 1214 {D_STR_W_LEN ("110"), 3, 110}, 1215 {D_STR_W_LEN ("111"), 3, 111}, 1216 {D_STR_W_LEN ("112"), 3, 112}, 1217 {D_STR_W_LEN ("113"), 3, 113}, 1218 {D_STR_W_LEN ("114"), 3, 114}, 1219 {D_STR_W_LEN ("115"), 3, 115}, 1220 {D_STR_W_LEN ("116"), 3, 116}, 1221 {D_STR_W_LEN ("117"), 3, 117}, 1222 {D_STR_W_LEN ("118"), 3, 118}, 1223 {D_STR_W_LEN ("119"), 3, 119}, 1224 {D_STR_W_LEN ("120"), 3, 120}, 1225 {D_STR_W_LEN ("121"), 3, 121}, 1226 {D_STR_W_LEN ("122"), 3, 122}, 1227 {D_STR_W_LEN ("123"), 3, 123}, 1228 {D_STR_W_LEN ("124"), 3, 124}, 1229 {D_STR_W_LEN ("125"), 3, 125}, 1230 {D_STR_W_LEN ("126"), 3, 126}, 1231 {D_STR_W_LEN ("127"), 3, 127}, 1232 {D_STR_W_LEN ("128"), 3, 128}, 1233 {D_STR_W_LEN ("129"), 3, 129}, 1234 {D_STR_W_LEN ("130"), 3, 130}, 1235 {D_STR_W_LEN ("131"), 3, 131}, 1236 {D_STR_W_LEN ("132"), 3, 132}, 1237 {D_STR_W_LEN ("133"), 3, 133}, 1238 {D_STR_W_LEN ("134"), 3, 134}, 1239 {D_STR_W_LEN ("135"), 3, 135}, 1240 {D_STR_W_LEN ("136"), 3, 136}, 1241 {D_STR_W_LEN ("137"), 3, 137}, 1242 {D_STR_W_LEN ("138"), 3, 138}, 1243 {D_STR_W_LEN ("139"), 3, 139}, 1244 {D_STR_W_LEN ("140"), 3, 140}, 1245 {D_STR_W_LEN ("141"), 3, 141}, 1246 {D_STR_W_LEN ("142"), 3, 142}, 1247 {D_STR_W_LEN ("143"), 3, 143}, 1248 {D_STR_W_LEN ("144"), 3, 144}, 1249 {D_STR_W_LEN ("145"), 3, 145}, 1250 {D_STR_W_LEN ("146"), 3, 146}, 1251 {D_STR_W_LEN ("147"), 3, 147}, 1252 {D_STR_W_LEN ("148"), 3, 148}, 1253 {D_STR_W_LEN ("149"), 3, 149}, 1254 {D_STR_W_LEN ("150"), 3, 150}, 1255 {D_STR_W_LEN ("151"), 3, 151}, 1256 {D_STR_W_LEN ("152"), 3, 152}, 1257 {D_STR_W_LEN ("153"), 3, 153}, 1258 {D_STR_W_LEN ("154"), 3, 154}, 1259 {D_STR_W_LEN ("155"), 3, 155}, 1260 {D_STR_W_LEN ("156"), 3, 156}, 1261 {D_STR_W_LEN ("157"), 3, 157}, 1262 {D_STR_W_LEN ("158"), 3, 158}, 1263 {D_STR_W_LEN ("159"), 3, 159}, 1264 {D_STR_W_LEN ("160"), 3, 160}, 1265 {D_STR_W_LEN ("161"), 3, 161}, 1266 {D_STR_W_LEN ("162"), 3, 162}, 1267 {D_STR_W_LEN ("163"), 3, 163}, 1268 {D_STR_W_LEN ("164"), 3, 164}, 1269 {D_STR_W_LEN ("165"), 3, 165}, 1270 {D_STR_W_LEN ("166"), 3, 166}, 1271 {D_STR_W_LEN ("167"), 3, 167}, 1272 {D_STR_W_LEN ("168"), 3, 168}, 1273 {D_STR_W_LEN ("169"), 3, 169}, 1274 {D_STR_W_LEN ("170"), 3, 170}, 1275 {D_STR_W_LEN ("171"), 3, 171}, 1276 {D_STR_W_LEN ("172"), 3, 172}, 1277 {D_STR_W_LEN ("173"), 3, 173}, 1278 {D_STR_W_LEN ("174"), 3, 174}, 1279 {D_STR_W_LEN ("175"), 3, 175}, 1280 {D_STR_W_LEN ("176"), 3, 176}, 1281 {D_STR_W_LEN ("177"), 3, 177}, 1282 {D_STR_W_LEN ("178"), 3, 178}, 1283 {D_STR_W_LEN ("179"), 3, 179}, 1284 {D_STR_W_LEN ("180"), 3, 180}, 1285 {D_STR_W_LEN ("181"), 3, 181}, 1286 {D_STR_W_LEN ("182"), 3, 182}, 1287 {D_STR_W_LEN ("183"), 3, 183}, 1288 {D_STR_W_LEN ("184"), 3, 184}, 1289 {D_STR_W_LEN ("185"), 3, 185}, 1290 {D_STR_W_LEN ("186"), 3, 186}, 1291 {D_STR_W_LEN ("187"), 3, 187}, 1292 {D_STR_W_LEN ("188"), 3, 188}, 1293 {D_STR_W_LEN ("189"), 3, 189}, 1294 {D_STR_W_LEN ("190"), 3, 190}, 1295 {D_STR_W_LEN ("191"), 3, 191}, 1296 {D_STR_W_LEN ("192"), 3, 192}, 1297 {D_STR_W_LEN ("193"), 3, 193}, 1298 {D_STR_W_LEN ("194"), 3, 194}, 1299 {D_STR_W_LEN ("195"), 3, 195}, 1300 {D_STR_W_LEN ("196"), 3, 196}, 1301 {D_STR_W_LEN ("197"), 3, 197}, 1302 {D_STR_W_LEN ("198"), 3, 198}, 1303 {D_STR_W_LEN ("199"), 3, 199}, 1304 {D_STR_W_LEN ("200"), 3, 200}, 1305 {D_STR_W_LEN ("201"), 3, 201}, 1306 {D_STR_W_LEN ("202"), 3, 202}, 1307 {D_STR_W_LEN ("203"), 3, 203}, 1308 {D_STR_W_LEN ("204"), 3, 204}, 1309 {D_STR_W_LEN ("205"), 3, 205}, 1310 {D_STR_W_LEN ("206"), 3, 206}, 1311 {D_STR_W_LEN ("207"), 3, 207}, 1312 {D_STR_W_LEN ("208"), 3, 208}, 1313 {D_STR_W_LEN ("209"), 3, 209}, 1314 {D_STR_W_LEN ("210"), 3, 210}, 1315 {D_STR_W_LEN ("211"), 3, 211}, 1316 {D_STR_W_LEN ("212"), 3, 212}, 1317 {D_STR_W_LEN ("213"), 3, 213}, 1318 {D_STR_W_LEN ("214"), 3, 214}, 1319 {D_STR_W_LEN ("215"), 3, 215}, 1320 {D_STR_W_LEN ("216"), 3, 216}, 1321 {D_STR_W_LEN ("217"), 3, 217}, 1322 {D_STR_W_LEN ("218"), 3, 218}, 1323 {D_STR_W_LEN ("219"), 3, 219}, 1324 {D_STR_W_LEN ("220"), 3, 220}, 1325 {D_STR_W_LEN ("221"), 3, 221}, 1326 {D_STR_W_LEN ("222"), 3, 222}, 1327 {D_STR_W_LEN ("223"), 3, 223}, 1328 {D_STR_W_LEN ("224"), 3, 224}, 1329 {D_STR_W_LEN ("225"), 3, 225}, 1330 {D_STR_W_LEN ("226"), 3, 226}, 1331 {D_STR_W_LEN ("227"), 3, 227}, 1332 {D_STR_W_LEN ("228"), 3, 228}, 1333 {D_STR_W_LEN ("229"), 3, 229}, 1334 {D_STR_W_LEN ("230"), 3, 230}, 1335 {D_STR_W_LEN ("231"), 3, 231}, 1336 {D_STR_W_LEN ("232"), 3, 232}, 1337 {D_STR_W_LEN ("233"), 3, 233}, 1338 {D_STR_W_LEN ("234"), 3, 234}, 1339 {D_STR_W_LEN ("235"), 3, 235}, 1340 {D_STR_W_LEN ("236"), 3, 236}, 1341 {D_STR_W_LEN ("237"), 3, 237}, 1342 {D_STR_W_LEN ("238"), 3, 238}, 1343 {D_STR_W_LEN ("239"), 3, 239}, 1344 {D_STR_W_LEN ("240"), 3, 240}, 1345 {D_STR_W_LEN ("241"), 3, 241}, 1346 {D_STR_W_LEN ("242"), 3, 242}, 1347 {D_STR_W_LEN ("243"), 3, 243}, 1348 {D_STR_W_LEN ("244"), 3, 244}, 1349 {D_STR_W_LEN ("245"), 3, 245}, 1350 {D_STR_W_LEN ("246"), 3, 246}, 1351 {D_STR_W_LEN ("247"), 3, 247}, 1352 {D_STR_W_LEN ("248"), 3, 248}, 1353 {D_STR_W_LEN ("249"), 3, 249}, 1354 {D_STR_W_LEN ("250"), 3, 250}, 1355 {D_STR_W_LEN ("251"), 3, 251}, 1356 {D_STR_W_LEN ("252"), 3, 252}, 1357 {D_STR_W_LEN ("253"), 3, 253}, 1358 {D_STR_W_LEN ("254"), 3, 254}, 1359 {D_STR_W_LEN ("255"), 3, 255} 1360 }; 1361 1362 static const struct str_with_value duint8_w_values_p3[] = { 1363 {D_STR_W_LEN ("000"), 3, 0}, 1364 {D_STR_W_LEN ("001"), 3, 1}, 1365 {D_STR_W_LEN ("002"), 3, 2}, 1366 {D_STR_W_LEN ("003"), 3, 3}, 1367 {D_STR_W_LEN ("004"), 3, 4}, 1368 {D_STR_W_LEN ("005"), 3, 5}, 1369 {D_STR_W_LEN ("006"), 3, 6}, 1370 {D_STR_W_LEN ("007"), 3, 7}, 1371 {D_STR_W_LEN ("008"), 3, 8}, 1372 {D_STR_W_LEN ("009"), 3, 9}, 1373 {D_STR_W_LEN ("010"), 3, 10}, 1374 {D_STR_W_LEN ("011"), 3, 11}, 1375 {D_STR_W_LEN ("012"), 3, 12}, 1376 {D_STR_W_LEN ("013"), 3, 13}, 1377 {D_STR_W_LEN ("014"), 3, 14}, 1378 {D_STR_W_LEN ("015"), 3, 15}, 1379 {D_STR_W_LEN ("016"), 3, 16}, 1380 {D_STR_W_LEN ("017"), 3, 17}, 1381 {D_STR_W_LEN ("018"), 3, 18}, 1382 {D_STR_W_LEN ("019"), 3, 19}, 1383 {D_STR_W_LEN ("020"), 3, 20}, 1384 {D_STR_W_LEN ("021"), 3, 21}, 1385 {D_STR_W_LEN ("022"), 3, 22}, 1386 {D_STR_W_LEN ("023"), 3, 23}, 1387 {D_STR_W_LEN ("024"), 3, 24}, 1388 {D_STR_W_LEN ("025"), 3, 25}, 1389 {D_STR_W_LEN ("026"), 3, 26}, 1390 {D_STR_W_LEN ("027"), 3, 27}, 1391 {D_STR_W_LEN ("028"), 3, 28}, 1392 {D_STR_W_LEN ("029"), 3, 29}, 1393 {D_STR_W_LEN ("030"), 3, 30}, 1394 {D_STR_W_LEN ("031"), 3, 31}, 1395 {D_STR_W_LEN ("032"), 3, 32}, 1396 {D_STR_W_LEN ("033"), 3, 33}, 1397 {D_STR_W_LEN ("034"), 3, 34}, 1398 {D_STR_W_LEN ("035"), 3, 35}, 1399 {D_STR_W_LEN ("036"), 3, 36}, 1400 {D_STR_W_LEN ("037"), 3, 37}, 1401 {D_STR_W_LEN ("038"), 3, 38}, 1402 {D_STR_W_LEN ("039"), 3, 39}, 1403 {D_STR_W_LEN ("040"), 3, 40}, 1404 {D_STR_W_LEN ("041"), 3, 41}, 1405 {D_STR_W_LEN ("042"), 3, 42}, 1406 {D_STR_W_LEN ("043"), 3, 43}, 1407 {D_STR_W_LEN ("044"), 3, 44}, 1408 {D_STR_W_LEN ("045"), 3, 45}, 1409 {D_STR_W_LEN ("046"), 3, 46}, 1410 {D_STR_W_LEN ("047"), 3, 47}, 1411 {D_STR_W_LEN ("048"), 3, 48}, 1412 {D_STR_W_LEN ("049"), 3, 49}, 1413 {D_STR_W_LEN ("050"), 3, 50}, 1414 {D_STR_W_LEN ("051"), 3, 51}, 1415 {D_STR_W_LEN ("052"), 3, 52}, 1416 {D_STR_W_LEN ("053"), 3, 53}, 1417 {D_STR_W_LEN ("054"), 3, 54}, 1418 {D_STR_W_LEN ("055"), 3, 55}, 1419 {D_STR_W_LEN ("056"), 3, 56}, 1420 {D_STR_W_LEN ("057"), 3, 57}, 1421 {D_STR_W_LEN ("058"), 3, 58}, 1422 {D_STR_W_LEN ("059"), 3, 59}, 1423 {D_STR_W_LEN ("060"), 3, 60}, 1424 {D_STR_W_LEN ("061"), 3, 61}, 1425 {D_STR_W_LEN ("062"), 3, 62}, 1426 {D_STR_W_LEN ("063"), 3, 63}, 1427 {D_STR_W_LEN ("064"), 3, 64}, 1428 {D_STR_W_LEN ("065"), 3, 65}, 1429 {D_STR_W_LEN ("066"), 3, 66}, 1430 {D_STR_W_LEN ("067"), 3, 67}, 1431 {D_STR_W_LEN ("068"), 3, 68}, 1432 {D_STR_W_LEN ("069"), 3, 69}, 1433 {D_STR_W_LEN ("070"), 3, 70}, 1434 {D_STR_W_LEN ("071"), 3, 71}, 1435 {D_STR_W_LEN ("072"), 3, 72}, 1436 {D_STR_W_LEN ("073"), 3, 73}, 1437 {D_STR_W_LEN ("074"), 3, 74}, 1438 {D_STR_W_LEN ("075"), 3, 75}, 1439 {D_STR_W_LEN ("076"), 3, 76}, 1440 {D_STR_W_LEN ("077"), 3, 77}, 1441 {D_STR_W_LEN ("078"), 3, 78}, 1442 {D_STR_W_LEN ("079"), 3, 79}, 1443 {D_STR_W_LEN ("080"), 3, 80}, 1444 {D_STR_W_LEN ("081"), 3, 81}, 1445 {D_STR_W_LEN ("082"), 3, 82}, 1446 {D_STR_W_LEN ("083"), 3, 83}, 1447 {D_STR_W_LEN ("084"), 3, 84}, 1448 {D_STR_W_LEN ("085"), 3, 85}, 1449 {D_STR_W_LEN ("086"), 3, 86}, 1450 {D_STR_W_LEN ("087"), 3, 87}, 1451 {D_STR_W_LEN ("088"), 3, 88}, 1452 {D_STR_W_LEN ("089"), 3, 89}, 1453 {D_STR_W_LEN ("090"), 3, 90}, 1454 {D_STR_W_LEN ("091"), 3, 91}, 1455 {D_STR_W_LEN ("092"), 3, 92}, 1456 {D_STR_W_LEN ("093"), 3, 93}, 1457 {D_STR_W_LEN ("094"), 3, 94}, 1458 {D_STR_W_LEN ("095"), 3, 95}, 1459 {D_STR_W_LEN ("096"), 3, 96}, 1460 {D_STR_W_LEN ("097"), 3, 97}, 1461 {D_STR_W_LEN ("098"), 3, 98}, 1462 {D_STR_W_LEN ("099"), 3, 99}, 1463 {D_STR_W_LEN ("100"), 3, 100}, 1464 {D_STR_W_LEN ("101"), 3, 101}, 1465 {D_STR_W_LEN ("102"), 3, 102}, 1466 {D_STR_W_LEN ("103"), 3, 103}, 1467 {D_STR_W_LEN ("104"), 3, 104}, 1468 {D_STR_W_LEN ("105"), 3, 105}, 1469 {D_STR_W_LEN ("106"), 3, 106}, 1470 {D_STR_W_LEN ("107"), 3, 107}, 1471 {D_STR_W_LEN ("108"), 3, 108}, 1472 {D_STR_W_LEN ("109"), 3, 109}, 1473 {D_STR_W_LEN ("110"), 3, 110}, 1474 {D_STR_W_LEN ("111"), 3, 111}, 1475 {D_STR_W_LEN ("112"), 3, 112}, 1476 {D_STR_W_LEN ("113"), 3, 113}, 1477 {D_STR_W_LEN ("114"), 3, 114}, 1478 {D_STR_W_LEN ("115"), 3, 115}, 1479 {D_STR_W_LEN ("116"), 3, 116}, 1480 {D_STR_W_LEN ("117"), 3, 117}, 1481 {D_STR_W_LEN ("118"), 3, 118}, 1482 {D_STR_W_LEN ("119"), 3, 119}, 1483 {D_STR_W_LEN ("120"), 3, 120}, 1484 {D_STR_W_LEN ("121"), 3, 121}, 1485 {D_STR_W_LEN ("122"), 3, 122}, 1486 {D_STR_W_LEN ("123"), 3, 123}, 1487 {D_STR_W_LEN ("124"), 3, 124}, 1488 {D_STR_W_LEN ("125"), 3, 125}, 1489 {D_STR_W_LEN ("126"), 3, 126}, 1490 {D_STR_W_LEN ("127"), 3, 127}, 1491 {D_STR_W_LEN ("128"), 3, 128}, 1492 {D_STR_W_LEN ("129"), 3, 129}, 1493 {D_STR_W_LEN ("130"), 3, 130}, 1494 {D_STR_W_LEN ("131"), 3, 131}, 1495 {D_STR_W_LEN ("132"), 3, 132}, 1496 {D_STR_W_LEN ("133"), 3, 133}, 1497 {D_STR_W_LEN ("134"), 3, 134}, 1498 {D_STR_W_LEN ("135"), 3, 135}, 1499 {D_STR_W_LEN ("136"), 3, 136}, 1500 {D_STR_W_LEN ("137"), 3, 137}, 1501 {D_STR_W_LEN ("138"), 3, 138}, 1502 {D_STR_W_LEN ("139"), 3, 139}, 1503 {D_STR_W_LEN ("140"), 3, 140}, 1504 {D_STR_W_LEN ("141"), 3, 141}, 1505 {D_STR_W_LEN ("142"), 3, 142}, 1506 {D_STR_W_LEN ("143"), 3, 143}, 1507 {D_STR_W_LEN ("144"), 3, 144}, 1508 {D_STR_W_LEN ("145"), 3, 145}, 1509 {D_STR_W_LEN ("146"), 3, 146}, 1510 {D_STR_W_LEN ("147"), 3, 147}, 1511 {D_STR_W_LEN ("148"), 3, 148}, 1512 {D_STR_W_LEN ("149"), 3, 149}, 1513 {D_STR_W_LEN ("150"), 3, 150}, 1514 {D_STR_W_LEN ("151"), 3, 151}, 1515 {D_STR_W_LEN ("152"), 3, 152}, 1516 {D_STR_W_LEN ("153"), 3, 153}, 1517 {D_STR_W_LEN ("154"), 3, 154}, 1518 {D_STR_W_LEN ("155"), 3, 155}, 1519 {D_STR_W_LEN ("156"), 3, 156}, 1520 {D_STR_W_LEN ("157"), 3, 157}, 1521 {D_STR_W_LEN ("158"), 3, 158}, 1522 {D_STR_W_LEN ("159"), 3, 159}, 1523 {D_STR_W_LEN ("160"), 3, 160}, 1524 {D_STR_W_LEN ("161"), 3, 161}, 1525 {D_STR_W_LEN ("162"), 3, 162}, 1526 {D_STR_W_LEN ("163"), 3, 163}, 1527 {D_STR_W_LEN ("164"), 3, 164}, 1528 {D_STR_W_LEN ("165"), 3, 165}, 1529 {D_STR_W_LEN ("166"), 3, 166}, 1530 {D_STR_W_LEN ("167"), 3, 167}, 1531 {D_STR_W_LEN ("168"), 3, 168}, 1532 {D_STR_W_LEN ("169"), 3, 169}, 1533 {D_STR_W_LEN ("170"), 3, 170}, 1534 {D_STR_W_LEN ("171"), 3, 171}, 1535 {D_STR_W_LEN ("172"), 3, 172}, 1536 {D_STR_W_LEN ("173"), 3, 173}, 1537 {D_STR_W_LEN ("174"), 3, 174}, 1538 {D_STR_W_LEN ("175"), 3, 175}, 1539 {D_STR_W_LEN ("176"), 3, 176}, 1540 {D_STR_W_LEN ("177"), 3, 177}, 1541 {D_STR_W_LEN ("178"), 3, 178}, 1542 {D_STR_W_LEN ("179"), 3, 179}, 1543 {D_STR_W_LEN ("180"), 3, 180}, 1544 {D_STR_W_LEN ("181"), 3, 181}, 1545 {D_STR_W_LEN ("182"), 3, 182}, 1546 {D_STR_W_LEN ("183"), 3, 183}, 1547 {D_STR_W_LEN ("184"), 3, 184}, 1548 {D_STR_W_LEN ("185"), 3, 185}, 1549 {D_STR_W_LEN ("186"), 3, 186}, 1550 {D_STR_W_LEN ("187"), 3, 187}, 1551 {D_STR_W_LEN ("188"), 3, 188}, 1552 {D_STR_W_LEN ("189"), 3, 189}, 1553 {D_STR_W_LEN ("190"), 3, 190}, 1554 {D_STR_W_LEN ("191"), 3, 191}, 1555 {D_STR_W_LEN ("192"), 3, 192}, 1556 {D_STR_W_LEN ("193"), 3, 193}, 1557 {D_STR_W_LEN ("194"), 3, 194}, 1558 {D_STR_W_LEN ("195"), 3, 195}, 1559 {D_STR_W_LEN ("196"), 3, 196}, 1560 {D_STR_W_LEN ("197"), 3, 197}, 1561 {D_STR_W_LEN ("198"), 3, 198}, 1562 {D_STR_W_LEN ("199"), 3, 199}, 1563 {D_STR_W_LEN ("200"), 3, 200}, 1564 {D_STR_W_LEN ("201"), 3, 201}, 1565 {D_STR_W_LEN ("202"), 3, 202}, 1566 {D_STR_W_LEN ("203"), 3, 203}, 1567 {D_STR_W_LEN ("204"), 3, 204}, 1568 {D_STR_W_LEN ("205"), 3, 205}, 1569 {D_STR_W_LEN ("206"), 3, 206}, 1570 {D_STR_W_LEN ("207"), 3, 207}, 1571 {D_STR_W_LEN ("208"), 3, 208}, 1572 {D_STR_W_LEN ("209"), 3, 209}, 1573 {D_STR_W_LEN ("210"), 3, 210}, 1574 {D_STR_W_LEN ("211"), 3, 211}, 1575 {D_STR_W_LEN ("212"), 3, 212}, 1576 {D_STR_W_LEN ("213"), 3, 213}, 1577 {D_STR_W_LEN ("214"), 3, 214}, 1578 {D_STR_W_LEN ("215"), 3, 215}, 1579 {D_STR_W_LEN ("216"), 3, 216}, 1580 {D_STR_W_LEN ("217"), 3, 217}, 1581 {D_STR_W_LEN ("218"), 3, 218}, 1582 {D_STR_W_LEN ("219"), 3, 219}, 1583 {D_STR_W_LEN ("220"), 3, 220}, 1584 {D_STR_W_LEN ("221"), 3, 221}, 1585 {D_STR_W_LEN ("222"), 3, 222}, 1586 {D_STR_W_LEN ("223"), 3, 223}, 1587 {D_STR_W_LEN ("224"), 3, 224}, 1588 {D_STR_W_LEN ("225"), 3, 225}, 1589 {D_STR_W_LEN ("226"), 3, 226}, 1590 {D_STR_W_LEN ("227"), 3, 227}, 1591 {D_STR_W_LEN ("228"), 3, 228}, 1592 {D_STR_W_LEN ("229"), 3, 229}, 1593 {D_STR_W_LEN ("230"), 3, 230}, 1594 {D_STR_W_LEN ("231"), 3, 231}, 1595 {D_STR_W_LEN ("232"), 3, 232}, 1596 {D_STR_W_LEN ("233"), 3, 233}, 1597 {D_STR_W_LEN ("234"), 3, 234}, 1598 {D_STR_W_LEN ("235"), 3, 235}, 1599 {D_STR_W_LEN ("236"), 3, 236}, 1600 {D_STR_W_LEN ("237"), 3, 237}, 1601 {D_STR_W_LEN ("238"), 3, 238}, 1602 {D_STR_W_LEN ("239"), 3, 239}, 1603 {D_STR_W_LEN ("240"), 3, 240}, 1604 {D_STR_W_LEN ("241"), 3, 241}, 1605 {D_STR_W_LEN ("242"), 3, 242}, 1606 {D_STR_W_LEN ("243"), 3, 243}, 1607 {D_STR_W_LEN ("244"), 3, 244}, 1608 {D_STR_W_LEN ("245"), 3, 245}, 1609 {D_STR_W_LEN ("246"), 3, 246}, 1610 {D_STR_W_LEN ("247"), 3, 247}, 1611 {D_STR_W_LEN ("248"), 3, 248}, 1612 {D_STR_W_LEN ("249"), 3, 249}, 1613 {D_STR_W_LEN ("250"), 3, 250}, 1614 {D_STR_W_LEN ("251"), 3, 251}, 1615 {D_STR_W_LEN ("252"), 3, 252}, 1616 {D_STR_W_LEN ("253"), 3, 253}, 1617 {D_STR_W_LEN ("254"), 3, 254}, 1618 {D_STR_W_LEN ("255"), 3, 255} 1619 }; 1620 1621 1622 static const struct str_with_value *duint8_w_values_p[3] = 1623 {duint8_w_values_p1, duint8_w_values_p2, duint8_w_values_p3}; 1624 1625 static size_t 1626 check_str_from_uint8_pad (void) 1627 { 1628 int i; 1629 uint8_t pad; 1630 size_t t_failed = 0; 1631 1632 if ((256 != sizeof(duint8_w_values_p1) / sizeof(duint8_w_values_p1[0])) || 1633 (256 != sizeof(duint8_w_values_p2) / sizeof(duint8_w_values_p2[0])) || 1634 (256 != sizeof(duint8_w_values_p3) / sizeof(duint8_w_values_p3[0]))) 1635 { 1636 fprintf (stderr, 1637 "ERROR: wrong number of items in duint8_w_values_p*.\n"); 1638 exit (99); 1639 } 1640 for (pad = 0; pad <= 3; pad++) 1641 { 1642 size_t table_num; 1643 if (0 != pad) 1644 table_num = pad - 1; 1645 else 1646 table_num = 0; 1647 1648 for (i = 0; i <= 255; i++) 1649 { 1650 const struct str_with_value *const t = duint8_w_values_p[table_num] + i; 1651 size_t b_size; 1652 size_t rs; 1653 char buf[8]; 1654 1655 if (t->str.len < t->num_of_digt) 1656 { 1657 fprintf (stderr, 1658 "ERROR: dstrs_w_values[%u] has wrong num_of_digt (%u): num_of_digt is expected" 1659 " to be less or equal to str.len (%u).\n", 1660 (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned 1661 int) t->str. 1662 len); 1663 exit (99); 1664 } 1665 if (sizeof(buf) < t->str.len + 1) 1666 { 1667 fprintf (stderr, 1668 "ERROR: dstrs_w_values[%u] has too long (%u) string, " 1669 "size of 'buf' should be increased.\n", 1670 (unsigned int) i, (unsigned int) t->str.len); 1671 exit (99); 1672 } 1673 for (b_size = 0; b_size <= t->str.len + 1; ++b_size) 1674 { 1675 /* fill buffer with pseudo-random values */ 1676 memset (buf, '#', sizeof(buf)); 1677 1678 rs = mhd_uint8_to_str_pad ((uint8_t) t->val, pad, buf, b_size); 1679 1680 if (t->num_of_digt > b_size) 1681 { 1682 /* Must fail, buffer is too small for result */ 1683 if (0 != rs) 1684 { 1685 t_failed++; 1686 fprintf (stderr, 1687 "FAILED: mhd_uint8_to_str_pad(%" PRIu64 ", %d, -> buf," 1688 " %d) returned %" PRIuPTR 1689 ", while expecting 0.\n", t->val, (int) pad, (int) b_size, 1690 (uintptr_t) rs); 1691 } 1692 } 1693 else 1694 { 1695 if (t->num_of_digt != rs) 1696 { 1697 t_failed++; 1698 fprintf (stderr, 1699 "FAILED: mhd_uint8_to_str_pad(%" PRIu64 ", %d, -> buf," 1700 " %d) returned %" PRIuPTR 1701 ", while expecting %d.\n", t->val, (int) pad, 1702 (int) b_size, (uintptr_t) rs, (int) t->num_of_digt); 1703 } 1704 else if (0 != memcmp (buf, t->str.str, t->num_of_digt)) 1705 { 1706 t_failed++; 1707 fprintf (stderr, 1708 "FAILED: mhd_uint8_to_str_pad(%" PRIu64 ", %d, " 1709 "-> \"%.*s\", %d) returned %" PRIuPTR ".\n", 1710 t->val, (int) pad, (int) rs, buf, 1711 (int) b_size, (uintptr_t) rs); 1712 } 1713 else if (0 != memcmp (buf + rs, "########", sizeof(buf) - rs)) 1714 { 1715 t_failed++; 1716 fprintf (stderr, 1717 "FAILED: mhd_uint8_to_str_pad(%" PRIu64 ", %d," 1718 " -> \"%.*s\", %d) returned %" PRIuPTR 1719 " and touched data after the resulting string.\n", 1720 t->val, (int) pad, (int) rs, buf, (int) b_size, 1721 (uintptr_t) rs); 1722 } 1723 } 1724 } 1725 } 1726 } 1727 if ((verbose > 1) && (0 == t_failed)) 1728 printf ("PASSED: mhd_uint8_to_str_pad.\n"); 1729 1730 return t_failed; 1731 } 1732 1733 1734 static int 1735 run_str_from_X_tests (void) 1736 { 1737 size_t str_from_uint16; 1738 size_t str_from_uint64; 1739 size_t strx_from_uint32; 1740 size_t str_from_uint8_pad; 1741 size_t failures; 1742 1743 failures = 0; 1744 1745 str_from_uint16 = check_str_from_uint16 (); 1746 if (str_from_uint16 != 0) 1747 { 1748 fprintf (stderr, 1749 "FAILED: testcase check_str_from_uint16() failed.\n\n"); 1750 failures += str_from_uint16; 1751 } 1752 else if (verbose > 1) 1753 printf ("PASSED: testcase check_str_from_uint16() successfully " 1754 "passed.\n\n"); 1755 1756 str_from_uint64 = check_str_from_uint64 (); 1757 if (str_from_uint64 != 0) 1758 { 1759 fprintf (stderr, 1760 "FAILED: testcase check_str_from_uint16() failed.\n\n"); 1761 failures += str_from_uint64; 1762 } 1763 else if (verbose > 1) 1764 printf ("PASSED: testcase check_str_from_uint16() successfully " 1765 "passed.\n\n"); 1766 strx_from_uint32 = check_strx_from_uint32 (); 1767 if (strx_from_uint32 != 0) 1768 { 1769 fprintf (stderr, 1770 "FAILED: testcase check_strx_from_uint32() failed.\n\n"); 1771 failures += strx_from_uint32; 1772 } 1773 else if (verbose > 1) 1774 printf ("PASSED: testcase check_strx_from_uint32() successfully " 1775 "passed.\n\n"); 1776 1777 str_from_uint8_pad = check_str_from_uint8_pad (); 1778 if (str_from_uint8_pad != 0) 1779 { 1780 fprintf (stderr, 1781 "FAILED: testcase check_str_from_uint8_pad() failed.\n\n"); 1782 failures += str_from_uint8_pad; 1783 } 1784 else if (verbose > 1) 1785 printf ("PASSED: testcase check_str_from_uint8_pad() successfully " 1786 "passed.\n\n"); 1787 1788 if (failures) 1789 { 1790 if (verbose > 0) 1791 printf ("At least one test failed.\n"); 1792 1793 return 1; 1794 } 1795 1796 if (verbose > 0) 1797 printf ("All tests passed successfully.\n"); 1798 1799 return 0; 1800 } 1801 1802 1803 int 1804 main (int argc, char *argv[]) 1805 { 1806 if (has_param (argc, argv, "-v") || 1807 has_param (argc, argv, "--verbose") || 1808 has_param (argc, argv, "--verbose1")) 1809 MHDT_set_verbosity (MHDT_VERB_LVL_BASIC); 1810 if (has_param (argc, argv, "-vv") || 1811 has_param (argc, argv, "--verbose2")) 1812 MHDT_set_verbosity (MHDT_VERB_LVL_VERBOSE); 1813 1814 return run_str_from_X_tests (); 1815 }