}
            if (timePoints.containsKey(name)) {
                return
            }
            throw new IllegalStateException("Timeout waiting for instant '$name' to be defined by another thread.")
        }
    }

    private long monotonicClockMillis() {
        System.nanoTime() / 1000000L
    }

    def getProperty(String name) {
        synchronized (lock) {

        repository {
            'org:foo:1.0'()
            'org:foo:1.1'()
        }
        buildFile << """
            configurations {
                other.shouldResolveConsistentlyWith(another)
                another.shouldResolveConsistentlyWith(conf)
                conf.shouldResolveConsistentlyWith(other)
            }

            dependencies {
                conf 'org:foo:1.0'

    }

    @ToBeFixedForConfigurationCache
    def "can configure which source set dependency configurations contribute test dependencies to the classpath"() {
        given:
        mavenRepo.module('org', 'another').publish()
        buildFile << """
            configurations {
                integration
            }

            dependencies {
                integration 'org:lib:1.0'

    def "generates a prefix header file" () {
        def headers = new ArrayList<>()
        headers.add "header.h"
        headers.add "<stdio.h>"
        headers.add "some/path/to/another.h"
        def tempDir = tmpDirProvider.createDir("temp")
        def prefixHeaderFile = new File(tempDir, "prefix-headers.h")

        when:
        PCHUtils.generatePrefixHeaderFile(headers, prefixHeaderFile)

        executer.expectDocumentedDeprecationWarning("The foo configuration has been deprecated for resolution. This will fail with an error in Gradle 9.0. Please resolve another configuration instead. For more information, please refer to...

        cleanup:
        lock?.close()

        where:
        lockMode << [Exclusive, Shared]
    }

    def "a lock has not been updated when locking an existing file that has been read by another process since last open"() {
        given:
        def lockManager = new DefaultFileLockManager(metaDataProvider, contentionHandler)
        writeFile(lockManager)

        and:
        def lock = createLock(lockMode)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that inlining a function literal that captures both a type
// switch case variable and another local variable works correctly.

package a

func F(p *int, x any) func() {
	switch x := x.(type) {
	case int:
		return func() {
			*p += x
		}
	}
	return nil

    }

    def "can wire the output file of a task as input to another task using property"() {
        buildFile """
            class FileOutputTask extends DefaultTask {
                @InputFile
                final RegularFileProperty inputFile = project.objects.fileProperty()

        blockingHttpServer.expectConcurrent("taskAction3")

        expect:
        args("--max-workers=3")
        succeeds("parallelWorkTask")
    }

    def "starts dependent task in another project as soon as submitted work for current task is complete (with --parallel)"() {
        given:
        createDirs("childProject")
        settingsFile << """
            include ':childProject'
        """

import spock.lang.Issue

class DestroyerTaskCommandLineOrderIntegrationTest extends AbstractCommandLineOrderTaskIntegrationTest {
    def "destroyer task with a dependency in another project will run before producer tasks when ordered first (type: #type)"() {
        def foo = subproject(':foo')
        def bar = subproject(':bar')

        def cleanFoo = foo.task('cleanFoo').destroys('build/foo')