37     protected IntBuffer buf;
40         buf = IntBuffer.allocate(BUFFER_LENGTH);
41         loadTestData1(buf);
42         baseBuf = buf;
46         buf = null;
51         int array[] = buf.array();
52         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
54         loadTestData1(array, buf.arrayOffset(), buf.capacity());
55         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
57         loadTestData2(array, buf.arrayOffset(), buf.capacity());
58         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
60         loadTestData1(buf);
61         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
63         loadTestData2(buf);
64         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
68         int array[] = buf.array();
69         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
71         loadTestData1(array, buf.arrayOffset(), buf.capacity());
72         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
74         loadTestData2(array, buf.arrayOffset(), buf.capacity());
75         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
77         loadTestData1(buf);
78         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
80         loadTestData2(buf);
81         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
85         buf.clear();
86         buf.mark();
87         buf.position(buf.limit());
89         // readonly's contents should be the same as buf
90         IntBuffer readonly = buf.asReadOnlyBuffer();
91         assertNotSame(buf, readonly);
93         assertEquals(buf.position(), readonly.position());
94         assertEquals(buf.limit(), readonly.limit());
95         assertEquals(buf.isDirect(), readonly.isDirect());
96         assertEquals(buf.order(), readonly.order());
97         assertContentEquals(buf, readonly);
99         // readonly's position, mark, and limit should be independent to buf
103         assertEquals(buf.position(), buf.limit());
104         buf.reset();
105         assertEquals(buf.position(), 0);
110         buf.clear();
111         buf.mark();
112         loadTestData1(buf);
113         IntBuffer ret = buf.compact();
114         assertSame(ret, buf);
115         assertEquals(buf.position(), buf.capacity());
116         assertEquals(buf.limit(), buf.capacity());
117         assertContentLikeTestData1(buf, 0, 0, buf.capacity());
119             buf.reset();
126         buf.position(0);
127         buf.limit(0);
128         buf.mark();
129         ret = buf.compact();
130         assertSame(ret, buf);
131         assertEquals(buf.position(), 0);
132         assertEquals(buf.limit(), buf.capacity());
133         assertContentLikeTestData1(buf, 0, 0, buf.capacity());
135             buf.reset();
142         assertTrue(buf.capacity() > 5);
143         buf.position(1);
144         buf.limit(5);
145         buf.mark();
146         ret = buf.compact();
147         assertSame(ret, buf);
148         assertEquals(buf.position(), 4);
149         assertEquals(buf.limit(), buf.capacity());
150         assertContentLikeTestData1(buf, 0, 1, 4);
152             buf.reset();
161         assertEquals(0, buf.compareTo(buf));
164         assertTrue(buf.capacity() > 5);
165         buf.clear();
166         IntBuffer other = IntBuffer.allocate(buf.capacity());
168         assertEquals(0, buf.compareTo(other));
169         assertEquals(0, other.compareTo(buf));
170         buf.position(1);
171         assertTrue(buf.compareTo(other) > 0);
172         assertTrue(other.compareTo(buf) < 0);
174         assertTrue(buf.compareTo(other) < 0);
175         assertTrue(other.compareTo(buf) > 0);
176         buf.position(2);
178         assertTrue(buf.compareTo(other) > 0);
179         assertTrue(other.compareTo(buf) < 0);
183         buf.clear();
184         buf.mark();
185         buf.position(buf.limit());
187         // duplicate's contents should be the same as buf
188         IntBuffer duplicate = buf.duplicate();
189         assertNotSame(buf, duplicate);
190         assertEquals(buf.position(), duplicate.position());
191         assertEquals(buf.limit(), duplicate.limit());
192         assertEquals(buf.isReadOnly(), duplicate.isReadOnly());
193         assertEquals(buf.isDirect(), duplicate.isDirect());
194         assertEquals(buf.order(), duplicate.order());
195         assertContentEquals(buf, duplicate);
197         // duplicate's position, mark, and limit should be independent to buf
201         assertEquals(buf.position(), buf.limit());
202         buf.reset();
203         assertEquals(buf.position(), 0);
205         // duplicate share the same content with buf
207             loadTestData1(buf);
208             assertContentEquals(buf, duplicate);
210             assertContentEquals(buf, duplicate);
216         assertTrue(buf.equals(buf));
217         IntBuffer readonly = buf.asReadOnlyBuffer();
218         assertTrue(buf.equals(readonly));
219         IntBuffer duplicate = buf.duplicate();
220         assertTrue(buf.equals(duplicate));
223         assertFalse(buf.equals(Boolean.TRUE));
225         assertTrue(buf.capacity() > 5);
227         buf.limit(buf.capacity()).position(0);
229         assertFalse(buf.equals(readonly));
231         buf.limit(buf.capacity() - 1).position(0);
233         assertFalse(buf.equals(duplicate));
240         buf.clear();
241         for (int i = 0; i < buf.capacity(); i++) {
242             assertEquals(buf.position(), i);
243             assertEquals(buf.get(), buf.get(i));
246             buf.get();
258         buf.clear();
259         for (int i = 0; i < buf.capacity(); i++) {
260             assertEquals(buf.position(), i);
261             IntBuffer ret = buf.get(array);
262             assertEquals(array[0], buf.get(i));
263             assertSame(ret, buf);
266             buf.get(array);
272             buf.get((int[])null);
283         buf.clear();
284         int array[] = new int[buf.capacity()];
287             buf.get(new int[buf.capacity() + 1], 0, buf.capacity() + 1);
292         assertEquals(buf.position(), 0);
294             buf.get(array, -1, array.length);
299         buf.get(array, array.length, 0);
301             buf.get(array, array.length + 1, 1);
306         assertEquals(buf.position(), 0);
308             buf.get(array, 2, -1);
314             buf.get((int[])null, 2, -1);
320             buf.get(array, 2, array.length);
326             buf.get(array, 1, Integer.MAX_VALUE);
332             buf.get(array, Integer.MAX_VALUE, 1);
337         assertEquals(buf.position(), 0);
339         buf.clear();
340         IntBuffer ret = buf.get(array, 0, array.length);
341         assertEquals(buf.position(), buf.capacity());
342         assertContentEquals(buf, array, 0, array.length);
343         assertSame(ret, buf);
350         buf.clear();
351         for (int i = 0; i < buf.capacity(); i++) {
352             assertEquals(buf.position(), i);
353             assertEquals(buf.get(), buf.get(i));
356             buf.get(-1);
362             buf.get(buf.limit());
370         assertNotNull(buf.array());
374         buf.clear();
375         IntBuffer readonly = buf.asReadOnlyBuffer();
376         IntBuffer duplicate = buf.duplicate();
377         assertTrue(buf.hashCode() == readonly.hashCode());
379         assertTrue(buf.capacity() > 5);
380         duplicate.position(buf.capacity() / 2);
381         assertTrue(buf.hashCode() != duplicate.hashCode());
385         assertFalse(buf.isDirect());
389         buf.order();
390         assertEquals(ByteOrder.nativeOrder(), buf.order());
397         buf.clear();
398         for (int i = 0; i < buf.capacity(); i++) {
399             assertEquals(buf.position(), i);
400             IntBuffer ret = buf.put((int) i);
401             assertEquals(buf.get(i), (int) i);
402             assertSame(ret, buf);
405             buf.put(0);
417         buf.clear();
418         for (int i = 0; i < buf.capacity(); i++) {
419             assertEquals(buf.position(), i);
421             IntBuffer ret = buf.put(array);
422             assertEquals(buf.get(i), (int) i);
423             assertSame(ret, buf);
426             buf.put(array);
432             buf.position(buf.limit());
433             buf.put((int[])null);
444         buf.clear();
445         int array[] = new int[buf.capacity()];
447             buf.put(new int[buf.capacity() + 1], 0, buf.capacity() + 1);
452         assertEquals(buf.position(), 0);
454             buf.put(array, -1, array.length);
460             buf.put(array, array.length + 1, 0);
465         buf.put(array, array.length, 0);
466         assertEquals(buf.position(), 0);
468             buf.put(array, 0, -1);
474             buf.put((int[])null, 0, -1);
480             buf.put(array, 2, array.length);
486             buf.put(array, Integer.MAX_VALUE, 1);
492             buf.put(array, 1, Integer.MAX_VALUE);
497         assertEquals(buf.position(), 0);
500         IntBuffer ret = buf.put(array, 0, array.length);
501         assertEquals(buf.position(), buf.capacity());
502         assertContentEquals(buf, array, 0, array.length);
503         assertSame(ret, buf);
510         IntBuffer other = IntBuffer.allocate(buf.capacity());
512             buf.put(buf);
518             buf.put(IntBuffer.allocate(buf.capacity() + 1));
524             buf.flip();
525             buf.put((IntBuffer)null);
533         buf.clear();
534         IntBuffer ret = buf.put(other);
536         assertEquals(buf.position(), buf.capacity());
537         assertContentEquals(other, buf);
538         assertSame(ret, buf);
545         buf.clear();
546         for (int i = 0; i < buf.capacity(); i++) {
547             assertEquals(buf.position(), 0);
548             IntBuffer ret = buf.put(i, (int) i);
549             assertEquals(buf.get(i), (int) i);
550             assertSame(ret, buf);
553             buf.put(-1, 0);
559             buf.put(buf.limit(), 0);
567         assertTrue(buf.capacity() > 5);
568         buf.position(1);
569         buf.limit(buf.capacity() - 1);
571         IntBuffer slice = buf.slice();
572         assertEquals(buf.isReadOnly(), slice.isReadOnly());
573         assertEquals(buf.isDirect(), slice.isDirect());
574         assertEquals(buf.order(), slice.order());
576         assertEquals(slice.limit(), buf.remaining());
577         assertEquals(slice.capacity(), buf.remaining());
585         // slice share the same content with buf
588             assertContentLikeTestData1(buf, 1, 0, slice.capacity());
589             buf.put(2, 500);
595         String str = buf.toString();
597         assertTrue(str.indexOf("" + buf.position()) >= 0);
598         assertTrue(str.indexOf("" + buf.limit()) >= 0);
599         assertTrue(str.indexOf("" + buf.capacity()) >= 0);
614       void loadTestData1(IntBuffer buf) {
615         buf.clear();
616         for (int i = 0; i < buf.capacity(); i++) {
617             buf.put(i, (int) i);
621       void loadTestData2(IntBuffer buf) {
622         buf.clear();
623         for (int i = 0; i < buf.capacity(); i++) {
624             buf.put(i, (int) buf.capacity() - i);
628       void assertContentEquals(IntBuffer buf, int array[],
631             assertEquals(buf.get(i), array[offset + i]);
635       void assertContentEquals(IntBuffer buf, IntBuffer other) {
636         assertEquals(buf.capacity(), other.capacity());
637         for (int i = 0; i < buf.capacity(); i++) {
638             assertEquals(buf.get(i), other.get(i));
642       void assertContentLikeTestData1(IntBuffer buf,
646             assertEquals(buf.get(startIndex + i), value);

Indexes created Thu Nov 22 16:40:23 CET 2012