[jboss-cvs] JBossAS SVN: r110352 - branches/JBPAPP_5_1_datagrid/testsuite/src/main/org/jboss/test/cluster/datagrid/test.

jboss-cvs-commits at lists.jboss.org jboss-cvs-commits at lists.jboss.org
Thu Jan 13 10:43:31 EST 2011


Author: rachmatowicz at jboss.com
Date: 2011-01-13 10:43:30 -0500 (Thu, 13 Jan 2011)
New Revision: 110352

Modified:
   branches/JBPAPP_5_1_datagrid/testsuite/src/main/org/jboss/test/cluster/datagrid/test/HotRodClientRemoteCacheTestCase.java
Log:
Update HotRodClintRemoteCacheTestCase

Modified: branches/JBPAPP_5_1_datagrid/testsuite/src/main/org/jboss/test/cluster/datagrid/test/HotRodClientRemoteCacheTestCase.java
===================================================================
--- branches/JBPAPP_5_1_datagrid/testsuite/src/main/org/jboss/test/cluster/datagrid/test/HotRodClientRemoteCacheTestCase.java	2011-01-13 14:11:49 UTC (rev 110351)
+++ branches/JBPAPP_5_1_datagrid/testsuite/src/main/org/jboss/test/cluster/datagrid/test/HotRodClientRemoteCacheTestCase.java	2011-01-13 15:43:30 UTC (rev 110352)
@@ -270,9 +270,9 @@
 	 */
 	public void testPut() throws IOException {
 		
-		assert null == remoteCache.put("aKey", "aValue");
-		assert remoteCache.containsKey("aKey");
-		assert remoteCache.get("aKey").equals("aValue");
+		assertTrue(null == remoteCache.put("aKey", "aValue"));
+		assertTrue(remoteCache.containsKey("aKey"));
+		assertTrue(remoteCache.get("aKey").equals("aValue"));
 	}	
 	
 	/*
@@ -280,23 +280,23 @@
 	 */
 	public void testSize() throws IOException {
 		
-		assert remoteCache.size() == 0;
+		assertTrue(remoteCache.size() == 0);
 		
-		assert null == remoteCache.put("aKey", "aValue");
-		assert remoteCache.containsKey("aKey");
-		assert remoteCache.size() == 1 ;
+		assertTrue(null == remoteCache.put("aKey", "aValue"));
+		assertTrue(remoteCache.containsKey("aKey"));
+		assertTrue(remoteCache.size() == 1) ;
 
-		assert null == remoteCache.put("anotherKey", "anotherValue");
-		assert remoteCache.containsKey("anotherKey");
-		assert remoteCache.size() == 2 ;		
+		assertTrue(null == remoteCache.put("anotherKey", "anotherValue"));
+		assertTrue(remoteCache.containsKey("anotherKey"));
+		assertTrue(remoteCache.size() == 2) ;		
 		
-		assert null == remoteCache.remove("anotherKey");
-		assert !remoteCache.containsKey("anotherKey");
-		assert remoteCache.size() == 1 ;
+		assertTrue(null == remoteCache.remove("anotherKey"));
+		assertTrue(!remoteCache.containsKey("anotherKey"));
+		assertTrue(remoteCache.size() == 1) ;
 		
-		assert null == remoteCache.remove("aKey");
-		assert !remoteCache.containsKey("aKey");
-		assert remoteCache.size() == 0 ;
+		assertTrue(null == remoteCache.remove("aKey"));
+		assertTrue(!remoteCache.containsKey("aKey"));
+		assertTrue(remoteCache.size() == 0) ;
 	}	
 	
 	/*
@@ -304,15 +304,15 @@
 	 */
 	public void testIsEmpty() throws IOException {
 		
-		assert remoteCache.isEmpty();
+		assertTrue(remoteCache.isEmpty());
 		
-		assert null == remoteCache.put("aKey", "aValue");
-		assert remoteCache.containsKey("aKey");
-		assert !remoteCache.isEmpty();
+		assertTrue(null == remoteCache.put("aKey", "aValue"));
+		assertTrue(remoteCache.containsKey("aKey"));
+		assertTrue(!remoteCache.isEmpty());
 		
-		assert null == remoteCache.remove("aKey");
-		assert !remoteCache.containsKey("aKey");
-		assert remoteCache.isEmpty();		
+		assertTrue(null == remoteCache.remove("aKey"));
+		assertTrue(!remoteCache.containsKey("aKey"));
+		assertTrue(remoteCache.isEmpty());		
 	}	
 	
 	
