fix: do not cache finished specimen #102

akutschera · Nylle · commit 1991eb4c333b · 2024-08-22T19:08:09.000+02:00
This will allow us to create different objects so we can populate
sets.
diff --git a/src/main/java/com/github/nylle/javafixture/specimen/AbstractSpecimen.java b/src/main/java/com/github/nylle/javafixture/specimen/AbstractSpecimen.java
@@ -61,9 +61,9 @@ public T create(final CustomizationContext customizationContext, Annotation[] an
                                     Map.<String, ISpecimen<?>>of().getOrDefault(
                                             field.getGenericType().getTypeName(),
                                             specimenFactory.build(SpecimenType.fromClass(field.getGenericType()))).create(new CustomizationContext(List.of(), Map.of(), false), field.getAnnotations()))));
-            return result;
+            return context.remove(type);
         } catch(SpecimenException ignored) {
-            return context.cached(type, instanceFactory.manufacture(type, customizationContext));
+            return instanceFactory.manufacture(type, customizationContext);
         }
     }
 }
diff --git a/src/main/java/com/github/nylle/javafixture/specimen/ArraySpecimen.java b/src/main/java/com/github/nylle/javafixture/specimen/ArraySpecimen.java
@@ -49,6 +49,6 @@ public T create(final CustomizationContext customizationContext, Annotation[] an
 
         IntStream.range(0, length).boxed().forEach(i -> Array.set(result, i, specimenFactory.build(SpecimenType.fromClass(type.getComponentType())).create(customizationContext, new Annotation[0])));
 
-        return result;
+        return context.remove(type);
     }
 }
diff --git a/src/main/java/com/github/nylle/javafixture/specimen/CollectionSpecimen.java b/src/main/java/com/github/nylle/javafixture/specimen/CollectionSpecimen.java
@@ -65,7 +65,7 @@ public T create(final CustomizationContext customizationContext, Annotation[] an
                 .filter(x -> specimen != null)
                 .forEach(x -> collection.add(specimen.create(customizationContext, new Annotation[0])));
 
-        return (T) collection;
+        return context.remove(type);
     }
 
     private <G extends Enum> T createEnumSet(CustomizationContext customizationContext) {
diff --git a/src/main/java/com/github/nylle/javafixture/specimen/ExperimentalAbstractSpecimen.java b/src/main/java/com/github/nylle/javafixture/specimen/ExperimentalAbstractSpecimen.java
@@ -58,11 +58,11 @@ public T create(CustomizationContext customizationContext, Annotation[] annotati
             return context.cached(type);
         }
 
-        return context.cached(type, shuffledStream(derivedTypes)
+        return shuffledStream(derivedTypes)
                 .map(derivedType -> specimenFactory.build(derivedType))
                 .flatMap(derivedSpecimen -> tryCreate(derivedSpecimen, customizationContext, annotations).stream())
                 .findFirst()
-                .orElseGet(() -> proxy(customizationContext)));
+                .orElseGet(() -> proxy(customizationContext));
     }
 
     private <R extends T> R proxy(CustomizationContext customizationContext) {
diff --git a/src/main/java/com/github/nylle/javafixture/specimen/GenericSpecimen.java b/src/main/java/com/github/nylle/javafixture/specimen/GenericSpecimen.java
@@ -61,11 +61,11 @@ public T create(CustomizationContext customizationContext, Annotation[] annotati
         }
 
         if (type.isInterface()) {
-            return (T) context.cached(type, instanceFactory.proxy(type, specimens));
+            return (T) instanceFactory.proxy(type, specimens);
         }
 
         if (customizationContext.useRandomConstructor()) {
-            return context.cached(type, instanceFactory.construct(type, customizationContext));
+            return instanceFactory.construct(type, customizationContext);
         }
 
         return populate(customizationContext);
@@ -85,9 +85,10 @@ private T populate(CustomizationContext customizationContext) {
                                             field.getGenericType().getTypeName(),
                                             specimenFactory.build(SpecimenType.fromClass(field.getType()))).create(new CustomizationContext(List.of(), Map.of(), false), new Annotation[0]))));
         } catch (SpecimenException ex) {
-            return context.overwrite(type, instanceFactory.construct(type, customizationContext));
+            context.remove(type);
+            return instanceFactory.construct(type, customizationContext);
         }
