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 }