Merge branch 'dev-0.11.0'

2 files changed, 1322 insertions, 0 deletions

diff --git a/plugins/base/src/test/kotlin/transformers/CommentsToContentConverterTest.kt b/plugins/base/src/test/kotlin/transformers/CommentsToContentConverterTest.kt
new file mode 100644
index 00000000..5197afc6
--- /dev/null
+++ b/plugins/base/src/test/kotlin/transformers/CommentsToContentConverterTest.kt
@@ -0,0 +1,403 @@
+package transformers
+
+import org.jetbrains.dokka.base.transformers.pages.comments.DocTagToContentConverter
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.doc.*
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+import matchers.content.*
+import org.jetbrains.dokka.pages.*
+import org.jetbrains.kotlin.utils.addToStdlib.assertedCast
+
+class CommentsToContentConverterTest {
+    private val converter = DocTagToContentConverter
+
+    private fun executeTest(
+        docTag:DocTag,
+        match: ContentMatcherBuilder<ContentComposite>.() -> Unit
+    ) {
+        val dci = DCI(
+            setOf(
+                DRI("kotlin", "Any")
+            ),
+            ContentKind.Comment
+        )
+        converter.buildContent(
+            Li(
+                listOf(
+                    docTag
+                )
+            ),
+            dci,
+            emptySet()
+        ).single().assertNode(match)
+    }
+
+    @Test
+    fun `simple text`() {
+        val docTag = P(listOf(Text("This is simple test of string Next line")))
+        executeTest(docTag) {
+            +"This is simple test of string Next line"
+        }
+    }
+
+    @Test
+    fun `simple text with new line`() {
+        val docTag = P(
+            listOf(
+                Text("This is simple test of string"),
+                Br,
+                Text("Next line")
+            )
+        )
+        executeTest(docTag) {
+            +"This is simple test of string"
+            node<ContentBreakLine>()
+            +"Next line"
+        }
+    }
+
+    @Test
+    fun `paragraphs`() {
+        val docTag = P(
+            listOf(
+                P(listOf(Text("Paragraph number one"))),
+                P(listOf(Text("Paragraph"), Br, Text("number two")))
+            )
+        )
+        executeTest(docTag) {
+            +"Paragraph number one"
+            +"Paragraph"
+            node<ContentBreakLine>()
+            +"number two"
+        }
+    }
+
+    @Test
+    fun `unordered list with empty lines`() {
+        val docTag = 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(docTag) {
+            node<ContentList> {
+                group {
+                    +"list item 1 continue 1"
+                }
+                group {
+                    +"list item 2"
+                    node<ContentBreakLine>()
+                    +"continue 2"
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `nested list`() {
+        val docTag = 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(docTag) {
+            node<ContentList> {
+                group { +"Outer first Outer next line" }
+                group { +"Outer second" }
+                node<ContentList> {
+                    group { +"Middle first Middle next line" }
+                    group { +"Middle second" }
+                    node<ContentList> {
+                        group { +"Inner first Inner next line" }
+                    }
+                    group { +"Middle third" }
+                }
+                group { +"Outer third" }
+            }
+            +"New paragraph"
+        }
+    }
+
+    @Test
+    fun `header and paragraphs`() {
+        val docTag = P(
+            listOf(
+                H1(listOf(Text("Header 1"))),
+                P(listOf(Text("Following text"))),
+                P(listOf(Text("New paragraph")))
+            )
+        )
+        executeTest(docTag) {
+            header(1) { +"Header 1" }
+            +"Following text"
+            +"New paragraph"
+        }
+    }
+
+    @Test
+    fun `header levels`() {
+        val docTag = 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(docTag) {
+            header(1) {+"Header 1"}
+            +"Text 1"
+            header(2) {+"Header 2"}
+            +"Text 2"
+            header(3) {+"Header 3"}
+            +"Text 3"
+            header(4) {+"Header 4"}
+            +"Text 4"
+            header(5) {+"Header 5"}
+            +"Text 5"
+            header(6) {+"Header 6"}
+            +"Text 6"
+        }
+    }
+
+    @Test
+    fun `block quotes`() {
+        val docTag = 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(docTag) {
+            node<ContentCodeBlock> {
+                +"Blockquotes are very handy in email to emulate reply text. This line is part of the same quote."
+            }
+            +"Quote break."
+            node<ContentCodeBlock> {
+                +"Quote"
+            }
+        }
+    }
+
+    @Test
+    fun `nested block quotes`() {
+        val docTag = 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(docTag) {
+            node<ContentCodeBlock> {
+                +"text 1 text 2"
+                node<ContentCodeBlock> {
+                    +"text 3 text 4"
+                }
+                +"text 5"
+            }
+            +"Quote break."
+            node<ContentCodeBlock> {
+                +"Quote"
+            }
+        }
+    }
+
+    @Test
+    fun `multiline code`() {
+        val docTag = P(
+            listOf(
+                CodeBlock(
+                    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(docTag) {
+            node<ContentCodeBlock> {
+                +"val x: Int = 0"
+                node<ContentBreakLine>()
+                +"val y: String = \"Text\""
+                node<ContentBreakLine>()
+                node<ContentBreakLine>()
+                +"    val z: Boolean = true"
+                node<ContentBreakLine>()
+                +"for(i in 0..10) {"
+                node<ContentBreakLine>()
+                +"    println(i)"
+                node<ContentBreakLine>()
+                +"}"
+            }
+            +"Sample text"
+        }
+    }
+
+    @Test
+    fun `inline link`() {
+        val docTag = P(
+            listOf(
+                A(
+                    listOf(Text("I'm an inline-style link")),
+                    mapOf("href" to "https://www.google.com")
+                )
+            )
+        )
+        executeTest(docTag) {
+            link {
+                +"I'm an inline-style link"
+                check {
+                    assertEquals(
+                        assertedCast<ContentResolvedLink> { "Link should be resolved" }.address,
+                        "https://www.google.com"
+                    )
+                }
+            }
+        }
+    }
+
+
+
+    @Test
+    fun `ordered list`() {
+        val docTag =
+            Ol(
+            listOf(
+                Li(
+                    listOf(
+                        P(listOf(Text("test1"))),
+                        P(listOf(Text("test2"))),
+                    )
+                ),
+                Li(
+                    listOf(
+                        P(listOf(Text("test3"))),
+                        P(listOf(Text("test4"))),
+                    )
+                )
+            )
+        )
+        executeTest(docTag) {
+            node<ContentList> {
+                group {
+                        +"test1"
+                        +"test2"
+                }
+                group {
+                        +"test3"
+                        +"test4"
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `nested ordered list`() {
+        val docTag = 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(docTag) {
+            node<ContentList> {
+                group { +"Outer first Outer next line" }
+                group { +"Outer second" }
+                node<ContentList> {
+                    group { +"Middle first Middle next line" }
+                    group { +"Middle second" }
+                    node<ContentList> {
+                        +"Inner first Inner next line"
+                    }
+                    group { +"Middle third" }
+                }
+                group { +"Outer third" }
+            }
+            +"New paragraph"
+        }
+    }
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/transformers/ReportUndocumentedTransformerTest.kt b/plugins/base/src/test/kotlin/transformers/ReportUndocumentedTransformerTest.kt
new file mode 100644
index 00000000..72948372
--- /dev/null
+++ b/plugins/base/src/test/kotlin/transformers/ReportUndocumentedTransformerTest.kt
@@ -0,0 +1,919 @@
+package transformers
+
+import org.jetbrains.dokka.PackageOptionsImpl
+import org.jetbrains.dokka.Platform
+import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Disabled
+import org.junit.jupiter.api.Test
+
+
+class ReportUndocumentedTransformerTest : AbstractCoreTest() {
+    @Test
+    fun `undocumented class gets reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/kotlin/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt    
+            |package sample
+            |
+            |class X
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport(Regex("init"))
+                assertSingleUndocumentedReport(Regex("""sample/X/"""))
+            }
+        }
+    }
+
+    @Test
+    fun `undocumented non-public class does not get reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/kotlin/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt    
+            |package sample
+            |
+            |internal class X
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport()
+            }
+        }
+    }
+
+    @Test
+    fun `undocumented function gets reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/kotlin/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt    
+            |package sample
+            |
+            |/** Documented */
+            |class X {
+            |    fun x()
+            |}
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertSingleUndocumentedReport(Regex("X"))
+                assertSingleUndocumentedReport(Regex("X/x"))
+            }
+        }
+    }
+
+    @Test
+    fun `undocumented property gets reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/kotlin/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt    
+            |package sample
+            |
+            |/** Documented */
+            |class X {
+            |    val x: Int = 0
+            |}
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertSingleUndocumentedReport(Regex("X"))
+                assertSingleUndocumentedReport(Regex("X/x"))
+            }
+        }
+    }
+
+    @Test
+    fun `undocumented primary constructor does not get reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/kotlin/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt    
+            |package sample
+            |
+            |/** Documented */
+            |class X(private val x: Int) {
+            |}
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport()
+            }
+        }
+    }
+
+    @Test
+    fun `data class component functions do not get reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/kotlin")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt    
+            |package sample
+            |
+            |/** Documented */
+            |data class X(val x: Int) {
+            |}
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport(Regex("component"))
+                assertNumberOfUndocumentedReports(1)
+            }
+        }
+    }
+
+    @Disabled
+    @Test
+    fun `undocumented secondary constructor gets reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/kotlin/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt    
+            |package sample
+            |
+            |/** Documented */
+            |class X {
+            |   constructor(unit: Unit) : this()
+            |}
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertSingleUndocumentedReport(Regex("X"))
+                assertSingleUndocumentedReport(Regex("X.*init.*Unit"))
+            }
+        }
+    }
+
+    @Test
+    fun `undocumented inherited function does not get reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/kotlin/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt    
+            |package sample
+            |
+            |/** Documented */
+            |open class A {
+            |   fun a() = Unit
+            |}
+            |
+            |/** Documented */
+            |class B : A()
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport(Regex("B"))
+                assertSingleUndocumentedReport(Regex("A.*a"))
+            }
+        }
+    }
+
+    @Test
+    fun `undocumented inherited property does not get reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/kotlin/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt    
+            |package sample
+            |
+            |/** Documented */
+            |open class A {
+            |   val a = Unit
+            |}
+            |
+            |/** Documented */
+            |class B : A()
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport(Regex("B"))
+                assertSingleUndocumentedReport(Regex("A.*a"))
+            }
+        }
+    }
+
+    @Test
+    fun `overridden function does not get reported when super is documented`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/kotlin/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt
+            |package sample
+            |import kotlin.Exception
+            |
+            |/** Documented */
+            |open class A {
+            |   /** Documented */
+            |   fun a() = Unit
+            |}
+            |
+            |/** Documented */
+            |class B : A() {
+            |    override fun a() = throw Exception()
+            |}
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport()
+            }
+        }
+    }
+
+    @Test
+    fun `overridden property does not get reported when super is documented`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/kotlin/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt
+            |package sample
+            |import kotlin.Exception
+            |
+            |/** Documented */
+            |open class A {
+            |   /** Documented */
+            |   open val a = 0
+            |}
+            |
+            |/** Documented */
+            |class B : A() {
+            |    override val a = 1
+            |}
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport()
+            }
+        }
+    }
+
+    @Test
+    fun `report disabled by source set`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = false
+                    sourceRoots = listOf("src/main/kotlin/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt    
+            |package sample
+            |
+            |class X
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport()
+            }
+        }
+    }
+
+    @Test
+    fun `report enabled by package configuration`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    perPackageOptions += packageOptions(
+                        prefix = "sample",
+                        reportUndocumented = true,
+                    )
+                    reportUndocumented = false
+                    sourceRoots = listOf("src/main/kotlin/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt    
+            |package sample
+            |
+            |class X
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertSingleUndocumentedReport(Regex("X"))
+            }
+        }
+    }
+
+    @Test
+    fun `report enabled by more specific package configuration`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    perPackageOptions += packageOptions(
+                        prefix = "sample",
+                        reportUndocumented = false,
+                    )
+                    perPackageOptions += packageOptions(
+                        prefix = "sample.enabled",
+                        reportUndocumented = true,
+                    )
+                    reportUndocumented = false
+                    sourceRoots = listOf("src/main/kotlin/")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/sample/disabled/Disabled.kt
+            |package sample.disabled
+            |class Disabled
+            |
+            |/src/main/kotlin/sample/enabled/Enabled.kt    
+            |package sample.enabled
+            |class Enabled
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertSingleUndocumentedReport(Regex("Enabled"))
+                assertNumberOfUndocumentedReports(1)
+            }
+        }
+    }
+
+    @Test
+    fun `report disabled by more specific package configuration`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    perPackageOptions += packageOptions(
+                        prefix = "sample",
+                        reportUndocumented = true,
+                    )
+                    perPackageOptions += packageOptions(
+                        prefix = "sample.disabled",
+                        reportUndocumented = false,
+                    )
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/kotlin/")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/sample/disabled/Disabled.kt
+            |package sample.disabled
+            |class Disabled
+            |
+            |/src/main/kotlin/sample/enabled/Enabled.kt    
+            |package sample.enabled
+            |class Enabled
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertSingleUndocumentedReport(Regex("Enabled"))
+                assertNumberOfUndocumentedReports(1)
+            }
+        }
+    }
+
+    @Test
+    fun `multiplatform undocumented class gets reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                val commonMain = sourceSet {
+                    reportUndocumented = true
+                    analysisPlatform = Platform.common.toString()
+                    name = "commonMain"
+                    displayName = "commonMain"
+                    sourceRoots = listOf("src/commonMain/kotlin")
+                }
+
+                sourceSet {
+                    reportUndocumented = true
+                    analysisPlatform = Platform.jvm.toString()
+                    name = "jvmMain"
+                    displayName = "jvmMain"
+                    sourceRoots = listOf("src/jvmMain/kotlin")
+                    dependentSourceSets = setOf(commonMain.sourceSetID)
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/commonMain/kotlin/sample/Common.kt
+            |package sample
+            |expect class X
+            |
+            |/src/jvmMain/kotlin/sample/JvmMain.kt    
+            |package sample
+            |actual class X
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNumberOfUndocumentedReports(2, Regex("X"))
+                assertSingleUndocumentedReport(Regex("X.*jvmMain"))
+                assertSingleUndocumentedReport(Regex("X.*commonMain"))
+            }
+        }
+    }
+
+    @Test
+    fun `multiplatform undocumented class does not get reported if expect is documented`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                val commonMain = sourceSet {
+                    reportUndocumented = true
+                    analysisPlatform = Platform.common.toString()
+                    name = "commonMain"
+                    displayName = "commonMain"
+                    sourceRoots = listOf("src/commonMain/kotlin")
+                }
+
+                sourceSet {
+                    reportUndocumented = true
+                    analysisPlatform = Platform.jvm.toString()
+                    name = "jvmMain"
+                    displayName = "jvmMain"
+                    sourceRoots = listOf("src/jvmMain/kotlin")
+                    dependentSourceSets = setOf(commonMain.sourceSetID)
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/commonMain/kotlin/sample/Common.kt
+            |package sample
+            |/** Documented */
+            |expect class X
+            |
+            |/src/jvmMain/kotlin/sample/JvmMain.kt    
+            |package sample
+            |actual class X
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNumberOfUndocumentedReports(0)
+            }
+        }
+    }
+
+    @Test
+    fun `multiplatform undocumented function gets reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                val commonMain = sourceSet {
+                    reportUndocumented = true
+                    analysisPlatform = Platform.common.toString()
+                    name = "commonMain"
+                    displayName = "commonMain"
+                    sourceRoots = listOf("src/commonMain/kotlin")
+                }
+
+                sourceSet {
+                    reportUndocumented = true
+                    analysisPlatform = Platform.jvm.toString()
+                    name = "jvmMain"
+                    displayName = "jvmMain"
+                    sourceRoots = listOf("src/jvmMain/kotlin")
+                    dependentSourceSets = setOf(commonMain.sourceSetID)
+                }
+
+                sourceSet {
+                    reportUndocumented = true
+                    analysisPlatform = Platform.native.toString()
+                    name = "macosMain"
+                    displayName = "macosMain"
+                    sourceRoots = listOf("src/macosMain/kotlin")
+                    dependentSourceSets = setOf(commonMain.sourceSetID)
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/commonMain/kotlin/sample/Common.kt
+            |package sample
+            |expect fun x()
+            |
+            |/src/macosMain/kotlin/sample/MacosMain.kt    
+            |package sample
+            |/** Documented */
+            |actual fun x() = Unit
+            |
+            |/src/jvmMain/kotlin/sample/JvmMain.kt    
+            |package sample
+            |actual fun x() = Unit
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNumberOfUndocumentedReports(2)
+                assertSingleUndocumentedReport(Regex("x.*commonMain"))
+                assertSingleUndocumentedReport(Regex("x.*jvmMain"))
+            }
+        }
+    }
+
+    @Test
+    fun `java undocumented class gets reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/java")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/java/sample/Test.java    
+            |package sample
+            |public class Test { }
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport(Regex("init"))
+                assertSingleUndocumentedReport(Regex("""Test"""))
+                assertNumberOfUndocumentedReports(1)
+            }
+        }
+    }
+
+    @Test
+    fun `java undocumented non-public class does not get reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/java")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/java/sample/Test.java    
+            |package sample
+            |class Test { }
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport()
+            }
+        }
+    }
+
+    @Test
+    fun `java undocumented constructor does not get reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/java")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/java/sample/Test.java    
+            |package sample
+            |/** Documented */
+            |public class Test {
+            |   public Test() {
+            |   }
+            |}
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport()
+            }
+        }
+    }
+
+    @Test
+    fun `java undocumented method gets reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/java")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/java/sample/X.java    
+            |package sample
+            |/** Documented */
+            |public class X {
+            |   public void x { }
+            |}
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertSingleUndocumentedReport(Regex("X"))
+                assertSingleUndocumentedReport(Regex("X.*x"))
+                assertNumberOfUndocumentedReports(1)
+            }
+        }
+    }
+
+    @Test
+    fun `java undocumented property gets reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/java")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/java/sample/X.java    
+            |package sample
+            |/** Documented */
+            |public class X {
+            |   public int x = 0;
+            |}
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertSingleUndocumentedReport(Regex("X"))
+                assertSingleUndocumentedReport(Regex("X.*x"))
+                assertNumberOfUndocumentedReports(1)
+            }
+        }
+    }
+
+    @Test
+    fun `java undocumented inherited method gets reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/java")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/java/sample/Super.java    
+            |package sample
+            |/** Documented */
+            |public class Super {
+            |    public void x() {}
+            |}
+            |
+            |/src/main/java/sample/X.java
+            |package sample
+            |/** Documented */
+            |public class X extends Super {
+            |    public void x() {}
+            |}
+            |
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertSingleUndocumentedReport(Regex("X"))
+                assertSingleUndocumentedReport(Regex("X.*x"))
+                assertSingleUndocumentedReport(Regex("Super.*x"))
+                assertNumberOfUndocumentedReports(2)
+            }
+        }
+    }
+
+    @Test
+    fun `java documented inherited method does not get reported`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/java")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/java/sample/Super.java    
+            |package sample
+            |/** Documented */
+            |public class Super {
+            |    /** Documented */
+            |    public void x() {}
+            |}
+            |
+            |/src/main/java/sample/X.java
+            |package sample
+            |/** Documented */
+            |public class X extends Super {
+            |    
+            |}
+            |
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport()
+            }
+        }
+    }
+
+    @Test
+    fun `java overridden function does not get reported when super is documented`() {
+        val configuration = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    reportUndocumented = true
+                    sourceRoots = listOf("src/main/java")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/java/sample/Super.java    
+            |package sample
+            |/** Documented */
+            |public class Super {
+            |    /** Documented */
+            |    public void x() {}
+            |}
+            |
+            |/src/main/java/sample/X.java
+            |package sample
+            |/** Documented */
+            |public class X extends Super {
+            |    @Override
+            |    public void x() {}
+            |}
+            |
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = {
+                assertNoUndocumentedReport()
+            }
+        }
+    }
+
+    private fun assertNumberOfUndocumentedReports(expectedReports: Int, regex: Regex = Regex(".")) {
+        val reports = logger.warnMessages
+            .filter { it.startsWith("Undocumented:") }
+        val matchingReports = reports
+            .filter { it.contains(regex) }
+
+        assertEquals(
+            expectedReports, matchingReports.size,
+            "Expected $expectedReports report of documented code ($regex).\n" +
+                    "Found matching reports: $matchingReports\n" +
+                    "Found reports: $reports"
+        )
+    }
+
+    private fun assertSingleUndocumentedReport(regex: Regex) {
+        assertNumberOfUndocumentedReports(1, regex)
+    }
+
+    private fun assertNoUndocumentedReport(regex: Regex) {
+        assertNumberOfUndocumentedReports(0, regex)
+    }
+
+    private fun assertNoUndocumentedReport() {
+        assertNoUndocumentedReport(Regex("."))
+    }
+
+    private fun packageOptions(
+        prefix: String,
+        reportUndocumented: Boolean?,
+        includeNonPublic: Boolean = true,
+        skipDeprecated: Boolean = false,
+        suppress: Boolean = false
+    ) = PackageOptionsImpl(
+        prefix = prefix,
+        reportUndocumented = reportUndocumented,
+        includeNonPublic = includeNonPublic,
+        skipDeprecated = skipDeprecated,
+        suppress = suppress
+    )
+}