1 /*
2 * Copyright 2000-2008 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any 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 import java.lang.reflect.Method;
35
36
37 public class Basic$Type$
38 extends Basic
39 {
40
41 private static void relGet($Type$Buffer b) {
42 int n = b.capacity();
43 $type$ v;
44 for (int i = 0; i < n; i++)
45 ck(b, (long)b.get(), (long)(($type$)ic(i)));
46 b.rewind();
47 }
48
49 private static void relGet($Type$Buffer b, int start) {
50 int n = b.remaining();
51 $type$ v;
52 for (int i = start; i < n; i++)
53 ck(b, (long)b.get(), (long)(($type$)ic(i)));
54 b.rewind();
55 }
56
57 private static void absGet($Type$Buffer b) {
58 int n = b.capacity();
59 $type$ v;
60 for (int i = 0; i < n; i++)
61 ck(b, (long)b.get(), (long)(($type$)ic(i)));
62 b.rewind();
63 }
64
65 private static void bulkGet($Type$Buffer b) {
66 int n = b.capacity();
67 $type$[] a = new $type$[n + 7];
68 b.get(a, 7, n);
69 for (int i = 0; i < n; i++)
70 ck(b, (long)a[i + 7], (long)(($type$)ic(i)));
71 }
72
73 private static void relPut($Type$Buffer b) {
74 int n = b.capacity();
75 b.clear();
76 for (int i = 0; i < n; i++)
77 b.put(($type$)ic(i));
78 b.flip();
79 }
80
81 private static void absPut($Type$Buffer b) {
82 int n = b.capacity();
83 b.clear();
84 for (int i = 0; i < n; i++)
85 b.put(i, ($type$)ic(i));
86 b.limit(n);
87 b.position(0);
88 }
89
90 private static void bulkPutArray($Type$Buffer b) {
91 int n = b.capacity();
92 b.clear();
93 $type$[] a = new $type$[n + 7];
94 for (int i = 0; i < n; i++)
95 a[i + 7] = ($type$)ic(i);
96 b.put(a, 7, n);
97 b.flip();
98 }
99
100 private static void bulkPutBuffer($Type$Buffer b) {
101 int n = b.capacity();
102 b.clear();
103 $Type$Buffer c = $Type$Buffer.allocate(n + 7);
104 c.position(7);
105 for (int i = 0; i < n; i++)
106 c.put(($type$)ic(i));
107 c.flip();
108 c.position(7);
109 b.put(c);
110 b.flip();
111 }
112
113 //6231529
114 private static void callReset($Type$Buffer b) {
115 b.position(0);
116 b.mark();
117
118 b.duplicate().reset();
119 b.asReadOnlyBuffer().reset();
120 }
121
122 #if[byte]
123 #else[byte]
124 // 6221101-6234263
125
126 private static void putBuffer() {
127 final int cap = 10;
128
129 $Type$Buffer direct1 = ByteBuffer.allocateDirect(cap).as$Type$Buffer();
130 $Type$Buffer nondirect1 = ByteBuffer.allocate(cap).as$Type$Buffer();
131 direct1.put(nondirect1);
132
133 $Type$Buffer direct2 = ByteBuffer.allocateDirect(cap).as$Type$Buffer();
134 $Type$Buffer nondirect2 = ByteBuffer.allocate(cap).as$Type$Buffer();
135 nondirect2.put(direct2);
136
137 $Type$Buffer direct3 = ByteBuffer.allocateDirect(cap).as$Type$Buffer();
138 $Type$Buffer direct4 = ByteBuffer.allocateDirect(cap).as$Type$Buffer();
139 direct3.put(direct4);
140
141 $Type$Buffer nondirect3 = ByteBuffer.allocate(cap).as$Type$Buffer();
142 $Type$Buffer nondirect4 = ByteBuffer.allocate(cap).as$Type$Buffer();
143 nondirect3.put(nondirect4);
144 }
145 #end[byte]
146
147 #if[char]
148
149 private static void bulkPutString($Type$Buffer b) {
150 int n = b.capacity();
151 b.clear();
152 StringBuffer sb = new StringBuffer(n + 7);
153 sb.append("1234567");
154 for (int i = 0; i < n; i++)
155 sb.append((char)ic(i));
156 b.put(sb.toString(), 7, 7 + n);
157 b.flip();
158 }
159
160 #end[char]
161
162 private static void checkSlice($Type$Buffer b, $Type$Buffer slice) {
163 ck(slice, 0, slice.position());
164 ck(slice, b.remaining(), slice.limit());
165 ck(slice, b.remaining(), slice.capacity());
166 if (b.isDirect() != slice.isDirect())
167 fail("Lost direction", slice);
168 if (b.isReadOnly() != slice.isReadOnly())
169 fail("Lost read-only", slice);
170 }
171
172 #if[byte]
173
174 private static void checkBytes(ByteBuffer b, byte[] bs) {
175 int n = bs.length;
176 int p = b.position();
177 byte v;
178 if (b.order() == ByteOrder.BIG_ENDIAN) {
179 for (int i = 0; i < n; i++)
180 ck(b, b.get(), bs[i]);
181 } else {
182 for (int i = n - 1; i >= 0; i--)
183 ck(b, b.get(), bs[i]);
184 }
185 b.position(p);
186 }
187
188 private static void compact(Buffer b) {
189 try {
190 Class<?> cl = b.getClass();
191 Method m = cl.getDeclaredMethod("compact");
192 m.setAccessible(true);
193 m.invoke(b);
194 } catch (Exception e) {
195 fail(e.getMessage(), b);
196 }
197 }
198
199 private static void checkInvalidMarkException(final Buffer b) {
200 tryCatch(b, InvalidMarkException.class, new Runnable() {
201 public void run() {
202 b.mark();
203 compact(b);
204 b.reset();
205 }});
206 }
207
208 private static void testViews(int level, ByteBuffer b, boolean direct) {
209
210 ShortBuffer sb = b.asShortBuffer();
211 BasicShort.test(level, sb, direct);
212 checkBytes(b, new byte[] { 0, (byte)ic(0) });
213 checkInvalidMarkException(sb);
214
215 CharBuffer cb = b.asCharBuffer();
216 BasicChar.test(level, cb, direct);
217 checkBytes(b, new byte[] { 0, (byte)ic(0) });
218 checkInvalidMarkException(cb);
219
220 IntBuffer ib = b.asIntBuffer();
221 BasicInt.test(level, ib, direct);
222 checkBytes(b, new byte[] { 0, 0, 0, (byte)ic(0) });
223 checkInvalidMarkException(ib);
224
225 LongBuffer lb = b.asLongBuffer();
226 BasicLong.test(level, lb, direct);
227 checkBytes(b, new byte[] { 0, 0, 0, 0, 0, 0, 0, (byte)ic(0) });
228 checkInvalidMarkException(lb);
229
230 FloatBuffer fb = b.asFloatBuffer();
231 BasicFloat.test(level, fb, direct);
232 checkBytes(b, new byte[] { 0x42, (byte)0xc2, 0, 0 });
233 checkInvalidMarkException(fb);
234
235 DoubleBuffer db = b.asDoubleBuffer();
236 BasicDouble.test(level, db, direct);
237 checkBytes(b, new byte[] { 0x40, 0x58, 0x40, 0, 0, 0, 0, 0 });
238 checkInvalidMarkException(db);
239 }
240
241 private static void testHet(int level, ByteBuffer b) {
242
243 int p = b.position();
244 b.limit(b.capacity());
245 show(level, b);
246 out.print(" put:");
247
248 b.putChar((char)1);
249 b.putChar((char)Character.MAX_VALUE);
250 out.print(" char");
251
252 b.putShort((short)1);
253 b.putShort((short)Short.MAX_VALUE);
254 out.print(" short");
255
256 b.putInt(1);
257 b.putInt(Integer.MAX_VALUE);
258 out.print(" int");
259
260 b.putLong((long)1);
261 b.putLong((long)Long.MAX_VALUE);
262 out.print(" long");
263
264 b.putFloat((float)1);
265 b.putFloat((float)Float.MIN_VALUE);
266 b.putFloat((float)Float.MAX_VALUE);
267 out.print(" float");
268
269 b.putDouble((double)1);
270 b.putDouble((double)Double.MIN_VALUE);
271 b.putDouble((double)Double.MAX_VALUE);
272 out.print(" double");
273
274 out.println();
275 b.limit(b.position());
276 b.position(p);
277 show(level, b);
278 out.print(" get:");
279
280 ck(b, b.getChar(), 1);
281 ck(b, b.getChar(), Character.MAX_VALUE);
282 out.print(" char");
283
284 ck(b, b.getShort(), 1);
285 ck(b, b.getShort(), Short.MAX_VALUE);
286 out.print(" short");
287
288 ck(b, b.getInt(), 1);
289 ck(b, b.getInt(), Integer.MAX_VALUE);
290 out.print(" int");
291
292 ck(b, b.getLong(), 1);
293 ck(b, b.getLong(), Long.MAX_VALUE);
294 out.print(" long");
295
296 ck(b, (long)b.getFloat(), 1);
297 ck(b, (long)b.getFloat(), (long)Float.MIN_VALUE);
298 ck(b, (long)b.getFloat(), (long)Float.MAX_VALUE);
299 out.print(" float");
300
301 ck(b, (long)b.getDouble(), 1);
302 ck(b, (long)b.getDouble(), (long)Double.MIN_VALUE);
303 ck(b, (long)b.getDouble(), (long)Double.MAX_VALUE);
304 out.print(" double");
305
306 out.println();
307
308 }
309
310 #end[byte]
311
312 private static void tryCatch(Buffer b, Class ex, Runnable thunk) {
313 boolean caught = false;
314 try {
315 thunk.run();
316 } catch (Throwable x) {
317 if (ex.isAssignableFrom(x.getClass())) {
318 caught = true;
319 } else {
320 fail(x.getMessage() + " not expected");
321 }
322 }
323 if (!caught)
324 fail(ex.getName() + " not thrown", b);
325 }
326
327 private static void tryCatch($type$ [] t, Class ex, Runnable thunk) {
328 tryCatch($Type$Buffer.wrap(t), ex, thunk);
329 }
330
331 public static void test(int level, final $Type$Buffer b, boolean direct) {
332
333 show(level, b);
334
335 if (direct != b.isDirect())
336 fail("Wrong direction", b);
337
338 // Gets and puts
339
340 relPut(b);
341 relGet(b);
342 absGet(b);
343 bulkGet(b);
344
345 absPut(b);
346 relGet(b);
347 absGet(b);
348 bulkGet(b);
349
350 bulkPutArray(b);
351 relGet(b);
352
353 bulkPutBuffer(b);
354 relGet(b);
355
356 #if[char]
357
358 bulkPutString(b);
359 relGet(b);
360 b.position(1);
361 b.limit(7);
362 ck(b, b.toString().equals("bcdefg"));
363
364 // CharSequence ops
365
366 b.position(2);
367 ck(b, b.charAt(1), 'd');
368 CharBuffer c = (CharBuffer)b.subSequence(1, 4);
369 ck(b, b.subSequence(1, 4).toString().equals("def"));
370
371 // 4938424
372 b.position(4);
373 ck(b, b.charAt(1), 'f');
374 ck(b, b.subSequence(1, 3).toString().equals("fg"));
375
376 #end[char]
377
378 // Compact
379
380 relPut(b);
381 b.position(13);
382 b.compact();
383 b.flip();
384 relGet(b, 13);
385
386 // Exceptions
387
388 relPut(b);
389 b.limit(b.capacity() / 2);
390 b.position(b.limit());
391
392 tryCatch(b, BufferUnderflowException.class, new Runnable() {
393 public void run() {
394 b.get();
395 }});
396
397 tryCatch(b, BufferOverflowException.class, new Runnable() {
398 public void run() {
399 b.put(($type$)42);
400 }});
401
402 // The index must be non-negative and lesss than the buffer's limit.
403 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
404 public void run() {
405 b.get(b.limit());
406 }});
407 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
408 public void run() {
409 b.get(-1);
410 }});
411
412 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
413 public void run() {
414 b.put(b.limit(), ($type$)42);
415 }});
416
417 tryCatch(b, InvalidMarkException.class, new Runnable() {
418 public void run() {
419 b.position(0);
420 b.mark();
421 b.compact();
422 b.reset();
423 }});
424
425 // Values
426
427 b.clear();
428 b.put(($type$)0);
429 b.put(($type$)-1);
430 b.put(($type$)1);
431 b.put($Fulltype$.MAX_VALUE);
432 b.put($Fulltype$.MIN_VALUE);
433 #if[float]
434 b.put(-Float.MAX_VALUE);
435 b.put(-Float.MIN_VALUE);
436 b.put(Float.NEGATIVE_INFINITY);
437 b.put(Float.POSITIVE_INFINITY);
438 b.put(Float.NaN);
439 b.put(0.91697687f); // Changes value if incorrectly swapped
440 #end[float]
441 #if[double]
442 b.put(-Double.MAX_VALUE);
443 b.put(-Double.MIN_VALUE);
444 b.put(Double.NEGATIVE_INFINITY);
445 b.put(Double.POSITIVE_INFINITY);
446 b.put(Double.NaN);
447 b.put(0.5121609353879392); // Changes value if incorrectly swapped
448 #end[double]
449
450 $type$ v;
451 b.flip();
452 ck(b, b.get(), 0);
453 ck(b, b.get(), ($type$)-1);
454 ck(b, b.get(), 1);
455 ck(b, b.get(), $Fulltype$.MAX_VALUE);
456 ck(b, b.get(), $Fulltype$.MIN_VALUE);
457
458 #if[float]
459 ck(b, b.get(), -Float.MAX_VALUE);
460 ck(b, b.get(), -Float.MIN_VALUE);
461 ck(b, b.get(), Float.NEGATIVE_INFINITY);
462 ck(b, b.get(), Float.POSITIVE_INFINITY);
463 if (Float.floatToRawIntBits(v = b.get()) != Float.floatToRawIntBits(Float.NaN))
464 fail(b, (long)Float.NaN, (long)v);
465 ck(b, b.get(), 0.91697687f);
466 #end[float]
467 #if[double]
468 ck(b, b.get(), -Double.MAX_VALUE);
469 ck(b, b.get(), -Double.MIN_VALUE);
470 ck(b, b.get(), Double.NEGATIVE_INFINITY);
471 ck(b, b.get(), Double.POSITIVE_INFINITY);
472 if (Double.doubleToRawLongBits(v = b.get())
473 != Double.doubleToRawLongBits(Double.NaN))
474 fail(b, (long)Double.NaN, (long)v);
475 ck(b, b.get(), 0.5121609353879392);
476 #end[double]
477
478
479 // Comparison
480 b.rewind();
481 $Type$Buffer b2 = $Type$Buffer.allocate(b.capacity());
482 b2.put(b);
483 b2.flip();
484 b.position(2);
485 b2.position(2);
486 if (!b.equals(b2)) {
487 for (int i = 2; i < b.limit(); i++) {
488 $type$ x = b.get(i);
489 $type$ y = b2.get(i);
490 if (x != y
491 #if[double]
492 || Double.compare(x, y) != 0
493 #end[double]
494 #if[float]
495 || Float.compare(x, y) != 0
496 #end[float]
497 )
498 out.println("[" + i + "] " + x + " != " + y);
499 }
500 fail("Identical buffers not equal", b, b2);
501 }
502 if (b.compareTo(b2) != 0)
503 fail("Comparison to identical buffer != 0", b, b2);
504
505 b.limit(b.limit() + 1);
506 b.position(b.limit() - 1);
507 b.put(($type$)99);
508 b.rewind();
509 b2.rewind();
510 if (b.equals(b2))
511 fail("Non-identical buffers equal", b, b2);
512 if (b.compareTo(b2) <= 0)
513 fail("Comparison to shorter buffer <= 0", b, b2);
514 b.limit(b.limit() - 1);
515
516 b.put(2, ($type$)42);
517 if (b.equals(b2))
518 fail("Non-identical buffers equal", b, b2);
519 if (b.compareTo(b2) <= 0)
520 fail("Comparison to lesser buffer <= 0", b, b2);
521
522 // Sub, dup
523
524 relPut(b);
525 relGet(b.duplicate());
526 b.position(13);
527 relGet(b.duplicate(), 13);
528 relGet(b.duplicate().slice(), 13);
529 relGet(b.slice(), 13);
530 relGet(b.slice().duplicate(), 13);
531
532 // Slice
533
534 b.position(5);
535 $Type$Buffer sb = b.slice();
536 checkSlice(b, sb);
537 b.position(0);
538 $Type$Buffer sb2 = sb.slice();
539 checkSlice(sb, sb2);
540
541 if (!sb.equals(sb2))
542 fail("Sliced slices do not match", sb, sb2);
543 if ((sb.hasArray()) && (sb.arrayOffset() != sb2.arrayOffset()))
544 fail("Array offsets do not match: "
545 + sb.arrayOffset() + " != " + sb2.arrayOffset(), sb, sb2);
546
547 #if[byte]
548
549 // Views
550
551 b.clear();
552 b.order(ByteOrder.BIG_ENDIAN);
553 testViews(level + 1, b, direct);
554
555 for (int i = 1; i <= 9; i++) {
556 b.position(i);
557 show(level + 1, b);
558 testViews(level + 2, b, direct);
559 }
560
561 b.position(0);
562 b.order(ByteOrder.LITTLE_ENDIAN);
563 testViews(level + 1, b, direct);
564
565 // Heterogeneous accessors
566
567 b.order(ByteOrder.BIG_ENDIAN);
568 for (int i = 0; i <= 9; i++) {
569 b.position(i);
570 testHet(level + 1, b);
571 }
572 b.order(ByteOrder.LITTLE_ENDIAN);
573 b.position(3);
574 testHet(level + 1, b);
575
576 #end[byte]
577
578 // Read-only views
579
580 b.rewind();
581 final $Type$Buffer rb = b.asReadOnlyBuffer();
582 if (!b.equals(rb))
583 fail("Buffer not equal to read-only view", b, rb);
584 show(level + 1, rb);
585
586 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
587 public void run() {
588 relPut(rb);
589 }});
590
591 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
592 public void run() {
593 absPut(rb);
594 }});
595
596 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
597 public void run() {
598 bulkPutArray(rb);
599 }});
600
601 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
602 public void run() {
603 bulkPutBuffer(rb);
604 }});
605
606 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
607 public void run() {
608 rb.compact();
609 }});
610
611 #if[byte]
612
613 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
614 public void run() {
615 rb.putChar((char)1);
616 }});
617 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
618 public void run() {
619 rb.putChar(0, (char)1);
620 }});
621
622 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
623 public void run() {
624 rb.putShort((short)1);
625 }});
626 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
627 public void run() {
628 rb.putShort(0, (short)1);
629 }});
630
631 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
632 public void run() {
633 rb.putInt(1);
634 }});
635 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
636 public void run() {
637 rb.putInt(0, 1);
638 }});
639
640 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
641 public void run() {
642 rb.putLong((long)1);
643 }});
644 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
645 public void run() {
646 rb.putLong(0, (long)1);
647 }});
648
649 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
650 public void run() {
651 rb.putFloat((float)1);
652 }});
653 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
654 public void run() {
655 rb.putFloat(0, (float)1);
656 }});
657
658 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
659 public void run() {
660 rb.putDouble((double)1);
661 }});
662 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
663 public void run() {
664 rb.putDouble(0, (double)1);
665 }});
666
667 #end[byte]
668
669 if (rb.getClass().getName().startsWith("java.nio.Heap")) {
670
671 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
672 public void run() {
673 rb.array();
674 }});
675
676 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
677 public void run() {
678 rb.arrayOffset();
679 }});
680
681 if (rb.hasArray())
682 fail("Read-only heap buffer's backing array is accessible",
683 rb);
684
685 }
686
687 // Bulk puts from read-only buffers
688
689 b.clear();
690 rb.rewind();
691 b.put(rb);
692
693 #if[byte]
694 // For byte buffers, test both the direct and non-direct cases
695 $Type$Buffer ob
696 = (b.isDirect()
697 ? $Type$Buffer.allocate(rb.capacity())
698 : $Type$Buffer.allocateDirect(rb.capacity()));
699 rb.rewind();
700 ob.put(rb);
701 #end[byte]
702
703 relPut(b); // Required by testViews
704
705 }
706
707 #if[char]
708
709 private static void testStr() {
710 final String s = "abcdefghijklm";
711 int start = 3;
712 int end = 9;
713 final CharBuffer b = CharBuffer.wrap(s, start, end);
714 show(0, b);
715 ck(b, b.toString().equals(s.substring(start, end)));
716 ck(b, b.toString().equals("defghi"));
717 ck(b, b.isReadOnly());
718 tryCatch(b, ReadOnlyBufferException.class, new Runnable() {
719 public void run() {
720 b.put('x');
721 }});
722 ck(b, start, b.position());
723 ck(b, end, b.limit());
724 ck(b, s.length(), b.capacity());
725
726 // The index, relative to the position, must be non-negative and
727 // smaller than remaining().
728 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
729 public void run() {
730 b.charAt(-1);
731 }});
732 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
733 public void run() {
734 b.charAt(b.remaining());
735 }});
736
737 // The index must be non-negative and less than the buffer's limit.
738 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
739 public void run() {
740 b.get(b.limit());
741 }});
742 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
743 public void run() {
744 b.get(-1);
745 }});
746
747 // The start must be non-negative and no larger than remaining().
748 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
749 public void run() {
750 b.subSequence(-1, b.remaining());
751 }});
752 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
753 public void run() {
754 b.subSequence(b.remaining() + 1, b.remaining());
755 }});
756
757 // The end must be no smaller than start and no larger than
758 // remaining().
759 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
760 public void run() {
761 b.subSequence(2, 1);
762 }});
763 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
764 public void run() {
765 b.subSequence(0, b.remaining() + 1);
766 }});
767
768 // The offset must be non-negative and no larger than <array.length>.
769 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
770 public void run() {
771 $Type$Buffer.wrap(s, -1, s.length());
772 }});
773 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
774 public void run() {
775 $Type$Buffer.wrap(s, s.length() + 1, s.length());
776 }});
777 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
778 public void run() {
779 $Type$Buffer.wrap(s, 1, 0);
780 }});
781 tryCatch(b, IndexOutOfBoundsException.class, new Runnable() {
782 public void run() {
783 $Type$Buffer.wrap(s, 0, s.length() + 1);
784 }});
785 }
786
787 #end[char]
788
789 public static void test(final $type$ [] ba) {
790 int offset = 47;
791 int length = 900;
792 final $Type$Buffer b = $Type$Buffer.wrap(ba, offset, length);
793 show(0, b);
794 ck(b, b.capacity(), ba.length);
795 ck(b, b.position(), offset);
796 ck(b, b.limit(), offset + length);
797
798 // The offset must be non-negative and no larger than <array.length>.
799 tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
800 public void run() {
801 $Type$Buffer.wrap(ba, -1, ba.length);
802 }});
803 tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
804 public void run() {
805 $Type$Buffer.wrap(ba, ba.length + 1, ba.length);
806 }});
807 tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
808 public void run() {
809 $Type$Buffer.wrap(ba, 0, -1);
810 }});
811 tryCatch(ba, IndexOutOfBoundsException.class, new Runnable() {
812 public void run() {
813 $Type$Buffer.wrap(ba, 0, ba.length + 1);
814 }});
815
816 // A NullPointerException will be thrown if the array is null.
817 tryCatch(ba, NullPointerException.class, new Runnable() {
818 public void run() {
819 $Type$Buffer.wrap(($type$ []) null, 0, 5);
820 }});
821 tryCatch(ba, NullPointerException.class, new Runnable() {
822 public void run() {
823 $Type$Buffer.wrap(($type$ []) null);
824 }});
825 }
826
827 private static void testAllocate() {
828 // An IllegalArgumentException will be thrown for negative capacities.
829 tryCatch((Buffer) null, IllegalArgumentException.class, new Runnable() {
830 public void run() {
831 $Type$Buffer.allocate(-1);
832 }});
833 #if[byte]
834 tryCatch((Buffer) null, IllegalArgumentException.class, new Runnable() {
835 public void run() {
836 $Type$Buffer.allocateDirect(-1);
837 }});
838 #end[byte]
839 }
840
841 public static void test() {
842 testAllocate();
843 test(0, $Type$Buffer.allocate(7 * 1024), false);
844 test(0, $Type$Buffer.wrap(new $type$[7 * 1024], 0, 7 * 1024), false);
845 test(new $type$[1024]);
846 #if[byte]
847 $Type$Buffer b = $Type$Buffer.allocateDirect(7 * 1024);
848 for (b.position(0); b.position() < b.limit(); )
849 ck(b, b.get(), 0);
850 test(0, b, true);
851 #end[byte]
852 #if[char]
853 testStr();
854 #end[char]
855
856 callReset($Type$Buffer.allocate(10));
857
858 #if[byte]
859 #else[byte]
860 putBuffer();
861 #end[byte]
862 }
863
864 }