http://www.jogamp.org/bugzilla/show_bug.cgi?id=389

Mixed types in generated code are functioning now,
even though not all permutations are generated - still.

However, this patch merges the indirect object passing,
wheather it is a primitive array or an indirect NIO buffer,
incl. PointerBuffer.

This allows the usage of only one JNI functions for all combinations.

Only in case of NIODirectOnly, the simplified direct only '0'
variation is created - otherwise the parametrized '1' variant.

The junit tests proves the implementation and
almost completes the gluegen junit tests coverage
for JavaEmitter and ProcAddressEmitter.

Impact/Result:
    - Working mixed array types
    - JOGL GL2 native library shrunk around 30%
    - Simplified gluegen code
    - Almost complete gluegen junit tests

TODO: Complete permutations of array/NIO arguments,
      if desired.

++++

Misc changes:

- NativeLibrary implements DynamicLookupHelper:
    lookupFunction() -> dynamicLookupFunction()

10 files changed, 680 insertions, 193 deletions

diff --git a/src/junit/com/jogamp/gluegen/test/junit/BaseTest1.java b/src/junit/com/jogamp/gluegen/test/junit/BaseTest1.java
new file mode 100644
index 0000000..457d96f
--- /dev/null
+++ b/src/junit/com/jogamp/gluegen/test/junit/BaseTest1.java
@@ -0,0 +1,250 @@
+/*
+ * Copyright (c) 2010 Sven Gothel. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name Sven Gothel or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SVEN GOTHEL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.gluegen.test.junit;
+
+import com.sun.gluegen.runtime.BufferFactory;
+import com.sun.gluegen.runtime.PointerBuffer;
+import java.nio.*;
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URISyntaxException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static java.lang.System.*;
+import static com.jogamp.gluegen.test.junit.BuildEnvironment.*;
+
+/**
+ * @author Michael Bien
+ * @author Sven Gothel
+ */
+public class BaseTest1 {
+
+    /**
+     * Verifies the existence and creation of the generated class.
+     */
+    public void testClassExist(String name) throws Exception {
+        String ifName = "com.jogamp.gluegen.test.junit.Binding"+name;
+        String implName = "com.jogamp.gluegen.test.junit.impl.Binding"+name+"Impl";
+
+        Class<?> clazzIf   = Class.forName(ifName);
+        Class<?> clazzImpl = Class.forName(implName);
+
+        Assert.assertNotNull(ifName+" does not exist", clazzIf);
+        Assert.assertNotNull(implName+" does not exist", clazzImpl);
+
+        Assert.assertEquals((int)1,  clazzIf.getDeclaredField("CONSTANT_ONE").get(null));
+
+        Object obj = clazzImpl.newInstance();
+        Assert.assertTrue("Not of type "+ifName, clazzIf.isAssignableFrom(obj.getClass()));
+        Assert.assertTrue("Not of type com.jogamp.gluegen.test.junit.BindingTest1", (obj instanceof com.jogamp.gluegen.test.junit.BindingTest1));
+    }
+
+    /**
+     * Verifies if all generated method signatures are completed,
+     * ie a compilation only coverage test without functional tests.
+     */
+    public void chapter__TestCoverageSignature(BindingTest1 binding) throws Exception {
+          int i;
+          long result;
+          long context = 0;
+          ByteBuffer bb=null;
+          PointerBuffer pb=null;
+          LongBuffer lb=null;
+          long[] larray = null;
+          int array_offset = 0;
+          String str=null;
+          String[] strings = null;
+          IntBuffer ib = null;
+          int[] iarray = null;
+          int iarray_offset = 0;
+
+          result = binding.arrayTest(context, pb);
+          result = binding.arrayTest(context, larray, array_offset);
+          result = binding.arrayTestNioOnly(context, pb);
+
+          result = binding.bufferTest(bb);
+          result = binding.bufferTestNioOnly(bb);
+
+          result = binding.doubleTest(context, bb, pb, bb, pb);
+          result = binding.doubleTest(context, bb, larray, array_offset, bb, larray, array_offset);
+          result = binding.doubleTestNioOnly(context, bb, pb, bb, pb);
+
+          result = binding.mixedTest(context, bb, pb);
+          result = binding.mixedTest(context, bb, larray, array_offset);
+          result = binding.mixedTestNioOnly(context, bb, pb);
+
+          result = binding.nopTest();
+
+          i = binding.strToInt(str);
+          str = binding.intToStr(i);
+
+          i = binding.stringArrayRead(strings, i);
+
+          i = binding.intArrayRead(ib, i);
+          i = binding.intArrayRead(iarray, iarray_offset, i);
+
+    }
+
+    /**
+     * Verifies if all methods / signatures are properly generated,
+     * can be invoked and functions.
+     * This is a compilation (coverage) and runtime time (semantic) test.
+     * This covers indirect primitive arrays and direct NIO buffers.
+     */
+    public void chapter03TestCoverageFunctionalityDirectNIOAndPrimitiveArray(BindingTest1 binding) throws Exception {
+          int i;
+          long result;
+
+          long context = 1;
+          ByteBuffer bb1 = BufferFactory.newDirectByteBuffer(BufferFactory.SIZEOF_LONG);
+          LongBuffer bb1L = bb1.asLongBuffer();
+          bb1L.put(0,  10);
+
+          ByteBuffer bb2 = BufferFactory.newDirectByteBuffer(BufferFactory.SIZEOF_LONG);
+          LongBuffer bb2L = bb2.asLongBuffer();
+          bb2L.put(0, 100);
+
+          PointerBuffer pb1 = PointerBuffer.allocateDirect(BindingTest1.ARRAY_SIZE);
+          for(i=0; i<BindingTest1.ARRAY_SIZE; i++) {
+            pb1.put(i,  1000);
+          }
+          PointerBuffer pb2 = PointerBuffer.allocateDirect(BindingTest1.ARRAY_SIZE);
+          for(i=0; i<BindingTest1.ARRAY_SIZE; i++) {
+            pb2.put(i, 10000);
+          }
+
+          long[] larray1 = new long[BindingTest1.ARRAY_SIZE];
+          int array1_offset = 0;
+          for(i=0; i<BindingTest1.ARRAY_SIZE; i++) {
+            larray1[i]=  1000;
+          }
+
+          long[] larray2 = new long[BindingTest1.ARRAY_SIZE];
+          int array2_offset = 0;
+          for(i=0; i<BindingTest1.ARRAY_SIZE; i++) {
+            larray2[i]= 10000;
+          }
+
+          result = binding.arrayTest(context, pb1);
+          Assert.assertTrue("Wrong result: "+result, 1+8000==result);
+
+          result = binding.arrayTest(context, larray1, array1_offset);
+          Assert.assertTrue("Wrong result: "+result, 1+8000==result);
+
+          result = binding.arrayTestNioOnly(context, pb1);
+          Assert.assertTrue("Wrong result: "+result, 1+8000==result);
+
+          result = binding.bufferTest(bb1);
+          Assert.assertTrue("Wrong result: "+result, 10==result);
+
+          result = binding.bufferTestNioOnly(bb1);
+          Assert.assertTrue("Wrong result: "+result, 10==result);
+
+          result = binding.doubleTest(context, bb1, pb1, bb2, pb2);
+          Assert.assertTrue("Wrong result: "+result, 1+10+8000+100+80000==result);
+
+          result = binding.doubleTest(context, bb1, larray1, array1_offset, bb2, larray2, array2_offset);
+          Assert.assertTrue("Wrong result: "+result, 1+10+8000+100+80000==result);
+
+          result = binding.doubleTestNioOnly(context, bb1, pb1, bb2, pb2);
+          Assert.assertTrue("Wrong result: "+result, 1+10+8000+100+80000==result);
+
+          result = binding.mixedTest(context, bb1, pb1);
+          Assert.assertTrue("Wrong result: "+result, 1+10+8000==result);
+
+          result = binding.mixedTest(context, bb1, larray1, array1_offset);
+          Assert.assertTrue("Wrong result: "+result, 1+10+8000==result);
+
+          result = binding.mixedTestNioOnly(context, bb1, pb1);
+          Assert.assertTrue("Wrong result: "+result, 1+10+8000==result);
+
+          result = binding.nopTest();
+          Assert.assertTrue("Wrong result: "+result, 42==result);
+
+          i = binding.strToInt("42");
+          Assert.assertTrue("Wrong result: "+i, 42==i);
+
+          String str = binding.intToStr(42);
+          Assert.assertTrue("Wrong result: "+str, str.equals("42"));
+
+          i = binding.stringArrayRead(new String[] { "1234", "5678", "9a" }, 3);
+          Assert.assertTrue("Wrong result: "+i, 10==i);
+
+          ByteBuffer bb3 = BufferFactory.newDirectByteBuffer(BufferFactory.SIZEOF_INT * 3);
+          IntBuffer ib = bb3.asIntBuffer();
+          ib.put(0, 1);
+          ib.put(1, 2);
+          ib.put(2, 3);
+
+          int[] iarray = new int[] { 1, 2, 3 };
+          int iarray_offset = 0;
+
+          i = binding.intArrayRead(ib, 3);
+          Assert.assertTrue("Wrong result: "+i, 6==i);
+
+          i = binding.intArrayRead(iarray, 0, 3);
+          Assert.assertTrue("Wrong result: "+i, 6==i);
+    }
+
+    /**
+     * This covers indirect primitive arrays and indirect NIO buffers.
+     */
+    public void chapter04TestSomeFunctionsAllIndirect(BindingTest1 binding) throws Exception {
+          int i;
+          long result;
+
+          IntBuffer ib = IntBuffer.allocate(3);
+          ib.put(0, 1);
+          ib.put(1, 2);
+          ib.put(2, 3);
+
+          int[] iarray = new int[] { 1, 2, 3 };
+          int iarray_offset = 0;
+
+          i = binding.intArrayRead(ib, 3);
+          Assert.assertTrue("Wrong result: "+i, 6==i);
+
+          i = binding.intArrayRead(iarray, 0, 3);
+          Assert.assertTrue("Wrong result: "+i, 6==i);
+    }
+
+}
diff --git a/src/junit/com/jogamp/gluegen/test/junit/Test1.java b/src/junit/com/jogamp/gluegen/test/junit/Test1.java
deleted file mode 100644
index 03fbaee..0000000
--- a/src/junit/com/jogamp/gluegen/test/junit/Test1.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- * Copyright (c) 2010 Sven Gothel. All Rights Reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- * - Redistribution of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * 
- * - Redistribution in binary form must reproduce the above copyright
- *   notice, this list of conditions and the following disclaimer in the
- *   documentation and/or other materials provided with the distribution.
- * 
- * Neither the name Sven Gothel or the names of
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- * 
- * This software is provided "AS IS," without a warranty of any kind. ALL
- * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
- * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
- * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
- * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
- * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
- * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
- * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
- * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
- * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
- * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
- * SVEN GOTHEL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- */
-
-package com.jogamp.gluegen.test.junit;
-
-import com.jogamp.gluegen.test.junit.impl.BindingTest1Impl;
-
-import com.sun.gluegen.runtime.BufferFactory;
-import com.sun.gluegen.runtime.PointerBuffer;
-import java.nio.*;
-import java.io.File;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.net.URISyntaxException;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import static java.lang.System.*;
-import static com.jogamp.gluegen.test.junit.BuildEnvironment.*;
-
-/**
- * @author Michael Bien
- * @author Sven Gothel
- */
-public class Test1 {
-
-    /**
-     * Verifies loading of the new library.
-     */
-    @Test
-    public void chapter01TestLoadLibrary() throws Exception {
-        String nativesPath = testOutput + "/build/natives";
-        System.load(nativesPath + "/libtest1.so");
-    }
-
-    /**
-     * Verifies the existence and creation of the generated class.
-     */
-    @Test
-    public void chapter01TestClassExist() throws Exception {
-        Class<?> clazzIf   = Class.forName("com.jogamp.gluegen.test.junit.BindingTest1");
-        Class<?> clazzImpl = Class.forName("com.jogamp.gluegen.test.junit.impl.BindingTest1Impl");
-
-        Assert.assertNotNull("com.jogamp.gluegen.test.junit.BindingTest1 does not exist", clazzIf);
-        Assert.assertNotNull("com.jogamp.gluegen.test.junit.impl.BindingTest1Impl does not exist", clazzImpl);
-
-        Assert.assertEquals((int)1,  clazzIf.getDeclaredField("CONSTANT_ONE").get(null));
-
-        Object obj = clazzImpl.newInstance();
-        Assert.assertTrue("Not of type com.jogamp.gluegen.test.junit.BindingTest1", (obj instanceof com.jogamp.gluegen.test.junit.BindingTest1));
-
-        BindingTest1 bindingTest1 = (BindingTest1) obj;
-        Assert.assertTrue("nopTest1 failed", 42==bindingTest1.nopTest());
-    }
-
-    /**
-     * Verifies if all methods / signatures are properly generated,
-     * and can be invoked.
-     * Gluegen Coverage test.
-     * This is a compilation and runtime time test.
-     */
-    @Test
-    public void chapter01TestCoverage() throws Exception {
-          int dummy;
-
-          int array_size = 10;
-          long context = 0;
-          ByteBuffer bb1 = BufferFactory.newDirectByteBuffer(PointerBuffer.elementSize() * array_size);
-          ByteBuffer bb2 = BufferFactory.newDirectByteBuffer(PointerBuffer.elementSize() * array_size);
-
-          PointerBuffer pb1 = PointerBuffer.allocateDirect(array_size);
-          PointerBuffer pb2 = PointerBuffer.allocateDirect(array_size);
-
-          long[] larray1 = new long[array_size];
-          int array1_offset = 0;
-
-          long[] larray2 = new long[array_size];
-          int array2_offset = 0;
-
-          BindingTest1 binding = new BindingTest1Impl();
-
-          /** Interface to C language function: <br> <code> int arrayTest(long context, foo *  array); </code>    */
-          dummy = binding.arrayTest(context, pb1);
-          Assert.assertTrue(42==dummy);
-
-          /** Interface to C language function: <br> <code> int arrayTest(long context, foo *  array); </code>    */
-          dummy = binding.arrayTest(context, larray1, array1_offset);
-          Assert.assertTrue(42==dummy);
-
-          /** Interface to C language function: <br> <code> int bufferTest(void *  object); </code>    */
-          dummy = binding.bufferTest(bb1);
-          Assert.assertTrue(42==dummy);
-
-          /** Interface to C language function: <br> <code> int doubleTest(long context, void *  object1, foo *  array1, void *  object2, foo *  array2); </code>    */
-          dummy = binding.doubleTest(context, bb1, pb1, bb2, pb2);
-          Assert.assertTrue(42==dummy);
-
-          /** Interface to C language function: <br> <code> int doubleTest(long context, void *  object1, foo *  array1, void *  object2, foo *  array2); </code>    */
-          dummy = binding.doubleTest(context, bb1, larray1, array1_offset, bb2, larray2, array2_offset);
-          Assert.assertTrue(42==dummy);
-
-          /** Interface to C language function: <br> <code> int mixedTest(long context, void *  object, foo *  array); </code>    */
-          dummy = binding.mixedTest(context, bb1, pb1);
-          Assert.assertTrue(42==dummy);
-
-          /** Interface to C language function: <br> <code> int mixedTest(long context, void *  object, foo *  array); </code>    */
-          dummy = binding.mixedTest(context, bb1, larray1, array1_offset);
-          Assert.assertTrue(42==dummy);
-
-          /** Interface to C language function: <br> <code> int nopTest(); </code>    */
-          dummy = binding.nopTest();
-          Assert.assertTrue(42==dummy);
-    }
-
-}
diff --git a/src/junit/com/jogamp/gluegen/test/junit/Test1p1JavaEmitter.java b/src/junit/com/jogamp/gluegen/test/junit/Test1p1JavaEmitter.java
new file mode 100644
index 0000000..1edb70e
--- /dev/null
+++ b/src/junit/com/jogamp/gluegen/test/junit/Test1p1JavaEmitter.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2010 Sven Gothel. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name Sven Gothel or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SVEN GOTHEL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.gluegen.test.junit;
+
+import com.jogamp.gluegen.test.junit.impl.BindingTest1p1Impl;
+
+import com.sun.gluegen.runtime.BufferFactory;
+import com.sun.gluegen.runtime.PointerBuffer;
+import java.nio.*;
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URISyntaxException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static java.lang.System.*;
+import static com.jogamp.gluegen.test.junit.BuildEnvironment.*;
+
+/**
+ * @author Michael Bien
+ * @author Sven Gothel
+ */
+public class Test1p1JavaEmitter extends BaseTest1 {
+
+    /**
+     * Verifies loading of the new library.
+     */
+    @Test
+    public void chapter01TestLoadLibrary() throws Exception {
+        String nativesPath = testOutput + "/build/natives";
+        System.load(nativesPath + "/libtest1p1.so");
+    }
+
+    /**
+     * Verifies the existence and creation of the generated class.
+     */
+    @Test
+    public void chapter02TestClassExist() throws Exception {
+        testClassExist("Test1p1");
+    }
+
+    /**
+     * Verifies if all generated method signatures are completed,
+     * ie a compilation only coverage test without functional tests.
+     */
+    public void chapter__TestCoverageSignature() throws Exception {
+        chapter__TestCoverageSignature(new BindingTest1p1Impl());
+    }
+
+    /**
+     * Verifies if all methods / signatures are properly generated,
+     * can be invoked and functions.
+     * This is a compilation (coverage) and runtime time (semantic) test.
+     * This covers indirect primitive arrays and direct NIO buffers.
+     */
+    @Test
+    public void chapter03TestCoverageFunctionalityDirectNIOAndPrimitiveArray() throws Exception {
+        chapter03TestCoverageFunctionalityDirectNIOAndPrimitiveArray(new BindingTest1p1Impl());
+    }
+
+    /**
+     * This covers indirect primitive arrays and indirect NIO buffers.
+     */
+    @Test
+    public void chapter04TestSomeFunctionsAllIndirect() throws Exception {
+        chapter04TestSomeFunctionsAllIndirect(new BindingTest1p1Impl());
+    }
+
+}
diff --git a/src/junit/com/jogamp/gluegen/test/junit/Test1p2ProcAddressEmitter.java b/src/junit/com/jogamp/gluegen/test/junit/Test1p2ProcAddressEmitter.java
new file mode 100644
index 0000000..63d41f3
--- /dev/null
+++ b/src/junit/com/jogamp/gluegen/test/junit/Test1p2ProcAddressEmitter.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2010 Sven Gothel. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name Sven Gothel or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SVEN GOTHEL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.gluegen.test.junit;
+
+import com.jogamp.gluegen.test.junit.impl.BindingTest1p2Impl;
+
+import com.sun.gluegen.runtime.BufferFactory;
+import com.sun.gluegen.runtime.PointerBuffer;
+import com.sun.gluegen.runtime.NativeLibrary;
+import com.sun.gluegen.runtime.DynamicLookupHelper;
+import java.nio.*;
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URISyntaxException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static java.lang.System.*;
+import static com.jogamp.gluegen.test.junit.BuildEnvironment.*;
+
+/**
+ * @author Michael Bien
+ * @author Sven Gothel
+ */
+public class Test1p2ProcAddressEmitter extends BaseTest1 {
+
+    DynamicLookupHelper dynamicLookupHelper;
+
+    /**
+     * Verifies loading of the new library.
+     */
+    @Test
+    public void chapter01TestLoadLibrary() throws Exception {
+        System.loadLibrary("test1p2");
+        dynamicLookupHelper = NativeLibrary.open("test1p2", getClass().getClassLoader(), true);
+        Assert.assertNotNull("NativeLibrary.open(test1p2) failed", dynamicLookupHelper);
+
+        BindingTest1p2Impl.resetProcAddressTable(dynamicLookupHelper);
+    }
+
+    /**
+     * Verifies the existence and creation of the generated class.
+     */
+    @Test
+    public void chapter02TestClassExist() throws Exception {
+        testClassExist("Test1p2");
+    }
+
+    /**
+     * Verifies if all generated method signatures are completed,
+     * ie a compilation only coverage test without functional tests.
+     */
+    public void chapter__TestCoverageSignature() throws Exception {
+        chapter__TestCoverageSignature(new BindingTest1p2Impl());
+    }
+
+    /**
+     * Verifies if all methods / signatures are properly generated,
+     * can be invoked and functions.
+     * This is a compilation (coverage) and runtime time (semantic) test.
+     * This covers indirect primitive arrays and direct NIO buffers.
+     */
+    @Test
+    public void chapter03TestCoverageFunctionalityDirectNIOAndPrimitiveArray() throws Exception {
+        chapter03TestCoverageFunctionalityDirectNIOAndPrimitiveArray(new BindingTest1p2Impl());
+    }
+
+    /**
+     * This covers indirect primitive arrays and indirect NIO buffers.
+     */
+    @Test
+    public void chapter04TestSomeFunctionsAllIndirect() throws Exception {
+        chapter04TestSomeFunctionsAllIndirect(new BindingTest1p2Impl());
+    }
+
+    public static void main(String[] args) {
+        Test1p2ProcAddressEmitter test = new Test1p2ProcAddressEmitter();
+        try {
+            test.chapter01TestLoadLibrary();
+            test.chapter02TestClassExist();
+            test.chapter03TestCoverageFunctionalityDirectNIOAndPrimitiveArray();
+            test.chapter04TestSomeFunctionsAllIndirect();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}
diff --git a/src/junit/com/jogamp/gluegen/test/junit/test1-common.cfg b/src/junit/com/jogamp/gluegen/test/junit/test1-common.cfg
new file mode 100644
index 0000000..d775424
--- /dev/null
+++ b/src/junit/com/jogamp/gluegen/test/junit/test1-common.cfg
@@ -0,0 +1,18 @@
+
+NIODirectOnly arrayTestNioOnly
+NIODirectOnly bufferTestNioOnly
+NIODirectOnly mixedTestNioOnly
+NIODirectOnly doubleTestNioOnly
+
+ReturnsString intToStr
+ArgumentIsString strToInt 0
+ArgumentIsString stringArrayRead 0
+
+CustomCCode #include "test1.h"
+
+# Imports needed by all glue code
+Import java.nio.*
+Import java.util.*
+
+
+
diff --git a/src/junit/com/jogamp/gluegen/test/junit/test1-gluegen.cfg b/src/junit/com/jogamp/gluegen/test/junit/test1-gluegen.cfg
index 291e6cc..9d0f856 100644
--- a/src/junit/com/jogamp/gluegen/test/junit/test1-gluegen.cfg
+++ b/src/junit/com/jogamp/gluegen/test/junit/test1-gluegen.cfg
@@ -1,35 +1,9 @@
 Package com.jogamp.gluegen.test.junit
 JavaClass BindingTest1
-Style InterfaceAndImpl
+Style InterfaceOnly
 JavaOutputDir classes
-NativeOutputDir native
 
-# Use a ProcAddressTable so we dynamically look up the routines
-#ProcAddressNameExpr PFN $UPPERCASE({0}) PROC
-#EmitProcAddressTable true
-#ProcAddressTableClassName BindingTest1ProcAddressTable
-#GetProcAddressTableExpr _table
+Include test1-common.cfg
 
-# Force all of the methods to be emitted using dynamic linking so we
-# don't need to link against any emulation library on the desktop or
-# depend on the presence of an import library for a particular device
-#ForceProcAddressGen __ALL__
-
-# Also force the calling conventions of the locally generated function
-# pointer typedefs for these routines to MYAPIENTRY
-#LocalProcAddressCallingConvention __ALL__ MYAPIENTRY
-
-#EmitProcAddressTable true
-#ProcAddressTableClassName CLProcAddressTable
-#GetProcAddressTableExpr addressTable
-#ProcAddressNameExpr $UpperCase(arg)
-#ForceProcAddressGen clGetGLContextInfoKHR
-
-CustomCCode #include "test1.h"
-
-# Imports needed by all glue code
-Import java.nio.*
-Import java.util.*
-Import com.jogamp.gluegen.test.junit.BindingTest1
 
 
diff --git a/src/junit/com/jogamp/gluegen/test/junit/test1.c b/src/junit/com/jogamp/gluegen/test/junit/test1.c
index 6b63f90..31c5f40 100644
--- a/src/junit/com/jogamp/gluegen/test/junit/test1.c
+++ b/src/junit/com/jogamp/gluegen/test/junit/test1.c
@@ -1,21 +1,101 @@
 #include "test1.h"
+#include <assert.h>
+#include <stdlib.h>
 
-int nopTest() {
+foo nopTest() {
     return 42;
 }
 
-int arrayTest(long context, foo * array) {
-    return 42;
+foo arrayTest(long context, foo * array) {
+    foo r=0;
+    int i;
+    assert(NULL!=array);
+    // printf("array test - %p\n", array);
+    for(i=0; i<ARRAY_SIZE; i++) {
+        r+=array[i];
+    }
+    return r+context;
 }
 
-int bufferTest(void * object) {
-    return 42;
+foo bufferTest(void * object) {
+    assert(NULL!=object);
+    return *((foo *)object);
 }
 
-int mixedTest(long context, void * object, foo * array){
-    return 42;
+foo mixedTest(long context, void * object, foo * array){
+    assert(NULL!=object);
+    assert(NULL!=array);
+    return arrayTest(context, array) + bufferTest(object);
 }
 
-int doubleTest(long context, void * object1, foo * array1, void * object2, foo * array2) {
-    return 42;
+foo doubleTest(long context, void * object1, foo * array1, void * object2, foo * array2) {
+    assert(NULL!=object1);
+    assert(NULL!=array1);
+    assert(NULL!=object2);
+    assert(NULL!=array2);
+    return arrayTest(context, array1) + 
+           arrayTest(      0, array2) + 
+           bufferTest(object1) +
+           bufferTest(object2);
+}
+
+foo arrayTestNioOnly(long context, foo * array ) {
+    return arrayTest(context, array);
+}
+
+foo bufferTestNioOnly(void * object) {
+    return bufferTest(object);
+}
+
+foo mixedTestNioOnly(long context, void * object, foo * array ) {
+    return mixedTest(context, object, array);
+}
+
+foo doubleTestNioOnly(long context, void * object1, foo * array1, void * object2, foo * array2 ) {
+    return doubleTest(context, object1, array1, object2, array2);
+}
+
+int strToInt(const char * str) {
+    return atoi(str);
 }
+
+const char * intToStr(int i) {
+    static char singleton[200];
+    snprintf(singleton, sizeof(singleton)-1, "%d", i);
+    return singleton;
+}
+
+int stringArrayRead(const char *  *  strings, int num) {
+    int i=0, l=0;
+    if(NULL!=strings) {
+        for(i=0; i<num; i++) {
+            if(NULL!=strings[i]) {
+                l+=strlen(strings[i]);
+            }
+        }
+    }
+    return l;
+}
+
+int intArrayRead(const int *  ints, int num) {
+    int i=0, s=0;
+    if(NULL!=ints) {
+        for(i=0; i<num; i++) {
+            s+=ints[i];
+        }
+    }
+    return s;
+}
+
+/**
+int intArrayWrite(int * *  ints, int num) {
+    int i=0, s=0;
+    if(NULL!=ints) {
+        for(i=0; i<num; i++) {
+            *(ints[i]) = *(ints[i]) + 1;
+            s+=*(ints[i]);
+        }
+    }
+    return s;
+} */
+
diff --git a/src/junit/com/jogamp/gluegen/test/junit/test1.h b/src/junit/com/jogamp/gluegen/test/junit/test1.h
index 776bc0a..38b4911 100644
--- a/src/junit/com/jogamp/gluegen/test/junit/test1.h
+++ b/src/junit/com/jogamp/gluegen/test/junit/test1.h
@@ -9,16 +9,49 @@
 #define MYAPI
 
 #define CONSTANT_ONE 1
+#define ARRAY_SIZE 8
 
 typedef unsigned long foo;
 
-MYAPI int MYAPIENTRY nopTest();
+/** Returns 42 */
+MYAPI foo MYAPIENTRY nopTest();
 
-MYAPI int MYAPIENTRY arrayTest(long context, foo * array );
+/** Returns Sum(array) + context */
+MYAPI foo MYAPIENTRY arrayTest(long context, foo * array );
 
-MYAPI int MYAPIENTRY bufferTest(void * object);
+/** Returns *((foo *)object) */
+MYAPI foo MYAPIENTRY bufferTest(void * object);
 
-MYAPI int MYAPIENTRY mixedTest(long context, void * object, foo * array );
+/** Returns Sum(array) + context + *((foo *)object) */
+MYAPI foo MYAPIENTRY mixedTest(long context, void * object, foo * array );
 
-MYAPI int MYAPIENTRY doubleTest(long context, void * object1, foo * array1, void * object2, foo * array2 );
+/** Returns Sum(array1) + Sum(array2) + context + *((foo *)object1) + *((foo *)object2) */
+MYAPI foo MYAPIENTRY doubleTest(long context, void * object1, foo * array1, void * object2, foo * array2 );
+
+/** Returns Sum(array) + context */
+MYAPI foo MYAPIENTRY arrayTestNioOnly(long context, foo * array );
+
+/** Returns *((foo *)object) */
+MYAPI foo MYAPIENTRY bufferTestNioOnly(void * object);
+
+/** Returns Sum(array) + context + *((foo *)object) */
+MYAPI foo MYAPIENTRY mixedTestNioOnly(long context, void * object, foo * array );
+
+/** Returns Sum(array1) + Sum(array2) + context + *((foo *)object1) + *((foo *)object2) */
+MYAPI foo MYAPIENTRY doubleTestNioOnly(long context, void * object1, foo * array1, void * object2, foo * array2 );
+
+/** Returns atoi(str) */
+MYAPI int MYAPIENTRY strToInt(const char* str);
+
+/** Returns itoa(i) - not thread safe */
+MYAPI const char * MYAPIENTRY intToStr(int i);
+
+/** Returns the length of all strings */
+MYAPI int MYAPIENTRY stringArrayRead(const char *  *  strings, int num);
+
+/** Returns the sum of all integers */
+MYAPI int MYAPIENTRY intArrayRead(const int *  ints, int num);
+
+/** Increases the elements by 1, and returns the sum 
+MYAPI int MYAPIENTRY intArrayWrite(int *  *  ints, int num); */
 
diff --git a/src/junit/com/jogamp/gluegen/test/junit/test1p1-gluegen.cfg b/src/junit/com/jogamp/gluegen/test/junit/test1p1-gluegen.cfg
new file mode 100644
index 0000000..78e4d8a
--- /dev/null
+++ b/src/junit/com/jogamp/gluegen/test/junit/test1p1-gluegen.cfg
@@ -0,0 +1,14 @@
+Package com.jogamp.gluegen.test.junit
+JavaClass BindingTest1p1
+Style InterfaceAndImpl
+JavaOutputDir classes
+NativeOutputDir native
+
+Extends BindingTest1p1 BindingTest1
+
+Include test1-common.cfg
+
+Import com.jogamp.gluegen.test.junit.BindingTest1
+Import com.jogamp.gluegen.test.junit.BindingTest1p1
+
+
diff --git a/src/junit/com/jogamp/gluegen/test/junit/test1p2-gluegen.cfg b/src/junit/com/jogamp/gluegen/test/junit/test1p2-gluegen.cfg
new file mode 100644
index 0000000..c0a63b4
--- /dev/null
+++ b/src/junit/com/jogamp/gluegen/test/junit/test1p2-gluegen.cfg
@@ -0,0 +1,36 @@
+Package com.jogamp.gluegen.test.junit
+JavaClass BindingTest1p2
+Style InterfaceAndImpl
+JavaOutputDir classes
+NativeOutputDir native
+
+Extends BindingTest1p2 BindingTest1
+
+# Use a ProcAddressTable so we dynamically look up the routines
+EmitProcAddressTable true
+ProcAddressTableClassName BindingTest1p2ProcAddressTable
+GetProcAddressTableExpr _table
+ProcAddressNameExpr PFN $UPPERCASE({0}) PROC
+
+# Force all of the methods to be emitted using dynamic linking so we
+# don't need to link against any emulation library on the desktop or
+# depend on the presence of an import library for a particular device
+ForceProcAddressGen __ALL__
+
+# Also force the calling conventions of the locally generated function
+# pointer typedefs for these routines to MYAPIENTRY
+LocalProcAddressCallingConvention __ALL__ MYAPIENTRY
+
+Include test1-common.cfg
+Include ../../../../../../../make/config/intptr.cfg
+
+Import com.jogamp.gluegen.test.junit.BindingTest1
+Import com.jogamp.gluegen.test.junit.BindingTest1p2
+Import com.sun.gluegen.runtime.*
+
+CustomJavaCode BindingTest1p2Impl  private static BindingTest1p2ProcAddressTable _table = new BindingTest1p2ProcAddressTable();
+CustomJavaCode BindingTest1p2Impl  public static void resetProcAddressTable(DynamicLookupHelper lookup) {
+CustomJavaCode BindingTest1p2Impl      ProcAddressHelper.resetProcAddressTable(_table, lookup);
+CustomJavaCode BindingTest1p2Impl  }
+
+