xml2vmxtest.c 8.0 KB
Newer Older
1 2
#include <config.h>

3
#ifdef WITH_VMX
4

5 6 7
# include <stdio.h>
# include <string.h>
# include <unistd.h>
8

9 10 11
# include "internal.h"
# include "memory.h"
# include "testutils.h"
12
# include "vmx/vmx.h"
13

14
static virCapsPtr caps;
15
static virVMXContext ctx;
16

17 18 19 20 21
static int testDefaultConsoleType(const char *ostype ATTRIBUTE_UNUSED)
{
    return VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL;
}

22
static void
23
testCapsInit(void)
24 25 26 27 28 29 30 31 32
{
    virCapsGuestPtr guest = NULL;

    caps = virCapabilitiesNew("i686", 1, 1);

    if (caps == NULL) {
        return;
    }

33 34
    caps->defaultConsoleTargetType = testDefaultConsoleType;

35
    virCapabilitiesSetMacPrefix(caps, (unsigned char[]){ 0x00, 0x0c, 0x29 });
36 37
    virCapabilitiesAddHostMigrateTransport(caps, "esx");

38 39
    caps->hasWideScsiBus = true;

40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
    /* i686 guest */
    guest =
      virCapabilitiesAddGuest(caps, "hvm", "i686", 32, NULL, NULL, 0, NULL);

    if (guest == NULL) {
        goto failure;
    }

    if (virCapabilitiesAddGuestDomain(guest, "vmware", NULL, NULL, 0,
                                      NULL) == NULL) {
        goto failure;
    }

    /* x86_64 guest */
    guest =
      virCapabilitiesAddGuest(caps, "hvm", "x86_64", 64, NULL, NULL, 0, NULL);

    if (guest == NULL) {
        goto failure;
    }

    if (virCapabilitiesAddGuestDomain(guest, "vmware", NULL, NULL, 0,
                                      NULL) == NULL) {
        goto failure;
    }

    return;

  failure:
    virCapabilitiesFree(caps);
    caps = NULL;
}

static int
74
testCompareFiles(const char *xml, const char *vmx, int virtualHW_version)
75 76
{
    int result = -1;
77 78
    char *xmlData = NULL;
    char *vmxData = NULL;
79 80 81
    char *formatted = NULL;
    virDomainDefPtr def = NULL;

82
    if (virtTestLoadFile(xml, &xmlData) < 0) {
83 84 85
        goto failure;
    }

86
    if (virtTestLoadFile(vmx, &vmxData) < 0) {
87 88 89
        goto failure;
    }

M
Matthias Bolte 已提交
90 91
    def = virDomainDefParseString(caps, xmlData, 1 << VIR_DOMAIN_VIRT_VMWARE,
                                  VIR_DOMAIN_XML_INACTIVE);
92 93 94 95 96

    if (def == NULL) {
        goto failure;
    }

97
    formatted = virVMXFormatConfig(&ctx, caps, def, virtualHW_version);
98 99 100 101 102 103 104 105 106 107 108 109 110

    if (formatted == NULL) {
        goto failure;
    }

    if (STRNEQ(vmxData, formatted)) {
        virtTestDifference(stderr, vmxData, formatted);
        goto failure;
    }

    result = 0;

  failure:
111 112
    VIR_FREE(xmlData);
    VIR_FREE(vmxData);
113 114 115 116 117 118 119 120 121
    VIR_FREE(formatted);
    virDomainDefFree(def);

    return result;
}

struct testInfo {
    const char *input;
    const char *output;
122
    int virtualHW_version;
123 124 125 126 127
};

static int
testCompareHelper(const void *data)
{
128
    int result = -1;
129
    const struct testInfo *info = data;
130 131 132 133 134 135 136 137 138
    char *xml = NULL;
    char *vmx = NULL;

    if (virAsprintf(&xml, "%s/xml2vmxdata/xml2vmx-%s.xml", abs_srcdir,
                    info->input) < 0 ||
        virAsprintf(&vmx, "%s/xml2vmxdata/xml2vmx-%s.vmx", abs_srcdir,
                    info->output) < 0) {
        goto cleanup;
    }
139

140
    result = testCompareFiles(xml, vmx, info->virtualHW_version);
141

142 143 144 145 146
  cleanup:
    VIR_FREE(xml);
    VIR_FREE(vmx);

    return result;
147 148
}

149 150 151 152
static int
testAutodetectSCSIControllerModel(virDomainDiskDefPtr def ATTRIBUTE_UNUSED,
                                  int *model, void *opaque ATTRIBUTE_UNUSED)
{
153
    *model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC;
154 155 156 157 158 159 160 161

    return 0;
}

static char *
testFormatVMXFileName(const char *src, void *opaque ATTRIBUTE_UNUSED)
{
    bool success = false;
162 163 164
    char *copyOfDatastorePath = NULL;
    char *tmp = NULL;
    char *saveptr = NULL;
165
    char *datastoreName = NULL;
166
    char *directoryAndFileName = NULL;
167 168 169 170
    char *absolutePath = NULL;

    if (STRPREFIX(src, "[")) {
        /* Found potential datastore path */
171 172 173 174 175 176 177 178 179
        copyOfDatastorePath = strdup(src);

        if (copyOfDatastorePath == NULL) {
            goto cleanup;
        }

        /* Expected format: '[<datastore>] <path>' where <path> is optional */
        if ((tmp = STRSKIP(copyOfDatastorePath, "[")) == NULL || *tmp == ']' ||
            (datastoreName = strtok_r(tmp, "]", &saveptr)) == NULL) {
180 181 182
            goto cleanup;
        }

183 184 185 186 187 188 189 190
        directoryAndFileName = strtok_r(NULL, "", &saveptr);

        if (directoryAndFileName == NULL) {
            directoryAndFileName = (char *)"";
        } else {
            directoryAndFileName += strspn(directoryAndFileName, " ");
        }

191 192
        virAsprintf(&absolutePath, "/vmfs/volumes/%s/%s", datastoreName,
                    directoryAndFileName);
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
    } else if (STRPREFIX(src, "/")) {
        /* Found absolute path */
        absolutePath = strdup(src);
    } else {
        /* Found relative path, this is not supported */
        goto cleanup;
    }

    success = true;

  cleanup:
    if (! success) {
        VIR_FREE(absolutePath);
    }

208
    VIR_FREE(copyOfDatastorePath);
209 210 211 212

    return absolutePath;
}

