testutils.c 34.1 KB
Newer Older
K
Karel Zak 已提交
1
/*
2
 * testutils.c: basic test utils
K
Karel Zak 已提交
3
 *
4
 * Copyright (C) 2005-2015 Red Hat, Inc.
K
Karel Zak 已提交
5
 *
O
Osier Yang 已提交
6 7 8 9 10 11 12 13 14 15 16
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library.  If not, see
O
Osier Yang 已提交
18
 * <http://www.gnu.org/licenses/>.
K
Karel Zak 已提交
19 20 21 22
 *
 * Karel Zak <kzak@redhat.com>
 */

23
#include <config.h>
24

K
Karel Zak 已提交
25 26
#include <stdio.h>
#include <stdlib.h>
27
#include <stdarg.h>
K
Karel Zak 已提交
28
#include <sys/time.h>
29 30
#include <sys/types.h>
#include <sys/stat.h>
31 32
#include <sys/wait.h>
#include <regex.h>
33
#include <unistd.h>
34
#include <string.h>
35 36
#include <fcntl.h>
#include <limits.h>
K
Karel Zak 已提交
37
#include "testutils.h"
38
#include "internal.h"
39
#include "viralloc.h"
40
#include "virutil.h"
41
#include "virthread.h"
42
#include "virerror.h"
43
#include "virbuffer.h"
44
#include "virlog.h"
45
#include "vircommand.h"
46
#include "virrandom.h"
E
Eric Blake 已提交
47
#include "dirname.h"
48
#include "virprocess.h"
49
#include "virstring.h"
50

51 52 53 54 55 56 57
#ifdef TEST_OOM
# ifdef TEST_OOM_TRACE
#  include <dlfcn.h>
#  include <execinfo.h>
# endif
#endif

58 59
#define VIR_FROM_THIS VIR_FROM_NONE

60 61
VIR_LOG_INIT("tests.testutils");

62
#include "virbitmap.h"
E
Eric Blake 已提交
63
#include "virfile.h"
64

65
static unsigned int testDebug = -1;
66
static unsigned int testVerbose = -1;
67
static unsigned int testExpensive = -1;
68
static unsigned int testRegenerate = -1;
69

70
#ifdef TEST_OOM
71
static unsigned int testOOM;
72 73
static unsigned int testOOMStart = -1;
static unsigned int testOOMEnd = -1;
74
static unsigned int testOOMTrace;
75 76 77 78 79
# ifdef TEST_OOM_TRACE
void *testAllocStack[30];
int ntestAllocStack;
# endif
#endif
80
static bool testOOMActive;
81

82
static size_t testCounter;
83
static virBitmapPtr testBitmap;
84

E
Eric Blake 已提交
85
char *progname;
J
Ján Tomko 已提交
86
static char *perl;
E
Eric Blake 已提交
87

88
bool virTestOOMActive(void)
89 90 91 92
{
    return testOOMActive;
}

93
static int virTestUseTerminalColors(void)
94 95 96 97
{
    return isatty(STDIN_FILENO);
}

98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
static unsigned int
virTestGetFlag(const char *name)
{
    char *flagStr;
    unsigned int flag;

    if ((flagStr = getenv(name)) == NULL)
        return 0;

    if (virStrToLong_ui(flagStr, NULL, 10, &flag) < 0)
        return 0;

    return flag;
}

113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
#ifdef TEST_OOM_TRACE
static void virTestAllocHook(int nalloc ATTRIBUTE_UNUSED,
                             void *opaque ATTRIBUTE_UNUSED)
{
    ntestAllocStack = backtrace(testAllocStack, ARRAY_CARDINALITY(testAllocStack));
}
#endif

#ifdef TEST_OOM_TRACE
static void
virTestShowTrace(void)
{
    size_t j;
    for (j = 2; j < ntestAllocStack; j++) {
        Dl_info info;
        char *cmd;

        dladdr(testAllocStack[j], &info);
        if (info.dli_fname &&
            strstr(info.dli_fname, ".so")) {
            if (virAsprintf(&cmd, ADDR2LINE " -f -e %s %p",
                            info.dli_fname,
                            ((void*)((unsigned long long)testAllocStack[j]
                                     - (unsigned long long)info.dli_fbase))) < 0)
                continue;
        } else {
            if (virAsprintf(&cmd, ADDR2LINE " -f -e %s %p",
                            (char*)(info.dli_fname ? info.dli_fname : "<unknown>"),
                            testAllocStack[j]) < 0)
                continue;
        }
        ignore_value(system(cmd));
        VIR_FREE(cmd);
    }
}
#endif

150
/*
151
 * Runs test
152 153
 *
 * returns: -1 = error, 0 = success
K
Karel Zak 已提交
154 155
 */
int
156 157
virTestRun(const char *title,
           int (*body)(const void *data), const void *data)
