}

    def "nothing subscribed when no actions registered"() {
        expect:
        !r.isSubscribed(null)
        !r.isSubscribed(CharSequence)
        !r.isSubscribed(String)
    }

    def "actions are invoked in order registered"() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)

        given:
        r.registerEagerAddAction(String, action1)
        r.registerEagerAddAction(String, action2)

                "plugins" to sequenceOf("")
            )

        val action1 = resolverActionFor(environment, null)
        org.gradle.kotlin.dsl.fixtures.withInstanceOf<ResolverAction.RequestNew>(action1) {
            val action2 = resolverActionFor(environment, scriptDependencies())
            assertInstanceOf<ResolverAction.ReturnPrevious>(action2)
        }
    }

    @Test

        1 == defaultTask.actions.size()

        defaultTask.is(defaultTask.doFirst(action2))
        2 == defaultTask.actions.size()

        action2.is(defaultTask.actions[0].action)
        action1.is(defaultTask.actions[1].action)
    }

    def "doLast() adds action to the end of actions list"() {
        given:
        Action<Task> action1 = Actions.doNothing()

        manager.withPlugin("bar", action2)

        then:
        2 * action1.execute(_) >> { AppliedPlugin p ->
            assert p.id == "foo"
        }
        2 * action2.execute(_) >> { AppliedPlugin p ->
            assert p.id == "bar"
        }
        0 * action1._
        0 * action2._
    }

    def "action is notified for plugin with org.gradle id"() {

        def binary2 = Stub(SwiftBinary)
        def action1 = Mock(Action)
        def action2 = Mock(Action)
        def finalizeAction = Mock(Action)

        spec.isSatisfiedBy(binary2) >> true

        given:
        def p = container.get(spec)
        p.whenFinalized(finalizeAction)
        p.configure(action1)
        container.configureEach(action2)
        container.add(binary1)

                def release1 = cacheAccess.acquireFileLock()
                thread.blockUntil.action2
                release1.run()
                instant.action1
            }
            start {
                def release2 = cacheAccess.acquireFileLock()
                instant.action2
                thread.blockUntil.action1
                release2.run()
            }
        }

        then:

        outputs.stdOut.contains(expectedText)
        outputs.stdOut.contains("action1")
        !action1Intermediary || outputs.stdOut.contains("action2")

        and:
        1 * actionFactory1.createAction(!null, !null) >> {
            def action1 = { println "action1" }
            action1Intermediary ? action1 as ContinuingAction<ExecutionListener> : action1 as Action<ExecutionListener>

        }

        given:
        def action1 = {
            instant.action1Start
            thread.block()
            instant.action1End
        }
        def action2 = {
            instant.action2Start
        }

        when:
        start {
            synchronizer.runNow(action1)
        }
        async {
            thread.blockUntil.action1Start

        client?.stop()
    }

    def "manages contention for multiple locks"() {
        def action1 = new AtomicBoolean()
        def action2 = new AtomicBoolean()

        when:
        int port = handler.reservePort()
        handler.start(10, { action1.set(true) })
        handler.start(11, { action2.set(true) })

        client.maybePingOwner(port, 10, "lock 1", 50000, null)

        def cl1 = new URLClassLoader([implJar.toURI().toURL()] as URL[], getClass().classLoader)
        def action1 = cl1.loadClass("ActionImpl").getConstructor().newInstance()

        when:
        File actualJar1 = withConnection { ProjectConnection connection ->
            connection.action(action1).run()
        }
        cl1.close()
        Files.delete(implJar.toPath())

        then: