}

    def "the lock holder starts the release request only once and discards additional requests in the meantime"() {
        given:
        def requestReceived = false
        def terminate = false
        setupLockOwner {
            requestReceived = true
            while(!terminate) { Thread.sleep(100) } //block the release action thread
        }

        when:

    }

    def "ignores missing dependency if there is an #relation relation in the other direction"() {
        def sourceDir = "src"
        file(sourceDir).createDir()
        def outputDir = "build/output"

        buildFile """
            task firstTask {
                inputs.dir("${sourceDir}")
                def outputDir = file("${outputDir}")
                outputs.dir(outputDir)

                }
            }
        """
    }

    def <T> T fetchModel(Class<T> type = SomeToolingModel.class, String... tasks = null) {
        def model = null
        result = toolingApiExecutor.runBuildWithToolingConnection { connection ->
            def output = new ByteArrayOutputStream()
            def error = new ByteArrayOutputStream()
            def args = executer.allArgs
            args.remove("--no-daemon")

    private identifier = new OperationIdentifier(2)

    def setup() {
        def diagnosticsFactory = new NoOpProblemDiagnosticsFactory()

        problemEmitter = Mock(ProblemEmitter)
        def currentBuildRef = Mock(CurrentBuildOperationRef)

        currentBuildRef.getId() >> identifier

        def buildOperationProgressEventEmitter = Mock(BuildOperationProgressEventEmitter)

        buildFinishedHandler.getResult() == "build"
    }

    def "failures from action are received and future actions not run"() {
        def projectsLoadedHandler = new IntermediateResultHandlerCollector()
        def buildFinishedHandler = new IntermediateResultHandlerCollector()

        when:
        withConnection { connection ->
            def action = connection.action()

import org.gradle.internal.serialize.PlaceholderException
import spock.lang.Specification

class FullExceptionFormatterTest extends Specification {
    def testDescriptor = new SimpleTestDescriptor()
    def testLogging = Mock(TestLogging)
    def formatter = new FullExceptionFormatter(testLogging)

    def "shows all exceptions that have occurred for a test"() {
        expect:

            }

            def threaded(Closure action) {
                Thread.start(action).join()
            }
        """

        when:
        succeeds("all")

        then:
        10.times { projectCount ->
            def allExecutionOp = operations.only("Execute doLast {} action for :project-${projectCount}:all")
            def allExecutionOpTaskProgresses = allExecutionOp.progress

        "explicitly enabled"        | true
    }

    def "cleans up entries even if gradle user home cache cleanup is disabled via #cleanupMethod"() {
        def lastCleanupCheck = initializeHome()

        disableCacheCleanup(cleanupMethod)

        when:
        def newTrashFile = temporaryFolder.file("0" * hashStringLength).createFile()
        def oldTrashFile = temporaryFolder.file("1" * hashStringLength).createFile()

    }

    def "uses #what toolchain #when (without java base plugin)"() {
        def currentJdk = Jvm.current()
        def otherJdk = AvailableJavaHomes.differentVersion
        def selectJdk = { it == "other" ? otherJdk : it == "current" ? currentJdk : null }

        def compileWithVersion = [currentJdk, otherJdk].collect { it.javaVersion }.min()

    private static final String REPOSITORY_ID = 'abc'
    def delegate = Mock(ModuleComponentRepositoryAccess)
    def repositoryBlacklister = Mock(RepositoryDisabler)

    @Shared
    def runtimeError = new RuntimeException('Something went wrong')
    @Shared
    def socketError = new SocketException()
    @Shared
    def connectTimeout = new SocketTimeoutException()
    @Shared
    def cannotConnect = new HttpHostConnectException(null, null)