patterns = compilePatterns(filterList);
+ myPatterns.put(groupName, patterns);
+ myAllPatterns.addAll(patterns);
+ }
+
+ /**
+ * Creates TestClassesFilter object assuming that the given stream contains grouped test class filters
+ * at the following format:
+ *
+ *
+ * -
+ * every line that starts with
'[' symbol and ends with ']' symbol defines start
+ * of the new test group. That means that all test class filters that follows this line belongs to the same
+ * test group which name is defined by the text contained between '[' and ']'
+ *
+ * - every line that is not a test-group definition is considered to be a test class filter at regexp format;
+ *
+ *
+ * Example
+ * Consider that given stream points to the following data:
+ *
+ * [CVS]
+ * com.intellij.cvsSupport2.*
+ * [STRESS_TESTS]
+ * com.intellij.application.InspectionPerformanceTest
+ * com.intellij.application.TraverseUITest
+ *
+ *
+ * It defines two test groups:
+ *
+ * - CVS group with the single test class name pattern
'com.intellij.cvsSupport2.*';
+ * -
+ * STRESS_TESTS group with the following test class name patterns:
+ *
+ * - com.intellij.application.InspectionPerformanceTest
+ * - com.intellij.application.TraverseUITest
+ *
+ *
+ *
+ *
+ * This method doesn't suppose itself to be owner of the given stream reader, i.e. it assumes that the stream should be
+ * closed on caller side.
+ *
+ *
+ * @param inputStreamReader reader that points to the target test groups config
+ * @param testGroupName
+ * @return newly created {@link GroupBasedTestClassFilter} object with the data contained at the given reader
+ * @see #matches(String)
+ */
+ @SuppressWarnings({"IOResourceOpenedButNotSafelyClosed"})
+ public static TestClassesFilter createOn(InputStreamReader inputStreamReader, String testGroupName) {
+ try {
+ Map> groupNameToPatternsMap = new HashMap>();
+ String currentGroupName = "";
+ LineNumberReader lineNumberReader = new LineNumberReader(inputStreamReader);
+ String line;
+ while ((line = lineNumberReader.readLine()) != null) {
+ if (line.startsWith("#")) continue;
+ if (line.startsWith("[") && line.endsWith("]")) {
+ currentGroupName = line.substring(1, line.length() - 1);
+ }
+ else {
+ if (!groupNameToPatternsMap.containsKey(currentGroupName)) {
+ groupNameToPatternsMap.put(currentGroupName, new ArrayList());
+ }
+ groupNameToPatternsMap.get(currentGroupName).add(line);
+ }
+ }
+
+ return new GroupBasedTestClassFilter(groupNameToPatternsMap, testGroupName);
+ }
+ catch (IOException e) {
+ return ALL_CLASSES;
+ }
+ }
+
+ /**
+ * Allows to check if given class name belongs to the test group with the given name based on filtering rules encapsulated
+ * at the current {@link GroupBasedTestClassFilter} object. I.e. this method returns true if given test class name
+ * is matched with any test class name filter configured for the test group with the given name.
+ *
+ * Note: there is a special case processing when given group name is {@link #ALL_EXCLUDE_DEFINED}. This method
+ * returns true only if all registered patterns (for all test groups) don't match given test class name.
+ *
+ * @param className target test class name to check
+ * @return true if given test group name is defined (not null) and test class with given
+ * name belongs to the test group with given name;
+ * true if given group if undefined or equal to {@link #ALL_EXCLUDE_DEFINED} and given test
+ * class name is not matched by all registered patterns;
+ * false otherwise
+ */
+ @Override
+ public boolean matches(String className) {
+ boolean result = matchesAnyPattern(myTestGroupPatterns, className);
+ //null group means all patterns from each defined group should be excluded
+ if (isAllExcludeDefinedGroup(myTestGroupName)) {
+ return !result;
+ }
+ else {
+ return result;
+ }
+ }
+
+ private static boolean isAllExcludeDefinedGroup(String groupName) {
+ return StringUtil.isEmpty(groupName) || ALL_EXCLUDE_DEFINED.equalsIgnoreCase(groupName.trim());
+ }
+
+ private List collectPatternsFor(String groupName) {
+ if (isAllExcludeDefinedGroup(groupName)){
+ return myAllPatterns;
+ } else {
+ if (!myPatterns.containsKey(groupName)){
+ return EMPTY_LIST;
+ } else {
+ return myPatterns.get(groupName);
+ }
+ }
+ }
+}
diff --git a/platform/testFramework/src/com/intellij/PatternListTestClassFilter.java b/platform/testFramework/src/com/intellij/PatternListTestClassFilter.java
new file mode 100644
index 000000000000..fff6527dab1f
--- /dev/null
+++ b/platform/testFramework/src/com/intellij/PatternListTestClassFilter.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2000-2011 JetBrains s.r.o.
+ *
+ * Licensed 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.
+ */
+package com.intellij;
+
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @author yole
+ */
+public class PatternListTestClassFilter extends TestClassesFilter {
+ private final List myPatterns;
+
+ public PatternListTestClassFilter(List patterns) {
+ myPatterns = compilePatterns(patterns);
+ }
+
+ @Override
+ public boolean matches(String className) {
+ return TestClassesFilter.matchesAnyPattern(myPatterns, className);
+ }
+}
diff --git a/platform/testFramework/src/com/intellij/TestCaseLoader.java b/platform/testFramework/src/com/intellij/TestCaseLoader.java
index 6c277712e0c1..9e24e832aea3 100644
--- a/platform/testFramework/src/com/intellij/TestCaseLoader.java
+++ b/platform/testFramework/src/com/intellij/TestCaseLoader.java
@@ -69,7 +69,7 @@ public class TestCaseLoader {
}
if (excludedStream != null) {
try {
- myTestClassesFilter = TestClassesFilter.createOn(new InputStreamReader(excludedStream));
+ myTestClassesFilter = GroupBasedTestClassFilter.createOn(new InputStreamReader(excludedStream), myTestGroupName);
}
finally {
try {
@@ -83,10 +83,10 @@ public class TestCaseLoader {
else {
String patterns = System.getProperty(TARGET_TEST_PATTERNS);
if (patterns != null) {
- myTestClassesFilter = new TestClassesFilter(StringUtil.split(patterns, ";"));
+ myTestClassesFilter = new PatternListTestClassFilter(StringUtil.split(patterns, ";"));
}
else {
- myTestClassesFilter = TestClassesFilter.EMPTY_CLASSES_FILTER;
+ myTestClassesFilter = TestClassesFilter.ALL_CLASSES;
}
}
@@ -174,7 +174,7 @@ public class TestCaseLoader {
* Determine if we should exclude this test case.
*/
private boolean shouldExcludeTestClass(Class testCaseClass) {
- return !myTestClassesFilter.matches(testCaseClass.getName(), myTestGroupName) || isBombed(testCaseClass)
+ return !myTestClassesFilter.matches(testCaseClass.getName()) || isBombed(testCaseClass)
|| blockedTests.contains(testCaseClass.getName());
}
diff --git a/platform/testFramework/src/com/intellij/TestClassesFilter.java b/platform/testFramework/src/com/intellij/TestClassesFilter.java
index 8cec572aa1e4..4b03e33952e1 100644
--- a/platform/testFramework/src/com/intellij/TestClassesFilter.java
+++ b/platform/testFramework/src/com/intellij/TestClassesFilter.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2011 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,146 +15,37 @@
*/
package com.intellij;
-import com.intellij.openapi.util.text.StringUtil;
-
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.LineNumberReader;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
import java.util.regex.Pattern;
/**
- * Encapsulates logic of filtering test classes (classes that contain test-cases).
- *
- * We want to have such facility in order to be able to execute different sets of tests like 'fast tests',
- * 'problem tests' etc.
- *
- * I.e. assumed usage scenario is to create object of this class with necessary filtering criteria and use it's
- * {@link #matches(String, String)} method for determining if particular test should be executed.
- *
- * The filtering is performed by fully-qualified test class name. There are two ways to define the criteria at the moment:
- *
- * -
- * Define target class name filters (at regexp format) explicitly using
- * {@link #TestClassesFilter(List) dedicated constructor};
- *
- * - Read class name filters (at regexp format) from the given stream - see {@link #createOn(InputStreamReader)};
- *
+ * @author yole
*/
-public class TestClassesFilter {
-
- private final Map> myPatterns = new HashMap>();
- public static final TestClassesFilter EMPTY_CLASSES_FILTER = new TestClassesFilter(new HashMap>());
- public static final ArrayList EMPTY_LIST = new ArrayList();
- private final List myAllPatterns = new ArrayList();
-
- /**
- * Holds reserved test group name that serves as a negation of matching result.
- *
- * @see #matches(String, String)
- */
- public static final String ALL_EXCLUDE_DEFINED = "ALL_EXCLUDE_DEFINED";
-
- private TestClassesFilter(Map> filters) {
-
- for (String groupName : filters.keySet()) {
- List filterList = filters.get(groupName);
- addPatterns(groupName, filterList);
+public abstract class TestClassesFilter {
+ public static final TestClassesFilter ALL_CLASSES = new TestClassesFilter() {
+ @Override
+ public boolean matches(String className) {
+ return true;
}
- }
+ };
- /**
- * Creates new TestClassesFilter object with the given list of matching patterns (at regexp format).
- *
- * @param filterList list of test class matching patterns
- */
- TestClassesFilter(List filterList) {
- addPatterns("", filterList);
- }
+ public abstract boolean matches(String className);
- private void addPatterns(String groupName, List filterList) {
+ protected static ArrayList compilePatterns(List filterList) {
ArrayList patterns = new ArrayList();
- myPatterns.put(groupName, patterns);
for (String aFilter : filterList) {
String filter = aFilter.trim();
if (filter.length() == 0) continue;
filter = filter.replaceAll("\\*", ".\\*");
Pattern pattern = Pattern.compile(filter);
- myAllPatterns.add(pattern);
patterns.add(pattern);
}
+ return patterns;
}
- /**
- * Creates TestClassesFilter object assuming that the given stream contains grouped test class filters
- * at the following format:
- *
- *
- * -
- * every line that starts with
'[' symbol and ends with ']' symbol defines start
- * of the new test group. That means that all test class filters that follows this line belongs to the same
- * test group which name is defined by the text contained between '[' and ']'
- *
- * - every line that is not a test-group definition is considered to be a test class filter at regexp format;
- *
- *
- * Example
- * Consider that given stream points to the following data:
- *
- * [CVS]
- * com.intellij.cvsSupport2.*
- * [STRESS_TESTS]
- * com.intellij.application.InspectionPerformanceTest
- * com.intellij.application.TraverseUITest
- *
- *
- * It defines two test groups:
- *
- * - CVS group with the single test class name pattern
'com.intellij.cvsSupport2.*';
- * -
- * STRESS_TESTS group with the following test class name patterns:
- *
- * - com.intellij.application.InspectionPerformanceTest
- * - com.intellij.application.TraverseUITest
- *
- *
- *
- *
- * This method doesn't suppose itself to be owner of the given stream reader, i.e. it assumes that the stream should be
- * closed on caller side.
- *
- * @param inputStreamReader reader that points to the target test groups config
- * @return newly created {@link TestClassesFilter} object with the data contained at the given reader
- * @see #matches(String, String)
- */
- @SuppressWarnings({"IOResourceOpenedButNotSafelyClosed"})
- public static TestClassesFilter createOn(InputStreamReader inputStreamReader) {
- try {
- Map> groupNameToPatternsMap = new HashMap>();
- String currentGroupName = "";
- LineNumberReader lineNumberReader = new LineNumberReader(inputStreamReader);
- String line;
- while ((line = lineNumberReader.readLine()) != null) {
- if (line.startsWith("#")) continue;
- if (line.startsWith("[") && line.endsWith("]")) {
- currentGroupName = line.substring(1, line.length() - 1);
- }
- else {
- if (!groupNameToPatternsMap.containsKey(currentGroupName)) {
- groupNameToPatternsMap.put(currentGroupName, new ArrayList());
- }
- groupNameToPatternsMap.get(currentGroupName).add(line);
- }
- }
-
- return new TestClassesFilter(groupNameToPatternsMap);
- }
- catch (IOException e) {
- return EMPTY_CLASSES_FILTER;
- }
- }
-
- private static boolean matches(Collection patterns, String className) {
+ protected static boolean matchesAnyPattern(Collection patterns, String className) {
for (Pattern pattern : patterns) {
if (pattern.matcher(className).matches()) {
return true;
@@ -162,48 +53,4 @@ public class TestClassesFilter {
}
return false;
}
-
- /**
- * Allows to check if given class name belongs to the test group with the given name based on filtering rules encapsulated
- * at the current {@link TestClassesFilter} object. I.e. this method returns true if given test class name
- * is matched with any test class name filter configured for the test group with the given name.
- *
- * Note: there is a special case processing when given group name is {@link #ALL_EXCLUDE_DEFINED}. This method
- * returns true only if all registered patterns (for all test groups) don't match given test class name.
- *
- * @param className target test class name to check
- * @param groupName target test group name to check
- * @return true if given test group name is defined (not null) and test class with given
- * name belongs to the test group with given name;
- * true if given group if undefined or equal to {@link #ALL_EXCLUDE_DEFINED} and given test
- * class name is not matched by all registered patterns;
- * false otherwise
- */
- public boolean matches(String className, String groupName) {
- List patterns = collectPatternsFor(groupName);
- boolean result = matches(patterns, className);
- //null group means all patterns from each defined group should be excluded
- if (isAllExcludeDefinedGroup(groupName)) {
- return !result;
- }
- else {
- return result;
- }
- }
-
- private static boolean isAllExcludeDefinedGroup(String groupName) {
- return StringUtil.isEmpty(groupName) || ALL_EXCLUDE_DEFINED.equalsIgnoreCase(groupName.trim());
- }
-
- private List collectPatternsFor(String groupName) {
- if (isAllExcludeDefinedGroup(groupName)){
- return myAllPatterns;
- } else {
- if (!myPatterns.containsKey(groupName)){
- return EMPTY_LIST;
- } else {
- return myPatterns.get(groupName);
- }
- }
- }
}