This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-collections.git
The following commit(s) were added to refs/heads/master by this push:
new c47f52c1e Rework test fixtures
c47f52c1e is described below
commit c47f52c1ecaee52390878780b66f7524eb6de6c5
Author: Gary Gregory <garydgreg...@gmail.com>
AuthorDate: Sun Mar 31 08:46:47 2024 -0400
Rework test fixtures
Next, grow the amount of data tested to find bugs in the tests with
non-repeatable map ordering
---
.../multimap/AbstractMultiValuedMapTest.java | 255 ++++++++++++---------
.../multimap/UnmodifiableMultiValuedMapTest.java | 6 +-
2 files changed, 152 insertions(+), 109 deletions(-)
diff --git
a/src/test/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapTest.java
b/src/test/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapTest.java
index 7bb8dfb50..c9665c862 100644
---
a/src/test/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapTest.java
+++
b/src/test/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapTest.java
@@ -29,6 +29,7 @@ import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
+import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
@@ -115,7 +116,7 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
final V[] sampleValues =
AbstractMultiValuedMapTest.this.getSampleValues();
final Collection<V>[] colArr = new Collection[3];
for (int i = 0; i < 3; i++) {
- final Collection<V> coll = Arrays.asList(sampleValues[i*2],
sampleValues[i*2 + 1]);
+ final Collection<V> coll = Arrays.asList(sampleValues[i * 2],
sampleValues[i * 2 + 1]);
colArr[i] = isSetValuedMap ? new HashSet<>(coll) : coll;
}
return colArr;
@@ -511,6 +512,10 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
return this.map;
}
+ public int getSampleCountPerKey() {
+ return 2;
+ }
+
/**
* Returns the set of keys in the mappings used to test the map. This
method
* must return an array with the same length as {@link #getSampleValues()}
@@ -520,22 +525,24 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
*/
@SuppressWarnings("unchecked")
public K[] getSampleKeys() {
- final Object[] result = new Object[getSampleSize()];
+ final Object[] result = new Object[getSampleTotalValueCount()];
+ final int cpk = getSampleCountPerKey();
int k = 0;
- for (int i = 0; i < result.length; i += 2, k++) {
- final String key = "k" + Integer.valueOf(k);
- result[i] = key;
- result[i + 1] = key;
+ for (int i = 0; i < result.length; i += cpk, k++) {
+ final K key = makeKey(k);
+ for (int j = 0; j < cpk; j++) {
+ result[i + j] = key;
+ }
}
return (K[]) result;
}
- public int getSampleSize() {
- return 6;
+ public int getSampleKeySize() {
+ return 3;
}
- public int getSampleValuesPerKey() {
- return 2;
+ public int getSampleTotalValueCount() {
+ return getSampleCountPerKey() * getSampleKeySize();
}
/**
@@ -546,12 +553,13 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
*/
@SuppressWarnings("unchecked")
public V[] getSampleValues() {
- final Object[] result = new Object[getSampleSize()];
+ final Object[] result = new Object[getSampleTotalValueCount()];
+ final int cpk = getSampleCountPerKey();
int k = 0;
- for (int i = 0; i < result.length; i += 2, k++) {
- final String key = "v" + Integer.valueOf(k);
- result[i] = key + "_a";
- result[i + 1] = key + "_b";
+ for (int i = 0; i < result.length; i += cpk, k++) {
+ for (int j = 0; j < cpk; j++) {
+ result[i + j] = makeValue(k, j);
+ }
}
return (V[]) result;
}
@@ -627,9 +635,17 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
return map;
}
+ <E> E makeKey(final int key) {
+ return (E) new StringBuilder("k").append(key).toString();
+ }
+
@Override
public abstract MultiValuedMap<K, V> makeObject();
+ String makeValue(final int key, final int value) {
+ return new
StringBuilder("v").append(key).append('_').append(value).toString();
+ }
+
/**
* Resets the {@link #map} and {@link #confirmed} fields to empty.
*/
@@ -654,7 +670,7 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
// public void testKeyedIterator() {
// final MultiValuedMap<K, V> map = makeFullMap();
// final ArrayList<Object> actual = new
ArrayList<Object>(IteratorUtils.toList(map.iterator("k0")));
-// final ArrayList<Object> expected = new
ArrayList<Object>(Arrays.asList("v1_b", "v0_b"));
+// final ArrayList<Object> expected = new
ArrayList<Object>(Arrays.asList("v1_1", "v0_1"));
// assertEquals(expected, actual);
// }
@@ -675,15 +691,15 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
assertTrue(col1.isEmpty());
assertTrue(col2.isEmpty());
assertEquals(0, map.size());
- col1.add((V) "v1_b");
- col2.add((V) "v0_b");
+ col1.add((V) "v1_1");
+ col2.add((V) "v0_1");
assertTrue(map.containsKey("k0"));
- assertTrue(map.containsMapping("k0", "v1_b"));
- assertTrue(map.containsMapping("k0", "v0_b"));
- assertTrue(map.containsValue("v1_b"));
- assertTrue(map.containsValue("v0_b"));
- assertTrue(col1.contains("v0_b"));
- assertTrue(col2.contains("v1_b"));
+ assertTrue(map.containsMapping("k0", "v1_1"));
+ assertTrue(map.containsMapping("k0", "v0_1"));
+ assertTrue(map.containsValue("v1_1"));
+ assertTrue(map.containsValue("v0_1"));
+ assertTrue(col1.contains("v0_1"));
+ assertTrue(col2.contains("v1_1"));
}
/*public void testRemoveViaGetCollectionRemove() {
@@ -692,8 +708,8 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
}
final MultiValuedMap<K, V> map = makeFullMap();
Collection<V> values = map.get("k0");
- values.remove("v1_b");
- values.remove("v0_b");
+ values.remove("v1_1");
+ values.remove("v0_1");
assertFalse(map.containsKey("k0"));
assertEquals(4, map.size());
}*/
@@ -712,18 +728,25 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
// }
@Test
- public void testAsMapGet() {
+ public void testAsMapGet_Empty() {
resetEmpty();
- Map<K, Collection<V>> mapCol = getMap().asMap();
+ final Map<K, Collection<V>> mapCol = getMap().asMap();
assertNull(mapCol.get("k0"));
assertEquals(0, mapCol.size());
+ }
+ @Test
+ public void testAsMapGet_Full() {
resetFull();
- mapCol = getMap().asMap();
- final Collection<V> col = mapCol.get("k0");
- assertNotNull(col);
- assertTrue(col.contains("v0_a"));
- assertTrue(col.contains("v0_b"));
+ final Map<K, Collection<V>> mapCol = getMap().asMap();
+ final int maxK = getSampleKeySize();
+ final int maxV = getSampleCountPerKey();
+ for (int k = 0; k < maxK; k++) {
+ final Collection<V> col = mapCol.get(makeKey(k));
+ for (int v = 0; v < maxV; v++) {
+ assertTrue(col.contains(makeValue(k, v)));
+ }
+ }
}
@Test
@@ -741,12 +764,13 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
@Test
public void testContainsValue() {
final MultiValuedMap<K, V> map = makeFullMap();
- assertTrue(map.containsValue("v1_b"));
- assertTrue(map.containsValue("v0_b"));
- assertTrue(map.containsValue("v1_a"));
- assertTrue(map.containsValue("v1_b"));
- assertTrue(map.containsValue("v2_a"));
- assertTrue(map.containsValue("v2_b"));
+ final int maxK = getSampleKeySize();
+ final int maxV = getSampleCountPerKey();
+ for (int k = 0; k < maxK; k++) {
+ for (int v = 0; v < maxV; v++) {
+ assertTrue(map.containsValue(makeValue(k, v)));
+ }
+ }
assertFalse(map.containsValue("quatro"));
}
@@ -754,7 +778,7 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
@SuppressWarnings("unchecked")
public void testContainsValue_Key() {
final MultiValuedMap<K, V> map = makeFullMap();
- assertTrue(map.containsMapping("k0", "v0_b"));
+ assertTrue(map.containsMapping("k0", "v0_1"));
assertFalse(map.containsMapping("k1", "2"));
if (!isAddSupported()) {
return;
@@ -820,8 +844,8 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
// while (it.hasNext()) {
// values.add(it.next());
// }
-// assertTrue( values.contains("v0_b"));
-// assertTrue( values.contains("v1_b"));
+// assertTrue( values.contains("v0_1"));
+// assertTrue( values.contains("v1_1"));
// assertFalse(map.iterator("A").hasNext());
// assertFalse(map.iterator("A").hasNext());
// if (!isAddSupported()) {
@@ -838,48 +862,59 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
@SuppressWarnings("unchecked")
public void testGet() {
final MultiValuedMap<K, V> map = makeFullMap();
- assertTrue(map.get((K) "k0").contains("v0_a"));
- assertTrue(map.get((K) "k0").contains("v0_b"));
- assertTrue(map.get((K) "k1").contains("v1_a"));
- assertTrue(map.get((K) "k1").contains("v1_b"));
- assertTrue(map.get((K) "k2").contains("v2_a"));
- assertTrue(map.get((K) "k2").contains("v2_b"));
+ final int maxK = getSampleKeySize();
+ final int maxV = getSampleCountPerKey();
+ for (int k = 0; k < maxK; k++) {
+ for (int v = 0; v < maxV; v++) {
+ assertTrue(map.get((K) makeKey(k)).contains(makeValue(k, v)));
+ }
+ }
}
@Test
public void testKeyContainsValue() {
final MultiValuedMap<K, V> map = makeFullMap();
- assertTrue(map.containsMapping("k0", "v0_a"));
- assertTrue(map.containsMapping("k0", "v0_b"));
- assertTrue(map.containsMapping("k1", "v1_a"));
- assertTrue(map.containsMapping("k1", "v1_b"));
- assertTrue(map.containsMapping("k2", "v2_a"));
- assertTrue(map.containsMapping("k2", "v2_b"));
+ final int maxK = getSampleKeySize();
+ final int maxV = getSampleCountPerKey();
+ for (int k = 0; k < maxK; k++) {
+ for (int v = 0; v < maxV; v++) {
+ assertTrue(map.containsMapping(makeKey(k), makeValue(k, v)));
+ }
+ }
assertFalse(map.containsMapping("k", "v"));
}
@Test
- @SuppressWarnings("unchecked")
+ @SuppressWarnings({ "unchecked", "cast" })
public void testKeysBagContainsAll() {
final MultiValuedMap<K, V> map = makeFullMap();
final MultiSet<K> keyMultiSet = map.keys();
- final Collection<K> col = (Collection<K>) Arrays.asList("k0", "k1",
"k2", "k0", "k1", "k2");
- assertTrue(keyMultiSet.containsAll(col));
+
+ final List<String> col = new ArrayList<>();
+ final int maxK = getSampleKeySize();
+ for (int k = 0; k < maxK; k++) {
+ col.add(makeKey(k));
+ }
+ for (int k = 0; k < maxK; k++) {
+ col.add(makeKey(k));
+ }
+ // Make sure we test Collection API
+ assertTrue(keyMultiSet.containsAll((Collection<K>) col));
}
@Test
public void testKeysBagIterator() {
final MultiValuedMap<K, V> map = makeFullMap();
final Collection<K> col = new ArrayList<>();
- final Iterator<K> it = map.keys().iterator();
- while (it.hasNext()) {
- col.add(it.next());
+ for (K element : map.keys()) {
+ col.add(element);
}
final Bag<K> bag = new HashBag<>(col);
- assertEquals(2, bag.getCount("k0"));
- assertEquals(2, bag.getCount("k1"));
- assertEquals(2, bag.getCount("k2"));
- assertEquals(getSampleSize(), bag.size());
+ final int maxK = getSampleKeySize();
+ for (int k = 0; k < maxK; k++) {
+ assertEquals(getSampleCountPerKey(), bag.getCount(makeKey(k)));
+ }
+ assertEquals(getSampleTotalValueCount(), bag.size());
}
@Test
@@ -892,11 +927,12 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
public void testKeysMultiSet() {
final MultiValuedMap<K, V> map = makeFullMap();
final MultiSet<K> keyMultiSet = map.keys();
- assertEquals(2, keyMultiSet.getCount("k0"));
- assertEquals(2, keyMultiSet.getCount("k1"));
- assertEquals(2, keyMultiSet.getCount("k2"));
+ final int maxK = getSampleKeySize();
+ for (int k = 0; k < maxK; k++) {
+ assertEquals(getSampleCountPerKey(),
keyMultiSet.getCount(makeKey(k)));
+ }
assertEquals(0, keyMultiSet.getCount("conut"));
- assertEquals(getSampleSize(), keyMultiSet.size());
+ assertEquals(getSampleTotalValueCount(), keyMultiSet.size());
}
@Test
@@ -955,10 +991,15 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
@Test
public void testMultipleValues() {
final MultiValuedMap<K, V> map = makeFullMap();
- @SuppressWarnings("unchecked")
- final Collection<V> col = map.get((K) "k0");
- assertTrue(col.contains("v0_a"));
- assertTrue(col.contains("v0_b"));
+ final int maxK = getSampleKeySize();
+ final int maxV = getSampleCountPerKey();
+ for (int k = 0; k < maxK; k++) {
+ final Collection<V> col = map.get(makeKey(k));
+ for (int v = 0; v < maxV; v++) {
+ assertTrue(col.contains(makeValue(k, v)));
+ }
+ }
+
}
@Test
@@ -976,22 +1017,22 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
assertTrue(it.hasNext() );
assertEquals("k0", it.next());
assertEquals("k0", it.getKey());
- assertEquals("v0_a", it.getValue());
+ assertEquals("v0_0", it.getValue());
assertEquals("k0", it.next());
assertEquals("k0", it.getKey());
- assertEquals("v0_b", it.getValue());
+ assertEquals("v0_1", it.getValue());
assertEquals("k1", it.next());
assertEquals("k1", it.getKey());
- assertEquals("v1_a", it.getValue());
+ assertEquals("v1_0", it.getValue());
assertEquals("k1", it.next());
assertEquals("k1", it.getKey());
- assertEquals("v1_b", it.getValue());
+ assertEquals("v1_1", it.getValue());
assertEquals("k2", it.next());
assertEquals("k2", it.getKey());
- assertEquals("v2_a", it.getValue());
+ assertEquals("v2_0", it.getValue());
assertEquals("k2", it.next());
assertEquals("k2", it.getKey());
- assertEquals("v2_b", it.getValue());
+ assertEquals("v2_1", it.getValue());
assertThrows(UnsupportedOperationException.class, () ->
it.setValue((V) "threetrois"));
}
}
@@ -1157,15 +1198,15 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
final MultiValuedMap<K, V> map = getMap();
@SuppressWarnings("unchecked")
Collection<V> col = map.get((K) "k0");
- assertEquals(2, col.size());
- assertEquals(getSampleSize(), map.size());
- assertTrue(col.remove("v0_a"));
- assertTrue(col.remove("v0_b"));
+ assertEquals(getSampleCountPerKey(), col.size());
+ assertEquals(getSampleTotalValueCount(), map.size());
+ assertTrue(col.remove("v0_0"));
+ assertTrue(col.remove("v0_1"));
assertFalse(map.containsKey("k0"));
- assertFalse(map.containsMapping("k0", "v0_a"));
- assertFalse(map.containsMapping("k0", "v0_b"));
- assertFalse(map.containsValue("v0_a"));
- assertFalse(map.containsValue("v0_b"));
+ assertFalse(map.containsMapping("k0", "v0_0"));
+ assertFalse(map.containsMapping("k0", "v0_1"));
+ assertFalse(map.containsValue("v0_0"));
+ assertFalse(map.containsValue("v0_1"));
assertEquals(4, map.size());
col = map.remove("k0");
assertNotNull(col);
@@ -1186,10 +1227,10 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
it.remove();
}
assertFalse(map.containsKey("k0"));
- assertFalse(map.containsMapping("k0", "v1_b"));
- assertFalse(map.containsMapping("k0", "v0_b"));
- assertFalse(map.containsValue("v0_a"));
- assertFalse(map.containsValue("v0_b"));
+ assertFalse(map.containsMapping("k0", "v1_1"));
+ assertFalse(map.containsMapping("k0", "v0_1"));
+ assertFalse(map.containsValue("v0_0"));
+ assertFalse(map.containsValue("v0_1"));
assertEquals(4, map.size());
final Collection<V> coll = map.remove("k0");
assertNotNull(coll);
@@ -1203,30 +1244,31 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
}
final MultiValuedMap<K, V> map = makeFullMap();
final Collection<V> values = map.values();
- values.remove("v0_a");
- values.remove("v0_b");
+ values.remove("v0_0");
+ values.remove("v0_1");
assertFalse(map.containsKey("k0"));
assertEquals(4, map.size());
}
@Test
public void testSize() {
- assertEquals(getSampleSize(), makeFullMap().size());
+ assertEquals(getSampleTotalValueCount(), makeFullMap().size());
}
@Test
@SuppressWarnings("unchecked")
public void testSize_Key() {
final MultiValuedMap<K, V> map = makeFullMap();
- assertEquals(2, map.get((K) "k0").size());
- assertEquals(2, map.get((K) "k1").size());
- assertEquals(2, map.get((K) "k2").size());
+ final int maxK = getSampleKeySize();
+ for (int k = 0; k < maxK; k++) {
+ assertEquals(getSampleCountPerKey(), map.get((K)
makeKey(k)).size());
+ }
if (!isAddSupported()) {
return;
}
map.put((K) "A", (V) "AA");
assertEquals(1, map.get((K) "A").size());
- //assertEquals(0, map.get("B").size());
+ // assertEquals(0, map.get("B").size());
map.put((K) "B", (V) "BA");
assertEquals(1, map.get((K) "A").size());
assertEquals(1, map.get((K) "B").size());
@@ -1240,10 +1282,10 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
return;
}
map.remove("A");
- //assertEquals(0, map.get("A").size());
+ // assertEquals(0, map.get("A").size());
assertEquals(3, map.get((K) "B").size());
map.removeMapping("B", "BC");
- //assertEquals(0, map.get("A").size());
+ // assertEquals(0, map.get("A").size());
assertEquals(2, map.get((K) "B").size());
}
@@ -1304,14 +1346,15 @@ public abstract class AbstractMultiValuedMapTest<K, V>
extends AbstractObjectTes
public void testValues() {
final MultiValuedMap<K, V> map = makeFullMap();
final HashSet<V> expected = new HashSet<>();
- expected.add((V) "v0_a");
- expected.add((V) "v0_b");
- expected.add((V) "v1_a");
- expected.add((V) "v1_b");
- expected.add((V) "v2_a");
- expected.add((V) "v2_b");
+ final int maxK = getSampleKeySize();
+ final int maxV = getSampleCountPerKey();
+ for (int k = 0; k < maxK; k++) {
+ for (int v = 0; v < maxV; v++) {
+ expected.add((V) makeValue(k, v));
+ }
+ }
final Collection<V> c = map.values();
- assertEquals(getSampleSize(), c.size());
+ assertEquals(getSampleTotalValueCount(), c.size());
assertEquals(expected, new HashSet<>(c));
}
diff --git
a/src/test/java/org/apache/commons/collections4/multimap/UnmodifiableMultiValuedMapTest.java
b/src/test/java/org/apache/commons/collections4/multimap/UnmodifiableMultiValuedMapTest.java
index aa5e0bc0e..efa0c651f 100644
---
a/src/test/java/org/apache/commons/collections4/multimap/UnmodifiableMultiValuedMapTest.java
+++
b/src/test/java/org/apache/commons/collections4/multimap/UnmodifiableMultiValuedMapTest.java
@@ -52,9 +52,9 @@ public class UnmodifiableMultiValuedMapTest<K, V> extends
AbstractMultiValuedMap
* @param map the MultiValuedMap<K, V> to check
*/
private void assertMapContainsAllValues(final MultiValuedMap<K, V> map) {
- assertEquals("[v0_a, v0_b]", map.get((K) "k0").toString());
- assertEquals("[v1_a, v1_b]", map.get((K) "k1").toString());
- assertEquals("[v2_a, v2_b]", map.get((K) "k2").toString());
+ assertEquals("[v0_0, v0_1]", map.get((K) "k0").toString());
+ assertEquals("[v1_0, v1_1]", map.get((K) "k1").toString());
+ assertEquals("[v2_0, v2_1]", map.get((K) "k2").toString());
}
@Override