K
Karel Zak 已提交
158
{
159
    int ret = 0;
160

161 162 163 164 165
    /* Some test are fragile about environ settings.  If that's
     * the case, don't poison it. */
    if (getenv("VIR_TEST_MOCK_PROGNAME"))
        setenv("VIR_TEST_MOCK_TESTNAME", title, 1);

166 167 168
    if (testCounter == 0 && !virTestGetVerbose())
        fprintf(stderr, "      ");

169
    testCounter++;
170

171 172

    /* Skip tests if out of range */
173
    if (testBitmap && !virBitmapIsBitSet(testBitmap, testCounter))
174 175
        return 0;

D
Daniel P. Berrange 已提交
176 177
    if (virTestGetVerbose())
        fprintf(stderr, "%2zu) %-65s ... ", testCounter, title);
178

179 180 181 182 183 184
    virResetLastError();
    ret = body(data);
    virErrorPtr err = virGetLastError();
    if (err) {
        if (virTestGetVerbose() || virTestGetDebug())
            virDispatchError(NULL);
185
    }
186

D
Daniel P. Berrange 已提交
187
    if (virTestGetVerbose()) {
188
        if (ret == 0)
189
            if (virTestUseTerminalColors())
190 191 192
                fprintf(stderr, "\e[32mOK\e[0m\n");  /* green */
            else
                fprintf(stderr, "OK\n");
D
Daniel P. Berrange 已提交
193
        else if (ret == EXIT_AM_SKIP)
194
            if (virTestUseTerminalColors())
195 196 197
                fprintf(stderr, "\e[34m\e[1mSKIP\e[0m\n");  /* bold blue */
            else
                fprintf(stderr, "SKIP\n");
D
Daniel P. Berrange 已提交
198
        else
199
            if (virTestUseTerminalColors())
200 201 202
                fprintf(stderr, "\e[31m\e[1mFAILED\e[0m\n");  /* bold red */
            else
                fprintf(stderr, "FAILED\n");
D
Daniel P. Berrange 已提交
203 204 205 206 207
    } else {
        if (testCounter != 1 &&
            !((testCounter-1) % 40)) {
            fprintf(stderr, " %-3zu\n", (testCounter-1));
            fprintf(stderr, "      ");
208
        }
D
Daniel P. Berrange 已提交
209
        if (ret == 0)
210
                fprintf(stderr, ".");
D
Daniel P. Berrange 已提交
211 212 213 214
        else if (ret == EXIT_AM_SKIP)
            fprintf(stderr, "_");
        else
            fprintf(stderr, "!");
215
    }
216

217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
#ifdef TEST_OOM
    if (testOOM && ret != EXIT_AM_SKIP) {
        int nalloc;
        int oomret;
        int start, end;
        size_t i;
        virResetLastError();
        virAllocTestInit();
# ifdef TEST_OOM_TRACE
        virAllocTestHook(virTestAllocHook, NULL);
# endif
        oomret = body(data);
        nalloc = virAllocTestCount();
        fprintf(stderr, "    Test OOM for nalloc=%d ", nalloc);
        if (testOOMStart == -1 ||
            testOOMEnd == -1) {
            start = 0;
            end = nalloc;
        } else {
            start = testOOMStart;
            end = testOOMEnd + 1;
        }
        testOOMActive = true;
        for (i = start; i < end; i++) {
            bool missingFail = false;
# ifdef TEST_OOM_TRACE
            memset(testAllocStack, 0, ARRAY_CARDINALITY(testAllocStack));
            ntestAllocStack = 0;
# endif
            virAllocTestOOM(i + 1, 1);
            oomret = body(data);

            /* fprintf() disabled because XML parsing APIs don't allow
             * distinguish between element / attribute not present
             * in the XML (which is non-fatal), vs OOM / malformed
             * which should be fatal. Thus error reporting for
             * optionally present XML is mostly broken.
             */
            if (oomret == 0) {
                missingFail = true;
# if 0
                fprintf(stderr, " alloc %zu failed but no err status\n", i + 1);
# endif
            } else {
                virErrorPtr lerr = virGetLastError();
                if (!lerr) {
# if 0
                    fprintf(stderr, " alloc %zu failed but no error report\n", i + 1);
# endif
                    missingFail = true;
                }
            }
            if ((missingFail && testOOMTrace) || (testOOMTrace > 1)) {
                fprintf(stderr, "%s", "!");
# ifdef TEST_OOM_TRACE
                virTestShowTrace();
# endif
                ret = -1;
            } else {
                fprintf(stderr, "%s", ".");
            }
        }
        testOOMActive = false;
        if (ret == 0)
            fprintf(stderr, " OK\n");
        else
            fprintf(stderr, " FAILED\n");
        virAllocTestInit();
    }
#endif /* TEST_OOM */

288
    unsetenv("VIR_TEST_MOCK_TESTNAME");
289
    return ret;
K
Karel Zak 已提交
290
}
291

292 293 294 295
/* Allocate BUF to the size of FILE. Read FILE into buffer BUF.
   Upon any failure, diagnose it and return -1, but don't bother trying
   to preserve errno. Otherwise, return the number of bytes copied into BUF. */
int
296
virTestLoadFile(const char *file, char **buf)
297
{
298
    FILE *fp = fopen(file, "r");
299
    struct stat st;
300 301
    char *tmp;
    int len, tmplen, buflen;
302

303
    if (!fp) {
304
        fprintf(stderr, "%s: failed to open: %s\n", file, strerror(errno));
305
        return -1;
306
    }
307 308

    if (fstat(fileno(fp), &st) < 0) {
309
        fprintf(stderr, "%s: failed to fstat: %s\n", file, strerror(errno));
310
        VIR_FORCE_FCLOSE(fp);
311 312 313
        return -1;
    }

314 315 316
    tmplen = buflen = st.st_size + 1;

    if (VIR_ALLOC_N(*buf, buflen) < 0) {
317
        VIR_FORCE_FCLOSE(fp);
318 319 320
        return -1;
    }

321
    tmp = *buf;
322
    (*buf)[0] = '\0';
323
    if (st.st_size) {
324 325 326
        /* read the file line by line */
        while (fgets(tmp, tmplen, fp) != NULL) {
            len = strlen(tmp);
327 328 329
            /* stop on an empty line */
            if (len == 0)
                break;
330 331 332 333 334 335 336 337 338 339
            /* remove trailing backslash-newline pair */
            if (len >= 2 && tmp[len-2] == '\\' && tmp[len-1] == '\n') {
                len -= 2;
                tmp[len] = '\0';
            }
            /* advance the temporary buffer pointer */
            tmp += len;
            tmplen -= len;
        }
        if (ferror(fp)) {
340
            fprintf(stderr, "%s: read failed: %s\n", file, strerror(errno));
341
            VIR_FORCE_FCLOSE(fp);
342
            VIR_FREE(*buf);
343 344
            return -1;
        }
345 346
    }

347
    VIR_FORCE_FCLOSE(fp);
348
    return strlen(*buf);
349 350
}

