Clarify generic-only inline value class support

Signed-off-by: Ogu1208 <kdasunb6@gmail.com>

Author: Ogu1208

documentation/modules/ROOT/partials/release-notes/release-notes-6.1.0-M2.adoc

@@ -51,9 +51,10 @@ repository on GitHub.
 * Introduce new `trimStacktrace(Class<?>)` and `retainStackTraceElements(int)`
   methods for `AssertionFailureBuilder`. These allow user defined assertions to
   trim their stacktrace.
-* Kotlin inline value classes (such as `Result<T>`) can now be used as parameters in
-`@ParameterizedTest` methods when `kotlin-reflect` is on the classpath.
-See {junit-team-issue}5081[#5081].
+* Generic inline value classes (such as `kotlin.Result<T>`) can now be used as parameters
+in `@ParameterizedTest` methods when `kotlin-reflect` is on the classpath.
+Note: Primitive-wrapper inline value classes (e.g., `UInt`, custom value classes wrapping
+primitives) are not yet supported. See {junit-team-issue}5081[#5081].
 
 [[v6.1.0-M2-junit-vintage]]
 === JUnit Vintage

jupiter-tests/src/test/kotlin/org/junit/jupiter/api/kotlin/GenericInlineValueClassTests.kt

@@ -0,0 +1,69 @@
+package org.junit.jupiter.api.kotlin
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
+
+/**
+ * Tests for generic inline value classes.
+ * These work because they compile to Object in JVM, bypassing strict type validation.
+ */
+class GenericInlineValueClassTests {
+
+    @MethodSource("resultProvider")
+    @ParameterizedTest
+    fun testResult(result: Result<String>) {
+        assertEquals("success", result.getOrThrow())
+    }
+
+    @MethodSource("multipleResultsProvider")
+    @ParameterizedTest
+    fun testMultipleResults(
+        result1: Result<String>,
+        result2: Result<Int>
+    ) {
+        assertEquals("data", result1.getOrThrow())
+        assertEquals(42, result2.getOrThrow())
+    }
+
+    @MethodSource("nullableResultProvider")
+    @ParameterizedTest
+    fun testNullableResult(result: Result<String>?) {
+        assertEquals("test", result?.getOrNull())
+    }
+
+    @MethodSource("customGenericProvider")
+    @ParameterizedTest
+    fun testCustomGenericContainer(container: Container<String>) {
+        assertEquals("content", container.value)
+    }
+
+    companion object {
+        @JvmStatic
+        fun resultProvider() = listOf(
+            Arguments.of(Result.success("success"))
+        )
+
+        @JvmStatic
+        fun multipleResultsProvider() = listOf(
+            Arguments.of(
+                Result.success("data"),
+                Result.success(42)
+            )
+        )
+
+        @JvmStatic
+        fun nullableResultProvider() = listOf(
+            Arguments.of(Result.success("test"))
+        )
+
+        @JvmStatic
+        fun customGenericProvider() = listOf(
+            Arguments.of(Container("content"))
+        )
+    }
+}
+
+@JvmInline
+value class Container<T>(val value: T)

jupiter-tests/src/test/kotlin/org/junit/jupiter/api/kotlin/MultipleInlineValueClassTests.kt

@@ -7,15 +7,24 @@ import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.MethodSource
 
 /**
- * Tests for custom inline value classes.
+ * Tests for primitive-wrapper inline value classes.
  *
- * Currently, disabled: The POC only supports kotlin.Result.
- * Support for arbitrary inline value classes needs to be added.
+ * Currently disabled: These fail because Kotlin compiles them to primitives
+ * (UInt→int, UserId→long), causing JUnit's type validation to fail before
+ * reaching the invocation logic.
+ *
+ * Supporting these would require modifications to JUnit's core type validation system.
  *
  * @see <a href="https://github.com/junit-team/junit-framework/issues/5081">Issue #5081</a>
  */
-@Disabled("POC only supports kotlin.Result, not custom inline value classes")
-class CustomInlineValueClassTests {
+@Disabled("Primitive-wrapper inline value classes are not yet supported")
+class PrimitiveWrapperInlineValueClassTests {
+
+    @MethodSource("uintProvider")
+    @ParameterizedTest
+    fun testUInt(value: UInt) {
+        assertEquals(42u, value)
+    }
 
     @MethodSource("userIdProvider")
     @ParameterizedTest
@@ -30,10 +39,19 @@ class CustomInlineValueClassTests {
     }
 
     companion object {
+        @JvmStatic
+        fun uintProvider() = listOf(Arguments.of(42u))
+
         @JvmStatic
         fun userIdProvider() = listOf(Arguments.of(UserId(123L)))
 
         @JvmStatic
         fun emailProvider() = listOf(Arguments.of(Email("test@example.com")))
     }
-}
+}
+
+@JvmInline
+value class UserId(val value: Long)
+
+@JvmInline
+value class Email(val value: String)