commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From billbar...@apache.org
Subject svn commit: r769224 - /commons/proper/math/trunk/src/test/org/apache/commons/math/util/OpenIntToFieldTest.java
Date Tue, 28 Apr 2009 02:42:57 GMT
Author: billbarker
Date: Tue Apr 28 02:42:57 2009
New Revision: 769224

URL: http://svn.apache.org/viewvc?rev=769224&view=rev
Log:
Adding unit test for OpenIntToFieldHashMap

Added:
    commons/proper/math/trunk/src/test/org/apache/commons/math/util/OpenIntToFieldTest.java
  (with props)

Added: commons/proper/math/trunk/src/test/org/apache/commons/math/util/OpenIntToFieldTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/org/apache/commons/math/util/OpenIntToFieldTest.java?rev=769224&view=auto
==============================================================================
--- commons/proper/math/trunk/src/test/org/apache/commons/math/util/OpenIntToFieldTest.java
(added)
+++ commons/proper/math/trunk/src/test/org/apache/commons/math/util/OpenIntToFieldTest.java
Tue Apr 28 02:42:57 2009
@@ -0,0 +1,300 @@
+package org.apache.commons.math.util;
+
+import java.util.ConcurrentModificationException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Random;
+import java.util.Set;
+import java.util.Map.Entry;
+
+import org.apache.commons.math.Field;
+import org.apache.commons.math.FieldElement;
+import org.apache.commons.math.fraction.Fraction;
+import org.apache.commons.math.fraction.FractionConversionException;
+import org.apache.commons.math.fraction.FractionField;
+
+import junit.framework.TestCase;
+
+public class OpenIntToFieldTest extends TestCase {
+
+    private Map<Integer, Fraction> javaMap = new HashMap<Integer, Fraction>();
+    private FractionField field = FractionField.getInstance();
+
+    @Override
+    protected void setUp() throws Exception {
+        javaMap.put(50, new Fraction(100.0));
+        javaMap.put(75, new Fraction(75.0));
+        javaMap.put(25, new Fraction(500.0));
+        javaMap.put(Integer.MAX_VALUE, new Fraction(Integer.MAX_VALUE));
+        javaMap.put(0, new Fraction(-1.0));
+        javaMap.put(1, new Fraction(0.0));
+        javaMap.put(33, new Fraction(-0.1));
+        javaMap.put(23234234, new Fraction(-242343.0));
+        javaMap.put(23321, new Fraction (Integer.MIN_VALUE));
+        javaMap.put(-4444, new Fraction(332.0));
+        javaMap.put(-1, new Fraction(-2323.0));
+        javaMap.put(Integer.MIN_VALUE, new Fraction(44.0));
+
+        /* Add a few more to cause the table to rehash */
+        javaMap.putAll(generate());
+
+    }
+
+    private Map<Integer, Fraction> generate() {
+        Map<Integer, Fraction> map = new HashMap<Integer, Fraction>();
+        Random r = new Random();
+        double dd=0;
+        for (int i = 0; i < 2000; ++i)
+            dd = r.nextDouble(); 
+            try {
+                map.put(r.nextInt(), new Fraction(dd));
+            } catch (FractionConversionException e) {
+                throw new IllegalStateException("Invalid :"+dd, e);
+            }
+        return map;
+    }
+
+    private OpenIntToFieldHashMap<Fraction> createFromJavaMap(Field<Fraction>
field) {
+        OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field);
+        for (Map.Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) {
+            map.put(mapEntry.getKey(), mapEntry.getValue());
+        }
+        return map;
+    }
+    
+    public void testPutAndGetWith0ExpectedSize() {
+        OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field,0);
+        assertPutAndGet(map);
+    }
+    
+    public void testPutAndGetWithExpectedSize() {
+        OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field,500);
+        assertPutAndGet(map);
+    }
+
+    public void testPutAndGet() {
+        OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field);
+        assertPutAndGet(map);
+    }
+
+    private void assertPutAndGet(OpenIntToFieldHashMap<Fraction> map) {
+        assertPutAndGet(map, 0, new HashSet<Integer>());
+    }
+
+    private void assertPutAndGet(OpenIntToFieldHashMap<Fraction> map, int mapSize,
+            Set<Integer> keysInMap) {
+        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()));
+        }
+    }
+
+    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()));
+        }
+    }
+
+    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()));
+        }
+    }
+
+    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())));
+    }
+
+    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)));
+    }
+
+    public void testRemove() {
+        OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field);
+        int mapSize = javaMap.size();
+        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())));
+        }
+
+        /* Ensure that put and get still work correctly after removals */
+        assertPutAndGet(map);
+    }
+
+    /* This time only remove some entries */
+    public void testRemove2() {
+        OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field);
+        int mapSize = javaMap.size();
+        int count = 0;
+        Set<Integer> keysInMap = new HashSet<Integer>(javaMap.keySet());
+        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())));
+            if (count++ > 5)
+                break;
+        }
+
+        /* Ensure that put and get still work correctly after removals */
+        assertPutAndGet(map, mapSize, keysInMap);
+    }
+
+    public void testRemoveFromEmpty() {
+        OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field);
+        assertTrue(field.getZero().equals(map.remove(50)));
+    }
+
+    public void testRemoveAbsent() {
+        Map<Integer, Fraction> generated = generateAbsent();
+
+        OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field);
+        int mapSize = map.size();
+        
+        for (Map.Entry<Integer, Fraction> mapEntry : generated.entrySet()) {
+            map.remove(mapEntry.getKey());
+            assertEquals(mapSize, map.size());
+            assertTrue(field.getZero().equals(map.get(mapEntry.getKey())));
+        }
+    }
+
+    /**
+     * Returns a map with at least 100 elements where each element is absent from javaMap.
+     */
+    private Map<Integer, Fraction> generateAbsent() {
+        Map<Integer, Fraction> generated = new HashMap<Integer, Fraction>();
+        do {
+            generated.putAll(generate());
+            for (Integer key : javaMap.keySet())
+                generated.remove(key);
+        } while (generated.size() < 100);
+        return generated;
+    }
+
+    public void testCopy() {
+        OpenIntToFieldHashMap<Fraction> copy =
+            new OpenIntToFieldHashMap<Fraction>(createFromJavaMap(field));
+        assertEquals(javaMap.size(), copy.size());
+
+        for (Map.Entry<Integer, Fraction> mapEntry : javaMap.entrySet())
+            assertEquals(mapEntry.getValue(), copy.get(mapEntry.getKey()));
+    }
+
+    public void testContainsKey() {
+        OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field);
+        for (Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) {
+            assertTrue(map.containsKey(mapEntry.getKey()));
+        }
+        for (Map.Entry<Integer, Fraction> mapEntry : generateAbsent().entrySet()) {
+            assertFalse(map.containsKey(mapEntry.getKey()));
+        }
+        for (Entry<Integer, Fraction> mapEntry : javaMap.entrySet()) {
+            int key = mapEntry.getKey();
+            assertTrue(map.containsKey(key));
+            map.remove(key);
+            assertFalse(map.containsKey(key));
+        }
+    }
+
+    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());
+            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));
+        }
+        assertFalse(iterator.hasNext());
+        try {
+            iterator.advance();
+            fail("an exception should have been thrown");
+        } catch (NoSuchElementException nsee) {
+            // expected
+        }
+    }
+
+    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");
+        } catch (ConcurrentModificationException cme) {
+            // expected
+        }
+    }
+
+    /**
+     * Regression test for a bug in findInsertionIndex where the hashing in the second probing
+     * loop was inconsistent with the first causing duplicate keys after the right sequence
+     * of puts and removes.
+     */
+    public void testPutKeysWithCollisions() {
+        OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field);
+        int key1 = -1996012590;
+        Fraction value1 = new Fraction(1);
+        map.put(key1, value1);
+        int key2 = 835099822;
+        map.put(key2, value1);
+        int key3 = 1008859686;
+        map.put(key3, value1);
+        assertEquals(value1, map.get(key3));
+        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());
+    }
+    
+    /**
+     * Similar to testPutKeysWithCollisions() but exercises the codepaths in a slightly
+     * different manner.
+     */
+    public void testPutKeysWithCollision2() {
+        OpenIntToFieldHashMap<Fraction>map = new OpenIntToFieldHashMap<Fraction>(field);
+        int key1 = 837989881;
+        Fraction value1 = new Fraction(1);
+        map.put(key1, value1);
+        int key2 = 476463321;
+        map.put(key2, value1);
+        assertEquals(2, map.size());
+        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));
+    }
+
+
+}

Propchange: commons/proper/math/trunk/src/test/org/apache/commons/math/util/OpenIntToFieldTest.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message