tasks.register("bar", Delete)
        """

        when:
        succeeds "help"

        then:
        // help task is realized and configured
        outputContains("configured :help")

        // are "built-in" tasks realized and configured?
        if (realizesBuiltInTasks) {
            outputContains("configured :tasks")
            outputContains("configured :projects")
        } else {

    DynamicObject getTasksAsDynamicObject();

    /**
     * Force the task graph to come into existence.
     */
    void realize();

    /**
     * Performs work to discover more tasks.
     *
     * This method differs from {@link #realize} in that it does not realize the whole subtree.
     */
    void discoverTasks();

    /**

        project.apply plugin: 'custom-rule-source'

        then:
        project.modelRegistry.realize("foo", String) == "bar"
    }

    def "can apply a rule source by type"() {
        when:
        def project = buildProject()
        project.apply type: CustomRuleSource

        then:
        project.modelRegistry.realize("foo", String) == "bar"
    }

        then:
        !foo.promise.canBeViewedAs(ModelType.of(String))
        foo.promise.canBeViewedAs(ModelType.of(List))

        registry.realize(fooReference.path, fooReference.type).is(fooList)
        registry.realize(barReference.path, barReference.type).is(barList)
    }

        and:
        source.iterator().collect() == iterationOrder("foo", "bar", "baz", "fizz", "fuzz", "bazz")
    }

    def "once realized, provided values appear like realized values"() {
        when:
        source.addPending(provider("foo"))
        source.add("bar")
        source.add("baz")
        source.addPending(provider("fizz"))

        def process = ['ar', '-t', binaryFile.getAbsolutePath()].execute(environments, null)
        return process.inputStream.readLines().drop(1)
    }

    List<String> listLinkedLibraries() {
        def process = ['otool', '-L', binaryFile.absolutePath].execute(environments, null)
        def lines = process.inputStream.readLines()
        return lines
    }

    List<Symbol> listSymbols() {

        source.contains("foo")
    }

    def "an element added as both a provider and a realized value is not duplicated"() {
        when:
        source.add("foo")
        source.addPending(provider("foo"))

        then:
        source.iterator().collect() == ["foo"]
    }

    def "an element added as both a provider and a realized value has the correct order"() {
        when:
        source.addPending(provider("foo"))

    id 'java'
}

def version = objects.property(String)

configurations.testImplementation.dependencies.addLater(version.map { project.dependencies.create("com.example:artifact:\${it}") })

tasks.all {} // force realize all tasks

version.set('5.6')

assert configurations.testRuntimeClasspath.allDependencies.size() == 1 
        """
        expect:
        succeeds("help")
    }

        then:
        outputs.stdOut.readLines() == ['message']
        outputs.stdErr == ''
    }

    def rendersErrorLogEventsToStdErr() {
        when:
        renderer.attachSystemOutAndErr()
        renderer.onOutput(event('message', LogLevel.ERROR))

        then:
        outputs.stdOut == ''
        outputs.stdErr.readLines() == ['message']
    }

                return Collections.emptyMap();
            }
            List<String> lines = readLines(incrementalProcessorDeclaration);
            return parseIncrementalProcessors(lines);
        }

        private List<String> readLines(File file) throws IOException {
            return Files.asCharSource(file, Charsets.UTF_8).readLines(new MetadataLineProcessor());
        }