Add more correct type resolves for collections and maps

Author: Markoutte

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

@@ -1,13 +1,16 @@
 package org.utbot.fuzzing.providers
 
+import com.google.common.reflect.TypeToken
 import org.utbot.framework.plugin.api.*
 import org.utbot.framework.plugin.api.util.*
 import org.utbot.fuzzer.FuzzedType
 import org.utbot.fuzzer.FuzzedValue
 import org.utbot.fuzzer.IdGenerator
 import org.utbot.fuzzer.fuzzed
 import org.utbot.fuzzing.*
+import org.utbot.fuzzing.spring.utils.jType
 import org.utbot.fuzzing.utils.hex
+import java.lang.reflect.Method
 import kotlin.reflect.KClass
 
 class EmptyCollectionValueProvider(
@@ -80,9 +83,25 @@ class EmptyCollectionValueProvider(
 class MapValueProvider(
     idGenerator: IdGenerator<Int>
 ) : CollectionValueProvider(idGenerator, java.util.Map::class.id) {
+
+    private enum class MethodCall { KEYS, VALUES }
+
+    private fun findTypeByMethod(description: FuzzedDescription, type: FuzzedType, method: MethodCall): FuzzedType {
+        val methodName = when (method) {
+            MethodCall.KEYS -> "keySet"
+            MethodCall.VALUES -> "values"
+        }
+        val m = Map::class.java.getMethod(methodName)
+        return resolveTypeByMethod(description, type, m)?.let {
+            assert(it.classId.isSubtypeOf(collectionClassId))
+            assert(it.generics.size == 1)
+            it.generics[0]
+        } ?: FuzzedType(objectClassId)
+    }
+
     override fun resolveType(description: FuzzedDescription, type: FuzzedType) = sequence {
-        val keyGeneric = type.generics.getOrNull(0) ?: FuzzedType(objectClassId)
-        val valueGeneric = type.generics.getOrNull(1) ?: FuzzedType(objectClassId)
+        val keyGeneric = findTypeByMethod(description, type, MethodCall.KEYS)
+        val valueGeneric = findTypeByMethod(description, type, MethodCall.VALUES)
         when (type.classId) {
             java.util.Map::class.id -> {
                 if (keyGeneric.classId isSubtypeOf Comparable::class) {
@@ -108,8 +127,20 @@ class MapValueProvider(
 class ListSetValueProvider(
     idGenerator: IdGenerator<Int>
 ) : CollectionValueProvider(idGenerator, java.util.Collection::class.id) {
+
+    private val iteratorClassId = java.util.Iterator::class.java.id
+
+    private fun findTypeByMethod(description: FuzzedDescription, type: FuzzedType): FuzzedType {
+        val method = java.util.Collection::class.java.getMethod("iterator")
+        return resolveTypeByMethod(description, type, method)?.let {
+            assert(it.classId.isSubtypeOf(iteratorClassId))
+            assert(it.generics.size == 1)
+            it.generics[0]
+        } ?: FuzzedType(objectClassId)
+    }
+
     override fun resolveType(description: FuzzedDescription, type: FuzzedType) = sequence {
-        val generic = type.generics.firstOrNull() ?: FuzzedType(objectClassId)
+        val generic = findTypeByMethod(description, type)
         when (type.classId) {
             java.util.Queue::class.id,
             java.util.Deque::class.id-> {
@@ -171,6 +202,20 @@ abstract class CollectionValueProvider(
         }
     }
 
+    /**
+     * Can be used to resolve some types using [type] and some method of this type
+     */
+    protected fun resolveTypeByMethod(description: FuzzedDescription, type: FuzzedType, method: Method): FuzzedType? {
+        return try {
+            toFuzzerType(
+                TypeToken.of(type.jType).resolveType(method.genericReturnType).type,
+                description.typeCache
+            )
+        } catch (t: Throwable) {
+            null
+        }
+    }
+
     /**
      * Types should be resolved with type parameters
      */

utbot-java-fuzzing/src/test/java/org/utbot/fuzzing/samples/ConcreateMap.java

@@ -0,0 +1,6 @@
+package org.utbot.fuzzing.samples;
+
+import java.util.HashMap;
+
+public class ConcreateMap<V extends Number> extends HashMap<String, V> {
+}

utbot-java-fuzzing/src/test/java/org/utbot/fuzzing/samples/ConcreteList.java

@@ -0,0 +1,7 @@
+package org.utbot.fuzzing.samples;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class ConcreteList extends ArrayList<Collection<String>> {
+}

utbot-java-fuzzing/src/test/kotlin/org/utbot/fuzzing/JavaValueProviderTest.kt

@@ -0,0 +1,61 @@
+package org.utbot.fuzzing
+
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+import org.utbot.framework.plugin.api.Instruction
+import org.utbot.framework.plugin.api.util.collectionClassId
+import org.utbot.framework.plugin.api.util.id
+import org.utbot.framework.plugin.api.util.stringClassId
+import org.utbot.framework.plugin.api.util.voidClassId
+import org.utbot.fuzzer.FuzzedMethodDescription
+import org.utbot.fuzzer.FuzzedType
+import org.utbot.fuzzing.providers.ListSetValueProvider
+import org.utbot.fuzzing.providers.MapValueProvider
+import org.utbot.fuzzing.samples.ConcreateMap
+import org.utbot.fuzzing.samples.ConcreteList
+import org.utbot.fuzzing.utils.Trie
+import java.lang.reflect.Type
+import kotlin.random.Random
+
+fun emptyFuzzerDescription(typeCache: MutableMap<Type, FuzzedType>) = FuzzedDescription(
+    FuzzedMethodDescription("no name", voidClassId, emptyList()),
+    Trie(Instruction::id),
+    typeCache,
+    Random(42)
+)
+
+class JavaValueProviderTest {
+
+    @Test
+    fun `collection value provider correctly resolves types for concrete types of map`() {
+        val typeCache = mutableMapOf<Type, FuzzedType>()
+        runBlockingWithContext {
+            val seed = MapValueProvider(TestIdentityPreservingIdGenerator).generate(
+                emptyFuzzerDescription(typeCache),
+                toFuzzerType(ConcreateMap::class.java, typeCache)
+            ).first()
+            val collection = seed as Seed.Collection
+            val types = collection.modify.types
+            Assertions.assertEquals(2, types.size)
+            Assertions.assertEquals(types[0].classId, stringClassId)
+            Assertions.assertEquals(types[1].classId, java.lang.Number::class.java.id)
+        }
+    }
+
+    @Test
+    fun `collection value provider correctly resolves types for concrete types of list`() {
+        val typeCache = mutableMapOf<Type, FuzzedType>()
+        runBlockingWithContext {
+            val seed = ListSetValueProvider(TestIdentityPreservingIdGenerator).generate(
+                emptyFuzzerDescription(typeCache),
+                toFuzzerType(ConcreteList::class.java, typeCache)
+            ).first()
+            val collection = seed as Seed.Collection
+            val types = collection.modify.types
+            Assertions.assertEquals(1, types.size)
+            Assertions.assertEquals(types[0].classId, collectionClassId)
+            Assertions.assertEquals(1, types[0].generics.size)
+            Assertions.assertEquals(types[0].generics[0].classId, stringClassId)
+        }
+    }
+}