Merge branch 'dev-0.11.0'

7 files changed, 2101 insertions, 0 deletions

diff --git a/plugins/base/src/test/kotlin/model/ClassesTest.kt b/plugins/base/src/test/kotlin/model/ClassesTest.kt
new file mode 100644
index 00000000..5dc8812e
--- /dev/null
+++ b/plugins/base/src/test/kotlin/model/ClassesTest.kt
@@ -0,0 +1,533 @@
+package model
+
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.links.sureClassNames
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.KotlinModifier.*
+import org.junit.jupiter.api.Assertions.assertNull
+import org.junit.jupiter.api.Test
+import utils.AbstractModelTest
+import utils.assertNotNull
+import utils.name
+import utils.supers
+
+
+class ClassesTest : AbstractModelTest("/src/main/kotlin/classes/Test.kt", "classes") {
+
+    @Test
+    fun emptyClass() {
+        inlineModelTest(
+            """
+            |class Klass {}"""
+        ) {
+            with((this / "classes" / "Klass").cast<DClass>()) {
+                name equals "Klass"
+                children counts 4
+            }
+        }
+    }
+
+    @Test
+    fun emptyObject() {
+        inlineModelTest(
+            """
+            |object Obj {}
+            """
+        ) {
+            with((this / "classes" / "Obj").cast<DObject>()) {
+                name equals "Obj"
+                children counts 3
+            }
+        }
+    }
+
+    @Test
+    fun classWithConstructor() {
+        inlineModelTest(
+            """
+            |class Klass(name: String)
+        """
+        ) {
+            with((this / "classes" / "Klass").cast<DClass>()) {
+                name equals "Klass"
+                children counts 4
+
+                with(constructors.firstOrNull().assertNotNull("Constructor")) {
+                    visibility.values allEquals KotlinVisibility.Public
+                    parameters counts 1
+                    with(parameters.firstOrNull().assertNotNull("Constructor parameter")) {
+                        name equals "name"
+                        type.name equals "String"
+                    }
+                }
+
+            }
+        }
+    }
+
+    @Test
+    fun classWithFunction() {
+        inlineModelTest(
+            """
+            |class Klass {
+            |   fun fn() {}
+            |}
+            """
+        ) {
+            with((this / "classes" / "Klass").cast<DClass>()) {
+                name equals "Klass"
+                children counts 5
+
+                with((this / "fn").cast<DFunction>()) {
+                    type.name equals "Unit"
+                    parameters counts 0
+                    visibility.values allEquals KotlinVisibility.Public
+                }
+            }
+        }
+    }
+
+    @Test
+    fun classWithProperty() {
+        inlineModelTest(
+            """
+            |class Klass {
+            |   val name: String = ""
+            |}
+            """
+        ) {
+            with((this / "classes" / "Klass").cast<DClass>()) {
+                name equals "Klass"
+                children counts 5
+
+                with((this / "name").cast<DProperty>()) {
+                    name equals "name"
+                    // TODO property name
+                }
+            }
+        }
+    }
+
+    @Test
+    fun classWithCompanionObject() {
+        inlineModelTest(
+            """
+            |class Klass() {
+            |   companion object {
+            |        val x = 1
+            |        fun foo() {}
+            |    }
+            |}
+            """
+        ) {
+            with((this / "classes" / "Klass").cast<DClass>()) {
+                name equals "Klass"
+                children counts 5
+
+                with((this / "Companion").cast<DObject>()) {
+                    name equals "Companion"
+                    children counts 5
+
+                    with((this / "x").cast<DProperty>()) {
+                        name equals "x"
+                    }
+
+                    with((this / "foo").cast<DFunction>()) {
+                        name equals "foo"
+                        parameters counts 0
+                        type.name equals "Unit"
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun dataClass() {
+        inlineModelTest(
+            """
+                |data class Klass() {}
+                """
+        ) {
+            with((this / "classes" / "Klass").cast<DClass>()) {
+                name equals "Klass"
+                visibility.values allEquals KotlinVisibility.Public
+                with(extra[AdditionalModifiers]!!.content.entries.single().value.assertNotNull("Extras")) {
+                    this counts 1
+                    first() equals ExtraModifiers.KotlinOnlyModifiers.Data
+                }
+            }
+        }
+    }
+
+    @Test
+    fun sealedClass() {
+        inlineModelTest(
+            """
+                |sealed class Klass() {}
+                """
+        ) {
+            with((this / "classes" / "Klass").cast<DClass>()) {
+                name equals "Klass"
+                modifier.values.forEach { it equals Sealed }
+            }
+        }
+    }
+
+    @Test
+    fun annotatedClassWithAnnotationParameters() {
+        inlineModelTest(
+            """
+                |@Deprecated("should no longer be used") class Foo() {}
+                """
+        ) {
+            with((this / "classes" / "Foo").cast<DClass>()) {
+                with(extra[Annotations]!!.content.entries.single().value.assertNotNull("Annotations")) {
+                    this counts 1
+                    with(first()) {
+                        dri.classNames equals "Deprecated"
+                        params.entries counts 1
+                        (params["message"].assertNotNull("message") as StringValue).value equals "\"should no longer be used\""
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun notOpenClass() {
+        inlineModelTest(
+            """
+                |open class C() {
+                |    open fun f() {}
+                |}
+                |
+                |class D() : C() {
+                |    override fun f() {}
+                |}
+                """
+        ) {
+            val C = (this / "classes" / "C").cast<DClass>()
+            val D = (this / "classes" / "D").cast<DClass>()
+
+            with(C) {
+                modifier.values.forEach { it equals Open }
+                with((this / "f").cast<DFunction>()) {
+                    modifier.values.forEach { it equals Open }
+                }
+            }
+            with(D) {
+                modifier.values.forEach { it equals Final }
+                with((this / "f").cast<DFunction>()) {
+                    modifier.values.forEach { it equals Open }
+                }
+                D.supertypes.flatMap { it.component2() }.firstOrNull()?.dri equals C.dri
+            }
+        }
+    }
+
+    @Test
+    fun indirectOverride() {
+        inlineModelTest(
+            """
+                |abstract class C() {
+                |    abstract fun foo()
+                |}
+                |
+                |abstract class D(): C()
+                |
+                |class E(): D() {
+                |    override fun foo() {}
+                |}
+                """
+        ) {
+            val C = (this / "classes" / "C").cast<DClass>()
+            val D = (this / "classes" / "D").cast<DClass>()
+            val E = (this / "classes" / "E").cast<DClass>()
+
+            with(C) {
+                modifier.values.forEach { it equals Abstract }
+                ((this / "foo").cast<DFunction>()).modifier.values.forEach { it equals Abstract }
+            }
+
+            with(D) {
+                modifier.values.forEach { it equals Abstract }
+            }
+
+            with(E) {
+                modifier.values.forEach { it equals Final }
+
+            }
+            D.supers.single().dri equals C.dri
+            E.supers.single().dri equals D.dri
+        }
+    }
+
+    @Test
+    fun innerClass() {
+        inlineModelTest(
+            """
+                |class C {
+                |    inner class D {}
+                |}
+                """
+        ) {
+            with((this / "classes" / "C").cast<DClass>()) {
+
+                with((this / "D").cast<DClass>()) {
+                    with(extra[AdditionalModifiers]!!.content.entries.single().value.assertNotNull("AdditionalModifiers")) {
+                        this counts 1
+                        first() equals ExtraModifiers.KotlinOnlyModifiers.Inner
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun companionObjectExtension() {
+        inlineModelTest(
+            """
+                |class Klass {
+                |    companion object Default {}
+                |}
+                |
+                |/**
+                | * The def
+                | */
+                |val Klass.Default.x: Int get() = 1
+                """
+        ) {
+            with((this / "classes" / "Klass").cast<DClass>()) {
+                name equals "Klass"
+
+                with((this / "Default").cast<DObject>()) {
+                    name equals "Default"
+                    // TODO extensions
+                }
+            }
+        }
+    }
+
+//    @Test fun companionObjectExtension() {
+//        checkSourceExistsAndVerifyModel("testdata/classes/companionObjectExtension.kt", defaultModelConfig) { model ->
+//            val pkg = model.members.single()
+//            val cls = pkg.members.single { it.name == "Foo" }
+//            val extensions = cls.extensions.filter { it.kind == NodeKind.CompanionObjectProperty }
+//            assertEquals(1, extensions.size)
+//        }
+//    }
+
+    @Test
+    fun secondaryConstructor() {
+        inlineModelTest(
+            """
+                |class C() {
+                |    /** This is a secondary constructor. */
+                |    constructor(s: String): this() {}
+                |}
+                """
+        ) {
+            with((this / "classes" / "C").cast<DClass>()) {
+                name equals "C"
+                constructors counts 2
+
+                constructors.map { it.name } allEquals "<init>"
+
+                with(constructors.find { it.parameters.isNullOrEmpty() } notNull "C()") {
+                    parameters counts 0
+                }
+
+                with(constructors.find { it.parameters.isNotEmpty() } notNull "C(String)") {
+                    parameters counts 1
+                    with(parameters.firstOrNull() notNull "Constructor parameter") {
+                        name equals "s"
+                        type.name equals "String"
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun sinceKotlin() {
+        inlineModelTest(
+            """
+                |/**
+                | * Useful
+                | */
+                |@SinceKotlin("1.1")
+                |class C
+                """
+        ) {
+            with((this / "classes" / "C").cast<DClass>()) {
+                with(extra[Annotations]!!.content.entries.single().value.assertNotNull("Annotations")) {
+                    this counts 1
+                    with(first()) {
+                        dri.classNames equals "SinceKotlin"
+                        params.entries counts 1
+                        (params["version"].assertNotNull("version") as StringValue).value equals "\"1.1\""
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun privateCompanionObject() {
+        inlineModelTest(
+            """
+                |class Klass {
+                |    private companion object {
+                |        fun fn() {}
+                |        val a = 0
+                |    }
+                |}
+                """
+        ) {
+            with((this / "classes" / "Klass").cast<DClass>()) {
+                name equals "Klass"
+                assertNull(companion, "Companion should not be visible by default")
+            }
+        }
+    }
+
+    @Test
+    fun companionObject() {
+        inlineModelTest(
+            """
+                |class Klass {
+                |    companion object {
+                |        fun fn() {}
+                |        val a = 0
+                |    }
+                |}
+                """
+        ) {
+            with((this / "classes" / "Klass").cast<DClass>()) {
+                name equals "Klass"
+                with((this / "Companion").cast<DObject>()) {
+                    name equals "Companion"
+                    visibility.values allEquals KotlinVisibility.Public
+
+                    with((this / "fn").cast<DFunction>()) {
+                        name equals "fn"
+                        parameters counts 0
+                        receiver equals null
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun annotatedClass() {
+        inlineModelTest(
+            """@Suppress("abc") class Foo() {}"""
+        ) {
+            with((this / "classes" / "Foo").cast<DClass>()) {
+                with(extra[Annotations]?.content?.values?.firstOrNull()?.firstOrNull().assertNotNull("annotations")) {
+                    dri.toString() equals "kotlin/Suppress///PointingToDeclaration/"
+                    (params["names"].assertNotNull("param") as ArrayValue).value equals listOf(StringValue("\"abc\""))
+                }
+            }
+        }
+    }
+
+    @Test
+    fun javaAnnotationClass() {
+        inlineModelTest(
+            """
+                |import java.lang.annotation.Retention
+                |import java.lang.annotation.RetentionPolicy
+                |
+                |@Retention(RetentionPolicy.SOURCE)
+                |public annotation class throws()
+            """
+        ) {
+            with((this / "classes" / "throws").cast<DAnnotation>()) {
+                with(extra[Annotations]!!.content.entries.single().value.assertNotNull("Annotations")) {
+                    this counts 1
+                    with(first()) {
+                        dri.classNames equals "Retention"
+                        params["value"].assertNotNull("value") equals EnumValue(
+                            "RetentionPolicy.SOURCE",
+                            DRI("java.lang.annotation", "RetentionPolicy.SOURCE")
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    @Test fun genericAnnotationClass() {
+        inlineModelTest(
+            """annotation class Foo<A,B,C,D:Number>() {}"""
+        ) {
+            with((this / "classes" / "Foo").cast<DAnnotation>()){
+                generics.map { it.name to it.bounds.first().name } equals listOf("A" to "Any", "B" to "Any", "C" to "Any", "D" to "Number")
+            }
+        }
+    }
+
+    @Test fun nestedGenericClasses(){
+        inlineModelTest(
+            """
+            |class Outer<OUTER> {
+            |   inner class Inner<INNER, T : OUTER> { }
+            |}
+        """.trimMargin()
+        ){
+            with((this / "classes" / "Outer").cast<DClass>()){
+                val inner = classlikes.single().cast<DClass>()
+                inner.generics.map { it.name to it.bounds.first().name } equals listOf("INNER" to "Any", "T" to "OUTER")
+            }
+        }
+    }
+
+    @Test fun allImplementedInterfaces() {
+        inlineModelTest(
+            """
+                | interface Highest { }
+                | open class HighestImpl: Highest { }
+                | interface Lower { }
+                | interface LowerImplInterface: Lower { }
+                | class Tested : HighestImpl(), LowerImplInterface { }
+            """.trimIndent()
+        ){
+            with((this / "classes" / "Tested").cast<DClass>()){
+                extra[ImplementedInterfaces]?.interfaces?.entries?.single()?.value?.map { it.sureClassNames }?.sorted() equals listOf("Highest", "Lower", "LowerImplInterface").sorted()
+            }
+        }
+    }
+
+    @Test fun multipleClassInheritance() {
+        inlineModelTest(
+            """
+                | open class A { }
+                | open class B: A() { }
+                | class Tested : B() { }
+            """.trimIndent()
+        ) {
+            with((this / "classes" / "Tested").cast<DClass>()) {
+                supertypes.entries.single().value.map { it.dri.sureClassNames }.single() equals "B"
+            }
+        }
+    }
+
+    @Test fun multipleClassInheritanceWithInterface(){
+        inlineModelTest(
+            """
+               | open class A { }
+               | open class B: A() { }
+               | interface X { }
+               | interface Y : X { }
+               | class Tested : B(), Y { }
+            """.trimIndent()
+        ){
+            with((this / "classes" / "Tested").cast<DClass>()) {
+                supertypes.entries.single().value.map { it.dri.sureClassNames to it.kind }.sortedBy { it.first } equals listOf("B" to KotlinClassKindTypes.CLASS, "Y" to KotlinClassKindTypes.INTERFACE)
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/model/CommentTest.kt b/plugins/base/src/test/kotlin/model/CommentTest.kt
new file mode 100644
index 00000000..c1da8ee0
--- /dev/null
+++ b/plugins/base/src/test/kotlin/model/CommentTest.kt
@@ -0,0 +1,332 @@
+package model
+
+import org.jetbrains.dokka.model.DProperty
+import org.jetbrains.dokka.model.doc.CustomTagWrapper
+import org.jetbrains.dokka.model.doc.Text
+import org.junit.jupiter.api.Test
+import utils.*
+
+class CommentTest : AbstractModelTest("/src/main/kotlin/comment/Test.kt", "comment") {
+
+    @Test
+    fun codeBlockComment() {
+        inlineModelTest(
+            """
+                |/**
+                | * ```brainfuck
+                | * ++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
+                | * ```
+                | */
+                |val prop1 = ""
+                |
+                |
+                |/**
+                | * ```
+                | * a + b - c
+                | * ```
+                | */
+                |val prop2 = ""
+            """
+        ) {
+            with((this / "comment" / "prop1").cast<DProperty>()) {
+                name equals "prop1"
+                with(this.docs().firstOrNull()?.root.assertNotNull("Code")) {
+                    (children.firstOrNull() as? Text)
+                        ?.body equals "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>."
+
+                    params["lang"] equals "brainfuck"
+                }
+            }
+            with((this / "comment" / "prop2").cast<DProperty>()) {
+                name equals "prop2"
+                comments() equals "a + b - c"
+            }
+        }
+    }
+
+    @Test
+    fun emptyDoc() {
+        inlineModelTest(
+            """
+            val property = "test"
+        """
+        ) {
+            with((this / "comment" / "property").cast<DProperty>()) {
+                name equals "property"
+                comments() equals ""
+            }
+        }
+    }
+
+    @Test
+    fun emptyDocButComment() {
+        inlineModelTest(
+            """
+            |/* comment */
+            |val property = "test"
+            |fun tst() = property
+        """
+        ) {
+            val p = this
+            with((this / "comment" / "property").cast<DProperty>()) {
+                comments() equals ""
+            }
+        }
+    }
+
+    @Test
+    fun multilineDoc() {
+        inlineModelTest(
+            """
+            |/**
+            | * doc1
+            | *
+            | * doc2
+            | * doc3
+            | */
+            |val property = "test"
+        """
+        ) {
+            with((this / "comment" / "property").cast<DProperty>()) {
+                comments() equals "doc1\ndoc2 doc3"
+            }
+        }
+    }
+
+    @Test
+    fun multilineDocWithComment() {
+        inlineModelTest(
+            """
+            |/**
+            | * doc1
+            | *
+            | * doc2
+            | * doc3
+            | */
+            |// comment
+            |val property = "test"
+        """
+        ) {
+            with((this / "comment" / "property").cast<DProperty>()) {
+                comments() equals "doc1\ndoc2 doc3"
+            }
+        }
+    }
+
+    @Test
+    fun oneLineDoc() {
+        inlineModelTest(
+            """
+            |/** doc */
+            |val property = "test"
+        """
+        ) {
+            with((this / "comment" / "property").cast<DProperty>()) {
+                comments() equals "doc"
+            }
+        }
+    }
+
+    @Test
+    fun oneLineDocWithComment() {
+        inlineModelTest(
+            """
+            |/** doc */
+            |// comment
+            |val property = "test"
+        """
+        ) {
+            with((this / "comment" / "property").cast<DProperty>()) {
+                comments() equals "doc"
+            }
+        }
+    }
+
+    @Test
+    fun oneLineDocWithEmptyLine() {
+        inlineModelTest(
+            """
+            |/** doc */
+            |
+            |val property = "test"
+        """
+        ) {
+            with((this / "comment" / "property").cast<DProperty>()) {
+                comments() equals "doc"
+            }
+        }
+    }
+
+    @Test
+    fun emptySection() {
+        inlineModelTest(
+            """
+            |/**
+            | * Summary
+            | * @one
+            | */
+            |val property = "test"
+        """
+        ) {
+            with((this / "comment" / "property").cast<DProperty>()) {
+                comments() equals "Summary\none: []"
+                docs().find { it is CustomTagWrapper && it.name == "one" }.let {
+                    with(it.assertNotNull("'one' entry")) {
+                        root.children counts 0
+                        root.params.keys counts 0
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun quotes() {
+        inlineModelTest(
+            """
+            |/** it's "useful" */
+            |val property = "test"
+        """
+        ) {
+            with((this / "comment" / "property").cast<DProperty>()) {
+                comments() equals """it's "useful""""
+            }
+        }
+    }
+
+    @Test
+    fun section1() {
+        inlineModelTest(
+            """
+            |/**
+            | * Summary
+            | * @one section one
+            | */
+            |val property = "test"
+        """
+        ) {
+            with((this / "comment" / "property").cast<DProperty>()) {
+                comments() equals "Summary\none: [section one]"
+            }
+        }
+    }
+
+
+    @Test
+    fun section2() {
+        inlineModelTest(
+            """
+            |/**
+            | * Summary
+            | * @one section one
+            | * @two section two
+            | */
+            |val property = "test"
+        """
+        ) {
+            with((this / "comment" / "property").cast<DProperty>()) {
+                comments() equals "Summary\none: [section one]\ntwo: [section two]"
+            }
+        }
+    }
+
+    @Test
+    fun multilineSection() {
+        inlineModelTest(
+            """
+            |/**
+            | * Summary
+            | * @one
+            | *   line one
+            | *   line two
+            | */
+            |val property = "test"
+        """
+        ) {
+            with((this / "comment" / "property").cast<DProperty>()) {
+                comments() equals "Summary\none: [line one line two]"
+            }
+        }
+    }
+
+//    @Test todo
+    fun directive() {
+        inlineModelTest(
+            """
+            |/**
+            | * Summary
+            | *
+            | * @sample example1
+            | * @sample example2
+            | * @sample X.example3
+            | * @sample X.Y.example4
+            | */
+            |val property = "test"
+            |
+            |fun example1(node: String) = if (true) {
+            |    println(property)
+            |}
+            |
+            |fun example2(node: String) {
+            |    if (true) {
+            |        println(property)
+            |    }
+            |}
+            |
+            |class X {
+            |    fun example3(node: String) {
+            |        if (true) {
+            |            println(property)
+            |        }
+            |    }
+            |
+            |    class Y {
+            |        fun example4(node: String) {
+            |            if (true) {
+            |                println(property)
+            |            }
+            |        }
+            |    }
+            |}
+        """
+        ) {
+            with((this / "comment" / "property").cast<DProperty>()) {
+                this
+            }
+        }
+    }
+
+
+//    @Test fun directive() {
+//        checkSourceExistsAndVerifyModel("testdata/comments/directive.kt", defaultModelConfig) { model ->
+//            with(model.members.single().members.first()) {
+//                assertEquals("Summary", content.summary.toTestString())
+//                with (content.description) {
+//                    assertEqualsIgnoringSeparators("""
+//                        |[code lang=kotlin]
+//                        |if (true) {
+//                        |    println(property)
+//                        |}
+//                        |[/code]
+//                        |[code lang=kotlin]
+//                        |if (true) {
+//                        |    println(property)
+//                        |}
+//                        |[/code]
+//                        |[code lang=kotlin]
+//                        |if (true) {
+//                        |    println(property)
+//                        |}
+//                        |[/code]
+//                        |[code lang=kotlin]
+//                        |if (true) {
+//                        |    println(property)
+//                        |}
+//                        |[/code]
+//                        |""".trimMargin(), toTestString())
+//                }
+//            }
+//        }
+//    }
+
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/model/FunctionsTest.kt b/plugins/base/src/test/kotlin/model/FunctionsTest.kt
new file mode 100644
index 00000000..c96e7df6
--- /dev/null
+++ b/plugins/base/src/test/kotlin/model/FunctionsTest.kt
@@ -0,0 +1,396 @@
+package model
+
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.*
+import org.junit.jupiter.api.Test
+import utils.AbstractModelTest
+import utils.assertNotNull
+import utils.comments
+import utils.name
+
+class FunctionTest : AbstractModelTest("/src/main/kotlin/function/Test.kt", "function") {
+
+    @Test
+    fun function() {
+        inlineModelTest(
+            """
+            |/**
+            | * Function fn
+            | */
+            |fun fn() {}
+        """
+        ) {
+            with((this / "function" / "fn").cast<DFunction>()) {
+                name equals "fn"
+                type.name equals "Unit"
+                this.children.assertCount(0, "Function children: ")
+            }
+        }
+    }
+
+    @Test
+    fun overloads() {
+        inlineModelTest(
+            """
+            |/**
+            | * Function fn
+            | */
+            |fun fn() {}
+            | /**
+            | * Function fn(Int)
+            | */
+            |fun fn(i: Int) {}
+        """
+        ) {
+            with((this / "function").cast<DPackage>()) {
+                val fn1 = functions.find {
+                    it.name == "fn" && it.parameters.isNullOrEmpty()
+                }.assertNotNull("fn()")
+                val fn2 = functions.find {
+                    it.name == "fn" && it.parameters.isNotEmpty()
+                }.assertNotNull("fn(Int)")
+
+                with(fn1) {
+                    name equals "fn"
+                    parameters.assertCount(0)
+                }
+
+                with(fn2) {
+                    name equals "fn"
+                    parameters.assertCount(1)
+                    parameters.first().type.name equals "Int"
+                }
+            }
+        }
+    }
+
+    @Test
+    fun functionWithReceiver() {
+        inlineModelTest(
+            """
+            |/**
+            | * Function with receiver
+            | */
+            |fun String.fn() {}
+            |
+            |/**
+            | * Function with receiver
+            | */
+            |fun String.fn(x: Int) {}
+        """
+        ) {
+            with((this / "function").cast<DPackage>()) {
+                val fn1 = functions.find {
+                    it.name == "fn" && it.parameters.isNullOrEmpty()
+                }.assertNotNull("fn()")
+                val fn2 = functions.find {
+                    it.name == "fn" && it.parameters.count() == 1
+                }.assertNotNull("fn(Int)")
+
+                with(fn1) {
+                    name equals "fn"
+                    parameters counts 0
+                    receiver.assertNotNull("fn() receiver")
+                }
+
+                with(fn2) {
+                    name equals "fn"
+                    parameters counts 1
+                    receiver.assertNotNull("fn(Int) receiver")
+                    parameters.first().type.name equals "Int"
+                }
+            }
+        }
+    }
+
+    @Test
+    fun functionWithParams() {
+        inlineModelTest(
+            """
+                |/**
+                | * Multiline
+                | *
+                | * Function
+                | * Documentation
+                | */
+                |fun function(/** parameter */ x: Int) {
+                |}
+        """
+        ) {
+            with((this / "function" / "function").cast<DFunction>()) {
+                comments() equals "Multiline\nFunction Documentation"
+
+                name equals "function"
+                parameters counts 1
+                parameters.firstOrNull().assertNotNull("Parameter: ").also {
+                    it.name equals "x"
+                    it.type.name equals "Int"
+                    it.comments() equals "parameter"
+                }
+
+                type.assertNotNull("Return type: ").name equals "Unit"
+            }
+        }
+    }
+
+    @Test
+    fun functionWithNotDocumentedAnnotation() {
+        inlineModelTest(
+            """
+                |@Suppress("FOO") fun f() {}
+        """
+        ) {
+            with((this / "function" / "f").cast<DFunction>()) {
+                with(extra[Annotations]!!.content.entries.single().value.assertNotNull("Annotations")) {
+                    this counts 1
+                    with(first()) {
+                        dri.classNames equals "Suppress"
+                        params.entries counts 1