tests/qemuxml2argvtest.c

   1 #include <config.h>
   2
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <unistd.h>
   6 #include <string.h>
   7
   8 #include <sys/types.h>
   9 #include <fcntl.h>
  10
  11 #include "testutils.h"
  12
  13 #ifdef WITH_QEMU
  14
  15 # include "internal.h"
  16 # include "viralloc.h"
  17 # include "qemu/qemu_capabilities.h"
  18 # include "qemu/qemu_command.h"
  19 # include "qemu/qemu_domain.h"
  20 # include "datatypes.h"
  21 # include "conf/storage_conf.h"
  22 # include "cpu/cpu_map.h"
  23 # include "virstring.h"
  24
  25 # include "testutilsqemu.h"
  26
  27 # define VIR_FROM_THIS VIR_FROM_QEMU
  28
  29 static const char *abs_top_srcdir;
  30 static virQEMUDriver driver;
  31
  32 static unsigned char *
  33 fakeSecretGetValue(virSecretPtr obj ATTRIBUTE_UNUSED,
  34                    size_t *value_size,
  35                    unsigned int fakeflags ATTRIBUTE_UNUSED,
  36                    unsigned int internalFlags ATTRIBUTE_UNUSED)
  37 {
  38     char *secret;
  39     if (VIR_STRDUP(secret, "AQCVn5hO6HzFAhAAq0NCv8jtJcIcE+HOBlMQ1A") < 0)
  40         return NULL;
  41     *value_size = strlen(secret);
  42     return (unsigned char *) secret;
  43 }
  44
  45 static virSecretPtr
  46 fakeSecretLookupByUsage(virConnectPtr conn,
  47                         int usageType ATTRIBUTE_UNUSED,
  48                         const char *usageID)
  49 {
  50     unsigned char uuid[VIR_UUID_BUFLEN];
  51     if (STRNEQ(usageID, "mycluster_myname"))
  52         return NULL;
  53
  54     virUUIDGenerate(uuid);
  55     return virGetSecret(conn, uuid, usageType, usageID);
  56 }
  57
  58 static int
  59 fakeSecretClose(virConnectPtr conn ATTRIBUTE_UNUSED)
  60 {
  61     return 0;
  62 }
  63
  64 static virSecretDriver fakeSecretDriver = {
  65     .name = "fake_secret",
  66     .secretOpen = NULL,
  67     .secretClose = fakeSecretClose,
  68     .connectNumOfSecrets = NULL,
  69     .connectListSecrets = NULL,
  70     .secretLookupByUUID = NULL,
  71     .secretLookupByUsage = fakeSecretLookupByUsage,
  72     .secretDefineXML = NULL,
  73     .secretGetXMLDesc = NULL,
  74     .secretSetValue = NULL,
  75     .secretGetValue = fakeSecretGetValue,
  76     .secretUndefine = NULL,
  77 };
  78
  79
  80 # define STORAGE_POOL_XML_PATH "storagepoolxml2xmlout/"
  81 static const unsigned char fakeUUID[VIR_UUID_BUFLEN] = "fakeuuid";
  82
  83 static virStoragePoolPtr
  84 fakeStoragePoolLookupByName(virConnectPtr conn,
  85                             const char *name)
  86 {
  87     char *xmlpath = NULL;
  88     virStoragePoolPtr ret = NULL;
  89
  90     if (STRNEQ(name, "inactive")) {
  91         if (virAsprintf(&xmlpath, "%s/%s%s.xml",
  92                         abs_srcdir,
  93                         STORAGE_POOL_XML_PATH,
  94                         name) < 0)
  95             return NULL;
  96
  97         if (!virFileExists(xmlpath)) {
  98             virReportError(VIR_ERR_NO_STORAGE_POOL,
  99                            "File '%s' not found", xmlpath);
 100             goto cleanup;
 101         }
 102     }
 103
 104     ret = virGetStoragePool(conn, name, fakeUUID, NULL, NULL);
 105
 106  cleanup:
 107     VIR_FREE(xmlpath);
 108     return ret;
 109 }
 110
 111
 112 static virStorageVolPtr
 113 fakeStorageVolLookupByName(virStoragePoolPtr pool,
 114                            const char *name)
 115 {
 116     char **volinfo = NULL;
 117     virStorageVolPtr ret = NULL;
 118
 119     if (STREQ(pool->name, "inactive")) {
 120         virReportError(VIR_ERR_OPERATION_INVALID,
 121                        "storage pool '%s' is not active", pool->name);
 122         return NULL;
 123     }
 124
 125     if (STREQ(name, "nonexistent")) {
 126         virReportError(VIR_ERR_NO_STORAGE_VOL,
 127                        "no storage vol with matching name '%s'", name);
 128         return NULL;
 129     }
 130
 131     if (!strchr(name, '+'))
 132         goto fallback;
 133
 134     if (!(volinfo = virStringSplit(name, "+", 2)))
 135         return NULL;
 136
 137     if (!volinfo[1])
 138         goto fallback;
 139
 140     ret = virGetStorageVol(pool->conn, pool->name, volinfo[1], volinfo[0],
 141                            NULL, NULL);
 142
 143  cleanup:
 144     virStringFreeList(volinfo);
 145     return ret;
 146
 147  fallback:
 148     ret = virGetStorageVol(pool->conn, pool->name, name, "block", NULL, NULL);
 149     goto cleanup;
 150 }
 151
 152 static int
 153 fakeStorageVolGetInfo(virStorageVolPtr vol,
 154                       virStorageVolInfoPtr info)
 155 {
 156     memset(info, 0, sizeof(*info));
 157
 158     info->type = virStorageVolTypeFromString(vol->key);
 159
 160     if (info->type < 0) {
 161         virReportError(VIR_ERR_INTERNAL_ERROR,
 162                        "Invalid volume type '%s'", vol->key);
 163         return -1;
 164     }
 165
 166     return 0;
 167 }
 168
 169
 170 static char *
 171 fakeStorageVolGetPath(virStorageVolPtr vol)
 172 {
 173     char *ret = NULL;
 174
 175     ignore_value(virAsprintf(&ret, "/some/%s/device/%s", vol->key, vol->name));
 176
 177     return ret;
 178 }
 179
 180
 181 static char *
 182 fakeStoragePoolGetXMLDesc(virStoragePoolPtr pool,
 183                           unsigned int flags_unused ATTRIBUTE_UNUSED)
 184 {
 185     char *xmlpath = NULL;
 186     char *xmlbuf = NULL;
 187
 188     if (STREQ(pool->name, "inactive")) {
 189         virReportError(VIR_ERR_NO_STORAGE_POOL, NULL);
 190         return NULL;
 191     }
 192
 193     if (virAsprintf(&xmlpath, "%s/%s%s.xml",
 194                     abs_srcdir,
 195                     STORAGE_POOL_XML_PATH,
 196                     pool->name) < 0)
 197         return NULL;
 198
 199     if (virtTestLoadFile(xmlpath, &xmlbuf) < 0) {
 200         virReportError(VIR_ERR_INTERNAL_ERROR,
 201                        "failed to load XML file '%s'",
 202                        xmlpath);
 203         goto cleanup;
 204     }
 205
 206  cleanup:
 207     VIR_FREE(xmlpath);
 208
 209     return xmlbuf;
 210 }
 211
 212 static int
 213 fakeStorageClose(virConnectPtr conn ATTRIBUTE_UNUSED)
 214 {
 215     return 0;
 216 }
 217
 218 static int
 219 fakeStoragePoolIsActive(virStoragePoolPtr pool)
 220 {
 221     if (STREQ(pool->name, "inactive"))
 222         return 0;
 223
 224     return 1;
 225 }
 226
 227 /* Test storage pool implementation
 228  *
 229  * These functions aid testing of storage pool related stuff when creating a
 230  * qemu command line.
 231  *
 232  * There are a few "magic" values to pass to these functions:
 233  *
 234  * 1) "inactive" as a pool name to create an inactive pool. All other names are
 235  * interpreted as file names in storagepoolxml2xmlout/ and are used as the
 236  * definition for the pool. If the file doesn't exist the pool doesn't exist.
 237  *
 238  * 2) "nonexistent" returns an error while looking up a volume. Otherwise
 239  * pattern VOLUME_TYPE+VOLUME_PATH can be used to simulate a volume in a pool.
 240  * This creates a fake path for this volume. If the '+' sign is omitted, block
 241  * type is assumed.
 242  */
 243 static virStorageDriver fakeStorageDriver = {
 244     .name = "fake_storage",
 245     .storageClose = fakeStorageClose,
 246     .storagePoolLookupByName = fakeStoragePoolLookupByName,
 247     .storageVolLookupByName = fakeStorageVolLookupByName,
 248     .storagePoolGetXMLDesc = fakeStoragePoolGetXMLDesc,
 249     .storageVolGetPath = fakeStorageVolGetPath,
 250     .storageVolGetInfo = fakeStorageVolGetInfo,
 251     .storagePoolIsActive = fakeStoragePoolIsActive,
 252 };
 253
 254 typedef enum {
 255     FLAG_EXPECT_ERROR       = 1 << 0,
 256     FLAG_EXPECT_FAILURE     = 1 << 1,
 257     FLAG_EXPECT_PARSE_ERROR = 1 << 2,
 258     FLAG_JSON               = 1 << 3,
 259 } virQemuXML2ArgvTestFlags;
 260
 261 static int testCompareXMLToArgvFiles(const char *xml,
 262                                      const char *cmdline,
 263                                      virQEMUCapsPtr extraFlags,
 264                                      const char *migrateFrom,
 265                                      int migrateFd,
 266                                      virQemuXML2ArgvTestFlags flags)
 267 {
 268     char *expectargv = NULL;
 269     int len;
 270     char *actualargv = NULL;
 271     int ret = -1;
 272     virDomainDefPtr vmdef = NULL;
 273     virDomainChrSourceDef monitor_chr;
 274     virConnectPtr conn;
 275     char *log = NULL;
 276     virCommandPtr cmd = NULL;
 277     size_t i;
 278
 279     if (!(conn = virGetConnect()))
 280         goto out;
 281     conn->secretDriver = &fakeSecretDriver;
 282     conn->storageDriver = &fakeStorageDriver;
 283
 284     if (!(vmdef = virDomainDefParseFile(xml, driver.caps, driver.xmlopt,
 285                                         QEMU_EXPECTED_VIRT_TYPES,
 286                                         VIR_DOMAIN_XML_INACTIVE))) {
 287         if (!virtTestOOMActive() &&
 288             (flags & FLAG_EXPECT_PARSE_ERROR))
 289             goto ok;
 290         goto out;
 291     }
 292
 293     if (!virDomainDefCheckABIStability(vmdef, vmdef)) {
 294         fprintf(stderr, "ABI stability check failed on %s", xml);
 295         goto out;
 296     }
 297
 298     if (virQEMUCapsGet(extraFlags, QEMU_CAPS_DOMID))
 299         vmdef->id = 6;
 300     else
 301         vmdef->id = -1;
 302
 303     memset(&monitor_chr, 0, sizeof(monitor_chr));
 304     monitor_chr.type = VIR_DOMAIN_CHR_TYPE_UNIX;
 305     monitor_chr.data.nix.path = (char *)"/tmp/test-monitor";
 306     monitor_chr.data.nix.listen = true;
 307
 308     virQEMUCapsSetList(extraFlags,
 309                        QEMU_CAPS_VNC_COLON,
 310                        QEMU_CAPS_NO_REBOOT,
 311                        QEMU_CAPS_NO_ACPI,
 312                        QEMU_CAPS_LAST);
 313
 314     if (STREQ(vmdef->os.machine, "pc") &&
 315         STREQ(vmdef->emulator, "/usr/bin/qemu-system-x86_64")) {
 316         VIR_FREE(vmdef->os.machine);
 317         if (VIR_STRDUP(vmdef->os.machine, "pc-0.11") < 0)
 318             goto out;
 319     }
 320
 321     if (virQEMUCapsGet(extraFlags, QEMU_CAPS_DEVICE)) {
 322         if (qemuDomainAssignAddresses(vmdef, extraFlags, NULL)) {
 323             if (flags & FLAG_EXPECT_ERROR)
 324                 goto ok;
 325             goto out;
 326         }
 327     }
 328
 329     log = virtTestLogContentAndReset();
 330     VIR_FREE(log);
 331     virResetLastError();
 332
 333     if (vmdef->os.arch == VIR_ARCH_X86_64 ||
 334         vmdef->os.arch == VIR_ARCH_I686) {
 335         virQEMUCapsSet(extraFlags, QEMU_CAPS_PCI_MULTIBUS);
 336     }
 337
 338     if (qemuAssignDeviceAliases(vmdef, extraFlags) < 0)
 339         goto out;
 340
 341     for (i = 0; i < vmdef->nhostdevs; i++) {
 342         virDomainHostdevDefPtr hostdev = vmdef->hostdevs[i];
 343
 344         if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
 345             hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI &&
 346             hostdev->source.subsys.u.pci.backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT) {
 347             hostdev->source.subsys.u.pci.backend = VIR_DOMAIN_HOSTDEV_PCI_BACKEND_KVM;
 348         }
 349     }
 350
 351     for (i = 0; i < vmdef->ndisks; i++) {
 352         if (qemuTranslateDiskSourcePool(conn, vmdef->disks[i]) < 0)
 353             goto out;
 354     }
 355
 356     if (!(cmd = qemuBuildCommandLine(conn, &driver, vmdef, &monitor_chr,
 357                                      (flags & FLAG_JSON), extraFlags,
 358                                      migrateFrom, migrateFd, NULL,
 359                                      VIR_NETDEV_VPORT_PROFILE_OP_NO_OP,
 360                                      &testCallbacks, false))) {
 361         if (!virtTestOOMActive() &&
 362             (flags & FLAG_EXPECT_FAILURE)) {
 363             ret = 0;
 364             if (virTestGetDebug() > 1)
 365                 fprintf(stderr, "Got expected error: %s\n",
 366                         virGetLastErrorMessage());
 367             virResetLastError();
 368         }
 369         goto out;
 370     } else if (flags & FLAG_EXPECT_FAILURE) {
 371         if (virTestGetDebug())
 372             fprintf(stderr, "qemuBuildCommandLine should have failed\n");
 373         goto out;
 374     }
 375
 376     if (!virtTestOOMActive() &&
 377         (!!virGetLastError() != !!(flags & FLAG_EXPECT_ERROR))) {
 378         if (virTestGetDebug() && (log = virtTestLogContentAndReset()))
 379             fprintf(stderr, "\n%s", log);
 380         goto out;
 381     }
 382
 383     if (!(actualargv = virCommandToString(cmd)))
 384         goto out;
 385
 386     len = virtTestLoadFile(cmdline, &expectargv);
 387     if (len < 0)
 388         goto out;
 389     if (len && expectargv[len - 1] == '\n')
 390         expectargv[len - 1] = '\0';
 391
 392     if (STRNEQ(expectargv, actualargv)) {
 393         virtTestDifference(stderr, expectargv, actualargv);
 394         goto out;
 395     }
 396
 397  ok:
 398     if (!virtTestOOMActive() &&
 399         (flags & FLAG_EXPECT_ERROR)) {
 400         /* need to suppress the errors */
 401         virResetLastError();
 402     }
 403
 404     ret = 0;
 405
 406  out:
 407     VIR_FREE(log);
 408     VIR_FREE(expectargv);
 409     VIR_FREE(actualargv);
 410     virCommandFree(cmd);
 411     virDomainDefFree(vmdef);
 412     virObjectUnref(conn);
 413     return ret;
 414 }
 415
 416
 417 struct testInfo {
 418     const char *name;
 419     virQEMUCapsPtr extraFlags;
 420     const char *migrateFrom;
 421     int migrateFd;
 422     unsigned int flags;
 423 };
 424
 425 static int
 426 testCompareXMLToArgvHelper(const void *data)
 427 {
 428     int result = -1;
 429     const struct testInfo *info = data;
 430     char *xml = NULL;
 431     char *args = NULL;
 432     unsigned int flags = info->flags;
 433
 434     if (virAsprintf(&xml, "%s/qemuxml2argvdata/qemuxml2argv-%s.xml",
 435                     abs_srcdir, info->name) < 0 ||
 436         virAsprintf(&args, "%s/qemuxml2argvdata/qemuxml2argv-%s.args",
 437                     abs_srcdir, info->name) < 0)
 438         goto cleanup;
 439
 440     if (virQEMUCapsGet(info->extraFlags, QEMU_CAPS_MONITOR_JSON))
 441         flags |= FLAG_JSON;
 442
 443     result = testCompareXMLToArgvFiles(xml, args, info->extraFlags,
 444                                        info->migrateFrom, info->migrateFd,
 445                                        flags);
 446
 447  cleanup:
 448     VIR_FREE(xml);
 449     VIR_FREE(args);
 450     return result;
 451 }
 452
 453
 454 static int
 455 testAddCPUModels(virQEMUCapsPtr caps, bool skipLegacy)
 456 {
 457     const char *newModels[] = {
 458         "Opteron_G3", "Opteron_G2", "Opteron_G1",
 459         "Nehalem", "Penryn", "Conroe",
 460     };
 461     const char *legacyModels[] = {
 462         "n270", "athlon", "pentium3", "pentium2", "pentium",
 463         "486", "coreduo", "kvm32", "qemu32", "kvm64",
 464         "core2duo", "phenom", "qemu64",
 465     };
 466     size_t i;
 467
 468     for (i = 0; i < ARRAY_CARDINALITY(newModels); i++) {
 469         if (virQEMUCapsAddCPUDefinition(caps, newModels[i]) < 0)
 470             return -1;
 471     }
 472     if (skipLegacy)
 473         return 0;
 474     for (i = 0; i < ARRAY_CARDINALITY(legacyModels); i++) {
 475         if (virQEMUCapsAddCPUDefinition(caps, legacyModels[i]) < 0)
 476             return -1;
 477     }
 478     return 0;
 479 }
 480
 481
 482 static int
 483 mymain(void)
 484 {
 485     int ret = 0;
 486     bool skipLegacyCPUs = false;
 487
 488     abs_top_srcdir = getenv("abs_top_srcdir");
 489     if (!abs_top_srcdir)
 490         abs_top_srcdir = abs_srcdir "/..";
 491
 492     /* Set the timezone because we are mocking the time() function.
 493      * If we don't do that, then localtime() may return unpredictable
 494      * results. In order to detect things that just work by a blind
 495      * chance, we need to set an virtual timezone that no libvirt
 496      * developer resides in. */
 497     if (setenv("TZ", "VIR00:30", 1) < 0) {
 498         perror("setenv");
 499         return EXIT_FAILURE;
 500     }
 501
 502     driver.config = virQEMUDriverConfigNew(false);
 503     if (driver.config == NULL)
 504         return EXIT_FAILURE;
 505     else
 506         driver.config->privileged = true;
 507
 508     VIR_FREE(driver.config->spiceListen);
 509     VIR_FREE(driver.config->vncListen);
 510
 511     VIR_FREE(driver.config->vncTLSx509certdir);
 512     if (VIR_STRDUP_QUIET(driver.config->vncTLSx509certdir, "/etc/pki/libvirt-vnc") < 0)
 513         return EXIT_FAILURE;
 514     VIR_FREE(driver.config->spiceTLSx509certdir);
 515     if (VIR_STRDUP_QUIET(driver.config->spiceTLSx509certdir, "/etc/pki/libvirt-spice") < 0)
 516         return EXIT_FAILURE;
 517
 518     if ((driver.caps = testQemuCapsInit()) == NULL)
 519         return EXIT_FAILURE;
 520     if (!(driver.xmlopt = virQEMUDriverCreateXMLConf(&driver)))
 521         return EXIT_FAILURE;
 522     VIR_FREE(driver.config->stateDir);
 523     if (VIR_STRDUP_QUIET(driver.config->stateDir, "/nowhere") < 0)
 524         return EXIT_FAILURE;
 525     VIR_FREE(driver.config->hugetlbfsMount);
 526     if (VIR_STRDUP_QUIET(driver.config->hugetlbfsMount, "/dev/hugepages") < 0)
 527         return EXIT_FAILURE;
 528     VIR_FREE(driver.config->hugepagePath);
 529     if (VIR_STRDUP_QUIET(driver.config->hugepagePath, "/dev/hugepages/libvirt/qemu") < 0)
 530         return EXIT_FAILURE;
 531     driver.config->spiceTLS = 1;
 532     if (VIR_STRDUP_QUIET(driver.config->spicePassword, "123456") < 0)
 533         return EXIT_FAILURE;
 534
 535 # define DO_TEST_FULL(name, migrateFrom, migrateFd, flags, ...)         \
 536     do {                                                                \
 537         static struct testInfo info = {                                 \
 538             name, NULL, migrateFrom, migrateFd, (flags)                 \
 539         };                                                              \
 540         if (!(info.extraFlags = virQEMUCapsNew()))                      \
 541             return EXIT_FAILURE;                                        \
 542         if (testAddCPUModels(info.extraFlags, skipLegacyCPUs) < 0)      \
 543             return EXIT_FAILURE;                                        \
 544         virQEMUCapsSetList(info.extraFlags, __VA_ARGS__, QEMU_CAPS_LAST);\
 545         if (virtTestRun("QEMU XML-2-ARGV " name,                        \
 546                         testCompareXMLToArgvHelper, &info) < 0)         \
 547             ret = -1;                                                   \
 548         virObjectUnref(info.extraFlags);                                \
 549     } while (0)
 550
 551 # define DO_TEST(name, ...)                                             \
 552     DO_TEST_FULL(name, NULL, -1, 0, __VA_ARGS__)
 553
 554 # define DO_TEST_ERROR(name, ...)                                       \
 555     DO_TEST_FULL(name, NULL, -1, FLAG_EXPECT_ERROR, __VA_ARGS__)
 556
 557 # define DO_TEST_FAILURE(name, ...)                                     \
 558     DO_TEST_FULL(name, NULL, -1, FLAG_EXPECT_FAILURE, __VA_ARGS__)
 559
 560 # define DO_TEST_PARSE_ERROR(name, ...)                                 \
 561     DO_TEST_FULL(name, NULL, -1,                                        \
 562                  FLAG_EXPECT_PARSE_ERROR | FLAG_EXPECT_ERROR,           \
 563                  __VA_ARGS__)
 564
 565 # define NONE QEMU_CAPS_LAST
 566
 567     /* Unset or set all envvars here that are copied in qemudBuildCommandLine
 568      * using ADD_ENV_COPY, otherwise these tests may fail due to unexpected
 569      * values for these envvars */
 570     setenv("PATH", "/bin", 1);
 571     setenv("USER", "test", 1);
 572     setenv("LOGNAME", "test", 1);
 573     setenv("HOME", "/home/test", 1);
 574     unsetenv("TMPDIR");
 575     unsetenv("LD_PRELOAD");
 576     unsetenv("LD_LIBRARY_PATH");
 577     unsetenv("QEMU_AUDIO_DRV");
 578     unsetenv("SDL_AUDIODRIVER");
 579
 580     DO_TEST("minimal", QEMU_CAPS_NAME);
 581     DO_TEST("minimal-msg-timestamp", QEMU_CAPS_NAME, QEMU_CAPS_MSG_TIMESTAMP);
 582     DO_TEST("minimal-s390", QEMU_CAPS_NAME);
 583     DO_TEST("machine-aliases1", NONE);
 584     DO_TEST("machine-aliases2", QEMU_CAPS_KVM);
 585     DO_TEST("machine-core-on", QEMU_CAPS_MACHINE_OPT,
 586             QEMU_CAPS_DUMP_GUEST_CORE);
 587     DO_TEST("machine-core-off", QEMU_CAPS_MACHINE_OPT,
 588             QEMU_CAPS_DUMP_GUEST_CORE);
 589     DO_TEST_FAILURE("machine-core-on", NONE);
 590     DO_TEST_FAILURE("machine-core-on", QEMU_CAPS_MACHINE_OPT);
 591     DO_TEST("machine-usb-opt", QEMU_CAPS_MACHINE_OPT,
 592             QEMU_CAPS_MACHINE_USB_OPT);
 593     DO_TEST("kvm", QEMU_CAPS_MACHINE_OPT);
 594     DO_TEST("boot-cdrom", NONE);
 595     DO_TEST("boot-network", NONE);
 596     DO_TEST("boot-floppy", NONE);
 597     DO_TEST("boot-multi", QEMU_CAPS_BOOT_MENU);
 598     DO_TEST("boot-menu-enable",
 599             QEMU_CAPS_BOOT_MENU, QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE);
 600     DO_TEST("boot-menu-enable",
 601             QEMU_CAPS_BOOT_MENU, QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE,
 602             QEMU_CAPS_BOOTINDEX);
 603     DO_TEST("boot-menu-disable", QEMU_CAPS_BOOT_MENU);
 604     DO_TEST("boot-menu-disable-drive",
 605             QEMU_CAPS_BOOT_MENU, QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE);
 606     DO_TEST("boot-menu-disable-drive-bootindex",
 607             QEMU_CAPS_BOOT_MENU, QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE,
 608             QEMU_CAPS_BOOTINDEX);
 609     DO_TEST_PARSE_ERROR("boot-dev+order",
 610             QEMU_CAPS_BOOTINDEX, QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE,
 611             QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
 612     DO_TEST("boot-order",
 613             QEMU_CAPS_BOOTINDEX, QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE,
 614             QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
 615     DO_TEST("boot-complex",
 616             QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT,
 617             QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
 618     DO_TEST("boot-complex-bootindex",
 619             QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT,
 620             QEMU_CAPS_BOOTINDEX,
 621             QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
 622     DO_TEST("boot-strict",
 623             QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT,
 624             QEMU_CAPS_BOOTINDEX, QEMU_CAPS_BOOT_STRICT,
 625             QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
 626     DO_TEST("bootloader", QEMU_CAPS_DOMID, QEMU_CAPS_KVM);
 627
 628     DO_TEST("reboot-timeout-disabled", QEMU_CAPS_REBOOT_TIMEOUT);
 629     DO_TEST("reboot-timeout-enabled", QEMU_CAPS_REBOOT_TIMEOUT);
 630     DO_TEST_FAILURE("reboot-timeout-enabled", NONE);
 631
 632     DO_TEST("bios", QEMU_CAPS_DEVICE, QEMU_CAPS_SGA);
 633     DO_TEST("clock-utc", NONE);
 634     DO_TEST("clock-localtime", NONE);
 635     DO_TEST("clock-localtime-basis-localtime", QEMU_CAPS_RTC);
 636     DO_TEST("clock-variable", QEMU_CAPS_RTC);
 637     DO_TEST("clock-france", QEMU_CAPS_RTC);
 638     DO_TEST("clock-hpet-off", QEMU_CAPS_RTC, QEMU_CAPS_NO_HPET,
 639             QEMU_CAPS_NO_KVM_PIT);
 640     DO_TEST("clock-catchup", QEMU_CAPS_RTC, QEMU_CAPS_NO_KVM_PIT);
 641     DO_TEST("cpu-kvmclock", QEMU_CAPS_ENABLE_KVM);
 642     DO_TEST("cpu-host-kvmclock", QEMU_CAPS_ENABLE_KVM, QEMU_CAPS_CPU_HOST);
 643     DO_TEST("kvmclock", QEMU_CAPS_KVM);
 644     DO_TEST("clock-timer-hyperv-rtc", QEMU_CAPS_KVM);
 645
 646     DO_TEST("cpu-eoi-disabled", QEMU_CAPS_ENABLE_KVM);
 647     DO_TEST("cpu-eoi-enabled", QEMU_CAPS_ENABLE_KVM);
 648     DO_TEST("controller-order", QEMU_CAPS_DRIVE, QEMU_CAPS_PCIDEVICE,
 649             QEMU_CAPS_KVM, QEMU_CAPS_DEVICE, QEMU_CAPS_ENABLE_KVM,
 650             QEMU_CAPS_BOOT_MENU, QEMU_CAPS_PIIX3_USB_UHCI,
 651             QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_DRIVE_AIO,
 652             QEMU_CAPS_CCID_PASSTHRU, QEMU_CAPS_CHARDEV,
 653             QEMU_CAPS_CHARDEV_SPICEVMC, QEMU_CAPS_SPICE, QEMU_CAPS_HDA_DUPLEX);
 654     DO_TEST("eoi-disabled", NONE);
 655     DO_TEST("eoi-enabled", NONE);
 656     DO_TEST("pv-spinlock-disabled", NONE);
 657     DO_TEST("pv-spinlock-enabled", NONE);
 658     DO_TEST("kvmclock+eoi-disabled", QEMU_CAPS_ENABLE_KVM);
 659
 660     DO_TEST("hyperv", NONE);
 661     DO_TEST("hyperv-off", NONE);
 662
 663     DO_TEST("hugepages", QEMU_CAPS_MEM_PATH);
 664     DO_TEST("nosharepages", QEMU_CAPS_MACHINE_OPT, QEMU_CAPS_MEM_MERGE);
 665     DO_TEST("disk-cdrom", NONE);
 666     DO_TEST("disk-cdrom-network-http", QEMU_CAPS_KVM, QEMU_CAPS_DEVICE,
 667             QEMU_CAPS_DRIVE);
 668     DO_TEST("disk-cdrom-network-https", QEMU_CAPS_KVM, QEMU_CAPS_DEVICE,
 669             QEMU_CAPS_DRIVE);
 670     DO_TEST("disk-cdrom-network-ftp", QEMU_CAPS_KVM, QEMU_CAPS_DEVICE,
 671             QEMU_CAPS_DRIVE);
 672     DO_TEST("disk-cdrom-network-ftps", QEMU_CAPS_KVM, QEMU_CAPS_DEVICE,
 673             QEMU_CAPS_DRIVE);
 674     DO_TEST("disk-cdrom-network-tftp", QEMU_CAPS_KVM, QEMU_CAPS_DEVICE,
 675             QEMU_CAPS_DRIVE);
 676     DO_TEST("disk-cdrom-empty", QEMU_CAPS_DRIVE);
 677     DO_TEST("disk-cdrom-tray",
 678             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_VIRTIO_TX_ALG);
 679     DO_TEST("disk-cdrom-tray-no-device-cap", NONE);
 680     DO_TEST("disk-floppy", NONE);
 681     DO_TEST("disk-floppy-tray-no-device-cap", NONE);
 682     DO_TEST("disk-floppy-tray",
 683             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE);
 684     DO_TEST("disk-virtio-s390", QEMU_CAPS_DRIVE,
 685             QEMU_CAPS_DEVICE, QEMU_CAPS_VIRTIO_S390);
 686     DO_TEST("disk-many", NONE);
 687     DO_TEST("disk-virtio", QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT);
 688     DO_TEST("disk-virtio-ccw", QEMU_CAPS_DRIVE,
 689             QEMU_CAPS_DEVICE, QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
 690     DO_TEST("disk-virtio-ccw-many", QEMU_CAPS_DRIVE,
 691             QEMU_CAPS_DEVICE, QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
 692     DO_TEST("disk-virtio-scsi-ccw", QEMU_CAPS_DRIVE, QEMU_CAPS_VIRTIO_SCSI,
 693             QEMU_CAPS_DEVICE, QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
 694     DO_TEST("disk-order",
 695             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE_BOOT,
 696             QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
 697     DO_TEST("disk-xenvbd", QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT);
 698     DO_TEST("disk-drive-boot-disk",
 699             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT);
 700     DO_TEST("disk-drive-boot-cdrom",
 701             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT);
 702     DO_TEST("floppy-drive-fat",
 703             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT, QEMU_CAPS_DRIVE_FORMAT);
 704     DO_TEST("disk-drive-fat",
 705             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT, QEMU_CAPS_DRIVE_FORMAT);
 706     DO_TEST("disk-drive-readonly-disk",
 707             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_READONLY,
 708             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
 709     DO_TEST("disk-drive-readonly-no-device",
 710             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_READONLY, QEMU_CAPS_NODEFCONFIG);
 711     DO_TEST("disk-drive-fmt-qcow",
 712             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT, QEMU_CAPS_DRIVE_FORMAT);
 713     DO_TEST("disk-drive-shared",
 714             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT, QEMU_CAPS_DRIVE_SERIAL);
 715     DO_TEST("disk-drive-cache-v1-wt",
 716             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 717     DO_TEST("disk-drive-cache-v1-wb",
 718             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 719     DO_TEST("disk-drive-cache-v1-none",
 720             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 721     DO_TEST("disk-drive-error-policy-stop",
 722             QEMU_CAPS_DRIVE, QEMU_CAPS_MONITOR_JSON, QEMU_CAPS_DRIVE_FORMAT);
 723     DO_TEST("disk-drive-error-policy-enospace",
 724             QEMU_CAPS_DRIVE, QEMU_CAPS_MONITOR_JSON, QEMU_CAPS_DRIVE_FORMAT);
 725     DO_TEST("disk-drive-error-policy-wreport-rignore",
 726             QEMU_CAPS_DRIVE, QEMU_CAPS_MONITOR_JSON, QEMU_CAPS_DRIVE_FORMAT);
 727     DO_TEST("disk-drive-cache-v2-wt",
 728             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_CACHE_V2, QEMU_CAPS_DRIVE_FORMAT);
 729     DO_TEST("disk-drive-cache-v2-wb",
 730             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_CACHE_V2, QEMU_CAPS_DRIVE_FORMAT);
 731     DO_TEST("disk-drive-cache-v2-none",
 732             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_CACHE_V2, QEMU_CAPS_DRIVE_FORMAT);
 733     DO_TEST("disk-drive-cache-directsync",
 734             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_CACHE_V2,
 735             QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC, QEMU_CAPS_DRIVE_FORMAT);
 736     DO_TEST("disk-drive-cache-unsafe",
 737             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_CACHE_V2,
 738             QEMU_CAPS_DRIVE_CACHE_UNSAFE, QEMU_CAPS_DRIVE_FORMAT);
 739     DO_TEST("disk-drive-copy-on-read",
 740             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_CACHE_V2,
 741             QEMU_CAPS_DRIVE_COPY_ON_READ, QEMU_CAPS_DRIVE_FORMAT);
 742     DO_TEST("disk-drive-network-nbd",
 743             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 744     DO_TEST("disk-drive-network-nbd-export",
 745             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 746     DO_TEST("disk-drive-network-nbd-ipv6",
 747             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 748     DO_TEST("disk-drive-network-nbd-ipv6-export",
 749             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 750     DO_TEST("disk-drive-network-nbd-unix",
 751             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 752     DO_TEST("disk-drive-network-iscsi",
 753             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 754     DO_TEST("disk-drive-network-iscsi-auth",
 755             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 756     DO_TEST("disk-drive-network-iscsi-lun",
 757             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE_FORMAT,
 758             QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_VIRTIO_SCSI,
 759             QEMU_CAPS_VIRTIO_BLK_SG_IO, QEMU_CAPS_SCSI_BLOCK);
 760     DO_TEST("disk-drive-network-gluster",
 761             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 762     DO_TEST("disk-drive-network-rbd",
 763             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 764     DO_TEST("disk-drive-network-sheepdog",
 765             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 766     DO_TEST("disk-drive-network-rbd-auth",
 767             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 768     DO_TEST("disk-drive-network-rbd-ipv6",
 769             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 770     DO_TEST_FAILURE("disk-drive-network-rbd-no-colon",
 771                     QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
 772     DO_TEST("disk-drive-no-boot",
 773             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_BOOTINDEX);
 774     DO_TEST("disk-usb",  NONE);
 775     DO_TEST("disk-usb-device",
 776             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_USB_STORAGE,
 777             QEMU_CAPS_NODEFCONFIG);
 778     DO_TEST("disk-usb-device-removable",
 779             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_USB_STORAGE,
 780             QEMU_CAPS_USB_STORAGE_REMOVABLE, QEMU_CAPS_NODEFCONFIG);
 781     DO_TEST("disk-scsi-device",
 782             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
 783             QEMU_CAPS_SCSI_LSI);
 784     DO_TEST("disk-scsi-device-auto",
 785             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
 786             QEMU_CAPS_SCSI_LSI);
 787     DO_TEST("disk-scsi-disk-split",
 788             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
 789             QEMU_CAPS_SCSI_CD, QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI);
 790     DO_TEST("disk-scsi-disk-wwn",
 791             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
 792             QEMU_CAPS_SCSI_CD, QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI,
 793             QEMU_CAPS_SCSI_DISK_WWN);
 794     DO_TEST("disk-scsi-disk-vpd",
 795             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
 796             QEMU_CAPS_SCSI_CD, QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI,
 797             QEMU_CAPS_SCSI_DISK_WWN);
 798     DO_TEST_FAILURE("disk-scsi-disk-vpd-build-error",
 799             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
 800             QEMU_CAPS_SCSI_CD, QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI,
 801             QEMU_CAPS_SCSI_DISK_WWN);
 802     DO_TEST("disk-scsi-vscsi",
 803             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
 804     DO_TEST("disk-scsi-virtio-scsi",
 805             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
 806             QEMU_CAPS_VIRTIO_SCSI);
 807     DO_TEST("disk-virtio-scsi-num_queues",
 808             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
 809             QEMU_CAPS_VIRTIO_SCSI);
 810     DO_TEST("disk-scsi-megasas",
 811             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
 812             QEMU_CAPS_SCSI_MEGASAS);
 813     DO_TEST("disk-sata-device",
 814             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE,
 815             QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_ICH9_AHCI);
 816     DO_TEST("disk-aio",
 817             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_AIO,
 818             QEMU_CAPS_DRIVE_CACHE_V2, QEMU_CAPS_DRIVE_FORMAT);
 819     DO_TEST("disk-source-pool",
 820             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
 821     DO_TEST("disk-source-pool-mode",
 822             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
 823     DO_TEST("disk-ioeventfd",
 824             QEMU_CAPS_DRIVE, QEMU_CAPS_VIRTIO_IOEVENTFD,
 825             QEMU_CAPS_VIRTIO_TX_ALG, QEMU_CAPS_DEVICE,
 826             QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
 827     DO_TEST("disk-copy_on_read",
 828             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_COPY_ON_READ,
 829             QEMU_CAPS_VIRTIO_TX_ALG, QEMU_CAPS_DEVICE,
 830             QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
 831     DO_TEST("disk-drive-discard",
 832             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_DISCARD,
 833             QEMU_CAPS_DEVICE);
 834     DO_TEST("disk-snapshot",
 835             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_CACHE_V2, QEMU_CAPS_DRIVE_FORMAT);
 836     DO_TEST("event_idx",
 837             QEMU_CAPS_DRIVE,
 838             QEMU_CAPS_VIRTIO_BLK_EVENT_IDX,
 839             QEMU_CAPS_VIRTIO_NET_EVENT_IDX,
 840             QEMU_CAPS_DEVICE,
 841             QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
 842     DO_TEST("virtio-lun",
 843             QEMU_CAPS_DRIVE,
 844             QEMU_CAPS_DEVICE,
 845             QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
 846     DO_TEST("disk-scsi-lun-passthrough",
 847             QEMU_CAPS_DRIVE,
 848             QEMU_CAPS_DEVICE,
 849             QEMU_CAPS_SCSI_BLOCK, QEMU_CAPS_VIRTIO_BLK_SG_IO,
 850             QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI);
 851
 852     DO_TEST("graphics-vnc", QEMU_CAPS_VNC);
 853     DO_TEST("graphics-vnc-socket", QEMU_CAPS_VNC);
 854     DO_TEST("graphics-vnc-websocket", QEMU_CAPS_VNC, QEMU_CAPS_VNC_WEBSOCKET);
 855     DO_TEST("graphics-vnc-policy", QEMU_CAPS_VNC, QEMU_CAPS_VNC_SHARE_POLICY);
 856
 857     driver.config->vncSASL = 1;
 858     VIR_FREE(driver.config->vncSASLdir);
 859     ignore_value(VIR_STRDUP(driver.config->vncSASLdir, "/root/.sasl2"));
 860     DO_TEST("graphics-vnc-sasl", QEMU_CAPS_VNC, QEMU_CAPS_VGA);
 861     driver.config->vncTLS = 1;
 862     driver.config->vncTLSx509verify = 1;
 863     DO_TEST("graphics-vnc-tls", QEMU_CAPS_VNC);
 864     driver.config->vncSASL = driver.config->vncTLSx509verify = driver.config->vncTLS = 0;
 865     VIR_FREE(driver.config->vncSASLdir);
 866     VIR_FREE(driver.config->vncTLSx509certdir);
 867
 868     DO_TEST("graphics-sdl", NONE);
 869     DO_TEST("graphics-sdl-fullscreen", NONE);
 870     DO_TEST("nographics", QEMU_CAPS_VGA);
 871     DO_TEST("nographics-vga",
 872             QEMU_CAPS_VGA, QEMU_CAPS_VGA_NONE);
 873     DO_TEST("graphics-spice",
 874             QEMU_CAPS_VGA, QEMU_CAPS_VGA_QXL,
 875             QEMU_CAPS_DEVICE, QEMU_CAPS_SPICE,
 876             QEMU_CAPS_DEVICE_QXL,
 877             QEMU_CAPS_SPICE_FILE_XFER_DISABLE);
 878     driver.config->spiceSASL = 1;
 879     ignore_value(VIR_STRDUP(driver.config->spiceSASLdir, "/root/.sasl2"));
 880     DO_TEST("graphics-spice-sasl",
 881             QEMU_CAPS_VGA, QEMU_CAPS_VGA_QXL,
 882             QEMU_CAPS_DEVICE, QEMU_CAPS_SPICE,
 883             QEMU_CAPS_DEVICE_QXL);
 884     VIR_FREE(driver.config->spiceSASLdir);
 885     driver.config->spiceSASL = 0;
 886     DO_TEST("graphics-spice-agentmouse",
 887             QEMU_CAPS_VGA, QEMU_CAPS_VGA_QXL,
 888             QEMU_CAPS_DEVICE, QEMU_CAPS_SPICE,
 889             QEMU_CAPS_CHARDEV_SPICEVMC,
 890             QEMU_CAPS_NODEFCONFIG);
 891     DO_TEST("graphics-spice-compression",
 892             QEMU_CAPS_VGA, QEMU_CAPS_VGA_QXL,
 893             QEMU_CAPS_DEVICE, QEMU_CAPS_SPICE,
 894             QEMU_CAPS_DEVICE_QXL);
 895     DO_TEST("graphics-spice-timeout",
 896             QEMU_CAPS_DRIVE,
 897             QEMU_CAPS_VGA, QEMU_CAPS_VGA_QXL,
 898             QEMU_CAPS_DEVICE, QEMU_CAPS_SPICE,
 899             QEMU_CAPS_DEVICE_QXL_VGA);
 900     DO_TEST("graphics-spice-qxl-vga",
 901             QEMU_CAPS_VGA, QEMU_CAPS_VGA_QXL,
 902             QEMU_CAPS_DEVICE, QEMU_CAPS_SPICE,
 903             QEMU_CAPS_DEVICE_QXL_VGA,
 904             QEMU_CAPS_DEVICE_QXL);
 905     DO_TEST("graphics-spice-usb-redir",
 906             QEMU_CAPS_VGA, QEMU_CAPS_SPICE,
 907             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
 908             QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_USB_HUB,
 909             QEMU_CAPS_ICH9_USB_EHCI1, QEMU_CAPS_USB_REDIR,
 910             QEMU_CAPS_CHARDEV_SPICEVMC);
 911     DO_TEST("graphics-spice-agent-file-xfer",
 912             QEMU_CAPS_VGA, QEMU_CAPS_VGA_QXL,
 913             QEMU_CAPS_DEVICE, QEMU_CAPS_SPICE,
 914             QEMU_CAPS_DEVICE_QXL_VGA,
 915             QEMU_CAPS_DEVICE_QXL,
 916             QEMU_CAPS_SPICE_FILE_XFER_DISABLE);
 917
 918     DO_TEST("input-usbmouse", NONE);
 919     DO_TEST("input-usbtablet", NONE);
 920     DO_TEST("input-xen", QEMU_CAPS_DOMID, QEMU_CAPS_KVM, QEMU_CAPS_VNC);
 921     DO_TEST("misc-acpi", NONE);
 922     DO_TEST("misc-disable-s3", QEMU_CAPS_DISABLE_S3);
 923     DO_TEST("misc-disable-suspends", QEMU_CAPS_DISABLE_S3, QEMU_CAPS_DISABLE_S4);
 924     DO_TEST("misc-enable-s4", QEMU_CAPS_DISABLE_S4);
 925     DO_TEST_FAILURE("misc-enable-s4", NONE);
 926     DO_TEST("misc-no-reboot", NONE);
 927     DO_TEST("misc-uuid", QEMU_CAPS_NAME, QEMU_CAPS_UUID);
 928     DO_TEST("net-user", NONE);
 929     DO_TEST("net-virtio", NONE);
 930     DO_TEST("net-virtio-device",
 931             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_VIRTIO_TX_ALG);
 932     DO_TEST("net-virtio-netdev",
 933             QEMU_CAPS_DEVICE, QEMU_CAPS_NETDEV, QEMU_CAPS_NODEFCONFIG);
 934     DO_TEST("net-virtio-s390",
 935             QEMU_CAPS_DEVICE, QEMU_CAPS_VIRTIO_S390);
 936     DO_TEST("net-virtio-ccw",
 937             QEMU_CAPS_DEVICE, QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
 938     DO_TEST("net-eth", NONE);
 939     DO_TEST("net-eth-ifname", NONE);
 940     DO_TEST("net-eth-names", QEMU_CAPS_NET_NAME);
 941     DO_TEST("net-client", NONE);
 942     DO_TEST("net-server", NONE);
 943     DO_TEST("net-mcast", NONE);
 944     DO_TEST("net-hostdev",
 945             QEMU_CAPS_PCIDEVICE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
 946     DO_TEST("net-hostdev-multidomain",
 947             QEMU_CAPS_PCIDEVICE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
 948             QEMU_CAPS_HOST_PCI_MULTIDOMAIN);
 949     DO_TEST_FAILURE("net-hostdev-multidomain",
 950                     QEMU_CAPS_PCIDEVICE, QEMU_CAPS_DEVICE,
 951                     QEMU_CAPS_NODEFCONFIG);
 952     DO_TEST("net-hostdev-vfio",
 953             QEMU_CAPS_PCIDEVICE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
 954             QEMU_CAPS_DEVICE_VFIO_PCI);
 955     DO_TEST("net-hostdev-vfio-multidomain",
 956             QEMU_CAPS_PCIDEVICE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
 957             QEMU_CAPS_DEVICE_VFIO_PCI, QEMU_CAPS_HOST_PCI_MULTIDOMAIN);
 958     DO_TEST_FAILURE("net-hostdev-vfio-multidomain",
 959                     QEMU_CAPS_PCIDEVICE, QEMU_CAPS_DEVICE,
 960                     QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_DEVICE_VFIO_PCI);
 961
 962     DO_TEST("serial-vc", NONE);
 963     DO_TEST("serial-pty", NONE);
 964     DO_TEST("serial-dev", NONE);
 965     DO_TEST("serial-file", NONE);
 966     DO_TEST("serial-unix", NONE);
 967     DO_TEST("serial-tcp", NONE);
 968     DO_TEST("serial-udp", NONE);
 969     DO_TEST("serial-tcp-telnet", NONE);
 970     DO_TEST("serial-many", NONE);
 971     DO_TEST("serial-spiceport",
 972             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE,
 973             QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
 974             QEMU_CAPS_DEVICE_QXL, QEMU_CAPS_DEVICE_QXL_VGA,
 975             QEMU_CAPS_SPICE, QEMU_CAPS_CHARDEV_SPICEPORT);
 976     DO_TEST("serial-spiceport-nospice", QEMU_CAPS_NAME);
 977
 978     DO_TEST("parallel-tcp", NONE);
 979     DO_TEST("console-compat", NONE);
 980     DO_TEST("console-compat-auto", NONE);
 981
 982     DO_TEST("serial-vc-chardev",
 983             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
 984     DO_TEST("serial-pty-chardev",
 985             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
 986     DO_TEST("serial-dev-chardev",
 987             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
 988     DO_TEST("serial-file-chardev",
 989             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
 990     DO_TEST("serial-unix-chardev",
 991             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
 992     DO_TEST("serial-tcp-chardev",
 993             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
 994     DO_TEST("serial-udp-chardev",
 995             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
 996     DO_TEST("serial-tcp-telnet-chardev",
 997             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
 998     DO_TEST("serial-many-chardev",
 999             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1000     DO_TEST("parallel-tcp-chardev",
1001             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1002     DO_TEST("parallel-parport-chardev",
1003             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1004     DO_TEST("console-compat-chardev",
1005             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1006
1007     DO_TEST("channel-guestfwd",
1008             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1009     DO_TEST("channel-virtio",
1010             QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG);
1011     DO_TEST("channel-virtio-auto",
1012             QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG);
1013     DO_TEST("console-virtio",
1014             QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG);
1015     DO_TEST("console-virtio-many",
1016             QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG);
1017     DO_TEST("console-virtio-s390",
1018             QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG,
1019             QEMU_CAPS_DRIVE, QEMU_CAPS_BOOTINDEX, QEMU_CAPS_VIRTIO_S390);
1020     DO_TEST("console-virtio-ccw",
1021             QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG,
1022             QEMU_CAPS_DRIVE, QEMU_CAPS_BOOTINDEX, QEMU_CAPS_VIRTIO_CCW,
1023             QEMU_CAPS_VIRTIO_S390);
1024     DO_TEST("console-sclp",
1025             QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG,
1026             QEMU_CAPS_DRIVE, QEMU_CAPS_VIRTIO_S390, QEMU_CAPS_SCLP_S390);
1027     DO_TEST("channel-spicevmc",
1028             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1029             QEMU_CAPS_SPICE, QEMU_CAPS_CHARDEV_SPICEVMC);
1030     DO_TEST("channel-spicevmc-old",
1031             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1032             QEMU_CAPS_SPICE, QEMU_CAPS_DEVICE_SPICEVMC);
1033
1034     DO_TEST("smartcard-host",
1035             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE,
1036             QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_CCID_EMULATED);
1037     DO_TEST("smartcard-host-certificates",
1038             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE,
1039             QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_CCID_EMULATED);
1040     DO_TEST("smartcard-passthrough-tcp",
1041             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE,
1042             QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_CCID_PASSTHRU);
1043     DO_TEST("smartcard-passthrough-spicevmc",
1044             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1045             QEMU_CAPS_CCID_PASSTHRU, QEMU_CAPS_CHARDEV_SPICEVMC);
1046     DO_TEST("smartcard-controller",
1047             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE,
1048             QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_CCID_EMULATED);
1049
1050     DO_TEST("usb-controller",
1051             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE,
1052             QEMU_CAPS_NODEFCONFIG);
1053     DO_TEST("usb-piix3-controller",
1054             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_PIIX3_USB_UHCI,
1055             QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_NODEFCONFIG);
1056     DO_TEST("usb-ich9-ehci-addr",
1057             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1058             QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_ICH9_USB_EHCI1);
1059     DO_TEST("input-usbmouse-addr",
1060             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1061     DO_TEST("usb-ich9-companion",
1062             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1063             QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_ICH9_USB_EHCI1);
1064     DO_TEST_PARSE_ERROR("usb-ich9-no-companion",
1065             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1066             QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_ICH9_USB_EHCI1);
1067     DO_TEST("usb-hub",
1068             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_USB_HUB,
1069             QEMU_CAPS_NODEFCONFIG);
1070     DO_TEST("usb-ports",
1071             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_USB_HUB,
1072             QEMU_CAPS_NODEFCONFIG);
1073     DO_TEST("usb-redir",
1074             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1075             QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_USB_HUB,
1076             QEMU_CAPS_ICH9_USB_EHCI1, QEMU_CAPS_USB_REDIR,
1077             QEMU_CAPS_SPICE, QEMU_CAPS_CHARDEV_SPICEVMC);
1078     DO_TEST("usb-redir-boot",
1079             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1080             QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_USB_HUB,
1081             QEMU_CAPS_ICH9_USB_EHCI1, QEMU_CAPS_USB_REDIR,
1082             QEMU_CAPS_SPICE, QEMU_CAPS_CHARDEV_SPICEVMC, QEMU_CAPS_BOOTINDEX,
1083             QEMU_CAPS_USB_REDIR_BOOTINDEX);
1084     DO_TEST("usb-redir-filter",
1085             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1086             QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_USB_HUB,
1087             QEMU_CAPS_ICH9_USB_EHCI1, QEMU_CAPS_USB_REDIR,
1088             QEMU_CAPS_SPICE, QEMU_CAPS_CHARDEV_SPICEVMC,
1089             QEMU_CAPS_USB_REDIR_FILTER);
1090     DO_TEST("usb1-usb2",
1091             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1092             QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_PIIX3_USB_UHCI,
1093             QEMU_CAPS_USB_HUB, QEMU_CAPS_ICH9_USB_EHCI1);
1094     DO_TEST("usb-none",
1095             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1096     DO_TEST_PARSE_ERROR("usb-none-other",
1097             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1098     DO_TEST_PARSE_ERROR("usb-none-hub",
1099             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1100             QEMU_CAPS_USB_HUB);
1101     DO_TEST_PARSE_ERROR("usb-none-usbtablet",
1102             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1103
1104
1105     DO_TEST("smbios", QEMU_CAPS_SMBIOS_TYPE);
1106     DO_TEST_PARSE_ERROR("smbios-date", QEMU_CAPS_SMBIOS_TYPE);
1107     DO_TEST_PARSE_ERROR("smbios-uuid-match", QEMU_CAPS_SMBIOS_TYPE);
1108
1109     DO_TEST("watchdog", NONE);
1110     DO_TEST("watchdog-device", QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1111     DO_TEST("watchdog-dump", NONE);
1112     DO_TEST("balloon-device", QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1113     DO_TEST("balloon-device-auto",
1114             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1115     DO_TEST("balloon-device-period", QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1116     DO_TEST("sound", NONE);
1117     DO_TEST("sound-device",
1118             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1119             QEMU_CAPS_HDA_DUPLEX, QEMU_CAPS_HDA_MICRO,
1120             QEMU_CAPS_DEVICE_ICH9_INTEL_HDA);
1121     DO_TEST("fs9p",
1122             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_FSDEV,
1123             QEMU_CAPS_FSDEV_WRITEOUT);
1124
1125     DO_TEST("hostdev-usb-address", NONE);
1126     DO_TEST("hostdev-usb-address-device",
1127             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1128     DO_TEST("hostdev-usb-address-device-boot", QEMU_CAPS_DEVICE,
1129             QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_BOOTINDEX,
1130             QEMU_CAPS_USB_HOST_BOOTINDEX);
1131     DO_TEST("hostdev-pci-address", QEMU_CAPS_PCIDEVICE);
1132     DO_TEST("hostdev-pci-address-device",
1133             QEMU_CAPS_PCIDEVICE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1134     DO_TEST("hostdev-vfio",
1135             QEMU_CAPS_PCIDEVICE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1136             QEMU_CAPS_DEVICE_VFIO_PCI);
1137     DO_TEST("hostdev-vfio-multidomain",
1138             QEMU_CAPS_PCIDEVICE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1139             QEMU_CAPS_DEVICE_VFIO_PCI, QEMU_CAPS_HOST_PCI_MULTIDOMAIN);
1140     DO_TEST_FAILURE("hostdev-vfio-multidomain",
1141                     QEMU_CAPS_PCIDEVICE, QEMU_CAPS_DEVICE,
1142                     QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_DEVICE_VFIO_PCI);
1143     DO_TEST("pci-rom",
1144             QEMU_CAPS_PCIDEVICE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1145             QEMU_CAPS_PCI_ROMBAR);
1146
1147     DO_TEST_FULL("restore-v1", "stdio", 7, 0, QEMU_CAPS_MIGRATE_KVM_STDIO);
1148     DO_TEST_FULL("restore-v2", "stdio", 7, 0, QEMU_CAPS_MIGRATE_QEMU_EXEC);
1149     DO_TEST_FULL("restore-v2", "exec:cat", 7, 0, QEMU_CAPS_MIGRATE_QEMU_EXEC);
1150     DO_TEST_FULL("restore-v2-fd", "stdio", 7, 0, QEMU_CAPS_MIGRATE_QEMU_FD);
1151     DO_TEST_FULL("restore-v2-fd", "fd:7", 7, 0, QEMU_CAPS_MIGRATE_QEMU_FD);
1152     DO_TEST_FULL("migrate", "tcp:10.0.0.1:5000", -1, 0,
1153             QEMU_CAPS_MIGRATE_QEMU_TCP);
1154
1155     DO_TEST("qemu-ns", NONE);
1156
1157     DO_TEST("smp", QEMU_CAPS_SMP_TOPOLOGY);
1158
1159     DO_TEST("cpu-topology1", QEMU_CAPS_SMP_TOPOLOGY);
1160     DO_TEST("cpu-topology2", QEMU_CAPS_SMP_TOPOLOGY);
1161     DO_TEST("cpu-topology3", NONE);
1162     DO_TEST("cpu-minimum1", NONE);
1163     DO_TEST("cpu-minimum2", NONE);
1164     DO_TEST("cpu-exact1", NONE);
1165     DO_TEST("cpu-exact2", NONE);
1166     DO_TEST("cpu-exact2-nofallback", NONE);
1167     DO_TEST("cpu-fallback", NONE);
1168     DO_TEST_FAILURE("cpu-nofallback", NONE);
1169     DO_TEST("cpu-strict1", NONE);
1170     DO_TEST("cpu-numa1", NONE);
1171     DO_TEST("cpu-numa2", QEMU_CAPS_SMP_TOPOLOGY);
1172     DO_TEST("cpu-host-model", NONE);
1173     skipLegacyCPUs = true;
1174     DO_TEST("cpu-host-model-fallback", NONE);
1175     DO_TEST_FAILURE("cpu-host-model-nofallback", NONE);
1176     skipLegacyCPUs = false;
1177     DO_TEST("cpu-host-passthrough", QEMU_CAPS_KVM, QEMU_CAPS_CPU_HOST);
1178     DO_TEST_FAILURE("cpu-host-passthrough", NONE);
1179     DO_TEST_FAILURE("cpu-qemu-host-passthrough",
1180                     QEMU_CAPS_KVM, QEMU_CAPS_CPU_HOST);
1181
1182     DO_TEST("memtune", QEMU_CAPS_NAME);
1183     DO_TEST("memtune-unlimited", QEMU_CAPS_NAME);
1184     DO_TEST("blkiotune", QEMU_CAPS_NAME);
1185     DO_TEST("blkiotune-device", QEMU_CAPS_NAME);
1186     DO_TEST("cputune", QEMU_CAPS_NAME);
1187     DO_TEST("cputune-zero-shares", QEMU_CAPS_NAME);
1188     DO_TEST("numatune-memory", NONE);
1189     DO_TEST("numatune-auto-nodeset-invalid", NONE);
1190     DO_TEST("numad", NONE);
1191     DO_TEST("numad-auto-vcpu-static-numatune", NONE);
1192     DO_TEST("numad-auto-memory-vcpu-cpuset", NONE);
1193     DO_TEST("numad-auto-memory-vcpu-no-cpuset-and-placement", NONE);
1194     DO_TEST("numad-static-memory-auto-vcpu", NONE);
1195     DO_TEST("blkdeviotune", QEMU_CAPS_NAME, QEMU_CAPS_DEVICE,
1196             QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_IOTUNE);
1197
1198     DO_TEST("multifunction-pci-device",
1199             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1200             QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_SCSI_LSI);
1201
1202     DO_TEST("monitor-json", QEMU_CAPS_DEVICE,
1203             QEMU_CAPS_CHARDEV, QEMU_CAPS_MONITOR_JSON, QEMU_CAPS_NODEFCONFIG);
1204     DO_TEST("no-shutdown", QEMU_CAPS_DEVICE,
1205             QEMU_CAPS_CHARDEV, QEMU_CAPS_MONITOR_JSON, QEMU_CAPS_NODEFCONFIG,
1206             QEMU_CAPS_NO_SHUTDOWN);
1207
1208     DO_TEST("seclabel-dynamic", QEMU_CAPS_NAME);
1209     DO_TEST("seclabel-dynamic-baselabel", QEMU_CAPS_NAME);
1210     DO_TEST("seclabel-dynamic-override", QEMU_CAPS_NAME);
1211     DO_TEST("seclabel-dynamic-labelskip", QEMU_CAPS_NAME);
1212     DO_TEST("seclabel-dynamic-relabel", QEMU_CAPS_NAME);
1213     DO_TEST("seclabel-static", QEMU_CAPS_NAME);
1214     DO_TEST("seclabel-static-relabel", QEMU_CAPS_NAME);
1215     DO_TEST("seclabel-static-labelskip", QEMU_CAPS_NAME);
1216     DO_TEST("seclabel-none", QEMU_CAPS_NAME);
1217
1218     DO_TEST("pseries-basic",
1219             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1220     DO_TEST("pseries-vio", QEMU_CAPS_DRIVE,
1221             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1222     DO_TEST("pseries-usb-default", QEMU_CAPS_DRIVE,
1223             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE,
1224             QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_PIIX3_USB_UHCI,
1225             QEMU_CAPS_PCI_OHCI, QEMU_CAPS_PCI_MULTIFUNCTION);
1226     DO_TEST("pseries-usb-multi", QEMU_CAPS_DRIVE,
1227             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE,
1228             QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_PIIX3_USB_UHCI,
1229             QEMU_CAPS_PCI_OHCI, QEMU_CAPS_PCI_MULTIFUNCTION);
1230     DO_TEST("pseries-vio-user-assigned", QEMU_CAPS_DRIVE,
1231             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1232     DO_TEST_ERROR("pseries-vio-address-clash", QEMU_CAPS_DRIVE,
1233             QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1234     DO_TEST("pseries-nvram", QEMU_CAPS_DEVICE_NVRAM);
1235     DO_TEST("pseries-usb-kbd", QEMU_CAPS_PCI_OHCI,
1236             QEMU_CAPS_DEVICE_USB_KBD, QEMU_CAPS_CHARDEV,
1237             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1238     DO_TEST_FAILURE("pseries-cpu-exact", QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1239     DO_TEST("disk-ide-drive-split",
1240             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1241             QEMU_CAPS_IDE_CD);
1242     DO_TEST("disk-ide-wwn",
1243             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_IDE_CD,
1244             QEMU_CAPS_DRIVE_SERIAL, QEMU_CAPS_IDE_DRIVE_WWN);
1245
1246     DO_TEST("disk-geometry", QEMU_CAPS_DRIVE);
1247     DO_TEST("disk-blockio",
1248             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1249             QEMU_CAPS_IDE_CD, QEMU_CAPS_BLOCKIO);
1250
1251     DO_TEST("video-device-pciaddr-default",
1252             QEMU_CAPS_KVM, QEMU_CAPS_VNC,
1253             QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
1254             QEMU_CAPS_DEVICE_QXL, QEMU_CAPS_DEVICE_QXL_VGA,
1255             QEMU_CAPS_DEVICE_PCI_BRIDGE);
1256
1257     DO_TEST("virtio-rng-default", QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_VIRTIO_RNG,
1258             QEMU_CAPS_OBJECT_RNG_RANDOM);
1259     DO_TEST("virtio-rng-random", QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_VIRTIO_RNG,
1260             QEMU_CAPS_OBJECT_RNG_RANDOM);
1261     DO_TEST("virtio-rng-egd", QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_VIRTIO_RNG,
1262             QEMU_CAPS_OBJECT_RNG_EGD);
1263     DO_TEST_PARSE_ERROR("virtio-rng-egd-crash", QEMU_CAPS_DEVICE,
1264             QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_EGD);
1265     DO_TEST("virtio-rng-ccw",
1266             QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG,
1267             QEMU_CAPS_DRIVE, QEMU_CAPS_BOOTINDEX, QEMU_CAPS_VIRTIO_CCW,
1268             QEMU_CAPS_VIRTIO_S390, QEMU_CAPS_DEVICE_VIRTIO_RNG,
1269             QEMU_CAPS_OBJECT_RNG_RANDOM);
1270
1271     DO_TEST("s390-usb-none",
1272             QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG,
1273             QEMU_CAPS_DRIVE, QEMU_CAPS_BOOTINDEX, QEMU_CAPS_VIRTIO_S390,
1274             QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
1275
1276     DO_TEST("s390-piix-controllers",
1277             QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG,
1278             QEMU_CAPS_DRIVE, QEMU_CAPS_BOOTINDEX, QEMU_CAPS_VIRTIO_S390,
1279             QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
1280
1281     DO_TEST("ppc-dtb", QEMU_CAPS_KVM, QEMU_CAPS_DTB);
1282     DO_TEST("ppce500-serial", QEMU_CAPS_KVM, QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV);
1283
1284     DO_TEST("tpm-passthrough", QEMU_CAPS_DEVICE,
1285             QEMU_CAPS_DEVICE_TPM_PASSTHROUGH, QEMU_CAPS_DEVICE_TPM_TIS);
1286     DO_TEST_PARSE_ERROR("tpm-no-backend-invalid", QEMU_CAPS_DEVICE,
1287                         QEMU_CAPS_DEVICE_TPM_PASSTHROUGH, QEMU_CAPS_DEVICE_TPM_TIS);
1288
1289     DO_TEST("pci-autoadd-addr", QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_PCI_BRIDGE);
1290     DO_TEST("pci-autoadd-idx", QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_PCI_BRIDGE);
1291     DO_TEST("pci-bridge-many-disks",
1292             QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE_PCI_BRIDGE);
1293     DO_TEST("pcie-root",
1294             QEMU_CAPS_ICH9_AHCI,
1295             QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_PCI_BRIDGE,
1296             QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE);
1297     DO_TEST("q35",
1298             QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_PCI_BRIDGE,
1299             QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
1300             QEMU_CAPS_DRIVE, QEMU_CAPS_ICH9_AHCI,
1301             QEMU_CAPS_VGA, QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
1302             QEMU_CAPS_VGA, QEMU_CAPS_VGA_QXL, QEMU_CAPS_DEVICE_QXL);
1303
1304     DO_TEST("hostdev-scsi-lsi", QEMU_CAPS_DRIVE,
1305             QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE,
1306             QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
1307             QEMU_CAPS_DEVICE_SCSI_GENERIC);
1308     DO_TEST("hostdev-scsi-virtio-scsi", QEMU_CAPS_DRIVE,
1309             QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE,
1310             QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_VIRTIO_SCSI,
1311             QEMU_CAPS_DEVICE_SCSI_GENERIC);
1312     DO_TEST("hostdev-scsi-readonly", QEMU_CAPS_DRIVE,
1313             QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE,
1314             QEMU_CAPS_DRIVE_READONLY, QEMU_CAPS_VIRTIO_SCSI,
1315             QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_SCSI_GENERIC);
1316     DO_TEST("hostdev-scsi-virtio-scsi", QEMU_CAPS_DRIVE,
1317             QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE,
1318             QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_VIRTIO_SCSI,
1319             QEMU_CAPS_DEVICE_SCSI_GENERIC,
1320             QEMU_CAPS_DEVICE_SCSI_GENERIC_BOOTINDEX);
1321
1322     DO_TEST("mlock-on", QEMU_CAPS_MLOCK);
1323     DO_TEST_FAILURE("mlock-on", NONE);
1324     DO_TEST("mlock-off", QEMU_CAPS_MLOCK);
1325     DO_TEST("mlock-unsupported", NONE);
1326
1327     DO_TEST_PARSE_ERROR("pci-bridge-negative-index-invalid",
1328                         QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_PCI_BRIDGE);
1329     DO_TEST_PARSE_ERROR("pci-bridge-duplicate-index",
1330                         QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_PCI_BRIDGE);
1331     DO_TEST_PARSE_ERROR("pci-root-nonzero-index",
1332                         QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_PCI_BRIDGE);
1333     DO_TEST_PARSE_ERROR("pci-root-address",
1334                         QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_PCI_BRIDGE);
1335
1336     DO_TEST("hotplug-base",
1337             QEMU_CAPS_KVM, QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE,
1338             QEMU_CAPS_VIRTIO_SCSI);
1339
1340     DO_TEST("pcihole64", QEMU_CAPS_DEVICE, QEMU_CAPS_I440FX_PCI_HOLE64_SIZE);
1341     DO_TEST_FAILURE("pcihole64-none", QEMU_CAPS_DEVICE);
1342     DO_TEST("pcihole64-q35",
1343             QEMU_CAPS_DEVICE, QEMU_CAPS_DEVICE_PCI_BRIDGE,
1344             QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
1345             QEMU_CAPS_DRIVE, QEMU_CAPS_ICH9_AHCI,
1346             QEMU_CAPS_VGA, QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
1347             QEMU_CAPS_VGA_QXL, QEMU_CAPS_DEVICE_QXL,
1348             QEMU_CAPS_Q35_PCI_HOLE64_SIZE);
1349
1350     DO_TEST("arm-vexpressa9-nodevs",
1351             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_DTB);
1352     DO_TEST("arm-vexpressa9-basic",
1353             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_DTB,
1354             QEMU_CAPS_DRIVE);
1355     DO_TEST("arm-vexpressa9-virtio",
1356             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_DTB,
1357             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE_VIRTIO_MMIO,
1358             QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
1359     DO_TEST("arm-virt-virtio",
1360             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_DTB,
1361             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE_VIRTIO_MMIO,
1362             QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
1363
1364     DO_TEST("aarch64-virt-virtio",
1365             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_DTB,
1366             QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE_VIRTIO_MMIO,
1367             QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
1368     DO_TEST("aarch64-virt-default-nic",
1369             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
1370             QEMU_CAPS_DEVICE_VIRTIO_MMIO);
1371
1372     DO_TEST("kvm-pit-device", QEMU_CAPS_KVM_PIT_TICK_POLICY);
1373     DO_TEST("kvm-pit-delay", QEMU_CAPS_NO_KVM_PIT);
1374     DO_TEST("kvm-pit-device", QEMU_CAPS_NO_KVM_PIT,
1375             QEMU_CAPS_KVM_PIT_TICK_POLICY);
1376
1377     DO_TEST("panic", QEMU_CAPS_DEVICE_PANIC,
1378             QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
1379
1380     virObjectUnref(driver.config);
1381     virObjectUnref(driver.caps);
1382     virObjectUnref(driver.xmlopt);
1383
1384     return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1385 }
1386
1387 VIRT_TEST_MAIN_PRELOAD(mymain, abs_builddir "/.libs/qemuxml2argvmock.so")
1388
1389 #else
1390
1391 int main(void)
1392 {
1393     return EXIT_AM_SKIP;
1394 }
1395
1396 #endif /* WITH_QEMU */