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>

17 files changed, 0 insertions, 2230 deletions

diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/AbstractJavadocTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/AbstractJavadocTemplateMapTest.kt
deleted file mode 100644
index 60265e33..00000000
--- a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/AbstractJavadocTemplateMapTest.kt
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package org.jetbrains.dokka.javadoc
-
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.DokkaConfigurationImpl
-import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
-import org.jetbrains.dokka.javadoc.location.JavadocLocationProvider
-import org.jetbrains.dokka.javadoc.pages.JavadocPageNode
-import org.jetbrains.dokka.javadoc.renderer.JavadocContentToTemplateMapTranslator
-import org.jetbrains.dokka.jdk
-import org.jetbrains.dokka.kotlinStdlib
-import org.jetbrains.dokka.model.withDescendants
-import org.jetbrains.dokka.pages.RootPageNode
-import org.jetbrains.dokka.plugability.*
-
-internal abstract class AbstractJavadocTemplateMapTest : BaseAbstractTest() {
-    protected var config: DokkaConfigurationImpl = dokkaConfiguration {
-        format = "javadoc"
-        suppressObviousFunctions = false
-        sourceSets {
-            sourceSet {
-                sourceRoots = listOf("src")
-                analysisPlatform = "jvm"
-                externalDocumentationLinks = listOf(
-                    DokkaConfiguration.ExternalDocumentationLink.jdk(8),
-                    DokkaConfiguration.ExternalDocumentationLink.kotlinStdlib()
-                )
-                classpath = listOfNotNull(jvmStdlibPath)
-            }
-        }
-    }
-
-    data class Result(
-        val rootPageNode: RootPageNode,
-        val context: DokkaContext
-    ) {
-
-        val translator: JavadocContentToTemplateMapTranslator by lazy {
-            val locationProvider = context.plugin<JavadocPlugin>()
-                .querySingle { locationProviderFactory }
-                .getLocationProvider(rootPageNode) as JavadocLocationProvider
-
-            JavadocContentToTemplateMapTranslator(locationProvider, context)
-        }
-
-        val JavadocPageNode.templateMap: Map<String, Any?> get() = translator.templateMapForPageNode(this)
-
-        inline fun <reified T : JavadocPageNode> allPagesOfType(): List<T> {
-            return rootPageNode.withDescendants().filterIsInstance<T>().toList()
-        }
-
-        inline fun <reified T : JavadocPageNode> firstPageOfType(): T {
-            return rootPageNode.withDescendants().filterIsInstance<T>().first()
-        }
-
-        inline fun <reified T : JavadocPageNode> firstPageOfTypeOrNull(): T? {
-            return rootPageNode.withDescendants().filterIsInstance<T>().firstOrNull()
-        }
-
-        inline fun <reified T : JavadocPageNode> singlePageOfType(): T {
-            return rootPageNode.withDescendants().filterIsInstance<T>().single()
-        }
-    }
-
-    fun testTemplateMapInline(
-        query: String,
-        configuration: DokkaConfigurationImpl = config,
-        pluginsOverride: List<DokkaPlugin> = emptyList(),
-        assertions: Result.() -> Unit
-    ) {
-        testInline(query, configuration, pluginOverrides = pluginsOverride) {
-            renderingStage = { rootPageNode, dokkaContext ->
-                val preprocessors = dokkaContext.plugin<JavadocPlugin>().query { javadocPreprocessors }
-                val transformedRootPageNode = preprocessors.fold(rootPageNode) { acc, pageTransformer ->
-                    pageTransformer(acc)
-                }
-
-                Result(transformedRootPageNode, dokkaContext).assertions()
-            }
-        }
-    }
-
-    fun dualTestTemplateMapInline(
-        kotlin: String? = null,
-        java: String? = null,
-        configuration: DokkaConfigurationImpl = config,
-        pluginsOverride: List<DokkaPlugin> = emptyList(),
-        assertions: Result.() -> Unit
-    ) {
-        val kotlinException = kotlin?.let {
-            runCatching {
-                testTemplateMapInline(
-                    query = kotlin,
-                    configuration = configuration,
-                    pluginsOverride = pluginsOverride,
-                    assertions = assertions
-                )
-            }.exceptionOrNull()
-        }
-
-        val javaException = java?.let {
-            runCatching {
-                testTemplateMapInline(
-                    query = java,
-                    configuration = configuration,
-                    pluginsOverride = pluginsOverride,
-                    assertions = assertions
-                )
-            }.exceptionOrNull()
-        }
-
-        if (kotlinException != null && javaException != null) {
-            throw AssertionError(
-                "Kotlin and Java Code failed assertions\n" +
-                        "Kotlin: ${kotlinException.message}\n" +
-                        "Java  : ${javaException.message}",
-                kotlinException
-            )
-        }
-
-        if (kotlinException != null) {
-            throw AssertionError("Kotlin Code failed assertions", kotlinException)
-        }
-
-        if (javaException != null) {
-            throw AssertionError("Java Code failed assertions", javaException)
-        }
-    }
-}
diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/Asserts.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/Asserts.kt
deleted file mode 100644
index 2854ac7c..00000000
--- a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/Asserts.kt
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package org.jetbrains.dokka.javadoc
-
-import kotlin.contracts.ExperimentalContracts
-import kotlin.contracts.contract
-
-// TODO replace with assertIs<T> from kotlin-test as part of #2924
-@OptIn(ExperimentalContracts::class)
-inline fun <reified T> assertIsInstance(obj: Any?): T {
-    contract {
-        returns() implies (obj is T)
-    }
-
-    if (obj is T) {
-        return obj
-    }
-
-    throw AssertionError("Expected instance of type ${T::class.qualifiedName} but found $obj")
-}
diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocAccessorNamingTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocAccessorNamingTest.kt
deleted file mode 100644
index 95ce4d27..00000000
--- a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocAccessorNamingTest.kt
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package org.jetbrains.dokka.javadoc
-
-import org.jsoup.Jsoup
-import utils.TestOutputWriterPlugin
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertTrue
-
-internal class JavadocAccessorNamingTest : AbstractJavadocTemplateMapTest() {
-
-    val configuration = dokkaConfiguration {
-        suppressObviousFunctions = true
-        sourceSets {
-            sourceSet {
-                sourceRoots = listOf("src/main/kotlin")
-                classpath = listOfNotNull(jvmStdlibPath)
-            }
-        }
-    }
-
-    /**
-     * This is a quick sanity check for the AccessorMethodNamingTest
-     */
-    @Test
-    fun verifySpecialIsRuleIsApplied() {
-        val writerPlugin = TestOutputWriterPlugin()
-
-        testInline(
-            """
-            /src/main/kotlin/sample/TestCase.kt
-            package sample
-            
-            /**
-             * Test links:
-             * - [TestCase.issuesFetched]
-             * - [TestCase.isFoo]
-             */
-            data class TestCase(
-               var issuesFetched: Int,
-               var isFoo: String,
-            )
-            """.trimIndent(),
-            configuration,
-            cleanupOutput = false,
-            pluginOverrides = listOf(writerPlugin, JavadocPlugin())
-        ) {
-            renderingStage = { _, _ ->
-                val html = writerPlugin.writer.contents.getValue("sample/TestCase.html").let { Jsoup.parse(it) }
-                val props = html
-                    .select("#memberSummary_tabpanel")
-                    .select("th[scope=row].colSecond")
-                    .select("code")
-                    .map { it.text() }
-                    .toSet()
-                // In K2 name of accessors parameter  is `value`
-                assertTrue(
-                    setOf(
-                        "getIssuesFetched()",
-                        "setIssuesFetched(Integer issuesFetched)",
-                        "isFoo()",
-                        "setFoo(String isFoo)",
-                    ) == props || setOf(
-                        "getIssuesFetched()",
-                        "setIssuesFetched(Integer value)",
-                        "isFoo()",
-                        "setFoo(String value)",
-                    ) == props
-                )
-
-                val descriptionLinks = html
-                    .select("div.description")
-                    .select("p")
-                    .select("a")
-                    .eachAttr("href")
-                    .map { a -> a.takeLastWhile { it != '#' } }
-
-                assertEquals(setOf(
-                    "issuesFetched",
-                    "isFoo()",
-                ), descriptionLinks.toSet())
-
-                // Make sure that the ids from above actually exist
-                assertEquals(1, html.select("[id = isFoo()]").size)
-                // Bug! Nothing in the doc has the right id
-                assertEquals(0, html.select("[id = issuesFetched]").size)
-            }
-        }
-    }
-}
diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocAllClassesTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocAllClassesTemplateMapTest.kt
deleted file mode 100644
index 8d7ff1ea..00000000
--- a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocAllClassesTemplateMapTest.kt
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package org.jetbrains.dokka.javadoc
-
-import org.jetbrains.dokka.javadoc.pages.AllClassesPage
-import org.jetbrains.dokka.javadoc.pages.LinkJavadocListEntry
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.pages.ContentKind
-import org.junit.jupiter.api.Tag
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-internal class JavadocAllClassesTemplateMapTest : AbstractJavadocTemplateMapTest() {
-    @Test
-    @Tag("onlyDescriptors") // https://github.com/Kotlin/dokka/issues/3250
-    fun `two classes from different packages`() {
-        dualTestTemplateMapInline(
-            """
-            /src/source0.kt
-            package package0
-            /** 
-            * Documentation for ClassA 
-            */
-            class ClassA
-            
-            /src/source1.kt
-            package package1
-            /**
-            * Documentation for ClassB
-            */
-            class ClassB
-            """
-        ) {
-            val map = singlePageOfType<AllClassesPage>().templateMap
-            assertEquals("main", map["kind"])
-            assertEquals("All Classes", map["title"])
-
-            val list = assertIsInstance<List<*>>(map["list"])
-            assertEquals(2, list.size, "Expected two classes")
-
-            val classA = assertIsInstance<LinkJavadocListEntry>(list[0])
-            assertEquals("ClassA", classA.name)
-            assertEquals(DRI("package0", "ClassA"), classA.dri.single())
-            assertEquals(ContentKind.Classlikes, classA.kind)
-
-            val classB = assertIsInstance<LinkJavadocListEntry>(list[1])
-            assertEquals("ClassB", classB.name)
-            assertEquals(DRI("package1", "ClassB"), classB.dri.single())
-            assertEquals(ContentKind.Classlikes, classB.kind)
-        }
-    }
-}
diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocClasslikeTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocClasslikeTemplateMapTest.kt
deleted file mode 100644
index fd382d42..00000000
--- a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocClasslikeTemplateMapTest.kt
+++ /dev/null
@@ -1,461 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package org.jetbrains.dokka.javadoc
-
-import org.jetbrains.dokka.javadoc.pages.JavadocClasslikePageNode
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-internal class JavadocClasslikeTemplateMapTest : AbstractJavadocTemplateMapTest() {
-
-    @Test
-    fun `empty class`() {
-        dualTestTemplateMapInline(
-            kotlin =
-            """
-            /src/source0.kt
-            package com.test.package0
-            /**
-            * Documentation for TestClass
-            */
-            class TestClass
-            """,
-            java =
-            """
-            /src/com/test/package0/TestClass.java
-            package com.test.package0;
-            /**
-            * Documentation for TestClass
-            */
-            public final class TestClass {}
-            """
-        ) {
-            val map = singlePageOfType<JavadocClasslikePageNode>().templateMap
-            assertEquals("TestClass", map["name"])
-            assertEquals("TestClass", map["title"])
-            assertEquals("com.test.package0", map["packageName"])
-            assertEquals("<p>Documentation for TestClass</p>", map["classlikeDocumentation"])
-            assertEquals("Documentation for TestClass", map["subtitle"])
-            assertEquals("public final class <a href=TestClass.html>TestClass</a>", map.signatureWithModifiers())
-        }
-    }
-
-    @Test
-    fun `single function`() {
-        dualTestTemplateMapInline(
-            kotlin =
-            """
-            /src/source0.kt
-            package com.test.package0
-            /**
-            * Documentation for TestClass
-            */
-            class TestClass {
-                /**
-                * Documentation for testFunction
-                */
-                fun testFunction(): String = ""
-            }
-            """,
-            java =
-            """
-            /src/com/test/package0/TestClass.java
-            package com.test.package0
-            /**
-            * Documentation for TestClass
-            */
-            public final class TestClass {
-                /**
-                * Documentation for testFunction
-                */
-                public final String testFunction() {
-                    return "";
-                }
-            }
-            """
-        ) {
-            val map = singlePageOfType<JavadocClasslikePageNode>().templateMap
-
-            assertEquals("TestClass", map["name"])
-            assertEquals("TestClass", map["title"])
-            assertEquals("com.test.package0", map["packageName"])
-            assertEquals("<p>Documentation for TestClass</p>", map["classlikeDocumentation"])
-            assertEquals("Documentation for TestClass", map["subtitle"])
-            assertEquals("public final class", map.modifiers())
-            assertEquals("<a href=TestClass.html>TestClass</a>", map.signatureWithoutModifiers())
-
-            val methods = assertIsInstance<Map<Any, Any?>>(map["methods"])
-            val ownMethods = assertIsInstance<List<*>>(methods["own"])
-            assertEquals(1, ownMethods.size, "Expected only one method")
-            val method = assertIsInstance<Map<String, Any?>>(ownMethods.single())
-            assertEquals("Documentation for testFunction", method["brief"])
-            assertEquals("testFunction", method["name"])
-            assertEquals(
-                0, assertIsInstance<List<*>>(method["parameters"]).size,
-                "Expected no parameters"
-            )
-            assertEquals("final <a href=https://docs.oracle.com/javase/8/docs/api/java/lang/String.html>String</a>", method.modifiers())
-            assertEquals("<a href=TestClass.html#testFunction()>testFunction</a>()", method.signatureWithoutModifiers())
-        }
-    }
-
-    @Test
-    fun `class with annotation`(){
-        dualTestTemplateMapInline(
-            kotlin =
-            """
-            /src/source0.kt
-            package com.test.package0
-            @MustBeDocumented
-            annotation class Author(val name: String)
-
-            @Author(
-                    name = "Benjamin Franklin"
-            )
-            class TestClass {`
-                
-                @Author(
-                    name = "Franklin D. Roosevelt"
-                )
-                fun testFunction(): String = ""
-            }
-            """,
-            java =
-            """
-            /src/com/test/package0/Author.java
-            package com.test.package0
-            import java.lang.annotation.Documented;
-
-            @Documented
-            public @interface Author {
-                String name();
-            }
-            /src/com/test/package0/TestClass.java
-            package com.test.package0
-
-            @Author(
-                    name = "Benjamin Franklin"
-            )
-            public final class TestClass {
-                
-                @Author(
-                    name = "Franklin D. Roosevelt"
-                )
-                public final String testFunction() {
-                    return "";
-                }
-            }
-            """
-        ){
-            val map = allPagesOfType<JavadocClasslikePageNode>().first { it.name == "TestClass" }.templateMap
-            assertEquals("TestClass", map["name"])
-            val signature = assertIsInstance<Map<String, Any?>>(map["signature"])
-            assertEquals("@<a href=Author.html>Author</a>(name = &quot;Benjamin Franklin&quot;)", signature["annotations"])
-
-            val methods = assertIsInstance<Map<Any, Any?>>(map["methods"])
-            val ownMethods = assertIsInstance<List<*>>(methods["own"])
-            val method = assertIsInstance<Map<String, Any?>>(ownMethods.single())
-            val methodSignature = assertIsInstance<Map<String, Any?>>(method["signature"])
-            assertEquals("@<a href=Author.html>Author</a>(name = &quot;Franklin D. Roosevelt&quot;)", methodSignature["annotations"])
-        }
-    }
-
-    @Test
-    fun `simple enum`(){
-        dualTestTemplateMapInline(
-            kotlin =
-            """
-            /src/source0.kt
-            package com.test.package0
-            enum class ClockDays {
-                /**
-                 * Sample docs for first
-                 */
-                FIRST,
-                /**
-                 * Sample docs for second
-                 */
-                SECOND
-            }
-            """,
-            java =
-            """
-            /src/com/test/package0/TestClass.java
-            package com.test.package0;
-            public enum ClockDays {
-                /**
-                 * Sample docs for first
-                 */
-                FIRST,
-                /**
-                 * Sample docs for second
-                 */
-                SECOND
-            }
-            """
-        ){
-            val map = singlePageOfType<JavadocClasslikePageNode>().templateMap
-            assertEquals("ClockDays", map["name"])
-            assertEquals("enum", map["kind"])
-            val entries = assertIsInstance<List<Map<String, Any?>>>(map["entries"])
-            assertEquals(2, entries.size)
-
-            val (first, second) = entries.sortedBy { it["brief"] as String }
-            assertEquals("<p>Sample docs for first</p>", first["brief"])
-            assertEquals("<p>Sample docs for second</p>", second["brief"])
-
-            assertEquals("<a href=ClockDays.html#FIRST>FIRST</a>", first.signatureWithoutModifiers())
-            assertEquals("<a href=ClockDays.html#SECOND>SECOND</a>", second.signatureWithoutModifiers())
-        }
-    }
-
-    @Test
-    fun `documented function parameters`(){
-        dualTestTemplateMapInline(
-            kotlin =
-            """
-            /src/source0.kt
-            package com.test.package0
-            class TestClass {
-                /**
-                 * Simple parameters list to check out
-                 * @param simple simple String parameter
-                 * @param parameters simple Integer parameter
-                 * @param list simple Boolean parameter
-                 * @return just a String
-                 */
-                fun testFunction(simple: String?, parameters: Int?, list: Boolean?): String {
-                    return ""
-                }
-            }
-            """,
-            java =
-            """
-            /src/com/test/package0/TestClass.java
-            package com.test.package0;
-            public final class TestClass {
-                /**
-                 * Simple parameters list to check out
-                 * @param simple simple String parameter
-                 * @param parameters simple Integer parameter
-                 * @param list simple Boolean parameter
-                 * @return just a String
-                 */
-                public final String testFunction(String simple, Integer parameters, Boolean list) {
-                    return "";
-                }
-            }
-            """
-        ) {
-            val map = singlePageOfType<JavadocClasslikePageNode>().templateMap
-            assertEquals("TestClass", map["name"])
-
-            val methods = assertIsInstance<Map<String, Any?>>(map["methods"])
-            val testFunction = assertIsInstance<List<Map<String, Any?>>>(methods["own"]).single()
-            assertEquals("Simple parameters list to check out", testFunction["brief"])
-
-            val (first, second, third) = assertIsInstance<List<Map<String, Any?>>>(testFunction["parameters"])
-            assertParameterNode(
-                node = first,
-                expectedName = "simple",
-                expectedType = "<a href=https://docs.oracle.com/javase/8/docs/api/java/lang/String.html>String</a>",
-                expectedDescription = "simple String parameter"
-            )
-            assertParameterNode(
-                node = second,
-                expectedName = "parameters",
-                expectedType = "<a href=https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html>Integer</a>",
-                expectedDescription = "simple Integer parameter"
-            )
-            assertParameterNode(
-                node = third,
-                expectedName = "list",
-                expectedType = "<a href=https://docs.oracle.com/javase/8/docs/api/java/lang/Boolean.html>Boolean</a>",
-                expectedDescription = "simple Boolean parameter"
-            )
-        }
-    }
-
-    @Test
-    fun `with generic parameters`(){
-        dualTestTemplateMapInline(
-            kotlin =
-            """
-            /src/source0.kt
-            package com.test.package0
-            import java.io.Serializable
-
-            class Generic<T : Serializable?> {
-                fun <D : T> sampleFunction(): D = TODO()
-            }
-            """,
-            java =
-            """
-            /src/com/test/package0/Generic.java
-            package com.test.package0;
-            import java.io.Serializable;
-
-            public final class Generic<T extends Serializable> {
-                public final <D extends T> D sampleFunction(){
-                    return null;
-                }
-            }
-            """
-        ) {
-            val map = singlePageOfType<JavadocClasslikePageNode>().templateMap
-            assertEquals("Generic", map["name"])
-
-            assertEquals(
-                "public final class <a href=Generic.html>Generic</a>&lt;T extends <a href=https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html>Serializable</a>&gt;",
-                map.signatureWithModifiers()
-            )
-            val methods = assertIsInstance<Map<Any, Any?>>(map["methods"])
-            val ownMethods = assertIsInstance<List<*>>(methods["own"]).first()
-            val sampleFunction = assertIsInstance<Map<String, Any?>>(ownMethods)
-
-            assertEquals("final &lt;D extends <a href=Generic.html>T</a>&gt; <a href=Generic.html#sampleFunction()>D</a> <a href=Generic.html#sampleFunction()>sampleFunction</a>()", sampleFunction.signatureWithModifiers())
-        }
-    }
-
-    @Test
-    fun `class with top-level const`() {
-        dualTestTemplateMapInline(
-            kotlin =
-                """
-                /src/Test.kt
-                package com.test.package0
-                
-                const val TEST_VAL = "test"
-                """,
-            java =
-                """
-                /src/com/test/package0/TestKt.java
-                package com.test.package0;
-                
-                public final class TestKt {
-                    public static final String TEST_VAL = "test"; 
-                }
-                """
-        ) {
-            val map = singlePageOfType<JavadocClasslikePageNode>().templateMap
-            val properties = assertIsInstance<List<*>>(map["properties"])
-            val property = assertIsInstance<Map<String, Any?>>(properties.first())
-            assertEquals("public final static <a href=https://docs.oracle.com/javase/8/docs/api/java/lang/String.html>String</a> <a href=TestKt.html#TEST_VAL>TEST_VAL</a>", "${property["modifiers"]} ${property["signature"]}")
-        }
-    }
-
-    @Test
-    fun `@author @since @return method tags`(){
-        dualTestTemplateMapInline(
-            kotlin =
-            """
-            /src/source0.kt
-            package com.test.package0
-            class TestClass {
-                /**
-                 * Testing @author @since @return method tags
-                 * @since 1.2
-                 * @since 08 april 2023 
-                 * @return parameter's value in lower case
-                 */
-                fun testFunction(testParam: String?): String {
-                    return testParam?.lowercase() ?: ""
-                }
-            }
-            """,
-            java =
-            """
-            /src/com/test/package0/TestClass.java
-            package com.test.package0;
-            public final class TestClass {
-                /**
-                 * Testing @author @since @return method tags
-                 * @since 1.2
-                 * @since 08 april 2023 
-                 * @return parameter's value in lower case
-                 */
-                public final String testFunction(String testParam) {
-                    return testParam.toLowerCase();
-                }
-            }
-            """
-        ) {
-            val map = singlePageOfType<JavadocClasslikePageNode>().templateMap
-            assertEquals("TestClass", map["name"])
-
-            val methods = assertIsInstance<Map<String, Any?>>(map["methods"])
-            val testFunction = assertIsInstance<List<Map<String, Any?>>>(methods["own"]).single()
-            assertEquals("Testing @author @since @return method tags", testFunction["brief"])
-
-            assertEquals("testFunction", testFunction["name"])
-            assertEquals(listOf("<p>1.2</p>", "<p>08 april 2023</p>"), testFunction["sinceTagContent"])
-            assertEquals("<p>parameter's value in lower case</p>", testFunction["returnTagContent"])
-        }
-    }
-
-    @Test
-    fun `@author @since class tags`(){
-        dualTestTemplateMapInline(
-            kotlin =
-            """
-            /src/source0.kt
-            package com.test.package0
-            /**
-             * Testing @author @since class tags
-             * @author Test Author
-             * @author Test Author2
-             * @author Test Author3
-             * @since 1.2
-             * @since 08 april 2023 
-             */
-            class TestClass {
-                fun testFunction(testParam: String?): String {
-                    return testParam?.lowercase() ?: ""
-                }
-            }
-            """,
-            java =
-            """
-            /src/com/test/package0/TestClass.java
-            package com.test.package0;
-            /**
-             * Testing @author @since class tags
-             * @author Test Author
-             * @author Test Author2
-             * @author Test Author3
-             * @since 1.2
-             * @since 08 april 2023 
-             */
-            public final class TestClass {
-                public final String testFunction(String testParam) {
-                    return testParam.toLowerCase();
-                }
-            }
-            """
-        ) {
-            val map = singlePageOfType<JavadocClasslikePageNode>().templateMap
-
-            assertEquals("TestClass", map["name"])
-            assertEquals("<p>Testing @author @since class tags</p>", map["classlikeDocumentation"])
-            assertEquals(listOf("<p>Test Author</p>", "<p>Test Author2</p>", "<p>Test Author3</p>"), map["authorTagContent"])
-            assertEquals(listOf("<p>1.2</p>", "<p>08 april 2023</p>"), map["sinceTagContent"])
-        }
-    }
-
-    private fun assertParameterNode(no