static void add_pc_test_case(const char *mname)
{
char *path;
PlugTestData *data;
if (!g_str_has_prefix(mname, "pc-")) {
return;
}
data = g_new(PlugTestData, 1);
data->machine = g_strdup(mname);
data->cpu_model = "Haswell"; /* 1.3+ theoretically */
data->device_model = g_strdup_printf("%s-%s-cpu", data->cpu_model,
qtest_get_arch());
data->sockets = 1;
data->cores = 3;
data->threads = 2;
data->maxcpus = data->sockets * data->cores * data->threads;
if (g_str_has_suffix(mname, "-1.4") ||
(strcmp(mname, "pc-1.3") == 0) ||
(strcmp(mname, "pc-1.2") == 0) ||
(strcmp(mname, "pc-1.1") == 0) ||
(strcmp(mname, "pc-1.0") == 0) ||
(strcmp(mname, "pc-0.15") == 0) ||
(strcmp(mname, "pc-0.14") == 0) ||
(strcmp(mname, "pc-0.13") == 0) ||
(strcmp(mname, "pc-0.12") == 0)) {
path = g_strdup_printf("cpu-plug/%s/init/%ux%ux%u&maxcpus=%u",
mname, data->sockets, data->cores,
data->threads, data->maxcpus);
qtest_add_data_func_full(path, data, test_plug_without_cpu_add,
test_data_free);
g_free(path);
} else {
PlugTestData *data2 = g_memdup(data, sizeof(PlugTestData));
data2->machine = g_strdup(data->machine);
data2->device_model = g_strdup(data->device_model);
path = g_strdup_printf("cpu-plug/%s/cpu-add/%ux%ux%u&maxcpus=%u",
mname, data->sockets, data->cores,
data->threads, data->maxcpus);
qtest_add_data_func_full(path, data, test_plug_with_cpu_add,
test_data_free);
g_free(path);
path = g_strdup_printf("cpu-plug/%s/device-add/%ux%ux%u&maxcpus=%u",
mname, data2->sockets, data2->cores,
data2->threads, data2->maxcpus);
qtest_add_data_func_full(path, data2, test_plug_with_device_add_x86,
test_data_free);
g_free(path);
}
}
/*
* Wait for some output in the serial output file,
* we get an 'A' followed by an endless string of 'B's
* but on the destination we won't have the A.
*/
static void wait_for_serial(const char *side)
{
char *serialpath = g_strdup_printf("%s/%s", tmpfs, side);
FILE *serialfile = fopen(serialpath, "r");
const char *arch = qtest_get_arch();
int started = (strcmp(side, "src_serial") == 0 &&
strcmp(arch, "ppc64") == 0) ? 0 : 1;
g_free(serialpath);
do {
int readvalue = fgetc(serialfile);
if (!started) {
/* SLOF prints its banner before starting test,
* to ignore it, mark the start of the test with '_',
* ignore all characters until this marker
*/
switch (readvalue) {
case '_':
started = 1;
break;
case EOF:
fseek(serialfile, 0, SEEK_SET);
usleep(1000);
break;
}
continue;
}
switch (readvalue) {
case 'A':
/* Fine */
break;
case 'B':
/* It's alive! */
fclose(serialfile);
return;
case EOF:
started = (strcmp(side, "src_serial") == 0 &&
strcmp(arch, "ppc64") == 0) ? 0 : 1;
fseek(serialfile, 0, SEEK_SET);
usleep(1000);
break;
default:
fprintf(stderr, "Unexpected %d on %s serial\n", readvalue, side);
g_assert_not_reached();
}
} while (true);
}
int main(int argc, char **argv)
{
const char *arch = qtest_get_arch();
char *cmdline;
int fd;
int ret;
/* Check architecture */
if (strcmp(arch, "i386") && strcmp(arch, "x86_64")) {
g_test_message("Skipping test for non-x86\n");
return 0;
}
/* Create a temporary raw image */
fd = mkstemp(test_image);
g_assert(fd >= 0);
ret = ftruncate(fd, TEST_IMAGE_SIZE);
g_assert(ret == 0);
close(fd);
/* Run the tests */
g_test_init(&argc, &argv, NULL);
cmdline = g_strdup_printf("-vnc none ");
qtest_start(cmdline);
qtest_irq_intercept_in(global_qtest, "ioapic");
qtest_add_func("/fdc/cmos", test_cmos);
qtest_add_func("/fdc/no_media_on_start", test_no_media_on_start);
qtest_add_func("/fdc/read_without_media", test_read_without_media);
qtest_add_func("/fdc/media_change", test_media_change);
qtest_add_func("/fdc/sense_interrupt", test_sense_interrupt);
qtest_add_func("/fdc/relative_seek", test_relative_seek);
qtest_add_func("/fdc/read_id", test_read_id);
qtest_add_func("/fdc/verify", test_verify);
qtest_add_func("/fdc/media_insert", test_media_insert);
qtest_add_func("/fdc/read_no_dma_1", test_read_no_dma_1);
qtest_add_func("/fdc/read_no_dma_18", test_read_no_dma_18);
qtest_add_func("/fdc/read_no_dma_19", test_read_no_dma_19);
qtest_add_func("/fdc/fuzz-registers", fuzz_registers);
ret = g_test_run();
/* Cleanup */
qtest_end();
unlink(test_image);
return ret;
}
static void test_ivshmem_hotplug(void)
{
const char *arch = qtest_get_arch();
qtest_start("-object memory-backend-ram,size=1M,id=mb1");
qtest_qmp_device_add("ivshmem-plain", "iv1",
"{'addr': %s, 'memdev': 'mb1'}",
stringify(PCI_SLOT_HP));
if (strcmp(arch, "ppc64") != 0) {
qpci_unplug_acpi_device_test("iv1", PCI_SLOT_HP);
}
qtest_end();
}
int main(int argc, char **argv)
{
const char *arch = qtest_get_arch();
g_test_init(&argc, &argv, NULL);
if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
qtest_cb_for_every_machine(add_pc_test_case, g_test_quick());
} else if (g_str_equal(arch, "ppc64")) {
qtest_cb_for_every_machine(add_pseries_test_case, g_test_quick());
} else if (g_str_equal(arch, "s390x")) {
qtest_cb_for_every_machine(add_s390x_test_case, g_test_quick());
}
return g_test_run();
}
static QOSState *qvirtio_scsi_start(const char *extra_opts)
{
const char *arch = qtest_get_arch();
const char *cmd = "-drive id=drv0,if=none,file=null-co://,format=raw "
"-device virtio-scsi-pci,id=vs0 "
"-device scsi-hd,bus=vs0.0,drive=drv0 %s";
if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
return qtest_pc_boot(cmd, extra_opts ? : "");
}
if (strcmp(arch, "ppc64") == 0) {
return qtest_spapr_boot(cmd, extra_opts ? : "");
}
g_printerr("virtio-scsi tests are only available on x86 or ppc64\n");
exit(EXIT_FAILURE);
}
int main(int argc, char *argv[])
{
const char *arch = qtest_get_arch();
int i;
g_test_init(&argc, &argv, NULL);
for (i = 0; tests[i].arch != NULL; i++) {
if (strcmp(arch, tests[i].arch) == 0) {
char *name = g_strdup_printf("boot-serial/%s", tests[i].machine);
qtest_add_data_func(name, &tests[i], test_machine);
g_free(name);
}
}
return g_test_run();
}
/* Create boot disk file. */
int boot_sector_init(char *fname)
{
int fd, ret;
size_t len;
char *boot_code;
const char *arch = qtest_get_arch();
fd = mkstemp(fname);
if (fd < 0) {
fprintf(stderr, "Couldn't open \"%s\": %s", fname, strerror(errno));
return 1;
}
if (g_str_equal(arch, "i386") || g_str_equal(arch, "x86_64")) {
/* Q35 requires a minimum 0x7e000 bytes disk (bug or feature?) */
len = MAX(0x7e000, sizeof(x86_boot_sector));
boot_code = g_malloc0(len);
memcpy(boot_code, x86_boot_sector, sizeof(x86_boot_sector));
} else if (g_str_equal(arch, "ppc64")) {
/* For Open Firmware based system, use a Forth script */
boot_code = g_strdup_printf("\\ Bootscript\n%x %x c! %x %x c!\n",
LOW(SIGNATURE), SIGNATURE_ADDR,
HIGH(SIGNATURE), SIGNATURE_ADDR + 1);
len = strlen(boot_code);
} else if (g_str_equal(arch, "s390x")) {
len = 0x10000 + sizeof(s390x_code);
boot_code = g_malloc0(len);
memcpy(boot_code, s390x_psw, sizeof(s390x_psw));
memcpy(&boot_code[0x10000], s390x_code, sizeof(s390x_code));
} else {
g_assert_not_reached();
}
ret = write(fd, boot_code, len);
close(fd);
g_free(boot_code);
if (ret != len) {
fprintf(stderr, "Could not write \"%s\"", fname);
return 1;
}
return 0;
}
int main(int argc, char *argv[])
{
int ret;
const char *arch = qtest_get_arch();
ret = boot_sector_init(disk);
if(ret)
return ret;
g_test_init(&argc, &argv, NULL);
if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
qtest_add_func("pxe/e1000", test_pxe_e1000);
qtest_add_func("pxe/virtio", test_pxe_virtio_pci);
}
ret = g_test_run();
boot_sector_cleanup(disk);
return ret;
}
static QOSState *qvirtio_9p_start(void)
{
const char *arch = qtest_get_arch();
const char *cmd = "-fsdev local,id=fsdev0,security_model=none,path=%s "
"-device virtio-9p-pci,fsdev=fsdev0,mount_tag=%s";
test_share = g_strdup("/tmp/qtest.XXXXXX");
g_assert_nonnull(mkdtemp(test_share));
if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
return qtest_pc_boot(cmd, test_share, mount_tag);
}
if (strcmp(arch, "ppc64") == 0) {
return qtest_spapr_boot(cmd, test_share, mount_tag);
}
g_printerr("virtio-9p tests are only available on x86 or ppc64\n");
exit(EXIT_FAILURE);
}
/* Create boot disk file. */
int boot_sector_init(const char *fname)
{
FILE *f = fopen(fname, "w");
if (!f) {
fprintf(stderr, "Couldn't open \"%s\": %s", fname, strerror(errno));
return 1;
}
/* For Open Firmware based system, we can use a Forth script instead */
if (strcmp(qtest_get_arch(), "ppc64") == 0) {
memset(boot_sector, ' ', sizeof boot_sector);
sprintf((char *)boot_sector, "\\ Bootscript\n%x %x c! %x %x c!\n",
LOW(SIGNATURE), BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET,
HIGH(SIGNATURE), BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET + 1);
}
fwrite(boot_sector, 1, sizeof boot_sector, f);
fclose(f);
return 0;
}
static QVirtIO9P *qvirtio_9p_start(const char *driver)
{
const char *arch = qtest_get_arch();
const char *cmd = "-fsdev local,id=fsdev0,security_model=none,path=%s "
"-device %s,fsdev=fsdev0,mount_tag=%s";
QVirtIO9P *v9p = g_new0(QVirtIO9P, 1);
v9p->test_share = g_strdup("/tmp/qtest.XXXXXX");
g_assert_nonnull(mkdtemp(v9p->test_share));
if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
v9p->qs = qtest_pc_boot(cmd, v9p->test_share, driver, mount_tag);
} else if (strcmp(arch, "ppc64") == 0) {
v9p->qs = qtest_spapr_boot(cmd, v9p->test_share, driver, mount_tag);
} else {
g_printerr("virtio-9p tests are only available on x86 or ppc64\n");
exit(EXIT_FAILURE);
}
return v9p;
}
int main(int argc, char *argv[])
{
const char *sparc_machines[] = { "SPARCbook", "Voyager", "SS-20", NULL };
const char *sparc64_machines[] = { "sun4u", "sun4v", NULL };
const char *mac_machines[] = { "mac99", "g3beige", NULL };
const char *arch = qtest_get_arch();
g_test_init(&argc, &argv, NULL);
if (!strcmp(arch, "ppc") || !strcmp(arch, "ppc64")) {
add_tests(mac_machines);
} else if (!strcmp(arch, "sparc")) {
add_tests(sparc_machines);
} else if (!strcmp(arch, "sparc64")) {
add_tests(sparc64_machines);
} else {
g_assert_not_reached();
}
return g_test_run();
}
int main(int argc, char *argv[])
{
const char *arch = qtest_get_arch();
g_test_init(&argc, &argv, NULL);
if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
qtest_add_func("boot-order/pc", test_pc_boot_order);
} else if (strcmp(arch, "ppc") == 0 || strcmp(arch, "ppc64") == 0) {
qtest_add_func("boot-order/prep", test_prep_boot_order);
qtest_add_func("boot-order/pmac_oldworld",
test_pmac_oldworld_boot_order);
qtest_add_func("boot-order/pmac_newworld",
test_pmac_newworld_boot_order);
} else if (strcmp(arch, "sparc") == 0) {
qtest_add_func("boot-order/sun4m", test_sun4m_boot_order);
} else if (strcmp(arch, "sparc64") == 0) {
qtest_add_func("boot-order/sun4u", test_sun4u_boot_order);
}
return g_test_run();
}
int main(int argc, char **argv)
{
int ret, fd;
const char *arch = qtest_get_arch();
gchar dir[] = "/tmp/ivshmem-test.XXXXXX";
g_test_init(&argc, &argv, NULL);
qtest_add_abrt_handler(abrt_handler, NULL);
/* shm */
tmpshm = mktempshm(TMPSHMSIZE, &fd);
if (!tmpshm) {
goto out;
}
tmpshmem = mmap(0, TMPSHMSIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
g_assert(tmpshmem != MAP_FAILED);
/* server */
if (mkdtemp(dir) == NULL) {
g_error("mkdtemp: %s", g_strerror(errno));
}
tmpdir = dir;
tmpserver = g_strconcat(tmpdir, "/server", NULL);
qtest_add_func("/ivshmem/single", test_ivshmem_single);
qtest_add_func("/ivshmem/hotplug", test_ivshmem_hotplug);
qtest_add_func("/ivshmem/memdev", test_ivshmem_memdev);
if (g_test_slow()) {
qtest_add_func("/ivshmem/pair", test_ivshmem_pair);
if (strcmp(arch, "ppc64") != 0) {
qtest_add_func("/ivshmem/server", test_ivshmem_server);
}
}
out:
ret = g_test_run();
cleanup();
return ret;
}
static void test_migrate(void)
{
char *uri = g_strdup_printf("unix:%s/migsocket", tmpfs);
QTestState *global = global_qtest, *from, *to;
unsigned char dest_byte_a, dest_byte_b, dest_byte_c, dest_byte_d;
gchar *cmd, *cmd_src, *cmd_dst;
QDict *rsp;
char *bootpath = g_strdup_printf("%s/bootsect", tmpfs);
const char *arch = qtest_get_arch();
got_stop = false;
if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
init_bootfile_x86(bootpath);
cmd_src = g_strdup_printf("-machine accel=kvm:tcg -m 150M"
" -name pcsource,debug-threads=on"
" -serial file:%s/src_serial"
" -drive file=%s,format=raw",
tmpfs, bootpath);
cmd_dst = g_strdup_printf("-machine accel=kvm:tcg -m 150M"
" -name pcdest,debug-threads=on"
" -serial file:%s/dest_serial"
" -drive file=%s,format=raw"
" -incoming %s",
tmpfs, bootpath, uri);
} else if (strcmp(arch, "ppc64") == 0) {
init_bootfile_ppc(bootpath);
cmd_src = g_strdup_printf("-machine accel=kvm:tcg -m 256M"
" -name pcsource,debug-threads=on"
" -serial file:%s/src_serial"
" -drive file=%s,if=pflash,format=raw",
tmpfs, bootpath);
cmd_dst = g_strdup_printf("-machine accel=kvm:tcg -m 256M"
" -name pcdest,debug-threads=on"
" -serial file:%s/dest_serial"
" -incoming %s",
tmpfs, uri);
} else {
g_assert_not_reached();
}
g_free(bootpath);
from = qtest_start(cmd_src);
g_free(cmd_src);
to = qtest_init(cmd_dst);
g_free(cmd_dst);
global_qtest = from;
rsp = qmp("{ 'execute': 'migrate-set-capabilities',"
"'arguments': { "
"'capabilities': [ {"
"'capability': 'postcopy-ram',"
"'state': true } ] } }");
g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp);
global_qtest = to;
rsp = qmp("{ 'execute': 'migrate-set-capabilities',"
"'arguments': { "
"'capabilities': [ {"
"'capability': 'postcopy-ram',"
"'state': true } ] } }");
g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp);
/* We want to pick a speed slow enough that the test completes
* quickly, but that it doesn't complete precopy even on a slow
* machine, so also set the downtime.
*/
global_qtest = from;
rsp = qmp("{ 'execute': 'migrate_set_speed',"
"'arguments': { 'value': 100000000 } }");
g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp);
/* 1ms downtime - it should never finish precopy */
rsp = qmp("{ 'execute': 'migrate_set_downtime',"
"'arguments': { 'value': 0.001 } }");
g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp);
/* Wait for the first serial output from the source */
wait_for_serial("src_serial");
cmd = g_strdup_printf("{ 'execute': 'migrate',"
"'arguments': { 'uri': '%s' } }",
uri);
rsp = qmp(cmd);
g_free(cmd);
g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp);
wait_for_migration_pass();
rsp = return_or_event(qmp("{ 'execute': 'migrate-start-postcopy' }"));
g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp);
if (!got_stop) {
qmp_eventwait("STOP");
}
global_qtest = to;
qmp_eventwait("RESUME");
wait_for_serial("dest_serial");
global_qtest = from;
wait_for_migration_complete();
qtest_quit(from);
global_qtest = to;
qtest_memread(to, start_address, &dest_byte_a, 1);
/* Destination still running, wait for a byte to change */
do {
qtest_memread(to, start_address, &dest_byte_b, 1);
usleep(10 * 1000);
} while (dest_byte_a == dest_byte_b);
qmp("{ 'execute' : 'stop'}");
/* With it stopped, check nothing changes */
qtest_memread(to, start_address, &dest_byte_c, 1);
sleep(1);
qtest_memread(to, start_address, &dest_byte_d, 1);
g_assert_cmpint(dest_byte_c, ==, dest_byte_d);
check_guests_ram();
qtest_quit(to);
g_free(uri);
global_qtest = global;
cleanup("bootsect");
cleanup("migsocket");
cleanup("src_serial");
cleanup("dest_serial");
}
static void test_migrate_start(QTestState **from, QTestState **to,
const char *uri, bool hide_stderr)
{
gchar *cmd_src, *cmd_dst;
char *bootpath = g_strdup_printf("%s/bootsect", tmpfs);
const char *arch = qtest_get_arch();
const char *accel = "kvm:tcg";
got_stop = false;
if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
init_bootfile_x86(bootpath);
cmd_src = g_strdup_printf("-machine accel=%s -m 150M"
" -name source,debug-threads=on"
" -serial file:%s/src_serial"
" -drive file=%s,format=raw",
accel, tmpfs, bootpath);
cmd_dst = g_strdup_printf("-machine accel=%s -m 150M"
" -name target,debug-threads=on"
" -serial file:%s/dest_serial"
" -drive file=%s,format=raw"
" -incoming %s",
accel, tmpfs, bootpath, uri);
} else if (strcmp(arch, "ppc64") == 0) {
/* On ppc64, the test only works with kvm-hv, but not with kvm-pr */
if (access("/sys/module/kvm_hv", F_OK)) {
accel = "tcg";
}
init_bootfile_ppc(bootpath);
cmd_src = g_strdup_printf("-machine accel=%s -m 256M"
" -name source,debug-threads=on"
" -serial file:%s/src_serial"
" -drive file=%s,if=pflash,format=raw",
accel, tmpfs, bootpath);
cmd_dst = g_strdup_printf("-machine accel=%s -m 256M"
" -name target,debug-threads=on"
" -serial file:%s/dest_serial"
" -incoming %s",
accel, tmpfs, uri);
} else {
g_assert_not_reached();
}
g_free(bootpath);
if (hide_stderr) {
gchar *tmp;
tmp = g_strdup_printf("%s 2>/dev/null", cmd_src);
g_free(cmd_src);
cmd_src = tmp;
tmp = g_strdup_printf("%s 2>/dev/null", cmd_dst);
g_free(cmd_dst);
cmd_dst = tmp;
}
*from = qtest_start(cmd_src);
g_free(cmd_src);
*to = qtest_init(cmd_dst);
g_free(cmd_dst);
}
int main(int argc, char **argv)
{
int ret;
const char *arch = qtest_get_arch();
const char *genisocheck[] = { "genisoimage", "-version", NULL };
g_test_init(&argc, &argv, NULL);
if (exec_genisoimg(genisocheck)) {
/* genisoimage not available - so can't run tests */
return g_test_run();
}
ret = prepare_image(arch, isoimage);
if (ret) {
return ret;
}
if (g_str_equal(arch, "i386") || g_str_equal(arch, "x86_64")) {
add_x86_tests();
} else if (g_str_equal(arch, "s390x")) {
add_s390x_tests();
} else if (g_str_equal(arch, "ppc64")) {
const char *ppcmachines[] = {
"pseries", "mac99", "g3beige", "40p", "prep", NULL
};
add_cdrom_param_tests(ppcmachines);
} else if (g_str_equal(arch, "sparc")) {
const char *sparcmachines[] = {
"LX", "SPARCClassic", "SPARCbook", "SS-10", "SS-20", "SS-4",
"SS-5", "SS-600MP", "Voyager", "leon3_generic", NULL
};
add_cdrom_param_tests(sparcmachines);
} else if (g_str_equal(arch, "sparc64")) {
const char *sparc64machines[] = {
"niagara", "sun4u", "sun4v", NULL
};
add_cdrom_param_tests(sparc64machines);
} else if (!strncmp(arch, "mips64", 6)) {
const char *mips64machines[] = {
"magnum", "malta", "mips", "pica61", NULL
};
add_cdrom_param_tests(mips64machines);
} else if (g_str_equal(arch, "arm") || g_str_equal(arch, "aarch64")) {
const char *armmachines[] = {
"realview-eb", "realview-eb-mpcore", "realview-pb-a8",
"realview-pbx-a9", "versatileab", "versatilepb", "vexpress-a15",
"vexpress-a9", "virt", NULL
};
add_cdrom_param_tests(armmachines);
} else {
const char *nonemachine[] = { "none", NULL };
add_cdrom_param_tests(nonemachine);
}
ret = g_test_run();
unlink(isoimage);
return ret;
}
int main(int argc, char **argv)
{
const char *arch = qtest_get_arch();
g_test_init(&argc, &argv, NULL);
add_test_cases(arch, "none");
if (strcmp(arch, "i386") == 0 ||
strcmp(arch, "x86_64") == 0) {
ADD_MACHINE_TESTS(arch, x86_machines);
} else if (strcmp(arch, "alpha") == 0) {
ADD_MACHINE_TESTS(arch, alpha_machines);
} else if (strcmp(arch, "arm") == 0) {
ADD_MACHINE_TESTS(arch, arm_machines);
} else if (strcmp(arch, "cris") == 0) {
ADD_MACHINE_TESTS(arch, cris_machines);
} else if (strcmp(arch, "lm32") == 0) {
ADD_MACHINE_TESTS(arch, lm32_machines);
} else if (strcmp(arch, "m68k") == 0) {
ADD_MACHINE_TESTS(arch, m68k_machines);
} else if (strcmp(arch, "microblaze") == 0 ||
strcmp(arch, "microblazeel") == 0) {
ADD_MACHINE_TESTS(arch, microblaze_machines);
} else if (strcmp(arch, "mips") == 0 ||
strcmp(arch, "mipsel") == 0 ||
strcmp(arch, "mips64") == 0) {
ADD_MACHINE_TESTS(arch, mips_machines);
} else if (strcmp(arch, "mips64el") == 0) {
ADD_MACHINE_TESTS(arch, mips_machines);
add_test_cases(arch, "fulong2e");
} else if (strcmp(arch, "moxie") == 0) {
ADD_MACHINE_TESTS(arch, moxie_machines);
} else if (strcmp(arch, "or32") == 0) {
ADD_MACHINE_TESTS(arch, openrisc_machines);
} else if (strcmp(arch, "ppcemb") == 0) {
#if 0
/* XXX Available in ppcemb but don't work */
ADD_MACHINE_TESTS(arch, ppc405_machines);
#endif
ADD_MACHINE_TESTS(arch, ppc440_machines);
} else if (strcmp(arch, "ppc") == 0) {
ADD_MACHINE_TESTS(arch, ppc405_machines);
ADD_MACHINE_TESTS(arch, ppc440_machines);
ADD_MACHINE_TESTS(arch, ppc_machines);
} else if (strcmp(arch, "ppc64") == 0) {
ADD_MACHINE_TESTS(arch, ppc405_machines);
ADD_MACHINE_TESTS(arch, ppc440_machines);
ADD_MACHINE_TESTS(arch, ppc_machines);
ADD_MACHINE_TESTS(arch, ppc64_machines);
} else if (strcmp(arch, "s390x") == 0) {
ADD_MACHINE_TESTS(arch, s390_machines);
} else if (strcmp(arch, "sh4") == 0 ||
strcmp(arch, "sh4eb") == 0) {
ADD_MACHINE_TESTS(arch, superh_machines);
} else if (strcmp(arch, "sparc") == 0) {
ADD_MACHINE_TESTS(arch, sparc_machines);
} else if (strcmp(arch, "sparc64") == 0) {
ADD_MACHINE_TESTS(arch, sparc64_machines);
} else if (strcmp(arch, "unicore32") == 0) {
ADD_MACHINE_TESTS(arch, unicore32_machines);
} else if (strcmp(arch, "xtensa") == 0 ||
strcmp(arch, "xtensaeb") == 0) {
ADD_MACHINE_TESTS(arch, xtensa_machines);
}
return g_test_run();
}
