You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2018/11/23 07:32:12 UTC
[1/2] commons-collections git commit: Sort members.
Repository: commons-collections
Updated Branches:
refs/heads/master 2ec7843b9 -> 1979a6e31
Sort members.
Project: http://git-wip-us.apache.org/repos/asf/commons-collections/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-collections/commit/dc828f8b
Tree: http://git-wip-us.apache.org/repos/asf/commons-collections/tree/dc828f8b
Diff: http://git-wip-us.apache.org/repos/asf/commons-collections/diff/dc828f8b
Branch: refs/heads/master
Commit: dc828f8b16a4e34d474b2470041eb0d757853a09
Parents: 2ec7843
Author: Gary Gregory <ga...@gmail.com>
Authored: Fri Nov 23 00:24:01 2018 -0700
Committer: Gary Gregory <ga...@gmail.com>
Committed: Fri Nov 23 00:24:01 2018 -0700
----------------------------------------------------------------------
.../collections4/list/SetUniqueListTest.java | 542 +++++++++----------
1 file changed, 271 insertions(+), 271 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/dc828f8b/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java b/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java
index 1207dc8..24d2209 100644
--- a/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java
@@ -32,27 +32,27 @@ import java.util.Set;
*/
public class SetUniqueListTest<E> extends AbstractListTest<E> {
- public SetUniqueListTest(final String testName) {
- super(testName);
+ class SetUniqueList307 extends SetUniqueList<E> {
+ /**
+ * Generated serial version ID.
+ */
+ private static final long serialVersionUID = 1415013031022962158L;
+
+ public SetUniqueList307(final List<E> list, final Set<E> set) {
+ super(list, set);
+ }
}
- //-----------------------------------------------------------------------
- @Override
- public List<E> makeObject() {
- return new SetUniqueList<>(new ArrayList<E>(), new HashSet<E>());
+ boolean extraVerify = true;
+
+ public SetUniqueListTest(final String testName) {
+ super(testName);
}
//-----------------------------------------------------------------------
@Override
- public void testListIteratorSet() {
- // override to block
- resetFull();
- final ListIterator<E> it = getCollection().listIterator();
- it.next();
- try {
- it.set(null);
- fail();
- } catch (final UnsupportedOperationException ex) {}
+ public String getCompatibilityVersion() {
+ return "4";
}
@Override
@@ -80,33 +80,35 @@ public class SetUniqueListTest<E> extends AbstractListTest<E> {
};
}
+ //-----------------------------------------------------------------------
@Override
- public void testListIteratorAdd() {
- // override to cope with Set behaviour
- resetEmpty();
- final List<E> list1 = getCollection();
- final List<E> list2 = getConfirmed();
+ public List<E> makeObject() {
+ return new SetUniqueList<>(new ArrayList<E>(), new HashSet<E>());
+ }
- final E[] elements = getOtherElements(); // changed here
- ListIterator<E> iter1 = list1.listIterator();
- ListIterator<E> iter2 = list2.listIterator();
+ @SuppressWarnings("unchecked")
+ public void testAdd() {
+ final SetUniqueList<E> lset = new SetUniqueList<>(new ArrayList<E>(), new HashSet<E>());
- for (final E element : elements) {
- iter1.add(element);
- iter2.add(element);
- super.verify(); // changed here
- }
+ // Duplicate element
+ final E obj = (E) Integer.valueOf(1);
+ lset.add(obj);
+ lset.add(obj);
+ assertEquals("Duplicate element was added.", 1, lset.size());
- resetFull();
- iter1 = getCollection().listIterator();
- iter2 = getConfirmed().listIterator();
- for (final E element : elements) {
- iter1.next();
- iter2.next();
- iter1.add(element);
- iter2.add(element);
- super.verify(); // changed here
- }
+ // Unique element
+ lset.add((E) Integer.valueOf(2));
+ assertEquals("Unique element was not added.", 2, lset.size());
+ }
+
+ @SuppressWarnings("unchecked")
+ public void testAddAll() {
+ final SetUniqueList<E> lset = new SetUniqueList<>(new ArrayList<E>(), new HashSet<E>());
+
+ lset.addAll(
+ Arrays.asList((E[]) new Integer[] { Integer.valueOf(1), Integer.valueOf(1)}));
+
+ assertEquals("Duplicate element was added.", 1, lset.size());
}
@Override
@@ -137,6 +139,92 @@ public class SetUniqueListTest<E> extends AbstractListTest<E> {
assertEquals("Size should increase after addAll",
size + elements.length, getCollection().size());
}
+ @Override
+ public void testCollectionIteratorRemove() {
+ try {
+ extraVerify = false;
+ super.testCollectionIteratorRemove();
+ } finally {
+ extraVerify = true;
+ }
+ }
+
+ public void testCollections304() {
+ final List<String> list = new LinkedList<>();
+ final SetUniqueList<String> decoratedList = SetUniqueList.setUniqueList(list);
+ final String s1 = "Apple";
+ final String s2 = "Lemon";
+ final String s3 = "Orange";
+ final String s4 = "Strawberry";
+
+ decoratedList.add(s1);
+ decoratedList.add(s2);
+ decoratedList.add(s3);
+ assertEquals(3, decoratedList.size());
+
+ decoratedList.set(1, s4);
+ assertEquals(3, decoratedList.size());
+
+ decoratedList.add(1, s4);
+ assertEquals(3, decoratedList.size());
+
+ decoratedList.add(1, s2);
+ assertEquals(4, decoratedList.size());
+ }
+
+ @SuppressWarnings("unchecked")
+ public void testCollections307() {
+ List<E> list = new ArrayList<>();
+ List<E> uniqueList = SetUniqueList.setUniqueList(list);
+
+ final String hello = "Hello";
+ final String world = "World";
+ uniqueList.add((E) hello);
+ uniqueList.add((E) world);
+
+ List<E> subList = list.subList(0, 0);
+ List<E> subUniqueList = uniqueList.subList(0, 0);
+
+ assertFalse(subList.contains(world)); // passes
+ assertFalse(subUniqueList.contains(world)); // fails
+
+ List<E> worldList = new ArrayList<>();
+ worldList.add((E) world);
+ assertFalse(subList.contains("World")); // passes
+ assertFalse(subUniqueList.contains("World")); // fails
+
+ // repeat the test with a different class than HashSet;
+ // which means subclassing SetUniqueList below
+ list = new ArrayList<>();
+ uniqueList = new SetUniqueList307(list, new java.util.TreeSet<E>());
+
+ uniqueList.add((E) hello);
+ uniqueList.add((E) world);
+
+ subList = list.subList(0, 0);
+ subUniqueList = uniqueList.subList(0, 0);
+
+ assertFalse(subList.contains(world)); // passes
+ assertFalse(subUniqueList.contains(world)); // fails
+
+ worldList = new ArrayList<>();
+ worldList.add((E) world);
+ assertFalse(subList.contains("World")); // passes
+ assertFalse(subUniqueList.contains("World")); // fails
+ }
+
+ //-----------------------------------------------------------------------
+ public void testFactory() {
+ final Integer[] array = new Integer[] { Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(1) };
+ final ArrayList<Integer> list = new ArrayList<>(Arrays.asList(array));
+ final SetUniqueList<Integer> lset = SetUniqueList.setUniqueList(list);
+
+ assertEquals("Duplicate element was added.", 2, lset.size());
+ assertEquals(Integer.valueOf(1), lset.get(0));
+ assertEquals(Integer.valueOf(2), lset.get(1));
+ assertEquals(Integer.valueOf(1), list.get(0));
+ assertEquals(Integer.valueOf(2), list.get(1));
+ }
public void testIntCollectionAddAll() {
// make a SetUniqueList with one element
@@ -163,85 +251,130 @@ public class SetUniqueListTest<E> extends AbstractListTest<E> {
assertEquals("Third new element should be at index 0", thirdNewElement, list.get(0));
}
- @Override
@SuppressWarnings("unchecked")
- public void testListSetByIndex() {
- // override for set behaviour
- resetFull();
- final int size = getCollection().size();
- getCollection().set(0, (E) new Long(1000));
- assertEquals(size, getCollection().size());
+ public void testListIterator() {
+ final SetUniqueList<E> lset = new SetUniqueList<>(new ArrayList<E>(), new HashSet<E>());
- getCollection().set(2, (E) new Long(1000));
- assertEquals(size - 1, getCollection().size());
- assertEquals(new Long(1000), getCollection().get(1)); // set into 2, but shifted down to 1
- }
+ final E obj1 = (E) Integer.valueOf(1);
+ final E obj2 = (E) Integer.valueOf(2);
+ lset.add(obj1);
+ lset.add(obj2);
- boolean extraVerify = true;
- @Override
- public void testCollectionIteratorRemove() {
- try {
- extraVerify = false;
- super.testCollectionIteratorRemove();
- } finally {
- extraVerify = true;
+ // Attempts to add a duplicate object
+ for (final ListIterator<E> it = lset.listIterator(); it.hasNext();) {
+ it.next();
+
+ if (!it.hasNext()) {
+ it.add(obj1);
+ break;
+ }
}
+
+ assertEquals("Duplicate element was added", 2, lset.size());
}
@Override
- @SuppressWarnings("unchecked")
- public void verify() {
- super.verify();
+ public void testListIteratorAdd() {
+ // override to cope with Set behaviour
+ resetEmpty();
+ final List<E> list1 = getCollection();
+ final List<E> list2 = getConfirmed();
- if (extraVerify) {
- final int size = getCollection().size();
- getCollection().add((E) new Long(1000));
- assertEquals(size + 1, getCollection().size());
+ final E[] elements = getOtherElements(); // changed here
+ ListIterator<E> iter1 = list1.listIterator();
+ ListIterator<E> iter2 = list2.listIterator();
- getCollection().add((E) new Long(1000));
- assertEquals(size + 1, getCollection().size());
- assertEquals(new Long(1000), getCollection().get(size));
+ for (final E element : elements) {
+ iter1.add(element);
+ iter2.add(element);
+ super.verify(); // changed here
+ }
- getCollection().remove(size);
+ resetFull();
+ iter1 = getCollection().listIterator();
+ iter2 = getConfirmed().listIterator();
+ for (final E element : elements) {
+ iter1.next();
+ iter2.next();
+ iter1.add(element);
+ iter2.add(element);
+ super.verify(); // changed here
}
}
//-----------------------------------------------------------------------
- public void testFactory() {
- final Integer[] array = new Integer[] { Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(1) };
- final ArrayList<Integer> list = new ArrayList<>(Arrays.asList(array));
- final SetUniqueList<Integer> lset = SetUniqueList.setUniqueList(list);
+ @Override
+ public void testListIteratorSet() {
+ // override to block
+ resetFull();
+ final ListIterator<E> it = getCollection().listIterator();
+ it.next();
+ try {
+ it.set(null);
+ fail();
+ } catch (final UnsupportedOperationException ex) {}
+ }
- assertEquals("Duplicate element was added.", 2, lset.size());
- assertEquals(Integer.valueOf(1), lset.get(0));
- assertEquals(Integer.valueOf(2), lset.get(1));
- assertEquals(Integer.valueOf(1), list.get(0));
- assertEquals(Integer.valueOf(2), list.get(1));
+ @Override
+ @SuppressWarnings("unchecked")
+ public void testListSetByIndex() {
+ // override for set behaviour
+ resetFull();
+ final int size = getCollection().size();
+ getCollection().set(0, (E) new Long(1000));
+ assertEquals(size, getCollection().size());
+
+ getCollection().set(2, (E) new Long(1000));
+ assertEquals(size - 1, getCollection().size());
+ assertEquals(new Long(1000), getCollection().get(1)); // set into 2, but shifted down to 1
}
@SuppressWarnings("unchecked")
- public void testAdd() {
- final SetUniqueList<E> lset = new SetUniqueList<>(new ArrayList<E>(), new HashSet<E>());
+ public void testRetainAll() {
+ final List<E> list = new ArrayList<>(10);
+ final SetUniqueList<E> uniqueList = SetUniqueList.setUniqueList(list);
+ for (int i = 0; i < 10; ++i) {
+ uniqueList.add((E)Integer.valueOf(i));
+ }
- // Duplicate element
- final E obj = (E) Integer.valueOf(1);
- lset.add(obj);
- lset.add(obj);
- assertEquals("Duplicate element was added.", 1, lset.size());
+ final Collection<E> retained = new ArrayList<>(5);
+ for (int i = 0; i < 5; ++i) {
+ retained.add((E)Integer.valueOf(i * 2));
+ }
- // Unique element
- lset.add((E) Integer.valueOf(2));
- assertEquals("Unique element was not added.", 2, lset.size());
+ assertTrue(uniqueList.retainAll(retained));
+ assertEquals(5, uniqueList.size());
+ assertTrue(uniqueList.contains(Integer.valueOf(0)));
+ assertTrue(uniqueList.contains(Integer.valueOf(2)));
+ assertTrue(uniqueList.contains(Integer.valueOf(4)));
+ assertTrue(uniqueList.contains(Integer.valueOf(6)));
+ assertTrue(uniqueList.contains(Integer.valueOf(8)));
}
@SuppressWarnings("unchecked")
- public void testAddAll() {
- final SetUniqueList<E> lset = new SetUniqueList<>(new ArrayList<E>(), new HashSet<E>());
+ public void testRetainAllWithInitialList() {
+ // initialized with empty list
+ final List<E> list = new ArrayList<>(10);
+ for (int i = 0; i < 5; ++i) {
+ list.add((E)Integer.valueOf(i));
+ }
+ final SetUniqueList<E> uniqueList = SetUniqueList.setUniqueList(list);
+ for (int i = 5; i < 10; ++i) {
+ uniqueList.add((E)Integer.valueOf(i));
+ }
- lset.addAll(
- Arrays.asList((E[]) new Integer[] { Integer.valueOf(1), Integer.valueOf(1)}));
+ final Collection<E> retained = new ArrayList<>(5);
+ for (int i = 0; i < 5; ++i) {
+ retained.add((E)Integer.valueOf(i * 2));
+ }
- assertEquals("Duplicate element was added.", 1, lset.size());
+ assertTrue(uniqueList.retainAll(retained));
+ assertEquals(5, uniqueList.size());
+ assertTrue(uniqueList.contains(Integer.valueOf(0)));
+ assertTrue(uniqueList.contains(Integer.valueOf(2)));
+ assertTrue(uniqueList.contains(Integer.valueOf(4)));
+ assertTrue(uniqueList.contains(Integer.valueOf(6)));
+ assertTrue(uniqueList.contains(Integer.valueOf(8)));
}
@SuppressWarnings("unchecked")
@@ -283,58 +416,22 @@ public class SetUniqueListTest<E> extends AbstractListTest<E> {
assertSame(obj1, lset.get(0));
}
- @SuppressWarnings("unchecked")
- public void testListIterator() {
- final SetUniqueList<E> lset = new SetUniqueList<>(new ArrayList<E>(), new HashSet<E>());
+ public void testSetCollections444() {
+ final SetUniqueList<Integer> lset = new SetUniqueList<>(new ArrayList<Integer>(), new HashSet<Integer>());
+
+ // Duplicate element
+ final Integer obj1 = Integer.valueOf(1);
+ final Integer obj2 = Integer.valueOf(2);
- final E obj1 = (E) Integer.valueOf(1);
- final E obj2 = (E) Integer.valueOf(2);
lset.add(obj1);
lset.add(obj2);
+ lset.set(0, obj1);
+ assertEquals(2, lset.size());
+ assertSame(obj1, lset.get(0));
+ assertSame(obj2, lset.get(1));
- // Attempts to add a duplicate object
- for (final ListIterator<E> it = lset.listIterator(); it.hasNext();) {
- it.next();
-
- if (!it.hasNext()) {
- it.add(obj1);
- break;
- }
- }
-
- assertEquals("Duplicate element was added", 2, lset.size());
- }
-
- @SuppressWarnings("unchecked")
- public void testUniqueListReInsert() {
- final List<E> l = SetUniqueList.setUniqueList(new LinkedList<E>());
- l.add((E) new Object());
- l.add((E) new Object());
-
- final E a = l.get(0);
-
- // duplicate is removed
- l.set(0, l.get(1));
- assertEquals(1, l.size());
-
- // old object is added back in
- l.add(1, a);
- assertEquals(2, l.size());
- }
-
- @SuppressWarnings("unchecked")
- public void testUniqueListDoubleInsert() {
- final List<E> l = SetUniqueList.setUniqueList(new LinkedList<E>());
- l.add((E) new Object());
- l.add((E) new Object());
-
- // duplicate is removed
- l.set(0, l.get(1));
- assertEquals(1, l.size());
-
- // duplicate should be removed again
- l.add(1, l.get(0));
- assertEquals(1, l.size());
+ assertTrue(lset.contains(obj1));
+ assertTrue(lset.contains(obj2));
}
@SuppressWarnings("unchecked")
@@ -365,7 +462,6 @@ public class SetUniqueListTest<E> extends AbstractListTest<E> {
assertTrue(s.contains(b));
assertFalse(s.contains(a));
}
-
@SuppressWarnings("unchecked")
public void testSetInBiggerList() {
/*
@@ -438,29 +534,6 @@ public class SetUniqueListTest<E> extends AbstractListTest<E> {
assertTrue(s.contains(c));
}
- public void testCollections304() {
- final List<String> list = new LinkedList<>();
- final SetUniqueList<String> decoratedList = SetUniqueList.setUniqueList(list);
- final String s1 = "Apple";
- final String s2 = "Lemon";
- final String s3 = "Orange";
- final String s4 = "Strawberry";
-
- decoratedList.add(s1);
- decoratedList.add(s2);
- decoratedList.add(s3);
- assertEquals(3, decoratedList.size());
-
- decoratedList.set(1, s4);
- assertEquals(3, decoratedList.size());
-
- decoratedList.add(1, s4);
- assertEquals(3, decoratedList.size());
-
- decoratedList.add(1, s2);
- assertEquals(4, decoratedList.size());
- }
-
public void testSubListIsUnmodifiable() {
resetFull();
final List<E> subList = getCollection().subList(1, 3);
@@ -471,130 +544,57 @@ public class SetUniqueListTest<E> extends AbstractListTest<E> {
// expected
}
}
- @SuppressWarnings("unchecked")
- public void testCollections307() {
- List<E> list = new ArrayList<>();
- List<E> uniqueList = SetUniqueList.setUniqueList(list);
-
- final String hello = "Hello";
- final String world = "World";
- uniqueList.add((E) hello);
- uniqueList.add((E) world);
-
- List<E> subList = list.subList(0, 0);
- List<E> subUniqueList = uniqueList.subList(0, 0);
-
- assertFalse(subList.contains(world)); // passes
- assertFalse(subUniqueList.contains(world)); // fails
-
- List<E> worldList = new ArrayList<>();
- worldList.add((E) world);
- assertFalse(subList.contains("World")); // passes
- assertFalse(subUniqueList.contains("World")); // fails
-
- // repeat the test with a different class than HashSet;
- // which means subclassing SetUniqueList below
- list = new ArrayList<>();
- uniqueList = new SetUniqueList307(list, new java.util.TreeSet<E>());
-
- uniqueList.add((E) hello);
- uniqueList.add((E) world);
-
- subList = list.subList(0, 0);
- subUniqueList = uniqueList.subList(0, 0);
-
- assertFalse(subList.contains(world)); // passes
- assertFalse(subUniqueList.contains(world)); // fails
-
- worldList = new ArrayList<>();
- worldList.add((E) world);
- assertFalse(subList.contains("World")); // passes
- assertFalse(subUniqueList.contains("World")); // fails
- }
@SuppressWarnings("unchecked")
- public void testRetainAll() {
- final List<E> list = new ArrayList<>(10);
- final SetUniqueList<E> uniqueList = SetUniqueList.setUniqueList(list);
- for (int i = 0; i < 10; ++i) {
- uniqueList.add((E)Integer.valueOf(i));
- }
+ public void testUniqueListDoubleInsert() {
+ final List<E> l = SetUniqueList.setUniqueList(new LinkedList<E>());
+ l.add((E) new Object());
+ l.add((E) new Object());
- final Collection<E> retained = new ArrayList<>(5);
- for (int i = 0; i < 5; ++i) {
- retained.add((E)Integer.valueOf(i * 2));
- }
+ // duplicate is removed
+ l.set(0, l.get(1));
+ assertEquals(1, l.size());
- assertTrue(uniqueList.retainAll(retained));
- assertEquals(5, uniqueList.size());
- assertTrue(uniqueList.contains(Integer.valueOf(0)));
- assertTrue(uniqueList.contains(Integer.valueOf(2)));
- assertTrue(uniqueList.contains(Integer.valueOf(4)));
- assertTrue(uniqueList.contains(Integer.valueOf(6)));
- assertTrue(uniqueList.contains(Integer.valueOf(8)));
+ // duplicate should be removed again
+ l.add(1, l.get(0));
+ assertEquals(1, l.size());
}
@SuppressWarnings("unchecked")
- public void testRetainAllWithInitialList() {
- // initialized with empty list
- final List<E> list = new ArrayList<>(10);
- for (int i = 0; i < 5; ++i) {
- list.add((E)Integer.valueOf(i));
- }
- final SetUniqueList<E> uniqueList = SetUniqueList.setUniqueList(list);
- for (int i = 5; i < 10; ++i) {
- uniqueList.add((E)Integer.valueOf(i));
- }
-
- final Collection<E> retained = new ArrayList<>(5);
- for (int i = 0; i < 5; ++i) {
- retained.add((E)Integer.valueOf(i * 2));
- }
+ public void testUniqueListReInsert() {
+ final List<E> l = SetUniqueList.setUniqueList(new LinkedList<E>());
+ l.add((E) new Object());
+ l.add((E) new Object());
- assertTrue(uniqueList.retainAll(retained));
- assertEquals(5, uniqueList.size());
- assertTrue(uniqueList.contains(Integer.valueOf(0)));
- assertTrue(uniqueList.contains(Integer.valueOf(2)));
- assertTrue(uniqueList.contains(Integer.valueOf(4)));
- assertTrue(uniqueList.contains(Integer.valueOf(6)));
- assertTrue(uniqueList.contains(Integer.valueOf(8)));
- }
+ final E a = l.get(0);
- public void testSetCollections444() {
- final SetUniqueList<Integer> lset = new SetUniqueList<>(new ArrayList<Integer>(), new HashSet<Integer>());
+ // duplicate is removed
+ l.set(0, l.get(1));
+ assertEquals(1, l.size());
- // Duplicate element
- final Integer obj1 = Integer.valueOf(1);
- final Integer obj2 = Integer.valueOf(2);
+ // old object is added back in
+ l.add(1, a);
+ assertEquals(2, l.size());
+ }
- lset.add(obj1);
- lset.add(obj2);
- lset.set(0, obj1);
- assertEquals(2, lset.size());
- assertSame(obj1, lset.get(0));
- assertSame(obj2, lset.get(1));
+ @Override
+ @SuppressWarnings("unchecked")
+ public void verify() {
+ super.verify();
- assertTrue(lset.contains(obj1));
- assertTrue(lset.contains(obj2));
- }
+ if (extraVerify) {
+ final int size = getCollection().size();
+ getCollection().add((E) new Long(1000));
+ assertEquals(size + 1, getCollection().size());
- class SetUniqueList307 extends SetUniqueList<E> {
- /**
- * Generated serial version ID.
- */
- private static final long serialVersionUID = 1415013031022962158L;
+ getCollection().add((E) new Long(1000));
+ assertEquals(size + 1, getCollection().size());
+ assertEquals(new Long(1000), getCollection().get(size));
- public SetUniqueList307(final List<E> list, final Set<E> set) {
- super(list, set);
+ getCollection().remove(size);
}
}
- //-----------------------------------------------------------------------
- @Override
- public String getCompatibilityVersion() {
- return "4";
- }
-
// public void testCreate() throws Exception {
// resetEmpty();
// writeExternalFormToDisk((java.io.Serializable) getCollection(), "src/test/resources/data/test/SetUniqueList.emptyCollection.version4.obj");
[2/2] commons-collections git commit: [COLLECTIONS-701]
StackOverflowError in SetUniqueList.add() when it receives itself. Closes
#57.
Posted by gg...@apache.org.
[COLLECTIONS-701] StackOverflowError in SetUniqueList.add() when it
receives itself. Closes #57.
Project: http://git-wip-us.apache.org/repos/asf/commons-collections/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-collections/commit/1979a6e3
Tree: http://git-wip-us.apache.org/repos/asf/commons-collections/tree/1979a6e3
Diff: http://git-wip-us.apache.org/repos/asf/commons-collections/diff/1979a6e3
Branch: refs/heads/master
Commit: 1979a6e31067a18c9ede59ad4518f738512eba82
Parents: dc828f8
Author: Don Jeba <do...@yahoo.com>
Authored: Fri Nov 23 00:32:09 2018 -0700
Committer: Gary Gregory <ga...@gmail.com>
Committed: Fri Nov 23 00:32:09 2018 -0700
----------------------------------------------------------------------
src/changes/changes.xml | 3 +++
.../collections4/list/SetUniqueList.java | 2 +-
.../collections4/list/Collections701Test.java | 1 -
.../collections4/list/SetUniqueListTest.java | 27 +++++++++++++++++++-
4 files changed, 30 insertions(+), 3 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/1979a6e3/src/changes/changes.xml
----------------------------------------------------------------------
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index 1d5fb6b..2cc7a7e 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -36,6 +36,9 @@
<action issue="COLLECTIONS-696" dev="ggregory" type="add" due-to="Maxim Solodovnik">
AbstractReferenceMap made easier for subclassing; PR #51.
</action>
+ <action issue="COLLECTIONS-701" dev="ggregory" type="fix" due-to="Don Jeba">
+ StackOverflowError in SetUniqueList.add() when it receives itself.
+ </action>
</release>
<release version="4.2" date="2018-07-11" description="Update from Java 6 to Java 7, bug fixes, and small changes.">
<action issue="COLLECTIONS-681" dev="kinow" type="add" due-to="Stephan Fuhrmann">
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/1979a6e3/src/main/java/org/apache/commons/collections4/list/SetUniqueList.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/collections4/list/SetUniqueList.java b/src/main/java/org/apache/commons/collections4/list/SetUniqueList.java
index 3227e43..b00b2d2 100644
--- a/src/main/java/org/apache/commons/collections4/list/SetUniqueList.java
+++ b/src/main/java/org/apache/commons/collections4/list/SetUniqueList.java
@@ -149,8 +149,8 @@ public class SetUniqueList<E> extends AbstractSerializableListDecorator<E> {
public void add(final int index, final E object) {
// adds element if it is not contained already
if (set.contains(object) == false) {
- super.add(index, object);
set.add(object);
+ super.add(index, object);
}
}
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/1979a6e3/src/test/java/org/apache/commons/collections4/list/Collections701Test.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/collections4/list/Collections701Test.java b/src/test/java/org/apache/commons/collections4/list/Collections701Test.java
index 118369c..82bfd26 100644
--- a/src/test/java/org/apache/commons/collections4/list/Collections701Test.java
+++ b/src/test/java/org/apache/commons/collections4/list/Collections701Test.java
@@ -47,7 +47,6 @@ public class Collections701Test {
}
@Test
- @Ignore
public void testSetUniqueList() {
final List<Object> source = new ArrayList<>();
final List<Object> list = SetUniqueList.setUniqueList(source);
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/1979a6e3/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java b/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java
index 24d2209..e8b6c14 100644
--- a/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java
@@ -139,6 +139,7 @@ public class SetUniqueListTest<E> extends AbstractListTest<E> {
assertEquals("Size should increase after addAll",
size + elements.length, getCollection().size());
}
+
@Override
public void testCollectionIteratorRemove() {
try {
@@ -148,7 +149,6 @@ public class SetUniqueListTest<E> extends AbstractListTest<E> {
extraVerify = true;
}
}
-
public void testCollections304() {
final List<String> list = new LinkedList<>();
final SetUniqueList<String> decoratedList = SetUniqueList.setUniqueList(list);
@@ -213,6 +213,31 @@ public class SetUniqueListTest<E> extends AbstractListTest<E> {
assertFalse(subUniqueList.contains("World")); // fails
}
+ public void testCollections701() {
+ final SetUniqueList<Object> uniqueList = new SetUniqueList<>(new ArrayList<>(), new HashSet<>());
+ final Integer obj1 = Integer.valueOf(1);
+ final Integer obj2 = Integer.valueOf(2);
+ uniqueList.add(obj1);
+ uniqueList.add(obj2);
+ assertEquals(2, uniqueList.size());
+ uniqueList.add(uniqueList);
+ assertEquals(3, uniqueList.size());
+ final List<Object> list = new LinkedList<>();
+ final SetUniqueList<Object> decoratedList = SetUniqueList.setUniqueList(list);
+ final String s1 = "Apple";
+ final String s2 = "Lemon";
+ final String s3 = "Orange";
+ final String s4 = "Strawberry";
+ decoratedList.add(s1);
+ decoratedList.add(s2);
+ decoratedList.add(s3);
+ assertEquals(3, decoratedList.size());
+ decoratedList.set(1, s4);
+ assertEquals(3, decoratedList.size());
+ decoratedList.add(decoratedList);
+ assertEquals(4, decoratedList.size());
+ }
+
//-----------------------------------------------------------------------
public void testFactory() {
final Integer[] array = new Integer[] { Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(1) };