class DaemonClientTest extends ConcurrentSpecification {
    final DaemonConnector connector = Mock()
    final DaemonClientConnection connection = Mock()
    final OutputEventListener outputEventListener = Mock()
    final DaemonCompatibilitySpec compatibilitySpec = Mock()
    final def idGenerator = new UUIDGenerator()
    final ProcessEnvironment processEnvironment = Mock()
    final GlobalUserInputReceiver userInput = Stub()

        expect:
        !results1.hasAnyFailure()
        results2.hasAnyFailure()
        results3.hasAnyFailure()
    }

    def "visits all resolution failures"() {
        given:
        def throwable = Mock(Throwable)
        def resolveEx = Mock(ResolveException)

        def unresolved = Mock(UnresolvedDependency) {
            getProblem() >> throwable

    }
    def moduleResolutionCache = Stub(AbstractModuleVersionsCache)
    def moduleDescriptorCache = Mock(AbstractModuleMetadataCache)
    def moduleArtifactsCache = Mock(AbstractArtifactsCache)
    def artifactAtRepositoryCache = Mock(ModuleArtifactCache)
    def cachePolicy = Stub(CachePolicy)
    def metadataProcessor = Stub(ComponentMetadataProcessor)
    def listener = Stub(ChangingValueDependencyResolutionListener)

    def "can resolve artifact"() {
        access = createAccess(maxRetries)

        given:
        def artifact = Mock(ComponentArtifactMetadata)
        def artifactId = Mock(ComponentArtifactIdentifier)
        def moduleSources = ImmutableModuleSources.of(Mock(ModuleSource))
        def result = Mock(BuildableArtifactFileResolveResult)
        artifact.getId() >> artifactId

        when: 'repo is not disabled'

class CancellableModelBuilderBackedModelProducerTest extends Specification {

    def adapter = Mock(ProtocolToModelAdapter)
    def versionDetails = Mock(VersionDetails)
    def mapping = Mock(ModelMapping)
    def transformer = CancellationExceptionTransformer.transformerFor(VersionDetails.from("4.8"))
    def builder = Mock(InternalCancellableConnection)

    def modelProducer

    def setup() {

    @Rule final TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    final GlobalScopedCacheBuilderFactory cacheBuilderFactory = Mock()
    final ModuleRegistry moduleRegistry = Mock()
    final WorkerProcessClassPathProvider provider = new WorkerProcessClassPathProvider(cacheBuilderFactory, moduleRegistry)

    def returnsNullForUnknownClasspath() {
        expect:

    public final TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    def cacheDir = tmpDir.file("dir")
    def cleanupAction = Mock(CleanupAction)
    def cacheCleanup = Mock(CacheCleanupStrategy)
    def lockManager = Mock(FileLockManager)
    def lock = Mock(FileLock)
    def buildOperationRunner = Stub(BuildOperationRunner) {
        run(_ as RunnableBuildOperation) >> { RunnableBuildOperation operation ->

    @Rule SetSystemProperties properties = new SetSystemProperties()
    def workerContext = Mock(WorkerProcessContext)
    def connection = Mock(ObjectConnection)
    def factory = Mock(WorkerTestClassProcessorFactory)
    def processor = Mock(TestClassProcessor)
    def test = Mock(TestClassRunInfo)
    def resultProcessor = Mock(TestResultProcessor)
    def worker = new TestWorker(factory)

class BuildSrcBuildListenerFactoryTest extends Specification {

    def startParameter = Mock(StartParameterInternal)
    def projectState = Mock(ProjectState) {
        fromMutableState(_) >> { Function function -> function.apply(project) }
    }
    def project = Mock(ProjectInternal) {
        getOwner() >> projectState
    }
    def gradle = Mock(GradleInternal) {
        getStartParameter() >> startParameter

    DependencyMetaDataProvider metaDataProvider = Mock() {
        getModule() >> Mock(Module)
    }
    ComponentIdentifierFactory componentIdentifierFactory = Mock()
    ImmutableModuleIdentifierFactory moduleIdentifierFactory = Mock()
    LocalConfigurationMetadataBuilder configurationMetadataBuilder = Mock(LocalConfigurationMetadataBuilder) {
        create(_, _, _, _, _, _) >> { args ->
            Mock(LocalConfigurationGraphResolveMetadata)
        }