1 files changed, 148 insertions, 0 deletions
diff --git a/tests/test-extensions/net/sourceforge/jnlp/browsertesting/BrowserTestRunner.java b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/BrowserTestRunner.java
new file mode 100644
index 0000000..36350e8
--- /dev/null
+++ b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/BrowserTestRunner.java
@@ -0,0 +1,148 @@
+package net.sourceforge.jnlp.browsertesting;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import net.sourceforge.jnlp.annotations.TestInBrowsers;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import net.sourceforge.jnlp.ServerAccess;
+import org.junit.Ignore;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.internal.runners.model.EachTestNotifier;
+import org.junit.runner.Description;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.Statement;
+
+public class BrowserTestRunner extends BlockJUnit4ClassRunner {
+
+    public BrowserTestRunner(java.lang.Class<?> testClass) throws InitializationError {
+        super(testClass);
+    }
+
+    @Override
+    protected void runChild(FrameworkMethod method, RunNotifier notifier) {
+        Method mm = method.getMethod();
+        TestInBrowsers tib = mm.getAnnotation(TestInBrowsers.class);
+        injectBrowserCatched(method, Browsers.none);
+        boolean browserIgnoration = false;
+        if (tib != null) {
+            try {
+                List<Browsers> testableBrowsers = BrowserFactory.getFactory().getBrowsers(tib);
+                String mbr = System.getProperty("modified.browsers.run");
+                if (mbr != null) {
+                    if (mbr.equalsIgnoreCase("all")) {
+                        if (!isBrowsersNoneSet(tib)) {
+                            testableBrowsers = BrowserFactory.getFactory().getBrowsers(new Browsers[]{Browsers.all});
+                        }
+                    } else if (mbr.equalsIgnoreCase("one")) {
+                        //this complication here is for case like
+                        // namely enumerated concrete browsers, so we want to pick up
+                        // random one from those already enumerated
+                        if (isBrowsersNoneSet(tib)) {
+                            testableBrowsers = Arrays.asList(new Browsers[]{testableBrowsers.get(new Random().nextInt(testableBrowsers.size()))});
+                        }
+                    } else if (mbr.equalsIgnoreCase("ignore")) {
+                        testableBrowsers = BrowserFactory.getFactory().getBrowsers(new Browsers[]{Browsers.none});
+                        browserIgnoration = true;
+                    } else {
+                        ServerAccess.logErrorReprint("unrecognized value of modified.browsers.run - " + mbr);
+                    }
+                }
+                for (Browsers browser : testableBrowsers) {
+                    try {
+                        injcetBrowser(method, browser);
+                        runChildX(method, notifier, browser, browserIgnoration);
+                    } catch (Exception ex) {
+                        //throw new RuntimeException("unabled to inject browser", ex);
+                        ServerAccess.logException(ex, true);
+                    }
+                }
+            } finally {
+                injectBrowserCatched(method, Browsers.none);
+            }
+        } else {
+            runChildX(method, notifier, null, false);
+        }
+    }
+
+    private boolean isBrowsersNoneSet(TestInBrowsers tib) {
+        if (tib.testIn().length == 1 && tib.testIn()[0] == Browsers.none) {
+            return true;
+        }
+        return false;
+    }
+
+    private void injectBrowserCatched(FrameworkMethod method, Browsers browser) {
+        try {
+            injcetBrowser(method, browser);
+        } catch (Exception ex) {
+            //throw new RuntimeException("unabled to inject browser", ex);
+            ServerAccess.logException(ex, true);
+        }
+    }
+
+    private void injcetBrowser(FrameworkMethod method, Browsers browser) throws IllegalAccessException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
+        Method ff = method.getMethod().getDeclaringClass().getMethod("setBrowser", Browsers.class);
+        ff.invoke(null, browser);
+    }
+
+    protected void runChildX(final FrameworkMethod method, RunNotifier notifier, Browsers browser, boolean browserIgnoration) {
+        Description description = describeChild(method, browser);
+        if (method.getAnnotation(Ignore.class) != null) {
+            notifier.fireTestIgnored(description);
+        } else {
+            try {
+                runLeaf(methodBlock(method), description, notifier, browserIgnoration);
+//                ServerAccess.logOutputReprint("trying leaf");
+//                Method m = this.getClass().getMethod("runLeaf", Statement.class, Description.class, RunNotifier.class);
+//                m.setAccessible(true);
+//                m.invoke(this, methodBlock(method), description, notifier);
+//                ServerAccess.logOutputReprint("leaf invoked");
+            } catch (Exception ex) {
+                //throw new RuntimeException("unabled to lunch test on leaf", ex);
+                ServerAccess.logException(ex, true);
+            }
+        }
+    }
+
+    /**
+     * Runs a {@link Statement} that represents a leaf (aka atomic) test.
+     */
+    protected final void runLeaf(Statement statement, Description description,
+            RunNotifier notifier, boolean ignore) {
+        EachTestNotifier eachNotifier = new EachTestNotifier(notifier, description);
+        eachNotifier.fireTestStarted();
+          if (ignore) {
+                eachNotifier.fireTestIgnored();
+                return;
+            }
+        try {
+          statement.evaluate();
+        } catch (AssumptionViolatedException e) {
+            eachNotifier.addFailedAssumption(e);
+        } catch (Throwable e) {
+            eachNotifier.addFailure(e);
+        } finally {
+            eachNotifier.fireTestFinished();
+        }
+    }
+
+    protected Description describeChild(FrameworkMethod method, Browsers browser) {
+        if (browser == null) {
+            return super.describeChild(method);
+        } else {
+            try {
+                return Description.createTestDescription(getTestClass().getJavaClass(),
+                        testName(method) + " - " + browser.toString(), method.getAnnotations());
+            } catch (Exception ex) {
+                ServerAccess.logException(ex, true);
+                return super.describeChild(method);
+            }
+        }
+    }
+}