@@ -321,11 +321,11 @@
 	 * - we start with empty cache
 	 */
 	public void testContains() {
-		assert !remoteCache.containsKey("aKey");
+		assertTrue(!remoteCache.containsKey("aKey"));
 		remoteCache.put("aKey", "aValue");
-		assert remoteCache.containsKey("aKey");
-		assert remoteCache.containsValue("aValue");
-		assert !remoteCache.containsValue("someOtherValue"); 
+		assertTrue(remoteCache.containsKey("aKey"));
+		assertTrue(remoteCache.containsValue("aValue"));
+		assertTrue(!remoteCache.containsValue("someOtherValue")); 
 	}
 	
 	/*
@@ -336,12 +336,12 @@
 	 */
 	public void testWithFlags() throws IOException {
 		
-		assert null == remoteCache.put("aKey", "aValue");
-		assert remoteCache.containsKey("aKey");
+		assertTrue(null == remoteCache.put("aKey", "aValue"));
+		assertTrue(remoteCache.containsKey("aKey"));
 		assertEquals("aValue", remoteCache.get("aKey"));
 		
 		// should not return return old value
-		assert null == remoteCache.put("aKey", "anotherValue") ;
+		assertTrue(null == remoteCache.put("aKey", "anotherValue")) ;
 		assertEquals("anotherValue", remoteCache.get("aKey"));
 		
 		// now should return old value
@@ -354,9 +354,9 @@
 	 */
 	public void XtestEviction() {
 		remoteCache.put("aKey", "aValue");
-		assert remoteCache.containsKey("aKey");
+		assertTrue(remoteCache.containsKey("aKey"));
 		remoteCache.evict("aKey");
-		assert !remoteCache.containsKey("aKey");		
+		assertTrue(!remoteCache.containsKey("aKey"));		
 	}
 	
 	/*
@@ -373,8 +373,8 @@
 		remoteCache.putAll(mapOut);
 		mapIn = remoteCache.getBulk();
 		
-		assert mapIn.keySet().equals(mapOut.keySet());
-		assert mapIn.values().equals(mapOut.values());
+		// check that the maps are equal
+		assertTrue(mapIn.equals(mapOut));
 	}
 	
 	/*
@@ -396,7 +396,7 @@
 		sleepForSecs(lifespanInSecs) ;
 		
 		mapIn = remoteCache.getBulk();		
-		assert mapIn.size() == 0;
+		assertTrue(mapIn.size() == 3);
 	}
 
 	
@@ -419,8 +419,12 @@
 
 		mapIn = remoteCache.getBulk();
 		
-		assert mapIn.keySet().equals(mapOut.keySet());
-		assert mapIn.values().equals(mapOut.values());
+		// check that the maps are equal
+		assertTrue(mapIn.equals(mapOut));
+		
+		// funny why these assertions do not hold 
+		//assertTrue(mapIn.keySet().equals(mapOut.keySet()));
+		//assertTrue(mapIn.values().equals(mapOut.values()));
 	}
 	
 	/*
@@ -444,7 +448,7 @@
 		sleepForSecs(lifespanInSecs) ;
 				
 		mapIn = remoteCache.getBulk();
-		assert mapIn.size() == 0;
+		assertTrue(mapIn.size() == 0);
 	}
 	
 	
@@ -467,9 +471,9 @@
 		
 		remoteCache.putAll(mapOut) ;
 		
-		assert mapEntrySet.equals(remoteCache.entrySet()) ;
-		assert mapKeySet.equals(remoteCache.keySet()) ;
-		assert mapValues.equals(remoteCache.values());		
+		assertTrue(mapEntrySet.equals(remoteCache.entrySet())) ;
+		assertTrue(mapKeySet.equals(remoteCache.keySet())) ;
+		assertTrue(mapValues.equals(remoteCache.values()));		
 	}
 	
 	
@@ -490,7 +494,7 @@
 		remoteCache.put("anotherKey", "anotherValue") ;
 		remoteCache.endBatch(false) ;
 		
-		assert null == remoteCache.get("aKey") ;
+		assertTrue(null == remoteCache.get("aKey")) ;
 		
 		// check no intermediate results committed 
 		
@@ -515,9 +519,9 @@
 		assertNull(remoteCache.getVersioned("aKey"), "expected null but received: " + value);
 		
 		remoteCache.put("aKey", "aValue");
-		assert remoteCache.get("aKey").equals("aValue");
+		assertTrue(remoteCache.get("aKey").equals("aValue"));
 		VersionedValue valueBinary = remoteCache.getVersioned("aKey");
-		assert valueBinary != null;
+		assertTrue(valueBinary != null);
 		assertEquals(valueBinary.getValue(), "aValue");
 		log.info("Version is: " + valueBinary.getVersion());
 
@@ -526,15 +530,15 @@
 		VersionedValue entry2 = remoteCache.getVersioned("aKey");
 		assertEquals(entry2.getValue(), "aValue");
 
-		assert entry2.getVersion() != valueBinary.getVersion();
-		assert !valueBinary.equals(entry2);
+		assertTrue(entry2.getVersion() != valueBinary.getVersion());
+		assertTrue(!valueBinary.equals(entry2));
 
 		//now put a different value
 		remoteCache.put("aKey", "anotherValue");
 		VersionedValue entry3 = remoteCache.getVersioned("aKey");
 		assertEquals(entry3.getValue(), "anotherValue");
-		assert entry3.getVersion() != entry2.getVersion();
-		assert !entry3.equals(entry2);
+		assertTrue(entry3.getVersion() != entry2.getVersion());
+		assertTrue(!entry3.equals(entry2));
 	}
 
 	/*
@@ -556,20 +560,20 @@
 	 * version was read
 	 */
 	public void testReplaceWithVersion() {
-		assert null == remoteCache.replace("aKey", "aValue");
+		assertTrue(null == remoteCache.replace("aKey", "aValue"));
 
 		remoteCache.put("aKey", "aValue");
 		VersionedValue valueBinary = remoteCache.getVersioned("aKey");
 		// replacement should take place (and so return true)
-		assert remoteCache.replaceWithVersion("aKey", "aNewValue", valueBinary.getVersion());
+		assertTrue(remoteCache.replaceWithVersion("aKey", "aNewValue", valueBinary.getVersion()));
 
 		// version should have changed; value should have changed
 		VersionedValue entry2 = remoteCache.getVersioned("aKey");
-		assert entry2.getVersion() != valueBinary.getVersion();
+		assertTrue(entry2.getVersion() != valueBinary.getVersion());
 		assertEquals(entry2.getValue(), "aNewValue");
 
 		// replacement should not take place because we have changed the value
-		assert !remoteCache.replaceWithVersion("aKey", "aNewValue", valueBinary.getVersion());
+		assertTrue(!remoteCache.replaceWithVersion("aKey", "aNewValue", valueBinary.getVersion()));
 	}
 
 	/*
@@ -578,23 +582,23 @@
 	 * version was read
 	 */
 	public void testReplaceWithVersionAsync() throws Exception {
-		assert null == remoteCache.replace("aKey", "aValue");
+		assertTrue(null == remoteCache.replace("aKey", "aValue"));
 
 		remoteCache.put("aKey", "aValue");
 		VersionedValue valueBinary = remoteCache.getVersioned("aKey");
 		// replacement should take place (and so return true)
 		NotifyingFuture<Boolean> future = null ;
 		future = remoteCache.replaceWithVersionAsync("aKey", "aNewValue", valueBinary.getVersion());
-		assert future.get() ;
+		assertTrue(future.get()) ;
 		
 		// version should have changed; value should have changed
 		VersionedValue entry2 = remoteCache.getVersioned("aKey");
-		assert entry2.getVersion() != valueBinary.getVersion();
+		assertTrue(entry2.getVersion() != valueBinary.getVersion());
 		assertEquals(entry2.getValue(), "aNewValue");
 
 		// replacement should not take place because we have changed the value
 		future = remoteCache.replaceWithVersionAsync("aKey", "aNewValue", valueBinary.getVersion());
-		assert !future.get() ;
+		assertTrue(!future.get()) ;
 	}
 	
 	/* to here */
@@ -604,11 +608,11 @@
 	 * - put key/value, verify put value, remove key, verify key removed
 	 */
 	public void testRemove() throws IOException {
-		assert null == remoteCache.put("aKey", "aValue");
-		assert remoteCache.get("aKey").equals("aValue");
+		assertTrue(null == remoteCache.put("aKey", "aValue"));
+		assertTrue(remoteCache.get("aKey").equals("aValue"));
 
-		assert null == remoteCache.remove("aKey");
-		assert !remoteCache.containsKey("aKey");
+		assertTrue(null == remoteCache.remove("aKey"));
+		assertTrue(!remoteCache.containsKey("aKey"));
 	}
 
 	/*
@@ -616,19 +620,19 @@
 	 */
 	public void testRemoveWithVersion() {
 		
-		assert !remoteCache.removeWithVersion("aKey", 12321212l);
+		assertTrue(!remoteCache.removeWithVersion("aKey", 12321212l));
 
 		remoteCache.put("aKey", "aValue");
 		VersionedValue valueBinary = remoteCache.getVersioned("aKey");
-		assert remoteCache.removeWithVersion("aKey", valueBinary.getVersion());
+		assertTrue(remoteCache.removeWithVersion("aKey", valueBinary.getVersion()));
 
 		remoteCache.put("aKey", "aNewValue");
 
 		VersionedValue entry2 = remoteCache.getVersioned("aKey");
-		assert entry2.getVersion() != valueBinary.getVersion();
+		assertTrue(entry2.getVersion() != valueBinary.getVersion());
 		assertEquals(entry2.getValue(), "aNewValue");
 
-		assert  !remoteCache.removeWithVersion("aKey", valueBinary.getVersion());
+		assertTrue(!remoteCache.removeWithVersion("aKey", valueBinary.getVersion()));
 	}
 	
 	/*
@@ -639,21 +643,21 @@
 		NotifyingFuture<Boolean> future = null ;
 		
 		future = remoteCache.removeWithVersionAsync("aKey", 12321212l);
-		assert !future.get();
+		assertTrue(!future.get());
 
 		remoteCache.put("aKey", "aValue");
 		VersionedValue valueBinary = remoteCache.getVersioned("aKey");
 		future = remoteCache.removeWithVersionAsync("aKey", valueBinary.getVersion());
-		assert future.get();
+		assertTrue(future.get());
 		
 		remoteCache.put("aKey", "aNewValue");
 
 		VersionedValue entry2 = remoteCache.getVersioned("aKey");
-		assert entry2.getVersion() != valueBinary.getVersion();
+		assertTrue(entry2.getVersion() != valueBinary.getVersion());
 		assertEquals(entry2.getValue(), "aNewValue");
 
 		future = remoteCache.removeWithVersionAsync("aKey", valueBinary.getVersion());
-		assert  !future.get();
+		assertTrue(!future.get());
 	}
 
 	
@@ -664,10 +668,10 @@
 	public void testPutIfAbsent() {
 		
 		remoteCache.putIfAbsent("aKey", "aValue");
-		assert remoteCache.size() == 1;
+		assertTrue(remoteCache.size() == 1);
 		assertEquals(remoteCache.get("aKey"),"aValue");		
 		
-		assert null == remoteCache.putIfAbsent("aKey", "anotherValue");
+		assertTrue(null == remoteCache.putIfAbsent("aKey", "anotherValue"));
 		assertEquals(remoteCache.get("aKey"),"aValue");
 	}
 
@@ -678,8 +682,8 @@
 		remoteCache.put("aKey", "aValue");
 		remoteCache.put("aKey2", "aValue");
 		remoteCache.clear();
-		assert !remoteCache.containsKey("aKey");
-		assert !remoteCache.containsKey("aKey2");
+		assertTrue(!remoteCache.containsKey("aKey"));
+		assertTrue(!remoteCache.containsKey("aKey2"));
 	}
 	
 
@@ -691,13 +695,13 @@
 		RemoteCacheManager manager = null ;
 		
 		manager = remoteCache.getRemoteCacheManager() ;
-		assert manager == this.remoteCacheManager : "getRemoteCachemanager() returned incorrect value" ;
+		assertTrue("getRemoteCachemanager() returned incorrect value", manager == this.remoteCacheManager) ;
 	}
 
 	public void testStats() {
 		
 		ServerStatistics remoteStats = remoteCache.stats();
-		assert null != remoteStats ;
+		assertTrue(null != remoteStats) ;
 		System.out.println("named stats = " + remoteStats.getStatsMap()) ;
 	}
 	
@@ -712,17 +716,17 @@
 		
 		remoteCache.addListener(listener);
 		listeners = remoteCache.getListeners() ;
-		assert listeners.size() == 1 ;
+		assertTrue(listeners.size() == 1) ;
 		
 		remoteCache.put("aKey", "aValue");
 		org.infinispan.notifications.cachelistener.event.Event e = listener.getLastEvent() ;
-		assert null != e ;
-		assert (e.getType() == org.infinispan.notifications.cachelistener.event.Event.Type.CACHE_ENTRY_CREATED || 
+		assertTrue(null != e) ;
+		assertTrue(e.getType() == org.infinispan.notifications.cachelistener.event.Event.Type.CACHE_ENTRY_CREATED || 
 				e.getType() == org.infinispan.notifications.cachelistener.event.Event.Type.CACHE_ENTRY_MODIFIED) ;
 		
 		remoteCache.removeListener(listener);
 		listeners = remoteCache.getListeners() ;
-		assert listeners.size() == 0 ;		
+		assertTrue(listeners.size() == 0) ;		
 	}
 			
 	private void assertNull(Object obj, String msg) {



More information about the jboss-cvs-commits mailing list