feat: support native abstract classes

Author: Nylle

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

@@ -51,7 +51,7 @@ public <T> ISpecimen<T> build(final SpecimenType<T> type) {
             return new MapSpecimen<>(type, context, this);
         }
 
-        if (type.isParameterized() && !type.isInterface()) {
+        if (type.isParameterized() && !type.isInterface() && !type.isAbstract()) {
             return new GenericSpecimen<>(type, context, this);
         }
 
@@ -63,6 +63,14 @@ public <T> ISpecimen<T> build(final SpecimenType<T> type) {
             return new GenericSpecimen<>(type, context, this);
         }
 
+        if (type.isParameterized() && type.isAbstract()) {
+            if (context.getConfiguration().experimentalInterfaces() && type.isAbstract()) {
+                return subClassOrProxy(type);
+            }
+
+            return new GenericSpecimen<>(type, context, this);
+        }
+
         if (type.isArray()) {
             return new ArraySpecimen<>(type, context, this);
         }
@@ -80,6 +88,9 @@ public <T> ISpecimen<T> build(final SpecimenType<T> type) {
         }
 
         if (type.isAbstract()) {
+            if (context.getConfiguration().experimentalInterfaces()) {
+                return subClassOrProxy(type);
+            }
             return new AbstractSpecimen<>(type, context, this);
         }
 
@@ -115,6 +126,32 @@ private <T> ISpecimen<T> implementationOrProxy(final SpecimenType<T> interfaceTy
         }
     }
 
+    private <T> ISpecimen<T> subClassOrProxy(final SpecimenType<T> abstractType) {
+        try (ScanResult scanResult = new ClassGraph().enableAllInfo().scan()) {
+            var subClasses = scanResult.getSubclasses(abstractType.asClass()).stream()
+                    .filter(x -> !x.isAbstract())
+                    .filter(x -> isNotParametrized(x) || abstractType.isParameterized())
+                    .filter(x -> isNotParametrized(x) || typeParametersMatch(x, abstractType))
+                    .collect(Collectors.toList());
+
+            if (subClasses.isEmpty()) {
+                return new AbstractSpecimen<>(abstractType, context, this);
+            }
+
+            var implementingClass = subClasses.get(new Random().nextInt(subClasses.size()));
+            if (isNotParametrized(implementingClass)) {
+                return new ObjectSpecimen<>(SpecimenType.fromClass(implementingClass.loadClass()), context, this);
+            }
+
+            return new GenericSpecimen<>(
+                    SpecimenType.fromRawType(implementingClass.loadClass(), resolveTypeArguments(abstractType, implementingClass)),
+                    context,
+                    this);
+        } catch (Exception ex) {
+            return new AbstractSpecimen<>(abstractType, context, this);
+        }
+    }
+
     private static boolean isNotParametrized(ClassInfo classInfo) {
         return classInfo.getTypeSignature() == null || classInfo.getTypeSignature().getTypeParameters().isEmpty();
     }

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

@@ -2,6 +2,7 @@
 
 import com.github.nylle.javafixture.annotations.testcases.TestCase;
 import com.github.nylle.javafixture.annotations.testcases.TestWithCases;
+import com.github.nylle.javafixture.specimen.AbstractSpecimen;
 import com.github.nylle.javafixture.specimen.ArraySpecimen;
 import com.github.nylle.javafixture.specimen.CollectionSpecimen;
 import com.github.nylle.javafixture.specimen.EnumSpecimen;
@@ -16,6 +17,14 @@
 import com.github.nylle.javafixture.testobjects.TestEnum;
 import com.github.nylle.javafixture.testobjects.TestObjectGeneric;
 import com.github.nylle.javafixture.testobjects.TestPrimitive;
+import com.github.nylle.javafixture.testobjects.abstractclasses.AbstractClassWithAbstractImplementation;
+import com.github.nylle.javafixture.testobjects.abstractclasses.AbstractClassWithGenericImplementation;
+import com.github.nylle.javafixture.testobjects.abstractclasses.AbstractClassWithImplementation;
+import com.github.nylle.javafixture.testobjects.abstractclasses.AbstractClassWithoutImplementation;
+import com.github.nylle.javafixture.testobjects.abstractclasses.GenericAbstractClassTUWithGenericImplementationT;
+import com.github.nylle.javafixture.testobjects.abstractclasses.GenericAbstractClassTUWithGenericImplementationTU;
+import com.github.nylle.javafixture.testobjects.abstractclasses.GenericAbstractClassTUWithGenericImplementationU;
+import com.github.nylle.javafixture.testobjects.abstractclasses.GenericAbstractClassWithImplementation;
 import com.github.nylle.javafixture.testobjects.example.IContract;
 import com.github.nylle.javafixture.testobjects.interfaces.GenericInterfaceTUWithGenericImplementationT;
 import com.github.nylle.javafixture.testobjects.interfaces.GenericInterfaceTUWithGenericImplementationTU;
