Index: cluster/src/main/org/jboss/ha/framework/server/lock/YieldingGloballyExclusiveClusterLockSupport.java
===================================================================
--- cluster/src/main/org/jboss/ha/framework/server/lock/YieldingGloballyExclusiveClusterLockSupport.java	(revision 113708)
+++ cluster/src/main/org/jboss/ha/framework/server/lock/YieldingGloballyExclusiveClusterLockSupport.java	(working copy)
@@ -82,12 +82,17 @@
    @Override
    protected RemoteLockResponse yieldLock(ClusterLockState lockState, ClusterNode caller, long timeout)
    {
+       log.info("yieldLock() > "+getLocalClusterNode()+" - "+ lockState.getHolder() + " = "+ getLocalClusterNode().equals(lockState.getHolder()));
       if (getLocalClusterNode().equals(lockState.getHolder()))
       {
-         return getLock(lockState.lockId, lockState, caller, timeout);
+          
+          RemoteLockResponse rsp =getLock(lockState.lockId, lockState, caller, timeout);
+          log.info("yieldLock() > "+rsp);
+         return rsp;
       }
       else
       {
+         log.info("yieldLock() -> REJECT > "+new RemoteLockResponse(getLocalClusterNode(), RemoteLockResponse.Flag.REJECT, lockState.getHolder()));
          return new RemoteLockResponse(getLocalClusterNode(), RemoteLockResponse.Flag.REJECT, lockState.getHolder());
       }
    }
Index: cluster/src/main/org/jboss/ha/framework/server/lock/AbstractClusterLockSupport.java
===================================================================
--- cluster/src/main/org/jboss/ha/framework/server/lock/AbstractClusterLockSupport.java	(revision 113708)
+++ cluster/src/main/org/jboss/ha/framework/server/lock/AbstractClusterLockSupport.java	(working copy)
@@ -137,8 +137,10 @@
       
       long left = timeout > 0 ? timeout : Long.MAX_VALUE;
       long start = System.currentTimeMillis();
