[[sec:build_script]]
== Build scripts

The build script is either a `build.gradle` file written in Groovy or a `build.gradle.kts` file in Kotlin.

The link:{groovyDslPath}/index.html[Groovy DSL^] and the link:{kotlinDslPath}/index.html[Kotlin DSL^] are the only accepted languages for Gradle scripts.

Let's take a look at an example and break it down:

====
[.multi-language-sample]
=====
.build.gradle.kts
[source,kotlin]
----
plugins {

configurations {
    create("gradleScriptsElements") {
        isVisible = false
        isCanBeResolved = false
        isCanBeConsumed = true
        attributes.attribute(Usage.USAGE_ATTRIBUTE, objects.named("start-scripts"))
        outgoing.artifact(startScripts)
    }

Each script is a text archive (go doc internal/txtar).
The script begins with an actual command script to run
followed by the content of zero or more supporting files to
create in the script's temporary file system before it starts executing.

As an example, run_hello.txt says:

	# hello world
	go run hello.go
	stderr 'hello world'
	! stdout .

	-- hello.go --

Yan Zhulanow <******@****.***> 1710406416 +0900

	}
	return reg
}

// Scripts returns the list of supported scripts. As all scripts are in a
// consecutive range, it simply returns a slice of numbers in increasing order.
// The "undefined" script is not returned.
func (s allSubtags) Scripts() []Script {
	scr := make([]Script, language.NumScripts)
	for i := range scr {
		scr[i] = Script{language.Script(i + 1)}
	}
	return scr
}

    }

    TestFile withDefaultSettingsGroovyIn(String baseDir) {
        return withSettingsGroovyIn(baseDir, defaultSettingsScript)
    }

    TestFile withSettingsGroovyIn(String baseDir, String script) {
        return withFile("$baseDir/$settingsFileName", script)
    }

    TestFile withBuildScript(String script = "") {
        return withBuildScriptIn(".", script)
    }

### Brief System Overview

The top-level scripts and utility scripts should be fairly well-documented. Here
is a brief explanation of how they tie together:

1.  `envs/*` are lists of variables made with bash syntax. A user must set a
    `TFCI` env param pointing to a list of `env` files.
2.  `utilities/setup.sh`, initialized by all top-level scripts, reads and sets
    values from those `TFCI` paths.

 * limitations under the License.
 */
package org.gradle.internal.scripts;

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.scripts.ScriptingLanguage;

import javax.annotation.Nullable;
import java.io.File;
import java.util.List;

/**
 * Resolves script files according to available {@link ScriptingLanguage} providers.
 *
 * @since 4.0

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# A single script that runs a predefined set of update-* scripts, as they often go together.
set -o errexit
set -o nounset
set -o pipefail

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/../..
source "${KUBE_ROOT}/hack/lib/init.sh"

SILENT=${SILENT:-true}

    def "init script file is a dotfile"() {
        def initScript = file('.empty')
        initScript << 'println "greetings from empty init script"'
        executer.withArguments('--init-script', initScript.absolutePath)

        when:
        run()

        then:
        output.contains("greetings from empty init script")
    }

    private def createExternalJar() {