refactor: simplify usage of getGenericTypeArgument

Author: Nylle

src/main/java/com/github/nylle/javafixture/InstanceFactory.java

@@ -166,7 +166,7 @@ private <T> T manufactureOrNull(final Method method, SpecimenType<T> type, Custo
             for (int i = 0; i < method.getParameterCount(); i++) {
                 var genericParameterType = method.getGenericParameterTypes()[i];
                 var specimen = specimenFactory.build(type.isParameterized()
-                        ? SpecimenType.fromClass(type.getGenericTypeArgument(i))
+                        ? type.getGenericTypeArgument(i)
                         : SpecimenType.fromClass(genericParameterType));
                 var o = specimen.create(customizationContext, new Annotation[0]);
                 arguments.add(o);

src/main/java/com/github/nylle/javafixture/SpecimenType.java

@@ -68,47 +68,43 @@ public Class<T> asClass() {
     }
 
     public ParameterizedType asParameterizedType() {
-        if (isParameterized()) {
-            return (ParameterizedType) type;
+        if (!isParameterized()) {
+            throw new SpecimenTypeException(format("%s is not a ParameterizedType", type));
         }
-
-        throw new SpecimenTypeException(format("%s is not a ParameterizedType", type));
+        return (ParameterizedType) type;
     }
 
-    public Type[] getGenericTypeArguments() {
-        if (isParameterized()) {
-            return ((ParameterizedType) type).getActualTypeArguments();
+    public String[] getTypeParameterNames() {
+        if (!isParameterized()) {
+            throw new SpecimenTypeException(format("%s is not a ParameterizedType", type));
         }
-
-        throw new SpecimenTypeException(format("%s is not a ParameterizedType", type));
+        return Stream.of(asClass().getTypeParameters()).map(x -> x.getName()).toArray(size -> new String[size]);
     }
 
-    public Type getGenericTypeArgument(final int index) {
-        return getGenericTypeArguments()[index];
+    public String getTypeParameterName(final int index) {
+        return getTypeParameterNames()[index];
     }
 
-    public String[] getTypeParameterNames() {
-        if (isParameterized()) {
-            return Stream.of(asClass().getTypeParameters()).map(x -> x.getName()).toArray(size -> new String[size]);
+    public Type[] getGenericTypeArguments() {
+        if (!isParameterized()) {
+            throw new SpecimenTypeException(format("%s is not a ParameterizedType", type));
         }
-
-        throw new SpecimenTypeException(format("%s is not a ParameterizedType", type));
+        return ((ParameterizedType) type).getActualTypeArguments();
     }
 
-    public String getTypeParameterName(final int index) {
-        return getTypeParameterNames()[index];
+    public <A> SpecimenType<A> getGenericTypeArgument(int index) {
+        return SpecimenType.fromClass(getGenericTypeArguments()[index]);
     }
 
     public <A> Map<String, A> getTypeParameterNamesAndTypes(Function<SpecimenType<?>, A> f) {
         if (!isParameterized()) {
             return Map.of();
         }
-
         return IntStream.range(0, this.getGenericTypeArguments().length)
                 .boxed()
                 .collect(toMap(
                         i -> this.getTypeParameterName(i),
-                        i -> f.apply(SpecimenType.fromClass(this.getGenericTypeArgument(i)))));
+                        i -> f.apply(this.getGenericTypeArgument(i))));
     }
 
     public Class<?> getComponentType() {

src/main/java/com/github/nylle/javafixture/specimen/CollectionSpecimen.java

@@ -43,7 +43,7 @@ public CollectionSpecimen(final SpecimenType<T> type, final Context context, fin
         this.context = context;
 
         if (type.isParameterized()) {
-            this.specimen = specimenFactory.build(SpecimenType.fromClass(type.getGenericTypeArgument(0)));
+            this.specimen = specimenFactory.build(type.getGenericTypeArgument(0));
         }
         this.instanceFactory = new InstanceFactory(specimenFactory);
     }

src/main/java/com/github/nylle/javafixture/specimen/MapSpecimen.java

@@ -49,8 +49,8 @@ public MapSpecimen(final SpecimenType<T> type, final Context context, final Spec
         this.context = context;
 
         if (type.isParameterized()) {
-            this.keySpecimen = specimenFactory.build(SpecimenType.fromClass(type.getGenericTypeArgument(0)));
-            this.valueSpecimen = specimenFactory.build(SpecimenType.fromClass(type.getGenericTypeArgument(1)));
+            this.keySpecimen = specimenFactory.build(type.getGenericTypeArgument(0));
+            this.valueSpecimen = specimenFactory.build(type.getGenericTypeArgument(1));
         }
     }
 
@@ -72,7 +72,7 @@ public T create(final CustomizationContext customizationContext, Annotation[] an
 
     private Map<K, V> createFromConcreteType(final SpecimenType<T> type) {
         if (type.asClass().equals(EnumMap.class)) {
-            return (Map<K, V>) new EnumMap((Class<K>) type.getGenericTypeArgument(0));
+            return (Map<K, V>) new EnumMap(type.getGenericTypeArgument(0).asClass());
         }
 
         try {

src/test/java/com/github/nylle/javafixture/SpecimenTypeTest.java

@@ -281,10 +281,11 @@ void isSpecialTypeFromClass(Class<?> value, boolean expected) {
     void getGenericTypeArgument() {
         var sut = new SpecimenType<Map<String, Optional<Integer>>>() {};
 
-        assertThat(sut.getGenericTypeArgument(0)).isEqualTo(String.class);
-        assertThat(sut.getGenericTypeArgument(1)).isInstanceOf(ParameterizedType.class);
-        assertThat(((ParameterizedType) (sut.getGenericTypeArgument(1))).getRawType()).isEqualTo(Optional.class);
-        assertThat(((ParameterizedType) (sut.getGenericTypeArgument(1))).getActualTypeArguments()[0]).isEqualTo(Integer.class);
+        assertThat(sut.getGenericTypeArgument(0).asClass()).isEqualTo(String.class);
+        assertThat(sut.getGenericTypeArgument(1).asClass()).isEqualTo(Optional.class);
+        assertThat(sut.getGenericTypeArgument(1).asParameterizedType()).isInstanceOf(ParameterizedType.class);
+        assertThat(sut.getGenericTypeArgument(1).asParameterizedType().getRawType()).isEqualTo(Optional.class);
+        assertThat(sut.getGenericTypeArgument(1).asParameterizedType().getActualTypeArguments()[0]).isEqualTo(Integer.class);
 
         assertThatExceptionOfType(SpecimenTypeException.class)
                 .isThrownBy(() -> SpecimenType.fromClass(String.class).getGenericTypeArgument(0))
@@ -352,7 +353,7 @@ void returnsMapOfTypeParameterNamesAndSpecimenTypes() {
             assertThat(actual).hasSize(2);
             assertThat(actual.get("T").asClass()).isEqualTo(String.class);
             assertThat(actual.get("U").asClass()).isEqualTo(Optional.class);
-            assertThat(actual.get("U").getGenericTypeArgument(0)).isEqualTo(Integer.class);
+            assertThat(actual.get("U").getGenericTypeArgument(0).asClass()).isEqualTo(Integer.class);
         }
 
         @Test