Wrapper for basic Stream

utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/impl/FieldIdStrategies.kt

@@ -47,7 +47,7 @@ class FieldIdReflectionStrategy(val fieldId: FieldId) : FieldIdStrategy {
         get() = Modifier.isStatic(fieldId.field.modifiers)
 
     override val isSynthetic: Boolean
-        get() = false
+        get() = fieldId.field.isSynthetic
 
     override val type: ClassId
         get() = fieldId.field.type.id

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

@@ -0,0 +1,27 @@
+package org.utbot.engine.overrides.collections;
+
+import org.utbot.api.annotation.UtClassMock;
+import org.utbot.engine.overrides.stream.UtStream;
+
+import java.util.stream.Stream;
+
+@UtClassMock(target = java.util.Collection.class, internalUsage = true)
+public interface Collection<E> extends java.util.Collection<E> {
+    @SuppressWarnings("unchecked")
+    @Override
+    default Stream<E> parallelStream() {
+        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);
+    }
+}

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

@@ -13,7 +13,10 @@
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
+import java.util.stream.Stream;
+
 import org.jetbrains.annotations.NotNull;
+import org.utbot.engine.overrides.stream.UtStream;
 
 import static org.utbot.api.mock.UtMock.assume;
 import static org.utbot.engine.ResolverKt.MAX_LIST_SIZE;
@@ -361,6 +364,28 @@ public void replaceAll(UnaryOperator<E> operator) {
         }
     }
 
+    @SuppressWarnings("unchecked")
+    @Override
+    public Stream<E> stream() {
+        preconditionCheck();
+
+        int size = elementData.end;
+        Object[] data = elementData.toArray(0, size);
+
+        return new UtStream<>((E[]) data, size);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public Stream<E> parallelStream() {
+        preconditionCheck();
+
+        int size = elementData.end;
+        Object[] data = elementData.toArray(0, size);
+
+        return new UtStream<>((E[]) data, size);
+    }
+
     /**
      * Auxiliary method, that should be only executed concretely
      * @return new ArrayList with all the elements from this.

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

@@ -8,7 +8,10 @@
 import java.util.Objects;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
+import java.util.stream.Stream;
+
 import org.jetbrains.annotations.NotNull;
+import org.utbot.engine.overrides.stream.UtStream;
 
 import static org.utbot.api.mock.UtMock.assume;
 import static org.utbot.engine.overrides.UtOverrideMock.alreadyVisited;
@@ -263,6 +266,28 @@ public Iterator<E> iterator() {
         return new UtHashSetIterator();
     }
 
+    @SuppressWarnings("unchecked")
+    @Override
+    public Stream<E> stream() {
+        preconditionCheck();
+
+        int size = elementData.end;
+        Object[] data = elementData.toArray(0, size);
+
+        return new UtStream<>((E[]) data, size);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public Stream<E> parallelStream() {
+        preconditionCheck();
+
+        int size = elementData.end;
+        Object[] data = elementData.toArray(0, size);
+
+        return new UtStream<>((E[]) data, size);
+    }
+
     public class UtHashSetIterator implements Iterator<E> {
         int index = 0;
 

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

@@ -13,7 +13,10 @@
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
+import java.util.stream.Stream;
+
 import org.jetbrains.annotations.NotNull;
+import org.utbot.engine.overrides.stream.UtStream;
 
 import static org.utbot.api.mock.UtMock.assume;
 import static org.utbot.engine.ResolverKt.MAX_LIST_SIZE;
@@ -448,6 +451,29 @@ public Iterator<E> descendingIterator() {
         preconditionCheck();
         return new ReverseIteratorWrapper(elementData.end);
     }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public Stream<E> stream() {
+        preconditionCheck();
+
+        int size = elementData.end;
+        Object[] data = elementData.toArray(0, size);
+
+        return new UtStream<>((E[]) data, size);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public Stream<E> parallelStream() {
+        preconditionCheck();
+
+        int size = elementData.end;
+        Object[] data = elementData.toArray(0, size);
+
+        return new UtStream<>((E[]) data, size);
+    }
+
     public class ReverseIteratorWrapper implements ListIterator<E> {
 
         int index;

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

@@ -0,0 +1,20 @@
+package org.utbot.engine.overrides.stream;
+
+import org.utbot.api.annotation.UtClassMock;
+
+import java.util.stream.Stream;
+
+@UtClassMock(target = java.util.Arrays.class, internalUsage = true)
+public class Arrays {
+    public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive) {
+        int size = array.length;
+
+        if (startInclusive < 0 || endExclusive < startInclusive || endExclusive > size) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+
+        return new UtStream<>(array, startInclusive, endExclusive);
+    }
+
+    // TODO primitive arrays https://github.com/UnitTestBot/UTBotJava/issues/146
+}

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

@@ -0,0 +1,54 @@
+package org.utbot.engine.overrides.stream;
+
+import org.utbot.api.annotation.UtClassMock;
+
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+import java.util.stream.BaseStream;
+
+import static org.utbot.engine.overrides.UtOverrideMock.executeConcretely;
+
+@SuppressWarnings("unused")
+@UtClassMock(target = java.util.stream.Stream.class, internalUsage = true)
+public interface Stream<E> extends BaseStream<E, Stream<E>> {
+    @SuppressWarnings("unchecked")
+    static <E> java.util.stream.Stream<E> of(E element) {
+        Object[] data = new Object[1];
+        data[0] = element;
+
+        return new UtStream<>((E[]) data, 1);
+    }
+
+    @SuppressWarnings("unchecked")
+    static <E> java.util.stream.Stream<E> of(E... elements) {
+        int size = elements.length;
+
+        return new UtStream<>(elements, size);
+    }
+
+    @SuppressWarnings("unchecked")
+    static <E> java.util.stream.Stream<E> empty() {
+        return new UtStream<>((E[]) new Object[]{}, 0);
+    }
+
+    static <E> java.util.stream.Stream<E> generate(Supplier<E> s) {
+        // as "generate" method produces an infinite stream, we cannot analyze it symbolically
+        executeConcretely();
+        return null;
+    }
+
+    static <E> java.util.stream.Stream<E> iterate(final E seed, final UnaryOperator<E> f) {
+        // as "iterate" method produces an infinite stream, we cannot analyze it symbolically
+        executeConcretely();
+        return null;
+    }
+
+     static <E> java.util.stream.Stream<E> concat(
+            java.util.stream.Stream<? extends E> a, 
+            java.util.stream.Stream<? extends E> b
+    ) {
+        // as provided streams might be infinite, we cannot analyze this method symbolically
+        executeConcretely();
+        return null;
+    }
+}