public Filter and( Filter filter1, Filter filter2 ) { return new AndFilter( filter1, filter2 ); } }
@Override public String describe() { return combinedFilter.describe(); } }
public Filter createMethodFilter( TestListResolver resolver ) { return new MethodFilter( resolver ); }
private Filter createJUnit48Filter() { final FilterFactory factory = new FilterFactory( testClassLoader ); Map<String, String> props = providerParameters.getProviderProperties(); Filter groupFilter = factory.canCreateGroupFilter( props ) ? factory.createGroupFilter( props ) : null; TestListResolver methodFilter = optionallyWildcardFilter( testResolver ); boolean onlyGroups = methodFilter.isEmpty() || methodFilter.isWildcard(); if ( onlyGroups ) { return groupFilter; } else { Filter jUnitMethodFilter = factory.createMethodFilter( methodFilter ); return groupFilter == null ? jUnitMethodFilter : factory.and( groupFilter, jUnitMethodFilter ); } }
private Filter createJUnit48Filter() { final FilterFactory filterFactory = new FilterFactory( testClassLoader ); return isMethodFilterSpecified() ? filterFactory.createMethodFilter( requestedTestMethod ) : filterFactory.createGroupFilter( providerParameters.getProviderProperties() ); }
public JUnitCoreProvider( ProviderParameters bootParams ) { // don't start a thread in CommandReader while we are in in-plugin process commandsReader = bootParams.isInsideFork() ? getReader().setShutdown( bootParams.getShutdown() ) : null; providerParameters = bootParams; testClassLoader = bootParams.getTestClassLoader(); scanResult = bootParams.getScanResult(); runOrderCalculator = bootParams.getRunOrderCalculator(); jUnitCoreParameters = new JUnitCoreParameters( bootParams.getProviderProperties() ); scannerFilter = new JUnit48TestChecker( testClassLoader ); testResolver = bootParams.getTestRequest().getTestListResolver(); rerunFailingTestsCount = bootParams.getTestRequest().getRerunFailingTestsCount(); customRunListeners = bootParams.getProviderProperties().get( "listener" ); jUnit48Reflector = new JUnit48Reflector( testClassLoader ); }
@Override public boolean shouldRun( Description description ) { return ( includedFilters.isEmpty() || anyFilterMatchesDescription( includedFilters, description ) ) && ( excludedFilters.isEmpty() || allFiltersMatchDescription( excludedFilters, description ) ); }
@SuppressWarnings( { "unchecked" } ) private boolean isAbstractWithEnclosedRunner( Class testClass ) { return jUnit4TestChecker.isRunWithPresentInClassLoader() && isAbstract( testClass ) && isRunWithEnclosedRunner( testClass ); }
boolean isCategoryAnnotationPresent( Class clazz ) { return clazz != null && category != null && ( clazz.getAnnotation( category ) != null || isCategoryAnnotationPresent( clazz.getSuperclass() ) ); } }
MethodFilter( TestListResolver testResolver ) { Collection<Filter> includedFilters = new LinkedHashSet<Filter>(); Collection<Filter> excludedFilters = new LinkedHashSet<Filter>(); for ( ResolvedTest test : testResolver.getIncludedPatterns() ) { includedFilters.add( new RequestedTest( test, true ) ); } for ( ResolvedTest test : testResolver.getExcludedPatterns() ) { excludedFilters.add( new RequestedTest( test, false ) ); } combinedFilter = new CombinedCategoryFilter( includedFilters, excludedFilters ); }
@Override public boolean shouldRun( Description description ) { if ( description.isEmpty() ) { return false; } else if ( description.isTest() ) { return combinedFilter.shouldRun( description ); } else { for ( Description o : description.getChildren() ) { if ( combinedFilter.shouldRun( o ) || shouldRun( o ) ) { return true; } } return false; } }
public Iterator getSuites() { final Filter filter = jUnit48Reflector.isJUnit48Available() ? createJUnit48Filter() : null; testsToRun = getSuitesAsList( filter ); return testsToRun.iterator(); }
@Override public boolean equals( Object o ) { return this == o || o != null && getClass() == o.getClass() && equals( (RequestedTest) o ); }
@Override public boolean accept( Class testClass ) { return jUnit4TestChecker.accept( testClass ) || isAbstractWithEnclosedRunner( testClass ); }
@Override public String describe() { StringBuilder sb = new StringBuilder(); if ( !includedFilters.isEmpty() ) { sb.append( "(" ); sb.append( joinFilters( includedFilters, " OR " ) ); sb.append( ")" ); if ( !excludedFilters.isEmpty() ) { sb.append( " AND " ); } } if ( !excludedFilters.isEmpty() ) { sb.append( "NOT (" ); sb.append( joinFilters( includedFilters, " OR " ) ); sb.append( ")" ); } return sb.toString(); }
private static void findSuperclassCategories( Set<Class<?>> cats, Class<?> clazz ) { if ( clazz != null && clazz.getSuperclass() != null ) { Category cat = clazz.getSuperclass().getAnnotation( Category.class ); if ( cat != null ) { addAll( cats, cat.value() ); } else { findSuperclassCategories( cats, clazz.getSuperclass() ); } } }
@Override public boolean shouldRun( Description description ) { if ( description.getMethodName() == null || description.getTestClass() == null ) { return shouldRun( description, null, null ); } else { Class<?> testClass = description.getTestClass(); return shouldRun( description, createSuiteDescription( testClass ), testClass ); } }
@Override public boolean shouldRun( Description description ) { Class<?> realTestClass = description.getTestClass(); String methodName = description.getMethodName(); if ( realTestClass == null && methodName == null ) { return true; } else { String testClass = classFile( realTestClass ); return isPositiveFilter ? test.matchAsInclusive( testClass, methodName ) : !test.matchAsExclusive( testClass, methodName ); } }
public Filter createMethodFilter( String requestedTestMethod ) { return new MethodFilter( requestedTestMethod ); }
public <T extends Object> T getOverride(Class<T> cls, MethodHandler handler) { ProxyFactory factory = new ProxyFactory(); factory.setSuperclass(cls); factory.setFilter( new MethodFilter() { @Override public boolean isHandled(Method method) { return Modifier.isAbstract(method.getModifiers()); } } ); return (T) factory.create(new Class<?>[0], new Object[0], handler); }