Fixed failed tests

Damtev · Damtev · commit 6f2bed75751c · 2022-09-07T17:26:53.000+03:00
diff --git a/utbot-framework-test/src/test/kotlin/org/utbot/examples/stream/DoubleStreamExampleTest.kt b/utbot-framework-test/src/test/kotlin/org/utbot/examples/stream/DoubleStreamExampleTest.kt
@@ -175,7 +175,6 @@ class DoubleStreamExampleTest : UtValueTestCaseChecker(
     }
 
     @Test
-    @Disabled("TODO wrong returned value")
     fun testPeekExample() {
         checkThisAndStaticsAfter(
             DoubleStreamExample::peekExample,
@@ -186,25 +185,23 @@ class DoubleStreamExampleTest : UtValueTestCaseChecker(
     }
 
     @Test
-    @Disabled("TODO unable to find second branch, even after exceeding steps limit")
     fun testLimitExample() {
         check(
             DoubleStreamExample::limitExample,
             ignoreExecutionsNumber,
-            { c, r -> c.size <= 5 && c.doubles().contentEquals(r) },
-            { c, r -> c.size > 5 && c.take(5).doubles().contentEquals(r) },
+            { c, r -> c.size <= 2 && c.doubles().contentEquals(r) },
+            { c, r -> c.size > 2 && c.take(2).doubles().contentEquals(r) },
             coverage = FullWithAssumptions(assumeCallsNumber = 1)
         )
     }
 
     @Test
-    @Disabled("TODO unable to find second branch, even after exceeding steps limit")
     fun testSkipExample() {
         check(
             DoubleStreamExample::skipExample,
             ignoreExecutionsNumber,
-            { c, r -> c.size > 5 && c.drop(5).doubles().contentEquals(r) },
-            { c, r -> c.size <= 5 && r!!.isEmpty() },
+            { c, r -> c.size > 2 && c.drop(2).doubles().contentEquals(r) },
+            { c, r -> c.size <= 2 && r!!.isEmpty() },
             coverage = FullWithAssumptions(assumeCallsNumber = 1)
         )
     }
diff --git a/utbot-framework-test/src/test/kotlin/org/utbot/examples/stream/IntStreamExampleTest.kt b/utbot-framework-test/src/test/kotlin/org/utbot/examples/stream/IntStreamExampleTest.kt
@@ -184,25 +184,23 @@ class IntStreamExampleTest : UtValueTestCaseChecker(
     }
 
     @Test
-    @Disabled("TODO unable to find second branch, even after exceeding steps limit")
     fun testLimitExample() {
         check(
             IntStreamExample::limitExample,
             ignoreExecutionsNumber,
-            { c, r -> c.size <= 5 && c.ints().contentEquals(r) },
-            { c, r -> c.size > 5 && c.take(5).ints().contentEquals(r) },
+            { c, r -> c.size <= 2 && c.ints().contentEquals(r) },
+            { c, r -> c.size > 2 && c.take(2).ints().contentEquals(r) },
             coverage = FullWithAssumptions(assumeCallsNumber = 1)
         )
     }
 
     @Test
-    @Disabled("TODO unable to find second branch, even after exceeding steps limit")
     fun testSkipExample() {
         check(
             IntStreamExample::skipExample,
             ignoreExecutionsNumber,
-            { c, r -> c.size > 5 && c.drop(5).ints().contentEquals(r) },
-            { c, r -> c.size <= 5 && r!!.isEmpty() },
+            { c, r -> c.size > 2 && c.drop(2).ints().contentEquals(r) },
+            { c, r -> c.size <= 2 && r!!.isEmpty() },
             coverage = FullWithAssumptions(assumeCallsNumber = 1)
         )
     }
diff --git a/utbot-framework-test/src/test/kotlin/org/utbot/examples/stream/LongStreamExampleTest.kt b/utbot-framework-test/src/test/kotlin/org/utbot/examples/stream/LongStreamExampleTest.kt
@@ -184,25 +184,23 @@ class LongStreamExampleTest : UtValueTestCaseChecker(
     }
 
     @Test
-    @Disabled("TODO unable to find second branch, even after exceeding steps limit")
     fun testLimitExample() {
         check(
             LongStreamExample::limitExample,
             ignoreExecutionsNumber,
-            { c, r -> c.size <= 5 && c.longs().contentEquals(r) },
-            { c, r -> c.size > 5 && c.take(5).longs().contentEquals(r) },
+            { c, r -> c.size <= 2 && c.longs().contentEquals(r) },
+            { c, r -> c.size > 2 && c.take(2).longs().contentEquals(r) },
             coverage = FullWithAssumptions(assumeCallsNumber = 1)
         )
     }
 
     @Test
-    @Disabled("TODO unable to find second branch, even after exceeding steps limit")
     fun testSkipExample() {
         check(
             LongStreamExample::skipExample,
             ignoreExecutionsNumber,
-            { c, r -> c.size > 5 && c.drop(5).longs().contentEquals(r) },
-            { c, r -> c.size <= 5 && r!!.isEmpty() },
+            { c, r -> c.size > 2 && c.drop(2).longs().contentEquals(r) },
+            { c, r -> c.size <= 2 && r!!.isEmpty() },
             coverage = FullWithAssumptions(assumeCallsNumber = 1)
         )
     }
diff --git a/utbot-sample/src/main/java/org/utbot/examples/stream/BaseStreamExample.java b/utbot-sample/src/main/java/org/utbot/examples/stream/BaseStreamExample.java
@@ -173,12 +173,16 @@ int peekExample(List<Integer> list) {
         int beforeStaticValue = x;
 
         final Consumer<Integer> action = value -> x += value;
+        final Stream<Integer> stream = list.stream();
         if (list.contains(null)) {
-            list.stream().peek(action);
+            stream.peek(action);
         } else {
-            list.stream().peek(action);
+            stream.peek(action);
         }
 
+        // use terminal operation to force peek action
+        stream.count();
+
         return beforeStaticValue;
     }
 
diff --git a/utbot-sample/src/main/java/org/utbot/examples/stream/DoubleStreamExample.java b/utbot-sample/src/main/java/org/utbot/examples/stream/DoubleStreamExample.java
@@ -158,6 +158,9 @@ int peekExample(List<Short> list) {
             doubles.peek(action);
         }
 
+        // use terminal operation to force peek action
+        doubles.count();
+
         return beforeStaticValue;
     }
 
@@ -167,10 +170,10 @@ int peekExample(List<Short> list) {
         final ToDoubleFunction<Short> shortToDoubleFunction = value -> value == null ? 0 : value.doubleValue();
         final DoubleStream doubles = list.stream().mapToDouble(shortToDoubleFunction);
 
-        if (list.size() <= 5) {
-            return doubles.limit(5).toArray();
+        if (list.size() <= 2) {
+            return doubles.limit(2).toArray();
         } else {
-            return doubles.limit(5).toArray();
+            return doubles.limit(2).toArray();
         }
     }
 
@@ -180,10 +183,10 @@ int peekExample(List<Short> list) {
         final ToDoubleFunction<Short> shortToDoubleFunction = value -> value == null ? 0 : value.doubleValue();
         final DoubleStream doubles = list.stream().mapToDouble(shortToDoubleFunction);
 
-        if (list.size() <= 5) {
-            return doubles.skip(5).toArray();
+        if (list.size() <= 2) {
+            return doubles.skip(2).toArray();
         } else {
-            return doubles.skip(5).toArray();
+            return doubles.skip(2).toArray();
         }
     }
 
diff --git a/utbot-sample/src/main/java/org/utbot/examples/stream/IntStreamExample.java b/utbot-sample/src/main/java/org/utbot/examples/stream/IntStreamExample.java
@@ -161,6 +161,9 @@ int peekExample(List<Short> list) {
             ints.peek(action);
         }
 
+        // use terminal operation to force peek action
+        ints.count();
+
         return beforeStaticValue;
     }
 
@@ -170,10 +173,10 @@ int[] limitExample(List<Short> list) {
         final ToIntFunction<Short> shortToIntFunction = value -> value == null ? 0 : value.intValue();
         final IntStream ints = list.stream().mapToInt(shortToIntFunction);
 
-        if (list.size() <= 5) {
-            return ints.limit(5).toArray();
+        if (list.size() <= 2) {
+            return ints.limit(2).toArray();
         } else {
-            return ints.limit(5).toArray();
+            return ints.limit(2).toArray();
         }
     }
 
@@ -183,10 +186,10 @@ int[] skipExample(List<Short> list) {
         final ToIntFunction<Short> shortToIntFunction = value -> value == null ? 0 : value.intValue();
         final IntStream ints = list.stream().mapToInt(shortToIntFunction);
 
-        if (list.size() <= 5) {
-            return ints.skip(5).toArray();
+        if (list.size() <= 2) {
+            return ints.skip(2).toArray();
         } else {
-            return ints.skip(5).toArray();
+            return ints.skip(2).toArray();
         }
     }
 
diff --git a/utbot-sample/src/main/java/org/utbot/examples/stream/LongStreamExample.java b/utbot-sample/src/main/java/org/utbot/examples/stream/LongStreamExample.java
@@ -160,6 +160,9 @@ int peekExample(List<Short> list) {
             longs.peek(action);
         }
 
+        // use terminal operation to force peek action
+        longs.count();
+
         return beforeStaticValue;
     }
 
@@ -169,10 +172,10 @@ long[] limitExample(List<Short> list) {
         final ToLongFunction<Short> shortToLongFunction = value -> value == null ? 0 : value.longValue();
         final LongStream longs = list.stream().mapToLong(shortToLongFunction);
 
-        if (list.size() <= 5) {
-            return longs.limit(5).toArray();
+        if (list.size() <= 2) {
+            return longs.limit(2).toArray();
         } else {
-            return longs.limit(5).toArray();
+            return longs.limit(2).toArray();
         }
     }
 
@@ -182,10 +185,10 @@ long[] skipExample(List<Short> list) {
         final ToLongFunction<Short> shortToLongFunction = value -> value == null ? 0 : value.longValue();
         final LongStream longs = list.stream().mapToLong(shortToLongFunction);
 
-        if (list.size() <= 5) {
-            return longs.skip(5).toArray();
+        if (list.size() <= 2) {
+            return longs.skip(2).toArray();
         } else {
-            return longs.skip(5).toArray();
+            return longs.skip(2).toArray();
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -175,7 +175,6 @@ class DoubleStreamExampleTest : UtValueTestCaseChecker(`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`@Test`
`178`		`- @Disabled("TODO wrong returned value")`
`179`	`178`	`fun testPeekExample() {`
`180`	`179`	`checkThisAndStaticsAfter(`
`181`	`180`	`DoubleStreamExample::peekExample,`
`@@ -186,25 +185,23 @@ class DoubleStreamExampleTest : UtValueTestCaseChecker(`
`186`	`185`	`}`
`187`	`186`
`188`	`187`	`@Test`
`189`		`- @Disabled("TODO unable to find second branch, even after exceeding steps limit")`
`190`	`188`	`fun testLimitExample() {`
`191`	`189`	`check(`
`192`	`190`	`DoubleStreamExample::limitExample,`
`193`	`191`	`ignoreExecutionsNumber,`
`194`		`- { c, r -> c.size <= 5 && c.doubles().contentEquals(r) },`
`195`		`- { c, r -> c.size > 5 && c.take(5).doubles().contentEquals(r) },`
	`192`	`+ { c, r -> c.size <= 2 && c.doubles().contentEquals(r) },`
	`193`	`+ { c, r -> c.size > 2 && c.take(2).doubles().contentEquals(r) },`
`196`	`194`	`coverage = FullWithAssumptions(assumeCallsNumber = 1)`
`197`	`195`	`)`
`198`	`196`	`}`
`199`	`197`
`200`	`198`	`@Test`
`201`		`- @Disabled("TODO unable to find second branch, even after exceeding steps limit")`
`202`	`199`	`fun testSkipExample() {`
`203`	`200`	`check(`
`204`	`201`	`DoubleStreamExample::skipExample,`
`205`	`202`	`ignoreExecutionsNumber,`
`206`		`- { c, r -> c.size > 5 && c.drop(5).doubles().contentEquals(r) },`
`207`		`- { c, r -> c.size <= 5 && r!!.isEmpty() },`
	`203`	`+ { c, r -> c.size > 2 && c.drop(2).doubles().contentEquals(r) },`
	`204`	`+ { c, r -> c.size <= 2 && r!!.isEmpty() },`
`208`	`205`	`coverage = FullWithAssumptions(assumeCallsNumber = 1)`
`209`	`206`	`)`
`210`	`207`	`}`
Original file line number	Diff line number	Diff line change
`@@ -184,25 +184,23 @@ class IntStreamExampleTest : UtValueTestCaseChecker(`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`@Test`
`187`		`- @Disabled("TODO unable to find second branch, even after exceeding steps limit")`
`188`	`187`	`fun testLimitExample() {`
`189`	`188`	`check(`
`190`	`189`	`IntStreamExample::limitExample,`
`191`	`190`	`ignoreExecutionsNumber,`
`192`		`- { c, r -> c.size <= 5 && c.ints().contentEquals(r) },`
`193`		`- { c, r -> c.size > 5 && c.take(5).ints().contentEquals(r) },`
	`191`	`+ { c, r -> c.size <= 2 && c.ints().contentEquals(r) },`
	`192`	`+ { c, r -> c.size > 2 && c.take(2).ints().contentEquals(r) },`
`194`	`193`	`coverage = FullWithAssumptions(assumeCallsNumber = 1)`
`195`	`194`	`)`
`196`	`195`	`}`
`197`	`196`
`198`	`197`	`@Test`
`199`		`- @Disabled("TODO unable to find second branch, even after exceeding steps limit")`
`200`	`198`	`fun testSkipExample() {`
`201`	`199`	`check(`
`202`	`200`	`IntStreamExample::skipExample,`
`203`	`201`	`ignoreExecutionsNumber,`
`204`		`- { c, r -> c.size > 5 && c.drop(5).ints().contentEquals(r) },`
`205`		`- { c, r -> c.size <= 5 && r!!.isEmpty() },`
	`202`	`+ { c, r -> c.size > 2 && c.drop(2).ints().contentEquals(r) },`
	`203`	`+ { c, r -> c.size <= 2 && r!!.isEmpty() },`
`206`	`204`	`coverage = FullWithAssumptions(assumeCallsNumber = 1)`
`207`	`205`	`)`
`208`	`206`	`}`
Original file line number	Diff line number	Diff line change
`@@ -184,25 +184,23 @@ class LongStreamExampleTest : UtValueTestCaseChecker(`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`@Test`
`187`		`- @Disabled("TODO unable to find second branch, even after exceeding steps limit")`
`188`	`187`	`fun testLimitExample() {`
`189`	`188`	`check(`
`190`	`189`	`LongStreamExample::limitExample,`
`191`	`190`	`ignoreExecutionsNumber,`
`192`		`- { c, r -> c.size <= 5 && c.longs().contentEquals(r) },`
`193`		`- { c, r -> c.size > 5 && c.take(5).longs().contentEquals(r) },`
	`191`	`+ { c, r -> c.size <= 2 && c.longs().contentEquals(r) },`
	`192`	`+ { c, r -> c.size > 2 && c.take(2).longs().contentEquals(r) },`
`194`	`193`	`coverage = FullWithAssumptions(assumeCallsNumber = 1)`
`195`	`194`	`)`
`196`	`195`	`}`
`197`	`196`
`198`	`197`	`@Test`
`199`		`- @Disabled("TODO unable to find second branch, even after exceeding steps limit")`
`200`	`198`	`fun testSkipExample() {`
`201`	`199`	`check(`
`202`	`200`	`LongStreamExample::skipExample,`
`203`	`201`	`ignoreExecutionsNumber,`
`204`		`- { c, r -> c.size > 5 && c.drop(5).longs().contentEquals(r) },`
`205`		`- { c, r -> c.size <= 5 && r!!.isEmpty() },`
	`202`	`+ { c, r -> c.size > 2 && c.drop(2).longs().contentEquals(r) },`
	`203`	`+ { c, r -> c.size <= 2 && r!!.isEmpty() },`
`206`	`204`	`coverage = FullWithAssumptions(assumeCallsNumber = 1)`
`207`	`205`	`)`
`208`	`206`	`}`
Original file line number	Diff line number	Diff line change
`@@ -158,6 +158,9 @@ int peekExample(List<Short> list) {`
`158`	`158`	`doubles.peek(action);`
`159`	`159`	`}`
`160`	`160`
	`161`	`+ // use terminal operation to force peek action`
	`162`	`+ doubles.count();`
	`163`	`+`
`161`	`164`	`return beforeStaticValue;`
`162`	`165`	`}`
`163`	`166`
`@@ -167,10 +170,10 @@ int peekExample(List<Short> list) {`
`167`	`170`	`final ToDoubleFunction<Short> shortToDoubleFunction = value -> value == null ? 0 : value.doubleValue();`
`168`	`171`	`final DoubleStream doubles = list.stream().mapToDouble(shortToDoubleFunction);`
`169`	`172`
`170`		`- if (list.size() <= 5) {`
`171`		`- return doubles.limit(5).toArray();`
	`173`	`+ if (list.size() <= 2) {`
	`174`	`+ return doubles.limit(2).toArray();`
`172`	`175`	`} else {`
`173`		`- return doubles.limit(5).toArray();`
	`176`	`+ return doubles.limit(2).toArray();`
`174`	`177`	`}`
`175`	`178`	`}`
`176`	`179`
`@@ -180,10 +183,10 @@ int peekExample(List<Short> list) {`
`180`	`183`	`final ToDoubleFunction<Short> shortToDoubleFunction = value -> value == null ? 0 : value.doubleValue();`
`181`	`184`	`final DoubleStream doubles = list.stream().mapToDouble(shortToDoubleFunction);`
`182`	`185`
`183`		`- if (list.size() <= 5) {`
`184`		`- return doubles.skip(5).toArray();`
	`186`	`+ if (list.size() <= 2) {`
	`187`	`+ return doubles.skip(2).toArray();`
`185`	`188`	`} else {`
`186`		`- return doubles.skip(5).toArray();`
	`189`	`+ return doubles.skip(2).toArray();`
`187`	`190`	`}`
`188`	`191`	`}`
`189`	`192`
Original file line number	Diff line number	Diff line change
`@@ -161,6 +161,9 @@ int peekExample(List<Short> list) {`
`161`	`161`	`ints.peek(action);`
`162`	`162`	`}`
`163`	`163`
	`164`	`+ // use terminal operation to force peek action`
	`165`	`+ ints.count();`
	`166`	`+`
`164`	`167`	`return beforeStaticValue;`
`165`	`168`	`}`
`166`	`169`
`@@ -170,10 +173,10 @@ int[] limitExample(List<Short> list) {`
`170`	`173`	`final ToIntFunction<Short> shortToIntFunction = value -> value == null ? 0 : value.intValue();`
`171`	`174`	`final IntStream ints = list.stream().mapToInt(shortToIntFunction);`
`172`	`175`
`173`		`- if (list.size() <= 5) {`
`174`		`- return ints.limit(5).toArray();`
	`176`	`+ if (list.size() <= 2) {`
	`177`	`+ return ints.limit(2).toArray();`
`175`	`178`	`} else {`
`176`		`- return ints.limit(5).toArray();`
	`179`	`+ return ints.limit(2).toArray();`
`177`	`180`	`}`
`178`	`181`	`}`
`179`	`182`
`@@ -183,10 +186,10 @@ int[] skipExample(List<Short> list) {`
`183`	`186`	`final ToIntFunction<Short> shortToIntFunction = value -> value == null ? 0 : value.intValue();`
`184`	`187`	`final IntStream ints = list.stream().mapToInt(shortToIntFunction);`
`185`	`188`
`186`		`- if (list.size() <= 5) {`
`187`		`- return ints.skip(5).toArray();`
	`189`	`+ if (list.size() <= 2) {`
	`190`	`+ return ints.skip(2).toArray();`
`188`	`191`	`} else {`
`189`		`- return ints.skip(5).toArray();`
	`192`	`+ return ints.skip(2).toArray();`
`190`	`193`	`}`
`191`	`194`	`}`
`192`	`195`
Original file line number	Diff line number	Diff line change
`@@ -160,6 +160,9 @@ int peekExample(List<Short> list) {`
`160`	`160`	`longs.peek(action);`
`161`	`161`	`}`
`162`	`162`
	`163`	`+ // use terminal operation to force peek action`
	`164`	`+ longs.count();`
	`165`	`+`
`163`	`166`	`return beforeStaticValue;`
`164`	`167`	`}`
`165`	`168`
`@@ -169,10 +172,10 @@ long[] limitExample(List<Short> list) {`
`169`	`172`	`final ToLongFunction<Short> shortToLongFunction = value -> value == null ? 0 : value.longValue();`
`170`	`173`	`final LongStream longs = list.stream().mapToLong(shortToLongFunction);`
`171`	`174`
`172`		`- if (list.size() <= 5) {`
`173`		`- return longs.limit(5).toArray();`
	`175`	`+ if (list.size() <= 2) {`
	`176`	`+ return longs.limit(2).toArray();`
`174`	`177`	`} else {`
`175`		`- return longs.limit(5).toArray();`
	`178`	`+ return longs.limit(2).toArray();`
`176`	`179`	`}`
`177`	`180`	`}`
`178`	`181`
`@@ -182,10 +185,10 @@ long[] skipExample(List<Short> list) {`
`182`	`185`	`final ToLongFunction<Short> shortToLongFunction = value -> value == null ? 0 : value.longValue();`
`183`	`186`	`final LongStream longs = list.stream().mapToLong(shortToLongFunction);`
`184`	`187`
`185`		`- if (list.size() <= 5) {`
`186`		`- return longs.skip(5).toArray();`
	`188`	`+ if (list.size() <= 2) {`
	`189`	`+ return longs.skip(2).toArray();`
`187`	`190`	`} else {`
`188`		`- return longs.skip(5).toArray();`
	`191`	`+ return longs.skip(2).toArray();`
`189`	`192`	`}`
`190`	`193`	`}`
`191`	`194`