package org.gradle.smoketests

import com.gradle.develocity.testing.annotations.LocalOnly
import org.gradle.integtests.fixtures.android.AndroidHome
import org.gradle.test.fixtures.dsl.GradleDsl
import org.gradle.util.internal.VersionNumber

import static org.gradle.integtests.fixtures.versions.KotlinGradlePluginVersions.hasConfigurationCacheWarnings
import static org.gradle.testkit.runner.TaskOutcome.SUCCESS

/**

        List<File> combinedClasspath = ImmutableList.<File>builder()
            .addAll(classpath)
            .addAll(groovyClasspath)
            .build();

        VersionNumber version = VersionNumber.parse(getGroovyVersion(combinedClasspath));

        final Map<String, Object> args = new LinkedHashMap<>();
        args.put("sourcepath", tmpDir.toString());
        args.put("destdir", destDir);

import org.gradle.util.internal.VersionNumber

import static org.hamcrest.CoreMatchers.startsWith

class CodeNarcGroovyVersionIntegrationTest extends AbstractIntegrationSpec implements CodeNarcTestFixture {
    def setup() {
        writeRuleFile()
    }

    void writeBuildFile(String groovyVersion, String codenarcVersion) {

    @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}'

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

        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 }

        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;

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

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

        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;