NuKVM/libvirt
3
0
Fork 0
mirror of https://github.com/libvirt/libvirt.git synced 2025-02-25 18:55:26 -06:00
Code Issues Packages Projects Releases Wiki Activity

tests: Add VIR_TEST_DEBUG and VIR_TEST_VERBOSE

Browse Source 
To remove a bunch of TestGetDebug()/TestGetVerbose() checks
This commit is contained in:
Cole Robinson 2015-04-23 13:38:00 -04:00
parent 1268820a63
commit 01f2f6c6c9
20 changed files with 188 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
tests/cputest.c
View File

@ -235,13 +235,11 @@ cpuTestCompare(const void *arg)
virResetLastError(); virResetLastError();
if (data->result != result) { if (data->result != result) {
if (virTestGetVerbose()) { VIR_TEST_VERBOSE("\nExpected result %s, got %s\n",
fprintf(stderr, "\nExpected result %s, got %s\n",
cpuTestCompResStr(data->result), cpuTestCompResStr(data->result),
cpuTestCompResStr(result)); cpuTestCompResStr(result));
/* Pad to line up with test name ... in virTestRun */ /* Pad to line up with test name ... in virTestRun */
fprintf(stderr, "%74s", "... "); VIR_TEST_VERBOSE("%74s", "... ");
}
goto cleanup; goto cleanup;
} }
@ -337,8 +335,8 @@ cpuTestBaseline(const void *arg)
virResetLastError(); virResetLastError();
if (!baseline) { if (!baseline) {
ret = 0; ret = 0;
} else if (virTestGetVerbose()) { } else {
fprintf(stderr, "\n%-70s... ", VIR_TEST_VERBOSE("\n%-70s... ",
"cpuBaseline was expected to fail but it succeeded"); "cpuBaseline was expected to fail but it succeeded");
} }
goto cleanup; goto cleanup;
@ -364,11 +362,9 @@ cpuTestBaseline(const void *arg)
cmp = cpuCompare(cpus[i], baseline, false); cmp = cpuCompare(cpus[i], baseline, false);
if (cmp != VIR_CPU_COMPARE_SUPERSET && if (cmp != VIR_CPU_COMPARE_SUPERSET &&
cmp != VIR_CPU_COMPARE_IDENTICAL) { cmp != VIR_CPU_COMPARE_IDENTICAL) {
if (virTestGetVerbose()) { VIR_TEST_VERBOSE("\nbaseline CPU is incompatible with CPU %zu\n",
fprintf(stderr, i);
"\nbaseline CPU is incompatible with CPU %zu\n", i); VIR_TEST_VERBOSE("%74s", "... ");
fprintf(stderr, "%74s", "... ");
}
ret = -1; ret = -1;
goto cleanup; goto cleanup;
} }
@ -438,13 +434,11 @@ cpuTestHasFeature(const void *arg)
virResetLastError(); virResetLastError();
if (data->result != result) { if (data->result != result) {
if (virTestGetVerbose()) { VIR_TEST_VERBOSE("\nExpected result %s, got %s\n",
fprintf(stderr, "\nExpected result %s, got %s\n", cpuTestBoolWithErrorStr(data->result),
cpuTestBoolWithErrorStr(data->result), cpuTestBoolWithErrorStr(result));
cpuTestBoolWithErrorStr(result)); /* Pad to line up with test name ... in virTestRun */
/* Pad to line up with test name ... in virTestRun */ VIR_TEST_VERBOSE("%74s", "... ");
fprintf(stderr, "%74s", "... ");
}
goto cleanup; goto cleanup;
} }
@ -483,7 +477,7 @@ cpuTestRun(const char *name, const struct data *data)
char *log; char *log;
if ((log = virtTestLogContentAndReset()) && if ((log = virtTestLogContentAndReset()) &&
strlen(log) > 0) strlen(log) > 0)
fprintf(stderr, "\n%s\n", log); VIR_TEST_DEBUG("\n%s\n", log);
VIR_FREE(log); VIR_FREE(log);
} }

48
tests/jsontest.c
View File

@ -27,23 +27,19 @@ testJSONFromString(const void *data)
if (info->pass) { if (info->pass) {
if (!json) { if (!json) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("Fail to parse %s\n", info->doc);
fprintf(stderr, "Fail to parse %s\n", info->doc);
ret = -1; ret = -1;
goto cleanup; goto cleanup;
} else { } else {
if (virTestGetDebug()) VIR_TEST_DEBUG("Parsed %s\n", info->doc);
fprintf(stderr, "Parsed %s\n", info->doc);
} }
} else { } else {
if (json) { if (json) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("Should not have parsed %s\n", info->doc);
fprintf(stderr, "Should not have parsed %s\n", info->doc);
ret = -1; ret = -1;
goto cleanup; goto cleanup;
} else { } else {
if (virTestGetDebug()) VIR_TEST_DEBUG("Fail to parse %s\n", info->doc);
fprintf(stderr, "Fail to parse %s\n", info->doc);
} }
} }
@ -66,8 +62,7 @@ testJSONAddRemove(const void *data)
json = virJSONValueFromString(info->doc); json = virJSONValueFromString(info->doc);
if (!json) { if (!json) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("Fail to parse %s\n", info->doc);
fprintf(stderr, "Fail to parse %s\n", info->doc);
ret = -1; ret = -1;
goto cleanup; goto cleanup;
} }
@ -75,49 +70,42 @@ testJSONAddRemove(const void *data)
switch (virJSONValueObjectRemoveKey(json, "name", &name)) { switch (virJSONValueObjectRemoveKey(json, "name", &name)) {
case 1: case 1:
if (!info->pass) { if (!info->pass) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("should not remove from non-object %s\n",
fprintf(stderr, "should not remove from non-object %s\n", info->doc);
info->doc);
goto cleanup; goto cleanup;
} }
break; break;
case -1: case -1:
if (!info->pass) if (!info->pass)
ret = 0; ret = 0;
else if (virTestGetVerbose()) else
fprintf(stderr, "Fail to recognize non-object %s\n", info->doc); VIR_TEST_VERBOSE("Fail to recognize non-object %s\n", info->doc);
goto cleanup; goto cleanup;
default: default:
if (virTestGetVerbose()) VIR_TEST_VERBOSE("unexpected result when removing from %s\n",
fprintf(stderr, "unexpected result when removing from %s\n", info->doc);
info->doc);
goto cleanup; goto cleanup;
} }
if (STRNEQ_NULLABLE(virJSONValueGetString(name), "sample")) { if (STRNEQ_NULLABLE(virJSONValueGetString(name), "sample")) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("unexpected value after removing name: %s\n",
fprintf(stderr, "unexpected value after removing name: %s\n", NULLSTR(virJSONValueGetString(name)));
NULLSTR(virJSONValueGetString(name)));
goto cleanup; goto cleanup;
} }
if (virJSONValueObjectRemoveKey(json, "name", NULL)) { if (virJSONValueObjectRemoveKey(json, "name", NULL)) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("%s",
fprintf(stderr, "%s", "unexpected success when removing missing key\n");
"unexpected success when removing missing key\n");
goto cleanup; goto cleanup;
} }
if (virJSONValueObjectAppendString(json, "newname", "foo") < 0) { if (virJSONValueObjectAppendString(json, "newname", "foo") < 0) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("%s", "unexpected failure adding new key\n");
fprintf(stderr, "%s", "unexpected failure adding new key\n");
goto cleanup; goto cleanup;
} }
if (!(result = virJSONValueToString(json, false))) { if (!(result = virJSONValueToString(json, false))) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("%s", "failed to stringize result\n");
fprintf(stderr, "%s", "failed to stringize result\n");
goto cleanup; goto cleanup;
} }
if (STRNEQ(info->expect, result)) { if (STRNEQ(info->expect, result)) {
if (virTestGetVerbose()) virtTestDifference(stderr, info->expect, result);
virtTestDifference(stderr, info->expect, result);
goto cleanup; goto cleanup;
} }
ret = 0; ret = 0;

