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 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 // Values 672 673 b.clear(); 674 b.put((byte)0); 675 b.put((byte)-1); 676 b.put((byte)1); 677 b.put(Byte.MAX_VALUE); 678 b.put(Byte.MIN_VALUE); 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 b.flip(); 697 ck(b, b.get(), 0); 698 ck(b, b.get(), (byte)-1); 699 ck(b, b.get(), 1); 700 ck(b, b.get(), Byte.MAX_VALUE); 701 ck(b, b.get(), Byte.MIN_VALUE); 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 // Comparison 730 b.rewind(); 731 ByteBuffer b2 = ByteBuffer.allocate(b.capacity()); 732 b2.put(b); 733 b2.flip(); 734 b.position(2); 735 b2.position(2); 736 if (!b.equals(b2)) { 737 for (int i = 2; i < b.limit(); i++) { 738 byte x = b.get(i); 739 byte y = b2.get(i); 740 if (x != y 741 742 743 744 745 746 747 ) { 748 out.println("[" + i + "] " + x + " != " + y); 749 } 750 } 751 fail("Identical buffers not equal", b, b2); 752 } 753 if (b.compareTo(b2) != 0) { 754 fail("Comparison to identical buffer != 0", b, b2); 755 } 756 b.limit(b.limit() + 1); 757 b.position(b.limit() - 1); 758 b.put((byte)99); 759 b.rewind(); 760 b2.rewind(); 761 if (b.equals(b2)) 762 fail("Non-identical buffers equal", b, b2); 763 if (b.compareTo(b2) <= 0) 764 fail("Comparison to shorter buffer <= 0", b, b2); 765 b.limit(b.limit() - 1); 766 767 b.put(2, (byte)42); 768 if (b.equals(b2)) 769 fail("Non-identical buffers equal", b, b2); 770 if (b.compareTo(b2) <= 0) 771 fail("Comparison to lesser buffer <= 0", b, b2); 772 773 // Check equals and compareTo with interesting values 774 for (byte x : VALUES) { 775 ByteBuffer xb = ByteBuffer.wrap(new byte[] { x }); 776 if (xb.compareTo(xb) != 0) { 777 fail("compareTo not reflexive", xb, xb, x, x); 778 } 779 if (!xb.equals(xb)) { 780 fail("equals not reflexive", xb, xb, x, x); 781 } 782 for (byte y : VALUES) { 783 ByteBuffer yb = ByteBuffer.wrap(new byte[] { y }); 784 if (xb.compareTo(yb) != - yb.compareTo(xb)) { 785 fail("compareTo not anti-symmetric", 786 xb, yb, x, y); 787 } 788 if ((xb.compareTo(yb) == 0) != xb.equals(yb)) { 789 fail("compareTo inconsistent with equals", 790 xb, yb, x, y); 791 } 792 if (xb.compareTo(yb) != Byte.compare(x, y)) { 793 794 795 796 797 798 799 fail("Incorrect results for ByteBuffer.compareTo", 800 xb, yb, x, y); 801 } 802 if (xb.equals(yb) != ((x == y) || ((x != x) && (y != y)))) { 803 fail("Incorrect results for ByteBuffer.equals", 804 xb, yb, x, y); 805 } 806 } 807 } 808 809 // Sub, dup 810 811 relPut(b); 812 relGet(b.duplicate()); 813 b.position(13); 814 relGet(b.duplicate(), 13); 815 relGet(b.duplicate().slice(), 13); 816 relGet(b.slice(), 13); 817 relGet(b.slice().duplicate(), 13); 818 819 // Slice 820 821 b.position(5); 822 ByteBuffer sb = b.slice(); 823 checkSlice(b, sb); 824 b.position(0); 825 ByteBuffer sb2 = sb.slice(); 826 checkSlice(sb, sb2); 827 828 if (!sb.equals(sb2)) 829 fail("Sliced slices do not match", sb, sb2); 830 if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset())) { 831 fail("Array offsets do not match: " 832 + sb.arrayOffset() + " != " + sb2.arrayOffset(), sb, sb2); 833 } 834 835 836 837 // Views 838 839 b.clear(); 840 b.order(ByteOrder.BIG_ENDIAN); 841 testViews(level + 1, b, direct); 842 843 for (int i = 1; i <= 9; i++) { 844 b.position(i); 845 show(level + 1, b); 846 testViews(level + 2, b, direct); 847 } 848 849 b.position(0); 850 b.order(ByteOrder.LITTLE_ENDIAN); 851 testViews(level + 1, b, direct); 852 853 // Heterogeneous accessors 854 855 b.order(ByteOrder.BIG_ENDIAN); 856 for (int i = 0; i <= 9; i++) { 857 b.position(i); 858 testHet(level + 1, b); 859 } 860 b.order(ByteOrder.LITTLE_ENDIAN); 861 b.position(3); 862 testHet(level + 1, b); 863 864 865 866 // Read-only views 867 868 b.rewind(); 869 final ByteBuffer rb = b.asReadOnlyBuffer(); 870 if (!b.equals(rb)) 871 fail("Buffer not equal to read-only view", b, rb); 872 show(level + 1, rb); 873 874 catchReadOnlyBuffer(b, () -> relPut(rb)); 875 catchReadOnlyBuffer(b, () -> absPut(rb)); 876 catchReadOnlyBuffer(b, () -> bulkPutArray(rb)); 877 catchReadOnlyBuffer(b, () -> bulkPutBuffer(rb)); 878 catchReadOnlyBuffer(b, () -> absBulkPutArray(rb)); 879 880 // put(ByteBuffer) should not change source position 881 final ByteBuffer src = ByteBuffer.allocate(1); 882 catchReadOnlyBuffer(b, () -> rb.put(src)); 883 ck(src, src.position(), 0); 884 885 catchReadOnlyBuffer(b, () -> rb.compact()); 886 887 888 889 catchReadOnlyBuffer(b, () -> rb.putChar((char)1)); 890 catchReadOnlyBuffer(b, () -> rb.putChar(0, (char)1)); 891 catchReadOnlyBuffer(b, () -> rb.putShort((short)1)); 892 catchReadOnlyBuffer(b, () -> rb.putShort(0, (short)1)); 893 catchReadOnlyBuffer(b, () -> rb.putInt(1)); 894 catchReadOnlyBuffer(b, () -> rb.putInt(0, 1)); 895 catchReadOnlyBuffer(b, () -> rb.putLong((long)1)); 896 catchReadOnlyBuffer(b, () -> rb.putLong(0, (long)1)); 897 catchReadOnlyBuffer(b, () -> rb.putFloat((float)1)); 898 catchReadOnlyBuffer(b, () -> rb.putFloat(0, (float)1)); 899 catchReadOnlyBuffer(b, () -> rb.putDouble((double)1)); 900 catchReadOnlyBuffer(b, () -> rb.putDouble(0, (double)1)); 901 902 903 904 905 906 907 908 909 910 911 912 if (rb.getClass().getName().startsWith("java.nio.Heap")) { 913 catchReadOnlyBuffer(b, () -> rb.array()); 914 catchReadOnlyBuffer(b, () -> rb.arrayOffset()); 915 if (rb.hasArray()) { 916 fail("Read-only heap buffer's backing array is accessible", rb); 917 } 918 } 919 920 // Bulk puts from read-only buffers 921 922 b.clear(); 923 rb.rewind(); 924 b.put(rb); 925 926 927 // For byte buffers, test both the direct and non-direct cases 928 ByteBuffer ob 929 = (b.isDirect() 930 ? ByteBuffer.allocate(rb.capacity()) 931 : ByteBuffer.allocateDirect(rb.capacity())); 932 rb.rewind(); 933 ob.put(rb); 934 935 936 relPut(b); // Required by testViews 937 938 939 // Test alignment 940 941 testAlign(b, direct); 942 943 } 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 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 public static void test(final byte [] ba) { 996 int offset = 47; 997 int length = 900; 998 final ByteBuffer b = ByteBuffer.wrap(ba, offset, length); 999 show(0, b); 1000 ck(b, b.capacity(), ba.length); 1001 ck(b, b.position(), offset); 1002 ck(b, b.limit(), offset + length); 1003 1004 // The offset must be non-negative and no larger than <array.length>. 1005 catchIndexOutOfBounds(ba, () -> ByteBuffer.wrap(ba, -1, ba.length)); 1006 catchIndexOutOfBounds(ba, () -> ByteBuffer.wrap(ba, ba.length + 1, ba.length)); 1007 catchIndexOutOfBounds(ba, () -> ByteBuffer.wrap(ba, 0, -1)); 1008 catchIndexOutOfBounds(ba, () -> ByteBuffer.wrap(ba, 0, ba.length + 1)); 1009 1010 // A NullPointerException will be thrown if the array is null. 1011 tryCatch(ba, NullPointerException.class, 1012 () -> ByteBuffer.wrap((byte []) null, 0, 5)); 1013 tryCatch(ba, NullPointerException.class, 1014 () -> ByteBuffer.wrap((byte []) null)); 1015 } 1016 1017 private static void testAllocate() { 1018 // An IllegalArgumentException will be thrown for negative capacities. 1019 catchIllegalArgument((Buffer) null, () -> ByteBuffer.allocate(-1)); 1020 try { 1021 ByteBuffer.allocate(-1); 1022 } catch (IllegalArgumentException e) { 1023 if (e.getMessage() == null) { 1024 fail("Non-null IllegalArgumentException message expected for" 1025 + " attempt to allocate negative capacity buffer"); 1026 } 1027 } 1028 1029 catchIllegalArgument((Buffer) null, () -> ByteBuffer.allocateDirect(-1)); 1030 try { 1031 ByteBuffer.allocateDirect(-1); 1032 } catch (IllegalArgumentException e) { 1033 if (e.getMessage() == null) { 1034 fail("Non-null IllegalArgumentException message expected for" 1035 + " attempt to allocate negative capacity direct buffer"); 1036 } 1037 } 1038 1039 } 1040 1041 public static void test() { 1042 testAllocate(); 1043 test(0, ByteBuffer.allocate(7 * 1024), false); 1044 test(0, ByteBuffer.wrap(new byte[7 * 1024], 0, 7 * 1024), false); 1045 test(new byte[1024]); 1046 1047 ByteBuffer b = ByteBuffer.allocateDirect(7 * 1024); 1048 for (b.position(0); b.position() < b.limit(); ) 1049 ck(b, b.get(), 0); 1050 test(0, b, true); 1051 1052 1053 1054 1055 1056 callReset(ByteBuffer.allocate(10)); 1057 1058 1059 1060 1061 1062 } 1063 1064 }