import spock.lang.Specification
import spock.lang.Subject

import java.nio.file.Path

class TwoStageByUrlCachedExternalResourceIndexTest extends Specification {
    Path readOnlyPath = Stub(Path)
    File artifact = Stub(File)
    ExternalResourceMetaData metadata = Stub(ExternalResourceMetaData)

    CachedExternalResourceIndex<String> readIndex = Mock(CachedExternalResourceIndex)

        _ * project.gradle >> services.gradle
        _ * project.owner >> projectState
        def projectServices = new DefaultServiceRegistry(TestUtil.services())
        projectServices.add(Stub(PropertyWalker))
        projectServices.add(Stub(FileCollectionFactory))
        _ * project.services >> projectServices
        _ * project.pluginManager >> Stub(PluginManagerInternal)
        def lock = Stub(ResourceLock)

        0 * _
    }

    def dependsOnUnionOfDependenciesOfSourceCollections() {
        def task1 = Stub(Task)
        def task2 = Stub(Task)
        def task3 = Stub(Task)
        def source1 = Stub(FileCollectionInternal)
        def source2 = Stub(FileCollectionInternal)

        given:
        source1.visitDependencies(_) >> { TaskDependencyResolveContext context ->

        given:
        def listenerManager = Mock(ListenerManager)
        def notifyAction = Mock(Action)
        def daemonScanInfo = new DefaultDaemonScanInfo(Stub(DaemonRunningStats), 0, false, Stub(DaemonRegistry), listenerManager)
        DaemonExpirationListener daemonExpirationListener
        BuildListener buildListener

        when:
        daemonScanInfo.notifyOnUnhealthy(notifyAction)

    List<Deployment> deployments = []
    def deploymentRegistry = Stub(DeploymentRegistryInternal) {
        getRunningDeployments() >> deployments
    }
    def startParameter = Stub(StartParameterInternal)
    def buildOperationRunner = Mock(BuildOperationRunner)
    def buildController = Stub(BuildTreeLifecycleController)
    def delegate = Mock(BuildActionRunner)
    def buildAction = Stub(BuildAction)

import spock.lang.Subject

class WorkerDaemonClientsManagerTest extends ConcurrentSpecification {
    def options = Stub(DaemonForkOptions)
    def starter = Stub(WorkerDaemonStarter)
    def listenerManager = Stub(ListenerManager)
    def loggingManager = Stub(LoggingManagerInternal)
    def memoryManager = Mock(MemoryManager)

    @Subject

class TwoStageModuleMetadataCacheTest extends Specification {
    def timeProvider = Stub(BuildCommencedTimeProvider)
    def readCache = Mock(AbstractModuleMetadataCache)
    def writeCache = Mock(AbstractModuleMetadataCache)
    def key = Stub(ModuleComponentAtRepositoryKey)
    def entry = Stub(ModuleMetadataCacheEntry)
    def metadata = Stub(ModuleMetadataCache.CachedMetadata)

    @Subject

        given:
        def fileAttributeView = Stub(BasicFileAttributeView) {
            setTimes(_, _, _) >> { throw new FileSystemException("file: Operation not permitted") }
        }
        def path = Stub(java.nio.file.Path) {
            getFileSystem() >> Stub(FileSystem) {
                provider() >> Stub(FileSystemProvider) {
                    getFileAttributeView(_, _, _) >> fileAttributeView

    def "wraps builder for requested model"() {
        def builder1 = Mock(ToolingModelBuilder)
        def builder2 = Mock(ToolingModelBuilder)
        def project = Stub(ProjectInternal)

        given:
        registry.register(builder1)
        registry.register(builder2)

        and:
        builder1.canBuild("model") >> false
        builder2.canBuild("model") >> true

class FixedStepPathMatcherTest extends Specification {
    def "calculates min and max number of segments"() {
        def next = Stub(PathMatcher) {
            getMinSegments() >> 2
            getMaxSegments() >> 3
        }
        def matcher = new FixedStepPathMatcher(Stub(PatternStep), next)

        expect:
        matcher.minSegments == 3
        matcher.maxSegments == 4
    }