[K/N] Migrate runtime/collections tests to new testing infra ^KT-61259
This commit is contained in:
Alexander Shabalin
committed by
Space Team
Space Team
parent
10a6d8fd2c
commit
b3e13fb2c2
@@ -0,0 +1,97 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
||||
*/
|
||||
|
||||
package test.collections
|
||||
|
||||
import kotlin.test.*
|
||||
import test.collections.behaviors.*
|
||||
|
||||
class AbstractMutableCollectionTest {
|
||||
private class TestCollection(private val storage: IntArray): AbstractMutableCollection<Int>() {
|
||||
private var len = 0
|
||||
|
||||
override val size: Int
|
||||
get() = len
|
||||
|
||||
override fun add(element: Int): Boolean {
|
||||
if (len >= storage.size) return false
|
||||
storage[len++] = element
|
||||
return true
|
||||
}
|
||||
|
||||
override fun iterator(): MutableIterator<Int> = object: MutableIterator<Int> {
|
||||
var nextIndex = 0
|
||||
|
||||
override fun hasNext() = nextIndex < len
|
||||
override fun next() = storage[nextIndex++]
|
||||
|
||||
override fun remove() {
|
||||
if (nextIndex == 0) throw IllegalStateException()
|
||||
for (i in nextIndex..len - 1) {
|
||||
storage[i - 1] = storage[i]
|
||||
}
|
||||
len--
|
||||
nextIndex--
|
||||
}
|
||||
}
|
||||
|
||||
override fun clear() {
|
||||
len = 0
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun addAllSuccess() {
|
||||
val collection = TestCollection(IntArray(3))
|
||||
assertTrue(collection.addAll(listOf(1, 2, 3)))
|
||||
compare(listOf(1, 2, 3), collection) {
|
||||
collectionBehavior()
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun addAllFailure() {
|
||||
val collection = TestCollection(IntArray(3))
|
||||
assertTrue(collection.addAll(listOf(1, 2, 3)))
|
||||
assertFalse(collection.addAll(listOf(4, 5)))
|
||||
compare(listOf(1, 2, 3), collection) {
|
||||
collectionBehavior()
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun removeAll() {
|
||||
val collection = TestCollection(IntArray(7))
|
||||
assertTrue(collection.addAll(listOf(1, 2, 3, 2, 4, 5, 4)))
|
||||
assertTrue(collection.removeAll(listOf(1, 2)))
|
||||
compare(listOf(3, 4, 5, 4), collection) {
|
||||
collectionBehavior()
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun retainAll() {
|
||||
val collection = TestCollection(IntArray(7))
|
||||
assertTrue(collection.addAll(listOf(1, 2, 4, 3, 5, 2, 4)))
|
||||
assertTrue(collection.retainAll(listOf(4, 5)))
|
||||
compare(listOf(4, 5, 4), collection) {
|
||||
collectionBehavior()
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun remove() {
|
||||
val collection = TestCollection(IntArray(3))
|
||||
assertTrue(collection.addAll(listOf(1, 2, 3)))
|
||||
assertTrue(collection.remove(2))
|
||||
compare(listOf(1, 3), collection) {
|
||||
collectionBehavior()
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun clear() {
|
||||
val collection = TestCollection(IntArray(3))
|
||||
assertTrue(collection.addAll(listOf(1, 2, 3)))
|
||||
collection.clear()
|
||||
compare(emptyList(), collection) {
|
||||
collectionBehavior()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,372 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
||||
*/
|
||||
|
||||
package test.collections
|
||||
|
||||
import kotlin.random.Random
|
||||
import kotlin.test.*
|
||||
|
||||
// TODO: Check which parts are already tested in libraries/stdlib/test/collections/IterableTests.kt
|
||||
class ArrayListNativeTest {
|
||||
@Test fun basic() {
|
||||
val a = ArrayList<String>()
|
||||
assertTrue(a.isEmpty())
|
||||
assertEquals(0, a.size)
|
||||
|
||||
assertTrue(a.add("1"))
|
||||
assertTrue(a.add("2"))
|
||||
assertTrue(a.add("3"))
|
||||
assertFalse(a.isEmpty())
|
||||
assertEquals(3, a.size)
|
||||
assertEquals("1", a[0])
|
||||
assertEquals("2", a[1])
|
||||
assertEquals("3", a[2])
|
||||
|
||||
a[0] = "11"
|
||||
assertEquals("11", a[0])
|
||||
|
||||
assertEquals("11", a.removeAt(0))
|
||||
assertEquals(2, a.size)
|
||||
assertEquals("2", a[0])
|
||||
assertEquals("3", a[1])
|
||||
|
||||
a.add(1, "22")
|
||||
assertEquals(3, a.size)
|
||||
assertEquals("2", a[0])
|
||||
assertEquals("22", a[1])
|
||||
assertEquals("3", a[2])
|
||||
|
||||
a.clear()
|
||||
assertTrue(a.isEmpty())
|
||||
assertEquals(0, a.size)
|
||||
}
|
||||
|
||||
@Test fun iterator() {
|
||||
val a = ArrayList(listOf("1", "2", "3"))
|
||||
val it = a.iterator()
|
||||
assertTrue(it.hasNext())
|
||||
assertEquals("1", it.next())
|
||||
assertTrue(it.hasNext())
|
||||
assertEquals("2", it.next())
|
||||
assertTrue(it.hasNext())
|
||||
assertEquals("3", it.next())
|
||||
assertFalse(it.hasNext())
|
||||
}
|
||||
|
||||
@Test fun containsAll() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5"))
|
||||
assertFalse(a.containsAll(listOf("6", "7", "8")))
|
||||
assertFalse(a.containsAll(listOf("5", "6", "7")))
|
||||
assertFalse(a.containsAll(listOf("4", "5", "6")))
|
||||
assertTrue(a.containsAll(listOf("3", "4", "5")))
|
||||
assertTrue(a.containsAll(listOf("2", "3", "4")))
|
||||
}
|
||||
|
||||
@Test fun remove() {
|
||||
val a = ArrayList(listOf("1", "2", "3"))
|
||||
assertTrue(a.remove("2"))
|
||||
assertEquals(2, a.size)
|
||||
assertEquals("1", a[0])
|
||||
assertEquals("3", a[1])
|
||||
assertFalse(a.remove("2"))
|
||||
assertEquals(2, a.size)
|
||||
assertEquals("1", a[0])
|
||||
assertEquals("3", a[1])
|
||||
}
|
||||
|
||||
@Test fun removeAll() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5", "1"))
|
||||
assertFalse(a.removeAll(listOf("6", "7", "8")))
|
||||
assertEquals(listOf("1", "2", "3", "4", "5", "1"), a)
|
||||
assertTrue(a.removeAll(listOf("5", "3", "1")))
|
||||
assertEquals(listOf("2", "4"), a)
|
||||
}
|
||||
|
||||
@Test fun retainAll() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5"))
|
||||
assertFalse(a.retainAll(listOf("1", "2", "3", "4", "5")))
|
||||
assertEquals(listOf("1", "2", "3", "4", "5"), a)
|
||||
assertTrue(a.retainAll(listOf("5", "3", "1")))
|
||||
assertEquals(listOf("1", "3", "5"), a)
|
||||
}
|
||||
|
||||
@Test fun equals() {
|
||||
val a = ArrayList(listOf("1", "2", "3"))
|
||||
assertTrue(a == listOf("1", "2", "3"))
|
||||
assertFalse(a == listOf("2", "3", "1")) // order matters
|
||||
assertFalse(a == listOf("1", "2", "4"))
|
||||
assertFalse(a == listOf("1", "2"))
|
||||
}
|
||||
|
||||
@Test fun hashCodeIdentity() {
|
||||
val a = ArrayList(listOf("1", "2", "3"))
|
||||
assertEquals(listOf("1", "2", "3").hashCode(), a.hashCode())
|
||||
}
|
||||
|
||||
@Test fun toStringIdentity() {
|
||||
val a = ArrayList(listOf("1", "2", "3"))
|
||||
assertEquals(listOf("1", "2", "3").toString(), a.toString())
|
||||
}
|
||||
|
||||
@Test fun subList() {
|
||||
val a0 = ArrayList(listOf("0", "1", "2", "3", "4"))
|
||||
val a = a0.subList(1, 4)
|
||||
assertEquals(3, a.size)
|
||||
assertEquals("1", a[0])
|
||||
assertEquals("2", a[1])
|
||||
assertEquals("3", a[2])
|
||||
assertTrue(a == listOf("1", "2", "3"))
|
||||
assertTrue(a.hashCode() == listOf("1", "2", "3").hashCode())
|
||||
assertTrue(a.toString() == listOf("1", "2", "3").toString())
|
||||
}
|
||||
|
||||
@Test fun resize() {
|
||||
val a = ArrayList<String>()
|
||||
val n = 10000
|
||||
for (i in 1..n)
|
||||
assertTrue(a.add(i.toString()))
|
||||
assertEquals(n, a.size)
|
||||
for (i in 1..n)
|
||||
assertEquals(i.toString(), a[i - 1])
|
||||
a.trimToSize()
|
||||
assertEquals(n, a.size)
|
||||
for (i in 1..n)
|
||||
assertEquals(i.toString(), a[i - 1])
|
||||
}
|
||||
|
||||
@Test fun subListContains() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4"))
|
||||
val s = a.subList(1, 3)
|
||||
assertTrue(a.contains("1"))
|
||||
assertFalse(s.contains("1"))
|
||||
assertTrue(a.contains("2"))
|
||||
assertTrue(s.contains("2"))
|
||||
assertTrue(a.contains("3"))
|
||||
assertTrue(s.contains("3"))
|
||||
assertTrue(a.contains("4"))
|
||||
assertFalse(s.contains("4"))
|
||||
}
|
||||
|
||||
@Test fun subListIndexOf() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "1"))
|
||||
val s = a.subList(1, 3)
|
||||
assertEquals(0, a.indexOf("1"))
|
||||
assertEquals(-1, s.indexOf("1"))
|
||||
assertEquals(1, a.indexOf("2"))
|
||||
assertEquals(0, s.indexOf("2"))
|
||||
assertEquals(2, a.indexOf("3"))
|
||||
assertEquals(1, s.indexOf("3"))
|
||||
assertEquals(3, a.indexOf("4"))
|
||||
assertEquals(-1, s.indexOf("4"))
|
||||
}
|
||||
|
||||
@Test fun subListLastIndexOf() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "1"))
|
||||
val s = a.subList(1, 3)
|
||||
assertEquals(4, a.lastIndexOf("1"))
|
||||
assertEquals(-1, s.lastIndexOf("1"))
|
||||
assertEquals(1, a.lastIndexOf("2"))
|
||||
assertEquals(0, s.lastIndexOf("2"))
|
||||
assertEquals(2, a.lastIndexOf("3"))
|
||||
assertEquals(1, s.lastIndexOf("3"))
|
||||
assertEquals(3, a.lastIndexOf("4"))
|
||||
assertEquals(-1, s.lastIndexOf("4"))
|
||||
}
|
||||
|
||||
@Test fun subListClear() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4"))
|
||||
val s = a.subList(1, 3)
|
||||
assertEquals(listOf("2", "3"), s)
|
||||
|
||||
s.clear()
|
||||
assertEquals(listOf<String>(), s)
|
||||
assertEquals(listOf("1", "4"), a)
|
||||
}
|
||||
|
||||
@Test fun subListSubListClear() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5", "6"))
|
||||
val s = a.subList(1, 5)
|
||||
val q = s.subList(1, 3)
|
||||
assertEquals(listOf("2", "3", "4", "5"), s)
|
||||
assertEquals(listOf("3", "4"), q)
|
||||
|
||||
q.clear()
|
||||
assertEquals(listOf<String>(), q)
|
||||
assertEquals(listOf("2", "5"), s)
|
||||
assertEquals(listOf("1", "2", "5", "6"), a)
|
||||
}
|
||||
|
||||
@Test fun subListAdd() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4"))
|
||||
val s = a.subList(1, 3)
|
||||
assertEquals(listOf("2", "3"), s)
|
||||
|
||||
assertTrue(s.add("5"))
|
||||
assertEquals(listOf("2", "3", "5"), s)
|
||||
assertEquals(listOf("1", "2", "3", "5", "4"), a)
|
||||
}
|
||||
|
||||
@Test fun subListSubListAdd() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5", "6"))
|
||||
val s = a.subList(1, 5)
|
||||
val q = s.subList(1, 3)
|
||||
assertEquals(listOf("2", "3", "4", "5"), s)
|
||||
assertEquals(listOf("3", "4"), q)
|
||||
|
||||
assertTrue(q.add("7"))
|
||||
assertEquals(listOf("3", "4", "7"), q)
|
||||
assertEquals(listOf("2", "3", "4", "7", "5"), s)
|
||||
assertEquals(listOf("1", "2", "3", "4", "7", "5", "6"), a)
|
||||
}
|
||||
|
||||
@Test fun subListAddAll() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4"))
|
||||
val s = a.subList(1, 3)
|
||||
assertEquals(listOf("2", "3"), s)
|
||||
|
||||
assertTrue(s.addAll(listOf("5", "6")))
|
||||
assertEquals(listOf("2", "3", "5", "6"), s)
|
||||
assertEquals(listOf("1", "2", "3", "5", "6", "4"), a)
|
||||
}
|
||||
|
||||
@Test fun subListSubListAddAll() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5", "6"))
|
||||
val s = a.subList(1, 5)
|
||||
val q = s.subList(1, 3)
|
||||
assertEquals(listOf("2", "3", "4", "5"), s)
|
||||
assertEquals(listOf("3", "4"), q)
|
||||
|
||||
assertTrue(q.addAll(listOf("7", "8")))
|
||||
assertEquals(listOf("3", "4", "7", "8"), q)
|
||||
assertEquals(listOf("2", "3", "4", "7", "8", "5"), s)
|
||||
assertEquals(listOf("1", "2", "3", "4", "7", "8", "5", "6"), a)
|
||||
}
|
||||
|
||||
@Test fun subListRemoveAt() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5"))
|
||||
val s = a.subList(1, 4)
|
||||
assertEquals(listOf("2", "3", "4"), s)
|
||||
|
||||
assertEquals("3", s.removeAt(1))
|
||||
assertEquals(listOf("2", "4"), s)
|
||||
assertEquals(listOf("1", "2", "4", "5"), a)
|
||||
}
|
||||
|
||||
@Test fun subListSubListRemoveAt() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5", "6", "7"))
|
||||
val s = a.subList(1, 6)
|
||||
val q = s.subList(1, 4)
|
||||
assertEquals(listOf("2", "3", "4", "5", "6"), s)
|
||||
assertEquals(listOf("3", "4", "5"), q)
|
||||
|
||||
assertEquals("4", q.removeAt(1))
|
||||
assertEquals(listOf("3", "5"), q)
|
||||
assertEquals(listOf("2", "3", "5", "6"), s)
|
||||
assertEquals(listOf("1", "2", "3", "5", "6", "7"), a)
|
||||
}
|
||||
|
||||
@Test fun subListRemoveAll() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "3", "4", "5"))
|
||||
val s = a.subList(1, 5)
|
||||
assertEquals(listOf("2", "3", "3", "4"), s)
|
||||
|
||||
assertTrue(s.removeAll(listOf("3", "5")))
|
||||
assertEquals(listOf("2", "4"), s)
|
||||
assertEquals(listOf("1", "2", "4", "5"), a)
|
||||
}
|
||||
|
||||
@Test fun subListSubListRemoveAll() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5", "6", "7"))
|
||||
val s = a.subList(1, 6)
|
||||
val q = s.subList(1, 4)
|
||||
assertEquals(listOf("2", "3", "4", "5", "6"), s)
|
||||
assertEquals(listOf("3", "4", "5"), q)
|
||||
|
||||
assertTrue(q.removeAll(listOf("4", "6")))
|
||||
assertEquals(listOf("3", "5"), q)
|
||||
assertEquals(listOf("2", "3", "5", "6"), s)
|
||||
assertEquals(listOf("1", "2", "3", "5", "6", "7"), a)
|
||||
}
|
||||
|
||||
@Test fun subListRetainAll() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5"))
|
||||
val s = a.subList(1, 4)
|
||||
assertEquals(listOf("2", "3", "4"), s)
|
||||
|
||||
assertTrue(s.retainAll(listOf("5", "3")))
|
||||
assertEquals(listOf("3"), s)
|
||||
assertEquals(listOf("1", "3", "5"), a)
|
||||
}
|
||||
|
||||
@Test fun subListSubListRetainAll() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5", "6", "7"))
|
||||
val s = a.subList(1, 6)
|
||||
val q = s.subList(1, 4)
|
||||
assertEquals(listOf("2", "3", "4", "5", "6"), s)
|
||||
assertEquals(listOf("3", "4", "5"), q)
|
||||
|
||||
assertTrue(q.retainAll(listOf("5", "3")))
|
||||
assertEquals(listOf("3", "5"), q)
|
||||
assertEquals(listOf("2", "3", "5", "6"), s)
|
||||
assertEquals(listOf("1", "2", "3", "5", "6", "7"), a)
|
||||
}
|
||||
|
||||
@Test fun iteratorRemove() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5"))
|
||||
val it = a.iterator()
|
||||
while (it.hasNext())
|
||||
if (it.next()[0].toInt() % 2 == 0)
|
||||
it.remove()
|
||||
assertEquals(listOf("1", "3", "5"), a)
|
||||
}
|
||||
|
||||
@Test fun iteratorAdd() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5"))
|
||||
val it = a.listIterator()
|
||||
while (it.hasNext()) {
|
||||
val next = it.next()
|
||||
if (next[0].toInt() % 2 == 0)
|
||||
it.add("-" + next)
|
||||
}
|
||||
assertEquals(listOf("1", "2", "-2", "3", "4", "-4", "5"), a)
|
||||
}
|
||||
|
||||
@Test fun iteratorNext() {
|
||||
val a = arrayListOf("1", "2", "3", "4", "5")
|
||||
val it = a.listIterator()
|
||||
assertFailsWith<NoSuchElementException> {
|
||||
while (true) {
|
||||
it.next()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun iteratorPrevious() {
|
||||
val a = arrayListOf("1", "2", "3", "4", "5")
|
||||
val it = a.listIterator()
|
||||
it.next()
|
||||
assertFailsWith<NoSuchElementException> {
|
||||
while (true) {
|
||||
it.previous()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun factory() {
|
||||
val nonConstStr = Random.nextInt().toString()
|
||||
val list = arrayListOf(nonConstStr, "b", "c")
|
||||
assertEquals(3, list.size)
|
||||
assertEquals(nonConstStr, list[0])
|
||||
assertEquals("b", list[1])
|
||||
assertEquals("c", list[2])
|
||||
|
||||
list.add("d")
|
||||
assertEquals(4, list.size)
|
||||
assertEquals(nonConstStr, list[0])
|
||||
assertEquals("b", list[1])
|
||||
assertEquals("c", list[2])
|
||||
assertEquals("d", list[3])
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,384 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
||||
*/
|
||||
|
||||
package test.collections
|
||||
|
||||
import kotlin.test.*
|
||||
|
||||
// Native-specific part of stdlib/test/collections/ArraysTest.kt
|
||||
class ArraysNativeTest {
|
||||
@Test fun byteArraySet() {
|
||||
val arr = ByteArray(5)
|
||||
arr[1] = 1
|
||||
arr[3] = -1
|
||||
assertEquals(1, arr[1])
|
||||
assertEquals(-1, arr[3])
|
||||
}
|
||||
|
||||
@Test fun shortArraySet() {
|
||||
val arr = ShortArray(5)
|
||||
arr[1] = 1
|
||||
arr[3] = -1
|
||||
assertEquals(1, arr[1])
|
||||
assertEquals(-1, arr[3])
|
||||
}
|
||||
|
||||
@Test fun intArraySet() {
|
||||
val arr = IntArray(5)
|
||||
arr[1] = 1
|
||||
arr[3] = -1
|
||||
assertEquals(1, arr[1])
|
||||
assertEquals(-1, arr[3])
|
||||
}
|
||||
|
||||
@Test fun longArraySet() {
|
||||
val arr = LongArray(5)
|
||||
arr[1] = 1
|
||||
arr[3] = -1
|
||||
assertEquals(1, arr[1])
|
||||
assertEquals(-1, arr[3])
|
||||
}
|
||||
|
||||
@Test fun arrayGetOutOfBounds() {
|
||||
val arr = Array<Any?>(5) { null }
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE]
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun byteArrayGetOutOfBounds() {
|
||||
val arr = ByteArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE]
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun shortArrayGetOutOfBounds() {
|
||||
val arr = ShortArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE]
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun intArrayGetOutOfBounds() {
|
||||
val arr = IntArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE]
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun floatArrayGetOutOfBounds() {
|
||||
val arr = FloatArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE]
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun doubleArrayGetOutOfBounds() {
|
||||
val arr = DoubleArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE]
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun charArrayGetOutOfBounds() {
|
||||
val arr = CharArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE]
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun arraySetOutOfBounds() {
|
||||
val arr = Array<Any?>(5) { null }
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size] = Any()
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1] = Any()
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE] = Any()
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE] = Any()
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun byteArraySetOutOfBounds() {
|
||||
val arr = ByteArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size] = 1
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1] = 1
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE] = 1
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE] = 1
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun shortArraySetOutOfBounds() {
|
||||
val arr = ShortArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size] = 1
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1] = 1
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE] = 1
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE] = 1
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun intArraySetOutOfBounds() {
|
||||
val arr = IntArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size] = 1
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1] = 1
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE] = 1
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE] = 1
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun floatArraySetOutOfBounds() {
|
||||
val arr = FloatArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size] = 1.0f
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1] = 1.0f
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE] = 1.0f
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE] = 1.0f
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun doubleArraySetOutOfBounds() {
|
||||
val arr = DoubleArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size] = 1.0
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1] = 1.0
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE] = 1.0
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE] = 1.0
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun charArraySetOutOfBounds() {
|
||||
val arr = CharArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size] = '1'
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1] = '1'
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE] = '1'
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE] = '1'
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun largeByteArray() {
|
||||
val arr = ByteArray(1000000) { it.toByte() }
|
||||
|
||||
var sum = 0
|
||||
for (b in arr) {
|
||||
sum += b
|
||||
}
|
||||
|
||||
assertEquals(-497952, sum)
|
||||
}
|
||||
|
||||
@Test fun largeArray() {
|
||||
val arr = Array<Byte>(1000000) { it.toByte() }
|
||||
|
||||
var sum = 0
|
||||
for (b in arr) {
|
||||
sum += b
|
||||
}
|
||||
|
||||
assertEquals(-497952, sum)
|
||||
}
|
||||
|
||||
private fun Array<Int>.assertSorted(cmp: Comparator<Int>, message: String = "") {
|
||||
for (i in 1 until size) {
|
||||
assertTrue(cmp.compare(this[i - 1], this[i]) <= 0, message)
|
||||
}
|
||||
}
|
||||
|
||||
private fun Array<MyComparable>.assertSorted(message: String = "") {
|
||||
for (i in 1 until size) {
|
||||
assertTrue(this[i - 1] <= this[i], message)
|
||||
}
|
||||
}
|
||||
|
||||
private class MyComparable (val value: Int, val comparator: Comparator<Int>): Comparable<MyComparable> {
|
||||
override fun compareTo(other: MyComparable): Int = comparator.compare(value, other.value)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun sortWith() {
|
||||
listOf<Array<Int>>(
|
||||
arrayOf(),
|
||||
arrayOf(1),
|
||||
arrayOf(Int.MIN_VALUE, 0, Int.MAX_VALUE),
|
||||
arrayOf(Int.MAX_VALUE, 0, Int.MIN_VALUE),
|
||||
arrayOf(1, 2, 3),
|
||||
arrayOf(-2, -1, 99, 1, 2),
|
||||
arrayOf(90, 91, 0, 98, 99),
|
||||
arrayOf(2, 1, 99, -1, 2),
|
||||
arrayOf(99, 98, 0, 91, 90),
|
||||
arrayOf(42, 42, 42),
|
||||
arrayOf(99, 42, 0, 42, 50),
|
||||
arrayOf(
|
||||
100000, 190001, 200002, 200003, 200004, 210005, 220006, 250007, 300008, 310009, 360010, 365011,
|
||||
380012, 390013, 390014, 399015, 400016, 400017, 400018, 400019, 400020, 400021, 400022, 400023,
|
||||
400024, 400025, 400026, 450027, 450028, 480029, 480030, 500031, 500032, 500033, 500034, 500035,
|
||||
500036, 500037, 500038, 500039, 500040, 500041, 500042, 500043, 500044, 500045, 500046, 500047,
|
||||
500048, 500049, 500050, 500051, 500052, 500053, 505054, 510055, 510056, 510057, 510058, 510059,
|
||||
510060, 510061, 510062, 510063, 410064, 410065, 511066, 511067, 520068, 520069, 420070, 520071,
|
||||
530072, 530073, 530074, 430075, 430076, 530077, 540078, 540079, 540080, 540081, 540082, 540083,
|
||||
540084, 490085, 540086, 540087, 542088, 544089, 546090, 550091, 550092, 550093, 550094, 590095,
|
||||
590096, 595097, 600098, 600099, 600100, 600101, 600102, 600103, 600104, 550105, 600106, 600107,
|
||||
600108, 600109, 600110, 610111, 610112, 610113, 620114, 620115, 620116, 620117, 620118, 620119,
|
||||
640120, 640121, 645122, 645123, 645124, 645125, 645126, 645127, 650128, 700129, 700130
|
||||
)
|
||||
).forEach { array ->
|
||||
data class ComparatorInfo(val name: String, val isCorrect: Boolean, val comparator: Comparator<Int>)
|
||||
// Assert that the array is sorted in terms of a comparator only for correct/partially correct cases
|
||||
listOf<ComparatorInfo>(
|
||||
ComparatorInfo("Correct increasing", true) { a, b ->
|
||||
when {
|
||||
a > b -> 1
|
||||
a < b -> -1
|
||||
else -> 0
|
||||
}
|
||||
},
|
||||
ComparatorInfo("Correct decreasing", true) { a, b ->
|
||||
when {
|
||||
a < b -> 1
|
||||
a > b -> -1
|
||||
else -> 0
|
||||
}
|
||||
},
|
||||
ComparatorInfo("Incorrect increasing", false) { a, b -> if (a > b) 1 else -1 },
|
||||
ComparatorInfo("Incorrect decreasing", false) { a, b -> if (a < b) 1 else -1 },
|
||||
ComparatorInfo("Always 1", false) { a, b -> 1 },
|
||||
ComparatorInfo("Always -1", false) { a, b -> -1 },
|
||||
ComparatorInfo("Always 0", false) { a, b -> 0 },
|
||||
).forEach { (name, isCorrect, comparator) ->
|
||||
// Test with custom comparator
|
||||
val arrayUnderTest = array.copyOf()
|
||||
arrayUnderTest.sortWith(comparator)
|
||||
if (isCorrect) {
|
||||
arrayUnderTest.assertSorted(comparator, """
|
||||
Assert sorted failed for comparator: "${name}"
|
||||
Array: ${array.joinToString()}
|
||||
Array after sorting: ${arrayUnderTest.joinToString()}
|
||||
""".trimIndent())
|
||||
}
|
||||
|
||||
// Test of a custom comparable
|
||||
val comparableArrayUnderTest = Array(array.size) { i ->
|
||||
MyComparable(array[i], comparator)
|
||||
}
|
||||
comparableArrayUnderTest.sort()
|
||||
|
||||
if (isCorrect) {
|
||||
comparableArrayUnderTest.assertSorted("""
|
||||
Assert sorted failed for Comparable: "${name}"
|
||||
Array: ${array.joinToString()}
|
||||
Array after sorting: ${comparableArrayUnderTest.joinToString()}
|
||||
""".trimIndent())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,415 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
||||
*/
|
||||
|
||||
package test.collections
|
||||
|
||||
import kotlin.test.*
|
||||
|
||||
private fun assertContainsOnly(bitSet: BitSet, trueBits: Set<Int>, size: Int) {
|
||||
for (i in 0 until size) {
|
||||
assertEquals(i in trueBits, bitSet[i])
|
||||
}
|
||||
}
|
||||
|
||||
private fun assertNotContainsOnly(bitSet: BitSet, falseBits: Set<Int>, size: Int) {
|
||||
for (i in 0 until size) {
|
||||
assertNotEquals(i in falseBits, bitSet[i])
|
||||
}
|
||||
}
|
||||
|
||||
class BitSetTest {
|
||||
@Test fun constructor() {
|
||||
var b = BitSet(12)
|
||||
assertContainsOnly(b, setOf(), 12)
|
||||
|
||||
b = BitSet(12) { it == 0 || it in 5..6 || it == 11 }
|
||||
assertContainsOnly(b, setOf(0, 5, 6, 11), 12)
|
||||
}
|
||||
|
||||
@Test fun set() {
|
||||
var b = BitSet(0)
|
||||
assertEquals(b.lastTrueIndex, -1)
|
||||
b = BitSet(2)
|
||||
// Test set and clear operation for single index.
|
||||
assertTrue(b.isEmpty)
|
||||
b.set(0, true)
|
||||
b.set(3, true)
|
||||
assertEquals(b.lastTrueIndex, 3)
|
||||
assertFalse(b.isEmpty)
|
||||
assertContainsOnly(b, setOf(0, 3), 4)
|
||||
b.clear()
|
||||
assertContainsOnly(b, setOf(), 4)
|
||||
b.set(1)
|
||||
b.set(5)
|
||||
assertEquals(b.lastTrueIndex, 5)
|
||||
assertContainsOnly(b, setOf(1, 5), 6)
|
||||
b.set(1, false)
|
||||
b.set(7, false)
|
||||
assertEquals(b.lastTrueIndex, 5)
|
||||
assertContainsOnly(b, setOf(5), 8)
|
||||
b.clear(5)
|
||||
assertEquals(b.lastTrueIndex, -1)
|
||||
assertContainsOnly(b, setOf(), 8)
|
||||
b.set(70)
|
||||
assertEquals(b.lastTrueIndex, 70)
|
||||
assertContainsOnly(b, setOf(70), 71)
|
||||
b.clear(70)
|
||||
assertEquals(b.lastTrueIndex, -1)
|
||||
assertContainsOnly(b, setOf(), 71)
|
||||
|
||||
// Test set and clear operations for ranges.
|
||||
// Set false and clear.
|
||||
b = BitSet(2)
|
||||
assertContainsOnly(b, setOf(), 2)
|
||||
b.set(0..70, true)
|
||||
assertNotContainsOnly(b, setOf(), 71)
|
||||
b.set(0..2, false)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2), 71)
|
||||
b.set(63..65, false)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2, 63, 64, 65), 71)
|
||||
b.set(68..70, false)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2, 63, 64, 65, 68, 69, 70), 71)
|
||||
b.set(68..72, false)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2, 63, 64, 65, 68, 69, 70, 71, 72), 73)
|
||||
b.set(0..72, false)
|
||||
assertContainsOnly(b, setOf(), 73)
|
||||
|
||||
b.set(0..72)
|
||||
assertNotContainsOnly(b, setOf(), 73)
|
||||
b.clear(0..2)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2), 73)
|
||||
b.clear(63..65)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2, 63, 64, 65), 73)
|
||||
b.clear(68..70)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2, 63, 64, 65, 68, 69, 70), 73)
|
||||
b.clear(68..72)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2, 63, 64, 65, 68, 69, 70, 71, 72), 73)
|
||||
b.clear(0..72)
|
||||
assertContainsOnly(b, setOf(), 73)
|
||||
|
||||
// Set true.
|
||||
b.set(0..2, true)
|
||||
assertContainsOnly(b, setOf(0, 1, 2), 73)
|
||||
b.set(63..65, true)
|
||||
assertContainsOnly(b, setOf(0, 1, 2, 63, 64, 65), 73)
|
||||
b.set(70..72, true)
|
||||
assertContainsOnly(b, setOf(0, 1, 2, 63, 64, 65, 70, 71, 72), 73)
|
||||
b.set(73..74, true)
|
||||
assertContainsOnly(b, setOf(0, 1, 2, 63, 64, 65, 70, 71, 72, 73, 74), 75)
|
||||
b.set(0..74, true)
|
||||
assertNotContainsOnly(b, setOf(), 75)
|
||||
|
||||
// Test set and clear for pair of indices.
|
||||
b = BitSet(2)
|
||||
assertContainsOnly(b, setOf(), 71)
|
||||
b.set(0, 71, true)
|
||||
assertNotContainsOnly(b, setOf(), 71)
|
||||
b.set(0, 3, false)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2), 71)
|
||||
b.set(63, 66, false)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2, 63, 64, 65), 71)
|
||||
b.set(68, 71, false)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2, 63, 64, 65, 68, 69, 70), 71)
|
||||
b.set(68, 73, false)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2, 63, 64, 65, 68, 69, 70, 71, 72), 73)
|
||||
b.set(0, 73, false)
|
||||
assertContainsOnly(b, setOf(), 73)
|
||||
|
||||
b.set(0, 73)
|
||||
assertNotContainsOnly(b, setOf(), 73)
|
||||
b.clear(0, 3)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2), 73)
|
||||
b.clear(63, 66)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2, 63, 64, 65), 73)
|
||||
b.clear(68, 71)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2, 63, 64, 65, 68, 69, 70), 73)
|
||||
b.clear(68, 73)
|
||||
assertNotContainsOnly(b, setOf(0, 1, 2, 63, 64, 65, 68, 69, 70, 71, 72), 73)
|
||||
b.clear(0, 73)
|
||||
assertContainsOnly(b, setOf(), 73)
|
||||
|
||||
// Set true.
|
||||
b.set(0, 3, true)
|
||||
assertContainsOnly(b, setOf(0, 1, 2), 73)
|
||||
b.set(63, 66, true)
|
||||
assertContainsOnly(b, setOf(0, 1, 2, 63, 64, 65), 73)
|
||||
b.set(70, 73, true)
|
||||
assertContainsOnly(b, setOf(0, 1, 2, 63, 64, 65, 70, 71, 72), 73)
|
||||
b.set(73, 75, true)
|
||||
assertContainsOnly(b, setOf(0, 1, 2, 63, 64, 65, 70, 71, 72, 73, 74), 75)
|
||||
b.set(0, 75, true)
|
||||
assertNotContainsOnly(b, setOf(), 75)
|
||||
|
||||
// Access to negative elements must cause an exception
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
b.set(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
b.clear(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
b.clear(-1..0)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
b.set(-1..0)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
b[-1]
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun flip() {
|
||||
val b = BitSet(2)
|
||||
b.set(0, true)
|
||||
b.set(70, true)
|
||||
b.set(63..65, true)
|
||||
assertEquals(b.lastTrueIndex, 70)
|
||||
// 0 element
|
||||
assertContainsOnly(b, setOf(0, 63, 64, 65, 70), 71)
|
||||
b.flip(0)
|
||||
assertContainsOnly(b, setOf(63, 64, 65, 70), 71)
|
||||
b.flip(1)
|
||||
assertContainsOnly(b, setOf(1, 63, 64, 65, 70), 71)
|
||||
b.flip(0)
|
||||
assertContainsOnly(b, setOf(0, 1, 63, 64, 65, 70), 71)
|
||||
|
||||
// last element
|
||||
b.flip(70)
|
||||
assertContainsOnly(b, setOf(0, 1, 63, 64, 65), 71)
|
||||
b.flip(69)
|
||||
assertContainsOnly(b, setOf(0, 1, 63, 64, 65, 69), 71)
|
||||
b.flip(70)
|
||||
assertContainsOnly(b, setOf(0, 1, 63, 64, 65, 69, 70), 71)
|
||||
|
||||
// element in the middle
|
||||
b.flip(64)
|
||||
assertContainsOnly(b, setOf(0, 1, 63, 65, 69, 70), 71)
|
||||
b.flip(65)
|
||||
assertContainsOnly(b, setOf(0, 1, 63, 69, 70), 71)
|
||||
b.flip(65)
|
||||
b.flip(64)
|
||||
assertContainsOnly(b, setOf(0, 1, 63, 64, 65, 69, 70), 71)
|
||||
|
||||
// range in the beginning
|
||||
b.flip(0..2)
|
||||
assertContainsOnly(b, setOf(2, 63, 64, 65, 69, 70), 71)
|
||||
b.flip(0, 3)
|
||||
assertContainsOnly(b, setOf(0, 1, 63, 64, 65, 69, 70), 71)
|
||||
|
||||
// In the end
|
||||
b.flip(68..70)
|
||||
assertContainsOnly(b, setOf(0, 1, 63, 64, 65, 68), 71)
|
||||
b.flip(68, 71)
|
||||
assertContainsOnly(b, setOf(0, 1, 63, 64, 65, 69, 70), 71)
|
||||
|
||||
// In the middle
|
||||
b.flip(64..66)
|
||||
assertContainsOnly(b, setOf(0, 1, 63, 66, 69, 70), 71)
|
||||
b.flip(64, 67)
|
||||
assertContainsOnly(b, setOf(0, 1, 63, 64, 65, 69, 70), 71)
|
||||
|
||||
// Access to a negative element must cause an exception.
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
b.flip(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
b.flip(-1..0)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun nextBit() {
|
||||
val b = BitSet(71)
|
||||
b.set(0)
|
||||
b.set(65)
|
||||
b.set(70)
|
||||
assertEquals(b.nextSetBit(), 0)
|
||||
assertEquals(b.nextSetBit(0), 0)
|
||||
assertEquals(b.nextSetBit(1), 65)
|
||||
assertEquals(b.nextSetBit(65), 65)
|
||||
assertEquals(b.nextSetBit(66), 70)
|
||||
assertEquals(b.nextSetBit(70), 70)
|
||||
assertEquals(b.nextSetBit(71), -1)
|
||||
|
||||
assertEquals(b.previousSetBit(0), 0)
|
||||
assertEquals(b.previousSetBit(64), 0)
|
||||
assertEquals(b.previousSetBit(65), 65)
|
||||
assertEquals(b.previousSetBit(69), 65)
|
||||
assertEquals(b.previousSetBit(70), 70)
|
||||
assertEquals(b.previousSetBit(71), 70)
|
||||
|
||||
b.clear()
|
||||
assertEquals(b.nextSetBit(), -1)
|
||||
assertEquals(b.previousSetBit(70), -1)
|
||||
|
||||
b.set(0..70)
|
||||
assertEquals(b.nextClearBit(), 71)
|
||||
assertEquals(b.previousClearBit(70), -1)
|
||||
|
||||
b.clear(0)
|
||||
b.clear(65)
|
||||
b.clear(70)
|
||||
assertEquals(b.nextClearBit(), 0)
|
||||
assertEquals(b.nextClearBit(0), 0)
|
||||
assertEquals(b.nextClearBit(1), 65)
|
||||
assertEquals(b.nextClearBit(65), 65)
|
||||
assertEquals(b.nextClearBit(66), 70)
|
||||
assertEquals(b.nextClearBit(70), 70)
|
||||
assertEquals(b.nextClearBit(71), 71) // assume that the bitset is extended here (virtually).
|
||||
|
||||
assertEquals(b.previousClearBit(0), 0)
|
||||
assertEquals(b.previousClearBit(64), 0)
|
||||
assertEquals(b.previousClearBit(65), 65)
|
||||
assertEquals(b.previousClearBit(69), 65)
|
||||
assertEquals(b.previousClearBit(70), 70)
|
||||
assertEquals(b.previousClearBit(71), 71)
|
||||
|
||||
// See http://docs.oracle.com/javase/8/docs/api/java/util/BitSet.html#previousClearBit-int-
|
||||
assertEquals(b.previousClearBit(-1), -1)
|
||||
assertEquals(b.previousSetBit(-1), -1)
|
||||
|
||||
// Test behaviour on the right border of the bit vector.
|
||||
// We assume that the vector is infinite and have zeros after (size - 1)th bit.
|
||||
var a = BitSet(64)
|
||||
assertEquals(a.nextClearBit(63), 63)
|
||||
assertEquals(a.nextClearBit(64), 64)
|
||||
assertEquals(a.nextSetBit(63), -1)
|
||||
assertEquals(a.nextSetBit(64), -1)
|
||||
a.set(0, 64)
|
||||
assertEquals(a.nextClearBit(63), 64)
|
||||
assertEquals(a.nextClearBit(64), 64)
|
||||
assertEquals(a.nextSetBit(63), 63)
|
||||
assertEquals(a.nextSetBit(64), -1)
|
||||
|
||||
a.clear()
|
||||
assertEquals(a.previousClearBit(63), 63)
|
||||
assertEquals(a.previousClearBit(64), 64)
|
||||
assertEquals(a.previousSetBit(63), -1)
|
||||
assertEquals(a.previousSetBit(64), -1)
|
||||
a.set(0, 64)
|
||||
assertEquals(a.previousClearBit(63), -1)
|
||||
assertEquals(a.previousClearBit(64), 64)
|
||||
assertEquals(a.previousSetBit(63), 63)
|
||||
assertEquals(a.previousSetBit(64), 63)
|
||||
|
||||
a = BitSet(0)
|
||||
assertEquals(a.nextSetBit(0), -1)
|
||||
assertEquals(a.nextClearBit(0), 0)
|
||||
assertEquals(a.previousSetBit(0), -1)
|
||||
assertEquals(a.previousClearBit(0), 0)
|
||||
|
||||
// Access to a negative element must cause an exception.
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
b.previousSetBit(-2)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
b.previousClearBit(-2)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
b.nextSetBit(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
b.nextClearBit(-1)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun logic() {
|
||||
var b2 = BitSet(76)
|
||||
intArrayOf(1, 3, 61, 63, 65, 67, 70, 72).forEach {
|
||||
b2.set(it)
|
||||
}
|
||||
|
||||
// and
|
||||
var b1 = BitSet(73)
|
||||
b1.set(2..3); b1.set(62..63); b1.set(66..67); b1.set(71..72)
|
||||
b1.and(b2)
|
||||
assertContainsOnly(b1, setOf(3, 63, 67, 72), 76)
|
||||
b1 = BitSet(73)
|
||||
b1.set(2..3); b1.set(62..63); b1.set(66..67); b1.set(71..72)
|
||||
b1.set(128)
|
||||
b1.and(b2)
|
||||
assertContainsOnly(b1, setOf(3, 63, 67, 72), 129)
|
||||
|
||||
// or
|
||||
b1 = BitSet(73)
|
||||
b1.set(2..3); b1.set(62..63); b1.set(66..67); b1.set(71..72)
|
||||
b1.or(b2)
|
||||
assertContainsOnly(b1, setOf(1, 2, 3, 61, 62, 63, 65, 66, 67, 70, 71, 72), 76)
|
||||
|
||||
b1 = BitSet(73)
|
||||
b1.set(2..3); b1.set(62..63); b1.set(66..67); b1.set(71..72)
|
||||
b1.set(128)
|
||||
b1.or(b2)
|
||||
assertContainsOnly(b1, setOf(1, 2, 3, 61, 62, 63, 65, 66, 67, 70, 71, 72, 128), 129)
|
||||
|
||||
// xor
|
||||
b1 = BitSet(73)
|
||||
b1.set(2..3); b1.set(62..63); b1.set(66..67); b1.set(71..72)
|
||||
b1.xor(b2)
|
||||
assertContainsOnly(b1, setOf(1, 2, 61, 62, 65, 66, 70, 71), 76)
|
||||
|
||||
b1 = BitSet(73)
|
||||
b1.set(2..3); b1.set(62..63); b1.set(66..67); b1.set(71..72)
|
||||
b1.set(128)
|
||||
b1.xor(b2)
|
||||
assertContainsOnly(b1, setOf(1, 2, 61, 62, 65, 66, 70, 71, 128), 129)
|
||||
|
||||
// andNot
|
||||
b1 = BitSet(73)
|
||||
b1.set(2..3); b1.set(62..63); b1.set(66..67); b1.set(71..72)
|
||||
b1.andNot(b2)
|
||||
assertContainsOnly(b1, setOf(2, 62, 66, 71), 76)
|
||||
|
||||
b1 = BitSet(73)
|
||||
b1.set(2..3); b1.set(62..63); b1.set(66..67); b1.set(71..72)
|
||||
b1.set(128)
|
||||
b1.andNot(b2)
|
||||
assertContainsOnly(b1, setOf(2, 62, 66, 71, 128), 129)
|
||||
|
||||
// intersects
|
||||
b1 = BitSet(73)
|
||||
b1.set(0..1); b1.set(62..63); b1.set(64..65); b1.set(71..72)
|
||||
b2.clear(); b2.set(0)
|
||||
assertTrue(b1.intersects(b2))
|
||||
b2.clear(); b2.set(62..65)
|
||||
assertTrue(b1.intersects(b2))
|
||||
b2.clear(); b2.set(72)
|
||||
assertTrue(b1.intersects(b2))
|
||||
b2.clear()
|
||||
assertFalse(b1.intersects(b2))
|
||||
b2.set(128)
|
||||
assertFalse(b1.intersects(b2))
|
||||
}
|
||||
|
||||
// Based on Harmony tests.
|
||||
@Test fun equalsHashCode() {
|
||||
// HashCode.
|
||||
val b = BitSet()
|
||||
b.set(0..7)
|
||||
b.clear(2)
|
||||
b.clear(6)
|
||||
assertEquals(1129, b.hashCode())
|
||||
b.set(10)
|
||||
b.clear(3)
|
||||
assertEquals(97, b.hashCode())
|
||||
|
||||
// Equals.
|
||||
val b1 = BitSet()
|
||||
val b2 = BitSet()
|
||||
b1.set(0..7)
|
||||
b2.set(0..7)
|
||||
|
||||
assertTrue(b1 == b1)
|
||||
assertTrue(b1 == b2)
|
||||
b2.clear(6)
|
||||
assertFalse(b1 == b2)
|
||||
|
||||
val b3 = BitSet()
|
||||
b3.set(0..7)
|
||||
b3.set(128)
|
||||
assertFalse(b1 == b3)
|
||||
b3.clear(128)
|
||||
assertTrue(b1 == b3)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,444 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
||||
*/
|
||||
|
||||
package test.collections
|
||||
|
||||
import kotlin.test.*
|
||||
|
||||
class ByteArrayTest {
|
||||
@Test fun getUByteOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
assertEquals(0U, arr.getUByteAt(0))
|
||||
assertEquals(0U, arr.getUByteAt(arr.size - 1))
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUByteAt(arr.size)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUByteAt(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUByteAt(Int.MAX_VALUE)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUByteAt(Int.MIN_VALUE)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun setUByteOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
arr.setUByteAt(0, 1U)
|
||||
arr.setUByteAt(arr.size - 1, 1U)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUByteAt(arr.size, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUByteAt(-1, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUByteAt(Int.MAX_VALUE, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUByteAt(Int.MIN_VALUE, 1U)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun getCharOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
assertEquals(0.toChar(), arr.getCharAt(0))
|
||||
assertEquals(0.toChar(), arr.getCharAt(8))
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getCharAt(arr.size - 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getCharAt(arr.size)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getCharAt(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getCharAt(Int.MAX_VALUE)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getCharAt(Int.MIN_VALUE)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun setCharOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
arr.setCharAt(0, '1')
|
||||
arr.setCharAt(8, '1')
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setCharAt(arr.size - 1, '1')
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setCharAt(arr.size, '1')
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setCharAt(-1, '1')
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setCharAt(Int.MAX_VALUE, '1')
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setCharAt(Int.MIN_VALUE, '1')
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun getShortOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
assertEquals(0, arr.getShortAt(0))
|
||||
assertEquals(0, arr.getShortAt(8))
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getShortAt(arr.size - 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getShortAt(arr.size)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getShortAt(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getShortAt(Int.MAX_VALUE)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getShortAt(Int.MIN_VALUE)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun setShortOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
arr.setShortAt(0, 0)
|
||||
arr.setShortAt(8, 0)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setShortAt(arr.size - 1, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setShortAt(arr.size, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setShortAt(-1, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setShortAt(Int.MAX_VALUE, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setShortAt(Int.MIN_VALUE, 1)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun getUShortOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
assertEquals(0U, arr.getUShortAt(0))
|
||||
assertEquals(0U, arr.getUShortAt(8))
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUShortAt(arr.size - 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUShortAt(arr.size)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUShortAt(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUShortAt(Int.MAX_VALUE)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUShortAt(Int.MIN_VALUE)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun setUShortOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
arr.setUShortAt(0, 0U)
|
||||
arr.setUShortAt(8, 0U)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUShortAt(arr.size - 1, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUShortAt(arr.size, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUShortAt(-1, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUShortAt(Int.MAX_VALUE, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUShortAt(Int.MIN_VALUE, 1U)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun getIntOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
assertEquals(0, arr.getIntAt(0))
|
||||
assertEquals(0, arr.getIntAt(6))
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getIntAt(7)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getIntAt(arr.size)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getIntAt(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getIntAt(Int.MAX_VALUE)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getIntAt(Int.MIN_VALUE)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun setIntOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
arr.setIntAt(0, 1)
|
||||
arr.setIntAt(6, 1)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setIntAt(7, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setIntAt(arr.size, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setIntAt(-1, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setIntAt(Int.MAX_VALUE, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setIntAt(Int.MIN_VALUE, 1)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun getUIntOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
assertEquals(0U, arr.getUIntAt(0))
|
||||
assertEquals(0U, arr.getUIntAt(6))
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUIntAt(7)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUIntAt(arr.size)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUIntAt(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUIntAt(Int.MAX_VALUE)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getUIntAt(Int.MIN_VALUE)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun setUIntOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
arr.setUIntAt(0, 1U)
|
||||
arr.setUIntAt(6, 1U)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUIntAt(7, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUIntAt(arr.size, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUIntAt(-1, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUIntAt(Int.MAX_VALUE, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setUIntAt(Int.MIN_VALUE, 1U)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun getLongOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
assertEquals(0, arr.getLongAt(0))
|
||||
assertEquals(0, arr.getLongAt(2))
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getLongAt(3)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getLongAt(arr.size)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getLongAt(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getLongAt(Int.MAX_VALUE)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getLongAt(Int.MIN_VALUE)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun setLongOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
arr.setLongAt(0, 1)
|
||||
arr.setLongAt(2, 1)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setLongAt(3, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setLongAt(arr.size, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setLongAt(-1, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setLongAt(Int.MAX_VALUE, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setLongAt(Int.MIN_VALUE, 1)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun getULongOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
assertEquals(0U, arr.getULongAt(0))
|
||||
assertEquals(0U, arr.getULongAt(2))
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getULongAt(3)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getULongAt(arr.size)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getULongAt(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getULongAt(Int.MAX_VALUE)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getULongAt(Int.MIN_VALUE)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun setULongOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
arr.setULongAt(0, 1U)
|
||||
arr.setULongAt(2, 1U)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setULongAt(3, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setULongAt(arr.size, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setULongAt(-1, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setULongAt(Int.MAX_VALUE, 1U)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setULongAt(Int.MIN_VALUE, 1U)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun getFloatOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
assertEquals(0.0f, arr.getFloatAt(0))
|
||||
assertEquals(0.0f, arr.getFloatAt(6))
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getFloatAt(7)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getFloatAt(arr.size)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getFloatAt(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getFloatAt(Int.MAX_VALUE)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getFloatAt(Int.MIN_VALUE)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun setFloatOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
arr.setFloatAt(0, 1.0f)
|
||||
arr.setFloatAt(6, 1.0f)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setFloatAt(7, 1.0f)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setFloatAt(arr.size, 1.0f)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setFloatAt(-1, 1.0f)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setFloatAt(Int.MAX_VALUE, 1.0f)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setFloatAt(Int.MIN_VALUE, 1.0f)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun getDoubleOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
assertEquals(0.0, arr.getDoubleAt(0))
|
||||
assertEquals(0.0, arr.getDoubleAt(2))
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getDoubleAt(3)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getDoubleAt(arr.size)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getDoubleAt(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getDoubleAt(Int.MAX_VALUE)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.getDoubleAt(Int.MIN_VALUE)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun setDoubleOutOfBounds() {
|
||||
val arr = ByteArray(10) { 0 }
|
||||
arr.setDoubleAt(0, 1.0)
|
||||
arr.setDoubleAt(2, 1.0)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setDoubleAt(3, 1.0)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setDoubleAt(arr.size, 1.0)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setDoubleAt(-1, 1.0)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setDoubleAt(Int.MAX_VALUE, 1.0)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr.setDoubleAt(Int.MIN_VALUE, 1.0)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun smoke() {
|
||||
// These tests assume little endian bit ordering.
|
||||
val array = ByteArray(42)
|
||||
array.setLongAt(5, 0x1234_5678_9abc_def0)
|
||||
|
||||
expect(0x1234_5678_9abc_def0) { array.getLongAt(5) }
|
||||
expect(0xdef0.toInt()) { array.getCharAt(5).toInt() }
|
||||
expect(0x9abc.toShort()) { array.getShortAt(7) }
|
||||
expect(0x1234_5678) { array.getIntAt(9) }
|
||||
expect(0xdef0_0000u) { array.getUIntAt(3) }
|
||||
expect(0xf0_00u) { array.getUShortAt(4) }
|
||||
expect(0xf0u) { array.getUByteAt(5) }
|
||||
expect(0x1234_5678_9abcuL) { array.getULongAt(7) }
|
||||
|
||||
array.setIntAt(2, 0x40100000)
|
||||
expect(2.25f) { array.getFloatAt(2) }
|
||||
array.setLongAt(11, 0x400c_0000_0000_0000)
|
||||
expect(3.5) { array.getDoubleAt(11) }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,237 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
||||
*/
|
||||
|
||||
package test.collections
|
||||
|
||||
import kotlin.test.*
|
||||
|
||||
// TODO: Check which parts are already tested in libraries/stdlib/test/collections/MapTest.kt
|
||||
class HashMapTest {
|
||||
@Test fun basic() {
|
||||
val m = HashMap<String, String>()
|
||||
assertTrue(m.isEmpty())
|
||||
assertEquals(0, m.size)
|
||||
|
||||
assertFalse(m.containsKey("1"))
|
||||
assertFalse(m.containsValue("a"))
|
||||
assertEquals(null, m.get("1"))
|
||||
|
||||
assertEquals(null, m.put("1", "a"))
|
||||
assertTrue(m.containsKey("1"))
|
||||
assertTrue(m.containsValue("a"))
|
||||
assertEquals("a", m.get("1"))
|
||||
assertFalse(m.isEmpty())
|
||||
assertEquals(1, m.size)
|
||||
|
||||
assertFalse(m.containsKey("2"))
|
||||
assertFalse(m.containsValue("b"))
|
||||
assertEquals(null, m.get("2"))
|
||||
|
||||
assertEquals(null, m.put("2", "b"))
|
||||
assertTrue(m.containsKey("1"))
|
||||
assertTrue(m.containsValue("a"))
|
||||
assertEquals("a", m.get("1"))
|
||||
assertTrue(m.containsKey("2"))
|
||||
assertTrue(m.containsValue("b"))
|
||||
assertEquals("b", m.get("2"))
|
||||
assertFalse(m.isEmpty())
|
||||
assertEquals(2, m.size)
|
||||
|
||||
assertEquals("b", m.put("2", "bb"))
|
||||
assertTrue(m.containsKey("1"))
|
||||
assertTrue(m.containsValue("a"))
|
||||
assertEquals("a", m.get("1"))
|
||||
assertTrue(m.containsKey("2"))
|
||||
assertTrue(m.containsValue("a"))
|
||||
assertTrue(m.containsValue("bb"))
|
||||
assertEquals("bb", m.get("2"))
|
||||
assertFalse(m.isEmpty())
|
||||
assertEquals(2, m.size)
|
||||
|
||||
assertEquals("a", m.remove("1"))
|
||||
assertFalse(m.containsKey("1"))
|
||||
assertFalse(m.containsValue("a"))
|
||||
assertEquals(null, m.get("1"))
|
||||
assertTrue(m.containsKey("2"))
|
||||
assertTrue(m.containsValue("bb"))
|
||||
assertEquals("bb", m.get("2"))
|
||||
assertFalse(m.isEmpty())
|
||||
assertEquals(1, m.size)
|
||||
|
||||
assertEquals("bb", m.remove("2"))
|
||||
assertFalse(m.containsKey("1"))
|
||||
assertFalse(m.containsValue("a"))
|
||||
assertEquals(null, m.get("1"))
|
||||
assertFalse(m.containsKey("2"))
|
||||
assertFalse(m.containsValue("bb"))
|
||||
assertEquals(null, m.get("2"))
|
||||
assertTrue(m.isEmpty())
|
||||
assertEquals(0, m.size)
|
||||
}
|
||||
|
||||
@Test fun equals() {
|
||||
val expected = mapOf("a" to "1", "b" to "2", "c" to "3")
|
||||
val m = HashMap(expected)
|
||||
assertTrue(m == expected)
|
||||
assertTrue(m == mapOf("b" to "2", "c" to "3", "a" to "1")) // order does not matter
|
||||
assertFalse(m == mapOf("a" to "1", "b" to "2", "c" to "4"))
|
||||
assertFalse(m == mapOf("a" to "1", "b" to "2", "c" to "5"))
|
||||
assertFalse(m == mapOf("a" to "1", "b" to "2"))
|
||||
assertEquals(m.keys, expected.keys)
|
||||
assertEquals(m.values.toList(), expected.values.toList())
|
||||
assertEquals(m.entries, expected.entries)
|
||||
}
|
||||
|
||||
@Test fun hashCodeTest() {
|
||||
val expected = mapOf("a" to "1", "b" to "2", "c" to "3")
|
||||
val m = HashMap(expected)
|
||||
assertEquals(expected.hashCode(), m.hashCode())
|
||||
assertEquals(expected.entries.hashCode(), m.entries.hashCode())
|
||||
assertEquals(expected.keys.hashCode(), m.keys.hashCode())
|
||||
}
|
||||
|
||||
@Test fun toStringTest() {
|
||||
val expected = mapOf("a" to "1", "b" to "2", "c" to "3")
|
||||
val m = HashMap(expected)
|
||||
assertEquals(expected.toString(), m.toString())
|
||||
assertEquals(expected.entries.toString(), m.entries.toString())
|
||||
assertEquals(expected.keys.toString(), m.keys.toString())
|
||||
assertEquals(expected.values.toString(), m.values.toString())
|
||||
}
|
||||
|
||||
@Test fun put() {
|
||||
val expected = mapOf("a" to "1", "b" to "2", "c" to "3")
|
||||
val m = HashMap(expected)
|
||||
val e = expected.entries.iterator().next() as MutableMap.MutableEntry<String, String>
|
||||
assertTrue(m.entries.contains(e))
|
||||
assertTrue(m.entries.remove(e))
|
||||
assertTrue(mapOf("b" to "2", "c" to "3") == m)
|
||||
assertEquals(null, m.put(e.key, e.value))
|
||||
assertTrue(expected == m)
|
||||
assertEquals(e.value, m.put(e.key, e.value))
|
||||
assertTrue(expected == m)
|
||||
}
|
||||
|
||||
@Test fun removeAll() {
|
||||
val expected = mapOf("a" to "1", "b" to "2", "c" to "3")
|
||||
val m = HashMap(expected)
|
||||
assertFalse(m.entries.removeAll(mapOf("a" to "2", "b" to "3", "c" to "4").entries))
|
||||
assertEquals(expected, m)
|
||||
assertTrue(m.entries.removeAll(mapOf("b" to "22", "c" to "3", "d" to "4").entries))
|
||||
assertNotEquals(expected, m)
|
||||
assertEquals(mapOf("a" to "1", "b" to "2"), m)
|
||||
}
|
||||
|
||||
@Test fun retainAll() {
|
||||
val expected = mapOf("a" to "1", "b" to "2", "c" to "3")
|
||||
val m = HashMap(expected)
|
||||
assertFalse(m.entries.retainAll(expected.entries))
|
||||
assertEquals(expected, m)
|
||||
assertTrue(m.entries.retainAll(mapOf("b" to "22", "c" to "3", "d" to "4").entries))
|
||||
assertEquals(mapOf("c" to "3"), m)
|
||||
}
|
||||
|
||||
@Test fun containsAll() {
|
||||
val m = HashMap(mapOf("a" to "1", "b" to "2", "c" to "3"))
|
||||
assertTrue(m.values.containsAll(listOf("1", "2")))
|
||||
assertTrue(m.values.containsAll(listOf("1", "2", "3")))
|
||||
assertFalse(m.values.containsAll(listOf("1", "2", "3", "4")))
|
||||
assertFalse(m.values.containsAll(listOf("2", "3", "4")))
|
||||
}
|
||||
|
||||
@Test fun valuesRemove() {
|
||||
val expected = mapOf("a" to "1", "b" to "2", "c" to "3")
|
||||
val m = HashMap(expected)
|
||||
assertFalse(m.values.remove("b"))
|
||||
assertEquals(expected, m)
|
||||
assertTrue(m.values.remove("2"))
|
||||
assertEquals(mapOf("a" to "1", "c" to "3"), m)
|
||||
}
|
||||
|
||||
@Test fun valuesRemoveAll() {
|
||||
val expected = mapOf("a" to "1", "b" to "2", "c" to "3")
|
||||
val m = HashMap(expected)
|
||||
assertFalse(m.values.removeAll(listOf("b", "c")))
|
||||
assertEquals(expected, m)
|
||||
assertTrue(m.values.removeAll(listOf("b", "3")))
|
||||
assertEquals(mapOf("a" to "1", "b" to "2"), m)
|
||||
}
|
||||
|
||||
@Test fun valuesRetainAll() {
|
||||
val expected = mapOf("a" to "1", "b" to "2", "c" to "3")
|
||||
val m = HashMap(expected)
|
||||
assertFalse(m.values.retainAll(listOf("1", "2", "3")))
|
||||
assertEquals(expected, m)
|
||||
assertTrue(m.values.retainAll(listOf("1", "2", "c")))
|
||||
assertEquals(mapOf("a" to "1", "b" to "2"), m)
|
||||
}
|
||||
|
||||
@Test fun iterator() {
|
||||
val expected = mapOf("a" to "1", "b" to "2", "c" to "3")
|
||||
val m = HashMap(expected)
|
||||
val it = m.iterator()
|
||||
while (it.hasNext()) {
|
||||
val entry = it.next()
|
||||
entry.setValue(entry.value + "!")
|
||||
}
|
||||
assertNotEquals(expected, m)
|
||||
assertEquals(mapOf("a" to "1!", "b" to "2!", "c" to "3!"), m)
|
||||
}
|
||||
|
||||
// TODO: Is it too slow with aggressive GC?
|
||||
@Test fun rehashAndCompact() {
|
||||
val m = HashMap<String, String>()
|
||||
for (repeat in 1..10) {
|
||||
val n = when (repeat) {
|
||||
1 -> 1000
|
||||
2 -> 10000
|
||||
3 -> 10
|
||||
else -> 100000
|
||||
}
|
||||
for (i in 1..n) {
|
||||
assertFalse(m.containsKey(i.toString()))
|
||||
assertEquals(null, m.put(i.toString(), "val$i"))
|
||||
assertTrue(m.containsKey(i.toString()))
|
||||
assertEquals(i, m.size)
|
||||
}
|
||||
for (i in 1..n) {
|
||||
assertTrue(m.containsKey(i.toString()))
|
||||
}
|
||||
for (i in 1..n) {
|
||||
assertEquals("val$i", m.remove(i.toString()))
|
||||
assertFalse(m.containsKey(i.toString()))
|
||||
assertEquals(n - i, m.size)
|
||||
}
|
||||
assertTrue(m.isEmpty())
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Is it too slow with aggressive GC?
|
||||
@Test fun clear() {
|
||||
val m = HashMap<String, String>()
|
||||
for (repeat in 1..10) {
|
||||
val n = when (repeat) {
|
||||
1 -> 1000
|
||||
2 -> 10000
|
||||
3 -> 10
|
||||
else -> 100000
|
||||
}
|
||||
for (i in 1..n) {
|
||||
assertFalse(m.containsKey(i.toString()))
|
||||
assertEquals(null, m.put(i.toString(), "val$i"))
|
||||
assertTrue(m.containsKey(i.toString()))
|
||||
assertEquals(i, m.size)
|
||||
}
|
||||
for (i in 1..n) {
|
||||
assertTrue(m.containsKey(i.toString()))
|
||||
}
|
||||
m.clear()
|
||||
assertEquals(0, m.size)
|
||||
for (i in 1..n) {
|
||||
assertFalse(m.containsKey(i.toString()))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
||||
*/
|
||||
|
||||
package test.collections
|
||||
|
||||
import kotlin.test.*
|
||||
|
||||
// TODO: Check which parts are already tested in libraries/stdlib/test/collections
|
||||
class HashSetTest {
|
||||
@Test fun basic() {
|
||||
val a = HashSet<String>()
|
||||
assertTrue(a.isEmpty())
|
||||
assertEquals(0, a.size)
|
||||
|
||||
assertTrue(a.add("1"))
|
||||
assertTrue(a.add("2"))
|
||||
assertTrue(a.add("3"))
|
||||
assertFalse(a.isEmpty())
|
||||
assertEquals(3, a.size)
|
||||
assertTrue(a.contains("1"))
|
||||
assertTrue(a.contains("2"))
|
||||
assertTrue(a.contains("3"))
|
||||
assertFalse(a.contains("4"))
|
||||
|
||||
assertTrue(a.remove("1"))
|
||||
assertEquals(2, a.size)
|
||||
assertFalse(a.contains("1"))
|
||||
assertTrue(a.contains("2"))
|
||||
assertTrue(a.contains("3"))
|
||||
assertFalse(a.contains("4"))
|
||||
|
||||
assertTrue(a.add("4"))
|
||||
assertEquals(3, a.size)
|
||||
assertFalse(a.contains("1"))
|
||||
assertTrue(a.contains("2"))
|
||||
assertTrue(a.contains("3"))
|
||||
assertTrue(a.contains("4"))
|
||||
|
||||
assertFalse(a.add("4"))
|
||||
assertEquals(3, a.size)
|
||||
assertFalse(a.contains("1"))
|
||||
assertTrue(a.contains("2"))
|
||||
assertTrue(a.contains("3"))
|
||||
assertTrue(a.contains("4"))
|
||||
|
||||
a.clear()
|
||||
assertTrue(a.isEmpty())
|
||||
assertEquals(0, a.size)
|
||||
assertFalse(a.contains("1"))
|
||||
assertFalse(a.contains("2"))
|
||||
assertFalse(a.contains("3"))
|
||||
assertFalse(a.contains("4"))
|
||||
}
|
||||
|
||||
@Test fun iterator() {
|
||||
val s = HashSet(listOf("1", "2", "3"))
|
||||
val it = s.iterator()
|
||||
assertTrue(it.hasNext())
|
||||
assertEquals("1", it.next())
|
||||
assertTrue(it.hasNext())
|
||||
assertEquals("2", it.next())
|
||||
assertTrue(it.hasNext())
|
||||
assertEquals("3", it.next())
|
||||
assertFalse(it.hasNext())
|
||||
}
|
||||
|
||||
@Test fun equals() {
|
||||
val s = HashSet(listOf("1", "2", "3"))
|
||||
assertTrue(s == setOf("1", "2", "3"))
|
||||
assertTrue(s == setOf("2", "3", "1")) // order does not matter
|
||||
assertFalse(s == setOf("1", "2", "4"))
|
||||
assertFalse(s == setOf("1", "2"))
|
||||
}
|
||||
|
||||
@Test fun hashCodeTest() {
|
||||
val s = HashSet(listOf("1", "2", "3"))
|
||||
assertTrue(s.hashCode() == setOf("1", "2", "3").hashCode())
|
||||
}
|
||||
|
||||
@Test fun toStringTest() {
|
||||
val s = HashSet(listOf("1", "2", "3"))
|
||||
assertTrue(s.toString() == setOf("1", "2", "3").toString())
|
||||
}
|
||||
|
||||
@Test fun containsAll() {
|
||||
val s = HashSet(listOf("1", "2", "3", "4", "5"))
|
||||
assertFalse(s.containsAll(listOf("6", "7", "8")))
|
||||
assertFalse(s.containsAll(listOf("5", "6", "7")))
|
||||
assertFalse(s.containsAll(listOf("4", "5", "6")))
|
||||
assertTrue(s.containsAll(listOf("3", "4", "5")))
|
||||
assertTrue(s.containsAll(listOf("2", "3", "4")))
|
||||
}
|
||||
|
||||
@Test fun removeAll() {
|
||||
val s = HashSet(listOf("1", "2", "3", "4", "5", "1"))
|
||||
assertFalse(s.removeAll(listOf("6", "7", "8")))
|
||||
assertEquals(setOf("1", "2", "3", "4", "5", "1"), s)
|
||||
assertTrue(s.removeAll(listOf("5", "3", "1")))
|
||||
assertEquals(setOf("2", "4"), s)
|
||||
}
|
||||
|
||||
@Test fun retainAll() {
|
||||
val s = HashSet(listOf("1", "2", "3", "4", "5"))
|
||||
assertFalse(s.retainAll(listOf("1", "2", "3", "4", "5")))
|
||||
assertEquals(setOf("1", "2", "3", "4", "5"), s)
|
||||
assertTrue(s.retainAll(listOf("5", "3", "1")))
|
||||
assertEquals(setOf("1", "3", "5"), s)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
||||
*/
|
||||
|
||||
package test.collections
|
||||
|
||||
import kotlin.test.*
|
||||
import kotlinx.cinterop.*
|
||||
|
||||
class ImmutableBlobTest {
|
||||
@Test fun iterator() {
|
||||
val blob = immutableBlobOf(1, 2, 3)
|
||||
val actual = buildList {
|
||||
for (b in blob) {
|
||||
add(b)
|
||||
}
|
||||
}
|
||||
assertContentEquals(listOf<Byte>(1, 2, 3), actual)
|
||||
}
|
||||
|
||||
@Test fun toByteArray() {
|
||||
val blob = immutableBlobOf(1, 2, 3)
|
||||
val actual = blob.toByteArray()
|
||||
assertContentEquals(byteArrayOf(1, 2, 3), actual)
|
||||
}
|
||||
|
||||
@Test fun toByteArraySlice() {
|
||||
val blob = immutableBlobOf(0, 0)
|
||||
val arr = blob.toByteArray(0, 1)
|
||||
assertEquals(1, arr.size)
|
||||
assertEquals(0, arr[0])
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.toByteArray(-1, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.toByteArray(0, -1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.toByteArray(0, 10)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.toByteArray(10, 11)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.toByteArray(10, 1)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun toUByteArraySlice() {
|
||||
val blob = immutableBlobOf(0, 0)
|
||||
val arr = blob.toUByteArray(0, 1)
|
||||
assertEquals(1, arr.size)
|
||||
assertEquals(0U, arr[0])
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.toUByteArray(-1, 1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.toUByteArray(0, -1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.toUByteArray(0, 10)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.toUByteArray(10, 11)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.toUByteArray(10, 1)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun asCPointer() {
|
||||
val blob = immutableBlobOf(0, 0)
|
||||
assertEquals(0, blob.asCPointer(0).pointed.value)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.asCPointer(10)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.asCPointer(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.asCPointer(Int.MAX_VALUE)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.asCPointer(Int.MIN_VALUE)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun asUCPointer() {
|
||||
val blob = immutableBlobOf(0, 0)
|
||||
assertEquals(0U, blob.asUCPointer(0).pointed.value)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.asUCPointer(10)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.asUCPointer(-1)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.asUCPointer(Int.MAX_VALUE)
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
blob.asUCPointer(Int.MIN_VALUE)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
||||
*/
|
||||
|
||||
package test.collections
|
||||
|
||||
import kotlin.random.Random
|
||||
import kotlin.test.*
|
||||
|
||||
// Native-specific part of stdlib/test/collections/ListSpecificTest.kt
|
||||
class ListSpecificNativeTest {
|
||||
|
||||
@Test fun factory() {
|
||||
val nonConstStr = Random.nextInt().toString()
|
||||
val list = listOf(nonConstStr, "b", "c")
|
||||
assertEquals(3, list.size)
|
||||
assertEquals(nonConstStr, list[0])
|
||||
assertEquals("b", list[1])
|
||||
assertEquals("c", list[2])
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
||||
*/
|
||||
|
||||
package test.collection
|
||||
|
||||
import kotlin.test.*
|
||||
|
||||
// Native-specific part of stdlib/test/collections/MutableCollectionsTest.kt
|
||||
class MutableCollectionsNativeTest {
|
||||
@Test fun sortListString() {
|
||||
val x = mutableListOf("x", "a", "b")
|
||||
x.sort()
|
||||
assertContentEquals(listOf("a", "b", "x"), x)
|
||||
}
|
||||
|
||||
@Test fun sortListInt() {
|
||||
val x = mutableListOf(239, 42, -1, 100500, 0)
|
||||
x.sort()
|
||||
assertContentEquals(listOf(-1, 0, 42, 239, 100500), x)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,139 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
||||
*/
|
||||
|
||||
package test.collections
|
||||
|
||||
import kotlin.test.*
|
||||
|
||||
// Native-specific part of stdlib/test/collections/UnsignedArraysTest.kt
|
||||
class UnsignedArraysNativeTest {
|
||||
@Test fun ubyteArray() {
|
||||
assertFailsWith<IllegalArgumentException> { UByteArray(-1) }
|
||||
}
|
||||
|
||||
@Test fun ubyteArrayInit() {
|
||||
assertFailsWith<IllegalArgumentException> { UByteArray(-1) { it.toUByte() } }
|
||||
}
|
||||
|
||||
@Test fun ushortArray() {
|
||||
assertFailsWith<IllegalArgumentException> { UShortArray(-1) }
|
||||
}
|
||||
|
||||
@Test fun ushortArrayInit() {
|
||||
assertFailsWith<IllegalArgumentException> { UShortArray(-1) { it.toUShort() } }
|
||||
}
|
||||
|
||||
@Test fun uintArray() {
|
||||
assertFailsWith<IllegalArgumentException> { UIntArray(-1) }
|
||||
}
|
||||
|
||||
@Test fun uintArrayInit() {
|
||||
assertFailsWith<IllegalArgumentException> { UIntArray(-1) { it.toUInt() } }
|
||||
}
|
||||
|
||||
@Test fun ulongArray() {
|
||||
assertFailsWith<IllegalArgumentException> { ULongArray(-1) }
|
||||
}
|
||||
|
||||
@Test fun ulongArrayInit() {
|
||||
assertFailsWith<IllegalArgumentException> { ULongArray(-1) { it.toULong() } }
|
||||
}
|
||||
|
||||
@Test fun ubyteArrayGetOutOfBounds() {
|
||||
val arr = UByteArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE]
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun ushortArrayGetOutOfBounds() {
|
||||
val arr = UShortArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE]
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun uintArrayGetOutOfBounds() {
|
||||
val arr = UIntArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE]
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE]
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun ubyteArraySetOutOfBounds() {
|
||||
val arr = UByteArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size] = 1U
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1] = 1U
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE] = 1U
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE] = 1U
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun ushortArraySetOutOfBounds() {
|
||||
val arr = UShortArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size] = 1U
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1] = 1U
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE] = 1U
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE] = 1U
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun uintArraySetOutOfBounds() {
|
||||
val arr = UIntArray(5)
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[arr.size] = 1U
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[-1] = 1U
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MAX_VALUE] = 1U
|
||||
}
|
||||
assertFailsWith<IndexOutOfBoundsException> {
|
||||
arr[Int.MIN_VALUE] = 1U
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user