< prev index next >

test/jdk/java/foreign/TestMemoryAlignment.java

Print this page
@@ -24,50 +24,54 @@
  /*
   * @test
   * @run testng TestMemoryAlignment
   */
  
- import jdk.incubator.foreign.MemoryLayouts;
  import jdk.incubator.foreign.MemoryLayout;
  
  import jdk.incubator.foreign.GroupLayout;
  import jdk.incubator.foreign.MemoryLayout.PathElement;
  import jdk.incubator.foreign.MemorySegment;
  import jdk.incubator.foreign.ResourceScope;
  import jdk.incubator.foreign.SequenceLayout;
  import jdk.incubator.foreign.ValueLayout;
  import java.lang.invoke.VarHandle;
+ import java.nio.ByteOrder;
  import java.util.stream.LongStream;
  
  import org.testng.annotations.*;
  import static org.testng.Assert.*;
  
  public class TestMemoryAlignment {
  
      @Test(dataProvider = "alignments")
      public void testAlignedAccess(long align) {
-         ValueLayout layout = MemoryLayouts.BITS_32_BE;
+         ValueLayout layout = ValueLayout.JAVA_INT
+                 .withBitAlignment(32)
+                 .withOrder(ByteOrder.BIG_ENDIAN);
          assertEquals(layout.bitAlignment(), 32);
          ValueLayout aligned = layout.withBitAlignment(align);
          assertEquals(aligned.bitAlignment(), align); //unreasonable alignment here, to make sure access throws
-         VarHandle vh = aligned.varHandle(int.class);
+         VarHandle vh = aligned.varHandle();
          try (ResourceScope scope = ResourceScope.newConfinedScope()) {
              MemorySegment segment = MemorySegment.allocateNative(aligned, scope);
              vh.set(segment, -42);
              int val = (int)vh.get(segment);
              assertEquals(val, -42);
          }
      }
  
      @Test(dataProvider = "alignments")
      public void testUnalignedAccess(long align) {
-         ValueLayout layout = MemoryLayouts.BITS_32_BE;
+         ValueLayout layout = ValueLayout.JAVA_INT
+                 .withBitAlignment(32)
+                 .withOrder(ByteOrder.BIG_ENDIAN);
          assertEquals(layout.bitAlignment(), 32);
          ValueLayout aligned = layout.withBitAlignment(align);
-         MemoryLayout alignedGroup = MemoryLayout.structLayout(MemoryLayouts.PAD_8, aligned);
+         MemoryLayout alignedGroup = MemoryLayout.structLayout(MemoryLayout.paddingLayout(8), aligned);
          assertEquals(alignedGroup.bitAlignment(), align);
-         VarHandle vh = aligned.varHandle(int.class);
+         VarHandle vh = aligned.varHandle();
          try (ResourceScope scope = ResourceScope.newConfinedScope()) {
              MemorySegment segment = MemorySegment.allocateNative(alignedGroup, scope);
              vh.set(segment.asSlice(1L), -42);
              assertEquals(align, 8); //this is the only case where access is aligned
          } catch (IllegalStateException ex) {

@@ -75,26 +79,26 @@
          }
      }
  
      @Test(dataProvider = "alignments")
      public void testUnalignedPath(long align) {
-         MemoryLayout layout = MemoryLayouts.BITS_32_BE;
+         MemoryLayout layout = ValueLayout.JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN);
          MemoryLayout aligned = layout.withBitAlignment(align).withName("value");
-         GroupLayout alignedGroup = MemoryLayout.structLayout(MemoryLayouts.PAD_8, aligned);
+         GroupLayout alignedGroup = MemoryLayout.structLayout(MemoryLayout.paddingLayout(8), aligned);
          try {
-             alignedGroup.varHandle(int.class, PathElement.groupElement("value"));
+             alignedGroup.varHandle(PathElement.groupElement("value"));
              assertEquals(align, 8); //this is the only case where path is aligned
          } catch (UnsupportedOperationException ex) {
              assertNotEquals(align, 8); //if align != 8, path is always unaligned
          }
      }
  
      @Test(dataProvider = "alignments")
      public void testUnalignedSequence(long align) {
-         SequenceLayout layout = MemoryLayout.sequenceLayout(5, MemoryLayouts.BITS_32_BE.withBitAlignment(align));
+         SequenceLayout layout = MemoryLayout.sequenceLayout(5, ValueLayout.JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN).withBitAlignment(align));
          try {
-             VarHandle vh = layout.varHandle(int.class, PathElement.sequenceElement());
+             VarHandle vh = layout.varHandle(PathElement.sequenceElement());
              try (ResourceScope scope = ResourceScope.newConfinedScope()) {
                  MemorySegment segment = MemorySegment.allocateNative(layout, scope);
                  for (long i = 0 ; i < 5 ; i++) {
                      vh.set(segment, i, -42);
                  }

@@ -104,21 +108,21 @@
          }
      }
  
      @Test
      public void testPackedAccess() {
-         ValueLayout vChar = MemoryLayouts.BITS_8_BE;
-         ValueLayout vShort = MemoryLayouts.BITS_16_BE;
-         ValueLayout vInt = MemoryLayouts.BITS_32_BE;
+         ValueLayout vChar = ValueLayout.JAVA_BYTE;
+         ValueLayout vShort = ValueLayout.JAVA_SHORT.withOrder(ByteOrder.BIG_ENDIAN);
+         ValueLayout vInt = ValueLayout.JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN);
          //mimic pragma pack(1)
          GroupLayout g = MemoryLayout.structLayout(vChar.withBitAlignment(8).withName("a"),
                                 vShort.withBitAlignment(8).withName("b"),
                                 vInt.withBitAlignment(8).withName("c"));
          assertEquals(g.bitAlignment(), 8);
-         VarHandle vh_c = g.varHandle(byte.class, PathElement.groupElement("a"));
-         VarHandle vh_s = g.varHandle(short.class, PathElement.groupElement("b"));
-         VarHandle vh_i = g.varHandle(int.class, PathElement.groupElement("c"));
+         VarHandle vh_c = g.varHandle(PathElement.groupElement("a"));
+         VarHandle vh_s = g.varHandle(PathElement.groupElement("b"));
+         VarHandle vh_i = g.varHandle(PathElement.groupElement("c"));
          try (ResourceScope scope = ResourceScope.newConfinedScope()) {
              MemorySegment segment = MemorySegment.allocateNative(g, scope);
              vh_c.set(segment, Byte.MIN_VALUE);
              assertEquals(vh_c.get(segment), Byte.MIN_VALUE);
              vh_s.set(segment, Short.MIN_VALUE);
< prev index next >