}

    @Override
    public OperatingSystemFamily getOperatingSystemFamily() {
        return operatingSystemFamily;
    }

    @Override
    public MachineArchitecture getArchitecture() {
        return architecture;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

    void assertSupported();

    class Identifier {
        public static String identify(NativeToolChainInternal toolChain, NativePlatformInternal platform) {
            return toolChain.getOutputType() + ":" + platform.getArchitecture().getName() + ":" + platform.getOperatingSystem().getName();
        }
    }

    def modelRegistry = Stub(ModelRegistry)
    def osFamily = Stub(OperatingSystemFamily)
    def machineArchitecture = Stub(MachineArchitecture)
    def targetMachine = Stub(TargetMachine) {
        getArchitecture() >> machineArchitecture
        getOperatingSystemFamily() >> osFamily
    }
    def os = Stub(OperatingSystemInternal)
    def arch = Stub(ArchitectureInternal)
    def host = new DefaultNativePlatform("host", os, arch)

        cppPCHCompile.source sourceFile
        execute(cppPCHCompile)

        then:
        _ * toolChain.outputType >> "cpp"
        platform.getName() >> "testPlatform"
        platform.getArchitecture() >> Mock(ArchitectureInternal) { getName() >> "arch" }
        platform.getOperatingSystem() >> Mock(OperatingSystemInternal) { getName() >> "os" }
        1 * toolChain.select(platform) >> platformToolChain

        }
        return platforms.get(getPlatformArchitecture(targetPlatform));
    }

    private Architecture getPlatformArchitecture(NativePlatformInternal targetPlatform) {
        return targetPlatform.getArchitecture();
    }

    private VisualCpp getDescriptor(NativePlatformInternal targetPlatform) {
        return platforms.get(getPlatformArchitecture(targetPlatform));
    }

public interface NativePlatform extends Platform, Describable {
    /**
     * The cpu architecture being targeted. Defaults to the default architecture produced by the tool chain.
     */
    @Nested
    Architecture getArchitecture();

    /**
     * Sets the cpu architecture being targeted.
     * <p>
     * The architecture is provided as a string name, which is translated into one of the supported architecture types.
     * </p>

        objCPCHCompile.source sourceFile
        execute(objCPCHCompile)

        then:
        _ * toolChain.outputType >> "c"
        platform.getName() >> "testPlatform"
        platform.getArchitecture() >> Mock(ArchitectureInternal) { getName() >> "arch" }
        platform.getOperatingSystem() >> Mock(OperatingSystemInternal) { getName() >> "os" }
        1 * toolChain.select(platform) >> platformToolChain

        objCppPCHCompile.source sourceFile
        execute(objCppPCHCompile)

        then:
        _ * toolChain.outputType >> "objcpp"
        platform.getName() >> "testPlatform"
        platform.getArchitecture() >> Mock(ArchitectureInternal) { getName() >> "arch" }
        platform.getOperatingSystem() >> Mock(OperatingSystemInternal) { getName() >> "os" }
        1 * toolChain.select(platform) >> platformToolChain

        cCompile.setPreCompiledHeader pch
        execute(cCompile)

        then:
        _ * toolChain.outputType >> "c"
        platform.getName() >> "testPlatform"
        platform.getArchitecture() >> Mock(ArchitectureInternal) { getName() >> "arch" }
        platform.getOperatingSystem() >> Mock(OperatingSystemInternal) { getName() >> "os" }
        2 * toolChain.select(platform) >> platformToolChain

        def objectFactory = TestUtil.objectFactory()
        return Stub(TargetMachine) {
            getOperatingSystemFamily() >> objectFactory.named(OperatingSystemFamily.class, os)
            getArchitecture() >> objectFactory.named(MachineArchitecture.class, arch)
        }
    }