Add tests

Author: minborg

src/java.base/share/classes/jdk/internal/access/HeterogeneousContainer.java

@@ -138,7 +138,7 @@ static <T> HeterogeneousContainer<T> of(Class<T> type) {
         if (!type.isSealed()) {
             throw new IllegalArgumentException("The provided type must be sealed: " + type);
         }
-        throw new UnsupportedOperationException();
+        return HeterogeneousContainerImpl.of(Objects.requireNonNull(type.getPermittedSubclasses()));
     }
 
 }

src/java.base/share/classes/jdk/internal/access/HeterogeneousContainerImpl.java

@@ -5,6 +5,7 @@
 import jdk.internal.vm.annotation.ForceInline;
 import jdk.internal.vm.annotation.Stable;
 
+import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.StringJoiner;
 import java.util.function.Function;
@@ -16,7 +17,11 @@ record HeterogeneousContainerImpl<T>(@Stable Object[] table) implements Heteroge
 
     @ForceInline
     public <C extends T> C get(Class<C> type) {
-        return type.cast(componentRaw(type));
+        final Object componentRaw = componentRaw(type);
+        if (componentRaw == null) {
+            throw new NoSuchElementException("No component of type " + type);
+        }
+        return type.cast(componentRaw);
     }
 
     public boolean isInitialized(Class<? extends T> type) {

…nstant/StableComponentContainerTest.java …Constant/HeterogeneousContainerTest.javatest/jdk/java/lang/LazyConstant/StableComponentContainerTest.java renamed to test/jdk/java/lang/LazyConstant/HeterogeneousContainerTest.java test/jdk/java/lang/LazyConstant/StableComponentContainerTest.java renamed to test/jdk/java/lang/LazyConstant/HeterogeneousContainerTest.java

@@ -22,13 +22,13 @@
  */
 
 /* @test
- * @summary Basic tests for the StableComponentContainer implementation
+ * @summary Basic tests for the HeterogeneousContainer implementation
  * @enablePreview
  * @modules java.base/jdk.internal.access:+open
- * @run junit StableComponentContainerTest
+ * @run junit HeterogeneousContainerTest
  */
 
-import jdk.internal.access.StableComponentContainer;
+import jdk.internal.access.HeterogeneousContainer;
 import org.junit.jupiter.api.Test;
 
 import java.math.BigInteger;
@@ -38,7 +38,7 @@
 
 import static org.junit.jupiter.api.Assertions.*;
 
-final class StableComponentContainerTest {
+final class HeterogeneousContainerTest {
 
     private static final Set<Class<? extends Number>> SET = Set.of(
             Byte.class,
@@ -48,35 +48,26 @@ final class StableComponentContainerTest {
             Float.class,
             Double.class);
 
-    sealed interface Component {
-        sealed interface Foo extends Component {
-            final class FooImp implements Foo {}
-        }
-
-        sealed interface Bar extends Component {
-            final class BarImp implements Bar {}
-        }
-    }
 
     @Test
     void factoryInvariants() {
-        assertThrows(NullPointerException.class, () -> StableComponentContainer.of((Set<Class<?>>) null));
+        assertThrows(NullPointerException.class, () -> HeterogeneousContainer.of((Set<Class<?>>) null));
         Set<Class<? extends Number>> setWithNull = new HashSet<>();
         setWithNull.add(Byte.class);
         setWithNull.add(Short.class);
         setWithNull.add(null);
         setWithNull.add(Integer.class);
-        assertThrows(NullPointerException.class, () -> StableComponentContainer.of(setWithNull));
+        assertThrows(NullPointerException.class, () -> HeterogeneousContainer.of(setWithNull));
 
-        assertThrows(NullPointerException.class, () -> StableComponentContainer.of((Class<?>) null));
+        assertThrows(NullPointerException.class, () -> HeterogeneousContainer.of((Class<?>) null));
         // Integer is not a sealed class
-        var x = assertThrows(IllegalArgumentException.class, () -> StableComponentContainer.of(Integer.class));
+        var x = assertThrows(IllegalArgumentException.class, () -> HeterogeneousContainer.of(Integer.class));
         assertEquals("The provided type must be sealed: " + Integer.class, x.getMessage());
     }
 
     @Test
     void basic() {
-        StableComponentContainer<Number> container = populated();
+        HeterogeneousContainer<Number> container = populated();
         for (Class<? extends Number> type : SET) {
             Number value = container.get(type);
             assertEquals(1, value.intValue(), type.toString());
@@ -85,11 +76,13 @@ void basic() {
         assertEquals("The component is already initialized: " + Byte.class.getName(), x0.getMessage());
         var x1 = assertThrows(IllegalArgumentException.class, () -> container.set(BigInteger.class, BigInteger.ONE));
         assertTrue(x1.getMessage().startsWith("The type '" + BigInteger.class.getName() + "' is outside the allowed input types:"), x1.getMessage());
+        var x2 = assertThrows(IllegalArgumentException.class, () -> container.get(BigInteger.class));
+        assertTrue(x2.getMessage().startsWith("The type 'java.math.BigInteger' is outside the allowed input types:"), x2.getMessage());
     }
 
     @Test
     void testToString() {
-        StableComponentContainer<Number> container = populated();
+        HeterogeneousContainer<Number> container = populated();
         var toString = container.toString();
         assertTrue(toString.startsWith("StableComponentContainer{"), toString);
         for (Class<? extends Number> type : SET) {
@@ -100,16 +93,16 @@ void testToString() {
 
     @Test
     void testToStringEmpty() {
-        StableComponentContainer<Number> container = StableComponentContainer.of(Set.of());
+        HeterogeneousContainer<Number> container = HeterogeneousContainer.of(Set.of());
         assertEquals("StableComponentContainer{}", container.toString());
     }
 
     @Test
     void computeIfAbsent() {
-        StableComponentContainer<Number> container = StableComponentContainer.of(SET);
-        Integer value = container.computeIfAbsent(Integer.class, StableComponentContainerTest::mapper);
+        HeterogeneousContainer<Number> container = HeterogeneousContainer.of(SET);
+        Integer value = container.computeIfAbsent(Integer.class, HeterogeneousContainerTest::mapper);
         assertEquals(1, value);
-        assertThrows(NullPointerException.class, () -> container.computeIfAbsent(Byte.class, StableComponentContainerTest::mapper));
+        assertThrows(NullPointerException.class, () -> container.computeIfAbsent(Byte.class, HeterogeneousContainerTest::mapper));
     }
 
     static <C extends Number> C mapper(Class<C> type) {
@@ -120,8 +113,8 @@ static <C extends Number> C mapper(Class<C> type) {
         });
     }
 
-    private static StableComponentContainer<Number> populated() {
-        StableComponentContainer<Number> container = StableComponentContainer.of(SET);
+    private static HeterogeneousContainer<Number> populated() {
+        HeterogeneousContainer<Number> container = HeterogeneousContainer.of(SET);
         container.set(Byte.class, (byte) 1);
         container.set(Short.class, (short) 1);
         container.set(Integer.class, 1);
@@ -131,4 +124,36 @@ private static StableComponentContainer<Number> populated() {
         return container;
     }
 
+    sealed interface NumericOperations {
+        non-sealed interface Adder extends NumericOperations {
+            int add(int a, int b);
+        }
+        non-sealed interface Subtractor extends NumericOperations {
+            int subtract(int a, int b);
+        }
+    }
+
+    @Test
+    void testSealedType() {
+        HeterogeneousContainer<NumericOperations> ops = HeterogeneousContainer.of(NumericOperations.class);
+        ops.set(NumericOperations.Adder.class, Integer::sum);
+        ops.set(NumericOperations.Subtractor.class, StrictMath::subtractExact);
+        // ...
+        assertEquals(3, ops.get(NumericOperations.Adder.class).add(1,2));
+        assertEquals(Integer.MIN_VALUE, ops.get(NumericOperations.Adder.class).add(Integer.MAX_VALUE,1));
+
+        assertEquals(-1, ops.get(NumericOperations.Subtractor.class).subtract(1,2));
+        assertThrows(ArithmeticException.class, () -> ops.get(NumericOperations.Subtractor.class).subtract(Integer.MIN_VALUE,1));
+    }
+
+    @Test
+    void testNoBounds() {
+        HeterogeneousContainer<Object> c = HeterogeneousContainer.of(Set.of(Integer.class, Long.class, Object.class));
+        c.set(Integer.class,1);
+        c.set(Long.class,2L);
+        assertEquals(1, c.get(Integer.class));
+        assertEquals(2L, c.get(Long.class));
+        assertThrows(NoSuchElementException.class, () -> c.get(Object.class));
+    }
+
 }