-        return result;
+        return context.remove(type);
     }
 }
 
diff --git a/src/main/java/com/github/nylle/javafixture/specimen/InterfaceSpecimen.java b/src/main/java/com/github/nylle/javafixture/specimen/InterfaceSpecimen.java
@@ -40,11 +40,7 @@ public InterfaceSpecimen(final SpecimenType<T> type, final Context context, fina
 
     @Override
     public T create(final CustomizationContext customizationContext, Annotation[] annotations) {
-        if (context.isCached(type)) {
-            return context.cached(type);
-        }
-
-        return (T) context.cached(type, instanceFactory.proxy(type));
+        return (T) instanceFactory.proxy(type);
     }
 }
 
diff --git a/src/main/java/com/github/nylle/javafixture/specimen/MapSpecimen.java b/src/main/java/com/github/nylle/javafixture/specimen/MapSpecimen.java
@@ -67,7 +67,7 @@ public T create(final CustomizationContext customizationContext, Annotation[] an
                 .filter(x -> keySpecimen != null && valueSpecimen != null)
                 .forEach(x -> map.put(keySpecimen.create(customizationContext, new Annotation[0]), valueSpecimen.create(customizationContext, new Annotation[0])));
 
-        return (T) map;
+        return context.remove(type);
     }
 
     private Map<K, V> createFromConcreteType(final SpecimenType<T> type) {
diff --git a/src/main/java/com/github/nylle/javafixture/specimen/ObjectSpecimen.java b/src/main/java/com/github/nylle/javafixture/specimen/ObjectSpecimen.java
@@ -51,7 +51,7 @@ public T create(CustomizationContext customizationContext, Annotation[] annotati
         }
 
         if (customizationContext.useRandomConstructor()) {
-            return context.cached(type, instanceFactory.construct(type, customizationContext));
+            return instanceFactory.construct(type, customizationContext);
         }
 
         return populate(customizationContext);
@@ -72,6 +72,6 @@ private T populate(CustomizationContext customizationContext) {
         } catch (SpecimenException ex) {
             return context.overwrite(type, instanceFactory.construct(type, customizationContext));
         }
-        return result;
+        return context.remove(type);
     }
 }
