maven-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tibordig...@apache.org
Subject [03/19] maven-surefire git commit: Unit tests of method filtering and according fixes
Date Thu, 26 Mar 2015 00:15:45 GMT
Unit tests of method filtering and according fixes


Project: http://git-wip-us.apache.org/repos/asf/maven-surefire/repo
Commit: http://git-wip-us.apache.org/repos/asf/maven-surefire/commit/a439d07c
Tree: http://git-wip-us.apache.org/repos/asf/maven-surefire/tree/a439d07c
Diff: http://git-wip-us.apache.org/repos/asf/maven-surefire/diff/a439d07c

Branch: refs/heads/master
Commit: a439d07c2e95fe4275d74f7c13a630b5dd08f6df
Parents: 650ee15
Author: Jörn Horstmann <git@jhorstmann.net>
Authored: Thu Dec 18 00:30:23 2014 +0100
Committer: Jörn Horstmann <git@jhorstmann.net>
Committed: Thu Dec 18 00:30:23 2014 +0100

----------------------------------------------------------------------
 .../surefire/common/junit48/FilterFactory.java  |  52 +++--
 .../common/junit48/FilterFactoryTest.java       | 208 +++++++++++++++++++
 2 files changed, 242 insertions(+), 18 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/maven-surefire/blob/a439d07c/surefire-providers/common-junit48/src/main/java/org/apache/maven/surefire/common/junit48/FilterFactory.java
----------------------------------------------------------------------
diff --git a/surefire-providers/common-junit48/src/main/java/org/apache/maven/surefire/common/junit48/FilterFactory.java
b/surefire-providers/common-junit48/src/main/java/org/apache/maven/surefire/common/junit48/FilterFactory.java
index 184d7d9..dbab6dd 100644
--- a/surefire-providers/common-junit48/src/main/java/org/apache/maven/surefire/common/junit48/FilterFactory.java
+++ b/surefire-providers/common-junit48/src/main/java/org/apache/maven/surefire/common/junit48/FilterFactory.java
@@ -19,6 +19,7 @@ package org.apache.maven.surefire.common.junit48;
  * under the License.
  */
 
+import org.apache.maven.shared.utils.StringUtils;
 import org.apache.maven.shared.utils.io.SelectorUtils;
 import org.apache.maven.surefire.booter.ProviderParameterNames;
 import org.apache.maven.surefire.group.match.AndGroupMatcher;
@@ -31,6 +32,7 @@ import org.junit.runner.Description;
 import org.junit.runner.manipulation.Filter;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
@@ -126,47 +128,58 @@ public class FilterFactory
                 this.methodName = methodName;
             }
 
-            private boolean isDescriptionmatch( Description description )
+            private static boolean isSelectorPattern( String pattern )
+            {
+                return pattern.contains( "*" ) || pattern.contains( "?" );
+            }
+
+            public boolean isDescriptionmatch( Description description )
             {
                 String describedClassName = description.getClassName();
                 String describedMethodName = description.getMethodName();
 
-                if ( describedClassName != null )
+                if ( methodName != null )
+                {
+                    if ( describedMethodName == null || !SelectorUtils.match( methodName,
describedMethodName ) )
+                    {
+                        return false;
+                    }
+                }
+
+                if ( className != null && describedClassName != null )
                 {
-                    if ( this.className.indexOf( '*' ) < 0 && this.className.indexOf(
'?' ) < 0 )
+                    if ( !isSelectorPattern( className ) )
                     {
                         // existing implementation seems to be a simple contains check
-                        if ( !describedClassName.contains( this.className ) )
+                        if ( describedClassName.contains( className ) )
                         {
-                            return false;
+                            return true;
                         }
                     }
                     else
                     {
-                        if ( !SelectorUtils.match( this.className, describedClassName ) )
+                        if ( SelectorUtils.match( className, describedClassName ) )
                         {
-                            return false;
+                            return true;
                         }
                     }
-                }
 
-                if ( describedMethodName != null && !SelectorUtils.match( this.methodName,
describedMethodName ) )
-                {
                     return false;
                 }
 
                 return true;
+
             }
         }
 
         private final String requestString;
