<lambda>null1 package org.jetbrains.dokka.tests
2
3 import org.jetbrains.dokka.Content
4 import org.jetbrains.dokka.NodeKind
5 import org.jetbrains.dokka.RefKind
6 import org.junit.Assert.assertEquals
7 import org.junit.Assert.assertTrue
8 import org.junit.Test
9
10 class ClassTest {
11 @Test fun emptyClass() {
12 verifyModel("testdata/classes/emptyClass.kt") { model ->
13 with(model.members.single().members.single()) {
14 assertEquals(NodeKind.Class, kind)
15 assertEquals("Klass", name)
16 assertEquals(Content.Empty, content)
17 assertEquals("<init>", members.single().name)
18 assertTrue(links.none())
19 }
20 }
21 }
22
23 @Test fun emptyObject() {
24 verifyModel("testdata/classes/emptyObject.kt") { model ->
25 with(model.members.single().members.single()) {
26 assertEquals(NodeKind.Object, kind)
27 assertEquals("Obj", name)
28 assertEquals(Content.Empty, content)
29 assertTrue(members.none())
30 assertTrue(links.none())
31 }
32 }
33 }
34
35 @Test fun classWithConstructor() {
36 verifyModel("testdata/classes/classWithConstructor.kt") { model ->
37 with (model.members.single().members.single()) {
38 assertEquals(NodeKind.Class, kind)
39 assertEquals("Klass", name)
40 assertEquals(Content.Empty, content)
41 assertTrue(links.none())
42
43 assertEquals(1, members.count())
44 with(members.elementAt(0)) {
45 assertEquals("<init>", name)
46 assertEquals(Content.Empty, content)
47 assertEquals(NodeKind.Constructor, kind)
48 assertEquals(3, details.count())
49 assertEquals("public", details.elementAt(0).name)
50 with(details.elementAt(2)) {
51 assertEquals("name", name)
52 assertEquals(NodeKind.Parameter, kind)
53 assertEquals(Content.Empty, content)
54 assertEquals("String", detail(NodeKind.Type).name)
55 assertTrue(links.none())
56 assertTrue(members.none())
57 }
58 assertTrue(links.none())
59 assertTrue(members.none())
60 }
61 }
62 }
63 }
64
65 @Test fun classWithFunction() {
66 verifyModel("testdata/classes/classWithFunction.kt") { model ->
67 with(model.members.single().members.single()) {
68 assertEquals(NodeKind.Class, kind)
69 assertEquals("Klass", name)
70 assertEquals(Content.Empty, content)
71 assertTrue(links.none())
72
73 assertEquals(2, members.count())
74 with(members.elementAt(0)) {
75 assertEquals("<init>", name)
76 assertEquals(Content.Empty, content)
77 assertEquals(NodeKind.Constructor, kind)
78 assertEquals(2, details.count())
79 assertEquals("public", details.elementAt(0).name)
80 assertTrue(links.none())
81 assertTrue(members.none())
82 }
83 with(members.elementAt(1)) {
84 assertEquals("fn", name)
85 assertEquals(Content.Empty, content)
86 assertEquals(NodeKind.Function, kind)
87 assertEquals("Unit", detail(NodeKind.Type).name)
88 assertTrue(links.none())
89 assertTrue(members.none())
90 }
91 }
92 }
93 }
94
95 @Test fun classWithProperty() {
96 verifyModel("testdata/classes/classWithProperty.kt") { model ->
97 with(model.members.single().members.single()) {
98 assertEquals(NodeKind.Class, kind)
99 assertEquals("Klass", name)
100 assertEquals(Content.Empty, content)
101 assertTrue(links.none())
102
103 assertEquals(2, members.count())
104 with(members.elementAt(0)) {
105 assertEquals("<init>", name)
106 assertEquals(Content.Empty, content)
107 assertEquals(NodeKind.Constructor, kind)
108 assertEquals(2, details.count())
109 assertEquals("public", details.elementAt(0).name)
110 assertTrue(members.none())
111 assertTrue(links.none())
112 }
113 with(members.elementAt(1)) {
114 assertEquals("name", name)
115 assertEquals(Content.Empty, content)
116 assertEquals(NodeKind.Property, kind)
117 assertEquals("String", detail(NodeKind.Type).name)
118 assertTrue(members.none())
119 assertTrue(links.none())
120 }
121 }
122 }
123 }
124
125 @Test fun classWithCompanionObject() {
126 verifyModel("testdata/classes/classWithCompanionObject.kt") { model ->
127 with(model.members.single().members.single()) {
128 assertEquals(NodeKind.Class, kind)
129 assertEquals("Klass", name)
130 assertEquals(Content.Empty, content)
131 assertTrue(links.none())
132
133 assertEquals(3, members.count())
134 with(members.elementAt(0)) {
135 assertEquals("<init>", name)
136 assertEquals(Content.Empty, content)
137 }
138 with(members.elementAt(1)) {
139 assertEquals("foo", name)
140 assertEquals(NodeKind.CompanionObjectFunction, kind)
141 assertTrue(members.none())
142 assertTrue(links.none())
143 }
144 with(members.elementAt(2)) {
145 assertEquals("x", name)
146 assertEquals(NodeKind.CompanionObjectProperty, kind)
147 assertTrue(members.none())
148 assertTrue(links.none())
149 }
150 }
151 }
152 }
153
154 @Test fun annotatedClass() {
155 verifyPackageMember("testdata/classes/annotatedClass.kt", withKotlinRuntime = true) { cls ->
156 assertEquals(1, cls.annotations.count())
157 with(cls.annotations[0]) {
158 assertEquals("Strictfp", name)
159 assertEquals(Content.Empty, content)
160 assertEquals(NodeKind.Annotation, kind)
161 }
162 }
163 }
164
165 @Test fun dataClass() {
166 verifyPackageMember("testdata/classes/dataClass.kt") { cls ->
167 val modifiers = cls.details(NodeKind.Modifier).map { it.name }
168 assertTrue("data" in modifiers)
169 }
170 }
171
172 @Test fun sealedClass() {
173 verifyPackageMember("testdata/classes/sealedClass.kt") { cls ->
174 val modifiers = cls.details(NodeKind.Modifier).map { it.name }
175 assertEquals(1, modifiers.count { it == "sealed" })
176 }
177 }
178
179 @Test fun annotatedClassWithAnnotationParameters() {
180 verifyModel("testdata/classes/annotatedClassWithAnnotationParameters.kt") { model ->
181 with(model.members.single().members.single()) {
182 with(deprecation!!) {
183 assertEquals("Deprecated", name)
184 // assertEquals(Content.Empty, content) // this is now an empty MutableContent instead
185 assertEquals(NodeKind.Annotation, kind)
186 assertEquals(1, details.count())
187 with(details[0]) {
188 assertEquals(NodeKind.Parameter, kind)
189 assertEquals(1, details.count())
190 with(details[0]) {
191 assertEquals(NodeKind.Value, kind)
192 assertEquals("\"should no longer be used\"", name)
193 }
194 }
195 }
196 }
197 }
198 }
199
200 @Test fun javaAnnotationClass() {
201 verifyModel("testdata/classes/javaAnnotationClass.kt", withJdk = true) { model ->
202 with(model.members.single().members.single()) {
203 assertEquals(1, annotations.count())
204 with(annotations[0]) {
205 assertEquals("Retention", name)
206 assertEquals(Content.Empty, content)
207 assertEquals(NodeKind.Annotation, kind)
208 with(details[0]) {
209 assertEquals(NodeKind.Parameter, kind)
210 assertEquals(1, details.count())
211 with(details[0]) {
212 assertEquals(NodeKind.Value, kind)
213 assertEquals("RetentionPolicy.SOURCE", name)
214 }
215 }
216 }
217 }
218 }
219 }
220
221 @Test fun notOpenClass() {
222 verifyModel("testdata/classes/notOpenClass.kt") { model ->
223 with(model.members.single().members.first { it.name == "D"}.members.first { it.name == "f" }) {
224 val modifiers = details(NodeKind.Modifier)
225 assertEquals(2, modifiers.size)
226 assertEquals("final", modifiers[1].name)
227
228 val overrideReferences = references(RefKind.Override)
229 assertEquals(1, overrideReferences.size)
230 }
231 }
232 }
233
234 @Test fun indirectOverride() {
235 verifyModel("testdata/classes/indirectOverride.kt") { model ->
236 with(model.members.single().members.first { it.name == "E"}.members.first { it.name == "foo" }) {
237 val modifiers = details(NodeKind.Modifier)
238 assertEquals(2, modifiers.size)
239 assertEquals("final", modifiers[1].name)
240
241 val overrideReferences = references(RefKind.Override)
242 assertEquals(1, overrideReferences.size)
243 }
244 }
245 }
246
247 @Test fun innerClass() {
248 verifyPackageMember("testdata/classes/innerClass.kt") { cls ->
249 val innerClass = cls.members.single { it.name == "D" }
250 val modifiers = innerClass.details(NodeKind.Modifier)
251 assertEquals(3, modifiers.size)
252 assertEquals("inner", modifiers[2].name)
253 }
254 }
255
256 @Test fun companionObjectExtension() {
257 verifyModel("testdata/classes/companionObjectExtension.kt") { model ->
258 val pkg = model.members.single()
259 val cls = pkg.members.single { it.name == "Foo" }
260 val extensions = cls.extensions.filter { it.kind == NodeKind.CompanionObjectProperty }
261 assertEquals(1, extensions.size)
262 }
263 }
264
265 @Test fun secondaryConstructor() {
266 verifyPackageMember("testdata/classes/secondaryConstructor.kt") { cls ->
267 val constructors = cls.members(NodeKind.Constructor)
268 assertEquals(2, constructors.size)
269 with (constructors.first { it.details(NodeKind.Parameter).size == 1}) {
270 assertEquals("<init>", name)
271 assertEquals("This is a secondary constructor.", summary.toTestString())
272 }
273 }
274 }
275
276 @Test fun sinceKotlin() {
277 verifyModel("testdata/classes/sinceKotlin.kt") { model ->
278 with(model.members.single().members.single()) {
279 assertEquals(listOf("Kotlin 1.1"), platforms)
280 }
281 }
282 }
283
284 @Test fun privateCompanionObject() {
285 verifyModel("testdata/classes/privateCompanionObject.kt", includeNonPublic = false) { model ->
286 with(model.members.single().members.single()) {
287 assertEquals(0, members(NodeKind.CompanionObjectFunction).size)
288 assertEquals(0, members(NodeKind.CompanionObjectProperty).size)
289 }
290 }
291 }
292
293 }
294