[maven-surefire] branch 1564_2 updated (1fecdad -> 5dbffcc)

classic Classic list List threaded Threaded
2 messages Options
Reply | Threaded
Open this post in threaded view
|

[maven-surefire] branch 1564_2 updated (1fecdad -> 5dbffcc)

Tibor Digana
This is an automated email from the ASF dual-hosted git repository.

tibordigana pushed a change to branch 1564_2
in repository https://gitbox.apache.org/repos/asf/maven-surefire.git.


 discard 1fecdad  [SUREFIRE-1564] Can't override platform version through project/plugin dependencies
     add 57fbb16  [SUREFIRE-1532] MIME type for javascript is now officially application/javascript
     new 5dbffcc  [SUREFIRE-1564] Can't override platform version through project/plugin dependencies

This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version.  This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:

 * -- * -- B -- O -- O -- O   (1fecdad)
            \
             N -- N -- N   refs/heads/1564_2 (5dbffcc)

You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.

Any revisions marked "omit" are not gone; other references still
refer to them.  Any revisions marked "discard" are gone forever.

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 .../surefire/report/SurefireReportGenerator.java   |  2 +-
 surefire-its/pom.xml                               | 27 ++++++-
 .../surefire/its/JUnit47RedirectOutputIT.java      |  2 +-
 .../jiras/Surefire260TestWithIdenticalNamesIT.java | 39 ++++++----
 .../surefire-260-testWithIdenticalNames/pom.xml    | 91 +++++++++++++---------
 5 files changed, 107 insertions(+), 54 deletions(-)

Reply | Threaded
Open this post in threaded view
|

[maven-surefire] 01/01: [SUREFIRE-1564] Can't override platform version through project/plugin dependencies

Tibor Digana
This is an automated email from the ASF dual-hosted git repository.

tibordigana pushed a commit to branch 1564_2
in repository https://gitbox.apache.org/repos/asf/maven-surefire.git

commit 5dbffcc12f26407e76325357593414bb67e55733
Author: Christian Stein <[hidden email]>
AuthorDate: Fri Sep 14 05:51:56 2018 +0200

    [SUREFIRE-1564] Can't override platform version through project/plugin dependencies
---
 .../plugin/surefire/AbstractSurefireMojo.java      | 173 +++++++++------------
 .../maven/plugin/surefire/ClasspathCache.java      |  17 ++
 .../apache/maven/plugin/surefire/ProviderInfo.java |  10 +-
 .../surefire/SurefireDependencyResolver.java       |  64 ++++----
 .../maven/plugin/surefire/TestClassPath.java       | 115 ++++++++++++++
 .../AbstractSurefireMojoJava7PlusTest.java         |  74 +++++++--
 .../plugin/surefire/AbstractSurefireMojoTest.java  |  92 ++++++++---
 .../maven/surefire/its/JUnitPlatformEnginesIT.java | 160 +++++++++++++++++++
 .../apache/maven/surefire/its/JUnitPlatformIT.java |  48 +++---
 .../apache/maven/surefire/its/fixture/IsRegex.java | 100 ++++++++++++
 .../surefire/its/fixture/OutputValidator.java      |  29 ++--
 .../Surefire1082ParallelJUnitParameterizedIT.java  |  61 +-------
 .../test/resources/junit-platform-1.1.1/pom.xml    |  60 -------
 .../JUnitPlatform_1_1_1_Test.java                  |  37 -----
 .../test/resources/junit-platform-1.2.0/pom.xml    |  60 -------
 .../JUnitPlatform_1_2_0_Test.java                  |  37 -----
 .../pom.xml                                        |  17 +-
 .../java/junitplatform/JUnitPlatformTest.java}     |   5 +-
 surefire-providers/surefire-junit-platform/pom.xml |   4 +-
 .../junitplatform/RunListenerAdapterTest.java      |   5 +-
 .../junitplatform/TestMethodFilterTest.java        |   5 +-
 21 files changed, 693 insertions(+), 480 deletions(-)

diff --git a/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/AbstractSurefireMojo.java b/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/AbstractSurefireMojo.java
index fa4f257..1a52dab 100644
--- a/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/AbstractSurefireMojo.java
+++ b/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/AbstractSurefireMojo.java
@@ -1712,64 +1712,59 @@ public abstract class AbstractSurefireMojo
     private StartupConfiguration createStartupConfiguration( @Nonnull ProviderInfo provider, boolean isInprocess,
                                                              @Nonnull ClassLoaderConfiguration classLoaderConfiguration,
                                                              @Nonnull DefaultScanResult scanResult )
