true
        }
        result.executionTimeInMillis == 42 + 23
    }

    def "tracks time for getCompletions()"() {
        def element = Stub(Element)
        def annotation = Stub(AnnotationMirror)
        def member = Stub(ExecutableElement)
        def userText = "foo"
        def completion = Completions.of("bar")

        when:

    final LocalComponentRegistry registry = Mock()
    final ProjectStateRegistry projectRegistry = Stub()
    final ProjectArtifactResolver projectArtifactResolver = Stub()
    final ProjectDependencyResolver resolver = new ProjectDependencyResolver(registry, projectArtifactResolver)

    def setup() {
        def projectState = Stub(ProjectState)
        _ * projectRegistry.stateFor(_) >> projectState

        def a = profile.getTaskProfile("foo:a").completed(Stub(TaskState)).setStart(100).setFinish(300)
        def b = profile.getTaskProfile("foo:b").completed(Stub(TaskState)).setStart(300).setFinish(300)
        def c = profile.getTaskProfile("foo:c").completed(Stub(TaskState)).setStart(300).setFinish(300)
        def d = profile.getTaskProfile("foo:d").completed(Stub(TaskState)).setStart(301).setFinish(302)

        expect:

    def "wraps resolveArtifact exception as failure"() {
        def componentArtifactId = Stub(ComponentArtifactIdentifier) {
            getDisplayName() >> "<component-artifact>"
        }
        def componentArtifact = Stub(ComponentArtifactMetadata) {
            getId() >> componentArtifactId
        }
        def component = Stub(ComponentArtifactResolveMetadata)
        def artifactResolveResult = Mock(BuildableArtifactResolveResult)

        and:
        !var.present
    }

    def "can specify the producer task for a directory"() {
        def var = factory.newDirectoryProperty()
        def task = Stub(Task)
        def owner = Stub(ModelObject)
        owner.taskThatOwnsThisObject >> task
        def action = Mock(Action)

        when:
        var.attachProducer(owner)
        def producer = var.producer

    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)

        def calculator = Mock(ValueCalculator)

        when:
        def container = new CalculatedValueContainer(Describables.of("<thing>"), calculator, projectLeaseService, Stub(NodeExecutionContext))

        then:
        0 * _

        when:
        container.run(Stub(NodeExecutionContext))

        then:
        1 * calculator.calculateValue(_) >> "result"
        0 * _

        when:
        def result = container.get()

    BuildCommencedTimeProvider timeProvider = Mock(BuildCommencedTimeProvider)
    IndexedCache persistentIndexedCache = Mock(IndexedCache)
    CachedArtifact cachedArtifact = Stub(CachedArtifact)
    FileAccessTracker fileAccessTracker = Stub(FileAccessTracker)
    String persistentCacheFile = "cacheFile"
    Path commonRootPath = folder.createDir("common").toPath()

        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)

        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: