Failed tests:
        Test example.MyFailingTest#fail (Task: :secondTest)
        Test example.MyFailingTest#fail2 (Task: :secondTest)
        Test example.MyFailingTest#fail (Task: :test)
        Test example.MyFailingTest#fail2 (Task: :test)"""

        when:
        launchTests { TestLauncher testLauncher ->
            testLauncher.withJvmTestMethods("example.MyFailingTest", "fail")
        }

        then:

        System.out.println("out.fail");
        System.err.println("err.fail");
        fail("failing!");
    }
    @Test public void passing2() {
        System.out.println("out.pass2");
        System.err.println("err.pass2");
    }
    @Test public void failing2() {
        System.out.println("out.fail2");
        System.err.println("err.fail2");
        fail("failing2!");
    }

// boundsABI determines which register arguments a bounds check call should use. For an [a:b:c] slice, we do:
//
//	CMPQ c, cap
//	JA   fail1
//	CMPQ b, c
//	JA   fail2
//	CMPQ a, b
//	JA   fail3
//
// fail1: CALL panicSlice3Acap (c, cap)
// fail2: CALL panicSlice3B (b, c)
// fail3: CALL panicSlice3C (a, b)
//
// When we register allocate that code, we want the same register to be used for

            package example;
            public class MyFailingTest {
                @org.junit.Test public void fail() throws Exception {
                     org.junit.Assert.assertEquals(1, 2);
                }

                @org.junit.Test public void fail2() throws Exception {
                     org.junit.Assert.assertEquals(1, 2);
                }
            }"""

    }

        }
"""

        when:
        fails "fail"

        then:
        failure.assertHasCause('Could not create an instance of type Thing.')
        failure.assertHasCause('Too many parameters provided for constructor for type Thing. Expected 0, received 1.')
    }

    def "object creation fails with ObjectInstantiationException when construction parameters provided for interface"() {
        given:
        buildFile """

                    }

                    // Try to resolve configuration "fail" - this fails due to the repository being disabled, and the original cause is also printed underneath
                    configurations.fail.files
                }
            }
        """

        when:
        moduleA.pom.expectGetBlocking()
        fails('resolve', '--max-workers=1')

        then:

            }
            'org:test:1.0' {
                expectGetMetadata()
            }
        }
        fails ':checkDeps'

        then:
        failure.assertHasCause("Could not resolve org:test:1.+: Resolution strategy disallows usage of dynamic versions")
    }

    def "fails to resolve a transitive dependency which uses a dynamic version"() {
        buildFile << """
            dependencies {

        when: 'task fails'
        buildFile '''
            tasks.register('fail') {
                doLast { assert false }
            }
        '''
        configurationCacheFails 'fail'

        then: 'flow action reacts to build failure'
        outputContains '(red)'
        configCache.assertStateStored()

        when: 'task from cache fails'
        configurationCacheFails 'fail'

    def "reports and breaks build when tests fail"() {
        given:
        file('src/test/java/org/gradle/BrokenAfter.java') << """
            package org.gradle;

            ${testFrameworkImports}

            public class BrokenAfter {
                ${afterTestAnnotation}
                public void broken() {
                    fail("failed");
                }

                @Test

# Test that running a fuzz target that returns without failing or calling
# f.Fuzz fails and causes a non-zero exit status.
! go test noop_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that fuzzing a fuzz target that returns without failing or calling
# f.Fuzz fails and causes a non-zero exit status.
! go test -fuzz=Fuzz -fuzztime=1x noop_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that calling f.Error in a fuzz target causes a non-zero exit status.