Fallback provider should not prevent providers filtering when applied

Author: Markoutte

utbot-fuzzing/src/main/kotlin/org/utbot/fuzzing/Providers.kt

@@ -96,9 +96,9 @@ fun interface ValueProvider<T, R, D : Description<T>> {
      */
     fun except(filter: (ValueProvider<T, R, D>) -> Boolean): ValueProvider<T, R, D> {
         return if (this is Combined) {
-            Combined(providers.filterNot(filter))
+            Combined(providers.map { it.unwrapIfFallback() }.filterNot(filter))
         } else {
-            Combined(if (filter(this)) emptyList() else listOf(this))
+            Combined(if (filter(unwrapIfFallback())) emptyList() else listOf(this))
         }
     }
 
@@ -117,26 +117,7 @@ fun interface ValueProvider<T, R, D : Description<T>> {
      * Uses fallback value provider in case when 'this' one failed to generate any value.
      */
     fun withFallback(fallback: ValueProvider<T, R, D>) : ValueProvider<T, R, D> {
-        val thisProvider = this
-        return object : ValueProvider<T, R, D> {
-            override fun enrich(description: D, type: T, scope: Scope) {
-                thisProvider.enrich(description, type, scope)
-                // Enriching scope by fallback value provider in this point is not quite right,
-                // but it doesn't look as a problem right now.
-                fallback.enrich(description, type, scope)
-            }
-
-            override fun generate(description: D, type: T): Sequence<Seed<T, R>> {
-                val default = if (thisProvider.accept(type)) thisProvider.generate(description, type) else emptySequence()
-                return if (default.iterator().hasNext()) {
-                    default
-                } else if (fallback.accept(type)) {
-                    fallback.generate(description, type)
-                } else {
-                    emptySequence()
-                }
-            }
-        }
+        return Fallback(this, fallback)
     }
 
     /**
@@ -152,6 +133,42 @@ fun interface ValueProvider<T, R, D : Description<T>> {
         return if (flag) block(this) else this
     }
 
+    /**
+     * Checks if current provider has fallback and return the initial provider.
+     *
+     * If the initial provider is also fallback, then it is unwrapped too.
+     *
+     * @return unwrapped provider or this if it is not fallback
+     */
+    fun unwrapIfFallback(): ValueProvider<T, R, D> {
+        return if (this is Fallback<T, R, D>) { provider.unwrapIfFallback() } else { this }
+    }
+
+    private class Fallback<T, R, D : Description<T>>(
+        val provider: ValueProvider<T, R, D>,
+        val fallback: ValueProvider<T, R, D>,
+    ): ValueProvider<T, R, D> {
+
+        override fun enrich(description: D, type: T, scope: Scope) {
+            provider.enrich(description, type, scope)
+            // Enriching scope by fallback value provider in this point is not quite right,
+            // but it doesn't look as a problem right now.
+            fallback.enrich(description, type, scope)
+        }
+
+        override fun generate(description: D, type: T): Sequence<Seed<T, R>> {
+            val default = if (provider.accept(type)) provider.generate(description, type) else emptySequence()
+            return if (default.iterator().hasNext()) {
+                default
+            } else if (fallback.accept(type)) {
+                fallback.generate(description, type)
+            } else {
+                emptySequence()
+            }
+        }
+
+    }
+
     /**
      * Wrapper class that delegates implementation to the [providers].
      */

utbot-fuzzing/src/test/kotlin/org/utbot/fuzzing/ProvidersTest.kt

@@ -111,6 +111,27 @@ class ProvidersTest {
         Assertions.assertEquals(3, (seq.drop(1).first() as Seed.Simple).value)
     }
 
+    @Test
+    fun `test fallback unwrapping from providers`() {
+        val provider1 = p { 2 }
+        val provider2 = p { 3 }
+        val fallback = p { 4 }
+        val providers1 = ValueProvider.of(listOf(
+            provider1.withFallback(fallback),
+            provider2
+        ))
+        val seq1 = providers1.generate(description, Unit).toSet()
+        Assertions.assertEquals(2, seq1.count())
+        Assertions.assertEquals(2, (seq1.first() as Seed.Simple).value)
+        Assertions.assertEquals(3, (seq1.drop(1).first() as Seed.Simple).value)
+
+        val providers2 = providers1.except(provider1)
+
+        val seq2 = providers2.generate(description, Unit).toSet()
+        Assertions.assertEquals(1, seq2.count())
+        Assertions.assertEquals(3, (seq2.first() as Seed.Simple).value)
+    }
+
     @Test
     fun `provider is not called when accept-method returns false`() {
         val seq = ValueProvider.of(listOf(

utbot-java-fuzzing/src/main/kotlin/org/utbot/fuzzing/providers/Objects.kt

@@ -151,7 +151,7 @@ class CreateObjectAnywayValueProvider(
         yield(Seed.Recursive(
             construct = Routine.Create(emptyList()) {
                 UtCompositeModel(idGenerator.createId(), type.classId, useMock).fuzzed {
-                    summary = "some object"
+                    summary = "Unsafe object"
                 }
             },
             modify = sequence {
@@ -188,7 +188,7 @@ class CreateObjectAnywayValueProvider(
             },
             empty = Routine.Empty {
                 UtCompositeModel(idGenerator.createId(), type.classId, useMock).fuzzed {
-                    summary = "some object"
+                    summary = "Unsafe object"
                 }
             }
         ))