A
Atsushi SAKAI 已提交
351
#ifndef WIN32
352
static
353 354
void virTestCaptureProgramExecChild(const char *const argv[],
                                    int pipefd)
355
{
356
    size_t i;
357 358 359 360
    int open_max;
    int stdinfd = -1;
    const char *const env[] = {
        "LANG=C",
361
# if WITH_DRIVER_MODULES
362
        "LIBVIRT_DRIVER_DIR=" TEST_DRIVER_DIR,
363
# endif
364 365 366
        NULL
    };

367
    if ((stdinfd = open("/dev/null", O_RDONLY)) < 0)
368 369
        goto cleanup;

370
    open_max = sysconf(_SC_OPEN_MAX);
J
John Ferlan 已提交
371 372 373
    if (open_max < 0)
        goto cleanup;

374 375
    for (i = 0; i < open_max; i++) {
        if (i != stdinfd &&
376
            i != pipefd) {
377 378
            int tmpfd;
            tmpfd = i;
379 380
            VIR_FORCE_CLOSE(tmpfd);
        }
381 382 383 384 385 386
    }

    if (dup2(stdinfd, STDIN_FILENO) != STDIN_FILENO)
        goto cleanup;
    if (dup2(pipefd, STDOUT_FILENO) != STDOUT_FILENO)
        goto cleanup;
387
    if (dup2(pipefd, STDERR_FILENO) != STDERR_FILENO)
388 389 390 391
        goto cleanup;

    /* SUS is crazy here, hence the cast */
    execve(argv[0], (char *const*)argv, (char *const*)env);
392 393

 cleanup:
394
    VIR_FORCE_CLOSE(stdinfd);
395 396
}

397
int
398
virTestCaptureProgramOutput(const char *const argv[], char **buf, int maxlen)
399
{
400
    int pipefd[2];
401
    int len;
402 403 404 405

    if (pipe(pipefd) < 0)
        return -1;

406
    pid_t pid = fork();
407
    switch (pid) {
408
    case 0:
409
        VIR_FORCE_CLOSE(pipefd[0]);
410
        virTestCaptureProgramExecChild(argv, pipefd[1]);
411

412
        VIR_FORCE_CLOSE(pipefd[1]);
413
        _exit(EXIT_FAILURE);
414

415 416
    case -1:
        return -1;
417

418
    default:
419 420 421
        VIR_FORCE_CLOSE(pipefd[1]);
        len = virFileReadLimFD(pipefd[0], maxlen, buf);
        VIR_FORCE_CLOSE(pipefd[0]);
422
        if (virProcessWait(pid, NULL, false) < 0)
E
Eric Blake 已提交
423
            return -1;
424

425
        return len;
426
    }
427
}
428
#else /* !WIN32 */
429
int
430 431 432
virTestCaptureProgramOutput(const char *const argv[] ATTRIBUTE_UNUSED,
                            char **buf ATTRIBUTE_UNUSED,
                            int maxlen ATTRIBUTE_UNUSED)
433
{
434 435
    return -1;
}
A
Atsushi SAKAI 已提交
436
#endif /* !WIN32 */
437

438 439 440 441 442 443 444
static int
virTestRewrapFile(const char *filename)
{
    int ret = -1;
    char *script = NULL;
    virCommandPtr cmd = NULL;

J
Ján Tomko 已提交
445 446 447 448
    if (!(virFileHasSuffix(filename, ".args") ||
          virFileHasSuffix(filename, ".ldargs")))
        return 0;

J
Ján Tomko 已提交
449 450 451 452 453
    if (!perl) {
        fprintf(stderr, "cannot rewrap %s: unable to find perl in path", filename);
        return -1;
    }

454 455 456
    if (virAsprintf(&script, "%s/test-wrap-argv.pl", abs_srcdir) < 0)
        goto cleanup;

J
Ján Tomko 已提交
457
    cmd = virCommandNewArgList(perl, script, "--in-place", filename, NULL);
458 459 460 461 462 463 464 465 466
    if (virCommandRun(cmd, NULL) < 0)
        goto cleanup;

    ret = 0;
 cleanup:
    VIR_FREE(script);
    virCommandFree(cmd);
    return ret;
}
467 468

/**
469
 * @param stream: output stream to write differences to
470
 * @param expect: expected output text
471
 * @param expectName: name designator of the expected text
472
 * @param actual: actual output text
473
 * @param actualName: name designator of the actual text
474
 * @param regenerate: enable or disable regenerate functionality
475
 *
476 477 478
 * Display expected and actual output text, trimmed to first and last
 * characters at which differences occur. Displays names of the text strings if
 * non-NULL.
479
 */
