Merge branch 'dev-0.11.0'

25 files changed, 108 insertions, 3800 deletions

diff --git a/core/src/test/kotlin/DokkaConfigurationTestImplementations.kt b/core/src/test/kotlin/DokkaConfigurationTestImplementations.kt
deleted file mode 100644
index a6f427b1..00000000
--- a/core/src/test/kotlin/DokkaConfigurationTestImplementations.kt
+++ /dev/null
@@ -1,81 +0,0 @@
-package org.jetbrains.dokka.tests
-
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.Platform
-import java.io.File
-
-
-data class SourceLinkDefinitionImpl(override val path: String,
-                                    override val url: String,
-                                    override val lineSuffix: String?) : DokkaConfiguration.SourceLinkDefinition {
-    companion object {
-        fun parseSourceLinkDefinition(srcLink: String): DokkaConfiguration.SourceLinkDefinition {
-            val (path, urlAndLine) = srcLink.split('=')
-            return SourceLinkDefinitionImpl(
-                File(path).canonicalPath,
-                    urlAndLine.substringBefore("#"),
-                    urlAndLine.substringAfter("#", "").let { if (it.isEmpty()) null else "#$it" })
-        }
-    }
-}
-
-class SourceRootImpl(path: String) : DokkaConfiguration.SourceRoot {
-    override val path: String = File(path).absolutePath
-
-    companion object {
-        fun parseSourceRoot(sourceRoot: String): DokkaConfiguration.SourceRoot = SourceRootImpl(sourceRoot)
-    }
-}
-
-data class PackageOptionsImpl(override val prefix: String,
-                              override val includeNonPublic: Boolean = false,
-                              override val reportUndocumented: Boolean = true,
-                              override val skipDeprecated: Boolean = false,
-                              override val suppress: Boolean = false) : DokkaConfiguration.PackageOptions
-
- class DokkaConfigurationImpl(
-    override val outputDir: String = "",
-    override val format: String = "html",
-    override val generateIndexPages: Boolean = false,
-    override val cacheRoot: String? = null,
-    override val impliedPlatforms: List<String> = emptyList(),
-    override val passesConfigurations: List<DokkaConfiguration.PassConfiguration> = emptyList()
-) : DokkaConfiguration
-
-class PassConfigurationImpl (
-    override val classpath: List<String> = emptyList(),
-    override val moduleName: String = "",
-    override val sourceRoots: List<DokkaConfiguration.SourceRoot> = emptyList(),
-    override val samples: List<String> = emptyList(),
-    override val includes: List<String> = emptyList(),
-    override val includeNonPublic: Boolean = false,
-    override val includeRootPackage: Boolean = false,
-    override val reportUndocumented: Boolean = false,
-    override val skipEmptyPackages: Boolean = false,
-    override val skipDeprecated: Boolean = false,
-    override val jdkVersion: Int = 6,
-    override val sourceLinks: List<DokkaConfiguration.SourceLinkDefinition> = emptyList(),
-    override val perPackageOptions: List<DokkaConfiguration.PackageOptions> = emptyList(),
-    externalDocumentationLinks: List<DokkaConfiguration.ExternalDocumentationLink> = emptyList(),
-    override val languageVersion: String? = null,
-    override val apiVersion: String? = null,
-    override val noStdlibLink: Boolean = false,
-    override val noJdkLink: Boolean = false,
-    override val suppressedFiles: List<String> = emptyList(),
-    override val collectInheritedExtensionsFromLibraries: Boolean = false,
-    override val analysisPlatform: Platform = Platform.DEFAULT,
-    override val targets: List<String> = emptyList(),
-    override val sinceKotlin: String? = null
-): DokkaConfiguration.PassConfiguration {
-    private val defaultLinks = run {
-        val links = mutableListOf<DokkaConfiguration.ExternalDocumentationLink>()
-        if (!noJdkLink)
-            links += DokkaConfiguration.ExternalDocumentationLink.Builder("https://docs.oracle.com/javase/$jdkVersion/docs/api/").build()
-
-        if (!noStdlibLink)
-            links += DokkaConfiguration.ExternalDocumentationLink.Builder("https://kotlinlang.org/api/latest/jvm/stdlib/").build()
-        links
-    }
-    override val externalDocumentationLinks = defaultLinks + externalDocumentationLinks
-}
-
diff --git a/core/src/test/kotlin/NodeSelect.kt b/core/src/test/kotlin/NodeSelect.kt
deleted file mode 100644
index fe0394f9..00000000
--- a/core/src/test/kotlin/NodeSelect.kt
+++ /dev/null
@@ -1,90 +0,0 @@
-package org.jetbrains.dokka.tests
-
-import org.jetbrains.dokka.DocumentationNode
-import org.jetbrains.dokka.NodeKind
-import org.jetbrains.dokka.RefKind
-
-class SelectBuilder {
-    private val root = ChainFilterNode(SubgraphTraverseFilter(), null)
-    private var activeNode = root
-    private val chainEnds = mutableListOf<SelectFilter>()
-
-    fun withName(name: String) = matching { it.name == name }
-
-    fun withKind(kind: NodeKind) = matching{ it.kind == kind }
-
-    fun matching(block: (DocumentationNode) -> Boolean) {
-        attachFilterAndMakeActive(PredicateFilter(block))
-    }
-
-    fun subgraph() {
-        attachFilterAndMakeActive(SubgraphTraverseFilter())
-    }
-
-    fun subgraphOf(kind: RefKind) {
-        attachFilterAndMakeActive(DirectEdgeFilter(kind))
-    }
-
-    private fun attachFilterAndMakeActive(next: SelectFilter) {
-        activeNode = ChainFilterNode(next, activeNode)
-    }
-
-    private fun endChain() {
-        chainEnds += activeNode
-    }
-
-    fun build(): SelectFilter {
-        endChain()
-        return CombineFilterNode(chainEnds)
-    }
-}
-
-private class ChainFilterNode(val filter: SelectFilter, val previous: SelectFilter?): SelectFilter() {
-    override fun select(roots: Sequence<DocumentationNode>): Sequence<DocumentationNode> {
-        return filter.select(previous?.select(roots) ?: roots)
-    }
-}
-
-private class CombineFilterNode(val previous: List<SelectFilter>): SelectFilter() {
-    override fun select(roots: Sequence<DocumentationNode>): Sequence<DocumentationNode> {
-        return previous.asSequence().flatMap { it.select(roots) }
-    }
-}
-
-abstract class SelectFilter {
-    abstract fun select(roots: Sequence<DocumentationNode>): Sequence<DocumentationNode>
-}
-
-private class SubgraphTraverseFilter: SelectFilter() {
-    override fun select(roots: Sequence<DocumentationNode>): Sequence<DocumentationNode> {
-        val visited = mutableSetOf<DocumentationNode>()
-        return roots.flatMap {
-            generateSequence(listOf(it)) { nodes ->
-                nodes.flatMap { it.allReferences() }
-                    .map { it.to }
-                    .filter { visited.add(it) }
-                    .takeUnless { it.isEmpty() }
-            }
-        }.flatten()
-    }
-
-}
-
-private class PredicateFilter(val condition: (DocumentationNode) -> Boolean): SelectFilter() {
-    override fun select(roots: Sequence<DocumentationNode>): Sequence<DocumentationNode> {
-        return roots.filter(condition)
-    }
-}
-
-private class DirectEdgeFilter(val kind: RefKind): SelectFilter() {
-    override fun select(roots: Sequence<DocumentationNode>): Sequence<DocumentationNode> {
-        return roots.flatMap { it.references(kind).asSequence() }.map { it.to }
-    }
-}
-
-
-fun selectNodes(root: DocumentationNode, block: SelectBuilder.() -> Unit): List<DocumentationNode> {
-    val builder = SelectBuilder()
-    builder.apply(block)
-    return builder.build().select(sequenceOf(root)).toMutableSet().toList()
-}
\ No newline at end of file
diff --git a/core/src/test/kotlin/TestAPI.kt b/core/src/test/kotlin/TestAPI.kt
deleted file mode 100644
index 4f9af761..00000000
--- a/core/src/test/kotlin/TestAPI.kt
+++ /dev/null
@@ -1,353 +0,0 @@
-package org.jetbrains.dokka.tests
-
-import com.google.inject.Guice
-import com.intellij.openapi.application.PathManager
-import com.intellij.openapi.util.Disposer
-import com.intellij.openapi.util.io.FileUtil
-import com.intellij.rt.execution.junit.FileComparisonFailure
-import org.jetbrains.dokka.*
-import org.jetbrains.dokka.Utilities.DokkaAnalysisModule
-import org.jetbrains.dokka.Utilities.DokkaRunModule
-import org.jetbrains.kotlin.cli.common.config.ContentRoot
-import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.utils.PathUtil
-import org.junit.Assert
-import org.junit.Assert.fail
-import java.io.File
-
-data class ModelConfig(
-    val roots: Array<ContentRoot> = arrayOf(),
-    val withJdk: Boolean = false,
-    val withKotlinRuntime: Boolean = false,
-    val format: String = "html",
-    val includeNonPublic: Boolean = true,
-    val perPackageOptions: List<DokkaConfiguration.PackageOptions> = emptyList(),
-    val analysisPlatform: Platform = Platform.DEFAULT,
-    val defaultPlatforms: List<String> = emptyList(),
-    val noStdlibLink: Boolean = true,
-    val collectInheritedExtensionsFromLibraries: Boolean = false,
-    val sourceLinks: List<DokkaConfiguration.SourceLinkDefinition> = emptyList()
-)
-
-fun verifyModel(
-    modelConfig: ModelConfig,
-    verifier: (DocumentationModule) -> Unit
-) {
-    val documentation = DocumentationModule("test")
-
-    val passConfiguration = PassConfigurationImpl(
-        includeNonPublic = modelConfig.includeNonPublic,
-        skipEmptyPackages = false,
-        includeRootPackage = true,
-        sourceLinks = modelConfig.sourceLinks,
-        perPackageOptions = modelConfig.perPackageOptions,
-        noStdlibLink = modelConfig.noStdlibLink,
-        noJdkLink = false,
-        languageVersion = null,
-        apiVersion = null,
-        collectInheritedExtensionsFromLibraries = modelConfig.collectInheritedExtensionsFromLibraries
-    )
-    val configuration = DokkaConfigurationImpl(
-        outputDir = "",
-        format = modelConfig.format,
-        generateIndexPages = false,
-        cacheRoot = "default",
-        passesConfigurations = listOf(passConfiguration)
-    )
-
-    appendDocumentation(documentation, configuration, passConfiguration, modelConfig)
-    documentation.prepareForGeneration(configuration)
-
-    verifier(documentation)
-}
-
-fun appendDocumentation(
-    documentation: DocumentationModule,
-    dokkaConfiguration: DokkaConfiguration,
-    passConfiguration: DokkaConfiguration.PassConfiguration,
-    modelConfig: ModelConfig
-) {
-    val messageCollector = object : MessageCollector {
-        override fun clear() {
-
-        }
-
-        override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
-            when (severity) {
-                CompilerMessageSeverity.STRONG_WARNING,
-                CompilerMessageSeverity.WARNING,
-                CompilerMessageSeverity.LOGGING,
-                CompilerMessageSeverity.OUTPUT,
-                CompilerMessageSeverity.INFO,
-                CompilerMessageSeverity.ERROR -> {
-                    println("$severity: $message at $location")
-                }
-                CompilerMessageSeverity.EXCEPTION -> {
-                    fail("$severity: $message at $location")
-                }
-            }
-        }
-
-        override fun hasErrors() = false
-    }
-
-    val environment = AnalysisEnvironment(messageCollector, modelConfig.analysisPlatform)
-    environment.apply {
-        if (modelConfig.withJdk || modelConfig.withKotlinRuntime) {
-            addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
-        }
-        if (modelConfig.withKotlinRuntime) {
-            if (analysisPlatform == Platform.jvm) {
-                val kotlinStrictfpRoot = PathManager.getResourceRoot(Strictfp::class.java, "/kotlin/jvm/Strictfp.class")
-                addClasspath(File(kotlinStrictfpRoot))
-            }
-            if (analysisPlatform == Platform.js) {
-                val kotlinStdlibJsRoot = PathManager.getResourceRoot(Any::class.java, "/kotlin/jquery")
-                addClasspath(File(kotlinStdlibJsRoot))
-            }
-
-            if (analysisPlatform == Platform.common) {
-                // TODO: Feels hacky
-                val kotlinStdlibCommonRoot = ClassLoader.getSystemResource("kotlin/UInt.kotlin_metadata")
-                addClasspath(File(kotlinStdlibCommonRoot.file.replace("file:", "").replaceAfter(".jar", "")))
-            }
-        }
-        addRoots(modelConfig.roots.toList())
-
-        loadLanguageVersionSettings(passConfiguration.languageVersion, passConfiguration.apiVersion)
-    }
-    val defaultPlatformsProvider = object : DefaultPlatformsProvider {
-        override fun getDefaultPlatforms(descriptor: DeclarationDescriptor) = modelConfig.defaultPlatforms
-    }
-
-    val globalInjector = Guice.createInjector(
-        DokkaRunModule(dokkaConfiguration)
-    )
-
-    val injector = globalInjector.createChildInjector(
-        DokkaAnalysisModule(
-            environment,
-            dokkaConfiguration,
-            defaultPlatformsProvider,
-            documentation.nodeRefGraph,
-            passConfiguration,
-            DokkaConsoleLogger
-        )
-    )
-
-    buildDocumentationModule(injector, documentation)
-    Disposer.dispose(environment)
-}
-
-fun checkSourceExistsAndVerifyModel(
-    source: String,
-    modelConfig: ModelConfig = ModelConfig(),
-    verifier: (DocumentationModule) -> Unit
-) {
-    require(File(source).exists()) {
-        "Cannot find test data file $source"
-    }
-    verifyModel(
-        ModelConfig(
-            roots = arrayOf(contentRootFromPath(source)),
-            withJdk = modelConfig.withJdk,
-            withKotlinRuntime = modelConfig.withKotlinRuntime,
-            format = modelConfig.format,
-            includeNonPublic = modelConfig.includeNonPublic,
-            sourceLinks = modelConfig.sourceLinks,
-            analysisPlatform = modelConfig.analysisPlatform
-        ),
-
-        verifier = verifier
-    )
-}
-
-fun verifyPackageMember(
-    source: String,
-    modelConfig: ModelConfig = ModelConfig(),
-    verifier: (DocumentationNode) -> Unit
-) {
-    checkSourceExistsAndVerifyModel(
-        source,
-        modelConfig = ModelConfig(
-            withJdk = modelConfig.withJdk,
-            withKotlinRuntime = modelConfig.withKotlinRuntime,
-            analysisPlatform = modelConfig.analysisPlatform
-        )
-    ) { model ->
-        val pkg = model.members.single()
-        verifier(pkg.members.single())
-    }
-}
-
-fun verifyJavaModel(
-    source: String,
-    modelConfig: ModelConfig = ModelConfig(),
-    verifier: (DocumentationModule) -> Unit
-) {
-    val tempDir = FileUtil.createTempDirectory("dokka", "")
-    try {
-        val sourceFile = File(source)
-        FileUtil.copy(sourceFile, File(tempDir, sourceFile.name))
-        verifyModel(
-            ModelConfig(
-                roots = arrayOf(JavaSourceRoot(tempDir, null)),
-                withJdk = true,
-                withKotlinRuntime = modelConfig.withKotlinRuntime,
-                analysisPlatform = modelConfig.analysisPlatform
-            ),
-            verifier = verifier
-        )
-    } finally {
-        FileUtil.delete(tempDir)
-    }
-}
-
-fun verifyJavaPackageMember(
-    source: String,
-    modelConfig: ModelConfig = ModelConfig(),
-    verifier: (DocumentationNode) -> Unit
-) {
-    verifyJavaModel(source, modelConfig) { model ->
-        val pkg = model.members.single()
-        verifier(pkg.members.single())
-    }
-}
-
-fun verifyOutput(
-    modelConfig: ModelConfig = ModelConfig(),
-    outputExtension: String,
-    outputGenerator: (DocumentationModule, StringBuilder) -> Unit
-) {
-    verifyModel(modelConfig) {
-        verifyModelOutput(it, outputExtension, modelConfig.roots.first().path, outputGenerator)
-    }
-}
-
-fun verifyOutput(
-    path: String,
-    outputExtension: String,
-    modelConfig: ModelConfig = ModelConfig(),
-    outputGenerator: (DocumentationModule, StringBuilder) -> Unit
-) {
-    verifyOutput(
-        ModelConfig(
-            roots = arrayOf(contentRootFromPath(path)) + modelConfig.roots,
-            withJdk = modelConfig.withJdk,
-            withKotlinRuntime = modelConfig.withKotlinRuntime,
-            format = modelConfig.format,
-            includeNonPublic = modelConfig.includeNonPublic,
-            analysisPlatform = modelConfig.analysisPlatform,
-            noStdlibLink = modelConfig.noStdlibLink,
-            collectInheritedExtensionsFromLibraries = modelConfig.collectInheritedExtensionsFromLibraries
-        ),
-        outputExtension,
-        outputGenerator
-    )
-}
-
-fun verifyModelOutput(
-    it: DocumentationModule,
-    outputExtension: String,
-    sourcePath: String,
-    outputGenerator: (DocumentationModule, StringBuilder) -> Unit
-) {
-    val output = StringBuilder()
-    outputGenerator(it, output)
-    val ext = outputExtension.removePrefix(".")
-    val expectedFile = File(sourcePath.replaceAfterLast(".", ext, sourcePath + "." + ext))
-    assertEqualsIgnoringSeparators(expectedFile, output.toString())
-}
-
-fun verifyJavaOutput(
-    path: String,
-    outputExtension: String,
-    modelConfig: ModelConfig = ModelConfig(),
-    outputGenerator: (DocumentationModule, StringBuilder) -> Unit
-) {
-    verifyJavaModel(path, modelConfig) { model ->
-        verifyModelOutput(model, outputExtension, path, outputGenerator)
-    }
-}
-
-fun assertEqualsIgnoringSeparators(expectedFile: File, output: String) {
-    if (!expectedFile.exists()) expectedFile.createNewFile()
-    val expectedText = expectedFile.readText().replace("\r\n", "\n")
-    val actualText = output.replace("\r\n", "\n")
-
-    if (expectedText != actualText)
-        throw FileComparisonFailure("", expectedText, actualText, expectedFile.canonicalPath)
-}
-
-fun assertEqualsIgnoringSeparators(expectedOutput: String, output: String) {
-    Assert.assertEquals(expectedOutput.replace("\r\n", "\n"), output.replace("\r\n", "\n"))
-}
-
-fun StringBuilder.appendChildren(node: ContentBlock): StringBuilder {
-    for (child in node.children) {
-        val childText = child.toTestString()
-        append(childText)
-    }
-    return this
-}
-
-fun StringBuilder.appendNode(node: ContentNode): StringBuilder {
-    when (node) {
-        is ContentText -> {
-            append(node.text)
-        }
-        is ContentEmphasis -> append("*").appendChildren(node).append("*")
-        is ContentBlockCode -> {
-            if (node.language.isNotBlank())
-                appendln("[code lang=${node.language}]")
-            else
-                appendln("[code]")
-            appendChildren(node)
-            appendln()
-            appendln("[/code]")
-        }
-        is ContentNodeLink -> {
-            append("[")
-            appendChildren(node)
-            append(" -> ")
-            append(node.node.toString())
-            append("]")
-        }
-        is ContentBlock -> {
-            appendChildren(node)
-        }
-        is NodeRenderContent -> {
-            append("render(")
-            append(node.node)
-            append(",")
-            append(node.mode)
-            append(")")
-        }
-        is ContentSymbol -> {
-            append(node.text)
-        }
-        is ContentEmpty -> { /* nothing */
-        }
-        else -> throw IllegalStateException("Don't know how to format node $node")
-    }
-    return this
-}
-
-fun ContentNode.toTestString(): String {
-    val node = this
-    return StringBuilder().apply {
-        appendNode(node)
-    }.toString()
-}
-
-val ContentRoot.path: String
-    get() = when (this) {
-        is KotlinSourceRoot -> path
-        is JavaSourceRoot -> file.path
-        else -> throw UnsupportedOperationException()
-    }
diff --git a/core/src/test/kotlin/format/FileGeneratorTestCase.kt b/core/src/test/kotlin/format/FileGeneratorTestCase.kt
deleted file mode 100644
index ef9e815d..00000000
--- a/core/src/test/kotlin/format/FileGeneratorTestCase.kt
+++ /dev/null
@@ -1,35 +0,0 @@
-package org.jetbrains.dokka.tests
-
-import org.jetbrains.dokka.*
-import org.junit.Before
-import org.junit.Rule
-import org.junit.rules.TemporaryFolder
-
-
-abstract class FileGeneratorTestCase {
-    abstract val formatService: FormatService
-
-    @get:Rule
-    var folder = TemporaryFolder()
-
-    val fileGenerator = FileGenerator(folder.apply { create() }.root)
-
-    @Before
-    fun bindGenerator() {
-        fileGenerator.formatService = formatService
-    }
-
-    fun buildPagesAndReadInto(nodes: List<DocumentationNode>, sb: StringBuilder) = with(fileGenerator) {
-        buildPages(nodes)
-        val byLocations = nodes.groupBy { location(it) }
-        byLocations.forEach { (loc, _) ->
-            if (byLocations.size > 1) {
-                if (sb.isNotBlank() && !sb.endsWith('\n')) {
-                    sb.appendln()
-                }
-                sb.appendln("<!-- File: ${loc.file.relativeTo(root).toUnixString()} -->")
-            }
-            sb.append(loc.file.readText())
-        }
-    }
-}
\ No newline at end of file
diff --git a/core/src/test/kotlin/format/GFMFormatTest.kt b/core/src/test/kotlin/format/GFMFormatTest.kt
deleted file mode 100644
index 60de7d29..00000000
--- a/core/src/test/kotlin/format/GFMFormatTest.kt
+++ /dev/null
@@ -1,36 +0,0 @@
-package org.jetbrains.dokka.tests
-
-import org.jetbrains.dokka.GFMFormatService
-import org.jetbrains.dokka.KotlinLanguageService
-import org.jetbrains.dokka.Platform
-import org.junit.Test
-
-abstract class BaseGFMFormatTest(val analysisPlatform: Platform) : FileGeneratorTestCase() {
-    override val formatService = GFMFormatService(fileGenerator, KotlinLanguageService(), listOf())
-    private val defaultModelConfig = ModelConfig(analysisPlatform = analysisPlatform)
-
-
-    @Test
-    fun sample() {
-        verifyGFMNodeByName("sample", "Foo", defaultModelConfig)
-    }
-
-    @Test
-    fun listInTableCell() {
-        verifyGFMNodeByName("listInTableCell", "Foo", defaultModelConfig)
-    }
-
-    private fun verifyGFMNodeByName(fileName: String, name: String, modelConfig: ModelConfig) {
-        verifyOutput("testdata/format/gfm/$fileName.kt", ".md", modelConfig) { model, output ->
-            buildPagesAndReadInto(
-                    model.members.single().members.filter { it.name == name },
-                    output
-            )
-        }
-    }
-}
-
-
-class JsGFMFormatTest : BaseGFMFormatTest(Platform.js)
-class JvmGFMFormatTest : BaseGFMFormatTest(Platform.jvm)
-class CommonGFMFormatTest : BaseGFMFormatTest(Platform.common)
\ No newline at end of file
diff --git a/core/src/test/kotlin/format/HtmlFormatTest.kt b/core/src/test/kotlin/format/HtmlFormatTest.kt
deleted file mode 100644
index 60e29006..00000000
--- a/core/src/test/kotlin/format/HtmlFormatTest.kt
+++ /dev/null
@@ -1,192 +0,0 @@
-package org.jetbrains.dokka.tests
-
-import org.jetbrains.dokka.*
-import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
-import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot
-import org.junit.Test
-import java.io.File
-
-abstract class BaseHtmlFormatTest(val analysisPlatform: Platform): FileGeneratorTestCase() {
-    protected val defaultModelConfig = ModelConfig(analysisPlatform = analysisPlatform)
-    override val formatService = HtmlFormatService(fileGenerator, KotlinLanguageService(), HtmlTemplateService.default(), listOf())
-
-    @Test fun classWithCompanionObject() {
-        verifyHtmlNode("classWithCompanionObject", defaultModelConfig)
-    }
-
-    @Test fun htmlEscaping() {
-        verifyHtmlNode("htmlEscaping", defaultModelConfig)
-    }
-
-    @Test fun overloads() {
-        verifyHtmlNodes("overloads", defaultModelConfig) { model -> model.members }
-    }
-
-    @Test fun overloadsWithDescription() {
-        verifyHtmlNode("overloadsWithDescription", defaultModelConfig)
-    }
-
-    @Test fun overloadsWithDifferentDescriptions() {
-        verifyHtmlNode("overloadsWithDifferentDescriptions", defaultModelConfig)
-    }
-
-    @Test fun deprecated() {
-        verifyOutput("testdata/format/deprecated.kt", ".package.html", defaultModelConfig) { model, output ->
-            buildPagesAndReadInto(model.members, output)
-        }
-        verifyOutput("testdata/format/deprecated.kt", ".class.html", defaultModelConfig) { model, output ->
-            buildPagesAndReadInto(model.members.single().members, output)
-        }
-    }
-
-    @Test fun brokenLink() {
-        verifyHtmlNode("brokenLink", defaultModelConfig)
-    }
-
-    @Test fun codeSpan() {
-        verifyHtmlNode("codeSpan", defaultModelConfig)
-    }
-
-    @Test fun parenthesis() {
-        verifyHtmlNode("parenthesis", defaultModelConfig)
-    }
-
-    @Test fun bracket() {
-        verifyHtmlNode("bracket", defaultModelConfig)
-    }
-
-    @Test fun see() {
-        verifyHtmlNode("see", defaultModelConfig)
-    }
-
-    @Test fun tripleBackticks() {
-        verifyHtmlNode("tripleBackticks", defaultModelConfig)
-    }
-
-    @Test fun typeLink() {
-        verifyHtmlNodes("typeLink", defaultModelConfig) { model -> model.members.single().members.filter { it.name == "Bar" } }
-    }
-
-    @Test fun parameterAnchor() {
-        verifyHtmlNode("parameterAnchor", defaultModelConfig)
-    }
-
-    @Test fun codeBlock() {
-        verifyHtmlNode("codeBlock", defaultModelConfig)
-    }
-    @Test fun orderedList() {
-        verifyHtmlNodes("orderedList", defaultModelConfig) { model -> model.members.single().members.filter { it.name == "Bar" } }
-    }
-
-    @Test fun linkWithLabel() {
-        verifyHtmlNodes("linkWithLabel", defaultModelConfig) { model -> model.members.single().members.filter { it.name == "Bar" } }
-    }
-
-    @Test fun entity() {
-        verifyHtmlNodes("entity", defaultModelConfig) { model -> model.members.single().members.filter { it.name == "Bar" } }
-    }
-
-    @Test fun uninterpretedEmphasisCharacters() {
-        verifyHtmlNode("uninterpretedEmphasisCharacters", defaultModelConfig)
-    }
-
-    @Test fun markdownInLinks() {
-        verifyHtmlNode("markdownInLinks", defaultModelConfig)
-    }
-
-    @Test fun returnWithLink() {
-        verifyHtmlNode("returnWithLink", defaultModelConfig)
-    }
-
-    @Test fun linkWithStarProjection() {
-        verifyHtmlNode("linkWithStarProjection", ModelConfig(analysisPlatform = analysisPlatform, withKotlinRuntime = true))
-    }
-
-    @Test fun functionalTypeWithNamedParameters() {
-        verifyHtmlNode("functionalTypeWithNamedParameters", defaultModelConfig)
-    }
-
-    @Test fun sinceKotlin() {
-        verifyHtmlNode("sinceKotlin", defaultModelConfig)
-    }
-
-    @Test fun blankLineInsideCodeBlock() {
-        verifyHtmlNode("blankLineInsideCodeBlock", defaultModelConfig)
-    }
-
-    @Test fun indentedCodeBlock() {
-        verifyHtmlNode("indentedCodeBlock", defaultModelConfig)
-    }
-
-    private fun verifyHtmlNode(fileName: String, modelConfig: ModelConfig = ModelConfig()) {
-        verifyHtmlNodes(fileName, modelConfig) { model -> model.members.single().members }
-    }
-
-    private fun verifyHtmlNodes(fileName: String,
-                                modelConfig: ModelConfig = ModelConfig(),
-                                nodeFilter: (DocumentationModule) -> List<DocumentationNode>) {
-        verifyOutput("testdata/format/$fileName.kt", ".html", modelConfig) { model, output ->
-            buildPagesAndReadInto(nodeFilter(model), output)
-        }
-    }
-
-    protected fun verifyJavaHtmlNode(fileName: String, modelConfig: ModelConfig = ModelConfig()) {
-        verifyJavaHtmlNodes(fileName, modelConfig) { model -> model.members.single().members }
-    }
-
-    protected fun verifyJavaHtmlNodes(fileName: String,
-                                      modelConfig: ModelConfig = ModelConfig(),
-                                      nodeFilter: (DocumentationModule) -> List<DocumentationNode>) {
-        verifyJavaOutput("testdata/format/$fileName.java", ".html", modelConfig) { model, output ->
-            buildPagesAndReadInto(nodeFilter(model), output)
-        }
-    }
-}
-
-class JSHtmlFormatTest: BaseHtmlFormatTest(Platform.js)
-
-class JVMHtmlFormatTest: BaseHtmlFormatTest(Platform.jvm) {
-    @Test
-    fun javaSeeTag() {
-        verifyJavaHtmlNode("javaSeeTag", defaultModelConfig)
-    }
-
-    @Test fun javaDeprecated() {
-        verifyJavaHtmlNodes("javaDeprecated", defaultModelConfig) { model ->
-            model.members.single().members.single { it.name == "Foo" }.members.filter { it.name == "foo" }
-        }
-    }
-
-    @Test fun crossLanguageKotlinExtendsJava() {
-        verifyOutput(
-            ModelConfig(
-                roots = arrayOf(
-