1_5/modules/kernel/test/org/apache/axis2/context/ContextPropertiesTest.java - axis-axis2-java-core - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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 org.apache.axis2.context;

 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;

 import junit.framework.TestCase;

 /**
  * Test the setting of properties on an AbstractContext instance.  Note that MessageContext is used
  * in most of the tests as the concrete implementation of AbstractContext.  Some tests also test
  * the HashTableUpdateLockable collection used in AbstractContext.proeprties directly.
  */
 public class ContextPropertiesTest extends TestCase {

     /**
      * Test to ensure using an Iterator from getPropertyNames() after the properties have been
      * updated does not cause a ConcurrentModificationException.  The CME does not happen because
      * the Iterator is over a copy of the key names, not the actual collection (which would cause
      * a CME in this test).
      */
     public void testPropertyNamesForCME() {
         MessageContext mc = new MessageContext();

         mc.setProperty("key1", "value1");
         mc.setProperty("key2", "value2");
         mc.setProperty(null, "value3_nullkey");
         mc.setProperty("key4_nullvalue", null);

         // Get an iterator over the key names, then add a new element.
         // This simulates two threads accessing the context.  This should not cause
         // a ConcurrentModificationException (it will if a live iterator over the collection
         // key set is returned by getPropertyNames())
         Iterator propNamesIterator = mc.getPropertyNames();
         mc.setProperty("newKey", "newValue");
         while (propNamesIterator.hasNext()) {
             // Verify
             // (1) that calling next() on the iterator does not cause a CME,
             // (2) that the keys are as expected and
             // (3) those keys can be used to access the entries in the collection.
             String checkKey = (String) propNamesIterator.next();
             Iterator concurrentIterator = mc.getPropertyNames();
             while (concurrentIterator.hasNext()) {
                 String concurrentKey = (String) concurrentIterator.next();
             }
         }
     }

     /**
      * Test that using an iterator of propertyNames does not cause a CME.  This is degenerate
      * test of the test for CME that updates the collection before using the iterator.
      * @see #testPropertyNamesForCME()
      */
     public void testPropertyNamesForCME_NoUpdate() {
         MessageContext mc = new MessageContext();

         mc.setProperty("key1", "value1");
         mc.setProperty("key2", "value2");
         mc.setProperty(null, "value3_nullkey");
         mc.setProperty("key4_nullvalue", null);

         Iterator propNamesIterator = mc.getPropertyNames();
         while (propNamesIterator.hasNext()) {
             Iterator concurrentIterator = mc.getPropertyNames();
             // Verify
             // (1) that calling next() on the iterator does not cause a CME,
             // (2) that the keys are as expected and
             // (3) those keys can be used to access the entries in the collection.
             String checkKey = (String) propNamesIterator.next();
         }
     }

     /**
      * Test some aspects of the Concurrent collection directly, such as creating with a Map.
      */
     public void testHashMapUpdateLockable() {

         HashMapUpdateLockable testMap = new HashMapUpdateLockable();
         testMap.put("key", "value");
         testMap.put(1, 2);

         Map map = new HashMap();
         map.put("k1", "v1");
         map.put("k2", "v2");
         map.put(null, "v3NullKey");
         map.put("k3_null", null);
         HashMapUpdateLockable testCtorMap = new HashMapUpdateLockable(map);
         assertEquals("v1", testCtorMap.get("k1"));
         assertEquals("v2", testCtorMap.get("k2"));
         assertEquals("v3NullKey", testCtorMap.get(null));
         assertNull(testCtorMap.get("k3_null"));

         // put returns the previous value if there was one, or null
         assertEquals("v1", testCtorMap.put("k1", "newK1Value"));
         assertNull(testCtorMap.put("k3_null", "newK3Value"));
         assertNull(testCtorMap.put("noSuchKey-put", "value6"));

         // remove returns the value if there was an entry with that key, or null
         assertNull(testCtorMap.remove("noSuchKey-remove"));
         testCtorMap.put("key7", null);
         assertNull(testCtorMap.remove("key7"));

     }

     // =============================================================================================
     // The following tests are multithreaded tests to test the locking, blocking, and releasing
     // of threads by the HashTableUpdateLockable collection.
     // =============================================================================================

     /**
      * Methods on HashTableUpdateLockable to be tested.  The update methods are tested to
      * verify they block while the updateLock is held.  Some non-update methods are tested to
      * verify they do not block if the updateLock is held.
      */
     private enum MethodToCheck {checkLock_wait, checkLock_nowait, put, putAll, remove, get};

     /**
      * Test HashTableUpdateLockable.remove method which overrides the HashTable method.
      * Tests the HashTableUpdateLockable collection in a multithreaded environment to ensure that
      * a thread trying to update the collection will block as long as another thread has the
      * collection locked for update.  Note that UpdateRunnable performs the actual test of the
      * method.
      * @see UpdateRunnable#run()
      *
      */
     public void testMultithreadUpdateLock_remove() {
         MultithreadUpdateLockMonitor testMonitor = new MultithreadUpdateLockMonitor();
         HashMapUpdateLockable testMap = new HashMapUpdateLockable();
         testMap.put("testKey1", "value1");
         testMap.put("removeKey", "value2");
         startupTestThreads(testMonitor, testMap, MethodToCheck.remove);

         assertNoThreadErrors(testMonitor);

         // Make sure the update thread blocked, i.e. the lockThread was released before the update thread.
         assertTrue(testMonitor.lockThreadReleaseTime <= testMonitor.updateThreadReleaseTime);
     }

     /**
      * Test HashTableUpdateLockable.putAll method which overrides the HashTable method.
      * Tests the HashTableUpdateLockable collection in a multithreaded environment to ensure that
      * a thread trying to update the collection will block as long as another thread has the
      * collection locked for update.  Note that UpdateRunnable performs the actual test of the
      * method.
      * @see UpdateRunnable#run()
      */
     public void testMultithreadUpdateLock_putAll() {
         MultithreadUpdateLockMonitor testMonitor = new MultithreadUpdateLockMonitor();
         HashMapUpdateLockable testMap = new HashMapUpdateLockable();
         startupTestThreads(testMonitor, testMap, MethodToCheck.putAll);

         assertNoThreadErrors(testMonitor);

         // Make sure the update thread blocked, i.e. the lockThread was released before the update thread.
         assertTrue(testMonitor.lockThreadReleaseTime <= testMonitor.updateThreadReleaseTime);
     }

     /**
      * Test HashTableUpdateLockable.put method which overrides the HashTable method.
      * Tests the HashTableUpdateLockable collection in a multithreaded environment to ensure that
      * a thread trying to update the collection will block as long as another thread has the
      * collection locked for update.  Note that UpdateRunnable performs the actual test of the
      * method.
      * @see UpdateRunnable#run()
      */
     public void testMultithreadUpdateLock_put() {
         MultithreadUpdateLockMonitor testMonitor = new MultithreadUpdateLockMonitor();
         HashMapUpdateLockable testMap = new HashMapUpdateLockable();
         startupTestThreads(testMonitor, testMap, MethodToCheck.put);

         assertNoThreadErrors(testMonitor);

         // Make sure the update thread blocked, i.e. the lockThread was released before the update thread.
         assertTrue(testMonitor.lockThreadReleaseTime <= testMonitor.updateThreadReleaseTime);
     }

     /**
      * Test HashTableUpdateLockable.put method which overrides the HashTable method.
      * Tests the HashTableUpdateLockable collection in a multithreaded environment to ensure that
      * a thread trying to update the collection does not block as long as another thread has the
      * collection locked for update.  Note that UpdateRunnable performs the actual test of the
      * method.
      * @see UpdateRunnable#run()
      */
     public void testMultithreadUpdateLock_get() {
         MultithreadUpdateLockMonitor testMonitor = new MultithreadUpdateLockMonitor();
         HashMapUpdateLockable testMap = new HashMapUpdateLockable();
         testMap.put("key1", "value1");
         testMap.put("key2", "value2");
         testMap.put("getKey", "value3");
         startupTestThreads(testMonitor, testMap, MethodToCheck.get);

         assertNoThreadErrors(testMonitor);

         // The update thread shouldn't block since we said to not wait.
         assertTrue(testMonitor.updateThreadReleaseTime <= testMonitor.lockThreadReleaseTime);
     }

     /**
      * Test HashTableUpdateLockable.checkUpdateLock method.
      * Tests the HashTableUpdateLockable collection in a multithreaded environment to ensure that
      * a thread trying to update the collection will block as long as another thread has the
      * collection locked for update.  Note that UpdateRunnable performs the actual test of the
      * method.
      * @see UpdateRunnable#run()
      */
     public void testMultithreadUpdateLock_checkLock_wait() {
         MultithreadUpdateLockMonitor testMonitor = new MultithreadUpdateLockMonitor();
         HashMapUpdateLockable testMap = new HashMapUpdateLockable();
         startupTestThreads(testMonitor, testMap, MethodToCheck.checkLock_wait);

         assertNoThreadErrors(testMonitor);

         // Make sure the update thread blocked, i.e. the lockThread was released before the update thread.
         assertTrue(testMonitor.lockThreadReleaseTime <= testMonitor.updateThreadReleaseTime);
         // Make sure the return value indicates the table was not locked.
         assertFalse(((Boolean) testMonitor.methodToTestReturnValue).booleanValue());
     }

     /**
      * Test HashTableUpdateLockable.checkUpdateLock method.
      * Tests the HashTableUpdateLockable collection in a multithreaded environment to ensure that
      * a thread trying to update the collection will not block as long as another thread has the
      * collection locked for update.  Note that UpdateRunnable performs the actual test of the
      * method.
      * @see UpdateRunnable#run()
      */
     public void testMultithreadUpdateLock_checkLock_nowait() {
         MultithreadUpdateLockMonitor testMonitor = new MultithreadUpdateLockMonitor();
         HashMapUpdateLockable testMap = new HashMapUpdateLockable();
         startupTestThreads(testMonitor, testMap, MethodToCheck.checkLock_nowait);

         assertNoThreadErrors(testMonitor);

         // The update thread shouldn't block since we said to not wait.
         assertTrue(testMonitor.updateThreadReleaseTime <= testMonitor.lockThreadReleaseTime);
         // Make sure the return value indicates the table was locked.
         assertTrue(((Boolean) testMonitor.methodToTestReturnValue).booleanValue());
     }

     // Amount of time the testcase should wait on the test threads before timing out
     private static int THREAD_TIMEOUT = 90000;
     // Amount of time the thread holding the update lock should sleep.  This needs to be long
     // enough so that comparisons between the time the locking thread is released and the update
     // thread is released can be reliably compared as an indication of whether the update thread
     // was blocked.
     private static int LOCK_THREAD_SLEEP = 5000;

     /**
      * Assert there were no errors in the basic running of the threads.
      * @param testMonitor contains information about each of the test threads.
      */
     private void assertNoThreadErrors(MultithreadUpdateLockMonitor testMonitor) {
         // Make sure both threads were released (i.e. release time != 0) and that the
         // that there were no exceptions encountered

         assertNull(testMonitor.lockThreadException);
         assertTrue(testMonitor.lockThreadReleaseTime != 0);

         assertNull(testMonitor.updateThreadException);
         assertTrue(testMonitor.updateThreadReleaseTime != 0);
     }

     /**
      * Configures the test threads with the common object to store information about each one, the
      * collection to be tested and the method to be tested.  Two threads will be started:
      * (1) A thread that will lock the collection, sleep, then unlock the collection
      * (2) A thread that will try to update the collection while it is locked.
      * Thread (2) should block if the method to be tested is one that would update the table,
      * otherwise it should not block.
      *
      * @param testMonitor Common object used to communicate between the test method and the two
      * test threads
      * @param testMap Instance of HashTableUpdateLockable to test
      * @param methodToTest The method on HashTableUpdateLockable to be tested.
      */
     private void startupTestThreads(MultithreadUpdateLockMonitor testMonitor,
                                     HashMapUpdateLockable testMap,
                                     MethodToCheck methodToTest) {
         LockingRunnable lockingRunnable = new LockingRunnable();
         lockingRunnable.testMonitor = testMonitor;
         lockingRunnable.testMap = testMap;
         lockingRunnable.methodToTest = methodToTest;

         UpdateRunnable updateRunnable = new UpdateRunnable();
         updateRunnable.testMonitor = testMonitor;
         updateRunnable.testMap = testMap;
         updateRunnable.methodToTest = methodToTest;

         Thread lockingThread = new Thread(lockingRunnable, "Locking");
         Thread updateThread = new Thread(updateRunnable, "Updating");

         // To eliminate a timing window where the locking thread starts and runs to completion
         // before the update thread gets started, start the update thread first.  It will block
         // waiting on the locking thread to complete.
         updateThread.start();
         lockingThread.start();

         // Join the threads to wait for their completion, specifying a timeout to prevent
         // a testcase hang if something goes wrong with the threads.
         try {
             lockingThread.join(THREAD_TIMEOUT);
             updateThread.join(THREAD_TIMEOUT);
         } catch (InterruptedException e) {
             e.printStackTrace();
             fail("Unable to join to testing threads");
         }
     }

     /**
      * Object used to communicate information between the testcase and the two test threads.
      */
     class MultithreadUpdateLockMonitor {
         long lockThreadReleaseTime = 0;
         boolean lockSetupComplete = false;
         RuntimeException lockThreadException = null;

         long updateThreadReleaseTime = 0;
         RuntimeException updateThreadException = null;

         Object methodToTestReturnValue = null;
     }

     /**
      * Abstract superclass of the two test threads.
      */
     abstract class UpdateLockableTestRunnable implements Runnable {
         MultithreadUpdateLockMonitor testMonitor = null;
         MethodToCheck methodToTest = null;
         HashMapUpdateLockable testMap = null;
     }


     /**
      * Test thread that will lock the collection, sleep, then unlock the collection.
      */
     class LockingRunnable extends UpdateLockableTestRunnable {

         public void run() {
             try {
                 // Lock the table, then relese the "lockSetupComplete" waiters, which will
                 // release the update thread.
                 // NOTE that the lock is done inside a try block and the unlock is done in
                 // a finaly block so that it will always be executed.
                 testMap.lockForUpdate();
                 synchronized (testMonitor) {
                     testMonitor.lockThreadReleaseTime = 0;
                     testMonitor.lockSetupComplete = true;
                     testMonitor.notifyAll();
                 }
                 // Sleep for a while to verify that the update thread is being blocked while
                 // the table is locked by this thread.  Then unlock the table.
                 try {
                     Thread.sleep(LOCK_THREAD_SLEEP);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                     testMonitor.lockThreadException = new RuntimeException(e);
                     throw testMonitor.lockThreadException;
             }
             } finally {
                 // Get the current time before releasing the lock.  On some systems, as soon as the
                 // notify is done, the waiting thread will immediately get control.
                 testMonitor.lockThreadReleaseTime = System.currentTimeMillis();
                 testMap.unlockForUpdate();
             }
         }
     }

     /**
      * Thread that will run the methods to be tested on the collection while it is locked for
      * update by another thread.
      */
     class UpdateRunnable extends UpdateLockableTestRunnable  {
         public void run() {
             // Setup whatever we'll need to test laser on
             Map putAllMap = new HashMap();
             putAllMap.put("k1", "v1");
             putAllMap.put("k2", "v2");
             putAllMap.put("k3", "v3");

             // Wait till the locking thread is setup
             synchronized(testMonitor) {
                 testMonitor.updateThreadReleaseTime = 0;
                 while(!testMonitor.lockSetupComplete) {
                     try {
                         testMonitor.wait();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                         testMonitor.updateThreadException = new RuntimeException(e);
                         throw testMonitor.updateThreadException;
                     }
                 }
             }

             // Test the update method specified
             switch(methodToTest) {
             case checkLock_wait:
                 boolean retValWait = testMap.checkUpdateLock(true);
                 testMonitor.methodToTestReturnValue = new Boolean(retValWait);
                 break;
             case checkLock_nowait:
                 boolean retValNoWait = testMap.checkUpdateLock(false);
                 testMonitor.methodToTestReturnValue = new Boolean(retValNoWait);
                 break;
             case put:
                 testMap.put("newKey", "newValue");
                 break;
             case putAll:
                 testMap.putAll(putAllMap);
                 break;
             case remove:
                 testMap.remove("removeKey");
                 break;
             case get:
                 testMap.get("getKey");
                 break;
             default:
                 testMonitor.updateThreadException =
                     new UnsupportedOperationException("method to test not recognized: " + methodToTest);
                 throw testMonitor.updateThreadException;
             }
             testMonitor.updateThreadReleaseTime = System.currentTimeMillis();
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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 org.apache.axis2.context;

	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.Map;

	import junit.framework.TestCase;

	/**
	* Test the setting of properties on an AbstractContext instance. Note that MessageContext is used
	* in most of the tests as the concrete implementation of AbstractContext. Some tests also test
	* the HashTableUpdateLockable collection used in AbstractContext.proeprties directly.
	*/
	public class ContextPropertiesTest extends TestCase {

	/**
	* Test to ensure using an Iterator from getPropertyNames() after the properties have been
	* updated does not cause a ConcurrentModificationException. The CME does not happen because
	* the Iterator is over a copy of the key names, not the actual collection (which would cause
	* a CME in this test).
	*/
	public void testPropertyNamesForCME() {
	MessageContext mc = new MessageContext();

	mc.setProperty("key1", "value1");
	mc.setProperty("key2", "value2");
	mc.setProperty(null, "value3_nullkey");
	mc.setProperty("key4_nullvalue", null);

	// Get an iterator over the key names, then add a new element.
	// This simulates two threads accessing the context. This should not cause
	// a ConcurrentModificationException (it will if a live iterator over the collection
	// key set is returned by getPropertyNames())
	Iterator propNamesIterator = mc.getPropertyNames();
	mc.setProperty("newKey", "newValue");
	while (propNamesIterator.hasNext()) {
	// Verify
	// (1) that calling next() on the iterator does not cause a CME,
	// (2) that the keys are as expected and
	// (3) those keys can be used to access the entries in the collection.
	String checkKey = (String) propNamesIterator.next();
	Iterator concurrentIterator = mc.getPropertyNames();
	while (concurrentIterator.hasNext()) {
	String concurrentKey = (String) concurrentIterator.next();
	}
	}
	}

	/**
	* Test that using an iterator of propertyNames does not cause a CME. This is degenerate
	* test of the test for CME that updates the collection before using the iterator.
	* @see #testPropertyNamesForCME()
	*/
	public void testPropertyNamesForCME_NoUpdate() {
	MessageContext mc = new MessageContext();

	mc.setProperty("key1", "value1");
	mc.setProperty("key2", "value2");
	mc.setProperty(null, "value3_nullkey");
	mc.setProperty("key4_nullvalue", null);

	Iterator propNamesIterator = mc.getPropertyNames();
	while (propNamesIterator.hasNext()) {
	Iterator concurrentIterator = mc.getPropertyNames();
	// Verify
	// (1) that calling next() on the iterator does not cause a CME,
	// (2) that the keys are as expected and
	// (3) those keys can be used to access the entries in the collection.
	String checkKey = (String) propNamesIterator.next();
	}
	}

	/**
	* Test some aspects of the Concurrent collection directly, such as creating with a Map.
	*/
	public void testHashMapUpdateLockable() {

	HashMapUpdateLockable testMap = new HashMapUpdateLockable();
	testMap.put("key", "value");
	testMap.put(1, 2);

	Map map = new HashMap();
	map.put("k1", "v1");
	map.put("k2", "v2");
	map.put(null, "v3NullKey");
	map.put("k3_null", null);
	HashMapUpdateLockable testCtorMap = new HashMapUpdateLockable(map);
	assertEquals("v1", testCtorMap.get("k1"));
	assertEquals("v2", testCtorMap.get("k2"));
	assertEquals("v3NullKey", testCtorMap.get(null));
	assertNull(testCtorMap.get("k3_null"));

	// put returns the previous value if there was one, or null
	assertEquals("v1", testCtorMap.put("k1", "newK1Value"));
	assertNull(testCtorMap.put("k3_null", "newK3Value"));
	assertNull(testCtorMap.put("noSuchKey-put", "value6"));

	// remove returns the value if there was an entry with that key, or null
	assertNull(testCtorMap.remove("noSuchKey-remove"));
	testCtorMap.put("key7", null);
	assertNull(testCtorMap.remove("key7"));

	}

	// =============================================================================================
	// The following tests are multithreaded tests to test the locking, blocking, and releasing
	// of threads by the HashTableUpdateLockable collection.
	// =============================================================================================

	/**
	* Methods on HashTableUpdateLockable to be tested. The update methods are tested to
	* verify they block while the updateLock is held. Some non-update methods are tested to
	* verify they do not block if the updateLock is held.
	*/
	private enum MethodToCheck {checkLock_wait, checkLock_nowait, put, putAll, remove, get};

	/**
	* Test HashTableUpdateLockable.remove method which overrides the HashTable method.
	* Tests the HashTableUpdateLockable collection in a multithreaded environment to ensure that
	* a thread trying to update the collection will block as long as another thread has the
	* collection locked for update. Note that UpdateRunnable performs the actual test of the
	* method.
	* @see UpdateRunnable#run()
	*
	*/
	public void testMultithreadUpdateLock_remove() {
	MultithreadUpdateLockMonitor testMonitor = new MultithreadUpdateLockMonitor();
	HashMapUpdateLockable testMap = new HashMapUpdateLockable();
	testMap.put("testKey1", "value1");
	testMap.put("removeKey", "value2");
	startupTestThreads(testMonitor, testMap, MethodToCheck.remove);

	assertNoThreadErrors(testMonitor);

	// Make sure the update thread blocked, i.e. the lockThread was released before the update thread.
	assertTrue(testMonitor.lockThreadReleaseTime <= testMonitor.updateThreadReleaseTime);
	}

	/**
	* Test HashTableUpdateLockable.putAll method which overrides the HashTable method.
	* Tests the HashTableUpdateLockable collection in a multithreaded environment to ensure that
	* a thread trying to update the collection will block as long as another thread has the
	* collection locked for update. Note that UpdateRunnable performs the actual test of the
	* method.
	* @see UpdateRunnable#run()
	*/
	public void testMultithreadUpdateLock_putAll() {
	MultithreadUpdateLockMonitor testMonitor = new MultithreadUpdateLockMonitor();
	HashMapUpdateLockable testMap = new HashMapUpdateLockable();
	startupTestThreads(testMonitor, testMap, MethodToCheck.putAll);

	assertNoThreadErrors(testMonitor);

	// Make sure the update thread blocked, i.e. the lockThread was released before the update thread.
	assertTrue(testMonitor.lockThreadReleaseTime <= testMonitor.updateThreadReleaseTime);
	}

	/**
	* Test HashTableUpdateLockable.put method which overrides the HashTable method.
	* Tests the HashTableUpdateLockable collection in a multithreaded environment to ensure that
	* a thread trying to update the collection will block as long as another thread has the
	* collection locked for update. Note that UpdateRunnable performs the actual test of the
	* method.
	* @see UpdateRunnable#run()
	*/
	public void testMultithreadUpdateLock_put() {
	MultithreadUpdateLockMonitor testMonitor = new MultithreadUpdateLockMonitor();
	HashMapUpdateLockable testMap = new HashMapUpdateLockable();
	startupTestThreads(testMonitor, testMap, MethodToCheck.put);

	assertNoThreadErrors(testMonitor);

	// Make sure the update thread blocked, i.e. the lockThread was released before the update thread.
	assertTrue(testMonitor.lockThreadReleaseTime <= testMonitor.updateThreadReleaseTime);
	}

	/**
	* Test HashTableUpdateLockable.put method which overrides the HashTable method.
	* Tests the HashTableUpdateLockable collection in a multithreaded environment to ensure that
	* a thread trying to update the collection does not block as long as another thread has the
	* collection locked for update. Note that UpdateRunnable performs the actual test of the
	* method.
	* @see UpdateRunnable#run()
	*/
	public void testMultithreadUpdateLock_get() {
	MultithreadUpdateLockMonitor testMonitor = new MultithreadUpdateLockMonitor();
	HashMapUpdateLockable testMap = new HashMapUpdateLockable();
	testMap.put("key1", "value1");
	testMap.put("key2", "value2");
	testMap.put("getKey", "value3");
	startupTestThreads(testMonitor, testMap, MethodToCheck.get);

	assertNoThreadErrors(testMonitor);

	// The update thread shouldn't block since we said to not wait.
	assertTrue(testMonitor.updateThreadReleaseTime <= testMonitor.lockThreadReleaseTime);
	}

	/**
	* Test HashTableUpdateLockable.checkUpdateLock method.
	* Tests the HashTableUpdateLockable collection in a multithreaded environment to ensure that
	* a thread trying to update the collection will block as long as another thread has the
	* collection locked for update. Note that UpdateRunnable performs the actual test of the
	* method.
	* @see UpdateRunnable#run()
	*/
	public void testMultithreadUpdateLock_checkLock_wait() {
	MultithreadUpdateLockMonitor testMonitor = new MultithreadUpdateLockMonitor();
	HashMapUpdateLockable testMap = new HashMapUpdateLockable();
	startupTestThreads(testMonitor, testMap, MethodToCheck.checkLock_wait);

	assertNoThreadErrors(testMonitor);

	// Make sure the update thread blocked, i.e. the lockThread was released before the update thread.
	assertTrue(testMonitor.lockThreadReleaseTime <= testMonitor.updateThreadReleaseTime);
	// Make sure the return value indicates the table was not locked.
	assertFalse(((Boolean) testMonitor.methodToTestReturnValue).booleanValue());
	}

	/**
	* Test HashTableUpdateLockable.checkUpdateLock method.
	* Tests the HashTableUpdateLockable collection in a multithreaded environment to ensure that
	* a thread trying to update the collection will not block as long as another thread has the
	* collection locked for update. Note that UpdateRunnable performs the actual test of the
	* method.
	* @see UpdateRunnable#run()
	*/
	public void testMultithreadUpdateLock_checkLock_nowait() {
	MultithreadUpdateLockMonitor testMonitor = new MultithreadUpdateLockMonitor();
	HashMapUpdateLockable testMap = new HashMapUpdateLockable();
	startupTestThreads(testMonitor, testMap, MethodToCheck.checkLock_nowait);

	assertNoThreadErrors(testMonitor);

	// The update thread shouldn't block since we said to not wait.
	assertTrue(testMonitor.updateThreadReleaseTime <= testMonitor.lockThreadReleaseTime);
	// Make sure the return value indicates the table was locked.
	assertTrue(((Boolean) testMonitor.methodToTestReturnValue).booleanValue());
	}

	// Amount of time the testcase should wait on the test threads before timing out
	private static int THREAD_TIMEOUT = 90000;
	// Amount of time the thread holding the update lock should sleep. This needs to be long
	// enough so that comparisons between the time the locking thread is released and the update
	// thread is released can be reliably compared as an indication of whether the update thread
	// was blocked.
	private static int LOCK_THREAD_SLEEP = 5000;

	/**
	* Assert there were no errors in the basic running of the threads.
	* @param testMonitor contains information about each of the test threads.
	*/
	private void assertNoThreadErrors(MultithreadUpdateLockMonitor testMonitor) {
	// Make sure both threads were released (i.e. release time != 0) and that the
	// that there were no exceptions encountered

	assertNull(testMonitor.lockThreadException);
	assertTrue(testMonitor.lockThreadReleaseTime != 0);

	assertNull(testMonitor.updateThreadException);
	assertTrue(testMonitor.updateThreadReleaseTime != 0);
	}

	/**
	* Configures the test threads with the common object to store information about each one, the
	* collection to be tested and the method to be tested. Two threads will be started:
	* (1) A thread that will lock the collection, sleep, then unlock the collection
	* (2) A thread that will try to update the collection while it is locked.
	* Thread (2) should block if the method to be tested is one that would update the table,
	* otherwise it should not block.
	*
	* @param testMonitor Common object used to communicate between the test method and the two
	* test threads
	* @param testMap Instance of HashTableUpdateLockable to test
	* @param methodToTest The method on HashTableUpdateLockable to be tested.
	*/
	private void startupTestThreads(MultithreadUpdateLockMonitor testMonitor,
	HashMapUpdateLockable testMap,
	MethodToCheck methodToTest) {
	LockingRunnable lockingRunnable = new LockingRunnable();
	lockingRunnable.testMonitor = testMonitor;
	lockingRunnable.testMap = testMap;
	lockingRunnable.methodToTest = methodToTest;

	UpdateRunnable updateRunnable = new UpdateRunnable();
	updateRunnable.testMonitor = testMonitor;
	updateRunnable.testMap = testMap;
	updateRunnable.methodToTest = methodToTest;

	Thread lockingThread = new Thread(lockingRunnable, "Locking");
	Thread updateThread = new Thread(updateRunnable, "Updating");

	// To eliminate a timing window where the locking thread starts and runs to completion
	// before the update thread gets started, start the update thread first. It will block
	// waiting on the locking thread to complete.
	updateThread.start();
	lockingThread.start();

	// Join the threads to wait for their completion, specifying a timeout to prevent
	// a testcase hang if something goes wrong with the threads.
	try {
	lockingThread.join(THREAD_TIMEOUT);
	updateThread.join(THREAD_TIMEOUT);
	} catch (InterruptedException e) {
	e.printStackTrace();
	fail("Unable to join to testing threads");
	}
	}

	/**
	* Object used to communicate information between the testcase and the two test threads.
	*/
	class MultithreadUpdateLockMonitor {
	long lockThreadReleaseTime = 0;
	boolean lockSetupComplete = false;
	RuntimeException lockThreadException = null;

	long updateThreadReleaseTime = 0;
	RuntimeException updateThreadException = null;

	Object methodToTestReturnValue = null;
	}

	/**
	* Abstract superclass of the two test threads.
	*/
	abstract class UpdateLockableTestRunnable implements Runnable {
	MultithreadUpdateLockMonitor testMonitor = null;
	MethodToCheck methodToTest = null;
	HashMapUpdateLockable testMap = null;
	}


	/**
	* Test thread that will lock the collection, sleep, then unlock the collection.
	*/
	class LockingRunnable extends UpdateLockableTestRunnable {

	public void run() {
	try {
	// Lock the table, then relese the "lockSetupComplete" waiters, which will
	// release the update thread.
	// NOTE that the lock is done inside a try block and the unlock is done in
	// a finaly block so that it will always be executed.
	testMap.lockForUpdate();
	synchronized (testMonitor) {
	testMonitor.lockThreadReleaseTime = 0;
	testMonitor.lockSetupComplete = true;
	testMonitor.notifyAll();
	}
	// Sleep for a while to verify that the update thread is being blocked while
	// the table is locked by this thread. Then unlock the table.
	try {
	Thread.sleep(LOCK_THREAD_SLEEP);
	} catch (InterruptedException e) {
	e.printStackTrace();
	testMonitor.lockThreadException = new RuntimeException(e);
	throw testMonitor.lockThreadException;
	}
	} finally {
	// Get the current time before releasing the lock. On some systems, as soon as the
	// notify is done, the waiting thread will immediately get control.
	testMonitor.lockThreadReleaseTime = System.currentTimeMillis();
	testMap.unlockForUpdate();
	}
	}
	}

	/**
	* Thread that will run the methods to be tested on the collection while it is locked for
	* update by another thread.
	*/
	class UpdateRunnable extends UpdateLockableTestRunnable {
	public void run() {
	// Setup whatever we'll need to test laser on
	Map putAllMap = new HashMap();
	putAllMap.put("k1", "v1");
	putAllMap.put("k2", "v2");
	putAllMap.put("k3", "v3");

	// Wait till the locking thread is setup
	synchronized(testMonitor) {
	testMonitor.updateThreadReleaseTime = 0;
	while(!testMonitor.lockSetupComplete) {
	try {
	testMonitor.wait();
	} catch (InterruptedException e) {
	e.printStackTrace();
	testMonitor.updateThreadException = new RuntimeException(e);
	throw testMonitor.updateThreadException;
	}
	}
	}

	// Test the update method specified
	switch(methodToTest) {
	case checkLock_wait:
	boolean retValWait = testMap.checkUpdateLock(true);
	testMonitor.methodToTestReturnValue = new Boolean(retValWait);
	break;
	case checkLock_nowait:
	boolean retValNoWait = testMap.checkUpdateLock(false);
	testMonitor.methodToTestReturnValue = new Boolean(retValNoWait);
	break;
	case put:
	testMap.put("newKey", "newValue");
	break;
	case putAll:
	testMap.putAll(putAllMap);
	break;
	case remove:
	testMap.remove("removeKey");
	break;
	case get:
	testMap.get("getKey");
	break;
	default:
	testMonitor.updateThreadException =
	new UnsupportedOperationException("method to test not recognized: " + methodToTest);
	throw testMonitor.updateThreadException;
	}
	testMonitor.updateThreadReleaseTime = System.currentTimeMillis();
	}
	}
	}