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)

    }

    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:

        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)

    @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))
    }

    def source = Mock(FilteredMinimalFileTree)
    def patterns = Stub(PatternSet)
    def tree = new FilteredMinimalFileTree(patterns, source)

    def "ignores directory that is not included"() {
        def spec = Mock(Spec)
        def included = Stub(FileVisitDetails)
        def excluded = Stub(FileVisitDetails)
        def visitor = Mock(FileVisitor)

        when:
        tree.visit(visitor)

        def lister = new InstantiatingAction<ComponentMetadataListerDetails>(DefaultConfigurableRules.of(Stub(ConfigurableRule)), TestUtil.instantiatorFactory().inject(), Stub(InstantiatingAction.ExceptionHandler))