@Rule
    public final TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())

    def toolchainConfiguration = Mock(ToolchainConfiguration)
    TestFile candidates

    @Subject
    def supplier = new JabbaInstallationSupplier(toolchainConfiguration)

    def setup() {
        candidates = temporaryFolder.createDir("candidates")

    @Rule
    GitHttpRepository repoA = new GitHttpRepository(httpServer, 'testA', temporaryFolder.getTestDirectory())
    @Rule
    GitHttpRepository repoB = new GitHttpRepository(httpServer, 'testB', temporaryFolder.getTestDirectory())
    @Rule
    GitHttpRepository repoC = new GitHttpRepository(httpServer, 'testC', temporaryFolder.getTestDirectory())

    def setup() {
        httpServer.start()
        settingsFile << """

import spock.lang.Specification
import spock.lang.Subject

import java.util.concurrent.Callable

abstract class AbstractJvmPluginServicesTest extends Specification {
    @Rule
    final TestNameTestDirectoryProvider temporaryFolder = TestNameTestDirectoryProvider.newInstance(getClass())

    def configurations = Mock(ConfigurationContainer)
    def instanceGenerator = Mock(InstanceGenerator)
    def tasks = Mock(TaskContainerInternal)

        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)
        when:
        objCppPCHCompile.toolChain = toolChain
        objCppPCHCompile.targetPlatform = platform
        objCppPCHCompile.compilerArgs = ["arg"]
        objCppPCHCompile.macros = [def: "value"]
        objCppPCHCompile.objectFileDir = temporaryFolder.file("outputFile")

    private ProjectDependencyMetadataConverter converter = new ProjectDependencyMetadataConverter(excludeRuleConverterStub)

    @Rule
    TestNameTestDirectoryProvider temporaryFolder = TestNameTestDirectoryProvider.newInstance(getClass())

    def canConvert() {
        expect:
        converter.canConvert(Mock(ProjectDependency))
        !converter.canConvert(Mock(ExternalModuleDependency))
    }

        }
    }

    @Rule
    public final ScopeIdsFixture scopeIds = new ScopeIdsFixture(delegatingExecuter, temporaryFolder)

    @Rule
    public final OriginFixture originBuildInvocationIdFixture = new OriginFixture(delegatingExecuter, temporaryFolder)

    String getBuildInvocationId() {
        scopeIds.buildInvocationId.asString()
    }

    String originBuildInvocationId(String taskPath) {

import org.junit.Rule
import spock.lang.Specification
import spock.lang.Subject

class ModuleMetadataStoreTest extends Specification {

    @Rule TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    def pathKeyFileStore = Mock(PathKeyFileStore)
    def repository = "repositoryId"
    def fileStoreEntry = Mock(LocallyAvailableResource)

    }

    def "executes using the Assembler"() {
        def inputDir = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)
        when:
        assembleTask.toolChain = toolChain
        assembleTask.targetPlatform = platform
        assembleTask.assemblerArgs = ["arg"]
        assembleTask.objectFileDir = temporaryFolder.file("outputFile")
        assembleTask.source inputDir
        execute(assembleTask)

        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)
        when:
        cPCHCompile.toolChain = toolChain
        cPCHCompile.targetPlatform = platform
        cPCHCompile.compilerArgs = ["arg"]
        cPCHCompile.macros = [def: "value"]
        cPCHCompile.objectFileDir = temporaryFolder.file("outputFile")
        cPCHCompile.source sourceFile

 * to clean up.  It defaults to "temporaryFolder", which is the field for AbstractIntegrationSpec.  Other specs
 * can set it accordingly using "fieldName".
 */
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@ExtensionAnnotation(CleanupTestDirectoryExtension)
@interface CleanupTestDirectory {
    String fieldName() default "temporaryFolder";