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