then:
        succeeds "echo"
        outputContains "values: [true, false, false]"
    }

    def "only literal strings can be given to dollar method - #code"() {
        when:
        buildScript """
        model {
          foo {
            $code
          }
        }
        """

        then:
        fails "tasks"
        failure.assertHasLineNumber 4

	if !enableTestHooks {
		panic("web: test hooks not enabled")
	}
	enableTestHooks = false
	testInterceptors = nil
}

var (
	enableTestHooks  = false
	testInterceptors []Interceptor
)

func interceptURL(u *urlpkg.URL) (*Interceptor, bool) {
	if !enableTestHooks {
		return nil, false
	}
	for i, t := range testInterceptors {

									},
								},
							},
							TopologyKey: v1.LabelHostname,
						},
					},
				},
			},
			errorExpected: false,
		},
		// invalid topologyKey in requiredDuringSchedulingIgnoredDuringExecution then admission fails.
		{
			affinity: &api.Affinity{
				PodAntiAffinity: &api.PodAntiAffinity{
					RequiredDuringSchedulingIgnoredDuringExecution: []api.PodAffinityTerm{
						{

		input  []byte
		expect []byte
		stale  bool
		err    error
		match  int
	}{
		{[]byte("first:value"), []byte("value1"), false, nil, 0},
		{[]byte("second:value"), []byte("value2"), true, nil, 1},
		{[]byte("third:value"), nil, false, testErr, -1},
		{[]byte("fails:value"), nil, false, transformErr, 2},
		{[]byte("stale:value"), []byte("value3"), true, nil, 3},
	}
	for i, test := range testCases {

        task.someFlag
        otherTask.someFlag
    }

    def "fails if some of the types cannot accommodate the setting"() {
        when:
        configurer.configureTasks([task, defaultTask], ['--someFlag'])

        then:
        def ex = thrown(TaskConfigurationException)
        ex.cause.message.contains('someFlag')
    }

    def "fails if one of the options cannot be applied to one of the tasks"() {
        when:

    !!! tip "Tipp"
        Bevorzugen Sie die `Annotated`-Version, falls möglich.

    ```Python hl_lines="16"
    {!> ../../../docs_src/dependencies/tutorial011.py!}
    ```

Und auf diese Weise können wir unsere Abhängigkeit „parametrisieren“, die jetzt `"bar"` enthält, als das Attribut `checker.fixed_content`.

## Die Instanz als Abhängigkeit verwenden

        executed ":pluginBuild:jar", ":pluginBuild:assemble", ":assemble"

        where:
        withVersion << [true, false]
    }

    def "can co-develop plugin and consumer with plugin as included library build using 'apply plugin', withVersion: #withVersion"() {
        given:
        applyPlugin(buildA, false, withVersion)
        addLifecycleTasks(buildA)

        includeBuild pluginBuild

        when:

        then:
        result.getLockedDependencies() == [newId(DefaultModuleIdentifier.newId('org', 'bar'), '1.1')] as Set

        where:
        unique << [true, false]
    }

    def 'fails with invalid content in lock file (Unique: #unique)'() {
        given:
        writeLockFile(["invalid"], unique)

        when:
        provider.loadLockState('conf', owner)

        then:

            def someMethod() {}
            apply from: "script2.gradle"
        """

        file("script2.gradle") << """
            someMethod()
        """

        when:
        fails "help"

        then:
        failure.assertHasFileName("Script '${file("script2.gradle").absolutePath}'")
        failure.assertThatCause(containsText("Could not find method someMethod()"))
    }

			expected: map[string]bool{"foo": true, "foo/bar": false, "foo/baz": true, "qux": false},
		},
		{
			name:     "options can skip phases - hierarchy is considered",
			options:  RunnerOptions{SkipPhases: []string{"foo"}},
			expected: map[string]bool{"foo": false, "foo/bar": false, "foo/baz": false, "qux": true},
		},
		{
			name: "skip options have higher precedence than filter options",
			options: RunnerOptions{