Apply project-wide `kotlinLangStyle` formatting

11 files changed, 283 insertions, 301 deletions

diff --git a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/TestCoroutineRule.kt b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/TestCoroutineRule.kt
index 1acdf9e577..1f84171e3d 100644
--- a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/TestCoroutineRule.kt
+++ b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/TestCoroutineRule.kt
@@ -7,9 +7,8 @@ import kotlinx.coroutines.test.setMain
 import org.junit.rules.TestWatcher
 import org.junit.runner.Description
 
-class TestCoroutineRule(
-    val testDispatcher: TestCoroutineDispatcher = TestCoroutineDispatcher()
-) : TestWatcher() {
+class TestCoroutineRule(val testDispatcher: TestCoroutineDispatcher = TestCoroutineDispatcher()) :
+    TestWatcher() {
 
     override fun starting(description: Description?) {
         super.starting(description)
diff --git a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/TestUtils.kt b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/TestUtils.kt
index 4c4f043c06..59e1c70c6c 100644
--- a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/TestUtils.kt
+++ b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/TestUtils.kt
@@ -2,10 +2,15 @@ package net.mullvad.mullvadvpn
 
 import kotlin.test.assertTrue
 
-fun <T> assertLists(expected: List<T>, actual: List<T>, message: String? = null) = assertTrue(
-    expected.size == actual.size && expected.containsAll(actual) && actual.containsAll(expected),
-    message ?: """Expected list should have same size and contains same items.
+fun <T> assertLists(expected: List<T>, actual: List<T>, message: String? = null) =
+    assertTrue(
+        expected.size == actual.size &&
+            expected.containsAll(actual) &&
+            actual.containsAll(expected),
+        message
+            ?: """Expected list should have same size and contains same items.
         | Expected(${expected.size}): $expected
         | Actual(${actual.size})  : $actual
-    """.trimMargin()
-)
+    """
+                .trimMargin()
+    )
diff --git a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/applist/ApplicationsIconManagerTest.kt b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/applist/ApplicationsIconManagerTest.kt
index e6d43621a1..8db700f452 100644
--- a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/applist/ApplicationsIconManagerTest.kt
+++ b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/applist/ApplicationsIconManagerTest.kt
@@ -58,12 +58,8 @@ class ApplicationsIconManagerTest {
 
         assertEquals(mockedDrawable, result)
         assertEquals(mockedDrawable, result2)
-        verify(exactly = 2) {
-            mockedMainLooper.isCurrentThread
-        }
-        verify(exactly = 1) {
-            mockedPackageManager.getApplicationIcon(testPackageName)
-        }
+        verify(exactly = 2) { mockedMainLooper.isCurrentThread }
+        verify(exactly = 1) { mockedPackageManager.getApplicationIcon(testPackageName) }
     }
 
     @Test
diff --git a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/applist/ApplicationsProviderTest.kt b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/applist/ApplicationsProviderTest.kt
index e1a9e37ac4..3f2534798d 100644
--- a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/applist/ApplicationsProviderTest.kt
+++ b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/applist/ApplicationsProviderTest.kt
@@ -34,26 +34,41 @@ class ApplicationsProviderTest {
 
         every {
             mockedPackageManager.getInstalledApplications(PackageManager.GET_META_DATA)
-        } returns listOf(
-            createApplicationInfo(launchWithInternetPackageName, launch = true, internet = true),
-            createApplicationInfo(launchWithoutInternetPackageName, launch = true),
-            createApplicationInfo(nonLaunchWithInternetPackageName, internet = true),
-            createApplicationInfo(nonLaunchWithoutInternetPackageName),
-            createApplicationInfo(
-                leanbackLaunchWithInternetPackageName,
-                leanback = true,
-                internet = true
-            ),
-            createApplicationInfo(leanbackLaunchWithoutInternetPackageName, leanback = true),
-            createApplicationInfo(selfPackageName, internet = true, launch = true)
-        )
+        } returns
+            listOf(
+                createApplicationInfo(
+                    launchWithInternetPackageName,
+                    launch = true,
+                    internet = true
+                ),
+                createApplicationInfo(launchWithoutInternetPackageName, launch = true),
+                createApplicationInfo(nonLaunchWithInternetPackageName, internet = true),
+                createApplicationInfo(nonLaunchWithoutInternetPackageName),
+                createApplicationInfo(
+                    leanbackLaunchWithInternetPackageName,
+                    leanback = true,
+                    internet = true
+                ),
+                createApplicationInfo(leanbackLaunchWithoutInternetPackageName, leanback = true),
+                createApplicationInfo(selfPackageName, internet = true, launch = true)
+            )
 
         val result = testSubject.getAppsList()
-        val expected = listOf(
-            AppData(launchWithInternetPackageName, 0, launchWithInternetPackageName),
-            AppData(nonLaunchWithInternetPackageName, 0, nonLaunchWithInternetPackageName, true),
-            AppData(leanbackLaunchWithInternetPackageName, 0, leanbackLaunchWithInternetPackageName)
-        )
+        val expected =
+            listOf(
+                AppData(launchWithInternetPackageName, 0, launchWithInternetPackageName),
+                AppData(
+                    nonLaunchWithInternetPackageName,
+                    0,
+                    nonLaunchWithInternetPackageName,
+                    true
+                ),
+                AppData(
+                    leanbackLaunchWithInternetPackageName,
+                    0,
+                    leanbackLaunchWithInternetPackageName
+                )
+            )
 
         assertLists(expected, result)
 
@@ -61,31 +76,34 @@ class ApplicationsProviderTest {
             mockedPackageManager.getInstalledApplications(PackageManager.GET_META_DATA)
 
             listOf(
-                launchWithInternetPackageName,
-                launchWithoutInternetPackageName,
-                nonLaunchWithInternetPackageName,
-                nonLaunchWithoutInternetPackageName,
-                leanbackLaunchWithInternetPackageName,
-                leanbackLaunchWithoutInternetPackageName,
-                selfPackageName
-            ).forEach { packageName ->
-                mockedPackageManager.checkPermission(internet, packageName)
-            }
+                    launchWithInternetPackageName,
+                    launchWithoutInternetPackageName,
+                    nonLaunchWithInternetPackageName,
+                    nonLaunchWithoutInternetPackageName,
+                    leanbackLaunchWithInternetPackageName,
+                    leanbackLaunchWithoutInternetPackageName,
+                    selfPackageName
+                )
+                .forEach { packageName ->
+                    mockedPackageManager.checkPermission(internet, packageName)
+                }
 
             listOf(
-                launchWithInternetPackageName,
-                nonLaunchWithInternetPackageName,
-                leanbackLaunchWithInternetPackageName
-            ).forEach { packageName ->
-                mockedPackageManager.getLaunchIntentForPackage(packageName)
-            }
+                    launchWithInternetPackageName,
+                    nonLaunchWithInternetPackageName,
+                    leanbackLaunchWithInternetPackageName
+                )
+                .forEach { packageName ->
+                    mockedPackageManager.getLaunchIntentForPackage(packageName)
+                }
 
             listOf(
-                nonLaunchWithInternetPackageName,
-                leanbackLaunchWithInternetPackageName,
-            ).forEach { packageName ->
-                mockedPackageManager.getLeanbackLaunchIntentForPackage(packageName)
-            }
+                    nonLaunchWithInternetPackageName,
+                    leanbackLaunchWithInternetPackageName,
+                )
+                .forEach { packageName ->
+                    mockedPackageManager.getLeanbackLaunchIntentForPackage(packageName)
+                }
         }
     }
 
