diff options
Diffstat (limited to 'plugins/javadoc/src/test/kotlin')
8 files changed, 959 insertions, 0 deletions
diff --git a/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt new file mode 100644 index 00000000..f4f35ef0 --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt @@ -0,0 +1,122 @@ +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<JavadocPlugin>() + .querySingle { locationProviderFactory } + .getLocationProvider(rootPageNode) + + JavadocContentToTemplateMapTranslator(locationProvider, context) + } + + val JavadocPageNode.templateMap: Map<String, Any?> get() = translator.templateMapForPageNode(this) + + inline fun <reified T : JavadocPageNode> allPagesOfType(): List<T> { + return rootPageNode.withDescendants().filterIsInstance<T>().toList() + } + + inline fun <reified T : JavadocPageNode> firstPageOfType(): T { + return rootPageNode.withDescendants().filterIsInstance<T>().first() + } + + inline fun <reified T : JavadocPageNode> firstPageOfTypeOrNull(): T? { + return rootPageNode.withDescendants().filterIsInstance<T>().firstOrNull() + } + + inline fun <reified T : JavadocPageNode> singlePageOfType(): T { + return rootPageNode.withDescendants().filterIsInstance<T>().single() + } + } + + fun testTemplateMapInline( + query: String, + configuration: DokkaConfigurationImpl = config, + pluginsOverride: List<DokkaPlugin> = 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<DokkaPlugin> = 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 new file mode 100644 index 00000000..314ba0a3 --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/javadoc/JavadocAllClassesTemplateMapTest.kt @@ -0,0 +1,49 @@ +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 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<AllClassesPage>().templateMap + assertEquals("main", map["kind"]) + assertEquals("All Classes", map["title"]) + + val list = assertIsInstance<List<*>>(map["list"]) + assertEquals(2, list.size, "Expected two classes") + + val classA = assertIsInstance<LinkJavadocListEntry>(list[0]) + assertEquals("ClassA", classA.name) + assertEquals(DRI("package0", "ClassA"), classA.dri.single()) + assertEquals(ContentKind.Classlikes, classA.kind) + + val classB = assertIsInstance<LinkJavadocListEntry>(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 new file mode 100644 index 00000000..2dea1abe --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/javadoc/JavadocClasslikeTemplateMapTest.kt @@ -0,0 +1,331 @@ +package javadoc + +import javadoc.pages.JavadocClasslikePageNode +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Test +import 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<JavadocClasslikePageNode>().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 <a href=TestClass.html>TestClass</a>", 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<JavadocClasslikePageNode>().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("<a href=TestClass.html>TestClass</a>", map.signatureWithoutModifiers()) + + val methods = assertIsInstance<Map<Any, Any?>>(map["methods"]) + val ownMethods = assertIsInstance<List<*>>(methods["own"]) + assertEquals(1, ownMethods.size, "Expected only one method") + val method = assertIsInstance<Map<String, Any?>>(ownMethods.single()) + assertEquals("Documentation for testFunction", method["brief"]) + assertEquals("testFunction", method["name"]) + assertEquals( + 0, assertIsInstance<List<*>>(method["parameters"]).size, + "Expected no parameters" + ) + assertEquals("final <a href=.html>String</a>", method.modifiers()) + assertEquals("<a href=TestClass.html#testFunction()>testFunction</a>()", 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<JavadocClasslikePageNode>().first { it.name == "TestClass" }.templateMap + assertEquals("TestClass", map["name"]) + val signature = assertIsInstance<Map<String, Any?>>(map["signature"]) + assertEquals("@<a href=Author.html>Author</a>(name = \"Benjamin Franklin\")", signature["annotations"]) + + val methods = assertIsInstance<Map<Any, Any?>>(map["methods"]) + val ownMethods = assertIsInstance<List<*>>(methods["own"]) + val method = assertIsInstance<Map<String, Any?>>(ownMethods.single()) + val methodSignature = assertIsInstance<Map<String, Any?>>(method["signature"]) + assertEquals("@<a href=Author.html>Author</a>(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<JavadocClasslikePageNode>().templateMap + assertEquals("ClockDays", map["name"]) + assertEquals("enum", map["kind"]) + val entries = assertIsInstance<List<Map<String, Any?>>>(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("<a href=ClockDays.html#FIRST>FIRST</a>", first.signatureWithoutModifiers()) + assertEquals("<a href=ClockDays.html#SECOND>SECOND</a>", 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<JavadocClasslikePageNode>().templateMap + assertEquals("TestClass", map["name"]) + + val methods = assertIsInstance<Map<String, Any?>>(map["methods"]) + val testFunction = assertIsInstance<List<Map<String, Any?>>>(methods["own"]).single() + assertEquals("Simple parameters list to check out", testFunction["brief"]) + + val (first, second, third) = assertIsInstance<List<Map<String, Any?>>>(testFunction["parameters"]) + assertParameterNode( + node = first, + expectedName = "simple", + expectedType = "<a href=.html>String</a>", + expectedDescription = "simple String parameter" + ) + assertParameterNode( + node = second, + expectedName = "parameters", + expectedType = "<a href=.html>Integer</a>", + expectedDescription = "simple Integer parameter" + ) + assertParameterNode( + node = third, + expectedName = "list", + expectedType = "<a href=.html>Boolean</a>", + expectedDescription = "simple Boolean parameter" + ) + } + } + + @Test + fun `with generic parameters`(){ + dualTestTemplateMapInline( + kotlin = + """ + /src/source0.kt + package com.test.package0 + import java.io.Serializable + + class Generic<T : Serializable?> { + fun <D : T> sampleFunction(): D = TODO() + } + """, + java = + """ + /src/com/test/package0/Generic.java + package com.test.package0; + import java.io.Serializable; + + public final class Generic<T extends Serializable> { + public final <D extends T> D sampleFunction(){ + return null; + } + } + """ + ) { + val map = singlePageOfType<JavadocClasslikePageNode>().templateMap + assertEquals("Generic", map["name"]) + + assertEquals( + "public final class <a href=Generic.html>Generic</a><T extends <a href=.html>Serializable</a>>", + map.signatureWithModifiers() + ) + val methods = assertIsInstance<Map<Any, Any?>>(map["methods"]) + val ownMethods = assertIsInstance<List<*>>(methods["own"]).first() + val sampleFunction = assertIsInstance<Map<String, Any?>>(ownMethods) + + assertEquals("final <D extends <a href=Generic.html>T</a>> <a href=Generic.html#sampleFunction()>D</a> <a href=Generic.html#sampleFunction()>sampleFunction</a>()", sampleFunction.signatureWithModifiers()) + } + } + + private fun assertParameterNode(node: Map<String, Any?>, expectedName: String, expectedType: String, expectedDescription: String){ + assertEquals(expectedName, node["name"]) + assertEquals(expectedType, node["type"]) + assertEquals(expectedDescription, node["description"]) + } + + private fun Map<String, Any?>.signatureWithModifiers(): String = "${modifiers()} ${signatureWithoutModifiers()}" + + private fun Map<String, Any?>.signatureWithoutModifiers(): String = (get("signature") as Map<String, Any?>)["signatureWithoutModifiers"] as String + + private fun Map<String, Any?>.modifiers(): String = (get("signature") as Map<String, Any?>)["modifiers"] as String + +} diff --git a/plugins/javadoc/src/test/kotlin/javadoc/JavadocModuleTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/JavadocModuleTemplateMapTest.kt new file mode 100644 index 00000000..b8bf41f2 --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/javadoc/JavadocModuleTemplateMapTest.kt @@ -0,0 +1,78 @@ +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 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<JavadocModulePageNode>().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<RowJavadocListEntry>(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<JavadocModulePageNode>().templateMap + val list = assertIsInstance<List<*>>(moduleTemplateMap["list"]) + assertEquals(2, list.size, "Expected two entries in 'list'") + assertEquals("com.test.package0", assertIsInstance<RowJavadocListEntry>(list[0]).link.name) + assertEquals("com.test.package1", assertIsInstance<RowJavadocListEntry>(list[1]).link.name) + assertEquals(DRI("com.test.package0"), assertIsInstance<RowJavadocListEntry>(list[0]).link.dri.single()) + assertEquals(DRI("com.test.package1"), assertIsInstance<RowJavadocListEntry>(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 new file mode 100644 index 00000000..e0ef030e --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/javadoc/JavadocPackageTemplateMapTest.kt @@ -0,0 +1,123 @@ +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 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<JavadocPackagePageNode>().templateMap + assertEquals("Class Summary", ((map["lists"] as List<*>).first() as Map<String, *>)["tabTitle"]) + assertEquals("Class", ((map["lists"] as List<*>).first() as Map<String, *>)["colTitle"]) + assertEquals("com.test.package0", map["title"]) + assertEquals("", map["subtitle"]) + assertEquals("package", map["kind"]) + + val list = assertIsInstance<List<*>>(((map["lists"] as List<*>).first() as Map<String, *>)["list"]) + val entry = assertIsInstance<RowJavadocListEntry>(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<JavadocPackagePageNode>() + packagePages.forEach { page -> + val map = page.templateMap + assertEquals("Class Summary", ((map["lists"] as List<*>).first() as Map<String, *>)["tabTitle"]) + assertEquals("Class", ((map["lists"] as List<*>).first() as Map<String, *>)["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<JavadocPackagePageNode>() + + 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 new file mode 100644 index 00000000..31a33ad5 --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt @@ -0,0 +1,69 @@ +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<Int> + |class Test2() : List<Int> + |/jvmSrc/javadoc/TestJ.java + |package javadoc + |abstract class Test3 extends List<Int> {} + """.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 new file mode 100644 index 00000000..235f68c0 --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/javadoc/location/JavadocLocationTest.kt @@ -0,0 +1,128 @@ +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.kt + |package javadoc + |import java.io.Serializable + |class Test<A>() : Serializable, Cloneable { + | fun test() {} + | fun test2(s: String) {} + | fun <T> 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<JavadocPackagePageNode>() + .firstChildOfType<JavadocClasslikePageNode>() + assertEquals( + " implements <a href=https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html>Serializable</a>, <a href=https://docs.oracle.com/javase/8/docs/api/java/lang/Cloneable.html>Cloneable</a>", + 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<JavadocPackagePageNode>() + .firstChildOfType<JavadocClasslikePageNode> { it.name == "Test" } + val testFunctionNode = testClassNode.methods.first { it.name == "test" } + assertEquals( + """<a href=Test.html#test()>test</a>()""", + 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<JavadocPackagePageNode>() + .firstChildOfType<JavadocClasslikePageNode> { it.name == "Test" } + val testFunctionNode = testClassNode.methods.first { it.name == "test2" } + assertEquals( + """<a href=Test.html#test2(String)>test2</a>(<a href=https://docs.oracle.com/javase/8/docs/api/java/lang/String.html>String</a> 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<JavadocPackagePageNode>() + .firstChildOfType<JavadocClasslikePageNode> { it.name == "Test" } + val testFunctionNode = testClassNode.methods.first { it.name == "test3" } + assertEquals( + """<a href=Test.html#test3(A,T)>test3</a>(<a href=Test.html>A</a> a, <a href=Test.html#test3(A,T)>T</a> t)""", + transformer.htmlForContentNode( + testFunctionNode.signature.signatureWithoutModifiers, + testClassNode + ) + ) + } + } + + private fun htmlTranslator(rootPageNode: RootPageNode, dokkaContext: DokkaContext) = JavadocContentToHtmlTranslator( + dokkaContext.plugin<JavadocPlugin>().querySingle { locationProviderFactory } + .getLocationProvider(rootPageNode), + dokkaContext + ) +} diff --git a/plugins/javadoc/src/test/kotlin/javadoc/search/JavadocIndexSearchTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/search/JavadocIndexSearchTest.kt new file mode 100644 index 00000000..6abed98d --- /dev/null +++ b/plugins/javadoc/src/test/kotlin/javadoc/search/JavadocIndexSearchTest.kt @@ -0,0 +1,59 @@ +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 |