44     protected IntBuffer buf;
48         buf = IntBuffer.allocate(BUFFER_LENGTH);
49         loadTestData1(buf);
50         baseBuf = buf;
54         buf = null;
102         int array[] = buf.array();
103         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
105         loadTestData1(array, buf.arrayOffset(), buf.capacity());
106         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
108         loadTestData2(array, buf.arrayOffset(), buf.capacity());
109         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
111         loadTestData1(buf);
112         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
114         loadTestData2(buf);
115         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
125         int array[] = buf.array();
126         for(int i = 0; i < buf.capacity(); i++) {
129         int offset = buf.arrayOffset();
130         assertContentEquals(buf, array, offset, buf.capacity());
135         assertContentEquals(buf, array, offset, buf.capacity());
138         assertContentEquals(buf, array, offset, buf.capacity());
148         buf.clear();
149         buf.mark();
150         buf.position(buf.limit());
152         // readonly's contents should be the same as buf
153         IntBuffer readonly = buf.asReadOnlyBuffer();
154         assertNotSame(buf, readonly);
156         assertEquals(buf.position(), readonly.position());
157         assertEquals(buf.limit(), readonly.limit());
158         assertEquals(buf.isDirect(), readonly.isDirect());
159         assertEquals(buf.order(), readonly.order());
160         assertContentEquals(buf, readonly);
162         // readonly's position, mark, and limit should be independent to buf
166         assertEquals(buf.position(), buf.limit());
167         buf.reset();
168         assertEquals(buf.position(), 0);
180         buf.clear();
181         buf.mark();
182         loadTestData1(buf);
183         IntBuffer ret = buf.compact();
184         assertSame(ret, buf);
185         assertEquals(buf.position(), buf.capacity());
186         assertEquals(buf.limit(), buf.capacity());
187         assertContentLikeTestData1(buf, 0, 0, buf.capacity());
189             buf.reset();
196         buf.position(0);
197         buf.limit(0);
198         buf.mark();
199         ret = buf.compact();
200         assertSame(ret, buf);
201         assertEquals(buf.position(), 0);
202         assertEquals(buf.limit(), buf.capacity());
203         assertContentLikeTestData1(buf, 0, 0, buf.capacity());
208             buf.reset();
215         assertTrue(buf.capacity() > 5);
216         buf.position(1);
217         buf.limit(5);
218         buf.mark();
219         ret = buf.compact();
220         assertSame(ret, buf);
221         assertEquals(buf.position(), 4);
222         assertEquals(buf.limit(), buf.capacity());
223         assertContentLikeTestData1(buf, 0, 1, 4);
225             buf.reset();
240         assertEquals(0, buf.compareTo(buf));
243         assertTrue(buf.capacity() > 5);
244         buf.clear();
245         IntBuffer other = IntBuffer.allocate(buf.capacity());
247         assertEquals(0, buf.compareTo(other));
248         assertEquals(0, other.compareTo(buf));
249         buf.position(1);
250         assertTrue(buf.compareTo(other) > 0);
251         assertTrue(other.compareTo(buf) < 0);
253         assertTrue(buf.compareTo(other) < 0);
254         assertTrue(other.compareTo(buf) > 0);
255         buf.position(2);
257         assertTrue(buf.compareTo(other) > 0);
258         assertTrue(other.compareTo(buf) < 0);
268         buf.clear();
269         buf.mark();
270         buf.position(buf.limit());
272         // duplicate's contents should be the same as buf
273         IntBuffer duplicate = buf.duplicate();
274         assertNotSame(buf, duplicate);
275         assertEquals(buf.position(), duplicate.position());
276         assertEquals(buf.limit(), duplicate.limit());
277         assertEquals(buf.isReadOnly(), duplicate.isReadOnly());
278         assertEquals(buf.isDirect(), duplicate.isDirect());
279         assertEquals(buf.order(), duplicate.order());
280         assertContentEquals(buf, duplicate);
282         // duplicate's position, mark, and limit should be independent to buf
286         assertEquals(buf.position(), buf.limit());
287         buf.reset();
288         assertEquals(buf.position(), 0);
290         // duplicate share the same content with buf
292             loadTestData1(buf);
293             assertContentEquals(buf, duplicate);
295             assertContentEquals(buf, duplicate);
307         assertTrue(buf.equals(buf));
308         IntBuffer readonly = buf.asReadOnlyBuffer();
309         assertTrue(buf.equals(readonly));
310         IntBuffer duplicate = buf.duplicate();
311         assertTrue(buf.equals(duplicate));
314         assertFalse(buf.equals(Boolean.TRUE));
316         assertTrue(buf.capacity() > 5);
318         buf.limit(buf.capacity()).position(0);
320         assertFalse(buf.equals(readonly));
322         buf.limit(buf.capacity() - 1).position(0);
324         assertFalse(buf.equals(duplicate));
337         buf.clear();
338         for (int i = 0; i < buf.capacity(); i++) {
339             assertEquals(buf.position(), i);
340             assertEquals(buf.get(), buf.get(i));
343             buf.get();
361         buf.clear();
362         for (int i = 0; i < buf.capacity(); i++) {
363             assertEquals(buf.position(), i);
364             IntBuffer ret = buf.get(array);
365             assertEquals(array[0], buf.get(i));
366             assertSame(ret, buf);
369         buf.get(new int[0]);
372             buf.get(array);
379             buf.get((int[])null);
396         buf.clear();
397         int array[] = new int[buf.capacity()];
400             buf.get(new int[buf.capacity() + 1], 0, buf.capacity() + 1);
405         assertEquals(buf.position(), 0);
407             buf.get(array, -1, array.length);
412         buf.get(array, array.length, 0);
414             buf.get(array, array.length + 1, 1);
419         assertEquals(buf.position(), 0);
421             buf.get(array, 2, -1);
427             buf.get((int[])null, 2, -1);
433             buf.get(array, 2, array.length);
439             buf.get(array, 1, Integer.MAX_VALUE);
445             buf.get(array, Integer.MAX_VALUE, 1);
450         assertEquals(buf.position(), 0);
452         buf.clear();
453         IntBuffer ret = buf.get(array, 0, array.length);
454         assertEquals(buf.position(), buf.capacity());
455         assertContentEquals(buf, array, 0, array.length);
456         assertSame(ret, buf);
469         buf.clear();
470         for (int i = 0; i < buf.capacity(); i++) {
471             assertEquals(buf.position(), i);
472             assertEquals(buf.get(), buf.get(i));
475             buf.get(-1);
481             buf.get(buf.limit());
495         if (buf.hasArray()) {
496             assertNotNull(buf.array());
499                 buf.array();
517         buf.clear();
518         IntBuffer readonly = buf.asReadOnlyBuffer();
519         IntBuffer duplicate = buf.duplicate();
520         assertTrue(buf.hashCode() == readonly.hashCode());
522         assertTrue(buf.capacity() > 5);
523         duplicate.position(buf.capacity() / 2);
524         assertTrue(buf.hashCode() != duplicate.hashCode());
534         assertFalse(buf.isDirect());
544         assertFalse(buf.isReadOnly());
554         assertEquals(ByteOrder.nativeOrder(), buf.order());
567         buf.clear();
568         for (int i = 0; i < buf.capacity(); i++) {
569             assertEquals(buf.position(), i);
570             IntBuffer ret = buf.put((int) i);
571             assertEquals(buf.get(i), (int) i);
572             assertSame(ret, buf);
575             buf.put(0);
593         buf.clear();
594         for (int i = 0; i < buf.capacity(); i++) {
595             assertEquals(buf.position(), i);
597             IntBuffer ret = buf.put(array);
598             assertEquals(buf.get(i), (int) i);
599             assertSame(ret, buf);
602             buf.put(array);
608             buf.position(buf.limit());
609             buf.put((int[])null);
626         buf.clear();
627         int array[] = new int[buf.capacity()];
629             buf.put(new int[buf.capacity() + 1], 0, buf.capacity() + 1);
634         assertEquals(buf.position(), 0);
636             buf.put(array, -1, array.length);
642             buf.put(array, array.length + 1, 0);
647         buf.put(array, array.length, 0);
648         assertEquals(buf.position(), 0);
650             buf.put(array, 0, -1);
656             buf.put((int[])null, 0, -1);
662             buf.put(array, 2, array.length);
668             buf.put(array, Integer.MAX_VALUE, 1);
674             buf.put(array, 1, Integer.MAX_VALUE);
679         assertEquals(buf.position(), 0);
682         IntBuffer ret = buf.put(array, 0, array.length);
683         assertEquals(buf.position(), buf.capacity());
684         assertContentEquals(buf, array, 0, array.length);
685         assertSame(ret, buf);
699         ByteBuffer buf = ByteBuffer.allocateDirect(20);
700         IntBuffer intBuf = buf.asIntBuffer();
721         IntBuffer other = IntBuffer.allocate(buf.capacity());
723             buf.put(buf);
729             buf.put(IntBuffer.allocate(buf.capacity() + 1));
735             buf.flip();
736             buf.put((IntBuffer)null);
744         buf.clear();
745         IntBuffer ret = buf.put(other);
747         assertEquals(buf.position(), buf.capacity());
748         assertContentEquals(other, buf);
749         assertSame(ret, buf);
762         buf.clear();
763         for (int i = 0; i < buf.capacity(); i++) {
764             assertEquals(buf.position(), 0);
765             IntBuffer ret = buf.put(i, (int) i);
766             assertEquals(buf.get(i), (int) i);
767             assertSame(ret, buf);
770             buf.put(-1, 0);
776             buf.put(buf.limit(), 0);
790         assertTrue(buf.capacity() > 5);
791         buf.position(1);
792         buf.limit(buf.capacity() - 1);
794         IntBuffer slice = buf.slice();
795         assertEquals(buf.isReadOnly(), slice.isReadOnly());
796         assertEquals(buf.isDirect(), slice.isDirect());
797         assertEquals(buf.order(), slice.order());
799         assertEquals(slice.limit(), buf.remaining());
800         assertEquals(slice.capacity(), buf.remaining());
808         // slice share the same content with buf
811             assertContentLikeTestData1(buf, 1, 0, slice.capacity());
812             buf.put(2, 500);
824         String str = buf.toString();
826         assertTrue(str.indexOf("" + buf.position()) >= 0);
827         assertTrue(str.indexOf("" + buf.limit()) >= 0);
828         assertTrue(str.indexOf("" + buf.capacity()) >= 0);
858         loadTestData2(array, 0, buf.capacity());
893         loadTestData2(array, 0, buf.capacity());
918     void loadTestData1(IntBuffer buf) {
919         buf.clear();
920         for (int i = 0; i < buf.capacity(); i++) {
921             buf.put(i, (int)i);
925     void loadTestData2(IntBuffer buf) {
926         buf.clear();
927         for (int i = 0; i < buf.capacity(); i++) {
928             buf.put(i, (int)buf.capacity() - i);
932       void assertContentEquals(IntBuffer buf, int array[],
935             assertEquals(buf.get(i), array[offset + i]);
939       void assertContentEquals(IntBuffer buf, IntBuffer other) {
940         assertEquals(buf.capacity(), other.capacity());
941         for (int i = 0; i < buf.capacity(); i++) {
942             assertEquals(buf.get(i), other.get(i));
946       void assertContentLikeTestData1(IntBuffer buf,
950             assertEquals(buf.get(startIndex + i), value);

Indexes created Mon Aug 13 18:52:36 CEST 2012