-        throws MojoExecutionException, MojoFailureException
+        throws MojoExecutionException
     {
         try
         {
-            // cache the provider lookup
-            String providerName = provider.getProviderName();
-            Classpath providerClasspath = ClasspathCache.getCachedClassPath( providerName );
-            if ( providerClasspath == null )
-            {
-                // todo: 100 milli seconds, try to fetch List<String> within classpath asynchronously
-                providerClasspath = provider.getProviderClasspath();
-                ClasspathCache.setCachedClasspath( providerName, providerClasspath );
-            }
-            Artifact surefireArtifact = getCommonArtifact();
-            Classpath inprocClassPath =
-                    providerClasspath.addClassPathElementUrl( surefireArtifact.getFile().getAbsolutePath() )
-                            .addClassPathElementUrl( getApiArtifact().getFile().getAbsolutePath() );
-
             File moduleDescriptor = getModuleDescriptor();
-
+            Set<Artifact> providerArtifacts = provider.getProviderClasspath();
+            String providerName = provider.getProviderName();
             if ( moduleDescriptor.exists() && !isInprocess )
             {
-                return newStartupConfigForModularClasspath( classLoaderConfiguration, providerClasspath, providerName,
+                return newStartupConfigWithModularPath( classLoaderConfiguration, providerArtifacts, providerName,
                         moduleDescriptor, scanResult );
             }
             else
             {
-                return newStartupConfigForNonModularClasspath( classLoaderConfiguration, providerClasspath,
-                        inprocClassPath, providerName );
+                return newStartupConfigWithClasspath( classLoaderConfiguration, providerArtifacts, providerName );
             }
         }
         catch ( AbstractArtifactResolutionException e )
         {
             throw new MojoExecutionException( "Unable to generate classpath: " + e, e );
         }
-        catch ( InvalidVersionSpecificationException e )
-        {
-            throw new MojoExecutionException( "Unable to generate classpath: " + e, e );
-        }
         catch ( IOException e )
         {
             throw new MojoExecutionException( e.getMessage(), e );
         }
     }
 
-    private StartupConfiguration newStartupConfigForNonModularClasspath(
-            @Nonnull ClassLoaderConfiguration classLoaderConfiguration, @Nonnull Classpath providerClasspath,
-            @Nonnull Classpath inprocClasspath, @Nonnull String providerName )
-            throws MojoExecutionException, MojoFailureException, InvalidVersionSpecificationException,
-            AbstractArtifactResolutionException
+    private StartupConfiguration newStartupConfigWithClasspath(
+            @Nonnull ClassLoaderConfiguration classLoaderConfiguration, @Nonnull Set<Artifact> providerArtifacts,
+            @Nonnull String providerName )
     {
-        Classpath testClasspath = generateTestClasspath();
+        TestClassPath testClasspathWrapper = generateTestClasspath();
+        Classpath testClasspath = testClasspathWrapper.toClasspath();
+
+        testClasspathWrapper.avoidArtifactDuplicates( providerArtifacts );
+
+        Classpath providerClasspath = ClasspathCache.getCachedClassPath( providerName );
+        if ( providerClasspath == null )
+        {
+            providerClasspath = ClasspathCache.setCachedClasspath( providerName, providerArtifacts );
+        }
 
         getConsoleLogger().debug( testClasspath.getLogMessage( "test classpath:" ) );
         getConsoleLogger().debug( providerClasspath.getLogMessage( "provider classpath:" ) );
         getConsoleLogger().debug( testClasspath.getCompactLogMessage( "test(compact) classpath:" ) );
         getConsoleLogger().debug( providerClasspath.getCompactLogMessage( "provider(compact) classpath:" ) );
 
+        String surefireCommonArtifactPath = getCommonArtifact().getFile().getAbsolutePath(); // todo: why added?
+        String surefireApiArtifactPath = getApiArtifact().getFile().getAbsolutePath();
+        // todo: surefireApiArtifactPath is always in every provider - why added here?
+        Classpath inprocClasspath = providerClasspath.addClassPathElementUrl( surefireCommonArtifactPath )
+                .addClassPathElementUrl( surefireApiArtifactPath );
+
         ClasspathConfiguration classpathConfiguration = new ClasspathConfiguration( testClasspath, providerClasspath,
                 inprocClasspath, effectiveIsEnableAssertions(), isChildDelegation() );
 
@@ -1782,18 +1777,28 @@ public abstract class AbstractSurefireMojo
         return new LocationManager();
     }
 
-    private StartupConfiguration newStartupConfigForModularClasspath(
-            @Nonnull ClassLoaderConfiguration classLoaderConfiguration, @Nonnull Classpath providerClasspath,
+    private StartupConfiguration newStartupConfigWithModularPath(
+            @Nonnull ClassLoaderConfiguration classLoaderConfiguration, @Nonnull Set<Artifact> providerArtifacts,
             @Nonnull String providerName, @Nonnull File moduleDescriptor, @Nonnull DefaultScanResult scanResult )
-            throws MojoExecutionException, MojoFailureException, InvalidVersionSpecificationException,
-            AbstractArtifactResolutionException, IOException
+            throws IOException
     {
-        ResolvePathsRequest<String> req = ResolvePathsRequest.withStrings( generateTestClasspath().getClassPath() )
+        TestClassPath testClasspathWrapper = generateTestClasspath();
+        Classpath testClasspath = testClasspathWrapper.toClasspath();
+
+        testClasspathWrapper.avoidArtifactDuplicates( providerArtifacts );
+
+        Classpath providerClasspath = ClasspathCache.getCachedClassPath( providerName );
+        if ( providerClasspath == null )
+        {
+            providerClasspath = ClasspathCache.setCachedClasspath( providerName, providerArtifacts );
+        }
+
+        ResolvePathsRequest<String> req = ResolvePathsRequest.ofStrings( testClasspath.getClassPath() )
                 .setMainModuleDescriptor( moduleDescriptor.getAbsolutePath() );
 
         ResolvePathsResult<String> result = ( (LocationManager) getLocationManager() ).resolvePaths( req );
 
-        Classpath testClasspath = new Classpath( result.getClasspathElements() );
+        testClasspath = new Classpath( result.getClasspathElements() );
         Classpath testModulepath = new Classpath( result.getModulepathElements().keySet() );
 
         SortedSet<String> packages = new TreeSet<String>();
@@ -2094,13 +2099,13 @@ public abstract class AbstractSurefireMojo
     }
 
     private InPluginVMSurefireStarter createInprocessStarter( @Nonnull ProviderInfo provider,
-                                                             @Nonnull ClassLoaderConfiguration classLoaderConfiguration,
+                                                              @Nonnull ClassLoaderConfiguration classLoaderConfig,
                                                               @Nonnull RunOrderParameters runOrderParameters,
                                                               @Nonnull DefaultScanResult scanResult )
         throws MojoExecutionException, MojoFailureException
     {
         StartupConfiguration startupConfiguration =
-                createStartupConfiguration( provider, true, classLoaderConfiguration, scanResult );
+                createStartupConfiguration( provider, true, classLoaderConfig, scanResult );
         String configChecksum = getConfigChecksum();
         StartupReportConfiguration startupReportConfiguration = getStartupReportConfiguration( configChecksum, false );
         ProviderConfiguration providerConfiguration = createProviderConfiguration( runOrderParameters );
@@ -2425,25 +2430,12 @@ public abstract class AbstractSurefireMojo
     }
 
     /**
-     * Generate the test classpath.
+     * Generates the test classpath.
      *
-     * @return List containing the classpath elements
-     * @throws InvalidVersionSpecificationException
-     *                                     when it happens
-     * @throws MojoFailureException        when it happens
-     * @throws ArtifactNotFoundException   when it happens
-     * @throws ArtifactResolutionException when it happens
+     * @return the classpath elements
      */
-    private Classpath generateTestClasspath()
-        throws InvalidVersionSpecificationException, MojoFailureException, ArtifactResolutionException,
-        ArtifactNotFoundException, MojoExecutionException
+    private TestClassPath generateTestClasspath()
     {
-        List<String> classpath = new ArrayList<String>( 2 + getProject().getArtifacts().size() );
-
-        classpath.add( getTestClassesDirectory().getAbsolutePath() );
-
-        classpath.add( getClassesDirectory().getAbsolutePath() );
-
         @SuppressWarnings( "unchecked" ) Set<Artifact> classpathArtifacts = getProject().getArtifacts();
 
         if ( getClasspathDependencyScopeExclude() != null && !getClasspathDependencyScopeExclude().isEmpty() )
@@ -2459,38 +2451,16 @@ public abstract class AbstractSurefireMojo
             classpathArtifacts = filterArtifacts( classpathArtifacts, dependencyFilter );
         }
 
-        for ( Artifact artifact : classpathArtifacts )
-        {
-            if ( artifact.getArtifactHandler().isAddedToClasspath() )
-            {
-                File file = artifact.getFile();
-                if ( file != null )
-                {
-                    classpath.add( file.getPath() );
-                }
-            }
-        }
-
-        // Add additional configured elements to the classpath
-        if ( getAdditionalClasspathElements() != null )
-        {
-            for ( String classpathElement : getAdditionalClasspathElements() )
-            {
-                if ( classpathElement != null )
-                {
-                    addAll( classpath, split( classpathElement, "," ) );
-                }
-            }
-        }
+        return new TestClassPath( classpathArtifacts, getClassesDirectory(),
+                getTestClassesDirectory(), getAdditionalClasspathElements(), logger );
 
         // adding TestNG MethodSelector to the classpath
         // Todo: move
-        if ( getTestNgArtifact() != null )
+        // todo: why t use it in general, and surefire-grouper
+        /*if ( getTestNgArtifact() != null )
         {
             addTestNgUtilsArtifacts( classpath );
-        }
-
-        return new Classpath( classpath );
+        }*/
     }
 
     private void addTestNgUtilsArtifacts( List<String> classpath )
@@ -2836,12 +2806,12 @@ public abstract class AbstractSurefireMojo
 
         @Override
         @Nonnull
-        public Classpath getProviderClasspath()
+        public Set<Artifact> getProviderClasspath()
             throws ArtifactResolutionException, ArtifactNotFoundException
         {
             Artifact surefireArtifact = getPluginArtifactMap().get( "org.apache.maven.surefire:surefire-booter" );
-            return dependencyResolver.getProviderClasspath( "surefire-testng", surefireArtifact.getBaseVersion(),
-                                                            testNgArtifact );
+            String version = surefireArtifact.getBaseVersion();
+            return dependencyResolver.getProviderClasspath( "surefire-testng", version, testNgArtifact );
         }
     }
 
@@ -2867,14 +2837,13 @@ public abstract class AbstractSurefireMojo
 
         @Override
         @Nonnull
-        public Classpath getProviderClasspath()
+        public Set<Artifact> getProviderClasspath()
             throws ArtifactResolutionException, ArtifactNotFoundException
         {
             // add the JUnit provider as default - it doesn't require JUnit to be present,
             // since it supports POJO tests.
-            return dependencyResolver.getProviderClasspath( "surefire-junit3", surefireBooterArtifact.getBaseVersion(),
-                                                            null );
-
+            String version = surefireBooterArtifact.getBaseVersion();
+            return dependencyResolver.getProviderClasspath( "surefire-junit3", version, null );
         }
     }
 
@@ -2910,13 +2879,12 @@ public abstract class AbstractSurefireMojo
 
         @Override
         @Nonnull
-        public Classpath getProviderClasspath()
+        public Set<Artifact> getProviderClasspath()
             throws ArtifactResolutionException, ArtifactNotFoundException
         {
-            return dependencyResolver.getProviderClasspath( "surefire-junit4", surefireBooterArtifact.getBaseVersion(),
-                                                            null );
+            String version = surefireBooterArtifact.getBaseVersion();
+            return dependencyResolver.getProviderClasspath( "surefire-junit4", version, null );
         }
-
     }
 
     final class JUnitPlatformProviderInfo
@@ -2929,27 +2897,32 @@ public abstract class AbstractSurefireMojo
             this.junitArtifact = junitArtifact;
         }
 
-        @Nonnull public String getProviderName()
+        @Override
+        @Nonnull
+        public String getProviderName()
         {
             return "org.apache.maven.surefire.junitplatform.JUnitPlatformProvider";
         }
 
+        @Override
         public boolean isApplicable()
         {
             return junitArtifact != null;
         }
 
+        @Override
         public void addProviderProperties() throws MojoExecutionException
         {
             convertGroupParameters();
         }
 
-        public Classpath getProviderClasspath()
+        @Override
+        @Nonnull
+        public Set<Artifact> getProviderClasspath()
             throws ArtifactResolutionException, ArtifactNotFoundException
         {
-            return dependencyResolver.getProviderClasspath( "surefire-junit-platform",
-                                                            surefireBooterArtifact.getBaseVersion(),
-                                                            null );
+            String version = surefireBooterArtifact.getBaseVersion();
+            return dependencyResolver.getProviderClasspath( "surefire-junit-platform", version, null );
         }
     }
 
@@ -2994,11 +2967,11 @@ public abstract class AbstractSurefireMojo
 
         @Override
         @Nonnull
-        public Classpath getProviderClasspath()
+        public Set<Artifact> getProviderClasspath()
             throws ArtifactResolutionException, ArtifactNotFoundException
         {
-            return dependencyResolver.getProviderClasspath( "surefire-junit47", surefireBooterArtifact.getBaseVersion(),
-                                                            null );
+            String version = surefireBooterArtifact.getBaseVersion();
+            return dependencyResolver.getProviderClasspath( "surefire-junit47", version, null );
         }
     }
 
@@ -3044,7 +3017,7 @@ public abstract class AbstractSurefireMojo
 
         @Override
         @Nonnull
-        public Classpath getProviderClasspath()
+        public Set<Artifact> getProviderClasspath()
             throws ArtifactResolutionException, ArtifactNotFoundException
         {
             return dependencyResolver.addProviderToClasspath( pluginArtifactMap, getMojoArtifact() );
diff --git a/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/ClasspathCache.java b/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/ClasspathCache.java
index b8b2e2d..3bb1ac2 100644
--- a/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/ClasspathCache.java
+++ b/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/ClasspathCache.java
@@ -19,7 +19,12 @@ package org.apache.maven.plugin.surefire;
  * under the License.
  */
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+
+import org.apache.maven.artifact.Artifact;
 import org.apache.maven.surefire.booter.Classpath;
 
 import javax.annotation.Nonnull;
@@ -41,4 +46,16 @@ public class ClasspathCache
     {
         CLASSPATHS.put( key, classpath );
     }
+
+    public static Classpath setCachedClasspath( @Nonnull String key, @Nonnull Set<Artifact> artifacts )
+    {
+        Collection<String> files = new ArrayList<String>();
+        for ( Artifact artifact : artifacts )
+        {
+            files.add( artifact.getFile().getAbsolutePath() );
+        }
+        Classpath classpath = new Classpath( files );
+        setCachedClasspath( key, classpath );
+        return classpath;
+    }
 }
