qemuxml2argvtest.c 131.8 KB
Newer Older
1
#include <config.h>
2 3

#include <unistd.h>
4 5 6 7

#include <sys/types.h>
#include <fcntl.h>

8 9
#include "testutils.h"

10 11
#ifdef WITH_QEMU

12
# include "internal.h"
13
# include "viralloc.h"
14
# include "qemu/qemu_alias.h"
15 16
# include "qemu/qemu_capabilities.h"
# include "qemu/qemu_command.h"
M
Matthias Bolte 已提交
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 "qemu/qemu_qapi.h"
22
# include "datatypes.h"
23
# include "conf/storage_conf.h"
24
# include "cpu/cpu_map.h"
25
# include "virstring.h"
26
# include "storage/storage_driver.h"
27
# include "virmock.h"
28 29
# include "virfilewrapper.h"
# include "configmake.h"
30 31
# include "testutilsqemuschema.h"
# include "qemu/qemu_monitor_json.h"
32

33
# define LIBVIRT_QEMU_CAPSPRIV_H_ALLOW
34 35
# include "qemu/qemu_capspriv.h"

36
# include "testutilsqemu.h"
37

38 39
# define VIR_FROM_THIS VIR_FROM_QEMU

40
static virQEMUDriver driver;
41

42
static unsigned char *
J
Ján Tomko 已提交
43
fakeSecretGetValue(virSecretPtr obj G_GNUC_UNUSED,
44
                   size_t *value_size,
J
Ján Tomko 已提交
45 46
                   unsigned int fakeflags G_GNUC_UNUSED,
                   unsigned int internalFlags G_GNUC_UNUSED)
47
{
48
    char *secret;
49
    secret = g_strdup("AQCVn5hO6HzFAhAAq0NCv8jtJcIcE+HOBlMQ1A");
50 51 52 53 54 55
    *value_size = strlen(secret);
    return (unsigned char *) secret;
}

static virSecretPtr
fakeSecretLookupByUsage(virConnectPtr conn,
56
                        int usageType,
57 58
                        const char *usageID)
{
59
    unsigned char uuid[VIR_UUID_BUFLEN];
60 61 62 63 64 65 66 67 68 69
    if (usageType == VIR_SECRET_USAGE_TYPE_VOLUME) {
        if (!STRPREFIX(usageID, "/storage/guest_disks/")) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "test provided invalid volume storage prefix '%s'",
                           usageID);
            return NULL;
        }
    } else if (STRNEQ(usageID, "mycluster_myname")) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "test provided incorrect usage '%s'", usageID);
70
        return NULL;
71
    }
72

73 74 75
    if (virUUIDGenerate(uuid) < 0)
        return NULL;

76
    return virGetSecret(conn, uuid, usageType, usageID);
77 78
}

79 80 81 82
static virSecretPtr
fakeSecretLookupByUUID(virConnectPtr conn,
                       const unsigned char *uuid)
{
83 84 85
    /* NB: This mocked value could be "tls" or "volume" depending on
     * which test is being run, we'll leave at NONE (or 0) */
    return virGetSecret(conn, uuid, VIR_SECRET_USAGE_TYPE_NONE, "");
86 87
}

88
static virSecretDriver fakeSecretDriver = {
89 90
    .connectNumOfSecrets = NULL,
    .connectListSecrets = NULL,
91
    .secretLookupByUUID = fakeSecretLookupByUUID,
92 93 94 95 96 97
    .secretLookupByUsage = fakeSecretLookupByUsage,
    .secretDefineXML = NULL,
    .secretGetXMLDesc = NULL,
    .secretSetValue = NULL,
    .secretGetValue = fakeSecretGetValue,
    .secretUndefine = NULL,
98 99
};

100 101 102 103 104 105 106 107 108 109 110 111

# define STORAGE_POOL_XML_PATH "storagepoolxml2xmlout/"
static const unsigned char fakeUUID[VIR_UUID_BUFLEN] = "fakeuuid";

static virStoragePoolPtr
fakeStoragePoolLookupByName(virConnectPtr conn,
                            const char *name)
{
    char *xmlpath = NULL;
    virStoragePoolPtr ret = NULL;

    if (STRNEQ(name, "inactive")) {
112 113
        xmlpath = g_strdup_printf("%s/%s%s.xml", abs_srcdir,
                                  STORAGE_POOL_XML_PATH, name);
114 115 116 117 118 119 120 121 122 123

        if (!virFileExists(xmlpath)) {
            virReportError(VIR_ERR_NO_STORAGE_POOL,
                           "File '%s' not found", xmlpath);
            goto cleanup;
        }
    }

    ret = virGetStoragePool(conn, name, fakeUUID, NULL, NULL);

124
 cleanup:
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
    VIR_FREE(xmlpath);
    return ret;
}


static virStorageVolPtr
fakeStorageVolLookupByName(virStoragePoolPtr pool,
                           const char *name)
{
    char **volinfo = NULL;
    virStorageVolPtr ret = NULL;

    if (STREQ(pool->name, "inactive")) {
        virReportError(VIR_ERR_OPERATION_INVALID,
                       "storage pool '%s' is not active", pool->name);
        return NULL;
    }

    if (STREQ(name, "nonexistent")) {
        virReportError(VIR_ERR_NO_STORAGE_VOL,
                       "no storage vol with matching name '%s'", name);
        return NULL;
    }

    if (!strchr(name, '+'))
        goto fallback;

    if (!(volinfo = virStringSplit(name, "+", 2)))
        return NULL;

    if (!volinfo[1])
        goto fallback;

    ret = virGetStorageVol(pool->conn, pool->name, volinfo[1], volinfo[0],
                           NULL, NULL);

161
 cleanup:
162
    virStringListFree(volinfo);
163 164
    return ret;

165
 fallback:
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
    ret = virGetStorageVol(pool->conn, pool->name, name, "block", NULL, NULL);
    goto cleanup;
}

static int
fakeStorageVolGetInfo(virStorageVolPtr vol,
                      virStorageVolInfoPtr info)
{
    memset(info, 0, sizeof(*info));

    info->type = virStorageVolTypeFromString(vol->key);

    if (info->type < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "Invalid volume type '%s'", vol->key);
        return -1;
    }

    return 0;
}


static char *
fakeStorageVolGetPath(virStorageVolPtr vol)
{
M
Michal Privoznik 已提交
191
    return g_strdup_printf("/some/%s/device/%s", vol->key, vol->name);
192 193 194 195 196
}


static char *
fakeStoragePoolGetXMLDesc(virStoragePoolPtr pool,
J
Ján Tomko 已提交
197
                          unsigned int flags_unused G_GNUC_UNUSED)
198 199 200 201 202 203 204 205 206
{
    char *xmlpath = NULL;
    char *xmlbuf = NULL;

    if (STREQ(pool->name, "inactive")) {
        virReportError(VIR_ERR_NO_STORAGE_POOL, NULL);
        return NULL;
    }

207 208
    xmlpath = g_strdup_printf("%s/%s%s.xml", abs_srcdir, STORAGE_POOL_XML_PATH,
                              pool->name);
209

210
    if (virTestLoadFile(xmlpath, &xmlbuf) < 0) {
211 212 213 214 215 216
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "failed to load XML file '%s'",
                       xmlpath);
        goto cleanup;
    }

217
 cleanup:
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
    VIR_FREE(xmlpath);

    return xmlbuf;
}

static int
fakeStoragePoolIsActive(virStoragePoolPtr pool)
{
    if (STREQ(pool->name, "inactive"))
        return 0;

    return 1;
}

/* Test storage pool implementation
 *
 * These functions aid testing of storage pool related stuff when creating a
235
 * qemu command line.
236 237 238
 *
 * There are a few "magic" values to pass to these functions:
 *
239 240
 * 1) "inactive" as a pool name to create an inactive pool. All other names are
 * interpreted as file names in storagepoolxml2xmlout/ and are used as the
241 242 243
 * definition for the pool. If the file doesn't exist the pool doesn't exist.
 *
 * 2) "nonexistent" returns an error while looking up a volume. Otherwise
244
 * pattern VOLUME_TYPE+VOLUME_PATH can be used to simulate a volume in a pool.
245 246 247 248 249 250 251 252 253 254 255 256
 * This creates a fake path for this volume. If the '+' sign is omitted, block
 * type is assumed.
 */
static virStorageDriver fakeStorageDriver = {
    .storagePoolLookupByName = fakeStoragePoolLookupByName,
    .storageVolLookupByName = fakeStorageVolLookupByName,
    .storagePoolGetXMLDesc = fakeStoragePoolGetXMLDesc,
    .storageVolGetPath = fakeStorageVolGetPath,
    .storageVolGetInfo = fakeStorageVolGetInfo,
    .storagePoolIsActive = fakeStoragePoolIsActive,
};

257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272

/* virNetDevOpenvswitchGetVhostuserIfname mocks a portdev name - handle that */
static virNWFilterBindingPtr
fakeNWFilterBindingLookupByPortDev(virConnectPtr conn,
                                   const char *portdev)
{
    if (STREQ(portdev, "vhost-user0"))
        return virGetNWFilterBinding(conn, "fake_vnet0", "fakeFilterName");

    virReportError(VIR_ERR_NO_NWFILTER_BINDING,
                   "no nwfilter binding for port dev '%s'", portdev);
    return NULL;
}


static int
J
Ján Tomko 已提交
273
fakeNWFilterBindingDelete(virNWFilterBindingPtr binding G_GNUC_UNUSED)
274 275 276 277 278 279 280 281 282 283
{
    return 0;
}


static virNWFilterDriver fakeNWFilterDriver = {
    .nwfilterBindingLookupByPortDev = fakeNWFilterBindingLookupByPortDev,
    .nwfilterBindingDelete = fakeNWFilterBindingDelete,
};

284 285 286 287

static int
testAddCPUModels(virQEMUCapsPtr caps, bool skipLegacy)
{
288 289
    virArch arch = virQEMUCapsGetArch(caps);
    const char *x86Models[] = {
290 291 292 293
        "Opteron_G3", "Opteron_G2", "Opteron_G1",
        "Nehalem", "Penryn", "Conroe",
        "Haswell-noTSX", "Haswell",
    };
294
    const char *x86LegacyModels[] = {
295 296 297 298
        "n270", "athlon", "pentium3", "pentium2", "pentium",
        "486", "coreduo", "kvm32", "qemu32", "kvm64",
        "core2duo", "phenom", "qemu64",
    };
299 300 301 302 303 304
    const char *armModels[] = {
        "cortex-a9", "cortex-a8", "cortex-a57", "cortex-a53",
    };
    const char *ppc64Models[] = {
        "POWER8", "POWER7",
    };
305 306 307
    const char *s390xModels[] = {
        "z990", "zEC12", "z13",
    };
308

309
    if (ARCH_IS_X86(arch)) {
310
        if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM, x86Models,
311
                                         G_N_ELEMENTS(x86Models),
312
                                         VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0 ||
313
            virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_QEMU, x86Models,
314
                                         G_N_ELEMENTS(x86Models),
315
                                         VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
316 317
            return -1;

318 319 320
        if (!skipLegacy) {
            if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM,
                                             x86LegacyModels,
321
                                             G_N_ELEMENTS(x86LegacyModels),
322
                                             VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0 ||
323 324
                virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_QEMU,
                                             x86LegacyModels,
325
                                             G_N_ELEMENTS(x86LegacyModels),
326
                                             VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
327 328
                return -1;
        }
329
    } else if (ARCH_IS_ARM(arch)) {
330
        if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM, armModels,
331
                                         G_N_ELEMENTS(armModels),
332
                                         VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0 ||
333
            virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_QEMU, armModels,
334
                                         G_N_ELEMENTS(armModels),
335
                                         VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
336 337
            return -1;
    } else if (ARCH_IS_PPC64(arch)) {
338
        if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM, ppc64Models,
339
                                         G_N_ELEMENTS(ppc64Models),
340
                                         VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0 ||
341
            virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_QEMU, ppc64Models,
342
                                         G_N_ELEMENTS(ppc64Models),
343
                                         VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
344
            return -1;
345 346
    } else if (ARCH_IS_S390(arch)) {
        if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM, s390xModels,
347
                                         G_N_ELEMENTS(s390xModels),
348 349
                                         VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
            return -1;
350
    }
351 352 353 354 355

    return 0;
}


356
static int
357
testUpdateQEMUCaps(const struct testQemuInfo *info,
358 359
                   virDomainObjPtr vm,
                   virCapsPtr caps)
360
{
361
    if (!caps)
362
        return -1;
363

364 365
    virQEMUCapsSetArch(info->qemuCaps, vm->def->os.arch);

366 367
    virQEMUCapsInitQMPBasicArch(info->qemuCaps);

368 369
    if (testAddCPUModels(info->qemuCaps,
                         !!(info->flags & FLAG_SKIP_LEGACY_CPUS)) < 0)
370
        return -1;
371

372 373 374 375
    virQEMUCapsInitHostCPUModel(info->qemuCaps, caps->host.arch,
                                VIR_DOMAIN_VIRT_KVM);
    virQEMUCapsInitHostCPUModel(info->qemuCaps, caps->host.arch,
                                VIR_DOMAIN_VIRT_QEMU);
376

377
    return 0;
378 379 380
}


381 382 383 384 385 386
static int
testCheckExclusiveFlags(int flags)
{
    virCheckFlags(FLAG_EXPECT_FAILURE |
                  FLAG_EXPECT_PARSE_ERROR |
                  FLAG_FIPS |
387
                  FLAG_REAL_CAPS |
388
                  FLAG_SKIP_LEGACY_CPUS |
389
                  FLAG_SLIRP_HELPER |
390 391
                  0, -1);

392
    VIR_EXCLUSIVE_FLAGS_RET(FLAG_REAL_CAPS, FLAG_SKIP_LEGACY_CPUS, -1);
393 394 395 396
    return 0;
}


397 398 399 400 401
static virCommandPtr
testCompareXMLToArgvCreateArgs(virQEMUDriverPtr drv,
                               virDomainObjPtr vm,
                               const char *migrateURI,
                               struct testQemuInfo *info,
402 403
                               unsigned int flags,
                               bool jsonPropsValidation)
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
{
    size_t i;

    for (i = 0; i < vm->def->nhostdevs; i++) {
        virDomainHostdevDefPtr hostdev = vm->def->hostdevs[i];

        if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
            hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI &&
            hostdev->source.subsys.u.pci.backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT) {
            hostdev->source.subsys.u.pci.backend = VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO;
        }
    }

    for (i = 0; i < vm->def->nfss; i++) {
        virDomainFSDefPtr fs = vm->def->fss[i];
        char *s;

        if (fs->fsdriver != VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS ||
            QEMU_DOMAIN_FS_PRIVATE(fs)->vhostuser_fs_sock)
            continue;

        s = g_strdup_printf("/tmp/lib/domain--1-guest/fs%zu.vhost-fs.sock", i);
        QEMU_DOMAIN_FS_PRIVATE(fs)->vhostuser_fs_sock = s;
    }

    if (vm->def->vsock) {
        virDomainVsockDefPtr vsock = vm->def->vsock;
        qemuDomainVsockPrivatePtr vsockPriv =
            (qemuDomainVsockPrivatePtr)vsock->privateData;

        if (vsock->auto_cid == VIR_TRISTATE_BOOL_YES)
            vsock->guest_cid = 42;

        vsockPriv->vhostfd = 6789;
    }

    if (vm->def->tpm) {
        switch (vm->def->tpm->type) {
        case VIR_DOMAIN_TPM_TYPE_EMULATOR:
            VIR_FREE(vm->def->tpm->data.emulator.source.data.file.path);
            vm->def->tpm->data.emulator.source.data.file.path = g_strdup("/dev/test");
            vm->def->tpm->data.emulator.source.type = VIR_DOMAIN_CHR_TYPE_FILE;
            break;
        case VIR_DOMAIN_TPM_TYPE_PASSTHROUGH:
        case VIR_DOMAIN_TPM_TYPE_LAST:
            break;
       }
    }

    for (i = 0; i < vm->def->nvideos; i++) {
        virDomainVideoDefPtr video = vm->def->videos[i];

        if (video->backend == VIR_DOMAIN_VIDEO_BACKEND_TYPE_VHOSTUSER) {
            qemuDomainVideoPrivatePtr vpriv = QEMU_DOMAIN_VIDEO_PRIVATE(video);

            vpriv->vhost_user_fd = 1729;
        }
    }

    if (flags & FLAG_SLIRP_HELPER) {
        for (i = 0; i < vm->def->nnets; i++) {
            virDomainNetDefPtr net = vm->def->nets[i];

            if (net->type == VIR_DOMAIN_NET_TYPE_USER &&
                virQEMUCapsGet(info->qemuCaps, QEMU_CAPS_DBUS_VMSTATE)) {
                qemuSlirpPtr slirp = qemuSlirpNew();
                slirp->fd[0] = 42;
                QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp = slirp;
            }
        }
    }

    return qemuProcessCreatePretendCmd(drv, vm, migrateURI,
                                       (flags & FLAG_FIPS), false,
478
                                       jsonPropsValidation,
479 480 481 482
                                       VIR_QEMU_PROCESS_START_COLD);
}


483 484 485 486 487 488 489
static int
testCompareXMLToArgvValidateSchema(virQEMUDriverPtr drv,
                                   const char *migrateURI,
                                   struct testQemuInfo *info,
                                   unsigned int flags)
{
    VIR_AUTOSTRINGLIST args = NULL;
490
    g_autoptr(virDomainObj) vm = NULL;
491 492 493 494
    size_t nargs = 0;
    size_t i;
    g_autoptr(virHashTable) schema = NULL;
    g_autoptr(virCommand) cmd = NULL;
495
    unsigned int parseFlags = info->parseFlags;
496 497 498 499 500 501 502 503 504 505 506 507

    if (info->schemafile)
        schema = testQEMUSchemaLoad(info->schemafile);

    /* comment out with line comment to enable schema checking for non _CAPS tests
    if (!schema)
        schema = testQEMUSchemaLoadLatest(virArchToString(info->arch));
    // */

    if (!schema)
        return 0;

508 509 510 511 512 513 514 515 516
    if (!(vm = virDomainObjNew(driver.xmlopt)))
        return -1;

    parseFlags |= VIR_DOMAIN_DEF_PARSE_INACTIVE;
    if (!(vm->def = virDomainDefParseFile(info->infile,
                                          driver.xmlopt,
                                          NULL, parseFlags)))
        return -1;

517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
    if (!(cmd = testCompareXMLToArgvCreateArgs(drv, vm, migrateURI, info, flags,
                                               true)))
        return -1;

    if (virCommandGetArgList(cmd, &args, &nargs) < 0)
        return -1;

    for (i = 0; i < nargs; i++) {
        g_auto(virBuffer) debug = VIR_BUFFER_INITIALIZER;
        g_autoptr(virJSONValue) jsonargs = NULL;

        if (STREQ(args[i], "-blockdev")) {
            if (!(jsonargs = virJSONValueFromString(args[i + 1])))
                return -1;

            if (testQEMUSchemaValidateCommand("blockdev-add", jsonargs,
                                              schema, false, false, &debug) < 0) {
                VIR_TEST_VERBOSE("failed to validate -blockdev '%s' against QAPI schema: %s",
                                 args[i + 1], virBufferCurrentContent(&debug));
                return -1;
            }

            i++;
        } else if (STREQ(args[i], "-netdev")) {
            if (!(jsonargs = virJSONValueFromString(args[i + 1])))
                return -1;

            /* skip the validation for pre-QAPIfication cases */
            if (virQEMUQAPISchemaPathExists("netdev_add/arg-type/type/!string", schema))
                continue;

            if (testQEMUSchemaValidateCommand("netdev_add", jsonargs,
                                              schema, false, false, &debug) < 0) {
                VIR_TEST_VERBOSE("failed to validate -netdev '%s' against QAPI schema: %s",
                                 args[i + 1], virBufferCurrentContent(&debug));
                return -1;
            }

            i++;
        }
    }

    return 0;
}


