result.testClass('pkg.FailedTest').assertTestFailed('failTest', CoreMatchers.anything())
        result.testClass('pkg.OtherTest').assertTestPassed('passingTest')

        where:
        description        | taskList                   | buildConfig
        'default config'   | ['test']                   | ''
        'failFast = false' | ['test']                   | 'test { failFast = false }'
    }

        root.file('src/test/java/pkg/FailedTest.java') << """
            package pkg;
            $testFrameworkImports
            public class FailedTest {
                @Test
                public void failTest() {
                    ${server.callFromBuild("$FAILED_RESOURCE")}
                    throw new RuntimeException();
                }
            }
        """.stripIndent()
    }

# test fail fast
! go test ./failfast_test.go -run='TestFailingA' -failfast=true
stdout -count=1 'FAIL - '
! go test ./failfast_test.go -run='TestFailing[AB]' -failfast=true
stdout -count=1 'FAIL - '
! 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 - '

  }

  fun enqueueResponse(response: MockResponse) {
    delegate.enqueueResponse(response.wrap())
  }

  override fun shutdown() {
    delegate.shutdown()
  }

  fun setFailFast(failFast: Boolean) {
    delegate.setFailFast(failFast)
  }

  fun setFailFast(failFastResponse: MockResponse?) {
    delegate.setFailFast(failFastResponse?.wrap())
  }

  }

  open fun clear() {
    responseQueue.clear()
  }

  override fun shutdown() {
    responseQueue.add(DEAD_LETTER)
  }

  open fun setFailFast(failFast: Boolean) {
    val failFastResponse =
      if (failFast) {
        MockResponse(code = HttpURLConnection.HTTP_NOT_FOUND)
      } else {
        null
      }
    setFailFast(failFastResponse)
  }

go test testcache -run=Benchtime -bench=Benchtime -benchtime=1x
! stdout '\(cached\)'

# golang.org/issue/47355: that includes the `-failfast` argument.
go test testcache -run=TestOSArgs -failfast
! stdout '\(cached\)'
go test testcache -run=TestOSArgs -failfast
stdout '\(cached\)'

# golang.org/issue/64638: that includes the `-fullpath` argument.
go test testcache -run=TestOSArgs -fullpath

        filter.setCommandLineIncludePatterns(testNamePattern);
        return this;
    }

    @Internal
    boolean getFailFast() {
        return failFast;
    }

    void setFailFast(boolean failFast) {
        this.failFast = failFast;
    }

    /**
     * The reports that this task potentially produces.
     *
     * @return The reports that this task potentially produces
     */

	"blockprofile":         true,
	"blockprofilerate":     true,
	"count":                true,
	"coverprofile":         true,
	"cpu":                  true,
	"cpuprofile":           true,
	"failfast":             true,
	"fullpath":             true,
	"fuzz":                 true,
	"fuzzminimizetime":     true,
	"fuzztime":             true,
	"list":                 true,
	"memprofile":           true,

# was emitted and whether it ended in a newline, but that seems too invasive.)
go test
! stderr .
stdout '^skippingok\s+example/skip'


-- go.mod --
module example

go 1.18
-- fail/fail_test.go --
package fail

import (
	"os"
	"testing"
)

func TestMain(m *testing.M) {
	os.Stderr.WriteString("exitcode=1")
	os.Exit(1)
}
-- skip/skip_test.go --
package skip

import (

                <td>excludes</td>
                <td>[]</td>
            </tr>
            <tr>
                <td>testLogging</td>
                <td/>
            </tr>
            <tr>
                <td>failFast</td>
                <td><literal>false</literal></td>
            </tr>
            <tr>
                <td>modularity</td>
                <td/>
            </tr>
            <tr>