480
static int
481 482 483 484 485 486
virTestDifferenceFullInternal(FILE *stream,
                              const char *expect,
                              const char *expectName,
                              const char *actual,
                              const char *actualName,
                              bool regenerate)
487
{
488 489 490 491 492 493 494 495 496 497 498 499 500 501
    const char *expectStart;
    const char *expectEnd;
    const char *actualStart;
    const char *actualEnd;

    if (!expect)
        expect = "";
    if (!actual)
        actual = "";

    expectStart = expect;
    expectEnd = expect + (strlen(expect)-1);
    actualStart = actual;
    actualEnd = actual + (strlen(actual)-1);
502

503
    if (expectName && regenerate && (virTestGetRegenerate() > 0)) {
504 505
        if (virFileWriteStr(expectName, actual, 0666) < 0) {
            virDispatchError(NULL);
506
            return -1;
507
        }
508

509 510
        if (virTestRewrapFile(expectName) < 0) {
            virDispatchError(NULL);
511
            return -1;
512
        }
513 514
    }

515
    if (!virTestGetDebug())
516 517
        return 0;

518
    if (virTestGetDebug() < 2) {
519 520 521 522 523 524
        /* Skip to first character where they differ */
        while (*expectStart && *actualStart &&
               *actualStart == *expectStart) {
            actualStart++;
            expectStart++;
        }
525

526 527 528 529 530 531 532
        /* Work backwards to last character where they differ */
        while (actualEnd > actualStart &&
               expectEnd > expectStart &&
               *actualEnd == *expectEnd) {
            actualEnd--;
            expectEnd--;
        }
533 534 535
    }

    /* Show the trimmed differences */
536 537
    if (expectName)
        fprintf(stream, "\nIn '%s':", expectName);
E
Eric Blake 已提交
538
    fprintf(stream, "\nOffset %d\nExpect [", (int) (expectStart - expect));
539 540 541 542
    if ((expectEnd - expectStart + 1) &&
        fwrite(expectStart, (expectEnd-expectStart+1), 1, stream) != 1)
        return -1;
    fprintf(stream, "]\n");
543 544
    if (actualName)
        fprintf(stream, "In '%s':\n", actualName);
545 546 547 548 549 550 551 552 553 554 555
    fprintf(stream, "Actual [");
    if ((actualEnd - actualStart + 1) &&
        fwrite(actualStart, (actualEnd-actualStart+1), 1, stream) != 1)
        return -1;
    fprintf(stream, "]\n");

    /* Pad to line up with test name ... in virTestRun */
    fprintf(stream, "                                                                      ... ");

    return 0;
}
556

557 558 559 560 561 562 563 564 565 566 567 568 569
/**
 * @param stream: output stream to write differences to
 * @param expect: expected output text
 * @param expectName: name designator of the expected text
 * @param actual: actual output text
 * @param actualName: name designator of the actual text
 *
 * Display expected and actual output text, trimmed to first and last
 * characters at which differences occur. Displays names of the text strings if
 * non-NULL. If VIR_TEST_REGENERATE_OUTPUT is used, this function will
 * regenerate the expected file.
 */
int
570 571 572 573 574
virTestDifferenceFull(FILE *stream,
                      const char *expect,
                      const char *expectName,
                      const char *actual,
                      const char *actualName)
575
{
576 577
    return virTestDifferenceFullInternal(stream, expect, expectName,
                                         actual, actualName, true);
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592
}

/**
 * @param stream: output stream to write differences to
 * @param expect: expected output text
 * @param expectName: name designator of the expected text
 * @param actual: actual output text
 * @param actualName: name designator of the actual text
 *
 * Display expected and actual output text, trimmed to first and last
 * characters at which differences occur. Displays names of the text strings if
 * non-NULL. If VIR_TEST_REGENERATE_OUTPUT is used, this function will not
 * regenerate the expected file.
 */
int
593 594 595 596 597
virTestDifferenceFullNoRegenerate(FILE *stream,
                                  const char *expect,
                                  const char *expectName,
                                  const char *actual,
                                  const char *actualName)
598
{
599 600
    return virTestDifferenceFullInternal(stream, expect, expectName,
                                         actual, actualName, false);
601 602
}

603
/**
604
 * @param stream: output stream to write differences to
605 606 607 608 609 610
 * @param expect: expected output text
 * @param actual: actual output text
 *
 * Display expected and actual output text, trimmed to
 * first and last characters at which differences occur
 */
611
int
612 613 614
virTestDifference(FILE *stream,
                  const char *expect,
                  const char *actual)
615
{
616 617 618
    return virTestDifferenceFullNoRegenerate(stream,
                                             expect, NULL,
                                             actual, NULL);
619 620 621
}


622
/**
623
 * @param stream: output stream to write differences to
624 625 626 627 628 629
 * @param expect: expected output text
 * @param actual: actual output text
 *
 * Display expected and actual output text, trimmed to
 * first and last characters at which differences occur
 */
630 631 632 633
int virTestDifferenceBin(FILE *stream,
                         const char *expect,
                         const char *actual,
                         size_t length)