563 564 565
static int
testCompareXMLToArgv(const void *data)
{
566
    struct testQemuInfo *info = (void *) data;
567
    char *migrateURI = NULL;
568
    char *actualargv = NULL;
569 570
    unsigned int flags = info->flags;
    unsigned int parseFlags = info->parseFlags;
E
Eric Blake 已提交
571
    int ret = -1;
572
    virDomainObjPtr vm = NULL;
573
    virDomainChrSourceDef monitor_chr;
574
    virConnectPtr conn;
J
Jiri Denemark 已提交
575
    char *log = NULL;
E
Eric Blake 已提交
576
    virCommandPtr cmd = NULL;
577
    qemuDomainObjPrivatePtr priv = NULL;
578

579
    if (info->arch != VIR_ARCH_NONE && info->arch != VIR_ARCH_X86_64)
580
        qemuTestSetHostArch(&driver, info->arch);
581

582 583
    memset(&monitor_chr, 0, sizeof(monitor_chr));

584
    if (!(conn = virGetConnect()))
585
        goto cleanup;
586

587
    conn->secretDriver = &fakeSecretDriver;
588
    conn->storageDriver = &fakeStorageDriver;
589
    conn->nwfilterDriver = &fakeNWFilterDriver;
590

591 592 593 594
    virSetConnectInterface(conn);
    virSetConnectNetwork(conn);
    virSetConnectNWFilter(conn);
    virSetConnectNodeDev(conn);
595 596 597
    virSetConnectSecret(conn);
    virSetConnectStorage(conn);

598 599 600
    if (virQEMUCapsGet(info->qemuCaps, QEMU_CAPS_ENABLE_FIPS))
        flags |= FLAG_FIPS;

601 602 603
    if (testCheckExclusiveFlags(info->flags) < 0)
        goto cleanup;

604
    if (qemuTestCapsCacheInsert(driver.qemuCapsCache, info->qemuCaps) < 0)
605 606 607
        goto cleanup;

    if (info->migrateFrom &&
608 609
        !(migrateURI = qemuMigrationDstGetURI(info->migrateFrom,
                                              info->migrateFd)))
610 611
        goto cleanup;

612
    if (!(vm = virDomainObjNew(driver.xmlopt)))
613
        goto cleanup;
614

615
    parseFlags |= VIR_DOMAIN_DEF_PARSE_INACTIVE;
616
    if (!(vm->def = virDomainDefParseFile(info->infile,
617
                                          driver.xmlopt,
618
                                          NULL, parseFlags))) {
P
Pavel Hrdina 已提交
619
        if (flags & FLAG_EXPECT_PARSE_ERROR)
620
            goto ok;
621
        goto cleanup;
622
    }
623 624 625 626
    if (flags & FLAG_EXPECT_PARSE_ERROR) {
        VIR_TEST_DEBUG("passed instead of expected parse error");
        goto cleanup;
    }
627
    priv = vm->privateData;
628

629
    if (virBitmapParse("0-3", &priv->autoNodeset, 4) < 0)
630
        goto cleanup;
P
Pavel Hrdina 已提交
631

632
    if (!virDomainDefCheckABIStability(vm->def, vm->def, driver.xmlopt)) {
633
        VIR_TEST_DEBUG("ABI stability check failed on %s", info->infile);
634
        goto cleanup;
635 636
    }

637
    vm->def->id = -1;
638

639
    if (qemuProcessPrepareMonitorChr(&monitor_chr, priv->libDir) < 0)
640
        goto cleanup;
641

642 643 644 645 646 647
    if (!(info->flags & FLAG_REAL_CAPS)) {
        if (testUpdateQEMUCaps(info, vm, driver.caps) < 0)
            goto cleanup;
        if (qemuTestCapsCacheInsert(driver.qemuCapsCache, info->qemuCaps) < 0)
            goto cleanup;
    }
648

649
    log = virTestLogContentAndReset();
650
    VIR_FREE(log);
651
    virResetLastError();
J
Jiri Denemark 已提交
652

653
    if (!(cmd = testCompareXMLToArgvCreateArgs(&driver, vm, migrateURI, info,
654
                                               flags, false))) {
P
Pavel Hrdina 已提交
655 656
        if (flags & FLAG_EXPECT_FAILURE)
            goto ok;
657
        goto cleanup;
J
Jiri Denemark 已提交
658
    }
659 660 661 662
    if (flags & FLAG_EXPECT_FAILURE) {
        VIR_TEST_DEBUG("passed instead of expected failure");
        goto cleanup;
    }
J
Jiri Denemark 已提交
663

664
    if (testCompareXMLToArgvValidateSchema(&driver, migrateURI, info, flags) < 0)
665 666
        goto cleanup;

667
    if (!(actualargv = virCommandToString(cmd, false)))
668
        goto cleanup;
E
Eric Blake 已提交
669

670
    if (virTestCompareToFile(actualargv, info->outfile) < 0)
671
        goto cleanup;
672

P
Pavel Hrdina 已提交
673 674
    ret = 0;

675
 ok:
676
    if (ret == 0 && flags & FLAG_EXPECT_FAILURE) {
P
Pavel Hrdina 已提交
677
        ret = -1;
678
        VIR_TEST_DEBUG("Error expected but there wasn't any.");
679
        goto cleanup;
P
Pavel Hrdina 已提交
680
    }
681 682 683
    if (flags & FLAG_EXPECT_FAILURE) {
        if ((log = virTestLogContentAndReset()))
            VIR_TEST_DEBUG("Got expected error: \n%s", log);
684
    }
685 686
    virResetLastError();
    ret = 0;
687

688
 cleanup:
689 690
    VIR_FREE(log);
    VIR_FREE(actualargv);
691
    virDomainChrSourceDefClear(&monitor_chr);
E
Eric Blake 已提交
692
    virCommandFree(cmd);
693
    virObjectUnref(vm);
694 695
    virSetConnectSecret(NULL);
    virSetConnectStorage(NULL);
696
    virObjectUnref(conn);
697
    VIR_FREE(migrateURI);
698
    if (info->arch != VIR_ARCH_NONE && info->arch != VIR_ARCH_X86_64)
699
        qemuTestSetHostArch(&driver, VIR_ARCH_NONE);
700

701
    return ret;
702 703
}

704
static void
705
testInfoSetPaths(struct testQemuInfo *info,
706 707
                 const char *suffix)
{
708 709 710 711
    info->infile = g_strdup_printf("%s/qemuxml2argvdata/%s.xml",
                                   abs_srcdir, info->name);
    info->outfile = g_strdup_printf("%s/qemuxml2argvdata/%s%s.args",
                                    abs_srcdir, info->name, suffix ? suffix : "");
712 713
}

714 715
# define FAKEROOTDIRTEMPLATE abs_builddir "/fakerootdir-XXXXXX"

716
static int
E
Eric Blake 已提交
717
mymain(void)
718
{
C
Cole Robinson 已提交
719
    int ret = 0;
720
    char *fakerootdir;
721
    virHashTablePtr capslatest = NULL;
722

723 724 725 726 727 728 729 730 731
    fakerootdir = g_strdup(FAKEROOTDIRTEMPLATE);

    if (!g_mkdtemp(fakerootdir)) {
        fprintf(stderr, "Cannot create fakerootdir");
        abort();
    }

    g_setenv("LIBVIRT_FAKE_ROOT_DIR", fakerootdir, TRUE);

732 733 734 735 736
    /* Set the timezone because we are mocking the time() function.
     * If we don't do that, then localtime() may return unpredictable
     * results. In order to detect things that just work by a blind
     * chance, we need to set an virtual timezone that no libvirt
     * developer resides in. */
737 738
    if (g_setenv("TZ", "VIR00:30", TRUE) == FALSE) {
        perror("g_setenv");
739 740 741
        return EXIT_FAILURE;
    }

742
    if (qemuTestDriverInit(&driver) < 0)
743
        return EXIT_FAILURE;
744 745

    driver.privileged = true;
746

747
    VIR_FREE(driver.config->defaultTLSx509certdir);
748
    driver.config->defaultTLSx509certdir = g_strdup("/etc/pki/qemu");
749
    VIR_FREE(driver.config->vncTLSx509certdir);
750
    driver.config->vncTLSx509certdir = g_strdup("/etc/pki/libvirt-vnc");
751
    VIR_FREE(driver.config->spiceTLSx509certdir);
752
    driver.config->spiceTLSx509certdir = g_strdup("/etc/pki/libvirt-spice");
753
    VIR_FREE(driver.config->chardevTLSx509certdir);
754
    driver.config->chardevTLSx509certdir = g_strdup("/etc/pki/libvirt-chardev");
755
    VIR_FREE(driver.config->vxhsTLSx509certdir);
756
    driver.config->vxhsTLSx509certdir = g_strdup("/etc/pki/libvirt-vxhs/dummy,path");
757
    VIR_FREE(driver.config->nbdTLSx509certdir);
758
    driver.config->nbdTLSx509certdir = g_strdup("/etc/pki/libvirt-nbd/dummy,path");
759

760
    VIR_FREE(driver.config->hugetlbfs);
761
    if (VIR_ALLOC_N(driver.config->hugetlbfs, 2) < 0)
762
        return EXIT_FAILURE;
763
    driver.config->nhugetlbfs = 2;
764 765
    driver.config->hugetlbfs[0].mnt_dir = g_strdup("/dev/hugepages2M");
    driver.config->hugetlbfs[1].mnt_dir = g_strdup("/dev/hugepages1G");
766 767
    driver.config->hugetlbfs[0].size = 2048;
    driver.config->hugetlbfs[0].deflt = true;
768
    driver.config->hugetlbfs[1].size = 1048576;
769
    driver.config->spiceTLS = 1;
770
    driver.config->spicePassword = g_strdup("123456");
771
    VIR_FREE(driver.config->memoryBackingDir);
772
    driver.config->memoryBackingDir = g_strdup("/var/lib/libvirt/qemu/ram");
773
    VIR_FREE(driver.config->nvramDir);
774
    driver.config->nvramDir = g_strdup("/var/lib/libvirt/qemu/nvram");
775

C
Cole Robinson 已提交
776
    capslatest = testQemuGetLatestCaps();
777
    if (!capslatest)
778 779
        return EXIT_FAILURE;

780 781 782 783 784 785 786
    virFileWrapperAddPrefix(SYSCONFDIR "/qemu/firmware",
                            abs_srcdir "/qemufirmwaredata/etc/qemu/firmware");
    virFileWrapperAddPrefix(PREFIX "/share/qemu/firmware",
                            abs_srcdir "/qemufirmwaredata/usr/share/qemu/firmware");
    virFileWrapperAddPrefix("/home/user/.config/qemu/firmware",
                            abs_srcdir "/qemufirmwaredata/home/user/.config/qemu/firmware");

787 788 789 790 791 792 793 794 795 796
    virFileWrapperAddPrefix(SYSCONFDIR "/qemu/vhost-user",
                            abs_srcdir "/qemuvhostuserdata/etc/qemu/vhost-user");
    virFileWrapperAddPrefix(PREFIX "/share/qemu/vhost-user",
                            abs_srcdir "/qemuvhostuserdata/usr/share/qemu/vhost-user");
    virFileWrapperAddPrefix("/home/user/.config/qemu/vhost-user",
                            abs_srcdir "/qemuvhostuserdata/home/user/.config/qemu/vhost-user");

    virFileWrapperAddPrefix("/usr/libexec/qemu/vhost-user",
                            abs_srcdir "/qemuvhostuserdata/usr/libexec/qemu/vhost-user");

797 798 799 800 801 802 803 804 805 806 807 808 809 810
/**
 * The following set of macros allows testing of XML -> argv conversion with a
 * real set of capabilities gathered from a real qemu copy. It is desired to use
 * these for positive test cases as it provides combinations of flags which
 * can be met in real life.
 *
 * The capabilities are taken from the real capabilities stored in
 * tests/qemucapabilitiesdata.
 *
 * It is suggested to use the DO_TEST_CAPS_LATEST macro which always takes the
 * most recent capability set. In cases when the new code would change behaviour
 * the test cases should be forked using DO_TEST_CAPS_VER with the appropriate
 * version.
 */
811
# define DO_TEST_INTERNAL(_name, _suffix, ...) \
812
    do { \
813
        static struct testQemuInfo info = { \
814
            .name = _name, \
815
        }; \
816 817
        if (testQemuInfoSetArgs(&info, capslatest, \
                                __VA_ARGS__, ARG_END) < 0) \
818
            return EXIT_FAILURE; \
819
        testInfoSetPaths(&info, _suffix); \
820
        if (virTestRun("QEMU XML-2-ARGV " _name _suffix, \
821 822
                       testCompareXMLToArgv, &info) < 0) \
            ret = -1; \
823
        testQemuInfoClear(&info); \
824 825
    } while (0)

826 827 828 829 830 831
# define DO_TEST_CAPS_INTERNAL(name, arch, ver, ...) \
    DO_TEST_INTERNAL(name, "." arch "-" ver, \
                     ARG_CAPS_ARCH, arch, \
                     ARG_CAPS_VER, ver, \
                     __VA_ARGS__)

832
# define DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, ...) \
833
    DO_TEST_CAPS_INTERNAL(name, arch, "latest", __VA_ARGS__)
834

835 836 837
# define DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, ...) \
    DO_TEST_CAPS_INTERNAL(name, arch, ver, __VA_ARGS__)

838
# define DO_TEST_CAPS_ARCH_LATEST(name, arch) \
839
    DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, ARG_END)
840

841
# define DO_TEST_CAPS_ARCH_VER(name, arch, ver) \
842
    DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, ARG_END)
843

844
# define DO_TEST_CAPS_LATEST(name) \
845
    DO_TEST_CAPS_ARCH_LATEST(name, "x86_64")
846

847 848 849
# define DO_TEST_CAPS_VER(name, ver) \
    DO_TEST_CAPS_ARCH_VER(name, "x86_64", ver)

850 851 852
# define DO_TEST_CAPS_LATEST_PPC64(name) \
    DO_TEST_CAPS_ARCH_LATEST(name, "ppc64")

853 854
# define DO_TEST_CAPS_ARCH_LATEST_FAILURE(name, arch) \
    DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, \
855
                                  ARG_FLAGS, FLAG_EXPECT_FAILURE)
856

857 858 859 860 861 862 863 864 865 866 867 868
# define DO_TEST_CAPS_ARCH_VER_FAILURE(name, arch, ver) \
    DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, \
                               ARG_FLAGS, FLAG_EXPECT_FAILURE)

# define DO_TEST_CAPS_LATEST_FAILURE(name) \
    DO_TEST_CAPS_ARCH_LATEST_FAILURE(name, "x86_64")

# define DO_TEST_CAPS_VER_FAILURE(name, ver) \
    DO_TEST_CAPS_ARCH_VER_FAILURE(name, "x86_64", ver)

# define DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR(name, arch) \
    DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, \
869
                                  ARG_FLAGS, FLAG_EXPECT_PARSE_ERROR)
870

871 872 873 874 875 876 877 878 879 880
# define DO_TEST_CAPS_ARCH_VER_PARSE_ERROR(name, arch, ver) \
    DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, \
                               ARG_FLAGS, FLAG_EXPECT_PARSE_ERROR)

# define DO_TEST_CAPS_LATEST_PARSE_ERROR(name) \
    DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR(name, "x86_64")

# define DO_TEST_CAPS_VER_PARSE_ERROR(name, ver) \
    DO_TEST_CAPS_ARCH_VER_PARSE_ERROR(name, "x86_64", ver)

881 882 883
# define DO_TEST_FULL(name, ...) \
    DO_TEST_INTERNAL(name, "", \
                     __VA_ARGS__, QEMU_CAPS_LAST)
884

885 886 887
/* All the following macros require an explicit QEMU_CAPS_* list
 * at the end of the argument list, or the NONE placeholder.
 * */
888
# define DO_TEST(name, ...) \
889
    DO_TEST_FULL(name, \
890
                 ARG_QEMU_CAPS, __VA_ARGS__)
891

892
# define DO_TEST_GIC(name, gic, ...) \
893
    DO_TEST_FULL(name, \
894
                 ARG_GIC, gic, \
895
                 ARG_QEMU_CAPS, __VA_ARGS__)
896

897
# define DO_TEST_FAILURE(name, ...) \
898 899
    DO_TEST_FULL(name, \
                 ARG_FLAGS, FLAG_EXPECT_FAILURE, \
900
                 ARG_QEMU_CAPS, __VA_ARGS__)
901

902
# define DO_TEST_PARSE_ERROR(name, ...) \
903
    DO_TEST_FULL(name, \
904
                 ARG_FLAGS, FLAG_EXPECT_PARSE_ERROR | FLAG_EXPECT_FAILURE, \
905
                 ARG_QEMU_CAPS, __VA_ARGS__)
906

907
# define NONE QEMU_CAPS_LAST
908

909 910 911
    /* Unset or set all envvars here that are copied in qemudBuildCommandLine
     * using ADD_ENV_COPY, otherwise these tests may fail due to unexpected
     * values for these envvars */
912 913 914 915 916 917 918 919 920
    g_setenv("PATH", "/bin", TRUE);
    g_setenv("USER", "test", TRUE);
    g_setenv("LOGNAME", "test", TRUE);
    g_setenv("HOME", "/home/test", TRUE);
    g_unsetenv("TMPDIR");
    g_unsetenv("LD_PRELOAD");
    g_unsetenv("LD_LIBRARY_PATH");
    g_unsetenv("QEMU_AUDIO_DRV");
    g_unsetenv("SDL_AUDIODRIVER");
921

922
    DO_TEST("minimal", NONE);
923 924
    DO_TEST("minimal-sandbox",
            QEMU_CAPS_SECCOMP_BLACKLIST);
925
    DO_TEST_PARSE_ERROR("minimal-no-memory", NONE);
926
    DO_TEST("minimal-msg-timestamp", QEMU_CAPS_MSG_TIMESTAMP);
927 928 929 930

    DO_TEST_CAPS_LATEST("genid");
    DO_TEST_CAPS_LATEST("genid-auto");

931
    DO_TEST("machine-aliases1", NONE);
932
    DO_TEST("machine-aliases2", QEMU_CAPS_KVM);
933
    DO_TEST("machine-core-on", NONE);
934
    driver.config->dumpGuestCore = true;
935
    DO_TEST("machine-core-off", NONE);
936
    driver.config->dumpGuestCore = false;
M
Michal Privoznik 已提交
937 938 939
    DO_TEST("machine-smm-opt",
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
940
            QEMU_CAPS_DEVICE_IOH3420,
M
Michal Privoznik 已提交
941 942 943
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_MACHINE_SMM_OPT,
            QEMU_CAPS_VIRTIO_SCSI);
944
    DO_TEST("machine-vmport-opt",
945
            QEMU_CAPS_MACHINE_VMPORT_OPT);
946 947 948
    DO_TEST("default-kvm-host-arch", NONE);
    DO_TEST("default-qemu-host-arch", NONE);
    DO_TEST("x86-kvm-32-on-64", NONE);
949 950 951
    DO_TEST("boot-cdrom", NONE);
    DO_TEST("boot-network", NONE);
    DO_TEST("boot-floppy", NONE);
952
    DO_TEST("boot-floppy-q35",
953
            QEMU_CAPS_DEVICE_IOH3420,
954
            QEMU_CAPS_ICH9_AHCI);
J
Ján Tomko 已提交
955 956
    DO_TEST("boot-multi", NONE);
    DO_TEST("boot-menu-enable", NONE);
957
    DO_TEST("boot-menu-enable-with-timeout",
958
            QEMU_CAPS_SPLASH_TIMEOUT);
959
    DO_TEST_PARSE_ERROR("boot-menu-enable-with-timeout", NONE);
960
    DO_TEST_PARSE_ERROR("boot-menu-enable-with-timeout-invalid", NONE);
J
Ján Tomko 已提交
961 962
    DO_TEST("boot-menu-disable", NONE);
    DO_TEST("boot-menu-disable-drive", NONE);
963
    DO_TEST_PARSE_ERROR("boot-dev+order",
964
            QEMU_CAPS_VIRTIO_BLK_SCSI);
965
    DO_TEST("boot-order",
966
            QEMU_CAPS_VIRTIO_BLK_SCSI);
967
    DO_TEST("boot-complex",
968
            QEMU_CAPS_VIRTIO_BLK_SCSI);
969
    DO_TEST("boot-strict",
970
            QEMU_CAPS_BOOT_STRICT,
971
            QEMU_CAPS_VIRTIO_BLK_SCSI);
972 973 974

    DO_TEST("reboot-timeout-disabled", QEMU_CAPS_REBOOT_TIMEOUT);
    DO_TEST("reboot-timeout-enabled", QEMU_CAPS_REBOOT_TIMEOUT);
975
    DO_TEST_PARSE_ERROR("reboot-timeout-enabled", NONE);
976

977
    DO_TEST("bios",
978
            QEMU_CAPS_DEVICE_ISA_SERIAL,
979
            QEMU_CAPS_SGA);
J
Ján Tomko 已提交
980
    DO_TEST("bios-nvram", NONE);
M
Michal Privoznik 已提交
981 982 983
    DO_TEST("bios-nvram-secure",
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
984
            QEMU_CAPS_DEVICE_IOH3420,
M
Michal Privoznik 已提交
985 986 987
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_MACHINE_SMM_OPT,
            QEMU_CAPS_VIRTIO_SCSI);
988 989 990 991 992 993 994

    /* Make sure all combinations of ACPI and UEFI behave as expected */
    DO_TEST("q35-acpi-uefi", NONE);
    DO_TEST_PARSE_ERROR("q35-noacpi-uefi", NONE);
    DO_TEST("q35-noacpi-nouefi", NONE);
    DO_TEST("q35-acpi-nouefi", NONE);

995
    DO_TEST("clock-utc", NONE);
996
    DO_TEST("clock-localtime", NONE);
J
Ján Tomko 已提交
997 998 999 1000
    DO_TEST("clock-localtime-basis-localtime", NONE);
    DO_TEST("clock-variable", NONE);
    DO_TEST("clock-france", NONE);
    DO_TEST("clock-hpet-off", NONE);
J
Ján Tomko 已提交
1001
    DO_TEST("clock-catchup", QEMU_CAPS_KVM_PIT_TICK_POLICY);
1002 1003
    DO_TEST("cpu-kvmclock", NONE);
    DO_TEST("cpu-host-kvmclock", NONE);
1004
    DO_TEST("kvmclock", QEMU_CAPS_KVM);
1005
    DO_TEST("clock-timer-hyperv-rtc", QEMU_CAPS_KVM);
1006

1007 1008
    DO_TEST("cpu-eoi-disabled", NONE);
    DO_TEST("cpu-eoi-enabled", NONE);
