Merge branch 'dev'

15 files changed, 483 insertions, 55 deletions

diff --git a/core/src/test/kotlin/NodeSelect.kt b/core/src/test/kotlin/NodeSelect.kt
new file mode 100644
index 00000000..fe0394f9
--- /dev/null
+++ b/core/src/test/kotlin/NodeSelect.kt
@@ -0,0 +1,90 @@
+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
index aa3eff48..4f77a2f6 100644
--- a/core/src/test/kotlin/TestAPI.kt
+++ b/core/src/test/kotlin/TestAPI.kt
@@ -8,12 +8,12 @@ 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.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.config.ContentRoot
-import org.jetbrains.kotlin.config.KotlinSourceRoot
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.junit.Assert
 import org.junit.Assert.fail
@@ -25,22 +25,27 @@ fun verifyModel(vararg roots: ContentRoot,
                 format: String = "html",
                 includeNonPublic: Boolean = true,
                 perPackageOptions: List<DokkaConfiguration.PackageOptions> = emptyList(),
+                noStdlibLink: Boolean = true,
+                collectInheritedExtensionsFromLibraries: Boolean = false,
+                sourceLinks: List<SourceLinkDefinition> = emptyList(),
                 verifier: (DocumentationModule) -> Unit) {
     val documentation = DocumentationModule("test")
 
     val options = DocumentationOptions(
-            "",
-            format,
-            includeNonPublic = includeNonPublic,
-            skipEmptyPackages = false,
-            includeRootPackage = true,
-            sourceLinks = listOf(),
-            perPackageOptions = perPackageOptions,
-            generateIndexPages = false,
-            noStdlibLink = true,
-            cacheRoot = "default",
-            languageVersion = null,
-            apiVersion = null
+        "",
+        format,
+        includeNonPublic = includeNonPublic,
+        skipEmptyPackages = false,
+        includeRootPackage = true,
+        sourceLinks = sourceLinks,
+        perPackageOptions = perPackageOptions,
+        generateIndexPages = false,
+        noStdlibLink = noStdlibLink,
+        noJdkLink = false,
+        cacheRoot = "default",
+        languageVersion = null,
+        apiVersion = null,
+        collectInheritedExtensionsFromLibraries = collectInheritedExtensionsFromLibraries
     )
 
     appendDocumentation(documentation, *roots,
@@ -110,15 +115,17 @@ fun verifyModel(source: String,
                 withKotlinRuntime: Boolean = false,
                 format: String = "html",
                 includeNonPublic: Boolean = true,
+                sourceLinks: List<SourceLinkDefinition> = emptyList(),
                 verifier: (DocumentationModule) -> Unit) {
-    if (!File(source).exists()) {
-        throw IllegalArgumentException("Can't find test data file $source")
+    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)
 }
 
@@ -161,13 +168,17 @@ fun verifyOutput(roots: Array<ContentRoot>,
                  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
+        *roots,
+        withJdk = withJdk,
+        withKotlinRuntime = withKotlinRuntime,
+        format = format,
+        includeNonPublic = includeNonPublic,
+        noStdlibLink = noStdlibLink,
+        collectInheritedExtensionsFromLibraries = collectInheritedExtensionsFromLibraries
     ) {
         verifyModelOutput(it, outputExtension, roots.first().path, outputGenerator)
     }
@@ -184,21 +195,27 @@ 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) {
+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,
-            outputGenerator
+        arrayOf(contentRootFromPath(path)),
+        outputExtension,
+        withJdk,
+        withKotlinRuntime,
+        format,
+        includeNonPublic,
+        noStdlibLink,
+        collectInheritedExtensionsFromLibraries,
+        outputGenerator
     )
 }
 
@@ -257,6 +274,14 @@ fun StringBuilder.appendNode(node: ContentNode): StringBuilder {
         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")
     }
