<component>
------------------------------------------------------------{normal}
""")
    }

    def "renders component with no source sets"() {
        def component = Stub(SourceComponentSpec)

        when:
        renderer.render(component, builder)

        then:
        output.value.contains("No source sets")
    }

    def "renders component with no binaries"() {
        def component = Stub(VariantComponentSpec)

    /**
     * Renders the abbreviated type as-is and its expansion in a comment, e.g. `foo.bar.StringAlias /* = kotlin.String */`.
     */
    RENDER_ABBREVIATED_TYPE_WITH_EXPANDED_TYPE_COMMENT,

    /**
     * Renders the expanded type as-is, e.g. `kotlin.String`.
     */
    RENDER_EXPANDED_TYPE,

    /**
     * Renders the expanded type as-is and its abbreviated type in a comment, e.g. `kotlin.String /* from: foo.bar.StringAlias */`.

    def output = new TestStyledTextOutput()
    def renderer = new ComponentReportRenderer(resolver, binaryRenderer)

    def setup() {
        renderer.output = output
    }

    def "renders project with no components"() {
        when:
        renderer.startProject(project)
        renderer.renderComponents([])
        renderer.completeProject(project)
        renderer.complete()

        then:

    final GraphNodeRenderer<String> nodeRenderer = Stub(GraphNodeRenderer) {
        renderTo(_, _) >> { String node, StyledTextOutput output -> output.text("[$node]")}
    }
    final DirectedGraphRenderer<String> renderer = new DirectedGraphRenderer<String>(nodeRenderer, graph)
    final TestStyledTextOutput output = new TestStyledTextOutput()

    def "renders a graph with a single root node"() {
        given:

        fixture.publishDummyPlugin(executer)
    }

    def "does not render hint for successful build without applied plugin"() {
        given:
        buildFile << """
            task $DUMMY_TASK_NAME
        """

        when:
        succeeds(DUMMY_TASK_NAME)

        then:
        result.assertNotOutput(SCAN)
    }

    def "renders hint for failing build without applied plugin and #description"() {
        given:

    private final static String GROUP_1 = 'Group 1'
    private final static String GROUP_2 = 'Group 2'
    private final static String TASKS_GROUPS_REPORT_TASK = TASKS_REPORT_TASK + ['--groups', GROUP_1]

    def "always renders default tasks running #tasks"() {
        given:
        String projectName = 'test'
        settingsFile << "rootProject.name = '$projectName'"

        when:
        succeeds tasks

        then:

public class HtmlReportRenderer {
    /**
     * Renders a multi-page HTML report from the given model, into the given directory.
     */
    public <T> void render(T model, ReportRenderer<T, HtmlReportBuilder> renderer, File outputDirectory) {
        try {
            outputDirectory.mkdirs();
            DefaultHtmlReportContext context = new DefaultHtmlReportContext(outputDirectory);
            renderer.render(model, context);

        when:
        renderer.render([root])
        renderer.complete()

        then:
        textOutput.value.readLines() == [
                '+--- dep1',
                '|    \\--- dep1.1',
                '\\--- dep2',
                '     +--- dep2.1',
                '     \\--- dep2.2'
        ]
    }

    def "renders graph with repeated nodes"() {

import org.gradle.internal.UncheckedException;

import java.io.File;
import java.net.URI;
import java.net.URISyntaxException;

/**
 * Renders information in a format suitable for logging to the console.
 */
public class ConsoleRenderer {
    /**
     * Renders a path name as a file URL that is likely recognized by consoles.
     */
    public String asClickableFileUrl(File path) {

    TemporaryFolder tmpDir = new TemporaryFolder()

    Asciidoctor asciidoctor

    def setup() {
        tmpDir.newFolder("src", "samples")
        asciidoctor = Asciidoctor.Factory.create()
    }

    def "renders example with title adding link to self"() {
        given:
        String asciidocContent = """
.Example Title `with code`
====
some text
====
"""

        when: