tests/test-util.c

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