2
tests/nodeinfotest.c
View File

@ -50,7 +50,7 @@ linuxTestCompareFiles(const char *cpuinfofile,
if (virTestGetDebug()) { if (virTestGetDebug()) {
virErrorPtr error = virSaveLastError(); virErrorPtr error = virSaveLastError();
if (error && error->code != VIR_ERR_OK) if (error && error->code != VIR_ERR_OK)
fprintf(stderr, "\n%s\n", error->message); VIR_TEST_DEBUG("\n%s\n", error->message);
virFreeError(error); virFreeError(error);
} }
VIR_FORCE_FCLOSE(cpuinfo); VIR_FORCE_FCLOSE(cpuinfo);

15
tests/qemuargv2xmltest.c
View File

@ -64,22 +64,17 @@ static int testCompareXMLToArgvFiles(const char *xml,
goto fail; goto fail;
if (flags & FLAG_EXPECT_WARNING) { if (flags & FLAG_EXPECT_WARNING) {
if (*log) { if (*log) {
if (virTestGetDebug() > 1) VIR_TEST_DEBUG("Got expected warning from "
fprintf(stderr,
"Got expected warning from "
"qemuParseCommandLineString:\n%s", "qemuParseCommandLineString:\n%s",
log); log);
} else { } else {
if (virTestGetDebug()) VIR_TEST_DEBUG("qemuParseCommandLineString "
fprintf(stderr, "qemuParseCommandLineString " "should have logged a warning\n");
"should have logged a warning\n");
goto fail; goto fail;
} }
} else { /* didn't expect a warning */ } else { /* didn't expect a warning */
if (*log) { if (*log) {
if (virTestGetDebug()) VIR_TEST_DEBUG("Got unexpected warning from "
fprintf(stderr,
"Got unexpected warning from "
"qemuParseCommandLineString:\n%s", "qemuParseCommandLineString:\n%s",
log); log);
goto fail; goto fail;
@ -88,7 +83,7 @@ static int testCompareXMLToArgvFiles(const char *xml,
} }
if (!virDomainDefCheckABIStability(vmdef, vmdef)) { if (!virDomainDefCheckABIStability(vmdef, vmdef)) {
fprintf(stderr, "ABI stability check failed on %s", xml); VIR_TEST_DEBUG("ABI stability check failed on %s", xml);
goto fail; goto fail;
} }

6
tests/qemuhelptest.c
View File

@ -90,10 +90,8 @@ static int testHelpStrParsing(const void *data)
goto cleanup; goto cleanup;
if (STRNEQ(got, expected)) { if (STRNEQ(got, expected)) {
if (virTestGetVerbose() || virTestGetDebug()) VIR_TEST_DEBUG("%s: computed flags do not match: got %s, expected %s\n",
fprintf(stderr, info->name, got, expected);
"%s: computed flags do not match: got %s, expected %s\n",
info->name, got, expected);
if (virTestGetDebug()) if (virTestGetDebug())
printMismatchedFlags(flags, info->flags); printMismatchedFlags(flags, info->flags);

19
tests/qemuhotplugtest.c
View File

@ -115,9 +115,8 @@ testQemuHotplugAttach(virDomainObjPtr vm,
ret = qemuDomainAttachChrDevice(&driver, vm, dev->data.chr); ret = qemuDomainAttachChrDevice(&driver, vm, dev->data.chr);
break; break;
default: default:
if (virTestGetVerbose()) VIR_TEST_VERBOSE("device type '%s' cannot be attached\n",
fprintf(stderr, "device type '%s' cannot be attached\n", virDomainDeviceTypeToString(dev->type));
virDomainDeviceTypeToString(dev->type));
break; break;
} }
@ -138,9 +137,8 @@ testQemuHotplugDetach(virDomainObjPtr vm,
ret = qemuDomainDetachChrDevice(&driver, vm, dev->data.chr); ret = qemuDomainDetachChrDevice(&driver, vm, dev->data.chr);
break; break;
default: default:
if (virTestGetVerbose()) VIR_TEST_VERBOSE("device type '%s' cannot be detached\n",
fprintf(stderr, "device type '%s' cannot be detached\n", virDomainDeviceTypeToString(dev->type));
virDomainDeviceTypeToString(dev->type));
break; break;
} }
@ -163,9 +161,8 @@ testQemuHotplugUpdate(virDomainObjPtr vm,
ret = qemuDomainChangeGraphics(&driver, vm, dev->data.graphics); ret = qemuDomainChangeGraphics(&driver, vm, dev->data.graphics);
break; break;
default: default:
if (virTestGetVerbose()) VIR_TEST_VERBOSE("device type '%s' cannot be updated\n",
fprintf(stderr, "device type '%s' cannot be updated\n", virDomainDeviceTypeToString(dev->type));
virDomainDeviceTypeToString(dev->type));
break; break;
} }
@ -187,8 +184,8 @@ testQemuHotplugCheckResult(virDomainObjPtr vm,
vm->def->id = QEMU_HOTPLUG_TEST_DOMAIN_ID; vm->def->id = QEMU_HOTPLUG_TEST_DOMAIN_ID;
if (STREQ(expected, actual)) { if (STREQ(expected, actual)) {
if (fail && virTestGetVerbose()) if (fail)
fprintf(stderr, "domain XML should not match the expected result\n"); VIR_TEST_VERBOSE("domain XML should not match the expected result\n");
ret = 0; ret = 0;
} else { } else {
if (!fail) if (!fail)

24
tests/qemumonitortest.c
View File

@ -43,13 +43,11 @@ static int testEscapeArg(const void *data ATTRIBUTE_UNUSED)
for (i = 0; i < ARRAY_CARDINALITY(escapeStrings); ++i) { for (i = 0; i < ARRAY_CARDINALITY(escapeStrings); ++i) {
escaped = qemuMonitorEscapeArg(escapeStrings[i].unescaped); escaped = qemuMonitorEscapeArg(escapeStrings[i].unescaped);
if (!escaped) { if (!escaped) {
if (virTestGetDebug() > 0) { VIR_TEST_DEBUG("\nUnescaped string [%s]\n",
fprintf(stderr, "\nUnescaped string [%s]\n", escapeStrings[i].unescaped);
escapeStrings[i].unescaped); VIR_TEST_DEBUG("Expect result [%s]\n",
fprintf(stderr, "Expect result [%s]\n", escapeStrings[i].escaped);
escapeStrings[i].escaped); VIR_TEST_DEBUG("Actual result [(null)]\n");
fprintf(stderr, "Actual result [(null)]\n");
}
return -1; return -1;
} }
if (STRNEQ(escapeStrings[i].escaped, escaped)) { if (STRNEQ(escapeStrings[i].escaped, escaped)) {
@ -70,13 +68,11 @@ static int testUnescapeArg(const void *data ATTRIBUTE_UNUSED)
for (i = 0; i < ARRAY_CARDINALITY(escapeStrings); ++i) { for (i = 0; i < ARRAY_CARDINALITY(escapeStrings); ++i) {
unescaped = qemuMonitorUnescapeArg(escapeStrings[i].escaped); unescaped = qemuMonitorUnescapeArg(escapeStrings[i].escaped);
if (!unescaped) { if (!unescaped) {
if (virTestGetDebug() > 0) { VIR_TEST_DEBUG("\nEscaped string [%s]\n",
fprintf(stderr, "\nEscaped string [%s]\n", escapeStrings[i].escaped);
escapeStrings[i].escaped); VIR_TEST_DEBUG("Expect result [%s]\n",
fprintf(stderr, "Expect result [%s]\n", escapeStrings[i].unescaped);
escapeStrings[i].unescaped); VIR_TEST_DEBUG("Actual result [(null)]\n");
fprintf(stderr, "Actual result [(null)]\n");
}
return -1; return -1;
} }
if (STRNEQ(escapeStrings[i].unescaped, unescaped)) { if (STRNEQ(escapeStrings[i].unescaped, unescaped)) {

14
tests/qemuxml2argvtest.c
View File

@ -282,7 +282,7 @@ static int testCompareXMLToArgvFiles(const char *xml,
} }
if (!virDomainDefCheckABIStability(vmdef, vmdef)) { if (!virDomainDefCheckABIStability(vmdef, vmdef)) {
fprintf(stderr, "ABI stability check failed on %s", xml); VIR_TEST_DEBUG("ABI stability check failed on %s", xml);
goto out; goto out;
} }
@ -353,22 +353,20 @@ static int testCompareXMLToArgvFiles(const char *xml,
if (!virtTestOOMActive() && if (!virtTestOOMActive() &&
(flags & FLAG_EXPECT_FAILURE)) { (flags & FLAG_EXPECT_FAILURE)) {
ret = 0; ret = 0;
if (virTestGetDebug() > 1) VIR_TEST_DEBUG("Got expected error: %s\n",
fprintf(stderr, "Got expected error: %s\n", virGetLastErrorMessage());
virGetLastErrorMessage());
virResetLastError(); virResetLastError();
} }
goto out; goto out;
} else if (flags & FLAG_EXPECT_FAILURE) { } else if (flags & FLAG_EXPECT_FAILURE) {
if (virTestGetDebug()) VIR_TEST_DEBUG("qemuBuildCommandLine should have failed\n");
fprintf(stderr, "qemuBuildCommandLine should have failed\n");
goto out; goto out;
} }
if (!virtTestOOMActive() && if (!virtTestOOMActive() &&
(!!virGetLastError() != !!(flags & FLAG_EXPECT_ERROR))) { (!!virGetLastError() != !!(flags & FLAG_EXPECT_ERROR))) {
if (virTestGetDebug() && (log = virtTestLogContentAndReset())) if ((log = virtTestLogContentAndReset()))
fprintf(stderr, "\n%s", log); VIR_TEST_DEBUG("\n%s", log);
goto out; goto out;
} }

6
tests/qemuxmlnstest.c
View File

@ -59,7 +59,7 @@ static int testCompareXMLToArgvFiles(const char *xml,
goto fail; goto fail;
if (!virDomainDefCheckABIStability(vmdef, vmdef)) { if (!virDomainDefCheckABIStability(vmdef, vmdef)) {
fprintf(stderr, "ABI stability check failed on %s", xml); VIR_TEST_DEBUG("ABI stability check failed on %s", xml);
goto fail; goto fail;
} }
@ -121,8 +121,8 @@ static int testCompareXMLToArgvFiles(const char *xml,
if (!virtTestOOMActive()) { if (!virtTestOOMActive()) {
if (!!virGetLastError() != expectError) { if (!!virGetLastError() != expectError) {
if (virTestGetDebug() && (log = virtTestLogContentAndReset())) if ((log = virtTestLogContentAndReset()))
fprintf(stderr, "\n%s", log); VIR_TEST_DEBUG("\n%s", log);
goto fail; goto fail;
} }

6
tests/securityselinuxlabeltest.c
View File

@ -336,9 +336,9 @@ testSELinuxLabeling(const void *opaque)
VIR_FREE(files[i].context); VIR_FREE(files[i].context);
} }
VIR_FREE(files); VIR_FREE(files);
if (ret < 0 && virTestGetVerbose()) { if (ret < 0) {
virErrorPtr err = virGetLastError(); virErrorPtr err = virGetLastError();
fprintf(stderr, "%s\n", err ? err->message : "<unknown>"); VIR_TEST_VERBOSE("%s\n", err ? err->message : "<unknown>");
} }
return ret; return ret;
} }
@ -358,7 +358,7 @@ mymain(void)
if (!(mgr = virSecurityManagerNew("selinux", "QEMU", false, true, false))) { if (!(mgr = virSecurityManagerNew("selinux", "QEMU", false, true, false))) {
virErrorPtr err = virGetLastError(); virErrorPtr err = virGetLastError();
fprintf(stderr, "Unable to initialize security driver: %s\n", VIR_TEST_VERBOSE("Unable to initialize security driver: %s\n",
err->message); err->message);
return EXIT_FAILURE; return EXIT_FAILURE;
} }

3
tests/statstest.c
View File

@ -18,8 +18,7 @@ static int testDevice(const char *path, int expect)
if (actual == expect) { if (actual == expect) {
return 0; return 0;
} else { } else {
if (virTestGetDebug()) VIR_TEST_DEBUG("Expect %-6d Actual %-6d\n", expect, actual);
fprintf(stderr, "Expect %-6d Actual %-6d\n", expect, actual);
return -1; return -1;
} }
} }

2
tests/testutils.c
View File

@ -960,7 +960,7 @@ virCapsPtr virTestGenericCapsInit(void)
if (!caps_str) if (!caps_str)
goto error; goto error;
fprintf(stderr, "Generic driver capabilities:\n%s", caps_str); VIR_TEST_DEBUG("Generic driver capabilities:\n%s", caps_str);
VIR_FREE(caps_str); VIR_FREE(caps_str);
} }

12
tests/testutils.h
View File

@ -78,6 +78,18 @@ unsigned int virTestGetDebug(void);
unsigned int virTestGetVerbose(void); unsigned int virTestGetVerbose(void);
unsigned int virTestGetExpensive(void); unsigned int virTestGetExpensive(void);
# define VIR_TEST_DEBUG(...) \
do { \
if (virTestGetDebug()) \
fprintf(stderr, __VA_ARGS__); \
} while (0)
# define VIR_TEST_VERBOSE(...) \
do { \
if (virTestGetVerbose()) \
fprintf(stderr, __VA_ARGS__); \
} while (0)
char *virtTestLogContentAndReset(void); char *virtTestLogContentAndReset(void);
void virtTestQuiesceLibvirtErrors(bool always); void virtTestQuiesceLibvirtErrors(bool always);

2
tests/testutilslxc.c
View File

@ -44,7 +44,7 @@ virCapsPtr testLXCCapsInit(void)
if (!caps_str) if (!caps_str)
goto error; goto error;
fprintf(stderr, "LXC driver capabilities:\n%s", caps_str); VIR_TEST_DEBUG("LXC driver capabilities:\n%s", caps_str);
VIR_FREE(caps_str); VIR_FREE(caps_str);
} }

2
tests/testutilsqemu.c
View File

@ -427,7 +427,7 @@ virCapsPtr testQemuCapsInit(void)
if (!caps_str) if (!caps_str)
goto cleanup; goto cleanup;
fprintf(stderr, "QEMU driver capabilities:\n%s", caps_str); VIR_TEST_DEBUG("QEMU driver capabilities:\n%s", caps_str);
VIR_FREE(caps_str); VIR_FREE(caps_str);
} }

30
tests/utiltest.c
View File

@ -63,10 +63,8 @@ testDiskNameToIndex(const void *data ATTRIBUTE_UNUSED)
idx = virDiskNameToIndex(diskName); idx = virDiskNameToIndex(diskName);
if (idx < 0 || idx != i) { if (idx < 0 || idx != i) {
if (virTestGetDebug() > 0) { VIR_TEST_DEBUG("\nExpect [%zu]\n", i);
fprintf(stderr, "\nExpect [%zu]\n", i); VIR_TEST_DEBUG("Actual [%d]\n", idx);
fprintf(stderr, "Actual [%d]\n", idx);
}
VIR_FREE(diskName); VIR_FREE(diskName);
@ -115,11 +113,9 @@ testParseVersionString(const void *data ATTRIBUTE_UNUSED)
versions[i].allowMissing); versions[i].allowMissing);
if (result != versions[i].result) { if (result != versions[i].result) {
if (virTestGetDebug() > 0) { VIR_TEST_DEBUG("\nVersion string [%s]\n", versions[i].string);
fprintf(stderr, "\nVersion string [%s]\n", versions[i].string); VIR_TEST_DEBUG("Expect result [%d]\n", versions[i].result);
fprintf(stderr, "Expect result [%d]\n", versions[i].result); VIR_TEST_DEBUG("Actual result [%d]\n", result);
fprintf(stderr, "Actual result [%d]\n", result);
}
return -1; return -1;
} }
@ -128,11 +124,9 @@ testParseVersionString(const void *data ATTRIBUTE_UNUSED)
continue; continue;
if (version != versions[i].version) { if (version != versions[i].version) {
if (virTestGetDebug() > 0) { VIR_TEST_DEBUG("\nVersion string [%s]\n", versions[i].string);
fprintf(stderr, "\nVersion string [%s]\n", versions[i].string); VIR_TEST_DEBUG("Expect version [%lu]\n", versions[i].version);
fprintf(stderr, "Expect version [%lu]\n", versions[i].version); VIR_TEST_DEBUG("Actual version [%lu]\n", version);
fprintf(stderr, "Actual version [%lu]\n", version);
}
return -1; return -1;
} }
@ -166,11 +160,9 @@ testRoundValueToPowerOfTwo(const void *data ATTRIBUTE_UNUSED)
for (i = 0; i < ARRAY_CARDINALITY(roundData); i++) { for (i = 0; i < ARRAY_CARDINALITY(roundData); i++) {
result = VIR_ROUND_UP_POWER_OF_TWO(roundData[i].input); result = VIR_ROUND_UP_POWER_OF_TWO(roundData[i].input);
if (roundData[i].output != result) { if (roundData[i].output != result) {
if (virTestGetDebug() > 0) { VIR_TEST_DEBUG("\nInput number [%u]\n", roundData[i].input);
fprintf(stderr, "\nInput number [%u]\n", roundData[i].input); VIR_TEST_DEBUG("Expected number [%u]\n", roundData[i].output);
fprintf(stderr, "Expected number [%u]\n", roundData[i].output); VIR_TEST_DEBUG("Actual number [%u]\n", result);
fprintf(stderr, "Actual number [%u]\n", result);
}
return -1; return -1;
} }

60
tests/virbuftest.c
View File

@ -12,12 +12,6 @@
#define VIR_FROM_THIS VIR_FROM_NONE #define VIR_FROM_THIS VIR_FROM_NONE
#define TEST_ERROR(...) \
do { \
if (virTestGetDebug()) \
fprintf(stderr, __VA_ARGS__); \
} while (0)
struct testInfo { struct testInfo {
int doEscape; int doEscape;
}; };
@ -50,7 +44,7 @@ static int testBufInfiniteLoop(const void *data)
out: out:
bufret = virBufferContentAndReset(buf); bufret = virBufferContentAndReset(buf);
if (!bufret) { if (!bufret) {
TEST_ERROR("Buffer had error set"); VIR_TEST_DEBUG("Buffer had error set");
ret = -1; ret = -1;
} }
@ -70,54 +64,54 @@ static int testBufAutoIndent(const void *data ATTRIBUTE_UNUSED)
if (virBufferGetIndent(buf, false) != 0 || if (virBufferGetIndent(buf, false) != 0 ||
virBufferGetIndent(buf, true) != 0) { virBufferGetIndent(buf, true) != 0) {
TEST_ERROR("Wrong indentation"); VIR_TEST_DEBUG("Wrong indentation");
ret = -1; ret = -1;
} }
virBufferAdjustIndent(buf, 3); virBufferAdjustIndent(buf, 3);
if (STRNEQ(virBufferCurrentContent(buf), "")) { if (STRNEQ(virBufferCurrentContent(buf), "")) {
TEST_ERROR("Wrong content"); VIR_TEST_DEBUG("Wrong content");
ret = -1; ret = -1;
} }
if (virBufferGetIndent(buf, false) != 3 || if (virBufferGetIndent(buf, false) != 3 ||
virBufferGetIndent(buf, true) != 3 || virBufferGetIndent(buf, true) != 3 ||
virBufferError(buf)) { virBufferError(buf)) {
TEST_ERROR("Wrong indentation"); VIR_TEST_DEBUG("Wrong indentation");
ret = -1; ret = -1;
} }
virBufferAdjustIndent(buf, -2); virBufferAdjustIndent(buf, -2);
if (virBufferGetIndent(buf, false) != 1 || if (virBufferGetIndent(buf, false) != 1 ||
virBufferGetIndent(buf, true) != 1 || virBufferGetIndent(buf, true) != 1 ||
virBufferError(buf)) { virBufferError(buf)) {
TEST_ERROR("Wrong indentation"); VIR_TEST_DEBUG("Wrong indentation");
ret = -1; ret = -1;
} }
virBufferAdjustIndent(buf, -3); virBufferAdjustIndent(buf, -3);
if (virBufferGetIndent(buf, false) != -1 || if (virBufferGetIndent(buf, false) != -1 ||
virBufferGetIndent(buf, true) != -1 || virBufferGetIndent(buf, true) != -1 ||
virBufferError(buf) != -1) { virBufferError(buf) != -1) {
TEST_ERROR("Usage error not flagged"); VIR_TEST_DEBUG("Usage error not flagged");
ret = -1; ret = -1;
} }
virBufferFreeAndReset(buf); virBufferFreeAndReset(buf);
if (virBufferGetIndent(buf, false) != 0 || if (virBufferGetIndent(buf, false) != 0 ||
virBufferGetIndent(buf, true) != 0 || virBufferGetIndent(buf, true) != 0 ||
virBufferError(buf)) { virBufferError(buf)) {
TEST_ERROR("Reset didn't clear indentation"); VIR_TEST_DEBUG("Reset didn't clear indentation");
ret = -1; ret = -1;
} }
virBufferAdjustIndent(buf, 2); virBufferAdjustIndent(buf, 2);
virBufferAddLit(buf, "1"); virBufferAddLit(buf, "1");
if (virBufferError(buf)) { if (virBufferError(buf)) {
TEST_ERROR("Buffer had error"); VIR_TEST_DEBUG("Buffer had error");
return -1; return -1;
} }
if (STRNEQ(virBufferCurrentContent(buf), " 1")) { if (STRNEQ(virBufferCurrentContent(buf), " 1")) {
TEST_ERROR("Wrong content"); VIR_TEST_DEBUG("Wrong content");
ret = -1; ret = -1;
} }
if (virBufferGetIndent(buf, false) != 2 || if (virBufferGetIndent(buf, false) != 2 ||
virBufferGetIndent(buf, true) != 0) { virBufferGetIndent(buf, true) != 0) {
TEST_ERROR("Wrong indentation"); VIR_TEST_DEBUG("Wrong indentation");
ret = -1; ret = -1;
} }
virBufferAddLit(buf, "\n"); virBufferAddLit(buf, "\n");
@ -138,7 +132,7 @@ static int testBufAutoIndent(const void *data ATTRIBUTE_UNUSED)
virBufferAddChar(buf, '\n'); virBufferAddChar(buf, '\n');
if (virBufferError(buf)) { if (virBufferError(buf)) {
TEST_ERROR("Buffer had error"); VIR_TEST_DEBUG("Buffer had error");
return -1; return -1;
} }
@ -175,7 +169,7 @@ static int testBufTrim(const void *data ATTRIBUTE_UNUSED)
virBufferTrim(buf, ",", -1); virBufferTrim(buf, ",", -1);
if (virBufferError(buf)) { if (virBufferError(buf)) {
TEST_ERROR("Buffer had error"); VIR_TEST_DEBUG("Buffer had error");
return -1; return -1;
} }
@ -187,7 +181,7 @@ static int testBufTrim(const void *data ATTRIBUTE_UNUSED)
virBufferTrim(buf, NULL, -1); virBufferTrim(buf, NULL, -1);
if (virBufferError(buf) != -1) { if (virBufferError(buf) != -1) {
TEST_ERROR("Usage error not flagged"); VIR_TEST_DEBUG("Usage error not flagged");
goto cleanup; goto cleanup;
} }
@ -223,17 +217,17 @@ static int testBufAddBuffer(const void *data ATTRIBUTE_UNUSED)
" destroy an entire planet.\n"; " destroy an entire planet.\n";
if (virBufferUse(&buf1)) { if (virBufferUse(&buf1)) {
TEST_ERROR("buf1 already in use"); VIR_TEST_DEBUG("buf1 already in use");
goto cleanup; goto cleanup;
} }
if (virBufferUse(&buf2)) { if (virBufferUse(&buf2)) {
TEST_ERROR("buf2 already in use"); VIR_TEST_DEBUG("buf2 already in use");
goto cleanup; goto cleanup;
} }
if (virBufferUse(&buf3)) { if (virBufferUse(&buf3)) {
TEST_ERROR("buf3 already in use"); VIR_TEST_DEBUG("buf3 already in use");
goto cleanup; goto cleanup;
} }
@ -258,41 +252,41 @@ static int testBufAddBuffer(const void *data ATTRIBUTE_UNUSED)
virBufferAddLit(&buf3, "destroy an entire planet.\n"); virBufferAddLit(&buf3, "destroy an entire planet.\n");
if (!virBufferUse(&buf1)) { if (!virBufferUse(&buf1)) {
TEST_ERROR("Error adding to buf1"); VIR_TEST_DEBUG("Error adding to buf1");
goto cleanup; goto cleanup;
} }
if (!virBufferUse(&buf2)) { if (!virBufferUse(&buf2)) {
TEST_ERROR("Error adding to buf2"); VIR_TEST_DEBUG("Error adding to buf2");
goto cleanup; goto cleanup;
} }
if (!virBufferUse(&buf3)) { if (!virBufferUse(&buf3)) {
TEST_ERROR("Error adding to buf3"); VIR_TEST_DEBUG("Error adding to buf3");
goto cleanup; goto cleanup;
} }
virBufferAddBuffer(&buf2, &buf3); virBufferAddBuffer(&buf2, &buf3);
if (!virBufferUse(&buf2)) { if (!virBufferUse(&buf2)) {
TEST_ERROR("buf2 cleared mistakenly"); VIR_TEST_DEBUG("buf2 cleared mistakenly");
goto cleanup; goto cleanup;
} }
if (virBufferUse(&buf3)) { if (virBufferUse(&buf3)) {
TEST_ERROR("buf3 is not clear even though it should be"); VIR_TEST_DEBUG("buf3 is not clear even though it should be");
goto cleanup; goto cleanup;
} }
virBufferAddBuffer(&buf1, &buf2); virBufferAddBuffer(&buf1, &buf2);
if (!virBufferUse(&buf1)) { if (!virBufferUse(&buf1)) {
TEST_ERROR("buf1 cleared mistakenly"); VIR_TEST_DEBUG("buf1 cleared mistakenly");
goto cleanup; goto cleanup;
} }
if (virBufferUse(&buf2)) { if (virBufferUse(&buf2)) {
TEST_ERROR("buf2 is not clear even though it should be"); VIR_TEST_DEBUG("buf2 is not clear even though it should be");
goto cleanup; goto cleanup;
} }
@ -330,12 +324,12 @@ testBufAddStr(const void *opaque ATTRIBUTE_UNUSED)
virBufferAddLit(&buf, "</c>"); virBufferAddLit(&buf, "</c>");
if (!(actual = virBufferContentAndReset(&buf))) { if (!(actual = virBufferContentAndReset(&buf))) {
TEST_ERROR("buf is empty"); VIR_TEST_DEBUG("buf is empty");
goto cleanup; goto cleanup;
} }
if (STRNEQ_NULLABLE(actual, data->expect)) { if (STRNEQ_NULLABLE(actual, data->expect)) {
TEST_ERROR("testBufAddStr(): Strings don't match:\n"); VIR_TEST_DEBUG("testBufAddStr(): Strings don't match:\n");
virtTestDifference(stderr, data->expect, actual); virtTestDifference(stderr, data->expect, actual);
goto cleanup; goto cleanup;
} }
@ -363,12 +357,12 @@ testBufEscapeStr(const void *opaque ATTRIBUTE_UNUSED)
virBufferAddLit(&buf, "</c>"); virBufferAddLit(&buf, "</c>");
if (!(actual = virBufferContentAndReset(&buf))) { if (!(actual = virBufferContentAndReset(&buf))) {
TEST_ERROR("buf is empty"); VIR_TEST_DEBUG("buf is empty");
goto cleanup; goto cleanup;
} }
if (STRNEQ_NULLABLE(actual, data->expect)) { if (STRNEQ_NULLABLE(actual, data->expect)) {
TEST_ERROR("testBufEscapeStr(): Strings don't match:\n"); VIR_TEST_DEBUG("testBufEscapeStr(): Strings don't match:\n");
virtTestDifference(stderr, data->expect, actual); virtTestDifference(stderr, data->expect, actual);
goto cleanup; goto cleanup;
} }

152
tests/virhashtest.c
View File

@ -17,18 +17,6 @@
VIR_LOG_INIT("tests.hashtest"); VIR_LOG_INIT("tests.hashtest");
#define testError(...) \
do { \
char *str; \
if (virAsprintfQuiet(&str, __VA_ARGS__) >= 0) { \
fprintf(stderr, "%s", str); \
VIR_FREE(str); \
} \
/* Pad to line up with test name ... in virTestRun */ \
fprintf(stderr, "%74s", "... "); \
} while (0)
static virHashTablePtr static virHashTablePtr
testHashInit(int size) testHashInit(int size)
{ {
@ -48,25 +36,22 @@ testHashInit(int size)
return NULL; return NULL;
} }
if (virHashTableSize(hash) != oldsize && virTestGetDebug()) { if (virHashTableSize(hash) != oldsize) {
VIR_WARN("hash grown from %zd to %zd", VIR_TEST_DEBUG("hash grown from %zd to %zd",
(size_t)oldsize, (size_t)virHashTableSize(hash)); (size_t)oldsize, (size_t)virHashTableSize(hash));
} }
} }
for (i = 0; i < ARRAY_CARDINALITY(uuids); i++) { for (i = 0; i < ARRAY_CARDINALITY(uuids); i++) {
if (!virHashLookup(hash, uuids[i])) { if (!virHashLookup(hash, uuids[i])) {
if (virTestGetVerbose()) { VIR_TEST_VERBOSE("\nentry \"%s\" could not be found\n", uuids[i]);
VIR_WARN("\nentry \"%s\" could not be found\n",
uuids[i]);
}
virHashFree(hash); virHashFree(hash);
return NULL; return NULL;
} }
} }
if (size && size != virHashTableSize(hash) && virTestGetDebug()) if (size && size != virHashTableSize(hash))
fprintf(stderr, "\n"); VIR_TEST_DEBUG("\n");
return hash; return hash;
} }
@ -84,14 +69,14 @@ testHashCheckCount(virHashTablePtr hash, size_t count)
ssize_t iter_count = 0; ssize_t iter_count = 0;
if (virHashSize(hash) != count) { if (virHashSize(hash) != count) {
testError("\nhash contains %zu instead of %zu elements\n", VIR_TEST_VERBOSE("\nhash contains %zu instead of %zu elements\n",
(size_t)virHashSize(hash), count); (size_t)virHashSize(hash), count);
return -1; return -1;
} }
iter_count = virHashForEach(hash, testHashCheckForEachCount, NULL); iter_count = virHashForEach(hash, testHashCheckForEachCount, NULL);
if (count != iter_count) { if (count != iter_count) {
testError("\nhash claims to have %zu elements but iteration finds %zu\n", VIR_TEST_VERBOSE("\nhash claims to have %zu elements but iteration finds %zu\n",
count, (size_t)iter_count); count, (size_t)iter_count);
return -1; return -1;
} }
@ -140,20 +125,16 @@ testHashUpdate(const void *data ATTRIBUTE_UNUSED)
for (i = 0; i < ARRAY_CARDINALITY(uuids_subset); i++) { for (i = 0; i < ARRAY_CARDINALITY(uuids_subset); i++) {
if (virHashUpdateEntry(hash, uuids_subset[i], (void *) 1) < 0) { if (virHashUpdateEntry(hash, uuids_subset[i], (void *) 1) < 0) {
if (virTestGetVerbose()) { VIR_TEST_VERBOSE("\nentry \"%s\" could not be updated\n",
fprintf(stderr, "\nentry \"%s\" could not be updated\n", uuids_subset[i]);
uuids_subset[i]);
}
goto cleanup; goto cleanup;
} }
} }
for (i = 0; i < ARRAY_CARDINALITY(uuids_new); i++) { for (i = 0; i < ARRAY_CARDINALITY(uuids_new); i++) {
if (virHashUpdateEntry(hash, uuids_new[i], (void *) 1) < 0) { if (virHashUpdateEntry(hash, uuids_new[i], (void *) 1) < 0) {
if (virTestGetVerbose()) { VIR_TEST_VERBOSE("\nnew entry \"%s\" could not be updated\n",
fprintf(stderr, "\nnew entry \"%s\" could not be updated\n", uuids_new[i]);
uuids_new[i]);
}
goto cleanup; goto cleanup;
} }
} }
@ -182,10 +163,8 @@ testHashRemove(const void *data ATTRIBUTE_UNUSED)
for (i = 0; i < ARRAY_CARDINALITY(uuids_subset); i++) { for (i = 0; i < ARRAY_CARDINALITY(uuids_subset); i++) {
if (virHashRemoveEntry(hash, uuids_subset[i]) < 0) { if (virHashRemoveEntry(hash, uuids_subset[i]) < 0) {
if (virTestGetVerbose()) { VIR_TEST_VERBOSE("\nentry \"%s\" could not be removed\n",
fprintf(stderr, "\nentry \"%s\" could not be removed\n", uuids_subset[i]);
uuids_subset[i]);
}
goto cleanup; goto cleanup;
} }
} }
@ -214,8 +193,8 @@ testHashRemoveForEachSome(void *payload ATTRIBUTE_UNUSED,
for (i = 0; i < ARRAY_CARDINALITY(uuids_subset); i++) { for (i = 0; i < ARRAY_CARDINALITY(uuids_subset); i++) {
if (STREQ(uuids_subset[i], name)) { if (STREQ(uuids_subset[i], name)) {
if (virHashRemoveEntry(hash, name) < 0 && virTestGetVerbose()) { if (virHashRemoveEntry(hash, name) < 0) {
fprintf(stderr, "\nentry \"%s\" could not be removed", VIR_TEST_VERBOSE("\nentry \"%s\" could not be removed",
uuids_subset[i]); uuids_subset[i]);
} }
break; break;
@ -251,9 +230,8 @@ testHashRemoveForEachForbidden(void *payload ATTRIBUTE_UNUSED,
if (STREQ(uuids_subset[i], name)) { if (STREQ(uuids_subset[i], name)) {
int next = (i + 1) % ARRAY_CARDINALITY(uuids_subset); int next = (i + 1) % ARRAY_CARDINALITY(uuids_subset);
if (virHashRemoveEntry(hash, uuids_subset[next]) == 0 && if (virHashRemoveEntry(hash, uuids_subset[next]) == 0) {
virTestGetVerbose()) { VIR_TEST_VERBOSE(
fprintf(stderr,
"\nentry \"%s\" should not be allowed to be removed", "\nentry \"%s\" should not be allowed to be removed",
uuids_subset[next]); uuids_subset[next]);
} }
@ -277,11 +255,9 @@ testHashRemoveForEach(const void *data)
count = virHashForEach(hash, (virHashIterator) info->data, hash); count = virHashForEach(hash, (virHashIterator) info->data, hash);
if (count != ARRAY_CARDINALITY(uuids)) { if (count != ARRAY_CARDINALITY(uuids)) {
if (virTestGetVerbose()) { VIR_TEST_VERBOSE("\nvirHashForEach didn't go through all entries,"
testError("\nvirHashForEach didn't go through all entries," " %d != %zu\n",
" %d != %zu\n", count, ARRAY_CARDINALITY(uuids));
count, ARRAY_CARDINALITY(uuids));
}
goto cleanup; goto cleanup;
} }
@ -309,10 +285,8 @@ testHashSteal(const void *data ATTRIBUTE_UNUSED)
for (i = 0; i < ARRAY_CARDINALITY(uuids_subset); i++) { for (i = 0; i < ARRAY_CARDINALITY(uuids_subset); i++) {
if (!virHashSteal(hash, uuids_subset[i])) { if (!virHashSteal(hash, uuids_subset[i])) {
if (virTestGetVerbose()) { VIR_TEST_VERBOSE("\nentry \"%s\" could not be stolen\n",
fprintf(stderr, "\nentry \"%s\" could not be stolen\n", uuids_subset[i]);
uuids_subset[i]);
}
goto cleanup; goto cleanup;
} }
} }
@ -343,31 +317,21 @@ testHashForEachIter(void *payload ATTRIBUTE_UNUSED,
{ {
virHashTablePtr hash = data; virHashTablePtr hash = data;
if (virHashAddEntry(hash, uuids_new[0], NULL) == 0 && if (virHashAddEntry(hash, uuids_new[0], NULL) == 0)
virTestGetVerbose()) { VIR_TEST_VERBOSE("\nadding entries in ForEach should be forbidden");
fprintf(stderr, "\nadding entries in ForEach should be forbidden");
}
if (virHashUpdateEntry(hash, uuids_new[0], NULL) == 0 && if (virHashUpdateEntry(hash, uuids_new[0], NULL) == 0)
virTestGetVerbose()) { VIR_TEST_VERBOSE("\nupdating entries in ForEach should be forbidden");
fprintf(stderr, "\nupdating entries in ForEach should be forbidden");
}
if (virHashSteal(hash, uuids_new[0]) != NULL && if (virHashSteal(hash, uuids_new[0]) != NULL)
virTestGetVerbose()) { VIR_TEST_VERBOSE("\nstealing entries in ForEach should be forbidden");
fprintf(stderr, "\nstealing entries in ForEach should be forbidden");
}
if (virHashSteal(hash, uuids_new[0]) != NULL && if (virHashSteal(hash, uuids_new[0]) != NULL)
virTestGetVerbose()) { VIR_TEST_VERBOSE("\nstealing entries in ForEach should be forbidden");
fprintf(stderr, "\nstealing entries in ForEach should be forbidden");
}
if (virHashForEach(hash, testHashIter, NULL) >= 0 && if (virHashForEach(hash, testHashIter, NULL) >= 0)
virTestGetVerbose()) { VIR_TEST_VERBOSE("\niterating through hash in ForEach"
fprintf(stderr, "\niterating through hash in ForEach"
" should be forbidden"); " should be forbidden");
}
} }
static int static int
@ -383,11 +347,9 @@ testHashForEach(const void *data ATTRIBUTE_UNUSED)
count = virHashForEach(hash, testHashForEachIter, hash); count = virHashForEach(hash, testHashForEachIter, hash);
if (count != ARRAY_CARDINALITY(uuids)) { if (count != ARRAY_CARDINALITY(uuids)) {
if (virTestGetVerbose()) { VIR_TEST_VERBOSE("\nvirHashForEach didn't go through all entries,"
testError("\nvirHashForEach didn't go through all entries," " %d != %zu\n",
" %d != %zu\n", count, ARRAY_CARDINALITY(uuids));
count, ARRAY_CARDINALITY(uuids));
}
goto cleanup; goto cleanup;
} }
@ -440,11 +402,9 @@ testHashRemoveSet(const void *data ATTRIBUTE_UNUSED)
rcount = virHashRemoveSet(hash, testHashRemoveSetIter, &count); rcount = virHashRemoveSet(hash, testHashRemoveSetIter, &count);
if (count != rcount) { if (count != rcount) {
if (virTestGetVerbose()) { VIR_TEST_VERBOSE("\nvirHashRemoveSet didn't remove expected number of"
testError("\nvirHashRemoveSet didn't remove expected number of" " entries, %d != %u\n",
" entries, %d != %u\n", rcount, count);
rcount, count);
}
goto cleanup; goto cleanup;
} }
@ -482,10 +442,8 @@ testHashSearch(const void *data ATTRIBUTE_UNUSED)
entry = virHashSearch(hash, testHashSearchIter, NULL); entry = virHashSearch(hash, testHashSearchIter, NULL);
if (!entry || STRNEQ(uuids_subset[testSearchIndex], entry)) { if (!entry || STRNEQ(uuids_subset[testSearchIndex], entry)) {
if (virTestGetVerbose()) { VIR_TEST_VERBOSE("\nvirHashSearch didn't find entry '%s'\n",
testError("\nvirHashSearch didn't find entry '%s'\n", uuids_subset[testSearchIndex]);
uuids_subset[testSearchIndex]);
}
goto cleanup; goto cleanup;
} }
@ -531,15 +489,13 @@ testHashGetItems(const void *data ATTRIBUTE_UNUSED)
virHashAddEntry(hash, keya, value3) < 0 || virHashAddEntry(hash, keya, value3) < 0 ||
virHashAddEntry(hash, keyc, value1) < 0 || virHashAddEntry(hash, keyc, value1) < 0 ||
virHashAddEntry(hash, keyb, value2) < 0) { virHashAddEntry(hash, keyb, value2) < 0) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("\nfailed to create hash");
testError("\nfailed to create hash");
goto cleanup; goto cleanup;
} }
if (!(array = virHashGetItems(hash, NULL)) || if (!(array = virHashGetItems(hash, NULL)) ||
array[3].key || array[3].value) { array[3].key || array[3].value) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("\nfailed to get items with NULL sort");
testError("\nfailed to get items with NULL sort");
goto cleanup; goto cleanup;
} }
VIR_FREE(array); VIR_FREE(array);
@ -552,8 +508,7 @@ testHashGetItems(const void *data ATTRIBUTE_UNUSED)
STRNEQ(array[2].key, "c") || STRNEQ(array[2].key, "c") ||
STRNEQ(array[2].value, "1") || STRNEQ(array[2].value, "1") ||
array[3].key || array[3].value) { array[3].key || array[3].value) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("\nfailed to get items with key sort");
testError("\nfailed to get items with key sort");
goto cleanup; goto cleanup;
} }
VIR_FREE(array); VIR_FREE(array);
@ -566,8 +521,7 @@ testHashGetItems(const void *data ATTRIBUTE_UNUSED)
STRNEQ(array[2].key, "a") || STRNEQ(array[2].key, "a") ||
STRNEQ(array[2].value, "3") || STRNEQ(array[2].value, "3") ||
array[3].key || array[3].value) { array[3].key || array[3].value) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("\nfailed to get items with value sort");
testError("\nfailed to get items with value sort");
goto cleanup; goto cleanup;
} }
@ -608,38 +562,32 @@ testHashEqual(const void *data ATTRIBUTE_UNUSED)
virHashAddEntry(hash1, keyc, value3_l) < 0 || virHashAddEntry(hash1, keyc, value3_l) < 0 ||
virHashAddEntry(hash2, keya, value1_u) < 0 || virHashAddEntry(hash2, keya, value1_u) < 0 ||
virHashAddEntry(hash2, keyb, value2_u) < 0) { virHashAddEntry(hash2, keyb, value2_u) < 0) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("\nfailed to create hashes");
testError("\nfailed to create hashes");
goto cleanup; goto cleanup;
} }
if (virHashEqual(hash1, hash2, testHashEqualCompValue)) { if (virHashEqual(hash1, hash2, testHashEqualCompValue)) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("\nfailed equal test for different number of elements");
testError("\nfailed equal test for different number of elements");
goto cleanup; goto cleanup;
} }
if (virHashAddEntry(hash2, keyc, value4_u) < 0) { if (virHashAddEntry(hash2, keyc, value4_u) < 0) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("\nfailed to add element to hash2");
testError("\nfailed to add element to hash2");
goto cleanup; goto cleanup;
} }
if (virHashEqual(hash1, hash2, testHashEqualCompValue)) { if (virHashEqual(hash1, hash2, testHashEqualCompValue)) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("\nfailed equal test for same number of elements");
testError("\nfailed equal test for same number of elements");
goto cleanup; goto cleanup;
} }
if (virHashUpdateEntry(hash2, keyc, value3_u) < 0) { if (virHashUpdateEntry(hash2, keyc, value3_u) < 0) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("\nfailed to update element in hash2");
testError("\nfailed to update element in hash2");
goto cleanup; goto cleanup;
} }
if (!virHashEqual(hash1, hash2, testHashEqualCompValue)) { if (!virHashEqual(hash1, hash2, testHashEqualCompValue)) {
if (virTestGetVerbose()) VIR_TEST_VERBOSE("\nfailed equal test for equal hash tables");
testError("\nfailed equal test for equal hash tables");
goto cleanup; goto cleanup;
} }