634 635 636 637 638 639 640 641 642
{
    size_t start = 0, end = length;
    ssize_t i;

    if (!virTestGetDebug())
        return 0;

    if (virTestGetDebug() < 2) {
        /* Skip to first character where they differ */
643
        for (i = 0; i < length; i++) {
644 645 646 647 648 649 650
            if (expect[i] != actual[i]) {
                start = i;
                break;
            }
        }

        /* Work backwards to last character where they differ */
651
        for (i = (length -1); i >= 0; i--) {
652 653 654 655 656 657
            if (expect[i] != actual[i]) {
                end = i;
                break;
            }
        }
    }
E
Eric Blake 已提交
658
    /* Round to nearest boundary of 4, except that last word can be short */
659 660 661 662 663 664 665
    start -= (start % 4);
    end += 4 - (end % 4);
    if (end >= length)
        end = length - 1;

    /* Show the trimmed differences */
    fprintf(stream, "\nExpect [ Region %d-%d", (int)start, (int)end);
666
    for (i = start; i < end; i++) {
667 668 669 670 671 672
        if ((i % 4) == 0)
            fprintf(stream, "\n    ");
        fprintf(stream, "0x%02x, ", ((int)expect[i])&0xff);
    }
    fprintf(stream, "]\n");
    fprintf(stream, "Actual [ Region %d-%d", (int)start, (int)end);
673
    for (i = start; i < end; i++) {
674 675 676 677 678 679 680 681 682 683 684 685
        if ((i % 4) == 0)
            fprintf(stream, "\n    ");
        fprintf(stream, "0x%02x, ", ((int)actual[i])&0xff);
    }
    fprintf(stream, "]\n");

    /* Pad to line up with test name ... in virTestRun */
    fprintf(stream, "                                                                      ... ");

    return 0;
}

C
Cole Robinson 已提交
686 687 688 689 690
/*
 * @param strcontent: String input content
 * @param filename: File to compare strcontent against
 */
int
691 692
virTestCompareToFile(const char *strcontent,
                     const char *filename)
C
Cole Robinson 已提交
693 694 695 696 697
{
    int ret = -1;
    char *filecontent = NULL;
    char *fixedcontent = NULL;

698
    if (virTestLoadFile(filename, &filecontent) < 0 && !virTestGetRegenerate())
C
Cole Robinson 已提交
699 700
        goto failure;

701 702
    if (filecontent &&
        filecontent[strlen(filecontent) - 1] == '\n' &&
C
Cole Robinson 已提交
703 704 705 706 707
        strcontent[strlen(strcontent) - 1] != '\n') {
        if (virAsprintf(&fixedcontent, "%s\n", strcontent) < 0)
            goto failure;
    }

708 709
    if (STRNEQ_NULLABLE(fixedcontent ? fixedcontent : strcontent,
                        filecontent)) {
710 711
        virTestDifferenceFull(stderr,
                              filecontent, filename,
712
                              fixedcontent, NULL);
C
Cole Robinson 已提交
713 714 715 716 717 718 719 720 721 722
        goto failure;
    }

    ret = 0;
 failure:
    VIR_FREE(fixedcontent);
    VIR_FREE(filecontent);
    return ret;
}

J
Jim Fehlig 已提交
723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
/*
 * @param strcontent: String input content
 * @param strsrc: String source to compare strcontent against
 */
int
virTestCompareToString(const char *strcontent,
                       const char *strsrc)
{
    if (STRNEQ_NULLABLE(strcontent, strsrc)) {
        virTestDifference(stderr, strcontent, strsrc);
        return -1;
    }

    return 0;
}

739
static void
740 741
virTestErrorFuncQuiet(void *data ATTRIBUTE_UNUSED,
                      virErrorPtr err ATTRIBUTE_UNUSED)
742
{ }
743 744 745 746


/* register an error handler in tests when using connections */
void
747
virTestQuiesceLibvirtErrors(bool always)
748 749
{
    if (always || !virTestGetVerbose())
750
        virSetErrorFunc(NULL, virTestErrorFuncQuiet);
751
}
752

753 754 755 756 757 758
struct virtTestLogData {
    virBuffer buf;
};

static struct virtTestLogData testLog = { VIR_BUFFER_INITIALIZER };

759
static void
760
virtTestLogOutput(virLogSourcePtr source ATTRIBUTE_UNUSED,
761
                  virLogPriority priority ATTRIBUTE_UNUSED,
762 763
                  const char *filename ATTRIBUTE_UNUSED,
                  int lineno ATTRIBUTE_UNUSED,
764
                  const char *funcname ATTRIBUTE_UNUSED,
765
                  const char *timestamp,
M
Miloslav Trmač 已提交
766
                  virLogMetadataPtr metadata ATTRIBUTE_UNUSED,
767
                  unsigned int flags,
768
                  const char *rawstr ATTRIBUTE_UNUSED,
769 770
                  const char *str,
                  void *data)
771 772
{
    struct virtTestLogData *log = data;
773
    virCheckFlags(VIR_LOG_STACK_TRACE,);
774 775
    if (!testOOMActive)
        virBufferAsprintf(&log->buf, "%s: %s", timestamp, str);
776 777 778 779 780 781 782 783 784 785 786 787 788
}

static void
virtTestLogClose(void *data)
{
    struct virtTestLogData *log = data;

    virBufferFreeAndReset(&log->buf);
}

/* Return a malloc'd string (possibly with strlen of 0) of all data
 * logged since the last call to this function, or NULL on failure.  */
char *
789
virTestLogContentAndReset(void)
790 791 792 793 794 795
{
    char *ret;

    if (virBufferError(&testLog.buf))
        return NULL;
    ret = virBufferContentAndReset(&testLog.buf);
796 797 798
    if (!ret)
        ignore_value(VIR_STRDUP(ret, ""));
    return ret;
799 800
}

801

802
unsigned int
803 804
virTestGetDebug(void)
{
805 806
    if (testDebug == -1)
        testDebug = virTestGetFlag("VIR_TEST_DEBUG");
807 808
    return testDebug;
}
809

810
unsigned int
811 812
virTestGetVerbose(void)
{
813 814 815 816 817
    if (testVerbose == -1)
        testVerbose = virTestGetFlag("VIR_TEST_VERBOSE");
    return testVerbose || virTestGetDebug();
}

818
unsigned int
819 820
virTestGetExpensive(void)
{
821 822 823 824 825
    if (testExpensive == -1)
        testExpensive = virTestGetFlag("VIR_TEST_EXPENSIVE");
    return testExpensive;
}

826 827 828 829 830 831 832 833
unsigned int
virTestGetRegenerate(void)
{
    if (testRegenerate == -1)
        testRegenerate = virTestGetFlag("VIR_TEST_REGENERATE_OUTPUT");
    return testRegenerate;
}

M
Michal Privoznik 已提交
834 835 836 837 838 839 840
static int
virTestSetEnvPath(void)
{
    int ret = -1;
    const char *path = getenv("PATH");
    char *new_path = NULL;

841 842 843 844 845 846 847 848 849
    if (path) {
        if (strstr(path, abs_builddir) != path &&
            virAsprintf(&new_path, "%s:%s", abs_builddir, path) < 0)
            goto cleanup;
    } else {
        if (VIR_STRDUP(new_path, abs_builddir) < 0)
            goto cleanup;
    }

850 851
    if (new_path &&
        setenv("PATH", new_path, 1) < 0)
M
Michal Privoznik 已提交
852 853 854 855 856 857 858 859
        goto cleanup;

    ret = 0;
 cleanup:
    VIR_FREE(new_path);
    return ret;
}

860 861
#define TEST_MOCK (abs_builddir "/.libs/virtestmock.so")

862 863 864 865
int virTestMain(int argc,
                char **argv,
                int (*func)(void),
                ...)
866
{
867 868
    const char *lib;
    va_list ap;
869
    int ret;
870
    char *testRange = NULL;
871 872 873
#ifdef TEST_OOM
    char *oomstr;
#endif
874

875 876 877
    if (getenv("VIR_TEST_FILE_ACCESS"))
        VIRT_TEST_PRELOAD(TEST_MOCK);

878 879
    va_start(ap, func);
    while ((lib = va_arg(ap, const char *)))
880
        VIRT_TEST_PRELOAD(lib);
881
    va_end(ap);
882 883 884 885 886 887 888

    progname = last_component(argv[0]);
    if (STRPREFIX(progname, "lt-"))
        progname += 3;

    setenv("VIR_TEST_MOCK_PROGNAME", progname, 1);

889 890
    virFileActivateDirOverride(argv[0]);

M
Michal Privoznik 已提交
891 892 893
    if (virTestSetEnvPath() < 0)
        return EXIT_AM_HARDFAIL;

894
    if (!virFileExists(abs_srcdir))
895
        return EXIT_AM_HARDFAIL;
E
Eric Blake 已提交
896 897 898

    if (argc > 1) {
        fprintf(stderr, "Usage: %s\n", argv[0]);
899 900 901 902
        fputs("effective environment variables:\n"
              "VIR_TEST_VERBOSE set to show names of individual tests\n"
              "VIR_TEST_DEBUG set to show information for debugging failures\n",
              stderr);
E
Eric Blake 已提交
903 904 905
        return EXIT_FAILURE;
    }
    fprintf(stderr, "TEST: %s\n", progname);
906

907
    if (virThreadInitialize() < 0 ||
908
        virErrorInitialize() < 0)
909
        return EXIT_FAILURE;
910

911
    virLogSetFromEnv();
912 913
    if (!getenv("LIBVIRT_DEBUG") && !virLogGetNbOutputs()) {
        if (virLogDefineOutput(virtTestLogOutput, virtTestLogClose, &testLog,
914
                               VIR_LOG_DEBUG, VIR_LOG_TO_STDERR, NULL, 0) < 0)
915
            return EXIT_FAILURE;
916
    }
917

918
    if ((testRange = getenv("VIR_TEST_RANGE")) != NULL) {
919
        if (virBitmapParseUnlimited(testRange, &testBitmap) < 0) {
920 921 922 923 924
            fprintf(stderr, "Cannot parse range %s\n", testRange);
            return EXIT_FAILURE;
        }
    }

925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978
#ifdef TEST_OOM
    if ((oomstr = getenv("VIR_TEST_OOM")) != NULL) {
        char *next;
        if (testDebug == -1)
            testDebug = 1;
        testOOM = 1;
        if (oomstr[0] != '\0' &&
            oomstr[1] == ':') {
            if (virStrToLong_ui(oomstr + 2, &next, 10, &testOOMStart) < 0) {
                fprintf(stderr, "Cannot parse range %s\n", oomstr);
                return EXIT_FAILURE;
            }
            if (*next == '\0') {
                testOOMEnd = testOOMStart;
            } else {
                if (*next != '-') {
                    fprintf(stderr, "Cannot parse range %s\n", oomstr);
                    return EXIT_FAILURE;
                }
                if (virStrToLong_ui(next+1, NULL, 10, &testOOMEnd) < 0) {
                    fprintf(stderr, "Cannot parse range %s\n", oomstr);
                    return EXIT_FAILURE;
                }
            }
        } else {
            testOOMStart = -1;
            testOOMEnd = -1;
        }
    }

# ifdef TEST_OOM_TRACE
    if ((oomstr = getenv("VIR_TEST_OOM_TRACE")) != NULL) {
        if (virStrToLong_ui(oomstr, NULL, 10, &testOOMTrace) < 0) {
            fprintf(stderr, "Cannot parse oom trace %s\n", oomstr);
            return EXIT_FAILURE;
        }
    }
# else
    if (getenv("VIR_TEST_OOM_TRACE")) {
        fprintf(stderr, "%s", "OOM test tracing not enabled in this build\n");
        return EXIT_FAILURE;
    }
# endif
#else /* TEST_OOM */
    if (getenv("VIR_TEST_OOM")) {
        fprintf(stderr, "%s", "OOM testing not enabled in this build\n");
        return EXIT_FAILURE;
    }
    if (getenv("VIR_TEST_OOM_TRACE")) {
        fprintf(stderr, "%s", "OOM test tracing not enabled in this build\n");
        return EXIT_FAILURE;
    }
#endif /* TEST_OOM */

J
Ján Tomko 已提交
979 980 981
    /* Find perl early because some tests override PATH */
    perl = virFindFileInPath("perl");

E
Eric Blake 已提交
982
    ret = (func)();
983 984

    virResetLastError();
985
    if (!virTestGetVerbose() && ret != EXIT_AM_SKIP) {
E
Eric Blake 已提交
986
        if (testCounter == 0 || testCounter % 40)
987 988
            fprintf(stderr, "%*s", 40 - (int)(testCounter % 40), "");
        fprintf(stderr, " %-3zu %s\n", testCounter, ret == 0 ? "OK" : "FAIL");
989
    }
J
Ján Tomko 已提交
990
    VIR_FREE(perl);
991
    return ret;
992
}
993 994


