fix: CollectionUtils unchecked

tests

assira/pom.xml

@@ -39,12 +39,12 @@
                                 <exclude>net/ranides/assira/collection/HashIntComparator.class</exclude>
                                 <exclude>net/ranides/assira/collection/IntComparator.class</exclude>
                                 
-<!--                                <exclude>net/ranides/assira/collection/arrays/ArrayAllocator.class</exclude>-->
+                                <exclude>net/ranides/assira/collection/arrays/ArrayAllocator.class</exclude>
                                 <exclude>net/ranides/assira/collection/arrays/ArraySort.class</exclude>
                                 <exclude>net/ranides/assira/collection/arrays/IntArraySort.class</exclude>
-<!--                                <exclude>net/ranides/assira/collection/arrays/NativeArray$*</exclude>-->
-<!--                                <exclude>net/ranides/assira/collection/arrays/NativeArray.class</exclude>-->
-<!--                                <exclude>net/ranides/assira/collection/arrays/NativeArrayAllocator.class</exclude>-->
+                                <exclude>net/ranides/assira/collection/arrays/NativeArray$*</exclude>
+                                <exclude>net/ranides/assira/collection/arrays/NativeArray.class</exclude>
+                                <exclude>net/ranides/assira/collection/arrays/NativeArrayAllocator.class</exclude>
                                 <exclude>net/ranides/assira/collection/arrays/NativeArraySort$*</exclude>
                                 <exclude>net/ranides/assira/collection/arrays/NativeArraySort.class</exclude>
                                 
@@ -143,8 +143,8 @@
                                 <exclude>net/ranides/assira/collection/sets/RBTreeSet$*</exclude>
                                 <exclude>net/ranides/assira/collection/sets/RBTreeSet.class</exclude>
                                 
-                                <exclude>net/ranides/assira/events/CoreEvent$*</exclude>
-                                <exclude>net/ranides/assira/events/CoreEvent.class</exclude>
+                                <exclude>net/ranides/assira/events/Events$*</exclude>
+                                <exclude>net/ranides/assira/events/Events.class</exclude>
                                 <exclude>net/ranides/assira/events/EventBinding$*</exclude>
                                 <exclude>net/ranides/assira/events/EventBinding.class</exclude>
                                 <exclude>net/ranides/assira/events/EventDispatcher.class</exclude>
@@ -164,8 +164,8 @@
                                 
 								<exclude>net/ranides/assira/trace/ExceptionInspector$*</exclude>
 								<exclude>net/ranides/assira/trace/ExceptionInspector.class</exclude>
-								<exclude>net/ranides/assira/trace/StackInspector$*</exclude>
-								<exclude>net/ranides/assira/trace/StackInspector.class</exclude>
+								<!--<exclude>net/ranides/assira/trace/StackInspector$*</exclude>-->
+								<!--<exclude>net/ranides/assira/trace/StackInspector.class</exclude>-->
 								<exclude>net/ranides/assira/trace/ThreadInspector$*</exclude>
 								<exclude>net/ranides/assira/trace/ThreadInspector.class</exclude>
                                 

assira/src/main/java/net/ranides/assira/collection/CollectionUtils.java

@@ -87,18 +87,32 @@ public final class CollectionUtils {
 			}
 
             @Override
+			@SuppressWarnings("unchecked")
             public boolean remove(Object value) {
-                return values.remove(function.invert((T)value));
+				Object v;
+				try {
+					v = function.invert((T)value);
+				} catch(ClassCastException _e) {
+					return false;
+				}
+                return values.remove(v);
             }
 
             @Override
             public boolean add(T value) {
-                return values.add(function.invert((T)value));
+                return values.add(function.invert(value));
             }
 
             @Override
+			@SuppressWarnings("unchecked")
             public boolean contains(Object value) {
-                return values.contains(function.invert((T)value));
+				Object v;
+				try {
+					v = function.invert((T)value);
+				} catch(ClassCastException _e) {
+					return false;
+				}
+                return values.contains(v);
             }
             
 		};

assira/src/main/java/net/ranides/assira/collection/arrays/NativeArrayAllocator.java

