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