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 #warn This file is preprocessed before being compiled
32
33 import java.nio.*;
34
35
36 public class Basic$Type$
37 extends Basic
38 {
39
40 private static final $type$[] VALUES = {
41 $Fulltype$.MIN_VALUE,
42 ($type$) -1,
43 ($type$) 0,
44 ($type$) 1,
45 $Fulltype$.MAX_VALUE,
46 #if[float]
47 $Fulltype$.NEGATIVE_INFINITY,
48 $Fulltype$.POSITIVE_INFINITY,
49 $Fulltype$.NaN,
50 ($type$) -0.0,
51 #end[float]
52 #if[double]
53 $Fulltype$.NEGATIVE_INFINITY,
54 $Fulltype$.POSITIVE_INFINITY,
55 $Fulltype$.NaN,
56 ($type$) -0.0,
57 #end[double]
58 };
59
60 private static void relGet($Type$Buffer b) {
61 int n = b.capacity();
62 for (int i = 0; i < n; i++)
63 ck(b, (long)b.get(), (long)(($type$)ic(i)));
64 b.rewind();
65 }
66
67 private static void relGet($Type$Buffer b, int start) {
68 int n = b.remaining();
69 for (int i = start; i < n; i++)
70 ck(b, (long)b.get(), (long)(($type$)ic(i)));
71 b.rewind();
72 }
73
74 private static void absGet($Type$Buffer b) {
75 int n = b.capacity();
76 for (int i = 0; i < n; i++)
77 ck(b, (long)b.get(), (long)(($type$)ic(i)));
78 b.rewind();
79 }
80
81 private static void bulkGet($Type$Buffer b) {
82 int n = b.capacity();
83 $type$[] a = new $type$[n + 7];
84 b.get(a, 7, n);
85 for (int i = 0; i < n; i++) {
86 ck(b, (long)a[i + 7], (long)(($type$)ic(i)));
87 }
88 }
89
90 private static void absBulkGet($Type$Buffer b) {
91 int n = b.capacity();
92 int len = n - 7*2;
93 $type$[] a = new $type$[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)(($type$)ic(i)));
99 }
100 }
101
102 private static void relPut($Type$Buffer b) {
103 int n = b.capacity();
104 b.clear();
105 for (int i = 0; i < n; i++)
106 b.put(($type$)ic(i));
107 b.flip();
108 }
109
110 private static void absPut($Type$Buffer b) {
111 int n = b.capacity();
112 b.clear();
113 for (int i = 0; i < n; i++)
114 b.put(i, ($type$)ic(i));
115 b.limit(n);
116 b.position(0);
117 }
118
119 private static void bulkPutArray($Type$Buffer b) {
120 int n = b.capacity();
121 b.clear();
122 $type$[] a = new $type$[n + 7];
123 for (int i = 0; i < n; i++)
124 a[i + 7] = ($type$)ic(i);
125 b.put(a, 7, n);
126 b.flip();
127 }
128
129 private static void bulkPutBuffer($Type$Buffer b) {
130 int n = b.capacity();
131 b.clear();
132 $Type$Buffer c = $Type$Buffer.allocate(n + 7);
133 c.position(7);
134 for (int i = 0; i < n; i++)
135 c.put(($type$)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($Type$Buffer b) {
152 int n = b.capacity();
153 b.clear();
154 int lim = n - 7;
155 int len = lim - 7;
156 b.limit(lim);
157 $type$[] a = new $type$[len + 7];
158 for (int i = 0; i < len; i++)
159 a[i + 7] = ($type$)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($Type$Buffer b) {
167 b.position(0);
168 b.mark();
169
170 b.duplicate().reset();
171 b.asReadOnlyBuffer().reset();
172 }
173
174 #if[byte]
175 #else[byte]
176 // 6221101-6234263
177
178 private static void putBuffer() {
179 final int cap = 10;
180
181 $Type$Buffer direct1 = ByteBuffer.allocateDirect(cap).as$Type$Buffer();
182 $Type$Buffer nondirect1 = ByteBuffer.allocate(cap).as$Type$Buffer();
183 direct1.put(nondirect1);
184
185 $Type$Buffer direct2 = ByteBuffer.allocateDirect(cap).as$Type$Buffer();
186 $Type$Buffer nondirect2 = ByteBuffer.allocate(cap).as$Type$Buffer();
187 nondirect2.put(direct2);
188
189 $Type$Buffer direct3 = ByteBuffer.allocateDirect(cap).as$Type$Buffer();
190 $Type$Buffer direct4 = ByteBuffer.allocateDirect(cap).as$Type$Buffer();
191 direct3.put(direct4);
192
193 $Type$Buffer nondirect3 = ByteBuffer.allocate(cap).as$Type$Buffer();
194 $Type$Buffer nondirect4 = ByteBuffer.allocate(cap).as$Type$Buffer();
195 nondirect3.put(nondirect4);
196 }
197 #end[byte]
198
199 #if[char]
200
201 private static void bulkPutString($Type$Buffer b) {
202 int n = b.capacity();
203 b.clear();
204 StringBuilder sb = new StringBuilder(n + 7);
205 sb.append("1234567");
206 for (int i = 0; i < n; i++)
207 sb.append((char)ic(i));
208 b.put(sb.toString(), 7, 7 + n);
209 b.flip();
210 }
211
212 #end[char]
213
214 private static void checkSlice($Type$Buffer b, $Type$Buffer 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 #if[byte]
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 #end[byte]
474
475 private static void fail(String problem,
476 $Type$Buffer xb, $Type$Buffer yb,
477 $type$ x, $type$ 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($type$[] 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($type$[] t, Class<?> ex, Runnable thunk) {
521 tryCatch($Type$Buffer.wrap(t), ex, thunk);
522 }
523
524 public static void test(int level, final $Type$Buffer 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 #if[char]
553
554 bulkPutString(b);
555 relGet(b);
556 b.position(1);
557 b.limit(7);
558 ck(b, b.toString().equals("bcdefg"));
559
560 // CharSequence ops
561
562 b.position(2);
563 ck(b, b.charAt(1), 'd');
564 CharBuffer c = b.subSequence(1, 4);
565 ck(c, c.capacity(), b.capacity());
566 ck(c, c.position(), b.position()+1);
567 ck(c, c.limit(), b.position()+4);
568 ck(c, b.subSequence(1, 4).toString().equals("def"));
569
570 // 4938424
571 b.position(4);
572 ck(b, b.charAt(1), 'f');
573 ck(b, b.subSequence(1, 3).toString().equals("fg"));
574
575 // String ops
576
577 // 7190219
578 b.clear();
579 int pos = b.position();
580 tryCatch(b, BufferOverflowException.class, () ->
581 b.put(String.valueOf(new char[b.capacity() + 1]), 0, b.capacity() + 1)
582 );
583 ck(b, b.position(), pos);
584 relGet(b);
585
586 #end[char]
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(($type$)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(), ($type$)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, ($type$[])null, 0, 42));
655
656 $type$[] tmpa = new $type$[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(($type$)0);
680 b.put(($type$)-1);
681 b.put(($type$)1);
682 b.put($Fulltype$.MAX_VALUE);
683 b.put($Fulltype$.MIN_VALUE);
684 #if[float]
685 b.put(-Float.MAX_VALUE);
686 b.put(-Float.MIN_VALUE);
687 b.put(Float.NEGATIVE_INFINITY);
688 b.put(Float.POSITIVE_INFINITY);
689 b.put(Float.NaN);
690 b.put(0.91697687f); // Changes value if incorrectly swapped
691 #end[float]
692 #if[double]
693 b.put(-Double.MAX_VALUE);
694 b.put(-Double.MIN_VALUE);
695 b.put(Double.NEGATIVE_INFINITY);
696 b.put(Double.POSITIVE_INFINITY);
697 b.put(Double.NaN);
698 b.put(0.5121609353879392); // Changes value if incorrectly swapped
699 #end[double]
700
701 b.flip();
702 ck(b, b.get(), 0);
703 ck(b, b.get(), ($type$)-1);
704 ck(b, b.get(), 1);
705 ck(b, b.get(), $Fulltype$.MAX_VALUE);
706 ck(b, b.get(), $Fulltype$.MIN_VALUE);
707
708 #if[float]
709 $type$ v;
710 ck(b, b.get(), -Float.MAX_VALUE);
711 ck(b, b.get(), -Float.MIN_VALUE);
712 ck(b, b.get(), Float.NEGATIVE_INFINITY);
713 ck(b, b.get(), Float.POSITIVE_INFINITY);
714 if (Float.floatToRawIntBits(v = b.get()) !=
715 Float.floatToRawIntBits(Float.NaN)) {
716 fail(b, (long)Float.NaN, (long)v);
717 }
718 ck(b, b.get(), 0.91697687f);
719 #end[float]
720 #if[double]
721 $type$ v;
722 ck(b, b.get(), -Double.MAX_VALUE);
723 ck(b, b.get(), -Double.MIN_VALUE);
724 ck(b, b.get(), Double.NEGATIVE_INFINITY);
725 ck(b, b.get(), Double.POSITIVE_INFINITY);
726 if (Double.doubleToRawLongBits(v = b.get())
727 != Double.doubleToRawLongBits(Double.NaN)) {
728 fail(b, (long)Double.NaN, (long)v);
729 }
730 ck(b, b.get(), 0.5121609353879392);
731 #end[double]
732
733
734 // Comparison
735 b.rewind();
736 $Type$Buffer b2 = $Type$Buffer.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 $type$ x = b.get(i);
744 $type$ y = b2.get(i);
745 if (x != y
746 #if[double]
747 || Double.compare(x, y) != 0
748 #end[double]
749 #if[float]
750 || Float.compare(x, y) != 0
751 #end[float]
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(($type$)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, ($type$)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 ($type$ x : VALUES) {
780 $Type$Buffer xb = $Type$Buffer.wrap(new $type$[] { 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 ($type$ y : VALUES) {
788 $Type$Buffer yb = $Type$Buffer.wrap(new $type$[] { 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) != $Fulltype$.compare(x, y)) {
798 #if[float]
799 if (x == 0.0 && y == 0.0) continue;
800 #end[float]
801 #if[double]
802 if (x == 0.0 && y == 0.0) continue;
803 #end[double]
804 fail("Incorrect results for $Type$Buffer.compareTo",
805 xb, yb, x, y);
806 }
807 if (xb.equals(yb) != ((x == y) || ((x != x) && (y != y)))) {
808 fail("Incorrect results for $Type$Buffer.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 $Type$Buffer sb = b.slice();
828 checkSlice(b, sb);
829 b.position(0);
830 $Type$Buffer 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 $Type$Buffer rsb = b.slice();
846 b.position(0);
847 b.limit(b.capacity());
848 $Type$Buffer asb = b.slice(7, 35);
849 checkSlice(rsb, asb);
850
851 b.position(bPos);
852 b.limit(bLim);
853
854 #if[byte]
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 #end[byte]
884
885 // Read-only views
886
887 b.rewind();
888 final $Type$Buffer 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($Type$Buffer) should not change source position
900 final $Type$Buffer src = $Type$Buffer.allocate(1);
901 catchReadOnlyBuffer(b, () -> rb.put(src));
902 ck(src, src.position(), 0);
903
904 catchReadOnlyBuffer(b, () -> rb.compact());
905
906 #if[byte]
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 #end[byte]
922
923 #if[char]
924
925 // 7199551
926 catchReadOnlyBuffer(b, () -> rb.put(new String(new char[rb.remaining() + 1])));
927 catchReadOnlyBuffer(b, () -> rb.append(new String(new char[rb.remaining() + 1])));
928
929 #end[char]
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 #if[byte]
946 // For byte buffers, test both the direct and non-direct cases
947 $Type$Buffer ob
948 = (b.isDirect()
949 ? $Type$Buffer.allocate(rb.capacity())
950 : $Type$Buffer.allocateDirect(rb.capacity()));
951 rb.rewind();
952 ob.put(rb);
953 #end[byte]
954
955 relPut(b); // Required by testViews
956
957 #if[byte]
958 // Test alignment
959
960 testAlign(b, direct);
961 #end[byte]
962 }
963
964 #if[char]
965
966 private static void testStr() {
967 final String s = "abcdefghijklm";
968 int start = 3;
969 int end = 9;
970 final CharBuffer b = CharBuffer.wrap(s, start, end);
971 show(0, b);
972 ck(b, b.toString().equals(s.substring(start, end)));
973 ck(b, b.toString().equals("defghi"));
974 ck(b, b.isReadOnly());
975 catchReadOnlyBuffer(b, () -> b.put('x'));
976 ck(b, start, b.position());
977 ck(b, end, b.limit());
978 ck(b, s.length(), b.capacity());
979 b.position(6);
980 ck(b, b.subSequence(0,3).toString().equals("ghi"));
981
982 // absolute bulk get
983 char[] c = new char[end + 1 - (start - 1) + 1]; // [start - 1, end + 1]
984 b.limit(end + 2);
985 b.get(start - 1, c, 0, c.length);
986 for (int i = 0; i < c.length; i++)
987 ck(b, c[i], s.charAt(start - 1 + i));
988
989 // The index, relative to the position, must be non-negative and
990 // smaller than remaining().
991 catchIndexOutOfBounds(b, () -> b.charAt(-1));
992 catchIndexOutOfBounds(b, () -> b.charAt(b.remaining()));
993 // The index must be non-negative and less than the buffer's limit.
994 catchIndexOutOfBounds(b, () -> b.get(b.limit()));
995 catchIndexOutOfBounds(b, () -> b.get(-1));
996 // The start must be non-negative and no larger than remaining().
997 catchIndexOutOfBounds(b, () -> b.subSequence(-1, b.remaining()));
998 catchIndexOutOfBounds(b, () -> b.subSequence(b.remaining() + 1, b.remaining()));
999
1000 // The end must be no smaller than start and no larger than
1001 // remaining().
1002 catchIndexOutOfBounds(b, () -> b.subSequence(2, 1));
1003 catchIndexOutOfBounds(b, () -> b.subSequence(0, b.remaining() + 1));
1004
1005 // The offset must be non-negative and no larger than <array.length>.
1006 catchIndexOutOfBounds(b, () -> $Type$Buffer.wrap(s, -1, s.length()));
1007 catchIndexOutOfBounds(b, () -> $Type$Buffer.wrap(s, s.length() + 1, s.length()));
1008 catchIndexOutOfBounds(b, () -> $Type$Buffer.wrap(s, 1, 0));
1009 catchIndexOutOfBounds(b, () -> $Type$Buffer.wrap(s, 0, s.length() + 1));
1010 }
1011
1012 #end[char]
1013
1014 public static void test(final $type$ [] ba) {
1015 int offset = 47;
1016 int length = 900;
1017 final $Type$Buffer b = $Type$Buffer.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, () -> $Type$Buffer.wrap(ba, -1, ba.length));
1025 catchIndexOutOfBounds(ba, () -> $Type$Buffer.wrap(ba, ba.length + 1, ba.length));
1026 catchIndexOutOfBounds(ba, () -> $Type$Buffer.wrap(ba, 0, -1));
1027 catchIndexOutOfBounds(ba, () -> $Type$Buffer.wrap(ba, 0, ba.length + 1));
1028
1029 // A NullPointerException will be thrown if the array is null.
1030 tryCatch(ba, NullPointerException.class,
1031 () -> $Type$Buffer.wrap(($type$ []) null, 0, 5));
1032 tryCatch(ba, NullPointerException.class,
1033 () -> $Type$Buffer.wrap(($type$ []) null));
1034 }
1035
1036 private static void testAllocate() {
1037 // An IllegalArgumentException will be thrown for negative capacities.
1038 catchIllegalArgument((Buffer) null, () -> $Type$Buffer.allocate(-1));
1039 try {
1040 $Type$Buffer.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 #if[byte]
1048 catchIllegalArgument((Buffer) null, () -> $Type$Buffer.allocateDirect(-1));
1049 try {
1050 $Type$Buffer.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 #end[byte]
1058 }
1059
1060 public static void test() {
1061 testAllocate();
1062 test(0, $Type$Buffer.allocate(7 * 1024), false);
1063 test(0, $Type$Buffer.wrap(new $type$[7 * 1024], 0, 7 * 1024), false);
1064 test(new $type$[1024]);
1065 #if[byte]
1066 $Type$Buffer b = $Type$Buffer.allocateDirect(7 * 1024);
1067 for (b.position(0); b.position() < b.limit(); )
1068 ck(b, b.get(), 0);
1069 test(0, b, true);
1070 #end[byte]
1071 #if[char]
1072 testStr();
1073 #end[char]
1074
1075 callReset($Type$Buffer.allocate(10));
1076
1077 #if[byte]
1078 #else[byte]
1079 putBuffer();
1080 #end[byte]
1081 }
1082
1083 }