tests/test-util.c

   1 /*
   2  * Copyright (c) 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #undef NDEBUG
  19 #include "util.h"
  20 #include <assert.h>
  21 #include <getopt.h>
  22 #include <inttypes.h>
  23 #include <limits.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include "byte-order.h"
  27 #include "command-line.h"
  28 #include "ovstest.h"
  29 #include "random.h"
  30 #include "openvswitch/vlog.h"
  31
  32 static void
  33 check_log_2_floor(uint32_t x, int n)
  34 {
  35     if (log_2_floor(x) != n) {
  36         fprintf(stderr, "log_2_floor(%"PRIu32") is %d but should be %d\n",
  37                 x, log_2_floor(x), n);
  38         abort();
  39     }
  40 }
  41
  42 static void
  43 test_log_2_floor(struct ovs_cmdl_context *ctx OVS_UNUSED)
  44 {
  45     int n;
  46
  47     for (n = 0; n < 32; n++) {
  48         /* Check minimum x such that f(x) == n. */
  49         check_log_2_floor(1 << n, n);
  50
  51         /* Check maximum x such that f(x) == n. */
  52         check_log_2_floor((1 << n) | ((1 << n) - 1), n);
  53
  54         /* Check a random value in the middle. */
  55         check_log_2_floor((random_uint32() & ((1 << n) - 1)) | (1 << n), n);
  56     }
  57
  58     /* log_2_floor(0) is undefined, so don't check it. */
  59 }
  60
  61 static void
  62 check_ctz32(uint32_t x, int n)
  63 {
  64     if (ctz32(x) != n) {
  65         fprintf(stderr, "ctz32(%"PRIu32") is %d but should be %d\n",
  66                 x, ctz32(x), n);
  67         abort();
  68     }
  69 }
  70
  71 static void
  72 check_ctz64(uint64_t x, int n)
  73 {
  74     if (ctz64(x) != n) {
  75         fprintf(stderr, "ctz64(%"PRIu64") is %d but should be %d\n",
  76                 x, ctz64(x), n);
  77         abort();
  78     }
  79 }
  80
  81 static void
  82 test_ctz(struct ovs_cmdl_context *ctx OVS_UNUSED)
  83 {
  84     int n;
  85
  86     for (n = 0; n < 32; n++) {
  87         /* Check minimum x such that f(x) == n. */
  88         check_ctz32(1 << n, n);
  89
  90         /* Check maximum x such that f(x) == n. */
  91         check_ctz32(UINT32_MAX << n, n);
  92
  93         /* Check a random value in the middle. */
  94         check_ctz32((random_uint32() | 1) << n, n);
  95     }
  96
  97
  98     for (n = 0; n < 64; n++) {
  99         /* Check minimum x such that f(x) == n. */
 100         check_ctz64(UINT64_C(1) << n, n);
 101
 102         /* Check maximum x such that f(x) == n. */
 103         check_ctz64(UINT64_MAX << n, n);
 104
 105         /* Check a random value in the middle. */
 106         check_ctz64((random_uint64() | UINT64_C(1)) << n, n);
 107     }
 108
 109     /* Check ctz(0). */
 110     check_ctz32(0, 32);
 111     check_ctz64(0, 64);
 112 }
 113
 114 static void
 115 check_clz32(uint32_t x, int n)
 116 {
 117     if (clz32(x) != n) {
 118         fprintf(stderr, "clz32(%"PRIu32") is %d but should be %d\n",
 119                 x, clz32(x), n);
 120         abort();
 121     }
 122 }
 123
 124 static void
 125 check_clz64(uint64_t x, int n)
 126 {
 127     if (clz64(x) != n) {
 128         fprintf(stderr, "clz64(%"PRIu64") is %d but should be %d\n",
 129                 x, clz64(x), n);
 130         abort();
 131     }
 132 }
 133
 134 static void
 135 test_clz(struct ovs_cmdl_context *ctx OVS_UNUSED)
 136 {
 137     int n;
 138
 139     for (n = 0; n < 32; n++) {
 140         /* Check minimum x such that f(x) == n. */
 141         check_clz32((1u << 31) >> n, n);
 142
 143         /* Check maximum x such that f(x) == n. */
 144         check_clz32(UINT32_MAX >> n, n);
 145
 146         /* Check a random value in the middle. */
 147         check_clz32((random_uint32() | 1u << 31) >> n, n);
 148     }
 149
 150     for (n = 0; n < 64; n++) {
 151         /* Check minimum x such that f(x) == n. */
 152         check_clz64((UINT64_C(1) << 63) >> n, n);
 153
 154         /* Check maximum x such that f(x) == n. */
 155         check_clz64(UINT64_MAX >> n, n);
 156
 157         /* Check a random value in the middle. */
 158         check_clz64((random_uint64() | UINT64_C(1) << 63) >> n, n);
 159     }
 160
 161     /* Check clz(0). */
 162     check_clz32(0, 32);
 163     check_clz64(0, 64);
 164 }
 165
 166 /* Returns a random number in the range 'min'...'max' inclusive. */
 167 static uint32_t
 168 random_in_range(uint32_t min, uint32_t max)
 169 {
 170     return min == max ? min : min + random_range(max - min + 1);
 171 }
 172
 173 static void
 174 check_rup2(uint32_t x, int n)
 175 {
 176     uint32_t rup2 = ROUND_UP_POW2(x);
 177     if (rup2 != n) {
 178         fprintf(stderr, "ROUND_UP_POW2(%#"PRIx32") is %#"PRIx32" "
 179                 "but should be %#"PRIx32"\n", x, rup2, n);
 180         abort();
 181     }
 182 }
 183
 184 static void
 185 test_round_up_pow2(struct ovs_cmdl_context *ctx OVS_UNUSED)
 186 {
 187     int n;
 188
 189     for (n = 0; n < 32; n++) {
 190         /* Min, max value for which ROUND_UP_POW2 should yield (1 << n). */
 191         uint32_t min = ((1u << n) >> 1) + 1;
 192         uint32_t max = 1u << n;
 193
 194         check_rup2(min, 1u << n);
 195         check_rup2(max, 1u << n);
 196         check_rup2(random_in_range(min, max), 1u << n);
 197     }
 198     check_rup2(0, 0);
 199 }
 200
 201 static void
 202 check_rdp2(uint32_t x, int n)
 203 {
 204     uint32_t rdp2 = ROUND_DOWN_POW2(x);
 205     if (rdp2 != n) {
 206         fprintf(stderr, "ROUND_DOWN_POW2(%#"PRIx32") is %#"PRIx32" "
 207                 "but should be %#"PRIx32"\n", x, rdp2, n);
 208         abort();
 209     }
 210 }
 211
 212 static void
 213 test_round_down_pow2(struct ovs_cmdl_context *ctx OVS_UNUSED)
 214 {
 215     int n;
 216
 217     for (n = 0; n < 32; n++) {
 218         /* Min, max value for which ROUND_DOWN_POW2 should yield (1 << n). */
 219         uint32_t min = 1u << n;
 220         uint32_t max = ((1u << n) << 1) - 1;
 221
 222         check_rdp2(min, 1u << n);
 223         check_rdp2(max, 1u << n);
 224         check_rdp2(random_in_range(min, max), 1u << n);
 225     }
 226     check_rdp2(0, 0);
 227 }
 228
 229 static void
 230 shuffle(uint64_t *p, size_t n)
 231 {
 232     for (; n > 1; n--, p++) {
 233         uint64_t *q = &p[random_range(n)];
 234         uint64_t tmp = *p;
 235         *p = *q;
 236         *q = tmp;
 237     }
 238 }
 239
 240 static void
 241 check_count_1bits(uint64_t x, int n)
 242 {
 243     if (count_1bits(x) != n) {
 244         fprintf(stderr, "count_1bits(%#"PRIx64") is %d but should be %d\n",
 245                 x, count_1bits(x), n);
 246         abort();
 247     }
 248 }
 249
 250 static void
 251 test_count_1bits(struct ovs_cmdl_context *ctx OVS_UNUSED)
 252 {
 253     uint64_t bits[64];
 254     int i;
 255
 256     for (i = 0; i < ARRAY_SIZE(bits); i++) {
 257         bits[i] = UINT64_C(1) << i;
 258     }
 259
 260     check_count_1bits(0, 0);
 261
 262     for (i = 0; i < 1000; i++) {
 263         uint64_t x = 0;
 264         int j;
 265
 266         shuffle(bits, ARRAY_SIZE(bits));
 267         for (j = 0; j < 64; j++) {
 268             x |= bits[j];
 269             check_count_1bits(x, j + 1);
 270         }
 271         assert(x == UINT64_MAX);
 272
 273         shuffle(bits, ARRAY_SIZE(bits));
 274         for (j = 63; j >= 0; j--) {
 275             x &= ~bits[j];
 276             check_count_1bits(x, j);
 277         }
 278         assert(x == 0);
 279     }
 280 }
 281
 282 /* Returns the sum of the squares of the first 'n' positive integers. */
 283 static unsigned int
 284 sum_of_squares(int n)
 285 {
 286     return n * (n + 1) * (2 * n + 1) / 6;
 287 }
 288
 289 static void
 290 test_bitwise_copy(struct ovs_cmdl_context *ctx OVS_UNUSED)
 291 {
 292     unsigned int n_loops;
 293     int src_ofs;
 294     int dst_ofs;
 295     int n_bits;
 296
 297     n_loops = 0;
 298     for (n_bits = 0; n_bits <= 64; n_bits++) {
 299         for (src_ofs = 0; src_ofs < 64 - n_bits; src_ofs++) {
 300             for (dst_ofs = 0; dst_ofs < 64 - n_bits; dst_ofs++) {
 301                 ovs_be64 src = htonll(random_uint64());
 302                 ovs_be64 dst = htonll(random_uint64());
 303                 ovs_be64 orig_dst = dst;
 304                 ovs_be64 expect;
 305
 306                 if (n_bits == 64) {
 307                     expect = dst;
 308                 } else {
 309                     uint64_t mask = (UINT64_C(1) << n_bits) - 1;
 310                     expect = orig_dst & ~htonll(mask << dst_ofs);
 311                     expect |= htonll(((ntohll(src) >> src_ofs) & mask)
 312                                      << dst_ofs);
 313                 }
 314
 315                 bitwise_copy(&src, sizeof src, src_ofs,
 316                              &dst, sizeof dst, dst_ofs,
 317                              n_bits);
 318                 if (expect != dst) {
 319                     fprintf(stderr,"copy_bits(0x%016"PRIx64",8,%d, "
 320                             "0x%016"PRIx64",8,%d, %d) yielded 0x%016"PRIx64" "
 321                             "instead of the expected 0x%016"PRIx64"\n",
 322                             ntohll(src), src_ofs,
 323                             ntohll(orig_dst), dst_ofs,
 324                             n_bits,
 325                             ntohll(dst), ntohll(expect));
 326                     abort();
 327                 }
 328
 329                 n_loops++;
 330             }
 331         }
 332     }
 333
 334     if (n_loops != sum_of_squares(64)) {
 335         abort();
 336     }
 337 }
 338
 339 static void
 340 test_bitwise_zero(struct ovs_cmdl_context *ctx OVS_UNUSED)
 341 {
 342     unsigned int n_loops;
 343     int dst_ofs;
 344     int n_bits;
 345
 346     n_loops = 0;
 347     for (n_bits = 0; n_bits <= 64; n_bits++) {
 348         for (dst_ofs = 0; dst_ofs < 64 - n_bits; dst_ofs++) {
 349             ovs_be64 dst = htonll(random_uint64());
 350             ovs_be64 orig_dst = dst;
 351             ovs_be64 expect;
 352
 353             if (n_bits == 64) {
 354                 expect = htonll(0);
 355             } else {
 356                 uint64_t mask = (UINT64_C(1) << n_bits) - 1;
 357                 expect = orig_dst & ~htonll(mask << dst_ofs);
 358             }
 359
 360             bitwise_zero(&dst, sizeof dst, dst_ofs, n_bits);
 361             if (expect != dst) {
 362                 fprintf(stderr,"bitwise_zero(0x%016"PRIx64",8,%d, %d) "
 363                         "yielded 0x%016"PRIx64" "
 364                         "instead of the expected 0x%016"PRIx64"\n",
 365                         ntohll(orig_dst), dst_ofs,
 366                         n_bits,
 367                         ntohll(dst), ntohll(expect));
 368                 abort();
 369             }
 370
 371             n_loops++;
 372         }
 373     }
 374
 375     if (n_loops != 64 * (64 + 1) / 2) {
 376         abort();
 377     }
 378 }
 379
 380 static void
 381 test_bitwise_one(struct ovs_cmdl_context *ctx OVS_UNUSED)
 382 {
 383     unsigned int n_loops;
 384     int dst_ofs;
 385     int n_bits;
 386
 387     n_loops = 0;
 388     for (n_bits = 0; n_bits <= 64; n_bits++) {
 389         for (dst_ofs = 0; dst_ofs < 64 - n_bits; dst_ofs++) {
 390             ovs_be64 dst = htonll(random_uint64());
 391             ovs_be64 orig_dst = dst;
 392             ovs_be64 expect;
 393
 394             if (n_bits == 64) {
 395                 expect = OVS_BE64_MAX;
 396             } else {
 397                 uint64_t mask = (UINT64_C(1) << n_bits) - 1;
 398                 expect = orig_dst | htonll(mask << dst_ofs);
 399             }
 400
 401             bitwise_one(&dst, sizeof dst, dst_ofs, n_bits);
 402             if (expect != dst) {
 403                 fprintf(stderr,"bitwise_one(0x%016"PRIx64",8,%d, %d) "
 404                         "yielded 0x%016"PRIx64" "
 405                         "instead of the expected 0x%016"PRIx64"\n",
 406                         ntohll(orig_dst), dst_ofs,
 407                         n_bits,
 408                         ntohll(dst), ntohll(expect));
 409                 abort();
 410             }
 411
 412             n_loops++;
 413         }
 414     }
 415
 416     if (n_loops != 64 * (64 + 1) / 2) {
 417         abort();
 418     }
 419 }
 420
 421 static void
 422 test_bitwise_is_all_zeros(struct ovs_cmdl_context *ctx OVS_UNUSED)
 423 {
 424     int n_loops;
 425
 426     for (n_loops = 0; n_loops < 100; n_loops++) {
 427         ovs_be64 x = htonll(0);
 428         int i;
 429
 430         for (i = 0; i < 64; i++) {
 431             ovs_be64 bit;
 432             int ofs, n;
 433
 434             /* Change a random 0-bit into a 1-bit. */
 435             do {
 436                 bit = htonll(UINT64_C(1) << (random_range(64)));
 437             } while (x & bit);
 438             x |= bit;
 439
 440             for (ofs = 0; ofs < 64; ofs++) {
 441                 for (n = 0; n <= 64 - ofs; n++) {
 442                     bool expect;
 443                     bool answer;
 444
 445                     expect = (n == 64
 446                               ? x == 0
 447                               : !(x & htonll(((UINT64_C(1) << n) - 1)
 448                                              << ofs)));
 449                     answer = bitwise_is_all_zeros(&x, sizeof x, ofs, n);
 450                     if (expect != answer) {
 451                         fprintf(stderr,
 452                                 "bitwise_is_all_zeros(0x%016"PRIx64",8,%d,%d "
 453                                 "returned %s instead of %s\n",
 454                                 ntohll(x), ofs, n,
 455                                 answer ? "true" : "false",
 456                                 expect ? "true" : "false");
 457                         abort();
 458                     }
 459                 }
 460             }
 461         }
 462     }
 463 }
 464
 465 static int
 466 trivial_bitwise_rscan(const void *p, unsigned int len, bool target,
 467                       int start, int end)
 468 {
 469     int ofs;
 470
 471     for (ofs = start; ofs > end; ofs--) {
 472         if (bitwise_get_bit(p, len, ofs) == target) {
 473             break;
 474         }
 475     }
 476     return ofs;
 477 }
 478
 479 static void
 480 test_bitwise_rscan(struct ovs_cmdl_context *ctx OVS_UNUSED)
 481 {
 482     /* All 1s */
 483     uint8_t s1[3] = {0xff, 0xff, 0xff};
 484     /* Target is the first bit */
 485     ovs_assert(23 == bitwise_rscan(s1, 3, 1, 23, -1));
 486     /* Target is not found, return -1 */
 487     ovs_assert(-1 == bitwise_rscan(s1, 3, 0, 23, -1));
 488     /* Target is not found and end != -1, return end */
 489     ovs_assert(20 == bitwise_rscan(s1, 3, 0, 23, 20));
 490
 491     /* bit 20 - 23 are 0s */
 492     uint8_t s2[3] = {0x0f, 0xff, 0xff};
 493     /* Target is in the first byte but not the first bit */
 494     ovs_assert(19 == bitwise_rscan(s2, 3, 1, 23, -1));
 495     /* Target exists before the start postion */
 496     ovs_assert(18 == bitwise_rscan(s2, 3, 1, 18, -1));
 497     /* Target exists after the end postion, return end */
 498     ovs_assert(20 == bitwise_rscan(s2, 3, 1, 23, 20));
 499     /* Target is at the end postion, return end */
 500     ovs_assert(19 == bitwise_rscan(s2, 3, 1, 23, 19));
 501     /* start == end, target at start */
 502     ovs_assert(19 == bitwise_rscan(s2, 3, 1, 19, 19));
 503     /* start == end, target not at start */
 504     ovs_assert(20 == bitwise_rscan(s2, 3, 1, 20, 20));
 505     /* Target is 0 ... */
 506     ovs_assert(22 == bitwise_rscan(s2, 3, 0, 22, -1));
 507
 508     /* bit 4 - 23 are 0s */
 509     uint8_t s3[3] = {0x00, 0x00, 0x0f};
 510     /* Target is in the end byte */
 511     ovs_assert(3 == bitwise_rscan(s3, 3, 1, 16, -1));
 512     /* Target exists after the end byte, return end */
 513     ovs_assert(15 == bitwise_rscan(s3, 3, 1, 23, 15));
 514     /* Target exists in end byte but after the end bit, return end */
 515     ovs_assert(4 == bitwise_rscan(s3, 3, 1, 23, 4));
 516     /* Target is 0 ... */
 517     ovs_assert(12 == bitwise_rscan(s3, 3, 0, 12, -1));
 518
 519     /* All 0s */
 520     uint8_t s4[3] = {0x00, 0x00, 0x00};
 521     /* Target not found */
 522     ovs_assert(-1 == bitwise_rscan(s4, 3, 1, 23, -1));
 523     /* Target is 0 ..., start is 0 */
 524     ovs_assert(0 == bitwise_rscan(s4, 3, 0, 0, -1));
 525
 526     int n_loops;
 527     for (n_loops = 0; n_loops < 100; n_loops++) {
 528         ovs_be64 x = htonll(0);
 529         int i;
 530
 531         for (i = 0; i < 64; i++) {
 532             ovs_be64 bit;
 533
 534             /* Change a random 0-bit into a 1-bit. */
 535             do {
 536                 bit = htonll(UINT64_C(1) << (random_range(64)));
 537             } while (x & bit);
 538             x |= bit;
 539
 540             for (int end = -1; end <= 63; end++) {
 541                 for (int start = end; start <= 63; start++) {
 542                     for (int target = 0; target < 2; target++) {
 543                         bool expect = trivial_bitwise_rscan(
 544                             &x, sizeof x, target, start, end);
 545                         bool answer = bitwise_rscan(
 546                             &x, sizeof x, target, start, end);
 547                         if (expect != answer) {
 548                             fprintf(stderr,
 549                                     "bitwise_rscan(0x%016"PRIx64",8,%s,%d,%d) "
 550                                     "returned %s instead of %s\n",
 551                                     ntohll(x),
 552                                     target ? "true" : "false",
 553                                     start, end,
 554                                     answer ? "true" : "false",
 555                                     expect ? "true" : "false");
 556                             abort();
 557                         }
 558                     }
 559                 }
 560             }
 561         }
 562     }
 563 }
 564
 565 static void
 566 test_follow_symlinks(struct ovs_cmdl_context *ctx)
 567 {
 568     int i;
 569
 570     for (i = 1; i < ctx->argc; i++) {
 571         char *target = follow_symlinks(ctx->argv[i]);
 572         puts(target);
 573         free(target);
 574     }
 575 }
 576
 577 static void
 578 test_assert(struct ovs_cmdl_context *ctx OVS_UNUSED)
 579 {
 580     ovs_assert(false);
 581 }
 582
 583 static void
 584 test_ovs_scan(struct ovs_cmdl_context *ctx OVS_UNUSED)
 585 {
 586     char str[16], str2[16], str3[16];
 587     long double ld, ld2;
 588     long long ll, ll2;
 589     signed char c, c2;
 590     ptrdiff_t pd, pd2;
 591     intmax_t im, im2;
 592     size_t sz, sz2;
 593     int n, n2, n3;
 594     double d, d2;
 595     short s, s2;
 596     float f, f2;
 597     long l, l2;
 598     int i, i2;
 599
 600     ovs_assert(ovs_scan("", " "));
 601     ovs_assert(ovs_scan(" ", " "));
 602     ovs_assert(ovs_scan("  ", " "));
 603     ovs_assert(ovs_scan(" \t ", " "));
 604
 605     ovs_assert(ovs_scan("xyzzy", "xyzzy"));
 606     ovs_assert(ovs_scan("xy%zzy", "xy%%zzy"));
 607     ovs_assert(!ovs_scan(" xy%zzy", "xy%%zzy"));
 608     ovs_assert(ovs_scan("    xy%\tzzy", " xy%% zzy"));
 609
 610     ovs_assert(ovs_scan("123", "%d", &i));
 611     ovs_assert(i == 123);
 612     ovs_assert(ovs_scan("0", "%d", &i));
 613     ovs_assert(i == 0);
 614     ovs_assert(!ovs_scan("123", "%d%d", &i, &i2));
 615     ovs_assert(ovs_scan("+123", "%d", &i));
 616     ovs_assert(i == 123);
 617     ovs_assert(ovs_scan("-123", "%d", &i));
 618     ovs_assert(i == -123);
 619     ovs_assert(ovs_scan("0123", "%d", &i));
 620     ovs_assert(i == 123);
 621     ovs_assert(ovs_scan(" 123", "%d", &i));
 622     ovs_assert(i == 123);
 623     ovs_assert(ovs_scan("0x123", "%d", &i));
 624     ovs_assert(i == 0);
 625     ovs_assert(ovs_scan("123", "%2d %d", &i, &i2));
 626     ovs_assert(i == 12);
 627     ovs_assert(i2 == 3);
 628     ovs_assert(ovs_scan("+123", "%2d %d", &i, &i2));
 629     ovs_assert(i == 1);
 630     ovs_assert(i2 == 23);
 631     ovs_assert(ovs_scan("-123", "%2d %d", &i, &i2));
 632     ovs_assert(i == -1);
 633     ovs_assert(i2 == 23);
 634     ovs_assert(ovs_scan("0123", "%2d %d", &i, &i2));
 635     ovs_assert(i == 1);
 636     ovs_assert(i2 == 23);
 637     ovs_assert(ovs_scan("123", "%*2d %d", &i));
 638     ovs_assert(i == 3);
 639     ovs_assert(ovs_scan("+123", "%2d %*d", &i));
 640     ovs_assert(i == 1);
 641     ovs_assert(i2 == 23);
 642     ovs_assert(ovs_scan("-123", "%*2d %*d"));
 643
 644     ovs_assert(ovs_scan("123", "%u", &i));
 645     ovs_assert(i == 123);
 646     ovs_assert(ovs_scan("0", "%u", &i));
 647     ovs_assert(i == 0);
 648     ovs_assert(!ovs_scan("123", "%u%u", &i, &i2));
 649     ovs_assert(ovs_scan("+123", "%u", &i));
 650     ovs_assert(i == 123);
 651     ovs_assert(ovs_scan("-123", "%u", &i));
 652     ovs_assert(i == -123);
 653     ovs_assert(ovs_scan("0123", "%u", &i));
 654     ovs_assert(i == 123);
 655     ovs_assert(ovs_scan(" 123", "%u", &i));
 656     ovs_assert(i == 123);
 657     ovs_assert(ovs_scan("0x123", "%u", &i));
 658     ovs_assert(i == 0);
 659     ovs_assert(ovs_scan("123", "%2u %u", &i, &i2));
 660     ovs_assert(i == 12);
 661     ovs_assert(i2 == 3);
 662     ovs_assert(ovs_scan("+123", "%2u %u", &i, &i2));
 663     ovs_assert(i == 1);
 664     ovs_assert(i2 == 23);
 665     ovs_assert(ovs_scan("-123", "%2u %u", &i, &i2));
 666     ovs_assert(i == -1);
 667     ovs_assert(i2 == 23);
 668     ovs_assert(ovs_scan("0123", "%2u %u", &i, &i2));
 669     ovs_assert(i == 1);
 670     ovs_assert(i2 == 23);
 671     ovs_assert(ovs_scan("123", "%*2u %u", &i));
 672     ovs_assert(i == 3);
 673     ovs_assert(ovs_scan("+123", "%2u %*u", &i));
 674     ovs_assert(i == 1);
 675     ovs_assert(i2 == 23);
 676     ovs_assert(ovs_scan("-123", "%*2u %*u"));
 677
 678     ovs_assert(ovs_scan("123", "%i", &i));
 679     ovs_assert(i == 123);
 680     ovs_assert(ovs_scan("0", "%i", &i));
 681     ovs_assert(i == 0);
 682     ovs_assert(!ovs_scan("123", "%i%i", &i, &i2));
 683     ovs_assert(ovs_scan("+123", "%i", &i));
 684     ovs_assert(i == 123);
 685     ovs_assert(ovs_scan("-123", "%i", &i));
 686     ovs_assert(i == -123);
 687     ovs_assert(ovs_scan("0123", "%i", &i));
 688     ovs_assert(i == 0123);
 689     ovs_assert(ovs_scan(" 123", "%i", &i));
 690     ovs_assert(i == 123);
 691     ovs_assert(ovs_scan("0x123", "%i", &i));
 692     ovs_assert(i == 0x123);
 693     ovs_assert(ovs_scan("123", "%2i %i", &i, &i2));
 694     ovs_assert(i == 12);
 695     ovs_assert(i2 == 3);
 696     ovs_assert(ovs_scan("+123", "%2i %i", &i, &i2));
 697     ovs_assert(i == 1);
 698     ovs_assert(i2 == 23);
 699     ovs_assert(ovs_scan("-123", "%2i %i", &i, &i2));
 700     ovs_assert(i == -1);
 701     ovs_assert(i2 == 23);
 702     ovs_assert(ovs_scan("0123", "%2i %i", &i, &i2));
 703     ovs_assert(i == 1);
 704     ovs_assert(i2 == 23);
 705     ovs_assert(ovs_scan("123", "%*2i %i", &i));
 706     ovs_assert(i == 3);
 707     ovs_assert(ovs_scan("+123", "%2i %*i", &i));
 708     ovs_assert(i == 1);
 709     ovs_assert(i2 == 23);
 710     ovs_assert(ovs_scan("-123", "%*2i %*i"));
 711
 712     ovs_assert(ovs_scan("123", "%o", &i));
 713     ovs_assert(i == 0123);
 714     ovs_assert(ovs_scan("0", "%o", &i));
 715     ovs_assert(i == 0);
 716     ovs_assert(!ovs_scan("123", "%o%o", &i, &i2));
 717     ovs_assert(ovs_scan("+123", "%o", &i));
 718     ovs_assert(i == 0123);
 719     ovs_assert(ovs_scan("-123", "%o", &i));
 720     ovs_assert(i == -0123);
 721     ovs_assert(ovs_scan("0123", "%o", &i));
 722     ovs_assert(i == 0123);
 723     ovs_assert(ovs_scan(" 123", "%o", &i));
 724     ovs_assert(i == 0123);
 725     ovs_assert(ovs_scan("0x123", "%o", &i));
 726     ovs_assert(i == 0);
 727     ovs_assert(ovs_scan("123", "%2o %o", &i, &i2));
 728     ovs_assert(i == 012);
 729     ovs_assert(i2 == 3);
 730     ovs_assert(ovs_scan("+123", "%2o %o", &i, &i2));
 731     ovs_assert(i == 1);
 732     ovs_assert(i2 == 023);
 733     ovs_assert(ovs_scan("-123", "%2o %o", &i, &i2));
 734     ovs_assert(i == -1);
 735     ovs_assert(i2 == 023);
 736     ovs_assert(ovs_scan("0123", "%2o %o", &i, &i2));
 737     ovs_assert(i == 1);
 738     ovs_assert(i2 == 023);
 739     ovs_assert(ovs_scan("123", "%*2o %o", &i));
 740     ovs_assert(i == 3);
 741     ovs_assert(ovs_scan("+123", "%2o %*o", &i));
 742     ovs_assert(i == 1);
 743     ovs_assert(i2 == 023);
 744     ovs_assert(ovs_scan("-123", "%*2o %*o"));
 745
 746     ovs_assert(ovs_scan("123", "%x", &i));
 747     ovs_assert(i == 0x123);
 748     ovs_assert(ovs_scan("0", "%x", &i));
 749     ovs_assert(i == 0);
 750     ovs_assert(!ovs_scan("123", "%x%x", &i, &i2));
 751     ovs_assert(ovs_scan("+123", "%x", &i));
 752     ovs_assert(i == 0x123);
 753     ovs_assert(ovs_scan("-123", "%x", &i));
 754     ovs_assert(i == -0x123);
 755     ovs_assert(ovs_scan("0123", "%x", &i));
 756     ovs_assert(i == 0x123);
 757     ovs_assert(ovs_scan(" 123", "%x", &i));
 758     ovs_assert(i == 0x123);
 759     ovs_assert(ovs_scan("0x123", "%x", &i));
 760     ovs_assert(i == 0x123);
 761     ovs_assert(ovs_scan("123", "%2x %x", &i, &i2));
 762     ovs_assert(i == 0x12);
 763     ovs_assert(i2 == 3);
 764     ovs_assert(ovs_scan("+123", "%2x %x", &i, &i2));
 765     ovs_assert(i == 1);
 766     ovs_assert(i2 == 0x23);
 767     ovs_assert(ovs_scan("-123", "%2x %x", &i, &i2));
 768     ovs_assert(i == -1);
 769     ovs_assert(i2 == 0x23);
 770     ovs_assert(ovs_scan("0123", "%2x %x", &i, &i2));
 771     ovs_assert(i == 1);
 772     ovs_assert(i2 == 0x23);
 773     ovs_assert(ovs_scan("123", "%*2x %x", &i));
 774     ovs_assert(i == 3);
 775     ovs_assert(ovs_scan("+123", "%2x %*x", &i));
 776     ovs_assert(i == 1);
 777     ovs_assert(i2 == 0x23);
 778     ovs_assert(ovs_scan("-123", "%*2x %*x"));
 779
 780     ovs_assert(ovs_scan("123", "%hd", &s));
 781     ovs_assert(s == 123);
 782     ovs_assert(!ovs_scan("123", "%hd%hd", &s, &s2));
 783     ovs_assert(ovs_scan("+123", "%hd", &s));
 784     ovs_assert(s == 123);
 785     ovs_assert(ovs_scan("-123", "%hd", &s));
 786     ovs_assert(s == -123);
 787     ovs_assert(ovs_scan("0123", "%hd", &s));
 788     ovs_assert(s == 123);
 789     ovs_assert(ovs_scan(" 123", "%hd", &s));
 790     ovs_assert(s == 123);
 791     ovs_assert(ovs_scan("0x123", "%hd", &s));
 792     ovs_assert(s == 0);
 793     ovs_assert(ovs_scan("123", "%2hd %hd", &s, &s2));
 794     ovs_assert(s == 12);
 795     ovs_assert(s2 == 3);
 796     ovs_assert(ovs_scan("+123", "%2hd %hd", &s, &s2));
 797     ovs_assert(s == 1);
 798     ovs_assert(s2 == 23);
 799     ovs_assert(ovs_scan("-123", "%2hd %hd", &s, &s2));
 800     ovs_assert(s == -1);
 801     ovs_assert(s2 == 23);
 802     ovs_assert(ovs_scan("0123", "%2hd %hd", &s, &s2));
 803     ovs_assert(s == 1);
 804     ovs_assert(s2 == 23);
 805
 806     ovs_assert(ovs_scan("123", "%hhd", &c));
 807     ovs_assert(c == 123);
 808     ovs_assert(ovs_scan("0", "%hhd", &c));
 809     ovs_assert(c == 0);
 810     ovs_assert(!ovs_scan("123", "%hhd%hhd", &c, &c2));
 811     ovs_assert(ovs_scan("+123", "%hhd", &c));
 812     ovs_assert(c == 123);
 813     ovs_assert(ovs_scan("-123", "%hhd", &c));
 814     ovs_assert(c == -123);
 815     ovs_assert(ovs_scan("0123", "%hhd", &c));
 816     ovs_assert(c == 123);
 817     ovs_assert(ovs_scan(" 123", "%hhd", &c));
 818     ovs_assert(c == 123);
 819     ovs_assert(ovs_scan("0x123", "%hhd", &c));
 820     ovs_assert(c == 0);
 821     ovs_assert(ovs_scan("123", "%2hhd %hhd", &c, &c2));
 822     ovs_assert(c == 12);
 823     ovs_assert(c2 == 3);
 824     ovs_assert(ovs_scan("+123", "%2hhd %hhd", &c, &c2));
 825     ovs_assert(c == 1);
 826     ovs_assert(c2 == 23);
 827     ovs_assert(ovs_scan("-123", "%2hhd %hhd", &c, &c2));
 828     ovs_assert(c == -1);
 829     ovs_assert(c2 == 23);
 830     ovs_assert(ovs_scan("0123", "%2hhd %hhd", &c, &c2));
 831     ovs_assert(c == 1);
 832     ovs_assert(c2 == 23);
 833
 834     ovs_assert(ovs_scan("123", "%ld", &l));
 835     ovs_assert(l == 123);
 836     ovs_assert(ovs_scan("0", "%ld", &l));
 837     ovs_assert(l == 0);
 838     ovs_assert(!ovs_scan("123", "%ld%ld", &l, &l2));
 839     ovs_assert(ovs_scan("+123", "%ld", &l));
 840     ovs_assert(l == 123);
 841     ovs_assert(ovs_scan("-123", "%ld", &l));
 842     ovs_assert(l == -123);
 843     ovs_assert(ovs_scan("0123", "%ld", &l));
 844     ovs_assert(l == 123);
 845     ovs_assert(ovs_scan(" 123", "%ld", &l));
 846     ovs_assert(l == 123);
 847     ovs_assert(ovs_scan("0x123", "%ld", &l));
 848     ovs_assert(l == 0);
 849     ovs_assert(ovs_scan("123", "%2ld %ld", &l, &l2));
 850     ovs_assert(l == 12);
 851     ovs_assert(l2 == 3);
 852     ovs_assert(ovs_scan("+123", "%2ld %ld", &l, &l2));
 853     ovs_assert(l == 1);
 854     ovs_assert(l2 == 23);
 855     ovs_assert(ovs_scan("-123", "%2ld %ld", &l, &l2));
 856     ovs_assert(l == -1);
 857     ovs_assert(l2 == 23);
 858     ovs_assert(ovs_scan("0123", "%2ld %ld", &l, &l2));
 859     ovs_assert(l == 1);
 860     ovs_assert(l2 == 23);
 861
 862     ovs_assert(ovs_scan("123", "%lld", &ll));
 863     ovs_assert(ll == 123);
 864     ovs_assert(ovs_scan("0", "%lld", &ll));
 865     ovs_assert(ll == 0);
 866     ovs_assert(!ovs_scan("123", "%lld%lld", &ll, &ll2));
 867     ovs_assert(ovs_scan("+123", "%lld", &ll));
 868     ovs_assert(ll == 123);
 869     ovs_assert(ovs_scan("-123", "%lld", &ll));
 870     ovs_assert(ll == -123);
 871     ovs_assert(ovs_scan("0123", "%lld", &ll));
 872     ovs_assert(ll == 123);
 873     ovs_assert(ovs_scan(" 123", "%lld", &ll));
 874     ovs_assert(ll == 123);
 875     ovs_assert(ovs_scan("0x123", "%lld", &ll));
 876     ovs_assert(ll == 0);
 877     ovs_assert(ovs_scan("123", "%2lld %lld", &ll, &ll2));
 878     ovs_assert(ll == 12);
 879     ovs_assert(ll2 == 3);
 880     ovs_assert(ovs_scan("+123", "%2lld %lld", &ll, &ll2));
 881     ovs_assert(ll == 1);
 882     ovs_assert(ll2 == 23);
 883     ovs_assert(ovs_scan("-123", "%2lld %lld", &ll, &ll2));
 884     ovs_assert(ll == -1);
 885     ovs_assert(ll2 == 23);
 886     ovs_assert(ovs_scan("0123", "%2lld %lld", &ll, &ll2));
 887     ovs_assert(ll == 1);
 888     ovs_assert(ll2 == 23);
 889
 890     ovs_assert(ovs_scan("123", "%jd", &im));
 891     ovs_assert(im == 123);
 892     ovs_assert(ovs_scan("0", "%jd", &im));
 893     ovs_assert(im == 0);
 894     ovs_assert(!ovs_scan("123", "%jd%jd", &im, &im2));
 895     ovs_assert(ovs_scan("+123", "%jd", &im));
 896     ovs_assert(im == 123);
 897     ovs_assert(ovs_scan("-123", "%jd", &im));
 898     ovs_assert(im == -123);
 899     ovs_assert(ovs_scan("0123", "%jd", &im));
 900     ovs_assert(im == 123);
 901     ovs_assert(ovs_scan(" 123", "%jd", &im));
 902     ovs_assert(im == 123);
 903     ovs_assert(ovs_scan("0x123", "%jd", &im));
 904     ovs_assert(im == 0);
 905     ovs_assert(ovs_scan("123", "%2jd %jd", &im, &im2));
 906     ovs_assert(im == 12);
 907     ovs_assert(im2 == 3);
 908     ovs_assert(ovs_scan("+123", "%2jd %jd", &im, &im2));
 909     ovs_assert(im == 1);
 910     ovs_assert(im2 == 23);
 911     ovs_assert(ovs_scan("-123", "%2jd %jd", &im, &im2));
 912     ovs_assert(im == -1);
 913     ovs_assert(im2 == 23);
 914     ovs_assert(ovs_scan("0123", "%2jd %jd", &im, &im2));
 915     ovs_assert(im == 1);
 916     ovs_assert(im2 == 23);
 917
 918     ovs_assert(ovs_scan("123", "%td", &pd));
 919     ovs_assert(pd == 123);
 920     ovs_assert(ovs_scan("0", "%td", &pd));
 921     ovs_assert(pd == 0);
 922     ovs_assert(!ovs_scan("123", "%td%td", &pd, &pd2));
 923     ovs_assert(ovs_scan("+123", "%td", &pd));
 924     ovs_assert(pd == 123);
 925     ovs_assert(ovs_scan("-123", "%td", &pd));
 926     ovs_assert(pd == -123);
 927     ovs_assert(ovs_scan("0123", "%td", &pd));
 928     ovs_assert(pd == 123);
 929     ovs_assert(ovs_scan(" 123", "%td", &pd));
 930     ovs_assert(pd == 123);
 931     ovs_assert(ovs_scan("0x123", "%td", &pd));
 932     ovs_assert(pd == 0);
 933     ovs_assert(ovs_scan("123", "%2td %td", &pd, &pd2));
 934     ovs_assert(pd == 12);
 935     ovs_assert(pd2 == 3);
 936     ovs_assert(ovs_scan("+123", "%2td %td", &pd, &pd2));
 937     ovs_assert(pd == 1);
 938     ovs_assert(pd2 == 23);
 939     ovs_assert(ovs_scan("-123", "%2td %td", &pd, &pd2));
 940     ovs_assert(pd == -1);
 941     ovs_assert(pd2 == 23);
 942     ovs_assert(ovs_scan("0123", "%2td %td", &pd, &pd2));
 943     ovs_assert(pd == 1);
 944     ovs_assert(pd2 == 23);
 945
 946     ovs_assert(ovs_scan("123", "%zd", &sz));
 947     ovs_assert(sz == 123);
 948     ovs_assert(ovs_scan("0", "%zd", &sz));
 949     ovs_assert(sz == 0);
 950     ovs_assert(!ovs_scan("123", "%zd%zd", &sz, &sz2));
 951     ovs_assert(ovs_scan("+123", "%zd", &sz));
 952     ovs_assert(sz == 123);
 953     ovs_assert(ovs_scan("-123", "%zd", &sz));
 954     ovs_assert(sz == -123);
 955     ovs_assert(ovs_scan("0123", "%zd", &sz));
 956     ovs_assert(sz == 123);
 957     ovs_assert(ovs_scan(" 123", "%zd", &sz));
 958     ovs_assert(sz == 123);
 959     ovs_assert(ovs_scan("0x123", "%zd", &sz));
 960     ovs_assert(sz == 0);
 961     ovs_assert(ovs_scan("123", "%2zd %zd", &sz, &sz2));
 962     ovs_assert(sz == 12);
 963     ovs_assert(sz2 == 3);
 964     ovs_assert(ovs_scan("+123", "%2zd %zd", &sz, &sz2));
 965     ovs_assert(sz == 1);
 966     ovs_assert(sz2 == 23);
 967     ovs_assert(ovs_scan("-123", "%2zd %zd", &sz, &sz2));
 968     ovs_assert(sz == -1);
 969     ovs_assert(sz2 == 23);
 970     ovs_assert(ovs_scan("0123", "%2zd %zd", &sz, &sz2));
 971     ovs_assert(sz == 1);
 972     ovs_assert(sz2 == 23);
 973
 974     ovs_assert(ovs_scan("0.25", "%f", &f));
 975     ovs_assert(f == 0.25);
 976     ovs_assert(ovs_scan("1.0", "%f", &f));
 977     ovs_assert(f == 1.0);
 978     ovs_assert(ovs_scan("-5", "%f", &f));
 979     ovs_assert(f == -5.0);
 980     ovs_assert(ovs_scan("+6", "%f", &f));
 981     ovs_assert(f == 6.0);
 982     ovs_assert(ovs_scan("-1e5", "%f", &f));
 983     ovs_assert(f == -1e5);
 984     ovs_assert(ovs_scan("-.25", "%f", &f));
 985     ovs_assert(f == -.25);
 986     ovs_assert(ovs_scan("+123.e1", "%f", &f));
 987     ovs_assert(f == 1230.0);
 988     ovs_assert(ovs_scan("25e-2", "%f", &f));
 989     ovs_assert(f == 0.25);
 990     ovs_assert(ovs_scan("0.25", "%1f %f", &f, &f2));
 991     ovs_assert(f == 0);
 992     ovs_assert(f2 == 0.25);
 993     ovs_assert(ovs_scan("1.0", "%2f %f", &f, &f2));
 994     ovs_assert(f == 1.0);
 995     ovs_assert(f2 == 0.0);
 996     ovs_assert(!ovs_scan("-5", "%1f", &f));
 997     ovs_assert(!ovs_scan("+6", "%1f", &f));
 998     ovs_assert(!ovs_scan("-1e5", "%2f %*f", &f));
 999     ovs_assert(f == -1);
1000     ovs_assert(!ovs_scan("-.25", "%2f", &f));
1001     ovs_assert(!ovs_scan("+123.e1", "%6f", &f));
1002     ovs_assert(!ovs_scan("25e-2", "%4f", &f));
1003
1004     ovs_assert(ovs_scan("0.25", "%lf", &d));
1005     ovs_assert(d == 0.25);
1006     ovs_assert(ovs_scan("1.0", "%lf", &d));
1007     ovs_assert(d == 1.0);
1008     ovs_assert(ovs_scan("-5", "%lf", &d));
1009     ovs_assert(d == -5.0);
1010     ovs_assert(ovs_scan("+6", "%lf", &d));
1011     ovs_assert(d == 6.0);
1012     ovs_assert(ovs_scan("-1e5", "%lf", &d));
1013     ovs_assert(d == -1e5);
1014     ovs_assert(ovs_scan("-.25", "%lf", &d));
1015     ovs_assert(d == -.25);
1016     ovs_assert(ovs_scan("+123.e1", "%lf", &d));
1017     ovs_assert(d == 1230.0);
1018     ovs_assert(ovs_scan("25e-2", "%lf", &d));
1019     ovs_assert(d == 0.25);
1020     ovs_assert(ovs_scan("0.25", "%1lf %lf", &d, &d2));
1021     ovs_assert(d == 0);
1022     ovs_assert(d2 == 0.25);
1023     ovs_assert(ovs_scan("1.0", "%2lf %lf", &d, &d2));
1024     ovs_assert(d == 1.0);
1025     ovs_assert(d2 == 0.0);
1026     ovs_assert(!ovs_scan("-5", "%1lf", &d));
1027     ovs_assert(!ovs_scan("+6", "%1lf", &d));
1028     ovs_assert(!ovs_scan("-1e5", "%2lf %*f", &d));
1029     ovs_assert(d == -1);
1030     ovs_assert(!ovs_scan("-.25", "%2lf", &d));
1031     ovs_assert(!ovs_scan("+123.e1", "%6lf", &d));
1032     ovs_assert(!ovs_scan("25e-2", "%4lf", &d));
1033
1034     ovs_assert(ovs_scan("0.25", "%Lf", &ld));
1035     ovs_assert(ld == 0.25);
1036     ovs_assert(ovs_scan("1.0", "%Lf", &ld));
1037     ovs_assert(ld == 1.0);
1038     ovs_assert(ovs_scan("-5", "%Lf", &ld));
1039     ovs_assert(ld == -5.0);
1040     ovs_assert(ovs_scan("+6", "%Lf", &ld));
1041     ovs_assert(ld == 6.0);
1042     ovs_assert(ovs_scan("-1e5", "%Lf", &ld));
1043     ovs_assert(ld == -1e5);
1044     ovs_assert(ovs_scan("-.25", "%Lf", &ld));
1045     ovs_assert(ld == -.25);
1046     ovs_assert(ovs_scan("+123.e1", "%Lf", &ld));
1047     ovs_assert(ld == 1230.0);
1048     ovs_assert(ovs_scan("25e-2", "%Lf", &ld));
1049     ovs_assert(ld == 0.25);
1050     ovs_assert(ovs_scan("0.25", "%1Lf %Lf", &ld, &ld2));
1051     ovs_assert(ld == 0);
1052     ovs_assert(ld2 == 0.25);
1053     ovs_assert(ovs_scan("1.0", "%2Lf %Lf", &ld, &ld2));
1054     ovs_assert(ld == 1.0);
1055     ovs_assert(ld2 == 0.0);
1056     ovs_assert(!ovs_scan("-5", "%1Lf", &ld));
1057     ovs_assert(!ovs_scan("+6", "%1Lf", &ld));
1058     ovs_assert(!ovs_scan("-1e5", "%2Lf %*f", &ld));
1059     ovs_assert(ld == -1);
1060     ovs_assert(!ovs_scan("-.25", "%2Lf", &ld));
1061     ovs_assert(!ovs_scan("+123.e1", "%6Lf", &ld));
1062     ovs_assert(!ovs_scan("25e-2", "%4Lf", &ld));
1063
1064     ovs_assert(ovs_scan(" Hello,\tworld ", "%*s%n%*s%n", &n, &n2));
1065     ovs_assert(n == 7);
1066     ovs_assert(n2 == 13);
1067     ovs_assert(!ovs_scan(" Hello,\tworld ", "%*s%*s%*s"));
1068     ovs_assert(ovs_scan(" Hello,\tworld ", "%6s%n%5s%n", str, &n, str2, &n2));
1069     ovs_assert(!strcmp(str, "Hello,"));
1070     ovs_assert(n == 7);
1071     ovs_assert(!strcmp(str2, "world"));
1072     ovs_assert(n2 == 13);
1073     ovs_assert(ovs_scan(" Hello,\tworld ", "%5s%5s%5s", str, str2, str3));
1074     ovs_assert(!strcmp(str, "Hello"));
1075     ovs_assert(!strcmp(str2, ","));
1076     ovs_assert(!strcmp(str3, "world"));
1077     ovs_assert(!ovs_scan(" ", "%*s"));
1078
1079     ovs_assert(ovs_scan(" Hello,\tworld ", "%*c%n%*c%n%c%n",
1080                         &n, &n2, &c, &n3));
1081     ovs_assert(n == 1);
1082     ovs_assert(n2 == 2);
1083     ovs_assert(c == 'e');
1084     ovs_assert(n3 == 3);
1085     ovs_assert(ovs_scan(" Hello,\tworld ", "%*5c%5c", str));
1086     ovs_assert(!memcmp(str, "o,\two", 5));
1087     ovs_assert(!ovs_scan(" Hello,\tworld ", "%*15c"));
1088
1089     ovs_assert(ovs_scan("0x1234xyzzy", "%9[x0-9a-fA-F]%n", str, &n));
1090     ovs_assert(!strcmp(str, "0x1234x"));
1091     ovs_assert(n == 7);
1092     ovs_assert(ovs_scan("foo:bar=baz", "%5[^:=]%n:%5[^:=]%n=%5[^:=]%n",
1093                         str, &n, str2, &n2, str3, &n3));
1094     ovs_assert(!strcmp(str, "foo"));
1095     ovs_assert(n == 3);
1096     ovs_assert(!strcmp(str2, "bar"));
1097     ovs_assert(n2 == 7);
1098     ovs_assert(!strcmp(str3, "baz"));
1099     ovs_assert(n3 == 11);
1100     ovs_assert(!ovs_scan(" ", "%*[0-9]"));
1101     ovs_assert(ovs_scan("0x123a]4xyzzy-", "%[]x0-9a-fA-F]", str));
1102     ovs_assert(!strcmp(str, "0x123a]4x"));
1103     ovs_assert(ovs_scan("abc]xyz","%[^]xyz]", str));
1104     ovs_assert(!strcmp(str, "abc"));
1105     ovs_assert(!ovs_scan("0x123a]4xyzzy-", "%[x0-9]a-fA-F]", str));
1106     ovs_assert(ovs_scan("0x12-3]xyz", "%[x0-9a-f-]", str));
1107     ovs_assert(!strcmp(str, "0x12-3"));
1108     ovs_assert(ovs_scan("0x12-3]xyz", "%[^a-f-]", str));
1109     ovs_assert(!strcmp(str, "0x12"));
1110     ovs_assert(sscanf("0x12-3]xyz", "%[^-a-f]", str));
1111     ovs_assert(!strcmp(str, "0x12"));
1112 }
1113
1114 static void
1115 test_snprintf(struct ovs_cmdl_context *ctx OVS_UNUSED)
1116 {
1117     char s[16];
1118
1119     ovs_assert(snprintf(s, 4, "abcde") == 5);
1120     ovs_assert(!strcmp(s, "abc"));
1121
1122     ovs_assert(snprintf(s, 5, "abcde") == 5);
1123     ovs_assert(!strcmp(s, "abcd"));
1124
1125     ovs_assert(snprintf(s, 6, "abcde") == 5);
1126     ovs_assert(!strcmp(s, "abcde"));
1127
1128     ovs_assert(snprintf(NULL, 0, "abcde") == 5);
1129 }
1130
1131 #ifndef _WIN32
1132 static void
1133 test_file_name(struct ovs_cmdl_context *ctx)
1134 {
1135     int i;
1136
1137     for (i = 1; i < ctx->argc; i++) {
1138         char *dir, *base;
1139
1140         dir = dir_name(ctx->argv[i]);
1141         puts(dir);
1142         free(dir);
1143
1144         base = base_name(ctx->argv[i]);
1145         puts(base);
1146         free(base);
1147     }
1148 }
1149 #endif /* _WIN32 */
1150 \f
1151 static const struct ovs_cmdl_command commands[] = {
1152     {"ctz", NULL, 0, 0, test_ctz},
1153     {"clz", NULL, 0, 0, test_clz},
1154     {"round_up_pow2", NULL, 0, 0, test_round_up_pow2},
1155     {"round_down_pow2", NULL, 0, 0, test_round_down_pow2},
1156     {"count_1bits", NULL, 0, 0, test_count_1bits},
1157     {"log_2_floor", NULL, 0, 0, test_log_2_floor},
1158     {"bitwise_copy", NULL, 0, 0, test_bitwise_copy},
1159     {"bitwise_zero", NULL, 0, 0, test_bitwise_zero},
1160     {"bitwise_one", NULL, 0, 0, test_bitwise_one},
1161     {"bitwise_is_all_zeros", NULL, 0, 0, test_bitwise_is_all_zeros},
1162     {"bitwise_rscan", NULL, 0, 0, test_bitwise_rscan},
1163     {"follow-symlinks", NULL, 1, INT_MAX, test_follow_symlinks},
1164     {"assert", NULL, 0, 0, test_assert},
1165     {"ovs_scan", NULL, 0, 0, test_ovs_scan},
1166     {"snprintf", NULL, 0, 0, test_snprintf},
1167 #ifndef _WIN32
1168     {"file_name", NULL, 1, INT_MAX, test_file_name},
1169 #endif
1170     {NULL, NULL, 0, 0, NULL},
1171 };
1172
1173 static void
1174 parse_options(int argc, char *argv[])
1175 {
1176     enum {
1177         VLOG_OPTION_ENUMS
1178     };
1179     static const struct option long_options[] = {
1180         VLOG_LONG_OPTIONS,
1181         {NULL, 0, NULL, 0},
1182     };
1183     char *short_options = ovs_cmdl_long_options_to_short_options(long_options);
1184
1185     for (;;) {
1186         int c = getopt_long(argc, argv, short_options, long_options, NULL);
1187         if (c == -1) {
1188             break;
1189         }
1190
1191         switch (c) {
1192         VLOG_OPTION_HANDLERS
1193
1194         case '?':
1195             exit(EXIT_FAILURE);
1196
1197         default:
1198             abort();
1199         }
1200     }
1201     free(short_options);
1202 }
1203
1204 static void
1205 test_util_main(int argc, char *argv[])
1206 {
1207     struct ovs_cmdl_context ctx = { .argc = 0, };
1208     set_program_name(argv[0]);
1209     parse_options(argc, argv);
1210     /* On Windows, stderr is fully buffered if connected to a pipe.
1211      * Make it _IONBF so that an abort does not miss log contents.
1212      * POSIX doesn't define the circumstances in which stderr is
1213      * fully buffered either. */
1214     setvbuf(stderr, NULL, _IONBF, 0);
1215     ctx.argc = argc - optind;
1216     ctx.argv = argv + optind;
1217     ovs_cmdl_run_command(&ctx, commands);
1218 }
1219
1220 OVSTEST_REGISTER("test-util", test_util_main);