Tests for public API dump tool.

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()
+}