Moves all core tests to base plugin

7 files changed, 1424 insertions, 0 deletions

diff --git a/plugins/base/src/test/kotlin/basic/DRITest.kt b/plugins/base/src/test/kotlin/basic/DRITest.kt
new file mode 100644
index 00000000..c7dc85fb
--- /dev/null
+++ b/plugins/base/src/test/kotlin/basic/DRITest.kt
@@ -0,0 +1,168 @@
+package basic
+
+import org.jetbrains.dokka.links.*
+import org.jetbrains.dokka.pages.ContentPage
+import org.jetbrains.dokka.pages.asSequence
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import testApi.testRunner.AbstractCoreTest
+
+class DRITest : AbstractCoreTest() {
+    @Test
+    fun `#634`() {
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/basic/Test.kt
+            |package toplevel
+            |
+            |inline fun <T, R : Comparable<R>> Array<out T>.mySortBy(
+            |    crossinline selector: (T) -> R?): Array<out T> = TODO()
+            |}
+        """.trimMargin(),
+            configuration
+        ) {
+            documentablesMergingStage = { module ->
+                val expected = TypeConstructor(
+                    "kotlin.Function1", listOf(
+                        TypeParam(listOf(Nullable(TypeConstructor("kotlin.Any", emptyList())))),
+                        Nullable(TypeParam(listOf(TypeConstructor("kotlin.Comparable", listOf(SelfType)))))
+                    )
+                )
+                val actual = module.packages.single()
+                    .functions.single()
+                    .dri.callable?.params?.single()
+                assertEquals(expected, actual)
+            }
+        }
+    }
+
+    @Test
+    fun `#634 with immediate nullable self`() {
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/basic/Test.kt
+            |package toplevel
+            |
+            |fun <T : Comparable<T>> Array<T>.doSomething(t: T?): Array<T> = TODO()
+            |}
+        """.trimMargin(),
+            configuration
+        ) {
+            documentablesMergingStage = { module ->
+                val expected = Nullable(TypeParam(listOf(TypeConstructor("kotlin.Comparable", listOf(SelfType)))))
+                val actual = module.packages.single()
+                    .functions.single()
+                    .dri.callable?.params?.single()
+                assertEquals(expected, actual)
+            }
+        }
+    }
+
+    @Test
+    fun `#634 with generic nullable receiver`() {
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/basic/Test.kt
+            |package toplevel
+            |
+            |fun <T : Comparable<T>> T?.doSomethingWithNullable() = TODO()
+            |}
+        """.trimMargin(),
+            configuration
+        ) {
+            documentablesMergingStage = { module ->
+                val expected = Nullable(TypeParam(listOf(TypeConstructor("kotlin.Comparable", listOf(SelfType)))))
+                val actual = module.packages.single()
+                    .functions.single()
+                    .dri.callable?.receiver
+                assertEquals(expected, actual)
+            }
+        }
+    }
+
+    @Test
+    fun `#642 with * and Any?`() {
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    analysisPlatform = "js"
+                    sourceRoots = listOf("src/")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt
+            |
+            |open class Bar<Z>
+            |class ReBarBar : Bar<StringBuilder>()
+            |class Foo<out T : Comparable<*>, R : List<Bar<*>>>
+            |
+            |fun <T : Comparable<Any?>> Foo<T, *>.qux(): String = TODO()
+            |fun <T : Comparable<*>> Foo<T, *>.qux(): String = TODO()
+            |
+        """.trimMargin(),
+            configuration
+        ) {
+            pagesGenerationStage = { module ->
+                // DRI(//qux/Foo[TypeParam(bounds=[kotlin.Comparable[kotlin.Any?]]),kotlin.Any?]#//)
+                val expectedDRI = DRI(
+                    "",
+                    null,
+                    Callable(
+                        "qux",
+                        TypeConstructor(
+                            "Foo",
+                            listOf(
+                                TypeParam(
+                                    listOf(
+                                        TypeConstructor(
+                                            "kotlin.Comparable",
+                                            listOf(
+                                                Nullable(TypeConstructor("kotlin.Any", emptyList()))
+                                            )
+                                        )
+                                    )
+                                ),
+                                Nullable(TypeConstructor("kotlin.Any", emptyList()))
+                            )
+                        ),
+                        emptyList()
+                    )
+                )
+
+                val driCount = module
+                    .asSequence()
+                    .filterIsInstance<ContentPage>()
+                    .sumBy { it.dri.count { dri -> dri == expectedDRI } }
+
+                assertEquals(1, driCount)
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt b/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt
new file mode 100644
index 00000000..021f110c
--- /dev/null
+++ b/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt
@@ -0,0 +1,41 @@
+package basic
+
+import org.jetbrains.dokka.pages.ClasslikePageNode
+import org.jetbrains.dokka.pages.ModulePageNode
+import org.junit.Test
+import testApi.testRunner.AbstractCoreTest
+
+class DokkaBasicTests : AbstractCoreTest() {
+
+    @Test
+    fun basic1() {
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/basic/Test.kt
+            |package basic
+            |
+            |class Test {
+            |   val tI = 1
+            |   fun tF() = 2
+            |}
+        """.trimMargin(),
+            configuration
+        ) {
+            pagesGenerationStage = {
+                println(it.dri)
+                assert(it.getClasslikeToMemberMap().filterKeys { it.name == "Test" }.entries.firstOrNull()?.value?.size == 5)
+            }
+        }
+    }
+
+    fun ModulePageNode.getClasslikeToMemberMap() =
+        this.parentMap.filterValues { it is ClasslikePageNode }.entries.groupBy ({it.value}){it.key}
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/enums/EnumsTest.kt b/plugins/base/src/test/kotlin/enums/EnumsTest.kt
new file mode 100644
index 00000000..efc46595
--- /dev/null
+++ b/plugins/base/src/test/kotlin/enums/EnumsTest.kt
@@ -0,0 +1,45 @@
+package enums
+
+import org.jetbrains.dokka.pages.ClasslikePageNode
+import org.jetbrains.dokka.pages.ModulePageNode
+import org.junit.Test
+import testApi.testRunner.AbstractCoreTest
+
+class EnumsTest : AbstractCoreTest() {
+
+    @Test
+    fun basicEnums() {
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/basic/Test.kt
+            |package enums
+            |
+            |enum class Test {
+            |   E1,
+            |   E2
+            |}
+        """.trimMargin(),
+            configuration
+        ) {
+            pagesGenerationStage = {
+                val map = it.getClasslikeToMemberMap()
+                val test = map.filterKeys { it.name == "Test" }.values.firstOrNull()
+                assert(test != null) { "Test not found" }
+                assert(test!!.any { it.name == "E1" } && test.any { it.name == "E2" }) { "Enum entries missing in parent" }
+                assert(map.keys.any { it.name == "E1" } && map.keys.any { it.name == "E2" }) { "Enum entries missing" }
+            }
+        }
+    }
+
+
+    fun ModulePageNode.getClasslikeToMemberMap() =
+        this.parentMap.filterValues { it is ClasslikePageNode }.entries.groupBy({ it.value }) { it.key }
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/markdown/KDocTest.kt b/plugins/base/src/test/kotlin/markdown/KDocTest.kt
new file mode 100644
index 00000000..c58c4e30
--- /dev/null
+++ b/plugins/base/src/test/kotlin/markdown/KDocTest.kt
@@ -0,0 +1,48 @@
+package markdown
+
+import org.jetbrains.dokka.model.Package
+import org.jetbrains.dokka.model.doc.DocumentationNode
+import org.jetbrains.dokka.pages.ModulePageNode
+import org.junit.Assert
+import testApi.testRunner.AbstractCoreTest
+
+open class KDocTest : AbstractCoreTest() {
+
+    private val configuration = dokkaConfiguration {
+        passes {
+            pass {
+                sourceRoots = listOf("src/main/kotlin/example/Test.kt")
+            }
+        }
+    }
+
+    private fun interpolateKdoc(kdoc: String) = """
+            |/src/main/kotlin/example/Test.kt
+            |package example
+            | /**
+            ${kdoc.split("\n").joinToString("") { "| *$it\n" } }
+            | */
+            |class Test
+        """.trimMargin()
+
+    private fun actualDocumentationNode(modulePageNode: ModulePageNode) =
+        (modulePageNode.documentable?.children?.first() as Package)
+            .classlikes.first()
+            .platformInfo.first()
+            .documentationNode
+
+
+    protected fun executeTest(kdoc: String, expectedDocumentationNode: DocumentationNode) {
+        testInline(
+            interpolateKdoc(kdoc),
+            configuration
+        ) {
+            pagesGenerationStage = {
+                Assert.assertEquals(
+                    expectedDocumentationNode,
+                    actualDocumentationNode(it)
+                )
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/markdown/ParserTest.kt b/plugins/base/src/test/kotlin/markdown/ParserTest.kt
new file mode 100644
index 00000000..dee8e907
--- /dev/null
+++ b/plugins/base/src/test/kotlin/markdown/ParserTest.kt
@@ -0,0 +1,940 @@
+package org.jetbrains.dokka.tests
+
+import markdown.KDocTest
+import org.jetbrains.dokka.model.doc.*
+import org.junit.Ignore
+import org.junit.Test
+
+
+class ParserTest : KDocTest() {
+
+    @Test fun `Simple text`() {
+        val kdoc = """
+        | This is simple test of string
+        | Next line
+        """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(Text("This is simple test of string Next line")))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Simple text with new line`() {
+        val kdoc = """
+        | This is simple test of string\
+        | Next line
+        """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        Text("This is simple test of string"),
+                        Br,
+                        Text("Next line")
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Text with Bold and Emphasis decorators`() {
+        val kdoc = """
+        | This is **simple** test of _string_
+        | Next **_line_**
+        """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(
+                        listOf(
+                            Text("This is "),
+                            B(listOf(Text("simple"))),
+                            Text(" test of "),
+                            I(listOf(Text("string"))),
+                            Text(" Next "),
+                            B(listOf(I(listOf(Text("line")))))
+                        )
+                    )
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Text with Colon`() {
+        val kdoc = """
+        | This is simple text with: colon!
+        """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(Text("This is simple text with: colon!")))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Multilined text`() {
+        val kdoc = """
+        | Text
+        | and
+        | String
+        """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(Text("Text and String")))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Paragraphs`() {
+        val kdoc = """
+        | Paragraph number
+        | one
+        |
+        | Paragraph\
+        | number two
+        """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(
+                        listOf(
+                            P(listOf(Text("Paragraph number one"))),
+                            P(listOf(Text("Paragraph"), Br, Text("number two")))
+                        )
+                    )
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Emphasis with star`() {
+        val kdoc = " *text*"
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(I(listOf(Text("text")))))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Underscores that are not Emphasis`() {
+        val kdoc = "text_with_underscores"
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(Text("text_with_underscores")))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Emphasis with underscores`() {
+        val kdoc = "_text_"
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(I(listOf(Text("text")))))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Embedded star`() {
+        val kdoc = "Embedded*Star"
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(Text("Embedded*Star")))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+
+    @Test fun `Unordered list`() {
+        val kdoc = """
+        | * list item 1
+        | * list item 2
+        """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    Ul(
+                        listOf(
+                            Li(listOf(P(listOf(Text("list item 1"))))),
+                            Li(listOf(P(listOf(Text("list item 2")))))
+                        )
+                    )
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Unordered list with multilines`() {
+        val kdoc = """
+        | * list item 1
+        |  continue 1
+        | * list item 2\
+        | continue 2
+        """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    Ul(
+                        listOf(
+                            Li(listOf(P(listOf(Text("list item 1 continue 1"))))),
+                            Li(listOf(P(listOf(Text("list item 2"), Br, Text("continue 2")))))
+                        )
+                    )
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Unordered list with Bold`() {
+        val kdoc = """
+        | * list **item** 1
+        |  continue 1
+        | * list __item__ 2
+        |  continue 2
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    Ul(listOf(
+                        Li(listOf(P(listOf(
+                            Text("list "),
+                            B(listOf(Text("item"))),
+                            Text(" 1 continue 1")
+                        )))),
+                        Li(listOf(P(listOf(
+                            Text("list "),
+                            B(listOf(Text("item"))),
+                            Text(" 2 continue 2")
+                        ))))
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Unordered list with nested bullets`() {
+        val kdoc = """
+        | * Outer first
+        | Outer next line
+        | * Outer second
+        |     - Middle first
+        | Middle next line
+        |     - Middle second
+        |         + Inner first
+        | Inner next line
+        |     - Middle third
+        | * Outer third
+        |
+        | New paragraph""".trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        Ul(listOf(
+                            Li(listOf(P(listOf(Text("Outer first Outer next line"))))),
+                            Li(listOf(P(listOf(Text("Outer second"))))),
+                            Ul(listOf(
+                                Li(listOf(P(listOf(Text("Middle first Middle next line"))))),
+                                Li(listOf(P(listOf(Text("Middle second"))))),
+                                Ul(listOf(
+                                    Li(listOf(P(listOf(Text("Inner first Inner next line")))))
+                                )),
+                                Li(listOf(P(listOf(Text("Middle third")))))
+                            )),
+                            Li(listOf(P(listOf(Text("Outer third")))))
+                        )),
+                        P(listOf(Text("New paragraph")))
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Ordered list`() {
+        val kdoc = """
+        | 1. list item 1
+        | 2. list item 2
+        """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    Ol(
+                        listOf(
+                            Li(listOf(P(listOf(Text("list item 1"))))),
+                            Li(listOf(P(listOf(Text("list item 2")))))
+                        ),
+                        mapOf("start" to "1")
+                    )
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+
+    @Test fun `Ordered list beginning from other number`() {
+        val kdoc = """
+        | 9. list item 1
+        | 12. list item 2
+        """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    Ol(
+                        listOf(
+                            Li(listOf(P(listOf(Text("list item 1"))))),
+                            Li(listOf(P(listOf(Text("list item 2")))))
+                        ),
+                        mapOf("start" to "9")
+                    )
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Ordered list with multilines`() {
+        val kdoc = """
+        | 2. list item 1
+        |  continue 1
+        | 3. list item 2
+        | continue 2
+        """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    Ol(
+                        listOf(
+                            Li(listOf(P(listOf(Text("list item 1 continue 1"))))),
+                            Li(listOf(P(listOf(Text("list item 2 continue 2")))))
+                        ),
+                        mapOf("start" to "2")
+                    )
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Ordered list with Bold`() {
+        val kdoc = """
+        | 1. list **item** 1
+        |  continue 1
+        | 2. list __item__ 2
+        |  continue 2
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    Ol(listOf(
+                            Li(listOf(P(listOf(
+                                Text("list "),
+                                B(listOf(Text("item"))),
+                                Text(" 1 continue 1")
+                            )))),
+                            Li(listOf(P(listOf(
+                                Text("list "),
+                                B(listOf(Text("item"))),
+                                Text(" 2 continue 2")
+                            ))))
+                        ),
+                        mapOf("start" to "1")
+                    )
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Ordered list with nested bullets`() {
+        val kdoc = """
+        | 1. Outer first
+        | Outer next line
+        | 2. Outer second
+        |     1. Middle first
+        | Middle next line
+        |     2. Middle second
+        |         1. Inner first
+        | Inner next line
+        |     5. Middle third
+        | 4. Outer third
+        |
+        | New paragraph""".trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        Ol(listOf(
+                            Li(listOf(P(listOf(Text("Outer first Outer next line"))))),
+                            Li(listOf(P(listOf(Text("Outer second"))))),
+                            Ol(listOf(
+                                Li(listOf(P(listOf(Text("Middle first Middle next line"))))),
+                                Li(listOf(P(listOf(Text("Middle second"))))),
+                                Ol(listOf(
+                                    Li(listOf(P(listOf(Text("Inner first Inner next line")))))
+                                    ),
+                                    mapOf("start" to "1")
+                                ),
+                                Li(listOf(P(listOf(Text("Middle third")))))
+                                ),
+                                mapOf("start" to "1")
+                            ),
+                            Li(listOf(P(listOf(Text("Outer third")))))
+                            ),
+                            mapOf("start" to "1")
+                        ),
+                        P(listOf(Text("New paragraph")))
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Ordered nested in Unordered nested in Ordered list`() {
+        val kdoc = """
+        | 1. Outer first
+        | Outer next line
+        | 2. Outer second
+        |     + Middle first
+        | Middle next line
+        |     + Middle second
+        |         1. Inner first
+        | Inner next line
+        |     + Middle third
+        | 4. Outer third
+        |
+        | New paragraph""".trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        Ol(listOf(
+                            Li(listOf(P(listOf(Text("Outer first Outer next line"))))),
+                            Li(listOf(P(listOf(Text("Outer second"))))),
+                            Ul(listOf(
+                                Li(listOf(P(listOf(Text("Middle first Middle next line"))))),
+                                Li(listOf(P(listOf(Text("Middle second"))))),
+                                Ol(listOf(
+                                    Li(listOf(P(listOf(Text("Inner first Inner next line")))))
+                                ),
+                                    mapOf("start" to "1")
+                                ),
+                                Li(listOf(P(listOf(Text("Middle third")))))
+                            )),
+                            Li(listOf(P(listOf(Text("Outer third")))))
+                        ),
+                            mapOf("start" to "1")
+                        ),
+                        P(listOf(Text("New paragraph")))
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Header and two paragraphs`() {
+        val kdoc = """
+        | # Header 1
+        | Following text
+        |
+        | New paragraph
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        H1(listOf(Text("Header 1"))),
+                        P(listOf(Text("Following text"))),
+                        P(listOf(Text("New paragraph")))
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Ignore //TODO: ATX_2 to ATX_6 and sometimes ATX_1 from jetbrains parser consumes white space. Need to handle it in their library
+    @Test fun `All headers`() {
+        val kdoc = """
+        | # Header 1
+        | Text 1
+        | ## Header 2
+        | Text 2
+        | ### Header 3
+        | Text 3
+        | #### Header 4
+        | Text 4
+        | ##### Header 5
+        | Text 5
+        | ###### Header 6
+        | Text 6
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        H1(listOf(Text("Header 1"))),
+                        P(listOf(Text("Text 1"))),
+                        H2(listOf(Text("Header 2"))),
+                        P(listOf(Text("Text 2"))),
+                        H3(listOf(Text("Header 3"))),
+                        P(listOf(Text("Text 3"))),
+                        H4(listOf(Text("Header 4"))),
+                        P(listOf(Text("Text 4"))),
+                        H5(listOf(Text("Header 5"))),
+                        P(listOf(Text("Text 5"))),
+                        H6(listOf(Text("Header 6"))),
+                        P(listOf(Text("Text 6")))
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Bold New Line Bold`() {
+        val kdoc = """
+        | **line 1**\
+        | **line 2**
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        B(listOf(Text("line 1"))),
+                        Br,
+                        B(listOf(Text("line 2")))
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Horizontal rule`() {
+        val kdoc = """
+        | ***
+        | text 1
+        | ___
+        | text 2
+        | ***
+        | text 3
+        | ___
+        | text 4
+        | ***
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        HorizontalRule,
+                        P(listOf(Text("text 1"))),
+                        HorizontalRule,
+                        P(listOf(Text("text 2"))),
+                        HorizontalRule,
+                        P(listOf(Text("text 3"))),
+                        HorizontalRule,
+                        P(listOf(Text("text 4"))),
+                        HorizontalRule
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Blockquote`() {
+        val kdoc = """
+        | > Blockquotes are very handy in email to emulate reply text.
+        | > This line is part of the same quote.
+        |
+        | Quote break.
+        |
+        | > Quote
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        BlockQuote(listOf(
+                            P(listOf(
+                                Text("Blockquotes are very handy in email to emulate reply text. This line is part of the same quote.")
+                            ))
+                        )),
+                        P(listOf(Text("Quote break."))),
+                        BlockQuote(listOf(
+                            P(listOf(Text("Quote")))
+                        ))
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+
+    @Test fun `Blockquote nested`() {
+        val kdoc = """
+        | > text 1
+        | > text 2
+        | >> text 3
+        | >> text 4
+        | >
+        | > text 5
+        |
+        | Quote break.
+        |
+        | > Quote
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        BlockQuote(listOf(
+                            P(listOf(Text("text 1 text 2"))),
+                            BlockQuote(listOf(
+                                P(listOf(Text("text 3 text 4")))
+                            )),
+                            P(listOf(Text("text 5")))
+                            )),
+                        P(listOf(Text("Quote break."))),
+                        BlockQuote(listOf(
+                            P(listOf(Text("Quote")))
+                        ))
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Ignore //TODO: Again ATX_1 consumes white space
+    @Test fun `Blockquote nested with fancy text enhancement`() {
+        val kdoc = """
+        | > text **1**
+        | > text 2
+        | >> # text 3
+        | >> * text 4
+        | >>     * text 5
+        | >
+        | > text 6
+        |
+        | Quote break.
+        |
+        | > Quote
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        BlockQuote(listOf(
+                            P(listOf(
+                                Text("text "),
+                                B(listOf(Text("1"))),
+                                Text("\ntext 2")
+                            )),
+                            BlockQuote(listOf(
+                                H1(listOf(Text("text 3"))),
+                                Ul(listOf(
+                                    Li(listOf(P(listOf(Text("text 4"))))),
+                                    Ul(listOf(
+                                        Li(listOf(P(listOf(Text("text 5")))))
+                                    )
+                                )))
+                            )),
+                            P(listOf(Text("text 6")))
+                        )),
+                        P(listOf(Text("Quote break."))),
+                        BlockQuote(listOf(
+                            P(listOf(Text("Quote")))
+                        ))
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Simple Code Block`() {
+        val kdoc = """
+        | `Some code`
+        | Sample text
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        Code(listOf(Text("Some code"))),
+                        Text(" Sample text")
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Multilined Code Block`() {
+        val kdoc = """
+        | ```kotlin
+        | val x: Int = 0
+        | val y: String = "Text"
+        |
+        |     val z: Boolean = true
+        | for(i in 0..10) {
+        |     println(i)
+        | }
+        | ```
+        | Sample text
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        Code(
+                            listOf(
+                                Text("val x: Int = 0"), Br,
+                                Text("val y: String = \"Text\""), Br, Br,
+                                Text("    val z: Boolean = true"), Br,
+                                Text("for(i in 0..10) {"), Br,
+                                Text("    println(i)"), Br,
+                                Text("}")
+                            ),
+                            mapOf("lang" to "kotlin")
+                        ),
+                        P(listOf(Text("Sample text")))
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+
+    @Test fun `Inline link`() {
+        val kdoc = """
+        | [I'm an inline-style link](https://www.google.com)
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(A(
+                        listOf(Text("I'm an inline-style link")),
+                        mapOf("href" to "https://www.google.com")
+                    )))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Inline link with title`() {
+        val kdoc = """
+        | [I'm an inline-style link with title](https://www.google.com "Google's Homepage")
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(A(
+                        listOf(Text("I'm an inline-style link with title")),
+                        mapOf("href" to "https://www.google.com", "title" to "Google's Homepage")
+                    )))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Full reference link`() {
+        val kdoc = """
+        | [I'm a reference-style link][Arbitrary case-insensitive reference text]
+        |
+        | [arbitrary case-insensitive reference text]: https://www.mozilla.org
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(P(listOf(A(
+                        listOf(Text("I'm a reference-style link")),
+                        mapOf("href" to "https://www.mozilla.org")
+                    )))))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Full reference link with number`() {
+        val kdoc = """
+        | [You can use numbers for reference-style link definitions][1]
+        |
+        | [1]: http://slashdot.org
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(P(listOf(A(
+                        listOf(Text("You can use numbers for reference-style link definitions")),
+                        mapOf("href" to "http://slashdot.org")
+                    )))))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Short reference link`() {
+        val kdoc = """
+        | Or leave it empty and use the [link text itself].
+        |
+        | [link text itself]: http://www.reddit.com
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(P(listOf(
+                        Text("Or leave it empty and use the "),
+                        A(
+                            listOf(Text("link text itself")),
+                            mapOf("href" to "http://www.reddit.com")
+                        ),
+                        Text(".")
+                    ))))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Autolink`() {
+        val kdoc = """
+        | URLs and URLs in angle brackets will automatically get turned into links.
+        | http://www.example.com or <http://www.example.com> and sometimes
+        | example.com (but not on Github, for example).
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        Text("URLs and URLs in angle brackets will automatically get turned into links. http://www.example.com or "),
+                        A(
+                            listOf(Text("http://www.example.com")),
+                            mapOf("href" to "http://www.example.com")
+                        ),
+                        Text(" and sometimes example.com (but not on Github, for example).")
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Various links`() {
+        val kdoc = """
+        | [I'm an inline-style link](https://www.google.com)
+        |
+        | [I'm an inline-style link with title](https://www.google.com "Google's Homepage")
+        |
+        | [I'm a reference-style link][Arbitrary case-insensitive reference text]
+        |
+        | [You can use numbers for reference-style link definitions][1]
+        |
+        | Or leave it empty and use the [link text itself].
+        |
+        | URLs and URLs in angle brackets will automatically get turned into links.
+        | http://www.example.com or <http://www.example.com> and sometimes
+        | example.com (but not on Github, for example).
+        |
+        | Some text to show that the reference links can follow later.
+        |
+        | [arbitrary case-insensitive reference text]: https://www.mozilla.org
+        | [1]: http://slashdot.org
+        | [link text itself]: http://www.reddit.com
+         """.trimMargin()
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        P(listOf(A(
+                            listOf(Text("I'm an inline-style link")),
+                            mapOf("href" to "https://www.google.com")
+                        ))),
+                        P(listOf(A(
+                            listOf(Text("I'm an inline-style link with title")),
+                            mapOf("href" to "https://www.google.com", "title" to "Google's Homepage")
+                        ))),
+                        P(listOf(A(
+                            listOf(Text("I'm a reference-style link")),
+                            mapOf("href" to "https://www.mozilla.org")
+                        ))),
+                        P(listOf(A(
+                            listOf(Text("You can use numbers for reference-style link definitions")),
+                            mapOf("href" to "http://slashdot.org")
+                        ))),
+                        P(listOf(
+                            Text("Or leave it empty and use the "),
+                            A(
+                                listOf(Text("link text itself")),
+                                mapOf("href" to "http://www.reddit.com")
+                            ),
+                            Text(".")
+                        )),
+                        P(listOf(
+                            Text("URLs and URLs in angle brackets will automatically get turned into links. http://www.example.com or "),
+                            A(
+                                listOf(Text("http://www.example.com")),
+                                mapOf("href" to "http://www.example.com")
+                            ),
+                            Text(" and sometimes example.com (but not on Github, for example).")
+                        )),
+                        P(listOf(Text("Some text to show that the reference links can follow later.")))
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+
+    @Test fun `Windows Carriage Return Line Feed`() {
+        val kdoc = "text\r\ntext"
+        val expectedDocumentationNode = DocumentationNode(
+            listOf(
+                Description(
+                    P(listOf(
+                        Text("text text")
+                    ))
+                )
+            )
+        )
+        executeTest(kdoc, expectedDocumentationNode)
+    }
+}
+
diff --git a/plugins/base/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt b/plugins/base/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
new file mode 100644
index 00000000..f9431bbb
--- /dev/null
+++ b/plugins/base/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
@@ -0,0 +1,55 @@
+package multiplatform
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import testApi.testRunner.AbstractCoreTest
+
+class BasicMultiplatformTest : AbstractCoreTest() {
+
+    @Test
+    fun dataTestExample() {
+        val testDataDir = getTestDataDir("multiplatform/basicMultiplatformTest").toAbsolutePath()
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("$testDataDir/jvmMain/")
+                }
+            }
+        }
+
+        testFromData(configuration) {
+            pagesTransformationStage = {
+                assertEquals(6, it.children.firstOrNull()?.children?.count() ?: 0)
+            }
+        }
+    }
+
+    @Test
+    fun inlineTestExample() {
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/multiplatform/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/multiplatform/Test.kt
+            |package multiplatform
+            |
+            |object Test {
+            |   fun test2(str: String): Unit {println(str)}
+            |}
+        """.trimMargin(),
+            configuration
+        ) {
+            pagesGenerationStage = {
+                println(it.dri)
+                assertEquals(7, it.parentMap.size)
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt b/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
new file mode 100644
index 00000000..88e57ddb
--- /dev/null
+++ b/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
@@ -0,0 +1,127 @@
+package pageMerger
+
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.pages.ContentPage
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.transformers.pages.DefaultPageMergerStrategy
+import org.jetbrains.dokka.transformers.pages.SameMethodNamePageMergerStrategy
+import org.jetbrains.dokka.utilities.DokkaLogger
+import org.junit.Test
+import testApi.testRunner.AbstractCoreTest
+
+class PageNodeMergerTest : AbstractCoreTest() {
+
+    object SameNameStrategy : DokkaPlugin() {
+        val strategy by extending { CoreExtensions.pageMergerStrategy with SameMethodNamePageMergerStrategy }
+    }
+
+    class DefaultStrategy(val strList: MutableList<String> = mutableListOf()) : DokkaPlugin(), DokkaLogger {
+        val strategy by extending { CoreExtensions.pageMergerStrategy with DefaultPageMergerStrategy(this@DefaultStrategy) }
+
+        override var warningsCount: Int = 0
+        override var errorsCount: Int = 0
+
+        override fun debug(message: String) = TODO()
+
+        override fun info(message: String) = TODO()
+
+        override fun progress(message: String) = TODO()
+
+        override fun warn(message: String) {
+            strList += message
+        }
+
+        override fun error(message: String) = TODO()
+
+        override fun report() = TODO()
+    }
+
+    @Test
+    fun sameNameStrategyTest() {
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/pageMerger/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/pageMerger/Test.kt
+            |package pageMerger
+            |
+            |fun testT(): Int = 1
+            |fun testT(i: Int): Int = i
+            |
+            |object Test {
+            |   fun test(): String = ""
+            |   fun test(str: String): String = str
+            |}
+        """.trimMargin(),
+            configuration,
+            pluginOverrides = listOf(SameNameStrategy)
+        ) {
+            pagesTransformationStage = {
+                val allChildren = it.childrenRec().filterIsInstance<ContentPage>()
+                val testT = allChildren.filter { it.name == "testT" }
+                val test = allChildren.filter { it.name == "test" }
+
+                assert(testT.size == 1) { "There can be only one testT page" }
+                assert(testT.first().dri.size == 2) { "testT page should have 2 DRI, but has ${testT.first().dri.size}" }
+
+                assert(test.size == 1) { "There can be only one test page" }
+                assert(test.first().dri.size == 2) { "test page should have 2 DRI, but has ${test.first().dri.size}" }
+            }
+        }
+    }
+
+    @Test
+    fun defaultStrategyTest() {
+        val strList: MutableList<String> = mutableListOf()
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/pageMerger/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/pageMerger/Test.kt
+            |package pageMerger
+            |
+            |fun testT(): Int = 1
+            |fun testT(i: Int): Int = i
+            |
+            |object Test {
+            |   fun test(): String = ""
+            |   fun test(str: String): String = str
+            |}
+        """.trimMargin(),
+            configuration,
+            pluginOverrides = listOf(DefaultStrategy(strList))
+        ) {
+            pagesTransformationStage = { root ->
+                val allChildren = root.childrenRec().filterIsInstance<ContentPage>()
+                val testT = allChildren.filter { it.name == "testT" }
+                val test = allChildren.filter { it.name == "test" }
+
+                assert(testT.size == 1) { "There can be only one testT page" }
+                assert(testT.first().dri.size == 1) { "testT page should have single DRI, but has ${testT.first().dri.size}" }
+
+                assert(test.size == 1) { "There can be only one test page" }
+                assert(test.first().dri.size == 1) { "test page should have single DRI, but has ${test.first().dri.size}" }
+
+                assert(strList.count() == 2) { "Expected 2 warnings, got ${strList.count()}" }
+            }
+        }
+    }
+
+    fun PageNode.childrenRec(): List<PageNode> = listOf(this) + children.flatMap { it.childrenRec() }
+
+}
\ No newline at end of file