Revert "Add logging to uitest module TB test fails. (#12249)" (#12255)

This reverts commit 8c39731123b56ef5fa08a614b9aa1b55bd53e5cc.

1 files changed, 0 insertions, 534 deletions

diff --git a/uitest/src/test/java/com/vaadin/testbench/parallel/ParallelRunner.java b/uitest/src/test/java/com/vaadin/testbench/parallel/ParallelRunner.java
deleted file mode 100644
index dac2dcce29..0000000000
--- a/uitest/src/test/java/com/vaadin/testbench/parallel/ParallelRunner.java
+++ /dev/null
@@ -1,534 +0,0 @@
-/**
- * Copyright (C) 2012 Vaadin Ltd
- *
- * This program is available under Commercial Vaadin Add-On License 3.0
- * (CVALv3).
- *
- * See the file licensing.txt distributed with this software for more
- * information about licensing.
- *
- * You should have received a copy of the license along with this program.
- * If not, see <http://vaadin.com/license/cval-3>.
- */
-
-package com.vaadin.testbench.parallel;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import org.junit.Ignore;
-import org.junit.Test;
-import org.junit.runners.BlockJUnit4ClassRunner;
-import org.junit.runners.Parameterized;
-import org.junit.runners.model.FrameworkMethod;
-import org.junit.runners.model.InitializationError;
-import org.junit.runners.model.Statement;
-import org.openqa.selenium.Capabilities;
-import org.openqa.selenium.remote.DesiredCapabilities;
-
-import com.vaadin.testbench.Parameters;
-import com.vaadin.testbench.annotations.BrowserConfiguration;
-import com.vaadin.testbench.annotations.BrowserFactory;
-import com.vaadin.testbench.annotations.RunLocally;
-
-/**
- * NOTE: The compatibility of this overridden class must be checked if TestBench
- * version is ever upgraded from 5.2.0.
- * <p>
- * Initial commit contains changes to {@link TBMethod#invokeExplosively}
- * <p>
- * <br>
- * This runner is loosely based on FactoryTestRunner by Ted Young
- * (http://tedyoung.me/2011/01/23/junit-runtime-tests-custom-runners/). The
- * generated test names give information about the parameters used (unlike
- * {@link Parameterized}).
- */
-public class ParallelRunner extends BlockJUnit4ClassRunner {
-
-    private static Logger logger = Logger
-            .getLogger(ParallelRunner.class.getName());
-
-    /**
-     * This is the total limit of actual JUnit test instances run in parallel
-     */
-    private static final int MAX_CONCURRENT_TESTS;
-
-    /**
-     * This is static so it is shared by all tests running concurrently on the
-     * same machine and thus can limit the number of threads in use.
-     */
-    private static final ExecutorService service;
-
-    static {
-        MAX_CONCURRENT_TESTS = Parameters.getMaxThreads();
-        service = Executors.newFixedThreadPool(MAX_CONCURRENT_TESTS);
-    }
-
-    public ParallelRunner(Class<?> klass) throws InitializationError {
-        super(klass);
-        setScheduler(new ParallelScheduler(service));
-    }
-
-    @Override
-    protected List<FrameworkMethod> computeTestMethods() {
-        List<FrameworkMethod> tests = new LinkedList<>();
-
-        if (!ParallelTest.class
-                .isAssignableFrom(getTestClass().getJavaClass())) {
-            throw new RuntimeException(getClass().getName() + " only supports "
-                    + ParallelTest.class.getName());
-        }
-
-        BrowserUtil.setBrowserFactory(getBrowserFactory());
-        try {
-            Collection<DesiredCapabilities> desiredCapabilities = getDesiredCapabilities();
-
-            TestNameSuffix testNameSuffixProperty = findAnnotation(
-                    getTestClass().getJavaClass(), TestNameSuffix.class);
-
-            for (FrameworkMethod m : getTestMethods()) {
-                // No browsers available for this test, so we need to
-                // wrap the test method inside IgnoredTestMethod.
-                // This will add @Ignore annotation to it.
-                if (desiredCapabilities.size() <= 0
-                        || categoryIsExcludedOrNotExcplicitlyIncluded()) {
-                    tests.add(new IgnoredTestMethod(m.getMethod()));
-                } else {
-                    for (DesiredCapabilities capabilities : desiredCapabilities) {
-                        TBMethod method = new TBMethod(m.getMethod(),
-                                capabilities);
-                        if (testNameSuffixProperty != null) {
-                            method.setTestNameSuffix("-" + System.getProperty(
-                                    testNameSuffixProperty.property()));
-                        }
-                        tests.add(method);
-                    }
-                }
-            }
-        } catch (Exception e) {
-            throw new RuntimeException("Error retrieving browsers to run on",
-                    e);
-        }
-
-        return tests;
-    }
-
-    private boolean categoryIsExcludedOrNotExcplicitlyIncluded() {
-        Class<?> c = getTestClass().getJavaClass();
-
-        if (categoryIsExcluded(c)) {
-            return true;
-        }
-
-        if (explicitInclusionIsUsed()) {
-            return !categoryIsIncluded(c);
-        }
-
-        return false;
-    }
-
-    private boolean categoryIsIncluded(Class<?> c) {
-        String include = System.getProperty("categories.include");
-        if (include != null && include.trim().length() > 0) {
-            return hasCategoryFor(c, include.toLowerCase().trim());
-        }
-
-        return false;
-    }
-
-    private static boolean explicitInclusionIsUsed() {
-        String include = System.getProperty("categories.include");
-
-        return include != null && include.trim().length() > 0;
-    }
-
-    private static boolean categoryIsExcluded(Class<?> c) {
-        String exclude = System.getProperty("categories.exclude");
-        if (exclude != null && exclude.trim().length() > 0) {
-            return hasCategoryFor(c, exclude.toLowerCase().trim());
-        }
-
-        return false;
-    }
-
-    private static boolean hasCategoryFor(Class<?> c, String searchString) {
-        if (hasCategory(c)) {
-            return searchString.contains(getCategory(c).toLowerCase());
-        }
-
-        return false;
-    }
-
-    private static boolean hasCategory(Class<?> c) {
-        return c.getAnnotation(TestCategory.class) != null;
-    }
-
-    private static String getCategory(Class<?> c) {
-        return c.getAnnotation(TestCategory.class).value();
-    }
-
-    private List<FrameworkMethod> getTestMethods() {
-        return getTestClass().getAnnotatedMethods(Test.class);
-    }
-
-    /*
-     * Returns a list of desired browser capabilities according to browsers
-     * defined in the test class, filtered by possible filter parameters. Use
-     * {@code @RunLocally} annotation or com.vaadin.testbench.runLocally
-     * property to override all capabilities.
-     */
-    private Collection<DesiredCapabilities> getDesiredCapabilities() {
-        if (testRunsLocally()) {
-            Collection<DesiredCapabilities> desiredCapabilities = new ArrayList<>();
-            Class<?> javaTestClass = getTestClass().getJavaClass();
-            desiredCapabilities.add(BrowserUtil.getBrowserFactory().create(
-                    getRunLocallyBrowserName(javaTestClass),
-                    getRunLocallyBrowserVersion(javaTestClass)));
-            return desiredCapabilities;
-        } else {
-            return getFilteredCapabilities();
-        }
-    }
-
-    private boolean testRunsLocally() {
-        if (Parameters.getRunLocallyBrowserName() != null) {
-            return true;
-        }
-
-        RunLocally runLocally = getTestClass().getJavaClass()
-                .getAnnotation(RunLocally.class);
-        if (runLocally == null) {
-            return false;
-        }
-        return true;
-    }
-
-    static Browser getRunLocallyBrowserName(Class<?> testClass) {
-
-        String runLocallyBrowserName = Parameters.getRunLocallyBrowserName();
-        if (runLocallyBrowserName != null) {
-            return Browser.valueOf(runLocallyBrowserName.toUpperCase());
-        }
-        RunLocally runLocally = testClass.getAnnotation(RunLocally.class);
-        if (runLocally == null) {
-            return null;
-        }
-        return runLocally.value();
-    }
-
-    static String getRunLocallyBrowserVersion(Class<?> testClass) {
-        String runLocallyBrowserVersion = Parameters
-                .getRunLocallyBrowserVersion();
-        if (runLocallyBrowserVersion != null) {
-            return runLocallyBrowserVersion;
-        }
-
-        RunLocally runLocally = testClass.getAnnotation(RunLocally.class);
-        if (runLocally == null) {
-            return "";
-        }
-        return runLocally.version();
-    }
-
-    private TestBenchBrowserFactory getBrowserFactory() {
-        BrowserFactory browserFactoryAnnotation = getTestClass().getJavaClass()
-                .getAnnotation(BrowserFactory.class);
-
-        try {
-            if (browserFactoryAnnotation != null
-                    && TestBenchBrowserFactory.class.isAssignableFrom(
-                            browserFactoryAnnotation.value())) {
-                return (TestBenchBrowserFactory) browserFactoryAnnotation
-                        .value().newInstance();
-            }
-        } catch (Exception e) {
-        }
-
-        return new DefaultBrowserFactory();
-    }
-
-    /*
-     * Takes the desired browser capabilities defined in the test class and
-     * returns a list of browser capabilities filtered browsers.include and
-     * browsers.exclude system properties. (if present)
-     */
-    private Collection<DesiredCapabilities> getFilteredCapabilities() {
-
-        Collection<DesiredCapabilities> desiredCapabilites = getBrowsersConfiguration();
-
-        ArrayList<DesiredCapabilities> filteredCapabilities = new ArrayList<>();
-
-        String include = System.getProperty("browsers.include");
-        String exclude = System.getProperty("browsers.exclude");
-
-        for (DesiredCapabilities d : desiredCapabilites) {
-            String browserName = (d.getBrowserName() + d.getVersion())
-                    .toLowerCase();
-            if (include != null && include.trim().length() > 0) {
-                if (include.trim().toLowerCase().contains(browserName)) {
-                    filteredCapabilities.add(d);
-                }
-            } else {
-                filteredCapabilities.add(d);
-            }
-
-            if (exclude != null && exclude.trim().length() > 0) {
-                if (exclude.trim().toLowerCase().contains(browserName)) {
-                    filteredCapabilities.remove(d);
-                }
-            }
-
-        }
-        return filteredCapabilities;
-    }
-
-    private Collection<DesiredCapabilities> getBrowsersConfiguration() {
-
-        Class<?> klass = getTestClass().getJavaClass();
-
-        while (klass != null) {
-            Method[] declaredMethods = klass.getDeclaredMethods();
-            for (Method method : declaredMethods) {
-                // TODO if already found one annotated method in class, warn
-                // user?
-
-                if (method.isAnnotationPresent(BrowserConfiguration.class)) {
-                    boolean methodSignatureIsValid = validateBrowserConfigurationAnnotatedSignature(
-                            method);
-
-                    if (!methodSignatureIsValid) {
-                        /*
-                         * ignore this method and searches for another
-                         * BrowserConfiguration annotated method in this class'
-                         * superclasses
-                         */
-                        break;
-                    }
-
-                    try {
-                        return (Collection<DesiredCapabilities>) method
-                                .invoke(getTestClassInstance());
-                    } catch (Exception e) {
-                        // Handle possible exceptions.
-
-                        String errMsg = String.format(
-                                "Error occurred while invoking BrowserConfiguration method %s.%s(). Method was ignored, searching BrowserConfiguration method in superclasses",
-                                method.getDeclaringClass().getName(),
-                                method.getName());
-                        logger.log(Level.INFO, errMsg, e);
-
-                        /*
-                         * ignore this method and searches for another
-                         * BrowserConfiguration annotated method in this class'
-                         * superclasses
-                         */
-                        break;
-                    }
-                }
-            }
-            klass = klass.getSuperclass();
-        }
-
-        // No valid BrowserConfiguration annotated method was found
-        return ParallelTest.getDefaultCapabilities();
-    }
-
-    /**
-     * Validates the signature of a BrowserConfiguration annotated method.
-     *
-     * @param method
-     *            BrowserConfiguration annotated method
-     * @return true if method signature is valid. false otherwise.
-     */
-    private boolean validateBrowserConfigurationAnnotatedSignature(
-            Method method) {
-        String genericErrorMessage = "Error occurred while invoking BrowserConfigurationMethod %s.%s()."
-                + " %s. Method was ignored, searching BrowserConfiguration method in superclasses";
-
-        if (method.getParameterTypes().length != 0) {
-            String errMsg = String.format(genericErrorMessage,
-                    method.getDeclaringClass().getName(), method.getName(),
-                    "BrowserConfiguration annotated method must not require any arguments");
-            logger.info(errMsg);
-            return false;
-        }
-        if (!Collection.class.isAssignableFrom(method.getReturnType())) {
-            /*
-             * Validates if method's return type is Collection.
-             * ClassCastException may still occur if method's return type is not
-             * Collection<DesiredCapabilities>
-             */
-            String errMsg = String.format(genericErrorMessage,
-                    method.getDeclaringClass().getName(), method.getName(),
-                    "BrowserConfiguration annotated method must return a Collection<DesiredCapabilities>");
-            logger.info(errMsg);
-            return false;
-        }
-        return true;
-    }
-
-    private ParallelTest getTestClassInstance() throws InstantiationException,
-            IllegalAccessException, InvocationTargetException {
-        ParallelTest testClassInstance = (ParallelTest) getTestClass()
-                .getOnlyConstructor().newInstance();
-        return testClassInstance;
-    }
-
-    // This is a FrameworkMethod class that will always
-    // return @Ignore and @Test annotations for the wrapped method.
-    private class IgnoredTestMethod extends FrameworkMethod {
-
-        private class IgnoreTestAnnotations {
-
-            // We use this method to easily get our hands on
-            // the Annotation instances for @Ignore and @Test
-            @Ignore
-            @Test
-            public void ignoredTest() {
-            }
-        }
-
-        public IgnoredTestMethod(Method method) {
-            super(method);
-        }
-
-        @Override
-        public Annotation[] getAnnotations() {
-            return getIgnoredTestMethod().getAnnotations();
-        }
-
-        private Method getIgnoredTestMethod() {
-            try {
-                return IgnoreTestAnnotations.class.getMethod("ignoredTest",
-                        null);
-            } catch (Exception e) {
-                return null;
-            }
-
-        }
-
-        @Override
-        public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
-            return getIgnoredTestMethod().getAnnotation(annotationType);
-        }
-    }
-
-    /**
-     * Finds the given annotation in the given class or one of its super
-     * classes. Return the first found annotation
-     *
-     * @param searchClass
-     * @param annotationClass
-     * @return
-     */
-    private <T extends Annotation> T findAnnotation(Class<?> searchClass,
-            Class<T> annotationClass) {
-        if (searchClass == Object.class) {
-            return null;
-        }
-
-        if (searchClass.getAnnotation(annotationClass) != null) {
-            return searchClass.getAnnotation(annotationClass);
-        }
-
-        return findAnnotation(searchClass.getSuperclass(), annotationClass);
-    }
-
-    @Override
-    protected Statement withBefores(final FrameworkMethod method,
-            final Object target, Statement statement) {
-        if (!(method instanceof TBMethod)) {
-            throw new RuntimeException("Unexpected method type "
-                    + method.getClass().getName() + ", expected TBMethod");
-        }
-        final TBMethod tbmethod = (TBMethod) method;
-
-        // setDesiredCapabilities before running the real @Befores (which use
-        // capabilities)
-
-        final Statement realBefores = super.withBefores(method, target,
-                statement);
-        return new Statement() {
-
-            @Override
-            public void evaluate() throws Throwable {
-                ((ParallelTest) target)
-                        .setDesiredCapabilities(tbmethod.capabilities);
-                realBefores.evaluate();
-            }
-        };
-    }
-
-    public static class TBMethod extends FrameworkMethod {
-        private final DesiredCapabilities capabilities;
-        private String testNameSuffix = "";
-
-        public TBMethod(Method method, DesiredCapabilities capabilities) {
-            super(method);
-            this.capabilities = capabilities;
-        }
-
-        public DesiredCapabilities getCapabilities() {
-            return capabilities;
-        }
-
-        public void setTestNameSuffix(String testNameSuffix) {
-            this.testNameSuffix = testNameSuffix;
-        }
-
-        @Override
-        public Object invokeExplosively(final Object target, Object... params)
-                throws Throwable {
-            // Executes the test method with the supplied parameters
-            try {
-                return super.invokeExplosively(target);
-            } catch (Exception e) {
-                e.printStackTrace();
-                throw e;
-            }
-        }
-
-        @Override
-        public String getName() {
-            return String.format("%s[%s]",
-                    getMethod().getName() + testNameSuffix,
-                    getUniqueIdentifier(capabilities));
-        }
-
-        @Override
-        public boolean equals(Object obj) {
-            if (!TBMethod.class.isInstance(obj)) {
-                return false;
-            }
-
-            return ((TBMethod) obj).capabilities.equals(capabilities)
-                    && super.equals(obj);
-        }
-
-        /**
-         * Returns a string which uniquely (enough) identifies this browser.
-         * Used mainly in screenshot names.
-         */
-        private static String getUniqueIdentifier(Capabilities capabilities) {
-            String platform = BrowserUtil.getPlatform(capabilities);
-            String browser = BrowserUtil.getBrowserIdentifier(capabilities);
-            String version;
-            if (capabilities == null) {
-                version = "Unknown";
-            } else {
-                version = capabilities.getVersion();
-            }
-            return platform + "_" + browser + "_" + version;
-        }
-    }
-
-}