customImlFolder {}
            excludeMePlease {}
            customModuleContentRoot {}
            src { main { java {} } }
        }

        //when
        runTask 'idea', '''
apply plugin: "java"
apply plugin: "idea"

configurations {
  provided
  compileClasspath.extendsFrom(provided)
}

idea {
    pathVariables CUSTOM_VARIABLE: file('customModuleContentRoot').parentFile

    module {

        plugins.empty

        when:
        container.apply(pluginClass)

        then:
        plugins == []
    }

    def "calls apply on target for type only"() {
        when:
        container.apply(plugin1Class)

        then:
        1 * target.applyImperative(null, { plugin1Class.isInstance(it) })
    }

    def "calls apply on target for id"() {
        when:

                    @Model
                    String string() { "foo" }
                }
            }

            apply type: MyPlugin
            apply type: MyOtherPlugin
        """

        then:
        fails "tasks"

        and:
        failure.assertHasCause("Failed to apply plugin class 'MyOtherPlugin'")

            }
        """

        file("sub/build.gradle") << "apply from: 'script.gradle'"
        file("sub/script.gradle") << "someMethod()"

        when:
        run "help"

        then:
        output.contains("from some method")
    }

    @Issue("https://issues.gradle.org/browse/GRADLE-3082")
    def "can use apply block syntax to apply multiple scripts"() {
        given:
        buildScript """

    }

    def "explicit project language level does not affect module language level"() {
        given:
        project.plugins.apply(JavaPlugin)
        child1.plugins.apply(JavaPlugin)
        child2.plugins.apply(JavaPlugin)
        project.idea.project.languageLevel = '1.2'
        project.java.sourceCompatibility = '1.3'
        child1.java.sourceCompatibility = '1.4'

        file("unzip/TestProject-custom/someFile").assertIsFile()
    }

    def "can publish distribution"() {
        when:
        buildFile << """
            apply plugin:'distribution'
            apply plugin:'maven-publish'
            group = "org.acme"
            version = "1.0"

            distributions {
                main {
                    contents {

        class MySamplePlugin implements Plugin<Project> {
            void apply(final Project project) {}

            static class Rules extends RuleSource {
                @ComponentType
                void register(TypeBuilder<SampleBinary> builder) {
                }
            }
        }

        apply plugin:MySamplePlugin

        model {
            tasks {

    checkNotNull(keyFunction);
    checkNotNull(valueFunction);
    return Collector.of(
        ImmutableMap.Builder<K, V>::new,
        (builder, input) -> builder.put(keyFunction.apply(input), valueFunction.apply(input)),
        ImmutableMap.Builder::combine,
        ImmutableMap.Builder::buildOrThrow);
  }

  static <T extends @Nullable Object, K, V> Collector<T, ?, ImmutableMap<K, V>> toImmutableMap(

    checkNotNull(keyFunction);
    checkNotNull(valueFunction);
    return Collector.of(
        ImmutableMap.Builder<K, V>::new,
        (builder, input) -> builder.put(keyFunction.apply(input), valueFunction.apply(input)),
        ImmutableMap.Builder::combine,
        ImmutableMap.Builder::buildOrThrow);
  }

  static <T extends @Nullable Object, K, V> Collector<T, ?, ImmutableMap<K, V>> toImmutableMap(

        """

        def buildFile = file("build.gradle")
        buildFile << """
            allprojects {
                apply plugin: 'java'
                apply plugin: 'idea'
            }

            project(":library") {
                apply plugin: 'java-library'
                dependencies {
                    api project(":api")
                    implementation project(":impl")