removing static type assertions work in progress
This commit is contained in:
@@ -16,6 +16,8 @@
|
||||
|
||||
package kotlin.js
|
||||
|
||||
inline fun Any?.asDynamic(): dynamic = this
|
||||
|
||||
// TODO add the support ES6 iterators
|
||||
public fun dynamic.iterator(): Iterator<dynamic> {
|
||||
val r = this
|
||||
@@ -24,9 +26,9 @@ public fun dynamic.iterator(): Iterator<dynamic> {
|
||||
this["iterator"] != null ->
|
||||
this["iterator"]()
|
||||
js("Array.isArray(r)") ->
|
||||
(this: Array<*>).iterator()
|
||||
(this as Array<*>).iterator()
|
||||
|
||||
else ->
|
||||
(r: Iterable<*>).iterator()
|
||||
(r as Iterable<*>).iterator()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -15,7 +15,7 @@ import java.util.Collections // TODO: it's temporary while we have java.util.Col
|
||||
*/
|
||||
public fun <T> Array<out T>.asList(): List<T> {
|
||||
val al = ArrayList<T>()
|
||||
(al: dynamic).array = this // black dynamic magic
|
||||
al.asDynamic().array = this // black dynamic magic
|
||||
return al
|
||||
}
|
||||
|
||||
@@ -80,7 +80,7 @@ public inline fun ShortArray.asList(): List<Short> {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun <T> Array<out T>.copyOf(): Array<T> {
|
||||
return (this: dynamic).slice(0)
|
||||
return this.asDynamic().slice(0)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -88,7 +88,7 @@ public inline fun <T> Array<out T>.copyOf(): Array<T> {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun BooleanArray.copyOf(): BooleanArray {
|
||||
return (this: dynamic).slice(0)
|
||||
return this.asDynamic().slice(0)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -96,7 +96,7 @@ public inline fun BooleanArray.copyOf(): BooleanArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun ByteArray.copyOf(): ByteArray {
|
||||
return (this: dynamic).slice(0)
|
||||
return this.asDynamic().slice(0)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -104,7 +104,7 @@ public inline fun ByteArray.copyOf(): ByteArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun CharArray.copyOf(): CharArray {
|
||||
return (this: dynamic).slice(0)
|
||||
return this.asDynamic().slice(0)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -112,7 +112,7 @@ public inline fun CharArray.copyOf(): CharArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun DoubleArray.copyOf(): DoubleArray {
|
||||
return (this: dynamic).slice(0)
|
||||
return this.asDynamic().slice(0)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -120,7 +120,7 @@ public inline fun DoubleArray.copyOf(): DoubleArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun FloatArray.copyOf(): FloatArray {
|
||||
return (this: dynamic).slice(0)
|
||||
return this.asDynamic().slice(0)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -128,7 +128,7 @@ public inline fun FloatArray.copyOf(): FloatArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun IntArray.copyOf(): IntArray {
|
||||
return (this: dynamic).slice(0)
|
||||
return this.asDynamic().slice(0)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -136,7 +136,7 @@ public inline fun IntArray.copyOf(): IntArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun LongArray.copyOf(): LongArray {
|
||||
return (this: dynamic).slice(0)
|
||||
return this.asDynamic().slice(0)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -144,7 +144,7 @@ public inline fun LongArray.copyOf(): LongArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun ShortArray.copyOf(): ShortArray {
|
||||
return (this: dynamic).slice(0)
|
||||
return this.asDynamic().slice(0)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -215,7 +215,7 @@ public fun <T> Array<out T>.copyOf(newSize: Int): Array<T?> {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun <T> Array<out T>.copyOfRange(fromIndex: Int, toIndex: Int): Array<T> {
|
||||
return (this: dynamic).slice(fromIndex, toIndex)
|
||||
return this.asDynamic().slice(fromIndex, toIndex)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -223,7 +223,7 @@ public inline fun <T> Array<out T>.copyOfRange(fromIndex: Int, toIndex: Int): Ar
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun BooleanArray.copyOfRange(fromIndex: Int, toIndex: Int): BooleanArray {
|
||||
return (this: dynamic).slice(fromIndex, toIndex)
|
||||
return this.asDynamic().slice(fromIndex, toIndex)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -231,7 +231,7 @@ public inline fun BooleanArray.copyOfRange(fromIndex: Int, toIndex: Int): Boolea
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun ByteArray.copyOfRange(fromIndex: Int, toIndex: Int): ByteArray {
|
||||
return (this: dynamic).slice(fromIndex, toIndex)
|
||||
return this.asDynamic().slice(fromIndex, toIndex)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -239,7 +239,7 @@ public inline fun ByteArray.copyOfRange(fromIndex: Int, toIndex: Int): ByteArray
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun CharArray.copyOfRange(fromIndex: Int, toIndex: Int): CharArray {
|
||||
return (this: dynamic).slice(fromIndex, toIndex)
|
||||
return this.asDynamic().slice(fromIndex, toIndex)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -247,7 +247,7 @@ public inline fun CharArray.copyOfRange(fromIndex: Int, toIndex: Int): CharArray
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun DoubleArray.copyOfRange(fromIndex: Int, toIndex: Int): DoubleArray {
|
||||
return (this: dynamic).slice(fromIndex, toIndex)
|
||||
return this.asDynamic().slice(fromIndex, toIndex)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -255,7 +255,7 @@ public inline fun DoubleArray.copyOfRange(fromIndex: Int, toIndex: Int): DoubleA
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun FloatArray.copyOfRange(fromIndex: Int, toIndex: Int): FloatArray {
|
||||
return (this: dynamic).slice(fromIndex, toIndex)
|
||||
return this.asDynamic().slice(fromIndex, toIndex)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -263,7 +263,7 @@ public inline fun FloatArray.copyOfRange(fromIndex: Int, toIndex: Int): FloatArr
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun IntArray.copyOfRange(fromIndex: Int, toIndex: Int): IntArray {
|
||||
return (this: dynamic).slice(fromIndex, toIndex)
|
||||
return this.asDynamic().slice(fromIndex, toIndex)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -271,7 +271,7 @@ public inline fun IntArray.copyOfRange(fromIndex: Int, toIndex: Int): IntArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun LongArray.copyOfRange(fromIndex: Int, toIndex: Int): LongArray {
|
||||
return (this: dynamic).slice(fromIndex, toIndex)
|
||||
return this.asDynamic().slice(fromIndex, toIndex)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -279,7 +279,7 @@ public inline fun LongArray.copyOfRange(fromIndex: Int, toIndex: Int): LongArray
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun ShortArray.copyOfRange(fromIndex: Int, toIndex: Int): ShortArray {
|
||||
return (this: dynamic).slice(fromIndex, toIndex)
|
||||
return this.asDynamic().slice(fromIndex, toIndex)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -287,7 +287,7 @@ public inline fun ShortArray.copyOfRange(fromIndex: Int, toIndex: Int): ShortArr
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun <T> Array<out T>.plus(array: Array<out T>): Array<T> {
|
||||
return (this: dynamic).concat(array)
|
||||
return this.asDynamic().concat(array)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -295,7 +295,7 @@ public inline fun <T> Array<out T>.plus(array: Array<out T>): Array<T> {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun BooleanArray.plus(array: BooleanArray): BooleanArray {
|
||||
return (this: dynamic).concat(array)
|
||||
return this.asDynamic().concat(array)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -303,7 +303,7 @@ public inline fun BooleanArray.plus(array: BooleanArray): BooleanArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun ByteArray.plus(array: ByteArray): ByteArray {
|
||||
return (this: dynamic).concat(array)
|
||||
return this.asDynamic().concat(array)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -311,7 +311,7 @@ public inline fun ByteArray.plus(array: ByteArray): ByteArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun CharArray.plus(array: CharArray): CharArray {
|
||||
return (this: dynamic).concat(array)
|
||||
return this.asDynamic().concat(array)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -319,7 +319,7 @@ public inline fun CharArray.plus(array: CharArray): CharArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun DoubleArray.plus(array: DoubleArray): DoubleArray {
|
||||
return (this: dynamic).concat(array)
|
||||
return this.asDynamic().concat(array)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -327,7 +327,7 @@ public inline fun DoubleArray.plus(array: DoubleArray): DoubleArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun FloatArray.plus(array: FloatArray): FloatArray {
|
||||
return (this: dynamic).concat(array)
|
||||
return this.asDynamic().concat(array)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -335,7 +335,7 @@ public inline fun FloatArray.plus(array: FloatArray): FloatArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun IntArray.plus(array: IntArray): IntArray {
|
||||
return (this: dynamic).concat(array)
|
||||
return this.asDynamic().concat(array)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -343,7 +343,7 @@ public inline fun IntArray.plus(array: IntArray): IntArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun LongArray.plus(array: LongArray): LongArray {
|
||||
return (this: dynamic).concat(array)
|
||||
return this.asDynamic().concat(array)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -351,7 +351,7 @@ public inline fun LongArray.plus(array: LongArray): LongArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun ShortArray.plus(array: ShortArray): ShortArray {
|
||||
return (this: dynamic).concat(array)
|
||||
return this.asDynamic().concat(array)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -422,7 +422,7 @@ public fun ShortArray.plus(collection: Collection<Short>): ShortArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun <T> Array<out T>.plus(element: T): Array<T> {
|
||||
return (this: dynamic).concat(arrayOf(element))
|
||||
return this.asDynamic().concat(arrayOf(element))
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -430,7 +430,7 @@ public inline fun <T> Array<out T>.plus(element: T): Array<T> {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun BooleanArray.plus(element: Boolean): BooleanArray {
|
||||
return (this: dynamic).concat(arrayOf(element))
|
||||
return this.asDynamic().concat(arrayOf(element))
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -438,7 +438,7 @@ public inline fun BooleanArray.plus(element: Boolean): BooleanArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun ByteArray.plus(element: Byte): ByteArray {
|
||||
return (this: dynamic).concat(arrayOf(element))
|
||||
return this.asDynamic().concat(arrayOf(element))
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -446,7 +446,7 @@ public inline fun ByteArray.plus(element: Byte): ByteArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun CharArray.plus(element: Char): CharArray {
|
||||
return (this: dynamic).concat(arrayOf(element))
|
||||
return this.asDynamic().concat(arrayOf(element))
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -454,7 +454,7 @@ public inline fun CharArray.plus(element: Char): CharArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun DoubleArray.plus(element: Double): DoubleArray {
|
||||
return (this: dynamic).concat(arrayOf(element))
|
||||
return this.asDynamic().concat(arrayOf(element))
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -462,7 +462,7 @@ public inline fun DoubleArray.plus(element: Double): DoubleArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun FloatArray.plus(element: Float): FloatArray {
|
||||
return (this: dynamic).concat(arrayOf(element))
|
||||
return this.asDynamic().concat(arrayOf(element))
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -470,7 +470,7 @@ public inline fun FloatArray.plus(element: Float): FloatArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun IntArray.plus(element: Int): IntArray {
|
||||
return (this: dynamic).concat(arrayOf(element))
|
||||
return this.asDynamic().concat(arrayOf(element))
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -478,7 +478,7 @@ public inline fun IntArray.plus(element: Int): IntArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun LongArray.plus(element: Long): LongArray {
|
||||
return (this: dynamic).concat(arrayOf(element))
|
||||
return this.asDynamic().concat(arrayOf(element))
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -486,7 +486,7 @@ public inline fun LongArray.plus(element: Long): LongArray {
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
public inline fun ShortArray.plus(element: Short): ShortArray {
|
||||
return (this: dynamic).concat(arrayOf(element))
|
||||
return this.asDynamic().concat(arrayOf(element))
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
+2
-2
@@ -4,8 +4,8 @@ fun box(): String {
|
||||
|
||||
assertEquals('A', 'A'.toChar(), "toChar")
|
||||
assertEquals(65, 'A'.toInt(), "toInt")
|
||||
assertEquals(65: Short, 'A'.toShort(), "toShort")
|
||||
assertEquals(65: Byte, 'A'.toByte(), "toByte")
|
||||
assertEquals(65.toShort(), 'A'.toShort(), "toShort")
|
||||
assertEquals(65.toByte(), 'A'.toByte(), "toByte")
|
||||
assertEquals(65.0, 'A'.toDouble(), "toDouble")
|
||||
assertEquals(65.0f, 'A'.toFloat(), "toFloat")
|
||||
assertEquals(65L, 'A'.toLong(), "toLong")
|
||||
|
||||
+1
-1
@@ -6,7 +6,7 @@ fun box(): String {
|
||||
|
||||
assertEquals(true, 'A' == 'A')
|
||||
assertEquals(false, 'A'== 'B')
|
||||
assertEquals(false, ('A': Any) == (65: Any))
|
||||
assertEquals(false, ('A' as Any) == (65 as Any))
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+7
-7
@@ -4,15 +4,15 @@ class A
|
||||
|
||||
fun box(): String {
|
||||
|
||||
assertEquals(false, ('A': Any) is Int)
|
||||
assertEquals(false, ('A': Any) is Short)
|
||||
assertEquals(false, ('A': Any) is Byte)
|
||||
assertEquals(false, ('A': Any) is Float)
|
||||
assertEquals(false, ('A': Any) is Double)
|
||||
assertEquals(false, ('A': Any) is Number)
|
||||
assertEquals(false, ('A' as Any) is Int)
|
||||
assertEquals(false, ('A' as Any) is Short)
|
||||
assertEquals(false, ('A' as Any) is Byte)
|
||||
assertEquals(false, ('A' as Any) is Float)
|
||||
assertEquals(false, ('A' as Any) is Double)
|
||||
assertEquals(false, ('A' as Any) is Number)
|
||||
|
||||
assertEquals(true, 'A' is Char)
|
||||
assertEquals(true, ('A': Any) is Char)
|
||||
assertEquals(true, ('A' as Any) is Char)
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+2
-1
@@ -37,7 +37,8 @@ fun box(): String {
|
||||
assertNotEquals(ho1, ho2)
|
||||
assertNotEquals(ho1, ho3)
|
||||
|
||||
assertTrue((d1 : Any) != "")
|
||||
val d1any: Any = d1
|
||||
assertTrue(d1any != "")
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+2
-2
@@ -3,7 +3,7 @@ package foo
|
||||
fun testFor(expected: Int, d: dynamic, case: String) {
|
||||
var actual = 0
|
||||
for (v in d) {
|
||||
actual += v: Int
|
||||
actual += v as Int
|
||||
}
|
||||
assertEquals(expected, actual, "testFor on $case")
|
||||
}
|
||||
@@ -12,7 +12,7 @@ fun testIterator(expected: Int, d: dynamic, case: String) {
|
||||
var actual = 0
|
||||
val it = d.iterator()
|
||||
while (it.hasNext()) {
|
||||
actual += it.next(): Int
|
||||
actual += it.next() as Int
|
||||
}
|
||||
assertEquals(expected, actual, "testIterator on $case")
|
||||
}
|
||||
|
||||
+1
-1
@@ -13,7 +13,7 @@ enum class JsEnum {
|
||||
fun box(): String {
|
||||
assertEquals(1, JsEnum.Foo)
|
||||
assertEquals("BAR", JsEnum.Bar)
|
||||
assertEquals("OK", (JsEnum.Baz: dynamic).ok)
|
||||
assertEquals("OK", JsEnum.Baz.asDynamic().ok)
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+4
-3
@@ -25,9 +25,10 @@ fun testMethodAsCompareTo() {
|
||||
assertEquals(true, x > y, "meth: x > y")
|
||||
assertEquals(1, x compareTo y, "meth: x compareTo y")
|
||||
|
||||
assertEquals(false, (x: Comparable<A>) < y, "meth: (x: Comparable<A>) < y")
|
||||
assertEquals(true, (x: Comparable<A>) > y, "meth: (x: Comparable<A>) > y")
|
||||
assertEquals(1, (x: Comparable<A>) compareTo y, "meth: (x: Comparable<A>) compareTo y")
|
||||
val comparable: Comparable<A> = x
|
||||
assertEquals(false, comparable < y, "meth: (x: Comparable<A>) < y")
|
||||
assertEquals(true, comparable > y, "meth: (x: Comparable<A>) > y")
|
||||
assertEquals(1, comparable compareTo y, "meth: (x: Comparable<A>) compareTo y")
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
|
||||
+1
-1
@@ -7,7 +7,7 @@ fun box(): Boolean {
|
||||
if (!(a equals 2.0)) return false
|
||||
val c = "a"
|
||||
if (!("a" equals c)) return false
|
||||
if (!((null : Any?)?.equals(null) ?: true)) return false
|
||||
if (!((null as Any?)?.equals(null) ?: true)) return false
|
||||
val d = 5.6
|
||||
if (!(d.toShort() equals 5.toShort())) return false
|
||||
if (!(d.toByte() equals 5.toByte())) return false
|
||||
|
||||
@@ -37,7 +37,7 @@ private class PrivateClass {
|
||||
val CALEE_NAME = RegExp("""((?:equals|hashCode|toString)[^(]*)""")
|
||||
|
||||
fun <T> Function0<T>.extractNames(): Array<String> {
|
||||
val names = CALEE_NAME.exec(this.toString(): String)
|
||||
val names = CALEE_NAME.exec(this.toString())
|
||||
|
||||
if (names == null || names.size() != 2) {
|
||||
throw Exception("Cannot extract function name, $names for actual = \"$this\"")
|
||||
|
||||
@@ -8,7 +8,7 @@ fun box(): String {
|
||||
val kot: CharSequence = kotlin.subSequence(0, 3)
|
||||
if (kot.toString() != "kot") return "Fail 1: $kot"
|
||||
|
||||
val tlin = (kotlin : CharSequence).subSequence(2, 6)
|
||||
val tlin = (kotlin as CharSequence).subSequence(2, 6)
|
||||
if (tlin.toString() != "tlin") return "Fail 2: $tlin"
|
||||
|
||||
return "OK"
|
||||
|
||||
@@ -5,7 +5,7 @@ class A() {
|
||||
}
|
||||
|
||||
fun box(): Boolean {
|
||||
var a = null : A?
|
||||
var a: A? = null
|
||||
when(a) {
|
||||
is A? -> return true
|
||||
else -> return false
|
||||
|
||||
@@ -10,8 +10,8 @@ class B() {
|
||||
|
||||
fun box(): Boolean {
|
||||
var c: Int = 0
|
||||
var a = A() : Any?
|
||||
var b = null : Any?
|
||||
var a: Any? = A()
|
||||
var b: Any? = null
|
||||
when(a) {
|
||||
null -> c = 10;
|
||||
is B -> c = 10000
|
||||
|
||||
+4
-2
@@ -21,9 +21,11 @@ public class MyNode : Node<ClassAB>() {
|
||||
fun box(): String {
|
||||
|
||||
var node = MyNode()
|
||||
val traitA: TraitA = ClassAB()
|
||||
val traitB: TraitB = ClassAB()
|
||||
assertEquals("MyNode.bar(ClassAB)", node.bar(ClassAB()))
|
||||
assertEquals("MyNode.bar(TraitA)", node.bar(ClassAB(): TraitA))
|
||||
assertEquals("MyNode.bar(TraitB)", node.bar(ClassAB(): TraitB))
|
||||
assertEquals("MyNode.bar(TraitA)", node.bar(traitA))
|
||||
assertEquals("MyNode.bar(TraitB)", node.bar(traitB))
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -14,8 +14,8 @@ fun box(): String {
|
||||
assertEquals(65, 321.toByte())
|
||||
assertEquals(-56, 200.toByte())
|
||||
|
||||
assertEquals(65, (321: Short).toByte())
|
||||
assertEquals(-56, (200: Short).toByte())
|
||||
assertEquals(65, (321.toShort()).toByte())
|
||||
assertEquals(-56, (200.toShort()).toByte())
|
||||
|
||||
assertEquals(-1, 65535.0.toShort())
|
||||
assertEquals(-1, 65535.0f.toShort())
|
||||
|
||||
@@ -5,8 +5,8 @@ fun testForNumber(numberX: Number) {
|
||||
assertEquals(true, 65.0f == numberX.toFloat())
|
||||
assertEquals(true, 65L == numberX.toLong())
|
||||
assertEquals(true, 65 == numberX.toInt())
|
||||
assertEquals(true, (65: Short) == numberX.toShort())
|
||||
assertEquals(true, (65: Byte) == numberX.toByte())
|
||||
assertEquals(true, 65.toShort() == numberX.toShort())
|
||||
assertEquals(true, 65.toByte() == numberX.toByte())
|
||||
assertEquals(true, 'A' == numberX.toChar())
|
||||
}
|
||||
|
||||
@@ -16,16 +16,16 @@ fun box(): String {
|
||||
testForNumber(65.0f)
|
||||
testForNumber(65L)
|
||||
testForNumber(65)
|
||||
testForNumber(65: Short)
|
||||
testForNumber(65: Byte)
|
||||
testForNumber(65.toShort())
|
||||
testForNumber(65.toByte())
|
||||
|
||||
var doubleX: Double = 65.0
|
||||
assertEquals(true, 65.0 == doubleX.toDouble())
|
||||
assertEquals(true, 65.0f == doubleX.toFloat())
|
||||
assertEquals(true, 65L == doubleX.toLong())
|
||||
assertEquals(true, 65 == doubleX.toInt())
|
||||
assertEquals(true, (65: Short) == doubleX.toShort())
|
||||
assertEquals(true, (65: Byte) == doubleX.toByte())
|
||||
assertEquals(true, 65.toShort() == doubleX.toShort())
|
||||
assertEquals(true, 65.toByte() == doubleX.toByte())
|
||||
assertEquals(true, 'A' == doubleX.toChar())
|
||||
|
||||
var floatX: Float = 65.0f
|
||||
@@ -33,8 +33,8 @@ fun box(): String {
|
||||
assertEquals(true, 65.0f == floatX.toFloat())
|
||||
assertEquals(true, 65L == floatX.toLong())
|
||||
assertEquals(true, 65 == floatX.toInt())
|
||||
assertEquals(true, (65: Short) == floatX.toShort())
|
||||
assertEquals(true, (65: Byte) == floatX.toByte())
|
||||
assertEquals(true, 65.toShort() == floatX.toShort())
|
||||
assertEquals(true, 65.toByte() == floatX.toByte())
|
||||
assertEquals(true, 'A' == floatX.toChar())
|
||||
|
||||
val longX: Long = 65L
|
||||
@@ -42,8 +42,8 @@ fun box(): String {
|
||||
assertEquals(true, 65.0f == longX.toFloat())
|
||||
assertEquals(true, 65L == longX.toLong())
|
||||
assertEquals(true, 65 == longX.toInt())
|
||||
assertEquals(true, (65: Short) == longX.toShort())
|
||||
assertEquals(true, (65: Byte) == longX.toByte())
|
||||
assertEquals(true, 65.toShort() == longX.toShort())
|
||||
assertEquals(true, 65.toByte() == longX.toByte())
|
||||
assertEquals(true, 'A' == longX.toChar())
|
||||
|
||||
val intX: Int = 65
|
||||
@@ -51,26 +51,26 @@ fun box(): String {
|
||||
assertEquals(true, 65.0f == intX.toFloat())
|
||||
assertEquals(true, 65L == intX.toLong())
|
||||
assertEquals(true, 65 == intX.toInt())
|
||||
assertEquals(true, (65: Short) == intX.toShort())
|
||||
assertEquals(true, (65: Byte) == intX.toByte())
|
||||
assertEquals(true, 65.toShort() == intX.toShort())
|
||||
assertEquals(true, 65.toByte() == intX.toByte())
|
||||
assertEquals(true, 'A' == intX.toChar())
|
||||
|
||||
val shortX: Short = 65: Short
|
||||
val shortX: Short = 65.toShort()
|
||||
assertEquals(true, 65.0 == shortX.toDouble())
|
||||
assertEquals(true, 65.0f == shortX.toFloat())
|
||||
assertEquals(true, 65L == shortX.toLong())
|
||||
assertEquals(true, 65 == shortX.toInt())
|
||||
assertEquals(true, (65: Short) == shortX.toShort())
|
||||
assertEquals(true, (65: Byte) == shortX.toByte())
|
||||
assertEquals(true, 65.toShort() == shortX.toShort())
|
||||
assertEquals(true, 65.toByte() == shortX.toByte())
|
||||
assertEquals(true, 'A' == shortX.toChar())
|
||||
|
||||
val byteX: Byte = 65: Byte
|
||||
val byteX: Byte = 65.toByte()
|
||||
assertEquals(true, 65.0 == byteX.toDouble())
|
||||
assertEquals(true, 65.0f == byteX.toFloat())
|
||||
assertEquals(true, 65L == byteX.toLong())
|
||||
assertEquals(true, 65 == byteX.toInt())
|
||||
assertEquals(true, (65: Short) == byteX.toShort())
|
||||
assertEquals(true, (65: Byte) == byteX.toByte())
|
||||
assertEquals(true, 65.toShort() == byteX.toShort())
|
||||
assertEquals(true, 65.toByte() == byteX.toByte())
|
||||
assertEquals(true, 'A' == byteX.toChar())
|
||||
|
||||
return "OK"
|
||||
|
||||
+4
-4
@@ -8,11 +8,11 @@ fun box(): String {
|
||||
assertEquals(0.5f, 1 / 2.0f, "Int / Float")
|
||||
assertEquals(0.5, 1 / 2.0, "Int / Double")
|
||||
|
||||
assertEquals(0.5f, (1: Short) / 2.0f, "Short / Float")
|
||||
assertEquals(0.5, (1: Short) / 2.0, "Short / Double")
|
||||
assertEquals(0.5f, 1.toShort() / 2.0f, "Short / Float")
|
||||
assertEquals(0.5, 1.toShort() / 2.0, "Short / Double")
|
||||
|
||||
assertEquals(0.5f, (1: Byte) / 2.0f, "Byte / Float")
|
||||
assertEquals(0.5, (1: Byte) / 2.0, "Byte / Double")
|
||||
assertEquals(0.5f, 1.toByte() / 2.0f, "Byte / Float")
|
||||
assertEquals(0.5, 1.toByte() / 2.0, "Byte / Double")
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -19,14 +19,14 @@ fun box(): String {
|
||||
assertEquals(30.0f, 10L + 20.0f)
|
||||
assertEquals(30L, 10L + 20L)
|
||||
assertEquals(30L, 10L + 20)
|
||||
assertEquals(30L, 10L + (20: Short))
|
||||
assertEquals(30L, 10L + (20: Byte))
|
||||
assertEquals(30L, 10L + 20.toShort())
|
||||
assertEquals(30L, 10L + 20.toByte())
|
||||
|
||||
assertEquals(30.0, 20.0 + 10L)
|
||||
assertEquals(30.0f, 20.0f + 10L)
|
||||
assertEquals(20L, 10 + 10L)
|
||||
assertEquals(20L, (10: Short) + 10L)
|
||||
assertEquals(20L, (10: Byte) + 10L)
|
||||
assertEquals(20L, 10.toShort() + 10L)
|
||||
assertEquals(20L, 10.toByte() + 10L)
|
||||
|
||||
assertEquals(20L, 30 - 10L)
|
||||
|
||||
|
||||
@@ -12,10 +12,10 @@ fun box(): String {
|
||||
assertEquals(true, 10 < 20L, "Int.compareTo(Long)")
|
||||
assertEquals(true, 10 < 7540113804746346429L, "Int.compareTo(Long)")
|
||||
|
||||
assertEquals(true, (10: Short) < 20L, "Short.compareTo(Long)")
|
||||
assertEquals(true, (10: Short) < 7540113804746346429L, "Short.compareTo(Long)")
|
||||
assertEquals(true, (10: Byte) < 20L, "Byte.compareTo(Long)")
|
||||
assertEquals(true, (10: Byte) < 7540113804746346429L, "Byte.compareTo(Long)")
|
||||
assertEquals(true, 10.toShort() < 20L, "Short.compareTo(Long)")
|
||||
assertEquals(true, 10.toShort() < 7540113804746346429L, "Short.compareTo(Long)")
|
||||
assertEquals(true, 10.toByte() < 20L, "Byte.compareTo(Long)")
|
||||
assertEquals(true, 10.toByte() < 7540113804746346429L, "Byte.compareTo(Long)")
|
||||
|
||||
assertEquals(true, 10L < 20.0, "Long.compareTo(Double)")
|
||||
assertEquals(false, 7540113804746346429L < 20.0, "Long.compareTo(Double)")
|
||||
@@ -28,13 +28,13 @@ fun box(): String {
|
||||
assertEquals(true, 7540113804746346429L > 20, "Long.compareTo(Int)")
|
||||
assertEquals(false, 7540113804746346429L < 20, "Long.compareTo(Int)")
|
||||
|
||||
assertEquals(true, 10L < (20: Short), "Long.compareTo(Short)")
|
||||
assertEquals(true, 7540113804746346429L > (20: Short), "Long.compareTo(Short)")
|
||||
assertEquals(false, 7540113804746346429L < (20: Short), "Long.compareTo(Short)")
|
||||
assertEquals(true, 10L < 20.toShort(), "Long.compareTo(Short)")
|
||||
assertEquals(true, 7540113804746346429L > 20.toShort(), "Long.compareTo(Short)")
|
||||
assertEquals(false, 7540113804746346429L < 20.toShort(), "Long.compareTo(Short)")
|
||||
|
||||
assertEquals(true, 10L < (20: Byte), "Long.compareTo(Byte)")
|
||||
assertEquals(true, 7540113804746346429L > (20: Byte), "Long.compareTo(Byte)")
|
||||
assertEquals(false, 7540113804746346429L < (20: Byte), "Long.compareTo(Byte)")
|
||||
assertEquals(true, 10L < 20.toByte(), "Long.compareTo(Byte)")
|
||||
assertEquals(true, 7540113804746346429L > 20.toByte(), "Long.compareTo(Byte)")
|
||||
assertEquals(false, 7540113804746346429L < 20.toByte(), "Long.compareTo(Byte)")
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+42
-42
@@ -10,72 +10,72 @@ fun id(s: String, value: Int): Int {
|
||||
fun box(): String {
|
||||
|
||||
assertEquals(-1, 1.compareTo(2))
|
||||
assertEquals(-1, (1: Comparable<Int>).compareTo(2))
|
||||
assertEquals(-1, (1 as Comparable<Int>).compareTo(2))
|
||||
|
||||
assertEquals(-1, 1 compareTo 2L)
|
||||
assertEquals(-1, 1 compareTo 2L)
|
||||
assertEquals(-1, 1 compareTo 7540113804746346429L)
|
||||
assertEquals(-1, 1 compareTo (2:Short))
|
||||
assertEquals(-1, 1 compareTo (2:Byte))
|
||||
assertEquals(-1, 1 compareTo 2.toShort())
|
||||
assertEquals(-1, 1 compareTo 2.toByte())
|
||||
assertEquals(-1, 1 compareTo 2.0)
|
||||
assertEquals(-1, 1 compareTo 2.0f)
|
||||
|
||||
assertEquals(1, 10 compareTo 2L)
|
||||
assertEquals(1, 10 compareTo 2)
|
||||
assertEquals(1, 10 compareTo (2:Short))
|
||||
assertEquals(1, 10 compareTo (2:Byte))
|
||||
assertEquals(1, 10 compareTo 2.toShort())
|
||||
assertEquals(1, 10 compareTo 2.toByte())
|
||||
assertEquals(1, 10 compareTo 2.0)
|
||||
assertEquals(1, 10 compareTo 2.0f)
|
||||
|
||||
assertEquals(0, 2 compareTo 2L)
|
||||
assertEquals(0, 2 compareTo 2)
|
||||
assertEquals(0, 2 compareTo (2:Short))
|
||||
assertEquals(0, 2 compareTo (2:Byte))
|
||||
assertEquals(0, 2 compareTo 2.toShort())
|
||||
assertEquals(0, 2 compareTo 2.toByte())
|
||||
assertEquals(0, 2 compareTo 2.0)
|
||||
assertEquals(0, 2 compareTo 2.0f)
|
||||
|
||||
assertEquals(-1, (1: Short) compareTo 2L)
|
||||
assertEquals(-1, (1: Short) compareTo 7540113804746346429L)
|
||||
assertEquals(-1, (1: Short) compareTo 2)
|
||||
assertEquals(-1, (1: Short) compareTo (2:Short))
|
||||
assertEquals(-1, ((1: Short): Comparable<Short>) compareTo (2:Short))
|
||||
assertEquals(-1, (1: Short) compareTo (2:Byte))
|
||||
assertEquals(-1, (1: Short) compareTo 2.0)
|
||||
assertEquals(-1, (1: Short) compareTo 2.0f)
|
||||
assertEquals(-1, 1.toShort() compareTo 2L)
|
||||
assertEquals(-1, 1.toShort() compareTo 7540113804746346429L)
|
||||
assertEquals(-1, 1.toShort() compareTo 2)
|
||||
assertEquals(-1, 1.toShort() compareTo 2.toShort())
|
||||
assertEquals(-1, (1.toShort() as Comparable<Short>) compareTo 2.toShort())
|
||||
assertEquals(-1, 1.toShort() compareTo 2.toByte())
|
||||
assertEquals(-1, 1.toShort() compareTo 2.0)
|
||||
assertEquals(-1, 1.toShort() compareTo 2.0f)
|
||||
|
||||
assertEquals(1, (10: Byte) compareTo 2L)
|
||||
assertEquals(-1, (10: Byte) compareTo 7540113804746346429L)
|
||||
assertEquals(1, (10: Byte) compareTo 2)
|
||||
assertEquals(1, (10: Byte) compareTo (2:Short))
|
||||
assertEquals(1, (10: Byte) compareTo (2:Byte))
|
||||
assertEquals(1, ((10: Byte): Comparable<Byte>) compareTo (2:Byte))
|
||||
assertEquals(1, (10: Byte) compareTo 2.0)
|
||||
assertEquals(1, (10: Byte) compareTo 2.0f)
|
||||
assertEquals(1, 10.toByte() compareTo 2L)
|
||||
assertEquals(-1, 10.toByte() compareTo 7540113804746346429L)
|
||||
assertEquals(1, 10.toByte() compareTo 2)
|
||||
assertEquals(1, 10.toByte() compareTo 2.toShort())
|
||||
assertEquals(1, 10.toByte() compareTo 2.toByte())
|
||||
assertEquals(1, (10.toByte() as Comparable<Byte>) compareTo 2.toByte())
|
||||
assertEquals(1, 10.toByte() compareTo 2.0)
|
||||
assertEquals(1, 10.toByte() compareTo 2.0f)
|
||||
|
||||
assertEquals(0, 2.0 compareTo 2L)
|
||||
assertEquals(-1, 2.0 compareTo 7540113804746346429L)
|
||||
assertEquals(0, 2.0 compareTo 2)
|
||||
assertEquals(0, 2.0 compareTo (2:Short))
|
||||
assertEquals(0, 2.0 compareTo (2:Byte))
|
||||
assertEquals(0, 2.0 compareTo 2.toShort())
|
||||
assertEquals(0, 2.0 compareTo 2.toByte())
|
||||
assertEquals(0, 2.0 compareTo 2.0)
|
||||
assertEquals(0, (2.0: Comparable<Double>) compareTo 2.0)
|
||||
assertEquals(0, (2.0 as Comparable<Double>) compareTo 2.0)
|
||||
assertEquals(0, 2.0 compareTo 2.0f)
|
||||
|
||||
assertEquals(1, 3.0f compareTo 2L)
|
||||
assertEquals(-1, 3.0f compareTo 7540113804746346429L)
|
||||
assertEquals(1, 3.0f compareTo 2)
|
||||
assertEquals(1, 3.0f compareTo (2:Short))
|
||||
assertEquals(1, 3.0f compareTo (2:Byte))
|
||||
assertEquals(1, 3.0f compareTo 2.toShort())
|
||||
assertEquals(1, 3.0f compareTo 2.toByte())
|
||||
assertEquals(1, 3.0f compareTo 2.0)
|
||||
assertEquals(1, 3.0f compareTo 2.0f)
|
||||
assertEquals(1, (3.0f: Comparable<Float>) compareTo 2.0f)
|
||||
assertEquals(1, (3.0f as Comparable<Float>) compareTo 2.0f)
|
||||
|
||||
assertEquals(1, 10L compareTo 2L)
|
||||
assertEquals(-1, 10L compareTo 7540113804746346429L)
|
||||
assertEquals(1, (10L: Comparable<Long>) compareTo 2L)
|
||||
assertEquals(1, (10L as Comparable<Long>) compareTo 2L)
|
||||
assertEquals(1, 10L compareTo 2)
|
||||
assertEquals(1, 10L compareTo (2:Short))
|
||||
assertEquals(1, 10L compareTo (2:Byte))
|
||||
assertEquals(1, 10L compareTo 2.toShort())
|
||||
assertEquals(1, 10L compareTo 2.toByte())
|
||||
assertEquals(1, 10L compareTo 2.0)
|
||||
assertEquals(1, 10L compareTo 2.0f)
|
||||
|
||||
@@ -83,8 +83,8 @@ fun box(): String {
|
||||
|
||||
assertEquals(-1, 1L compareTo 2L)
|
||||
assertEquals(-1, 1L compareTo 2)
|
||||
assertEquals(-1, 1L compareTo (2:Short))
|
||||
assertEquals(-1, 1L compareTo (2:Byte))
|
||||
assertEquals(-1, 1L compareTo 2.toShort())
|
||||
assertEquals(-1, 1L compareTo 2.toByte())
|
||||
assertEquals(-1, 1L compareTo 2.0)
|
||||
assertEquals(-1, 1L compareTo 2.0f)
|
||||
|
||||
@@ -92,29 +92,29 @@ fun box(): String {
|
||||
assertEquals(1, 7540113804746346429L compareTo 2L)
|
||||
assertEquals(0, 2L compareTo 2L)
|
||||
assertEquals(0, 2L compareTo 2)
|
||||
assertEquals(0, 2L compareTo (2:Short))
|
||||
assertEquals(0, 2L compareTo (2:Byte))
|
||||
assertEquals(0, 2L compareTo 2.toShort())
|
||||
assertEquals(0, 2L compareTo 2.toByte())
|
||||
assertEquals(0, 2L compareTo 2.0)
|
||||
assertEquals(0, 2L compareTo 2.0f)
|
||||
|
||||
assertEquals(1, 10L compareTo 2L)
|
||||
assertEquals(1, 10L compareTo 2)
|
||||
assertEquals(1, 10L compareTo (2:Short))
|
||||
assertEquals(1, 10L compareTo (2:Byte))
|
||||
assertEquals(1, 10L compareTo 2.toShort())
|
||||
assertEquals(1, 10L compareTo 2.toByte())
|
||||
assertEquals(1, 10L compareTo 2.0)
|
||||
assertEquals(1, 10L compareTo 2.0f)
|
||||
|
||||
assertEquals(-1, 1L compareTo 2L)
|
||||
assertEquals(-1, 1L compareTo 2)
|
||||
assertEquals(-1, 1L compareTo (2:Short))
|
||||
assertEquals(-1, 1L compareTo (2:Byte))
|
||||
assertEquals(-1, 1L compareTo 2.toShort())
|
||||
assertEquals(-1, 1L compareTo 2.toByte())
|
||||
assertEquals(-1, 1L compareTo 2.0)
|
||||
assertEquals(-1, 1L compareTo 2.0f)
|
||||
|
||||
assertEquals(0, 2L compareTo 2L)
|
||||
assertEquals(0, 2L compareTo 2)
|
||||
assertEquals(0, 2L compareTo (2:Short))
|
||||
assertEquals(0, 2L compareTo (2:Byte))
|
||||
assertEquals(0, 2L compareTo 2.toShort())
|
||||
assertEquals(0, 2L compareTo 2.toByte())
|
||||
assertEquals(0, 2L compareTo 2.0)
|
||||
assertEquals(0, 2L compareTo 2.0f)
|
||||
|
||||
|
||||
+2
-2
@@ -36,8 +36,8 @@ fun box(): String {
|
||||
assertEquals(false, anyX is Number, "anyX is Number")
|
||||
|
||||
testNum(100)
|
||||
testNum(100: Short)
|
||||
testNum(100: Byte)
|
||||
testNum(100.toShort())
|
||||
testNum(100.toByte())
|
||||
testNum(100.0)
|
||||
testNum(100.0f)
|
||||
|
||||
|
||||
+2
-2
@@ -4,9 +4,9 @@ fun box(): String {
|
||||
|
||||
assertEquals(true, 2..1 == 4..2, "2..1 == 4..2")
|
||||
assertEquals(true, 2L..1L == 318238945677L..2L, "2L..1L == 318238945677L..2L")
|
||||
assertEquals(false, (2..1): Any == (4L..2L): Any, "(2..1): Any == (4L..2L): Any")
|
||||
assertEquals(false, (2..1) as Any == (4L..2L) as Any, "(2..1): Any == (4L..2L): Any")
|
||||
assertEquals(true, 'B'..'A' == 'W'..'B', "'B'..'A' == 'W'..'B'")
|
||||
assertEquals(false, (2..1): Any == ('B'..'A'): Any, "(2..1): Any == ('B'..'A'): Any")
|
||||
assertEquals(false, (2..1) as Any == ('B'..'A') as Any, "(2..1): Any == ('B'..'A'): Any")
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -8,8 +8,8 @@ class stdlib_emptyListClass : List<Any> by ArrayList<Any>() {}
|
||||
fun box(): String {
|
||||
|
||||
assertTrue(stdlib_emptyListClass() is List<*>, "stdlib_emptyListClass() is List<*> #1")
|
||||
assertTrue((stdlib_emptyListClass(): Any) is List<*>, "stdlib_emptyListClass() is List<*> #2")
|
||||
assertTrue((stdlib_emptyListClass(): Any) !is ArrayList<*>, "stdlib_emptyListClass() !is ArrayList<*>")
|
||||
assertTrue((stdlib_emptyListClass() as Any) is List<*>, "stdlib_emptyListClass() is List<*> #2")
|
||||
assertTrue((stdlib_emptyListClass() as Any) !is ArrayList<*>, "stdlib_emptyListClass() !is ArrayList<*>")
|
||||
|
||||
assertTrue(stdlib_emptyListClass().isEmpty, "stdlib_emptyListClass().isEmpty")
|
||||
assertTrue(stdlib_emptyListClass().size() == 0, "stdlib_emptyListClass().size() == 0")
|
||||
|
||||
@@ -14,11 +14,11 @@ fun box(): String {
|
||||
assertEquals("number", typeof (mapWithIntKeys.keySet().iterator().next()), "mapWithIntKeys")
|
||||
|
||||
val mapWithShortKeys = HashMap<Short, Int>()
|
||||
mapWithShortKeys[1: Short] = 1
|
||||
mapWithShortKeys[1.toShort()] = 1
|
||||
assertEquals("number", typeof (mapWithShortKeys.keySet().iterator().next()), "mapWithShortKeys")
|
||||
|
||||
val mapWithByteKeys = HashMap<Byte, Int>()
|
||||
mapWithByteKeys[1: Byte] = 1
|
||||
mapWithByteKeys[1.toByte()] = 1
|
||||
assertEquals("number", typeof (mapWithByteKeys.keySet().iterator().next()), "mapWithByteKeys")
|
||||
|
||||
val mapWithDoubleKeys = HashMap<Double, Int>()
|
||||
|
||||
@@ -14,11 +14,11 @@ fun box(): String {
|
||||
assertEquals("number", typeof (intSet.iterator().next()), "intSet")
|
||||
|
||||
val shortSet = HashSet<Short>()
|
||||
shortSet.add(1: Short)
|
||||
shortSet.add(1.toShort())
|
||||
assertEquals("number", typeof (shortSet.iterator().next()), "shortSet")
|
||||
|
||||
val byteSet = HashSet<Byte>()
|
||||
byteSet.add(1: Byte)
|
||||
byteSet.add(1.toByte())
|
||||
assertEquals("number", typeof (byteSet.iterator().next()), "byteSet")
|
||||
|
||||
val doubleSet = HashSet<Double>()
|
||||
|
||||
Reference in New Issue
Block a user