Improved coverage for ExtendedSet.
Added test case for retainAll but test case failed. Added Ignore for that test case.
Change-Id: I893f761c73ef6b366e95093c4ed51dc2fbdad96f
diff --git a/utils/misc/src/test/java/org/onlab/util/ExtendedSetTest.java b/utils/misc/src/test/java/org/onlab/util/ExtendedSetTest.java
index fa39d96..b647cb9 100644
--- a/utils/misc/src/test/java/org/onlab/util/ExtendedSetTest.java
+++ b/utils/misc/src/test/java/org/onlab/util/ExtendedSetTest.java
@@ -15,8 +15,11 @@
*/
package org.onlab.util;
+import java.util.ArrayList;
+import java.util.Iterator;
import java.util.Objects;
+import org.junit.Ignore;
import org.junit.Test;
import com.google.common.collect.Maps;
@@ -64,6 +67,174 @@
assertTrue(set.add(small));
set.conditionalRemove(medium, existing -> existing.value2() < medium.value2);
assertFalse(set.contains(small));
+
+ assertTrue(set.add(small));
+ set.conditionalRemove(medium, existing -> existing.value2() > medium.value2);
+ assertTrue(set.contains(small));
+
+ }
+
+ @Test
+ public void testIsEmpty() {
+ ExtendedSet<TestValue> nonemptyset = new ExtendedSet<>(Maps.newConcurrentMap());
+ TestValue val = new TestValue("foo", 1);
+ assertTrue(nonemptyset.insertOrReplace(val, existing -> existing.value2() < val.value2()));
+ assertTrue(nonemptyset.contains(val));
+ assertFalse(nonemptyset.isEmpty());
+
+ ExtendedSet<TestValue> emptyset = new ExtendedSet<>(Maps.newConcurrentMap());
+ assertTrue(emptyset.isEmpty());
+
+ }
+
+ @Test
+ public void testClear() {
+ ExtendedSet<TestValue> set = new ExtendedSet<>(Maps.newConcurrentMap());
+ TestValue val = new TestValue("foo", 1);
+ assertTrue(set.insertOrReplace(val, existing -> existing.value2() < val.value2()));
+ assertTrue(set.contains(val));
+ set.clear();
+ assertFalse(set.contains(val));
+ }
+
+ @Test
+ public void testSize() {
+ ExtendedSet<TestValue> nonemptyset = new ExtendedSet<>(Maps.newConcurrentMap());
+ TestValue val = new TestValue("foo", 1);
+ assertTrue(nonemptyset.insertOrReplace(val, existing -> existing.value2() < val.value2()));
+ assertTrue(nonemptyset.contains(val));
+ assertEquals(1, nonemptyset.size());
+ TestValue secval = new TestValue("goo", 2);
+ assertTrue(nonemptyset.insertOrReplace(secval, existing -> existing.value2() < secval.value2()));
+ assertTrue(nonemptyset.contains(secval));
+ assertEquals(2, nonemptyset.size());
+
+ ExtendedSet<TestValue> emptyset = new ExtendedSet<>(Maps.newConcurrentMap());
+ assertEquals(0, emptyset.size());
+ }
+
+ @Test
+ public void testIterator() {
+ ExtendedSet<TestValue> set = new ExtendedSet<>(Maps.newConcurrentMap());
+ TestValue val = new TestValue("foo", 1);
+ assertTrue(set.insertOrReplace(val, existing -> existing.value2() < val.value2()));
+ TestValue nextval = new TestValue("goo", 2);
+ assertTrue(set.insertOrReplace(nextval, existing -> existing.value2() < nextval.value2()));
+ assertTrue(set.contains(nextval));
+ Iterator<TestValue> iterator = set.iterator();
+ assertEquals(val, iterator.next());
+ assertTrue(iterator.hasNext());
+ assertEquals(nextval, iterator.next());
+ }
+
+ @Test
+ public void testToArray() {
+ ExtendedSet<TestValue> set = new ExtendedSet<>(Maps.newConcurrentMap());
+ TestValue val = new TestValue("foo", 1);
+ assertTrue(set.insertOrReplace(val, existing -> existing.value2() < val.value2()));
+ TestValue nextval = new TestValue("goo", 2);
+ assertTrue(set.insertOrReplace(nextval, existing -> existing.value2() < nextval.value2()));
+ Object[] array = set.toArray();
+ TestValue[] valarray = {val, nextval};
+ assertArrayEquals(valarray, array);
+ assertTrue(set.toArray(new TestValue[0])[0] instanceof TestValue);
+
+ }
+
+ @Test
+ public void testContainsAll() {
+ ExtendedSet<TestValue> set = new ExtendedSet<>(Maps.newConcurrentMap());
+ TestValue val = new TestValue("foo", 1);
+ assertTrue(set.insertOrReplace(val, existing -> existing.value2() < val.value2()));
+ TestValue nextval = new TestValue("goo", 2);
+ assertTrue(set.insertOrReplace(nextval, existing -> existing.value2() < nextval.value2()));
+ ArrayList<TestValue> vals = new ArrayList<TestValue>();
+ vals.add(val);
+ vals.add(nextval);
+ assertTrue(set.containsAll(vals));
+ }
+
+ @Test
+ public void testRemove() {
+ ExtendedSet<TestValue> set = new ExtendedSet<>(Maps.newConcurrentMap());
+ TestValue val = new TestValue("foo", 1);
+ assertTrue(set.insertOrReplace(val, existing -> existing.value2() < val.value2()));
+ TestValue nextval = new TestValue("goo", 2);
+ assertTrue(set.insertOrReplace(nextval, existing -> existing.value2() < nextval.value2()));
+ assertTrue(set.remove(val));
+ assertFalse(set.contains(val));
+ assertTrue(set.remove(nextval));
+ assertFalse(set.contains(nextval));
+ }
+
+ @Test
+ public void testAddAll() {
+ ExtendedSet<TestValue> nonemptyset = new ExtendedSet<>(Maps.newConcurrentMap());
+ TestValue val = new TestValue("foo", 1);
+ assertTrue(nonemptyset.insertOrReplace(val, existing -> existing.value2() < val.value2()));
+ TestValue nextval = new TestValue("goo", 2);
+ TestValue finalval = new TestValue("shoo", 3);
+ ArrayList<TestValue> vals = new ArrayList<TestValue>();
+ vals.add(nextval);
+ vals.add(finalval);
+ assertTrue(nonemptyset.addAll(vals));
+ assertTrue(nonemptyset.contains(nextval));
+ assertTrue(nonemptyset.contains(finalval));
+
+ ExtendedSet<TestValue> emptyset = new ExtendedSet<>(Maps.newConcurrentMap());
+ vals = new ArrayList<TestValue>();
+ vals.add(val);
+ vals.add(nextval);
+ vals.add(finalval);
+ assertTrue(emptyset.addAll(vals));
+ assertTrue(emptyset.contains(val));
+ assertTrue(emptyset.contains(nextval));
+ assertTrue(emptyset.contains(finalval));
+ }
+
+ @Test
+ public void testRemoveAll() {
+ ExtendedSet<TestValue> set = new ExtendedSet<>(Maps.newConcurrentMap());
+ TestValue val = new TestValue("foo", 1);
+ assertTrue(set.insertOrReplace(val, existing -> existing.value2() < val.value2()));
+ TestValue nextval = new TestValue("goo", 2);
+ assertTrue(set.insertOrReplace(nextval, existing -> existing.value2() < nextval.value2()));
+ TestValue finalval = new TestValue("shoo", 3);
+ assertTrue(set.insertOrReplace(finalval, existing -> existing.value2() < finalval.value2()));
+ ArrayList<TestValue> vals = new ArrayList<TestValue>();
+ vals.add(nextval);
+ vals.add(finalval);
+ assertTrue(set.removeAll(vals));
+ assertFalse(set.contains(nextval));
+ assertFalse(set.contains(finalval));
+ }
+
+ @Test
+ @Ignore("retainAll appears to violate the documented semantics because it does" +
+ " not properly remove the items that are not in the Collection parameter.")
+ public void testRetainAll() {
+ ExtendedSet<TestValue> set = new ExtendedSet<>(Maps.newConcurrentMap());
+ TestValue small = new TestValue("foo", 1);
+ assertTrue(set.insertOrReplace(small, existing -> existing.value2() < small.value2()));
+ TestValue medium = new TestValue("goo", 2);
+ assertTrue(set.insertOrReplace(medium, existing -> existing.value2() < medium.value2()));
+ TestValue large = new TestValue("shoo", 3);
+ assertTrue(set.insertOrReplace(large, existing -> existing.value2() < large.value2()));
+ TestValue extreme = new TestValue("who", 4);
+ assertTrue(set.insertOrReplace(extreme, existing -> existing.value2() < extreme.value2()));
+ ArrayList<TestValue> firstvals = new ArrayList<TestValue>();
+ firstvals.add(medium);
+ firstvals.add(extreme);
+ set.retainAll(firstvals);
+ assertTrue(set.contains(medium));
+ assertTrue(set.contains(extreme));
+ assertFalse(set.contains(small));
+ assertFalse(set.contains(large));
+ ArrayList<TestValue> secondval = new ArrayList<TestValue>();
+ secondval.add(medium);
+ set.retainAll(secondval);
+ assertFalse(set.contains(extreme));
+ assertTrue(set.contains(medium));
}
private class TestValue {