Hash map by @elizarov, more stdlib code (#112)
This commit is contained in:
Nikolay Igotti
-2
@@ -3,11 +3,9 @@ package org.jetbrains.kotlin.backend.konan.llvm
|
||||
|
||||
import kotlinx.cinterop.*
|
||||
import llvm.*
|
||||
import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
|
||||
import org.jetbrains.kotlin.descriptors.ClassDescriptor
|
||||
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
|
||||
import org.jetbrains.kotlin.descriptors.PropertyDescriptor
|
||||
import org.jetbrains.kotlin.ir.declarations.IrConstructor
|
||||
import org.jetbrains.kotlin.ir.declarations.IrFunction
|
||||
import org.jetbrains.kotlin.types.KotlinType
|
||||
|
||||
|
||||
+34
-20
@@ -4,32 +4,25 @@ import kotlinx.cinterop.*
|
||||
import llvm.*
|
||||
import org.jetbrains.kotlin.backend.konan.*
|
||||
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
|
||||
import org.jetbrains.kotlin.backend.konan.llvm.KonanPlatform
|
||||
import org.jetbrains.kotlin.descriptors.*
|
||||
import org.jetbrains.kotlin.descriptors.impl.LazyClassReceiverParameterDescriptor
|
||||
import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor
|
||||
import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor
|
||||
import org.jetbrains.kotlin.incremental.components.NoLookupLocation
|
||||
import org.jetbrains.kotlin.ir.IrElement
|
||||
import org.jetbrains.kotlin.ir.declarations.*
|
||||
import org.jetbrains.kotlin.ir.descriptors.IrBuiltinOperatorDescriptorBase
|
||||
import org.jetbrains.kotlin.ir.descriptors.IrTemporaryVariableDescriptor
|
||||
import org.jetbrains.kotlin.ir.expressions.*
|
||||
import org.jetbrains.kotlin.ir.expressions.impl.IrBinaryPrimitiveImpl
|
||||
import org.jetbrains.kotlin.ir.expressions.impl.IrBreakImpl
|
||||
import org.jetbrains.kotlin.ir.expressions.impl.IrSetterCallImpl
|
||||
import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
|
||||
import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
|
||||
import org.jetbrains.kotlin.ir.visitors.acceptVoid
|
||||
import org.jetbrains.kotlin.name.FqName
|
||||
import org.jetbrains.kotlin.name.Name
|
||||
import org.jetbrains.kotlin.resolve.DescriptorUtils
|
||||
import org.jetbrains.kotlin.resolve.descriptorUtil.classId
|
||||
import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
|
||||
import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperclassesWithoutAny
|
||||
import org.jetbrains.kotlin.types.KotlinType
|
||||
import org.jetbrains.kotlin.types.TypeUtils
|
||||
import org.jetbrains.kotlin.types.typeUtil.isNothing
|
||||
import org.jetbrains.kotlin.types.typeUtil.isNullableNothing
|
||||
import org.jetbrains.kotlin.types.typeUtil.isUnit
|
||||
|
||||
fun emitLLVM(module: IrModuleFragment, runtimeFile: String, outFile: String) {
|
||||
@@ -726,7 +719,8 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid
|
||||
//-------------------------------------------------------------------------//
|
||||
|
||||
private fun evaluateStringConcatenation(tmpVariableName: String, value: IrStringConcatenation): LLVMValueRef? {
|
||||
val stringPlus = KonanPlatform.builtIns.stringType.memberScope.getContributedFunctions(Name.identifier("plus"), NoLookupLocation.FROM_BACKEND).first()
|
||||
val stringPlus = KonanPlatform.builtIns.stringType.memberScope.getContributedFunctions(
|
||||
Name.identifier("plus"), NoLookupLocation.FROM_BACKEND).first()
|
||||
var res:LLVMValueRef? = null
|
||||
val strings:List<LLVMValueRef> = value.arguments.map {
|
||||
val descriptor = getToString(it.type)
|
||||
@@ -1464,6 +1458,7 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid
|
||||
}
|
||||
|
||||
descriptor.valueParameters.map {
|
||||
//println(it.index)
|
||||
res += (it to expression.getValueArgument(it.index)!!)
|
||||
}
|
||||
|
||||
@@ -1549,6 +1544,7 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid
|
||||
private val kLt0 = Name.identifier("LT0")
|
||||
private val kLteq0 = Name.identifier("LTEQ0")
|
||||
private val kNot = Name.identifier("NOT")
|
||||
private val kThrowNpe = Name.identifier("THROW_NPE")
|
||||
private val kImmZero = LLVMConstInt(LLVMInt32Type(), 0, 1)!!
|
||||
private val kImmOne = LLVMConstInt(LLVMInt32Type(), 1, 1)!!
|
||||
private val kTrue = LLVMConstInt(LLVMInt1Type(), 1, 1)!!
|
||||
@@ -1559,13 +1555,15 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid
|
||||
logger.log("evaluateCall : $tmpVariableName origin:${ir2string(callee)}")
|
||||
val descriptor = callee.descriptor
|
||||
when (descriptor.name) {
|
||||
kEqeq -> return evaluateOperatorEqeq (callee as IrBinaryPrimitiveImpl, args[0]!!, args[1]!!, tmpVariableName)
|
||||
ktEqeqeq -> return evaluateOperatorEqeqeq(callee as IrBinaryPrimitiveImpl, args[0]!!, args[1]!!, tmpVariableName)
|
||||
kGt0 -> return codegen.icmpGt(args[0]!!, kImmZero, tmpVariableName)
|
||||
kGteq0 -> return codegen.icmpGe(args[0]!!, kImmZero, tmpVariableName)
|
||||
kLt0 -> return codegen.icmpLt(args[0]!!, kImmZero, tmpVariableName)
|
||||
kLteq0 -> return codegen.icmpLe(args[0]!!, kImmZero, tmpVariableName)
|
||||
kNot -> return codegen.icmpNe(args[0]!!, kTrue, tmpVariableName)
|
||||
kEqeq -> return evaluateOperatorEqeq (callee as IrBinaryPrimitiveImpl, args[0]!!, args[1]!!, tmpVariableName)
|
||||
ktEqeqeq -> return evaluateOperatorEqeqeq(callee as IrBinaryPrimitiveImpl, args[0]!!, args[1]!!, tmpVariableName)
|
||||
kGt0 -> return codegen.icmpGt(args[0]!!, kImmZero, tmpVariableName)
|
||||
kGteq0 -> return codegen.icmpGe(args[0]!!, kImmZero, tmpVariableName)
|
||||
kLt0 -> return codegen.icmpLt(args[0]!!, kImmZero, tmpVariableName)
|
||||
kLteq0 -> return codegen.icmpLe(args[0]!!, kImmZero, tmpVariableName)
|
||||
kNot -> return codegen.icmpNe(args[0]!!, kTrue, tmpVariableName)
|
||||
// TODO: reconsider.
|
||||
kThrowNpe -> return evaluateOperatorThrowNpe()
|
||||
else -> {
|
||||
TODO(descriptor.name.toString())
|
||||
}
|
||||
@@ -1574,9 +1572,9 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid
|
||||
|
||||
//-------------------------------------------------------------------------//
|
||||
|
||||
private fun getEquals(type: KotlinType, methodName: String) : SimpleFunctionDescriptor {
|
||||
private fun getEquals(type: KotlinType) : SimpleFunctionDescriptor {
|
||||
|
||||
val name = Name.identifier(methodName)
|
||||
val name = Name.identifier("equals")
|
||||
val descriptors = type.memberScope.getContributedFunctions(name, NoLookupLocation.FROM_BACKEND).filter {
|
||||
it.valueParameters.size == 1 && KotlinBuiltIns.isAnyOrNullableAny(it.valueParameters[0].type)
|
||||
}
|
||||
@@ -1593,6 +1591,15 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid
|
||||
return descriptor
|
||||
}
|
||||
|
||||
private fun getThrowNpe(): SimpleFunctionDescriptor {
|
||||
val name = Name.identifier("ThrowNullPointerException")
|
||||
val moduleDescriptor = KonanPlatform.builtIns.builtInsModule
|
||||
val packageDescriptor = moduleDescriptor.getPackage(FqName("konan.internal"))
|
||||
val descriptor = packageDescriptor.memberScope.getContributedFunctions(
|
||||
name, NoLookupLocation.FROM_BACKEND).first()
|
||||
return descriptor
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------//
|
||||
|
||||
private fun evaluateOperatorEqeq(callee: IrBinaryPrimitiveImpl, arg0: LLVMValueRef, arg1: LLVMValueRef, tmpVariableName: String): LLVMValueRef {
|
||||
@@ -1611,14 +1618,15 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid
|
||||
|
||||
private fun generateEqeqForObjects(callee: IrBinaryPrimitiveImpl, arg0: LLVMValueRef, arg1: LLVMValueRef, tmpVariableName: String): LLVMValueRef {
|
||||
val arg0Type = callee.argument0.type
|
||||
val descriptor = getEquals(arg0Type, "equals") // Get descriptor for "arg0.equals".
|
||||
val descriptor = getEquals(arg0Type) // Get descriptor for "arg0.equals".
|
||||
if (arg0Type.isMarkedNullable) { // If arg0 is nullable.
|
||||
val bbEq2 = codegen.basicBlock() // Block to process "eqeq".
|
||||
val bbEq3 = codegen.basicBlock() // Block to process "eqeqeq".
|
||||
val bbExit = codegen.basicBlock() // Exit block for feather generation.
|
||||
val result = codegen.alloca(codegen.getLLVMType(callee.type), codegen.newVar())
|
||||
|
||||
val condition = codegen.icmpEq(arg0, codegen.kNullObjHeaderPtr, codegen.newVar()) // Compare arg0 with "null".
|
||||
val condition = codegen.icmpEq(
|
||||
arg0, codegen.kNullObjHeaderPtr, codegen.newVar()) // Compare arg0 with "null".
|
||||
codegen.condBr(condition, bbEq3, bbEq2) // If (arg0 == null) bbEq3 else bbEq2.
|
||||
|
||||
codegen.positionAtEnd(bbEq3) // Get generation to bbEq3.
|
||||
@@ -1653,6 +1661,12 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid
|
||||
}
|
||||
}
|
||||
|
||||
private fun evaluateOperatorThrowNpe(): LLVMValueRef {
|
||||
val result = evaluateSimpleFunctionCall("", getThrowNpe(), listOf())
|
||||
codegen.unreachable()
|
||||
return result
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------//
|
||||
|
||||
private fun generateWhenCase(isUnit:Boolean, isNothing:Boolean, resultPtr: LLVMValueRef?, branch: IrBranch, bbNext: LLVMBasicBlockRef?, bbExit: LLVMBasicBlockRef?) {
|
||||
|
||||
@@ -477,6 +477,16 @@ task array_list1(type: RunKonanTest) {
|
||||
source = "runtime/collections/array_list1.kt"
|
||||
}
|
||||
|
||||
task hash_map0(type: RunKonanTest) {
|
||||
goldValue = "OK\n"
|
||||
source = "runtime/collections/hash_map0.kt"
|
||||
}
|
||||
|
||||
task hash_set0(type: RunKonanTest) {
|
||||
goldValue = "OK\n"
|
||||
source = "runtime/collections/hash_set0.kt"
|
||||
}
|
||||
|
||||
task listof0(type: RunKonanTest) {
|
||||
goldValue = "abc\n[a, b, c, d]\n[n, s, a]\n"
|
||||
arguments = ["a"]
|
||||
|
||||
@@ -8,12 +8,7 @@ fun assertFalse(cond: Boolean) {
|
||||
println("FAIL")
|
||||
}
|
||||
|
||||
fun assertEquals(value1: String, value2: String) {
|
||||
if (value1 != value2)
|
||||
println("FAIL")
|
||||
}
|
||||
|
||||
fun assertEquals(value1: ArrayList<String>, value2: ArrayList<String>) {
|
||||
fun assertEquals(value1: Any?, value2: Any?) {
|
||||
if (value1 != value2)
|
||||
println("FAIL")
|
||||
}
|
||||
@@ -56,77 +51,8 @@ fun testBasic() {
|
||||
assertEquals(0, a.size)
|
||||
}
|
||||
|
||||
fun makeList123() : ArrayList<String> {
|
||||
val a = ArrayList<String>()
|
||||
a.add("1")
|
||||
a.add("2")
|
||||
a.add("3")
|
||||
return a
|
||||
}
|
||||
|
||||
fun makeList12345() : ArrayList<String> {
|
||||
val a = ArrayList<String>()
|
||||
a.add("1")
|
||||
a.add("2")
|
||||
a.add("3")
|
||||
a.add("4")
|
||||
a.add("5")
|
||||
return a
|
||||
}
|
||||
|
||||
fun makeList12341() : ArrayList<String> {
|
||||
val a = ArrayList<String>()
|
||||
a.add("1")
|
||||
a.add("2")
|
||||
a.add("3")
|
||||
a.add("4")
|
||||
a.add("1")
|
||||
return a
|
||||
}
|
||||
|
||||
fun makeList01234() : ArrayList<String> {
|
||||
val a = ArrayList<String>()
|
||||
a.add("0")
|
||||
a.add("1")
|
||||
a.add("2")
|
||||
a.add("3")
|
||||
a.add("4")
|
||||
return a
|
||||
}
|
||||
|
||||
fun makeList678() : ArrayList<String> {
|
||||
val a = ArrayList<String>()
|
||||
a.add("6")
|
||||
a.add("7")
|
||||
a.add("8")
|
||||
return a
|
||||
}
|
||||
|
||||
fun makeList531() : ArrayList<String> {
|
||||
val a = ArrayList<String>()
|
||||
a.add("5")
|
||||
a.add("3")
|
||||
a.add("1")
|
||||
return a
|
||||
}
|
||||
|
||||
fun makeList135() : ArrayList<String> {
|
||||
val a = ArrayList<String>()
|
||||
a.add("1")
|
||||
a.add("3")
|
||||
a.add("5")
|
||||
return a
|
||||
}
|
||||
|
||||
fun makeList24() : ArrayList<String> {
|
||||
val a = ArrayList<String>()
|
||||
a.add("2")
|
||||
a.add("4")
|
||||
return a
|
||||
}
|
||||
|
||||
fun testIterator() {
|
||||
val a = makeList123()
|
||||
val a = ArrayList(listOf("1", "2", "3"))
|
||||
val it = a.iterator()
|
||||
assertTrue(it.hasNext())
|
||||
assertEquals("1", it.next())
|
||||
@@ -137,8 +63,17 @@ fun testIterator() {
|
||||
assertFalse(it.hasNext())
|
||||
}
|
||||
|
||||
fun testContainsAll() {
|
||||
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")))
|
||||
}
|
||||
|
||||
fun testRemove() {
|
||||
val a = makeList123()
|
||||
val a = ArrayList(listOf("1", "2", "3"))
|
||||
assertTrue(a.remove("2"))
|
||||
assertEquals(2, a.size)
|
||||
assertEquals("1", a[0])
|
||||
@@ -150,75 +85,68 @@ fun testRemove() {
|
||||
}
|
||||
|
||||
fun testRemoveAll() {
|
||||
val a = ArrayList(makeList12345())
|
||||
assertFalse(a.removeAll(makeList678()))
|
||||
assertEquals(makeList12345(), a)
|
||||
assertTrue(a.removeAll(makeList531()))
|
||||
assertEquals(makeList24(), a)
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5"))
|
||||
assertFalse(a.removeAll(listOf("6", "7", "8")))
|
||||
assertEquals(listOf("1", "2", "3", "4", "5"), a)
|
||||
assertTrue(a.removeAll(listOf("5", "3", "1")))
|
||||
assertEquals(listOf("2", "4"), a)
|
||||
}
|
||||
|
||||
fun testRetainAll() {
|
||||
val a = makeList12345()
|
||||
assertFalse(a.retainAll(makeList12345()))
|
||||
assertEquals(makeList12345(), a)
|
||||
assertTrue(a.retainAll(makeList531()))
|
||||
assertEquals(makeList135(), a)
|
||||
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)
|
||||
}
|
||||
|
||||
fun testEquals() {
|
||||
val a = makeList123()
|
||||
assertTrue(a == makeList123())
|
||||
assertFalse(a == makeList135())
|
||||
assertFalse(a == makeList24())
|
||||
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"))
|
||||
}
|
||||
|
||||
fun testHashCode() {
|
||||
val a = makeList123()
|
||||
assertTrue(a.hashCode() == makeList123().hashCode())
|
||||
val a = ArrayList(listOf("1", "2", "3"))
|
||||
assertTrue(a.hashCode() == listOf("1", "2", "3").hashCode())
|
||||
}
|
||||
|
||||
fun testToString() {
|
||||
val a = makeList123()
|
||||
assertTrue(a.toString() == makeList123().toString())
|
||||
}
|
||||
|
||||
fun testToString2() {
|
||||
val a = makeList123()
|
||||
assertEquals(a.toString(), "[1, 2, 3]")
|
||||
val a = ArrayList(listOf("1", "2", "3"))
|
||||
assertTrue(a.toString() == listOf("1", "2", "3").toString())
|
||||
}
|
||||
|
||||
|
||||
fun testSubList() {
|
||||
val a0 = makeList01234()
|
||||
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 == makeList123())
|
||||
assertTrue(a.hashCode() == makeList123().hashCode())
|
||||
assertTrue(a.toString() == makeList123().toString())
|
||||
assertTrue(a == listOf("1", "2", "3"))
|
||||
assertTrue(a.hashCode() == listOf("1", "2", "3").hashCode())
|
||||
assertTrue(a.toString() == listOf("1", "2", "3").toString())
|
||||
}
|
||||
|
||||
fun testResize() {
|
||||
val a = ArrayList<String>()
|
||||
val n = 10000
|
||||
var i = 0
|
||||
while (i++ < n)
|
||||
for (i in 1..n)
|
||||
assertTrue(a.add(i.toString()))
|
||||
assertEquals(n, a.size)
|
||||
i = 0
|
||||
while (i++ < n)
|
||||
for (i in 1..n)
|
||||
assertEquals(i.toString(), a[i - 1])
|
||||
a.trimToSize()
|
||||
assertEquals(n, a.size)
|
||||
i = 0
|
||||
while (i++ < n)
|
||||
for (i in 1..n)
|
||||
assertEquals(i.toString(), a[i - 1])
|
||||
}
|
||||
|
||||
fun testSubListContains() {
|
||||
val a = makeList12345()
|
||||
val a = ArrayList(listOf("1", "2", "3", "4"))
|
||||
val s = a.subList(1, 3)
|
||||
assertTrue(a.contains("1"))
|
||||
assertFalse(s.contains("1"))
|
||||
@@ -231,7 +159,7 @@ fun testSubListContains() {
|
||||
}
|
||||
|
||||
fun testSubListIndexOf() {
|
||||
val a = makeList12341()
|
||||
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"))
|
||||
@@ -244,7 +172,7 @@ fun testSubListIndexOf() {
|
||||
}
|
||||
|
||||
fun testSubListLastIndexOf() {
|
||||
val a = makeList12341()
|
||||
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"))
|
||||
@@ -256,29 +184,164 @@ fun testSubListLastIndexOf() {
|
||||
assertEquals(-1, s.lastIndexOf("4"))
|
||||
}
|
||||
|
||||
fun testSubListClear() {
|
||||
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)
|
||||
}
|
||||
|
||||
fun testSubListSubListClear() {
|
||||
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)
|
||||
}
|
||||
|
||||
fun testSubListAdd() {
|
||||
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)
|
||||
}
|
||||
|
||||
fun testSubListSubListAdd() {
|
||||
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)
|
||||
}
|
||||
|
||||
fun testSubListAddAll() {
|
||||
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)
|
||||
}
|
||||
|
||||
fun testSubListSubListAddAll() {
|
||||
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)
|
||||
}
|
||||
|
||||
fun testSubListRemoveAt() {
|
||||
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)
|
||||
}
|
||||
|
||||
fun testSubListSubListRemoveAt() {
|
||||
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)
|
||||
}
|
||||
|
||||
fun testSubListRemoveAll() {
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5"))
|
||||
val s = a.subList(1, 4)
|
||||
assertEquals(listOf("2", "3", "4"), s)
|
||||
|
||||
assertTrue(s.removeAll(listOf("3", "5")))
|
||||
assertEquals(listOf("2", "4"), s)
|
||||
assertEquals(listOf("1", "2", "4", "5"), a)
|
||||
}
|
||||
|
||||
fun testSubListSubListRemoveAll() {
|
||||
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)
|
||||
}
|
||||
|
||||
fun testSubListRetainAll() {
|
||||
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)
|
||||
}
|
||||
|
||||
fun testSubListSubListRetainAll() {
|
||||
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)
|
||||
}
|
||||
|
||||
fun testIteratorRemove() {
|
||||
val a = makeList12345()
|
||||
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(makeList135(), a)
|
||||
assertEquals(listOf("1", "3", "5"), a)
|
||||
}
|
||||
|
||||
fun testIteratorAdd() {
|
||||
val a = makeList12345()
|
||||
val a = ArrayList(listOf("1", "2", "3", "4", "5"))
|
||||
val it = a.listIterator()
|
||||
var i = 1
|
||||
while (it.hasNext()) {
|
||||
val next = it.next()
|
||||
if (i++ % 2 == 0)
|
||||
if (next[0].toInt() % 2 == 0)
|
||||
it.add("-" + next)
|
||||
}
|
||||
assertEquals("[1, 2, -2, 3, 4, -4, 5]", a.toString())
|
||||
assertEquals(listOf("1", "2", "-2", "3", "4", "-4", "5"), a)
|
||||
}
|
||||
|
||||
|
||||
|
||||
fun main(args : Array<String>) {
|
||||
testBasic()
|
||||
testIterator()
|
||||
@@ -288,13 +351,27 @@ fun main(args : Array<String>) {
|
||||
testEquals()
|
||||
testHashCode()
|
||||
testToString()
|
||||
testToString2()
|
||||
testSubList()
|
||||
testResize()
|
||||
testSubListContains()
|
||||
testSubListIndexOf()
|
||||
testSubListLastIndexOf()
|
||||
testIteratorAdd()
|
||||
/*
|
||||
testSubListClear()
|
||||
testSubListSubListClear()
|
||||
testSubListAdd()
|
||||
testSubListSubListAdd()
|
||||
testSubListAddAll()
|
||||
testSubListSubListAddAll()
|
||||
testSubListRemoveAt()
|
||||
testSubListSubListRemoveAt()
|
||||
testSubListRemoveAll()
|
||||
testSubListSubListRemoveAll()
|
||||
testSubListSubListRemoveAll()
|
||||
testSubListRetainAll()
|
||||
testSubListSubListRetainAll() */
|
||||
testIteratorRemove()
|
||||
testIteratorAdd()
|
||||
|
||||
println("OK")
|
||||
}
|
||||
@@ -0,0 +1,157 @@
|
||||
fun assertTrue(cond: Boolean) {
|
||||
if (!cond)
|
||||
println("FAIL")
|
||||
}
|
||||
|
||||
fun assertFalse(cond: Boolean) {
|
||||
if (cond)
|
||||
println("FAIL")
|
||||
}
|
||||
|
||||
fun assertEquals(value1: Any?, value2: Any?) {
|
||||
if (value1 != value2)
|
||||
println("FAIL")
|
||||
}
|
||||
|
||||
fun assertEquals(value1: Int, value2: Int) {
|
||||
if (value1 != value2)
|
||||
println("FAIL")
|
||||
}
|
||||
|
||||
|
||||
fun testBasic() {
|
||||
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)
|
||||
}
|
||||
|
||||
fun testRehashAndCompact() {
|
||||
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())
|
||||
}
|
||||
}
|
||||
|
||||
fun testClear() {
|
||||
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()))
|
||||
}
|
||||
}
|
||||
}
|
||||
// 'to' not yet working.
|
||||
/*
|
||||
fun testEquals() {
|
||||
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, expected.values)
|
||||
assertEquals(m.entries, expected.entries)
|
||||
} */
|
||||
|
||||
fun main(args : Array<String>) {
|
||||
testBasic()
|
||||
testRehashAndCompact()
|
||||
testClear()
|
||||
//testEquals()
|
||||
println("OK")
|
||||
}
|
||||
@@ -0,0 +1,131 @@
|
||||
fun assertTrue(cond: Boolean) {
|
||||
if (!cond)
|
||||
println("FAIL")
|
||||
}
|
||||
|
||||
fun assertFalse(cond: Boolean) {
|
||||
if (cond)
|
||||
println("FAIL")
|
||||
}
|
||||
|
||||
fun assertEquals(value1: Any?, value2: Any?) {
|
||||
if (value1 != value2)
|
||||
println("FAIL")
|
||||
}
|
||||
|
||||
fun assertEquals(value1: Int, value2: Int) {
|
||||
if (value1 != value2)
|
||||
println("FAIL")
|
||||
}
|
||||
|
||||
fun testBasic() {
|
||||
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"))
|
||||
}
|
||||
|
||||
fun testIterator() {
|
||||
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())
|
||||
}
|
||||
|
||||
fun testEquals() {
|
||||
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"))
|
||||
}
|
||||
|
||||
fun testHashCode() {
|
||||
val s = HashSet(listOf("1", "2", "3"))
|
||||
assertTrue(s.hashCode() == setOf("1", "2", "3").hashCode())
|
||||
}
|
||||
|
||||
fun testToString() {
|
||||
val s = HashSet(listOf("1", "2", "3"))
|
||||
assertTrue(s.toString() == setOf("1", "2", "3").toString())
|
||||
}
|
||||
|
||||
fun testContainsAll() {
|
||||
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")))
|
||||
}
|
||||
|
||||
fun testRemoveAll() {
|
||||
val s = HashSet(listOf("1", "2", "3", "4", "5"))
|
||||
assertFalse(s.removeAll(listOf("6", "7", "8")))
|
||||
assertEquals(setOf("1", "2", "3", "4", "5"), s)
|
||||
assertTrue(s.removeAll(listOf("5", "3", "1")))
|
||||
assertEquals(setOf("2", "4"), s)
|
||||
}
|
||||
|
||||
fun testRetainAll() {
|
||||
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)
|
||||
}
|
||||
|
||||
fun main(args : Array<String>) {
|
||||
testBasic()
|
||||
testIterator()
|
||||
testEquals()
|
||||
testHashCode()
|
||||
testToString()
|
||||
testContainsAll()
|
||||
testRemoveAll()
|
||||
testRetainAll()
|
||||
println("OK")
|
||||
}
|
||||
Reference in New Issue
Block a user