Test refactoring and split by different platforms

27 files changed, 884 insertions, 613 deletions

diff --git a/core/src/test/kotlin/TestAPI.kt b/core/src/test/kotlin/TestAPI.kt
index aa3eff48..bcbbf2fc 100644
--- a/core/src/test/kotlin/TestAPI.kt
+++ b/core/src/test/kotlin/TestAPI.kt
@@ -6,7 +6,6 @@ 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.DokkaConfiguration.SourceLinkDefinition
 import org.jetbrains.dokka.Utilities.DokkaAnalysisModule
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
@@ -18,24 +17,29 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 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.js,
+    val defaultPlatforms: List<String> = emptyList()
+)
 
-fun verifyModel(vararg roots: ContentRoot,
-                withJdk: Boolean = false,
-                withKotlinRuntime: Boolean = false,
-                format: String = "html",
-                includeNonPublic: Boolean = true,
-                perPackageOptions: List<DokkaConfiguration.PackageOptions> = emptyList(),
+fun verifyModel(modelConfig: ModelConfig,
                 verifier: (DocumentationModule) -> Unit) {
     val documentation = DocumentationModule("test")
 
     val options = DocumentationOptions(
             "",
-            format,
-            includeNonPublic = includeNonPublic,
+            modelConfig.format,
+            includeNonPublic = modelConfig.includeNonPublic,
             skipEmptyPackages = false,
             includeRootPackage = true,
             sourceLinks = listOf(),
-            perPackageOptions = perPackageOptions,
+            perPackageOptions = modelConfig.perPackageOptions,
             generateIndexPages = false,
             noStdlibLink = true,
             cacheRoot = "default",
@@ -43,21 +47,16 @@ fun verifyModel(vararg roots: ContentRoot,
             apiVersion = null
     )
 
-    appendDocumentation(documentation, *roots,
-            withJdk = withJdk,
-            withKotlinRuntime = withKotlinRuntime,
-            options = options)
+    appendDocumentation(documentation, options, modelConfig)
     documentation.prepareForGeneration(options)
 
     verifier(documentation)
 }
 
 fun appendDocumentation(documentation: DocumentationModule,
-                        vararg roots: ContentRoot,
-                        withJdk: Boolean = false,
-                        withKotlinRuntime: Boolean = false,
                         options: DocumentationOptions,
-                        defaultPlatforms: List<String> = emptyList()) {
+                        modelConfig: ModelConfig
+) {
     val messageCollector = object : MessageCollector {
         override fun clear() {
 
@@ -82,22 +81,28 @@ fun appendDocumentation(documentation: DocumentationModule,
         override fun hasErrors() = false
     }
 
-    val environment = AnalysisEnvironment(messageCollector)
+    val environment = AnalysisEnvironment(messageCollector, modelConfig.analysisPlatform)
     environment.apply {
-        if (withJdk || withKotlinRuntime) {
+        if (modelConfig.withJdk || modelConfig.withKotlinRuntime) {
             val stringRoot = PathManager.getResourceRoot(String::class.java, "/java/lang/String.class")
             addClasspath(File(stringRoot))
         }
-        if (withKotlinRuntime) {
+        if (modelConfig.withKotlinRuntime) {
             val kotlinStrictfpRoot = PathManager.getResourceRoot(Strictfp::class.java, "/kotlin/jvm/Strictfp.class")
             addClasspath(File(kotlinStrictfpRoot))
+            // TODO: Fix concrete path to correct gradle path providing
+            if (analysisPlatform == Platform.js) {
+                addClasspath(File("/home/jetbrains/.local/share/JetBrains/Toolbox/apps/IDEA-U/ch-0/181.5281.24/plugins/Kotlin/kotlinc/lib/kotlin-jslib.jar"))
+                addClasspath(File("/home/jetbrains/.local/share/JetBrains/Toolbox/apps/IDEA-U/ch-0/181.5281.24/plugins/Kotlin/kotlinc/lib/kotlin-stdlib-js.jar"))
+                addClasspath(File("/home/jetbrains/.local/share/JetBrains/Toolbox/apps/IDEA-U/ch-0/181.5281.24/plugins/Kotlin/kotlinc/lib/kotlin-stdlib-js-sources.jar"))
+                }
         }
-        addRoots(roots.toList())
+        addRoots(modelConfig.roots.toList())
 
         loadLanguageVersionSettings(options.languageVersion, options.apiVersion)
     }
     val defaultPlatformsProvider = object : DefaultPlatformsProvider {
-        override fun getDefaultPlatforms(descriptor: DeclarationDescriptor) = defaultPlatforms
+        override fun getDefaultPlatforms(descriptor: DeclarationDescriptor) = modelConfig.defaultPlatforms
     }
     val injector = Guice.createInjector(
             DokkaAnalysisModule(environment, options, defaultPlatformsProvider, documentation.nodeRefGraph, DokkaConsoleLogger))
@@ -105,41 +110,59 @@ fun appendDocumentation(documentation: DocumentationModule,
     Disposer.dispose(environment)
 }
 
-fun verifyModel(source: String,
-                withJdk: Boolean = false,
-                withKotlinRuntime: Boolean = false,
-                format: String = "html",
-                includeNonPublic: Boolean = true,
-                verifier: (DocumentationModule) -> Unit) {
+fun checkSourceExistsAndVerifyModel(source: String,
+                        modelConfig: ModelConfig = ModelConfig(),
+                        verifier: (DocumentationModule) -> Unit
+) {
     if (!File(source).exists()) {
         throw IllegalArgumentException("Can't find test data file $source")
     }
-    verifyModel(contentRootFromPath(source),
-            withJdk = withJdk,
-            withKotlinRuntime = withKotlinRuntime,
-            format = format,
-            includeNonPublic = includeNonPublic,
-            verifier = verifier)
+    verifyModel(
+        ModelConfig(
+            roots = arrayOf(contentRootFromPath(source)),
+            withJdk = modelConfig.withJdk,
+            withKotlinRuntime = modelConfig.withKotlinRuntime,
+            format = modelConfig.format,
+            includeNonPublic = modelConfig.includeNonPublic,
+            analysisPlatform = modelConfig.analysisPlatform
+        ),
+
+        verifier = verifier
+    )
 }
 
 fun verifyPackageMember(source: String,
-                        withJdk: Boolean = false,
-                        withKotlinRuntime: Boolean = false,
+                        modelConfig: ModelConfig = ModelConfig(),
                         verifier: (DocumentationNode) -> Unit) {
-    verifyModel(source, withJdk = withJdk, withKotlinRuntime = withKotlinRuntime) { model ->
+    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,
-                    withKotlinRuntime: Boolean = false,
+                    modelConfig: ModelConfig = ModelConfig(),
                     verifier: (DocumentationModule) -> Unit) {
     val tempDir = FileUtil.createTempDirectory("dokka", "")
     try {
         val sourceFile = File(source)
         FileUtil.copy(sourceFile, File(tempDir, sourceFile.name))
-        verifyModel(JavaSourceRoot(tempDir, null), withJdk = true, withKotlinRuntime = withKotlinRuntime, verifier = verifier)
+        verifyModel(
+            ModelConfig(
+                roots = arrayOf(JavaSourceRoot(tempDir, null)),
+                withJdk = true,
+                withKotlinRuntime = modelConfig.withKotlinRuntime,
+                analysisPlatform = modelConfig.analysisPlatform
+            ),
+            verifier = verifier
+        )
     }
     finally {
         FileUtil.delete(tempDir)
@@ -147,32 +170,40 @@ fun verifyJavaModel(source: String,
 }
 
 fun verifyJavaPackageMember(source: String,
-                            withKotlinRuntime: Boolean = false,
+                            modelConfig: ModelConfig = ModelConfig(),
                             verifier: (DocumentationNode) -> Unit) {
-    verifyJavaModel(source, withKotlinRuntime) { model ->
+    verifyJavaModel(source, modelConfig) { model ->
         val pkg = model.members.single()
         verifier(pkg.members.single())
     }
 }
 
-fun verifyOutput(roots: Array<ContentRoot>,
+fun verifyOutput(modelConfig: ModelConfig = ModelConfig(),
                  outputExtension: String,
-                 withJdk: Boolean = false,
-                 withKotlinRuntime: Boolean = false,
-                 format: String = "html",
-                 includeNonPublic: Boolean = true,
                  outputGenerator: (DocumentationModule, StringBuilder) -> Unit) {
-    verifyModel(
-            *roots,
-            withJdk = withJdk,
-            withKotlinRuntime = withKotlinRuntime,
-            format = format,
-            includeNonPublic = includeNonPublic
-    ) {
-        verifyModelOutput(it, outputExtension, roots.first().path, outputGenerator)
+    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
+        ),
+        outputExtension,
+        outputGenerator
+    )
+}
+
 fun verifyModelOutput(it: DocumentationModule,
                       outputExtension: String,
                       sourcePath: String,
@@ -184,29 +215,11 @@ fun verifyModelOutput(it: DocumentationModule,
     assertEqualsIgnoringSeparators(expectedFile, output.toString())
 }
 
-fun verifyOutput(path: String,
-                 outputExtension: String,
-                 withJdk: Boolean = false,
-                 withKotlinRuntime: Boolean = false,
-                 format: String = "html",
-                 includeNonPublic: Boolean = true,
-                 outputGenerator: (DocumentationModule, StringBuilder) -> Unit) {
-    verifyOutput(
-            arrayOf(contentRootFromPath(path)),
-            outputExtension,
-            withJdk,
-            withKotlinRuntime,
-            format,
-            includeNonPublic,
-            outputGenerator
-    )
-}
-
 fun verifyJavaOutput(path: String,
                      outputExtension: String,
-                     withKotlinRuntime: Boolean = false,
+                     modelConfig: ModelConfig = ModelConfig(),
                      outputGenerator: (DocumentationModule, StringBuilder) -> Unit) {
-    verifyJavaModel(path, withKotlinRuntime) { model ->
+    verifyJavaModel(path, modelConfig) { model ->
         verifyModelOutput(model, outputExtension, path, outputGenerator)
     }
 }
diff --git a/core/src/test/kotlin/format/BaseHtmlFormatTest.kt b/core/src/test/kotlin/format/BaseHtmlFormatTest.kt
new file mode 100644
index 00000000..7fd331cf
--- /dev/null
+++ b/core/src/test/kotlin/format/BaseHtmlFormatTest.kt
@@ -0,0 +1,146 @@
+package org.jetbrains.dokka.tests
+
+import org.jetbrains.dokka.*
+import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot
+import org.jetbrains.kotlin.config.KotlinSourceRoot
+import org.junit.Before
+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)
+        }
+    }
+}
+
diff --git a/core/src/test/kotlin/format/MarkdownFormatTest.kt b/core/src/test/kotlin/format/BaseMarkdownFormatTest.kt
index 9e4c831d..5612b1fd 100644
--- a/core/src/test/kotlin/format/MarkdownFormatTest.kt
+++ b/core/src/test/kotlin/format/BaseMarkdownFormatTest.kt
@@ -4,49 +4,33 @@ import org.jetbrains.dokka.*
 import org.junit.Before
 import org.junit.Test
 
-class MarkdownFormatTest: FileGeneratorTestCase() {
+abstract class BaseMarkdownFormatTest(val analysisPlatform: Platform): FileGeneratorTestCase() {
     override val formatService = MarkdownFormatService(fileGenerator, KotlinLanguageService(), listOf())
 
+    protected val defaultModelConfig = ModelConfig(analysisPlatform = analysisPlatform)
+
     @Test fun emptyDescription() {
-        verifyMarkdownNode("emptyDescription")
+        verifyMarkdownNode("emptyDescription", defaultModelConfig)
     }
 
     @Test fun classWithCompanionObject() {
-        verifyMarkdownNode("classWithCompanionObject")
+        verifyMarkdownNode("classWithCompanionObject", defaultModelConfig)
     }
 
     @Test fun annotations() {
-        verifyMarkdownNode("annotations")
+        verifyMarkdownNode("annotations", defaultModelConfig)
     }
 
     @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)
-        }
+        verifyMarkdownNode("annotationClass", ModelConfig(analysisPlatform = analysisPlatform, withKotlinRuntime = true))
+        verifyMarkdownPackage("annotationClass", ModelConfig(analysisPlatform = analysisPlatform, withKotlinRuntime = true))
     }
 
     @Test fun enumClass() {
-        verifyOutput("testdata/format/enumClass.kt", ".md") { model, output ->
+        verifyOutput("testdata/format/enumClass.kt", ".md", defaultModelConfig) { model, output ->
             buildPagesAndReadInto(model.members.single().members, output)
         }
-        verifyOutput("testdata/format/enumClass.kt", ".value.md") { model, output ->
+        verifyOutput("testdata/format/enumClass.kt", ".value.md", defaultModelConfig) { model, output ->
             val enumClassNode = model.members.single().members[0]
             buildPagesAndReadInto(
                     enumClassNode.members.filter { it.name == "LOCAL_CONTINUE_AND_BREAK" },
@@ -56,222 +40,179 @@ class MarkdownFormatTest: FileGeneratorTestCase() {
     }
 
     @Test fun varargsFunction() {
-        verifyMarkdownNode("varargsFunction")
+        verifyMarkdownNode("varargsFunction", defaultModelConfig)
     }
 
     @Test fun overridingFunction() {
-        verifyMarkdownNodes("overridingFunction") { model->
+        verifyMarkdownNodes("overridingFunction", defaultModelConfig) { model->
             val classMembers = model.members.single().members.first { it.name == "D" }.members
             classMembers.filter { it.name == "f" }
         }
     }
 
     @Test fun propertyVar() {
-        verifyMarkdownNode("propertyVar")
+        verifyMarkdownNode("propertyVar", defaultModelConfig)
     }
 
     @Test fun functionWithDefaultParameter() {
-        verifyMarkdownNode("functionWithDefaultParameter")
+        verifyMarkdownNode("functionWithDefaultParameter", defaultModelConfig)
     }
 
     @Test fun accessor() {
-        verifyMarkdownNodes("accessor") { model ->
+        verifyMarkdownNodes("accessor", defaultModelConfig) { model ->
             model.members.single().members.first { it.name == "C" }.members.filter { it.name == "x" }
         }
     }
 
     @Test fun paramTag() {
-        verifyMarkdownNode("paramTag")
+        verifyMarkdownNode("paramTag", defaultModelConfig)
     }
 
     @Test fun throwsTag() {
-        verifyMarkdownNode("throwsTag")
+        verifyMarkdownNode("throwsTag", defaultModelConfig)
     }
 
     @Test fun typeParameterBounds() {
-        verifyMarkdownNode("typeParameterBounds")
+        verifyMarkdownNode("typeParameterBounds", defaultModelConfig)
     }
 
     @Test fun typeParameterVariance() {
-        verifyMarkdownNode("typeParameterVariance")
+        verifyMarkdownNode("typeParameterVariance", defaultModelConfig)
     }
 
     @Test fun typeProjectionVariance() {
-        verifyMarkdownNode("typeProjectionVariance")
-    }
-
-    @Test fun javadocHtml() {
-        verifyJavaMarkdownNode("javadocHtml")
-    }
-
-    @Test fun javaCodeLiteralTags() {
-        verifyJavaMarkdownNode("javaCodeLiteralTags")
-    }
-
-    @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" }
-        }
+        verifyMarkdownNode("typeProjectionVariance", defaultModelConfig)
     }
 
     @Test fun codeBlockNoHtmlEscape() {
-        verifyMarkdownNodeByName("codeBlockNoHtmlEscape", "hackTheArithmetic")
+        verifyMarkdownNodeByName("codeBlockNoHtmlEscape", "hackTheArithmetic", defaultModelConfig)
     }
 
     @Test fun companionObjectExtension() {
-        verifyMarkdownNodeByName("companionObjectExtension", "Foo")
+        verifyMarkdownNodeByName("companionObjectExtension", "Foo", defaultModelConfig)
     }
 
     @Test fun starProjection() {
-        verifyMarkdownNode("starProjection")
+        verifyMarkdownNode("starProjection", defaultModelConfig)
     }
 
     @Test fun extensionFunctionParameter() {
-        verifyMarkdownNode("extensionFunctionParameter")
+        verifyMarkdownNode("extensionFunctionParameter", defaultModelConfig)
     }
 
     @Test fun summarizeSignatures() {
-        verifyMarkdownNodes("summarizeSignatures") { model -> model.members }
-    }
-
-    @Test fun summarizeSignaturesProperty() {
-        verifyMarkdownNodes("summarizeSignaturesProperty") { model -> model.members }
+        verifyMarkdownNodes("summarizeSignatures", defaultModelConfig) { model -> model.members }
     }
 
     @Test fun reifiedTypeParameter() {
-        verifyMarkdownNode("reifiedTypeParameter", withKotlinRuntime = true)
+        verifyMarkdownNode("reifiedTypeParameter", ModelConfig(analysisPlatform = analysisPlatform, withKotlinRuntime = true))
     }
 
     @Test fun annotatedTypeParameter() {
-        verifyMarkdownNode("annotatedTypeParameter", withKotlinRuntime = true)
+        verifyMarkdownNode("annotatedTypeParameter", ModelConfig(analysisPlatform = analysisPlatform, withKotlinRuntime = true))
     }
 
     @Test fun inheritedMembers() {
-        verifyMarkdownNodeByName("inheritedMembers", "Bar")
+        verifyMarkdownNodeByName("inheritedMembers", "Bar", defaultModelConfig)
     }
 
     @Test fun inheritedExtensions() {
-        verifyMarkdownNodeByName("inheritedExtensions", "Bar")
+        verifyMarkdownNodeByName("inheritedExtensions", "Bar", defaultModelConfig)
     }
 
     @Test fun genericInheritedExtensions() {
-        verifyMarkdownNodeByName("genericInheritedExtensions", "Bar")
+        verifyMarkdownNodeByName("genericInheritedExtensions", "Bar", defaultModelConfig)
     }
 
     @Test fun arrayAverage() {
-        verifyMarkdownNodeByName("arrayAverage", "XArray")
+        verifyMarkdownNodeByName("arrayAverage", "XArray", defaultModelConfig)
     }
 
     @Test fun multipleTypeParameterConstraints() {
-        verifyMarkdownNode("multipleTypeParameterConstraints", withKotlinRuntime = true)
+        verifyMarkdownNode("multipleTypeParameterConstraints", ModelConfig(analysisPlatform = analysisPlatform, withKotlinRuntime = true))
     }
 
     @Test fun inheritedCompanionObjectProperties() {
-        verifyMarkdownNodeByName("inheritedCompanionObjectProperties", "C")
+        verifyMarkdownNodeByName("inheritedCompanionObjectProperties", "C", defaultModelConfig)
     }
 
     @Test fun shadowedExtensionFunctions() {
-        verifyMarkdownNodeByName("shadowedExtensionFunctions", "Bar")
+        verifyMarkdownNodeByName("shadowedExtensionFunctions", "Bar", defaultModelConfig)
     }
 
     @Test fun inapplicableExtensionFunctions() {
-        verifyMarkdownNodeByName("inapplicableExtensionFunctions", "Bar")
+        verifyMarkdownNodeByName("inapplicableExtensionFunctions", "Bar", defaultModelConfig)
     }
 
     @Test fun receiverParameterTypeBound() {
-        verifyMarkdownNodeByName("receiverParameterTypeBound", "Foo")
+        verifyMarkdownNodeByName("receiverParameterTypeBound", "Foo", defaultModelConfig)
     }
 
     @Test fun extensionWithDocumentedReceiver() {
-        verifyMarkdownNodes("extensionWithDocumentedReceiver") { model ->
+        verifyMarkdownNodes("extensionWithDocumentedReceiver", defaultModelConfig) { model ->
             model.members.single().members.single().members.filter { it.name == "fn" }
         }
     }
 
-    @Test fun jdkLinks() {
-        verifyMarkdownNode("jdkLinks", withKotlinRuntime = true)
-    }
-
     @Test fun codeBlock() {
-        verifyMarkdownNode("codeBlock")
+        verifyMarkdownNode("codeBlock", defaultModelConfig)
     }
 
     @Test fun exclInCodeBlock() {
-        verifyMarkdownNodeByName("exclInCodeBlock", "foo")
+        verifyMarkdownNodeByName("exclInCodeBlock", "foo", defaultModelConfig)
     }
 
     @Test fun backtickInCodeBlock() {
-        verifyMarkdownNodeByName("backtickInCodeBlock", "foo")
+        verifyMarkdownNodeByName("backtickInCodeBlock", "foo", defaultModelConfig)
     }
 
     @Test fun qualifiedNameLink() {
-        verifyMarkdownNodeByName("qualifiedNameLink", "foo", withKotlinRuntime = true)
+        verifyMarkdownNodeByName("qualifiedNameLink", "foo",
+            ModelConfig(analysisPlatform = analysisPlatform, withKotlinRuntime = true))
     }
 
     @Test fun functionalTypeWithNamedParameters() {
-        verifyMarkdownNode("functionalTypeWithNamedParameters")
+        verifyMarkdownNode("functionalTypeWithNamedParameters", defaultModelConfig)
     }
 
     @Test fun typeAliases() {
-        verifyMarkdownNode("typeAliases")
-        verifyMarkdownPackage("typeAliases")
-    }
-
-    @Test fun sampleByFQName() {
-        verifyMarkdownNode("sampleByFQName")
+        verifyMarkdownNode("typeAliases", defaultModelConfig)
+        verifyMarkdownPackage("typeAliases", defaultModelConfig)
     }
 
     @Test fun sampleByShortName() {
-        verifyMarkdownNode("sampleByShortName")
+        verifyMarkdownNode("sampleByShortName", defaultModelConfig)
     }
 
 
     @Test fun suspendParam() {
-        verifyMarkdownNode("suspendParam")
-        verifyMarkdownPackage("suspendParam")
+        verifyMarkdownNode("suspendParam", defaultModelConfig)
+        verifyMarkdownPackage("suspendParam", defaultModelConfig)
     }
 
     @Test fun sinceKotlin() {
-        verifyMarkdownNode("sinceKotlin")
-        verifyMarkdownPackage("sinceKotlin")
+        verifyMarkdownNode("sinceKotlin", defaultModelConfig)
+        verifyMarkdownPackage("sinceKotlin", defaultModelConfig)
     }
 
     @Test fun sinceKotlinWide() {
-        verifyMarkdownPackage("sinceKotlinWide")
+        verifyMarkdownPackage("sinceKotlinWide", defaultModelConfig)
     }
 
     @Test fun dynamicType() {
-        verifyMarkdownNode("dynamicType")
+        verifyMarkdownNode("dynamicType", de