def operations = new BuildOperationsFixture(executer, temporaryFolder)

    def "emitsBuildOperationsForJUnitTests"() {
        given:
        executer.withRepositoryMirrors()

        when:
        run "test"

        then: "test build operations are emitted in expected hierarchy"
        def rootTestOp = operations.first(ExecuteTestBuildOperationType)

 */

package org.gradle.integtests.fixtures

import org.junit.Assume

abstract class AbstractSampleIntegrationTest extends AbstractIntegrationSpec {
    def setup() {
        executer.withRepositoryMirrors()
    }

    def configureExecuterForToolchains(String... versions) {
        def jdks = AvailableJavaHomes.getJdks(versions)
        Assume.assumeTrue(versions.length == jdks.size())

class JUnit4TestFilteringSamplesIntegrationTest extends AbstractIntegrationSpec {

    @Rule Sample sample = new Sample(temporaryFolder, 'testing/filtering/groovy')

    def setup() {
        executer.withRepositoryMirrors()
    }

    def "uses test filter"() {
        when:
        inDirectory(sample.dir)
        run("test")

        then:
        def result = new DefaultTestExecutionResult(sample.dir)

    @Rule public final Sample sample = new Sample(temporaryFolder, 'webApplication/quickstart/groovy')
    @Rule ReleasingPortAllocator portFinder = new ReleasingPortAllocator()

    def setup() {
        executer.withRepositoryMirrors()
    }

    def "can build a war"() {
        given:
        super.sample sample

        when:
        executer.withTasks('clean', 'build').run()

        then:

import org.junit.Rule

class SamplesJavaCustomizedLayoutIntegrationTest extends AbstractSampleIntegrationTest {

    @Rule
    Sample sample = new Sample(testDirectoryProvider)

    def setup() {
        executer.withRepositoryMirrors()
    }

    @UsesSample('java/customizedLayout')
    def "can build jar with #dsl dsl"() {
        TestFile javaprojectDir = sample.dir.file(dsl)

        // Build and test projects

class SamplesDefiningUsingConfigurationsIntegrationTest extends AbstractIntegrationSpec {

    @Rule
    Sample sample = new Sample(testDirectoryProvider)

    def setup() {
        executer.withRepositoryMirrors()
    }

    @UsesSample("dependencyManagement/definingUsingConfigurations-custom")

    @Rule
    final TestResources resources = new TestResources(testDirectoryProvider)

    def "retainsStackTraceForInheritedTestMethods"() {
        given:
        executer.withRepositoryMirrors()
        executer.withStackTraceChecksDisabled()

        when:
        runAndFail "test"

        then:
        outputContains("Base.java:6")
        // TestThatInherits > alwaysFails() FAILED

    def operations = new BuildOperationsFixture(delegatingExecuter, temporaryFolder)

    void afterBuild() {
        afterExecute*.execute(executer)
    }

    def setup() {
        executer.withRepositoryMirrors()
    }

    def "emits test operations for continuous builds"() {
        given:
        resources.maybeCopy('TestExecutionBuildOperationsIntegrationTest/emitsBuildOperationsForJUnitTests')

import org.junit.Rule

class SamplesDeclaringRepositoriesIntegrationTest extends AbstractIntegrationSpec {

    @Rule
    Sample sample = new Sample(testDirectoryProvider)

    def setup() {
        executer.withRepositoryMirrors()
    }

    @UsesSample("dependencyManagement/declaringRepositories-multipleRepositories")
    def "can declare multiple repositories and resolve binary dependency"() {

class SamplesJavaPatchModuleIntegrationTest extends AbstractIntegrationSpec {

    @Rule Sample sample = new Sample(temporaryFolder, 'testing/patch-module')

    def setup() {
        executer.withRepositoryMirrors()
    }

    def "can compile and run patched module whitebox tests with #dsl dsl"() {
        when:
        executer.inDirectory(sample.dir.file(dsl))
        succeeds('build')

        then: