src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.core.test/src/org/graalvm/compiler/core/test/ea/UnsafeEATest.java

*** 36,45 ****
--- 36,49 ----
      public static int zero = 0;
  
      private static final long fieldOffset1;
      private static final long fieldOffset2;
  
+     private static final long byteArrayBaseOffset;
+     private static final long intArrayBaseOffset;
+     private static final long longArrayBaseOffset;
+ 
      static {
          try {
              long localFieldOffset1 = UNSAFE.objectFieldOffset(TestClassInt.class.getField("x"));
              // Make the fields 8 byte aligned (Required for testing setLong on Architectures which
              // does not support unaligned memory access
*** 49,58 ****
--- 53,65 ----
              } else {
                  fieldOffset1 = UNSAFE.objectFieldOffset(TestClassInt.class.getField("y"));
                  fieldOffset2 = UNSAFE.objectFieldOffset(TestClassInt.class.getField("z"));
              }
              assert fieldOffset2 == fieldOffset1 + 4;
+             byteArrayBaseOffset = UNSAFE.arrayBaseOffset(byte[].class);
+             intArrayBaseOffset = UNSAFE.arrayBaseOffset(int[].class);
+             longArrayBaseOffset = UNSAFE.arrayBaseOffset(long[].class);
          } catch (Exception e) {
              throw new RuntimeException(e);
          }
      }
  
*** 193,198 ****
--- 200,278 ----
          } catch (RuntimeException e) {
              return x;
          }
          return x;
      }
+ 
+     public static int testWriteIntToByteArraySnippet() {
+         byte[] array = new byte[4];
+         UNSAFE.putInt(array, byteArrayBaseOffset, 0x01020304);
+         return array[0];
+     }
+ 
+     @Test
+     public void testWriteIntToByteArray() {
+         test("testWriteIntToByteArraySnippet");
+     }
+ 
+     public static byte testWriteSignedExtendedByteToByteArraySnippet(byte b) {
+         byte[] array = new byte[4];
+         array[0] = 0x01;
+         array[1] = 0x02;
+         array[2] = 0x03;
+         array[3] = 0x04;
+         UNSAFE.putInt(array, byteArrayBaseOffset, b);
+         return array[3];
+     }
+ 
+     @Test
+     public void testWriteSignedExtendedByteToByteArray() {
+         test("testWriteSignedExtendedByteToByteArraySnippet", (byte) 0);
+     }
+ 
+     public static int testWriteLongToIntArraySnippet() {
+         int[] array = new int[2];
+         UNSAFE.putLong(array, intArrayBaseOffset, 0x0102030405060708L);
+         return array[0];
+     }
+ 
+     @Test
+     public void testWriteLongToIntArray() {
+         test("testWriteLongToIntArraySnippet");
+     }
+ 
+     public static int testWriteByteToIntArraySnippet() {
+         int[] array = new int[1];
+         array[0] = 0x01020304;
+         UNSAFE.putByte(array, intArrayBaseOffset, (byte) 0x05);
+         return array[0];
+     }
+ 
+     @Test
+     public void testWriteByteToIntArray() {
+         test("testWriteByteToIntArraySnippet");
+     }
+ 
+     public static long testWriteIntToLongArraySnippet() {
+         long[] array = new long[1];
+         array[0] = 0x0102030405060708L;
+         UNSAFE.putInt(array, longArrayBaseOffset, 0x04030201);
+         return array[0];
+     }
+ 
+     @Test
+     public void testWriteIntToLongArray() {
+         test("testWriteIntToLongArraySnippet");
+     }
+ 
+     public static float testWriteFloatToIntArraySnippet() {
+         float[] array = new float[1];
+         UNSAFE.putInt(array, intArrayBaseOffset, Float.floatToRawIntBits(0.5f));
+         return array[0];
+     }
+ 
+     @Test
+     public void testWriteFloatToIntArray() {
+         test("testWriteFloatToIntArraySnippet");
+     }
+ 
  }