base, name := filepath.Split(args[0])
				args[0] = filepath.Join(base, "llvm-dlltool")
				var machine string
				switch prefix, _, _ := strings.Cut(name, "-"); prefix {
				case "i686":
					machine = "i386"
				case "x86_64":
					machine = "i386:x86-64"
				case "armv7":
					machine = "arm"
				case "aarch64":
					machine = "arm64"
				}
				if len(machine) > 0 {
					args = append(args, "-m", machine)
				}

        Assume.assumeNotNull(x86ToolChain?.buildScriptConfig, sparcToolChain?.buildScriptConfig)

        when:
        buildFile << """
model {
    platforms {
        i386 {
            architecture "i386"
        }
        sparc {
            architecture "sparc"
        }
    }
    toolChains {
        ${x86ToolChain.buildScriptConfig}
        ${sparcToolChain.buildScriptConfig}

model {
    toolChains {
        ${toolChain.buildScriptConfig}
    }
    platforms {
        i386 { architecture 'i386' }
        amd64 { architecture 'amd64' }
    }
    flavors {
        free
        paid
    }
    components {
        someLib(NativeLibrarySpec) {
            targetPlatform "i386"
            targetPlatform "amd64"
        }
    }
}
"""
        when:

    // Tests will only work on x86 and x86-64 architectures
    def currentArch() {
        // On windows we currently target i386 by default, even on amd64
        if (OperatingSystem.current().windows || Native.get(SystemInfo).architecture == SystemInfo.Architecture.i386) {
            return [name: "x86", altName: "i386"]
        }
        return [name: "x86-64", altName: "amd64"]
    }

    @ToBeFixedForConfigurationCache

        when:
        platform.architecture "x86"

        then:
        platform.architecture.name == "x86"
        platform.architecture.i386

        when:
        platform.architecture "i386"

        then:
        platform.architecture.name == "x86"
        platform.architecture.i386
    }

    def "can configure operating system"() {
        when:
        platform.operatingSystem "the-os"

        then:

        def arch = new DefaultArchitecture(name)

        expect:
        arch.name == name
        arch.i386 == i386
        arch.amd64 == amd64
        arch.ia64 == ia64
        arch.arm == arm || arm64
        arch.arm32 == arm
        arch.arm64 == arm64

        where:
        name        | i386  | amd64 | ia64  | arm   | arm64
        "x86"       | true  | false | false | false | false

        }
    }
    platforms {
        arm {
            architecture "arm"
        }
        i386 {
            architecture "i386"
        }
        sparc {
            architecture "sparc"
        }
    }
    components {
        all {
            targetPlatform "arm"
            targetPlatform "i386"
            targetPlatform "sparc"
        }
    }
}
"""

        and:

    1.7.0-ea-b223-ea-b223-ea-b223, i386:\t"Java SE 7 Developer Preview"\t/Library/Java/JavaVirtualMachines/JDK 1.7.0 Developer Preview.jdk/Contents/Home
    1.7.0, x86_64:\t"OpenJDK 7"\t/Library/Java/JavaVirtualMachines/1.7.0.jdk/Contents/Home
    1.7.0, i386:\t"OpenJDK 7"\t/Library/Java/JavaVirtualMachines/1.7.0.jdk/Contents/Home

        "32-bit" | SystemInfo.Architecture.i386  | "amd64"        | false          | LEGACY_AMD64_ON_X86
        "64-bit" | SystemInfo.Architecture.amd64 | "amd64"        | true           | LEGACY_AMD64_ON_AMD64
        "64-bit" | SystemInfo.Architecture.amd64 | "amd64"        | false          | LEGACY_AMD64_ON_X86

        "32-bit" | SystemInfo.Architecture.i386  | "x86"          | false          | LEGACY_X86_ON_X86

        expect:
        unix.nativePrefix == prefix

        where:
        [arch, prefix] << [['i386', 'unknown-i386'], ['x86', 'unknown-i386']]
    }

    def "macOS uses same prefix for all architectures"() {
        def osx = new OperatingSystem.MacOs()

        expect:
        osx.nativePrefix == 'darwin'
    }

    def "macOS transforms shared library names"() {
        def os = new OperatingSystem.MacOs()