*
 * E.g:
 * <pre>
 *      modelReport.reportNode.'**'.primaryCredentials.username.@nodeValue[0] == 'uname'
 *      modelReport.reportNode.'**'.primaryCredentials.username.@type[0] == 'java.lang.String'
 * </pre>
 *
 */
class ReportNode extends Node {
    Integer depth

    ReportNode(name) {
        super(null, name)
    }

    ReportNode(ReportNode parent, name) {
        super(parent, name)
    }

        return new ReportNode(name)
    }

    @Override
    protected Object createNode(Object name, Map attributes) {
        def node = new ReportNode(name, attributes)
        return node
    }

    @Override
    protected Object createNode(Object name, Map attributes, Object value) {
        return null
    }

    public ReportNode get() {
        return rootNode.children()?.find()

     * Each node of the subtree is then verified against the expected structure.
     */
    void hasNodeStructure(ReportNode expectedNode) {
        def parsedNodes = parsedModelReport.reportNode
        def actualNode = parsedNodes.findFirstByName(expectedNode.name())
        assert actualNode: "Could not find the first node to begin comparison"

        setup:
        ReportNode reportNode = new ReportNode('myName')
        def child = new ReportNode('child')
        reportNode.append(child)

        expect:
        reportNode.children().size() == 1
    }

    def "should find the first matching child node"() {
        setup:
        ReportNode parent = new ReportNode('parent')
        new ReportNode(parent, 'child', [aVal: 2])

        "    | Value:  \tC++ source 'lss:lss'" | false
    }

    def "should find a node attributes"() {
        ReportNode reportNode = new ReportNode('test')
        when:
        ModelReportParser.setNodeProperties(line, reportNode)

        then:
        reportNode.attribute(expectedAttribute) == expectedValue
        where:
        line                               | expectedAttribute | expectedValue

    }

    private static ReportNode parseNodes(List<String> nodeLines) {
        ReportNode root = new ReportNode("model")
        root.depth = 0
        ReportNode prev = root
        nodeLines.each { line ->
            if (lineIsANode(line)) {
                int depth = getNodeDepth(line)
                if (depth > prev.getDepth()) {
                    ReportNode node = new ReportNode(prev, getNodeName(line))

    final List<String> nodeOnlyLines
    final ReportNode reportNode

    ParsedModelReport(String title, List<String> reportLines, List<String> nodeOnlyLines, ReportNode reportNode) {
        this.title = title
        this.reportLines = reportLines.asImmutable()
        this.nodeOnlyLines = nodeOnlyLines.asImmutable()
        this.reportNode = reportNode
    }

 */

package org.gradle.api.reporting.model

import spock.lang.Specification

class ModelReportNodeBuilderTest extends Specification {

    def "builds a report node structure from a DSL"() {
        ReportNode node = ModelReportNodeBuilder.fromDsl({
            model {
                childOne()
                childTwo(aValue: 'someThing', anotherValue: 'somethingElse')
            }
        }).get()

        expect: