Fix tests for concurrent connection wrapper

Author: kpgalligan

SQLiter/src/commonMain/kotlin/co/touchlab/sqliter/concurrency/ConcurrentDatabaseConnection.kt

@@ -66,7 +66,7 @@ class ConcurrentDatabaseConnection(private val delegateConnection:DatabaseConnec
 
     }
 
-    inner class ConcurrentStatement(private val delegateStatement:Statement):Statement{
+    inner class ConcurrentStatement(internal val delegateStatement:Statement):Statement{
         override fun execute() = accessLock.withLock { delegateStatement.execute() }
 
         override fun executeInsert(): Long = accessLock.withLock { delegateStatement.executeInsert() }

SQLiter/src/nativeCommonTest/kotlin/co/touchlab/sqliter/DatabaseConnectionTest.kt

@@ -17,6 +17,7 @@
 package co.touchlab.sqliter
 
 import co.touchlab.sqliter.NativeFileContext.deleteDatabase
+import co.touchlab.sqliter.concurrency.ConcurrentDatabaseConnection
 import kotlin.test.*
 
 class DatabaseConnectionTest {
@@ -70,16 +71,23 @@ class DatabaseConnectionTest {
     fun sameStatementSqlDifferentInstances() {
         basicTestDb(TWO_COL) {
             it.withConnection {
+                println("a 1")
                 val s1 = it.createStatement("INSERT INTO test(num, str)values(?,?)")
+                println("a 2")
                 val s2 = it.createStatement("INSERT INTO test(num, str)values(?,?)")
+                println("a 3")
                 assertNotSame(s1, s2)
+                println("a 4")
                 assertNotEquals(
-                    (s1 as NativeStatement).nativePointer,
-                    (s2 as NativeStatement).nativePointer
+                    ((s1 as ConcurrentDatabaseConnection.ConcurrentStatement).delegateStatement as NativeStatement).nativePointer,
+                    ((s2 as ConcurrentDatabaseConnection.ConcurrentStatement).delegateStatement as NativeStatement).nativePointer
                 )
+                println("a 5")
 
                 s1.finalizeStatement()
+                println("a 6")
                 s2.finalizeStatement()
+                println("a 7")
             }
         }
     }

SQLiter/src/nativeCommonTest/kotlin/co/touchlab/sqliter/DatabaseManagerTest.kt

@@ -16,6 +16,7 @@
 
 package co.touchlab.sqliter
 
+import kotlin.native.concurrent.AtomicInt
 import kotlin.test.*
 
 class DatabaseManagerTest : BaseDatabaseTest(){
@@ -36,21 +37,21 @@ class DatabaseManagerTest : BaseDatabaseTest(){
 
     @Test
     fun createUpdateCalled(){
-        var createCalled = 0
-        var updateCalled = 0
+        val createCalled = AtomicInt(0)
+        var updateCalled = AtomicInt(0)
 
         val config1 = DatabaseConfiguration(
             name = TEST_DB_NAME,
             version = 1,
             create = { db ->
                 db.withStatement(TWO_COL) {
-                    createCalled++
+                    createCalled.increment()
                     println("createCalled $createCalled")
                     execute()
                 }
             },
             upgrade = { _, _, _ ->
-                updateCalled++
+                updateCalled.increment()
                 println("updateCalled $updateCalled")
             }
         )
@@ -59,30 +60,30 @@ class DatabaseManagerTest : BaseDatabaseTest(){
 
         val db1 = createDatabaseManager(config1)
 
-        assertEquals(0, createCalled)
+        assertEquals(0, createCalled.value)
         db1.withConnection {  }
-        assertEquals(1, createCalled)
-        assertEquals(0, updateCalled)
+        assertEquals(1, createCalled.value)
+        assertEquals(0, updateCalled.value)
         db1.withConnection {  }
-        assertEquals(1, createCalled)
+        assertEquals(1, createCalled.value)
 
         val db2 = createDatabaseManager(config2)
 
-        assertEquals(0, updateCalled)
+        assertEquals(0, updateCalled.value)
         db2.withConnection {  }
-        assertEquals(1, createCalled)
-        assertEquals(1, updateCalled)
+        assertEquals(1, createCalled.value)
+        assertEquals(1, updateCalled.value)
 
         val db3 = createDatabaseManager(config2)
 
         db3.withConnection {  }
-        assertEquals(1, createCalled)
-        assertEquals(1, updateCalled)
+        assertEquals(1, createCalled.value)
+        assertEquals(1, updateCalled.value)
     }
 
     @Test
     fun downgradeNotAllowed(){
-        var upgradeCalled = 0
+        val upgradeCalled = AtomicInt(0)
         val config1 = DatabaseConfiguration(
             name = TEST_DB_NAME,
             version = 1,
@@ -92,14 +93,14 @@ class DatabaseManagerTest : BaseDatabaseTest(){
                 }
             },
             upgrade = { _, _, _ ->
-                upgradeCalled++
+                upgradeCalled.increment()
             }
         )
 
         createDatabaseManager(config1).withConnection {  }
-        assertEquals(0, upgradeCalled)
+        assertEquals(0, upgradeCalled.value)
         createDatabaseManager(config1.copy(version = 2)).withConnection {  }
-        assertEquals(1, upgradeCalled)
+        assertEquals(1, upgradeCalled.value)
         assertFails {
             createDatabaseManager(config1.copy(version = 1)).withConnection {  }
         }