4
tests/virpcitest.c
View File

@ -359,12 +359,12 @@ mymain(void)
char *fakesysfsdir; char *fakesysfsdir;
if (VIR_STRDUP_QUIET(fakesysfsdir, FAKESYSFSDIRTEMPLATE) < 0) { if (VIR_STRDUP_QUIET(fakesysfsdir, FAKESYSFSDIRTEMPLATE) < 0) {
fprintf(stderr, "Out of memory\n"); VIR_TEST_DEBUG("Out of memory\n");
abort(); abort();
} }
if (!mkdtemp(fakesysfsdir)) { if (!mkdtemp(fakesysfsdir)) {
fprintf(stderr, "Cannot create fakesysfsdir"); VIR_TEST_DEBUG("Cannot create fakesysfsdir");
abort(); abort();
} }

35
tests/virportallocatortest.c
View File

@ -49,7 +49,7 @@ static void init_syms(void)
realsocket = dlsym(RTLD_NEXT, "socket"); realsocket = dlsym(RTLD_NEXT, "socket");
if (!realsocket) { if (!realsocket) {
fprintf(stderr, "Unable to find 'socket' symbol\n"); VIR_TEST_DEBUG("Unable to find 'socket' symbol\n");
abort(); abort();
} }
@ -132,54 +132,47 @@ static int testAllocAll(const void *args ATTRIBUTE_UNUSED)
if (virPortAllocatorAcquire(alloc, &p1) < 0) if (virPortAllocatorAcquire(alloc, &p1) < 0)
goto cleanup; goto cleanup;
if (p1 != 5901) { if (p1 != 5901) {
if (virTestGetDebug()) VIR_TEST_DEBUG("Expected 5901, got %d", p1);
fprintf(stderr, "Expected 5901, got %d", p1);
goto cleanup; goto cleanup;
} }
if (virPortAllocatorAcquire(alloc, &p2) < 0) if (virPortAllocatorAcquire(alloc, &p2) < 0)
goto cleanup; goto cleanup;
if (p2 != 5902) { if (p2 != 5902) {
if (virTestGetDebug()) VIR_TEST_DEBUG("Expected 5902, got %d", p2);
fprintf(stderr, "Expected 5902, got %d", p2);
goto cleanup; goto cleanup;
} }
if (virPortAllocatorAcquire(alloc, &p3) < 0) if (virPortAllocatorAcquire(alloc, &p3) < 0)
goto cleanup; goto cleanup;
if (p3 != 5903) { if (p3 != 5903) {
if (virTestGetDebug()) VIR_TEST_DEBUG("Expected 5903, got %d", p3);
fprintf(stderr, "Expected 5903, got %d", p3);
goto cleanup; goto cleanup;
} }
if (virPortAllocatorAcquire(alloc, &p4) < 0) if (virPortAllocatorAcquire(alloc, &p4) < 0)
goto cleanup; goto cleanup;
if (p4 != 5907) { if (p4 != 5907) {
if (virTestGetDebug()) VIR_TEST_DEBUG("Expected 5907, got %d", p4);
fprintf(stderr, "Expected 5907, got %d", p4);
goto cleanup; goto cleanup;
} }
if (virPortAllocatorAcquire(alloc, &p5) < 0) if (virPortAllocatorAcquire(alloc, &p5) < 0)
goto cleanup; goto cleanup;
if (p5 != 5908) { if (p5 != 5908) {
if (virTestGetDebug()) VIR_TEST_DEBUG("Expected 5908, got %d", p5);
fprintf(stderr, "Expected 5908, got %d", p5);
goto cleanup; goto cleanup;
} }
if (virPortAllocatorAcquire(alloc, &p6) < 0) if (virPortAllocatorAcquire(alloc, &p6) < 0)
goto cleanup; goto cleanup;
if (p6 != 5909) { if (p6 != 5909) {
if (virTestGetDebug()) VIR_TEST_DEBUG("Expected 5909, got %d", p6);
fprintf(stderr, "Expected 5909, got %d", p6);
goto cleanup; goto cleanup;
} }
if (virPortAllocatorAcquire(alloc, &p7) == 0) { if (virPortAllocatorAcquire(alloc, &p7) == 0) {
if (virTestGetDebug()) VIR_TEST_DEBUG("Expected error, got %d", p7);
fprintf(stderr, "Expected error, got %d", p7);
goto cleanup; goto cleanup;
} }
@ -203,24 +196,21 @@ static int testAllocReuse(const void *args ATTRIBUTE_UNUSED)
if (virPortAllocatorAcquire(alloc, &p1) < 0) if (virPortAllocatorAcquire(alloc, &p1) < 0)
goto cleanup; goto cleanup;
if (p1 != 5901) { if (p1 != 5901) {
if (virTestGetDebug()) VIR_TEST_DEBUG("Expected 5901, got %d", p1);
fprintf(stderr, "Expected 5901, got %d", p1);
goto cleanup; goto cleanup;
} }
if (virPortAllocatorAcquire(alloc, &p2) < 0) if (virPortAllocatorAcquire(alloc, &p2) < 0)
goto cleanup; goto cleanup;
if (p2 != 5902) { if (p2 != 5902) {
if (virTestGetDebug()) VIR_TEST_DEBUG("Expected 5902, got %d", p2);
fprintf(stderr, "Expected 5902, got %d", p2);
goto cleanup; goto cleanup;
} }
if (virPortAllocatorAcquire(alloc, &p3) < 0) if (virPortAllocatorAcquire(alloc, &p3) < 0)
goto cleanup; goto cleanup;
if (p3 != 5903) { if (p3 != 5903) {
if (virTestGetDebug()) VIR_TEST_DEBUG("Expected 5903, got %d", p3);
fprintf(stderr, "Expected 5903, got %d", p3);
goto cleanup; goto cleanup;
} }
@ -231,8 +221,7 @@ static int testAllocReuse(const void *args ATTRIBUTE_UNUSED)
if (virPortAllocatorAcquire(alloc, &p4) < 0) if (virPortAllocatorAcquire(alloc, &p4) < 0)
goto cleanup; goto cleanup;
if (p4 != 5902) { if (p4 != 5902) {
if (virTestGetDebug()) VIR_TEST_DEBUG("Expected 5902, got %d", p4);
fprintf(stderr, "Expected 5902, got %d", p4);
goto cleanup; goto cleanup;
} }