use Type... instead of Map for generic classes

Author: HamzaBenyazid

src/main/java/io/javarig/RandomInstanceGenerator.java

@@ -3,13 +3,11 @@
 import io.javarig.exception.InstanceGenerationException;
 import io.javarig.exception.NestedObjectRecursionException;
 import io.javarig.generator.CollectionGenerator;
-import io.javarig.generator.ObjectGenerator;
 import io.javarig.generator.TypeGenerator;
 import lombok.NonNull;
 import org.apache.commons.lang3.Validate;
 
 import java.lang.reflect.Type;
-import java.util.Map;
 import java.util.Stack;
 import java.util.function.Consumer;
 
@@ -98,16 +96,6 @@ public <T> T generate(
         return generate(parameterizedType);
     }
 
-    public <T> T generate(
-            @NonNull Type objectType,
-            @NonNull Map<String,Type> genericTypes
-    ) throws InstanceGenerationException {
-        return generate(objectType, generator -> {
-            if(generator instanceof ObjectGenerator objectGenerator){
-                objectGenerator.setGenericTypes(genericTypes);
-            }
-        });
-    }
 
     /**
      * generate a random instance of a generic collection with a fixed size

src/main/java/io/javarig/generator/ObjectGenerator.java

@@ -1,5 +1,6 @@
 package io.javarig.generator;
 
+import io.javarig.util.GenericTypes;
 import io.javarig.ParameterizedTypeImpl;
 import io.javarig.RandomInstanceGenerator;
 import io.javarig.exception.AbstractClassInstantiationException;
@@ -13,6 +14,8 @@
 
 import java.lang.reflect.*;
 import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 import static io.javarig.util.Utils.getOwnOrInheritedFieldByName;
 
@@ -21,22 +24,39 @@
 @Slf4j
 public class ObjectGenerator extends TypeGenerator {
     private static final String SETTER_PREFIX = "set";
-    private Map<String,Type> genericTypes = new HashMap<>();
+    private Map<String,Type> genericTypesMap = new HashMap<>();
 
     public ObjectGenerator(Type type, RandomInstanceGenerator randomInstanceGenerator) {
         super(type, randomInstanceGenerator);
     }
 
     @Override
     public Object generate() throws InstanceGenerationException {
-        Class<?> objectClass = (Class<?>) getType();
+        Type objectType = getType();
+        Class<?> objectClass;
+        if(objectType instanceof ParameterizedType parameterizedType){
+            objectClass = (Class<?>) parameterizedType.getRawType();
+            constructGenericTypesMap(objectClass, parameterizedType);
+        } else {
+            objectClass = (Class<?>) objectType;
+        }
         Object generatedObject = getNewObjectInstance(objectClass);
         log.info("generating object of type {} ...", objectClass.getName());
         generateFields(generatedObject, objectClass);
         log.info("created object {}", generatedObject);
         return generatedObject;
     }
 
+    private void constructGenericTypesMap(Class<?> objectClass, ParameterizedType parameterizedType) {
+        List<Type> typeParametersValues = Arrays.asList(parameterizedType.getActualTypeArguments());
+        List<String> typeParametersKeys = Arrays.stream(objectClass.getTypeParameters())
+                .map(TypeVariable::getTypeName)
+                .toList();
+        genericTypesMap = IntStream.range(0, typeParametersKeys.size())
+                .boxed()
+                .collect(Collectors.toMap(typeParametersKeys::get, typeParametersValues::get));
+    }
+
     private void generateFields(Object generatedObject, Class<?> objectClass) throws InstanceGenerationException {
         List<Method> setters = getSetters(objectClass);
         setters.forEach((setter) -> generateFieldWithSetter(generatedObject, objectClass, setter));
@@ -63,7 +83,7 @@ private void generateField(Object generatedObject, Method setter, Field field) t
         if(type instanceof ParameterizedType parameterizedType){
             type = setTypeArguments(parameterizedType);
         }
-        Object generatedField = getRandomInstanceGenerator().generate(type);
+        Object generatedField = getRandomInstanceGenerator().generate(GenericTypes.resolve(type, genericTypesMap));
         try {
             setter.invoke(generatedObject, generatedField);
         } catch (IllegalAccessException ignore) {
@@ -76,13 +96,13 @@ private void generateField(Object generatedObject, Method setter, Field field) t
     }
 
     private Type setTypeArguments(Type type) {
-        List<Type> typeArguments = new ArrayList<>();
         ParameterizedType parameterizedType = (ParameterizedType) type;
-        for(Type typeArgument : parameterizedType.getActualTypeArguments()){
-            typeArguments.add(genericTypes.getOrDefault(typeArgument.getTypeName(),typeArgument));
-        }
+        List<Type> typeArguments = Arrays.stream(parameterizedType.getActualTypeArguments())
+                .map((typeArgument -> GenericTypes.resolve(typeArgument, genericTypesMap)))
+                .toList();
         Type[] typeArgumentsArray = new Type[typeArguments.size()];
-        return new ParameterizedTypeImpl(typeArguments.toArray(typeArgumentsArray), (Class<?>) ((ParameterizedType) type).getRawType());
+        return new ParameterizedTypeImpl(typeArguments.toArray(typeArgumentsArray),
+                (Class<?>) ((ParameterizedType) type).getRawType());
     }
 
     private Object getNewObjectInstance(Class<?> objectClass) throws InstanceGenerationException {

src/main/java/io/javarig/util/GenericTypes.java

@@ -0,0 +1,13 @@
+package io.javarig.util;
+
+import java.lang.reflect.Type;
+import java.util.Map;
+
+public class GenericTypes {
+    public static Type resolve(Type type, Map<String, Type> genericTypesMap){
+        if(genericTypesMap.containsKey(type.getTypeName())){
+            return genericTypesMap.get(type.getTypeName());
+        }
+        return type;
+    }
+}

src/test/java/io/javarig/generation/ObjectGenerationTest.java

@@ -12,9 +12,6 @@
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Type;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.TreeMap;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -198,8 +195,7 @@ public void shouldGenerateBaseFieldsAndInheritedFieldsWhenGivenClassExtendingAno
     @ValueSource(classes = {String.class, Integer.class, Double.class, BaseClass.class})
     public void shouldGenerateAGenericClass(Type genericType) {
         //given
-        Map<String, Type> genericTypes = Map.of("T", genericType);
-        Object generatedObject = randomInstanceGenerator.generate(GenericTestClass.class, genericTypes);
+        Object generatedObject = randomInstanceGenerator.generate(GenericTestClass.class, genericType);
         // then
         assertThat(generatedObject)
                 .isNotNull()
@@ -214,4 +210,32 @@ public void shouldGenerateAGenericClass(Type genericType) {
                 .isInstanceOf((Class<?>) genericType);
     }
 
+    @Test
+    public void shouldGenerateAGenericClassWithRightOrderTypes() {
+        //given
+        Class<String> classParam1 = String.class;
+        Class<Integer> classParam2 = Integer.class;
+        Object generatedObject = randomInstanceGenerator.generate(GenericTestClass2.class, classParam1, classParam2);
+        // then
+        assertThat(generatedObject)
+                .isNotNull()
+                .isInstanceOf(GenericTestClass2.class);
+
+        GenericTestClass2<String, Integer> genericTestClass2 = (GenericTestClass2) generatedObject;
+        assertThat(genericTestClass2)
+                .extracting(GenericTestClass2::getGenericClass3)
+                .isNotNull()
+                .isInstanceOf(GenericTestClass3.class)
+                .extracting(GenericTestClass3::getT)
+                .isNotNull()
+                .isInstanceOf(classParam2);
+
+        assertThat(genericTestClass2)
+                .extracting(GenericTestClass2::getGenericClass3)
+                .isNotNull()
+                .isInstanceOf(GenericTestClass3.class)
+                .extracting(GenericTestClass3::getK)
+                .isNotNull()
+                .isInstanceOf(classParam1);
+    }
 }

src/test/java/io/javarig/testclasses/GenericTestClass2.java

@@ -0,0 +1,14 @@
+package io.javarig.testclasses;
+
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+
+@NoArgsConstructor
+@Getter
+@Setter
+@ToString
+public class GenericTestClass2<T,K> {
+    private GenericTestClass3<K,T> genericClass3;
+}

src/test/java/io/javarig/testclasses/GenericTestClass3.java

@@ -0,0 +1,15 @@
+package io.javarig.testclasses;
+
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+
+@NoArgsConstructor
+@Getter
+@Setter
+@ToString
+public class GenericTestClass3<T,K> {
+    private T t;
+    private K k;
+}