Merge pull request #53 from oubaydos/setGeneration

Set generation

Author: oubaydos

src/main/java/io/javarig/TypeEnum.java

@@ -4,6 +4,9 @@
 import io.javarig.generator.collection.list.ArrayListGenerator;
 import io.javarig.generator.collection.map.HashMapGenerator;
 import io.javarig.generator.collection.map.TreeMapGenerator;
+import io.javarig.generator.collection.set.HashSetGenerator;
+import io.javarig.generator.collection.set.LinkedHashSetGenerator;
+import io.javarig.generator.collection.set.TreeSetGenerator;
 import io.javarig.generator.primitive.*;
 
 import java.lang.reflect.Type;
@@ -31,6 +34,10 @@ public enum TypeEnum {
     TREE_MAP(TreeMap.class, TreeMapGenerator.class),
     LIST(List.class, ArrayListGenerator.class),
     ARRAY_LIST(ArrayList.class, ArrayListGenerator.class),
+    SET(Set.class, HashSetGenerator.class),
+    HASH_SET(HashSet.class, HashSetGenerator.class),
+    LINKED_HASH_SET(LinkedHashSet.class, LinkedHashSetGenerator.class),
+    TREE_SET(TreeSet.class, TreeSetGenerator.class),
     ENUM(null, EnumGenerator.class),
     ARRAY(null, ArrayGenerator.class),
     OBJECT(null, ObjectGenerator.class);

src/main/java/io/javarig/generator/collection/set/HashSetGenerator.java

@@ -0,0 +1,19 @@
+package io.javarig.generator.collection.set;
+
+import io.javarig.RandomInstanceGenerator;
+
+import java.lang.reflect.Type;
+import java.util.HashSet;
+import java.util.Set;
+
+public class HashSetGenerator extends SetGenerator{
+    public HashSetGenerator(Type type, RandomInstanceGenerator randomInstanceGenerator) {
+        super(type, randomInstanceGenerator);
+    }
+
+    @SuppressWarnings({"rawtypes"})
+    @Override
+    public Class<? extends Set> getImplementationType() {
+        return HashSet.class;
+    }
+}

src/main/java/io/javarig/generator/collection/set/LinkedHashSetGenerator.java

@@ -0,0 +1,19 @@
+package io.javarig.generator.collection.set;
+
+import io.javarig.RandomInstanceGenerator;
+
+import java.lang.reflect.Type;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+public class LinkedHashSetGenerator extends SetGenerator{
+    public LinkedHashSetGenerator(Type type, RandomInstanceGenerator randomInstanceGenerator) {
+        super(type, randomInstanceGenerator);
+    }
+
+    @SuppressWarnings({"rawtypes"})
+    @Override
+    public Class<? extends Set> getImplementationType() {
+        return LinkedHashSet.class;
+    }
+}

src/main/java/io/javarig/generator/collection/set/TreeSetGenerator.java

@@ -0,0 +1,19 @@
+package io.javarig.generator.collection.set;
+
+import io.javarig.RandomInstanceGenerator;
+
+import java.lang.reflect.Type;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class TreeSetGenerator extends SetGenerator{
+    public TreeSetGenerator(Type type, RandomInstanceGenerator randomInstanceGenerator) {
+        super(type, randomInstanceGenerator);
+    }
+
+    @SuppressWarnings({"rawtypes"})
+    @Override
+    public Class<? extends Set> getImplementationType() {
+        return TreeSet.class;
+    }
+}

src/test/java/io/javarig/generation/javapredefinedtypes/collection/CollectionGenerationTest.java

@@ -9,93 +9,105 @@
 import lombok.extern.slf4j.Slf4j;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.lang.reflect.Type;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.assertj.core.api.InstanceOfAssertFactories.LIST;
+import static org.assertj.core.api.InstanceOfAssertFactories.COLLECTION;
 
 @Slf4j
-public class ListGenerationTest {
+public class SingleGenericTypeCollectionGenerationTest {
     private RandomInstanceGenerator randomInstanceGenerator;
+    private static final Class<?>[] implementedCollectionClasses = {List.class, ArrayList.class, Set.class, HashSet.class, LinkedHashSet.class, TreeSet.class};
 
     @BeforeEach
     public void setUp() {
         randomInstanceGenerator = new RandomInstanceGenerator();
     }
-    @Test
-    public void shouldReturnList() {
+    private static Class<?>[] getImplementedCollectionClasses(){
+        return SingleGenericTypeCollectionGenerationTest.implementedCollectionClasses;
+    }
+
+    @ParameterizedTest
+    @MethodSource("getImplementedCollectionClasses")
+    public void shouldReturnCollectionOfAppropriateType(Class<?> collectionClass) {
         //given
         Class<?> type = String.class;
         //when
-        Object generated = randomInstanceGenerator.generate(List.class, type);
+        Object generated = randomInstanceGenerator.generate(collectionClass, type);
         //then
-        log.info("shouldReturnList : {}", generated);
+        log.info("shouldReturn{} : {}",collectionClass.getSimpleName(), generated);
         assertThat(generated).isNotNull();
-        assertThat(generated).isInstanceOf(List.class);
+        assertThat(generated).isInstanceOf(collectionClass);
 
         //asserting type
-        assertThat(generated).asInstanceOf(LIST).first().isInstanceOf(type);
+        assertThat(generated).asInstanceOf(COLLECTION).first().isInstanceOf(type);
     }
 
-    @Test
-    public void shouldReturnListWithExactSize() {
+    @ParameterizedTest
+    @MethodSource("getImplementedCollectionClasses")
+    public void shouldReturnTheAppropriateCollectionWithExactSize(Class<?> collectionClass) {
         //given
         int size = 20;
         Class<?> type = String.class;
         //when
-        Object generated = randomInstanceGenerator.generate(List.class, size, type);
+        Object generated = randomInstanceGenerator.generate(collectionClass, size, type);
         //then
-        log.info("shouldReturnListWithExactSize : {}", generated);
+        log.info("shouldReturn{}WithExactSize : {}",collectionClass.getSimpleName(), generated);
         assertThat(generated).isNotNull();
-        assertThat(generated).isInstanceOf(List.class);
-        assertThat(generated).asInstanceOf(LIST).hasSize(size);
+        assertThat(generated).isInstanceOf(collectionClass);
+        assertThat(generated).asInstanceOf(COLLECTION).hasSize(size);
 
         //asserting type
-        assertThat(generated).asInstanceOf(LIST).first().isInstanceOf(type);
+        assertThat(generated).asInstanceOf(COLLECTION).first().isInstanceOf(type);
     }
 
-    @Test
-    public void shouldReturnListWithSizeBetween() {
+    @ParameterizedTest
+    @MethodSource("getImplementedCollectionClasses")
+    public void shouldReturnTheAppropriateCollectionWithSizeBetween(Class<?> collectionClass) {
         //given
         int minSize = 20;
         int maxSize = 40;
         Class<?> type = String.class;
         //when
-        Object generated = randomInstanceGenerator.generate(List.class, minSize, maxSize, type);
+        Object generated = randomInstanceGenerator.generate(collectionClass, minSize, maxSize, type);
         //then
         log.info("shouldReturnListWithSizeBetween : {}", generated);
         assertThat(generated).isNotNull();
-        assertThat(generated).isInstanceOf(List.class);
-        assertThat(generated).asInstanceOf(LIST).hasSizeBetween(minSize, maxSize);
+        assertThat(generated).isInstanceOf(collectionClass);
+        assertThat(generated).asInstanceOf(COLLECTION).hasSizeBetween(minSize, maxSize);
 
         //asserting type
-        assertThat(generated).asInstanceOf(LIST).first().isInstanceOf(type);
+        assertThat(generated).asInstanceOf(COLLECTION).first().isInstanceOf(type);
     }
-    @Test
-    public void shouldThrowInvalidGenericParamsNumberExceptionWhenTryingToGenerateAListWithAZeroGenericParams() {
+    @ParameterizedTest
+    @MethodSource("getImplementedCollectionClasses")
+    public void shouldThrowInvalidGenericParamsNumberExceptionWhenTryingToGenerateACollectionWithAZeroGenericParams(Class<?> collectionClass) {
         int required = 1;
-        assertThatThrownBy(() -> randomInstanceGenerator.generate(List.class))
+        assertThatThrownBy(() -> randomInstanceGenerator.generate(collectionClass))
                 .isInstanceOf(InvalidGenericParametersNumberException.class)
                 .hasMessage("invalid number of generic parameters, required %d and 0 was found".formatted(required));
     }
 
-    @Test
-    public void shouldThrowInvalidGenericParamsNumberExceptionWhenTryingToGenerateAListWithAMoreThanOneGenericParams() {
+    @ParameterizedTest
+    @MethodSource("getImplementedCollectionClasses")
+    public void shouldThrowInvalidGenericParamsNumberExceptionWhenTryingToGenerateACollectionWithAMoreThanOneGenericParams(Class<?> collectionClass) {
         int required = 1;
         Type[] genericParams = new Type[]{String.class, Integer.class};
-        assertThatThrownBy(() -> randomInstanceGenerator.generate(List.class, genericParams))
+        assertThatThrownBy(() -> randomInstanceGenerator.generate(collectionClass, genericParams))
                 .isInstanceOf(InvalidGenericParametersNumberException.class)
-                .hasMessage("invalid number of generic parameters, required %d and %d was found".formatted(required, genericParams.length));
+                .hasMessage("invalid number of generic parameters, required %d and %d was found".formatted(required, genericParams.length)); // FIXME is this how should we check for message ? it would be better if we checked a type rather than a string that could be changed in the future without necessarily breaking the code
     }
-    @Test
-    public void shouldThrowIllegalArgumentExceptionGivenMinSizeEqualsMaxSize() {
+    @ParameterizedTest
+    @MethodSource("getImplementedCollectionClasses")
+    public void shouldThrowIllegalArgumentExceptionGivenMinSizeEqualsMaxSize(Class<?> collectionClass) {
         int size = 30;
         assertThatThrownBy(() -> {//when
-            randomInstanceGenerator.generate(ArrayList.class, size, size);
+            randomInstanceGenerator.generate(collectionClass, size, size);
         }).isInstanceOf(IllegalArgumentException.class)
                 .hasMessage("Start value must be smaller than end value.");
     }