@Override
    boolean isSupportsEmptyClassWithRunner() {
        // JUnit 4.0 does not support an empty class with a runner (i.e. the test fails)
        return VersionNumber.parse(version) >= VersionNumber.parse('4.1')
    }

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

import java.io.File;

public abstract class WindowsKitInstall implements Named {
    private final File baseDir;
    private final String name;
    private final VersionNumber version;

    public WindowsKitInstall(File baseDir, VersionNumber version, String name) {
        this.baseDir = baseDir;
        this.version = version;

    private static boolean supportsScriptsInGroovydoc() {
        return versionNumber >= VersionNumber.parse("1.7.3")
    }

    // The flags are available in all versions of Groovydoc, but package/protected only works in 1.7 and above
    private static boolean supportsHidingNonPrivateScopes() {
        return versionNumber >= VersionNumber.parse("1.7")
    }

    def setup() {
        buildFile << """

import org.gradle.util.internal.VersionNumber;

import java.io.File;

public interface VisualStudioInstallCandidate {
    enum Compatibility { LEGACY, VS2017_OR_LATER }

    VersionNumber getVersion();

    File getInstallDir();

    File getVisualCppDir();

    VersionNumber getVisualCppVersion();

    Compatibility getCompatibility();

 */
package org.gradle.api.plugins.quality.pmd

import org.gradle.util.internal.VersionNumber

import static org.junit.Assume.assumeTrue

class PmdPluginSubtypeParamIntegrationTest extends AbstractPmdPluginVersionIntegrationTest {

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

    def setup() {
        buildFile << """
            apply plugin: 'java'

import org.gradle.language.base.compile.CompilerVersion;
import org.gradle.util.internal.VersionNumber;

@NonNullApi
public class DefaultCompilerVersion implements CompilerVersion {

    private final String type;
    private final String vendor;
    private final VersionNumber version;

    public DefaultCompilerVersion(String type, String vendor, VersionNumber version) {
        this.type = type;
        this.vendor = vendor;

import groovy.transform.SelfType
import org.gradle.util.internal.VersionNumber

/**
 * Implementing this trait means that a class knows how to create runners for testing Android and Kotlin plugins.
 */
@SelfType(AbstractSmokeTest)
trait RunnerFactory {

    SmokeTestGradleRunner mixedRunner(boolean parallel, String agpVersion, VersionNumber kgpVersion, String... tasks) {
        def runner = kgpRunner(parallel, kgpVersion, tasks)

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

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

/**

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