Unittests for passing arrays to NFI.

Author: rschatz

truffle/src/com.oracle.truffle.nfi.test/src/com/oracle/truffle/nfi/test/ArrayNFITest.java

@@ -40,13 +40,12 @@
  */
 package com.oracle.truffle.nfi.test;
 
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.is;
-
 import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.Collection;
 
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -59,7 +58,7 @@
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.interop.InteropException;
-import com.oracle.truffle.api.interop.InteropLibrary;
+import com.oracle.truffle.nfi.api.SignatureLibrary;
 import com.oracle.truffle.nfi.backend.spi.types.NativeSimpleType;
 import com.oracle.truffle.tck.TruffleRunner;
 import com.oracle.truffle.tck.TruffleRunner.Inject;
@@ -93,29 +92,36 @@ public static Collection<Object[]> data() {
 
     public class CreateAndSumArray extends NFITestRootNode {
 
-        private final Class<?> finalJavaType;
-
         private final Object store;
+        private final Object storeSignature;
+
         private final Object sum;
+        private final Object sumSignature;
 
-        @Child InteropLibrary storeInterop;
-        @Child InteropLibrary sumInterop;
+        @Child SignatureLibrary storeSignatureLibrary;
+        @Child SignatureLibrary sumSignatureLibrary;
 
         public CreateAndSumArray() {
-            this.finalJavaType = javaType;
-            this.store = lookupAndBind("store_" + nativeType, String.format("([%s], uint32, %s) : void", nativeType, nativeType));
-            this.sum = lookupAndBind("sum_" + nativeType, String.format("([%s], uint32) : %s", nativeType, nativeType));
+            try {
+                this.store = UNCACHED_INTEROP.readMember(testLibrary, "store_" + nativeType);
+                this.storeSignature = parseSignature(String.format("([%s], uint32, %s) : void", nativeType, nativeType));
 
-            this.storeInterop = getInterop(this.store);
-            this.sumInterop = getInterop(this.sum);
+                this.sum = UNCACHED_INTEROP.readMember(testLibrary, "sum_" + nativeType);
+                this.sumSignature = parseSignature(String.format("([%s], uint32) : %s", nativeType, nativeType));
+
+                this.storeSignatureLibrary = SignatureLibrary.getFactory().create(this.storeSignature);
+                this.sumSignatureLibrary = SignatureLibrary.getFactory().create(this.sumSignature);
+            } catch (InteropException ex) {
+                throw new AssertionError(ex);
+            }
         }
 
         @TruffleBoundary
         private void verifyArray(Object array) {
             int length = Array.getLength(array);
             for (int i = 0; i < length; i++) {
                 Object elem = Array.get(array, i);
-                Assert.assertThat("array element", elem, is(instanceOf(finalJavaType)));
+                Assert.assertThat("array element", elem, is(instanceOf(javaType)));
                 long actual = 0;
                 long expected = i + 1;
                 if (elem instanceof Number) {
@@ -135,29 +141,40 @@ private void verifyArray(Object array) {
 
         @Override
         public Object executeTest(VirtualFrame frame) {
-            int arrayLength = (Integer) frame.getArguments()[0];
-
-            Object array = Array.newInstance(finalJavaType, arrayLength);
-            Object wrappedArray = runWithPolyglot.getTruffleTestEnv().asGuestValue(array);
+            Object array = frame.getArguments()[0];
+            Object wrappedArray = frame.getArguments()[1];
+            int arrayLength = Array.getLength(array);
 
             try {
                 for (int i = 0; i < arrayLength; i++) {
-                    storeInterop.execute(store, wrappedArray, i, i + 1);
+                    storeSignatureLibrary.call(storeSignature, store, wrappedArray, i, i + 1);
                 }
                 verifyArray(array);
-                return sumInterop.execute(sum, wrappedArray, arrayLength);
+                return sumSignatureLibrary.call(sumSignature, sum, wrappedArray, arrayLength);
             } catch (InteropException ex) {
                 CompilerDirectives.transferToInterpreter();
                 throw new AssertionError(ex);
             }
         }
     }
 
-    @Test
-    public void testSumArray(@Inject(CreateAndSumArray.class) CallTarget callTarget) {
-        int arrayLength = 5;
-        Object ret = callTarget.call(arrayLength);
+    private static void testSumArray(CallTarget callTarget, Object array, Object wrappedArray) {
+        int arrayLength = Array.getLength(array);
+        Object ret = callTarget.call(array, wrappedArray);
         Assert.assertThat("return value", ret, is(instanceOf(Number.class)));
         Assert.assertEquals("return value", arrayLength * (arrayLength + 1) / 2, ((Number) ret).intValue());
     }
+
+    @Test
+    public void testSumArrayDirect(@Inject(CreateAndSumArray.class) CallTarget callTarget) {
+        Object array = Array.newInstance(javaType, 5);
+        testSumArray(callTarget, array, array);
+    }
+
+    @Test
+    public void testSumArrayWrapped(@Inject(CreateAndSumArray.class) CallTarget callTarget) {
+        Object array = Array.newInstance(javaType, 5);
+        Object wrappedArray = runWithPolyglot.getTruffleTestEnv().asGuestValue(array);
+        testSumArray(callTarget, array, wrappedArray);
+    }
 }

truffle/src/com.oracle.truffle.nfi.test/src/com/oracle/truffle/nfi/test/NFITest.java

@@ -180,9 +180,13 @@ protected static Object lookupAndBindDefault(String name, String signature) {
         }
     }
 
-    protected static Object lookupAndBind(Object library, String name, String signature) {
+    protected static Object parseSignature(String signature) {
         Source sigSource = Source.newBuilder("nfi", signature, "signature").internal(true).build();
         CallTarget sigTarget = runWithPolyglot.getTruffleTestEnv().parseInternal(sigSource);
-        return lookupAndBind.call(library, name, sigTarget.call());
+        return sigTarget.call();
+    }
+
+    protected static Object lookupAndBind(Object library, String name, String signature) {
+        return lookupAndBind.call(library, name, parseSignature(signature));
     }
 }