Fix test compilation

matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/account/DeactivateAccountTest.kt

@@ -26,15 +26,12 @@ import org.matrix.android.sdk.InstrumentedTest
 import org.matrix.android.sdk.api.auth.UIABaseAuth
 import org.matrix.android.sdk.api.auth.UserInteractiveAuthInterceptor
 import org.matrix.android.sdk.api.auth.UserPasswordAuth
-import org.matrix.android.sdk.api.auth.data.LoginFlowResult
 import org.matrix.android.sdk.api.auth.registration.RegistrationFlowResponse
-import org.matrix.android.sdk.api.auth.registration.RegistrationResult
 import org.matrix.android.sdk.api.failure.Failure
 import org.matrix.android.sdk.api.failure.MatrixError
 import org.matrix.android.sdk.common.CommonTestHelper
 import org.matrix.android.sdk.common.SessionTestParams
 import org.matrix.android.sdk.common.TestConstants
-import org.matrix.android.sdk.common.TestMatrixCallback
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.resume
 
@@ -75,23 +72,23 @@ class DeactivateAccountTest : InstrumentedTest {
         // Try to create an account with the deactivate account user id, it will fail (M_USER_IN_USE)
         val hs = commonTestHelper.createHomeServerConfig()
 
-        commonTestHelper.doSync<LoginFlowResult> {
-            commonTestHelper.matrix.authenticationService.getLoginFlow(hs, it)
+        commonTestHelper.runBlockingTest {
+            commonTestHelper.matrix.authenticationService.getLoginFlow(hs)
         }
 
         var accountCreationError: Throwable? = null
-        commonTestHelper.waitWithLatch {
-            commonTestHelper.matrix.authenticationService
-                    .getRegistrationWizard()
-                    .createAccount(session.myUserId.substringAfter("@").substringBefore(":"),
-                            TestConstants.PASSWORD,
-                            null,
-                            object : TestMatrixCallback<RegistrationResult>(it, false) {
-                                override fun onFailure(failure: Throwable) {
-                                    accountCreationError = failure
-                                    super.onFailure(failure)
-                                }
-                            })
+        commonTestHelper.runBlockingTest {
+            try {
+                commonTestHelper.matrix.authenticationService
+                        .getRegistrationWizard()
+                        .createAccount(
+                                session.myUserId.substringAfter("@").substringBefore(":"),
+                                TestConstants.PASSWORD,
+                                null
+                        )
+            } catch (failure: Throwable) {
+                accountCreationError = failure
+            }
         }
 
         // Test the error

matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CommonTestHelper.kt

@@ -23,7 +23,6 @@ import org.matrix.android.sdk.api.Matrix
 import org.matrix.android.sdk.api.MatrixCallback
 import org.matrix.android.sdk.api.MatrixConfiguration
 import org.matrix.android.sdk.api.auth.data.HomeServerConnectionConfig
-import org.matrix.android.sdk.api.auth.data.LoginFlowResult
 import org.matrix.android.sdk.api.auth.registration.RegistrationResult
 import org.matrix.android.sdk.api.session.Session
 import org.matrix.android.sdk.api.session.events.model.EventType
@@ -210,22 +209,21 @@ class CommonTestHelper(context: Context) {
                                      sessionTestParams: SessionTestParams): Session {
         val hs = createHomeServerConfig()
 
-        doSync<LoginFlowResult> {
-            matrix.authenticationService
-                    .getLoginFlow(hs, it)
+        runBlockingTest {
+            matrix.authenticationService.getLoginFlow(hs)
         }
 
-        doSync<RegistrationResult>(timeout = 60_000) {
+        runBlockingTest(timeout = 60_000) {
             matrix.authenticationService
                     .getRegistrationWizard()
-                    .createAccount(userName, password, null, it)
+                    .createAccount(userName, password, null)
         }
 
         // Perform dummy step
-        val registrationResult = doSync<RegistrationResult>(timeout = 60_000) {
+        val registrationResult = runBlockingTest(timeout = 60_000) {
             matrix.authenticationService
                     .getRegistrationWizard()
-                    .dummy(it)
+                    .dummy()
         }
 
         assertTrue(registrationResult is RegistrationResult.Success)
@@ -249,15 +247,14 @@ class CommonTestHelper(context: Context) {
                                   sessionTestParams: SessionTestParams): Session {
         val hs = createHomeServerConfig()
 
-        doSync<LoginFlowResult> {
-            matrix.authenticationService
-                    .getLoginFlow(hs, it)
+        runBlockingTest {
+            matrix.authenticationService.getLoginFlow(hs)
         }
 
-        val session = doSync<Session> {
+        val session = runBlockingTest {
             matrix.authenticationService
                     .getLoginWizard()
-                    .login(userName, password, "myDevice", it)
+                    .login(userName, password, "myDevice")
         }
 
         if (sessionTestParams.withInitialSync) {
@@ -277,21 +274,19 @@ class CommonTestHelper(context: Context) {
                             password: String): Throwable {
         val hs = createHomeServerConfig()
 
-        doSync<LoginFlowResult> {
-            matrix.authenticationService
-                    .getLoginFlow(hs, it)
+        runBlockingTest {
+            matrix.authenticationService.getLoginFlow(hs)
         }
 
         var requestFailure: Throwable? = null
-        waitWithLatch { latch ->
-            matrix.authenticationService
-                    .getLoginWizard()
-                    .login(userName, password, "myDevice", object : TestMatrixCallback<Session>(latch, onlySuccessful = false) {
-                        override fun onFailure(failure: Throwable) {
-                            requestFailure = failure
-                            super.onFailure(failure)
-                        }
-                    })
+        runBlockingTest {
+            try {
+                matrix.authenticationService
+                        .getLoginWizard()
+                        .login(userName, password, "myDevice")
+            } catch (failure: Throwable) {
+                requestFailure = failure
+            }
         }
 
         assertNotNull(requestFailure)

matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/search/SearchMessagesTest.kt

@@ -61,7 +61,7 @@ class SearchMessagesTest : InstrumentedTest {
                 2)
 
         run {
-            var lock = CountDownLatch(1)
+            val lock = CountDownLatch(1)
 
             val eventListener = commonTestHelper.createEventListener(lock) { snapshot ->
                 snapshot.count { it.root.content.toModel<MessageContent>()?.body?.startsWith(MESSAGE).orFalse() } == 2
@@ -70,7 +70,6 @@ class SearchMessagesTest : InstrumentedTest {
             aliceTimeline.addListener(eventListener)
             commonTestHelper.await(lock)
 
-            lock = CountDownLatch(1)
             val data = commonTestHelper.runBlockingTest {
                 aliceSession
                         .searchService()

vector/src/androidTest/java/im/vector/app/VerificationTestBase.kt

@@ -23,11 +23,11 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
 import org.junit.Assert
 import org.matrix.android.sdk.api.Matrix
 import org.matrix.android.sdk.api.MatrixCallback
 import org.matrix.android.sdk.api.auth.data.HomeServerConnectionConfig
-import org.matrix.android.sdk.api.auth.data.LoginFlowResult
 import org.matrix.android.sdk.api.auth.registration.RegistrationResult
 import org.matrix.android.sdk.api.session.Session
 import org.matrix.android.sdk.api.session.sync.SyncState
@@ -47,22 +47,21 @@ abstract class VerificationTestBase {
                              withInitialSync: Boolean): Session {
         val hs = createHomeServerConfig()
 
-        doSync<LoginFlowResult> {
-            matrix.authenticationService()
-                    .getLoginFlow(hs, it)
+        runBlockingTest {
+            matrix.authenticationService().getLoginFlow(hs)
         }
 
-        doSync<RegistrationResult> {
+        runBlockingTest {
             matrix.authenticationService()
                     .getRegistrationWizard()
-                    .createAccount(userName, password, null, it)
+                    .createAccount(userName, password, null)
         }
 
         // Perform dummy step
-        val registrationResult = doSync<RegistrationResult> {
+        val registrationResult = runBlockingTest {
             matrix.authenticationService()
                     .getRegistrationWizard()
-                    .dummy(it)
+                    .dummy()
         }
 
         Assert.assertTrue(registrationResult is RegistrationResult.Success)
@@ -80,6 +79,14 @@ abstract class VerificationTestBase {
                 .build()
     }
 
+    protected fun <T> runBlockingTest(timeout: Long = 20_000, block: suspend () -> T): T {
+        return runBlocking {
+            withTimeout(timeout) {
+                block()
+            }
+        }
+    }
+
     // Transform a method with a MatrixCallback to a synchronous method
     inline fun <reified T> doSync(block: (MatrixCallback<T>) -> Unit): T {
         val lock = CountDownLatch(1)