@@ -103,26 +121,16 @@ class ApplicationsProviderTest {
 
         every { mockApplicationInfo.loadLabel(mockedPackageManager) } returns packageName
 
-        every {
-            mockedPackageManager.getLaunchIntentForPackage(packageName)
-        } returns if (launch || systemApp)
-            mockk()
-        else
-            null
+        every { mockedPackageManager.getLaunchIntentForPackage(packageName) } returns
+            if (launch || systemApp) mockk() else null
 
-        every {
-            mockedPackageManager.getLeanbackLaunchIntentForPackage(packageName)
-        } returns if (leanback || systemApp)
-            mockk()
-        else
-            null
+        every { mockedPackageManager.getLeanbackLaunchIntentForPackage(packageName) } returns
+            if (leanback || systemApp) mockk() else null
 
         every {
             mockedPackageManager.checkPermission(Manifest.permission.INTERNET, packageName)
-        } returns if (internet)
-            PackageManager.PERMISSION_GRANTED
-        else
-            PackageManager.PERMISSION_DENIED
+        } returns
+            if (internet) PackageManager.PERMISSION_GRANTED else PackageManager.PERMISSION_DENIED
 
         return mockApplicationInfo
     }
diff --git a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/di/UiModuleTest.kt b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/di/UiModuleTest.kt
index 92ffd792a0..01b1807d42 100644
--- a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/di/UiModuleTest.kt
+++ b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/di/UiModuleTest.kt
@@ -18,10 +18,7 @@ import org.koin.test.KoinTestRule
 
 class UiModuleTest : KoinTest {
 
-    @get:Rule
-    val koinTestRule = KoinTestRule.create {
-        modules(uiModule)
-    }
+    @get:Rule val koinTestRule = KoinTestRule.create { modules(uiModule) }
 
     @After
     fun tearDown() {
@@ -31,18 +28,17 @@ class UiModuleTest : KoinTest {
     @Test
     fun test_scope_linking() {
         val appsScope: Scope = getKoin().createScope(APPS_SCOPE, named(APPS_SCOPE))
-        val serviceConnectionScope = getKoin().createScope(
-            SERVICE_CONNECTION_SCOPE,
-            named(SERVICE_CONNECTION_SCOPE)
-        )
+        val serviceConnectionScope =
+            getKoin().createScope(SERVICE_CONNECTION_SCOPE, named(SERVICE_CONNECTION_SCOPE))
 
         appsScope.linkTo(serviceConnectionScope)
 
         val mockedMessenger = mockk<Messenger>()
         val mockedEventMessageHandler = mockk<MessageDispatcher<Event>>(relaxed = true)
-        val serviceConnectionSplitTunneling = serviceConnectionScope.get<SplitTunneling>(
-            parameters = { parametersOf(mockedMessenger, mockedEventMessageHandler) }
-        )
+        val serviceConnectionSplitTunneling =
+            serviceConnectionScope.get<SplitTunneling>(
+                parameters = { parametersOf(mockedMessenger, mockedEventMessageHandler) }
+            )
 
         assertEquals(appsScope.get<SplitTunneling>(), serviceConnectionSplitTunneling)
     }
diff --git a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/service/ConnectionProxyTest.kt b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/service/ConnectionProxyTest.kt
index 44ccdf013b..ff10770540 100644
--- a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/service/ConnectionProxyTest.kt
+++ b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/service/ConnectionProxyTest.kt
@@ -26,14 +26,11 @@ import org.junit.Test
 
 class ConnectionProxyTest {
 
-    @MockK
-    private lateinit var mockedMainLooper: Looper
+    @MockK private lateinit var mockedMainLooper: Looper
 
-    @MockK
-    private lateinit var connection: Messenger
+    @MockK private lateinit var connection: Messenger
 
-    @MockK
-    private lateinit var mockedDispatchingHandler: EventDispatcher
+    @MockK private lateinit var mockedDispatchingHandler: EventDispatcher
     lateinit var connectionProxy: ConnectionProxy
 
     @Before
@@ -57,9 +54,7 @@ class ConnectionProxyTest {
     fun test_initialize_connection_proxy() {
         // Arrange
         val eventType = slot<KClass<Event.TunnelStateChange>>()
-        every {
-            mockedDispatchingHandler.registerHandler(capture(eventType), any())
-        } just Runs
+        every { mockedDispatchingHandler.registerHandler(capture(eventType), any()) } just Runs
         // Create ConnectionProxy instance and assert initial Event type
         connectionProxy = ConnectionProxy(connection, mockedDispatchingHandler)
         assertEquals(Event.TunnelStateChange::class, eventType.captured.java.kotlin)
@@ -69,9 +64,7 @@ class ConnectionProxyTest {
     fun test_tunnel_normal_connect_disconnect() {
         // Arrange
         every { connection.send(any()) } just Runs
-        every {
-            mockedDispatchingHandler.registerHandler(any<KClass<Event>>(), any())
-        } just Runs
+        every { mockedDispatchingHandler.registerHandler(any<KClass<Event>>(), any()) } just Runs
         // Act and Assert no crashes
         connectionProxy = ConnectionProxy(connection, mockedDispatchingHandler)
         connectionProxy.connect()
@@ -82,9 +75,7 @@ class ConnectionProxyTest {
     fun test_tunnel_handle_crash_on_connect() {
         // Arrange
         every { connection.send(any()) } throws DeadObjectException()
-        every {
-            mockedDispatchingHandler.registerHandler(any<KClass<Event>>(), any())
-        } just Runs
+        every { mockedDispatchingHandler.registerHandler(any<KClass<Event>>(), any()) } just Runs
         // Act and Assert no crashes
         connectionProxy = ConnectionProxy(connection, mockedDispatchingHandler)
         connectionProxy.connect()
diff --git a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/service/ServiceConnectionDeviceDataSourceTest.kt b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/service/ServiceConnectionDeviceDataSourceTest.kt
index 8b737cba69..81633c89be 100644
--- a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/service/ServiceConnectionDeviceDataSourceTest.kt
+++ b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/service/ServiceConnectionDeviceDataSourceTest.kt
@@ -25,14 +25,11 @@ import org.junit.Test
 class ServiceConnectionDeviceDataSourceTest {
     private val tracker = JobTracker()
 
-    @MockK
-    private lateinit var mockedMainLooper: Looper
+    @MockK private lateinit var mockedMainLooper: Looper
 
-    @MockK
-    private lateinit var mockedDispatchingHandler: EventDispatcher
+    @MockK private lateinit var mockedDispatchingHandler: EventDispatcher
 
-    @MockK
-    private lateinit var connection: Messenger
+    @MockK private lateinit var connection: Messenger
 
     lateinit var serviceConnectionDeviceDataSource: ServiceConnectionDeviceDataSource
 
@@ -57,9 +54,7 @@ class ServiceConnectionDeviceDataSourceTest {
     fun test_get_devices_list() {
         // Arrange
         every { connection.send(any()) } just Runs
-        every {
-            mockedDispatchingHandler.registerHandler(any<KClass<Event>>(), any())
-        } just Runs
+        every { mockedDispatchingHandler.registerHandler(any<KClass<Event>>(), any()) } just Runs
         // Act and Assert no crashes
         serviceConnectionDeviceDataSource =
             ServiceConnectionDeviceDataSource(connection, mockedDispatchingHandler)
@@ -70,9 +65,7 @@ class ServiceConnectionDeviceDataSourceTest {
     fun test_catch_exception_on_devices_list() {
         // Arrange
         every { connection.send(any()) } throws DeadObjectException()
-        every {
-            mockedDispatchingHandler.registerHandler(any<KClass<Event>>(), any())
-        } just Runs
+        every { mockedDispatchingHandler.registerHandler(any<KClass<Event>>(), any()) } just Runs
         // Act and Assert no crashes
         serviceConnectionDeviceDataSource =
             ServiceConnectionDeviceDataSource(connection, mockedDispatchingHandler)
diff --git a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/ChangelogViewModelTest.kt b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/ChangelogViewModelTest.kt
index eafac23bfc..3547b92065 100644
--- a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/ChangelogViewModelTest.kt
+++ b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/ChangelogViewModelTest.kt
@@ -19,8 +19,7 @@ import org.junit.Test
 
 class ChangelogViewModelTest {
 
-    @MockK
-    private lateinit var mockedChangelogRepository: ChangelogRepository
+    @MockK private lateinit var mockedChangelogRepository: ChangelogRepository
 
     private lateinit var viewModel: ChangelogViewModel
 
@@ -28,9 +27,8 @@ class ChangelogViewModelTest {
     fun setup() {
         MockKAnnotations.init(this)
         mockkStatic(EVENT_NOTIFIER_EXTENSION_CLASS)
-        every {
-            mockedChangelogRepository.setVersionCodeOfMostRecentChangelogShowed(any())
-        } just Runs
+        every { mockedChangelogRepository.setVersionCodeOfMostRecentChangelogShowed(any()) } just
+            Runs
         viewModel = ChangelogViewModel(mockedChangelogRepository, 1, false)
     }
 
@@ -52,9 +50,8 @@ class ChangelogViewModelTest {
         viewModel.changelogDialogUiState.test {
             // Arrange
             val fakeList = listOf("test")
-            every {
-                mockedChangelogRepository.getVersionCodeOfMostRecentChangelogShowed()
-            } returns -1
+            every { mockedChangelogRepository.getVersionCodeOfMostRecentChangelogShowed() } returns
+                -1
             every { mockedChangelogRepository.getLastVersionChanges() } returns fakeList
 
             // Assert initial ui state
@@ -76,9 +73,8 @@ class ChangelogViewModelTest {
         viewModel.changelogDialogUiState.test {
             // Arrange
             val fakeEmptyList = emptyList<String>()
-            every {
-                mockedChangelogRepository.getVersionCodeOfMostRecentChangelogShowed()
-            } returns -1
+            every { mockedChangelogRepository.getVersionCodeOfMostRecentChangelogShowed() } returns
+                -1
             every { mockedChangelogRepository.getLastVersionChanges() } returns fakeEmptyList
 
             // Assert initial ui state
diff --git a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/DeviceRevokedViewModelTest.kt b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/DeviceRevokedViewModelTest.kt
index c3be82c1e1..32cce31136 100644
--- a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/DeviceRevokedViewModelTest.kt
+++ b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/DeviceRevokedViewModelTest.kt
@@ -30,11 +30,9 @@ import org.junit.Test
 
 class DeviceRevokedViewModelTest {
 
-    @MockK
-    private lateinit var mockedAccountRepository: AccountRepository
+    @MockK private lateinit var mockedAccountRepository: AccountRepository
 
-    @MockK
-    private lateinit var mockedServiceConnectionManager: ServiceConnectionManager
+    @MockK private lateinit var mockedServiceConnectionManager: ServiceConnectionManager
 
     private val serviceConnectionState =
         MutableStateFlow<ServiceConnectionState>(ServiceConnectionState.Disconnected)
@@ -46,11 +44,12 @@ class DeviceRevokedViewModelTest {
         MockKAnnotations.init(this)
         mockkStatic(EVENT_NOTIFIER_EXTENSION_CLASS)
         every { mockedServiceConnectionManager.connectionState } returns serviceConnectionState
-        viewModel = DeviceRevokedViewModel(
-            mockedServiceConnectionManager,
-            mockedAccountRepository,
-            TestCoroutineDispatcher()
-        )
+        viewModel =
+            DeviceRevokedViewModel(
+                mockedServiceConnectionManager,
+                mockedAccountRepository,
+                TestCoroutineDispatcher()
+            )
     }
 
     @After
@@ -79,17 +78,19 @@ class DeviceRevokedViewModelTest {
     @Test
     fun testUiStateWhenServiceConnectedAndReady() = runBlockingTest {
         // Arrange
-        val mockedContainer = mockk<ServiceConnectionContainer>().apply {
-            val eventNotifierMock = mockk<EventNotifier<TunnelState>>().apply {
-                every { callbackFlowFromSubscription(any()) } returns MutableStateFlow(
-                    TunnelState.Connected(mockk(), mockk())
-                )
+        val mockedContainer =
+            mockk<ServiceConnectionContainer>().apply {
+                val eventNotifierMock =
+                    mockk<EventNotifier<TunnelState>>().apply {
+                        every { callbackFlowFromSubscription(any()) } returns
+                            MutableStateFlow(TunnelState.Connected(mockk(), mockk()))
+                    }
+                val mockedConnectionProxy =
+                    mockk<ConnectionProxy>().apply {
+                        every { onUiStateChange } returns eventNotifierMock
+                    }
+                every { connectionProxy } returns mockedConnectionProxy
             }
-            val mockedConnectionProxy = mockk<ConnectionProxy>().apply {
-                every { onUiStateChange } returns eventNotifierMock
-            }
-            every { connectionProxy } returns mockedConnectionProxy
-        }
 
         // Act, Assert
         viewModel.uiState.test {
@@ -102,30 +103,30 @@ class DeviceRevokedViewModelTest {
     @Test
     fun testGoToLoginWhenDisconnected() {
         // Arrange
-        val mockedContainer = mockk<ServiceConnectionContainer>().also {
-            every { it.connectionProxy.state } returns TunnelState.Disconnected
-            every { it.connectionProxy.disconnect() } just Runs
-            every { mockedAccountRepository.logout() } just Runs
-        }
+        val mockedContainer =
+            mockk<ServiceConnectionContainer>().also {
+                every { it.connectionProxy.state } returns TunnelState.Disconnected
+                every { it.connectionProxy.disconnect() } just Runs
+                every { mockedAccountRepository.logout() } just Runs
+            }
         serviceConnectionState.value = ServiceConnectionState.ConnectedReady(mockedContainer)
 
         // Act
         viewModel.onGoToLoginClicked()
 
         // Assert
-        verify {
-            mockedAccountRepository.logout()
-        }
+        verify { mockedAccountRepository.logout() }
     }
 
     @Test
     fun testGoToLoginWhenConnected() {
         // Arrange
-        val mockedContainer = mockk<ServiceConnectionContainer>().also {
-            every { it.connectionProxy.state } returns TunnelState.Connected(mockk(), mockk())
-            every { it.connectionProxy.disconnect() } just Runs
-            every { mockedAccountRepository.logout() } just Runs
-        }
+        val mockedContainer =
+            mockk<ServiceConnectionContainer>().also {
+                every { it.connectionProxy.state } returns TunnelState.Connected(mockk(), mockk())
+                every { it.connectionProxy.disconnect() } just Runs
+                every { mockedAccountRepository.logout() } just Runs
+            }
         serviceConnectionState.value = ServiceConnectionState.ConnectedReady(mockedContainer)
 
         // Act
diff --git a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/LoginViewModelTest.kt b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/LoginViewModelTest.kt
index ea35dd7c6c..0531342cc4 100644
--- a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/LoginViewModelTest.kt
+++ b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/LoginViewModelTest.kt
@@ -28,14 +28,11 @@ import org.junit.Test
 
 class LoginViewModelTest {
 
-    @MockK
-    private lateinit var mockedAccountRepository: AccountRepository
+    @MockK private lateinit var mockedAccountRepository: AccountRepository
 
-    @MockK
-    private lateinit var mockedDeviceRepository: DeviceRepository
+    @MockK private lateinit var mockedDeviceRepository: DeviceRepository
 
-    @MockK
-    private lateinit var mockedServiceConnectionContainer: ServiceConnectionContainer
+    @MockK private lateinit var mockedServiceConnectionContainer: ServiceConnectionContainer
 
     private lateinit var loginViewModel: LoginViewModel
 
@@ -58,11 +55,12 @@ class LoginViewModelTest {
         serviceConnectionState.value =
             ServiceConnectionState.ConnectedReady(mockedServiceConnectionContainer)
 
-        loginViewModel = LoginViewModel(
-            mockedAccountRepository,
-            mockedDeviceRepository,
-            TestCoroutineDispatcher()
-        )
+        loginViewModel =
+            LoginViewModel(
+                mockedAccountRepository,
+                mockedDeviceRepository,
+                TestCoroutineDispatcher()
+            )
     }
 
     @Test
@@ -109,15 +107,8 @@ class LoginViewModelTest {
     @Test
     fun testLoginWithTooManyDevicesError() = runBlockingTest {
         coEvery {
-            mockedDeviceRepository.refreshAndAwaitDeviceListWithTimeout(
-                any(),
-                any(),
-                any(),
-                any()
-            )
-        } returns DeviceListEvent.Available(
-            DUMMY_ACCOUNT_TOKEN, listOf()
-        )
+            mockedDeviceRepository.refreshAndAwaitDeviceListWithTimeout(any(), any(), any(), any())
+        } returns DeviceListEvent.Available(DUMMY_ACCOUNT_TOKEN, listOf())
 
         loginViewModel.uiState.test {
             skipDefaultItem()
@@ -125,7 +116,8 @@ class LoginViewModelTest {
             assertEquals(LoginViewModel.LoginUiState.Loading, awaitItem())
             loginTestEvents.emit(Event.LoginEvent(LoginResult.MaxDevicesReached))
             assertEquals(
-                LoginViewModel.LoginUiState.TooManyDevicesError(DUMMY_ACCOUNT_TOKEN), awaitItem()
+                LoginViewModel.LoginUiState.TooManyDevicesError(DUMMY_ACCOUNT_TOKEN),
+                awaitItem()
             )
         }
     }
diff --git a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/SplitTunnelingViewModelTest.kt b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/SplitTunnelingViewModelTest.kt
index ac229ba3fb..9fa0e9ea88 100644
--- a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/SplitTunnelingViewModelTest.kt
+++ b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/SplitTunnelingViewModelTest.kt
@@ -29,11 +29,9 @@ import org.junit.Test
 import org.junit.rules.Timeout
 
 class SplitTunnelingViewModelTest {
-    @get:Rule
-    val testCoroutineRule = TestCoroutineRule()
+    @get:Rule val testCoroutineRule = TestCoroutineRule()
 
-    @get:Rule
-    val timeout = Timeout(3000L, TimeUnit.MILLISECONDS)
+    @get:Rule val timeout = Timeout(3000L, TimeUnit.MILLISECONDS)
     private val mockedApplicationsProvider = mockk<ApplicationsProvider>()
     private val mockedSplitTunneling = mockk<SplitTunneling>()
     private lateinit var testSubject: SplitTunnelingViewModel
@@ -50,166 +48,174 @@ class SplitTunnelingViewModelTest {
     }
 
     @Test
-    fun test_has_progress_on_start() = runBlockingTest(testCoroutineRule.testDispatcher) {
-        initTestSubject(emptyList())
-        val actualList: List<ListItemData> = testSubject.listItems.first()
+    fun test_has_progress_on_start() =
+        runBlockingTest(testCoroutineRule.testDispatcher) {
+            initTestSubject(emptyList())
+            val actualList: List<ListItemData> = testSubject.listItems.first()
 
-        val initialExpectedList = listOf(
-            createTextItem(R.string.split_tunneling_description),
-            createDivider(0),
-            createProgressItem()
-        )
+            val initialExpectedList =
+                listOf(
+                    createTextItem(R.string.split_tunneling_description),
+                    createDivider(0),
+                    createProgressItem()
+                )
 
-        assertLists(initialExpectedList, actualList)
+            assertLists(initialExpectedList, actualList)
 
-        verify(exactly = 1) {
-            mockedApplicationsProvider.getAppsList()
+            verify(exactly = 1) { mockedApplicationsProvider.getAppsList() }
         }
-    }
 
     @Test
-    fun test_empty_app_list() = runBlockingTest(testCoroutineRule.testDispatcher) {
-        initTestSubject(emptyList())
-        testSubject.processIntent(ViewIntent.ViewIsReady)
-        val actualList = testSubject.listItems.first()
-        val expectedList = listOf(createTextItem(R.string.split_tunneling_description))
-        assertLists(expectedList, actualList)
-    }
+    fun test_empty_app_list() =
+        runBlockingTest(testCoroutineRule.testDispatcher) {
+            initTestSubject(emptyList())
+            testSubject.processIntent(ViewIntent.ViewIsReady)
+            val actualList = testSubject.listItems.first()
+            val expectedList = listOf(createTextItem(R.string.split_tunneling_description))
+            assertLists(expectedList, actualList)
+        }
 
     @Test
-    fun test_apps_list_delivered() = runBlockingTest(testCoroutineRule.testDispatcher) {
-        val appExcluded = AppData("test.excluded", 0, "testName1")
-        val appNotExcluded = AppData("test.not.excluded", 0, "testName2")
-        every { mockedSplitTunneling.isAppExcluded(appExcluded.packageName) } returns true
-        every { mockedSplitTunneling.isAppExcluded(appNotExcluded.packageName) } returns false
+    fun test_apps_list_delivered() =
+        runBlockingTest(testCoroutineRule.testDispatcher) {
+            val appExcluded = AppData("test.excluded", 0, "testName1")
+            val appNotExcluded = AppData("test.not.excluded", 0, "testName2")
+            every { mockedSplitTunneling.isAppExcluded(appExcluded.packageName) } returns true
+            every { mockedSplitTunneling.isAppExcluded(appNotExcluded.packageName) } returns false
 
-        initTestSubject(listOf(appExcluded, appNotExcluded))
-        testSubject.processIntent(ViewIntent.ViewIsReady)
+            initTestSubject(listOf(appExcluded, appNotExcluded))
+            testSubject.processIntent(ViewIntent.ViewIsReady)
 
-        val actualList = testSubject.listItems.first()
-        val expectedList = listOf(
-            createTextItem(R.string.split_tunneling_description),
-            createDivider(0),
-            createMainItem(R.string.exclude_applications),
-            createApplicationItem(appExcluded, true),
-            createDivider(1),
-            createSwitchItem(R.string.show_system_apps, false),
-            createMainItem(R.string.all_applications),
-            createApplicationItem(appNotExcluded, false),
-        )
+            val actualList = testSubject.listItems.first()
+            val expectedList =
+                listOf(
+                    createTextItem(R.string.split_tunneling_description),
+                    createDivider(0),
+                    createMainItem(R.string.exclude_applications),
+                    createApplicationItem(appExcluded, true),
+                    createDivider(1),
+                    createSwitchItem(R.string.show_system_apps, false),
+                    createMainItem(R.string.all_applications),
+                    createApplicationItem(appNotExcluded, false),
+                )
 
-        assertLists(expectedList, actualList)
-        verifyAll {
-            mockedSplitTunneling.enabled
-            mockedSplitTunneling.isAppExcluded(appExcluded.packageName)
-            mockedSplitTunneling.isAppExcluded(appNotExcluded.packageName)
+            assertLists(expectedList, actualList)
+            verifyAll {
+                mockedSplitTunneling.enabled
+                mockedSplitTunneling.isAppExcluded(appExcluded.packageName)
+                mockedSplitTunneling.isAppExcluded(appNotExcluded.packageName)
+            }
         }
-    }
 
     @Test
-    fun test_remove_app_from_excluded() = runBlockingTest(testCoroutineRule.testDispatcher) {
-        val app = AppData("test", 0, "testName")
-        every { mockedSplitTunneling.isAppExcluded(app.packageName) } returns true
-        every { mockedSplitTunneling.includeApp(app.packageName) } just Runs
+    fun test_remove_app_from_excluded() =
+        runBlockingTest(testCoroutineRule.testDispatcher) {
+            val app = AppData("test", 0, "testName")
+            every { mockedSplitTunneling.isAppExcluded(app.packageName) } returns true
+            every { mockedSplitTunneling.includeApp(app.packageName) } just Runs
 
-        initTestSubject(listOf(app))
-        testSubject.processIntent(ViewIntent.ViewIsReady)
+            initTestSubject(listOf(app))
+            testSubject.processIntent(ViewIntent.ViewIsReady)
 
-        val listBeforeAction = testSubject.listItems.first()
-        val expectedListBeforeAction = listOf(
-            createTextItem(R.string.split_tunneling_description),
-            createDivider(0),
-            createMainItem(R.string.exclude_applications),
-            createApplicationItem(app, true),
-        )
+            val listBeforeAction = testSubject.listItems.first()
+            val expectedListBeforeAction =
+                listOf(
+                    createTextItem(R.string.split_tunneling_description),
+                    createDivider(0),
+                    createMainItem(R.string.exclude_applications),
+                    createApplicationItem(app, true),
+                )
 
-        assertLists(expectedListBeforeAction, listBeforeAction)
+            assertLists(expectedListBeforeAction, listBeforeAction)
 
-        val item = listBeforeAction.first { it.identifier == app.packageName }
-        testSubject.processIntent(ViewIntent.ChangeApplicationGroup(item))
+            val item = listBeforeAction.first { it.identifier == app.packageName }
+            testSubject.processIntent(ViewIntent.ChangeApplicationGroup(item))
 
-        val itemsAfterAction = testSubject.listItems.first()
-        val expectedList = listOf(
-            createTextItem(R.string.split_tunneling_description),
-            createDivider(1),
-            createSwitchItem(R.string.show_system_apps, false),
-            createMainItem(R.string.all_applications),
-            createApplicationItem(app, false),
-        )
+            val itemsAfterAction = testSubject.listItems.first()
+            val expectedList =
+                listOf(
+                    createTextItem(R.string.split_tunneling_description),
+                    createDivider(1),
+                    createSwitchItem(R.string.show_system_apps, false),
+                    createMainItem(R.string.all_applications),
+                    createApplicationItem(app, false),
+                )
 
-        assertLists(expectedList, itemsAfterAction)
+            assertLists(expectedList, itemsAfterAction)
 
-        verifyAll {
-            mockedSplitTunneling.enabled
-            mockedSplitTunneling.isAppExcluded(app.packageName)
-            mockedSplitTunneling.includeApp(app.packageName)
+            verifyAll {
+                mockedSplitTunneling.enabled
+                mockedSplitTunneling.isAppExcluded(app.packageName)
+                mockedSplitTunneling.includeApp(app.packageName)
+            }
         }
-    }
 
     @Test
-    fun test_add_app_to_excluded() = runBlockingTest(testCoroutineRule.testDispatcher) {
-        val app = AppData("test", 0, "testName")
-        every { mockedSplitTunneling.isAppExcluded(app.packageName) } returns false
-        every { mockedSplitTunneling.excludeApp(app.packageName) } just Runs
-        initTestSubject(listOf(app))
-        testSubject.processIntent(ViewIntent.ViewIsReady)
+    fun test_add_app_to_excluded() =
+        runBlockingTest(testCoroutineRule.testDispatcher) {
+            val app = AppData("test", 0, "testName")
+            every { mockedSplitTunneling.isAppExcluded(app.packageName) } returns false
+            every { mockedSplitTunneling.excludeApp(app.packageName) } just Runs
+            initTestSubject(listOf(app))
+            testSubject.processIntent(ViewIntent.ViewIsReady)
 
-        val listBeforeAction = testSubject.listItems.first()
-        val expectedListBeforeAction = listOf(
-            createTextItem(R.string.split_tunneling_description),
-            createDivider(1),
-            createSwitchItem(R.string.show_system_apps, false),
-            createMainItem(R.string.all_applications),
-            createApplicationItem(app, false),
-        )
+            val listBeforeAction = testSubject.listItems.first()
+            val expectedListBeforeAction =
+                listOf(
+                    createTextItem(R.string.split_tunneling_description),
+                    createDivider(1),
+                    createSwitchItem(R.string.show_system_apps, false),
+                    createMainItem(R.string.all_applications),
+                    createApplicationItem(app, false),
+                )
 
-        assertLists(expectedListBeforeAction, listBeforeAction)
+            assertLists(expectedListBeforeAction, listBeforeAction)
 
-        val item = listBeforeAction.first { it.identifier == app.packageName }
-        testSubject.processIntent(ViewIntent.ChangeApplicationGroup(item))
+            val item = listBeforeAction.first { it.identifier == app.packageName }
+            testSubject.processIntent(ViewIntent.ChangeApplicationGroup(item))
 
-        val itemsAfterAction = testSubject.listItems.first()
-        val expectedList = listOf(
-            createTextItem(R.string.split_tunneling_description),
-            createDivider(0),
-            createMainItem(R.string.exclude_applications),
-            createApplicationItem(app, true),
-        )
+            val itemsAfterAction = testSubject.listItems.first()
+            val expectedList =
+                listOf(
+                    createTextItem(R.string.split_tunneling_description),
+                    createDivider(0),
+                    createMainItem(R.string.exclude_applications),
+                    createApplicationItem(app, true),
+                )
 
-        assertLists(expectedList, itemsAfterAction)
+            assertLists(expectedList, itemsAfterAction)
 
-        verifyAll {
-            mockedSplitTunneling.enabled
-            mockedSplitTunneling.isAppExcluded(app.packageName)
-            mockedSplitTunneling.excludeApp(app.packageName)
+            verifyAll {
+                mockedSplitTunneling.enabled
+                mockedSplitTunneling.isAppExcluded(app.packageName)
+                mockedSplitTunneling.excludeApp(app.packageName)
+            }
         }
-    }
 
     private fun initTestSubject(appList: List<AppData>) {
         every { mockedApplicationsProvider.getAppsList() } returns appList
-        testSubject = SplitTunnelingViewModel(
-            mockedApplicationsProvider,
-            mockedSplitTunneling,
-            testCoroutineRule.testDispatcher
-        )
+        testSubject =
+            SplitTunnelingViewModel(
+                mockedApplicationsProvider,
+                mockedSplitTunneling,
+                testCoroutineRule.testDispatcher
+            )
     }
 
-    private fun createApplicationItem(
-        appData: AppData,
-        checked: Boolean
-    ): ListItemData = ListItemData.build(appData.packageName) {
-        type = ListItemData.APPLICATION
-        text = appData.name
-        iconRes = appData.iconRes
-        action = ListItemData.ItemAction(appData.packageName)
-        widget = WidgetState.ImageState(
-            if (checked) R.drawable.ic_icons_remove else R.drawable.ic_icons_add
-        )
-    }
+    private fun createApplicationItem(appData: AppData, checked: Boolean): ListItemData =
+        ListItemData.build(appData.packageName) {
+            type = ListItemData.APPLICATION
+            text = appData.name
+            iconRes = appData.iconRes
+            action = ListItemData.ItemAction(appData.packageName)
+            widget =
+                WidgetState.ImageState(
+                    if (checked) R.drawable.ic_icons_remove else R.drawable.ic_icons_add
+                )
+        }
 
-    private fun createDivider(id: Int): ListItemData = ListItemData.build("space_$id") {
-        type = ListItemData.DIVIDER
-    }
+    private fun createDivider(id: Int): ListItemData =
+        ListItemData.build("space_$id") { type = ListItemData.DIVIDER }
 
     private fun createMainItem(@StringRes text: Int): ListItemData =
         ListItemData.build("header_$text") {
@@ -224,9 +230,8 @@ class SplitTunnelingViewModelTest {
             action = ListItemData.ItemAction(text.toString())
         }
 
-    private fun createProgressItem(): ListItemData = ListItemData.build(identifier = "progress") {
-        type = ListItemData.PROGRESS
-    }
+    private fun createProgressItem(): ListItemData =
+        ListItemData.build(identifier = "progress") { type = ListItemData.PROGRESS }
 
     private fun createSwitchItem(@StringRes text: Int, checked: Boolean): ListItemData =
         ListItemData.build(identifier = "switch_$text") {