Buffers float/double conversion: Add arg for given destination buffer; Add back conversion; Add unit test for arrays

1 files changed, 153 insertions, 0 deletions

diff --git a/src/junit/com/jogamp/common/nio/TestBuffersFloatDoubleConversion.java b/src/junit/com/jogamp/common/nio/TestBuffersFloatDoubleConversion.java
new file mode 100644
index 0000000..0555578
--- /dev/null
+++ b/src/junit/com/jogamp/common/nio/TestBuffersFloatDoubleConversion.java
@@ -0,0 +1,153 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions 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.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+ 
+package com.jogamp.common.nio;
+
+import java.io.IOException;
+import org.junit.Assert;
+
+import org.junit.Test;
+
+public class TestBuffersFloatDoubleConversion {
+
+    public static boolean cmpFloatArray(float[] d1, int d1_offset, float[] d2, int d2_offset, int len) {
+        if( d1.length - d1_offset < len) {
+            throw new RuntimeException("d1 too small len "+len+" > "+d1.length+" - "+d1_offset);
+        }
+        if( d2.length - d2_offset < len) {
+            throw new RuntimeException("d2 too small len "+len+" > "+d2.length+" - "+d2_offset);
+        }
+        boolean ok = true;
+        for(int i=0; ok && i<len; i++) {
+            ok = d1[d1_offset+i] == d2[d2_offset+i] ;
+        }
+        return ok;
+    }
+
+    public static boolean cmpDoubleArray(double[] d1, int d1_offset, double[] d2, int d2_offset, int len) {
+        if( d1.length - d1_offset < len) {
+            throw new RuntimeException("d1 too small len "+len+" > "+d1.length+" - "+d1_offset);
+        }
+        if( d2.length - d2_offset < len) {
+            throw new RuntimeException("d2 too small len "+len+" > "+d2.length+" - "+d2_offset);
+        }
+        boolean ok = true;
+        for(int i=0; ok && i<len; i++) {
+            ok = d1[d1_offset+i] == d2[d2_offset+i] ;
+        }
+        return ok;
+    }
+
+    public static void incrFloatArray(float[] data, int offset, int len) {
+        if( data.length - offset < len) {
+            throw new RuntimeException("data too small len "+len+" > "+data.length+" - "+offset);
+        }
+        for(int i=0; i<len; i++) {
+            data[offset+i] += 1;
+        }
+    }
+
+    public static void incrDoubleArray(double[] data, int offset, int len) {
+        if( data.length - offset < len) {
+            throw new RuntimeException("data too small len "+len+" > "+data.length+" - "+offset);
+        }
+        for(int i=0; i<len; i++) {
+            data[offset+i] += 1;
+        }
+    }
+
+    public static void setFloatArray(float[] data, int offset, int len) {
+        if( data.length - offset < len) {
+            throw new RuntimeException("data too small len "+len+" > "+data.length+" - "+offset);
+        }
+        for(int i=0; i<len; i++) {
+            data[offset+i] = i;
+        }
+    }
+
+    public static void setDoubleArray(double[] data, int offset, int len) {
+        if( data.length - offset < len) {
+            throw new RuntimeException("data too small len "+len+" > "+data.length+" - "+offset);
+        }
+        for(int i=0; i<len; i++) {
+            data[offset+i] = i;
+        }
+    }
+
+    public static void doItDoubleArray01(double[] data, int offset, int len) {
+        float[] f_data = Buffers.getFloatArray(data, offset, null, 0, len);
+        incrFloatArray(f_data, 0, len);
+        Buffers.getDoubleArray(f_data, 0, data, offset, len);
+    }
+
+    @Test
+    public void testDoubleArray2FloatArrayAndBack01() {
+        final int offset = 50;
+        final int len = 20;
+
+        // reference 1
+        float[] fa_ref = new float[100];
+        setFloatArray(fa_ref, offset, len);
+        incrFloatArray(fa_ref, offset, len);
+
+        // reference 2
+        double[] da_ref = new double[100];
+        setDoubleArray(da_ref, offset, len);
+        incrDoubleArray(da_ref, offset, len);
+
+        // test 1: forth and back .. double -> float -> double
+        {
+            double[] da1 = new double[100];
+            setDoubleArray(da1, offset, len);
+            incrDoubleArray(da1, offset, len);
+
+            // conv_forth: double[offset..len] -> float[0..len]
+            float[] f_da1 = Buffers.getFloatArray(da1, offset, null, 0, len);
+            Assert.assertTrue(cmpFloatArray(fa_ref, offset, f_da1, 0, len));
+
+            // conv_back: float[0..len] -> double[offset..len]
+            Buffers.getDoubleArray(f_da1, 0, da1, offset, len);
+            Assert.assertTrue(cmpDoubleArray(da_ref, offset, da1, offset, len));
+        }
+
+        // test 2: forth, incr, back .. double -> float -> incr -> double
+        {
+            double[] da1 = new double[100];
+            setDoubleArray(da1, offset, len);
+
+            doItDoubleArray01(da1, offset, len);
+            Assert.assertTrue(cmpDoubleArray(da_ref, offset, da1, offset, len));
+        }
+    }
+
+    public static void main(String args[]) throws IOException {
+        String tstname = TestBuffersFloatDoubleConversion.class.getName();
+        org.junit.runner.JUnitCore.main(tstname);
+    }
+
+}