model {
              foo {
                $code
              }
            }
        """

        then:
        succeeds "tasks" // succeeds because we don't fail on invalid usage, and don't fail due to unbound inputs

        where:
        code << [
            'something.$(1)',
            'this.$("$name")',
            'foo.bar().$("a" + "b")',
        ]
    }

                Integer fail1 = SmbTransportPoolImpl.this.failCounts.get(o1.getHostAddress());
                Integer fail2 = SmbTransportPoolImpl.this.failCounts.get(o2.getHostAddress());
                if ( fail1 == null ) {
                    fail1 = 0;
                }
                if ( fail2 == null ) {
                    fail2 = 0;
                }

func NewSyncResult(action SyncAction, target interface{}) *SyncResult {
	return &SyncResult{Action: action, Target: target}
}

// Fail fails the SyncResult with specific error and message
func (r *SyncResult) Fail(err error, msg string) {
	r.Error, r.Message = err, msg
}

// PodSyncResult is the summary result of SyncPod() and KillPod()
type PodSyncResult struct {

    /*
        Note: these tests are very granular to ensure coverage for versions that
              don't support querying the output or tasks.
     */

    def "does not throw exception when build fails expectantly"() {
        given:
        buildScript """
            task helloWorld {
                doLast {
                    throw new GradleException('Expected exception')
                }
            }

            }
        """

        when:
        fails ':help'

        then:
        result.assertTaskExecuted(':buildSrc:jar')
        result.assertTaskNotExecuted(':help')
        failure.assertHasCause('Cannot resolve external dependency org:module:1.0 because no repositories are defined.')
    }

    // fails to delete directory under Windows otherwise

        !dsl.getBuildFile(targetDir).text.contains("java.targetCompatibility = ")

        when:
        fails 'clean', 'build'

        then:
        // when tests fail, jar may not exist
        failure.assertHasDescription("Execution failed for task ':test'.")
        failure.assertHasCause("There were failing tests.")
    }

    def "adding and removing tests remove old tests from reports"() {
        given:
        createPassingFailingTest()
        fails("check")
        when:
        renameTests()
        fails("check")
        then:
        testResult.assertTestClassesExecuted('SomeTest', 'NewTest')
    }

                dependsOn(firstTask)
                credentials.set(providers.credentials(PasswordCredentials, 'testCredentials'))
            }
        """

        when:
        fails 'taskWithCredentials'

        then:
        notExecuted(':firstTask', ':taskWithCredentials')
        failure.assertHasDescription("Credentials required for this build could not be resolved.")

        """

        expect:
        fails()
        failure.assertHasLineNumber(4)
        failure.assertHasCause("Could not set unknown property 'p1' for root project 'test' of type ${Project.name}.")
    }

    def failsWhenInvokingUnknownMethodOnProject() {
        buildFile """
            unknown(12, "things")
        """

        expect:
        fails()
        failure.assertHasLineNumber(2)

         */
        DO_NOT_SKIP,

        /**
         * Use this reason on unrolled tests in super classes that fail on some subclasses.
         * Spock doesn't allow to override test methods and annotate them.
         */
        UNROLLED_FAILS_IN_SUBCLASS,

        /**
         * Use this reason on tests that fail <code>:verifyTestFilesCleanup</code> with configuration cache.
         */
        FAILS_TO_CLEANUP,

        /**