1 /* 2 * Copyright (c) 2000, 2016, 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 BasicInt 37 extends Basic 38 { 39 40 private static final int[] VALUES = { 41 Integer.MIN_VALUE, 42 (int) -1, 43 (int) 0, 44 (int) 1, 45 Integer.MAX_VALUE, 46 47 48 49 50 51 52 53 54 55 56 57 58 }; 59 60 private static void relGet(IntBuffer b) { 61 int n = b.capacity(); 62 for (int i = 0; i < n; i++) 63 ck(b, (long)b.get(), (long)((int)ic(i))); 64 b.rewind(); 65 } 66 67 private static void relGet(IntBuffer b, int start) { 68 int n = b.remaining(); 69 for (int i = start; i < n; i++) 70 ck(b, (long)b.get(), (long)((int)ic(i))); 71 b.rewind(); 72 } 73 74 private static void absGet(IntBuffer b) { 75 int n = b.capacity(); 76 for (int i = 0; i < n; i++) 77 ck(b, (long)b.get(), (long)((int)ic(i))); 78 b.rewind(); 79 } 80 81 private static void bulkGet(IntBuffer b) { 82 int n = b.capacity(); 83 int[] a = new int[n + 7]; 84 b.get(a, 7, n); 85 for (int i = 0; i < n; i++) { 86 ck(b, (long)a[i + 7], (long)((int)ic(i))); 87 } 88 } 89 90 private static void relPut(IntBuffer b) { 91 int n = b.capacity(); 92 b.clear(); 93 for (int i = 0; i < n; i++) 94 b.put((int)ic(i)); 95 b.flip(); 96 } 97 98 private static void absPut(IntBuffer b) { 99 int n = b.capacity(); 100 b.clear(); 101 for (int i = 0; i < n; i++) 102 b.put(i, (int)ic(i)); 103 b.limit(n); 104 b.position(0); 105 } 106 107 private static void bulkPutArray(IntBuffer b) { 108 int n = b.capacity(); 109 b.clear(); 110 int[] a = new int[n + 7]; 111 for (int i = 0; i < n; i++) 112 a[i + 7] = (int)ic(i); 113 b.put(a, 7, n); 114 b.flip(); 115 } 116 117 private static void bulkPutBuffer(IntBuffer b) { 118 int n = b.capacity(); 119 b.clear(); 120 IntBuffer c = IntBuffer.allocate(n + 7); 121 c.position(7); 122 for (int i = 0; i < n; i++) 123 c.put((int)ic(i)); 124 c.flip(); 125 c.position(7); 126 b.put(c); 127 b.flip(); 128 try { 129 b.put(b); 130 fail("IllegalArgumentException expected for put into same buffer"); 131 } catch (IllegalArgumentException e) { 132 if (e.getMessage() == null) { 133 fail("Non-null IllegalArgumentException message expected from" 134 + " put into same buffer"); 135 } 136 } 137 } 138 139 //6231529 140 private static void callReset(IntBuffer b) { 141 b.position(0); 142 b.mark(); 143 144 b.duplicate().reset(); 145 b.asReadOnlyBuffer().reset(); 146 } 147 148 149 150 // 6221101-6234263 151 152 private static void putBuffer() { 153 final int cap = 10; 154 155 IntBuffer direct1 = ByteBuffer.allocateDirect(cap).asIntBuffer(); 156 IntBuffer nondirect1 = ByteBuffer.allocate(cap).asIntBuffer(); 157 direct1.put(nondirect1); 158 159 IntBuffer direct2 = ByteBuffer.allocateDirect(cap).asIntBuffer(); 160 IntBuffer nondirect2 = ByteBuffer.allocate(cap).asIntBuffer(); 161 nondirect2.put(direct2); 162 163 IntBuffer direct3 = ByteBuffer.allocateDirect(cap).asIntBuffer(); 164 IntBuffer direct4 = ByteBuffer.allocateDirect(cap).asIntBuffer(); 165 direct3.put(direct4); 166 167 IntBuffer nondirect3 = ByteBuffer.allocate(cap).asIntBuffer(); 168 IntBuffer nondirect4 = ByteBuffer.allocate(cap).asIntBuffer(); 169 nondirect3.put(nondirect4); 170 } 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 private static void checkSlice(IntBuffer b, IntBuffer slice) { 189 ck(slice, 0, slice.position()); 190 ck(slice, b.remaining(), slice.limit()); 191 ck(slice, b.remaining(), slice.capacity()); 192 if (b.isDirect() != slice.isDirect()) 193 fail("Lost direction", slice); 194 if (b.isReadOnly() != slice.isReadOnly()) 195 fail("Lost read-only", slice); 196 } 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 private static void fail(String problem, 450 IntBuffer xb, IntBuffer yb, 451 int x, int y) { 452 fail(problem + String.format(": x=%s y=%s", x, y), xb, yb); 453 } 454 455 private static void catchIllegalArgument(Buffer b, Runnable thunk) { 456 tryCatch(b, IllegalArgumentException.class, thunk); 457 } 458 459 private static void catchReadOnlyBuffer(Buffer b, Runnable thunk) { 460 tryCatch(b, ReadOnlyBufferException.class, thunk); 461 } 462 463 private static void catchIndexOutOfBounds(Buffer b, Runnable thunk) { 464 tryCatch(b, IndexOutOfBoundsException.class, thunk); 465 } 466 467 private static void catchIndexOutOfBounds(int[] t, Runnable thunk) { 468 tryCatch(t, IndexOutOfBoundsException.class, thunk); 469 } 470 471 private static void tryCatch(Buffer b, Class<?> ex, Runnable thunk) { 472 boolean caught = false; 473 try { 474 thunk.run(); 475 } catch (Throwable x) { 476 if (ex.isAssignableFrom(x.getClass())) { 477 caught = true; 478 } else { 479 fail(x.getMessage() + " not expected"); 480 } 481 } 482 if (!caught) { 483 fail(ex.getName() + " not thrown", b); 484 } 485 } 486 487 private static void tryCatch(int[] t, Class<?> ex, Runnable thunk) { 488 tryCatch(IntBuffer.wrap(t), ex, thunk); 489 } 490 491 public static void test(int level, final IntBuffer b, boolean direct) { 492 493 show(level, b); 494 495 if (direct != b.isDirect()) 496 fail("Wrong direction", b); 497 498 // Gets and puts 499 500 relPut(b); 501 relGet(b); 502 absGet(b); 503 bulkGet(b); 504 505 absPut(b); 506 relGet(b); 507 absGet(b); 508 bulkGet(b); 509 510 bulkPutArray(b); 511 relGet(b); 512 513 bulkPutBuffer(b); 514 relGet(b); 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 // Compact 553 554 relPut(b); 555 b.position(13); 556 b.compact(); 557 b.flip(); 558 relGet(b, 13); 559 560 // Exceptions 561 562 relPut(b); 563 b.limit(b.capacity() / 2); 564 b.position(b.limit()); 565 566 tryCatch(b, BufferUnderflowException.class, () -> b.get()); 567 tryCatch(b, BufferOverflowException.class, () -> b.put((int)42)); 568 // The index must be non-negative and less than the buffer's limit. 569 catchIndexOutOfBounds(b, () -> b.get(b.limit())); 570 catchIndexOutOfBounds(b, () -> b.get(-1)); 571 catchIndexOutOfBounds(b, () -> b.put(b.limit(), (int)42)); 572 tryCatch(b, InvalidMarkException.class, 573 () -> b.position(0).mark().compact().reset()); 574 575 try { 576 b.position(b.limit() + 1); 577 fail("IllegalArgumentException expected for position beyond limit"); 578 } catch (IllegalArgumentException e) { 579 if (e.getMessage() == null) { 580 fail("Non-null IllegalArgumentException message expected for" 581 + " position beyond limit"); 582 } 583 } 584 585 try { 586 b.position(-1); 587 fail("IllegalArgumentException expected for negative position"); 588 } catch (IllegalArgumentException e) { 589 if (e.getMessage() == null) { 590 fail("Non-null IllegalArgumentException message expected for" 591 + " negative position"); 592 } 593 } 594 595 try { 596 b.limit(b.capacity() + 1); 597 fail("IllegalArgumentException expected for limit beyond capacity"); 598 } catch (IllegalArgumentException e) { 599 if (e.getMessage() == null) { 600 fail("Non-null IllegalArgumentException message expected for" 601 + " limit beyond capacity"); 602 } 603 } 604 605 try { 606 b.limit(-1); 607 fail("IllegalArgumentException expected for negative limit"); 608 } catch (IllegalArgumentException e) { 609 if (e.getMessage() == null) { 610 fail("Non-null IllegalArgumentException message expected for" 611 + " negative limit"); 612 } 613 } 614 615 // Values 616 617 b.clear(); 618 b.put((int)0); 619 b.put((int)-1); 620 b.put((int)1); 621 b.put(Integer.MAX_VALUE); 622 b.put(Integer.MIN_VALUE); 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 b.flip(); 641 ck(b, b.get(), 0); 642 ck(b, b.get(), (int)-1); 643 ck(b, b.get(), 1); 644 ck(b, b.get(), Integer.MAX_VALUE); 645 ck(b, b.get(), Integer.MIN_VALUE); 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 // Comparison 674 b.rewind(); 675 IntBuffer b2 = IntBuffer.allocate(b.capacity()); 676 b2.put(b); 677 b2.flip(); 678 b.position(2); 679 b2.position(2); 680 if (!b.equals(b2)) { 681 for (int i = 2; i < b.limit(); i++) { 682 int x = b.get(i); 683 int y = b2.get(i); 684 if (x != y 685 686 687 688 689 690 691 ) { 692 out.println("[" + i + "] " + x + " != " + y); 693 } 694 } 695 fail("Identical buffers not equal", b, b2); 696 } 697 if (b.compareTo(b2) != 0) { 698 fail("Comparison to identical buffer != 0", b, b2); 699 } 700 b.limit(b.limit() + 1); 701 b.position(b.limit() - 1); 702 b.put((int)99); 703 b.rewind(); 704 b2.rewind(); 705 if (b.equals(b2)) 706 fail("Non-identical buffers equal", b, b2); 707 if (b.compareTo(b2) <= 0) 708 fail("Comparison to shorter buffer <= 0", b, b2); 709 b.limit(b.limit() - 1); 710 711 b.put(2, (int)42); 712 if (b.equals(b2)) 713 fail("Non-identical buffers equal", b, b2); 714 if (b.compareTo(b2) <= 0) 715 fail("Comparison to lesser buffer <= 0", b, b2); 716 717 // Check equals and compareTo with interesting values 718 for (int x : VALUES) { 719 IntBuffer xb = IntBuffer.wrap(new int[] { x }); 720 if (xb.compareTo(xb) != 0) { 721 fail("compareTo not reflexive", xb, xb, x, x); 722 } 723 if (!xb.equals(xb)) { 724 fail("equals not reflexive", xb, xb, x, x); 725 } 726 for (int y : VALUES) { 727 IntBuffer yb = IntBuffer.wrap(new int[] { y }); 728 if (xb.compareTo(yb) != - yb.compareTo(xb)) { 729 fail("compareTo not anti-symmetric", 730 xb, yb, x, y); 731 } 732 if ((xb.compareTo(yb) == 0) != xb.equals(yb)) { 733 fail("compareTo inconsistent with equals", 734 xb, yb, x, y); 735 } 736 if (xb.compareTo(yb) != Integer.compare(x, y)) { 737 738 739 740 741 742 743 fail("Incorrect results for IntBuffer.compareTo", 744 xb, yb, x, y); 745 } 746 if (xb.equals(yb) != ((x == y) || ((x != x) && (y != y)))) { 747 fail("Incorrect results for IntBuffer.equals", 748 xb, yb, x, y); 749 } 750 } 751 } 752 753 // Sub, dup 754 755 relPut(b); 756 relGet(b.duplicate()); 757 b.position(13); 758 relGet(b.duplicate(), 13); 759 relGet(b.duplicate().slice(), 13); 760 relGet(b.slice(), 13); 761 relGet(b.slice().duplicate(), 13); 762 763 // Slice 764 765 b.position(5); 766 IntBuffer sb = b.slice(); 767 checkSlice(b, sb); 768 b.position(0); 769 IntBuffer sb2 = sb.slice(); 770 checkSlice(sb, sb2); 771 772 if (!sb.equals(sb2)) 773 fail("Sliced slices do not match", sb, sb2); 774 if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset())) { 775 fail("Array offsets do not match: " 776 + sb.arrayOffset() + " != " + sb2.arrayOffset(), sb, sb2); 777 } 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 // Read-only views 811 812 b.rewind(); 813 final IntBuffer rb = b.asReadOnlyBuffer(); 814 if (!b.equals(rb)) 815 fail("Buffer not equal to read-only view", b, rb); 816 show(level + 1, rb); 817 818 catchReadOnlyBuffer(b, () -> relPut(rb)); 819 catchReadOnlyBuffer(b, () -> absPut(rb)); 820 catchReadOnlyBuffer(b, () -> bulkPutArray(rb)); 821 catchReadOnlyBuffer(b, () -> bulkPutBuffer(rb)); 822 823 // put(IntBuffer) should not change source position 824 final IntBuffer src = IntBuffer.allocate(1); 825 catchReadOnlyBuffer(b, () -> rb.put(src)); 826 ck(src, src.position(), 0); 827 828 catchReadOnlyBuffer(b, () -> rb.compact()); 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 if (rb.getClass().getName().startsWith("java.nio.Heap")) { 856 catchReadOnlyBuffer(b, () -> rb.array()); 857 catchReadOnlyBuffer(b, () -> rb.arrayOffset()); 858 if (rb.hasArray()) { 859 fail("Read-only heap buffer's backing array is accessible", rb); 860 } 861 } 862 863 // Bulk puts from read-only buffers 864 865 b.clear(); 866 rb.rewind(); 867 b.put(rb); 868 869 870 871 872 873 874 875 876 877 878 879 relPut(b); // Required by testViews 880 881 882 883 884 885 886 } 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 public static void test(final int [] ba) { 932 int offset = 47; 933 int length = 900; 934 final IntBuffer b = IntBuffer.wrap(ba, offset, length); 935 show(0, b); 936 ck(b, b.capacity(), ba.length); 937 ck(b, b.position(), offset); 938 ck(b, b.limit(), offset + length); 939 940 // The offset must be non-negative and no larger than <array.length>. 941 catchIndexOutOfBounds(ba, () -> IntBuffer.wrap(ba, -1, ba.length)); 942 catchIndexOutOfBounds(ba, () -> IntBuffer.wrap(ba, ba.length + 1, ba.length)); 943 catchIndexOutOfBounds(ba, () -> IntBuffer.wrap(ba, 0, -1)); 944 catchIndexOutOfBounds(ba, () -> IntBuffer.wrap(ba, 0, ba.length + 1)); 945 946 // A NullPointerException will be thrown if the array is null. 947 tryCatch(ba, NullPointerException.class, 948 () -> IntBuffer.wrap((int []) null, 0, 5)); 949 tryCatch(ba, NullPointerException.class, 950 () -> IntBuffer.wrap((int []) null)); 951 } 952 953 private static void testAllocate() { 954 // An IllegalArgumentException will be thrown for negative capacities. 955 catchIllegalArgument((Buffer) null, () -> IntBuffer.allocate(-1)); 956 try { 957 IntBuffer.allocate(-1); 958 } catch (IllegalArgumentException e) { 959 if (e.getMessage() == null) { 960 fail("Non-null IllegalArgumentException message expected for" 961 + " attempt to allocate negative capacity buffer"); 962 } 963 } 964 965 966 967 968 969 970 971 972 973 974 975 } 976 977 public static void test() { 978 testAllocate(); 979 test(0, IntBuffer.allocate(7 * 1024), false); 980 test(0, IntBuffer.wrap(new int[7 * 1024], 0, 7 * 1024), false); 981 test(new int[1024]); 982 983 984 985 986 987 988 989 990 991 992 callReset(IntBuffer.allocate(10)); 993 994 995 996 putBuffer(); 997 998 } 999 1000 }