@@ -169,7 +169,11 @@ public final class NativeArrayAllocator {
     }
     
     public static NativeArray resize(NativeArray array, int size) {
-        return NativeArrayUtils.copy(array, 0, array.allocate(size), 0, Math.min(size, array.size()));
+		int n = array.size();
+		if(size == n) {
+			return array;
+		}
+        return NativeArrayUtils.copy(array, 0, array.allocate(size), 0, Math.min(size, n));
     }
  
     /**

assira/src/test/java/net/ranides/assira/collection/arrays/ArrayAllocatorTest.java

@@ -1,311 +1,337 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.collection.arrays;
-
-import java.lang.reflect.Array;
-import net.ranides.assira.collection.mockup.TPoint;
-import static net.ranides.assira.junit.NewAssert.assertThrows;
-import org.junit.Test;
-import static org.junit.Assert.*;
-
-/**
- *
- * @author Ranides Atterwim <ranides@gmail.com>
- */
-public class ArrayAllocatorTest {
-    
-    @Test
-    public void testEnsureCapacity() {
-        Integer[] array1 = new Integer[]{ 1,2,3,4,5,6 };
-        
-        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 0));
-        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 3));
-        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 6));
-        
-        Integer[] array2 = ArrayAllocator.ensureCapacity(array1, 8);
-        assertNotSame(array1, array2);
-        assertArrayEquals(new Integer[]{1,2,3,4,5,6,null,null}, array2);
-    }
-    
-    @Test
-    public void testEnsureCapacity_native() {
-        byte[] array1 = new byte[]{ 1,2,3,4,5,6 };
-        
-        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 0));
-        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 3));
-        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 6));
-        
-        byte[] array2 = ArrayAllocator.ensureCapacity(array1, 8);
-        assertNotSame(array1, array2);
-        assertArrayEquals(new byte[]{1,2,3,4,5,6,0,0}, array2);
-    }
-
-    @Test
-    public void testEnsureCapacity_Preserve() {
-        Integer[] array1 = new Integer[]{ 1,2,3,4,5,6 };
-        
-        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 0, 0));
-        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 3, 0));
-        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 6, 0));
-        
-        Integer[] array2 = ArrayAllocator.ensureCapacity(array1, 8, 6);
-        assertNotSame(array1, array2);
-        assertArrayEquals(new Integer[]{1,2,3,4,5,6,null,null}, array2);
-        
-        Integer[] array3 = ArrayAllocator.ensureCapacity(array1, 8, 4);
-        assertNotSame(array1, array3);
-        assertArrayEquals(new Integer[]{1,2,3,4,null,null,null,null}, array3);
-        
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureCapacity(array1, 8, 7);
-        });
-    }
-    
-    @Test
-    public void testEnsureCapacity_Preserve_native() {
-        byte[] array1 = new byte[]{ 1,2,3,4,5,6 };
-        
-        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 0, 0));
-        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 3, 0));
-        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 6, 0));
-        
-        byte[] array2 = ArrayAllocator.ensureCapacity(array1, 8, 6);
-        assertNotSame(array1, array2);
-        assertArrayEquals(new byte[]{1,2,3,4,5,6,0,0}, array2);
-        
-        byte[] array3 = ArrayAllocator.ensureCapacity(array1, 8, 4);
-        assertNotSame(array1, array3);
-        assertArrayEquals(new byte[]{1,2,3,4,0,0,0,0}, array3);
-        
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureCapacity(array1, 8, 7);
-        });
-    }
-
-    @Test
-    public void testEnsureOffsetLength() {
-        Integer[] array1 = new Integer[4];
-        ArrayAllocator.ensureOffsetLength(array1, 1, 2);
-        ArrayAllocator.ensureOffsetLength(array1, 0, 4);
-        ArrayAllocator.ensureOffsetLength(array1, 1, 3);
-        
-        assertThrows(IllegalArgumentException.class, ()-> {
-            ArrayAllocator.ensureOffsetLength(array1, 1, -1);
-        });
-        assertThrows(IllegalArgumentException.class, ()-> {
-            ArrayAllocator.ensureOffsetLength(array1, 8, -1);
-        });
-        
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureOffsetLength(array1, -1, 1);
-        });
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureOffsetLength(array1, 8, 1);
-        });
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureOffsetLength(array1, 3, 10);
-        });
-    }
-   
-    @Test
-    public void testEnsureOffsetLength_native() {
-        byte[] array1 = new byte[4];
-        ArrayAllocator.ensureOffsetLength(array1, 1, 2);
-        ArrayAllocator.ensureOffsetLength(array1, 0, 4);
-        ArrayAllocator.ensureOffsetLength(array1, 1, 3);
-        
-        assertThrows(IllegalArgumentException.class, ()-> {
-            ArrayAllocator.ensureOffsetLength(array1, 1, -1);
-        });
-        assertThrows(IllegalArgumentException.class, ()-> {
-            ArrayAllocator.ensureOffsetLength(array1, 8, -1);
-        });
-        
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureOffsetLength(array1, -1, 1);
-        });
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureOffsetLength(array1, 8, 1);
-        });
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureOffsetLength(array1, 3, 10);
-        });
-    }
-
-    @Test
-    public void testEnsureFromTo() {
-        Integer[] array1 = new Integer[4];
-        ArrayAllocator.ensureFromTo(array1, 1, 3);
-        ArrayAllocator.ensureFromTo(array1, 0, 4);
-        ArrayAllocator.ensureFromTo(array1, 1, 4);
-        
-        assertThrows(IllegalArgumentException.class, ()-> {
-            ArrayAllocator.ensureFromTo(array1, 3, 1);
-        });
-        
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureFromTo(array1, -1, 8);
-        });
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureFromTo(array1, 2, 8);
-        });
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureFromTo(array1, 5, 6);
-        });
-    }
-    
-    @Test
-    public void testEnsureFromTo_native() {
-        byte[] array1 = new byte[4];
-        ArrayAllocator.ensureFromTo(array1, 1, 3);
-        ArrayAllocator.ensureFromTo(array1, 0, 4);
-        ArrayAllocator.ensureFromTo(array1, 1, 4);
-        
-        assertThrows(IllegalArgumentException.class, ()-> {
-            ArrayAllocator.ensureFromTo(array1, 3, 1);
-        });
-        
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureFromTo(array1, -1, 8);
-        });
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureFromTo(array1, 2, 8);
-        });
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
-            ArrayAllocator.ensureFromTo(array1, 5, 6);
-        });
-    }
-    
-    @Test
-    public void testGrow() {
-        Integer[] array1 = new Integer[]{1,2,3};
-        assertSame(array1, ArrayAllocator.grow(array1, 2));
-        assertSame(array1, ArrayAllocator.grow(array1, 3));
-        assertArrayEquals(new Integer[]{1,2,3,null,null,null}, ArrayAllocator.grow(array1, 4));
-        assertArrayEquals(new Integer[]{1,2,3,null,null,null}, ArrayAllocator.grow(array1, 5));
-        assertArrayEquals(new Integer[]{1,2,3,null,null,null}, ArrayAllocator.grow(array1, 6));
-        assertArrayEquals(new Integer[]{1,2,3,null,null,null,null}, ArrayAllocator.grow(array1, 7));
-        assertArrayEquals(new Integer[]{1,2,3,null,null,null,null,null,null}, ArrayAllocator.grow(array1, 9));
-    }
-    
-    @Test
-    public void testGrow_native() {
-        byte[] array1 = new byte[]{1,2,3};
-        assertSame(array1, ArrayAllocator.grow(array1, 2));
-        assertSame(array1, ArrayAllocator.grow(array1, 3));
-        assertArrayEquals(new byte[]{1,2,3,0,0,0}, ArrayAllocator.grow(array1, 4));
-        assertArrayEquals(new byte[]{1,2,3,0,0,0}, ArrayAllocator.grow(array1, 5));
-        assertArrayEquals(new byte[]{1,2,3,0,0,0}, ArrayAllocator.grow(array1, 6));
-        assertArrayEquals(new byte[]{1,2,3,0,0,0,0}, ArrayAllocator.grow(array1, 7));
-        assertArrayEquals(new byte[]{1,2,3,0,0,0,0,0,0}, ArrayAllocator.grow(array1, 9));
-    }
-    
-    @Test
-    public void testGrow_preserve() {
-        Integer[] array1 = new Integer[]{1,2,3};
-        assertSame(array1, ArrayAllocator.grow(array1, 2, 2));
-        assertSame(array1, ArrayAllocator.grow(array1, 3, 2));
-        assertArrayEquals(new Integer[]{1,2,null,null,null,null}, ArrayAllocator.grow(array1, 4, 2));
-        assertArrayEquals(new Integer[]{1,2,null,null,null,null}, ArrayAllocator.grow(array1, 5, 2));
-        assertArrayEquals(new Integer[]{1,2,null,null,null,null}, ArrayAllocator.grow(array1, 6, 2));
-        assertArrayEquals(new Integer[]{1,2,null,null,null,null,null}, ArrayAllocator.grow(array1, 7, 2));
-        assertArrayEquals(new Integer[]{1,2,null,null,null,null,null,null,null}, ArrayAllocator.grow(array1, 9, 2));
-    }
-    
-    @Test
-    public void testGrow_preserve_native() {
-        byte[] array1 = new byte[]{1,2,3};
-        assertSame(array1, ArrayAllocator.grow(array1, 2, 2));
-        assertSame(array1, ArrayAllocator.grow(array1, 3, 2));
-        assertArrayEquals(new byte[]{1,2,0,0,0,0}, ArrayAllocator.grow(array1, 4, 2));
-        assertArrayEquals(new byte[]{1,2,0,0,0,0}, ArrayAllocator.grow(array1, 5, 2));
-        assertArrayEquals(new byte[]{1,2,0,0,0,0}, ArrayAllocator.grow(array1, 6, 2));
-        assertArrayEquals(new byte[]{1,2,0,0,0,0,0}, ArrayAllocator.grow(array1, 7, 2));
-        assertArrayEquals(new byte[]{1,2,0,0,0,0,0,0,0}, ArrayAllocator.grow(array1, 9, 2));
-    }
-    
-    @Test
-    public void testTrim() {
-        Integer[] array1 = new Integer[]{1,2,3};
-        
-        assertSame(array1, ArrayAllocator.trim(array1, 5));
-        assertSame(array1, ArrayAllocator.trim(array1, 3));
-        assertArrayEquals(new Integer[]{1,2}, ArrayAllocator.trim(array1, 2));
-        assertArrayEquals(new Integer[]{1}, ArrayAllocator.trim(array1, 1));
-        assertArrayEquals(new Integer[]{}, ArrayAllocator.trim(array1, 0));
-    }
-        
-    @Test
-    public void testTrim_native() {
-        byte[] array1 = new byte[]{1,2,3};
-        
-        assertSame(array1, ArrayAllocator.trim(array1, 5));
-        assertSame(array1, ArrayAllocator.trim(array1, 3));
-        assertArrayEquals(new byte[]{1,2}, ArrayAllocator.trim(array1, 2));
-        assertArrayEquals(new byte[]{1}, ArrayAllocator.trim(array1, 1));
-        assertArrayEquals(new byte[]{}, ArrayAllocator.trim(array1, 0));
-    }
-    
-    @Test
-    public void testForPrototype() {
-        assertArray(Float[].class, 4, ArrayAllocator.forPrototype(new Float[0], 4));
-        assertArray(Integer[].class, 4, ArrayAllocator.forPrototype(new Integer[0], 4));
-        
-        assertArray(Float[].class, 0, ArrayAllocator.forPrototype(new Float[0], 0));
-        
-        assertArray(Object[].class, 4, ArrayAllocator.forPrototype(new Object[0], 4));
-        
-        assertArray(Object[].class, 0, ArrayAllocator.forPrototype(new Object[0], 0));
-    }
-    
-    @Test
-    public void testForPrototype_native() {
-        assertArray(float[].class, 4, ArrayAllocator.forPrototype(new float[0], 4));
-        assertArray(int[].class, 4, ArrayAllocator.forPrototype(new int[0], 4));
-        assertArray(float[].class, 0, ArrayAllocator.forPrototype(new float[0], 0));
-    }
-    
-    @Test
-    public void testForComponent() {
-        assertArray(Float[].class, 4, ArrayAllocator.forComponent(Float.class, 4));
-        assertArray(Integer[].class, 4, ArrayAllocator.forComponent(Integer.class, 4));
-        assertArray(Object[].class, 4, ArrayAllocator.forComponent(Object.class, 4));
-        assertArray(TPoint[].class, 4, ArrayAllocator.forComponent(TPoint.class, 4));
-        
-        assertArray(Float[].class, 0, ArrayAllocator.forComponent(Float.class, 0));
-        assertArray(Integer[].class, 0, ArrayAllocator.forComponent(Integer.class, 0));
-        assertArray(Object[].class, 0, ArrayAllocator.forComponent(Object.class, 0));
-        assertArray(TPoint[].class, 0, ArrayAllocator.forComponent(TPoint.class, 0));
-    }
-    
-    @Test
-    public void testForComponent_native() {
-        assertArray(byte[].class, 0, ArrayAllocator.forComponent(byte.class, 0));
-        assertArray(short[].class, 0, ArrayAllocator.forComponent(short.class, 0));
-        assertArray(int[].class, 0, ArrayAllocator.forComponent(int.class, 0));
-        assertArray(long[].class, 0, ArrayAllocator.forComponent(long.class, 0));
-        assertArray(float[].class, 0, ArrayAllocator.forComponent(float.class, 0));
-        assertArray(double[].class, 0, ArrayAllocator.forComponent(double.class, 0));
-        assertArray(boolean[].class, 0, ArrayAllocator.forComponent(boolean.class, 0));
-        assertArray(char[].class, 0, ArrayAllocator.forComponent(char.class, 0));
-        
-        assertArray(byte[].class, 4, ArrayAllocator.forComponent(byte.class, 4));
-        assertArray(short[].class, 4, ArrayAllocator.forComponent(short.class, 4));
-        assertArray(int[].class, 4, ArrayAllocator.forComponent(int.class, 4));
-        assertArray(long[].class, 4, ArrayAllocator.forComponent(long.class, 4));
-        assertArray(float[].class, 4, ArrayAllocator.forComponent(float.class, 4));
-        assertArray(double[].class, 4, ArrayAllocator.forComponent(double.class, 4));
-        assertArray(boolean[].class, 4, ArrayAllocator.forComponent(boolean.class, 4));
-        assertArray(char[].class, 4, ArrayAllocator.forComponent(char.class, 4));
-    }
-    
-    private void assertArray(Class<?> type, int size, Object array) {
-        assertEquals(type, array.getClass());
-        assertEquals(size, Array.getLength(array));
-    }
-    
-}
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.collection.arrays;
+
+import java.lang.reflect.Array;
+import net.ranides.assira.collection.mockup.TPoint;
+import static net.ranides.assira.junit.NewAssert.assertThrows;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public class ArrayAllocatorTest {
+    
+    @Test
+    public void testEnsureCapacity() {
+        Integer[] array1 = new Integer[]{ 1,2,3,4,5,6 };
+        
+        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 0));
+        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 3));
+        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 6));
+        
+        Integer[] array2 = ArrayAllocator.ensureCapacity(array1, 8);
+        assertNotSame(array1, array2);
+        assertArrayEquals(new Integer[]{1,2,3,4,5,6,null,null}, array2);
+    }
+    
+    @Test
+    public void testEnsureCapacity_native() {
+        byte[] array1 = new byte[]{ 1,2,3,4,5,6 };
+        
+        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 0));
+        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 3));
+        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 6));
+        
+        byte[] array2 = ArrayAllocator.ensureCapacity(array1, 8);
+        assertNotSame(array1, array2);
+        assertArrayEquals(new byte[]{1,2,3,4,5,6,0,0}, array2);
+    }
+
+    @Test
+    public void testEnsureCapacity_Preserve() {
+        Integer[] array1 = new Integer[]{ 1,2,3,4,5,6 };
+        
+        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 0, 0));
+        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 3, 0));
+        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 6, 0));
+        
+        Integer[] array2 = ArrayAllocator.ensureCapacity(array1, 8, 6);
+        assertNotSame(array1, array2);
+        assertArrayEquals(new Integer[]{1,2,3,4,5,6,null,null}, array2);
+        
+        Integer[] array3 = ArrayAllocator.ensureCapacity(array1, 8, 4);
+        assertNotSame(array1, array3);
+        assertArrayEquals(new Integer[]{1,2,3,4,null,null,null,null}, array3);
+        
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureCapacity(array1, 8, 7);
+        });
+    }
+    
+    @Test
+    public void testEnsureCapacity_Preserve_native() {
+        byte[] array1 = new byte[]{ 1,2,3,4,5,6 };
+        
+        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 0, 0));
+        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 3, 0));
+        assertSame(array1, ArrayAllocator.ensureCapacity(array1, 6, 0));
+        
+        byte[] array2 = ArrayAllocator.ensureCapacity(array1, 8, 6);
+        assertNotSame(array1, array2);
+        assertArrayEquals(new byte[]{1,2,3,4,5,6,0,0}, array2);
+        
+        byte[] array3 = ArrayAllocator.ensureCapacity(array1, 8, 4);
+        assertNotSame(array1, array3);
+        assertArrayEquals(new byte[]{1,2,3,4,0,0,0,0}, array3);
+        
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureCapacity(array1, 8, 7);
+        });
+    }
+
+    @Test
+    public void testEnsureOffsetLength() {
+        Integer[] array1 = new Integer[4];
+        ArrayAllocator.ensureOffsetLength(array1, 1, 2);
+        ArrayAllocator.ensureOffsetLength(array1, 0, 4);
+        ArrayAllocator.ensureOffsetLength(array1, 1, 3);
+        
+        assertThrows(IllegalArgumentException.class, ()-> {
+            ArrayAllocator.ensureOffsetLength(array1, 1, -1);
+        });
+        assertThrows(IllegalArgumentException.class, ()-> {
+            ArrayAllocator.ensureOffsetLength(array1, 8, -1);
+        });
+        
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureOffsetLength(array1, -1, 1);
+        });
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureOffsetLength(array1, 8, 1);
+        });
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureOffsetLength(array1, 3, 10);
+        });
+    }
+   
+    @Test
+    public void testEnsureOffsetLength_native() {
+        byte[] array1 = new byte[4];
+        ArrayAllocator.ensureOffsetLength(array1, 1, 2);
+        ArrayAllocator.ensureOffsetLength(array1, 0, 4);
+        ArrayAllocator.ensureOffsetLength(array1, 1, 3);
+        
+        assertThrows(IllegalArgumentException.class, ()-> {
+            ArrayAllocator.ensureOffsetLength(array1, 1, -1);
+        });
+        assertThrows(IllegalArgumentException.class, ()-> {
+            ArrayAllocator.ensureOffsetLength(array1, 8, -1);
+        });
+        
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureOffsetLength(array1, -1, 1);
+        });
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureOffsetLength(array1, 8, 1);
+        });
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureOffsetLength(array1, 3, 10);
+        });
+    }
+
+    @Test
+    public void testEnsureFromTo() {
+        Integer[] array1 = new Integer[4];
+        ArrayAllocator.ensureFromTo(array1, 1, 3);
+        ArrayAllocator.ensureFromTo(array1, 0, 4);
+        ArrayAllocator.ensureFromTo(array1, 1, 4);
+        
+        assertThrows(IllegalArgumentException.class, ()-> {
+            ArrayAllocator.ensureFromTo(array1, 3, 1);
+        });
+        
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureFromTo(array1, -1, 8);
+        });
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureFromTo(array1, 2, 8);
+        });
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureFromTo(array1, 5, 6);
+        });
+    }
+    
+    @Test
+    public void testEnsureFromTo_native() {
+        byte[] array1 = new byte[4];
+        ArrayAllocator.ensureFromTo(array1, 1, 3);
+        ArrayAllocator.ensureFromTo(array1, 0, 4);
+        ArrayAllocator.ensureFromTo(array1, 1, 4);
+        
+        assertThrows(IllegalArgumentException.class, ()-> {
+            ArrayAllocator.ensureFromTo(array1, 3, 1);
+        });
+        
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureFromTo(array1, -1, 8);
+        });
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureFromTo(array1, 2, 8);
+        });
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()-> {
+            ArrayAllocator.ensureFromTo(array1, 5, 6);
+        });
+    }
+    
+    @Test
+    public void testGrow() {
+        Integer[] array1 = new Integer[]{1,2,3};
+        assertSame(array1, ArrayAllocator.grow(array1, 2));
+        assertSame(array1, ArrayAllocator.grow(array1, 3));
+        assertArrayEquals(new Integer[]{1,2,3,null,null,null}, ArrayAllocator.grow(array1, 4));
+        assertArrayEquals(new Integer[]{1,2,3,null,null,null}, ArrayAllocator.grow(array1, 5));
+        assertArrayEquals(new Integer[]{1,2,3,null,null,null}, ArrayAllocator.grow(array1, 6));
+        assertArrayEquals(new Integer[]{1,2,3,null,null,null,null}, ArrayAllocator.grow(array1, 7));
+        assertArrayEquals(new Integer[]{1,2,3,null,null,null,null,null,null}, ArrayAllocator.grow(array1, 9));
+    }
+    
+    @Test
+    public void testGrow_native() {
+        byte[] array1 = new byte[]{1,2,3};
+        assertSame(array1, ArrayAllocator.grow(array1, 2));
+        assertSame(array1, ArrayAllocator.grow(array1, 3));
+        assertArrayEquals(new byte[]{1,2,3,0,0,0}, ArrayAllocator.grow(array1, 4));
+        assertArrayEquals(new byte[]{1,2,3,0,0,0}, ArrayAllocator.grow(array1, 5));
+        assertArrayEquals(new byte[]{1,2,3,0,0,0}, ArrayAllocator.grow(array1, 6));
+        assertArrayEquals(new byte[]{1,2,3,0,0,0,0}, ArrayAllocator.grow(array1, 7));
+        assertArrayEquals(new byte[]{1,2,3,0,0,0,0,0,0}, ArrayAllocator.grow(array1, 9));
+    }
+    
+    @Test
+    public void testGrow_preserve() {
+        Integer[] array1 = new Integer[]{1,2,3};
+        assertSame(array1, ArrayAllocator.grow(array1, 2, 2));
+        assertSame(array1, ArrayAllocator.grow(array1, 3, 2));
+        assertArrayEquals(new Integer[]{1,2,null,null,null,null}, ArrayAllocator.grow(array1, 4, 2));
+        assertArrayEquals(new Integer[]{1,2,null,null,null,null}, ArrayAllocator.grow(array1, 5, 2));
+        assertArrayEquals(new Integer[]{1,2,null,null,null,null}, ArrayAllocator.grow(array1, 6, 2));
+        assertArrayEquals(new Integer[]{1,2,null,null,null,null,null}, ArrayAllocator.grow(array1, 7, 2));
+        assertArrayEquals(new Integer[]{1,2,null,null,null,null,null,null,null}, ArrayAllocator.grow(array1, 9, 2));
+    }
+    
+    @Test
+    public void testGrow_preserve_native() {
+        byte[] array1 = new byte[]{1,2,3};
+        assertSame(array1, ArrayAllocator.grow(array1, 2, 2));
+        assertSame(array1, ArrayAllocator.grow(array1, 3, 2));
+        assertArrayEquals(new byte[]{1,2,0,0,0,0}, ArrayAllocator.grow(array1, 4, 2));
+        assertArrayEquals(new byte[]{1,2,0,0,0,0}, ArrayAllocator.grow(array1, 5, 2));
+        assertArrayEquals(new byte[]{1,2,0,0,0,0}, ArrayAllocator.grow(array1, 6, 2));
+        assertArrayEquals(new byte[]{1,2,0,0,0,0,0}, ArrayAllocator.grow(array1, 7, 2));
+        assertArrayEquals(new byte[]{1,2,0,0,0,0,0,0,0}, ArrayAllocator.grow(array1, 9, 2));
+    }
+    
+    @Test
+    public void testTrim() {
+        Integer[] array1 = new Integer[]{1,2,3};
+        
+        assertSame(array1, ArrayAllocator.trim(array1, 5));
+        assertSame(array1, ArrayAllocator.trim(array1, 3));
+        assertArrayEquals(new Integer[]{1,2}, ArrayAllocator.trim(array1, 2));
+        assertArrayEquals(new Integer[]{1}, ArrayAllocator.trim(array1, 1));
+        assertArrayEquals(new Integer[]{}, ArrayAllocator.trim(array1, 0));
+    }
+        
+    @Test
+    public void testTrim_native() {
+        byte[] array1 = new byte[]{1,2,3};
+        
+        assertSame(array1, ArrayAllocator.trim(array1, 5));
+        assertSame(array1, ArrayAllocator.trim(array1, 3));
+        assertArrayEquals(new byte[]{1,2}, ArrayAllocator.trim(array1, 2));
+        assertArrayEquals(new byte[]{1}, ArrayAllocator.trim(array1, 1));
+        assertArrayEquals(new byte[]{}, ArrayAllocator.trim(array1, 0));
+    }
+    
+    @Test
+    public void testForPrototype() {
+        assertArray(Float[].class, 4, ArrayAllocator.forPrototype(new Float[0], 4));
+        assertArray(Integer[].class, 4, ArrayAllocator.forPrototype(new Integer[0], 4));
+        
+        assertArray(Float[].class, 0, ArrayAllocator.forPrototype(new Float[0], 0));
+        
+        assertArray(Object[].class, 4, ArrayAllocator.forPrototype(new Object[0], 4));
+        
+        assertArray(Object[].class, 0, ArrayAllocator.forPrototype(new Object[0], 0));
+    }
+    
+    @Test
+    public void testForPrototype_native() {
+        assertArray(float[].class, 4, ArrayAllocator.forPrototype(new float[0], 4));
+        assertArray(int[].class, 4, ArrayAllocator.forPrototype(new int[0], 4));
+        assertArray(float[].class, 0, ArrayAllocator.forPrototype(new float[0], 0));
+    }
+    
+    @Test
+    public void testForComponent() {
+        assertArray(Float[].class, 4, ArrayAllocator.forComponent(Float.class, 4));
+        assertArray(Integer[].class, 4, ArrayAllocator.forComponent(Integer.class, 4));
+        assertArray(Object[].class, 4, ArrayAllocator.forComponent(Object.class, 4));
+        assertArray(TPoint[].class, 4, ArrayAllocator.forComponent(TPoint.class, 4));
+        
+        assertArray(Float[].class, 0, ArrayAllocator.forComponent(Float.class, 0));
+        assertArray(Integer[].class, 0, ArrayAllocator.forComponent(Integer.class, 0));
+        assertArray(Object[].class, 0, ArrayAllocator.forComponent(Object.class, 0));
+        assertArray(TPoint[].class, 0, ArrayAllocator.forComponent(TPoint.class, 0));
+    }
+    
+    @Test
+    public void testForComponent_native() {
+        assertArray(byte[].class, 0, ArrayAllocator.forComponent(byte.class, 0));
+        assertArray(short[].class, 0, ArrayAllocator.forComponent(short.class, 0));
+        assertArray(int[].class, 0, ArrayAllocator.forComponent(int.class, 0));
+        assertArray(long[].class, 0, ArrayAllocator.forComponent(long.class, 0));
+        assertArray(float[].class, 0, ArrayAllocator.forComponent(float.class, 0));
+        assertArray(double[].class, 0, ArrayAllocator.forComponent(double.class, 0));
+        assertArray(boolean[].class, 0, ArrayAllocator.forComponent(boolean.class, 0));
+        assertArray(char[].class, 0, ArrayAllocator.forComponent(char.class, 0));
+        
+        assertArray(byte[].class, 4, ArrayAllocator.forComponent(byte.class, 4));
+        assertArray(short[].class, 4, ArrayAllocator.forComponent(short.class, 4));
+        assertArray(int[].class, 4, ArrayAllocator.forComponent(int.class, 4));
+        assertArray(long[].class, 4, ArrayAllocator.forComponent(long.class, 4));
+        assertArray(float[].class, 4, ArrayAllocator.forComponent(float.class, 4));
+        assertArray(double[].class, 4, ArrayAllocator.forComponent(double.class, 4));
+        assertArray(boolean[].class, 4, ArrayAllocator.forComponent(boolean.class, 4));
+        assertArray(char[].class, 4, ArrayAllocator.forComponent(char.class, 4));
+    }
+	
+	@Test
+	public void testResize() {
+		Integer[] a1 = new Integer[]{1,2,3};
+		Integer[] o1 = ArrayAllocator.resize(a1, 0);
+		Integer[] o2 = ArrayAllocator.resize(a1, 1);
+		Integer[] o3 = ArrayAllocator.resize(a1, 3);
+		Integer[] o4 = ArrayAllocator.resize(a1, 5);
+		assertArrayEquals(new Integer[0], o1);
+		assertArrayEquals(new Integer[]{1}, o2);
+		assertSame(a1, o3);
+		assertArrayEquals(new Integer[]{1,2,3,null,null}, o4);
+	}
+	
+	@Test
+	public void testResize_native() {
+		int[] a1 = new int[]{1,2,3};
+		int[] o1 = ArrayAllocator.resize(a1, 0);
+		int[] o2 = ArrayAllocator.resize(a1, 1);
+		int[] o3 = ArrayAllocator.resize(a1, 3);
+		int[] o4 = ArrayAllocator.resize(a1, 5);
+		assertArrayEquals(new int[0], o1);
+		assertArrayEquals(new int[]{1}, o2);
+		assertSame(a1, o3);
+		assertArrayEquals(new int[]{1,2,3,0,0}, o4);
+	}
+    
+    private void assertArray(Class<?> type, int size, Object array) {
+        assertEquals(type, array.getClass());
+        assertEquals(size, Array.getLength(array));
+    }
+    
+}

