--- /dev/null	2019-12-04 18:44:18.020007537 +0000
+++ new/test/jdk/java/foreign/TestVarHandleCombinators.java	2019-12-09 18:16:00.092549992 +0000
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ * @run testng TestVarHandleCombinators
+ */
+
+import jdk.incubator.foreign.MemoryHandles;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemorySegment;
+
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+import static org.testng.Assert.assertEquals;
+
+public class TestVarHandleCombinators {
+
+    @Test
+    public void testElementAccess() {
+        VarHandle vh = MemoryHandles.varHandle(byte.class, ByteOrder.nativeOrder());
+        vh = MemoryHandles.withStride(vh, 1);
+
+        byte[] arr = { 0, 0, -1, 0 };
+        MemorySegment segment = MemorySegment.ofArray(arr);
+        MemoryAddress addr = segment.baseAddress();
+
+        assertEquals((byte) vh.get(addr, 2), (byte) -1);
+    }
+
+    @Test(expectedExceptions = IllegalArgumentException.class)
+    public void testUnalignedElement() {
+        VarHandle vh = MemoryHandles.varHandle(byte.class, 4, ByteOrder.nativeOrder());
+        MemoryHandles.withStride(vh, 2);
+    }
+
+    @Test(expectedExceptions = IllegalArgumentException.class)
+    public void testBadStrideElement() {
+        VarHandle vh = MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder());
+        MemoryHandles.withStride(vh, 0); //scale factor cant be zero
+    }
+
+    @Test(expectedExceptions = IllegalArgumentException.class)
+    public void testAlignNotPowerOf2() {
+        VarHandle vh = MemoryHandles.varHandle(byte.class, 3, ByteOrder.nativeOrder());
+    }
+
+    @Test(expectedExceptions = IllegalArgumentException.class)
+    public void testAlignNegative() {
+        VarHandle vh = MemoryHandles.varHandle(byte.class, -1, ByteOrder.nativeOrder());
+    }
+
+    @Test
+    public void testAlign() {
+        VarHandle vh = MemoryHandles.varHandle(byte.class, 2, ByteOrder.nativeOrder());
+
+        MemorySegment segment = MemorySegment.allocateNative(1, 2);
+        MemoryAddress address = segment.baseAddress();
+
+        vh.set(address, (byte) 10); // fine, memory region is aligned
+        assertEquals((byte) vh.get(address), (byte) 10);
+    }
+
+    @Test(expectedExceptions = IllegalArgumentException.class)
+    public void testAlignBadAccess() {
+        VarHandle vh = MemoryHandles.varHandle(byte.class, 2, ByteOrder.nativeOrder());
+        vh = MemoryHandles.withOffset(vh, 1); // offset by 1 byte
+
+        MemorySegment segment = MemorySegment.allocateNative(2, 2);
+        MemoryAddress address = segment.baseAddress();
+
+        vh.set(address, (byte) 10); // should be bad align
+    }
+
+    @Test(expectedExceptions = IllegalArgumentException.class)
+    public void testOffsetNegative() {
+        VarHandle vh = MemoryHandles.varHandle(byte.class, ByteOrder.nativeOrder());
+        MemoryHandles.withOffset(vh, -1);
+    }
+
+    @Test(expectedExceptions = IllegalArgumentException.class)
+    public void testUnalignedOffset() {
+        VarHandle vh = MemoryHandles.varHandle(byte.class, 4, ByteOrder.nativeOrder());
+        MemoryHandles.withOffset(vh, 2);
+    }
+
+    @Test
+    public void testOffset() {
+        VarHandle vh = MemoryHandles.varHandle(byte.class, ByteOrder.nativeOrder());
+        vh = MemoryHandles.withOffset(vh, 1);
+
+        MemorySegment segment = MemorySegment.ofArray(new byte[2]);
+        MemoryAddress address = segment.baseAddress();
+
+        vh.set(address, (byte) 10);
+        assertEquals((byte) vh.get(address), (byte) 10);
+    }
+
+    @Test
+    public void testByteOrderLE() {
+        VarHandle vh = MemoryHandles.varHandle(short.class, 2, ByteOrder.LITTLE_ENDIAN);
+        byte[] arr = new byte[2];
+        MemorySegment segment = MemorySegment.ofArray(arr);
+        MemoryAddress address = segment.baseAddress();
+
+        vh.set(address, (short) 0xFF);
+        assertEquals(arr[0], (byte) 0xFF);
+        assertEquals(arr[1], (byte) 0);
+    }
+
+    @Test
+    public void testByteOrderBE() {
+        VarHandle vh = MemoryHandles.varHandle(short.class, 2, ByteOrder.BIG_ENDIAN);
+        byte[] arr = new byte[2];
+        MemorySegment segment = MemorySegment.ofArray(arr);
+        MemoryAddress address = segment.baseAddress();
+
+        vh.set(address, (short) 0xFF);
+        assertEquals(arr[0], (byte) 0);
+        assertEquals(arr[1], (byte) 0xFF);
+    }
+
+    @Test
+    public void testNestedSequenceAccess() {
+        int outer_size = 10;
+        int inner_size = 5;
+
+        //[10 : [5 : [x32 i32]]]
+
+        VarHandle vh = MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder());
+        vh = MemoryHandles.withOffset(vh, 4);
+        VarHandle inner_vh = MemoryHandles.withStride(vh, 8);
+        VarHandle outer_vh = MemoryHandles.withStride(inner_vh, 5 * 8);
+        int count = 0;
+        try (MemorySegment segment = MemorySegment.allocateNative(inner_size * outer_size * 8)) {
+            for (long i = 0; i < outer_size; i++) {
+                for (long j = 0; j < inner_size; j++) {
+                    outer_vh.set(segment.baseAddress(), i, j, count);
+                    assertEquals(
+                            (int)inner_vh.get(segment.baseAddress().offset(i * inner_size * 8), j),
+                            count);
+                    count++;
+                }
+            }
+        }
+    }
+
+    @Test(dataProvider = "badCarriers", expectedExceptions = IllegalArgumentException.class)
+    public void testBadCarrier(Class<?> carrier) {
+        MemoryHandles.varHandle(carrier, ByteOrder.nativeOrder());
+    }
+
+    @DataProvider(name = "badCarriers")
+    public Object[][] createBadCarriers() {
+        return new Object[][] {
+                { void.class },
+                { boolean.class },
+                { Object.class },
+                { int[].class },
+                { MemoryAddress.class }
+        };
+    }
+
+}