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>

18 files changed, 2205 insertions, 0 deletions

diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/BasicTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/BasicTest.kt
new file mode 100644
index 00000000..9653b7bb
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/BasicTest.kt
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.html
+
+import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
+import org.jetbrains.dokka.links.DRI
+import renderers.testPage
+import utils.Span
+import utils.match
+import kotlin.test.Test
+
+class BasicTest : HtmlRenderingOnlyTestBase() {
+    @Test
+    fun `unresolved DRI link should render as text`() {
+        val page = testPage {
+            link("linkText", DRI("nonexistentPackage", "nonexistentClass"))
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.match(Span("linkText"))
+    }
+}
diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/BreadcrumbsTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/BreadcrumbsTest.kt
new file mode 100644
index 00000000..4bb0d41f
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/BreadcrumbsTest.kt
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.html
+
+import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
+import org.jsoup.nodes.Element
+import signatures.renderedContent
+import utils.*
+import kotlin.test.Test
+
+class BreadcrumbsTest : BaseAbstractTest() {
+
+    private val configuration = dokkaConfiguration {
+        sourceSets {
+            sourceSet {
+                sourceRoots = listOf("src/")
+            }
+        }
+    }
+
+    @Test
+    fun `should add breadcrumbs with current element`() {
+        val writerPlugin = TestOutputWriterPlugin()
+        testInline(
+            """
+            |/src/main/kotlin/basic/TestClass.kt
+            |package testpackage
+            |
+            |class TestClass {
+            |    fun foo() {}
+            |}
+        """.trimMargin(),
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                writerPlugin.writer.renderedContent("root/testpackage/-test-class/foo.html").selectBreadcrumbs().match(
+                    link("root"),
+                    delimiter(),
+                    link("testpackage"),
+                    delimiter(),
+                    link("TestClass"),
+                    delimiter(),
+                    current("foo"),
+                    ignoreSpanWithTokenStyle = true
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `should mark only one element as current even if more elements have the same name`() {
+        val writerPlugin = TestOutputWriterPlugin()
+        testInline(
+            """
+            |/src/main/kotlin/basic/TestClass.kt
+            |package testpackage
+            |
+            |class testname {
+            |    val testname: String = ""
+            |}
+        """.trimMargin(),
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                writerPlugin.writer.renderedContent("root/testpackage/testname/testname.html").selectBreadcrumbs().match(
+                    link("root"),
+                    delimiter(),
+                    link("testpackage"),
+                    delimiter(),
+                    link("testname"),
+                    delimiter(),
+                    current("testname"),
+                    ignoreSpanWithTokenStyle = true
+                )
+            }
+        }
+    }
+
+    private fun Element.selectBreadcrumbs() = this.select("div.breadcrumbs").single()
+
+    private fun link(text: String): Tag = A(text)
+    private fun delimiter(): Tag = Span().withClasses("delimiter")
+    private fun current(text: String): Tag = Span(text).withClasses("current")
+}
diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/CoverPageTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/CoverPageTest.kt
new file mode 100644
index 00000000..6b3ce2eb
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/CoverPageTest.kt
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.html
+
+import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
+import signatures.renderedContent
+import utils.TestOutputWriterPlugin
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class CoverPageTest : BaseAbstractTest() {
+
+    private val configuration = dokkaConfiguration {
+        sourceSets {
+            sourceSet {
+                sourceRoots = listOf("src/")
+                classpath = listOf(commonStdlibPath!!)
+                externalDocumentationLinks = listOf(stdlibExternalDocumentationLink)
+            }
+        }
+    }
+
+    @Test
+    fun `names of nested inheritors`() {
+        val source = """
+            |/src/main/kotlin/test/Test.kt
+            |package example
+            |
+            | sealed class Result{
+            |   class Success(): Result()
+            |   class Failed(): Result()
+            | }
+            """
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testInline(
+            source,
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                val content = writerPlugin.writer.renderedContent("root/example/-result/index.html")
+                val tableInheritors = content.select("div.table").single { it.previousElementSibling()?.text() == "Inheritors" && it.childrenSize() == 2 }
+                assertEquals(tableInheritors.getElementsContainingOwnText("Failed").singleOrNull()?.tagName(), "a")
+                assertEquals(tableInheritors.getElementsContainingOwnText("Success").singleOrNull()?.tagName(), "a")
+            }
+        }
+    }
+}
diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/CustomFooterTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/CustomFooterTest.kt
new file mode 100644
index 00000000..ff562c38
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/CustomFooterTest.kt
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.html
+
+import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.DokkaConfigurationImpl
+import org.jetbrains.dokka.PluginConfigurationImpl
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.base.DokkaBaseConfiguration
+import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
+import org.jetbrains.dokka.base.templating.toJsonString
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Element
+import renderers.testPage
+import utils.A
+import utils.Div
+import utils.Span
+import utils.match
+import kotlin.test.Test
+
+class CustomFooterTest : HtmlRenderingOnlyTestBase() {
+    @Test
+    fun `should include message from custom footer`() {
+        val page = testPage { }
+        HtmlRenderer(context).render(page)
+        renderedContent.match(
+            Span(A()),
+            Span(Div("Custom message")),
+            Span(Span("Generated by "), A(Span("dokka"), Span()))
+        )
+    }
+
+    override val configuration: DokkaConfigurationImpl
+        get() = super.configuration.copy(
+            pluginsConfiguration = listOf(
+                PluginConfigurationImpl(
+                    DokkaBase::class.java.canonicalName,
+                    DokkaConfiguration.SerializationFormat.JSON,
+                    toJsonString(DokkaBaseConfiguration(footerMessage = """<div style="color: red">Custom message</div>"""))
+                )
+            )
+        )
+
+    override val renderedContent: Element
+        get() = files.contents.getValue("test-page.html").let { Jsoup.parse(it) }.select(".footer").single()
+}
diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/DivergentTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/DivergentTest.kt
new file mode 100644
index 00000000..ccc43f12
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/DivergentTest.kt
@@ -0,0 +1,316 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.html
+
+import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.pages.ContentDivergentGroup
+import renderers.testPage
+import utils.Br
+import utils.match
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class DivergentTest : HtmlRenderingOnlyTestBase() {
+
+    @Test
+    fun simpleWrappingCase() {
+        val page = testPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("a")
+                    }
+                }
+            }
+        }
+        HtmlRenderer(context).render(page)
+        renderedContent.select("[data-togglable=DEFAULT/js]").single().match("a")
+    }
+
+    @Test
+    fun noPlatformHintCase() {
+        val page = testPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test"), implicitlySourceSetHinted = false) {
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("a")
+                    }
+                }
+            }
+        }
+        HtmlRenderer(context).render(page)
+        renderedContent.match("a")
+    }
+
+    @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")
+                    }
+                }
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        val content = renderedContent
+        content.select("[data-togglable=DEFAULT/js]").single().match("a")
+        content.select("[data-togglable=DEFAULT/jvm]").single().match("b")
+        content.select("[data-togglable=DEFAULT/native]").single().match("c")
+    }
+
+    @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")
+                    }
+                }
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.select("[data-togglable=DEFAULT/js]").single().match("abc")
+    }
+
+    @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")
+                    }
+                }
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        val content = renderedContent
+        val orderOfTabs = content.select(".platform-bookmarks-row").single().children().map { it.attr("data-toggle") }
+
+        assertEquals(listOf("DEFAULT/js", "DEFAULT/jvm", "DEFAULT/native"), orderOfTabs)
+
+        content.select("[data-togglable=DEFAULT/native]").single().match("ae")
+        content.select("[data-togglable=DEFAULT/js]").single().match("bd")
+        content.select("[data-togglable=DEFAULT/jvm]").single().match("c")
+    }
+
+    @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+")
+                    }
+                }
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        val content = renderedContent
+        content.select("[data-togglable=DEFAULT/native]").single().match("aa+", Br, "ee+")
+        content.select("[data-togglable=DEFAULT/js]").single().match("bdbd+")
+        content.select("[data-togglable=DEFAULT/jvm]").single().match("c")
+    }
+
+    @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")
+                    }
+                }
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.select("[data-togglable=DEFAULT/native]").single().match("ab-ab")
+    }
+
+    @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+")
+                    }
+                }
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.select("[data-togglable=DEFAULT/native]").single().match("abab+")
+    }
+
+    @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+")
+                    }
+                }
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.select("[data-togglable=DEFAULT/native]").single().match("ab-abab+")
+    }
+
+    @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+")
+                    }
+                }
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.select("[data-togglable=DEFAULT/native]").single().match("a-aab+", Br, "b-bab+")
+    }
+}
diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/FooterMessageTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/FooterMessageTest.kt
new file mode 100644
index 00000000..149f970c
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/FooterMessageTest.kt
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.html
+
+import org.jetbrains.dokka.base.DokkaBaseConfiguration.Companion.defaultFooterMessage
+import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Element
+import renderers.testPage
+import utils.A
+import utils.Span
+import utils.match
+import kotlin.test.Test
+
+class FooterMessageTest : HtmlRenderingOnlyTestBase() {
+    @Test
+    fun `should include defaultFooter`() {
+        val page = testPage { }
+        HtmlRenderer(context).render(page)
+        renderedContent.match(
+            Span(A()),
+            Span(defaultFooterMessage),
+            Span(Span("Generated by "), A(Span("dokka"), Span()))
+        )
+    }
+
+    override val renderedContent: Element
+        get() = files.contents.getValue("test-page.html").let { Jsoup.parse(it) }.select(".footer").single()
+}
diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/FormattingUtilsTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/FormattingUtilsTest.kt
new file mode 100644
index 00000000..028ffa77
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/FormattingUtilsTest.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.html
+
+import kotlinx.html.body
+import kotlinx.html.html
+import kotlinx.html.stream.createHTML
+import org.jetbrains.dokka.base.renderers.html.buildBreakableText
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class FormattingUtilsTest {
+    @Test
+    fun `should build breakable text`(){
+        val testedText = "kotlinx.collections.immutable"
+        val expectedHtml = """
+            <html>
+              <body><span>kotlinx.</span><wbr></wbr><span>collections.</span><wbr></wbr><span>immutable</span></body>
+            </html>
+        """.trimIndent()
+
+        val html = createHTML(prettyPrint = true).html {
+            body {
+                buildBreakableText(testedText)
+            }
+        }
+
+        assertEquals(expectedHtml.trim(), html.trim())
+    }
+
+    @Test
+    fun `should build breakable text without empty spans`(){
+        val testedText = "Package org.jetbrains.dokka.it.moduleC"
+        val expectedHtml = """
+            <html>
+              <body><span><span>Package</span></span> <span>org.</span><wbr></wbr><span>jetbrains.</span><wbr></wbr><span>dokka.</span><wbr></wbr><span>it.</span><wbr></wbr><span>moduleC</span></body>
+            </html>
+        """.trimIndent()
+
+        val html = createHTML(prettyPrint = true).html {
+            body {
+                buildBreakableText(testedText)
+            }
+        }
+
+        assertEquals(expectedHtml.trim(), html.trim())
+    }
+
+    @Test
+    fun `should build breakable text for text with braces`(){
+        val testedText = "[Common]kotlinx.collections.immutable"
+        val expectedHtml = """
+            <html>
+              <body><span>[Common]kotlinx.</span><wbr></wbr><span>collections.</span><wbr></wbr><span>immutable</span></body>
+            </html>
+        """.trimIndent()
+
+        val html = createHTML(prettyPrint = true).html {
+            body {
+                buildBreakableText(testedText)
+            }
+        }
+
+        assertEquals(expectedHtml.trim(), html.trim())
+    }
+
+    @Test
+    fun `should build breakable text for camel case notation`(){
+        val testedText = "DokkkkkkkaIsTheBest"
+        val expectedHtml = """
+            <html>
+              <body><span>Dokkkkkkka</span><wbr></wbr><span>Is</span><wbr></wbr><span>The</span><wbr></wbr><span><span>Best</span></span></body>
+            </html>
+        """.trimIndent()
+
+        val html = createHTML(prettyPrint = true).html {
+            body {
+                buildBreakableText(testedText)
+            }
+        }
+
+        assertEquals(expectedHtml.trim(), html.trim())
+    }
+}
diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/GroupWrappingTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/GroupWrappingTest.kt
new file mode 100644
index 00000000..cc9b763d
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/GroupWrappingTest.kt
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.html
+
+import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
+import org.jetbrains.dokka.pages.TextStyle
+import renderers.testPage
+import utils.Div
+import utils.P
+import utils.match
+import kotlin.test.Test
+
+class GroupWrappingTest : HtmlRenderingOnlyTestBase() {
+
+    @Test
+    fun notWrapped() {
+        val page = testPage {
+            group {
+                text("a")
+                text("b")
+            }
+            text("c")
+        }
+
+        HtmlRenderer(context).render(page)
+
+        renderedContent.match("abc")
+    }
+
+    @Test
+    fun paragraphWrapped() {
+        val page = testPage {
+            group(styles = setOf(TextStyle.Paragraph)) {
+                text("a")
+                text("b")
+            }
+            text("c")
+        }
+
+        HtmlRenderer(context).render(page)
+
+        renderedContent.match(P("ab"), "c")
+    }
+
+    @Test
+    fun blockWrapped() {
+        val page = testPage {
+            group(styles = setOf(TextStyle.Block)) {
+                text("a")
+                text("b")
+            }
+            text("c")
+        }
+
+        HtmlRenderer(context).render(page)
+
+        renderedContent.match(Div("ab"), "c")
+    }
+
+    @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")
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+
+        renderedContent.match(Div("a", Div(Div("bc")), "d"))
+    }
+
+}
diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/HeaderTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/HeaderTest.kt
new file mode 100644
index 00000000..c19f965f
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/renderers/html/HeaderTest.kt
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package renderers.html
+
+import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.DokkaConfigurationImpl
+import org.jetbrains.dokka.PluginConfigurationImpl
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.base.DokkaBaseConfiguration
+import org.jetbrains.dokka.base.templating.toJsonString
+import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
+import org.jetbrains.dokka.pages.RootPageNode
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jsoup.Jsoup
+import utils.TestOutputWriter
+import utils.TestOutputWriterPlugin
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+
+class HeaderTest : BaseAbstractTest() {
+    private val configuration = dokkaConfiguration {
+        sourceSets {
+            sourceSet {
+                name = "jvm"
+                sourceRoots = listOf("src/jvm")
+            }
+            sourceSet {
+                name = "js"
+                sourceRoots = listOf("src/js")
+            }
+        }
+    }
+
+    @Test
+    fun `should include homepage link if homepageLink is provided`() {
+        testRendering(
+            DokkaBaseConfiguration(homepageLink = "https://github.com/Kotlin/dokka/")
+        ) { _, _, writer ->
+            val renderedContent = navigationElement(writer)
+
+            val sourceLinkElement =
+                assertNotNull(renderedContent.getElementById("homepage-link"), "Source link element not found")
+            val aElement = assertNotNull(sourceLinkElement.selectFirst("a"))
+            assertEquals("https://github.com/Kotlin/dokka/", aElement.attr("href"))
+        }
+    }
+
+    @Test
+    fun `should not include homepage link by default`() {
+        testRendering(nul