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

    }

    void assertHtmlReportHasProblems(
        @DelegatesTo(value = HasConfigurationCacheProblemsInReportSpec, strategy = Closure.DELEGATE_FIRST) Closure<?> specClosure
    ) {
        def spec = createSpec(specClosure)
        def jsModel = readJsModelFromReport()
        checkProblemsAgainstModel(spec, jsModel)
    }

    PluginRequestCollector(
        TextResourceScriptSource(StringTextResource("script", ""))
    ).run {
        PluginDependenciesSpecScope(createSpec(1)).block()
        pluginRequests.toList()
    }


fun plugin(id: String, version: String? = null, isApply: Boolean = true) = Plugin(id, version, isApply)

        this.scriptSource = scriptSource;
    }

    private final List<PluginDependencySpecImpl> specs = new LinkedList<PluginDependencySpecImpl>();

    public PluginDependenciesSpec createSpec(final int pluginsBlockLineNumber) {
        return new PluginDependenciesSpecImpl(pluginsBlockLineNumber);
    }

    public PluginRequests getPluginRequests() {
        if (specs.isEmpty()) {

        pluginRequestCollectorFor(plugin).run {

            loadClass(plugin.compiledScriptTypeName)
                .getConstructor(PluginDependenciesSpec::class.java)
                .newInstance(createSpec(1))

            pluginRequests
        }

    private
    fun pluginRequestCollectorFor(plugin: PrecompiledScriptPlugin) =
        PluginRequestCollector(scriptSourceFor(plugin))

    private

     * @param fileNames
     */
    void expectFiles(List<String> fileNames) {
        always {
            expectFiles(fileNames)
        }
    }

    void createSpecs() {
        withModuleMetadataSpec = new SingleArtifactResolutionResultSpec<T>(module)
        withoutModuleMetadataSpec = new SingleArtifactResolutionResultSpec<T>(module)
    }

    abstract T getModule()