diff options
Diffstat (limited to 'tests/test-extensions/net')
29 files changed, 3166 insertions, 0 deletions
diff --git a/tests/test-extensions/net/sourceforge/jnlp/ContentReader.java b/tests/test-extensions/net/sourceforge/jnlp/ContentReader.java new file mode 100644 index 0000000..464b778 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/ContentReader.java @@ -0,0 +1,133 @@ +/* ContentReader.java +Copyright (C) 2011,2012 Red Hat, Inc. + +This file is part of IcedTea. + +IcedTea is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License as published by +the Free Software Foundation, version 2. + +IcedTea is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with IcedTea; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. + */ + +package net.sourceforge.jnlp; + +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.Reader; + +/** + * Class to read content of stdout/stderr of process, and to cooperate with its running/terminated/finished statuses. + */ +class ContentReader implements Runnable { + + StringBuilder sb = new StringBuilder(); + private final InputStream is; + private boolean done; + ContentReaderListener listener; + + public String getContent() { + return sb.toString(); + } + + public ContentReader(InputStream is) throws IOException { + this.is = is; + } + + public ContentReader(InputStream is, ContentReaderListener l) throws IOException { + this.is = is; + this.listener = l; + } + + public void setListener(ContentReaderListener listener) { + this.listener = listener; + } + + public ContentReaderListener getListener() { + return listener; + } + + /** + * Blocks until the copy is complete, or until the thread is interrupted + */ + public synchronized void waitUntilDone() throws InterruptedException { + boolean interrupted = false; + // poll interrupted flag, while waiting for copy to complete + while (!(interrupted = Thread.interrupted()) && !done) { + wait(1000); + } + if (interrupted) { + ServerAccess.logNoReprint("Stream copier: throwing InterruptedException"); + //throw new InterruptedException(); + } + } + + @Override + public void run() { + try { + Reader br = new InputStreamReader(is, "UTF-8"); + StringBuilder line = new StringBuilder(); + while (true) { + int s = br.read(); + if (s < 0) { + if (line.length() > 0 && listener != null) { + listener.lineReaded(line.toString()); + } + break; + } + char ch = (char) s; + sb.append(ch); + line.append(ch); + if (ch == '\n') { + if (listener != null) { + listener.lineReaded(line.toString()); + } + line = new StringBuilder(); + } + if (listener != null) { + listener.charReaded(ch); + } + } + //do not want to bother output with terminations + //mostly compaling when assassin kill the process about StreamClosed + //do not want to bother output with terminations + //mostly compaling when assassin kill the process about StreamClosed + } catch (Exception ex) { + // logException(ex); + } finally { + try { + is.close(); + } catch (Exception ex) { + // ex.printStackTrace(); + } finally { + done = true; + } + } + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/ContentReaderListener.java b/tests/test-extensions/net/sourceforge/jnlp/ContentReaderListener.java new file mode 100644 index 0000000..4427d84 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/ContentReaderListener.java @@ -0,0 +1,45 @@ +/* ContentReaderListener.java +Copyright (C) 2011,2012 Red Hat, Inc. + +This file is part of IcedTea. + +IcedTea is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License as published by +the Free Software Foundation, version 2. + +IcedTea is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with IcedTea; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. + */ + +package net.sourceforge.jnlp; + +public interface ContentReaderListener { + + public void charReaded(char ch); + public void lineReaded(String s); + +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/LogItem.java b/tests/test-extensions/net/sourceforge/jnlp/LogItem.java new file mode 100644 index 0000000..dd99c04 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/LogItem.java @@ -0,0 +1,71 @@ +/* LogItem.java +Copyright (C) 2011,2012 Red Hat, Inc. + +This file is part of IcedTea. + +IcedTea is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License as published by +the Free Software Foundation, version 2. + +IcedTea is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with IcedTea; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. + */ + +package net.sourceforge.jnlp; + +import java.util.Date; + +class LogItem { + + public final Date timeStamp = new Date(); + public final StackTraceElement[] fullTrace = Thread.currentThread().getStackTrace(); + public final String text; + private static final String ITEM_ELEMENT = "item"; + private static final String ITEM_ID_ATTRIBUTE = "id"; + private static final String STAMP_ELEMENT = "stamp"; + private static final String TEXT_ELEMENT = "text"; + private static final String FULLTRACE_ELEMENT = "fulltrace"; + + public LogItem(String text) { + this.text = text; + } + + public StringBuilder toStringBuilder(int id) { + StringBuilder sb = new StringBuilder(); + sb.append(" <" + ITEM_ELEMENT + " " + ITEM_ID_ATTRIBUTE + "=\"").append(id).append("\">\n"); + sb.append(" <" + STAMP_ELEMENT + "><![CDATA[").append(timeStamp.toString()).append("]]></" + STAMP_ELEMENT + ">\n"); + sb.append(" <" + TEXT_ELEMENT + "><![CDATA[\n").append(text).append("\n]]></" + TEXT_ELEMENT + ">\n"); + sb.append(" <" + FULLTRACE_ELEMENT + "><![CDATA[\n"); + //five methods since call in log methods + getStacktrace method + for (int i = 6; i < fullTrace.length; i++) { + sb.append(fullTrace[i].toString()).append("\n"); + } + sb.append("\n]]> </" + FULLTRACE_ELEMENT + ">\n"); + sb.append(" </" + ITEM_ELEMENT + ">\n"); + return sb; + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/LoggingBottleneck.java b/tests/test-extensions/net/sourceforge/jnlp/LoggingBottleneck.java new file mode 100644 index 0000000..3f4de4b --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/LoggingBottleneck.java @@ -0,0 +1,215 @@ +/* LoggingBottleneck.java +Copyright (C) 2011,2012 Red Hat, Inc. + +This file is part of IcedTea. + +IcedTea is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License as published by +the Free Software Foundation, version 2. + +IcedTea is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with IcedTea; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. + */ + +package net.sourceforge.jnlp; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.OutputStreamWriter; +import java.io.Writer; +import java.lang.reflect.Method; +import java.util.HashMap; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import net.sourceforge.jnlp.annotations.TestInBrowsers; +import net.sourceforge.jnlp.browsertesting.BrowserTest; +import net.sourceforge.jnlp.browsertesting.Browsers; + +public class LoggingBottleneck { + + /** + * default singleton + */ + private static LoggingBottleneck loggingBottleneck; + private static final File DEFAULT_LOG_FILE = new File("ServerAccess-logs.xml"); + private static final File DEFAULT_STDERR_FILE = new File("stderr.log"); + private static final File DEFAULT_STDOUT_FILE = new File("stdout.log"); + private static final File DEFAULT_STDLOGS_FILE = new File("all.log"); + private static final String LOGS_ELEMENT = "logs"; + private static final String CLASSLOG_ELEMENT = "classlog"; + private static final String CLASSNAME_ATTRIBUTE = "className"; + private static final String TESTLOG_ELEMENT = "testLog"; + private static final String TESTMETHOD_ATTRIBUTE = "testMethod"; + private static final String FULLID_ATTRIBUTE = "fullId"; + private BufferedWriter DEFAULT_STDERR_WRITER; + private BufferedWriter DEFAULT_STDOUT_WRITER; + private BufferedWriter DEFAULT_STDLOGS_WRITER; + /** + * This is static copy of name of id of currentBrowser for logging purposes + */ + private String loggedBrowser = Browsers.none.toString(); + /** + * map of classes, each have map of methods, each have errorlist, outLIst, and allList (allist contains also not std or err messages) + * class.testMethod.logs + */ + final Map<String, Map<String, TestsLogs>> processLogs = new HashMap<String, Map<String, TestsLogs>>(100); + private boolean added = false; + + public static LoggingBottleneck getDefaultLoggingBottleneck() { + if (loggingBottleneck == null) { + loggingBottleneck = new LoggingBottleneck(); + } + return loggingBottleneck; + + } + + private LoggingBottleneck() { + try { + DEFAULT_STDOUT_WRITER = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(DEFAULT_STDOUT_FILE))); + DEFAULT_STDERR_WRITER = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(DEFAULT_STDERR_FILE))); + DEFAULT_STDLOGS_WRITER = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(DEFAULT_STDLOGS_FILE))); + } catch (Throwable t) { + t.printStackTrace(); + } + } + + void writeXmlLog() throws FileNotFoundException, IOException { + writeXmlLog(DEFAULT_LOG_FILE); + } + + void writeXmlLog(File f) throws FileNotFoundException, IOException { + Writer w = new OutputStreamWriter(new FileOutputStream(f)); + Set<Entry<String, Map<String, TestsLogs>>> classes = processLogs.entrySet(); + w.write("<" + LOGS_ELEMENT + ">"); + for (Entry<String, Map<String, TestsLogs>> classLog : classes) { + String className = classLog.getKey(); + w.write("<" + CLASSLOG_ELEMENT + " " + CLASSNAME_ATTRIBUTE + "=\"" + className + "\">"); + Set<Entry<String, TestsLogs>> testsLogs = classLog.getValue().entrySet(); + for (Entry<String, TestsLogs> testLog : testsLogs) { + String testName = testLog.getKey(); + String testLogs = testLog.getValue().toString(); + w.write("<" + TESTLOG_ELEMENT + " " + TESTMETHOD_ATTRIBUTE + "=\"" + testName + "\" " + FULLID_ATTRIBUTE + "=\"" + className + "." + testName + "\" >"); + w.write(testLogs); + w.write("</" + TESTLOG_ELEMENT + ">"); + } + w.write("</" + CLASSLOG_ELEMENT + ">"); + } + w.write("</" + LOGS_ELEMENT + ">"); + w.flush(); + w.close(); + } + + void addToXmlLog(String message, boolean printToOut, boolean printToErr, StackTraceElement ste) { + Map<String, TestsLogs> classLog = processLogs.get(ste.getClassName()); + if (classLog == null) { + classLog = new HashMap<String, TestsLogs>(50); + processLogs.put(ste.getClassName(), classLog); + } + String methodBrowseredName = ste.getMethodName(); + methodBrowseredName = modifyMethodWithForBrowser(methodBrowseredName, ste.getClassName()); + TestsLogs methodLog = classLog.get(methodBrowseredName); + if (methodLog == null) { + methodLog = new TestsLogs(); + classLog.put(methodBrowseredName, methodLog); + } + if (!added) { + Runtime.getRuntime().addShutdownHook(new Thread() { + + @Override + public void run() { + try { + LoggingBottleneck.getDefaultLoggingBottleneck().writeXmlLog(); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + }); + added = true; + } + methodLog.add(printToErr, printToOut, message); + } + + public String modifyMethodWithForBrowser(String methodBrowseredName, String className) { + try { + Class clazz = Class.forName(className); + /* + * By using this isAssignable to ensure corect class before invocation, + * then we lost possibility to track manualy set browsers, but it is correct, + * as method description is set only when annotation is used + */ + if (clazz != null && BrowserTest.class.isAssignableFrom(clazz)) { + Method testMethod = clazz.getMethod(methodBrowseredName); + if (testMethod != null) { + TestInBrowsers tib = testMethod.getAnnotation(TestInBrowsers.class); + if (tib != null) { + methodBrowseredName = methodBrowseredName + " - " + loggedBrowser; + } + } + } + } catch (Throwable ex) { + ex.printStackTrace(); + } + return methodBrowseredName; + } + + public void setLoggedBrowser(String loggedBrowser) { + this.loggedBrowser = loggedBrowser; + } + + public void logIntoPlaintextLog(String message, boolean printToOut, boolean printToErr) { + try { + if (printToOut) { + LoggingBottleneck.getDefaultLoggingBottleneck().stdout(message); + } + if (printToErr) { + LoggingBottleneck.getDefaultLoggingBottleneck().stderr(message); + } + LoggingBottleneck.getDefaultLoggingBottleneck().stdeall(message); + } catch (Throwable t) { + t.printStackTrace(); + } + } + + private void stdout(String idded) throws IOException { + DEFAULT_STDOUT_WRITER.write(idded); + DEFAULT_STDOUT_WRITER.newLine(); + } + + private void stderr(String idded) throws IOException { + DEFAULT_STDERR_WRITER.write(idded); + DEFAULT_STDERR_WRITER.newLine(); + } + + private void stdeall(String idded) throws IOException { + DEFAULT_STDLOGS_WRITER.write(idded); + DEFAULT_STDLOGS_WRITER.newLine(); + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/ProcessAssasin.java b/tests/test-extensions/net/sourceforge/jnlp/ProcessAssasin.java new file mode 100644 index 0000000..c910311 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/ProcessAssasin.java @@ -0,0 +1,159 @@ +/* ProcessAssasin.java +Copyright (C) 2011,2012 Red Hat, Inc. + +This file is part of IcedTea. + +IcedTea is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License as published by +the Free Software Foundation, version 2. + +IcedTea is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with IcedTea; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. + */ + +package net.sourceforge.jnlp; + +/** + * class which timeout any ThreadedProcess. This killing of 'thread with process' replaced not working process.destroy(). + */ +class ProcessAssasin extends Thread { + + long timeout; + private final ThreadedProcess p; + //false == is disabled:( + private boolean canRun = true; + private boolean wasTerminated = false; + /** + * if this is true, then process is not destroyed after timeout, but just left to its own destiny. + * Its stdout/err is no longer recorded, and it is leaking system resources until it dies by itself + * The contorl is returned to main thread with all informations recorded untill now. + * You will be able to listen to std out from listeners still + */ + private boolean skipInstedOfDesroy = false; + + public ProcessAssasin(ThreadedProcess p, long timeout) { + this.p = (p); + this.timeout = timeout; + } + + public ProcessAssasin(ThreadedProcess p, long timeout, boolean skipInstedOfDesroy) { + this.p = (p); + this.timeout = timeout; + this.skipInstedOfDesroy = skipInstedOfDesroy; + } + + public void setCanRun(boolean canRun) { + this.canRun = canRun; + if (p != null) { + if (p.getP() != null) { + ServerAccess.logNoReprint("Stopping assassin for" + p.toString() + " " + p.getP().toString() + " " + p.getCommandLine() + ": "); + } else { + ServerAccess.logNoReprint("Stopping assassin for" + p.toString() + " " + p.getCommandLine() + ": "); + } + } else { + ServerAccess.logNoReprint("Stopping assassin for null job: "); + } + } + + public boolean isCanRun() { + return canRun; + } + + public boolean wasTerminated() { + return wasTerminated; + } + + public void setSkipInstedOfDesroy(boolean skipInstedOfDesroy) { + this.skipInstedOfDesroy = skipInstedOfDesroy; + } + + public boolean isSkipInstedOfDesroy() { + return skipInstedOfDesroy; + } + + @Override + public void run() { + long startTime = System.nanoTime() / ServerAccess.NANO_TIME_DELIMITER; + while (canRun) { + try { + long time = System.nanoTime() / ServerAccess.NANO_TIME_DELIMITER; + //ServerAccess.logOutputReprint(time - startTime); + //ServerAccess.logOutputReprint((time - startTime) > timeout); + if ((time - startTime) > timeout) { + try { + if (p != null) { + if (p.getP() != null) { + ServerAccess.logErrorReprint("Timed out " + p.toString() + " " + p.getP().toString() + " .. killing " + p.getCommandLine() + ": "); + } else { + ServerAccess.logErrorReprint("Timed out " + p.toString() + " " + "null .. killing " + p.getCommandLine() + ": "); + } + wasTerminated = true; + p.interrupt(); + while (!ServerAccess.terminated.contains(p)) { + Thread.sleep(100); + } + if (p.getP() != null) { + try { + if (!skipInstedOfDesroy) { + p.getP().destroy(); + } + } catch (Throwable ex) { + if (p.deadlyException == null) { + p.deadlyException = ex; + } + ex.printStackTrace(); + } + } + if (p.getP() != null) { + ServerAccess.logErrorReprint("Timed out " + p.toString() + " " + p.getP().toString() + " .. killed " + p.getCommandLine()); + } else { + ServerAccess.logErrorReprint("Timed out " + p.toString() + " null .. killed " + p.getCommandLine()); + } + } else { + ServerAccess.logErrorReprint("Timed out null job"); + } + break; + } finally { + p.setDestoyed(true); + } + } + Thread.sleep(100); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + if (p != null) { + if (p.getP() != null) { + ServerAccess.logNoReprint("assassin for" + p.toString() + " " + p.getP().toString() + " .. done " + p.getCommandLine() + " termination " + wasTerminated); + } else { + ServerAccess.logNoReprint("assassin for" + p.toString() + " null .. done " + p.getCommandLine() + " termination " + wasTerminated); + } + } else { + ServerAccess.logNoReprint("assassin for non existing job termination " + wasTerminated); + } + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/ProcessResult.java b/tests/test-extensions/net/sourceforge/jnlp/ProcessResult.java new file mode 100644 index 0000000..d436f72 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/ProcessResult.java @@ -0,0 +1,69 @@ +/* ProcessResult.java +Copyright (C) 2011,2012 Red Hat, Inc. + +This file is part of IcedTea. + +IcedTea is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License as published by +the Free Software Foundation, version 2. + +IcedTea is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with IcedTea; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. + */ + +package net.sourceforge.jnlp; + +/** + * artefacts what are left by finished process + */ +public class ProcessResult { + + public final String stdout; + public final String notFilteredStdout; + public final String stderr; + public final Process process; + public final Integer returnValue; + public final boolean wasTerminated; + /* + * possible exception which caused Process not to be launched + */ + public final Throwable deadlyException; + + public ProcessResult(String stdout, String stderr, Process process, boolean wasTerminated, Integer r, Throwable deadlyException) { + this.notFilteredStdout = stdout; + if (stdout == null) { + this.stdout = null; + } else { + this.stdout = stdout.replaceAll("EMMA:.*\n?", ""); + } + this.stderr = stderr; + this.process = process; + this.wasTerminated = wasTerminated; + this.returnValue = r; + this.deadlyException = deadlyException; + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/ResourcesTest.java b/tests/test-extensions/net/sourceforge/jnlp/ResourcesTest.java new file mode 100644 index 0000000..097ac4f --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/ResourcesTest.java @@ -0,0 +1,389 @@ +/* ResourcesTestl.java +Copyright (C) 2011 Red Hat, Inc. + +This file is part of IcedTea. + +IcedTea is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License as published by +the Free Software Foundation, version 2. + +IcedTea is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with IcedTea; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. + */ +package net.sourceforge.jnlp; + +import java.io.File; +import java.io.FileFilter; +import java.io.FileInputStream; +import java.io.IOException; +import java.net.MalformedURLException; +import java.net.URI; +import java.net.URL; +import java.util.Arrays; +import java.util.List; +import net.sourceforge.jnlp.browsertesting.Browser; +import net.sourceforge.jnlp.browsertesting.BrowserFactory; +import net.sourceforge.jnlp.browsertesting.BrowserTest; +import net.sourceforge.jnlp.browsertesting.Browsers; +import net.sourceforge.jnlp.annotations.NeedsDisplay; +import net.sourceforge.jnlp.browsertesting.browsers.LinuxBrowser; +import net.sourceforge.jnlp.annotations.TestInBrowsers; +import org.junit.Assert; + +import org.junit.Test; + +public class ResourcesTest extends BrowserTest{ + + + @Test + @NeedsDisplay + public void testNonExisitngBrowserWillNotDeadlock() throws Exception { + server.setCurrentBrowser(Browsers.none); + ServerAccess.ProcessResult pr = server.executeBrowser("/simpletest1.jnlp"); + Assert.assertNull(pr.process); + Assert.assertEquals(pr.stderr, ""); + Assert.assertEquals(pr.stdout, ""); + Assert.assertTrue(pr.wasTerminated); + Assert.assertTrue(pr.returnValue < 0); + junit.framework.Assert.assertNotNull(pr.deadlyException); + } + + @Test + public void testUnexistingProcessWillFailRecognizedly() throws Exception { + server.setCurrentBrowser(Browsers.none); + List<String> al=Arrays.asList(new String[] {"definietly_not_Existing_process"}); + ServerAccess.ProcessResult pr = server.executeProcess(al); + Assert.assertNull(pr.process); + Assert.assertEquals(pr.stderr, ""); + Assert.assertEquals(pr.stdout, ""); + Assert.assertTrue(pr.wasTerminated); + Assert.assertTrue(pr.returnValue < 0); + junit.framework.Assert.assertNotNull(pr.deadlyException); + } + + @Test + public void testGetUrlUponThisInstance() throws MalformedURLException{ + URL u1=server.getUrlUponThisInstance("simple.jsp"); + URL u2=server.getUrlUponThisInstance("/simple.jsp"); + Assert.assertEquals(u1, u2); + } + + @Test + @TestInBrowsers(testIn=Browsers.none) + public void testNonExisitngBrowserWillNotCauseMess() throws Exception { + ServerAccess.ProcessResult pr = server.executeBrowser("/simpletest1.jnlp"); + Assert.assertNull(pr.process); + Assert.assertEquals(pr.stderr, ""); + Assert.assertEquals(pr.stdout, ""); + Assert.assertTrue(pr.wasTerminated); + Assert.assertTrue(pr.returnValue < 0); + junit.framework.Assert.assertNotNull(pr.deadlyException); + } + + @Test + public void testBrowsers2() throws Exception { + List<Browser> a = BrowserFactory.getFactory().getAllBrowsers(); + Assert.assertNotNull("returned browsers array must not be null", a); + Assert.assertTrue("at least one browser must be configured", a.size() > 0); + for (Browser b : a) { + testBrowser(b); + } + + } + + @Test + @TestInBrowsers(testIn = Browsers.all) + public void testBrowser3() throws Exception { + testBrowser(server.getCurrentBrowser()); + + + } + + @Test + public void testBrowsers1() throws Exception { + BrowserFactory bf = new BrowserFactory(null); + int expected = 0; + Assert.assertTrue("Created from null there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + bf = new BrowserFactory(""); + expected = 0; + Assert.assertTrue("Created from empty there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + String s = "dsgrdg"; + bf = new BrowserFactory(s); + expected = 0; + Assert.assertTrue("Created from nonsense " + s + " there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + s = "sgrg/jkik"; + bf = new BrowserFactory(s); + expected = 0; + Assert.assertTrue("Created from nonsense " + s + " there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + s = Browsers.firefox + "/jkik"; + bf = new BrowserFactory(s); + expected = 0; + Assert.assertTrue("Created from nonsense " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + s = "sgrg/jkik:sege"; + bf = new BrowserFactory(s); + expected = 0; + Assert.assertTrue("Created from two nonsenses " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + s = Browsers.firefox.toExec() + ":" + Browsers.firefox; + bf = new BrowserFactory(s); + expected = 2; + Assert.assertTrue("Created from " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + s = Browsers.firefox.toExec(); + bf = new BrowserFactory(s); + expected = 1; + Assert.assertTrue("Created from " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + s = "something/somewhere/" + Browsers.firefox.toExec(); + bf = new BrowserFactory(s); + expected = 1; + Assert.assertTrue("Created from " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + s = "something/somewhere/" + Browsers.firefox.toExec() + ":" + "something/somewhere/" + Browsers.opera.toExec(); + bf = new BrowserFactory(s); + expected = 2; + Assert.assertTrue("Created from " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + s = "something/somewhere/" + Browsers.firefox.toExec() + ":" + "something/somewhere/" + Browsers.opera.toExec() + ":" + Browsers.chromiumBrowser; + bf = new BrowserFactory(s); + expected = 3; + Assert.assertTrue("Created from " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + s = Browsers.firefox.toExec() + ":" + "vfdgf" + ":" + Browsers.googleChrome.toExec(); + bf = new BrowserFactory(s); + expected = 2; + Assert.assertTrue("Created from " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + s = Browsers.firefox.toExec() + ":" + Browsers.chromiumBrowser + ":" + Browsers.googleChrome.toExec() + ":" + Browsers.opera + ":" + Browsers.epiphany + ":" + Browsers.midori; + bf = new BrowserFactory(s); + expected = 6; + Assert.assertTrue("Created from " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + testFullFactory(bf); + + s = "fgfd/" + Browsers.firefox.toExec() + ":" + "/fgfd/" + Browsers.chromiumBrowser + ":" + "fgfd/dfsdf/" + Browsers.googleChrome.toExec() + ":" + "/g/fgfd/" + Browsers.opera + ":" + Browsers.epiphany + ":" + Browsers.midori; + bf = new BrowserFactory(s); + expected = 6; + Assert.assertTrue("Created from " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + testFullFactory(bf); + + s = Browsers.firefox.toExec() + ":" + ":" + Browsers.googleChrome.toExec() + ":" + Browsers.opera; + bf = new BrowserFactory(s); + expected = 3; + Assert.assertTrue("Created from " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + s = Browsers.firefox.toExec() + ":" + ":" + ":" + Browsers.opera; + bf = new BrowserFactory(s); + expected = 2; + Assert.assertTrue("Created from " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + s = ":" + ":" + Browsers.googleChrome.toExec() + ":"; + bf = new BrowserFactory(s); + expected = 1; + Assert.assertTrue("Created from " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + s = ":" + Browsers.firefox.toExec() + ":bfgbfg/fddf/" + Browsers.googleChrome.toExec() + ":"; + bf = new BrowserFactory(s); + expected = 2; + Assert.assertTrue("Created from " + s + "there must be " + expected + " browsers in factory. Is" + bf.getAllBrowsers().size(), bf.getAllBrowsers().size() == expected); + + + + + } + + @Test + public void testResourcesExists() throws Exception { + File[] simpleContent = server.getDir().listFiles(new FileFilter() { + + public boolean accept(File file) { + if (!file.isDirectory()) { + return true; + } else { + return false; + } + } + }); + Assert.assertNotNull(simpleContent); + Assert.assertTrue(simpleContent.length > 5); + + for (int i = 0; i < simpleContent.length; i++) { + File file = simpleContent[i]; + ServerAccess.logOutputReprint(file.getName()); + //server port have in fact no usage in converting filename to uri-like-filename. + //But if there is null, instead if some number, then nullpointer exception is thrown (Integer->int). + //So I'm using "real" currently used port, instead of some random value. + URI u = new URI((String) null, (String) null, (String) null, server.getPort(), file.getName(), (String) null, null); + ServerAccess.logOutputReprint(" ("+u.toString()+")"); + String fname = u.toString(); + if (file.getName().toLowerCase().endsWith(".jnlp")) { + String c = server.getResourceAsString("/" + fname); + Assert.assertTrue(c.contains("<")); + Assert.assertTrue(c.contains(">")); + Assert.assertTrue(c.contains("jnlp")); + Assert.assertTrue(c.contains("resources")); + Assert.assertTrue(c.replaceAll("\\s*", "").contains("</jnlp>")); + + } else { + byte[] c = server.getResourceAsBytes("/" + fname).toByteArray(); + Assert.assertEquals(c.length, file.length()); + } + + } + + } + + @Test + @NeedsDisplay + @TestInBrowsers(testIn = Browsers.one) + public void testListeners() throws Exception { + final StringBuilder o1 = new StringBuilder(); + final StringBuilder e1 = new StringBuilder(); + final StringBuilder o2 = new StringBuilder(); + final StringBuilder e2 = new StringBuilder(); + final ContentReaderListener lo = new ContentReaderListener() { + + @Override + public void charReaded(char ch) { + //ServerAccess.logOutputReprint("OO recieved char: "+ch); + o1.append(ch); + } + + @Override + public void lineReaded(String s) { + //ServerAccess.logOutputReprint("OO recieved line: "+s); + o2.append(s).append("\n"); + } + }; + ContentReaderListener le = new ContentReaderListener() { + + @Override + public void charReaded(char ch) { + //ServerAccess.logOutputReprint("EE recieved char: "+ch); + e1.append(ch); + } + + @Override + public void lineReaded(String s) { + //ServerAccess.logOutputReprint("EE recieved line: "+s); + e2.append(s).append("\n"); + } + }; + ServerAccess.ProcessResult pr = server.executeBrowser("/simpletest1.jnlp", le, lo); + server.setCurrentBrowser(BrowserFactory.getFactory().getFirst().getID()); + Assert.assertNotNull(server.getCurrentBrowsers()); + Assert.assertNotNull(server.getCurrentBrowser()); +// ServerAccess.logOutputReprint("total o"); +// ServerAccess.logOutputReprint(pr.stdout); +// ServerAccess.logOutputReprint("total e"); +// ServerAccess.logOutputReprint(pr.stderr); + Assert.assertEquals(pr.stdout, o1.toString()); + Assert.assertEquals(pr.stderr, e1.toString()); + //the last \n is mandatory as las tline is flushed also when proces dies + Assert.assertEquals(pr.stdout.replace("\n", ""), o2.toString().replace("\n", "")); + Assert.assertEquals(pr.stderr.replace("\n", ""), e2.toString().replace("\n", "")); + + } + + private void testFullFactory(BrowserFactory bf) { + Assert.assertEquals(bf.getBrowser(Browsers.chromiumBrowser).getID(), Browsers.chromiumBrowser); + Assert.assertEquals(bf.getBrowser(Browsers.googleChrome).getID(), Browsers.googleChrome); + Assert.assertEquals(bf.getBrowser(Browsers.firefox).getID(), Browsers.firefox); + Assert.assertEquals(bf.getBrowser(Browsers.opera).getID(), Browsers.opera); + Assert.assertEquals(bf.getBrowser(Browsers.epiphany).getID(), Browsers.epiphany); + Assert.assertEquals(bf.getBrowser(Browsers.midori).getID(), Browsers.midori); + } + + private void testBrowser(Browser browser) throws IOException { + File f1 = null; + if (browser.getDefaultPluginExpectedLocation() != null) { + f1 = new File(browser.getDefaultPluginExpectedLocation()); + } + File f2 = null; + if (browser.getUserDefaultPluginExpectedLocation() != null) { + f2 = new File(browser.getUserDefaultPluginExpectedLocation()); + } + if (f1 != null) { + Assert.assertTrue("browser's plugins location should exist " + f1.toString() + " for " + browser.getID().toString(), f1.exists()); + } + if (f2 != null) { + Assert.assertTrue("browser's users-plugins location should exist " + f2.toString() + " for " + browser.getID().toString(), f2.exists()); + } + + File[] ff1 = new File[0]; + if (f1 != null) { + ff1 = f1.listFiles(); + } + + File[] ff2 = new File[0]; + if (f2 != null) { + ff2 = f2.listFiles(); + } + + Assert.assertTrue("at least one of browser's plugins directory should contains at least one file didn't. For " + browser.getID().toString(), ff1.length + ff2.length > 0); + + ff1 = new File[0]; + if (f1 != null) { + ff1 = f1.listFiles(new FileFilter() { + + @Override + public boolean accept(File pathname) { + return (pathname.getName().equals(LinuxBrowser.DEFAULT_PLUGIN_NAME)); + } + }); + } + + ff2 = new File[0]; + if (f2 != null) { + ff2 = f2.listFiles(new FileFilter() { + + @Override + public boolean accept(File pathname) { + return (pathname.getName().equals(LinuxBrowser.DEFAULT_PLUGIN_NAME)); + } + }); + } + + Assert.assertTrue("browser's plugins directories should contains exactly one " + LinuxBrowser.DEFAULT_PLUGIN_NAME + ", but didnt for " + browser.getID().toString(), + ff1.length + ff2.length == 1); + String currentPath = server.getJavawsFile().getParentFile().getParentFile().getAbsolutePath(); + + File[] ff; + if (ff1.length == 1) { + ff = ff1; + } else { + ff = ff2; + } + String s = ServerAccess.getContentOfStream(new FileInputStream(ff[0]), "ASCII"); + Assert.assertTrue("browser's plugins shoud points to" + currentPath + ", but didnt", + s.contains(s)); + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/ServerAccess.java b/tests/test-extensions/net/sourceforge/jnlp/ServerAccess.java new file mode 100644 index 0000000..353d208 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/ServerAccess.java @@ -0,0 +1,828 @@ +/* ServerAccess.java +Copyright (C) 2011 Red Hat, Inc. + +This file is part of IcedTea. + +IcedTea is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License as published by +the Free Software Foundation, version 2. + +IcedTea is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with IcedTea; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. + */ +package net.sourceforge.jnlp; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.io.Writer; +import java.net.HttpURLConnection; +import java.net.MalformedURLException; +import java.net.ServerSocket; +import java.net.URL; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import net.sourceforge.jnlp.browsertesting.Browser; +import net.sourceforge.jnlp.browsertesting.BrowserFactory; +import net.sourceforge.jnlp.browsertesting.Browsers; +import org.junit.Assert; + +/** + * + * This class provides access to virtual server and stuff around. + * It can find unoccupied port, start server, provides its singleton instantiation, lunch parallel instantiations, + * read location of installed (tested javaws) see javaws.build.bin java property, + * location of server www root on file system (see test.server.dir java property), + * stubs for lunching javaws and for locating resources and read resources. + * + * It can also execute processes with timeout (@see PROCESS_TIMEOUT) (used during lunching javaws) + * Some protected apis are exported because public classes in this package are put to be tested by makefile. + * + * There are included test cases which show some basic usages. + * + * + */ +public class ServerAccess { + + public static final long NANO_TIME_DELIMITER=1000000l; + /** + * java property which value containing path to default (makefile by) directory with deployed resources + */ + public static final String TEST_SERVER_DIR = "test.server.dir"; + /** + * java property which value containing path to installed (makefile by) javaws binary + */ + public static final String JAVAWS_BUILD_BIN = "javaws.build.bin"; + /** property to set the different then default browser + */ + public static final String USED_BROWSERS = "used.browsers"; + public static final String DEFAULT_LOCALHOST_NAME = "localhost"; + /** + * server instance singleton + */ + private static ServerLauncher server; + /** + * inner version of engine + */ + private static final String version = "5"; + /** + * timeout to read 'remote' resources + * This can be changed in runtime, but will affect all following tasks + */ + public static int READ_TIMEOUT = 1000; + /** + * timeout in ms to let process to finish, before assassin will kill it. + * This can be changed in runtime, but will affect all following tasks + */ + public static long PROCESS_TIMEOUT = 20 * 1000;//ms + /** + * all terminated processes are stored here. As wee need to 'wait' to termination to be finished. + */ + static Set<Thread> terminated = new HashSet<Thread>(); + /** + * this flag is indicating whether output of executeProcess should be logged. By default true. + */ + public static boolean PROCESS_LOG = true; + public static boolean LOGS_REPRINT = false; + + private Browser currentBrowser; + public static final String UNSET_BROWSER="unset_browser"; + + /** + * main method of this class prints out random free port + * or runs server + * param "port" prints out the port + * nothing or number will run server on random(or on number specified) + * port in -Dtest.server.dir + */ + public static void main(String[] args) throws Exception { + if (args.length > 0 && args[0].equalsIgnoreCase("port")) { + int i = findFreePort(); + System.out.println(i); + System.exit(0); + } else { + int port = 44321; + if (args.length > 0) { + port=new Integer(args[0]); + } + getIndependentInstance(port); + while (true) { + Thread.sleep(1000); + } + + } + } + + /** + * utility method to find random free port + * + * @return - found random free port + * @throws IOException - if socket can't be opened or no free port exists + */ + public static int findFreePort() + throws IOException { + ServerSocket findPortTestingSocket = new ServerSocket(0); + int port = findPortTestingSocket.getLocalPort(); + findPortTestingSocket.close(); + return port; + } + public static final String HEADLES_OPTION="-headless"; + + /** + * we would like to have an singleton instance ASAP + */ + public ServerAccess() { + + getInstance(); + + + } + + /** + * + * @return cached instance. If none, then creates new + */ + public static ServerLauncher getInstance() { + if (server == null) { + server = getIndependentInstance(); + } + return server; + } + + /** + * + * @return new not cached iserver instance on random port, + * useful for testing application loading from different url then base + */ + public static ServerLauncher getIndependentInstance() { + return getIndependentInstance(true); + } + public static ServerLauncher getIndependentInstance(boolean daemon) { + String dir = (System.getProperty(TEST_SERVER_DIR)); + try{ + return getIndependentInstance(dir, findFreePort(),daemon); + }catch (Exception ex){ + throw new RuntimeException(ex); + } + } + + + /** + * + * @return new not cached iserver instance on random port, + * useful for testing application loading from different url then base + */ + + public static ServerLauncher getIndependentInstance(int port) { + return getIndependentInstance(port, true); + } + public static ServerLauncher getIndependentInstance(int port,boolean daemon) { + String dir = (System.getProperty(TEST_SERVER_DIR)); + return getIndependentInstance(dir,port,daemon); + } + + /** + * + * @return new not cached iserver instance on random port upon custom www root directory, + * useful for testing application loading from different url then base + */ + + public static ServerLauncher getIndependentInstance(String dir, int port) { + return getIndependentInstance(dir, port, true); + } + public static ServerLauncher getIndependentInstance(String dir, int port,boolean daemon) { + + + if (dir == null || dir.trim().length() == 0 || !new File(dir).exists() || !new File(dir).isDirectory()) { + throw new RuntimeException("test.server.dir property must be set to valid directory!"); + } + try { + ServerLauncher lServerLuncher = new ServerLauncher(port, new File(dir)); + Thread r=new Thread(lServerLuncher); + r.setDaemon(daemon); + r.start(); + return lServerLuncher; + } catch (Exception ex) { + throw new RuntimeException(ex); + } + + } + + /** + * + * @return - value passed inside as javaws binary location. See JAVAWS_BUILD_BIN + */ + public String getJavawsLocation() { + return System.getProperty(JAVAWS_BUILD_BIN); + } + + /** + * + * @return - bianry from where to lunch current browser + */ + public String getBrowserLocation() { + if (this.currentBrowser==null) return UNSET_BROWSER; + return this.currentBrowser.getBin(); + } + + public List<String> getBrowserParams() { + if (this.currentBrowser==null) return null; + List<String> l1=this.currentBrowser.getComaptibilitySwitches(); + List<String> l2=this.currentBrowser.getDefaultSwitches(); + List<String> l= new ArrayList(); + if (l1!=null)l.addAll(l1); + if (l2!=null)l.addAll(l2); + return l; + + } + + public Browsers getCurrentBrowsers() { + if (currentBrowser==null) return null; + return currentBrowser.getID(); + } + public Browser getCurrentBrowser() { + return currentBrowser; + } + + public void setCurrentBrowser(Browsers currentBrowser) { + this.currentBrowser = BrowserFactory.getFactory().getBrowser(currentBrowser); + if (this.currentBrowser == null) { + LoggingBottleneck.getDefaultLoggingBottleneck().setLoggedBrowser(UNSET_BROWSER); + } else { + LoggingBottleneck.getDefaultLoggingBottleneck().setLoggedBrowser(this.currentBrowser.getID().toString()); + } + } + + public void setCurrentBrowser(Browser currentBrowser) { + this.currentBrowser = currentBrowser; + if (this.currentBrowser == null) { + LoggingBottleneck.getDefaultLoggingBottleneck().setLoggedBrowser(UNSET_BROWSER); + } else { + LoggingBottleneck.getDefaultLoggingBottleneck().setLoggedBrowser(this.currentBrowser.getID().toString()); + } + } + + + + /** + * + * @return - value passed inside as javaws binary location as file. See JAVAWS_BUILD_BIN + */ + public File getJavawsFile() { + return new File(System.getProperty(JAVAWS_BUILD_BIN)); + } + + /** + * + * @return port on which is running cached server. If non singleton instance is running, new is created. + */ + public int getPort() { + if (server == null) { + getInstance(); + } + //if (!server.isRunning()) throw new RuntimeException("Server mysteriously died"); + return server.getPort(); + + } + + /** + * + * @return directory upon which is running cached server. If non singleton instance is running, new is created. + */ + public File getDir() { + if (server == null) { + getInstance(); + } + // if (!server.isRunning()) throw new RuntimeException("Server mysteriously died"); + return server.getDir(); + } + + /** + * + * @return url pointing to cached server resource. If non singleton instance is running, new is created. + */ + public URL getUrl(String resource) throws MalformedURLException { + if (server == null) { + getInstance(); + } + //if (!server.isRunning()) throw new RuntimeException("Server mysteriously died"); + return server.getUrl(resource); + } + + /** + * + * @return url pointing to cached server . If non singleton instance is running, new is created. + */ + public URL getUrl() throws MalformedURLException { + return getUrl(""); + + } + + /** + * + * @return whether cached server is alive. If non singleton instance is running, new is created. + */ + public boolean isRunning() { + if (server == null) { + getInstance(); + } + //if (!server.isRunning()) throw new RuntimeException("Server mysteriously died"); + return server.isRunning(); + + } + + /** + * Return resource from cached server + * + * @param resource to be located on cached server + * @return individual bytes of resource + * @throws IOException if connection can't be established or resource does not exist + */ + public ByteArrayOutputStream getResourceAsBytes(String resource) throws IOException { + return getResourceAsBytes(getUrl(resource)); + } + + /** + * Return resource from cached server + * + * @param resource to be located on cached server + * @return string constructed from resource + * @throws IOException if connection can't be established or resource does not exist + */ + public String getResourceAsString(String resource) throws IOException { + return getResourceAsString(getUrl(resource)); + } + + /** + * utility method which can read bytes of any stream + * + * @param input stream to be read + * @return individual bytes of resource + * @throws IOException if connection can't be established or resource does not exist + */ + public static ByteArrayOutputStream getBytesFromStream(InputStream is) throws IOException { + ByteArrayOutputStream buffer = new ByteArrayOutputStream(); + int nRead; + byte[] data = new byte[16384]; + while ((nRead = is.read(data, 0, data.length)) != -1) { + buffer.write(data, 0, nRead); + } + buffer.flush(); + return buffer; + } + + /** + * utility method which can read from any stream as one long String + * + * @param input stream + * @return stream as string + * @throws IOException if connection can't be established or resource does not exist + */ + public static String getContentOfStream(InputStream is,String encoding) throws IOException { + try { + BufferedReader br = new BufferedReader(new InputStreamReader(is, encoding)); + StringBuilder sb = new StringBuilder(); + while (true) { + String s = br.readLine(); + if (s == null) { + break; + } + sb.append(s).append("\n"); + + } + return sb.toString(); + } finally { + is.close(); + } + + } + + /** + * utility method which can read from any stream as one long String + * + * @param input stream + * @return stream as string + * @throws IOException if connection can't be established or resource does not exist + */ + public static String getContentOfStream(InputStream is) throws IOException { + return getContentOfStream(is, "UTF-8"); + + } + + /** + * utility method which can read bytes of resource from any url + * + * @param resource to be located on any url + * @return individual bytes of resource + * @throws IOException if connection can't be established or resource does not exist + */ + public static ByteArrayOutputStream getResourceAsBytes(URL u) throws IOException { + HttpURLConnection connection = (HttpURLConnection) u.openConnection(); + connection = (HttpURLConnection) u.openConnection(); + connection.setRequestMethod("GET"); + connection.setDoOutput(true); + connection.setReadTimeout(READ_TIMEOUT); + connection.connect(); + return getBytesFromStream(connection.getInputStream()); + + } + + /** + * utility method which can read string of resource from any url + * + * @param resource to be located on any url + * @return resource as string + * @throws IOException if connection can't be established or resource does not exist + */ + public static String getResourceAsString(URL u) throws IOException { + HttpURLConnection connection = (HttpURLConnection) u.openConnection(); + connection = (HttpURLConnection) u.openConnection(); + connection.setRequestMethod("GET"); + connection.setDoOutput(true); + connection.setReadTimeout(READ_TIMEOUT); + connection.connect(); + return getContentOfStream(connection.getInputStream()); + } + + /** + * helping dummy method to save String as file + * + * @param content + * @param f + * @throws IOException + */ + public static void saveFile(String content, File f) throws IOException { + saveFile(content, f, "utf-8"); + } + public static void saveFile(String content, File f,String encoding) throws IOException { + Writer output = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(f),encoding)); + output.write(content); + output.flush(); + output.close(); + } + + /** + * wrapping method to executeProcess (eg: javaws -headless http://localhost:port/resource) + * will execute default javaws (@see JAVAWS_BUILD_BIN) upon default url upon cached server (@see SERVER_NAME @see getPort(), @see getInstance()) + * with parameter -headless (no gui, no asking) + * @param resource name of resource + * @return result what left after running this process + * @throws Exception + */ + public ProcessResult executeJavawsHeadless(String resource) throws Exception { + return executeJavawsHeadless(null, resource); + } + public ProcessResult executeJavawsHeadless(String resource,ContentReaderListener stdoutl,ContentReaderListener stderrl) throws Exception { + return executeJavawsHeadless(null, resource,stdoutl,stderrl); + } + + /** + * wrapping method to executeProcess (eg: javaws arg arg -headless http://localhost:port/resource) + * will execute default javaws (@see JAVAWS_BUILD_BIN) upon default url upon cached server (@see SERVER_NAME @see getPort(), @see getInstance()) + * with parameter -headless (no gui, no asking) + * @param resource name of resource + * @param otherargs other arguments to be added to headless one + * @return result what left after running this process + * @throws Exception + */ + public ProcessResult executeJavawsHeadless(List<String> otherargs, String resource) throws Exception { + return executeJavawsHeadless(otherargs, resource,null,null); + } + public ProcessResult executeJavawsHeadless(List<String> otherargs, String resource,ContentReaderListener stdoutl,ContentReaderListener stderrl) throws Exception { + if (otherargs == null) { + otherargs = new ArrayList<String>(1); + } + List<String> headlesList = new ArrayList<String>(otherargs); + headlesList.add(HEADLES_OPTION); + return executeJavaws(headlesList, resource,stdoutl,stderrl); + } + + + /** + * wrapping method to executeProcess (eg: javaws http://localhost:port/resource) + * will execute default javaws (@see JAVAWS_BUILD_BIN) upon default url upon cached server (@see SERVER_NAME @see getPort(), @see getInstance()) + * @param resource name of resource + * @return result what left after running this process + * @throws Exception + */ + public ProcessResult executeJavaws(String resource) throws Exception { + return executeJavaws(null, resource); + } + public ProcessResult executeJavaws(String resource,ContentReaderListener stdoutl,ContentReaderListener stderrl) throws Exception { + return executeJavaws(null, resource,stdoutl,stderrl); + } + public ProcessResult executeBrowser(String resource) throws Exception { + return executeBrowser(getBrowserParams(), resource); + } + public ProcessResult executeBrowser(String resource,ContentReaderListener stdoutl,ContentReaderListener stderrl) throws Exception { + return executeBrowser(getBrowserParams(), resource,stderrl,stdoutl); + } + + /** + * wrapping method to executeProcess (eg: javaws arg arg http://localhost:port/resource) + * will execute default javaws (@see JAVAWS_BUILD_BIN) upon default url upon cached server (@see SERVER_NAME @see getPort(), @see getInstance())) + * @param resource name of resource + * @param otherargs other arguments to be added + * @return result what left after running this process + * @throws Exception + */ + public ProcessResult executeJavaws(List<String> otherargs, String resource) throws Exception { + return executeProcessUponURL(getJavawsLocation(), otherargs, getUrlUponThisInstance(resource)); + } + public ProcessResult executeJavaws(List<String> otherargs, String resource,ContentReaderListener stdoutl,ContentReaderListener stderrl) throws Exception { + return executeProcessUponURL(getJavawsLocation(), otherargs, getUrlUponThisInstance(resource),stdoutl,stderrl); + } + + public ProcessResult executeBrowser(List<String> otherargs, String resource) throws Exception { + return executeProcessUponURL(getBrowserLocation(), otherargs, getUrlUponThisInstance(resource)); + } + public ProcessResult executeBrowser(List<String> otherargs, String resource,ContentReaderListener stdoutl,ContentReaderListener stderrl) throws Exception { + return executeProcessUponURL(getBrowserLocation(), otherargs, getUrlUponThisInstance(resource),stdoutl,stderrl); + } + + public ProcessResult executeBrowser(Browser b,List<String> otherargs, String resource) throws Exception { + return executeProcessUponURL(b.getBin(), otherargs, getUrlUponThisInstance(resource)); + } + public ProcessResult executeBrowser(Browser b,List<String> otherargs, String resource,ContentReaderListener stdoutl,ContentReaderListener stderrl) throws Exception { + return executeProcessUponURL(b.getBin(), otherargs, getUrlUponThisInstance(resource),stdoutl,stderrl); + } + + /** + * Ctreate resource on http, on 'localhost' on port on which this instance is running + * @param resource + * @return + * @throws MalformedURLException + */ + public URL getUrlUponThisInstance(String resource) throws MalformedURLException { + if (!resource.startsWith("/")) { + resource = "/" + resource; + } + return new URL("http", server.getServerName(), getPort(), resource); + } + + /** + * wrapping method to executeProcess (eg: javaws arg arg arg url) + * will execute default javaws (@see JAVAWS_BUILD_BIN) upon any server + * @param u url of resource upon any server + * @param javaws arguments + * @return result what left after running this process + * @throws Exception + */ + public ProcessResult executeJavawsUponUrl(List<String> otherargs, URL u) throws Exception { + return executeProcessUponURL(getJavawsLocation(), otherargs, u); + } + public ProcessResult executeJavawsUponUrl(List<String> otherargs, URL u,ContentReaderListener stdoutl,ContentReaderListener stderrl) throws Exception { + return executeProcessUponURL(getJavawsLocation(), otherargs, u,stdoutl,stderrl); + } + + /** + * wrapping utility method to executeProcess (eg: any_binary arg arg arg url) + * + * will execute any process upon url upon any server + * @param u url of resource upon any server + * @param javaws arguments + * @return result what left after running this process + * @throws Exception + */ + public static ProcessResult executeProcessUponURL(String toBeExecuted, List<String> otherargs, URL u) throws Exception { + return executeProcessUponURL(toBeExecuted, otherargs, u,null,null); + } + + public static ProcessResult executeProcessUponURL(String toBeExecuted, List<String> otherargs, URL u,ContentReaderListener stdoutl,ContentReaderListener stderrl) throws Exception { + Assert.assertNotNull(u); + Assert.assertNotNull(toBeExecuted); + Assert.assertTrue(toBeExecuted.trim().length() > 1); + if (otherargs == null) { + otherargs = new ArrayList<String>(1); + } + List<String> urledArgs = new ArrayList<String>(otherargs); + urledArgs.add(0, toBeExecuted); + urledArgs.add(u.toString()); + return executeProcess(urledArgs, stdoutl, stderrl); + } + + public static ProcessResult executeProcess(final List<String> args) throws Exception { + return executeProcess(args, null); + } + public static ProcessResult executeProcess(final List<String> args,ContentReaderListener stdoutl,ContentReaderListener stderrl) throws Exception { + return executeProcess(args, null,stdoutl,stderrl); + } + /** + * utility method to lunch process, get its stdout/stderr, its return value and to kill it if running to long (@see PROCESS_TIMEOUT) + * + * + * Small bacground: + * This method creates thread inside which exec will be executed. Then creates assassin thread with given timeout to kill the previously created thread if necessary. + * Starts assassin thread, starts process thread. Wait until process is running, then starts content readers. + * Closes input of process. + * Wait until process is running (no matter if it terminate itself (correctly or badly), or is terminated by its assassin. + * Construct result from readed stdout, stderr, process return value, assassin successfully + * + * @param args binary with args to be executed + * @param dir optional, directory where this process will run + * @return what left from process - process itself, its stdout, stderr and return value and whether it was terminated by assassin. + * @throws Exception + */ + public static ProcessResult executeProcess(final List<String> args,File dir) throws Exception { + return executeProcess(args, dir, null, null); + } + + private static String createConnectionMessage(ThreadedProcess t) { + return "Connecting " + t.getCommandLine(); + } + + /** + * Proceed message s to logging with request to reprint to System.err + * @param s + */ + public static void logErrorReprint(String s) { + log(s, false, true); + } + + /** + * Proceed message s to logging with request to reprint to System.out + * @param s + */ + public static void logOutputReprint(String s) { + log(s, true, false); + } + + /** + * Proceed message s to logging withhout request to reprint + * @param s + */ + public static void logNoReprint(String s) { + log(s, false, false); + } + + private static void log(String message, boolean printToOut, boolean printToErr) { + String idded; + StackTraceElement ste = getTestMethod(); + String fullId = ste.getClassName() + "." + ste.getMethodName(); + fullId = LoggingBottleneck.getDefaultLoggingBottleneck().modifyMethodWithForBrowser(ste.getMethodName(), ste.getClassName()); + if (message.contains("\n")) { + idded = fullId + ": \n" + message + "\n" + fullId + " ---"; + } else { + idded = fullId + ": " + message; + + } + if (LOGS_REPRINT) { + if (printToOut) { + System.out.println(idded); + } + if (printToErr) { + System.err.println(idded); + } + } + LoggingBottleneck.getDefaultLoggingBottleneck().logIntoPlaintextLog(idded, printToOut,printToErr); + LoggingBottleneck.getDefaultLoggingBottleneck().addToXmlLog(message,printToOut,printToErr,ste); + } + + public static void logException(Throwable t){ + logException(t, true); + } + public static void logException(Throwable t, boolean print){ + try{ + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + t.printStackTrace(pw); + log(sw.toString(), false, print); + pw.close(); + sw.close(); + }catch(Exception ex){ + throw new RuntimeException(ex); + } + } + + private static StackTraceElement getTestMethod() { + return getTestMethod(Thread.currentThread().getStackTrace()); + } + + private static StackTraceElement getTestMethod(StackTraceElement[] stack) { + //0 is always thread + //1 is net.sourceforge.jnlp.ServerAccess + StackTraceElement result = stack[1]; + String baseClass = stack[1].getClassName(); + int i = 2; + for (; i < stack.length; i++) { + result = stack[i];//at least moving up + if(stack[i].getClassName().contains("$")){ + continue; + } + if (!baseClass.equals(stack[i].getClassName())) { + break; + } + } + //if nothing left in stack then we have been in ServerAccess already + //so the target method is the highest form it and better to return it + //rather then die to ArrayOutOfBounds + if(i >= stack.length){ + return result; + } + //now we are out of net.sourceforge.jnlp.ServerAccess + //method we need (the test) is highest from following class + baseClass = stack[i].getClassName(); + for (; i < stack.length; i++) { + if(stack[i].getClassName().contains("$")){ + continue; + } + if (!baseClass.equals(stack[i].getClassName())) { + break; + } + result = stack[i]; + } + + return result; + } + + public static ProcessResult executeProcess(final List<String> args, File dir, ContentReaderListener stdoutl, ContentReaderListener stderrl) throws Exception { + ThreadedProcess t = new ThreadedProcess(args, dir); + if (PROCESS_LOG) { + String connectionMesaage = createConnectionMessage(t); + log(connectionMesaage, true, true); + } + ProcessAssasin pa = new ProcessAssasin(t, PROCESS_TIMEOUT); + pa.start(); + t.start(); + while (t.getP() == null && t.deadlyException == null) { + Thread.sleep(100); + } + if (t.deadlyException != null) { + pa.setCanRun(false); + return new ProcessResult("", "", null, true, Integer.MIN_VALUE, t.deadlyException); + } + ContentReader crs = new ContentReader(t.getP().getInputStream(),stdoutl); + ContentReader cre = new ContentReader(t.getP().getErrorStream(),stderrl); + + OutputStream out = t.getP().getOutputStream(); + if (out != null) { + out.close(); + } + + new Thread(crs).start(); + new Thread(cre).start(); + while (t.isRunning()) { + Thread.sleep(100); + } + + while (!t.isDestoyed()) { + Thread.sleep(100); + } + pa.setCanRun(false); + // ServerAccess.logOutputReprint(t.getP().exitValue()); when process is killed, this throws exception + + ProcessResult pr=new ProcessResult(crs.getContent(), cre.getContent(), t.getP(), pa.wasTerminated(), t.getExitCode(), null); + if (PROCESS_LOG) { + log(pr.stdout, true, false); + log(pr.stderr, false, true); + } + return pr; + } + + /** + * this is temprary solution until refactoring is fully done + * Use net.sourceforge.jnlp.ProcessResult instead + */ + @Deprecated + public static class ProcessResult extends net.sourceforge.jnlp.ProcessResult { + + public ProcessResult(String stdout, String stderr, Process process, boolean wasTerminated, Integer r, Throwable deadlyException) { + super(stdout, stderr, process, wasTerminated, r, deadlyException); + } + } + } diff --git a/tests/test-extensions/net/sourceforge/jnlp/ServerLauncher.java b/tests/test-extensions/net/sourceforge/jnlp/ServerLauncher.java new file mode 100644 index 0000000..92634cc --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/ServerLauncher.java @@ -0,0 +1,120 @@ +/* ServerLauncher.java +Copyright (C) 2011,2012 Red Hat, Inc. + +This file is part of IcedTea. + +IcedTea is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License as published by +the Free Software Foundation, version 2. + +IcedTea is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with IcedTea; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. + */ + +package net.sourceforge.jnlp; + +import java.io.File; +import java.net.MalformedURLException; +import java.net.ServerSocket; +import java.net.URL; + +/** + * wrapper around tiny http server to separate lunch configurations and servers. + * to allow terminations and stuff around. + */ +public class ServerLauncher implements Runnable { + + /** + * default url name part. + * This can be changed in runtime, but will affect all following tasks upon those server + */ + private String serverName = ServerAccess.DEFAULT_LOCALHOST_NAME; + private boolean running; + private final Integer port; + private final File dir; + + public String getServerName() { + return serverName; + } + + public void setServerName(String serverName) { + this.serverName = serverName; + } + + public ServerLauncher(Integer port, File dir) { + this.port = port; + this.dir = dir; + System.err.println("port: " + port); + System.err.println("dir: " + dir); + } + + public boolean isRunning() { + return running; + } + + public Integer getPort() { + return port; + } + + public File getDir() { + return dir; + } + + public ServerLauncher(File dir) { + this(8181, dir); + } + + public ServerLauncher(Integer port) { + this(port, new File(System.getProperty("user.dir"))); + } + + public ServerLauncher() { + this(8181, new File(System.getProperty("user.dir"))); + } + + public void run() { + running = true; + try { + ServerSocket s = new ServerSocket(port); + while (running) { + new TinyHttpdImpl(s.accept(), dir, port); + } + } catch (Exception e) { + e.printStackTrace(); + } finally { + running = false; + } + } + + public URL getUrl(String resource) throws MalformedURLException { + return new URL("http", getServerName(), getPort(), resource); + } + + public URL getUrl() throws MalformedURLException { + return getUrl(""); + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/TestsLogs.java b/tests/test-extensions/net/sourceforge/jnlp/TestsLogs.java new file mode 100644 index 0000000..3277dfe --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/TestsLogs.java @@ -0,0 +1,85 @@ +/* TestsLogs.java +Copyright (C) 2011,2012 Red Hat, Inc. + +This file is part of IcedTea. + +IcedTea is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License as published by +the Free Software Foundation, version 2. + +IcedTea is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with IcedTea; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. + */ + +package net.sourceforge.jnlp; + +import java.util.LinkedList; +import java.util.List; + +class TestsLogs { + + public final List<LogItem> outs = new LinkedList<LogItem>(); + public final List<LogItem> errs = new LinkedList<LogItem>(); + public final List<LogItem> all = new LinkedList<LogItem>(); + private static final String LOG_ELEMENT = "log"; + private static final String LOG_ID_ATTRIBUTE = "id"; + + synchronized void add(boolean err, boolean out, String text) { + if (text == null) { + text = "null"; + } + LogItem li = new LogItem(text); + if (out) { + outs.add(li); + } + if (err) { + errs.add(li); + } + all.add(li); + + } + + @Override + public String toString() { + StringBuilder sb = listToStringBuilder(outs, "out"); + sb.append(listToStringBuilder(errs, "err")); + sb.append(listToStringBuilder(all, "all")); + return sb.toString(); + } + + private StringBuilder listToStringBuilder(List<LogItem> l, String id) { + StringBuilder sb = new StringBuilder(); + sb.append("<" + LOG_ELEMENT + " " + LOG_ID_ATTRIBUTE + "=\"").append(id).append("\">\n"); + int i = 0; + for (LogItem logItem : l) { + i++; + sb.append(logItem.toStringBuilder(i)); + } + sb.append("</" + LOG_ELEMENT + ">\n"); + return sb; + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/ThreadedProcess.java b/tests/test-extensions/net/sourceforge/jnlp/ThreadedProcess.java new file mode 100644 index 0000000..c37d842 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/ThreadedProcess.java @@ -0,0 +1,140 @@ +/* ThreadedProcess.java +Copyright (C) 2011,2012 Red Hat, Inc. + +This file is part of IcedTea. + +IcedTea is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License as published by +the Free Software Foundation, version 2. + +IcedTea is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with IcedTea; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. + */ + +package net.sourceforge.jnlp; + +import java.io.File; +import java.util.List; + +/** + * + * wrapper around Runtime.getRuntime().exec(...) which ensures that process is run inside its own, by us controlled, thread. + * Process builder caused some unexpected and weird behavior :/ + */ +class ThreadedProcess extends Thread { + + Process p = null; + List<String> args; + Integer exitCode; + Boolean running; + File dir; + Throwable deadlyException = null; + /* + * before removing this "useless" variable + * check DeadLockTestTest.testDeadLockTestTerminated2 + */ + private boolean destoyed = false; + + public boolean isDestoyed() { + return destoyed; + } + + public void setDestoyed(boolean destoyed) { + this.destoyed = destoyed; + } + + public Boolean isRunning() { + return running; + } + + public Integer getExitCode() { + return exitCode; + } + + public ThreadedProcess(List<String> args) { + this.args = args; + } + + public ThreadedProcess(List<String> args, File dir) { + this.args = args; + this.dir = dir; + } + + public String getCommandLine() { + String commandLine = "unknown command"; + try { + if (args != null && args.size() > 0) { + commandLine = ""; + for (String string : args) { + commandLine = commandLine + " " + string; + } + } + } catch (Exception ex) { + ex.printStackTrace(); + } finally { + return commandLine; + } + } + + public Process getP() { + return p; + } + + @Override + public void run() { + try { + running = true; + Runtime r = Runtime.getRuntime(); + if (dir == null) { + p = r.exec(args.toArray(new String[0])); + } else { + p = r.exec(args.toArray(new String[0]), new String[0], dir); + } + try { + exitCode = p.waitFor(); + Thread.sleep(500); //this is giving to fast done proecesses's e/o readers time to read all. I would like to know better solution :-/ + } finally { + destoyed = true; + } + } catch (Exception ex) { + if (ex instanceof InterruptedException) { + //add to the set of terminated threaded processes + deadlyException = ex; + ServerAccess.logException(deadlyException, false); + ServerAccess.terminated.add(this); + } else { + //happens when non-existing process is launched, is causing p null! + ServerAccess.terminated.add(this); + deadlyException = ex; + ServerAccess.logException(deadlyException, false); + throw new RuntimeException(ex); + } + } finally { + running = false; + } + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/TinyHttpdImpl.java b/tests/test-extensions/net/sourceforge/jnlp/TinyHttpdImpl.java new file mode 100644 index 0000000..34870ab --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/TinyHttpdImpl.java @@ -0,0 +1,174 @@ +/* TinyHttpdImpl.java +Copyright (C) 2011,2012 Red Hat, Inc. + +This file is part of IcedTea. + +IcedTea is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License as published by +the Free Software Foundation, version 2. + +IcedTea is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with IcedTea; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. + */ + +package net.sourceforge.jnlp; + +import java.io.BufferedReader; +import java.io.DataOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.InputStreamReader; +import java.net.Socket; +import java.net.SocketException; +import java.net.URLDecoder; +import java.util.StringTokenizer; + +/** + * based on http://www.mcwalter.org/technology/java/httpd/tiny/index.html + * Very small implementation of http return headers for our served resources + * Originally Licenced under GPLv2.0 + * + * When resource starts with XslowX prefix, then resouce (without XslowX) + * is returned, but its delivery is delayed + */ +class TinyHttpdImpl extends Thread { + + Socket c; + private final File dir; + private final int port; + private boolean canRun = true; + private static final String XSX = "/XslowX"; + + public TinyHttpdImpl(Socket s, File f, int port) { + c = s; + this.dir = f; + this.port = port; + start(); + } + + public void setCanRun(boolean canRun) { + this.canRun = canRun; + } + + public int getPort() { + return port; + } + + @Override + public void run() { + try { + BufferedReader i = new BufferedReader(new InputStreamReader(c.getInputStream())); + DataOutputStream o = new DataOutputStream(c.getOutputStream()); + try { + while (canRun) { + String s = i.readLine(); + if (s.length() < 1) { + break; + } + if (s.startsWith("GET")) { + StringTokenizer t = new StringTokenizer(s, " "); + t.nextToken(); + String op = t.nextToken(); + String p = op; + if (p.startsWith(XSX)) { + p = p.replace(XSX, "/"); + } + ServerAccess.logNoReprint("Getting: " + p); + p = URLDecoder.decode(p, "UTF-8"); + ServerAccess.logNoReprint("Serving: " + p); + p = (".".concat((p.endsWith("/")) ? p.concat("index.html") : p)).replace('/', File.separatorChar); + File pp = new File(dir, p); + int l = (int) pp.length(); + byte[] b = new byte[l]; + FileInputStream f = new FileInputStream(pp); + f.read(b); + String content = ""; + String ct = "Content-Type: "; + if (p.toLowerCase().endsWith(".jnlp")) { + content = ct + "application/x-java-jnlp-file\n"; + } else if (p.toLowerCase().endsWith(".html")) { + content = ct + "text/html\n"; + } else if (p.toLowerCase().endsWith(".jar")) { + content = ct + "application/x-jar\n"; + } + o.writeBytes("HTTP/1.0 200 OK\nConten" + "t-Length:" + l + "\n" + content + "\n"); + if (op.startsWith(XSX)) { + byte[][] bb = splitArray(b, 10); + for (int j = 0; j < bb.length; j++) { + Thread.sleep(2000); + byte[] bs = bb[j]; + o.write(bs, 0, bs.length); + } + } else { + o.write(b, 0, l); + } + } + } + } catch (SocketException e) { + ServerAccess.logException(e, false); + } catch (Exception e) { + o.writeBytes("HTTP/1.0 404 ERROR\n\n\n"); + ServerAccess.logException(e, false); + } + o.close(); + } catch (Exception e) { + ServerAccess.logException(e, false); + } + } + + /** + * This function splits input array to severasl pieces + * from byte[length] splitt to n pieces s is retrunrd byte[n][length/n], except + * last piece which contains length%n + * + * @param input - array to be splitted + * @param pieces - to how many pieces it should be broken + * @return inidividual pices of original array, which concatet again givs original array + */ + public static byte[][] splitArray(byte[] input, int pieces) { + int rest = input.length; + int rowLength = rest / pieces; + if (rest % pieces > 0) { + rowLength++; + } + if (pieces * rowLength >= rest + rowLength) { + pieces--; + } + int i = 0, j = 0; + byte[][] array = new byte[pieces][]; + array[0] = new byte[rowLength]; + for (byte b : input) { + if (i >= rowLength) { + i = 0; + array[++j] = new byte[Math.min(rowLength, rest)]; + } + array[j][i++] = b; + rest--; + } + return array; + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/annotations/Bug.java b/tests/test-extensions/net/sourceforge/jnlp/annotations/Bug.java new file mode 100644 index 0000000..ac157d9 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/annotations/Bug.java @@ -0,0 +1,32 @@ +package net.sourceforge.jnlp.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * When declare for suite class or for Test-marked method, + * should be interpreted by report generating tool to links. + * Known shortcuts are + * SX - http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=X + * PRX - http://icedtea.classpath.org/bugzilla/show_bug.cgi?id=X + * RHX - https://bugzilla.redhat.com/show_bug.cgi?id=X + * DX - http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=X + * GX - http://bugs.gentoo.org/show_bug.cgi?id=X + * CAX - http://server.complang.tuwien.ac.at/cgi-bin/bugzilla/show_bug.cgi?id=X + * LPX - https://bugs.launchpad.net/bugs/X + * + * http://mail.openjdk.java.net/pipermail/distro-pkg-dev/ + * and http://mail.openjdk.java.net/pipermail/ are proceed differently + * You just put eg @Bug(id="RH12345",id="http:/my.bukpage.com/terribleNew") + * and RH12345 will be transalated as + * <a href="https://bugzilla.redhat.com/show_bug.cgi?id=123456">123456<a> or + * similar, the url will be inclueded as is. Both added to proper tests or suites + * + */ +@Target({ElementType.METHOD,ElementType.TYPE}) +@Retention(RetentionPolicy.RUNTIME) +public @interface Bug { + public String[] id(); +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/annotations/KnownToFail.java b/tests/test-extensions/net/sourceforge/jnlp/annotations/KnownToFail.java new file mode 100644 index 0000000..e7c2464 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/annotations/KnownToFail.java @@ -0,0 +1,24 @@ +package net.sourceforge.jnlp.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * <p> + * This annotation marks a test as a known failure (as opposed to a + * regression). A test that is a known failure will not hold of a release, + * nor should developers hold off a fix if they run the unit tests and a + * test marked as a known failure fails. + * </p><p> + * This annotation is meant for adding tests for bugs before the fix is + * implemented. + * </p> + */ + +@Target({ElementType.METHOD,ElementType.TYPE}) +@Retention(RetentionPolicy.RUNTIME) +public @interface KnownToFail { + +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/annotations/NeedsDisplay.java b/tests/test-extensions/net/sourceforge/jnlp/annotations/NeedsDisplay.java new file mode 100644 index 0000000..e8b9d49 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/annotations/NeedsDisplay.java @@ -0,0 +1,18 @@ + +package net.sourceforge.jnlp.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * This annotation should be declared for each test which requires DISPALY defined. + * If no display is defined, then those test will not be run + * + */ +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +public @interface NeedsDisplay { + +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/annotations/TestInBrowsers.java b/tests/test-extensions/net/sourceforge/jnlp/annotations/TestInBrowsers.java new file mode 100644 index 0000000..b4ea2a3 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/annotations/TestInBrowsers.java @@ -0,0 +1,18 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package net.sourceforge.jnlp.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import net.sourceforge.jnlp.browsertesting.Browsers; + +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +public @interface TestInBrowsers { + public Browsers[] testIn(); +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/browsertesting/Browser.java b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/Browser.java new file mode 100644 index 0000000..81db960 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/Browser.java @@ -0,0 +1,19 @@ +package net.sourceforge.jnlp.browsertesting; + +import java.util.List; + +/** + * interface which represents individual browsers + */ +public interface Browser { + public String getDefaultBin(); + public String getDefaultPluginExpectedLocation(); + public String getBin(); + //public void setBin(String bin); + public String getUserDefaultPluginExpectedLocation(); + public Browsers getID(); + public List<String> getComaptibilitySwitches(); + public List<String> getDefaultSwitches(); + + +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/browsertesting/BrowserFactory.java b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/BrowserFactory.java new file mode 100644 index 0000000..7171afc --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/BrowserFactory.java @@ -0,0 +1,189 @@ +package net.sourceforge.jnlp.browsertesting; + +import net.sourceforge.jnlp.annotations.TestInBrowsers; +import java.io.File; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Random; +import net.sourceforge.jnlp.ServerAccess; +import net.sourceforge.jnlp.browsertesting.browsers.Chrome; +import net.sourceforge.jnlp.browsertesting.browsers.Chromium; +import net.sourceforge.jnlp.browsertesting.browsers.Epiphany; +import net.sourceforge.jnlp.browsertesting.browsers.Firefox; +import net.sourceforge.jnlp.browsertesting.browsers.Midory; +import net.sourceforge.jnlp.browsertesting.browsers.Opera; + +public class BrowserFactory { + + private static final BrowserFactory factory = new BrowserFactory(System.getProperty(ServerAccess.USED_BROWSERS)); + private List<Browser> configuredBrowsers; + Random oneGenerator = new Random(); + + public static BrowserFactory getFactory() { + return factory; + } + + /** + * This is public just for testing purposes! + */ + public BrowserFactory(String browsers) { + if (browsers == null) { + configuredBrowsers = new ArrayList<Browser>(0); + } else { + String[] s = browsers.split(File.pathSeparator); + configuredBrowsers = new ArrayList<Browser>(s.length); + for (int i = 0; i < s.length; i++) { + String string = s[i]; + String[] p = string.split("/"); + if (p.length > 1) { + string = p[p.length - 1]; + } + if (string.equals(Browsers.chromiumBrowser.toString())) { + configuredBrowsers.add(new Chromium(s[i])); + } + if (string.equals(Browsers.googleChrome.toString())) { + configuredBrowsers.add(new Chrome(s[i])); + } + if (string.equals(Browsers.opera.toString())) { + configuredBrowsers.add(new Opera(s[i])); + } + if (string.equals(Browsers.firefox.toString())) { + configuredBrowsers.add(new Firefox(s[i])); + } + if (string.equals(Browsers.epiphany.toString())) { + configuredBrowsers.add(new Epiphany(s[i])); + } + if (string.equals(Browsers.midori.toString())) { + configuredBrowsers.add(new Midory(s[i])); + } + } + } + + } + + public Browser getBrowser(Browsers id) { + for (int i = 0; i < configuredBrowsers.size(); i++) { + Browser browser = configuredBrowsers.get(i); + if (browser.getID() == id) { + return browser; + } + + } + return null; + + } + + public Browser getFirst() { + for (int i = 0; i < configuredBrowsers.size(); i++) { + Browser browser = configuredBrowsers.get(i); + return browser; + + } + return null; + + } + + public Browser getRandom() { + if (configuredBrowsers.isEmpty()){ + return null; + } + return configuredBrowsers.get(oneGenerator.nextInt(configuredBrowsers.size())); + } + + public List<Browser> getAllBrowsers() { + return Collections.unmodifiableList(configuredBrowsers); + } + + public List<Browsers> getBrowsers(TestInBrowsers tib) { + return getBrowsers(tib.testIn()); + } + public List<Browsers> getBrowsers(Browsers[] testIn) { + List<Browser> q = translateAnnotationSilently(testIn); + if (q==null || q.isEmpty()){ + List<Browsers> qq = new ArrayList<Browsers>(0); + qq.add(Browsers.none); + return qq; + } + List<Browsers> qq = new ArrayList<Browsers>(q.size()); + for (Browser browser : q) { + qq.add(browser.getID()); + } + return qq; + + } + /** + * + * @param testIn Bbrowsers which should be transformed to list of Browser + * @return all matching browser, if browser do not exists, this is ignored and run is silently continued + */ + public List<Browser> translateAnnotationSilently(Browsers[] testIn) { + if (testIn==null) { + return null; + } + List<Browser> r = new ArrayList<Browser>(configuredBrowsers.size()); + for (Browsers b : testIn) { + if (b == Browsers.all) { + if (getAllBrowsers().isEmpty()) { + ServerAccess.logErrorReprint("You try to add all browsers, but there is none"); + } else { + r.addAll(getAllBrowsers()); + } + } else if (b == Browsers.one) { + Browser bb = getRandom(); + if (bb == null) { + ServerAccess.logErrorReprint("You try to add random browser, but there is none"); + } else { + r.add(bb); + } + } else { + Browser bb = getBrowser(b); + if (bb == null) { + ServerAccess.logErrorReprint("You try to add " + b.toString() + " browser, but it do not exists"); + } else { + r.add(bb); + } + + } + } + + return r; + + } + + /** + * + * @param tib + * @return all matching browser, if browser do not exists, exception is thrown + */ + public List<Browser> translateAnnotationLaudly(TestInBrowsers tib) { + return translateAnnotationLaudly(tib.testIn()); + } + public List<Browser> translateAnnotationLaudly(Browsers[] testIn) { + List<Browser> r = new ArrayList<Browser>(configuredBrowsers.size()); + for (Browsers b :testIn) { + if (b == Browsers.all) { + if (getAllBrowsers().isEmpty()) { + throw new IllegalStateException("You try to add all browsers, but there is none"); + } + r.addAll(getAllBrowsers()); + } else if (b == Browsers.one) { + Browser bb = getRandom(); + if (bb == null) { + throw new IllegalStateException("You try to add random browser, but there is none"); + } + r.add(bb); + } else { + Browser bb = getBrowser(b); + if (bb == null) { + throw new IllegalStateException("You try to add " + b.toString() + " browser, but it do not exists"); + } + r.add(bb); + + } + } + + return r; + + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/browsertesting/BrowserTest.java b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/BrowserTest.java new file mode 100644 index 0000000..232b63a --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/BrowserTest.java @@ -0,0 +1,23 @@ +package net.sourceforge.jnlp.browsertesting; + +import net.sourceforge.jnlp.ServerAccess; +import org.junit.runner.RunWith; + + +@RunWith(value = BrowserTestRunner.class) +public abstract class BrowserTest { + + public static Browsers browser=null; + public static final ServerAccess server = new ServerAccess(); + + public static void setBrowser(Browsers b) { + browser = b; + server.setCurrentBrowser(browser); + } + + public static Browsers getBrowser() { + return browser; + } + + +} 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); + } + } + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/browsertesting/Browsers.java b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/Browsers.java new file mode 100644 index 0000000..8d85241 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/Browsers.java @@ -0,0 +1,46 @@ +package net.sourceforge.jnlp.browsertesting; + +/** + * When all represent all configured browser, one represens one random + * (the first found) configured browser. Each other represents inidivdual browsers + * + */ +public enum Browsers { + + none, all, one, opera, googleChrome, chromiumBrowser, firefox, midori,epiphany; + + public String toExec() { + switch (this) { + case opera: + return "opera"; + case googleChrome: + return "google-chrome"; + case chromiumBrowser: + return "chromium-browser"; + case firefox: + return "firefox"; + case midori: + return "midori"; + case epiphany: + return "epiphany"; + default: + return null; + + } + } + + @Override + public String toString() { + if (toExec()!=null) return toExec(); + switch (this) { + case all: + return "all"; + case one: + return "one"; + case none: + return "unset_browser"; + default: return "unknown"; + + } + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Chrome.java b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Chrome.java new file mode 100644 index 0000000..2668d65 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Chrome.java @@ -0,0 +1,15 @@ +package net.sourceforge.jnlp.browsertesting.browsers; + +import net.sourceforge.jnlp.browsertesting.Browsers; + +public class Chrome extends MozillaFamilyLinuxBrowser { + + public Chrome(String bin) { + super(bin); + } + + @Override + public Browsers getID() { + return Browsers.googleChrome; + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Chromium.java b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Chromium.java new file mode 100644 index 0000000..616d38a --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Chromium.java @@ -0,0 +1,15 @@ +package net.sourceforge.jnlp.browsertesting.browsers; + +import net.sourceforge.jnlp.browsertesting.Browsers; + +public class Chromium extends MozillaFamilyLinuxBrowser { + + public Chromium(String bin) { + super(bin); + } + + @Override + public Browsers getID() { + return Browsers.chromiumBrowser; + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Epiphany.java b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Epiphany.java new file mode 100644 index 0000000..3adc3d8 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Epiphany.java @@ -0,0 +1,18 @@ +package net.sourceforge.jnlp.browsertesting.browsers; + +import net.sourceforge.jnlp.browsertesting.Browsers; + +public class Epiphany extends MozillaFamilyLinuxBrowser { + + public Epiphany(String bin) { + super(bin); + } + + @Override + public Browsers getID() { + return Browsers.epiphany; + } + + + +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Firefox.java b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Firefox.java new file mode 100644 index 0000000..8458bce --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Firefox.java @@ -0,0 +1,29 @@ +package net.sourceforge.jnlp.browsertesting.browsers; + +import java.util.Arrays; +import java.util.List; +import net.sourceforge.jnlp.browsertesting.Browsers; + +public class Firefox extends MozillaFamilyLinuxBrowser { + + public Firefox(String bin) { + super(bin); + } + + String[] cs={"-no-remote", "-new-tab"}; + + @Override + public Browsers getID() { + return Browsers.firefox; + } + + @Override + public List<String> getComaptibilitySwitches() { + return Arrays.asList(cs); + } + + + + + +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/LinuxBrowser.java b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/LinuxBrowser.java new file mode 100644 index 0000000..edc95e0 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/LinuxBrowser.java @@ -0,0 +1,60 @@ +package net.sourceforge.jnlp.browsertesting.browsers; + +import net.sourceforge.jnlp.browsertesting.Browser; + + +public abstract class LinuxBrowser implements Browser{ + public static final String DEFAULT_PLUGIN_NAME="libjavaplugin.so"; + public static final String DEFAULT_BIN_PATH="/usr/bin/"; + + protected final String bin; + protected String fsdir="unknown"; + + public LinuxBrowser(String bin) { + this.bin = bin; + } + + + + @Override + public String getBin() { + return bin; + } + +// @Override +// public void setBin(String bin) { +// this.bin=bin; +// } + + @Override + public String getDefaultBin() { + return DEFAULT_BIN_PATH+getID().toExec(); + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof Browser)) return false; + Browser b=(Browser) obj; + return b.getBin().equals(getBin()); + } + + @Override + public int hashCode() { + int hash = 5; + hash = 59 * hash + (this.bin != null ? this.bin.hashCode() : 0); + return hash; + } + + @Override + public String getDefaultPluginExpectedLocation() { + if (System.getProperty("os.arch").contains("64")) { + return "/usr/lib64/"+fsdir+"/plugins"; + } else { + return "/usr/lib/"+fsdir+"/plugins"; + + } + } + + + +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Midory.java b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Midory.java new file mode 100644 index 0000000..fc563fb --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Midory.java @@ -0,0 +1,18 @@ +package net.sourceforge.jnlp.browsertesting.browsers; + +import net.sourceforge.jnlp.browsertesting.Browsers; + +public class Midory extends MozillaFamilyLinuxBrowser { + + public Midory(String bin) { + super(bin); + } + + @Override + public Browsers getID() { + return Browsers.midori; + } + + + +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/MozillaFamilyLinuxBrowser.java b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/MozillaFamilyLinuxBrowser.java new file mode 100644 index 0000000..c8d1e85 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/MozillaFamilyLinuxBrowser.java @@ -0,0 +1,29 @@ +package net.sourceforge.jnlp.browsertesting.browsers; + +import java.util.List; + +public abstract class MozillaFamilyLinuxBrowser extends LinuxBrowser{ + + public MozillaFamilyLinuxBrowser(String bin) { + super(bin); + fsdir="mozilla"; + } + + + @Override + public List<String> getComaptibilitySwitches() { + return null; + } + + @Override + public List<String> getDefaultSwitches() { + return null; + } + + @Override + public String getUserDefaultPluginExpectedLocation() { + return System.getProperty("user.home")+"/.mozilla/plugins"; + } + + +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Opera.java b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Opera.java new file mode 100644 index 0000000..edbf57f --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/browsertesting/browsers/Opera.java @@ -0,0 +1,37 @@ +package net.sourceforge.jnlp.browsertesting.browsers; + +import java.util.Arrays; +import java.util.List; +import net.sourceforge.jnlp.browsertesting.Browsers; + +public class Opera extends LinuxBrowser { + + public Opera(String bin) { + super(bin); + fsdir="opera"; + } + + @Override + public Browsers getID() { + return Browsers.opera; + } + + @Override + public String getUserDefaultPluginExpectedLocation() { + return null; + } + + + String[] cs={"-nosession", "-nomail", "-nolirc", "-newtab"}; + + @Override + public List<String> getComaptibilitySwitches() { + return Arrays.asList(cs); + } + + @Override + public List<String> getDefaultSwitches() { + return null; + } + +}
\ No newline at end of file |