213
static int
E
Eric Blake 已提交
214
mymain(void)
215 216 217
{
    int result = 0;

218
# define DO_TEST(_in, _out, _version)                                         \
219 220 221 222 223 224 225 226 227
        do {                                                                  \
            struct testInfo info = { _in, _out, _version };                   \
            virResetLastError();                                              \
            if (virtTestRun("VMware XML-2-VMX "_in" -> "_out, 1,              \
                            testCompareHelper, &info) < 0) {                  \
                result = -1;                                                  \
            }                                                                 \
        } while (0)

228
    testCapsInit();
229 230 231 232 233

    if (caps == NULL) {
        return EXIT_FAILURE;
    }

234 235 236 237 238
    ctx.opaque = NULL;
    ctx.parseFileName = NULL;
    ctx.formatFileName = testFormatVMXFileName;
    ctx.autodetectSCSIControllerModel = testAutodetectSCSIControllerModel;

239 240
    DO_TEST("minimal", "minimal", 4);
    DO_TEST("minimal-64bit", "minimal-64bit", 4);
241

242
    DO_TEST("graphics-vnc", "graphics-vnc", 4);
M
Matthias Bolte 已提交
243

244 245
    DO_TEST("scsi-driver", "scsi-driver", 4);
    DO_TEST("scsi-writethrough", "scsi-writethrough", 4);
246

247 248
    DO_TEST("harddisk-scsi-file", "harddisk-scsi-file", 4);
    DO_TEST("harddisk-ide-file", "harddisk-ide-file", 4);
249

250 251 252 253
    DO_TEST("cdrom-scsi-file", "cdrom-scsi-file", 4);
    DO_TEST("cdrom-scsi-device", "cdrom-scsi-device", 4);
    DO_TEST("cdrom-ide-file", "cdrom-ide-file", 4);
    DO_TEST("cdrom-ide-device", "cdrom-ide-device", 4);
254

255 256
    DO_TEST("floppy-file", "floppy-file", 4);
    DO_TEST("floppy-device", "floppy-device", 4);
257

258 259
    DO_TEST("ethernet-e1000", "ethernet-e1000", 4);
    DO_TEST("ethernet-vmxnet2", "ethernet-vmxnet2", 4);
260

261 262
    DO_TEST("ethernet-custom", "ethernet-custom", 4);
    DO_TEST("ethernet-bridged", "ethernet-bridged", 4);
263

264 265 266 267
    DO_TEST("ethernet-generated", "ethernet-generated", 4);
    DO_TEST("ethernet-static", "ethernet-static", 4);
    DO_TEST("ethernet-vpx", "ethernet-vpx", 4);
    DO_TEST("ethernet-other", "ethernet-other", 4);
268

269 270 271 272 273
    DO_TEST("serial-file", "serial-file", 4);
    DO_TEST("serial-device", "serial-device", 4);
    DO_TEST("serial-pipe", "serial-pipe", 4);
    DO_TEST("serial-network-server", "serial-network-server", 7);
    DO_TEST("serial-network-client", "serial-network-client", 7);
274

275 276
    DO_TEST("parallel-file", "parallel-file", 4);
    DO_TEST("parallel-device", "parallel-device", 4);
277

278 279 280 281 282
    DO_TEST("esx-in-the-wild-1", "esx-in-the-wild-1", 4);
    DO_TEST("esx-in-the-wild-2", "esx-in-the-wild-2", 4);
    DO_TEST("esx-in-the-wild-3", "esx-in-the-wild-3", 4);
    DO_TEST("esx-in-the-wild-4", "esx-in-the-wild-4", 4);
    DO_TEST("esx-in-the-wild-5", "esx-in-the-wild-5", 4);
283
    DO_TEST("esx-in-the-wild-6", "esx-in-the-wild-6", 4);
284

285 286 287 288
    DO_TEST("gsx-in-the-wild-1", "gsx-in-the-wild-1", 4);
    DO_TEST("gsx-in-the-wild-2", "gsx-in-the-wild-2", 4);
    DO_TEST("gsx-in-the-wild-3", "gsx-in-the-wild-3", 4);
    DO_TEST("gsx-in-the-wild-4", "gsx-in-the-wild-4", 4);
289

290
    DO_TEST("annotation", "annotation", 4);
291

292
    DO_TEST("smbios", "smbios", 4);
M
Matthias Bolte 已提交
293

294 295
    DO_TEST("svga", "svga", 4);

296 297 298 299 300 301 302 303 304
    virCapabilitiesFree(caps);

    return result == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}

VIRT_TEST_MAIN(mymain)

#else

305
int main(void)
306
{
307
    return EXIT_AM_SKIP;
308 309
}

310
#endif /* WITH_VMX */