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 "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)

    }

    def "adds only default attributes when multiple artifacts with different types"() {
        def attrs = ImmutableAttributes.EMPTY
        def attrsPlusFormat = concat(attrs, ["custom-default": "123"])
        def artifact1 = Stub(ComponentArtifactMetadata)
        def artifactName1 = Stub(IvyArtifactName)
        def artifact2 = Stub(ComponentArtifactMetadata)

        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 listenerManager = new DefaultListenerManager(Scope.BuildTree)
    def services = new DefaultServiceRegistry()

    def setup() {
        services.add(listenerManager)
    }

    def "automatically creates and registers stateful listener when first event is broadcast"() {
        def created = Mock(Runnable)
        def listener = Mock(TestListener)

        when:

    def locationAnalyzer = Mock(ProblemLocationAnalyzer)
    def userCodeContext = Mock(UserCodeApplicationContext)
    def factory = new DefaultProblemDiagnosticsFactory(DefaultFailureFactory.withDefaultClassifier(), locationAnalyzer, userCodeContext, 2)

    def "uses caller's stack trace to calculate problem location"() {
        given:
        def location = Stub(Location)

        cleanup:
        registry?.stop()
    }

    def "can run as worker thread"() {
        def registry = workerLeaseService(1)

        def action = {
            assert registry.workerThread
            def lease = registry.currentWorkerLease
            def nested = registry.runAsWorkerThread({
                assert registry.workerThread

            statusScheme == ["integration", "release"]
        }
    }

    def "supports rule with typed IvyModuleDescriptor parameter"() {
        def metadata = ivyMetadata()
        def id1 = new NamespaceId('namespace', 'info1')
        def id2 = new NamespaceId('namespace', 'info2')
        def extraAttrs = [:]
        extraAttrs[id1] = "info1 value"
        extraAttrs[id2] = "info2 value"

        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"() {