package org.apache.maven.surefire.junitplatform;

/*
 * 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.util.Collections.emptyMap;
import static java.util.Collections.singletonMap;
import static java.util.stream.Collectors.toSet;
import static org.apache.maven.surefire.api.booter.ProviderParameterNames.TESTNG_EXCLUDEDGROUPS_PROP;
import static org.apache.maven.surefire.api.booter.ProviderParameterNames.TESTNG_GROUPS_PROP;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.junit.jupiter.api.Assumptions.assumeFalse;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.withSettings;

import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.maven.surefire.api.provider.ProviderParameters;
import org.apache.maven.surefire.api.report.ConsoleOutputReceiver;
import org.apache.maven.surefire.api.report.ReportEntry;
import org.apache.maven.surefire.api.report.ReporterFactory;
import org.apache.maven.surefire.api.report.RunListener;
import org.apache.maven.surefire.api.report.SimpleReportEntry;
import org.apache.maven.surefire.api.report.TestSetReportEntry;
import org.apache.maven.surefire.api.testset.TestListResolver;
import org.apache.maven.surefire.api.testset.TestRequest;
import org.apache.maven.surefire.api.testset.TestSetFailedException;
import org.apache.maven.surefire.api.util.RunOrderCalculator;
import org.apache.maven.surefire.api.util.ScanResult;
import org.apache.maven.surefire.api.util.TestsToRun;
import org.fest.assertions.Assertions;
import org.junit.Test;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.DisplayName;
import org.junit.platform.launcher.Launcher;
import org.junit.platform.launcher.TestIdentifier;
import org.junit.platform.launcher.TestPlan;
import org.junit.platform.launcher.core.LauncherFactory;
import org.junit.platform.launcher.listeners.SummaryGeneratingListener;
import org.junit.platform.launcher.listeners.TestExecutionSummary;
import org.junit.platform.launcher.listeners.TestExecutionSummary.Failure;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;

/**
 * Unit tests for {@link JUnitPlatformProvider}.
 *
 * @since 2.22.0
 */
public class JUnitPlatformProviderTest
{
    @Test
    public void shouldFailClassOnBeforeAll()
            throws Exception
    {
        Launcher launcher = LauncherFactory.create();
        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParametersMock(), launcher );
        RunListener listener = mock( RunListener.class );

        ArgumentCaptor<ReportEntry> testCaptor = ArgumentCaptor.forClass( ReportEntry.class );
        ArgumentCaptor<TestSetReportEntry> testSetCaptor = ArgumentCaptor.forClass( TestSetReportEntry.class );

        RunListenerAdapter adapter = new RunListenerAdapter( listener );
        launcher.registerTestExecutionListeners( adapter );

        TestsToRun testsToRun = newTestsToRun( FailingBeforeAllJupiterTest.class );
        invokeProvider( provider, testsToRun );
        InOrder inOrder = inOrder( listener );
        inOrder.verify( listener, times( 1 ) ).testSetStarting( testSetCaptor.capture() );
        inOrder.verify( listener, never() ).testStarting( any( ReportEntry.class ) );
        inOrder.verify( listener, times( 1 ) ).testFailed( testCaptor.capture() );
        inOrder.verify( listener, times( 1 ) ).testSetCompleted( testSetCaptor.capture() );

        assertThat( testSetCaptor.getAllValues() )
                .hasSize( 2 );

        assertThat( testSetCaptor.getAllValues().get( 0 ).getSourceName() )
                .isEqualTo( FailingBeforeAllJupiterTest.class.getName() );

        assertThat( testSetCaptor.getAllValues().get( 0 ).getName() )
                .isNull();

        assertThat( testCaptor.getAllValues() )
                .hasSize( 1 );

        assertThat( testCaptor.getValue().getSourceName() )
                .isEqualTo( FailingBeforeAllJupiterTest.class.getName() );

        assertThat( testCaptor.getValue().getName() )
                .isNull();

        assertThat( testSetCaptor.getAllValues().get( 1 ).getSourceName() )
                .isEqualTo( FailingBeforeAllJupiterTest.class.getName() );