assira/src/test/java/net/ranides/assira/collection/arrays/NativeArrayAllocatorTest.java

@@ -177,5 +177,43 @@ public class NativeArrayAllocatorTest {
         assertArrayEquals(new byte[]{1}, NativeArrayAllocator.trim(array1, 1).$array());
         assertArrayEquals(new byte[]{}, NativeArrayAllocator.trim(array1, 0).$array());
     }
+	
+	@Test
+	public void testResize() {
+		NativeArray a1 = NativeArray.wrap(new Integer[]{1,2,3});
+		NativeArray o1 = NativeArrayAllocator.resize(a1, 0);
+		NativeArray o2 = NativeArrayAllocator.resize(a1, 1);
+		NativeArray o3 = NativeArrayAllocator.resize(a1, 3);
+		NativeArray o4 = NativeArrayAllocator.resize(a1, 5);
+		assertArrayEquals(new Integer[0], o1.$array());
+		assertArrayEquals(new Integer[]{1}, o2.$array());
+		assertSame(a1, o3);
+		assertArrayEquals(new Integer[]{1,2,3,null,null}, o4.$array());
+	}
+	
+	@Test
+	public void testResize_native() {
+		NativeArray a1 = NativeArray.wrap(new int[]{1,2,3});
+		NativeArray o1 = NativeArrayAllocator.resize(a1, 0);
+		NativeArray o2 = NativeArrayAllocator.resize(a1, 1);
+		NativeArray o3 = NativeArrayAllocator.resize(a1, 3);
+		NativeArray o4 = NativeArrayAllocator.resize(a1, 5);
+		assertArrayEquals(new int[0], o1.$array());
+		assertArrayEquals(new int[]{1}, o2.$array());
+		assertSame(a1, o3);
+		assertArrayEquals(new int[]{1,2,3,0,0}, o4.$array());
+	}
+	
+	@Test
+	public void testForComponent() {
+		assertArrayEquals(new int[]{0,0,0,0}, NativeArrayAllocator.forComponent(int.class, 4).$array());
+		assertArrayEquals(new Integer[]{null,null,null,null}, NativeArrayAllocator.forComponent(Integer.class, 4).$array());
+	}
+	
+	@Test
+	public void testForPrototype() {
+		assertArrayEquals(new int[]{0,0,0,0}, NativeArrayAllocator.forPrototype(NativeArray.wrap(new int[1]), 4).$array());
+		assertArrayEquals(new Integer[]{null,null,null,null}, NativeArrayAllocator.forPrototype(NativeArray.wrap(new Integer[1]), 4).$array());
+	}
     
 }

