broken / TMap refactoring

assira/src/test/java/net/ranides/assira/collection/mockup/TMap.java

@@ -23,13 +23,16 @@ import net.ranides.assira.collection.arrays.ArrayAllocator;
  */
 public abstract class TMap<K,V> {
     
-    public final class TItem {
+    public static final class TItem<K,V> {
+        
+        private final TMap<K,V> that;
         
         private final K key;
         
         private final V value;
 
-        protected TItem(K key, V value) {
+        protected TItem(TMap<K,V> that, K key, V value) {
+            this.that = that;
             this.key = key;
             this.value = value;
         }
@@ -42,22 +45,36 @@ public abstract class TMap<K,V> {
             return value;
         }
         
+        public int keyInt() {
+            return (Integer)key;
+        }
+        
+        public int valueInt() {
+            return (Integer)value;
+        }
+        
         public Entry<K,V> entry() {
             return new AbstractMap.SimpleImmutableEntry<>(key, value);
         }
         
-        public TItem next() {
-            return new TItem(nextKey(key), nextValue(value));
+        public TItem<K,V> next() {
+            return new TItem<>(that, that.nextKey(key), that.nextValue(value));
         }
         
     }
     
-    public final class TItems implements Iterable<TItem> {
+    public static final class TItems<K,V> implements Iterable<TItem<K,V>> {
         
-        private final List<TItem> data = new ArrayList<>();
+        private final TMap<K,V> that;
+        
+        private final List<TItem<K,V>> data = new ArrayList<>();
+        
+        protected TItems(TMap<K,V> that) {
+            this.that = that;
+        }
         
         public K[] keys() {
-            K[] array = ArrayAllocator.allocate(key(0).getClass(), data.size());
+            K[] array = ArrayAllocator.allocate(that.key(0).getClass(), data.size());
             for(int i=0,n=data.size(); i<n; i++) {
                 array[i] = data.get(i).key();
             }
@@ -65,13 +82,29 @@ public abstract class TMap<K,V> {
         }
         
         public V[] values() {
-            V[] array = ArrayAllocator.allocate(value(0).getClass(), data.size());
+            V[] array = ArrayAllocator.allocate(that.value(0).getClass(), data.size());
             for(int i=0,n=data.size(); i<n; i++) {
                 array[i] = data.get(i).value();
             }
             return array;
         }
         
+        public int[] keysInt() {
+            int[] array = new int[data.size()];
+            for(int i=0,n=data.size(); i<n; i++) {
+                array[i] = data.get(i).keyInt();
+            }
+            return array;
+        }
+        
+        public int[] valuesInt() {
+            int[] array = new int[data.size()];
+            for(int i=0,n=data.size(); i<n; i++) {
+                array[i] = data.get(i).valueInt();
+            }
+            return array;
+        }
+        
         public Entry<K,V>[] entries() {
             Entry<K,V> array[] = new Entry[data.size()];
             for(int i=0, n=data.size(); i<n; i++) {
@@ -88,15 +121,15 @@ public abstract class TMap<K,V> {
             return target;
         }
         
-        public TItems next() {
-            TItems items = new TItems();
+        public TItems<K,V> next() {
+            TItems<K,V> items = new TItems(that);
             for(int i=0, n=data.size(); i<n; i++) {
                 items.data.add(data.get(i).next());
             }
             return items;
         }
         
-        public TItems shuffle(long seed) {
+        public TItems<K,V> shuffle(long seed) {
             int n = data.size();
             Random random = new Random(seed);
             for(int i=0; i<n; i++) {
@@ -113,21 +146,25 @@ public abstract class TMap<K,V> {
             data.set(bi, a);
         }
         
-        public TItems add(TItem item) {
+        public TItems<K,V> add(TItem item) {
             data.add(item);
             return this;
         }
         
-        public TItems add(TItems items) {
+        public TItems<K,V> add(TItems items) {
             data.addAll(items.data);
             return this;
         }
 
         @Override
-        public Iterator<TItem> iterator() {
+        public Iterator<TItem<K,V>> iterator() {
             return data.iterator();
         }
         
+        public TItem<K,V> at(int index) {
+            return data.get(index);
+        }
+        
     }
     
     protected abstract K key(int index);
@@ -138,33 +175,33 @@ public abstract class TMap<K,V> {
     
     protected abstract V nextValue(V value);
     
-    public TItem item(int index) {
-        return new TItem(key(index), value(index));
+    public TItem<K,V> item(int index) {
+        return new TItem<>(this, key(index), value(index));
     }
     
-    public TItems list(int... indexes) {
-        TItems ret = new TItems();
+    public TItems<K,V> list(int... indexes) {
+        TItems<K,V> ret = new TItems<>(this);
         for(int i=0; i<indexes.length; i++) {
             ret.data.add(item(indexes[i]));
         }
         return ret;
     }
     
-    public TItems range(int begin, int end) {
-        TItems ret = new TItems();
+    public TItems<K,V> range(int begin, int end) {
+        TItems<K,V> ret = new TItems<>(this);
         for(int i=begin; i<end; i++) {
             ret.data.add(item(i));
         }
         return ret;
     }
     
-    public TItems urange(int begin, int end) {
-        TItems items = range(begin, end);
-        return new TItems().add(items).add(items).add(items.next()).shuffle(777);
+    public TItems<K,V> urange(int begin, int end) {
+        TItems<K,V> items = range(begin, end);
+        return new TItems<>(this).add(items).add(items).add(items.next()).shuffle(777);
     }
     
-    public void put(Map<K,V> target, TItems items) {
-        for(TItem item : items) {
+    public void put(Map<K,V> target, TItems<K,V> items) {
+        for(TItem<K,V> item : items) {
             target.put(item.key(), item.value());
         }
     }

assira/src/test/java/net/ranides/assira/collection/mockup/TPoint.java

@@ -46,6 +46,10 @@ public class TPoint implements Serializable {
         }
         return STD.equals(this, (TPoint)object);
     }
+    
+    private static int zz(int z) {
+        return z & 0x3FF;
+    }
 
     @Override
     public String toString() {
@@ -80,11 +84,6 @@ public class TPoint implements Serializable {
             return HashUtils.hashValues(1, 1199, object.x, object.y, object.z);
         }
 
-        @Override
-        public boolean equals(TPoint value1, TPoint value2) {
-            return 0 == compare(value1, value2);
-        }
-
         @Override
         public int compare(TPoint value1, TPoint value2) {
             int dx = value1.x - value2.x;
@@ -95,8 +94,28 @@ public class TPoint implements Serializable {
         
     };
     
-    private static int zz(int z) {
-        return z & 0x3FF;
-    }
+    public static final TMap<TPoint, Integer> STD_INT_MAP = new TMap<TPoint, Integer>(){
+
+        @Override
+        protected TPoint key(int index) {
+            return new TPoint(index, index, index);
+        }
+
+        @Override
+        protected Integer value(int index) {
+            return index;
+        }
+
+        @Override
+        protected TPoint nextKey(TPoint key) {
+            return new TPoint(key.x, key.y, key.z+1);
+        }
+
+        @Override
+        protected Integer nextValue(Integer value) {
+            return value + 1;
+        }
 
+    };
+    
 }

assira/src/test/java/net/ranides/assira/collection/suite/AHashMapTester.java

@@ -6,9 +6,9 @@
  */
 package net.ranides.assira.collection.suite;
 
+import javax.annotation.Resource;
 import net.ranides.assira.collection.maps.AHashMap;
-import net.ranides.assira.collection.mockup.TPoint;
-import static net.ranides.assira.collection.mockup.TPointUtils.*;
+import net.ranides.assira.collection.mockup.TMap;
 import net.ranides.assira.junit.QAssert;
 import org.junit.Test;
 
@@ -16,32 +16,35 @@ import org.junit.Test;
  *
  * @author Ranides Atterwim <ranides@gmail.com>
  */
-public final class AHashMapTester {
+public final class AHashMapTester<K> {
 
+    @Resource
+    private TMap<K,Integer> $map;
+    
     @Test
-    public void basicTrim(AHashMap<TPoint, Integer> target) {
-        $put(target, $ukeys(1024));
+    public void basicTrim(AHashMap<K, Integer> target) {
+        $map.put(target, $map.urange(0, 1024));
         target.clear();
-        $put(target, $ukeys(128));
+        $map.put(target, $map.urange(0, 128));
         target.trim();
     }
     
     @Test
-    public void basicTrimN1(AHashMap<TPoint, Integer> target) {
+    public void basicTrimN1(AHashMap<K, Integer> target) {
         basicTrim(target, 5*32, 32, 1024);
     }
     
     @Test
-    public void basicTrimN2(AHashMap<TPoint, Integer>target) {
+    public void basicTrimN2(AHashMap<K, Integer>target) {
         QAssert.assertThrows(IllegalArgumentException.class, () -> 
             basicTrim(target, 5*32, 32, 1)
         );
     }
     
-    private static void basicTrim(AHashMap<TPoint, Integer> target, int put1st, int put2nd, int n) {
-        $put(target, $ukeys(put1st));
+    private void basicTrim(AHashMap<K, Integer> target, int put1st, int put2nd, int n) {
+        $map.put(target, $map.urange(0, put1st));
         target.clear();
-        $put(target, $ukeys(put2nd));
+        $map.put(target, $map.urange(0, put2nd));
         target.trim(n);
     }
     

assira/src/test/java/net/ranides/assira/collection/suite/CollectionSuite.java

@@ -6,6 +6,7 @@
  */
 package net.ranides.assira.collection.suite;
 
+import net.ranides.assira.collection.mockup.TPoint;
 import net.ranides.assira.junit.QTesterSuite;
 
 /**
@@ -23,7 +24,7 @@ public final class CollectionSuite {
         .append(new MapTester())
         .append(new AHashMapTester())
         .append(new SortedMapTester())
-        ;
+        .param("$map", TPoint.STD_INT_MAP);
     
     public static final QTesterSuite INT_SUITE = new QTesterSuite(System.err)
         .append(new IntMapTester())

assira/src/test/java/net/ranides/assira/collection/suite/LookupTester.java

@@ -9,13 +9,17 @@ package net.ranides.assira.collection.suite;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Set;
+import javax.annotation.Resource;
 import net.ranides.assira.collection.IntCollection;
 import net.ranides.assira.collection.iterators.IntIterator;
 import net.ranides.assira.collection.lookups.Lookup;
-import net.ranides.assira.collection.mockup.TPoint;
-import net.ranides.assira.collection.mockup.ValueEnum;
-import static net.ranides.assira.collection.mockup.ValueEnum.*;
-import static net.ranides.assira.collection.mockup.TPointUtils.*;
+import net.ranides.assira.collection.mockup.TMap;
+import net.ranides.assira.collection.mockup.TMap.TItem;
+import net.ranides.assira.collection.mockup.TMap.TItems;
+//import net.ranides.assira.collection.mockup.TPoint;
+//import net.ranides.assira.collection.mockup.ValueEnum;
+//import static net.ranides.assira.collection.mockup.ValueEnum.*;
+//import static net.ranides.assira.collection.mockup.TPointUtils.*;
 import net.ranides.assira.junit.QAssert;
 import static org.junit.Assert.*;
 import org.junit.Test;
@@ -25,7 +29,10 @@ import org.junit.Test;
  * @author Ranides Atterwim <ranides@gmail.com>
  */
 @SuppressWarnings("PMD.MethodNameRules")
-public final class LookupTester {
+public final class LookupTester<K> {
+    
+    @Resource
+    private TMap<K,Integer> $map;
     
     private static final int BASIC_PUT_MANY = 128;
     
@@ -38,11 +45,10 @@ public final class LookupTester {
     private static final int BASIC_REMOVE_RANDOM = 273;
     
     @Test
-    public void basicPut(Lookup<TPoint> target) {
+    public void basicPut(Lookup<K> target) {
         int prev = target.size();
-        int value = $value(A1);
-        for (TPoint point : $keys(BASIC_PUT_MANY)) {
-            target.put(point, value++);
+        for(TItem<K,Integer> item :$map.range(0, BASIC_PUT_MANY)) {
+            target.put(item.key(), item.value());
         }
         assertEquals(prev + BASIC_PUT_MANY, target.size());
         
@@ -50,105 +56,100 @@ public final class LookupTester {
     }
     
     @Test
-    public void logicPut(Lookup<TPoint> target) {
+    public void logicPut(Lookup<K> target) {
         int prev = target.size();
-        target.put($key(A1), $value(A1));
+        TItem<K,Integer> item1 = $map.item(1);
+        TItem<K,Integer> item2 = $map.item(1).next();
+        target.put(item1.key(), item1.value());
         assertEquals(prev + 1, target.size());
         
-        target.put($key(A1_EQ), $value(A1_EQ)); // identical hash & eq
+        target.put(item1.key(), item1.value());
         assertEquals(prev + 1, target.size());
         
-        target.put($key(A1_NE), $value(A1_NE)); // identical hash but not eq
+        target.put(item2.key(), item2.value()); // identical hash but not eq
         assertEquals(prev + 2, target.size());
     }
     
     @Test
-    public void basicPutReplace(Lookup<TPoint> target) {
+    public void basicPutReplace(Lookup<K> target) {
         int prev = target.size();
-        for (TPoint point : $ukeys(BASIC_PUT_REPLACE)) {
-            target.put(point, $value(B1));
+        for (TItem<K,Integer> item : $map.urange(0, BASIC_PUT_REPLACE)) {
+            target.put(item.key(), item.value());
         }
         assertEquals(prev + (2 * BASIC_PUT_REPLACE), target.size());
     }
 	
 	@Test
-    public void basicPutRandom(Lookup<TPoint> target) {
+    public void basicPutRandom(Lookup<K> target) {
         int prev = target.size();
-        for (TPoint point : $shuffle($ukeys(BASIC_PUT_RANDOM))) {
-            target.put(point, $value(B1));
+        for (TItem<K,Integer> item : $map.urange(0, BASIC_PUT_RANDOM)) {
+            target.put(item.key(), item.value());
         }
         assertEquals(prev + (2 * BASIC_PUT_RANDOM), target.size());
     }
 	    
     @Test
-    public void basicRemove(Lookup<TPoint> target) {
+    public void basicRemove(Lookup<K> target) {
         target.defaultReturnValue(-1);
-        $put(target, A1, B1, C1);
+        $map.put(target, $map.list(1,2,3));
         
-        assertNotRemove(target, A1_NE);
+        assertNotRemove(target, $map.item(1).next());
         
-        assertRemove(target, A1_EQ, A1);
-        assertRemove(target, B1, B1);
-        assertRemove(target, C1, C1);
+        assertRemove(target, $map.item(1).key(), $map.item(1).value());
+        assertRemove(target, $map.item(2).key(), $map.item(2).value());
+        assertRemove(target, $map.item(3).key(), $map.item(3).value());
         
         assertEquals(0, target.size());
         
-        assertNotRemove(target, C1);
+        assertNotRemove(target, $map.item(3));
     }
     
     @Test
-    public void basicRemoveAll(Lookup<TPoint> target) {
+    public void basicRemoveAll(Lookup<K> target) {
         assertEquals(0, target.size());
-        TPoint[] keys = $keys(BASIC_REMOVE_ALL);
-        int[] values = $values(BASIC_REMOVE_ALL);
+        TItems<K,Integer> items = $map.range(0, BASIC_REMOVE_ALL);
         
-        for(int i=0; i<BASIC_REMOVE_ALL; i++) {
-            target.put(keys[i], values[i]);
-        }
+        $map.put(target, items);
         assertEquals(BASIC_REMOVE_ALL, target.size());
         
         for(int i=0; i<BASIC_REMOVE_ALL; i++) {
-            assertEquals(values[i], target.removeInt(keys[i]));
+            assertEquals(items.at(i).valueInt(), target.removeInt(items.at(i).key()));
             assertEquals(BASIC_REMOVE_ALL-i-1, target.size());
         }
         assertEquals(0, target.size());
     }
     
     @Test
-    public void basicRemoveRandom(Lookup<TPoint> target) {
+    public void basicRemoveRandom(Lookup<K> target) {
         assertEquals(0, target.size());
-        TPoint[] keys = $keys(BASIC_REMOVE_RANDOM);
-        int[] values = $values(BASIC_REMOVE_RANDOM);
+        TItems<K,Integer> items = $map.range(0, BASIC_REMOVE_RANDOM);
         
-        for(int i=0; i<BASIC_REMOVE_RANDOM; i++) {
-            target.put(keys[i], values[i]);
-        }
+        $map.put(target, items);
         assertEquals(BASIC_REMOVE_RANDOM, target.size());
 
-        $shuffle(keys, values);
+        items.shuffle(777);
         for(int i=0; i<BASIC_REMOVE_RANDOM; i++) {
-            assertEquals(values[i], target.removeInt(keys[i]));
+            assertEquals(items.at(i).valueInt(), target.removeInt(items.at(i).key()));
             assertEquals(BASIC_REMOVE_RANDOM-i-1, target.size());
         }
         assertEquals(0, target.size());
     }
     
     @Test
-    public void basicGet(Lookup<TPoint> target) {
-        assertEquals(0, target.getInt($key(A1)));
-        
-        $put(target, A1, B1, C1);
+    public void basicGet(Lookup<K> target) {
+        assertEquals(0, target.getInt($map.item(1).key()));
+
+        $map.put(target, $map.list(1,2,3));
         assertEquals(3, target.size());
-        assertEquals(0, target.getInt($key(A1_NE)));
+        assertEquals(0, target.getInt($map.item(1).next().key()));
         
-        assertEquals($value(A1), target.getInt($key(A1)));
-        assertEquals($value(A1), target.getInt($key(A1_EQ)));
-        assertEquals($value(B1), target.getInt($key(B1)));
-        assertEquals($value(C1), target.getInt($key(C1)));
+        assertEquals($map.item(1).valueInt(), target.getInt($map.item(1).key()));
+        assertEquals($map.item(2).valueInt(), target.getInt($map.item(2).key()));
+        assertEquals($map.item(3).valueInt(), target.getInt($map.item(3).key()));
     }
     
     @Test
-    public void logicRemove(Lookup<TPoint> target) {
+    public void logicRemove(Lookup<K> target) {
         target.defaultReturnValue(-1);
         $put(target, A1, B1, C1);
         
@@ -171,7 +172,7 @@ public final class LookupTester {
     }
     
     @Test
-    public void basicContains(Lookup<TPoint> target) {
+    public void basicContains(Lookup<K> target) {
         assertEquals(0, target.size());
         $put(target, A1, B1);
         
@@ -184,16 +185,16 @@ public final class LookupTester {
     }
     
 	@Test
-    public void basicEntrySet_Iterator(Lookup<TPoint> target) {
-        Set<Lookup.LookupEntry<TPoint>> set = target.fastEntrySet();
+    public void basicEntrySet_Iterator(Lookup<K> target) {
+        Set<Lookup.LookupEntry<K>> set = target.fastEntrySet();
 		
         assertEquals(0, set.size());
 		$put(target, A1, A1_NE, B1, C1);
 		assertEquals(4, set.size());
         
-        Iterator<Lookup.LookupEntry<TPoint>> iterator = set.iterator();
+        Iterator<Lookup.LookupEntry<K>> iterator = set.iterator();
         while(iterator.hasNext()) {
-            Lookup.LookupEntry<TPoint> entry = iterator.next();
+            Lookup.LookupEntry<K> entry = iterator.next();
             assertEquals(target.getInt(entry.getKey()), entry.getIntValue());
         }
         
@@ -201,16 +202,16 @@ public final class LookupTester {
 	}
     
     @Test
-    public void basicEntrySet_Iterator_SetValue(Lookup<TPoint> target) {
-        Set<Lookup.LookupEntry<TPoint>> set = target.fastEntrySet();
+    public void basicEntrySet_Iterator_SetValue(Lookup<K> target) {
+        Set<Lookup.LookupEntry<K>> set = target.fastEntrySet();
                 
 		assertEquals(0, set.size());
 		$put(target, A1, A1_NE, B1, C1);
 		
-		Iterator<Lookup.LookupEntry<TPoint>> iterator = set.iterator();
+		Iterator<Lookup.LookupEntry<K>> iterator = set.iterator();
 		while(iterator.hasNext()) {
-			Lookup.LookupEntry<TPoint> entry = iterator.next();
-			TPoint key = entry.getKey();
+			Lookup.LookupEntry<K> entry = iterator.next();
+			K key = entry.getKey();
 			if(TPoint.SUM.equals(key, $key(A1_EQ))) {
                 entry.setValue($value(D1));
             }
@@ -225,7 +226,7 @@ public final class LookupTester {
 	}
     
     @Test
-    public void basicValues_Contains(Lookup<TPoint> target) {
+    public void basicValues_Contains(Lookup<K> target) {
         IntCollection set = target.values();
 		
         assertEquals(0, set.size());
@@ -242,7 +243,7 @@ public final class LookupTester {
 	}
     
     @Test
-    public void basicValues_Remove(Lookup<TPoint> target) {
+    public void basicValues_Remove(Lookup<K> target) {
         IntCollection set = target.values();
 		
         basicValues_Contains(target);
@@ -258,7 +259,7 @@ public final class LookupTester {
 	}
    
     @Test
-    public void basicValues_Iterator(Lookup<TPoint> target) {
+    public void basicValues_Iterator(Lookup<K> target) {
         IntCollection set = target.values();
 		
         assertEquals(0, set.size());
@@ -276,7 +277,7 @@ public final class LookupTester {
     
     @SuppressWarnings("unchecked")
     @Test
-    public void basicValues_Iterator_Remove(Lookup<TPoint> target) {
+    public void basicValues_Iterator_Remove(Lookup<K> target) {
         IntCollection set = target.values();
         
 		assertEquals(0, set.size());
@@ -305,26 +306,26 @@ public final class LookupTester {
         assertEquals(0, target.size());
 	}
         
-    private static void assertRemove(Lookup<TPoint> target, ValueEnum key, ValueEnum prev) {
+    private void assertRemove(Lookup<K> target, K key, Integer prev) {
         int size = target.size();
-        assertEquals($value(prev), target.removeInt($key(key)));
+        assertEquals(prev.intValue(), target.removeInt(key));
         assertEquals(size-1, target.size());
     }
     
-    private static void assertNotRemove(Lookup<TPoint> target, ValueEnum key) {
+    private void assertNotRemove(Lookup<K> target, TItem<K,Integer> item) {
         int size = target.size();
-        assertEquals(target.defaultReturnValue(), target.removeInt($key(key)));
+        assertEquals(target.defaultReturnValue(), target.removeInt(item.key()));
         assertEquals(size, target.size());
     }
     
-    private static void assertContains(Lookup<TPoint> target, ValueEnum key, ValueEnum value) {
-        assertEquals(true, target.containsKey($key(key)));
-        assertEquals($value(value), target.getInt($key(key)));
+    private void assertContains(Lookup<K> target, TItem<K,Integer> item) {
+        assertEquals(true, target.containsKey(item.key()));
+        assertEquals(item.valueInt(), target.getInt(item.key()));
     }
     
-    private static void assertNotContains(Lookup<TPoint> target, ValueEnum key) {
-        assertEquals(false, target.containsKey($key(key)));
-        assertEquals(target.defaultReturnValue(), target.getInt($key(key)));
+    private void assertNotContains(Lookup<K> target, TItem<K,Integer> item) {
+        assertEquals(false, target.containsKey(item.key()));
+        assertEquals(target.defaultReturnValue(), target.getInt(item.key()));
     }
     
 }