From 14860667038e8e79b0c047a081b3ffe5703eaf12 Mon Sep 17 00:00:00 2001 From: Christian Marquez Grabia <4968250+chalmagr@users.noreply.github.com> Date: Mon, 6 Jun 2022 00:17:31 -0500 Subject: [PATCH] [SUREFIRE-2065] Use legacy name to avoid retried test to make tests show as flaky on junit4 --- .../maven/surefire/its/fixture/TestFile.java | 19 ++++ .../surefire/its/jiras/Surefire2065IT.java | 103 ++++++++++++++++++ .../resources/surefire-2065-common/pom.xml | 72 ++++++++++++ .../java/pkg/junit4/ParameterizedTest.java | 29 +++++ .../ParameterizedWithDisplayNameTest.java | 31 ++++++ .../java/pkg/junit5/ParameterizedTest.java | 30 +++++ .../ParameterizedWithDisplayNameTest.java | 30 +++++ .../resources/surefire-2065-junit4/pom.xml | 59 ++++++++++ .../java/pkg/junit4/ParameterizedTest.java | 29 +++++ .../ParameterizedWithDisplayNameTest.java | 31 ++++++ .../resources/surefire-2065-junit5/pom.xml | 65 +++++++++++ .../java/pkg/junit5/ParameterizedTest.java | 30 +++++ .../ParameterizedWithDisplayNameTest.java | 30 +++++ .../junitplatform/RunListenerAdapter.java | 43 ++++---- .../JUnitPlatformProviderTest.java | 6 +- .../junitplatform/RunListenerAdapterTest.java | 24 +++- 16 files changed, 600 insertions(+), 31 deletions(-) create mode 100644 surefire-its/src/test/java/org/apache/maven/surefire/its/jiras/Surefire2065IT.java create mode 100644 surefire-its/src/test/resources/surefire-2065-common/pom.xml create mode 100644 surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit4/ParameterizedTest.java create mode 100644 surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit4/ParameterizedWithDisplayNameTest.java create mode 100644 surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit5/ParameterizedTest.java create mode 100644 surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit5/ParameterizedWithDisplayNameTest.java create mode 100644 surefire-its/src/test/resources/surefire-2065-junit4/pom.xml create mode 100644 surefire-its/src/test/resources/surefire-2065-junit4/src/test/java/pkg/junit4/ParameterizedTest.java create mode 100644 surefire-its/src/test/resources/surefire-2065-junit4/src/test/java/pkg/junit4/ParameterizedWithDisplayNameTest.java create mode 100644 surefire-its/src/test/resources/surefire-2065-junit5/pom.xml create mode 100644 surefire-its/src/test/resources/surefire-2065-junit5/src/test/java/pkg/junit5/ParameterizedTest.java create mode 100644 surefire-its/src/test/resources/surefire-2065-junit5/src/test/java/pkg/junit5/ParameterizedWithDisplayNameTest.java diff --git a/surefire-its/src/test/java/org/apache/maven/surefire/its/fixture/TestFile.java b/surefire-its/src/test/java/org/apache/maven/surefire/its/fixture/TestFile.java index d6aefa3d21..f3fc2a49ba 100644 --- a/surefire-its/src/test/java/org/apache/maven/surefire/its/fixture/TestFile.java +++ b/surefire-its/src/test/java/org/apache/maven/surefire/its/fixture/TestFile.java @@ -154,6 +154,25 @@ public TestFile assertContainsText( String text ) return assertContainsText( containsString( text ) ); } + public TestFile assertNotContainsText( Matcher matcher ) + { + final List list = surefireVerifier.loadFile( file, encoding ); + for ( String line : list ) + { + if ( matcher.matches( line ) ) + { + Assert.fail( "Found unexpected message in log" ); + return null; + } + } + return this; + } + + public TestFile assertNotContainsText( String text ) + { + return assertNotContainsText( containsString( text ) ); + } + public URI toURI() { return file.toURI(); diff --git a/surefire-its/src/test/java/org/apache/maven/surefire/its/jiras/Surefire2065IT.java b/surefire-its/src/test/java/org/apache/maven/surefire/its/jiras/Surefire2065IT.java new file mode 100644 index 0000000000..5c6a20a68d --- /dev/null +++ b/surefire-its/src/test/java/org/apache/maven/surefire/its/jiras/Surefire2065IT.java @@ -0,0 +1,103 @@ +package org.apache.maven.surefire.its.jiras; + +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +import static java.nio.charset.StandardCharsets.UTF_8; + +import org.apache.maven.it.VerificationException; +import org.apache.maven.surefire.its.fixture.OutputValidator; +import org.apache.maven.surefire.its.fixture.SurefireJUnit4IntegrationTestCase; +import org.hamcrest.Matchers; +import org.junit.Test; + +/** + * Integration Tests for SUREFIRE-2065 + */ +@SuppressWarnings( "checkstyle:magicnumber" ) +public class Surefire2065IT extends SurefireJUnit4IntegrationTestCase +{ + @Test + public void shouldNotDetectFlakyTestsWhenCombiningJunit4And5Tests() throws VerificationException + { + OutputValidator validator = unpack( "surefire-2065-common" ) + .mavenTestFailureIgnore( true ) + .executeTest() + .assertTestSuiteResults( 8, 0, 4, 0, 0 ); + + assertJunit4( validator ); + assertJunit5( validator ); + } + + @Test + public void shouldNotDetectFlakyTestsWhenRunningOnlyJunit4() throws VerificationException + { + OutputValidator validator = unpack( "surefire-2065-junit4" ) + .mavenTestFailureIgnore( true ) + .executeTest() + .assertTestSuiteResults( 4, 0, 2, 0, 0 ); + + assertJunit4( validator ); + } + + @Test + public void shouldNotDetectFlakyTestsWhenRunningOnlyJunit5() throws VerificationException + { + OutputValidator validator = unpack( "surefire-2065-junit5" ) + .mavenTestFailureIgnore( true ) + .executeTest() + .assertTestSuiteResults( 4, 0, 2, 0, 0 ); + + assertJunit5( validator ); + } + + private static void assertJunit4( OutputValidator validator ) + { + validator.getSurefireReportsFile( "TEST-pkg.junit4.ParameterizedTest.xml", UTF_8 ) + .assertContainsText( Matchers.matchesPattern( "^ *$" ) ) + .assertContainsText( Matchers.matchesPattern( "^ *$" ) ) + .assertContainsText( "$" ) ) + .assertContainsText( Matchers.matchesPattern( "^ *$" ) ) + .assertContainsText( "$" ) ) + .assertContainsText( Matchers.matchesPattern( "^ *$" ) ) + .assertContainsText( "$" ) ) + .assertContainsText( Matchers.matchesPattern( "^ *$" ) ) + .assertContainsText( " + + + + 4.0.0 + + org.example + surefire-2065-common + 1.0-SNAPSHOT + + + UTF-8 + ${java.specification.version} + ${java.specification.version} + 4.12 + 5.3.2 + + + + + junit + junit + ${junit4.version} + test + + + org.junit.jupiter + junit-jupiter-api + ${junit5.version} + test + + + org.junit.jupiter + junit-jupiter-params + ${junit5.version} + test + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + ${surefire.version} + + 1 + + + + + + diff --git a/surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit4/ParameterizedTest.java b/surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit4/ParameterizedTest.java new file mode 100644 index 0000000000..1456a81385 --- /dev/null +++ b/surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit4/ParameterizedTest.java @@ -0,0 +1,29 @@ +package pkg.junit4; + +import static org.junit.Assert.assertEquals; + +import java.util.Arrays; +import java.util.List; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +@RunWith(Parameterized.class) +public class ParameterizedTest +{ + @Parameterized.Parameters + public static List parameters() throws Exception + { + return Arrays.asList( 0, 1 ); + } + + @Parameterized.Parameter(0) + public int expected; + + @Test + public void notFlaky() + { + assertEquals( expected, 0 ); + } +} diff --git a/surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit4/ParameterizedWithDisplayNameTest.java b/surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit4/ParameterizedWithDisplayNameTest.java new file mode 100644 index 0000000000..af00293609 --- /dev/null +++ b/surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit4/ParameterizedWithDisplayNameTest.java @@ -0,0 +1,31 @@ +package pkg.junit4; + +import static org.junit.Assert.assertEquals; + +import java.util.Arrays; +import java.util.List; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +@RunWith(Parameterized.class) +public class ParameterizedWithDisplayNameTest +{ + private static int count = 0; + + @Parameterized.Parameters(name = "value={0}") + public static List parameters() throws Exception + { + return Arrays.asList( 0, 1 ); + } + + @Parameterized.Parameter(0) + public int expected; + + @Test + public void notFlaky() + { + assertEquals( expected, 0 ); + } +} diff --git a/surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit5/ParameterizedTest.java b/surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit5/ParameterizedTest.java new file mode 100644 index 0000000000..ec2b2fbc57 --- /dev/null +++ b/surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit5/ParameterizedTest.java @@ -0,0 +1,30 @@ +package pkg.junit5; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.Arrays; +import java.util.stream.Stream; + +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.ArgumentsProvider; +import org.junit.jupiter.params.provider.ArgumentsSource; + +class ParameterizedTest +{ + static class ParameterSource implements ArgumentsProvider + { + @Override + public Stream provideArguments( ExtensionContext context ) throws Exception + { + return Arrays.asList(0, 1).stream().map( Arguments::of ); + } + } + + @org.junit.jupiter.params.ParameterizedTest + @ArgumentsSource(value = ParameterSource.class) + public void notFlaky(int expected) + { + assertEquals( expected, 0 ); + } +} diff --git a/surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit5/ParameterizedWithDisplayNameTest.java b/surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit5/ParameterizedWithDisplayNameTest.java new file mode 100644 index 0000000000..94cd8a34a2 --- /dev/null +++ b/surefire-its/src/test/resources/surefire-2065-common/src/test/java/pkg/junit5/ParameterizedWithDisplayNameTest.java @@ -0,0 +1,30 @@ +package pkg.junit5; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.Arrays; +import java.util.stream.Stream; + +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.ArgumentsProvider; +import org.junit.jupiter.params.provider.ArgumentsSource; + +class ParameterizedWithDisplayNameTest +{ + static class ParameterSource implements ArgumentsProvider + { + @Override + public Stream provideArguments( ExtensionContext context ) throws Exception + { + return Arrays.asList(0, 1).stream().map( Arguments::of ); + } + } + + @org.junit.jupiter.params.ParameterizedTest(name = "value={0}") + @ArgumentsSource(value = ParameterSource.class) + public void notFlaky(int expected) + { + assertEquals( expected, 0 ); + } +} diff --git a/surefire-its/src/test/resources/surefire-2065-junit4/pom.xml b/surefire-its/src/test/resources/surefire-2065-junit4/pom.xml new file mode 100644 index 0000000000..fa6470cc4c --- /dev/null +++ b/surefire-its/src/test/resources/surefire-2065-junit4/pom.xml @@ -0,0 +1,59 @@ + + + + + 4.0.0 + + org.example + surefire-2065-junit4 + 1.0-SNAPSHOT + + + UTF-8 + ${java.specification.version} + ${java.specification.version} + 4.12 + + + + + junit + junit + ${junit4.version} + test + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + ${surefire.version} + + 1 + + + + + + diff --git a/surefire-its/src/test/resources/surefire-2065-junit4/src/test/java/pkg/junit4/ParameterizedTest.java b/surefire-its/src/test/resources/surefire-2065-junit4/src/test/java/pkg/junit4/ParameterizedTest.java new file mode 100644 index 0000000000..1456a81385 --- /dev/null +++ b/surefire-its/src/test/resources/surefire-2065-junit4/src/test/java/pkg/junit4/ParameterizedTest.java @@ -0,0 +1,29 @@ +package pkg.junit4; + +import static org.junit.Assert.assertEquals; + +import java.util.Arrays; +import java.util.List; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +@RunWith(Parameterized.class) +public class ParameterizedTest +{ + @Parameterized.Parameters + public static List parameters() throws Exception + { + return Arrays.asList( 0, 1 ); + } + + @Parameterized.Parameter(0) + public int expected; + + @Test + public void notFlaky() + { + assertEquals( expected, 0 ); + } +} diff --git a/surefire-its/src/test/resources/surefire-2065-junit4/src/test/java/pkg/junit4/ParameterizedWithDisplayNameTest.java b/surefire-its/src/test/resources/surefire-2065-junit4/src/test/java/pkg/junit4/ParameterizedWithDisplayNameTest.java new file mode 100644 index 0000000000..af00293609 --- /dev/null +++ b/surefire-its/src/test/resources/surefire-2065-junit4/src/test/java/pkg/junit4/ParameterizedWithDisplayNameTest.java @@ -0,0 +1,31 @@ +package pkg.junit4; + +import static org.junit.Assert.assertEquals; + +import java.util.Arrays; +import java.util.List; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +@RunWith(Parameterized.class) +public class ParameterizedWithDisplayNameTest +{ + private static int count = 0; + + @Parameterized.Parameters(name = "value={0}") + public static List parameters() throws Exception + { + return Arrays.asList( 0, 1 ); + } + + @Parameterized.Parameter(0) + public int expected; + + @Test + public void notFlaky() + { + assertEquals( expected, 0 ); + } +} diff --git a/surefire-its/src/test/resources/surefire-2065-junit5/pom.xml b/surefire-its/src/test/resources/surefire-2065-junit5/pom.xml new file mode 100644 index 0000000000..8241ef480d --- /dev/null +++ b/surefire-its/src/test/resources/surefire-2065-junit5/pom.xml @@ -0,0 +1,65 @@ + + + + + 4.0.0 + + org.example + surefire-2065-junit5 + 1.0-SNAPSHOT + + + UTF-8 + ${java.specification.version} + ${java.specification.version} + 5.3.2 + + + + + org.junit.jupiter + junit-jupiter-api + ${junit5.version} + test + + + org.junit.jupiter + junit-jupiter-params + ${junit5.version} + test + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + ${surefire.version} + + 1 + + + + + + diff --git a/surefire-its/src/test/resources/surefire-2065-junit5/src/test/java/pkg/junit5/ParameterizedTest.java b/surefire-its/src/test/resources/surefire-2065-junit5/src/test/java/pkg/junit5/ParameterizedTest.java new file mode 100644 index 0000000000..ec2b2fbc57 --- /dev/null +++ b/surefire-its/src/test/resources/surefire-2065-junit5/src/test/java/pkg/junit5/ParameterizedTest.java @@ -0,0 +1,30 @@ +package pkg.junit5; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.Arrays; +import java.util.stream.Stream; + +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.ArgumentsProvider; +import org.junit.jupiter.params.provider.ArgumentsSource; + +class ParameterizedTest +{ + static class ParameterSource implements ArgumentsProvider + { + @Override + public Stream provideArguments( ExtensionContext context ) throws Exception + { + return Arrays.asList(0, 1).stream().map( Arguments::of ); + } + } + + @org.junit.jupiter.params.ParameterizedTest + @ArgumentsSource(value = ParameterSource.class) + public void notFlaky(int expected) + { + assertEquals( expected, 0 ); + } +} diff --git a/surefire-its/src/test/resources/surefire-2065-junit5/src/test/java/pkg/junit5/ParameterizedWithDisplayNameTest.java b/surefire-its/src/test/resources/surefire-2065-junit5/src/test/java/pkg/junit5/ParameterizedWithDisplayNameTest.java new file mode 100644 index 0000000000..94cd8a34a2 --- /dev/null +++ b/surefire-its/src/test/resources/surefire-2065-junit5/src/test/java/pkg/junit5/ParameterizedWithDisplayNameTest.java @@ -0,0 +1,30 @@ +package pkg.junit5; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.Arrays; +import java.util.stream.Stream; + +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.ArgumentsProvider; +import org.junit.jupiter.params.provider.ArgumentsSource; + +class ParameterizedWithDisplayNameTest +{ + static class ParameterSource implements ArgumentsProvider + { + @Override + public Stream provideArguments( ExtensionContext context ) throws Exception + { + return Arrays.asList(0, 1).stream().map( Arguments::of ); + } + } + + @org.junit.jupiter.params.ParameterizedTest(name = "value={0}") + @ArgumentsSource(value = ParameterSource.class) + public void notFlaky(int expected) + { + assertEquals( expected, 0 ); + } +} diff --git a/surefire-providers/surefire-junit-platform/src/main/java/org/apache/maven/surefire/junitplatform/RunListenerAdapter.java b/surefire-providers/surefire-junit-platform/src/main/java/org/apache/maven/surefire/junitplatform/RunListenerAdapter.java index aeb24576e0..16df8ae721 100644 --- a/surefire-providers/surefire-junit-platform/src/main/java/org/apache/maven/surefire/junitplatform/RunListenerAdapter.java +++ b/surefire-providers/surefire-junit-platform/src/main/java/org/apache/maven/surefire/junitplatform/RunListenerAdapter.java @@ -30,7 +30,6 @@ import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; -import java.util.regex.Pattern; import java.util.stream.Stream; import org.apache.maven.surefire.api.report.OutputReportEntry; @@ -58,8 +57,6 @@ final class RunListenerAdapter implements TestExecutionListener, TestOutputReceiver, RunModeSetter { - private static final Pattern COMMA_PATTERN = Pattern.compile( "," ); - private final ClassMethodIndexer classMethodIndexer = new ClassMethodIndexer(); private final ConcurrentMap testStartTime = new ConcurrentHashMap<>(); private final ConcurrentMap failures = new ConcurrentHashMap<>(); @@ -144,7 +141,7 @@ public void executionFinished( TestIdentifier testIdentifier, TestExecutionResul break; case FAILED: String reason = safeGetMessage( testExecutionResult.getThrowable().orElse( null ) ); - SimpleReportEntry reportEntry = createReportEntry( testIdentifier, testExecutionResult, + SimpleReportEntry reportEntry = createReportEntry( testIdentifier, testExecutionResult, reason, elapsed ); if ( isAssertionError ) { @@ -300,7 +297,9 @@ private String[] toClassMethodName( TestIdentifier testIdentifier ) MethodSource methodSource = testSource.map( MethodSource.class::cast ).get(); String realClassName = methodSource.getClassName(); - String[] source = testPlan.getParent( testIdentifier ) + String[] source = collectAllTestIdentifiersInHierarchy( testIdentifier ) + .filter( i -> i.getSource().map( ClassSource.class::isInstance ).orElse( false ) ) + .findFirst() .map( this::toClassMethodName ) .map( s -> new String[] { s[0], s[1] } ) .orElse( new String[] { realClassName, realClassName } ); @@ -314,28 +313,26 @@ private String[] toClassMethodName( TestIdentifier testIdentifier ) boolean needsSpaceSeparator = isNotBlank( parentDisplay ) && !display.startsWith( "[" ); String methodDisplay = parentDisplay + ( needsSpaceSeparator ? " " : "" ) + display; - String simpleClassNames = COMMA_PATTERN.splitAsStream( methodSource.getMethodParameterTypes() ) - .map( s -> s.substring( 1 + s.lastIndexOf( '.' ) ) ) - .collect( joining( "," ) ); - - boolean hasParams = isNotBlank( methodSource.getMethodParameterTypes() ); - String methodName = methodSource.getMethodName(); + // SUREFIRE-2065 (see tables below) String description = testIdentifier.getLegacyReportingName(); - String methodSign = hasParams ? methodName + '(' + simpleClassNames + ')' : methodName; - boolean equalDescriptions = methodDisplay.equals( description ); - boolean hasLegacyDescription = description.startsWith( methodName + '(' ); - boolean hasDisplayName = !equalDescriptions || !hasLegacyDescription; - String methodDesc = equalDescriptions || !hasParams ? methodSign : description; - String methodDisp = hasDisplayName ? methodDisplay : methodDesc; - - // The behavior of methods getLegacyReportingName() and getDisplayName(). - // test || legacy | display + + // For better handling of parameterized junit4, use of LegacyReportingName as description + // fits better since display and legacy are same for parameterized junit4 + // junit4 || legacy | display + // ==============||==========|========== + // normal || m | m + // param || m[0] | m[0] + // param+displ || m[displ] | m[displ] + + // For junit5 legacy / display behaves as below + // junit5 || legacy | display // ==============||==========|========== // normal || m() | m() - // normal+displ || displ | displ - // parameterized || m()[1] | displ + // normal+displ || m() | displ + // param || m()[1] | [1] + // param+displ || m()[1] | displ - return new String[] {source[0], source[1], methodDesc, methodDisp}; + return new String[] {source[0], source[1], description, methodDisplay}; } else if ( testSource.filter( ClassSource.class::isInstance ).isPresent() ) { diff --git a/surefire-providers/surefire-junit-platform/src/test/java/org/apache/maven/surefire/junitplatform/JUnitPlatformProviderTest.java b/surefire-providers/surefire-junit-platform/src/test/java/org/apache/maven/surefire/junitplatform/JUnitPlatformProviderTest.java index f734bab115..366f51b925 100644 --- a/surefire-providers/surefire-junit-platform/src/test/java/org/apache/maven/surefire/junitplatform/JUnitPlatformProviderTest.java +++ b/surefire-providers/surefire-junit-platform/src/test/java/org/apache/maven/surefire/junitplatform/JUnitPlatformProviderTest.java @@ -448,7 +448,7 @@ public void runDisplayNameTest() throws Exception assertEquals( DisplayNameTest.class.getName(), reportEntries.get( 0 ).getSourceName() ); assertEquals( "<< ✨ >>", reportEntries.get( 0 ).getSourceText() ); - assertEquals( "test1", reportEntries.get( 0 ).getName() ); + assertEquals( "test1()", reportEntries.get( 0 ).getName() ); assertEquals( "73$71 ✔", reportEntries.get( 0 ).getNameText() ); } @@ -480,7 +480,7 @@ public void detectErroredParameterized() assertEquals( TestClass8.class.getName(), reportEntries.get( 0 ).getSourceName() ); assertNull( reportEntries.get( 0 ).getSourceText() ); - assertEquals( "testParameterizedTestCases", reportEntries.get( 0 ).getName() ); + assertEquals( "testParameterizedTestCases()", reportEntries.get( 0 ).getName() ); assertNull( reportEntries.get( 0 ).getNameText() ); TestExecutionSummary summary = executionListener.summaries.get( 0 ); @@ -519,7 +519,7 @@ public void detectFailedParameterized() assertEquals( TestClass9.class.getName(), reportEntries.get( 0 ).getSourceName() ); assertNull( reportEntries.get( 0 ).getSourceText() ); - assertEquals( "testParameterizedTestCases", reportEntries.get( 0 ).getName() ); + assertEquals( "testParameterizedTestCases()", reportEntries.get( 0 ).getName() ); assertNull( reportEntries.get( 0 ).getNameText() ); TestExecutionSummary summary = executionListener.summaries.get( 0 ); diff --git a/surefire-providers/surefire-junit-platform/src/test/java/org/apache/maven/surefire/junitplatform/RunListenerAdapterTest.java b/surefire-providers/surefire-junit-platform/src/test/java/org/apache/maven/surefire/junitplatform/RunListenerAdapterTest.java index 3c1e129054..d217dfb6df 100644 --- a/surefire-providers/surefire-junit-platform/src/test/java/org/apache/maven/surefire/junitplatform/RunListenerAdapterTest.java +++ b/surefire-providers/surefire-junit-platform/src/test/java/org/apache/maven/surefire/junitplatform/RunListenerAdapterTest.java @@ -111,7 +111,7 @@ public void notifiedWithCorrectNamesWhenMethodExecutionStarted() verify( listener ).testStarting( entryCaptor.capture() ); ReportEntry entry = entryCaptor.getValue(); - assertEquals( MY_TEST_METHOD_NAME, entry.getName() ); + assertEquals( MY_TEST_METHOD_NAME.concat( "()" ), entry.getName() ); assertEquals( MyTestClass.class.getName(), entry.getSourceName() ); assertNull( entry.getStackTraceWriter() ); } @@ -161,7 +161,7 @@ public void notifiedEagerlyForTestSetWhenClassExecutionStarted() adapter.executionStarted( TestIdentifier.from( child ) ); verify( listener ).testStarting( new SimpleReportEntry( NORMAL_RUN, 0x0000000100000001L, className, null, - MY_TEST_METHOD_NAME, null ) ); + MY_TEST_METHOD_NAME.concat( "()" ), null ) ); verifyNoMoreInteractions( listener ); adapter.executionFinished( TestIdentifier.from( child ), successful() ); @@ -176,7 +176,7 @@ public void notifiedEagerlyForTestSetWhenClassExecutionStarted() assertThat( report.getValue().getSourceText() ) .isNull(); assertThat( report.getValue().getName() ) - .isEqualTo( MY_TEST_METHOD_NAME ); + .isEqualTo( MY_TEST_METHOD_NAME.concat( "()" ) ); assertThat( report.getValue().getNameText() ) .isNull(); assertThat( report.getValue().getElapsed() ) @@ -526,7 +526,7 @@ public void notifiedWithCorrectNamesWhenContainerFailed() ReportEntry entry = entryCaptor.getValue(); assertEquals( MyTestClass.class.getTypeName(), entry.getSourceName() ); - assertEquals( MY_TEST_METHOD_NAME, entry.getName() ); + assertEquals( MY_TEST_METHOD_NAME.concat( "()" ), entry.getName() ); assertNotNull( entry.getStackTraceWriter() ); assertNotNull( entry.getStackTraceWriter().getThrowable() ); assertThat( entry.getStackTraceWriter().getThrowable().getTarget() ) @@ -800,10 +800,24 @@ void myNamedTestMethod() static class TestMethodTestDescriptorWithDisplayName extends AbstractTestDescriptor { + private final String legacyName; + private TestMethodTestDescriptorWithDisplayName( UniqueId uniqueId, Class testClass, Method testMethod, String displayName ) { - super( uniqueId, displayName, MethodSource.from( testClass, testMethod ) ); + this( uniqueId, displayName, MethodSource.from( testClass, testMethod ) ); + } + + private TestMethodTestDescriptorWithDisplayName( UniqueId uniqueId, String displayName, MethodSource source ) + { + super( uniqueId, displayName, source ); + legacyName = source.getMethodName(); + } + + @Override + public String getLegacyReportingName() + { + return legacyName; } @Override