refactor: migrate core modules to Kotlin Multiplatform and consolidat… (#4735)

Signed-off-by: James Rich <2199651+jamesarich@users.noreply.github.com>

core/domain/src/commonMain/kotlin/org/meshtastic/core/domain/usecase/settings/ExportDataUseCase.kt

@@ -16,15 +16,16 @@
  */
 package org.meshtastic.core.domain.usecase.settings
 
-import android.icu.text.SimpleDateFormat
 import kotlinx.coroutines.flow.first
+import kotlinx.datetime.Instant
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+import okio.BufferedSink
 import org.meshtastic.core.model.Position
 import org.meshtastic.core.model.util.positionToMeter
 import org.meshtastic.core.repository.MeshLogRepository
 import org.meshtastic.core.repository.NodeRepository
 import org.meshtastic.proto.PortNum
-import java.io.BufferedWriter
-import java.util.Locale
 import javax.inject.Inject
 import kotlin.math.roundToInt
 import org.meshtastic.proto.Position as ProtoPosition
@@ -37,14 +38,14 @@ constructor(
     private val meshLogRepository: MeshLogRepository,
 ) {
     /**
-     * Writes all persisted packet data to the provided [BufferedWriter].
+     * Writes all persisted packet data to the provided [BufferedSink].
      *
-     * @param writer The writer to output the CSV data to.
+     * @param sink The sink to output the CSV data to.
      * @param myNodeNum The node number of the current device.
      * @param filterPortnum If provided, only packets with this port number will be exported.
      */
     @Suppress("detekt:CyclomaticComplexMethod", "detekt:LongMethod", "detekt:NestedBlockDepth")
-    suspend operator fun invoke(writer: BufferedWriter, myNodeNum: Int, filterPortnum: Int? = null) {
+    suspend operator fun invoke(sink: BufferedSink, myNodeNum: Int, filterPortnum: Int? = null) {
         val nodes = nodeRepository.nodeDBbyNum.value
         val positionToPos: (ProtoPosition?) -> Position? = { meshPosition ->
             meshPosition?.let { Position(it) }?.takeIf { it.isValid() }
@@ -53,11 +54,10 @@ constructor(
         val nodePositions = mutableMapOf<Int, ProtoPosition?>()
 
         @Suppress("MaxLineLength")
-        writer.appendLine(
-            "\"date\",\"time\",\"from\",\"sender name\",\"sender lat\",\"sender long\",\"rx lat\",\"rx long\",\"rx elevation\",\"rx snr\",\"distance(m)\",\"hop limit\",\"payload\"",
+        sink.writeUtf8(
+            "\"date\",\"time\",\"from\",\"sender name\",\"sender lat\",\"sender long\",\"rx lat\",\"rx long\",\"rx elevation\",\"rx snr\",\"distance(m)\",\"hop limit\",\"payload\"\n",
         )
 
-        val dateFormat = SimpleDateFormat("\"yyyy-MM-dd\",\"HH:mm:ss\"", Locale.getDefault())
         meshLogRepository.getAllLogsInReceiveOrder(Int.MAX_VALUE).first().forEach { packet ->
             packet.nodeInfo?.let { nodeInfo ->
                 positionToPos.invoke(nodeInfo.position)?.let { nodePositions[nodeInfo.num] = nodeInfo.position }
@@ -74,7 +74,10 @@ constructor(
                     (filterPortnum == null || (proto.decoded?.portnum?.value ?: 0) == filterPortnum) &&
                     proto.rx_snr != 0.0f
                 ) {
-                    val rxDateTime = dateFormat.format(packet.received_date)
+                    val timeZone = TimeZone.currentSystemDefault()
+                    val rxDateTimeObj = Instant.fromEpochMilliseconds(packet.received_date).toLocalDateTime(timeZone)
+                    val timeString = rxDateTimeObj.time.toString().substringBefore('.')
+                    val rxDateTime = "\"${rxDateTimeObj.date}\",\"$timeString\""
                     val rxFrom = proto.from.toUInt()
                     val senderName = nodes[proto.from]?.user?.long_name ?: ""
 
@@ -112,11 +115,12 @@ constructor(
                         }
 
                     @Suppress("MaxLineLength")
-                    writer.appendLine(
-                        "$rxDateTime,\"$rxFrom\",\"$senderName\",\"$senderLat\",\"$senderLong\",\"$rxLat\",\"$rxLong\",\"$rxAlt\",\"$rxSnr\",\"$dist\",\"$hopLimit\",\"$payload\"",
+                    sink.writeUtf8(
+                        "$rxDateTime,\"$rxFrom\",\"$senderName\",\"$senderLat\",\"$senderLong\",\"$rxLat\",\"$rxLong\",\"$rxAlt\",\"$rxSnr\",\"$dist\",\"$hopLimit\",\"$payload\"\n",
                     )
                 }
             }
         }
+        sink.flush()
     }
 }

core/domain/src/commonMain/kotlin/org/meshtastic/core/domain/usecase/settings/ExportProfileUseCase.kt

@@ -16,20 +16,21 @@
  */
 package org.meshtastic.core.domain.usecase.settings
 
+import okio.BufferedSink
 import org.meshtastic.proto.DeviceProfile
-import java.io.OutputStream
 import javax.inject.Inject
 
 /** Use case for exporting a device profile to an output stream. */
 open class ExportProfileUseCase @Inject constructor() {
     /**
-     * Exports the provided [DeviceProfile] to the given [OutputStream].
+     * Exports the provided [DeviceProfile] to the given [BufferedSink].
      *
-     * @param outputStream The stream to write the profile to.
+     * @param sink The sink to write the profile to.
      * @param profile The device profile to export.
      * @return A [Result] indicating success or failure.
      */
-    operator fun invoke(outputStream: OutputStream, profile: DeviceProfile): Result<Unit> = runCatching {
-        outputStream.write(profile.encode())
+    operator fun invoke(sink: BufferedSink, profile: DeviceProfile): Result<Unit> = runCatching {
+        sink.write(profile.encode())
+        sink.flush()
     }
 }

core/domain/src/commonMain/kotlin/org/meshtastic/core/domain/usecase/settings/ExportSecurityConfigUseCase.kt

@@ -16,43 +16,36 @@
  */
 package org.meshtastic.core.domain.usecase.settings
 
-import android.util.Base64
-import org.json.JSONObject
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.put
+import okio.BufferedSink
 import org.meshtastic.core.common.util.nowMillis
 import org.meshtastic.proto.Config
-import java.io.OutputStream
 import javax.inject.Inject
 
 /** Use case for exporting security configuration to a JSON format. */
 open class ExportSecurityConfigUseCase @Inject constructor() {
     /**
-     * Exports the provided [Config.SecurityConfig] as a JSON string to the given [OutputStream].
+     * Exports the provided [Config.SecurityConfig] as a JSON string to the given [BufferedSink].
      *
-     * @param outputStream The stream to write the JSON to.
+     * @param sink The sink to write the JSON to.
      * @param securityConfig The security configuration to export.
      * @return A [Result] indicating success or failure.
      */
-    operator fun invoke(outputStream: OutputStream, securityConfig: Config.SecurityConfig): Result<Unit> = runCatching {
-        val publicKeyBytes = securityConfig.public_key.toByteArray()
-        val privateKeyBytes = securityConfig.private_key.toByteArray()
-
-        // Convert byte arrays to Base64 strings
-        val publicKeyBase64 = Base64.encodeToString(publicKeyBytes, Base64.NO_WRAP)
-        val privateKeyBase64 = Base64.encodeToString(privateKeyBytes, Base64.NO_WRAP)
+    operator fun invoke(sink: BufferedSink, securityConfig: Config.SecurityConfig): Result<Unit> = runCatching {
+        // Convert ByteStrings to Base64 strings
+        val publicKeyBase64 = securityConfig.public_key.base64()
+        val privateKeyBase64 = securityConfig.private_key.base64()
 
         // Create a JSON object
-        val jsonObject =
-            JSONObject().apply {
-                put("timestamp", nowMillis)
-                put("public_key", publicKeyBase64)
-                put("private_key", privateKeyBase64)
-            }
+        val jsonObject = buildJsonObject {
+            put("timestamp", nowMillis)
+            put("public_key", publicKeyBase64)
+            put("private_key", privateKeyBase64)
+        }
 
-        val jsonString = jsonObject.toString(JSON_INDENT_SPACES)
-        outputStream.write(jsonString.toByteArray(Charsets.UTF_8))
-    }
-
-    private companion object {
-        private const val JSON_INDENT_SPACES = 4
+        val jsonString = jsonObject.toString()
+        sink.writeUtf8(jsonString)
+        sink.flush()
     }
 }

core/domain/src/commonMain/kotlin/org/meshtastic/core/domain/usecase/settings/ImportProfileUseCase.kt

@@ -16,20 +16,20 @@
  */
 package org.meshtastic.core.domain.usecase.settings
 
+import okio.BufferedSource
 import org.meshtastic.proto.DeviceProfile
-import java.io.InputStream
 import javax.inject.Inject
 
 /** Use case for importing a device profile from an input stream. */
 open class ImportProfileUseCase @Inject constructor() {
     /**
-     * Imports a [DeviceProfile] from the provided [InputStream].
+     * Imports a [DeviceProfile] from the provided [BufferedSource].
      *
-     * @param inputStream The stream to read the profile from.
+     * @param source The source to read the profile from.
      * @return A [Result] containing the imported [DeviceProfile] or an error.
      */
-    operator fun invoke(inputStream: InputStream): Result<DeviceProfile> = runCatching {
-        val bytes = inputStream.readBytes()
+    operator fun invoke(source: BufferedSource): Result<DeviceProfile> = runCatching {
+        val bytes = source.readByteArray()
         DeviceProfile.ADAPTER.decode(bytes)
     }
 }

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/SendMessageUseCaseTest.kt

@@ -24,11 +24,6 @@ import io.mockk.slot
 import io.mockk.unmockkAll
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.test.runTest
-import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.domain.FakeRadioController
 import org.meshtastic.core.model.Capabilities
 import org.meshtastic.core.model.DataPacket
@@ -40,6 +35,11 @@ import org.meshtastic.core.repository.PacketRepository
 import org.meshtastic.core.repository.usecase.SendMessageUseCase
 import org.meshtastic.proto.Config
 import org.meshtastic.proto.DeviceMetadata
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
 
 class SendMessageUseCaseTest {
 
@@ -50,7 +50,7 @@ class SendMessageUseCaseTest {
     private lateinit var messageQueue: MessageQueue
     private lateinit var useCase: SendMessageUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         nodeRepository = mockk(relaxed = true)
         packetRepository = mockk(relaxed = true)
@@ -70,7 +70,7 @@ class SendMessageUseCaseTest {
         mockkConstructor(Capabilities::class)
     }
 
-    @After
+    @AfterTest
     fun tearDown() {
         unmockkAll()
     }

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/AdminActionsUseCaseTest.kt

@@ -20,11 +20,11 @@ import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockk
 import kotlinx.coroutines.test.runTest
-import org.junit.Assert.assertEquals
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.model.RadioController
 import org.meshtastic.core.repository.NodeRepository
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
 
 class AdminActionsUseCaseTest {
 
@@ -32,7 +32,7 @@ class AdminActionsUseCaseTest {
     private lateinit var nodeRepository: NodeRepository
     private lateinit var useCase: AdminActionsUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         radioController = mockk(relaxed = true)
         nodeRepository = mockk(relaxed = true)

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/CleanNodeDatabaseUseCaseTest.kt

@@ -20,12 +20,12 @@ import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.mockk
 import kotlinx.coroutines.test.runTest
-import org.junit.Assert.assertEquals
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.domain.FakeRadioController
 import org.meshtastic.core.model.Node
 import org.meshtastic.core.repository.NodeRepository
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
 import kotlin.time.Duration.Companion.days
 
 class CleanNodeDatabaseUseCaseTest {
@@ -34,7 +34,7 @@ class CleanNodeDatabaseUseCaseTest {
     private lateinit var radioController: FakeRadioController
     private lateinit var useCase: CleanNodeDatabaseUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         nodeRepository = mockk(relaxed = true)
         radioController = FakeRadioController()

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/ExportDataUseCaseTest.kt

@@ -21,11 +21,8 @@ import io.mockk.mockk
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.test.runTest
+import okio.Buffer
 import okio.ByteString.Companion.encodeUtf8
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Test
-import org.junit.runner.RunWith
 import org.meshtastic.core.database.entity.MeshLog
 import org.meshtastic.core.model.Node
 import org.meshtastic.core.repository.MeshLogRepository
@@ -35,18 +32,17 @@ import org.meshtastic.proto.FromRadio
 import org.meshtastic.proto.MeshPacket
 import org.meshtastic.proto.PortNum
 import org.meshtastic.proto.User
-import org.robolectric.RobolectricTestRunner
-import java.io.BufferedWriter
-import java.io.StringWriter
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertTrue
 
-@RunWith(RobolectricTestRunner::class)
 class ExportDataUseCaseTest {
 
     private lateinit var nodeRepository: NodeRepository
     private lateinit var meshLogRepository: MeshLogRepository
     private lateinit var useCase: ExportDataUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         nodeRepository = mockk(relaxed = true)
         meshLogRepository = mockk(relaxed = true)
@@ -82,17 +78,15 @@ class ExportDataUseCaseTest {
             )
         every { meshLogRepository.getAllLogsInReceiveOrder(any()) } returns flowOf(listOf(meshLog))
 
-        val stringWriter = StringWriter()
-        val bufferedWriter = BufferedWriter(stringWriter)
+        val buffer = Buffer()
 
         // Act
-        useCase(bufferedWriter, myNodeNum)
-        bufferedWriter.flush()
+        useCase(buffer, myNodeNum)
 
         // Assert
-        val output = stringWriter.toString()
-        assertTrue("Header should be present", output.contains("\"date\",\"time\",\"from\",\"sender name\""))
-        assertTrue("Sender name should be present", output.contains("Sender Name"))
-        assertTrue("Payload should be present", output.contains("Hello"))
+        val output = buffer.readUtf8()
+        assertTrue(output.contains("\"date\",\"time\",\"from\",\"sender name\""), "Header should be present")
+        assertTrue(output.contains("Sender Name"), "Sender name should be present")
+        assertTrue(output.contains("Hello"), "Payload should be present")
     }
 }

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/ExportProfileUseCaseTest.kt

@@ -16,18 +16,18 @@
  */
 package org.meshtastic.core.domain.usecase.settings
 
-import org.junit.Assert.assertArrayEquals
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Test
+import okio.Buffer
 import org.meshtastic.proto.DeviceProfile
-import java.io.ByteArrayOutputStream
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertTrue
 
 class ExportProfileUseCaseTest {
 
     private lateinit var useCase: ExportProfileUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         useCase = ExportProfileUseCase()
     }
@@ -36,13 +36,13 @@ class ExportProfileUseCaseTest {
     fun `invoke writes encoded profile to output stream`() {
         // Arrange
         val profile = DeviceProfile(long_name = "Export Node")
-        val outputStream = ByteArrayOutputStream()
+        val buffer = Buffer()
 
         // Act
-        val result = useCase(outputStream, profile)
+        val result = useCase(buffer, profile)
 
         // Assert
         assertTrue(result.isSuccess)
-        assertArrayEquals(profile.encode(), outputStream.toByteArray())
+        assertContentEquals(profile.encode(), buffer.readByteArray())
     }
 }

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/ExportSecurityConfigUseCaseTest.kt

@@ -16,23 +16,22 @@
  */
 package org.meshtastic.core.domain.usecase.settings
 
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import okio.Buffer
 import okio.ByteString.Companion.toByteString
-import org.json.JSONObject
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Test
-import org.junit.runner.RunWith
 import org.meshtastic.proto.Config
-import org.robolectric.RobolectricTestRunner
-import java.io.ByteArrayOutputStream
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
 
-@RunWith(RobolectricTestRunner::class)
 class ExportSecurityConfigUseCaseTest {
 
     private lateinit var useCase: ExportSecurityConfigUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         useCase = ExportSecurityConfigUseCase()
     }
@@ -43,19 +42,19 @@ class ExportSecurityConfigUseCaseTest {
         val publicKey = byteArrayOf(1, 2, 3).toByteString()
         val privateKey = byteArrayOf(4, 5, 6).toByteString()
         val config = Config.SecurityConfig(public_key = publicKey, private_key = privateKey)
-        val outputStream = ByteArrayOutputStream()
+        val buffer = Buffer()
 
         // Act
-        val result = useCase(outputStream, config)
+        val result = useCase(buffer, config)
 
         // Assert
         assertTrue(result.isSuccess)
-        val json = JSONObject(outputStream.toString())
-        assertTrue(json.has("timestamp"))
-        assertTrue(json.has("public_key"))
-        assertTrue(json.has("private_key"))
+        val json = Json.parseToJsonElement(buffer.readUtf8()).jsonObject
+        assertTrue(json.containsKey("timestamp"))
+        assertTrue(json.containsKey("public_key"))
+        assertTrue(json.containsKey("private_key"))
         // Check base64 values
-        assertEquals("AQID", json.getString("public_key"))
-        assertEquals("BAUG", json.getString("private_key"))
+        assertEquals("AQID", json["public_key"]?.jsonPrimitive?.content)
+        assertEquals("BAUG", json["private_key"]?.jsonPrimitive?.content)
     }
 }

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/ImportProfileUseCaseTest.kt

@@ -16,18 +16,18 @@
  */
 package org.meshtastic.core.domain.usecase.settings
 
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Test
+import okio.Buffer
 import org.meshtastic.proto.DeviceProfile
-import java.io.ByteArrayInputStream
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
 
 class ImportProfileUseCaseTest {
 
     private lateinit var useCase: ImportProfileUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         useCase = ImportProfileUseCase()
     }
@@ -36,10 +36,10 @@ class ImportProfileUseCaseTest {
     fun `invoke with valid data returns profile`() {
         // Arrange
         val profile = DeviceProfile(long_name = "Test Node")
-        val inputStream = ByteArrayInputStream(profile.encode())
+        val buffer = Buffer().write(profile.encode())
 
         // Act
-        val result = useCase(inputStream)
+        val result = useCase(buffer)
 
         // Assert
         assertTrue(result.isSuccess)
@@ -49,10 +49,10 @@ class ImportProfileUseCaseTest {
     @Test
     fun `invoke with invalid data returns failure`() {
         // Arrange
-        val inputStream = ByteArrayInputStream(byteArrayOf(1, 2, 3))
+        val buffer = Buffer().write(byteArrayOf(1, 2, 3))
 
         // Act
-        val result = useCase(inputStream)
+        val result = useCase(buffer)
 
         // Assert
         assertTrue(result.isFailure)

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/InstallProfileUseCaseTest.kt

@@ -20,8 +20,6 @@ import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockk
 import kotlinx.coroutines.test.runTest
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.model.RadioController
 import org.meshtastic.proto.Config
 import org.meshtastic.proto.DeviceProfile
@@ -29,13 +27,15 @@ import org.meshtastic.proto.LocalConfig
 import org.meshtastic.proto.LocalModuleConfig
 import org.meshtastic.proto.ModuleConfig
 import org.meshtastic.proto.User
+import kotlin.test.BeforeTest
+import kotlin.test.Test
 
 class InstallProfileUseCaseTest {
 
     private lateinit var radioController: RadioController
     private lateinit var useCase: InstallProfileUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         radioController = mockk(relaxed = true)
         useCase = InstallProfileUseCase(radioController)

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/IsOtaCapableUseCaseTest.kt

@@ -22,16 +22,16 @@ import io.mockk.every
 import io.mockk.mockk
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.test.runTest
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.model.ConnectionState
 import org.meshtastic.core.model.Node
 import org.meshtastic.core.model.RadioController
 import org.meshtastic.core.repository.DeviceHardwareRepository
 import org.meshtastic.core.repository.NodeRepository
 import org.meshtastic.core.repository.RadioPrefs
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 
 class IsOtaCapableUseCaseTest {
 
@@ -44,7 +44,7 @@ class IsOtaCapableUseCaseTest {
     private val ourNodeInfoFlow = MutableStateFlow<Node?>(null)
     private val connectionStateFlow = MutableStateFlow<ConnectionState>(ConnectionState.Disconnected)
 
-    @Before
+    @BeforeTest
     fun setUp() {
         nodeRepository = mockk { every { ourNodeInfo } returns ourNodeInfoFlow }
         radioController = mockk { every { connectionState } returns connectionStateFlow }

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/MeshLocationUseCaseTest.kt

@@ -18,16 +18,16 @@ package org.meshtastic.core.domain.usecase.settings
 
 import io.mockk.mockk
 import io.mockk.verify
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.model.RadioController
+import kotlin.test.BeforeTest
+import kotlin.test.Test
 
 class MeshLocationUseCaseTest {
 
     private lateinit var radioController: RadioController
     private lateinit var useCase: MeshLocationUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         radioController = mockk(relaxed = true)
         useCase = MeshLocationUseCase(radioController)

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/ProcessRadioResponseUseCaseTest.kt

@@ -16,22 +16,22 @@
  */
 package org.meshtastic.core.domain.usecase.settings
 
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.proto.AdminMessage
 import org.meshtastic.proto.Data
 import org.meshtastic.proto.DeviceMetadata
 import org.meshtastic.proto.MeshPacket
 import org.meshtastic.proto.PortNum
 import org.meshtastic.proto.Routing
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
 
 class ProcessRadioResponseUseCaseTest {
 
     private lateinit var useCase: ProcessRadioResponseUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         useCase = ProcessRadioResponseUseCase()
     }

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/RadioConfigUseCaseTest.kt

@@ -20,22 +20,22 @@ import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockk
 import kotlinx.coroutines.test.runTest
-import org.junit.Assert.assertEquals
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.model.Position
 import org.meshtastic.core.model.RadioController
 import org.meshtastic.proto.Channel
 import org.meshtastic.proto.Config
 import org.meshtastic.proto.ModuleConfig
 import org.meshtastic.proto.User
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
 
 class RadioConfigUseCaseTest {
 
     private lateinit var radioController: RadioController
     private lateinit var useCase: RadioConfigUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         radioController = mockk(relaxed = true)
         useCase = RadioConfigUseCase(radioController)

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/SetAppIntroCompletedUseCaseTest.kt

@@ -18,16 +18,16 @@ package org.meshtastic.core.domain.usecase.settings
 
 import io.mockk.mockk
 import io.mockk.verify
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.datastore.UiPreferencesDataSource
+import kotlin.test.BeforeTest
+import kotlin.test.Test
 
 class SetAppIntroCompletedUseCaseTest {
 
     private lateinit var uiPreferencesDataSource: UiPreferencesDataSource
     private lateinit var useCase: SetAppIntroCompletedUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         uiPreferencesDataSource = mockk(relaxed = true)
         useCase = SetAppIntroCompletedUseCase(uiPreferencesDataSource)

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/SetDatabaseCacheLimitUseCaseTest.kt

@@ -18,17 +18,17 @@ package org.meshtastic.core.domain.usecase.settings
 
 import io.mockk.mockk
 import io.mockk.verify
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.common.database.DatabaseManager
 import org.meshtastic.core.database.DatabaseConstants
+import kotlin.test.BeforeTest
+import kotlin.test.Test
 
 class SetDatabaseCacheLimitUseCaseTest {
 
     private lateinit var databaseManager: DatabaseManager
     private lateinit var useCase: SetDatabaseCacheLimitUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         databaseManager = mockk(relaxed = true)
         useCase = SetDatabaseCacheLimitUseCase(databaseManager)

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/SetMeshLogSettingsUseCaseTest.kt

@@ -21,10 +21,10 @@ import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
 import kotlinx.coroutines.test.runTest
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.repository.MeshLogPrefs
 import org.meshtastic.core.repository.MeshLogRepository
+import kotlin.test.BeforeTest
+import kotlin.test.Test
 
 class SetMeshLogSettingsUseCaseTest {
 
@@ -32,7 +32,7 @@ class SetMeshLogSettingsUseCaseTest {
     private lateinit var meshLogPrefs: MeshLogPrefs
     private lateinit var useCase: SetMeshLogSettingsUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         meshLogRepository = mockk(relaxed = true)
         meshLogPrefs = mockk(relaxed = true)

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/SetProvideLocationUseCaseTest.kt

@@ -18,16 +18,16 @@ package org.meshtastic.core.domain.usecase.settings
 
 import io.mockk.mockk
 import io.mockk.verify
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.repository.UiPrefs
+import kotlin.test.BeforeTest
+import kotlin.test.Test
 
 class SetProvideLocationUseCaseTest {
 
     private lateinit var uiPrefs: UiPrefs
     private lateinit var useCase: SetProvideLocationUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         uiPrefs = mockk(relaxed = true)
         useCase = SetProvideLocationUseCase(uiPrefs)

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/SetThemeUseCaseTest.kt

@@ -18,16 +18,16 @@ package org.meshtastic.core.domain.usecase.settings
 
 import io.mockk.mockk
 import io.mockk.verify
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.datastore.UiPreferencesDataSource
+import kotlin.test.BeforeTest
+import kotlin.test.Test
 
 class SetThemeUseCaseTest {
 
     private lateinit var uiPreferencesDataSource: UiPreferencesDataSource
     private lateinit var useCase: SetThemeUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         uiPreferencesDataSource = mockk(relaxed = true)
         useCase = SetThemeUseCase(uiPreferencesDataSource)

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/ToggleAnalyticsUseCaseTest.kt

@@ -19,16 +19,16 @@ package org.meshtastic.core.domain.usecase.settings
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.repository.AnalyticsPrefs
+import kotlin.test.BeforeTest
+import kotlin.test.Test
 
 class ToggleAnalyticsUseCaseTest {
 
     private lateinit var analyticsPrefs: AnalyticsPrefs
     private lateinit var useCase: ToggleAnalyticsUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         analyticsPrefs = mockk(relaxed = true)
         useCase = ToggleAnalyticsUseCase(analyticsPrefs)

core/domain/src/commonTest/kotlin/org/meshtastic/core/domain/usecase/settings/ToggleHomoglyphEncodingUseCaseTest.kt

@@ -19,16 +19,16 @@ package org.meshtastic.core.domain.usecase.settings
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
-import org.junit.Before
-import org.junit.Test
 import org.meshtastic.core.repository.HomoglyphPrefs
+import kotlin.test.BeforeTest
+import kotlin.test.Test
 
 class ToggleHomoglyphEncodingUseCaseTest {
 
     private lateinit var homoglyphEncodingPrefs: HomoglyphPrefs
     private lateinit var useCase: ToggleHomoglyphEncodingUseCase
 
-    @Before
+    @BeforeTest
     fun setUp() {
         homoglyphEncodingPrefs = mockk(relaxed = true)
         useCase = ToggleHomoglyphEncodingUseCase(homoglyphEncodingPrefs)