unit_str_from_value.c (60715B)
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, (unsigned int) t->num_of_digt, (unsigned 495 int) t->str. 496 len); 497 exit (99); 498 } 499 if ('0' == t->str.str[0]) 500 continue; /* Skip strings prefixed with zeros */ 501 if (t->num_of_digt != t->str.len) 502 continue; /* Skip strings with suffixes */ 503 if ((t->val & 0xFFFFu) != t->val) 504 continue; /* Too large value to convert */ 505 if (sizeof(buf) < t->str.len + 1) 506 { 507 fprintf (stderr, 508 "ERROR: dstrs_w_values[%u] has too long (%u) string, " 509 "size of 'buf' should be increased.\n", 510 (unsigned int) i, (unsigned int) t->str.len); 511 exit (99); 512 } 513 rs = 0; /* Only to mute compiler warning */ 514 for (b_size = 0; b_size <= t->str.len + 1; ++b_size) 515 { 516 /* fill buffer with pseudo-random values */ 517 memcpy (buf, erase, sizeof(buf)); 518 519 rs = mhd_uint16_to_str ((uint_least16_t) t->val, buf, b_size); 520 521 if (t->num_of_digt > b_size) 522 { 523 /* Must fail, buffer is too small for result */ 524 if (0 != rs) 525 { 526 if (0 == c_failed[i]) 527 t_failed++; 528 c_failed[i] = ! 0; 529 fprintf (stderr, 530 "FAILED: mhd_uint16_to_str(%" PRIuFAST64 ", -> buf," 531 " %d) returned %" PRIuPTR 532 ", while expecting 0." 533 " Locale: %s\n", t->val, (int) b_size, (uintptr_t) rs, 534 get_current_locale_str ()); 535 } 536 } 537 else 538 { 539 if (t->num_of_digt != rs) 540 { 541 if (0 == c_failed[i]) 542 t_failed++; 543 c_failed[i] = ! 0; 544 fprintf (stderr, 545 "FAILED: mhd_uint16_to_str(%" PRIuFAST64 ", -> buf," 546 " %d) returned %" PRIuPTR 547 ", while expecting %d." 548 " Locale: %s\n", t->val, (int) b_size, (uintptr_t) rs, 549 (int) t->num_of_digt, get_current_locale_str ()); 550 } 551 else if (0 != memcmp (buf, t->str.str, t->num_of_digt)) 552 { 553 if (0 == c_failed[i]) 554 t_failed++; 555 c_failed[i] = ! 0; 556 fprintf (stderr, 557 "FAILED: mhd_uint16_to_str(%" PRIuFAST64 ", -> \"%.*s\"," 558 " %d) returned %" PRIuPTR "." 559 " Locale: %s\n", t->val, (int) rs, buf, (int) b_size, 560 (uintptr_t) rs, get_current_locale_str ()); 561 } 562 else if (0 != memcmp (buf + rs, erase + rs, sizeof(buf) - rs)) 563 { 564 if (0 == c_failed[i]) 565 t_failed++; 566 c_failed[i] = ! 0; 567 fprintf (stderr, 568 "FAILED: mhd_uint16_to_str(%" PRIuFAST64 ", -> \"%.*s\"," 569 " %d) returned %" PRIuPTR 570 " and touched data after the resulting string." 571 " Locale: %s\n", t->val, (int) rs, buf, (int) b_size, 572 (uintptr_t) rs, get_current_locale_str ()); 573 } 574 } 575 } 576 if ((verbose > 1) && (j == locale_name_count - 1) && ! c_failed[i]) 577 printf ("PASSED: mhd_uint16_to_str(%" PRIuFAST64 ", -> \"%.*s\", %d) " 578 "== %" PRIuPTR "\n", 579 t->val, (int) rs, buf, (int) b_size - 1, (uintptr_t) rs); 580 } 581 } 582 return t_failed; 583 } 584 585 586 static size_t 587 check_str_from_uint64 (void) 588 { 589 size_t t_failed = 0; 590 size_t i, j; 591 char buf[70]; 592 const char *erase = 593 "-@=sd#+&(pdirenDSFGSe#@C&S!DAS*!AOIPUQWESAdFzxcvSs*()&#$%KH`" 594 "32452d098poiden45SADFFDA3S4D3SDFdfgsdfgsSADFzxdvs$*()द`" 595 "adsf##$$@&*^%*^&56qwe#3C@S!DAScFAOIP$#%#$Ad1zs3v1$*()ӌ`"; 596 int c_failed[sizeof(dstrs_w_values) 597 / sizeof(dstrs_w_values[0])]; 598 static const size_t n_checks = sizeof(c_failed) / sizeof(c_failed[0]); 599 600 memset (c_failed, 0, sizeof(c_failed)); 601 602 for (j = 0; j < locale_name_count; j++) 603 { 604 set_test_locale (j); /* setlocale() can be slow! */ 605 for (i = 0; i < n_checks; i++) 606 { 607 const struct str_with_value *const t = dstrs_w_values + i; 608 size_t b_size; 609 size_t rs; 610 611 if (c_failed[i]) 612 continue; /* skip already failed checks */ 613 614 if (t->str.len < t->num_of_digt) 615 { 616 fprintf (stderr, 617 "ERROR: dstrs_w_values[%u] has wrong num_of_digt (%u): num_of_digt is expected" 618 " to be less or equal to str.len (%u).\n", 619 (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned 620 int) t->str. 621 len); 622 exit (99); 623 } 624 if ('0' == t->str.str[0]) 625 continue; /* Skip strings prefixed with zeros */ 626 if (t->num_of_digt != t->str.len) 627 continue; /* Skip strings with suffixes */ 628 if (sizeof(buf) < t->str.len + 1) 629 { 630 fprintf (stderr, 631 "ERROR: dstrs_w_values[%u] has too long (%u) string, " 632 "size of 'buf' should be increased.\n", 633 (unsigned int) i, (unsigned int) t->str.len); 634 exit (99); 635 } 636 rs = 0; /* Only to mute compiler warning */ 637 for (b_size = 0; b_size <= t->str.len + 1; ++b_size) 638 { 639 /* fill buffer with pseudo-random values */ 640 memcpy (buf, erase, sizeof(buf)); 641 642 rs = mhd_uint64_to_str (t->val, buf, b_size); 643 644 if (t->num_of_digt > b_size) 645 { 646 /* Must fail, buffer is too small for result */ 647 if (0 != rs) 648 { 649 if (0 == c_failed[i]) 650 t_failed++; 651 c_failed[i] = ! 0; 652 fprintf (stderr, 653 "FAILED: mhd_uint64_to_str(%" PRIuFAST64 ", -> buf," 654 " %d) returned %" PRIuPTR 655 ", while expecting 0." 656 " Locale: %s\n", t->val, (int) b_size, (uintptr_t) rs, 657 get_current_locale_str ()); 658 } 659 } 660 else 661 { 662 if (t->num_of_digt != rs) 663 { 664 if (0 == c_failed[i]) 665 t_failed++; 666 c_failed[i] = ! 0; 667 fprintf (stderr, 668 "FAILED: mhd_uint64_to_str(%" PRIuFAST64 ", -> buf," 669 " %d) returned %" PRIuPTR 670 ", while expecting %d." 671 " Locale: %s\n", t->val, (int) b_size, (uintptr_t) rs, 672 (int) t->num_of_digt, get_current_locale_str ()); 673 } 674 else if (0 != memcmp (buf, t->str.str, t->num_of_digt)) 675 { 676 if (0 == c_failed[i]) 677 t_failed++; 678 c_failed[i] = ! 0; 679 fprintf (stderr, 680 "FAILED: mhd_uint64_to_str(%" PRIuFAST64 ", -> \"%.*s\"," 681 " %d) returned %" PRIuPTR "." 682 " Locale: %s\n", t->val, (int) rs, buf, (int) b_size, 683 (uintptr_t) rs, get_current_locale_str ()); 684 } 685 else if (0 != memcmp (buf + rs, erase + rs, sizeof(buf) - rs)) 686 { 687 if (0 == c_failed[i]) 688 t_failed++; 689 c_failed[i] = ! 0; 690 fprintf (stderr, 691 "FAILED: mhd_uint64_to_str(%" PRIuFAST64 ", -> \"%.*s\"," 692 " %d) returned %" PRIuPTR 693 " and touched data after the resulting string." 694 " Locale: %s\n", t->val, (int) rs, buf, (int) b_size, 695 (uintptr_t) rs, get_current_locale_str ()); 696 } 697 } 698 } 699 if ((verbose > 1) && (j == locale_name_count - 1) && ! c_failed[i]) 700 printf ("PASSED: mhd_uint64_to_str(%" PRIuFAST64 ", -> \"%.*s\", %d) " 701 "== %" PRIuPTR "\n", 702 t->val, (int) rs, buf, (int) b_size - 1, (uintptr_t) rs); 703 } 704 } 705 return t_failed; 706 } 707 708 709 static size_t 710 check_strx_from_uint32 (void) 711 { 712 size_t t_failed = 0; 713 size_t i, j; 714 char buf[70]; 715 const char *erase = 716 "jrlkjssfhjfvrjntJHLJ$@%$#adsfdkj;k$##$%#$%FGDF%$#^FDFG%$#$D`" 717 ";skjdhjflsdkjhdjfalskdjhdfalkjdhf$%##%$$#%FSDGFSDDGDFSSDSDF`" 718 "#5#$%#$#$DFSFDDFSGSDFSDF354FDDSGFDFfdssfddfswqemn,.zxih,.sx`"; 719 int c_failed[sizeof(xdstrs_w_values) 720 / sizeof(xdstrs_w_values[0])]; 721 static const size_t n_checks = sizeof(c_failed) / sizeof(c_failed[0]); 722 723 memset (c_failed, 0, sizeof(c_failed)); 724 725 for (j = 0; j < locale_name_count; j++) 726 { 727 set_test_locale (j); /* setlocale() can be slow! */ 728 for (i = 0; i < n_checks; i++) 729 { 730 const struct str_with_value *const t = xdstrs_w_values + i; 731 size_t b_size; 732 size_t rs; 733 734 if (c_failed[i]) 735 continue; /* skip already failed checks */ 736 737 if (t->str.len < t->num_of_digt) 738 { 739 fprintf (stderr, 740 "ERROR: dstrs_w_values[%u] has wrong num_of_digt (%u): num_of_digt is expected" 741 " to be less or equal to str.len (%u).\n", 742 (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned 743 int) t->str. 744 len); 745 exit (99); 746 } 747 if ('0' == t->str.str[0]) 748 continue; /* Skip strings prefixed with zeros */ 749 if (t->num_of_digt != t->str.len) 750 continue; /* Skip strings with suffixes */ 751 if ((t->val & 0xFFFFFFFFu) != t->val) 752 continue; /* Too large value to convert */ 753 if (sizeof(buf) < t->str.len + 1) 754 { 755 fprintf (stderr, 756 "ERROR: dstrs_w_values[%u] has too long (%u) string, " 757 "size of 'buf' should be increased.\n", 758 (unsigned int) i, (unsigned int) t->str.len); 759 exit (99); 760 } 761 rs = 0; /* Only to mute compiler warning */ 762 for (b_size = 0; b_size <= t->str.len + 1; ++b_size) 763 { 764 /* fill buffer with pseudo-random values */ 765 memcpy (buf, erase, sizeof(buf)); 766 767 rs = mhd_uint32_to_strx ((uint_fast32_t) t->val, buf, b_size); 768 769 if (t->num_of_digt > b_size) 770 { 771 /* Must fail, buffer is too small for result */ 772 if (0 != rs) 773 { 774 if (0 == c_failed[i]) 775 t_failed++; 776 c_failed[i] = ! 0; 777 fprintf (stderr, 778 "FAILED: mhd_uint32_to_strx(0x%" PRIXFAST64 ", -> buf," 779 " %d) returned %" PRIuPTR 780 ", while expecting 0." 781 " Locale: %s\n", t->val, (int) b_size, (uintptr_t) rs, 782 get_current_locale_str ()); 783 } 784 } 785 else 786 { 787 if (t->num_of_digt != rs) 788 { 789 if (0 == c_failed[i]) 790 t_failed++; 791 c_failed[i] = ! 0; 792 fprintf (stderr, 793 "FAILED: mhd_uint32_to_strx(0x%" PRIXFAST64 ", -> buf," 794 " %d) returned %" PRIuPTR 795 ", while expecting %d." 796 " Locale: %s\n", t->val, (int) b_size, (uintptr_t) rs, 797 (int) t->num_of_digt, get_current_locale_str ()); 798 } 799 else if (0 == mhd_str_equal_caseless_bin_n (buf, t->str.str, 800 t->num_of_digt)) 801 { 802 if (0 == c_failed[i]) 803 t_failed++; 804 c_failed[i] = ! 0; 805 fprintf (stderr, 806 "FAILED: mhd_uint32_to_strx(0x%" PRIXFAST64 807 ", -> \"%.*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%" PRIXFAST64 827 ", -> \"%.*s\"," 828 " %d) returned %" PRIuPTR 829 " and touched data after the resulting string." 830 " Locale: %s\n", t->val, (int) rs, buf, (int) b_size, 831 (uintptr_t) rs, get_current_locale_str ()); 832 } 833 } 834 } 835 if ((verbose > 1) && (j == locale_name_count - 1) && ! c_failed[i]) 836 printf ("PASSED: mhd_uint32_to_strx(0x%" PRIXFAST64 837 ", -> \"%.*s\", %d) " 838 "== %" PRIuPTR "\n", 839 t->val, (int) rs, buf, (int) b_size - 1, (uintptr_t) rs); 840 } 841 } 842 return t_failed; 843 } 844 845 846 static const struct str_with_value duint8_w_values_p1[] = { 847 {D_STR_W_LEN ("0"), 1, 0}, 848 {D_STR_W_LEN ("1"), 1, 1}, 849 {D_STR_W_LEN ("2"), 1, 2}, 850 {D_STR_W_LEN ("3"), 1, 3}, 851 {D_STR_W_LEN ("4"), 1, 4}, 852 {D_STR_W_LEN ("5"), 1, 5}, 853 {D_STR_W_LEN ("6"), 1, 6}, 854 {D_STR_W_LEN ("7"), 1, 7}, 855 {D_STR_W_LEN ("8"), 1, 8}, 856 {D_STR_W_LEN ("9"), 1, 9}, 857 {D_STR_W_LEN ("10"), 2, 10}, 858 {D_STR_W_LEN ("11"), 2, 11}, 859 {D_STR_W_LEN ("12"), 2, 12}, 860 {D_STR_W_LEN ("13"), 2, 13}, 861 {D_STR_W_LEN ("14"), 2, 14}, 862 {D_STR_W_LEN ("15"), 2, 15}, 863 {D_STR_W_LEN ("16"), 2, 16}, 864 {D_STR_W_LEN ("17"), 2, 17}, 865 {D_STR_W_LEN ("18"), 2, 18}, 866 {D_STR_W_LEN ("19"), 2, 19}, 867 {D_STR_W_LEN ("20"), 2, 20}, 868 {D_STR_W_LEN ("21"), 2, 21}, 869 {D_STR_W_LEN ("22"), 2, 22}, 870 {D_STR_W_LEN ("23"), 2, 23}, 871 {D_STR_W_LEN ("24"), 2, 24}, 872 {D_STR_W_LEN ("25"), 2, 25}, 873 {D_STR_W_LEN ("26"), 2, 26}, 874 {D_STR_W_LEN ("27"), 2, 27}, 875 {D_STR_W_LEN ("28"), 2, 28}, 876 {D_STR_W_LEN ("29"), 2, 29}, 877 {D_STR_W_LEN ("30"), 2, 30}, 878 {D_STR_W_LEN ("31"), 2, 31}, 879 {D_STR_W_LEN ("32"), 2, 32}, 880 {D_STR_W_LEN ("33"), 2, 33}, 881 {D_STR_W_LEN ("34"), 2, 34}, 882 {D_STR_W_LEN ("35"), 2, 35}, 883 {D_STR_W_LEN ("36"), 2, 36}, 884 {D_STR_W_LEN ("37"), 2, 37}, 885 {D_STR_W_LEN ("38"), 2, 38}, 886 {D_STR_W_LEN ("39"), 2, 39}, 887 {D_STR_W_LEN ("40"), 2, 40}, 888 {D_STR_W_LEN ("41"), 2, 41}, 889 {D_STR_W_LEN ("42"), 2, 42}, 890 {D_STR_W_LEN ("43"), 2, 43}, 891 {D_STR_W_LEN ("44"), 2, 44}, 892 {D_STR_W_LEN ("45"), 2, 45}, 893 {D_STR_W_LEN ("46"), 2, 46}, 894 {D_STR_W_LEN ("47"), 2, 47}, 895 {D_STR_W_LEN ("48"), 2, 48}, 896 {D_STR_W_LEN ("49"), 2, 49}, 897 {D_STR_W_LEN ("50"), 2, 50}, 898 {D_STR_W_LEN ("51"), 2, 51}, 899 {D_STR_W_LEN ("52"), 2, 52}, 900 {D_STR_W_LEN ("53"), 2, 53}, 901 {D_STR_W_LEN ("54"), 2, 54}, 902 {D_STR_W_LEN ("55"), 2, 55}, 903 {D_STR_W_LEN ("56"), 2, 56}, 904 {D_STR_W_LEN ("57"), 2, 57}, 905 {D_STR_W_LEN ("58"), 2, 58}, 906 {D_STR_W_LEN ("59"), 2, 59}, 907 {D_STR_W_LEN ("60"), 2, 60}, 908 {D_STR_W_LEN ("61"), 2, 61}, 909 {D_STR_W_LEN ("62"), 2, 62}, 910 {D_STR_W_LEN ("63"), 2, 63}, 911 {D_STR_W_LEN ("64"), 2, 64}, 912 {D_STR_W_LEN ("65"), 2, 65}, 913 {D_STR_W_LEN ("66"), 2, 66}, 914 {D_STR_W_LEN ("67"), 2, 67}, 915 {D_STR_W_LEN ("68"), 2, 68}, 916 {D_STR_W_LEN ("69"), 2, 69}, 917 {D_STR_W_LEN ("70"), 2, 70}, 918 {D_STR_W_LEN ("71"), 2, 71}, 919 {D_STR_W_LEN ("72"), 2, 72}, 920 {D_STR_W_LEN ("73"), 2, 73}, 921 {D_STR_W_LEN ("74"), 2, 74}, 922 {D_STR_W_LEN ("75"), 2, 75}, 923 {D_STR_W_LEN ("76"), 2, 76}, 924 {D_STR_W_LEN ("77"), 2, 77}, 925 {D_STR_W_LEN ("78"), 2, 78}, 926 {D_STR_W_LEN ("79"), 2, 79}, 927 {D_STR_W_LEN ("80"), 2, 80}, 928 {D_STR_W_LEN ("81"), 2, 81}, 929 {D_STR_W_LEN ("82"), 2, 82}, 930 {D_STR_W_LEN ("83"), 2, 83}, 931 {D_STR_W_LEN ("84"), 2, 84}, 932 {D_STR_W_LEN ("85"), 2, 85}, 933 {D_STR_W_LEN ("86"), 2, 86}, 934 {D_STR_W_LEN ("87"), 2, 87}, 935 {D_STR_W_LEN ("88"), 2, 88}, 936 {D_STR_W_LEN ("89"), 2, 89}, 937 {D_STR_W_LEN ("90"), 2, 90}, 938 {D_STR_W_LEN ("91"), 2, 91}, 939 {D_STR_W_LEN ("92"), 2, 92}, 940 {D_STR_W_LEN ("93"), 2, 93}, 941 {D_STR_W_LEN ("94"), 2, 94}, 942 {D_STR_W_LEN ("95"), 2, 95}, 943 {D_STR_W_LEN ("96"), 2, 96}, 944 {D_STR_W_LEN ("97"), 2, 97}, 945 {D_STR_W_LEN ("98"), 2, 98}, 946 {D_STR_W_LEN ("99"), 2, 99}, 947 {D_STR_W_LEN ("100"), 3, 100}, 948 {D_STR_W_LEN ("101"), 3, 101}, 949 {D_STR_W_LEN ("102"), 3, 102}, 950 {D_STR_W_LEN ("103"), 3, 103}, 951 {D_STR_W_LEN ("104"), 3, 104}, 952 {D_STR_W_LEN ("105"), 3, 105}, 953 {D_STR_W_LEN ("106"), 3, 106}, 954 {D_STR_W_LEN ("107"), 3, 107}, 955 {D_STR_W_LEN ("108"), 3, 108}, 956 {D_STR_W_LEN ("109"), 3, 109}, 957 {D_STR_W_LEN ("110"), 3, 110}, 958 {D_STR_W_LEN ("111"), 3, 111}, 959 {D_STR_W_LEN ("112"), 3, 112}, 960 {D_STR_W_LEN ("113"), 3, 113}, 961 {D_STR_W_LEN ("114"), 3, 114}, 962 {D_STR_W_LEN ("115"), 3, 115}, 963 {D_STR_W_LEN ("116"), 3, 116}, 964 {D_STR_W_LEN ("117"), 3, 117}, 965 {D_STR_W_LEN ("118"), 3, 118}, 966 {D_STR_W_LEN ("119"), 3, 119}, 967 {D_STR_W_LEN ("120"), 3, 120}, 968 {D_STR_W_LEN ("121"), 3, 121}, 969 {D_STR_W_LEN ("122"), 3, 122}, 970 {D_STR_W_LEN ("123"), 3, 123}, 971 {D_STR_W_LEN ("124"), 3, 124}, 972 {D_STR_W_LEN ("125"), 3, 125}, 973 {D_STR_W_LEN ("126"), 3, 126}, 974 {D_STR_W_LEN ("127"), 3, 127}, 975 {D_STR_W_LEN ("128"), 3, 128}, 976 {D_STR_W_LEN ("129"), 3, 129}, 977 {D_STR_W_LEN ("130"), 3, 130}, 978 {D_STR_W_LEN ("131"), 3, 131}, 979 {D_STR_W_LEN ("132"), 3, 132}, 980 {D_STR_W_LEN ("133"), 3, 133}, 981 {D_STR_W_LEN ("134"), 3, 134}, 982 {D_STR_W_LEN ("135"), 3, 135}, 983 {D_STR_W_LEN ("136"), 3, 136}, 984 {D_STR_W_LEN ("137"), 3, 137}, 985 {D_STR_W_LEN ("138"), 3, 138}, 986 {D_STR_W_LEN ("139"), 3, 139}, 987 {D_STR_W_LEN ("140"), 3, 140}, 988 {D_STR_W_LEN ("141"), 3, 141}, 989 {D_STR_W_LEN ("142"), 3, 142}, 990 {D_STR_W_LEN ("143"), 3, 143}, 991 {D_STR_W_LEN ("144"), 3, 144}, 992 {D_STR_W_LEN ("145"), 3, 145}, 993 {D_STR_W_LEN ("146"), 3, 146}, 994 {D_STR_W_LEN ("147"), 3, 147}, 995 {D_STR_W_LEN ("148"), 3, 148}, 996 {D_STR_W_LEN ("149"), 3, 149}, 997 {D_STR_W_LEN ("150"), 3, 150}, 998 {D_STR_W_LEN ("151"), 3, 151}, 999 {D_STR_W_LEN ("152"), 3, 152}, 1000 {D_STR_W_LEN ("153"), 3, 153}, 1001 {D_STR_W_LEN ("154"), 3, 154}, 1002 {D_STR_W_LEN ("155"), 3, 155}, 1003 {D_STR_W_LEN ("156"), 3, 156}, 1004 {D_STR_W_LEN ("157"), 3, 157}, 1005 {D_STR_W_LEN ("158"), 3, 158}, 1006 {D_STR_W_LEN ("159"), 3, 159}, 1007 {D_STR_W_LEN ("160"), 3, 160}, 1008 {D_STR_W_LEN ("161"), 3, 161}, 1009 {D_STR_W_LEN ("162"), 3, 162}, 1010 {D_STR_W_LEN ("163"), 3, 163}, 1011 {D_STR_W_LEN ("164"), 3, 164}, 1012 {D_STR_W_LEN ("165"), 3, 165}, 1013 {D_STR_W_LEN ("166"), 3, 166}, 1014 {D_STR_W_LEN ("167"), 3, 167}, 1015 {D_STR_W_LEN ("168"), 3, 168}, 1016 {D_STR_W_LEN ("169"), 3, 169}, 1017 {D_STR_W_LEN ("170"), 3, 170}, 1018 {D_STR_W_LEN ("171"), 3, 171}, 1019 {D_STR_W_LEN ("172"), 3, 172}, 1020 {D_STR_W_LEN ("173"), 3, 173}, 1021 {D_STR_W_LEN ("174"), 3, 174}, 1022 {D_STR_W_LEN ("175"), 3, 175}, 1023 {D_STR_W_LEN ("176"), 3, 176}, 1024 {D_STR_W_LEN ("177"), 3, 177}, 1025 {D_STR_W_LEN ("178"), 3, 178}, 1026 {D_STR_W_LEN ("179"), 3, 179}, 1027 {D_STR_W_LEN ("180"), 3, 180}, 1028 {D_STR_W_LEN ("181"), 3, 181}, 1029 {D_STR_W_LEN ("182"), 3, 182}, 1030 {D_STR_W_LEN ("183"), 3, 183}, 1031 {D_STR_W_LEN ("184"), 3, 184}, 1032 {D_STR_W_LEN ("185"), 3, 185}, 1033 {D_STR_W_LEN ("186"), 3, 186}, 1034 {D_STR_W_LEN ("187"), 3, 187}, 1035 {D_STR_W_LEN ("188"), 3, 188}, 1036 {D_STR_W_LEN ("189"), 3, 189}, 1037 {D_STR_W_LEN ("190"), 3, 190}, 1038 {D_STR_W_LEN ("191"), 3, 191}, 1039 {D_STR_W_LEN ("192"), 3, 192}, 1040 {D_STR_W_LEN ("193"), 3, 193}, 1041 {D_STR_W_LEN ("194"), 3, 194}, 1042 {D_STR_W_LEN ("195"), 3, 195}, 1043 {D_STR_W_LEN ("196"), 3, 196}, 1044 {D_STR_W_LEN ("197"), 3, 197}, 1045 {D_STR_W_LEN ("198"), 3, 198}, 1046 {D_STR_W_LEN ("199"), 3, 199}, 1047 {D_STR_W_LEN ("200"), 3, 200}, 1048 {D_STR_W_LEN ("201"), 3, 201}, 1049 {D_STR_W_LEN ("202"), 3, 202}, 1050 {D_STR_W_LEN ("203"), 3, 203}, 1051 {D_STR_W_LEN ("204"), 3, 204}, 1052 {D_STR_W_LEN ("205"), 3, 205}, 1053 {D_STR_W_LEN ("206"), 3, 206}, 1054 {D_STR_W_LEN ("207"), 3, 207}, 1055 {D_STR_W_LEN ("208"), 3, 208}, 1056 {D_STR_W_LEN ("209"), 3, 209}, 1057 {D_STR_W_LEN ("210"), 3, 210}, 1058 {D_STR_W_LEN ("211"), 3, 211}, 1059 {D_STR_W_LEN ("212"), 3, 212}, 1060 {D_STR_W_LEN ("213"), 3, 213}, 1061 {D_STR_W_LEN ("214"), 3, 214}, 1062 {D_STR_W_LEN ("215"), 3, 215}, 1063 {D_STR_W_LEN ("216"), 3, 216}, 1064 {D_STR_W_LEN ("217"), 3, 217}, 1065 {D_STR_W_LEN ("218"), 3, 218}, 1066 {D_STR_W_LEN ("219"), 3, 219}, 1067 {D_STR_W_LEN ("220"), 3, 220}, 1068 {D_STR_W_LEN ("221"), 3, 221}, 1069 {D_STR_W_LEN ("222"), 3, 222}, 1070 {D_STR_W_LEN ("223"), 3, 223}, 1071 {D_STR_W_LEN ("224"), 3, 224}, 1072 {D_STR_W_LEN ("225"), 3, 225}, 1073 {D_STR_W_LEN ("226"), 3, 226}, 1074 {D_STR_W_LEN ("227"), 3, 227}, 1075 {D_STR_W_LEN ("228"), 3, 228}, 1076 {D_STR_W_LEN ("229"), 3, 229}, 1077 {D_STR_W_LEN ("230"), 3, 230}, 1078 {D_STR_W_LEN ("231"), 3, 231}, 1079 {D_STR_W_LEN ("232"), 3, 232}, 1080 {D_STR_W_LEN ("233"), 3, 233}, 1081 {D_STR_W_LEN ("234"), 3, 234}, 1082 {D_STR_W_LEN ("235"), 3, 235}, 1083 {D_STR_W_LEN ("236"), 3, 236}, 1084 {D_STR_W_LEN ("237"), 3, 237}, 1085 {D_STR_W_LEN ("238"), 3, 238}, 1086 {D_STR_W_LEN ("239"), 3, 239}, 1087 {D_STR_W_LEN ("240"), 3, 240}, 1088 {D_STR_W_LEN ("241"), 3, 241}, 1089 {D_STR_W_LEN ("242"), 3, 242}, 1090 {D_STR_W_LEN ("243"), 3, 243}, 1091 {D_STR_W_LEN ("244"), 3, 244}, 1092 {D_STR_W_LEN ("245"), 3, 245}, 1093 {D_STR_W_LEN ("246"), 3, 246}, 1094 {D_STR_W_LEN ("247"), 3, 247}, 1095 {D_STR_W_LEN ("248"), 3, 248}, 1096 {D_STR_W_LEN ("249"), 3, 249}, 1097 {D_STR_W_LEN ("250"), 3, 250}, 1098 {D_STR_W_LEN ("251"), 3, 251}, 1099 {D_STR_W_LEN ("252"), 3, 252}, 1100 {D_STR_W_LEN ("253"), 3, 253}, 1101 {D_STR_W_LEN ("254"), 3, 254}, 1102 {D_STR_W_LEN ("255"), 3, 255}, 1103 }; 1104 1105 static const struct str_with_value duint8_w_values_p2[] = { 1106 {D_STR_W_LEN ("00"), 2, 0}, 1107 {D_STR_W_LEN ("01"), 2, 1}, 1108 {D_STR_W_LEN ("02"), 2, 2}, 1109 {D_STR_W_LEN ("03"), 2, 3}, 1110 {D_STR_W_LEN ("04"), 2, 4}, 1111 {D_STR_W_LEN ("05"), 2, 5}, 1112 {D_STR_W_LEN ("06"), 2, 6}, 1113 {D_STR_W_LEN ("07"), 2, 7}, 1114 {D_STR_W_LEN ("08"), 2, 8}, 1115 {D_STR_W_LEN ("09"), 2, 9}, 1116 {D_STR_W_LEN ("10"), 2, 10}, 1117 {D_STR_W_LEN ("11"), 2, 11}, 1118 {D_STR_W_LEN ("12"), 2, 12}, 1119 {D_STR_W_LEN ("13"), 2, 13}, 1120 {D_STR_W_LEN ("14"), 2, 14}, 1121 {D_STR_W_LEN ("15"), 2, 15}, 1122 {D_STR_W_LEN ("16"), 2, 16}, 1123 {D_STR_W_LEN ("17"), 2, 17}, 1124 {D_STR_W_LEN ("18"), 2, 18}, 1125 {D_STR_W_LEN ("19"), 2, 19}, 1126 {D_STR_W_LEN ("20"), 2, 20}, 1127 {D_STR_W_LEN ("21"), 2, 21}, 1128 {D_STR_W_LEN ("22"), 2, 22}, 1129 {D_STR_W_LEN ("23"), 2, 23}, 1130 {D_STR_W_LEN ("24"), 2, 24}, 1131 {D_STR_W_LEN ("25"), 2, 25}, 1132 {D_STR_W_LEN ("26"), 2, 26}, 1133 {D_STR_W_LEN ("27"), 2, 27}, 1134 {D_STR_W_LEN ("28"), 2, 28}, 1135 {D_STR_W_LEN ("29"), 2, 29}, 1136 {D_STR_W_LEN ("30"), 2, 30}, 1137 {D_STR_W_LEN ("31"), 2, 31}, 1138 {D_STR_W_LEN ("32"), 2, 32}, 1139 {D_STR_W_LEN ("33"), 2, 33}, 1140 {D_STR_W_LEN ("34"), 2, 34}, 1141 {D_STR_W_LEN ("35"), 2, 35}, 1142 {D_STR_W_LEN ("36"), 2, 36}, 1143 {D_STR_W_LEN ("37"), 2, 37}, 1144 {D_STR_W_LEN ("38"), 2, 38}, 1145 {D_STR_W_LEN ("39"), 2, 39}, 1146 {D_STR_W_LEN ("40"), 2, 40}, 1147 {D_STR_W_LEN ("41"), 2, 41}, 1148 {D_STR_W_LEN ("42"), 2, 42}, 1149 {D_STR_W_LEN ("43"), 2, 43}, 1150 {D_STR_W_LEN ("44"), 2, 44}, 1151 {D_STR_W_LEN ("45"), 2, 45}, 1152 {D_STR_W_LEN ("46"), 2, 46}, 1153 {D_STR_W_LEN ("47"), 2, 47}, 1154 {D_STR_W_LEN ("48"), 2, 48}, 1155 {D_STR_W_LEN ("49"), 2, 49}, 1156 {D_STR_W_LEN ("50"), 2, 50}, 1157 {D_STR_W_LEN ("51"), 2, 51}, 1158 {D_STR_W_LEN ("52"), 2, 52}, 1159 {D_STR_W_LEN ("53"), 2, 53}, 1160 {D_STR_W_LEN ("54"), 2, 54}, 1161 {D_STR_W_LEN ("55"), 2, 55}, 1162 {D_STR_W_LEN ("56"), 2, 56}, 1163 {D_STR_W_LEN ("57"), 2, 57}, 1164 {D_STR_W_LEN ("58"), 2, 58}, 1165 {D_STR_W_LEN ("59"), 2, 59}, 1166 {D_STR_W_LEN ("60"), 2, 60}, 1167 {D_STR_W_LEN ("61"), 2, 61}, 1168 {D_STR_W_LEN ("62"), 2, 62}, 1169 {D_STR_W_LEN ("63"), 2, 63}, 1170 {D_STR_W_LEN ("64"), 2, 64}, 1171 {D_STR_W_LEN ("65"), 2, 65}, 1172 {D_STR_W_LEN ("66"), 2, 66}, 1173 {D_STR_W_LEN ("67"), 2, 67}, 1174 {D_STR_W_LEN ("68"), 2, 68}, 1175 {D_STR_W_LEN ("69"), 2, 69}, 1176 {D_STR_W_LEN ("70"), 2, 70}, 1177 {D_STR_W_LEN ("71"), 2, 71}, 1178 {D_STR_W_LEN ("72"), 2, 72}, 1179 {D_STR_W_LEN ("73"), 2, 73}, 1180 {D_STR_W_LEN ("74"), 2, 74}, 1181 {D_STR_W_LEN ("75"), 2, 75}, 1182 {D_STR_W_LEN ("76"), 2, 76}, 1183 {D_STR_W_LEN ("77"), 2, 77}, 1184 {D_STR_W_LEN ("78"), 2, 78}, 1185 {D_STR_W_LEN ("79"), 2, 79}, 1186 {D_STR_W_LEN ("80"), 2, 80}, 1187 {D_STR_W_LEN ("81"), 2, 81}, 1188 {D_STR_W_LEN ("82"), 2, 82}, 1189 {D_STR_W_LEN ("83"), 2, 83}, 1190 {D_STR_W_LEN ("84"), 2, 84}, 1191 {D_STR_W_LEN ("85"), 2, 85}, 1192 {D_STR_W_LEN ("86"), 2, 86}, 1193 {D_STR_W_LEN ("87"), 2, 87}, 1194 {D_STR_W_LEN ("88"), 2, 88}, 1195 {D_STR_W_LEN ("89"), 2, 89}, 1196 {D_STR_W_LEN ("90"), 2, 90}, 1197 {D_STR_W_LEN ("91"), 2, 91}, 1198 {D_STR_W_LEN ("92"), 2, 92}, 1199 {D_STR_W_LEN ("93"), 2, 93}, 1200 {D_STR_W_LEN ("94"), 2, 94}, 1201 {D_STR_W_LEN ("95"), 2, 95}, 1202 {D_STR_W_LEN ("96"), 2, 96}, 1203 {D_STR_W_LEN ("97"), 2, 97}, 1204 {D_STR_W_LEN ("98"), 2, 98}, 1205 {D_STR_W_LEN ("99"), 2, 99}, 1206 {D_STR_W_LEN ("100"), 3, 100}, 1207 {D_STR_W_LEN ("101"), 3, 101}, 1208 {D_STR_W_LEN ("102"), 3, 102}, 1209 {D_STR_W_LEN ("103"), 3, 103}, 1210 {D_STR_W_LEN ("104"), 3, 104}, 1211 {D_STR_W_LEN ("105"), 3, 105}, 1212 {D_STR_W_LEN ("106"), 3, 106}, 1213 {D_STR_W_LEN ("107"), 3, 107}, 1214 {D_STR_W_LEN ("108"), 3, 108}, 1215 {D_STR_W_LEN ("109"), 3, 109}, 1216 {D_STR_W_LEN ("110"), 3, 110}, 1217 {D_STR_W_LEN ("111"), 3, 111}, 1218 {D_STR_W_LEN ("112"), 3, 112}, 1219 {D_STR_W_LEN ("113"), 3, 113}, 1220 {D_STR_W_LEN ("114"), 3, 114}, 1221 {D_STR_W_LEN ("115"), 3, 115}, 1222 {D_STR_W_LEN ("116"), 3, 116}, 1223 {D_STR_W_LEN ("117"), 3, 117}, 1224 {D_STR_W_LEN ("118"), 3, 118}, 1225 {D_STR_W_LEN ("119"), 3, 119}, 1226 {D_STR_W_LEN ("120"), 3, 120}, 1227 {D_STR_W_LEN ("121"), 3, 121}, 1228 {D_STR_W_LEN ("122"), 3, 122}, 1229 {D_STR_W_LEN ("123"), 3, 123}, 1230 {D_STR_W_LEN ("124"), 3, 124}, 1231 {D_STR_W_LEN ("125"), 3, 125}, 1232 {D_STR_W_LEN ("126"), 3, 126}, 1233 {D_STR_W_LEN ("127"), 3, 127}, 1234 {D_STR_W_LEN ("128"), 3, 128}, 1235 {D_STR_W_LEN ("129"), 3, 129}, 1236 {D_STR_W_LEN ("130"), 3, 130}, 1237 {D_STR_W_LEN ("131"), 3, 131}, 1238 {D_STR_W_LEN ("132"), 3, 132}, 1239 {D_STR_W_LEN ("133"), 3, 133}, 1240 {D_STR_W_LEN ("134"), 3, 134}, 1241 {D_STR_W_LEN ("135"), 3, 135}, 1242 {D_STR_W_LEN ("136"), 3, 136}, 1243 {D_STR_W_LEN ("137"), 3, 137}, 1244 {D_STR_W_LEN ("138"), 3, 138}, 1245 {D_STR_W_LEN ("139"), 3, 139}, 1246 {D_STR_W_LEN ("140"), 3, 140}, 1247 {D_STR_W_LEN ("141"), 3, 141}, 1248 {D_STR_W_LEN ("142"), 3, 142}, 1249 {D_STR_W_LEN ("143"), 3, 143}, 1250 {D_STR_W_LEN ("144"), 3, 144}, 1251 {D_STR_W_LEN ("145"), 3, 145}, 1252 {D_STR_W_LEN ("146"), 3, 146}, 1253 {D_STR_W_LEN ("147"), 3, 147}, 1254 {D_STR_W_LEN ("148"), 3, 148}, 1255 {D_STR_W_LEN ("149"), 3, 149}, 1256 {D_STR_W_LEN ("150"), 3, 150}, 1257 {D_STR_W_LEN ("151"), 3, 151}, 1258 {D_STR_W_LEN ("152"), 3, 152}, 1259 {D_STR_W_LEN ("153"), 3, 153}, 1260 {D_STR_W_LEN ("154"), 3, 154}, 1261 {D_STR_W_LEN ("155"), 3, 155}, 1262 {D_STR_W_LEN ("156"), 3, 156}, 1263 {D_STR_W_LEN ("157"), 3, 157}, 1264 {D_STR_W_LEN ("158"), 3, 158}, 1265 {D_STR_W_LEN ("159"), 3, 159}, 1266 {D_STR_W_LEN ("160"), 3, 160}, 1267 {D_STR_W_LEN ("161"), 3, 161}, 1268 {D_STR_W_LEN ("162"), 3, 162}, 1269 {D_STR_W_LEN ("163"), 3, 163}, 1270 {D_STR_W_LEN ("164"), 3, 164}, 1271 {D_STR_W_LEN ("165"), 3, 165}, 1272 {D_STR_W_LEN ("166"), 3, 166}, 1273 {D_STR_W_LEN ("167"), 3, 167}, 1274 {D_STR_W_LEN ("168"), 3, 168}, 1275 {D_STR_W_LEN ("169"), 3, 169}, 1276 {D_STR_W_LEN ("170"), 3, 170}, 1277 {D_STR_W_LEN ("171"), 3, 171}, 1278 {D_STR_W_LEN ("172"), 3, 172}, 1279 {D_STR_W_LEN ("173"), 3, 173}, 1280 {D_STR_W_LEN ("174"), 3, 174}, 1281 {D_STR_W_LEN ("175"), 3, 175}, 1282 {D_STR_W_LEN ("176"), 3, 176}, 1283 {D_STR_W_LEN ("177"), 3, 177}, 1284 {D_STR_W_LEN ("178"), 3, 178}, 1285 {D_STR_W_LEN ("179"), 3, 179}, 1286 {D_STR_W_LEN ("180"), 3, 180}, 1287 {D_STR_W_LEN ("181"), 3, 181}, 1288 {D_STR_W_LEN ("182"), 3, 182}, 1289 {D_STR_W_LEN ("183"), 3, 183}, 1290 {D_STR_W_LEN ("184"), 3, 184}, 1291 {D_STR_W_LEN ("185"), 3, 185}, 1292 {D_STR_W_LEN ("186"), 3, 186}, 1293 {D_STR_W_LEN ("187"), 3, 187}, 1294 {D_STR_W_LEN ("188"), 3, 188}, 1295 {D_STR_W_LEN ("189"), 3, 189}, 1296 {D_STR_W_LEN ("190"), 3, 190}, 1297 {D_STR_W_LEN ("191"), 3, 191}, 1298 {D_STR_W_LEN ("192"), 3, 192}, 1299 {D_STR_W_LEN ("193"), 3, 193}, 1300 {D_STR_W_LEN ("194"), 3, 194}, 1301 {D_STR_W_LEN ("195"), 3, 195}, 1302 {D_STR_W_LEN ("196"), 3, 196}, 1303 {D_STR_W_LEN ("197"), 3, 197}, 1304 {D_STR_W_LEN ("198"), 3, 198}, 1305 {D_STR_W_LEN ("199"), 3, 199}, 1306 {D_STR_W_LEN ("200"), 3, 200}, 1307 {D_STR_W_LEN ("201"), 3, 201}, 1308 {D_STR_W_LEN ("202"), 3, 202}, 1309 {D_STR_W_LEN ("203"), 3, 203}, 1310 {D_STR_W_LEN ("204"), 3, 204}, 1311 {D_STR_W_LEN ("205"), 3, 205}, 1312 {D_STR_W_LEN ("206"), 3, 206}, 1313 {D_STR_W_LEN ("207"), 3, 207}, 1314 {D_STR_W_LEN ("208"), 3, 208}, 1315 {D_STR_W_LEN ("209"), 3, 209}, 1316 {D_STR_W_LEN ("210"), 3, 210}, 1317 {D_STR_W_LEN ("211"), 3, 211}, 1318 {D_STR_W_LEN ("212"), 3, 212}, 1319 {D_STR_W_LEN ("213"), 3, 213}, 1320 {D_STR_W_LEN ("214"), 3, 214}, 1321 {D_STR_W_LEN ("215"), 3, 215}, 1322 {D_STR_W_LEN ("216"), 3, 216}, 1323 {D_STR_W_LEN ("217"), 3, 217}, 1324 {D_STR_W_LEN ("218"), 3, 218}, 1325 {D_STR_W_LEN ("219"), 3, 219}, 1326 {D_STR_W_LEN ("220"), 3, 220}, 1327 {D_STR_W_LEN ("221"), 3, 221}, 1328 {D_STR_W_LEN ("222"), 3, 222}, 1329 {D_STR_W_LEN ("223"), 3, 223}, 1330 {D_STR_W_LEN ("224"), 3, 224}, 1331 {D_STR_W_LEN ("225"), 3, 225}, 1332 {D_STR_W_LEN ("226"), 3, 226}, 1333 {D_STR_W_LEN ("227"), 3, 227}, 1334 {D_STR_W_LEN ("228"), 3, 228}, 1335 {D_STR_W_LEN ("229"), 3, 229}, 1336 {D_STR_W_LEN ("230"), 3, 230}, 1337 {D_STR_W_LEN ("231"), 3, 231}, 1338 {D_STR_W_LEN ("232"), 3, 232}, 1339 {D_STR_W_LEN ("233"), 3, 233}, 1340 {D_STR_W_LEN ("234"), 3, 234}, 1341 {D_STR_W_LEN ("235"), 3, 235}, 1342 {D_STR_W_LEN ("236"), 3, 236}, 1343 {D_STR_W_LEN ("237"), 3, 237}, 1344 {D_STR_W_LEN ("238"), 3, 238}, 1345 {D_STR_W_LEN ("239"), 3, 239}, 1346 {D_STR_W_LEN ("240"), 3, 240}, 1347 {D_STR_W_LEN ("241"), 3, 241}, 1348 {D_STR_W_LEN ("242"), 3, 242}, 1349 {D_STR_W_LEN ("243"), 3, 243}, 1350 {D_STR_W_LEN ("244"), 3, 244}, 1351 {D_STR_W_LEN ("245"), 3, 245}, 1352 {D_STR_W_LEN ("246"), 3, 246}, 1353 {D_STR_W_LEN ("247"), 3, 247}, 1354 {D_STR_W_LEN ("248"), 3, 248}, 1355 {D_STR_W_LEN ("249"), 3, 249}, 1356 {D_STR_W_LEN ("250"), 3, 250}, 1357 {D_STR_W_LEN ("251"), 3, 251}, 1358 {D_STR_W_LEN ("252"), 3, 252}, 1359 {D_STR_W_LEN ("253"), 3, 253}, 1360 {D_STR_W_LEN ("254"), 3, 254}, 1361 {D_STR_W_LEN ("255"), 3, 255} 1362 }; 1363 1364 static const struct str_with_value duint8_w_values_p3[] = { 1365 {D_STR_W_LEN ("000"), 3, 0}, 1366 {D_STR_W_LEN ("001"), 3, 1}, 1367 {D_STR_W_LEN ("002"), 3, 2}, 1368 {D_STR_W_LEN ("003"), 3, 3}, 1369 {D_STR_W_LEN ("004"), 3, 4}, 1370 {D_STR_W_LEN ("005"), 3, 5}, 1371 {D_STR_W_LEN ("006"), 3, 6}, 1372 {D_STR_W_LEN ("007"), 3, 7}, 1373 {D_STR_W_LEN ("008"), 3, 8}, 1374 {D_STR_W_LEN ("009"), 3, 9}, 1375 {D_STR_W_LEN ("010"), 3, 10}, 1376 {D_STR_W_LEN ("011"), 3, 11}, 1377 {D_STR_W_LEN ("012"), 3, 12}, 1378 {D_STR_W_LEN ("013"), 3, 13}, 1379 {D_STR_W_LEN ("014"), 3, 14}, 1380 {D_STR_W_LEN ("015"), 3, 15}, 1381 {D_STR_W_LEN ("016"), 3, 16}, 1382 {D_STR_W_LEN ("017"), 3, 17}, 1383 {D_STR_W_LEN ("018"), 3, 18}, 1384 {D_STR_W_LEN ("019"), 3, 19}, 1385 {D_STR_W_LEN ("020"), 3, 20}, 1386 {D_STR_W_LEN ("021"), 3, 21}, 1387 {D_STR_W_LEN ("022"), 3, 22}, 1388 {D_STR_W_LEN ("023"), 3, 23}, 1389 {D_STR_W_LEN ("024"), 3, 24}, 1390 {D_STR_W_LEN ("025"), 3, 25}, 1391 {D_STR_W_LEN ("026"), 3, 26}, 1392 {D_STR_W_LEN ("027"), 3, 27}, 1393 {D_STR_W_LEN ("028"), 3, 28}, 1394 {D_STR_W_LEN ("029"), 3, 29}, 1395 {D_STR_W_LEN ("030"), 3, 30}, 1396 {D_STR_W_LEN ("031"), 3, 31}, 1397 {D_STR_W_LEN ("032"), 3, 32}, 1398 {D_STR_W_LEN ("033"), 3, 33}, 1399 {D_STR_W_LEN ("034"), 3, 34}, 1400 {D_STR_W_LEN ("035"), 3, 35}, 1401 {D_STR_W_LEN ("036"), 3, 36}, 1402 {D_STR_W_LEN ("037"), 3, 37}, 1403 {D_STR_W_LEN ("038"), 3, 38}, 1404 {D_STR_W_LEN ("039"), 3, 39}, 1405 {D_STR_W_LEN ("040"), 3, 40}, 1406 {D_STR_W_LEN ("041"), 3, 41}, 1407 {D_STR_W_LEN ("042"), 3, 42}, 1408 {D_STR_W_LEN ("043"), 3, 43}, 1409 {D_STR_W_LEN ("044"), 3, 44}, 1410 {D_STR_W_LEN ("045"), 3, 45}, 1411 {D_STR_W_LEN ("046"), 3, 46}, 1412 {D_STR_W_LEN ("047"), 3, 47}, 1413 {D_STR_W_LEN ("048"), 3, 48}, 1414 {D_STR_W_LEN ("049"), 3, 49}, 1415 {D_STR_W_LEN ("050"), 3, 50}, 1416 {D_STR_W_LEN ("051"), 3, 51}, 1417 {D_STR_W_LEN ("052"), 3, 52}, 1418 {D_STR_W_LEN ("053"), 3, 53}, 1419 {D_STR_W_LEN ("054"), 3, 54}, 1420 {D_STR_W_LEN ("055"), 3, 55}, 1421 {D_STR_W_LEN ("056"), 3, 56}, 1422 {D_STR_W_LEN ("057"), 3, 57}, 1423 {D_STR_W_LEN ("058"), 3, 58}, 1424 {D_STR_W_LEN ("059"), 3, 59}, 1425 {D_STR_W_LEN ("060"), 3, 60}, 1426 {D_STR_W_LEN ("061"), 3, 61}, 1427 {D_STR_W_LEN ("062"), 3, 62}, 1428 {D_STR_W_LEN ("063"), 3, 63}, 1429 {D_STR_W_LEN ("064"), 3, 64}, 1430 {D_STR_W_LEN ("065"), 3, 65}, 1431 {D_STR_W_LEN ("066"), 3, 66}, 1432 {D_STR_W_LEN ("067"), 3, 67}, 1433 {D_STR_W_LEN ("068"), 3, 68}, 1434 {D_STR_W_LEN ("069"), 3, 69}, 1435 {D_STR_W_LEN ("070"), 3, 70}, 1436 {D_STR_W_LEN ("071"), 3, 71}, 1437 {D_STR_W_LEN ("072"), 3, 72}, 1438 {D_STR_W_LEN ("073"), 3, 73}, 1439 {D_STR_W_LEN ("074"), 3, 74}, 1440 {D_STR_W_LEN ("075"), 3, 75}, 1441 {D_STR_W_LEN ("076"), 3, 76}, 1442 {D_STR_W_LEN ("077"), 3, 77}, 1443 {D_STR_W_LEN ("078"), 3, 78}, 1444 {D_STR_W_LEN ("079"), 3, 79}, 1445 {D_STR_W_LEN ("080"), 3, 80}, 1446 {D_STR_W_LEN ("081"), 3, 81}, 1447 {D_STR_W_LEN ("082"), 3, 82}, 1448 {D_STR_W_LEN ("083"), 3, 83}, 1449 {D_STR_W_LEN ("084"), 3, 84}, 1450 {D_STR_W_LEN ("085"), 3, 85}, 1451 {D_STR_W_LEN ("086"), 3, 86}, 1452 {D_STR_W_LEN ("087"), 3, 87}, 1453 {D_STR_W_LEN ("088"), 3, 88}, 1454 {D_STR_W_LEN ("089"), 3, 89}, 1455 {D_STR_W_LEN ("090"), 3, 90}, 1456 {D_STR_W_LEN ("091"), 3, 91}, 1457 {D_STR_W_LEN ("092"), 3, 92}, 1458 {D_STR_W_LEN ("093"), 3, 93}, 1459 {D_STR_W_LEN ("094"), 3, 94}, 1460 {D_STR_W_LEN ("095"), 3, 95}, 1461 {D_STR_W_LEN ("096"), 3, 96}, 1462 {D_STR_W_LEN ("097"), 3, 97}, 1463 {D_STR_W_LEN ("098"), 3, 98}, 1464 {D_STR_W_LEN ("099"), 3, 99}, 1465 {D_STR_W_LEN ("100"), 3, 100}, 1466 {D_STR_W_LEN ("101"), 3, 101}, 1467 {D_STR_W_LEN ("102"), 3, 102}, 1468 {D_STR_W_LEN ("103"), 3, 103}, 1469 {D_STR_W_LEN ("104"), 3, 104}, 1470 {D_STR_W_LEN ("105"), 3, 105}, 1471 {D_STR_W_LEN ("106"), 3, 106}, 1472 {D_STR_W_LEN ("107"), 3, 107}, 1473 {D_STR_W_LEN ("108"), 3, 108}, 1474 {D_STR_W_LEN ("109"), 3, 109}, 1475 {D_STR_W_LEN ("110"), 3, 110}, 1476 {D_STR_W_LEN ("111"), 3, 111}, 1477 {D_STR_W_LEN ("112"), 3, 112}, 1478 {D_STR_W_LEN ("113"), 3, 113}, 1479 {D_STR_W_LEN ("114"), 3, 114}, 1480 {D_STR_W_LEN ("115"), 3, 115}, 1481 {D_STR_W_LEN ("116"), 3, 116}, 1482 {D_STR_W_LEN ("117"), 3, 117}, 1483 {D_STR_W_LEN ("118"), 3, 118}, 1484 {D_STR_W_LEN ("119"), 3, 119}, 1485 {D_STR_W_LEN ("120"), 3, 120}, 1486 {D_STR_W_LEN ("121"), 3, 121}, 1487 {D_STR_W_LEN ("122"), 3, 122}, 1488 {D_STR_W_LEN ("123"), 3, 123}, 1489 {D_STR_W_LEN ("124"), 3, 124}, 1490 {D_STR_W_LEN ("125"), 3, 125}, 1491 {D_STR_W_LEN ("126"), 3, 126}, 1492 {D_STR_W_LEN ("127"), 3, 127}, 1493 {D_STR_W_LEN ("128"), 3, 128}, 1494 {D_STR_W_LEN ("129"), 3, 129}, 1495 {D_STR_W_LEN ("130"), 3, 130}, 1496 {D_STR_W_LEN ("131"), 3, 131}, 1497 {D_STR_W_LEN ("132"), 3, 132}, 1498 {D_STR_W_LEN ("133"), 3, 133}, 1499 {D_STR_W_LEN ("134"), 3, 134}, 1500 {D_STR_W_LEN ("135"), 3, 135}, 1501 {D_STR_W_LEN ("136"), 3, 136}, 1502 {D_STR_W_LEN ("137"), 3, 137}, 1503 {D_STR_W_LEN ("138"), 3, 138}, 1504 {D_STR_W_LEN ("139"), 3, 139}, 1505 {D_STR_W_LEN ("140"), 3, 140}, 1506 {D_STR_W_LEN ("141"), 3, 141}, 1507 {D_STR_W_LEN ("142"), 3, 142}, 1508 {D_STR_W_LEN ("143"), 3, 143}, 1509 {D_STR_W_LEN ("144"), 3, 144}, 1510 {D_STR_W_LEN ("145"), 3, 145}, 1511 {D_STR_W_LEN ("146"), 3, 146}, 1512 {D_STR_W_LEN ("147"), 3, 147}, 1513 {D_STR_W_LEN ("148"), 3, 148}, 1514 {D_STR_W_LEN ("149"), 3, 149}, 1515 {D_STR_W_LEN ("150"), 3, 150}, 1516 {D_STR_W_LEN ("151"), 3, 151}, 1517 {D_STR_W_LEN ("152"), 3, 152}, 1518 {D_STR_W_LEN ("153"), 3, 153}, 1519 {D_STR_W_LEN ("154"), 3, 154}, 1520 {D_STR_W_LEN ("155"), 3, 155}, 1521 {D_STR_W_LEN ("156"), 3, 156}, 1522 {D_STR_W_LEN ("157"), 3, 157}, 1523 {D_STR_W_LEN ("158"), 3, 158}, 1524 {D_STR_W_LEN ("159"), 3, 159}, 1525 {D_STR_W_LEN ("160"), 3, 160}, 1526 {D_STR_W_LEN ("161"), 3, 161}, 1527 {D_STR_W_LEN ("162"), 3, 162}, 1528 {D_STR_W_LEN ("163"), 3, 163}, 1529 {D_STR_W_LEN ("164"), 3, 164}, 1530 {D_STR_W_LEN ("165"), 3, 165}, 1531 {D_STR_W_LEN ("166"), 3, 166}, 1532 {D_STR_W_LEN ("167"), 3, 167}, 1533 {D_STR_W_LEN ("168"), 3, 168}, 1534 {D_STR_W_LEN ("169"), 3, 169}, 1535 {D_STR_W_LEN ("170"), 3, 170}, 1536 {D_STR_W_LEN ("171"), 3, 171}, 1537 {D_STR_W_LEN ("172"), 3, 172}, 1538 {D_STR_W_LEN ("173"), 3, 173}, 1539 {D_STR_W_LEN ("174"), 3, 174}, 1540 {D_STR_W_LEN ("175"), 3, 175}, 1541 {D_STR_W_LEN ("176"), 3, 176}, 1542 {D_STR_W_LEN ("177"), 3, 177}, 1543 {D_STR_W_LEN ("178"), 3, 178}, 1544 {D_STR_W_LEN ("179"), 3, 179}, 1545 {D_STR_W_LEN ("180"), 3, 180}, 1546 {D_STR_W_LEN ("181"), 3, 181}, 1547 {D_STR_W_LEN ("182"), 3, 182}, 1548 {D_STR_W_LEN ("183"), 3, 183}, 1549 {D_STR_W_LEN ("184"), 3, 184}, 1550 {D_STR_W_LEN ("185"), 3, 185}, 1551 {D_STR_W_LEN ("186"), 3, 186}, 1552 {D_STR_W_LEN ("187"), 3, 187}, 1553 {D_STR_W_LEN ("188"), 3, 188}, 1554 {D_STR_W_LEN ("189"), 3, 189}, 1555 {D_STR_W_LEN ("190"), 3, 190}, 1556 {D_STR_W_LEN ("191"), 3, 191}, 1557 {D_STR_W_LEN ("192"), 3, 192}, 1558 {D_STR_W_LEN ("193"), 3, 193}, 1559 {D_STR_W_LEN ("194"), 3, 194}, 1560 {D_STR_W_LEN ("195"), 3, 195}, 1561 {D_STR_W_LEN ("196"), 3, 196}, 1562 {D_STR_W_LEN ("197"), 3, 197}, 1563 {D_STR_W_LEN ("198"), 3, 198}, 1564 {D_STR_W_LEN ("199"), 3, 199}, 1565 {D_STR_W_LEN ("200"), 3, 200}, 1566 {D_STR_W_LEN ("201"), 3, 201}, 1567 {D_STR_W_LEN ("202"), 3, 202}, 1568 {D_STR_W_LEN ("203"), 3, 203}, 1569 {D_STR_W_LEN ("204"), 3, 204}, 1570 {D_STR_W_LEN ("205"), 3, 205}, 1571 {D_STR_W_LEN ("206"), 3, 206}, 1572 {D_STR_W_LEN ("207"), 3, 207}, 1573 {D_STR_W_LEN ("208"), 3, 208}, 1574 {D_STR_W_LEN ("209"), 3, 209}, 1575 {D_STR_W_LEN ("210"), 3, 210}, 1576 {D_STR_W_LEN ("211"), 3, 211}, 1577 {D_STR_W_LEN ("212"), 3, 212}, 1578 {D_STR_W_LEN ("213"), 3, 213}, 1579 {D_STR_W_LEN ("214"), 3, 214}, 1580 {D_STR_W_LEN ("215"), 3, 215}, 1581 {D_STR_W_LEN ("216"), 3, 216}, 1582 {D_STR_W_LEN ("217"), 3, 217}, 1583 {D_STR_W_LEN ("218"), 3, 218}, 1584 {D_STR_W_LEN ("219"), 3, 219}, 1585 {D_STR_W_LEN ("220"), 3, 220}, 1586 {D_STR_W_LEN ("221"), 3, 221}, 1587 {D_STR_W_LEN ("222"), 3, 222}, 1588 {D_STR_W_LEN ("223"), 3, 223}, 1589 {D_STR_W_LEN ("224"), 3, 224}, 1590 {D_STR_W_LEN ("225"), 3, 225}, 1591 {D_STR_W_LEN ("226"), 3, 226}, 1592 {D_STR_W_LEN ("227"), 3, 227}, 1593 {D_STR_W_LEN ("228"), 3, 228}, 1594 {D_STR_W_LEN ("229"), 3, 229}, 1595 {D_STR_W_LEN ("230"), 3, 230}, 1596 {D_STR_W_LEN ("231"), 3, 231}, 1597 {D_STR_W_LEN ("232"), 3, 232}, 1598 {D_STR_W_LEN ("233"), 3, 233}, 1599 {D_STR_W_LEN ("234"), 3, 234}, 1600 {D_STR_W_LEN ("235"), 3, 235}, 1601 {D_STR_W_LEN ("236"), 3, 236}, 1602 {D_STR_W_LEN ("237"), 3, 237}, 1603 {D_STR_W_LEN ("238"), 3, 238}, 1604 {D_STR_W_LEN ("239"), 3, 239}, 1605 {D_STR_W_LEN ("240"), 3, 240}, 1606 {D_STR_W_LEN ("241"), 3, 241}, 1607 {D_STR_W_LEN ("242"), 3, 242}, 1608 {D_STR_W_LEN ("243"), 3, 243}, 1609 {D_STR_W_LEN ("244"), 3, 244}, 1610 {D_STR_W_LEN ("245"), 3, 245}, 1611 {D_STR_W_LEN ("246"), 3, 246}, 1612 {D_STR_W_LEN ("247"), 3, 247}, 1613 {D_STR_W_LEN ("248"), 3, 248}, 1614 {D_STR_W_LEN ("249"), 3, 249}, 1615 {D_STR_W_LEN ("250"), 3, 250}, 1616 {D_STR_W_LEN ("251"), 3, 251}, 1617 {D_STR_W_LEN ("252"), 3, 252}, 1618 {D_STR_W_LEN ("253"), 3, 253}, 1619 {D_STR_W_LEN ("254"), 3, 254}, 1620 {D_STR_W_LEN ("255"), 3, 255} 1621 }; 1622 1623 1624 static const struct str_with_value *duint8_w_values_p[3] = 1625 {duint8_w_values_p1, duint8_w_values_p2, duint8_w_values_p3}; 1626 1627 static size_t 1628 check_str_from_uint8_pad (void) 1629 { 1630 int i; 1631 uint8_t pad; 1632 size_t t_failed = 0; 1633 1634 if ((256 != sizeof(duint8_w_values_p1) / sizeof(duint8_w_values_p1[0])) || 1635 (256 != sizeof(duint8_w_values_p2) / sizeof(duint8_w_values_p2[0])) || 1636 (256 != sizeof(duint8_w_values_p3) / sizeof(duint8_w_values_p3[0]))) 1637 { 1638 fprintf (stderr, 1639 "ERROR: wrong number of items in duint8_w_values_p*.\n"); 1640 exit (99); 1641 } 1642 for (pad = 0; pad <= 3; pad++) 1643 { 1644 size_t table_num; 1645 if (0 != pad) 1646 table_num = pad - 1; 1647 else 1648 table_num = 0; 1649 1650 for (i = 0; i <= 255; i++) 1651 { 1652 const struct str_with_value *const t = duint8_w_values_p[table_num] + i; 1653 size_t b_size; 1654 size_t rs; 1655 char buf[8]; 1656 1657 if (t->str.len < t->num_of_digt) 1658 { 1659 fprintf (stderr, 1660 "ERROR: dstrs_w_values[%u] has wrong num_of_digt (%u): num_of_digt is expected" 1661 " to be less or equal to str.len (%u).\n", 1662 (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned 1663 int) t->str. 1664 len); 1665 exit (99); 1666 } 1667 if (sizeof(buf) < t->str.len + 1) 1668 { 1669 fprintf (stderr, 1670 "ERROR: dstrs_w_values[%u] has too long (%u) string, " 1671 "size of 'buf' should be increased.\n", 1672 (unsigned int) i, (unsigned int) t->str.len); 1673 exit (99); 1674 } 1675 for (b_size = 0; b_size <= t->str.len + 1; ++b_size) 1676 { 1677 /* fill buffer with pseudo-random values */ 1678 memset (buf, '#', sizeof(buf)); 1679 1680 rs = mhd_uint8_to_str_pad ((uint8_t) t->val, pad, buf, b_size); 1681 1682 if (t->num_of_digt > b_size) 1683 { 1684 /* Must fail, buffer is too small for result */ 1685 if (0 != rs) 1686 { 1687 t_failed++; 1688 fprintf (stderr, 1689 "FAILED: mhd_uint8_to_str_pad(%" PRIuFAST64 ", %d, -> buf," 1690 " %d) returned %" PRIuPTR 1691 ", while expecting 0.\n", t->val, (int) pad, (int) b_size, 1692 (uintptr_t) rs); 1693 } 1694 else if (0 != memcmp (buf + b_size, 1695 "##########", 1696 sizeof(buf) - b_size)) 1697 { 1698 t_failed++; 1699 fprintf (stderr, 1700 "FAILED: mhd_uint8_to_str_pad(%" PRIuFAST64 ", %d," 1701 " -> \"%.*s\", %d) returned %" PRIuPTR 1702 " and touched memory outside provided buffer.\n" 1703 "The tail of the buffer must be \"%.*s\", " 1704 "but it is \"%.*s\".\n", 1705 t->val, (int) pad, (int) rs, buf, (int) b_size, 1706 (uintptr_t) rs, 1707 (int) (sizeof(buf) - b_size), 1708 "##########", 1709 (int) (sizeof(buf) - b_size), 1710 buf + b_size); 1711 } 1712 } 1713 else 1714 { 1715 if (t->num_of_digt != rs) 1716 { 1717 t_failed++; 1718 fprintf (stderr, 1719 "FAILED: mhd_uint8_to_str_pad(%" PRIuFAST64 ", %d, -> buf," 1720 " %d) returned %" PRIuPTR 1721 ", while expecting %d.\n", t->val, (int) pad, 1722 (int) b_size, (uintptr_t) rs, (int) t->num_of_digt); 1723 } 1724 else if (0 != memcmp (buf, t->str.str, t->num_of_digt)) 1725 { 1726 t_failed++; 1727 fprintf (stderr, 1728 "FAILED: mhd_uint8_to_str_pad(%" PRIuFAST64 ", %d, " 1729 "-> \"%.*s\", %d) returned %" PRIuPTR ".\n", 1730 t->val, (int) pad, (int) rs, buf, 1731 (int) b_size, (uintptr_t) rs); 1732 } 1733 else if (0 != memcmp (buf + rs, "########", sizeof(buf) - rs)) 1734 { 1735 t_failed++; 1736 fprintf (stderr, 1737 "FAILED: mhd_uint8_to_str_pad(%" PRIuFAST64 ", %d," 1738 " -> \"%.*s\", %d) returned %" PRIuPTR 1739 " and touched data after the resulting string.\n", 1740 t->val, (int) pad, (int) rs, buf, (int) b_size, 1741 (uintptr_t) rs); 1742 } 1743 } 1744 } 1745 } 1746 } 1747 if ((verbose > 1) && (0 == t_failed)) 1748 printf ("PASSED: mhd_uint8_to_str_pad.\n"); 1749 1750 return t_failed; 1751 } 1752 1753 1754 static int 1755 run_str_from_X_tests (void) 1756 { 1757 size_t str_from_uint16; 1758 size_t str_from_uint64; 1759 size_t strx_from_uint32; 1760 size_t str_from_uint8_pad; 1761 size_t failures; 1762 1763 failures = 0; 1764 1765 str_from_uint16 = check_str_from_uint16 (); 1766 if (str_from_uint16 != 0) 1767 { 1768 fprintf (stderr, 1769 "FAILED: testcase check_str_from_uint16() failed.\n\n"); 1770 failures += str_from_uint16; 1771 } 1772 else if (verbose > 1) 1773 printf ("PASSED: testcase check_str_from_uint16() successfully " 1774 "passed.\n\n"); 1775 1776 str_from_uint64 = check_str_from_uint64 (); 1777 if (str_from_uint64 != 0) 1778 { 1779 fprintf (stderr, 1780 "FAILED: testcase check_str_from_uint16() failed.\n\n"); 1781 failures += str_from_uint64; 1782 } 1783 else if (verbose > 1) 1784 printf ("PASSED: testcase check_str_from_uint16() successfully " 1785 "passed.\n\n"); 1786 strx_from_uint32 = check_strx_from_uint32 (); 1787 if (strx_from_uint32 != 0) 1788 { 1789 fprintf (stderr, 1790 "FAILED: testcase check_strx_from_uint32() failed.\n\n"); 1791 failures += strx_from_uint32; 1792 } 1793 else if (verbose > 1) 1794 printf ("PASSED: testcase check_strx_from_uint32() successfully " 1795 "passed.\n\n"); 1796 1797 str_from_uint8_pad = check_str_from_uint8_pad (); 1798 if (str_from_uint8_pad != 0) 1799 { 1800 fprintf (stderr, 1801 "FAILED: testcase check_str_from_uint8_pad() failed.\n\n"); 1802 failures += str_from_uint8_pad; 1803 } 1804 else if (verbose > 1) 1805 printf ("PASSED: testcase check_str_from_uint8_pad() successfully " 1806 "passed.\n\n"); 1807 1808 if (failures) 1809 { 1810 if (verbose > 0) 1811 printf ("At least one test failed.\n"); 1812 1813 return 1; 1814 } 1815 1816 if (verbose > 0) 1817 printf ("All tests passed successfully.\n"); 1818 1819 return 0; 1820 } 1821 1822 1823 int 1824 main (int argc, char *argv[]) 1825 { 1826 if (mhdt_has_param (argc, argv, "-v") || 1827 mhdt_has_param (argc, argv, "--verbose") || 1828 mhdt_has_param (argc, argv, "--verbose1")) 1829 MHDT_set_verbosity (MHDT_VERB_LVL_BASIC); 1830 if (mhdt_has_param (argc, argv, "-vv") || 1831 mhdt_has_param (argc, argv, "--verbose2")) 1832 MHDT_set_verbosity (MHDT_VERB_LVL_VERBOSE); 1833 1834 return run_str_from_X_tests (); 1835 }