Merge boxWithStdlib testData into box, delete BoxWithStdlib test

compiler/testData/codegen/box/reflection/javaProperties/java.kt

@@ -0,0 +1,60 @@
+// WITH_REFLECT
+
+import kotlin.reflect.KClass
+
+fun checkPrimitive(clazz: Class<*>, expected: String) {
+    assert (clazz!!.canonicalName == expected) {
+        "clazz name: ${clazz.canonicalName}"
+    }
+}
+
+fun checkPrimitive(kClass: KClass<*>, expected: String) {
+    checkPrimitive(kClass.java, expected)
+}
+
+fun checkObject(clazz: Class<*>, expected: String) {
+    assert (clazz.canonicalName == "$expected") {
+        "clazz should be object, but found: ${clazz!!.canonicalName}"
+    }
+}
+
+fun checkObject(kClass: KClass<*>, expected: String) {
+    checkObject(kClass.java, expected)
+}
+
+fun box(): String {
+    checkPrimitive(Boolean::class.java, "boolean")
+    checkPrimitive(Boolean::class, "boolean")
+
+    checkPrimitive(Char::class.java, "char")
+    checkPrimitive(Char::class, "char")
+
+    checkPrimitive(Byte::class.java, "byte")
+    checkPrimitive(Byte::class, "byte")
+
+    checkPrimitive(Short::class.java, "short")
+    checkPrimitive(Short::class, "short")
+
+    checkPrimitive(Int::class.java, "int")
+    checkPrimitive(Int::class, "int")
+
+    checkPrimitive(Float::class.java, "float")
+    checkPrimitive(Float::class, "float")
+
+    checkPrimitive(Long::class.java, "long")
+    checkPrimitive(Long::class, "long")
+
+    checkPrimitive(Double::class.java, "double")
+    checkPrimitive(Double::class, "double")
+
+    checkObject(String::class.java, "java.lang.String")
+    checkObject(String::class, "java.lang.String")
+
+    checkObject(Nothing::class.java, "java.lang.Void")
+    checkObject(Nothing::class, "java.lang.Void")
+
+    checkObject(java.lang.Void::class.java, "java.lang.Void")
+    checkObject(java.lang.Void::class, "java.lang.Void")
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/javaProperties/javaObjectType.kt

@@ -0,0 +1,50 @@
+// WITH_REFLECT
+
+import kotlin.reflect.KClass
+
+fun check(clazz: Class<*>?, expected: String) {
+    assert (clazz!!.canonicalName == expected) {
+        "clazz name: ${clazz.canonicalName}"
+    }
+}
+
+fun check(kClass: KClass<*>, expected: String) {
+    check(kClass.javaObjectType, expected)
+}
+
+fun box(): String {
+    check(Boolean::class.javaObjectType, "java.lang.Boolean")
+    check(Boolean::class, "java.lang.Boolean")
+
+    check(Char::class.javaObjectType, "java.lang.Character")
+    check(Char::class, "java.lang.Character")
+
+    check(Byte::class.javaObjectType, "java.lang.Byte")
+    check(Byte::class, "java.lang.Byte")
+
+    check(Short::class.javaObjectType, "java.lang.Short")
+    check(Short::class, "java.lang.Short")
+
+    check(Int::class.javaObjectType, "java.lang.Integer")
+    check(Int::class, "java.lang.Integer")
+
+    check(Float::class.javaObjectType, "java.lang.Float")
+    check(Float::class, "java.lang.Float")
+
+    check(Long::class.javaObjectType, "java.lang.Long")
+    check(Long::class, "java.lang.Long")
+
+    check(Double::class.javaObjectType, "java.lang.Double")
+    check(Double::class, "java.lang.Double")
+
+    check(String::class.javaObjectType, "java.lang.String")
+    check(String::class, "java.lang.String")
+
+    check(Nothing::class.javaObjectType, "java.lang.Void")
+    check(Nothing::class, "java.lang.Void")
+
+    check(java.lang.Void::class.javaObjectType, "java.lang.Void")
+    check(java.lang.Void::class, "java.lang.Void")
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/javaProperties/javaObjectTypeReified.kt

@@ -0,0 +1,26 @@
+// WITH_REFLECT
+
+import kotlin.reflect.KClass
+
+inline fun <reified T : Any> check(expected: String) {
+    val clazz = T::class.javaObjectType!!
+    assert (clazz.canonicalName == "java.lang.${expected.capitalize()}") {
+        "clazz name: ${clazz.canonicalName}"
+    }
+}
+
+fun box(): String {
+    check<Boolean>("boolean")
+    check<Char>("character")
+    check<Byte>("byte")
+    check<Short>("short")
+    check<Int>("integer")
+    check<Float>("float")
+    check<Long>("long")
+    check<Double>("double")
+
+    check<String>("String")
+    check<java.lang.Void>("Void")
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/javaProperties/javaPrimitiveType.kt

@@ -0,0 +1,60 @@
+// WITH_REFLECT
+
+import kotlin.reflect.KClass
+
+fun check(clazz: Class<*>?, expected: String) {
+    assert (clazz!!.canonicalName == expected) {
+        "clazz name: ${clazz.canonicalName}"
+    }
+}
+
+fun check(kClass: KClass<*>, expected: String) {
+    check(kClass.javaPrimitiveType, expected)
+}
+
+fun checkNull(clazz: Class<*>?) {
+    assert (clazz == null) {
+        "clazz should be null: ${clazz!!.canonicalName}"
+    }
+}
+
+fun checkNull(kClass: KClass<*>) {
+    checkNull(kClass.javaPrimitiveType)
+}
+
+fun box(): String {
+    check(Boolean::class.javaPrimitiveType, "boolean")
+    check(Boolean::class, "boolean")
+
+    check(Char::class.javaPrimitiveType, "char")
+    check(Char::class, "char")
+
+    check(Byte::class.javaPrimitiveType, "byte")
+    check(Byte::class, "byte")
+
+    check(Short::class.javaPrimitiveType, "short")
+    check(Short::class, "short")
+
+    check(Int::class.javaPrimitiveType, "int")
+    check(Int::class, "int")
+
+    check(Float::class.javaPrimitiveType, "float")
+    check(Float::class, "float")
+
+    check(Long::class.javaPrimitiveType, "long")
+    check(Long::class, "long")
+
+    check(Double::class.javaPrimitiveType, "double")
+    check(Double::class, "double")
+
+    checkNull(String::class.javaPrimitiveType)
+    checkNull(String::class)
+
+    checkNull(Nothing::class.javaPrimitiveType)
+    checkNull(Nothing::class)
+
+    checkNull(java.lang.Void::class.javaPrimitiveType)
+    checkNull(java.lang.Void::class)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/javaProperties/javaPrimitiveTypeReified.kt

@@ -0,0 +1,33 @@
+// WITH_REFLECT
+
+import kotlin.reflect.KClass
+
+inline fun <reified T : Any> check(expected: String) {
+    val clazz = T::class.javaPrimitiveType!!
+    assert (clazz.canonicalName == expected) {
+        "clazz name: ${clazz.canonicalName}"
+    }
+}
+
+inline fun <reified T : Any> checkNull() {
+    val clazz = T::class.javaPrimitiveType
+    assert (clazz == null) {
+        "clazz should be null: ${clazz!!.canonicalName}"
+    }
+}
+
+fun box(): String {
+    check<Boolean>("boolean")
+    check<Char>("char")
+    check<Byte>("byte")
+    check<Short>("short")
+    check<Int>("int")
+    check<Float>("float")
+    check<Long>("long")
+    check<Double>("double")
+
+    checkNull<String>()
+    checkNull<java.lang.Void>()
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/javaProperties/javaReified.kt

@@ -0,0 +1,26 @@
+// WITH_REFLECT
+
+import kotlin.reflect.KClass
+
+inline fun <reified T : Any> check(expected: String) {
+    val clazz = T::class.java!!
+    assert (clazz.canonicalName == "java.lang.${expected.capitalize()}") {
+        "clazz name: ${clazz.canonicalName}"
+    }
+}
+
+fun box(): String {
+    check<Boolean>("boolean")
+    check<Char>("character")
+    check<Byte>("byte")
+    check<Short>("short")
+    check<Int>("integer")
+    check<Float>("float")
+    check<Long>("long")
+    check<Double>("double")
+
+    check<String>("String")
+    check<java.lang.Void>("Void")
+
+    return "OK"
+}