J
Ján Tomko 已提交
1009
    DO_TEST("controller-order",
1010 1011 1012 1013 1014 1015
            QEMU_CAPS_KVM,
            QEMU_CAPS_PIIX3_USB_UHCI,
            QEMU_CAPS_CCID_PASSTHRU,
            QEMU_CAPS_SPICE,
            QEMU_CAPS_HDA_DUPLEX,
            QEMU_CAPS_USB_HUB,
1016
            QEMU_CAPS_DEVICE_ISA_SERIAL,
1017
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
1018
    DO_TEST_CAPS_VER("eoi-disabled", "2.7.0");
1019
    DO_TEST_CAPS_VER("eoi-disabled", "4.0.0");
1020 1021
    DO_TEST_CAPS_LATEST("eoi-disabled");
    DO_TEST_CAPS_VER("eoi-enabled", "2.7.0");
1022
    DO_TEST_CAPS_VER("eoi-enabled", "4.0.0");
1023 1024
    DO_TEST_CAPS_LATEST("eoi-enabled");
    DO_TEST_CAPS_VER("pv-spinlock-disabled", "2.7.0");
1025
    DO_TEST_CAPS_VER("pv-spinlock-disabled", "4.0.0");
1026 1027
    DO_TEST_CAPS_LATEST("pv-spinlock-disabled");
    DO_TEST_CAPS_VER("pv-spinlock-enabled", "2.7.0");
1028
    DO_TEST_CAPS_VER("pv-spinlock-enabled", "4.0.0");
1029 1030
    DO_TEST_CAPS_LATEST("pv-spinlock-enabled");
    DO_TEST_CAPS_VER("kvmclock+eoi-disabled", "2.7.0");
1031
    DO_TEST_CAPS_VER("kvmclock+eoi-disabled", "4.0.0");
1032
    DO_TEST_CAPS_LATEST("kvmclock+eoi-disabled");
1033

1034 1035 1036 1037 1038 1039
    DO_TEST_CAPS_VER("hyperv", "4.0.0");
    DO_TEST_CAPS_LATEST("hyperv");
    DO_TEST_CAPS_VER("hyperv-off", "4.0.0");
    DO_TEST_CAPS_LATEST("hyperv-off");
    DO_TEST_CAPS_VER("hyperv-panic", "4.0.0");
    DO_TEST_CAPS_LATEST("hyperv-panic");
1040
    DO_TEST_CAPS_LATEST("hyperv-stimer-direct");
1041

1042 1043 1044
    DO_TEST("kvm-features", NONE);
    DO_TEST("kvm-features-off", NONE);

1045 1046 1047
    DO_TEST("pmu-feature", NONE);
    DO_TEST("pmu-feature-off", NONE);

1048 1049 1050
    DO_TEST("pages-discard",
            QEMU_CAPS_OBJECT_MEMORY_FILE,
            QEMU_CAPS_OBJECT_MEMORY_FILE_DISCARD);
1051 1052 1053 1054
    DO_TEST("pages-discard-hugepages",
            QEMU_CAPS_OBJECT_MEMORY_RAM,
            QEMU_CAPS_OBJECT_MEMORY_FILE,
            QEMU_CAPS_OBJECT_MEMORY_FILE_DISCARD);
1055 1056 1057 1058
    DO_TEST("pages-dimm-discard",
            QEMU_CAPS_DEVICE_PC_DIMM,
            QEMU_CAPS_OBJECT_MEMORY_FILE,
            QEMU_CAPS_OBJECT_MEMORY_FILE_DISCARD);
1059 1060
    DO_TEST("hugepages-default", QEMU_CAPS_OBJECT_MEMORY_FILE);
    DO_TEST("hugepages-default-2M", QEMU_CAPS_OBJECT_MEMORY_FILE);
1061
    DO_TEST("hugepages-default-system-size", QEMU_CAPS_OBJECT_MEMORY_FILE);
1062
    DO_TEST_PARSE_ERROR("hugepages-default-1G-nodeset-2M", NONE);
1063
    DO_TEST("hugepages-nodeset", QEMU_CAPS_OBJECT_MEMORY_FILE);
1064 1065 1066 1067
    DO_TEST_PARSE_ERROR("hugepages-nodeset-nonexist",
                        QEMU_CAPS_DEVICE_PC_DIMM,
                        QEMU_CAPS_OBJECT_MEMORY_FILE,
                        QEMU_CAPS_OBJECT_MEMORY_FILE_DISCARD);
1068
    DO_TEST("hugepages-numa-default",
1069
            QEMU_CAPS_OBJECT_MEMORY_FILE);
1070 1071 1072
    DO_TEST("hugepages-numa-default-2M",
            QEMU_CAPS_OBJECT_MEMORY_RAM,
            QEMU_CAPS_OBJECT_MEMORY_FILE);
1073
    DO_TEST("hugepages-numa-default-dimm",
1074
            QEMU_CAPS_DEVICE_PC_DIMM,
J
Ján Tomko 已提交
1075
            QEMU_CAPS_OBJECT_MEMORY_FILE);
1076
    DO_TEST("hugepages-numa-nodeset",
A
Andrea Bolognani 已提交
1077
            QEMU_CAPS_OBJECT_MEMORY_RAM,
1078
            QEMU_CAPS_OBJECT_MEMORY_FILE);
1079 1080
    DO_TEST("hugepages-numa-nodeset-part",
            QEMU_CAPS_OBJECT_MEMORY_RAM,
1081
            QEMU_CAPS_OBJECT_MEMORY_FILE);
1082 1083 1084
    DO_TEST_PARSE_ERROR("hugepages-numa-nodeset-nonexist",
                        QEMU_CAPS_OBJECT_MEMORY_RAM,
                        QEMU_CAPS_OBJECT_MEMORY_FILE);
A
Andrea Bolognani 已提交
1085 1086 1087
    DO_TEST("hugepages-shared",
            QEMU_CAPS_OBJECT_MEMORY_RAM,
            QEMU_CAPS_OBJECT_MEMORY_FILE);
1088
    DO_TEST_PARSE_ERROR("hugepages-memaccess-invalid", NONE);
1089 1090 1091
    DO_TEST("hugepages-memaccess", QEMU_CAPS_OBJECT_MEMORY_FILE,
            QEMU_CAPS_OBJECT_MEMORY_RAM, QEMU_CAPS_DEVICE_PC_DIMM,
            QEMU_CAPS_NUMA);
1092 1093 1094
    DO_TEST("hugepages-memaccess2", QEMU_CAPS_OBJECT_MEMORY_FILE,
            QEMU_CAPS_OBJECT_MEMORY_RAM, QEMU_CAPS_DEVICE_PC_DIMM,
            QEMU_CAPS_NUMA);
1095 1096 1097
    DO_TEST_PARSE_ERROR("hugepages-memaccess3",
                        QEMU_CAPS_OBJECT_MEMORY_RAM,
                        QEMU_CAPS_OBJECT_MEMORY_FILE);
1098
    DO_TEST_CAPS_LATEST("hugepages-nvdimm");
1099
    DO_TEST("nosharepages", QEMU_CAPS_MEM_MERGE);
1100
    DO_TEST("disk-cdrom", NONE);
1101
    DO_TEST_CAPS_VER("disk-cdrom", "2.12.0");
1102
    DO_TEST_CAPS_LATEST("disk-cdrom");
1103
    DO_TEST_CAPS_LATEST("disk-cdrom-empty-network-invalid");
1104
    DO_TEST_CAPS_LATEST("disk-cdrom-bus-other");
1105
    DO_TEST("disk-iscsi", NONE);
1106
    DO_TEST("disk-cdrom-network", QEMU_CAPS_KVM);
1107
    DO_TEST_CAPS_VER("disk-cdrom-network", "2.12.0");
1108
    DO_TEST_CAPS_LATEST("disk-cdrom-network");
1109
    DO_TEST("disk-cdrom-tray",
1110
            QEMU_CAPS_VIRTIO_TX_ALG);
1111
    DO_TEST_CAPS_VER("disk-cdrom-tray", "2.12.0");
1112
    DO_TEST_CAPS_LATEST("disk-cdrom-tray");
1113
    DO_TEST("disk-floppy", NONE);
1114
    DO_TEST_CAPS_VER("disk-floppy", "2.12.0");
1115
    DO_TEST_CAPS_LATEST("disk-floppy");
1116
    DO_TEST_CAPS_VER("disk-floppy-q35-2_9", "2.12.0");
1117
    DO_TEST_CAPS_LATEST("disk-floppy-q35-2_9");
1118
    DO_TEST_CAPS_VER("disk-floppy-q35-2_11", "2.12.0");
1119
    DO_TEST_CAPS_LATEST("disk-floppy-q35-2_11");
1120 1121
    DO_TEST_FAILURE("disk-floppy-pseries",
                    QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
1122
    DO_TEST("disk-floppy-tray", NONE);
1123
    DO_TEST("disk-virtio-s390",
1124
            QEMU_CAPS_VIRTIO_S390);
1125
    DO_TEST("disk-virtio", NONE);
1126
    DO_TEST("disk-virtio-ccw",
1127
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
1128
    DO_TEST("disk-virtio-ccw-many",
1129
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
1130 1131 1132 1133
    DO_TEST("disk-virtio-s390-zpci",
            QEMU_CAPS_DEVICE_ZPCI,
            QEMU_CAPS_CCW,
            QEMU_CAPS_VIRTIO_S390);
1134
    DO_TEST("disk-order", QEMU_CAPS_VIRTIO_BLK_SCSI);
1135
    DO_TEST("disk-virtio-queues",
L
Lin Ma 已提交
1136
            QEMU_CAPS_VIRTIO_BLK_NUM_QUEUES);
1137 1138 1139
    DO_TEST("disk-boot-disk", NONE);
    DO_TEST("disk-boot-cdrom", NONE);
    DO_TEST("floppy-drive-fat", NONE);
1140
    DO_TEST_CAPS_VER("floppy-drive-fat", "2.12.0");
1141
    DO_TEST_CAPS_LATEST("floppy-drive-fat");
1142
    DO_TEST("disk-readonly-disk", NONE);
1143
    DO_TEST_CAPS_VER("disk-readonly-disk", "2.12.0");
1144
    DO_TEST_CAPS_LATEST("disk-readonly-disk");
1145 1146 1147 1148
    DO_TEST("disk-fmt-qcow", NONE);
    DO_TEST_PARSE_ERROR("disk-fmt-cow", NONE);
    DO_TEST_PARSE_ERROR("disk-fmt-dir", NONE);
    DO_TEST_PARSE_ERROR("disk-fmt-iso", NONE);
1149
    DO_TEST_CAPS_VER("disk-shared", "2.12.0");
1150
    DO_TEST_CAPS_LATEST("disk-shared");
1151 1152
    DO_TEST_PARSE_ERROR("disk-shared-qcow", NONE);
    DO_TEST("disk-error-policy", NONE);
1153
    DO_TEST_CAPS_VER("disk-error-policy", "2.12.0");
1154
    DO_TEST_CAPS_LATEST("disk-error-policy");
1155 1156
    DO_TEST_CAPS_ARCH_VER("disk-error-policy-s390x", "s390x", "2.12.0");
    DO_TEST_CAPS_ARCH_LATEST("disk-error-policy-s390x", "s390x");
1157
    DO_TEST_CAPS_VER("disk-cache", "1.5.3");
1158 1159
    DO_TEST_CAPS_VER("disk-cache", "2.6.0");
    DO_TEST_CAPS_VER("disk-cache", "2.7.0");
1160
    DO_TEST_CAPS_VER("disk-cache", "2.12.0");
1161
    DO_TEST_CAPS_LATEST("disk-cache");
1162
    DO_TEST("disk-network-nbd", NONE);
1163
    DO_TEST_CAPS_VER("disk-network-nbd", "2.12.0");
1164
    DO_TEST_CAPS_LATEST("disk-network-nbd");
1165
    DO_TEST("disk-network-iscsi", QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_BLOCK);
1166 1167 1168 1169
    DO_TEST("disk-network-iscsi-modern",
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_BLOCK,
            QEMU_CAPS_ISCSI_PASSWORD_SECRET);
1170
    DO_TEST_CAPS_VER("disk-network-iscsi", "2.12.0");
1171
    DO_TEST_CAPS_LATEST("disk-network-iscsi");
1172 1173 1174 1175
    DO_TEST_PARSE_ERROR("disk-network-iscsi-auth-secrettype-invalid", NONE);
    DO_TEST_PARSE_ERROR("disk-network-iscsi-auth-wrong-secrettype", NONE);
    DO_TEST_PARSE_ERROR("disk-network-source-auth-both", NONE);
    DO_TEST("disk-network-gluster",
1176
            QEMU_CAPS_GLUSTER_DEBUG_LEVEL);
1177
    DO_TEST_CAPS_VER("disk-network-gluster", "2.12.0");
1178
    DO_TEST_CAPS_LATEST("disk-network-gluster");
1179
    DO_TEST_CAPS_VER("disk-network-rbd", "2.5.0");
1180
    DO_TEST_CAPS_VER("disk-network-rbd", "2.12.0");
1181 1182
    DO_TEST_CAPS_LATEST("disk-network-rbd");
    DO_TEST_FAILURE("disk-network-rbd-no-colon", NONE);
1183
    DO_TEST("disk-network-sheepdog", NONE);
1184
    DO_TEST_CAPS_VER("disk-network-sheepdog", "2.12.0");
1185
    DO_TEST_CAPS_LATEST("disk-network-sheepdog");
1186
    DO_TEST("disk-network-source-auth", NONE);
1187
    DO_TEST_CAPS_VER("disk-network-source-auth", "2.12.0");
1188
    DO_TEST_CAPS_LATEST("disk-network-source-auth");
1189
    DO_TEST("disk-network-vxhs", QEMU_CAPS_VXHS);
1190
    driver.config->vxhsTLS = 1;
1191
    DO_TEST("disk-network-tlsx509", QEMU_CAPS_VXHS,
1192
            QEMU_CAPS_OBJECT_TLS_CREDS_X509, QEMU_CAPS_NBD_TLS);
1193
    DO_TEST_CAPS_VER("disk-network-tlsx509", "2.12.0");
1194
    DO_TEST_CAPS_LATEST("disk-network-tlsx509");
1195
    DO_TEST_CAPS_LATEST("disk-network-http");
1196 1197
    driver.config->vxhsTLS = 0;
    VIR_FREE(driver.config->vxhsTLSx509certdir);
1198
    DO_TEST("disk-no-boot", NONE);
1199
    DO_TEST_CAPS_LATEST("disk-nvme");
1200
    DO_TEST_PARSE_ERROR("disk-device-lun-type-invalid",
1201
                        QEMU_CAPS_VIRTIO_SCSI);
1202
    DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-attaching-partition-nosupport");
1203
    DO_TEST_FAILURE("disk-usb-nosupport", NONE);
1204
    DO_TEST("disk-usb-device",
1205
            QEMU_CAPS_DEVICE_USB_STORAGE);
1206
    DO_TEST("disk-usb-device-removable",
1207
            QEMU_CAPS_DEVICE_USB_STORAGE,
1208
            QEMU_CAPS_USB_STORAGE_REMOVABLE);
1209
    DO_TEST_FAILURE("disk-usb-pci",
1210
                    QEMU_CAPS_DEVICE_USB_STORAGE);
1211
    DO_TEST_CAPS_LATEST("disk-scsi");
1212 1213
    DO_TEST_CAPS_VER("disk-scsi-device-auto", "1.5.3");
    DO_TEST_CAPS_LATEST("disk-scsi-device-auto");
1214
    DO_TEST("disk-scsi-disk-split",
1215
            QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI);
1216
    DO_TEST("disk-scsi-disk-wwn",
1217
            QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
1218
    DO_TEST("disk-scsi-disk-vpd",
1219
            QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
1220
    DO_TEST_PARSE_ERROR("disk-scsi-disk-vpd-build-error",
1221
            QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
1222
    DO_TEST_CAPS_LATEST("controller-virtio-scsi");
1223
    DO_TEST("disk-sata-device",
1224
            QEMU_CAPS_ICH9_AHCI);
J
Ján Tomko 已提交
1225
    DO_TEST("disk-aio", NONE);
1226
    DO_TEST_CAPS_VER("disk-aio", "2.12.0");
1227
    DO_TEST_CAPS_LATEST("disk-aio");
H
Han Han 已提交
1228
    DO_TEST_CAPS_LATEST("disk-aio-io_uring");
1229 1230
    DO_TEST("disk-source-pool", NONE);
    DO_TEST("disk-source-pool-mode", NONE);
1231
    DO_TEST("disk-ioeventfd",
1232
            QEMU_CAPS_VIRTIO_IOEVENTFD,
1233
            QEMU_CAPS_VIRTIO_TX_ALG,
1234
            QEMU_CAPS_VIRTIO_BLK_SCSI);
1235
    DO_TEST("disk-copy_on_read",
1236
            QEMU_CAPS_VIRTIO_TX_ALG,
1237
            QEMU_CAPS_VIRTIO_BLK_SCSI);
1238
    DO_TEST_CAPS_VER("disk-copy_on_read", "2.12.0");
1239
    DO_TEST_CAPS_LATEST("disk-copy_on_read");
1240 1241
    DO_TEST_CAPS_VER("disk-discard", "4.1.0");
    DO_TEST_CAPS_LATEST("disk-discard");
1242
    DO_TEST_CAPS_VER("disk-detect-zeroes", "2.12.0");
1243
    DO_TEST_CAPS_LATEST("disk-detect-zeroes");
1244
    DO_TEST("disk-snapshot", NONE);
1245 1246
    DO_TEST_PARSE_ERROR("disk-same-targets",
                        QEMU_CAPS_SCSI_LSI,
1247
                        QEMU_CAPS_DEVICE_USB_STORAGE);
1248
    DO_TEST_PARSE_ERROR("disk-address-conflict",
1249 1250
                        QEMU_CAPS_ICH9_AHCI);
    DO_TEST_PARSE_ERROR("disk-hostdev-scsi-address-conflict",
1251
                        QEMU_CAPS_VIRTIO_SCSI);
1252
    DO_TEST_PARSE_ERROR("hostdevs-drive-address-conflict",
1253
                        QEMU_CAPS_VIRTIO_SCSI);
1254
    DO_TEST("event_idx",
1255 1256
            QEMU_CAPS_VIRTIO_BLK_EVENT_IDX,
            QEMU_CAPS_VIRTIO_NET_EVENT_IDX,
1257
            QEMU_CAPS_VIRTIO_BLK_SCSI);
1258
    DO_TEST("virtio-lun",
1259
            QEMU_CAPS_VIRTIO_BLK_SCSI);
1260
    DO_TEST("disk-scsi-lun-passthrough",
1261
            QEMU_CAPS_SCSI_BLOCK,
1262
            QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI);
1263
    DO_TEST("disk-serial",
1264
            QEMU_CAPS_KVM);
1265 1266 1267 1268 1269 1270 1271 1272
    DO_TEST_PARSE_ERROR("disk-fdc-incompatible-address",
                        NONE);
    DO_TEST_PARSE_ERROR("disk-ide-incompatible-address",
                        NONE);
    DO_TEST_PARSE_ERROR("disk-sata-incompatible-address",
                        QEMU_CAPS_ICH9_AHCI);
    DO_TEST_PARSE_ERROR("disk-scsi-incompatible-address",
                        QEMU_CAPS_VIRTIO_SCSI);
1273 1274 1275 1276
    DO_TEST_CAPS_VER("disk-backing-chains-index", "2.12.0");
    DO_TEST_CAPS_LATEST("disk-backing-chains-index");
    DO_TEST_CAPS_VER("disk-backing-chains-noindex", "2.12.0");
    DO_TEST_CAPS_LATEST("disk-backing-chains-noindex");
1277

1278 1279
    DO_TEST_CAPS_LATEST("disk-slices");

1280 1281 1282
    DO_TEST_CAPS_ARCH_VER("disk-arm-virtio-sd", "aarch64", "4.0.0");
    DO_TEST_CAPS_ARCH_LATEST("disk-arm-virtio-sd", "aarch64");

1283 1284 1285
    DO_TEST("graphics-egl-headless",
            QEMU_CAPS_EGL_HEADLESS,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
1286 1287
    DO_TEST_CAPS_LATEST("graphics-egl-headless");
    DO_TEST_CAPS_LATEST("graphics-egl-headless-rendernode");
1288

1289 1290
    DO_TEST("graphics-vnc", QEMU_CAPS_VNC, QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("graphics-vnc-socket", QEMU_CAPS_VNC, QEMU_CAPS_DEVICE_CIRRUS_VGA);
1291 1292
    DO_TEST("graphics-vnc-websocket",
            QEMU_CAPS_VNC,
1293
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
1294
    DO_TEST("graphics-vnc-policy", QEMU_CAPS_VNC,
1295 1296 1297 1298 1299
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("graphics-vnc-no-listen-attr", QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("graphics-vnc-remove-generated-socket", QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
1300
    driver.config->vncAutoUnixSocket = true;
1301 1302
    DO_TEST("graphics-vnc-auto-socket-cfg", QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
1303
    driver.config->vncAutoUnixSocket = false;
1304 1305 1306 1307
    DO_TEST("graphics-vnc-socket", QEMU_CAPS_VNC, QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("graphics-vnc-auto-socket", QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("graphics-vnc-none", QEMU_CAPS_VNC, QEMU_CAPS_DEVICE_CIRRUS_VGA);
1308 1309
    DO_TEST("graphics-vnc-socket-new-cmdline", QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA, QEMU_CAPS_VNC_MULTI_SERVERS);
1310

1311 1312
    driver.config->vncSASL = 1;
    VIR_FREE(driver.config->vncSASLdir);
1313
    driver.config->vncSASLdir = g_strdup("/root/.sasl2");
1314
    DO_TEST("graphics-vnc-sasl", QEMU_CAPS_VNC, QEMU_CAPS_DEVICE_CIRRUS_VGA);
1315 1316
    driver.config->vncTLS = 1;
    driver.config->vncTLSx509verify = 1;
1317
    DO_TEST("graphics-vnc-tls", QEMU_CAPS_VNC, QEMU_CAPS_DEVICE_CIRRUS_VGA);
1318 1319
    DO_TEST_CAPS_VER("graphics-vnc-tls", "2.4.0");
    DO_TEST_CAPS_LATEST("graphics-vnc-tls");
1320
    driver.config->vncTLSx509secretUUID = g_strdup("6fd3f62d-9fe7-4a4e-a869-7acd6376d8ea");
1321 1322
    DO_TEST_CAPS_LATEST("graphics-vnc-tls-secret");
    VIR_FREE(driver.config->vncTLSx509secretUUID);
1323
    driver.config->vncSASL = driver.config->vncTLSx509verify = driver.config->vncTLS = 0;
1324 1325
    VIR_FREE(driver.config->vncSASLdir);
    VIR_FREE(driver.config->vncTLSx509certdir);
1326 1327 1328 1329
    DO_TEST("graphics-vnc-egl-headless",
            QEMU_CAPS_VNC,
            QEMU_CAPS_EGL_HEADLESS,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
1330

J
Ján Tomko 已提交
1331 1332
    DO_TEST("graphics-sdl",
            QEMU_CAPS_DEVICE_VGA);
1333
    DO_TEST_CAPS_LATEST_PARSE_ERROR("graphics-sdl-egl-headless");
J
Ján Tomko 已提交
1334
    DO_TEST("graphics-sdl-fullscreen",
1335
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
1336
    DO_TEST("graphics-spice",
1337
            QEMU_CAPS_SPICE,
1338 1339
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_SPICE_FILE_XFER_DISABLE);
1340
    DO_TEST("graphics-spice-no-args",
1341
            QEMU_CAPS_SPICE, QEMU_CAPS_DEVICE_CIRRUS_VGA);
1342
    driver.config->spiceSASL = 1;
1343
    driver.config->spiceSASLdir = g_strdup("/root/.sasl2");
1344
    DO_TEST("graphics-spice-sasl",
1345
            QEMU_CAPS_SPICE,
1346 1347 1348
            QEMU_CAPS_DEVICE_QXL);
    VIR_FREE(driver.config->spiceSASLdir);
    driver.config->spiceSASL = 0;
1349
    DO_TEST("graphics-spice-agentmouse",
1350
            QEMU_CAPS_DEVICE_QXL,
1351
            QEMU_CAPS_SPICE,
1352
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
1353
    DO_TEST("graphics-spice-compression",
1354
            QEMU_CAPS_SPICE,
1355
            QEMU_CAPS_DEVICE_QXL);
1356
    DO_TEST("graphics-spice-timeout",
1357
            QEMU_CAPS_KVM,
1358
            QEMU_CAPS_SPICE,
1359 1360
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_DEVICE_VGA);
1361
    DO_TEST("graphics-spice-qxl-vga",
1362
            QEMU_CAPS_SPICE,
1363
            QEMU_CAPS_DEVICE_QXL);
1364
    DO_TEST("graphics-spice-usb-redir",
1365
            QEMU_CAPS_SPICE,
1366 1367 1368 1369
            QEMU_CAPS_USB_HUB,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_USB_REDIR,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
1370
    DO_TEST("graphics-spice-agent-file-xfer",
1371
            QEMU_CAPS_SPICE,
1372 1373
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_SPICE_FILE_XFER_DISABLE);
1374 1375
    DO_TEST("graphics-spice-socket",
            QEMU_CAPS_SPICE,
1376 1377
            QEMU_CAPS_SPICE_UNIX,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
1378 1379
    DO_TEST("graphics-spice-auto-socket",
            QEMU_CAPS_SPICE,
1380 1381
            QEMU_CAPS_SPICE_UNIX,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
1382 1383 1384
    driver.config->spiceAutoUnixSocket = true;
    DO_TEST("graphics-spice-auto-socket-cfg",
            QEMU_CAPS_SPICE,
1385 1386
            QEMU_CAPS_SPICE_UNIX,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
1387
    driver.config->spiceAutoUnixSocket = false;
1388 1389 1390 1391
    DO_TEST("graphics-spice-egl-headless",
            QEMU_CAPS_SPICE,
            QEMU_CAPS_EGL_HEADLESS,
            QEMU_CAPS_DEVICE_QXL);
1392
    DO_TEST_CAPS_LATEST_PARSE_ERROR("graphics-spice-invalid-egl-headless");
1393
    DO_TEST_CAPS_LATEST("graphics-spice-gl-auto-rendernode");
1394

1395 1396 1397
    DO_TEST("input-usbmouse", NONE);
    DO_TEST("input-usbtablet", NONE);
    DO_TEST("misc-acpi", NONE);
1398 1399 1400
    DO_TEST("misc-disable-s3", QEMU_CAPS_PIIX_DISABLE_S3);
    DO_TEST("misc-disable-suspends", QEMU_CAPS_PIIX_DISABLE_S3, QEMU_CAPS_PIIX_DISABLE_S4);
    DO_TEST("misc-enable-s4", QEMU_CAPS_PIIX_DISABLE_S4);
1401
    DO_TEST_PARSE_ERROR("misc-enable-s4", NONE);
1402
    DO_TEST("misc-no-reboot", NONE);
1403
    DO_TEST("misc-uuid", NONE);
1404
    DO_TEST_PARSE_ERROR("vhost_queues-invalid", NONE);
1405
    DO_TEST("net-vhostuser", QEMU_CAPS_CHARDEV_FD_PASS);
1406 1407
    DO_TEST_CAPS_VER("net-vhostuser", "2.5.0");
    DO_TEST_CAPS_LATEST("net-vhostuser");
1408
    DO_TEST("net-vhostuser-multiq",
J
Ján Tomko 已提交
1409 1410
            QEMU_CAPS_VHOSTUSER_MULTIQUEUE);
    DO_TEST_FAILURE("net-vhostuser-multiq", NONE);
1411 1412
    DO_TEST_FAILURE("net-vhostuser-fail",
                    QEMU_CAPS_VHOSTUSER_MULTIQUEUE);
1413
    DO_TEST("net-user", NONE);
1414
    DO_TEST_CAPS_ARCH_VER_FULL("net-user", "x86_64", "4.0.0", ARG_FLAGS, FLAG_SLIRP_HELPER);
J
Ján Tomko 已提交
1415
    DO_TEST("net-user-addr", NONE);
1416 1417
    DO_TEST("net-virtio", NONE);
    DO_TEST("net-virtio-device",
1418 1419 1420
            QEMU_CAPS_VIRTIO_TX_ALG);
    DO_TEST("net-virtio-disable-offloads", NONE);
    DO_TEST("net-virtio-netdev", NONE);
1421
    DO_TEST("net-virtio-s390",
1422
            QEMU_CAPS_VIRTIO_S390);
1423
    DO_TEST("net-virtio-ccw",
1424
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
1425 1426 1427
    DO_TEST("net-virtio-rxtxqueuesize",
            QEMU_CAPS_VIRTIO_NET_RX_QUEUE_SIZE,
            QEMU_CAPS_VIRTIO_NET_TX_QUEUE_SIZE);
1428
    DO_TEST_PARSE_ERROR("net-virtio-rxqueuesize-invalid-size", NONE);
1429 1430 1431 1432
    DO_TEST("net-virtio-teaming",
            QEMU_CAPS_VIRTIO_NET_FAILOVER,
            QEMU_CAPS_DEVICE_VFIO_PCI);
    DO_TEST_PARSE_ERROR("net-virtio-teaming", NONE);
1433 1434
    DO_TEST("net-eth", NONE);
    DO_TEST("net-eth-ifname", NONE);
1435
    DO_TEST("net-eth-names", NONE);
1436
    DO_TEST("net-eth-hostip", NONE);
1437
    DO_TEST("net-eth-unmanaged-tap", NONE);
1438 1439
    DO_TEST("net-client", NONE);
    DO_TEST("net-server", NONE);
1440
    DO_TEST("net-many-models", NONE);
1441
    DO_TEST("net-mcast", NONE);
1442
    DO_TEST("net-udp", NONE);
1443 1444 1445
    DO_TEST("net-hostdev", QEMU_CAPS_DEVICE_VFIO_PCI);
    DO_TEST("net-hostdev-bootorder", QEMU_CAPS_DEVICE_VFIO_PCI);
    DO_TEST("net-hostdev-multidomain", QEMU_CAPS_DEVICE_VFIO_PCI);
1446 1447
    DO_TEST("net-hostdev-vfio",
            QEMU_CAPS_DEVICE_VFIO_PCI);
1448
    DO_TEST("net-hostdev-vfio-multidomain",
1449
            QEMU_CAPS_DEVICE_VFIO_PCI);
1450 1451 1452
    DO_TEST_FAILURE("net-hostdev-fail",
                    QEMU_CAPS_DEVICE_VFIO_PCI);

1453 1454 1455
    DO_TEST("hostdev-pci-multifunction",
            QEMU_CAPS_KVM,
            QEMU_CAPS_DEVICE_VFIO_PCI);
1456

1457 1458 1459 1460
    DO_TEST("hostdev-pci-address-unassigned",
            QEMU_CAPS_KVM,
            QEMU_CAPS_DEVICE_VFIO_PCI);

1461 1462
    DO_TEST("serial-file-log",
            QEMU_CAPS_CHARDEV_FILE_APPEND,
1463
            QEMU_CAPS_DEVICE_ISA_SERIAL,
1464
            QEMU_CAPS_CHARDEV_LOGFILE);
1465
    DO_TEST("serial-spiceport",
1466
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
1467
            QEMU_CAPS_DEVICE_QXL,
1468
            QEMU_CAPS_SPICE,
1469
            QEMU_CAPS_DEVICE_ISA_SERIAL);
1470
    DO_TEST("serial-spiceport-nospice", NONE);
1471

1472 1473 1474 1475
    DO_TEST("console-compat",
            QEMU_CAPS_DEVICE_ISA_SERIAL);
    DO_TEST("console-compat-auto",
            QEMU_CAPS_DEVICE_ISA_SERIAL);
1476 1477

    DO_TEST("serial-vc-chardev",
1478
            QEMU_CAPS_DEVICE_ISA_SERIAL);
1479
    DO_TEST("serial-pty-chardev",
1480
            QEMU_CAPS_DEVICE_ISA_SERIAL);
1481
    DO_TEST("serial-dev-chardev",
1482
            QEMU_CAPS_DEVICE_ISA_SERIAL);
1483
    DO_TEST("serial-dev-chardev-iobase",
1484
            QEMU_CAPS_DEVICE_ISA_SERIAL);
1485
    DO_TEST("serial-file-chardev",
1486
            QEMU_CAPS_DEVICE_ISA_SERIAL,
1487
            QEMU_CAPS_CHARDEV_FILE_APPEND);
1488
    DO_TEST("serial-unix-chardev",
1489
            QEMU_CAPS_DEVICE_ISA_SERIAL);
1490
    DO_TEST_CAPS_LATEST("serial-unix-chardev");
1491
    DO_TEST_PARSE_ERROR("serial-unix-missing-source", NONE);
1492
    DO_TEST("serial-tcp-chardev",
1493
            QEMU_CAPS_DEVICE_ISA_SERIAL);
1494
    DO_TEST("serial-udp-chardev",
1495
            QEMU_CAPS_DEVICE_ISA_SERIAL);
1496
    DO_TEST("serial-tcp-telnet-chardev",
1497
            QEMU_CAPS_DEVICE_ISA_SERIAL);
1498 1499
    driver.config->chardevTLS = 1;
    DO_TEST("serial-tcp-tlsx509-chardev",
1500
            QEMU_CAPS_DEVICE_ISA_SERIAL,
1501
            QEMU_CAPS_OBJECT_TLS_CREDS_X509);
1502 1503
    driver.config->chardevTLSx509verify = 1;
    DO_TEST("serial-tcp-tlsx509-chardev-verify",
1504
            QEMU_CAPS_DEVICE_ISA_SERIAL,
1505 1506
            QEMU_CAPS_OBJECT_TLS_CREDS_X509);
    driver.config->chardevTLSx509verify = 0;
1507
    DO_TEST("serial-tcp-tlsx509-chardev-notls",
1508
            QEMU_CAPS_DEVICE_ISA_SERIAL,
1509
            QEMU_CAPS_OBJECT_TLS_CREDS_X509);
1510
    VIR_FREE(driver.config->chardevTLSx509certdir);
1511 1512
    driver.config->chardevTLSx509certdir = g_strdup("/etc/pki/libvirt-chardev");
    driver.config->chardevTLSx509secretUUID = g_strdup("6fd3f62d-9fe7-4a4e-a869-7acd6376d8ea");
1513 1514
    DO_TEST("serial-tcp-tlsx509-secret-chardev",
            QEMU_CAPS_OBJECT_SECRET,
1515
            QEMU_CAPS_DEVICE_ISA_SERIAL,
1516
            QEMU_CAPS_OBJECT_TLS_CREDS_X509);
1517 1518
    driver.config->chardevTLS = 0;
    VIR_FREE(driver.config->chardevTLSx509certdir);
1519
    DO_TEST("serial-many-chardev",
1520 1521 1522
            QEMU_CAPS_DEVICE_ISA_SERIAL);
    DO_TEST("parallel-tcp-chardev", NONE);
    DO_TEST("parallel-parport-chardev", NONE);
J
Ján Tomko 已提交
1523 1524
    DO_TEST_CAPS_VER("parallel-unix-chardev", "2.5.0");
    DO_TEST_CAPS_LATEST("parallel-unix-chardev");
1525
    DO_TEST("console-compat-chardev",
1526
            QEMU_CAPS_DEVICE_ISA_SERIAL);
M
Michal Privoznik 已提交
1527 1528
    DO_TEST("pci-serial-dev-chardev",
            QEMU_CAPS_DEVICE_PCI_SERIAL);
1529

1530
    DO_TEST("channel-guestfwd", NONE);
J
Ján Tomko 已提交
1531 1532
    DO_TEST_CAPS_VER("channel-unix-guestfwd", "2.5.0");
    DO_TEST_CAPS_LATEST("channel-unix-guestfwd");
1533 1534 1535 1536 1537 1538
    DO_TEST("channel-virtio", NONE);
    DO_TEST("channel-virtio-state", NONE);
    DO_TEST("channel-virtio-auto", NONE);
    DO_TEST("channel-virtio-autoassign", NONE);
    DO_TEST("channel-virtio-autoadd", NONE);
    DO_TEST("console-virtio", NONE);
1539
    DO_TEST("console-virtio-many",
1540
            QEMU_CAPS_DEVICE_ISA_SERIAL);
1541
    DO_TEST("console-virtio-s390",
1542
            QEMU_CAPS_VIRTIO_S390);
1543
    DO_TEST("console-virtio-ccw",
1544
            QEMU_CAPS_CCW,
1545
            QEMU_CAPS_VIRTIO_S390);
J
Ján Tomko 已提交
1546 1547
    DO_TEST_CAPS_VER("console-virtio-unix", "2.5.0");
    DO_TEST_CAPS_LATEST("console-virtio-unix");
1548
    DO_TEST("console-sclp",
1549
            QEMU_CAPS_VIRTIO_S390,
1550
            QEMU_CAPS_DEVICE_SCLPCONSOLE);
1551
    DO_TEST("channel-spicevmc",
1552
            QEMU_CAPS_SPICE,
1553
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
1554
    DO_TEST("channel-virtio-default",
1555
            QEMU_CAPS_SPICE);
1556
    DO_TEST("channel-virtio-unix", NONE);
1557

1558
    DO_TEST("smartcard-host",
1559
            QEMU_CAPS_CCID_EMULATED);
1560
    DO_TEST("smartcard-host-certificates",
1561
            QEMU_CAPS_CCID_EMULATED);
1562 1563
    DO_TEST("smartcard-host-certificates-database",
            QEMU_CAPS_CCID_EMULATED);
1564
    DO_TEST("smartcard-passthrough-tcp",
1565
            QEMU_CAPS_CCID_PASSTHRU);
1566
    DO_TEST("smartcard-passthrough-spicevmc",
1567
            QEMU_CAPS_CCID_PASSTHRU);
1568
    DO_TEST("smartcard-controller",
1569
            QEMU_CAPS_CCID_EMULATED);
J
Ján Tomko 已提交
1570 1571
    DO_TEST_CAPS_VER("smartcard-passthrough-unix", "2.5.0");
    DO_TEST_CAPS_LATEST("smartcard-passthrough-unix");
1572

1573 1574 1575 1576 1577 1578 1579 1580
    DO_TEST("chardev-reconnect",
            QEMU_CAPS_CHARDEV_RECONNECT,
            QEMU_CAPS_USB_REDIR,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_EGD,
            QEMU_CAPS_CCID_PASSTHRU);
    DO_TEST_PARSE_ERROR("chardev-reconnect-invalid-timeout",
                        QEMU_CAPS_CHARDEV_RECONNECT);
1581 1582
    DO_TEST_PARSE_ERROR("chardev-reconnect-generated-path",
                        QEMU_CAPS_CHARDEV_RECONNECT);
1583

1584
    DO_TEST("usb-controller", NONE);
1585
    DO_TEST("usb-piix3-controller",
1586
            QEMU_CAPS_PIIX3_USB_UHCI);
1587
    DO_TEST("usb-ich9-ehci-addr",
1588
            QEMU_CAPS_ICH9_USB_EHCI1);
1589
    DO_TEST("input-usbmouse-addr", NONE);
1590
    DO_TEST("usb-ich9-companion",
1591
            QEMU_CAPS_ICH9_USB_EHCI1);
1592
    DO_TEST_PARSE_ERROR("usb-ich9-no-companion",
1593
            QEMU_CAPS_ICH9_USB_EHCI1);
1594
    DO_TEST("usb-ich9-autoassign",
1595
            QEMU_CAPS_ICH9_USB_EHCI1,
1596
            QEMU_CAPS_USB_HUB);
1597
    DO_TEST("usb-hub",
1598
            QEMU_CAPS_USB_HUB);
1599
    DO_TEST("usb-hub-autoadd",
1600
            QEMU_CAPS_USB_HUB);
1601
    DO_TEST("usb-hub-autoadd-deluxe",
1602
            QEMU_CAPS_USB_HUB);
J
Ján Tomko 已提交
1603
    DO_TEST_PARSE_ERROR("usb-hub-conflict",
1604
            QEMU_CAPS_USB_HUB);
1605
    DO_TEST_PARSE_ERROR("usb-hub-nonexistent",
1606
            QEMU_CAPS_USB_HUB);
J
Ján Tomko 已提交
1607
    DO_TEST("usb-port-missing",
1608
            QEMU_CAPS_USB_HUB);
1609
    DO_TEST_FAILURE("usb-bus-missing",
1610
                    QEMU_CAPS_USB_HUB);
1611
    DO_TEST("usb-ports",
1612
            QEMU_CAPS_USB_HUB);
1613
    DO_TEST_PARSE_ERROR("usb-ports-out-of-range",
1614
            QEMU_CAPS_USB_HUB);
1615
    DO_TEST("usb-port-autoassign",
1616
            QEMU_CAPS_USB_HUB);
1617
    DO_TEST("usb-redir",
1618 1619 1620
            QEMU_CAPS_USB_HUB,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_USB_REDIR,
1621
            QEMU_CAPS_SPICE);
1622
    DO_TEST("usb-redir-boot",
1623 1624 1625
            QEMU_CAPS_USB_HUB,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_USB_REDIR,
1626
            QEMU_CAPS_SPICE);
1627
    DO_TEST("usb-redir-filter",
1628 1629 1630 1631
            QEMU_CAPS_USB_HUB,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_USB_REDIR,
            QEMU_CAPS_SPICE,
1632
            QEMU_CAPS_USB_REDIR_FILTER);
1633 1634
    DO_TEST("usb-redir-filter-version",
            QEMU_CAPS_USB_REDIR,
1635
            QEMU_CAPS_SPICE,
1636
            QEMU_CAPS_USB_REDIR_FILTER);
J
Ján Tomko 已提交
1637 1638
    DO_TEST_CAPS_VER("usb-redir-unix", "2.5.0");
    DO_TEST_CAPS_LATEST("usb-redir-unix");
1639
    DO_TEST("usb1-usb2",
1640 1641 1642
            QEMU_CAPS_PIIX3_USB_UHCI,
            QEMU_CAPS_USB_HUB,
            QEMU_CAPS_ICH9_USB_EHCI1);
1643 1644
    DO_TEST("usb-none", NONE);
    DO_TEST_PARSE_ERROR("usb-none-other", NONE);
1645 1646
    DO_TEST_PARSE_ERROR("usb-none-hub",
            QEMU_CAPS_USB_HUB);
1647
    DO_TEST_PARSE_ERROR("usb-none-usbtablet", NONE);
1648
    DO_TEST("usb-controller-default-q35",
1649
            QEMU_CAPS_DEVICE_IOH3420,
1650 1651 1652
            QEMU_CAPS_PCI_OHCI,
            QEMU_CAPS_PIIX3_USB_UHCI,
            QEMU_CAPS_NEC_USB_XHCI);
1653
    DO_TEST_FAILURE("usb-controller-default-unavailable-q35",
1654
                    QEMU_CAPS_DEVICE_IOH3420,
1655
                    QEMU_CAPS_PCI_OHCI,
1656 1657
                    QEMU_CAPS_NEC_USB_XHCI);
    DO_TEST("usb-controller-explicit-q35",
1658
            QEMU_CAPS_DEVICE_IOH3420,
1659 1660 1661
            QEMU_CAPS_PCI_OHCI,
            QEMU_CAPS_PIIX3_USB_UHCI,
            QEMU_CAPS_NEC_USB_XHCI);
1662
    DO_TEST_FAILURE("usb-controller-explicit-unavailable-q35",
1663
                    QEMU_CAPS_DEVICE_IOH3420,
1664
                    QEMU_CAPS_PCI_OHCI,
1665
                    QEMU_CAPS_PIIX3_USB_UHCI);
1666
    DO_TEST("usb-controller-xhci",
1667 1668 1669
            QEMU_CAPS_PIIX3_USB_UHCI,
            QEMU_CAPS_NEC_USB_XHCI,
            QEMU_CAPS_NEC_USB_XHCI_PORTS);
1670
    DO_TEST("usb-xhci-autoassign",
1671 1672 1673
            QEMU_CAPS_PIIX3_USB_UHCI,
            QEMU_CAPS_NEC_USB_XHCI,
            QEMU_CAPS_NEC_USB_XHCI_PORTS,
1674
            QEMU_CAPS_USB_HUB);
1675
    DO_TEST_PARSE_ERROR("usb-controller-xhci-limit",
1676 1677 1678
            QEMU_CAPS_PIIX3_USB_UHCI,
            QEMU_CAPS_NEC_USB_XHCI,
            QEMU_CAPS_NEC_USB_XHCI_PORTS);
1679 1680 1681 1682
    DO_TEST("usb-controller-qemu-xhci", QEMU_CAPS_DEVICE_QEMU_XHCI);
    DO_TEST_FAILURE("usb-controller-qemu-xhci-unavailable", NONE);
    DO_TEST_PARSE_ERROR("usb-controller-qemu-xhci-limit",
                        QEMU_CAPS_DEVICE_QEMU_XHCI);
1683

1684 1685 1686
    DO_TEST("smbios", NONE);
    DO_TEST_PARSE_ERROR("smbios-date", NONE);
    DO_TEST_PARSE_ERROR("smbios-uuid-match", NONE);
1687
    DO_TEST("smbios-type-fwcfg", QEMU_CAPS_FW_CFG);
1688

1689
    DO_TEST("watchdog", NONE);
1690
    DO_TEST("watchdog-device", NONE);
1691
    DO_TEST("watchdog-dump", NONE);
1692
    DO_TEST("watchdog-injectnmi", NONE);
1693
    DO_TEST("watchdog-diag288", QEMU_CAPS_VIRTIO_S390);
1694 1695
    DO_TEST("balloon-device", NONE);
    DO_TEST("balloon-device-deflate",
1696
            QEMU_CAPS_VIRTIO_BALLOON_AUTODEFLATE);
1697
    DO_TEST("balloon-ccw-deflate",
1698
            QEMU_CAPS_VIRTIO_BALLOON_AUTODEFLATE);
1699
    DO_TEST("balloon-mmio-deflate",
J
Ján Tomko 已提交
1700
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
1701
            QEMU_CAPS_VIRTIO_BALLOON_AUTODEFLATE);
1702
    DO_TEST("balloon-device-deflate-off",
1703
            QEMU_CAPS_VIRTIO_BALLOON_AUTODEFLATE);
1704 1705
    DO_TEST("balloon-device-auto", NONE);
    DO_TEST("balloon-device-period", NONE);
1706 1707
    DO_TEST("sound", NONE);
    DO_TEST("sound-device",
1708
            QEMU_CAPS_HDA_DUPLEX, QEMU_CAPS_HDA_MICRO,
1709
            QEMU_CAPS_HDA_OUTPUT,
1710 1711
            QEMU_CAPS_DEVICE_ICH9_INTEL_HDA,
            QEMU_CAPS_OBJECT_USB_AUDIO);
1712
    DO_TEST("fs9p", NONE);
1713
    DO_TEST_CAPS_LATEST("fs9p");
1714
    DO_TEST("fs9p-ccw",
1715
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
1716
    DO_TEST_CAPS_ARCH_LATEST("fs9p-ccw", "s390x");
1717

1718
    DO_TEST("hostdev-usb-address", NONE);
1719
    DO_TEST("hostdev-usb-address-device", NONE);
1720
    DO_TEST("hostdev-usb-address-device-boot", NONE);
1721 1722
    DO_TEST("hostdev-pci-address", QEMU_CAPS_DEVICE_VFIO_PCI);
    DO_TEST("hostdev-pci-address-device", QEMU_CAPS_DEVICE_VFIO_PCI);
1723 1724
    DO_TEST("hostdev-vfio",
            QEMU_CAPS_DEVICE_VFIO_PCI);
1725
    DO_TEST("hostdev-vfio-multidomain",
1726
            QEMU_CAPS_DEVICE_VFIO_PCI);
1727 1728 1729 1730 1731 1732
    DO_TEST("hostdev-mdev-precreated",
            QEMU_CAPS_DEVICE_VFIO_PCI);
    DO_TEST_PARSE_ERROR("hostdev-mdev-src-address-invalid",
            QEMU_CAPS_DEVICE_VFIO_PCI);
    DO_TEST_PARSE_ERROR("hostdev-mdev-invalid-target-address",
            QEMU_CAPS_DEVICE_VFIO_PCI);
1733 1734 1735 1736 1737 1738 1739
    DO_TEST_CAPS_LATEST("hostdev-mdev-display-spice-opengl");
    DO_TEST_CAPS_LATEST("hostdev-mdev-display-spice-egl-headless");
    DO_TEST_CAPS_LATEST("hostdev-mdev-display-vnc");
    DO_TEST_CAPS_LATEST("hostdev-mdev-display-vnc-egl-headless");
    DO_TEST_PARSE_ERROR("hostdev-mdev-display-missing-graphics",
            QEMU_CAPS_DEVICE_VFIO_PCI,
            QEMU_CAPS_VFIO_PCI_DISPLAY);
1740
    DO_TEST_CAPS_LATEST("hostdev-mdev-display-ramfb");
1741 1742
    DO_TEST_PARSE_ERROR("hostdev-vfio-zpci-wrong-arch",
                        QEMU_CAPS_DEVICE_VFIO_PCI);
1743 1744 1745
    DO_TEST("hostdev-vfio-zpci",
            QEMU_CAPS_DEVICE_VFIO_PCI,
            QEMU_CAPS_DEVICE_ZPCI);
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758
    DO_TEST("hostdev-vfio-zpci-multidomain-many",
            QEMU_CAPS_DEVICE_VFIO_PCI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_ZPCI);
    DO_TEST("hostdev-vfio-zpci-autogenerate",
            QEMU_CAPS_DEVICE_VFIO_PCI,
            QEMU_CAPS_DEVICE_ZPCI);
    DO_TEST("hostdev-vfio-zpci-boundaries",
            QEMU_CAPS_DEVICE_VFIO_PCI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_ZPCI);
    DO_TEST_PARSE_ERROR("hostdev-vfio-zpci",
                        QEMU_CAPS_DEVICE_VFIO_PCI);
1759
    DO_TEST("pci-rom", QEMU_CAPS_DEVICE_VFIO_PCI);
1760
    DO_TEST("pci-rom-disabled", NONE);
1761
    DO_TEST("pci-rom-disabled-invalid", NONE);
1762

1763 1764 1765 1766
    DO_TEST("hostdev-subsys-mdev-vfio-ccw",
            QEMU_CAPS_CCW,
            QEMU_CAPS_CCW_CSSID_UNRESTRICTED,
            QEMU_CAPS_DEVICE_VFIO_CCW);
1767 1768
    DO_TEST_CAPS_ARCH_LATEST("hostdev-subsys-mdev-vfio-ccw-boot",
                             "s390x");
1769 1770 1771
    DO_TEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ccw",
                        QEMU_CAPS_CCW,
                        QEMU_CAPS_CCW_CSSID_UNRESTRICTED);
1772 1773 1774 1775 1776 1777 1778 1779 1780
    DO_TEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ccw-duplicate-address",
            QEMU_CAPS_CCW,
            QEMU_CAPS_CCW_CSSID_UNRESTRICTED,
            QEMU_CAPS_DEVICE_VFIO_CCW);
    DO_TEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ccw-invalid-address",
            QEMU_CAPS_CCW,
            QEMU_CAPS_CCW_CSSID_UNRESTRICTED,
            QEMU_CAPS_DEVICE_VFIO_CCW);

B
Boris Fiuczynski 已提交
1781 1782
    DO_TEST_CAPS_ARCH_LATEST("hostdev-subsys-mdev-vfio-ap",
                             "s390x");
1783 1784
    DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ap-boot-fail",
                                         "s390x");
B
Boris Fiuczynski 已提交
1785

1786
    DO_TEST_FULL("restore-v2",
1787 1788
                 ARG_MIGRATE_FROM, "exec:cat",
                 ARG_MIGRATE_FD, 7,
1789
                 ARG_QEMU_CAPS, NONE);
1790
    DO_TEST_FULL("restore-v2-fd",
1791 1792
                 ARG_MIGRATE_FROM, "stdio",
                 ARG_MIGRATE_FD, 7,
1793
                 ARG_QEMU_CAPS, NONE);
1794
    DO_TEST_FULL("restore-v2-fd",
1795 1796
                 ARG_MIGRATE_FROM, "fd:7",
                 ARG_MIGRATE_FD, 7,
1797
                 ARG_QEMU_CAPS, NONE);
1798
    DO_TEST_FULL("migrate",
1799
                 ARG_MIGRATE_FROM, "tcp:10.0.0.1:5000",
1800
                 ARG_QEMU_CAPS, NONE);
1801

1802
    DO_TEST_FULL("migrate-numa-unaligned",
1803 1804
                 ARG_MIGRATE_FROM, "stdio",
                 ARG_MIGRATE_FD, 7,
1805
                 ARG_QEMU_CAPS,
A
Andrea Bolognani 已提交
1806 1807
                 QEMU_CAPS_NUMA,
                 QEMU_CAPS_OBJECT_MEMORY_RAM);
1808

1809 1810
    DO_TEST_CAPS_VER("qemu-ns", "4.0.0");
    DO_TEST_CAPS_LATEST("qemu-ns");
1811
    DO_TEST("qemu-ns-no-env", NONE);
1812
    DO_TEST("qemu-ns-alt", NONE);
1813

1814
    DO_TEST("smp", NONE);
1815
    DO_TEST("smp-dies", QEMU_CAPS_SMP_DIES);
1816

J
John Ferlan 已提交
1817
    DO_TEST("iothreads", QEMU_CAPS_OBJECT_IOTHREAD);
1818 1819
    DO_TEST("iothreads-ids", QEMU_CAPS_OBJECT_IOTHREAD);
    DO_TEST("iothreads-ids-partial", QEMU_CAPS_OBJECT_IOTHREAD);
1820
    DO_TEST_FAILURE("iothreads-nocap", NONE);
1821 1822
    DO_TEST("iothreads-disk", QEMU_CAPS_OBJECT_IOTHREAD);
    DO_TEST("iothreads-disk-virtio-ccw", QEMU_CAPS_OBJECT_IOTHREAD,
1823
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
1824 1825
    DO_TEST_CAPS_LATEST("iothreads-virtio-scsi-pci");
    DO_TEST_CAPS_ARCH_LATEST("iothreads-virtio-scsi-ccw", "s390x");
J
John Ferlan 已提交
1826

1827 1828
    DO_TEST("cpu-topology1", NONE);
    DO_TEST("cpu-topology2", NONE);
1829
    DO_TEST("cpu-topology3", NONE);
1830 1831 1832 1833 1834 1835 1836 1837
    DO_TEST("cpu-minimum1", QEMU_CAPS_KVM);
    DO_TEST("cpu-minimum2", QEMU_CAPS_KVM);
    DO_TEST("cpu-exact1", QEMU_CAPS_KVM);
    DO_TEST("cpu-exact2", QEMU_CAPS_KVM);
    DO_TEST("cpu-exact2-nofallback", QEMU_CAPS_KVM);
    DO_TEST("cpu-fallback", QEMU_CAPS_KVM);
    DO_TEST_FAILURE("cpu-nofallback", QEMU_CAPS_KVM);
    DO_TEST("cpu-strict1", QEMU_CAPS_KVM);
1838
    DO_TEST("cpu-no-removed-features", QEMU_CAPS_KVM);
1839
    DO_TEST("cpu-numa1", NONE);
1840 1841
    DO_TEST("cpu-numa2", NONE);
    DO_TEST("cpu-numa-no-memory-element", NONE);
1842
    DO_TEST_PARSE_ERROR("cpu-numa3", NONE);
1843
    DO_TEST_PARSE_ERROR("cpu-numa-disjoint", NONE);
1844
    DO_TEST("cpu-numa-disjoint", QEMU_CAPS_NUMA);
1845
    DO_TEST_FAILURE("cpu-numa-memshared", QEMU_CAPS_OBJECT_MEMORY_RAM);
1846
    DO_TEST_PARSE_ERROR("cpu-numa-memshared", NONE);
1847
    DO_TEST("cpu-numa-memshared", QEMU_CAPS_OBJECT_MEMORY_FILE);
1848
    DO_TEST("cpu-host-model", NONE);
1849
    DO_TEST("cpu-host-model-vendor", NONE);
1850
    DO_TEST_FULL("cpu-host-model-fallback",
1851
                 ARG_FLAGS, FLAG_SKIP_LEGACY_CPUS,
1852
                 ARG_QEMU_CAPS, NONE);
1853
    DO_TEST_FULL("cpu-host-model-nofallback",
1854
                 ARG_FLAGS, FLAG_SKIP_LEGACY_CPUS | FLAG_EXPECT_FAILURE,
1855
                 ARG_QEMU_CAPS, NONE);
A
Andrea Bolognani 已提交
1856 1857
    DO_TEST("cpu-host-passthrough", QEMU_CAPS_KVM);
    DO_TEST_FAILURE("cpu-qemu-host-passthrough", QEMU_CAPS_KVM);
1858

1859
    qemuTestSetHostArch(&driver, VIR_ARCH_S390X);
1860
    DO_TEST("cpu-s390-zEC12", QEMU_CAPS_KVM, QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
1861 1862
    DO_TEST("cpu-s390-features", QEMU_CAPS_KVM, QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION);
    DO_TEST_FAILURE("cpu-s390-features", QEMU_CAPS_KVM);
1863
    qemuTestSetHostArch(&driver, VIR_ARCH_NONE);
1864

1865
    qemuTestSetHostCPU(&driver, driver.hostarch, cpuHaswell);
1866 1867 1868 1869
    DO_TEST("cpu-Haswell", QEMU_CAPS_KVM);
    DO_TEST("cpu-Haswell2", QEMU_CAPS_KVM);
    DO_TEST("cpu-Haswell3", QEMU_CAPS_KVM);
    DO_TEST("cpu-Haswell-noTSX", QEMU_CAPS_KVM);
1870
    DO_TEST("cpu-host-model-cmt", NONE);
1871
    DO_TEST_CAPS_VER("cpu-host-model-cmt", "4.0.0");
1872
    DO_TEST("cpu-tsc-frequency", QEMU_CAPS_KVM);
1873
    DO_TEST_CAPS_VER("cpu-tsc-frequency", "4.0.0");
1874 1875
    DO_TEST_CAPS_VER("cpu-translation", "4.0.0");
    DO_TEST_CAPS_LATEST("cpu-translation");
1876
    qemuTestSetHostCPU(&driver, driver.hostarch, NULL);
1877

1878 1879
    DO_TEST("encrypted-disk", QEMU_CAPS_QCOW2_LUKS, QEMU_CAPS_OBJECT_SECRET);
    DO_TEST("encrypted-disk-usage", QEMU_CAPS_QCOW2_LUKS, QEMU_CAPS_OBJECT_SECRET);
1880
    DO_TEST("luks-disks", QEMU_CAPS_OBJECT_SECRET);
1881
    DO_TEST("luks-disks-source", QEMU_CAPS_OBJECT_SECRET);
1882 1883
    DO_TEST_PARSE_ERROR("luks-disks-source-qcow2", QEMU_CAPS_OBJECT_SECRET);
    DO_TEST("luks-disks-source-qcow2", QEMU_CAPS_OBJECT_SECRET, QEMU_CAPS_QCOW2_LUKS);
1884
    DO_TEST_CAPS_LATEST("luks-disks-source-qcow2");
1885
    DO_TEST_PARSE_ERROR("luks-disk-invalid", NONE);
1886
    DO_TEST_PARSE_ERROR("luks-disks-source-both", QEMU_CAPS_OBJECT_SECRET);
1887

1888 1889 1890 1891 1892 1893 1894 1895
    DO_TEST("memtune", NONE);
    DO_TEST("memtune-unlimited", NONE);
    DO_TEST("blkiotune", NONE);
    DO_TEST("blkiotune-device", NONE);
    DO_TEST("cputune", NONE);
    DO_TEST("cputune-zero-shares", NONE);
    DO_TEST_PARSE_ERROR("cputune-iothreadsched-toomuch", NONE);
    DO_TEST_PARSE_ERROR("cputune-vcpusched-overlap", NONE);
1896
    DO_TEST("cputune-numatune",
1897
            QEMU_CAPS_KVM,
1898
            QEMU_CAPS_OBJECT_IOTHREAD,
1899 1900
            QEMU_CAPS_OBJECT_MEMORY_RAM,
            QEMU_CAPS_OBJECT_MEMORY_FILE);
1901 1902 1903
    DO_TEST("vcpu-placement-static",
            QEMU_CAPS_KVM,
            QEMU_CAPS_OBJECT_IOTHREAD);
1904
    DO_TEST_CAPS_LATEST("cputune-cpuset-big-id");
1905

1906
    DO_TEST("numatune-memory", NONE);
1907
    DO_TEST_PARSE_ERROR("numatune-memory-invalid-nodeset", NONE);
A
Andrea Bolognani 已提交
1908 1909 1910
    DO_TEST("numatune-memnode",
            QEMU_CAPS_NUMA,
            QEMU_CAPS_OBJECT_MEMORY_RAM);
1911
    DO_TEST_PARSE_ERROR("numatune-memnode", NONE);
1912

A
Andrea Bolognani 已提交
1913 1914 1915
    DO_TEST("numatune-memnode-no-memory",
            QEMU_CAPS_NUMA,
            QEMU_CAPS_OBJECT_MEMORY_RAM);
1916
    DO_TEST_PARSE_ERROR("numatune-memnode-no-memory", NONE);
1917

1918 1919
    DO_TEST("numatune-distances", QEMU_CAPS_NUMA, QEMU_CAPS_NUMA_DIST);

1920
    DO_TEST("numatune-auto-nodeset-invalid", NONE);
1921 1922
    DO_TEST("numatune-auto-prefer", QEMU_CAPS_OBJECT_MEMORY_RAM,
            QEMU_CAPS_OBJECT_MEMORY_FILE);
1923 1924
    DO_TEST_FAILURE("numatune-static-nodeset-exceed-hostnode",
                    QEMU_CAPS_OBJECT_MEMORY_RAM);
1925 1926
    DO_TEST_PARSE_ERROR("numatune-memnode-nocpu", NONE);
    DO_TEST_PARSE_ERROR("numatune-memnodes-problematic", NONE);
1927 1928
    DO_TEST("numad", NONE);
    DO_TEST("numad-auto-vcpu-static-numatune", NONE);
1929
    DO_TEST_PARSE_ERROR("numad-auto-vcpu-static-numatune-no-nodeset", NONE);
1930 1931 1932
    DO_TEST("numad-auto-memory-vcpu-cpuset", NONE);
    DO_TEST("numad-auto-memory-vcpu-no-cpuset-and-placement", NONE);
    DO_TEST("numad-static-memory-auto-vcpu", NONE);
1933 1934 1935 1936 1937 1938
    DO_TEST_CAPS_VER("blkdeviotune-max", "4.1.0");
    DO_TEST_CAPS_LATEST("blkdeviotune-max");
    DO_TEST_CAPS_VER("blkdeviotune-group-num", "4.1.0");
    DO_TEST_CAPS_LATEST("blkdeviotune-group-num");
    DO_TEST_CAPS_VER("blkdeviotune-max-length", "4.1.0");
    DO_TEST_CAPS_LATEST("blkdeviotune-max-length");
1939

1940
    DO_TEST("multifunction-pci-device",
1941
            QEMU_CAPS_SCSI_LSI);
1942

1943
    DO_TEST("monitor-json", NONE);
1944

1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956
    DO_TEST("seclabel-dynamic", NONE);
    DO_TEST("seclabel-dynamic-baselabel", NONE);
    DO_TEST("seclabel-dynamic-override", NONE);
    DO_TEST("seclabel-dynamic-labelskip", NONE);
    DO_TEST("seclabel-dynamic-relabel", NONE);
    DO_TEST("seclabel-static", NONE);
    DO_TEST("seclabel-static-relabel", NONE);
    DO_TEST("seclabel-static-labelskip", NONE);
    DO_TEST("seclabel-none", NONE);
    DO_TEST("seclabel-dac-none", NONE);
    DO_TEST_PARSE_ERROR("seclabel-multiple", NONE);
    DO_TEST_PARSE_ERROR("seclabel-device-duplicates", NONE);
1957

1958
    DO_TEST("pseries-basic",
1959
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
1960
            QEMU_CAPS_DEVICE_SPAPR_VTY);
1961
    DO_TEST("pseries-vio",
1962
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
1963
            QEMU_CAPS_DEVICE_SPAPR_VTY);
1964
    DO_TEST("pseries-usb-default",
1965
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
1966
            QEMU_CAPS_DEVICE_SPAPR_VTY,
1967
            QEMU_CAPS_PIIX3_USB_UHCI,
1968
            QEMU_CAPS_PCI_OHCI);
1969
    DO_TEST("pseries-usb-multi",
1970
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
1971
            QEMU_CAPS_DEVICE_SPAPR_VTY,
1972
            QEMU_CAPS_PIIX3_USB_UHCI,
1973
            QEMU_CAPS_PCI_OHCI);
1974
    DO_TEST("pseries-vio-user-assigned",
1975
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
1976 1977
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST_PARSE_ERROR("pseries-vio-address-clash", NONE);
1978 1979 1980
    DO_TEST("pseries-nvram",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_DEVICE_NVRAM);
1981
    DO_TEST("pseries-usb-kbd", QEMU_CAPS_PCI_OHCI,
1982
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
1983
            QEMU_CAPS_DEVICE_USB_KBD,
1984
            QEMU_CAPS_DEVICE_SPAPR_VTY);
1985
    DO_TEST("pseries-cpu-exact",
1986
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
1987 1988
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST_PARSE_ERROR("pseries-no-parallel", NONE);
1989

1990
    qemuTestSetHostArch(&driver, VIR_ARCH_PPC64);
A
Andrea Bolognani 已提交
1991
    DO_TEST("pseries-cpu-compat", QEMU_CAPS_KVM,
1992
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
1993
            QEMU_CAPS_DEVICE_SPAPR_VTY);
1994 1995 1996
    DO_TEST("pseries-machine-max-cpu-compat",
            QEMU_CAPS_KVM,
            QEMU_CAPS_MACHINE_PSERIES_MAX_CPU_COMPAT,
1997
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
A
Andrea Bolognani 已提交
1998
    DO_TEST("pseries-cpu-le", QEMU_CAPS_KVM,
1999
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
2000
            QEMU_CAPS_DEVICE_SPAPR_VTY);
2001 2002 2003
    DO_TEST_FAILURE("pseries-cpu-compat-power9",
                    QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
                    QEMU_CAPS_KVM);
2004

2005
    qemuTestSetHostCPU(&driver, driver.hostarch, cpuPower9);
2006
    DO_TEST("pseries-cpu-compat-power9",
2007
            QEMU_CAPS_KVM,
2008
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
2009
            QEMU_CAPS_DEVICE_SPAPR_VTY);
2010
    qemuTestSetHostCPU(&driver, driver.hostarch, NULL);
2011

2012
    qemuTestSetHostArch(&driver, VIR_ARCH_NONE);
2013

2014
    DO_TEST("pseries-panic-missing",
2015
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
2016
            QEMU_CAPS_DEVICE_SPAPR_VTY);
2017
    DO_TEST("pseries-panic-no-address",
2018
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
2019
            QEMU_CAPS_DEVICE_SPAPR_VTY);
2020
    DO_TEST_FAILURE("pseries-panic-address",
2021
                    QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
2022 2023 2024 2025 2026

    DO_TEST("pseries-phb-simple",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
    DO_TEST("pseries-phb-default-missing",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
2027 2028 2029 2030 2031 2032
    DO_TEST("pseries-phb-numa-node",
            QEMU_CAPS_NUMA,
            QEMU_CAPS_OBJECT_MEMORY_RAM,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_SPAPR_PCI_HOST_BRIDGE_NUMA_NODE);
    DO_TEST_PARSE_ERROR("pseries-default-phb-numa-node", NONE);
2033 2034 2035
    DO_TEST_PARSE_ERROR("pseries-phb-invalid-target-index-1", NONE);
    DO_TEST_PARSE_ERROR("pseries-phb-invalid-target-index-2", NONE);
    DO_TEST_PARSE_ERROR("pseries-phb-invalid-target-index-3", NONE);
2036

2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058
    DO_TEST("pseries-many-devices",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("pseries-many-buses-1",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("pseries-many-buses-2",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("pseries-hostdevs-1",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_VFIO_PCI);
    DO_TEST("pseries-hostdevs-2",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_VFIO_PCI);
    DO_TEST("pseries-hostdevs-3",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_VFIO_PCI);

2059
    DO_TEST("pseries-features",
2060
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
2061
            QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
2062
            QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
2063
            QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
2064
            QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
2065
            QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
2066
            QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
2067
            QEMU_CAPS_MACHINE_PSERIES_CAP_IBS,
2068
            QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);
2069 2070 2071 2072 2073 2074 2075

    /* parse error: no QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT */
    DO_TEST_PARSE_ERROR("pseries-features",
                        QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
2076
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
2077
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
2078 2079
                        QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_IBS);
2080 2081 2082 2083 2084 2085 2086

    /* parse error: no QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE */
    DO_TEST_PARSE_ERROR("pseries-features",
                        QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
2087
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
2088
                        QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
2089
                        QEMU_CAPS_MACHINE_PSERIES_CAP_IBS,
2090 2091 2092 2093 2094 2095 2096 2097
                        QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);

    /* parse error: no QEMU_CAPS_MACHINE_PSERIES_CAP_HTM */
    DO_TEST_PARSE_ERROR("pseries-features",
                        QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
2098
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
2099
                        QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
2100
                        QEMU_CAPS_MACHINE_PSERIES_CAP_IBS,
2101 2102 2103 2104 2105 2106 2107 2108
                        QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);

    /* parse error: no QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV */
    DO_TEST_PARSE_ERROR("pseries-features",
                        QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
2109
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
2110
                        QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
2111
                        QEMU_CAPS_MACHINE_PSERIES_CAP_IBS,
2112 2113 2114 2115 2116 2117 2118 2119
                        QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);

    /* parse error: no QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST */
    DO_TEST_PARSE_ERROR("pseries-features",
                        QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
2120
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
2121
                        QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
2122
                        QEMU_CAPS_MACHINE_PSERIES_CAP_IBS,
2123 2124
                        QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);

2125 2126 2127 2128 2129 2130 2131
    /* parse error: no QEMU_CAPS_MACHINE_PSERIES_CFPC */
    DO_TEST_PARSE_ERROR("pseries-features",
                        QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
                        QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
2132
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
2133 2134
                        QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_IBS);
2135 2136 2137 2138 2139 2140 2141 2142 2143

    /* parse error: no QEMU_CAPS_MACHINE_PSERIES_SBBC */
    DO_TEST_PARSE_ERROR("pseries-features",
                        QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
                        QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_IBS);

    /* parse error: no QEMU_CAPS_MACHINE_PSERIES_IBS */
    DO_TEST_PARSE_ERROR("pseries-features",
                        QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
                        QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
                        QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC);
2157

A
Andrea Bolognani 已提交
2158
    DO_TEST_PARSE_ERROR("pseries-features-invalid-machine", NONE);
2159

2160
    DO_TEST("pseries-serial-native",
2161
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
2162 2163
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST("pseries-serial+console-native",
2164
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
2165 2166
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST("pseries-serial-compat",
2167
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
2168
            QEMU_CAPS_DEVICE_SPAPR_VTY);
2169
    DO_TEST("pseries-serial-pci",
2170
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
2171 2172
            QEMU_CAPS_DEVICE_PCI_SERIAL);
    DO_TEST("pseries-serial-usb",
2173
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
2174 2175
            QEMU_CAPS_DEVICE_QEMU_XHCI,
            QEMU_CAPS_DEVICE_USB_SERIAL);
2176
    DO_TEST("pseries-console-native",
2177
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
2178 2179
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST("pseries-console-virtio",
2180
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
2181
    DO_TEST_PARSE_ERROR("pseries-serial-invalid-machine", NONE);
2182
    DO_TEST_PARSE_ERROR("pseries-spaprvio-invalid", "ppc64");
2183

2184
    DO_TEST("mach-virt-serial-native",
2185
            QEMU_CAPS_DEVICE_PL011);
2186
    DO_TEST("mach-virt-serial+console-native",
2187
            QEMU_CAPS_DEVICE_PL011);
2188
    DO_TEST("mach-virt-serial-compat",
2189
            QEMU_CAPS_DEVICE_PL011);
2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201
    DO_TEST("mach-virt-serial-pci",
            QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCI_SERIAL);
    DO_TEST("mach-virt-serial-usb",
            QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
            QEMU_CAPS_DEVICE_QEMU_XHCI,
            QEMU_CAPS_DEVICE_USB_SERIAL);
    DO_TEST("mach-virt-console-native",
2202
            QEMU_CAPS_DEVICE_PL011);
2203 2204
    DO_TEST("mach-virt-console-virtio",
            QEMU_CAPS_DEVICE_VIRTIO_MMIO);
2205 2206
    DO_TEST_PARSE_ERROR("mach-virt-serial-invalid-machine", NONE);

2207 2208
    DO_TEST("disk-ide-split", NONE);
    DO_TEST("disk-ide-wwn", QEMU_CAPS_IDE_DRIVE_WWN);
2209

2210
    DO_TEST("disk-geometry", NONE);
2211
    DO_TEST("disk-blockio", QEMU_CAPS_BLOCKIO);
2212

2213
    DO_TEST("video-device-pciaddr-default",
2214 2215
            QEMU_CAPS_KVM,
            QEMU_CAPS_VNC,
2216
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2217
            QEMU_CAPS_DEVICE_QXL);
2218
    DO_TEST("video-vga-nodevice", QEMU_CAPS_DEVICE_VGA);
2219
    DO_TEST("video-vga-device", QEMU_CAPS_DEVICE_VGA,
2220
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
2221
    DO_TEST("video-vga-device-vgamem", QEMU_CAPS_DEVICE_VGA,
2222
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY, QEMU_CAPS_VGA_VGAMEM);
2223
    DO_TEST("video-qxl-nodevice", QEMU_CAPS_DEVICE_QXL);
2224
    DO_TEST("video-qxl-device",
2225
            QEMU_CAPS_DEVICE_QXL,
2226
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
2227
    DO_TEST("video-qxl-device-vgamem",
2228
            QEMU_CAPS_DEVICE_QXL,
2229
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2230
            QEMU_CAPS_QXL_VGAMEM);
2231
    DO_TEST_CAPS_LATEST("video-qxl-device-vram64");
2232
    DO_TEST("video-qxl-sec-device",
2233
            QEMU_CAPS_DEVICE_QXL, QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
2234
    DO_TEST("video-qxl-sec-device-vgamem",
2235 2236
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2237
            QEMU_CAPS_QXL_VGAMEM);
2238
    DO_TEST_CAPS_LATEST("video-qxl-sec-device-vram64");
2239 2240 2241
    DO_TEST("video-qxl-heads",
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_DEVICE_QXL,
2242
            QEMU_CAPS_QXL_MAX_OUTPUTS);
2243 2244 2245
    DO_TEST("video-vga-qxl-heads",
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_QXL_MAX_OUTPUTS);
2246 2247 2248
    DO_TEST("video-qxl-noheads",
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_DEVICE_QXL,
2249
            QEMU_CAPS_QXL_MAX_OUTPUTS);
2250 2251 2252 2253
    DO_TEST("video-qxl-resolution",
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_QXL_VGAMEM);
M
Marc-André Lureau 已提交
2254
    DO_TEST("video-virtio-gpu-device",
2255
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
M
Marc-André Lureau 已提交
2256
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
2257
    DO_TEST("video-virtio-gpu-virgl",
2258
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
2259
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
2260
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
2261 2262
    DO_TEST("video-virtio-gpu-spice-gl",
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
2263
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
2264 2265
            QEMU_CAPS_SPICE,
            QEMU_CAPS_SPICE_GL,
2266
            QEMU_CAPS_SPICE_RENDERNODE,
2267
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
2268 2269 2270 2271 2272
    DO_TEST("video-virtio-gpu-sdl-gl",
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_SDL_GL,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
2273 2274 2275
    DO_TEST("video-virtio-gpu-secondary",
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
2276 2277 2278
    DO_TEST("video-virtio-vga",
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_DEVICE_VIRTIO_VGA,
2279 2280
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_VIRTIO_GPU_MAX_OUTPUTS);
2281
    DO_TEST_CAPS_LATEST("video-bochs-display-device");
2282
    DO_TEST_CAPS_LATEST("video-ramfb-display-device");
2283 2284 2285
    DO_TEST("video-none-device",
            QEMU_CAPS_VNC);
    DO_TEST_PARSE_ERROR("video-invalid-multiple-devices", NONE);
2286
    DO_TEST_PARSE_ERROR("default-video-type-x86_64-caps-test-0", NONE);
2287

2288 2289 2290 2291 2292
    DO_TEST_CAPS_ARCH_LATEST("default-video-type-aarch64", "aarch64");
    DO_TEST_CAPS_ARCH_LATEST("default-video-type-ppc64", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("default-video-type-riscv64", "riscv64");
    DO_TEST_CAPS_ARCH_LATEST("default-video-type-s390x", "s390x");

2293 2294
    DO_TEST("virtio-rng-default",
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
2295
            QEMU_CAPS_OBJECT_RNG_RANDOM);
2296 2297
    DO_TEST("virtio-rng-random",
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
2298
            QEMU_CAPS_OBJECT_RNG_RANDOM);
2299 2300
    DO_TEST("virtio-rng-egd",
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
2301
            QEMU_CAPS_OBJECT_RNG_EGD);
H
Han Han 已提交
2302
    DO_TEST_CAPS_LATEST("virtio-rng-builtin");
J
Ján Tomko 已提交
2303 2304
    DO_TEST_CAPS_VER("virtio-rng-egd-unix", "2.5.0");
    DO_TEST_CAPS_LATEST("virtio-rng-egd-unix");
2305 2306 2307 2308
    DO_TEST("virtio-rng-multiple",
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_EGD,
            QEMU_CAPS_OBJECT_RNG_RANDOM);
2309
    DO_TEST_PARSE_ERROR("virtio-rng-egd-crash",
2310 2311
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_EGD);
2312
    DO_TEST("virtio-rng-ccw",
2313
            QEMU_CAPS_CCW,
2314 2315
            QEMU_CAPS_VIRTIO_S390,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
2316
            QEMU_CAPS_OBJECT_RNG_RANDOM);
2317

2318
    DO_TEST("s390-allow-bogus-usb-none",
2319 2320 2321
            QEMU_CAPS_VIRTIO_S390,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM);
2322
    DO_TEST("s390-allow-bogus-usb-controller",
2323 2324 2325
            QEMU_CAPS_VIRTIO_S390,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM);
2326

2327
    DO_TEST("s390-panic-no-address",
2328
            QEMU_CAPS_CCW,
2329
            QEMU_CAPS_VIRTIO_S390);
2330
    DO_TEST_FAILURE("s390-panic-address",
2331
            QEMU_CAPS_CCW,
2332
            QEMU_CAPS_VIRTIO_S390);
2333
    DO_TEST("s390-panic-missing",
2334
            QEMU_CAPS_CCW,
2335
            QEMU_CAPS_VIRTIO_S390);
2336
    DO_TEST_PARSE_ERROR("s390-no-parallel",
2337
            QEMU_CAPS_CCW,
2338
            QEMU_CAPS_VIRTIO_S390);
2339
    DO_TEST("s390-serial",
2340
            QEMU_CAPS_CCW,
2341 2342 2343
            QEMU_CAPS_VIRTIO_S390,
            QEMU_CAPS_DEVICE_SCLPCONSOLE);
    DO_TEST("s390-serial-2",
2344
            QEMU_CAPS_CCW,
2345 2346 2347 2348
            QEMU_CAPS_VIRTIO_S390,
            QEMU_CAPS_DEVICE_SCLPCONSOLE,
            QEMU_CAPS_DEVICE_SCLPLMCONSOLE);
    DO_TEST("s390-serial-console",
2349
            QEMU_CAPS_CCW,
2350 2351
            QEMU_CAPS_VIRTIO_S390,
            QEMU_CAPS_DEVICE_SCLPCONSOLE);
2352

2353
    DO_TEST("ppc-dtb",
J
Ján Tomko 已提交
2354
            QEMU_CAPS_KVM);
2355 2356
    DO_TEST("ppce500-serial",
            QEMU_CAPS_KVM);
O
Olivia Yin 已提交
2357

2358 2359
    DO_TEST_CAPS_LATEST("tpm-passthrough");
    DO_TEST_CAPS_LATEST("tpm-passthrough-crb");
2360
    DO_TEST_PARSE_ERROR("tpm-no-backend-invalid",
2361
                        QEMU_CAPS_DEVICE_TPM_PASSTHROUGH, QEMU_CAPS_DEVICE_TPM_TIS);
2362
    DO_TEST_CAPS_LATEST("tpm-emulator");
2363
    DO_TEST_CAPS_LATEST("tpm-emulator-tpm2");
2364
    DO_TEST_CAPS_LATEST("tpm-emulator-tpm2-enc");
2365
    DO_TEST_CAPS_LATEST_PPC64("tpm-emulator-spapr");
2366

2367 2368 2369 2370
    DO_TEST_PARSE_ERROR("pci-domain-invalid", NONE);
    DO_TEST_PARSE_ERROR("pci-bus-invalid", NONE);
    DO_TEST_PARSE_ERROR("pci-slot-invalid", NONE);
    DO_TEST_PARSE_ERROR("pci-function-invalid", NONE);
2371

2372 2373 2374 2375 2376 2377
    DO_TEST("pci-bridge",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("pci-autoadd-addr",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
2378
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
2379 2380
    DO_TEST("pci-autoadd-idx",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
2381 2382
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("pci-autofill-addr", QEMU_CAPS_DEVICE_CIRRUS_VGA);
2383
    DO_TEST("pci-many",
2384
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
2385
    DO_TEST("pci-bridge-many-disks",
2386
            QEMU_CAPS_DEVICE_PCI_BRIDGE);
L
Laine Stump 已提交
2387
    DO_TEST("pcie-root",
2388 2389 2390 2391
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_DEVICE_QXL);
2392
    DO_TEST("q35",
2393
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
2394
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
2395
            QEMU_CAPS_DEVICE_IOH3420,
2396
            QEMU_CAPS_ICH9_AHCI,
2397
            QEMU_CAPS_ICH9_USB_EHCI1,
2398
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2399
            QEMU_CAPS_DEVICE_QXL);
2400 2401 2402 2403 2404 2405 2406 2407
    DO_TEST_PARSE_ERROR("q35-dmi-bad-address1",
                        QEMU_CAPS_DEVICE_PCI_BRIDGE,
                        QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
                        QEMU_CAPS_DEVICE_IOH3420);
    DO_TEST_PARSE_ERROR("q35-dmi-bad-address2",
                        QEMU_CAPS_DEVICE_PCI_BRIDGE,
                        QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
                        QEMU_CAPS_DEVICE_IOH3420);
2408
    DO_TEST("q35-pm-disable",
2409
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
2410
            QEMU_CAPS_DEVICE_IOH3420,
2411 2412 2413 2414
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE, QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PIIX_DISABLE_S3, QEMU_CAPS_PIIX_DISABLE_S4,
            QEMU_CAPS_ICH9_DISABLE_S3, QEMU_CAPS_ICH9_DISABLE_S4);
    DO_TEST("q35-pm-disable-fallback",
2415
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
2416
            QEMU_CAPS_DEVICE_IOH3420,
2417 2418
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE, QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PIIX_DISABLE_S3, QEMU_CAPS_PIIX_DISABLE_S4);
2419
    DO_TEST("q35-usb2",
2420
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
2421
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
2422
            QEMU_CAPS_DEVICE_IOH3420,
2423
            QEMU_CAPS_ICH9_AHCI,
2424
            QEMU_CAPS_ICH9_USB_EHCI1,
2425
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2426
            QEMU_CAPS_DEVICE_QXL);
2427
    DO_TEST("q35-usb2-multi",
2428
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
2429
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
2430
            QEMU_CAPS_DEVICE_IOH3420,
2431
            QEMU_CAPS_ICH9_AHCI,
2432
            QEMU_CAPS_ICH9_USB_EHCI1,
2433
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2434
            QEMU_CAPS_DEVICE_QXL);
2435
    DO_TEST("q35-usb2-reorder",
2436
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
2437
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
2438
            QEMU_CAPS_DEVICE_IOH3420,
2439
            QEMU_CAPS_ICH9_AHCI,
2440
            QEMU_CAPS_ICH9_USB_EHCI1,
2441
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2442
            QEMU_CAPS_DEVICE_QXL);
2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460
    /* verify that devices with pcie capability are assigned to a pcie slot */
    DO_TEST("q35-pcie",
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
2461
            QEMU_CAPS_NEC_USB_XHCI,
2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
    /* same XML as q35-pcie, but don't set
     * QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY, so virtio devices should
     * be assigned to legacy pci slots
     */
    DO_TEST("q35-virtio-pci",
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_NEC_USB_XHCI,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
    /* same as q35-pcie, but all PCI controllers are added automatically */
    DO_TEST("q35-pcie-autoadd",
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_NEC_USB_XHCI,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
    DO_TEST("q35-default-devices-only",
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_NEC_USB_XHCI,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
    DO_TEST("q35-multifunction",
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
2528 2529 2530 2531 2532
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
2533 2534 2535 2536 2537 2538 2539 2540
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
2541
            QEMU_CAPS_NEC_USB_XHCI,
2542
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
2543 2544
    DO_TEST("q35-virt-manager-basic",
            QEMU_CAPS_KVM,
2545
            QEMU_CAPS_MACHINE_VMPORT_OPT,
2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569
            QEMU_CAPS_ICH9_DISABLE_S3,
            QEMU_CAPS_ICH9_DISABLE_S4,
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_NEC_USB_XHCI,
            QEMU_CAPS_DEVICE_ICH9_INTEL_HDA,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_SPICE,
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_HDA_DUPLEX,
2570
            QEMU_CAPS_DEVICE_ISA_SERIAL,
2571
            QEMU_CAPS_USB_REDIR);
2572 2573

    /* Test automatic and manual setting of pcie-root-port attributes */
2574 2575
    DO_TEST("pcie-root-port",
            QEMU_CAPS_DEVICE_IOH3420,
2576
            QEMU_CAPS_ICH9_AHCI,
2577
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2578
            QEMU_CAPS_DEVICE_QXL);
2579 2580 2581 2582 2583 2584

    /* Make sure the default model for PCIe Root Ports is picked correctly
     * based on QEMU binary capabilities. We use x86/q35 for the test, but
     * any PCIe machine type (such as aarch64/virt) will behave the same */
    DO_TEST("pcie-root-port-model-generic",
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
2585
            QEMU_CAPS_DEVICE_IOH3420);
2586
    DO_TEST("pcie-root-port-model-ioh3420",
2587
            QEMU_CAPS_DEVICE_IOH3420);
2588
    DO_TEST_CAPS_LATEST("pcie-root-port-nohotplug");
2589

2590 2591 2592 2593 2594 2595 2596
    DO_TEST("autoindex",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_ICH9_AHCI,
2597
            QEMU_CAPS_ICH9_USB_EHCI1,
2598
            QEMU_CAPS_NEC_USB_XHCI);
2599 2600 2601 2602 2603 2604 2605
    /* Make sure the user can always override libvirt's default device
     * placement policy by providing an explicit PCI address */
    DO_TEST("q35-pci-force-address",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_HDA_DUPLEX);
2606

2607
    DO_TEST_PARSE_ERROR("q35-wrong-root",
2608
            QEMU_CAPS_DEVICE_IOH3420,
2609
            QEMU_CAPS_ICH9_AHCI,
2610
            QEMU_CAPS_ICH9_USB_EHCI1,
2611
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2612
            QEMU_CAPS_DEVICE_QXL);
2613
    DO_TEST_PARSE_ERROR("440fx-wrong-root", NONE);
2614
    DO_TEST_PARSE_ERROR("440fx-ide-address-conflict", NONE);
2615

2616
    DO_TEST_PARSE_ERROR("pcie-root-port-too-many",
2617
            QEMU_CAPS_DEVICE_IOH3420,
2618
            QEMU_CAPS_ICH9_AHCI,
2619
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2620
            QEMU_CAPS_DEVICE_QXL);
2621

2622 2623 2624
    DO_TEST("pcie-switch-upstream-port",
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
2625
            QEMU_CAPS_ICH9_AHCI,
2626
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2627
            QEMU_CAPS_DEVICE_QXL);
2628 2629 2630 2631
    DO_TEST("pcie-switch-downstream-port",
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
2632
            QEMU_CAPS_ICH9_AHCI,
2633
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2634
            QEMU_CAPS_DEVICE_QXL);
2635

2636 2637 2638 2639 2640 2641
    DO_TEST("pci-expander-bus",
            QEMU_CAPS_DEVICE_PXB);
    DO_TEST_PARSE_ERROR("pci-expander-bus-bad-node",
                        QEMU_CAPS_DEVICE_PXB);
    DO_TEST_PARSE_ERROR("pci-expander-bus-bad-machine",
                        QEMU_CAPS_DEVICE_PXB);
2642 2643
    DO_TEST_PARSE_ERROR("pci-expander-bus-bad-bus",
                        QEMU_CAPS_DEVICE_PXB);
2644

2645 2646 2647 2648 2649 2650 2651 2652 2653 2654
    DO_TEST("pcie-expander-bus",
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_DEVICE_PXB_PCIE);
    DO_TEST_PARSE_ERROR("pcie-expander-bus-bad-machine",
                        QEMU_CAPS_DEVICE_IOH3420,
                        QEMU_CAPS_DEVICE_X3130_UPSTREAM,
                        QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
                        QEMU_CAPS_DEVICE_PXB_PCIE);
2655 2656 2657
    DO_TEST_PARSE_ERROR("pcie-expander-bus-bad-bus",
                        QEMU_CAPS_DEVICE_IOH3420,
                        QEMU_CAPS_DEVICE_PXB_PCIE);
2658

2659
    DO_TEST_CAPS_VER("hostdev-scsi-lsi", "2.8.0");
2660
    DO_TEST_CAPS_VER("hostdev-scsi-lsi", "4.1.0");
2661
    DO_TEST_CAPS_LATEST("hostdev-scsi-lsi");
2662
    DO_TEST_CAPS_VER("hostdev-scsi-virtio-scsi", "2.8.0");
2663
    DO_TEST_CAPS_VER("hostdev-scsi-virtio-scsi", "4.1.0");
2664
    DO_TEST_CAPS_LATEST("hostdev-scsi-virtio-scsi");
2665

2666
    DO_TEST("hostdev-scsi-readonly",
2667 2668
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
2669
    DO_TEST("hostdev-scsi-virtio-iscsi",
2670 2671
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
2672
    DO_TEST("hostdev-scsi-virtio-iscsi-auth",
2673 2674
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
2675
    DO_TEST("disk-hostdev-scsi-virtio-iscsi-auth-AES",
2676 2677 2678
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_OBJECT_SECRET,
2679
            QEMU_CAPS_ISCSI_PASSWORD_SECRET);
2680 2681
    DO_TEST("hostdev-scsi-vhost-scsi-ccw",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
2682
            QEMU_CAPS_CCW);
2683
    DO_TEST("hostdev-scsi-vhost-scsi-pci",
2684 2685
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_VHOST_SCSI);
2686
    DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-scsi-vhost-scsi-pci-boot-fail");
2687 2688 2689 2690 2691
    DO_TEST("hostdev-scsi-vhost-scsi-pcie",
            QEMU_CAPS_KVM,
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY);
2692

2693 2694
    DO_TEST_CAPS_VER("mlock-on", "3.0.0");
    DO_TEST_CAPS_VER("mlock-off", "3.0.0");
2695 2696
    DO_TEST_CAPS_LATEST("mlock-on");
    DO_TEST_CAPS_LATEST("mlock-off");
2697

2698 2699 2700 2701
    DO_TEST_PARSE_ERROR("pci-bridge-negative-index-invalid", NONE);
    DO_TEST_PARSE_ERROR("pci-bridge-duplicate-index", NONE);
    DO_TEST_PARSE_ERROR("pci-root-nonzero-index", NONE);
    DO_TEST_PARSE_ERROR("pci-root-address", NONE);
2702

2703
    DO_TEST("hotplug-base",
2704
            QEMU_CAPS_KVM, QEMU_CAPS_VIRTIO_SCSI);
2705

2706
    DO_TEST("pcihole64", QEMU_CAPS_I440FX_PCI_HOLE64_SIZE);
2707
    DO_TEST_PARSE_ERROR("pcihole64-none", NONE);
2708
    DO_TEST("pcihole64-q35",
2709
            QEMU_CAPS_DEVICE_IOH3420,
2710
            QEMU_CAPS_ICH9_AHCI,
2711
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2712
            QEMU_CAPS_DEVICE_QXL,
2713 2714
            QEMU_CAPS_Q35_PCI_HOLE64_SIZE);

J
Ján Tomko 已提交
2715 2716
    DO_TEST("arm-vexpressa9-nodevs", NONE);
    DO_TEST("arm-vexpressa9-basic", NONE);
2717
    DO_TEST("arm-vexpressa9-virtio",
2718
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
2719
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
2720
    DO_TEST("arm-virt-virtio",
2721
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
2722
            QEMU_CAPS_DEVICE_PL011,
2723
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
2724

2725
    DO_TEST("aarch64-virt-virtio",
2726
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
2727
            QEMU_CAPS_DEVICE_PL011,
2728
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
2729 2730 2731 2732 2733 2734

    /* Demonstrates the virtio-pci default... namely that there isn't any!
       q35 style PCI controllers will be added if the binary supports it,
       but virtio-mmio is always used unless PCI addresses are manually
       specified. */
    DO_TEST("aarch64-virtio-pci-default",
2735
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
2736 2737 2738
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_OBJECT_GPEX, QEMU_CAPS_DEVICE_PCI_BRIDGE,
2739
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
2740
            QEMU_CAPS_DEVICE_IOH3420,
2741
            QEMU_CAPS_DEVICE_PL011,
2742
            QEMU_CAPS_VIRTIO_SCSI);
2743
    DO_TEST("aarch64-virt-2.6-virtio-pci-default",
2744
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
2745 2746
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_OBJECT_GPEX, QEMU_CAPS_DEVICE_PCI_BRIDGE,
2747
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
2748
            QEMU_CAPS_DEVICE_PL011,
2749
            QEMU_CAPS_DEVICE_IOH3420);
2750 2751 2752
    /* Example of using virtio-pci with no explicit PCI controller
       but with manual PCI addresses */
    DO_TEST("aarch64-virtio-pci-manual-addresses",
2753
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
2754 2755
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_OBJECT_GPEX, QEMU_CAPS_DEVICE_PCI_BRIDGE,
2756 2757 2758
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_VIRTIO_SCSI);
2759
    DO_TEST("aarch64-video-virtio-gpu-pci",
2760
            QEMU_CAPS_OBJECT_GPEX,
2761
            QEMU_CAPS_DEVICE_PCI_BRIDGE, QEMU_CAPS_DEVICE_IOH3420,
2762
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2763
            QEMU_CAPS_DEVICE_VIRTIO_GPU);
2764
    DO_TEST("aarch64-video-default",
2765
            QEMU_CAPS_OBJECT_GPEX,
2766
            QEMU_CAPS_DEVICE_PCI_BRIDGE, QEMU_CAPS_DEVICE_IOH3420,
2767
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
2768 2769
            QEMU_CAPS_DEVICE_VIRTIO_GPU, QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_VNC);
2770
    DO_TEST("aarch64-aavmf-virtio-mmio",
2771
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
2772
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
2773 2774
    DO_TEST("aarch64-virt-default-nic",
            QEMU_CAPS_DEVICE_VIRTIO_MMIO);
2775
    qemuTestSetHostArch(&driver, VIR_ARCH_AARCH64);
2776
    DO_TEST("aarch64-cpu-passthrough",
2777
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
A
Andrea Bolognani 已提交
2778
            QEMU_CAPS_KVM);
2779
    DO_TEST_GIC("aarch64-gic-none", GIC_NONE,
2780
            QEMU_CAPS_KVM,
2781
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
2782
    DO_TEST_GIC("aarch64-gic-none-v2", GIC_V2,
2783
            QEMU_CAPS_KVM,
2784 2785
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
    DO_TEST_GIC("aarch64-gic-none-v3", GIC_V3,
2786
            QEMU_CAPS_KVM,
2787
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
2788
    DO_TEST_GIC("aarch64-gic-none-both", GIC_BOTH,
2789
            QEMU_CAPS_KVM,
2790
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
2791 2792
    DO_TEST_GIC("aarch64-gic-none-tcg", GIC_BOTH,
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
2793
    DO_TEST_GIC("aarch64-gic-default", GIC_NONE,
2794
            QEMU_CAPS_KVM,
2795
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
A
Andrea Bolognani 已提交
2796
    DO_TEST_GIC("aarch64-gic-default-v2", GIC_V2,
2797
            QEMU_CAPS_KVM,
2798
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
A
Andrea Bolognani 已提交
2799
    DO_TEST_GIC("aarch64-gic-default-v3", GIC_V3,
2800
            QEMU_CAPS_KVM,
2801
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
A
Andrea Bolognani 已提交
2802
    DO_TEST_GIC("aarch64-gic-default-both", GIC_BOTH,
2803
            QEMU_CAPS_KVM,
2804 2805
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
    DO_TEST_GIC("aarch64-gic-v2", GIC_NONE,
2806
            QEMU_CAPS_KVM,
2807 2808
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
    DO_TEST_GIC("aarch64-gic-v2", GIC_V2,
2809
            QEMU_CAPS_KVM,
2810 2811
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
    DO_TEST_GIC("aarch64-gic-v2", GIC_V3,
2812
            QEMU_CAPS_KVM,
2813
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
2814
    DO_TEST_GIC("aarch64-gic-v2", GIC_BOTH,
2815
            QEMU_CAPS_KVM,
2816
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
2817
    DO_TEST_FAILURE("aarch64-gic-v3",
2818
            QEMU_CAPS_KVM, NONE);
2819
    DO_TEST_GIC("aarch64-gic-v3", GIC_NONE,
2820
            QEMU_CAPS_KVM,
2821 2822
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
    DO_TEST_GIC("aarch64-gic-v3", GIC_V2,
2823
            QEMU_CAPS_KVM,
2824 2825
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
    DO_TEST_GIC("aarch64-gic-v3", GIC_V3,
2826
            QEMU_CAPS_KVM,
2827 2828
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
    DO_TEST_GIC("aarch64-gic-v3", GIC_BOTH,
2829
            QEMU_CAPS_KVM,
2830
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
2831
    DO_TEST_FAILURE("aarch64-gic-host",
2832
            QEMU_CAPS_KVM, NONE);
2833
    DO_TEST_GIC("aarch64-gic-host", GIC_NONE,
2834
            QEMU_CAPS_KVM,
2835 2836
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
    DO_TEST_GIC("aarch64-gic-host", GIC_V2,
2837
            QEMU_CAPS_KVM,
2838 2839
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
    DO_TEST_GIC("aarch64-gic-host", GIC_V3,
2840
            QEMU_CAPS_KVM,
2841 2842
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
    DO_TEST_GIC("aarch64-gic-host", GIC_BOTH,
2843
            QEMU_CAPS_KVM,
2844
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
2845
    DO_TEST_PARSE_ERROR("aarch64-gic-invalid",
2846
            QEMU_CAPS_KVM,
2847
            QEMU_CAPS_MACH_VIRT_GIC_VERSION);
2848
    DO_TEST_PARSE_ERROR("aarch64-gic-not-virt",
2849
                        QEMU_CAPS_KVM,
2850 2851
                        QEMU_CAPS_MACH_VIRT_GIC_VERSION);
    DO_TEST_PARSE_ERROR("aarch64-gic-not-arm",
2852
                        QEMU_CAPS_KVM,
2853
                        QEMU_CAPS_MACH_VIRT_GIC_VERSION);
2854
    DO_TEST("aarch64-kvm-32-on-64",
2855
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
2856
            QEMU_CAPS_DEVICE_PL011,
A
Andrea Bolognani 已提交
2857
            QEMU_CAPS_KVM, QEMU_CAPS_CPU_AARCH64_OFF);
2858
    DO_TEST_FAILURE("aarch64-kvm-32-on-64",
2859
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
A
Andrea Bolognani 已提交
2860
            QEMU_CAPS_KVM);
2861 2862 2863 2864 2865 2866 2867
    DO_TEST("aarch64-pci-serial",
            QEMU_CAPS_DEVICE_PCI_SERIAL,
            QEMU_CAPS_CHARDEV_LOGFILE,
            QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT);
2868 2869 2870 2871
    DO_TEST("aarch64-traditional-pci",
            QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
2872
            QEMU_CAPS_DEVICE_PCIE_PCI_BRIDGE,
2873 2874
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCI_SERIAL);
2875 2876 2877 2878 2879 2880 2881

    /* Make sure all combinations of ACPI and UEFI behave as expected */
    DO_TEST("aarch64-acpi-uefi", NONE);
    DO_TEST("aarch64-noacpi-uefi", NONE);
    DO_TEST("aarch64-noacpi-nouefi", NONE);
    DO_TEST_PARSE_ERROR("aarch64-acpi-nouefi", NONE);

2882 2883 2884 2885 2886 2887 2888 2889 2890
    /* QEMU 4.0.0 didn't have support for aarch64 CPU features */
    DO_TEST_CAPS_ARCH_VER_FAILURE("aarch64-features-sve", "aarch64", "4.0.0");
    /* aarch64 doesn't support the same CPU features as x86 */
    DO_TEST_CAPS_ARCH_LATEST_FAILURE("aarch64-features-wrong", "aarch64");
    /* Can't enable vector lengths when SVE is overall disabled */
    DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("aarch64-features-sve-disabled", "aarch64");
    /* SVE aarch64 CPU features work on modern QEMU */
    DO_TEST_CAPS_ARCH_LATEST("aarch64-features-sve", "aarch64");

2891 2892
    DO_TEST_CAPS_ARCH_LATEST("clock-timer-armvtimer", "aarch64");

2893
    qemuTestSetHostArch(&driver, VIR_ARCH_NONE);
2894

2895
    DO_TEST("kvm-pit-delay", QEMU_CAPS_KVM_PIT_TICK_POLICY);
2896
    DO_TEST("kvm-pit-discard", QEMU_CAPS_KVM_PIT_TICK_POLICY);
2897

2898 2899 2900 2901
    DO_TEST("panic",
            QEMU_CAPS_DEVICE_PANIC);
    DO_TEST("panic-double",
            QEMU_CAPS_DEVICE_PANIC);
H
Hu Tao 已提交
2902

2903 2904
    DO_TEST("panic-no-address",
            QEMU_CAPS_DEVICE_PANIC);
2905

2906 2907
    DO_TEST("fips-enabled", QEMU_CAPS_ENABLE_FIPS);

J
Ján Tomko 已提交
2908
    DO_TEST("shmem", QEMU_CAPS_DEVICE_IVSHMEM);
2909 2910 2911
    DO_TEST("shmem-plain-doorbell", QEMU_CAPS_DEVICE_IVSHMEM,
            QEMU_CAPS_DEVICE_IVSHMEM_PLAIN,
            QEMU_CAPS_DEVICE_IVSHMEM_DOORBELL);
2912
    DO_TEST_FAILURE("shmem", NONE);
J
Ján Tomko 已提交
2913
    DO_TEST_FAILURE("shmem-invalid-size",
2914
                    QEMU_CAPS_DEVICE_IVSHMEM);
J
Ján Tomko 已提交
2915
    DO_TEST_FAILURE("shmem-invalid-address",
2916
                    QEMU_CAPS_DEVICE_IVSHMEM);
J
Ján Tomko 已提交
2917
    DO_TEST_FAILURE("shmem-small-size",
2918
                    QEMU_CAPS_DEVICE_IVSHMEM);
2919
    DO_TEST_PARSE_ERROR("shmem-msi-only", NONE);
A
Andrea Bolognani 已提交
2920
    DO_TEST("cpu-host-passthrough-features", QEMU_CAPS_KVM);
2921

2922
    DO_TEST_FAILURE("memory-align-fail", NONE);
2923
    DO_TEST_FAILURE("memory-hotplug-nonuma", QEMU_CAPS_DEVICE_PC_DIMM);
M
Michal Privoznik 已提交
2924
    DO_TEST("memory-hotplug", NONE);
2925
    DO_TEST("memory-hotplug", QEMU_CAPS_DEVICE_PC_DIMM, QEMU_CAPS_NUMA);
2926
    DO_TEST("memory-hotplug-dimm", QEMU_CAPS_DEVICE_PC_DIMM, QEMU_CAPS_NUMA,
2927
            QEMU_CAPS_OBJECT_MEMORY_RAM, QEMU_CAPS_OBJECT_MEMORY_FILE);
2928
    DO_TEST("memory-hotplug-dimm-addr", QEMU_CAPS_DEVICE_PC_DIMM, QEMU_CAPS_NUMA,
2929
            QEMU_CAPS_OBJECT_MEMORY_RAM, QEMU_CAPS_OBJECT_MEMORY_FILE);
2930
    DO_TEST("memory-hotplug-ppc64-nonuma", QEMU_CAPS_KVM, QEMU_CAPS_DEVICE_PC_DIMM, QEMU_CAPS_NUMA,
2931
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
2932
            QEMU_CAPS_OBJECT_MEMORY_RAM, QEMU_CAPS_OBJECT_MEMORY_FILE);
2933 2934 2935
    DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm");
    DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-access");
    DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-label");
2936
    DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-align");
2937
    DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-pmem");
2938
    DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-readonly");
2939
    DO_TEST_CAPS_ARCH_LATEST("memory-hotplug-nvdimm-ppc64", "ppc64");
2940

2941
    DO_TEST("machine-aeskeywrap-on-caps",
2942
            QEMU_CAPS_AES_KEY_WRAP,
2943
            QEMU_CAPS_DEA_KEY_WRAP,
2944
            QEMU_CAPS_VIRTIO_SCSI,
2945
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
2946
    DO_TEST_FAILURE("machine-aeskeywrap-on-caps",
2947
                    QEMU_CAPS_VIRTIO_SCSI,
2948
                    QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
2949 2950 2951
    DO_TEST_FAILURE("machine-aeskeywrap-on-caps", NONE);

    DO_TEST("machine-aeskeywrap-on-cap",
2952
            QEMU_CAPS_AES_KEY_WRAP,
2953
            QEMU_CAPS_VIRTIO_SCSI,
2954
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
2955
    DO_TEST_FAILURE("machine-aeskeywrap-on-cap",
2956
                    QEMU_CAPS_VIRTIO_SCSI,
2957
                    QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
2958 2959 2960
    DO_TEST_FAILURE("machine-aeskeywrap-on-cap", NONE);

    DO_TEST("machine-aeskeywrap-off-caps",
2961
            QEMU_CAPS_AES_KEY_WRAP, QEMU_CAPS_DEA_KEY_WRAP,
2962
            QEMU_CAPS_VIRTIO_SCSI,
2963
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
2964
    DO_TEST_FAILURE("machine-aeskeywrap-off-caps",
2965
                    QEMU_CAPS_VIRTIO_SCSI,
2966
                    QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
2967 2968 2969
    DO_TEST_FAILURE("machine-aeskeywrap-off-caps", NONE);

    DO_TEST("machine-aeskeywrap-off-cap",
2970
            QEMU_CAPS_AES_KEY_WRAP,
2971
            QEMU_CAPS_VIRTIO_SCSI,
2972
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
2973
    DO_TEST_FAILURE("machine-aeskeywrap-off-cap",
2974
                    QEMU_CAPS_VIRTIO_SCSI,
2975
                    QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
2976 2977 2978
    DO_TEST_FAILURE("machine-aeskeywrap-off-cap", NONE);

    DO_TEST("machine-deakeywrap-on-caps",
2979
            QEMU_CAPS_AES_KEY_WRAP, QEMU_CAPS_DEA_KEY_WRAP,
2980
            QEMU_CAPS_VIRTIO_SCSI,
2981
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
2982
    DO_TEST_FAILURE("machine-deakeywrap-on-caps",
2983
                    QEMU_CAPS_VIRTIO_SCSI,
2984
                    QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
2985 2986 2987
    DO_TEST_FAILURE("machine-deakeywrap-on-caps", NONE);

    DO_TEST("machine-deakeywrap-on-cap",
2988
            QEMU_CAPS_DEA_KEY_WRAP,
2989
            QEMU_CAPS_VIRTIO_SCSI,
2990
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
2991
    DO_TEST_FAILURE("machine-deakeywrap-on-cap",
2992
                    QEMU_CAPS_VIRTIO_SCSI,
2993
                    QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
2994 2995 2996
    DO_TEST_FAILURE("machine-deakeywrap-on-cap", NONE);

    DO_TEST("machine-deakeywrap-off-caps",
2997
            QEMU_CAPS_AES_KEY_WRAP, QEMU_CAPS_DEA_KEY_WRAP,
2998
            QEMU_CAPS_VIRTIO_SCSI,
2999
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
3000
    DO_TEST_FAILURE("machine-deakeywrap-off-caps",
3001
                    QEMU_CAPS_VIRTIO_SCSI,
3002
                    QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
3003 3004 3005
    DO_TEST_FAILURE("machine-deakeywrap-off-caps", NONE);

    DO_TEST("machine-deakeywrap-off-cap",
3006
            QEMU_CAPS_DEA_KEY_WRAP,
3007
            QEMU_CAPS_VIRTIO_SCSI,
3008
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
3009
    DO_TEST_FAILURE("machine-deakeywrap-off-cap",
3010
                    QEMU_CAPS_VIRTIO_SCSI,
3011
                    QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
3012 3013 3014
    DO_TEST_FAILURE("machine-deakeywrap-off-cap", NONE);

    DO_TEST("machine-keywrap-none-caps",
3015
            QEMU_CAPS_AES_KEY_WRAP, QEMU_CAPS_DEA_KEY_WRAP,
3016
            QEMU_CAPS_VIRTIO_SCSI,
3017
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
3018
    DO_TEST("machine-keywrap-none",
3019
            QEMU_CAPS_VIRTIO_SCSI,
3020
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
3021

3022
    DO_TEST("machine-loadparm-s390",
3023
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390,
3024
            QEMU_CAPS_LOADPARM);
3025
    DO_TEST("machine-loadparm-net-s390",
3026
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390,
3027
            QEMU_CAPS_LOADPARM);
3028
    DO_TEST("machine-loadparm-multiple-disks-nets-s390",
3029
            QEMU_CAPS_CCW,
3030
            QEMU_CAPS_VIRTIO_S390,
3031 3032
            QEMU_CAPS_LOADPARM);
    DO_TEST_PARSE_ERROR("machine-loadparm-s390-char-invalid",
3033
                        QEMU_CAPS_CCW,
3034
                        QEMU_CAPS_VIRTIO_S390,
3035 3036
                        QEMU_CAPS_LOADPARM);
    DO_TEST_PARSE_ERROR("machine-loadparm-s390-len-invalid",
3037
                        QEMU_CAPS_CCW,
3038
                        QEMU_CAPS_VIRTIO_S390,
3039 3040
                        QEMU_CAPS_LOADPARM);

J
Jiri Denemark 已提交
3041 3042 3043 3044 3045 3046 3047
    DO_TEST("qemu-ns-domain-ns0", NONE);
    DO_TEST("qemu-ns-domain-commandline", NONE);
    DO_TEST("qemu-ns-domain-commandline-ns0", NONE);
    DO_TEST("qemu-ns-commandline", NONE);
    DO_TEST("qemu-ns-commandline-ns0", NONE);
    DO_TEST("qemu-ns-commandline-ns1", NONE);

3048
    DO_TEST("virtio-input", QEMU_CAPS_VIRTIO_KEYBOARD,
3049
            QEMU_CAPS_VIRTIO_MOUSE, QEMU_CAPS_VIRTIO_TABLET);
3050
    DO_TEST("virtio-input-passthrough", QEMU_CAPS_VIRTIO_INPUT_HOST);
3051

3052
    DO_TEST("ppc64-usb-controller",
3053
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
3054
            QEMU_CAPS_PCI_OHCI);
3055
    DO_TEST("ppc64-usb-controller-legacy",
3056
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
3057
            QEMU_CAPS_PIIX3_USB_UHCI);
3058
    DO_TEST_FULL("ppc64-usb-controller-qemu-xhci",
3059
                 ARG_PARSEFLAGS, VIR_DOMAIN_DEF_PARSE_ABI_UPDATE,
3060
                 ARG_QEMU_CAPS,
3061
                 QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
3062 3063 3064 3065 3066 3067 3068
                 QEMU_CAPS_NEC_USB_XHCI,
                 QEMU_CAPS_DEVICE_QEMU_XHCI);

    DO_TEST("aarch64-usb-controller-qemu-xhci",
            QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_NEC_USB_XHCI,
            QEMU_CAPS_DEVICE_QEMU_XHCI);
3069

3070 3071 3072 3073
    DO_TEST("aarch64-usb-controller-nec-xhci",
            QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_NEC_USB_XHCI);

3074
    /* VM XML has invalid arch/ostype/virttype combo, but the SKIP flag
3075 3076 3077 3078 3079
     * will avoid the error during parse. This will cause us to fill in
     * the missing machine type using the i386 binary, despite it being
     * the wrong binary for the arch. We expect to get a failure about
     * bad arch later when creating the pretend command.
     */
3080
    DO_TEST_FULL("missing-machine",
3081
                 ARG_FLAGS, FLAG_EXPECT_FAILURE,
3082 3083
                 ARG_PARSEFLAGS, VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE,
                 ARG_QEMU_CAPS, NONE);
3084

3085 3086 3087
    DO_TEST("name-escape",
            QEMU_CAPS_NAME_DEBUG_THREADS,
            QEMU_CAPS_OBJECT_SECRET,
3088 3089
            QEMU_CAPS_DRIVE_IOTUNE_MAX,
            QEMU_CAPS_DRIVE_IOTUNE_GROUP,
3090 3091 3092 3093
            QEMU_CAPS_VNC,
            QEMU_CAPS_NAME_GUEST,
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_SPICE,
3094
            QEMU_CAPS_SPICE_UNIX,
3095 3096 3097 3098 3099
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_SPICE_GL,
            QEMU_CAPS_SPICE_RENDERNODE,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
3100
            QEMU_CAPS_DEVICE_ISA_SERIAL,
3101
            QEMU_CAPS_CHARDEV_FILE_APPEND,
3102
            QEMU_CAPS_CCID_EMULATED,
3103
            QEMU_CAPS_VIRTIO_SCSI);
M
Marc-André Lureau 已提交
3104 3105
    DO_TEST("debug-threads", QEMU_CAPS_NAME_DEBUG_THREADS);

3106
    DO_TEST("master-key", QEMU_CAPS_OBJECT_SECRET);
3107
    DO_TEST("usb-long-port-path",
J
Ján Tomko 已提交
3108
            QEMU_CAPS_USB_HUB);
3109
    DO_TEST_PARSE_ERROR("usb-too-long-port-path-invalid",
3110
                        QEMU_CAPS_USB_HUB);
3111

3112
    DO_TEST("acpi-table", NONE);
3113 3114 3115 3116 3117 3118

    DO_TEST_CAPS_LATEST("intel-iommu");
    DO_TEST_CAPS_VER("intel-iommu", "2.6.0");
    DO_TEST_CAPS_LATEST("intel-iommu-caching-mode");
    DO_TEST_CAPS_LATEST("intel-iommu-eim");
    DO_TEST_CAPS_LATEST("intel-iommu-device-iotlb");
3119
    DO_TEST_CAPS_LATEST_PARSE_ERROR("intel-iommu-wrong-machine");
3120
    DO_TEST_CAPS_ARCH_LATEST("iommu-smmuv3", "aarch64");
3121

3122
    DO_TEST("cpu-hotplug-startup", QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS);
3123 3124 3125
    DO_TEST_PARSE_ERROR("cpu-hotplug-granularity",
                        QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS);

3126
    DO_TEST_CAPS_LATEST("virtio-options");
3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150
    DO_TEST_CAPS_LATEST("virtio-options-controller-iommu");
    DO_TEST_CAPS_LATEST("virtio-options-disk-iommu");
    DO_TEST_CAPS_LATEST("virtio-options-fs-iommu");
    DO_TEST_CAPS_LATEST("virtio-options-input-iommu");
    DO_TEST_CAPS_LATEST("virtio-options-memballoon-iommu");
    DO_TEST_CAPS_LATEST("virtio-options-net-iommu");
    DO_TEST_CAPS_LATEST("virtio-options-rng-iommu");
    DO_TEST_CAPS_LATEST("virtio-options-video-iommu");
    DO_TEST_CAPS_LATEST("virtio-options-controller-ats");
    DO_TEST_CAPS_LATEST("virtio-options-disk-ats");
    DO_TEST_CAPS_LATEST("virtio-options-fs-ats");
    DO_TEST_CAPS_LATEST("virtio-options-input-ats");
    DO_TEST_CAPS_LATEST("virtio-options-memballoon-ats");
    DO_TEST_CAPS_LATEST("virtio-options-net-ats");
    DO_TEST_CAPS_LATEST("virtio-options-rng-ats");
    DO_TEST_CAPS_LATEST("virtio-options-video-ats");
    DO_TEST_CAPS_LATEST("virtio-options-controller-packed");
    DO_TEST_CAPS_LATEST("virtio-options-disk-packed");
    DO_TEST_CAPS_LATEST("virtio-options-fs-packed");
    DO_TEST_CAPS_LATEST("virtio-options-input-packed");
    DO_TEST_CAPS_LATEST("virtio-options-memballoon-packed");
    DO_TEST_CAPS_LATEST("virtio-options-net-packed");
    DO_TEST_CAPS_LATEST("virtio-options-rng-packed");
    DO_TEST_CAPS_LATEST("virtio-options-video-packed");
3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192
    DO_TEST_PARSE_ERROR("virtio-options-controller-iommu", QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST_PARSE_ERROR("virtio-options-disk-iommu", NONE);
    DO_TEST_PARSE_ERROR("virtio-options-fs-iommu", NONE);
    DO_TEST_PARSE_ERROR("virtio-options-input-iommu", QEMU_CAPS_VIRTIO_MOUSE,
                        QEMU_CAPS_VIRTIO_KEYBOARD);
    DO_TEST_PARSE_ERROR("virtio-options-net-iommu", NONE);
    DO_TEST_PARSE_ERROR("virtio-options-memballoon-iommu", NONE);
    DO_TEST_PARSE_ERROR("virtio-options-rng-iommu", QEMU_CAPS_DEVICE_VIRTIO_RNG,
                        QEMU_CAPS_OBJECT_RNG_RANDOM);
    DO_TEST_PARSE_ERROR("virtio-options-video-iommu", QEMU_CAPS_DEVICE_VIRTIO_GPU,
                        QEMU_CAPS_DEVICE_VIRTIO_GPU,
                        QEMU_CAPS_VIRTIO_GPU_VIRGL,
                        QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
                        QEMU_CAPS_DEVICE_VHOST_USER_GPU);
    DO_TEST_PARSE_ERROR("virtio-options-controller-ats", QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST_PARSE_ERROR("virtio-options-disk-ats", NONE);
    DO_TEST_PARSE_ERROR("virtio-options-fs-ats", NONE);
    DO_TEST_PARSE_ERROR("virtio-options-input-ats", QEMU_CAPS_VIRTIO_MOUSE,
                        QEMU_CAPS_VIRTIO_KEYBOARD);
    DO_TEST_PARSE_ERROR("virtio-options-memballoon-ats", NONE);
    DO_TEST_PARSE_ERROR("virtio-options-net-ats", NONE);
    DO_TEST_PARSE_ERROR("virtio-options-rng-ats", QEMU_CAPS_DEVICE_VIRTIO_RNG,
                        QEMU_CAPS_OBJECT_RNG_RANDOM);
    DO_TEST_PARSE_ERROR("virtio-options-video-ats", QEMU_CAPS_DEVICE_VIRTIO_GPU,
                        QEMU_CAPS_DEVICE_VIRTIO_GPU,
                        QEMU_CAPS_VIRTIO_GPU_VIRGL,
                        QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
                        QEMU_CAPS_DEVICE_VHOST_USER_GPU);
    DO_TEST_PARSE_ERROR("virtio-options-controller-packed", QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST_PARSE_ERROR("virtio-options-disk-packed", NONE);
    DO_TEST_PARSE_ERROR("virtio-options-fs-packed", NONE);
    DO_TEST_PARSE_ERROR("virtio-options-input-packed", QEMU_CAPS_VIRTIO_MOUSE,
                        QEMU_CAPS_VIRTIO_KEYBOARD);
    DO_TEST_PARSE_ERROR("virtio-options-memballoon-packed", NONE);
    DO_TEST_PARSE_ERROR("virtio-options-net-packed", NONE);
    DO_TEST_PARSE_ERROR("virtio-options-rng-packed", QEMU_CAPS_DEVICE_VIRTIO_RNG,
                        QEMU_CAPS_OBJECT_RNG_RANDOM);
    DO_TEST_PARSE_ERROR("virtio-options-video-packed", QEMU_CAPS_DEVICE_VIRTIO_GPU,
                        QEMU_CAPS_DEVICE_VIRTIO_GPU,
                        QEMU_CAPS_VIRTIO_GPU_VIRGL,
                        QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
                        QEMU_CAPS_DEVICE_VHOST_USER_GPU);
3193

J
Ján Tomko 已提交
3194
    DO_TEST("fd-memory-numa-topology", QEMU_CAPS_OBJECT_MEMORY_FILE,
3195
            QEMU_CAPS_KVM);
J
Ján Tomko 已提交
3196
    DO_TEST("fd-memory-numa-topology2", QEMU_CAPS_OBJECT_MEMORY_FILE,
3197
            QEMU_CAPS_KVM);
J
Ján Tomko 已提交
3198
    DO_TEST("fd-memory-numa-topology3", QEMU_CAPS_OBJECT_MEMORY_FILE,
3199 3200
            QEMU_CAPS_KVM);

J
Ján Tomko 已提交
3201
    DO_TEST("fd-memory-no-numa-topology", QEMU_CAPS_OBJECT_MEMORY_FILE,
3202 3203
            QEMU_CAPS_KVM);

M
Marc-André Lureau 已提交
3204
    DO_TEST_CAPS_LATEST("memfd-memory-numa");
3205
    DO_TEST_CAPS_LATEST("memfd-memory-default-hugepage");
M
Marc-André Lureau 已提交
3206

3207 3208 3209 3210 3211 3212 3213 3214
    DO_TEST("cpu-check-none", QEMU_CAPS_KVM);
    DO_TEST("cpu-check-partial", QEMU_CAPS_KVM);
    DO_TEST("cpu-check-full", QEMU_CAPS_KVM);
    DO_TEST("cpu-check-default-none", QEMU_CAPS_KVM);
    DO_TEST("cpu-check-default-none2", NONE);
    DO_TEST("cpu-check-default-partial", QEMU_CAPS_KVM);
    DO_TEST("cpu-check-default-partial2", QEMU_CAPS_KVM);

3215 3216 3217 3218 3219 3220 3221 3222 3223
    DO_TEST("cpu-cache-disable", QEMU_CAPS_KVM, QEMU_CAPS_CPU_CACHE);
    DO_TEST("cpu-cache-disable2", QEMU_CAPS_KVM);
    DO_TEST("cpu-cache-disable3", QEMU_CAPS_KVM, QEMU_CAPS_CPU_CACHE);
    DO_TEST("cpu-cache-passthrough", QEMU_CAPS_KVM, QEMU_CAPS_CPU_CACHE);
    DO_TEST("cpu-cache-passthrough2", QEMU_CAPS_KVM);
    DO_TEST("cpu-cache-emulate-l3", QEMU_CAPS_KVM, QEMU_CAPS_CPU_CACHE);
    DO_TEST_PARSE_ERROR("cpu-cache-emulate-l2", QEMU_CAPS_KVM);
    DO_TEST_PARSE_ERROR("cpu-cache-passthrough3", QEMU_CAPS_KVM);
    DO_TEST_PARSE_ERROR("cpu-cache-passthrough-l3", QEMU_CAPS_KVM);
M
Marc-André Lureau 已提交
3224
    DO_TEST("vmcoreinfo", QEMU_CAPS_DEVICE_VMCOREINFO);
3225

3226 3227 3228
    DO_TEST("user-aliases", QEMU_CAPS_KVM, QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_OBJECT_MEMORY_FILE, QEMU_CAPS_PIIX_DISABLE_S3,
            QEMU_CAPS_PIIX_DISABLE_S4, QEMU_CAPS_VNC,
3229
            QEMU_CAPS_DEVICE_ISA_SERIAL,
3230
            QEMU_CAPS_HDA_DUPLEX,
3231 3232
            QEMU_CAPS_CCID_EMULATED,
            QEMU_CAPS_QCOW2_LUKS, QEMU_CAPS_OBJECT_SECRET);
3233
    DO_TEST("user-aliases2", QEMU_CAPS_DEVICE_IOH3420, QEMU_CAPS_ICH9_AHCI);
3234 3235
    DO_TEST("user-aliases-usb", QEMU_CAPS_KVM,
            QEMU_CAPS_PIIX_DISABLE_S3, QEMU_CAPS_PIIX_DISABLE_S4,
3236
            QEMU_CAPS_ICH9_USB_EHCI1);
3237

3238
    DO_TEST_CAPS_VER("disk-virtio-scsi-reservations", "2.12.0");
3239
    DO_TEST_CAPS_LATEST("disk-virtio-scsi-reservations");
3240

3241
    DO_TEST_CAPS_LATEST("tseg-explicit-size");
3242 3243 3244
    DO_TEST_CAPS_LATEST_PARSE_ERROR("tseg-i440fx");
    DO_TEST_CAPS_VER_PARSE_ERROR("tseg-explicit-size", "2.10.0");
    DO_TEST_CAPS_LATEST_PARSE_ERROR("tseg-invalid-size");
3245

3246
    DO_TEST("video-virtio-gpu-ccw", QEMU_CAPS_CCW,
3247 3248 3249 3250 3251 3252
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_VIRTIO_GPU_MAX_OUTPUTS,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_VIRTIO_GPU_CCW);

3253
    DO_TEST("input-virtio-ccw", QEMU_CAPS_CCW,
3254 3255 3256 3257 3258 3259 3260
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_DEVICE_VIRTIO_KEYBOARD_CCW,
            QEMU_CAPS_DEVICE_VIRTIO_MOUSE_CCW,
            QEMU_CAPS_DEVICE_VIRTIO_TABLET_CCW);

3261 3262
    DO_TEST_CAPS_LATEST("vhost-vsock");
    DO_TEST_CAPS_LATEST("vhost-vsock-auto");
3263 3264
    DO_TEST_CAPS_ARCH_LATEST("vhost-vsock-ccw", "s390x");
    DO_TEST_CAPS_ARCH_LATEST("vhost-vsock-ccw-auto", "s390x");
3265

3266
    DO_TEST_CAPS_VER("launch-security-sev", "2.12.0");
3267

3268 3269
    DO_TEST_CAPS_LATEST("vhost-user-fs-fd-memory");
    DO_TEST_CAPS_LATEST("vhost-user-fs-hugepages");
3270
    DO_TEST_CAPS_LATEST_PARSE_ERROR("vhost-user-fs-readonly");
3271

L
Lubomir Rintel 已提交
3272 3273
    DO_TEST("riscv64-virt",
            QEMU_CAPS_DEVICE_VIRTIO_MMIO);
3274 3275
    DO_TEST("riscv64-virt-pci",
            QEMU_CAPS_OBJECT_GPEX);
L
Lubomir Rintel 已提交
3276

3277 3278 3279 3280 3281
    /* Older version checks disable-legacy usage */
    DO_TEST_CAPS_VER("virtio-transitional", "3.1.0");
    DO_TEST_CAPS_VER("virtio-non-transitional", "3.1.0");
    DO_TEST_CAPS_LATEST("virtio-transitional");
    DO_TEST_CAPS_LATEST("virtio-non-transitional");
3282
    DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-transitional-not-supported");
3283

3284 3285 3286 3287 3288 3289 3290 3291
    /* Simple headless guests for various architectures */
    DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-headless", "aarch64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-pseries-headless", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-headless", "riscv64");
    DO_TEST_CAPS_ARCH_LATEST("s390x-ccw-headless", "s390x");
    DO_TEST_CAPS_ARCH_LATEST("x86_64-pc-headless", "x86_64");
    DO_TEST_CAPS_ARCH_LATEST("x86_64-q35-headless", "x86_64");

3292 3293 3294
    /* Simple guests with graphics for various architectures */
    DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-graphics", "aarch64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-pseries-graphics", "ppc64");
3295
    DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-graphics", "riscv64");
3296
    DO_TEST_CAPS_ARCH_LATEST("s390x-ccw-graphics", "s390x");
3297 3298 3299
    DO_TEST_CAPS_ARCH_LATEST("x86_64-pc-graphics", "x86_64");
    DO_TEST_CAPS_ARCH_LATEST("x86_64-q35-graphics", "x86_64");

3300 3301 3302 3303 3304
    DO_TEST_CAPS_LATEST("os-firmware-bios");
    DO_TEST_CAPS_LATEST("os-firmware-efi");
    DO_TEST_CAPS_LATEST("os-firmware-efi-secboot");
    DO_TEST_CAPS_ARCH_LATEST("aarch64-os-firmware-efi", "aarch64");

3305 3306 3307
    DO_TEST_CAPS_LATEST("vhost-user-vga");
    DO_TEST_CAPS_LATEST("vhost-user-gpu-secondary");

3308 3309 3310
    DO_TEST_CAPS_VER("cpu-Icelake-Server-pconfig", "3.1.0");
    DO_TEST_CAPS_LATEST("cpu-Icelake-Server-pconfig");

3311 3312
    DO_TEST_CAPS_ARCH_LATEST("aarch64-default-cpu-kvm-virt-4.2", "aarch64");
    DO_TEST_CAPS_ARCH_LATEST("aarch64-default-cpu-tcg-virt-4.2", "aarch64");
3313 3314 3315 3316 3317 3318
    DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-kvm-pseries-2.7", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-tcg-pseries-2.7", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-kvm-pseries-3.1", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-tcg-pseries-3.1", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-kvm-pseries-4.2", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-tcg-pseries-4.2", "ppc64");
3319 3320
    DO_TEST_CAPS_ARCH_LATEST("s390-default-cpu-kvm-ccw-virtio-2.7", "s390x");
    DO_TEST_CAPS_ARCH_LATEST("s390-default-cpu-tcg-ccw-virtio-2.7", "s390x");
3321 3322
    DO_TEST_CAPS_ARCH_LATEST("s390-default-cpu-kvm-ccw-virtio-4.2", "s390x");
    DO_TEST_CAPS_ARCH_LATEST("s390-default-cpu-tcg-ccw-virtio-4.2", "s390x");
3323 3324 3325 3326
    DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-kvm-pc-4.2", "x86_64");
    DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-tcg-pc-4.2", "x86_64");
    DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-kvm-q35-4.2", "x86_64");
    DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-tcg-q35-4.2", "x86_64");
3327

3328 3329
    DO_TEST_CAPS_LATEST("virtio-9p-multidevs");

3330 3331 3332
    if (getenv("LIBVIRT_SKIP_CLEANUP") == NULL)
        virFileDeleteTree(fakerootdir);

3333
    VIR_FREE(driver.config->nbdTLSx509certdir);
3334
    qemuTestDriverFree(&driver);
3335
    VIR_FREE(fakerootdir);
3336
    virHashFree(capslatest);
3337
    virFileWrapperClearPrefixes();
3338

3339
    return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
3340 3341
}

3342
VIR_TEST_MAIN_PRELOAD(mymain,
3343
                      VIR_TEST_MOCK("qemuxml2argv"),
M
Michal Privoznik 已提交
3344
                      VIR_TEST_MOCK("domaincaps"),
3345 3346 3347
                      VIR_TEST_MOCK("virrandom"),
                      VIR_TEST_MOCK("qemucpu"),
                      VIR_TEST_MOCK("virpci"))
3348

3349 3350
#else

3351 3352 3353 3354
int main(void)
{
    return EXIT_AM_SKIP;
}
3355 3356

#endif /* WITH_QEMU */