Merge pull request #1112 from jqno/sealed-null

Sealed null

Author: jqno

CHANGELOG.md

@@ -14,6 +14,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- `NullPointerException` with abstract sealed types whose subtypes add state and need `Warning.NULL_FIELDS` suppressed. ([Issue 1111](https://github.com/jqno/equalsverifier/issues/1111))
+
 ## [4.0.7] - 2025-07-30
 
 ### Fixed

equalsverifier-core/src/main/java/nl/jqno/equalsverifier/internal/instantiation/InstanceCreator.java

@@ -24,9 +24,20 @@ public class InstanceCreator<T> {
      * @param objenesis To instantiate non-record classes.
      */
     public InstanceCreator(ClassProbe<T> probe, Objenesis objenesis) {
-        this.type = probe.getType();
         this.probe = probe;
-        this.instantiator = Instantiator.of(type, objenesis);
+        this.instantiator = Instantiator.of(probe.getType(), objenesis);
+        this.type = instantiator.getType();
+    }
+
+    /**
+     * Returns the actual type as determined by the Instantiator. The instantiator might defer to a subtype of the given
+     * type, for example if it's a sealed abstract type. The subtype might have additional fields, which need to receive
+     * values too.
+     *
+     * @return The actual type.
+     */
+    public Class<T> getActualType() {
+        return type;
     }
 
     /**

equalsverifier-core/src/main/java/nl/jqno/equalsverifier/internal/instantiation/SubjectCreator.java

@@ -18,6 +18,7 @@ public class SubjectCreator<T> {
 
     private final TypeTag typeTag;
     private final Class<T> type;
+    private final Class<? extends T> actualType;
     private final Configuration<T> config;
     private final ValueProvider valueProvider;
     private final ClassProbe<T> classProbe;
@@ -39,6 +40,7 @@ public SubjectCreator(Configuration<T> config, ValueProvider valueProvider, Obje
         this.classProbe = ClassProbe.of(type);
         this.objenesis = objenesis;
         this.instanceCreator = new InstanceCreator<>(classProbe, objenesis);
+        this.actualType = instanceCreator.getActualType();
     }
 
     /**
@@ -236,10 +238,14 @@ private Map<Field, Object> with(Field f, Object v) {
     }
 
     private FieldIterable fields() {
-        return FieldIterable.ofIgnoringStatic(type);
+        return FieldIterable.ofIgnoringStatic(actualType);
     }
 
     private FieldIterable nonSuperFields() {
+        // This should probably use `actualType` instead of `type`, but then we'd need to find
+        // a way to include all fields from `type` and `actualType` together but without the fields
+        // from `type`'s superclass. That's hard, and it doesn't seem to come up in practice. I'm
+        // leaving this comment here as an explanation, in case it does come up at some point.
         return FieldIterable.ofIgnoringSuperAndStatic(type);
     }
 

equalsverifier-core/src/main/java/nl/jqno/equalsverifier/internal/reflection/Instantiator.java

@@ -56,6 +56,15 @@ public static <T> Instantiator<T> of(Class<T> type, Objenesis objenesis) {
         return new Instantiator<>(type, objenesis);
     }
 
+    /**
+     * The actual type that will be instantiated. Could be a subclass of the requested type.
+     *
+     * @return The actual type that will be instantiated.
+     */
+    public Class<T> getType() {
+        return type;
+    }
+
     /**
      * Instantiates an object of type T.
      *

equalsverifier-core/src/main/java/nl/jqno/equalsverifier/internal/reflection/SealedTypesFinder.java

@@ -10,13 +10,11 @@ public final class SealedTypesFinder {
     private SealedTypesFinder() {}
 
     public static <T, U extends T> Optional<Class<U>> findInstantiableSubclass(Class<T> type) {
-        return findInstantiablePermittedClass(type, false);
+        return findInstantiablePermittedClass(type);
     }
 
-    private static <T, U extends T> Optional<Class<U>> findInstantiablePermittedClass(
-            Class<T> type,
-            boolean checkCurrent) {
-        if (checkCurrent && (!isAbstract(type) || !type.isSealed())) {
+    private static <T, U extends T> Optional<Class<U>> findInstantiablePermittedClass(Class<T> type) {
+        if (!isAbstract(type) || !type.isSealed()) {
             @SuppressWarnings("unchecked")
             var result = (Class<U>) type;
             return Optional.of(result);
@@ -29,7 +27,7 @@ private static <T, U extends T> Optional<Class<U>> findInstantiablePermittedClas
             @SuppressWarnings("unchecked")
             Class<U> subType = (Class<U>) permitted;
 
-            var c = findInstantiablePermittedClass(subType, true);
+            var c = findInstantiablePermittedClass(subType);
             if (c.isPresent()) {
                 return c;
             }

equalsverifier-core/src/test/java/nl/jqno/equalsverifier/internal/instantiation/InstanceCreatorTest.java

@@ -12,10 +12,31 @@
 
 class InstanceCreatorTest {
 
+    private final Objenesis objenesis = new ObjenesisStd();
+
+    @Test
+    void getActualType() {
+        var probe = ClassProbe.of(SomeClass.class);
+        var sut = new InstanceCreator<>(probe, objenesis);
+
+        Class<SomeClass> actual = sut.getActualType();
+
+        assertThat(actual).isEqualTo(SomeClass.class);
+    }
+
+    @Test
+    void getActualType_sealedAbstract() {
+        var probe = ClassProbe.of(SealedAbstract.class);
+        var sut = new InstanceCreator<>(probe, objenesis);
+
+        Class<SealedAbstract> actual = sut.getActualType();
+
+        assertThat(actual).isEqualTo(SealedSub.class);
+    }
+
     @Test
     void instantiate() throws NoSuchFieldException {
         ClassProbe<SomeClass> probe = ClassProbe.of(SomeClass.class);
-        Objenesis objenesis = new ObjenesisStd();
         var sut = new InstanceCreator<InstanceCreatorTest.SomeClass>(probe, objenesis);
 
         Field x = SomeClass.class.getDeclaredField("x");
@@ -32,7 +53,6 @@ void instantiate() throws NoSuchFieldException {
     @Test
     void copy() throws NoSuchFieldException {
         ClassProbe<SomeSubClass> probe = ClassProbe.of(SomeSubClass.class);
-        Objenesis objenesis = new ObjenesisStd();
         var sut = new InstanceCreator<InstanceCreatorTest.SomeSubClass>(probe, objenesis);
 
         SomeClass original = new SomeClass(42, 1337, "yeah");
@@ -66,4 +86,8 @@ public SomeSubClass(int x, int y, String z, int a) {
             this.a = a;
         }
     }
+
+    sealed static abstract class SealedAbstract permits SealedSub {}
+
+    static final class SealedSub extends SealedAbstract {}
 }

equalsverifier-core/src/test/java/nl/jqno/equalsverifier/internal/instantiation/SubjectCreatorTest.java

@@ -52,6 +52,18 @@ void plain() {
         assertThat(actual).isEqualTo(expected);
     }
 
+    @Test
+    void plain_sealedAbstract() {
+        var anotherConfig = ConfigurationHelper.emptyConfiguration(SealedAbstract.class);
+        var anotherSut = new SubjectCreator<>(anotherConfig, valueProvider, objenesis);
+        var anotherActual = anotherSut.plain();
+
+        assertThat(anotherActual.s).isEqualTo(S_RED);
+
+        // SubjectCreator returns a subclass with new fields!
+        assertThat(((SealedSub) anotherActual).i).isEqualTo(I_RED);
+    }
+
     @Test
     void withFieldDefaulted_super() {
         expected = new SomeClass(0, I_RED, S_RED);
@@ -330,4 +342,21 @@ public String toString() {
             return "SomeSub: " + x + "," + i + "," + s + "," + q;
         }
     }
+
+    sealed static abstract class SealedAbstract permits SealedSub {
+        private final String s;
+
+        public SealedAbstract(String s) {
+            this.s = s;
+        }
+    }
+
+    static final class SealedSub extends SealedAbstract {
+        private final int i;
+
+        public SealedSub(String s, int i) {
+            super(s);
+            this.i = i;
+        }
+    }
 }

equalsverifier-core/src/test/java/nl/jqno/equalsverifier/internal/reflection/InstantiatorTest.java

@@ -23,6 +23,24 @@ class InstantiatorTest {
 
     private final Objenesis objenesis = new ObjenesisStd();
 
+    @Test
+    void getType() {
+        Instantiator<Point> instantiator = Instantiator.of(Point.class, objenesis);
+        Class<Point> type = instantiator.getType();
+        assertThat(type).isEqualTo(Point.class);
+    }
+
+    @Test
+    void getType_sealedAbstract() {
+        Instantiator<SealedAbstract> instantiator = Instantiator.of(SealedAbstract.class, objenesis);
+        Class<SealedAbstract> type = instantiator.getType();
+        assertThat(type).isEqualTo(SealedSub.class);
+    }
+
+    sealed static abstract class SealedAbstract permits SealedSub {}
+
+    static final class SealedSub extends SealedAbstract {}
+
     @Test
     void instantiateClass() {
         Instantiator<Point> instantiator = Instantiator.of(Point.class, objenesis);

equalsverifier-core/src/test/java/nl/jqno/equalsverifier/internal/reflection/SealedTypesHelperTest.java renamed to equalsverifier-core/src/test/java/nl/jqno/equalsverifier/internal/reflection/SealedTypesFinderTest.java

@@ -2,11 +2,9 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-import java.util.Optional;
-
 import org.junit.jupiter.api.Test;
 
-class SealedTypesHelperTest {
+class SealedTypesFinderTest {
 
     @Test
     void twoLevels() {
@@ -35,7 +33,7 @@ static final class FourLevelChild implements FourLevelMiddle2 {}
     @Test
     void allConcrete() {
         var actual = SealedTypesFinder.findInstantiableSubclass(AllConcreteParent.class);
-        assertThat(actual.get()).isEqualTo(AllConcreteMiddle.class);
+        assertThat(actual.get()).isEqualTo(AllConcreteParent.class);
     }
 
     sealed static class AllConcreteParent {}
@@ -44,6 +42,18 @@ sealed static class AllConcreteMiddle extends AllConcreteParent {}
 
     static final class AllConcreteChild extends AllConcreteMiddle {}
 
+    @Test
+    void abstractTopThreeLevels() {
+        var actual = SealedTypesFinder.findInstantiableSubclass(AbstractParent.class);
+        assertThat(actual.get()).isEqualTo(AbstractMiddle.class);
+    }
+
+    sealed abstract static class AbstractParent {}
+
+    sealed static class AbstractMiddle extends AbstractParent {}
+
+    static final class AbstractChild extends AbstractMiddle {}
+
     @Test
     void nonSealedAtTheBottom() {
         var actual = SealedTypesFinder.findInstantiableSubclass(NonSealedAtTheBottomParent.class);
@@ -57,6 +67,6 @@ non-sealed interface NonSealedAtTheBottomChild extends NonSealedAtTheBottomParen
     @Test
     void notSealed() {
         var actual = SealedTypesFinder.findInstantiableSubclass(Object.class);
-        assertThat(actual).isEqualTo(Optional.empty());
+        assertThat(actual.get()).isEqualTo(Object.class);
     }
 }

equalsverifier-test/src/test/java/nl/jqno/equalsverifier/integration/extended_contract/SealedTypesTest.java

@@ -3,6 +3,7 @@
 import java.util.Objects;
 
 import nl.jqno.equalsverifier.EqualsVerifier;
+import nl.jqno.equalsverifier.Warning;
 import nl.jqno.equalsverifier_testhelpers.ExpectedException;
 import org.junit.jupiter.api.Test;
 
@@ -64,6 +65,11 @@ void fail_whenSealeadParentHasAnIncorrectImplementationOfEquals() {
                 .assertFailure();
     }
 
+    @Test
+    void succeed_whenSealedParentHasTwoChildren_parent() {
+        EqualsVerifier.forClass(SealedParentWithTwoChildren.class).verify();
+    }
+
     @Test
     void succeed_whenSealedParentHasTwoChildren_a() {
         EqualsVerifier.forClass(SealedChildA.class).verify();
@@ -74,6 +80,22 @@ void succeed_whenSealedParentHasTwoChildren_b() {
         EqualsVerifier.forClass(SealedChildB.class).verify();
     }
 
+    @Test
+    void succeed_whenSealedParentThrowsNull() {
+        EqualsVerifier
+                .forClass(SealedParentThrowsNull.class)
+                .suppress(Warning.STRICT_INHERITANCE, Warning.NULL_FIELDS)
+                .verify();
+    }
+
+    @Test
+    void succeed_whenSealedChildThrowsNull() {
+        EqualsVerifier
+                .forClass(SealedChildThrowsNull.class)
+                .suppress(Warning.STRICT_INHERITANCE, Warning.NULL_FIELDS)
+                .verify();
+    }
+
     public abstract static sealed class SealedParentWithFinalChild permits FinalSealedChild {
 
         private final int i;
@@ -212,14 +234,14 @@ protected SealedParentWithTwoChildren(String value) {
         }
 
         @Override
-        public boolean equals(Object other) {
+        public final boolean equals(Object other) {
             return other != null
                     && (this.getClass() == other.getClass())
                     && Objects.equals(this.value, ((SealedParentWithTwoChildren) other).value);
         }
 
         @Override
-        public int hashCode() {
+        public final int hashCode() {
             return Objects.hashCode(this.value);
         }
 
@@ -242,4 +264,43 @@ public static final class SealedChildB extends SealedParentWithTwoChildren {
             super(value);
         }
     }
+
+    public static abstract sealed class SealedParentThrowsNull permits SealedChildThrowsNull {
+        private final String string;
+
+        public SealedParentThrowsNull(String string) {
+            this.string = string;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            return obj instanceof SealedParentThrowsNull other && Objects.equals(string, other.string);
+        }
+
+        @Override
+        public int hashCode() {
+            return string.hashCode();
+        }
+    }
+
+    public static final class SealedChildThrowsNull extends SealedParentThrowsNull {
+        private final Integer i;
+
+        public SealedChildThrowsNull(String string, Integer i) {
+            super(string);
+            this.i = i;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            return obj instanceof SealedChildThrowsNull other && super.equals(obj) && Objects.equals(i, other.i);
+        }
+
+        @Override
+        public int hashCode() {
+            int hashCode = super.hashCode();
+            hashCode = 31 * hashCode + i.hashCode();
+            return hashCode;
+        }
+    }
 }