Refactored reproducers directry structure

1 files changed, 828 insertions, 0 deletions

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);
+        }
+    }
+    }