def node = Stub(Node)
    def set = new DependencySuccessorsOnlyNodeSet()

    def "does not wait when the set is empty"() {
        expect:
        set.getState(node) == Node.DependenciesState.COMPLETE_AND_SUCCESSFUL
    }

    def "waits until all dependencies have completed successfully"() {
        def dep1 = Stub(Node)
        def dep2 = Stub(Node)

        given:

        def ti1 = TestTaskIdentities.create("t1", Task, Stub(ProjectInternal) {
            projectPath(_) >> { args -> Path.path(":" + args[0]) }
        })
        def t = Stub(LocalTaskNode) {
            getTask() >> Stub(TaskInternal) {
                getTaskIdentity() >> ti1
            }
        }
        List<Node> nodes = [t]

        def scheduledNodesStub = Stub(QueryableExecutionPlan.ScheduledNodes) {

class TwoStageArtifactIdentifierFileStoreTest extends Specification {
    def readStore = Mock(ArtifactIdentifierFileStore)
    def writeStore = Mock(ArtifactIdentifierFileStore)
    def key = Stub(ModuleComponentArtifactIdentifier)
    def file = Stub(File)
    def action = Stub(Action)

    @Subject
    def twoStageStore = new TwoStageArtifactIdentifierFileStore(readStore, writeStore)

    def "storing an artifact uses the writable store"() {

    def featureFlagListener = Mock(FeatureFlagListener)
    def listenerManager = Stub(ListenerManager) {
        getBroadcaster(FeatureFlagListener) >> featureFlagListener
    }
    def flags = new DefaultFeatureFlags(new DefaultInternalOptions(sysProperties), listenerManager)

    def "flag is disabled by default"() {
        def flag = Stub(FeatureFlag)
        flag.systemPropertyName >> null

        expect:

    def taskProperties = Stub(TaskProperties) {
        getInputFileProperties() >> ImmutableSortedSet.of()
        getOutputFileProperties() >> ImmutableSortedSet.of()
    }
    def previousState = Stub(PreviousExecutionState) {
        getInputProperties() >> ImmutableSortedMap.of()
        getInputFileProperties() >> ImmutableSortedMap.of()
        getImplementation() >> Stub(ClassImplementationSnapshot)

class PhasedActionAwareConsumerConnectionTest extends Specification {

    final target = Mock(TestConnection) {
        getMetaData() >> Stub(ConnectionMetaDataVersion1) {
            getVersion() >> "4.8"
        }
    }
    final adapter = Stub(ProtocolToModelAdapter)
    final modelMapping = Stub(ModelMapping)
    final connection = new PhasedActionAwareConsumerConnection(target, modelMapping, adapter)

        Stub(TypeElement) {
            getEnclosingElement() >> null
            getQualifiedName() >> Stub(Name) {
                toString() >> name
            }
            getSimpleName() >> Stub(Name) {
                toString() >> name
            }
            getAnnotation(Retention) >> Stub(Retention) {
                value() >> retentionPolicy
            }

    def cachePolicy = new DefaultCachePolicy()
    def ruleExecutor = new ComponentMetadataSupplierRuleExecutor(Stub(GlobalScopedCacheBuilderFactory), Stub(DefaultInMemoryCacheDecoratorFactory), Stub(ValueSnapshotter), Stub(BuildCommencedTimeProvider), Stub(Serializer))

    def setup() {
        resolveState.getCachePolicy() >> cachePolicy
        resolveState.getComponentMetadataSupplierExecutor() >> ruleExecutor

                stub.childrenStubs.forEach(::indexStub)
            }
            is KotlinTypeAliasStubImpl -> indexTypeAlias(stub.psi)
            is KotlinFunctionStubImpl -> addToFunctionMap(stub.psi)
            is KotlinPropertyStubImpl -> addToPropertyMap(stub.psi)
            is KotlinPlaceHolderStubImpl -> {
                if (stub.stubType == KtStubElementTypes.CLASS_BODY) {

    @Test
    void testADependencies() {
        final List<MavenProject> mavenProjects = stub.getUpstreamProjects(ProjectDependencyGraphStub.A, false);
        assertEquals(0, mavenProjects.size());
    }

    @Test
    void testBDependencies() {
        final List<MavenProject> bProjects = stub.getUpstreamProjects(ProjectDependencyGraphStub.B, false);
        assertEquals(1, bProjects.size());