Spotless fix

Author: djordjeh

CLAUDE.md

@@ -17,7 +17,7 @@ This is a Kotlin Multiplatform (KMP) library that provides unified barcode scann
 - For the naming of test class use suffix `Test` of the original class
 - If the same class name exists in common module and in platform specific like android for example, you can add platform name as suffix as well but before the word `Test`
 - Test coverage is ony important for the `scan-engine/` module and run tests only for this module
-- Classes with functions annotated as @Composable they need to be tested via android (instrumented) tests and not unit tests
+- Classes with functions annotated as @Composable they need to be tested via android instrumented tests and not unit tests
 - Activities or Fragment classes cover with android (instrumented) tests, not unit tests
 - Make sure at the end after you run all tests you cleanup test class for any unused variables, imports or components
 - `./gradlew :scan-engine:allTests` - Run tests for all platforms (Android, iOS) and create aggregated report

scan-engine/src/androidInstrumentedTest/kotlin/de/tillhub/scanengine/camera/contract/CameraScanContractTest.kt

@@ -91,7 +91,7 @@ class CameraScanContractTest {
     fun testCameraScanContractWithStateChanges() {
         var latestEvent: ScannerEvent? = null
         var eventCount = 0
-        
+
         val onResult: (ScannerEvent) -> Unit = { event ->
             latestEvent = event
             eventCount++
@@ -112,7 +112,7 @@ class CameraScanContractTest {
 
         // Manually trigger launch to test functionality
         contract.launchCameraScanner("manual_test")
-        
+
         // Wait for composition updates
         composeTestRule.waitForIdle()
 
@@ -125,14 +125,14 @@ class CameraScanContractTest {
     @Test
     fun testCameraScanContractRecomposition() {
         var recompositionCount = 0
-        
+
         val onResult: (ScannerEvent) -> Unit = { }
 
         composeTestRule.setContent {
             recompositionCount++
-            
+
             val contract = rememberCameraScanLauncher(onResult = onResult)
-            
+
             // Contract should be remembered across recompositions
             assertNotNull(contract)
         }
@@ -176,10 +176,10 @@ class CameraScanContractTest {
         // Verify all launches triggered InProgress events
         val inProgressEvents = events.filterIsInstance<ScannerEvent.Camera.InProgress>()
         assertEquals(3, inProgressEvents.size)
-        
+
         // Verify the scan keys are correct
         assertEquals("first_launch", inProgressEvents[0].scanKey)
         assertEquals("second_launch", inProgressEvents[1].scanKey)
         assertEquals(null, inProgressEvents[2].scanKey)
     }
-}
+}

scan-engine/src/androidInstrumentedTest/kotlin/de/tillhub/scanengine/camera/ui/CameraPreviewTest.kt

@@ -45,7 +45,7 @@ class CameraPreviewTest {
                     .fillMaxSize()
                     .testTag("camera_preview"),
                 barcodeScanned = barcodeCallback,
-                onCameraError = errorCallback
+                onCameraError = errorCallback,
             )
         }
 
@@ -73,7 +73,7 @@ class CameraPreviewTest {
             cameraPreview(
                 modifier = Modifier.testTag("camera_preview_callbacks"),
                 barcodeScanned = barcodeCallback,
-                onCameraError = errorCallback
+                onCameraError = errorCallback,
             )
         }
 
@@ -92,7 +92,7 @@ class CameraPreviewTest {
                     .fillMaxSize()
                     .testTag("camera_preview_modified"),
                 barcodeScanned = { },
-                onCameraError = { }
+                onCameraError = { },
             )
         }
 
@@ -119,7 +119,7 @@ class CameraPreviewTest {
                 },
                 onCameraError = { error ->
                     errorState.value = error
-                }
+                },
             )
         }
 
@@ -141,7 +141,7 @@ class CameraPreviewTest {
             cameraPreview(
                 modifier = Modifier.testTag("camera_preview_recomposition"),
                 barcodeScanned = { },
-                onCameraError = { }
+                onCameraError = { },
             )
         }
 
@@ -155,4 +155,4 @@ class CameraPreviewTest {
         // Verify composable still exists after potential recomposition
         composeTestRule.onNodeWithTag("camera_preview_recomposition").assertExists()
     }
-}
+}

scan-engine/src/androidInstrumentedTest/kotlin/de/tillhub/scanengine/camera/ui/CameraScanActivityTest.kt

@@ -23,17 +23,17 @@ class CameraScanActivityTest {
     fun testActivityLaunch() {
         val context = InstrumentationRegistry.getInstrumentation().targetContext
         val intent = Intent(context, CameraScanActivity::class.java)
-        
+
         ActivityScenario.launch<CameraScanActivity>(intent).use { scenario ->
             scenario.onActivity { activity ->
                 assertNotNull(activity)
-                
+
                 // Test basic activity functionality
                 val testBarcode = "test_barcode_123"
                 val resultIntent = Intent().apply {
                     putExtra(CameraScanActivity.DATA_KEY, testBarcode)
                 }
-                
+
                 // Verify we can set result and finish activity
                 activity.setResult(Activity.RESULT_OK, resultIntent)
                 activity.finish()
@@ -45,15 +45,15 @@ class CameraScanActivityTest {
     fun testActivityCancellation() {
         val context = InstrumentationRegistry.getInstrumentation().targetContext
         val intent = Intent(context, CameraScanActivity::class.java)
-        
+
         ActivityScenario.launch<CameraScanActivity>(intent).use { scenario ->
             scenario.onActivity { activity ->
                 assertNotNull(activity)
-                
+
                 // Test cancellation scenario
                 activity.setResult(Activity.RESULT_CANCELED)
                 activity.finish()
             }
         }
     }
-}
+}

scan-engine/src/androidUnitTest/kotlin/de/tillhub/scanengine/camera/AndroidPermissionHandlerTest.kt

@@ -47,4 +47,4 @@ internal class AndroidPermissionHandlerTest {
 
         assertFalse(result)
     }
-}
+}

scan-engine/src/androidUnitTest/kotlin/de/tillhub/scanengine/camera/CameraHandlerTest.kt

@@ -27,4 +27,4 @@ internal class CameraHandlerTest {
         // without calling getCameraProvider which requires CameraX setup
         assertNotNull(target)
     }
-}
+}

scan-engine/src/androidUnitTest/kotlin/de/tillhub/scanengine/camera/InputImageGeneratorTest.kt

@@ -20,4 +20,4 @@ internal class InputImageGeneratorTest {
         // Simple test to ensure the InputImageGenerator can be created
         assertNotNull(target)
     }
-}
+}

scan-engine/src/iosTest/kotlin/de/tillhub/scanengine/camera/IosPermissionHandlerTest.kt

@@ -0,0 +1,101 @@
+package de.tillhub.scanengine.camera
+
+import androidx.compose.ui.test.ExperimentalTestApi
+import androidx.compose.ui.test.runComposeUiTest
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlin.test.Test
+import kotlin.test.assertNotNull
+
+@OptIn(ExperimentalTestApi::class, ExperimentalForeignApi::class)
+internal class IosPermissionHandlerTest {
+
+    @Test
+    fun testIosPermissionHandlerInstantiation() {
+        val handler = IosPermissionHandler()
+        assertNotNull(handler)
+    }
+
+    @Test
+    fun testHasCameraPermissionMethod() {
+        val handler = IosPermissionHandler()
+
+        // This will check the actual iOS permission status
+        // The result depends on the system state, but it should not crash
+        val result = handler.hasCameraPermission()
+
+        // Just verify the method executes without error
+        // The actual permission state is environment dependent
+    }
+
+    @Test
+    fun testRequestCameraPermissionComposable() = runComposeUiTest {
+        var grantedCalled = false
+        var deniedCalled = false
+
+        val onGranted = { grantedCalled = true }
+        val onDenied = { deniedCalled = true }
+
+        val handler = IosPermissionHandler()
+
+        setContent {
+            handler.requestCameraPermission(
+                onGranted = onGranted,
+                onDenied = onDenied,
+            )
+        }
+
+        // Wait for composition
+        waitForIdle()
+
+        // The actual permission request behavior depends on the system state
+        // This test verifies that the composable can be called without crashing
+    }
+
+    @Test
+    fun testGetPermissionHandlerComposable() = runComposeUiTest {
+        var handler: PermissionHandler? = null
+
+        setContent {
+            handler = getPermissionHandler()
+        }
+
+        waitForIdle()
+
+        assertNotNull(handler)
+        // Verify it returns an IosPermissionHandler instance
+        // We can't use instanceof in Kotlin/Native, so we verify it's not null
+        // and that it has the expected interface
+        val result = handler.hasCameraPermission()
+        // Just verifying the interface works
+    }
+
+    @Test
+    fun testPermissionHandlerRecomposition() = runComposeUiTest {
+        var recompositionCount = 0
+        var handler1: PermissionHandler? = null
+        var handler2: PermissionHandler? = null
+
+        setContent {
+            recompositionCount++
+            if (recompositionCount == 1) {
+                handler1 = getPermissionHandler()
+            } else {
+                handler2 = getPermissionHandler()
+            }
+        }
+
+        waitForIdle()
+
+        // Force recomposition by updating content
+        setContent {
+            recompositionCount++
+            handler2 = getPermissionHandler()
+        }
+
+        waitForIdle()
+
+        // Both handlers should be non-null and functional
+        assertNotNull(handler1)
+        assertNotNull(handler2)
+    }
+}