<lambda>null1 package org.jetbrains.dokka.tests
2
3 import org.jetbrains.dokka.NodeKind
4 import org.jetbrains.dokka.RefKind
5 import org.junit.Assert.*
6 import org.junit.Ignore
7 import org.junit.Test
8
9 public class JavaTest {
10 @Test fun function() {
11 verifyJavaPackageMember("testdata/java/member.java") { cls ->
12 assertEquals("Test", cls.name)
13 assertEquals(NodeKind.Class, cls.kind)
14 with(cls.members(NodeKind.Function).single()) {
15 assertEquals("fn", name)
16 assertEquals("Summary for Function", content.summary.toTestString().trimEnd())
17 assertEquals(3, content.sections.size)
18 with(content.sections[0]) {
19 assertEquals("Parameters", tag)
20 assertEquals("name", subjectName)
21 assertEquals("render(Type:String,SUMMARY): is String parameter", toTestString())
22 }
23 with(content.sections[1]) {
24 assertEquals("Parameters", tag)
25 assertEquals("value", subjectName)
26 assertEquals("render(Type:Int,SUMMARY): is int parameter", toTestString())
27 }
28 with(content.sections[2]) {
29 assertEquals("Author", tag)
30 assertEquals("yole", toTestString())
31 }
32 assertEquals("Unit", detail(NodeKind.Type).name)
33 assertTrue(members.none())
34 assertTrue(links.none())
35 with(details.first { it.name == "name" }) {
36 assertEquals(NodeKind.Parameter, kind)
37 assertEquals("String", detail(NodeKind.Type).name)
38 }
39 with(details.first { it.name == "value" }) {
40 assertEquals(NodeKind.Parameter, kind)
41 assertEquals("Int", detail(NodeKind.Type).name)
42 }
43 }
44 }
45 }
46
47 @Test fun memberWithModifiers() {
48 verifyJavaPackageMember("testdata/java/memberWithModifiers.java") { cls ->
49 val modifiers = cls.details(NodeKind.Modifier).map { it.name }
50 assertTrue("abstract" in modifiers)
51 with(cls.members.single { it.name == "fn" }) {
52 assertEquals("protected", details[0].name)
53 }
54 with(cls.members.single { it.name == "openFn" }) {
55 assertEquals("open", details[1].name)
56 }
57 }
58 }
59
60 @Test fun superClass() {
61 verifyJavaPackageMember("testdata/java/superClass.java") { cls ->
62 val superTypes = cls.details(NodeKind.Supertype)
63 assertEquals(2, superTypes.size)
64 assertEquals("Exception", superTypes[0].name)
65 assertEquals("Cloneable", superTypes[1].name)
66 }
67 }
68
69 @Test fun arrayType() {
70 verifyJavaPackageMember("testdata/java/arrayType.java") { cls ->
71 with(cls.members(NodeKind.Function).single()) {
72 val type = detail(NodeKind.Type)
73 assertEquals("Array", type.name)
74 assertEquals("String", type.detail(NodeKind.Type).name)
75 with(details(NodeKind.Parameter).single()) {
76 val parameterType = detail(NodeKind.Type)
77 assertEquals("IntArray", parameterType.name)
78 }
79 }
80 }
81 }
82
83 @Test fun typeParameter() {
84 verifyJavaPackageMember("testdata/java/typeParameter.java") { cls ->
85 val typeParameters = cls.details(NodeKind.TypeParameter)
86 with(typeParameters.single()) {
87 assertEquals("T", name)
88 with(detail(NodeKind.UpperBound)) {
89 assertEquals("Comparable", name)
90 assertEquals("T", detail(NodeKind.Type).name)
91 }
92 }
93 with(cls.members(NodeKind.Function).single()) {
94 val methodTypeParameters = details(NodeKind.TypeParameter)
95 with(methodTypeParameters.single()) {
96 assertEquals("E", name)
97 }
98 }
99 }
100 }
101
102 @Test fun constructors() {
103 verifyJavaPackageMember("testdata/java/constructors.java") { cls ->
104 val constructors = cls.members(NodeKind.Constructor)
105 assertEquals(2, constructors.size)
106 with(constructors[0]) {
107 assertEquals("<init>", name)
108 }
109 }
110 }
111
112 @Test fun innerClass() {
113 verifyJavaPackageMember("testdata/java/InnerClass.java") { cls ->
114 val innerClass = cls.members(NodeKind.Class).single()
115 assertEquals("D", innerClass.name)
116 }
117 }
118
119 @Test fun varargs() {
120 verifyJavaPackageMember("testdata/java/varargs.java") { cls ->
121 val fn = cls.members(NodeKind.Function).single()
122 val param = fn.detail(NodeKind.Parameter)
123 assertEquals("vararg", param.details(NodeKind.Modifier).first().name)
124 val psiType = param.detail(NodeKind.Type)
125 assertEquals("String", psiType.name)
126 assertTrue(psiType.details(NodeKind.Type).isEmpty())
127 }
128 }
129
130 @Test fun fields() {
131 verifyJavaPackageMember("testdata/java/field.java") { cls ->
132 val i = cls.members(NodeKind.Property).single { it.name == "i" }
133 assertEquals("Int", i.detail(NodeKind.Type).name)
134 assertTrue("var" in i.details(NodeKind.Modifier).map { it.name })
135
136 val s = cls.members(NodeKind.Property).single { it.name == "s" }
137 assertEquals("String", s.detail(NodeKind.Type).name)
138 assertFalse("var" in s.details(NodeKind.Modifier).map { it.name })
139 assertTrue("static" in s.details(NodeKind.Modifier).map { it.name })
140 }
141 }
142
143 @Test fun staticMethod() {
144 verifyJavaPackageMember("testdata/java/staticMethod.java") { cls ->
145 val m = cls.members(NodeKind.Function).single { it.name == "foo" }
146 assertTrue("static" in m.details(NodeKind.Modifier).map { it.name })
147 }
148 }
149
150 /**
151 * `@suppress` not supported in Java!
152 *
153 * [Proposed tags](http://www.oracle.com/technetwork/java/javase/documentation/proposed-tags-142378.html)
154 * Proposed tag `@exclude` for it, but not supported yet
155 */
156 @Ignore("@suppress not supported in Java!") @Test fun suppressTag() {
157 verifyJavaPackageMember("testdata/java/suppressTag.java") { cls ->
158 assertEquals(1, cls.members(NodeKind.Function).size)
159 }
160 }
161
162 @Test fun hideAnnotation() {
163 verifyJavaPackageMember("testdata/java/hideAnnotation.java") { cls ->
164 assertEquals(1, cls.members(NodeKind.Function).size)
165 assertEquals(1, cls.members(NodeKind.Property).size)
166
167 // The test file contains two classes, one of which is hidden.
168 // The test for @hide annotation on classes is via verifyJavaPackageMember(),
169 // which will throw an IllegalArgumentException if it detects more than one class.
170 }
171 }
172
173 @Test fun annotatedAnnotation() {
174 verifyJavaPackageMember("testdata/java/annotatedAnnotation.java") { cls ->
175 assertEquals(1, cls.annotations.size)
176 with(cls.annotations[0]) {
177 assertEquals(1, details.count())
178 with(details[0]) {
179 assertEquals(NodeKind.Parameter, kind)
180 assertEquals(1, details.count())
181 with(details[0]) {
182 assertEquals(NodeKind.Value, kind)
183 assertEquals("[AnnotationTarget.FIELD, AnnotationTarget.CLASS, AnnotationTarget.FILE, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER]", name)
184 }
185 }
186 }
187 }
188 }
189
190 @Test fun deprecation() {
191 verifyJavaPackageMember("testdata/java/deprecation.java") { cls ->
192 val fn = cls.members(NodeKind.Function).single()
193 assertEquals("This should no longer be used", fn.deprecation!!.content.toTestString())
194 }
195 }
196
197 @Test fun javaLangObject() {
198 verifyJavaPackageMember("testdata/java/javaLangObject.java") { cls ->
199 val fn = cls.members(NodeKind.Function).single()
200 assertEquals("Any", fn.detail(NodeKind.Type).name)
201 }
202 }
203
204 @Test fun enumValues() {
205 verifyJavaPackageMember("testdata/java/enumValues.java") { cls ->
206 val superTypes = cls.details(NodeKind.Supertype)
207 assertEquals(1, superTypes.size)
208 assertEquals(1, cls.members(NodeKind.EnumItem).size)
209 }
210 }
211
212 @Test fun inheritorLinks() {
213 verifyJavaPackageMember("testdata/java/InheritorLinks.java") { cls ->
214 val fooClass = cls.members.single { it.name == "Foo" }
215 val inheritors = fooClass.references(RefKind.Inheritor)
216 assertEquals(1, inheritors.size)
217 }
218 }
219 }
220