assira/src/test/java/net/ranides/assira/collection/arrays/NativeArrayTest.java

@@ -6,7 +6,13 @@
  */
 package net.ranides.assira.collection.arrays;
 
+import java.lang.reflect.Array;
 import java.util.Random;
+import java.util.function.Function;
+import net.ranides.assira.collection.IntComparator;
+import net.ranides.assira.generic.CompareUtils;
+import net.ranides.assira.junit.InterfaceTest;
+import net.ranides.assira.junit.NewAssert;
 import org.junit.Test;
 import static org.junit.Assert.*;
 
@@ -32,6 +38,20 @@ public class NativeArrayTest {
             .ignore("NativeArrayTester.basicCompare_cmp");
         NativeArrayTester.run(index -> new Random(1027*index).nextBoolean());
     }
+	
+	@Test
+    public void testAllocateErrors() {
+		NewAssert.assertThrows(UnsupportedOperationException.class, ()->{
+			NativeArray.allocate(Void.TYPE, 4);
+		});
+	}
+	
+	@Test
+    public void testWrapErrors() {
+		NewAssert.assertThrows(IllegalArgumentException.class, ()->{
+			NativeArray.wrap(new Integer(17));
+		});
+	}
     
     @Test
     public void testBoxing() {
@@ -52,4 +72,30 @@ public class NativeArrayTest {
         assertSame(na3c, na3c.unbox());
     }
 	
+	@Test
+    public void basicComparator_cmp_int() {
+        NativeArray target = NativeArray.wrap(new int[]{1,3,5,7,2});
+		
+		IntComparator fcmp = Integer::compare;
+		
+        IntComparator icmp = target.comparator(fcmp.reversed());
+        
+        assertEquals(Integer.compare(3,1), icmp.compare(0,1));
+        assertEquals(Integer.compare(5,3), icmp.compare(1,2));
+        assertEquals(Integer.compare(7,1), icmp.compare(0,3));
+        assertEquals(Integer.compare(1,7), icmp.compare(3,0));
+        assertEquals(Integer.compare(5,5), icmp.compare(2,2));
+        assertEquals(Integer.compare(2,3), icmp.compare(1,4));
+        
+        NativeArray array = NativeArray.wrap(new int[]{4,5,9,3,1});
+        IntComparator acmp = target.comparator(array, fcmp.reversed());
+        
+        assertEquals(Integer.compare(5,1), acmp.compare(0,1));
+        assertEquals(Integer.compare(9,3), acmp.compare(1,2));
+        assertEquals(Integer.compare(3,1), acmp.compare(0,3));
+        assertEquals(Integer.compare(4,7), acmp.compare(3,0));
+        assertEquals(Integer.compare(9,5), acmp.compare(2,2));
+        assertEquals(Integer.compare(1,3), acmp.compare(1,4));
+    }
+	
 }

