}

        and:
        context.current() == null
    }

    def "can nest application"() {
        def source = Stub(UserCodeSource)
        def source2 = Stub(UserCodeSource)
        def action = Mock(Action)
        def action2 = Mock(Action)
        def id1

        when:
        context.apply(source, action)

        then:

        then:
        def e = thrown(RuntimeException)
        e == failure

        cleanup:
        cacheAccessWorker?.stop()
    }

    def "read completes after failed update"() {
        given:
        def failure = new RuntimeException()
        start(cacheAccessWorker)

        when:
        cacheAccessWorker.enqueue { throw failure }
        def result = cacheAccessWorker.read { 2 }

    }

    def callsVetoActionBeforeObjectIsAdded() {
        def action = Mock(Action)
        container.beforeCollectionChanges(action)

        when:
        container.add("a")

        then:
        1 * action.execute(null)
        0 * _
    }

    def objectIsNotAddedWhenVetoActionThrowsAnException() {
        def action = Mock(Action)
        def failure = new RuntimeException()

    }

    def "serializes method invocations for multiple methods"() {
        def method1 = String.class.getMethod("substring", Integer.TYPE, Integer.TYPE)
        def method2 = String.class.getMethod("substring", Integer.TYPE)
        def invocation1 = new MethodInvocation(method1, [1, 2] as Object[])
        def invocation2 = new MethodInvocation(method2, [3] as Object[])

        def otherSuccessful = ExecutionResult.succeeded()
        def failed = ExecutionResult.failed(failure1)
        def otherFailed = ExecutionResult.failed(failure2)
        def allFailed = ExecutionResult.maybeFailed([failure1, failure2])

        expect:
        def result = successful.withFailures(otherSuccessful)
        result.value == 12
        result.failures.empty

        def result2 = successful.withFailures(failed)

    private static final Attribute<String> BAZ = Attribute.of("baz", String)

    def isolatableFactory = SnapshotTestUtil.isolatableFactory()
    def instantiator = TestUtil.objectInstantiator()

    def factory = new DefaultImmutableAttributesFactory(isolatableFactory, instantiator)

    def "can create empty set"() {
        when:
        def attributes = factory.root

        then:
        attributes.empty

        def nameOnly = new DefaultModuleComponentArtifactIdentifier(componentId, "name", "type", null, null)
        def nameOnlyFileName = new ComponentFileArtifactIdentifier(componentId, "name-version")
        nameOnly.displayName == nameOnlyFileName.displayName
    }

    //ComponentFileArtifactIdentifier

    def "calculates a file name from attributes"() {

        and:
        def hasher2 = Hashing.newHasher()
        hasher2.putInt(1)

        then: "closing them in reverse order"
        def hash2 = hasher2.hash()
        def hash1 = hasher1.hash()

        then:
        hash2 == hash1
    }

    def 'hasher works without calling final hash method'() {
        given:
        def value = ('a'..'z').join()

        when:
        def hasher1 = Hashing.newHasher()

        expressions[4].is(SimpleExpression.RIGHT_PAREN)
    }

    def "serializes macro directives"() {
        def macro1 = new MacroWithSimpleExpression("ONE", IncludeType.QUOTED, "one")
        def macro2 = new MacroWithSimpleExpression("TWO", IncludeType.MACRO, "two")
        def macro3 = new MacroWithComplexExpression("THREE", IncludeType.MACRO_FUNCTION, "abc", [])

    def "runs methods in a single worker process and stops when requested"() {
        when:
        def builder = workerFactory.multiRequestWorker(StatefulTestWorker.class)
        def worker = builder.build()
        worker.start()
        def result1 = worker.run("value")
        def result2 = worker.run("value")
        def result3 = worker.run("value")
        worker.stop()