2006-05-09 15:35:46 +00:00
|
|
|
/*
|
2007-01-19 20:30:05 +00:00
|
|
|
* testutils.c: basic test utils
|
2006-05-09 15:35:46 +00:00
|
|
|
*
|
2012-01-25 15:17:46 +00:00
|
|
|
* Copyright (C) 2005-2012 Red Hat, Inc.
|
2006-05-09 15:35:46 +00:00
|
|
|
*
|
2012-07-27 09:39:53 +00:00
|
|
|
* 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
|
2012-09-20 22:30:55 +00:00
|
|
|
* License along with this library. If not, see
|
2012-07-27 09:39:53 +00:00
|
|
|
* <http://www.gnu.org/licenses/>.
|
2006-05-09 15:35:46 +00:00
|
|
|
*
|
|
|
|
* Karel Zak <kzak@redhat.com>
|
|
|
|
*/
|
|
|
|
|
2008-01-29 18:15:54 +00:00
|
|
|
#include <config.h>
|
2007-12-07 10:08:06 +00:00
|
|
|
|
2006-05-09 15:35:46 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <sys/time.h>
|
2006-08-24 15:05:19 +00:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
2008-06-26 09:37:51 +00:00
|
|
|
#ifndef WIN32
|
2010-03-09 18:22:22 +00:00
|
|
|
# include <sys/wait.h>
|
2008-06-26 09:37:51 +00:00
|
|
|
#endif
|
2009-05-29 14:29:22 +00:00
|
|
|
#ifdef HAVE_REGEX_H
|
2010-03-09 18:22:22 +00:00
|
|
|
# include <regex.h>
|
2009-05-29 14:29:22 +00:00
|
|
|
#endif
|
2006-08-24 15:05:19 +00:00
|
|
|
#include <unistd.h>
|
2008-04-18 15:05:29 +00:00
|
|
|
#include <string.h>
|
2006-08-24 21:46:28 +00:00
|
|
|
#include <fcntl.h>
|
|
|
|
#include <limits.h>
|
2006-05-09 15:35:46 +00:00
|
|
|
#include "testutils.h"
|
2008-04-30 12:30:55 +00:00
|
|
|
#include "internal.h"
|
2008-05-29 15:21:45 +00:00
|
|
|
#include "memory.h"
|
|
|
|
#include "util.h"
|
2009-01-28 21:53:48 +00:00
|
|
|
#include "threads.h"
|
|
|
|
#include "virterror_internal.h"
|
tests: silence qemuargv2xmltest noise
Before this patch, the testsuite was noisy:
TEST: qemuargv2xmltest
........................................ 40
................20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument '-unknown', adding to the qemu namespace
20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument 'parameter', adding to the qemu namespace
. 57 OK
PASS: qemuargv2xmltest
It's not a real failure (which is why the test was completing
successfully), so much as an intentional warning to the user that use
of the qemu namespace has the potential for undefined effects that
leaked through the default logging behavior. After this patch series,
all tests can access any logged data, and this particular test can
explicitly check for the presence or absence of the warning, such that
the test output becomes:
TEST: qemuargv2xmltest
........................................ 40
................. 57 OK
PASS: qemuargv2xmltest
* tests/testutils.h (virtTestLogContentAndReset): New prototype.
* tests/testutils.c (struct virtTestLogData): New struct.
(virtTestLogOutput, virtTestLogClose, virtTestLogContentAndReset):
New functions.
(virtTestMain): Always capture log data emitted during tests.
* tests/qemuargv2xmltest.c (testCompareXMLToArgvHelper, mymain):
Use flag to mark which tests expect noisy stderr.
(testCompareXMLToArgvFiles): Add parameter to test whether stderr
was appropriately silent.
2010-09-10 16:25:49 +00:00
|
|
|
#include "buf.h"
|
|
|
|
#include "logging.h"
|
2011-10-21 17:09:23 +00:00
|
|
|
#include "command.h"
|
2012-01-25 15:17:46 +00:00
|
|
|
#include "virrandom.h"
|
2012-05-25 02:34:16 +00:00
|
|
|
#include "dirname.h"
|
2012-09-24 17:10:37 +00:00
|
|
|
#include "virprocess.h"
|
2008-05-29 15:21:45 +00:00
|
|
|
|
|
|
|
#if TEST_OOM_TRACE
|
2010-03-09 18:22:22 +00:00
|
|
|
# include <execinfo.h>
|
2008-05-29 15:21:45 +00:00
|
|
|
#endif
|
2006-05-09 15:35:46 +00:00
|
|
|
|
2007-06-15 15:24:20 +00:00
|
|
|
#ifdef HAVE_PATHS_H
|
2010-03-09 18:22:22 +00:00
|
|
|
# include <paths.h>
|
2007-06-15 15:24:20 +00:00
|
|
|
#endif
|
|
|
|
|
2012-05-09 14:18:56 +00:00
|
|
|
#define VIR_FROM_THIS VIR_FROM_NONE
|
|
|
|
|
2006-05-09 15:35:46 +00:00
|
|
|
#define GETTIMEOFDAY(T) gettimeofday(T, NULL)
|
2007-01-19 20:30:05 +00:00
|
|
|
#define DIFF_MSEC(T, U) \
|
2011-01-31 11:42:57 +00:00
|
|
|
((((int) ((T)->tv_sec - (U)->tv_sec)) * 1000000.0 + \
|
2007-01-19 20:30:05 +00:00
|
|
|
((int) ((T)->tv_usec - (U)->tv_usec))) / 1000.0)
|
2006-05-09 15:35:46 +00:00
|
|
|
|
2011-07-19 18:32:58 +00:00
|
|
|
#include "virfile.h"
|
2010-11-09 20:48:48 +00:00
|
|
|
|
2009-10-16 15:37:36 +00:00
|
|
|
static unsigned int testDebug = -1;
|
2009-11-30 19:01:31 +00:00
|
|
|
static unsigned int testVerbose = -1;
|
2009-09-10 10:07:20 +00:00
|
|
|
|
2008-05-29 15:21:45 +00:00
|
|
|
static unsigned int testOOM = 0;
|
|
|
|
static unsigned int testCounter = 0;
|
|
|
|
|
2011-04-29 16:21:20 +00:00
|
|
|
char *progname;
|
|
|
|
char *abs_srcdir;
|
|
|
|
|
2006-05-09 15:35:46 +00:00
|
|
|
double
|
|
|
|
virtTestCountAverage(double *items, int nitems)
|
|
|
|
{
|
2007-01-19 20:30:05 +00:00
|
|
|
long double sum = 0;
|
|
|
|
int i;
|
2006-05-09 15:35:46 +00:00
|
|
|
|
2007-01-19 20:30:05 +00:00
|
|
|
for (i=1; i < nitems; i++)
|
|
|
|
sum += items[i];
|
2006-05-09 15:35:46 +00:00
|
|
|
|
2007-01-19 20:30:05 +00:00
|
|
|
return (double) (sum / nitems);
|
2006-05-09 15:35:46 +00:00
|
|
|
}
|
|
|
|
|
2012-03-29 09:41:37 +00:00
|
|
|
|
2009-11-30 19:01:31 +00:00
|
|
|
void virtTestResult(const char *name, int ret, const char *msg, ...)
|
|
|
|
{
|
|
|
|
va_list vargs;
|
|
|
|
va_start(vargs, msg);
|
|
|
|
|
2011-07-09 09:50:38 +00:00
|
|
|
if (testCounter == 0 && !virTestGetVerbose())
|
|
|
|
fprintf(stderr, " ");
|
|
|
|
|
2009-11-30 19:01:31 +00:00
|
|
|
testCounter++;
|
|
|
|
if (virTestGetVerbose()) {
|
|
|
|
fprintf(stderr, "%3d) %-60s ", testCounter, name);
|
|
|
|
if (ret == 0)
|
|
|
|
fprintf(stderr, "OK\n");
|
|
|
|
else {
|
|
|
|
fprintf(stderr, "FAILED\n");
|
|
|
|
if (msg) {
|
2012-03-29 09:41:37 +00:00
|
|
|
char *str;
|
|
|
|
if (virVasprintf(&str, msg, vargs) == 0) {
|
|
|
|
fprintf(stderr, "%s", str);
|
|
|
|
VIR_FREE(str);
|
|
|
|
}
|
2009-11-30 19:01:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (testCounter != 1 &&
|
|
|
|
!((testCounter-1) % 40)) {
|
|
|
|
fprintf(stderr, " %-3d\n", (testCounter-1));
|
|
|
|
fprintf(stderr, " ");
|
|
|
|
}
|
|
|
|
if (ret == 0)
|
|
|
|
fprintf(stderr, ".");
|
|
|
|
else
|
|
|
|
fprintf(stderr, "!");
|
|
|
|
}
|
|
|
|
|
|
|
|
va_end(vargs);
|
|
|
|
}
|
|
|
|
|
2007-01-19 20:30:05 +00:00
|
|
|
/*
|
2006-05-22 14:38:33 +00:00
|
|
|
* Runs test and count average time (if the nloops is grater than 1)
|
2007-01-19 20:30:05 +00:00
|
|
|
*
|
|
|
|
* returns: -1 = error, 0 = success
|
2006-05-09 15:35:46 +00:00
|
|
|
*/
|
|
|
|
int
|
2007-07-18 21:08:22 +00:00
|
|
|
virtTestRun(const char *title, int nloops, int (*body)(const void *data), const void *data)
|
2006-05-09 15:35:46 +00:00
|
|
|
{
|
2007-01-19 20:30:05 +00:00
|
|
|
int i, ret = 0;
|
|
|
|
double *ts = NULL;
|
2008-04-18 15:05:29 +00:00
|
|
|
|
2011-07-09 09:50:38 +00:00
|
|
|
if (testCounter == 0 && !virTestGetVerbose())
|
|
|
|
fprintf(stderr, " ");
|
|
|
|
|
2008-05-29 15:21:45 +00:00
|
|
|
testCounter++;
|
2008-04-18 15:05:29 +00:00
|
|
|
|
2008-05-29 15:21:45 +00:00
|
|
|
if (testOOM < 2) {
|
2009-11-30 19:01:31 +00:00
|
|
|
if (virTestGetVerbose())
|
|
|
|
fprintf(stderr, "%2d) %-65s ... ", testCounter, title);
|
2008-05-29 15:21:45 +00:00
|
|
|
}
|
2007-01-19 20:30:05 +00:00
|
|
|
|
2012-02-02 23:16:43 +00:00
|
|
|
if (nloops > 1 && (VIR_ALLOC_N(ts, nloops) < 0))
|
2007-01-19 20:30:05 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
for (i=0; i < nloops; i++) {
|
|
|
|
struct timeval before, after;
|
|
|
|
|
|
|
|
if (ts)
|
|
|
|
GETTIMEOFDAY(&before);
|
2010-11-23 16:01:03 +00:00
|
|
|
|
2010-09-08 16:12:42 +00:00
|
|
|
virResetLastError();
|
2010-11-23 16:01:03 +00:00
|
|
|
ret = body(data);
|
2010-09-08 16:12:42 +00:00
|
|
|
virErrorPtr err = virGetLastError();
|
2010-11-23 16:01:03 +00:00
|
|
|
if (err) {
|
|
|
|
if (virTestGetVerbose() || virTestGetDebug())
|
|
|
|
virDispatchError(NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret != 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ts) {
|
2007-01-19 20:30:05 +00:00
|
|
|
GETTIMEOFDAY(&after);
|
|
|
|
ts[i] = DIFF_MSEC(&after, &before);
|
|
|
|
}
|
|
|
|
}
|
2008-05-29 15:21:45 +00:00
|
|
|
if (testOOM < 2) {
|
2009-11-30 19:01:31 +00:00
|
|
|
if (virTestGetVerbose()) {
|
|
|
|
if (ret == 0 && ts)
|
|
|
|
fprintf(stderr, "OK [%.5f ms]\n",
|
|
|
|
virtTestCountAverage(ts, nloops));
|
|
|
|
else if (ret == 0)
|
|
|
|
fprintf(stderr, "OK\n");
|
2011-10-12 08:08:33 +00:00
|
|
|
else if (ret == EXIT_AM_SKIP)
|
|
|
|
fprintf(stderr, "SKIP\n");
|
2009-11-30 19:01:31 +00:00
|
|
|
else
|
|
|
|
fprintf(stderr, "FAILED\n");
|
|
|
|
} else {
|
|
|
|
if (testCounter != 1 &&
|
|
|
|
!((testCounter-1) % 40)) {
|
|
|
|
fprintf(stderr, " %-3d\n", (testCounter-1));
|
|
|
|
fprintf(stderr, " ");
|
|
|
|
}
|
|
|
|
if (ret == 0)
|
|
|
|
fprintf(stderr, ".");
|
2011-10-12 08:08:33 +00:00
|
|
|
else if (ret == EXIT_AM_SKIP)
|
|
|
|
fprintf(stderr, "_");
|
2009-11-30 19:01:31 +00:00
|
|
|
else
|
|
|
|
fprintf(stderr, "!");
|
|
|
|
}
|
2008-05-29 15:21:45 +00:00
|
|
|
}
|
2007-01-19 20:30:05 +00:00
|
|
|
|
2012-02-02 23:16:43 +00:00
|
|
|
VIR_FREE(ts);
|
2007-01-19 20:30:05 +00:00
|
|
|
return ret;
|
2006-05-09 15:35:46 +00:00
|
|
|
}
|
2006-08-24 15:05:19 +00:00
|
|
|
|
2011-04-24 22:25:10 +00:00
|
|
|
/* 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
|
|
|
|
virtTestLoadFile(const char *file, char **buf)
|
|
|
|
{
|
2009-02-02 20:35:14 +00:00
|
|
|
FILE *fp = fopen(file, "r");
|
2006-08-24 15:05:19 +00:00
|
|
|
struct stat st;
|
2011-04-24 22:25:10 +00:00
|
|
|
char *tmp;
|
|
|
|
int len, tmplen, buflen;
|
2007-01-19 20:30:05 +00:00
|
|
|
|
2009-02-02 20:35:14 +00:00
|
|
|
if (!fp) {
|
|
|
|
fprintf (stderr, "%s: failed to open: %s\n", file, strerror(errno));
|
2006-08-24 15:05:19 +00:00
|
|
|
return -1;
|
2009-02-02 20:35:14 +00:00
|
|
|
}
|
2006-08-24 15:05:19 +00:00
|
|
|
|
|
|
|
if (fstat(fileno(fp), &st) < 0) {
|
2009-02-02 20:35:14 +00:00
|
|
|
fprintf (stderr, "%s: failed to fstat: %s\n", file, strerror(errno));
|
2010-11-17 02:13:29 +00:00
|
|
|
VIR_FORCE_FCLOSE(fp);
|
2006-08-24 15:05:19 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-04-24 22:25:10 +00:00
|
|
|
tmplen = buflen = st.st_size + 1;
|
|
|
|
|
|
|
|
if (VIR_ALLOC_N(*buf, buflen) < 0) {
|
|
|
|
fprintf (stderr, "%s: larger than available memory (> %d)\n", file, buflen);
|
2010-11-17 02:13:29 +00:00
|
|
|
VIR_FORCE_FCLOSE(fp);
|
2006-08-24 15:05:19 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-04-24 22:25:10 +00:00
|
|
|
tmp = *buf;
|
2011-01-31 11:42:57 +00:00
|
|
|
(*buf)[0] = '\0';
|
2007-01-19 20:30:05 +00:00
|
|
|
if (st.st_size) {
|
2011-01-31 11:42:57 +00:00
|
|
|
/* read the file line by line */
|
|
|
|
while (fgets(tmp, tmplen, fp) != NULL) {
|
|
|
|
len = strlen(tmp);
|
2011-04-24 22:25:10 +00:00
|
|
|
/* stop on an empty line */
|
|
|
|
if (len == 0)
|
|
|
|
break;
|
2011-01-31 11:42:57 +00:00
|
|
|
/* 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)) {
|
2009-02-02 20:35:14 +00:00
|
|
|
fprintf (stderr, "%s: read failed: %s\n", file, strerror(errno));
|
2010-11-17 02:13:29 +00:00
|
|
|
VIR_FORCE_FCLOSE(fp);
|
2012-02-02 23:16:43 +00:00
|
|
|
VIR_FREE(*buf);
|
2007-01-19 20:30:05 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2006-08-24 15:05:19 +00:00
|
|
|
}
|
|
|
|
|
2010-11-17 02:13:29 +00:00
|
|
|
VIR_FORCE_FCLOSE(fp);
|
2011-01-31 11:42:57 +00:00
|
|
|
return strlen(*buf);
|
2006-08-24 15:05:19 +00:00
|
|
|
}
|
|
|
|
|
2008-06-26 09:37:51 +00:00
|
|
|
#ifndef WIN32
|
2006-08-24 21:46:28 +00:00
|
|
|
static
|
|
|
|
void virtTestCaptureProgramExecChild(const char *const argv[],
|
2007-01-19 20:30:05 +00:00
|
|
|
int pipefd) {
|
|
|
|
int i;
|
|
|
|
int open_max;
|
|
|
|
int stdinfd = -1;
|
|
|
|
const char *const env[] = {
|
|
|
|
"LANG=C",
|
2010-03-09 18:22:22 +00:00
|
|
|
# if WITH_DRIVER_MODULES
|
2008-11-21 12:16:08 +00:00
|
|
|
"LIBVIRT_DRIVER_DIR=" TEST_DRIVER_DIR,
|
2010-03-09 18:22:22 +00:00
|
|
|
# endif
|
2007-01-19 20:30:05 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2008-12-17 18:04:55 +00:00
|
|
|
if ((stdinfd = open("/dev/null", O_RDONLY)) < 0)
|
2007-01-19 20:30:05 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
open_max = sysconf (_SC_OPEN_MAX);
|
|
|
|
for (i = 0; i < open_max; i++) {
|
|
|
|
if (i != stdinfd &&
|
2010-11-09 20:48:48 +00:00
|
|
|
i != pipefd) {
|
|
|
|
int tmpfd = i;
|
|
|
|
VIR_FORCE_CLOSE(tmpfd);
|
|
|
|
}
|
2007-01-19 20:30:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (dup2(stdinfd, STDIN_FILENO) != STDIN_FILENO)
|
|
|
|
goto cleanup;
|
|
|
|
if (dup2(pipefd, STDOUT_FILENO) != STDOUT_FILENO)
|
|
|
|
goto cleanup;
|
2009-07-06 14:03:31 +00:00
|
|
|
if (dup2(pipefd, STDERR_FILENO) != STDERR_FILENO)
|
2007-01-19 20:30:05 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
/* SUS is crazy here, hence the cast */
|
|
|
|
execve(argv[0], (char *const*)argv, (char *const*)env);
|
2006-08-24 21:46:28 +00:00
|
|
|
|
|
|
|
cleanup:
|
2010-11-09 20:48:48 +00:00
|
|
|
VIR_FORCE_CLOSE(stdinfd);
|
2006-08-24 21:46:28 +00:00
|
|
|
}
|
|
|
|
|
2011-04-24 22:25:10 +00:00
|
|
|
int
|
|
|
|
virtTestCaptureProgramOutput(const char *const argv[], char **buf, int maxlen)
|
|
|
|
{
|
2007-01-19 20:30:05 +00:00
|
|
|
int pipefd[2];
|
2011-04-24 22:25:10 +00:00
|
|
|
int len;
|
2007-01-19 20:30:05 +00:00
|
|
|
|
|
|
|
if (pipe(pipefd) < 0)
|
|
|
|
return -1;
|
|
|
|
|
build: use correct type for pid and similar types
No thanks to 64-bit windows, with 64-bit pid_t, we have to avoid
constructs like 'int pid'. Our API in libvirt-qemu cannot be
changed without breaking ABI; but then again, libvirt-qemu can
only be used on systems that support UNIX sockets, which rules
out Windows (even if qemu could be compiled there) - so for all
points on the call chain that interact with this API decision,
we require a different variable name to make it clear that we
audited the use for safety.
Adding a syntax-check rule only solves half the battle; anywhere
that uses printf on a pid_t still needs to be converted, but that
will be a separate patch.
* cfg.mk (sc_correct_id_types): New syntax check.
* src/libvirt-qemu.c (virDomainQemuAttach): Document why we didn't
use pid_t for pid, and validate for overflow.
* include/libvirt/libvirt-qemu.h (virDomainQemuAttach): Tweak name
for syntax check.
* src/vmware/vmware_conf.c (vmwareExtractPid): Likewise.
* src/driver.h (virDrvDomainQemuAttach): Likewise.
* tools/virsh.c (cmdQemuAttach): Likewise.
* src/remote/qemu_protocol.x (qemu_domain_attach_args): Likewise.
* src/qemu_protocol-structs (qemu_domain_attach_args): Likewise.
* src/util/cgroup.c (virCgroupPidCode, virCgroupKillInternal):
Likewise.
* src/qemu/qemu_command.c(qemuParseProcFileStrings): Likewise.
(qemuParseCommandLinePid): Use pid_t for pid.
* daemon/libvirtd.c (daemonForkIntoBackground): Likewise.
* src/conf/domain_conf.h (_virDomainObj): Likewise.
* src/probes.d (rpc_socket_new): Likewise.
* src/qemu/qemu_command.h (qemuParseCommandLinePid): Likewise.
* src/qemu/qemu_driver.c (qemudGetProcessInfo, qemuDomainAttach):
Likewise.
* src/qemu/qemu_process.c (qemuProcessAttach): Likewise.
* src/qemu/qemu_process.h (qemuProcessAttach): Likewise.
* src/uml/uml_driver.c (umlGetProcessInfo): Likewise.
* src/util/virnetdev.h (virNetDevSetNamespace): Likewise.
* src/util/virnetdev.c (virNetDevSetNamespace): Likewise.
* tests/testutils.c (virtTestCaptureProgramOutput): Likewise.
* src/conf/storage_conf.h (_virStoragePerms): Use mode_t, uid_t,
and gid_t rather than int.
* src/security/security_dac.c (virSecurityDACSetOwnership): Likewise.
* src/conf/storage_conf.c (virStorageDefParsePerms): Avoid
compiler warning.
2012-02-10 23:08:11 +00:00
|
|
|
pid_t pid = fork();
|
2007-01-19 20:30:05 +00:00
|
|
|
switch (pid) {
|
2006-08-24 21:46:28 +00:00
|
|
|
case 0:
|
2010-11-09 20:48:48 +00:00
|
|
|
VIR_FORCE_CLOSE(pipefd[0]);
|
2007-01-19 20:30:05 +00:00
|
|
|
virtTestCaptureProgramExecChild(argv, pipefd[1]);
|
|
|
|
|
2010-11-09 20:48:48 +00:00
|
|
|
VIR_FORCE_CLOSE(pipefd[1]);
|
2007-01-19 20:30:05 +00:00
|
|
|
_exit(1);
|
|
|
|
|
2006-08-24 21:46:28 +00:00
|
|
|
case -1:
|
|
|
|
return -1;
|
2007-01-19 20:30:05 +00:00
|
|
|
|
2006-08-24 21:46:28 +00:00
|
|
|
default:
|
2011-04-24 22:25:10 +00:00
|
|
|
VIR_FORCE_CLOSE(pipefd[1]);
|
|
|
|
len = virFileReadLimFD(pipefd[0], maxlen, buf);
|
|
|
|
VIR_FORCE_CLOSE(pipefd[0]);
|
2012-09-24 16:59:31 +00:00
|
|
|
if (virProcessWait(pid, NULL) < 0)
|
2011-10-21 17:09:23 +00:00
|
|
|
return -1;
|
2006-08-24 21:46:28 +00:00
|
|
|
|
2011-04-24 22:25:10 +00:00
|
|
|
return len;
|
2007-01-19 20:30:05 +00:00
|
|
|
}
|
2006-08-24 21:46:28 +00:00
|
|
|
}
|
2010-03-16 23:36:07 +00:00
|
|
|
#else /* !WIN32 */
|
2011-04-24 22:25:10 +00:00
|
|
|
int
|
|
|
|
virtTestCaptureProgramOutput(const char *const argv[] ATTRIBUTE_UNUSED,
|
|
|
|
char **buf ATTRIBUTE_UNUSED,
|
|
|
|
int maxlen ATTRIBUTE_UNUSED)
|
|
|
|
{
|
2010-03-16 23:36:07 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2008-06-26 09:37:51 +00:00
|
|
|
#endif /* !WIN32 */
|
2008-04-18 15:05:29 +00:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param stream: output stream write to differences to
|
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
int virtTestDifference(FILE *stream,
|
|
|
|
const char *expect,
|
|
|
|
const char *actual)
|
|
|
|
{
|
|
|
|
const char *expectStart = expect;
|
|
|
|
const char *expectEnd = expect + (strlen(expect)-1);
|
|
|
|
const char *actualStart = actual;
|
|
|
|
const char *actualEnd = actual + (strlen(actual)-1);
|
|
|
|
|
2009-11-30 19:01:31 +00:00
|
|
|
if (!virTestGetDebug())
|
2008-05-29 15:21:45 +00:00
|
|
|
return 0;
|
|
|
|
|
2009-11-30 19:01:31 +00:00
|
|
|
if (virTestGetDebug() < 2) {
|
2008-04-30 12:30:55 +00:00
|
|
|
/* Skip to first character where they differ */
|
|
|
|
while (*expectStart && *actualStart &&
|
|
|
|
*actualStart == *expectStart) {
|
|
|
|
actualStart++;
|
|
|
|
expectStart++;
|
|
|
|
}
|
2008-04-18 15:05:29 +00:00
|
|
|
|
2008-04-30 12:30:55 +00:00
|
|
|
/* Work backwards to last character where they differ */
|
|
|
|
while (actualEnd > actualStart &&
|
|
|
|
expectEnd > expectStart &&
|
|
|
|
*actualEnd == *expectEnd) {
|
|
|
|
actualEnd--;
|
|
|
|
expectEnd--;
|
|
|
|
}
|
2008-04-18 15:05:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Show the trimmed differences */
|
2011-09-17 13:57:26 +00:00
|
|
|
fprintf(stream, "\nOffset %d\nExpect [", (int) (expectStart - expect));
|
2008-04-18 15:05:29 +00:00
|
|
|
if ((expectEnd - expectStart + 1) &&
|
|
|
|
fwrite(expectStart, (expectEnd-expectStart+1), 1, stream) != 1)
|
|
|
|
return -1;
|
|
|
|
fprintf(stream, "]\n");
|
|
|
|
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;
|
|
|
|
}
|
2008-05-29 15:21:45 +00:00
|
|
|
|
2010-12-06 17:03:22 +00:00
|
|
|
/**
|
|
|
|
* @param stream: output stream write to differences to
|
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
int virtTestDifferenceBin(FILE *stream,
|
|
|
|
const char *expect,
|
|
|
|
const char *actual,
|
|
|
|
size_t length)
|
|
|
|
{
|
|
|
|
size_t start = 0, end = length;
|
|
|
|
ssize_t i;
|
|
|
|
|
|
|
|
if (!virTestGetDebug())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (virTestGetDebug() < 2) {
|
|
|
|
/* Skip to first character where they differ */
|
|
|
|
for (i = 0 ; i < length ; i++) {
|
|
|
|
if (expect[i] != actual[i]) {
|
|
|
|
start = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Work backwards to last character where they differ */
|
|
|
|
for (i = (length -1) ; i >= 0 ; i--) {
|
|
|
|
if (expect[i] != actual[i]) {
|
|
|
|
end = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-06-24 14:01:10 +00:00
|
|
|
/* Round to nearest boundary of 4, except that last word can be short */
|
2010-12-06 17:03:22 +00:00
|
|
|
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);
|
|
|
|
for (i = start; i < end ; i++) {
|
|
|
|
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);
|
|
|
|
for (i = start; i < end ; i++) {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-05-29 19:41:40 +00:00
|
|
|
#if TEST_OOM
|
2008-05-29 15:21:45 +00:00
|
|
|
static void
|
|
|
|
virtTestErrorFuncQuiet(void *data ATTRIBUTE_UNUSED,
|
|
|
|
virErrorPtr err ATTRIBUTE_UNUSED)
|
|
|
|
{ }
|
2008-05-29 19:41:40 +00:00
|
|
|
#endif
|
2008-05-29 15:21:45 +00:00
|
|
|
|
tests: silence qemuargv2xmltest noise
Before this patch, the testsuite was noisy:
TEST: qemuargv2xmltest
........................................ 40
................20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument '-unknown', adding to the qemu namespace
20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument 'parameter', adding to the qemu namespace
. 57 OK
PASS: qemuargv2xmltest
It's not a real failure (which is why the test was completing
successfully), so much as an intentional warning to the user that use
of the qemu namespace has the potential for undefined effects that
leaked through the default logging behavior. After this patch series,
all tests can access any logged data, and this particular test can
explicitly check for the presence or absence of the warning, such that
the test output becomes:
TEST: qemuargv2xmltest
........................................ 40
................. 57 OK
PASS: qemuargv2xmltest
* tests/testutils.h (virtTestLogContentAndReset): New prototype.
* tests/testutils.c (struct virtTestLogData): New struct.
(virtTestLogOutput, virtTestLogClose, virtTestLogContentAndReset):
New functions.
(virtTestMain): Always capture log data emitted during tests.
* tests/qemuargv2xmltest.c (testCompareXMLToArgvHelper, mymain):
Use flag to mark which tests expect noisy stderr.
(testCompareXMLToArgvFiles): Add parameter to test whether stderr
was appropriately silent.
2010-09-10 16:25:49 +00:00
|
|
|
struct virtTestLogData {
|
|
|
|
virBuffer buf;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct virtTestLogData testLog = { VIR_BUFFER_INITIALIZER };
|
|
|
|
|
2012-09-20 18:24:00 +00:00
|
|
|
static void
|
2012-09-27 13:44:22 +00:00
|
|
|
virtTestLogOutput(virLogSource source ATTRIBUTE_UNUSED,
|
2012-09-27 12:58:58 +00:00
|
|
|
virLogPriority priority ATTRIBUTE_UNUSED,
|
2012-09-27 13:28:44 +00:00
|
|
|
const char *filename ATTRIBUTE_UNUSED,
|
|
|
|
int lineno ATTRIBUTE_UNUSED,
|
tests: silence qemuargv2xmltest noise
Before this patch, the testsuite was noisy:
TEST: qemuargv2xmltest
........................................ 40
................20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument '-unknown', adding to the qemu namespace
20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument 'parameter', adding to the qemu namespace
. 57 OK
PASS: qemuargv2xmltest
It's not a real failure (which is why the test was completing
successfully), so much as an intentional warning to the user that use
of the qemu namespace has the potential for undefined effects that
leaked through the default logging behavior. After this patch series,
all tests can access any logged data, and this particular test can
explicitly check for the presence or absence of the warning, such that
the test output becomes:
TEST: qemuargv2xmltest
........................................ 40
................. 57 OK
PASS: qemuargv2xmltest
* tests/testutils.h (virtTestLogContentAndReset): New prototype.
* tests/testutils.c (struct virtTestLogData): New struct.
(virtTestLogOutput, virtTestLogClose, virtTestLogContentAndReset):
New functions.
(virtTestMain): Always capture log data emitted during tests.
* tests/qemuargv2xmltest.c (testCompareXMLToArgvHelper, mymain):
Use flag to mark which tests expect noisy stderr.
(testCompareXMLToArgvFiles): Add parameter to test whether stderr
was appropriately silent.
2010-09-10 16:25:49 +00:00
|
|
|
const char *funcname ATTRIBUTE_UNUSED,
|
2011-09-28 13:20:07 +00:00
|
|
|
const char *timestamp,
|
2012-05-09 14:18:56 +00:00
|
|
|
unsigned int flags,
|
2012-09-27 11:45:33 +00:00
|
|
|
const char *rawstr ATTRIBUTE_UNUSED,
|
2011-09-28 13:20:07 +00:00
|
|
|
const char *str,
|
|
|
|
void *data)
|
tests: silence qemuargv2xmltest noise
Before this patch, the testsuite was noisy:
TEST: qemuargv2xmltest
........................................ 40
................20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument '-unknown', adding to the qemu namespace
20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument 'parameter', adding to the qemu namespace
. 57 OK
PASS: qemuargv2xmltest
It's not a real failure (which is why the test was completing
successfully), so much as an intentional warning to the user that use
of the qemu namespace has the potential for undefined effects that
leaked through the default logging behavior. After this patch series,
all tests can access any logged data, and this particular test can
explicitly check for the presence or absence of the warning, such that
the test output becomes:
TEST: qemuargv2xmltest
........................................ 40
................. 57 OK
PASS: qemuargv2xmltest
* tests/testutils.h (virtTestLogContentAndReset): New prototype.
* tests/testutils.c (struct virtTestLogData): New struct.
(virtTestLogOutput, virtTestLogClose, virtTestLogContentAndReset):
New functions.
(virtTestMain): Always capture log data emitted during tests.
* tests/qemuargv2xmltest.c (testCompareXMLToArgvHelper, mymain):
Use flag to mark which tests expect noisy stderr.
(testCompareXMLToArgvFiles): Add parameter to test whether stderr
was appropriately silent.
2010-09-10 16:25:49 +00:00
|
|
|
{
|
|
|
|
struct virtTestLogData *log = data;
|
2012-09-20 18:24:00 +00:00
|
|
|
virCheckFlags(VIR_LOG_STACK_TRACE,);
|
2011-09-28 13:20:07 +00:00
|
|
|
virBufferAsprintf(&log->buf, "%s: %s", timestamp, str);
|
tests: silence qemuargv2xmltest noise
Before this patch, the testsuite was noisy:
TEST: qemuargv2xmltest
........................................ 40
................20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument '-unknown', adding to the qemu namespace
20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument 'parameter', adding to the qemu namespace
. 57 OK
PASS: qemuargv2xmltest
It's not a real failure (which is why the test was completing
successfully), so much as an intentional warning to the user that use
of the qemu namespace has the potential for undefined effects that
leaked through the default logging behavior. After this patch series,
all tests can access any logged data, and this particular test can
explicitly check for the presence or absence of the warning, such that
the test output becomes:
TEST: qemuargv2xmltest
........................................ 40
................. 57 OK
PASS: qemuargv2xmltest
* tests/testutils.h (virtTestLogContentAndReset): New prototype.
* tests/testutils.c (struct virtTestLogData): New struct.
(virtTestLogOutput, virtTestLogClose, virtTestLogContentAndReset):
New functions.
(virtTestMain): Always capture log data emitted during tests.
* tests/qemuargv2xmltest.c (testCompareXMLToArgvHelper, mymain):
Use flag to mark which tests expect noisy stderr.
(testCompareXMLToArgvFiles): Add parameter to test whether stderr
was appropriately silent.
2010-09-10 16:25:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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 *
|
|
|
|
virtTestLogContentAndReset(void)
|
|
|
|
{
|
|
|
|
char *ret;
|
|
|
|
|
|
|
|
if (virBufferError(&testLog.buf))
|
|
|
|
return NULL;
|
|
|
|
ret = virBufferContentAndReset(&testLog.buf);
|
|
|
|
return ret ? ret : strdup("");
|
|
|
|
}
|
|
|
|
|
2008-05-29 19:41:40 +00:00
|
|
|
#if TEST_OOM_TRACE
|
2008-05-29 15:21:45 +00:00
|
|
|
static void
|
2008-05-29 18:47:00 +00:00
|
|
|
virtTestErrorHook(int n, void *data ATTRIBUTE_UNUSED)
|
2008-05-29 15:21:45 +00:00
|
|
|
{
|
|
|
|
void *trace[30];
|
|
|
|
int ntrace = ARRAY_CARDINALITY(trace);
|
|
|
|
int i;
|
|
|
|
char **symbols = NULL;
|
|
|
|
|
|
|
|
ntrace = backtrace(trace, ntrace);
|
|
|
|
symbols = backtrace_symbols(trace, ntrace);
|
|
|
|
if (symbols) {
|
2008-05-29 18:47:00 +00:00
|
|
|
fprintf(stderr, "Failing allocation %d at:\n", n);
|
2008-05-29 15:21:45 +00:00
|
|
|
for (i = 0 ; i < ntrace ; i++) {
|
|
|
|
if (symbols[i])
|
|
|
|
fprintf(stderr, " TRACE: %s\n", symbols[i]);
|
|
|
|
}
|
2012-02-02 23:16:43 +00:00
|
|
|
VIR_FREE(symbols);
|
2008-05-29 15:21:45 +00:00
|
|
|
}
|
|
|
|
}
|
2008-05-29 19:41:40 +00:00
|
|
|
#endif
|
2008-05-29 15:21:45 +00:00
|
|
|
|
2009-11-30 19:01:31 +00:00
|
|
|
static unsigned int
|
|
|
|
virTestGetFlag(const char *name) {
|
|
|
|
char *flagStr;
|
|
|
|
unsigned int flag;
|
2009-10-16 15:37:36 +00:00
|
|
|
|
2009-11-30 19:01:31 +00:00
|
|
|
if ((flagStr = getenv(name)) == NULL)
|
2009-10-16 15:37:36 +00:00
|
|
|
return 0;
|
|
|
|
|
2009-11-30 19:01:31 +00:00
|
|
|
if (virStrToLong_ui(flagStr, NULL, 10, &flag) < 0)
|
2009-10-16 15:37:36 +00:00
|
|
|
return 0;
|
|
|
|
|
2009-11-30 19:01:31 +00:00
|
|
|
return flag;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int
|
2010-07-16 16:30:00 +00:00
|
|
|
virTestGetDebug(void) {
|
2009-11-30 19:01:31 +00:00
|
|
|
if (testDebug == -1)
|
|
|
|
testDebug = virTestGetFlag("VIR_TEST_DEBUG");
|
2009-10-16 15:37:36 +00:00
|
|
|
return testDebug;
|
|
|
|
}
|
2008-05-29 15:21:45 +00:00
|
|
|
|
2009-11-30 19:01:31 +00:00
|
|
|
unsigned int
|
2010-07-16 16:30:00 +00:00
|
|
|
virTestGetVerbose(void) {
|
2009-11-30 19:01:31 +00:00
|
|
|
if (testVerbose == -1)
|
|
|
|
testVerbose = virTestGetFlag("VIR_TEST_VERBOSE");
|
|
|
|
return testVerbose || virTestGetDebug();
|
|
|
|
}
|
|
|
|
|
2008-05-29 15:21:45 +00:00
|
|
|
int virtTestMain(int argc,
|
|
|
|
char **argv,
|
2011-04-29 16:21:20 +00:00
|
|
|
int (*func)(void))
|
2008-05-29 15:21:45 +00:00
|
|
|
{
|
|
|
|
int ret;
|
2011-04-29 17:14:23 +00:00
|
|
|
bool abs_srcdir_cleanup = false;
|
2009-01-28 21:53:48 +00:00
|
|
|
#if TEST_OOM
|
2008-05-29 15:21:45 +00:00
|
|
|
int approxAlloc = 0;
|
|
|
|
int n;
|
2008-07-09 10:27:17 +00:00
|
|
|
char *oomStr = NULL;
|
2008-05-29 15:21:45 +00:00
|
|
|
int oomCount;
|
2008-07-07 10:10:29 +00:00
|
|
|
int mp = 0;
|
|
|
|
pid_t *workers;
|
|
|
|
int worker = 0;
|
2008-07-09 10:27:17 +00:00
|
|
|
#endif
|
|
|
|
|
2011-04-29 16:21:20 +00:00
|
|
|
abs_srcdir = getenv("abs_srcdir");
|
2011-04-29 17:14:23 +00:00
|
|
|
if (!abs_srcdir) {
|
|
|
|
abs_srcdir = getcwd(NULL, 0);
|
|
|
|
abs_srcdir_cleanup = true;
|
|
|
|
}
|
2011-04-29 16:21:20 +00:00
|
|
|
if (!abs_srcdir)
|
|
|
|
exit(EXIT_AM_HARDFAIL);
|
|
|
|
|
2012-05-25 02:34:16 +00:00
|
|
|
progname = last_component(argv[0]);
|
|
|
|
if (STRPREFIX(progname, "lt-"))
|
|
|
|
progname += 3;
|
2011-04-29 16:21:20 +00:00
|
|
|
if (argc > 1) {
|
|
|
|
fprintf(stderr, "Usage: %s\n", argv[0]);
|
2012-05-08 17:46:45 +00:00
|
|
|
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);
|
2011-04-29 16:21:20 +00:00
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
fprintf(stderr, "TEST: %s\n", progname);
|
2009-11-30 19:01:31 +00:00
|
|
|
|
2009-01-28 21:53:48 +00:00
|
|
|
if (virThreadInitialize() < 0 ||
|
2012-08-03 23:15:00 +00:00
|
|
|
virErrorInitialize() < 0)
|
2009-01-28 21:53:48 +00:00
|
|
|
return 1;
|
|
|
|
|
2010-10-13 08:41:47 +00:00
|
|
|
virLogSetFromEnv();
|
2010-12-06 17:03:35 +00:00
|
|
|
if (!getenv("LIBVIRT_DEBUG") && !virLogGetNbOutputs()) {
|
|
|
|
if (virLogDefineOutput(virtTestLogOutput, virtTestLogClose, &testLog,
|
2012-09-27 13:04:21 +00:00
|
|
|
VIR_LOG_DEBUG, VIR_LOG_TO_STDERR, NULL, 0) < 0)
|
2010-12-06 17:03:35 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2008-05-29 15:21:45 +00:00
|
|
|
|
2008-07-09 10:27:17 +00:00
|
|
|
#if TEST_OOM
|
2008-05-29 15:21:45 +00:00
|
|
|
if ((oomStr = getenv("VIR_TEST_OOM")) != NULL) {
|
|
|
|
if (virStrToLong_i(oomStr, NULL, 10, &oomCount) < 0)
|
|
|
|
oomCount = 0;
|
|
|
|
|
|
|
|
if (oomCount < 0)
|
|
|
|
oomCount = 0;
|
|
|
|
if (oomCount)
|
|
|
|
testOOM = 1;
|
|
|
|
}
|
|
|
|
|
2008-07-07 10:10:29 +00:00
|
|
|
if (getenv("VIR_TEST_MP") != NULL) {
|
|
|
|
mp = sysconf(_SC_NPROCESSORS_ONLN);
|
|
|
|
fprintf(stderr, "Using %d worker processes\n", mp);
|
2009-01-28 21:53:48 +00:00
|
|
|
if (VIR_ALLOC_N(workers, mp) < 0) {
|
|
|
|
ret = EXIT_FAILURE;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2008-07-07 10:10:29 +00:00
|
|
|
}
|
|
|
|
|
2009-09-02 14:09:04 +00:00
|
|
|
/* Run once to prime any static allocations & ensure it passes */
|
2011-04-29 16:21:20 +00:00
|
|
|
ret = (func)();
|
2008-05-29 15:21:45 +00:00
|
|
|
if (ret != EXIT_SUCCESS)
|
2009-01-28 21:53:48 +00:00
|
|
|
goto cleanup;
|
2008-05-29 15:21:45 +00:00
|
|
|
|
2010-03-09 18:22:22 +00:00
|
|
|
# if TEST_OOM_TRACE
|
2009-11-30 19:01:31 +00:00
|
|
|
if (virTestGetDebug())
|
2008-05-29 15:21:45 +00:00
|
|
|
virAllocTestHook(virtTestErrorHook, NULL);
|
2010-03-09 18:22:22 +00:00
|
|
|
# endif
|
2008-05-29 15:21:45 +00:00
|
|
|
|
|
|
|
if (testOOM) {
|
|
|
|
/* Makes next test runs quiet... */
|
|
|
|
testOOM++;
|
|
|
|
virSetErrorFunc(NULL, virtTestErrorFuncQuiet);
|
|
|
|
|
2009-09-02 14:09:04 +00:00
|
|
|
virAllocTestInit();
|
|
|
|
|
|
|
|
/* Run again to count allocs, and ensure it passes :-) */
|
2011-04-29 16:21:20 +00:00
|
|
|
ret = (func)();
|
2009-09-02 14:09:04 +00:00
|
|
|
if (ret != EXIT_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
|
2008-05-29 15:21:45 +00:00
|
|
|
approxAlloc = virAllocTestCount();
|
|
|
|
testCounter++;
|
2009-11-30 19:01:31 +00:00
|
|
|
if (virTestGetDebug())
|
2008-05-29 15:21:45 +00:00
|
|
|
fprintf(stderr, "%d) OOM...\n", testCounter);
|
|
|
|
else
|
|
|
|
fprintf(stderr, "%d) OOM of %d allocs ", testCounter, approxAlloc);
|
|
|
|
|
2008-07-07 10:10:29 +00:00
|
|
|
if (mp) {
|
|
|
|
int i;
|
|
|
|
for (i = 0 ; i < mp ; i++) {
|
|
|
|
workers[i] = fork();
|
|
|
|
if (workers[i] == 0) {
|
|
|
|
worker = i + 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-05-29 15:21:45 +00:00
|
|
|
/* Run once for each alloc, failing a different one
|
|
|
|
and validating that the test case failed */
|
2008-07-07 10:10:29 +00:00
|
|
|
for (n = 0; n < approxAlloc && (!mp || worker) ; n++) {
|
2009-04-01 10:31:01 +00:00
|
|
|
if (mp &&
|
|
|
|
(n % mp) != (worker - 1))
|
2008-07-07 10:10:29 +00:00
|
|
|
continue;
|
2009-11-30 19:01:31 +00:00
|
|
|
if (!virTestGetDebug()) {
|
2008-07-07 10:10:29 +00:00
|
|
|
if (mp)
|
|
|
|
fprintf(stderr, "%d", worker);
|
|
|
|
else
|
|
|
|
fprintf(stderr, ".");
|
2008-05-29 15:21:45 +00:00
|
|
|
fflush(stderr);
|
|
|
|
}
|
|
|
|
virAllocTestOOM(n+1, oomCount);
|
|
|
|
|
2011-04-29 16:21:20 +00:00
|
|
|
if (((func)()) != EXIT_FAILURE) {
|
2008-05-29 15:21:45 +00:00
|
|
|
ret = EXIT_FAILURE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-07 10:10:29 +00:00
|
|
|
if (mp) {
|
|
|
|
if (worker) {
|
|
|
|
_exit(ret);
|
|
|
|
} else {
|
|
|
|
int i, status;
|
|
|
|
for (i = 0 ; i < mp ; i++) {
|
2012-09-24 16:59:31 +00:00
|
|
|
if (virProcessWait(workers[i], NULL) < 0)
|
2008-07-07 10:10:29 +00:00
|
|
|
ret = EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
VIR_FREE(workers);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-30 19:01:31 +00:00
|
|
|
if (virTestGetDebug())
|
2008-05-29 15:21:45 +00:00
|
|
|
fprintf(stderr, " ... OOM of %d allocs", approxAlloc);
|
|
|
|
|
|
|
|
if (ret == EXIT_SUCCESS)
|
|
|
|
fprintf(stderr, " OK\n");
|
|
|
|
else
|
|
|
|
fprintf(stderr, " FAILED\n");
|
|
|
|
}
|
2009-01-28 21:53:48 +00:00
|
|
|
cleanup:
|
2008-05-29 15:21:45 +00:00
|
|
|
#else
|
2011-04-29 16:21:20 +00:00
|
|
|
ret = (func)();
|
2008-05-29 15:21:45 +00:00
|
|
|
#endif
|
2009-01-28 21:53:48 +00:00
|
|
|
|
2011-04-29 17:14:23 +00:00
|
|
|
if (abs_srcdir_cleanup)
|
|
|
|
VIR_FREE(abs_srcdir);
|
2009-01-28 21:53:48 +00:00
|
|
|
virResetLastError();
|
2011-07-09 09:50:38 +00:00
|
|
|
if (!virTestGetVerbose() && ret != EXIT_AM_SKIP) {
|
2011-07-11 15:19:11 +00:00
|
|
|
if (testCounter == 0 || testCounter % 40)
|
|
|
|
fprintf(stderr, "%*s", 40 - (testCounter % 40), "");
|
2009-11-30 19:01:31 +00:00
|
|
|
fprintf(stderr, " %-3d %s\n", testCounter, ret == 0 ? "OK" : "FAIL");
|
|
|
|
}
|
2009-01-28 21:53:48 +00:00
|
|
|
return ret;
|
2008-05-29 15:21:45 +00:00
|
|
|
}
|
2009-05-21 14:22:51 +00:00
|
|
|
|
|
|
|
|
2009-05-29 14:29:22 +00:00
|
|
|
#ifdef HAVE_REGEX_H
|
2009-05-21 14:22:51 +00:00
|
|
|
int virtTestClearLineRegex(const char *pattern,
|
|
|
|
char *str)
|
|
|
|
{
|
|
|
|
regex_t reg;
|
|
|
|
char *lineStart = str;
|
|
|
|
char *lineEnd = strchr(str, '\n');
|
|
|
|
|
|
|
|
if (regcomp(®, pattern, REG_EXTENDED | REG_NOSUB) != 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
while (lineStart) {
|
|
|
|
int ret;
|
|
|
|
if (lineEnd)
|
|
|
|
*lineEnd = '\0';
|
|
|
|
|
|
|
|
|
|
|
|
ret = regexec(®, lineStart, 0, NULL, 0);
|
|
|
|
//fprintf(stderr, "Match %d '%s' '%s'\n", ret, lineStart, pattern);
|
|
|
|
if (ret == 0) {
|
|
|
|
if (lineEnd) {
|
|
|
|
memmove(lineStart, lineEnd + 1, strlen(lineEnd+1) + 1);
|
|
|
|
/* Don't update lineStart - just iterate again on this
|
|
|
|
location */
|
|
|
|
lineEnd = strchr(lineStart, '\n');
|
|
|
|
} else {
|
|
|
|
*lineStart = '\0';
|
|
|
|
lineStart = NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (lineEnd) {
|
|
|
|
*lineEnd = '\n';
|
|
|
|
lineStart = lineEnd + 1;
|
|
|
|
lineEnd = strchr(lineStart, '\n');
|
|
|
|
} else {
|
|
|
|
lineStart = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
regfree(®);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2009-05-29 14:29:22 +00:00
|
|
|
#else
|
|
|
|
int virtTestClearLineRegex(const char *pattern ATTRIBUTE_UNUSED,
|
|
|
|
char *str ATTRIBUTE_UNUSED)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|