!fix Long.encodeToHex bug, rewritten with new types

+fast BitSet set with enums support

src/commonTest/kotlin/bipack/StorageTest.kt

@@ -1,14 +1,17 @@
 package bipack
 
 import net.sergeych.bintools.*
+import net.sergeych.collections.bitSetOf
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
 import kotlin.test.assertNull
 
 class StorageTest {
     @Test
     fun storageTest3() {
         val s1 = MemoryKVStorage()
+
         val s2 = defaultNamedStorage("test_mp_bintools2")
         s2.clear()
 
@@ -41,4 +44,17 @@ class StorageTest {
         assertEquals(42, s1.read("reason"))
         assertEquals(42, reason)
     }
+
+    @Test
+    fun bitSetEquityTest() {
+        val a = bitSetOf(1, 12)
+        val b = bitSetOf(12, 1)
+        assertEquals(a, b)
+        assertEquals(b, a)
+        a += 1230
+        assertFalse { a == b }
+        a -= 1230
+        assertEquals(a, b)
+        assertEquals(b, a)
+    }
 }

src/commonTest/kotlin/collections/CollectionsTest.kt

@@ -6,8 +6,9 @@ import kotlinx.coroutines.test.advanceTimeBy
 import kotlinx.coroutines.test.resetMain
 import kotlinx.coroutines.test.runTest
 import kotlinx.coroutines.test.setMain
-import net.sergeych.collections.ExpirableAsyncCache
-import net.sergeych.collections.SortedList
+import net.sergeych.bintools.toDump
+import net.sergeych.bipack.BipackEncoder
+import net.sergeych.collections.*
 import kotlin.test.*
 import kotlin.time.Duration.Companion.milliseconds
 
@@ -15,14 +16,14 @@ class CollectionsTest {
 
     @Test
     fun testSortedList1() {
-        val a1 = SortedList(5,4,3,9,1)
+        val a1 = SortedList(5, 4, 3, 9, 1)
         assertTrue { 4 in a1 }
         assertTrue { 14 !in a1 }
-        fun <T: Comparable<T>>test(x: SortedList<T>) {
+        fun <T : Comparable<T>> test(x: SortedList<T>) {
             var last: T? = null
             for (i in x.toList()) {
-                if( last == null ) last = i
-                else if( last > i ) fail("invalid order: $last should be <= $i")
+                if (last == null) last = i
+                else if (last > i) fail("invalid order: $last should be <= $i")
                 assertContains(x, i)
             }
         }
@@ -31,16 +32,16 @@ class CollectionsTest {
         println(a1.toList())
         assertEquals(listOf(-55, 0, 0, 0, 1, 1, 1, 2, 3, 3, 4, 5, 9, 9, 11, 22), a1.toList())
         assertEquals(11, a1.find(11))
-        assertEquals(listOf(0,0,0), a1.findAll(0))
+        assertEquals(listOf(0, 0, 0), a1.findAll(0))
         assertEquals(listOf(11), a1.findAll(11))
-        assertEquals(listOf(3,3), a1.findAll(3))
+        assertEquals(listOf(3, 3), a1.findAll(3))
         assertTrue { a1.remove(3) }
         assertEquals(listOf(3), a1.findAll(3))
         assertTrue { a1.remove(3) }
         assertEquals(listOf(), a1.findAll(3))
         assertTrue { 3 !in a1 }
         assertEquals(3, a1.findAll(1).size)
-        assertEquals( 3, a1.removeAll(1))
+        assertEquals(3, a1.removeAll(1))
         assertTrue { 1 !in a1 }
         assertEquals(listOf(-55, 0, 0, 0, 2, 4, 5, 9, 9, 11, 22), a1.toList())
     }
@@ -49,7 +50,7 @@ class CollectionsTest {
     @Test
     fun expirableAsyncCacheTest() = runTest {
         val removedValues = mutableSetOf<Int>()
-        val m = ExpirableAsyncCache<String,Int>(500.milliseconds) {
+        val m = ExpirableAsyncCache<String, Int>(500.milliseconds) {
             removedValues += it
         }
         m.put("one", 1)
@@ -67,7 +68,7 @@ class CollectionsTest {
         m.getOrDefault("two", 22)
         assertEquals(2, m.get("two"))
 
-        m.getOrPut("two") {222}
+        m.getOrPut("two") { 222 }
         assertEquals(2, m.get("two"))
 
         m.getOrPut("three") { 3 }
@@ -78,4 +79,88 @@ class CollectionsTest {
 //        delay(1000)
 //        assertNull(m.get("one"))
     }
+
+    enum class Nn {
+        One, Two, Three
+    }
+
+    @Test
+    fun bitsetTest() {
+        fun checkAdd(vararg values: Int) {
+            val x = bitSetOf(*values)
+            println(":: ${values.toList()}: ${x.toHex()}")
+            assertEquals(values.toSet(), x.toIntSet())
+            for (i in values) {
+                assertTrue(i in x, "failed $i in ${values.toList()}")
+            }
+        }
+        checkAdd(0, 1, 2, 3)
+        val src = intArrayOf(31, 32, 33, 60, 61, 62, 63, 64, 65)
+        checkAdd(*src)
+
+        assertEquals(src.toSet(), src.toBitSet().toIntSet())
+        assertFalse { src.toSet() != src.toBitSet() }
+        assertFalse { src.toSet() + 17 == src.toBitSet() }
+        assertEquals(src.toBitSet() + 17, src.toSet() + 17, )
+        assertTrue { src.toSet() + 17 == src.toBitSet() + 17 }
+        assertTrue { src.toBitSet() + 17 == src.toBitSet() + 17 }
+
+        var y = src.toBitSet() + 2
+        assertTrue { y.retainAll(setOf(1, 3, 31, 32, 33)) }
+        assertEquals(setOf(31, 32, 33), y.toIntSet())
+        assertFalse { y.retainAll(setOf(1, 3, 31, 32, 33)) }
+
+        y = src.toBitSet() + 2
+        for (i in setOf(2, 31, 32, 33))
+            assertTrue(i in y, "failed $i in ${y.toList()}")
+        assertTrue { y.retainAll(bitSetOf(1, 3, 31, 32, 33)) }
+        assertEquals(setOf(31, 32, 33), y.toIntSet())
+        assertFalse { y.retainAll(setOf(1, 3, 31, 32, 33)) }
+
+        var z = src.toBitSet() + 2
+        assertTrue { z.removeAll(setOf(31, 65)) }
+        assertEquals(listOf(2, 32, 33, 60, 61, 62, 63, 64), z.toList())
+        assertFalse { z.removeAll(setOf(31, 65)) }
+
+        z = src.toBitSet() + 2
+        assertTrue { z.removeAll(bitSetOf(31, 65)) }
+        assertEquals(listOf(2, 32, 33, 60, 61, 62, 63, 64), z.toList())
+        assertFalse { z.removeAll(setOf(31, 65)) }
+
+        z = src.toBitSet() + 2
+        assertTrue { z.removeAll(bitSetOf(31, 32)) }
+        assertEquals(listOf(2, 33, 60, 61, 62, 63, 64, 65), z.toList())
+        assertFalse { z.removeAll(setOf(31, 4)) }
+
+        assertTrue {
+            BipackEncoder.encode(src.toSet()).size > BipackEncoder.encode(src.toBitSet()).size
+        }
+
+        assertFalse { z includes Nn.Two }
+        assertTrue { z includes Nn.Three }
+        assertTrue { z + 1 includesAll listOf(Nn.Three, Nn.Two) }
+
+        assertEquals(setOf(Nn.One, Nn.Three), bitSetOf(0, 2).toEnumSet())
+        assertTrue { z + 1 includesAny setOf(Nn.One, Nn.Two) }
+    }
+
+    @Test
+    fun bitsetEnumsTest() {
+        val a = bitSetOfEnum(Nn.One)
+        assertTrue { a includes Nn.One }
+        assertFalse { a includes Nn.Two }
+        assertFalse { a includes Nn.Three }
+        a.insert(Nn.Three)
+        assertEquals(setOf(Nn.One, Nn.Three), a.toEnumSet())
+        a.delete(Nn.One)
+        assertEquals(setOf(Nn.Three), a.toEnumSet())
+        a.insertAll(listOf(Nn.Two, Nn.Three))
+        assertEquals(setOf(Nn.Two, Nn.Three), a.toEnumSet())
+        assertTrue { a includesAll listOf(Nn.Two, Nn.Three) }
+        assertFalse { a includesAll listOf(Nn.One, Nn.Two) }
+        assertTrue { a includesAny listOf(Nn.One, Nn.Two) }
+        a.deleteAll(listOf(Nn.Two, Nn.Three, Nn.One))
+        assertTrue { a.isEmpty() }
+        assertTrue { a.toEnumSet<Nn>().isEmpty() }
+    }
 }