Fix #3303: distinguish JUnit 6 ParameterizedClass invocations (#3432)

* Fix #3303: keep JUnit 6 ParameterizedClass invocations distinct

@ParameterizedClass uses a [class-template-invocation:#N] unique-id
segment and a ClassSource parent. The method legacy name no longer
carries [N], so rerunFailingTestsCount merged a pass+fail pair into
one flaky name.

Append that index to the reported method name, same as we already do
for @ParameterizedTest.

* Fix #3303: keep nested ParameterizedClass indices

Collect every class-template-invocation index so nested parameterizations stay distinct. Do not re-append when the legacy name already carries the class index.

* Fix #3303: parse UniqueId segments for class/method indexes

Use UniqueId.parse().getSegments() instead of string scanning.
Rebuild the reported name as [class][method] so a method-only
legacy suffix is not treated as the class index.

Author: AzazelSensei

surefire-providers/surefire-junit-platform/src/main/java/org/apache/maven/surefire/junitplatform/RunListenerAdapter.java

@@ -283,6 +283,37 @@ private Stream<TestIdentifier> collectAllTestIdentifiersInHierarchy(TestIdentifi
                 .orElseGet(Stream::empty);
     }
 
+    /**
+     * Collect every {@code [class-template-invocation:#N]} / {@code [test-template-invocation:#N]}
+     * index from the unique id. Nested {@code @ParameterizedClass} declarations emit more than
+     * one class segment; taking only the last would collapse outer #1/inner #1 with outer #2/inner #1.
+     *
+     * @param uniqueId the platform unique id string
+     * @param segmentType {@code class-template-invocation} or {@code test-template-invocation}
+     * @return {@code [outer][inner]} or empty when the id has no such segment
+     */
+    private static String extractInvocationIndexSuffix(String uniqueId, String segmentType) {
+        if (uniqueId == null || uniqueId.isEmpty()) {
+            return "";
+        }
+        try {
+            StringBuilder suffix = new StringBuilder();
+            for (UniqueId.Segment segment : UniqueId.parse(uniqueId).getSegments()) {
+                if (!segmentType.equals(segment.getType())) {
+                    continue;
+                }
+                String value = segment.getValue();
+                if (value.startsWith("#")) {
+                    value = value.substring(1);
+                }
+                suffix.append('[').append(value).append(']');
+            }
+            return suffix.toString();
+        } catch (RuntimeException ignored) {
+            return "";
+        }
+    }
+
     private String safeGetMessage(Throwable throwable) {
         try {
             SafeThrowable t = throwable == null ? null : new SafeThrowable(throwable);
@@ -553,14 +584,37 @@ private ResultDisplay toClassMethodName(TestIdentifier testIdentifier) {
                     .map(TestIdentifier::getLegacyReportingName)
                     .anyMatch(legacyReportingName -> legacyReportingName.matches("^\\[.+]$"));
             boolean isTestTemplate = testIdentifier.getLegacyReportingName().matches("^.*\\[\\d+]$");
-
-            boolean parameterized = isParameterized || hasParameterizedParent || isTestTemplate;
+            // JUnit 6 @ParameterizedClass parents have a ClassSource, so they are missed by
+            // hasParameterizedParent, and the method legacy name no longer includes [N] (#3303).
+            String uniqueId = testIdentifier.getUniqueId();
+            String classTemplateInvocationSuffix = extractInvocationIndexSuffix(uniqueId, "class-template-invocation");
+            String testTemplateInvocationSuffix = extractInvocationIndexSuffix(uniqueId, "test-template-invocation");
+
+            boolean parameterized = isParameterized
+                    || hasParameterizedParent
+                    || isTestTemplate
+                    || !classTemplateInvocationSuffix.isEmpty();
             String methodName = methodSource.getMethodName();
             String description = testIdentifier.getLegacyReportingName();
             boolean equalDescriptions = methodDisplay.equals(description);
             boolean hasLegacyDescription = description.startsWith(methodName + '(');
             boolean hasDisplayName = !equalDescriptions || !hasLegacyDescription;
             String methodDesc = parameterized ? description : methodName;
+            // Rebuild as [class][method]. A contains() check on the class index alone
+            // treated foo()[2] (method #2) as already tagged for class #2, and
+            // foo()[1] + class #2 became foo()[1][2] instead of foo()[2][1].
+            if (!classTemplateInvocationSuffix.isEmpty()) {
+                String desired = classTemplateInvocationSuffix + testTemplateInvocationSuffix;
+                if (!methodDesc.endsWith(desired)) {
+                    if (!testTemplateInvocationSuffix.isEmpty() && methodDesc.endsWith(testTemplateInvocationSuffix)) {
+                        methodDesc =
+                                methodDesc.substring(0, methodDesc.length() - testTemplateInvocationSuffix.length())
+                                        + desired;
+                    } else {
+                        methodDesc = methodDesc + classTemplateInvocationSuffix;
+                    }
+                }
+            }
             String methodDisp = hasDisplayName ? methodDisplay : methodDesc;
 
             // The behavior of methods getLegacyReportingName() and getDisplayName().

surefire-providers/surefire-junit-platform/src/test/java/org/apache/maven/surefire/junitplatform/RunListenerAdapterTest.java

@@ -239,6 +239,178 @@ public void notifiedWithCompatibleNameForMethodWithArguments() throws Exception
         assertNull(entry.getStackTraceWriter());
     }
 
+    @Test
+    public void distinguishedJUnit6ParameterizedClassInvocationsByIndex() throws Exception {
+        // JUnit 6 @ParameterizedClass uses [class-template-invocation:#N] parents with a ClassSource.
+        // The method's own legacy name has no [N] suffix (unlike JUnit 5.14 / @ParameterizedTest),
+        // so invocations must still be reported under distinct names or rerunFailingTestsCount
+        // aggregates a pass+fail pair as a flake (#3303).
+        EngineDescriptor engine = new EngineDescriptor(UniqueId.forEngine("junit-jupiter"), "JUnit Jupiter");
+        TestDescriptor classTemplate = newParameterizedClassTemplateDescriptor(engine.getUniqueId());
+        engine.addChild(classTemplate);
+
+        TestDescriptor invocation1 = newParameterizedClassInvocationDescriptor(classTemplate.getUniqueId(), 1);
+        TestDescriptor method1 = newUnparameterizedMethodDescriptor(invocation1.getUniqueId());
+        classTemplate.addChild(invocation1);
+        invocation1.addChild(method1);
+
+        TestDescriptor invocation2 = newParameterizedClassInvocationDescriptor(classTemplate.getUniqueId(), 2);
+        TestDescriptor method2 = newUnparameterizedMethodDescriptor(invocation2.getUniqueId());
+        classTemplate.addChild(invocation2);
+        invocation2.addChild(method2);
+
+        TestPlan plan = TestPlan.from(false, singletonList(engine), CONFIG_PARAMS, OUTPUT_DIRECTORY);
+        adapter.testPlanExecutionStarted(plan);
+
+        adapter.executionStarted(TestIdentifier.from(engine));
+        adapter.executionStarted(TestIdentifier.from(classTemplate));
+        adapter.executionStarted(TestIdentifier.from(invocation1));
+        adapter.executionStarted(TestIdentifier.from(method1));
+        adapter.executionFinished(TestIdentifier.from(method1), successful());
+        adapter.executionFinished(TestIdentifier.from(invocation1), successful());
+        adapter.executionStarted(TestIdentifier.from(invocation2));
+        adapter.executionStarted(TestIdentifier.from(method2));
+        adapter.executionFinished(TestIdentifier.from(method2), failed(new AssertionError("fail")));
+
+        ArgumentCaptor<ReportEntry> started = ArgumentCaptor.forClass(ReportEntry.class);
+        verify(listener, times(2)).testStarting(started.capture());
+        assertEquals(
+                MY_TEST_METHOD_NAME + "()[1]", started.getAllValues().get(0).getName());
+        assertEquals(
+                MY_TEST_METHOD_NAME + "()[2]", started.getAllValues().get(1).getName());
+
+        ArgumentCaptor<ReportEntry> failed = ArgumentCaptor.forClass(ReportEntry.class);
+        verify(listener).testFailed(failed.capture());
+        assertEquals(MY_TEST_METHOD_NAME + "()[2]", failed.getValue().getName());
+        assertThat(failed.getValue().getName())
+                .isNotEqualTo(started.getAllValues().get(0).getName());
+    }
+
+    @Test
+    public void distinguishedNestedJUnit6ParameterizedClassInvocations() throws Exception {
+        EngineDescriptor engine = new EngineDescriptor(UniqueId.forEngine("junit-jupiter"), "JUnit Jupiter");
+        TestDescriptor outerTemplate = newParameterizedClassTemplateDescriptor(engine.getUniqueId());
+        engine.addChild(outerTemplate);
+
+        TestDescriptor outer1 = newParameterizedClassInvocationDescriptor(outerTemplate.getUniqueId(), 1);
+        TestDescriptor innerTemplate1 = newParameterizedClassTemplateDescriptor(outer1.getUniqueId());
+        TestDescriptor inner1 = newParameterizedClassInvocationDescriptor(innerTemplate1.getUniqueId(), 1);
+        TestDescriptor method11 = newUnparameterizedMethodDescriptor(inner1.getUniqueId());
+        outerTemplate.addChild(outer1);
+        outer1.addChild(innerTemplate1);
+        innerTemplate1.addChild(inner1);
+        inner1.addChild(method11);
+
+        TestDescriptor outer2 = newParameterizedClassInvocationDescriptor(outerTemplate.getUniqueId(), 2);
+        TestDescriptor innerTemplate2 = newParameterizedClassTemplateDescriptor(outer2.getUniqueId());
+        TestDescriptor inner2 = newParameterizedClassInvocationDescriptor(innerTemplate2.getUniqueId(), 1);
+        TestDescriptor method21 = newUnparameterizedMethodDescriptor(inner2.getUniqueId());
+        outerTemplate.addChild(outer2);
+        outer2.addChild(innerTemplate2);
+        innerTemplate2.addChild(inner2);
+        inner2.addChild(method21);
+
+        TestPlan plan = TestPlan.from(false, singletonList(engine), CONFIG_PARAMS, OUTPUT_DIRECTORY);
+        adapter.testPlanExecutionStarted(plan);
+
+        adapter.executionStarted(TestIdentifier.from(engine));
+        adapter.executionStarted(TestIdentifier.from(outerTemplate));
+        adapter.executionStarted(TestIdentifier.from(outer1));
+        adapter.executionStarted(TestIdentifier.from(innerTemplate1));
+        adapter.executionStarted(TestIdentifier.from(inner1));
+        adapter.executionStarted(TestIdentifier.from(method11));
+        adapter.executionFinished(TestIdentifier.from(method11), successful());
+        adapter.executionStarted(TestIdentifier.from(outer2));
+        adapter.executionStarted(TestIdentifier.from(innerTemplate2));
+        adapter.executionStarted(TestIdentifier.from(inner2));
+        adapter.executionStarted(TestIdentifier.from(method21));
+        adapter.executionFinished(TestIdentifier.from(method21), failed(new AssertionError("fail")));
+
+        ArgumentCaptor<ReportEntry> started = ArgumentCaptor.forClass(ReportEntry.class);
+        verify(listener, times(2)).testStarting(started.capture());
+        assertEquals(
+                MY_TEST_METHOD_NAME + "()[1][1]", started.getAllValues().get(0).getName());
+        assertEquals(
+                MY_TEST_METHOD_NAME + "()[2][1]", started.getAllValues().get(1).getName());
+    }
+
+    @Test
+    public void doesNotReappendClassIndexWhenLegacyNameAlreadyHasIt() throws Exception {
+        // JUnit 6.1+ parameterized methods already report method()[class][method].
+        EngineDescriptor engine = new EngineDescriptor(UniqueId.forEngine("junit-jupiter"), "JUnit Jupiter");
+        TestDescriptor classTemplate = newParameterizedClassTemplateDescriptor(engine.getUniqueId());
+        engine.addChild(classTemplate);
+
+        TestDescriptor invocation = newParameterizedClassInvocationDescriptor(classTemplate.getUniqueId(), 1);
+        TestDescriptor method = newLegacyIndexedMethodDescriptor(invocation.getUniqueId(), "()[1][2]", 2);
+        classTemplate.addChild(invocation);
+        invocation.addChild(method);
+
+        TestPlan plan = TestPlan.from(false, singletonList(engine), CONFIG_PARAMS, OUTPUT_DIRECTORY);
+        adapter.testPlanExecutionStarted(plan);
+
+        adapter.executionStarted(TestIdentifier.from(engine));
+        adapter.executionStarted(TestIdentifier.from(classTemplate));
+        adapter.executionStarted(TestIdentifier.from(invocation));
+        adapter.executionStarted(TestIdentifier.from(method));
+        adapter.executionFinished(TestIdentifier.from(method), successful());
+
+        ArgumentCaptor<ReportEntry> started = ArgumentCaptor.forClass(ReportEntry.class);
+        verify(listener).testStarting(started.capture());
+        assertEquals(MY_TEST_METHOD_NAME + "()[1][2]", started.getValue().getName());
+    }
+
+    @Test
+    public void classIndexGoesBeforeMethodIndexWhenLegacyNameOnlyHasMethodIndex() throws Exception {
+        // JUnit 6.0 @ParameterizedTest under @ParameterizedClass: legacy is foo()[m] only.
+        EngineDescriptor engine = new EngineDescriptor(UniqueId.forEngine("junit-jupiter"), "JUnit Jupiter");
+        TestDescriptor classTemplate = newParameterizedClassTemplateDescriptor(engine.getUniqueId());
+        engine.addChild(classTemplate);
+
+        TestDescriptor invocation = newParameterizedClassInvocationDescriptor(classTemplate.getUniqueId(), 2);
+        TestDescriptor method = newLegacyIndexedMethodDescriptor(invocation.getUniqueId(), "()[1]", 1);
+        classTemplate.addChild(invocation);
+        invocation.addChild(method);
+
+        TestPlan plan = TestPlan.from(false, singletonList(engine), CONFIG_PARAMS, OUTPUT_DIRECTORY);
+        adapter.testPlanExecutionStarted(plan);
+
+        adapter.executionStarted(TestIdentifier.from(engine));
+        adapter.executionStarted(TestIdentifier.from(classTemplate));
+        adapter.executionStarted(TestIdentifier.from(invocation));
+        adapter.executionStarted(TestIdentifier.from(method));
+        adapter.executionFinished(TestIdentifier.from(method), successful());
+
+        ArgumentCaptor<ReportEntry> started = ArgumentCaptor.forClass(ReportEntry.class);
+        verify(listener).testStarting(started.capture());
+        assertEquals(MY_TEST_METHOD_NAME + "()[2][1]", started.getValue().getName());
+    }
+
+    @Test
+    public void classAndMethodIndexOnTheDiagonalStayDistinct() throws Exception {
+        EngineDescriptor engine = new EngineDescriptor(UniqueId.forEngine("junit-jupiter"), "JUnit Jupiter");
+        TestDescriptor classTemplate = newParameterizedClassTemplateDescriptor(engine.getUniqueId());
+        engine.addChild(classTemplate);
+
+        TestDescriptor invocation = newParameterizedClassInvocationDescriptor(classTemplate.getUniqueId(), 2);
+        TestDescriptor method = newLegacyIndexedMethodDescriptor(invocation.getUniqueId(), "()[2]", 2);
+        classTemplate.addChild(invocation);
+        invocation.addChild(method);
+
+        TestPlan plan = TestPlan.from(false, singletonList(engine), CONFIG_PARAMS, OUTPUT_DIRECTORY);
+        adapter.testPlanExecutionStarted(plan);
+
+        adapter.executionStarted(TestIdentifier.from(engine));
+        adapter.executionStarted(TestIdentifier.from(classTemplate));
+        adapter.executionStarted(TestIdentifier.from(invocation));
+        adapter.executionStarted(TestIdentifier.from(method));
+        adapter.executionFinished(TestIdentifier.from(method), successful());
+
+        ArgumentCaptor<ReportEntry> started = ArgumentCaptor.forClass(ReportEntry.class);
+        verify(listener).testStarting(started.capture());
+        assertEquals(MY_TEST_METHOD_NAME + "()[2][2]", started.getValue().getName());
+    }
+
     @Test
     public void notifiedEagerlyForTestSetWhenClassExecutionStarted() throws Exception {
         EngineDescriptor engine = newEngineDescriptor();
@@ -973,6 +1145,60 @@ public Type getType() {
         assertEquals("Run a dummy cucumber test", entry.getName());
     }
 
+    private static TestDescriptor newParameterizedClassTemplateDescriptor(UniqueId engineId) {
+        return new ClassTestDescriptor(
+                engineId.append("class-template", MyTestClass.class.getName()),
+                MyTestClass.class,
+                new DefaultJupiterConfiguration(CONFIG_PARAMS, OUTPUT_DIRECTORY));
+    }
+
+    private static TestDescriptor newParameterizedClassInvocationDescriptor(UniqueId classTemplateId, int index) {
+        return new AbstractTestDescriptor(
+                classTemplateId.append("class-template-invocation", "#" + index),
+                "Parameterization with index: [" + index + "]",
+                ClassSource.from(MyTestClass.class)) {
+            @Override
+            public Type getType() {
+                return CONTAINER;
+            }
+
+            @Override
+            public String getLegacyReportingName() {
+                return MyTestClass.class.getSimpleName() + "[" + index + "]";
+            }
+        };
+    }
+
+    private static TestDescriptor newUnparameterizedMethodDescriptor(UniqueId parentId) throws Exception {
+        return newLegacyIndexedMethodDescriptor(parentId, "()");
+    }
+
+    private static TestDescriptor newLegacyIndexedMethodDescriptor(UniqueId parentId, String legacySuffix)
+            throws Exception {
+        return newLegacyIndexedMethodDescriptor(parentId, legacySuffix, 0);
+    }
+
+    private static TestDescriptor newLegacyIndexedMethodDescriptor(
+            UniqueId parentId, String legacySuffix, int testTemplateInvocationIndex) throws Exception {
+        Method method = MyTestClass.class.getDeclaredMethod(MY_TEST_METHOD_NAME);
+        UniqueId methodId = parentId.append("method", method.getName() + "()");
+        if (testTemplateInvocationIndex > 0) {
+            methodId = methodId.append("test-template-invocation", "#" + testTemplateInvocationIndex);
+        }
+        return new AbstractTestDescriptor(
+                methodId, method.getName() + "()", MethodSource.from(MyTestClass.class, method)) {
+            @Override
+            public Type getType() {
+                return TEST;
+            }
+
+            @Override
+            public String getLegacyReportingName() {
+                return method.getName() + legacySuffix;
+            }
+        };
+    }
+
     private static TestIdentifier newMethodIdentifier() throws Exception {
         return TestIdentifier.from(newMethodDescriptor());
     }