Merge branch 'kotlin-website-jonnyzzz' into multiplatform-support

19 files changed, 913 insertions, 596 deletions

diff --git a/core/src/test/kotlin/TestAPI.kt b/core/src/test/kotlin/TestAPI.kt
index 4f77a2f6..6ee610cd 100644
--- a/core/src/test/kotlin/TestAPI.kt
+++ b/core/src/test/kotlin/TestAPI.kt
@@ -8,6 +8,7 @@ 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.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
@@ -15,54 +16,59 @@ 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<SourceLinkDefinition> = emptyList()
+)
 
-fun verifyModel(vararg roots: ContentRoot,
-                withJdk: Boolean = false,
-                withKotlinRuntime: Boolean = false,
-                format: String = "html",
-                includeNonPublic: Boolean = true,
-                perPackageOptions: List<DokkaConfiguration.PackageOptions> = emptyList(),
-                noStdlibLink: Boolean = true,
-                collectInheritedExtensionsFromLibraries: Boolean = false,
-                sourceLinks: List<SourceLinkDefinition> = emptyList(),
+fun verifyModel(modelConfig: ModelConfig,
                 verifier: (DocumentationModule) -> Unit) {
     val documentation = DocumentationModule("test")
 
-    val options = DocumentationOptions(
-        "",
-        format,
-        includeNonPublic = includeNonPublic,
+    val passConfiguration = PassConfigurationImpl (
+        includeNonPublic = modelConfig.includeNonPublic,
         skipEmptyPackages = false,
         includeRootPackage = true,
-        sourceLinks = sourceLinks,
-        perPackageOptions = perPackageOptions,
-        generateIndexPages = false,
-        noStdlibLink = noStdlibLink,
+        sourceLinks = modelConfig.sourceLinks,
+        perPackageOptions = modelConfig.perPackageOptions,
+        noStdlibLink = modelConfig.noStdlibLink,
         noJdkLink = false,
-        cacheRoot = "default",
         languageVersion = null,
         apiVersion = null,
-        collectInheritedExtensionsFromLibraries = collectInheritedExtensionsFromLibraries
+        collectInheritedExtensionsFromLibraries = modelConfig.collectInheritedExtensionsFromLibraries
+    )
+    val configuration = DokkaConfigurationImpl(
+        outputDir = "",
+        format = modelConfig.format,
+        generateIndexPages = false,
+        cacheRoot = "default",
+        passesConfigurations = listOf(passConfiguration)
     )
 
-    appendDocumentation(documentation, *roots,
-            withJdk = withJdk,
-            withKotlinRuntime = withKotlinRuntime,
-            options = options)
-    documentation.prepareForGeneration(options)
+    appendDocumentation(documentation, configuration, passConfiguration, modelConfig)
+    documentation.prepareForGeneration(configuration)
 
     verifier(documentation)
 }
 
 fun appendDocumentation(documentation: DocumentationModule,
-                        vararg roots: ContentRoot,
-                        withJdk: Boolean = false,
-                        withKotlinRuntime: Boolean = false,
-                        options: DocumentationOptions,
-                        defaultPlatforms: List<String> = emptyList()) {
+                        dokkaConfiguration: DokkaConfiguration,
+                        passConfiguration: DokkaConfiguration.PassConfiguration,
+                        modelConfig: ModelConfig
+) {
     val messageCollector = object : MessageCollector {
         override fun clear() {
 
@@ -87,66 +93,106 @@ fun appendDocumentation(documentation: DocumentationModule,
         override fun hasErrors() = false
     }
 
-    val environment = AnalysisEnvironment(messageCollector)
+    val environment = AnalysisEnvironment(messageCollector, modelConfig.analysisPlatform)
     environment.apply {
-        if (withJdk || withKotlinRuntime) {
-            val stringRoot = PathManager.getResourceRoot(String::class.java, "/java/lang/String.class")
-            addClasspath(File(stringRoot))
+        if (modelConfig.withJdk || modelConfig.withKotlinRuntime) {
+            addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
         }
-        if (withKotlinRuntime) {
-            val kotlinStrictfpRoot = PathManager.getResourceRoot(Strictfp::class.java, "/kotlin/jvm/Strictfp.class")
-            addClasspath(File(kotlinStrictfpRoot))
+        if (modelConfig.withKotlinRuntime) {
+            if (analysisPlatform == Platform.jvm) {
+                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"))
+                }
+            if (analysisPlatform == Platform.common) {
+                addClasspath(File("/home/jetbrains/.gradle/caches/modules-2/files-2.1/org.jetbrains.kotlin/kotlin-stdlib-common/1.2.51/e4a9d4b13ab19ed1e6531fce6df98e8cfa7f7301/kotlin-stdlib-common-1.2.51.jar"))
+            }
         }
-        addRoots(roots.toList())
+        addRoots(modelConfig.roots.toList())
 
-        loadLanguageVersionSettings(options.languageVersion, options.apiVersion)
+        loadLanguageVersionSettings(passConfiguration.languageVersion, passConfiguration.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))
+
+    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 verifyModel(source: String,
-                withJdk: Boolean = false,
-                withKotlinRuntime: Boolean = false,
-                format: String = "html",
-                includeNonPublic: Boolean = true,
-                sourceLinks: List<SourceLinkDefinition> = emptyList(),
-                verifier: (DocumentationModule) -> Unit) {
+fun checkSourceExistsAndVerifyModel(source: String,
+                        modelConfig: ModelConfig = ModelConfig(),
+                        verifier: (DocumentationModule) -> Unit) {
     require (File(source).exists()) {
         "Cannot find test data file $source"
     }
-    verifyModel(contentRootFromPath(source),
-            withJdk = withJdk,
-            withKotlinRuntime = withKotlinRuntime,
-            format = format,
-            includeNonPublic = includeNonPublic,
-            sourceLinks = sourceLinks,
-            verifier = verifier)
+    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,
-                        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)
@@ -154,36 +200,42 @@ 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,
-                 noStdlibLink: Boolean = true,
-                 collectInheritedExtensionsFromLibraries: Boolean = false,
                  outputGenerator: (DocumentationModule, StringBuilder) -> Unit) {
-    verifyModel(
-        *roots,
-        withJdk = withJdk,
-        withKotlinRuntime = withKotlinRuntime,
-        format = format,
-        includeNonPublic = includeNonPublic,
-        noStdlibLink = noStdlibLink,
-        collectInheritedExtensionsFromLibraries = collectInheritedExtensionsFromLibraries
-    ) {
-        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,
+            noStdlibLink = modelConfig.noStdlibLink,
+            collectInheritedExtensionsFromLibraries = modelConfig.collectInheritedExtensionsFromLibraries
+            ),
+        outputExtension,
+        outputGenerator
+    )
+}
+
 fun verifyModelOutput(it: DocumentationModule,
                       outputExtension: String,
                       sourcePath: String,
@@ -195,35 +247,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,
-    noStdlibLink: Boolean = true,
-    collectInheritedExtensionsFromLibraries: Boolean = false,
-    outputGenerator: (DocumentationModule, StringBuilder) -> Unit
-) {
-    verifyOutput(
-        arrayOf(contentRootFromPath(path)),
-        outputExtension,
-        withJdk,
-        withKotlinRuntime,
-        format,
-        includeNonPublic,
-        noStdlibLink,
-        collectInheritedExtensionsFromLibraries,
-        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/GFMFormatTest.kt b/core/src/test/kotlin/format/GFMFormatTest.kt
index b90ab2bf..60de7d29 100644
--- a/core/src/test/kotlin/format/GFMFormatTest.kt
+++ b/core/src/test/kotlin/format/GFMFormatTest.kt
@@ -2,23 +2,26 @@ package org.jetbrains.dokka.tests
 
 import org.jetbrains.dokka.GFMFormatService
 import org.jetbrains.dokka.KotlinLanguageService
+import org.jetbrains.dokka.Platform
 import org.junit.Test
 
-class GFMFormatTest : FileGeneratorTestCase() {
+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")
+        verifyGFMNodeByName("sample", "Foo", defaultModelConfig)
     }
 
     @Test
     fun listInTableCell() {
-        verifyGFMNodeByName("listInTableCell", "Foo")
+        verifyGFMNodeByName("listInTableCell", "Foo", defaultModelConfig)
     }
 
-    private fun verifyGFMNodeByName(fileName: String, name: String) {
-        verifyOutput("testdata/format/gfm/$fileName.kt", ".md") { model, output ->
+    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
@@ -26,3 +29,8 @@ class GFMFormatTest : FileGeneratorTestCase() {
         }
     }
 }
+
+
+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
index 807118c5..60e29006 100644
--- a/core/src/test/kotlin/format/HtmlFormatTest.kt
+++ b/core/src/test/kotlin/format/HtmlFormatTest.kt
@@ -6,176 +6,187 @@ import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot
 import org.junit.Test
 import java.io.File
 
-class HtmlFormatTest: FileGeneratorTestCase() {
+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")
+        verifyHtmlNode("classWithCompanionObject", defaultModelConfig)
     }
 
     @Test fun htmlEscaping() {
-        verifyHtmlNode("htmlEscaping")
+        verifyHtmlNode("htmlEscaping", defaultModelConfig)
     }
 
     @Test fun overloads() {
-        verifyHtmlNodes("overloads") { model -> model.members }
+        verifyHtmlNodes("overloads", defaultModelConfig) { model -> model.members }
     }
 
     @Test fun overloadsWithDescription() {
-        verifyHtmlNode("overloadsWithDescription")
+        verifyHtmlNode("overloadsWithDescription", defaultModelConfig)
     }
 
     @Test fun overloadsWithDifferentDescriptions() {
-        verifyHtmlNode("overloadsWithDifferentDescriptions")
+        verifyHtmlNode("overloadsWithDifferentDescriptions", defaultModelConfig)
     }
 
     @Test fun deprecated() {
-        verifyOutput("testdata/format/deprecated.kt", ".package.html") { model, output ->
+        verifyOutput("testdata/format/deprecated.kt", ".package.html", defaultModelConfig) { model, output ->
             buildPagesAndReadInto(model.members, output)
         }
-        verifyOutput("testdata/format/deprecated.kt", ".class.html") { model, output ->
+        verifyOutput("testdata/format/deprecated.kt", ".class.html", defaultModelConfig) { model, output ->
             buildPagesAndReadInto(model.members.single().members, output)
         }
     }
 
     @Test fun brokenLink() {
-        verifyHtmlNode("brokenLink")
+        verifyHtmlNode("brokenLink", defaultModelConfig)
     }
 
     @Test fun codeSpan() {
-        verifyHtmlNode("codeSpan")
+        verifyHtmlNode("codeSpan", defaultModelConfig)
     }
 
     @Test fun parenthesis() {
-        verifyHtmlNode("parenthesis")
+        verifyHtmlNode("parenthesis", defaultModelConfig)
     }
 
     @Test fun bracket() {
-        verifyHtmlNode("bracket")
+        verifyHtmlNode("bracket", defaultModelConfig)
     }
 
     @Test fun see() {
-        verifyHtmlNode("see")
+        verifyHtmlNode("see", defaultModelConfig)
     }
 
     @Test fun tripleBackticks() {
-        verifyHtmlNode("tripleBackticks")
+        verifyHtmlNode("tripleBackticks", defaultModelConfig)
     }
 
     @Test fun typeLink() {
-        verifyHtmlNodes("typeLink") { model -> model.members.single().members.filter { it.name == "Bar" } }
+        verifyHtmlNodes("typeLink", defaultModelConfig) { model -> model.members.single().members.filter { it.name == "Bar" } }
     }
 
     @Test fun parameterAnchor() {
-        verifyHtmlNode("parameterAnchor")
-    }
-
-    @Test fun javaSupertypeLink() {
-        verifyJavaHtmlNodes("JavaSupertype") { model ->
-            model.members.single().members.single { it.name == "JavaSupertype" }.members.filter { it.name == "Bar" }
-        }
+        verifyHtmlNode("parameterAnchor", defaultModelConfig)
     }
 
     @Test fun codeBlock() {
-        verifyHtmlNode("codeBlock")
-    }
-
-    @Test fun javaLinkTag() {
-        verifyJavaHtmlNode("javaLinkTag")
-    }
-
-    @Test fun javaLinkTagWithLabel() {
-        verifyJavaHtmlNode("javaLinkTagWithLabel")
-    }
-
-    @Test fun javaSeeTag() {
-        verifyJavaHtmlNode("javaSeeTag")
+        verifyHtmlNode("codeBlock", defaultModelConfig)
     }
-
-    @Test fun javaDeprecated() {
-        verifyJavaHtmlNodes("javaDeprecated") { model ->
-            model.members.single().members.single { it.name == "Foo" }.members.filter { it.name == "foo" }
-        }
-    }
-
-    @Test fun crossLanguageKotlinExtendsJava() {
-        verifyOutput(arrayOf(
-            KotlinSourceRoot("testdata/format/crossLanguage/kotlinExtendsJava/Bar.kt", false),
-                JavaSourceRoot(File("testdata/format/crossLanguage/kotlinExtendsJava"), null)),
-                ".html") { model, output ->
-            buildPagesAndReadInto(
-                    model.members.single().members.filter { it.name == "Bar" },
-                    output
-            )
-        }
-    }
-
     @Test fun orderedList() {
-        verifyHtmlNodes("orderedList") { model -> model.members.single().members.filter { it.name == "Bar" } }
+        verifyHtmlNodes("orderedList", defaultModelConfig) { model -> model.members.single().members.filter { it.name == "Bar" } }
     }
 
     @Test fun linkWithLabel() {
-        verifyHtmlNodes("linkWithLabel") { model -> model.members.single().members.filter { it.name == "Bar" } }
+        verifyHtmlNodes("linkWithLabel", defaultModelConfig) { model -> model.members.single().members.filter { it.name == "Bar" } }
     }
 
     @Test fun entity() {
-        verifyHtmlNodes("entity") { model -> model.members.single().members.filter { it.name == "Bar" } }
+        verifyHtmlNodes("entity", defaultModelConfig) { model -> model.members.single().members.filter { it.name == "Bar" } }
     }
 
     @Test fun uninterpretedEmphasisCharacters() {
-        verifyHtmlNode("uninterpretedEmphasisCharacters")
+        verifyHtmlNode("uninterpretedEmphasisCharacters", defaultModelConfig)
     }
 
     @Test fun markdownInLinks() {
-        verifyHtmlNode("markdownInLinks")
+        verifyHtmlNode("markdownInLinks", defaultModelConfig)
     }
 
     @Test fun returnWithLink() {
-        verifyHtmlNode("returnWithLink")
+        verifyHtmlNode("returnWithLink", defaultModelConfig)
     }
 
     @Test fun linkWithStarProjection() {
-        verifyHtmlNode("linkWithStarProjection", withKotlinRuntime = true)
+        verifyHtmlNode("linkWithStarProjection", ModelConfig(analysisPlatform = analysisPlatform, withKotlinRuntime = true))
     }
 
     @Test fun functionalTypeWithNamedParameters() {
-        verifyHtmlNode("functionalTypeWithNamedParameters")
+        verifyHtmlNode("functionalTypeWithNamedParameters", defaultModelConfig)
     }
 
     @Test fun sinceKotlin() {
-        verifyHtmlNode("sinceKotlin")
+        verifyHtmlNode("sinceKotlin", defaultModelConfig)
     }
 
     @Test fun blankLineInsideCodeBlock() {
-        verifyHtmlNode("blankLineInsideCodeBlock")
+        verifyHtmlNode("blankLineInsideCodeBlock", defaultModelConfig)
     }
 
     @Test fun indentedCodeBlock() {
-        verifyHtmlNode("indentedCodeBlock")
+        verifyHtmlNode("indentedCodeBlock", defaultModelConfig)
     }
 
-    private fun verifyHtmlNode(fileName: String, withKotlinRuntime: Boolean = false) {
-        verifyHtmlNodes(fileName, withKotlinRuntime) { model -> model.members.single().members }
+    private fun verifyHtmlNode(fileName: String, modelConfig: ModelConfig = ModelConfig()) {
+        verifyHtmlNodes(fileName, modelConfig) { model -> model.members.single().members }
     }
 
     private fun verifyHtmlNodes(fileName: String,
-                                withKotlinRuntime: Boolean = false,
+                                modelConfig: ModelConfig = ModelConfig(),
                                 nodeFilter: (DocumentationModule) -> List<DocumentationNode>) {
-        verifyOutput("testdata/format/$fileName.kt", ".html", withKotlinRuntime = withKotlinRuntime) { model, output ->
+        verifyOutput("testdata/format/$fileName.kt", ".html", modelConfig) { model, output ->
             buildPagesAndReadInto(nodeFilter(model), output)
         }
     }
 
-    private fun verifyJavaHtmlNode(fileName: String, withKotlinRuntime: Boolean = false) {
-        verifyJavaHtmlNodes(fileName, withKotlinRuntime) { model -> model.members.single().members }
+    protected fun verifyJavaHtmlNode(fileName: String, modelConfig: ModelConfig = ModelConfig()) {
+        verifyJavaHtmlNodes(fileName, modelConfig) { model -> model.members.single().members }
     }
 
-    private fun verifyJavaHtmlNodes(fileName: String,
-                                    withKotlinRuntime: Boolean = false,
-                                    nodeFilter: (DocumentationModule) -> List<DocumentationNode>) {
-        verifyJavaOutput("testdata/format/$fileName.java", ".html", withKotlinRuntime = withKotlinRuntime) { model, output ->
+    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(
+                    KotlinSourceRoot("testdata/format/crossLanguage/kotlinExtendsJava/Bar.kt", false),
+                    JavaSourceRoot(File("testdata/format/crossLanguage/kotlinExtendsJava"), null)
+                ),
+                analysisPlatform = analysisPlatform
+            ), ".html") { model, output ->
+            buildPagesAndReadInto(
+                model.members.single().members.filter { it.name == "Bar" },
+                output
+            )
+        }
+    }
+
+    @Test fun javaLinkTag() {
+        verifyJavaHtmlNode("javaLinkTag", defaultModelConfig)
+    }
+
+    @Test fun javaLinkTagWithLabel() {
+        verifyJavaHtmlNode("javaLinkTagWithLabel", defaultModelConfig)
+    }
+
+    @Test fun javaSupertypeLink() {
+        verifyJavaHtmlNodes("JavaSupertype", defaultModelConfig) { model ->
+            model.members.single().members.single { it.name == "JavaSupertype" }.members.filter { it.name == "Bar" }
+        }
+    }
+
+}
+
+class CommonHtmlFormatTest: BaseHtmlFormatTest(Platform.common)
\ No newline at end of file
diff --git a/core/src/test/kotlin/format/KotlinWebSiteFormatTest.kt b/core/src/test/kotlin/format/KotlinWebSiteFormatTest.kt
index 062cf0b5..4f292e37 100644
--- a/core/src/test/kotlin/format/KotlinWebSiteFormatTest.kt
+++ b/core/src/test/kotlin/format/KotlinWebSiteFormatTest.kt
@@ -1,7 +1,6 @@
 package org.jetbrains.dokka.tests
 
 import org.jetbrains.dokka.*
-import org.junit.Before
 import org.junit.Ignore
 import org.junit.Test
 
@@ -39,7 +38,7 @@ class KotlinWebSiteFormatTest: FileGeneratorTestCase() {
     }
 
     private fun verifyKWSNodeByName(fileName: String, name: String) {
-        verifyOutput("testdata/format/website/$fileName.kt", ".md", format = "kotlin-website") { model, output ->
+        verifyOutput("testdata/format/website/$fileName.kt", ".md", ModelConfig(format = "kotlin-website")) { model, output ->
             buildPagesAndReadInto(
                     model.members.single().members.filter { it.name == name },
                     output
@@ -49,18 +48,39 @@ class KotlinWebSiteFormatTest: FileGeneratorTestCase() {
 
     private fun buildMultiplePlatforms(path: String): DocumentationModule {
         val module = DocumentationModule("test")
-        val options = DocumentationOptions(
-                outputDir = "",
-                outputFormat = "html",
-                generateIndexPages = false,
-                noStdlibLink = true,
+        val passConfiguration = PassConfigurationImpl(noStdlibLink = true,
                 noJdkLink = true,
                 languageVersion = null,
                 apiVersion = null
         )
-        appendDocumentation(module, contentRootFromPath("testdata/format/website/$path/jvm.kt"), defaultPlatforms = listOf("JVM"), options = options)
-        appendDocumentation(module, contentRootFromPath("testdata/format/website/$path/jre7.kt"), defaultPlatforms = listOf("JVM", "JRE7"), options = options)
-        appendDocumentation(module, contentRootFromPath("testdata/format/website/$path/js.kt"), defaultPlatforms = listOf("JS"), options = options)
+        val configuration = DokkaConfigurationImpl(
+            outputDir = "",
+            format = "html",
+            generateIndexPages = false,
+            passesConfigurations = listOf(passConfiguration)
+            )
+
+        appendDocumentation(
+            module, configuration, passConfiguration, ModelConfig(
+                roots = arrayOf(contentRootFromPath("testdata/format/website/$path/jvm.kt")),
+                defaultPlatforms = listOf("JVM")
+            )
+
+        )
+
+
+        appendDocumentation(
+            module, configuration, passConfiguration, ModelConfig(
+                roots = arrayOf(contentRootFromPath("testdata/format/website/$path/jre7.kt")),
+                defaultPlatforms = listOf("JVM", "JRE7")
+            )
+        )
+        appendDocumentation(
+            module, configuration, passConfiguration, ModelConfig(
+                roots = arrayOf(contentRootFromPath("testdata/format/website/$path/js.kt")),
+                defaultPlatforms = listOf("JS")
+            )
+        )
         return module
     }
 
diff --git a/core/src/test/kotlin/format/KotlinWebSiteHtmlFormatTest.kt b/core/src/test/kotlin/format/KotlinWebSiteHtmlFormatTest.kt
index 8076fb92..1901154f 100644
--- a/core/src/test/kotlin/format/KotlinWebSiteHtmlFormatTest.kt
+++ b/core/src/test/kotlin/format/KotlinWebSiteHtmlFormatTest.kt
@@ -1,38 +1,38 @@
 package org.jetbrains.dokka.tests
 
 import org.jetbrains.dokka.*
-import org.junit.Before
 import org.junit.Test
 
-class KotlinWebSiteHtmlFormatTest: FileGeneratorTestCase() {
+abstract class BaseKotlinWebSiteHtmlFormatTest(val analysisPlatform: Platform): FileGeneratorTestCase() {
+    val defaultModelConfig = ModelConfig(analysisPlatform = analysisPlatform)
     override val formatService = KotlinWebsiteHtmlFormatService(fileGenerator, KotlinLanguageService(), listOf(), EmptyHtmlTemplateService)
 
     @Test fun dropImport() {
-        verifyKWSNodeByName("dropImport", "foo")
+        verifyKWSNodeByName("dropImport", "foo", defaultModelConfig)
     }
 
     @Test fun sample() {
-        verifyKWSNodeByName("sample", "foo")
+        verifyKWSNodeByName("sample", "foo", defaultModelConfig)
     }
 
     @Test fun sampleWithAsserts() {
-        verifyKWSNodeByName("sampleWithAsserts", "a")
+        verifyKWSNodeByName("sampleWithAsserts", "a", defaultModelConfig)
     }
 
     @Test fun newLinesInSamples() {
-        verifyKWSNodeByName("newLinesIn