printAttribute("Language Version", metadata.getLanguageVersion().getMajorVersion());
        printAttribute("Vendor", metadata.getVendor().getDisplayName());
        printAttribute("Architecture", metadata.getArchitecture());
        printAttribute("Is JDK", String.valueOf(metadata.hasCapability(JAVA_COMPILER)));
        printAttribute("Detected by", toolchain.location.getSource());
        output.println();
    }

        objCCompile.setPreCompiledHeader pch
        execute(objCCompile)

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

        objCppCompile.setPreCompiledHeader pch
        execute(objCppCompile)

        then:
        _ * toolChain.outputType >> "objcpp"
        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)
        }
    }

        NativePlatformInternal defaultPlatform = new DefaultNativePlatform("default");
        OperatingSystemInternal os = defaultPlatform.getOperatingSystem();
        ArchitectureInternal architecture = defaultPlatform.getArchitecture();

        if (os.isWindows()) {
            // Always use x86 as default on windows
            return platformName(OS_WINDOWS, ARCH_X86);
        }
        if (os.isLinux()) {

        architectureDescriptorBuilders.add(LEGACY_IA64_ON_X86);
        architectureDescriptorBuilders.add(LEGACY_ARM_ON_X86);

        boolean isNativeAmd64 = systemInfo.getArchitecture() == SystemInfo.Architecture.amd64;
        if (isNativeAmd64) {
            // Prefer 64-bit tools when building on a 64-bit OS
            architectureDescriptorBuilders.add(LEGACY_AMD64_ON_AMD64);

        cppCompile.setPreCompiledHeader pch
        execute(cppCompile)

        then:
        _ * toolChain.outputType >> "cpp"
        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)
        }
    }

        def vsDir = fullVsDir("vs", is64BitInstall)
        def vcDir = new File(vsDir, "VC")

        given:
        systemInfo.getArchitecture() >> systemArchitecture
        1 * commandLineLocator.getVisualStudioInstalls() >> []
        1 * windowsRegistryLocator.getVisualStudioInstalls() >> []
        1 * systemPathLocator.getVisualStudioInstalls() >> []

    def id = new DefaultComponentSpecIdentifier("project", "name")
    def component = BaseComponentFixtures.createNode(NativeLibrarySpec, TestNativeComponentSpec, id)

    def platform1 = Stub(NativePlatform) {
        getArchitecture() >> Architectures.forInput("i386")
    }
    def buildType1 = Stub(BuildType) {
        getName() >> "BuildType1"
    }
    def resolver = Mock(NativeDependencyResolver)