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;

class DefaultBuildCacheConfigurationTest extends Specification {
    def instantiator = Mock(Instantiator) {
        newInstance(DirectoryBuildCache) >> { Stub(DirectoryBuildCache) }
    }

    def 'can reconfigure remote'() {
        def buildCacheConfiguration = createConfig()
        def original = Stub(CustomBuildCache)
        when:
        buildCacheConfiguration.remote(CustomBuildCache) { config ->
            original = config
        }

    def propertyFactory = new DefaultPropertyFactory(Stub(PropertyHost))
    def patternSetFactory = TestFiles.patternSetFactory
    def factory = new DefaultObjectFactory(TestUtil.instantiatorFactory().decorateLenient(), TestUtil.objectInstantiator(), Stub(DirectoryFileTreeFactory), patternSetFactory, propertyFactory, Stub(FilePropertyFactory), Stub(TaskDependencyFactory), Stub(FileCollectionFactory), Stub(DomainObjectCollectionFactory))

    }

    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:

import org.gradle.platform.base.BinarySpec
import spock.lang.Specification

class TypeAwareBinaryRendererTest extends Specification {
    def "delegates to renderer for type"() {
        def binary = Stub(SomeBinary)
        def output = Stub(TextReportBuilder)
        def renderer = new TypeAwareBinaryRenderer()
        def binRenderer = Mock(AbstractBinaryRenderer)

        given:
        binRenderer.targetType >> binary.getClass()

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

    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 "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:

 */
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: