static void TEST_UTIL(void)
{
DO_TEST(TEST_UTIL_Log);
DO_TEST(TEST_CORE_GetUsername);
DO_TEST(TEST_UTIL_MatchesMask);
DO_TEST(TEST_CORE_GetVMPageSize);
}
int
main(int argc, char** argv)
{
if (DO_TEST(1)) {
std::cout << "Test returns true for 1" << std::endl;
} else {
std::cout << "Test returns false for 1" << std::endl;
}
if (DO_TEST(0)) {
std::cout << "Test returns true for 0" << std::endl;
} else {
std::cout << "Test returns false for 0" << std::endl;
}
if (DO_TEST(1 != 0)) {
std::cout << "Test returns true for 1 != 0" << std::endl;
} else {
std::cout << "Test returns false for 1 != 0" << std::endl;
}
bool y = DO_TEST(3);
if (y) {
std::cout << "Test returns true for 3" << std::endl;
} else {
std::cout << "Test returns false for 3" << std::endl;
}
}
static void TEST_CORE(void)
{
/* Do all TEST_CORE_***() tests */
DO_TEST(TEST_CORE_Io);
DO_TEST(TEST_CORE_Lock);
DO_TEST(TEST_CORE_Log);
}
static int
mymain(void)
{
int ret = 0;
if (VIR_ALLOC(testSnapshotXMLVariableLineRegex) < 0)
goto cleanup;
if (regcomp(testSnapshotXMLVariableLineRegex,
testSnapshotXMLVariableLineRegexStr,
REG_EXTENDED | REG_NOSUB) != 0) {
ret = -1;
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
"failed to compile test regex");
goto cleanup;
}
# define DO_TEST(name) \
if (virTestRun("VBox Snapshot XML-2-XML " name, \
testCompareXMLToXMLHelper, (name)) < 0) \
ret = -1
DO_TEST("2disks-nosnap");
DO_TEST("2disks-1snap");
DO_TEST("2disks-2snap");
DO_TEST("2disks-3snap");
DO_TEST("2disks-3snap-brother");
cleanup:
if (testSnapshotXMLVariableLineRegex)
regfree(testSnapshotXMLVariableLineRegex);
VIR_FREE(testSnapshotXMLVariableLineRegex);
return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
static int
mymain(void)
{
int ret = 0;
virCapsPtr caps;
if (virThreadInitialize() < 0)
exit(EXIT_FAILURE);
if (!(caps = testQemuCapsInit()))
exit(EXIT_FAILURE);
virEventRegisterDefaultImpl();
#define DO_TEST(name) \
if (virtTestRun(# name, 1, testQemuMonitorJSON ## name, caps) < 0) \
ret = -1
DO_TEST(GetStatus);
DO_TEST(GetVersion);
DO_TEST(GetMachines);
DO_TEST(GetCPUDefinitions);
DO_TEST(GetCommands);
virObjectUnref(caps);
return (ret == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
int test_main(void)
{
int rc = 0;
pj_caching_pool caching_pool;
pj_init();
pj_caching_pool_init(&caching_pool, &pj_pool_factory_default_policy, 0);
pj_log_set_decor(PJ_LOG_HAS_NEWLINE);
pj_log_set_level(3);
mem = &caching_pool.factory;
DO_TEST(sdp_neg_test());
//DO_TEST(sdp_test (&caching_pool.factory));
//DO_TEST(rtp_test(&caching_pool.factory));
//DO_TEST(session_test (&caching_pool.factory));
DO_TEST(jbuf_main());
DO_TEST(mips_test());
DO_TEST(codec_test_vectors());
PJ_LOG(3,(THIS_FILE," "));
on_return:
if (rc != 0) {
PJ_LOG(3,(THIS_FILE,"Test completed with error(s)!"));
} else {
PJ_LOG(3,(THIS_FILE,"Looks like everything is okay!"));
}
pj_caching_pool_destroy(&caching_pool);
return rc;
}
static int
mymain(void)
{
int ret = 0;
testQemuData data;
#if !WITH_YAJL
fputs("libvirt not compiled with yajl, skipping this test\n", stderr);
return EXIT_AM_SKIP;
#endif
if (virThreadInitialize() < 0)
return EXIT_FAILURE;
virEventRegisterDefaultImpl();
#define DO_TEST_FULL(name, guest) \
data.base = name; \
data.guestarch = guest; \
if (virtTestRun(name, testQemuCapsXML, &data) < 0) \
ret = -1
#define DO_TEST(name) DO_TEST_FULL(name, VIR_ARCH_I686)
DO_TEST("all_1.6.0-1");
DO_TEST("nodisksnapshot_1.6.0-1");
return (ret == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
static int
mymain(void)
{
int ret = 0;
if ((caps = testLXCCapsInit()) == NULL)
return EXIT_FAILURE;
# define DO_TEST_FULL(name, is_different, inactive) \
do { \
const struct testInfo info = {name, is_different, inactive}; \
if (virtTestRun("LXC XML-2-XML " name, \
1, testCompareXMLToXMLHelper, &info) < 0) \
ret = -1; \
} while (0)
# define DO_TEST(name) \
DO_TEST_FULL(name, 0, false)
# define DO_TEST_DIFFERENT(name) \
DO_TEST_FULL(name, 1, false)
/* Unset or set all envvars here that are copied in lxcdBuildCommandLine
* using ADD_ENV_COPY, otherwise these tests may fail due to unexpected
* values for these envvars */
setenv("PATH", "/bin", 1);
DO_TEST("systemd");
DO_TEST("hostdev");
virObjectUnref(caps);
return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
static int
mymain(int argc, char **argv)
{
int ret = 0;
char cwd[PATH_MAX];
progname = argv[0];
if (argc > 1) {
fprintf(stderr, "Usage: %s\n", progname);
return (EXIT_FAILURE);
}
abs_srcdir = getenv("abs_srcdir");
if (!abs_srcdir)
abs_srcdir = getcwd(cwd, sizeof(cwd));
#define DO_TEST(name) \
if (virtTestRun("Network XML-2-XML " name, \
1, testCompareXMLToXMLHelper, (name)) < 0) \
ret = -1
DO_TEST("isolated-network");
DO_TEST("routed-network");
DO_TEST("nat-network");
DO_TEST("netboot-network");
DO_TEST("netboot-proxy-network");
return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
static int
mymain(void)
{
int ret = 0;
if (!(caps = testXLInitCaps()))
return EXIT_FAILURE;
if (!(xmlopt = libxlCreateXMLConf()))
return EXIT_FAILURE;
#define DO_TEST_PARSE(name) \
do { \
struct testInfo info0 = { name, 0 }; \
if (virtTestRun("Xen XL-2-XML Parse " name, \
testCompareHelper, &info0) < 0) \
ret = -1; \
} while (0)
#define DO_TEST_FORMAT(name) \
do { \
struct testInfo info1 = { name, 1 }; \
if (virtTestRun("Xen XL-2-XML Format " name, \
testCompareHelper, &info1) < 0) \
ret = -1; \
} while (0)
#define DO_TEST(name) \
do { \
DO_TEST_PARSE(name); \
DO_TEST_FORMAT(name); \
} while (0)
DO_TEST("paravirt-maxvcpus");
DO_TEST("new-disk");
DO_TEST_FORMAT("disk-positional-parms-full");
DO_TEST_FORMAT("disk-positional-parms-partial");
DO_TEST("spice");
DO_TEST("spice-features");
DO_TEST("vif-rate");
DO_TEST("paravirt-cmdline");
DO_TEST_FORMAT("paravirt-cmdline-extra-root");
DO_TEST_FORMAT("paravirt-cmdline-bogus-extra-root");
DO_TEST("rbd-multihost-noauth");
#ifdef LIBXL_HAVE_BUILDINFO_USBDEVICE_LIST
DO_TEST("fullvirt-multiusb");
#endif
#ifdef LIBXL_HAVE_BUILDINFO_KERNEL
DO_TEST("fullvirt-direct-kernel-boot");
DO_TEST_FORMAT("fullvirt-direct-kernel-boot-extra");
DO_TEST_FORMAT("fullvirt-direct-kernel-boot-bogus-extra");
#endif
virObjectUnref(caps);
virObjectUnref(xmlopt);
return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main( int argc, char *argv[])
{
int failures = 0;
failures += DO_TEST( t_null_buffer);
failures += DO_TEST( t_no_clusters);
failures += DO_TEST( t_input_only);
failures += DO_TEST( t_output_only);
failures += DO_TEST( t_both);
return test_exit( failures);
}
int main(int argc, char *argv[])
{
int const n=1024;
float *x, *y, *z;
int i;
printf("OV_PLATFORM: %s\n", OV_PLATFORM);
printf("OV_FLOAT_WIDTH %d\n", OV_FLOAT_WIDTH);
x=(float*)malloc(sizeof(float)*(n));
y=(float*)calloc(n, sizeof(float));
z=(float*)calloc(n, sizeof(float));
/*
Init
*/
// float f=8388608.0f;
// float f=-2147483647.0f;
float f=-1.0e20;
int k=*(int*)&f;
printf("k=%d, f=%f\n", k, f);
while(fabs(f)>0.4f)
{
//printf("k=%d, f=%f\n", k, f);
for (i=0; i<n; i++)
{
// printf("k=%d, f=%f\n", k, f);
k--;
f=*(float*)&k;
x[i]=f;
}
//for (i=0; i<n; i++) printf("x[%d]=%f\n",i,x[i]);
DO_TEST(ov_floorf, floorf);
DO_TEST(ov_ceilf, ceilf);
if ((f<0.0f) && (f>-.5))
{
f=2147483647.0f;
k=*(int*)&f;
}
}
free(x);
free(y);
free(z);
printf("Passed all tests.\n");
return 0;
}
static int
mymain(void)
{
int ret = 0;
if ((driver.caps = testQemuCapsInit()) == NULL)
return EXIT_FAILURE;
# define DO_TEST(name, uuid, internal) \
do { \
const struct testInfo info = {name, uuid, internal}; \
if (virtTestRun("SNAPSHOT XML-2-XML " name, \
1, testCompareXMLToXMLHelper, &info) < 0) \
ret = -1; \
} while (0)
/* 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 */
setenv("PATH", "/bin", 1);
DO_TEST("all_parameters", "9d37b878-a7cc-9f9a-b78f-49b3abad25a8", 1);
DO_TEST("disk_snapshot", "c7a5fdbd-edaf-9455-926a-d65c16db1809", 1);
DO_TEST("full_domain", "c7a5fdbd-edaf-9455-926a-d65c16db1809", 1);
DO_TEST("noparent_nodescription_noactive", NULL, 0);
DO_TEST("noparent_nodescription", NULL, 1);
DO_TEST("noparent", "9d37b878-a7cc-9f9a-b78f-49b3abad25a8", 0);
DO_TEST("metadata", "c7a5fdbd-edaf-9455-926a-d65c16db1809", 0);
DO_TEST("external_vm", "c7a5fdbd-edaf-9455-926a-d65c16db1809", 0);
virObjectUnref(driver.caps);
return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
int
main()
{
// construction
{
std::string const s( "test" );
breath::string_argument
arg( s ) ;
DO_TEST( arg.value() == "test" ) ;
char const * s2 = "test-2" ;
breath::string_argument
arg2( s2 ) ;
DO_TEST(arg2.value() == "test-2" ) ;
}
}
int
main()
{
std::ostringstream oss ;
stream_guard const guard( std::cout, oss.rdbuf() ) ;
// TEST 1)
// check that 1 << 3 is output as "1 << 3", first, and not directly as "8"
BREATH_DUMP_EXPRESSION( 1 << 3 ) ;
DO_TEST( oss.str() == "1 << 3 = 8\n" ) ;
clear_stringstream( oss ) ;
// TEST 2)
// now check with some strings (gps ricordati di portare questo test nei
// test di BREATH_STRINGIZE (e controllare cosa dice lo standard)!)
BREATH_DUMP_EXPRESSION( "test" ) ;
DO_TEST( oss.str() == "\"test\" = test\n" ) ;
clear_stringstream( oss ) ;
// TEST 3)
// check that macros are expanded (the replacement lists here are
// intentionally not parenthesized, although we already have a
// separate parenthesis-test in place)
# define OBJECT_LIKE_DUMMY 1 << 3 * 2
# define FUNCTION_LIKE_DUMMY() 1 << 3 * 4
BREATH_DUMP_EXPRESSION( OBJECT_LIKE_DUMMY ) ;
DO_TEST( oss.str() == "1 << 3 * 2 = 64 [from: OBJECT_LIKE_DUMMY]\n" ) ;
clear_stringstream( oss ) ;
BREATH_DUMP_EXPRESSION( FUNCTION_LIKE_DUMMY() ) ;
DO_TEST( oss.str() == "1 << 3 * 4 = 4096 [from: FUNCTION_LIKE_DUMMY()]\n" ) ;
clear_stringstream( oss ) ;
// TEST 4)
// the one case that the macro doesn't detect: a macro that is object-like
// and expands to its own name (of course it's not important, but it's good
// to have a test here, in case I manage to detect it)
int BREATH_dummy = 1 ;
# define BREATH_dummy BREATH_dummy
BREATH_DUMP_EXPRESSION( BREATH_dummy ) ;
DO_TEST( oss.str() == "BREATH_dummy = 1\n" ) ;
clear_stringstream( oss ) ;
}
int main( int argc, char *argv[])
{
int failures = 0;
failures += DO_TEST( t_zcl_type_name);
return test_exit( failures);
}
int main( int argc, char *argv[])
{
int failures = 0;
failures += DO_TEST( t_memcheck);
return test_exit( failures);
}
static int
mymain(void)
{
int ret = 0;
if ((driver.caps = virBhyveCapsBuild()) == NULL)
return EXIT_FAILURE;
if ((driver.xmlopt = virDomainXMLOptionNew(NULL, NULL, NULL)) == NULL)
return EXIT_FAILURE;
# define DO_TEST(name) \
do { \
if (virtTestRun("BHYVE XML-2-ARGV " name, \
testCompareXMLToArgvHelper, name) < 0) \
ret = -1; \
} while (0)
DO_TEST("base");
DO_TEST("acpiapic");
DO_TEST("disk-cdrom");
DO_TEST("disk-virtio");
DO_TEST("macaddr");
DO_TEST("serial");
DO_TEST("console");
virObjectUnref(driver.caps);
virObjectUnref(driver.xmlopt);
return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
static int
mymain(void)
{
int ret = 0;
# define DO_TEST(name, family, ...) \
do { \
const char *addr[] = { __VA_ARGS__, NULL}; \
struct testNSSData data = { \
.hostname = name, .ipAddr = addr, .af = family, \
}; \
if (virTestRun(name, testGetHostByName, &data) < 0) \
ret = -1; \
} while (0)
# if !defined(LIBVIRT_NSS_GUEST)
DO_TEST("fedora", AF_INET, "192.168.122.197", "192.168.122.198", "192.168.122.199");
DO_TEST("gentoo", AF_INET, "192.168.122.254");
DO_TEST("gentoo", AF_INET6, "2001:1234:dead:beef::2");
DO_TEST("gentoo", AF_UNSPEC, "192.168.122.254");
DO_TEST("non-existent", AF_UNSPEC, NULL);
# else /* defined(LIBVIRT_NSS_GUEST) */
DO_TEST("debian", AF_INET, "192.168.122.2");
DO_TEST("suse", AF_INET, "192.168.122.3");
# endif /* defined(LIBVIRT_NSS_GUEST) */
return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
static int
mymain(void)
{
int ret = 0;
virDomainXMLOptionPtr xmlopt;
#if !WITH_YAJL
fputs("libvirt not compiled with yajl, skipping this test\n", stderr);
return EXIT_AM_SKIP;
#endif
if (virThreadInitialize() < 0 ||
!(xmlopt = virQEMUDriverCreateXMLConf(NULL)))
return EXIT_FAILURE;
virEventRegisterDefaultImpl();
#define DO_TEST(name) \
if (virtTestRun(# name, 1, testQemuMonitorJSON ## name, xmlopt) < 0) \
ret = -1
DO_TEST(GetStatus);
DO_TEST(GetVersion);
DO_TEST(GetMachines);
DO_TEST(GetCPUDefinitions);
DO_TEST(GetCommands);
DO_TEST(GetTPMModels);
DO_TEST(GetCommandLineOptionParameters);
virObjectUnref(xmlopt);
return (ret == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
static int test_inner(void)
{
pj_caching_pool caching_pool;
int rc = 0;
mem = &caching_pool.factory;
#if 1
pj_log_set_level(5);
pj_log_set_decor(param_log_decor);
#endif
rc = pj_init();
if (rc != 0) {
app_perror("pj_init() error!!", rc);
return rc;
}
pj_dump_config();
pj_caching_pool_init( &caching_pool, &pj_pool_factory_default_policy, 0 );
pjlib_util_init();
pjnath_init();
#if INCLUDE_STUN_TEST
DO_TEST(stun_test());
DO_TEST(sess_auth_test());
#endif
#if INCLUDE_ICE_TEST
DO_TEST(ice_test());
#endif
#if INCLUDE_STUN_SOCK_TEST
DO_TEST(stun_sock_test());
#endif
#if INCLUDE_TURN_SOCK_TEST
DO_TEST(turn_sock_test());
#endif
on_return:
return rc;
}
int stun_sock_test(void)
{
struct pjlib_state pjlib_state;
pj_stun_config stun_cfg;
pj_ioqueue_t *ioqueue = NULL;
pj_timer_heap_t *timer_heap = NULL;
pj_pool_t *pool = NULL;
pj_status_t status;
int ret = 0;
pool = pj_pool_create(mem, NULL, 512, 512, NULL);
status = pj_ioqueue_create(pool, 12, &ioqueue);
if (status != PJ_SUCCESS) {
app_perror(" pj_ioqueue_create()", status);
ret = -4;
goto on_return;
}
status = pj_timer_heap_create(pool, 100, &timer_heap);
if (status != PJ_SUCCESS) {
app_perror(" pj_timer_heap_create()", status);
ret = -8;
goto on_return;
}
pj_stun_config_init(&stun_cfg, mem, 0, ioqueue, timer_heap);
DO_TEST(timeout_test(&stun_cfg, PJ_FALSE));
DO_TEST(timeout_test(&stun_cfg, PJ_TRUE));
DO_TEST(missing_attr_test(&stun_cfg, PJ_FALSE));
DO_TEST(missing_attr_test(&stun_cfg, PJ_TRUE));
DO_TEST(keep_alive_test(&stun_cfg));
on_return:
if (timer_heap) pj_timer_heap_destroy(timer_heap);
if (ioqueue) pj_ioqueue_destroy(ioqueue);
if (pool) pj_pool_release(pool);
return ret;
}
static int test_inner(void)
{
pj_caching_pool caching_pool;
int rc = 0;
mem = &caching_pool.factory;
pj_log_set_level(3);
pj_log_set_decor(param_log_decor);
rc = pj_init();
if (rc != 0) {
app_perror("pj_init() error!!", rc);
return rc;
}
rc = pjlib_util_init();
pj_assert(rc == 0);
pj_dump_config();
pj_caching_pool_init( &caching_pool, &pj_pool_factory_default_policy, 0 );
#if INCLUDE_XML_TEST
DO_TEST(xml_test());
#endif
#if INCLUDE_ENCRYPTION_TEST
DO_TEST(encryption_test());
DO_TEST(encryption_benchmark());
#endif
#if INCLUDE_STUN_TEST
DO_TEST(stun_test());
#endif
#if INCLUDE_RESOLVER_TEST
DO_TEST(resolver_test());
#endif
on_return:
return rc;
}
int main()
{
vec_float4 res_v;
TEST_SET_START("164260798500","RUD", "roundf4");
//s=0
DEFINE_DATA(x1, 1.0, 1.0f)
DEFINE_DATA(x2, -1.0,-1.0f)
//s=-1
DEFINE_DATA(x3, 0.5, 1.0f)
DEFINE_DATA(x4, -0.5, -1.0f)
//s=-2
DEFINE_DATA(x5, 0.25, 0.0f)
//s=-3
DEFINE_DATA(x6, 0.125, 0.0f)
//s=0, e=128, f=7fffff --> s=0, e=128, f=7fffff
DEFINE_DATA_UNSIGNED(x7,0x7fffffff,0x7fffffff)
//s=0, e=-126, f=0 --> 0
DEFINE_DATA_UNSIGNED(x8, 0x800000,0x0)
DEFINE_DATA(x9, 0.4999, 0.f)
DEFINE_DATA(x10, 0.9999, 1.f)
//TEST
TEST_START("roundf4");
DO_TEST(x1,164260798501RUD)
DO_TEST(x2,164260798502RUD)
DO_TEST(x3,164260798503RUD)
DO_TEST(x4,164260798504RUD)
DO_TEST(x5,164260798505RUD)
DO_TEST(x6,164260798506RUD)
DO_TEST(x7,164260798507RUD)
DO_TEST(x8,164260798508RUD)
DO_TEST(x9,164260798509RUD)
DO_TEST(x10,164260798510RUD)
TEST_SET_DONE();
TEST_EXIT();
}
static int
mymain(void)
{
int ret = 0;
#define DO_TEST(name) \
do { \
const struct testInfo info = {name, false}; \
if (virtTestRun("Secret XML->XML " name, \
testCompareXMLToXMLHelper, &info) < 0) \
ret = -1; \
} while (0)
DO_TEST("ephemeral-usage-volume");
DO_TEST("usage-volume");
DO_TEST("usage-ceph");
DO_TEST("usage-iscsi");
return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
static int
mymain(void)
{
int ret = 0;
#define DO_TEST(NAME) \
do { \
test_parms tp = { \
.name = NAME, \
}; \
if (virTestRun("NWFilter XML-2-XML " NAME, \
testCompareXMLToXMLHelper, (&tp)) < 0) \
ret = -1; \
} while (0)
DO_TEST("simple");
DO_TEST("filter-vars");
return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
static int
do_test (locale_t l)
{
int result = 0;
size_t n;
#define DO_TEST(TEST, RES) \
for (n = 0; n < sizeof (str) - 1; ++n) \
if ('0' + (TEST (str[n], l) != 0) != RES[n]) \
{ \
printf ("%s(%c) failed\n", #TEST, str[n]); \
result = 1; \
}
DO_TEST (isdigit_l, exd);
DO_TEST (isalpha_l, exa);
DO_TEST (isxdigit_l, exx);
return result;
}
static int
mymain(void)
{
int ret = 0;
# define DO_TEST(vmware_type, name, version) \
do { \
struct testInfo info = { \
vmware_type, name, version \
}; \
if (virTestRun("VMware Version String Parsing " name, \
testVerStrParse, &info) < 0) \
ret = -1; \
} while (0)
DO_TEST("ws", "workstation-7.0.0", 7000000);
DO_TEST("ws", "workstation-7.0.0-with-garbage", 7000000);
DO_TEST("fusion", "fusion-5.0.3", 5000003);
return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
static int
mymain(int argc, char **argv)
{
int ret = 0;
char cwd[PATH_MAX];
progname = argv[0];
if (argc > 1) {
fprintf(stderr, "Usage: %s\n", progname);
return (EXIT_FAILURE);
}
abs_srcdir = getenv("abs_srcdir");
if (!abs_srcdir)
abs_srcdir = getcwd(cwd, sizeof(cwd));
#define DO_TEST(pool, name) \
do { \
struct testInfo info = { pool, name }; \
if (virtTestRun("Storage Vol XML-2-XML " name, \
1, testCompareXMLToXMLHelper, &info) < 0) \
ret = -1; \
} \
while(0);
DO_TEST("pool-dir", "vol-file");
DO_TEST("pool-dir", "vol-file-backing");
DO_TEST("pool-dir", "vol-qcow2");
DO_TEST("pool-disk", "vol-partition");
DO_TEST("pool-logical", "vol-logical");
DO_TEST("pool-logical", "vol-logical-backing");
return (ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
static int
mymain(void)
{
int ret = 0;
virDomainXMLOptionPtr xmlopt;
testQemuData data;
#if !WITH_YAJL
fputs("libvirt not compiled with yajl, skipping this test\n", stderr);
return EXIT_AM_SKIP;
#endif
if (virThreadInitialize() < 0 ||
!(xmlopt = virQEMUDriverCreateXMLConf(NULL)))
return EXIT_FAILURE;
virEventRegisterDefaultImpl();
data.xmlopt = xmlopt;
#define DO_TEST(name) \
data.base = name; \
if (virtTestRun(name, testQemuCaps, &data) < 0) \
ret = -1
DO_TEST("caps_1.2.2-1");
DO_TEST("caps_1.3.1-1");
DO_TEST("caps_1.4.2-1");
DO_TEST("caps_1.5.3-1");
DO_TEST("caps_1.6.0-1");
DO_TEST("caps_1.6.50-1");
virObjectUnref(xmlopt);
return (ret == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
