}

    def "allows provider convertible of type MinimalExternalModuleDependency as an input"() {
        given:
        def providerConvertible = Stub(ProviderConvertible.class)
        def provider = Stub(Provider.class)
        def dependency = Stub(MinimalExternalModuleDependency.class)
        dependency.module >> DefaultModuleIdentifier.newId("org.foo", "bar")

    def jApiClassifier = Stub(JApiClass) // represents interfaces, enums and annotations
    def jApiMethod = Stub(JApiMethod)
    def jApiField = Stub(JApiField) // represents fields and enum literals
    def jApiConstructor = Stub(JApiConstructor)
    def incubatingAnnotation = Stub(JApiAnnotation)
    def deprecatedAnnotation = Stub(JApiAnnotation)
    def overrideAnnotation = Stub(JApiAnnotation)

abstract class AbstractQueueTest extends Specification {
    final Condition broken = Stub() {
        await() >> { throw new UnsupportedOperationException("should not be waiting") }
    }
    final Lock lock = Stub() {
        newCondition() >> broken
    }

    def unicast() {
        InterHubMessage message = Stub() {
            getDelivery() >> InterHubMessage.Delivery.SingleHandler
        }
        return message

        def buildAction = Stub(SubscribableBuildAction) {
            getClientSubscriptions() >> new BuildEventSubscriptions(EnumSet.allOf(OperationType))
        }
        def consumer = Stub(BuildEventConsumer)
        def buildSessionContext = Stub(BuildSessionContext)

        def listener1 = Stub(BuildOperationListener)
        def listener2 = Stub(BuildOperationListener)

    def work = Stub(ImmutableUnitOfWork) {
        getWorkspaceProvider() >> immutableWorkspaceProvider
    }
    def originMetadata = Stub(OriginMetadata)
    def delegateResult = Stub(CachingResult) {
        getDuration() >> Duration.ofSeconds(1)
        getExecution() >> Try.successful(Stub(ExecutionEngine.Execution))

    def "can query id and metadata when resolved"() {
        ModuleVersionIdentifier id = Stub()
        def metadata = Stub(ModuleComponentResolveMetadata) {
            getModuleVersionId() >> id
        }
        def state = Stub(ComponentGraphResolveState) {
            getMetadata() >> metadata
        }
        def graphState = Stub(ComponentGraphSpecificResolveState)

        when:
        result.resolved(state, graphState)

        1 * readCache.get(key) >> Stub(AbstractArtifactsCache.ModuleArtifactsCacheEntry)

        when:
        twoStageArtifactsCache.get(key)

        then:
        1 * writeCache.get(key) >> Stub(AbstractArtifactsCache.ModuleArtifactsCacheEntry)
        0 * readCache.get(key)
    }

    def "writes are delegated to the writable cache"() {
        def entry = Stub(AbstractArtifactsCache.ModuleArtifactsCacheEntry)

    }

    def "creates wrapper for non-empty set of selected artifacts"() {
        def target = Stub(ArtifactSet)
        def selector = Stub(ArtifactVariantSelector)
        def selected = Stub(ResolvedArtifactSet)
        def visitor = Mock(TaskDependencyResolveContext)

        given:
        target.select(_, _) >> selected

        when:

    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    def element = new TestBuildableComponentSpec(Stub(ComponentSpecIdentifier))
    def dependedOn1 = Stub(Task)
    def dependedOn2 = Stub(Task)
    def lifecycleTask = TestUtil.create(tmpDir).task(DefaultTask)

    def "has direct dependencies with no lifecycle task set"() {
        when:

        services.add(Stub(BuildOperationProgressEventEmitter))
        services.add(Mock(BuildModelParameters))
        services.add(Mock(ProjectParallelExecutionController))
        services.add(BuildTreeActionExecutor, actionExecutor)
        services.add(listenerManager)
        state = new BuildTreeState(buildInvocationScopeId, services, Stub(BuildTreeModelControllerServices.Supplier))
    }