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, 0 insertions, 1297 deletions

diff --git a/plugins/gfm/src/test/kotlin/renderers/gfm/CodeWrappingTest.kt b/plugins/gfm/src/test/kotlin/renderers/gfm/CodeWrappingTest.kt
deleted file mode 100644
index 0d6a18cc..00000000
--- a/plugins/gfm/src/test/kotlin/renderers/gfm/CodeWrappingTest.kt
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * 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/plugins/gfm/src/test/kotlin/renderers/gfm/DivergentTest.kt b/plugins/gfm/src/test/kotlin/renderers/gfm/DivergentTest.kt
deleted file mode 100644
index 8d90fac2..00000000
--- a/plugins/gfm/src/test/kotlin/renderers/gfm/DivergentTest.kt
+++ /dev/null
@@ -1,505 +0,0 @@
-/*
- * 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/plugins/gfm/src/test/kotlin/renderers/gfm/GfmRenderingOnlyTestBase.kt b/plugins/gfm/src/test/kotlin/renderers/gfm/GfmRenderingOnlyTestBase.kt
deleted file mode 100644
index 9080a4fd..00000000
--- a/plugins/gfm/src/test/kotlin/renderers/gfm/GfmRenderingOnlyTestBase.kt
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * 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/plugins/gfm/src/test/kotlin/renderers/gfm/GroupWrappingTest.kt b/plugins/gfm/src/test/kotlin/renderers/gfm/GroupWrappingTest.kt
deleted file mode 100644
index 13cb16c4..00000000
--- a/plugins/gfm/src/test/kotlin/renderers/gfm/GroupWrappingTest.kt
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * 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/plugins/gfm/src/test/kotlin/renderers/gfm/SimpleElementsTest.kt b/plugins/gfm/src/test/kotlin/renderers/gfm/SimpleElementsTest.kt
deleted file mode 100644
index 720a0af5..00000000
--- a/plugins/gfm/src/test/kotlin/renderers/gfm/SimpleElementsTest.kt
+++ /dev/null
@@ -1,393 +0,0 @@
-/*
- * 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/plugins/gfm/src/test/kotlin/renderers/gfm/SourceSetDependentHintTest.kt b/plugins/gfm/src/test/kotlin/renderers/gfm/SourceSetDependentHintTest.kt
deleted file mode 100644
index 3f0129af..00000000
--- a/plugins/gfm/src/test/kotlin/renderers/gfm/SourceSetDependentHintTest.kt
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
- * 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)
-    }
-}