diff --git a/src/test/java/com/github/nylle/javafixture/InstanceFactoryTest.java b/src/test/java/com/github/nylle/javafixture/InstanceFactoryTest.java
@@ -134,15 +134,15 @@ void argumentsCanBeCustomized() {
 
         @Test
         @DisplayName("constructor arguments are cached")
-        void constructorArgumentsAreCached() {
+        void constructorArgumentsAreNotCached() {
             var sut = new InstanceFactory(new SpecimenFactory(new Context(Configuration.configure())));
 
             var customizationContext = new CustomizationContext(List.of(), Map.of(), true);
             TestObject first = sut.construct(fromClass(TestObject.class), customizationContext);
             TestObject second = sut.construct(fromClass(TestObject.class), customizationContext);
 
-            assertThat(first.getIntegers()).usingRecursiveComparison().isEqualTo(second.getIntegers());
-            assertThat(first.getStrings()).usingRecursiveComparison().isEqualTo(second.getStrings());
+            assertThat(first.getIntegers()).usingRecursiveComparison().isNotEqualTo(second.getIntegers());
+            assertThat(first.getStrings()).usingRecursiveComparison().isNotEqualTo(second.getStrings());
             assertThat(first.getValue()).as("primitives are never cached").isNotEqualTo(second.getValue());
         }
 
diff --git a/src/test/java/com/github/nylle/javafixture/specimen/AbstractSpecimenTest.java b/src/test/java/com/github/nylle/javafixture/specimen/AbstractSpecimenTest.java
@@ -108,23 +108,27 @@ void voidAbstractMethodsWillJustReturnVoid() {
 
     @Test
     void createAbstractClassWithoutConstructor() {
-        var sut = new AbstractSpecimen<Charset>(SpecimenType.fromClass(Charset.class), context, specimenFactory);
+        SpecimenType<Charset> specimenType = SpecimenType.fromClass(Charset.class);
+        var sut = new AbstractSpecimen<>(specimenType, context, specimenFactory);
+        assertThat(context.isCached(specimenType)).isFalse();
 
         var actual = sut.create(noContext(), new Annotation[0]);
 
         assertThat(actual).isInstanceOf(Charset.class);
+        assertThat(context.isCached(specimenType)).isFalse();
     }
 
     @Test
-    void resultIsCached() {
+    void resultIsNotCached() {
 
         var original = new AbstractSpecimen<TestAbstractClass>(SpecimenType.fromClass(TestAbstractClass.class), context, specimenFactory).create(noContext(), new Annotation[0]);
-        var cached = new AbstractSpecimen<TestAbstractClass>(SpecimenType.fromClass(TestAbstractClass.class), context, specimenFactory).create(noContext(), new Annotation[0]);
+        var second = new AbstractSpecimen<TestAbstractClass>(SpecimenType.fromClass(TestAbstractClass.class), context, specimenFactory).create(noContext(), new Annotation[0]);
 
         assertThat(original).isInstanceOf(TestAbstractClass.class);
-        assertThat(original).isSameAs(cached);
-        assertThat(original.toString()).isEqualTo(cached.toString());
-        assertThat(original.getString()).isSameAs(cached.getString());
+        assertThat(original).isNotEqualTo(second);
+        assertThat(original.hashCode()).isNotEqualTo(second.hashCode());
+        assertThat(original.toString()).isNotEqualTo(second.toString());
+        assertThat(original.getString()).isNotEqualTo(second.getString());
     }
 }
 
diff --git a/src/test/java/com/github/nylle/javafixture/specimen/ArraySpecimenTest.java b/src/test/java/com/github/nylle/javafixture/specimen/ArraySpecimenTest.java
@@ -9,6 +9,7 @@
 import org.junit.jupiter.api.Test;
 
 import java.lang.annotation.Annotation;
+import java.util.Arrays;
 import java.util.Map;
 
 import static com.github.nylle.javafixture.CustomizationContext.noContext;
@@ -83,8 +84,18 @@ void canHandleCircularReferences() {
         assertThat(actual).isInstanceOf(AccountManager[].class);
         assertThat(actual.length).isEqualTo(2);
         assertThat(actual[0]).isInstanceOf(AccountManager.class);
-        assertThat(actual[0]).isSameAs(actual[1]);
+        assertThat(actual[0]).isNotEqualTo(actual[1]);
         assertThat(actual[0].getOtherAccountManagers()).isInstanceOf(AccountManager[].class);
         assertThat(actual[0].getOtherAccountManagers()).isSameAs(actual);
     }
+
+    @Test
+    void createdArraysAreNotCached() {
+        var sut = new ArraySpecimen<AccountManager[]>(SpecimenType.fromClass(AccountManager[].class), context, specimenFactory);
+
+        var actual = sut.create(noContext(), new Annotation[0]);
+        var second = sut.create(noContext(), new Annotation[0]);
+
+        assertThat(Arrays.asList(actual)).doesNotContainAnyElementsOf(Arrays.asList(second));
+    }
 }
diff --git a/src/test/java/com/github/nylle/javafixture/specimen/CollectionSpecimenTest.java b/src/test/java/com/github/nylle/javafixture/specimen/CollectionSpecimenTest.java
@@ -132,12 +132,12 @@ void createTreeSetFromSortedSetInterface() {
 
     @Test
     void createHashSetFromSetInterface() {
-        var sut = new CollectionSpecimen<>(new SpecimenType<Set<String>>() {}, context, specimenFactory);
+        var sut = new CollectionSpecimen<>(new SpecimenType<Set<Object>>() {}, context, specimenFactory);
 
         var actual = sut.create(noContext(), new Annotation[0]);
 
         assertThat(actual).isInstanceOf(HashSet.class);
-        assertThat(actual.stream().allMatch(x -> x.getClass().equals(String.class))).isTrue();
+        assertThat(actual.stream().allMatch(x -> x.getClass().equals(Object.class))).isTrue();
         assertThat(actual.size()).isEqualTo(2);
     }
 
@@ -295,16 +295,16 @@ void createLinkedList() {
     }
 
     @Test
-    void resultIsCached() {
+    void resultIsNotCached() {
 
         var original = new CollectionSpecimen<>(new SpecimenType<List<String>>() {}, context, specimenFactory).create(noContext(), new Annotation[0]);
-        var cached = new CollectionSpecimen<>(new SpecimenType<List<String>>() {}, context, specimenFactory).create(noContext(), new Annotation[0]);
+        var second = new CollectionSpecimen<>(new SpecimenType<List<String>>() {}, context, specimenFactory).create(noContext(), new Annotation[0]);
 
         assertThat(original).isInstanceOf(List.class);
-        assertThat(original.size()).isEqualTo(2);
-        assertThat(original).isSameAs(cached);
-        assertThat(original.get(0)).isEqualTo(cached.get(0));
-        assertThat(original.get(1)).isEqualTo(cached.get(1));
+        assertThat(original.size()).as("collection size should be two because of this test's context").isEqualTo(2);
+        assertThat(original).isNotEqualTo(second);
+        assertThat(original.get(0)).isNotEqualTo(second.get(0));
+        assertThat(original.get(1)).isNotEqualTo(second.get(1));
     }
 
     @Test
@@ -323,7 +323,7 @@ void nestedLists() {
     }
 
     @Test
-    void nonPrimitiveElementsAreSameInstance() {
+    void nonPrimitiveElementsAreNotCached() {
 
         var sut = new CollectionSpecimen<>(new SpecimenType<List<TestObject>>() {}, context, specimenFactory);
 
@@ -333,7 +333,7 @@ void nonPrimitiveElementsAreSameInstance() {
         assertThat(actual.size()).isEqualTo(2);
         assertThat(actual.get(0)).isExactlyInstanceOf(TestObject.class);
         assertThat(actual.get(1)).isExactlyInstanceOf(TestObject.class);
-        assertThat(actual.get(0)).isSameAs(actual.get(1));
+        assertThat(actual.get(0)).isNotEqualTo(actual.get(1));
 
     }
 }
diff --git a/src/test/java/com/github/nylle/javafixture/specimen/ExperimentalAbstractSpecimenTest.java b/src/test/java/com/github/nylle/javafixture/specimen/ExperimentalAbstractSpecimenTest.java
@@ -113,16 +113,16 @@ void typeMustNotBeMap() {
     class WhenCallingCreate {
 
         @Test
-        @DisplayName("the result is cached")
-        void resultIsCached() {
+        @DisplayName("the result is not cached")
+        void resultIsNotCached() {
             var original = new InterfaceSpecimen<InterfaceWithoutImplementation>(SpecimenType.fromClass(InterfaceWithoutImplementation.class), context, specimenFactory).create(noContext(), new Annotation[0]);
-            var cached = new InterfaceSpecimen<InterfaceWithoutImplementation>(SpecimenType.fromClass(InterfaceWithoutImplementation.class), context, specimenFactory).create(noContext(), new Annotation[0]);
+            var second = new InterfaceSpecimen<InterfaceWithoutImplementation>(SpecimenType.fromClass(InterfaceWithoutImplementation.class), context, specimenFactory).create(noContext(), new Annotation[0]);
 
             assertThat(original)
                     .isInstanceOf(InterfaceWithoutImplementation.class)
-                    .isSameAs(cached);
-            assertThat(original.toString()).isEqualTo(cached.toString());
-            assertThat(original.getTestObject()).isSameAs(cached.getTestObject());
+                    .isNotEqualTo(second);
+            assertThat(original.toString()).isNotEqualTo(second.toString());
+            assertThat(original.getTestObject()).isNotEqualTo(second.getTestObject());
         }
 
         @Nested
diff --git a/src/test/java/com/github/nylle/javafixture/specimen/GenericSpecimenTest.java b/src/test/java/com/github/nylle/javafixture/specimen/GenericSpecimenTest.java
@@ -6,9 +6,12 @@
 import com.github.nylle.javafixture.SpecimenException;
 import com.github.nylle.javafixture.SpecimenFactory;
 import com.github.nylle.javafixture.SpecimenType;
+import com.github.nylle.javafixture.annotations.testcases.TestCase;
+import com.github.nylle.javafixture.annotations.testcases.TestWithCases;
 import com.github.nylle.javafixture.testobjects.TestObject;
 import com.github.nylle.javafixture.testobjects.TestObjectGeneric;
 import com.github.nylle.javafixture.testobjects.inheritance.GenericChild;
+import com.github.nylle.javafixture.testobjects.withconstructor.TestObjectWithConstructedField;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
@@ -108,6 +111,15 @@ void subSpecimenAreProperlyCached() {
         assertThat(result.getU()).isInstanceOf(Optional.class);
     }
 
+    @Test
+    void constructedGenericsAreNotCached() {
+        var first = new GenericSpecimen<>(new SpecimenType<Optional<Integer>>() {}, context, specimenFactory).create(noContext(), new Annotation[0]);
+        var second = new GenericSpecimen<>(new SpecimenType<Optional<Integer>>() {}, context, specimenFactory).create(noContext(), new Annotation[0]);
+
+        assertThat(first).isNotEqualTo(second);
+
+    }
+
     @Test
     void cannotSetNonExistingField() {
         var sut = new GenericSpecimen<>(new SpecimenType<TestObjectGeneric<String, Integer>>() {}, context, specimenFactory);
@@ -147,6 +159,42 @@ void customFieldIsOnlyUsedInTopLevelObject() {
         assertThat(actual.getTestObject().getIntegers()).isNotEmpty();
     }
 
+    @Test
+    void createdObjectsAreNotCached() {
+        var sut = new GenericSpecimen<>(new SpecimenType<WithTestObject<Integer>>() {}, context, specimenFactory);
+        var actual = sut.create(new CustomizationContext(List.of(), Map.of(), false), new Annotation[0]);
+        var second = sut.create(new CustomizationContext(List.of(), Map.of(), false), new Annotation[0]);
+
+        assertThat(actual).isNotEqualTo(second);
+    }
+
+    @DisplayName("objects are not cached, neither constructed nor populated")
+    @TestWithCases
+    @TestCase(bool1 = true)
+    @TestCase(bool1 = false)
+    void constructedObjectsAreNotCached(boolean useConstructor) {
+        var sut = new GenericSpecimen<>(new SpecimenType<WithTestObject<TestObjectWithConstructedField>>() {}, context, specimenFactory);
+
+        var actual = sut.create(new CustomizationContext(List.of(), Map.of(), useConstructor), new Annotation[0]);
+        var second = sut.create(new CustomizationContext(List.of(), Map.of(), useConstructor), new Annotation[0]);
+
+        assertThat(actual).isNotEqualTo(second);
+    }
+
+    @DisplayName("when generic type is an interface, we will fixture the non-default methods")
+    @Test
+    void interfacesAreFixtured() {
+        var sut = new GenericSpecimen<>(new SpecimenType<Comparable<Integer>>() {}, context, specimenFactory);
+
+        var actual = sut.create(new CustomizationContext(List.of(), Map.of(), false), new Annotation[0]);
+        var second = sut.create(new CustomizationContext(List.of(), Map.of(), false), new Annotation[0]);
+
+        assertThat(actual.compareTo(0))
+                .as("two different fixtured objects should have two different fixtured results")
+                .isNotEqualTo(second.compareTo(0));
+        assertThat(actual).isNotEqualTo(second);
+    }
+
     @Nested
     @DisplayName("when specimen has superclass")
     class WhenInheritance {
diff --git a/src/test/java/com/github/nylle/javafixture/specimen/InterfaceSpecimenTest.java b/src/test/java/com/github/nylle/javafixture/specimen/InterfaceSpecimenTest.java
@@ -70,15 +70,15 @@ void createInterface() {
     }
 
     @Test
-    void resultIsCached() {
+    void resultIsNotCached() {
 
         var original = new InterfaceSpecimen<InterfaceWithoutImplementation>(SpecimenType.fromClass(InterfaceWithoutImplementation.class), context, specimenFactory).create(noContext(), new Annotation[0]);
-        var cached = new InterfaceSpecimen<InterfaceWithoutImplementation>(SpecimenType.fromClass(InterfaceWithoutImplementation.class), context, specimenFactory).create(noContext(), new Annotation[0]);
+        var second = new InterfaceSpecimen<InterfaceWithoutImplementation>(SpecimenType.fromClass(InterfaceWithoutImplementation.class), context, specimenFactory).create(noContext(), new Annotation[0]);
 
         assertThat(original).isInstanceOf(InterfaceWithoutImplementation.class);
-        assertThat(original).isSameAs(cached);
-        assertThat(original.toString()).isEqualTo(cached.toString());
-        assertThat(original.getTestObject()).isSameAs(cached.getTestObject());
+        assertThat(original).isNotEqualTo(second);
+        assertThat(original.toString()).isNotEqualTo(second.toString());
+        assertThat(original.getTestObject()).isNotEqualTo(second.getTestObject());
     }
 }
 
diff --git a/src/test/java/com/github/nylle/javafixture/specimen/MapSpecimenTest.java b/src/test/java/com/github/nylle/javafixture/specimen/MapSpecimenTest.java
@@ -183,16 +183,15 @@ void createEnumMap() {
     }
 
     @Test
-    void resultIsCached() {
+    void resultIsNotCached() {
 
         var original = new MapSpecimen<>(new SpecimenType<Map<String, Integer>>() {}, context, specimenFactory).create(noContext(), new Annotation[0]);
-        var cached = new MapSpecimen<>(new SpecimenType<Map<String, Integer>>() {}, context, specimenFactory).create(noContext(), new Annotation[0]);
+        var second = new MapSpecimen<>(new SpecimenType<Map<String, Integer>>() {}, context, specimenFactory).create(noContext(), new Annotation[0]);
 
         assertThat(original).isInstanceOf(Map.class);
         assertThat(original.size()).isEqualTo(2);
-        assertThat(original).isSameAs(cached);
-        assertThat(original.get(0)).isEqualTo(cached.get(0));
-        assertThat(original.get(1)).isEqualTo(cached.get(1));
+        assertThat(original).isNotEqualTo(second);
+        assertThat(original.values()).doesNotContainAnyElementsOf(second.values());
     }
 
     @Test
diff --git a/src/test/java/com/github/nylle/javafixture/specimen/ObjectSpecimenTest.java b/src/test/java/com/github/nylle/javafixture/specimen/ObjectSpecimenTest.java

Original file line number	Diff line number	Diff line change
`@@ -61,9 +61,9 @@ public T create(final CustomizationContext customizationContext, Annotation[] an`
`61`	`61`	`Map.<String, ISpecimen<?>>of().getOrDefault(`
`62`	`62`	`field.getGenericType().getTypeName(),`
`63`	`63`	`specimenFactory.build(SpecimenType.fromClass(field.getGenericType()))).create(new CustomizationContext(List.of(), Map.of(), false), field.getAnnotations()))));`
`64`		`- return result;`
	`64`	`+ return context.remove(type);`
`65`	`65`	`} catch(SpecimenException ignored) {`
`66`		`- return context.cached(type, instanceFactory.manufacture(type, customizationContext));`
	`66`	`+ return instanceFactory.manufacture(type, customizationContext);`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,6 @@ public T create(final CustomizationContext customizationContext, Annotation[] an`
`49`	`49`
`50`	`50`	`IntStream.range(0, length).boxed().forEach(i -> Array.set(result, i, specimenFactory.build(SpecimenType.fromClass(type.getComponentType())).create(customizationContext, new Annotation[0])));`
`51`	`51`
`52`		`- return result;`
	`52`	`+ return context.remove(type);`
`53`	`53`	`}`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ public T create(final CustomizationContext customizationContext, Annotation[] an`
`65`	`65`	`.filter(x -> specimen != null)`
`66`	`66`	`.forEach(x -> collection.add(specimen.create(customizationContext, new Annotation[0])));`
`67`	`67`
`68`		`- return (T) collection;`
	`68`	`+ return context.remove(type);`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`private <G extends Enum> T createEnumSet(CustomizationContext customizationContext) {`
Original file line number	Diff line number	Diff line change
`@@ -58,11 +58,11 @@ public T create(CustomizationContext customizationContext, Annotation[] annotati`
`58`	`58`	`return context.cached(type);`
`59`	`59`	`}`
`60`	`60`
`61`		`- return context.cached(type, shuffledStream(derivedTypes)`
	`61`	`+ return shuffledStream(derivedTypes)`
`62`	`62`	`.map(derivedType -> specimenFactory.build(derivedType))`
`63`	`63`	`.flatMap(derivedSpecimen -> tryCreate(derivedSpecimen, customizationContext, annotations).stream())`
`64`	`64`	`.findFirst()`
`65`		`- .orElseGet(() -> proxy(customizationContext)));`
	`65`	`+ .orElseGet(() -> proxy(customizationContext));`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`private <R extends T> R proxy(CustomizationContext customizationContext) {`
Original file line number	Diff line number	Diff line change
`@@ -61,11 +61,11 @@ public T create(CustomizationContext customizationContext, Annotation[] annotati`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`if (type.isInterface()) {`
`64`		`- return (T) context.cached(type, instanceFactory.proxy(type, specimens));`
	`64`	`+ return (T) instanceFactory.proxy(type, specimens);`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`if (customizationContext.useRandomConstructor()) {`
`68`		`- return context.cached(type, instanceFactory.construct(type, customizationContext));`
	`68`	`+ return instanceFactory.construct(type, customizationContext);`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`return populate(customizationContext);`
`@@ -85,9 +85,10 @@ private T populate(CustomizationContext customizationContext) {`
`85`	`85`	`field.getGenericType().getTypeName(),`
`86`	`86`	`specimenFactory.build(SpecimenType.fromClass(field.getType()))).create(new CustomizationContext(List.of(), Map.of(), false), new Annotation[0]))));`
`87`	`87`	`} catch (SpecimenException ex) {`
`88`		`- return context.overwrite(type, instanceFactory.construct(type, customizationContext));`
	`88`	`+ context.remove(type);`
	`89`	`+ return instanceFactory.construct(type, customizationContext);`
`89`	`90`	`}`
`90`		`- return result;`
	`91`	`+ return context.remove(type);`
`91`	`92`	`}`
`92`	`93`	`}`
`93`	`94`
Original file line number	Diff line number	Diff line change
`@@ -40,11 +40,7 @@ public InterfaceSpecimen(final SpecimenType<T> type, final Context context, fina`
`40`	`40`
`41`	`41`	`@Override`
`42`	`42`	`public T create(final CustomizationContext customizationContext, Annotation[] annotations) {`
`43`		`- if (context.isCached(type)) {`
`44`		`- return context.cached(type);`
`45`		`- }`
`46`		`-`
`47`		`- return (T) context.cached(type, instanceFactory.proxy(type));`
	`43`	`+ return (T) instanceFactory.proxy(type);`
`48`	`44`	`}`
`49`	`45`	`}`
`50`	`46`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ public T create(final CustomizationContext customizationContext, Annotation[] an`
`67`	`67`	`.filter(x -> keySpecimen != null && valueSpecimen != null)`
`68`	`68`	`.forEach(x -> map.put(keySpecimen.create(customizationContext, new Annotation[0]), valueSpecimen.create(customizationContext, new Annotation[0])));`
`69`	`69`
`70`		`- return (T) map;`
	`70`	`+ return context.remove(type);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`private Map<K, V> createFromConcreteType(final SpecimenType<T> type) {`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public T create(CustomizationContext customizationContext, Annotation[] annotati`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`if (customizationContext.useRandomConstructor()) {`
`54`		`- return context.cached(type, instanceFactory.construct(type, customizationContext));`
	`54`	`+ return instanceFactory.construct(type, customizationContext);`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`return populate(customizationContext);`
`@@ -72,6 +72,6 @@ private T populate(CustomizationContext customizationContext) {`
`72`	`72`	`} catch (SpecimenException ex) {`
`73`	`73`	`return context.overwrite(type, instanceFactory.construct(type, customizationContext));`
`74`	`74`	`}`
`75`		`- return result;`
	`75`	`+ return context.remove(type);`
`76`	`76`	`}`
`77`	`77`	`}`