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>

19 files changed, 6967 insertions, 0 deletions

diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/content/ContentInDescriptionTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/content/ContentInDescriptionTest.kt
new file mode 100644
index 00000000..a278795d
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/content/ContentInDescriptionTest.kt
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package content
+
+import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
+import org.jetbrains.dokka.model.doc.*
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class ContentInDescriptionTest : BaseAbstractTest() {
+    private val configuration = dokkaConfiguration {
+        sourceSets {
+            sourceSet {
+                sourceRoots = listOf("src/")
+                analysisPlatform = "jvm"
+                classpath += jvmStdlibPath!!
+            }
+        }
+    }
+
+    val expectedDescription = Description(
+        CustomDocTag(
+            listOf(
+                P(
+                    listOf(
+                        Text("Hello World! Docs with period issue, e.g."),
+                        Text(String(Character.toChars(160)), params = mapOf("content-type" to "html")),
+                        Text("this.")
+                    )
+                )
+            ),
+            params = emptyMap(),
+            name = "MARKDOWN_FILE"
+        )
+    )
+
+    @Test
+    fun `nbsp is handled as code in kotlin`() {
+        testInline(
+            """
+            |/src/main/kotlin/sample/ParentKt.kt
+            |package sample;
+            |/**
+            | * Hello World! Docs with period issue, e.g. this.
+            | */
+            |public class ParentKt {
+            |}
+            """.trimIndent(), configuration
+        ) {
+            documentablesMergingStage = {
+                val classlike = it.packages.flatMap { it.classlikes }.find { it.name == "ParentKt" }
+
+                assertTrue(classlike != null)
+                assertEquals(expectedDescription, classlike.documentation.values.first().children.first())
+            }
+        }
+    }
+
+    @Test
+    fun `nbsp is handled as code in java`() {
+        testInline(
+            """
+            |/src/main/kotlin/sample/Parent.java
+            |package sample;
+            |/**
+            | * Hello World! Docs with period issue, e.g. this.
+            | */
+            |public class Parent {
+            |}
+            """.trimIndent(), configuration
+        ) {
+            documentablesMergingStage = {
+                val classlike = it.packages.flatMap { it.classlikes }.find { it.name == "Parent" }
+
+                assertTrue(classlike != null)
+                assertEquals(expectedDescription, classlike.documentation.values.first().children.first())
+            }
+        }
+    }
+
+    @Test
+    fun `same documentation in java and kotlin when nbsp is present`() {
+        testInline(
+            """
+            |/src/main/kotlin/sample/Parent.java
+            |package sample;
+            |/**
+            | * Hello World! Docs with period issue, e.g. this.
+            | */
+            |public class Parent {
+            |}
+            |
+            |/src/main/kotlin/sample/ParentKt.kt
+            |package sample;
+            |/**
+            | * Hello World! Docs with period issue, e.g. this.
+            | */
+            |public class ParentKt {
+            |}
+            """.trimIndent(),
+            configuration
+        ) {
+            documentablesMergingStage = { module ->
+                val java = module.packages.flatMap { it.classlikes }.first { it.name == "Parent" }
+                val kotlin = module.packages.flatMap { it.classlikes }.first { it.name == "ParentKt" }
+
+                assertEquals(java.documentation.values.first(), kotlin.documentation.values.first())
+            }
+        }
+    }
+
+    @Test
+    fun `text surrounded by angle brackets is not removed`() {
+        testInline(
+            """
+        |/src/main/kotlin/sample/Foo.kt
+        |package sample
+        |/**
+        | * My example `CodeInline<Bar>`
+        | * ``` 
+        | *  CodeBlock<Bar>
+        | * ```         
+        | */
+        |class Foo {
+        |}
+        """.trimIndent(),
+            configuration
+        ) {
+            documentablesMergingStage = { module ->
+                val cls = module.packages.flatMap { it.classlikes }.first { it.name == "Foo" }
+                val documentation = cls.documentation.values.first()
+                val docTags = documentation.children.single().root.children
+
+                assertEquals("CodeInline<Bar>", ((docTags[0].children[1] as CodeInline).children.first() as Text).body)
+                assertEquals("CodeBlock<Bar>", ((docTags[1] as CodeBlock).children.first() as Text).body)
+            }
+        }
+    }
+}
diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/content/HighlightingTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/content/HighlightingTest.kt
new file mode 100644
index 00000000..a7fb2bde
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/content/HighlightingTest.kt
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package content
+
+import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
+import org.jetbrains.dokka.model.dfs
+import org.jetbrains.dokka.pages.*
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+class HighlightingTest : BaseAbstractTest() {
+    private val configuration = dokkaConfiguration {
+        sourceSets {
+            sourceSet {
+                sourceRoots = listOf("src/")
+                classpath = listOf(commonStdlibPath!!, jvmStdlibPath!!)
+                externalDocumentationLinks = listOf(stdlibExternalDocumentationLink)
+            }
+        }
+    }
+
+    @Test
+    fun `open suspend fun`() {
+        testInline(
+            """
+            |/src/main/kotlin/test/Test.kt
+            |package example
+            |
+            | open suspend fun simpleFun(): String = "Celebrimbor"
+            """,
+            configuration
+        ) {
+            pagesTransformationStage = { module ->
+                val symbol = (module.dfs { it.name == "simpleFun" } as MemberPageNode).content
+                    .dfs { it is ContentGroup && it.dci.kind == ContentKind.Symbol }
+                val children = symbol?.children
+
+                for (it in listOf(
+                    Pair(0, TokenStyle.Keyword), Pair(1, TokenStyle.Keyword), Pair(2, TokenStyle.Keyword),
+                    Pair(4, TokenStyle.Punctuation), Pair(5, TokenStyle.Punctuation), Pair(6, TokenStyle.Operator)
+                ))
+                    assertTrue(children?.get(it.first)?.style?.contains(it.second) == true)
+                assertTrue(children?.get(3)?.children?.first()?.style?.contains(TokenStyle.Function) == true)
+            }
+        }
+    }
+
+    @Test
+    fun `plain typealias of plain class with annotation`() {
+        testInline(
+            """
+                |/src/main/kotlin/common/Test.kt
+                |package example
+                |
+                |@MustBeDocumented
+                |@Target(AnnotationTarget.TYPEALIAS)
+                |annotation class SomeAnnotation
+                |
+                |@SomeAnnotation
+                |typealias PlainTypealias = Int
+                |
+            """.trimMargin(),
+            configuration
+        ) {
+            pagesTransformationStage = { module ->
+                val symbol = (module.dfs { it.name == "example" } as PackagePageNode).content
+                    .dfs { it is ContentGroup && it.dci.kind == ContentKind.Symbol }
+                val children = symbol?.children
+
+                for (it in listOf(
+                    Pair(1, TokenStyle.Keyword), Pair(3, TokenStyle.Operator)
+                ))
+                    assertTrue(children?.get(it.first)?.style?.contains(it.second) == true)
+                val annotation = children?.first()?.children?.first()
+
+                assertTrue(annotation?.children?.get(0)?.style?.contains(TokenStyle.Annotation) == true)
+                assertTrue(annotation?.children?.get(1)?.children?.first()?.style?.contains(TokenStyle.Annotation) == true)
+            }
+        }
+    }
+}
diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt
new file mode 100644
index 00000000..7293b53c
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt
@@ -0,0 +1,351 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package content.annotations
+
+import matchers.content.*
+import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
+import org.jetbrains.dokka.base.utils.firstNotNullOfOrNull
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.pages.ContentPage
+import org.jetbrains.dokka.pages.ContentText
+import org.jetbrains.dokka.pages.MemberPageNode
+import org.jetbrains.dokka.pages.PackagePageNode
+import utils.ParamAttributes
+import utils.assertNotNull
+import utils.bareSignature
+import utils.propertySignature
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+
+class ContentForAnnotationsTest : BaseAbstractTest() {
+
+
+    private val testConfiguration = dokkaConfiguration {
+        sourceSets {
+            sourceSet {
+                sourceRoots = listOf("src/")
+                analysisPlatform = "jvm"
+                classpath += jvmStdlibPath!!
+            }
+        }
+    }
+
+    @Test
+    fun `function with documented annotation`() {
+        testInline(
+            """
+            |/src/main/kotlin/test/source.kt
+            |package test
+            |
+            |@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION,
+            |    AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FIELD
+            |)
+            |@Retention(AnnotationRetention.SOURCE)
+            |@MustBeDocumented
+            |annotation class Fancy
+            |
+            |
+            |@Fancy
+            |fun function(@Fancy abc: String): String {
+            |    return "Hello, " + abc
+            |}
+        """.trimIndent(), testConfiguration
+        ) {
+            pagesTransformationStage = { module ->
+                val page = module.children.single { it.name == "test" }
+                    .children.single { it.name == "function" } as ContentPage
+                page.content.assertNode {
+                    group {
+                        header(1) { +"function" }
+                    }
+                    divergentGroup {
+                        divergentInstance {
+                            divergent {
+                                bareSignature(
+                                    mapOf("Fancy" to emptySet()),
+                                    "",
+                                    "",
+                                    emptySet(),
+                                    "function",
+                                    "String",
+                                    "abc" to ParamAttributes(mapOf("Fancy" to emptySet()), emptySet(), "String")
+                                )
+                            }
+                        }
+                    }
+
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `function with undocumented annotation`() {
+        testInline(
+            """
+            |/src/main/kotlin/test/source.kt
+            |package test
+            |
+            |@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION,
+            |    AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FIELD
+            |)
+            |@Retention(AnnotationRetention.SOURCE)
+            |annotation class Fancy
+            |
+            |@Fancy
+            |fun function(@Fancy abc: String): String {
+            |    return "Hello, " + abc
+            |}
+        """.trimIndent(), testConfiguration
+        ) {
+            pagesTransformationStage = { module ->
+                val page = module.children.single { it.name == "test" }
+                    .children.single { it.name == "function" } as ContentPage
+                page.content.assertNode {
+                    group {
+                        header(1) { +"function" }
+                    }
+                    divergentGroup {
+                        divergentInstance {
+                            divergent {
+                                bareSignature(
+                                    emptyMap(),
+                                    "",
+                                    "",
+                                    emptySet(),
+                                    "function",
+                                    "String",
+                                    "abc" to ParamAttributes(emptyMap(), emptySet(), "String")
+                                )
+                            }
+                        }
+                    }
+
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `property with undocumented annotation`() {
+        testInline(
+            """
+            |/src/main/kotlin/test/source.kt
+            |package test
+            |
+            |@Suppress
+            |val property: Int = 6
+        """.trimIndent(), testConfiguration
+        ) {
+            pagesTransformationStage = { module ->
+                val page = module.children.single { it.name == "test" } as PackagePageNode
+                page.content.assertNode {
+                    propertySignature(emptyMap(), "", "", emptySet(), "val", "property", "Int", "6")
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `property with documented annotation`() {
+        testInline(
+            """
+            |/src/main/kotlin/test/source.kt
+            |package test
+            |
+            |@MustBeDocumented
+            |annotation class Fancy
+            |
+            |@Fancy
+            |val property: Int = 6
+        """.trimIndent(), testConfiguration
+        ) {
+            pagesTransformationStage = { module ->
+                val page = module.children.single { it.name == "test" } as PackagePageNode
+                page.content.assertNode {
+                    propertySignature(mapOf("Fancy" to emptySet()), "", "", emptySet(), "val", "property", "Int", "6")
+                }
+            }
+        }
+    }
+
+
+    @Test
+    fun `rich documented annotation`() {
+        testInline(
+            """
+            |/src/main/kotlin/test/source.kt
+            |package test
+            |
+            |@MustBeDocumented
+            |@Retention(AnnotationRetention.SOURCE)
+            |@Target(AnnotationTarget.PROPERTY)
+            |annotation class BugReport(
+            |    val assignedTo: String = "[none]",
+            |    val testCase: KClass<ABC> = ABC::class,
+            |    val status: Status = Status.UNCONFIRMED,
+            |    val ref: Reference = Reference(value = 1),
+            |    val reportedBy: Array<Reference>,
+            |    val showStopper: Boolean = false
+            |    val previousReport: BugReport?
+            |) {
+            |    enum class Status {
+            |        UNCONFIRMED, CONFIRMED, FIXED, NOTABUG
+            |    }
+            |    class ABC
+            |}
+            |annotation class Reference(val value: Long)
+            |annotation class ReferenceReal(val value: Double)
+            | 
+            |
+            |@BugReport(
+            |    assignedTo = "me",
+            |    testCase = BugReport.ABC::class,
+            |    status = BugReport.Status.FIXED,
+            |    ref = Reference(value = 2u),
+            |    reportedBy = [Reference(value = 2UL), Reference(value = 4L), 
+            |                  ReferenceReal(value = 4.9), ReferenceReal(value = 2f)],
+            |    showStopper = true,
+            |    previousReport = null
+            |)
+            |val ltint: Int = 5
+        """.trimIndent(), testConfiguration
+        ) {
+            documentablesCreationStage = { modules ->
+
+                fun expectedAnnotationValue(name: String, value: AnnotationParameterValue) = AnnotationValue(Annotations.Annotation(
+                    dri = DRI("test", name),
+                    params = mapOf("value" to value),
+                    scope = Annotations.AnnotationScope.DIRECT,
+                    mustBeDocumented = false
+                ))
+                val property = modules.flatMap { it.packages }.flatMap { it.properties }.first()
+                val annotation = property.extra[Annotations]?.let {
+                    it.directAnnotations.entries.firstNotNullOfOrNull { (_, annotations) -> annotations.firstOrNull() }
+                }
+                val annotationParams = annotation?.params ?: emptyMap()
+
+                assertEquals(expectedAnnotationValue("Reference", IntValue(2)), annotationParams["ref"])
+
+                val reportedByParam = ArrayValue(listOf(
+                    expectedAnnotationValue("Reference", LongValue(2)),
+                    expectedAnnotationValue("Reference", LongValue(4)),
+                    expectedAnnotationValue("ReferenceReal", DoubleValue(4.9)),
+                    expectedAnnotationValue("ReferenceReal", FloatValue(2f))
+                ))
+                assertEquals(reportedByParam, annotationParams["reportedBy"])
+                assertEquals(BooleanValue(true), annotationParams["showStopper"])
+                assertEquals(NullValue, annotationParams["previousReport"])
+            }
+
+            pagesTransformationStage = { module ->
+                val page = module.children.single { it.name == "test" } as PackagePageNode
+                page.content.assertNode {
+                    propertySignature(
+                        mapOf(
+                            "BugReport" to setOf(
+                                "assignedTo",
+                                "testCase",
+                                "status",
+                                "ref",
+                                "reportedBy",
+                                "showStopper",
+                                "previousReport"
+                            )
+                        ), "", "", emptySet(), "val", "ltint", "Int", "5"
+                    )
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `JvmName for property with setter and getter`() {
+        testInline(
+            """
+                |/src/main/kotlin/test/source.kt
+                |package test
+                |@get:JvmName("xd")
+                |@set:JvmName("asd")
+                |var property: String
+                |    get() = ""
+                |    set(value) {}
+            """.trimIndent(), testConfiguration
+        ) {
+            documentablesCreationStage = { modules ->
+                fun expectedAnnotation(name: String) = Annotations.Annotation(
+                    dri = DRI("kotlin.jvm", "JvmName"),
+                    params = mapOf("name" to StringValue(name)),
+                    scope = Annotations.AnnotationScope.DIRECT,
+                    mustBeDocumented = true
+                )
+
+                val property = modules.flatMap { it.packages }.flatMap { it.properties }.first()
+                val getterAnnotation = property.getter?.extra?.get(Annotations)?.let {
+                    it.directAnnotations.entries.firstNotNullOfOrNull { (_, annotations) -> annotations.firstOrNull() }
+                }
+                val setterAnnotation = property.getter?.extra?.get(Annotations)?.let {
+                    it.directAnnotations.entries.firstNotNullOfOrNull { (_, annotations) -> annotations.firstOrNull() }
+                }
+
+                assertEquals(expectedAnnotation("xd"), getterAnnotation)
+                assertTrue(getterAnnotation?.mustBeDocumented!!)
+                assertEquals(Annotations.AnnotationScope.DIRECT, getterAnnotation.scope)
+
+                assertEquals(expectedAnnotation("asd"), setterAnnotation)
+                assertTrue(setterAnnotation?.mustBeDocumented!!)
+                assertEquals(Annotations.AnnotationScope.DIRECT, setterAnnotation.scope)
+            }
+        }
+    }
+
+    @Test
+    fun `annotated bounds in Kotlin`() {
+        testInline(
+            """
+             |/src/main/kotlin/test/source.kt
+             |@MustBeDocumented
+             |@Target(AnnotationTarget.TYPE_PARAMETER)
+             |annotation class Hello(val bar: String)
+             |fun <T: @Hello("abc") String> foo(arg: String): List<T> = TODO()
+            """.trimIndent(), testConfiguration
+        ) {
+            pagesTransformationStage = { root ->
+                val fooPage = root.dfs { it.name == "foo" } as MemberPageNode
+                fooPage.content.dfs { it is ContentText && it.text == "Hello" }.assertNotNull()
+            }
+        }
+    }
+
+    @Test
+    fun `annotated bounds in Java`() {
+        testInline(
+            """
+             |/src/main/java/demo/AnnotationTest.java
+             |package demo;
+             |import java.lang.annotation.*;
+             |import java.util.List;
+             |@Documented
+             |@Target({ElementType.TYPE_USE, ElementType.TYPE})
+             |@interface Hello {
+             |   public String bar() default "";
+             |}
+             |public class AnnotationTest {
+             |    public <T extends @Hello(bar = "baz") String> List<T> foo() {
+             |        return null;
+             |    }
+             |}
+            """.trimIndent(), testConfiguration
+        ) {
+            pagesTransformationStage = { root ->
+                val fooPage = root.dfs { it.name == "foo" } as MemberPageNode
+                fooPage.content.dfs { it is ContentText && it.text == "Hello" }.assertNotNull()
+            }
+        }
+    }
+}
diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/content/annotations/FileLevelJvmNameTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/content/annotations/FileLevelJvmNameTest.kt
new file mode 100644
index 00000000..5809d7df
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/content/annotations/FileLevelJvmNameTest.kt
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package content.annotations
+
+import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.Annotations
+import org.jetbrains.dokka.model.StringValue
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
+import kotlin.test.assertEquals
+
+class FileLevelJvmNameTest : BaseAbstractTest() {
+    private val testConfiguration = dokkaConfiguration {
+        sourceSets {
+            sourceSet {
+                sourceRoots = listOf("src/")
+                analysisPlatform = "jvm"
+                classpath += jvmStdlibPath!!
+            }
+        }
+    }
+
+    companion object {
+        private const val functionTest =
+            """
+            |/src/main/kotlin/test/source.kt
+            |@file:JvmName("CustomJvmName")
+            |package test
+            |
+            |fun function(abc: String): String {
+            |    return "Hello, " + abc
+            |}
+        """
+
+        private const val extensionFunctionTest =
+            """
+            |/src/main/kotlin/test/source.kt
+            |@file:JvmName("CustomJvmName")
+            |package test
+            |
+            |fun String.function(abc: String): String {
+            |    return "Hello, " + abc
+            |}
+        """
+
+        private const val propertyTest =
+            """
+            |/src/main/kotlin/test/source.kt
+            |@file:JvmName("CustomJvmName")
+            |package test
+            |
+            |val property: String
+            |   get() = ""
+        """
+
+        private const val extensionPropertyTest =
+            """
+            |/src/main/kotlin/test/source.kt
+            |@file:JvmName("CustomJvmName")
+            |package test
+            |
+            |val String.property: String
+            |   get() = ""
+        """
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = [functionTest, extensionFunctionTest])
+    fun `jvm name should be included in functions extra`(query: String) {
+        testInline(
+            query.trimIndent(), testConfiguration
+        ) {
+            documentablesCreationStage = { modules ->
+                val expectedAnnotation = Annotations.Annotation(
+                    dri = DRI("kotlin.jvm", "JvmName"),
+                    params = mapOf("name" to StringValue("CustomJvmName")),
+                    scope = Annotations.AnnotationScope.FILE,
+                    mustBeDocumented = true
+                )
+                val function = modules.flatMap { it.packages }.first().functions.first()
+                val annotation = function.extra[Annotations]?.fileLevelAnnotations?.entries?.first()?.value?.single()
+                assertEquals(emptyMap(), function.extra[Annotations]?.directAnnotations)
+                assertEquals(expectedAnnotation, annotation)
+                assertEquals(expectedAnnotation.scope, annotation?.scope)
+                assertEquals(expectedAnnotation.mustBeDocumented, annotation?.mustBeDocumented)
+            }
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = [propertyTest, extensionPropertyTest])
+    fun `jvm name should be included in properties extra`(query: String) {
+        testInline(
+            query.trimIndent(), testConfiguration
+        ) {
+            documentablesCreationStage = { modules ->
+                val expectedAnnotation = Annotations.Annotation(
+                    dri = DRI("kotlin.jvm", "JvmName"),
+                    params = mapOf("name" to StringValue("CustomJvmName")),
+                    scope = Annotations.AnnotationScope.FILE,
+                    mustBeDocumented = true
+                )
+                val properties = modules.flatMap { it.packages }.first().properties.first()
+                val annotation = properties.extra[Annotations]?.fileLevelAnnotations?.entries?.first()?.value?.single()
+                assertEquals(emptyMap(), properties.extra[Annotations]?.directAnnotations)
+                assertEquals(expectedAnnotation, annotation)
+                assertEquals(expectedAnnotation.scope, annotation?.scope)
+                assertEquals(expectedAnnotation.mustBeDocumented, annotation?.mustBeDocumented)
+            }
+        }
+    }
+}
diff --git a/dokka-subprojects/plugin-base/src/test/kotlin/content/annotations/JavaDeprecatedTest.kt b/dokka-subprojects/plugin-base/src/test/kotlin/content/annotations/JavaDeprecatedTest.kt
new file mode 100644
index 00000000..5a2ff93e
--- /dev/null
+++ b/dokka-subprojects/plugin-base/src/test/kotlin/content/annotations/JavaDeprecatedTest.kt
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package content.annotations
+
+import matchers.content.*
+import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
+import org.jetbrains.dokka.base.transformers.documentables.deprecatedAnnotation
+import org.jetbrains.dokka.base.transformers.documentables.isDeprecated
+import org.jetbrains.dokka.model.Documentable
+import org.jetbrains.dokka.model.properties.WithExtraProperties
+import org.jetbrains.dokka.pages.ContentPage
+import org.jetbrains.dokka.pages.ContentStyle
+import utils.pWrapped
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+
+class JavaDeprecatedTest : BaseAbstractTest() {
+
+    private val testConfiguration = dokkaConfiguration {
+        sourceSets {
+            sourceSet {
+                sourceRoots = listOf("src/")
+                analysisPlatform = "jvm"
+            }
+        }
+    }
+
+    @Test
+    @Suppress("UNCHECKED_CAST")
+    fun `should assert util functions for deprecation`() {
+        testInline(
+            """
+            |/src/main/kotlin/deprecated/DeprecatedJavaClass.java
+            |package deprecated
+            |
+            |@Deprecated(forRemoval = true)
+            |public class DeprecatedJavaClass {}
+            """.trimIndent(),
+            testConfiguration
+        ) {
+            documentablesTransformationStage = { module ->
+                val deprecatedClass = module.children
+                    .single { it.name == "deprecated" }.children
+                    .single { it.name == "DeprecatedJavaClass" }
+
+                val isDeprecated = (deprecatedClass as WithExtraProperties<out Documentable>).isDeprecated()