protected Collection computePerformanceTests()

in base/src/main/java/org/apache/sling/performance/PerformanceRunner.java [147:284]
96 lines of code
20 McCabe index (conditional complexity)

    protected Collection<? extends FrameworkMethod> computePerformanceTests()
            throws Exception {
        List<FrameworkMethod> tests = new LinkedList<FrameworkMethod>();

        List<Object> testObjects = new ArrayList<Object>();
        List<Object> testObjectsTmp = 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);
                testObjectsTmp = testCenter.getTestObjectList();

                // Iterate through all the test cases and see if they have a factory
                for (Object testObject : testObjectsTmp) {
                    Method[] factoryMethods = getSpecificMethods(
                            testObject.getClass(), PerformanceTestFactory.class);

                    // If we have a factory method, get all the instance objects returned by this factory
                    if (factoryMethods.length > 0) {
                        // Make sure there's only one factory method
                        if (factoryMethods.length > 1) {
                            throw new IllegalStateException(
                                    "There should be at most one PerformanceTestFactory method");
                        }
                        Method factoryMethod = factoryMethods[0];

                        // Execute the method (statically)
                        Object instances = factoryMethod.invoke(testObject);

                        // If the factory returned an array, make a list
                        if (instances.getClass().isArray()) {
                            instances = Arrays.asList((Object[]) instances);
                        }

                        // If the factory returned a single element, put it in a list
                        if (!(instances instanceof Iterable<?>)) {
                            instances = Collections.singletonList(instances);
                        }
                        testObjects.addAll((List) instances);
                    } else {
                        testObjects.add(testObject);
                    }
                }
            } else {
                throw new InitializationError(
                        "Wrong signature for the @PerformanceTestSuite 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 PerformanceSuite
        if (!testObjects.isEmpty()) {
            for (Object testObject : testObjects) {

                // retrieve the test methods from the test classes
                Method[] testMethods = getSpecificMethods(testObject.getClass(), PerformanceTest.class);

                for (Method method : testMethods) {
                    FrameworkPerformanceMethod performaceTestMethod =
                            new FrameworkPerformanceMethod(method, testObject, current, reportLevel, referenceMethod);
                    tests.add(performaceTestMethod);
                }

                if (!suiteAlreadyRegistered) {
                    newSuite.incrementNumberOfTestMethodsInSuite();
                }
            }

            // 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 performanceTestMethod = new FrameworkPerformanceMethod(
                    method.getMethod(), targetObject, current, reportLevel, referenceMethod);
            tests.add(performanceTestMethod);
        }

        return tests;
    }