+      log.info("--> start: "+start); 
       while (left > 0)
       {
+         log.info("--> left: "+left); 
          // Another node we lost to who should take precedence
          // over ourself in competition for the lock
          ClusterNode superiorCompetitor = null;
@@ -235,8 +237,10 @@
          // If we've detected we are competing with someone else who is 
          // "superior" pause longer to let them proceed first.
          long backoff = computeBackoff(timeout, start, left, superiorCompetitor == null);
+         log.info("--> backoff: "+backoff); 
          if (backoff > 0)
          {
+             
             try
             {
                Thread.sleep(backoff);
@@ -257,6 +261,8 @@
          long now = System.currentTimeMillis();
          left -= (now - start);
          start = now;
+         log.info("--> new left: "+left); 
+         log.info("--> new start: "+start); 
       }
       
       return false;
@@ -543,6 +549,7 @@
    {
       try
       {
+          log.info("---> cleanup()");
          partition.callMethodOnCluster(getServiceHAName(), "releaseRemoteLock", new Object[]{categoryName, me}, RELEASE_REMOTE_LOCK_TYPES, true);
       }
       catch (RuntimeException e)
Index: testsuite/src/main/org/jboss/test/cluster/lock/ClusteredLockManagerTestBase.java
===================================================================
--- testsuite/src/main/org/jboss/test/cluster/lock/ClusteredLockManagerTestBase.java	(revision 113708)
+++ testsuite/src/main/org/jboss/test/cluster/lock/ClusteredLockManagerTestBase.java	(working copy)
@@ -115,244 +115,244 @@
       super.tearDown();
    }
 
-   public void testConstructor() throws Exception
-   {
-      HAPartition haPartition = createNiceMock(HAPartition.class);      
-      LocalLockHandler handler = createNiceMock(LocalLockHandler.class);
-      
-      try
-      {
-         createClusteredLockManager(null, haPartition, handler);
-         fail("Null serviceHAName should prevent construction");
-      }
-      catch (IllegalArgumentException good) {}
-      
-      try
-      {
-         createClusteredLockManager("test", null, handler);
-         fail("Null HAPartition should prevent construction");
-      }
-      catch (IllegalArgumentException good) {}     
-      
-      try
-      {
-         createClusteredLockManager("test", haPartition, null);
-         fail("Null LocalLockHandler should prevent construction");
-      }
-      catch (IllegalArgumentException good) {}  
-      
-      expect(haPartition.getClusterNode()).andReturn(node1);
-      expect(haPartition.getPartitionName()).andReturn("TestPartition");
-      
-      replay(haPartition);
-      replay(handler);
-      
-      T testee = createClusteredLockManager("test", haPartition, handler);
-      
-      assertEquals("test", testee.getServiceHAName());
-      assertEquals("TestPartition", testee.getPartitionName());
-   }
-
-   public void testStart() throws Exception
-   {
-      HAPartition haPartition = createNiceMock(HAPartition.class);      
-      LocalLockHandler handler = createNiceMock(LocalLockHandler.class);       
-      expect(haPartition.getClusterNode()).andReturn(node1);
-      expect(haPartition.getPartitionName()).andReturn("TestPartition");
-      
-      replay(haPartition);
-      replay(handler);      
-      
-      T testee = createClusteredLockManager("test", haPartition, handler);
-      
-      try
-      {
-         testee.lock("id", 1000);
-         fail("Call to lock() should fail if not started");
-      }
-      catch (IllegalStateException good) {}
-      
-      try
-      {
-         testee.unlock("id");
-         fail("Call to unlock() should fail if not started");
-      }
-      catch (IllegalStateException good) {}
-      
-      reset(haPartition);
-      
-      assertEquals("Current view is empty when unstarted", 0, testee.getCurrentView().size());
-      
-      haPartition.registerRPCHandler(eq("test"), isA(RpcTarget.class));
-      haPartition.registerMembershipListener(testee);
-      expect(haPartition.getClusterNodes()).andReturn(new ClusterNode[]{node1});
-      replay(haPartition);
-      
-      testee.start();
-      
-      verify(haPartition);
-      
-      assertEquals("Current view is correct", 1, testee.getCurrentView().size());
-      assertTrue(testee.getCurrentView().contains(node1));
-      
-   }
-
-   public void testStop() throws Exception
-   {
-      TesteeSet<T> testeeSet = getTesteeSet(node1, 0, 1);
-      T testee = testeeSet.impl;
-      HAPartition haPartition = testee.getPartition();      
-      
-      reset(haPartition);
-   
-      haPartition.unregisterMembershipListener(testee);
-      haPartition.unregisterRPCHandler(eq("test"), same(testeeSet.target));
-      
-      replay(haPartition);
-      
-      testee.stop();
-      
-      verify(haPartition);
-      
-      assertEquals("Current view is empty when stopped", 0, testee.getCurrentView().size());
-      
-      try
-      {
-         testee.lock("id", 1000);
-         fail("Call to lock() should fail if stopped");
-      }
-      catch (IllegalStateException good) {}
-      
-      try
-      {
-         testee.unlock("id");
-         fail("Call to unlock() should fail if stopped");
-      }
-      catch (IllegalStateException good) {}
-      
-   }
-
-   public void testGetMembers() throws Exception
-   {
-      TesteeSet<T> testeeSet = getTesteeSet(node1, 1, 2);
-      T testee = testeeSet.impl;
-      
-      List<ClusterNode> members = testee.getCurrentView();
-      assertEquals(2, members.size());
-      assertEquals(node1, members.get(1));
-      
-      ClusterNode dead = members.get(0);
-      assertFalse(node1.equals(dead));
-      
-      Vector<ClusterNode> newView = getView(node1, 0, 3);
-      newView.remove(dead);
-      
-      Vector<ClusterNode> addedMembers = new Vector<ClusterNode>(newView);
-      addedMembers.removeAll(members);
-      
-      Vector<ClusterNode> deadMembers = new Vector<ClusterNode>();
-      deadMembers.add(dead);
-      
-      testee.membershipChanged(deadMembers, addedMembers, newView);
-      
-      members = testee.getCurrentView();
-      assertEquals(2, members.size());
-      assertEquals(node1, members.get(0));
-      assertFalse(node1.equals(members.get(1)));
-      assertFalse(members.contains(dead));
-      
-   }
-   
-   /**
-    * Simple test of acquiring a cluster-wide lock in a two node cluster
-    * where local-only locks are supported.
-    * 
-    * @throws Exception
-    */
-   public void testBasicClusterLock() throws Exception
-   {
-      basicClusterLockTest(2);
-   }
-   
-   /**
-    * Simple test of acquiring a cluster-wide lock in a cluster where the
-    * caller is the only member and where local-only locks are supported.
-    * 
-    * @throws Exception
-    */
-   public void testStandaloneClusterLock() throws Exception
-   {
-      basicClusterLockTest(1);
-   }
-
-   private void basicClusterLockTest(int viewSize) throws Exception
-   {
-      int viewPos = viewSize == 1 ? 0 : 1;
-      TesteeSet<T> testeeSet = getTesteeSet(node1, viewPos, viewSize);
-      AbstractClusterLockSupport testee = testeeSet.impl;
-      HAPartition partition = testee.getPartition();
-      LocalLockHandler handler = testee.getLocalHandler();
-      
-      resetToStrict(partition);
-      resetToStrict(handler);
-      
-      ArrayList<RemoteLockResponse> rspList = new ArrayList<RemoteLockResponse>();
-      for (int i = 0; i < viewSize - 1; i++)
-      {
-         rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.OK));
-      }
-      
-      expect(partition.callMethodOnCluster(eq("test"), 
-                                           eq("remoteLock"), 
-                                           eqLockParams(node1, 200000), 
-                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
-                                           eq(true))).andReturn(rspList);
-      
-      handler.lockFromCluster(eq("test"), eq(node1), anyLong());
-      
-      replay(partition);
-      replay(handler);
-      
-      assertTrue(testee.lock("test", 200000));
-      
-      verify(partition);
-      verify(handler);
-      
-   }
-   
-   public void testRemoteRejectionFromSuperiorCaller() throws Exception
-   {
-      TesteeSet<T> testeeSet = getTesteeSet(node1, 1, 3);
-      AbstractClusterLockSupport testee = testeeSet.impl;
-      HAPartition partition = testee.getPartition();
-      LocalLockHandler handler = testee.getLocalHandler();
-      
-      resetToNice(partition);
-      resetToStrict(handler);
-      
-      ClusterNode superior = testee.getCurrentView().get(0);
-      
-      ArrayList<RemoteLockResponse> rspList = new ArrayList<RemoteLockResponse>();
-      rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.OK));
-      rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.REJECT, superior));
-      
-      
-      expect(partition.callMethodOnCluster(eq("test"), 
-                                           eq("remoteLock"), 
-                                           eqLockParams(node1, 200000), 
-                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
-                                           eq(true))).andReturn(rspList).atLeastOnce();
-      
-      replay(partition);
-      replay(handler);
-      
-      assertFalse(testee.lock("test", 50));
-      
-      verify(partition);
-      verify(handler);
-      
-   }
-   
+//   public void testConstructor() throws Exception
+//   {
+//      HAPartition haPartition = createNiceMock(HAPartition.class);      
+//      LocalLockHandler handler = createNiceMock(LocalLockHandler.class);
+//      
+//      try
+//      {
+//         createClusteredLockManager(null, haPartition, handler);
+//         fail("Null serviceHAName should prevent construction");
+//      }
+//      catch (IllegalArgumentException good) {}
+//      
+//      try
+//      {
+//         createClusteredLockManager("test", null, handler);
+//         fail("Null HAPartition should prevent construction");
+//      }
+//      catch (IllegalArgumentException good) {}     
+//      
+//      try
+//      {
+//         createClusteredLockManager("test", haPartition, null);
+//         fail("Null LocalLockHandler should prevent construction");
+//      }
+//      catch (IllegalArgumentException good) {}  
+//      
+//      expect(haPartition.getClusterNode()).andReturn(node1);
+//      expect(haPartition.getPartitionName()).andReturn("TestPartition");
+//      
+//      replay(haPartition);
+//      replay(handler);
+//      
+//      T testee = createClusteredLockManager("test", haPartition, handler);
+//      
+//      assertEquals("test", testee.getServiceHAName());
+//      assertEquals("TestPartition", testee.getPartitionName());
+//   }
+//
+//   public void testStart() throws Exception
+//   {
+//      HAPartition haPartition = createNiceMock(HAPartition.class);      
+//      LocalLockHandler handler = createNiceMock(LocalLockHandler.class);       
+//      expect(haPartition.getClusterNode()).andReturn(node1);
+//      expect(haPartition.getPartitionName()).andReturn("TestPartition");
+//      
+//      replay(haPartition);
+//      replay(handler);      
+//      
+//      T testee = createClusteredLockManager("test", haPartition, handler);
+//      
+//      try
+//      {
+//         testee.lock("id", 1000);
+//         fail("Call to lock() should fail if not started");
+//      }
+//      catch (IllegalStateException good) {}
+//      
+//      try
+//      {
+//         testee.unlock("id");
+//         fail("Call to unlock() should fail if not started");
+//      }
+//      catch (IllegalStateException good) {}
+//      
+//      reset(haPartition);
+//      
+//      assertEquals("Current view is empty when unstarted", 0, testee.getCurrentView().size());
+//      
+//      haPartition.registerRPCHandler(eq("test"), isA(RpcTarget.class));
+//      haPartition.registerMembershipListener(testee);
+//      expect(haPartition.getClusterNodes()).andReturn(new ClusterNode[]{node1});
+//      replay(haPartition);
+//      
+//      testee.start();
+//      
+//      verify(haPartition);
+//      
+//      assertEquals("Current view is correct", 1, testee.getCurrentView().size());
+//      assertTrue(testee.getCurrentView().contains(node1));
+//      
+//   }
+//
+//   public void testStop() throws Exception
+//   {
+//      TesteeSet<T> testeeSet = getTesteeSet(node1, 0, 1);
+//      T testee = testeeSet.impl;
+//      HAPartition haPartition = testee.getPartition();      
+//      
+//      reset(haPartition);
+//   
+//      haPartition.unregisterMembershipListener(testee);
+//      haPartition.unregisterRPCHandler(eq("test"), same(testeeSet.target));
+//      
+//      replay(haPartition);
+//      
+//      testee.stop();
+//      
+//      verify(haPartition);
+//      
+//      assertEquals("Current view is empty when stopped", 0, testee.getCurrentView().size());
+//      
+//      try
+//      {
+//         testee.lock("id", 1000);
+//         fail("Call to lock() should fail if stopped");
+//      }
+//      catch (IllegalStateException good) {}
+//      
+//      try
+//      {
+//         testee.unlock("id");
+//         fail("Call to unlock() should fail if stopped");
+//      }
+//      catch (IllegalStateException good) {}
+//      
+//   }
+//
+//   public void testGetMembers() throws Exception
+//   {
+//      TesteeSet<T> testeeSet = getTesteeSet(node1, 1, 2);
+//      T testee = testeeSet.impl;
+//      
+//      List<ClusterNode> members = testee.getCurrentView();
+//      assertEquals(2, members.size());
+//      assertEquals(node1, members.get(1));
+//      
+//      ClusterNode dead = members.get(0);
+//      assertFalse(node1.equals(dead));
+//      
+//      Vector<ClusterNode> newView = getView(node1, 0, 3);
+//      newView.remove(dead);
+//      
+//      Vector<ClusterNode> addedMembers = new Vector<ClusterNode>(newView);
+//      addedMembers.removeAll(members);
+//      
+//      Vector<ClusterNode> deadMembers = new Vector<ClusterNode>();
+//      deadMembers.add(dead);
+//      
+//      testee.membershipChanged(deadMembers, addedMembers, newView);
+//      
+//      members = testee.getCurrentView();
+//      assertEquals(2, members.size());
+//      assertEquals(node1, members.get(0));
+//      assertFalse(node1.equals(members.get(1)));
+//      assertFalse(members.contains(dead));
+//      
+//   }
+//   
+//   /**
+//    * Simple test of acquiring a cluster-wide lock in a two node cluster
+//    * where local-only locks are supported.
+//    * 
+//    * @throws Exception
+//    */
+//   public void testBasicClusterLock() throws Exception
+//   {
+//      basicClusterLockTest(2);
+//   }
+//   
+//   /**
+//    * Simple test of acquiring a cluster-wide lock in a cluster where the
+//    * caller is the only member and where local-only locks are supported.
+//    * 
+//    * @throws Exception
+//    */
+//   public void testStandaloneClusterLock() throws Exception
+//   {
+//      basicClusterLockTest(1);
+//   }
+//
+//   private void basicClusterLockTest(int viewSize) throws Exception
+//   {
+//      int viewPos = viewSize == 1 ? 0 : 1;
+//      TesteeSet<T> testeeSet = getTesteeSet(node1, viewPos, viewSize);
+//      AbstractClusterLockSupport testee = testeeSet.impl;
+//      HAPartition partition = testee.getPartition();
+//      LocalLockHandler handler = testee.getLocalHandler();
+//      
+//      resetToStrict(partition);
+//      resetToStrict(handler);
+//      
+//      ArrayList<RemoteLockResponse> rspList = new ArrayList<RemoteLockResponse>();
+//      for (int i = 0; i < viewSize - 1; i++)
+//      {
+//         rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.OK));
+//      }
+//      
+//      expect(partition.callMethodOnCluster(eq("test"), 
+//                                           eq("remoteLock"), 
+//                                           eqLockParams(node1, 200000), 
+//                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
+//                                           eq(true))).andReturn(rspList);
+//      
+//      handler.lockFromCluster(eq("test"), eq(node1), anyLong());
+//      
+//      replay(partition);
+//      replay(handler);
+//      
+//      assertTrue(testee.lock("test", 200000));
+//      
+//      verify(partition);
+//      verify(handler);
+//      
+//   }
+//   
+//   public void testRemoteRejectionFromSuperiorCaller() throws Exception
+//   {
+//      TesteeSet<T> testeeSet = getTesteeSet(node1, 1, 3);
+//      AbstractClusterLockSupport testee = testeeSet.impl;
+//      HAPartition partition = testee.getPartition();
+//      LocalLockHandler handler = testee.getLocalHandler();
+//      
+//      resetToNice(partition);
+//      resetToStrict(handler);
+//      
+//      ClusterNode superior = testee.getCurrentView().get(0);
+//      
+//      ArrayList<RemoteLockResponse> rspList = new ArrayList<RemoteLockResponse>();
+//      rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.OK));
+//      rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.REJECT, superior));
+//      
+//      
+//      expect(partition.callMethodOnCluster(eq("test"), 
+//                                           eq("remoteLock"), 
+//                                           eqLockParams(node1, 200000), 
+//                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
+//                                           eq(true))).andReturn(rspList).atLeastOnce();
+//      
+//      replay(partition);
+//      replay(handler);
+//      
+//      assertFalse(testee.lock("test", 50));
+//      
+//      verify(partition);
+//      verify(handler);
+//      
+//   }
+//   
    public void testRemoteRejectionFromInferiorCaller() throws Exception
    {
       TesteeSet<T> testeeSet = getTesteeSet(node1, 1, 3);
@@ -399,295 +399,295 @@
       replay(partition);
       replay(handler);
       
-      assertTrue(testee.lock("test", 50));
+      assertTrue(testee.lock("test", 20));
       
       verify(partition);
       verify(handler);
       
    }
