assertEstimations for signed and unsigned integer types

Author: Kopilov

dataframe-arrow/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/arrow.kt

@@ -139,8 +139,8 @@ public fun DataFrame.Companion.readArrowFeather(channel: SeekableByteChannel, al
 
 private fun BitVector.values(range: IntRange): List<Boolean?> = range.map { getObject(it) }
 
-private fun UInt1Vector.values(range: IntRange): List<Byte?> = range.map { getObject(it) }
-private fun UInt2Vector.values(range: IntRange): List<Char?> = range.map { getObject(it) }
+private fun UInt1Vector.values(range: IntRange): List<Short?> = range.map { getObjectNoOverflow(it) }
+private fun UInt2Vector.values(range: IntRange): List<Int?> = range.map { getObject(it).code }
 private fun UInt4Vector.values(range: IntRange): List<Long?> = range.map { getObjectNoOverflow(it) }
 private fun UInt8Vector.values(range: IntRange): List<BigInteger?> = range.map { getObjectNoOverflow(it) }
 

dataframe-arrow/src/test/kotlin/exampleEstimatesAssertions.kt

@@ -3,6 +3,8 @@ import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.api.forEach
 import org.jetbrains.kotlinx.dataframe.api.forEachIndexed
+import java.math.BigInteger
+import kotlin.math.absoluteValue
 import kotlin.reflect.typeOf
 
 /**
@@ -22,20 +24,71 @@ internal fun assertEstimations(exampleFrame: AnyFrame) {
         element shouldBe "Test Example ${iBatch(i)}"
     }
 
-    val utf8StringCol = exampleFrame["utf8String"]
-    val largeStringCol = exampleFrame["largeString"]
+    val utf8StringCol = exampleFrame["utf8String"] as DataColumn<String?>
+    utf8StringCol.type() shouldBe typeOf<String?>()
+    utf8StringCol.forEachIndexed { i, element ->
+        element shouldBe "Тестовый пример ${iBatch(i)}"
+    }
+
+    val largeStringCol = exampleFrame["largeString"] as DataColumn<String?>
+    largeStringCol.type() shouldBe typeOf<String?>()
+    largeStringCol.forEachIndexed { i, element ->
+        element shouldBe "Test Example Should Be Large ${iBatch(i)}"
+    }
+
+    val booleanCol = exampleFrame["boolean"] as DataColumn<Boolean?>
+    booleanCol.type() shouldBe typeOf<Boolean?>()
+    booleanCol.forEachIndexed { i, element ->
+        element shouldBe (iBatch(i) % 2 == 0)
+    }
+
+    val byteCol = exampleFrame["byte"] as DataColumn<Byte?>
+    byteCol.type() shouldBe typeOf<Byte?>()
+    byteCol.forEachIndexed { i, element ->
+        element shouldBe (iBatch(i) * 10).toByte()
+    }
+
+    val shortCol = exampleFrame["short"] as DataColumn<Short?>
+    shortCol.type() shouldBe typeOf<Short?>()
+    shortCol.forEachIndexed { i, element ->
+        element shouldBe (iBatch(i) * 1000).toShort()
+    }
 
-    val booleanCol = exampleFrame["boolean"]
+    val intCol = exampleFrame["int"] as DataColumn<Int?>
+    intCol.type() shouldBe typeOf<Int?>()
+    intCol.forEachIndexed { i, element ->
+        element shouldBe (iBatch(i) * 100000000).toInt()
+    }
 
-    val byteCol = exampleFrame["byte"]
-    val shortCol = exampleFrame["short"]
-    val intCol = exampleFrame["int"]
-    val longIntCol = exampleFrame["longInt"]
+    val longCol = exampleFrame["longInt"] as DataColumn<Long?>
+    longCol.type() shouldBe typeOf<Long?>()
+    longCol.forEachIndexed { i, element ->
+        element shouldBe iBatch(i) * 100000000000000000L
+    }
 
-    val unsignedByteCol = exampleFrame["unsigned_byte"]
-    val unsignedShortCol = exampleFrame["unsigned_short"]
-    val unsignedIntCol = exampleFrame["unsigned_int"]
-    val unsignedLongIntCol = exampleFrame["unsigned_longInt"]
+    val unsignedByteCol = exampleFrame["unsigned_byte"] as DataColumn<Short?>
+    unsignedByteCol.type() shouldBe typeOf<Short?>()
+    unsignedByteCol.forEachIndexed { i, element ->
+        element shouldBe (iBatch(i) * 10 % (Byte.MIN_VALUE.toShort() * 2).absoluteValue).toShort()
+    }
+
+    val unsignedShortCol = exampleFrame["unsigned_short"] as DataColumn<Int?>
+    unsignedShortCol.type() shouldBe typeOf<Int?>()
+    unsignedShortCol.forEachIndexed { i, element ->
+        element shouldBe (iBatch(i) * 1000 % (Short.MIN_VALUE.toInt() * 2).absoluteValue)
+    }
+
+    val unsignedIntCol = exampleFrame["unsigned_int"] as DataColumn<Long?>
+    unsignedIntCol.type() shouldBe typeOf<Long?>()
+    unsignedIntCol.forEachIndexed { i, element ->
+        element shouldBe (iBatch(i).toLong() * 100000000 % (Int.MIN_VALUE.toLong() * 2).absoluteValue)
+    }
+
+    val unsignedLongIntCol = exampleFrame["unsigned_longInt"] as DataColumn<BigInteger?>
+    unsignedLongIntCol.type() shouldBe typeOf<BigInteger?>()
+    unsignedLongIntCol.forEachIndexed { i, element ->
+        element shouldBe (iBatch(i).toBigInteger() * 100000000000000000L.toBigInteger() % (Long.MIN_VALUE.toBigInteger() * 2.toBigInteger()).abs())
+    }
 
     val dateCol = exampleFrame["date32"]
     val datetimeCol = exampleFrame["date64"]