user/src/com/google/gwt/junit/JUnitMessageQueue.java - gwt - Git at Google

 /*
  * 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;

 import com.google.gwt.junit.client.TimeoutException;
 import com.google.gwt.junit.client.impl.JUnitResult;
 import com.google.gwt.junit.client.impl.JUnitHost.TestInfo;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 /**
  * A message queue to pass data between {@link JUnitShell} and {@link
  * com.google.gwt.junit.server.JUnitHostImpl} in a thread-safe manner.
  *
  * <p>
  * The public methods are called by the servlet to find out what test to execute
  * next, and to report the results of the last test to run.
  * </p>
  *
  * <p>
  * The protected methods are called by the shell to fetch test results and drive
  * the next test the client should run.
  * </p>
  */
 public class JUnitMessageQueue {

   /**
    * Holds the state of an individual client.
    */
   public static class ClientStatus {
     public final String clientId;

     public JUnitResult currentTestResults = null;
     public boolean hasRequestedCurrentTest = false;
     public boolean isNew = true;

     public ClientStatus(String clientId) {
       this.clientId = clientId;
     }
   }

   /**
    * Records results for each client; must lock before accessing.
    */
   private final Map<String, ClientStatus> clientStatuses = new HashMap<String, ClientStatus>();

   /**
    * The lock used to synchronize access to clientStatuses.
    */
   private Object clientStatusesLock = new Object();

   /**
    * The current test to execute.
    */
   private TestInfo currentTest;

   /**
    * The number of TestCase clients executing in parallel.
    */
   private final int numClients;

   /**
    * Only instantiable within this package.
    *
    * @param numClients The number of parallel clients being served by this
    *          queue.
    */
   JUnitMessageQueue(int numClients) {
     synchronized (clientStatusesLock) {
       this.numClients = numClients;
     }
   }

   /**
    * Called by the servlet to query for for the next method to test.
    *
    * @param timeout how long to wait for an answer
    * @return the next test to run, or <code>null</code> if
    *         <code>timeout</code> is exceeded or the next test does not match
    *         <code>testClassName</code>
    */
   public TestInfo getNextTestInfo(String clientId, long timeout)
       throws TimeoutException {
     synchronized (clientStatusesLock) {
       ClientStatus clientStatus = clientStatuses.get(clientId);
       if (clientStatus == null) {
         clientStatus = new ClientStatus(clientId);
         clientStatuses.put(clientId, clientStatus);
       }

       long startTime = System.currentTimeMillis();
       long stopTime = startTime + timeout;
       while (clientStatus.currentTestResults != null) {
         long timeToWait = stopTime - System.currentTimeMillis();
         if (timeToWait < 1) {
           double elapsed = (System.currentTimeMillis() - startTime) / 1000.0;
           throw new TimeoutException("The servlet did not respond to the "
               + "next query to test within " + timeout + "ms.\n"
               + " Client id: " + clientId + "\n" + " Actual time elapsed: "
               + elapsed + " seconds.\n");
         }
         try {
           clientStatusesLock.wait(timeToWait);
         } catch (InterruptedException e) {
           /*
            * Should never happen; but if it does, just send a null back to the
            * client, which will cause it to stop running tests.
            */
           System.err.println("Unexpected thread interruption");
           e.printStackTrace();
           return null;
         }
       }

       // Record that this client has retrieved the current test.
       clientStatus.hasRequestedCurrentTest = true;
       return currentTest;
     }
   }

   /**
    * Called by the servlet to report the results of the last test to run.
    *
    * @param testInfo the testInfo the result is for
    * @param results the result of running the test
    */
   public void reportResults(String clientId, TestInfo testInfo,
       JUnitResult results) {
     synchronized (clientStatusesLock) {
       if (testInfo != null && !testInfo.equals(currentTest)) {
         // A client is reporting results for the wrong test.
         return;
       }
       assert (results != null);
       ClientStatus clientStatus = clientStatuses.get(clientId);
       /*
        * Unknown client, but valid testInfo; this can happen if the client's
        * module fails to load.
        */
       if (clientStatus == null) {
         clientStatus = new ClientStatus(clientId);
         clientStatuses.put(clientId, clientStatus);
       }
       clientStatus.currentTestResults = results;
       clientStatusesLock.notifyAll();
     }
   }

   /**
    * Returns any new clients that have contacted the server since the last call.
    * The same client will never be returned from this method twice.
    */
   String[] getNewClients() {
     synchronized (clientStatusesLock) {
       List<String> results = new ArrayList<String>();
       for (ClientStatus clientStatus : clientStatuses.values()) {
         if (clientStatus.isNew) {
           results.add(clientStatus.clientId);
           // Record that this client is no longer new.
           clientStatus.isNew = false;
         }
       }
       return results.toArray(new String[results.size()]);
     }
   }

   /**
    * Returns how many clients have requested the currently-running test.
    */
   int getNumClientsRetrievedCurrentTest() {
     int count = 0;
     synchronized (clientStatusesLock) {
       for (ClientStatus clientStatus : clientStatuses.values()) {
         if (clientStatus.hasRequestedCurrentTest) {
           ++count;
         }
       }
     }
     return count;
   }

   /**
    * Fetches the results of a completed test.
    *
    * @return A map of results from all clients.
    */
   Map<String, JUnitResult> getResults() {
     synchronized (clientStatusesLock) {
       Map<String, JUnitResult> result = new HashMap<String, JUnitResult>();
       for (ClientStatus clientStatus : clientStatuses.values()) {
         result.put(clientStatus.clientId, clientStatus.currentTestResults);
       }
       return result;
     }
   }

   /**
    * Returns a pretty printed list of clients that have not retrieved the
    * current test. Used for error reporting.
    *
    * @return a string containing the list of clients that have not retrieved the
    *         current test.
    */
   String getUnretrievedClients() {
     synchronized (clientStatusesLock) {
       StringBuilder buf = new StringBuilder();
       int lineCount = 0;
       for (ClientStatus clientStatus : clientStatuses.values()) {
         if (lineCount > 0) {
           buf.append('\n');
         }

         if (!clientStatus.hasRequestedCurrentTest) {
           buf.append(" - NO RESPONSE: ");
         } else {
           buf.append(" - (ok): ");
         }
         buf.append(clientStatus.clientId);
         ++lineCount;
       }
       int difference = numClients - getNumClientsRetrievedCurrentTest();
       if (difference > 0) {
         if (lineCount > 0) {
           buf.append('\n');
         }
         buf.append(" - "
             + difference
             + " client(s) haven't responded back to JUnitShell since the start of the test.");
       }
       return buf.toString();
     }
   }

   /**
    * Called by the shell to see if the currently-running test has completed.
    *
    * @return If the test has completed, <code>true</code>, otherwise
    *         <code>false</code>.
    */
   boolean hasResult() {
     synchronized (clientStatusesLock) {
       if (numClients > clientStatuses.size()) {
         return false;
       }
       for (ClientStatus clientStatus : clientStatuses.values()) {
         if (clientStatus.currentTestResults == null) {
           return false;
         }
       }
     }
     return true;
   }

   /**
    * Called by the shell to set the next test to run.
    */
   void setNextTest(TestInfo testInfo) {
     synchronized (clientStatusesLock) {
       this.currentTest = testInfo;
       for (ClientStatus clientStatus : clientStatuses.values()) {
         clientStatus.hasRequestedCurrentTest = false;
         clientStatus.currentTestResults = null;
       }
       clientStatusesLock.notifyAll();
     }
   }

   void waitForResults(int millis) {
     synchronized (clientStatusesLock) {
       try {
         clientStatusesLock.wait(millis);
       } catch (InterruptedException e) {
       }
     }
   }
 }
	/*
	* 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;

	import com.google.gwt.junit.client.TimeoutException;
	import com.google.gwt.junit.client.impl.JUnitResult;
	import com.google.gwt.junit.client.impl.JUnitHost.TestInfo;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	/**
	* A message queue to pass data between {@link JUnitShell} and {@link
	* com.google.gwt.junit.server.JUnitHostImpl} in a thread-safe manner.
	*
	* <p>
	* The public methods are called by the servlet to find out what test to execute
	* next, and to report the results of the last test to run.
	* </p>
	*
	* <p>
	* The protected methods are called by the shell to fetch test results and drive
	* the next test the client should run.
	* </p>
	*/
	public class JUnitMessageQueue {

	/**
	* Holds the state of an individual client.
	*/
	public static class ClientStatus {
	public final String clientId;

	public JUnitResult currentTestResults = null;
	public boolean hasRequestedCurrentTest = false;
	public boolean isNew = true;

	public ClientStatus(String clientId) {
	this.clientId = clientId;
	}
	}

	/**
	* Records results for each client; must lock before accessing.
	*/
	private final Map<String, ClientStatus> clientStatuses = new HashMap<String, ClientStatus>();

	/**
	* The lock used to synchronize access to clientStatuses.
	*/
	private Object clientStatusesLock = new Object();

	/**
	* The current test to execute.
	*/
	private TestInfo currentTest;

	/**
	* The number of TestCase clients executing in parallel.
	*/
	private final int numClients;

	/**
	* Only instantiable within this package.
	*
	* @param numClients The number of parallel clients being served by this
	* queue.
	*/
	JUnitMessageQueue(int numClients) {
	synchronized (clientStatusesLock) {
	this.numClients = numClients;
	}
	}

	/**
	* Called by the servlet to query for for the next method to test.
	*
	* @param timeout how long to wait for an answer
	* @return the next test to run, or <code>null</code> if
	* <code>timeout</code> is exceeded or the next test does not match
	* <code>testClassName</code>
	*/
	public TestInfo getNextTestInfo(String clientId, long timeout)
	throws TimeoutException {
	synchronized (clientStatusesLock) {
	ClientStatus clientStatus = clientStatuses.get(clientId);
	if (clientStatus == null) {
	clientStatus = new ClientStatus(clientId);
	clientStatuses.put(clientId, clientStatus);
	}

	long startTime = System.currentTimeMillis();
	long stopTime = startTime + timeout;
	while (clientStatus.currentTestResults != null) {
	long timeToWait = stopTime - System.currentTimeMillis();
	if (timeToWait < 1) {
	double elapsed = (System.currentTimeMillis() - startTime) / 1000.0;
	throw new TimeoutException("The servlet did not respond to the "
	+ "next query to test within " + timeout + "ms.\n"
	+ " Client id: " + clientId + "\n" + " Actual time elapsed: "
	+ elapsed + " seconds.\n");
	}
	try {
	clientStatusesLock.wait(timeToWait);
	} catch (InterruptedException e) {
	/*
	* Should never happen; but if it does, just send a null back to the
	* client, which will cause it to stop running tests.
	*/
	System.err.println("Unexpected thread interruption");
	e.printStackTrace();
	return null;
	}
	}

	// Record that this client has retrieved the current test.
	clientStatus.hasRequestedCurrentTest = true;
	return currentTest;
	}
	}

	/**
	* Called by the servlet to report the results of the last test to run.
	*
	* @param testInfo the testInfo the result is for
	* @param results the result of running the test
	*/
	public void reportResults(String clientId, TestInfo testInfo,
	JUnitResult results) {
	synchronized (clientStatusesLock) {
	if (testInfo != null && !testInfo.equals(currentTest)) {
	// A client is reporting results for the wrong test.
	return;
	}
	assert (results != null);
	ClientStatus clientStatus = clientStatuses.get(clientId);
	/*
	* Unknown client, but valid testInfo; this can happen if the client's
	* module fails to load.
	*/
	if (clientStatus == null) {
	clientStatus = new ClientStatus(clientId);
	clientStatuses.put(clientId, clientStatus);
	}
	clientStatus.currentTestResults = results;
	clientStatusesLock.notifyAll();
	}
	}

	/**
	* Returns any new clients that have contacted the server since the last call.
	* The same client will never be returned from this method twice.
	*/
	String[] getNewClients() {
	synchronized (clientStatusesLock) {
	List<String> results = new ArrayList<String>();
	for (ClientStatus clientStatus : clientStatuses.values()) {
	if (clientStatus.isNew) {
	results.add(clientStatus.clientId);
	// Record that this client is no longer new.
	clientStatus.isNew = false;
	}
	}
	return results.toArray(new String[results.size()]);
	}
	}

	/**
	* Returns how many clients have requested the currently-running test.
	*/
	int getNumClientsRetrievedCurrentTest() {
	int count = 0;
	synchronized (clientStatusesLock) {
	for (ClientStatus clientStatus : clientStatuses.values()) {
	if (clientStatus.hasRequestedCurrentTest) {
	++count;
	}
	}
	}
	return count;
	}

	/**
	* Fetches the results of a completed test.
	*
	* @return A map of results from all clients.
	*/
	Map<String, JUnitResult> getResults() {
	synchronized (clientStatusesLock) {
	Map<String, JUnitResult> result = new HashMap<String, JUnitResult>();
	for (ClientStatus clientStatus : clientStatuses.values()) {
	result.put(clientStatus.clientId, clientStatus.currentTestResults);
	}
	return result;
	}
	}

	/**
	* Returns a pretty printed list of clients that have not retrieved the
	* current test. Used for error reporting.
	*
	* @return a string containing the list of clients that have not retrieved the
	* current test.
	*/
	String getUnretrievedClients() {
	synchronized (clientStatusesLock) {
	StringBuilder buf = new StringBuilder();
	int lineCount = 0;
	for (ClientStatus clientStatus : clientStatuses.values()) {
	if (lineCount > 0) {
	buf.append('\n');
	}

	if (!clientStatus.hasRequestedCurrentTest) {
	buf.append(" - NO RESPONSE: ");
	} else {
	buf.append(" - (ok): ");
	}
	buf.append(clientStatus.clientId);
	++lineCount;
	}
	int difference = numClients - getNumClientsRetrievedCurrentTest();
	if (difference > 0) {
	if (lineCount > 0) {
	buf.append('\n');
	}
	buf.append(" - "
	+ difference
	+ " client(s) haven't responded back to JUnitShell since the start of the test.");
	}
	return buf.toString();
	}
	}

	/**
	* Called by the shell to see if the currently-running test has completed.
	*
	* @return If the test has completed, <code>true</code>, otherwise
	* <code>false</code>.
	*/
	boolean hasResult() {
	synchronized (clientStatusesLock) {
	if (numClients > clientStatuses.size()) {
	return false;
	}
	for (ClientStatus clientStatus : clientStatuses.values()) {
	if (clientStatus.currentTestResults == null) {
	return false;
	}
	}
	}
	return true;
	}

	/**
	* Called by the shell to set the next test to run.
	*/
	void setNextTest(TestInfo testInfo) {
	synchronized (clientStatusesLock) {
	this.currentTest = testInfo;
	for (ClientStatus clientStatus : clientStatuses.values()) {
	clientStatus.hasRequestedCurrentTest = false;
	clientStatus.currentTestResults = null;
	}
	clientStatusesLock.notifyAll();
	}
	}

	void waitForResults(int millis) {
	synchronized (clientStatusesLock) {
	try {
	clientStatusesLock.wait(millis);
	} catch (InterruptedException e) {
	}
	}
	}
	}