/*
* 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.
*/
package org.apache.sling.performance;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import javax.naming.directory.InvalidAttributesException;
import org.apache.commons.math.stat.descriptive.DescriptiveStatistics;
import org.apache.sling.performance.annotation.AfterMethodInvocation;
import org.apache.sling.performance.annotation.BeforeMethodInvocation;
import org.apache.sling.performance.annotation.PerformanceTest;
import org.junit.After;
import org.junit.Before;
import org.junit.runners.model.FrameworkMethod;
class FrameworkPerformanceMethod extends FrameworkMethod {
private Object target;
private PerformanceSuiteState performanceSuiteState;
private PerformanceRunner.ReportLevel reportLevel = PerformanceRunner.ReportLevel.ClassLevel;
private String testCaseName = "";
private String className;
public FrameworkPerformanceMethod(Method method, Object target,
PerformanceSuiteState performanceSuiteState, PerformanceRunner.ReportLevel reportLevel) {
super(method);
this.target = target;
this.performanceSuiteState = performanceSuiteState;
this.reportLevel = reportLevel;
if (target instanceof IdentifiableTestCase) {
this.testCaseName = ((IdentifiableTestCase) target).testCaseName();
}
// Name of the test class, as the report logger needs it
// This can be overwritten by tests by implementing IdentifiableTestClass
String longClassName = this.target.getClass().getName();
className = longClassName.substring(longClassName.lastIndexOf(".") + 1);
if (target instanceof IdentifiableTestClass) {
this.className = ((IdentifiableTestClass) target).testClassName();
}
}
@Override
public Object invokeExplosively(Object target, Object... params)
throws Throwable {
// Executes the test method on the supplied target
// Check if this is the first test running from this specific
// PerformanceSuite
// and run the BeforeSuite methods
if ((performanceSuiteState != null)
&& (performanceSuiteState.getBeforeSuiteMethod() != null)
&& (performanceSuiteState.getTargetObjectSuite() != null)
&& (performanceSuiteState.getNumberOfExecutedMethods() == 0)
&& !performanceSuiteState.testSuiteName
.equals(ParameterizedTestList.TEST_CASE_ONLY)) {
performanceSuiteState.getBeforeSuiteMethod().invoke(
performanceSuiteState.getTargetObjectSuite());
}
// In case of a PerformanceSuite we need to run the methods annotated
// with Before and After
// ourselves as JUnit can't find them (JUnit is looking for them in the
// test suite class);
// in case we don't have to deal with a PerformanceSuite just skip this
// as JUnit will run the methods itself
if ((performanceSuiteState != null)
&& !performanceSuiteState.testSuiteName.equals(ParameterizedTestList.TEST_CASE_ONLY)) {
recursiveCallSpecificMethod(this.target.getClass(), this.target, Before.class);
}
// Need to count the number of tests run from the PerformanceSuite
// so that we can call the AfterSuite method after the last test from
// the suite
// has run and the AfterSuite needs to run
performanceSuiteState.incrementNumberOfExecutedTestMethods();
Object response = null;
Method testMethodToInvoke = this.getMethod();
PerformanceTest performanceAnnotation = testMethodToInvoke
.getAnnotation(PerformanceTest.class);
// retrieve the test configuration options
int warmuptime = performanceAnnotation.warmuptime();
int runtime = performanceAnnotation.runtime();
int warmupinvocations = performanceAnnotation.warmupinvocations();
int runinvocations = performanceAnnotation.runinvocations();
DescriptiveStatistics statistics = new DescriptiveStatistics();
if (warmupinvocations != 0) {
// Run the number of invocation specified in the annotation
// for warming up the system
for (int invocationIndex = 0; invocationIndex < warmupinvocations; invocationIndex++) {
recursiveCallSpecificMethod(this.target.getClass(), this.target, BeforeMethodInvocation.class);
// TODO: implement the method to run a before a specific test
// method
// recursiveCallSpecificMethod(this.target.getClass(),
// this.target, BeforeSpecificTest.class);
response = super.invokeExplosively(this.target, params);
// TODO: implement the method to run a after a specific test
// method
// recursiveCallSpecificMethod(this.target.getClass(),
// this.target, AfterSpecificTest.class);
recursiveCallSpecificMethod(this.target.getClass(),
this.target, AfterMethodInvocation.class);
}
} else {
// Run a few iterations to warm up the system
long warmupEnd = System.currentTimeMillis() + warmuptime * 1000;
while (System.currentTimeMillis() < warmupEnd) {
recursiveCallSpecificMethod(this.target.getClass(),
this.target, BeforeMethodInvocation.class);
// TODO: implement the method to run a before a specific test
// method
// recursiveCallSpecificMethod(this.target.getClass(),
// this.target, BeforeSpecificTest.class);
response = super.invokeExplosively(this.target, params);
// recursiveCallSpecificMethod(this.target.getClass(),
// this.target, AfterSpecificTest.class);
// TODO: implement the method to run a after a specific test
// method
recursiveCallSpecificMethod(this.target.getClass(),
this.target, AfterMethodInvocation.class);
}
}
// System.out.println("Warmup ended - test :" +
// testMethodToInvoke.getName());
if (runinvocations != 0) {
// Run the specified number of iterations and capture the execution
// times
for (int invocationIndex = 0; invocationIndex < runinvocations; invocationIndex++) {
response = this.invokeTimedTestMethod(testMethodToInvoke,
statistics, params);
}
} else {
// Run test iterations and capture the execution times
long runtimeEnd = System.currentTimeMillis() + runtime * 1000;
while (System.currentTimeMillis() < runtimeEnd) {
response = this.invokeTimedTestMethod(testMethodToInvoke,
statistics, params);
}
}
if (statistics.getN() > 0) {
ReportLogger.writeReport(this.performanceSuiteState.testSuiteName, testCaseName, className, getMethod().getName(),
statistics, ReportLogger.ReportType.TXT, reportLevel);
}
// In case of a PerformanceSuite we need to run the methods annotated
// with Before and After
// ourselves as JUnit can't find them; in case we don't have to deal
// with a PerformanceSuite
// just skip this as JUnit will run the methods itself
if ((performanceSuiteState != null)
&& !performanceSuiteState.testSuiteName.equals(ParameterizedTestList.TEST_CASE_ONLY)) {
recursiveCallSpecificMethod(this.target.getClass(), this.target, After.class);
}
// Check if this is the last test running from a PerformanceSuite
// and run the AfterSuite method
if ((performanceSuiteState != null)
&& (performanceSuiteState.getAfterSuiteMethod() != null)
&& (performanceSuiteState.getTargetObjectSuite() != null)
&& (performanceSuiteState.getNumberOfExecutedMethods() == performanceSuiteState.getNumberOfMethodsInSuite())
&& !performanceSuiteState.testSuiteName.equals(ParameterizedTestList.TEST_CASE_ONLY)) {
performanceSuiteState.getAfterSuiteMethod().invoke(performanceSuiteState.getTargetObjectSuite());
}
return response;
}
/**
* Method that runs 1 invocation of the timed test method
*
* @param testMethodToInvoke
* the test method to invoke
* @param statistics
* the statistics object that collects the results
* @param params
* the parameters for the invocation of the test method
* @return the response from the method invocation
* @throws Throwable
*/
private Object invokeTimedTestMethod(Method testMethodToInvoke,
DescriptiveStatistics statistics, Object... params)
throws Throwable {
Object response = null;
recursiveCallSpecificMethod(this.target.getClass(), this.target,
BeforeMethodInvocation.class);
// TODO: implement the method to run a before a specific test method
// recursiveCallSpecificMethod(this.target.getClass(), this.target,
// BeforeSpecificTest.class);
// timing the test method execution
// System.out.println("Start test: " + testMethodToInvoke.getName());
long start = System.nanoTime();
response = super.invokeExplosively(this.target, params);
long timeMilliseconds = TimeUnit.MILLISECONDS.convert(System.nanoTime() - start, TimeUnit.NANOSECONDS);
statistics.addValue(timeMilliseconds);
// System.out.println("End test: " + testMethodToInvoke.getName());
// System.out.println("Test execution time (ms): " + timeMilliseconds);
// TODO: implement the method to run a after a specific test method
// recursiveCallSpecificMethod(this.target.getClass(), this.target,
// AfterSpecificTest.class);
recursiveCallSpecificMethod(this.target.getClass(), this.target, AfterMethodInvocation.class);
return response;
}
/**
* Recursively call a specific method annotated with a custom annotation
*
* @param test
* the test class that contains the method
* @param instance
* the instance on which will run the method
* @param methodAnnotation
* the method annotation to look for
* @throws InvocationTargetException
* @throws InvalidAttributesException
* @throws IllegalAccessException
* @throws InstantiationException
*/
@SuppressWarnings({ "rawtypes" })
private void recursiveCallSpecificMethod(Class test, Object instance,
Class<? extends Annotation> methodAnnotation)
throws InvocationTargetException, InvalidAttributesException,
IllegalAccessException, InstantiationException {
if (test.getSuperclass() != null) {
recursiveCallSpecificMethod(test.getSuperclass(), instance,
methodAnnotation);
}
Method testMethod = getSpecificTestMethod(test, methodAnnotation);
if (testMethod != null) {
if (!testMethod.isAccessible()) {
testMethod.setAccessible(true);
}
testMethod.invoke(instance);
}
}
/**
* Get the method annotated with the custom annotation
*
* @param testClass
* the test class on which to look for the method
* @param methodAnnotation
* the method annotation to look for
* @return
* @throws InvalidAttributesException
* @throws IllegalAccessException
* @throws InstantiationException
*/
@SuppressWarnings({ "rawtypes" })
private Method getSpecificTestMethod(Class testClass,
Class<? extends Annotation> methodAnnotation)
throws InvalidAttributesException, IllegalAccessException,
InstantiationException {
Method[] methodsToReturn = getSpecificMethods(testClass, methodAnnotation);
Method methodToReturn = null;
if (methodsToReturn.length == 1) {
methodToReturn = methodsToReturn[0];
} else if (methodsToReturn.length > 1) {
throw new InvalidAttributesException("Only 1 non parameterized before method accepted");
}
return methodToReturn;
}
/**
* Retrieve all the specific methods from test class
*
* @param testClass
* the test class that we need to search in
* @param annotation
* the annotation that we should look for
* @return the list with the methods that have the specified annotation
*/
@SuppressWarnings({ "rawtypes" })
private Method[] getSpecificMethods(Class testClass,
Class<? extends Annotation> annotation) {
Method[] allMethods = testClass.getDeclaredMethods();
List<Method> methodListResult = new ArrayList<Method>();
for (Method testMethod : allMethods) {
if (testMethod.isAnnotationPresent(annotation)) {
methodListResult.add(testMethod);
}
}
return methodListResult.toArray(new Method[] {});
}
@Override
public String getName() {
if (testCaseName == null || "".equals(testCaseName.trim())) { return super.getName(); }
return String.format("%s [%s.%s]", testCaseName, target.getClass().getSimpleName(),
getMethod().getName());
}
}