-   
-   public void testLocalLockingStateRejectsSuperiorRemoteCaller() throws Exception
-   { 
-      TesteeSet<T> testeeSet = getTesteeSet(node1, 1, 3);
-      T testee = testeeSet.impl;
-      HAPartition partition = testee.getPartition();
-      LocalLockHandler handler = testee.getLocalHandler();
-      final RpcTarget target = testeeSet.target;
-      
-      ClusterNode superiorCaller = testee.getCurrentView().get(0);
-      assertFalse(node1.equals(superiorCaller));
+//   
+//   public void testLocalLockingStateRejectsSuperiorRemoteCaller() throws Exception
+//   { 
+//      TesteeSet<T> testeeSet = getTesteeSet(node1, 1, 3);
+//      T testee = testeeSet.impl;
+//      HAPartition partition = testee.getPartition();
+//      LocalLockHandler handler = testee.getLocalHandler();
+//      final RpcTarget target = testeeSet.target;
+//      
+//      ClusterNode superiorCaller = testee.getCurrentView().get(0);
+//      assertFalse(node1.equals(superiorCaller));
+//
+//      resetToStrict(partition);    
+//      makeThreadSafe(partition, true);
+//      resetToStrict(handler);   
+//      makeThreadSafe(handler, true);
+//      
+//      ArrayList<RemoteLockResponse> rspList = new ArrayList<RemoteLockResponse>();
+//      rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.OK));
+//      
+//      expect(partition.callMethodOnCluster(eq("test"), 
+//                                           eq("remoteLock"), 
+//                                           eqLockParams(node1, 200000), 
+//                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
+//                                           eq(true))).andReturn(rspList);
+//      
+//      // When caller 1 invokes, block before giving response 
+//      CountDownLatch answerAwaitLatch = new CountDownLatch(1);
+//      CountDownLatch answerStartLatch = new CountDownLatch(1);
+//      CountDownLatch answerDoneLatch = new CountDownLatch(1);
+//      BlockingAnswer<Boolean> caller1Answer = new BlockingAnswer<Boolean>(Boolean.TRUE, answerAwaitLatch, answerStartLatch, null);
+//      handler.lockFromCluster(eq("test"), eq(node1), anyLong());
+//      expectLastCall().andAnswer(caller1Answer);
+//      
+//      replay(partition);
+//      replay(handler);
+//      
+//      LocalLockCaller winner = new LocalLockCaller(testee, null, null, answerDoneLatch, 500);
+//      
+//      Thread t1 = new Thread(winner);
+//      t1.setDaemon(true);
+//      
+//      try
+//      {
+//         t1.start();         
+//         assertTrue(answerStartLatch.await(500, TimeUnit.SECONDS));
+//         // t1 should now be blocking in caller1Answer
+//         
+//         RemoteLockResponse rsp = target.remoteLock("test", superiorCaller, 1);
+//         assertEquals(RemoteLockResponse.Flag.REJECT, rsp.flag);
+//         assertEquals(node1, rsp.holder);
+//         
+//         // release t1
+//         answerAwaitLatch.countDown();
+//         
+//         // wait for t1 to complete
+//         assertTrue(answerDoneLatch.await(5, TimeUnit.SECONDS));
+//         
+//         verify(handler);
+//         
+//         rethrow("winner had an exception", winner.getException());
+//         
+//         Boolean locked = winner.getResult();         
+//         assertEquals(Boolean.TRUE, locked);
+//      }
+//      finally
+//      {
+//         if (t1.isAlive())
+//            t1.interrupt();
+//      }
+//   }
+//   
+//   public void testRemoteLockingStateAllowsSuperiorRemoteCaller() throws Exception
+//   {
+//      TesteeSet<T> testeeSet = getTesteeSet(node1, 1, 3);
+//      T testee = testeeSet.impl;
+//      HAPartition partition = testee.getPartition();
+//      LocalLockHandler handler = testee.getLocalHandler();
+//      final RpcTarget target = testeeSet.target;
+//      
+//      ClusterNode superiorCaller = testee.getCurrentView().get(0);
+//      assertFalse(node1.equals(superiorCaller));
+//
+//      resetToNice(partition);   // nice as we may loop retrying and failing 
+//      makeThreadSafe(partition, true);
+//      resetToStrict(handler);   
+//      makeThreadSafe(handler, true);
+//      
+//      // When caller 1 invokes, block before giving response 
+//      CountDownLatch answerAwaitLatch = new CountDownLatch(1);
+//      CountDownLatch answerStartLatch = new CountDownLatch(1);
+//      
+//      ArrayList<RemoteLockResponse> rspList = new ArrayList<RemoteLockResponse>();
+//      rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.OK));
+//      rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.REJECT, superiorCaller));
+//      
+//      BlockingAnswer<ArrayList<RemoteLockResponse>> caller1Answer = new BlockingAnswer<ArrayList<RemoteLockResponse>>(rspList, answerAwaitLatch, answerStartLatch, null);
+//      
+//      expect(partition.callMethodOnCluster(eq("test"), 
+//                                           eq("remoteLock"), 
+//                                           eqLockParams(node1, 200000), 
+//                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
+//                                           eq(true))).andAnswer(caller1Answer).atLeastOnce();
+//      
+//      handler.lockFromCluster(eq("test"), eq(superiorCaller), anyLong());   
+//      
+//      expect(partition.callMethodOnCluster(eq("test"), 
+//            eq("releaseRemoteLock"), 
+//            aryEq(new Object[]{"test", node1}), 
+//            aryEq(AbstractClusterLockSupport.RELEASE_REMOTE_LOCK_TYPES), 
+//            eq(true))).andReturn(new ArrayList<Object>()).atLeastOnce();
+//      		
+//      replay(partition);
+//      replay(handler);
+//
+//      CountDownLatch finishedLatch = new CountDownLatch(1);
+//      LocalLockCaller loser = new LocalLockCaller(testee, null, null, finishedLatch);
+//      
+//      Thread t1 = new Thread(loser);
+//      t1.setDaemon(true);
+//      
+//      try
+//      {
+//         t1.start();         
+//         assertTrue(answerStartLatch.await(1, TimeUnit.SECONDS));
+//         // t1 should now be blocking in caller1Answer
+//         
+//         RemoteLockResponse rsp = target.remoteLock("test", superiorCaller, 1);
+//         assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
+//         
+//         // release t1
+//         answerAwaitLatch.countDown();
+//         
+//         // wait for t1 to complete
+//         assertTrue(finishedLatch.await(5, TimeUnit.SECONDS));
+//         
+//         verify(handler);
+//         
+//         rethrow("winner had an exception", loser.getException());
+//         
+//         Boolean locked = loser.getResult();         
+//         assertEquals(Boolean.FALSE, locked);
+//      }
+//      finally
+//      {
+//         if (t1.isAlive())
+//            t1.interrupt();
+//      }
+//   }
+//   
+//   public void testRemoteLockingStateRejectsInferiorRemoteCaller() throws Exception
+//   {
+//      TesteeSet<T> testeeSet = getTesteeSet(node1, 1, 3);
+//      T testee = testeeSet.impl;
+//      HAPartition partition = testee.getPartition();
+//      LocalLockHandler handler = testee.getLocalHandler();
+//      final RpcTarget target = testeeSet.target;
+//      
+//      ClusterNode inferiorNode = testee.getCurrentView().get(2);
+//      assertFalse(node1.equals(inferiorNode));
+//      
+//      ClusterNode superiorNode = testee.getCurrentView().get(0);
+//      assertFalse(node1.equals(superiorNode));
+//
+//      resetToStrict(partition);    
+//      makeThreadSafe(partition, true);
+//      resetToStrict(handler);   
+//      makeThreadSafe(handler, true);
+//      
+//      // When caller 1 invokes, block before giving response 
+//      CountDownLatch answerAwaitLatch = new CountDownLatch(1);
+//      CountDownLatch answerStartLatch = new CountDownLatch(1);
+//      
+//      ArrayList<RemoteLockResponse> rspList = new ArrayList<RemoteLockResponse>();
+//      rspList.add(new RemoteLockResponse(superiorNode, RemoteLockResponse.Flag.OK));
+//      rspList.add(new RemoteLockResponse(inferiorNode, RemoteLockResponse.Flag.REJECT, inferiorNode));
+//      
+//      BlockingAnswer<ArrayList<RemoteLockResponse>> caller1Answer = 
+//         new BlockingAnswer<ArrayList<RemoteLockResponse>>(rspList, answerAwaitLatch, answerStartLatch, null);
+//      
+//      expect(partition.callMethodOnCluster(eq("test"), 
+//                                           eq("remoteLock"), 
+//                                           eqLockParams(node1, 200000), 
+//                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
+//                                           eq(true))).andAnswer(caller1Answer);  
+//      
+//      expect(partition.callMethodOnCluster(eq("test"), 
+//            eq("releaseRemoteLock"), 
+//            aryEq(new Object[]{"test", node1}), 
+//            aryEq(AbstractClusterLockSupport.RELEASE_REMOTE_LOCK_TYPES), 
+//            eq(true))).andReturn(new ArrayList<Object>()); 
+//      
+//      rspList = new ArrayList<RemoteLockResponse>();
+//      rspList.add(new RemoteLockResponse(superiorNode, RemoteLockResponse.Flag.OK));
+//      rspList.add(new RemoteLockResponse(inferiorNode, RemoteLockResponse.Flag.OK));
+//      
+//      expect(partition.callMethodOnCluster(eq("test"), 
+//                                           eq("remoteLock"), 
+//                                           eqLockParams(node1, 200000), 
+//                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
+//                                           eq(true))).andReturn(rspList);  
+//      
+//      handler.lockFromCluster(eq("test"), eq(node1), anyLong());
+//      
+//      replay(partition);
+//      replay(handler);
+//
+//      CountDownLatch finishedLatch = new CountDownLatch(1);
+//      LocalLockCaller winner = new LocalLockCaller(testee, null, null, finishedLatch);
+//      
+//      Thread t1 = new Thread(winner);
+//      t1.setDaemon(true);
+//      
+//      try
+//      {
+//         t1.start();         
+//         assertTrue(answerStartLatch.await(1, TimeUnit.SECONDS));
+//         // t1 should now be blocking in caller1Answer
+//         
+//         RemoteLockResponse rsp = target.remoteLock("test", inferiorNode, 1);
+//         assertEquals(RemoteLockResponse.Flag.REJECT, rsp.flag);
+//         assertEquals(node1, rsp.holder);
+//         
+//         // release t1
+//         answerAwaitLatch.countDown();
+//         
+//         // wait for t1 to complete
+//         assertTrue(finishedLatch.await(5, TimeUnit.SECONDS));
+//         
+//         verify(handler);
+//         
+//         rethrow("winner had an exception", winner.getException());
+//         
+//         Boolean locked = winner.getResult();         
+//         assertEquals(Boolean.TRUE, locked);
+//      }
+//      finally
+//      {
+//         if (t1.isAlive())
+//            t1.interrupt();
+//      }
+//   }
+//   
+//   /**
+//    * Local node acquires a lock; remote node tries to releasem which is ignored.
+//    * 
+//    * @throws Exception
+//    */
+//   public void testSpuriousRemoteLockReleaseIgnored() throws Exception
+//   {
+//      TesteeSet<T> testeeSet = getTesteeSet(node1, 1, 2);
+//      AbstractClusterLockSupport testee = testeeSet.impl;
+//      HAPartition partition = testee.getPartition();
+//      LocalLockHandler handler = testee.getLocalHandler();
+//      
+//      ClusterNode other = testee.getCurrentView().get(0);
+//      resetToStrict(partition);
+//      resetToStrict(handler);
+//      
+//      ArrayList<RemoteLockResponse> rspList = new ArrayList<RemoteLockResponse>();
+//      rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.OK));
+//      
+//      
+//      expect(partition.callMethodOnCluster(eq("test"), 
+//                                           eq("remoteLock"), 
+//                                           eqLockParams(node1, 200000), 
+//                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
+//                                           eq(true))).andReturn(rspList);
+//      
+//      handler.lockFromCluster(eq("test"), eq(node1), anyLong());
+//      
+//      expect(handler.getLockHolder("test")).andReturn(node1);
+//      
+//      replay(partition);
+//      replay(handler);
+//      
+//      assertTrue(testee.lock("test", 200000));
+//      testeeSet.target.releaseRemoteLock("test", other);
+//      
+//      verify(partition);
+//      verify(handler);
+//   }
 
-      resetToStrict(partition);    
-      makeThreadSafe(partition, true);
-      resetToStrict(handler);   
-      makeThreadSafe(handler, true);
-      
-      ArrayList<RemoteLockResponse> rspList = new ArrayList<RemoteLockResponse>();
-      rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.OK));
-      
-      expect(partition.callMethodOnCluster(eq("test"), 
-                                           eq("remoteLock"), 
-                                           eqLockParams(node1, 200000), 
-                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
-                                           eq(true))).andReturn(rspList);
-      
-      // When caller 1 invokes, block before giving response 
-      CountDownLatch answerAwaitLatch = new CountDownLatch(1);
-      CountDownLatch answerStartLatch = new CountDownLatch(1);
-      CountDownLatch answerDoneLatch = new CountDownLatch(1);
-      BlockingAnswer<Boolean> caller1Answer = new BlockingAnswer<Boolean>(Boolean.TRUE, answerAwaitLatch, answerStartLatch, null);
-      handler.lockFromCluster(eq("test"), eq(node1), anyLong());
-      expectLastCall().andAnswer(caller1Answer);
-      
-      replay(partition);
-      replay(handler);
-      
-      LocalLockCaller winner = new LocalLockCaller(testee, null, null, answerDoneLatch, 500);
-      
-      Thread t1 = new Thread(winner);
-      t1.setDaemon(true);
-      
-      try
-      {
-         t1.start();         
-         assertTrue(answerStartLatch.await(500, TimeUnit.SECONDS));
-         // t1 should now be blocking in caller1Answer
-         
-         RemoteLockResponse rsp = target.remoteLock("test", superiorCaller, 1);
-         assertEquals(RemoteLockResponse.Flag.REJECT, rsp.flag);
-         assertEquals(node1, rsp.holder);
-         
-         // release t1
-         answerAwaitLatch.countDown();
-         
-         // wait for t1 to complete
-         assertTrue(answerDoneLatch.await(5, TimeUnit.SECONDS));
-         
-         verify(handler);
-         
-         rethrow("winner had an exception", winner.getException());
-         
-         Boolean locked = winner.getResult();         
-         assertEquals(Boolean.TRUE, locked);
-      }
-      finally
-      {
-         if (t1.isAlive())
-            t1.interrupt();
-      }
-   }
-   
-   public void testRemoteLockingStateAllowsSuperiorRemoteCaller() throws Exception
-   {
-      TesteeSet<T> testeeSet = getTesteeSet(node1, 1, 3);
-      T testee = testeeSet.impl;
-      HAPartition partition = testee.getPartition();
-      LocalLockHandler handler = testee.getLocalHandler();
-      final RpcTarget target = testeeSet.target;
-      
-      ClusterNode superiorCaller = testee.getCurrentView().get(0);
-      assertFalse(node1.equals(superiorCaller));
-
-      resetToNice(partition);   // nice as we may loop retrying and failing 
-      makeThreadSafe(partition, true);
-      resetToStrict(handler);   
-      makeThreadSafe(handler, true);
-      
-      // When caller 1 invokes, block before giving response 
-      CountDownLatch answerAwaitLatch = new CountDownLatch(1);
-      CountDownLatch answerStartLatch = new CountDownLatch(1);
-      
-      ArrayList<RemoteLockResponse> rspList = new ArrayList<RemoteLockResponse>();
-      rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.OK));
-      rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.REJECT, superiorCaller));
-      
-      BlockingAnswer<ArrayList<RemoteLockResponse>> caller1Answer = new BlockingAnswer<ArrayList<RemoteLockResponse>>(rspList, answerAwaitLatch, answerStartLatch, null);
-      
-      expect(partition.callMethodOnCluster(eq("test"), 
-                                           eq("remoteLock"), 
-                                           eqLockParams(node1, 200000), 
-                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
-                                           eq(true))).andAnswer(caller1Answer).atLeastOnce();
-      
-      handler.lockFromCluster(eq("test"), eq(superiorCaller), anyLong());   
-      
-      expect(partition.callMethodOnCluster(eq("test"), 
-            eq("releaseRemoteLock"), 
-            aryEq(new Object[]{"test", node1}), 
-            aryEq(AbstractClusterLockSupport.RELEASE_REMOTE_LOCK_TYPES), 
-            eq(true))).andReturn(new ArrayList<Object>()).atLeastOnce();
-      		
-      replay(partition);
-      replay(handler);
-
-      CountDownLatch finishedLatch = new CountDownLatch(1);
-      LocalLockCaller loser = new LocalLockCaller(testee, null, null, finishedLatch);
-      
-      Thread t1 = new Thread(loser);
-      t1.setDaemon(true);
-      
-      try
-      {
-         t1.start();         
-         assertTrue(answerStartLatch.await(1, TimeUnit.SECONDS));
-         // t1 should now be blocking in caller1Answer
-         
-         RemoteLockResponse rsp = target.remoteLock("test", superiorCaller, 1);
-         assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
-         
-         // release t1
-         answerAwaitLatch.countDown();
-         
-         // wait for t1 to complete
-         assertTrue(finishedLatch.await(5, TimeUnit.SECONDS));
-         
-         verify(handler);
-         
-         rethrow("winner had an exception", loser.getException());
-         
-         Boolean locked = loser.getResult();         
-         assertEquals(Boolean.FALSE, locked);
-      }
-      finally
-      {
-         if (t1.isAlive())
-            t1.interrupt();
-      }
-   }
-   
-   public void testRemoteLockingStateRejectsInferiorRemoteCaller() throws Exception
-   {
-      TesteeSet<T> testeeSet = getTesteeSet(node1, 1, 3);
-      T testee = testeeSet.impl;
-      HAPartition partition = testee.getPartition();
-      LocalLockHandler handler = testee.getLocalHandler();
-      final RpcTarget target = testeeSet.target;
-      
-      ClusterNode inferiorNode = testee.getCurrentView().get(2);
-      assertFalse(node1.equals(inferiorNode));
-      
-      ClusterNode superiorNode = testee.getCurrentView().get(0);
-      assertFalse(node1.equals(superiorNode));
-
-      resetToStrict(partition);    
-      makeThreadSafe(partition, true);
-      resetToStrict(handler);   
-      makeThreadSafe(handler, true);
-      
-      // When caller 1 invokes, block before giving response 
-      CountDownLatch answerAwaitLatch = new CountDownLatch(1);
-      CountDownLatch answerStartLatch = new CountDownLatch(1);
-      
-      ArrayList<RemoteLockResponse> rspList = new ArrayList<RemoteLockResponse>();
-      rspList.add(new RemoteLockResponse(superiorNode, RemoteLockResponse.Flag.OK));
-      rspList.add(new RemoteLockResponse(inferiorNode, RemoteLockResponse.Flag.REJECT, inferiorNode));
-      
-      BlockingAnswer<ArrayList<RemoteLockResponse>> caller1Answer = 
-         new BlockingAnswer<ArrayList<RemoteLockResponse>>(rspList, answerAwaitLatch, answerStartLatch, null);
-      
-      expect(partition.callMethodOnCluster(eq("test"), 
-                                           eq("remoteLock"), 
-                                           eqLockParams(node1, 200000), 
-                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
-                                           eq(true))).andAnswer(caller1Answer);  
-      
-      expect(partition.callMethodOnCluster(eq("test"), 
-            eq("releaseRemoteLock"), 
-            aryEq(new Object[]{"test", node1}), 
-            aryEq(AbstractClusterLockSupport.RELEASE_REMOTE_LOCK_TYPES), 
-            eq(true))).andReturn(new ArrayList<Object>()); 
-      
-      rspList = new ArrayList<RemoteLockResponse>();
-      rspList.add(new RemoteLockResponse(superiorNode, RemoteLockResponse.Flag.OK));
-      rspList.add(new RemoteLockResponse(inferiorNode, RemoteLockResponse.Flag.OK));
-      
-      expect(partition.callMethodOnCluster(eq("test"), 
-                                           eq("remoteLock"), 
-                                           eqLockParams(node1, 200000), 
-                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
-                                           eq(true))).andReturn(rspList);  
-      
-      handler.lockFromCluster(eq("test"), eq(node1), anyLong());
-      
-      replay(partition);
-      replay(handler);
-
-      CountDownLatch finishedLatch = new CountDownLatch(1);
-      LocalLockCaller winner = new LocalLockCaller(testee, null, null, finishedLatch);
-      
-      Thread t1 = new Thread(winner);
-      t1.setDaemon(true);
-      
-      try
-      {
-         t1.start();         
-         assertTrue(answerStartLatch.await(1, TimeUnit.SECONDS));
-         // t1 should now be blocking in caller1Answer
-         
-         RemoteLockResponse rsp = target.remoteLock("test", inferiorNode, 1);
-         assertEquals(RemoteLockResponse.Flag.REJECT, rsp.flag);
-         assertEquals(node1, rsp.holder);
-         
-         // release t1
-         answerAwaitLatch.countDown();
-         
-         // wait for t1 to complete
-         assertTrue(finishedLatch.await(5, TimeUnit.SECONDS));
-         
-         verify(handler);
-         
-         rethrow("winner had an exception", winner.getException());
-         
-         Boolean locked = winner.getResult();         
-         assertEquals(Boolean.TRUE, locked);
-      }
-      finally
-      {
-         if (t1.isAlive())
-            t1.interrupt();
-      }
-   }
-   
-   /**
-    * Local node acquires a lock; remote node tries to releasem which is ignored.
-    * 
-    * @throws Exception
-    */
-   public void testSpuriousRemoteLockReleaseIgnored() throws Exception
-   {
-      TesteeSet<T> testeeSet = getTesteeSet(node1, 1, 2);
-      AbstractClusterLockSupport testee = testeeSet.impl;
-      HAPartition partition = testee.getPartition();
-      LocalLockHandler handler = testee.getLocalHandler();
-      
-      ClusterNode other = testee.getCurrentView().get(0);
-      resetToStrict(partition);
-      resetToStrict(handler);
-      
-      ArrayList<RemoteLockResponse> rspList = new ArrayList<RemoteLockResponse>();
-      rspList.add(new RemoteLockResponse(null, RemoteLockResponse.Flag.OK));
-      
-      
-      expect(partition.callMethodOnCluster(eq("test"), 
-                                           eq("remoteLock"), 
-                                           eqLockParams(node1, 200000), 
-                                           aryEq(AbstractClusterLockSupport.REMOTE_LOCK_TYPES), 
-                                           eq(true))).andReturn(rspList);
-      
-      handler.lockFromCluster(eq("test"), eq(node1), anyLong());
-      
-      expect(handler.getLockHolder("test")).andReturn(node1);
-      
-      replay(partition);
-      replay(handler);
-      
-      assertTrue(testee.lock("test", 200000));
-      testeeSet.target.releaseRemoteLock("test", other);
-      
-      verify(partition);
-      verify(handler);
-   }
-
    protected TesteeSet<T> getTesteeSet(ClusterNode node, int viewPos, int viewSize) throws Exception
    {
       HAPartition haPartition = createNiceMock(HAPartition.class);      
Index: testsuite/src/main/org/jboss/test/cluster/defaultcfg/test/YieldingGloballyExclusiveClusterLockSupportUnitTestCase.java
===================================================================
--- testsuite/src/main/org/jboss/test/cluster/defaultcfg/test/YieldingGloballyExclusiveClusterLockSupportUnitTestCase.java	(revision 113708)
+++ testsuite/src/main/org/jboss/test/cluster/defaultcfg/test/YieldingGloballyExclusiveClusterLockSupportUnitTestCase.java	(working copy)
@@ -62,129 +62,129 @@
       return new YieldingGloballyExclusiveClusterLockSupport(serviceHAName, partition, handler);
    }
 
