Simplify & shrink

Author: jan-goral

test_app/bash/test_filters.sh

@@ -39,4 +39,4 @@ function filter_annotation_method_foo {
 # should exclude both
 function filter_notPackage_foo_notClass_bar {
     run_instrument -e notPackage ${PACKAGE_FOO} -e notClass ${CLASS_BAR}
-}
+}

test_runner/src/main/kotlin/ftl/run/platform/android/CreateAndroidTestContext.kt

@@ -2,10 +2,12 @@ package ftl.run.platform.android
 
 import com.linkedin.dex.parser.DecodedValue
 import com.linkedin.dex.parser.DexParser
+import com.linkedin.dex.parser.TestAnnotation
+import com.linkedin.dex.parser.TestMethod
 import com.linkedin.dex.parser.formatClassName
 import com.linkedin.dex.parser.getAnnotationsDirectory
 import com.linkedin.dex.parser.getClassAnnotationValues
-import com.linkedin.dex.spec.AnnotationsDirectoryItem
+import com.linkedin.dex.spec.ClassDefItem
 import com.linkedin.dex.spec.DexFile
 import ftl.args.AndroidArgs
 import ftl.args.ArgsHelper
@@ -56,48 +58,37 @@ private fun InstrumentationTestContext.calculateShards(
 
 private fun InstrumentationTestContext.getFlankTestMethods(
     testFilter: TestFilter
-): List<FlankTestMethod> {
-    val parameterizedClasses = getParametrizedClasses()
-    return getNonParametrizedClassesTests(testFilter, parameterizedClasses) + parameterizedClasses.toFlankTestMethods()
-}
+): List<FlankTestMethod> =
+    getParametrizedClasses().let { parameterizedClasses: List<String> ->
+        DexParser.findTestMethods(test.local).asSequence()
+            .distinct()
+            .filter(testFilter.shouldRun)
+            .filterNot(parameterizedClasses::belong)
+            .map(TestMethod::toFlankTestMethod).toList()
+            .plus(parameterizedClasses.map(String::toFlankTestMethod))
+    }
 
-private fun InstrumentationTestContext.getParametrizedClasses() =
-    DexParser.readDexFiles(test.local)
-        .fold(mutableListOf<String>()) { parameterizedClasses, file ->
-            file.classDefs.forEach { classDef ->
-                val directory = file.getAnnotationsDirectory(classDef)
-                if (file.hasRunWithAnnotation(directory) && file.isAnnotationParameterIsParametrized(directory)) {
-                    parameterizedClasses += file.formatClassName(classDef).dropLast(1)
-                }
-            }
-            parameterizedClasses
-        }
+private fun List<String>.belong(method: TestMethod) = any { className -> method.testName.startsWith(className) }
 
-private fun DexFile.hasRunWithAnnotation(directory: AnnotationsDirectoryItem?) =
-    getClassAnnotationValues(directory).map { it.name }.any { it.toLowerCase().contains("RunWith".toLowerCase()) }
+private fun TestMethod.toFlankTestMethod() = FlankTestMethod("class $testName", ignored = annotations.any { it.name == "org.junit.Ignore" })
 
-private fun DexFile.isAnnotationParameterIsParametrized(directory: AnnotationsDirectoryItem?) =
-    getClassAnnotationValues(directory)
-        .flatMap { annotations -> annotations.values.values }
-        .filterIsInstance<DecodedValue.DecodedType>()
-        .map { it.value }
-        .any { it.toLowerCase().contains("Parameterized".toLowerCase()) }
+private fun String.toFlankTestMethod() = FlankTestMethod("class $this", ignored = false)
 
-private fun InstrumentationTestContext.getNonParametrizedClassesTests(
-    testFilter: TestFilter,
-    parameterizedClasses: List<String>
-) = DexParser.findTestMethods(test.local).asSequence()
-    .distinct()
-    .filter(testFilter.shouldRun)
-    .filter { method -> parameterizedClasses.none { method.testName.contains(it) } }
-    .map { testMethod ->
-        FlankTestMethod(
-            testName = "class ${testMethod.testName}",
-            ignored = testMethod.annotations.any { it.name == "org.junit.Ignore" }
-        )
-    }.toList()
+private fun InstrumentationTestContext.getParametrizedClasses(): List<String> =
+    DexParser.readDexFiles(test.local).fold(emptyList()) { accumulator, file: DexFile ->
+        accumulator + file.classDefs
+            .filter(file::isParametrizedClass)
+            .map(file::formatClassName) // returns class name + '#'
+            .map { it.dropLast(1) } // so drop '#'
+    }
 
-private fun List<String>.toFlankTestMethods() = map { FlankTestMethod("class $it", false) }
+private fun DexFile.isParametrizedClass(classDef: ClassDefItem): Boolean =
+    getClassAnnotationValues(getAnnotationsDirectory(classDef)).let { annotations: List<TestAnnotation> ->
+        annotations.any { it.name.contains("RunWith", ignoreCase = true) } && annotations
+            .flatMap { it.values.values }
+            .filterIsInstance<DecodedValue.DecodedType>()
+            .any { it.value.contains("Parameterized", ignoreCase = true) }
+    }
 
 private fun List<AndroidTestContext>.dropEmptyInstrumentationTest(): List<AndroidTestContext> =
     filterIsInstance<InstrumentationTestContext>().filter { it.shards.isEmpty() }.let { withoutTests ->

test_runner/src/test/kotlin/ftl/run/platform/android/CreateAndroidTestContextKtTest.kt

@@ -7,7 +7,6 @@ import ftl.run.model.RoboTestContext
 import ftl.test.util.mixedConfigYaml
 import ftl.test.util.should
 import kotlinx.coroutines.runBlocking
-import org.junit.Assert
 import org.junit.Assert.assertEquals
 import org.junit.Test
 
@@ -32,7 +31,7 @@ class CreateAndroidTestContextKtTest {
                 app = should { local.endsWith("app-debug.apk") },
                 test = should { local.endsWith("app-multiple-flaky-debug-androidTest.apk") },
                 shards = listOf(
-                    should { size == 3 },
+                    should { size == 3 && contains("class com.example.test_app.ParameterizedTest") },
                     should { size == 3 }
                 )
             )
@@ -46,18 +45,4 @@ class CreateAndroidTestContextKtTest {
         // then
         assertEquals(expected, actual)
     }
-
-    @Test
-    fun `should contains parametrized test`() {
-        // given
-        val expected = "class com.example.test_app.ParameterizedTest"
-
-        // when
-        val actual = runBlocking {
-            AndroidArgs.load(mixedConfigYaml).createAndroidTestContexts()
-        }.map { it as? InstrumentationTestContext }.filterNotNull().flatMap { it.shards.flatten() }
-
-        // then
-        Assert.assertTrue(actual.contains(expected))
-    }
 }