diff --git a/core/src/test/kotlin/format/HtmlFormatTest.kt b/core/src/test/kotlin/format/HtmlFormatTest.kt
index 54c367fd..807118c5 100644
--- a/core/src/test/kotlin/format/HtmlFormatTest.kt
+++ b/core/src/test/kotlin/format/HtmlFormatTest.kt
@@ -1,9 +1,8 @@
 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.jetbrains.kotlin.config.KotlinSourceRoot
-import org.junit.Before
 import org.junit.Test
 import java.io.File
 
@@ -100,7 +99,8 @@ class HtmlFormatTest: FileGeneratorTestCase() {
     }
 
     @Test fun crossLanguageKotlinExtendsJava() {
-        verifyOutput(arrayOf(KotlinSourceRoot("testdata/format/crossLanguage/kotlinExtendsJava/Bar.kt"),
+        verifyOutput(arrayOf(
+            KotlinSourceRoot("testdata/format/crossLanguage/kotlinExtendsJava/Bar.kt", false),
                 JavaSourceRoot(File("testdata/format/crossLanguage/kotlinExtendsJava"), null)),
                 ".html") { model, output ->
             buildPagesAndReadInto(
diff --git a/core/src/test/kotlin/format/KotlinWebSiteFormatTest.kt b/core/src/test/kotlin/format/KotlinWebSiteFormatTest.kt
index b971b54d..062cf0b5 100644
--- a/core/src/test/kotlin/format/KotlinWebSiteFormatTest.kt
+++ b/core/src/test/kotlin/format/KotlinWebSiteFormatTest.kt
@@ -54,6 +54,7 @@ class KotlinWebSiteFormatTest: FileGeneratorTestCase() {
                 outputFormat = "html",
                 generateIndexPages = false,
                 noStdlibLink = true,
+                noJdkLink = true,
                 languageVersion = null,
                 apiVersion = null
         )
diff --git a/core/src/test/kotlin/format/KotlinWebSiteHtmlFormatTest.kt b/core/src/test/kotlin/format/KotlinWebSiteHtmlFormatTest.kt
index 49fa6d2f..8076fb92 100644
--- a/core/src/test/kotlin/format/KotlinWebSiteHtmlFormatTest.kt
+++ b/core/src/test/kotlin/format/KotlinWebSiteHtmlFormatTest.kt
@@ -65,6 +65,7 @@ class KotlinWebSiteHtmlFormatTest: FileGeneratorTestCase() {
                 outputFormat = "kotlin-website-html",
                 generateIndexPages = false,
                 noStdlibLink = true,
+                noJdkLink = true,
                 languageVersion = null,
                 apiVersion = null
         )
diff --git a/core/src/test/kotlin/format/MarkdownFormatTest.kt b/core/src/test/kotlin/format/MarkdownFormatTest.kt
index 9e4c831d..b078292b 100644
--- a/core/src/test/kotlin/format/MarkdownFormatTest.kt
+++ b/core/src/test/kotlin/format/MarkdownFormatTest.kt
@@ -109,7 +109,12 @@ class MarkdownFormatTest: FileGeneratorTestCase() {
     }
 
     @Test fun javaCodeInParam() {
-        verifyJavaMarkdownNode("javaCodeInParam")
+        verifyJavaMarkdownNodes("javaCodeInParam") {
+            selectNodes(it) {
+                subgraphOf(RefKind.Member)
+                withKind(NodeKind.Function)
+            }
+        }
     }
 
     @Test fun javaSpaceInAuthor() {
@@ -160,6 +165,14 @@ class MarkdownFormatTest: FileGeneratorTestCase() {
         verifyMarkdownNode("reifiedTypeParameter", withKotlinRuntime = true)
     }
 
+    @Test fun suspendInlineFunctionOrder() {
+        verifyMarkdownNode("suspendInlineFunction", withKotlinRuntime = true)
+    }
+
+    @Test fun inlineSuspendFunctionOrderChanged() {
+        verifyMarkdownNode("inlineSuspendFunction", withKotlinRuntime = true)
+    }
+
     @Test fun annotatedTypeParameter() {
         verifyMarkdownNode("annotatedTypeParameter", withKotlinRuntime = true)
     }
@@ -313,6 +326,7 @@ class MarkdownFormatTest: FileGeneratorTestCase() {
                 outputFormat = "html",
                 generateIndexPages = false,
                 noStdlibLink = true,
+                noJdkLink = true,
                 languageVersion = null,
                 apiVersion = null
         )
@@ -447,6 +461,7 @@ class MarkdownFormatTest: FileGeneratorTestCase() {
                 outputFormat = "html",
                 generateIndexPages = false,
                 noStdlibLink = true,
+                noJdkLink = true,
                 languageVersion = null,
                 apiVersion = null
         )
@@ -524,4 +539,8 @@ class MarkdownFormatTest: FileGeneratorTestCase() {
             nodesWithName
         }
     }
+
+    @Test fun nullableTypeParameterFunction() {
+        verifyMarkdownNode("nullableTypeParameterFunction", withKotlinRuntime = true)
+    }
 }
diff --git a/core/src/test/kotlin/format/PackageDocsTest.kt b/core/src/test/kotlin/format/PackageDocsTest.kt
index 704f7b99..3ff5f123 100644
--- a/core/src/test/kotlin/format/PackageDocsTest.kt
+++ b/core/src/test/kotlin/format/PackageDocsTest.kt
@@ -1,19 +1,46 @@
 package org.jetbrains.dokka.tests.format
 
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.util.Disposer
 import com.nhaarman.mockito_kotlin.any
 import com.nhaarman.mockito_kotlin.doAnswer
 import com.nhaarman.mockito_kotlin.eq
 import com.nhaarman.mockito_kotlin.mock
 import org.jetbrains.dokka.*
 import org.jetbrains.dokka.tests.assertEqualsIgnoringSeparators
+import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreProjectEnvironment
+import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
+import org.junit.After
 import org.junit.Assert.assertEquals
+import org.junit.Before
 import org.junit.Test
 import java.io.File
 
 class PackageDocsTest {
+
+    private lateinit var testDisposable: Disposable
+
+    @Before
+    fun setup() {
+        testDisposable = Disposer.newDisposable()
+    }
+
+    @After
+    fun cleanup() {
+        Disposer.dispose(testDisposable)
+    }
+
+    fun createPackageDocs(linkResolver: DeclarationLinkResolver?): PackageDocs {
+        val environment = KotlinCoreEnvironment.createForTests(testDisposable, CompilerConfiguration.EMPTY, EnvironmentConfigFiles.JVM_CONFIG_FILES)
+        return PackageDocs(linkResolver, DokkaConsoleLogger, environment, mock(), mock())
+    }
+
     @Test fun verifyParse() {
-        val docs = PackageDocs(null, DokkaConsoleLogger)
+
+        val docs = createPackageDocs(null)
         docs.parse("testdata/packagedocs/stdlib.md", emptyList())
         val packageContent = docs.packageContent["kotlin"]!!
         val block = (packageContent.children.single() as ContentBlock).children.first() as ContentText
@@ -22,13 +49,13 @@ class PackageDocsTest {
 
     @Test fun testReferenceLinksInPackageDocs() {
         val mockLinkResolver = mock<DeclarationLinkResolver> {
-            val exampleCom = "http://example.com"
+            val exampleCom = "https://example.com"
             on { tryResolveContentLink(any(), eq(exampleCom)) } doAnswer { ContentExternalLink(exampleCom) }
         }
 
         val mockPackageDescriptor = mock<PackageFragmentDescriptor> {}
 
-        val docs = PackageDocs(mockLinkResolver, DokkaConsoleLogger)
+        val docs = createPackageDocs(mockLinkResolver)
         docs.parse("testdata/packagedocs/referenceLinks.md", listOf(mockPackageDescriptor))
 
         checkMarkdownOutput(docs, "testdata/packagedocs/referenceLinks")
diff --git a/core/src/test/kotlin/javadoc/JavadocTest.kt b/core/src/test/kotlin/javadoc/JavadocTest.kt
index 45c45aa4..6adbe7a0 100644
--- a/core/src/test/kotlin/javadoc/JavadocTest.kt
+++ b/core/src/test/kotlin/javadoc/JavadocTest.kt
@@ -7,6 +7,7 @@ import org.jetbrains.dokka.tests.assertEqualsIgnoringSeparators
 import org.jetbrains.dokka.tests.verifyModel
 import org.junit.Assert.*
 import org.junit.Test
+import java.lang.reflect.Modifier.*
 
 class JavadocTest {
     @Test fun testTypes() {
@@ -64,7 +65,7 @@ class JavadocTest {
             val member = classDoc.methods().find { it.name() == "main" }!!
             val paramType = member.parameters()[0].type()
             assertNull(paramType.asParameterizedType())
-            assertEquals("String", paramType.typeName())
+            assertEquals("String[]", paramType.typeName())
             assertEquals("String", paramType.asClassDoc().name())
         }
     }
@@ -161,6 +162,115 @@ class JavadocTest {
         }
     }
 
+    @Test
+    fun testVararg() {
+        verifyJavadoc("testdata/javadoc/vararg.kt") { doc ->
+            val classDoc = doc.classNamed("VarargKt")!!
+            val methods = classDoc.methods()
+            methods.single { it.name() == "vararg" }.let {  method ->
+                assertTrue(method.isVarArgs)
+                assertEquals("int", method.parameters().last().typeName())
+            }
+            methods.single { it.name() == "varargInMiddle" }.let {  method ->
+                assertFalse(method.isVarArgs)
+                assertEquals("int[]", method.parameters()[1].typeName())
+            }
+        }
+    }
+
+    @Test
+    fun shouldHaveValidVisibilityModifiers() {
+        verifyJavadoc("testdata/javadoc/visibilityModifiers.kt", withKotlinRuntime = true) { doc ->
+            val classDoc = doc.classNamed("foo.Apple")!!
+            val methods = classDoc.methods()
+
+            val getName = methods[0]
+            val setName = methods[1]
+            val getWeight = methods[2]
+            val setWeight = methods[3]
+            val getRating = methods[4]
+            val setRating = methods[5]
+            val getCode = methods[6]
+            val color = classDoc.fields()[3]
+            val code = classDoc.fields()[4]
+
+            assertTrue(getName.isProtected)
+            assertEquals(PROTECTED, getName.modifierSpecifier())
+            assertTrue(setName.isProtected)
+            assertEquals(PROTECTED, setName.modifierSpecifier())
+
+            assertTrue(getWeight.isPublic)
+            assertEquals(PUBLIC, getWeight.modifierSpecifier())
+            assertTrue(setWeight.isPublic)
+            assertEquals(PUBLIC, setWeight.modifierSpecifier())
+
+            assertTrue(getRating.isPublic)
+            assertEquals(PUBLIC, getRating.modifierSpecifier())
+            assertTrue(setRating.isPublic)
+            assertEquals(PUBLIC, setRating.modifierSpecifier())
+
+            assertTrue(getCode.isPublic)
+            assertEquals(PUBLIC or STATIC, getCode.modifierSpecifier())
+
+            assertEquals(methods.size, 7)
+
+            assertTrue(color.isPrivate)
+            assertEquals(PRIVATE, color.modifierSpecifier())
+
+            assertTrue(code.isPrivate)
+            assertTrue(code.isStatic)
+            assertEquals(PRIVATE or STATIC, code.modifierSpecifier())
+        }
+    }
+
+    @Test
+    fun shouldNotHaveDuplicatedConstructorParameters() {
+        verifyJavadoc("testdata/javadoc/constructorParameters.kt") { doc ->
+            val classDoc = doc.classNamed("bar.Banana")!!
+            val paramTags = classDoc.constructors()[0].paramTags()
+
+            assertEquals(3, paramTags.size)
+        }
+    }
+
+    @Test fun shouldHaveAllFunctionMarkedAsDeprecated() {
+        verifyJavadoc("testdata/javadoc/deprecated.java") { doc ->
+            val classDoc = doc.classNamed("bar.Banana")!!
+
+            classDoc.methods().forEach { method ->
+                assertTrue(method.tags().any { it.kind() == "deprecated" })
+            }
+        }
+    }
+
+    @Test
+    fun testDefaultNoArgConstructor() {
+        verifyJavadoc("testdata/javadoc/defaultNoArgConstructor.kt") { doc ->
+            val classDoc = doc.classNamed("foo.Peach")!!
+            assertTrue(classDoc.constructors()[0].tags()[2].text() == "print peach")
+        }
+    }
+
+    @Test
+    fun testNoArgConstructor() {
+        verifyJavadoc("testdata/javadoc/noArgConstructor.kt") { doc ->
+            val classDoc = doc.classNamed("foo.Plum")!!
+            assertTrue(classDoc.constructors()[0].tags()[2].text() == "print plum")
+        }
+    }
+
+    @Test
+    fun testArgumentReference() {
+        verifyJavadoc("testdata/javadoc/argumentReference.kt") { doc ->
+            val classDoc = doc.classNamed("ArgumentReferenceKt")!!
+            val method = classDoc.methods().first()
+            val tag = method.seeTags().first()
+            assertEquals("argNamedError", tag.referencedMemberName())
+            assertEquals("error", tag.label())
+        }
+    }
+
+
     private fun verifyJavadoc(name: String,
                               withJdk: Boolean = false,
                               withKotlinRuntime: Boolean = false,
diff --git a/core/src/test/kotlin/model/FunctionTest.kt b/core/src/test/kotlin/model/FunctionTest.kt
index 32910682..fd7a16a4 100644
--- a/core/src/test/kotlin/model/FunctionTest.kt
+++ b/core/src/test/kotlin/model/FunctionTest.kt
@@ -167,6 +167,33 @@ Documentation""", content.description.toTestString())
         }
     }
 
+    @Test fun suspendFunction() {
+        verifyPackageMember("testdata/functions/suspendFunction.kt") { func ->
+            val modifiers = func.details(NodeKind.Modifier).map { it.name }
+            assertTrue("suspend" in modifiers)
+        }
+    }
+
+    @Test fun suspendInlineFunctionOrder() {
+        verifyPackageMember("testdata/functions/suspendInlineFunction.kt") { func ->
+            val modifiers = func.details(NodeKind.Modifier).map { it.name }.filter {
+                it == "suspend" || it == "inline"
+            }
+
+            assertEquals(listOf("suspend", "inline"), modifiers)
+        }
+    }
+
+    @Test fun inlineSuspendFunctionOrderChanged() {
+        verifyPackageMember("testdata/functions/inlineSuspendFunction.kt") { func ->
+            val modifiers = func.details(NodeKind.Modifier).map { it.name }.filter {
+                it == "suspend" || it == "inline"
+            }
+
+            assertEquals(listOf("suspend", "inline"), modifiers)
+        }
+    }
+
     @Test fun functionWithAnnotatedParam() {
         verifyModel("testdata/functions/functionWithAnnotatedParam.kt") { model ->
             with(model.members.single().members.single { it.name == "function" }) {
diff --git a/core/src/test/kotlin/model/JavaTest.kt b/core/src/test/kotlin/model/JavaTest.kt
index e6c22ee4..0bec6d01 100644
--- a/core/src/test/kotlin/model/JavaTest.kt
+++ b/core/src/test/kotlin/model/JavaTest.kt
@@ -18,12 +18,12 @@ public class JavaTest {
                 with(content.sections[0]) {
                     assertEquals("Parameters", tag)
                     assertEquals("name", subjectName)
-                    assertEquals("is String parameter", toTestString())
+                    assertEquals("render(Type:String,SUMMARY): is String parameter", toTestString())
                 }
                 with(content.sections[1]) {
                     assertEquals("Parameters", tag)
                     assertEquals("value", subjectName)
-                    assertEquals("is int parameter", toTestString())
+                    assertEquals("render(Type:Int,SUMMARY): is int parameter", toTestString())
                 }
                 with(content.sections[2]) {
                     assertEquals("Author", tag)
@@ -150,7 +150,7 @@ public class JavaTest {
     /**
      *  `@suppress` not supported in Java!
      *
-     *  [Proposed tags](http://www.oracle.com/technetwork/java/javase/documentation/proposed-tags-142378.html)
+     *  [Proposed tags](https://www.oracle.com/technetwork/java/javase/documentation/proposed-tags-142378.html)
      *  Proposed tag `@exclude` for it, but not supported yet
      */
     @Ignore("@suppress not supported in Java!") @Test fun suppressTag() {
@@ -193,7 +193,7 @@ public class JavaTest {
     @Test fun enumValues() {
         verifyJavaPackageMember("testdata/java/enumValues.java") { cls ->
             val superTypes = cls.details(NodeKind.Supertype)
-            assertEquals(0, superTypes.size)
+            assertEquals(1, superTypes.size)
             assertEquals(1, cls.members(NodeKind.EnumItem).size)
         }
     }
diff --git a/core/src/test/kotlin/model/KotlinAsJavaTest.kt b/core/src/test/kotlin/model/KotlinAsJavaTest.kt
index d24d8bdd..22818038 100644
--- a/core/src/test/kotlin/model/KotlinAsJavaTest.kt
+++ b/core/src/test/kotlin/model/KotlinAsJavaTest.kt
@@ -2,6 +2,8 @@ package org.jetbrains.dokka.tests
 
 import org.jetbrains.dokka.DocumentationModule
 import org.jetbrains.dokka.NodeKind
+import org.jetbrains.dokka.RefKind
+import org.junit.Assert
 import org.junit.Test
 import org.junit.Assert.assertEquals
 
@@ -27,6 +29,24 @@ class KotlinAsJavaTest {
             assertEquals("doc", getter.content.summary.toTestString())
         }
     }
+
+
+    @Test fun constants() {
+        verifyModelAsJava("testdata/java/constants.java") { cls ->
+            selectNodes(cls) {
+                subgraphOf(RefKind.Member)
+                matching { it.name == "constStr" || it.name == "refConst" }
+            }.forEach {
+                assertEquals("In $it", "\"some value\"", it.detailOrNull(NodeKind.Value)?.name)
+            }
+            val nullConstNode = selectNodes(cls) {
+                subgraphOf(RefKind.Member)
+                withName("nullConst")
+            }.single()
+
+            Assert.assertNull(nullConstNode.detailOrNull(NodeKind.Value))
+        }
+    }
 }
 
 fun verifyModelAsJava(source: String,
diff --git a/core/src/test/kotlin/model/PackageTest.kt b/core/src/test/kotlin/model/PackageTest.kt
index 052f0d28..7a8f0d06 100644
--- a/core/src/test/kotlin/model/PackageTest.kt
+++ b/core/src/test/kotlin/model/PackageTest.kt
@@ -3,7 +3,7 @@ package org.jetbrains.dokka.tests
 import org.jetbrains.dokka.Content
 import org.jetbrains.dokka.NodeKind
 import org.jetbrains.dokka.PackageOptionsImpl
-import org.jetbrains.kotlin.config.KotlinSourceRoot
+import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
 import org.junit.Assert.*
 import org.junit.Test
 
@@ -48,8 +48,8 @@ public class PackageTest {
     }
 
     @Test fun multipleFiles() {
-        verifyModel(KotlinSourceRoot("testdata/packages/dottedNamePackage.kt"),
-                    KotlinSourceRoot("testdata/packages/simpleNamePackage.kt")) { model ->
+        verifyModel(KotlinSourceRoot("testdata/packages/dottedNamePackage.kt", false),
+                    KotlinSourceRoot("testdata/packages/simpleNamePackage.kt", false)) { model ->
             assertEquals(2, model.members.count())
             with(model.members.single { it.name == "simple" }) {
                 assertEquals(NodeKind.Package, kind)
@@ -70,8 +70,8 @@ public class PackageTest {
     }
 
     @Test fun multipleFilesSamePackage() {
-        verifyModel(KotlinSourceRoot("testdata/packages/simpleNamePackage.kt"),
-                    KotlinSourceRoot("testdata/packages/simpleNamePackage2.kt")) { model ->
+        verifyModel(KotlinSourceRoot("testdata/packages/simpleNamePackage.kt", false),
+                    KotlinSourceRoot("testdata/packages/simpleNamePackage2.kt", false)) { model ->
             assertEquals(1, model.members.count())
             with(model.members.elementAt(0)) {
                 assertEquals(NodeKind.Package, kind)
@@ -85,7 +85,7 @@ public class PackageTest {
     }
 
     @Test fun classAtPackageLevel() {
-        verifyModel(KotlinSourceRoot("testdata/packages/classInPackage.kt")) { model ->
+        verifyModel(KotlinSourceRoot("testdata/packages/classInPackage.kt", false)) { model ->
             assertEquals(1, model.members.count())
             with(model.members.elementAt(0)) {
                 assertEquals(NodeKind.Package, kind)
@@ -99,7 +99,7 @@ public class PackageTest {
     }
 
     @Test fun suppressAtPackageLevel() {
-        verifyModel(KotlinSourceRoot("testdata/packages/classInPackage.kt"),
+        verifyModel(KotlinSourceRoot("testdata/packages/classInPackage.kt", false),
                 perPackageOptions = listOf(PackageOptionsImpl(prefix = "simple.name", suppress = true))) { model ->
             assertEquals(1, model.members.count())
             with(model.members.elementAt(0)) {
diff --git a/core/src/test/kotlin/model/PropertyTest.kt b/core/src/test/kotlin/model/PropertyTest.kt
index 0ee0e0f5..296eaa4c 100644
--- a/core/src/test/kotlin/model/PropertyTest.kt
+++ b/core/src/test/kotlin/model/PropertyTest.kt
@@ -69,7 +69,7 @@ class PropertyTest {
             with(model.members.single().members.single()) {
                 assertEquals(1, annotations.count())
                 with(annotations[0]) {
-                    assertEquals("Volatile", name)
+                    assertEquals("Strictfp", name)
                     assertEquals(Content.Empty, content)
                     assertEquals(NodeKind.Annotation, kind)
                 }
diff --git a/core/src/test/kotlin/model/SourceLinksErrorTest.kt b/core/src/test/kotlin/model/SourceLinksErrorTest.kt
new file mode 100644
index 00000000..a72bd62a
--- /dev/null
+++ b/core/src/test/kotlin/model/SourceLinksErrorTest.kt
@@ -0,0 +1,34 @@
+package org.jetbrains.dokka.tests.model
+
+import org.jetbrains.dokka.NodeKind
+import org.jetbrains.dokka.SourceLinkDefinitionImpl
+import org.jetbrains.dokka.tests.verifyModel
+import org.junit.Assert
+import org.junit.Test
+import java.io.File
+
+class SourceLinksErrorTest {
+
+    @Test
+    fun absolutePath_notMatching() {
+        val sourceLink = SourceLinkDefinitionImpl(File("testdata/nonExisting").absolutePath, "http://...", null)
+        verifyNoSourceUrl(sourceLink)
+    }
+
+    @Test
+    fun relativePath_notMatching() {
+        val sourceLink = SourceLinkDefinitionImpl("testdata/nonExisting", "http://...", null)
+        verifyNoSourceUrl(sourceLink)
+    }
+
+    private fun verifyNoSourceUrl(sourceLink: SourceLinkDefinitionImpl) {
+        verifyModel("testdata/sourceLinks/dummy.kt", sourceLinks = listOf(sourceLink)) { model ->
+            with(model.members.single().members.single()) {
+                Assert.assertEquals("foo", name)
+                Assert.assertEquals(NodeKind.Function, kind)
+                Assert.assertTrue("should not have source urls", details(NodeKind.SourceUrl).isEmpty())
+            }
+        }
+    }
+}
+
diff --git a/core/src/test/kotlin/model/SourceLinksTest.kt b/core/src/test/kotlin/model/SourceLinksTest.kt
new file mode 100644
index 00000000..0e9b666c
--- /dev/null
+++ b/core/src/test/kotlin/model/SourceLinksTest.kt
@@ -0,0 +1,74 @@
+package org.jetbrains.dokka.tests.model
+
+import org.jetbrains.dokka.NodeKind
+import org.jetbrains.dokka.SourceLinkDefinitionImpl
+import org.jetbrains.dokka.tests.verifyModel
+import org.junit.Assert
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+import java.io.File
+
+@RunWith(Parameterized::class)
+class SourceLinksTest(
+    private val srcLink: String,
+    private val url: String,
+    private val lineSuffix: String?,
+    private val expectedUrl: String
+) {
+
+    @Test
+    fun test() {
+        val link = if(srcLink.contains(sourceLinks)){
+            srcLink.substringBeforeLast(sourceLinks) + sourceLinks
+        } else {
+            srcLink.substringBeforeLast(testdata) + testdata
+        }
+        val sourceLink = SourceLinkDefinitionImpl(link, url, lineSuffix)
+
+        verifyModel(filePath, sourceLinks = listOf(sourceLink)) { model ->
+            with(model.members.single().members.single()) {
+                Assert.assertEquals("foo", name)
+                Assert.assertEquals(NodeKind.Function, kind)
+                Assert.assertEquals(expectedUrl, details(NodeKind.SourceUrl).single().name)
+            }
+        }
+    }
+
+    companion object {
+        private const val testdata = "testdata"
+        private const val sourceLinks = "sourceLinks"
+        private const val dummy = "dummy.kt"
+        private const val pathSuffix = "$sourceLinks/$dummy"
+        private const val filePath = "$testdata/$pathSuffix"
+        private const val url = "https://example.com"
+
+        @Parameterized.Parameters(name = "{index}: {0}, {1}, {2} = {3}")
+        @JvmStatic
+        fun data(): Collection<Array<String?>> {
+            val longestPath = File(testdata).absolutePath.removeSuffix("/") + "/../$testdata/"
+            val maxLength = longestPath.length
+            val list = listOf(
+                arrayOf(File(testdata).absolutePath.removeSuffix("/"), "$url/$pathSuffix"),
+                arrayOf(File("$testdata/$sourceLinks").absolutePath.removeSuffix("/") + "/", "$url/$dummy"),
+                arrayOf(longestPath, "$url/$pathSuffix"),
+
+                arrayOf(testdata, "$url/$pathSuffix"),
+                arrayOf("./$testdata", "$url/$pathSuffix"),
+                arrayOf("../core/$testdata", "$url/$pathSuffix"),
+                arrayOf("$testdata/$sourceLinks", "$url/$dummy"),
+                arrayOf("./$testdata/../$testdata/$sourceLinks", "$url/$dummy")
+            )
+
+            return list.map { arrayOf(it[0].padEnd(maxLength, '_'), url, null, it[1]) } +
+                    listOf(
+                        // check that it also works if url ends with /
+                        arrayOf((File(testdata).absolutePath.removeSuffix("/") + "/").padEnd(maxLength, '_'), "$url/", null, "$url/$pathSuffix"),
+                        // check if line suffix work
+                        arrayOf<String?>("../core/../core/./$testdata/$sourceLinks/".padEnd(maxLength, '_'), "$url/", "#L", "$url/$dummy#L4")
+                    )
+        }
+    }
+
+}
+