995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
/*
 * @cmdset contains a list of command line args, eg
 *
 * "/usr/sbin/iptables --table filter --insert INPUT --in-interface virbr0 --protocol tcp --destination-port 53 --jump ACCEPT
 *  /usr/sbin/iptables --table filter --insert INPUT --in-interface virbr0 --protocol udp --destination-port 53 --jump ACCEPT
 *  /usr/sbin/iptables --table filter --insert FORWARD --in-interface virbr0 --jump REJECT
 *  /usr/sbin/iptables --table filter --insert FORWARD --out-interface virbr0 --jump REJECT
 *  /usr/sbin/iptables --table filter --insert FORWARD --in-interface virbr0 --out-interface virbr0 --jump ACCEPT"
 *
 * And we're munging it in-place to strip the path component
 * of the command line, to produce
 *
 * "iptables --table filter --insert INPUT --in-interface virbr0 --protocol tcp --destination-port 53 --jump ACCEPT
 *  iptables --table filter --insert INPUT --in-interface virbr0 --protocol udp --destination-port 53 --jump ACCEPT
 *  iptables --table filter --insert FORWARD --in-interface virbr0 --jump REJECT
 *  iptables --table filter --insert FORWARD --out-interface virbr0 --jump REJECT
 *  iptables --table filter --insert FORWARD --in-interface virbr0 --out-interface virbr0 --jump ACCEPT"
 */
1013
void virTestClearCommandPath(char *cmdset)
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
{
    size_t offset = 0;
    char *lineStart = cmdset;
    char *lineEnd = strchr(lineStart, '\n');

    while (lineStart) {
        char *dirsep;
        char *movestart;
        size_t movelen;
        dirsep = strchr(lineStart, ' ');
        if (dirsep) {
            while (dirsep > lineStart && *dirsep != '/')
                dirsep--;
            if (*dirsep == '/')
                dirsep++;
            movestart = dirsep;
        } else {
            movestart = lineStart;
        }
        movelen = lineEnd ? lineEnd - movestart : strlen(movestart);

        if (movelen) {
            memmove(cmdset + offset, movestart, movelen + 1);
            offset += movelen + 1;
        }
        lineStart = lineEnd ? lineEnd + 1 : NULL;
        lineEnd = lineStart ? strchr(lineStart, '\n') : NULL;
    }
    cmdset[offset] = '\0';
}


1046 1047 1048 1049 1050 1051
virCapsPtr virTestGenericCapsInit(void)
{
    virCapsPtr caps;
    virCapsGuestPtr guest;

    if ((caps = virCapabilitiesNew(VIR_ARCH_X86_64,
1052
                                   false, false)) == NULL)
1053 1054
        return NULL;

1055
    if ((guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_I686,
1056 1057 1058 1059
                                         "/usr/bin/acme-virt", NULL,
                                         0, NULL)) == NULL)
        goto error;

1060
    if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_TEST, NULL, NULL, 0, NULL))
1061 1062 1063
        goto error;


1064
    if ((guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_X86_64,
1065 1066 1067 1068
                                         "/usr/bin/acme-virt", NULL,
                                         0, NULL)) == NULL)
        goto error;

1069
    if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_TEST, NULL, NULL, 0, NULL))
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
        goto error;


    if (virTestGetDebug()) {
        char *caps_str;

        caps_str = virCapabilitiesFormatXML(caps);
        if (!caps_str)
            goto error;

1080
        VIR_TEST_DEBUG("Generic driver capabilities:\n%s", caps_str);
1081 1082 1083 1084 1085 1086

        VIR_FREE(caps_str);
    }

    return caps;

1087
 error:
1088 1089 1090 1091
    virObjectUnref(caps);
    return NULL;
}

