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