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;
 
Metadata about various types of callback methods on a given test class.

Author(s):
Steve Ebersole
 
 public class TestClassMetadata {
 	private static final Object[] NO_ARGS = new Object[0];
 
 
 	public TestClassMetadata(Class testClass) {
 		processClassHierarchytestClass );
 	}
 
 	private void processClassHierarchy(Class testClass) {
 		// NOTE recursive on itself
 		for ( Method method : testClass.getDeclaredMethods() ) {
 			if ( method.getAnnotation.. ) != null ) {
 			}
 			if ( method.getAnnotation.. ) != null ) {
 			}
 			if ( method.getAnnotation.. ) != null ) {
 				addOnFailureCallbackmethod );
 			}
 			if ( method.getAnnotation.. ) != null ) {
 			}
 		}
 
 		Class superClass = testClass.getSuperclass();
 		if ( superClass != null ) {
 			processClassHierarchysuperClass );
 		}
 	}
 
 	private void addBeforeClassOnceCallback(Method method) {
 		if (  == null ) {
 		}
 		ensureAccessibilitymethod );
 	}
 
 	private void ensureAccessibility(Method method) {
 		if ( !method.isAccessible() ) {
 			try {
 				method.setAccessibletrue );
 			}
 			catch (Exception ignored) {
 				// ignore for now
 			}
 		}
 	}
 
 	private void addAfterClassOnceCallback(Method method) {
 		if (  == null ) {
 		}
	}
	private void addOnFailureCallback(Method method) {
		if (  == null ) {
		}
	}
	private void addOnExpectedFailureCallback(Method method) {
		if (  == null ) {
		}
	}
	public void validate(List<Throwableerrors) {
	}
	private void validate(LinkedHashSet<MethodcallbackMethodsCallbackType callbackTypeList<Throwableerrors) {
		if ( callbackMethods != null ) {
			for ( Method method : callbackMethods ) {
				validateCallbackMethodmethodcallbackTypeerrors );
			}
		}
	}
	private void validateCallbackMethod(Method methodCallbackType typeList<Throwableerrors) {
		if ( method.getParameterTypes().length > 0 ) {
			errors.add(
							type.buildTypeMarker() + " callback only valid on no-arg methods : "
									+ Helper.extractMethodNamemethod )
					)
			);
		}
		if ( !method.isAccessible() ) {
			try {
				method.setAccessibletrue );
			}
			catch (Exception e) {
				errors.add(
								type.buildTypeMarker() + " attached to inaccessible method and unable to make accessible"
						)
				);
			}
		}
	}
	private static enum CallbackType {
		BEFORE_CLASS_ONCE( BeforeClassOnce.class ),
		AFTER_CLASS_ONCE( AfterClassOnce.class ),
		ON_FAILURE( OnFailure.class ),
		ON_EXPECTED_FAILURE( OnExpectedFailure.class );
		private final Class<? extends AnnotationannotationClass;
		private CallbackType(Class<? extends AnnotationannotationClass) {
			this. = annotationClass;
		}
		public Class<? extends AnnotationgetAnnotationClass() {
		}
		public String buildTypeMarker() {
			return "@" + getAnnotationClass().getSimpleName();
		}
	}
	public void performBeforeClassCallbacks(Object target) {
	}
	private void performCallbacks(LinkedHashSet<MethodcallbackMethodsObject target) {
		if ( callbackMethods == null ) {
			return;
		}
		for ( Method callbackMethod : callbackMethods ) {
			invokeCallbackcallbackMethodtarget );
		}
	}
	private void invokeCallback(Method callbackObject target) {
		try {
			performCallbackInvocationcallbacktarget );
		}
		catch (CallbackException e) {
			// this is getting eaten, at least when run from IntelliJ.  The test fails to start (for start up
			// callbacks), but the exception is never shown..
			..println"Error performing callback invocation : " + e.getLocalizedMessage() );
			throw e;
		}
	}
	private void performCallbackInvocation(Method callbackObject target) {
		try {
			callback.invoketarget );
		}
			throw new CallbackExceptioncallbacke.getTargetException() );
		}
			throw new CallbackExceptioncallbacke );
		}
	}
	public void performAfterClassCallbacks(Object target) {
	}
	public void performOnFailureCallback(Object target) {
	}
	public void performOnExpectedFailureCallback(Object target) {
	}
New to GrepCode? Check out our FAQ X