public final void testNonBlockingIdentityHashMapSize() {
NonBlockingIdentityHashMap<Long, String> items = new NonBlockingIdentityHashMap<Long, String>();
items.put(Long.valueOf(100), "100");
items.put(Long.valueOf(101), "101");
assertEquals("keySet().size()", 2, items.keySet().size());
assertTrue("keySet().contains(100)", items.keySet().contains(Long.valueOf(100)));
assertTrue("keySet().contains(101)", items.keySet().contains(Long.valueOf(101)));
assertEquals("values().size()", 2, items.values().size());
assertTrue("values().contains(\"100\")", items.values().contains("100"));
assertTrue("values().contains(\"101\")", items.values().contains("101"));
assertEquals("entrySet().size()", 2, items.entrySet().size());
boolean found100 = false;
boolean found101 = false;
for (Entry<Long, String> entry : items.entrySet()) {
if (entry.getKey().equals(Long.valueOf(100))) {
assertEquals("entry[100].getValue()==\"100\"", "100", entry.getValue());
found100 = true;
} else if (entry.getKey().equals(Long.valueOf(101))) {
assertEquals("entry[101].getValue()==\"101\"", "101", entry.getValue());
found101 = true;
}
}
assertTrue("entrySet().contains([100])", found100);
assertTrue("entrySet().contains([101])", found101);
}
// Do some simple concurrent testing
public void testConcurrentSimple() throws InterruptedException {
final NonBlockingIdentityHashMap<String, String> nbhm =
new NonBlockingIdentityHashMap<String, String>();
final String[] keys = new String[20000];
for (int i = 0; i < 20000; i++) keys[i] = "k" + i;
// In 2 threads, add & remove even & odd elements concurrently
Thread t1 =
new Thread() {
public void run() {
work_helper(nbhm, "T1", 1, keys);
}
};
t1.start();
work_helper(nbhm, "T0", 0, keys);
t1.join();
// In the end, all members should be removed
StringBuffer buf = new StringBuffer();
buf.append("Should be emptyset but has these elements: {");
boolean found = false;
for (String x : nbhm.keySet()) {
buf.append(" ").append(x);
found = true;
}
if (found) System.out.println(buf + " }");
assertThat("concurrent size=0", nbhm.size(), is(0));
for (String x : nbhm.keySet()) {
assertTrue("No elements so never get here", false);
}
}
public void testIteration() {
assertTrue(_nbhm.isEmpty());
assertThat(_nbhm.put("k1", "v1"), nullValue());
assertThat(_nbhm.put("k2", "v2"), nullValue());
String str1 = "";
for (Iterator<Map.Entry<String, String>> i = _nbhm.entrySet().iterator(); i.hasNext(); ) {
Map.Entry<String, String> e = i.next();
str1 += e.getKey();
}
assertThat("found all entries", str1, anyOf(is("k1k2"), is("k2k1")));
String str2 = "";
for (Iterator<String> i = _nbhm.keySet().iterator(); i.hasNext(); ) {
String key = i.next();
str2 += key;
}
assertThat("found all keys", str2, anyOf(is("k1k2"), is("k2k1")));
String str3 = "";
for (Iterator<String> i = _nbhm.values().iterator(); i.hasNext(); ) {
String val = i.next();
str3 += val;
}
assertThat("found all vals", str3, anyOf(is("v1v2"), is("v2v1")));
assertThat(
"toString works", _nbhm.toString(), anyOf(is("{k1=v1, k2=v2}"), is("{k2=v2, k1=v1}")));
}
// Check all iterators for correct size counts
private void checkSizes(int expectedSize) {
assertEquals("size()", _nbhm.size(), expectedSize);
Collection<String> vals = _nbhm.values();
checkSizes("values()", vals.size(), vals.iterator(), expectedSize);
Set<String> keys = _nbhm.keySet();
checkSizes("keySet()", keys.size(), keys.iterator(), expectedSize);
Set<Entry<String, String>> ents = _nbhm.entrySet();
checkSizes("entrySet()", ents.size(), ents.iterator(), expectedSize);
}
public void testIterationBig() {
final int CNT = 10000;
String[] keys = new String[CNT];
String[] vals = new String[CNT];
assertThat(_nbhm.size(), is(0));
for (int i = 0; i < CNT; i++) _nbhm.put(keys[i] = ("k" + i), vals[i] = ("v" + i));
assertThat(_nbhm.size(), is(CNT));
int sz = 0;
int sum = 0;
for (String s : _nbhm.keySet()) {
sz++;
assertThat("", s.charAt(0), is('k'));
int x = Integer.parseInt(s.substring(1));
sum += x;
assertTrue(x >= 0 && x <= (CNT - 1));
}
assertThat("Found 10000 ints", sz, is(CNT));
assertThat("Found all integers in list", sum, is(CNT * (CNT - 1) / 2));
assertThat("can remove 3", _nbhm.remove(keys[3]), is(vals[3]));
assertThat("can remove 4", _nbhm.remove(keys[4]), is(vals[4]));
sz = 0;
sum = 0;
for (String s : _nbhm.keySet()) {
sz++;
assertThat("", s.charAt(0), is('k'));
int x = Integer.parseInt(s.substring(1));
sum += x;
assertTrue(x >= 0 && x <= (CNT - 1));
String v = _nbhm.get(s);
assertThat("", v.charAt(0), is('v'));
assertThat("", s.substring(1), is(v.substring(1)));
}
assertThat("Found " + (CNT - 2) + " ints", sz, is(CNT - 2));
assertThat("Found all integers in list", sum, is(CNT * (CNT - 1) / 2 - (3 + 4)));
}