Add speedtest benchmarkandroid-throughput-tests

24 files changed, 999 insertions, 0 deletions

diff --git a/android/test/benchmark/README.md b/android/test/benchmark/README.md
new file mode 100644
index 0000000000..750e27da45
--- /dev/null
+++ b/android/test/benchmark/README.md
@@ -0,0 +1,20 @@
+# Benchmarks
+
+## Setup
+
+Setup the e2e & benchmark properties in your local `gradle.properties`.
+
+Don't forget to specify the IP and port for your target iPerf testing server.
+`mullvad.test.benchmark.target.ip=<IP>`
+`mullvad.test.benchmark.target.port=<PORT>`
+
+## Run tests
+
+Start the test server and is reachable:
+```
+iperf3 -s -p <PORT>
+```
+Make sure the ip and port matches what you've previously configured.
+
+Then start the tests by running the SpeedTests class. The output will be printed in the logs.
+
diff --git a/android/test/benchmark/build.gradle.kts b/android/test/benchmark/build.gradle.kts
new file mode 100644
index 0000000000..4eff073fbf
--- /dev/null
+++ b/android/test/benchmark/build.gradle.kts
@@ -0,0 +1,129 @@
+plugins {
+    alias(libs.plugins.android.test)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.kotlinx.serialization)
+    alias(libs.plugins.junit5.android)
+}
+
+android {
+    namespace = "net.mullvad.mullvadvpn.test.benchmark"
+    compileSdk = libs.versions.compile.sdk.get().toInt()
+    buildToolsVersion = libs.versions.build.tools.get()
+
+    defaultConfig {
+        minSdk = libs.versions.min.sdk.get().toInt()
+        testApplicationId = "net.mullvad.mullvadvpn.test.benchmark"
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        testInstrumentationRunnerArguments["runnerBuilder"] =
+            "de.mannodermaus.junit5.AndroidJUnit5Builder"
+        targetProjectPath = ":app"
+
+        missingDimensionStrategy(FlavorDimensions.BILLING, Flavors.PLAY)
+
+        testInstrumentationRunnerArguments += buildMap {
+            put("clearPackageData", "true")
+
+            // Add all properties starting with "test.e2e" to the testInstrumentationRunnerArguments
+            properties.forEach {
+                if (it.key.startsWith("mullvad.test.e2e") || it.key.startsWith("mullvad.test.benchmark")) {
+                    put(it.key, it.value.toString())
+                }
+            }
+        }
+    }
+
+    flavorDimensions += FlavorDimensions.INFRASTRUCTURE
+
+    productFlavors {
+        create(Flavors.PROD) {
+            dimension = FlavorDimensions.INFRASTRUCTURE
+            buildConfigField(
+                type = "String",
+                name = "INFRASTRUCTURE_BASE_DOMAIN",
+                value = "\"mullvad.net\"",
+            )
+        }
+        create(Flavors.STAGEMOLE) {
+            dimension = FlavorDimensions.INFRASTRUCTURE
+            buildConfigField(
+                type = "String",
+                name = "INFRASTRUCTURE_BASE_DOMAIN",
+                value = "\"stagemole.eu\"",
+            )
+        }
+    }
+
+
+    testOptions { execution = "ANDROIDX_TEST_ORCHESTRATOR" }
+
+    buildFeatures { buildConfig = true }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = libs.versions.jvm.target.get()
+        allWarningsAsErrors = true
+    }
+
+    lint {
+        lintConfig = file("${rootProject.projectDir}/config/lint.xml")
+        abortOnError = true
+        warningsAsErrors = true
+    }
+
+    packaging {
+        resources {
+            pickFirsts +=
+                setOf(
+                    // Fixes packaging error caused by: jetified-junit-*
+                    "META-INF/LICENSE.md",
+                    "META-INF/LICENSE-notice.md",
+                )
+        }
+    }
+    kotlin {
+        compilerOptions {
+            freeCompilerArgs.add("-Xjvm-default=all-compatibility")
+        }
+    }
+}
+
+
+dependencies {
+    implementation(projects.lib.endpoint)
+    implementation(projects.test.common)
+    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))
+    implementation(libs.androidx.test.core)
+    // Fixes: https://github.com/android/android-test/issues/1589
+    implementation(libs.androidx.test.monitor)
+    implementation(libs.androidx.test.runner)
+    implementation(libs.androidx.test.rules)
+    implementation(libs.androidx.test.uiautomator)
+    implementation(libs.kermit)
+    implementation(libs.junit.jupiter.api)
+    implementation(libs.junit5.android.test.extensions)
+    implementation(libs.junit5.android.test.runner)
+    implementation(libs.mockkWebserver)
+
+    implementation(libs.ktor.client.core)
+    implementation(libs.ktor.client.cio)
+    implementation(libs.ktor.client.auth)
+    implementation(libs.ktor.client.logging)
+    implementation(libs.ktor.serialization.kotlinx.json)
+    implementation(libs.ktor.client.content.negotiation)
+    implementation(libs.ktor.client.resources)
+    implementation(libs.ktor.client.json)
+
+    androidTestUtil(libs.androidx.test.orchestrator)
+
+    // Needed or else the app crashes when launched
+    implementation(libs.junit5.android.test.compose)
+    implementation(libs.compose.material3)
+
+    // Need these for forcing later versions of dependencies
+    implementation(libs.compose.ui)
+    implementation(libs.androidx.activity.compose)
+}
diff --git a/android/test/benchmark/lib/arm64-v8a/iperf3.18 b/android/test/benchmark/lib/arm64-v8a/iperf3.18
new file mode 100755
index 0000000000..88b3d782e0
--- /dev/null
+++ b/android/test/benchmark/lib/arm64-v8a/iperf3.18
diff --git a/android/test/benchmark/lib/armeabi-v7a/iperf3.18 b/android/test/benchmark/lib/armeabi-v7a/iperf3.18
new file mode 100755
index 0000000000..e89b4c24d3
--- /dev/null
+++ b/android/test/benchmark/lib/armeabi-v7a/iperf3.18
diff --git a/android/test/benchmark/lib/riscv64/iperf3.18 b/android/test/benchmark/lib/riscv64/iperf3.18
new file mode 100755
index 0000000000..68f874238c
--- /dev/null
+++ b/android/test/benchmark/lib/riscv64/iperf3.18
diff --git a/android/test/benchmark/lib/x86/iperf3.18 b/android/test/benchmark/lib/x86/iperf3.18
new file mode 100755
index 0000000000..e0c5e6d306
--- /dev/null
+++ b/android/test/benchmark/lib/x86/iperf3.18
diff --git a/android/test/benchmark/lib/x86_64/iperf3.18 b/android/test/benchmark/lib/x86_64/iperf3.18
new file mode 100755
index 0000000000..3773b8ce6d
--- /dev/null
+++ b/android/test/benchmark/lib/x86_64/iperf3.18
diff --git a/android/test/benchmark/libs/iperf3.jar b/android/test/benchmark/libs/iperf3.jar
new file mode 100644
index 0000000000..b6d174cdae
--- /dev/null
+++ b/android/test/benchmark/libs/iperf3.jar
diff --git a/android/test/benchmark/src/main/AndroidManifest.xml b/android/test/benchmark/src/main/AndroidManifest.xml
new file mode 100644
index 0000000000..bc5d11c5d4
--- /dev/null
+++ b/android/test/benchmark/src/main/AndroidManifest.xml
@@ -0,0 +1,11 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <instrumentation
+            android:name="androidx.test.runner.AndroidJUnitRunner"
+            android:targetPackage="net.mullvad.mullvadvpn" />
+
+    <application
+            android:extractNativeLibs="true"
+            android:icon="@android:color/background_light" />
+</manifest>
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/BenchmarkTest.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/BenchmarkTest.kt
new file mode 100644
index 0000000000..da8c8c6c8c
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/BenchmarkTest.kt
@@ -0,0 +1,43 @@
+package net.mullvad.mullvadvpn.test.benchmark
+
+import android.Manifest.permission.READ_EXTERNAL_STORAGE
+import android.Manifest.permission.WRITE_EXTERNAL_STORAGE
+import android.content.Context
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.UiDevice
+import co.touchlab.kermit.Logger
+import de.mannodermaus.junit5.extensions.GrantPermissionExtension
+import net.mullvad.mullvadvpn.test.benchmark.constant.LOG_TAG
+import net.mullvad.mullvadvpn.test.common.interactor.AppInteractor
+import net.mullvad.mullvadvpn.test.common.rule.CaptureScreenshotOnFailedTestRule
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.extension.RegisterExtension
+
+abstract class BenchmarkTest {
+
+    @RegisterExtension @JvmField val rule = CaptureScreenshotOnFailedTestRule(LOG_TAG)
+
+    @RegisterExtension
+    @JvmField
+    val permissionRule: GrantPermissionExtension =
+        GrantPermissionExtension.grant(WRITE_EXTERNAL_STORAGE, READ_EXTERNAL_STORAGE)
+
+    lateinit var device: UiDevice
+    lateinit var context: Context
+    lateinit var targetContext: Context
+    lateinit var app: AppInteractor
+
+    @BeforeEach
+    open fun setup() {
+        Logger.setTag(LOG_TAG)
+
+        device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
+        context = InstrumentationRegistry.getInstrumentation().context
+        targetContext = InstrumentationRegistry.getInstrumentation().targetContext
+
+        app = AppInteractor(device, targetContext)
+    }
+
+    @AfterEach open fun teardown() {}
+}
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/IPerf.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/IPerf.kt
new file mode 100644
index 0000000000..cf93b8c3af
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/IPerf.kt
@@ -0,0 +1,31 @@
+package net.mullvad.mullvadvpn.test.benchmark
+
+import android.content.Context
+import androidx.test.platform.app.InstrumentationRegistry
+import java.io.File
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.decodeFromStream
+import net.mullvad.mullvadvpn.test.benchmark.constant.getTargetIp
+import net.mullvad.mullvadvpn.test.benchmark.constant.getTargetPort
+import net.mullvad.mullvadvpn.test.benchmark.model.IperfResult
+
+@OptIn(ExperimentalSerializationApi::class)
+fun runIperf3(context: Context): IperfResult {
+    val iperf = File(context.applicationInfo.nativeLibraryDir + "/iperf3.18")
+    iperf.setExecutable(true)
+    val process =
+        ProcessBuilder(iperf.absolutePath, "-c", InstrumentationRegistry.getArguments().getTargetIp(), "-p",
+            InstrumentationRegistry.getArguments().getTargetPort(), "--json").start()
+    return Json.decodeFromStream<IperfResult>(process.inputStream)
+}
+
+fun IperfResult.summarize(): String = buildString {
+    appendLine("# Speed #")
+    appendLine("Receive: ${end.sumReceived.bitsPerSecond / 1000000} Mbit/s")
+    appendLine("Send: ${end.sumSent.bitsPerSecond / 1000000} Mbit/s")
+    appendLine("# CPU #")
+    appendLine("User: ${end.cpuUtilizationPercent.hostUser}")
+    appendLine("System: ${end.cpuUtilizationPercent.hostSystem}")
+    appendLine("Total: ${end.cpuUtilizationPercent.hostTotal}")
+}
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/IperfResultTest.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/IperfResultTest.kt
new file mode 100644
index 0000000000..ab2f76cb7f
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/IperfResultTest.kt
@@ -0,0 +1,20 @@
+package net.mullvad.mullvadvpn.test.benchmark
+
+import co.touchlab.kermit.Logger
+import java.io.BufferedReader
+import java.io.File
+import java.io.IOException
+import java.io.InputStreamReader
+import kotlinx.serialization.json.Json
+import net.mullvad.mullvadvpn.test.benchmark.model.IperfResult
+import org.junit.jupiter.api.Test
+
+class IperfResultTest : BenchmarkTest() {
+
+    @Test
+    fun testIPerf() {
+        val result = runIperf3(context)
+        Logger.d("!!! TESTING !!!")
+        Logger.d(result.summarize())
+    }
+}
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/SpeedTest.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/SpeedTest.kt
new file mode 100644
index 0000000000..7e9a67bea2
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/SpeedTest.kt
@@ -0,0 +1,118 @@
+package net.mullvad.mullvadvpn.test.benchmark
+
+import co.touchlab.kermit.Logger
+import net.mullvad.mullvadvpn.test.benchmark.rule.AccountTestRule
+import net.mullvad.mullvadvpn.test.common.extension.acceptVpnPermissionDialog
+import net.mullvad.mullvadvpn.test.common.page.ConnectPage
+import net.mullvad.mullvadvpn.test.common.page.SelectLocationPage
+import net.mullvad.mullvadvpn.test.common.page.SettingsPage
+import net.mullvad.mullvadvpn.test.common.page.VpnSettingsPage
+import net.mullvad.mullvadvpn.test.common.page.on
+import net.mullvad.mullvadvpn.test.common.rule.ForgetAllVpnAppsInSettingsTestRule
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.RegisterExtension
+
+class SpeedTest : BenchmarkTest() {
+
+    @RegisterExtension @JvmField val accountTestRule = AccountTestRule()
+
+    @RegisterExtension
+    @JvmField
+    val forgetAllVpnAppsInSettingsTestRule = ForgetAllVpnAppsInSettingsTestRule()
+
+    @Test
+    fun noVpn() {
+        val result = runIperf3(context)
+
+        Logger.d("# No VPN result #")
+        Logger.d(result.summarize())
+    }
+
+    @Test
+    fun testNoObfuscation() {
+        // Given
+        app.launchAndLogIn(accountTestRule.validAccountNumber)
+
+        on<ConnectPage> { clickSettings() }
+        on<SettingsPage> { clickVpnSettings() }
+        on<VpnSettingsPage> {
+            scrollUntilWireGuardObfuscationOffCell()
+            clickWireGuardObfuscationOffCell()
+        }
+        device.pressBack()
+        device.pressBack()
+
+        on<ConnectPage> { clickSelectLocation() }
+
+        on<SelectLocationPage> {
+            clickLocationExpandButton(DEFAULT_COUNTRY)
+            clickLocationExpandButton(DEFAULT_CITY)
+            clickLocationCell(DEFAULT_RELAY)
+        }
+
+        device.acceptVpnPermissionDialog()
+
+        on<ConnectPage> { waitForConnectedLabel() }
+
+        val result = runIperf3(context)
+
+        Logger.d("# No obfuscation #")
+        Logger.d(result.summarize())
+    }
+
+    @Test
+    fun testUdpOverTcpObfuscation() {
+        // Given
+        app.launchAndLogIn(accountTestRule.validAccountNumber)
+
+        on<ConnectPage> { clickSettings() }
+        on<SettingsPage> { clickVpnSettings() }
+        on<VpnSettingsPage> {
+            scrollUntilWireGuardObfuscationUdpOverTcpCell()
+            clickWireguardObfuscationUdpOverTcpCell()
+        }
+        device.pressBack()
+        device.pressBack()
+
+        on<ConnectPage> { clickConnect() }
+
+        device.acceptVpnPermissionDialog()
+
+        on<ConnectPage> { waitForConnectedLabel() }
+
+        val result = runIperf3(context)
+
+        Logger.d("# Udp-over-Tcp #")
+        Logger.d(result.summarize())
+    }
+
+    @Test
+    fun testShadowsocks() {
+        // Given
+        app.launchAndLogIn(accountTestRule.validAccountNumber)
+
+        on<ConnectPage> { clickSettings() }
+        on<SettingsPage> { clickVpnSettings() }
+        on<VpnSettingsPage> {
+            scrollUntilWireGuardObfuscationShadowsocksCell()
+            clickWireGuardObfuscationShadowsocksCell()
+        }
+        device.pressBack()
+        device.pressBack()
+
+        on<ConnectPage> { clickConnect() }
+
+        device.acceptVpnPermissionDialog()
+
+        on<ConnectPage> { waitForConnectedLabel() }
+
+        val result = runIperf3(context)
+
+        Logger.d("# Shadowsocks #")
+        Logger.d(result.summarize())
+    }
+}
+
+const val DEFAULT_COUNTRY = "Sweden"
+const val DEFAULT_CITY = "Gothenburg"
+const val DEFAULT_RELAY = "se-got-wg-001"
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/connectioncheck/ConnCheckResult.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/connectioncheck/ConnCheckResult.kt
new file mode 100644
index 0000000000..18f5417314
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/connectioncheck/ConnCheckResult.kt
@@ -0,0 +1,15 @@
+package net.mullvad.mullvadvpn.test.benchmark.api.connectioncheck
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ConnCheckResult(
+    @SerialName("mullvad_exit_ip") val mullvadExitIp: Boolean,
+    val ip: String,
+    val organization: String,
+    val country: String,
+    val city: String,
+    val longitude: Double,
+    val latitude: Double,
+)
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/connectioncheck/ConnectionCheckApi.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/connectioncheck/ConnectionCheckApi.kt
new file mode 100644
index 0000000000..a434010462
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/connectioncheck/ConnectionCheckApi.kt
@@ -0,0 +1,48 @@
+package net.mullvad.mullvadvpn.test.benchmark.api.connectioncheck
+
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.engine.cio.CIO
+import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.client.plugins.defaultRequest
+import io.ktor.client.plugins.logging.LogLevel
+import io.ktor.client.plugins.logging.Logging
+import io.ktor.client.request.get
+import io.ktor.http.ContentType
+import io.ktor.http.URLProtocol.Companion.HTTPS
+import io.ktor.http.contentType
+import io.ktor.http.path
+import io.ktor.serialization.kotlinx.json.json
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import net.mullvad.mullvadvpn.test.benchmark.BuildConfig
+
+class ConnectionCheckApi {
+    private val client: HttpClient =
+        HttpClient(CIO) {
+            install(ContentNegotiation) { json(Json { ignoreUnknownKeys = true }) }
+            install(Logging) {
+                level = LogLevel.INFO
+            }
+            defaultRequest {
+                url {
+                    protocol = HTTPS
+                    host = BASE_URL
+                }
+                contentType(ContentType.Application.Json)
+            }
+            expectSuccess = true
+        }
+
+    suspend fun connectionCheck(): ConnCheckResult =
+        withContext(Dispatchers.IO) {
+            client.get { url { path(JSON_PATH) } }.body<ConnCheckResult>()
+        }
+
+    companion object {
+        // Connection check
+        private const val BASE_URL = "am.i.${BuildConfig.INFRASTRUCTURE_BASE_DOMAIN}"
+        private const val JSON_PATH = "json"
+    }
+}
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/connectioncheck/ConnectionCheckApiTest.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/connectioncheck/ConnectionCheckApiTest.kt
new file mode 100644
index 0000000000..39622c25c4
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/connectioncheck/ConnectionCheckApiTest.kt
@@ -0,0 +1,19 @@
+package net.mullvad.mullvadvpn.test.benchmark.api.connectioncheck
+
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Disabled
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertNotNull
+
+@Disabled("Only used developing the ConnectionCheckApi")
+class ConnectionCheckApiTest {
+    private val connCheckApi = ConnectionCheckApi()
+
+    @Test
+    fun testConnCheck() = runTest {
+        val result = connCheckApi.connectionCheck()
+        assertNotNull(result)
+        assertFalse(result.mullvadExitIp)
+    }
+}
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/mullvad/MullvadApi.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/mullvad/MullvadApi.kt
new file mode 100644
index 0000000000..6d9f75c938
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/mullvad/MullvadApi.kt
@@ -0,0 +1,120 @@
+package net.mullvad.mullvadvpn.test.benchmark.api.mullvad
+
+import co.touchlab.kermit.Logger
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.engine.cio.CIO
+import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.client.plugins.defaultRequest
+import io.ktor.client.plugins.logging.LogLevel
+import io.ktor.client.plugins.logging.Logging
+import io.ktor.client.plugins.resources.Resources
+import io.ktor.client.request.bearerAuth
+import io.ktor.client.request.delete
+import io.ktor.client.request.get
+import io.ktor.client.request.post
+import io.ktor.client.request.setBody
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.ContentType
+import io.ktor.http.HttpHeaders
+import io.ktor.http.URLProtocol.Companion.HTTPS
+import io.ktor.http.contentType
+import io.ktor.http.path
+import io.ktor.serialization.kotlinx.json.json
+import io.ktor.utils.io.InternalAPI
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import net.mullvad.mullvadvpn.test.benchmark.BuildConfig
+
+class MullvadApi {
+    private val json = Json {
+        ignoreUnknownKeys = true
+        prettyPrint = true
+        isLenient = true
+    }
+    private val client: HttpClient =
+        HttpClient(CIO) {
+            install(ContentNegotiation) { json(json) }
+            install(Resources)
+            install(Logging) {
+                level = LogLevel.INFO
+                sanitizeHeader { header -> header == HttpHeaders.Authorization }
+            }
+
+            defaultRequest {
+                url {
+                    protocol = HTTPS
+                    host = BASE_URL
+                }
+                contentType(ContentType.Application.Json)
+            }
+            expectSuccess = true
+        }
+
+    @OptIn(InternalAPI::class)
+    suspend fun login(accountNumber: String): String =
+        withContext(Dispatchers.IO) {
+            val test =
+                client
+                    .post {
+                        url { path(AUTH_PATH) }
+                        setBody(LoginRequest(accountNumber))
+                    }
+                    .also {
+                        Logger.d("Login response: ${it}")
+                        Logger.d("Login response: ${it.bodyAsText()}")
+                    }
+                    .bodyAsText()
+            json.decodeFromString<LoginResponse>(test).
+                also {
+                    Logger.d { "Login response: $it" }
+                }.accessToken
+        }
+
+    @Serializable data class Device(val name: String, val id: String)
+
+    suspend fun getDeviceList(accessToken: String): List<String> =
+        withContext(Dispatchers.IO) {
+            client
+                .get {
+                    url { path(DEVICES_PATH) }
+                    bearerAuth(accessToken)
+                }
+                .body<List<Device>>()
+                .map { it.id }
+        }
+
+    suspend fun removeDevice(accessToken: String, deviceId: String) =
+        withContext(Dispatchers.IO) {
+            client.delete {
+                url { path("$DEVICES_PATH/$deviceId") }
+                bearerAuth(accessToken)
+            }
+        }
+
+    companion object {
+        private const val BASE_URL = "api-app.${BuildConfig.INFRASTRUCTURE_BASE_DOMAIN}"
+        private const val AUTH_PATH = "auth/v1/token"
+        private const val DEVICES_PATH = "accounts/v1/devices"
+    }
+}
+
+@OptIn(ExperimentalSerializationApi::class)
+@Serializable
+data class LoginRequest(@SerialName("account_number") val accountNumber: String)
+
+@Serializable data class LoginResponse(@SerialName("access_token") val accessToken: String)
+
+suspend fun MullvadApi.removeAllDevices(accessToken: String) =
+    withContext(Dispatchers.IO) {
+        val token = login(accessToken)
+        val devices = getDeviceList(token)
+
+        devices.map { async { removeDevice(token, it) } }.awaitAll()
+    }
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/mullvad/MullvadApiTest.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/mullvad/MullvadApiTest.kt
new file mode 100644
index 0000000000..fec9e4e4a7
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/mullvad/MullvadApiTest.kt
@@ -0,0 +1,28 @@
+package net.mullvad.mullvadvpn.test.benchmark.api.mullvad
+
+import kotlinx.coroutines.test.runTest
+import net.mullvad.mullvadvpn.test.benchmark.rule.AccountProvider
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Disabled
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertDoesNotThrow
+
+@Disabled("Only used developing the MullvadApi")
+class MullvadApiTest {
+    private val mullvadApi = MullvadApi()
+
+    @Test
+    fun testLogin() = runTest {
+        val validAccountNumber = AccountProvider.getValidAccountNumber()
+        val accessToken = assertDoesNotThrow { mullvadApi.login(validAccountNumber) }
+        assertTrue(accessToken.isNotBlank())
+    }
+
+    @Test
+    fun testGetDeviceList() = runTest {
+        val validAccountNumber = AccountProvider.getValidAccountNumber()
+        val accessToken = assertDoesNotThrow { mullvadApi.login(validAccountNumber) }
+        assertTrue(accessToken.isNotBlank())
+        assertDoesNotThrow { mullvadApi.getDeviceList(accessToken) }
+    }
+}
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/partner/PartnerApi.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/partner/PartnerApi.kt
new file mode 100644
index 0000000000..f9210574d3
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/partner/PartnerApi.kt
@@ -0,0 +1,72 @@
+package net.mullvad.mullvadvpn.test.benchmark.api.partner
+
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.engine.cio.CIO
+import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.client.plugins.defaultRequest
+import io.ktor.client.plugins.logging.LogLevel
+import io.ktor.client.plugins.logging.Logging
+import io.ktor.client.request.headers
+import io.ktor.client.request.post
+import io.ktor.client.request.setBody
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.ContentType
+import io.ktor.http.HttpHeaders
+import io.ktor.http.URLProtocol.Companion.HTTPS
+import io.ktor.http.contentType
+import io.ktor.http.path
+import io.ktor.serialization.kotlinx.json.json
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import net.mullvad.mullvadvpn.test.benchmark.BuildConfig
+
+class PartnerApi(base64AuthCredentials: String) {
+    private val client: HttpClient =
+        HttpClient(CIO) {
+            install(ContentNegotiation) { json(Json { ignoreUnknownKeys = true }) }
+            
+            install(Logging) {
+                level = LogLevel.INFO
+                sanitizeHeader { header -> header == HttpHeaders.Authorization }
+            }
+
+            defaultRequest {
+                url {
+                    protocol = HTTPS
+                    host = BASE_URL
+                }
+                contentType(ContentType.Application.Json)
+
+                headers { append("Authorization", "Basic $base64AuthCredentials") }
+            }
+            expectSuccess = true
+        }
+
+    suspend fun createAccount(): String =
+        withContext(Dispatchers.IO) {
+            client.post { url { path(ACCOUNT_PATH) } }.body<CreateAccountResponse>().id
+        }
+
+    suspend fun addTime(accountNumber: String, daysToAdd: Int) =
+        withContext(Dispatchers.IO) {
+            val request = AddTimeRequest(daysToAdd)
+            client
+                .post {
+                    url { path("$ACCOUNT_PATH/$accountNumber/extend") }
+                    setBody(request)
+                }
+                .bodyAsText()
+        }
+
+    companion object {
+        private const val BASE_URL = "partner.${BuildConfig.INFRASTRUCTURE_BASE_DOMAIN}"
+        private const val ACCOUNT_PATH = "v1/accounts"
+    }
+}
+
+@Serializable data class CreateAccountResponse(val id: String)
+
+@Serializable data class AddTimeRequest(val days: Int)
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/partner/PartnerApiTest.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/partner/PartnerApiTest.kt
new file mode 100644
index 0000000000..d709a1331e
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/api/partner/PartnerApiTest.kt
@@ -0,0 +1,26 @@
+package net.mullvad.mullvadvpn.test.benchmark.api.partner
+
+import androidx.test.platform.app.InstrumentationRegistry
+import kotlinx.coroutines.test.runTest
+import net.mullvad.mullvadvpn.test.benchmark.constant.getPartnerAuth
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Disabled
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertDoesNotThrow
+
+@Disabled("Only used developing the PartnerApi")
+class PartnerApiTest {
+    private val partnerApi = PartnerApi(InstrumentationRegistry.getArguments().getPartnerAuth()!!)
+
+    @Test
+    fun testCreateAccount() = runTest {
+        val accessToken = assertDoesNotThrow { partnerApi.createAccount() }
+        assertTrue(accessToken.isNotBlank())
+    }
+
+    @Test
+    fun testAddTime() = runTest {
+        val accessToken = assertDoesNotThrow { partnerApi.createAccount() }
+        assertDoesNotThrow { partnerApi.addTime(accessToken, 1) }
+    }
+}
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/constant/Constants.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/constant/Constants.kt
new file mode 100644
index 0000000000..6d7859386c
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/constant/Constants.kt
@@ -0,0 +1,37 @@
+package net.mullvad.mullvadvpn.test.benchmark.constant
+
+import android.os.Bundle
+import net.mullvad.mullvadvpn.test.benchmark.BuildConfig
+
+const val LOG_TAG = "mullvad-benchmark"
+
+fun Bundle.getRequiredArgument(argument: String): String {
+    return getString(argument)
+        ?: throw IllegalArgumentException("Missing required argument: $argument")
+}
+
+fun Bundle.getPartnerAuth() = getString("mullvad.test.e2e.${BuildConfig.FLAVOR}.partnerAuth")
+
+fun Bundle.getValidAccountNumber() =
+    getRequiredArgument("mullvad.test.e2e.${BuildConfig.FLAVOR}.accountNumber.valid")
+
+fun Bundle.getTargetIp() = getRequiredArgument("mullvad.test.benchmark.target.ip")
+
+fun Bundle.getTargetPort() = getRequiredArgument("mullvad.test.benchmark.target.port")
+
+fun Bundle.getInvalidAccountNumber() =
+    getRequiredArgument("mullvad.test.e2e.${BuildConfig.FLAVOR}.accountNumber.invalid")
+
+fun Bundle.isRaasEnabled(): Boolean =
+    getRequiredArgument("mullvad.test.e2e.config.raas.enable").toBoolean()
+
+fun Bundle.isHighlyRateLimitedTestsEnabled(): Boolean =
+    getRequiredArgument("mullvad.test.e2e.config.runHighlyRateLimitedTests").toBoolean()
+
+fun Bundle.getRaasHost() = getRequiredArgument("mullvad.test.e2e.config.raas.host")
+
+fun Bundle.getTrafficGeneratorHost(): String =
+    getRequiredArgument("mullvad.test.e2e.config.raas.trafficGenerator.target.host")
+
+fun Bundle.getTrafficGeneratorPort(): Int =
+    getRequiredArgument("mullvad.test.e2e.config.raas.trafficGenerator.target.port").toInt()
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/model/IperfResult.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/model/IperfResult.kt
new file mode 100644
index 0000000000..a7d6aba7d5
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/model/IperfResult.kt
@@ -0,0 +1,217 @@
+package net.mullvad.mullvadvpn.test.benchmark.model
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class IperfResult(
+    val start: Start,
+    val intervals: List<Interval>,
+    val end: End,
+)
+
+@Serializable
+data class Start(
+    val connected: List<Connected>,
+    val version: String,
+
+    @SerialName("system_info")
+    val systemInfo: String,
+    val timestamp: Timestamp,
+    @SerialName("connecting_to")
+    val connectingTo: ConnectingTo,
+    val cookie: String,
+    @SerialName("tcp_mss_default")
+    val tcpMssDefault: Long,
+    @SerialName("target_bitrate")
+    val targetBitrate: Long,
+    @SerialName("fq_rate")
+    val fqRate: Long,
+    @SerialName("sock_bufsize")
+    val sockBufsize: Long,
+    @SerialName("sndbuf_actual")
+    val sndbufActual: Long,
+    @SerialName("rcvbuf_actual")
+    val rcvbufActual: Long,
+    @SerialName("test_start")
+    val testStart: TestStart,
+)
+
+@Serializable
+data class Connected(
+    val socket: Long,
+    @SerialName("local_host")
+    val localHost: String,
+    @SerialName("local_port")
+    val localPort: Long,
+    @SerialName("remote_host")
+    val remoteHost: String,
+    @SerialName("remote_port")
+    val remotePort: Long,
+)
+
+@Serializable
+data class Timestamp(
+    val time: String,
+    val timesecs: Long,
+)
+
+@Serializable
+data class ConnectingTo(
+    val host: String,
+    val port: Long,
+)
+
+@Serializable
+data class TestStart(
+    val protocol: String,
+    @SerialName("num_streams")
+    val numStreams: Long,
+    val blksize: Long,
+    val omit: Long,
+    val duration: Long,
+    val bytes: Long,
+    val blocks: Long,
+    val reverse: Long,
+    val tos: Long,
+    @SerialName("target_bitrate")
+    val targetBitrate: Long,
+    val bidir: Long,
+    val fqrate: Long,
+    val interval: Long,
+)
+
+@Serializable
+data class Interval(
+    val streams: List<Stream>,
+    val sum: Sum,
+)
+
+@Serializable
+data class Stream(
+    val socket: Long,
+    val start: Double,
+    val end: Double,
+    val seconds: Double,
+    val bytes: Long,
+    @SerialName("bits_per_second")
+    val bitsPerSecond: Double,
+    val retransmits: Long,
+    @SerialName("snd_cwnd")
+    val sndCwnd: Long,
+    @SerialName("snd_wnd")
+    val sndWnd: Long,
+    val rtt: Long,
+    val rttvar: Long,
+    val pmtu: Long,
+    val omitted: Boolean,
+    val sender: Boolean,
+)
+
+@Serializable
+data class Sum(
+    val start: Double,
+    val end: Double,
+    val seconds: Double,
+    val bytes: Long,
+    @SerialName("bits_per_second")
+    val bitsPerSecond: Double,
+    val retransmits: Long,
+    val omitted: Boolean,
+    val sender: Boolean,
+)
+
+@Serializable
+data class End(
+    val streams: List<Stream2>,
+    @SerialName("sum_sent")
+    val sumSent: SumSent,
+    @SerialName("sum_received")
+    val sumReceived: SumReceived,
+    @SerialName("cpu_utilization_percent")
+    val cpuUtilizationPercent: CpuUtilizationPercent,
+    @SerialName("sender_tcp_congestion")
+    val senderTcpCongestion: String,
+    @SerialName("receiver_tcp_congestion")
+    val receiverTcpCongestion: String,
+)
+
+@Serializable
+data class Stream2(
+    val sender: Sender,
+    val receiver: Receiver,
+)
+
+@Serializable
+data class Sender(
+    val socket: Long,
+    val start: Long,
+    val end: Double,
+    val seconds: Double,
+    val bytes: Long,
+    @SerialName("bits_per_second")
+    val bitsPerSecond: Double,
+    val retransmits: Long,
+    @SerialName("max_snd_cwnd")
+    val maxSndCwnd: Long,
+    @SerialName("max_snd_wnd")
+    val maxSndWnd: Long,
+    @SerialName("max_rtt")
+    val maxRtt: Long,
+    @SerialName("min_rtt")
+    val minRtt: Long,
+    @SerialName("mean_rtt")
+    val meanRtt: Long,
+    val sender: Boolean,
+)
+
+@Serializable
+data class Receiver(
+    val socket: Long,
+    val start: Long,
+    val end: Double,
+    val seconds: Double,
+    val bytes: Long,
+    @SerialName("bits_per_second")
+    val bitsPerSecond: Double,
+    val sender: Boolean,
+)
+
+@Serializable
+data class SumSent(
+    val start: Long,
+    val end: Double,
+    val seconds: Double,
+    val bytes: Long,
+    @SerialName("bits_per_second")
+    val bitsPerSecond: Double,
+    val retransmits: Long,
+    val sender: Boolean,
+)
+
+@Serializable
+data class SumReceived(
+    val start: Long,
+    val end: Double,
+    val seconds: Double,
+    val bytes: Long,
+    @SerialName("bits_per_second")
+    val bitsPerSecond: Double,
+    val sender: Boolean,
+)
+
+@Serializable
+data class CpuUtilizationPercent(
+    @SerialName("host_total")
+    val hostTotal: Double,
+    @SerialName("host_user")
+    val hostUser: Double,
+    @SerialName("host_system")
+    val hostSystem: Double,
+    @SerialName("remote_total")
+    val remoteTotal: Double,
+    @SerialName("remote_user")
+    val remoteUser: Double,
+    @SerialName("remote_system")
+    val remoteSystem: Double,
+)
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/rule/AccountProvider.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/rule/AccountProvider.kt
new file mode 100644
index 0000000000..64e7a8b224
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/rule/AccountProvider.kt
@@ -0,0 +1,30 @@
+package net.mullvad.mullvadvpn.test.benchmark.rule
+
+import androidx.test.platform.app.InstrumentationRegistry
+import net.mullvad.mullvadvpn.test.benchmark.api.mullvad.MullvadApi
+import net.mullvad.mullvadvpn.test.benchmark.api.mullvad.removeAllDevices
+import net.mullvad.mullvadvpn.test.benchmark.api.partner.PartnerApi
+import net.mullvad.mullvadvpn.test.benchmark.constant.getInvalidAccountNumber
+import net.mullvad.mullvadvpn.test.benchmark.constant.getPartnerAuth
+import net.mullvad.mullvadvpn.test.benchmark.constant.getValidAccountNumber
+
+object AccountProvider {
+    private val mullvadClient = MullvadApi()
+    private val partnerAuth: String? = InstrumentationRegistry.getArguments().getPartnerAuth()
+    private val partnerClient: PartnerApi by lazy { PartnerApi(partnerAuth!!) }
+
+    suspend fun getValidAccountNumber() =
+        // If partner auth is provided, create a new account using the partner API. Otherwise we
+        // expect and account with time to be provided.
+        if (partnerAuth != null) {
+            val accountNumber = partnerClient.createAccount()
+            partnerClient.addTime(accountNumber = accountNumber, daysToAdd = 1)
+            accountNumber
+        } else {
+            val validAccountNumber = InstrumentationRegistry.getArguments().getValidAccountNumber()
+            mullvadClient.removeAllDevices(validAccountNumber)
+            validAccountNumber
+        }
+
+    fun getInvalidAccountNumber() = InstrumentationRegistry.getArguments().getInvalidAccountNumber()
+}
diff --git a/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/rule/AccountTestRule.kt b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/rule/AccountTestRule.kt
new file mode 100644
index 0000000000..4859b92f2e
--- /dev/null
+++ b/android/test/benchmark/src/main/kotlin/net/mullvad/mullvadvpn/test/benchmark/rule/AccountTestRule.kt
@@ -0,0 +1,15 @@
+package net.mullvad.mullvadvpn.test.benchmark.rule
+
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.extension.BeforeEachCallback
+import org.junit.jupiter.api.extension.ExtensionContext
+
+class AccountTestRule : BeforeEachCallback {
+    lateinit var validAccountNumber: String
+    lateinit var invalidAccountNumber: String
+
+    override fun beforeEach(context: ExtensionContext): Unit = runBlocking {
+        validAccountNumber = AccountProvider.getValidAccountNumber()
+        invalidAccountNumber = AccountProvider.getInvalidAccountNumber()
+    }
+}