Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
package org.apache.maven.surefire.junit;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.apache.maven.surefire.report.ReporterManager;
import org.apache.maven.surefire.testset.AbstractTestSet;
import org.apache.maven.surefire.testset.TestSetFailedException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
public final class JUnitTestSet
extends AbstractTestSet
{
public static final String TEST_CASE = "junit.framework.Test";
public static final String TEST_RESULT = "junit.framework.TestResult";
public static final String TEST_LISTENER = "junit.framework.TestListener";
public static final String TEST = "junit.framework.Test";
public static final String ADD_LISTENER_METHOD = "addListener";
public static final String RUN_METHOD = "run";
public static final String COUNT_TEST_CASES_METHOD = "countTestCases";
public static final String SETUP_METHOD = "setUp";
public static final String TEARDOWN_METHOD = "tearDown";
private static final String TEST_SUITE = "junit.framework.TestSuite";
private Class[] interfacesImplementedByDynamicProxy;
private Class testResultClass;
private Method addListenerMethod;
private Method countTestCasesMethod;
private Method runMethod;
private static final Class[] EMPTY_CLASS_ARRAY = new Class[0];
private static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
public JUnitTestSet( Class testClass )
throws TestSetFailedException
{
super( testClass );
processTestClass();
}
private void processTestClass()
throws TestSetFailedException
{
try
{
Class testClass = getTestClass();
ClassLoader loader = testClass.getClassLoader();
testResultClass = loader.loadClass( TEST_RESULT );
Class testListenerInterface = loader.loadClass( TEST_LISTENER );
Class testInterface = loader.loadClass( TEST );
// ----------------------------------------------------------------------
// Strategy for executing JUnit tests
//
// o look for the suite method and if that is present execute that method
// to get the test object.
//
// o look for test classes that are assignable from TestCase
//
// o look for test classes that only implement the Test interface
// ----------------------------------------------------------------------
interfacesImplementedByDynamicProxy = new Class[1];
interfacesImplementedByDynamicProxy[0] = testListenerInterface;
// The interface implemented by the dynamic proxy (TestListener), happens to be
// the same as the param types of TestResult.addTestListener
Class[] addListenerParamTypes = interfacesImplementedByDynamicProxy;
addListenerMethod = testResultClass.getMethod( ADD_LISTENER_METHOD, addListenerParamTypes );
if ( testInterface.isAssignableFrom( testClass ) )//testObject.getClass() ) )
{
countTestCasesMethod = testInterface.getMethod( COUNT_TEST_CASES_METHOD, EMPTY_CLASS_ARRAY );
runMethod = testInterface.getMethod( RUN_METHOD, new Class[]{testResultClass} );
}
else
{
countTestCasesMethod = testClass.getMethod( COUNT_TEST_CASES_METHOD, EMPTY_CLASS_ARRAY );
runMethod = testClass.getMethod( RUN_METHOD, new Class[]{testResultClass} );
}
}
catch ( ClassNotFoundException e )
{
throw new TestSetFailedException( "JUnit classes not available", e );
}
catch ( NoSuchMethodException e )
{
throw new TestSetFailedException( "Class is not a JUnit TestCase", e );
}
}
private static Object constructTestObject( Class testClass )
throws IllegalAccessException, InvocationTargetException, NoSuchMethodException, InstantiationException,
ClassNotFoundException
{
Object testObject = createInstanceFromSuiteMethod( testClass );
if ( testObject == null && testClass.getClassLoader().loadClass( TEST_CASE ).isAssignableFrom( testClass ) )
{
Class[] constructorParamTypes = {Class.class};
Constructor constructor =
testClass.getClassLoader().loadClass( TEST_SUITE ).getConstructor( constructorParamTypes );
Object[] constructorParams = {testClass};
testObject = constructor.newInstance( constructorParams );
}
if ( testObject == null )
{
Constructor testConstructor = getTestConstructor( testClass );
if ( testConstructor.getParameterTypes().length == 0 )
{
testObject = testConstructor.newInstance( EMPTY_OBJECT_ARRAY );
}
else
{
testObject = testConstructor.newInstance( new Object[]{testClass.getName()} );
}
}
return testObject;
}
private static Object createInstanceFromSuiteMethod( Class testClass )
throws IllegalAccessException, InvocationTargetException
{
Object testObject = null;
try
{
Method suiteMethod = testClass.getMethod( "suite", EMPTY_CLASS_ARRAY );
if ( Modifier.isPublic( suiteMethod.getModifiers() ) && Modifier.isStatic( suiteMethod.getModifiers() ) )
{
testObject = suiteMethod.invoke( null, EMPTY_CLASS_ARRAY );
}
}
catch ( NoSuchMethodException e )
{
// No suite method
}
return testObject;
}
public void execute( ReporterManager reportManager, ClassLoader loader )
throws TestSetFailedException
{
Class testClass = getTestClass();
try
{
Object testObject = constructTestObject( testClass );
Object instanceOfTestResult = testResultClass.newInstance();
TestListenerInvocationHandler invocationHandler =
new TestListenerInvocationHandler( reportManager, instanceOfTestResult, loader );
Object testListener =
Proxy.newProxyInstance( loader, interfacesImplementedByDynamicProxy, invocationHandler );
Object[] addTestListenerParams = {testListener};
addListenerMethod.invoke( instanceOfTestResult, addTestListenerParams );
Object[] runParams = {instanceOfTestResult};
runMethod.invoke( testObject, runParams );
}
catch ( IllegalArgumentException e )
{
throw new TestSetFailedException( testClass.getName(), e );
}
catch ( InstantiationException e )
{
throw new TestSetFailedException( testClass.getName(), e );
}
catch ( IllegalAccessException e )
{
throw new TestSetFailedException( testClass.getName(), e );
}
catch ( InvocationTargetException e )
{
throw new TestSetFailedException( testClass.getName(), e.getTargetException() );
}
catch ( ClassNotFoundException e )
{
throw new TestSetFailedException( "JUnit classes not available", e );
}
catch ( NoSuchMethodException e )
{
throw new TestSetFailedException( "Class is not a JUnit TestCase", e );
}
}
private static Constructor getTestConstructor( Class testClass )
throws NoSuchMethodException
{
Constructor constructor;
try
{
constructor = testClass.getConstructor( new Class[]{String.class} );
}
catch ( NoSuchMethodException e )
{
constructor = testClass.getConstructor( EMPTY_CLASS_ARRAY );
}
return constructor;
}
}
