package org.jgroups.tests;
import org.jgroups.Global;
import org.jgroups.JChannel;
import org.jgroups.blocks.ReplicatedHashMap;
import org.testng.Assert;
import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* Test methods for ReplicatedHashMap
*
* @author Bela Ban
* Exp $
*/
@Test(groups=Global.STACK_DEPENDENT,sequential=true)
public class ReplicatedHashMapTest extends ChannelTestBase {
private ReplicatedHashMap<String,String> map1;
private ReplicatedHashMap<String,String> map2;
private ConcurrentHashMap<String,String> wrap=new ConcurrentHashMap<String,String>();
@BeforeClass
protected void setUp() throws Exception {
JChannel c1=createChannel(true, 2);
this.map1=new ReplicatedHashMap<String,String>(c1, false);
map1.setBlockingUpdates(true);
c1.connect("ReplicatedHashMapTest");
this.map1.start(5000);
JChannel c2=createChannel(c1);
this.map2=new ReplicatedHashMap<String,String>(wrap, c2, false);
map2.setBlockingUpdates(true);
c2.connect("ReplicatedHashMapTest");
this.map2.start(5000);
}
@AfterMethod
protected void clean() {
map1.clear();
map2.clear();
}
@AfterClass
protected void tearDown() throws Exception {
this.map1.stop();
this.map2.stop();
}
public void testEqualsEtc() {
map1.put("key1", "value1");
assertEquals(this.map1, this.map2);
Assert.assertEquals(this.map1.hashCode(), this.map2.hashCode());
Assert.assertEquals(this.map1.toString(), this.map2.toString());
assertEquals(this.wrap, this.map1);
}
public void testSize() {
Assert.assertEquals(0, this.map1.size());
Assert.assertEquals(this.map2.size(), this.map1.size());
this.map1.put("key1", "value1");
Assert.assertEquals(1, this.map1.size());
Assert.assertEquals(this.map2.size(), this.map1.size());
this.map2.put("key2", "value2");
Assert.assertEquals(2, this.map1.size());
Assert.assertEquals(this.map2.size(), this.map1.size());
}
public void testIsEmpty() {
assertTrue(this.map1.isEmpty());
assertTrue(this.map2.isEmpty());
this.map1.put("key", "value");
assertFalse(this.map1.isEmpty());
assertFalse(this.map2.isEmpty());
}
public void testContainsKey() {
assertFalse(this.map1.containsKey("key1"));
assertFalse(this.map2.containsKey("key1"));
this.map1.put("key1", "value");
assertTrue(this.map1.containsKey("key1"));
assertTrue(this.map2.containsKey("key1"));
this.map2.put("key2", "value");
assertTrue(this.map1.containsKey("key2"));
assertTrue(this.map2.containsKey("key2"));
}
public void testContainsValue() {
assertFalse(this.map1.containsValue("value1"));
assertFalse(this.map2.containsValue("value1"));
this.map1.put("key1", "value1");
assertTrue(this.map1.containsValue("value1"));
assertTrue(this.map2.containsValue("value1"));
this.map2.put("key2", "value2");
assertTrue(this.map1.containsValue("value2"));
assertTrue(this.map2.containsValue("value2"));
}
public void testPutAndGet() {
assert this.map1.get("key1") == null;
assert this.map2.get("key1") == null;
this.map1.put("key1", "value1");
assertNotNull(this.map1.get("key1"));
assertNotNull(this.map2.get("key1"));
this.map2.put("key2", "value2");
assertNotNull(this.map1.get("key2"));
assertNotNull(this.map2.get("key2"));
}
public void testPutIfAbsent() {
String retval=map1.putIfAbsent("name", "Bela");
assert retval == null;
retval=map1.putIfAbsent("name", "Michelle");
assertNotNull(retval);
Assert.assertEquals("Bela", retval);
Assert.assertEquals("Bela", map1.get("name"));
Assert.assertEquals("Bela", map2.get("name"));
}
public void testRemove() {
assert this.map1.get("key1") == null;
assert this.map2.get("key1") == null;
this.map1.put("key1", "value1");
this.map2.put("key2", "value2");
assertNotNull(this.map1.get("key1"));
assertNotNull(this.map2.get("key1"));
assertNotNull(this.map1.get("key2"));
assertNotNull(this.map2.get("key2"));
this.map1.remove("key1");
assert this.map1.get("key1") == null;
assert this.map2.get("key1") == null;
assertNotNull(this.map1.get("key2"));
assertNotNull(this.map2.get("key2"));
this.map2.remove("key2");
assert this.map1.get("key2") == null;
assert this.map2.get("key2") == null;
}
public void testRemove2() {
map1.put("name", "Bela");
map1.put("id", "322649");
System.out.println("map1: " + map1);
boolean removed=map1.remove("id", "322000");
assertFalse(removed);
assertTrue(map1.containsKey("id"));
removed=map1.remove("id", "322649");
System.out.println("map1: " + map1);
assertTrue(removed);
assertFalse(map1.containsKey("id"));
Assert.assertEquals(1, map2.size());
}
public void testReplace() {
map1.put("name", "Bela");
map1.put("id", "322649");
System.out.println("map1: " + map1);
String val=map1.replace("id2", "322000");
Assert.assertEquals(2, map1.size());
assert map1.get("id2") == null;
System.out.println("map1: " + map1);
assert val == null;
val=map1.replace("id", "322000");
System.out.println("map1: " + map1);
assertNotNull(val);
Assert.assertEquals("322649", val);
Assert.assertEquals("322000", map1.get("id"));
Assert.assertEquals("322000", map2.get("id"));
}
public void testReplace2() {
map1.put("name", "Bela");
map1.put("id", "322649");
System.out.println("map1: " + map1);
boolean replaced=map1.replace("id", "322000", "1");
assertFalse(replaced);
Assert.assertEquals("322649", map1.get("id"));
replaced=map1.replace("id", "322649", "1");
assertTrue(replaced);
Assert.assertEquals("1", map1.get("id"));
}
public void testPutAll() {
Map<String,String> all1=new HashMap<String,String>();
all1.put("key1", "value1");
all1.put("key2", "value2");
Map<String,String> all2=new HashMap<String,String>();
all2.put("key3", "value3");
all2.put("key4", "value4");
this.map1.putAll(all1);
Assert.assertEquals(2, this.map1.size());
Assert.assertEquals(2, this.map2.size());
this.map2.putAll(all2);
Assert.assertEquals(4, this.map1.size());
Assert.assertEquals(4, this.map2.size());
assertTrue(this.map1.containsKey("key1"));
assertTrue(this.map1.containsKey("key2"));
assertTrue(this.map1.containsKey("key3"));
assertTrue(this.map1.containsKey("key4"));
assertTrue(this.map2.containsKey("key1"));
assertTrue(this.map2.containsKey("key2"));
assertTrue(this.map2.containsKey("key3"));
assertTrue(this.map2.containsKey("key4"));
}
public void testClear() {
assertTrue(this.map1.isEmpty());
assertTrue(this.map2.isEmpty());
this.map1.put("key", "value");
assertFalse(this.map1.isEmpty());
assertFalse(this.map2.isEmpty());
this.map1.clear();
assertTrue(this.map1.isEmpty());
assertTrue(this.map2.isEmpty());
this.map2.put("key", "value");
assertFalse(this.map1.isEmpty());
assertFalse(this.map2.isEmpty());
this.map2.clear();
assertTrue(this.map1.isEmpty());
assertTrue(this.map2.isEmpty());
}
public void testKeySet() {
Map<String,String> all1=new HashMap<String,String>();
all1.put("key1", "value1");
all1.put("key2", "value2");
Map<String,String> all2=new HashMap<String,String>();
all2.put("key3", "value3");
all2.put("key4", "value4");
this.map1.putAll(all1);
assertEquals(all1.keySet(), this.map1.keySet());
assertEquals(all1.keySet(), this.map2.keySet());
this.map2.putAll(all2);
all1.putAll(all2);
assertEquals(all1.keySet(), this.map1.keySet());
assertEquals(all1.keySet(), this.map2.keySet());
}
public void testValues() {
Map<String,String> all1=new HashMap<String,String>();
all1.put("key1", "value1");
all1.put("key2", "value2");
Map<String,String> all2=new HashMap<String,String>();
all2.put("key3", "value3");
all2.put("key4", "value4");
this.map1.putAll(all1);
assertTrue(this.map1.values().containsAll(all1.values()));
assertTrue(this.map2.values().containsAll(all1.values()));
this.map2.putAll(all2);
all1.putAll(all2);
assertTrue(this.map1.values().containsAll(all1.values()));
assertTrue(this.map2.values().containsAll(all1.values()));
}
}