fix: ArraySearch #indexOf arguments

fix: ArraySearch #first
fix: ArraySearch #last

fix: NativeArraySearch #first
fix: NativeArraySearch #last

fix: NativeArrayUtils #rotate
new: NativeArrayUtils #reverse(begin, end)

fix: ArrayUtils #rotate
new: ArrayUtils #reverse(begin, end)

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

@@ -43,19 +43,19 @@ public final class ArraySearch {
         return NativeArraySearch.last(NativeArray.wrap(array), begin, end, predicate);
     }
     
-    public static <T> int indexOf(NativeArray array, T value) {
+    public static <A, T> int indexOf(A array, T value) {
         return NativeArraySearch.indexOf(NativeArray.wrap(array), value);
     }
     
-    public static <T> int indexOf(NativeArray array, int begin, int end, T value) {
+    public static <A,T> int indexOf(A array, int begin, int end, T value) {
         return NativeArraySearch.indexOf(NativeArray.wrap(array), begin, end, value);
     }
     
-    public static <T> int lastIndexOf(NativeArray array, T value) {
+    public static <A,T> int lastIndexOf(A array, T value) {
         return NativeArraySearch.lastIndexOf(NativeArray.wrap(array), value);
     }
     
-    public static <T> int lastIndexOf(NativeArray array, int begin, int end, T value) {
+    public static <A,T> int lastIndexOf(A array, int begin, int end, T value) {
         return NativeArraySearch.lastIndexOf(NativeArray.wrap(array), begin, end, value);
     }
     

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

@@ -111,6 +111,11 @@ public final class ArrayUtils {
     public static <A,T> void fill(A array, int begin, int end, T value) {
         NativeArrayUtils.fill(NativeArray.wrap(array), begin, end, value);
     }
+    
+    public static <A> A reverse(A array, int begin, int end){
+        NativeArrayUtils.reverse(NativeArray.wrap(array), begin, end);
+        return array;
+    }
 
     /**
      * Reverses the order of the elements in the specified array.
@@ -162,8 +167,8 @@ public final class ArrayUtils {
         return NativeArrayUtils.slice(NativeArray.wrap(array), begin, end).$array();
     }
     
-    public static <A> A shift(A array, int offset) {
-        return NativeArrayUtils.shift(NativeArray.wrap(array), offset).$array();
+    public static <A> A rotate(A array, int offset) {
+        return NativeArrayUtils.rotate(NativeArray.wrap(array), offset).$array();
     }
     
     public static <A> A shuffle(Random random, A array) {

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

@@ -7,6 +7,7 @@
 package net.ranides.assira.collection.arrays;
 
 import java.util.Comparator;
+import java.util.NoSuchElementException;
 import java.util.function.IntPredicate;
 import java.util.function.Predicate;
 import net.ranides.assira.collection.arrays.NativeArray.NativeComparator;
@@ -32,7 +33,7 @@ public final class NativeArraySearch {
                 return v;
             }
         }
-        return null;
+        throw new NoSuchElementException();
     }
     
     public static <T> T last(NativeArray array, Predicate<T> predicate) {
@@ -47,7 +48,7 @@ public final class NativeArraySearch {
                 return v;
             }
         }
-        return null;
+        throw new NoSuchElementException();
     }
     
     public static <T> boolean contains(NativeArray array, T value) {

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

@@ -52,15 +52,20 @@ public final class NativeArrayUtils {
         NativeArrayAllocator.ensureFromTo(array, begin, end);
         array.set(begin, end, value);
     }
-
-    public static void reverse(int size, Swapper swapper) {
-        for (int i = size / 2; i-- != 0;) {
-            swapper.swap(size - i - 1, i);
+    
+    public static <S extends Swapper> S reverse(S swapper, int begin, int end){
+        while(begin < --end){
+            swapper.swap(begin++, end);
         }
+        return swapper;
+    }
+
+    public static <S extends Swapper> S reverse(S swapper, int size) {
+        return reverse(swapper, 0, size);
     }
     
     public static NativeArray reverse(NativeArray array) {
-        reverse(array.size(), array);
+        reverse(array, array.size());
         return array;
     }
     
@@ -97,17 +102,17 @@ public final class NativeArrayUtils {
         return result;
     }
     
-    public static <A> NativeArray shift(NativeArray array, int offset) {
+    public static NativeArray rotate(NativeArray array, int offset) {
         int n = array.size();
-        if(offset > 0) {
-            for(int i=n-1; i>=0; i--) {
-                array.move(i, (i+offset)%n);
-            }
-        } else {
-            offset += n;
-            for(int i=0; i<n; i++) {
-                array.move(i, (i-offset)%n);
-            }
+        offset = offset % n;
+        if( offset > 0) {
+            int a = n - offset; 
+            reverse(array, 0, a);
+            reverse(array, a, n);
+            reverse(array, 0, n);
+        } 
+        else if( offset < 0) {
+            rotate(array, offset+n);
         }
         return array;
     }

assira/src/main/java/net/ranides/assira/text/StrBuilder.java

@@ -159,7 +159,7 @@ public final class StrBuilder implements CharSequence, Appendable, Serializable
     }
     
     public StrBuilder reverse() {
-        NativeArrayUtils.reverse(size, NativeArray.wrap(buffer));
+        NativeArrayUtils.reverse(NativeArray.wrap(buffer), size);
         return this;
     }
     

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

@@ -7,6 +7,7 @@
 package net.ranides.assira.collection.arrays;
 
 import java.util.Comparator;
+import java.util.NoSuchElementException;
 import net.ranides.assira.collection.IntComparator;
 import static net.ranides.assira.junit.NewAssert.*;
 import org.junit.Test;
@@ -149,4 +150,114 @@ public class ArraySearchTest {
         });
     }
     
+    @Test
+    public void testFirst() {
+		String[] list8 = new String[]{"a", "b", "cc", "d", "ee", "f", "gg", "h"};
+
+		assertThrows(NoSuchElementException.class, ()-> {
+			ArraySearch.first(list8, v -> false);
+		});
+		assertThrows(NoSuchElementException.class, ()-> {
+			ArraySearch.first(list8, 1, 3, v -> false);
+		});
+		
+		assertEquals("b", ArraySearch.first(list8, 1, 3, v -> true));
+		
+		assertEquals("cc", ArraySearch.first(list8, (String v) -> v.length()>1));
+		assertEquals("cc", ArraySearch.first(list8, 1, 3, (String v) -> v.length()>1));
+		assertEquals("ee", ArraySearch.first(list8, 3, 5, (String v) -> v.length()>1));
+    }
+	
+	@Test
+    public void testLast() {
+		String[] list8 = new String[]{"a", "b", "cc", "d", "ee", "f", "gg", "h"};
+
+		assertThrows(NoSuchElementException.class, ()-> {
+			ArraySearch.last(list8, v -> false);
+		});
+		assertThrows(NoSuchElementException.class, ()-> {
+			ArraySearch.last(list8, 1, 3, v -> false);
+		});
+		
+		assertEquals("d", ArraySearch.last(list8, 1, 4, v -> true));
+		
+		assertEquals("gg", ArraySearch.last(list8, (String v) -> v.length()>1));
+		assertEquals("ee", ArraySearch.last(list8, 1, 6, (String v) -> v.length()>1));
+		assertEquals("cc", ArraySearch.last(list8, 1, 3, (String v) -> v.length()>1));
+    }
+    
+    @Test
+    public void testIndexOf() {
+        String[] list0 = new String[]{};
+        String[] list1 = new String[]{"a"};
+        String[] list8 = new String[]{"a", "b", "c", "d", "c", "e", "d", "f"};
+        
+        assertEquals(-1, ArraySearch.indexOf(list0, "q"));
+        assertEquals(-1, ArraySearch.indexOf(list1, "q"));
+        assertEquals(-1, ArraySearch.indexOf(list8, "q"));
+        
+        assertEquals(0, ArraySearch.indexOf(list1, "a"));
+        assertEquals(2, ArraySearch.indexOf(list8, "c"));
+        assertEquals(7, ArraySearch.indexOf(list8, "f"));
+        
+        assertThrows(IndexOutOfBoundsException.class, ()->{
+            ArraySearch.indexOf(list1, 1, 3, "a");
+        });
+        
+        assertEquals(0, ArraySearch.indexOf(list8, 0, 3, "a"));
+        assertEquals(-1, ArraySearch.indexOf(list8, 1, 3, "a"));
+        assertEquals(2, ArraySearch.indexOf(list8, 1, 6, "c"));
+        assertEquals(4, ArraySearch.indexOf(list8, 3, 6, "c"));
+    }
+    
+    @Test
+    public void testLastIndexOf() {
+        String[] list0 = new String[]{};
+        String[] list1 = new String[]{"a"};
+        String[] list8 = new String[]{"a", "b", "c", "d", "c", "e", "d", "f"};
+        
+        assertEquals(-1, ArraySearch.lastIndexOf(list0, "q"));
+        assertEquals(-1, ArraySearch.lastIndexOf(list1, "q"));
+        assertEquals(-1, ArraySearch.lastIndexOf(list8, "q"));
+        
+        assertEquals(0, ArraySearch.lastIndexOf(list1, "a"));
+        assertEquals(4, ArraySearch.lastIndexOf(list8, "c"));
+        assertEquals(7, ArraySearch.lastIndexOf(list8, "f"));
+        
+        assertThrows(IndexOutOfBoundsException.class, ()->{
+            ArraySearch.lastIndexOf(list1, 1, 3, "a");
+        });
+        
+        assertEquals(0, ArraySearch.lastIndexOf(list8, 0, 3, "a"));
+        assertEquals(-1, ArraySearch.lastIndexOf(list8, 1, 3, "a"));
+        assertEquals(4, ArraySearch.lastIndexOf(list8, 1, 6, "c"));
+        assertEquals(2, ArraySearch.lastIndexOf(list8, 1, 3, "c"));
+    }
+    
+    @Test
+    public void testContains() {
+        String[] list0 = new String[]{};
+        String[] list1 = new String[]{"a"};
+        String[] list8 = new String[]{"a", "b", "c", "d", "c", "e", "d", "f"};
+        
+        assertEquals(false, ArraySearch.contains(list0, "q"));
+        assertEquals(false, ArraySearch.contains(list1, "q"));
+        assertEquals(false, ArraySearch.contains(list8, "q"));
+        
+        assertEquals(true, ArraySearch.contains(list1, "a"));
+        assertEquals(true, ArraySearch.contains(list8, "c"));
+        assertEquals(true, ArraySearch.contains(list8, "f"));
+        
+        assertThrows(IndexOutOfBoundsException.class, ()->{
+            ArraySearch.contains(list1, 1, 3, "a");
+        });
+        
+        assertEquals(true, ArraySearch.contains(list8, 0, 3, "a"));
+        assertEquals(false, ArraySearch.contains(list8, 1, 3, "a"));
+        assertEquals(true, ArraySearch.contains(list8, 2, 6, "c"));
+        assertEquals(false, ArraySearch.contains(list8, 2, 2, "c"));
+        assertEquals(true, ArraySearch.contains(list8, 1, 6, "c"));
+        assertEquals(true, ArraySearch.contains(list8, 3, 6, "c"));
+    }
+    
 }

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

@@ -1,170 +1,210 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.collection.arrays;
-
-import net.ranides.assira.collection.IntComparator;
-import net.ranides.assira.collection.lists.IntList;
-import net.ranides.assira.collection.lists.IntRange;
-import org.junit.Test;
-import static net.ranides.assira.junit.NewAssert.*;
-
-/**
- *
- * @author Ranides Atterwim <ranides@gmail.com>
- */
-public class ArrayUtilsTest {
-
-    private static final IntComparator CMP = IntComparator.ASC;
-
-    @Test
-    public void testHead() {
-        assertArrayEquals(array(0,0), ArrayUtils.head(array(1,5), 0, CMP));
-        assertArrayEquals(array(0,0), ArrayUtils.head(array(1,5), 1, CMP));
-        assertArrayEquals(array(1,2), ArrayUtils.head(array(1,5), 2, CMP));
-        assertArrayEquals(array(1,3), ArrayUtils.head(array(1,5), 3, CMP));
-        assertArrayEquals(array(1,4), ArrayUtils.head(array(1,5), 4, CMP));
-        assertArrayEquals(array(1,5), ArrayUtils.head(array(1,5), 5, CMP));
-        assertArrayEquals(array(1,5), ArrayUtils.head(array(1,5), 8, CMP));
-    }
-
-    @Test
-    public void testTail() {
-        assertArrayEquals(array(1,5), ArrayUtils.tail(array(1,5), 0, CMP));
-        assertArrayEquals(array(1,5), ArrayUtils.tail(array(1,5), 1, CMP));
-        assertArrayEquals(array(2,5), ArrayUtils.tail(array(1,5), 2, CMP));
-        assertArrayEquals(array(3,5), ArrayUtils.tail(array(1,5), 3, CMP));
-        assertArrayEquals(array(4,5), ArrayUtils.tail(array(1,5), 4, CMP));
-        assertArrayEquals(array(0,0), ArrayUtils.tail(array(1,5), 5, CMP));
-        assertArrayEquals(array(0,0), ArrayUtils.tail(array(1,5), 8, CMP));
-    }
-
-    @Test
-    public void testSlice() {
-        assertArrayEquals(array(1,7), ArrayUtils.slice(array(1,7), 0, 7, CMP));
-        assertArrayEquals(array(1,7), ArrayUtils.slice(array(1,7), 1, 7, CMP));
-        assertArrayEquals(array(2,7), ArrayUtils.slice(array(1,7), 2, 7, CMP));
-        assertArrayEquals(array(2,6), ArrayUtils.slice(array(1,7), 2, 6, CMP));
-        assertArrayEquals(array(2,4), ArrayUtils.slice(array(1,7), 2, 4, CMP));
-        assertArrayEquals(array(3,4), ArrayUtils.slice(array(1,7), 3, 4, CMP));
-        assertArrayEquals(array(0,0), ArrayUtils.slice(array(1,7), 3, 2, CMP));
-    }
-    
-    private static int[] array(int begin, int end) {
-        int n = end-begin;
-        int res[] = new int[n];
-        for(int i=0; i<n; i++) {
-            res[i] = begin+i;
-        }
-        return res;
-    }
-    
-    @Test
-    public void testCollect() {
-        IntList input = new IntRange(1, 5);
-        
-        int[] out1 = new int[4];
-        assertEquals(4, ArrayUtils.collect(input.iterator(), out1));
-        assertArrayEquals(new int[]{1,2,3,4}, out1);
-        
-        int[] out2 = new int[]{7,7,7,7,8,9};
-        assertEquals(4, ArrayUtils.collect(input.iterator(), out2));
-        assertArrayEquals(new int[]{1,2,3,4,8,9}, out2);
-    }
-    
-    @Test
-    public void testCollect_bounds() {
-        IntList inp1 = new IntRange(1, 5);
-        
-        int[] out1 = new int[]{7,7,7,7,8,9};
-        assertEquals(4, ArrayUtils.collect(inp1.iterator(), out1, 1, 4));
-        assertArrayEquals(new int[]{7,1,2,3,4,9}, out1);
-        
-        int[] out2 = new int[]{7,7,7,7,8,9};
-        assertEquals(4, ArrayUtils.collect(inp1.iterator(), out2, 2, 4));
-        assertArrayEquals(new int[]{7,7,1,2,3,4}, out2);
-        
-        int[] out3 = new int[]{7,7,7,7,8,9};
-        assertEquals(3, ArrayUtils.collect(inp1.iterator(), out3, 2, 3));
-        assertArrayEquals(new int[]{7,7,1,2,3,9}, out3);
-        
-        int[] out4 = new int[]{7,7,7,7,7,7,7,7};
-        
-        assertEquals(4, ArrayUtils.collect(inp1.iterator(), out4, 1, 6));
-        assertArrayEquals(new int[]{7,1,2,3,4,7,7,7}, out4);
-        
-        int[] out5 = new int[]{7,7};
-        assertEquals(2, ArrayUtils.collect(inp1.iterator(), out5, 0, 2));
-        assertArrayEquals(new int[]{1,2}, out5);
-        
-        int[] out6 = new int[]{7,7};
-        assertEquals(0, ArrayUtils.collect(inp1.iterator(), out6, 0, 0));
-        assertArrayEquals(new int[]{7,7}, out6);
-        
-        int[] out7 = new int[]{7,7,7,7,7,7};
-                
-        assertThrows(IndexOutOfBoundsException.class, ()->{
-            ArrayUtils.collect(inp1.iterator(), out7, -2, 4);
-        });
-        assertThrows(IllegalArgumentException.class, ()->{
-            ArrayUtils.collect(inp1.iterator(), out7, 0, -1);
-        });
-        assertThrows(IndexOutOfBoundsException.class, ()->{
-            ArrayUtils.collect(inp1.iterator(), out7, 0, 20);
-        });
-        assertThrows(IllegalArgumentException.class, ()->{
-            ArrayUtils.collect(inp1.iterator(), out6, 20, 1);
-        });
-    }
-    
-    
-    @Test
-    public void testReverse() {
-        int[] inp1 = new int[]{};
-        int[] inp2 = new int[]{1};
-        int[] inp3 = new int[]{1,2};
-        int[] inp4 = new int[]{1,2,3};
-        int[] inp5 = new int[]{1,2,3,4};
-        
-        assertReverse(new int[]{}, inp1);
-        assertReverse(new int[]{1}, inp2);
-        assertReverse(new int[]{2,1}, inp3);
-        assertReverse(new int[]{3,2,1}, inp4);
-        assertReverse(new int[]{4,3,2,1}, inp5);
-    }
-    
-    private void assertReverse(int[] expected, int[] values) {
-        assertSame(values, ArrayUtils.reverse(values));
-        assertArrayEquals(expected, values);
-    }
-    
-    @Test
-    public void testEquals() {
-        
-        assertFalse( ArrayUtils.equals(new int[1], new int[2]) );
-        
-        assertTrue( ArrayUtils.equals(new int[0], new int[0]) );
-        assertTrue( ArrayUtils.equals(new int[]{1}, new int[]{1}) );
-        assertTrue( ArrayUtils.equals(new int[]{1,2,3}, new int[]{1,2,3}) );
-        
-        assertFalse( ArrayUtils.equals(new int[]{1,2,3}, new int[]{1,2,4}) );
-        assertFalse( ArrayUtils.equals(new int[]{1,2,3}, new int[]{1,4,3}) );
-        assertFalse( ArrayUtils.equals(new int[]{1,2,3}, new int[]{5,2,3}) );
-    }
-    
-    @Test
-    public void testFill_FT() {
-        int[] out1 = new int[4];
-        int[] out2 = new int[4];
-        
-        ArrayUtils.fill(out1, 1, 3, 9);
-        assertArrayEquals(new int[]{0, 9, 9, 0}, out1);
-        
-        ArrayUtils.fill(out2, 0, 3, 9);
-        assertArrayEquals(new int[]{9, 9, 9, 0}, out2);
-    }
-    
-}
+/*
+ * @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.Arrays;
+import net.ranides.assira.collection.IntComparator;
+import net.ranides.assira.collection.lists.IntList;
+import net.ranides.assira.collection.lists.IntRange;
+import org.junit.Test;
+import static net.ranides.assira.junit.NewAssert.*;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public class ArrayUtilsTest {
+
+    private static final IntComparator CMP = IntComparator.ASC;
+
+    @Test
+    public void testHead() {
+        assertArrayEquals(array(0,0), ArrayUtils.head(array(1,5), 0, CMP));
+        assertArrayEquals(array(0,0), ArrayUtils.head(array(1,5), 1, CMP));
+        assertArrayEquals(array(1,2), ArrayUtils.head(array(1,5), 2, CMP));
+        assertArrayEquals(array(1,3), ArrayUtils.head(array(1,5), 3, CMP));
+        assertArrayEquals(array(1,4), ArrayUtils.head(array(1,5), 4, CMP));
+        assertArrayEquals(array(1,5), ArrayUtils.head(array(1,5), 5, CMP));
+        assertArrayEquals(array(1,5), ArrayUtils.head(array(1,5), 8, CMP));
+    }
+
+    @Test
+    public void testTail() {
+        assertArrayEquals(array(1,5), ArrayUtils.tail(array(1,5), 0, CMP));
+        assertArrayEquals(array(1,5), ArrayUtils.tail(array(1,5), 1, CMP));
+        assertArrayEquals(array(2,5), ArrayUtils.tail(array(1,5), 2, CMP));
+        assertArrayEquals(array(3,5), ArrayUtils.tail(array(1,5), 3, CMP));
+        assertArrayEquals(array(4,5), ArrayUtils.tail(array(1,5), 4, CMP));
+        assertArrayEquals(array(0,0), ArrayUtils.tail(array(1,5), 5, CMP));
+        assertArrayEquals(array(0,0), ArrayUtils.tail(array(1,5), 8, CMP));
+    }
+
+    @Test
+    public void testSlice() {
+        assertArrayEquals(array(1,7), ArrayUtils.slice(array(1,7), 0, 7, CMP));
+        assertArrayEquals(array(1,7), ArrayUtils.slice(array(1,7), 1, 7, CMP));
+        assertArrayEquals(array(2,7), ArrayUtils.slice(array(1,7), 2, 7, CMP));
+        assertArrayEquals(array(2,6), ArrayUtils.slice(array(1,7), 2, 6, CMP));
+        assertArrayEquals(array(2,4), ArrayUtils.slice(array(1,7), 2, 4, CMP));
+        assertArrayEquals(array(3,4), ArrayUtils.slice(array(1,7), 3, 4, CMP));
+        assertArrayEquals(array(0,0), ArrayUtils.slice(array(1,7), 3, 2, CMP));
+    }
+    
+    private static int[] array(int begin, int end) {
+        int n = end-begin;
+        int res[] = new int[n];
+        for(int i=0; i<n; i++) {
+            res[i] = begin+i;
+        }
+        return res;
+    }
+    
+    @Test
+    public void testCollect() {
+        IntList input = new IntRange(1, 5);
+        
+        int[] out1 = new int[4];
+        assertEquals(4, ArrayUtils.collect(input.iterator(), out1));
+        assertArrayEquals(new int[]{1,2,3,4}, out1);
+        
+        int[] out2 = new int[]{7,7,7,7,8,9};
+        assertEquals(4, ArrayUtils.collect(input.iterator(), out2));
+        assertArrayEquals(new int[]{1,2,3,4,8,9}, out2);
+    }
+    
+    @Test
+    public void testCollect_bounds() {
+        IntList inp1 = new IntRange(1, 5);
+        
+        int[] out1 = new int[]{7,7,7,7,8,9};
+        assertEquals(4, ArrayUtils.collect(inp1.iterator(), out1, 1, 4));
+        assertArrayEquals(new int[]{7,1,2,3,4,9}, out1);
+        
+        int[] out2 = new int[]{7,7,7,7,8,9};
+        assertEquals(4, ArrayUtils.collect(inp1.iterator(), out2, 2, 4));
+        assertArrayEquals(new int[]{7,7,1,2,3,4}, out2);
+        
+        int[] out3 = new int[]{7,7,7,7,8,9};
+        assertEquals(3, ArrayUtils.collect(inp1.iterator(), out3, 2, 3));
+        assertArrayEquals(new int[]{7,7,1,2,3,9}, out3);
+        
+        int[] out4 = new int[]{7,7,7,7,7,7,7,7};
+        
+        assertEquals(4, ArrayUtils.collect(inp1.iterator(), out4, 1, 6));
+        assertArrayEquals(new int[]{7,1,2,3,4,7,7,7}, out4);
+        
+        int[] out5 = new int[]{7,7};
+        assertEquals(2, ArrayUtils.collect(inp1.iterator(), out5, 0, 2));
+        assertArrayEquals(new int[]{1,2}, out5);
+        
+        int[] out6 = new int[]{7,7};
+        assertEquals(0, ArrayUtils.collect(inp1.iterator(), out6, 0, 0));
+        assertArrayEquals(new int[]{7,7}, out6);
+        
+        int[] out7 = new int[]{7,7,7,7,7,7};
+                
+        assertThrows(IndexOutOfBoundsException.class, ()->{
+            ArrayUtils.collect(inp1.iterator(), out7, -2, 4);
+        });
+        assertThrows(IllegalArgumentException.class, ()->{
+            ArrayUtils.collect(inp1.iterator(), out7, 0, -1);
+        });
+        assertThrows(IndexOutOfBoundsException.class, ()->{
+            ArrayUtils.collect(inp1.iterator(), out7, 0, 20);
+        });
+        assertThrows(IllegalArgumentException.class, ()->{
+            ArrayUtils.collect(inp1.iterator(), out6, 20, 1);
+        });
+    }
+    
+    
+    @Test
+    public void testReverse() {
+        int[] inp1 = new int[]{};
+        int[] inp2 = new int[]{1};
+        int[] inp3 = new int[]{1,2};
+        int[] inp4 = new int[]{1,2,3};
+        int[] inp5 = new int[]{1,2,3,4};
+        
+        assertReverse(new int[]{}, inp1);
+        assertReverse(new int[]{1}, inp2);
+        assertReverse(new int[]{2,1}, inp3);
+        assertReverse(new int[]{3,2,1}, inp4);
+        assertReverse(new int[]{4,3,2,1}, inp5);
+    }
+    
+    private void assertReverse(int[] expected, int[] values) {
+        assertSame(values, ArrayUtils.reverse(values));
+        assertArrayEquals(expected, values);
+    }
+    
+    @Test
+    public void testEquals() {
+        
+        assertFalse( ArrayUtils.equals(new int[1], new int[2]) );
+        
+        assertTrue( ArrayUtils.equals(new int[0], new int[0]) );
+        assertTrue( ArrayUtils.equals(new int[]{1}, new int[]{1}) );
+        assertTrue( ArrayUtils.equals(new int[]{1,2,3}, new int[]{1,2,3}) );
+        
+        assertFalse( ArrayUtils.equals(new int[]{1,2,3}, new int[]{1,2,4}) );
+        assertFalse( ArrayUtils.equals(new int[]{1,2,3}, new int[]{1,4,3}) );
+        assertFalse( ArrayUtils.equals(new int[]{1,2,3}, new int[]{5,2,3}) );
+    }
+    
+    @Test
+    public void testFill_FT() {
+        int[] out1 = new int[4];
+        int[] out2 = new int[4];
+        
+        ArrayUtils.fill(out1, 1, 3, 9);
+        assertArrayEquals(new int[]{0, 9, 9, 0}, out1);
+        
+        ArrayUtils.fill(out2, 0, 3, 9);
+        assertArrayEquals(new int[]{9, 9, 9, 0}, out2);
+    }
+    
+    @Test
+    public void testCopy() {
+        int[] v1 = new int[0];
+        int[] v2 = new int[]{1,2,3,4,5};
+        String[] v3 = new String[]{};
+        String[] v4 = new String[]{"a","b","c","d","e"};
+        
+        assertArrayEquals(v1, ArrayUtils.copy(v1));
+        assertArrayEquals(v2, ArrayUtils.copy(v2));
+        assertArrayEquals(v3, ArrayUtils.copy(v3));
+        assertArrayEquals(v4, ArrayUtils.copy(v4));
+        
+        assertNotSame(v1, ArrayUtils.copy(v1));
+        assertNotSame(v2, ArrayUtils.copy(v2));
+        assertNotSame(v3, ArrayUtils.copy(v3));
+        assertNotSame(v4, ArrayUtils.copy(v4));
+        
+        assertArrayEquals(new int[]{0,0,2,3,4,0}, ArrayUtils.copy(v2,1,new int[6], 2, 3));
+        assertArrayEquals(new int[]{0,0,2,3,4,5,0}, ArrayUtils.copy(v2,1,new int[7], 2, 4));
+        assertArrayEquals(new int[]{0,0,0}, ArrayUtils.copy(v2,1,new int[3],1,0));
+        
+        assertArrayEquals(new String[]{null,null,"b","c","d",null}, ArrayUtils.copy(v4,1,new String[6], 2, 3));
+        assertArrayEquals(new String[]{null,null,"b","c","d","e",null}, ArrayUtils.copy(v4,1,new String[7], 2, 4));
+        assertArrayEquals(new String[]{null,null,null}, ArrayUtils.copy(v4,1,new String[3],1,0));
+    }
+    
+    @Test
+    public void testRotate() {
+        int v1[] = new int[]{1,2,3,4,5,6,7,8};
+        int v2[] = new int[]{1,2,3,4,5,6,7,8};
+        assertArrayEquals(new int[]{7,8,1,2,3,4,5,6}, ArrayUtils.rotate(v1, 2));
+        assertArrayEquals(new int[]{3,4,5,6,7,8,1,2}, ArrayUtils.rotate(v2, -2));
+        
+        String[] v3 = new String[]{"1","2","3","4","5","6","7","8"};
+        String[] v4 = new String[]{"1","2","3","4","5","6","7","8"};
+        assertArrayEquals(new String[]{"7","8","1","2","3","4","5","6"}, ArrayUtils.rotate(v3, 2));
+        assertArrayEquals(new String[]{"3","4","5","6","7","8","1","2"}, ArrayUtils.rotate(v4, -2));
+    }
+    
+}

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

@@ -6,7 +6,11 @@
  */
 package net.ranides.assira.collection.arrays;
 
+import java.util.Arrays;
 import java.util.Comparator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import net.ranides.assira.collection.lists.ListUtils;
 import org.junit.Test;
 import static net.ranides.assira.junit.NewAssert.*;
 
@@ -83,4 +87,114 @@ public class NativeArraySearchTest {
         });
     }
     
+    @Test
+    public void testFirst() {
+		NativeArray list8 = NativeArray.wrap(new String[]{"a", "b", "cc", "d", "ee", "f", "gg", "h"});
+
+		assertThrows(NoSuchElementException.class, ()-> {
+			NativeArraySearch.first(list8, v -> false);
+		});
+		assertThrows(NoSuchElementException.class, ()-> {
+			NativeArraySearch.first(list8, 1, 3, v -> false);
+		});
+		
+		assertEquals("b", NativeArraySearch.first(list8, 1, 3, v -> true));
+		
+		assertEquals("cc", NativeArraySearch.first(list8, (String v) -> v.length()>1));
+		assertEquals("cc", NativeArraySearch.first(list8, 1, 3, (String v) -> v.length()>1));
+		assertEquals("ee", NativeArraySearch.first(list8, 3, 5, (String v) -> v.length()>1));
+    }
+	
+	@Test
+    public void testLast() {
+		NativeArray list8 = NativeArray.wrap(new String[]{"a", "b", "cc", "d", "ee", "f", "gg", "h"});
+
+		assertThrows(NoSuchElementException.class, ()-> {
+			NativeArraySearch.last(list8, v -> false);
+		});
+		assertThrows(NoSuchElementException.class, ()-> {
+			NativeArraySearch.last(list8, 1, 3, v -> false);
+		});
+		
+		assertEquals("d", NativeArraySearch.last(list8, 1, 4, v -> true));
+		
+		assertEquals("gg", NativeArraySearch.last(list8, (String v) -> v.length()>1));
+		assertEquals("ee", NativeArraySearch.last(list8, 1, 6, (String v) -> v.length()>1));
+		assertEquals("cc", NativeArraySearch.last(list8, 1, 3, (String v) -> v.length()>1));
+    }
+    
+    @Test
+    public void testIndexOf() {
+        NativeArray list0 = NativeArray.wrap(new String[]{});
+        NativeArray list1 = NativeArray.wrap(new String[]{"a"});
+        NativeArray list8 = NativeArray.wrap(new String[]{"a", "b", "c", "d", "c", "e", "d", "f"});
+        
+        assertEquals(-1, NativeArraySearch.indexOf(list0, "q"));
+        assertEquals(-1, NativeArraySearch.indexOf(list1, "q"));
+        assertEquals(-1, NativeArraySearch.indexOf(list8, "q"));
+        
+        assertEquals(0, NativeArraySearch.indexOf(list1, "a"));
+        assertEquals(2, NativeArraySearch.indexOf(list8, "c"));
+        assertEquals(7, NativeArraySearch.indexOf(list8, "f"));
+        
+        assertThrows(IndexOutOfBoundsException.class, ()->{
+            NativeArraySearch.indexOf(list1, 1, 3, "a");
+        });
+        
+        assertEquals(0, NativeArraySearch.indexOf(list8, 0, 3, "a"));
+        assertEquals(-1, NativeArraySearch.indexOf(list8, 1, 3, "a"));
+        assertEquals(2, NativeArraySearch.indexOf(list8, 1, 6, "c"));
+        assertEquals(4, NativeArraySearch.indexOf(list8, 3, 6, "c"));
+    }
+    
+    @Test
+    public void testLastIndexOf() {
+        NativeArray list0 = NativeArray.wrap(new String[]{});
+        NativeArray list1 = NativeArray.wrap(new String[]{"a"});
+        NativeArray list8 = NativeArray.wrap(new String[]{"a", "b", "c", "d", "c", "e", "d", "f"});
+        
+        assertEquals(-1, NativeArraySearch.lastIndexOf(list0, "q"));
+        assertEquals(-1, NativeArraySearch.lastIndexOf(list1, "q"));
+        assertEquals(-1, NativeArraySearch.lastIndexOf(list8, "q"));
+        
+        assertEquals(0, NativeArraySearch.lastIndexOf(list1, "a"));
+        assertEquals(4, NativeArraySearch.lastIndexOf(list8, "c"));
+        assertEquals(7, NativeArraySearch.lastIndexOf(list8, "f"));
+        
+        assertThrows(IndexOutOfBoundsException.class, ()->{
+            NativeArraySearch.lastIndexOf(list1, 1, 3, "a");
+        });
+        
+        assertEquals(0, NativeArraySearch.lastIndexOf(list8, 0, 3, "a"));
+        assertEquals(-1, NativeArraySearch.lastIndexOf(list8, 1, 3, "a"));
+        assertEquals(4, NativeArraySearch.lastIndexOf(list8, 1, 6, "c"));
+        assertEquals(2, NativeArraySearch.lastIndexOf(list8, 1, 3, "c"));
+    }
+    
+    @Test
+    public void testContains() {
+        NativeArray list0 = NativeArray.wrap(new String[]{});
+        NativeArray list1 = NativeArray.wrap(new String[]{"a"});
+        NativeArray list8 = NativeArray.wrap(new String[]{"a", "b", "c", "d", "c", "e", "d", "f"});
+        
+        assertEquals(false, NativeArraySearch.contains(list0, "q"));
+        assertEquals(false, NativeArraySearch.contains(list1, "q"));
+        assertEquals(false, NativeArraySearch.contains(list8, "q"));
+        
+        assertEquals(true, NativeArraySearch.contains(list1, "a"));
+        assertEquals(true, NativeArraySearch.contains(list8, "c"));
+        assertEquals(true, NativeArraySearch.contains(list8, "f"));
+        
+        assertThrows(IndexOutOfBoundsException.class, ()->{
+            NativeArraySearch.contains(list1, 1, 3, "a");
+        });
+        
+        assertEquals(true, NativeArraySearch.contains(list8, 0, 3, "a"));
+        assertEquals(false, NativeArraySearch.contains(list8, 1, 3, "a"));
+        assertEquals(true, NativeArraySearch.contains(list8, 2, 6, "c"));
+        assertEquals(false, NativeArraySearch.contains(list8, 2, 2, "c"));
+        assertEquals(true, NativeArraySearch.contains(list8, 1, 6, "c"));
+        assertEquals(true, NativeArraySearch.contains(list8, 3, 6, "c"));
+    }
+    
 }

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

@@ -58,25 +58,25 @@ public class NativeArrayUtilsTest {
         List<Integer> input = Arrays.asList(1,2,3,4);
         
         Integer[] out1 = new Integer[4];
-        assertEquals(4, NativeArrayUtils.collect(input.iterator(), NativeArray.wrap(out1)));
+        assertEquals(4, NativeArrayUtils.collect(input.iterator(), $a(out1)));
         assertArrayEquals(new Integer[]{1,2,3,4}, out1);
         
         Integer[] out2 = new Integer[]{7,7,7,7,8,9};
-        assertEquals(4, NativeArrayUtils.collect(input.iterator(), NativeArray.wrap(out2)));
+        assertEquals(4, NativeArrayUtils.collect(input.iterator(), $a(out2)));
         assertArrayEquals(new Integer[]{1,2,3,4,8,9}, out2);
         
         assertThrows(ArrayStoreException.class, ()->{
             // mamy brzydki mismatch, zrobiło nam T = Number :)
             Integer[] out3 = new Integer[]{7,7,7,7,8,9};
             List<Short> inp3 = Arrays.<Short>asList((short)1,(short)2,(short)3,(short)4);
-            NativeArrayUtils.collect(inp3.iterator(), NativeArray.wrap(out3));
+            NativeArrayUtils.collect(inp3.iterator(), $a(out3));
         });
         
         // tutaj mamy poprawne rozpoznanie T = Number
         Number[] out4 = new Number[]{7,7,7,7,8,9L};
         List<Short> inp4 = Arrays.<Short>asList((short)1,(short)2,(short)3,(short)4);
         Number[] exp4 = new Number[]{ (short)1,(short)2,(short)3,(short)4,(int)8,9L };
-        assertEquals(4, NativeArrayUtils.collect(inp4.iterator(), NativeArray.wrap(out4)));
+        assertEquals(4, NativeArrayUtils.collect(inp4.iterator(), $a(out4)));
         assertArrayEquals(exp4, out4);
     }
     
@@ -85,59 +85,59 @@ public class NativeArrayUtilsTest {
         List<Integer> input = Arrays.asList(1,2,3,4);
         
         Integer[] out1 = new Integer[]{7,7,7,7,8,9};
-        assertEquals(4, NativeArrayUtils.collect(input.iterator(), NativeArray.wrap(out1), 1, 4));
+        assertEquals(4, NativeArrayUtils.collect(input.iterator(), $a(out1), 1, 4));
         assertArrayEquals(new Integer[]{7,1,2,3,4,9}, out1);
         
         Integer[] out2 = new Integer[]{7,7,7,7,8,9};
-        assertEquals(4, NativeArrayUtils.collect(input.iterator(), NativeArray.wrap(out2), 2, 4));
+        assertEquals(4, NativeArrayUtils.collect(input.iterator(), $a(out2), 2, 4));
         assertArrayEquals(new Integer[]{7,7,1,2,3,4}, out2);
         
         Integer[] out3 = new Integer[]{7,7,7,7,8,9};
-        assertEquals(3, NativeArrayUtils.collect(input.iterator(), NativeArray.wrap(out3), 2, 3));
+        assertEquals(3, NativeArrayUtils.collect(input.iterator(), $a(out3), 2, 3));
         assertArrayEquals(new Integer[]{7,7,1,2,3,9}, out3);
         
         Integer[] out4 = new Integer[]{7,7,7,7,7,7,7,7};
         
-        assertEquals(4, NativeArrayUtils.collect(input.iterator(), NativeArray.wrap(out4), 1, 6));
+        assertEquals(4, NativeArrayUtils.collect(input.iterator(), $a(out4), 1, 6));
         assertArrayEquals(new Integer[]{7,1,2,3,4,7,7,7}, out4);
         
         Integer[] out5 = new Integer[]{7,7};
-        assertEquals(2, NativeArrayUtils.collect(input.iterator(), NativeArray.wrap(out5), 0, 2));
+        assertEquals(2, NativeArrayUtils.collect(input.iterator(), $a(out5), 0, 2));
         assertArrayEquals(new Integer[]{1,2}, out5);
         
         Integer[] out6 = new Integer[]{7,7};
-        assertEquals(0, NativeArrayUtils.collect(input.iterator(), NativeArray.wrap(out6), 0, 0));
+        assertEquals(0, NativeArrayUtils.collect(input.iterator(), $a(out6), 0, 0));
         assertArrayEquals(new Integer[]{7,7}, out6);
         
         Integer[] out7 = new Integer[]{7,7,7,7,7,7};
                 
         assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
-            NativeArrayUtils.collect(input.iterator(), NativeArray.wrap(out7), -2, 4);
+            NativeArrayUtils.collect(input.iterator(), $a(out7), -2, 4);
         });
         assertThrows(IllegalArgumentException.class, ()->{
-            NativeArrayUtils.collect(input.iterator(), NativeArray.wrap(out7), 0, -1);
+            NativeArrayUtils.collect(input.iterator(), $a(out7), 0, -1);
         });
         assertThrows(ArrayIndexOutOfBoundsException.class, ()->{
-            NativeArrayUtils.collect(input.iterator(), NativeArray.wrap(out7), 0, 20);
+            NativeArrayUtils.collect(input.iterator(), $a(out7), 0, 20);
         });
         assertThrows(IllegalArgumentException.class, ()->{
-            NativeArrayUtils.collect(input.iterator(), NativeArray.wrap(out6), 20, 1);
+            NativeArrayUtils.collect(input.iterator(), $a(out6), 20, 1);
         });
     }
     
     @Test
     public void testReverse() {
-        NativeArray inp1 = NativeArray.wrap(new Integer[]{});
-        NativeArray inp2 = NativeArray.wrap(new Integer[]{1});
-        NativeArray inp3 = NativeArray.wrap(new Integer[]{1,2});
-        NativeArray inp4 = NativeArray.wrap(new Integer[]{1,2,3});
-        NativeArray inp5 = NativeArray.wrap(new Integer[]{1,2,3,4});
-        
-        assertReverse(NativeArray.wrap(new Integer[]{}), inp1);
-        assertReverse(NativeArray.wrap(new Integer[]{1}), inp2);
-        assertReverse(NativeArray.wrap(new Integer[]{2,1}), inp3);
-        assertReverse(NativeArray.wrap(new Integer[]{3,2,1}), inp4);
-        assertReverse(NativeArray.wrap(new Integer[]{4,3,2,1}), inp5);
+        NativeArray inp1 = $a(new Integer[]{});
+        NativeArray inp2 = $a(new Integer[]{1});
+        NativeArray inp3 = $a(new Integer[]{1,2});
+        NativeArray inp4 = $a(new Integer[]{1,2,3});
+        NativeArray inp5 = $a(new Integer[]{1,2,3,4});
+        
+        assertReverse($a(new Integer[]{}), inp1);
+        assertReverse($a(new Integer[]{1}), inp2);
+        assertReverse($a(new Integer[]{2,1}), inp3);
+        assertReverse($a(new Integer[]{3,2,1}), inp4);
+        assertReverse($a(new Integer[]{4,3,2,1}), inp5);
     }
     
     private <T> void assertReverse(NativeArray expected, NativeArray values) {
@@ -163,7 +163,7 @@ public class NativeArrayUtilsTest {
     }
     
     private <A> boolean nae(A a, A b) {
-        return NativeArrayUtils.equals(NativeArray.wrap(a), NativeArray.wrap(b));
+        return NativeArrayUtils.equals($a(a), $a(b));
     }
     
     @Test
@@ -171,12 +171,42 @@ public class NativeArrayUtilsTest {
         String[] out1 = new String[4];
         String[] out2 = new String[4];
         
-        NativeArrayUtils.fill(NativeArray.wrap(out1), 1, 3, "#");
+        NativeArrayUtils.fill($a(out1), 1, 3, "#");
         assertArrayEquals(new String[]{null, "#", "#", null}, out1);
         
-        NativeArrayUtils.fill(NativeArray.wrap(out2), 0, 3, "#");
+        NativeArrayUtils.fill($a(out2), 0, 3, "#");
         assertArrayEquals(new String[]{"#", "#", "#", null}, out2);
     }
+    
+    @Test
+    public void testCopy() {
+        NativeArray v1 = $a(new int[0]);
+        NativeArray v2 = $a(new int[]{1,2,3,4,5});
+        NativeArray v3 = $a(new String[]{});
+        NativeArray v4 = $a(new String[]{"a","b","c","d","e"});
+        
+        assertEquals(v1, NativeArrayUtils.copy(v1));
+        assertEquals(v2, NativeArrayUtils.copy(v2));
+        assertEquals(v3, NativeArrayUtils.copy(v3));
+        assertEquals(v4, NativeArrayUtils.copy(v4));
+        
+        assertNotSame(v1, NativeArrayUtils.copy(v1));
+        assertNotSame(v2, NativeArrayUtils.copy(v2));
+        assertNotSame(v3, NativeArrayUtils.copy(v3));
+        assertNotSame(v4, NativeArrayUtils.copy(v4));
+        
+        assertEquals($a(new int[]{0,0,2,3,4,0}), NativeArrayUtils.copy(v2,1,$a(new int[6]), 2, 3));
+        assertEquals($a(new int[]{0,0,2,3,4,5,0}), NativeArrayUtils.copy(v2,1,$a(new int[7]), 2, 4));
+        assertEquals($a(new int[]{0,0,0}), NativeArrayUtils.copy(v2,1,$a(new int[3]),1,0));
+        
+        assertEquals($a(new String[]{null,null,"b","c","d",null}), NativeArrayUtils.copy(v4,1,$a(new String[6]), 2, 3));
+        assertEquals($a(new String[]{null,null,"b","c","d","e",null}), NativeArrayUtils.copy(v4,1,$a(new String[7]), 2, 4));
+        assertEquals($a(new String[]{null,null,null}), NativeArrayUtils.copy(v4,1,$a(new String[3]),1,0));
+    }
+    
+    private static NativeArray $a(Object array) {
+        return NativeArray.wrap(array);
+    }
       
     private static NativeArray array(int begin, int end) {
         int n = end-begin;