}
        """
    }

    def "can filter tests"() {
        when:
        succeeds("test", "--tests", "SubClass.$testMethod")

        then:
        new DefaultTestExecutionResult(testDirectory)
            .assertTestClassesExecuted("SubClass")
            .testClass("SubClass")
            .assertTestCount(1, 0, 0)
            .assertTestPassed(testMethod)

        where:

            }
        """.stripIndent()

        when:
        run 'test'

        then:
        def result = new DefaultTestExecutionResult(testDirectory)
        result.assertTestClassesExecuted('org.gradle.JUnitTest')
        result.testClass('org.gradle.JUnitTest').assertTestPassed('mySystemClassLoaderIsUsed')
    }

    }

    def "reading a file in transform action with #task does not create a build input"() {
        given:
        getTransformFixture().tap {
            withTransformPlugin(testDirectory.createDir("buildSrc"))
            withJavaLibrarySubproject(testDirectory.createDir("subproject"))
        }

        settingsFile("""
            include("subproject")
        """)

        buildFile("""

    final TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    @AutoCleanup
    ResolutionResultsStoreFactory f = new ResolutionResultsStoreFactory(TestFiles.tmpDirTemporaryFileProvider(tmpDir.testDirectory))

    def "provides binary stores"() {
        def stores = f.createStoreSet()
        def store1 = stores.nextBinaryStore()
        def store2 = stores.nextBinaryStore()

        expect:

    def "ignores install name for all major operating system"() {
        given:
        def testDir = tmpDirProvider.testDirectory
        def outputFile = testDir.file("output/lib")

        final expectedArgs = [
            "-emit-library",
            "-o", outputFile.absolutePath,
            testDir.file("one.o").absolutePath].flatten()

    def "can create xcode project for unbuildable component"() {
        given:
        makeSingleProject()
        buildFile << configureTargetMachines("machines.os('os-family')")
        componentUnderTest.writeToProject(testDirectory)

        when:
        succeeds("xcode")

        then:
        executedAndNotSkipped(":xcodeProject", ":xcodeProjectWorkspaceSettings", ":xcodeWorkspace", ":xcodeWorkspaceWorkspaceSettings", ":xcode")

        assumeSwiftCompilerVersion(sourceCompatibility)

        given:
        settingsFile << "rootProject.name = '${fixture.projectName}'"
        makeSingleProject()

        fixture.writeToProject(testDirectory)

        when:
        succeeds("xcode")

        then:
        def targets = rootXcodeProject.projectFile.findTargets(fixture.moduleName)
        assertHasSwiftVersion(sourceCompatibility, targets)

        DefaultTestExecutionResult result = new DefaultTestExecutionResult(testDirectory)
        result.assertTestClassesExecuted("com.example.IncludedTest")
        result.assertTestClassesNotExecuted("com.example.ExcludedTest")
    }

    void assertIntegrationTestsWereExecutedAndExcluded() {
        DefaultTestExecutionResult result = new DefaultTestExecutionResult(testDirectory, 'build', '', '', 'integrationTest')

class WrapperUserHomeIntegrationTest extends AbstractWrapperIntegrationSpec {
    void 'uses gradle user home set by -Dgradle.user.home'() {
        given:
        prepareWrapper()
        def gradleUserHome = testDirectory.file('some-custom-user-home')

        when:
        def executer = wrapperExecuter.withGradleUserHomeDir(null)
        executer.withArguments("-Dgradle.user.home=$gradleUserHome.absolutePath")
        executer.run()

class MonkeyPatchRelocationIntegrationTest extends AbstractIntegrationSpec implements DirectoryBuildCacheFixture {

    def "can change task input's path sensitivity"() {
        def original = testDirectory.file("original")
        def relocated = testDirectory.file("relocated")

        setupProjectIn(original)
        setupProjectIn(relocated)

        inDirectory(original)
        withBuildCache().run "broken"

        when: