this.platformDirName = platformDirName;
            this.hostDirName = hostDirName;
        }

        @Override
        public VersionNumber getImplementationVersion() {
            return WindowsKitSdkInstall.this.getVersion();
        }

        @Override
        public VersionNumber getSdkVersion() {
            return getImplementationVersion();
        }

        @Override
        public List<File> getIncludeDirs() {

 * limitations under the License.
 */
package org.gradle.api.internal.plugins

import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.gradle.util.internal.VersionNumber
import org.junit.Rule
import spock.lang.Specification

class GroovyJarFileTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

        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)

import org.gradle.util.internal.VersionNumber
import org.junit.Assume

@TargetCoverage({ PlayCoverage.DEFAULT })
@MultiVersionTest
abstract class AbstractMultiVersionPlayExternalContinuousBuildIntegrationTest extends AbstractPlayExternalContinuousBuildIntegrationTest {
    static def version

    static VersionNumber getVersionNumber() {
        VersionNumber.parse(version.toString())
    }

    def setup() {

    def "failure during JUnit platform initialization is written to console when granularity is set"() {
        Assume.assumeTrue("Non-existent test engine is only an error after 5.9.0", VersionNumber.parse(version) >= VersionNumber.parse("5.9.0"))

        buildFile.text = """
            apply plugin: "groovy"

            ${mavenCentralRepository()}

            dependencies {
                ${testFrameworkDependencies}

        });
    }

    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)) {

import org.gradle.api.Named;
import org.gradle.util.internal.VersionNumber;

import java.io.File;

public class VisualStudioInstall implements Named {
    private final String name;
    private final VisualCppInstall visualCppInstall;
    private final File baseDir;
    private final VersionNumber version;

    public VisualStudioInstall(String name, File baseDir, VersionNumber version, VisualCppInstall visualCppInstall) {

class DaemonMultiJdkIntegrationTest extends DaemonIntegrationSpec {
    static def version
    @Rule IgnoreIfJdkNotFound ignoreRule = new IgnoreIfJdkNotFound()

    JavaInfo jdk

    static VersionNumber getVersionNumber() {
        VersionNumber.parse(version.toString())
    }

    class IgnoreIfJdkNotFound implements TestRule {
        @Override
        Statement apply(Statement base, Description description) {

    }

    public File getFile() {
        return file;
    }

    public String getBaseName() {
        return matcher.group(1);
    }

    public VersionNumber getVersion() {
        return VersionNumber.parse(matcher.group(2));
    }

    public boolean isGroovyAll() {
        return getBaseName().equals("groovy-all");
    }

    public boolean isIndy() {

            visualCppDir = FileUtils.canonicalize(visualCppDir);
            File visualStudioDir = visualCppDir.getParentFile();
            VersionNumber version = VersionNumber.parse(versionString);
            installs.add(new VisualStudioMetadataBuilder()
                .installDir(visualStudioDir)
                .visualCppDir(visualCppDir)
                .version(version)