failure.assertThatCause(containsString("Only Settings scripts can contain a pluginManagement {} block."))
        includesLinkToUserguide()

        and:
        verifyAll(receivedProblem) {
            fqid == 'compilation:groovy-dsl:compilation-failed'
            contextualLabel == "Could not compile initialization script '${initScript.absolutePath}'."
        }
    }

import org.gradle.groovy.scripts.internal.Permits;
import org.gradle.groovy.scripts.internal.RestrictiveCodeVisitor;
import org.gradle.groovy.scripts.internal.ScriptBlock;

import static org.gradle.groovy.scripts.internal.AstUtils.hasSingleConstantArgOfType;
import static org.gradle.groovy.scripts.internal.AstUtils.hasSingleConstantStringArg;
import static org.gradle.groovy.scripts.internal.AstUtils.hasSinglePropertyExpressionArgument;

		})
}

// Stop returns a sentinel error that causes script execution to halt
// and s.Execute to return with a nil error.
func Stop() Cmd {
	return Command(
		CmdUsage{
			Summary: "stop execution of the script",
			Args:    "[msg]",
			Detail: []string{
				"The message is written to the script log, but no error is reported from the script engine.",
			},
		},

├── shared
│   ├── src
│   │   └──...
│   └── build.gradle
└── settings.gradle
----
<1> Create the `MyCustomTask` task.
<2> A shared build script.
<3> Uses the `MyCustomTask` task and shared build script.
=====

In the `buildSrc`, the build script `shared.gradle(.kts)` is created.
It contains dependencies and other build information that is common to multiple subprojects:

[.multi-language-sample]
=====

This can easily be handled by conditionally applying a version-compliant script.

NOTE: The version-compliant script should reside somewhere other than the `init.d` directory (such as a sub-directory), so it is not automatically applied.

|===

[[sec:build_script_plugins]]
== Script plugins

*Script plugins* are typically small, local plugins written in script files for tasks specific to a single build or project.
They do not need to be reused across multiple projects.
Script plugins *are not recommended* but many other forms of plugins evolve from script plugins.

        """

        then:
        succeeds("help")
    }

    def "adding precompiled script support does not fail when there are no precompiled scripts"() {
        when:
        enablePrecompiledPluginsInBuildSrc()

        then:
        succeeds("help")
    }

    def "can apply a precompiled script plugin by id"() {
        given:
        enablePrecompiledPluginsInBuildSrc()

    }

    def "pom conversion to kotlin build scripts is triggered when pom and no gradle file found"() {
        given:
        pom()

        when:
        run('init')

        then:
        pomValuesUsed(rootProjectDslFixtureFor(KOTLIN))
    }

    def "pom conversion to #scriptDsl build scripts not triggered when build type is specified"() {
        given:
        pom()

    }

    def "can change template file for default start script generators"() {
        given:
        file('customUnixStartScript.txt') << '${applicationName} start up script for UN*X'
        file('customWindowsStartScript.txt') << '${applicationName} start up script for Windows'
        buildFile << """
startScripts {
    applicationName = 'myApp'

<3> Gradle wrapper start scripts
<4> Settings file to define build name and subprojects
<5> Build script for `app` subproject
<6> Default Java source folder for `app` subproject
<7> Default Java test source folder for `app` subproject
=====

The `authoring-tutorial` folder is the *root project directory*.
Inside the root project directory are one or more subprojects, build scripts, and the Gradle wrapper.