-        private final List<RequestedTestMethod> requestedTestMethods;
+        private final Collection<RequestedTestMethod> requestedTestMethods;
 
         public MethodFilter( String requestString )
         {
-            List<RequestedTestMethod> requestedTestMethods = new ArrayList<RequestedTestMethod>();
+            Collection<RequestedTestMethod> requestedTestMethods = new ArrayList<RequestedTestMethod>();
 
-            if ( requestString.indexOf( '#' ) < 0 )
+            if ( !requestString.contains( "#" ) )
             {
                 // old way before SUREFIRE-745, filter only by method name
                 // class name filtering is done separately
@@ -177,23 +190,26 @@ public class FilterFactory
                 // possibly several classes and methods separated by comma
                 // several methods in the same class separated by plus
 
-                for ( String requestedTestMethod : requestString.split( "," ) )
+                for ( String request : StringUtils.split( requestString, "," ) )
                 {
-                    int index = requestedTestMethod.indexOf( '#' );
+                    int index = request.indexOf( '#' );
                     if ( index < 0 )
                     {
-                        requestedTestMethods.add( new RequestedTestMethod( null, requestedTestMethod
) );
+                        // request can also contain complete classes
+                        requestedTestMethods.add( new RequestedTestMethod( request, null
) );
                     }
                     else
                     {
-                        String className = index == 0 ? null : requestedTestMethod.substring(
0, index );
-                        for ( String methodName : requestedTestMethod.substring( index +
1 ).split( "\\+" ) )
+                        String className = index == 0 ? null : request.substring( 0, index
);
+                        String methodNames = request.substring( index + 1 );
+                        for ( String methodName : StringUtils.split( methodNames, "+" ) )
                         {
                             requestedTestMethods.add( new RequestedTestMethod( className,
methodName ) );
                         }
                     }
                 }
             }
+
             this.requestString = requestString;
             this.requestedTestMethods = requestedTestMethods;
         }