        assertThat( testSetCaptor.getAllValues().get( 1 ).getName() )
                .isNull();
    }

    @Test
    public void shouldErrorClassOnBeforeAll()
            throws Exception
    {
        Launcher launcher = LauncherFactory.create();
        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParametersMock(), launcher );
        RunListener listener = mock( RunListener.class );

        ArgumentCaptor<ReportEntry> testCaptor = ArgumentCaptor.forClass( ReportEntry.class );
        ArgumentCaptor<TestSetReportEntry> testSetCaptor = ArgumentCaptor.forClass( TestSetReportEntry.class );

        RunListenerAdapter adapter = new RunListenerAdapter( listener );
        launcher.registerTestExecutionListeners( adapter );

        TestsToRun testsToRun = newTestsToRun( FailingWithErrorBeforeAllJupiterTest.class );
        invokeProvider( provider, testsToRun );
        InOrder inOrder = inOrder( listener );
        inOrder.verify( listener, times( 1 ) ).testSetStarting( testSetCaptor.capture() );
        inOrder.verify( listener, never() ).testStarting( any( ReportEntry.class ) );
        inOrder.verify( listener, times( 1 ) ).testError( testCaptor.capture() );
        inOrder.verify( listener, times( 1 ) ).testSetCompleted( testSetCaptor.capture() );

        assertThat( testSetCaptor.getAllValues() )
                .hasSize( 2 );

        assertThat( testSetCaptor.getAllValues().get( 0 ).getSourceName() )
                .isEqualTo( FailingWithErrorBeforeAllJupiterTest.class.getName() );

        assertThat( testSetCaptor.getAllValues().get( 0 ).getName() )
                .isNull();

        assertThat( testCaptor.getAllValues() )
                .hasSize( 1 );

        assertThat( testCaptor.getValue().getSourceName() )
                .isEqualTo( FailingWithErrorBeforeAllJupiterTest.class.getName() );

        assertThat( testCaptor.getValue().getName() )
                .isNull();

        assertThat( testSetCaptor.getAllValues().get( 1 ).getSourceName() )
                .isEqualTo( FailingWithErrorBeforeAllJupiterTest.class.getName() );

        assertThat( testSetCaptor.getAllValues().get( 1 ).getName() )
                .isNull();
    }

    @Test
    public void getSuitesReturnsScannedClasses()
    {
        ProviderParameters providerParameters = providerParametersMock( TestClass1.class, TestClass2.class );
        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters );
        assertThat( provider.getSuites() )
                .containsOnly( TestClass1.class, TestClass2.class );
    }

    @Test
    public void invokeThrowsForWrongForkTestSet()
    {
        ProviderParameters providerParameters = providerParametersMock( Integer.class );
        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters );

        assertThrows( IllegalArgumentException.class, () -> invokeProvider( provider, "wrong forkTestSet" ) );
    }

    @Test
    public void allGivenTestsToRunAreInvoked()
                    throws Exception
    {
        Launcher launcher = LauncherFactory.create();
        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParametersMock(), launcher );

        TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
        launcher.registerTestExecutionListeners( executionListener );

        TestsToRun testsToRun = newTestsToRun( TestClass1.class, TestClass2.class );
        invokeProvider( provider, testsToRun );

        assertThat( executionListener.summaries ).hasSize( 1 );
        TestExecutionSummary summary = executionListener.summaries.get( 0 );
        assertEquals( TestClass1.TESTS_FOUND + TestClass2.TESTS_FOUND, summary.getTestsFoundCount() );
        assertEquals(
                        TestClass1.TESTS_STARTED + TestClass2.TESTS_STARTED, summary.getTestsStartedCount() );
        assertEquals(
                        TestClass1.TESTS_SKIPPED + TestClass2.TESTS_SKIPPED, summary.getTestsSkippedCount() );
        assertEquals(
                        TestClass1.TESTS_SUCCEEDED + TestClass2.TESTS_SUCCEEDED, summary.getTestsSucceededCount() );
        assertEquals(
                        TestClass1.TESTS_ABORTED + TestClass2.TESTS_ABORTED, summary.getTestsAbortedCount() );
        assertEquals( TestClass1.TESTS_FAILED + TestClass2.TESTS_FAILED, summary.getTestsFailedCount() );
    }

    @Test
    public void singleTestClassIsInvoked()
                    throws Exception
    {
        Launcher launcher = LauncherFactory.create();
        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParametersMock(), launcher );

        TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
        launcher.registerTestExecutionListeners( executionListener );

        invokeProvider( provider, TestClass1.class );

        assertThat( executionListener.summaries ).hasSize( 1 );
        TestExecutionSummary summary = executionListener.summaries.get( 0 );
        assertEquals( TestClass1.TESTS_FOUND, summary.getTestsFoundCount() );
        assertEquals( TestClass1.TESTS_STARTED, summary.getTestsStartedCount() );
        assertEquals( TestClass1.TESTS_SKIPPED, summary.getTestsSkippedCount() );
        assertEquals( TestClass1.TESTS_SUCCEEDED, summary.getTestsSucceededCount() );
        assertEquals( TestClass1.TESTS_ABORTED, summary.getTestsAbortedCount() );
        assertEquals( TestClass1.TESTS_FAILED, summary.getTestsFailedCount() );
    }

    @Test
    public void singleTestClassIsInvokedLazily()
        throws Exception
    {
        Launcher launcher = LauncherFactory.create();
        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParametersMock(), launcher );

        TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
        launcher.registerTestExecutionListeners( executionListener );

        invokeProvider( provider, newTestsToRunLazily( TestClass1.class ) );

        assertThat( executionListener.summaries ).hasSize( 1 );
        TestExecutionSummary summary = executionListener.summaries.get( 0 );
        assertEquals( TestClass1.TESTS_FOUND, summary.getTestsFoundCount() );
        assertEquals( TestClass1.TESTS_STARTED, summary.getTestsStartedCount() );
        assertEquals( TestClass1.TESTS_SKIPPED, summary.getTestsSkippedCount() );
        assertEquals( TestClass1.TESTS_SUCCEEDED, summary.getTestsSucceededCount() );
        assertEquals( TestClass1.TESTS_ABORTED, summary.getTestsAbortedCount() );
        assertEquals( TestClass1.TESTS_FAILED, summary.getTestsFailedCount() );
    }

    @Test
    public void failingTestCaseAfterRerun()
            throws Exception
    {
        Launcher launcher = LauncherFactory.create();
        ProviderParameters parameters = providerParametersMock();
        // Mock the rerun variable
        when( parameters.getTestRequest().getRerunFailingTestsCount() ).thenReturn( 1 );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( parameters, launcher );

        TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
        launcher.registerTestExecutionListeners( executionListener );

        invokeProvider( provider, TestClass2.class );

        assertThat( executionListener.summaries ).hasSize( 2 );
        TestExecutionSummary summary = executionListener.summaries.get( 0 );
        assertEquals( TestClass2.TESTS_FOUND, summary.getTestsFoundCount() );
        assertEquals( TestClass2.TESTS_STARTED, summary.getTestsStartedCount() );
        assertEquals( TestClass2.TESTS_SKIPPED, summary.getTestsSkippedCount() );
        assertEquals( TestClass2.TESTS_SUCCEEDED, summary.getTestsSucceededCount() );
        assertEquals( TestClass2.TESTS_ABORTED, summary.getTestsAbortedCount() );
        assertEquals( TestClass2.TESTS_FAILED, summary.getTestsFailedCount() );

        // Should only be re-running one unit test
        // - And it should only fail
        summary = executionListener.summaries.get( 1 );
        assertEquals( 1, summary.getTestsFoundCount() );
        assertEquals( 1, summary.getTestsStartedCount() );
        assertEquals( 0, summary.getTestsSkippedCount() );
        assertEquals( 0, summary.getTestsSucceededCount() );
        assertEquals( 0, summary.getTestsAbortedCount() );
        assertEquals( 1, summary.getTestsFailedCount() );
    }

    @Test
    public void rerunStillFailing()
                    throws Exception
    {
        Launcher launcher = LauncherFactory.create();
        ProviderParameters parameters = providerParametersMock();
        // Mock the rerun variable
        when( parameters.getTestRequest().getRerunFailingTestsCount() ).thenReturn( 2 );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( parameters, launcher );
        TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
        launcher.registerTestExecutionListeners( executionListener );

        // 3 unit tests:
        // - fail always
        // - fail twice (pass on 2nd rerun)
        // - pass always
        invokeProvider( provider, TestClass4.class );

        assertThat( executionListener.summaries ).hasSize( 3 );
        TestExecutionSummary summary = executionListener.summaries.get( 0 );
        assertEquals( 6, summary.getTestsFoundCount() );
        assertEquals( 5, summary.getTestsStartedCount() );
        assertEquals( 1, summary.getTestsSkippedCount() );
        assertEquals( 1, summary.getTestsSucceededCount() );
        assertEquals( 1, summary.getTestsAbortedCount() );
        assertEquals( 3, summary.getTestsFailedCount() );
        Set<String> failDisplays = new HashSet<>();
        for ( TestExecutionSummary.Failure failure : summary.getFailures() )
        {
            failDisplays.add( failure.getTestIdentifier().getDisplayName() );
        }
        assertEquals( 3, failDisplays.size() );
        assertTrue( failDisplays.contains( "Fails twice" ) );
        assertTrue( failDisplays.contains( "testAlwaysFail()" ) );
        assertTrue( failDisplays.contains( "testAlwaysError()" ) );

        // Should rerun both of the failures
        summary = executionListener.summaries.get( 1 );
        assertEquals( 3, summary.getTestsFoundCount() );
        assertEquals( 3, summary.getTestsStartedCount() );
        assertEquals( 0, summary.getTestsSkippedCount() );
        assertEquals( 0, summary.getTestsSucceededCount() );
        assertEquals( 0, summary.getTestsAbortedCount() );
        assertEquals( 3, summary.getTestsFailedCount() );
        failDisplays.clear();
        for ( TestExecutionSummary.Failure failure : summary.getFailures() )
        {
            failDisplays.add( failure.getTestIdentifier().getDisplayName() );
        }
        assertEquals( 3, failDisplays.size() );
        assertTrue( failDisplays.contains( "Fails twice" ) );
        assertTrue( failDisplays.contains( "testAlwaysFail()" ) );
        assertTrue( failDisplays.contains( "testAlwaysError()" ) );

        // now only one failure should remain
        summary = executionListener.summaries.get( 2 );
        assertEquals( 3, summary.getTestsFoundCount() );
        assertEquals( 3, summary.getTestsStartedCount() );
        assertEquals( 0, summary.getTestsSkippedCount() );
        assertEquals( 1, summary.getTestsSucceededCount() );
        assertEquals( 0, summary.getTestsAbortedCount() );
        assertEquals( 2, summary.getTestsFailedCount() );
        failDisplays.clear();
        for ( TestExecutionSummary.Failure failure : summary.getFailures() )
        {
            failDisplays.add( failure.getTestIdentifier().getDisplayName() );
        }
        assertEquals( 2, failDisplays.size() );
        assertTrue( failDisplays.contains( "testAlwaysFail()" ) );
        assertTrue( failDisplays.contains( "testAlwaysError()" ) );
    }

    @Test
    public void rerunWithSuccess()
            throws Exception
    {
        Launcher launcher = LauncherFactory.create();
        ProviderParameters parameters = providerParametersMock();
        // Mock the rerun variable
        when( parameters.getTestRequest().getRerunFailingTestsCount() ).thenReturn( 2 );
        when( parameters.getProviderProperties() )
                .thenReturn( singletonMap( JUnitPlatformProvider.CONFIGURATION_PARAMETERS,
                        "forkCount = 1\nreuseForks = true" ) );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( parameters, launcher );
        TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
        launcher.registerTestExecutionListeners( executionListener );

        invokeProvider( provider, TestClass5.class );

        assertThat( executionListener.summaries ).hasSize( 3 );
        TestExecutionSummary summary = executionListener.summaries.get( 0 );
        assertEquals( 1, summary.getTestsFoundCount() );
        assertEquals( 1, summary.getTestsStartedCount() );
        assertEquals( 0, summary.getTestsSucceededCount() );
        assertEquals( 1, summary.getTestsFailedCount() );

        summary = executionListener.summaries.get( 1 );
        assertEquals( 1, summary.getTestsFoundCount() );
        assertEquals( 1, summary.getTestsStartedCount() );
        assertEquals( 0, summary.getTestsSucceededCount() );
        assertEquals( 1, summary.getTestsFailedCount() );

        summary = executionListener.summaries.get( 2 );
        assertEquals( 1, summary.getTestsFoundCount() );
        assertEquals( 1, summary.getTestsStartedCount() );
        assertEquals( 1, summary.getTestsSucceededCount() );
        assertEquals( 0, summary.getTestsFailedCount() );
    }

    @Test
    public void runDisplayNameTest() throws Exception
    {
        Launcher launcher = LauncherFactory.create();
        ProviderParameters parameters = providerParametersMock();
        JUnitPlatformProvider provider = new JUnitPlatformProvider( parameters, launcher );

        RunListener listener = mock( RunListener.class );
        ArgumentCaptor<ReportEntry> entryCaptor = ArgumentCaptor.forClass( ReportEntry.class );
        RunListenerAdapter adapter = new RunListenerAdapter( listener );

        launcher.registerTestExecutionListeners( adapter );

        invokeProvider( provider, DisplayNameTest.class );

        verify( listener, times( 1 ) ).testStarting( entryCaptor.capture() );
        List<ReportEntry> reportEntries = entryCaptor.getAllValues();

        assertEquals( 1, reportEntries.size() );

        assertEquals( DisplayNameTest.class.getName(), reportEntries.get( 0 ).getSourceName() );
        assertEquals( "<< ✨ >>", reportEntries.get( 0 ).getSourceText() );
        assertEquals( "test1", reportEntries.get( 0 ).getName() );
        assertEquals( "73$71 ✔", reportEntries.get( 0 ).getNameText() );
    }

    @Test
    public void detectErroredParameterized()
        throws Exception
    {
        Launcher launcher = LauncherFactory.create();
        ProviderParameters parameters = providerParametersMock();

        JUnitPlatformProvider provider = new JUnitPlatformProvider( parameters, launcher );

        TestPlanSummaryListener executionListener = new TestPlanSummaryListener();

        RunListener listener = mock( RunListener.class );
        ArgumentCaptor<ReportEntry> entryCaptor = ArgumentCaptor.forClass( ReportEntry.class );
        RunListenerAdapter adapter = new RunListenerAdapter( listener );

        launcher.registerTestExecutionListeners( executionListener, adapter );

        invokeProvider( provider, TestClass8.class );

        assertThat( executionListener.summaries ).hasSize( 1 );

        verify( listener, times( 1 ) ).testSetCompleted( any() );
        verify( listener, times( 1 ) ).testError( entryCaptor.capture() );
        List<ReportEntry> reportEntries = entryCaptor.getAllValues();

        assertEquals( TestClass8.class.getName(), reportEntries.get( 0 ).getSourceName() );
        assertNull( reportEntries.get( 0 ).getSourceText() );
        assertEquals( "testParameterizedTestCases", reportEntries.get( 0 ).getName() );
        assertNull( reportEntries.get( 0 ).getNameText() );

        TestExecutionSummary summary = executionListener.summaries.get( 0 );
        assertEquals( 0, summary.getTestsFoundCount() );
        assertEquals( 1, summary.getContainersFailedCount() );
        assertEquals( 0, summary.getTestsStartedCount() );
        assertEquals( 0, summary.getTestsSucceededCount() );
        assertEquals( 0, summary.getTestsFailedCount() );
    }

    @Test
    public void detectFailedParameterized()
            throws Exception
    {
        Launcher launcher = LauncherFactory.create();
        ProviderParameters parameters = providerParametersMock();

        JUnitPlatformProvider provider = new JUnitPlatformProvider( parameters, launcher );

        TestPlanSummaryListener executionListener = new TestPlanSummaryListener();

        RunListener listener = mock( RunListener.class );
        ArgumentCaptor<ReportEntry> entryCaptor = ArgumentCaptor.forClass( ReportEntry.class );
        RunListenerAdapter adapter = new RunListenerAdapter( listener );

        launcher.registerTestExecutionListeners( executionListener, adapter );

        invokeProvider( provider, TestClass9.class );

        assertThat( executionListener.summaries ).hasSize( 1 );

        verify( listener, times( 1 ) ).testSetCompleted( any() );
        verify( listener, times( 1 ) ).testFailed( entryCaptor.capture() );
        List<ReportEntry> reportEntries = entryCaptor.getAllValues();

        assertEquals( TestClass9.class.getName(), reportEntries.get( 0 ).getSourceName() );
        assertNull( reportEntries.get( 0 ).getSourceText() );
        assertEquals( "testParameterizedTestCases", reportEntries.get( 0 ).getName() );
        assertNull( reportEntries.get( 0 ).getNameText() );

        TestExecutionSummary summary = executionListener.summaries.get( 0 );
        assertEquals( 0, summary.getTestsFoundCount() );
        assertEquals( 1, summary.getContainersFailedCount() );
        assertEquals( 0, summary.getTestsStartedCount() );
        assertEquals( 0, summary.getTestsSucceededCount() );
        assertEquals( 0, summary.getTestsFailedCount() );
    }

    @Test
    public void rerunParameterized()
            throws Exception
    {
        Launcher launcher = LauncherFactory.create();
        ProviderParameters parameters = providerParametersMock();
        // Mock the rerun variable
        when( parameters.getTestRequest().getRerunFailingTestsCount() ).thenReturn( 2 );
        when( parameters.getProviderProperties() )
                .thenReturn( singletonMap( JUnitPlatformProvider.CONFIGURATION_PARAMETERS,
                        "forkCount = 1\nreuseForks = true" ) );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( parameters, launcher );

        TestPlanSummaryListener executionListener = new TestPlanSummaryListener();

        RunListener listener = mock( RunListener.class );
        ArgumentCaptor<ReportEntry> entryCaptor = ArgumentCaptor.forClass( ReportEntry.class );
        RunListenerAdapter adapter = new RunListenerAdapter( listener );

        launcher.registerTestExecutionListeners( executionListener, adapter );

        invokeProvider( provider, TestClass7.class );

        assertThat( executionListener.summaries ).hasSize( 3 );

        verify( listener, times( 4 ) ).testStarting( entryCaptor.capture() );
        List<ReportEntry> reportEntries = entryCaptor.getAllValues();

        assertEquals( TestClass7.class.getName(), reportEntries.get( 0 ).getSourceName() );
        assertNull( reportEntries.get( 0 ).getSourceText() );
        assertEquals( "testParameterizedTestCases(String, boolean)[1]", reportEntries.get( 0 ).getName() );
        assertEquals( "[1] Always pass, true", reportEntries.get( 0 ).getNameText() );

        assertEquals( TestClass7.class.getName(), reportEntries.get( 1 ).getSourceName() );
        assertNull( reportEntries.get( 1 ).getSourceText() );
        assertEquals( "testParameterizedTestCases(String, boolean)[2]", reportEntries.get( 1 ).getName() );
        assertEquals( "[2] Always fail, false", reportEntries.get( 1 ).getNameText() );

        assertEquals( TestClass7.class.getName(), reportEntries.get( 2 ).getSourceName() );
        assertNull( reportEntries.get( 2 ).getSourceText() );
        assertEquals( "testParameterizedTestCases(String, boolean)[2]", reportEntries.get( 2 ).getName() );
        assertEquals( "[2] Always fail, false", reportEntries.get( 2 ).getNameText() );

        assertEquals( TestClass7.class.getName(), reportEntries.get( 3 ).getSourceName() );
        assertNull( reportEntries.get( 3 ).getSourceText() );
        assertEquals( "testParameterizedTestCases(String, boolean)[2]", reportEntries.get( 3 ).getName() );
        assertEquals( "[2] Always fail, false", reportEntries.get( 3 ).getNameText() );

        TestExecutionSummary summary = executionListener.summaries.get( 0 );
        assertEquals( 2, summary.getTestsFoundCount() );
        assertEquals( 2, summary.getTestsStartedCount() );
        assertEquals( 1, summary.getTestsSucceededCount() );
        assertEquals( 1, summary.getTestsFailedCount() );

        summary = executionListener.summaries.get( 1 );
        assertEquals( 1, summary.getTestsFoundCount() );
        assertEquals( 1, summary.getTestsStartedCount() );
        assertEquals( 0, summary.getTestsSucceededCount() );
        assertEquals( 1, summary.getTestsFailedCount() );

        summary = executionListener.summaries.get( 2 );
        assertEquals( 1, summary.getTestsFoundCount() );
        assertEquals( 1, summary.getTestsStartedCount() );
        assertEquals( 0, summary.getTestsSucceededCount() );
        assertEquals( 1, summary.getTestsFailedCount() );
    }

    @Test
    public void allDiscoveredTestsAreInvokedForNullArgument()
                    throws Exception
    {
        RunListener runListener = runListenerMock();
        ProviderParameters providerParameters =
                        providerParametersMock( runListener, TestClass1.class, TestClass2.class );
        Launcher launcher = LauncherFactory.create();
        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters, launcher );

        TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
        launcher.registerTestExecutionListeners( executionListener );

        invokeProvider( provider, null );

        InOrder inOrder = inOrder( runListener );

        ArgumentCaptor<SimpleReportEntry> report = ArgumentCaptor.forClass( SimpleReportEntry.class );
        inOrder.verify( runListener )
                .testSetStarting( report.capture() );
        Assertions.assertThat( report.getValue().getSourceName() )
                .isEqualTo( TestClass1.class.getName() );
        Assertions.assertThat( report.getValue().getName() )
                .isNull();

        report = ArgumentCaptor.forClass( SimpleReportEntry.class );
        inOrder.verify( runListener )
                .testSetCompleted( report.capture() );
        Assertions.assertThat( report.getValue().getSourceName() )
                .isEqualTo( TestClass1.class.getName() );
        Assertions.assertThat( report.getValue().getName() )
                .isNull();

        report = ArgumentCaptor.forClass( SimpleReportEntry.class );
        inOrder.verify( runListener )
                .testSetStarting( report.capture() );
        Assertions.assertThat( report.getValue().getSourceName() )
                .isEqualTo( TestClass2.class.getName() );
        Assertions.assertThat( report.getValue().getName() )
                .isNull();

        report = ArgumentCaptor.forClass( SimpleReportEntry.class );
        inOrder.verify( runListener )
                .testSetCompleted( report.capture() );
        Assertions.assertThat( report.getValue().getSourceName() )
                .isEqualTo( TestClass2.class.getName() );
        Assertions.assertThat( report.getValue().getName() )
                .isNull();

        assertThat( executionListener.summaries ).hasSize( 1 );
        TestExecutionSummary summary = executionListener.summaries.get( 0 );
        assertEquals( TestClass1.TESTS_FOUND + TestClass2.TESTS_FOUND, summary.getTestsFoundCount() );
        assertEquals(
                        TestClass1.TESTS_STARTED + TestClass2.TESTS_STARTED, summary.getTestsStartedCount() );
        assertEquals(
                        TestClass1.TESTS_SKIPPED + TestClass2.TESTS_SKIPPED, summary.getTestsSkippedCount() );
        assertEquals(
                        TestClass1.TESTS_SUCCEEDED + TestClass2.TESTS_SUCCEEDED, summary.getTestsSucceededCount() );
        assertEquals(
                        TestClass1.TESTS_ABORTED + TestClass2.TESTS_ABORTED, summary.getTestsAbortedCount() );
        assertEquals( TestClass1.TESTS_FAILED + TestClass2.TESTS_FAILED, summary.getTestsFailedCount() );
    }

    @Test
    public void outputIsCaptured()
                    throws Exception
    {
        Launcher launcher = LauncherFactory.create();
        RunListener runListener = runListenerMock();
        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParametersMock( runListener ), launcher );

        invokeProvider( provider, VerboseTestClass.class );

        ArgumentCaptor<String> captor = ArgumentCaptor.forClass( String.class );
        verify( (ConsoleOutputReceiver) runListener )
                        .writeTestOutput( captor.capture(), eq( true ), eq( true ) );
        verify( (ConsoleOutputReceiver) runListener )
                        .writeTestOutput( captor.capture(), eq( true ), eq( false ) );
        assertThat( captor.getAllValues() )
                .hasSize( 2 )
                .containsExactly( "stdout", "stderr" );
    }

    @Test
    public void onlyGroupsIsDeclared()
    {
        Map<String, String> properties = singletonMap( TESTNG_GROUPS_PROP, "groupOne, groupTwo" );

        ProviderParameters providerParameters = providerParametersMock( TestClass1.class );
        when( providerParameters.getProviderProperties() ).thenReturn( properties );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters );

        assertEquals( 1, provider.getFilters().length );
    }

    @Test
    public void onlyExcludeTagsIsDeclared()
    {
        Map<String, String> properties = singletonMap( TESTNG_EXCLUDEDGROUPS_PROP, "tagOne, tagTwo" );

        ProviderParameters providerParameters = providerParametersMock( TestClass1.class );
        when( providerParameters.getProviderProperties() ).thenReturn( properties );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters );

        assertEquals( 1, provider.getFilters().length );
    }

    @Test
    public void noFiltersAreCreatedIfTagsAreEmpty()
    {
        Map<String, String> properties = singletonMap( TESTNG_GROUPS_PROP, "" );

        ProviderParameters providerParameters = providerParametersMock( TestClass1.class );
        when( providerParameters.getProviderProperties() ).thenReturn( properties );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters );
        assertEquals( 0, provider.getFilters().length );
    }

    @Test
    public void filtersWithEmptyTagsAreNotRegistered()
    {
        // Here only tagOne is registered as a valid tag and other tags are ignored as they are empty
        Map<String, String> properties = singletonMap( TESTNG_EXCLUDEDGROUPS_PROP, "tagOne," );

        ProviderParameters providerParameters = providerParametersMock( TestClass1.class );
        when( providerParameters.getProviderProperties() ).thenReturn( properties );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters );
        assertEquals( 1, provider.getFilters().length );
    }

    @Test
    public void bothIncludeAndExcludeAreAllowed()
    {
        Map<String, String> properties = new HashMap<>();
        properties.put( TESTNG_GROUPS_PROP, "tagOne, tagTwo" );
        properties.put( TESTNG_EXCLUDEDGROUPS_PROP, "tagThree, tagFour" );

        ProviderParameters providerParameters = providerParametersMock( TestClass1.class );
        when( providerParameters.getProviderProperties() ).thenReturn( properties );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters );

        assertEquals( 2, provider.getFilters().length );
    }

    @Test
    public void tagExpressionsAreSupportedForIncludeTagsContainingVerticalBar()
    {
        Map<String, String> properties = new HashMap<>();
        properties.put( TESTNG_GROUPS_PROP, "tagOne | tagTwo" );
        properties.put( TESTNG_EXCLUDEDGROUPS_PROP, "tagThree | tagFour" );

        ProviderParameters providerParameters = providerParametersMock( TestClass1.class );
        when( providerParameters.getProviderProperties() ).thenReturn( properties );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters );

        assertEquals( 2, provider.getFilters().length );
    }

    @Test
    public void tagExpressionsAreSupportedForIncludeTagsContainingAmpersand()
    {
        Map<String, String> properties = new HashMap<>();
        properties.put( TESTNG_GROUPS_PROP, "tagOne & !tagTwo" );
        properties.put( TESTNG_EXCLUDEDGROUPS_PROP, "tagThree & !tagFour" );

        ProviderParameters providerParameters = providerParametersMock( TestClass1.class );
        when( providerParameters.getProviderProperties() ).thenReturn( properties );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters );

        assertEquals( 2, provider.getFilters().length );
    }

    @Test
    public void noFiltersAreCreatedIfNoPropertiesAreDeclared()
    {
        ProviderParameters providerParameters = providerParametersMock( TestClass1.class );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters );

        assertEquals( 0, provider.getFilters().length );
    }

    @Test
    public void defaultConfigurationParametersAreEmpty()
    {
        ProviderParameters providerParameters = providerParametersMock( TestClass1.class );
        when( providerParameters.getProviderProperties() ).thenReturn( emptyMap() );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters );

        assertTrue( provider.getConfigurationParameters().isEmpty() );
    }

    @Test
    public void parsesConfigurationParameters()
    {
        ProviderParameters providerParameters = providerParametersMock( TestClass1.class );
        when( providerParameters.getProviderProperties() )
                        .thenReturn( singletonMap( JUnitPlatformProvider.CONFIGURATION_PARAMETERS,
                                                     "foo = true\nbar 42\rbaz: *\r\nqux: EOF" ) );

        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters );

        assertEquals( 4, provider.getConfigurationParameters().size() );
        assertEquals( "true", provider.getConfigurationParameters().get( "foo" ) );
        assertEquals( "42", provider.getConfigurationParameters().get( "bar" ) );
        assertEquals( "*", provider.getConfigurationParameters().get( "baz" ) );
        assertEquals( "EOF", provider.getConfigurationParameters().get( "qux" ) );
    }

    @Test
    public void executesSingleTestIncludedByName()
                    throws Exception
    {
        // following is equivalent of adding '-Dtest=TestClass3#prefix1Suffix1'
        // '*' needed because it's a nested class and thus has name prefixed with '$'
        String pattern = "*TestClass3#prefix1Suffix1";

        testExecutionOfMatchingTestMethods( TestClass3.class, pattern, "prefix1Suffix1()" );
    }

    @Test
    public void executesMultipleTestsIncludedByName()
                    throws Exception
    {
        // following is equivalent of adding '-Dtest=TestClass3#prefix1Suffix1+prefix2Suffix1'
        // '*' needed because it's a nested class and thus has name prefixed with '$'
        String pattern = "*TestClass3#prefix1Suffix1+prefix2Suffix1";

        testExecutionOfMatchingTestMethods(
                        TestClass3.class, pattern, "prefix1Suffix1()", "prefix2Suffix1()" );
    }

    @Test
    public void executesMultipleTestsIncludedByNamePattern()
                    throws Exception
    {
        // following is equivalent of adding '-Dtest=TestClass3#prefix1*'
        // '*' needed because it's a nested class and thus has name prefixed with '$'
        String pattern = "*TestClass3#prefix1*";

        testExecutionOfMatchingTestMethods(
                        TestClass3.class, pattern, "prefix1Suffix1()", "prefix1Suffix2()" );
    }

    @Test
    public void executesMultipleTestsIncludedByNamePatternWithQuestionMark()
                    throws Exception
    {
        // following is equivalent of adding '-Dtest=TestClass3#prefix?Suffix2'
        // '*' needed because it's a nested class and thus has name prefixed with '$'
        String pattern = "*TestClass3#prefix?Suffix2";

        testExecutionOfMatchingTestMethods(
                        TestClass3.class, pattern, "prefix1Suffix2()", "prefix2Suffix2()" );
    }

    @Test
    public void doesNotExecuteTestsExcludedByName()
                    throws Exception
    {
        // following is equivalent of adding '-Dtest=!TestClass3#prefix1Suffix2'
        // '*' needed because it's a nested class and thus has name prefixed with '$'
        String pattern = "!*TestClass3#prefix1Suffix2";

        testExecutionOfMatchingTestMethods(
                        TestClass3.class, pattern, "prefix1Suffix1()", "prefix2Suffix1()", "prefix2Suffix2()" );
    }

    @Test
    public void doesNotExecuteTestsExcludedByNamePattern()
                    throws Exception
    {
        // following is equivalent of adding '-Dtest=!TestClass3#prefix2*'
        // '*' needed because it's a nested class and thus has name prefixed with '$'
        String pattern = "!*TestClass3#prefix2*";

        testExecutionOfMatchingTestMethods(
                        TestClass3.class, pattern, "prefix1Suffix1()", "prefix1Suffix2()" );
    }

    private static void testExecutionOfMatchingTestMethods( Class<?> testClass, String pattern,
                                                            String... expectedTestNames )
                    throws Exception
    {
        TestListResolver testListResolver = new TestListResolver( pattern );
        ProviderParameters providerParameters = providerParametersMock( testListResolver, testClass );
        Launcher launcher = LauncherFactory.create();
        JUnitPlatformProvider provider = new JUnitPlatformProvider( providerParameters, launcher );

        TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
        launcher.registerTestExecutionListeners( executionListener );

        invokeProvider( provider, null );

        assertEquals( 1, executionListener.summaries.size() );
        TestExecutionSummary summary = executionListener.summaries.get( 0 );
        int expectedCount = expectedTestNames.length;
        assertEquals( expectedCount, summary.getTestsFoundCount() );
        assertEquals( expectedCount, summary.getTestsFailedCount() );
        assertEquals( expectedCount, summary.getFailures().size() );

        assertThat( failedTestDisplayNames( summary ) ).contains( expectedTestNames );
    }

    private static ProviderParameters providerParametersMock( Class<?>... testClasses )
    {
        return providerParametersMock( runListenerMock(), testClasses );
    }

    private static ProviderParameters providerParametersMock(
                    RunListener runListener, Class<?>... testClasses )
    {
        TestListResolver testListResolver = new TestListResolver( "" );
        return providerParametersMock( runListener, testListResolver, testClasses );
    }

    private static ProviderParameters providerParametersMock(
                    TestListResolver testListResolver, Class<?>... testClasses )
    {
        return providerParametersMock( runListenerMock(), testListResolver, testClasses );
    }

    private static ProviderParameters providerParametersMock(
                    RunListener runListener, TestListResolver testListResolver, Class<?>... testClasses )
    {
        TestsToRun testsToRun = newTestsToRun( testClasses );

        ScanResult scanResult = mock( ScanResult.class );
        when( scanResult.applyFilter( any(), any() ) ).thenReturn( testsToRun );

        RunOrderCalculator runOrderCalculator = mock( RunOrderCalculator.class );
        when( runOrderCalculator.orderTestClasses( any() ) ).thenReturn( testsToRun );

        ReporterFactory reporterFactory = mock( ReporterFactory.class );
        when( reporterFactory.createReporter() ).thenReturn( runListener );

        TestRequest testRequest = mock( TestRequest.class );
        when( testRequest.getTestListResolver() ).thenReturn( testListResolver );

        ProviderParameters providerParameters = mock( ProviderParameters.class );
        when( providerParameters.getScanResult() ).thenReturn( scanResult );
        when( providerParameters.getRunOrderCalculator() ).thenReturn( runOrderCalculator );
        when( providerParameters.getReporterFactory() ).thenReturn( reporterFactory );
        when( providerParameters.getTestRequest() ).thenReturn( testRequest );

        return providerParameters;
    }

    private static RunListener runListenerMock()
    {
        return mock( RunListener.class, withSettings().extraInterfaces( ConsoleOutputReceiver.class ) );
    }

    private static Set<String> failedTestDisplayNames( TestExecutionSummary summary )
    {
        // @formatter:off
        return summary.getFailures()
                .stream()
                .map( Failure::getTestIdentifier )
                .map( TestIdentifier::getDisplayName )
                .collect( toSet() );
        // @formatter:on
    }

    private static TestsToRun newTestsToRun( Class<?>... testClasses )
    {
        List<Class<?>> classesList = Arrays.asList( testClasses );
        return new TestsToRun( new LinkedHashSet<>( classesList ) );
    }

    private static TestsToRun newTestsToRunLazily( Class<?>... testClasses )
    {
        class LazyTestsToRunFake extends TestsToRun
        {
            LazyTestsToRunFake( Set<Class<?>> locatedClasses )
            {
                super( locatedClasses );
            }

            @Override
            public boolean allowEagerReading()
            {
                return false;
            }
        }
        List<Class<?>> classesList = Arrays.asList( testClasses );
        return new LazyTestsToRunFake( new LinkedHashSet<>( classesList ) );
    }

    private static class TestPlanSummaryListener
                    extends SummaryGeneratingListener
    {
        private final List<TestExecutionSummary> summaries = new ArrayList<>();

        @Override
        public void testPlanExecutionFinished( TestPlan testPlan )
        {
            super.testPlanExecutionFinished( testPlan );
            summaries.add( getSummary() );
        }
    }

    /**
     * Invokes the provider, then restores system out and system error.
     *
     * @see <a href="https://github.com/junit-team/junit5/issues/986">#986</a>
     */
    private static void invokeProvider( JUnitPlatformProvider provider, Object forkTestSet )
                    throws TestSetFailedException
    {
        PrintStream systemOut = System.out;
        PrintStream systemErr = System.err;
        try
        {
            provider.invoke( forkTestSet );
        }
        finally
        {
            System.setOut( systemOut );
            System.setErr( systemErr );
        }
    }

    static class TestClass1
    {

        static final int TESTS_FOUND = 4;

        static final int TESTS_STARTED = 3;

        static final int TESTS_SKIPPED = 1;

        static final int TESTS_SUCCEEDED = 2;

        static final int TESTS_ABORTED = 0;

        static final int TESTS_FAILED = 1;

        @org.junit.jupiter.api.Test
        void test1()
        {
        }

        @org.junit.jupiter.api.Test
        void test2()
        {
        }

        @Disabled
        @org.junit.jupiter.api.Test
        void test3()
        {
        }

        @org.junit.jupiter.api.Test
        void test4()
        {
            throw new RuntimeException();
        }
    }

    static class TestClass2
    {

        static final int TESTS_FOUND = 3;

        static final int TESTS_STARTED = 3;

        static final int TESTS_SKIPPED = 0;

        static final int TESTS_SUCCEEDED = 1;

        static final int TESTS_ABORTED = 1;

        static final int TESTS_FAILED = 1;

        @org.junit.jupiter.api.Test
        void test1()
        {
        }

        @org.junit.jupiter.api.Test
        void test2()
        {
            throw new RuntimeException();
        }

        @org.junit.jupiter.api.Test
        void test3()
        {
            assumeTrue( false );
        }
    }

    static class VerboseTestClass
    {
        @org.junit.jupiter.api.Test
        void test()
        {
            System.out.println( "stdout" );
            System.err.println( "stderr" );
        }
    }

    @Test
    public void usesClassNamesForXmlReport()
                    throws TestSetFailedException
    {
        String[] classNames = { Sub1Tests.class.getName(), Sub2Tests.class.getName() };
        ProviderParameters providerParameters =
                        providerParametersMock( Sub1Tests.class, Sub2Tests.class );

        JUnitPlatformProvider jUnitPlatformProvider = new JUnitPlatformProvider( providerParameters );
        TestsToRun testsToRun = newTestsToRun( Sub1Tests.class, Sub2Tests.class );

        invokeProvider( jUnitPlatformProvider, testsToRun );
        RunListener reporter = providerParameters.getReporterFactory().createReporter();

        ArgumentCaptor<ReportEntry> reportEntryArgumentCaptor =
                        ArgumentCaptor.forClass( ReportEntry.class );
        verify( reporter, times( 2 ) ).testSucceeded( reportEntryArgumentCaptor.capture() );

        List<ReportEntry> allValues = reportEntryArgumentCaptor.getAllValues();
        assertThat( allValues ).extracting( ReportEntry::getSourceName ).containsExactly( classNames );
    }

    static class AbstractTestClass
    {
        @org.junit.jupiter.api.Test
        void test()
        {
        }
    }

    static class Sub1Tests
                    extends AbstractTestClass
    {
    }

    static class Sub2Tests
                    extends AbstractTestClass
    {
    }

    static class TestClass3
    {
        @org.junit.jupiter.api.Test
        void prefix1Suffix1()
        {
            throw new RuntimeException();
        }

        @org.junit.jupiter.api.Test
        void prefix2Suffix1()
        {
            throw new RuntimeException();
        }

        @org.junit.jupiter.api.Test
        void prefix1Suffix2()
        {
            throw new RuntimeException();
        }

        @org.junit.jupiter.api.Test
        void prefix2Suffix2()
        {
            throw new RuntimeException();
        }
    }

    static class TestClass4
    {
        static int count;

        @org.junit.jupiter.api.DisplayName( "Always passes" )
        @org.junit.jupiter.api.Test
        void testPass()
        {
        }

        @org.junit.jupiter.api.Test
        void testAborted()
        {
            assumeFalse( true );
            throw new IllegalStateException( "this exception should never happen" );
        }

        @org.junit.jupiter.api.Test
        void testAlwaysError()
        {
            throw new Error( "some error" );
        }

        @org.junit.jupiter.api.Test
        void testAlwaysFail()
        {
            assertTrue( false );
        }

        @org.junit.jupiter.api.Test
        @org.junit.jupiter.api.Disabled
        void testAlwaysSkipped()
        {
            throw new IllegalStateException( "this test should be never called" );
        }

        @org.junit.jupiter.api.DisplayName( "Fails twice" )
        @org.junit.jupiter.api.Test
        void testFailTwice()
        {
            count += 1;
            assertTrue( count >= 3 );
        }
    }

    static class TestClass5
    {
        static int count;

        @org.junit.jupiter.api.Test
        void testFailTwice1()
        {
            count += 1;
            assertTrue( count >= 3 );
        }
    }

    static class TestClass7
    {
        static List<Object[]> params()
        {
            return Arrays.asList(  new Object[] { "Always pass", true },
                    new Object[] { "Always fail", false }  );
        }

        @org.junit.jupiter.params.ParameterizedTest
        @org.junit.jupiter.params.provider.MethodSource( "params" )
        void testParameterizedTestCases( String testName, boolean value )
        {
            assertTrue( value );
        }
    }

    static class TestClass8
    {
        static List<Object[]> params()
        {
            throw new RuntimeException();
        }

        @org.junit.jupiter.params.ParameterizedTest
        @org.junit.jupiter.params.provider.MethodSource( "params" )
        void testParameterizedTestCases()
        {
        }
    }

    static class TestClass9
    {
        static List<Object[]> params()
        {
            assertTrue( false );
            return new ArrayList<>();
        }

        @org.junit.jupiter.params.ParameterizedTest
        @org.junit.jupiter.params.provider.MethodSource( "params" )
        void testParameterizedTestCases()
        {
        }
    }

    @DisplayName( "<< ✨ >>" )
    static class DisplayNameTest
    {
        @org.junit.jupiter.api.Test
        @DisplayName( "73$71 ✔" )
        void test1()
        {
        }
    }

    static class FailingBeforeAllJupiterTest
    {

        @BeforeAll
        static void oneTimeSetUp()
        {
            fail( "oneTimeSetUp() failed" );
        }

        @org.junit.jupiter.api.Test
        void test()
        {
        }

    }

    static class FailingWithErrorBeforeAllJupiterTest
    {

        @BeforeAll
        static void oneTimeSetUp()
        {
            throw new RuntimeException( "oneTimeSetUp() threw an exception" );
        }

        @org.junit.jupiter.api.Test
        void test()
        {
        }

    }
}