import org.gradle.api.tasks.util.PatternFilterable
import spock.lang.Specification

import java.util.function.Consumer

class CompositeFileTreeSpec extends Specification {
    def "tree filtered by spec has same live dependencies as tree"() {
        def task = Stub(Task)
        def dependency1 = Stub(Task)
        def dependency2 = Stub(Task)
        def dependencySource = Mock(TaskDependencyContainer)

package org.gradle.kotlin.dsl

import org.gradle.api.Task
import org.gradle.api.tasks.TaskCollection


/**
 * Returns a collection containing the objects in this collection of the given type. The
 * returned collection is live, so that when matching objects are later added to this
 * collection, they are also visible in the filtered collection.
 *
 * @param S The type of objects to find.

            // Not supported on Java 6
        }
    }

    private final Map<Object, Object> userData = new HashMap<Object, Object>();

    /**
     * This method can be used to store user data that should live among with this classloader
     *
     * @param consumerId the consumer
     * @param onMiss called to create the initial data, when not found
     * @param <T> the type of data
     * @return user data
     */

import java.io.RandomAccessFile
import java.net.ServerSocket
import java.net.Socket
import java.util.concurrent.Executor
import java.util.concurrent.ThreadFactory


fun BindingsBuilder.unsupportedTypes() {

    // Live JVM state
    bind(unsupported<ClassLoader>())
    bind(unsupported<Thread>())
    bind(unsupported<ThreadFactory>())
    bind(unsupported<Executor>())
    bind(unsupported<FileDescriptor>())

public interface FileLockContentionHandler {
    void start(long lockId, Consumer<FileLockReleasedSignal> whenContended);

    void stop(long lockId);

    int reservePort();

    /**
     * Pings the lock owner with the give port to start the lock releasing
     * process in the owner. May not ping the owner if:
     * - The owner was already pinged about the given lock before and the lock release is in progress

    withType(S::class.java, configuration)


/**
 * Returns a collection containing the objects in this collection of the given type. The
 * returned collection is live, so that when matching objects are later added to this
 * collection, they are also visible in the filtered collection.
 *
 * @param S The type of objects to find.

        then: // ensure ordering
        1 * rightSideEffect.execute("right")

        then: // ensure ordering
        1 * mergedSideEffect.execute(["left", "right"])
    }

    def "provider is live"() {
        given:
        def first = objects.property(String)
        def second = objects.property(String)

        def provider = new MergeProvider([first, second])

        when:
        first.set("1")

    implementation(libs.guava)
    implementation(libs.slf4jApi)

    runtimeOnly(project(":composite-builds"))
    runtimeOnly(project(":resources-http"))
    // TODO - move the isolatable serializer to model-core to live with the isolatable infrastructure
    runtimeOnly(project(":workers"))

    runtimeOnly(libs.kotlinReflect)

    testImplementation(projects.io)
    testImplementation(testFixtures(project(":core")))

- Click `Create subproject` button at the bottom of the "Subprojects" region of [this page](https://builds.gradle.org/admin/editProject.html?projectId=Gradle&tab=projectGeneralTab)
  - Select `Manually`.
  - Give it a name. The name will be displayed on TeamCity web UI. We highly recommend it be capitalized from the branch name, i.e. `MyTestBranch`.

 */
public interface FingerprintingStrategy {

    // TODO wolfs: Move these identifiers to the actual strategy classes when they live in :snapshots
    String CLASSPATH_IDENTIFIER = "CLASSPATH";
    String COMPILE_CLASSPATH_IDENTIFIER = "COMPILE_CLASSPATH";

    /**