Apache
/
commons-collections
mirror of https://github.com/apache/commons-collections.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Change all calls from assert() to assertTrue() -- introduced in JUnit 3.7 

-- to avoid future conflicts with the JDK standard assertion capability.


git-svn-id: https://svn.apache.org/repos/asf/jakarta/commons/proper/collections/trunk@130488 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Craig R. McClanahan 2001-07-14 23:33:27 +00:00
parent 4a2e49fd8d
commit 90e83728ac
10 changed files with 378 additions and 378 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/test/org/apache/commons/collections/TestArrayIterator.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestArrayIterator.java,v 1.2 2001/06/05 07:20:10 jstrachan Exp $
* $Revision: 1.2 $
* $Date: 2001/06/05 07:20:10 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestArrayIterator.java,v 1.3 2001/07/14 23:33:26 craigmcc Exp $
* $Revision: 1.3 $
* $Date: 2001/07/14 23:33:26 $
*
* ====================================================================
*
@ -72,7 +72,7 @@ import java.util.NoSuchElementException;
*
* @author James Strachan
* @author Mauricio S. Moura
* @version $Id: TestArrayIterator.java,v 1.2 2001/06/05 07:20:10 jstrachan Exp $
* @version $Id: TestArrayIterator.java,v 1.3 2001/07/14 23:33:26 craigmcc Exp $
*/
public class TestArrayIterator extends TestObject {
@ -104,12 +104,12 @@ public class TestArrayIterator extends TestObject {
assertEquals( "Iteration value is correct", testValue, iterValue );
}
assert("Iterator should now be empty", ! iter.hasNext() );
assertTrue("Iterator should now be empty", ! iter.hasNext() );
try {
Object testValue = iter.next();
} catch (Exception e) {
assert("NoSuchElementException must be thrown",
assertTrue("NoSuchElementException must be thrown",
e.getClass().equals((new NoSuchElementException()).getClass()));
}
}

10
src/test/org/apache/commons/collections/TestArrayList.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestArrayList.java,v 1.1 2001/04/21 12:22:30 craigmcc Exp $
* $Revision: 1.1 $
* $Date: 2001/04/21 12:22:30 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestArrayList.java,v 1.2 2001/07/14 23:33:26 craigmcc Exp $
* $Revision: 1.2 $
* $Date: 2001/07/14 23:33:26 $
*
* ====================================================================
*
@ -69,7 +69,7 @@ import java.util.List;
/**
* @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
* @version $Id: TestArrayList.java,v 1.1 2001/04/21 12:22:30 craigmcc Exp $
* @version $Id: TestArrayList.java,v 1.2 2001/07/14 23:33:26 craigmcc Exp $
*/
public class TestArrayList extends TestList
{
@ -104,7 +104,7 @@ public class TestArrayList extends TestList
public void testNewArrayList()
{
assert("New list is empty", list.isEmpty());
assertTrue("New list is empty", list.isEmpty());
assertEquals("New list has size zero", list.size(), 0);
try

12
src/test/org/apache/commons/collections/TestArrayStack.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestArrayStack.java,v 1.4 2001/04/21 12:22:30 craigmcc Exp $
* $Revision: 1.4 $
* $Date: 2001/04/21 12:22:30 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestArrayStack.java,v 1.5 2001/07/14 23:33:26 craigmcc Exp $
* $Revision: 1.5 $
* $Date: 2001/07/14 23:33:26 $
*
* ====================================================================
*
@ -66,7 +66,7 @@ import java.util.*;
/**
* @author Craig McClanahan
* @version $Id: TestArrayStack.java,v 1.4 2001/04/21 12:22:30 craigmcc Exp $
* @version $Id: TestArrayStack.java,v 1.5 2001/07/14 23:33:26 craigmcc Exp $
*/
public class TestArrayStack extends TestArrayList {
@ -97,7 +97,7 @@ public class TestArrayStack extends TestArrayList {
public void testNewStack() {
assert("New stack is empty", stack.empty());
assertTrue("New stack is empty", stack.empty());
assertEquals("New stack has size zero", stack.size(), 0);
try {
@ -120,7 +120,7 @@ public class TestArrayStack extends TestArrayList {
public void testPushPeekPop() {
stack.push("First Item");
assert("Stack is not empty", !stack.empty());
assertTrue("Stack is not empty", !stack.empty());
assertEquals("Stack size is one", stack.size(), 1);
assertEquals("Top item is 'First Item'",
(String) stack.peek(), "First Item");

106
src/test/org/apache/commons/collections/TestCollection.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestCollection.java,v 1.4 2001/04/24 23:48:04 rwaldhoff Exp $
* $Revision: 1.4 $
* $Date: 2001/04/24 23:48:04 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestCollection.java,v 1.5 2001/07/14 23:33:27 craigmcc Exp $
* $Revision: 1.5 $
* $Date: 2001/07/14 23:33:27 $
*
* ====================================================================
*
@ -78,7 +78,7 @@ import java.util.NoSuchElementException;
* test case (method) your {@link Collection} fails.
*
* @author Rodney Waldhoff
* @version $Id: TestCollection.java,v 1.4 2001/04/24 23:48:04 rwaldhoff Exp $
* @version $Id: TestCollection.java,v 1.5 2001/07/14 23:33:27 craigmcc Exp $
*/
public abstract class TestCollection extends TestObject {
public TestCollection(String testName) {
@ -138,13 +138,13 @@ public abstract class TestCollection extends TestObject {
}
if(cleared) {
assert("After Collection.clear(), Collection.isEmpty() should be true.",c.isEmpty());
assertTrue("After Collection.clear(), Collection.isEmpty() should be true.",c.isEmpty());
}
boolean added = tryToAdd(c,"element1");
if(added) {
assert("After element is added, Collection.isEmpty() should be false.",!c.isEmpty());
assertTrue("After element is added, Collection.isEmpty() should be false.",!c.isEmpty());
boolean cleared2 = false;
try {
c.clear();
@ -156,41 +156,41 @@ public abstract class TestCollection extends TestObject {
fail("Collection.clear should only throw UnsupportedOperationException. Found " + t.toString());
}
if(cleared2) {
assert("After Collection.clear(), Collection.isEmpty() should be true.",c.isEmpty());
assertTrue("After Collection.clear(), Collection.isEmpty() should be true.",c.isEmpty());
}
}
}
public void testCollectionContains() {
Collection c = makeCollection();
assert("Empty Collection shouldn't contain element.",!c.contains("element1"));
assertTrue("Empty Collection shouldn't contain element.",!c.contains("element1"));
boolean added1 = tryToAdd(c,"element1");
assert("[1] If an element was added, it should be contained, if it wasn't, it shouldn't.",added1 == c.contains("element1"));
assertTrue("[1] If an element was added, it should be contained, if it wasn't, it shouldn't.",added1 == c.contains("element1"));
assert("Shouldn't be contained.",!c.contains("element2"));
assertTrue("Shouldn't be contained.",!c.contains("element2"));
boolean added2 = tryToAdd(c,"element2");
assert("[2] If an element was added, it should be contained, if it wasn't, it shouldn't.",added1 == c.contains("element1"));
assert("[3] If an element was added, it should be contained, if it wasn't, it shouldn't.",added2 == c.contains("element2"));
assertTrue("[2] If an element was added, it should be contained, if it wasn't, it shouldn't.",added1 == c.contains("element1"));
assertTrue("[3] If an element was added, it should be contained, if it wasn't, it shouldn't.",added2 == c.contains("element2"));
}
public void testCollectionContainsAll() {
Collection c = makeCollection();
Collection col = new ArrayList();
assert("Every Collection should contain all elements of an empty Collection.",c.containsAll(col));
assertTrue("Every Collection should contain all elements of an empty Collection.",c.containsAll(col));
col.add("element1");
assert("Empty Collection shouldn't contain all elements of a non-empty Collection.",!c.containsAll(col));
assertTrue("Empty Collection shouldn't contain all elements of a non-empty Collection.",!c.containsAll(col));
boolean added1 = tryToAdd(c,"element1");
if(added1) {
assert("[1] Should contain all.",c.containsAll(col));
assertTrue("[1] Should contain all.",c.containsAll(col));
}
col.add("element2");
assert("Shouldn't contain all.",!c.containsAll(col));
assertTrue("Shouldn't contain all.",!c.containsAll(col));
boolean added2 = tryToAdd(c,"element2");
if(added1 && added2) {
assert("[2] Should contain all.",c.containsAll(col));
assertTrue("[2] Should contain all.",c.containsAll(col));
}
}
@ -211,8 +211,8 @@ public abstract class TestCollection extends TestObject {
boolean added1_1 = tryToAdd(c1,"element1");
if(added1_1) {
assert("Empty Collection not equal to non-empty Collection.",!c2.equals(c1));
assert("Non-empty Collection not equal to empty Collection.",!c1.equals(c2));
assertTrue("Empty Collection not equal to non-empty Collection.",!c2.equals(c1));
assertTrue("Non-empty Collection not equal to empty Collection.",!c1.equals(c2));
}
boolean added1_2 = tryToAdd(c2,"element1");
@ -221,7 +221,7 @@ public abstract class TestCollection extends TestObject {
boolean added2_1 = tryToAdd(c1,"element2");
boolean added3_2 = tryToAdd(c2,"element3");
if(added2_1 || added3_2) {
assert("Should not be equal.",!c1.equals(c2));
assertTrue("Should not be equal.",!c1.equals(c2));
}
}
@ -250,17 +250,17 @@ public abstract class TestCollection extends TestObject {
public void testCollectionIsEmpty() {
Collection c = makeCollection();
assert("New Collection should be empty.",c.isEmpty());
assertTrue("New Collection should be empty.",c.isEmpty());
boolean added = tryToAdd(c,"element1");
if(added) {
assert("If an element was added, the Collection.isEmpty() should return false.",!c.isEmpty());
assertTrue("If an element was added, the Collection.isEmpty() should return false.",!c.isEmpty());
}
}
public void testCollectionIterator() {
Collection c = makeCollection();
Iterator it1 = c.iterator();
assert("Iterator for empty Collection shouldn't have next.",!it1.hasNext());
assertTrue("Iterator for empty Collection shouldn't have next.",!it1.hasNext());
try {
it1.next();
fail("Iterator at end of Collection should throw NoSuchElementException when next is called.");
@ -274,9 +274,9 @@ public abstract class TestCollection extends TestObject {
boolean added = tryToAdd(c,"element1");
if(added) {
Iterator it2 = c.iterator();
assert("Iterator for non-empty Collection should have next.",it2.hasNext());
assertTrue("Iterator for non-empty Collection should have next.",it2.hasNext());
assertEquals("element1",it2.next());
assert("Iterator at end of Collection shouldn't have next.",!it2.hasNext());
assertTrue("Iterator at end of Collection shouldn't have next.",!it2.hasNext());
try {
it2.next();
fail("Iterator at end of Collection should throw NoSuchElementException when next is called.");
@ -295,7 +295,7 @@ public abstract class TestCollection extends TestObject {
boolean added = tryToAdd(c,"element1");
try {
assert("Shouldn't be able to remove an element that wasn't added.",!c.remove("element2"));
assertTrue("Shouldn't be able to remove an element that wasn't added.",!c.remove("element2"));
} catch(UnsupportedOperationException e) {
} catch(Throwable t) {
t.printStackTrace();
@ -303,8 +303,8 @@ public abstract class TestCollection extends TestObject {
}
try {
assert("If added, should be removed by call to remove.",added == c.remove("element1"));
assert("If removed, shouldn't be contained.",!c.contains("element1"));
assertTrue("If added, should be removed by call to remove.",added == c.remove("element1"));
assertTrue("If removed, shouldn't be contained.",!c.contains("element1"));
} catch(UnsupportedOperationException e) {
} catch(Throwable t) {
t.printStackTrace();
@ -315,7 +315,7 @@ public abstract class TestCollection extends TestObject {
// optional operation
public void testCollectionRemoveAll() {
Collection c = makeCollection();
assert("Initial Collection is empty.",c.isEmpty());
assertTrue("Initial Collection is empty.",c.isEmpty());
try {
c.removeAll(c);
} catch(UnsupportedOperationException e) {
@ -324,14 +324,14 @@ public abstract class TestCollection extends TestObject {
t.printStackTrace();
fail("Collection.removeAll should only throw UnsupportedOperationException. Found " + t.toString());
}
assert("Collection is still empty.",c.isEmpty());
assertTrue("Collection is still empty.",c.isEmpty());
boolean added = tryToAdd(c,"element1");
if(added) {
assert("Collection is not empty.",!c.isEmpty());
assertTrue("Collection is not empty.",!c.isEmpty());
try {
c.removeAll(c);
assert("Collection is empty.",c.isEmpty());
assertTrue("Collection is empty.",c.isEmpty());
} catch(UnsupportedOperationException e) {
// expected
} catch(Throwable t) {
@ -366,15 +366,15 @@ public abstract class TestCollection extends TestObject {
}
col.add("element4");
if(added) {
assert("Collection is not empty.",!c.isEmpty());
assertTrue("Collection is not empty.",!c.isEmpty());
try {
assert("Should be changed",c.removeAll(col));
assert("Collection is not empty.",!c.isEmpty());
assert("Collection should contain element",c.contains("element0"));
assert("Collection shouldn't contain removed element",!c.contains("element1"));
assert("Collection shouldn't contain removed element",!c.contains("element2"));
assert("Collection shouldn't contain removed element",!c.contains("element3"));
assert("Collection shouldn't contain removed element",!c.contains("element4"));
assertTrue("Should be changed",c.removeAll(col));
assertTrue("Collection is not empty.",!c.isEmpty());
assertTrue("Collection should contain element",c.contains("element0"));
assertTrue("Collection shouldn't contain removed element",!c.contains("element1"));
assertTrue("Collection shouldn't contain removed element",!c.contains("element2"));
assertTrue("Collection shouldn't contain removed element",!c.contains("element3"));
assertTrue("Collection shouldn't contain removed element",!c.contains("element4"));
} catch(UnsupportedOperationException e) {
// expected
} catch(Throwable t) {
@ -389,8 +389,8 @@ public abstract class TestCollection extends TestObject {
Collection a = makeCollection();
Collection b = makeCollection();
try {
assert(!a.retainAll(b));
assert(!a.retainAll(a));
assertTrue(!a.retainAll(b));
assertTrue(!a.retainAll(a));
} catch(UnsupportedOperationException e) {
// expected
} catch(Throwable t) {
@ -400,9 +400,9 @@ public abstract class TestCollection extends TestObject {
boolean added_b = b.add("element1");
try {
assert(!a.retainAll(b));
assert(added_b == b.retainAll(a));
assert(b.isEmpty());
assertTrue(!a.retainAll(b));
assertTrue(added_b == b.retainAll(a));
assertTrue(b.isEmpty());
} catch(UnsupportedOperationException e) {
// expected
} catch(Throwable t) {
@ -415,15 +415,15 @@ public abstract class TestCollection extends TestObject {
boolean added_a1 = a.add("element1");
if(added_b1 && added_b2 && added_a1) {
try {
assert(!b.retainAll(b));
assert(b.contains("element1"));
assert(b.contains("element2"));
assertTrue(!b.retainAll(b));
assertTrue(b.contains("element1"));
assertTrue(b.contains("element2"));
assert(!a.retainAll(b));
assertTrue(!a.retainAll(b));
assert(b.retainAll(a));
assert(b.contains("element1"));
assert(!b.contains("element2"));
assertTrue(b.retainAll(a));
assertTrue(b.contains("element1"));
assertTrue(!b.contains("element2"));
} catch(UnsupportedOperationException e) {
// expected
} catch(Throwable t) {
@ -471,7 +471,7 @@ public abstract class TestCollection extends TestObject {
String[] fits = new String[1];
String[] small = new String[0];
assertSame(fits,c.toArray(fits));
assert(small != c.toArray(small));
assertTrue(small != c.toArray(small));
}
}

132
src/test/org/apache/commons/collections/TestCollectionUtils.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestCollectionUtils.java,v 1.1 2001/04/24 18:48:38 rwaldhoff Exp $
* $Revision: 1.1 $
* $Date: 2001/04/24 18:48:38 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestCollectionUtils.java,v 1.2 2001/07/14 23:33:27 craigmcc Exp $
* $Revision: 1.2 $
* $Date: 2001/07/14 23:33:27 $
*
* ====================================================================
*
@ -66,7 +66,7 @@ import java.util.*;
/**
* @author Rodney Waldhoff
* @version $Id: TestCollectionUtils.java,v 1.1 2001/04/24 18:48:38 rwaldhoff Exp $
* @version $Id: TestCollectionUtils.java,v 1.2 2001/07/14 23:33:27 craigmcc Exp $
*/
public class TestCollectionUtils extends TestCase {
public TestCollectionUtils(String testName) {
@ -117,10 +117,10 @@ public class TestCollectionUtils extends TestCase {
assertEquals(new Integer(2),freq.get("b"));
assertEquals(new Integer(3),freq.get("c"));
assertEquals(new Integer(4),freq.get("d"));
assert(null == freq.get("e"));
assertTrue(null == freq.get("e"));
freq = CollectionUtils.getCardinalityMap(_b);
assert(null == freq.get("a"));
assertTrue(null == freq.get("a"));
assertEquals(new Integer(4),freq.get("b"));
assertEquals(new Integer(3),freq.get("c"));
assertEquals(new Integer(2),freq.get("d"));
@ -162,19 +162,19 @@ public class TestCollectionUtils extends TestCase {
public void testIntersection() {
Collection col = CollectionUtils.intersection(_a,_b);
Map freq = CollectionUtils.getCardinalityMap(col);
assert(null == freq.get("a"));
assertTrue(null == freq.get("a"));
assertEquals(new Integer(2),freq.get("b"));
assertEquals(new Integer(3),freq.get("c"));
assertEquals(new Integer(2),freq.get("d"));
assert(null == freq.get("e"));
assertTrue(null == freq.get("e"));
Collection col2 = CollectionUtils.intersection(_b,_a);
Map freq2 = CollectionUtils.getCardinalityMap(col2);
assert(null == freq2.get("a"));
assertTrue(null == freq2.get("a"));
assertEquals(new Integer(2),freq2.get("b"));
assertEquals(new Integer(3),freq2.get("c"));
assertEquals(new Integer(2),freq2.get("d"));
assert(null == freq2.get("e"));
assertTrue(null == freq2.get("e"));
}
public void testDisjunction() {
@ -182,7 +182,7 @@ public class TestCollectionUtils extends TestCase {
Map freq = CollectionUtils.getCardinalityMap(col);
assertEquals(new Integer(1),freq.get("a"));
assertEquals(new Integer(2),freq.get("b"));
assert(null == freq.get("c"));
assertTrue(null == freq.get("c"));
assertEquals(new Integer(2),freq.get("d"));
assertEquals(new Integer(1),freq.get("e"));
@ -190,7 +190,7 @@ public class TestCollectionUtils extends TestCase {
Map freq2 = CollectionUtils.getCardinalityMap(col2);
assertEquals(new Integer(1),freq2.get("a"));
assertEquals(new Integer(2),freq2.get("b"));
assert(null == freq2.get("c"));
assertTrue(null == freq2.get("c"));
assertEquals(new Integer(2),freq2.get("d"));
assertEquals(new Integer(1),freq2.get("e"));
}
@ -199,115 +199,115 @@ public class TestCollectionUtils extends TestCase {
Collection dis = CollectionUtils.disjunction(_a,_b);
Collection un = CollectionUtils.union(_a,_b);
Collection inter = CollectionUtils.intersection(_a,_b);
assert(CollectionUtils.isEqualCollection(dis,CollectionUtils.subtract(un,inter)));
assertTrue(CollectionUtils.isEqualCollection(dis,CollectionUtils.subtract(un,inter)));
}
public void testDisjunctionAsSymmetricDifference() {
Collection dis = CollectionUtils.disjunction(_a,_b);
Collection amb = CollectionUtils.subtract(_a,_b);
Collection bma = CollectionUtils.subtract(_b,_a);
assert(CollectionUtils.isEqualCollection(dis,CollectionUtils.union(amb,bma)));
assertTrue(CollectionUtils.isEqualCollection(dis,CollectionUtils.union(amb,bma)));
}
public void testSubtract() {
Collection col = CollectionUtils.subtract(_a,_b);
Map freq = CollectionUtils.getCardinalityMap(col);
assertEquals(new Integer(1),freq.get("a"));
assert(null == freq.get("b"));
assert(null == freq.get("c"));
assertTrue(null == freq.get("b"));
assertTrue(null == freq.get("c"));
assertEquals(new Integer(2),freq.get("d"));
assert(null == freq.get("e"));
assertTrue(null == freq.get("e"));
Collection col2 = CollectionUtils.subtract(_b,_a);
Map freq2 = CollectionUtils.getCardinalityMap(col2);
assertEquals(new Integer(1),freq2.get("e"));
assert(null == freq2.get("d"));
assert(null == freq2.get("c"));
assertTrue(null == freq2.get("d"));
assertTrue(null == freq2.get("c"));
assertEquals(new Integer(2),freq2.get("b"));
assert(null == freq2.get("a"));
assertTrue(null == freq2.get("a"));
}
public void testIsSubCollectionOfSelf() {
assert(CollectionUtils.isSubCollection(_a,_a));
assert(CollectionUtils.isSubCollection(_b,_b));
assertTrue(CollectionUtils.isSubCollection(_a,_a));
assertTrue(CollectionUtils.isSubCollection(_b,_b));
}
public void testIsSubCollection() {
assert(!CollectionUtils.isSubCollection(_a,_b));
assert(!CollectionUtils.isSubCollection(_b,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,_b));
assertTrue(!CollectionUtils.isSubCollection(_b,_a));
}
public void testIsSubCollection2() {
Collection c = new ArrayList();
assert(CollectionUtils.isSubCollection(c,_a));
assert(!CollectionUtils.isSubCollection(_a,c));
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("a");
assert(CollectionUtils.isSubCollection(c,_a));
assert(!CollectionUtils.isSubCollection(_a,c));
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("b");
assert(CollectionUtils.isSubCollection(c,_a));
assert(!CollectionUtils.isSubCollection(_a,c));
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("b");
assert(CollectionUtils.isSubCollection(c,_a));
assert(!CollectionUtils.isSubCollection(_a,c));
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("c");
assert(CollectionUtils.isSubCollection(c,_a));
assert(!CollectionUtils.isSubCollection(_a,c));
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("c");
assert(CollectionUtils.isSubCollection(c,_a));
assert(!CollectionUtils.isSubCollection(_a,c));
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("c");
assert(CollectionUtils.isSubCollection(c,_a));
assert(!CollectionUtils.isSubCollection(_a,c));
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("d");
assert(CollectionUtils.isSubCollection(c,_a));
assert(!CollectionUtils.isSubCollection(_a,c));
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("d");
assert(CollectionUtils.isSubCollection(c,_a));
assert(!CollectionUtils.isSubCollection(_a,c));
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("d");
assert(CollectionUtils.isSubCollection(c,_a));
assert(!CollectionUtils.isSubCollection(_a,c));
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(!CollectionUtils.isSubCollection(_a,c));
c.add("d");
assert(CollectionUtils.isSubCollection(c,_a));
assert(CollectionUtils.isSubCollection(_a,c));
assertTrue(CollectionUtils.isSubCollection(c,_a));
assertTrue(CollectionUtils.isSubCollection(_a,c));
c.add("e");
assert(!CollectionUtils.isSubCollection(c,_a));
assert(CollectionUtils.isSubCollection(_a,c));
assertTrue(!CollectionUtils.isSubCollection(c,_a));
assertTrue(CollectionUtils.isSubCollection(_a,c));
}
public void testIsEqualCollectionToSelf() {
assert(CollectionUtils.isEqualCollection(_a,_a));
assert(CollectionUtils.isEqualCollection(_b,_b));
assertTrue(CollectionUtils.isEqualCollection(_a,_a));
assertTrue(CollectionUtils.isEqualCollection(_b,_b));
}
public void testIsEqualCollection() {
assert(!CollectionUtils.isEqualCollection(_a,_b));
assert(!CollectionUtils.isEqualCollection(_b,_a));
assertTrue(!CollectionUtils.isEqualCollection(_a,_b));
assertTrue(!CollectionUtils.isEqualCollection(_b,_a));
}
public void testIsEqualCollection2() {
Collection a = new ArrayList();
Collection b = new ArrayList();
assert(CollectionUtils.isEqualCollection(a,b));
assert(CollectionUtils.isEqualCollection(b,a));
assertTrue(CollectionUtils.isEqualCollection(a,b));
assertTrue(CollectionUtils.isEqualCollection(b,a));
a.add("1");
assert(!CollectionUtils.isEqualCollection(a,b));
assert(!CollectionUtils.isEqualCollection(b,a));
assertTrue(!CollectionUtils.isEqualCollection(a,b));
assertTrue(!CollectionUtils.isEqualCollection(b,a));
b.add("1");
assert(CollectionUtils.isEqualCollection(a,b));
assert(CollectionUtils.isEqualCollection(b,a));
assertTrue(CollectionUtils.isEqualCollection(a,b));
assertTrue(CollectionUtils.isEqualCollection(b,a));
a.add("2");
assert(!CollectionUtils.isEqualCollection(a,b));
assert(!CollectionUtils.isEqualCollection(b,a));
assertTrue(!CollectionUtils.isEqualCollection(a,b));
assertTrue(!CollectionUtils.isEqualCollection(b,a));
b.add("2");
assert(CollectionUtils.isEqualCollection(a,b));
assert(CollectionUtils.isEqualCollection(b,a));
assertTrue(CollectionUtils.isEqualCollection(a,b));
assertTrue(CollectionUtils.isEqualCollection(b,a));
a.add("1");
assert(!CollectionUtils.isEqualCollection(a,b));
assert(!CollectionUtils.isEqualCollection(b,a));
assertTrue(!CollectionUtils.isEqualCollection(a,b));
assertTrue(!CollectionUtils.isEqualCollection(b,a));
b.add("1");
assert(CollectionUtils.isEqualCollection(a,b));
assert(CollectionUtils.isEqualCollection(b,a));
assertTrue(CollectionUtils.isEqualCollection(a,b));
assertTrue(CollectionUtils.isEqualCollection(b,a));
}
}

352
src/test/org/apache/commons/collections/TestCursorableLinkedList.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestCursorableLinkedList.java,v 1.2 2001/04/20 16:54:07 rwaldhoff Exp $
* $Revision: 1.2 $
* $Date: 2001/04/20 16:54:07 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestCursorableLinkedList.java,v 1.3 2001/07/14 23:33:27 craigmcc Exp $
* $Revision: 1.3 $
* $Date: 2001/07/14 23:33:27 $
*
* ====================================================================
*
@ -66,7 +66,7 @@ import java.util.*;
/**
* @author Rodney Waldhoff
* @version $Id: TestCursorableLinkedList.java,v 1.2 2001/04/20 16:54:07 rwaldhoff Exp $
* @version $Id: TestCursorableLinkedList.java,v 1.3 2001/07/14 23:33:27 craigmcc Exp $
*/
public class TestCursorableLinkedList extends TestList {
public TestCursorableLinkedList(String testName) {
@ -94,15 +94,15 @@ public class TestCursorableLinkedList extends TestList {
public void testAdd() {
assertEquals("[]",list.toString());
assert(list.add(new Integer(1)));
assertTrue(list.add(new Integer(1)));
assertEquals("[1]",list.toString());
assert(list.add(new Integer(2)));
assertTrue(list.add(new Integer(2)));
assertEquals("[1, 2]",list.toString());
assert(list.add(new Integer(3)));
assertTrue(list.add(new Integer(3)));
assertEquals("[1, 2, 3]",list.toString());
assert(list.addFirst(new Integer(0)));
assertTrue(list.addFirst(new Integer(0)));
assertEquals("[0, 1, 2, 3]",list.toString());
assert(list.addLast(new Integer(4)));
assertTrue(list.addLast(new Integer(4)));
assertEquals("[0, 1, 2, 3, 4]",list.toString());
list.add(0,new Integer(-2));
assertEquals("[-2, 0, 1, 2, 3, 4]",list.toString());
@ -116,79 +116,79 @@ public class TestCursorableLinkedList extends TestList {
list2.add("B");
list2.add("C");
assert(list.addAll(list2));
assertTrue(list.addAll(list2));
assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5, A, B, C]",list.toString());
assert(list.addAll(3,list2));
assertTrue(list.addAll(3,list2));
assertEquals("[-2, -1, 0, A, B, C, 1, 2, 3, 4, 5, A, B, C]",list.toString());
}
public void testClear() {
assertEquals(0,list.size());
assert(list.isEmpty());
assertTrue(list.isEmpty());
list.clear();
assertEquals(0,list.size());
assert(list.isEmpty());
assertTrue(list.isEmpty());
list.add("element");
assertEquals(1,list.size());
assert(!list.isEmpty());
assertTrue(!list.isEmpty());
list.clear();
assertEquals(0,list.size());
assert(list.isEmpty());
assertTrue(list.isEmpty());
list.add("element1");
list.add("element2");
assertEquals(2,list.size());
assert(!list.isEmpty());
assertTrue(!list.isEmpty());
list.clear();
assertEquals(0,list.size());
assert(list.isEmpty());
assertTrue(list.isEmpty());
for(int i=0;i<1000;i++) {
list.add(new Integer(i));
}
assertEquals(1000,list.size());
assert(!list.isEmpty());
assertTrue(!list.isEmpty());
list.clear();
assertEquals(0,list.size());
assert(list.isEmpty());
assertTrue(list.isEmpty());
}
public void testContains() {
assert(!list.contains("A"));
assert(list.add("A"));
assert(list.contains("A"));
assert(list.add("B"));
assert(list.contains("A"));
assert(list.addFirst("a"));
assert(list.contains("A"));
assert(list.remove("a"));
assert(list.contains("A"));
assert(list.remove("A"));
assert(!list.contains("A"));
assertTrue(!list.contains("A"));
assertTrue(list.add("A"));
assertTrue(list.contains("A"));
assertTrue(list.add("B"));
assertTrue(list.contains("A"));
assertTrue(list.addFirst("a"));
assertTrue(list.contains("A"));
assertTrue(list.remove("a"));
assertTrue(list.contains("A"));
assertTrue(list.remove("A"));
assertTrue(!list.contains("A"));
}
public void testContainsAll() {
assert(list.containsAll(list));
assertTrue(list.containsAll(list));
java.util.List list2 = new java.util.LinkedList();
assert(list.containsAll(list2));
assertTrue(list.containsAll(list2));
list2.add("A");
assert(!list.containsAll(list2));
assertTrue(!list.containsAll(list2));
list.add("B");
list.add("A");
assert(list.containsAll(list2));
assertTrue(list.containsAll(list2));
list2.add("B");
assert(list.containsAll(list2));
assertTrue(list.containsAll(list2));
list2.add("C");
assert(!list.containsAll(list2));
assertTrue(!list.containsAll(list2));
list.add("C");
assert(list.containsAll(list2));
assertTrue(list.containsAll(list2));
list2.add("C");
assert(list.containsAll(list2));
assert(list.containsAll(list));
assertTrue(list.containsAll(list2));
assertTrue(list.containsAll(list));
}
public void testCursorNavigation() {
@ -198,50 +198,50 @@ public class TestCursorableLinkedList extends TestList {
list.add("4");
list.add("5");
CursorableLinkedList.Cursor it = list.cursor();
assert(it.hasNext());
assert(!it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(!it.hasPrevious());
assertEquals("1",it.next());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("1",it.previous());
assert(it.hasNext());
assert(!it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(!it.hasPrevious());
assertEquals("1",it.next());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("2",it.next());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("2",it.previous());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("2",it.next());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("3",it.next());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("4",it.next());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("5",it.next());
assert(!it.hasNext());
assert(it.hasPrevious());
assertTrue(!it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("5",it.previous());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("4",it.previous());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("3",it.previous());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("2",it.previous());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals("1",it.previous());
assert(it.hasNext());
assert(!it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(!it.hasPrevious());
it.close();
}
@ -292,7 +292,7 @@ public class TestCursorableLinkedList extends TestList {
assertEquals("1",it.previous());
it.remove();
assertEquals("[3, 4, 5]",list.toString());
assert(!it.hasPrevious());
assertTrue(!it.hasPrevious());
assertEquals("3",it.next());
it.remove();
assertEquals("[4, 5]",list.toString());
@ -330,66 +330,66 @@ public class TestCursorableLinkedList extends TestList {
}
public void testEqualsAndHashCode() {
assert(list.equals(list));
assertTrue(list.equals(list));
assertEquals(list.hashCode(),list.hashCode());
list.add("A");
assert(list.equals(list));
assertTrue(list.equals(list));
assertEquals(list.hashCode(),list.hashCode());
CursorableLinkedList list2 = new CursorableLinkedList();
assert(!list.equals(list2));
assert(!list2.equals(list));
assertTrue(!list.equals(list2));
assertTrue(!list2.equals(list));
java.util.List list3 = new java.util.LinkedList();
assert(!list.equals(list3));
assert(!list3.equals(list));
assert(list2.equals(list3));
assert(list3.equals(list2));
assertTrue(!list.equals(list3));
assertTrue(!list3.equals(list));
assertTrue(list2.equals(list3));
assertTrue(list3.equals(list2));
assertEquals(list2.hashCode(),list3.hashCode());
list2.add("A");
assert(list.equals(list2));
assert(list2.equals(list));
assert(!list2.equals(list3));
assert(!list3.equals(list2));
assertTrue(list.equals(list2));
assertTrue(list2.equals(list));
assertTrue(!list2.equals(list3));
assertTrue(!list3.equals(list2));
list3.add("A");
assert(list2.equals(list3));
assert(list3.equals(list2));
assertTrue(list2.equals(list3));
assertTrue(list3.equals(list2));
assertEquals(list2.hashCode(),list3.hashCode());
list.add("B");
assert(list.equals(list));
assert(!list.equals(list2));
assert(!list2.equals(list));
assert(!list.equals(list3));
assert(!list3.equals(list));
assertTrue(list.equals(list));
assertTrue(!list.equals(list2));
assertTrue(!list2.equals(list));
assertTrue(!list.equals(list3));
assertTrue(!list3.equals(list));
list2.add("B");
list3.add("B");
assert(list.equals(list));
assert(list.equals(list2));
assert(list2.equals(list));
assert(list2.equals(list3));
assert(list3.equals(list2));
assertTrue(list.equals(list));
assertTrue(list.equals(list2));
assertTrue(list2.equals(list));
assertTrue(list2.equals(list3));
assertTrue(list3.equals(list2));
assertEquals(list2.hashCode(),list3.hashCode());
list.add("C");
list2.add("C");
list3.add("C");
assert(list.equals(list));
assert(list.equals(list2));
assert(list2.equals(list));
assert(list2.equals(list3));
assert(list3.equals(list2));
assertTrue(list.equals(list));
assertTrue(list.equals(list2));
assertTrue(list2.equals(list));
assertTrue(list2.equals(list3));
assertTrue(list3.equals(list2));
assertEquals(list.hashCode(),list2.hashCode());
assertEquals(list2.hashCode(),list3.hashCode());
list.add("D");
list2.addFirst("D");
assert(list.equals(list));
assert(!list.equals(list2));
assert(!list2.equals(list));
assertTrue(list.equals(list));
assertTrue(!list.equals(list2));
assertTrue(!list2.equals(list));
}
public void testGet() {
@ -400,9 +400,9 @@ public class TestCursorableLinkedList extends TestList {
// expected
}
assert(list.add("A"));
assertTrue(list.add("A"));
assertEquals("A",list.get(0));
assert(list.add("B"));
assertTrue(list.add("B"));
assertEquals("A",list.get(0));
assertEquals("B",list.get(1));
@ -442,15 +442,15 @@ public class TestCursorableLinkedList extends TestList {
}
public void testIsEmpty() {
assert(list.isEmpty());
assertTrue(list.isEmpty());
list.add("element");
assert(!list.isEmpty());
assertTrue(!list.isEmpty());
list.remove("element");
assert(list.isEmpty());
assertTrue(list.isEmpty());
list.add("element");
assert(!list.isEmpty());
assertTrue(!list.isEmpty());
list.clear();
assert(list.isEmpty());
assertTrue(list.isEmpty());
}
public void testIterator() {
@ -460,40 +460,40 @@ public class TestCursorableLinkedList extends TestList {
list.add("4");
list.add("5");
Iterator it = list.iterator();
assert(it.hasNext());
assertTrue(it.hasNext());
assertEquals("1",it.next());
assert(it.hasNext());
assertTrue(it.hasNext());
assertEquals("2",it.next());
assert(it.hasNext());
assertTrue(it.hasNext());
assertEquals("3",it.next());
assert(it.hasNext());
assertTrue(it.hasNext());
assertEquals("4",it.next());
assert(it.hasNext());
assertTrue(it.hasNext());
assertEquals("5",it.next());
assert(!it.hasNext());
assertTrue(!it.hasNext());
it = list.iterator();
assert(it.hasNext());
assertTrue(it.hasNext());
assertEquals("1",it.next());
it.remove();
assertEquals("[2, 3, 4, 5]",list.toString());
assert(it.hasNext());
assertTrue(it.hasNext());
assertEquals("2",it.next());
it.remove();
assertEquals("[3, 4, 5]",list.toString());
assert(it.hasNext());
assertTrue(it.hasNext());
assertEquals("3",it.next());
it.remove();
assertEquals("[4, 5]",list.toString());
assert(it.hasNext());
assertTrue(it.hasNext());
assertEquals("4",it.next());
it.remove();
assertEquals("[5]",list.toString());
assert(it.hasNext());
assertTrue(it.hasNext());
assertEquals("5",it.next());
it.remove();
assertEquals("[]",list.toString());
assert(!it.hasNext());
assertTrue(!it.hasNext());
}
public void testListIteratorNavigation() {
@ -503,78 +503,78 @@ public class TestCursorableLinkedList extends TestList {
list.add("4");
list.add("5");
ListIterator it = list.listIterator();
assert(it.hasNext());
assert(!it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(!it.hasPrevious());
assertEquals(-1,it.previousIndex());
assertEquals(0,it.nextIndex());
assertEquals("1",it.next());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(0,it.previousIndex());
assertEquals(1,it.nextIndex());
assertEquals("1",it.previous());
assert(it.hasNext());
assert(!it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(!it.hasPrevious());
assertEquals(-1,it.previousIndex());
assertEquals(0,it.nextIndex());
assertEquals("1",it.next());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(0,it.previousIndex());
assertEquals(1,it.nextIndex());
assertEquals("2",it.next());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(1,it.previousIndex());
assertEquals(2,it.nextIndex());
assertEquals("2",it.previous());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(0,it.previousIndex());
assertEquals(1,it.nextIndex());
assertEquals("2",it.next());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(1,it.previousIndex());
assertEquals(2,it.nextIndex());
assertEquals("3",it.next());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(2,it.previousIndex());
assertEquals(3,it.nextIndex());
assertEquals("4",it.next());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(3,it.previousIndex());
assertEquals(4,it.nextIndex());
assertEquals("5",it.next());
assert(!it.hasNext());
assert(it.hasPrevious());
assertTrue(!it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(4,it.previousIndex());
assertEquals(5,it.nextIndex());
assertEquals("5",it.previous());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(3,it.previousIndex());
assertEquals(4,it.nextIndex());
assertEquals("4",it.previous());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(2,it.previousIndex());
assertEquals(3,it.nextIndex());
assertEquals("3",it.previous());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(1,it.previousIndex());
assertEquals(2,it.nextIndex());
assertEquals("2",it.previous());
assert(it.hasNext());
assert(it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(it.hasPrevious());
assertEquals(0,it.previousIndex());
assertEquals(1,it.nextIndex());
assertEquals("1",it.previous());
assert(it.hasNext());
assert(!it.hasPrevious());
assertTrue(it.hasNext());
assertTrue(!it.hasPrevious());
assertEquals(-1,it.previousIndex());
assertEquals(0,it.nextIndex());
}
@ -625,7 +625,7 @@ public class TestCursorableLinkedList extends TestList {
assertEquals("1",it.previous());
it.remove();
assertEquals("[3, 4, 5]",list.toString());
assert(!it.hasPrevious());
assertTrue(!it.hasPrevious());
assertEquals("3",it.next());
it.remove();
assertEquals("[4, 5]",list.toString());
@ -674,9 +674,9 @@ public class TestCursorableLinkedList extends TestList {
set.add("4");
set.add("D");
assert(list.removeAll(set));
assertTrue(list.removeAll(set));
assertEquals("[1, 3, 5]",list.toString());
assert(!list.removeAll(set));
assertTrue(!list.removeAll(set));
}
public void testRemoveByIndex() {
@ -710,27 +710,27 @@ public class TestCursorableLinkedList extends TestList {
list.add("4");
list.add("5");
assertEquals("[1, 1, 2, 3, 4, 5, 2, 3, 4, 5]",list.toString());
assert(!list.remove("6"));
assert(list.remove("5"));
assertTrue(!list.remove("6"));
assertTrue(list.remove("5"));
assertEquals("[1, 1, 2, 3, 4, 2, 3, 4, 5]",list.toString());
assert(list.remove("5"));
assertTrue(list.remove("5"));
assertEquals("[1, 1, 2, 3, 4, 2, 3, 4]",list.toString());
assert(!list.remove("5"));
assert(list.remove("1"));
assertTrue(!list.remove("5"));
assertTrue(list.remove("1"));
assertEquals("[1, 2, 3, 4, 2, 3, 4]",list.toString());
assert(list.remove("1"));
assertTrue(list.remove("1"));
assertEquals("[2, 3, 4, 2, 3, 4]",list.toString());
assert(list.remove("2"));
assertTrue(list.remove("2"));
assertEquals("[3, 4, 2, 3, 4]",list.toString());
assert(list.remove("2"));
assertTrue(list.remove("2"));
assertEquals("[3, 4, 3, 4]",list.toString());
assert(list.remove("3"));
assertTrue(list.remove("3"));
assertEquals("[4, 3, 4]",list.toString());
assert(list.remove("3"));
assertTrue(list.remove("3"));
assertEquals("[4, 4]",list.toString());
assert(list.remove("4"));
assertTrue(list.remove("4"));
assertEquals("[4]",list.toString());
assert(list.remove("4"));
assertTrue(list.remove("4"));
assertEquals("[]",list.toString());
}
@ -753,9 +753,9 @@ public class TestCursorableLinkedList extends TestList {
set.add("4");
set.add("D");
assert(list.retainAll(set));
assertTrue(list.retainAll(set));
assertEquals("[2, 2, 4, 4]",list.toString());
assert(!list.retainAll(set));
assertTrue(!list.retainAll(set));
}
public void testSet() {
@ -896,7 +896,7 @@ public class TestCursorableLinkedList extends TestList {
String[] elts4 = new String[3];
String[] elts4b = (String[])(list.toArray(elts4));
assert(elts4 != elts4b);
assertTrue(elts4 != elts4b);
assertEquals("1",elts4b[0]);
assertEquals("2",elts4b[1]);
assertEquals("3",elts4b[2]);
@ -922,9 +922,9 @@ public class TestCursorableLinkedList extends TestList {
java.io.ObjectInputStream in = new java.io.ObjectInputStream(bufin);
Object list2 = in.readObject();
assert(list != list2);
assert(list2.equals(list));
assert(list.equals(list2));
assertTrue(list != list2);
assertTrue(list2.equals(list));
assertTrue(list.equals(list2));
}
public void testLongSerialization() throws Exception {
@ -944,9 +944,9 @@ public class TestCursorableLinkedList extends TestList {
java.io.ObjectInputStream in = new java.io.ObjectInputStream(bufin);
Object list2 = in.readObject();
assert(list != list2);
assert(list2.equals(list));
assert(list.equals(list2));
assertTrue(list != list2);
assertTrue(list2.equals(list));
assertTrue(list.equals(list2));
}
}
}

22
src/test/org/apache/commons/collections/TestExtendedProperties.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestExtendedProperties.java,v 1.2 2001/05/10 00:40:09 geirm Exp $
* $Revision: 1.2 $
* $Date: 2001/05/10 00:40:09 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestExtendedProperties.java,v 1.3 2001/07/14 23:33:27 craigmcc Exp $
* $Revision: 1.3 $
* $Date: 2001/07/14 23:33:27 $
*
* ====================================================================
*
@ -70,7 +70,7 @@ import junit.framework.TestSuite;
* class
*
* @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
* @version $Id: TestExtendedProperties.java,v 1.2 2001/05/10 00:40:09 geirm Exp $
* @version $Id: TestExtendedProperties.java,v 1.3 2001/07/14 23:33:27 craigmcc Exp $
*/
public class TestExtendedProperties extends TestCase
{
@ -111,26 +111,26 @@ public class TestExtendedProperties extends TestCase
* now add another and get a Vector
*/
eprop.addProperty("number", "2");
assert("This returns array", ( eprop.getVector("number") instanceof java.util.Vector ) );
assertTrue("This returns array", ( eprop.getVector("number") instanceof java.util.Vector ) );
/*
* now test dan's new fix where we get the first scalar
* when we access a vector valued
* property
*/
assert("This returns scalar", ( eprop.getString("number") instanceof String ) );
assertTrue("This returns scalar", ( eprop.getString("number") instanceof String ) );
/*
* test comma separated string properties
*/
String prop = "hey, that's a test";
eprop.setProperty("prop.string", prop);
assert("This returns vector", ( eprop.getVector("prop.string") instanceof java.util.Vector ) );
assertTrue("This returns vector", ( eprop.getVector("prop.string") instanceof java.util.Vector ) );
String prop2 = "hey\\, that's a test";
eprop.remove("prop.string");
eprop.setProperty("prop.string", prop2);
assert("This returns array", ( eprop.getString("prop.string") instanceof java.lang.String) );
assertTrue("This returns array", ( eprop.getString("prop.string") instanceof java.lang.String) );
/*
* test subset : we want to make sure that the EP doesn't reprocess the data
@ -139,9 +139,9 @@ public class TestExtendedProperties extends TestCase
ExtendedProperties subEprop = eprop.subset("prop");
assert("Returns the full string", subEprop.getString("string").equals( prop ) );
assert("This returns string for subset", ( subEprop.getString("string") instanceof java.lang.String) );
assert("This returns array for subset", ( subEprop.getVector("string") instanceof java.util.Vector) );
assertTrue("Returns the full string", subEprop.getString("string").equals( prop ) );
assertTrue("This returns string for subset", ( subEprop.getString("string") instanceof java.lang.String) );
assertTrue("This returns array for subset", ( subEprop.getVector("string") instanceof java.util.Vector) );
}
}

10
src/test/org/apache/commons/collections/TestHashMap.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestHashMap.java,v 1.1 2001/04/21 12:22:30 craigmcc Exp $
* $Revision: 1.1 $
* $Date: 2001/04/21 12:22:30 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestHashMap.java,v 1.2 2001/07/14 23:33:27 craigmcc Exp $
* $Revision: 1.2 $
* $Date: 2001/07/14 23:33:27 $
*
* ====================================================================
*
@ -69,7 +69,7 @@ import java.util.Map;
/**
* @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
* @version $Id: TestHashMap.java,v 1.1 2001/04/21 12:22:30 craigmcc Exp $
* @version $Id: TestHashMap.java,v 1.2 2001/07/14 23:33:27 craigmcc Exp $
*/
public class TestHashMap extends TestMap
{
@ -103,7 +103,7 @@ public class TestHashMap extends TestMap
public void testNewMap()
{
assert("New map is empty", map.isEmpty());
assertTrue("New map is empty", map.isEmpty());
assertEquals("New map has size zero", map.size(), 0);
}

90
src/test/org/apache/commons/collections/TestList.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestList.java,v 1.4 2001/05/04 16:34:27 rwaldhoff Exp $
* $Revision: 1.4 $
* $Date: 2001/05/04 16:34:27 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestList.java,v 1.5 2001/07/14 23:33:27 craigmcc Exp $
* $Revision: 1.5 $
* $Date: 2001/07/14 23:33:27 $
*
* ====================================================================
*
@ -80,7 +80,7 @@ import java.util.ListIterator;
* test case (method) your {@link List} fails.
*
* @author Rodney Waldhoff
* @version $Id: TestList.java,v 1.4 2001/05/04 16:34:27 rwaldhoff Exp $
* @version $Id: TestList.java,v 1.5 2001/07/14 23:33:27 craigmcc Exp $
*/
public abstract class TestList extends TestCollection {
public TestList(String testName) {
@ -189,11 +189,11 @@ public abstract class TestList extends TestCollection {
if(tryToAdd(list,0,"element2")) {
assertEquals(1,list.size());
if(tryToAdd(list,0,"element0")) {
assert(Arrays.equals(new String[] { "element0", "element2" },list.toArray()));
assertTrue(Arrays.equals(new String[] { "element0", "element2" },list.toArray()));
if(tryToAdd(list,1,"element1")) {
assert(Arrays.equals(new String[] { "element0", "element1", "element2" },list.toArray()));
assertTrue(Arrays.equals(new String[] { "element0", "element1", "element2" },list.toArray()));
if(tryToAdd(list,4,"element3")) {
assert(Arrays.equals(new String[] { "element0", "element1", "element2", "element3" },list.toArray()));
assertTrue(Arrays.equals(new String[] { "element0", "element1", "element2", "element3" },list.toArray()));
}
}
}
@ -203,19 +203,19 @@ public abstract class TestList extends TestCollection {
public void testListAdd() {
List list = makeList();
if(tryToAdd(list,"1")) {
assert(list.contains("1"));
assertTrue(list.contains("1"));
if(tryToAdd(list,"2")) {
assert(list.contains("1"));
assert(list.contains("2"));
assertTrue(list.contains("1"));
assertTrue(list.contains("2"));
if(tryToAdd(list,"3")) {
assert(list.contains("1"));
assert(list.contains("2"));
assert(list.contains("3"));
assertTrue(list.contains("1"));
assertTrue(list.contains("2"));
assertTrue(list.contains("3"));
if(tryToAdd(list,"4")) {
assert(list.contains("1"));
assert(list.contains("2"));
assert(list.contains("3"));
assert(list.contains("4"));
assertTrue(list.contains("1"));
assertTrue(list.contains("2"));
assertTrue(list.contains("3"));
assertTrue(list.contains("4"));
}
}
}
@ -224,20 +224,20 @@ public abstract class TestList extends TestCollection {
public void testListEqualsSelf() {
List list = makeList();
assert(list.equals(list));
assertTrue(list.equals(list));
tryToAdd(list,"elt");
assert(list.equals(list));
assertTrue(list.equals(list));
tryToAdd(list,"elt2");
assert(list.equals(list));
assertTrue(list.equals(list));
}
public void testListEqualsArrayList() {
List list1 = makeList();
List list2 = new ArrayList();
assert(list1.equals(list2));
assertTrue(list1.equals(list2));
assertEquals(list1.hashCode(),list2.hashCode());
tryToAdd(list1,"a");
assert(!list1.equals(list2));
assertTrue(!list1.equals(list2));
tryToAdd(list1,"b");
tryToAdd(list1,"c");
tryToAdd(list1,"d");
@ -247,22 +247,22 @@ public abstract class TestList extends TestCollection {
while(it.hasNext()) {
list2.add(it.next());
}
assert(list1.equals(list2));
assertTrue(list1.equals(list2));
assertEquals(list1.hashCode(),list2.hashCode());
}
public void testListEquals() {
List list1 = makeList();
List list2 = makeList();
assert(list1.equals(list2));
assertTrue(list1.equals(list2));
if(tryToAdd(list1,"a") && tryToAdd(list2,"a")) {
assert(list1.equals(list2));
assertTrue(list1.equals(list2));
if(tryToAdd(list1,"b") && tryToAdd(list2,"b")) {
assert(list1.equals(list2));
assertTrue(list1.equals(list2));
if(tryToAdd(list1,"c") && tryToAdd(list2,"c")) {
assert(list1.equals(list2));
assertTrue(list1.equals(list2));
if(tryToAdd(list1,"b") && tryToAdd(list2,"b")) {
assert(list1.equals(list2));
assertTrue(list1.equals(list2));
}
}
}
@ -574,7 +574,7 @@ public abstract class TestList extends TestCollection {
Object obj = list.set(i,String.valueOf(i));
assertEquals(obj,values[i]);
values[i] = String.valueOf(i);
assert(Arrays.equals(values,list.toArray()));
assertTrue(Arrays.equals(values,list.toArray()));
} catch(UnsupportedOperationException e) {
// expected
} catch(ClassCastException e) {
@ -626,10 +626,10 @@ public abstract class TestList extends TestCollection {
for(int i=0;i<values.length;i++) {
try {
assert(!list.remove("X"));
assert(list.contains(values[i]));
assert(list.remove(values[i]));
assert(!list.contains(values[i]));
assertTrue(!list.remove("X"));
assertTrue(list.contains(values[i]));
assertTrue(list.remove(values[i]));
assertTrue(!list.contains(values[i]));
} catch(UnsupportedOperationException e) {
// expected
}
@ -646,20 +646,20 @@ public abstract class TestList extends TestCollection {
Object[] values = list.toArray();
ListIterator iter = list.listIterator();
for(int i=0;i<values.length;i++) {
assert( iter.hasNext() );
assert((i!=0) == iter.hasPrevious());
assertTrue( iter.hasNext() );
assertTrue((i!=0) == iter.hasPrevious());
assertEquals(values[i],iter.next());
}
assert(!iter.hasNext());
assertTrue(!iter.hasNext());
for(int i=values.length-1;i>=0;i--) {
assert( iter.hasPrevious() );
assert((i!=(values.length-1)) == iter.hasNext());
assertTrue( iter.hasPrevious() );
assertTrue((i!=(values.length-1)) == iter.hasNext());
assertEquals(values[i],iter.previous());
}
assert(!iter.hasPrevious());
assertTrue(!iter.hasPrevious());
for(int i=0;i<values.length;i++) {
assert( iter.hasNext() );
assert((i!=0) == iter.hasPrevious());
assertTrue( iter.hasNext() );
assertTrue((i!=0) == iter.hasPrevious());
assertEquals(values[i],iter.next());
assertEquals(values[i],iter.previous());
assertEquals(values[i],iter.next());
@ -680,7 +680,7 @@ public abstract class TestList extends TestCollection {
assertEquals("previousIndex should be " + (i-1),i-1,iter.previousIndex());
assertEquals(values[i],iter.next());
}
assert(!iter.hasNext());
assertTrue(!iter.hasNext());
for(int i=values.length-1;i>=0;i--) {
assertEquals("previousIndex should be " + i,i,iter.previousIndex());
assertEquals("nextIndex should be " + (i+1),i+1,iter.nextIndex());
@ -716,7 +716,7 @@ public abstract class TestList extends TestCollection {
try {
iter.set(new Integer(i));
values[i] = new Integer(i);
assert(Arrays.equals(values,list.toArray()));
assertTrue(Arrays.equals(values,list.toArray()));
} catch(UnsupportedOperationException e) {
// expected
} catch(IllegalStateException e) {
@ -727,13 +727,13 @@ public abstract class TestList extends TestCollection {
// expected
}
}
assert(!iter.hasNext());
assertTrue(!iter.hasNext());
for(int i=values.length-1;i>=0;i--) {
iter.previous();
try {
iter.set(String.valueOf(i));
values[i] = String.valueOf(i);
assert(Arrays.equals(values,list.toArray()));
assertTrue(Arrays.equals(values,list.toArray()));
} catch(UnsupportedOperationException e) {
// expected
} catch(IllegalStateException e) {

10
src/test/org/apache/commons/collections/TestTreeMap.java
View File

@ -1,7 +1,7 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestTreeMap.java,v 1.1 2001/04/21 12:22:30 craigmcc Exp $
* $Revision: 1.1 $
* $Date: 2001/04/21 12:22:30 $
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestTreeMap.java,v 1.2 2001/07/14 23:33:27 craigmcc Exp $
* $Revision: 1.2 $
* $Date: 2001/07/14 23:33:27 $
*
* ====================================================================
*
@ -69,7 +69,7 @@ import java.util.Map;
/**
* @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
* @version $Id: TestTreeMap.java,v 1.1 2001/04/21 12:22:30 craigmcc Exp $
* @version $Id: TestTreeMap.java,v 1.2 2001/07/14 23:33:27 craigmcc Exp $
*/
public class TestTreeMap extends TestMap
{
@ -103,7 +103,7 @@ public class TestTreeMap extends TestMap
public void testNewMap()
{
assert("New map is empty", map.isEmpty());
assertTrue("New map is empty", map.isEmpty());
assertEquals("New map has size zero", map.size(), 0);
}