Inconsistent Collection Behaviour Between Records and Classes

[jk-idealo]

I know, that due to the currently supported java-version, Fixture cannot natively support records. However, so far it implicitly supports them through constructor-creation in the case that an instance cannot be mutated after creation.

This test is green:

@Test
void canCreateDistinctElementsInCollectionForClasses() {
    var actual = fixture().create(ClassWithList.class);

    assertThat(actual.getChildren().get(0)).isNotSameAs(actual.getChildren().get(1));
}

public static class ClassWithList {
    private final List<Child> children;

    public ClassWithList(List<Child> children) {
        this.children = children;
    }

    public List<Child> getChildren() {
        return children;
    }

    public static class Child {
        private final String string;

        public Child(String string) {
            this.string = string;
        }

        public String getString() {
            return string;
        }
    }
}

The test above is green, because Fixture will create distinct instances of classes in a collection.

The test below however is red, because the behaviour above does not seem to apply to records:

@Test
void canCreateDistinctElementsInCollectionForRecords() {
    var actual = fixture().create(RecordWithList.class);

    assertThat(actual.children().get(0)).isNotSameAs(actual.children().get(1));
}

public record RecordWithList(List<Child> children) {
    public record Child(String string) {}
}

(Unfortunately, I cannot run the test in Fixture, since its java-version doesn't support records.)

[Nylle]

When running the test with a class, in CollectionSpecimen, we add to the collection by calling create on the ObjectSpecimen, where we check whether an instance is already cached - which it isn't, so we add it. But after we created the instance, we remove it from the cache again.
When dealing with records though, the population of the object fails (because it's immutable), so we fall back to a constructor-based approach. In that case, however, we do not remove the instance from the cache, so when we create the next instance for the collection, we end up in the ObjectSpecimen again and pick the existing instance from the cache.

[akutschera]

Excellent analysis. We added the remove from the cache so we could populate Sets with more than one member #102
The fix is rather simple. Just remove the constructor-created object from the cache after creation.