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