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!");
    }

            }
            '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 {

// license that can be found in the LICENSE file.

package main

var x = [4]int32{-0x7fffffff, 0x7fffffff, 2, 4}

func main() {
	if x[0] > x[1] {
		panic("fail 1")
	}
	if x[2]&x[3] < 0 {
		panic("fail 2") // Fails here
	}

            package example;

            import org.junit.jupiter.api.Test;

            import static org.junit.jupiter.api.Assertions.fail;

            public class UnitTestWithVerificationFailure {
                @Test
                public void unitTest() {
                    fail("intentional verification failure");
                }
            }
        '''
    }

                    }
                }
            }
        """
    }

    def "skips tests after a config method failure by default"() {
        expect:
        fails "test"

        and:
        testResults.assertConfigMethodFailed("fail")
        testResults.assertTestSkipped("someTest")
    }

    def "can be configured to continue executing tests after a config method failure"() {
        when:

# Matches no subtests, but parent test still fails
! go test -run TestThatFails/ThisWillNotMatch standalone_fail_sub_test.go
! stdout '^ok.*\[no tests to run\]'
! stderr '^ok.*\[no tests to run\]'
stdout 'FAIL'

-- standalone_fail_sub_test.go --
package standalone_fail_sub_test

import "testing"

func TestThatFails(t *testing.T) {
	t.Run("Sub", func(t *testing.T) {})
	t.Fail()

! stdout TestNotListed

# Running the test directly still fails, if we pass the flag.
go test -c -o ./zero.exe ./zero
! exec ./zero.exe -test.paniconexit0

# Using -json doesn't affect the exit status.
! go test -json ./zero
! stdout '"Output":"ok'
! stdout 'exit status'
stdout 'panic'
stdout '"Output":"FAIL'

# Running the test via test2json also fails.
! go tool test2json ./zero.exe -test.v -test.paniconexit0

    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

        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'

     * @throws BuildCacheException if the cache fails to store a cache entry for the given key
     */
    void store(BuildCacheKey key, BuildCacheEntryWriter writer) throws BuildCacheException;

    /**
     * Clean up any resources held by the cache once it's not used anymore.
     *
     * @throws IOException if the cache fails to close cleanly.
     */
    @Override
    void close() throws IOException;