diff --git a/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/ProviderInfo.java b/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/ProviderInfo.java
index a3fb88e..e99cc82 100644
--- a/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/ProviderInfo.java
+++ b/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/ProviderInfo.java
@@ -19,12 +19,12 @@ package org.apache.maven.plugin.surefire;
  * under the License.
  */
 
-import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
-import org.apache.maven.artifact.resolver.ArtifactResolutionException;
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.artifact.resolver.AbstractArtifactResolutionException;
 import org.apache.maven.plugin.MojoExecutionException;
-import org.apache.maven.surefire.booter.Classpath;
 
 import javax.annotation.Nonnull;
+import java.util.Set;
 
 /**
  * @author Kristian Rosenvold
@@ -37,8 +37,8 @@ public interface ProviderInfo
     boolean isApplicable();
 
     @Nonnull
-    Classpath getProviderClasspath()
-        throws ArtifactResolutionException, ArtifactNotFoundException;
+    Set<Artifact> getProviderClasspath()
+        throws AbstractArtifactResolutionException;
 
     void addProviderProperties() throws MojoExecutionException;
 }
diff --git a/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/SurefireDependencyResolver.java b/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/SurefireDependencyResolver.java
index a43c4de..f33a316 100644
--- a/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/SurefireDependencyResolver.java
+++ b/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/SurefireDependencyResolver.java
@@ -19,10 +19,6 @@ package org.apache.maven.plugin.surefire;
  * under the License.
  */
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.artifact.factory.ArtifactFactory;
 import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
@@ -37,11 +33,19 @@ import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
 import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
 import org.apache.maven.artifact.versioning.OverConstrainedVersionException;
 import org.apache.maven.artifact.versioning.VersionRange;
-import org.apache.maven.surefire.booter.Classpath;
 import org.apache.maven.plugin.surefire.log.api.ConsoleLogger;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static java.util.Collections.singleton;
+import static org.apache.maven.artifact.Artifact.SCOPE_TEST;
+import static org.apache.maven.artifact.versioning.VersionRange.createFromVersion;
 
 /**
  * Does dependency resolution and artifact handling for the surefire plugin.
@@ -123,65 +127,55 @@ public class SurefireDependencyResolver
 
         Artifact originatingArtifact = artifactFactory.createBuildArtifact( "dummy", "dummy", "1.0", "jar" );
 
-        return artifactResolver.resolveTransitively( Collections.singleton( providerArtifact ), originatingArtifact,
+        return artifactResolver.resolveTransitively( singleton( providerArtifact ), originatingArtifact,
                                                      localRepository, remoteRepositories, artifactMetadataSource,
                                                      filter );
     }
 
     @Nonnull
-    public Classpath getProviderClasspath( String provider, String version, Artifact filteredArtifact )
+    @SuppressWarnings( "unchecked" )
+    public Set<Artifact> getProviderClasspath( String provider, String version, Artifact filteredArtifact )
         throws ArtifactNotFoundException, ArtifactResolutionException
     {
-        Classpath classPath = ClasspathCache.getCachedClassPath( provider );
-        if ( classPath == null )
-        {
-            Artifact providerArtifact = artifactFactory.createDependencyArtifact( "org.apache.maven.surefire", provider,
-                                                                                  VersionRange.createFromVersion(
-                                                                                      version ), "jar", null,
-                                                                                  Artifact.SCOPE_TEST );
-            ArtifactResolutionResult result = resolveArtifact( filteredArtifact, providerArtifact );
-            List<String> files = new ArrayList<String>();
+        Artifact providerArtifact = artifactFactory.createDependencyArtifact( "org.apache.maven.surefire",
+                provider, createFromVersion( version ), "jar", null, SCOPE_TEST );
+
+        ArtifactResolutionResult result = resolveArtifact( filteredArtifact, providerArtifact );
 
+        if ( log.isDebugEnabled() )
+        {
             for ( Object o : result.getArtifacts() )
             {
                 Artifact artifact = (Artifact) o;
-
-                log.debug(
-                    "Adding to " + pluginName + " test classpath: " + artifact.getFile().getAbsolutePath() + " Scope: "
-                        + artifact.getScope() );
-
-                files.add( artifact.getFile().getAbsolutePath() );
+                String artifactPath = artifact.getFile().getAbsolutePath();
+                String scope = artifact.getScope();
+                log.debug( "Adding to " + pluginName + " test classpath: " + artifactPath + " Scope: " + scope );
             }
-            classPath = new Classpath( files );
-            ClasspathCache.setCachedClasspath( provider, classPath );
         }
-        return classPath;
+
+        return result.getArtifacts();
     }
 
-    public Classpath addProviderToClasspath( Map<String, Artifact> pluginArtifactMap, Artifact surefireArtifact )
+    public Set<Artifact> addProviderToClasspath( Map<String, Artifact> pluginArtifactMap, Artifact surefireArtifact )
         throws ArtifactResolutionException, ArtifactNotFoundException
     {
-        List<String> files = new ArrayList<String>();
+        Set<Artifact> providerArtifacts = new LinkedHashSet<Artifact>();
         if ( surefireArtifact != null )
         {
-            final ArtifactResolutionResult artifactResolutionResult = resolveArtifact( null, surefireArtifact );
+            ArtifactResolutionResult artifactResolutionResult = resolveArtifact( null, surefireArtifact );
             for ( Artifact artifact : pluginArtifactMap.values() )
             {
                 if ( !artifactResolutionResult.getArtifacts().contains( artifact ) )
                 {
-                    files.add( artifact.getFile().getAbsolutePath() );
+                    providerArtifacts.add( artifact );
                 }
             }
         }
         else
         {
             // Bit of a brute force strategy if not found. Should probably be improved
-            for ( Artifact artifact : pluginArtifactMap.values() )
-            {
-                files.add( artifact.getFile().getPath() );
-            }
+            providerArtifacts.addAll( pluginArtifactMap.values() );
         }
-        return new Classpath( files );
+        return providerArtifacts;
     }
-
 }
diff --git a/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/TestClassPath.java b/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/TestClassPath.java
new file mode 100644
index 0000000..bad0b31
--- /dev/null
+++ b/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/TestClassPath.java
@@ -0,0 +1,115 @@
+package org.apache.maven.plugin.surefire;
+
+/*
+ * 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 org.apache.maven.artifact.Artifact;
+import org.apache.maven.surefire.booter.Classpath;
+import org.codehaus.plexus.logging.Logger;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import static java.util.Collections.addAll;
+import static org.apache.maven.shared.utils.StringUtils.split;
+
+final class TestClassPath
+{
+    private final Iterable<Artifact> artifacts;
+    private final File classesDirectory;
+    private final File testClassesDirectory;
+    private final String[] additionalClasspathElements;
+    private final Logger logger;
+
+    TestClassPath( Iterable<Artifact> artifacts,
+                   File classesDirectory,
+                   File testClassesDirectory,
+                   String[] additionalClasspathElements,
+                   Logger logger )
+    {
+        this.artifacts = artifacts;
+        this.classesDirectory = classesDirectory;
+        this.testClassesDirectory = testClassesDirectory;
+        this.additionalClasspathElements = additionalClasspathElements;
+        this.logger = logger;
+    }
+
+    void avoidArtifactDuplicates( Set<Artifact> providerArtifacts )
+    {
+        for ( Artifact artifact : artifacts )
+        {
+            Iterator<Artifact> it = providerArtifacts.iterator();
+            while ( it.hasNext() )
+            {
+                Artifact providerArtifact = it.next();
+                String classifier1 = providerArtifact.getClassifier();
+                String classifier2 = artifact.getClassifier();
+                if ( providerArtifact.getGroupId().equals( artifact.getGroupId() )
+                        && providerArtifact.getArtifactId().equals( artifact.getArtifactId() )
+                        && providerArtifact.getType().equals( artifact.getType() )
+                        && ( classifier1 == null ? classifier2 == null : classifier1.equals( classifier2 ) ) )
+                {
+                    it.remove();
+                    if ( logger.isDebugEnabled() )
+                    {
+                        logger.debug( "Removed artifact " + providerArtifact + " from provider. "
+                                + "Already appears in test classpath." );
+                    }
+                }
+            }
+        }
+    }
+
+    Classpath toClasspath()
+    {
+        List<String> classpath = new ArrayList<String>();
+        classpath.add( testClassesDirectory.getAbsolutePath() );
+        classpath.add( classesDirectory.getAbsolutePath() );
+        for ( Artifact artifact : artifacts )
+        {
+            if ( artifact.getArtifactHandler().isAddedToClasspath() )
+            {
+                File file = artifact.getFile();
+                if ( file != null )
+                {
+                    classpath.add( file.getAbsolutePath() );
+                }
+            }
+        }
+        if ( additionalClasspathElements != null )
+        {
+            for ( String additionalClasspathElement : additionalClasspathElements )
+            {
+                if ( additionalClasspathElement != null )
+                {
+                    addAll( classpath, split( additionalClasspathElement, "," ) );
+                }
+            }
+        }
+        // todo: why t use it in general, and surefire-grouper
+        /*if ( getTestNgArtifact() != null )
+        {
+            addTestNgUtilsArtifacts( classpath );
+        }*/
+        return new Classpath( classpath );
+    }
+}
diff --git a/maven-surefire-common/src/test/java/org/apache/maven/plugin/surefire/AbstractSurefireMojoJava7PlusTest.java b/maven-surefire-common/src/test/java/org/apache/maven/plugin/surefire/AbstractSurefireMojoJava7PlusTest.java
index 8310fe3..96a2a5c 100644
--- a/maven-surefire-common/src/test/java/org/apache/maven/plugin/surefire/AbstractSurefireMojoJava7PlusTest.java
+++ b/maven-surefire-common/src/test/java/org/apache/maven/plugin/surefire/AbstractSurefireMojoJava7PlusTest.java
@@ -20,6 +20,9 @@ package org.apache.maven.plugin.surefire;
  */
 
 import org.apache.maven.artifact.Artifact;
