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>

16 files changed, 0 insertions, 3768 deletions

diff --git a/plugins/base/src/test/kotlin/transformers/AbstractContextModuleAndPackageDocumentationReaderTest.kt b/plugins/base/src/test/kotlin/transformers/AbstractContextModuleAndPackageDocumentationReaderTest.kt
deleted file mode 100644
index 8ce9360f..00000000
--- a/plugins/base/src/test/kotlin/transformers/AbstractContextModuleAndPackageDocumentationReaderTest.kt
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package transformers
-
-import org.jetbrains.dokka.model.SourceSetDependent
-import org.jetbrains.dokka.model.doc.DocumentationNode
-import org.jetbrains.dokka.model.doc.Text
-import org.jetbrains.dokka.model.withDescendants
-import org.junit.jupiter.api.io.TempDir
-import java.nio.file.Path
-
-abstract class AbstractContextModuleAndPackageDocumentationReaderTest {
-    @TempDir
-    protected lateinit var temporaryDirectory: Path
-
-
-    companion object {
-        val SourceSetDependent<DocumentationNode>.texts: List<String>
-            get() = values.flatMap { it.withDescendants() }
-                .flatMap { it.children }
-                .flatMap { it.children }
-                .mapNotNull { it as? Text }
-                .map { it.body }
-    }
-}
diff --git a/plugins/base/src/test/kotlin/transformers/CommentsToContentConverterTest.kt b/plugins/base/src/test/kotlin/transformers/CommentsToContentConverterTest.kt
deleted file mode 100644
index 1387c0e0..00000000
--- a/plugins/base/src/test/kotlin/transformers/CommentsToContentConverterTest.kt
+++ /dev/null
@@ -1,484 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package transformers
-
-import matchers.content.*
-import org.jetbrains.dokka.base.transformers.pages.comments.DocTagToContentConverter
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.doc.*
-import org.jetbrains.dokka.pages.*
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertTrue
-
-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) {
-            group { +"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) {
-            group {
-                +"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) {
-            group {
-                group { +"Paragraph number one" }
-                group {
-                    +"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) {
-            group {
-                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" }
-                }
-                group { +"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) {
-            group {
-                header(1) { +"Header 1" }
-                group { +"Following text" }
-                group { +"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) {
-            group {
-                header(1) { +"Header 1" }
-                group { +"Text 1" }
-                header(2) { +"Header 2" }
-                group { +"Text 2" }
-                header(3) { +"Header 3" }
-                group { +"Text 3" }
-                header(4) { +"Header 4" }
-                group { +"Text 4" }
-                header(5) { +"Header 5" }
-                group { +"Text 5" }
-                header(6) { +"Header 6" }
-                group { +"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) {
-            group {
-                group {
-                    group {
-                        +"Blockquotes are very handy in email to emulate reply text. This line is part of the same quote."
-                    }
-                }
-                group { +"Quote break." }
-                group {
-                    group {
-                        +"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) {
-            group {
-                group {
-                    group { +"text 1 text 2" }
-                    group {
-                        group { +"text 3 text 4" }
-                    }
-                    group { +"text 5" }
-                }
-                group { +"Quote break." }
-                group {
-                    group { +"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) {
-            group {
-                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>()
-                    +"}"
-                }
-                group { +"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) {
-            group {
-                link {
-                    +"I'm an inline-style link"
-                    check {
-                        assertEquals(
-                            (this as? ContentResolvedLink)?.address ?: error("Link should be resolved"),
-                            "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) {
-            group {
-                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" }
-                }
-                group {
-                    +"New paragraph"
-                }
-            }
-        }
-    }
-
-    @Test
-    fun `description list`() {
-        val docTag =
-            Dl(
-                listOf(
-                    Dt(
-                        listOf(
-                            Text("description list can have...")
-                        )
-                    ),
-                    Dt(
-                        listOf(
-                            Text("... two consecutive description terms")
-                        )
-                    ),
-                    Dd(
-                        listOf(
-                            Text("and usually has some sort of a description, like this one")
-                        )
-                    )
-                )
-            )
-
-        executeTest(docTag) {
-            composite<ContentList> {
-                check {
-                    assertTrue(style.contains(ListStyle.DescriptionList), "Expected DL style")
-                }
-                group {
-                    check {
-                        assertTrue(style.contains(ListStyle.DescriptionTerm), "Expected DT style")
-                    }
-                    +"description list can have..."
-                }
-                group {
-                    check {
-                        assertTrue(style.contains(ListStyle.DescriptionTerm), "Expected DT style")
-                    }
-                    +"... two consecutive description terms"
-                }
-                group {
-                    check {
-                        assertTrue(style.contains(ListStyle.DescriptionDetails), "Expected DD style")
-                    }
-                    +"and usually has some sort of a description, like this one"
-                }
-            }
-        }
-    }
-}
diff --git a/plugins/base/src/test/kotlin/transformers/ContextModuleAndPackageDocumentationReaderTest1.kt b/plugins/base/src/test/kotlin/transformers/ContextModuleAndPackageDocumentationReaderTest1.kt
deleted file mode 100644
index dfb3eff1..00000000
--- a/plugins/base/src/test/kotlin/transformers/ContextModuleAndPackageDocumentationReaderTest1.kt
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package transformers
-
-import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
-import org.jetbrains.dokka.analysis.kotlin.internal.InternalKotlinAnalysisPlugin
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.doc.DocumentationNode
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.plugin
-import org.jetbrains.dokka.plugability.querySingle
-import org.jetbrains.dokka.testApi.logger.TestLogger
-import org.jetbrains.dokka.utilities.DokkaConsoleLogger
-import org.jetbrains.dokka.utilities.LoggingLevel
-import testApi.testRunner.TestDokkaConfigurationBuilder
-import testApi.testRunner.dModule
-import testApi.testRunner.dPackage
-import kotlin.test.BeforeTest
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
-
-class ContextModuleAndPackageDocumentationReaderTest1 : AbstractContextModuleAndPackageDocumentationReaderTest() {
-
-
-    private val includeSourceSetA by lazy { temporaryDirectory.resolve("includeA.md").toFile() }
-    private val includeSourceSetB by lazy { temporaryDirectory.resolve("includeB.md").toFile() }
-
-    @BeforeTest
-    fun materializeIncludes() {
-        includeSourceSetA.writeText(
-            """
-            # Module moduleA
-            This is moduleA
-            
-            # Package sample.a
-            This is package sample.a\r\n
-            
-            # Package noise.b
-            This will just add some noise
-            """.trimIndent().replace("\n", "\r\n")
-        )
-
-        includeSourceSetB.writeText(
-            """
-            # Module moduleB
-            This is moduleB
-            
-            # Package sample.b
-            This is package sample.b
-            
-            # Package noise.b
-            This will just add some more noise
-            """.trimIndent()
-        )
-    }
-
-    private val configurationBuilder = TestDokkaConfigurationBuilder().apply {
-        moduleName = "moduleA"
-    }
-
-    private val sourceSetA by configurationBuilder.sourceSet {
-        name = "sourceSetA"
-        includes = listOf(includeSourceSetA.canonicalPath)
-    }
-
-
-    private val sourceSetB by configurationBuilder.sourceSet {
-        name = "sourceSetB"
-        includes = listOf(includeSourceSetB.canonicalPath)
-    }
-
-
-    private val sourceSetB2 by configurationBuilder.sourceSet {
-        name = "sourceSetB2"
-        includes = emptyList()
-    }
-
-
-    private val context by lazy {
-        DokkaContext.create(
-            configuration = configurationBuilder.build(),
-            logger = TestLogger(DokkaConsoleLogger(LoggingLevel.DEBUG)),
-            pluginOverrides = emptyList()
-        )
-    }
-
-    private val reader by lazy { context.plugin<InternalKotlinAnalysisPlugin>().querySingle { moduleAndPackageDocumentationReader } }
-
-    @Test
-    fun `assert moduleA with sourceSetA`() {
-        val documentation = reader.read(dModule(name = "moduleA", sourceSets = setOf(sourceSetA)))
-        assertEquals(
-            1, documentation.keys.size,
-            "Expected moduleA only containing documentation in a single source set"
-        )
-        assertEquals(
-            "sourceSetA", documentation.keys.single().sourceSetID.sourceSetName,
-            "Expected moduleA documentation coming from sourceSetA"
-        )
-
-        assertEquals(
-            "This is moduleA", documentation.texts.single(),
-            "Expected moduleA documentation being present"
-        )
-    }
-
-    @Test
-    fun `assert moduleA with no source sets`() {
-        val documentation = reader.read(dModule("moduleA"))
-        assertEquals(
-            emptyMap(), documentation,
-            "Expected no documentation received for module not declaring a matching sourceSet"
-        )
-    }
-
-    @Test
-    fun `assert moduleA with unknown source set`() {
-        assertFailsWith<IllegalStateException>(
-            "Expected no documentation received for module with unknown sourceSet"
-        ) {
-            reader.read(
-                    dModule("moduleA", sourceSets = setOf(configurationBuilder.unattachedSourceSet { name = "unknown" }))
-            )
-        }
-    }
-
-    @Test
-    fun `assert moduleA with all sourceSets`() {
-        val documentation = reader.read(dModule("moduleA", sourceSets = setOf(sourceSetA, sourceSetB, sourceSetB2)))
-        assertEquals(1, documentation.entries.size, "Expected only one entry from sourceSetA")
-        assertEquals(sourceSetA, documentation.keys.single(), "Expected only one entry from sourceSetA")
-        assertEquals("This is moduleA", documentation.texts.single())
-    }
-
-    @Test
-    fun `assert moduleB with sourceSetB and sourceSetB2`() {
-        val documentation = reader.read(dModule("moduleB", sourceSets = setOf(sourceSetB, sourceSetB2)))
-        assertEquals(1, documentation.keys.size, "Expected only one entry from sourceSetB")
-        assertEquals(sourceSetB, documentation.keys.single(), "Expected only one entry from sourceSetB")
-        assertEquals("This is moduleB", documentation.texts.single())
-    }
-
-    @Test
-    fun `assert sample_A in sourceSetA`() {
-        val documentation = reader.read(dPackage(DRI("sample.a"), sourceSets = setOf(sourceSetA)))
-        assertEquals(1, documentation.keys.size, "Expected only one entry from sourceSetA")
-        assertEquals(sourceSetA, documentation.keys.single(), "Expected only one entry from sourceSetA")
-        assertEquals("This is package sample.a\\r\\n", documentation.texts.single())
-    }
-
-    @Test
-    fun `assert sample_a_sub in sourceSetA`() {
-        val documentation = reader.read(dPackage(DRI("sample.a.sub"), sourceSets = setOf(sourceSetA)))
-        assertEquals(
-            emptyMap<DokkaSourceSet, DocumentationNode>(), documentation,
-            "Expected no documentation found for different package"
-        )
-    }
-
-    @Test
-    fun `assert sample_a in sourceSetB`() {
-        val documentation = reader.read(dPackage(DRI("sample.a"), sourceSets = setOf(sourceSetB)))
-        assertEquals(
-            emptyMap<DokkaSourceSet, DocumentationNode>(), documentation,
-            "Expected no documentation found for different sourceSet"
-        )
-    }
-
-    @Test
-    fun `assert sample_b in sourceSetB`() {
-        val documentation = reader.read(dPackage(DRI("sample.b"), sourceSets = setOf(sourceSetB)))
-        assertEquals(1, documentation.keys.size, "Expected only one entry from sourceSetB")
-        assertEquals(sourceSetB, documentation.keys.single(), "Expected only one entry from sourceSetB")
-        assertEquals("This is package sample.b", documentation.texts.single())
-    }
-
-    @Test
-    fun `assert sample_b in sourceSetB and sourceSetB2`() {
-        val documentation = reader.read(dPackage(DRI("sample.b"), sourceSets = setOf(sourceSetB, sourceSetB2)))
-        assertEquals(1, documentation.keys.size, "Expected only one entry from sourceSetB")
-        assertEquals(sourceSetB, documentation.keys.single(), "Expected only one entry from sourceSetB")
-        assertEquals("This is package sample.b", documentation.texts.single())
-    }
-}
diff --git a/plugins/base/src/test/kotlin/transformers/ContextModuleAndPackageDocumentationReaderTest3.kt b/plugins/base/src/test/kotlin/transformers/ContextModuleAndPackageDocumentationReaderTest3.kt
deleted file mode 100644
index ebd5b7eb..00000000
--- a/plugins/base/src/test/kotlin/transformers/ContextModuleAndPackageDocumentationReaderTest3.kt
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package transformers
-
-import org.jetbrains.dokka.analysis.kotlin.internal.InternalKotlinAnalysisPlugin
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.plugin
-import org.jetbrains.dokka.plugability.querySingle
-import org.jetbrains.dokka.utilities.DokkaConsoleLogger
-import org.jetbrains.dokka.utilities.LoggingLevel
-import testApi.testRunner.TestDokkaConfigurationBuilder
-import testApi.testRunner.dPackage
-import kotlin.test.BeforeTest
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-class ContextModuleAndPackageDocumentationReaderTest3 : AbstractContextModuleAndPackageDocumentationReaderTest() {
-
-    private val include by lazy { temporaryDirectory.resolve("include.md").toFile() }
-
-    @BeforeTest
-    fun materializeInclude() {
-        include.writeText(
-            """
-            # Package
-            This is the root package
-            
-            # Package [root]
-            This is also the root package
-            """.trimIndent()
-        )
-    }
-
-    private val configurationBuilder = TestDokkaConfigurationBuilder()
-
-    private val sourceSet by configurationBuilder.sourceSet {
-        includes = listOf(include.canonicalPath)
-    }
-
-    private val context by lazy {
-        DokkaContext.create(
-            configuration = configurationBuilder.build(),
-            logger = DokkaConsoleLogger(LoggingLevel.DEBUG),
-            pluginOverrides = emptyList()
-        )
-    }
-
-    private val reader by lazy { context.plugin<InternalKotlinAnalysisPlugin>().querySingle { moduleAndPackageDocumentationReader } }
-
-
-    @Test
-    fun `root package is matched by empty string and the root keyword`() {
-        val documentation = reader.read(dPackage(DRI(""), sourceSets = setOf(sourceSet)))
-        assertEquals(
-            listOf("This is the root package", "This is also the root package"), documentation.texts
-        )
-    }
-}
diff --git a/plugins/base/src/test/kotlin/transformers/DivisionSwitchTest.kt b/plugins/base/src/test/kotlin/transformers/DivisionSwitchTest.kt
deleted file mode 100644
index fec5fc47..00000000
--- a/plugins/base/src/test/kotlin/transformers/DivisionSwitchTest.kt
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package transformers
-
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.PluginConfigurationImpl
-import org.jetbrains.dokka.base.DokkaBase
-import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
-import org.jetbrains.dokka.model.dfs
-import org.jetbrains.dokka.pages.ClasslikePageNode
-import org.jetbrains.dokka.pages.ContentHeader
-import org.jetbrains.dokka.pages.ContentNode
-import org.jetbrains.dokka.pages.ContentText
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertNotNull
-
-class DivisionSwitchTest : BaseAbstractTest() {
-
-    private val query = """
-            |/src/source0.kt
-            package package0
-            /** 
-            * Documentation for ClassA 
-            */
-            class ClassA {
-                val A: String = "A"
-                fun a() {}
-                fun b() {}
-            }
-            
-            /src/source1.kt
-            package package0
-            /**
-            * Documentation for ClassB
-            */
-            class ClassB : ClassA() {
-                val B: String = "B"
-                fun d() {}
-                fun e() {}
-            }
-        """.trimMargin()
-
-    private fun configuration(switchOn: Boolean) = dokkaConfiguration {
-        sourceSets {
-            sourceSet {
-                sourceRoots = listOf("src/")
-            }
-        }
-        suppressObviousFunctions = false
-        pluginsConfigurations.add(
-            PluginConfigurationImpl(
-                DokkaBase::class.qualifiedName!!,
-                DokkaConfiguration.SerializationFormat.JSON,
-                """{ "separateInheritedMembers": $switchOn }""",
-            )
-        )
-    }
-
-    private fun testClassB(switchOn: Boolean, operation: (ClasslikePageNode) -> Unit) {
-        testInline(
-            query,
-            configuration(switchOn),
-            cleanupOutput = true
-        ) {
-            pagesTransformationStage = { root ->