Tests for public API dump tool.

libraries/tools/binary-compatibility-validator/pom.xml

@@ -21,6 +21,12 @@
             <artifactId>kotlin-stdlib</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-test-junit</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.ow2.asm</groupId>
             <artifactId>asm-debug-all</artifactId>
@@ -56,6 +62,12 @@
                         <goals>
                             <goal>test-compile</goal>
                         </goals>
+                        <configuration>
+                            <args combine.children="append">
+                                <arg>-Xdump-declarations-to</arg>
+                                <arg>${basedir}/target/cases-declarations.json</arg>
+                            </args>
+                        </configuration>
                     </execution>
                 </executions>
             </plugin>

libraries/tools/binary-compatibility-validator/src/main/kotlin/org.jetbrains.kotlin.tools/PublicApiDump.kt

@@ -43,7 +43,7 @@ fun getBinaryAPI(classStreams: Sequence<InputStream>, visibilityMap: Map<String,
 
             val supertypes = listOf(superName) - "java/lang/Object" + interfaces.sorted()
 
-            val modifiers = getModifierString(access)
+            val modifiers = getModifierString(effectiveAccess and Opcodes.ACC_STATIC.inv())
 
             val memberSignatures =
                     fields.filter { it.isPublic() }

libraries/tools/binary-compatibility-validator/src/main/kotlin/org.jetbrains.kotlin.tools/asmUtils.kt

@@ -51,6 +51,7 @@ fun ClassNode.isLocal() = innerClasses.filter { it.name == name && it.innerName
 fun ClassNode.isWhenMappings() = isSynthetic() && name.endsWith("\$WhenMappings")
 fun MethodNode.isAccessMethod() = isSynthetic() && name.startsWith("access\$")
 
+val ClassNode.effectiveAccess: Int get() = innerClasses.singleOrNull { it.name == name }?.access ?: access
 
 
 private object KotlinClassKind {

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/companions/companions.kt

@@ -0,0 +1,102 @@
+package cases.companions
+
+
+object PublicClasses {
+    class PublicCompanion {
+        companion object
+    }
+
+    class ProtectedCompanion {
+        protected companion object
+    }
+
+    abstract class AbstractProtectedCompanion {
+        protected companion object
+    }
+
+    class InternalCompanion {
+        internal companion object
+    }
+
+    class PrivateCompanion {
+        private companion object
+    }
+}
+
+object PublicInterfaces {
+    interface PublicCompanion {
+        companion object
+    }
+
+    interface PrivateCompanion {
+        private companion object
+    }
+}
+
+
+
+object InternalClasses {
+    internal class PublicCompanion {
+        companion object
+    }
+
+    internal class ProtectedCompanion {
+        protected companion object
+    }
+
+    internal abstract class AbstractProtectedCompanion {
+        protected companion object
+    }
+
+    internal class InternalCompanion {
+        internal companion object
+    }
+
+    internal class PrivateCompanion {
+        private companion object
+    }
+}
+
+object InternalInterfaces {
+    internal interface PublicCompanion {
+        companion object
+    }
+
+    internal interface PrivateCompanion {
+        private companion object
+    }
+}
+
+
+object PrivateClasses {
+    private class PublicCompanion {
+        companion object
+    }
+
+    private class ProtectedCompanion {
+        protected companion object
+    }
+
+    private abstract class AbstractProtectedCompanion {
+        protected companion object
+    }
+
+    private class InternalCompanion {
+        internal companion object
+    }
+
+    private class PrivateCompanion {
+        private companion object
+    }
+}
+
+object PrivateInterfaces {
+    private interface PublicCompanion {
+        companion object
+    }
+
+    private interface PrivateCompanion {
+        private companion object
+    }
+}
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/inline/inlineExposed.kt

@@ -0,0 +1,22 @@
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+package cases.inline
+
+@kotlin.internal.InlineExposed
+internal fun exposedForInline() {}
+
+@kotlin.internal.InlineExposed
+internal class InternalClassExposed
+    @kotlin.internal.InlineExposed
+    internal constructor() {
+
+    @kotlin.internal.InlineExposed
+    internal fun funExposed() {}
+
+    @kotlin.internal.InlineExposed
+    internal var propertyExposed: String? = null
+
+    @JvmField
+    @kotlin.internal.InlineExposed
+    internal var fieldExposed: String? = null
+
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/inline/inlineOnly.kt

@@ -0,0 +1,5 @@
+package cases.inline
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@kotlin.internal.InlineOnly
+public inline fun inlineOnly(f: () -> Unit) = f()

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/internal/internalClass.kt

@@ -0,0 +1,7 @@
+package cases.internal
+
+internal class InternalClass {
+    public val property = 1
+
+    public fun function() = property
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/internal/internalMultifile1.kt

@@ -0,0 +1,5 @@
+@file:JvmName("MultifileKt")
+@file:JvmMultifileClass
+package cases.internal
+
+internal fun internalFun1() = internalVal

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/internal/internalMultifile2.kt

@@ -0,0 +1,5 @@
+@file:JvmName("MultifileKt")
+@file:JvmMultifileClass
+package cases.internal
+
+internal val internalVal = "Internal"

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/internal/internalPart.kt

@@ -0,0 +1,7 @@
+package cases.internal
+
+internal fun internalFun() {
+
+}
+
+// TODO: var, val, const

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/internal/publicClassInternalMember.kt

@@ -0,0 +1,9 @@
+package cases.internal
+
+public class PublicClass internal constructor() {
+
+    internal val property = 1
+
+    internal fun function() = property
+
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/java/Facade.java

@@ -0,0 +1,11 @@
+package cases.java;
+
+class Part1 {
+    public static void publicMethod(String param) { }
+}
+
+class Part2 extends Part1 {
+    public static void publicMethod(int param) { }
+}
+
+public class Facade extends Part2 { }

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/localClasses/fromStdlib.kt

@@ -0,0 +1,5 @@
+package cases.localClasses
+
+import kotlin.comparisons.compareBy
+
+private val COMPARER = compareBy<String> { it.length }

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/localClasses/lambdas.kt

@@ -0,0 +1,19 @@
+package cases.localClasses
+
+
+class L {
+    internal fun a(lambda: () -> Unit) = lambda()
+
+    internal inline fun inlineLambda() {
+        a {
+            println("OK")
+        }
+    }
+}
+
+fun box() {
+    L().inlineLambda()
+}
+
+
+// TODO: inline lambda from stdlib

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/localClasses/localClasses.kt

@@ -0,0 +1,23 @@
+package cases.localClasses
+
+class A {
+    fun a() : String {
+        class B() {
+            fun s() : String = "OK"
+
+            inner class C {}
+
+        }
+        return B().s()
+    }
+}
+
+
+class B {
+    fun a(p: String) : String {
+        class B() {
+            fun s() : String = p
+        }
+        return B().s()
+    }
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/nestedClasses/internalClass.kt

@@ -0,0 +1,24 @@
+package cases.nestedClasses
+
+internal class InternalClass {
+    public object ObjPublic
+    internal object ObjInternal
+    protected object ObjProtected
+    private object ObjPrivate
+
+    public class NestedPublic
+    internal class NestedInternal
+    protected class NestedProtected
+    private class NestedPrivate
+
+    public interface NestedPublicInterface
+    internal interface NestedInternalInterface
+    protected interface NestedProtectedInterface
+    private interface NestedPrivateInterface
+
+    public inner class InnerPublic
+    internal inner class InnerInternal
+    protected inner class InnerProtected
+    private inner class InnerPrivate
+}
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/nestedClasses/internalInterface.kt

@@ -0,0 +1,14 @@
+package cases.nestedClasses
+
+internal interface InternalInterface {
+    public object ObjPublic
+    private object ObjPrivate
+
+    public class NestedPublic
+    private class NestedPrivate
+
+    public interface NestedPublicInterface
+    private interface NestedPrivateInterface
+
+}
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/nestedClasses/internalObject.kt

@@ -0,0 +1,17 @@
+package cases.nestedClasses
+
+internal object InternalObject {
+
+    public object ObjPublic
+    internal object ObjInternal
+    private object ObjPrivate
+
+    public class NestedPublic
+    internal class NestedInternal
+    private class NestedPrivate
+
+    public interface NestedPublicInterface
+    internal interface NestedInternalInterface
+    private interface NestedPrivateInterface
+}
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/nestedClasses/privateClass.kt

@@ -0,0 +1,24 @@
+package cases.nestedClasses
+
+private class PrivateClass {
+    public object ObjPublic
+    internal object ObjInternal
+    protected object ObjProtected
+    private object ObjPrivate
+
+    public class NestedPublic
+    internal class NestedInternal
+    protected class NestedProtected
+    private class NestedPrivate
+
+    public interface NestedPublicInterface
+    internal interface NestedInternalInterface
+    protected interface NestedProtectedInterface
+    private interface NestedPrivateInterface
+
+    public inner class InnerPublic
+    internal inner class InnerInternal
+    protected inner class InnerProtected
+    private inner class InnerPrivate
+}
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/nestedClasses/privateInterface.kt

@@ -0,0 +1,14 @@
+package cases.nestedClasses
+
+private interface PrivateInterface {
+    public object ObjPublic
+    private object ObjPrivate
+
+    public class NestedPublic
+    private class NestedPrivate
+
+    public interface NestedPublicInterface
+    private interface NestedPrivateInterface
+
+}
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/nestedClasses/privateObject.kt

@@ -0,0 +1,17 @@
+package cases.nestedClasses
+
+private object PrivateObject {
+
+    public object ObjPublic
+    internal object ObjInternal
+    private object ObjPrivate
+
+    public class NestedPublic
+    internal class NestedInternal
+    private class NestedPrivate
+
+    public interface NestedPublicInterface
+    internal interface NestedInternalInterface
+    private interface NestedPrivateInterface
+}
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/nestedClasses/publicAbstractClass.kt

@@ -0,0 +1,12 @@
+package cases.nestedClasses
+
+public abstract class PublicAbstractClass {
+    protected object ObjProtected
+
+    protected class NestedProtected
+
+    protected interface NestedProtectedInterface
+
+    protected inner class InnerProtected
+}
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/nestedClasses/publicClass.kt

@@ -0,0 +1,24 @@
+package cases.nestedClasses
+
+public class PublicClass {
+    public object ObjPublic
+    internal object ObjInternal
+    protected object ObjProtected
+    private object ObjPrivate
+
+    public class NestedPublic
+    internal class NestedInternal
+    protected class NestedProtected
+    private class NestedPrivate
+
+    public interface NestedPublicInterface
+    internal interface NestedInternalInterface
+    protected interface NestedProtectedInterface
+    private interface NestedPrivateInterface
+
+    public inner class InnerPublic
+    internal inner class InnerInternal
+    protected inner class InnerProtected
+    private inner class InnerPrivate
+}
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/nestedClasses/publicInterface.kt

@@ -0,0 +1,14 @@
+package cases.nestedClasses
+
+public interface PublicInterface {
+    public object ObjPublic
+    private object ObjPrivate
+
+    public class NestedPublic
+    private class NestedPrivate
+
+    public interface NestedPublicInterface
+    private interface NestedPrivateInterface
+
+}
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/nestedClasses/publicObject.kt

@@ -0,0 +1,17 @@
+package cases.nestedClasses
+
+public object PublicObject {
+
+    public object ObjPublic
+    internal object ObjInternal
+    private object ObjPrivate
+
+    public class NestedPublic
+    internal class NestedInternal
+    private class NestedPrivate
+
+    public interface NestedPublicInterface
+    internal interface NestedInternalInterface
+    private interface NestedPrivateInterface
+}
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/nestedClasses/publicOpenClass.kt

@@ -0,0 +1,12 @@
+package cases.nestedClasses
+
+public open class PublicOpenClass {
+    protected object ObjProtected
+
+    protected class NestedProtected
+
+    protected interface NestedProtectedInterface
+
+    protected inner class InnerProtected
+}
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/private/privateClassMembers.kt

@@ -0,0 +1,7 @@
+package cases.private
+
+private open class PrivateClass public constructor() {
+    internal val internalVal = 1
+
+    protected fun protectedFun() = internalVal
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/private/privateMultifile1.kt

@@ -0,0 +1,8 @@
+@file:JvmName("MultifileKt")
+@file:JvmMultifileClass
+package cases.private
+
+private val privateVal: Any? = 1
+private var privateVar: Any? = 1
+
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/private/privateMultifile2.kt

@@ -0,0 +1,19 @@
+@file:JvmName("MultifileKt")
+@file:JvmMultifileClass
+package cases.private
+
+
+// const
+private const val privateConst: Int = 4
+
+// fun
+
+private fun privateFun(x: Any) {}
+
+
+private class PrivateClassInMultifile {
+    internal fun accessUsage() {
+        privateFun(privateConst)
+    }
+
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/private/privatePart.kt

@@ -0,0 +1,23 @@
+package cases.private
+
+// properties
+private val privateVal: Any? = 1
+private var privateVar: Any? = 1
+
+// constants
+
+private const val privateConst: Int = 4
+
+// fun
+
+private fun privateFun(a: Any?) = privateConst
+
+// access
+private class PrivateClassInPart {
+    internal fun accessUsage() {
+        privateFun(privateVal)
+        privateFun(privateVar)
+        privateFun(privateConst)
+    }
+
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/protected/protectedInAbstract.kt

@@ -0,0 +1,8 @@
+package cases.protected
+
+public abstract class PublicAbstractClass protected constructor() {
+    protected abstract val protectedVal: Int
+    protected abstract var protectedVar: Any?
+
+    protected abstract fun protectedFun()
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/protected/protectedInFinal.kt

@@ -0,0 +1,8 @@
+package cases.protected
+
+public class PublicFinalClass protected constructor() {
+    protected val protectedVal = 1
+    protected var protectedVar = 2
+
+    protected fun protectedFun() = protectedVal
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/protected/protectedInOpen.kt

@@ -0,0 +1,8 @@
+package cases.protected
+
+public open class PublicOpenClass protected constructor() {
+    protected val protectedVal = 1
+    protected var protectedVar = 2
+
+    protected fun protectedFun() = protectedVal
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/public/publicMultifile1.kt

@@ -0,0 +1,5 @@
+@file:JvmName("MultifileKt")
+@file:JvmMultifileClass
+package cases.public
+
+public fun publicFun1() = publicVal

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/public/publicMultifile2.kt

@@ -0,0 +1,5 @@
+@file:JvmName("MultifileKt")
+@file:JvmMultifileClass
+package cases.public
+
+public val publicVal = "Public"

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/public/publicPart.kt

@@ -0,0 +1,5 @@
+package cases.public
+
+public fun publicFun() {
+
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/special/hidden.kt

@@ -0,0 +1,25 @@
+package cases.special
+
+@Deprecated("For binary compatibility", level = DeprecationLevel.HIDDEN)
+public class HiddenClass
+    @Deprecated("For binary compatibility", level = DeprecationLevel.HIDDEN)
+    public constructor() {
+
+    @Deprecated("For binary compatibility", level = DeprecationLevel.HIDDEN)
+    val hiddenVal = 1
+
+    @Deprecated("For binary compatibility", level = DeprecationLevel.HIDDEN)
+    var hiddenVar = 2
+
+    @Deprecated("For binary compatibility", level = DeprecationLevel.HIDDEN)
+    fun hiddenFun() {}
+
+    public var varWithHiddenAccessors: String = ""
+        @Deprecated("For binary compatibility", level = DeprecationLevel.HIDDEN)
+        get
+        @Deprecated("For binary compatibility", level = DeprecationLevel.HIDDEN)
+        set
+}
+
+@Deprecated("For binary compatibility", level = DeprecationLevel.HIDDEN)
+fun hiddenTopLevelFun() {}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/special/internalLateinitMember.kt

@@ -0,0 +1,10 @@
+package cases.special
+
+public class ClassWithLateInitMembers internal constructor() {
+
+    public lateinit var publicLateInitWithInternalSet: String
+        internal set
+
+    internal lateinit var internalLateInit: String
+
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/special/jvmNames.kt

@@ -0,0 +1,22 @@
+package cases.special
+
+@JvmName("internalFun")
+internal fun internalRenamedFun() {}
+
+internal var internalVar: Int = 1
+    @JvmName("internalVarGetter")
+    get
+    @JvmName("internalVarSetter")
+    set
+
+@JvmName("publicFun")
+public fun publicRenamedFun() {}
+
+public var publicVar: Int = 1
+    @JvmName("publicVarGetter")
+    get
+    @JvmName("publicVarSetter")
+    set
+
+
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/special/jvmOverloads.kt

@@ -0,0 +1,17 @@
+package cases.special
+
+
+@JvmOverloads
+public fun publicFunWithOverloads(a: Int = 0, b: String? = null) {}
+
+@JvmOverloads
+internal fun internalFunWithOverloads(a: Int = 0, b: String? = null) {}
+
+public class ClassWithOverloads
+    @JvmOverloads
+    internal constructor(val a: Int = 0, val b: String? = null) {
+
+    @JvmOverloads
+    internal fun internalFunWithOverloads(a: Int = 0, b: String? = null) {}
+
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/whenMappings/enumWhen.kt

@@ -0,0 +1,20 @@
+package cases.whenMappings
+
+enum class SampleEnum {
+    A,
+    B,
+    C
+}
+
+fun SampleEnum.deacronimize() = when (this) {
+    SampleEnum.A -> "Apple"
+    SampleEnum.B -> "Biscuit"
+    SampleEnum.C -> "Cinnamon"
+}
+
+
+inline fun SampleEnum.switch(thenA: () -> Unit, thenB: () -> Unit, thenC: () -> Unit) = when (this) {
+    SampleEnum.C -> thenC()
+    SampleEnum.B -> thenB()
+    SampleEnum.A -> thenA()
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/cases/whenMappings/sealedClassWhen.kt

@@ -0,0 +1,20 @@
+package cases.whenMappings
+
+sealed class SampleSealed {
+    class A : SampleSealed()
+    class B : SampleSealed()
+    class C : SampleSealed()
+}
+
+fun SampleSealed.deacronimize() = when (this) {
+    is SampleSealed.A -> "Apple"
+    is SampleSealed.B -> "Biscuit"
+    is SampleSealed.C -> "Cinnamon"
+}
+
+
+inline fun SampleSealed.switch(thenA: () -> Unit, thenB: () -> Unit, thenC: () -> Unit) = when (this) {
+    is SampleSealed.C -> thenC()
+    is SampleSealed.B -> thenB()
+    is SampleSealed.A -> thenA()
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/org.jetbrains.kotlin.tools.tests/CasesPublicAPITest.kt

@@ -0,0 +1,50 @@
+package org.jetbrains.kotlin.tools.tests
+
+import org.jetbrains.kotlin.tools.*
+import org.junit.*
+import org.junit.rules.TestName
+import java.io.File
+
+class CasesPublicAPITest {
+
+    val visibilities = readKotlinVisibilities(File("target/cases-declarations.json"))
+    val baseClassPath = File("target/test-classes/cases").absoluteFile
+
+    @[Rule JvmField]
+    val testName = TestName()
+
+    @Test fun companions() { snapshotAPIAndCompare(testName.methodName) }
+
+    @Test fun inline() { snapshotAPIAndCompare(testName.methodName) }
+
+    @Test fun internal() { snapshotAPIAndCompare(testName.methodName) }
+
+    @Test fun java() { snapshotAPIAndCompare(testName.methodName) }
+
+    @Test fun localClasses() { snapshotAPIAndCompare(testName.methodName) }
+
+    @Test fun nestedClasses() { snapshotAPIAndCompare(testName.methodName) }
+
+    @Test fun private() { snapshotAPIAndCompare(testName.methodName) }
+
+    @Test fun protected() { snapshotAPIAndCompare(testName.methodName) }
+
+    @Test fun public() { snapshotAPIAndCompare(testName.methodName) }
+
+    @Test fun special() { snapshotAPIAndCompare(testName.methodName) }
+
+    @Test fun whenMappings() { snapshotAPIAndCompare(testName.methodName) }
+
+
+    private fun snapshotAPIAndCompare(testClassRelativePath: String) {
+        val testClassPath = baseClassPath.resolve(testClassRelativePath)
+        val testClasses = testClassPath.listFiles() ?: throw IllegalStateException("Cannot list files in $testClassPath")
+        val testClassStreams = testClasses.asSequence().filter { it.name.endsWith(".class") }.map { it.inputStream() }
+
+        val api = getBinaryAPI(testClassStreams, visibilities).filterOutNonPublic()
+
+        val target = File("src/test/resources/output/cases").resolve(testName.methodName + ".txt")
+
+        api.dumpAndCompareWith(target)
+    }
+}

libraries/tools/binary-compatibility-validator/src/test/kotlin/org.jetbrains.kotlin.tools.tests/RuntimePublicAPITest.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.tools.tests
+
+import org.jetbrains.kotlin.tools.*
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TestName
+import java.io.File
+import java.util.jar.JarFile
+
+class RuntimePublicAPITest {
+
+    @[Rule JvmField]
+    val testName = TestName()
+
+    @Test fun kotlinRuntime() {
+        snapshotAPIAndCompare("../../tools/runtime/target", "kotlin-runtime-0.1-SNAPSHOT.jar", "runtime-declarations.json")
+    }
+
+    @Test fun kotlinStdlib() {
+        snapshotAPIAndCompare("../../stdlib/target", "kotlin-stdlib-0.1-SNAPSHOT.jar", "stdlib-declarations.json")
+    }
+
+    private fun snapshotAPIAndCompare(basePath: String, jarPath: String, kotlinJvmMappingsPath: String) {
+        val base = File(basePath).absoluteFile
+        val visibilities = readKotlinVisibilities(base.resolve(kotlinJvmMappingsPath))
+
+        // TODO: List jars since version can differ
+        // TODO: Excluded package list
+        val api = getBinaryAPI(JarFile(base.resolve(jarPath)), visibilities).filterOutNonPublic()
+
+        val target = File("src/test/resources/output")
+                .resolve(testName.methodName.replaceCamelCaseWithDashedLowerCase() + ".txt")
+
+        api.dumpAndCompareWith(target)
+    }
+
+}
+

libraries/tools/binary-compatibility-validator/src/test/kotlin/org.jetbrains.kotlin.tools.tests/utils.kt

@@ -0,0 +1,40 @@
+package org.jetbrains.kotlin.tools.tests
+
+import org.jetbrains.kotlin.tools.*
+import java.io.File
+import kotlin.test.assertEquals
+import kotlin.test.fail
+
+private val OVERWRITE_EXPECTED_OUTPUT = System.getProperty("overwrite.output")?.toBoolean() ?: false // use -Doverwrite.output=true
+
+fun List<ClassBinarySignature>.dumpAndCompareWith(to: File) {
+    if (!to.exists()) {
+        to.parentFile?.mkdirs()
+        to.bufferedWriter().use { dump(to = it) }
+        fail("Expected data file did not exist. Generating: $to")
+    } else {
+        val actual = dump(to = StringBuilder())
+        assertEqualsToFile(to, actual)
+    }
+}
+
+private fun assertEqualsToFile(expectedFile: File, actual: CharSequence) {
+    val actualText = actual.trimTrailingWhitespacesAndAddNewlineAtEOF()
+    val expectedText = expectedFile.readText().trimTrailingWhitespacesAndAddNewlineAtEOF()
+
+    if (OVERWRITE_EXPECTED_OUTPUT && expectedText != actualText) {
+        expectedFile.writeText(actualText)
+        assertEquals(expectedText, actualText, "Actual data differs from file content: ${expectedFile.name}, rewriting")
+    }
+
+    assertEquals(expectedText, actualText, "Actual data differs from file content: ${expectedFile.name}")
+}
+
+private fun CharSequence.trimTrailingWhitespacesAndAddNewlineAtEOF(): String =
+        this.lineSequence().map { it.trimEnd() }.joinToString(separator = "\n").let {
+            if (it.endsWith("\n")) it else it + "\n"
+        }
+
+
+private val UPPER_CASE_CHARS = Regex("[A-Z]+")
+fun String.replaceCamelCaseWithDashedLowerCase() = replace(UPPER_CASE_CHARS) { "-" + it.value.toLowerCase() }

libraries/tools/binary-compatibility-validator/src/test/resources/output/cases/companions.txt

@@ -0,0 +1,69 @@
+public final class cases/companions/InternalClasses
+public static final field INSTANCE Lcases/companions/InternalClasses;
+------------------
+
+public final class cases/companions/InternalInterfaces
+public static final field INSTANCE Lcases/companions/InternalInterfaces;
+------------------
+
+public final class cases/companions/PrivateClasses
+public static final field INSTANCE Lcases/companions/PrivateClasses;
+------------------
+
+public final class cases/companions/PrivateInterfaces
+public static final field INSTANCE Lcases/companions/PrivateInterfaces;
+------------------
+
+public final class cases/companions/PublicClasses
+public static final field INSTANCE Lcases/companions/PublicClasses;
+------------------
+
+public abstract class cases/companions/PublicClasses$AbstractProtectedCompanion
+public static final field Companion Lcases/companions/PublicClasses$AbstractProtectedCompanion$Companion;
+public fun <init> ()V
+------------------
+
+protected final class cases/companions/PublicClasses$AbstractProtectedCompanion$Companion
+------------------
+
+public final class cases/companions/PublicClasses$InternalCompanion
+public static final field Companion Lcases/companions/PublicClasses$InternalCompanion$Companion;
+public fun <init> ()V
+------------------
+
+public final class cases/companions/PublicClasses$PrivateCompanion
+public static final field Companion Lcases/companions/PublicClasses$PrivateCompanion$Companion;
+public fun <init> ()V
+------------------
+
+public final class cases/companions/PublicClasses$ProtectedCompanion
+public static final field Companion Lcases/companions/PublicClasses$ProtectedCompanion$Companion;
+public fun <init> ()V
+------------------
+
+protected final class cases/companions/PublicClasses$ProtectedCompanion$Companion
+------------------
+
+public final class cases/companions/PublicClasses$PublicCompanion
+public static final field Companion Lcases/companions/PublicClasses$PublicCompanion$Companion;
+public fun <init> ()V
+------------------
+
+public final class cases/companions/PublicClasses$PublicCompanion$Companion
+------------------
+
+public final class cases/companions/PublicInterfaces
+public static final field INSTANCE Lcases/companions/PublicInterfaces;
+------------------
+
+public abstract interface class cases/companions/PublicInterfaces$PrivateCompanion
+public static final field Companion Lcases/companions/PublicInterfaces$PrivateCompanion$Companion;
+------------------
+
+public abstract interface class cases/companions/PublicInterfaces$PublicCompanion
+public static final field Companion Lcases/companions/PublicInterfaces$PublicCompanion$Companion;
+------------------
+
+public final class cases/companions/PublicInterfaces$PublicCompanion$Companion
+------------------
+

libraries/tools/binary-compatibility-validator/src/test/resources/output/cases/internal.txt

@@ -0,0 +1,3 @@
+public final class cases/internal/PublicClass
+------------------
+

libraries/tools/binary-compatibility-validator/src/test/resources/output/cases/java.txt

@@ -0,0 +1,4 @@
+public class cases/java/Facade: cases/java/Part2
+public fun <init> ()V
+------------------
+

libraries/tools/binary-compatibility-validator/src/test/resources/output/cases/localClasses.txt

@@ -0,0 +1,18 @@
+public final class cases/localClasses/A
+public fun <init> ()V
+public final fun a ()Ljava/lang/String;
+------------------
+
+public final class cases/localClasses/B
+public fun <init> ()V
+public final fun a (Ljava/lang/String;)Ljava/lang/String;
+------------------
+
+public final class cases/localClasses/L
+public fun <init> ()V
+------------------
+
+public final class cases/localClasses/LambdasKt
+public static final fun box ()V
+------------------
+

libraries/tools/binary-compatibility-validator/src/test/resources/output/cases/nestedClasses.txt

@@ -0,0 +1,101 @@
+public abstract class cases/nestedClasses/PublicAbstractClass
+public fun <init> ()V
+------------------
+
+protected final class cases/nestedClasses/PublicAbstractClass$InnerProtected
+public fun <init> (Lcases/nestedClasses/PublicAbstractClass;)V
+------------------
+
+protected final class cases/nestedClasses/PublicAbstractClass$NestedProtected
+public fun <init> ()V
+------------------
+
+protected abstract interface class cases/nestedClasses/PublicAbstractClass$NestedProtectedInterface
+------------------
+
+protected final class cases/nestedClasses/PublicAbstractClass$ObjProtected
+public static final field INSTANCE Lcases/nestedClasses/PublicAbstractClass$ObjProtected;
+------------------
+
+public final class cases/nestedClasses/PublicClass
+public fun <init> ()V
+------------------
+
+protected final class cases/nestedClasses/PublicClass$InnerProtected
+public fun <init> (Lcases/nestedClasses/PublicClass;)V
+------------------
+
+public final class cases/nestedClasses/PublicClass$InnerPublic
+public fun <init> (Lcases/nestedClasses/PublicClass;)V
+------------------
+
+protected final class cases/nestedClasses/PublicClass$NestedProtected
+public fun <init> ()V
+------------------
+
+protected abstract interface class cases/nestedClasses/PublicClass$NestedProtectedInterface
+------------------
+
+public final class cases/nestedClasses/PublicClass$NestedPublic
+public fun <init> ()V
+------------------
+
+public abstract interface class cases/nestedClasses/PublicClass$NestedPublicInterface
+------------------
+
+protected final class cases/nestedClasses/PublicClass$ObjProtected
+public static final field INSTANCE Lcases/nestedClasses/PublicClass$ObjProtected;
+------------------
+
+public final class cases/nestedClasses/PublicClass$ObjPublic
+public static final field INSTANCE Lcases/nestedClasses/PublicClass$ObjPublic;
+------------------
+
+public abstract interface class cases/nestedClasses/PublicInterface
+------------------
+
+public final class cases/nestedClasses/PublicInterface$NestedPublic
+public fun <init> ()V
+------------------
+
+public abstract interface class cases/nestedClasses/PublicInterface$NestedPublicInterface
+------------------
+
+public final class cases/nestedClasses/PublicInterface$ObjPublic
+public static final field INSTANCE Lcases/nestedClasses/PublicInterface$ObjPublic;
+------------------
+
+public final class cases/nestedClasses/PublicObject
+public static final field INSTANCE Lcases/nestedClasses/PublicObject;
+------------------
+
+public final class cases/nestedClasses/PublicObject$NestedPublic
+public fun <init> ()V
+------------------
+
+public abstract interface class cases/nestedClasses/PublicObject$NestedPublicInterface
+------------------
+
+public final class cases/nestedClasses/PublicObject$ObjPublic
+public static final field INSTANCE Lcases/nestedClasses/PublicObject$ObjPublic;
+------------------
+
+public class cases/nestedClasses/PublicOpenClass
+public fun <init> ()V
+------------------
+
+protected final class cases/nestedClasses/PublicOpenClass$InnerProtected
+public fun <init> (Lcases/nestedClasses/PublicOpenClass;)V
+------------------
+
+protected final class cases/nestedClasses/PublicOpenClass$NestedProtected
+public fun <init> ()V
+------------------
+
+protected abstract interface class cases/nestedClasses/PublicOpenClass$NestedProtectedInterface
+------------------
+
+protected final class cases/nestedClasses/PublicOpenClass$ObjProtected
+public static final field INSTANCE Lcases/nestedClasses/PublicOpenClass$ObjProtected;
+------------------
+

libraries/tools/binary-compatibility-validator/src/test/resources/output/cases/protected.txt

@@ -0,0 +1,24 @@
+public abstract class cases/protected/PublicAbstractClass
+protected fun <init> ()V
+protected abstract fun getProtectedVal ()I
+protected abstract fun getProtectedVar ()Ljava/lang/Object;
+protected abstract fun protectedFun ()V
+protected abstract fun setProtectedVar (Ljava/lang/Object;)V
+------------------
+
+public final class cases/protected/PublicFinalClass
+protected fun <init> ()V
+protected final fun getProtectedVal ()I
+protected final fun getProtectedVar ()I
+protected final fun protectedFun ()I
+protected final fun setProtectedVar (I)V
+------------------
+
+public class cases/protected/PublicOpenClass
+protected fun <init> ()V
+protected final fun getProtectedVal ()I
+protected final fun getProtectedVar ()I
+protected final fun protectedFun ()I
+protected final fun setProtectedVar (I)V
+------------------
+

libraries/tools/binary-compatibility-validator/src/test/resources/output/cases/public.txt

@@ -0,0 +1,9 @@
+public final class cases/public/MultifileKt
+public static final fun getPublicVal ()Ljava/lang/String;
+public static final fun publicFun1 ()Ljava/lang/String;
+------------------
+
+public final class cases/public/PublicPartKt
+public static final fun publicFun ()V
+------------------
+

libraries/tools/binary-compatibility-validator/src/test/resources/output/cases/special.txt

@@ -0,0 +1,38 @@
+public final class cases/special/ClassWithLateInitMembers
+public field internalLateInit Ljava/lang/String;
+public field publicLateInitWithInternalSet Ljava/lang/String;
+public final fun getPublicLateInitWithInternalSet ()Ljava/lang/String;
+------------------
+
+public final class cases/special/ClassWithOverloads
+public final fun getA ()I
+public final fun getB ()Ljava/lang/String;
+------------------
+
+public final class cases/special/HiddenClass
+public synthetic fun <init> ()V
+public final synthetic fun getHiddenVal ()I
+public final synthetic fun getHiddenVar ()I
+public final synthetic fun getVarWithHiddenAccessors ()Ljava/lang/String;
+public final synthetic fun hiddenFun ()V
+public final synthetic fun setHiddenVar (I)V
+public final synthetic fun setVarWithHiddenAccessors (Ljava/lang/String;)V
+------------------
+
+public final class cases/special/HiddenKt
+public static final synthetic fun hiddenTopLevelFun ()V
+------------------
+
+public final class cases/special/JvmNamesKt
+public static final fun publicFun ()V
+public static final fun publicVarGetter ()I
+public static final fun publicVarSetter (I)V
+------------------
+
+public final class cases/special/JvmOverloadsKt
+public static fun publicFunWithOverloads ()V
+public static fun publicFunWithOverloads (I)V
+public static final fun publicFunWithOverloads (ILjava/lang/String;)V
+public static synthetic fun publicFunWithOverloads$default (ILjava/lang/String;ILjava/lang/Object;)V
+------------------
+

libraries/tools/binary-compatibility-validator/src/test/resources/output/cases/whenMappings.txt

@@ -0,0 +1,33 @@
+public final class cases/whenMappings/EnumWhenKt
+public static final fun deacronimize (Lcases/whenMappings/SampleEnum;)Ljava/lang/String;
+public static final fun switch (Lcases/whenMappings/SampleEnum;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function0;)V
+------------------
+
+public final class cases/whenMappings/SampleEnum: java/lang/Enum
+public static final field A Lcases/whenMappings/SampleEnum;
+public static final field B Lcases/whenMappings/SampleEnum;
+public static final field C Lcases/whenMappings/SampleEnum;
+public static fun valueOf (Ljava/lang/String;)Lcases/whenMappings/SampleEnum;
+public static fun values ()[Lcases/whenMappings/SampleEnum;
+------------------
+
+public abstract class cases/whenMappings/SampleSealed
+------------------
+
+public final class cases/whenMappings/SampleSealed$A: cases/whenMappings/SampleSealed
+public fun <init> ()V
+------------------
+
+public final class cases/whenMappings/SampleSealed$B: cases/whenMappings/SampleSealed
+public fun <init> ()V
+------------------
+
+public final class cases/whenMappings/SampleSealed$C: cases/whenMappings/SampleSealed
+public fun <init> ()V
+------------------
+
+public final class cases/whenMappings/SealedClassWhenKt
+public static final fun deacronimize (Lcases/whenMappings/SampleSealed;)Ljava/lang/String;
+public static final fun switch (Lcases/whenMappings/SampleSealed;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function0;)V
+------------------
+