1 /*
2 * Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /* Type-specific source code for unit test
25 *
26 * Regenerate the BasicX classes via genBasic.sh whenever this file changes.
27 * We check in the generated source files so that the test tree can be used
28 * independently of the rest of the source tree.
29 */
30
31 // -- This file was mechanically generated: Do not edit! -- //
32
33 import java.nio.*;
34
35
36 public class BasicByte
37 extends Basic
38 {
39
40 private static final byte[] VALUES = {
41 Byte.MIN_VALUE,
42 (byte) -1,
43 (byte) 0,
44 (byte) 1,
45 Byte.MAX_VALUE,
46
47
48
49
50
51
52
53
54
55
56
57
58 };
59
60 private static void relGet(ByteBuffer b) {
61 int n = b.capacity();
62 for (int i = 0; i < n; i++)
63 ck(b, (long)b.get(), (long)((byte)ic(i)));
64 b.rewind();
65 }
66
67 private static void relGet(ByteBuffer b, int start) {
68 int n = b.remaining();
69 for (int i = start; i < n; i++)
70 ck(b, (long)b.get(), (long)((byte)ic(i)));
71 b.rewind();
72 }
73
74 private static void absGet(ByteBuffer b) {
75 int n = b.capacity();
76 for (int i = 0; i < n; i++)
77 ck(b, (long)b.get(), (long)((byte)ic(i)));
78 b.rewind();
79 }
80
81 private static void bulkGet(ByteBuffer b) {
82 int n = b.capacity();
83 byte[] a = new byte[n + 7];
84 b.get(a, 7, n);
85 for (int i = 0; i < n; i++) {
86 ck(b, (long)a[i + 7], (long)((byte)ic(i)));
87 }
88 }
89
90 private static void absBulkGet(ByteBuffer b) {
91 int n = b.capacity();
92 int len = n - 7*2;
93 byte[] a = new byte[n + 7];
94 b.position(42);
95 b.get(7, a, 7, len);
96 ck(b, b.position() == 42);
97 for (int i = 0; i < len; i++) {
98 ck(b, (long)a[i + 7], (long)((byte)ic(i)));
99 }
100 }
101
102 private static void relPut(ByteBuffer b) {
103 int n = b.capacity();
104 b.clear();
105 for (int i = 0; i < n; i++)
106 b.put((byte)ic(i));
107 b.flip();
108 }
109
110 private static void absPut(ByteBuffer b) {
111 int n = b.capacity();
112 b.clear();
113 for (int i = 0; i < n; i++)
114 b.put(i, (byte)ic(i));
115 b.limit(n);
116 b.position(0);
117 }
118
119 private static void bulkPutArray(ByteBuffer b) {
120 int n = b.capacity();
121 b.clear();
122 byte[] a = new byte[n + 7];
123 for (int i = 0; i < n; i++)
124 a[i + 7] = (byte)ic(i);
125 b.put(a, 7, n);
126 b.flip();
127 }
128
129 private static void bulkPutBuffer(ByteBuffer b) {
130 int n = b.capacity();
131 b.clear();
132 ByteBuffer c = ByteBuffer.allocate(n + 7);
133 c.position(7);
134 for (int i = 0; i < n; i++)
135 c.put((byte)ic(i));
136 c.flip();
137 c.position(7);
138 b.put(c);
139 b.flip();
140 try {
141 b.put(b);
142 fail("IllegalArgumentException expected for put into same buffer");
143 } catch (IllegalArgumentException e) {
144 if (e.getMessage() == null) {
145 fail("Non-null IllegalArgumentException message expected from"
146 + " put into same buffer");
147 }
148 }
149 }
150
151 private static void absBulkPutArray(ByteBuffer b) {
152 int n = b.capacity();
153 b.clear();
154 int lim = n - 7;
155 int len = lim - 7;
156 b.limit(lim);
157 byte[] a = new byte[len + 7];
158 for (int i = 0; i < len; i++)
159 a[i + 7] = (byte)ic(i);
160 b.position(42);
161 b.put(7, a, 7, len);
162 ck(b, b.position() == 42);
163 }
164
165 //6231529
166 private static void callReset(ByteBuffer b) {
167 b.position(0);
168 b.mark();
169
170 b.duplicate().reset();
171 b.asReadOnlyBuffer().reset();
172 }
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214 private static void checkSlice(ByteBuffer b, ByteBuffer slice) {
215 ck(slice, 0, slice.position());
216 ck(slice, b.remaining(), slice.limit());
217 ck(slice, b.remaining(), slice.capacity());
218 if (b.isDirect() != slice.isDirect())
219 fail("Lost direction", slice);
220 if (b.isReadOnly() != slice.isReadOnly())
221 fail("Lost read-only", slice);
222 }
223
224
225
226 private static void checkBytes(ByteBuffer b, byte[] bs) {
227 int n = bs.length;
228 int p = b.position();
229 if (b.order() == ByteOrder.BIG_ENDIAN) {
230 for (int i = 0; i < n; i++) {
231 ck(b, b.get(), bs[i]);
232 }
233 } else {
234 for (int i = n - 1; i >= 0; i--) {
235 ck(b, b.get(), bs[i]);
236 }
237 }
238 b.position(p);
239 }
240
241 private static void compact(Buffer b) {
242 try {
243 Class<?> cl = b.getClass();
244 java.lang.reflect.Method m = cl.getDeclaredMethod("compact");
245 m.setAccessible(true);
246 m.invoke(b);
247 } catch (Exception e) {
248 fail(e.getMessage(), b);
249 }
250 }
251
252 private static void checkInvalidMarkException(final Buffer b) {
253 tryCatch(b, InvalidMarkException.class, () -> {
254 b.mark();
255 compact(b);
256 b.reset();
257 });
258 }
259
260 private static void testViews(int level, ByteBuffer b, boolean direct) {
261
262 ShortBuffer sb = b.asShortBuffer();
263 BasicShort.test(level, sb, direct);
264 checkBytes(b, new byte[] { 0, (byte)ic(0) });
265 checkInvalidMarkException(sb);
266
267 CharBuffer cb = b.asCharBuffer();
268 BasicChar.test(level, cb, direct);
269 checkBytes(b, new byte[] { 0, (byte)ic(0) });
270 checkInvalidMarkException(cb);
271
272 IntBuffer ib = b.asIntBuffer();
273 BasicInt.test(level, ib, direct);
274 checkBytes(b, new byte[] { 0, 0, 0, (byte)ic(0) });
275 checkInvalidMarkException(ib);
276
277 LongBuffer lb = b.asLongBuffer();
278 BasicLong.test(level, lb, direct);
279 checkBytes(b, new byte[] { 0, 0, 0, 0, 0, 0, 0, (byte)ic(0) });
280 checkInvalidMarkException(lb);
281
282 FloatBuffer fb = b.asFloatBuffer();
283 BasicFloat.test(level, fb, direct);
284 checkBytes(b, new byte[] { 0x42, (byte)0xc2, 0, 0 });
285 checkInvalidMarkException(fb);
286
287 DoubleBuffer db = b.asDoubleBuffer();
288 BasicDouble.test(level, db, direct);
289 checkBytes(b, new byte[] { 0x40, 0x58, 0x40, 0, 0, 0, 0, 0 });
290 checkInvalidMarkException(db);
291 }
292
293 private static void testHet(int level, ByteBuffer b) {
294
295 int p = b.position();
296 b.limit(b.capacity());
297 show(level, b);
298 out.print(" put:");
299
300 b.putChar((char)1);
301 b.putChar((char)Character.MAX_VALUE);
302 out.print(" char");
303
304 b.putShort((short)1);
305 b.putShort((short)Short.MAX_VALUE);
306 out.print(" short");
307
308 b.putInt(1);
309 b.putInt(Integer.MAX_VALUE);
310 out.print(" int");
311
312 b.putLong((long)1);
313 b.putLong((long)Long.MAX_VALUE);
314 out.print(" long");
315
316 b.putFloat((float)1);
317 b.putFloat((float)Float.MIN_VALUE);
318 b.putFloat((float)Float.MAX_VALUE);
319 out.print(" float");
320
321 b.putDouble((double)1);
322 b.putDouble((double)Double.MIN_VALUE);
323 b.putDouble((double)Double.MAX_VALUE);
324 out.print(" double");
325
326 out.println();
327 b.limit(b.position());
328 b.position(p);
329 show(level, b);
330 out.print(" get:");
331
332 ck(b, b.getChar(), 1);
333 ck(b, b.getChar(), Character.MAX_VALUE);
334 out.print(" char");
335
336 ck(b, b.getShort(), 1);
337 ck(b, b.getShort(), Short.MAX_VALUE);
338 out.print(" short");
339
340 ck(b, b.getInt(), 1);
341 ck(b, b.getInt(), Integer.MAX_VALUE);
342 out.print(" int");
343
344 ck(b, b.getLong(), 1);
345 ck(b, b.getLong(), Long.MAX_VALUE);
346 out.print(" long");
347
348 ck(b, (long)b.getFloat(), 1);
349 ck(b, (long)b.getFloat(), (long)Float.MIN_VALUE);
350 ck(b, (long)b.getFloat(), (long)Float.MAX_VALUE);
351 out.print(" float");
352
353 ck(b, (long)b.getDouble(), 1);
354 ck(b, (long)b.getDouble(), (long)Double.MIN_VALUE);
355 ck(b, (long)b.getDouble(), (long)Double.MAX_VALUE);
356 out.print(" double");
357
358 out.println();
359
360 }
361
362 private static void testAlign(final ByteBuffer b, boolean direct) {
363 // index out-of bounds
364 catchIllegalArgument(b, () -> b.alignmentOffset(-1, (short) 1));
365
366 // unit size values
367 catchIllegalArgument(b, () -> b.alignmentOffset(0, (short) 0));
368 for (int us = 1; us < 65; us++) {
369 int _us = us;
370 if ((us & (us - 1)) != 0) {
371 // unit size not a power of two
372 catchIllegalArgument(b, () -> b.alignmentOffset(0, _us));
373 } else {
374 if (direct || us <= 8) {
375 b.alignmentOffset(0, us);
376 } else {
377 // unit size > 8 with non-direct buffer
378 tryCatch(b, UnsupportedOperationException.class,
379 () -> b.alignmentOffset(0, _us));
380 }
381 }
382 }
383
384 // Probe for long misalignment at index zero for a newly created buffer
385 ByteBuffer empty =
386 direct ? ByteBuffer.allocateDirect(0) : ByteBuffer.allocate(0);
387 int longMisalignmentAtZero = empty.alignmentOffset(0, 8);
388
389 if (direct) {
390 // Freshly created direct byte buffers should be aligned at index 0
391 // for ref and primitive values (see Unsafe.allocateMemory)
392 if (longMisalignmentAtZero != 0) {
393 fail("Direct byte buffer misaligned at index 0"
394 + " for ref and primitive values "
395 + longMisalignmentAtZero);
396 }
397 } else {
398 // For heap byte buffers misalignment may occur on 32-bit systems
399 // where Unsafe.ARRAY_BYTE_BASE_OFFSET % 8 == 4 and not 0
400 // Note the GC will preserve alignment of the base address of the
401 // array
402 if (jdk.internal.misc.Unsafe.ARRAY_BYTE_BASE_OFFSET % 8
403 != longMisalignmentAtZero) {
404 fail("Heap byte buffer misaligned at index 0"
405 + " for ref and primitive values "
406 + longMisalignmentAtZero);
407 }
408 }
409
410 // Ensure test buffer is correctly aligned at index 0
411 if (b.alignmentOffset(0, 8) != longMisalignmentAtZero)
412 fail("Test input buffer not correctly aligned at index 0", b);
413
414 // Test misalignment values
415 for (int us : new int[]{1, 2, 4, 8}) {
416 for (int i = 0; i < us * 2; i++) {
417 int am = b.alignmentOffset(i, us);
418 int expectedAm = (longMisalignmentAtZero + i) % us;
419
420 if (am != expectedAm) {
421 String f = "b.alignmentOffset(%d, %d) == %d incorrect, expected %d";
422 fail(String.format(f, i, us, am, expectedAm));
423 }
424 }
425 }
426
427 // Created aligned slice to test against
428 int ap = 8 - longMisalignmentAtZero;
429 int al = b.limit() - b.alignmentOffset(b.limit(), 8);
430 ByteBuffer ab = b.position(ap).limit(al).
431 slice();
432 if (ab.limit() == 0) {
433 fail("Test input buffer not sufficiently sized to cover" +
434 " an aligned region for all values", b);
435 }
436 if (ab.alignmentOffset(0, 8) != 0)
437 fail("Aligned test input buffer not correctly aligned at index 0", ab);
438
439 for (int us : new int[]{1, 2, 4, 8}) {
440 for (int p = 1; p < 16; p++) {
441 int l = ab.limit() - p;
442
443 ByteBuffer as = ab.slice().position(p).limit(l).
444 alignedSlice(us);
445
446 ck(as, 0, as.position());
447 ck(as, as.capacity(), as.limit());
448 if (b.isDirect() != as.isDirect())
449 fail("Lost direction", as);
450 if (b.isReadOnly() != as.isReadOnly())
451 fail("Lost read-only", as);
452
453 if (as.alignmentOffset(0, us) != 0)
454 fail("Buffer not correctly aligned at index 0", as);
455
456 if (as.alignmentOffset(as.limit(), us) != 0)
457 fail("Buffer not correctly aligned at limit", as);
458
459 int p_mod = ab.alignmentOffset(p, us);
460 int l_mod = ab.alignmentOffset(l, us);
461 // Round up position
462 p = (p_mod > 0) ? p + (us - p_mod) : p;
463 // Round down limit
464 l = l - l_mod;
465
466 int ec = l - p;
467 if (as.limit() != ec) {
468 fail("Buffer capacity incorrect, expected: " + ec, as);
469 }
470 }
471 }
472 }
473
474
475 private static void fail(String problem,
476 ByteBuffer xb, ByteBuffer yb,
477 byte x, byte y) {
478 fail(problem + String.format(": x=%s y=%s", x, y), xb, yb);
479 }
480
481 private static void catchNullArgument(Buffer b, Runnable thunk) {
482 tryCatch(b, NullPointerException.class, thunk);
483 }
484
485 private static void catchIllegalArgument(Buffer b, Runnable thunk) {
486 tryCatch(b, IllegalArgumentException.class, thunk);
487 }
488
489 private static void catchReadOnlyBuffer(Buffer b, Runnable thunk) {
490 tryCatch(b, ReadOnlyBufferException.class, thunk);
491 }
492
493 private static void catchIndexOutOfBounds(Buffer b, Runnable thunk) {
494 tryCatch(b, IndexOutOfBoundsException.class, thunk);
495 }
496
497 private static void catchIndexOutOfBounds(byte[] t, Runnable thunk) {
498 tryCatch(t, IndexOutOfBoundsException.class, thunk);
499 }
500
501 private static void tryCatch(Buffer b, Class<?> ex, Runnable thunk) {
502 boolean caught = false;
503 try {
504 thunk.run();
505 } catch (Throwable x) {
506 if (ex.isAssignableFrom(x.getClass())) {
507 caught = true;
508 } else {
509 String s = x.getMessage();
510 if (s == null)
511 s = x.getClass().getName();
512 fail(s + " not expected");
513 }
514 }
515 if (!caught) {
516 fail(ex.getName() + " not thrown", b);
517 }
518 }
519
520 private static void tryCatch(byte[] t, Class<?> ex, Runnable thunk) {
521 tryCatch(ByteBuffer.wrap(t), ex, thunk);
522 }
523
524 public static void test(int level, final ByteBuffer b, boolean direct) {
525
526 show(level, b);
527
528 if (direct != b.isDirect())
529 fail("Wrong direction", b);
530
531 // Gets and puts
532
533 relPut(b);
534 relGet(b);
535 absGet(b);
536 bulkGet(b);
537
538 absPut(b);
539 relGet(b);
540 absGet(b);
541 bulkGet(b);
542
543 bulkPutArray(b);
544 relGet(b);
545
546 bulkPutBuffer(b);
547 relGet(b);
548
549 absBulkPutArray(b);
550 absBulkGet(b);
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588 // Compact
589
590 relPut(b);
591 b.position(13);
592 b.compact();
593 b.flip();
594 relGet(b, 13);
595
596 // Exceptions
597
598 relPut(b);
599 b.limit(b.capacity() / 2);
600 b.position(b.limit());
601
602 tryCatch(b, BufferUnderflowException.class, () -> b.get());
603 tryCatch(b, BufferOverflowException.class, () -> b.put((byte)42));
604 // The index must be non-negative and less than the buffer's limit.
605 catchIndexOutOfBounds(b, () -> b.get(b.limit()));
606 catchIndexOutOfBounds(b, () -> b.get(-1));
607 catchIndexOutOfBounds(b, () -> b.put(b.limit(), (byte)42));
608 tryCatch(b, InvalidMarkException.class,
609 () -> b.position(0).mark().compact().reset());
610
611 try {
612 b.position(b.limit() + 1);
613 fail("IllegalArgumentException expected for position beyond limit");
614 } catch (IllegalArgumentException e) {
615 if (e.getMessage() == null) {
616 fail("Non-null IllegalArgumentException message expected for"
617 + " position beyond limit");
618 }
619 }
620
621 try {
622 b.position(-1);
623 fail("IllegalArgumentException expected for negative position");
624 } catch (IllegalArgumentException e) {
625 if (e.getMessage() == null) {
626 fail("Non-null IllegalArgumentException message expected for"
627 + " negative position");
628 }
629 }
630
631 try {
632 b.limit(b.capacity() + 1);
633 fail("IllegalArgumentException expected for limit beyond capacity");
634 } catch (IllegalArgumentException e) {
635 if (e.getMessage() == null) {
636 fail("Non-null IllegalArgumentException message expected for"
637 + " limit beyond capacity");
638 }
639 }
640
641 try {
642 b.limit(-1);
643 fail("IllegalArgumentException expected for negative limit");
644 } catch (IllegalArgumentException e) {
645 if (e.getMessage() == null) {
646 fail("Non-null IllegalArgumentException message expected for"
647 + " negative limit");
648 }
649 }
650
651 // Exceptions in absolute bulk and slice operations
652
653 catchNullArgument(b, () -> b.get(7, null, 0, 42));
654 catchNullArgument(b, () -> b.put(7, (byte[])null, 0, 42));
655
656 byte[] tmpa = new byte[42];
657 catchIndexOutOfBounds(b, () -> b.get(7, tmpa, -1, 42));
658 catchIndexOutOfBounds(b, () -> b.get(7, tmpa, 42, 1));
659 catchIndexOutOfBounds(b, () -> b.get(7, tmpa, 41, -1));
660 catchIndexOutOfBounds(b, () -> b.get(-1, tmpa, 0, 1));
661 catchIndexOutOfBounds(b, () -> b.get(b.limit(), tmpa, 0, 1));
662 catchIndexOutOfBounds(b, () -> b.get(b.limit() - 41, tmpa, 0, 42));
663
664 catchIndexOutOfBounds(b, () -> b.put(7, tmpa, -1, 42));
665 catchIndexOutOfBounds(b, () -> b.put(7, tmpa, 42, 1));
666 catchIndexOutOfBounds(b, () -> b.put(7, tmpa, 41, -1));
667 catchIndexOutOfBounds(b, () -> b.put(-1, tmpa, 0, 1));
668 catchIndexOutOfBounds(b, () -> b.put(b.limit(), tmpa, 0, 1));
669 catchIndexOutOfBounds(b, () -> b.put(b.limit() - 41, tmpa, 0, 42));
670
671 catchIndexOutOfBounds(b, () -> b.slice(-1, 7));
672 catchIndexOutOfBounds(b, () -> b.slice(b.limit() + 1, 7));
673 catchIndexOutOfBounds(b, () -> b.slice(0, -1));
674 catchIndexOutOfBounds(b, () -> b.slice(7, b.limit() - 7 + 1));
675
676 // Values
677
678 b.clear();
679 b.put((byte)0);
680 b.put((byte)-1);
681 b.put((byte)1);
682 b.put(Byte.MAX_VALUE);
683 b.put(Byte.MIN_VALUE);
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701 b.flip();
702 ck(b, b.get(), 0);
703 ck(b, b.get(), (byte)-1);
704 ck(b, b.get(), 1);
705 ck(b, b.get(), Byte.MAX_VALUE);
706 ck(b, b.get(), Byte.MIN_VALUE);
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734 // Comparison
735 b.rewind();
736 ByteBuffer b2 = ByteBuffer.allocate(b.capacity());
737 b2.put(b);
738 b2.flip();
739 b.position(2);
740 b2.position(2);
741 if (!b.equals(b2)) {
742 for (int i = 2; i < b.limit(); i++) {
743 byte x = b.get(i);
744 byte y = b2.get(i);
745 if (x != y
746
747
748
749
750
751
752 ) {
753 out.println("[" + i + "] " + x + " != " + y);
754 }
755 }
756 fail("Identical buffers not equal", b, b2);
757 }
758 if (b.compareTo(b2) != 0) {
759 fail("Comparison to identical buffer != 0", b, b2);
760 }
761 b.limit(b.limit() + 1);
762 b.position(b.limit() - 1);
763 b.put((byte)99);
764 b.rewind();
765 b2.rewind();
766 if (b.equals(b2))
767 fail("Non-identical buffers equal", b, b2);
768 if (b.compareTo(b2) <= 0)
769 fail("Comparison to shorter buffer <= 0", b, b2);
770 b.limit(b.limit() - 1);
771
772 b.put(2, (byte)42);
773 if (b.equals(b2))
774 fail("Non-identical buffers equal", b, b2);
775 if (b.compareTo(b2) <= 0)
776 fail("Comparison to lesser buffer <= 0", b, b2);
777
778 // Check equals and compareTo with interesting values
779 for (byte x : VALUES) {
780 ByteBuffer xb = ByteBuffer.wrap(new byte[] { x });
781 if (xb.compareTo(xb) != 0) {
782 fail("compareTo not reflexive", xb, xb, x, x);
783 }
784 if (!xb.equals(xb)) {
785 fail("equals not reflexive", xb, xb, x, x);
786 }
787 for (byte y : VALUES) {
788 ByteBuffer yb = ByteBuffer.wrap(new byte[] { y });
789 if (xb.compareTo(yb) != - yb.compareTo(xb)) {
790 fail("compareTo not anti-symmetric",
791 xb, yb, x, y);
792 }
793 if ((xb.compareTo(yb) == 0) != xb.equals(yb)) {
794 fail("compareTo inconsistent with equals",
795 xb, yb, x, y);
796 }
797 if (xb.compareTo(yb) != Byte.compare(x, y)) {
798
799
800
801
802
803
804 fail("Incorrect results for ByteBuffer.compareTo",
805 xb, yb, x, y);
806 }
807 if (xb.equals(yb) != ((x == y) || ((x != x) && (y != y)))) {
808 fail("Incorrect results for ByteBuffer.equals",
809 xb, yb, x, y);
810 }
811 }
812 }
813
814 // Sub, dup
815
816 relPut(b);
817 relGet(b.duplicate());
818 b.position(13);
819 relGet(b.duplicate(), 13);
820 relGet(b.duplicate().slice(), 13);
821 relGet(b.slice(), 13);
822 relGet(b.slice().duplicate(), 13);
823
824 // Slice
825
826 b.position(5);
827 ByteBuffer sb = b.slice();
828 checkSlice(b, sb);
829 b.position(0);
830 ByteBuffer sb2 = sb.slice();
831 checkSlice(sb, sb2);
832
833 if (!sb.equals(sb2))
834 fail("Sliced slices do not match", sb, sb2);
835 if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset())) {
836 fail("Array offsets do not match: "
837 + sb.arrayOffset() + " != " + sb2.arrayOffset(), sb, sb2);
838 }
839
840 int bPos = b.position();
841 int bLim = b.limit();
842
843 b.position(7);
844 b.limit(42);
845 ByteBuffer rsb = b.slice();
846 b.position(0);
847 b.limit(b.capacity());
848 ByteBuffer asb = b.slice(7, 35);
849 checkSlice(rsb, asb);
850
851 b.position(bPos);
852 b.limit(bLim);
853
854
855
856 // Views
857
858 b.clear();
859 b.order(ByteOrder.BIG_ENDIAN);
860 testViews(level + 1, b, direct);
861
862 for (int i = 1; i <= 9; i++) {
863 b.position(i);
864 show(level + 1, b);
865 testViews(level + 2, b, direct);
866 }
867
868 b.position(0);
869 b.order(ByteOrder.LITTLE_ENDIAN);
870 testViews(level + 1, b, direct);
871
872 // Heterogeneous accessors
873
874 b.order(ByteOrder.BIG_ENDIAN);
875 for (int i = 0; i <= 9; i++) {
876 b.position(i);
877 testHet(level + 1, b);
878 }
879 b.order(ByteOrder.LITTLE_ENDIAN);
880 b.position(3);
881 testHet(level + 1, b);
882
883
884
885 // Read-only views
886
887 b.rewind();
888 final ByteBuffer rb = b.asReadOnlyBuffer();
889 if (!b.equals(rb))
890 fail("Buffer not equal to read-only view", b, rb);
891 show(level + 1, rb);
892
893 catchReadOnlyBuffer(b, () -> relPut(rb));
894 catchReadOnlyBuffer(b, () -> absPut(rb));
895 catchReadOnlyBuffer(b, () -> bulkPutArray(rb));
896 catchReadOnlyBuffer(b, () -> bulkPutBuffer(rb));
897 catchReadOnlyBuffer(b, () -> absBulkPutArray(rb));
898
899 // put(ByteBuffer) should not change source position
900 final ByteBuffer src = ByteBuffer.allocate(1);
901 catchReadOnlyBuffer(b, () -> rb.put(src));
902 ck(src, src.position(), 0);
903
904 catchReadOnlyBuffer(b, () -> rb.compact());
905
906
907
908 catchReadOnlyBuffer(b, () -> rb.putChar((char)1));
909 catchReadOnlyBuffer(b, () -> rb.putChar(0, (char)1));
910 catchReadOnlyBuffer(b, () -> rb.putShort((short)1));
911 catchReadOnlyBuffer(b, () -> rb.putShort(0, (short)1));
912 catchReadOnlyBuffer(b, () -> rb.putInt(1));
913 catchReadOnlyBuffer(b, () -> rb.putInt(0, 1));
914 catchReadOnlyBuffer(b, () -> rb.putLong((long)1));
915 catchReadOnlyBuffer(b, () -> rb.putLong(0, (long)1));
916 catchReadOnlyBuffer(b, () -> rb.putFloat((float)1));
917 catchReadOnlyBuffer(b, () -> rb.putFloat(0, (float)1));
918 catchReadOnlyBuffer(b, () -> rb.putDouble((double)1));
919 catchReadOnlyBuffer(b, () -> rb.putDouble(0, (double)1));
920
921
922
923
924
925
926
927
928
929
930
931 if (rb.getClass().getName().startsWith("java.nio.Heap")) {
932 catchReadOnlyBuffer(b, () -> rb.array());
933 catchReadOnlyBuffer(b, () -> rb.arrayOffset());
934 if (rb.hasArray()) {
935 fail("Read-only heap buffer's backing array is accessible", rb);
936 }
937 }
938
939 // Bulk puts from read-only buffers
940
941 b.clear();
942 rb.rewind();
943 b.put(rb);
944
945
946 // For byte buffers, test both the direct and non-direct cases
947 ByteBuffer ob
948 = (b.isDirect()
949 ? ByteBuffer.allocate(rb.capacity())
950 : ByteBuffer.allocateDirect(rb.capacity()));
951 rb.rewind();
952 ob.put(rb);
953
954
955 relPut(b); // Required by testViews
956
957
958 // Test alignment
959
960 testAlign(b, direct);
961
962 }
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014 public static void test(final byte [] ba) {
1015 int offset = 47;
1016 int length = 900;
1017 final ByteBuffer b = ByteBuffer.wrap(ba, offset, length);
1018 show(0, b);
1019 ck(b, b.capacity(), ba.length);
1020 ck(b, b.position(), offset);
1021 ck(b, b.limit(), offset + length);
1022
1023 // The offset must be non-negative and no larger than <array.length>.
1024 catchIndexOutOfBounds(ba, () -> ByteBuffer.wrap(ba, -1, ba.length));
1025 catchIndexOutOfBounds(ba, () -> ByteBuffer.wrap(ba, ba.length + 1, ba.length));
1026 catchIndexOutOfBounds(ba, () -> ByteBuffer.wrap(ba, 0, -1));
1027 catchIndexOutOfBounds(ba, () -> ByteBuffer.wrap(ba, 0, ba.length + 1));
1028
1029 // A NullPointerException will be thrown if the array is null.
1030 tryCatch(ba, NullPointerException.class,
1031 () -> ByteBuffer.wrap((byte []) null, 0, 5));
1032 tryCatch(ba, NullPointerException.class,
1033 () -> ByteBuffer.wrap((byte []) null));
1034 }
1035
1036 private static void testAllocate() {
1037 // An IllegalArgumentException will be thrown for negative capacities.
1038 catchIllegalArgument((Buffer) null, () -> ByteBuffer.allocate(-1));
1039 try {
1040 ByteBuffer.allocate(-1);
1041 } catch (IllegalArgumentException e) {
1042 if (e.getMessage() == null) {
1043 fail("Non-null IllegalArgumentException message expected for"
1044 + " attempt to allocate negative capacity buffer");
1045 }
1046 }
1047
1048 catchIllegalArgument((Buffer) null, () -> ByteBuffer.allocateDirect(-1));
1049 try {
1050 ByteBuffer.allocateDirect(-1);
1051 } catch (IllegalArgumentException e) {
1052 if (e.getMessage() == null) {
1053 fail("Non-null IllegalArgumentException message expected for"
1054 + " attempt to allocate negative capacity direct buffer");
1055 }
1056 }
1057
1058 }
1059
1060 public static void test() {
1061 testAllocate();
1062 test(0, ByteBuffer.allocate(7 * 1024), false);
1063 test(0, ByteBuffer.wrap(new byte[7 * 1024], 0, 7 * 1024), false);
1064 test(new byte[1024]);
1065
1066 ByteBuffer b = ByteBuffer.allocateDirect(7 * 1024);
1067 for (b.position(0); b.position() < b.limit(); )
1068 ck(b, b.get(), 0);
1069 test(0, b, true);
1070
1071
1072
1073
1074
1075 callReset(ByteBuffer.allocate(10));
1076
1077
1078
1079
1080
1081 }
1082
1083 }