/* * test for method static DoubleBuffer allocate(int capacity) test covers * following usecases: 1. case for check DoubleBuffer testBuf properties 2. * case expected IllegalArgumentException */ @TestTargetNew( level = TestLevel.PARTIAL_COMPLETE, notes = "", method = "allocate", args = {int.class}) public void test_AllocateI() { // case: DoubleBuffer testBuf properties is satisfy the conditions // specification DoubleBuffer testBuf = DoubleBuffer.allocate(20); assertEquals(0, testBuf.position()); assertNotNull(testBuf.array()); assertEquals(0, testBuf.arrayOffset()); assertEquals(20, testBuf.limit()); assertEquals(20, testBuf.capacity()); testBuf = DoubleBuffer.allocate(0); assertEquals(0, testBuf.position()); assertNotNull(testBuf.array()); assertEquals(0, testBuf.arrayOffset()); assertEquals(0, testBuf.limit()); assertEquals(0, testBuf.capacity()); // case: expected IllegalArgumentException try { testBuf = DoubleBuffer.allocate(-20); fail("allocate method does not throws expected exception"); } catch (IllegalArgumentException e) { // expected } }
public void testDuplicate() { buf.clear(); buf.mark(); buf.position(buf.limit()); // duplicate's contents should be the same as buf DoubleBuffer duplicate = buf.duplicate(); assertNotSame(buf, duplicate); assertEquals(buf.position(), duplicate.position()); assertEquals(buf.limit(), duplicate.limit()); assertEquals(buf.isReadOnly(), duplicate.isReadOnly()); assertEquals(buf.isDirect(), duplicate.isDirect()); assertEquals(buf.order(), duplicate.order()); assertContentEquals(buf, duplicate); // duplicate's position, mark, and limit should be independent to buf duplicate.reset(); assertEquals(duplicate.position(), 0); duplicate.clear(); assertEquals(buf.position(), buf.limit()); buf.reset(); assertEquals(buf.position(), 0); // duplicate share the same content with buf // FIXME if (!duplicate.isReadOnly()) { loadTestData1(buf); assertContentEquals(buf, duplicate); loadTestData2(duplicate); assertContentEquals(buf, duplicate); } }
@TestTargetNew( level = TestLevel.PARTIAL_COMPLETE, notes = "", method = "equals", args = {java.lang.Object.class}) public void testEquals() { // equal to self assertTrue(buf.equals(buf)); DoubleBuffer readonly = buf.asReadOnlyBuffer(); assertTrue(buf.equals(readonly)); DoubleBuffer duplicate = buf.duplicate(); assertTrue(buf.equals(duplicate)); // always false, if type mismatch assertFalse(buf.equals(Boolean.TRUE)); assertTrue(buf.capacity() > 5); buf.limit(buf.capacity()).position(0); readonly.limit(readonly.capacity()).position(1); assertFalse(buf.equals(readonly)); buf.limit(buf.capacity() - 1).position(0); duplicate.limit(duplicate.capacity()).position(0); assertFalse(buf.equals(duplicate)); }
public void testSlice() { assertTrue(buf.capacity() > 5); buf.position(1); buf.limit(buf.capacity() - 1); DoubleBuffer slice = buf.slice(); assertEquals(buf.isReadOnly(), slice.isReadOnly()); assertEquals(buf.isDirect(), slice.isDirect()); assertEquals(buf.order(), slice.order()); assertEquals(slice.position(), 0); assertEquals(slice.limit(), buf.remaining()); assertEquals(slice.capacity(), buf.remaining()); try { slice.reset(); fail("Should throw Exception"); // $NON-NLS-1$ } catch (InvalidMarkException e) { // expected } // slice share the same content with buf // FIXME: if (!slice.isReadOnly()) { loadTestData1(slice); assertContentLikeTestData1(buf, 1, 0, slice.capacity()); buf.put(2, 500); assertEquals(slice.get(1), 500, 0.0); } }
@TestTargetNew( level = TestLevel.PARTIAL_COMPLETE, notes = "", method = "compact", args = {}) @AndroidOnly("Fails on RI. See comment below") public void testCompact() { // case: buffer is full buf.clear(); buf.mark(); loadTestData1(buf); DoubleBuffer ret = buf.compact(); assertSame(ret, buf); assertEquals(buf.position(), buf.capacity()); assertEquals(buf.limit(), buf.capacity()); assertContentLikeTestData1(buf, 0, 0.0, buf.capacity()); try { buf.reset(); fail("Should throw Exception"); // $NON-NLS-1$ } catch (InvalidMarkException e) { // expected } // case: buffer is empty buf.position(0); buf.limit(0); buf.mark(); ret = buf.compact(); assertSame(ret, buf); assertEquals(buf.position(), 0); assertEquals(buf.limit(), buf.capacity()); assertContentLikeTestData1(buf, 0, 0.0, buf.capacity()); try { // Fails on RI. Spec doesn't specify the behavior if // actually nothing to be done by compact(). So RI doesn't reset // mark position buf.reset(); fail("Should throw Exception"); // $NON-NLS-1$ } catch (InvalidMarkException e) { // expected } // case: normal assertTrue(buf.capacity() > 5); buf.position(1); buf.limit(5); buf.mark(); ret = buf.compact(); assertSame(ret, buf); assertEquals(buf.position(), 4); assertEquals(buf.limit(), buf.capacity()); assertContentLikeTestData1(buf, 0, 1.0, 4); try { buf.reset(); fail("Should throw Exception"); // $NON-NLS-1$ } catch (InvalidMarkException e) { // expected } }
public void testCompact() { // case: buffer is full buf.clear(); buf.mark(); loadTestData1(buf); DoubleBuffer ret = buf.compact(); assertSame(ret, buf); assertEquals(buf.position(), buf.capacity()); assertEquals(buf.limit(), buf.capacity()); assertContentLikeTestData1(buf, 0, 0.0, buf.capacity()); try { buf.reset(); fail("Should throw Exception"); // $NON-NLS-1$ } catch (InvalidMarkException e) { // expected } // case: buffer is empty buf.position(0); buf.limit(0); buf.mark(); ret = buf.compact(); assertSame(ret, buf); assertEquals(buf.position(), 0); assertEquals(buf.limit(), buf.capacity()); assertContentLikeTestData1(buf, 0, 0.0, buf.capacity()); try { buf.reset(); fail("Should throw Exception"); // $NON-NLS-1$ } catch (InvalidMarkException e) { // expected } // case: normal assertTrue(buf.capacity() > 5); buf.position(1); buf.limit(5); buf.mark(); ret = buf.compact(); assertSame(ret, buf); assertEquals(buf.position(), 4); assertEquals(buf.limit(), buf.capacity()); assertContentLikeTestData1(buf, 0, 1.0, 4); try { buf.reset(); fail("Should throw Exception"); // $NON-NLS-1$ } catch (InvalidMarkException e) { // expected } }
/* * test for method static DoubleBuffer wrap(double[] array, int offset, int * length) test covers following usecases: 1. case for check DoubleBuffer * buf2 properties 2. case for check equal between buf2 and double array[] * 3. case for check a buf2 dependens to array[] 4. case expected * IndexOutOfBoundsException */ @TestTargetNew( level = TestLevel.PARTIAL_COMPLETE, notes = "", method = "wrap", args = {double[].class, int.class, int.class}) public void test_Wrap$DII() { double array[] = new double[BUFFER_LENGTH]; int offset = 5; int length = BUFFER_LENGTH - offset; loadTestData1(array, 0, BUFFER_LENGTH); DoubleBuffer buf2 = DoubleBuffer.wrap(array, offset, length); // case: DoubleBuffer buf2 properties is satisfy the conditions // specification assertEquals(buf2.capacity(), array.length); assertEquals(buf2.position(), offset); assertEquals(buf2.limit(), offset + length); assertEquals(buf2.arrayOffset(), 0); // case: DoubleBuffer buf2 is equal to double array[] assertContentEquals(buf2, array, 0, array.length); // case: DoubleBuffer buf2 is depended to double array[] loadTestData2(array, 0, buf.capacity()); assertContentEquals(buf2, array, 0, array.length); // case: expected IndexOutOfBoundsException try { offset = 7; buf2 = DoubleBuffer.wrap(array, offset, length); fail("wrap method does not throws expected exception"); } catch (IndexOutOfBoundsException e) { // expected } }
/* * Class under test for java.nio.DoubleBuffer put(int, double) */ @TestTargetNew( level = TestLevel.PARTIAL_COMPLETE, notes = "Doesn't verify ReadOnlyBufferException.", method = "put", args = {int.class, double.class}) public void testPutintdouble() { buf.clear(); for (int i = 0; i < buf.capacity(); i++) { assertEquals(buf.position(), 0); DoubleBuffer ret = buf.put(i, (double) i); assertEquals(buf.get(i), (double) i, 0.0); assertSame(ret, buf); } try { buf.put(-1, 0); fail("Should throw Exception"); // $NON-NLS-1$ } catch (IndexOutOfBoundsException e) { // expected } try { buf.put(buf.limit(), 0); fail("Should throw Exception"); // $NON-NLS-1$ } catch (IndexOutOfBoundsException e) { // expected } }
public void testToString() { String str = buf.toString(); assertTrue(str.indexOf("Double") >= 0 || str.indexOf("double") >= 0); assertTrue(str.indexOf("" + buf.position()) >= 0); assertTrue(str.indexOf("" + buf.limit()) >= 0); assertTrue(str.indexOf("" + buf.capacity()) >= 0); }
@TestTargetNew( level = TestLevel.PARTIAL_COMPLETE, notes = "", method = "toString", args = {}) public void testToString() { String str = buf.toString(); assertTrue(str.indexOf("Double") >= 0 || str.indexOf("double") >= 0); assertTrue(str.indexOf("" + buf.position()) >= 0); assertTrue(str.indexOf("" + buf.limit()) >= 0); assertTrue(str.indexOf("" + buf.capacity()) >= 0); }
public void testEquals() { // equal to self assertTrue(buf.equals(buf)); DoubleBuffer readonly = buf.asReadOnlyBuffer(); assertTrue(buf.equals(readonly)); DoubleBuffer duplicate = buf.duplicate(); assertTrue(buf.equals(duplicate)); // always false, if type mismatch assertFalse(buf.equals(Boolean.TRUE)); assertTrue(buf.capacity() > 5); buf.limit(buf.capacity()).position(0); readonly.limit(readonly.capacity()).position(1); assertFalse(buf.equals(readonly)); buf.limit(buf.capacity() - 1).position(0); duplicate.limit(duplicate.capacity()).position(0); assertFalse(buf.equals(duplicate)); }
@TestTargetNew( level = TestLevel.PARTIAL_COMPLETE, notes = "", method = "asReadOnlyBuffer", args = {}) public void testAsReadOnlyBuffer() { buf.clear(); buf.mark(); buf.position(buf.limit()); // readonly's contents should be the same as buf DoubleBuffer readonly = buf.asReadOnlyBuffer(); assertNotSame(buf, readonly); assertTrue(readonly.isReadOnly()); assertEquals(buf.position(), readonly.position()); assertEquals(buf.limit(), readonly.limit()); assertEquals(buf.isDirect(), readonly.isDirect()); assertEquals(buf.order(), readonly.order()); assertContentEquals(buf, readonly); // readonly's position, mark, and limit should be independent to buf readonly.reset(); assertEquals(readonly.position(), 0); readonly.clear(); assertEquals(buf.position(), buf.limit()); buf.reset(); assertEquals(buf.position(), 0); // BEGIN android-added // copied from a newer version of Harmony DoubleBuffer dbuffer1 = DoubleBuffer.wrap(new double[] {Double.NaN}); DoubleBuffer dbuffer2 = DoubleBuffer.wrap(new double[] {Double.NaN}); DoubleBuffer dbuffer3 = DoubleBuffer.wrap(new double[] {42d}); assertEquals("Failed equal comparison with NaN entry", 0, dbuffer1.compareTo(dbuffer2)); assertEquals("Failed greater than comparison with NaN entry", 1, dbuffer3.compareTo(dbuffer1)); assertEquals("Failed greater than comparison with NaN entry", 1, dbuffer1.compareTo(dbuffer3)); // END android-added }
public void testAsReadOnlyBuffer() { buf.clear(); buf.mark(); buf.position(buf.limit()); // readonly's contents should be the same as buf DoubleBuffer readonly = buf.asReadOnlyBuffer(); assertNotSame(buf, readonly); assertTrue(readonly.isReadOnly()); assertEquals(buf.position(), readonly.position()); assertEquals(buf.limit(), readonly.limit()); assertEquals(buf.isDirect(), readonly.isDirect()); assertEquals(buf.order(), readonly.order()); assertContentEquals(buf, readonly); // readonly's position, mark, and limit should be independent to buf readonly.reset(); assertEquals(readonly.position(), 0); readonly.clear(); assertEquals(buf.position(), buf.limit()); buf.reset(); assertEquals(buf.position(), 0); }
@NotNull public static IndexedCollection<Double> ofDouble(@NotNull ByteBuffer byteBuffer) { int magic = byteBuffer.getInt(); if (magic != MAGIC) { throw new IllegalArgumentException("bad magic number"); } int version = byteBuffer.getInt(); if (version != VERSION) { throw new IllegalArgumentException("bad version number"); } int size = byteBuffer.getInt(); DoubleBuffer values = byteBuffer.asDoubleBuffer(); values.limit(size); byteBuffer.position(byteBuffer.position() + size * Integer.BYTES); return new DoubleBufferCollection(values.slice()); }
/* * Class under test for double get(int) */ public void testGetint() { buf.clear(); for (int i = 0; i < buf.capacity(); i++) { assertEquals(buf.position(), i); assertEquals(buf.get(), buf.get(i), 0.01); } try { buf.get(-1); fail("Should throw Exception"); // $NON-NLS-1$ } catch (IndexOutOfBoundsException e) { // expected } try { buf.get(buf.limit()); fail("Should throw Exception"); // $NON-NLS-1$ } catch (IndexOutOfBoundsException e) { // expected } }
@TestTargetNew( level = TestLevel.PARTIAL_COMPLETE, notes = "", method = "compareTo", args = {java.nio.DoubleBuffer.class}) public void testCompareTo() { DoubleBuffer other = DoubleBuffer.allocate(buf.capacity()); loadTestData1(other); assertEquals(0, buf.compareTo(other)); assertEquals(0, other.compareTo(buf)); buf.position(1); assertTrue(buf.compareTo(other) > 0); assertTrue(other.compareTo(buf) < 0); other.position(2); assertTrue(buf.compareTo(other) < 0); assertTrue(other.compareTo(buf) > 0); buf.position(2); other.limit(5); assertTrue(buf.compareTo(other) > 0); assertTrue(other.compareTo(buf) < 0); }
/* * Class under test for java.nio.DoubleBuffer put(int, double) */ public void testPutintdouble() { buf.clear(); for (int i = 0; i < buf.capacity(); i++) { assertEquals(buf.position(), 0); DoubleBuffer ret = buf.put(i, (double) i); assertEquals(buf.get(i), (double) i, 0.0); assertSame(ret, buf); } try { buf.put(-1, 0); fail("Should throw Exception"); // $NON-NLS-1$ } catch (IndexOutOfBoundsException e) { // expected } try { buf.put(buf.limit(), 0); fail("Should throw Exception"); // $NON-NLS-1$ } catch (IndexOutOfBoundsException e) { // expected } }
/* * test for method static DoubleBuffer wrap(double[] array) test covers * following usecases: 1. case for check DoubleBuffer buf2 properties 2. * case for check equal between buf2 and double array[] 3. case for check a * buf2 dependens to array[] */ @TestTargetNew( level = TestLevel.PARTIAL_COMPLETE, notes = "", method = "wrap", args = {double[].class}) public void test_Wrap$D() { double array[] = new double[BUFFER_LENGTH]; loadTestData1(array, 0, BUFFER_LENGTH); DoubleBuffer buf2 = DoubleBuffer.wrap(array); // case: DoubleBuffer buf2 properties is satisfy the conditions // specification assertEquals(buf2.capacity(), array.length); assertEquals(buf2.limit(), array.length); assertEquals(buf2.position(), 0); // case: DoubleBuffer buf2 is equal to double array[] assertContentEquals(buf2, array, 0, array.length); // case: DoubleBuffer buf2 is depended to double array[] loadTestData2(array, 0, buf.capacity()); assertContentEquals(buf2, array, 0, array.length); }
/* * Class under test for double get(int) */ @TestTargetNew( level = TestLevel.PARTIAL_COMPLETE, notes = "", method = "get", args = {int.class}) public void testGetint() { buf.clear(); for (int i = 0; i < buf.capacity(); i++) { assertEquals(buf.position(), i); assertEquals(buf.get(), buf.get(i), 0.01); } try { buf.get(-1); fail("Should throw Exception"); // $NON-NLS-1$ } catch (IndexOutOfBoundsException e) { // expected } try { buf.get(buf.limit()); fail("Should throw Exception"); // $NON-NLS-1$ } catch (IndexOutOfBoundsException e) { // expected } }
public void testCompareTo() { DoubleBuffer other = DoubleBuffer.allocate(buf.capacity()); loadTestData1(other); assertEquals(0, buf.compareTo(other)); assertEquals(0, other.compareTo(buf)); buf.position(1); assertTrue(buf.compareTo(other) > 0); assertTrue(other.compareTo(buf) < 0); other.position(2); assertTrue(buf.compareTo(other) < 0); assertTrue(other.compareTo(buf) > 0); buf.position(2); other.limit(5); assertTrue(buf.compareTo(other) > 0); assertTrue(other.compareTo(buf) < 0); DoubleBuffer dbuffer1 = DoubleBuffer.wrap(new double[] {Double.NaN}); DoubleBuffer dbuffer2 = DoubleBuffer.wrap(new double[] {Double.NaN}); DoubleBuffer dbuffer3 = DoubleBuffer.wrap(new double[] {42d}); assertEquals("Failed equal comparison with NaN entry", 0, dbuffer1.compareTo(dbuffer2)); assertEquals("Failed greater than comparison with NaN entry", 1, dbuffer3.compareTo(dbuffer1)); assertEquals("Failed greater than comparison with NaN entry", 1, dbuffer1.compareTo(dbuffer3)); }
public static TestIntfPrx allTests(Ice.Communicator communicator, PrintWriter out) { out.print("testing stringToProxy... "); out.flush(); String ref = "test:default -p 12010"; Ice.ObjectPrx obj = communicator.stringToProxy(ref); test(obj != null); out.println("ok"); out.print("testing checked cast... "); out.flush(); TestIntfPrx t = TestIntfPrxHelper.checkedCast(obj); test(t != null); test(t.equals(obj)); out.println("ok"); out.print("testing custom sequences... "); out.flush(); { // // Create a sequence of C instances, where elements 1..n simply point to element 0. // C[] seq = new C[5]; seq[0] = new C(); for (int i = 1; i < seq.length; i++) { seq[i] = seq[0]; } // // Invoke each operation and verify that the returned sequences have the same // structure as the original. // CSeqHolder seqH = new CSeqHolder(); C[] seqR = t.opCSeq(seq, seqH); test(seqR.length == seq.length); test(seqH.value.length == seq.length); for (int i = 1; i < seq.length; i++) { test(seqR[i] != null); test(seqR[i] == seqR[0]); test(seqR[i] == seqH.value[i]); } ArrayList<C> arr = new ArrayList<C>(Arrays.asList(seq)); CArrayHolder arrH = new CArrayHolder(); List<C> arrR = t.opCArray(arr, arrH); test(arrR.size() == arr.size()); test(arrH.value.size() == arr.size()); for (int i = 1; i < arr.size(); i++) { test(arrR.get(i) != null); test(arrR.get(i) == arrR.get(0)); test(arrR.get(i) == arrH.value.get(i)); } LinkedList<C> list = new LinkedList<C>(Arrays.asList(seq)); CListHolder listH = new CListHolder(); List<C> listR = t.opCList(list, listH); test(listR.size() == list.size()); test(listH.value.size() == list.size()); for (int i = 1; i < list.size(); i++) { test(listR.get(i) != null); test(listR.get(i) == listR.get(0)); test(listR.get(i) == listH.value.get(i)); } } { final Boolean[] seq = { Boolean.TRUE, Boolean.FALSE, Boolean.TRUE, Boolean.FALSE, Boolean.TRUE }; ArrayList<Boolean> list = new ArrayList<Boolean>(Arrays.asList(seq)); BoolSeqHolder listH = new BoolSeqHolder(); List<Boolean> listR = t.opBoolSeq(list, listH); test(listH.value.equals(listR)); test(listH.value.equals(list)); } { final Byte[] seq = { new Byte((byte) 0), new Byte((byte) 1), new Byte((byte) 2), new Byte((byte) 3) }; ArrayList<Byte> list = new ArrayList<Byte>(Arrays.asList(seq)); ByteSeqHolder listH = new ByteSeqHolder(); List<Byte> listR = t.opByteSeq(list, listH); test(listH.value.equals(listR)); test(listH.value.equals(list)); } { final Short[] seq = { new Short((short) 0), new Short((short) 1), new Short((short) 2), new Short((short) 3) }; ArrayList<Short> list = new ArrayList<Short>(Arrays.asList(seq)); ShortSeqHolder listH = new ShortSeqHolder(); List<Short> listR = t.opShortSeq(list, listH); test(listH.value.equals(listR)); test(listH.value.equals(list)); } { final Integer[] seq = {new Integer(0), new Integer(1), new Integer(2), new Integer(3)}; ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(seq)); IntSeqHolder listH = new IntSeqHolder(); List<Integer> listR = t.opIntSeq(list, listH); test(listH.value.equals(listR)); test(listH.value.equals(list)); } { final Long[] seq = {new Long(0), new Long(1), new Long(2), new Long(3)}; ArrayList<Long> list = new ArrayList<Long>(Arrays.asList(seq)); LongSeqHolder listH = new LongSeqHolder(); List<Long> listR = t.opLongSeq(list, listH); test(listH.value.equals(listR)); test(listH.value.equals(list)); } { final Float[] seq = {new Float(0), new Float(1), new Float(2), new Float(3)}; ArrayList<Float> list = new ArrayList<Float>(Arrays.asList(seq)); FloatSeqHolder listH = new FloatSeqHolder(); List<Float> listR = t.opFloatSeq(list, listH); test(listH.value.equals(listR)); test(listH.value.equals(list)); } { final Double[] seq = {new Double(0), new Double(1), new Double(2), new Double(3)}; ArrayList<Double> list = new ArrayList<Double>(Arrays.asList(seq)); DoubleSeqHolder listH = new DoubleSeqHolder(); List<Double> listR = t.opDoubleSeq(list, listH); test(listH.value.equals(listR)); test(listH.value.equals(list)); } { final String[] seq = {"0", "1", "2", "3", "4"}; ArrayList<String> list = new ArrayList<String>(Arrays.asList(seq)); StringSeqHolder listH = new StringSeqHolder(); List<String> listR = t.opStringSeq(list, listH); test(listH.value.equals(listR)); test(listH.value.equals(list)); } { final E[] seq = {E.E1, E.E2, E.E3}; ArrayList<E> list = new ArrayList<E>(Arrays.asList(seq)); ESeqHolder listH = new ESeqHolder(); List<E> listR = t.opESeq(list, listH); test(listH.value.equals(listR)); test(listH.value.equals(list)); } { S[] seq = new S[5]; for (int i = 0; i < seq.length; i++) { seq[i] = new S(); seq[i].en = E.values()[i % 3]; } ArrayList<S> list = new ArrayList<S>(Arrays.asList(seq)); SSeqHolder listH = new SSeqHolder(); List<S> listR = t.opSSeq(list, listH); test(listH.value.equals(listR)); test(listH.value.equals(list)); } { ArrayList<Map<Integer, String>> list = new ArrayList<Map<Integer, String>>(); for (int i = 0; i < 5; i++) { Map<Integer, String> m = new HashMap<Integer, String>(); for (int j = 0; j < 4; j++) { m.put(j, "" + j); } list.add(m); } DSeqHolder listH = new DSeqHolder(); List<Map<Integer, String>> listR = t.opDSeq(list, listH); test(listH.value.equals(listR)); test(listH.value.equals(list)); } { List<List<String>> seq = new LinkedList<List<String>>(); for (int i = 0; i < 5; i++) { final String[] arr = {"0", "1", "2", "3", "4"}; seq.add(new ArrayList<String>(Arrays.asList(arr))); } StringSeqSeqHolder listH = new StringSeqSeqHolder(); List<List<String>> listR = t.opStringSeqSeq(seq, listH); test(listH.value.equals(listR)); test(listH.value.equals(seq)); } { final byte[] fullSeq = new byte[] {0, 1, 2, 3, 4, 5, 6, 7}; final byte[] usedSeq = new byte[] {2, 3, 4, 5}; ByteBuffer buffer = ByteBuffer.wrap(fullSeq, 2, 4); Ice.Holder<ByteBuffer> bufferH = new Ice.Holder<ByteBuffer>(); ByteBuffer bufferR = t.opByteBufferSeq(buffer, bufferH); byte[] arr = new byte[bufferH.value.limit()]; bufferH.value.get(arr, 0, bufferH.value.limit()); test(Arrays.equals(arr, usedSeq)); arr = new byte[bufferR.limit()]; bufferR.get(arr, 0, bufferR.limit()); test(Arrays.equals(arr, usedSeq)); } { final short[] fullSeq = new short[] {0, 1, 2, 3, 4, 5, 6, 7}; final short[] usedSeq = new short[] {2, 3, 4, 5}; ShortBuffer buffer = ShortBuffer.wrap(fullSeq, 2, 4); Ice.Holder<ShortBuffer> bufferH = new Ice.Holder<ShortBuffer>(); ShortBuffer bufferR = t.opShortBufferSeq(buffer, bufferH); short[] arr = new short[bufferH.value.limit()]; bufferH.value.get(arr, 0, bufferH.value.limit()); test(Arrays.equals(arr, usedSeq)); arr = new short[bufferR.limit()]; bufferR.get(arr, 0, bufferR.limit()); test(Arrays.equals(arr, usedSeq)); } { final int[] fullSeq = new int[] {0, 1, 2, 3, 4, 5, 6, 7}; final int[] usedSeq = new int[] {2, 3, 4, 5}; IntBuffer buffer = IntBuffer.wrap(fullSeq, 2, 4); Ice.Holder<IntBuffer> bufferH = new Ice.Holder<IntBuffer>(); IntBuffer bufferR = t.opIntBufferSeq(buffer, bufferH); int[] arr = new int[bufferH.value.limit()]; bufferH.value.get(arr, 0, bufferH.value.limit()); test(Arrays.equals(arr, usedSeq)); arr = new int[bufferR.limit()]; bufferR.get(arr, 0, bufferR.limit()); test(Arrays.equals(arr, usedSeq)); } { final long[] fullSeq = new long[] {0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L}; final long[] usedSeq = new long[] {2L, 3L, 4L, 5L}; LongBuffer buffer = LongBuffer.wrap(fullSeq, 2, 4); Ice.Holder<LongBuffer> bufferH = new Ice.Holder<LongBuffer>(); LongBuffer bufferR = t.opLongBufferSeq(buffer, bufferH); long[] arr = new long[bufferH.value.limit()]; bufferH.value.get(arr, 0, bufferH.value.limit()); test(Arrays.equals(arr, usedSeq)); arr = new long[bufferR.limit()]; bufferR.get(arr, 0, bufferR.limit()); test(Arrays.equals(arr, usedSeq)); } { final float[] fullSeq = new float[] {0, 1, 2, 3, 4, 5, 6, 7}; final float[] usedSeq = new float[] {2, 3, 4, 5}; FloatBuffer buffer = FloatBuffer.wrap(fullSeq, 2, 4); Ice.Holder<FloatBuffer> bufferH = new Ice.Holder<FloatBuffer>(); FloatBuffer bufferR = t.opFloatBufferSeq(buffer, bufferH); float[] arr = new float[bufferH.value.limit()]; bufferH.value.get(arr, 0, bufferH.value.limit()); test(Arrays.equals(arr, usedSeq)); arr = new float[bufferR.limit()]; bufferR.get(arr, 0, bufferR.limit()); test(Arrays.equals(arr, usedSeq)); } { final double[] fullSeq = new double[] {0, 1, 2, 3, 4, 5, 6, 7}; final double[] usedSeq = new double[] {2, 3, 4, 5}; DoubleBuffer buffer = DoubleBuffer.wrap(fullSeq, 2, 4); Ice.Holder<DoubleBuffer> bufferH = new Ice.Holder<DoubleBuffer>(); DoubleBuffer bufferR = t.opDoubleBufferSeq(buffer, bufferH); double[] arr = new double[bufferH.value.limit()]; bufferH.value.get(arr, 0, bufferH.value.limit()); test(Arrays.equals(arr, usedSeq)); arr = new double[bufferR.limit()]; bufferR.get(arr, 0, bufferR.limit()); test(Arrays.equals(arr, usedSeq)); } out.println("ok"); return t; }