Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToDoubleHashMapTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToDoubleHashMapTest.java?rev=1083514&r1=1083513&r2=1083514&view=diff ============================================================================== --- commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToDoubleHashMapTest.java (original) +++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToDoubleHashMapTest.java Sun Mar 20 17:24:14 2011 @@ -24,17 +24,20 @@ import java.util.NoSuchElementException; import java.util.Random; import java.util.Set; -import junit.framework.TestCase; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + /** * Test cases for the {@link OpenIntToDoubleHashMap}. */ -public class OpenIntToDoubleHashMapTest extends TestCase { +public class OpenIntToDoubleHashMapTest { private Map<Integer, Double> javaMap = new HashMap<Integer, Double>(); - @Override - protected void setUp() throws Exception { + @Before + public void setUp() throws Exception { javaMap.put(50, 100.0); javaMap.put(75, 75.0); javaMap.put(25, 500.0); @@ -69,16 +72,19 @@ public class OpenIntToDoubleHashMapTest return map; } + @Test public void testPutAndGetWith0ExpectedSize() { OpenIntToDoubleHashMap map = new OpenIntToDoubleHashMap(0); assertPutAndGet(map); } + @Test public void testPutAndGetWithExpectedSize() { OpenIntToDoubleHashMap map = new OpenIntToDoubleHashMap(500); assertPutAndGet(map); } + @Test public void testPutAndGet() { OpenIntToDoubleHashMap map = new OpenIntToDoubleHashMap(); assertPutAndGet(map); @@ -90,58 +96,63 @@ public class OpenIntToDoubleHashMapTest private void assertPutAndGet(OpenIntToDoubleHashMap map, int mapSize, Set<Integer> keysInMap) { - assertEquals(mapSize, map.size()); + Assert.assertEquals(mapSize, map.size()); for (Map.Entry<Integer, Double> mapEntry : javaMap.entrySet()) { map.put(mapEntry.getKey(), mapEntry.getValue()); if (!keysInMap.contains(mapEntry.getKey())) ++mapSize; - assertEquals(mapSize, map.size()); - assertEquals(mapEntry.getValue(), map.get(mapEntry.getKey())); + Assert.assertEquals(mapSize, map.size()); + Assert.assertTrue(MathUtils.equals(mapEntry.getValue(), map.get(mapEntry.getKey()), 1)); } } + @Test public void testPutAbsentOnExisting() { OpenIntToDoubleHashMap map = createFromJavaMap(); int size = javaMap.size(); for (Map.Entry<Integer, Double> mapEntry : generateAbsent().entrySet()) { map.put(mapEntry.getKey(), mapEntry.getValue()); - assertEquals(++size, map.size()); - assertEquals(mapEntry.getValue(), map.get(mapEntry.getKey())); + Assert.assertEquals(++size, map.size()); + Assert.assertTrue(MathUtils.equals(mapEntry.getValue(), map.get(mapEntry.getKey()), 1)); } } + @Test public void testPutOnExisting() { OpenIntToDoubleHashMap map = createFromJavaMap(); for (Map.Entry<Integer, Double> mapEntry : javaMap.entrySet()) { map.put(mapEntry.getKey(), mapEntry.getValue()); - assertEquals(javaMap.size(), map.size()); - assertEquals(mapEntry.getValue(), map.get(mapEntry.getKey())); + Assert.assertEquals(javaMap.size(), map.size()); + Assert.assertTrue(MathUtils.equals(mapEntry.getValue(), map.get(mapEntry.getKey()), 1)); } } + @Test public void testGetAbsent() { Map<Integer, Double> generated = generateAbsent(); OpenIntToDoubleHashMap map = createFromJavaMap(); for (Map.Entry<Integer, Double> mapEntry : generated.entrySet()) - assertTrue(Double.isNaN(map.get(mapEntry.getKey()))); + Assert.assertTrue(Double.isNaN(map.get(mapEntry.getKey()))); } + @Test public void testGetFromEmpty() { OpenIntToDoubleHashMap map = new OpenIntToDoubleHashMap(); - assertTrue(Double.isNaN(map.get(5))); - assertTrue(Double.isNaN(map.get(0))); - assertTrue(Double.isNaN(map.get(50))); + Assert.assertTrue(Double.isNaN(map.get(5))); + Assert.assertTrue(Double.isNaN(map.get(0))); + Assert.assertTrue(Double.isNaN(map.get(50))); } + @Test public void testRemove() { OpenIntToDoubleHashMap map = createFromJavaMap(); int mapSize = javaMap.size(); - assertEquals(mapSize, map.size()); + Assert.assertEquals(mapSize, map.size()); for (Map.Entry<Integer, Double> mapEntry : javaMap.entrySet()) { map.remove(mapEntry.getKey()); - assertEquals(--mapSize, map.size()); - assertTrue(Double.isNaN(map.get(mapEntry.getKey()))); + Assert.assertEquals(--mapSize, map.size()); + Assert.assertTrue(Double.isNaN(map.get(mapEntry.getKey()))); } /* Ensure that put and get still work correctly after removals */ @@ -149,6 +160,7 @@ public class OpenIntToDoubleHashMapTest } /* This time only remove some entries */ + @Test public void testRemove2() { OpenIntToDoubleHashMap map = createFromJavaMap(); int mapSize = javaMap.size(); @@ -157,8 +169,8 @@ public class OpenIntToDoubleHashMapTest for (Map.Entry<Integer, Double> mapEntry : javaMap.entrySet()) { keysInMap.remove(mapEntry.getKey()); map.remove(mapEntry.getKey()); - assertEquals(--mapSize, map.size()); - assertTrue(Double.isNaN(map.get(mapEntry.getKey()))); + Assert.assertEquals(--mapSize, map.size()); + Assert.assertTrue(Double.isNaN(map.get(mapEntry.getKey()))); if (count++ > 5) break; } @@ -167,11 +179,13 @@ public class OpenIntToDoubleHashMapTest assertPutAndGet(map, mapSize, keysInMap); } + @Test public void testRemoveFromEmpty() { OpenIntToDoubleHashMap map = new OpenIntToDoubleHashMap(); - assertTrue(Double.isNaN(map.remove(50))); + Assert.assertTrue(Double.isNaN(map.remove(50))); } + @Test public void testRemoveAbsent() { Map<Integer, Double> generated = generateAbsent(); @@ -180,8 +194,8 @@ public class OpenIntToDoubleHashMapTest for (Map.Entry<Integer, Double> mapEntry : generated.entrySet()) { map.remove(mapEntry.getKey()); - assertEquals(mapSize, map.size()); - assertTrue(Double.isNaN(map.get(mapEntry.getKey()))); + Assert.assertEquals(mapSize, map.size()); + Assert.assertTrue(Double.isNaN(map.get(mapEntry.getKey()))); } } @@ -198,59 +212,63 @@ public class OpenIntToDoubleHashMapTest return generated; } + @Test public void testCopy() { OpenIntToDoubleHashMap copy = new OpenIntToDoubleHashMap(createFromJavaMap()); - assertEquals(javaMap.size(), copy.size()); + Assert.assertEquals(javaMap.size(), copy.size()); for (Map.Entry<Integer, Double> mapEntry : javaMap.entrySet()) - assertEquals(mapEntry.getValue(), copy.get(mapEntry.getKey())); + Assert.assertTrue(MathUtils.equals(mapEntry.getValue(), copy.get(mapEntry.getKey()), 1)); } + @Test public void testContainsKey() { OpenIntToDoubleHashMap map = createFromJavaMap(); for (Map.Entry<Integer, Double> mapEntry : javaMap.entrySet()) { - assertTrue(map.containsKey(mapEntry.getKey())); + Assert.assertTrue(map.containsKey(mapEntry.getKey())); } for (Map.Entry<Integer, Double> mapEntry : generateAbsent().entrySet()) { - assertFalse(map.containsKey(mapEntry.getKey())); + Assert.assertFalse(map.containsKey(mapEntry.getKey())); } for (Map.Entry<Integer, Double> mapEntry : javaMap.entrySet()) { int key = mapEntry.getKey(); - assertTrue(map.containsKey(key)); + Assert.assertTrue(map.containsKey(key)); map.remove(key); - assertFalse(map.containsKey(key)); + Assert.assertFalse(map.containsKey(key)); } } + @Test public void testIterator() { OpenIntToDoubleHashMap map = createFromJavaMap(); OpenIntToDoubleHashMap.Iterator iterator = map.iterator(); for (int i = 0; i < map.size(); ++i) { - assertTrue(iterator.hasNext()); + Assert.assertTrue(iterator.hasNext()); iterator.advance(); int key = iterator.key(); - assertTrue(map.containsKey(key)); - assertEquals(javaMap.get(key), map.get(key), 0); - assertEquals(javaMap.get(key), iterator.value(), 0); - assertTrue(javaMap.containsKey(key)); + Assert.assertTrue(map.containsKey(key)); + Assert.assertEquals(javaMap.get(key), map.get(key), 0); + Assert.assertEquals(javaMap.get(key), iterator.value(), 0); + Assert.assertTrue(javaMap.containsKey(key)); } - assertFalse(iterator.hasNext()); + Assert.assertFalse(iterator.hasNext()); try { iterator.advance(); - fail("an exception should have been thrown"); + Assert.fail("an exception should have been thrown"); } catch (NoSuchElementException nsee) { // expected } } + @Test public void testConcurrentModification() { OpenIntToDoubleHashMap map = createFromJavaMap(); OpenIntToDoubleHashMap.Iterator iterator = map.iterator(); map.put(3, 3); try { iterator.advance(); - fail("an exception should have been thrown"); + Assert.fail("an exception should have been thrown"); } catch (ConcurrentModificationException cme) { // expected } @@ -261,6 +279,7 @@ public class OpenIntToDoubleHashMapTest * loop was inconsistent with the first causing duplicate keys after the right sequence * of puts and removes. */ + @Test public void testPutKeysWithCollisions() { OpenIntToDoubleHashMap map = new OpenIntToDoubleHashMap(); int key1 = -1996012590; @@ -270,20 +289,21 @@ public class OpenIntToDoubleHashMapTest map.put(key2, value1); int key3 = 1008859686; map.put(key3, value1); - assertEquals(value1, map.get(key3)); - assertEquals(3, map.size()); + Assert.assertTrue(MathUtils.equals(value1, map.get(key3), 1)); + Assert.assertEquals(3, map.size()); map.remove(key2); double value2 = 2.0; map.put(key3, value2); - assertEquals(value2, map.get(key3)); - assertEquals(2, map.size()); + Assert.assertTrue(MathUtils.equals(value2, map.get(key3), 1)); + Assert.assertEquals(2, map.size()); } /** * Similar to testPutKeysWithCollisions() but exercises the codepaths in a slightly * different manner. */ + @Test public void testPutKeysWithCollision2() { OpenIntToDoubleHashMap map = new OpenIntToDoubleHashMap(); int key1 = 837989881; @@ -291,14 +311,14 @@ public class OpenIntToDoubleHashMapTest map.put(key1, value1); int key2 = 476463321; map.put(key2, value1); - assertEquals(2, map.size()); - assertEquals(value1, map.get(key2)); + Assert.assertEquals(2, map.size()); + Assert.assertTrue(MathUtils.equals(value1, map.get(key2), 1)); map.remove(key1); double value2 = 2.0; map.put(key2, value2); - assertEquals(1, map.size()); - assertEquals(value2, map.get(key2)); + Assert.assertEquals(1, map.size()); + Assert.assertTrue(MathUtils.equals(value2, map.get(key2), 1)); } }
Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToFieldTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToFieldTest.java?rev=1083514&r1=1083513&r2=1083514&view=diff ============================================================================== --- commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToFieldTest.java (original) +++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToFieldTest.java Sun Mar 20 17:24:14 2011 @@ -29,16 +29,18 @@ import org.apache.commons.math.Field; import org.apache.commons.math.fraction.Fraction; import org.apache.commons.math.fraction.FractionConversionException; import org.apache.commons.math.fraction.FractionField; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; -import junit.framework.TestCase; -public class OpenIntToFieldTest extends TestCase { +public class OpenIntToFieldTest { private Map<Integer, Fraction> javaMap = new HashMap<Integer, Fraction>(); private FractionField field = FractionField.getInstance(); - @Override - protected void setUp() throws Exception { + @Before + public void setUp() throws FractionConversionException { javaMap.put(50, new Fraction(100.0)); javaMap.put(75, new Fraction(75.0)); javaMap.put(25, new Fraction(500.0)); @@ -79,16 +81,19 @@ public class OpenIntToFieldTest extends return map; } + @Test public void testPutAndGetWith0ExpectedSize() { OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field,0); assertPutAndGet(map); } + @Test public void testPutAndGetWithExpectedSize() { OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field,500); assertPutAndGet(map); } + @Test public void testPutAndGet() { OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field); assertPutAndGet(map); @@ -100,58 +105,63 @@ public class OpenIntToFieldTest extends private void assertPutAndGet(OpenIntToFieldHashMap<Fraction> map, int mapSize, Set<Integer> keysInMap) { - assertEquals(mapSize, map.size()); + Assert.assertEquals(mapSize, map.size()); for (Map.Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) { map.put(mapEntry.getKey(), mapEntry.getValue()); if (!keysInMap.contains(mapEntry.getKey())) ++mapSize; - assertEquals(mapSize, map.size()); - assertEquals(mapEntry.getValue(), map.get(mapEntry.getKey())); + Assert.assertEquals(mapSize, map.size()); + Assert.assertEquals(mapEntry.getValue(), map.get(mapEntry.getKey())); } } + @Test public void testPutAbsentOnExisting() { OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field); int size = javaMap.size(); for (Map.Entry<Integer, Fraction> mapEntry : generateAbsent().entrySet()) { map.put(mapEntry.getKey(), mapEntry.getValue()); - assertEquals(++size, map.size()); - assertEquals(mapEntry.getValue(), map.get(mapEntry.getKey())); + Assert.assertEquals(++size, map.size()); + Assert.assertEquals(mapEntry.getValue(), map.get(mapEntry.getKey())); } } + @Test public void testPutOnExisting() { OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field); for (Map.Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) { map.put(mapEntry.getKey(), mapEntry.getValue()); - assertEquals(javaMap.size(), map.size()); - assertEquals(mapEntry.getValue(), map.get(mapEntry.getKey())); + Assert.assertEquals(javaMap.size(), map.size()); + Assert.assertEquals(mapEntry.getValue(), map.get(mapEntry.getKey())); } } + @Test public void testGetAbsent() { Map<Integer, Fraction> generated = generateAbsent(); OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field); for (Map.Entry<Integer, Fraction> mapEntry : generated.entrySet()) - assertTrue(field.getZero().equals(map.get(mapEntry.getKey()))); + Assert.assertTrue(field.getZero().equals(map.get(mapEntry.getKey()))); } + @Test public void testGetFromEmpty() { OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field); - assertTrue(field.getZero().equals(map.get(5))); - assertTrue(field.getZero().equals(map.get(0))); - assertTrue(field.getZero().equals(map.get(50))); + Assert.assertTrue(field.getZero().equals(map.get(5))); + Assert.assertTrue(field.getZero().equals(map.get(0))); + Assert.assertTrue(field.getZero().equals(map.get(50))); } + @Test public void testRemove() { OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field); int mapSize = javaMap.size(); - assertEquals(mapSize, map.size()); + Assert.assertEquals(mapSize, map.size()); for (Map.Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) { map.remove(mapEntry.getKey()); - assertEquals(--mapSize, map.size()); - assertTrue(field.getZero().equals(map.get(mapEntry.getKey()))); + Assert.assertEquals(--mapSize, map.size()); + Assert.assertTrue(field.getZero().equals(map.get(mapEntry.getKey()))); } /* Ensure that put and get still work correctly after removals */ @@ -159,6 +169,7 @@ public class OpenIntToFieldTest extends } /* This time only remove some entries */ + @Test public void testRemove2() { OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field); int mapSize = javaMap.size(); @@ -167,8 +178,8 @@ public class OpenIntToFieldTest extends for (Map.Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) { keysInMap.remove(mapEntry.getKey()); map.remove(mapEntry.getKey()); - assertEquals(--mapSize, map.size()); - assertTrue(field.getZero().equals(map.get(mapEntry.getKey()))); + Assert.assertEquals(--mapSize, map.size()); + Assert.assertTrue(field.getZero().equals(map.get(mapEntry.getKey()))); if (count++ > 5) break; } @@ -177,11 +188,13 @@ public class OpenIntToFieldTest extends assertPutAndGet(map, mapSize, keysInMap); } + @Test public void testRemoveFromEmpty() { OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field); - assertTrue(field.getZero().equals(map.remove(50))); + Assert.assertTrue(field.getZero().equals(map.remove(50))); } + @Test public void testRemoveAbsent() { Map<Integer, Fraction> generated = generateAbsent(); @@ -190,8 +203,8 @@ public class OpenIntToFieldTest extends for (Map.Entry<Integer, Fraction> mapEntry : generated.entrySet()) { map.remove(mapEntry.getKey()); - assertEquals(mapSize, map.size()); - assertTrue(field.getZero().equals(map.get(mapEntry.getKey()))); + Assert.assertEquals(mapSize, map.size()); + Assert.assertTrue(field.getZero().equals(map.get(mapEntry.getKey()))); } } @@ -208,59 +221,63 @@ public class OpenIntToFieldTest extends return generated; } + @Test public void testCopy() { OpenIntToFieldHashMap<Fraction> copy = new OpenIntToFieldHashMap<Fraction>(createFromJavaMap(field)); - assertEquals(javaMap.size(), copy.size()); + Assert.assertEquals(javaMap.size(), copy.size()); for (Map.Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) - assertEquals(mapEntry.getValue(), copy.get(mapEntry.getKey())); + Assert.assertEquals(mapEntry.getValue(), copy.get(mapEntry.getKey())); } + @Test public void testContainsKey() { OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field); for (Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) { - assertTrue(map.containsKey(mapEntry.getKey())); + Assert.assertTrue(map.containsKey(mapEntry.getKey())); } for (Map.Entry<Integer, Fraction> mapEntry : generateAbsent().entrySet()) { - assertFalse(map.containsKey(mapEntry.getKey())); + Assert.assertFalse(map.containsKey(mapEntry.getKey())); } for (Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) { int key = mapEntry.getKey(); - assertTrue(map.containsKey(key)); + Assert.assertTrue(map.containsKey(key)); map.remove(key); - assertFalse(map.containsKey(key)); + Assert.assertFalse(map.containsKey(key)); } } + @Test public void testIterator() { OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field); OpenIntToFieldHashMap<Fraction>.Iterator iterator = map.iterator(); for (int i = 0; i < map.size(); ++i) { - assertTrue(iterator.hasNext()); + Assert.assertTrue(iterator.hasNext()); iterator.advance(); int key = iterator.key(); - assertTrue(map.containsKey(key)); - assertEquals(javaMap.get(key), map.get(key)); - assertEquals(javaMap.get(key), iterator.value()); - assertTrue(javaMap.containsKey(key)); + Assert.assertTrue(map.containsKey(key)); + Assert.assertEquals(javaMap.get(key), map.get(key)); + Assert.assertEquals(javaMap.get(key), iterator.value()); + Assert.assertTrue(javaMap.containsKey(key)); } - assertFalse(iterator.hasNext()); + Assert.assertFalse(iterator.hasNext()); try { iterator.advance(); - fail("an exception should have been thrown"); + Assert.fail("an exception should have been thrown"); } catch (NoSuchElementException nsee) { // expected } } + @Test public void testConcurrentModification() { OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field); OpenIntToFieldHashMap<Fraction>.Iterator iterator = map.iterator(); map.put(3, new Fraction(3)); try { iterator.advance(); - fail("an exception should have been thrown"); + Assert.fail("an exception should have been thrown"); } catch (ConcurrentModificationException cme) { // expected } @@ -271,6 +288,7 @@ public class OpenIntToFieldTest extends * loop was inconsistent with the first causing duplicate keys after the right sequence * of puts and removes. */ + @Test public void testPutKeysWithCollisions() { OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field); int key1 = -1996012590; @@ -280,20 +298,21 @@ public class OpenIntToFieldTest extends map.put(key2, value1); int key3 = 1008859686; map.put(key3, value1); - assertEquals(value1, map.get(key3)); - assertEquals(3, map.size()); + Assert.assertEquals(value1, map.get(key3)); + Assert.assertEquals(3, map.size()); map.remove(key2); Fraction value2 = new Fraction(2); map.put(key3, value2); - assertEquals(value2, map.get(key3)); - assertEquals(2, map.size()); + Assert.assertEquals(value2, map.get(key3)); + Assert.assertEquals(2, map.size()); } /** * Similar to testPutKeysWithCollisions() but exercises the codepaths in a slightly * different manner. */ + @Test public void testPutKeysWithCollision2() { OpenIntToFieldHashMap<Fraction>map = new OpenIntToFieldHashMap<Fraction>(field); int key1 = 837989881; @@ -301,14 +320,14 @@ public class OpenIntToFieldTest extends map.put(key1, value1); int key2 = 476463321; map.put(key2, value1); - assertEquals(2, map.size()); - assertEquals(value1, map.get(key2)); + Assert.assertEquals(2, map.size()); + Assert.assertEquals(value1, map.get(key2)); map.remove(key1); Fraction value2 = new Fraction(2); map.put(key2, value2); - assertEquals(1, map.size()); - assertEquals(value2, map.get(key2)); + Assert.assertEquals(1, map.size()); + Assert.assertEquals(value2, map.get(key2)); } Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ResizableDoubleArrayTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ResizableDoubleArrayTest.java?rev=1083514&r1=1083513&r2=1083514&view=diff ============================================================================== --- commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ResizableDoubleArrayTest.java (original) +++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ResizableDoubleArrayTest.java Sun Mar 20 17:24:14 2011 @@ -17,6 +17,10 @@ package org.apache.commons.math.util; import org.apache.commons.math.random.RandomDataImpl; import org.apache.commons.math.random.RandomData; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; /** @@ -26,91 +30,88 @@ import org.apache.commons.math.random.Ra */ public class ResizableDoubleArrayTest extends DoubleArrayAbstractTest { - public ResizableDoubleArrayTest(String name) { - super( name ); - } - - @Override - protected void tearDown() throws Exception { + @After + public void tearDown() throws Exception { da = null; ra = null; } - @Override - protected void setUp() throws Exception { + @Before + public void setUp() throws Exception { da = new ResizableDoubleArray(); ra = new ResizableDoubleArray(); } + @Test public void testConstructors() { float defaultExpansionFactor = 2.0f; float defaultContractionCriteria = 2.5f; int defaultMode = ResizableDoubleArray.MULTIPLICATIVE_MODE; ResizableDoubleArray testDa = new ResizableDoubleArray(2); - assertEquals(0, testDa.getNumElements()); - assertEquals(2, testDa.getInternalLength()); - assertEquals(defaultExpansionFactor, testDa.getExpansionFactor(), 0); - assertEquals(defaultContractionCriteria, testDa.getContractionCriteria(), 0); - assertEquals(defaultMode, testDa.getExpansionMode()); + Assert.assertEquals(0, testDa.getNumElements()); + Assert.assertEquals(2, testDa.getInternalLength()); + Assert.assertEquals(defaultExpansionFactor, testDa.getExpansionFactor(), 0); + Assert.assertEquals(defaultContractionCriteria, testDa.getContractionCriteria(), 0); + Assert.assertEquals(defaultMode, testDa.getExpansionMode()); try { da = new ResizableDoubleArray(-1); - fail("Expecting IllegalArgumentException"); + Assert.fail("Expecting IllegalArgumentException"); } catch (IllegalArgumentException ex) { // expected } testDa = new ResizableDoubleArray((double[]) null); - assertEquals(0, testDa.getNumElements()); + Assert.assertEquals(0, testDa.getNumElements()); double[] initialArray = new double[] { 0, 1, 2 }; testDa = new ResizableDoubleArray(initialArray); - assertEquals(3, testDa.getNumElements()); + Assert.assertEquals(3, testDa.getNumElements()); testDa = new ResizableDoubleArray(2, 2.0f); - assertEquals(0, testDa.getNumElements()); - assertEquals(2, testDa.getInternalLength()); - assertEquals(defaultExpansionFactor, testDa.getExpansionFactor(), 0); - assertEquals(defaultContractionCriteria, testDa.getContractionCriteria(), 0); - assertEquals(defaultMode, testDa.getExpansionMode()); + Assert.assertEquals(0, testDa.getNumElements()); + Assert.assertEquals(2, testDa.getInternalLength()); + Assert.assertEquals(defaultExpansionFactor, testDa.getExpansionFactor(), 0); + Assert.assertEquals(defaultContractionCriteria, testDa.getContractionCriteria(), 0); + Assert.assertEquals(defaultMode, testDa.getExpansionMode()); try { da = new ResizableDoubleArray(2, 0.5f); - fail("Expecting IllegalArgumentException"); + Assert.fail("Expecting IllegalArgumentException"); } catch (IllegalArgumentException ex) { // expected } testDa = new ResizableDoubleArray(2, 3.0f); - assertEquals(3.0f, testDa.getExpansionFactor(), 0); - assertEquals(3.5f, testDa.getContractionCriteria(), 0); + Assert.assertEquals(3.0f, testDa.getExpansionFactor(), 0); + Assert.assertEquals(3.5f, testDa.getContractionCriteria(), 0); testDa = new ResizableDoubleArray(2, 2.0f, 3.0f); - assertEquals(0, testDa.getNumElements()); - assertEquals(2, testDa.getInternalLength()); - assertEquals(defaultExpansionFactor, testDa.getExpansionFactor(), 0); - assertEquals(3.0f, testDa.getContractionCriteria(), 0); - assertEquals(defaultMode, testDa.getExpansionMode()); + Assert.assertEquals(0, testDa.getNumElements()); + Assert.assertEquals(2, testDa.getInternalLength()); + Assert.assertEquals(defaultExpansionFactor, testDa.getExpansionFactor(), 0); + Assert.assertEquals(3.0f, testDa.getContractionCriteria(), 0); + Assert.assertEquals(defaultMode, testDa.getExpansionMode()); try { da = new ResizableDoubleArray(2, 2.0f, 1.5f); - fail("Expecting IllegalArgumentException"); + Assert.fail("Expecting IllegalArgumentException"); } catch (IllegalArgumentException ex) { // expected } testDa = new ResizableDoubleArray(2, 2.0f, 3.0f, ResizableDoubleArray.ADDITIVE_MODE); - assertEquals(0, testDa.getNumElements()); - assertEquals(2, testDa.getInternalLength()); - assertEquals(defaultExpansionFactor, testDa.getExpansionFactor(), 0); - assertEquals(3.0f, testDa.getContractionCriteria(), 0); - assertEquals(ResizableDoubleArray.ADDITIVE_MODE, + Assert.assertEquals(0, testDa.getNumElements()); + Assert.assertEquals(2, testDa.getInternalLength()); + Assert.assertEquals(defaultExpansionFactor, testDa.getExpansionFactor(), 0); + Assert.assertEquals(3.0f, testDa.getContractionCriteria(), 0); + Assert.assertEquals(ResizableDoubleArray.ADDITIVE_MODE, testDa.getExpansionMode()); try { da = new ResizableDoubleArray(2, 2.0f, 2.5f, -1); - fail("Expecting IllegalArgumentException"); + Assert.fail("Expecting IllegalArgumentException"); } catch (IllegalArgumentException ex) { // expected } @@ -121,11 +122,12 @@ public class ResizableDoubleArrayTest ex testDa.addElement(2.0); testDa.addElement(3.2); ResizableDoubleArray copyDa = new ResizableDoubleArray(testDa); - assertEquals(copyDa, testDa); - assertEquals(testDa, copyDa); + Assert.assertEquals(copyDa, testDa); + Assert.assertEquals(testDa, copyDa); } + @Test public void testSetElementArbitraryExpansion() { // MULTIPLICATIVE_MODE @@ -137,15 +139,15 @@ public class ResizableDoubleArrayTest ex // Expand the array arbitrarily to 1000 items da.setElement(1000, 3.4); - assertEquals( "The number of elements should now be 1001, it isn't", + Assert.assertEquals( "The number of elements should now be 1001, it isn't", da.getNumElements(), 1001); - assertEquals( "Uninitialized Elements are default value of 0.0, index 766 wasn't", 0.0, + Assert.assertEquals( "Uninitialized Elements are default value of 0.0, index 766 wasn't", 0.0, da.getElement( 760 ), Double.MIN_VALUE ); - assertEquals( "The 1000th index should be 3.4, it isn't", 3.4, da.getElement(1000), + Assert.assertEquals( "The 1000th index should be 3.4, it isn't", 3.4, da.getElement(1000), Double.MIN_VALUE ); - assertEquals( "The 0th index should be 2.0, it isn't", 2.0, da.getElement(0), + Assert.assertEquals( "The 0th index should be 2.0, it isn't", 2.0, da.getElement(0), Double.MIN_VALUE); // Make sure numElements and expansion work correctly for expansion boundary cases @@ -153,21 +155,21 @@ public class ResizableDoubleArrayTest ex da.addElement(2.0); da.addElement(4.0); da.addElement(6.0); - assertEquals(4, ((ResizableDoubleArray) da).getInternalLength()); - assertEquals(3, da.getNumElements()); + Assert.assertEquals(4, ((ResizableDoubleArray) da).getInternalLength()); + Assert.assertEquals(3, da.getNumElements()); da.setElement(3, 7.0); - assertEquals(4, ((ResizableDoubleArray) da).getInternalLength()); - assertEquals(4, da.getNumElements()); + Assert.assertEquals(4, ((ResizableDoubleArray) da).getInternalLength()); + Assert.assertEquals(4, da.getNumElements()); da.setElement(10, 10.0); - assertEquals(11, ((ResizableDoubleArray) da).getInternalLength()); - assertEquals(11, da.getNumElements()); + Assert.assertEquals(11, ((ResizableDoubleArray) da).getInternalLength()); + Assert.assertEquals(11, da.getNumElements()); da.setElement(9, 10.0); - assertEquals(11, ((ResizableDoubleArray) da).getInternalLength()); - assertEquals(11, da.getNumElements()); + Assert.assertEquals(11, ((ResizableDoubleArray) da).getInternalLength()); + Assert.assertEquals(11, da.getNumElements()); try { da.setElement(-2, 3); - fail("Expecting ArrayIndexOutOfBoundsException for negative index"); + Assert.fail("Expecting ArrayIndexOutOfBoundsException for negative index"); } catch (ArrayIndexOutOfBoundsException ex) { // expected } @@ -176,50 +178,53 @@ public class ResizableDoubleArrayTest ex ResizableDoubleArray testDa = new ResizableDoubleArray(2, 2.0f, 3.0f, ResizableDoubleArray.ADDITIVE_MODE); - assertEquals(2, testDa.getInternalLength()); + Assert.assertEquals(2, testDa.getInternalLength()); testDa.addElement(1d); testDa.addElement(1d); - assertEquals(2, testDa.getInternalLength()); + Assert.assertEquals(2, testDa.getInternalLength()); testDa.addElement(1d); - assertEquals(4, testDa.getInternalLength()); + Assert.assertEquals(4, testDa.getInternalLength()); } @Override + @Test public void testAdd1000() { super.testAdd1000(); - assertEquals("Internal Storage length should be 1024 if we started out with initial capacity of " + + Assert.assertEquals("Internal Storage length should be 1024 if we started out with initial capacity of " + "16 and an expansion factor of 2.0", 1024, ((ResizableDoubleArray) da).getInternalLength()); } + @Test public void testAddElements() { ResizableDoubleArray testDa = new ResizableDoubleArray(); // MULTIPLICATIVE_MODE testDa.addElements(new double[] {4, 5, 6}); - assertEquals(3, testDa.getNumElements(), 0); - assertEquals(4, testDa.getElement(0), 0); - assertEquals(5, testDa.getElement(1), 0); - assertEquals(6, testDa.getElement(2), 0); + Assert.assertEquals(3, testDa.getNumElements(), 0); + Assert.assertEquals(4, testDa.getElement(0), 0); + Assert.assertEquals(5, testDa.getElement(1), 0); + Assert.assertEquals(6, testDa.getElement(2), 0); testDa.addElements(new double[] {4, 5, 6}); - assertEquals(6, testDa.getNumElements()); + Assert.assertEquals(6, testDa.getNumElements()); // ADDITIVE_MODE (x's are occupied storage locations, 0's are open) testDa = new ResizableDoubleArray(2, 2.0f, 2.5f, ResizableDoubleArray.ADDITIVE_MODE); - assertEquals(2, testDa.getInternalLength()); + Assert.assertEquals(2, testDa.getInternalLength()); testDa.addElements(new double[] { 1d }); // x,0 testDa.addElements(new double[] { 2d }); // x,x testDa.addElements(new double[] { 3d }); // x,x,x,0 -- expanded - assertEquals(1d, testDa.getElement(0), 0); - assertEquals(2d, testDa.getElement(1), 0); - assertEquals(3d, testDa.getElement(2), 0); - assertEquals(4, testDa.getInternalLength()); // x,x,x,0 - assertEquals(3, testDa.getNumElements()); + Assert.assertEquals(1d, testDa.getElement(0), 0); + Assert.assertEquals(2d, testDa.getElement(1), 0); + Assert.assertEquals(3d, testDa.getElement(2), 0); + Assert.assertEquals(4, testDa.getInternalLength()); // x,x,x,0 + Assert.assertEquals(3, testDa.getNumElements()); } @Override + @Test public void testAddElementRolling() { super.testAddElementRolling(); @@ -228,55 +233,56 @@ public class ResizableDoubleArrayTest ex da.addElement(1); da.addElement(2); da.addElementRolling(3); - assertEquals(3, da.getElement(1), 0); + Assert.assertEquals(3, da.getElement(1), 0); da.addElementRolling(4); - assertEquals(3, da.getElement(0), 0); - assertEquals(4, da.getElement(1), 0); + Assert.assertEquals(3, da.getElement(0), 0); + Assert.assertEquals(4, da.getElement(1), 0); da.addElement(5); - assertEquals(5, da.getElement(2), 0); + Assert.assertEquals(5, da.getElement(2), 0); da.addElementRolling(6); - assertEquals(4, da.getElement(0), 0); - assertEquals(5, da.getElement(1), 0); - assertEquals(6, da.getElement(2), 0); + Assert.assertEquals(4, da.getElement(0), 0); + Assert.assertEquals(5, da.getElement(1), 0); + Assert.assertEquals(6, da.getElement(2), 0); // ADDITIVE_MODE (x's are occupied storage locations, 0's are open) ResizableDoubleArray testDa = new ResizableDoubleArray(2, 2.0f, 2.5f, ResizableDoubleArray.ADDITIVE_MODE); - assertEquals(2, testDa.getInternalLength()); + Assert.assertEquals(2, testDa.getInternalLength()); testDa.addElement(1d); // x,0 testDa.addElement(2d); // x,x testDa.addElement(3d); // x,x,x,0 -- expanded - assertEquals(1d, testDa.getElement(0), 0); - assertEquals(2d, testDa.getElement(1), 0); - assertEquals(3d, testDa.getElement(2), 0); - assertEquals(4, testDa.getInternalLength()); // x,x,x,0 - assertEquals(3, testDa.getNumElements()); + Assert.assertEquals(1d, testDa.getElement(0), 0); + Assert.assertEquals(2d, testDa.getElement(1), 0); + Assert.assertEquals(3d, testDa.getElement(2), 0); + Assert.assertEquals(4, testDa.getInternalLength()); // x,x,x,0 + Assert.assertEquals(3, testDa.getNumElements()); testDa.addElementRolling(4d); - assertEquals(2d, testDa.getElement(0), 0); - assertEquals(3d, testDa.getElement(1), 0); - assertEquals(4d, testDa.getElement(2), 0); - assertEquals(4, testDa.getInternalLength()); // 0,x,x,x - assertEquals(3, testDa.getNumElements()); + Assert.assertEquals(2d, testDa.getElement(0), 0); + Assert.assertEquals(3d, testDa.getElement(1), 0); + Assert.assertEquals(4d, testDa.getElement(2), 0); + Assert.assertEquals(4, testDa.getInternalLength()); // 0,x,x,x + Assert.assertEquals(3, testDa.getNumElements()); testDa.addElementRolling(5d); // 0,0,x,x,x,0 -- time to contract - assertEquals(3d, testDa.getElement(0), 0); - assertEquals(4d, testDa.getElement(1), 0); - assertEquals(5d, testDa.getElement(2), 0); - assertEquals(4, testDa.getInternalLength()); // contracted -- x,x,x,0 - assertEquals(3, testDa.getNumElements()); + Assert.assertEquals(3d, testDa.getElement(0), 0); + Assert.assertEquals(4d, testDa.getElement(1), 0); + Assert.assertEquals(5d, testDa.getElement(2), 0); + Assert.assertEquals(4, testDa.getInternalLength()); // contracted -- x,x,x,0 + Assert.assertEquals(3, testDa.getNumElements()); try { testDa.getElement(4); - fail("Expecting ArrayIndexOutOfBoundsException"); + Assert.fail("Expecting ArrayIndexOutOfBoundsException"); } catch (ArrayIndexOutOfBoundsException ex) { // expected } try { testDa.getElement(-1); - fail("Expecting ArrayIndexOutOfBoundsException"); + Assert.fail("Expecting ArrayIndexOutOfBoundsException"); } catch (ArrayIndexOutOfBoundsException ex) { // expected } } + @Test public void testSetNumberOfElements() { da.addElement( 1.0 ); da.addElement( 1.0 ); @@ -284,27 +290,28 @@ public class ResizableDoubleArrayTest ex da.addElement( 1.0 ); da.addElement( 1.0 ); da.addElement( 1.0 ); - assertEquals( "Number of elements should equal 6", da.getNumElements(), 6); + Assert.assertEquals( "Number of elements should equal 6", da.getNumElements(), 6); ((ResizableDoubleArray) da).setNumElements( 3 ); - assertEquals( "Number of elements should equal 3", da.getNumElements(), 3); + Assert.assertEquals( "Number of elements should equal 3", da.getNumElements(), 3); try { ((ResizableDoubleArray) da).setNumElements( -3 ); - fail( "Setting number of elements to negative should've thrown an exception"); + Assert.fail( "Setting number of elements to negative should've thrown an exception"); } catch( IllegalArgumentException iae ) { } ((ResizableDoubleArray) da).setNumElements(1024); - assertEquals( "Number of elements should now be 1024", da.getNumElements(), 1024); - assertEquals( "Element 453 should be a default double", da.getElement( 453 ), 0.0, Double.MIN_VALUE); + Assert.assertEquals( "Number of elements should now be 1024", da.getNumElements(), 1024); + Assert.assertEquals( "Element 453 should be a default double", da.getElement( 453 ), 0.0, Double.MIN_VALUE); } + @Test public void testWithInitialCapacity() { ResizableDoubleArray eDA2 = new ResizableDoubleArray(2); - assertEquals("Initial number of elements should be 0", 0, eDA2.getNumElements()); + Assert.assertEquals("Initial number of elements should be 0", 0, eDA2.getNumElements()); RandomData randomData = new RandomDataImpl(); int iterations = randomData.nextInt(100, 1000); @@ -313,18 +320,19 @@ public class ResizableDoubleArrayTest ex eDA2.addElement( i ); } - assertEquals("Number of elements should be equal to " + iterations, iterations, eDA2.getNumElements()); + Assert.assertEquals("Number of elements should be equal to " + iterations, iterations, eDA2.getNumElements()); eDA2.addElement( 2.0 ); - assertEquals("Number of elements should be equals to " + (iterations +1), + Assert.assertEquals("Number of elements should be equals to " + (iterations +1), iterations + 1 , eDA2.getNumElements() ); } + @Test public void testWithInitialCapacityAndExpansionFactor() { ResizableDoubleArray eDA3 = new ResizableDoubleArray(3, 3.0f, 3.5f); - assertEquals("Initial number of elements should be 0", 0, eDA3.getNumElements() ); + Assert.assertEquals("Initial number of elements should be 0", 0, eDA3.getNumElements() ); RandomData randomData = new RandomDataImpl(); int iterations = randomData.nextInt(100, 3000); @@ -333,16 +341,17 @@ public class ResizableDoubleArrayTest ex eDA3.addElement( i ); } - assertEquals("Number of elements should be equal to " + iterations, iterations,eDA3.getNumElements()); + Assert.assertEquals("Number of elements should be equal to " + iterations, iterations,eDA3.getNumElements()); eDA3.addElement( 2.0 ); - assertEquals("Number of elements should be equals to " + (iterations +1), + Assert.assertEquals("Number of elements should be equals to " + (iterations +1), iterations +1, eDA3.getNumElements() ); - assertEquals("Expansion factor should equal 3.0", 3.0f, eDA3.getExpansionFactor(), Double.MIN_VALUE); + Assert.assertEquals("Expansion factor should equal 3.0", 3.0f, eDA3.getExpansionFactor(), Double.MIN_VALUE); } + @Test public void testDiscard() { da.addElement(2.0); da.addElement(2.0); @@ -355,46 +364,47 @@ public class ResizableDoubleArrayTest ex da.addElement(2.0); da.addElement(2.0); da.addElement(2.0); - assertEquals( "Number of elements should be 11", 11, da.getNumElements()); + Assert.assertEquals( "Number of elements should be 11", 11, da.getNumElements()); ((ResizableDoubleArray)da).discardFrontElements(5); - assertEquals( "Number of elements should be 6", 6, da.getNumElements()); + Assert.assertEquals( "Number of elements should be 6", 6, da.getNumElements()); da.addElement(2.0); da.addElement(2.0); da.addElement(2.0); da.addElement(2.0); - assertEquals( "Number of elements should be 10", 10, da.getNumElements()); + Assert.assertEquals( "Number of elements should be 10", 10, da.getNumElements()); ((ResizableDoubleArray)da).discardMostRecentElements(2); - assertEquals( "Number of elements should be 8", 8, da.getNumElements()); + Assert.assertEquals( "Number of elements should be 8", 8, da.getNumElements()); try { ((ResizableDoubleArray)da).discardFrontElements(-1); - fail( "Trying to discard a negative number of element is not allowed"); + Assert.fail( "Trying to discard a negative number of element is not allowed"); } catch( Exception e ){ } try { ((ResizableDoubleArray)da).discardMostRecentElements(-1); - fail( "Trying to discard a negative number of element is not allowed"); + Assert.fail( "Trying to discard a negative number of element is not allowed"); } catch( Exception e ){ } try { ((ResizableDoubleArray)da).discardFrontElements( 10000 ); - fail( "You can't discard more elements than the array contains"); + Assert.fail( "You can't discard more elements than the array contains"); } catch( Exception e ){ } try { ((ResizableDoubleArray)da).discardMostRecentElements( 10000 ); - fail( "You can't discard more elements than the array contains"); + Assert.fail( "You can't discard more elements than the array contains"); } catch( Exception e ){ } } + @Test public void testSubstitute() { da.addElement(2.0); @@ -408,60 +418,62 @@ public class ResizableDoubleArrayTest ex da.addElement(2.0); da.addElement(2.0); da.addElement(2.0); - assertEquals( "Number of elements should be 11", 11, da.getNumElements()); + Assert.assertEquals( "Number of elements should be 11", 11, da.getNumElements()); ((ResizableDoubleArray)da).substituteMostRecentElement(24); - assertEquals( "Number of elements should be 11", 11, da.getNumElements()); + Assert.assertEquals( "Number of elements should be 11", 11, da.getNumElements()); try { ((ResizableDoubleArray)da).discardMostRecentElements(10); } catch( Exception e ){ - fail( "Trying to discard a negative number of element is not allowed"); + Assert.fail( "Trying to discard a negative number of element is not allowed"); } ((ResizableDoubleArray)da).substituteMostRecentElement(24); - assertEquals( "Number of elements should be 1", 1, da.getNumElements()); + Assert.assertEquals( "Number of elements should be 1", 1, da.getNumElements()); } + @Test public void testMutators() { ((ResizableDoubleArray)da).setContractionCriteria(10f); - assertEquals(10f, ((ResizableDoubleArray)da).getContractionCriteria(), 0); + Assert.assertEquals(10f, ((ResizableDoubleArray)da).getContractionCriteria(), 0); ((ResizableDoubleArray)da).setExpansionFactor(8f); - assertEquals(8f, ((ResizableDoubleArray)da).getExpansionFactor(), 0); + Assert.assertEquals(8f, ((ResizableDoubleArray)da).getExpansionFactor(), 0); try { ((ResizableDoubleArray)da).setExpansionFactor(11f); // greater than contractionCriteria - fail("Expecting IllegalArgumentException"); + Assert.fail("Expecting IllegalArgumentException"); } catch (IllegalArgumentException ex) { // expected } ((ResizableDoubleArray)da).setExpansionMode( ResizableDoubleArray.ADDITIVE_MODE); - assertEquals(ResizableDoubleArray.ADDITIVE_MODE, + Assert.assertEquals(ResizableDoubleArray.ADDITIVE_MODE, ((ResizableDoubleArray)da).getExpansionMode()); try { ((ResizableDoubleArray)da).setExpansionMode(-1); - fail ("Expecting IllegalArgumentException"); + Assert.fail("Expecting IllegalArgumentException"); } catch (IllegalArgumentException ex) { // expected } } + @Test public void testEqualsAndHashCode() throws Exception { // Wrong type ResizableDoubleArray first = new ResizableDoubleArray(); Double other = new Double(2); - assertFalse(first.equals(other)); + Assert.assertFalse(first.equals(other)); // Null other = null; - assertFalse(first.equals(other)); + Assert.assertFalse(first.equals(other)); // Reflexive - assertTrue(first.equals(first)); + Assert.assertTrue(first.equals(first)); // Argumentless constructor ResizableDoubleArray second = new ResizableDoubleArray(); @@ -526,15 +538,15 @@ public class ResizableDoubleArrayTest ex } private void verifyEquality(ResizableDoubleArray a, ResizableDoubleArray b) { - assertTrue(b.equals(a)); - assertTrue(a.equals(b)); - assertEquals(a.hashCode(), b.hashCode()); + Assert.assertTrue(b.equals(a)); + Assert.assertTrue(a.equals(b)); + Assert.assertEquals(a.hashCode(), b.hashCode()); } private void verifyInequality(ResizableDoubleArray a, ResizableDoubleArray b) { - assertFalse(b.equals(a)); - assertFalse(a.equals(b)); - assertFalse(a.hashCode() == b.hashCode()); + Assert.assertFalse(b.equals(a)); + Assert.assertFalse(a.equals(b)); + Assert.assertFalse(a.hashCode() == b.hashCode()); } } Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/TransformerMapTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/TransformerMapTest.java?rev=1083514&r1=1083513&r2=1083514&view=diff ============================================================================== --- commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/TransformerMapTest.java (original) +++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/TransformerMapTest.java Sun Mar 20 17:24:14 2011 @@ -18,97 +18,106 @@ package org.apache.commons.math.util; import org.apache.commons.math.TestUtils; +import org.junit.Assert; +import org.junit.Test; -import junit.framework.TestCase; /** * @version $Revision$ $Date$ */ -public class TransformerMapTest extends TestCase { +public class TransformerMapTest { /** * */ + @Test public void testPutTransformer(){ NumberTransformer expected = new DefaultTransformer(); TransformerMap map = new TransformerMap(); map.putTransformer(TransformerMapTest.class, expected); - assertEquals(expected, map.getTransformer(TransformerMapTest.class)); + Assert.assertEquals(expected, map.getTransformer(TransformerMapTest.class)); } /** * */ + @Test public void testContainsClass(){ NumberTransformer expected = new DefaultTransformer(); TransformerMap map = new TransformerMap(); map.putTransformer(TransformerMapTest.class, expected); - assertTrue(map.containsClass(TransformerMapTest.class)); + Assert.assertTrue(map.containsClass(TransformerMapTest.class)); } /** * */ + @Test public void testContainsTransformer(){ NumberTransformer expected = new DefaultTransformer(); TransformerMap map = new TransformerMap(); map.putTransformer(TransformerMapTest.class, expected); - assertTrue(map.containsTransformer(expected)); + Assert.assertTrue(map.containsTransformer(expected)); } /** * */ + @Test public void testRemoveTransformer(){ NumberTransformer expected = new DefaultTransformer(); TransformerMap map = new TransformerMap(); map.putTransformer(TransformerMapTest.class, expected); - assertTrue(map.containsClass(TransformerMapTest.class)); - assertTrue(map.containsTransformer(expected)); + Assert.assertTrue(map.containsClass(TransformerMapTest.class)); + Assert.assertTrue(map.containsTransformer(expected)); map.removeTransformer(TransformerMapTest.class); - assertFalse(map.containsClass(TransformerMapTest.class)); - assertFalse(map.containsTransformer(expected)); + Assert.assertFalse(map.containsClass(TransformerMapTest.class)); + Assert.assertFalse(map.containsTransformer(expected)); } /** * */ + @Test public void testClear(){ NumberTransformer expected = new DefaultTransformer(); TransformerMap map = new TransformerMap(); map.putTransformer(TransformerMapTest.class, expected); - assertTrue(map.containsClass(TransformerMapTest.class)); + Assert.assertTrue(map.containsClass(TransformerMapTest.class)); map.clear(); - assertFalse(map.containsClass(TransformerMapTest.class)); + Assert.assertFalse(map.containsClass(TransformerMapTest.class)); } /** * */ + @Test public void testClasses(){ NumberTransformer expected = new DefaultTransformer(); TransformerMap map = new TransformerMap(); map.putTransformer(TransformerMapTest.class, expected); - assertTrue(map.classes().contains(TransformerMapTest.class)); + Assert.assertTrue(map.classes().contains(TransformerMapTest.class)); } /** * */ + @Test public void testTransformers(){ NumberTransformer expected = new DefaultTransformer(); TransformerMap map = new TransformerMap(); map.putTransformer(TransformerMapTest.class, expected); - assertTrue(map.transformers().contains(expected)); + Assert.assertTrue(map.transformers().contains(expected)); } + @Test public void testSerial(){ NumberTransformer expected = new DefaultTransformer(); TransformerMap map = new TransformerMap(); map.putTransformer(TransformerMapTest.class, expected); - assertEquals(map, TestUtils.serializeAndRecover(map)); + Assert.assertEquals(map, TestUtils.serializeAndRecover(map)); } }
