Add variants (JU5 & 6) to instrumentation modules

Author: mannodermaus

build-logic/src/main/kotlin/Environment.kt

@@ -4,6 +4,14 @@ import org.gradle.api.Project
 import java.io.File
 import java.util.Properties
 
+enum class SupportedJUnit(
+    val label: String,
+    val minSdk: Int
+) {
+    JUnit5(label = "five", minSdk = 26),
+    JUnit6(label = "six", minSdk = 35)
+}
+
 enum class SupportedAgp(
     val version: String,
     val gradle: String,

build-logic/src/main/kotlin/extensions/StringExtensions.kt

@@ -0,0 +1,6 @@
+package extensions
+
+import java.util.Locale.getDefault
+
+fun String.capitalized(): String =
+    replaceFirstChar { if (it.isLowerCase()) it.titlecase(getDefault()) else it.toString() }

build-logic/src/main/kotlin/extensions/VersionCatalogExtensions.kt

@@ -8,7 +8,7 @@ import org.gradle.api.artifacts.VersionCatalogsExtension
 import org.gradle.api.provider.Provider
 import org.gradle.kotlin.dsl.getByType
 
-internal val Project.libs: VersionCatalog
+val Project.libs: VersionCatalog
     get() = extensions.getByType<VersionCatalogsExtension>().named("extensions.libs")
 
 fun VersionCatalog.agp(version: SupportedAgp): String {

instrumentation/build.gradle.kts

@@ -1,5 +1,6 @@
 import com.android.build.api.dsl.LibraryExtension
 import com.android.build.gradle.BaseExtension
+import extensions.capitalized
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
 import org.gradle.api.tasks.testing.logging.TestLogEvent
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
@@ -32,9 +33,9 @@ apiValidation {
 subprojects {
     apply(plugin = "explicit-api-mode")
 
-    val jvmTarget = JvmTarget.JVM_17
-    val javaVersion = JavaVersion.VERSION_17
-
+    val jvmTarget = JvmTarget.JVM_21
+    val javaVersion = JavaVersion.toVersion(jvmTarget.target)
+    
     // Configure Kotlin
     plugins.withType<KotlinBasePlugin> {
         tasks.withType<KotlinCompilationTask<*>>().configureEach {
@@ -48,6 +49,13 @@ subprojects {
         }
     }
 
+    // Configure Java
+    plugins.withId("java") {
+        configure<JavaPluginExtension> {
+            toolchain { languageVersion.set(JavaLanguageVersion.of(javaVersion.majorVersion)) }
+        }
+    }
+
     // Configure Android
     plugins.withId("com.android.base") {
         configure<BaseExtension> {
@@ -71,6 +79,48 @@ subprojects {
                 unitTests.isReturnDefaultValues = true
             }
 
+            // Create product flavors for each supported generation of JUnit,
+            // then declare the corresponding BOM for each of them
+            // to provide dependencies to each target
+            val supportedTargets = SupportedJUnit.values()
+
+            flavorDimensions("target")
+            productFlavors {
+                supportedTargets.forEachIndexed { index, junit ->
+                    register(junit.label) {
+                        dimension = "target"
+                        isDefault = index == supportedTargets.lastIndex
+                    }
+                }
+            }
+
+            dependencies {
+                supportedTargets.forEach { junit ->
+                    val configNames = listOf(
+                        "${junit.label}Api",
+                        "${junit.label}Implementation",
+                        "${junit.label}CompileOnly",
+                        "${junit.label}RuntimeOnly",
+                        "test${junit.label.capitalized()}Implementation",
+                        "test${junit.label.capitalized()}CompileOnly",
+                        "test${junit.label.capitalized()}RuntimeOnly",
+                        "androidTest${junit.label.capitalized()}Implementation",
+                        "androidTest${junit.label.capitalized()}CompileOnly",
+                        "androidTest${junit.label.capitalized()}RuntimeOnly",
+                    )
+
+                    configNames.forEach { configName ->
+                        add(
+                            configurationName = configName,
+                            dependencyNotation = when (junit) {
+                                SupportedJUnit.JUnit5 -> platform(libs.junit.framework.bom5)
+                                SupportedJUnit.JUnit6 -> platform(libs.junit.framework.bom6)
+                            }
+                        )
+                    }
+                }
+            }
+
             if (this is LibraryExtension) {
                 lint {
                     // JUnit 4 refers to java.lang.management APIs, which are absent on Android.

instrumentation/testutil/src/main/kotlin/de/mannodermaus/junit5/testutil/AndroidBuildUtils.kt

@@ -7,21 +7,25 @@ import com.google.common.truth.Truth.assertThat
 import de.mannodermaus.junit5.testutil.reflect.getFieldReflectively
 import de.mannodermaus.junit5.testutil.reflect.setStaticValue
 
-object AndroidBuildUtils {
-
-    fun withApiLevel(api: Int, block: () -> Unit) = withMockedStaticField<Build.VERSION>(
-        fieldName = "SDK_INT",
-        value = api,
-        block = block,
-    )
+public object AndroidBuildUtils {
+
+    public fun withApiLevel(api: Int, block: () -> Unit) {
+        withMockedStaticField<Build.VERSION>(
+            fieldName = "SDK_INT",
+            value = api,
+            block = block,
+        )
+    }
 
-    fun withManufacturer(name: String, block: () -> Unit) = withMockedStaticField<Build>(
-        fieldName = "MANUFACTURER",
-        value = name,
-        block = block,
-    )
+    public fun withManufacturer(name: String, block: () -> Unit) {
+        withMockedStaticField<Build>(
+            fieldName = "MANUFACTURER",
+            value = name,
+            block = block,
+        )
+    }
 
-    fun withMockedInstrumentation(arguments: Bundle = Bundle(), block: () -> Unit) {
+    public fun withMockedInstrumentation(arguments: Bundle = Bundle(), block: () -> Unit) {
         val (oldInstrumentation, oldArguments) = try {
             InstrumentationRegistry.getInstrumentation() to InstrumentationRegistry.getArguments()
         } catch (ignored: Throwable) {

instrumentation/testutil/src/main/kotlin/de/mannodermaus/junit5/testutil/CollectingRunListener.kt

@@ -7,9 +7,8 @@ import org.junit.runner.notification.RunListener
 /**
  * A JUnit 4 [RunListener] that collects information about executed and failed tests.
  */
-class CollectingRunListener : RunListener() {
-
-    data class Results(
+public class CollectingRunListener : RunListener() {
+    public data class Results(
         val successfulTests: List<Description>,
         val failedTests: List<Failure>,
         val ignoredTests: List<Description>
@@ -31,5 +30,5 @@ class CollectingRunListener : RunListener() {
         ignored += description
     }
 
-    fun getResults() = Results(success, failures, ignored)
+    public fun getResults(): Results = Results(success, failures, ignored)
 }