Restructure the project to utilize included builds (#3174)

* Refactor and simplify artifact publishing
* Update Gradle to 8.4
* Refactor and simplify convention plugins and build scripts

Fixes #3132

---------

Co-authored-by: Adam <897017+aSemy@users.noreply.github.com>
Co-authored-by: Oleg Yukhnevich <whyoleg@gmail.com>

6 files changed, 1297 insertions, 0 deletions

diff --git a/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/CodeWrappingTest.kt b/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/CodeWrappingTest.kt
new file mode 100644
index 00000000..0d6a18cc
--- /dev/null
+++ b/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/CodeWrappingTest.kt
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.gfm
+
+import org.jetbrains.dokka.gfm.renderer.CommonmarkRenderer
+import renderers.testPage
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class CodeWrappingTest : GfmRenderingOnlyTestBase() {
+    @Test
+    fun wrappedCodeBlock() {
+        val page = testPage {
+            codeBlock {
+                text("fun myCode(): String")
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |```kotlin
+                        |fun myCode(): String
+                        |```""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun `should preserve original text without escaping`() {
+        val page = testPage {
+            codeBlock {
+                text("<----> **text** & ~~this~~  and \"that\"")
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |```kotlin
+                        |<----> **text** & ~~this~~  and "that"
+                        |```""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+
+    @Test
+    fun wrappedInlineCode() {
+        val page = testPage {
+            text("This function adds the values of ")
+            codeInline {
+                text("left") 
+            }
+            text(" and ")
+            codeInline {
+                text("right")
+            }
+            text(".\nBoth numbers must be finite, or an exception occurs.\n")
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |This function adds the values of `left` and `right`.
+                        |Both numbers must be finite, or an exception occurs.""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun `should not add trailing backslash to newline elements for code inline code`() {
+        val page = testPage {
+            text("This adds some symbols (")
+            codeInline {
+                text("<----> **text** & ~~this~~  and \"that\"")
+            }
+            text(") to the test")
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |This adds some symbols (`<----> **text** & ~~this~~  and "that"`) to the test""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+}
diff --git a/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/DivergentTest.kt b/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/DivergentTest.kt
new file mode 100644
index 00000000..8d90fac2
--- /dev/null
+++ b/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/DivergentTest.kt
@@ -0,0 +1,505 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.gfm
+
+import org.jetbrains.dokka.DokkaSourceSetID
+import org.jetbrains.dokka.Platform
+import org.jetbrains.dokka.gfm.renderer.CommonmarkRenderer
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.pages.ContentDivergentGroup
+import renderers.testPage
+import testApi.testRunner.defaultSourceSet
+import java.io.File
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class DivergentTest : GfmRenderingOnlyTestBase() {
+    private val js = defaultSourceSet.copy(
+        "js",
+        DokkaSourceSetID("root", "js"),
+        analysisPlatform = Platform.js,
+        sourceRoots = setOf(File("pl1"))
+    )
+    private val jvm = defaultSourceSet.copy(
+        "jvm",
+        DokkaSourceSetID("root", "jvm"),
+        analysisPlatform = Platform.jvm,
+        sourceRoots = setOf(File("pl1"))
+    )
+    private val native = defaultSourceSet.copy(
+        "native",
+        DokkaSourceSetID("root", "native"),
+        analysisPlatform = Platform.native,
+        sourceRoots = setOf(File("pl1"))
+    )
+
+    @Test
+    fun simpleWrappingCase() {
+        val page = testPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("a")
+                    }
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[js]\
+                        |a""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun noPlatformHintCase() {
+        val page = testPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test"), implicitlySourceSetHinted = false) {
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("a")
+                    }
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[js]\
+                        |a""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun divergentBetweenSourceSets() {
+        val page = testPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("a")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(jvm)) {
+                    divergent {
+                        text("b")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    divergent {
+                        text("c")
+                    }
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[js, jvm, native]\
+                        |[js]\
+                        |a
+                        |
+                        |[jvm]\
+                        |b
+                        |
+                        |[native]\
+                        |c""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun divergentInOneSourceSet() {
+        val page = testPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("a")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(js)) {
+                    divergent {
+                        text("b")
+                    }
+                }
+                instance(setOf(DRI("test", "Test3")), setOf(js)) {
+                    divergent {
+                        text("c")
+                    }
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[js]\
+                        |a
+                        |
+                        |b
+                        |
+                        |c""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun divergentInAndBetweenSourceSets() {
+        val page = testPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    divergent {
+                        text("a")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("b")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(jvm)) {
+                    divergent {
+                        text("c")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(js)) {
+                    divergent {
+                        text("d")
+                    }
+                }
+                instance(setOf(DRI("test", "Test3")), setOf(native)) {
+                    divergent {
+                        text("e")
+                    }
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[native, js, jvm]\
+                        |[native]\
+                        |a
+                        |
+                        |[js]\
+                        |b
+                        |
+                        |[jvm]\
+                        |c
+                        |
+                        |[js]\
+                        |d
+                        |
+                        |[native]\
+                        |e""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun divergentInAndBetweenSourceSetsWithGrouping() {
+        val page = testPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    divergent {
+                        text("a")
+                    }
+                    after {
+                        text("a+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("b")
+                    }
+                    after {
+                        text("bd+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(jvm)) {
+                    divergent {
+                        text("c")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(js)) {
+                    divergent {
+                        text("d")
+                    }
+                    after {
+                        text("bd+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test3")), setOf(native)) {
+                    divergent {
+                        text("e")
+                    }
+                    after {
+                        text("e+")
+                    }
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[native]\
+                        |a
+                        |
+                        |a+
+                        |
+                        |[js]\
+                        |b
+                        |
+                        |d
+                        |
+                        |bd+
+                        |
+                        |[jvm]\
+                        |c
+                        |
+                        |[native]\
+                        |e
+                        |
+                        |e+""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun divergentSameBefore() {
+        val page = testPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    before {
+                        text("ab-")
+                    }
+                    divergent {
+                        text("a")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(native)) {
+                    before {
+                        text("ab-")
+                    }
+                    divergent {
+                        text("b")
+                    }
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[native]\
+                        |ab-
+                        |
+                        |a
+                        |
+                        |b""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun divergentSameAfter() {
+        val page = testPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    divergent {
+                        text("a")
+                    }
+                    after {
+                        text("ab+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(native)) {
+                    divergent {
+                        text("b")
+                    }
+                    after {
+                        text("ab+")
+                    }
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[native]\
+                        |a
+                        |
+                        |b
+                        |
+                        |ab+""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun divergentGroupedByBeforeAndAfter() {
+        val page = testPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    before {
+                        text("ab-")
+                    }
+                    divergent {
+                        text("a")
+                    }
+                    after {
+                        text("ab+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(native)) {
+                    before {
+                        text("ab-")
+                    }
+                    divergent {
+                        text("b")
+                    }
+                    after {
+                        text("ab+")
+                    }
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[native]\
+                        |ab-
+                        |
+                        |a
+                        |
+                        |b
+                        |
+                        |ab+""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun divergentDifferentBeforeAndAfter() {
+        val page = testPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    before {
+                        text("a-")
+                    }
+                    divergent {
+                        text("a")
+                    }
+                    after {
+                        text("ab+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(native)) {
+                    before {
+                        text("b-")
+                    }
+                    divergent {
+                        text("b")
+                    }
+                    after {
+                        text("ab+")
+                    }
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[native]\
+                        |a-
+                        |
+                        |a
+                        |
+                        |ab+
+                        |
+                        |[native]\
+                        |b-
+                        |
+                        |b
+                        |
+                        |ab+""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun divergentInAndBetweenSourceSetsWithGroupingAncCommonParts() {
+        val page = testPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    divergent {
+                        text("a")
+                    }
+                    after {
+                        text("a+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("b")
+                    }
+                    after {
+                        text("bd+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(jvm)) {
+                    divergent {
+                        text("c")
+                    }
+                    after {
+                        text("bd+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(js)) {
+                    divergent {
+                        text("d")
+                    }
+                    after {
+                        text("bd+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test3")), setOf(native)) {
+                    divergent {
+                        text("e")
+                    }
+                    after {
+                        text("e+")
+                    }
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[native]\
+                        |a
+                        |
+                        |a+
+                        |
+                        |[js, jvm]\
+                        |[js]\
+                        |b
+                        |
+                        |[jvm]\
+                        |c
+                        |
+                        |[js]\
+                        |d
+                        |
+                        |bd+
+                        |
+                        |[native]\
+                        |e
+                        |
+                        |e+""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+}
diff --git a/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/GfmRenderingOnlyTestBase.kt b/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/GfmRenderingOnlyTestBase.kt
new file mode 100644
index 00000000..9080a4fd
--- /dev/null
+++ b/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/GfmRenderingOnlyTestBase.kt
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.gfm
+
+import org.jetbrains.dokka.DokkaConfigurationImpl
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.base.renderers.RootCreator
+import org.jetbrains.dokka.base.resolvers.external.DefaultExternalLocationProviderFactory
+import org.jetbrains.dokka.base.resolvers.external.javadoc.JavadocExternalLocationProviderFactory
+import org.jetbrains.dokka.gfm.GfmPlugin
+import org.jetbrains.dokka.gfm.location.MarkdownLocationProvider
+import org.jetbrains.dokka.testApi.context.MockContext
+import renderers.RenderingOnlyTestBase
+import utils.TestOutputWriter
+
+abstract class GfmRenderingOnlyTestBase : RenderingOnlyTestBase<String>() {
+
+    val files = TestOutputWriter()
+    override val context = MockContext(
+        DokkaBase().outputWriter to { files },
+        DokkaBase().locationProviderFactory to MarkdownLocationProvider::Factory,
+        DokkaBase().externalLocationProviderFactory to ::JavadocExternalLocationProviderFactory,
+        DokkaBase().externalLocationProviderFactory to ::DefaultExternalLocationProviderFactory,
+        GfmPlugin().gfmPreprocessors to { RootCreator },
+
+        testConfiguration = DokkaConfigurationImpl(moduleName = "root", finalizeCoroutines = false)
+    )
+
+    override val renderedContent: String by lazy {
+        files.contents.getValue("test-page.md")
+    }
+}
diff --git a/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/GroupWrappingTest.kt b/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/GroupWrappingTest.kt
new file mode 100644
index 00000000..13cb16c4
--- /dev/null
+++ b/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/GroupWrappingTest.kt
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.gfm
+
+import org.jetbrains.dokka.gfm.renderer.CommonmarkRenderer
+import org.jetbrains.dokka.pages.TextStyle
+import renderers.testPage
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class GroupWrappingTest : GfmRenderingOnlyTestBase() {
+
+    @Test
+    fun notWrapped() {
+        val page = testPage {
+            group {
+                text("a")
+                text("b")
+            }
+            text("c")
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |abc""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun paragraphWrapped() {
+        val page = testPage {
+            group(styles = setOf(TextStyle.Paragraph)) {
+                text("a")
+                text("b")
+            }
+            text("c")
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |ab
+                        |
+                        |c""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun blockWrapped() {
+        val page = testPage {
+            group(styles = setOf(TextStyle.Block)) {
+                text("a")
+                text("b")
+            }
+            text("c")
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |ab
+                        |
+                        |c""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun nested() {
+        val page = testPage {
+            group(styles = setOf(TextStyle.Block)) {
+                text("a")
+                group(styles = setOf(TextStyle.Block)) {
+                    group(styles = setOf(TextStyle.Block)) {
+                        text("b")
+                        text("c")
+                    }
+                }
+                text("d")
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |a
+                        |
+                        |bc
+                        |
+                        |d""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+}
diff --git a/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/SimpleElementsTest.kt b/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/SimpleElementsTest.kt
new file mode 100644
index 00000000..720a0af5
--- /dev/null
+++ b/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/SimpleElementsTest.kt
@@ -0,0 +1,393 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.gfm
+
+import org.jetbrains.dokka.gfm.renderer.CommonmarkRenderer
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.pages.ContentEmbeddedResource
+import org.jetbrains.dokka.pages.ContentKind
+import org.jetbrains.dokka.pages.DCI
+import org.jetbrains.dokka.pages.TextStyle
+import renderers.RawTestPage
+import renderers.testPage
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class SimpleElementsTest : GfmRenderingOnlyTestBase() {
+
+    @Test
+    fun header() {
+        val page = testPage {
+            header(1, "The Hobbit or There and Back Again")
+        }
+        val expect = "//[testPage](test-page.md)\n\n# The Hobbit or There and Back Again"
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun link() {
+        val page = testPage {
+            link("They are not all accounted for, the lost Seeing Stones.", "http://www.google.com")
+        }
+        val expect =
+            "//[testPage](test-page.md)\n\n[They are not all accounted for, the lost Seeing Stones.](http://www.google.com)"
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun bold() {
+        val page = testPage {
+            text(
+                "That there’s some good in this world, Mr. Frodo… and it’s worth fighting for.",
+                styles = setOf(TextStyle.Bold)
+            )
+        }
+        val expect =
+            "//[testPage](test-page.md)\n\n**That there’s some good in this world, Mr. Frodo… and it’s worth fighting for.**"
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun italic() {
+        val page = testPage {
+            text("Even the smallest person can change the course of the future.", styles = setOf(TextStyle.Italic))
+        }
+        val expect = "//[testPage](test-page.md)\n\n*Even the smallest person can change the course of the future.*"
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun italicAndBold() {
+        val page = testPage {
+            text(
+                "There is no curse in Elvish, Entish, or the tongues of Men for this treachery.",
+                styles = setOf(TextStyle.Bold, TextStyle.Italic)
+            )
+        }
+        val expect =
+            "//[testPage](test-page.md)\n\n***There is no curse in Elvish, Entish, or the tongues of Men for this treachery.***"
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun strikethrough() {
+        val page = testPage {
+            text(
+                "A day may come when the courage of men fails… but it is not THIS day",
+                styles = setOf(TextStyle.Strikethrough)
+            )
+        }
+        val expect =
+            "//[testPage](test-page.md)\n\n~~A day may come when the courage of men fails… but it is not THIS day~~"
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun images() {
+        val image = ContentEmbeddedResource(
+            children = emptyList(),
+            address = "https://www.google.pl/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png",
+            altText = "This is a google logo",
+            dci = DCI(setOf(DRI.topLevel), ContentKind.Main),
+            sourceSets = emptySet()
+        )
+        val page = RawTestPage(content = image)
+        val expect =
+            "//[testPage](test-page.md)\n\n![This is a google logo](https://www.google.pl/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png)"
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun simpleTableWithHeader() {
+        val page = testPage {
+            table {
+                header {
+                    text("Col1")
+                    text("Col2")
+                    text("Col3")
+                }
+                row {
+                    text("Text1")
+                    text("Text2")
+                    text("Text3")
+                }
+                row {
+                    text("Text4")
+                    text("Text5")
+                    text("Text6")
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        || Col1 | Col2 | Col3 |
+                        ||---|---|---|
+                        || Text1 | Text2 | Text3 |
+                        || Text4 | Text5 | Text6 |""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun simpleTableWithoutHeader() {
+        val page = testPage {
+            table {
+                row {
+                    text("Text1")
+                    text("Text2")
+                    text("Text3")
+                }
+                row {
+                    text("Text4")
+                    text("Text5")
+                    text("Text6")
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        || | | |
+                        ||---|---|---|
+                        || Text1 | Text2 | Text3 |
+                        || Text4 | Text5 | Text6 |""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun `table with extra cell in row`() {
+        val page = testPage {
+            table {
+                header {
+                    text("Col1")
+                }
+                row {
+                    text("Text1")
+                    text("Text2")
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        || Col1 |
+                        ||---|
+                        || Text1 | Text2 |""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun `table with extra cell in header`() {
+        val page = testPage {
+            table {
+                header {
+                    text("Col1")
+                    text("Col2")
+                }
+                row {
+                    text("Text1")
+                }
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        || Col1 | Col2 |
+                        ||---|---|
+                        || Text1 |""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun escapeText() {
+        val page = testPage {
+            text(
+                "<b>a</b>",
+            )
+        }
+        val expect =
+            "//[testPage](test-page.md)\n\n&lt;b&gt;a&lt;/b&gt;"
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun `unordered list with two items`() {
+        val page = testPage {
+            unorderedList {
+                item { text("Item 1") }
+                item { text("Item 2") }
+            }
+        }
+
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |- Item 1
+                        |- Item 2""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun `unordered list with styled text`() {
+        val page = testPage {
+            unorderedList {
+                item {
+                    text("Nobody", styles = setOf(TextStyle.Italic))
+                    text(" tosses a Dwarf!")
+                }
+            }
+        }
+
+        val expect = "//[testPage](test-page.md)\n\n- *Nobody* tosses a Dwarf!"
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun `ordered list with two items`() {
+        val page = testPage {
+            orderedList {
+                item { text("Item 1") }
+                item { text("Item 2") }
+            }
+        }
+
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |1. Item 1
+                        |2. Item 2""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun `ordered list with nested unordered list`() {
+        val page = testPage {
+            orderedList {
+                item {
+                    text("And another list:")
+                    unorderedList {
+                        item { text("Item 1") }
+                        item { text("Item 2") }
+                    }
+                }
+                item { text("Following item") }
+            }
+        }
+
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |1. And another list:
+                        |   
+                        |   - Item 1
+                        |   - Item 2
+                        |2. Following item""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun `ordered list with nested table`() {
+        val page = testPage {
+            orderedList {
+                item {
+                    text("The following table is nested in a list:")
+                    table {
+                        header {
+                            text("Col1")
+                            text("Col2")
+                        }
+                        row {
+                            text("Text1")
+                            text("Text2")
+                        }
+                    }
+                }
+            }
+        }
+
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |1. The following table is nested in a list:
+                        |   | Col1 | Col2 |
+                        |   |---|---|
+                        |   | Text1 | Text2 |""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun `three levels of list`() {
+        val page = testPage {
+            unorderedList {
+                item {
+                    text("Level 1")
+                    unorderedList {
+                        item {
+                            text("Level 2")
+                            unorderedList {
+                                item {
+                                    text("Level 3")
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // Extra newlines are not pretty but do not impact formatting
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |- Level 1
+                        |   
+                        |   - Level 2
+                        |      
+                        |      - Level 3""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun `nested list with no text preceding it`() {
+        val page = testPage {
+            unorderedList {
+                item {
+                    unorderedList {
+                        item {
+                            text("Nested")
+                        }
+                    }
+                }
+            }
+        }
+
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |- 
+                        |   - Nested""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+}
diff --git a/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/SourceSetDependentHintTest.kt b/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/SourceSetDependentHintTest.kt
new file mode 100644
index 00000000..3f0129af
--- /dev/null
+++ b/dokka-subprojects/plugin-gfm/src/test/kotlin/renderers/gfm/SourceSetDependentHintTest.kt
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.gfm
+
+import org.jetbrains.dokka.DokkaSourceSetID
+import org.jetbrains.dokka.Platform
+import org.jetbrains.dokka.gfm.renderer.CommonmarkRenderer
+import org.jetbrains.dokka.pages.TextStyle
+import renderers.testPage
+import testApi.testRunner.defaultSourceSet
+import java.io.File
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class SourceSetDependentHintTest : GfmRenderingOnlyTestBase() {
+
+    private val pl1 = defaultSourceSet.copy(
+        "pl1",
+        DokkaSourceSetID("root", "pl1"),
+        analysisPlatform = Platform.js,
+        sourceRoots = setOf(File("pl1"))
+    )
+    private val pl2 = defaultSourceSet.copy(
+        "pl2",
+        DokkaSourceSetID("root", "pl2"),
+        analysisPlatform = Platform.jvm,
+        sourceRoots = setOf(File("pl1"))
+    )
+    private val pl3 = defaultSourceSet.copy(
+        "pl3",
+        DokkaSourceSetID("root", "pl3"),
+        analysisPlatform = Platform.native,
+        sourceRoots = setOf(File("pl1"))
+    )
+
+    @Test
+    fun platformIndependentCase() {
+        val page = testPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
+                text("a")
+                text("b")
+                text("c")
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[pl1, pl2, pl3]\
+                        |abc""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun completelyDivergentCase() {
+        val page = testPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1))
+                text("b", sourceSets = setOf(pl2))
+                text("c", sourceSets = setOf(pl3))
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[pl1]\
+                        |a
+                        |
+                        |[pl2]\
+                        |b
+                        |
+                        |[pl3]\
+                        |c""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun overlappingCase() {
+        val page = testPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1))
+                text("b", sourceSets = setOf(pl1, pl2))
+                text("c", sourceSets = setOf(pl2))
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[pl1]\
+                        |ab
+                        |
+                        |[pl2]\
+                        |bc""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun caseThatCanBeSimplified() {
+        val page = testPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1, pl2))
+                text("b", sourceSets = setOf(pl1))
+                text("b", sourceSets = setOf(pl2))
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[pl1, pl2]\
+                        |ab""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun caseWithGroupBreakingSimplification() {
+        val page = testPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
+                group(styles = setOf(TextStyle.Block)) {
+                    text("a", sourceSets = setOf(pl1, pl2))
+                    text("b", sourceSets = setOf(pl1))
+                }
+                text("b", sourceSets = setOf(pl2))
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[pl1]\
+                        |ab
+                        |
+                        |[pl2]\
+                        |a
+                        |
+                        |b""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun caseWithGroupNotBreakingSimplification() {
+        val page = testPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2)) {
+                group {
+                    text("a", sourceSets = setOf(pl1, pl2))
+                    text("b", sourceSets = setOf(pl1))
+                }
+                text("b", sourceSets = setOf(pl2))
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[pl1, pl2]\
+                        |ab""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+
+    @Test
+    fun partiallyUnifiedCase() {
+        val page = testPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1))
+                text("a", sourceSets = setOf(pl2))
+                text("b", sourceSets = setOf(pl3))
+            }
+        }
+        val expect = """|//[testPage](test-page.md)
+                        |
+                        |[pl1, pl2]\
+                        |a
+                        |
+                        |[pl3]\
+                        |b""".trimMargin()
+
+        CommonmarkRenderer(context).render(page)
+        assertEquals(expect, renderedContent)
+    }
+}