restructure Dokka build to use Gradle for everything except for the Maven plugin

14 files changed, 1922 insertions, 0 deletions

diff --git a/core/src/test/kotlin/TestAPI.kt b/core/src/test/kotlin/TestAPI.kt
new file mode 100644
index 00000000..d7833e36
--- /dev/null
+++ b/core/src/test/kotlin/TestAPI.kt
@@ -0,0 +1,214 @@
+package org.jetbrains.dokka.tests
+
+import com.google.inject.Guice
+import com.intellij.openapi.application.PathManager
+import com.intellij.openapi.util.Disposer
+import com.intellij.openapi.util.io.FileUtil
+import org.jetbrains.dokka.*
+import org.jetbrains.dokka.Utilities.DokkaModule
+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.junit.Assert
+import java.io.File
+import kotlin.test.fail
+
+public fun verifyModel(vararg roots: ContentRoot,
+                       withJdk: Boolean = false,
+                       withKotlinRuntime: Boolean = false,
+                       format: String = "html",
+                       verifier: (DocumentationModule) -> Unit) {
+    val messageCollector = object : MessageCollector {
+        override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation) {
+            when (severity) {
+                CompilerMessageSeverity.WARNING,
+                CompilerMessageSeverity.LOGGING,
+                CompilerMessageSeverity.OUTPUT,
+                CompilerMessageSeverity.INFO,
+                CompilerMessageSeverity.ERROR -> {
+                    println("$severity: $message at $location")
+                }
+                CompilerMessageSeverity.EXCEPTION -> {
+                    fail("$severity: $message at $location")
+                }
+            }
+        }
+    }
+
+    val environment = AnalysisEnvironment(messageCollector)
+    environment.apply {
+        if (withJdk || withKotlinRuntime) {
+            val stringRoot = PathManager.getResourceRoot(String::class.java, "/java/lang/String.class")
+            addClasspath(File(stringRoot))
+        }
+        if (withKotlinRuntime) {
+            val kotlinPairRoot = PathManager.getResourceRoot(Pair::class.java, "/kotlin/Pair.class")
+            addClasspath(File(kotlinPairRoot))
+        }
+        addRoots(roots.toList())
+    }
+    val options = DocumentationOptions("", format, includeNonPublic = true, skipEmptyPackages = false, sourceLinks = listOf<SourceLinkDefinition>())
+    val injector = Guice.createInjector(DokkaModule(environment, options, DokkaConsoleLogger))
+    val documentation = buildDocumentationModule(injector, "test")
+    verifier(documentation)
+    Disposer.dispose(environment)
+}
+
+public fun verifyModel(source: String,
+                       withJdk: Boolean = false,
+                       withKotlinRuntime: Boolean = false,
+                       format: String = "html",
+                       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,
+            verifier = verifier)
+}
+
+public fun verifyPackageMember(source: String,
+                               withJdk: Boolean = false,
+                               withKotlinRuntime: Boolean = false,
+                               verifier: (DocumentationNode) -> Unit) {
+    verifyModel(source, withJdk = withJdk, withKotlinRuntime = withKotlinRuntime) { model ->
+        val pkg = model.members.single()
+        verifier(pkg.members.single())
+    }
+}
+
+public fun verifyJavaModel(source: String,
+                           withKotlinRuntime: Boolean = false,
+                           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)
+    }
+    finally {
+        FileUtil.delete(tempDir)
+    }
+}
+
+public fun verifyJavaPackageMember(source: String,
+                                   withKotlinRuntime: Boolean = false,
+                                   verifier: (DocumentationNode) -> Unit) {
+    verifyJavaModel(source, withKotlinRuntime) { model ->
+        val pkg = model.members.single()
+        verifier(pkg.members.single())
+    }
+}
+
+public fun verifyOutput(roots: Array<ContentRoot>,
+                        outputExtension: String,
+                        withJdk: Boolean = false,
+                        withKotlinRuntime: Boolean = false,
+                        outputGenerator: (DocumentationModule, StringBuilder) -> Unit) {
+    verifyModel(*roots, withJdk = withJdk, withKotlinRuntime = withKotlinRuntime) {
+        verifyModelOutput(it, outputExtension, outputGenerator, roots.first().path)
+    }
+}
+
+private fun verifyModelOutput(it: DocumentationModule,
+                              outputExtension: String,
+                              outputGenerator: (DocumentationModule, StringBuilder) -> Unit,
+                              sourcePath: String) {
+    val output = StringBuilder()
+    outputGenerator(it, output)
+    val ext = outputExtension.removePrefix(".")
+    val path = sourcePath
+    val expectedOutput = File(path.replaceAfterLast(".", ext, path + "." + ext)).readText()
+    assertEqualsIgnoringSeparators(expectedOutput, output.toString())
+}
+
+public fun verifyOutput(path: String,
+                        outputExtension: String,
+                        withJdk: Boolean = false,
+                        withKotlinRuntime: Boolean = false,
+                        outputGenerator: (DocumentationModule, StringBuilder) -> Unit) {
+    verifyOutput(arrayOf(contentRootFromPath(path)), outputExtension, withJdk, withKotlinRuntime, outputGenerator)
+}
+
+public fun verifyJavaOutput(path: String,
+                            outputExtension: String,
+                            withKotlinRuntime: Boolean = false,
+                            outputGenerator: (DocumentationModule, StringBuilder) -> Unit) {
+    verifyJavaModel(path, withKotlinRuntime) { model ->
+        verifyModelOutput(model, outputExtension, outputGenerator, path)
+    }
+}
+
+public fun assertEqualsIgnoringSeparators(expectedOutput: String, output: String) {
+    Assert.assertEquals(expectedOutput.replace("\r\n", "\n"), output.replace("\r\n", "\n"))
+}
+
+fun StringBuilder.appendChildren(node: ContentBlock): StringBuilder {
+    for (child in node.children) {
+        val childText = child.toTestString()
+        append(childText)
+    }
+    return this
+}
+
+fun StringBuilder.appendNode(node: ContentNode): StringBuilder {
+    when (node) {
+        is ContentText -> {
+            append(node.text)
+        }
+        is ContentEmphasis -> append("*").appendChildren(node).append("*")
+        is ContentBlockCode -> {
+            appendln("[code]")
+            appendChildren(node)
+            appendln()
+            appendln("[/code]")
+        }
+        is ContentNodeLink -> {
+            append("[")
+            appendChildren(node)
+            append(" -> ")
+            append(node.node.toString())
+            append("]")
+        }
+        is ContentBlock -> {
+            appendChildren(node)
+        }
+        is ContentEmpty -> { /* nothing */ }
+        else -> throw IllegalStateException("Don't know how to format node $node")
+    }
+    return this
+}
+
+fun ContentNode.toTestString(): String {
+    val node = this
+    return StringBuilder().apply {
+        appendNode(node)
+    }.toString()
+}
+
+class InMemoryLocation(override val path: String): Location {
+    override fun relativePathTo(other: Location, anchor: String?): String =
+            if (anchor != null) other.path + "#" + anchor else other.path
+}
+
+object InMemoryLocationService: LocationService {
+    override fun location(qualifiedName: List<String>, hasMembers: Boolean) =
+            InMemoryLocation(relativePathToNode(qualifiedName, hasMembers))
+
+    override val root: Location
+        get() = InMemoryLocation("")
+}
+
+val tempLocation = InMemoryLocation("")
+
+val ContentRoot.path: String
+    get() = when(this) {
+        is KotlinSourceRoot -> path
+        is JavaSourceRoot -> file.path
+        else -> throw UnsupportedOperationException()
+    }
diff --git a/core/src/test/kotlin/format/HtmlFormatTest.kt b/core/src/test/kotlin/format/HtmlFormatTest.kt
new file mode 100644
index 00000000..593dbfe6
--- /dev/null
+++ b/core/src/test/kotlin/format/HtmlFormatTest.kt
@@ -0,0 +1,157 @@
+package org.jetbrains.dokka.tests
+
+import org.jetbrains.dokka.HtmlFormatService
+import org.jetbrains.dokka.HtmlTemplateService
+import org.jetbrains.dokka.KotlinLanguageService
+import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot
+import org.jetbrains.kotlin.config.KotlinSourceRoot
+import org.junit.Test
+import java.io.File
+
+public class HtmlFormatTest {
+    private val htmlService = HtmlFormatService(InMemoryLocationService, KotlinLanguageService(), HtmlTemplateService.default())
+
+    @Test fun classWithCompanionObject() {
+        verifyOutput("testdata/format/classWithCompanionObject.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun htmlEscaping() {
+        verifyOutput("testdata/format/htmlEscaping.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun overloads() {
+        verifyOutput("testdata/format/overloads.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members)
+        }
+    }
+
+    @Test fun overloadsWithDescription() {
+        verifyOutput("testdata/format/overloadsWithDescription.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun overloadsWithDifferentDescriptions() {
+        verifyOutput("testdata/format/overloadsWithDifferentDescriptions.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun deprecated() {
+        verifyOutput("testdata/format/deprecated.kt", ".package.html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members)
+        }
+        verifyOutput("testdata/format/deprecated.kt", ".class.html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun brokenLink() {
+        verifyOutput("testdata/format/brokenLink.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun codeSpan() {
+        verifyOutput("testdata/format/codeSpan.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun parenthesis() {
+        verifyOutput("testdata/format/parenthesis.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun bracket() {
+        verifyOutput("testdata/format/bracket.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun see() {
+        verifyOutput("testdata/format/see.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun tripleBackticks() {
+        verifyOutput("testdata/format/tripleBackticks.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun typeLink() {
+        verifyOutput("testdata/format/typeLink.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members.filter { it.name == "Bar"} )
+        }
+    }
+
+    @Test fun parameterAnchor() {
+        verifyOutput("testdata/format/parameterAnchor.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun javaSupertypeLink() {
+        verifyJavaOutput("testdata/format/javaSupertype.java", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members.single { it.name == "C"}.members.filter { it.name == "Bar"} )
+        }
+    }
+
+    @Test fun javaLinkTag() {
+        verifyJavaOutput("testdata/format/javaLinkTag.java", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun javaLinkTagWithLabel() {
+        verifyJavaOutput("testdata/format/javaLinkTagWithLabel.java", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun javaSeeTag() {
+        verifyJavaOutput("testdata/format/javaSeeTag.java", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun javaDeprecated() {
+        verifyJavaOutput("testdata/format/javaDeprecated.java", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, 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"),
+                            JavaSourceRoot(File("testdata/format/crossLanguage/kotlinExtendsJava"), null)),
+                ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members.filter { it.name == "Bar" })
+        }
+    }
+
+    @Test fun orderedList() {
+        verifyOutput("testdata/format/orderedList.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members.filter { it.name == "Bar" })
+        }
+    }
+
+    @Test fun linkWithLabel() {
+        verifyOutput("testdata/format/linkWithLabel.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members.filter { it.name == "Bar" })
+        }
+    }
+
+    @Test fun entity() {
+        verifyOutput("testdata/format/entity.kt", ".html") { model, output ->
+            htmlService.appendNodes(tempLocation, output, model.members.single().members.filter { it.name == "Bar" })
+        }
+    }
+}
+
diff --git a/core/src/test/kotlin/format/MarkdownFormatTest.kt b/core/src/test/kotlin/format/MarkdownFormatTest.kt
new file mode 100644
index 00000000..e2339707
--- /dev/null
+++ b/core/src/test/kotlin/format/MarkdownFormatTest.kt
@@ -0,0 +1,218 @@
+package org.jetbrains.dokka.tests
+
+import org.jetbrains.dokka.KotlinLanguageService
+import org.jetbrains.dokka.MarkdownFormatService
+import org.junit.Test
+
+public class MarkdownFormatTest {
+    private val markdownService = MarkdownFormatService(InMemoryLocationService, KotlinLanguageService())
+
+    @Test fun emptyDescription() {
+        verifyOutput("testdata/format/emptyDescription.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun classWithCompanionObject() {
+        verifyOutput("testdata/format/classWithCompanionObject.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun annotations() {
+        verifyOutput("testdata/format/annotations.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun annotationClass() {
+        verifyOutput("testdata/format/annotationClass.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun annotationParams() {
+        verifyOutput("testdata/format/annotationParams.kt", ".md", withKotlinRuntime = true) { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun extensions() {
+        verifyOutput("testdata/format/extensions.kt", ".package.md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members)
+        }
+        verifyOutput("testdata/format/extensions.kt", ".class.md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun enumClass() {
+        verifyOutput("testdata/format/enumClass.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+        verifyOutput("testdata/format/enumClass.kt", ".value.md") { model, output ->
+            val enumClassNode = model.members.single().members[0]
+            markdownService.appendNodes(tempLocation, output,
+                    enumClassNode.members.filter { it.name == "LOCAL_CONTINUE_AND_BREAK" })
+        }
+    }
+
+    @Test fun varargsFunction() {
+        verifyOutput("testdata/format/varargsFunction.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun overridingFunction() {
+        verifyOutput("testdata/format/overridingFunction.kt", ".md") { model, output ->
+            val classMembers = model.members.single().members.first { it.name == "D" }.members
+            markdownService.appendNodes(tempLocation, output, classMembers.filter { it.name == "f" })
+        }
+
+    }
+
+    @Test fun propertyVar() {
+        verifyOutput("testdata/format/propertyVar.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun functionWithDefaultParameter() {
+        verifyOutput("testdata/format/functionWithDefaultParameter.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun accessor() {
+        verifyOutput("testdata/format/accessor.kt", ".md") { model, output ->
+            val propertyNode = model.members.single().members.first { it.name == "C" }.members.filter { it.name == "x" }
+            markdownService.appendNodes(tempLocation, output, propertyNode)
+        }
+    }
+
+    @Test fun paramTag() {
+        verifyOutput("testdata/format/paramTag.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun throwsTag() {
+        verifyOutput("testdata/format/throwsTag.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun typeParameterBounds() {
+        verifyOutput("testdata/format/typeParameterBounds.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun typeParameterVariance() {
+        verifyOutput("testdata/format/typeParameterVariance.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun typeProjectionVariance() {
+        verifyOutput("testdata/format/typeProjectionVariance.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun javadocHtml() {
+        verifyJavaOutput("testdata/format/javadocHtml.java", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun javaCodeLiteralTags() {
+        verifyJavaOutput("testdata/format/javaCodeLiteralTags.java", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun javaCodeInParam() {
+        verifyJavaOutput("testdata/format/javaCodeInParam.java", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun javaSpaceInAuthor() {
+        verifyJavaOutput("testdata/format/javaSpaceInAuthor.java", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun nullability() {
+        verifyOutput("testdata/format/nullability.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun operatorOverloading() {
+        verifyOutput("testdata/format/operatorOverloading.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members.single { it.name == "C" }.members.filter { it.name == "plus" })
+        }
+    }
+
+    @Test fun javadocOrderedList() {
+        verifyJavaOutput("testdata/format/javadocOrderedList.java", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members.filter { it.name == "Bar" })
+        }
+    }
+
+    @Test fun companionObjectExtension() {
+        verifyOutput("testdata/format/companionObjectExtension.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members.filter { it.name == "Foo" })
+        }
+    }
+
+    @Test fun starProjection() {
+        verifyOutput("testdata/format/starProjection.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun extensionFunctionParameter() {
+        verifyOutput("testdata/format/extensionFunctionParameter.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun summarizeSignatures() {
+        verifyOutput("testdata/format/summarizeSignatures.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members)
+        }
+    }
+
+    @Test fun summarizeSignaturesProperty() {
+        verifyOutput("testdata/format/summarizeSignaturesProperty.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members)
+        }
+    }
+
+    @Test fun reifiedTypeParameter() {
+        verifyOutput("testdata/format/reifiedTypeParameter.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun annotatedTypeParameter() {
+        verifyOutput("testdata/format/annotatedTypeParameter.kt", ".md", withKotlinRuntime = true) { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members)
+        }
+    }
+
+    @Test fun inheritedMembers() {
+        verifyOutput("testdata/format/inheritedMembers.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members.filter { it.name == "Bar" })
+        }
+    }
+
+    @Test fun inheritedExtensions() {
+        verifyOutput("testdata/format/inheritedExtensions.kt", ".md") { model, output ->
+            markdownService.appendNodes(tempLocation, output, model.members.single().members.filter { it.name == "Bar" })
+        }
+    }
+}
diff --git a/core/src/test/kotlin/format/PackageDocsTest.kt b/core/src/test/kotlin/format/PackageDocsTest.kt
new file mode 100644
index 00000000..4d7852da
--- /dev/null
+++ b/core/src/test/kotlin/format/PackageDocsTest.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.dokka.tests.format
+
+import org.jetbrains.dokka.ContentBlock
+import org.jetbrains.dokka.ContentText
+import org.jetbrains.dokka.DokkaConsoleLogger
+import org.jetbrains.dokka.PackageDocs
+import org.junit.Test
+import kotlin.test.assertEquals
+
+public class PackageDocsTest {
+    @Test fun verifyParse() {
+        val docs = PackageDocs(null, DokkaConsoleLogger)
+        docs.parse("testdata/packagedocs/stdlib.md", null)
+        val packageContent = docs.packageContent["kotlin"]!!
+        val block = (packageContent.children.single() as ContentBlock).children.first() as ContentText
+        assertEquals("Core functions and types", block.text)
+    }
+}
diff --git a/core/src/test/kotlin/javadoc/JavadocTest.kt b/core/src/test/kotlin/javadoc/JavadocTest.kt
new file mode 100644
index 00000000..4f0049ac
--- /dev/null
+++ b/core/src/test/kotlin/javadoc/JavadocTest.kt
@@ -0,0 +1,44 @@
+package org.jetbrains.dokka.javadoc
+
+import org.jetbrains.dokka.DokkaConsoleLogger
+import org.jetbrains.dokka.tests.verifyModel
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+
+class JavadocTest {
+    @Test fun testTypes() {
+        verifyModel("testdata/javadoc/types.kt", format = "javadoc", withJdk = true) { model ->
+            val doc = ModuleNodeAdapter(model, StandardReporter(DokkaConsoleLogger), "")
+            val classDoc = doc.classNamed("foo.TypesKt")!!
+            val method = classDoc.methods().find { it.name() == "foo" }!!
+
+            val type = method.returnType()
+            assertFalse(type.asClassDoc().isIncluded)
+            assertEquals("java.lang.String", type.qualifiedTypeName())
+            assertEquals("java.lang.String", type.asClassDoc().qualifiedName())
+
+            val params = method.parameters()
+            assertTrue(params[0].type().isPrimitive)
+            assertFalse(params[1].type().asClassDoc().isIncluded)
+        }
+    }
+
+    @Test fun testObject() {
+        verifyModel("testdata/javadoc/obj.kt", format = "javadoc") { model ->
+            val doc = ModuleNodeAdapter(model, StandardReporter(DokkaConsoleLogger), "")
+
+            val classDoc = doc.classNamed("foo.O")
+            assertNotNull(classDoc)
+
+            val companionDoc = doc.classNamed("foo.O.Companion")
+            assertNotNull(companionDoc)
+
+            val pkgDoc = doc.packageNamed("foo")!!
+            assertEquals(2, pkgDoc.allClasses().size)
+        }
+    }
+
+}
diff --git a/core/src/test/kotlin/markdown/ParserTest.kt b/core/src/test/kotlin/markdown/ParserTest.kt
new file mode 100644
index 00000000..5a7adf05
--- /dev/null
+++ b/core/src/test/kotlin/markdown/ParserTest.kt
@@ -0,0 +1,142 @@
+package org.jetbrains.dokka.tests
+
+import org.junit.Test
+import org.jetbrains.dokka.toTestString
+import org.jetbrains.dokka.parseMarkdown
+import org.junit.Ignore
+
+@Ignore public class ParserTest {
+    fun runTestFor(text : String) {
+        println("MD: ---")
+        println(text)
+        val markdownTree = parseMarkdown(text)
+        println("AST: ---")
+        println(markdownTree.toTestString())
+        println()
+    }
+
+    @Test fun text() {
+        runTestFor("text")
+    }
+
+    @Test fun textWithSpaces() {
+        runTestFor("text and string")
+    }
+
+    @Test fun textWithColon() {
+        runTestFor("text and string: cool!")
+    }
+
+    @Test fun link() {
+        runTestFor("text [links]")
+    }
+
+    @Test fun linkWithHref() {
+        runTestFor("text [links](http://google.com)")
+    }
+
+    @Test fun multiline() {
+        runTestFor(
+                """
+text
+and
+string
+""")
+    }
+
+    @Test fun para() {
+        runTestFor(
+                """
+paragraph number
+one
+
+paragraph
+number two
+""")
+    }
+
+    @Test fun bulletList() {
+        runTestFor(
+                """* list item 1
+* list item 2
+""")
+    }
+
+    @Test fun bulletListWithLines() {
+        runTestFor(
+                """
+* list item 1
+  continue 1
+* list item 2
+  continue 2
+ """)
+    }
+
+    @Test fun bulletListStrong() {
+        runTestFor(
+                """
+* list *item* 1
+  continue 1
+* list *item* 2
+  continue 2
+ """)
+    }
+
+    @Test fun emph() {
+        runTestFor("*text*")
+    }
+
+    @Test fun directive() {
+        runTestFor("A text \${code with.another.value} with directive")
+    }
+
+    @Test fun emphAndEmptySection() {
+        runTestFor("*text*\n\$sec:\n")
+    }
+
+    @Test fun emphAndSection() {
+        runTestFor("*text*\n\$sec: some text\n")
+    }
+
+    @Test fun emphAndBracedSection() {
+        runTestFor("Text *bold* text \n\${sec}: some text")
+    }
+
+    @Test fun section() {
+        runTestFor(
+                "Plain text \n\$one: Summary \n\${two}: Description with *emphasis* \n\${An example of a section}: Example")
+    }
+
+    @Test fun anonymousSection() {
+        runTestFor("Summary\n\nDescription\n")
+    }
+
+    @Test fun specialSection() {
+        runTestFor(
+                "Plain text \n\$\$summary: Summary \n\${\$description}: Description \n\${\$An example of a section}: Example")
+    }
+
+    @Test fun emptySection() {
+        runTestFor(
+                "Plain text \n\$summary:")
+    }
+
+    val b = "$"
+    @Test fun pair() {
+        runTestFor(
+                """Represents a generic pair of two values.
+
+There is no meaning attached to values in this class, it can be used for any purpose.
+Pair exhibits value semantics, i.e. two pairs are equal if both components are equal.
+
+An example of decomposing it into values:
+${b}{code test.tuples.PairTest.pairMultiAssignment}
+
+${b}constructor: Creates new instance of [Pair]
+${b}first: First value
+${b}second: Second value""""
+                  )
+    }
+
+}
+
diff --git a/core/src/test/kotlin/model/ClassTest.kt b/core/src/test/kotlin/model/ClassTest.kt
new file mode 100644
index 00000000..981791c4
--- /dev/null
+++ b/core/src/test/kotlin/model/ClassTest.kt
@@ -0,0 +1,275 @@
+package org.jetbrains.dokka.tests
+
+import org.jetbrains.dokka.Content
+import org.jetbrains.dokka.DocumentationNode
+import org.jetbrains.dokka.DocumentationReference
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+public class ClassTest {
+    @Test fun emptyClass() {
+        verifyModel("testdata/classes/emptyClass.kt") { model ->
+            with(model.members.single().members.single()) {
+                assertEquals(DocumentationNode.Kind.Class, kind)
+                assertEquals("Klass", name)
+                assertEquals(Content.Empty, content)
+                assertEquals("<init>", members.single().name)
+                assertTrue(links.none())
+            }
+        }
+    }
+
+    @Test fun emptyObject() {
+        verifyModel("testdata/classes/emptyObject.kt") { model ->
+            with(model.members.single().members.single()) {
+                assertEquals(DocumentationNode.Kind.Object, kind)
+                assertEquals("Obj", name)
+                assertEquals(Content.Empty, content)
+                assertTrue(members.none())
+                assertTrue(links.none())
+            }
+        }
+    }
+
+    @Test fun classWithConstructor() {
+        verifyModel("testdata/classes/classWithConstructor.kt") { model ->
+            with (model.members.single().members.single()) {
+                assertEquals(DocumentationNode.Kind.Class, kind)
+                assertEquals("Klass", name)
+                assertEquals(Content.Empty, content)
+