diff options
| -rw-r--r-- | make/build.xml | 57 | ||||
| -rwxr-xr-x | make/scripts/runtest.sh | 4 | ||||
| -rw-r--r-- | src/java/com/jogamp/common/util/FloatStack.java | 157 | ||||
| -rw-r--r-- | src/java/com/jogamp/common/util/PrimitiveStack.java | 72 | ||||
| -rw-r--r-- | src/junit/com/jogamp/common/util/TestFloatStack01.java | 266 |
5 files changed, 551 insertions, 5 deletions
diff --git a/make/build.xml b/make/build.xml index d4ec1b7..76187a1 100644 --- a/make/build.xml +++ b/make/build.xml @@ -602,14 +602,62 @@ </copy> </target> + <target name="generate-primitive-stacks"> + + <!-- IntegerStack --> + <antcall target="create-pstack" inheritrefs="true"> + <param name="pstack.name" value="IntegerStack"/> + <param name="pstack.testname" value="TestIntegerStack01"/> + <param name="pstack.value" value="int"/> + <param name="pstack.value2" value="IntBuffer"/> + </antcall> + + </target> + + <target name="create-pstack"> + <copy file="${src.java}/com/jogamp/common/util/FloatStack.java" + tofile="${src.generated.java}/com/jogamp/common/util/${pstack.name}.java" overwrite="true"> + <filterchain> + <replaceregex pattern="FloatStack" replace="${pstack.name}"/> + <replaceregex pattern="@see ${pstack.name}" replace="@see FloatStack"/> + <replaceregex pattern="/\*value\*/float/\*value\*/" replace="${pstack.value}"/> + <replaceregex pattern="/\*value2\*/FloatBuffer/\*value2\*/" replace="${pstack.value2}"/> + </filterchain> + </copy> + <mkdir dir="${gluegen.root}/${rootrel.build}/test/build/gensrc/classes"/> + <copy file="${gluegen.root}/src/junit/com/jogamp/common/util/TestFloatStack01.java" + tofile="${gluegen.root}/${rootrel.build}/test/build/gensrc/classes/com/jogamp/common/util/${pstack.testname}.java" overwrite="true"> + <filterchain> + <replaceregex pattern="FloatStack" replace="${pstack.name}"/> + <replaceregex pattern="TestFloatStack01" replace="${pstack.testname}"/> + <replaceregex pattern="@see ${pstack.name}" replace="@see FloatStack"/> + <replaceregex pattern="/\*value\*/float/\*value\*/" replace="${pstack.value}"/> + <replaceregex pattern="/\*value2\*/FloatBuffer/\*value2\*/" replace="${pstack.value2}"/> + </filterchain> + </copy> + </target> + <target name="gluegen.build.check.java" depends="init"> - <uptodate property="gluegen.build.skip.java"> + <uptodate property="gluegen.build.skip.java1"> <srcfiles dir= "." includes="*.xml"/> <srcfiles dir= "${src.java}" includes="**"/> <srcfiles dir= "${c.grammar}" includes="**/*.g"/> <srcfiles dir= "${j.grammar}" includes="**/*.g"/> <mapper type="merge" to="${build}/gluegen.jar"/> </uptodate> + <uptodate property="gluegen.build.skip.java2"> + <srcfiles dir= "." includes="*.xml"/> + <srcfiles dir= "${src.java}" includes="**"/> + <srcfiles dir= "${c.grammar}" includes="**/*.g"/> + <srcfiles dir= "${j.grammar}" includes="**/*.g"/> + <mapper type="merge" to="${build}/gluegen-rt.jar"/> + </uptodate> + <condition property="gluegen.build.skip.java" value="true"> + <or> + <isset property="gluegen.build.skip.java1"/> + <isset property="gluegen.build.skip.java2"/> + </or> + </condition> </target> <target name="gluegen.build.javase"> @@ -803,9 +851,10 @@ </target> <target name="gluegen.build.java" depends="gluegen.cpptasks.detect.os,gluegen.build.check.java" unless="gluegen.build.skip.java"> - <antcall target="generate-hash-maps" inheritRefs="true"/> - <antcall target="gluegen.build.javase" inheritRefs="true"/> - <antcall target="gluegen.build.android" inheritRefs="true"/> + <antcall target="generate-hash-maps" inheritRefs="true"/> + <antcall target="generate-primitive-stacks" inheritRefs="true"/> + <antcall target="gluegen.build.javase" inheritRefs="true"/> + <antcall target="gluegen.build.android" inheritRefs="true"/> </target> <target name="gluegen.build.check.android-launcher" depends="init"> diff --git a/make/scripts/runtest.sh b/make/scripts/runtest.sh index 8cdf352..e7051e4 100755 --- a/make/scripts/runtest.sh +++ b/make/scripts/runtest.sh @@ -70,13 +70,15 @@ function onetest() { #onetest com.jogamp.common.GlueGenVersion 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.TestSystemPropsAndEnvs 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.TestVersionInfo 2>&1 | tee -a $LOG -onetest com.jogamp.common.util.TestVersionNumber 2>&1 | tee -a $LOG +#onetest com.jogamp.common.util.TestVersionNumber 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.TestIteratorIndexCORE 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.locks.TestRecursiveLock01 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.locks.TestRecursiveThreadGroupLock01 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.locks.TestSingletonServerSocket00 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.locks.TestSingletonServerSocket01 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.locks.TestSingletonServerSocket02 2>&1 | tee -a $LOG +onetest com.jogamp.common.util.TestFloatStack01 2>&1 | tee -a $LOG +onetest com.jogamp.common.util.TestIntegerStack01 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.TestArrayHashSet01 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.IntIntHashMapTest 2>&1 | tee -a $LOG #onetest com.jogamp.common.util.IntObjectHashMapTest 2>&1 | tee -a $LOG diff --git a/src/java/com/jogamp/common/util/FloatStack.java b/src/java/com/jogamp/common/util/FloatStack.java new file mode 100644 index 0000000..e5790a9 --- /dev/null +++ b/src/java/com/jogamp/common/util/FloatStack.java @@ -0,0 +1,157 @@ +/** + * Copyright 2012 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.util; + +import java.nio.BufferOverflowException; +import java.nio.BufferUnderflowException; +import java.nio./*value2*/FloatBuffer/*value2*/; + +/** + * Simple primitive-type stack. + * <p> + * Implemented operations: + * <ul> + * <li>FILO - First In, Last Out</li> + * </ul> + * </p> + */ +public class /*name*/FloatStack/*name*/ implements PrimitiveStack { + private int position; + private /*value*/float/*value*/[] buffer; + private int growSize; + + /** + * @param initialSize initial size, must be > zero + * @param growSize grow size if {@link #position()} is reached, maybe <code>0</code> + * in which case an {@link IndexOutOfBoundsException} is thrown. + */ + public /*name*/FloatStack/*name*/(int initialSize, int growSize) { + this.position = 0; + this.growSize = growSize; + this.buffer = new /*value*/float/*value*/[initialSize]; + } + + @Override + public final int capacity() { return buffer.length; } + + @Override + public final int position() { return position; } + + @Override + public final int remaining() { return buffer.length - position; } + + @Override + public final int getGrowSize() { return growSize; } + + @Override + public final void setGrowSize(int newGrowSize) { growSize = newGrowSize; } + + public final String toString() { + return "FloatStack[0..(top "+position+").."+buffer.length+", remaining "+remaining()+"]"; + } + + public final /*value*/float/*value*/[] buffer() { return buffer; } + + private final void growIfNecessary(int length) throws IndexOutOfBoundsException { + if( position + length > buffer.length ) { + if( 0 >= growSize ) { + throw new IndexOutOfBoundsException("Out of fixed stack size: "+this); + } + /*value*/float/*value*/[] newBuffer = + new /*value*/float/*value*/[buffer.length + growSize]; + System.arraycopy(buffer, 0, newBuffer, 0, position); + buffer = newBuffer; + } + } + + /** + * FILO put operation + * + * @param src source buffer + * @param srcOffset offset of src + * @param length number of float elements to put from <code>src</code> on-top this stack + * @return the src float[] + * @throws IndexOutOfBoundsException if stack cannot grow due to zero grow-size or offset+length exceeds src. + */ + public final /*value*/float/*value*/[] + putOnTop(/*value*/float/*value*/[] src, int srcOffset, int length) throws IndexOutOfBoundsException { + growIfNecessary(length); + System.arraycopy(src, srcOffset, buffer, position, length); + position += length; + return src; + } + + /** + * FILO put operation + * + * @param src source buffer, it's position is incremented by <code>length</code> + * @param length number of float elements to put from <code>src</code> on-top this stack + * @return the src FloatBuffer + * @throws IndexOutOfBoundsException if stack cannot grow due to zero grow-size + * @throws BufferUnderflowException if <code>src</code> FloatBuffer has less remaining elements than <code>length</code>. + */ + public final /*value2*/FloatBuffer/*value2*/ + putOnTop(/*value2*/FloatBuffer/*value2*/ src, int length) throws IndexOutOfBoundsException, BufferUnderflowException { + growIfNecessary(length); + src.get(buffer, position, length); + position += length; + return src; + } + + /** + * FILO get operation + * + * @param dest destination buffer + * @param destOffset offset of dest + * @param length number of float elements to get from-top this stack to <code>dest</code>. + * @return the dest float[] + * @throws IndexOutOfBoundsException if stack or <code>dest</code> has less elements than <code>length</code>. + */ + public final /*value*/float/*value*/[] + getFromTop(/*value*/float/*value*/[] dest, int destOffset, int length) throws IndexOutOfBoundsException { + System.arraycopy(buffer, position-length, dest, destOffset, length); + position -= length; + return dest; + } + + /** + * FILO get operation + * + * @param dest destination buffer, it's position is incremented by <code>length</code>. + * @param length number of float elements to get from-top this stack to <code>dest</code>. + * @return the dest FloatBuffer + * @throws IndexOutOfBoundsException if stack has less elements than length + * @throws BufferOverflowException if <code>src</code> FloatBuffer has less remaining elements than <code>length</code>. + */ + public final /*value2*/FloatBuffer/*value2*/ + getFromTop(/*value2*/FloatBuffer/*value2*/ dest, int length) throws IndexOutOfBoundsException, BufferOverflowException { + dest.put(buffer, position-length, length); + position -= length; + return dest; + } +} diff --git a/src/java/com/jogamp/common/util/PrimitiveStack.java b/src/java/com/jogamp/common/util/PrimitiveStack.java new file mode 100644 index 0000000..23447e3 --- /dev/null +++ b/src/java/com/jogamp/common/util/PrimitiveStack.java @@ -0,0 +1,72 @@ +/** + * Copyright 2012 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.util; + +/** + * Simple primitive-type stack. + */ +public interface PrimitiveStack { + + /** + * Returns this stack's current capacity. + * <p> + * The capacity may grow with a put operation w/ insufficient {@link #remaining()} elements left, if {@link #getGrowSize()} > 0. + * </p> + */ + int capacity(); + + /** + * Returns the current position where the next put operation will store the next element. + * <p> + * The position equals to the number of elements already stored. + * </p> + * <p> + * 0 denotes an empty stack. + * </p> + **/ + int position(); + + /** + * Returns the remaining elements left before stack will grow about {@link #getGrowSize()}. + * <pre> + * remaining := capacity() - position(); + * </pre> + * <p> + * 0 denotes a full stack. + * </p> + * @see #capacity() + * @see #position() + **/ + int remaining(); + + /** Returns the grow size. A stack grows by this size in case a put operation exceeds it's {@link #capacity()}. */ + int getGrowSize(); + + /** Set new {@link #growSize(). */ + void setGrowSize(int newGrowSize); +} diff --git a/src/junit/com/jogamp/common/util/TestFloatStack01.java b/src/junit/com/jogamp/common/util/TestFloatStack01.java new file mode 100644 index 0000000..0a2b077 --- /dev/null +++ b/src/junit/com/jogamp/common/util/TestFloatStack01.java @@ -0,0 +1,266 @@ +/** + * 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.util; + +import java.io.IOException; +import java.nio./*value2*/FloatBuffer/*value2*/; +import java.util.Arrays; + +import org.junit.Assert; +import org.junit.Test; + +import com.jogamp.junit.util.JunitTracer; + +public class /*testname*/TestFloatStack01/*testname*/ extends JunitTracer { + + static final boolean equals(/*value*/float/*value*/[] b, int bOffset, + /*value*/float/*value*/[] stack, int stackOffset, int length) { + for(int i=0; i<length; i++) { + if( b[bOffset+i] != stack[stackOffset+i]) { + return false; + } + } + return true; + } + + + @Test + public void test01PrimitiveArray() { + final int compNum = 3; + /*value*/float/*value*/[] e0 = + new /*value*/float/*value*/[] { 0, 1, 2 }; + /*value*/float/*value*/[] e1 = + new /*value*/float/*value*/[] { 3, 4, 5 }; + + final int initialSizeElem = 32; + final int growSizeElem = 2; + final int totalSizeElem = initialSizeElem+2*growSizeElem; + + final int initialSizeComp = initialSizeElem*compNum; + final int growSizeComp = growSizeElem*compNum; + final int totalSizeComp = totalSizeElem*compNum; + + final /*name*/FloatStack/*name*/ fs0 = + new /*name*/FloatStack/*name*/(initialSizeComp, growSizeComp); + + // + // PUT + // + + for(int i=0; i<totalSizeElem; i++) { + if(i < initialSizeElem) { + Assert.assertTrue("Error "+fs0, fs0.remaining() == (initialSizeElem-i)*compNum); + } else { + int j = ( i - initialSizeElem ) % growSizeElem ; + Assert.assertTrue("Error "+fs0, fs0.remaining() == j*compNum); + } + Assert.assertTrue("Error "+fs0, fs0.position() == i*compNum); + + // String s; + if( 0 == i % 2) { + // s = Arrays.toString(e0); + fs0.putOnTop(e0, 0, compNum); + } else { + // s = Arrays.toString(e1); + fs0.putOnTop(e1, 0, compNum); + } + // System.err.println("#"+i+"/"+totalSizeElem+": "+fs0+" <- "+s); + } + // System.err.println("X: "+fs0); + Assert.assertTrue("Error "+fs0, fs0.remaining() == 0); + Assert.assertTrue("Error "+fs0, fs0.position() == totalSizeComp); + + fs0.setGrowSize(0); + { + Exception expectedException = null; + try { + fs0.putOnTop(e1, 0, compNum); + } catch (Exception e) { + expectedException = e; + } + if(null == expectedException || !(expectedException instanceof IndexOutOfBoundsException) ) { + Assert.assertTrue("Error "+fs0+", exception "+expectedException, false); + } + } + + // + // GET + // + + for(int i=0; i<totalSizeElem; i++) { + Assert.assertTrue("Error "+fs0, fs0.remaining() == i*compNum); + Assert.assertTrue("Error "+fs0, fs0.position() == (totalSizeElem-i)*compNum); + + final /*value*/float/*value*/[] buf = + new /*value*/float/*value*/[compNum]; + fs0.getFromTop(buf, 0, compNum); + if( 0 == i % 2) { + Assert.assertTrue("Error "+fs0+", #"+i+": "+Arrays.toString(e1)+" != "+Arrays.toString(buf), Arrays.equals(e1, buf)); + } else { + Assert.assertTrue("Error "+fs0+", #"+i+": "+Arrays.toString(e0)+" != "+Arrays.toString(buf), Arrays.equals(e0, buf)); + } + } + Assert.assertTrue("Error "+fs0, fs0.remaining() == totalSizeComp); + Assert.assertTrue("Error "+fs0, fs0.position() == 0); + + { + final /*value*/float/*value*/[] buf = + new /*value*/float/*value*/[compNum]; + Exception expectedException = null; + try { + fs0.getFromTop(buf, 0, compNum); + } catch (Exception e) { + expectedException = e; + } + if(null == expectedException || !(expectedException instanceof IndexOutOfBoundsException) ) { + Assert.assertTrue("Error "+fs0+", exception "+expectedException, false); + } + } + } + + @Test + public void test02FloatBuffer() { + final int compNum = 3; + /*value2*/FloatBuffer/*value2*/ fb0 = + /*value2*/FloatBuffer/*value2*/.allocate(3*compNum); + + /*value*/float/*value*/[] e0 = + new /*value*/float/*value*/[] { 0, 1, 2 }; + /*value*/float/*value*/[] e1 = + new /*value*/float/*value*/[] { 3, 4, 5 }; + /*value*/float/*value*/[] e2 = + new /*value*/float/*value*/[] { 6, 7, 8 }; // not put on stack! + fb0.put(e0); + fb0.put(e1); + fb0.put(e2); + fb0.position(0); + + final int initialSizeElem = 32; + final int growSizeElem = 2; + final int totalSizeElem = initialSizeElem+2*growSizeElem; + + final int initialSizeComp = initialSizeElem*compNum; + final int growSizeComp = growSizeElem*compNum; + final int totalSizeComp = totalSizeElem*compNum; + + final /*name*/FloatStack/*name*/ fs0 = + new /*name*/FloatStack/*name*/(initialSizeComp, growSizeComp); + + // + // PUT + // + + for(int i=0; i<totalSizeElem; i++) { + if( 0 == i ) { + Assert.assertTrue("Error "+fs0+", "+fb0, fb0.position() == 0); + } else if( 0 == i % 2) { + Assert.assertTrue("Error "+fs0+", "+fb0, fb0.position() == 2*compNum); + fb0.position(0); + } else { + Assert.assertTrue("Error "+fs0+", "+fb0, fb0.position() == compNum); + } + if(i < initialSizeElem) { + Assert.assertTrue("Error "+fs0, fs0.remaining() == (initialSizeElem-i)*compNum); + } else { + int j = ( i - initialSizeElem ) % growSizeElem ; + Assert.assertTrue("Error "+fs0, fs0.remaining() == j*compNum); + } + Assert.assertTrue("Error "+fs0, fs0.position() == i*compNum); + + final int fb0Pos0 = fb0.position(); + fs0.putOnTop(fb0, compNum); + Assert.assertTrue("Error "+fs0+", "+fb0, fb0.position() == fb0Pos0 + compNum); + } + Assert.assertTrue("Error "+fs0, fs0.remaining() == 0); + Assert.assertTrue("Error "+fs0, fs0.position() == totalSizeComp); + + fs0.setGrowSize(0); + { + fb0.position(0); + Exception expectedException = null; + try { + fs0.putOnTop(fb0, compNum); + } catch (Exception e) { + expectedException = e; + } + if(null == expectedException || !(expectedException instanceof IndexOutOfBoundsException) ) { + Assert.assertTrue("Error "+fs0+", exception "+expectedException, false); + } + fb0.position(0); + } + + // + // GET + // + + for(int i=0; i<totalSizeElem; i++) { + Assert.assertTrue("Error "+fs0, fs0.remaining() == i*compNum); + Assert.assertTrue("Error "+fs0, fs0.position() == (totalSizeElem-i)*compNum); + + final /*value*/float/*value*/[] backing = + new /*value*/float/*value*/[compNum]; + /*value2*/FloatBuffer/*value2*/ buf = + /*value2*/FloatBuffer/*value2*/.wrap(backing); + + fs0.getFromTop(buf, compNum); + if( 0 == i % 2) { + Assert.assertTrue("Error "+fs0+", #"+i+": "+Arrays.toString(e1)+" != "+Arrays.toString(backing), Arrays.equals(e1, backing)); + } else { + Assert.assertTrue("Error "+fs0+", #"+i+": "+Arrays.toString(e0)+" != "+Arrays.toString(backing), Arrays.equals(e0, backing)); + } + Assert.assertTrue("Error "+fs0+", "+buf, buf.position() == compNum); + buf.position(0); + } + Assert.assertTrue("Error "+fs0, fs0.remaining() == totalSizeComp); + Assert.assertTrue("Error "+fs0, fs0.position() == 0); + + { + final /*value*/float/*value*/[] backing = + new /*value*/float/*value*/[compNum]; + /*value2*/FloatBuffer/*value2*/ buf + = /*value2*/FloatBuffer/*value2*/.wrap(backing); + Exception expectedException = null; + try { + fs0.getFromTop(buf, compNum); + } catch (Exception e) { + expectedException = e; + } + if(null == expectedException || !(expectedException instanceof IndexOutOfBoundsException) ) { + Assert.assertTrue("Error "+fs0+", exception "+expectedException, false); + } + } + + } + + public static void main(String args[]) throws IOException { + String tstname = /*testname*/TestFloatStack01/*testname*/.class.getName(); + org.junit.runner.JUnitCore.main(tstname); + } + +} |