2.1/user/test/com/google/gwt/junit/remote/BrowserManagerServerTest.java

/*
 * Copyright 2008 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.junit.remote;

import junit.framework.TestCase;

import java.io.File;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.Properties;

/**
 * Exercise the BrowserManagerServer with the serialized option turned on and
 * off.
 */
public class BrowserManagerServerTest extends TestCase {
  /**
   * Seconds for simulated browser to hang.
   */
  static final int TIMEOUT_MS = 2000;
  /**
   * Time to wait between keepAlive calls to all browsers.
   */
  static final int PING_INTERVAL_MS = 100;
  static final boolean LOG = false;

  private static final String REGISTRATION_KEY = "sleep-" + (TIMEOUT_MS / 1000)
      + "-seconds";
  private static Registry rmiRegistry = null;

  private int portArg = Registry.REGISTRY_PORT;
  private BrowserManagerServer server = null;

  /**
   * Run a test with the 'serialized' flag on.
   */
  public void testSerializedServer() throws Exception {
    BrowserManager browserManager = startBrowserManagerServer(true);

    // Launch some browsers all at once.
    final int NUM_BROWSERS = 4;
    int tokens[] = new int[NUM_BROWSERS];

    for (int i = 0; i < NUM_BROWSERS; i++) {
      tokens[i] = launchBrowser(browserManager, i);
    }

    // Give them a chance to startup.
    Thread.sleep(TIMEOUT_MS / 4);

    int numQueued = server.numQueued();
    int numRunning = server.numRunning();
    assertEquals("Did not find the number of expected browsers queued up",
        NUM_BROWSERS - 1, numQueued);
    assertEquals("Expected only one running at a time for serialized.", 1,
        numRunning);

    outer : for (int runningBrowser = 0; runningBrowser < NUM_BROWSERS; ++runningBrowser) {
      // The current browser should be dead within twice the expected timeout.
      long shouldBeDeadBy = System.currentTimeMillis() + (TIMEOUT_MS * 2);
      while (System.currentTimeMillis() < shouldBeDeadBy) {
        assertTrue(server.numRunning() <= 1);

        // Ping every alive browser.
        for (int i = runningBrowser; i < NUM_BROWSERS; ++i) {
          // Keep the browser alive with a margin of safety until the next ping.
          try {
            browserManager.keepAlive(tokens[runningBrowser], TIMEOUT_MS);
          } catch (IllegalStateException ise) {
            // Expected.
            assertEquals("The wrong browser is dead", runningBrowser, i);
            if (LOG) {
              System.out.println("Browser token: " + tokens[i]
                  + " exited sucessfully");
            }
            // Ensure it's legal to kill the dead browser.
            browserManager.killBrowser(tokens[i]);
            // Continue with the next active browser.
            continue outer;
          }
        }
        Thread.sleep(PING_INTERVAL_MS);
      }
      // Error case
      fail("Browser " + runningBrowser + " failed to exit in a timely manner");
    }
  }

  /**
   * Run a test with the 'serialized' flag on.
   */
  public void testUnserializedServer() throws Exception {
    BrowserManager browserManager = startBrowserManagerServer(false);

    // Launch some browsers all at once.
    final int NUM_BROWSERS = 6;
    int tokens[] = new int[NUM_BROWSERS];

    for (int i = 0; i < NUM_BROWSERS; i++) {
      tokens[i] = launchBrowser(browserManager, i);
    }

    // Give them a chance to startup.
    Thread.sleep(TIMEOUT_MS / 4);

    int numQueued = server.numQueued();
    int numRunning = server.numRunning();
    assertEquals("No queuing should occur", 0, numQueued);
    assertEquals("All browers should be running", NUM_BROWSERS, numRunning);

    // The current browser should be dead within twice the expected timeout.
    long shouldBeDeadBy = System.currentTimeMillis() + (TIMEOUT_MS * 2);
    int liveBrowsers = NUM_BROWSERS;
    while (System.currentTimeMillis() < shouldBeDeadBy) {
      // Ping every alive browser.
      for (int i = 0; i < NUM_BROWSERS; ++i) {
        if (tokens[i] == 0) {
          // This one's already dead.
          continue;
        }
        // Keep the browser alive with a margin of safety until the next ping.
        try {
          browserManager.keepAlive(tokens[i], TIMEOUT_MS);
        } catch (IllegalStateException ise) {
          // Expected.
          if (LOG) {
            System.out.println("Browser token: " + tokens[i]
                + " exited sucessfully");
          }
          // Ensure it's legal to kill the dead browser.
          browserManager.killBrowser(tokens[i]);

          tokens[i] = 0;
          --liveBrowsers;

          if (liveBrowsers == 0) {
            // All done;
            return;
          }
        }
      }
      Thread.sleep(PING_INTERVAL_MS);
    }
    // Error case
    fail(liveBrowsers + " browsers failed to exit in a timely manner");
  }

  /**
   * Start up the RMI registry and create a shell script that just sleeps for
   * 'timeout' seconds.
   */
  @Override
  protected void setUp() throws Exception {
    if (rmiRegistry == null) {
      rmiRegistry = LocateRegistry.createRegistry(portArg);
    }
  }

  /**
   * Clean up temporary files.
   */
  @Override
  protected void tearDown() throws Exception {
    // De-register the server.
    if (rmiRegistry != null) {
      rmiRegistry.unbind(REGISTRATION_KEY);
    }
  }

  /**
   * Start a browser task on the server.
   * 
   * @param browserManager handle to the browser manager instance
   * @param token browser ident number
   */
  private int launchBrowser(BrowserManager browserManager, int token)
      throws RemoteException {
    return browserManager.launchNewBrowser("# client" + token, TIMEOUT_MS);
  }

  /**
   * Starts up an instance of BrowserManagerServer.
   * 
   * @param isSerialized true to enable the serialized mode (run one browser
   *          instance at a time, queue any others.)
   * @return the newly created instance of BrowserManagerServer on success
   */
  private BrowserManager startBrowserManagerServer(boolean isSerialized)
      throws RemoteException, MalformedURLException, NotBoundException {
    // Construct a launch command for relaunching the JVM out of process,
    // running DummyProcess.
    StringBuilder sb = new StringBuilder();
    Properties properties = System.getProperties();
    sb.append(properties.getProperty("java.home"));
    sb.append(File.separatorChar);
    sb.append("bin");
    sb.append(File.separatorChar);
    sb.append("java");
    sb.append('\n');

    sb.append("-classpath");
    sb.append('\n');

    sb.append(properties.getProperty("java.class.path"));
    sb.append('\n');

    sb.append(DummyProcess.class.getName());

    server = new BrowserManagerServer(sb.toString(), isSerialized);
    rmiRegistry.rebind(REGISTRATION_KEY, server);

    // Server started. Now, create a client and send some commands to it
    String url = "rmi://localhost/" + REGISTRATION_KEY;
    BrowserManager browserManager = (BrowserManager) Naming.lookup(url);
    return browserManager;
  }
}