| package org.jetbrains.dokka.tests |
| |
| import org.jetbrains.dokka.NodeKind |
| import org.jetbrains.dokka.RefKind |
| import org.junit.Assert.* |
| import org.junit.Ignore |
| import org.junit.Test |
| |
| public class JavaTest { |
| @Test fun function() { |
| verifyJavaPackageMember("testdata/java/member.java") { cls -> |
| assertEquals("Test", cls.name) |
| assertEquals(NodeKind.Class, cls.kind) |
| with(cls.members(NodeKind.Function).single()) { |
| assertEquals("fn", name) |
| assertEquals("Summary for Function", content.summary.toTestString().trimEnd()) |
| assertEquals(3, content.sections.size) |
| with(content.sections[0]) { |
| assertEquals("Parameters", tag) |
| assertEquals("name", subjectName) |
| assertEquals("render(Type:String,SUMMARY): is String parameter", toTestString()) |
| } |
| with(content.sections[1]) { |
| assertEquals("Parameters", tag) |
| assertEquals("value", subjectName) |
| assertEquals("render(Type:String,SUMMARY): is int parameter", toTestString()) |
| } |
| with(content.sections[2]) { |
| assertEquals("Author", tag) |
| assertEquals("yole", toTestString()) |
| } |
| assertEquals("Unit", detail(NodeKind.Type).name) |
| assertTrue(members.none()) |
| assertTrue(links.none()) |
| with(details.first { it.name == "name" }) { |
| assertEquals(NodeKind.Parameter, kind) |
| assertEquals("String", detail(NodeKind.Type).name) |
| } |
| with(details.first { it.name == "value" }) { |
| assertEquals(NodeKind.Parameter, kind) |
| assertEquals("Int", detail(NodeKind.Type).name) |
| } |
| } |
| } |
| } |
| |
| @Test fun memberWithModifiers() { |
| verifyJavaPackageMember("testdata/java/memberWithModifiers.java") { cls -> |
| val modifiers = cls.details(NodeKind.Modifier).map { it.name } |
| assertTrue("abstract" in modifiers) |
| with(cls.members.single { it.name == "fn" }) { |
| assertEquals("protected", details[0].name) |
| } |
| with(cls.members.single { it.name == "openFn" }) { |
| assertEquals("open", details[1].name) |
| } |
| } |
| } |
| |
| @Test fun superClass() { |
| verifyJavaPackageMember("testdata/java/superClass.java") { cls -> |
| val superTypes = cls.details(NodeKind.Supertype) |
| assertEquals(2, superTypes.size) |
| assertEquals("Exception", superTypes[0].name) |
| assertEquals("Cloneable", superTypes[1].name) |
| } |
| } |
| |
| @Test fun arrayType() { |
| verifyJavaPackageMember("testdata/java/arrayType.java") { cls -> |
| with(cls.members(NodeKind.Function).single()) { |
| val type = detail(NodeKind.Type) |
| assertEquals("Array", type.name) |
| assertEquals("String", type.detail(NodeKind.Type).name) |
| with(details(NodeKind.Parameter).single()) { |
| val parameterType = detail(NodeKind.Type) |
| assertEquals("IntArray", parameterType.name) |
| } |
| } |
| } |
| } |
| |
| @Test fun typeParameter() { |
| verifyJavaPackageMember("testdata/java/typeParameter.java") { cls -> |
| val typeParameters = cls.details(NodeKind.TypeParameter) |
| with(typeParameters.single()) { |
| assertEquals("T", name) |
| with(detail(NodeKind.UpperBound)) { |
| assertEquals("Comparable", name) |
| assertEquals("T", detail(NodeKind.Type).name) |
| } |
| } |
| with(cls.members(NodeKind.Function).single()) { |
| val methodTypeParameters = details(NodeKind.TypeParameter) |
| with(methodTypeParameters.single()) { |
| assertEquals("E", name) |
| } |
| } |
| } |
| } |
| |
| @Test fun constructors() { |
| verifyJavaPackageMember("testdata/java/constructors.java") { cls -> |
| val constructors = cls.members(NodeKind.Constructor) |
| assertEquals(2, constructors.size) |
| with(constructors[0]) { |
| assertEquals("<init>", name) |
| } |
| } |
| } |
| |
| @Test fun innerClass() { |
| verifyJavaPackageMember("testdata/java/InnerClass.java") { cls -> |
| val innerClass = cls.members(NodeKind.Class).single() |
| assertEquals("D", innerClass.name) |
| } |
| } |
| |
| @Test fun varargs() { |
| verifyJavaPackageMember("testdata/java/varargs.java") { cls -> |
| val fn = cls.members(NodeKind.Function).single() |
| val param = fn.detail(NodeKind.Parameter) |
| assertEquals("vararg", param.details(NodeKind.Modifier).first().name) |
| val psiType = param.detail(NodeKind.Type) |
| assertEquals("String", psiType.name) |
| assertTrue(psiType.details(NodeKind.Type).isEmpty()) |
| } |
| } |
| |
| @Test fun fields() { |
| verifyJavaPackageMember("testdata/java/field.java") { cls -> |
| val i = cls.members(NodeKind.Property).single { it.name == "i" } |
| assertEquals("Int", i.detail(NodeKind.Type).name) |
| assertTrue("var" in i.details(NodeKind.Modifier).map { it.name }) |
| |
| val s = cls.members(NodeKind.Property).single { it.name == "s" } |
| assertEquals("String", s.detail(NodeKind.Type).name) |
| assertFalse("var" in s.details(NodeKind.Modifier).map { it.name }) |
| assertTrue("static" in s.details(NodeKind.Modifier).map { it.name }) |
| } |
| } |
| |
| @Test fun staticMethod() { |
| verifyJavaPackageMember("testdata/java/staticMethod.java") { cls -> |
| val m = cls.members(NodeKind.Function).single { it.name == "foo" } |
| assertTrue("static" in m.details(NodeKind.Modifier).map { it.name }) |
| } |
| } |
| |
| /** |
| * `@suppress` not supported in Java! |
| * |
| * [Proposed tags](http://www.oracle.com/technetwork/java/javase/documentation/proposed-tags-142378.html) |
| * Proposed tag `@exclude` for it, but not supported yet |
| */ |
| @Ignore("@suppress not supported in Java!") @Test fun suppressTag() { |
| verifyJavaPackageMember("testdata/java/suppressTag.java") { cls -> |
| assertEquals(1, cls.members(NodeKind.Function).size) |
| } |
| } |
| |
| @Test fun hideAnnotation() { |
| verifyJavaPackageMember("testdata/java/hideAnnotation.java") { cls -> |
| assertEquals(1, cls.members(NodeKind.Function).size) |
| assertEquals(1, cls.members(NodeKind.Property).size) |
| |
| // The test file contains two classes, one of which is hidden. |
| // The test for @hide annotation on classes is via verifyJavaPackageMember(), |
| // which will throw an IllegalArgumentException if it detects more than one class. |
| } |
| } |
| |
| @Test fun annotatedAnnotation() { |
| verifyJavaPackageMember("testdata/java/annotatedAnnotation.java") { cls -> |
| assertEquals(1, cls.annotations.size) |
| with(cls.annotations[0]) { |
| assertEquals(1, details.count()) |
| with(details[0]) { |
| assertEquals(NodeKind.Parameter, kind) |
| assertEquals(1, details.count()) |
| with(details[0]) { |
| assertEquals(NodeKind.Value, kind) |
| assertEquals("[AnnotationTarget.FIELD, AnnotationTarget.CLASS, AnnotationTarget.FILE, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER]", name) |
| } |
| } |
| } |
| } |
| } |
| |
| @Test fun deprecation() { |
| verifyJavaPackageMember("testdata/java/deprecation.java") { cls -> |
| val fn = cls.members(NodeKind.Function).single() |
| assertEquals("This should no longer be used", fn.deprecation!!.content.toTestString()) |
| } |
| } |
| |
| @Test fun javaLangObject() { |
| verifyJavaPackageMember("testdata/java/javaLangObject.java") { cls -> |
| val fn = cls.members(NodeKind.Function).single() |
| assertEquals("Any", fn.detail(NodeKind.Type).name) |
| } |
| } |
| |
| @Test fun enumValues() { |
| verifyJavaPackageMember("testdata/java/enumValues.java") { cls -> |
| val superTypes = cls.details(NodeKind.Supertype) |
| assertEquals(1, superTypes.size) |
| assertEquals(1, cls.members(NodeKind.EnumItem).size) |
| } |
| } |
| |
| @Test fun inheritorLinks() { |
| verifyJavaPackageMember("testdata/java/InheritorLinks.java") { cls -> |
| val fooClass = cls.members.single { it.name == "Foo" } |
| val inheritors = fooClass.references(RefKind.Inheritor) |
| assertEquals(1, inheritors.size) |
| } |
| } |
| } |