def factory = new PatternSpecFactory()

    def "creates spec for empty patterns"() {
        def source = new PatternSet()

        expect:
        def spec = factory.createSpec(source)
        spec.isSatisfiedBy(element("a.java"))
        spec.isSatisfiedBy(element("/a/b/c.java"))

        // Default excludes
        !spec.isSatisfiedBy(element("/.git/refs"))
    }

    JavaToolchainSpec createSpec() {
        TestUtil.objectFactory().newInstance(DefaultToolchainSpec)
    }

    def "spec key implements equals"() {
        given:
        def spec11 = createSpec()
        def spec12 = createSpec()
        def spec11Vendor1 = createSpec()
        def spec11Vendor2 = createSpec()
        def spec11Impl1 = createSpec()
        def spec11Impl2 = createSpec()

    JavaToolchainSpec createSpec() {
        TestUtil.objectFactory().newInstance(DefaultToolchainSpec)
    }

    def "can query for matching toolchain using version #versionToFind"() {
        given:
        def queryService = setupInstallations(versionRange(8, 12))

        when:
        def filter = createSpec()
        filter.languageVersion.set(versionToFind)

        javaCompile.destinationDirectory.fileValue(new File('tmp'))
        def javaHome = Jvm.current().javaHome

        when:
        def spec = javaCompile.createSpec()
        def actualCompiler = javaCompile.javaCompiler.get()

        then:
        spec.sourceCompatibility == Jvm.current().javaVersion.toString()
        spec.targetCompatibility == Jvm.current().javaVersion.toString()

    def "can query for matching toolchain using version #versionToFind"() {
        given:
        def queryService = createQueryServiceWithInstallations(versionRange(8, 12))

        when:
        def filter = createSpec(JavaLanguageVersion.of(versionToFind))
        def toolchain = queryService.findMatchingToolchain(filter)

        then:
        toolchain.languageVersion == JavaVersion.toVersion(versionToFind)

import spock.lang.Specification

class JavaToolchainInputTest extends Specification {
    JavaToolchainSpec createSpec() {
        TestUtil.objectFactory().newInstance(DefaultToolchainSpec)
    }

    def "optional properties are using defaults"() {
        given:
        def baseSpec = createSpec()
        def diffSpec = createSpec()
        baseSpec.languageVersion.set(JavaLanguageVersion.of(11))

        for (CaseSensitivity caseSensitivity : CaseSensitivity.values()) {
            defaultExcludeSpecCache.put(caseSensitivity, createSpec(defaultExcludes, false, caseSensitivity.isCaseSensitive()));
        }
    }

    protected Spec<FileTreeElement> createSpec(Collection<String> patterns, boolean include, boolean caseSensitive) {
        if (patterns.isEmpty()) {

        def invalidJavaHome = "invalidJavaHome"

        when:
        javaCompile.options.fork = true
        javaCompile.options.forkOptions.javaHome = new File("invalidJavaHome")
        javaCompile.createSpec()

        then:
        def e = thrown(AbstractProperty.PropertyQueryException)
        def cause = TestUtil.getRootCause(e) as InvalidUserDataException

        specInstanceCache = CacheBuilder.newBuilder().maximumSize(cacheSizer.scaleCacheSize(INSTANCES_MAX_SIZE)).build();
    }

    @Override
    protected Spec<FileTreeElement> createSpec(final Collection<String> patterns, final boolean include, final boolean caseSensitive) {
        final SpecKey key = new SpecKey(ImmutableList.copyOf(patterns), include, caseSensitive);
        try {

        this.scalaCompilerPlugins = scalaCompilerPlugins;
    }

    @Override
    protected ScalaJavaJointCompileSpec createSpec() {
        ScalaCompileOptionsConfigurer.configure(getScalaCompileOptions(), getToolchain(), getScalaClasspath().getFiles());
        ScalaJavaJointCompileSpec spec = super.createSpec();
        if (getScalaCompilerPlugins() != null) {