configuration.setTargetDirectory(spec.getDestinationDir());
        canonicalizeValues(spec.getGroovyCompileOptions().getOptimizationOptions());

        VersionNumber version = parseGroovyVersion();
        if (version.compareTo(VersionNumber.parse("2.5")) >= 0) {
            configuration.setParameters(spec.getGroovyCompileOptions().isParameters());
        } else if (spec.getGroovyCompileOptions().isParameters()) {

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

import static org.gradle.scala.ScalaCompilationFixture.scalaDependency

class AbstractScalaCompileJavaToolchainIntegrationTest extends MultiVersionIntegrationSpec implements JavaToolchainFixture {

    def getTargetJava8() {
        return versionNumber >= VersionNumber.parse("2.13.9") ? "-release:8"

    private static final String ASSERTJ_PMDAUX_DEPENDENCY = "pmdAux $ASSERTJ_STR"

    static boolean supportsAuxclasspath() {
        return VersionNumber.parse("5.2.0") < versionNumber
    }

    def setup() {
        includeProject("pmd-rule")
        buildFile << """
            allprojects {
                ${mavenCentralRepository()}

    def "can scrape version number from output of GCC #versionNumber"() {
        expect:
        def result = output(gcc, gccVerboseOutput(versionNumber.toString()))
        result.available
        result.component.version == VersionNumber.parse(versionNumber)

        where:
        gcc          | versionNumber
        gccMajorOnly | "3.0.0"
        gccNoMinor   | "3.0.4"

        return makeName(getVariantDimensions());
    }

    @Override
    public VersionNumber getVisualStudioVersion() {
        // Assume VS 2015
        return VersionNumber.parse("14.0");
    }

    @Override
    public VersionNumber getSdkVersion() {
        // Assume 8.1
        return VersionNumber.parse("8.1");
    }

    @Override
    public FileCollection getSourceFiles() {

        }

        if (isValidInstall(install) && install.getVisualCppVersion() != VersionNumber.UNKNOWN) {
            LOGGER.debug("Found Visual C++ {} at {}", install.getVisualCppVersion(), visualCppDir);
            VersionNumber visualStudioVersion = install.getVersion();
            String visualStudioDisplayVersion = install.getVersion() == VersionNumber.UNKNOWN ? "from " + source : install.getVersion().toString();

<suite name="AwesomeSuite">
  <test name='The Foo Test'><classes><class name='FooTest'/></classes></test>
</suite>"""

        when: succeeds "test"

        then:
        if (VersionNumber.parse(version.toString()) > VersionNumber.parse('5.12.1')) {
            // Broken in 5.12.1, fixed in 5.13
            assert containsLinesThatMatch(result.output,
                "Gradle Test Executor \\d+ -> static out",

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

import static org.gradle.nativeplatform.toolchain.internal.msvcpp.AbstractWindowsKitComponentLocator.PLATFORMS

    static Set<String> calculateDefaultDependencyNotation(final String versionString) {
        final VersionNumber toolVersion = VersionNumber.parse(versionString);
        if (toolVersion.compareTo(VersionNumber.version(5)) < 0) {
            return Collections.singleton("pmd:pmd:" + versionString);
        } else if (toolVersion.compareTo(VersionNumber.parse("5.2.0")) < 0) {
            return Collections.singleton("net.sourceforge.pmd:pmd:" + versionString);

 * limitations under the License.
 */

package org.gradle.internal.reflect

import org.gradle.api.provider.Property
import org.gradle.api.provider.Provider
import org.gradle.util.internal.VersionNumber
import spock.lang.Specification

import java.beans.Introspector

import static org.junit.Assume.assumeTrue

class PropertyAccessorTypeTest extends Specification {