Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Hibernate, Relational Persistence for Idiomatic Java
   *
   * Copyright (c) 2011, Red Hat Inc. or third-party contributors as
   * indicated by the @author tags or express copyright attribution
   * statements applied by the authors.  All third-party contributions are
   * distributed under license by Red Hat Inc.
   *
   * This copyrighted material is made available to anyone wishing to use, modify,
  * copy, or redistribute it subject to the terms and conditions of the GNU
  * Lesser General Public License, as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
  * for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this distribution; if not, write to:
  * Free Software Foundation, Inc.
  * 51 Franklin Street, Fifth Floor
  * Boston, MA  02110-1301  USA
  */
 package org.hibernate.testing.junit4;
 
 import java.util.List;
 
 
 import org.junit.Test;
 
The Hibernate-specific org.junit.runner.Runner implementation which layers ExtendedFrameworkMethod support on top of the standard JUnit org.junit.runners.model.FrameworkMethod for extra information after checking to make sure the test should be run.

Author(s):
Steve Ebersole
 
 public class CustomRunner extends BlockJUnit4ClassRunner {
 	private static final Logger log = Logger.getLoggerCustomRunner.class );
 
 
 		superclazz );
 	}
 
 	protected void collectInitializationErrors(List<Throwableerrors) {
 		super.collectInitializationErrorserrors );
 	}
 
 	}
 
     private Boolean isAllTestsIgnored;
 
     private boolean isAllTestsIgnored() {
         if (  == null ) {
             if ( computeTestMethods().isEmpty() ) {
                  = true;
             }
             else {
                  = true;
                 for ( FrameworkMethod method : computeTestMethods() ) {
                     Ignore ignore = method.getAnnotationIgnore.class );
                     if ( ignore == null ) {
                          = false;
                         break;
                     }
                 }
             }
        }
        return ;
    }
    @Override
    protected Statement withBeforeClasses(Statement statement) {
        if ( isAllTestsIgnored() ) {
            return super.withBeforeClassesstatement );
        }
        return new BeforeClassCallbackHandler(
                this,
                super.withBeforeClassesstatement )
        );
    }
	protected Statement withAfterClasses(Statement statement) {
        if ( isAllTestsIgnored() ) {
            return super.withAfterClassesstatement );
        }
				this,
				super.withAfterClassesstatement )
		);
	}

	protected Statement classBlockRunNotifier notifier ) {
		.infoBeforeClass.class.getSimpleName() + ": " + getName() );
		return super.classBlocknotifier );
	}
	protected Statement methodBlock(FrameworkMethod method) {
		.infoTest.class.getSimpleName() + ": " + method.getName() );
		final Statement originalMethodBlock = super.methodBlockmethod );
		final ExtendedFrameworkMethod extendedFrameworkMethod = (ExtendedFrameworkMethodmethod;
		return new FailureExpectedHandleroriginalMethodBlockextendedFrameworkMethod );
	}
	protected Object getTestInstance() throws Exception {
		if (  == null ) {
		}
		return ;
	}
	protected Object createTest() throws Exception {
		return getTestInstance();
	}
		if (  == null ) {
		}
	}
	protected void sortMethods(List<FrameworkMethodcomputedTestMethods) {
		if ( CollectionHelper.isEmptycomputedTestMethods ) ) {
			return;
		}
		Collections.sortcomputedTestMethodsnew Comparator<FrameworkMethod>() {
			public int compare(FrameworkMethod o1FrameworkMethod o2) {
				return o1.getName().compareToo2.getName() );
			}
		} );
	}
        // Next, get all the test methods as understood by JUnit
        final List<FrameworkMethodmethods = super.computeTestMethods();
        // Now process that full list of test methods and build our custom result
        final List<FrameworkMethodresult = new ArrayList<FrameworkMethod>();
		final boolean doValidation = Boolean.getBoolean. );
		int testCount = 0;
		Ignore virtualIgnore;
		for ( FrameworkMethod frameworkMethod : methods ) {
			// potentially ignore based on expected failure
            final FailureExpected failureExpected = Helper.locateAnnotationFailureExpected.classframeworkMethodgetTestClass() );
			if ( failureExpected != null && !doValidation ) {
				virtualIgnore = new IgnoreImpl( Helper.extractIgnoreMessagefailureExpectedframeworkMethod ) );
			}
			else {
				virtualIgnore = convertSkipToIgnoreframeworkMethod );
			}
			testCount++;
			.trace"adding test " + Helper.extractTestNameframeworkMethod ) + " [#" + testCount + "]" );
			result.addnew ExtendedFrameworkMethodframeworkMethodvirtualIgnorefailureExpected ) );
		}
		return result;
	}
	@SuppressWarnings( {"ClassExplicitlyAnnotation"})
	public static class IgnoreImpl implements Ignore {
		private final String value;
		public IgnoreImpl(String value) {
			this. = value;
		}
		public String value() {
			return ;
		}
		public Class<? extends AnnotationannotationType() {
			return Ignore.class;
		}
	}
	private static Dialect dialect = determineDialect();
	private static Dialect determineDialect() {
		try {
			return Dialect.getDialect();
		}
		catchException e ) {
			return new Dialect() {
			};
		}
	}
	protected Ignore convertSkipToIgnore(FrameworkMethod frameworkMethod) {
		// @Skip
		Skip skip = Helper.locateAnnotationSkip.classframeworkMethodgetTestClass() );
		if ( skip != null ) {
			if ( isMatchskip.condition() ) ) {
				return buildIgnoreskip );
			}
		}
		// @SkipForDialects & @SkipForDialect
		for ( SkipForDialect skipForDialectAnn : Helper.collectAnnotations(
				SkipForDialect.classSkipForDialects.classframeworkMethodgetTestClass()
		) ) {
			for ( Class<? extends DialectdialectClass : skipForDialectAnn.value() ) {
				if ( skipForDialectAnn.strictMatching() ) {
					if ( dialectClass.equals.getClass() ) ) {
						return buildIgnoreskipForDialectAnn );
					}
				}
				else {
					if ( dialectClass.isInstance ) ) {
						return buildIgnoreskipForDialectAnn );
					}
				}
			}
		}
		// @RequiresDialects & @RequiresDialect
		for ( RequiresDialect requiresDialectAnn : Helper.collectAnnotations(
				RequiresDialect.classRequiresDialects.classframeworkMethodgetTestClass()
		) ) {
			boolean foundMatch = false;
			for ( Class<? extends DialectdialectClass : requiresDialectAnn.value() ) {
				foundMatch = requiresDialectAnn.strictMatching()
dialectClass.equals.getClass() )
dialectClass.isInstance );
				if ( foundMatch ) {
					break;
				}
			}
			if ( !foundMatch ) {
				return buildIgnorerequiresDialectAnn );
			}
		}
		// @RequiresDialectFeature
		RequiresDialectFeature requiresDialectFeatureAnn = Helper.locateAnnotationRequiresDialectFeature.classframeworkMethodgetTestClass() );
		if ( requiresDialectFeatureAnn != null ) {
			try {
				boolean foundMatch = false;
				for ( Class<? extends DialectCheckcheckClass : requiresDialectFeatureAnn.value() ) {
					foundMatch = checkClass.newInstance().isMatch );
					if ( !foundMatch ) {
						return buildIgnorerequiresDialectFeatureAnn );
					}
				}
			}
			catch (RuntimeException e) {
				throw e;
			}
			catch (Exception e) {
				throw new RuntimeException"Unable to instantiate DialectCheck"e );
			}
		}
		return null;
	}
	private Ignore buildIgnore(Skip skip) {
		return new IgnoreImpl"@Skip : " + skip.message() );
	}
	private Ignore buildIgnore(SkipForDialect skip) {
		return buildIgnore"@SkipForDialect match"skip.comment(), skip.jiraKey() );
	}
	private Ignore buildIgnore(String reasonString commentString jiraKey) {
		StringBuilder buffer = new StringBuilderreason );
		if ( StringHelper.isNotEmptycomment ) ) {
			buffer.append"; " ).appendcomment );
		}
		if ( StringHelper.isNotEmptyjiraKey ) ) {
			buffer.append" (" ).appendjiraKey ).append')' );
		}
		return new IgnoreImplbuffer.toString() );
	}
	private Ignore buildIgnore(RequiresDialect requiresDialect) {
		return buildIgnore"@RequiresDialect non-match"requiresDialect.comment(), requiresDialect.jiraKey() );
	}
	private Ignore buildIgnore(RequiresDialectFeature requiresDialectFeature) {
		return buildIgnore"@RequiresDialectFeature non-match"requiresDialectFeature.comment(), requiresDialectFeature.jiraKey() );
	}
	private boolean isMatch(Class<? extends Skip.Matchercondition) {
		try {
			Skip.Matcher matcher = condition.newInstance();
			return matcher.isMatch();
		}
		catch (Exception e) {
			throw new MatcherInstantiationExceptionconditione );
		}
	}
	private static class MatcherInstantiationException extends RuntimeException {
		private MatcherInstantiationException(Class<? extends Skip.MatchermatcherClassThrowable cause) {
			super"Unable to instantiate specified Matcher [" + matcherClass.getName(), cause );
		}
	}
New to GrepCode? Check out our FAQ X