+ "stub-plugin-initialize, "
                        + "stub-plugin-process-resources, "
                        + "stub-plugin-compile, "
                        + "stub-plugin-process-test-resources, "
                        + "stub-plugin-test-compile, "
                        + "stub-plugin-test, "
                        + "stub-plugin-package, "

        library.publicHeaders.from(d)
        library.publicHeaderDirs.files == [d] as Set
    }

    def "can add shared library"() {
        def targetPlatform = Stub(CppPlatform)
        def toolChain = Stub(NativeToolChainInternal)
        def platformToolProvider = Stub(PlatformToolProvider)

        expect:
        def binary = library.addSharedLibrary(identity, targetPlatform, toolChain, platformToolProvider)

    def "adds compile task for binary"() {
        def binary = Stub(DefaultSwiftBinary)
        binary.name >> name
        binary.names >> Names.of(name)
        binary.module >> project.objects.property(String)
        binary.targetMachine >> Stub(TargetMachine)
        binary.targetPlatform >> Stub(SwiftPlatform)
        binary.sourceCompatibility >> project.objects.property(SwiftVersion)

        when:

    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:

  <!-- NOTE: Use stub versions of the core plugins referenced by the build -->
  <build>
    <pluginManagement>
      <plugins>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>0.1-stub-SNAPSHOT</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>0.1-stub-SNAPSHOT</version>
        </plugin>

    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)