aboutsummaryrefslogtreecommitdiff
path: root/plugins/base/src/test/kotlin/model/annotations/JavaAnnotationsForParametersTest.kt
blob: 5679010d7c08284409a59f8f913becc1ab55d149 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
package model.annotations

import org.jetbrains.dokka.links.DRI
import org.jetbrains.dokka.model.Annotations
import org.jetbrains.dokka.model.DClass
import org.jetbrains.dokka.model.DFunction
import org.junit.jupiter.api.Test
import utils.AbstractModelTest
import kotlin.test.assertEquals

class JavaAnnotationsForParametersTest : AbstractModelTest("/src/main/kotlin/java/Test.java", "java") {

    @Test
    fun `function with deprecated parameter`() {
        inlineModelTest(
            """
            |class Test {
            |    public void fn(@Deprecated String name) {}
            |}
        """.trimIndent()
        ) {
            with((this / "java" / "Test").cast<DClass>()) {
                with((this / "fn").cast<DFunction>()) {
                    val dri =
                        parameters.first().extra[Annotations]?.directAnnotations?.flatMap { it.value }?.map { it.dri }
                    assertEquals(listOf(DRI("java.lang", "Deprecated")), dri)
                }
            }
        }
    }

    @Test
    fun `function with parameter that has custom annotation`() {
        inlineModelTest(
            """
            |@Retention(RetentionPolicy.RUNTIME)
            |@Target(ElementType.PARAMETER)
            |public @interface Hello {
            |    public String bar() default "";
            |}
            |class Test {
            |   public void foo(@Hello(bar = "baz") String arg){ }
            |}
        """.trimIndent()
        ) {
            with((this / "java" / "Test").cast<DClass>()) {
                with((this / "foo").cast<DFunction>()) {
                    val annotations =
                        parameters.first().extra[Annotations]?.directAnnotations?.flatMap { it.value }
                    val driOfHello = DRI("java", "Hello")
                    val annotationsValues = annotations?.flatMap { it.params.values }?.map { it.toString() }?.toList()

                    assertEquals(listOf(driOfHello), annotations?.map { it.dri })
                    assertEquals(listOf("baz"), annotationsValues)
                }
            }
        }
    }

    @Test
    fun `function with annotated generic parameter`() {
        inlineModelTest(
            """
            |@Retention(RetentionPolicy.RUNTIME)
            |@Target(ElementType.TYPE_PARAMETER)
            |@interface Hello {
            |    public String bar() default "";
            |}
            |class Test {
            |   public <@Hello(bar = "baz") T> List<T> foo() {
            |        return null;
            |   }
            |}
        """.trimIndent()
        ) {
            with((this / "java" / "Test").cast<DClass>()) {
                with((this / "foo").cast<DFunction>()) {
                    val annotations = generics.first().extra[Annotations]?.directAnnotations?.flatMap { it.value }
                    val driOfHello = DRI("java", "Hello")
                    val annotationsValues = annotations?.flatMap { it.params.values }?.map { it.toString() }?.toList()

                    assertEquals(listOf(driOfHello), annotations?.map { it.dri })
                    assertEquals(listOf("baz"), annotationsValues)
                }
            }
        }
    }
}