@@ -179,4 +188,92 @@ void ifGenericImplementationOnlyUsesSecondTypeArgumentOfGenericInterface() {
             }
         }
     }
+
+    @Nested
+    @DisplayName("For abstract classes")
+    class AbstractClasses {
+
+        Context context = new Context(Configuration.configure().experimentalInterfaces(true));
+
+        @TestWithCases
+        @TestCase(bool1 = true, class2 = ObjectSpecimen.class)
+        @TestCase(bool1 = false, class2 = AbstractSpecimen.class)
+        @DisplayName("only scans for sub-classes if experimentalInterfaces is")
+        void abstractImplementationsAreOnlySupportedIfExperimentalInterfacesAreEnabled(boolean experimental, Class<?> expected) {
+            var context = new Context(Configuration.configure().experimentalInterfaces(experimental));
+
+            assertThat(new SpecimenFactory(context).build(SpecimenType.fromClass(AbstractClassWithImplementation.class))).isExactlyInstanceOf(expected);
+        }
+
+        @Nested
+        @DisplayName("creates AbstractSpecimen if")
+        class CreatesAbstractSpecimen {
+
+            @Test
+            @DisplayName("no subclasses found")
+            void createsAbstractSpecimenIfNoSubclassFound() {
+                assertThat(new SpecimenFactory(context).build(SpecimenType.fromClass(AbstractClassWithoutImplementation.class)))
+                        .isExactlyInstanceOf(AbstractSpecimen.class);
+            }
+
+            @Test
+            @DisplayName("only abstract subclasses found")
+            void createsAbstractSpecimenIfOnlyAbstractSubclassesFound() {
+                assertThat(new SpecimenFactory(context).build(SpecimenType.fromClass(AbstractClassWithAbstractImplementation.class)))
+                        .isExactlyInstanceOf(AbstractSpecimen.class);
+            }
+
+            @Test
+            @DisplayName("subclass is generic and superclass is not")
+            void createsAbstractSpecimenIfSubclassIsGenericAndSuperclassIsNot() {
+                assertThat(new SpecimenFactory(context).build(SpecimenType.fromClass(AbstractClassWithGenericImplementation.class)))
+                        .isExactlyInstanceOf(AbstractSpecimen.class);
+            }
+        }
+
+        @Nested
+        @DisplayName("creates ObjectSpecimen if")
+        class CreatesObjectSpecimen {
+
+            @Test
+            @DisplayName("subclass is not generic and superclass is not generic")
+            void createsObjectSpecimenIfBothSubclassAndSuperclassAreNotGeneric() {
+                assertThat(new SpecimenFactory(context).build(SpecimenType.fromClass(AbstractClassWithImplementation.class)))
+                        .isExactlyInstanceOf(ObjectSpecimen.class);
+            }
+
+            @Test
+            @DisplayName("subclass is not generic and superclass is generic")
+            void createsObjectSpecimenIfSubclassIsNotGenericAndSuperclassIs() {
+                assertThat(new SpecimenFactory(context).build(new SpecimenType<GenericAbstractClassWithImplementation<Integer, String>>() {}))
+                        .isExactlyInstanceOf(ObjectSpecimen.class);
+            }
+        }
+
+        @Nested
+        @DisplayName("creates GenericSpecimen if")
+        class CreatesGenericSpecimen {
+
+            @Test
+            @DisplayName("subclass is generic and superclass is generic")
+            void createsGenericSpecimenIfSubclassAndSuperclassAreGeneric() {
+                assertThat(new SpecimenFactory(context).build(new SpecimenType<GenericAbstractClassTUWithGenericImplementationTU<String, Integer>>() {}))
+                        .isExactlyInstanceOf(GenericSpecimen.class);
+            }
+
+            @Test
+            @DisplayName("generic subclass only uses first type-argument of generic superclass")
+            void createsGenericSpecimenIfGenericSubclassOnlyUsesFirstTypeArgumentOfGenericSuperclass() {
+                assertThat(new SpecimenFactory(context).build(new SpecimenType<GenericAbstractClassTUWithGenericImplementationT<String, Integer>>() {}))
+                        .isExactlyInstanceOf(GenericSpecimen.class);
+            }
+
+            @Test
+            @DisplayName("generic subclass only uses second type-argument of generic superclass")
+            void createsGenericSpecimenIfGenericSubclassOnlyUsesSecondTypeArgumentOfGenericSuperclass() {
+                assertThat(new SpecimenFactory(context).build(new SpecimenType<GenericAbstractClassTUWithGenericImplementationU<String, Integer>>() {}))
+                        .isExactlyInstanceOf(GenericSpecimen.class);
+            }
+        }
+    }
 }

