Author: asanso
Date: Mon Oct 1 11:29:34 2012
New Revision: 1392281
URL: http://svn.apache.org/viewvc?rev=1392281&view=rev
Log:
SLING-2593 - Improvement for the Sling performance tools. adjusting formatting
in order to be Sling compliant
Modified:
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/FrameworkPerformanceMethod.java
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/ParameterizedTestList.java
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/PerformanceRunner.java
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/PerformanceSuiteState.java
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/ReportLogger.java
Modified:
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/FrameworkPerformanceMethod.java
URL:
http://svn.apache.org/viewvc/sling/trunk/performance/base/src/main/java/org/apache/sling/performance/FrameworkPerformanceMethod.java?rev=1392281&r1=1392280&r2=1392281&view=diff
==============================================================================
---
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/FrameworkPerformanceMethod.java
(original)
+++
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/FrameworkPerformanceMethod.java
Mon Oct 1 11:29:34 2012
@@ -34,249 +34,314 @@ import org.junit.Before;
import org.junit.runners.model.FrameworkMethod;
class FrameworkPerformanceMethod extends FrameworkMethod {
-
- private Object target;
- private PerformanceSuiteState performanceSuiteState;
-
- public FrameworkPerformanceMethod(Method method, Object target,
PerformanceSuiteState performanceSuiteState) {
- super(method);
- this.target = target;
- this.performanceSuiteState = performanceSuiteState;
-
- }
-
- @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();
-
- //System.out.println("Warmup started - test :" +
testMethodToInvoke.getName());
-
- 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.target.getClass().getName(),
this.performanceSuiteState.testSuiteName,
- getMethod().getName() , statistics,
ReportLogger.ReportType.TXT);
- }
-
- // 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[]{});
- }
-
-}
+ private Object target;
+ private PerformanceSuiteState performanceSuiteState;
+
+ public FrameworkPerformanceMethod(Method method, Object target,
+ PerformanceSuiteState performanceSuiteState) {
+ super(method);
+ this.target = target;
+ this.performanceSuiteState = performanceSuiteState;
+
+ }
+
+ @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();
+
+ // System.out.println("Warmup started - test :" +
+ // testMethodToInvoke.getName());
+
+ 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.target.getClass().getName(),
+
this.performanceSuiteState.testSuiteName,
+ getMethod().getName(),
statistics,
+
ReportLogger.ReportType.TXT);
+ }
+
+ // 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[] {});
+ }
+
+}
Modified:
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/ParameterizedTestList.java
URL:
http://svn.apache.org/viewvc/sling/trunk/performance/base/src/main/java/org/apache/sling/performance/ParameterizedTestList.java?rev=1392281&r1=1392280&r2=1392281&view=diff
==============================================================================
---
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/ParameterizedTestList.java
(original)
+++
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/ParameterizedTestList.java
Mon Oct 1 11:29:34 2012
@@ -22,19 +22,19 @@ import java.util.List;
import java.util.Map;
/**
- * Represents the object that will be returned by the method
- * in which a new PerformanceTestSuite is created
- *
+ * Represents the object that will be returned by the method in which a new
+ * PerformanceTestSuite is created
+ *
*/
public class ParameterizedTestList {
public static final String TEST_CASE_ONLY = "TESTCASEONLY";
-
+
private List<Object> testObjectList = new ArrayList<Object>();
private String testSuiteTitle = TEST_CASE_ONLY;
private Map<String, String> parameters = new LinkedHashMap<String,
String>();
private Map<String, Object> parametersObjects = new
LinkedHashMap<String, Object>();
-
+
public Map<String, Object> getParametersObjects() {
return parametersObjects;
}
@@ -42,23 +42,23 @@ public class ParameterizedTestList {
public void addParameterObject(String key, Object parameterObject) {
this.parametersObjects.put(key, parameterObject);
}
-
+
public Map<String, String> getParameters() {
return parameters;
}
-
+
public void addParameter(String key, String value) {
parameters.put(key, value);
}
-
+
public List<Object> getTestObjectList() {
return testObjectList;
}
-
+
public void addTestObject(Object testObject) {
testObjectList.add(testObject);
}
-
+
public String getTestSuiteName() {
return testSuiteTitle;
}
@@ -66,5 +66,5 @@ public class ParameterizedTestList {
public void setTestSuiteTitle(String testSuiteTitle) {
this.testSuiteTitle = testSuiteTitle;
}
-
+
}
Modified:
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/PerformanceRunner.java
URL:
http://svn.apache.org/viewvc/sling/trunk/performance/base/src/main/java/org/apache/sling/performance/PerformanceRunner.java?rev=1392281&r1=1392280&r2=1392281&view=diff
==============================================================================
---
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/PerformanceRunner.java
(original)
+++
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/PerformanceRunner.java
Mon Oct 1 11:29:34 2012
@@ -33,177 +33,197 @@ import org.junit.runners.BlockJUnit4Clas
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;
-
/**
* The custom JUnit runner that collects the performance tests
- *
+ *
*/
public class PerformanceRunner extends BlockJUnit4ClassRunner {
- protected LinkedList<FrameworkMethod> tests = new
LinkedList<FrameworkMethod>();
- private List<PerformanceSuiteState> suitesState = new
ArrayList<PerformanceSuiteState>();
-
-
- public PerformanceRunner(Class<?> clazz) throws InitializationError {
- super(clazz);
- try {
- computeTests();
- }
- catch (Exception e) {
- throw new InitializationError(e);
- }
- }
-
- /**
- * Compute the tests that will be run
- * @throws Exception
- */
- protected void computeTests() throws Exception {
- tests.addAll(super.computeTestMethods());
-
- // count the performance tests
- tests.addAll(computePerformanceTests());
-
- // This is called here to ensure the test class constructor is
called at least
- // once during testing.
- createTest();
- }
-
- /**
- * Compute performance tests
- * @return the list containing the performance test methods
- * @throws Exception
- */
- protected Collection<? extends FrameworkMethod>
computePerformanceTests() throws Exception {
- List<FrameworkPerformanceMethod> tests = new
LinkedList<FrameworkPerformanceMethod>();
-
- List<Object> testObjects = new ArrayList<Object>();
- ParameterizedTestList testCenter = new ParameterizedTestList();
-
- // Retrieve the test objects included in the Performance test
suite
- for (FrameworkMethod method:
getTestClass().getAnnotatedMethods(PerformanceTestSuite.class)) {
- Object targetObject =
getTestClass().getJavaClass().newInstance();
- if
(method.getMethod().getReturnType().equals(ParameterizedTestList.class)){
- testCenter = (ParameterizedTestList)
method.getMethod().invoke(targetObject);
- testObjects = testCenter.getTestObjectList();
- }
- else{
- throw new InitializationError("Wrong signature
for the @PerformanceSuite method");
- }
- }
-
- // Retrieve the methods before running the methods from the
test suite
- List<FrameworkMethod> beforeSuiteMethods =
getTestClass().getAnnotatedMethods(BeforeSuite.class);
- if (beforeSuiteMethods.size() > 1){
- throw new InitializationError("Only one @BeforeSuite
method is allowed for a @PerformanceSuite");
- }
-
- // Retrieve the methods before running the methods from the
test suite
- List<FrameworkMethod> afterSuiteMethods =
getTestClass().getAnnotatedMethods(AfterSuite.class);
- if (afterSuiteMethods.size() > 1){
- throw new InitializationError("Only one @AfterSuite
method is allowed for a @PerformanceSuite");
- }
-
- PerformanceSuiteState current = null;
- boolean suiteAlreadyRegistered = false;
-
- for(PerformanceSuiteState suiteState : suitesState){
- if
(suiteState.testSuiteName.equals(testCenter.getTestSuiteName())){
- suiteAlreadyRegistered = true;
-
suiteState.incrementNumberOfTestMethodsInSuite();
- current = suiteState;
- break;
- }
- }
-
- // Create a new PerformanceSuiteState object
- PerformanceSuiteState newSuite = new
PerformanceSuiteState(testCenter.getTestSuiteName());
-
- if (!suiteAlreadyRegistered){
- if (beforeSuiteMethods.size() == 1){
-
newSuite.setBeforeSuiteMethod(beforeSuiteMethods.get(0).getMethod());
- }
- if (afterSuiteMethods.size() == 1){
-
newSuite.setAfterSuiteMethod(afterSuiteMethods.get(0).getMethod());
- }
-
- current = newSuite;
-
newSuite.setTargetObjectSuite(getTestClass().getJavaClass().newInstance());
-
- }
-
-
- // In case there are any objects retrieved from the
Performance Suite
- // we should add them to the tests that will be run and
increase the number of methods
- // contained in the PerformaceSuite
- if (!testObjects.isEmpty()){
- for (Object testObject : testObjects){
- // retrieve the test methods from the test
classes
- Method[] testMethods =
getSpecificMethods(testObject.getClass(), PerformanceTest.class);
-
- if (!suiteAlreadyRegistered){
-
newSuite.incrementNumberOfTestMethodsInSuite();
- }
-
- for (Method method: testMethods){
- FrameworkPerformanceMethod
performaceTestMethod = new FrameworkPerformanceMethod(method, testObject,
current);
- tests.add(performaceTestMethod);
- }
- }
-
- // add the new suite to the list of suites
- suitesState.add(newSuite);
- }
-
- // Retrieve the performance tests in the case we don't have a
performance test suite
- for (FrameworkMethod method:
getTestClass().getAnnotatedMethods(PerformanceTest.class)) {
- Object targetObject =
getTestClass().getJavaClass().newInstance();
- FrameworkPerformanceMethod performaceTestMethod = new
FrameworkPerformanceMethod(method.getMethod(), targetObject, current);
- tests.add(performaceTestMethod);
- }
-
- return tests;
- }
-
-
- /**
- * Retrieve specific method 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[]{});
- }
-
- /**
- * {@inheritDoc}
- * @see org.junit.runners.BlockJUnit4ClassRunner#computeTestMethods()
- */
- @Override
- protected List<FrameworkMethod> computeTestMethods() {
- return tests;
- }
-
- /**
- * Need to override method otherwise the validation will fail because
of some
- * hardcoded conditions in JUnit
- */
- @Override
- protected void validateInstanceMethods(List<Throwable> errors) {
- validatePublicVoidNoArgMethods(After.class, false, errors);
- validatePublicVoidNoArgMethods(Before.class, false, errors);
- validateTestMethods(errors);
- }
-
-
+ protected LinkedList<FrameworkMethod> tests = new
LinkedList<FrameworkMethod>();
+ private List<PerformanceSuiteState> suitesState = new
ArrayList<PerformanceSuiteState>();
+
+ public PerformanceRunner(Class<?> clazz) throws InitializationError {
+ super(clazz);
+ try {
+ computeTests();
+ } catch (Exception e) {
+ throw new InitializationError(e);
+ }
+ }
+
+ /**
+ * Compute the tests that will be run
+ *
+ * @throws Exception
+ */
+ protected void computeTests() throws Exception {
+ tests.addAll(super.computeTestMethods());
+
+ // count the performance tests
+ tests.addAll(computePerformanceTests());
+
+ // This is called here to ensure the test class constructor is
called at
+ // least
+ // once during testing.
+ createTest();
+ }
+
+ /**
+ * Compute performance tests
+ *
+ * @return the list containing the performance test methods
+ * @throws Exception
+ */
+ protected Collection<? extends FrameworkMethod>
computePerformanceTests()
+ throws Exception {
+ List<FrameworkPerformanceMethod> tests = new
LinkedList<FrameworkPerformanceMethod>();
+
+ List<Object> testObjects = new ArrayList<Object>();
+ ParameterizedTestList testCenter = new ParameterizedTestList();
+
+ // Retrieve the test objects included in the Performance test
suite
+ for (FrameworkMethod method :
getTestClass().getAnnotatedMethods(
+ PerformanceTestSuite.class)) {
+ Object targetObject =
getTestClass().getJavaClass().newInstance();
+ if (method.getMethod().getReturnType()
+ .equals(ParameterizedTestList.class)) {
+ testCenter = (ParameterizedTestList)
method.getMethod().invoke(
+ targetObject);
+ testObjects = testCenter.getTestObjectList();
+ } else {
+ throw new InitializationError(
+ "Wrong signature for the
@PerformanceSuite method");
+ }
+ }
+
+ // Retrieve the methods before running the methods from the
test suite
+ List<FrameworkMethod> beforeSuiteMethods = getTestClass()
+ .getAnnotatedMethods(BeforeSuite.class);
+ if (beforeSuiteMethods.size() > 1) {
+ throw new InitializationError(
+ "Only one @BeforeSuite method is
allowed for a @PerformanceSuite");
+ }
+
+ // Retrieve the methods before running the methods from the
test suite
+ List<FrameworkMethod> afterSuiteMethods = getTestClass()
+ .getAnnotatedMethods(AfterSuite.class);
+ if (afterSuiteMethods.size() > 1) {
+ throw new InitializationError(
+ "Only one @AfterSuite method is allowed
for a @PerformanceSuite");
+ }
+
+ PerformanceSuiteState current = null;
+ boolean suiteAlreadyRegistered = false;
+
+ for (PerformanceSuiteState suiteState : suitesState) {
+ if
(suiteState.testSuiteName.equals(testCenter.getTestSuiteName())) {
+ suiteAlreadyRegistered = true;
+
suiteState.incrementNumberOfTestMethodsInSuite();
+ current = suiteState;
+ break;
+ }
+ }
+
+ // Create a new PerformanceSuiteState object
+ PerformanceSuiteState newSuite = new PerformanceSuiteState(
+ testCenter.getTestSuiteName());
+
+ if (!suiteAlreadyRegistered) {
+ if (beforeSuiteMethods.size() == 1) {
+
newSuite.setBeforeSuiteMethod(beforeSuiteMethods.get(0)
+ .getMethod());
+ }
+ if (afterSuiteMethods.size() == 1) {
+
newSuite.setAfterSuiteMethod(afterSuiteMethods.get(0)
+ .getMethod());
+ }
+
+ current = newSuite;
+
newSuite.setTargetObjectSuite(getTestClass().getJavaClass()
+ .newInstance());
+
+ }
+
+ // In case there are any objects retrieved from the Performance
Suite
+ // we should add them to the tests that will be run and
increase the
+ // number of methods
+ // contained in the PerformaceSuite
+ if (!testObjects.isEmpty()) {
+ for (Object testObject : testObjects) {
+ // retrieve the test methods from the test
classes
+ Method[] testMethods = getSpecificMethods(
+ testObject.getClass(),
PerformanceTest.class);
+
+ if (!suiteAlreadyRegistered) {
+
newSuite.incrementNumberOfTestMethodsInSuite();
+ }
+
+ for (Method method : testMethods) {
+ FrameworkPerformanceMethod
performaceTestMethod = new FrameworkPerformanceMethod(
+ method, testObject,
current);
+ tests.add(performaceTestMethod);
+ }
+ }
+
+ // add the new suite to the list of suites
+ suitesState.add(newSuite);
+ }
+
+ // Retrieve the performance tests in the case we don't have a
+ // performance test suite
+ for (FrameworkMethod method :
getTestClass().getAnnotatedMethods(
+ PerformanceTest.class)) {
+ Object targetObject =
getTestClass().getJavaClass().newInstance();
+ FrameworkPerformanceMethod performaceTestMethod = new
FrameworkPerformanceMethod(
+ method.getMethod(), targetObject,
current);
+ tests.add(performaceTestMethod);
+ }
+
+ return tests;
+ }
+
+ /**
+ * Retrieve specific method 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[] {});
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.junit.runners.BlockJUnit4ClassRunner#computeTestMethods()
+ */
+ @Override
+ protected List<FrameworkMethod> computeTestMethods() {
+ return tests;
+ }
+
+ /**
+ * Need to override method otherwise the validation will fail because of
+ * some hardcoded conditions in JUnit
+ */
+ @Override
+ protected void validateInstanceMethods(List<Throwable> errors) {
+ validatePublicVoidNoArgMethods(After.class, false, errors);
+ validatePublicVoidNoArgMethods(Before.class, false, errors);
+ validateTestMethods(errors);
+ }
+
}
Modified:
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/PerformanceSuiteState.java
URL:
http://svn.apache.org/viewvc/sling/trunk/performance/base/src/main/java/org/apache/sling/performance/PerformanceSuiteState.java?rev=1392281&r1=1392280&r2=1392281&view=diff
==============================================================================
---
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/PerformanceSuiteState.java
(original)
+++
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/PerformanceSuiteState.java
Mon Oct 1 11:29:34 2012
@@ -21,25 +21,25 @@ import java.lang.reflect.Method;
public class PerformanceSuiteState {
public String testSuiteName = ParameterizedTestList.TEST_CASE_ONLY;
-
+
private Method beforeSuiteMethod;
private Method afterSuiteMethod;
private int numberOfMethodsInSuite = 0;
private int numberOfExecutedMethods = 0;
private Object targetObjectSuite;
-
- public PerformanceSuiteState(String testSuiteName){
+
+ public PerformanceSuiteState(String testSuiteName) {
this.testSuiteName = testSuiteName;
}
-
- public void incrementNumberOfTestMethodsInSuite(){
+
+ public void incrementNumberOfTestMethodsInSuite() {
numberOfMethodsInSuite++;
}
-
- public void incrementNumberOfExecutedTestMethods(){
+
+ public void incrementNumberOfExecutedTestMethods() {
numberOfExecutedMethods++;
}
-
+
public String getTestSuiteName() {
return testSuiteName;
}
@@ -87,5 +87,5 @@ public class PerformanceSuiteState {
public void setTargetObjectSuite(Object targetObjectSuite) {
this.targetObjectSuite = targetObjectSuite;
}
-
+
}
Modified:
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/ReportLogger.java
URL:
http://svn.apache.org/viewvc/sling/trunk/performance/base/src/main/java/org/apache/sling/performance/ReportLogger.java?rev=1392281&r1=1392280&r2=1392281&view=diff
==============================================================================
---
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/ReportLogger.java
(original)
+++
sling/trunk/performance/base/src/main/java/org/apache/sling/performance/ReportLogger.java
Mon Oct 1 11:29:34 2012
@@ -12,85 +12,89 @@ import org.apache.commons.math.stat.desc
public class ReportLogger {
- public enum ReportType{
+ public enum ReportType {
TXT, XML
}
-
-
- public static void writeReport(String test, String testSuiteName,
String name, DescriptiveStatistics statistics, ReportType reportType) throws
Exception{
- switch(reportType){
+
+ public static void writeReport(String test, String testSuiteName,
+ String name, DescriptiveStatistics statistics,
ReportType reportType)
+ throws Exception {
+ switch (reportType) {
case TXT:
writeReportTxt(test, testSuiteName, name, statistics);
break;
case XML:
throw new Exception("The XML reporting format is not
yet supported");
default:
- throw new Exception("The specified reporting format is
not yet supported");
+ throw new Exception(
+ "The specified reporting format is not
yet supported");
}
}
-
+
/**
- * Method the writes the performance report after a test is run
- * @param test the test name
- * @param name the name that will be listed in the report
- * @param statistics the statistics data to be written
- * @throws IOException
- */
- public static void writeReportTxt(String test, String testSuiteName,
String name, DescriptiveStatistics statistics)
- throws IOException {
-
- String className=test;
-
className=className.substring(className.lastIndexOf(".")+1);
-
- File reportDir = new File("target/performance-reports");
- if (!reportDir.exists()){
- boolean test1 = reportDir.mkdir();
- }
-
- File report = new File("target/performance-reports",
className + ".txt");
-
- // need this in the case a user wants to set the suite
name from the command line
- // useful if we run the test cases from the command
line for example
- // by using maven
- if
(testSuiteName.equals(ParameterizedTestList.TEST_CASE_ONLY)){
- if (System.getenv("testsuitename") != null){
- testSuiteName =
System.getenv("testsuitename");
- }
- }
-
- boolean needsPrefix = !report.exists();
- PrintWriter writer = new PrintWriter(
- new FileWriterWithEncoding(report, "UTF-8",
true));
- try {
- if (needsPrefix) {
- writer.format(
- "# %-34.34s min 10%% 50%% 90%%
max%n",
- className);
- }
-
- writer.format(
- "%-36.36s %6.0f %6.0f %6.0f %6.0f %6.0f%n",
- testSuiteName,
- statistics.getMin(),
- statistics.getPercentile(10.0),
- statistics.getPercentile(50.0),
- statistics.getPercentile(90.0),
- statistics.getMax());
- } finally {
- writer.close();
- }
- }
-
-
- /**
- * Get the date that will be written into the result file
- * @return
- */
- private static String getDate(){
+ * Method the writes the performance report after a test is run
+ *
+ * @param test
+ * the test name
+ * @param name
+ * the name that will be listed in the report
+ * @param statistics
+ * the statistics data to be written
+ * @throws IOException
+ */
+ public static void writeReportTxt(String test, String testSuiteName,
+ String name, DescriptiveStatistics statistics) throws
IOException {
+
+ String className = test;
+ className = className.substring(className.lastIndexOf(".") + 1);
+
+ File reportDir = new File("target/performance-reports");
+ if (!reportDir.exists()) {
+ boolean test1 = reportDir.mkdir();
+ }
+
+ File report = new File("target/performance-reports", className
+ ".txt");
+
+ // need this in the case a user wants to set the suite name
from the
+ // command line
+ // useful if we run the test cases from the command line for
example
+ // by using maven
+ if (testSuiteName.equals(ParameterizedTestList.TEST_CASE_ONLY))
{
+ if (System.getenv("testsuitename") != null) {
+ testSuiteName = System.getenv("testsuitename");
+ }
+ }
+
+ boolean needsPrefix = !report.exists();
+ PrintWriter writer = new PrintWriter(new
FileWriterWithEncoding(report,
+ "UTF-8", true));
+ try {
+ if (needsPrefix) {
+ writer.format(
+ "# %-34.34s min 10%%
50%% 90%% max%n",
+ className);
+ }
+
+ writer.format("%-36.36s %6.0f %6.0f %6.0f %6.0f
%6.0f%n",
+ testSuiteName, statistics.getMin(),
+ statistics.getPercentile(10.0),
+ statistics.getPercentile(50.0),
+ statistics.getPercentile(90.0),
statistics.getMax());
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * Get the date that will be written into the result file
+ *
+ * @return
+ */
+ private static String getDate() {
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd
HH:mm:ss");
Date date = new Date();
return dateFormat.format(date);
}
-
+
}
