def m = method.overriddenMethod

        then:
        m == null
        _ * owner.superClass >> null
        _ * owner.interfaces >> []
    }

    def hasNoOverriddenMethodWhenMethodDoesNotOverrideMethodInSuperClass() {
        ClassMetaData superClassMetaData = Mock()

        when:
        def m = method.overriddenMethod

        then:
        m == null

        jsonFileManager.emptyAcceptedApiChanges(jsonFile)

        then:
        jsonFile.text == nonExistentAcceptedApiChanges()
    }

    def "can clean non-existing API changes"() {
        given:
        jsonFile << nonExistentAcceptedApiChanges()

        when:
        jsonFileManager.emptyAcceptedApiChanges(jsonFile)

        then:
        jsonFile.text == nonExistentAcceptedApiChanges()
    }

        def result = parser.parse(classMetaData, listener)

        then:
        format(result.docbook).contains('x\n  indented')
    }

    def removesLeadingAsterixFromEachLine() {
        _ * classMetaData.rawCommentText >> ''' * line 1
 * line 2
'''
        when:
        def result = parser.parse(classMetaData, listener)

        then:
        format(result.docbook) == '''<para>line 1
line 2</para>'''
    }

    def canAddMetaData() {
        TestDomainObject value = new TestDomainObject('a')

        when:
        repository.put('class', value)

        then:
        repository.find('class') == value
        repository.get('class') == value
    }

    def findReturnsNullForUnknownClass() {
        expect:
        repository.find('unknown') == null
    }

     * useful regardless of this renderer's needs, since now there will be a link embedded in the report
     * to quickly open the changes file.  By then we can also regex that path out of the description
     * in order to create a changes {@link File} for further use in this class.
     *
     * @param data the report data containing a description to parse

            doc.superClass = superDoc
            doc.interfaces << superType1
            doc.interfaces << superType2
            builder.build(doc)
            return doc
        }

        then:
        doc.classProperties.size() == 5
        doc.classProperties[0].name == 'a'
        doc.classProperties[1].name == 'b'
        doc.classProperties[2].name == 'c'
        doc.classProperties[3].name == 'd'

    }

    def rawTypeForVarargsType() {
        when:
        type.setVarargs()

        then:
        type.rawType.signature == 'org.gradle.SomeType[]'

        when:
        type.arrayDimensions = 1

        then:
        type.rawType.signature == 'org.gradle.SomeType[][]'
    }

    def rawTypeForParameterizedArrayType() {
        type.arrayDimensions = 2

        when:
        def actual = UserGuideTransformTask.normalise(content)

        then:
        actual == "test    test    test"
    }

    def usesUnixLineEndings() {
        given:
        String content = "test\r\ntest\r\ntest"
        when:
        def actual = UserGuideTransformTask.normalise(content)

        then:
        actual == "test\ntest\ntest"
    }

    def stripsLeadingWhitespaceOnSingleLine() {

        _ * classDoc.subClasses >> []

        when:
        def result = parse('<root/>')
        withCategories {
            renderer.mergeContent(classDoc, result)
        }

        then:
        formatTree(result) == '''<root>
    <chapter id="classId">
        <title>Class</title>
        <segmentedlist>
            <segtitle>API Documentation</segtitle>
            <seglistitem>

        lexer.visit(visitor)

        then:
        1 * visitor.onStartHtmlElement('p')
        1 * visitor.onStartHtmlElementComplete('p')
        1 * visitor.onEndHtmlElement('end')
        1 * visitor.onEnd()
        0 * visitor._
    }

    def parsesHtmlEntities() {
        when:
        lexer.pushText("before & after")
        lexer.visit(visitor)

        then:
        1 * visitor.onText('before & after')