configuration.scriptBaseClass = DefaultScript.class.name
        configuration
    }

    private String getTestScriptText() {
        '''
// We leave out the path to check import adding
getName() // call a project method
assert hasProperty('custom')
repositories { }
def scriptMethod() { 'scriptMethod' }
String internalProp = 'a'
assert internalProp == 'a'
ext.newProperty = 'a'

- however if you are a library, adding <<dependency_downgrade_and_exclude.adoc#sec:excluding-transitive-deps,exclusions>> may prevent consumers from working properly, because they would exercise...

In the first instance, all of the required dependencies are present as builds in the `modules` directory. In a real-world example, these could well be clones of different Git repositories.

In order to avoid hard-coding the included builds to load, the `settings.gradle` file in `multirepo-app` loads each of these builds dynamically:

====
include::sample[dir="kotlin",files="settings.gradle.kts[tags=include_builds]"]

     * </pre>
     */
    public void setRuleSets(List<String> ruleSets) {
        this.ruleSets.set(ruleSets);
    }

    /**
     * Convenience method for adding rule sets.
     *
     * <pre>
     *     ruleSets "category/java/errorprone.xml", "category/java/bestpractices.xml"
     * </pre>
     *
     * @param ruleSets the rule sets to be added
     */

    }

    private void resolveAndFilterSourceFiles(JavaCompileSpec spec) {
        // this mimics the behavior of the Ant javac task (and therefore AntJavaCompiler),
        // which silently excludes files not ending in .java
        Iterable<File> javaOnly = Iterables.filter(spec.getSourceFiles(), NormalizingJavaCompiler::hasJavaExtension);
        spec.setSourceFiles(ImmutableSet.copyOf(javaOnly));
    }

     * See [org.gradle.initialization.DefaultExceptionAnalyser.transform], note the comments.
     * The Kotlin DSL provider handles this in isolation,
     * thus hiding the location of exceptions thrown by groovy scripts applied from kotlin scripts.
     *
     * This test exercises the current behavior.
     */
    @Test

}
----
<1> Add plugins.
<2> Use convention properties.
=====
====

=== 1. Add plugins
Plugins extend Gradle's functionality and can contribute tasks to a project.

Adding a plugin to a build is called _applying_ a plugin and makes additional functionality available.

[source,kotlin]
----
plugins {
    id("application")
}
----

    /**
     * Adds attributes to the precedence order. Attributes listed first have higher precedence.
     * <p>
     * The attributes will be added to any existing precedence order. If an attribute has already been added, adding it again
     * will fail.
     *
     * @param attributes the attributes in order
     *
     * @since 7.5
     * @see #setAttributeDisambiguationPrecedence(List)
     */
    @Incubating

        when:
        specUnderTest.setEnvironment(OTHERVAR: "otherval")

        then:
        specUnderTest.getEnvironment() == [OTHERVAR: "otherval"]
    }

    def "adding variables after setting environment is working"() {
        given:
        specUnderTest.setEnvironment(SOMEVAR: "someval")

        when:
        specUnderTest.environment(OTHERVAR: "otherval")

            dependencyGraphRenderer.complete();
        }

        getTextOutput().println();
        getTextOutput().text("A web-based, searchable dependency report is available by adding the ");
        getTextOutput().withStyle(UserInput).format("--%s", StartParameterBuildOptions.BuildScanOption.LONG_OPTION);
        getTextOutput().println(" option.");

        super.complete();
    }