| package org.jetbrains.dokka.tests |
| |
| import org.jetbrains.dokka.* |
| import org.junit.Before |
| import org.junit.Ignore |
| import org.junit.Test |
| |
| class MarkdownFormatTest: FileGeneratorTestCase() { |
| override val formatService = MarkdownFormatService(fileGenerator, KotlinLanguageService(), listOf()) |
| |
| @Test fun emptyDescription() { |
| verifyMarkdownNode("emptyDescription") |
| } |
| |
| @Test fun classWithCompanionObject() { |
| verifyMarkdownNode("classWithCompanionObject") |
| } |
| |
| @Test fun annotations() { |
| verifyMarkdownNode("annotations") |
| } |
| |
| @Test fun annotationClass() { |
| verifyMarkdownNode("annotationClass", withKotlinRuntime = true) |
| verifyMarkdownPackage("annotationClass", withKotlinRuntime = true) |
| } |
| |
| @Test fun exceptionClass() { |
| verifyMarkdownNode("exceptionClass", withKotlinRuntime = true) |
| verifyMarkdownPackage("exceptionClass", withKotlinRuntime = true) |
| } |
| |
| @Test fun annotationParams() { |
| verifyMarkdownNode("annotationParams", withKotlinRuntime = true) |
| } |
| |
| @Test fun extensions() { |
| verifyOutput("testdata/format/extensions.kt", ".package.md") { model, output -> |
| buildPagesAndReadInto(model.members, output) |
| } |
| verifyOutput("testdata/format/extensions.kt", ".class.md") { model, output -> |
| buildPagesAndReadInto(model.members.single().members, output) |
| } |
| } |
| |
| @Test fun enumClass() { |
| verifyOutput("testdata/format/enumClass.kt", ".md") { model, output -> |
| buildPagesAndReadInto(model.members.single().members, output) |
| } |
| verifyOutput("testdata/format/enumClass.kt", ".value.md") { model, output -> |
| val enumClassNode = model.members.single().members[0] |
| buildPagesAndReadInto( |
| enumClassNode.members.filter { it.name == "LOCAL_CONTINUE_AND_BREAK" }, |
| output |
| ) |
| } |
| } |
| |
| @Test fun varargsFunction() { |
| verifyMarkdownNode("varargsFunction") |
| } |
| |
| @Test fun overridingFunction() { |
| verifyMarkdownNodes("overridingFunction") { model-> |
| val classMembers = model.members.single().members.first { it.name == "D" }.members |
| classMembers.filter { it.name == "f" } |
| } |
| } |
| |
| @Test fun propertyVar() { |
| verifyMarkdownNode("propertyVar") |
| } |
| |
| @Test fun functionWithDefaultParameter() { |
| verifyMarkdownNode("functionWithDefaultParameter") |
| } |
| |
| @Test fun accessor() { |
| verifyMarkdownNodes("accessor") { model -> |
| model.members.single().members.first { it.name == "C" }.members.filter { it.name == "x" } |
| } |
| } |
| |
| @Test fun paramTag() { |
| verifyMarkdownNode("paramTag") |
| } |
| |
| @Test fun throwsTag() { |
| verifyMarkdownNode("throwsTag") |
| } |
| |
| @Test fun typeParameterBounds() { |
| verifyMarkdownNode("typeParameterBounds") |
| } |
| |
| @Test fun typeParameterVariance() { |
| verifyMarkdownNode("typeParameterVariance") |
| } |
| |
| @Test fun typeProjectionVariance() { |
| verifyMarkdownNode("typeProjectionVariance") |
| } |
| |
| @Test |
| fun javadocCodeMultiline() { |
| verifyJavaMarkdownNode("javadocCodeMultiline") |
| } |
| |
| // TODO: FIXME |
| @Ignore |
| @Test |
| fun javadocHtml() { |
| verifyJavaMarkdownNode("javadocHtml") |
| } |
| |
| // TODO: FIXME |
| @Ignore |
| @Test |
| fun javaCodeLiteralTags() { |
| verifyJavaMarkdownNode("javaCodeLiteralTags") |
| } |
| |
| @Test |
| fun javaSample() { |
| verifyJavaMarkdownNode("javaSample") |
| } |
| |
| // TODO: FIXME |
| @Ignore |
| @Test |
| fun javaCodeInParam() { |
| verifyJavaMarkdownNode("javaCodeInParam") |
| } |
| |
| @Test fun javaSpaceInAuthor() { |
| verifyJavaMarkdownNode("javaSpaceInAuthor") |
| } |
| |
| @Test fun nullability() { |
| verifyMarkdownNode("nullability") |
| } |
| |
| @Test fun operatorOverloading() { |
| verifyMarkdownNodes("operatorOverloading") { model-> |
| model.members.single().members.single { it.name == "C" }.members.filter { it.name == "plus" } |
| } |
| } |
| |
| @Test fun javadocOrderedList() { |
| verifyJavaMarkdownNodes("javadocOrderedList") { model -> |
| model.members.single().members.filter { it.name == "Bar" } |
| } |
| } |
| |
| @Test fun codeBlockNoHtmlEscape() { |
| verifyMarkdownNodeByName("codeBlockNoHtmlEscape", "hackTheArithmetic") |
| } |
| |
| @Test fun companionObjectExtension() { |
| verifyMarkdownNodeByName("companionObjectExtension", "Foo") |
| } |
| |
| @Test fun starProjection() { |
| verifyMarkdownNode("starProjection") |
| } |
| |
| @Test fun extensionFunctionParameter() { |
| verifyMarkdownNode("extensionFunctionParameter") |
| } |
| |
| @Test fun summarizeSignatures() { |
| verifyMarkdownNodes("summarizeSignatures") { model -> model.members } |
| } |
| |
| @Test fun summarizeSignaturesProperty() { |
| verifyMarkdownNodes("summarizeSignaturesProperty") { model -> model.members } |
| } |
| |
| @Test fun reifiedTypeParameter() { |
| verifyMarkdownNode("reifiedTypeParameter", withKotlinRuntime = true) |
| } |
| |
| @Test fun annotatedTypeParameter() { |
| verifyMarkdownNode("annotatedTypeParameter", withKotlinRuntime = true) |
| } |
| |
| @Test fun inheritedMembers() { |
| verifyMarkdownNodeByName("inheritedMembers", "Bar") |
| } |
| |
| @Test fun inheritedExtensions() { |
| verifyMarkdownNodeByName("inheritedExtensions", "Bar") |
| } |
| |
| @Test fun genericInheritedExtensions() { |
| verifyMarkdownNodeByName("genericInheritedExtensions", "Bar") |
| } |
| |
| @Test fun arrayAverage() { |
| verifyMarkdownNodeByName("arrayAverage", "XArray") |
| } |
| |
| @Test fun multipleTypeParameterConstraints() { |
| verifyMarkdownNode("multipleTypeParameterConstraints", withKotlinRuntime = true) |
| } |
| |
| @Test fun inheritedCompanionObjectProperties() { |
| verifyMarkdownNodeByName("inheritedCompanionObjectProperties", "C") |
| } |
| |
| @Test fun shadowedExtensionFunctions() { |
| verifyMarkdownNodeByName("shadowedExtensionFunctions", "Bar") |
| } |
| |
| @Test fun inapplicableExtensionFunctions() { |
| verifyMarkdownNodeByName("inapplicableExtensionFunctions", "Bar") |
| } |
| |
| @Test fun receiverParameterTypeBound() { |
| verifyMarkdownNodeByName("receiverParameterTypeBound", "Foo") |
| } |
| |
| @Test fun extensionWithDocumentedReceiver() { |
| verifyMarkdownNodes("extensionWithDocumentedReceiver") { model -> |
| model.members.single().members.single().members.filter { it.name == "fn" } |
| } |
| } |
| |
| @Test fun codeBlock() { |
| verifyMarkdownNode("codeBlock") |
| } |
| |
| @Test fun exclInCodeBlock() { |
| verifyMarkdownNodeByName("exclInCodeBlock", "foo") |
| } |
| |
| @Test fun backtickInCodeBlock() { |
| verifyMarkdownNodeByName("backtickInCodeBlock", "foo") |
| } |
| |
| @Test fun qualifiedNameLink() { |
| verifyMarkdownNodeByName("qualifiedNameLink", "foo", withKotlinRuntime = true) |
| } |
| |
| @Test fun functionalTypeWithNamedParameters() { |
| verifyMarkdownNode("functionalTypeWithNamedParameters") |
| } |
| |
| @Test fun typeAliases() { |
| verifyMarkdownNode("typeAliases") |
| verifyMarkdownPackage("typeAliases") |
| } |
| |
| @Test fun sampleByFQName() { |
| verifyMarkdownNode("sampleByFQName") |
| } |
| |
| @Test fun sampleByShortName() { |
| verifyMarkdownNode("sampleByShortName") |
| } |
| |
| |
| @Test fun suspendParam() { |
| verifyMarkdownNode("suspendParam") |
| verifyMarkdownPackage("suspendParam") |
| } |
| |
| @Test fun sinceKotlin() { |
| verifyMarkdownNode("sinceKotlin") |
| verifyMarkdownPackage("sinceKotlin") |
| } |
| |
| @Test fun sinceKotlinWide() { |
| verifyMarkdownPackage("sinceKotlinWide") |
| } |
| |
| @Test fun dynamicType() { |
| verifyMarkdownNode("dynamicType") |
| } |
| |
| @Test fun dynamicExtension() { |
| verifyMarkdownNodes("dynamicExtension") { model -> model.members.single().members.filter { it.name == "Foo" } } |
| } |
| |
| @Test fun memberExtension() { |
| verifyMarkdownNodes("memberExtension") { model -> model.members.single().members.filter { it.name == "Foo" } } |
| } |
| |
| @Test fun renderFunctionalTypeInParenthesisWhenItIsReceiver() { |
| verifyMarkdownNode("renderFunctionalTypeInParenthesisWhenItIsReceiver") |
| } |
| |
| @Test fun multiplePlatforms() { |
| verifyMultiplatformPackage(buildMultiplePlatforms("multiplatform/simple"), "multiplatform/simple") |
| } |
| |
| @Test fun multiplePlatformsMerge() { |
| verifyMultiplatformPackage(buildMultiplePlatforms("multiplatform/merge"), "multiplatform/merge") |
| } |
| |
| @Test fun multiplePlatformsMergeMembers() { |
| val module = buildMultiplePlatforms("multiplatform/mergeMembers") |
| verifyModelOutput(module, ".md", "testdata/format/multiplatform/mergeMembers/foo.kt") { model, output -> |
| buildPagesAndReadInto(model.members.single().members, output) |
| } |
| } |
| |
| @Test fun multiplePlatformsOmitRedundant() { |
| val module = buildMultiplePlatforms("multiplatform/omitRedundant") |
| verifyModelOutput(module, ".md", "testdata/format/multiplatform/omitRedundant/foo.kt") { model, output -> |
| buildPagesAndReadInto(model.members.single().members, output) |
| } |
| } |
| |
| @Test fun multiplePlatformsImplied() { |
| val module = buildMultiplePlatforms("multiplatform/implied") |
| verifyModelOutput(module, ".md", "testdata/format/multiplatform/implied/foo.kt") { model, output -> |
| val service = MarkdownFormatService(fileGenerator, KotlinLanguageService(), listOf("JVM", "JS")) |
| fileGenerator.formatService = service |
| buildPagesAndReadInto(model.members.single().members, output) |
| } |
| } |
| |
| @Test fun packagePlatformsWithExtExtensions() { |
| val path = "multiplatform/packagePlatformsWithExtExtensions" |
| val module = DocumentationModule("test") |
| val options = DocumentationOptions( |
| outputDir = "", |
| outputFormat = "html", |
| generateClassIndexPage = false, |
| generatePackageIndexPage = false, |
| noStdlibLink = true, |
| noJdkLink = true, |
| languageVersion = null, |
| apiVersion = null |
| ) |
| appendDocumentation(module, contentRootFromPath("testdata/format/$path/jvm.kt"), defaultPlatforms = listOf("JVM"), withKotlinRuntime = true, options = options) |
| verifyMultiplatformIndex(module, path) |
| verifyMultiplatformPackage(module, path) |
| } |
| |
| @Test fun multiplePlatformsPackagePlatformFromMembers() { |
| val path = "multiplatform/packagePlatformsFromMembers" |
| val module = buildMultiplePlatforms(path) |
| verifyMultiplatformIndex(module, path) |
| verifyMultiplatformPackage(module, path) |
| } |
| |
| @Test fun multiplePlatformsGroupNode() { |
| val path = "multiplatform/groupNode" |
| val module = buildMultiplePlatforms(path) |
| verifyModelOutput(module, ".md", "testdata/format/$path/multiplatform.kt") { model, output -> |
| buildPagesAndReadInto( |
| listOfNotNull(model.members.single().members.find { it.kind == NodeKind.GroupNode }), |
| output |
| ) |
| } |
| verifyMultiplatformPackage(module, path) |
| } |
| |
| @Test fun multiplePlatformsBreadcrumbsInMemberOfMemberOfGroupNode() { |
| val path = "multiplatform/breadcrumbsInMemberOfMemberOfGroupNode" |
| val module = buildMultiplePlatforms(path) |
| verifyModelOutput(module, ".md", "testdata/format/$path/multiplatform.kt") { model, output -> |
| buildPagesAndReadInto( |
| listOfNotNull(model.members.single().members.find { it.kind == NodeKind.GroupNode }?.member(NodeKind.Class)?.member(NodeKind.Function)), |
| output |
| ) |
| } |
| } |
| |
| @Test fun linksInEmphasis() { |
| verifyMarkdownNode("linksInEmphasis") |
| } |
| |
| @Test fun linksInStrong() { |
| verifyMarkdownNode("linksInStrong") |
| } |
| |
| @Test fun linksInHeaders() { |
| verifyMarkdownNode("linksInHeaders") |
| } |
| |
| @Test fun tokensInEmphasis() { |
| verifyMarkdownNode("tokensInEmphasis") |
| } |
| |
| @Test fun tokensInStrong() { |
| verifyMarkdownNode("tokensInStrong") |
| } |
| |
| @Test fun tokensInHeaders() { |
| verifyMarkdownNode("tokensInHeaders") |
| } |
| |
| @Test fun unorderedLists() { |
| verifyMarkdownNode("unorderedLists") |
| } |
| |
| @Test fun nestedLists() { |
| verifyMarkdownNode("nestedLists") |
| } |
| |
| @Test fun referenceLink() { |
| verifyMarkdownNode("referenceLink") |
| } |
| |
| @Test fun externalReferenceLink() { |
| verifyMarkdownNode("externalReferenceLink") |
| } |
| |
| @Test fun newlineInTableCell() { |
| verifyMarkdownPackage("newlineInTableCell") |
| } |
| |
| @Test fun indentedCodeBlock() { |
| verifyMarkdownNode("indentedCodeBlock") |
| } |
| |
| @Test fun receiverReference() { |
| verifyMarkdownNode("receiverReference") |
| } |
| |
| @Test fun extensionScope() { |
| verifyMarkdownNodeByName("extensionScope", "test") |
| } |
| |
| @Test fun typeParameterReference() { |
| verifyMarkdownNode("typeParameterReference") |
| } |
| |
| @Test fun notPublishedTypeAliasAutoExpansion() { |
| verifyMarkdownNodeByName("notPublishedTypeAliasAutoExpansion", "foo", includeNonPublic = false) |
| } |
| |
| @Test fun companionImplements() { |
| verifyMarkdownNodeByName("companionImplements", "Foo") |
| } |
| |
| @Test fun enumRef() { |
| verifyMarkdownNode("enumRef") |
| } |
| |
| @Test fun inheritedLink() { |
| val filePath = "testdata/format/inheritedLink" |
| verifyOutput( |
| arrayOf( |
| contentRootFromPath("$filePath.kt"), |
| contentRootFromPath("$filePath.1.kt") |
| ), |
| ".md", |
| withJdk = true, |
| withKotlinRuntime = true, |
| includeNonPublic = false |
| ) { model, output -> |
| buildPagesAndReadInto(model.members.single { it.name == "p2" }.members.single().members, output) |
| } |
| } |
| |
| |
| private fun buildMultiplePlatforms(path: String): DocumentationModule { |
| val module = DocumentationModule("test") |
| val options = DocumentationOptions( |
| outputDir = "", |
| outputFormat = "html", |
| generateClassIndexPage = false, |
| generatePackageIndexPage = false, |
| noStdlibLink = true, |
| noJdkLink = true, |
| languageVersion = null, |
| apiVersion = null |
| ) |
| appendDocumentation(module, contentRootFromPath("testdata/format/$path/jvm.kt"), defaultPlatforms = listOf("JVM"), options = options) |
| appendDocumentation(module, contentRootFromPath("testdata/format/$path/js.kt"), defaultPlatforms = listOf("JS"), options = options) |
| return module |
| } |
| |
| private fun verifyMultiplatformPackage(module: DocumentationModule, path: String) { |
| verifyModelOutput(module, ".package.md", "testdata/format/$path/multiplatform.kt") { model, output -> |
| buildPagesAndReadInto(model.members, output) |
| } |
| } |
| |
| private fun verifyMultiplatformIndex(module: DocumentationModule, path: String) { |
| verifyModelOutput(module, ".md", "testdata/format/$path/multiplatform.index.kt") { |
| model, output -> |
| val service = MarkdownFormatService(fileGenerator, KotlinLanguageService(), listOf()) |
| fileGenerator.formatService = service |
| buildPagesAndReadInto(listOf(model), output) |
| } |
| } |
| |
| @Test fun blankLineInsideCodeBlock() { |
| verifyMarkdownNode("blankLineInsideCodeBlock") |
| } |
| |
| private fun verifyMarkdownPackage(fileName: String, withKotlinRuntime: Boolean = false) { |
| verifyOutput("testdata/format/$fileName.kt", ".package.md", withKotlinRuntime = withKotlinRuntime) { model, output -> |
| buildPagesAndReadInto(model.members, output) |
| } |
| } |
| |
| private fun verifyMarkdownNode(fileName: String, withKotlinRuntime: Boolean = false) { |
| verifyMarkdownNodes(fileName, withKotlinRuntime) { model -> model.members.single().members } |
| } |
| |
| private fun verifyMarkdownNodes( |
| fileName: String, |
| withKotlinRuntime: Boolean = false, |
| includeNonPublic: Boolean = true, |
| nodeFilter: (DocumentationModule) -> List<DocumentationNode> |
| ) { |
| verifyOutput( |
| "testdata/format/$fileName.kt", |
| ".md", |
| withKotlinRuntime = withKotlinRuntime, |
| includeNonPublic = includeNonPublic |
| ) { model, output -> |
| buildPagesAndReadInto(nodeFilter(model), output) |
| } |
| } |
| |
| private fun verifyJavaMarkdownNode(fileName: String, withKotlinRuntime: Boolean = false) { |
| verifyJavaMarkdownNodes(fileName, withKotlinRuntime) { model -> model.members.single().members } |
| } |
| |
| private fun verifyJavaMarkdownNodes(fileName: String, withKotlinRuntime: Boolean = false, nodeFilter: (DocumentationModule) -> List<DocumentationNode>) { |
| verifyJavaOutput("testdata/format/$fileName.java", ".md", withKotlinRuntime = withKotlinRuntime) { model, output -> |
| buildPagesAndReadInto(nodeFilter(model), output) |
| } |
| } |
| |
| private fun verifyMarkdownNodeByName( |
| fileName: String, |
| name: String, |
| withKotlinRuntime: Boolean = false, |
| includeNonPublic: Boolean = true |
| ) { |
| verifyMarkdownNodes(fileName, withKotlinRuntime, includeNonPublic) { model-> |
| val nodesWithName = model.members.single().members.filter { it.name == name } |
| if (nodesWithName.isEmpty()) { |
| throw IllegalArgumentException("Found no nodes named $name") |
| } |
| nodesWithName |
| } |
| } |
| } |