Lines Matching refs:buf
48 protected ByteBuffer buf;
52 buf = ByteBuffer.allocate(BUFFER_LENGTH);
53 loadTestData1(buf);
54 baseBuf = buf;
59 buf = null;
153 byte array[] = buf.array();
154 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
156 loadTestData1(array, buf.arrayOffset(), buf.capacity());
157 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
159 loadTestData2(array, buf.arrayOffset(), buf.capacity());
160 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
162 loadTestData1(buf);
163 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
165 loadTestData2(buf);
166 assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
176 byte array[] = buf.array();
177 for(int i = 0; i < buf.capacity(); i++) {
180 int offset = buf.arrayOffset();
181 assertContentEquals(buf, array, offset, buf.capacity());
186 assertContentEquals(buf, array, offset, buf.capacity());
189 assertContentEquals(buf, array, offset, buf.capacity());
199 loadTestData1(buf);
200 buf.clear();
201 buf.mark();
202 buf.position(buf.limit());
204 // readonly's contents should be the same as buf
205 ByteBuffer readonly = buf.asReadOnlyBuffer();
206 assertNotSame(buf, readonly);
208 assertEquals(buf.position(), readonly.position());
209 assertEquals(buf.limit(), readonly.limit());
210 assertEquals(buf.isDirect(), readonly.isDirect());
211 assertEquals(buf.order(), readonly.order());
212 assertContentEquals(buf, readonly);
214 // readonly's position, mark, and limit should be independent to buf
218 assertEquals(buf.position(), buf.limit());
219 buf.reset();
220 assertEquals(0, buf.position());
231 if (buf.isReadOnly()) {
233 buf.compact();
242 buf.clear();
243 buf.mark();
244 loadTestData1(buf);
245 ByteBuffer ret = buf.compact();
246 assertSame(ret, buf);
247 assertEquals(buf.capacity(), buf.position());
248 assertEquals(buf.capacity(), buf.limit());
249 assertContentLikeTestData1(buf, 0, (byte) 0, buf.capacity());
254 buf.reset();
261 buf.position(0);
262 buf.limit(0);
263 buf.mark();
264 ret = buf.compact();
265 assertSame(ret, buf);
266 assertEquals(0, buf.position());
267 assertEquals(buf.limit(), buf.capacity());
268 assertContentLikeTestData1(buf, 0, (byte) 0, buf.capacity());
270 buf.reset();
277 assertTrue(buf.capacity() > SMALL_TEST_LENGTH);
278 buf.position(1);
279 buf.limit(SMALL_TEST_LENGTH);
280 buf.mark();
281 ret = buf.compact();
282 assertSame(ret, buf);
283 assertEquals(4, buf.position());
284 assertEquals(buf.limit(), buf.capacity());
285 assertContentLikeTestData1(buf, 0, (byte) 1, 4);
287 buf.reset();
302 assertEquals(0, buf.compareTo(buf));
305 if (!buf.isReadOnly()) {
306 assertTrue(buf.capacity() > SMALL_TEST_LENGTH);
307 buf.clear();
308 ByteBuffer other = ByteBuffer.allocate(buf.capacity());
309 loadTestData1(buf);
311 assertEquals(0, buf.compareTo(other));
312 assertEquals(0, other.compareTo(buf));
313 buf.position(1);
314 assertTrue(buf.compareTo(other) > 0);
315 assertTrue(other.compareTo(buf) < 0);
317 assertTrue(buf.compareTo(other) < 0);
318 assertTrue(other.compareTo(buf) > 0);
319 buf.position(2);
321 assertTrue(buf.compareTo(other) > 0);
322 assertTrue(other.compareTo(buf) < 0);
335 buf.clear();
336 buf.mark();
337 buf.position(buf.limit());
339 // duplicate's contents should be the same as buf
340 ByteBuffer duplicate = buf.duplicate();
341 assertNotSame(buf, duplicate);
342 assertEquals(buf.position(), duplicate.position());
343 assertEquals(buf.limit(), duplicate.limit());
344 assertEquals(buf.isReadOnly(), duplicate.isReadOnly());
345 assertEquals(buf.isDirect(), duplicate.isDirect());
346 assertEquals(buf.order(), duplicate.order());
347 assertContentEquals(buf, duplicate);
349 // duplicate's position, mark, and limit should be independent to buf
353 assertEquals(buf.position(), buf.limit());
354 buf.reset();
355 assertEquals(0, buf.position());
357 // duplicate share the same content with buf
359 loadTestData1(buf);
360 assertContentEquals(buf, duplicate);
362 assertContentEquals(buf, duplicate);
373 loadTestData1(buf);
376 assertTrue(buf.equals(buf));
377 ByteBuffer readonly = buf.asReadOnlyBuffer();
378 assertTrue(buf.equals(readonly));
379 ByteBuffer duplicate = buf.duplicate();
380 assertTrue(buf.equals(duplicate));
383 assertFalse(buf.equals(Boolean.TRUE));
385 assertTrue(buf.capacity() > SMALL_TEST_LENGTH);
387 buf.limit(buf.capacity()).position(0);
389 assertFalse(buf.equals(readonly));
391 buf.limit(buf.capacity() - 1).position(0);
393 assertFalse(buf.equals(duplicate));
395 buf.limit(buf.capacity() - 1).position(0);
397 assertFalse(buf.equals(duplicate));
410 loadTestData1(buf);
411 buf.clear();
412 for (int i = 0; i < buf.capacity(); i++) {
413 assertEquals(i, buf.position());
414 assertEquals(buf.get(), buf.get(i));
417 buf.get();
435 loadTestData1(buf);
436 buf.clear();
437 for (int i = 0; i < buf.capacity(); i++) {
438 assertEquals(i, buf.position());
439 ByteBuffer ret = buf.get(array);
440 assertEquals(array[0], buf.get(i));
441 assertSame(ret, buf);
444 buf.get(new byte[0]);
447 buf.get(array);
454 buf.get((byte[])null);
471 loadTestData1(buf);
472 buf.clear();
473 byte array[] = new byte[buf.capacity()];
476 buf.get(new byte[buf.capacity() + 1], 0, buf.capacity() + 1);
481 assertEquals(0, buf.position());
483 buf.get(array, -1, array.length);
488 buf.get(array, array.length, 0);
490 buf.get(array, array.length + 1, 1);
495 assertEquals(0, buf.position());
497 buf.get(array, 2, -1);
503 buf.get(array, 2, array.length);
509 buf.get((byte[])null, -1, 0);
515 buf.get(array, 1, Integer.MAX_VALUE);
521 buf.get(array, Integer.MAX_VALUE, 1);
526 assertEquals(0, buf.position());
528 buf.clear();
529 ByteBuffer ret = buf.get(array, 0, array.length);
530 assertEquals(buf.position(), buf.capacity());
531 assertContentEquals(buf, array, 0, array.length);
532 assertSame(ret, buf);
545 loadTestData1(buf);
546 buf.clear();
547 for (int i = 0; i < buf.capacity(); i++) {
548 assertEquals(i, buf.position());
549 assertEquals(buf.get(), buf.get(i));
552 buf.get(-1);
558 buf.get(buf.limit());
572 assertTrue(buf.hasArray());
573 assertNotNull(buf.array());
583 buf.clear();
584 loadTestData1(buf);
585 ByteBuffer readonly = buf.asReadOnlyBuffer();
586 ByteBuffer duplicate = buf.duplicate();
587 assertTrue(buf.hashCode() == readonly.hashCode());
588 assertTrue(buf.capacity() > SMALL_TEST_LENGTH);
589 duplicate.position(buf.capacity()/2);
590 assertTrue(buf.hashCode()!= duplicate.hashCode());
596 ByteBuffer buf;
598 buf = ByteBuffer.allocateDirect(BUFFER_LENGTH);
600 buf = ByteBuffer.allocate(BUFFER_LENGTH);
602 loadTestData1(buf);
603 buf = buf.asReadOnlyBuffer();
604 buf.clear();
605 ByteBuffer readonly = buf.asReadOnlyBuffer();
606 ByteBuffer duplicate = buf.duplicate();
607 assertEquals(buf.hashCode(),readonly.hashCode());
608 duplicate.position(buf.capacity()/2);
609 assertTrue(buf.hashCode()!= duplicate.hashCode());
619 assertFalse(buf.isDirect());
629 assertFalse(buf.isReadOnly());
640 assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
642 buf.order(ByteOrder.LITTLE_ENDIAN);
643 assertEquals(ByteOrder.LITTLE_ENDIAN, buf.order());
645 buf.order(ByteOrder.BIG_ENDIAN);
646 assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
649 buf.order((ByteOrder)null);
650 assertEquals(ByteOrder.LITTLE_ENDIAN, buf.order());
652 buf.order(ByteOrder.BIG_ENDIAN);
668 assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
670 buf.order(ByteOrder.LITTLE_ENDIAN);
671 assertEquals(ByteOrder.LITTLE_ENDIAN, buf.order());
673 buf.order(ByteOrder.BIG_ENDIAN);
674 assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
677 buf.order((ByteOrder)null);
678 assertEquals(ByteOrder.LITTLE_ENDIAN, buf.order());
680 buf.order(ByteOrder.BIG_ENDIAN);
693 if (buf.isReadOnly()) {
695 buf.clear();
696 buf.put((byte) 0);
704 buf.clear();
705 for (int i = 0; i < buf.capacity(); i++) {
706 assertEquals(i, buf.position());
707 ByteBuffer ret = buf.put((byte) i);
708 assertEquals((byte) i, buf.get(i));
709 assertSame(ret, buf);
712 buf.put((byte) 0);
718 buf.rewind();
719 buf.put(Byte.MAX_VALUE);
720 assertEquals(Byte.MAX_VALUE, buf.get(0));
721 buf.rewind();
722 buf.put(Byte.MIN_VALUE);
723 assertEquals(Byte.MIN_VALUE, buf.get(0));
737 if (buf.isReadOnly()) {
739 buf.put(array);
747 buf.clear();
748 for (int i = 0; i < buf.capacity(); i++) {
749 assertEquals(i, buf.position());
751 ByteBuffer ret = buf.put(array);
752 assertEquals((byte) i, buf.get(i));
753 assertSame(ret, buf);
756 buf.put(array);
762 buf.put((byte[])null);
779 buf.clear();
780 byte array[] = new byte[buf.capacity()];
781 if (buf.isReadOnly()) {
783 buf.put(array, 0, array.length);
792 buf.put(new byte[buf.capacity() + 1], 0, buf.capacity() + 1);
797 assertEquals(0, buf.position());
799 buf.put(array, -1, array.length);
805 buf.put(array, array.length + 1, 0);
810 buf.put(array, array.length, 0);
811 assertEquals(0, buf.position());
813 buf.put(array, 0, -1);
819 buf.put(array, 2, array.length);
826 buf.put(array, 2, Integer.MAX_VALUE);
832 buf.put(array, Integer.MAX_VALUE, 1);
838 buf.put((byte[])null, 2, Integer.MAX_VALUE);
844 assertEquals(0, buf.position());
847 ByteBuffer ret = buf.put(array, 0, array.length);
848 assertEquals(buf.position(), buf.capacity());
849 assertContentEquals(buf, array, 0, array.length);
850 assertSame(ret, buf);
863 ByteBuffer other = ByteBuffer.allocate(buf.capacity());
864 if (buf.isReadOnly()) {
866 buf.clear();
867 buf.put(other);
873 buf.clear();
874 buf.put((ByteBuffer)null);
883 buf.put(buf);
889 buf.put(ByteBuffer.allocate(buf.capacity() + 1));
896 buf.put((ByteBuffer)null);
903 buf.clear();
904 ByteBuffer ret = buf.put(other);
906 assertEquals(buf.position(), buf.capacity());
907 assertContentEquals(other, buf);
908 assertSame(ret, buf);
921 if (buf.isReadOnly()) {
923 buf.put(0, (byte) 0);
931 buf.clear();
932 for (int i = 0; i < buf.capacity(); i++) {
933 assertEquals(0, buf.position());
934 ByteBuffer ret = buf.put(i, (byte) i);
935 assertEquals((byte) i, buf.get(i));
936 assertSame(ret, buf);
939 buf.put(-1, (byte) 0);
945 buf.put(buf.limit(), (byte) 0);
951 buf.put(0, Byte.MAX_VALUE);
952 assertEquals(Byte.MAX_VALUE, buf.get(0));
953 buf.put(0, Byte.MIN_VALUE);
954 assertEquals(Byte.MIN_VALUE, buf.get(0));
964 loadTestData1(buf);
965 assertTrue(buf.capacity() > SMALL_TEST_LENGTH);
966 buf.position(1);
967 buf.limit(buf.capacity() - 1);
969 ByteBuffer slice = buf.slice();
970 assertEquals(buf.isReadOnly(), slice.isReadOnly());
971 assertEquals(buf.isDirect(), slice.isDirect());
972 assertEquals(buf.order(), slice.order());
974 assertEquals(buf.remaining(), slice.limit());
975 assertEquals(buf.remaining(), slice.capacity());
983 // slice share the same content with buf
986 assertContentLikeTestData1(buf, 1, (byte) 0, slice.capacity());
987 buf.put(2, (byte) 100);
999 String str = buf.toString();
1001 assertTrue(str.indexOf("" + buf.position()) >= 0);
1002 assertTrue(str.indexOf("" + buf.limit()) >= 0);
1003 assertTrue(str.indexOf("" + buf.capacity()) >= 0);
1016 loadTestData1(buf);
1019 buf.clear();
1020 buf.order(ByteOrder.BIG_ENDIAN);
1021 charBuffer = buf.asCharBuffer();
1024 buf.get(bytes);
1026 assertEquals(bytes2char(bytes, buf.order()), value);
1030 buf.clear();
1031 buf.order(ByteOrder.LITTLE_ENDIAN);
1032 charBuffer = buf.asCharBuffer();
1035 buf.get(bytes);
1037 assertEquals(bytes2char(bytes, buf.order()), value);
1040 if (!buf.isReadOnly()) {
1042 buf.clear();
1043 buf.order(ByteOrder.BIG_ENDIAN);
1044 charBuffer = buf.asCharBuffer();
1049 buf.get(bytes);
1050 assertTrue(Arrays.equals(bytes, char2bytes(value, buf.order())));
1054 buf.clear();
1055 buf.order(ByteOrder.LITTLE_ENDIAN);
1056 charBuffer = buf.asCharBuffer();
1061 buf.get(bytes);
1062 assertTrue(Arrays.equals(bytes, char2bytes(value, buf.order())));
1065 buf.clear();
1066 buf.order(ByteOrder.BIG_ENDIAN);
1079 loadTestData1(buf);
1082 buf.clear();
1083 buf.order(ByteOrder.BIG_ENDIAN);
1084 doubleBuffer = buf.asDoubleBuffer();
1087 buf.get(bytes);
1089 if (!(Double.isNaN(bytes2double(bytes, buf.order())) && Double
1091 assertEquals(bytes2double(bytes, buf.order()), value, 0.00);
1096 buf.clear();
1097 buf.order(ByteOrder.LITTLE_ENDIAN);
1098 doubleBuffer = buf.asDoubleBuffer();
1101 buf.get(bytes);
1103 if (!(Double.isNaN(bytes2double(bytes, buf.order())) && Double
1105 assertEquals(bytes2double(bytes, buf.order()), value, 0.00);
1109 if (!buf.isReadOnly()) {
1111 buf.clear();
1112 buf.order(ByteOrder.BIG_ENDIAN);
1113 doubleBuffer = buf.asDoubleBuffer();
1118 buf.get(bytes);
1119 assertTrue(Arrays.equals(bytes, double2bytes(value, buf.order())));
1123 buf.clear();
1124 buf.order(ByteOrder.LITTLE_ENDIAN);
1125 doubleBuffer = buf.asDoubleBuffer();
1130 buf.get(bytes);
1131 assertTrue(Arrays.equals(bytes, double2bytes(value, buf.order())));
1135 buf.clear();
1136 buf.order(ByteOrder.BIG_ENDIAN);
1149 loadTestData1(buf);
1152 buf.clear();
1153 buf.order(ByteOrder.BIG_ENDIAN);
1154 floatBuffer = buf.asFloatBuffer();
1157 buf.get(bytes);
1159 if (!(Float.isNaN(bytes2float(bytes, buf.order())) && Float
1161 assertEquals(bytes2float(bytes, buf.order()), value, 0.00);
1166 buf.clear();
1167 buf.order(ByteOrder.LITTLE_ENDIAN);
1168 floatBuffer = buf.asFloatBuffer();
1171 buf.get(bytes);
1173 if (!(Float.isNaN(bytes2float(bytes, buf.order())) && Float
1175 assertEquals(bytes2float(bytes, buf.order()), value, 0.00);
1179 if (!buf.isReadOnly()) {
1181 buf.clear();
1182 buf.order(ByteOrder.BIG_ENDIAN);
1183 floatBuffer = buf.asFloatBuffer();
1188 buf.get(bytes);
1189 assertTrue(Arrays.equals(bytes, float2bytes(value, buf.order())));
1193 buf.clear();
1194 buf.order(ByteOrder.LITTLE_ENDIAN);
1195 floatBuffer = buf.asFloatBuffer();
1200 buf.get(bytes);
1201 assertTrue(Arrays.equals(bytes, float2bytes(value, buf.order())));
1205 buf.clear();
1206 buf.order(ByteOrder.BIG_ENDIAN);
1219 loadTestData1(buf);
1222 buf.clear();
1223 buf.order(ByteOrder.BIG_ENDIAN);
1224 intBuffer = buf.asIntBuffer();
1227 buf.get(bytes);
1229 assertEquals(bytes2int(bytes, buf.order()), value);
1233 buf.clear();
1234 buf.order(ByteOrder.LITTLE_ENDIAN);
1235 intBuffer = buf.asIntBuffer();
1238 buf.get(bytes);
1240 assertEquals(bytes2int(bytes, buf.order()), value);
1243 if (!buf.isReadOnly()) {
1245 buf.clear();
1246 buf.order(ByteOrder.BIG_ENDIAN);
1247 intBuffer = buf.asIntBuffer();
1252 buf.get(bytes);
1253 assertTrue(Arrays.equals(bytes, int2bytes(value, buf.order())));
1257 buf.clear();
1258 buf.order(ByteOrder.LITTLE_ENDIAN);
1259 intBuffer = buf.asIntBuffer();
1264 buf.get(bytes);
1265 assertTrue(Arrays.equals(bytes, int2bytes(value, buf.order())));
1269 buf.clear();
1270 buf.order(ByteOrder.BIG_ENDIAN);
1283 loadTestData1(buf);
1286 buf.clear();
1287 buf.order(ByteOrder.BIG_ENDIAN);
1288 longBuffer = buf.asLongBuffer();
1291 buf.get(bytes);
1293 assertEquals(bytes2long(bytes, buf.order()), value);
1297 buf.clear();
1298 buf.order(ByteOrder.LITTLE_ENDIAN);
1299 longBuffer = buf.asLongBuffer();
1302 buf.get(bytes);
1304 assertEquals(bytes2long(bytes, buf.order()), value);
1307 if (!buf.isReadOnly()) {
1309 buf.clear();
1310 buf.order(ByteOrder.BIG_ENDIAN);
1311 longBuffer = buf.asLongBuffer();
1316 buf.get(bytes);
1317 assertTrue(Arrays.equals(bytes, long2bytes(value, buf.order())));
1321 buf.clear();
1322 buf.order(ByteOrder.LITTLE_ENDIAN);
1323 longBuffer = buf.asLongBuffer();
1328 buf.get(bytes);
1329 assertTrue(Arrays.equals(bytes, long2bytes(value, buf.order())));
1333 buf.clear();
1334 buf.order(ByteOrder.BIG_ENDIAN);
1347 loadTestData1(buf);
1350 buf.clear();
1351 buf.order(ByteOrder.BIG_ENDIAN);
1352 shortBuffer = buf.asShortBuffer();
1355 buf.get(bytes);
1357 assertEquals(bytes2short(bytes, buf.order()), value);
1361 buf.clear();
1362 buf.order(ByteOrder.LITTLE_ENDIAN);
1363 shortBuffer = buf.asShortBuffer();
1366 buf.get(bytes);
1368 assertEquals(bytes2short(bytes, buf.order()), value);
1371 if (!buf.isReadOnly()) {
1373 buf.clear();
1374 buf.order(ByteOrder.BIG_ENDIAN);
1375 shortBuffer = buf.asShortBuffer();
1380 buf.get(bytes);
1381 assertTrue(Arrays.equals(bytes, short2bytes(value, buf.order())));
1385 buf.clear();
1386 buf.order(ByteOrder.LITTLE_ENDIAN);
1387 shortBuffer = buf.asShortBuffer();
1392 buf.get(bytes);
1393 assertTrue(Arrays.equals(bytes, short2bytes(value, buf.order())));
1397 buf.clear();
1398 buf.order(ByteOrder.BIG_ENDIAN);
1411 loadTestData1(buf);
1413 buf.clear();
1414 for (int i = 0; buf.remaining() >= nbytes; i++) {
1415 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
1417 assertEquals(i * nbytes, buf.position());
1418 buf.mark();
1419 buf.get(bytes);
1420 buf.reset();
1421 value = buf.getChar();
1422 assertEquals(bytes2char(bytes, buf.order()), value);
1426 buf.getChar();
1432 buf.order(ByteOrder.BIG_ENDIAN);
1445 loadTestData1(buf);
1447 buf.clear();
1448 for (int i = 0; i <= buf.limit() - nbytes; i++) {
1449 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
1451 buf.position(i);
1452 value = buf.getChar(i);
1453 assertEquals(i, buf.position());
1454 buf.get(bytes);
1455 assertEquals(bytes2char(bytes, buf.order()), value);
1459 buf.getChar(-1);
1465 buf.getChar(buf.limit() - nbytes + 1);
1471 buf.order(ByteOrder.BIG_ENDIAN);
1481 if (buf.isReadOnly()) {
1483 buf.clear();
1484 buf.putChar((char) 1);
1495 buf.clear();
1496 for (int i = 0; buf.remaining() >= nbytes; i++) {
1497 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
1500 buf.mark();
1501 buf.putChar(value);
1502 assertEquals((i + 1) * nbytes, buf.position());
1503 buf.reset();
1504 buf.get(bytes);
1506 Arrays.equals(char2bytes(value, buf.order()), bytes));
1510 buf.putChar(value);
1516 buf.order(ByteOrder.BIG_ENDIAN);
1518 buf.rewind();
1519 buf.putChar(0, Character.MAX_VALUE);
1520 assertEquals(Character.MAX_VALUE, buf.getChar(0));
1521 buf.rewind();
1522 buf.putChar(0, Character.MIN_VALUE);
1523 assertEquals(Character.MIN_VALUE, buf.getChar(0));
1533 if (buf.isReadOnly()) {
1535 buf.putChar(0, (char) 1);
1546 buf.clear();
1547 for (int i = 0; i <= buf.limit() - nbytes; i++) {
1548 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
1551 buf.position(i);
1552 buf.putChar(i, value);
1553 assertEquals(i, buf.position());
1554 buf.get(bytes);
1556 Arrays.equals(char2bytes(value, buf.order()), bytes));
1560 buf.putChar(-1, value);
1566 buf.putChar(buf.limit() - nbytes + 1, value);
1572 buf.order(ByteOrder.BIG_ENDIAN);
1580 buf.putChar(0, Character.MAX_VALUE);
1581 assertEquals(Character.MAX_VALUE, buf.getChar(0));
1582 buf.putChar(0, Character.MIN_VALUE);
1583 assertEquals(Character.MIN_VALUE, buf.getChar(0));
1596 loadTestData1(buf);
1598 buf.clear();
1599 for (int i = 0; buf.remaining() >= nbytes; i++) {
1600 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
1602 assertEquals(i * nbytes, buf.position());
1603 buf.mark();
1604 buf.get(bytes);
1605 buf.reset();
1606 value = buf.getDouble();
1607 if (!(Double.isNaN(bytes2double(bytes, buf.order())) && Double
1609 assertEquals(bytes2double(bytes, buf.order()), value, 0.00);
1614 buf.getDouble();
1620 buf.order(ByteOrder.BIG_ENDIAN);
1633 loadTestData1(buf);
1635 buf.clear();
1636 for (int i = 0; i <= buf.limit() - nbytes; i++) {
1637 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
1639 buf.position(i);
1640 value = buf.getDouble(i);
1641 assertEquals(i, buf.position());
1642 buf.get(bytes);
1643 if (!(Double.isNaN(bytes2double(bytes, buf.order())) && Double
1645 assertEquals(bytes2double(bytes, buf.order()), value, 0.00);
1650 buf.getDouble(-1);
1656 buf.getDouble(buf.limit() - nbytes + 1);
1662 buf.order(ByteOrder.BIG_ENDIAN);
1678 if (buf.isReadOnly()) {
1680 buf.clear();
1681 buf.putDouble(1);
1692 buf.clear();
1693 for (int i = 0; buf.remaining() >= nbytes; i++) {
1694 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
1697 buf.mark();
1698 buf.putDouble(value);
1699 assertEquals((i + 1) * nbytes, buf.position());
1700 buf.reset();
1701 buf.get(bytes);
1703 Arrays.equals(double2bytes(value, buf.order()), bytes));
1707 buf.putDouble(value);
1713 buf.order(ByteOrder.BIG_ENDIAN);
1715 buf.rewind();
1716 buf.putDouble(Double.MAX_VALUE);
1717 assertEquals(Double.MAX_VALUE, buf.getDouble(0));
1718 buf.rewind();
1719 buf.putDouble(Double.MIN_VALUE);
1720 assertEquals(Double.MIN_VALUE, buf.getDouble(0));
1721 buf.rewind();
1722 buf.putDouble(Double.NaN);
1723 assertEquals(Double.NaN, buf.getDouble(0));
1724 buf.rewind();
1725 buf.putDouble(Double.NEGATIVE_INFINITY);
1726 assertEquals(Double.NEGATIVE_INFINITY, buf.getDouble(0));
1727 buf.rewind();
1728 buf.putDouble(Double.POSITIVE_INFINITY);
1729 assertEquals(Double.POSITIVE_INFINITY, buf.getDouble(0));
1739 if (buf.isReadOnly()) {
1741 buf.putDouble(0, 1);
1752 buf.clear();
1753 for (int i = 0; i <= buf.limit() - nbytes; i++) {
1754 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
1757 buf.position(i);
1758 buf.putDouble(i, value);
1759 assertEquals(i, buf.position());
1760 buf.get(bytes);
1762 Arrays.equals(double2bytes(value, buf.order()), bytes));
1766 buf.putDouble(-1, value);
1772 buf.putDouble(buf.limit() - nbytes + 1, value);
1778 buf.order(ByteOrder.BIG_ENDIAN);
1780 buf.putDouble(0, Double.MAX_VALUE);
1781 assertEquals(Double.MAX_VALUE, buf.getDouble(0));
1782 buf.putDouble(0, Double.MIN_VALUE);
1783 assertEquals(Double.MIN_VALUE, buf.getDouble(0));
1784 buf.putDouble(0, Double.NaN);
1785 assertEquals(Double.NaN, buf.getDouble(0));
1786 buf.putDouble(0, Double.NEGATIVE_INFINITY);
1787 assertEquals(Double.NEGATIVE_INFINITY, buf.getDouble(0));
1788 buf.putDouble(0, Double.POSITIVE_INFINITY);
1789 assertEquals(Double.POSITIVE_INFINITY, buf.getDouble(0));
1802 loadTestData1(buf);
1804 buf.clear();
1805 for (int i = 0; buf.remaining() >= nbytes; i++) {
1806 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
1808 assertEquals(i * nbytes, buf.position());
1809 buf.mark();
1810 buf.get(bytes);
1811 buf.reset();
1812 value = buf.getFloat();
1813 if (!(Float.isNaN(bytes2float(bytes, buf.order())) && Float
1815 assertEquals(bytes2float(bytes, buf.order()), value, 0.00);
1820 buf.getFloat();
1826 buf.order(ByteOrder.BIG_ENDIAN);
1839 loadTestData1(buf);
1841 buf.clear();
1842 for (int i = 0; i <= buf.limit() - nbytes; i++) {
1843 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
1845 buf.position(i);
1846 value = buf.getFloat(i);
1847 assertEquals(i, buf.position());
1848 buf.get(bytes);
1849 if (!(Float.isNaN(bytes2float(bytes, buf.order())) && Float
1851 assertEquals(bytes2float(bytes, buf.order()), value, 0.00);
1856 buf.getFloat(-1);
1862 buf.getFloat(buf.limit() - nbytes + 1);
1868 buf.order(ByteOrder.BIG_ENDIAN);
1878 if (buf.isReadOnly()) {
1880 buf.clear();
1881 buf.putFloat(1);
1892 buf.clear();
1893 for (int i = 0; buf.remaining() >= nbytes; i++) {
1894 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
1897 buf.mark();
1898 buf.putFloat(value);
1899 assertEquals((i + 1) * nbytes, buf.position());
1900 buf.reset();
1901 buf.get(bytes);
1903 Arrays.equals(float2bytes(value, buf.order()), bytes));
1907 buf.putFloat(value);
1913 buf.order(ByteOrder.BIG_ENDIAN);
1915 buf.rewind();
1916 buf.putFloat(Float.MAX_VALUE);
1917 assertEquals(Float.MAX_VALUE, buf.getFloat(0));
1918 buf.rewind();
1919 buf.putFloat(Float.MIN_VALUE);
1920 assertEquals(Float.MIN_VALUE, buf.getFloat(0));
1921 buf.rewind();
1922 buf.putFloat(Float.NaN);
1923 assertEquals(Float.NaN, buf.getFloat(0));
1924 buf.rewind();
1925 buf.putFloat(Float.NEGATIVE_INFINITY);
1926 assertEquals(Float.NEGATIVE_INFINITY, buf.getFloat(0));
1927 buf.rewind();
1928 buf.putFloat(Float.POSITIVE_INFINITY);
1929 assertEquals(Float.POSITIVE_INFINITY, buf.getFloat(0));
1939 if (buf.isReadOnly()) {
1941 buf.putFloat(0, 1);
1952 buf.clear();
1953 for (int i = 0; i <= buf.limit() - nbytes; i++) {
1954 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
1957 buf.position(i);
1958 buf.putFloat(i, value);
1959 assertEquals(i, buf.position());
1960 buf.get(bytes);
1962 Arrays.equals(float2bytes(value, buf.order()), bytes));
1966 buf.putFloat(-1, value);
1972 buf.putFloat(buf.limit() - nbytes + 1, value);
1978 buf.order(ByteOrder.BIG_ENDIAN);
1980 buf.putFloat(0, Float.MAX_VALUE);
1981 assertEquals(Float.MAX_VALUE, buf.getFloat(0));
1982 buf.putFloat(0, Float.MIN_VALUE);
1983 assertEquals(Float.MIN_VALUE, buf.getFloat(0));
1984 buf.putFloat(0, Float.NaN);
1985 assertEquals(Float.NaN, buf.getFloat(0));
1986 buf.putFloat(0, Float.NEGATIVE_INFINITY);
1987 assertEquals(Float.NEGATIVE_INFINITY, buf.getFloat(0));
1988 buf.putFloat(0, Float.POSITIVE_INFINITY);
1989 assertEquals(Float.POSITIVE_INFINITY, buf.getFloat(0));
2002 loadTestData1(buf);
2004 buf.clear();
2005 for (int i = 0; buf.remaining() >= nbytes; i++) {
2006 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
2008 assertEquals(i * nbytes, buf.position());
2009 buf.mark();
2010 buf.get(bytes);
2011 buf.reset();
2012 value = buf.getInt();
2013 assertEquals(bytes2int(bytes, buf.order()), value);
2017 buf.getInt();
2023 buf.order(ByteOrder.BIG_ENDIAN);
2036 loadTestData1(buf);
2038 buf.clear();
2039 for (int i = 0; i <= buf.limit() - nbytes; i++) {
2040 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
2042 buf.position(i);
2043 value = buf.getInt(i);
2044 assertEquals(i, buf.position());
2045 buf.get(bytes);
2046 assertEquals(bytes2int(bytes, buf.order()), value);
2050 buf.getInt(-1);
2056 buf.getInt(buf.limit() - nbytes + 1);
2062 buf.order(ByteOrder.BIG_ENDIAN);
2077 if (buf.isReadOnly()) {
2079 buf.clear();
2080 buf.putInt(1);
2091 buf.clear();
2092 for (int i = 0; buf.remaining() >= nbytes; i++) {
2093 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
2096 buf.mark();
2097 buf.putInt(value);
2098 assertEquals((i + 1) * nbytes, buf.position());
2099 buf.reset();
2100 buf.get(bytes);
2102 Arrays.equals(int2bytes(value, buf.order()), bytes));
2106 buf.putInt(value);
2112 buf.order(ByteOrder.BIG_ENDIAN);
2114 buf.rewind();
2115 buf.putInt(Integer.MAX_VALUE);
2116 assertEquals(Integer.MAX_VALUE, buf.getInt(0));
2117 buf.rewind();
2118 buf.putInt(Integer.MIN_VALUE);
2119 assertEquals(Integer.MIN_VALUE, buf.getInt(0));
2129 if (buf.isReadOnly()) {
2131 buf.putInt(0, 1);
2142 buf.clear();
2143 for (int i = 0; i <= buf.limit() - nbytes; i++) {
2144 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
2147 buf.position(i);
2148 buf.putInt(i, value);
2149 assertEquals(i, buf.position());
2150 buf.get(bytes);
2152 Arrays.equals(int2bytes(value, buf.order()), bytes));
2156 buf.putInt(-1, value);
2162 buf.putInt(buf.limit() - nbytes + 1, value);
2168 buf.order(ByteOrder.BIG_ENDIAN);
2170 buf.putInt(0, Integer.MAX_VALUE);
2171 assertEquals(Integer.MAX_VALUE, buf.getInt(0));
2172 buf.putInt(0, Integer.MIN_VALUE);
2173 assertEquals(Integer.MIN_VALUE, buf.getInt(0));
2186 loadTestData1(buf);
2188 buf.clear();
2189 for (int i = 0; buf.remaining() >= nbytes; i++) {
2190 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
2192 assertEquals(i * nbytes, buf.position());
2193 buf.mark();
2194 buf.get(bytes);
2195 buf.reset();
2196 value = buf.getLong();
2197 assertEquals(bytes2long(bytes, buf.order()), value);
2201 buf.getLong();
2207 buf.order(ByteOrder.BIG_ENDIAN);
2220 loadTestData1(buf);
2222 buf.clear();
2223 for (int i = 0; i <= buf.limit() - nbytes; i++) {
2224 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
2226 buf.position(i);
2227 value = buf.getLong(i);
2228 assertEquals(i, buf.position());
2229 buf.get(bytes);
2230 assertEquals(bytes2long(bytes, buf.order()), value);
2234 buf.getLong(-1);
2240 buf.getLong(buf.limit() - nbytes + 1);
2246 buf.order(ByteOrder.BIG_ENDIAN);
2256 if (buf.isReadOnly()) {
2258 buf.clear();
2259 buf.putLong(1);
2270 buf.clear();
2271 for (int i = 0; buf.remaining() >= nbytes; i++) {
2272 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
2275 buf.mark();
2276 buf.putLong(value);
2277 assertEquals((i + 1) * nbytes, buf.position());
2278 buf.reset();
2279 buf.get(bytes);
2281 Arrays.equals(long2bytes(value, buf.order()), bytes));
2285 buf.putLong(value);
2291 buf.order(ByteOrder.BIG_ENDIAN);
2293 buf.rewind();
2294 buf.putLong(Long.MAX_VALUE);
2295 assertEquals(Long.MAX_VALUE, buf.getLong(0));
2296 buf.rewind();
2297 buf.putLong(Long.MIN_VALUE);
2298 assertEquals(Long.MIN_VALUE, buf.getLong(0));
2308 if (buf.isReadOnly()) {
2310 buf.putLong(0, 1);
2321 buf.clear();
2322 for (int i = 0; i <= buf.limit() - nbytes; i++) {
2323 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
2326 buf.position(i);
2327 buf.putLong(i, value);
2328 assertEquals(i, buf.position());
2329 buf.get(bytes);
2331 Arrays.equals(long2bytes(value, buf.order()), bytes));
2335 buf.putLong(-1, value);
2341 buf.putLong(buf.limit() - nbytes + 1, value);
2347 buf.order(ByteOrder.BIG_ENDIAN);
2349 buf.putLong(0, Long.MAX_VALUE);
2350 assertEquals(Long.MAX_VALUE, buf.getLong(0));
2351 buf.putLong(0, Long.MIN_VALUE);
2352 assertEquals(Long.MIN_VALUE, buf.getLong(0));
2365 loadTestData1(buf);
2367 buf.clear();
2368 for (int i = 0; buf.remaining() >= nbytes; i++) {
2369 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
2371 assertEquals(i * nbytes, buf.position());
2372 buf.mark();
2373 buf.get(bytes);
2374 buf.reset();
2375 value = buf.getShort();
2376 assertEquals(bytes2short(bytes, buf.order()), value);
2380 buf.getShort();
2386 buf.order(ByteOrder.BIG_ENDIAN);
2399 loadTestData1(buf);
2401 buf.clear();
2402 for (int i = 0; i <= buf.limit() - nbytes; i++) {
2403 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
2405 buf.position(i);
2406 value = buf.getShort(i);
2407 assertEquals(i, buf.position());
2408 buf.get(bytes);
2409 assertEquals(bytes2short(bytes, buf.order()), value);
2413 buf.getShort(-1);
2419 buf.getShort(buf.limit() - nbytes + 1);
2425 buf.order(ByteOrder.BIG_ENDIAN);
2435 if (buf.isReadOnly()) {
2437 buf.clear();
2438 buf.putShort((short) 1);
2449 buf.clear();
2450 for (int i = 0; buf.remaining() >= nbytes; i++) {
2451 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
2454 buf.mark();
2455 buf.putShort(value);
2456 assertEquals((i + 1) * nbytes, buf.position());
2457 buf.reset();
2458 buf.get(bytes);
2460 Arrays.equals(short2bytes(value, buf.order()), bytes));
2464 buf.putShort(value);
2470 buf.order(ByteOrder.BIG_ENDIAN);
2472 buf.rewind();
2473 buf.putShort(Short.MAX_VALUE);
2474 assertEquals(Short.MAX_VALUE, buf.getShort(0));
2475 buf.rewind();
2476 buf.putShort(Short.MIN_VALUE);
2477 assertEquals(Short.MIN_VALUE, buf.getShort(0));
2487 if (buf.isReadOnly()) {
2489 buf.putShort(0, (short) 1);
2500 buf.clear();
2501 for (int i = 0; i <= buf.limit() - nbytes; i++) {
2502 buf.order(i % 2 == 0 ? ByteOrder.BIG_ENDIAN
2505 buf.position(i);
2506 buf.putShort(i, value);
2507 assertEquals(i, buf.position());
2508 buf.get(bytes);
2510 Arrays.equals(short2bytes(value, buf.order()), bytes));
2514 buf.putShort(-1, value);
2520 buf.putShort(buf.limit() - nbytes + 1, value);
2526 buf.order(ByteOrder.BIG_ENDIAN);
2528 buf.putShort(0, Short.MAX_VALUE);
2529 assertEquals(Short.MAX_VALUE, buf.getShort(0));
2530 buf.putShort(0, Short.MIN_VALUE);
2531 assertEquals(Short.MIN_VALUE, buf.getShort(0));
2585 loadTestData2(array, 0, buf.capacity());
2620 loadTestData2(array, 0, buf.capacity());
2645 protected void loadTestData1(ByteBuffer buf) {
2646 if (buf.isReadOnly()) {
2649 buf.clear();
2650 for (int i = 0; i < buf.capacity(); i++) {
2651 buf.put(i, (byte) i);
2655 protected void loadTestData2(ByteBuffer buf) {
2656 buf.clear();
2657 for (int i = 0; i < buf.capacity(); i++) {
2658 buf.put(i, (byte) (buf.capacity() - i));
2662 private void assertContentEquals(ByteBuffer buf, byte array[],
2665 assertEquals(array[offset + i], buf.get(i));
2669 private void assertContentEquals(ByteBuffer buf, ByteBuffer other) {
2670 assertEquals(buf.capacity(), other.capacity());
2671 for (int i = 0; i < buf.capacity(); i++) {
2672 assertEquals(buf.get(i), other.get(i));
2676 private void assertContentLikeTestData1(ByteBuffer buf,
2680 assertEquals(buf.get(startIndex + i), value);