-   public void testBasicRemoteLock() throws Exception
-   { 
-      TesteeSet<YieldingGloballyExclusiveClusterLockSupport> testeeSet = getTesteeSet(node1, 1, 2);
-      YieldingGloballyExclusiveClusterLockSupport testee = testeeSet.impl;
-      LocalLockHandler handler = testee.getLocalHandler();
-      RpcTarget target = testeeSet.target;
-      
-      ClusterNode caller = testee.getCurrentView().get(0);
-      assertFalse(node1.equals(caller));
-      
-      resetToStrict(handler);      
-      replay(handler);
-      
-      RemoteLockResponse rsp = target.remoteLock("test", caller, 1000);
-      
-      assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
-      assertNull(rsp.holder);
-      
-      verify(handler);
-      
-      // Do it again; should still work
-      resetToStrict(handler);      
-      replay(handler);
-      
-      rsp = target.remoteLock("test", caller, 1000);
-      
-      assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
-      assertNull(rsp.holder);
-      
-      verify(handler);
-   }
-   
-   public void testContestedRemoteLock() throws Exception
-   { 
-      TesteeSet<YieldingGloballyExclusiveClusterLockSupport> testeeSet = getTesteeSet(node1, 1, 3);
-      YieldingGloballyExclusiveClusterLockSupport testee = testeeSet.impl;
-      LocalLockHandler handler = testee.getLocalHandler();
-      RpcTarget target = testeeSet.target;
-      
-      ClusterNode caller1 = testee.getCurrentView().get(0);
-      assertFalse(node1.equals(caller1));
-      
-      ClusterNode caller2 = testee.getCurrentView().get(2);
-      assertFalse(node1.equals(caller2));
-      
-      resetToStrict(handler);      
-      replay(handler);
-      
-      RemoteLockResponse rsp = target.remoteLock("test", caller1, 1000);
-      
-      assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
-      assertNull(rsp.holder);
-      
-      verify(handler);
-      
-      // A call from a different caller should still work as
-      // w/ supportLockOnly==false we only reject if WE hold the lock
-      resetToStrict(handler);
-      replay(handler);
-      
-      rsp = target.remoteLock("test", caller2, 1000);
-      
-      assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
-      assertNull(rsp.holder);
-      
-      verify(handler);
-      
-   }
-   
-   /**
-    * Test that if a member holds a lock but is then removed from the
-    * view, another remote member can obtain the lock.
-    * 
-    * @throws Exception
-    */
-   public void testDeadMemberCleanupAllowsRemoteLock() throws Exception
-   { 
-      TesteeSet<YieldingGloballyExclusiveClusterLockSupport> testeeSet = getTesteeSet(node1, 1, 3);
-      YieldingGloballyExclusiveClusterLockSupport testee = testeeSet.impl;
-      LocalLockHandler handler = testee.getLocalHandler();
-      RpcTarget target = testeeSet.target;
-      
-      List<ClusterNode> members = testee.getCurrentView();
-      ClusterNode caller1 = members.get(0);
-      assertFalse(node1.equals(caller1));
-      
-      ClusterNode caller2 = members.get(2);
-      assertFalse(node1.equals(caller2));
-      
-      resetToStrict(handler);      
-      replay(handler);
-      
-      RemoteLockResponse rsp = target.remoteLock("test", caller1, 1000);
-      
-      assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
-      assertNull(rsp.holder);
-      
-      verify(handler);
-      
-      // Change the view
-      Vector<ClusterNode> dead = new Vector<ClusterNode>();
-      dead.add(caller1);
-      
-      Vector<ClusterNode> all = new Vector<ClusterNode>(members);
-      all.remove(caller1);
-      
-      resetToStrict(handler);
-      replay(handler);
-      
-      testee.membershipChanged(dead, new Vector<ClusterNode>(), all);
-      
-      verify(handler);
-      
-      // A call from a different caller should work 
-      resetToStrict(handler);
-      replay(handler);
-      
-      rsp = target.remoteLock("test", caller2, 1000);
-      
-      assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
-      assertNull(rsp.holder);
-      
-      verify(handler);
-   }
+//   public void testBasicRemoteLock() throws Exception
+//   { 
+//      TesteeSet<YieldingGloballyExclusiveClusterLockSupport> testeeSet = getTesteeSet(node1, 1, 2);
+//      YieldingGloballyExclusiveClusterLockSupport testee = testeeSet.impl;
+//      LocalLockHandler handler = testee.getLocalHandler();
+//      RpcTarget target = testeeSet.target;
+//      
+//      ClusterNode caller = testee.getCurrentView().get(0);
+//      assertFalse(node1.equals(caller));
+//      
+//      resetToStrict(handler);      
+//      replay(handler);
+//      
+//      RemoteLockResponse rsp = target.remoteLock("test", caller, 1000);
+//      
+//      assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
+//      assertNull(rsp.holder);
+//      
+//      verify(handler);
+//      
+//      // Do it again; should still work
+//      resetToStrict(handler);      
+//      replay(handler);
+//      
+//      rsp = target.remoteLock("test", caller, 1000);
+//      
+//      assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
+//      assertNull(rsp.holder);
+//      
+//      verify(handler);
+//   }
+//   
+//   public void testContestedRemoteLock() throws Exception
+//   { 
+//      TesteeSet<YieldingGloballyExclusiveClusterLockSupport> testeeSet = getTesteeSet(node1, 1, 3);
+//      YieldingGloballyExclusiveClusterLockSupport testee = testeeSet.impl;
+//      LocalLockHandler handler = testee.getLocalHandler();
+//      RpcTarget target = testeeSet.target;
+//      
+//      ClusterNode caller1 = testee.getCurrentView().get(0);
+//      assertFalse(node1.equals(caller1));
+//      
+//      ClusterNode caller2 = testee.getCurrentView().get(2);
+//      assertFalse(node1.equals(caller2));
+//      
+//      resetToStrict(handler);      
+//      replay(handler);
+//      
+//      RemoteLockResponse rsp = target.remoteLock("test", caller1, 1000);
+//      
+//      assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
+//      assertNull(rsp.holder);
+//      
+//      verify(handler);
+//      
+//      // A call from a different caller should still work as
+//      // w/ supportLockOnly==false we only reject if WE hold the lock
+//      resetToStrict(handler);
+//      replay(handler);
+//      
+//      rsp = target.remoteLock("test", caller2, 1000);
+//      
+//      assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
+//      assertNull(rsp.holder);
+//      
+//      verify(handler);
+//      
+//   }
+//   
+//   /**
+//    * Test that if a member holds a lock but is then removed from the
+//    * view, another remote member can obtain the lock.
+//    * 
+//    * @throws Exception
+//    */
+//   public void testDeadMemberCleanupAllowsRemoteLock() throws Exception
+//   { 
+//      TesteeSet<YieldingGloballyExclusiveClusterLockSupport> testeeSet = getTesteeSet(node1, 1, 3);
+//      YieldingGloballyExclusiveClusterLockSupport testee = testeeSet.impl;
+//      LocalLockHandler handler = testee.getLocalHandler();
+//      RpcTarget target = testeeSet.target;
+//      
+//      List<ClusterNode> members = testee.getCurrentView();
+//      ClusterNode caller1 = members.get(0);
+//      assertFalse(node1.equals(caller1));
+//      
+//      ClusterNode caller2 = members.get(2);
+//      assertFalse(node1.equals(caller2));
+//      
+//      resetToStrict(handler);      
+//      replay(handler);
+//      
+//      RemoteLockResponse rsp = target.remoteLock("test", caller1, 1000);
+//      
+//      assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
+//      assertNull(rsp.holder);
+//      
+//      verify(handler);
+//      
+//      // Change the view
+//      Vector<ClusterNode> dead = new Vector<ClusterNode>();
+//      dead.add(caller1);
+//      
+//      Vector<ClusterNode> all = new Vector<ClusterNode>(members);
+//      all.remove(caller1);
+//      
+//      resetToStrict(handler);
+//      replay(handler);
+//      
+//      testee.membershipChanged(dead, new Vector<ClusterNode>(), all);
+//      
+//      verify(handler);
+//      
+//      // A call from a different caller should work 
+//      resetToStrict(handler);
+//      replay(handler);
+//      
+//      rsp = target.remoteLock("test", caller2, 1000);
+//      
+//      assertEquals(RemoteLockResponse.Flag.OK, rsp.flag);
+//      assertNull(rsp.holder);
+//      
+//      verify(handler);
+//   }
 
 }
