static int testCompareXMLToArgvFiles(const char *xml,
const char *cmdline,
const char *ldcmdline,
const char *dmcmdline)
{
char *actualargv = NULL, *actualld = NULL, *actualdm = NULL;
virDomainDefPtr vmdef = NULL;
virCommandPtr cmd = NULL, ldcmd = NULL;
virConnectPtr conn;
int ret = -1;
if (!(conn = virGetConnect()))
goto out;
if (!(vmdef = virDomainDefParseFile(xml, driver.caps, driver.xmlopt,
VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto out;
conn->privateData = &driver;
if (!(cmd = virBhyveProcessBuildBhyveCmd(conn, vmdef, false)))
goto out;
if (!(actualargv = virCommandToString(cmd)))
goto out;
if (!(ldcmd = virBhyveProcessBuildLoadCmd(conn, vmdef, "<device.map>",
&actualdm)))
goto out;
if (actualdm != NULL)
virTrimSpaces(actualdm, NULL);
if (!(actualld = virCommandToString(ldcmd)))
goto out;
if (virtTestCompareToFile(actualargv, cmdline) < 0)
goto out;
if (virtTestCompareToFile(actualld, ldcmdline) < 0)
goto out;
if (virFileExists(dmcmdline) || actualdm) {
if (virtTestCompareToFile(actualdm, dmcmdline) < 0)
goto out;
}
ret = 0;
out:
VIR_FREE(actualargv);
VIR_FREE(actualld);
VIR_FREE(actualdm);
virCommandFree(cmd);
virCommandFree(ldcmd);
virDomainDefFree(vmdef);
return ret;
}
static int
testCompareFiles(const char *vmx, const char *xml)
{
int ret = -1;
char *vmxData = NULL;
char *formatted = NULL;
virDomainDefPtr def = NULL;
if (virtTestLoadFile(vmx, &vmxData) < 0)
goto cleanup;
if (!(def = virVMXParseConfig(&ctx, xmlopt, vmxData)))
goto cleanup;
if (!virDomainDefCheckABIStability(def, def)) {
fprintf(stderr, "ABI stability check failed on %s", vmx);
goto cleanup;
}
if (!(formatted = virDomainDefFormat(def, VIR_DOMAIN_DEF_FORMAT_SECURE)))
goto cleanup;
if (virtTestCompareToFile(formatted, xml) < 0)
goto cleanup;
ret = 0;
cleanup:
VIR_FREE(vmxData);
VIR_FREE(formatted);
virDomainDefFree(def);
return ret;
}
static int
cpuTestCompareXML(const char *arch,
virCPUDef *cpu,
const char *name,
bool updateCPU)
{
char *xml = NULL;
char *actual = NULL;
int ret = -1;
if (virAsprintf(&xml, "%s/cputestdata/%s-%s.xml",
abs_srcdir, arch, name) < 0)
goto cleanup;
if (!(actual = virCPUDefFormat(cpu, NULL, updateCPU)))
goto cleanup;
if (virtTestCompareToFile(actual, xml) < 0)
goto cleanup;
ret = 0;
cleanup:
VIR_FREE(xml);
VIR_FREE(actual);
return ret;
}
static int
testSysinfo(const void *data)
{
int result = -1;
const char *sysfsActualData;
virSysinfoDefPtr ret = NULL;
virBuffer buf = VIR_BUFFER_INITIALIZER;
const struct testSysinfoData *testdata = data;
virSysinfoSetup(testdata->decoder, testdata->sysinfo, testdata->cpuinfo);
if (!testdata->expected ||
!(ret = virSysinfoRead()))
goto cleanup;
if (virSysinfoFormat(&buf, ret) < 0)
goto cleanup;
if (!(sysfsActualData = virBufferCurrentContent(&buf)))
goto cleanup;
if (virtTestCompareToFile(sysfsActualData, testdata->expected) < 0)
goto cleanup;
result = 0;
cleanup:
virSysinfoDefFree(ret);
virBufferFreeAndReset(&buf);
return result;
}
static int
testCompareXMLToXMLFiles(const char *inxml, const char *outxml,
bool expect_error)
{
char *actual = NULL;
int ret = -1;
virNWFilterDefPtr dev = NULL;
virResetLastError();
if (!(dev = virNWFilterDefParseFile(inxml))) {
if (expect_error) {
virResetLastError();
goto done;
}
goto fail;
}
if (!(actual = virNWFilterDefFormat(dev)))
goto fail;
if (virtTestCompareToFile(actual, outxml) < 0)
goto fail;
done:
ret = 0;
fail:
VIR_FREE(actual);
virNWFilterDefFree(dev);
return ret;
}
static int
testCompareFiles(const char *xml, const char *sexpr)
{
char *sexprData = NULL;
char *gotxml = NULL;
int id;
char * tty;
int vncport;
int ret = -1;
virDomainDefPtr def = NULL;
virConnectPtr conn;
struct _xenUnifiedPrivate priv;
conn = virGetConnect();
if (!conn) goto fail;
if (virtTestLoadFile(sexpr, &sexprData) < 0)
goto fail;
memset(&priv, 0, sizeof(priv));
/* Many puppies died to bring you this code. */
priv.caps = caps;
conn->privateData = &priv;
if (virMutexInit(&priv.lock) < 0)
goto fail;
if (xenGetDomIdFromSxprString(sexprData, &id) < 0)
goto fail;
xenUnifiedLock(&priv);
tty = xenStoreDomainGetConsolePath(conn, id);
vncport = xenStoreDomainGetVNCPort(conn, id);
xenUnifiedUnlock(&priv);
if (!(def = xenParseSxprString(sexprData,
tty, vncport, caps, xmlopt)))
goto fail;
if (!virDomainDefCheckABIStability(def, def)) {
fprintf(stderr, "ABI stability check failed on %s", xml);
goto fail;
}
if (!(gotxml = virDomainDefFormat(def, 0)))
goto fail;
if (virtTestCompareToFile(gotxml, xml) < 0)
goto fail;
ret = 0;
fail:
VIR_FREE(sexprData);
VIR_FREE(gotxml);
virDomainDefFree(def);
virObjectUnref(conn);
return ret;
}
static int
linuxCPUStatsCompareFiles(const char *cpustatfile,
size_t ncpus,
const char *outfile)
{
int ret = -1;
char *actualData = NULL;
FILE *cpustat = NULL;
virNodeCPUStatsPtr params = NULL;
virBuffer buf = VIR_BUFFER_INITIALIZER;
size_t i;
int nparams = 0;
if (!(cpustat = fopen(cpustatfile, "r"))) {
virReportSystemError(errno, "failed to open '%s': ", cpustatfile);
goto fail;
}
if (linuxNodeGetCPUStats(NULL, 0, NULL, &nparams) < 0)
goto fail;
if (VIR_ALLOC_N(params, nparams) < 0)
goto fail;
if (linuxNodeGetCPUStats(cpustat, VIR_NODE_CPU_STATS_ALL_CPUS, params,
&nparams) < 0)
goto fail;
if (linuxCPUStatsToBuf(&buf, VIR_NODE_CPU_STATS_ALL_CPUS,
params, nparams) < 0)
goto fail;
for (i = 0; i < ncpus; i++) {
if (linuxNodeGetCPUStats(cpustat, i, params, &nparams) < 0)
goto fail;
if (linuxCPUStatsToBuf(&buf, i, params, nparams) < 0)
goto fail;
}
if (!(actualData = virBufferContentAndReset(&buf))) {
virReportOOMError();
goto fail;
}
if (virtTestCompareToFile(actualData, outfile) < 0)
goto fail;
ret = 0;
fail:
virBufferFreeAndReset(&buf);
VIR_FORCE_FCLOSE(cpustat);
VIR_FREE(actualData);
VIR_FREE(params);
return ret;
}
static int
testCompareParseXML(const char *xmcfg, const char *xml)
{
char *gotxmcfgData = NULL;
virConfPtr conf = NULL;
int ret = -1;
virConnectPtr conn = NULL;
int wrote = 4096;
struct _xenUnifiedPrivate priv;
virDomainDefPtr def = NULL;
if (VIR_ALLOC_N(gotxmcfgData, wrote) < 0)
goto fail;
conn = virGetConnect();
if (!conn) goto fail;
/* Many puppies died to bring you this code. */
priv.caps = caps;
conn->privateData = &priv;
if (!(def = virDomainDefParseFile(xml, caps, xmlopt,
VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto fail;
if (!virDomainDefCheckABIStability(def, def)) {
fprintf(stderr, "ABI stability check failed on %s", xml);
goto fail;
}
if (!(conf = xenFormatXM(conn, def)))
goto fail;
if (virConfWriteMem(gotxmcfgData, &wrote, conf) < 0)
goto fail;
gotxmcfgData[wrote] = '\0';
if (virtTestCompareToFile(gotxmcfgData, xmcfg) < 0)
goto fail;
ret = 0;
fail:
VIR_FREE(gotxmcfgData);
if (conf)
virConfFree(conf);
virDomainDefFree(def);
virObjectUnref(conn);
return ret;
}
static int
test_virDomainCapsFormat(const void *opaque)
{
const struct testData *data = opaque;
virDomainCapsPtr domCaps = NULL;
char *path = NULL;
char *domCapsXML = NULL;
int ret = -1;
if (virAsprintf(&path, "%s/domaincapsschemadata/%s.xml",
abs_srcdir, data->name) < 0)
goto cleanup;
if (!(domCaps = virDomainCapsNew(data->emulator, data->machine,
virArchFromString(data->arch),
data->type)))
goto cleanup;
switch (data->capsType) {
case CAPS_NONE:
break;
case CAPS_ALL:
if (fillAllCaps(domCaps) < 0)
goto cleanup;
break;
case CAPS_QEMU:
#if WITH_QEMU
if (fillQemuCaps(domCaps, data->capsName, data->arch, data->machine,
data->capsOpaque) < 0)
goto cleanup;
#endif
break;
}
if (!(domCapsXML = virDomainCapsFormat(domCaps)))
goto cleanup;
if (virtTestCompareToFile(domCapsXML, path) < 0)
goto cleanup;
ret = 0;
cleanup:
VIR_FREE(domCapsXML);
VIR_FREE(path);
virObjectUnref(domCaps);
return ret;
}
static int
testCompareXMLToXMLFiles(const char *inxml, const char *outxml,
unsigned int flags,
testCompareNetXML2XMLResult expectResult)
{
char *actual = NULL;
int ret;
testCompareNetXML2XMLResult result = TEST_COMPARE_NET_XML2XML_RESULT_SUCCESS;
virNetworkDefPtr dev = NULL;
if (!(dev = virNetworkDefParseFile(inxml))) {
result = TEST_COMPARE_NET_XML2XML_RESULT_FAIL_PARSE;
goto cleanup;
}
if (expectResult == TEST_COMPARE_NET_XML2XML_RESULT_FAIL_PARSE)
goto cleanup;
if (!(actual = virNetworkDefFormat(dev, flags))) {
result = TEST_COMPARE_NET_XML2XML_RESULT_FAIL_FORMAT;
goto cleanup;
}
if (expectResult == TEST_COMPARE_NET_XML2XML_RESULT_FAIL_FORMAT)
goto cleanup;
if (virtTestCompareToFile(actual, outxml) < 0) {
result = TEST_COMPARE_NET_XML2XML_RESULT_FAIL_COMPARE;
goto cleanup;
}
if (expectResult == TEST_COMPARE_NET_XML2XML_RESULT_FAIL_COMPARE)
goto cleanup;
cleanup:
if (result == expectResult) {
ret = 0;
if (expectResult != TEST_COMPARE_NET_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);
}
virResetLastError();
VIR_FREE(actual);
virNetworkDefFree(dev);
return ret;
}
static int
linuxTestCompareFiles(char *sysfs_prefix,
const char *cpuinfofile,
virArch arch,
const char *outputfile)
{
int ret = -1;
char *actualData = NULL;
virNodeInfo nodeinfo;
FILE *cpuinfo;
cpuinfo = fopen(cpuinfofile, "r");
if (!cpuinfo) {
fprintf(stderr, "unable to open: %s : %s\n",
cpuinfofile, strerror(errno));
goto fail;
}
memset(&nodeinfo, 0, sizeof(nodeinfo));
if (linuxNodeInfoCPUPopulate(sysfs_prefix, cpuinfo, arch, &nodeinfo) < 0) {
if (virTestGetDebug()) {
virErrorPtr error = virSaveLastError();
if (error && error->code != VIR_ERR_OK)
VIR_TEST_DEBUG("\n%s\n", error->message);
virFreeError(error);
}
VIR_FORCE_FCLOSE(cpuinfo);
goto fail;
}
VIR_FORCE_FCLOSE(cpuinfo);
if (virAsprintf(&actualData,
"CPUs: %u/%u, MHz: %u, Nodes: %u, Sockets: %u, "
"Cores: %u, Threads: %u\n",
nodeinfo.cpus, VIR_NODEINFO_MAXCPUS(nodeinfo),
nodeinfo.mhz, nodeinfo.nodes, nodeinfo.sockets,
nodeinfo.cores, nodeinfo.threads) < 0)
goto fail;
if (virtTestCompareToFile(actualData, outputfile) < 0)
goto fail;
ret = 0;
fail:
VIR_FREE(actualData);
return ret;
}
/*
* Parses domXML to virDomainDef object, which is then converted to xl.cfg(5)
* config and compared with expected config.
*/
static int
testCompareParseXML(const char *xlcfg, const char *xml)
{
char *gotxlcfgData = NULL;
virConfPtr conf = NULL;
virConnectPtr conn = NULL;
int wrote = 4096;
int ret = -1;
virDomainDefPtr def = NULL;
if (VIR_ALLOC_N(gotxlcfgData, wrote) < 0)
goto fail;
conn = virGetConnect();
if (!conn) goto fail;
if (!(def = virDomainDefParseFile(xml, caps, xmlopt,
VIR_DOMAIN_XML_INACTIVE)))
goto fail;
if (!virDomainDefCheckABIStability(def, def)) {
fprintf(stderr, "ABI stability check failed on %s", xml);
goto fail;
}
if (!(conf = xenFormatXL(def, conn)))
goto fail;
if (virConfWriteMem(gotxlcfgData, &wrote, conf) < 0)
goto fail;
gotxlcfgData[wrote] = '\0';
if (virtTestCompareToFile(gotxlcfgData, xlcfg) < 0)
goto fail;
ret = 0;
fail:
VIR_FREE(gotxlcfgData);
if (conf)
virConfFree(conf);
virDomainDefFree(def);
virObjectUnref(conn);
return ret;
}
static int
testCompareFormatXML(const char *xmcfg, const char *xml)
{
char *xmcfgData = NULL;
char *gotxml = NULL;
virConfPtr conf = NULL;
int ret = -1;
virConnectPtr conn;
struct _xenUnifiedPrivate priv;
virDomainDefPtr def = NULL;
conn = virGetConnect();
if (!conn) goto fail;
if (virtTestLoadFile(xmcfg, &xmcfgData) < 0)
goto fail;
/* Many puppies died to bring you this code. */
priv.caps = caps;
conn->privateData = &priv;
if (!(conf = virConfReadMem(xmcfgData, strlen(xmcfgData), 0)))
goto fail;
if (!(def = xenParseXM(conf, caps, xmlopt)))
goto fail;
if (!(gotxml = virDomainDefFormat(def, caps, VIR_DOMAIN_DEF_FORMAT_SECURE)))
goto fail;
if (virtTestCompareToFile(gotxml, xml) < 0)
goto fail;
ret = 0;
fail:
if (conf)
virConfFree(conf);
VIR_FREE(xmcfgData);
VIR_FREE(gotxml);
virDomainDefFree(def);
virObjectUnref(conn);
return ret;
}
static int
testCgroupDetectMounts(const void *args)
{
int result = -1;
const char *file = args;
char *mounts = NULL;
char *parsed = NULL;
const char *actual;
virCgroupPtr group = NULL;
virBuffer buf = VIR_BUFFER_INITIALIZER;
size_t i;
if (virAsprintf(&mounts, "%s/vircgroupdata/%s.mounts",
abs_srcdir, file) < 0 ||
virAsprintf(&parsed, "%s/vircgroupdata/%s.parsed",
abs_srcdir, file) < 0 ||
VIR_ALLOC(group) < 0)
goto cleanup;
if (virCgroupDetectMountsFromFile(group, mounts, false) < 0)
goto cleanup;
for (i = 0; i < VIR_CGROUP_CONTROLLER_LAST; i++) {
virBufferAsprintf(&buf, "%-12s %s\n",
virCgroupControllerTypeToString(i),
NULLSTR(group->controllers[i].mountPoint));
}
if (virBufferCheckError(&buf) < 0)
goto cleanup;
actual = virBufferCurrentContent(&buf);
if (virtTestCompareToFile(actual, parsed) < 0)
goto cleanup;
result = 0;
cleanup:
VIR_FREE(mounts);
VIR_FREE(parsed);
virCgroupFree(&group);
virBufferFreeAndReset(&buf);
return result;
}
/*
* Parses xl.cfg(5) config to virDomainDef object, which is then converted to
* domXML and compared to expected XML.
*/
static int
testCompareFormatXML(const char *xlcfg, const char *xml)
{
char *xlcfgData = NULL;
char *gotxml = NULL;
virConfPtr conf = NULL;
int ret = -1;
virConnectPtr conn;
virDomainDefPtr def = NULL;
conn = virGetConnect();
if (!conn) goto fail;
if (virtTestLoadFile(xlcfg, &xlcfgData) < 0)
goto fail;
if (!(conf = virConfReadMem(xlcfgData, strlen(xlcfgData), 0)))
goto fail;
if (!(def = xenParseXL(conf, caps, xmlopt)))
goto fail;
if (!(gotxml = virDomainDefFormat(def, caps, VIR_DOMAIN_XML_INACTIVE |
VIR_DOMAIN_XML_SECURE)))
goto fail;
if (virtTestCompareToFile(gotxml, xml) < 0)
goto fail;
ret = 0;
fail:
if (conf)
virConfFree(conf);
VIR_FREE(xlcfgData);
VIR_FREE(gotxml);
virDomainDefFree(def);
virObjectUnref(conn);
return ret;
}
static int
testCompareXMLToXMLFiles(const char *inxml, const char *outxml)
{
char *actual = NULL;
int ret = -1;
virStoragePoolDefPtr dev = NULL;
if (!(dev = virStoragePoolDefParseFile(inxml)))
goto fail;
if (!(actual = virStoragePoolDefFormat(dev)))
goto fail;
if (virtTestCompareToFile(actual, outxml) < 0)
goto fail;
ret = 0;
fail:
VIR_FREE(actual);
virStoragePoolDefFree(dev);
return ret;
}
static int testCompareXMLToArgvFiles(const char *xmlfile,
const char *cmdfile,
virQemuXML2ArgvTestFlags flags)
{
char *actualxml = NULL;
char *cmd = NULL;
char *log = NULL;
int ret = -1;
virDomainDefPtr vmdef = NULL;
if (virtTestLoadFile(cmdfile, &cmd) < 0)
goto fail;
if (!(vmdef = qemuParseCommandLineString(driver.caps, driver.xmlopt,
cmd, NULL, NULL, NULL)))
goto fail;
if (!virtTestOOMActive()) {
if ((log = virtTestLogContentAndReset()) == NULL)
goto fail;
if (flags & FLAG_EXPECT_WARNING) {
if (*log) {
VIR_TEST_DEBUG("Got expected warning from "
"qemuParseCommandLineString:\n%s",
log);
} else {
VIR_TEST_DEBUG("qemuParseCommandLineString "
"should have logged a warning\n");
goto fail;
}
} else { /* didn't expect a warning */
if (*log) {
VIR_TEST_DEBUG("Got unexpected warning from "
"qemuParseCommandLineString:\n%s",
log);
goto fail;
}
}
}
if (testSanitizeDef(vmdef) < 0)
goto fail;
if (!virDomainDefCheckABIStability(vmdef, vmdef)) {
VIR_TEST_DEBUG("ABI stability check failed on %s", xmlfile);
goto fail;
}
if (!(actualxml = virDomainDefFormat(vmdef, driver.caps, 0)))
goto fail;
if (virtTestCompareToFile(actualxml, xmlfile) < 0)
goto fail;
ret = 0;
fail:
VIR_FREE(actualxml);
VIR_FREE(cmd);
VIR_FREE(log);
virDomainDefFree(vmdef);
return ret;
}
static int testExecRestart(const void *opaque)
{
int ret = -1;
virNetServerPtr srv = NULL;
const struct testExecRestartData *data = opaque;
char *infile = NULL, *outfile = NULL;
char *injsonstr = NULL, *outjsonstr = NULL;
virJSONValuePtr injson = NULL, outjson = NULL;
int fdclient[2] = { -1, -1 }, fdserver[2] = { -1, -1 };
if (socketpair(PF_UNIX, SOCK_STREAM, 0, fdclient) < 0) {
virReportSystemError(errno, "%s",
"Cannot create socket pair");
goto cleanup;
}
if (socketpair(PF_UNIX, SOCK_STREAM, 0, fdserver) < 0) {
virReportSystemError(errno, "%s",
"Cannot create socket pair");
goto cleanup;
}
/* We're blindly assuming the test case isn't using
* fds 100->103 for something else, which is probably
* fairly reasonable in general
*/
dup2(fdserver[0], 100);
dup2(fdserver[1], 101);
dup2(fdclient[0], 102);
dup2(fdclient[1], 103);
if (virAsprintf(&infile, "%s/virnetserverdata/input-data-%s.json",
abs_srcdir, data->jsonfile) < 0)
goto cleanup;
if (virAsprintf(&outfile, "%s/virnetserverdata/output-data-%s.json",
abs_srcdir, data->jsonfile) < 0)
goto cleanup;
if (virFileReadAll(infile, 8192, &injsonstr) < 0)
goto cleanup;
if (!(injson = virJSONValueFromString(injsonstr)))
goto cleanup;
if (!(srv = virNetServerNewPostExecRestart(injson,
NULL, NULL, NULL,
NULL, NULL)))
goto cleanup;
if (!(outjson = virNetServerPreExecRestart(srv)))
goto cleanup;
if (!(outjsonstr = virJSONValueToString(outjson, true)))
goto cleanup;
if (virtTestCompareToFile(outjsonstr, outfile) < 0)
goto fail;
ret = 0;
cleanup:
if (ret < 0) {
virErrorPtr err = virGetLastError();
/* Rather be safe, we have lot of missing errors */
if (err)
fprintf(stderr, "%s\n", err->message);
else
fprintf(stderr, "%s\n", "Unknown error");
}
fail:
VIR_FREE(infile);
VIR_FREE(outfile);
VIR_FREE(injsonstr);
VIR_FREE(outjsonstr);
virJSONValueFree(injson);
virJSONValueFree(outjson);
virObjectUnref(srv);
VIR_FORCE_CLOSE(fdserver[0]);
VIR_FORCE_CLOSE(fdserver[1]);
VIR_FORCE_CLOSE(fdclient[0]);
VIR_FORCE_CLOSE(fdclient[1]);
return ret;
}