+import org.apache.maven.artifact.DefaultArtifact;
+import org.apache.maven.artifact.handler.ArtifactHandler;
+import org.apache.maven.artifact.versioning.VersionRange;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugin.surefire.log.PluginConsoleLogger;
@@ -32,6 +35,7 @@ import org.apache.maven.surefire.util.DefaultScanResult;
 import org.codehaus.plexus.languages.java.jpms.LocationManager;
 import org.codehaus.plexus.languages.java.jpms.ResolvePathsRequest;
 import org.codehaus.plexus.languages.java.jpms.ResolvePathsResult;
+import org.codehaus.plexus.languages.java.jpms.ResolvePathsResult.ModuleNameSource;
 import org.codehaus.plexus.logging.Logger;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -47,12 +51,13 @@ import java.nio.file.Path;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
-import static java.io.File.separatorChar;
 import static java.util.Arrays.asList;
 import static java.util.Collections.singleton;
 import static org.apache.commons.lang3.JavaVersion.JAVA_1_7;
 import static org.apache.commons.lang3.JavaVersion.JAVA_RECENT;
+import static org.apache.maven.artifact.versioning.VersionRange.createFromVersion;
 import static org.apache.maven.surefire.booter.SystemUtils.isBuiltInJava7AtLeast;
 import static org.fest.assertions.Assertions.assertThat;
 import static org.junit.Assume.assumeTrue;
