< prev index next >

tools/FxTestRunner/src/client/test/runner/CommonTestRunnerWorker.java

Print this page
rev 319 : 8160349: [TEST BUG] Hanged test blocks port and breaks following tests
Summary: Now each test uses random free port and test runner correctly handles interrupts from javatest.


  28 import java.io.IOException;
  29 import java.io.ObjectInputStream;
  30 import java.io.ObjectOutputStream;
  31 import java.io.PrintStream;
  32 import java.io.Serializable;
  33 import java.net.Socket;
  34 import java.util.concurrent.Semaphore;
  35 import org.junit.runner.JUnitCore;
  36 import org.junit.runner.Request;
  37 import org.junit.runner.Result;
  38 import org.junit.runner.notification.Failure;
  39 import org.junit.runner.notification.RunListener;
  40 import test.javaclient.shared.screenshots.ImagesManager;
  41 
  42 /**
  43  *
  44  * @author shura, mrkam, Sergey Grinev, Victor Shubov
  45  */
  46 public class CommonTestRunnerWorker {
  47 
  48     static final int PORT = 56179;

  49 
  50     private final JUnitCore core = new JUnitCore();
  51     private Abstract2TestRunner testRunner;
  52     private final Semaphore uilock = new Semaphore(0);
  53     private Socket socket;
  54     private String testClassName;
  55     private String testName;
  56     private long testStart;
  57     private String host = "127.0.0.1";
  58     private boolean debugMode = false;
  59     private volatile boolean isExiting = false;
  60 
  61     private CommonTestRunnerWorker() {
  62     }
  63 
  64     /**
  65      *
  66      * @param _testRunner
  67      */
  68     public CommonTestRunnerWorker(Abstract2TestRunner _testRunner) {
  69         testRunner = _testRunner;
  70     }
  71 
  72     private final Thread exitThread = new Thread(new Runnable() {
  73         @Override
  74         public void run() {
  75             waitUI();
  76             exit(testRunner.getCurrentStatus());
  77         }
  78     }, "exit waiter");
  79 



  80     /**
  81      *
  82      * @throws Throwable
  83      */
  84     public void runUI() throws Throwable {
  85         System.out.println("CommonTestRunnerWorker.runUI(): starting test...");
  86         core.addListener(new RunListener() {
  87 
  88             @Override
  89             public void testAssumptionFailure(Failure failure) {
  90                 System.out.println("junit failure: " + failure.getMessage());
  91                 failure.getException().printStackTrace();
  92                 exit(Abstract2TestRunner.Status.FAIL);
  93             }
  94 
  95             @Override
  96             public void testFailure(Failure failure) throws Exception {
  97                 System.out.println("junit failure: " + failure.getMessage());
  98                 failure.getException().printStackTrace();
  99                 exit(Abstract2TestRunner.Status.FAIL);


 167      *
 168      * @return
 169      */
 170     public String getTestName() {
 171         return testName;
 172     }
 173 
 174     /**
 175      *
 176      */
 177     protected final void prepareAndRunTest() {
 178 
 179         if (debugMode) {
 180             runTest();
 181             System.err.println("Test done.");
 182             return;
 183         }
 184 
 185         testStart = System.nanoTime();
 186         try {
 187             report("Looking for server at host " + host + ", port " + PORT + "...");

 188             socket = new Socket(host, PORT);


 189             ObjectInputStream readerStream = new ObjectInputStream(socket.getInputStream());
 190             report("Connected");
 191 
 192             loop:
 193             do {
 194                 Command trc = (Command) readerStream.readObject();
 195                 report("Got command: " + trc.type + ":" + trc.param);
 196                 switch (trc.type) {
 197                     case SET_TEST_CLASS:
 198                         testClassName = trc.param;
 199                         break;
 200                     case SET_BASEDIR:
 201                         //TODO: this design is a bit flawed as we introducing backward
 202                         //dependency on SharedTestUtils here.
 203                         ImagesManager.getInstance().setBaseDir(trc.param);
 204                         break;
 205                     case SET_ABSOLUTE_DIR:
 206                         ImagesManager.getInstance().setAbsoluteDir(trc.param);
 207                         break;
 208                     case SET_TEST_NAME:




  28 import java.io.IOException;
  29 import java.io.ObjectInputStream;
  30 import java.io.ObjectOutputStream;
  31 import java.io.PrintStream;
  32 import java.io.Serializable;
  33 import java.net.Socket;
  34 import java.util.concurrent.Semaphore;
  35 import org.junit.runner.JUnitCore;
  36 import org.junit.runner.Request;
  37 import org.junit.runner.Result;
  38 import org.junit.runner.notification.Failure;
  39 import org.junit.runner.notification.RunListener;
  40 import test.javaclient.shared.screenshots.ImagesManager;
  41 
  42 /**
  43  *
  44  * @author shura, mrkam, Sergey Grinev, Victor Shubov
  45  */
  46 public class CommonTestRunnerWorker {
  47 
  48     static final int DEFAULT_PORT = 56179;

  49 
  50     private final JUnitCore core = new JUnitCore();
  51     private Abstract2TestRunner testRunner;
  52     private final Semaphore uilock = new Semaphore(0);
  53     private Socket socket;
  54     private String testClassName;
  55     private String testName;
  56     private long testStart;
  57     private String host = "127.0.0.1";
  58     private boolean debugMode = false;
  59     private volatile boolean isExiting = false;
  60 
  61     private CommonTestRunnerWorker() {
  62     }
  63 
  64     /**
  65      *
  66      * @param _testRunner
  67      */
  68     public CommonTestRunnerWorker(Abstract2TestRunner _testRunner) {
  69         testRunner = _testRunner;
  70     }
  71 
  72     private final Thread exitThread = new Thread(new Runnable() {
  73         @Override
  74         public void run() {
  75             waitUI();
  76             exit(testRunner.getCurrentStatus());
  77         }
  78     }, "exit waiter");
  79 
  80     static int getTestPort() {

  81         return Integer.valueOf(System.getProperty("masterPort", String.valueOf(DEFAULT_PORT)));

  82     }

  83     /**
  84      *
  85      * @throws Throwable
  86      */
  87     public void runUI() throws Throwable {
  88         System.out.println("CommonTestRunnerWorker.runUI(): starting test...");
  89         core.addListener(new RunListener() {
  90 
  91             @Override
  92             public void testAssumptionFailure(Failure failure) {
  93                 System.out.println("junit failure: " + failure.getMessage());
  94                 failure.getException().printStackTrace();
  95                 exit(Abstract2TestRunner.Status.FAIL);
  96             }
  97 
  98             @Override
  99             public void testFailure(Failure failure) throws Exception {
 100                 System.out.println("junit failure: " + failure.getMessage());
 101                 failure.getException().printStackTrace();
 102                 exit(Abstract2TestRunner.Status.FAIL);


 170      *
 171      * @return
 172      */
 173     public String getTestName() {
 174         return testName;
 175     }
 176 
 177     /**
 178      *
 179      */
 180     protected final void prepareAndRunTest() {
 181 
 182         if (debugMode) {
 183             runTest();
 184             System.err.println("Test done.");
 185             return;
 186         }
 187 
 188         testStart = System.nanoTime();
 189         try {
 190             int port = getTestPort();

 191             report("Looking for server at host " + host + ", port " + port + "...");

 192             socket = new Socket(host, port);

 193             ObjectInputStream readerStream = new ObjectInputStream(socket.getInputStream());
 194             report("Connected");
 195 
 196             loop:
 197             do {
 198                 Command trc = (Command) readerStream.readObject();
 199                 report("Got command: " + trc.type + ":" + trc.param);
 200                 switch (trc.type) {
 201                     case SET_TEST_CLASS:
 202                         testClassName = trc.param;
 203                         break;
 204                     case SET_BASEDIR:
 205                         //TODO: this design is a bit flawed as we introducing backward
 206                         //dependency on SharedTestUtils here.
 207                         ImagesManager.getInstance().setBaseDir(trc.param);
 208                         break;
 209                     case SET_ABSOLUTE_DIR:
 210                         ImagesManager.getInstance().setAbsoluteDir(trc.param);
 211                         break;
 212                     case SET_TEST_NAME:


< prev index next >