tests/qemuxmlconftest.c

   1 #include <config.h>
   2
   3 #include <unistd.h>
   4
   5 #include <sys/types.h>
   6 #include <fcntl.h>
   7
   8 #include "testutils.h"
   9
  10 #ifdef WITH_QEMU
  11
  12 # include "internal.h"
  13 # include "viralloc.h"
  14 # include "viridentity.h"
  15 # include "qemu/qemu_block.h"
  16 # include "qemu/qemu_capabilities.h"
  17 # include "qemu/qemu_domain.h"
  18 # include "qemu/qemu_migration.h"
  19 # include "qemu/qemu_process.h"
  20 # include "qemu/qemu_slirp.h"
  21 # include "datatypes.h"
  22 # include "conf/storage_conf.h"
  23 # include "virfilewrapper.h"
  24 # include "configmake.h"
  25 # include "testutilsqemuschema.h"
  26
  27 # define LIBVIRT_QEMU_CAPSPRIV_H_ALLOW
  28 # include "qemu/qemu_capspriv.h"
  29
  30 # include "testutilsqemu.h"
  31
  32 # define VIR_FROM_THIS VIR_FROM_QEMU
  33
  34 static virQEMUDriver driver;
  35
  36 static unsigned char *
  37 fakeSecretGetValue(virSecretPtr obj G_GNUC_UNUSED,
  38                    size_t *value_size,
  39                    unsigned int fakeflags G_GNUC_UNUSED)
  40 {
  41     char *secret;
  42     secret = g_strdup("AQCVn5hO6HzFAhAAq0NCv8jtJcIcE+HOBlMQ1A");
  43     *value_size = strlen(secret);
  44     return (unsigned char *) secret;
  45 }
  46
  47 static virSecretPtr
  48 fakeSecretLookupByUsage(virConnectPtr conn,
  49                         int usageType,
  50                         const char *usageID)
  51 {
  52     unsigned char uuid[VIR_UUID_BUFLEN];
  53     if (usageType == VIR_SECRET_USAGE_TYPE_VOLUME) {
  54         if (!STRPREFIX(usageID, "/storage/guest_disks/")) {
  55             virReportError(VIR_ERR_INTERNAL_ERROR,
  56                            "test provided invalid volume storage prefix '%s'",
  57                            usageID);
  58             return NULL;
  59         }
  60     } else if (STRNEQ(usageID, "mycluster_myname") &&
  61                STRNEQ(usageID, "client.admin secret")) {
  62         virReportError(VIR_ERR_INTERNAL_ERROR,
  63                        "test provided incorrect usage '%s'", usageID);
  64         return NULL;
  65     }
  66
  67     if (virUUIDGenerate(uuid) < 0)
  68         return NULL;
  69
  70     return virGetSecret(conn, uuid, usageType, usageID);
  71 }
  72
  73 static virSecretPtr
  74 fakeSecretLookupByUUID(virConnectPtr conn,
  75                        const unsigned char *uuid)
  76 {
  77     /* NB: This mocked value could be "tls" or "volume" depending on
  78      * which test is being run, we'll leave at NONE (or 0) */
  79     return virGetSecret(conn, uuid, VIR_SECRET_USAGE_TYPE_NONE, "");
  80 }
  81
  82 static virSecretDriver fakeSecretDriver = {
  83     .connectNumOfSecrets = NULL,
  84     .connectListSecrets = NULL,
  85     .secretLookupByUUID = fakeSecretLookupByUUID,
  86     .secretLookupByUsage = fakeSecretLookupByUsage,
  87     .secretDefineXML = NULL,
  88     .secretGetXMLDesc = NULL,
  89     .secretSetValue = NULL,
  90     .secretGetValue = fakeSecretGetValue,
  91     .secretUndefine = NULL,
  92 };
  93
  94
  95 # define STORAGE_POOL_XML_PATH "storagepoolxml2xmlout/"
  96 static const unsigned char fakeUUID[VIR_UUID_BUFLEN] = "fakeuuid";
  97
  98 static virStoragePoolPtr
  99 fakeStoragePoolLookupByName(virConnectPtr conn,
 100                             const char *name)
 101 {
 102     g_autofree char *xmlpath = NULL;
 103
 104     if (STRNEQ(name, "inactive")) {
 105         xmlpath = g_strdup_printf("%s/%s%s.xml", abs_srcdir,
 106                                   STORAGE_POOL_XML_PATH, name);
 107
 108         if (!virFileExists(xmlpath)) {
 109             virReportError(VIR_ERR_NO_STORAGE_POOL,
 110                            "File '%s' not found", xmlpath);
 111             return NULL;
 112         }
 113     }
 114
 115     return virGetStoragePool(conn, name, fakeUUID, NULL, NULL);
 116 }
 117
 118
 119 static virStorageVolPtr
 120 fakeStorageVolLookupByName(virStoragePoolPtr pool,
 121                            const char *name)
 122 {
 123     g_auto(GStrv) volinfo = NULL;
 124
 125     if (STREQ(pool->name, "inactive")) {
 126         virReportError(VIR_ERR_OPERATION_INVALID,
 127                        "storage pool '%s' is not active", pool->name);
 128         return NULL;
 129     }
 130
 131     if (STREQ(name, "nonexistent")) {
 132         virReportError(VIR_ERR_NO_STORAGE_VOL,
 133                        "no storage vol with matching name '%s'", name);
 134         return NULL;
 135     }
 136
 137     if (!(volinfo = g_strsplit(name, "+", 2)))
 138         return NULL;
 139
 140     if (!volinfo[1]) {
 141         return virGetStorageVol(pool->conn, pool->name, name, "block", NULL, NULL);
 142     }
 143
 144     return virGetStorageVol(pool->conn, pool->name, volinfo[1], volinfo[0],
 145                            NULL, NULL);
 146 }
 147
 148 static int
 149 fakeStorageVolGetInfo(virStorageVolPtr vol,
 150                       virStorageVolInfoPtr info)
 151 {
 152     memset(info, 0, sizeof(*info));
 153
 154     info->type = virStorageVolTypeFromString(vol->key);
 155
 156     if (info->type < 0) {
 157         virReportError(VIR_ERR_INTERNAL_ERROR,
 158                        "Invalid volume type '%s'", vol->key);
 159         return -1;
 160     }
 161
 162     return 0;
 163 }
 164
 165
 166 static char *
 167 fakeStorageVolGetPath(virStorageVolPtr vol)
 168 {
 169     return g_strdup_printf("/some/%s/device/%s", vol->key, vol->name);
 170 }
 171
 172
 173 static char *
 174 fakeStoragePoolGetXMLDesc(virStoragePoolPtr pool,
 175                           unsigned int flags_unused G_GNUC_UNUSED)
 176 {
 177     g_autofree char *xmlpath = NULL;
 178     char *xmlbuf = NULL;
 179
 180     if (STREQ(pool->name, "inactive")) {
 181         virReportError(VIR_ERR_NO_STORAGE_POOL, NULL);
 182         return NULL;
 183     }
 184
 185     xmlpath = g_strdup_printf("%s/%s%s.xml", abs_srcdir, STORAGE_POOL_XML_PATH,
 186                               pool->name);
 187
 188     if (virTestLoadFile(xmlpath, &xmlbuf) < 0) {
 189         virReportError(VIR_ERR_INTERNAL_ERROR,
 190                        "failed to load XML file '%s'",
 191                        xmlpath);
 192         return NULL;
 193     }
 194
 195     return xmlbuf;
 196 }
 197
 198 static int
 199 fakeStoragePoolIsActive(virStoragePoolPtr pool)
 200 {
 201     if (STREQ(pool->name, "inactive"))
 202         return 0;
 203
 204     return 1;
 205 }
 206
 207 /* Test storage pool implementation
 208  *
 209  * These functions aid testing of storage pool related stuff when creating a
 210  * qemu command line.
 211  *
 212  * There are a few "magic" values to pass to these functions:
 213  *
 214  * 1) "inactive" as a pool name to create an inactive pool. All other names are
 215  * interpreted as file names in storagepoolxml2xmlout/ and are used as the
 216  * definition for the pool. If the file doesn't exist the pool doesn't exist.
 217  *
 218  * 2) "nonexistent" returns an error while looking up a volume. Otherwise
 219  * pattern VOLUME_TYPE+VOLUME_PATH can be used to simulate a volume in a pool.
 220  * This creates a fake path for this volume. If the '+' sign is omitted, block
 221  * type is assumed.
 222  */
 223 static virStorageDriver fakeStorageDriver = {
 224     .storagePoolLookupByName = fakeStoragePoolLookupByName,
 225     .storageVolLookupByName = fakeStorageVolLookupByName,
 226     .storagePoolGetXMLDesc = fakeStoragePoolGetXMLDesc,
 227     .storageVolGetPath = fakeStorageVolGetPath,
 228     .storageVolGetInfo = fakeStorageVolGetInfo,
 229     .storagePoolIsActive = fakeStoragePoolIsActive,
 230 };
 231
 232
 233 /* virNetDevOpenvswitchGetVhostuserIfname mocks a portdev name - handle that */
 234 static virNWFilterBindingPtr
 235 fakeNWFilterBindingLookupByPortDev(virConnectPtr conn,
 236                                    const char *portdev)
 237 {
 238     if (STREQ(portdev, "vhost-user0"))
 239         return virGetNWFilterBinding(conn, "fake_vnet0", "fakeFilterName");
 240
 241     virReportError(VIR_ERR_NO_NWFILTER_BINDING,
 242                    "no nwfilter binding for port dev '%s'", portdev);
 243     return NULL;
 244 }
 245
 246
 247 static int
 248 fakeNWFilterBindingDelete(virNWFilterBindingPtr binding G_GNUC_UNUSED)
 249 {
 250     return 0;
 251 }
 252
 253
 254 static virNWFilterDriver fakeNWFilterDriver = {
 255     .nwfilterBindingLookupByPortDev = fakeNWFilterBindingLookupByPortDev,
 256     .nwfilterBindingDelete = fakeNWFilterBindingDelete,
 257 };
 258
 259
 260 /* name of the fake network shall be constructed as:
 261  *  NETWORKXMLNAME;NETWORKPORTXMLNAME
 262  *  where:
 263  *  NETWORKXMLNAME resolves to abs_srcdir/networkxml2xmlin/NETWORKXMLNAME.xml
 264  *  NETWORKPORTXMLNAME resolves to abs_srcdir/virnetworkportxml2xmldata/NETWORKPORTXMLNAME.xml
 265  */
 266 static virNetworkPtr
 267 fakeNetworkLookupByName(virConnectPtr conn,
 268                         const char *name)
 269 {
 270     unsigned char uuid[VIR_UUID_BUFLEN];
 271     g_autofree char *netname = g_strdup(name);
 272     g_autofree char *path = NULL;
 273     char *tmp;
 274
 275     memset(uuid, 0, VIR_UUID_BUFLEN);
 276
 277     if ((tmp = strchr(netname, ';'))) {
 278         *tmp = '\0';
 279     } else {
 280         virReportError(VIR_ERR_NO_NETWORK,
 281                        "Malformed fake network name '%s'. See fakeNetworkLookupByName.",
 282                        name);
 283         return NULL;
 284     }
 285
 286     path = g_strdup_printf(abs_srcdir "/networkxml2xmlin/%s.xml", netname);
 287
 288     if (!virFileExists(path)) {
 289         virReportError(VIR_ERR_NO_NETWORK, "fake network '%s' not found", path);
 290         return NULL;
 291     }
 292
 293     return virGetNetwork(conn, name, uuid);
 294 }
 295
 296
 297 static char *
 298 fakeNetworkGetXMLDesc(virNetworkPtr network,
 299                       unsigned int noflags G_GNUC_UNUSED)
 300 {
 301     g_autofree char *netname = g_strdup(network->name);
 302     g_autofree char *path = NULL;
 303     char *xml = NULL;
 304
 305     *(strchr(netname, ';')) = '\0';
 306
 307     path = g_strdup_printf(abs_srcdir "/networkxml2xmlin/%s.xml", netname);
 308
 309     if (virFileReadAll(path, 4 * 1024, &xml) < 0)
 310         return NULL;
 311
 312     return xml;
 313 }
 314
 315
 316 static virNetworkPortPtr
 317 fakeNetworkPortCreateXML(virNetworkPtr net,
 318                          const char *xmldesc G_GNUC_UNUSED,
 319                          unsigned int noflags G_GNUC_UNUSED)
 320 {
 321     unsigned char uuid[VIR_UUID_BUFLEN];
 322     g_autofree char *portname = g_strdup(strchr(net->name, ';') + 1);
 323     g_autofree char *path = g_strdup_printf(abs_srcdir "/virnetworkportxml2xmldata/%s.xml", portname);
 324
 325     memset(uuid, 0, VIR_UUID_BUFLEN);
 326
 327     if (!virFileExists(path)) {
 328         virReportError(VIR_ERR_NO_NETWORK_PORT, "fake network port '%s' not found", path);
 329         return NULL;
 330     }
 331
 332     return virGetNetworkPort(net, uuid);
 333 }
 334
 335
 336 static char *
 337 fakeNetworkPortGetXMLDesc(virNetworkPortPtr port,
 338                           unsigned int noflags G_GNUC_UNUSED)
 339 {
 340     g_autofree char *portname = g_strdup(strchr(port->net->name, ';') + 1);
 341     g_autofree char *path = g_strdup_printf(abs_srcdir "/virnetworkportxml2xmldata/%s.xml", portname);
 342     char *xml = NULL;
 343
 344     if (virFileReadAll(path, 4 * 1024, &xml) < 0)
 345         return NULL;
 346
 347     return xml;
 348 }
 349
 350
 351 static virNetworkDriver fakeNetworkDriver = {
 352     .networkLookupByName = fakeNetworkLookupByName,
 353     .networkGetXMLDesc = fakeNetworkGetXMLDesc,
 354     .networkPortCreateXML = fakeNetworkPortCreateXML,
 355     .networkPortGetXMLDesc = fakeNetworkPortGetXMLDesc,
 356 };
 357
 358
 359 static void
 360 testUpdateQEMUCapsHostCPUModel(virQEMUCaps *qemuCaps, virArch hostArch)
 361 {
 362     virQEMUCapsUpdateHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
 363     virQEMUCapsUpdateHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_QEMU);
 364 }
 365
 366
 367 static int
 368 testCheckExclusiveFlags(int flags)
 369 {
 370     virCheckFlags(FLAG_EXPECT_FAILURE |
 371                   FLAG_EXPECT_PARSE_ERROR |
 372                   FLAG_REAL_CAPS |
 373                   FLAG_SLIRP_HELPER |
 374                   FLAG_ALLOW_DUPLICATE_OUTPUT |
 375                   FLAG_ALLOW_MISSING_INPUT |
 376                   0, -1);
 377
 378     return 0;
 379 }
 380
 381
 382 static virCommand *
 383 testCompareXMLToArgvCreateArgs(virQEMUDriver *drv,
 384                                virDomainObj *vm,
 385                                const char *migrateURI,
 386                                testQemuInfo *info,
 387                                unsigned int flags)
 388 {
 389     qemuDomainObjPrivate *priv = vm->privateData;
 390     size_t i;
 391
 392     if (qemuProcessCreatePretendCmdPrepare(drv, vm, migrateURI,
 393                                            VIR_QEMU_PROCESS_START_COLD) < 0)
 394         return NULL;
 395
 396     if (qemuDomainDeviceBackendChardevForeach(vm->def,
 397                                               testQemuPrepareHostBackendChardevOne,
 398                                               vm) < 0)
 399         return NULL;
 400
 401     if (testQemuPrepareHostBackendChardevOne(NULL, priv->monConfig, vm) < 0)
 402         return NULL;
 403
 404     for (i = 0; i < vm->def->ndisks; i++) {
 405         virDomainDiskDef *disk = vm->def->disks[i];
 406         virStorageSource *src;
 407
 408         /* host cdrom requires special treatment in qemu, mock it */
 409         if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM &&
 410             disk->src->format == VIR_STORAGE_FILE_RAW &&
 411             virStorageSourceIsBlockLocal(disk->src) &&
 412             STREQ(disk->src->path, "/dev/cdrom"))
 413             disk->src->hostcdrom = true;
 414
 415         if (info->args.vdpafds) {
 416             for (src = disk->src; virStorageSourceIsBacking(src); src = src->backingStore) {
 417                 gpointer value;
 418
 419                 if (src->type != VIR_STORAGE_TYPE_VHOST_VDPA)
 420                     continue;
 421
 422                 if ((value = g_hash_table_lookup(info->args.vdpafds, src->vdpadev))) {
 423                     int fd = GPOINTER_TO_INT(value);
 424                     qemuDomainStorageSourcePrivate *srcpriv;
 425                     VIR_AUTOCLOSE fakefd = open("/dev/zero", O_RDWR);
 426
 427                     if (fcntl(fd, F_GETFD) != -1) {
 428                         fprintf(stderr, "fd '%d' is already in use\n", fd);
 429                         abort();
 430                     }
 431
 432                     if (dup2(fakefd, fd) < 0) {
 433                         fprintf(stderr, "failed to duplicate fake fd: %s",
 434                                 g_strerror(errno));
 435                         abort();
 436                     }
 437
 438                     srcpriv = qemuDomainStorageSourcePrivateFetch(src);
 439
 440                     srcpriv->fdpass = qemuFDPassNew(qemuBlockStorageSourceGetStorageNodename(src), priv);
 441                     qemuFDPassAddFD(srcpriv->fdpass, &fd, "-vdpa");
 442                 }
 443             }
 444         }
 445     }
 446
 447     if (vm->def->vsock) {
 448         virDomainVsockDef *vsock = vm->def->vsock;
 449         qemuDomainVsockPrivate *vsockPriv =
 450             (qemuDomainVsockPrivate *)vsock->privateData;
 451
 452         if (vsock->auto_cid == VIR_TRISTATE_BOOL_YES)
 453             vsock->guest_cid = 42;
 454
 455         vsockPriv->vhostfd = 6789;
 456     }
 457
 458     for (i = 0; i < vm->def->ntpms; i++) {
 459         if (vm->def->tpms[i]->type != VIR_DOMAIN_TPM_TYPE_EMULATOR)
 460             continue;
 461
 462         VIR_FREE(vm->def->tpms[i]->data.emulator.source->data.nix.path);
 463         vm->def->tpms[i]->data.emulator.source->type = VIR_DOMAIN_CHR_TYPE_UNIX;
 464         vm->def->tpms[i]->data.emulator.source->data.nix.path = g_strdup("/dev/test");
 465     }
 466
 467     for (i = 0; i < vm->def->nvideos; i++) {
 468         virDomainVideoDef *video = vm->def->videos[i];
 469
 470         if (video->backend == VIR_DOMAIN_VIDEO_BACKEND_TYPE_VHOSTUSER) {
 471             qemuDomainVideoPrivate *vpriv = QEMU_DOMAIN_VIDEO_PRIVATE(video);
 472
 473             vpriv->vhost_user_fd = 1729;
 474         }
 475     }
 476
 477     if (flags & FLAG_SLIRP_HELPER) {
 478         for (i = 0; i < vm->def->nnets; i++) {
 479             virDomainNetDef *net = vm->def->nets[i];
 480
 481             if (net->type == VIR_DOMAIN_NET_TYPE_USER &&
 482                 net->backend.type == VIR_DOMAIN_NET_BACKEND_DEFAULT &&
 483                 virQEMUCapsGet(info->qemuCaps, QEMU_CAPS_DBUS_VMSTATE)) {
 484                 qemuSlirp *slirp = qemuSlirpNew();
 485                 slirp->fd[0] = 42;
 486                 QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp = slirp;
 487             }
 488         }
 489     }
 490
 491     return qemuProcessCreatePretendCmdBuild(vm, migrateURI);
 492 }
 493
 494
 495 struct testValidateSchemaCommandData {
 496     const char *name;
 497     const char *schema;
 498     bool allowIncomplete; /* relax validator for commands with incomplete schema */
 499 };
 500
 501
 502 static const struct testValidateSchemaCommandData commands[] = {
 503     { "-blockdev", "blockdev-add", false },
 504     { "-netdev", "netdev_add", false },
 505     { "-object", "object-add", false },
 506     { "-device", "device_add", true },
 507     { "-chardev", "chardev-add", false },
 508 };
 509
 510 static int
 511 testCompareXMLToArgvValidateSchemaCommand(GStrv args,
 512                                           GHashTable *schema)
 513 {
 514     GStrv arg;
 515
 516     for (arg = args; *arg; arg++) {
 517         const char *curcommand = *arg;
 518         const char *curargs = *(arg + 1);
 519         size_t i;
 520
 521         for (i = 0; i < G_N_ELEMENTS(commands); i++) {
 522             const struct testValidateSchemaCommandData *command = commands + i;
 523             g_auto(virBuffer) debug = VIR_BUFFER_INITIALIZER;
 524             g_autoptr(virJSONValue) jsonargs = NULL;
 525
 526             if (STRNEQ(curcommand, command->name))
 527                 continue;
 528
 529             if (!curargs) {
 530                 VIR_TEST_VERBOSE("expected arguments for command '%s'",
 531                                  command->name);
 532                 return -1;
 533             }
 534
 535             if (*curargs != '{') {
 536                 arg++;
 537                 break;
 538             }
 539
 540             if (!(jsonargs = virJSONValueFromString(curargs)))
 541                 return -1;
 542
 543             if (testQEMUSchemaValidateCommand(command->schema, jsonargs,
 544                                               schema, false, false,
 545                                               command->allowIncomplete,
 546                                               &debug) < 0) {
 547                 VIR_TEST_VERBOSE("failed to validate '%s %s' against QAPI schema: %s",
 548                                  command->name, curargs, virBufferCurrentContent(&debug));
 549                 return -1;
 550             }
 551
 552             arg++;
 553         }
 554     }
 555
 556     return 0;
 557 }
 558
 559
 560 static int
 561 testCompareXMLToArgvValidateSchema(virCommand *cmd,
 562                                    testQemuInfo *info)
 563 {
 564     g_auto(GStrv) args = NULL;
 565
 566     if (!info->qmpSchema)
 567         return 0;
 568
 569     if (virCommandGetArgList(cmd, &args) < 0)
 570         return -1;
 571
 572     if (testCompareXMLToArgvValidateSchemaCommand(args, info->qmpSchema) < 0)
 573         return -1;
 574
 575     return 0;
 576 }
 577
 578
 579 static int
 580 testInfoCheckDuplicate(testQemuInfo *info)
 581 {
 582     const char *path = info->outfile;
 583
 584     if (info->flags & FLAG_ALLOW_DUPLICATE_OUTPUT)
 585         return 0;
 586
 587     if (!path)
 588         path = info->errfile;
 589
 590     if (g_hash_table_contains(info->conf->duplicateTests, path)) {
 591         fprintf(stderr, "\nduplicate invocation of test case: %s\n'", path);
 592         return -1;
 593     }
 594
 595     g_hash_table_insert(info->conf->duplicateTests, g_strdup(path), NULL);
 596
 597     return 0;
 598 }
 599
 600
 601 /**
 602  * testQemuConfXMLCommon: Prepare common test data (e.g. parse input XML)
 603  * for a test case.
 604  *
 605  * @info: test info struct to prepare
 606  * @rv: return value that the caller is supposed to return (see below)
 607  *
 608  * Since some of the prepared data is reused by multiple tests, which can be
 609  * potentially skipped via 'VIR_TEST_RANGE', this function is designed to be
 610  * callable multiple times but processes data just once.
 611  *
 612  * Returns 'true' if subsequent tests are expected to run (input XML was parsed
 613  * properly and test is not expected to fail on parse error). Otherwise 'false'
 614  * is returned and rv is populated according to the following logic:
 615  *  1) expected failure of parsing (FLAG_EXPECT_PARSE_ERROR)
 616  *      - first invocation sets @rv to 0
 617  *      - other invocations set rv to EXIT_AM_SKIP
 618  *  2) unexpected error
 619  *      - all invocations return -1
 620  *      - first invocation reports actual error
 621  *      - other invocations report replacement error
 622  */
 623 static bool
 624 testQemuConfXMLCommon(testQemuInfo *info,
 625                       int *rv)
 626 {
 627     g_autoptr(virDomainDef) def = NULL;
 628
 629     /* initialize a test just once */
 630     if (info->prepared)
 631         goto cleanup;
 632
 633     /* mark test case as used */
 634     ignore_value(g_hash_table_remove(info->conf->existingTestCases, info->infile));
 635     if (info->outfile)
 636         ignore_value(g_hash_table_remove(info->conf->existingTestCases, info->outfile));
 637     if (info->errfile)
 638         ignore_value(g_hash_table_remove(info->conf->existingTestCases, info->errfile));
 639     if (info->out_xml_inactive)
 640         ignore_value(g_hash_table_remove(info->conf->existingTestCases, info->out_xml_inactive));
 641
 642     if (testQemuInfoInitArgs((testQemuInfo *) info) < 0)
 643         goto cleanup;
 644
 645     if (testInfoCheckDuplicate(info) < 0)
 646         goto cleanup;
 647
 648 # if !WITH_NBDKIT
 649     /* when compiled without nbdkit support we want to skip the test after
 650      * marking it as used */
 651     if (info->args.fakeNbdkitCaps) {
 652         info->prep_skip = true;
 653         info->prepared = true;
 654         goto cleanup;
 655     }
 656 # endif /* !WITH_NBDKIT */
 657
 658     if (info->arch != VIR_ARCH_NONE && info->arch != VIR_ARCH_X86_64)
 659         qemuTestSetHostArch(&driver, info->arch);
 660
 661     if (info->args.capsHostCPUModel) {
 662         virCPUDef *hostCPUModel = qemuTestGetCPUDef(info->args.capsHostCPUModel);
 663
 664         qemuTestSetHostCPU(&driver, driver.hostarch, hostCPUModel);
 665         testUpdateQEMUCapsHostCPUModel(info->qemuCaps, driver.hostarch);
 666     }
 667
 668     if (testCheckExclusiveFlags(info->flags) < 0)
 669         goto cleanup;
 670
 671     virFileCacheClear(driver.qemuCapsCache);
 672
 673     if (qemuTestCapsCacheInsert(driver.qemuCapsCache, info->qemuCaps) < 0)
 674         goto cleanup;
 675
 676     if (!(info->flags & FLAG_ALLOW_MISSING_INPUT) &&
 677         !virFileExists(info->infile)) {
 678         virReportError(VIR_ERR_INTERNAL_ERROR,
 679                        "Input file '%s' not found", info->infile);
 680         goto cleanup;
 681     }
 682
 683     if (!(def = virDomainDefParseFile(info->infile, driver.xmlopt, NULL,
 684                                       info->parseFlags | VIR_DOMAIN_DEF_PARSE_INACTIVE))) {
 685         virError *err = virGetLastError();
 686
 687         if (!err) {
 688             VIR_TEST_DEBUG("no error was reported for expected parse error");
 689             goto cleanup;
 690         }
 691
 692         if (info->flags & FLAG_EXPECT_PARSE_ERROR) {
 693             g_autoptr(GString) errstr = g_string_new(NULLSTR(err->message));
 694
 695             g_string_replace(errstr, abs_srcdir, "ABS_SRCDIR", 0);
 696             g_string_append_c(errstr, '\n');
 697
 698             if (virTestCompareToFile(errstr->str, info->errfile) >= 0) {
 699                 info->prep_skip = true;
 700             }
 701         }
 702
 703         goto cleanup;
 704     }
 705
 706     if (info->flags & FLAG_EXPECT_PARSE_ERROR) {
 707         VIR_TEST_DEBUG("passed instead of expected parse error");
 708         goto cleanup;
 709     }
 710
 711     info->def = g_steal_pointer(&def);
 712
 713  cleanup:
 714     /* definition is present and correct, return true to signal that caller can continue */
 715     if (info->def) {
 716         info->prepared = true;
 717         return true;
 718     }
 719
 720     /* definition is not present, but failure was expected */
 721     if (info->prep_skip) {
 722         /* first time we report success, any subsequent time EXIT_AM_SKIP */
 723         if (!info->prepared)
 724             *rv = 0;
 725         else
 726             *rv = EXIT_AM_SKIP;
 727     } else {
 728         /* any other failure always results in error in all invocations
 729          * so that the user will see all the failures in the final error
 730          * message which is suggesting a VIR_TEST_RANGE-limited run for
 731          * debugging. */
 732         *rv = -1;
 733
 734         /* report replacement error on subsequent runs */
 735         if (!info->prepared)
 736             VIR_TEST_VERBOSE("error from testQemuConfXMLCommon() was reported in the first invocation");
 737     }
 738
 739     info->prepared = true;
 740     /* caller is not expected to run tests */
 741     return false;
 742 }
 743
 744
 745 static int
 746 testCompareDef2XML(const void *data)
 747 {
 748     testQemuInfo *info = (void *) data;
 749     g_autofree char *actual = NULL;
 750     unsigned int format_flags = VIR_DOMAIN_DEF_FORMAT_SECURE;
 751     int rc = 0;
 752
 753     if (!testQemuConfXMLCommon(info, &rc))
 754         return rc;
 755
 756     /* we deliberately format the XML as live to catch potential test regressions
 757      * as virDomainDefFormatInternalSetRootName implies _INACTIVE if 'def->id'
 758      * is -1, thus VM is inactive. */
 759     if (!(actual = virDomainDefFormat(info->def, driver.xmlopt, format_flags)))
 760         return -1;
 761
 762     if (virTestCompareToFile(actual, info->out_xml_inactive) < 0)
 763         return -1;
 764
 765     return 0;
 766 }
 767
 768
 769 static int
 770 testCompareOutXML2XML(const void *data)
 771 {
 772     testQemuInfo *info = (void *) data;
 773     g_autofree char *actual = NULL;
 774     g_autoptr(virDomainDef) outdef = NULL;
 775     unsigned int format_flags = VIR_DOMAIN_DEF_FORMAT_SECURE;
 776     int rc = 0;
 777
 778     if (!testQemuConfXMLCommon(info, &rc))
 779         return rc;
 780
 781     /* parsing of the file produced by libvirt MUST succeed */
 782     if (!(outdef = virDomainDefParseFile(info->out_xml_inactive, driver.xmlopt, NULL,
 783                                          info->parseFlags | VIR_DOMAIN_DEF_PARSE_INACTIVE))) {
 784         VIR_TEST_VERBOSE("failed to parse '%s'", info->out_xml_inactive);
 785         return -1;
 786     }
 787
 788     /* we deliberately format the XML as live to catch potential test regressions
 789      * as virDomainDefFormatInternalSetRootName implies _INACTIVE if 'def->id'
 790      * is -1, thus VM is inactive. */
 791     if (!(actual = virDomainDefFormat(outdef, driver.xmlopt, format_flags)))
 792         return -1;
 793
 794     if (virTestCompareToFile(actual, info->out_xml_inactive) < 0)
 795         return -1;
 796
 797     return 0;
 798 }
 799
 800
 801 static int
 802 testCompareXMLToArgv(const void *data)
 803 {
 804     testQemuInfo *info = (void *) data;
 805     g_autofree char *migrateURI = NULL;
 806     g_auto(virBuffer) actualBuf = VIR_BUFFER_INITIALIZER;
 807     g_autofree char *actualargv = NULL;
 808     unsigned int flags = info->flags;
 809     int ret = -1;
 810     virDomainObj *vm = NULL;
 811     virDomainChrSourceDef monitor_chr = { 0 };
 812     virError *err = NULL;
 813     g_autofree char *log = NULL;
 814     g_autoptr(virCommand) cmd = NULL;
 815     qemuDomainObjPrivate *priv = NULL;
 816     g_autoptr(virIdentity) sysident = virIdentityGetSystem();
 817     int rc = 0;
 818
 819     if (!testQemuConfXMLCommon(info, &rc))
 820         return rc;
 821
 822     if (virIdentitySetCurrent(sysident) < 0)
 823         goto cleanup;
 824
 825     if (info->nbdkitCaps) {
 826         if (virFileCacheInsertData(driver.nbdkitCapsCache, TEST_NBDKIT_PATH,
 827                                    g_object_ref(info->nbdkitCaps)) < 0) {
 828             g_object_unref(info->nbdkitCaps);
 829             goto cleanup;
 830         }
 831     }
 832
 833     if (info->migrateFrom &&
 834         !(migrateURI = qemuMigrationDstGetURI(info->migrateFrom,
 835                                               info->migrateFd)))
 836         goto cleanup;
 837
 838     if (!(vm = virDomainObjNew(driver.xmlopt)))
 839         goto cleanup;
 840
 841     vm->def = info->def;
 842     priv = vm->privateData;
 843
 844     if (info->args.fds) {
 845         g_clear_pointer(&priv->fds, g_hash_table_unref);
 846         priv->fds = g_steal_pointer(&info->args.fds);
 847     }
 848
 849     if (virBitmapParse("0-3", &priv->autoNodeset, 4) < 0)
 850         goto cleanup;
 851
 852     if (!virDomainDefCheckABIStability(vm->def, vm->def, driver.xmlopt)) {
 853         VIR_TEST_DEBUG("ABI stability check failed on %s", info->infile);
 854         goto cleanup;
 855     }
 856
 857     vm->def->id = -1;
 858
 859     if (qemuProcessPrepareMonitorChr(&monitor_chr, priv->libDir) < 0)
 860         goto cleanup;
 861
 862     virResetLastError();
 863
 864     if (!(cmd = testCompareXMLToArgvCreateArgs(&driver, vm, migrateURI, info,
 865                                                flags))) {
 866         err = virGetLastError();
 867         if (!err) {
 868             VIR_TEST_DEBUG("no error was reported for expected failure");
 869             goto cleanup;
 870         }
 871         if (flags & FLAG_EXPECT_FAILURE) {
 872             g_autofree char *tmperr = g_strdup_printf("%s\n", NULLSTR(err->message));
 873             if (virTestCompareToFile(tmperr, info->errfile) >= 0)
 874                 goto ok;
 875         }
 876         goto cleanup;
 877     }
 878     if (flags & FLAG_EXPECT_FAILURE) {
 879         VIR_TEST_DEBUG("passed instead of expected failure");
 880         goto cleanup;
 881     }
 882
 883     if (testCompareXMLToArgvValidateSchema(cmd, info) < 0)
 884         goto cleanup;
 885
 886     if (virCommandToStringBuf(cmd, &actualBuf, true, false) < 0)
 887         goto cleanup;
 888
 889     virBufferAddLit(&actualBuf, "\n");
 890     actualargv = virBufferContentAndReset(&actualBuf);
 891
 892     if (virTestCompareToFileFull(actualargv, info->outfile, false) < 0)
 893         goto cleanup;
 894
 895     ret = 0;
 896
 897  ok:
 898     if (ret == 0 && flags & FLAG_EXPECT_FAILURE) {
 899         ret = -1;
 900         VIR_TEST_DEBUG("Error expected but there wasn't any.");
 901         goto cleanup;
 902     }
 903     if (flags & FLAG_EXPECT_FAILURE) {
 904         if ((log = virTestLogContentAndReset()))
 905             VIR_TEST_DEBUG("Got expected error: \n%s", log);
 906     }
 907     virResetLastError();
 908     ret = 0;
 909
 910  cleanup:
 911     /* clear overriden host cpu */
 912     if (info->args.capsHostCPUModel)
 913         qemuTestSetHostCPU(&driver, driver.hostarch, NULL);
 914     virDomainChrSourceDefClear(&monitor_chr);
 915     if (vm) {
 916         vm->def = NULL;
 917         virObjectUnref(vm);
 918     }
 919     virIdentitySetCurrent(NULL);
 920     if (info->arch != VIR_ARCH_NONE && info->arch != VIR_ARCH_X86_64)
 921         qemuTestSetHostArch(&driver, VIR_ARCH_NONE);
 922
 923     return ret;
 924 }
 925
 926
 927 static int
 928 testConfXMLCheck(GHashTable *existingTestCases)
 929 {
 930     g_autofree virHashKeyValuePair *items = virHashGetItems(existingTestCases, NULL, true);
 931     size_t i;
 932     int ret = 0;
 933
 934     for (i = 0; items[i].key; i++) {
 935         if (ret == 0)
 936             fprintf(stderr, "\n");
 937
 938         fprintf(stderr, "unused file: %s\n", (const char *) items[i].key);
 939         ret = -1;
 940     }
 941
 942     return ret;
 943 }
 944
 945
 946 static int
 947 testConfXMLEnumerate(GHashTable *existingTestCases)
 948 {
 949     struct dirent *ent;
 950     g_autoptr(DIR) dir = NULL;
 951     int rc;
 952
 953     /* If VIR_TEST_RANGE is in use don't bother filling in the data, which
 954      * also makes testConfXMLCheck succeed. */
 955     if (virTestHasRangeBitmap())
 956         return 0;
 957
 958     if (virDirOpen(&dir, abs_srcdir "/qemuxmlconfdata") < 0)
 959         return -1;
 960
 961     while ((rc = virDirRead(dir, &ent, abs_srcdir "/qemuxmlconfdata")) > 0) {
 962         if (virStringHasSuffix(ent->d_name, ".xml") ||
 963             virStringHasSuffix(ent->d_name, ".args") ||
 964             virStringHasSuffix(ent->d_name, ".err")) {
 965             g_hash_table_insert(existingTestCases,
 966                                 g_strdup_printf(abs_srcdir "/qemuxmlconfdata/%s", ent->d_name),
 967                                 NULL);
 968         }
 969     }
 970
 971     return rc;
 972 }
 973
 974
 975 static int
 976 testXMLParse(const void *data)
 977 {
 978     testQemuInfo *info = (void *) data;
 979     int rc = 0;
 980
 981     testQemuConfXMLCommon(info, &rc);
 982
 983     return rc;
 984 }
 985
 986
 987 static void
 988 testRun(const char *name,
 989         const char *suffix,
 990         int *ret,
 991         struct testQemuConf *testConf,
 992         ...)
 993 {
 994     g_autofree char *name_parse = g_strdup_printf("QEMU XML def parse %s%s", name, suffix);
 995     g_autofree char *name_xml = g_strdup_printf("QEMU XML def -> XML %s%s", name, suffix);
 996     g_autofree char *name_outxml = g_strdup_printf("QEMU XML OUT -> XML %s%s", name, suffix);
 997     g_autofree char *name_argv = g_strdup_printf("QEMU XML def -> ARGV %s%s", name, suffix);
 998     g_autoptr(testQemuInfo) info = g_new0(testQemuInfo, 1);
 999     va_list ap;
1000
1001     info->name = name;
1002     info->conf = testConf;
1003
1004     va_start(ap, testConf);
1005     testQemuInfoSetArgs(info, ap);
1006     va_end(ap);
1007
1008     info->infile = g_strdup_printf("%s/qemuxmlconfdata/%s.xml", abs_srcdir, info->name);
1009     if (info->flags & (FLAG_EXPECT_FAILURE | FLAG_EXPECT_PARSE_ERROR)) {
1010         info->errfile = g_strdup_printf("%s/qemuxmlconfdata/%s%s.err", abs_srcdir, info->name, suffix);
1011     } else {
1012         info->outfile = g_strdup_printf("%s/qemuxmlconfdata/%s%s.args", abs_srcdir, info->name, suffix);
1013     }
1014
1015     if (!(info->flags & FLAG_EXPECT_PARSE_ERROR))
1016         info->out_xml_inactive = g_strdup_printf("%s/qemuxmlconfdata/%s%s.xml", abs_srcdir, info->name, suffix);
1017
1018     virTestRunLog(ret, name_parse, testXMLParse, info);
1019     virTestRunLog(ret, name_xml, testCompareDef2XML, info);
1020     virTestRunLog(ret, name_outxml, testCompareOutXML2XML, info);
1021     virTestRunLog(ret, name_argv, testCompareXMLToArgv, info);
1022
1023     /* clear overriden host cpu */
1024     if (info->args.capsHostCPUModel)
1025         qemuTestSetHostCPU(&driver, driver.hostarch, NULL);
1026     if (info->arch != VIR_ARCH_NONE && info->arch != VIR_ARCH_X86_64)
1027         qemuTestSetHostArch(&driver, VIR_ARCH_NONE);
1028 }
1029
1030
1031 static int
1032 mymain(void)
1033 {
1034     int ret = 0;
1035     g_autoptr(virConnect) conn = NULL;
1036     g_autoptr(GHashTable) duplicateTests = virHashNew(NULL);
1037     g_autoptr(GHashTable) existingTestCases = virHashNew(NULL);
1038     g_autoptr(GHashTable) capslatest = testQemuGetLatestCaps();
1039     g_autoptr(GHashTable) qapiSchemaCache = virHashNew((GDestroyNotify) g_hash_table_unref);
1040     g_autoptr(GHashTable) capscache = virHashNew(virObjectUnref);
1041     struct testQemuConf testConf = { .capslatest = capslatest,
1042                                      .capscache = capscache,
1043                                      .qapiSchemaCache = qapiSchemaCache,
1044                                      .duplicateTests = duplicateTests,
1045                                      .existingTestCases = existingTestCases };
1046
1047     if (!capslatest)
1048         return EXIT_FAILURE;
1049
1050     /* enumerate and store all available test cases to verify at the end that
1051      * all of them were invoked */
1052     if (testConfXMLEnumerate(existingTestCases) < 0)
1053         return EXIT_FAILURE;
1054
1055     /* Set the timezone because we are mocking the time() function.
1056      * If we don't do that, then localtime() may return unpredictable
1057      * results. In order to detect things that just work by a blind
1058      * chance, we need to set an virtual timezone that no libvirt
1059      * developer resides in. */
1060     if (g_setenv("TZ", "VIR00:30", TRUE) == FALSE) {
1061         perror("g_setenv");
1062         return EXIT_FAILURE;
1063     }
1064
1065     if (qemuTestDriverInit(&driver) < 0)
1066         return EXIT_FAILURE;
1067
1068     virFileWrapperAddPrefix("/sys/devices/system",
1069                             abs_srcdir "/vircaps2xmldata/linux-basic/system");
1070     virFileWrapperAddPrefix(SYSCONFDIR "/qemu/firmware",
1071                             abs_srcdir "/qemufirmwaredata/etc/qemu/firmware");
1072     virFileWrapperAddPrefix(PREFIX "/share/qemu/firmware",
1073                             abs_srcdir "/qemufirmwaredata/usr/share/qemu/firmware");
1074     virFileWrapperAddPrefix("/home/user/.config/qemu/firmware",
1075                             abs_srcdir "/qemufirmwaredata/home/user/.config/qemu/firmware");
1076
1077     virFileWrapperAddPrefix(SYSCONFDIR "/qemu/vhost-user",
1078                             abs_srcdir "/qemuvhostuserdata/etc/qemu/vhost-user");
1079     virFileWrapperAddPrefix(PREFIX "/share/qemu/vhost-user",
1080                             abs_srcdir "/qemuvhostuserdata/usr/share/qemu/vhost-user");
1081     virFileWrapperAddPrefix("/home/user/.config/qemu/vhost-user",
1082                             abs_srcdir "/qemuvhostuserdata/home/user/.config/qemu/vhost-user");
1083
1084     virFileWrapperAddPrefix("/usr/libexec/qemu/vhost-user",
1085                             abs_srcdir "/qemuvhostuserdata/usr/libexec/qemu/vhost-user");
1086     virFileWrapperAddPrefix("/usr/libexec/virtiofsd",
1087                             abs_srcdir "/qemuvhostuserdata/usr/libexec/qemu/vhost-user/test-virtiofsd");
1088
1089     if (!(conn = virGetConnect()))
1090         return EXIT_FAILURE;
1091
1092     conn->secretDriver = &fakeSecretDriver;
1093     conn->storageDriver = &fakeStorageDriver;
1094     conn->nwfilterDriver = &fakeNWFilterDriver;
1095     conn->networkDriver = &fakeNetworkDriver;
1096
1097     virSetConnectInterface(conn);
1098     virSetConnectNetwork(conn);
1099     virSetConnectNWFilter(conn);
1100     virSetConnectNodeDev(conn);
1101     virSetConnectSecret(conn);
1102     virSetConnectStorage(conn);
1103
1104 /**
1105  * The following set of macros allows testing of XML -> argv conversion with a
1106  * real set of capabilities gathered from a real qemu copy. It is desired to use
1107  * these for positive test cases as it provides combinations of flags which
1108  * can be met in real life.
1109  *
1110  * The capabilities are taken from the real capabilities stored in
1111  * tests/qemucapabilitiesdata.
1112  *
1113  * It is suggested to use the DO_TEST_CAPS_LATEST macro which always takes the
1114  * most recent capability set. In cases when the new code would change behaviour
1115  * the test cases should be forked using DO_TEST_CAPS_VER with the appropriate
1116  * version.
1117  */
1118 # define DO_TEST_FULL(_name, _suffix, ...) \
1119     testRun(_name, _suffix, &ret, &testConf, __VA_ARGS__);
1120
1121 # define DO_TEST_CAPS_INTERNAL(name, arch, ver, ...) \
1122     DO_TEST_FULL(name, "." arch "-" ver, \
1123                  ARG_CAPS_ARCH, arch, \
1124                  ARG_CAPS_VER, ver, \
1125                  __VA_ARGS__, \
1126                  ARG_END)
1127
1128 # define DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, ...) \
1129     DO_TEST_CAPS_INTERNAL(name, arch, "latest", __VA_ARGS__)
1130
1131 # define DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, ...) \
1132     DO_TEST_CAPS_INTERNAL(name, arch, ver, __VA_ARGS__)
1133
1134 # define DO_TEST_CAPS_ARCH_LATEST(name, arch) \
1135     DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, ARG_END)
1136
1137 # define DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE(name, arch) \
1138     DO_TEST_FULL(name, "." arch "-latest.abi-update", \
1139                  ARG_CAPS_ARCH, arch, \
1140                  ARG_CAPS_VER, "latest", \
1141                  ARG_PARSEFLAGS, VIR_DOMAIN_DEF_PARSE_ABI_UPDATE, \
1142                  ARG_END)
1143
1144 # define DO_TEST_CAPS_ARCH_VER(name, arch, ver) \
1145     DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, ARG_END)
1146
1147 # define DO_TEST_CAPS_LATEST_NBDKIT(name, ...) \
1148     DO_TEST_CAPS_ARCH_LATEST_FULL(name, "x86_64", ARG_NBDKIT_CAPS, __VA_ARGS__, QEMU_NBDKIT_CAPS_LAST, ARG_END)
1149
1150 # define DO_TEST_CAPS_LATEST(name) \
1151     DO_TEST_CAPS_ARCH_LATEST(name, "x86_64")
1152
1153 # define DO_TEST_CAPS_LATEST_ABI_UPDATE(name) \
1154     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE(name, "x86_64")
1155
1156 # define DO_TEST_CAPS_VER(name, ver) \
1157     DO_TEST_CAPS_ARCH_VER(name, "x86_64", ver)
1158
1159 # define DO_TEST_CAPS_LATEST_PPC64(name) \
1160     DO_TEST_CAPS_ARCH_LATEST(name, "ppc64")
1161
1162 # define DO_TEST_CAPS_LATEST_PPC64_HOSTCPU(name, hostcpu) \
1163     DO_TEST_CAPS_ARCH_LATEST_FULL(name, "ppc64", \
1164                                   ARG_CAPS_HOST_CPU_MODEL, hostcpu)
1165
1166 # define DO_TEST_CAPS_LATEST_PPC64_HOSTCPU_FAILURE(name, hostcpu) \
1167     DO_TEST_CAPS_ARCH_LATEST_FULL(name, "ppc64", \
1168                                   ARG_CAPS_HOST_CPU_MODEL, hostcpu, \
1169                                   ARG_FLAGS, FLAG_EXPECT_FAILURE)
1170
1171 # define DO_TEST_CAPS_ARCH_LATEST_FAILURE(name, arch) \
1172     DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, \
1173                                   ARG_FLAGS, FLAG_EXPECT_FAILURE)
1174
1175 # define DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE_FAILURE(name, arch) \
1176     DO_TEST_FULL(name, "." arch "-latest.abi-update", \
1177                  ARG_CAPS_ARCH, arch, \
1178                  ARG_CAPS_VER, "latest", \
1179                  ARG_PARSEFLAGS, VIR_DOMAIN_DEF_PARSE_ABI_UPDATE, \
1180                  ARG_FLAGS, FLAG_EXPECT_FAILURE, \
1181                  ARG_END)
1182
1183 # define DO_TEST_CAPS_ARCH_VER_FAILURE(name, arch, ver) \
1184     DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, \
1185                                ARG_FLAGS, FLAG_EXPECT_FAILURE)
1186
1187 # define DO_TEST_CAPS_LATEST_FAILURE(name) \
1188     DO_TEST_CAPS_ARCH_LATEST_FAILURE(name, "x86_64")
1189
1190 # define DO_TEST_CAPS_LATEST_ABI_UPDATE_FAILURE(name) \
1191     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE_FAILURE(name, "x86_64")
1192
1193 # define DO_TEST_CAPS_VER_FAILURE(name, ver) \
1194     DO_TEST_CAPS_ARCH_VER_FAILURE(name, "x86_64", ver)
1195
1196 # define DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR(name, arch) \
1197     DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, \
1198                                   ARG_FLAGS, FLAG_EXPECT_PARSE_ERROR)
1199
1200 # define DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE_PARSE_ERROR(name, arch) \
1201     DO_TEST_FULL(name, "." arch "-latest.abi-update", \
1202                  ARG_CAPS_ARCH, arch, \
1203                  ARG_CAPS_VER, "latest", \
1204                  ARG_PARSEFLAGS, VIR_DOMAIN_DEF_PARSE_ABI_UPDATE, \
1205                  ARG_FLAGS, FLAG_EXPECT_PARSE_ERROR, \
1206                  ARG_END)
1207
1208 # define DO_TEST_CAPS_ARCH_VER_PARSE_ERROR(name, arch, ver) \
1209     DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, \
1210                                ARG_FLAGS, FLAG_EXPECT_PARSE_ERROR)
1211
1212 # define DO_TEST_CAPS_LATEST_PARSE_ERROR(name) \
1213     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR(name, "x86_64")
1214
1215 # define DO_TEST_CAPS_LATEST_ABI_UPDATE_PARSE_ERROR(name) \
1216     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE_PARSE_ERROR(name, "x86_64")
1217
1218 # define DO_TEST_CAPS_VER_PARSE_ERROR(name, ver) \
1219     DO_TEST_CAPS_ARCH_VER_PARSE_ERROR(name, "x86_64", ver)
1220
1221 # define DO_TEST_GIC(name, ver, gic) \
1222     DO_TEST_CAPS_ARCH_VER_FULL(name, "aarch64", ver, ARG_GIC, gic, ARG_FLAGS, FLAG_ALLOW_DUPLICATE_OUTPUT, ARG_END)
1223
1224     /* Unset or set all envvars here that are copied in qemudBuildCommandLine
1225      * using ADD_ENV_COPY, otherwise these tests may fail due to unexpected
1226      * values for these envvars */
1227     g_setenv("PATH", "/bin", TRUE);
1228     g_setenv("USER", "test", TRUE);
1229     g_setenv("LOGNAME", "test", TRUE);
1230     g_setenv("HOME", "/home/test", TRUE);
1231     g_setenv("LC_ALL", "C", TRUE);
1232     g_unsetenv("TMPDIR");
1233     g_unsetenv("LD_PRELOAD");
1234     g_unsetenv("LD_LIBRARY_PATH");
1235     g_unsetenv("DYLD_INSERT_LIBRARIES");
1236     g_unsetenv("DYLD_FORCE_FLAT_NAMESPACE");
1237     g_unsetenv("QEMU_AUDIO_DRV");
1238     g_unsetenv("SDL_AUDIODRIVER");
1239     g_unsetenv("PIPEWIRE_CORE");
1240     g_unsetenv("PIPEWIRE_REMOTE");
1241     g_unsetenv("PIPEWIRE_RUNTIME_DIR");
1242
1243     DO_TEST_CAPS_ARCH_LATEST_FULL("nonexistent-file", "x86_64",
1244                                   ARG_FLAGS, FLAG_EXPECT_PARSE_ERROR | FLAG_ALLOW_MISSING_INPUT);
1245     DO_TEST_CAPS_LATEST_PARSE_ERROR("broken-xml-invalid");
1246
1247     DO_TEST_CAPS_LATEST("x86_64-pc-minimal");
1248     DO_TEST_CAPS_LATEST_ABI_UPDATE("x86_64-pc-minimal");
1249     DO_TEST_CAPS_LATEST("x86_64-q35-minimal");
1250     DO_TEST_CAPS_LATEST_ABI_UPDATE("x86_64-q35-minimal");
1251     DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-minimal", "aarch64");
1252     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("aarch64-virt-minimal", "aarch64");
1253     DO_TEST_CAPS_ARCH_LATEST("aarch64-versatilepb-minimal", "aarch64");
1254     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("aarch64-versatilepb-minimal", "aarch64");
1255     DO_TEST_CAPS_ARCH_LATEST("armv7l-versatilepb-minimal", "armv7l");
1256     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("armv7l-versatilepb-minimal", "armv7l");
1257     DO_TEST_CAPS_ARCH_LATEST("aarch64-realview-minimal", "aarch64");
1258     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("aarch64-realview-minimal", "aarch64");
1259     /* The '-nousb' test case tests machine without a built-in USB controller */
1260     DO_TEST_CAPS_ARCH_LATEST("aarch64-nousb-minimal", "aarch64");
1261     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("aarch64-nousb-minimal", "aarch64");
1262     DO_TEST_CAPS_ARCH_LATEST("loongarch64-virt-minimal", "loongarch64");
1263     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("loongarch64-virt-minimal", "loongarch64");
1264     DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-minimal", "riscv64");
1265     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("riscv64-virt-minimal", "riscv64");
1266     DO_TEST_CAPS_ARCH_LATEST("ppc64-pseries-minimal", "ppc64");
1267     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("ppc64-pseries-minimal", "ppc64");
1268     DO_TEST_CAPS_ARCH_LATEST("ppc64-g3beige-minimal", "ppc64");
1269     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("ppc64-g3beige-minimal", "ppc64");
1270     DO_TEST_CAPS_ARCH_LATEST("ppc64-mac99-minimal", "ppc64");
1271     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("ppc64-mac99-minimal", "ppc64");
1272     DO_TEST_CAPS_ARCH_LATEST("ppc-mac99-minimal", "ppc");
1273     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("ppc-mac99-minimal", "ppc");
1274     DO_TEST_CAPS_ARCH_LATEST("ppc64-powernv9-minimal", "ppc64");
1275     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("ppc64-powernv9-minimal", "ppc64");
1276     DO_TEST_CAPS_ARCH_LATEST("s390x-ccw-minimal", "s390x");
1277     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("s390x-ccw-minimal", "s390x");
1278
1279     DO_TEST_CAPS_LATEST("x86_64-pc-default-models");
1280     DO_TEST_CAPS_LATEST_ABI_UPDATE("x86_64-pc-default-models");
1281     DO_TEST_CAPS_LATEST("x86_64-q35-default-models");
1282     DO_TEST_CAPS_LATEST_ABI_UPDATE("x86_64-q35-default-models");
1283     DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-default-models", "aarch64");
1284     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("aarch64-virt-default-models", "aarch64");
1285     DO_TEST_CAPS_ARCH_LATEST("loongarch64-virt-default-models", "loongarch64");
1286     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("loongarch64-virt-default-models", "loongarch64");
1287     DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-default-models", "riscv64");
1288     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("riscv64-virt-default-models", "riscv64");
1289     DO_TEST_CAPS_ARCH_LATEST("ppc64-pseries-default-models", "ppc64");
1290     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("ppc64-pseries-default-models", "ppc64");
1291     DO_TEST_CAPS_ARCH_LATEST("s390x-ccw-default-models", "s390x");
1292     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("s390x-ccw-default-models", "s390x");
1293
1294     DO_TEST_CAPS_LATEST_PARSE_ERROR("no-memory");
1295
1296     DO_TEST_CAPS_LATEST("genid");
1297     DO_TEST_CAPS_LATEST("genid-auto");
1298
1299     DO_TEST_CAPS_LATEST("machine-aliases1");
1300     DO_TEST_CAPS_LATEST("machine-aliases2");
1301     DO_TEST_CAPS_LATEST("machine-core-on");
1302     driver.config->dumpGuestCore = true;
1303     DO_TEST_CAPS_LATEST("machine-core-off");
1304     driver.config->dumpGuestCore = false;
1305     DO_TEST_CAPS_LATEST("machine-smm-on");
1306     DO_TEST_CAPS_LATEST("machine-smm-off");
1307     DO_TEST_CAPS_LATEST("machine-vmport-opt");
1308     DO_TEST_CAPS_LATEST("machine-i8042-on");
1309     DO_TEST_CAPS_VER_PARSE_ERROR("machine-i8042-on", "6.2.0");
1310     DO_TEST_CAPS_LATEST("machine-i8042-off");
1311     DO_TEST_CAPS_VER_PARSE_ERROR("machine-i8042-off", "6.2.0");
1312     DO_TEST_CAPS_LATEST_PARSE_ERROR("machine-i8042-off-vmport-on");
1313     DO_TEST_CAPS_LATEST_PARSE_ERROR("machine-i8042-off-explicit-ps2-inputs");
1314     DO_TEST_CAPS_LATEST("default-kvm-host-arch");
1315     DO_TEST_CAPS_LATEST("default-qemu-host-arch");
1316     DO_TEST_CAPS_LATEST("x86-kvm-32-on-64");
1317     DO_TEST_CAPS_LATEST("boot-cdrom");
1318     DO_TEST_CAPS_LATEST("boot-network");
1319     DO_TEST_CAPS_LATEST("boot-floppy");
1320     DO_TEST_CAPS_LATEST("boot-floppy-q35");
1321     DO_TEST_CAPS_LATEST("boot-multi");
1322     DO_TEST_CAPS_LATEST("boot-menu-enable");
1323     DO_TEST_CAPS_LATEST("boot-menu-enable-with-timeout");
1324     DO_TEST_CAPS_LATEST_PARSE_ERROR("boot-menu-enable-with-timeout-invalid");
1325     DO_TEST_CAPS_LATEST("boot-menu-disable");
1326     DO_TEST_CAPS_LATEST("boot-menu-disable-drive");
1327
1328     DO_TEST_CAPS_LATEST_PARSE_ERROR("boot-dev+order");
1329     DO_TEST_CAPS_LATEST("boot-order");
1330     DO_TEST_CAPS_LATEST("boot-complex");
1331
1332     DO_TEST_CAPS_LATEST("audio-none-minimal");
1333     DO_TEST_CAPS_LATEST("audio-alsa-minimal");
1334     DO_TEST_CAPS_LATEST("audio-coreaudio-minimal");
1335     DO_TEST_CAPS_LATEST("audio-jack-minimal");
1336     DO_TEST_CAPS_LATEST("audio-oss-minimal");
1337     DO_TEST_CAPS_LATEST("audio-pulseaudio-minimal");
1338     g_setenv("PIPEWIRE_RUNTIME_DIR", "/run/user/1000", TRUE);
1339     DO_TEST_CAPS_LATEST("audio-pipewire-minimal");
1340     g_unsetenv("PIPEWIRE_RUNTIME_DIR");
1341     DO_TEST_CAPS_LATEST("audio-sdl-minimal");
1342     DO_TEST_CAPS_LATEST("audio-spice-minimal");
1343     DO_TEST_CAPS_LATEST("audio-file-minimal");
1344
1345     DO_TEST_CAPS_LATEST("audio-none-best");
1346     DO_TEST_CAPS_LATEST("audio-alsa-best");
1347     DO_TEST_CAPS_LATEST("audio-coreaudio-best");
1348     DO_TEST_CAPS_LATEST("audio-oss-best");
1349     DO_TEST_CAPS_LATEST("audio-pulseaudio-best");
1350     DO_TEST_CAPS_LATEST("audio-pipewire-best");
1351     DO_TEST_CAPS_LATEST("audio-sdl-best");
1352     DO_TEST_CAPS_LATEST("audio-spice-best");
1353     DO_TEST_CAPS_LATEST("audio-file-best");
1354
1355     DO_TEST_CAPS_LATEST("audio-none-full");
1356     DO_TEST_CAPS_LATEST("audio-alsa-full");
1357     DO_TEST_CAPS_LATEST("audio-coreaudio-full");
1358     DO_TEST_CAPS_LATEST("audio-jack-full");
1359     DO_TEST_CAPS_LATEST("audio-oss-full");
1360     DO_TEST_CAPS_LATEST("audio-pulseaudio-full");
1361     DO_TEST_CAPS_LATEST("audio-pipewire-full");
1362     DO_TEST_CAPS_LATEST("audio-sdl-full");
1363     DO_TEST_CAPS_LATEST("audio-spice-full");
1364     DO_TEST_CAPS_LATEST("audio-file-full");
1365
1366     g_setenv("PIPEWIRE_RUNTIME_DIR", "/run/user/1000", TRUE);
1367     DO_TEST_CAPS_LATEST("audio-many-backends");
1368     g_unsetenv("PIPEWIRE_RUNTIME_DIR");
1369
1370     /* Validate auto-creation of <audio> for legacy compat */
1371     g_setenv("QEMU_AUDIO_DRV", "sdl", TRUE);
1372     g_setenv("SDL_AUDIODRIVER", "esd", TRUE);
1373     DO_TEST_CAPS_LATEST("audio-default-sdl");
1374     g_unsetenv("QEMU_AUDIO_DRV");
1375     g_unsetenv("SDL_AUDIODRIVER");
1376
1377     g_setenv("QEMU_AUDIO_DRV", "alsa", TRUE);
1378     driver.config->vncAllowHostAudio = true;
1379     DO_TEST_CAPS_LATEST("audio-default-vnc");
1380     driver.config->vncAllowHostAudio = false;
1381     g_unsetenv("QEMU_AUDIO_DRV");
1382
1383     DO_TEST_CAPS_LATEST("audio-default-spice");
1384
1385     g_setenv("QEMU_AUDIO_DRV", "alsa", TRUE);
1386     driver.config->nogfxAllowHostAudio = true;
1387     DO_TEST_CAPS_LATEST("audio-default-nographics");
1388     driver.config->nogfxAllowHostAudio = false;
1389     g_unsetenv("QEMU_AUDIO_DRV");
1390
1391     DO_TEST_CAPS_LATEST("reboot-timeout-disabled");
1392     DO_TEST_CAPS_LATEST("reboot-timeout-enabled");
1393
1394     DO_TEST_CAPS_LATEST("firmware-manual-bios");
1395     DO_TEST_CAPS_LATEST("firmware-manual-bios-stateless");
1396     DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-manual-bios-not-stateless");
1397     DO_TEST_CAPS_LATEST("firmware-manual-efi");
1398     DO_TEST_CAPS_LATEST("firmware-manual-efi-features");
1399     DO_TEST_CAPS_LATEST_ABI_UPDATE_PARSE_ERROR("firmware-manual-efi-features");
1400     DO_TEST_CAPS_LATEST("firmware-manual-efi-rw");
1401     DO_TEST_CAPS_LATEST("firmware-manual-efi-rw-legacy-paths");
1402     DO_TEST_CAPS_LATEST("firmware-manual-efi-rw-modern-paths");
1403     DO_TEST_CAPS_LATEST("firmware-manual-efi-rw-implicit");
1404     DO_TEST_CAPS_LATEST("firmware-manual-efi-loader-secure");
1405     DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-manual-efi-loader-no-path");
1406     DO_TEST_CAPS_LATEST("firmware-manual-efi-loader-path-nonstandard");
1407     DO_TEST_CAPS_LATEST("firmware-manual-efi-secboot");
1408     DO_TEST_CAPS_LATEST("firmware-manual-efi-no-enrolled-keys");
1409     DO_TEST_CAPS_LATEST("firmware-manual-efi-no-secboot");
1410     DO_TEST_CAPS_LATEST("firmware-manual-efi-stateless");
1411     DO_TEST_CAPS_LATEST("firmware-manual-efi-nvram-template");
1412     DO_TEST_CAPS_LATEST("firmware-manual-efi-nvram-template-nonstandard");
1413     DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-manual-efi-nvram-template-stateless");
1414     DO_TEST_CAPS_LATEST("firmware-manual-efi-nvram-network-iscsi");
1415     DO_TEST_CAPS_LATEST("firmware-manual-efi-nvram-network-nbd");
1416     DO_TEST_CAPS_LATEST("firmware-manual-efi-nvram-file");
1417     DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-manual-efi-nvram-stateless");
1418
1419     /* Make sure all combinations of ACPI and UEFI behave as expected */
1420     DO_TEST_CAPS_ARCH_LATEST("firmware-manual-efi-acpi-aarch64", "aarch64");
1421     DO_TEST_CAPS_LATEST("firmware-manual-efi-acpi-q35");
1422     DO_TEST_CAPS_ARCH_LATEST("firmware-manual-efi-noacpi-aarch64", "aarch64");
1423     DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-manual-efi-noacpi-q35");
1424     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("firmware-manual-noefi-acpi-aarch64", "aarch64");
1425     DO_TEST_CAPS_LATEST("firmware-manual-noefi-acpi-q35");
1426     DO_TEST_CAPS_ARCH_LATEST("firmware-manual-noefi-noacpi-aarch64", "aarch64");
1427     DO_TEST_CAPS_LATEST("firmware-manual-noefi-noacpi-q35");
1428
1429     /* Ensure that legacy firmware paths keep working */
1430     DO_TEST_CAPS_LATEST("firmware-manual-efi-secboot-legacy-paths");
1431     DO_TEST_CAPS_LATEST("firmware-manual-efi-no-enrolled-keys-legacy-paths");
1432     DO_TEST_CAPS_LATEST("firmware-manual-efi-no-secboot-legacy-paths");
1433     DO_TEST_CAPS_ARCH_LATEST("firmware-manual-efi-aarch64-legacy-paths", "aarch64");
1434
1435     DO_TEST_CAPS_LATEST("firmware-auto-bios");
1436     DO_TEST_CAPS_LATEST("firmware-auto-bios-stateless");
1437     DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-auto-bios-not-stateless");
1438     DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-auto-bios-nvram");
1439     DO_TEST_CAPS_LATEST("firmware-auto-efi");
1440     DO_TEST_CAPS_LATEST_ABI_UPDATE("firmware-auto-efi");
1441     DO_TEST_CAPS_LATEST("firmware-auto-efi-stateless");
1442     DO_TEST_CAPS_LATEST_FAILURE("firmware-auto-efi-rw");
1443     DO_TEST_CAPS_LATEST_FAILURE("firmware-auto-efi-rw-pflash");
1444     DO_TEST_CAPS_LATEST("firmware-auto-efi-loader-secure");
1445     DO_TEST_CAPS_LATEST_ABI_UPDATE("firmware-auto-efi-loader-secure");
1446     DO_TEST_CAPS_LATEST("firmware-auto-efi-loader-insecure");
1447     DO_TEST_CAPS_LATEST("firmware-auto-efi-loader-path");
1448     DO_TEST_CAPS_LATEST_FAILURE("firmware-auto-efi-loader-path-nonstandard");
1449     DO_TEST_CAPS_LATEST("firmware-auto-efi-secboot");
1450     DO_TEST_CAPS_LATEST("firmware-auto-efi-no-secboot");
1451     DO_TEST_CAPS_LATEST("firmware-auto-efi-enrolled-keys");
1452     DO_TEST_CAPS_LATEST("firmware-auto-efi-no-enrolled-keys");
1453     DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-auto-efi-enrolled-keys-no-secboot");
1454     DO_TEST_CAPS_LATEST("firmware-auto-efi-smm-off");
1455     DO_TEST_CAPS_ARCH_LATEST("firmware-auto-efi-aarch64", "aarch64");
1456     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("firmware-auto-efi-aarch64", "aarch64");
1457     DO_TEST_CAPS_ARCH_LATEST("firmware-auto-efi-loongarch64", "loongarch64");
1458     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("firmware-auto-efi-loongarch64", "loongarch64");
1459     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("firmware-auto-efi-riscv64", "riscv64");
1460     DO_TEST_CAPS_LATEST("firmware-auto-efi-nvram-path");
1461     DO_TEST_CAPS_LATEST("firmware-auto-efi-nvram-template");
1462     DO_TEST_CAPS_LATEST_FAILURE("firmware-auto-efi-nvram-template-nonstandard");
1463     DO_TEST_CAPS_LATEST("firmware-auto-efi-nvram-file");
1464     DO_TEST_CAPS_LATEST("firmware-auto-efi-nvram-network-nbd");
1465     DO_TEST_CAPS_LATEST("firmware-auto-efi-nvram-network-iscsi");
1466
1467     DO_TEST_CAPS_LATEST("firmware-auto-efi-format-loader-qcow2");
1468     DO_TEST_CAPS_LATEST("firmware-auto-efi-format-loader-qcow2-nvram-path");
1469     DO_TEST_CAPS_LATEST("firmware-auto-efi-format-nvram-qcow2");
1470     DO_TEST_CAPS_LATEST("firmware-auto-efi-format-nvram-qcow2-path");
1471     DO_TEST_CAPS_LATEST("firmware-auto-efi-format-nvram-qcow2-network-nbd");
1472     DO_TEST_CAPS_ARCH_LATEST("firmware-auto-efi-format-loader-raw", "aarch64");
1473     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("firmware-auto-efi-format-loader-raw", "aarch64");
1474     DO_TEST_CAPS_LATEST("firmware-auto-efi-format-mismatch");
1475
1476     DO_TEST_CAPS_LATEST("clock-utc");
1477     DO_TEST_CAPS_LATEST("clock-localtime");
1478     DO_TEST_CAPS_LATEST("clock-localtime-basis-localtime");
1479     DO_TEST_CAPS_LATEST("clock-variable");
1480     DO_TEST_CAPS_LATEST("clock-france");
1481     DO_TEST_CAPS_VER("clock-hpet-off", "7.2.0");
1482     DO_TEST_CAPS_LATEST("clock-hpet-off");
1483     DO_TEST_CAPS_LATEST("clock-catchup");
1484     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-kvmclock", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
1485     DO_TEST_CAPS_LATEST("cpu-host-kvmclock");
1486     DO_TEST_CAPS_LATEST("kvmclock");
1487     DO_TEST_CAPS_LATEST("clock-timer-hyperv-rtc");
1488     DO_TEST_CAPS_LATEST("clock-realtime");
1489     DO_TEST_CAPS_LATEST("clock-absolute");
1490
1491     DO_TEST_CAPS_LATEST("controller-usb-order");
1492
1493     DO_TEST_CAPS_LATEST("controller-order");
1494     /* 'eoi' cpu feature with an explicit CPU defined */
1495     DO_TEST_CAPS_LATEST("cpu-eoi-disabled");
1496     DO_TEST_CAPS_LATEST("cpu-eoi-enabled");
1497     /* 'eoi' cpu feature without an explicit CPU defined */
1498     DO_TEST_CAPS_LATEST("eoi-disabled");
1499     DO_TEST_CAPS_LATEST("eoi-enabled");
1500     DO_TEST_CAPS_LATEST("pv-spinlock-disabled");
1501     DO_TEST_CAPS_LATEST("pv-spinlock-enabled");
1502     DO_TEST_CAPS_LATEST("kvmclock+eoi-disabled");
1503
1504     DO_TEST_CAPS_LATEST("hyperv");
1505     DO_TEST_CAPS_LATEST("hyperv-off");
1506     DO_TEST_CAPS_LATEST("hyperv-panic");
1507     DO_TEST_CAPS_VER("hyperv-passthrough", "6.1.0");
1508     DO_TEST_CAPS_LATEST("hyperv-passthrough");
1509     DO_TEST_CAPS_LATEST("hyperv-stimer-direct");
1510
1511     DO_TEST_CAPS_LATEST("kvm-features");
1512     DO_TEST_CAPS_LATEST("kvm-features-off");
1513
1514     DO_TEST_CAPS_LATEST("pmu-feature");
1515     DO_TEST_CAPS_LATEST("pmu-feature-off");
1516
1517     DO_TEST_CAPS_LATEST("pages-discard");
1518     DO_TEST_CAPS_LATEST("pages-discard-hugepages");
1519     DO_TEST_CAPS_LATEST("pages-dimm-discard");
1520     DO_TEST_CAPS_LATEST("hugepages-default");
1521     DO_TEST_CAPS_LATEST("hugepages-default-2M");
1522     DO_TEST_CAPS_LATEST("hugepages-default-system-size");
1523     DO_TEST_CAPS_LATEST_FAILURE("hugepages-default-5M");
1524     DO_TEST_CAPS_LATEST_PARSE_ERROR("hugepages-default-1G-nodeset-2M");
1525     DO_TEST_CAPS_LATEST("hugepages-nodeset");
1526     DO_TEST_CAPS_LATEST_PARSE_ERROR("hugepages-nodeset-nonexist");
1527     DO_TEST_CAPS_LATEST("hugepages-numa-default");
1528     DO_TEST_CAPS_LATEST("hugepages-numa-default-2M");
1529     DO_TEST_CAPS_LATEST("hugepages-numa-default-dimm");
1530     DO_TEST_CAPS_LATEST("hugepages-numa-nodeset");
1531     DO_TEST_CAPS_LATEST("hugepages-numa-nodeset-part");
1532     DO_TEST_CAPS_LATEST_PARSE_ERROR("hugepages-numa-nodeset-nonexist");
1533     DO_TEST_CAPS_LATEST("hugepages-shared");
1534     DO_TEST_CAPS_LATEST_PARSE_ERROR("hugepages-memaccess-invalid");
1535     DO_TEST_CAPS_LATEST("hugepages-memaccess");
1536     DO_TEST_CAPS_LATEST("hugepages-memaccess2");
1537     DO_TEST_CAPS_LATEST("hugepages-memaccess3");
1538     DO_TEST_CAPS_LATEST("hugepages-nvdimm");
1539     DO_TEST_CAPS_LATEST("nosharepages");
1540
1541     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("non-x86_64-timer-error", "s390x");
1542
1543     DO_TEST_CAPS_LATEST("disk-cdrom");
1544     DO_TEST_CAPS_LATEST("disk-cdrom-empty-network-invalid");
1545     DO_TEST_CAPS_LATEST("disk-cdrom-bus-other");
1546     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-cdrom-usb-empty");
1547     DO_TEST_CAPS_LATEST("disk-cdrom-network");
1548     DO_TEST_CAPS_LATEST("disk-cdrom-tray");
1549     DO_TEST_CAPS_LATEST("disk-floppy");
1550     DO_TEST_CAPS_LATEST("disk-floppy-q35");
1551     DO_TEST_CAPS_ARCH_LATEST_FAILURE("disk-floppy-pseries", "ppc64");
1552     DO_TEST_CAPS_LATEST("disk-floppy-tray");
1553     DO_TEST_CAPS_LATEST("disk-virtio");
1554     DO_TEST_CAPS_ARCH_LATEST("disk-virtio-ccw", "s390x");
1555     DO_TEST_CAPS_ARCH_LATEST("disk-virtio-ccw-many", "s390x");
1556     DO_TEST_CAPS_ARCH_LATEST("disk-virtio-s390-zpci", "s390x");
1557     DO_TEST_CAPS_LATEST("disk-order");
1558     DO_TEST_CAPS_LATEST("disk-virtio-queues");
1559     DO_TEST_CAPS_LATEST("disk-boot-disk");
1560     DO_TEST_CAPS_LATEST("disk-boot-cdrom");
1561     DO_TEST_CAPS_LATEST("floppy-drive-fat");
1562     DO_TEST_CAPS_LATEST("disk-readonly-disk");
1563     DO_TEST_CAPS_LATEST("disk-fmt-qcow");
1564     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-fmt-cow");
1565     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-fmt-dir");
1566     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-fmt-iso");
1567     DO_TEST_CAPS_LATEST("disk-shared");
1568     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-shared-qcow");
1569     DO_TEST_CAPS_LATEST("disk-error-policy");
1570     DO_TEST_CAPS_ARCH_LATEST("disk-error-policy-s390x", "s390x");
1571     DO_TEST_CAPS_LATEST("disk-cache");
1572     DO_TEST_CAPS_LATEST("disk-metadata-cache");
1573     DO_TEST_CAPS_LATEST("disk-transient");
1574     DO_TEST_CAPS_LATEST("disk-network-nbd");
1575     DO_TEST_CAPS_LATEST("disk-network-iscsi");
1576     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-network-iscsi-auth-secrettype-invalid");
1577     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-network-iscsi-auth-wrong-secrettype");
1578     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-network-source-auth-both");
1579     /* 'gluster' protocol backend was deprecated in qemu-9.2 */
1580     DO_TEST_CAPS_VER("disk-network-gluster", "9.1.0");
1581     DO_TEST_CAPS_LATEST("disk-network-rbd");
1582     DO_TEST_CAPS_VER_PARSE_ERROR("disk-network-rbd-encryption", "6.0.0");
1583     DO_TEST_CAPS_LATEST("disk-network-rbd-encryption");
1584     DO_TEST_CAPS_VER_PARSE_ERROR("disk-network-rbd-encryption-layering", "7.2.0");
1585     DO_TEST_CAPS_LATEST("disk-network-rbd-encryption-layering");
1586     DO_TEST_CAPS_VER_PARSE_ERROR("disk-network-rbd-encryption-luks-any", "7.2.0");
1587     DO_TEST_CAPS_LATEST("disk-network-rbd-encryption-luks-any");
1588     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-encryption-wrong");
1589     DO_TEST_CAPS_LATEST("disk-network-rbd-no-colon");
1590     /* qemu-6.0 is the last qemu version supporting sheepdog */
1591     DO_TEST_CAPS_VER("disk-network-sheepdog", "6.0.0");
1592     DO_TEST_CAPS_LATEST("disk-network-source-auth");
1593     DO_TEST_CAPS_LATEST("disk-network-source-curl");
1594     DO_TEST_CAPS_LATEST("disk-network-nfs");
1595     driver.config->vxhsTLS = 1;
1596     driver.config->nbdTLSx509secretUUID = g_strdup("6fd3f62d-9fe7-4a4e-a869-7acd6376d8ea");
1597     driver.config->vxhsTLSx509secretUUID = g_strdup("6fd3f62d-9fe7-4a4e-a869-7acd6376d8ea");
1598     DO_TEST_CAPS_VER("disk-network-tlsx509-nbd", "5.2.0");
1599     DO_TEST_CAPS_LATEST("disk-network-tlsx509-nbd");
1600     DO_TEST_CAPS_VER_PARSE_ERROR("disk-network-tlsx509-nbd-hostname", "6.2.0");
1601     DO_TEST_CAPS_LATEST("disk-network-tlsx509-nbd-hostname");
1602     DO_TEST_CAPS_LATEST("disk-network-http");
1603     VIR_FREE(driver.config->nbdTLSx509secretUUID);
1604     VIR_FREE(driver.config->vxhsTLSx509secretUUID);
1605     driver.config->vxhsTLS = 0;
1606     DO_TEST_CAPS_LATEST("disk-network-ssh");
1607     DO_TEST_CAPS_LATEST("disk-no-boot");
1608     DO_TEST_CAPS_LATEST("disk-nvme");
1609     DO_TEST_CAPS_LATEST("disk-vhostuser-numa");
1610     DO_TEST_CAPS_LATEST("disk-vhostuser");
1611     DO_TEST_CAPS_ARCH_LATEST_FULL("disk-vhostvdpa", "x86_64",
1612                                   ARG_VDPA_FD, "/dev/vhost-vdpa-0", 201);
1613     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-device-lun-type-invalid");
1614     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-attaching-partition-nosupport");
1615     DO_TEST_CAPS_LATEST("disk-usb-device");
1616     DO_TEST_CAPS_LATEST("disk-device-removable");
1617     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-usb-pci");
1618     DO_TEST_CAPS_LATEST("disk-scsi");
1619     DO_TEST_CAPS_LATEST("disk-scsi-device-auto");
1620     DO_TEST_CAPS_LATEST("disk-scsi-disk-split");
1621     DO_TEST_CAPS_LATEST("disk-scsi-disk-wwn");
1622     DO_TEST_CAPS_LATEST("disk-scsi-disk-vpd");
1623     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-scsi-disk-vpd-build-error");
1624     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-scsi-product-length");
1625     DO_TEST_CAPS_LATEST("controller-virtio-scsi");
1626     DO_TEST_CAPS_LATEST("controller-scsi-auto");
1627     DO_TEST_CAPS_LATEST("disk-sata-device");
1628     DO_TEST_CAPS_LATEST("disk-sata-product");
1629     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-target-overflow");
1630     DO_TEST_CAPS_LATEST("disk-aio");
1631     DO_TEST_CAPS_LATEST("disk-aio-io_uring");
1632     DO_TEST_CAPS_LATEST("disk-source-pool");
1633     DO_TEST_CAPS_LATEST("disk-source-pool-mode");
1634     DO_TEST_CAPS_LATEST("disk-ioeventfd");
1635     DO_TEST_CAPS_LATEST("disk-copy_on_read");
1636     DO_TEST_CAPS_LATEST("disk-discard");
1637     DO_TEST_CAPS_LATEST("disk-detect-zeroes");
1638     DO_TEST_CAPS_LATEST("disk-discard_no_unref");
1639     DO_TEST_CAPS_LATEST("disk-snapshot");
1640     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-same-targets");
1641     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-missing-target-invalid");
1642     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-address-conflict");
1643     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-hostdev-scsi-address-conflict");
1644     DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdevs-drive-address-conflict");
1645     DO_TEST_CAPS_LATEST("event_idx");
1646     DO_TEST_CAPS_VER("virtio-lun", "9.0.0");
1647     DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-lun");
1648     DO_TEST_CAPS_LATEST("disk-scsi-lun-passthrough");
1649     DO_TEST_CAPS_LATEST("disk-serial");
1650     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-fdc-incompatible-address");
1651     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-ide-incompatible-address");
1652     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-sata-incompatible-address");
1653     DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-scsi-incompatible-address");
1654     DO_TEST_CAPS_LATEST("disk-backing-chains-index");
1655     DO_TEST_CAPS_LATEST("disk-backing-chains-noindex");
1656     DO_TEST_CAPS_LATEST("disk-qcow2-datafile-store");
1657     DO_TEST_CAPS_ARCH_LATEST_FULL("disk-source-fd", "x86_64",
1658                                   ARG_FD_GROUP, "testgroup2", 2, 200, 205,
1659                                   ARG_FD_GROUP, "testgroup5", 1, 204,
1660                                   ARG_FD_GROUP, "testgroup6", 2, 247, 248);
1661
1662     DO_TEST_CAPS_LATEST("disk-slices");
1663     DO_TEST_CAPS_LATEST("disk-rotation");
1664
1665     DO_TEST_CAPS_ARCH_LATEST("disk-arm-virtio-sd", "aarch64");
1666
1667     DO_TEST_CAPS_LATEST("encrypted-disk");
1668     DO_TEST_CAPS_LATEST("encrypted-disk-usage");
1669     DO_TEST_CAPS_LATEST("luks-disks");
1670     DO_TEST_CAPS_LATEST("luks-disks-source");
1671     DO_TEST_CAPS_VER("luks-disks-source-qcow2", "5.2.0");
1672     DO_TEST_CAPS_LATEST("luks-disks-source-qcow2");
1673     DO_TEST_CAPS_LATEST_PARSE_ERROR("luks-disk-invalid");
1674     DO_TEST_CAPS_LATEST_PARSE_ERROR("luks-disks-source-both");
1675
1676     DO_TEST_CAPS_LATEST("disk-ide-split");
1677     DO_TEST_CAPS_LATEST("disk-ide-wwn");
1678     DO_TEST_CAPS_LATEST("disk-geometry");
1679     DO_TEST_CAPS_LATEST("disk-blockio");
1680
1681     driver.config->storageUseNbdkit = 1;
1682     DO_TEST_CAPS_LATEST_NBDKIT("disk-cdrom-network-nbdkit", QEMU_NBDKIT_CAPS_PLUGIN_CURL);
1683     DO_TEST_CAPS_LATEST_NBDKIT("disk-network-source-curl-nbdkit", QEMU_NBDKIT_CAPS_PLUGIN_CURL);
1684     DO_TEST_CAPS_LATEST_NBDKIT("disk-network-source-curl-nbdkit-backing", QEMU_NBDKIT_CAPS_PLUGIN_CURL);
1685     DO_TEST_CAPS_LATEST_NBDKIT("disk-network-http-nbdkit", QEMU_NBDKIT_CAPS_PLUGIN_CURL);
1686     DO_TEST_CAPS_LATEST_NBDKIT("disk-network-ssh-nbdkit", QEMU_NBDKIT_CAPS_PLUGIN_SSH);
1687     DO_TEST_CAPS_LATEST_NBDKIT("disk-network-ssh-password", QEMU_NBDKIT_CAPS_PLUGIN_SSH);
1688     DO_TEST_CAPS_LATEST_NBDKIT("disk-network-ssh-key", QEMU_NBDKIT_CAPS_PLUGIN_SSH);
1689     driver.config->storageUseNbdkit = 0;
1690
1691     DO_TEST_CAPS_VER("disk-virtio-scsi-reservations", "5.2.0");
1692     DO_TEST_CAPS_LATEST("disk-virtio-scsi-reservations");
1693
1694     DO_TEST_CAPS_LATEST("graphics-egl-headless");
1695     DO_TEST_CAPS_LATEST("graphics-egl-headless-rendernode");
1696
1697     DO_TEST_CAPS_LATEST("graphics-vnc");
1698     DO_TEST_CAPS_LATEST("graphics-vnc-socket");
1699     DO_TEST_CAPS_LATEST("graphics-vnc-websocket");
1700     DO_TEST_CAPS_LATEST("graphics-vnc-policy");
1701     DO_TEST_CAPS_LATEST("graphics-vnc-power");
1702     DO_TEST_CAPS_LATEST("graphics-vnc-no-listen-attr");
1703     DO_TEST_CAPS_LATEST("graphics-vnc-remove-generated-socket");
1704     driver.config->vncAutoUnixSocket = true;
1705     DO_TEST_CAPS_LATEST("graphics-vnc-auto-socket-cfg");
1706     driver.config->vncAutoUnixSocket = false;
1707     DO_TEST_CAPS_LATEST("graphics-vnc-auto-socket");
1708     DO_TEST_CAPS_LATEST("graphics-vnc-none");
1709     DO_TEST_CAPS_LATEST("graphics-vnc-socket-new-cmdline");
1710
1711     driver.config->vncSASL = 1;
1712     DO_TEST_CAPS_LATEST("graphics-vnc-sasl");
1713     driver.config->vncTLS = 1;
1714     driver.config->vncTLSx509verify = 1;
1715     DO_TEST_CAPS_LATEST("graphics-vnc-tls");
1716     driver.config->vncTLSx509secretUUID = g_strdup("6fd3f62d-9fe7-4a4e-a869-7acd6376d8ea");
1717     DO_TEST_CAPS_VER("graphics-vnc-tls-secret", "5.2.0");
1718     DO_TEST_CAPS_LATEST("graphics-vnc-tls-secret");
1719     VIR_FREE(driver.config->vncTLSx509secretUUID);
1720     driver.config->vncSASL = driver.config->vncTLSx509verify = driver.config->vncTLS = 0;
1721     DO_TEST_CAPS_LATEST("graphics-vnc-egl-headless");
1722
1723     DO_TEST_CAPS_LATEST("graphics-sdl");
1724     DO_TEST_CAPS_LATEST_PARSE_ERROR("graphics-sdl-egl-headless");
1725     DO_TEST_CAPS_LATEST("graphics-sdl-fullscreen");
1726
1727     driver.config->spiceTLS = 1;
1728     DO_TEST_CAPS_LATEST("graphics-spice");
1729     DO_TEST_CAPS_LATEST("graphics-spice-no-args");
1730     driver.config->spiceSASL = 1;
1731     DO_TEST_CAPS_LATEST("graphics-spice-sasl");
1732     driver.config->spiceSASL = 0;
1733     DO_TEST_CAPS_LATEST("graphics-spice-agentmouse");
1734     DO_TEST_CAPS_LATEST("graphics-spice-compression");
1735     DO_TEST_CAPS_LATEST("graphics-spice-timeout");
1736     DO_TEST_CAPS_LATEST("graphics-spice-qxl-vga");
1737     DO_TEST_CAPS_LATEST("graphics-spice-usb-redir");
1738     DO_TEST_CAPS_LATEST("graphics-spice-agent-file-xfer");
1739     DO_TEST_CAPS_LATEST("graphics-spice-socket");
1740     DO_TEST_CAPS_LATEST("graphics-spice-auto-socket");
1741     driver.config->spiceAutoUnixSocket = true;
1742     DO_TEST_CAPS_LATEST("graphics-spice-auto-socket-cfg");
1743     driver.config->spiceAutoUnixSocket = false;
1744     DO_TEST_CAPS_LATEST("graphics-spice-egl-headless");
1745     DO_TEST_CAPS_LATEST_PARSE_ERROR("graphics-spice-invalid-egl-headless");
1746     DO_TEST_CAPS_LATEST("graphics-spice-gl-auto-rendernode");
1747     driver.config->spiceTLS = 0;
1748
1749     DO_TEST_CAPS_LATEST("graphics-dbus");
1750     DO_TEST_CAPS_LATEST("graphics-dbus-address");
1751     DO_TEST_CAPS_LATEST("graphics-dbus-p2p");
1752     DO_TEST_CAPS_LATEST("graphics-dbus-audio");
1753     DO_TEST_CAPS_LATEST("graphics-dbus-chardev");
1754     DO_TEST_CAPS_LATEST("graphics-dbus-usbredir");
1755
1756     DO_TEST_CAPS_LATEST("input-usbmouse");
1757     DO_TEST_CAPS_LATEST("input-usbtablet");
1758
1759     /* tests for ACPI support handling:
1760      *  - existing positive test cases enabling ACPI for aarch64/x86_64/loongarch:
1761      *     - firmware-manual-efi-acpi-q35
1762      *     - firmware-manual-efi-acpi-aarch64
1763      *     - firmware-auto-efi-loongarch64
1764      *
1765      *  - negative case for aarch64 with 'borzoi' machine not supporting ACPI
1766      *
1767      *  - s390x has hack to strip ACPI to preserve migration of old configs,
1768      *    but should produce error when ABI_UPDATE is requested
1769      */
1770     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("aarch64-noacpi-acpi", "aarch64");
1771     DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-acpi", "riscv64");
1772     DO_TEST_CAPS_ARCH_LATEST("s390x-ccw-acpi", "s390x");
1773     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE_PARSE_ERROR("s390x-ccw-acpi", "s390x");
1774
1775     DO_TEST_CAPS_LATEST("misc-disable-s3");
1776     DO_TEST_CAPS_LATEST("misc-disable-suspends");
1777     DO_TEST_CAPS_LATEST("misc-enable-s4");
1778     DO_TEST_CAPS_VER("misc-no-reboot", "5.2.0");
1779     DO_TEST_CAPS_LATEST("misc-no-reboot");
1780     DO_TEST_CAPS_LATEST("misc-uuid");
1781
1782     DO_TEST_CAPS_LATEST_PARSE_ERROR("vhost_queues-invalid");
1783
1784     DO_TEST_CAPS_LATEST("net-vhostuser");
1785     DO_TEST_CAPS_LATEST("net-vhostuser-multiq");
1786     DO_TEST_CAPS_LATEST_FAILURE("net-vhostuser-fail");
1787     DO_TEST_CAPS_LATEST("net-user");
1788     DO_TEST_CAPS_ARCH_LATEST_FULL("net-user", "x86_64", ARG_FLAGS, FLAG_SLIRP_HELPER | FLAG_ALLOW_DUPLICATE_OUTPUT);
1789     DO_TEST_CAPS_LATEST("net-user-addr");
1790     DO_TEST_CAPS_LATEST("net-user-passt");
1791     DO_TEST_CAPS_VER("net-user-passt", "7.2.0");
1792     DO_TEST_CAPS_LATEST_PARSE_ERROR("net-user-slirp-portforward");
1793     DO_TEST_CAPS_LATEST("net-virtio");
1794     DO_TEST_CAPS_LATEST("net-virtio-device");
1795     DO_TEST_CAPS_LATEST("net-virtio-disable-offloads");
1796     DO_TEST_CAPS_LATEST("net-virtio-netdev");
1797     DO_TEST_CAPS_LATEST("net-virtio-vhost");
1798     DO_TEST_CAPS_ARCH_LATEST("net-virtio-ccw", "s390x");
1799     DO_TEST_CAPS_LATEST("net-virtio-rxtxqueuesize");
1800     DO_TEST_CAPS_LATEST_PARSE_ERROR("net-virtio-rxqueuesize-invalid-size");
1801     DO_TEST_CAPS_LATEST("net-virtio-teaming");
1802     DO_TEST_CAPS_LATEST("net-virtio-teaming-hostdev");
1803     DO_TEST_CAPS_LATEST("net-linkstate");
1804     DO_TEST_CAPS_LATEST("net-eth");
1805     DO_TEST_CAPS_LATEST("net-eth-ifname");
1806     DO_TEST_CAPS_LATEST("net-eth-names");
1807     DO_TEST_CAPS_LATEST("net-eth-hostip");
1808     DO_TEST_CAPS_LATEST("net-eth-unmanaged-tap");
1809     DO_TEST_CAPS_LATEST("net-client");
1810     DO_TEST_CAPS_LATEST("net-server");
1811     DO_TEST_CAPS_LATEST("net-many-models");
1812     DO_TEST_CAPS_LATEST("net-mcast");
1813     DO_TEST_CAPS_LATEST("net-udp");
1814     DO_TEST_CAPS_LATEST("net-hostdev");
1815     DO_TEST_CAPS_LATEST("net-hostdev-bootorder");
1816     DO_TEST_CAPS_LATEST("net-hostdev-multidomain");
1817     DO_TEST_CAPS_LATEST("net-hostdev-vfio");
1818     DO_TEST_CAPS_LATEST("net-hostdev-vfio-multidomain");
1819     DO_TEST_CAPS_LATEST_FAILURE("net-hostdev-fail");
1820     DO_TEST_CAPS_LATEST("net-vdpa");
1821     DO_TEST_CAPS_LATEST("net-vdpa-multiqueue");
1822     DO_TEST_CAPS_LATEST("net-virtio-rss");
1823
1824     DO_TEST_CAPS_LATEST("hostdev-pci-multifunction");
1825
1826     DO_TEST_CAPS_LATEST("hostdev-pci-address-unassigned");
1827
1828     DO_TEST_CAPS_LATEST("serial-file-log");
1829     driver.config->spiceTLS = 1;
1830     DO_TEST_CAPS_LATEST("serial-spiceport");
1831     driver.config->spiceTLS = 0;
1832     DO_TEST_CAPS_LATEST("serial-debugcon");
1833
1834     DO_TEST_CAPS_LATEST("console-compat");
1835     DO_TEST_CAPS_LATEST("console-compat-auto");
1836     DO_TEST_CAPS_LATEST("console-compat-crash");
1837
1838     /* 'qemu-9.2' deprecated 'reconnect' in favor of 'reconnect-ms' */
1839     DO_TEST_CAPS_VER("chardev-backends", "9.1.0");
1840     DO_TEST_CAPS_LATEST("chardev-backends");
1841     /* As qemu doesn't yet support JSON syntax for -chardev we use the
1842      * QEMU_CAPS_CHARDEV_JSON capability just in the tests to have QMP schema
1843      * validation also for the QMP mode of the -chardev props generator */
1844     DO_TEST_CAPS_ARCH_VER_FULL("chardev-backends-json", "x86_64", "9.1.0", ARG_QEMU_CAPS, QEMU_CAPS_CHARDEV_JSON, QEMU_CAPS_LAST);
1845     DO_TEST_CAPS_ARCH_LATEST_FULL("chardev-backends-json", "x86_64", ARG_QEMU_CAPS, QEMU_CAPS_CHARDEV_JSON, QEMU_CAPS_LAST);
1846
1847     DO_TEST_CAPS_LATEST("serial-vc-chardev");
1848     DO_TEST_CAPS_LATEST("serial-pty-chardev");
1849     DO_TEST_CAPS_LATEST("serial-dev-chardev");
1850     DO_TEST_CAPS_LATEST("serial-dev-chardev-iobase");
1851     DO_TEST_CAPS_LATEST("serial-file-chardev");
1852     DO_TEST_CAPS_LATEST("serial-unix-chardev");
1853     DO_TEST_CAPS_LATEST_PARSE_ERROR("serial-unix-missing-source");
1854     DO_TEST_CAPS_LATEST("serial-tcp-chardev");
1855     DO_TEST_CAPS_LATEST_PARSE_ERROR("serial-tcp-chardev-telnets");
1856     DO_TEST_CAPS_LATEST("serial-udp-chardev");
1857     DO_TEST_CAPS_LATEST("serial-tcp-telnet-chardev");
1858     driver.config->chardevTLS = 1;
1859     DO_TEST_CAPS_LATEST("serial-tcp-tlsx509-chardev");
1860     driver.config->chardevTLSx509verify = 1;
1861     DO_TEST_CAPS_LATEST("serial-tcp-tlsx509-chardev-verify");
1862     driver.config->chardevTLSx509verify = 0;
1863     DO_TEST_CAPS_LATEST("serial-tcp-tlsx509-chardev-notls");
1864     driver.config->chardevTLSx509secretUUID = g_strdup("6fd3f62d-9fe7-4a4e-a869-7acd6376d8ea");
1865     DO_TEST_CAPS_LATEST("serial-tcp-tlsx509-secret-chardev");
1866     VIR_FREE(driver.config->chardevTLSx509secretUUID);
1867     driver.config->chardevTLS = 0;
1868     DO_TEST_CAPS_LATEST("serial-many-chardev");
1869     DO_TEST_CAPS_LATEST("parallel-tcp-chardev");
1870     DO_TEST_CAPS_LATEST("parallel-parport-chardev");
1871     DO_TEST_CAPS_LATEST("parallel-unix-chardev");
1872     DO_TEST_CAPS_LATEST("console-compat-chardev");
1873     DO_TEST_CAPS_LATEST("pci-serial-dev-chardev");
1874
1875     DO_TEST_CAPS_LATEST("channel-guestfwd");
1876     DO_TEST_CAPS_LATEST("channel-unix-guestfwd");
1877     DO_TEST_CAPS_LATEST("channel-virtio");
1878     DO_TEST_CAPS_LATEST("channel-virtio-state");
1879     DO_TEST_CAPS_LATEST("channel-virtio-auto");
1880     DO_TEST_CAPS_LATEST("channel-virtio-autoassign");
1881     DO_TEST_CAPS_LATEST("channel-virtio-autoadd");
1882     DO_TEST_CAPS_LATEST("console-virtio");
1883     DO_TEST_CAPS_LATEST("console-virtio-many");
1884     DO_TEST_CAPS_ARCH_LATEST("console-virtio-ccw", "s390x");
1885     DO_TEST_CAPS_LATEST("console-virtio-unix");
1886     DO_TEST_CAPS_ARCH_LATEST("console-sclp", "s390x");
1887     driver.config->spiceTLS = 1;
1888     DO_TEST_CAPS_LATEST("channel-spicevmc");
1889     driver.config->spiceTLS = 0;
1890     DO_TEST_CAPS_LATEST("channel-qemu-vdagent");
1891     DO_TEST_CAPS_LATEST("channel-qemu-vdagent-features");
1892     DO_TEST_CAPS_LATEST("channel-virtio-default");
1893     DO_TEST_CAPS_LATEST("channel-virtio-unix");
1894
1895     DO_TEST_CAPS_LATEST("smartcard-host");
1896     DO_TEST_CAPS_LATEST("smartcard-host-certificates");
1897     DO_TEST_CAPS_LATEST("smartcard-host-certificates-database");
1898     DO_TEST_CAPS_LATEST("smartcard-passthrough-tcp");
1899     DO_TEST_CAPS_LATEST("smartcard-passthrough-spicevmc");
1900     DO_TEST_CAPS_LATEST("smartcard-controller");
1901     DO_TEST_CAPS_LATEST("smartcard-passthrough-unix");
1902
1903     /* 'qemu-9.2' deprecated 'reconnect' in favor of 'reconnect-ms' */
1904     DO_TEST_CAPS_VER("chardev-reconnect", "9.1.0");
1905     DO_TEST_CAPS_LATEST("chardev-reconnect");
1906     DO_TEST_CAPS_LATEST_PARSE_ERROR("chardev-reconnect-invalid-timeout");
1907     DO_TEST_CAPS_LATEST_PARSE_ERROR("chardev-reconnect-generated-path");
1908
1909     DO_TEST_CAPS_LATEST("usb-controller-implicit-isapc");
1910     DO_TEST_CAPS_LATEST("usb-controller-implicit-i440fx");
1911     DO_TEST_CAPS_LATEST("usb-controller-implicit-q35");
1912     DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-controller-default-isapc");
1913     DO_TEST_CAPS_LATEST("usb-controller-default-i440fx");
1914     DO_TEST_CAPS_LATEST("usb-controller-default-q35");
1915     DO_TEST_CAPS_ARCH_LATEST("usb-controller-default-pseries", "ppc64");
1916     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("usb-controller-default-pseries", "ppc64");
1917     DO_TEST_CAPS_ARCH_LATEST("usb-controller-default-g3beige", "ppc64");
1918     DO_TEST_CAPS_ARCH_LATEST("usb-controller-default-mac99", "ppc64");
1919     DO_TEST_CAPS_ARCH_LATEST("usb-controller-default-mac99ppc", "ppc");
1920     DO_TEST_CAPS_ARCH_LATEST("usb-controller-default-powernv9", "ppc64");
1921     /* Until qemu-8.1 (see commit 6fe4464c05f) it was possible to compile
1922      * out USB support from i440fx; the implicit -usb controller still failed */
1923     DO_TEST_FULL("usb-controller-default-unavailable-i440fx", ".x86_64-latest",
1924                  ARG_CAPS_ARCH, "x86_64",
1925                  ARG_CAPS_VER, "latest",
1926                  ARG_FLAGS, FLAG_EXPECT_FAILURE,
1927                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_LAST,
1928                  ARG_END);
1929     /* The implicit controller can be compiled out for q35; initialization fails though */
1930     DO_TEST_FULL("usb-controller-default-unavailable-q35", ".x86_64-latest",
1931                  ARG_CAPS_ARCH, "x86_64",
1932                  ARG_CAPS_VER, "latest",
1933                  ARG_FLAGS, FLAG_EXPECT_FAILURE,
1934                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_LAST,
1935                  ARG_END);
1936     /* However, if the USB controller is the one that gets added
1937      * automatically for every guest instead of one that the user has
1938      * explicitly asked for, we prefer simply skipping it */
1939     DO_TEST_FULL("usb-controller-automatic-unavailable-q35", ".x86_64-latest",
1940                  ARG_CAPS_ARCH, "x86_64",
1941                  ARG_CAPS_VER, "latest",
1942                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_DEVICE_QEMU_XHCI, QEMU_CAPS_NEC_USB_XHCI, QEMU_CAPS_ICH9_USB_EHCI1, QEMU_CAPS_LAST,
1943                  ARG_END);
1944
1945     /* The USB controllers can be compiled out but downgrade to -usb fails in qemu */
1946     DO_TEST_FULL("usb-controller-default-unavailable-pseries", ".ppc64-latest",
1947                  ARG_CAPS_ARCH, "ppc64",
1948                  ARG_CAPS_VER, "latest",
1949                  ARG_FLAGS, FLAG_EXPECT_FAILURE,
1950                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_NEC_USB_XHCI, QEMU_CAPS_PCI_OHCI, QEMU_CAPS_DEVICE_QEMU_XHCI, QEMU_CAPS_LAST,
1951                  ARG_END);
1952
1953     /* controller selection tests for various uncommon machine types */
1954     DO_TEST_CAPS_ARCH_LATEST("usb-controller-default-versatilepb-aarch64", "aarch64");
1955     DO_TEST_FULL("usb-controller-default-fallback-versatilepb-aarch64", ".aarch64-latest",
1956                  ARG_CAPS_ARCH, "aarch64",
1957                  ARG_CAPS_VER, "latest",
1958                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_LAST,
1959                  ARG_END);
1960     DO_TEST_FULL("usb-controller-default-unavailable-versatilepb-aarch64", ".aarch64-latest",
1961                  ARG_CAPS_ARCH, "aarch64",
1962                  ARG_CAPS_VER, "latest",
1963                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_PCI_OHCI, QEMU_CAPS_LAST,
1964                  ARG_END);
1965
1966     DO_TEST_CAPS_ARCH_LATEST("usb-controller-default-versatilepb-armv7l", "armv7l");
1967     DO_TEST_FULL("usb-controller-default-fallback-versatilepb-armv7l", ".armv7l-latest",
1968                  ARG_CAPS_ARCH, "armv7l",
1969                  ARG_CAPS_VER, "latest",
1970                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_LAST,
1971                  ARG_END);
1972     DO_TEST_FULL("usb-controller-default-unavailable-versatilepb-armv7l", ".armv7l-latest",
1973                  ARG_CAPS_ARCH, "armv7l",
1974                  ARG_CAPS_VER, "latest",
1975                  ARG_FLAGS, FLAG_EXPECT_FAILURE,
1976                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_PCI_OHCI, QEMU_CAPS_LAST,
1977                  ARG_END);
1978
1979     DO_TEST_CAPS_ARCH_LATEST("usb-controller-default-realview", "aarch64");
1980     DO_TEST_FULL("usb-controller-default-fallback-realview", ".aarch64-latest",
1981                  ARG_CAPS_ARCH, "aarch64",
1982                  ARG_CAPS_VER, "latest",
1983                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_LAST,
1984                  ARG_END);
1985     DO_TEST_FULL("usb-controller-default-unavailable-realview", ".aarch64-latest",
1986                  ARG_CAPS_ARCH, "aarch64",
1987                  ARG_CAPS_VER, "latest",
1988                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_PCI_OHCI, QEMU_CAPS_LAST,
1989                  ARG_END);
1990
1991     /* The '-nousb' test case tests machine without a built-in USB controller */
1992     DO_TEST_CAPS_ARCH_LATEST("usb-controller-default-nousb", "aarch64");
1993     DO_TEST_FULL("usb-controller-default-fallback-nousb", ".aarch64-latest",
1994                  ARG_CAPS_ARCH, "aarch64",
1995                  ARG_CAPS_VER, "latest",
1996                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_LAST,
1997                  ARG_END);
1998     DO_TEST_FULL("usb-controller-default-unavailable-nousb", ".aarch64-latest",
1999                  ARG_CAPS_ARCH, "aarch64",
2000                  ARG_CAPS_VER, "latest",
2001                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_PCI_OHCI, QEMU_CAPS_LAST,
2002                  ARG_END);
2003
2004     DO_TEST_FULL("usb-controller-default-fallback-g3beige", ".ppc64-latest",
2005                  ARG_CAPS_ARCH, "ppc64",
2006                  ARG_CAPS_VER, "latest",
2007                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_NEC_USB_XHCI, QEMU_CAPS_DEVICE_QEMU_XHCI, QEMU_CAPS_LAST,
2008                  ARG_END);
2009     DO_TEST_FULL("usb-controller-default-unavailable-g3beige", ".ppc64-latest",
2010                  ARG_CAPS_ARCH, "ppc64",
2011                  ARG_CAPS_VER, "latest",
2012                  ARG_FLAGS, FLAG_EXPECT_FAILURE,
2013                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_NEC_USB_XHCI, QEMU_CAPS_PCI_OHCI, QEMU_CAPS_DEVICE_QEMU_XHCI, QEMU_CAPS_LAST,
2014                  ARG_END);
2015
2016     DO_TEST_FULL("usb-controller-default-fallback-mac99", ".ppc64-latest",
2017                  ARG_CAPS_ARCH, "ppc64",
2018                  ARG_CAPS_VER, "latest",
2019                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_NEC_USB_XHCI, QEMU_CAPS_DEVICE_QEMU_XHCI, QEMU_CAPS_LAST,
2020                  ARG_END);
2021     DO_TEST_FULL("usb-controller-default-unavailable-mac99", ".ppc64-latest",
2022                  ARG_CAPS_ARCH, "ppc64",
2023                  ARG_CAPS_VER, "latest",
2024                  ARG_FLAGS, FLAG_EXPECT_FAILURE,
2025                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_NEC_USB_XHCI, QEMU_CAPS_PCI_OHCI, QEMU_CAPS_DEVICE_QEMU_XHCI, QEMU_CAPS_LAST,
2026                  ARG_END);
2027
2028     DO_TEST_FULL("usb-controller-default-fallback-mac99ppc", ".ppc-latest",
2029                  ARG_CAPS_ARCH, "ppc",
2030                  ARG_CAPS_VER, "latest",
2031                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_NEC_USB_XHCI, QEMU_CAPS_DEVICE_QEMU_XHCI, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_LAST,
2032                  ARG_END);
2033     DO_TEST_FULL("usb-controller-default-unavailable-mac99ppc", ".ppc-latest",
2034                  ARG_CAPS_ARCH, "ppc",
2035                  ARG_CAPS_VER, "latest",
2036                  ARG_FLAGS, FLAG_EXPECT_FAILURE,
2037                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_NEC_USB_XHCI, QEMU_CAPS_PCI_OHCI, QEMU_CAPS_DEVICE_QEMU_XHCI, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_LAST,
2038                  ARG_END);
2039
2040     DO_TEST_FULL("usb-controller-default-fallback-powernv9", ".ppc64-latest",
2041                  ARG_CAPS_ARCH, "ppc64",
2042                  ARG_CAPS_VER, "latest",
2043                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_NEC_USB_XHCI, QEMU_CAPS_DEVICE_QEMU_XHCI, QEMU_CAPS_LAST,
2044                  ARG_END);
2045     DO_TEST_FULL("usb-controller-default-unavailable-powernv9", ".ppc64-latest",
2046                  ARG_CAPS_ARCH, "ppc64",
2047                  ARG_CAPS_VER, "latest",
2048                  ARG_FLAGS, FLAG_EXPECT_FAILURE,
2049                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_NEC_USB_XHCI, QEMU_CAPS_PCI_OHCI, QEMU_CAPS_DEVICE_QEMU_XHCI, QEMU_CAPS_LAST,
2050                  ARG_END);
2051     DO_TEST_CAPS_LATEST("usb-none");
2052
2053     DO_TEST_CAPS_LATEST("usb-controller-piix3");
2054     DO_TEST_CAPS_LATEST("usb-controller-ich9-ehci-addr");
2055     DO_TEST_CAPS_LATEST("usb-controller-ich9-companion");
2056     DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-controller-ich9-no-companion");
2057     DO_TEST_CAPS_LATEST("usb-controller-ich9-autoassign");
2058     DO_TEST_CAPS_LATEST("usb1-usb2");
2059
2060     DO_TEST_CAPS_LATEST("usb-controller-nec-xhci");
2061     DO_TEST_FULL("usb-controller-nec-xhci-unavailable", ".x86_64-latest",
2062                  ARG_CAPS_ARCH, "x86_64",
2063                  ARG_CAPS_VER, "latest",
2064                  ARG_FLAGS, FLAG_EXPECT_FAILURE,
2065                  ARG_QEMU_CAPS_DEL, QEMU_CAPS_NEC_USB_XHCI, QEMU_CAPS_LAST,
2066                  ARG_END);
2067     DO_TEST_CAPS_LATEST("usb-controller-nex-xhci-autoassign");
2068     DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-controller-nec-xhci-limit");
2069     DO_TEST_CAPS_LATEST("usb-controller-qemu-xhci");
2070     DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-controller-qemu-xhci-limit");
2071
2072     DO_TEST_CAPS_LATEST("input-usbmouse-addr");
2073     DO_TEST_CAPS_LATEST("usb-hub");
2074     DO_TEST_CAPS_LATEST("usb-hub-autoadd");
2075     DO_TEST_CAPS_LATEST("usb-hub-autoadd-deluxe");
2076     DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-hub-conflict");
2077     DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-hub-nonexistent");
2078     DO_TEST_CAPS_LATEST("usb-port-missing");
2079     DO_TEST_CAPS_LATEST_FAILURE("usb-bus-missing");
2080     DO_TEST_CAPS_LATEST("usb-ports");
2081     DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-ports-out-of-range");
2082     DO_TEST_CAPS_LATEST("usb-port-autoassign");
2083     DO_TEST_CAPS_LATEST("usb-redir");
2084     DO_TEST_CAPS_LATEST("usb-redir-boot");
2085     DO_TEST_CAPS_LATEST("usb-redir-filter");
2086     DO_TEST_CAPS_LATEST("usb-redir-filter-version");
2087     DO_TEST_CAPS_LATEST("usb-redir-unix");
2088     DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-none-other");
2089     DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-none-hub");
2090     DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-none-usbtablet");
2091     DO_TEST_CAPS_LATEST("usb-long-port-path");
2092
2093     DO_TEST_CAPS_LATEST("smbios");
2094     DO_TEST_CAPS_LATEST_PARSE_ERROR("smbios-date");
2095     DO_TEST_CAPS_LATEST_PARSE_ERROR("smbios-uuid-match");
2096     DO_TEST_CAPS_LATEST("smbios-type-fwcfg");
2097
2098     DO_TEST_CAPS_LATEST("watchdog");
2099     DO_TEST_CAPS_LATEST("watchdog-device");
2100     DO_TEST_CAPS_LATEST("watchdog-dump");
2101     DO_TEST_CAPS_LATEST("watchdog-injectnmi");
2102     DO_TEST_CAPS_LATEST("watchdog-q35-multiple");
2103     DO_TEST_CAPS_ARCH_LATEST("watchdog-diag288", "s390x");
2104
2105     DO_TEST_CAPS_LATEST("balloon-device");
2106     DO_TEST_CAPS_LATEST("balloon-device-deflate");
2107     DO_TEST_CAPS_ARCH_LATEST("balloon-ccw-deflate", "s390x");
2108     DO_TEST_CAPS_ARCH_LATEST("balloon-mmio-deflate", "aarch64");
2109     DO_TEST_CAPS_LATEST("balloon-device-deflate-off");
2110     DO_TEST_CAPS_LATEST("balloon-device-auto");
2111     DO_TEST_CAPS_LATEST("balloon-device-period");
2112
2113     DO_TEST_CAPS_LATEST("sound-device");
2114     DO_TEST_CAPS_LATEST("fs9p");
2115     DO_TEST_CAPS_ARCH_LATEST("fs9p-ccw", "s390x");
2116
2117     DO_TEST_CAPS_LATEST("hostdev-usb-address");
2118     DO_TEST_CAPS_LATEST("hostdev-usb-address-device");
2119     DO_TEST_CAPS_LATEST("hostdev-usb-address-device-boot");
2120     DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-usb-duplicate");
2121     DO_TEST_CAPS_LATEST("hostdev-pci-address");
2122     DO_TEST_CAPS_LATEST("hostdev-pci-address-device");
2123     DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-pci-duplicate");
2124     DO_TEST_CAPS_LATEST("hostdev-pci-display-ramfb");
2125     DO_TEST_CAPS_LATEST("hostdev-vfio");
2126     DO_TEST_CAPS_LATEST("hostdev-vfio-multidomain");
2127     DO_TEST_CAPS_LATEST("hostdev-mdev-precreated");
2128     DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-mdev-src-address-invalid");
2129     DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-mdev-invalid-target-address");
2130     DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-mdev-duplicate");
2131     DO_TEST_CAPS_LATEST("hostdev-mdev-display-spice-opengl");
2132     DO_TEST_CAPS_LATEST("hostdev-mdev-display-spice-egl-headless");
2133     DO_TEST_CAPS_LATEST("hostdev-mdev-display-vnc");
2134     DO_TEST_CAPS_LATEST("hostdev-mdev-display-vnc-egl-headless");
2135     DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-mdev-display-missing-graphics");
2136     DO_TEST_CAPS_LATEST("hostdev-mdev-display-ramfb");
2137     DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-mdev-display-ramfb-multiple");
2138     DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-vfio-zpci-wrong-arch");
2139     DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci", "s390x");
2140     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-vfio-zpci-invalid-uid-valid-fid", "s390x");
2141     DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci-multidomain-many", "s390x");
2142     DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci-autogenerate", "s390x");
2143     DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci-autogenerate-uids", "s390x");
2144     DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci-autogenerate-fids", "s390x");
2145     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-vfio-zpci-uid-set-zero", "s390x");
2146     DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci-boundaries", "s390x");
2147     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-vfio-zpci-duplicate", "s390x");
2148     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-vfio-zpci-set-zero", "s390x");
2149     DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci-ccw-memballoon", "s390x");
2150
2151     DO_TEST_CAPS_LATEST("pci-rom");
2152     DO_TEST_CAPS_LATEST("pci-rom-disabled");
2153     DO_TEST_CAPS_LATEST("pci-rom-disabled-invalid");
2154
2155     DO_TEST_CAPS_ARCH_LATEST("hostdev-subsys-mdev-vfio-ccw", "s390x");
2156     DO_TEST_CAPS_ARCH_LATEST("hostdev-subsys-mdev-vfio-ccw-boot", "s390x");
2157     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ccw-duplicate-address", "s390x");
2158     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ccw-invalid-address", "s390x");
2159
2160     DO_TEST_CAPS_ARCH_LATEST("hostdev-subsys-mdev-vfio-ap", "s390x");
2161     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ap-boot-fail", "s390x");
2162
2163     DO_TEST_CAPS_ARCH_LATEST_FULL("restore-v2", "x86_64",
2164                                   ARG_MIGRATE_FROM, "exec:cat",
2165                                   ARG_MIGRATE_FD, 7);
2166     DO_TEST_CAPS_ARCH_LATEST_FULL("restore-v2-fd", "x86_64",
2167                                   ARG_MIGRATE_FROM, "stdio",
2168                                   ARG_MIGRATE_FD, 7);
2169     DO_TEST_CAPS_ARCH_LATEST_FULL("restore-v2-fd", "x86_64",
2170                                   ARG_MIGRATE_FROM, "fd:7",
2171                                   ARG_MIGRATE_FD, 7,
2172                                   ARG_FLAGS, FLAG_ALLOW_DUPLICATE_OUTPUT);
2173     DO_TEST_CAPS_ARCH_LATEST_FULL("migrate", "x86_64",
2174                                   ARG_MIGRATE_FROM, "tcp:10.0.0.1:5000");
2175     DO_TEST_CAPS_ARCH_LATEST_FULL("migrate-numa-unaligned", "x86_64",
2176                                   ARG_MIGRATE_FROM, "stdio",
2177                                   ARG_MIGRATE_FD, 7);
2178
2179     DO_TEST_CAPS_LATEST("qemu-ns");
2180     DO_TEST_CAPS_LATEST("qemu-ns-no-env");
2181     DO_TEST_CAPS_LATEST("qemu-ns-alt");
2182
2183     DO_TEST_CAPS_LATEST("iothreads-ids");
2184     DO_TEST_CAPS_LATEST("iothreads-ids-partial");
2185     DO_TEST_CAPS_LATEST("iothreads-ids-pool-sizes");
2186     DO_TEST_CAPS_LATEST("iothreads-disk");
2187     DO_TEST_CAPS_VER("iothreads-virtio-scsi-pci", "5.2.0");
2188     DO_TEST_CAPS_LATEST("iothreads-virtio-scsi-pci");
2189     DO_TEST_CAPS_ARCH_LATEST("iothreads-virtio-scsi-ccw", "s390x");
2190
2191     DO_TEST_CAPS_LATEST("cpu-topology1");
2192     DO_TEST_CAPS_LATEST("cpu-topology2");
2193     DO_TEST_CAPS_LATEST("cpu-topology3");
2194     DO_TEST_CAPS_LATEST("cpu-topology4");
2195     DO_TEST_CAPS_ARCH_LATEST("cpu-topology5", "aarch64");
2196
2197     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-minimum1", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2198     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-minimum2", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2199     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-exact1", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2200     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-exact2", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2201     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-exact2-nofallback", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2202     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-strict1", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2203     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-no-removed-features", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2204
2205     /* EPYC-Milan became available in qemu-6.0, use it for the fallback tests */
2206     DO_TEST_CAPS_VER_FAILURE("cpu-nofallback", "5.2.0");
2207     DO_TEST_CAPS_VER("cpu-nofallback", "8.0.0");
2208     DO_TEST_CAPS_VER("cpu-fallback", "5.2.0");
2209     DO_TEST_CAPS_VER("cpu-fallback", "8.0.0");
2210
2211     DO_TEST_CAPS_LATEST("cpu-numa1");
2212     DO_TEST_CAPS_LATEST("cpu-numa-memory-oldstyle");
2213     DO_TEST_CAPS_LATEST("cpu-numa2");
2214     DO_TEST_CAPS_LATEST("cpu-numa-no-memory-element");
2215     DO_TEST_CAPS_LATEST_PARSE_ERROR("cpu-numa3");
2216     DO_TEST_CAPS_LATEST("cpu-numa-disjoint");
2217     DO_TEST_CAPS_LATEST("cpu-numa-memshared");
2218     DO_TEST_CAPS_LATEST_PARSE_ERROR("cpu-numa-distance-nonexistent-sibling");
2219
2220     /* host-model cpu expansion depends on the cpu reported by qemu and thus
2221      * we invoke it for all real capability dumps we have */
2222     DO_TEST_CAPS_VER("cpu-host-model-kvm", "5.2.0");
2223     DO_TEST_CAPS_VER("cpu-host-model-kvm", "6.0.0");
2224     DO_TEST_CAPS_VER("cpu-host-model-kvm", "6.1.0");
2225     DO_TEST_CAPS_VER("cpu-host-model-kvm", "6.2.0");
2226     DO_TEST_CAPS_VER("cpu-host-model-kvm", "7.0.0");
2227     DO_TEST_CAPS_VER("cpu-host-model-kvm", "7.1.0");
2228     DO_TEST_CAPS_VER("cpu-host-model-kvm", "7.2.0");
2229     DO_TEST_CAPS_VER("cpu-host-model-kvm", "8.0.0");
2230     DO_TEST_CAPS_VER("cpu-host-model-kvm", "8.1.0");
2231
2232     DO_TEST_CAPS_VER("cpu-host-model-tcg", "5.2.0");
2233     DO_TEST_CAPS_VER("cpu-host-model-tcg", "6.0.0");
2234     DO_TEST_CAPS_VER("cpu-host-model-tcg", "6.1.0");
2235     DO_TEST_CAPS_VER("cpu-host-model-tcg", "6.2.0");
2236     DO_TEST_CAPS_VER("cpu-host-model-tcg", "7.0.0");
2237     DO_TEST_CAPS_VER("cpu-host-model-tcg", "7.1.0");
2238     DO_TEST_CAPS_VER("cpu-host-model-tcg", "7.2.0");
2239     DO_TEST_CAPS_VER("cpu-host-model-tcg", "8.0.0");
2240     DO_TEST_CAPS_VER("cpu-host-model-tcg", "8.1.0");
2241
2242     DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "5.2.0");
2243     DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "6.0.0");
2244     DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "6.1.0");
2245     DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "6.2.0");
2246     DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "7.0.0");
2247     DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "7.1.0");
2248     DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "7.2.0");
2249     DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "8.0.0");
2250     DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "8.1.0");
2251
2252     DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "5.2.0");
2253     DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "6.0.0");
2254     DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "6.1.0");
2255     DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "6.2.0");
2256     DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "7.0.0");
2257     DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "7.1.0");
2258     DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "7.2.0");
2259     DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "8.0.0");
2260     DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "8.1.0");
2261
2262     DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "5.2.0");
2263     DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "6.0.0");
2264     DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "6.1.0");
2265     DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "6.2.0");
2266     DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "7.0.0");
2267     DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "7.1.0");
2268     DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "7.2.0");
2269     DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "8.0.0");
2270     DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "8.1.0");
2271
2272     DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "5.2.0");
2273     DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "6.0.0");
2274     DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "6.1.0");
2275     DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "6.2.0");
2276     DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "7.0.0");
2277     DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "7.1.0");
2278     DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "7.2.0");
2279     DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "8.0.0");
2280     DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "8.1.0");
2281
2282     /* For this specific test we accept the increased likelihood of changes
2283      * if qemu updates the CPU model */
2284     DO_TEST_CAPS_LATEST("cpu-host-model-kvm");
2285     DO_TEST_CAPS_LATEST("cpu-host-model-fallback-kvm");
2286     DO_TEST_CAPS_LATEST("cpu-host-model-nofallback-kvm");
2287
2288     DO_TEST_CAPS_LATEST("cpu-host-model-tcg");
2289     DO_TEST_CAPS_LATEST("cpu-host-model-fallback-tcg");
2290     DO_TEST_CAPS_LATEST("cpu-host-model-nofallback-tcg");
2291
2292     /* this test case uses 'cpu="host-model"', run it with Haswell host cpu to prevent test case churn */
2293     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-host-model-vendor", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2294     DO_TEST_CAPS_LATEST("cpu-host-passthrough");
2295     DO_TEST_CAPS_LATEST_FAILURE("cpu-qemu-host-passthrough");
2296
2297     DO_TEST_CAPS_ARCH_LATEST("cpu-s390-zEC12", "s390x");
2298     DO_TEST_CAPS_ARCH_LATEST("cpu-s390-features", "s390x");
2299
2300     DO_TEST_CAPS_ARCH_VER_FAILURE("cpu-model-deprecated-features-off", "s390x", "8.2.0");
2301     DO_TEST_CAPS_ARCH_LATEST("cpu-model-deprecated-features-off", "s390x");
2302
2303     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-Haswell", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2304     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-Haswell2", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2305     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-Haswell3", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2306     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-Haswell-noTSX", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2307     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-host-model-cmt", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2308     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-tsc-frequency", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2309
2310     DO_TEST_CAPS_LATEST("cpu-translation");
2311
2312     DO_TEST_CAPS_LATEST("memtune");
2313     DO_TEST_CAPS_LATEST("memtune-unlimited");
2314     DO_TEST_CAPS_LATEST("blkiotune");
2315     DO_TEST_CAPS_LATEST("blkiotune-device");
2316     DO_TEST_CAPS_LATEST("cputune");
2317     DO_TEST_CAPS_LATEST("cputune-zero-shares");
2318     DO_TEST_CAPS_LATEST_PARSE_ERROR("cputune-iothreadsched-toomuch");
2319     DO_TEST_CAPS_LATEST_PARSE_ERROR("cputune-vcpusched-overlap");
2320     DO_TEST_CAPS_LATEST("cputune-numatune");
2321     DO_TEST_CAPS_LATEST("vcpu-placement-static");
2322     DO_TEST_CAPS_LATEST("cputune-cpuset-big-id");
2323     DO_TEST_CAPS_LATEST_PARSE_ERROR("cpuset-invalid");
2324
2325     DO_TEST_CAPS_LATEST_PARSE_ERROR("numatune-memory-invalid-nodeset");
2326     DO_TEST_CAPS_VER("numatune-memnode", "5.2.0");
2327     DO_TEST_CAPS_LATEST("numatune-memnode");
2328     DO_TEST_CAPS_LATEST_PARSE_ERROR("numatune-memnode-invalid-mode");
2329     DO_TEST_CAPS_LATEST("numatune-memnode-restrictive-mode");
2330     DO_TEST_CAPS_LATEST_PARSE_ERROR("numatune-memnode-restrictive-mode-err-mixed");
2331     DO_TEST_CAPS_LATEST("numatune-system-memory");
2332
2333     DO_TEST_CAPS_LATEST("numatune-memnode-no-memory");
2334
2335     DO_TEST_CAPS_LATEST("numatune-distances");
2336     DO_TEST_CAPS_LATEST("numatune-no-vcpu");
2337     DO_TEST_CAPS_LATEST("numatune-hmat");
2338     DO_TEST_CAPS_LATEST("numatune-hmat-none");
2339
2340     DO_TEST_CAPS_LATEST("numatune-auto-nodeset-invalid");
2341     DO_TEST_CAPS_LATEST("numatune-auto-prefer");
2342     DO_TEST_CAPS_LATEST_FAILURE("numatune-static-nodeset-exceed-hostnode");
2343     DO_TEST_CAPS_LATEST_PARSE_ERROR("numatune-memnode-nocpu");
2344     DO_TEST_CAPS_LATEST_PARSE_ERROR("numatune-memnodes-problematic");
2345     DO_TEST_CAPS_LATEST_FAILURE("numatune-memnode-unavailable-strict");
2346     DO_TEST_CAPS_LATEST_FAILURE("numatune-memnode-unavailable-restrictive");
2347
2348     DO_TEST_CAPS_LATEST("numad");
2349     DO_TEST_CAPS_LATEST("numad-auto-vcpu-static-numatune");
2350     DO_TEST_CAPS_LATEST_PARSE_ERROR("numad-auto-vcpu-static-numatune-no-nodeset");
2351     DO_TEST_CAPS_LATEST("numad-auto-memory-vcpu-cpuset");
2352     DO_TEST_CAPS_LATEST("numad-auto-memory-vcpu-no-cpuset-and-placement");
2353     DO_TEST_CAPS_LATEST("numad-static-memory-auto-vcpu");
2354     DO_TEST_CAPS_LATEST("blkdeviotune");
2355     DO_TEST_CAPS_LATEST("blkdeviotune-max");
2356     DO_TEST_CAPS_LATEST("blkdeviotune-group-num");
2357     DO_TEST_CAPS_LATEST("blkdeviotune-max-length");
2358
2359     DO_TEST_CAPS_LATEST("multifunction-pci-device");
2360
2361     DO_TEST_CAPS_LATEST("seclabel-dynamic");
2362     DO_TEST_CAPS_LATEST("seclabel-dynamic-baselabel");
2363     DO_TEST_CAPS_LATEST("seclabel-dynamic-override");
2364     DO_TEST_CAPS_LATEST("seclabel-dynamic-labelskip");
2365     DO_TEST_CAPS_LATEST("seclabel-dynamic-relabel");
2366     DO_TEST_CAPS_LATEST("seclabel-static");
2367     DO_TEST_CAPS_LATEST("seclabel-static-relabel");
2368     DO_TEST_CAPS_LATEST("seclabel-static-labelskip");
2369     DO_TEST_CAPS_LATEST("seclabel-none");
2370     DO_TEST_CAPS_LATEST("seclabel-dac-none");
2371     DO_TEST_CAPS_LATEST_PARSE_ERROR("seclabel-multiple");
2372     DO_TEST_CAPS_LATEST_PARSE_ERROR("seclabel-device-duplicates");
2373     DO_TEST_CAPS_LATEST_PARSE_ERROR("seclabel-device-relabel-invalid");
2374
2375     DO_TEST_CAPS_LATEST_PPC64("pseries-basic");
2376     DO_TEST_CAPS_LATEST_PPC64("pseries-vio");
2377     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-vio-address-clash", "ppc64");
2378     DO_TEST_CAPS_LATEST_PPC64("pseries-usb-default");
2379     DO_TEST_CAPS_LATEST_PPC64("pseries-usb-multi");
2380     DO_TEST_CAPS_LATEST_PPC64("pseries-vio-user-assigned");
2381     DO_TEST_CAPS_LATEST_PPC64("pseries-nvram");
2382     DO_TEST_CAPS_LATEST_PPC64("pseries-usb-kbd");
2383     DO_TEST_CAPS_LATEST_PPC64("pseries-cpu-exact");
2384     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-no-parallel", "ppc64");
2385     DO_TEST_CAPS_LATEST_PPC64("pseries-cpu-le");
2386
2387     qemuTestSetHostArch(&driver, VIR_ARCH_PPC64);
2388     DO_TEST_CAPS_LATEST_PPC64_HOSTCPU("pseries-cpu-compat",
2389                                       QEMU_CPU_DEF_POWER9);
2390     DO_TEST_CAPS_LATEST_PPC64_HOSTCPU_FAILURE("pseries-cpu-compat-power9",
2391                                               QEMU_CPU_DEF_POWER8);
2392     DO_TEST_CAPS_LATEST_PPC64_HOSTCPU("pseries-cpu-compat-power9",
2393                                       QEMU_CPU_DEF_POWER9);
2394     DO_TEST_CAPS_LATEST_PPC64_HOSTCPU_FAILURE("pseries-cpu-compat-power10",
2395                                               QEMU_CPU_DEF_POWER9);
2396     DO_TEST_CAPS_LATEST_PPC64_HOSTCPU("pseries-cpu-compat-power10",
2397                                       QEMU_CPU_DEF_POWER10);
2398
2399     qemuTestSetHostArch(&driver, VIR_ARCH_NONE);
2400
2401     DO_TEST_CAPS_LATEST_PPC64("pseries-panic-missing");
2402     DO_TEST_CAPS_LATEST_PPC64("pseries-panic-no-address");
2403     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-panic-address", "ppc64");
2404
2405     DO_TEST_CAPS_LATEST_PPC64("pseries-phb-simple");
2406     DO_TEST_CAPS_LATEST_PPC64("pseries-phb-default-missing");
2407     DO_TEST_CAPS_LATEST_PPC64("pseries-phb-numa-node");
2408     DO_TEST_CAPS_LATEST_PPC64("pseries-phb-user-alias");
2409     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-default-phb-numa-node",
2410                                          "ppc64");
2411     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-phb-invalid-target-index-1", "ppc64");
2412     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-phb-invalid-target-index-2", "ppc64");
2413     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-phb-invalid-target-index-3", "ppc64");
2414
2415     DO_TEST_CAPS_LATEST_PPC64("pseries-many-devices");
2416     DO_TEST_CAPS_LATEST_PPC64("pseries-many-buses-1");
2417     DO_TEST_CAPS_LATEST_PPC64("pseries-many-buses-2");
2418     DO_TEST_CAPS_LATEST_PPC64("pseries-hostdevs-1");
2419     DO_TEST_CAPS_LATEST_PPC64("pseries-hostdevs-2");
2420     DO_TEST_CAPS_LATEST_PPC64("pseries-hostdevs-3");
2421
2422     DO_TEST_CAPS_LATEST_PPC64("pseries-features");
2423
2424     DO_TEST_CAPS_LATEST_PARSE_ERROR("pseries-features-invalid-machine");
2425
2426     DO_TEST_CAPS_LATEST_PPC64("pseries-serial-native");
2427     DO_TEST_CAPS_LATEST_PPC64("pseries-serial+console-native");
2428     DO_TEST_CAPS_LATEST_PPC64("pseries-serial-compat");
2429     DO_TEST_CAPS_LATEST_PPC64("pseries-serial-pci");
2430     DO_TEST_CAPS_LATEST_PPC64("pseries-serial-usb");
2431     DO_TEST_CAPS_LATEST_PPC64("pseries-console-native");
2432     DO_TEST_CAPS_LATEST_PPC64("pseries-console-virtio");
2433     DO_TEST_CAPS_LATEST_PARSE_ERROR("pseries-serial-invalid-machine");
2434     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-spaprvio-invalid", "ppc64");
2435
2436     DO_TEST_CAPS_ARCH_LATEST("mach-virt-serial-native", "aarch64");
2437     DO_TEST_CAPS_ARCH_LATEST("mach-virt-serial+console-native", "aarch64");
2438     DO_TEST_CAPS_ARCH_LATEST("mach-virt-serial-compat", "aarch64");
2439     DO_TEST_CAPS_ARCH_LATEST("mach-virt-serial-pci", "aarch64");
2440     DO_TEST_CAPS_ARCH_LATEST("mach-virt-serial-usb", "aarch64");
2441     DO_TEST_CAPS_ARCH_LATEST("mach-virt-console-native", "aarch64");
2442     DO_TEST_CAPS_ARCH_LATEST("mach-virt-console-virtio", "aarch64");
2443     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("mach-virt-serial-invalid-machine", "x86_64");
2444
2445     DO_TEST_CAPS_LATEST("video-device-pciaddr-default");
2446     DO_TEST_CAPS_LATEST("video-vga-device");
2447     DO_TEST_CAPS_LATEST("video-vga-device-vgamem");
2448     DO_TEST_CAPS_LATEST("video-qxl-device");
2449     DO_TEST_CAPS_LATEST("video-qxl-device-vgamem");
2450     DO_TEST_CAPS_LATEST("video-qxl-device-vram64");
2451     DO_TEST_CAPS_LATEST("video-qxl-sec-device");
2452     DO_TEST_CAPS_LATEST("video-qxl-sec-device-vgamem");
2453     DO_TEST_CAPS_LATEST("video-qxl-sec-device-vram64");
2454     DO_TEST_CAPS_LATEST("video-qxl-heads");
2455     DO_TEST_CAPS_LATEST("video-vga-qxl-heads");
2456     DO_TEST_CAPS_LATEST("video-qxl-noheads");
2457     DO_TEST_CAPS_LATEST("video-qxl-resolution");
2458     DO_TEST_CAPS_LATEST("video-virtio-gpu-device");
2459     DO_TEST_CAPS_LATEST("video-virtio-gpu-virgl");
2460     DO_TEST_CAPS_LATEST("video-virtio-gpu-spice-gl");
2461     DO_TEST_CAPS_LATEST("video-virtio-gpu-sdl-gl");
2462     DO_TEST_CAPS_LATEST("video-virtio-gpu-secondary");
2463     DO_TEST_CAPS_LATEST("video-virtio-vga");
2464     DO_TEST_CAPS_LATEST("video-virtio-blob-on");
2465     DO_TEST_CAPS_LATEST("video-virtio-blob-off");
2466     DO_TEST_CAPS_LATEST("video-virtio-vga-gpu-gl");
2467     DO_TEST_CAPS_LATEST("video-bochs-display-device");
2468     DO_TEST_CAPS_LATEST("video-ramfb-display-device");
2469     DO_TEST_CAPS_LATEST_PARSE_ERROR("video-ramfb-display-device-pci-address");
2470     DO_TEST_CAPS_LATEST("video-none-device");
2471     DO_TEST_CAPS_LATEST_PARSE_ERROR("video-invalid-multiple-devices");
2472     DO_TEST_CAPS_LATEST("default-video-type-x86_64");
2473
2474     DO_TEST_CAPS_ARCH_LATEST("default-video-type-aarch64", "aarch64");
2475     DO_TEST_CAPS_ARCH_LATEST("default-video-type-loongarch64", "loongarch64");
2476     DO_TEST_CAPS_ARCH_LATEST("default-video-type-ppc64", "ppc64");
2477     DO_TEST_CAPS_ARCH_LATEST("default-video-type-riscv64", "riscv64");
2478     DO_TEST_CAPS_ARCH_LATEST("default-video-type-s390x", "s390x");
2479
2480     DO_TEST_CAPS_LATEST_PARSE_ERROR("video-multiple-primaries");
2481
2482     DO_TEST_CAPS_LATEST("virtio-rng-default");
2483     DO_TEST_CAPS_LATEST("virtio-rng-random");
2484     DO_TEST_CAPS_LATEST("virtio-rng-egd");
2485     DO_TEST_CAPS_VER("virtio-rng-builtin", "5.2.0");
2486     DO_TEST_CAPS_LATEST("virtio-rng-builtin");
2487     DO_TEST_CAPS_VER("virtio-rng-egd-unix", "5.2.0");
2488     DO_TEST_CAPS_LATEST("virtio-rng-egd-unix");
2489     DO_TEST_CAPS_LATEST("virtio-rng-multiple");
2490     DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-rng-egd-crash");
2491     DO_TEST_CAPS_ARCH_LATEST("virtio-rng-ccw", "s390x");
2492
2493     DO_TEST_CAPS_ARCH_LATEST("s390-usb-none", "s390x");
2494     DO_TEST_CAPS_ARCH_LATEST("s390-usb-address", "s390x");
2495     DO_TEST_CAPS_ARCH_LATEST("s390-usb-model", "s390x");
2496
2497     DO_TEST_CAPS_ARCH_LATEST("s390-panic-no-address", "s390x");
2498     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("s390-panic-address", "s390x");
2499     DO_TEST_CAPS_ARCH_LATEST("s390-panic-missing", "s390x");
2500     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("s390-no-parallel", "s390x");
2501     DO_TEST_CAPS_ARCH_LATEST("s390-serial", "s390x");
2502     DO_TEST_CAPS_ARCH_LATEST("s390-serial-2", "s390x");
2503     DO_TEST_CAPS_ARCH_LATEST("s390-serial-console", "s390x");
2504
2505     DO_TEST_CAPS_ARCH_LATEST("ppc-dtb", "ppc");
2506     DO_TEST_CAPS_ARCH_LATEST("ppce500-serial", "ppc");
2507
2508     DO_TEST_CAPS_LATEST("tpm-passthrough");
2509     DO_TEST_CAPS_LATEST("tpm-passthrough-crb");
2510     DO_TEST_CAPS_LATEST_PARSE_ERROR("tpm-no-backend-invalid");
2511     DO_TEST_CAPS_LATEST("tpm-emulator");
2512     DO_TEST_CAPS_LATEST("tpm-emulator-tpm2");
2513     DO_TEST_CAPS_LATEST("tpm-emulator-tpm2-enc");
2514     DO_TEST_CAPS_LATEST("tpm-emulator-tpm2-pstate");
2515     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("aarch64-tpm-wrong-model", "aarch64");
2516     DO_TEST_CAPS_LATEST("tpm-external");
2517     DO_TEST_CAPS_LATEST("tpm-emulator-crb-profile");
2518
2519     g_setenv(TEST_TPM_ENV_VAR, TPM_VER_2_0, true);
2520     DO_TEST_CAPS_LATEST_PARSE_ERROR("tpm-emulator");
2521     g_setenv(TEST_TPM_ENV_VAR, TPM_VER_1_2, true);
2522     DO_TEST_CAPS_LATEST_PARSE_ERROR("tpm-emulator-tpm2");
2523     unsetenv(TEST_TPM_ENV_VAR);
2524
2525     DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-domain-invalid");
2526     DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-bus-invalid");
2527     DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-slot-invalid");
2528     DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-function-invalid");
2529
2530     DO_TEST_CAPS_LATEST("pci-bridge");
2531     DO_TEST_CAPS_LATEST("pci-autoadd-addr");
2532     DO_TEST_CAPS_LATEST("pci-autoadd-idx");
2533     DO_TEST_CAPS_LATEST("pci-autofill-addr");
2534     DO_TEST_CAPS_LATEST("pci-many");
2535     DO_TEST_CAPS_LATEST("pci-bridge-many-disks");
2536     DO_TEST_CAPS_LATEST("pcie-root");
2537     DO_TEST_CAPS_LATEST("q35");
2538     DO_TEST_CAPS_LATEST_PARSE_ERROR("q35-dmi-bad-address1");
2539     DO_TEST_CAPS_LATEST_PARSE_ERROR("q35-dmi-bad-address2");
2540     DO_TEST_CAPS_LATEST("pc-i440fx-acpi-root-hotplug-disable");
2541     DO_TEST_CAPS_LATEST("pc-i440fx-acpi-root-hotplug-enable");
2542     DO_TEST_CAPS_LATEST("q35-usb2");
2543     DO_TEST_CAPS_LATEST("q35-usb2-multi");
2544     DO_TEST_CAPS_LATEST("q35-usb2-reorder");
2545
2546     DO_TEST_CAPS_LATEST("q35-pcie");
2547     /* same as q35-pcie, but all PCI controllers are added automatically */
2548     DO_TEST_CAPS_LATEST("q35-pcie-autoadd");
2549     DO_TEST_CAPS_LATEST("q35-default-devices-only");
2550     DO_TEST_CAPS_LATEST("q35-multifunction");
2551     DO_TEST_CAPS_LATEST("q35-virt-manager-basic");
2552
2553     /* Test automatic and manual setting of pcie-root-port attributes */
2554     DO_TEST_CAPS_LATEST("pcie-root-port");
2555
2556     /* Make sure the default model for PCIe Root Ports is picked correctly
2557      * based on QEMU binary capabilities. We use x86/q35 for the test, but
2558      * any PCIe machine type (such as aarch64/virt) will behave the same */
2559     DO_TEST_CAPS_LATEST("pcie-root-port-model-generic");
2560     DO_TEST_CAPS_LATEST("pcie-root-port-model-ioh3420");
2561     DO_TEST_CAPS_LATEST("pcie-root-port-nohotplug");
2562
2563     DO_TEST_CAPS_LATEST("autoindex");
2564     /* Make sure the user can always override libvirt's default device
2565      * placement policy by providing an explicit PCI address */
2566     DO_TEST_CAPS_LATEST("q35-pci-force-address");
2567
2568     DO_TEST_CAPS_LATEST_PARSE_ERROR("q35-wrong-root");
2569     DO_TEST_CAPS_LATEST_PARSE_ERROR("440fx-wrong-root");
2570     DO_TEST_CAPS_LATEST_PARSE_ERROR("440fx-ide-address-conflict");
2571
2572     DO_TEST_CAPS_LATEST_PARSE_ERROR("pcie-root-port-too-many");
2573
2574     DO_TEST_CAPS_LATEST("pcie-switch-upstream-port");
2575     DO_TEST_CAPS_LATEST("pcie-switch-downstream-port");
2576
2577     DO_TEST_CAPS_LATEST("pci-expander-bus");
2578     DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-expander-bus-bad-node");
2579     DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-expander-bus-bad-machine");
2580     DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-expander-bus-bad-bus");
2581
2582     DO_TEST_CAPS_LATEST("pcie-expander-bus");
2583     DO_TEST_CAPS_LATEST_PARSE_ERROR("pcie-expander-bus-bad-machine");
2584     DO_TEST_CAPS_LATEST_PARSE_ERROR("pcie-expander-bus-bad-bus");
2585     DO_TEST_CAPS_ARCH_LATEST("pcie-expander-bus-aarch64", "aarch64");
2586
2587     DO_TEST_CAPS_LATEST("hostdev-scsi-lsi");
2588     DO_TEST_CAPS_LATEST("hostdev-scsi-virtio-scsi");
2589
2590     DO_TEST_CAPS_ARCH_LATEST("hostdev-scsi-vhost-scsi-ccw", "s390x");
2591     DO_TEST_CAPS_LATEST("hostdev-scsi-vhost-scsi-pci");
2592     DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-scsi-vhost-scsi-pci-boot-fail");
2593     DO_TEST_CAPS_LATEST("hostdev-scsi-vhost-scsi-pcie");
2594     DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-scsi-duplicate");
2595
2596     DO_TEST_CAPS_LATEST("mlock-on");
2597     DO_TEST_CAPS_LATEST("mlock-off");
2598
2599     DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-bridge-negative-index-invalid");
2600     DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-bridge-duplicate-index");
2601     DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-root-nonzero-index");
2602     DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-root-address");
2603
2604     DO_TEST_CAPS_LATEST("hotplug-base");
2605
2606     DO_TEST_CAPS_LATEST("pcihole64");
2607     DO_TEST_CAPS_LATEST("pcihole64-q35");
2608
2609     DO_TEST_CAPS_ARCH_LATEST("arm-vexpressa9-nodevs", "aarch64");
2610     DO_TEST_CAPS_ARCH_LATEST("arm-vexpressa9-basic", "aarch64");
2611     DO_TEST_CAPS_ARCH_LATEST("arm-vexpressa9-virtio", "aarch64");
2612
2613     DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-virtio", "aarch64");
2614
2615     /* Example of using virtio-pci with no explicit PCI controller
2616        but with manual PCI addresses */
2617     DO_TEST_CAPS_ARCH_LATEST("aarch64-virtio-pci-manual-addresses", "aarch64");
2618     DO_TEST_CAPS_ARCH_LATEST("aarch64-video-virtio-gpu-pci", "aarch64");
2619     DO_TEST_CAPS_ARCH_LATEST("aarch64-video-default", "aarch64");
2620     DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-default-nic", "aarch64");
2621     DO_TEST_CAPS_ARCH_LATEST("aarch64-cpu-passthrough", "aarch64");
2622     DO_TEST_GIC("aarch64-gic-none", "latest", GIC_NONE);
2623     DO_TEST_GIC("aarch64-gic-none-v2", "latest", GIC_V2);
2624     DO_TEST_GIC("aarch64-gic-none-v3", "latest", GIC_V3);
2625     DO_TEST_GIC("aarch64-gic-none-both", "latest", GIC_BOTH);
2626     DO_TEST_CAPS_ARCH_VER_FULL("aarch64-gic-none-tcg", "aarch64", "latest",
2627                                ARG_GIC, GIC_BOTH,
2628                                ARG_QEMU_CAPS_DEL, QEMU_CAPS_KVM, QEMU_CAPS_LAST,
2629                                ARG_END);
2630     DO_TEST_GIC("aarch64-gic-default", "latest", GIC_NONE);
2631     DO_TEST_GIC("aarch64-gic-default-v2", "latest", GIC_V2);
2632     DO_TEST_GIC("aarch64-gic-default-v3", "latest", GIC_V3);
2633     DO_TEST_GIC("aarch64-gic-default-both", "latest", GIC_BOTH);
2634     DO_TEST_GIC("aarch64-gic-v2", "latest", GIC_NONE);
2635     DO_TEST_GIC("aarch64-gic-v2", "latest", GIC_V2);
2636     DO_TEST_GIC("aarch64-gic-v2", "latest", GIC_V3);
2637     DO_TEST_GIC("aarch64-gic-v2", "latest", GIC_BOTH);
2638     DO_TEST_GIC("aarch64-gic-v3", "latest", GIC_NONE);
2639     DO_TEST_GIC("aarch64-gic-v3", "latest", GIC_V2);
2640     DO_TEST_GIC("aarch64-gic-v3", "latest", GIC_V3);
2641     DO_TEST_GIC("aarch64-gic-v3", "latest", GIC_BOTH);
2642     DO_TEST_GIC("aarch64-gic-host", "latest", GIC_NONE);
2643     DO_TEST_GIC("aarch64-gic-host", "latest", GIC_V2);
2644     DO_TEST_GIC("aarch64-gic-host", "latest", GIC_V3);
2645     DO_TEST_GIC("aarch64-gic-host", "latest", GIC_BOTH);
2646     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("aarch64-gic-invalid", "aarch64");
2647     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("aarch64-gic-not-virt", "aarch64");
2648     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("aarch64-gic-not-arm", "ppc64");
2649     DO_TEST_CAPS_ARCH_LATEST("aarch64-kvm-32-on-64", "aarch64");
2650     DO_TEST_CAPS_ARCH_LATEST("aarch64-pci-serial", "aarch64");
2651     DO_TEST_CAPS_ARCH_LATEST("aarch64-traditional-pci", "aarch64");
2652
2653     /* aarch64 doesn't support the same CPU features as x86 */
2654     DO_TEST_CAPS_ARCH_LATEST_FAILURE("aarch64-features-wrong", "aarch64");
2655     /* Can't enable vector lengths when SVE is overall disabled */
2656     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("aarch64-features-sve-disabled", "aarch64");
2657     /* SVE aarch64 CPU features work on modern QEMU */
2658     DO_TEST_CAPS_ARCH_LATEST("aarch64-features-sve", "aarch64");
2659
2660     DO_TEST_CAPS_ARCH_LATEST("aarch64-features-ras", "aarch64");
2661     DO_TEST_CAPS_ARCH_LATEST("aarch64-features-pauth", "aarch64");
2662
2663     DO_TEST_CAPS_ARCH_LATEST("clock-timer-armvtimer", "aarch64");
2664
2665     qemuTestSetHostArch(&driver, VIR_ARCH_NONE);
2666
2667     DO_TEST_CAPS_LATEST("kvm-pit-delay");
2668     DO_TEST_CAPS_LATEST("kvm-pit-discard");
2669
2670     DO_TEST_CAPS_LATEST("panic");
2671     DO_TEST_CAPS_LATEST("panic-double");
2672     DO_TEST_CAPS_LATEST("panic-no-address");
2673     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("riscv64-panic-no-model", "riscv64");
2674
2675     DO_TEST_CAPS_LATEST("pvpanic-pci-x86_64");
2676     DO_TEST_CAPS_ARCH_LATEST("pvpanic-pci-aarch64", "aarch64");
2677     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pvpanic-pci-invalid-address-aarch64", "aarch64");
2678     DO_TEST_CAPS_ARCH_LATEST("pvpanic-pci-no-address-aarch64", "aarch64");
2679
2680     DO_TEST_CAPS_LATEST("fips-enabled");
2681
2682     DO_TEST_CAPS_LATEST("shmem-plain-doorbell");
2683     DO_TEST_CAPS_LATEST_PARSE_ERROR("shmem-invalid-size");
2684     DO_TEST_CAPS_LATEST_FAILURE("shmem-invalid-address");
2685     DO_TEST_CAPS_LATEST_PARSE_ERROR("shmem-small-size");
2686     DO_TEST_CAPS_LATEST_PARSE_ERROR("shmem-msi-only");
2687     DO_TEST_CAPS_LATEST("cpu-host-passthrough-features");
2688
2689     DO_TEST_CAPS_LATEST_FAILURE("memory-align-fail");
2690     DO_TEST_CAPS_LATEST_PARSE_ERROR("memory-hotplug-nonuma");
2691     DO_TEST_CAPS_LATEST_PARSE_ERROR("memory-hotplug-invalid-targetnode");
2692     DO_TEST_CAPS_LATEST("memory-hotplug");
2693     DO_TEST_CAPS_LATEST("memory-hotplug-dimm");
2694     DO_TEST_CAPS_LATEST("memory-hotplug-dimm-addr");
2695     DO_TEST_CAPS_ARCH_LATEST("memory-hotplug-ppc64-nonuma", "ppc64");
2696     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("memory-hotplug-ppc64-nonuma", "ppc64");
2697     DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm");
2698     DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-access");
2699     DO_TEST_CAPS_VER("memory-hotplug-nvdimm-label", "5.2.0");
2700     DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-label");
2701     DO_TEST_CAPS_VER("memory-hotplug-nvdimm-align", "5.2.0");
2702     DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-align");
2703     DO_TEST_CAPS_VER("memory-hotplug-nvdimm-pmem", "5.2.0");
2704     DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-pmem");
2705     DO_TEST_CAPS_VER("memory-hotplug-nvdimm-readonly", "5.2.0");
2706     DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-readonly");
2707     DO_TEST_CAPS_ARCH_LATEST("memory-hotplug-nvdimm-ppc64", "ppc64");
2708     DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("memory-hotplug-nvdimm-ppc64", "ppc64");
2709     DO_TEST_CAPS_VER("memory-hotplug-virtio-pmem", "5.2.0");
2710     DO_TEST_CAPS_LATEST("memory-hotplug-virtio-pmem");
2711     DO_TEST_CAPS_LATEST("memory-hotplug-virtio-mem");
2712     DO_TEST_CAPS_LATEST("memory-hotplug-multiple");
2713     DO_TEST_CAPS_LATEST_PARSE_ERROR("memory-hotplug-virtio-mem-overlap-address");
2714     /* Test whether overlap calculation done in
2715      * virDomainMemoryDefCheckConflict() works for NVDIMMs which are special
2716      * than other memory devices because of how they handle <labelsize/> */
2717     DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-overlap");
2718     DO_TEST_CAPS_ARCH_LATEST("memory-hotplug-virtio-mem-pci-s390x", "s390x");
2719     DO_TEST_CAPS_ARCH_LATEST("memory-hotplug-virtio-mem-ccw-s390x", "s390x");
2720
2721     DO_TEST_CAPS_ARCH_LATEST("machine-aeskeywrap-on-caps", "s390x");
2722     DO_TEST_CAPS_ARCH_LATEST("machine-aeskeywrap-on-cap", "s390x");
2723     DO_TEST_CAPS_ARCH_LATEST("machine-aeskeywrap-off-caps", "s390x");
2724     DO_TEST_CAPS_ARCH_LATEST("machine-aeskeywrap-off-cap", "s390x");
2725     DO_TEST_CAPS_ARCH_LATEST("machine-deakeywrap-on-caps", "s390x");
2726     DO_TEST_CAPS_ARCH_LATEST("machine-deakeywrap-on-cap", "s390x");
2727     DO_TEST_CAPS_ARCH_LATEST("machine-deakeywrap-off-caps", "s390x");
2728     DO_TEST_CAPS_ARCH_LATEST("machine-deakeywrap-off-cap", "s390x");
2729     DO_TEST_CAPS_ARCH_LATEST("machine-keywrap-none-caps", "s390x");
2730     DO_TEST_CAPS_ARCH_LATEST("machine-keywrap-none", "s390x");
2731
2732     DO_TEST_CAPS_ARCH_LATEST("machine-loadparm-s390", "s390x");
2733     DO_TEST_CAPS_ARCH_VER("machine-loadparm-s390", "s390x", "9.1.0");
2734     DO_TEST_CAPS_ARCH_LATEST("machine-loadparm-net-s390", "s390x");
2735     DO_TEST_CAPS_ARCH_VER("machine-loadparm-net-s390", "s390x", "9.1.0");
2736     DO_TEST_CAPS_ARCH_LATEST("machine-loadparm-hostdev", "s390x");
2737     DO_TEST_CAPS_ARCH_VER("machine-loadparm-hostdev", "s390x", "9.1.0");
2738     DO_TEST_CAPS_ARCH_LATEST("machine-loadparm-multiple-disks-nets-s390", "s390x");
2739     DO_TEST_CAPS_ARCH_VER("machine-loadparm-multiple-disks-nets-s390", "s390x", "9.1.0");
2740     DO_TEST_CAPS_LATEST_PARSE_ERROR("machine-loadparm-s390-char-invalid");
2741     DO_TEST_CAPS_LATEST_PARSE_ERROR("machine-loadparm-s390-len-invalid");
2742
2743     DO_TEST_CAPS_LATEST("qemu-ns-domain-ns0");
2744     DO_TEST_CAPS_LATEST("qemu-ns-domain-commandline");
2745     DO_TEST_CAPS_LATEST("qemu-ns-domain-commandline-ns0");
2746     DO_TEST_CAPS_LATEST("qemu-ns-commandline");
2747     DO_TEST_CAPS_LATEST("qemu-ns-commandline-ns0");
2748     DO_TEST_CAPS_LATEST("qemu-ns-commandline-ns1");
2749
2750     DO_TEST_CAPS_LATEST("virtio-input");
2751     DO_TEST_CAPS_LATEST("virtio-input-passthrough");
2752
2753     DO_TEST_CAPS_LATEST("input-linux");
2754
2755     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("ppc64-tpmproxy-double", "ppc64");
2756     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("ppc64-tpm-double", "ppc64");
2757
2758     DO_TEST_CAPS_LATEST_PPC64("ppc64-tpmproxy-single");
2759     DO_TEST_CAPS_LATEST_PPC64("ppc64-tpmproxy-with-tpm");
2760
2761     DO_TEST_CAPS_ARCH_LATEST("aarch64-usb-controller", "aarch64");
2762
2763     DO_TEST_CAPS_ARCH_LATEST("sparc-minimal", "sparc");
2764
2765     DO_TEST_CAPS_LATEST_PARSE_ERROR("missing-machine");
2766
2767     DO_TEST_CAPS_LATEST("name-escape");
2768
2769     DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-too-long-port-path-invalid");
2770
2771     DO_TEST_CAPS_LATEST("acpi-table");
2772
2773     DO_TEST_CAPS_LATEST("intel-iommu");
2774     DO_TEST_CAPS_LATEST("intel-iommu-caching-mode");
2775     DO_TEST_CAPS_LATEST("intel-iommu-eim");
2776     DO_TEST_CAPS_LATEST("intel-iommu-device-iotlb");
2777     DO_TEST_CAPS_LATEST("intel-iommu-aw-bits");
2778     DO_TEST_CAPS_LATEST("intel-iommu-dma-translation");
2779     DO_TEST_CAPS_LATEST_PARSE_ERROR("intel-iommu-wrong-machine");
2780     DO_TEST_CAPS_LATEST_ABI_UPDATE("intel-iommu-eim-autoadd");
2781     DO_TEST_CAPS_LATEST_ABI_UPDATE("intel-iommu-eim-autoadd-v2");
2782     DO_TEST_CAPS_ARCH_LATEST("iommu-smmuv3", "aarch64");
2783     DO_TEST_CAPS_LATEST("virtio-iommu-x86_64");
2784     DO_TEST_CAPS_VER_PARSE_ERROR("virtio-iommu-x86_64", "6.1.0");
2785     DO_TEST_CAPS_ARCH_LATEST("virtio-iommu-aarch64", "aarch64");
2786     DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-iommu-wrong-machine");
2787     DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-iommu-no-acpi");
2788     DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-iommu-invalid-address-type");
2789     DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-iommu-invalid-address");
2790     DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-iommu-dma-translation");
2791
2792     DO_TEST_CAPS_LATEST("cpu-hotplug-startup");
2793     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("cpu-hotplug-granularity", "ppc64");
2794
2795     DO_TEST_CAPS_LATEST("virtio-options");
2796     DO_TEST_CAPS_LATEST("virtio-options-controller-iommu");
2797     DO_TEST_CAPS_LATEST("virtio-options-disk-iommu");
2798     DO_TEST_CAPS_LATEST("virtio-options-fs-iommu");
2799     DO_TEST_CAPS_LATEST("virtio-options-input-iommu");
2800     DO_TEST_CAPS_LATEST("virtio-options-memballoon-iommu");
2801     DO_TEST_CAPS_LATEST("virtio-options-net-iommu");
2802     DO_TEST_CAPS_LATEST("virtio-options-rng-iommu");
2803     DO_TEST_CAPS_LATEST("virtio-options-video-iommu");
2804     DO_TEST_CAPS_LATEST("virtio-options-controller-ats");
2805     DO_TEST_CAPS_LATEST("virtio-options-disk-ats");
2806     DO_TEST_CAPS_LATEST("virtio-options-fs-ats");
2807     DO_TEST_CAPS_LATEST("virtio-options-input-ats");
2808     DO_TEST_CAPS_LATEST("virtio-options-memballoon-ats");
2809     DO_TEST_CAPS_LATEST("virtio-options-net-ats");
2810     DO_TEST_CAPS_LATEST("virtio-options-rng-ats");
2811     DO_TEST_CAPS_LATEST("virtio-options-video-ats");
2812     DO_TEST_CAPS_LATEST("virtio-options-controller-packed");
2813     DO_TEST_CAPS_LATEST("virtio-options-disk-packed");
2814     DO_TEST_CAPS_LATEST("virtio-options-fs-packed");
2815     DO_TEST_CAPS_LATEST("virtio-options-input-packed");
2816     DO_TEST_CAPS_LATEST("virtio-options-memballoon-packed");
2817     DO_TEST_CAPS_LATEST("virtio-options-memballoon-freepage-reporting");
2818     DO_TEST_CAPS_LATEST("virtio-options-net-packed");
2819     DO_TEST_CAPS_LATEST("virtio-options-rng-packed");
2820     DO_TEST_CAPS_LATEST("virtio-options-video-packed");
2821
2822     DO_TEST_CAPS_LATEST("fd-memory-numa-topology");
2823     DO_TEST_CAPS_LATEST("fd-memory-numa-topology2");
2824     DO_TEST_CAPS_LATEST("fd-memory-numa-topology3");
2825     DO_TEST_CAPS_LATEST("fd-memory-numa-topology4");
2826
2827     DO_TEST_CAPS_LATEST("fd-memory-no-numa-topology");
2828
2829     DO_TEST_CAPS_LATEST("memfd-memory-numa");
2830     DO_TEST_CAPS_LATEST("memfd-memory-default-hugepage");
2831
2832     DO_TEST_CAPS_LATEST("cpu-check-none");
2833     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-check-partial", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2834     DO_TEST_CAPS_LATEST("cpu-check-full");
2835     DO_TEST_CAPS_LATEST("cpu-check-default-none");
2836     DO_TEST_CAPS_LATEST("cpu-check-default-none2");
2837     /* this test case uses 'cpu="host-model"', run it with Haswell host cpu to prevent test case churn */
2838     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-check-default-partial", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2839     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-check-default-partial2", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2840
2841     DO_TEST_CAPS_LATEST("cpu-cache-disable");
2842     /* this test case uses 'cpu="host-model"', run it with Haswell host cpu to prevent test case churn */
2843     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-cache-disable3", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2844     DO_TEST_CAPS_LATEST("cpu-cache-passthrough");
2845     DO_TEST_CAPS_LATEST("cpu-cache-emulate-l3");
2846     DO_TEST_CAPS_LATEST_PARSE_ERROR("cpu-cache-emulate-l2");
2847     DO_TEST_CAPS_LATEST_PARSE_ERROR("cpu-cache-passthrough3");
2848     DO_TEST_CAPS_LATEST_PARSE_ERROR("cpu-cache-passthrough-l3");
2849     DO_TEST_CAPS_LATEST("vmcoreinfo");
2850
2851     DO_TEST_CAPS_LATEST("user-aliases");
2852     DO_TEST_CAPS_LATEST("user-aliases2");
2853     DO_TEST_CAPS_LATEST("user-aliases-usb");
2854
2855     DO_TEST_CAPS_LATEST("tseg-explicit-size");
2856     DO_TEST_CAPS_LATEST_PARSE_ERROR("tseg-i440fx");
2857     DO_TEST_CAPS_LATEST_PARSE_ERROR("tseg-invalid-size");
2858
2859     DO_TEST_CAPS_ARCH_LATEST("video-virtio-gpu-ccw", "s390x");
2860     DO_TEST_CAPS_ARCH_LATEST("input-virtio-ccw", "s390x");
2861
2862     DO_TEST_CAPS_LATEST("vhost-vsock");
2863     DO_TEST_CAPS_LATEST("vhost-vsock-auto");
2864     DO_TEST_CAPS_ARCH_LATEST("vhost-vsock-ccw", "s390x");
2865     DO_TEST_CAPS_ARCH_LATEST("vhost-vsock-ccw-auto", "s390x");
2866     DO_TEST_CAPS_ARCH_LATEST("vhost-vsock-ccw-iommu", "s390x");
2867
2868     DO_TEST_CAPS_VER("launch-security-sev", "6.0.0");
2869     DO_TEST_CAPS_VER("launch-security-sev-missing-platform-info", "6.0.0");
2870     DO_TEST_CAPS_ARCH_LATEST_FULL("launch-security-sev-direct",
2871                                   "x86_64",
2872                                   ARG_QEMU_CAPS,
2873                                   QEMU_CAPS_SEV_GUEST,
2874                                   QEMU_CAPS_LAST);
2875
2876     DO_TEST_CAPS_ARCH_LATEST_FULL("launch-security-sev-snp",
2877                                   "x86_64",
2878                                   ARG_QEMU_CAPS,
2879                                   QEMU_CAPS_SEV_SNP_GUEST,
2880                                   QEMU_CAPS_LAST);
2881
2882     DO_TEST_CAPS_ARCH_LATEST("launch-security-s390-pv", "s390x");
2883
2884     DO_TEST_CAPS_LATEST("vhost-user-fs-fd-memory");
2885     DO_TEST_CAPS_LATEST("vhost-user-fs-fd-openfiles");
2886     DO_TEST_CAPS_LATEST("vhost-user-fs-hugepages");
2887     DO_TEST_CAPS_LATEST("vhost-user-fs-readonly");
2888
2889     DO_TEST_CAPS_ARCH_LATEST("vhost-user-fs-ccw", "s390x");
2890     DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("vhost-user-fs-ccw-bootindex", "s390x");
2891
2892     DO_TEST_CAPS_LATEST("virtio-transitional");
2893     DO_TEST_CAPS_LATEST("virtio-non-transitional");
2894     DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-transitional-not-supported");
2895
2896     /* Simple headless guests for various architectures */
2897     DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-headless", "aarch64");
2898     DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-headless-mmio", "aarch64");
2899     DO_TEST_CAPS_ARCH_LATEST("loongarch64-virt-headless", "loongarch64");
2900     DO_TEST_CAPS_ARCH_LATEST("ppc64-pseries-headless", "ppc64");
2901     DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-headless", "riscv64");
2902     DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-headless-mmio", "riscv64");
2903     DO_TEST_CAPS_ARCH_LATEST("s390x-ccw-headless", "s390x");
2904     DO_TEST_CAPS_ARCH_LATEST("x86_64-pc-headless", "x86_64");
2905     DO_TEST_CAPS_ARCH_LATEST("x86_64-q35-headless", "x86_64");
2906
2907     /* Simple guests with graphics for various architectures */
2908     DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-graphics", "aarch64");
2909     DO_TEST_CAPS_ARCH_LATEST("loongarch64-virt-graphics", "loongarch64");
2910     DO_TEST_CAPS_ARCH_LATEST("ppc64-pseries-graphics", "ppc64");
2911     DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-graphics", "riscv64");
2912     DO_TEST_CAPS_ARCH_LATEST("s390x-ccw-graphics", "s390x");
2913     DO_TEST_CAPS_ARCH_LATEST("x86_64-pc-graphics", "x86_64");
2914     DO_TEST_CAPS_ARCH_LATEST("x86_64-q35-graphics", "x86_64");
2915
2916     DO_TEST_CAPS_LATEST("vhost-user-vga");
2917     DO_TEST_CAPS_LATEST("vhost-user-gpu-secondary");
2918
2919     DO_TEST_CAPS_LATEST("cpu-Icelake-Server-pconfig");
2920
2921     DO_TEST_CAPS_ARCH_LATEST("aarch64-default-cpu-kvm-virt-4.2", "aarch64");
2922     DO_TEST_CAPS_ARCH_LATEST("aarch64-default-cpu-tcg-virt-4.2", "aarch64");
2923     DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-kvm-pseries-2.7", "ppc64");
2924     DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-tcg-pseries-2.7", "ppc64");
2925     DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-kvm-pseries-3.1", "ppc64");
2926     DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-tcg-pseries-3.1", "ppc64");
2927     DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-kvm-pseries-4.2", "ppc64");
2928     DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-tcg-pseries-4.2", "ppc64");
2929     DO_TEST_CAPS_ARCH_LATEST("s390-default-cpu-kvm-ccw-virtio-4.2", "s390x");
2930     DO_TEST_CAPS_ARCH_LATEST("s390-default-cpu-tcg-ccw-virtio-4.2", "s390x");
2931     DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-kvm-pc-4.2", "x86_64");
2932     DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-tcg-pc-4.2", "x86_64");
2933     DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-kvm-q35-4.2", "x86_64");
2934     DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-tcg-q35-4.2", "x86_64");
2935     DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-tcg-features", "x86_64");
2936
2937     DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-features-aia", "riscv64");
2938
2939     DO_TEST_CAPS_LATEST("virtio-9p-multidevs");
2940     DO_TEST_CAPS_LATEST("virtio-9p-createmode");
2941
2942     DO_TEST_CAPS_LATEST("devices-acpi-index");
2943
2944     DO_TEST_CAPS_ARCH_LATEST_FULL("hvf-x86_64-q35-headless", "x86_64", ARG_CAPS_VARIANT, "+hvf", ARG_END);
2945     DO_TEST_CAPS_ARCH_LATEST_FULL("hvf-aarch64-virt-headless", "aarch64", ARG_CAPS_VARIANT, "+hvf", ARG_END);
2946     /* HVF guests should not work on Linux with KVM */
2947     DO_TEST_CAPS_LATEST_PARSE_ERROR("hvf-x86_64-q35-headless");
2948
2949     DO_TEST_CAPS_LATEST("cpu-phys-bits-passthrough");
2950     DO_TEST_CAPS_LATEST("cpu-phys-bits-emulate");
2951     /* this test case uses 'cpu="host"', run it with Haswell host cpu to prevent test case churn */
2952     DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-phys-bits-emulate2", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
2953     DO_TEST_CAPS_LATEST_PARSE_ERROR("cpu-phys-bits-passthrough2");
2954     DO_TEST_CAPS_LATEST("cpu-phys-bits-limit");
2955     DO_TEST_CAPS_LATEST("cpu-phys-bits-emulate-bare");
2956
2957     DO_TEST_CAPS_VER("sgx-epc", "7.0.0");
2958
2959     DO_TEST_CAPS_LATEST("crypto-builtin");
2960
2961     DO_TEST_CAPS_LATEST("async-teardown");
2962     DO_TEST_CAPS_ARCH_LATEST("s390-async-teardown", "s390x");
2963     DO_TEST_CAPS_ARCH_LATEST("s390-async-teardown-no-attrib", "s390x");
2964     DO_TEST_CAPS_ARCH_VER_PARSE_ERROR("s390-async-teardown", "s390x", "6.0.0");
2965     DO_TEST_CAPS_ARCH_LATEST("s390-async-teardown-disabled", "s390x");
2966     DO_TEST_CAPS_ARCH_VER("s390-async-teardown-disabled", "s390x", "6.0.0");
2967
2968     DO_TEST_CAPS_LATEST("boot-menu-disable-with-timeout");
2969     DO_TEST_CAPS_LATEST("channel-unix-source-path");
2970     DO_TEST_CAPS_LATEST("chardev-label");
2971     DO_TEST_CAPS_LATEST("console-compat2");
2972     DO_TEST_CAPS_LATEST("cpu-empty");
2973     DO_TEST_CAPS_LATEST("cpu-host-model-features");
2974     DO_TEST_CAPS_LATEST("cpu-numa-disordered");
2975     DO_TEST_CAPS_LATEST("disk-active-commit");
2976     DO_TEST_CAPS_LATEST("disk-mirror-old");
2977     DO_TEST_CAPS_LATEST("disk-mirror");
2978     DO_TEST_CAPS_LATEST("downscript");
2979     DO_TEST_CAPS_LATEST("hostdev-mdev-display");
2980     DO_TEST_CAPS_LATEST("hostdev-scsi-autogen-address");
2981     DO_TEST_CAPS_LATEST("hostdev-scsi-large-unit");
2982     DO_TEST_CAPS_LATEST("hostdev-scsi-shareable");
2983     DO_TEST_CAPS_LATEST("lease");
2984     DO_TEST_CAPS_LATEST("memorybacking-set");
2985     DO_TEST_CAPS_LATEST("memorybacking-unset");
2986     DO_TEST_CAPS_LATEST("metadata-duplicate");
2987     DO_TEST_CAPS_LATEST("metadata");
2988     DO_TEST_CAPS_LATEST("net-midonet");
2989     DO_TEST_CAPS_LATEST("numad-auto-vcpu-no-numatune");
2990     DO_TEST_CAPS_LATEST("numad-static-vcpu-no-numatune");
2991     DO_TEST_CAPS_LATEST("numavcpus-topology-mismatch");
2992     DO_TEST_CAPS_ARCH_LATEST("panic-pseries", "ppc64");
2993     DO_TEST_CAPS_LATEST("pcihole64-gib");
2994     DO_TEST_CAPS_ARCH_LATEST("s390-defaultconsole", "s390x");
2995     DO_TEST_CAPS_ARCH_LATEST("s390-panic", "s390x");
2996     DO_TEST_CAPS_LATEST("seclabel-device-multiple");
2997     DO_TEST_CAPS_LATEST("seclabel-dynamic-none-relabel");
2998     DO_TEST_CAPS_LATEST("seclabel-dynamic-none");
2999     DO_TEST_CAPS_LATEST("serial-target-port-auto");
3000     DO_TEST_CAPS_LATEST("vhost-user-fs-sock");
3001     DO_TEST_CAPS_ARCH_LATEST("video-virtio-gpu-ccw-auto", "s390x");
3002
3003     DO_TEST_CAPS_LATEST("graphics-listen-network");
3004     DO_TEST_CAPS_LATEST("net-bandwidth");
3005     DO_TEST_CAPS_LATEST("net-bandwidth2");
3006     DO_TEST_CAPS_LATEST("net-coalesce");
3007     DO_TEST_CAPS_LATEST("net-isolated-port");
3008     DO_TEST_CAPS_LATEST("net-mtu");
3009     DO_TEST_CAPS_LATEST("net-openvswitch");
3010     DO_TEST_CAPS_LATEST("net-virtio-network-portgroup");
3011     DO_TEST_CAPS_LATEST("net-virtio-teaming-network");
3012     DO_TEST_CAPS_LATEST("tap-vhost-incorrect");
3013     DO_TEST_CAPS_LATEST("tap-vhost");
3014
3015     DO_TEST_CAPS_LATEST("mtp-usb-device")
3016     DO_TEST_CAPS_LATEST("net-usb")
3017     DO_TEST_CAPS_LATEST("sound-device-virtio")
3018     DO_TEST_CAPS_LATEST("pstore-acpi-erst")
3019
3020     DO_TEST_CAPS_LATEST_FAILURE("disk-network-iscsi-zero-hosts-invalid")
3021     DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-scsi-vhost-rawio-invalid")
3022     DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-scsi-vhost-sgio-invalid")
3023     DO_TEST_CAPS_LATEST("disk-startuppolicy-optional-drop")
3024
3025     /* check that all input files were actually used here */
3026     if (testConfXMLCheck(existingTestCases) < 0)
3027         ret = -1;
3028
3029     qemuTestDriverFree(&driver);
3030     virFileWrapperClearPrefixes();
3031
3032     return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
3033 }
3034
3035 VIR_TEST_MAIN_PRELOAD(mymain,
3036                       VIR_TEST_MOCK("qemuxml2argv"),
3037                       VIR_TEST_MOCK("domaincaps"),
3038                       VIR_TEST_MOCK("virrandom"),
3039                       VIR_TEST_MOCK("qemucpu"),
3040                       VIR_TEST_MOCK("virpci"),
3041                       VIR_TEST_MOCK("virnuma"))
3042
3043 #else
3044
3045 int main(void)
3046 {
3047     return EXIT_AM_SKIP;
3048 }
3049
3050 #endif /* WITH_QEMU */