Added wrapped methods for creating streams from primitive arrays

Author: Damtev

utbot-framework/src/main/java/org/utbot/engine/overrides/collections/Collection.java

@@ -9,19 +9,15 @@
 public interface Collection<E> extends java.util.Collection<E> {
     @SuppressWarnings("unchecked")
     @Override
-    default Stream<E> parallelStream() {
+    default Stream<E> stream() {
         Object[] data = toArray();
         int size = data.length;
 
         return new UtStream<>((E[]) data, size);
     }
 
-    @SuppressWarnings("unchecked")
     @Override
-    default Stream<E> stream() {
-        Object[] data = toArray();
-        int size = data.length;
-
-        return new UtStream<>((E[]) data, size);
+    default Stream<E> parallelStream() {
+        return stream();
     }
 }

utbot-framework/src/main/java/org/utbot/engine/overrides/stream/Arrays.java

@@ -4,6 +4,9 @@
 import org.utbot.engine.overrides.collections.UtArrayList;
 
 import java.util.List;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
 import java.util.stream.Stream;
 
 @UtClassMock(target = java.util.Arrays.class, internalUsage = true)
@@ -18,6 +21,54 @@ public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusi
         return new UtStream<>(array, startInclusive, endExclusive);
     }
 
+    // from docs - array is assumed to be umnodified during use
+    public static IntStream stream(int[] array, int startInclusive, int endExclusive) {
+        int size = array.length;
+
+        if (startInclusive < 0 || endExclusive < startInclusive || endExclusive > size) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+
+        Integer[] data = new Integer[size];
+        for (int i = 0; i < size; i++) {
+            data[i] = array[i];
+        }
+
+        return new UtIntStream(data, startInclusive, endExclusive);
+    }
+
+    // from docs - array is assumed to be umnodified during use
+    public static LongStream stream(long[] array, int startInclusive, int endExclusive) {
+        int size = array.length;
+
+        if (startInclusive < 0 || endExclusive < startInclusive || endExclusive > size) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+
+        Long[] data = new Long[size];
+        for (int i = 0; i < size; i++) {
+            data[i] = array[i];
+        }
+
+        return new UtLongStream(data, startInclusive, endExclusive);
+    }
+
+    // from docs - array is assumed to be umnodified during use
+    public static DoubleStream stream(double[] array, int startInclusive, int endExclusive) {
+        int size = array.length;
+
+        if (startInclusive < 0 || endExclusive < startInclusive || endExclusive > size) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+
+        Double[] data = new Double[size];
+        for (int i = 0; i < size; i++) {
+            data[i] = array[i];
+        }
+
+        return new UtDoubleStream(data, startInclusive, endExclusive);
+    }
+
     @SuppressWarnings({"unused", "varargs"})
     @SafeVarargs
     public static <T> List<T> asList(T... a) {

utbot-framework/src/main/java/org/utbot/engine/overrides/stream/UtDoubleStream.java

@@ -51,10 +51,17 @@ public UtDoubleStream() {
     }
 
     public UtDoubleStream(Double[] data, int length) {
+        this(data, 0, length);
+    }
+
+    public UtDoubleStream(Double[] data, int startInclusive, int endExclusive) {
         visit(this);
+
+        int size = endExclusive - startInclusive;
+
         elementData = new RangeModifiableUnlimitedArray<>();
-        elementData.setRange(0, data, 0, length);
-        elementData.end = length;
+        elementData.setRange(0, data, startInclusive, size);
+        elementData.end = endExclusive;
     }
 
     /**

utbot-framework/src/main/java/org/utbot/engine/overrides/stream/UtIntStream.java

@@ -52,10 +52,17 @@ public UtIntStream() {
     }
 
     public UtIntStream(Integer[] data, int length) {
+        this(data, 0, length);
+    }
+
+    public UtIntStream(Integer[] data, int startInclusive, int endExclusive) {
         visit(this);
+
+        int size = endExclusive - startInclusive;
+
         elementData = new RangeModifiableUnlimitedArray<>();
-        elementData.setRange(0, data, 0, length);
-        elementData.end = length;
+        elementData.setRange(0, data, startInclusive, size);
+        elementData.end = endExclusive;
     }
 
     /**

utbot-framework/src/main/java/org/utbot/engine/overrides/stream/UtLongStream.java

@@ -52,10 +52,17 @@ public UtLongStream() {
     }
 
     public UtLongStream(Long[] data, int length) {
+        this(data, 0, length);
+    }
+
+    public UtLongStream(Long[] data, int startInclusive, int endExclusive) {
         visit(this);
+
+        int size = endExclusive - startInclusive;
+
         elementData = new RangeModifiableUnlimitedArray<>();
-        elementData.setRange(0, data, 0, length);
-        elementData.end = length;
+        elementData.setRange(0, data, startInclusive, size);
+        elementData.end = endExclusive;
     }
 
     /**

utbot-framework/src/main/java/org/utbot/engine/overrides/stream/UtStream.java

@@ -56,10 +56,7 @@ public UtStream() {
     }
 
     public UtStream(E[] data, int length) {
-        visit(this);
-        elementData = new RangeModifiableUnlimitedArray<>();
-        elementData.setRange(0, data, 0, length);
-        elementData.end = length;
+        this(data, 0, length);
     }
 
     public UtStream(E[] data, int startInclusive, int endExclusive) {
@@ -185,6 +182,7 @@ public DoubleStream mapToDouble(ToDoubleFunction<? super E> mapper) {
 
         int size = elementData.end;
         Double[] data = new Double[size];
+        assume(data.length == elementData.end);
         for (int i = 0; i < size; i++) {
             final Object object = elementData.get(i);
             UtMock.disableClassCastExceptionCheck(object);