Menu
▾
▴
[pcgen-commit-svn] SF.net SVN: pcgen: [4186] branches/cdom/code/src
|
From: <th...@us...> - 2007-09-29 22:03:52
|
Revision: 4186
http://pcgen.svn.sourceforge.net/pcgen/?rev=4186&view=rev
Author: thpr
Date: 2007-09-29 15:03:55 -0700 (Sat, 29 Sep 2007)
Log Message:
-----------
Additional Base Tests & 1 fix
Modified Paths:
--------------
branches/cdom/code/src/java/pcgen/base/util/DoubleKeyMap.java
branches/cdom/code/src/utest/pcgen/base/formula/AddingFormulaTest.java
branches/cdom/code/src/utest/pcgen/base/formula/DividingFormulaTest.java
branches/cdom/code/src/utest/pcgen/base/formula/MultiplyingFormulaTest.java
branches/cdom/code/src/utest/pcgen/base/formula/SubtractingFormulaTest.java
branches/cdom/code/src/utest/pcgen/base/graph/visitor/DirectedNodeWeightCalculationTest.java
branches/cdom/code/src/utest/pcgen/base/util/BaseUtilTestSuite.java
branches/cdom/code/src/utest/pcgen/base/util/DoubleKeyMapTest.java
Added Paths:
-----------
branches/cdom/code/src/utest/pcgen/base/util/CaseInsensitiveMapTest.java
branches/cdom/code/src/utest/pcgen/base/util/TreeMapToListTest.java
Modified: branches/cdom/code/src/java/pcgen/base/util/DoubleKeyMap.java
===================================================================
--- branches/cdom/code/src/java/pcgen/base/util/DoubleKeyMap.java 2007-09-29 18:39:56 UTC (rev 4185)
+++ branches/cdom/code/src/java/pcgen/base/util/DoubleKeyMap.java 2007-09-29 22:03:55 UTC (rev 4186)
@@ -86,6 +86,7 @@
*/
public DoubleKeyMap(final DoubleKeyMap<K1, K2, V> otherMap)
{
+ this();
putAll(otherMap);
}
Modified: branches/cdom/code/src/utest/pcgen/base/formula/AddingFormulaTest.java
===================================================================
--- branches/cdom/code/src/utest/pcgen/base/formula/AddingFormulaTest.java 2007-09-29 18:39:56 UTC (rev 4185)
+++ branches/cdom/code/src/utest/pcgen/base/formula/AddingFormulaTest.java 2007-09-29 22:03:55 UTC (rev 4186)
@@ -13,6 +13,22 @@
testBrokenCalls(f);
}
+ public void testEquality()
+ {
+ AddingFormula f1 = new AddingFormula(1);
+ AddingFormula f2 = new AddingFormula(1);
+ AddingFormula f3 = new AddingFormula(2);
+ AddingFormula f4 = new AddingFormula(-1);
+ assertTrue(f1 != f2);
+ assertEquals(f1.hashCode(), f2.hashCode());
+ assertEquals(f1, f2);
+ assertFalse(f1.equals(null));
+ assertFalse(f1.hashCode() == f3.hashCode());
+ assertFalse(f1.equals(f3));
+ assertFalse(f1.hashCode() == f4.hashCode());
+ assertFalse(f1.equals(f4));
+ }
+
public void testPositive()
{
AddingFormula f = new AddingFormula(3);
Modified: branches/cdom/code/src/utest/pcgen/base/formula/DividingFormulaTest.java
===================================================================
--- branches/cdom/code/src/utest/pcgen/base/formula/DividingFormulaTest.java 2007-09-29 18:39:56 UTC (rev 4185)
+++ branches/cdom/code/src/utest/pcgen/base/formula/DividingFormulaTest.java 2007-09-29 22:03:55 UTC (rev 4186)
@@ -13,6 +13,22 @@
testBrokenCalls(f);
}
+ public void testEquality()
+ {
+ DividingFormula f1 = new DividingFormula(1);
+ DividingFormula f2 = new DividingFormula(1);
+ DividingFormula f3 = new DividingFormula(2);
+ DividingFormula f4 = new DividingFormula(-1);
+ assertTrue(f1 != f2);
+ assertEquals(f1.hashCode(), f2.hashCode());
+ assertEquals(f1, f2);
+ assertFalse(f1.equals(null));
+ assertFalse(f1.hashCode() == f3.hashCode());
+ assertFalse(f1.equals(f3));
+ assertFalse(f1.hashCode() == f4.hashCode());
+ assertFalse(f1.equals(f4));
+ }
+
public void testPositive()
{
DividingFormula f = new DividingFormula(3);
Modified: branches/cdom/code/src/utest/pcgen/base/formula/MultiplyingFormulaTest.java
===================================================================
--- branches/cdom/code/src/utest/pcgen/base/formula/MultiplyingFormulaTest.java 2007-09-29 18:39:56 UTC (rev 4185)
+++ branches/cdom/code/src/utest/pcgen/base/formula/MultiplyingFormulaTest.java 2007-09-29 22:03:55 UTC (rev 4186)
@@ -13,6 +13,22 @@
testBrokenCalls(f);
}
+ public void testEquality()
+ {
+ MultiplyingFormula f1 = new MultiplyingFormula(1);
+ MultiplyingFormula f2 = new MultiplyingFormula(1);
+ MultiplyingFormula f3 = new MultiplyingFormula(2);
+ MultiplyingFormula f4 = new MultiplyingFormula(-1);
+ assertTrue(f1 != f2);
+ assertEquals(f1.hashCode(), f2.hashCode());
+ assertEquals(f1, f2);
+ assertFalse(f1.equals(null));
+ assertFalse(f1.hashCode() == f3.hashCode());
+ assertFalse(f1.equals(f3));
+ assertFalse(f1.hashCode() == f4.hashCode());
+ assertFalse(f1.equals(f4));
+ }
+
public void testPositive()
{
MultiplyingFormula f = new MultiplyingFormula(3);
Modified: branches/cdom/code/src/utest/pcgen/base/formula/SubtractingFormulaTest.java
===================================================================
--- branches/cdom/code/src/utest/pcgen/base/formula/SubtractingFormulaTest.java 2007-09-29 18:39:56 UTC (rev 4185)
+++ branches/cdom/code/src/utest/pcgen/base/formula/SubtractingFormulaTest.java 2007-09-29 22:03:55 UTC (rev 4186)
@@ -15,6 +15,22 @@
testBrokenCalls(f);
}
+ public void testEquality()
+ {
+ SubtractingFormula f1 = new SubtractingFormula(1);
+ SubtractingFormula f2 = new SubtractingFormula(1);
+ SubtractingFormula f3 = new SubtractingFormula(2);
+ SubtractingFormula f4 = new SubtractingFormula(-1);
+ assertTrue(f1 != f2);
+ assertEquals(f1.hashCode(), f2.hashCode());
+ assertEquals(f1, f2);
+ assertFalse(f1.equals(null));
+ assertFalse(f1.hashCode() == f3.hashCode());
+ assertFalse(f1.equals(f3));
+ assertFalse(f1.hashCode() == f4.hashCode());
+ assertFalse(f1.equals(f4));
+ }
+
public void testPositive()
{
SubtractingFormula f = new SubtractingFormula(3);
Modified: branches/cdom/code/src/utest/pcgen/base/graph/visitor/DirectedNodeWeightCalculationTest.java
===================================================================
--- branches/cdom/code/src/utest/pcgen/base/graph/visitor/DirectedNodeWeightCalculationTest.java 2007-09-29 18:39:56 UTC (rev 4185)
+++ branches/cdom/code/src/utest/pcgen/base/graph/visitor/DirectedNodeWeightCalculationTest.java 2007-09-29 22:03:55 UTC (rev 4186)
@@ -38,7 +38,8 @@
DirectionalGraph g = new DirectionalListMapGraph();
- TestDirectionalHyperEdge edge1, edge2, edge3, edge4, edge5, edge6, edge7;
+ TestDirectionalHyperEdge edge1, edge2, edge3, edge4, edge5, edge6, edge7,
+ edge8;
Integer node1, node2, node3, node4, node5, node6, node7, node8, node9,
nodea, nodeb, nodec;
@@ -81,6 +82,7 @@
edge5 = new TestDirectionalHyperEdge(node6, new Integer[]{});
edge6 = new TestDirectionalHyperEdge(node4, new Integer[]{node6});
edge7 = new TestDirectionalHyperEdge(node6, new Integer[]{node6});
+ edge8 = new TestDirectionalHyperEdge(node8, new Integer[]{node6});
dedge1 = new TestDirectionalEdge(node1, node2);
dedge2 = new TestDirectionalEdge(node4, node5);
dedge3 = new TestDirectionalEdge(node1, node3);
@@ -170,7 +172,7 @@
}
}
- public void testNullNodes()
+ public void testNullNode()
{
try
{
@@ -183,17 +185,107 @@
}
}
- public void testMissingNodes()
+ public void testNullEdge()
{
+ try
+ {
+ d.calculateEdgeWeight(null);
+ fail();
+ }
+ catch (IllegalArgumentException e)
+ {
+ // OK
+ }
+ }
+
+ public void testOneNodeCall()
+ {
+ d.calculateNodeWeight(node3);
+ try
+ {
+ d.calculateNodeWeight(node1);
+ fail();
+ }
+ catch (UnsupportedOperationException e)
+ {
+ //OK
+ }
+ try
+ {
+ d.calculateEdgeWeight(dedge3);
+ fail();
+ }
+ catch (UnsupportedOperationException e)
+ {
+ //OK
+ }
+ }
+
+ public void testClear()
+ {
+ d.calculateNodeWeight(node3);
+ try
+ {
+ d.calculateNodeWeight(node1);
+ fail();
+ }
+ catch (UnsupportedOperationException e)
+ {
+ //OK
+ }
+ d.clear();
+ d.calculateEdgeWeight(dedge3);
+ }
+
+ public void testOneEdgeCall()
+ {
+ d.calculateEdgeWeight(dedge6);
+ try
+ {
+ d.calculateNodeWeight(node1);
+ fail();
+ }
+ catch (UnsupportedOperationException e)
+ {
+ //OK
+ }
+ try
+ {
+ d.calculateEdgeWeight(dedge3);
+ fail();
+ }
+ catch (UnsupportedOperationException e)
+ {
+ //OK
+ }
+ }
+
+ public void testMissingNode()
+ {
assertEquals(-1, d.calculateNodeWeight(node8));
}
- public void testSimpleDistance()
+ public void testMissingEdge()
{
+ assertEquals(-1, d.calculateEdgeWeight(edge8));
+ }
+
+ public void testSimpleEdgeDistance()
+ {
+ assertEquals(1, d.calculateEdgeWeight(dedge3));
+ }
+
+ public void testComplexEdgeDistance()
+ {
+ assertEquals(3, d.calculateEdgeWeight(dedge6));
+ }
+
+ public void testSimpleNodeDistance()
+ {
assertEquals(1, d.calculateNodeWeight(node1));
}
- public void testComplexDistance()
+ public void testComplexNodeDistance()
{
assertEquals(3, d.calculateNodeWeight(node3));
}
Modified: branches/cdom/code/src/utest/pcgen/base/util/BaseUtilTestSuite.java
===================================================================
--- branches/cdom/code/src/utest/pcgen/base/util/BaseUtilTestSuite.java 2007-09-29 18:39:56 UTC (rev 4185)
+++ branches/cdom/code/src/utest/pcgen/base/util/BaseUtilTestSuite.java 2007-09-29 22:03:55 UTC (rev 4186)
@@ -23,10 +23,11 @@
import junit.framework.TestSuite;
@RunWith(Suite.class)
-@Suite.SuiteClasses({DefaultMapTest.class, DoubleKeyMapTest.class,
- DoubleKeyMapToInstanceListTest.class, DoubleKeyMapToListTest.class,
- HashMapToListTest.class, HashMapToInstanceListTest.class,
- ListSetTest.class, MapCollectionTest.class, TripleKeyMapTest.class,
+@Suite.SuiteClasses({CaseInsensitiveMapTest.class, DefaultMapTest.class,
+ DoubleKeyMapTest.class, DoubleKeyMapToInstanceListTest.class,
+ DoubleKeyMapToListTest.class, HashMapToListTest.class,
+ HashMapToInstanceListTest.class, ListSetTest.class,
+ MapCollectionTest.class, TreeMapToListTest.class, TripleKeyMapTest.class,
TypeSafeMapTest.class, WeightedCollectionTest.class})
public class BaseUtilTestSuite extends TestSuite
{
Added: branches/cdom/code/src/utest/pcgen/base/util/CaseInsensitiveMapTest.java
===================================================================
--- branches/cdom/code/src/utest/pcgen/base/util/CaseInsensitiveMapTest.java (rev 0)
+++ branches/cdom/code/src/utest/pcgen/base/util/CaseInsensitiveMapTest.java 2007-09-29 22:03:55 UTC (rev 4186)
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2007 Tom Parker <th...@us...>
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+package pcgen.base.util;
+
+import junit.framework.TestCase;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class CaseInsensitiveMapTest extends TestCase
+{
+
+ CaseInsensitiveMap<Double> cim;
+
+ @Override
+ @Before
+ public void setUp()
+ {
+ cim = new CaseInsensitiveMap<Double>();
+ }
+
+ public void populate()
+ {
+ cim.put(Integer.valueOf(0), Double.valueOf(0));
+ cim.put("ONE", Double.valueOf(1));
+ cim.put("tWo", Double.valueOf(0));
+ cim.put("This is Three!", Double.valueOf(1));
+ cim.put("null result", null);
+ cim.put(null, Double.valueOf(-1));
+ }
+
+ @Test
+ public void testPutGetExact()
+ {
+ populate();
+ assertEquals(Double.valueOf(0), cim.get(Integer.valueOf(0)));
+ assertEquals(Double.valueOf(1), cim.get("ONE"));
+ assertEquals(Double.valueOf(0), cim.get("tWo"));
+ assertEquals(Double.valueOf(1), cim.get("This is Three!"));
+ assertNull(cim.get("null result"));
+ assertEquals(Double.valueOf(-1), cim.get(null));
+ }
+
+ @Test
+ public void testPutGetDiffCase()
+ {
+ populate();
+ assertEquals(Double.valueOf(0), cim.get(Integer.valueOf(0)));
+ assertEquals(Double.valueOf(1), cim.get("one"));
+ assertEquals(Double.valueOf(0), cim.get("TWO"));
+ assertEquals(Double.valueOf(1), cim.get("This is three!"));
+ assertNull(cim.get("NULL RESULT"));
+ assertEquals(Double.valueOf(-1), cim.get(null));
+ }
+
+ @Test
+ public void testContainsKey()
+ {
+ populate();
+ assertTrue(cim.containsKey(Integer.valueOf(0)));
+ assertTrue(cim.containsKey("one"));
+ assertTrue(cim.containsKey("TWO"));
+ assertTrue(cim.containsKey("This is three!"));
+ assertTrue(cim.containsKey("NULL RESULT"));
+ assertTrue(cim.containsKey(null));
+ }
+
+ @Test
+ public void testRemove()
+ {
+ populate();
+ assertEquals(Double.valueOf(0), cim.get(Integer.valueOf(0)));
+ assertEquals(Double.valueOf(1), cim.get("OnE"));
+ assertEquals(Double.valueOf(0), cim.get("two"));
+ assertEquals(Double.valueOf(1), cim.get("This IS three!"));
+ assertNull(cim.get("NULL result"));
+ assertEquals(Double.valueOf(-1), cim.get(null));
+
+ assertEquals(Double.valueOf(0), cim.remove(Integer.valueOf(0)));
+ assertEquals(Double.valueOf(1), cim.remove("one"));
+ assertEquals(Double.valueOf(0), cim.remove("TWO"));
+ assertEquals(Double.valueOf(1), cim.remove("This is three!"));
+ assertNull(cim.remove("NULL RESULT"));
+ assertEquals(Double.valueOf(-1), cim.remove(null));
+
+ assertNull(cim.get(Integer.valueOf(0)));
+ assertNull(cim.get("one"));
+ assertNull(cim.get("TWO"));
+ assertNull(cim.get("This is three!"));
+ assertNull(cim.get("NULL RESULT"));
+ assertNull(cim.get(null));
+ }
+}
Modified: branches/cdom/code/src/utest/pcgen/base/util/DoubleKeyMapTest.java
===================================================================
--- branches/cdom/code/src/utest/pcgen/base/util/DoubleKeyMapTest.java 2007-09-29 18:39:56 UTC (rev 4185)
+++ branches/cdom/code/src/utest/pcgen/base/util/DoubleKeyMapTest.java 2007-09-29 22:03:55 UTC (rev 4186)
@@ -34,6 +34,7 @@
private static final char CONST_A = 'A';
DoubleKeyMap<Integer, Double, Character> dkm;
+ @Override
@Before
public void setUp()
{
@@ -57,12 +58,17 @@
{
assertNull(dkm.get(Integer.valueOf(1), Double.valueOf(0)));
populate();
- assertEquals(Character.valueOf('A'), dkm.get(Integer.valueOf(1), Double.valueOf(1)));
- assertEquals(Character.valueOf('B'), dkm.get(Integer.valueOf(1), Double.valueOf(2)));
- assertEquals(Character.valueOf('C'), dkm.get(Integer.valueOf(1), Double.valueOf(3)));
+ assertEquals(Character.valueOf('A'), dkm.get(Integer.valueOf(1), Double
+ .valueOf(1)));
+ assertEquals(Character.valueOf('B'), dkm.get(Integer.valueOf(1), Double
+ .valueOf(2)));
+ assertEquals(Character.valueOf('C'), dkm.get(Integer.valueOf(1), Double
+ .valueOf(3)));
assertNull(dkm.get(Integer.valueOf(1), Double.valueOf(0)));
- assertEquals(Character.valueOf('D'), dkm.get(Integer.valueOf(2), Double.valueOf(1)));
- assertEquals(Character.valueOf('E'), dkm.get(Integer.valueOf(2), Double.valueOf(2)));
+ assertEquals(Character.valueOf('D'), dkm.get(Integer.valueOf(2), Double
+ .valueOf(1)));
+ assertEquals(Character.valueOf('E'), dkm.get(Integer.valueOf(2), Double
+ .valueOf(2)));
assertEquals(Character.valueOf('F'), dkm.get(null, Double.valueOf(3)));
assertEquals(Character.valueOf('G'), dkm.get(Integer.valueOf(3), null));
assertNull(dkm.get(Integer.valueOf(2), Double.valueOf(3)));
@@ -72,6 +78,28 @@
}
@Test
+ public void testRemoveAll()
+ {
+ assertNull(dkm.get(Integer.valueOf(1), Double.valueOf(0)));
+ populate();
+ dkm.removeAll(Integer.valueOf(1));
+ assertNull(dkm.get(Integer.valueOf(1), Double.valueOf(1)));
+ assertNull(dkm.get(Integer.valueOf(1), Double.valueOf(2)));
+ assertNull(dkm.get(Integer.valueOf(1), Double.valueOf(3)));
+ assertNull(dkm.get(Integer.valueOf(1), Double.valueOf(0)));
+ assertEquals(Character.valueOf('D'), dkm.get(Integer.valueOf(2), Double
+ .valueOf(1)));
+ assertEquals(Character.valueOf('E'), dkm.get(Integer.valueOf(2), Double
+ .valueOf(2)));
+ assertEquals(Character.valueOf('F'), dkm.get(null, Double.valueOf(3)));
+ assertEquals(Character.valueOf('G'), dkm.get(Integer.valueOf(3), null));
+ assertNull(dkm.get(Integer.valueOf(2), Double.valueOf(3)));
+ assertNull(dkm.get(Integer.valueOf(4), Double.valueOf(0)));
+ assertNull(dkm.get(Integer.valueOf(1), null));
+ assertNull(dkm.get(null, Double.valueOf(1)));
+ }
+
+ @Test
public void testContainsKey()
{
assertFalse(dkm.containsKey(Integer.valueOf(4)));
@@ -98,18 +126,23 @@
{
assertNull(dkm.remove(Integer.valueOf(1), Double.valueOf(1)));
populate();
- assertEquals(Character.valueOf('A'), dkm.remove(Integer.valueOf(1), Double.valueOf(1)));
+ assertEquals(Character.valueOf('A'), dkm.remove(Integer.valueOf(1),
+ Double.valueOf(1)));
assertFalse(dkm.containsKey(Integer.valueOf(1), Double.valueOf(1)));
assertNull(dkm.remove(Integer.valueOf(1), Double.valueOf(1)));
- assertEquals(Character.valueOf('F'), dkm.remove(null, Double.valueOf(3)));
+ assertEquals(Character.valueOf('F'), dkm
+ .remove(null, Double.valueOf(3)));
assertFalse(dkm.containsKey(null, Double.valueOf(3)));
assertNull(dkm.remove(null, Double.valueOf(3)));
- assertEquals(Character.valueOf('G'), dkm.remove(Integer.valueOf(3), null));
+ assertEquals(Character.valueOf('G'), dkm.remove(Integer.valueOf(3),
+ null));
assertFalse(dkm.containsKey(Integer.valueOf(3), null));
assertNull(dkm.remove(Integer.valueOf(3), null));
- assertEquals(Character.valueOf('B'), dkm.remove(Integer.valueOf(1), Double.valueOf(2)));
+ assertEquals(Character.valueOf('B'), dkm.remove(Integer.valueOf(1),
+ Double.valueOf(2)));
assertTrue(dkm.containsKey(Integer.valueOf(1)));
- assertEquals(Character.valueOf('C'), dkm.remove(Integer.valueOf(1), Double.valueOf(3)));
+ assertEquals(Character.valueOf('C'), dkm.remove(Integer.valueOf(1),
+ Double.valueOf(3)));
assertFalse(dkm.containsKey(Integer.valueOf(1)));
}
@@ -272,4 +305,196 @@
assertFalse(dkm.removeValue(Integer.valueOf(5), null));
assertFalse(dkm.containsKey(Integer.valueOf(5), Double.valueOf(6)));
}
+
+ @Test
+ public void testDKMconstructorOneClear()
+ {
+ populate();
+ DoubleKeyMap<Integer, Double, Character> dkm2;
+ dkm2 = new DoubleKeyMap<Integer, Double, Character>(dkm);
+ // Ensure 1 clear is innocent
+ dkm.clear();
+ assertFalse(dkm2.isEmpty());
+ assertEquals(Character.valueOf('A'), dkm2.get(Integer.valueOf(1),
+ Double.valueOf(1)));
+ assertEquals(Character.valueOf('B'), dkm2.get(Integer.valueOf(1),
+ Double.valueOf(2)));
+ }
+
+ @Test
+ public void testDKMconstructorTwoClear()
+ {
+ populate();
+ DoubleKeyMap<Integer, Double, Character> dkm2;
+ dkm2 = new DoubleKeyMap<Integer, Double, Character>(dkm);
+ // Ensure 2 clear is innocent
+ dkm2.clear();
+ assertFalse(dkm.isEmpty());
+ assertEquals(Character.valueOf('A'), dkm.get(Integer.valueOf(1), Double
+ .valueOf(1)));
+ assertEquals(Character.valueOf('B'), dkm.get(Integer.valueOf(1), Double
+ .valueOf(2)));
+ }
+
+ @Test
+ public void testDKMconstructorOneChange()
+ {
+ populate();
+ DoubleKeyMap<Integer, Double, Character> dkm2;
+ dkm2 = new DoubleKeyMap<Integer, Double, Character>(dkm);
+ // Ensure 1 change is innocent
+ dkm.put(Integer.valueOf(1), Double.valueOf(1), 'Z');
+ assertEquals(Character.valueOf('Z'), dkm.get(Integer.valueOf(1), Double
+ .valueOf(1)));
+ assertEquals(Character.valueOf('A'), dkm2.get(Integer.valueOf(1),
+ Double.valueOf(1)));
+ }
+
+ @Test
+ public void testDKMconstructorTwoChange()
+ {
+ populate();
+ DoubleKeyMap<Integer, Double, Character> dkm2;
+ dkm2 = new DoubleKeyMap<Integer, Double, Character>(dkm);
+ // Ensure 2 change is innocent
+ dkm2.put(Integer.valueOf(1), Double.valueOf(1), 'Z');
+ assertEquals(Character.valueOf('A'), dkm.get(Integer.valueOf(1), Double
+ .valueOf(1)));
+ assertEquals(Character.valueOf('Z'), dkm2.get(Integer.valueOf(1),
+ Double.valueOf(1)));
+ }
+
+ @Test
+ public void testDKMconstructorOneRemoveAll()
+ {
+ populate();
+ DoubleKeyMap<Integer, Double, Character> dkm2;
+ dkm2 = new DoubleKeyMap<Integer, Double, Character>(dkm);
+ // Ensure 1 remove is innocent
+ dkm.removeAll(Integer.valueOf(1));
+ assertEquals(null, dkm.get(Integer.valueOf(1), Double.valueOf(1)));
+ assertEquals(Character.valueOf('A'), dkm2.get(Integer.valueOf(1),
+ Double.valueOf(1)));
+ }
+
+ @Test
+ public void testDKMconstructorTwoRemoveAll()
+ {
+ populate();
+ DoubleKeyMap<Integer, Double, Character> dkm2;
+ dkm2 = new DoubleKeyMap<Integer, Double, Character>(dkm);
+ // Ensure 2 remove is innocent
+ dkm2.removeAll(Integer.valueOf(1));
+ assertEquals(null, dkm2.get(Integer.valueOf(1), Double.valueOf(1)));
+ assertEquals(Character.valueOf('A'), dkm.get(Integer.valueOf(1), Double
+ .valueOf(1)));
+ }
+
+ @Test
+ public void testDKMputAllOneClear()
+ {
+ populate();
+ DoubleKeyMap<Integer, Double, Character> dkm2 =
+ new DoubleKeyMap<Integer, Double, Character>();
+ dkm2.putAll(dkm);
+ // Ensure 1 clear is innocent
+ dkm.clear();
+ assertFalse(dkm2.isEmpty());
+ assertEquals(Character.valueOf('A'), dkm2.get(Integer.valueOf(1),
+ Double.valueOf(1)));
+ assertEquals(Character.valueOf('B'), dkm2.get(Integer.valueOf(1),
+ Double.valueOf(2)));
+ }
+
+ @Test
+ public void testDKMputAllTwoClear()
+ {
+ populate();
+ DoubleKeyMap<Integer, Double, Character> dkm2 =
+ new DoubleKeyMap<Integer, Double, Character>();
+ dkm2.putAll(dkm);
+ // Ensure 2 clear is innocent
+ dkm2.clear();
+ assertFalse(dkm.isEmpty());
+ assertEquals(Character.valueOf('A'), dkm.get(Integer.valueOf(1), Double
+ .valueOf(1)));
+ assertEquals(Character.valueOf('B'), dkm.get(Integer.valueOf(1), Double
+ .valueOf(2)));
+ }
+
+ @Test
+ public void testDKMputAllOneChange()
+ {
+ populate();
+ DoubleKeyMap<Integer, Double, Character> dkm2 =
+ new DoubleKeyMap<Integer, Double, Character>();
+ dkm2.putAll(dkm);
+ // Ensure 1 change is innocent
+ dkm.put(Integer.valueOf(1), Double.valueOf(1), 'Z');
+ assertEquals(Character.valueOf('Z'), dkm.get(Integer.valueOf(1), Double
+ .valueOf(1)));
+ assertEquals(Character.valueOf('A'), dkm2.get(Integer.valueOf(1),
+ Double.valueOf(1)));
+ }
+
+ @Test
+ public void testDKMputAllTwoChange()
+ {
+ populate();
+ DoubleKeyMap<Integer, Double, Character> dkm2 =
+ new DoubleKeyMap<Integer, Double, Character>();
+ dkm2.putAll(dkm);
+ // Ensure 2 change is innocent
+ dkm2.put(Integer.valueOf(1), Double.valueOf(1), 'Z');
+ assertEquals(Character.valueOf('A'), dkm.get(Integer.valueOf(1), Double
+ .valueOf(1)));
+ assertEquals(Character.valueOf('Z'), dkm2.get(Integer.valueOf(1),
+ Double.valueOf(1)));
+ }
+
+ @Test
+ public void testDKMputAllOneRemoveAll()
+ {
+ populate();
+ DoubleKeyMap<Integer, Double, Character> dkm2 =
+ new DoubleKeyMap<Integer, Double, Character>();
+ dkm2.putAll(dkm);
+ // Ensure 1 remove is innocent
+ dkm.removeAll(Integer.valueOf(1));
+ assertEquals(null, dkm.get(Integer.valueOf(1), Double.valueOf(1)));
+ assertEquals(Character.valueOf('A'), dkm2.get(Integer.valueOf(1),
+ Double.valueOf(1)));
+ }
+
+ @Test
+ public void testDKMputAllTwoRemoveAll()
+ {
+ populate();
+ DoubleKeyMap<Integer, Double, Character> dkm2 =
+ new DoubleKeyMap<Integer, Double, Character>();
+ dkm2.putAll(dkm);
+ // Ensure 2 remove is innocent
+ dkm2.removeAll(Integer.valueOf(1));
+ assertEquals(null, dkm2.get(Integer.valueOf(1), Double.valueOf(1)));
+ assertEquals(Character.valueOf('A'), dkm.get(Integer.valueOf(1), Double
+ .valueOf(1)));
+ }
+
+ @Test
+ public void testPutAllNull()
+ {
+ try
+ {
+ dkm.putAll(null);
+ fail();
+ }
+ catch (NullPointerException e)
+ {
+ // OK
+ }
+ catch (IllegalArgumentException e)
+ {
+ // OK
+ }
+ }
}
Added: branches/cdom/code/src/utest/pcgen/base/util/TreeMapToListTest.java
===================================================================
--- branches/cdom/code/src/utest/pcgen/base/util/TreeMapToListTest.java (rev 0)
+++ branches/cdom/code/src/utest/pcgen/base/util/TreeMapToListTest.java 2007-09-29 22:03:55 UTC (rev 4186)
@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2007 Tom Parker <th...@us...>
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+package pcgen.base.util;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import junit.framework.TestCase;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class TreeMapToListTest extends TestCase
+{
+
+ private static final Character CONST_E = 'E';
+
+ private static final Character CONST_C = 'C';
+
+ private static final Character CONST_G = 'G';
+
+ private static final Character CONST_F = 'F';
+
+ private static final Character CONST_D = 'D';
+
+ private static final Character CONST_B = 'B';
+
+ private static final Character CONST_A = 'A';
+
+ TreeMapToList<Integer, Character> dkm;
+
+ @Before
+ public void setUp()
+ {
+ dkm = new TreeMapToList<Integer, Character>();
+ }
+
+ public void populate()
+ {
+ dkm.addToListFor(Integer.valueOf(1), CONST_A);
+ dkm.addToListFor(Integer.valueOf(1), CONST_B);
+ dkm.addToListFor(Integer.valueOf(1), CONST_C);
+ dkm.addToListFor(Integer.valueOf(2), CONST_D);
+ dkm.addToListFor(Integer.valueOf(2), CONST_E);
+ dkm.addToListFor(Integer.valueOf(2), null);
+ dkm.addToListFor(Integer.valueOf(5), null);
+ }
+
+ @Test
+ void putNull()
+ {
+ try
+ {
+ dkm.addToListFor(null, CONST_F);
+ fail();
+ }
+ catch (NullPointerException e)
+ {
+ // OK
+ }
+ catch (IllegalArgumentException e)
+ {
+ // OK
+ }
+ }
+
+ @Test
+ public void testPutGet()
+ {
+ assertNull(dkm.getListFor(null));
+ assertNull(dkm.getListFor(Integer.valueOf(1)));
+ populate();
+ List l = dkm.getListFor(Integer.valueOf(1));
+ assertEquals(3, l.size());
+ assertTrue(l.contains(CONST_A));
+ assertTrue(l.contains(CONST_B));
+ assertTrue(l.contains(CONST_C));
+ dkm.addToListFor(Integer.valueOf(1), CONST_C);
+ l = dkm.getListFor(Integer.valueOf(1));
+ assertEquals(4, l.size());
+ assertTrue(l.contains(CONST_A));
+ assertTrue(l.contains(CONST_B));
+ assertTrue(l.contains(CONST_C));
+ // two of them
+ l.remove(Character.valueOf(CONST_C));
+ assertTrue(l.contains(CONST_C));
+ l = dkm.getListFor(Integer.valueOf(2));
+ assertEquals(3, l.size());
+ assertTrue(l.contains(CONST_D));
+ assertTrue(l.contains(CONST_E));
+ assertTrue(l.contains(null));
+ dkm.addToListFor(Integer.valueOf(2), null);
+ l = dkm.getListFor(Integer.valueOf(2));
+ assertEquals(4, l.size());
+ assertTrue(l.contains(CONST_D));
+ assertTrue(l.contains(CONST_E));
+ assertTrue(l.contains(null));
+ // Two of them.
+ l.remove(null);
+ assertTrue(l.contains(null));
+ assertNull(dkm.getListFor(Integer.valueOf(4)));
+ l = dkm.getListFor(Integer.valueOf(5));
+ assertEquals(1, l.size());
+ assertTrue(l.contains(null));
+ l.add(CONST_A);
+ List l2 = dkm.getListFor(Integer.valueOf(5));
+ assertEquals(1, l2.size());
+ assertTrue(l2.contains(null));
+ assertEquals(2, l.size());
+ assertTrue(l.contains(null));
+ assertTrue(l.contains(CONST_A));
+ dkm.clear();
+ assertEquals(1, l2.size());
+ assertTrue(l2.contains(null));
+ assertEquals(2, l.size());
+ assertTrue(l.contains(null));
+ assertTrue(l.contains(CONST_A));
+ l2.clear();
+ assertEquals(0, l2.size());
+ assertEquals(2, l.size());
+ assertTrue(l.contains(null));
+ assertTrue(l.contains(CONST_A));
+ }
+
+ @Test
+ public void testContainsKey()
+ {
+ assertFalse(dkm.containsListFor(Integer.valueOf(1)));
+ populate();
+ assertTrue(dkm.containsListFor(Integer.valueOf(1)));
+ // Keys are .equals items, not instance
+ assertTrue(dkm.containsListFor(new Integer(1)));
+ assertTrue(dkm.containsListFor(Integer.valueOf(2)));
+ assertTrue(dkm.containsListFor(Integer.valueOf(5)));
+ assertFalse(dkm.containsListFor(Integer.valueOf(-4)));
+ }
+
+ @Test
+ public void testRemoveListFor()
+ {
+ assertNull(dkm.removeListFor(Integer.valueOf(1)));
+ populate();
+ List l = dkm.removeListFor(Integer.valueOf(1));
+ assertEquals(3, l.size());
+ assertTrue(l.contains(CONST_A));
+ assertTrue(l.contains(CONST_B));
+ assertTrue(l.contains(CONST_C));
+ assertFalse(dkm.containsListFor(Integer.valueOf(1)));
+ assertNull(dkm.getListFor(Integer.valueOf(1)));
+ l = dkm.removeListFor(Integer.valueOf(2));
+ assertEquals(3, l.size());
+ assertTrue(l.contains(CONST_D));
+ assertTrue(l.contains(CONST_E));
+ assertTrue(l.contains(null));
+ }
+
+ @Test
+ public void testRemoveFromListFor()
+ {
+ assertFalse(dkm.removeFromListFor(Integer.valueOf(1), CONST_D));
+ populate();
+ assertTrue(dkm.removeFromListFor(Integer.valueOf(1), CONST_A));
+ assertTrue(dkm.containsListFor(Integer.valueOf(1)));
+ // Keys are .equals items, not instance
+ assertTrue(dkm.containsListFor(new Integer(1)));
+ assertEquals(2, dkm.sizeOfListFor(Integer.valueOf(1)));
+ assertFalse(dkm.removeFromListFor(Integer.valueOf(1), CONST_A));
+ assertTrue(dkm.removeFromListFor(Integer.valueOf(1), CONST_B));
+ assertEquals(1, dkm.sizeOfListFor(Integer.valueOf(1)));
+ assertTrue(dkm.containsListFor(Integer.valueOf(1)));
+ assertFalse(dkm.removeFromListFor(Integer.valueOf(1), CONST_A));
+ assertTrue(dkm.removeFromListFor(Integer.valueOf(1), CONST_C));
+ assertEquals(0, dkm.sizeOfListFor(Integer.valueOf(1)));
+ assertFalse(dkm.containsListFor(Integer.valueOf(1)));
+
+ // add a second :)
+ dkm.addToListFor(Integer.valueOf(2), CONST_D);
+ assertFalse(dkm.removeFromListFor(Integer.valueOf(2), CONST_A));
+ assertTrue(dkm.containsListFor(Integer.valueOf(2)));
+ assertEquals(4, dkm.sizeOfListFor(Integer.valueOf(2)));
+ assertFalse(dkm.removeFromListFor(Integer.valueOf(2), CONST_A));
+ assertTrue(dkm.removeFromListFor(Integer.valueOf(2), CONST_D));
+ assertEquals(3, dkm.sizeOfListFor(Integer.valueOf(2)));
+ assertTrue(dkm.containsListFor(Integer.valueOf(2)));
+ assertTrue(dkm.removeFromListFor(Integer.valueOf(2), CONST_E));
+ assertEquals(2, dkm.sizeOfListFor(Integer.valueOf(2)));
+ assertTrue(dkm.containsListFor(Integer.valueOf(2)));
+ assertTrue(dkm.removeFromListFor(Integer.valueOf(2), null));
+ assertEquals(1, dkm.sizeOfListFor(Integer.valueOf(2)));
+ assertTrue(dkm.containsListFor(Integer.valueOf(2)));
+ assertTrue(dkm.removeFromListFor(Integer.valueOf(2), CONST_D));
+ assertEquals(0, dkm.sizeOfListFor(Integer.valueOf(2)));
+ assertFalse(dkm.containsListFor(Integer.valueOf(2)));
+ }
+
+ @Test
+ public void testContainsInList()
+ {
+ assertFalse(dkm.containsInList(Integer.valueOf(1), CONST_D));
+ populate();
+ assertTrue(dkm.containsInList(Integer.valueOf(1), CONST_A));
+ // Keys are .equals items, not instance
+ assertTrue(dkm.containsInList(new Integer(1), CONST_A));
+ assertTrue(dkm.containsInList(Integer.valueOf(1), CONST_B));
+ assertTrue(dkm.containsInList(Integer.valueOf(1), CONST_C));
+ assertFalse(dkm.containsInList(Integer.valueOf(1), CONST_D));
+
+ // add a second :)
+ dkm.addToListFor(Integer.valueOf(1), CONST_C);
+ assertTrue(dkm.containsInList(Integer.valueOf(1), CONST_C));
+
+ // Test null stuff :)
+ assertTrue(dkm.containsInList(Integer.valueOf(2), null));
+ }
+
+ @Test
+ public void testGetKeySet()
+ {
+ Set<Integer> s = dkm.getKeySet();
+ assertEquals(0, s.size());
+ s.add(Integer.valueOf(-5));
+ // Ensure not saved in DoubleKeyMap
+ Set<Integer> s2 = dkm.getKeySet();
+ assertEquals(0, s2.size());
+ assertEquals(1, s.size());
+ // And ensure references are not kept the other direction to be altered
+ // by changes in the underlying DoubleKeyMap
+ populate();
+ assertEquals(1, s.size());
+ assertEquals(0, s2.size());
+ Set<Integer> s3 = dkm.getKeySet();
+ assertEquals(3, s3.size());
+ assertTrue(s3.contains(Integer.valueOf(1)));
+ assertTrue(s3.contains(Integer.valueOf(2)));
+ assertTrue(s3.contains(Integer.valueOf(5)));
+ }
+
+ @Test
+ public void testClearIsEmpty()
+ {
+ assertTrue(dkm.isEmpty());
+ assertEquals(0, dkm.size());
+ populate();
+ assertFalse(dkm.isEmpty());
+ assertEquals(3, dkm.size());
+ dkm.clear();
+ assertTrue(dkm.isEmpty());
+ assertEquals(0, dkm.size());
+ dkm.addToListFor(Integer.valueOf(3), 'G');
+ assertFalse(dkm.isEmpty());
+ assertEquals(1, dkm.size());
+ dkm.clear();
+ assertTrue(dkm.isEmpty());
+ assertEquals(0, dkm.size());
+ dkm.addToListFor(Integer.valueOf(5), null);
+ assertFalse(dkm.isEmpty());
+ assertEquals(1, dkm.size());
+ dkm.clear();
+ assertTrue(dkm.isEmpty());
+ assertEquals(0, dkm.size());
+ }
+
+ @Test
+ public void testEmptyAddAll()
+ {
+ dkm.addAllToListFor(Integer.valueOf(1), null);
+ assertFalse(dkm.containsListFor(Integer.valueOf(1)));
+ dkm.addAllToListFor(Integer.valueOf(1), new ArrayList());
+ assertFalse(dkm.containsListFor(Integer.valueOf(1)));
+ }
+
+ @Test
+ public void testAddAll()
+ {
+ List l = new ArrayList();
+ l.add(CONST_A);
+ l.add(null);
+ l.add(CONST_A);
+ l.add(CONST_B);
+ dkm.addAllToListFor(Integer.valueOf(1), l);
+ assertTrue(dkm.containsListFor(Integer.valueOf(1)));
+ assertEquals(4, dkm.sizeOfListFor(Integer.valueOf(1)));
+ dkm.addToListFor(Integer.valueOf(1), CONST_D);
+ assertEquals(4, l.size());
+ // Check reference semantics!
+ l.add(CONST_C);
+ l.add(CONST_E);
+ assertTrue(dkm.containsListFor(Integer.valueOf(1)));
+ assertEquals(5, dkm.sizeOfListFor(Integer.valueOf(1)));
+ l.clear();
+ assertTrue(dkm.containsListFor(Integer.valueOf(1)));
+ assertEquals(5, dkm.sizeOfListFor(Integer.valueOf(1)));
+ }
+
+ @Test
+ public void testInstanceBehavior()
+ {
+ Character ca = Character.valueOf('a');
+ Character cb = Character.valueOf('b');
+ Character cc = Character.valueOf('c');
+ Character ca1 = new Character('a');
+ Integer i1 = Integer.valueOf(1);
+ dkm.addToListFor(i1, ca);
+ dkm.addToListFor(i1, cb);
+ dkm.addToListFor(i1, cc);
+ Integer i2 = Integer.valueOf(2);
+ dkm.addToListFor(i2, ca);
+ dkm.addToListFor(i2, ca);
+ Integer i3 = Integer.valueOf(3);
+ dkm.addToListFor(i3, cb);
+ dkm.addToListFor(i3, cc);
+ assertTrue(dkm.containsInList(i1, ca));
+ assertTrue(dkm.containsInList(i1, ca1));
+ assertTrue(dkm.removeFromListFor(i1, ca1));
+ assertFalse(dkm.containsInList(i1, ca));
+
+ assertTrue(dkm.containsInList(i2, ca));
+ assertTrue(dkm.containsInList(i2, ca1));
+ assertTrue(dkm.removeFromListFor(i2, ca1));
+ // There were two
+ assertTrue(dkm.containsInList(i2, ca));
+ assertTrue(dkm.removeFromListFor(i2, ca));
+ // There were two
+ assertFalse(dkm.containsInList(i2, ca));
+ }
+
+ // TODO Need to test iterator order
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
