37     protected LongBuffer buf;
40         buf = LongBuffer.allocate(BUFFER_LENGTH);
41         loadTestData1(buf);
42         baseBuf = buf;
46         buf = null;
51         long 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         long 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         LongBuffer 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         LongBuffer 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         LongBuffer other = LongBuffer.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         LongBuffer 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         LongBuffer readonly = buf.asReadOnlyBuffer();
218         assertTrue(buf.equals(readonly));
219         LongBuffer 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             LongBuffer ret = buf.get(array);
262             assertEquals(array[0], buf.get(i));
263             assertSame(ret, buf);
266             buf.get(array);
272             buf.position(buf.limit());
273             buf.get((long[])null);
284         buf.clear();
285         long array[] = new long[buf.capacity()];
288             buf.get(new long[buf.capacity() + 1], 0, buf.capacity() + 1);
293         assertEquals(buf.position(), 0);
295             buf.get(array, -1, array.length);
300         buf.get(array, array.length, 0);
302             buf.get(array, array.length + 1, 1);
307         assertEquals(buf.position(), 0);
309             buf.get(array, 2, -1);
315             buf.get((long[])null, 2, -1);
321             buf.get(array, 2, array.length);
327             buf.get(array, 1, Integer.MAX_VALUE);
333             buf.get(array, Integer.MAX_VALUE, 1);
338         assertEquals(buf.position(), 0);
340         buf.clear();
341         LongBuffer ret = buf.get(array, 0, array.length);
342         assertEquals(buf.position(), buf.capacity());
343         assertContentEquals(buf, array, 0, array.length);
344         assertSame(ret, buf);
351         buf.clear();
352         for (int i = 0; i < buf.capacity(); i++) {
353             assertEquals(buf.position(), i);
354             assertEquals(buf.get(), buf.get(i));
357             buf.get(-1);
363             buf.get(buf.limit());
371         assertNotNull(buf.array());
375         buf.clear();
376         LongBuffer readonly = buf.asReadOnlyBuffer();
377         LongBuffer duplicate = buf.duplicate();
378         assertTrue(buf.hashCode() == readonly.hashCode());
380         assertTrue(buf.capacity() > 5);
381         duplicate.position(buf.capacity() / 2);
382         assertTrue(buf.hashCode() != duplicate.hashCode());
386         assertFalse(buf.isDirect());
390         buf.order();
391         assertEquals(ByteOrder.nativeOrder(), buf.order());
398          buf.clear();
399         for (int i = 0; i < buf.capacity(); i++) {
400             assertEquals(buf.position(), i);
401             LongBuffer ret = buf.put((long) i);
402             assertEquals(buf.get(i), (long) i);
403             assertSame(ret, buf);
406             buf.put(0);
418         buf.clear();
419         for (int i = 0; i < buf.capacity(); i++) {
420             assertEquals(buf.position(), i);
422             LongBuffer ret = buf.put(array);
423             assertEquals(buf.get(i), (long) i);
424             assertSame(ret, buf);
427             buf.put(array);
433             buf.position(buf.limit());
434             buf.put((long[])null);
445         buf.clear();
446         long array[] = new long[buf.capacity()];
448             buf.put(new long[buf.capacity() + 1], 0, buf.capacity() + 1);
453         assertEquals(buf.position(), 0);
455             buf.put(array, -1, array.length);
461             buf.put(array, array.length + 1, 0);
466         buf.put(array, array.length, 0);
467         assertEquals(buf.position(), 0);
469             buf.put(array, 0, -1);
475             buf.put(array, 2, array.length);
481             buf.put((long[])null, 0, -1);
487             buf.put(array, 2, array.length);
493             buf.put(array, Integer.MAX_VALUE, 1);
499             buf.put(array, 1, Integer.MAX_VALUE);
504         assertEquals(buf.position(), 0);
507         LongBuffer ret = buf.put(array, 0, array.length);
508         assertEquals(buf.position(), buf.capacity());
509         assertContentEquals(buf, array, 0, array.length);
510         assertSame(ret, buf);
517         LongBuffer other = LongBuffer.allocate(buf.capacity());
519             buf.put(buf);
525             buf.put(LongBuffer.allocate(buf.capacity() + 1));
531             buf.flip();
532             buf.put((LongBuffer)null);
540         buf.clear();
541         LongBuffer ret = buf.put(other);
543         assertEquals(buf.position(), buf.capacity());
544         assertContentEquals(other, buf);
545         assertSame(ret, buf);
552         buf.clear();
553         for (int i = 0; i < buf.capacity(); i++) {
554             assertEquals(buf.position(), 0);
555             LongBuffer ret = buf.put(i, (long) i);
556             assertEquals(buf.get(i), (long) i);
557             assertSame(ret, buf);
560             buf.put(-1, 0);
566             buf.put(buf.limit(), 0);
574         assertTrue(buf.capacity() > 5);
575         buf.position(1);
576         buf.limit(buf.capacity() - 1);
578         LongBuffer slice = buf.slice();
579         assertEquals(buf.isReadOnly(), slice.isReadOnly());
580         assertEquals(buf.isDirect(), slice.isDirect());
581         assertEquals(buf.order(), slice.order());
583         assertEquals(slice.limit(), buf.remaining());
584         assertEquals(slice.capacity(), buf.remaining());
592         // slice share the same content with buf
595             assertContentLikeTestData1(buf, 1, 0, slice.capacity());
596             buf.put(2, 500);
602         String str = buf.toString();
604         assertTrue(str.indexOf("" + buf.position()) >= 0);
605         assertTrue(str.indexOf("" + buf.limit()) >= 0);
606         assertTrue(str.indexOf("" + buf.capacity()) >= 0);
621     void loadTestData1(LongBuffer buf) {
622         buf.clear();
623         for (int i = 0; i < buf.capacity(); i++) {
624             buf.put(i, (long) i);
628     void loadTestData2(LongBuffer buf) {
629         buf.clear();
630         for (int i = 0; i < buf.capacity(); i++) {
631             buf.put(i, (long) buf.capacity() - i);
635     void assertContentEquals(LongBuffer buf, long array[],
638             assertEquals(buf.get(i), array[offset + i]);
642     void assertContentEquals(LongBuffer buf, LongBuffer other) {
643         assertEquals(buf.capacity(), other.capacity());
644         for (int i = 0; i < buf.capacity(); i++) {
645             assertEquals(buf.get(i), other.get(i));
649     void assertContentLikeTestData1(LongBuffer buf,
653             assertEquals(buf.get(startIndex + i), value);

Indexes created Thu Dec 22 05:45:36 CET 2016