metadata.visualCppVersion == VersionNumber.parse("1.2.3.4")
        metadata.version == VersionNumber.UNKNOWN
    }

    void vswhereInstall(File dir, String version) {
        VersionNumber versionNumber = VersionNumber.parse(version)
        vswhereInstalls << new VisualStudioMetadataBuilder()
            .installDir(dir)
            .version(versionNumber)

    private static final VersionNumber FIRST_VERSION_SUPPORTING_ISOLATED_PROJECTS = VersionNumber.parse("3.15")
    private static final VersionNumber FIRST_VERSION_SUPPORTING_ISOLATED_PROJECTS_FOR_TEST_ACCELERATION = VersionNumber.parse("3.17")
    private static final VersionNumber FIRST_VERSION_CALLING_BUILD_PATH = VersionNumber.parse("3.13.1")
    private static final VersionNumber FIRST_VERSION_BUNDLING_TEST_RETRY_PLUGIN = VersionNumber.parse("3.12")

        then:
        result.available
        result.component.name == "Visual Studio 12.0.0"
        result.component.version == VersionNumber.parse("12.0")
        result.component.baseDir == dir2
        result.component.visualCpp.name == "Visual C++ 12.0.0"
        result.component.visualCpp.version == VersionNumber.parse("12.0")
    }

    def "use highest visual studio version found from the command line"() {
        def dir1 = vsDir("vs1")

                    return "UNKNOWN";
            }
        }
    }

    public static class InstalledClang extends GccCompatibleToolChain {
        public InstalledClang(VersionNumber versionNumber) {
            super(ToolFamily.CLANG, versionNumber);
        }

        @Override
        public boolean meets(ToolChainRequirement requirement) {
            switch (requirement) {
                case AVAILABLE:

    }

    private String determineVendor(String error, VersionNumber versionNumber, File gccBinary) {
        BufferedReader reader = new BufferedReader(new StringReader(error));
        String majorMinorOnly = versionNumber.getMajor() + "." + versionNumber.getMinor();
        String line;
        try {
            while ((line = reader.readLine()) != null) {

        result.component.version == VersionNumber.UNKNOWN
        result.component.baseDir == sdkDir1

        when:
        result = windowsSdkLocator.locateComponent(sdkDir2)

        then:
        result.available
        result.component.name == "User-provided Windows SDK"
        result.component.version == VersionNumber.UNKNOWN
        result.component.baseDir == sdkDir2
    }

        Assume.assumeTrue(GroovyCoverage.supportsJavaVersion("$versionNumber", javaVersion))
        def jdk = AvailableJavaHomes.getJdk(javaVersion)
        Assume.assumeTrue(jdk != null)

        configureJavaPluginToolchainVersion(jdk)

        buildFile << """
            dependencies {
                testImplementation "org.spockframework:spock-core:${getSpockVersion(versionNumber)}"
            }

        expectedVersion << ["1.0", "0.0.1"]
    }

    def "attribute value evaluates lazily"() {
        given:
        buildFile << """
            def versionNumber = objects.property(String)
            versionNumber.set("1.0")

            task jar(type: Jar) {
                manifest {
                    attributes(attr: provider { "value" })
                    attributes(version: archiveVersion)

        });
    }

    private VersionNumber findIdeaTargetVersion() {
        VersionNumber targetVersion = null;
        String targetVersionString = rootProject.getExtensions().getByType(IdeaModel.class).getTargetVersion();
        if (targetVersionString != null) {
            targetVersion = VersionNumber.parse(targetVersionString);
            if (targetVersion.equals(VersionNumber.UNKNOWN)) {

    }

    private void pluginNotApplied() {
        fixture.notApplied(output)
    }

    static String newerThanAutoApplyPluginVersion() {
        def autoApplyVersion = VersionNumber.parse(PLUGIN_AUTO_APPLY_VERSION)
        VersionNumber.version(autoApplyVersion.major + 1).toString()
    }