tests/test-util.c

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