From a673f77482fea4ba89f9fdf3a7544955cf8b8226 Mon Sep 17 00:00:00 2001 From: Błażej Kardyś Date: Wed, 29 Jul 2020 19:34:12 +0200 Subject: Javadoc plugin package name fix --- .../javadoc/AbstractJavadocTemplateMapTest.kt | 122 -------- .../javadoc/JavadocAllClassesTemplateMapTest.kt | 49 --- .../javadoc/JavadocClasslikeTemplateMapTest.kt | 331 --------------------- .../kotlin/javadoc/JavadocModuleTemplateMapTest.kt | 78 ----- .../javadoc/JavadocPackageTemplateMapTest.kt | 123 -------- .../javadoc/src/test/kotlin/javadoc/JavadocTest.kt | 69 ----- .../kotlin/javadoc/location/JavadocLocationTest.kt | 146 --------- .../javadoc/search/JavadocIndexSearchTest.kt | 59 ---- .../javadoc/AbstractJavadocTemplateMapTest.kt | 122 ++++++++ .../javadoc/JavadocAllClassesTemplateMapTest.kt | 49 +++ .../javadoc/JavadocClasslikeTemplateMapTest.kt | 331 +++++++++++++++++++++ .../dokka/javadoc/JavadocModuleTemplateMapTest.kt | 78 +++++ .../dokka/javadoc/JavadocPackageTemplateMapTest.kt | 123 ++++++++ .../org/jetbrains/dokka/javadoc/JavadocTest.kt | 69 +++++ .../dokka/javadoc/location/JavadocLocationTest.kt | 146 +++++++++ .../dokka/javadoc/search/JavadocIndexSearchTest.kt | 59 ++++ 16 files changed, 977 insertions(+), 977 deletions(-) delete mode 100644 plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt delete mode 100644 plugins/javadoc/src/test/kotlin/javadoc/JavadocAllClassesTemplateMapTest.kt delete mode 100644 plugins/javadoc/src/test/kotlin/javadoc/JavadocClasslikeTemplateMapTest.kt delete mode 100644 plugins/javadoc/src/test/kotlin/javadoc/JavadocModuleTemplateMapTest.kt delete mode 100644 plugins/javadoc/src/test/kotlin/javadoc/JavadocPackageTemplateMapTest.kt delete mode 100644 plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt delete mode 100644 plugins/javadoc/src/test/kotlin/javadoc/location/JavadocLocationTest.kt delete mode 100644 plugins/javadoc/src/test/kotlin/javadoc/search/JavadocIndexSearchTest.kt create mode 100644 plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/AbstractJavadocTemplateMapTest.kt create mode 100644 plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocAllClassesTemplateMapTest.kt create mode 100644 plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocClasslikeTemplateMapTest.kt create mode 100644 plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocModuleTemplateMapTest.kt create mode 100644 plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocPackageTemplateMapTest.kt create mode 100644 plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocTest.kt create mode 100644 plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/location/JavadocLocationTest.kt create mode 100644 plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/search/JavadocIndexSearchTest.kt (limited to 'plugins/javadoc/src/test') diff --git a/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt deleted file mode 100644 index f4f35ef0..00000000 --- a/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt +++ /dev/null @@ -1,122 +0,0 @@ -package javadoc - -import javadoc.pages.JavadocPageNode -import javadoc.pages.preprocessors -import javadoc.renderer.JavadocContentToTemplateMapTranslator -import org.jetbrains.dokka.DokkaConfigurationImpl -import org.jetbrains.dokka.javadoc.JavadocPlugin -import org.jetbrains.dokka.model.withDescendants -import org.jetbrains.dokka.pages.RootPageNode -import org.jetbrains.dokka.plugability.DokkaContext -import org.jetbrains.dokka.plugability.DokkaPlugin -import org.jetbrains.dokka.plugability.plugin -import org.jetbrains.dokka.plugability.querySingle -import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest - -internal abstract class AbstractJavadocTemplateMapTest : AbstractCoreTest() { - protected var config: DokkaConfigurationImpl = dokkaConfiguration { - format = "javadoc" - sourceSets { - sourceSet { - sourceRoots = listOf("src") - analysisPlatform = "jvm" - } - } - } - - data class Result( - val rootPageNode: RootPageNode, - val context: DokkaContext - ) { - - val translator: JavadocContentToTemplateMapTranslator by lazy { - val locationProvider = context.plugin() - .querySingle { locationProviderFactory } - .getLocationProvider(rootPageNode) - - JavadocContentToTemplateMapTranslator(locationProvider, context) - } - - val JavadocPageNode.templateMap: Map get() = translator.templateMapForPageNode(this) - - inline fun allPagesOfType(): List { - return rootPageNode.withDescendants().filterIsInstance().toList() - } - - inline fun firstPageOfType(): T { - return rootPageNode.withDescendants().filterIsInstance().first() - } - - inline fun firstPageOfTypeOrNull(): T? { - return rootPageNode.withDescendants().filterIsInstance().firstOrNull() - } - - inline fun singlePageOfType(): T { - return rootPageNode.withDescendants().filterIsInstance().single() - } - } - - fun testTemplateMapInline( - query: String, - configuration: DokkaConfigurationImpl = config, - pluginsOverride: List = emptyList(), - assertions: Result.() -> Unit - ) { - testInline(query, configuration, pluginOverrides = pluginsOverride) { - renderingStage = { rootPageNode, dokkaContext -> - val transformedRootPageNode = preprocessors.fold(rootPageNode) { acc, pageTransformer -> - pageTransformer(acc) - } - - Result(transformedRootPageNode, dokkaContext).assertions() - } - } - } - - fun dualTestTemplateMapInline( - kotlin: String? = null, - java: String? = null, - configuration: DokkaConfigurationImpl = config, - pluginsOverride: List = emptyList(), - assertions: Result.() -> Unit - ) { - val kotlinException = kotlin?.let { - runCatching { - testTemplateMapInline( - query = kotlin, - configuration = configuration, - pluginsOverride = pluginsOverride, - assertions = assertions - ) - }.exceptionOrNull() - } - - val javaException = java?.let { - runCatching { - testTemplateMapInline( - query = java, - configuration = configuration, - pluginsOverride = pluginsOverride, - assertions = assertions - ) - }.exceptionOrNull() - } - - if (kotlinException != null && javaException != null) { - throw AssertionError( - "Kotlin and Java Code failed assertions\n" + - "Kotlin: ${kotlinException.message}\n" + - "Java : ${javaException.message}", - kotlinException - ) - } - - if (kotlinException != null) { - throw AssertionError("Kotlin Code failed assertions", kotlinException) - } - - if (javaException != null) { - throw AssertionError("Java Code failed assertions", javaException) - } - } -} diff --git a/plugins/javadoc/src/test/kotlin/javadoc/JavadocAllClassesTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/JavadocAllClassesTemplateMapTest.kt deleted file mode 100644 index 90789d43..00000000 --- a/plugins/javadoc/src/test/kotlin/javadoc/JavadocAllClassesTemplateMapTest.kt +++ /dev/null @@ -1,49 +0,0 @@ -package javadoc - -import javadoc.pages.AllClassesPage -import javadoc.pages.LinkJavadocListEntry -import org.jetbrains.dokka.links.DRI -import org.jetbrains.dokka.pages.ContentKind -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Test -import org.jetbrains.dokka.testApi.utils.assertIsInstance - -internal class JavadocAllClassesTemplateMapTest : AbstractJavadocTemplateMapTest() { - @Test - fun `two classes from different packages`() { - dualTestTemplateMapInline( - """ - /src/source0.kt - package package0 - /** - * Documentation for ClassA - */ - class ClassA - - /src/source1.kt - package package1 - /** - * Documentation for ClassB - */ - class ClassB - """ - ) { - val map = singlePageOfType().templateMap - assertEquals("main", map["kind"]) - assertEquals("All Classes", map["title"]) - - val list = assertIsInstance>(map["list"]) - assertEquals(2, list.size, "Expected two classes") - - val classA = assertIsInstance(list[0]) - assertEquals("ClassA", classA.name) - assertEquals(DRI("package0", "ClassA"), classA.dri.single()) - assertEquals(ContentKind.Classlikes, classA.kind) - - val classB = assertIsInstance(list[1]) - assertEquals("ClassB", classB.name) - assertEquals(DRI("package1", "ClassB"), classB.dri.single()) - assertEquals(ContentKind.Classlikes, classB.kind) - } - } -} diff --git a/plugins/javadoc/src/test/kotlin/javadoc/JavadocClasslikeTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/JavadocClasslikeTemplateMapTest.kt deleted file mode 100644 index 1ad912c5..00000000 --- a/plugins/javadoc/src/test/kotlin/javadoc/JavadocClasslikeTemplateMapTest.kt +++ /dev/null @@ -1,331 +0,0 @@ -package javadoc - -import javadoc.pages.JavadocClasslikePageNode -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Test -import org.jetbrains.dokka.testApi.utils.assertIsInstance - -internal class JavadocClasslikeTemplateMapTest : AbstractJavadocTemplateMapTest() { - - @Test - fun `empty class`() { - dualTestTemplateMapInline( - kotlin = - """ - /src/source0.kt - package com.test.package0 - /** - * Documentation for TestClass - */ - class TestClass - """, - java = - """ - /src/com/test/package0/TestClass.java - package com.test.package0; - /** - * Documentation for TestClass - */ - public final class TestClass {} - """ - ) { - val map = singlePageOfType().templateMap - assertEquals("TestClass", map["name"]) - assertEquals("TestClass", map["title"]) - assertEquals("com.test.package0", map["packageName"]) - assertEquals("Documentation for TestClass", map["classlikeDocumentation"]) - assertEquals("Documentation for TestClass", map["subtitle"]) - assertEquals("public final class TestClass", map.signatureWithModifiers()) - } - } - - @Test - fun `single function`() { - dualTestTemplateMapInline( - kotlin = - """ - /src/source0.kt - package com.test.package0 - /** - * Documentation for TestClass - */ - class TestClass { - /** - * Documentation for testFunction - */ - fun testFunction(): String = "" - } - """, - java = - """ - /src/com/test/package0/TestClass.java - package com.test.package0 - /** - * Documentation for TestClass - */ - public final class TestClass { - /** - * Documentation for testFunction - */ - public final String testFunction() { - return ""; - } - } - """ - ) { - val map = singlePageOfType().templateMap - - assertEquals("TestClass", map["name"]) - assertEquals("TestClass", map["title"]) - assertEquals("com.test.package0", map["packageName"]) - assertEquals("Documentation for TestClass", map["classlikeDocumentation"]) - assertEquals("Documentation for TestClass", map["subtitle"]) - assertEquals("public final class", map.modifiers()) - assertEquals("TestClass", map.signatureWithoutModifiers()) - - val methods = assertIsInstance>(map["methods"]) - val ownMethods = assertIsInstance>(methods["own"]) - assertEquals(1, ownMethods.size, "Expected only one method") - val method = assertIsInstance>(ownMethods.single()) - assertEquals("Documentation for testFunction", method["brief"]) - assertEquals("testFunction", method["name"]) - assertEquals( - 0, assertIsInstance>(method["parameters"]).size, - "Expected no parameters" - ) - assertEquals("final String", method.modifiers()) - assertEquals("testFunction()", method.signatureWithoutModifiers()) - } - } - - @Test - fun `class with annotation`(){ - dualTestTemplateMapInline( - kotlin = - """ - /src/source0.kt - package com.test.package0 - @MustBeDocumented - annotation class Author(val name: String) - - @Author( - name = "Benjamin Franklin" - ) - class TestClass {` - - @Author( - name = "Franklin D. Roosevelt" - ) - fun testFunction(): String = "" - } - """, - java = - """ - /src/com/test/package0/Author.java - package com.test.package0 - import java.lang.annotation.Documented; - - @Documented - public @interface Author { - String name(); - } - /src/com/test/package0/TestClass.java - package com.test.package0 - - @Author( - name = "Benjamin Franklin" - ) - public final class TestClass { - - @Author( - name = "Franklin D. Roosevelt" - ) - public final String testFunction() { - return ""; - } - } - """ - ){ - val map = allPagesOfType().first { it.name == "TestClass" }.templateMap - assertEquals("TestClass", map["name"]) - val signature = assertIsInstance>(map["signature"]) - assertEquals("@Author(name = \"Benjamin Franklin\")", signature["annotations"]) - - val methods = assertIsInstance>(map["methods"]) - val ownMethods = assertIsInstance>(methods["own"]) - val method = assertIsInstance>(ownMethods.single()) - val methodSignature = assertIsInstance>(method["signature"]) - assertEquals("@Author(name = \"Franklin D. Roosevelt\")", methodSignature["annotations"]) - } - } - - @Test - fun `simple enum`(){ - dualTestTemplateMapInline( - kotlin = - """ - /src/source0.kt - package com.test.package0 - enum class ClockDays { - /** - * Sample docs for first - */ - FIRST, - /** - * Sample docs for second - */ - SECOND - } - """, - java = - """ - /src/com/test/package0/TestClass.java - package com.test.package0; - enum ClockDays { - /** - * Sample docs for first - */ - FIRST, - /** - * Sample docs for second - */ - SECOND - } - """ - ){ - val map = singlePageOfType().templateMap - assertEquals("ClockDays", map["name"]) - assertEquals("enum", map["kind"]) - val entries = assertIsInstance>>(map["entries"]) - assertEquals(2, entries.size) - - val (first, second) = entries - assertEquals("Sample docs for first", first["brief"]) - assertEquals("Sample docs for second", second["brief"]) - - assertEquals("FIRST", first.signatureWithoutModifiers()) - assertEquals("SECOND", second.signatureWithoutModifiers()) - } - } - - @Test - fun `documented function parameters`(){ - dualTestTemplateMapInline( - kotlin = - """ - /src/source0.kt - package com.test.package0 - class TestClass { - /** - * Simple parameters list to check out - * @param simple simple String parameter - * @param parameters simple Integer parameter - * @param list simple Boolean parameter - * @return just a String - */ - fun testFunction(simple: String?, parameters: Int?, list: Boolean?): String { - return "" - } - } - """, - java = - """ - /src/com/test/package0/TestClass.java - package com.test.package0; - public final class TestClass { - /** - * Simple parameters list to check out - * @param simple simple String parameter - * @param parameters simple Integer parameter - * @param list simple Boolean parameter - * @return just a String - */ - public final String testFunction(String simple, Integer parameters, Boolean list) { - return ""; - } - } - """ - ) { - val map = singlePageOfType().templateMap - assertEquals("TestClass", map["name"]) - - val methods = assertIsInstance>(map["methods"]) - val testFunction = assertIsInstance>>(methods["own"]).single() - assertEquals("Simple parameters list to check out", testFunction["brief"]) - - val (first, second, third) = assertIsInstance>>(testFunction["parameters"]) - assertParameterNode( - node = first, - expectedName = "simple", - expectedType = "String", - expectedDescription = "simple String parameter" - ) - assertParameterNode( - node = second, - expectedName = "parameters", - expectedType = "Integer", - expectedDescription = "simple Integer parameter" - ) - assertParameterNode( - node = third, - expectedName = "list", - expectedType = "Boolean", - expectedDescription = "simple Boolean parameter" - ) - } - } - - @Test - fun `with generic parameters`(){ - dualTestTemplateMapInline( - kotlin = - """ - /src/source0.kt - package com.test.package0 - import java.io.Serializable - - class Generic { - fun sampleFunction(): D = TODO() - } - """, - java = - """ - /src/com/test/package0/Generic.java - package com.test.package0; - import java.io.Serializable; - - public final class Generic { - public final D sampleFunction(){ - return null; - } - } - """ - ) { - val map = singlePageOfType().templateMap - assertEquals("Generic", map["name"]) - - assertEquals( - "public final class Generic<T extends Serializable>", - map.signatureWithModifiers() - ) - val methods = assertIsInstance>(map["methods"]) - val ownMethods = assertIsInstance>(methods["own"]).first() - val sampleFunction = assertIsInstance>(ownMethods) - - assertEquals("final <D extends T> D sampleFunction()", sampleFunction.signatureWithModifiers()) - } - } - - private fun assertParameterNode(node: Map, expectedName: String, expectedType: String, expectedDescription: String){ - assertEquals(expectedName, node["name"]) - assertEquals(expectedType, node["type"]) - assertEquals(expectedDescription, node["description"]) - } - - private fun Map.signatureWithModifiers(): String = "${modifiers()} ${signatureWithoutModifiers()}" - - private fun Map.signatureWithoutModifiers(): String = (get("signature") as Map)["signatureWithoutModifiers"] as String - - private fun Map.modifiers(): String = (get("signature") as Map)["modifiers"] as String - -} diff --git a/plugins/javadoc/src/test/kotlin/javadoc/JavadocModuleTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/JavadocModuleTemplateMapTest.kt deleted file mode 100644 index f591bf35..00000000 --- a/plugins/javadoc/src/test/kotlin/javadoc/JavadocModuleTemplateMapTest.kt +++ /dev/null @@ -1,78 +0,0 @@ -package javadoc - -import javadoc.pages.JavadocModulePageNode -import javadoc.pages.RowJavadocListEntry -import org.jetbrains.dokka.links.DRI -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Test -import org.jetbrains.dokka.testApi.utils.assertIsInstance - -internal class JavadocModuleTemplateMapTest : AbstractJavadocTemplateMapTest() { - - @Test - fun singleEmptyClass() { - dualTestTemplateMapInline( - kotlin = - """ - /src/source.kt - package com.test.package - class Test - """, - java = - """ - /src/com/test/package/Source.java - package com.test.package; - public class Test { } - """ - ) { - val moduleTemplateMap = singlePageOfType().templateMap - assertEquals("main", moduleTemplateMap["kind"]) - assertEquals("root", moduleTemplateMap["title"]) - assertEquals("", moduleTemplateMap["subtitle"]) - assertEquals("Packages", moduleTemplateMap["tabTitle"]) - assertEquals("Package", moduleTemplateMap["colTitle"]) - assertEquals("", moduleTemplateMap["pathToRoot"]) - - val list = moduleTemplateMap["list"] as List<*> - assertEquals(1, list.size, "Expected only one entry in 'list'") - val rowListEntry = assertIsInstance(list.first()) - - assertEquals("com.test", rowListEntry.link.name) - assertEquals(DRI("com.test"), rowListEntry.link.dri.single()) - } - } - - @Test - fun multiplePackages() { - dualTestTemplateMapInline( - kotlin = - """ - /src/source0.kt - package com.test.package0 - class Test0 - - /src/source1.kt - package com.test.package1 - class Test1 - """, - java = - """ - /src/com/test/package0/Test0.java - package com.test.package0; - public class Test0 {} - - /src/com/test/package1/Test1.java - package com.test.package1; - public class Test1 {} - """ - ) { - val moduleTemplateMap = singlePageOfType().templateMap - val list = assertIsInstance>(moduleTemplateMap["list"]) - assertEquals(2, list.size, "Expected two entries in 'list'") - assertEquals("com.test.package0", assertIsInstance(list[0]).link.name) - assertEquals("com.test.package1", assertIsInstance(list[1]).link.name) - assertEquals(DRI("com.test.package0"), assertIsInstance(list[0]).link.dri.single()) - assertEquals(DRI("com.test.package1"), assertIsInstance(list[1]).link.dri.single()) - } - } -} diff --git a/plugins/javadoc/src/test/kotlin/javadoc/JavadocPackageTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/JavadocPackageTemplateMapTest.kt deleted file mode 100644 index f91bc024..00000000 --- a/plugins/javadoc/src/test/kotlin/javadoc/JavadocPackageTemplateMapTest.kt +++ /dev/null @@ -1,123 +0,0 @@ -package javadoc - -import javadoc.pages.JavadocContentKind -import javadoc.pages.JavadocPackagePageNode -import javadoc.pages.RowJavadocListEntry -import org.jetbrains.dokka.links.DRI -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Disabled -import org.junit.jupiter.api.Test -import org.jetbrains.dokka.testApi.utils.assertIsInstance - -internal class JavadocPackageTemplateMapTest : AbstractJavadocTemplateMapTest() { - - @Test - fun `single class`() { - dualTestTemplateMapInline( - kotlin = - """ - /src/source.kt - package com.test.package0 - class Test - """, - java = - """ - /src/com/test/package0/Test.java - package com.test.package0; - public class Test {} - """ - ) { - val map = singlePageOfType().templateMap - assertEquals("Class Summary", ((map["lists"] as List<*>).first() as Map)["tabTitle"]) - assertEquals("Class", ((map["lists"] as List<*>).first() as Map)["colTitle"]) - assertEquals("com.test.package0", map["title"]) - assertEquals("", map["subtitle"]) - assertEquals("package", map["kind"]) - - val list = assertIsInstance>(((map["lists"] as List<*>).first() as Map)["list"]) - val entry = assertIsInstance(list.single()) - assertEquals("Test", entry.link.name) - assertEquals(JavadocContentKind.Class, entry.link.kind) - assertEquals(DRI("com.test.package0", "Test"), entry.link.dri.single()) - } - } - - @Test - fun `multiple packages`() { - dualTestTemplateMapInline( - kotlin = - """ - /src/source0.kt - package com.test.package0 - class Test0 - - /src/source1.kt - package com.test.package1 - class Test1 - """, - java = - """ - /src/com/test/package0/Test0.java - package com.test.package0; - public class Test0 {} - - /src/com/test/package1/Test1.java - package com.test.package1; - public class Test1 {} - """ - ) { - val packagePages = allPagesOfType() - packagePages.forEach { page -> - val map = page.templateMap - assertEquals("Class Summary", ((map["lists"] as List<*>).first() as Map)["tabTitle"]) - assertEquals("Class", ((map["lists"] as List<*>).first() as Map)["colTitle"]) - assertEquals("", map["subtitle"]) - assertEquals("package", map["kind"]) - } - - assertEquals(2, packagePages.size, "Expected two package pages") - } - } - - @Disabled("To be implemented / To be fixed") - @Test - fun `single class with package documentation`() { - dualTestTemplateMapInline( - kotlin = - """ - /src/packages.md - # Package com.test.package0 - ABC - - /src/source0.kt - package com.test.package0 - class Test - """, - - java = - """ - /src/com/test/package0/package-info.java - /** - * ABC - */ - package com.test.package0; - - /src/com/test/package0/Test.java - package com.test.package0; - public class Test{} - """, - configuration = config.copy( - sourceSets = config.sourceSets.map { sourceSet -> - sourceSet.copy( - includes = listOf("packages.md") - ) - } - ) - ) { - val packagePage = singlePageOfType() - - val map = packagePage.templateMap - assertEquals("ABD", map["subtitle"].toString().trim()) - } - } -} diff --git a/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt deleted file mode 100644 index 31a33ad5..00000000 --- a/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt +++ /dev/null @@ -1,69 +0,0 @@ -package javadoc - -import org.jetbrains.dokka.javadoc.JavadocPlugin -import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest -import org.junit.jupiter.api.Test - -class JavadocTest : AbstractCoreTest() { - - @Test - fun test() { - val config = dokkaConfiguration { - format = "javadoc" - sourceSets { - sourceSet { - sourceRoots = listOf("jvmSrc/") - analysisPlatform = "jvm" - } - } - } - - /* - |/jvmSrc/javadoc/test/Test2.kt - |package javadoc.test - |class Test2() - */ - - testInline(""" - |/jvmSrc/javadoc/Test.kt - |/** - | test - |**/ - |package javadoc - |class Test() : List - |class Test2() : List - |/jvmSrc/javadoc/TestJ.java - |package javadoc - |abstract class Test3 extends List {} - """.trimIndent(), - config, - cleanupOutput = false, - pluginOverrides = listOf(JavadocPlugin()) - ) { - pagesTransformationStage = { - it - } - } - } - -// @Test -// fun test() { -// val config = dokkaConfiguration { -// format = "javadoc" -// passes { -// pass { -// sourceRoots = listOf("main/") -// analysisPlatform = "jvm" -// targets = listOf("jvm") -// } -// } -// } -// testFromData(config, -// cleanupOutput = false, -// pluginOverrides = listOf(JavadocPlugin())) { -// pagesTransformationStage = { -// it -// } -// } -// } -} diff --git a/plugins/javadoc/src/test/kotlin/javadoc/location/JavadocLocationTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/location/JavadocLocationTest.kt deleted file mode 100644 index b7a578a5..00000000 --- a/plugins/javadoc/src/test/kotlin/javadoc/location/JavadocLocationTest.kt +++ /dev/null @@ -1,146 +0,0 @@ -package javadoc.location - -import javadoc.pages.JavadocClasslikePageNode -import javadoc.pages.JavadocPackagePageNode -import javadoc.renderer.JavadocContentToHtmlTranslator -import org.jetbrains.dokka.DokkaConfiguration -import org.jetbrains.dokka.ExternalDocumentationLinkImpl -import org.jetbrains.dokka.javadoc.JavadocPlugin -import org.jetbrains.dokka.model.firstChildOfType -import org.jetbrains.dokka.pages.RootPageNode -import org.jetbrains.dokka.plugability.DokkaContext -import org.jetbrains.dokka.plugability.plugin -import org.jetbrains.dokka.plugability.querySingle -import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest -import org.junit.jupiter.api.Test -import org.junit.jupiter.api.Assertions.assertEquals - -class JavadocTest : AbstractCoreTest() { - - private fun locationTestInline(testHandler: (RootPageNode, DokkaContext) -> Unit) { - fun externalLink(link: String) = DokkaConfiguration.ExternalDocumentationLink - .Builder(link) - .build() as ExternalDocumentationLinkImpl - - val config = dokkaConfiguration { - format = "javadoc" - sourceSets { - sourceSet { - sourceRoots = listOf("jvmSrc/") - externalDocumentationLinks = listOf( - externalLink("https://docs.oracle.com/javase/8/docs/api/"), - externalLink("https://kotlinlang.org/api/latest/jvm/stdlib/") - ) - analysisPlatform = "jvm" - } - } - } - testInline( - """ - |/jvmSrc/javadoc/test/Test.kt - |package javadoc.test - |import java.io.Serializable - |class Test() : Serializable, Cloneable { - | fun test() {} - | fun test2(s: String) {} - | fun test3(a: A, t: T) {} - |} - """.trimIndent(), - config, - cleanupOutput = false, - pluginOverrides = listOf(JavadocPlugin()) - ) { renderingStage = testHandler } - } - - @Test - fun `resolved signature with external links`() { - - locationTestInline { rootPageNode, dokkaContext -> - val transformer = htmlTranslator(rootPageNode, dokkaContext) - val testClass = rootPageNode.firstChildOfType() - .firstChildOfType() - assertEquals( - " implements Serializable, Cloneable", - transformer.htmlForContentNode(testClass.signature.supertypes!!, null) - ) - } - } - - @Test - fun `resolved signature to no argument function`() { - - locationTestInline { rootPageNode, dokkaContext -> - val transformer = htmlTranslator(rootPageNode, dokkaContext) - val testClassNode = rootPageNode.firstChildOfType() - .firstChildOfType { it.name == "Test" } - val testFunctionNode = testClassNode.methods.first { it.name == "test" } - assertEquals( - """test()""", - transformer.htmlForContentNode( - testFunctionNode.signature.signatureWithoutModifiers, - testClassNode - ) - ) - } - } - - @Test - fun `resolved signature to one argument function`() { - - locationTestInline { rootPageNode, dokkaContext -> - val transformer = htmlTranslator(rootPageNode, dokkaContext) - val testClassNode = rootPageNode.firstChildOfType() - .firstChildOfType { it.name == "Test" } - val testFunctionNode = testClassNode.methods.first { it.name == "test2" } - assertEquals( - """test2(String s)""", - transformer.htmlForContentNode( - testFunctionNode.signature.signatureWithoutModifiers, - testClassNode - ) - ) - } - } - - @Test - fun `resolved signature to generic function`() { - - locationTestInline { rootPageNode, dokkaContext -> - val transformer = htmlTranslator(rootPageNode, dokkaContext) - val testClassNode = rootPageNode.firstChildOfType() - .firstChildOfType { it.name == "Test" } - val testFunctionNode = testClassNode.methods.first { it.name == "test3" } - assertEquals( - """test3(A a, T t)""", - transformer.htmlForContentNode( - testFunctionNode.signature.signatureWithoutModifiers, - testClassNode - ) - ) - } - } - - @Test - fun `resolved package path`() { - - locationTestInline { rootPageNode, dokkaContext -> - val locationProvider = dokkaContext.plugin().querySingle { locationProviderFactory } - .getLocationProvider(rootPageNode) - val packageNode = rootPageNode.firstChildOfType() - val packagePath = locationProvider.resolve(packageNode) - - assertEquals("javadoc/test/package-summary", packagePath) - } - } - - private fun htmlTranslator(rootPageNode: RootPageNode, dokkaContext: DokkaContext): JavadocContentToHtmlTranslator { - val locationProvider = dokkaContext.plugin().querySingle { locationProviderFactory } - .getLocationProvider(rootPageNode) - return htmlTranslator(dokkaContext, locationProvider) - } - - private fun htmlTranslator( - dokkaContext: DokkaContext, - locationProvider: JavadocLocationProvider - ) = JavadocContentToHtmlTranslator(locationProvider, dokkaContext) -} diff --git a/plugins/javadoc/src/test/kotlin/javadoc/search/JavadocIndexSearchTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/search/JavadocIndexSearchTest.kt deleted file mode 100644 index 6abed98d..00000000 --- a/plugins/javadoc/src/test/kotlin/javadoc/search/JavadocIndexSearchTest.kt +++ /dev/null @@ -1,59 +0,0 @@ -package javadoc.search - -import javadoc.AbstractJavadocTemplateMapTest -import org.junit.jupiter.api.Test -import utils.TestOutputWriterPlugin -import org.junit.jupiter.api.Assertions.* - -internal class JavadocIndexSearchTest : AbstractJavadocTemplateMapTest() { - @Test - fun `javadoc index search tag`(){ - val writerPlugin = TestOutputWriterPlugin() - dualTestTemplateMapInline( - java = """ - /src/ClassA.java - package package0 - /** - * Documentation for ClassA - * Defines the implementation of the system Java compiler and its command line equivalent, {@index javac}, as well as javah. - */ - class ClassA { - - } - """, - pluginsOverride = listOf(writerPlugin) - ) { - val contents = writerPlugin.writer.contents - val expectedSearchTagJson = """var tagSearchIndex = [{"p":"package0","c":"ClassA","l":"javac","url":"package0/ClassA.html#javac"}]""" - assertEquals(expectedSearchTagJson, contents["tag-search-index.js"]) - } - } - - @Test - fun `javadoc type with member search`(){ - val writerPlugin = TestOutputWriterPlugin() - dualTestTemplateMapInline( - java = """ - /src/ClassA.java - package package0 - class ClassA { - public String propertyOfClassA = "Sample"; - - public void sampleFunction(){ - - } - } - """, - pluginsOverride = listOf(writerPlugin) - ) { - val contents = writerPlugin.writer.contents - val expectedPackageJson = """var packageSearchIndex = [{"l":"package0","url":"package0/package-summary.html"}, {"l":"All packages","url":"index.html"}]""" - val expectedClassesJson = """var typeSearchIndex = [{"p":"package0","l":"ClassA","url":"package0/ClassA.html"}, {"l":"All classes","url":"allclasses.html"}]""" - val expectedMembersJson = """var memberSearchIndex = [{"p":"package0","c":"ClassA","l":"sampleFunction()","url":"package0/ClassA.html#sampleFunction()"}, {"p":"package0","c":"ClassA","l":"propertyOfClassA","url":"package0/ClassA.html#propertyOfClassA"}]""" - - assertEquals(expectedPackageJson, contents["package-search-index.js"]) - assertEquals(expectedClassesJson, contents["type-search-index.js"]) - assertEquals(expectedMembersJson, contents["member-search-index.js"]) - } - } -} \ No newline at end of file diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/AbstractJavadocTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/AbstractJavadocTemplateMapTest.kt new file mode 100644 index 00000000..ff254f99 --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/AbstractJavadocTemplateMapTest.kt @@ -0,0 +1,122 @@ +package org.jetbrains.dokka.javadoc + +import org.jetbrains.dokka.javadoc.pages.JavadocPageNode +import org.jetbrains.dokka.javadoc.pages.preprocessors +import org.jetbrains.dokka.javadoc.renderer.JavadocContentToTemplateMapTranslator +import org.jetbrains.dokka.DokkaConfigurationImpl +import org.jetbrains.dokka.javadoc.JavadocPlugin +import org.jetbrains.dokka.model.withDescendants +import org.jetbrains.dokka.pages.RootPageNode +import org.jetbrains.dokka.plugability.DokkaContext +import org.jetbrains.dokka.plugability.DokkaPlugin +import org.jetbrains.dokka.plugability.plugin +import org.jetbrains.dokka.plugability.querySingle +import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest + +internal abstract class AbstractJavadocTemplateMapTest : AbstractCoreTest() { + protected var config: DokkaConfigurationImpl = dokkaConfiguration { + format = "javadoc" + sourceSets { + sourceSet { + sourceRoots = listOf("src") + analysisPlatform = "jvm" + } + } + } + + data class Result( + val rootPageNode: RootPageNode, + val context: DokkaContext + ) { + + val translator: JavadocContentToTemplateMapTranslator by lazy { + val locationProvider = context.plugin() + .querySingle { locationProviderFactory } + .getLocationProvider(rootPageNode) + + JavadocContentToTemplateMapTranslator(locationProvider, context) + } + + val JavadocPageNode.templateMap: Map get() = translator.templateMapForPageNode(this) + + inline fun allPagesOfType(): List { + return rootPageNode.withDescendants().filterIsInstance().toList() + } + + inline fun firstPageOfType(): T { + return rootPageNode.withDescendants().filterIsInstance().first() + } + + inline fun firstPageOfTypeOrNull(): T? { + return rootPageNode.withDescendants().filterIsInstance().firstOrNull() + } + + inline fun singlePageOfType(): T { + return rootPageNode.withDescendants().filterIsInstance().single() + } + } + + fun testTemplateMapInline( + query: String, + configuration: DokkaConfigurationImpl = config, + pluginsOverride: List = emptyList(), + assertions: Result.() -> Unit + ) { + testInline(query, configuration, pluginOverrides = pluginsOverride) { + renderingStage = { rootPageNode, dokkaContext -> + val transformedRootPageNode = preprocessors.fold(rootPageNode) { acc, pageTransformer -> + pageTransformer(acc) + } + + Result(transformedRootPageNode, dokkaContext).assertions() + } + } + } + + fun dualTestTemplateMapInline( + kotlin: String? = null, + java: String? = null, + configuration: DokkaConfigurationImpl = config, + pluginsOverride: List = emptyList(), + assertions: Result.() -> Unit + ) { + val kotlinException = kotlin?.let { + runCatching { + testTemplateMapInline( + query = kotlin, + configuration = configuration, + pluginsOverride = pluginsOverride, + assertions = assertions + ) + }.exceptionOrNull() + } + + val javaException = java?.let { + runCatching { + testTemplateMapInline( + query = java, + configuration = configuration, + pluginsOverride = pluginsOverride, + assertions = assertions + ) + }.exceptionOrNull() + } + + if (kotlinException != null && javaException != null) { + throw AssertionError( + "Kotlin and Java Code failed assertions\n" + + "Kotlin: ${kotlinException.message}\n" + + "Java : ${javaException.message}", + kotlinException + ) + } + + if (kotlinException != null) { + throw AssertionError("Kotlin Code failed assertions", kotlinException) + } + + if (javaException != null) { + throw AssertionError("Java Code failed assertions", javaException) + } + } +} diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocAllClassesTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocAllClassesTemplateMapTest.kt new file mode 100644 index 00000000..57835490 --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocAllClassesTemplateMapTest.kt @@ -0,0 +1,49 @@ +package org.jetbrains.dokka.javadoc + +import org.jetbrains.dokka.javadoc.pages.AllClassesPage +import org.jetbrains.dokka.javadoc.pages.LinkJavadocListEntry +import org.jetbrains.dokka.links.DRI +import org.jetbrains.dokka.pages.ContentKind +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Test +import org.jetbrains.dokka.testApi.utils.assertIsInstance + +internal class JavadocAllClassesTemplateMapTest : AbstractJavadocTemplateMapTest() { + @Test + fun `two classes from different packages`() { + dualTestTemplateMapInline( + """ + /src/source0.kt + package package0 + /** + * Documentation for ClassA + */ + class ClassA + + /src/source1.kt + package package1 + /** + * Documentation for ClassB + */ + class ClassB + """ + ) { + val map = singlePageOfType().templateMap + assertEquals("main", map["kind"]) + assertEquals("All Classes", map["title"]) + + val list = assertIsInstance>(map["list"]) + assertEquals(2, list.size, "Expected two classes") + + val classA = assertIsInstance(list[0]) + assertEquals("ClassA", classA.name) + assertEquals(DRI("package0", "ClassA"), classA.dri.single()) + assertEquals(ContentKind.Classlikes, classA.kind) + + val classB = assertIsInstance(list[1]) + assertEquals("ClassB", classB.name) + assertEquals(DRI("package1", "ClassB"), classB.dri.single()) + assertEquals(ContentKind.Classlikes, classB.kind) + } + } +} diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocClasslikeTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocClasslikeTemplateMapTest.kt new file mode 100644 index 00000000..18bc69ff --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocClasslikeTemplateMapTest.kt @@ -0,0 +1,331 @@ +package org.jetbrains.dokka.javadoc + +import org.jetbrains.dokka.javadoc.pages.JavadocClasslikePageNode +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Test +import org.jetbrains.dokka.testApi.utils.assertIsInstance + +internal class JavadocClasslikeTemplateMapTest : AbstractJavadocTemplateMapTest() { + + @Test + fun `empty class`() { + dualTestTemplateMapInline( + kotlin = + """ + /src/source0.kt + package com.test.package0 + /** + * Documentation for TestClass + */ + class TestClass + """, + java = + """ + /src/com/test/package0/TestClass.java + package com.test.package0; + /** + * Documentation for TestClass + */ + public final class TestClass {} + """ + ) { + val map = singlePageOfType().templateMap + assertEquals("TestClass", map["name"]) + assertEquals("TestClass", map["title"]) + assertEquals("com.test.package0", map["packageName"]) + assertEquals("Documentation for TestClass", map["classlikeDocumentation"]) + assertEquals("Documentation for TestClass", map["subtitle"]) + assertEquals("public final class TestClass", map.signatureWithModifiers()) + } + } + + @Test + fun `single function`() { + dualTestTemplateMapInline( + kotlin = + """ + /src/source0.kt + package com.test.package0 + /** + * Documentation for TestClass + */ + class TestClass { + /** + * Documentation for testFunction + */ + fun testFunction(): String = "" + } + """, + java = + """ + /src/com/test/package0/TestClass.java + package com.test.package0 + /** + * Documentation for TestClass + */ + public final class TestClass { + /** + * Documentation for testFunction + */ + public final String testFunction() { + return ""; + } + } + """ + ) { + val map = singlePageOfType().templateMap + + assertEquals("TestClass", map["name"]) + assertEquals("TestClass", map["title"]) + assertEquals("com.test.package0", map["packageName"]) + assertEquals("Documentation for TestClass", map["classlikeDocumentation"]) + assertEquals("Documentation for TestClass", map["subtitle"]) + assertEquals("public final class", map.modifiers()) + assertEquals("TestClass", map.signatureWithoutModifiers()) + + val methods = assertIsInstance>(map["methods"]) + val ownMethods = assertIsInstance>(methods["own"]) + assertEquals(1, ownMethods.size, "Expected only one method") + val method = assertIsInstance>(ownMethods.single()) + assertEquals("Documentation for testFunction", method["brief"]) + assertEquals("testFunction", method["name"]) + assertEquals( + 0, assertIsInstance>(method["parameters"]).size, + "Expected no parameters" + ) + assertEquals("final String", method.modifiers()) + assertEquals("testFunction()", method.signatureWithoutModifiers()) + } + } + + @Test + fun `class with annotation`(){ + dualTestTemplateMapInline( + kotlin = + """ + /src/source0.kt + package com.test.package0 + @MustBeDocumented + annotation class Author(val name: String) + + @Author( + name = "Benjamin Franklin" + ) + class TestClass {` + + @Author( + name = "Franklin D. Roosevelt" + ) + fun testFunction(): String = "" + } + """, + java = + """ + /src/com/test/package0/Author.java + package com.test.package0 + import java.lang.annotation.Documented; + + @Documented + public @interface Author { + String name(); + } + /src/com/test/package0/TestClass.java + package com.test.package0 + + @Author( + name = "Benjamin Franklin" + ) + public final class TestClass { + + @Author( + name = "Franklin D. Roosevelt" + ) + public final String testFunction() { + return ""; + } + } + """ + ){ + val map = allPagesOfType().first { it.name == "TestClass" }.templateMap + assertEquals("TestClass", map["name"]) + val signature = assertIsInstance>(map["signature"]) + assertEquals("@Author(name = \"Benjamin Franklin\")", signature["annotations"]) + + val methods = assertIsInstance>(map["methods"]) + val ownMethods = assertIsInstance>(methods["own"]) + val method = assertIsInstance>(ownMethods.single()) + val methodSignature = assertIsInstance>(method["signature"]) + assertEquals("@Author(name = \"Franklin D. Roosevelt\")", methodSignature["annotations"]) + } + } + + @Test + fun `simple enum`(){ + dualTestTemplateMapInline( + kotlin = + """ + /src/source0.kt + package com.test.package0 + enum class ClockDays { + /** + * Sample docs for first + */ + FIRST, + /** + * Sample docs for second + */ + SECOND + } + """, + java = + """ + /src/com/test/package0/TestClass.java + package com.test.package0; + enum ClockDays { + /** + * Sample docs for first + */ + FIRST, + /** + * Sample docs for second + */ + SECOND + } + """ + ){ + val map = singlePageOfType().templateMap + assertEquals("ClockDays", map["name"]) + assertEquals("enum", map["kind"]) + val entries = assertIsInstance>>(map["entries"]) + assertEquals(2, entries.size) + + val (first, second) = entries + assertEquals("Sample docs for first", first["brief"]) + assertEquals("Sample docs for second", second["brief"]) + + assertEquals("FIRST", first.signatureWithoutModifiers()) + assertEquals("SECOND", second.signatureWithoutModifiers()) + } + } + + @Test + fun `documented function parameters`(){ + dualTestTemplateMapInline( + kotlin = + """ + /src/source0.kt + package com.test.package0 + class TestClass { + /** + * Simple parameters list to check out + * @param simple simple String parameter + * @param parameters simple Integer parameter + * @param list simple Boolean parameter + * @return just a String + */ + fun testFunction(simple: String?, parameters: Int?, list: Boolean?): String { + return "" + } + } + """, + java = + """ + /src/com/test/package0/TestClass.java + package com.test.package0; + public final class TestClass { + /** + * Simple parameters list to check out + * @param simple simple String parameter + * @param parameters simple Integer parameter + * @param list simple Boolean parameter + * @return just a String + */ + public final String testFunction(String simple, Integer parameters, Boolean list) { + return ""; + } + } + """ + ) { + val map = singlePageOfType().templateMap + assertEquals("TestClass", map["name"]) + + val methods = assertIsInstance>(map["methods"]) + val testFunction = assertIsInstance>>(methods["own"]).single() + assertEquals("Simple parameters list to check out", testFunction["brief"]) + + val (first, second, third) = assertIsInstance>>(testFunction["parameters"]) + assertParameterNode( + node = first, + expectedName = "simple", + expectedType = "String", + expectedDescription = "simple String parameter" + ) + assertParameterNode( + node = second, + expectedName = "parameters", + expectedType = "Integer", + expectedDescription = "simple Integer parameter" + ) + assertParameterNode( + node = third, + expectedName = "list", + expectedType = "Boolean", + expectedDescription = "simple Boolean parameter" + ) + } + } + + @Test + fun `with generic parameters`(){ + dualTestTemplateMapInline( + kotlin = + """ + /src/source0.kt + package com.test.package0 + import java.io.Serializable + + class Generic { + fun sampleFunction(): D = TODO() + } + """, + java = + """ + /src/com/test/package0/Generic.java + package com.test.package0; + import java.io.Serializable; + + public final class Generic { + public final D sampleFunction(){ + return null; + } + } + """ + ) { + val map = singlePageOfType().templateMap + assertEquals("Generic", map["name"]) + + assertEquals( + "public final class Generic<T extends Serializable>", + map.signatureWithModifiers() + ) + val methods = assertIsInstance>(map["methods"]) + val ownMethods = assertIsInstance>(methods["own"]).first() + val sampleFunction = assertIsInstance>(ownMethods) + + assertEquals("final <D extends T> D sampleFunction()", sampleFunction.signatureWithModifiers()) + } + } + + private fun assertParameterNode(node: Map, expectedName: String, expectedType: String, expectedDescription: String){ + assertEquals(expectedName, node["name"]) + assertEquals(expectedType, node["type"]) + assertEquals(expectedDescription, node["description"]) + } + + private fun Map.signatureWithModifiers(): String = "${modifiers()} ${signatureWithoutModifiers()}" + + private fun Map.signatureWithoutModifiers(): String = (get("signature") as Map)["signatureWithoutModifiers"] as String + + private fun Map.modifiers(): String = (get("signature") as Map)["modifiers"] as String + +} diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocModuleTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocModuleTemplateMapTest.kt new file mode 100644 index 00000000..7353be94 --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocModuleTemplateMapTest.kt @@ -0,0 +1,78 @@ +package org.jetbrains.dokka.javadoc + +import org.jetbrains.dokka.javadoc.pages.JavadocModulePageNode +import org.jetbrains.dokka.javadoc.pages.RowJavadocListEntry +import org.jetbrains.dokka.links.DRI +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Test +import org.jetbrains.dokka.testApi.utils.assertIsInstance + +internal class JavadocModuleTemplateMapTest : AbstractJavadocTemplateMapTest() { + + @Test + fun singleEmptyClass() { + dualTestTemplateMapInline( + kotlin = + """ + /src/source.kt + package com.test.package + class Test + """, + java = + """ + /src/com/test/package/Source.java + package com.test.package; + public class Test { } + """ + ) { + val moduleTemplateMap = singlePageOfType().templateMap + assertEquals("main", moduleTemplateMap["kind"]) + assertEquals("root", moduleTemplateMap["title"]) + assertEquals("", moduleTemplateMap["subtitle"]) + assertEquals("Packages", moduleTemplateMap["tabTitle"]) + assertEquals("Package", moduleTemplateMap["colTitle"]) + assertEquals("", moduleTemplateMap["pathToRoot"]) + + val list = moduleTemplateMap["list"] as List<*> + assertEquals(1, list.size, "Expected only one entry in 'list'") + val rowListEntry = assertIsInstance(list.first()) + + assertEquals("com.test", rowListEntry.link.name) + assertEquals(DRI("com.test"), rowListEntry.link.dri.single()) + } + } + + @Test + fun multiplePackages() { + dualTestTemplateMapInline( + kotlin = + """ + /src/source0.kt + package com.test.package0 + class Test0 + + /src/source1.kt + package com.test.package1 + class Test1 + """, + java = + """ + /src/com/test/package0/Test0.java + package com.test.package0; + public class Test0 {} + + /src/com/test/package1/Test1.java + package com.test.package1; + public class Test1 {} + """ + ) { + val moduleTemplateMap = singlePageOfType().templateMap + val list = assertIsInstance>(moduleTemplateMap["list"]) + assertEquals(2, list.size, "Expected two entries in 'list'") + assertEquals("com.test.package0", assertIsInstance(list[0]).link.name) + assertEquals("com.test.package1", assertIsInstance(list[1]).link.name) + assertEquals(DRI("com.test.package0"), assertIsInstance(list[0]).link.dri.single()) + assertEquals(DRI("com.test.package1"), assertIsInstance(list[1]).link.dri.single()) + } + } +} diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocPackageTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocPackageTemplateMapTest.kt new file mode 100644 index 00000000..447be3f8 --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocPackageTemplateMapTest.kt @@ -0,0 +1,123 @@ +package org.jetbrains.dokka.javadoc + +import org.jetbrains.dokka.javadoc.pages.JavadocContentKind +import org.jetbrains.dokka.javadoc.pages.JavadocPackagePageNode +import org.jetbrains.dokka.javadoc.pages.RowJavadocListEntry +import org.jetbrains.dokka.links.DRI +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Disabled +import org.junit.jupiter.api.Test +import org.jetbrains.dokka.testApi.utils.assertIsInstance + +internal class JavadocPackageTemplateMapTest : AbstractJavadocTemplateMapTest() { + + @Test + fun `single class`() { + dualTestTemplateMapInline( + kotlin = + """ + /src/source.kt + package com.test.package0 + class Test + """, + java = + """ + /src/com/test/package0/Test.java + package com.test.package0; + public class Test {} + """ + ) { + val map = singlePageOfType().templateMap + assertEquals("Class Summary", ((map["lists"] as List<*>).first() as Map)["tabTitle"]) + assertEquals("Class", ((map["lists"] as List<*>).first() as Map)["colTitle"]) + assertEquals("com.test.package0", map["title"]) + assertEquals("", map["subtitle"]) + assertEquals("package", map["kind"]) + + val list = assertIsInstance>(((map["lists"] as List<*>).first() as Map)["list"]) + val entry = assertIsInstance(list.single()) + assertEquals("Test", entry.link.name) + assertEquals(JavadocContentKind.Class, entry.link.kind) + assertEquals(DRI("com.test.package0", "Test"), entry.link.dri.single()) + } + } + + @Test + fun `multiple packages`() { + dualTestTemplateMapInline( + kotlin = + """ + /src/source0.kt + package com.test.package0 + class Test0 + + /src/source1.kt + package com.test.package1 + class Test1 + """, + java = + """ + /src/com/test/package0/Test0.java + package com.test.package0; + public class Test0 {} + + /src/com/test/package1/Test1.java + package com.test.package1; + public class Test1 {} + """ + ) { + val packagePages = allPagesOfType() + packagePages.forEach { page -> + val map = page.templateMap + assertEquals("Class Summary", ((map["lists"] as List<*>).first() as Map)["tabTitle"]) + assertEquals("Class", ((map["lists"] as List<*>).first() as Map)["colTitle"]) + assertEquals("", map["subtitle"]) + assertEquals("package", map["kind"]) + } + + assertEquals(2, packagePages.size, "Expected two package pages") + } + } + + @Disabled("To be implemented / To be fixed") + @Test + fun `single class with package documentation`() { + dualTestTemplateMapInline( + kotlin = + """ + /src/packages.md + # Package com.test.package0 + ABC + + /src/source0.kt + package com.test.package0 + class Test + """, + + java = + """ + /src/com/test/package0/package-info.java + /** + * ABC + */ + package com.test.package0; + + /src/com/test/package0/Test.java + package com.test.package0; + public class Test{} + """, + configuration = config.copy( + sourceSets = config.sourceSets.map { sourceSet -> + sourceSet.copy( + includes = listOf("packages.md") + ) + } + ) + ) { + val packagePage = singlePageOfType() + + val map = packagePage.templateMap + assertEquals("ABD", map["subtitle"].toString().trim()) + } + } +} diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocTest.kt new file mode 100644 index 00000000..9adcc2e0 --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocTest.kt @@ -0,0 +1,69 @@ +package org.jetbrains.dokka.javadoc + +import org.jetbrains.dokka.javadoc.JavadocPlugin +import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest +import org.junit.jupiter.api.Test + +class JavadocTest : AbstractCoreTest() { + + @Test + fun test() { + val config = dokkaConfiguration { + format = "javadoc" + sourceSets { + sourceSet { + sourceRoots = listOf("jvmSrc/") + analysisPlatform = "jvm" + } + } + } + + /* + |/jvmSrc/javadoc/test/Test2.kt + |package javadoc.test + |class Test2() + */ + + testInline(""" + |/jvmSrc/javadoc/Test.kt + |/** + | test + |**/ + |package javadoc + |class Test() : List + |class Test2() : List + |/jvmSrc/javadoc/TestJ.java + |package javadoc + |abstract class Test3 extends List {} + """.trimIndent(), + config, + cleanupOutput = false, + pluginOverrides = listOf(JavadocPlugin()) + ) { + pagesTransformationStage = { + it + } + } + } + +// @Test +// fun test() { +// val config = dokkaConfiguration { +// format = "javadoc" +// passes { +// pass { +// sourceRoots = listOf("main/") +// analysisPlatform = "jvm" +// targets = listOf("jvm") +// } +// } +// } +// testFromData(config, +// cleanupOutput = false, +// pluginOverrides = listOf(JavadocPlugin())) { +// pagesTransformationStage = { +// it +// } +// } +// } +} diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/location/JavadocLocationTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/location/JavadocLocationTest.kt new file mode 100644 index 00000000..dd56ad1d --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/location/JavadocLocationTest.kt @@ -0,0 +1,146 @@ +package org.jetbrains.dokka.javadoc.location + +import org.jetbrains.dokka.javadoc.pages.JavadocClasslikePageNode +import org.jetbrains.dokka.javadoc.pages.JavadocPackagePageNode +import org.jetbrains.dokka.javadoc.renderer.JavadocContentToHtmlTranslator +import org.jetbrains.dokka.DokkaConfiguration +import org.jetbrains.dokka.ExternalDocumentationLinkImpl +import org.jetbrains.dokka.javadoc.JavadocPlugin +import org.jetbrains.dokka.model.firstChildOfType +import org.jetbrains.dokka.pages.RootPageNode +import org.jetbrains.dokka.plugability.DokkaContext +import org.jetbrains.dokka.plugability.plugin +import org.jetbrains.dokka.plugability.querySingle +import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.Assertions.assertEquals + +class JavadocTest : AbstractCoreTest() { + + private fun locationTestInline(testHandler: (RootPageNode, DokkaContext) -> Unit) { + fun externalLink(link: String) = DokkaConfiguration.ExternalDocumentationLink + .Builder(link) + .build() as ExternalDocumentationLinkImpl + + val config = dokkaConfiguration { + format = "javadoc" + sourceSets { + sourceSet { + sourceRoots = listOf("jvmSrc/") + externalDocumentationLinks = listOf( + externalLink("https://docs.oracle.com/javase/8/docs/api/"), + externalLink("https://kotlinlang.org/api/latest/jvm/stdlib/") + ) + analysisPlatform = "jvm" + } + } + } + testInline( + """ + |/jvmSrc/javadoc/test/Test.kt + |package javadoc.test + |import java.io.Serializable + |class Test() : Serializable, Cloneable { + | fun test() {} + | fun test2(s: String) {} + | fun test3(a: A, t: T) {} + |} + """.trimIndent(), + config, + cleanupOutput = false, + pluginOverrides = listOf(JavadocPlugin()) + ) { renderingStage = testHandler } + } + + @Test + fun `resolved signature with external links`() { + + locationTestInline { rootPageNode, dokkaContext -> + val transformer = htmlTranslator(rootPageNode, dokkaContext) + val testClass = rootPageNode.firstChildOfType() + .firstChildOfType() + assertEquals( + " implements Serializable, Cloneable", + transformer.htmlForContentNode(testClass.signature.supertypes!!, null) + ) + } + } + + @Test + fun `resolved signature to no argument function`() { + + locationTestInline { rootPageNode, dokkaContext -> + val transformer = htmlTranslator(rootPageNode, dokkaContext) + val testClassNode = rootPageNode.firstChildOfType() + .firstChildOfType { it.name == "Test" } + val testFunctionNode = testClassNode.methods.first { it.name == "test" } + assertEquals( + """test()""", + transformer.htmlForContentNode( + testFunctionNode.signature.signatureWithoutModifiers, + testClassNode + ) + ) + } + } + + @Test + fun `resolved signature to one argument function`() { + + locationTestInline { rootPageNode, dokkaContext -> + val transformer = htmlTranslator(rootPageNode, dokkaContext) + val testClassNode = rootPageNode.firstChildOfType() + .firstChildOfType { it.name == "Test" } + val testFunctionNode = testClassNode.methods.first { it.name == "test2" } + assertEquals( + """test2(String s)""", + transformer.htmlForContentNode( + testFunctionNode.signature.signatureWithoutModifiers, + testClassNode + ) + ) + } + } + + @Test + fun `resolved signature to generic function`() { + + locationTestInline { rootPageNode, dokkaContext -> + val transformer = htmlTranslator(rootPageNode, dokkaContext) + val testClassNode = rootPageNode.firstChildOfType() + .firstChildOfType { it.name == "Test" } + val testFunctionNode = testClassNode.methods.first { it.name == "test3" } + assertEquals( + """test3(A a, T t)""", + transformer.htmlForContentNode( + testFunctionNode.signature.signatureWithoutModifiers, + testClassNode + ) + ) + } + } + + @Test + fun `resolved package path`() { + + locationTestInline { rootPageNode, dokkaContext -> + val locationProvider = dokkaContext.plugin().querySingle { locationProviderFactory } + .getLocationProvider(rootPageNode) + val packageNode = rootPageNode.firstChildOfType() + val packagePath = locationProvider.resolve(packageNode) + + assertEquals("javadoc/test/package-summary", packagePath) + } + } + + private fun htmlTranslator(rootPageNode: RootPageNode, dokkaContext: DokkaContext): JavadocContentToHtmlTranslator { + val locationProvider = dokkaContext.plugin().querySingle { locationProviderFactory } + .getLocationProvider(rootPageNode) + return htmlTranslator(dokkaContext, locationProvider) + } + + private fun htmlTranslator( + dokkaContext: DokkaContext, + locationProvider: JavadocLocationProvider + ) = JavadocContentToHtmlTranslator(locationProvider, dokkaContext) +} diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/search/JavadocIndexSearchTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/search/JavadocIndexSearchTest.kt new file mode 100644 index 00000000..90f499fe --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/search/JavadocIndexSearchTest.kt @@ -0,0 +1,59 @@ +package org.jetbrains.dokka.javadoc.search + +import org.jetbrains.dokka.javadoc.AbstractJavadocTemplateMapTest +import org.junit.jupiter.api.Test +import utils.TestOutputWriterPlugin +import org.junit.jupiter.api.Assertions.* + +internal class JavadocIndexSearchTest : AbstractJavadocTemplateMapTest() { + @Test + fun `javadoc index search tag`(){ + val writerPlugin = TestOutputWriterPlugin() + dualTestTemplateMapInline( + java = """ + /src/ClassA.java + package package0 + /** + * Documentation for ClassA + * Defines the implementation of the system Java compiler and its command line equivalent, {@index javac}, as well as javah. + */ + class ClassA { + + } + """, + pluginsOverride = listOf(writerPlugin) + ) { + val contents = writerPlugin.writer.contents + val expectedSearchTagJson = """var tagSearchIndex = [{"p":"package0","c":"ClassA","l":"javac","url":"package0/ClassA.html#javac"}]""" + assertEquals(expectedSearchTagJson, contents["tag-search-index.js"]) + } + } + + @Test + fun `javadoc type with member search`(){ + val writerPlugin = TestOutputWriterPlugin() + dualTestTemplateMapInline( + java = """ + /src/ClassA.java + package package0 + class ClassA { + public String propertyOfClassA = "Sample"; + + public void sampleFunction(){ + + } + } + """, + pluginsOverride = listOf(writerPlugin) + ) { + val contents = writerPlugin.writer.contents + val expectedPackageJson = """var packageSearchIndex = [{"l":"package0","url":"package0/package-summary.html"}, {"l":"All packages","url":"index.html"}]""" + val expectedClassesJson = """var typeSearchIndex = [{"p":"package0","l":"ClassA","url":"package0/ClassA.html"}, {"l":"All classes","url":"allclasses.html"}]""" + val expectedMembersJson = """var memberSearchIndex = [{"p":"package0","c":"ClassA","l":"sampleFunction()","url":"package0/ClassA.html#sampleFunction()"}, {"p":"package0","c":"ClassA","l":"propertyOfClassA","url":"package0/ClassA.html#propertyOfClassA"}]""" + + assertEquals(expectedPackageJson, contents["package-search-index.js"]) + assertEquals(expectedClassesJson, contents["type-search-index.js"]) + assertEquals(expectedMembersJson, contents["member-search-index.js"]) + } + } +} \ No newline at end of file -- cgit