Examples with Filter org.junit.runner.manipulation.Filter used on opensource projects

Example 1 with Filter

use of org.junit.runner.manipulation.Filter in project junit4 by junit-team.

the class ParentRunnerFilteringTest method testSuiteFilteringWithUnmodifyableChildList.

@Test
public void testSuiteFilteringWithUnmodifyableChildList() throws Exception {
    Runner runner = Request.aClass(ExampleSuiteWithUnmodifyableChildList.class).getRunner();
    Filter filter = notThisMethodName("test1");
    try {
        filter.apply(runner);
    } catch (NoTestsRemainException e) {
        return;
    }
    fail("Expected 'NoTestsRemainException' due to complete filtering");
}

Example 2 with Filter

use of org.junit.runner.manipulation.Filter in project intellij-community by JetBrains.

the class JUnit4TestRunnerUtil method buildRequest.

public static Request buildRequest(String[] suiteClassNames, final String name, boolean notForked) {
    if (suiteClassNames.length == 0) {
        return null;
    }
    Vector result = new Vector();
    for (int i = 0; i < suiteClassNames.length; i++) {
        String suiteClassName = suiteClassNames[i];
        if (suiteClassName.charAt(0) == '@') {
            // all tests in the package specified
            try {
                final Map classMethods = new HashMap();
                BufferedReader reader = new BufferedReader(new FileReader(suiteClassName.substring(1)));
                try {
                    final String packageName = reader.readLine();
                    if (packageName == null)
                        return null;
                    final String categoryName = reader.readLine();
                    final Class category = categoryName != null && categoryName.length() > 0 ? loadTestClass(categoryName) : null;
                    String line;
                    while ((line = reader.readLine()) != null) {
                        String className = line;
                        final int idx = line.indexOf(',');
                        if (idx != -1) {
                            className = line.substring(0, idx);
                            Set methodNames = (Set) classMethods.get(className);
                            if (methodNames == null) {
                                methodNames = new HashSet();
                                classMethods.put(className, methodNames);
                            }
                            methodNames.add(line.substring(idx + 1));
                        }
                        appendTestClass(result, className);
                    }
                    String suiteName = packageName.length() == 0 ? "<default package>" : packageName;
                    Class[] classes = getArrayOfClasses(result);
                    if (classes.length == 0) {
                        System.out.println(TestRunnerUtil.testsFoundInPackageMesage(0, suiteName));
                        return null;
                    }
                    Request allClasses;
                    try {
                        Class.forName("org.junit.runner.Computer");
                        allClasses = JUnit46ClassesRequestBuilder.getClassesRequest(suiteName, classes, classMethods, category);
                    } catch (ClassNotFoundException e) {
                        allClasses = getClassRequestsUsing44API(suiteName, classes);
                    } catch (NoSuchMethodError e) {
                        allClasses = getClassRequestsUsing44API(suiteName, classes);
                    }
                    return classMethods.isEmpty() ? allClasses : allClasses.filterWith(new Filter() {

                        public boolean shouldRun(Description description) {
                            if (description.isTest()) {
                                final Set methods = (Set) classMethods.get(JUnit4ReflectionUtil.getClassName(description));
                                if (methods == null) {
                                    return true;
                                }
                                String methodName = JUnit4ReflectionUtil.getMethodName(description);
                                if (methods.contains(methodName)) {
                                    return true;
                                }
                                if (name != null) {
                                    return methodName.endsWith(name) && methods.contains(methodName.substring(0, methodName.length() - name.length()));
                                }
                                final Class testClass = description.getTestClass();
                                if (testClass != null) {
                                    final RunWith classAnnotation = (RunWith) testClass.getAnnotation(RunWith.class);
                                    if (classAnnotation != null && Parameterized.class.isAssignableFrom(classAnnotation.value())) {
                                        final int idx = methodName.indexOf("[");
                                        if (idx > -1) {
                                            return methods.contains(methodName.substring(0, idx));
                                        }
                                    }
                                }
                                return false;
                            }
                            return true;
                        }

                        public String describe() {
                            return "Tests";
                        }
                    });
                } finally {
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
                System.exit(1);
            }
        } else {
            int index = suiteClassName.indexOf(',');
            if (index != -1) {
                final Class clazz = loadTestClass(suiteClassName.substring(0, index));
                final String methodName = suiteClassName.substring(index + 1);
                final RunWith clazzAnnotation = (RunWith) clazz.getAnnotation(RunWith.class);
                final Description testMethodDescription = Description.createTestDescription(clazz, methodName);
                if (clazzAnnotation == null) {
                    //do not override external runners
                    try {
                        final Method method = clazz.getMethod(methodName, null);
                        if (method != null && notForked && (method.getAnnotation(Ignore.class) != null || clazz.getAnnotation(Ignore.class) != null)) {
                            //override ignored case only
                            final Request classRequest = JUnit45ClassesRequestBuilder.createIgnoreIgnoredClassRequest(clazz, true);
                            final Filter ignoredTestFilter = Filter.matchMethodDescription(testMethodDescription);
                            return classRequest.filterWith(new Filter() {

                                public boolean shouldRun(Description description) {
                                    return ignoredTestFilter.shouldRun(description);
                                }

                                public String describe() {
                                    return "Ignored " + methodName;
                                }
                            });
                        }
                    } catch (Throwable ignored) {
                    //return simple method runner
                    }
                } else {
                    final Request request = getParameterizedRequest(name, methodName, clazz, clazzAnnotation);
                    if (request != null) {
                        return request;
                    }
                }
                try {
                    if (clazz.getMethod("suite", new Class[0]) != null && !methodName.equals("suite")) {
                        return Request.classWithoutSuiteMethod(clazz).filterWith(testMethodDescription);
                    }
                } catch (Throwable e) {
                //ignore
                }
                final Filter methodFilter;
                try {
                    methodFilter = Filter.matchMethodDescription(testMethodDescription);
                } catch (NoSuchMethodError e) {
                    return Request.method(clazz, methodName);
                }
                return Request.aClass(clazz).filterWith(new Filter() {

                    public boolean shouldRun(Description description) {
                        if (description.isTest() && description.getDisplayName().startsWith("warning(junit.framework.TestSuite$")) {
                            return true;
                        }
                        return methodFilter.shouldRun(description);
                    }

                    public String describe() {
                        return methodFilter.describe();
                    }
                });
            } else if (name != null && suiteClassNames.length == 1) {
                final Class clazz = loadTestClass(suiteClassName);
                if (clazz != null) {
                    final RunWith clazzAnnotation = (RunWith) clazz.getAnnotation(RunWith.class);
                    final Request request = getParameterizedRequest(name, null, clazz, clazzAnnotation);
                    if (request != null) {
                        return request;
                    }
                }
            }
            appendTestClass(result, suiteClassName);
        }
    }
    if (result.size() == 1) {
        final Class clazz = (Class) result.get(0);
        try {
            if (clazz.getAnnotation(Ignore.class) != null) {
                //override ignored case only
                return JUnit45ClassesRequestBuilder.createIgnoreIgnoredClassRequest(clazz, false);
            }
        } catch (ClassNotFoundException e) {
        //return simple class runner
        }
        return Request.aClass(clazz);
    }
    return Request.classes(getArrayOfClasses(result));
}

Example 3 with Filter

use of org.junit.runner.manipulation.Filter in project bazel by bazelbuild.

the class ShardingFiltersTest method testCreateShardingFilter_defaultStrategy.

@Test
public void testCreateShardingFilter_defaultStrategy() {
    List<Description> descriptions = ShardingFilterTestCase.createGenericTestCaseDescriptions(6);
    RoundRobinShardingFilter expectedFilter = new RoundRobinShardingFilter(descriptions, 0, 5);
    when(mockShardingEnvironment.getShardIndex()).thenReturn(0);
    when(mockShardingEnvironment.getTotalShards()).thenReturn(5);
    when(mockShardingEnvironment.getTestShardingStrategy()).thenReturn(null);
    ShardingFilters shardingFilters = new ShardingFilters(mockShardingEnvironment, ShardingFilters.ShardingStrategy.ROUND_ROBIN);
    Filter filter = shardingFilters.createShardingFilter(descriptions);
    assertThat(filter).isInstanceOf(RoundRobinShardingFilter.class);
    RoundRobinShardingFilter shardingFilter = (RoundRobinShardingFilter) filter;
    assertEquals(expectedFilter.testToShardMap, shardingFilter.testToShardMap);
    assertEquals(expectedFilter.shardIndex, shardingFilter.shardIndex);
    assertEquals(expectedFilter.totalShards, shardingFilter.totalShards);
}

Example 4 with Filter

use of org.junit.runner.manipulation.Filter in project bazel by bazelbuild.

the class ShardingFiltersTest method testCreateShardingFilter_customStrategy.

@Test
public void testCreateShardingFilter_customStrategy() {
    List<Description> descriptions = ShardingFilterTestCase.createGenericTestCaseDescriptions(6);
    when(mockShardingEnvironment.getShardIndex()).thenReturn(0);
    when(mockShardingEnvironment.getTotalShards()).thenReturn(5);
    when(mockShardingEnvironment.getTestShardingStrategy()).thenReturn("com.google.testing.junit.runner.sharding.ShardingFiltersTest$TestFilterFactory");
    ShardingFilters shardingFilters = new ShardingFilters(mockShardingEnvironment);
    Filter filter = shardingFilters.createShardingFilter(descriptions);
    assertEquals("com.google.testing.junit.runner.sharding.ShardingFiltersTest.TestFilter", filter.getClass().getCanonicalName());
}

Example 5 with Filter

use of org.junit.runner.manipulation.Filter in project gradle by gradle.

the class JUnitTestClassExecuter method allTestsFiltered.

private boolean allTestsFiltered(Runner runner, List<Filter> filters) {
    LinkedList<Description> queue = new LinkedList<Description>();
    queue.add(runner.getDescription());
    while (!queue.isEmpty()) {
        Description description = queue.removeFirst();
        queue.addAll(description.getChildren());
        boolean run = true;
        for (Filter filter : filters) {
            if (!filter.shouldRun(description)) {
                run = false;
                break;
            }
        }
        if (run) {
            return false;
        }
    }
    return true;
}