src/test/java/com/github/nylle/javafixture/testobjects/abstractclasses/AbstractClassWithAbstractImplementation.java

@@ -0,0 +1,11 @@
+package com.github.nylle.javafixture.testobjects.abstractclasses;
+
+import com.github.nylle.javafixture.testobjects.TestObject;
+
+public abstract class AbstractClassWithAbstractImplementation {
+    int publicField = 1;
+
+    abstract TestObject getTestObject();
+
+    abstract void setTestDto(TestObject value);
+}

src/test/java/com/github/nylle/javafixture/testobjects/abstractclasses/AbstractClassWithAbstractImplementationImpl.java

@@ -0,0 +1,10 @@
+package com.github.nylle.javafixture.testobjects.abstractclasses;
+
+import com.github.nylle.javafixture.testobjects.TestObject;
+
+public abstract class AbstractClassWithAbstractImplementationImpl extends AbstractClassWithAbstractImplementation {
+
+    abstract TestObject getTestObject();
+
+    abstract void setTestDto(TestObject value);
+}

src/test/java/com/github/nylle/javafixture/testobjects/abstractclasses/AbstractClassWithGenericImplementation.java

@@ -0,0 +1,6 @@
+package com.github.nylle.javafixture.testobjects.abstractclasses;
+
+public abstract class AbstractClassWithGenericImplementation {
+
+    abstract String getString();
+}

src/test/java/com/github/nylle/javafixture/testobjects/abstractclasses/AbstractClassWithGenericImplementationImpl.java

@@ -0,0 +1,15 @@
+package com.github.nylle.javafixture.testobjects.abstractclasses;
+
+public class AbstractClassWithGenericImplementationImpl<T> extends AbstractClassWithGenericImplementation {
+    private T t;
+    private String string;
+
+    @Override
+    public String getString() {
+        return string;
+    }
+
+    public T getT() {
+        return t;
+    }
+}

src/test/java/com/github/nylle/javafixture/testobjects/abstractclasses/AbstractClassWithImplementation.java

@@ -0,0 +1,11 @@
+package com.github.nylle.javafixture.testobjects.abstractclasses;
+
+import com.github.nylle.javafixture.testobjects.TestObject;
+
+public abstract class AbstractClassWithImplementation {
+    int publicField = 1;
+
+    abstract TestObject getTestObject();
+
+    abstract void setTestDto(TestObject value);
+}

src/test/java/com/github/nylle/javafixture/testobjects/abstractclasses/AbstractClassWithImplementationImpl.java

@@ -0,0 +1,15 @@
+package com.github.nylle.javafixture.testobjects.abstractclasses;
+
+import com.github.nylle.javafixture.testobjects.TestObject;
+
+public class AbstractClassWithImplementationImpl extends AbstractClassWithImplementation {
+    @Override
+    public TestObject getTestObject() {
+        return null;
+    }
+
+    @Override
+    public void setTestDto(TestObject value) {
+
+    }
+}

src/test/java/com/github/nylle/javafixture/testobjects/abstractclasses/AbstractClassWithoutImplementation.java

@@ -0,0 +1,11 @@
+package com.github.nylle.javafixture.testobjects.abstractclasses;
+
+import com.github.nylle.javafixture.testobjects.TestObject;
+
+public abstract class AbstractClassWithoutImplementation {
+    int publicField = 1;
+
+    abstract TestObject getTestObject();
+
+    abstract void setTestDto(TestObject value);
+}

src/test/java/com/github/nylle/javafixture/testobjects/abstractclasses/GenericAbstractClassTUWithGenericImplementationT.java

@@ -0,0 +1,11 @@
+package com.github.nylle.javafixture.testobjects.abstractclasses;
+
+public abstract class GenericAbstractClassTUWithGenericImplementationT<T, U> {
+    int publicField = 1;
+
+    abstract T getT();
+
+    abstract void setT(T value);
+
+    abstract U getU();
+}