1092 1093 1094
static virDomainDefParserConfig virTestGenericDomainDefParserConfig = {
    .features = VIR_DOMAIN_DEF_FEATURE_INDIVIDUAL_VCPUS,
};
1095 1096 1097 1098 1099 1100 1101 1102
static virDomainXMLPrivateDataCallbacks virTestGenericPrivateDataCallbacks;

virDomainXMLOptionPtr virTestGenericDomainXMLConfInit(void)
{
    return virDomainXMLOptionNew(&virTestGenericDomainDefParserConfig,
                                 &virTestGenericPrivateDataCallbacks,
                                 NULL);
}
1103 1104


1105 1106
int
testCompareDomXML2XMLFiles(virCapsPtr caps, virDomainXMLOptionPtr xmlopt,
1107 1108
                           const char *infile, const char *outfile, bool live,
                           testCompareDomXML2XMLPreFormatCallback cb,
1109 1110
                           const void *opaque, unsigned int parseFlags,
                           testCompareDomXML2XMLResult expectResult)
1111 1112 1113
{
    char *actual = NULL;
    int ret = -1;
1114
    testCompareDomXML2XMLResult result;
1115 1116 1117
    virDomainDefPtr def = NULL;
    unsigned int parse_flags = live ? 0 : VIR_DOMAIN_DEF_PARSE_INACTIVE;
    unsigned int format_flags = VIR_DOMAIN_DEF_FORMAT_SECURE;
1118 1119 1120

    parse_flags |= parseFlags;

1121 1122 1123 1124 1125
    if (!virFileExists(infile)) {
        VIR_TEST_DEBUG("Test input file '%s' is missing", infile);
        return -1;
    }

1126 1127 1128
    if (!live)
        format_flags |= VIR_DOMAIN_DEF_FORMAT_INACTIVE;

1129 1130 1131 1132
    if (!(def = virDomainDefParseFile(infile, caps, xmlopt, parse_flags))) {
        result = TEST_COMPARE_DOM_XML2XML_RESULT_FAIL_PARSE;
        goto out;
    }
1133 1134 1135

    if (!virDomainDefCheckABIStability(def, def)) {
        VIR_TEST_DEBUG("ABI stability check failed on %s", infile);
1136 1137
        result = TEST_COMPARE_DOM_XML2XML_RESULT_FAIL_STABILITY;
        goto out;
1138 1139
    }

1140 1141 1142 1143
    if (cb && cb(def, opaque) < 0) {
        result = TEST_COMPARE_DOM_XML2XML_RESULT_FAIL_CB;
        goto out;
    }
1144

1145 1146 1147 1148
    if (!(actual = virDomainDefFormat(def, caps, format_flags))) {
        result = TEST_COMPARE_DOM_XML2XML_RESULT_FAIL_FORMAT;
        goto out;
    }
1149

1150
    if (virTestCompareToFile(actual, outfile) < 0) {
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
        result = TEST_COMPARE_DOM_XML2XML_RESULT_FAIL_COMPARE;
        goto out;
    }

    result = TEST_COMPARE_DOM_XML2XML_RESULT_SUCCESS;

 out:
    if (result == expectResult) {
        ret = 0;
        if (expectResult != TEST_COMPARE_DOM_XML2XML_RESULT_SUCCESS) {
            VIR_TEST_DEBUG("Got expected failure code=%d msg=%s",
                           result, virGetLastErrorMessage());
        }
    } else {
        ret = -1;
        VIR_TEST_DEBUG("Expected result code=%d but received code=%d",
                       expectResult, result);
    }
1169 1170 1171 1172 1173 1174 1175

    VIR_FREE(actual);
    virDomainDefFree(def);
    return ret;
}


1176 1177 1178 1179 1180 1181
static int virtTestCounter;
static char virtTestCounterStr[128];
static char *virtTestCounterPrefixEndOffset;


/**
1182
 * virTestCounterReset:
1183 1184 1185
 * @prefix: name of the test group
 *
 * Resets the counter and sets up the test group name to use with
1186
 * virTestCounterNext(). This function is not thread safe.
1187 1188 1189 1190 1191
 *
 * Note: The buffer for the assembled message is 128 bytes long. Longer test
 * case names (including the number index) will be silently truncated.
 */
void
1192
virTestCounterReset(const char *prefix)
1193 1194 1195 1196 1197 1198 1199 1200 1201
{
    virtTestCounter = 0;

    ignore_value(virStrcpyStatic(virtTestCounterStr, prefix));
    virtTestCounterPrefixEndOffset = strchrnul(virtTestCounterStr, '\0');
}


/**
1202
 * virTestCounterNext:
1203 1204 1205 1206 1207
 *
 * This function is designed to ease test creation and reordering by adding
 * a way to do automagic test case numbering.
 *
 * Returns string consisting of test name prefix configured via
1208
 * virTestCounterReset() and a number that increments in every call of this
1209 1210 1211 1212 1213 1214
 * function. This function is not thread safe.
 *
 * Note: The buffer for the assembled message is 128 bytes long. Longer test
 * case names (including the number index) will be silently truncated.
 */
const char
1215
*virTestCounterNext(void)
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
{
    size_t len = ARRAY_CARDINALITY(virtTestCounterStr);

    /* calculate length of the rest of the string */
    len -= (virtTestCounterPrefixEndOffset - virtTestCounterStr);

    snprintf(virtTestCounterPrefixEndOffset, len, "%d", ++virtTestCounter);

    return virtTestCounterStr;
}