Index: testsuite/src/resources/log4j.xml
===================================================================
--- testsuite/src/resources/log4j.xml	(revision 113708)
+++ testsuite/src/resources/log4j.xml	(working copy)
@@ -21,9 +21,9 @@
   <!-- ================================= -->
 
   <!-- A time/date based rolling appender -->
-  <appender name="FILE" class="org.jboss.logging.appender.DailyRollingFileAppender">
-    <param name="File" value="${build.testlog}/test.log"/>
-    <param name="Append" value="true"/>
+  <appender name="FILE" class="org.apache.log4j.FileAppender">
+    <param name="File" value="${build.testlog}/testlog.txt"/>
+    <param name="Threshold" value="FINEST"/>
 
     <!-- Rollover at midnight each day -->
     <param name="DatePattern" value="'.'yyyy-MM-dd"/>
@@ -149,8 +149,14 @@
   <!-- ======================= -->
   <!-- Setup the Root category -->
   <!-- ======================= -->
-
+ <category name="org.jboss.test.cluster.defaultcfg.test">
+    <priority value="FINEST" />
+ </category>
+ <category name="org.jboss.ha.framework.server">
+    <priority value="FINEST" />
+ </category>
   <root>
+    <level value="FINEST"/>
     <appender-ref ref="CONSOLE"/>
     <appender-ref ref="FILE"/>
   </root>
