List<XCTestCaseElement> testCases = [
            passingTestCase("testA"),
        ]
    }

    final XCTestSourceFileElement alternateFooTestSuite = new XCTestSourceFileElement("FooTestSuite") {
        List<XCTestCaseElement> testCases = [
            passingTestCase("testA"),
            passingTestCase("testB")
        ]
    }

            }
        }
        listerInteractions.expectRefresh('testA')
        succeeds 'checkDeps', '--refresh-dependencies'

        then:
        outputContains("Listing versions for module testA")

        where:
        lister               | modules
        'simple'             | [testA: [1, 2, 3]]
        'file on repository' | [testA: [1, 2, 3]]
    }

    void "can recover from broken lister"() {

    private final static String ALL_METADATA = new JsonBuilder(
        [
            [group:'org', name: 'testA', version: '3', attributes: ['org.gradle.status': 'release', 'custom': 'foo']],
            [group:'org', name: 'testA', version: '2', attributes: ['org.gradle.status': 'integration', 'custom': 'bar']],
            [group:'org', name: 'testA', version: '1', attributes: ['org.gradle.status': 'release', 'custom': 'bar']],

        List<XCTestCaseElement> testCases = [
            passingTestCase("testA"),
            passingTestCase("testB")
        ]
    }

    final XCTestSourceFileElement alternateFooTestSuite = new XCTestSourceFileElement("FooTestSuite") {
        List<XCTestCaseElement> testCases = [
            passingTestCase("testA")
        ]
    }

package x
-- pkgs/a_test.go --
package x_test

import "testing"

func TestX(t *testing.T) {
}
-- pkgs/a/a.go --
package a
-- pkgs/a/a_test.go --
package a_test

import "testing"

func TestA(t *testing.T) {

package a_test

import (
	"cfg/a"
	"testing"
)

func TestA(t *testing.T) {
	a.A(0)
	var aat a.Atyp
	at := &aat
	at.Set(42)
	println(at.Get())

! go test ./failfast_test.go -run='TestFailing[AB]' -failfast=false
stdout -count=2 'FAIL - '

# mix with non-failing tests
! go test ./failfast_test.go -run='TestA|TestFailing[AB]' -failfast=true
stdout -count=1 'FAIL - '
! go test ./failfast_test.go -run='TestA|TestFailing[AB]' -failfast=false
stdout -count=2 'FAIL - '

# mix with parallel tests
! go test ./failfast_test.go -run='TestFailingB|TestParallelFailingA' -failfast=true

        given:
        repository {
            'org:testA:1.0' {
                variant('runtime') {
                    capability('org', 'testA', '1.0')
                    capability('cap')
                }
            }
            'org:testB:1.0' {
                variant('runtime') {
                    capability('org', 'testB', '1.0')

! stdout 'DATA RACE'
-- main_panic/testmain_parallel_sub_panic_test.go --
package testmain_parallel_sub_panic_test

import "testing"

func setup()    { println("setup()") }
func teardown() { println("teardown()") }
func TestA(t *testing.T) {
	t.Run("1", func(t *testing.T) {
		t.Run("1", func(t *testing.T) {
			t.Parallel()
			panic("A/1/1 panics")
		})
		t.Run("2", func(t *testing.T) {
			t.Parallel()
			println("A/1/2 is ok")
		})

class RemoteSourceDependencyIntegrationTest extends AbstractIntegrationSpec {
    @Rule
    BlockingHttpServer httpServer = new BlockingHttpServer()
    @Rule
    GitHttpRepository repoA = new GitHttpRepository(httpServer, 'testA', temporaryFolder.getTestDirectory())
    @Rule
    GitHttpRepository repoB = new GitHttpRepository(httpServer, 'testB', temporaryFolder.getTestDirectory())
    @Rule