http://git-wip-us.apache.org/repos/asf/maven-surefire/blob/a439d07c/surefire-providers/common-junit48/src/test/java/org/apache/maven/surefire/common/junit48/FilterFactoryTest.java
----------------------------------------------------------------------
diff --git a/surefire-providers/common-junit48/src/test/java/org/apache/maven/surefire/common/junit48/FilterFactoryTest.java
b/surefire-providers/common-junit48/src/test/java/org/apache/maven/surefire/common/junit48/FilterFactoryTest.java
new file mode 100644
index 0000000..bf9dd98
--- /dev/null
+++ b/surefire-providers/common-junit48/src/test/java/org/apache/maven/surefire/common/junit48/FilterFactoryTest.java
@@ -0,0 +1,208 @@
+package org.apache.maven.surefire.common.junit48;
+
+/*
+ * 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.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.manipulation.Filter;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.runner.Description.createTestDescription;
+
+public class FilterFactoryTest
+{
+    static class Suite
+    {
+
+    }
+
+    static class FirstClass
+    {
+
+    }
+
+    static class SecondClass {
+
+    }
+
+    private final Description testMethod = createTestDescription( FirstClass.class, "testMethod"
);
+    private final Description secondTestMethod = createTestDescription( FirstClass.class,
"secondTestMethod" );
+    private final Description otherMethod = createTestDescription( FirstClass.class, "otherMethod"
);
+    private final Description testMethodInSecondClass = createTestDescription( SecondClass.class,
"testMethod" );
+    private final Description secondTestMethodInSecondClass = createTestDescription( SecondClass.class,
+            "secondTestMethod" );
+
+    private final String firstClassName = FirstClass.class.getName();
+    private final String secondClassName = SecondClass.class.getName();
+
+    private Filter createMethodFilter( String requestString )
+    {
+        return new FilterFactory( getClass().getClassLoader() ).createMethodFilter( requestString
);
+    }
+
+    @Test
+    public void shouldMatchExactMethodName()
+    {
+        Filter exactFilter = createMethodFilter( "testMethod" );
+        assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod )
);
+    }
+
+    @Test
+    public void shouldMatchExactMethodNameWithHash()
+    {
+        Filter exactFilter = createMethodFilter( "#testMethod" );
+        assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod )
);
+    }
+
+    @Test
+    public void shouldNotMatchExactOnOtherMethod()
+    {
+        Filter exactFilter = createMethodFilter( "testMethod" );
+        assertFalse( "should not run other methods", exactFilter.shouldRun( otherMethod )
);
+    }
+
+    @Test
+    public void shouldMatchWildCardsInMethodName()
+    {
+        Filter starAtEnd = createMethodFilter( "test*" );
+        assertTrue( "match ending with star should run", starAtEnd.shouldRun( testMethod
) );
+
+        Filter starAtBeginning = createMethodFilter( "*Method" );
+        assertTrue( "match starting with star should run", starAtBeginning.shouldRun( testMethod
) );
+
+        Filter starInMiddle = createMethodFilter( "test*thod" );
+        assertTrue( "match containing star should run", starInMiddle.shouldRun( testMethod
) );
+
+        Filter questionAtEnd = createMethodFilter( "testMetho?" );
+        assertTrue( "match ending with question mark should run", questionAtEnd.shouldRun(
testMethod ) );
+
+        Filter questionAtBeginning = createMethodFilter( "????Method" );
+        assertTrue( "match starting with question mark should run", questionAtBeginning.shouldRun(
testMethod ) );
+
+        Filter questionInMiddle = createMethodFilter( "testM?thod" );
+        assertTrue( "match containing question mark should run", questionInMiddle.shouldRun(
testMethod ) );
+
+        Filter starAndQuestion = createMethodFilter( "t?st*thod" );
+        assertTrue( "match containing star and question mark should run", starAndQuestion.shouldRun(
testMethod ) );
+    }
+
+    @Test
+    public void shouldMatchExactClassAndMethod()
+    {
+        Filter exactFilter = createMethodFilter( firstClassName + "#testMethod" );
+        assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod )
);
+    }
+
+    @Test
+    public void shouldMatchEndOfClassNameWithMethod()
+    {
+        Filter exactFilter = createMethodFilter( "FirstClass#testMethod" );
+        assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod )
);
+        assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod
) );
+    }
+
+    @Test
+    public void shouldMatchPartialClassNameWithMethod()
+    {
+        Filter exactFilter = createMethodFilter( "FirstClass#testMethod" );
+        assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod )
);
+        assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod
) );
+    }
+
+    @Test
+    public void shouldMatchClassNameWithWildcardAndMethod()
+    {
+        Filter exactFilter = createMethodFilter( "*First*#testMethod" );
+        assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod )
);
+        assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod
) );
+    }
+
+    @Test
+    public void shouldMatchClassNameWithWildcardCompletely()
+    {
+        Filter exactFilter = createMethodFilter( "First*#testMethod" );
+        assertFalse( "other method should not match", exactFilter.shouldRun( testMethod )
);
+        assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod
) );
+    }
+
+
+    @Test
+    public void shouldMatchMultipleMethodsSeparatedByComman()
+    {
+        Filter exactFilter = createMethodFilter( firstClassName + "#testMethod,#secondTestMethod"
);
+
+        assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod )
);
+        assertTrue( "exact match on name should run", exactFilter.shouldRun( secondTestMethod
) );
+        assertTrue( "exact match on name should run", exactFilter.shouldRun( secondTestMethodInSecondClass
) );
+
+        assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod
) );
+    }
+
+    @Test
+    public void shouldMatchMultipleMethodsInSameClassSeparatedByPlus() {
+        Filter exactFilter = createMethodFilter( FirstClass.class.getName() + "#testMethod+secondTestMethod"
);
+
+        assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod )
);
+        assertTrue( "exact match on name should run", exactFilter.shouldRun( secondTestMethod
) );
+
+        assertFalse( "method in another class should not match", exactFilter.shouldRun( secondTestMethodInSecondClass
) );
+
+        assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod
) );
+    }
+
+    @Test
+    public void shouldRunCompleteClassWhenSeparatedByCommaWithoutHash() {
+        Filter exactFilter = createMethodFilter( firstClassName + "#testMethod," + secondClassName
);
+
+        assertTrue( "exact match on name should run", exactFilter.shouldRun( testMethod )
);
+
+        assertFalse( "other method should not match", exactFilter.shouldRun( secondTestMethod
) );
+        assertFalse( "other method should not match", exactFilter.shouldRun( otherMethod
) );
+
+        assertTrue( "should run complete second class", exactFilter.shouldRun( testMethodInSecondClass
) );
+        assertTrue( "should run complete second class", exactFilter.shouldRun( secondTestMethodInSecondClass
) );
+    }
+
+    @Test
+    public void shouldRunSuitesContainingExactMethodName()
+    {
+        Description suite = Description.createSuiteDescription( Suite.class );
+        suite.addChild( testMethod );
+        suite.addChild( secondTestMethod );
+
+        Filter exactFilter = createMethodFilter( "testMethod" );
+        assertTrue( "should run suites containing matching method", exactFilter.shouldRun(
suite ) );
+    }
+
+    @Test
+    public void shouldSkipSuitesNotContainingExactMethodName()
+    {
+        Description suite = Description.createSuiteDescription( Suite.class );
+        suite.addChild( testMethod );
+        suite.addChild( secondTestMethod );
+
+        Filter exactFilter = createMethodFilter( "otherMethod" );
+        assertFalse( "should not run method", exactFilter.shouldRun( testMethod ) );
+        assertFalse( "should not run method", exactFilter.shouldRun( secondTestMethod ) );
+        assertFalse( "should not run suites containing no matches", exactFilter.shouldRun(
suite ) );
+    }
+
+}


Mime
View raw message