def toolSearchPath = Stub(ToolSearchPath)
    def tool = Stub(CommandLineToolSearchResult) {
        isAvailable() >> true
        getTool() >> new File("tool")
    }
    def missing = Stub(CommandLineToolSearchResult) {
        isAvailable() >> false
    }
    def correctCompiler = new ComponentFound(Stub(GccMetadata))
    def metaDataProvider = Stub(CompilerMetaDataProvider)

        visited.toSet() == [a1, b1].toSet()
    }

    def "dependencies are union of dependencies of source trees"() {
        def task1 = Stub(Task)
        def task2 = Stub(Task)
        def task3 = Stub(Task)
        def tree1 = Stub(FileTreeInternal)
        def tree2 = Stub(FileTreeInternal)

        given:
        tree1.visitDependencies(_) >> { TaskDependencyResolveContext context ->
            context.add(task1)

import org.apache.maven.lifecycle.internal.stub.BuildPluginManagerStub;
import org.apache.maven.lifecycle.internal.stub.DefaultLifecyclesStub;
import org.apache.maven.lifecycle.internal.stub.PluginPrefixResolverStub;
import org.apache.maven.lifecycle.internal.stub.PluginVersionResolverStub;
import org.apache.maven.lifecycle.internal.stub.ProjectDependencyGraphStub;

        getConnection() >> connection
    }
    WorkerProcessBuilder workerProcessBuilder = Mock(WorkerProcessBuilder) {
        build() >> workerProcess
        getJavaCommand() >> Stub(JavaExecHandleBuilder)
    }
    WorkerProcessFactory workerProcessFactory = Stub(WorkerProcessFactory) {
        create(_) >> workerProcessBuilder
    }

    def "acquires worker lease and starts worker process on first test"() {
        given:

    }

    def 'decorates actions'() {
        given:
        def action = Mock(Action)
        def arg = new Object()
        def id
        def decoratedAction

        when:

        context.apply(Stub(UserCodeSource)) {
            id = it
            decoratedAction = decorator.decorate('foo', action)
        }

        then:
        !decoratedAction.is(action)

        when:

 */
package org.apache.maven.lifecycle.internal;

import java.util.List;

import org.apache.maven.execution.MavenSession;
import org.apache.maven.lifecycle.internal.stub.LifecycleTaskSegmentCalculatorStub;
import org.apache.maven.lifecycle.internal.stub.ProjectDependencyGraphStub;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;

class ProviderConnectionTest extends Specification {
    def payloadSerializer = Mock(PayloadSerializer)

    def "ignores unknown operation types"() {
        given:
        def parameters = Stub(ProviderOperationParameters) {
            getBuildProgressListener() >> Stub(InternalBuildProgressListener) {
                getSubscribedOperations() >> ["UNKNOWN_OPERATION"]
            }
        }

        when:

    def watcherRegistry = Mock(FileWatcherRegistry)
    def emptySnapshotHierarchy = DefaultSnapshotHierarchy.empty(CaseSensitivity.CASE_SENSITIVE)
    def nonEmptySnapshotHierarchy = Stub(SnapshotHierarchy) {
        empty() >> emptySnapshotHierarchy
    }
    def daemonDocumentationIndex = Mock(DaemonDocumentationIndex)
    def locationsUpdatedByCurrentBuild = Mock(FileWatchingFilter)

        def configurationMetadata = Stub(ConfigurationGraphResolveMetadata) {
            isCanBeConsumed() >> true
            getName() >> name
            getAttributes() >> attrs
        }
        def variant = Stub(VariantGraphResolveState) {
            getMetadata() >> configurationMetadata
        }
        Stub(TestConfigurationState) {
            getName() >> name

    }

    def "uses caller provided exception factory to calculate problem location"() {
        given:
        def exception = new Exception()
        def supplier = Stub(Supplier) {
            get() >> exception
        }
        def location = Stub(Location)
        def stream = factory.newStream()

        when:
        def diagnostics = stream.forCurrentCaller(supplier)

        then: