test/jdk/java/foreign/TestLayoutPaths.java

@@ -22,28 +22,29 @@
   *
   */
  
  /*
   * @test
-  * @enablePreview
   * @run testng TestLayoutPaths
   */
  
  import java.lang.foreign.*;
  import java.lang.foreign.MemoryLayout.PathElement;
  
  import org.testng.annotations.*;
  
  import java.lang.invoke.MethodHandle;
  import java.lang.invoke.VarHandle;
+ import java.nio.ByteOrder;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.function.IntFunction;
  
  import static java.lang.foreign.MemoryLayout.PathElement.groupElement;
  import static java.lang.foreign.MemoryLayout.PathElement.sequenceElement;
  import static java.lang.foreign.ValueLayout.JAVA_INT;
+ import static java.lang.foreign.ValueLayout.JAVA_LONG;
  import static java.lang.foreign.ValueLayout.JAVA_SHORT;
  import static org.testng.Assert.*;
  
  public class TestLayoutPaths {
  

@@ -134,37 +135,73 @@
          SequenceLayout seq = MemoryLayout.sequenceLayout(5, MemoryLayout.structLayout(JAVA_INT));
          seq.byteOffsetHandle(sequenceElement(5, 1)); // invalid range (starting position is outside the sequence)
      }
  
      @Test
-     public void testBadAlignmentOfRoot() throws Throwable {
+     public void testBadAlignmentOfRoot() {
          MemoryLayout struct = MemoryLayout.structLayout(
              JAVA_INT,
              JAVA_SHORT.withName("x"));
          assertEquals(struct.byteAlignment(), 4);
  
          try (Arena arena = Arena.ofConfined()) {
              MemorySegment seg = arena.allocate(struct.byteSize() + 2, struct.byteAlignment()).asSlice(2);
              assertEquals(seg.address() % JAVA_SHORT.byteAlignment(), 0); // should be aligned
              assertNotEquals(seg.address() % struct.byteAlignment(), 0); // should not be aligned
  
-             String expectedMessage = "Target offset incompatible with alignment constraints: " + struct.byteAlignment();
+             String expectedMessage = "Target offset 0 is incompatible with alignment constraint " + struct.byteAlignment() + " (of [i4s2(x)]) for segment MemorySegment";
  
              VarHandle vhX = struct.varHandle(groupElement("x"));
              IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, () -> {
-                 vhX.set(seg, (short) 42);
+                 vhX.set(seg, 0L, (short) 42);
              });
-             assertEquals(iae.getMessage(), expectedMessage);
+             assertTrue(iae.getMessage().startsWith(expectedMessage));
  
              MethodHandle sliceX = struct.sliceHandle(groupElement("x"));
              iae = expectThrows(IllegalArgumentException.class, () -> {
-                 MemorySegment slice = (MemorySegment) sliceX.invokeExact(seg);
+                 MemorySegment slice = (MemorySegment) sliceX.invokeExact(seg, 0L);
              });
-             assertEquals(iae.getMessage(), expectedMessage);
+             assertTrue(iae.getMessage().startsWith(expectedMessage));
          }
      }
  
+     @Test
+     public void testWrongTypeRoot() {
+         MemoryLayout struct = MemoryLayout.structLayout(
+                 JAVA_INT.withOrder(ByteOrder.LITTLE_ENDIAN),
+                 JAVA_INT.withOrder(ByteOrder.LITTLE_ENDIAN)
+         );
+ 
+         var expectedMessage = "Bad layout path: attempting to select a sequence element from a non-sequence layout: [i4i4]";
+ 
+         IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, () ->
+                 struct.select(PathElement.sequenceElement()));
+         assertEquals(iae.getMessage(), expectedMessage);
+     }
+ 
+     @Test
+     public void testWrongTypeEnclosing() {
+         MemoryLayout struct = MemoryLayout.structLayout(
+                 MemoryLayout.sequenceLayout(2, MemoryLayout.structLayout(
+                                 JAVA_INT.withOrder(ByteOrder.LITTLE_ENDIAN).withName("3a"),
+                                 JAVA_INT.withOrder(ByteOrder.LITTLE_ENDIAN).withName("3b")
+                         ).withName("2")
+                 ).withName("1")
+         ).withName("0");
+ 
+         var expectedMessage = "Bad layout path: attempting to select a sequence element from a non-sequence layout: " +
+                 "[i4(3a)i4(3b)](2), selected from: " +
+                 "[2:[i4(3a)i4(3b)](2)](1), selected from: " +
+                 "[[2:[i4(3a)i4(3b)](2)](1)](0)";
+ 
+         IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, () ->
+                 struct.select(PathElement.groupElement("1"),
+                         PathElement.sequenceElement(),
+                         PathElement.sequenceElement()));
+         assertEquals(iae.getMessage(), expectedMessage);
+     }
+ 
      @Test
      public void testBadSequencePathInOffset() {
          SequenceLayout seq = MemoryLayout.sequenceLayout(10, JAVA_INT);
          // bad path elements
          for (PathElement e : List.of( sequenceElement(), sequenceElement(0, 2) )) {

@@ -269,11 +306,11 @@
      @Test(dataProvider = "testLayouts")
      public void testOffsetHandle(MemoryLayout layout, PathElement[] pathElements, long[] indexes,
                                   long expectedByteOffset) throws Throwable {
          MethodHandle byteOffsetHandle = layout.byteOffsetHandle(pathElements);
          byteOffsetHandle = byteOffsetHandle.asSpreader(long[].class, indexes.length);
-         long actualByteOffset = (long) byteOffsetHandle.invokeExact(indexes);
+         long actualByteOffset = (long) byteOffsetHandle.invokeExact(0L, indexes);
          assertEquals(actualByteOffset, expectedByteOffset);
      }
  
      @DataProvider
      public static Object[][] testLayouts() {

@@ -358,11 +395,11 @@
          MethodHandle sliceHandle = layout.sliceHandle(pathElements);
          sliceHandle = sliceHandle.asSpreader(long[].class, indexes.length);
  
          try (Arena arena = Arena.ofConfined()) {
              MemorySegment segment = arena.allocate(layout);
-             MemorySegment slice = (MemorySegment) sliceHandle.invokeExact(segment, indexes);
+             MemorySegment slice = (MemorySegment) sliceHandle.invokeExact(segment, 0L, indexes);
              assertEquals(slice.address() - segment.address(), expectedByteOffset);
              assertEquals(slice.byteSize(), selected.byteSize());
          }
      }