Implemented UtStream

Author: Kamenev Yury

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/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({"UnnecessaryInterfaceModifier", "unused"})
+@UtClassMock(target = java.util.stream.Stream.class, internalUsage = true)
+public interface Stream<E> extends BaseStream<E, Stream<E>> {
+    @SuppressWarnings("unchecked")
+    public 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")
+    public static <E> java.util.stream.Stream<E> of(E... elements) {
+        int size = elements.length;
+
+        return new UtStream<>(elements, size);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <E> java.util.stream.Stream<E> empty() {
+        return new UtStream<>((E[]) new Object[]{}, 0);
+    }
+
+    public 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;
+    }
+
+    public 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;
+    }
+    
+    public 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;
+    }
+}