}

    def "compileBadCode"() {
        expect:
        fails("compileGroovy")
        failure.assertHasErrorOutput 'unable to resolve class Unknown1'
        failure.assertHasErrorOutput 'unable to resolve class Unknown2'
        failure.assertHasCause(compilationFailureMessage)
    }

    def "compileBadJavaCode"() {
        expect:
        fails("compileGroovy")

            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")',
        ]
    }

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.")

			for _, card := range hand {
				if card < 0 || card >= int(test.deckSize) {
					t.Errorf("test case %s fails in range check", test.name)
					return
				}
				cardMap[card] = struct{}{}
			}
			if len(cardMap) != int(test.handSize) {
				t.Errorf("test case %s fails in duplication check", test.name)
				return
			}

		})
	}
}

        """

        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)