@@ -78,6 +83,9 @@ import static org.powermock.reflect.Whitebox.invokeMethod;
 public class AbstractSurefireMojoJava7PlusTest
 {
     @Mock
+    private ArtifactHandler handler;
+
+    @Mock
     private LocationManager locationManager;
 
     @BeforeClass
@@ -94,36 +102,62 @@ public class AbstractSurefireMojoJava7PlusTest
         doReturn( locationManager )
                 .when( mojo, "getLocationManager" );
 
-        Classpath testClasspath = new Classpath( asList( "non-modular.jar", "modular.jar",
-                "target" + separatorChar + "classes", "junit.jar", "hamcrest.jar" ) );
+        when( handler.isAddedToClasspath() ).thenReturn( true );
+
+        VersionRange v1 = createFromVersion( "1" );
+        Artifact modular = new DefaultArtifact( "x", "modular", v1, "compile", "jar", "", handler );
+        modular.setFile( mockFile( "modular.jar" ) );
+
+        VersionRange v2 = createFromVersion( "1" );
+        Artifact nonModular = new DefaultArtifact( "x", "non-modular", v2, "test", "jar", "", handler );
+        nonModular.setFile( mockFile( "non-modular.jar" ) );
+
+        VersionRange v3 = createFromVersion( "4.12" );
+        Artifact junit = new DefaultArtifact( "junit", "junit", v3, "test", "jar", "", handler );
+        junit.setFile( mockFile( "junit.jar" ) );
+
+        VersionRange v4 = createFromVersion( "1.3.0" );
+        Artifact hamcrest = new DefaultArtifact( "org.hamcrest", "hamcrest-core", v4, "test", "jar", "", handler );
+        hamcrest.setFile( mockFile( "hamcrest.jar" ) );
+
+        File classesDir = mockFile( "classes" );
+        File testClassesDir = mockFile( "test-classes" );
+
+        TestClassPath testClasspath =
+                new TestClassPath( asList( modular, nonModular, junit, hamcrest ), classesDir, testClassesDir,
+                        null, null );
 
         doReturn( testClasspath ).when( mojo, "generateTestClasspath" );
         doReturn( 1 ).when( mojo, "getEffectiveForkCount" );
         doReturn( true ).when( mojo, "effectiveIsEnableAssertions" );
         when( mojo.isChildDelegation() ).thenReturn( false );
-        when( mojo.getTestClassesDirectory() ).thenReturn( new File( "target" + separatorChar + "test-classes" ) );
+        when( mojo.getTestClassesDirectory() ).thenReturn( testClassesDir );
 
         DefaultScanResult scanResult = mock( DefaultScanResult.class );
         when( scanResult.getClasses() ).thenReturn( asList( "org.apache.A", "org.apache.B" ) );
 
         ClassLoaderConfiguration classLoaderConfiguration = new ClassLoaderConfiguration( false, true );
 
-        Classpath providerClasspath = new Classpath( singleton( "surefire-provider.jar" ) );
+        VersionRange v5 = createFromVersion( "1" );
+        Artifact provider = new DefaultArtifact( "org.apache.maven.surefire", "surefire-provider", v5, "runtime",
+                "jar", "", handler );
+        provider.setFile( mockFile( "surefire-provider.jar" ) );
+        Set<Artifact> providerClasspath = singleton( provider );
 
-        File moduleInfo = new File( "target" + separatorChar + "classes" + separatorChar + "module-info.class" );
+        File moduleInfo = mockFile( "classes/module-info.class" );
 
         @SuppressWarnings( "unchecked" )
         ResolvePathsRequest<String> req = mock( ResolvePathsRequest.class );
         mockStatic( ResolvePathsRequest.class );
-        when( ResolvePathsRequest.withStrings( eq( testClasspath.getClassPath() ) ) ).thenReturn( req );
+        when( ResolvePathsRequest.ofStrings( eq( testClasspath.toClasspath().getClassPath() ) ) ).thenReturn( req );
         when( req.setMainModuleDescriptor( eq( moduleInfo.getAbsolutePath() ) ) ).thenReturn( req );
 
         @SuppressWarnings( "unchecked" )
         ResolvePathsResult<String> res = mock( ResolvePathsResult.class );
         when( res.getClasspathElements() ).thenReturn( asList( "non-modular.jar", "junit.jar", "hamcrest.jar" ) );
-        Map<String, ResolvePathsResult.ModuleNameSource> mod = new LinkedHashMap<String, ResolvePathsResult.ModuleNameSource>();
+        Map<String, ModuleNameSource> mod = new LinkedHashMap<String, ModuleNameSource>();
         mod.put( "modular.jar", null );
-        mod.put( "target" + separatorChar + "classes", null );
+        mod.put( "classes", null );
         when( res.getModulepathElements() ).thenReturn( mod );
         when( locationManager.resolvePaths( eq( req ) ) ).thenReturn( res );
 
@@ -132,7 +166,7 @@ public class AbstractSurefireMojoJava7PlusTest
         doNothing().when( logger ).debug( anyString() );
         when( mojo.getConsoleLogger() ).thenReturn( new PluginConsoleLogger( logger ) );
 
-        StartupConfiguration conf = invokeMethod( mojo, "newStartupConfigForModularClasspath",
+        StartupConfiguration conf = invokeMethod( mojo, "newStartupConfigWithModularPath",
                 classLoaderConfiguration, providerClasspath, "org.asf.Provider", moduleInfo, scanResult );
 
         verify( mojo, times( 1 ) ).effectiveIsEnableAssertions();
@@ -142,7 +176,7 @@ public class AbstractSurefireMojoJava7PlusTest
         verify( mojo, times( 1 ) ).getTestClassesDirectory();
         verify( scanResult, times( 1 ) ).getClasses();
         verifyStatic( ResolvePathsRequest.class, times( 1 ) );
-        ResolvePathsRequest.withStrings( eq( testClasspath.getClassPath() ) );
+        ResolvePathsRequest.ofStrings( eq( testClasspath.toClasspath().getClassPath() ) );
         verify( req, times( 1 ) ).setMainModuleDescriptor( eq( moduleInfo.getAbsolutePath() ) );
         verify( res, times( 1 ) ).getClasspathElements();
         verify( res, times( 1 ) ).getModulepathElements();
@@ -151,7 +185,7 @@ public class AbstractSurefireMojoJava7PlusTest
         verify( logger, times( 6 ) ).debug( argument.capture() );
         assertThat( argument.getAllValues() )
                 .containsExactly( "test classpath:  non-modular.jar  junit.jar  hamcrest.jar",
-                        "test modulepath:  modular.jar  target" + separatorChar + "classes",
+                        "test modulepath:  modular.jar  classes",
                         "provider classpath:  surefire-provider.jar",
                         "test(compact) classpath:  non-modular.jar  junit.jar  hamcrest.jar",
                         "test(compact) modulepath:  modular.jar  classes",
@@ -168,15 +202,16 @@ public class AbstractSurefireMojoJava7PlusTest
         assertThat( conf.getClasspathConfiguration() ).isNotNull();
         assertThat( ( Object ) conf.getClasspathConfiguration().getTestClasspath() )
                 .isEqualTo( new Classpath( res.getClasspathElements() ) );
-        assertThat( ( Object ) conf.getClasspathConfiguration().getProviderClasspath() ).isSameAs( providerClasspath );
+        assertThat( ( Object ) conf.getClasspathConfiguration().getProviderClasspath() )
+                .isEqualTo( new Classpath( singleton( "surefire-provider.jar" ) ) );
         assertThat( conf.getClasspathConfiguration() ).isInstanceOf( ModularClasspathConfiguration.class );
         ModularClasspathConfiguration mcc = ( ModularClasspathConfiguration ) conf.getClasspathConfiguration();
         assertThat( mcc.getModularClasspath().getModuleDescriptor() ).isEqualTo( moduleInfo );
         assertThat( mcc.getModularClasspath().getPackages() ).containsOnly( "org.apache" );
-        assertThat( mcc.getModularClasspath().getPatchFile() )
-                .isEqualTo( new File( "target" + separatorChar + "test-classes" ) );
+        assertThat( mcc.getModularClasspath().getPatchFile().getAbsolutePath() )
+                .isEqualTo( "test-classes" );
         assertThat( mcc.getModularClasspath().getModulePath() )
-                .containsExactly( "modular.jar", "target" + separatorChar + "classes" );
+                .containsExactly( "modular.jar", "classes" );
         assertThat( ( Object ) mcc.getTestClasspath() ).isEqualTo( new Classpath( res.getClasspathElements() ) );
     }
 
@@ -222,6 +257,13 @@ public class AbstractSurefireMojoJava7PlusTest
                 .isTrue();
     }
 
+    private static File mockFile( String absolutePath )
+    {
+        File f = mock( File.class );
+        when( f.getAbsolutePath() ).thenReturn( absolutePath );
+        return f;
+    }
+
     public static class Mojo
             extends AbstractSurefireMojo
     {
diff --git a/maven-surefire-common/src/test/java/org/apache/maven/plugin/surefire/AbstractSurefireMojoTest.java b/maven-surefire-common/src/test/java/org/apache/maven/plugin/surefire/AbstractSurefireMojoTest.java
index 481d91e..04528ab 100644
--- a/maven-surefire-common/src/test/java/org/apache/maven/plugin/surefire/AbstractSurefireMojoTest.java
+++ b/maven-surefire-common/src/test/java/org/apache/maven/plugin/surefire/AbstractSurefireMojoTest.java
@@ -20,7 +20,9 @@ package org.apache.maven.plugin.surefire;
  */
 
 import org.apache.maven.artifact.Artifact;
+import org.apache.maven.artifact.DefaultArtifact;
 import org.apache.maven.artifact.handler.ArtifactHandler;
+import org.apache.maven.artifact.versioning.VersionRange;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugin.surefire.log.PluginConsoleLogger;
@@ -33,23 +35,28 @@ import org.codehaus.plexus.logging.Logger;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
 import org.powermock.core.classloader.annotations.PrepareForTest;
 import org.powermock.modules.junit4.PowerMockRunner;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import static java.io.File.separatorChar;
 import static java.util.Arrays.asList;
 import static java.util.Collections.singleton;
 import static org.apache.commons.lang3.SystemUtils.IS_OS_WINDOWS;
+import static org.apache.maven.artifact.versioning.VersionRange.createFromVersion;
 import static org.fest.assertions.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.when;
 import static org.mockito.Mockito.verify;
@@ -67,6 +74,9 @@ import static org.powermock.reflect.Whitebox.invokeMethod;
 @PrepareForTest( AbstractSurefireMojo.class )
 public class AbstractSurefireMojoTest
 {
+    @Mock
+    private ArtifactHandler handler;
+
     private final Mojo mojo = new Mojo();
 
     @Test
@@ -121,21 +131,19 @@ public class AbstractSurefireMojoTest
         when( project.getArtifacts() ).thenReturn( artifacts );
         when( mojo.getProject() ).thenReturn( project );
 
-        Classpath cp = invokeMethod( mojo, "generateTestClasspath" );
+        TestClassPath cp = invokeMethod( mojo, "generateTestClasspath" );
 
         verifyPrivate( mojo, times( 1 ) ).invoke( "generateTestClasspath" );
         verify( mojo, times( 1 ) ).getClassesDirectory();
         verify( mojo, times( 1 ) ).getTestClassesDirectory();
         verify( mojo, times( 3 ) ).getClasspathDependencyScopeExclude();
         verify( mojo, times( 2 ) ).getClasspathDependencyExcludes();
-        verify( artifactHandler, times( 1 ) ).isAddedToClasspath();
-        verifyPrivate( mojo, times( 1 ) ).invoke( "getTestNgArtifact" );
-        verifyPrivate( mojo, times( 1 ) ).invoke( "addTestNgUtilsArtifacts", eq( cp.getClassPath() ) );
-
-        assertThat( cp.getClassPath() ).hasSize( 3 );
-        assertThat( cp.getClassPath().get( 0 ) ).endsWith( "test-classes" );
-        assertThat( cp.getClassPath().get( 1 ) ).endsWith( "classes" );
-        assertThat( cp.getClassPath().get( 2 ) ).endsWith( "a2-2.jar" );
+        verify( mojo, times( 1 ) ).getAdditionalClasspathElements();
+
+        assertThat( cp.toClasspath().getClassPath() ).hasSize( 3 );
+        assertThat( cp.toClasspath().getClassPath().get( 0 ) ).endsWith( "test-classes" );
+        assertThat( cp.toClasspath().getClassPath().get( 1 ) ).endsWith( "classes" );
+        assertThat( cp.toClasspath().getClassPath().get( 2 ) ).endsWith( "a2-2.jar" );
     }
 
     @Test
@@ -143,7 +151,37 @@ public class AbstractSurefireMojoTest
             throws Exception
     {
         AbstractSurefireMojo mojo = spy( this.mojo );
-        Classpath testClasspath = new Classpath( asList( "junit.jar", "hamcrest.jar" ) );
+
+        Artifact common = new DefaultArtifact( "org.apache.maven.surefire", "maven-surefire-common",
+                createFromVersion( "1" ), "runtime", "jar", "", handler );
+        common.setFile( mockFile( "maven-surefire-common.jar" ) );
+
+
+        Artifact api = new DefaultArtifact( "org.apache.maven.surefire", "surefire-api",
+                createFromVersion( "1" ), "runtime", "jar", "", handler );
+        api.setFile( mockFile( "surefire-api.jar" ) );
+
+        Map<String, Artifact> providerArtifactsMap = new HashMap<String, Artifact>();
+        providerArtifactsMap.put( "org.apache.maven.surefire:maven-surefire-common", common );
+        providerArtifactsMap.put( "org.apache.maven.surefire:surefire-api", api );
+
+        when( mojo.getPluginArtifactMap() )
+                .thenReturn( providerArtifactsMap );
+
+        when( handler.isAddedToClasspath() ).thenReturn( true );
+
+        VersionRange v1 = createFromVersion( "4.12" );
+        Artifact junit = new DefaultArtifact( "junit", "junit", v1, "test", "jar", "", handler );
+        junit.setFile( mockFile( "junit.jar" ) );
+
+        VersionRange v2 = createFromVersion( "1.3.0" );
+        Artifact hamcrest = new DefaultArtifact( "org.hamcrest", "hamcrest-core", v2, "test", "jar", "", handler );
+        hamcrest.setFile( mockFile( "hamcrest.jar" ) );
+
+        File classesDir = mockFile( "classes" );
+        File testClassesDir = mockFile( "test-classes" );
+        TestClassPath testClasspath =
+                new TestClassPath( asList( junit, hamcrest ), classesDir, testClassesDir, null, null );
 
         doReturn( testClasspath ).when( mojo, "generateTestClasspath" );
         doReturn( 1 ).when( mojo, "getEffectiveForkCount" );
@@ -152,18 +190,18 @@ public class AbstractSurefireMojoTest
 
         ClassLoaderConfiguration classLoaderConfiguration = new ClassLoaderConfiguration( false, true );
 
-        Classpath providerClasspath = new Classpath( singleton( "surefire-provider.jar" ) );
-
-        Classpath inprocClasspath =
-                new Classpath( asList( "surefire-api.jar", "surefire-common.jar", "surefire-provider.jar" ) );
+        VersionRange v3 = createFromVersion( "1" );
+        Artifact provider = new DefaultArtifact( "x", "surefire-provider", v3, "runtime", "jar", "", handler );
+        provider.setFile( mockFile( "surefire-provider.jar" ) );
+        Set<Artifact> providerArtifacts = singleton( provider );
 
         Logger logger = mock( Logger.class );
         when( logger.isDebugEnabled() ).thenReturn( true );
         doNothing().when( logger ).debug( anyString() );
         when( mojo.getConsoleLogger() ).thenReturn( new PluginConsoleLogger( logger ) );
 
-        StartupConfiguration conf = invokeMethod( mojo, "newStartupConfigForNonModularClasspath",
-                classLoaderConfiguration, providerClasspath, inprocClasspath, "org.asf.Provider" );
+        StartupConfiguration conf = invokeMethod( mojo, "newStartupConfigWithClasspath",
+                classLoaderConfiguration, providerArtifacts, "org.asf.Provider" );
 
         verify( mojo, times( 1 ) ).effectiveIsEnableAssertions();
         verify( mojo, times( 1 ) ).isChildDelegation();
@@ -173,9 +211,9 @@ public class AbstractSurefireMojoTest
         ArgumentCaptor<String> argument = ArgumentCaptor.forClass( String.class );
         verify( logger, times( 4 ) ).debug( argument.capture() );
         assertThat( argument.getAllValues() )
-                .containsExactly( "test classpath:  junit.jar  hamcrest.jar",
+                .containsExactly( "test classpath:  test-classes  classes  junit.jar  hamcrest.jar",
                         "provider classpath:  surefire-provider.jar",
-                        "test(compact) classpath:  junit.jar  hamcrest.jar",
+                        "test(compact) classpath:  test-classes  classes  junit.jar  hamcrest.jar",
                         "provider(compact) classpath:  surefire-provider.jar"
                 );
 
@@ -183,10 +221,15 @@ public class AbstractSurefireMojoTest
                 .isSameAs( classLoaderConfiguration );
 
         assertThat( ( Object ) conf.getClasspathConfiguration().getTestClasspath() )
-                .isSameAs( testClasspath );
+                .isEqualTo( testClasspath.toClasspath() );
 
+        Collection<String> files = new ArrayList<String>();
+        for ( Artifact providerArtifact : providerArtifacts )
+        {
+            files.add( providerArtifact.getFile().getAbsolutePath() );
+        }
         assertThat( ( Object ) conf.getClasspathConfiguration().getProviderClasspath() )
-                .isSameAs( providerClasspath );
+                .isEqualTo( new Classpath( files ) );
 
         assertThat( ( Object ) conf.getClasspathConfiguration().isClassPathConfig() )
                 .isEqualTo( true );
@@ -602,4 +645,11 @@ public class AbstractSurefireMojoTest
             return null;
         }
     }
+
+    private static File mockFile( String absolutePath )
+    {
+        File f = mock( File.class );
+        when( f.getAbsolutePath() ).thenReturn( absolutePath );
+        return f;
+    }
 }
diff --git a/surefire-its/src/test/java/org/apache/maven/surefire/its/JUnitPlatformEnginesIT.java b/surefire-its/src/test/java/org/apache/maven/surefire/its/JUnitPlatformEnginesIT.java
new file mode 100644
index 0000000..42a2b63
--- /dev/null
+++ b/surefire-its/src/test/java/org/apache/maven/surefire/its/JUnitPlatformEnginesIT.java
@@ -0,0 +1,160 @@
+package org.apache.maven.surefire.its;
+
+/*
+ * 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 org.apache.maven.it.VerificationException;
+import org.apache.maven.surefire.its.fixture.OutputValidator;
+import org.apache.maven.surefire.its.fixture.SurefireJUnit4IntegrationTestCase;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.apache.maven.surefire.its.fixture.HelperAssertions.assumeJavaVersion;
+import static org.apache.maven.surefire.its.fixture.IsRegex.regex;
+import static org.fest.assertions.Assertions.assertThat;
+import static org.fest.util.Collections.set;
+import static org.hamcrest.CoreMatchers.startsWith;
+import static org.junit.Assert.assertThat;
+
+@RunWith( Parameterized.class )
+public class JUnitPlatformEnginesIT
+        extends SurefireJUnit4IntegrationTestCase
+{
+    @Parameter
+    public String platform;
+
+    @Parameter( 1 )
+    public String jupiter;
+
+    @Parameter( 2 )
+    public String opentest;
+
+    @Parameter( 3 )
+    public String apiguardian;
+
+    @Parameters(name = "{0}")
+    public static Iterable<Object[]> regexVersions()
+    {
+        ArrayList<Object[]> args = new ArrayList<Object[]>();
+        args.add( new Object[] { "1.0.0", "5.0.0", "1.0.0", "1.0.0" } );
+        args.add( new Object[] { "1.1.1", "5.1.1", "1.0.0", "1.0.0" } );
+        args.add( new Object[] { "1.2.0", "5.2.0", "1.1.0", "1.0.0" } );
+        args.add( new Object[] { "1.3.1", "5.3.1", "1.1.1", "1.0.0" } );
+        args.add( new Object[] { "1.4.0-SNAPSHOT", "5.4.0-SNAPSHOT", "1.1.1", "1.0.0" } );
+        return args;
+    }
+
+    @Before
+    public void setUp()
+    {
+        assumeJavaVersion( 1.8d );
+    }
+
+    @Test
+    public void testToRegex()
+    {
+        String regex = toRegex( ".[]()*" );
+        assertThat( regex )
+                .isEqualTo( "\\.\\[\\]\\(\\).*" );
+    }
+
+    @Test
+    public void platform() throws VerificationException
+    {
+        OutputValidator validator = unpack( "junit-platform", '-' + platform )
+                .sysProp( "jupiter.version", jupiter )
+                .addGoal( "-X" )
+                .executeTest()
+                .verifyErrorFree( 1 );
+
+        String testClasspath = "[DEBUG] test(compact) classpath:"
+                + "  test-classes"
+                + "  classes"
+                + "  junit-jupiter-engine-" + jupiter + ".jar"
+                + "  apiguardian-api-" + apiguardian + ".jar"
+                + "  junit-platform-engine-" + platform + ".jar"
+                + "  junit-platform-commons-" + platform + ".jar"
+                + "  opentest4j-" + opentest + ".jar"
+                + "  junit-jupiter-api-" + jupiter + ".jar";
+
+        List<String> lines = validator.loadLogLines( startsWith( "[DEBUG] test(compact) classpath" ) );
+
+        assertThat( lines )
+                .hasSize( 1 );
+
+        String line = lines.get( 0 );
+
+        assertThat( set( line ), regex( toRegex( testClasspath ) ) );
+
+        String providerClasspath = "[DEBUG] provider(compact) classpath:"
+                + "  surefire-junit-platform-*.jar"
+                + "  junit-platform-launcher-1.3.1.jar"
+                + "  surefire-api-*.jar"
+                + "  surefire-logger-api-*.jar";
+
+        lines = validator.loadLogLines( startsWith( "[DEBUG] provider(compact) classpath" ) );
+
+        assertThat( lines )
+                .hasSize( 1 );
+
+        line = lines.get( 0 );
+
+        assertThat( set( line ), regex( toRegex( providerClasspath ) ) );
+
+        String bootClasspath = "[DEBUG] boot(compact) classpath:"
+                + "  surefire-booter-*.jar"
+                + "  surefire-api-*.jar"
+                + "  surefire-logger-api-*.jar"
+                + "  test-classes"
+                + "  classes"
+                + "  junit-jupiter-engine-" + jupiter + ".jar"
+                + "  apiguardian-api-" + apiguardian + ".jar"
+                + "  junit-platform-engine-" + platform + ".jar"
+                + "  junit-platform-commons-" + platform + ".jar"
+                + "  opentest4j-" + opentest + ".jar"
+                + "  junit-jupiter-api-" + jupiter + ".jar"
+                + "  surefire-junit-platform-*.jar"
+                + "  junit-platform-launcher-1.3.1.jar";
+
+        lines = validator.loadLogLines( startsWith( "[DEBUG] boot(compact) classpath" ) );
+
+        assertThat( lines )
+                .hasSize( 1 );
+
+        line = lines.get( 0 );
+
+        assertThat( set( line ), regex( toRegex( bootClasspath ) ) );
+    }
+
+    private static String toRegex(String text) {
+        return text.replaceAll( "\\.", "\\\\." )
+                .replaceAll( "\\[", "\\\\[" )
+                .replaceAll( "]", "\\\\]" )
+                .replaceAll( "\\(", "\\\\(" )
+                .replaceAll( "\\)", "\\\\)" )
+                .replaceAll( "\\*", ".*" );
+    }
+}
diff --git a/surefire-its/src/test/java/org/apache/maven/surefire/its/JUnitPlatformIT.java b/surefire-its/src/test/java/org/apache/maven/surefire/its/JUnitPlatformIT.java
index e1b808f..6c8d29d 100644
--- a/surefire-its/src/test/java/org/apache/maven/surefire/its/JUnitPlatformIT.java
+++ b/surefire-its/src/test/java/org/apache/maven/surefire/its/JUnitPlatformIT.java
@@ -23,66 +23,54 @@ import org.apache.maven.surefire.its.fixture.SurefireJUnit4IntegrationTestCase;
 import org.junit.Before;
 import org.junit.Test;
 
-import static java.lang.System.getProperty;
-import static org.hamcrest.Matchers.greaterThanOrEqualTo;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assume.assumeThat;
+import static org.apache.maven.surefire.its.fixture.HelperAssertions.assumeJavaVersion;
 
 public class JUnitPlatformIT
-    extends SurefireJUnit4IntegrationTestCase
+        extends SurefireJUnit4IntegrationTestCase
 {
     @Before
     public void setUp()
     {
-        assumeThat( "java.specification.version: ",
-                    getProperty( "java.specification.version" ), is( greaterThanOrEqualTo( "1.8" ) ) );
+        assumeJavaVersion( 1.8d );
     }
 
     @Test
     public void testJupiterEngine()
     {
-        unpack( "/junit-platform-engine-jupiter" ).executeTest().verifyErrorFree( 5 );
+        unpack( "/junit-platform-engine-jupiter" )
+                .executeTest()
+                .verifyErrorFree( 5 );
     }
 
     @Test
     public void testVintageEngine()
     {
-        unpack( "/junit-platform-engine-vintage" ).executeTest().verifyErrorFree( 1 );
+        unpack( "/junit-platform-engine-vintage" )
+                .executeTest()
+                .verifyErrorFree( 1 );
     }
 
     @Test
     public void testJQwikEngine()
     {
-        unpack( "/junit-platform-engine-jqwik" ).executeTest().verifyErrorFree( 1 );
+        unpack( "/junit-platform-engine-jqwik" )
+                .executeTest()
+                .verifyErrorFree( 1 );
     }
 
     @Test
     public void testMultipleEngines()
     {
-        unpack( "/junit-platform-multiple-engines" ).executeTest().verifyErrorFree( 7 );
-    }
-
-    @Test
-    public void testJUnitPlatform_1_0_0()
-    {
-        unpack( "/junit-platform-1.0.0" ).executeTest().verifyErrorFree( 1 );
-    }
-
-    @Test
-    public void testJUnitPlatform_1_1_1()
-    {
-        unpack( "/junit-platform-1.1.1" ).executeTest().verifyErrorFree( 1 );
-    }
-
-    @Test
-    public void testJUnitPlatform_1_2_0()
-    {
-        unpack( "/junit-platform-1.2.0" ).executeTest().verifyErrorFree( 1 );
+        unpack( "/junit-platform-multiple-engines" )
+                .executeTest()
+                .verifyErrorFree( 7 );
     }
 
     @Test
     public void testTags()
     {
-        unpack( "/junit-platform-tags" ).executeTest().verifyErrorFree( 2 );
+        unpack( "/junit-platform-tags" )
+                .executeTest()
+                .verifyErrorFree( 2 );
     }
 }
diff --git a/surefire-its/src/test/java/org/apache/maven/surefire/its/fixture/IsRegex.java b/surefire-its/src/test/java/org/apache/maven/surefire/its/fixture/IsRegex.java
new file mode 100644
index 0000000..09e8d0d
--- /dev/null
+++ b/surefire-its/src/test/java/org/apache/maven/surefire/its/fixture/IsRegex.java
@@ -0,0 +1,100 @@
+package org.apache.maven.surefire.its.fixture;
+
+/*
+ * 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 org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Set;
+
+import static java.util.Collections.singleton;
+
+/**
+ * Java Hamcrest Matcher with Regex.
+ */
+public final class IsRegex
+        extends BaseMatcher<Set<String>>
+{
+    public static Matcher<Set<String>> regex( Set<String> expectedRegex )
+    {
+        return new IsRegex( expectedRegex );
+    }
+
+    public static Matcher<Set<String>> regex( String expectedRegex )
+    {
+        return new IsRegex( expectedRegex );
+    }
+
+    private final Set<String> expectedRegex;
+
+    private IsRegex( String expectedRegex )
+    {
+        this.expectedRegex = singleton( expectedRegex );
+    }
+
+    private IsRegex( Set<String> expectedRegex )
+    {
+        this.expectedRegex = expectedRegex;
+    }
+
+    @Override
+    public boolean matches( Object o )
+    {
+        if ( o != null
+                && expectedRegex.size() == 1 ? isStringOrSet( o ) : isSet( o ) )
+        {
+            //noinspection unchecked
+            Set<String> actual = isSet( o ) ? ( Set<String> ) o : singleton( ( String ) o );
+            boolean matches = actual.size() == expectedRegex.size();
+            Iterator<String> regex = expectedRegex.iterator();
+            for ( String s : actual )
+            {
+                if ( s == null || !regex.hasNext() || !s.matches( regex.next() ) )
+                {
+                    matches = false;
+                }
+            }
+            return matches;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    @Override
+    public void describeTo( Description description )
+    {
+        description.appendValue( expectedRegex );
+    }
+
+    private static boolean isStringOrSet( Object o )
+    {
+        return o instanceof String || o instanceof Set;
+    }
+
+    private static boolean isSet( Object o )
+    {
+        return o instanceof Set;
+    }
+}
diff --git a/surefire-its/src/test/java/org/apache/maven/surefire/its/fixture/OutputValidator.java b/surefire-its/src/test/java/org/apache/maven/surefire/its/fixture/OutputValidator.java
index 882ed9c..56046f1 100644
--- a/surefire-its/src/test/java/org/apache/maven/surefire/its/fixture/OutputValidator.java
+++ b/surefire-its/src/test/java/org/apache/maven/surefire/its/fixture/OutputValidator.java
@@ -22,7 +22,7 @@ package org.apache.maven.surefire.its.fixture;
 import java.io.File;
 import java.io.IOException;
 import java.nio.charset.Charset;
-import java.util.Collection;
+import java.util.ArrayList;
 import java.util.List;
 
 import org.apache.commons.io.FileUtils;
@@ -39,9 +39,9 @@ import static org.hamcrest.MatcherAssert.assertThat;
  */
 public class OutputValidator
 {
-    protected final Verifier verifier;
+    final Verifier verifier;
 
-    protected final File baseDir;
+    private final File baseDir;
 
     public OutputValidator( Verifier verifier )
     {
@@ -93,14 +93,7 @@ public class OutputValidator
     public OutputValidator assertThatLogLine( Matcher<String> line, Matcher<Integer> nTimes )
         throws VerificationException
     {
-        int counter = 0;
-        for ( String log : loadLogLines() )
-        {
-            if ( line.matches( log ) )
-            {
-                counter++;
-            }
-        }
+        int counter = loadLogLines( line ).size();
         assertThat( "log pattern does not match nTimes", counter, nTimes );
         return this;
     }
@@ -111,6 +104,20 @@ public class OutputValidator
         return verifier.loadFile( verifier.getBasedir(), verifier.getLogFileName(), false );
     }
 
+    public List<String> loadLogLines( Matcher<String> line )
+            throws VerificationException
+    {
+        List<String> matchedLines = new ArrayList<String>();
+        for ( String log : loadLogLines() )
+        {
+            if ( line.matches( log ) )
+            {
+                matchedLines.add( log );
+            }
+        }
+        return matchedLines;
+    }
+
     public List<String> loadFile( File file, Charset charset )
     {
         //noinspection unchecked
diff --git a/surefire-its/src/test/java/org/apache/maven/surefire/its/jiras/Surefire1082ParallelJUnitParameterizedIT.java b/surefire-its/src/test/java/org/apache/maven/surefire/its/jiras/Surefire1082ParallelJUnitParameterizedIT.java
index 2669b2f..2209061 100644
--- a/surefire-its/src/test/java/org/apache/maven/surefire/its/jiras/Surefire1082ParallelJUnitParameterizedIT.java
+++ b/surefire-its/src/test/java/org/apache/maven/surefire/its/jiras/Surefire1082ParallelJUnitParameterizedIT.java
@@ -24,17 +24,15 @@ import org.apache.maven.surefire.its.fixture.OutputValidator;
 import org.apache.maven.surefire.its.fixture.SurefireJUnit4IntegrationTestCase;
 import org.apache.maven.surefire.its.fixture.SurefireLauncher;
 import org.apache.maven.surefire.its.fixture.TestFile;
-import org.hamcrest.BaseMatcher;
-import org.hamcrest.Description;
-import org.hamcrest.Matcher;
 import org.junit.Test;
 
 import java.nio.charset.Charset;
 import java.util.Collection;
-import java.util.Iterator;
 import java.util.Set;
 import java.util.TreeSet;
 
+import static org.apache.maven.surefire.its.fixture.IsRegex.regex;
+import static org.hamcrest.CoreMatchers.startsWith;
 import static org.hamcrest.core.AnyOf.anyOf;
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.core.StringContains.containsString;
@@ -48,14 +46,7 @@ import static org.junit.Assert.assertThat;
 public class Surefire1082ParallelJUnitParameterizedIT
     extends SurefireJUnit4IntegrationTestCase
 {
-    private static Set<String> printOnlyTestLinesFromConsole( OutputValidator validator )
-            throws VerificationException
-    {
-        return printOnlyTestLines( validator.loadLogLines() );
-    }
-
     private static Set<String> printOnlyTestLinesFromOutFile( OutputValidator validator )
-            throws VerificationException
     {
         TestFile report = validator.getSurefireReportsFile( "jiras.surefire1082.Jira1082Test-output.txt" );
         report.assertFileExists();
@@ -63,7 +54,6 @@ public class Surefire1082ParallelJUnitParameterizedIT
     }
 
     private static Set<String> printOnlyTestLines( Collection<String> logs )
-        throws VerificationException
     {
         Set<String> log = new TreeSet<String>();
         for ( String line : logs )
@@ -76,11 +66,6 @@ public class Surefire1082ParallelJUnitParameterizedIT
         return log;
     }
 
-    private static Matcher<Set<String>> regex( Set<String> r )
-    {
-        return new IsRegex( r );
-    }
-
     private static void assertParallelRun( Set<String> log )
     {
         assertThat( log.size(), is( 4 ) );
@@ -115,7 +100,7 @@ public class Surefire1082ParallelJUnitParameterizedIT
 
         validator.assertThatLogLine( containsString( "Running jiras.surefire1082.Jira1082Test" ), is( 1 ) );
 
-        Set<String> log = printOnlyTestLinesFromConsole( validator );
+        Set<String> log = new TreeSet<String>( validator.loadLogLines( startsWith( "class jiras.surefire1082." ) ) );
         assertParallelRun( log );
     }
 
@@ -169,44 +154,4 @@ public class Surefire1082ParallelJUnitParameterizedIT
     {
         return unpack( "surefire-1082-parallel-junit-parameterized" );
     }
-
-    private static class IsRegex
-        extends BaseMatcher<Set<String>>
-    {
-        private final Set<String> expectedRegex;
-
-        IsRegex( Set<String> expectedRegex )
-        {
-            this.expectedRegex = expectedRegex;
-        }
-
-        @Override
-        public boolean matches( Object o )
-        {
-            if ( o != null && o instanceof Set )
-            {
-                Set<String> actual = (Set<String>) o;
-                boolean matches = actual.size() == expectedRegex.size();
-                Iterator<String> regex = expectedRegex.iterator();
-                for ( String s : actual )
-                {
-                    if ( s == null || !regex.hasNext() || !s.matches( regex.next() ) )
-                    {
-                        matches = false;
-                    }
-                }
-                return matches;
-            }
-            else
-            {
-                return false;
-            }
-        }
-
-        @Override
-        public void describeTo( Description description )
-        {
-            description.appendValue( expectedRegex );
-        }
-    }
 }
diff --git a/surefire-its/src/test/resources/junit-platform-1.1.1/pom.xml b/surefire-its/src/test/resources/junit-platform-1.1.1/pom.xml
deleted file mode 100644
index 2555d8b..0000000
--- a/surefire-its/src/test/resources/junit-platform-1.1.1/pom.xml
+++ /dev/null
@@ -1,60 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ 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.
-  -->
-
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <groupId>org.apache.maven.plugins.surefire</groupId>
-    <artifactId>junit-platform-1.1.1</artifactId>
-    <version>1.0</version>
-    <name>Test for JUnit 5: Platform 1.1.1 + Jupiter 5.1.1</name>
-
-    <properties>
-        <maven.compiler.source>1.8</maven.compiler.source>
-        <maven.compiler.target>1.8</maven.compiler.target>
-    </properties>
-
-    <!--
-        Declare "junit-jupiter-engine" dependency because the
-        Jupiter Engine is needed at test runtime. Artifacts
-        needed for test compilation, like "junit-jupiter-api",
-        are pulled-in via transitive dependency resolution.
-    -->
-    <dependencies>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
-            <version>5.1.1</version>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-surefire-plugin</artifactId>
-                <version>${surefire.version}</version>
-            </plugin>
-        </plugins>
-    </build>
-</project>
diff --git a/surefire-its/src/test/resources/junit-platform-1.1.1/src/test/java/junitplatform_1_1_1/JUnitPlatform_1_1_1_Test.java b/surefire-its/src/test/resources/junit-platform-1.1.1/src/test/java/junitplatform_1_1_1/JUnitPlatform_1_1_1_Test.java
deleted file mode 100644
index e1bc05e..0000000
--- a/surefire-its/src/test/resources/junit-platform-1.1.1/src/test/java/junitplatform_1_1_1/JUnitPlatform_1_1_1_Test.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package junitplatform_1_1_1;
-
-/*
- * 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 org.junit.jupiter.api.Assertions.assertEquals;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.TestInfo;
-
-class JUnitPlatform_1_1_1_Test
-{
-
-    @Test
-    void test(TestInfo info)
-    {
-        assertEquals( "test(TestInfo)", info.getDisplayName(), "display name mismatch" );
-    }
-
-
-}
diff --git a/surefire-its/src/test/resources/junit-platform-1.2.0/pom.xml b/surefire-its/src/test/resources/junit-platform-1.2.0/pom.xml
deleted file mode 100644
index 8bc5638..0000000
--- a/surefire-its/src/test/resources/junit-platform-1.2.0/pom.xml
+++ /dev/null
@@ -1,60 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ 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.
-  -->
-
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <groupId>org.apache.maven.plugins.surefire</groupId>
-    <artifactId>junit-platform-1.2.0</artifactId>
-    <version>1.0</version>
-    <name>Test for JUnit 5: Platform 1.2.0 + Jupiter 5.2.0</name>
-
-    <properties>
-        <maven.compiler.source>1.8</maven.compiler.source>
-        <maven.compiler.target>1.8</maven.compiler.target>
-    </properties>
-
-    <!--
-        Declare "junit-jupiter-engine" dependency because the
-        Jupiter Engine is needed at test runtime. Artifacts
-        needed for test compilation, like "junit-jupiter-api",
-        are pulled-in via transitive dependency resolution.
-    -->
-    <dependencies>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
-            <version>5.2.0</version>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-surefire-plugin</artifactId>
-                <version>${surefire.version}</version>
-            </plugin>
-        </plugins>
-    </build>
-</project>
diff --git a/surefire-its/src/test/resources/junit-platform-1.2.0/src/test/java/junitplatform_1_2_0/JUnitPlatform_1_2_0_Test.java b/surefire-its/src/test/resources/junit-platform-1.2.0/src/test/java/junitplatform_1_2_0/JUnitPlatform_1_2_0_Test.java
deleted file mode 100644
index c6ccbfc..0000000
--- a/surefire-its/src/test/resources/junit-platform-1.2.0/src/test/java/junitplatform_1_2_0/JUnitPlatform_1_2_0_Test.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package junitplatform_1_2_0;
-
-/*
- * 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 org.junit.jupiter.api.Assertions.assertEquals;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.TestInfo;
-
-class JUnitPlatform_1_2_0_Test
-{
-
-    @Test
-    void test(TestInfo info)
-    {
-        assertEquals( "test(TestInfo)", info.getDisplayName(), "display name mismatch" );
-    }
-
-
-}
diff --git a/surefire-its/src/test/resources/junit-platform-1.0.0/pom.xml b/surefire-its/src/test/resources/junit-platform/pom.xml
similarity index 80%
rename from surefire-its/src/test/resources/junit-platform-1.0.0/pom.xml
rename to surefire-its/src/test/resources/junit-platform/pom.xml
index 1b6fd59..02e5c00 100644
--- a/surefire-its/src/test/resources/junit-platform-1.0.0/pom.xml
+++ b/surefire-its/src/test/resources/junit-platform/pom.xml
@@ -26,7 +26,7 @@
     <groupId>org.apache.maven.plugins.surefire</groupId>
     <artifactId>junit-platform-1.0.0</artifactId>
     <version>1.0</version>
-    <name>Test for JUnit 5: Platform 1.0.0 + Jupiter 5.0.0</name>
+    <name>Test for JUnit 5: Platform + Jupiter</name>
 
     <properties>
         <maven.compiler.source>1.8</maven.compiler.source>
@@ -43,7 +43,7 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>
-            <version>5.0.0</version>
+            <version>${jupiter.version}</version>
             <scope>test</scope>
         </dependency>
     </dependencies>
@@ -57,4 +57,17 @@
             </plugin>
         </plugins>
     </build>
+
+    <repositories>
+        <repository>
+            <id>oss-sonatype</id>
+            <name>oss-sonatype</name>
+            <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
+            <snapshots>
+                <enabled>true</enabled>
+                <updatePolicy>always</updatePolicy>
+                <checksumPolicy>ignore</checksumPolicy>
+            </snapshots>
+        </repository>
+    </repositories>
 </project>
diff --git a/surefire-its/src/test/resources/junit-platform-1.0.0/src/test/java/junitplatform_1_0_0/JUnitPlatform_1_0_0_Test.java b/surefire-its/src/test/resources/junit-platform/src/test/java/junitplatform/JUnitPlatformTest.java
similarity index 97%
rename from surefire-its/src/test/resources/junit-platform-1.0.0/src/test/java/junitplatform_1_0_0/JUnitPlatform_1_0_0_Test.java
rename to surefire-its/src/test/resources/junit-platform/src/test/java/junitplatform/JUnitPlatformTest.java
index 760d874..68bbe02 100644
--- a/surefire-its/src/test/resources/junit-platform-1.0.0/src/test/java/junitplatform_1_0_0/JUnitPlatform_1_0_0_Test.java
+++ b/surefire-its/src/test/resources/junit-platform/src/test/java/junitplatform/JUnitPlatformTest.java
@@ -24,14 +24,11 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestInfo;
 
-class JUnitPlatform_1_0_0_Test
+class JUnitPlatformTest
 {
-
     @Test
     void test(TestInfo info)
     {
         assertEquals( "test(TestInfo)", info.getDisplayName(), "display name mismatch" );
     }
-
-
 }
diff --git a/surefire-providers/surefire-junit-platform/pom.xml b/surefire-providers/surefire-junit-platform/pom.xml
index 18be313..4a57646 100644
--- a/surefire-providers/surefire-junit-platform/pom.xml
+++ b/surefire-providers/surefire-junit-platform/pom.xml
@@ -86,12 +86,12 @@
         <dependency>
             <groupId>org.junit.platform</groupId>
             <artifactId>junit-platform-launcher</artifactId>
-            <version>1.2.0</version>
+            <version>1.3.1</version>
         </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>
-            <version>5.2.0</version>
+            <version>5.3.1</version>
             <scope>test</scope>
         </dependency>
         <dependency>
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 0cf526c..0ccb4fe 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
@@ -48,6 +48,7 @@ import org.junit.Test;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.engine.descriptor.ClassTestDescriptor;
 import org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor;
+import org.junit.platform.engine.ConfigurationParameters;
 import org.junit.platform.engine.TestDescriptor;
 import org.junit.platform.engine.TestDescriptor.Type;
 import org.junit.platform.engine.TestExecutionResult;
@@ -68,6 +69,8 @@ import org.mockito.InOrder;
  */
 public class RunListenerAdapterTest
 {
+    private static final ConfigurationParameters CONFIG_PARAMS = mock(ConfigurationParameters.class);
+
     private RunListener listener;
 
     private RunListenerAdapter adapter;
@@ -444,7 +447,7 @@ public class RunListenerAdapterTest
 
     private static TestDescriptor newClassDescriptor()
     {
-        return new ClassTestDescriptor( UniqueId.root( "class", MyTestClass.class.getName() ), MyTestClass.class );
+        return new ClassTestDescriptor( UniqueId.root( "class", MyTestClass.class.getName() ), MyTestClass.class, CONFIG_PARAMS );
     }
 
     private static TestIdentifier newSourcelessChildIdentifierWithParent(
diff --git a/surefire-providers/surefire-junit-platform/src/test/java/org/apache/maven/surefire/junitplatform/TestMethodFilterTest.java b/surefire-providers/surefire-junit-platform/src/test/java/org/apache/maven/surefire/junitplatform/TestMethodFilterTest.java
index efb0589..6d4394e 100644
--- a/surefire-providers/surefire-junit-platform/src/test/java/org/apache/maven/surefire/junitplatform/TestMethodFilterTest.java
+++ b/surefire-providers/surefire-junit-platform/src/test/java/org/apache/maven/surefire/junitplatform/TestMethodFilterTest.java
@@ -31,6 +31,7 @@ import org.apache.maven.surefire.testset.TestListResolver;
 import org.junit.Test;
 import org.junit.jupiter.engine.descriptor.ClassTestDescriptor;
 import org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor;
+import org.junit.platform.engine.ConfigurationParameters;
 import org.junit.platform.engine.FilterResult;
 import org.junit.platform.engine.UniqueId;
 
@@ -41,6 +42,8 @@ import org.junit.platform.engine.UniqueId;
  */
 public class TestMethodFilterTest
 {
+    private static final ConfigurationParameters CONFIG_PARAMS = mock(ConfigurationParameters.class);
+
     private final TestListResolver resolver = mock( TestListResolver.class );
 
     private final TestMethodFilter filter = new TestMethodFilter( this.resolver );
@@ -90,7 +93,7 @@ public class TestMethodFilterTest
     private static ClassTestDescriptor newClassTestDescriptor()
     {
         UniqueId uniqueId = UniqueId.forEngine( "class" );
-        return new ClassTestDescriptor( uniqueId, TestClass.class );
+        return new ClassTestDescriptor( uniqueId, TestClass.class, CONFIG_PARAMS );
     }
 
     public static class TestClass