def "can set untyped using provider"() {
        def provider = supplierWithValues(someValue(), someValue())

        given:
        def property = propertyWithNoValue()
        property.setFromAnyValue(provider)

        expect:
        property.present
        property.get() == someValue()
    }

    def "convention value is used before value has been set"() {
        def property = propertyWithNoValue()

        buildIdentified()

        def loadBuildOp = operations.only(LoadBuildBuildOperationType)

        def evaluateSettingsOp = operations.only(EvaluateSettingsBuildOperationType)
        assert evaluateSettingsOp.parentId == loadBuildOp.id

        def configureBuildOp = operations.only(ConfigureBuildBuildOperationType)

        def loadProjectsOp = operations.only(LoadProjectsBuildOperationType)

    def rendersLinkToApiClass() {
        when:
        def link = renderer.link(type('org.gradle.SomeClass'), listener)

        then:
        format(link) == '<apilink class="org.gradle.SomeClass"/>'
        _ * model.isKnownType('org.gradle.SomeClass') >> true
    }

    def rendersLinkToApiClassArray() {
        when:

        given:
        def action = Mock(Action)
        def componentSelectorConverter = Mock(ComponentSelectorConverter)
        substitutions.allWithDependencyResolveDetails(action, componentSelectorConverter)

        def mid = DefaultModuleIdentifier.newId("org.utils", "api")
        def moduleOldRequested = DefaultModuleVersionSelector.newSelector(mid, "1.5")
        def moduleTarget = DefaultModuleComponentSelector.newSelector(moduleOldRequested)

    def "selects candidate with subset of attributes and whose values match"() {
        given:
        def matcher = new DefaultAttributeMatcher(schema)

        def usage = Attribute.of('usage', String)
        schema.attribute(usage)
        def other = Attribute.of('other', String)
        schema.attribute(other)

        def candidate1 = attributes(usage: "match")
        def candidate2 = attributes(usage: "no match")

    def determinesTaskDependenciesByResolvingDependencyObjectForTask() {
        when:
        def tasks = context.getDependencies(task, dependency)

        then:
        1 * dependency.visitDependencies(_)
        tasks.isEmpty()
    }

    def resolvesTaskObject() {
        when:
        def tasks = context.getDependencies(task, dependency)

        then:

        def artifactOps2 = buildOperations.all(DownloadArtifactBuildOperationType)
        artifactOps2.size() == 1
        artifactOps2[0].details.artifactIdentifier == 'impl-1.3.jar (org.utils:impl:1.3)'

        where:
        chunked << [true, false]
    }

    def "emits events for missing resources"() {
        given:
        def emptyRepo = mavenHttpRepo("empty")

    def classpathWalker = new ClasspathWalker(TestFiles.fileSystem())
    def classpathBuilder = new DefaultClasspathBuilder(TestFiles.tmpDirTemporaryFileProvider(testDirectoryProvider.createDir("tmp")))
    def fileSystemAccess = TestFiles.fileSystemAccess()
    def globalCacheLocations = Stub(GlobalCacheLocations)
    def fileLockManager = Stub(FileLockManager)
    def agentStatus = Stub(AgentStatus) {

        0 * _
    }

    def "file tree is live"() {
        def source1 = Mock(FileCollectionInternal)
        def source2 = Mock(FileCollectionInternal)
        def dir1 = new File("dir1")
        def dir2 = new File("dir1")
        def dir3 = new File("dir1")
        def source3 = Mock(FileCollectionInternal)
        def collection = new TestCompositeFileCollection(source1, source2)

    }

    def "can use test threads to define instants"() {
        def worker = new Worker(executor)

        given:
        def action = {
            instant.actionExecuted
        }

        when:
        worker.runLater(action)
        worker.stop()

        then:
        instant.actionExecuted
    }

    def "can use arbitrary thread to define an instant"() {