@Override
    boolean supportsSuiteOutput() {
        // Suite output events are not correctly reported until version 5.9.0.  See https://github.com/junit-team/junit5/pull/2985.
        return VersionNumber.parse(version) >= VersionNumber.parse("5.9.0")
    }

    @Override
    String getTestFrameworkJUnit3Dependencies() {
        return """
            testCompileOnly 'junit:junit:${LATEST_JUNIT3_VERSION}'

        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
    }

        and:
        metadata.size() == 1
        metadata[0].installDir == vsDir
        metadata[0].version == VersionNumber.parse("15.0")
        metadata[0].visualCppDir == new File(vsDir, "VC")
        metadata[0].visualCppVersion == VersionNumber.parse("15.0")
    }

    def "can locate an unknown visual studio install on the path"() {
        def vsDir = tmpDir.createDir("vs")

        private final VersionNumber version;

        DefaultSwiftcMetadata(String versionString, VersionNumber version) {
            this.versionString = versionString;
            this.version = version;
        }

        @Override
        public String getVendor() {
            return versionString;
        }

        @Override
        public VersionNumber getVersion() {
            return version;

        allTestedVersions = testedVersions.map { VersionNumber.parse(it.gradleVersion().version) }
            .groupBy { "${it.major}.${it.minor}" }
            .map { (_, v) -> v.maxOrNull()!!.format() }

        // Limit to first and last release of each major version
        mainTestedVersions = testedVersions.map { VersionNumber.parse(it.gradleVersion().version) }
            .groupBy { it.major }

        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)}"
            }

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

class VisualStudioProjectFileTest extends Specification {
    @Rule

        if (capabilityVersions.size() > 1) {
            Set<Capability> sorted = Sets.newTreeSet((o1, o2) -> {
                VersionNumber v1 = VersionNumber.parse(o1.getVersion());
                VersionNumber v2 = VersionNumber.parse(o2.getVersion());
                return v2.compareTo(v1);
            });
            sorted.addAll(capabilityVersions);
            boolean first = true;

    static final def CLASSIFIER_PATTERN = /^(.*?)(:.*)?$/

    static def version

    static VersionNumber getVersionNumber() {
        if (version == null) {
            throw new IllegalStateException("No version present")
        }
        def m = version.toString() =~ CLASSIFIER_PATTERN
        VersionNumber.parse(m[0][1])
    }

    @Nullable
    static String getVersionClassifier() {

 * limitations under the License.
 */

package org.gradle.play.integtest.fixtures.external

import org.gradle.util.internal.VersionNumber

class BasicPlayApp extends PlayApp {

    BasicPlayApp(VersionNumber version) {
        super(version)
    }