final ToolingImplementationLoader target = Mock()
    final ProgressLoggerFactory loggerFactory = Mock()
    final InternalBuildProgressListener progressListener = Mock()
    final ConnectionParameters params = DefaultConnectionParameters.builder().build()
    final BuildCancellationToken cancellationToken = Mock()

import spock.lang.Specification

import java.util.concurrent.Callable
import java.util.function.Consumer

class UnpackingVisitorTest extends Specification {
    def context = Mock(Consumer)
    def resolver = Mock(PathToFileResolver)
    def patternSetFactory = Mock(Factory)
    def visitor = new UnpackingVisitor(context, resolver, TestFiles.taskDependencyFactory(), patternSetFactory)

    def "resolves null"() {
        when:

metadata:
  name: mock
  labels:
    app: mock
spec:
  ports:
  - port: 99
    protocol: TCP
    targetPort: 9949
  selector:
    app: mock
---
apiVersion: v1
kind: ReplicationController
metadata:
  name: mock
spec:
  replicas: 1
  selector:
    app: mock
  template:
    metadata:
      labels:
        app: mock
    spec:
      containers:
      - name: mock-container

        int cpt = dynCount++
        Mock(ResolvableSelectorState) {
            getVersionConstraint() >> Mock(ResolvedVersionConstraint) {
                isDynamic() >> true
            }
            toString() >> "dynamic selector $cpt"
        }
    }

    ResolvableSelectorState latestSelector() {
        Mock(ResolvableSelectorState) {
            getVersionConstraint() >> Mock(ResolvedVersionConstraint) {

        1 * lock.close()
        0 * _
    }

    def "notifies handler when lock is acquired and released"() {
        def action = Mock(Supplier)
        def onOpen = Mock(Consumer)
        def onClose = Mock(Consumer)
        def lock = Mock(FileLock)
        def signal = Mock(FileLockReleasedSignal)
        Consumer contendedAction

    FileResolver fileResolver = Mock(FileResolver)
    ScriptPluginFactory scriptPluginFactory = Mock(ScriptPluginFactory)
    ScriptHandlerFactory scriptHandlerFactory = Mock(ScriptHandlerFactory)
    ScriptHandler settingsScriptHandler = Mock(ScriptHandler)
    DefaultPluginManager pluginManager = Mock(DefaultPluginManager)
    FeatureFlags previews = Mock(FeatureFlags)
    DefaultSettings settings

        // given:
        val pluginManager = mock<PluginManagerInternal>()
        val target = mock<ProjectInternal> {
            on { this.pluginManager } doReturn pluginManager
        }
        val initialRequests = mock<PluginRequests>(name = "initialRequests")
        val autoAppliedPlugins = mock<PluginRequests>(name = "autoAppliedPlugins")
        val autoAppliedPluginHandler = mock<AutoAppliedPluginHandler> {

        given:
        def protocol1 = Mock(WorkerLoggingProtocol)
        def protocol2 = Mock(WorkerLoggingProtocol)
        listener.setWorkerLoggingProtocol(protocol1)
        def logEvent1 = Mock(LogEvent)
        def logEvent2 = Mock(LogEvent)
        def logEvent3 = Mock(StyledTextOutputEvent)
        def logEvent4 = Mock(LogEvent)

        when:
        listener.onOutput(logEvent1)

    }

    def "can temporarily release a project lock while waiting on async work"() {
        def workerLease = Mock(WorkerLeaseRegistry.WorkerLease)
        def workerLeaseService = Mock(WorkerLeaseService)
        def asyncWorkTracker = new DefaultAsyncWorkTracker(workerLeaseService)
        def operation1 = Mock(BuildOperationRef)

        when:
        asyncWorkTracker.registerWork(operation1, new AsyncWorkCompletion() {

    def stopsAllElementsOnStop() {
        Stoppable a = Mock()
        Stoppable b = Mock()
        stoppable.add(a)
        stoppable.add(b)

        when:
        stoppable.stop()

        then:
        1 * a.stop()
        1 * b.stop()
    }

    def stopsAllElementsWhenOneFailsToStop() {
        Stoppable a = Mock()
        Stoppable b = Mock()
        RuntimeException failure = new RuntimeException()