assira/src/test/java/net/ranides/assira/collection/arrays/NativeArrayTester.java

@@ -1,313 +1,331 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.collection.arrays;
-
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.function.Function;
-import java.util.function.IntFunction;
-import javax.annotation.Resource;
-import net.ranides.assira.collection.IntComparator;
-import net.ranides.assira.collection.arrays.NativeArray.NativeComparator;
-import net.ranides.assira.collection.arrays.NativeArray.NativeMove;
-import net.ranides.assira.generic.CompareUtils;
-import net.ranides.assira.generic.HashUtils;
-import net.ranides.assira.junit.InterfaceSuite;
-import net.ranides.assira.junit.InterfaceTest;
-import net.ranides.assira.test.TCollection;
-import static net.ranides.assira.junit.NewAssert.*;
-
-/**
- *
- * @author Ranides Atterwim <ranides@gmail.com>
- */
-public class NativeArrayTester<K> {
-    
-    @Resource(name = "collection!")
-    private TCollection<K> $var;
-    
-    public static final InterfaceSuite SUITE = new InterfaceSuite(System.err)
-        .append(new NativeArrayTester());
-    
-    
-    public static <T> boolean run(InterfaceSuite suite, IntFunction<T> function) {
-        TValues<T> var = new TValues<>(function);
-        return suite
-            .param("collection!", var)
-            .run((int[] array)-> NativeArray.wrap(var.list(array).values()).unbox() );
-    }
-    
-    public static <T> boolean run(IntFunction<T> function) {
-        return run(SUITE, function);
-    }
-   
-    @InterfaceTest
-    public void basicCompare(Function<int[], NativeArray> f) {
-        NativeArray a = f.apply(new int[]{1,3,5,7});
-        NativeArray b = f.apply(new int[]{1,3,5,7});
-        NativeArray c = f.apply(new int[]{1,3,5});
-        NativeArray d = f.apply(new int[]{1,2,5,7});
-        NativeArray e = f.apply(new int[]{1,4,5,7});
-        
-        assertTrue("a==a", a.compareTo(a) == 0 );
-        assertTrue("a==b", a.compareTo(b) == 0 );
-        
-        assertTrue("a>c", a.compareTo(c) > 0 );
-        assertTrue("c<a", c.compareTo(a) < 0 );
-        
-        assertTrue("a==c (3)", a.compareTo(c,0,0,3) == 0 );
-        assertTrue("c==a (3)", c.compareTo(a,0,0,3) == 0 );
-        
-        assertTrue("a==c (0)", a.compareTo(c,0,0,0) == 0 );
-        assertTrue("c==a (0)", c.compareTo(a,1,0,0) == 0 );
-        
-        assertTrue("a>d", a.compareTo(d) > 0 );
-        assertTrue("d<a", d.compareTo(a) < 0 );
-        
-        assertTrue("a<e", a.compareTo(e) < 0 );
-        assertTrue("e>a", e.compareTo(a) > 0 );
-    }
-    
-    @InterfaceTest
-    public void basicCompare_cmp(Function<int[], NativeArray> f) {
-        Comparator cmp = CompareUtils.comparator().reversed();
-            
-        NativeArray a = f.apply(new int[]{1,3,5,7});
-        NativeArray b = f.apply(new int[]{1,3,5,7});
-        NativeArray c = f.apply(new int[]{1,3,5});
-        NativeArray d = f.apply(new int[]{1,2,5,7});
-        NativeArray e = f.apply(new int[]{1,4,5,7});
-        
-        assertTrue("a==a", a.compareTo(a, cmp) == 0 );
-        assertTrue("a==b", a.compareTo(b, cmp) == 0 );
-        
-        assertTrue("a>c", a.compareTo(c, cmp) > 0 );
-        assertTrue("c<a", c.compareTo(a, cmp) < 0 );
-        
-        assertTrue("a==c (3)", a.compareTo(c,0,0,3, cmp) == 0 );
-        assertTrue("c==a (3)", c.compareTo(a,0,0,3, cmp) == 0 );
-        
-        assertTrue("a==c (0)", a.compareTo(c,0,0,0, cmp) == 0 );
-        assertTrue("c==a (0)", c.compareTo(a,1,0,0, cmp) == 0 );
-        
-        assertTrue("a<d", a.compareTo(d, cmp) < 0 );
-        assertTrue("d>a", d.compareTo(a, cmp) > 0 );
-        
-        assertTrue("a>e", a.compareTo(e, cmp) > 0 );
-        assertTrue("e<a", e.compareTo(a, cmp) < 0 );
-    }
-    
-    @InterfaceTest
-    public void basicEquals(Function<int[], NativeArray> f) {
-        NativeArray a = f.apply(new int[]{1,3,5,7});
-        NativeArray b = f.apply(new int[]{1,3,5,7});
-        NativeArray c = f.apply(new int[]{1,3,5});
-        NativeArray d = f.apply(new int[]{1,4,5,7});
-
-        assertTrue("a==a", a.equals(a));
-        assertTrue("a==b", a.equals(b));
-        assertFalse("a!=c", a.equals(c));
-        assertFalse("a!=d", a.equals(d));
-    }
-
-    @InterfaceTest
-    public void basicSet(Function<int[], NativeArray> f) {
-        NativeArray target = f.apply(new int[]{1,3,5,7});
-        target.set(0, $var.item(4).value());
-        target.set(1, $var.item(6).value());
-        target.set(3, $var.item(8).value());
-        
-        assertEquals(f.apply(new int[]{4,6,5,8}), target);
-        
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
-            target.set(4, $var.item(9).value());
-        });
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
-            target.set(9, $var.item(9).value());
-        });
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
-            target.set(-1, $var.item(9).value());
-        });
-        
-        target.set(1,3, $var.item(2).value());
-        assertEquals(f.apply(new int[]{4,2,2,8}), target);
-    }
-    
-    @InterfaceTest
-    public void basicMove(Function<int[], NativeArray> f) {
-        NativeArray target = f.apply(new int[]{1,3,5,7});
-        
-        target.move(0,1);
-        target.move(1,3);
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
-            target.move(0,5);
-        });
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
-            target.move(5,0);
-        });
-        
-        assertEquals(f.apply(new int[]{3,7,5,7}), target);
-        
-        NativeMove imov = target.move(f.apply(new int[]{11,12,13,14}));
-        imov.move(0, 2);
-        imov.move(1, 1);
-        imov.move(3, 0);
-        assertEquals(f.apply(new int[]{13,12,5,11}), target);
-    }
-    
-    @InterfaceTest
-    public void basicSwap(Function<int[], NativeArray> f) {
-        NativeArray target = f.apply(new int[]{1,3,5,7,2,4});
-        
-        target.swap(0,1);
-        target.swap(1,3);
-        target.swap(2,5);
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
-            target.move(0,6);
-        });
-        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
-            target.move(6,0);
-        });
-        
-        assertEquals(f.apply(new int[]{3,7,4,1,2,5}), target);
-        
-    }
-    
-    @InterfaceTest
-    public void basicLRCompare(Function<int[], NativeArray> f) {
-        NativeArray target = f.apply(new int[]{1,3,5,7});
-        
-        NativeComparator lcmp = target.lcmp($var.item(4).value());
-        NativeComparator rcmp = target.rcmp($var.item(4).value());
-        
-        assertEquals($cmp(4,1), lcmp.compare(0));
-        assertEquals($cmp(4,3), lcmp.compare(1));
-        assertEquals($cmp(4,5), lcmp.compare(2));
-        assertEquals($cmp(4,7), lcmp.compare(3));
-        
-        assertEquals($cmp(1,4), rcmp.compare(0));
-        assertEquals($cmp(3,4), rcmp.compare(1));
-        assertEquals($cmp(5,4), rcmp.compare(2));
-        assertEquals($cmp(7,4), rcmp.compare(3));
-    }
-    
-    @InterfaceTest
-    public void basicLRCompare_cmp(Function<int[], NativeArray> f) {
-        NativeArray target = f.apply(new int[]{1,3,5,7});
-        
-        NativeComparator lcmp = target.lcmp($var.item(4).value(), CompareUtils.comparator().reversed());
-        NativeComparator rcmp = target.rcmp($var.item(4).value(), CompareUtils.comparator().reversed());
-        
-        assertEquals($cmp(1,4), lcmp.compare(0));
-        assertEquals($cmp(3,4), lcmp.compare(1));
-        assertEquals($cmp(5,4), lcmp.compare(2));
-        assertEquals($cmp(7,4), lcmp.compare(3));
-        
-        assertEquals($cmp(4,1), rcmp.compare(0));
-        assertEquals($cmp(4,3), rcmp.compare(1));
-        assertEquals($cmp(4,5), rcmp.compare(2));
-        assertEquals($cmp(4,7), rcmp.compare(3));
-    }
-    
-    @InterfaceTest
-    public void basicComparator(Function<int[], NativeArray> f) {
-        NativeArray target = f.apply(new int[]{1,3,5,7,2});
-        IntComparator icmp = target.comparator();
-        
-        assertEquals($cmp(1,3), icmp.compare(0,1));
-        assertEquals($cmp(3,5), icmp.compare(1,2));
-        assertEquals($cmp(1,7), icmp.compare(0,3));
-        assertEquals($cmp(7,1), icmp.compare(3,0));
-        assertEquals($cmp(5,5), icmp.compare(2,2));
-        assertEquals($cmp(3,2), icmp.compare(1,4));
-        
-        NativeArray array = f.apply(new int[]{4,5,9,3,1});
-        IntComparator acmp = target.comparator(array);
-        
-        assertEquals($cmp(1,5), acmp.compare(0,1));
-        assertEquals($cmp(3,9), acmp.compare(1,2));
-        assertEquals($cmp(1,3), acmp.compare(0,3));
-        assertEquals($cmp(7,4), acmp.compare(3,0));
-        assertEquals($cmp(5,9), acmp.compare(2,2));
-        assertEquals($cmp(3,1), acmp.compare(1,4));
-    }
-    
-    @InterfaceTest
-    public void basicComparator_cmp(Function<int[], NativeArray> f) {
-        NativeArray target = f.apply(new int[]{1,3,5,7,2});
-        IntComparator icmp = target.comparator(CompareUtils.comparator().reversed());
-        
-        assertEquals($cmp(3,1), icmp.compare(0,1));
-        assertEquals($cmp(5,3), icmp.compare(1,2));
-        assertEquals($cmp(7,1), icmp.compare(0,3));
-        assertEquals($cmp(1,7), icmp.compare(3,0));
-        assertEquals($cmp(5,5), icmp.compare(2,2));
-        assertEquals($cmp(2,3), icmp.compare(1,4));
-        
-        NativeArray array = f.apply(new int[]{4,5,9,3,1});
-        IntComparator acmp = target.comparator(array, CompareUtils.comparator().reversed());
-        
-        assertEquals($cmp(5,1), acmp.compare(0,1));
-        assertEquals($cmp(9,3), acmp.compare(1,2));
-        assertEquals($cmp(3,1), acmp.compare(0,3));
-        assertEquals($cmp(4,7), acmp.compare(3,0));
-        assertEquals($cmp(9,5), acmp.compare(2,2));
-        assertEquals($cmp(1,3), acmp.compare(1,4));
-    }
-    
-    @InterfaceTest
-    public void basicToString(Function<int[], NativeArray> f) {
-        NativeArray target = f.apply(new int[]{1,3,5,7,2});
-        String exp = $var.list(1,3,5,7,2).into(new ArrayList<>()).toString();
-        assertEquals(exp, target.toString());
-    }
-    
-    @InterfaceTest
-    public void basicAllocate(Function<int[], NativeArray> f) {
-        NativeArray target = f.apply(new int[]{1,3,5});
-        NativeArray z = target.allocate(0);
-        assertEquals(0, z.size());
-        assertEquals(target.component(), z.component());
-        
-        NativeArray c = target.allocate(5);
-        assertEquals(5, c.size());
-        assertEquals(target.component(), c.component());
-    }
-    
-    private int $cmp(int a, int b) {
-        return CompareUtils.cmp($var.item(a).value(), $var.item(b).value());
-    }
-    
-    private static class TValues<T> extends TCollection<T> {
-
-        private final IntFunction<T> function;
-        
-        public TValues(IntFunction<T> function) {
-            this.function = function;
-        }
-
-        @Override
-        protected T value(int index, int n) {
-            if(n!=0) {
-                throw new UnsupportedOperationException("NO TEST");
-            }
-            return function.apply(index);
-        }
-
-        @Override
-        protected int cmp(Object a, Object b) {
-            return CompareUtils.cmp(a, b);
-        }
-
-        @Override
-        protected int hash(Object value) {
-            return HashUtils.hash(value);
-        }
-        
-    }
-    
-}
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.collection.arrays;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.function.Function;
+import java.util.function.IntFunction;
+import java.util.function.IntPredicate;
+import javax.annotation.Resource;
+import net.ranides.assira.collection.IntComparator;
+import net.ranides.assira.collection.arrays.NativeArray.NativeComparator;
+import net.ranides.assira.collection.arrays.NativeArray.NativeMove;
+import net.ranides.assira.generic.CompareUtils;
+import net.ranides.assira.generic.HashUtils;
+import net.ranides.assira.junit.InterfaceSuite;
+import net.ranides.assira.junit.InterfaceTest;
+import net.ranides.assira.test.TCollection;
+import static net.ranides.assira.junit.NewAssert.*;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public class NativeArrayTester<K> {
+    
+    @Resource(name = "collection!")
+    private TCollection<K> $var;
+    
+    public static final InterfaceSuite SUITE = new InterfaceSuite(System.err)
+        .append(new NativeArrayTester<>());
+    
+    
+    public static <T> boolean run(InterfaceSuite suite, IntFunction<T> function) {
+        TValues<T> var = new TValues<>(function);
+        return suite
+            .param("collection!", var)
+            .run((int[] array)-> NativeArray.wrap(var.list(array).values()).unbox() );
+    }
+    
+    public static <T> boolean run(IntFunction<T> function) {
+        return run(SUITE, function);
+    }
+   
+    @InterfaceTest
+    public void basicCompare(Function<int[], NativeArray> f) {
+        NativeArray a = f.apply(new int[]{1,3,5,7});
+        NativeArray b = f.apply(new int[]{1,3,5,7});
+        NativeArray c = f.apply(new int[]{1,3,5});
+        NativeArray d = f.apply(new int[]{1,2,5,7});
+        NativeArray e = f.apply(new int[]{1,4,5,7});
+        
+        assertTrue("a==a", a.compareTo(a) == 0 );
+        assertTrue("a==b", a.compareTo(b) == 0 );
+        
+        assertTrue("a>c", a.compareTo(c) > 0 );
+        assertTrue("c<a", c.compareTo(a) < 0 );
+        
+        assertTrue("a==c (3)", a.compareTo(c,0,0,3) == 0 );
+        assertTrue("c==a (3)", c.compareTo(a,0,0,3) == 0 );
+        
+        assertTrue("a==c (0)", a.compareTo(c,0,0,0) == 0 );
+        assertTrue("c==a (0)", c.compareTo(a,1,0,0) == 0 );
+        
+        assertTrue("a>d", a.compareTo(d) > 0 );
+        assertTrue("d<a", d.compareTo(a) < 0 );
+        
+        assertTrue("a<e", a.compareTo(e) < 0 );
+        assertTrue("e>a", e.compareTo(a) > 0 );
+    }
+    
+    @InterfaceTest
+    public void basicCompare_cmp(Function<int[], NativeArray> f) {
+        Comparator cmp = CompareUtils.comparator().reversed();
+            
+        NativeArray a = f.apply(new int[]{1,3,5,7});
+        NativeArray b = f.apply(new int[]{1,3,5,7});
+        NativeArray c = f.apply(new int[]{1,3,5});
+        NativeArray d = f.apply(new int[]{1,2,5,7});
+        NativeArray e = f.apply(new int[]{1,4,5,7});
+        
+        assertTrue("a==a", a.compareTo(a, cmp) == 0 );
+        assertTrue("a==b", a.compareTo(b, cmp) == 0 );
+        
+        assertTrue("a>c", a.compareTo(c, cmp) > 0 );
+        assertTrue("c<a", c.compareTo(a, cmp) < 0 );
+        
+        assertTrue("a==c (3)", a.compareTo(c,0,0,3, cmp) == 0 );
+        assertTrue("c==a (3)", c.compareTo(a,0,0,3, cmp) == 0 );
+        
+        assertTrue("a==c (0)", a.compareTo(c,0,0,0, cmp) == 0 );
+        assertTrue("c==a (0)", c.compareTo(a,1,0,0, cmp) == 0 );
+        
+        assertTrue("a<d", a.compareTo(d, cmp) < 0 );
+        assertTrue("d>a", d.compareTo(a, cmp) > 0 );
+        
+        assertTrue("a>e", a.compareTo(e, cmp) > 0 );
+        assertTrue("e<a", e.compareTo(a, cmp) < 0 );
+    }
+    
+    @InterfaceTest
+    public void basicEquals(Function<int[], NativeArray> f) {
+        NativeArray a = f.apply(new int[]{1,3,5,7});
+        NativeArray b = f.apply(new int[]{1,3,5,7});
+        NativeArray c = f.apply(new int[]{1,3,5});
+        NativeArray d = f.apply(new int[]{1,4,5,7});
+
+        assertTrue("a==a", a.equals(a));
+        assertTrue("a==b", a.equals(b));
+        assertFalse("a!=c", a.equals(c));
+        assertFalse("a!=d", a.equals(d));
+    }
+
+    @InterfaceTest
+    public void basicSet(Function<int[], NativeArray> f) {
+        NativeArray target = f.apply(new int[]{1,3,5,7});
+        target.set(0, $var.item(4).value());
+        target.set(1, $var.item(6).value());
+        target.set(3, $var.item(8).value());
+        
+        assertEquals(f.apply(new int[]{4,6,5,8}), target);
+        
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
+            target.set(4, $var.item(9).value());
+        });
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
+            target.set(9, $var.item(9).value());
+        });
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
+            target.set(-1, $var.item(9).value());
+        });
+        
+        target.set(1,3, $var.item(2).value());
+        assertEquals(f.apply(new int[]{4,2,2,8}), target);
+    }
+    
+    @InterfaceTest
+    public void basicMove(Function<int[], NativeArray> f) {
+        NativeArray target = f.apply(new int[]{1,3,5,7});
+        
+        target.move(0,1);
+        target.move(1,3);
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
+            target.move(0,5);
+        });
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
+            target.move(5,0);
+        });
+        
+        assertEquals(f.apply(new int[]{3,7,5,7}), target);
+        
+        NativeMove imov = target.move(f.apply(new int[]{11,12,13,14}));
+        imov.move(0, 2);
+        imov.move(1, 1);
+        imov.move(3, 0);
+        assertEquals(f.apply(new int[]{13,12,5,11}), target);
+    }
+    
+    @InterfaceTest
+    public void basicSwap(Function<int[], NativeArray> f) {
+        NativeArray target = f.apply(new int[]{1,3,5,7,2,4});
+        
+        target.swap(0,1);
+        target.swap(1,3);
+        target.swap(2,5);
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
+            target.move(0,6);
+        });
+        assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
+            target.move(6,0);
+        });
+        
+        assertEquals(f.apply(new int[]{3,7,4,1,2,5}), target);
+        
+    }
+    
+    @InterfaceTest
+    public void basicLRCompare(Function<int[], NativeArray> f) {
+        NativeArray target = f.apply(new int[]{1,3,5,7});
+        
+        NativeComparator lcmp = target.lcmp($var.item(4).value());
+        NativeComparator rcmp = target.rcmp($var.item(4).value());
+        
+        assertEquals($cmp(4,1), lcmp.compare(0));
+        assertEquals($cmp(4,3), lcmp.compare(1));
+        assertEquals($cmp(4,5), lcmp.compare(2));
+        assertEquals($cmp(4,7), lcmp.compare(3));
+        
+        assertEquals($cmp(1,4), rcmp.compare(0));
+        assertEquals($cmp(3,4), rcmp.compare(1));
+        assertEquals($cmp(5,4), rcmp.compare(2));
+        assertEquals($cmp(7,4), rcmp.compare(3));
+    }
+    
+    @InterfaceTest
+    public void basicLRCompare_cmp(Function<int[], NativeArray> f) {
+        NativeArray target = f.apply(new int[]{1,3,5,7});
+        
+        NativeComparator lcmp = target.lcmp($var.item(4).value(), CompareUtils.comparator().reversed());
+        NativeComparator rcmp = target.rcmp($var.item(4).value(), CompareUtils.comparator().reversed());
+        
+        assertEquals($cmp(1,4), lcmp.compare(0));
+        assertEquals($cmp(3,4), lcmp.compare(1));
+        assertEquals($cmp(5,4), lcmp.compare(2));
+        assertEquals($cmp(7,4), lcmp.compare(3));
+        
+        assertEquals($cmp(4,1), rcmp.compare(0));
+        assertEquals($cmp(4,3), rcmp.compare(1));
+        assertEquals($cmp(4,5), rcmp.compare(2));
+        assertEquals($cmp(4,7), rcmp.compare(3));
+    }
+	
+	@InterfaceTest
+    public void basicEQCompare(Function<int[], NativeArray> f) {
+        NativeArray target = f.apply(new int[]{1,3,5,7});
+        
+        IntPredicate cmp = target.cmp($var.item(4).value());
+        
+        assertEquals($eq(1,4), cmp.test(0));
+        assertEquals($eq(3,4), cmp.test(1));
+        assertEquals($eq(5,4), cmp.test(2));
+        assertEquals($eq(7,4), cmp.test(3));
+        
+    }
+    
+    @InterfaceTest
+    public void basicComparator(Function<int[], NativeArray> f) {
+        NativeArray target = f.apply(new int[]{1,3,5,7,2});
+        IntComparator icmp = target.comparator();
+        
+        assertEquals($cmp(1,3), icmp.compare(0,1));
+        assertEquals($cmp(3,5), icmp.compare(1,2));
+        assertEquals($cmp(1,7), icmp.compare(0,3));
+        assertEquals($cmp(7,1), icmp.compare(3,0));
+        assertEquals($cmp(5,5), icmp.compare(2,2));
+        assertEquals($cmp(3,2), icmp.compare(1,4));
+        
+        NativeArray array = f.apply(new int[]{4,5,9,3,1});
+        IntComparator acmp = target.comparator(array);
+        
+        assertEquals($cmp(1,5), acmp.compare(0,1));
+        assertEquals($cmp(3,9), acmp.compare(1,2));
+        assertEquals($cmp(1,3), acmp.compare(0,3));
+        assertEquals($cmp(7,4), acmp.compare(3,0));
+        assertEquals($cmp(5,9), acmp.compare(2,2));
+        assertEquals($cmp(3,1), acmp.compare(1,4));
+    }
+    
+    @InterfaceTest
+    public void basicComparator_cmp(Function<int[], NativeArray> f) {
+        NativeArray target = f.apply(new int[]{1,3,5,7,2});
+        IntComparator icmp = target.comparator(CompareUtils.comparator().reversed());
+        
+        assertEquals($cmp(3,1), icmp.compare(0,1));
+        assertEquals($cmp(5,3), icmp.compare(1,2));
+        assertEquals($cmp(7,1), icmp.compare(0,3));
+        assertEquals($cmp(1,7), icmp.compare(3,0));
+        assertEquals($cmp(5,5), icmp.compare(2,2));
+        assertEquals($cmp(2,3), icmp.compare(1,4));
+        
+        NativeArray array = f.apply(new int[]{4,5,9,3,1});
+        IntComparator acmp = target.comparator(array, CompareUtils.comparator().reversed());
+        
+        assertEquals($cmp(5,1), acmp.compare(0,1));
+        assertEquals($cmp(9,3), acmp.compare(1,2));
+        assertEquals($cmp(3,1), acmp.compare(0,3));
+        assertEquals($cmp(4,7), acmp.compare(3,0));
+        assertEquals($cmp(9,5), acmp.compare(2,2));
+        assertEquals($cmp(1,3), acmp.compare(1,4));
+    }
+    
+    @InterfaceTest
+    public void basicToString(Function<int[], NativeArray> f) {
+        NativeArray target = f.apply(new int[]{1,3,5,7,2});
+        String exp = $var.list(1,3,5,7,2).into(new ArrayList<>()).toString();
+        assertEquals(exp, target.toString());
+    }
+    
+    @InterfaceTest
+    public void basicAllocate(Function<int[], NativeArray> f) {
+        NativeArray target = f.apply(new int[]{1,3,5});
+        NativeArray z = target.allocate(0);
+        assertEquals(0, z.size());
+        assertEquals(target.component(), z.component());
+        
+        NativeArray c = target.allocate(5);
+        assertEquals(5, c.size());
+        assertEquals(target.component(), c.component());
+    }
+	    
+    private int $cmp(int a, int b) {
+        return CompareUtils.cmp($var.item(a).value(), $var.item(b).value());
+    }
+	
+	private boolean $eq(int a, int b) {
+        return 0 == CompareUtils.cmp($var.item(a).value(), $var.item(b).value());
+    }
+    
+    private static class TValues<T> extends TCollection<T> {
+
+        private final IntFunction<T> function;
+        
+        public TValues(IntFunction<T> function) {
+            this.function = function;
+        }
+
+        @Override
+        protected T value(int index, int n) {
+            if(n!=0) {
+                throw new UnsupportedOperationException("NO TEST");
+            }
+            return function.apply(index);
+        }
+
+        @Override
+        protected int cmp(Object a, Object b) {
+            return CompareUtils.cmp(a, b);
+        }
+
+        @Override
+        protected int hash(Object value) {
+            return HashUtils.hash(value);
+        }
+        
+    }
+    
+}