when:
        def result = registry.get(BigDecimal)

        then:
        result == value

        and:
        1 * parent.get(BigDecimal) >> value
    }

    def delegatesToParentsForUnknownService() {
        def value = BigDecimal.TEN
        def parent1 = Mock(ParentServices)
        def parent2 = Mock(ParentServices)

    def "producer task with a dependency in another project will run before destroyer tasks when ordered first (type: #type)"() {
        def foo = subproject(':foo')
        def bar = subproject(':bar')

        def cleanFoo = foo.task('cleanFoo').destroys('build/foo')
        def cleanBar = bar.task('cleanBar').destroys('build/bar')

        1 * selectedComponentResult.matches(b.id)
        0 * _

    }

    def "chooses newest non rejected matching version without requiring metadata"() {
        given:
        def a = component('1.2')
        def b = component('1.3')
        def c = component('2.0')
        def d = component('1.1')
        def selectedComponentResult = Mock(ComponentSelectionContext)

        when:

        def apiElements9 = [attributes(Usage.JAVA_API, LibraryElements.JAR, 9)]
        def runtimeElements9 = [attributes(Usage.JAVA_RUNTIME, LibraryElements.JAR, 9)]

        def apiElements11 = [attributes(Usage.JAVA_API, LibraryElements.JAR, 11)]
        def runtimeElements11 = [attributes(Usage.JAVA_RUNTIME, LibraryElements.JAR, 11)]

        when:

    }

    def "detects no processors when processor declaration is missing"() {
        given:
        def jar = tmpDir.file("classes.jar")
        jar << JarUtils.jarWithContents()
        def dir = tmpDir.file("classes")
        def cp = files(jar, dir)

        expect:
        detector.detectProcessors(cp) == [:]
    }

        then:
        _ * provider2.elementType >> type
        0 * _
    }

    def "can execute action to configure element when element is realized"() {
        containerAllowsExternalProviders()
        def action = Mock(Action)
        def provider1 = Mock(ProviderInternal)
        def provider2 = Mock(ProviderInternal)
        def provider3 = Mock(CollectionProviderInternal)

        given:

    }

    def "artifact is attached to child configurations"() {
        given:
        def artifact1 = artifactName()
        def artifact2 = artifactName()
        def artifact3 = artifactName()
        def file1 = new File("artifact-1.zip")
        def file2 = new File("artifact-2.zip")
        def file3 = new File("artifact-3.zip")

        def conf1 = dependencyScope("conf1")

        def target = Stub(GradleProjectIdentity)
        def buildState1 = Stub(BuildState)
        def buildState2 = Stub(BuildState)
        def buildState3 = Stub(BuildState)
        def projects3 = Stub(BuildProjectRegistry)
        def projectState = Stub(ProjectState)
        def model = new Object()

        given:
        _ * workerThreadRegistry.workerThread >> true

    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)