43     protected LongBuffer buf;
47         buf = LongBuffer.allocate(BUFFER_LENGTH);
48         loadTestData1(buf);
49         baseBuf = buf;
53         buf = null;
101         long array[] = buf.array();
102         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
104         loadTestData1(array, buf.arrayOffset(), buf.capacity());
105         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
107         loadTestData2(array, buf.arrayOffset(), buf.capacity());
108         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
110         loadTestData1(buf);
111         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
113         loadTestData2(buf);
114         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
124         long array[] = buf.array();
125         for(int i = 0; i < buf.capacity(); i++) {
128         int offset = buf.arrayOffset();
129         assertContentEquals(buf, array, offset, buf.capacity());
134         assertContentEquals(buf, array, offset, buf.capacity());
137         assertContentEquals(buf, array, offset, buf.capacity());
147         buf.clear();
148         buf.mark();
149         buf.position(buf.limit());
151         // readonly's contents should be the same as buf
152         LongBuffer readonly = buf.asReadOnlyBuffer();
153         assertNotSame(buf, readonly);
155         assertEquals(buf.position(), readonly.position());
156         assertEquals(buf.limit(), readonly.limit());
157         assertEquals(buf.isDirect(), readonly.isDirect());
158         assertEquals(buf.order(), readonly.order());
159         assertContentEquals(buf, readonly);
161         // readonly's position, mark, and limit should be independent to buf
165         assertEquals(buf.position(), buf.limit());
166         buf.reset();
167         assertEquals(buf.position(), 0);
179         buf.clear();
180         buf.mark();
181         loadTestData1(buf);
182         LongBuffer ret = buf.compact();
183         assertSame(ret, buf);
184         assertEquals(buf.position(), buf.capacity());
185         assertEquals(buf.limit(), buf.capacity());
186         assertContentLikeTestData1(buf, 0, 0, buf.capacity());
188             buf.reset();
195         buf.position(0);
196         buf.limit(0);
197         buf.mark();
198         ret = buf.compact();
199         assertSame(ret, buf);
200         assertEquals(buf.position(), 0);
201         assertEquals(buf.limit(), buf.capacity());
202         assertContentLikeTestData1(buf, 0, 0, buf.capacity());
207             buf.reset();
214         assertTrue(buf.capacity() > 5);
215         buf.position(1);
216         buf.limit(5);
217         buf.mark();
218         ret = buf.compact();
219         assertSame(ret, buf);
220         assertEquals(buf.position(), 4);
221         assertEquals(buf.limit(), buf.capacity());
222         assertContentLikeTestData1(buf, 0, 1, 4);
224             buf.reset();
239         assertEquals(0, buf.compareTo(buf));
242         assertTrue(buf.capacity() > 5);
243         buf.clear();
244         LongBuffer other = LongBuffer.allocate(buf.capacity());
246         assertEquals(0, buf.compareTo(other));
247         assertEquals(0, other.compareTo(buf));
248         buf.position(1);
249         assertTrue(buf.compareTo(other) > 0);
250         assertTrue(other.compareTo(buf) < 0);
252         assertTrue(buf.compareTo(other) < 0);
253         assertTrue(other.compareTo(buf) > 0);
254         buf.position(2);
256         assertTrue(buf.compareTo(other) > 0);
257         assertTrue(other.compareTo(buf) < 0);
267         buf.clear();
268         buf.mark();
269         buf.position(buf.limit());
271         // duplicate's contents should be the same as buf
272         LongBuffer duplicate = buf.duplicate();
273         assertNotSame(buf, duplicate);
274         assertEquals(buf.position(), duplicate.position());
275         assertEquals(buf.limit(), duplicate.limit());
276         assertEquals(buf.isReadOnly(), duplicate.isReadOnly());
277         assertEquals(buf.isDirect(), duplicate.isDirect());
278         assertEquals(buf.order(), duplicate.order());
279         assertContentEquals(buf, duplicate);
281         // duplicate's position, mark, and limit should be independent to buf
285         assertEquals(buf.position(), buf.limit());
286         buf.reset();
287         assertEquals(buf.position(), 0);
289         // duplicate share the same content with buf
291             loadTestData1(buf);
292             assertContentEquals(buf, duplicate);
294             assertContentEquals(buf, duplicate);
306         assertTrue(buf.equals(buf));
307         LongBuffer readonly = buf.asReadOnlyBuffer();
308         assertTrue(buf.equals(readonly));
309         LongBuffer duplicate = buf.duplicate();
310         assertTrue(buf.equals(duplicate));
313         assertFalse(buf.equals(Boolean.TRUE));
315         assertTrue(buf.capacity() > 5);
317         buf.limit(buf.capacity()).position(0);
319         assertFalse(buf.equals(readonly));
321         buf.limit(buf.capacity() - 1).position(0);
323         assertFalse(buf.equals(duplicate));
336         buf.clear();
337         for (int i = 0; i < buf.capacity(); i++) {
338             assertEquals(buf.position(), i);
339             assertEquals(buf.get(), buf.get(i));
342             buf.get();
360         buf.clear();
361         for (int i = 0; i < buf.capacity(); i++) {
362             assertEquals(buf.position(), i);
363             LongBuffer ret = buf.get(array);
364             assertEquals(array[0], buf.get(i));
365             assertSame(ret, buf);
368         buf.get(new long[0]);
371             buf.get(array);
378             buf.get((long[])null);
395         buf.clear();
396         long array[] = new long[buf.capacity()];
399             buf.get(new long[buf.capacity() + 1], 0, buf.capacity() + 1);
404         assertEquals(buf.position(), 0);
406             buf.get(array, -1, array.length);
411         buf.get(array, array.length, 0);
413             buf.get(array, array.length + 1, 1);
418         assertEquals(buf.position(), 0);
420             buf.get(array, 2, -1);
426             buf.get((long[])null, 2, -1);
432             buf.get(array, 2, array.length);
438             buf.get(array, 1, Integer.MAX_VALUE);
444             buf.get(array, Integer.MAX_VALUE, 1);
449         assertEquals(buf.position(), 0);
451         buf.clear();
452         LongBuffer ret = buf.get(array, 0, array.length);
453         assertEquals(buf.position(), buf.capacity());
454         assertContentEquals(buf, array, 0, array.length);
455         assertSame(ret, buf);
468         buf.clear();
469         for (int i = 0; i < buf.capacity(); i++) {
470             assertEquals(buf.position(), i);
471             assertEquals(buf.get(), buf.get(i));
474             buf.get(-1);
480             buf.get(buf.limit());
494         if (buf.hasArray()) {
495             assertNotNull(buf.array());
498                 buf.array();
516         buf.clear();
517         LongBuffer readonly = buf.asReadOnlyBuffer();
518         LongBuffer duplicate = buf.duplicate();
519         assertTrue(buf.hashCode() == readonly.hashCode());
521         assertTrue(buf.capacity() > 5);
522         duplicate.position(buf.capacity() / 2);
523         assertTrue(buf.hashCode() != duplicate.hashCode());
533         assertFalse(buf.isDirect());
543         assertFalse(buf.isReadOnly());
553         assertEquals(ByteOrder.nativeOrder(), buf.order());
566          buf.clear();
567         for (int i = 0; i < buf.capacity(); i++) {
568             assertEquals(buf.position(), i);
569             LongBuffer ret = buf.put((long) i);
570             assertEquals(buf.get(i), (long) i);
571             assertSame(ret, buf);
574             buf.put(0);
592         buf.clear();
593         for (int i = 0; i < buf.capacity(); i++) {
594             assertEquals(buf.position(), i);
596             LongBuffer ret = buf.put(array);
597             assertEquals(buf.get(i), (long) i);
598             assertSame(ret, buf);
601             buf.put(array);
607             buf.position(buf.limit());
608             buf.put((long[])null);
625         buf.clear();
626         long array[] = new long[buf.capacity()];
628             buf.put(new long[buf.capacity() + 1], 0, buf.capacity() + 1);
633         assertEquals(buf.position(), 0);
635             buf.put(array, -1, array.length);
641             buf.put(array, array.length + 1, 0);
646         buf.put(array, array.length, 0);
647         assertEquals(buf.position(), 0);
649             buf.put(array, 0, -1);
655             buf.put(array, 2, array.length);
661             buf.put((long[])null, 0, -1);
667             buf.put(array, 2, array.length);
673             buf.put(array, Integer.MAX_VALUE, 1);
679             buf.put(array, 1, Integer.MAX_VALUE);
684         assertEquals(buf.position(), 0);
687         LongBuffer ret = buf.put(array, 0, array.length);
688         assertEquals(buf.position(), buf.capacity());
689         assertContentEquals(buf, array, 0, array.length);
690         assertSame(ret, buf);
703         LongBuffer other = LongBuffer.allocate(buf.capacity());
705             buf.put(buf);
711             buf.put(LongBuffer.allocate(buf.capacity() + 1));
717             buf.flip();
718             buf.put((LongBuffer)null);
726         buf.clear();
727         LongBuffer ret = buf.put(other);
729         assertEquals(buf.position(), buf.capacity());
730         assertContentEquals(other, buf);
731         assertSame(ret, buf);
744         buf.clear();
745         for (int i = 0; i < buf.capacity(); i++) {
746             assertEquals(buf.position(), 0);
747             LongBuffer ret = buf.put(i, (long) i);
748             assertEquals(buf.get(i), (long) i);
749             assertSame(ret, buf);
752             buf.put(-1, 0);
758             buf.put(buf.limit(), 0);
772         assertTrue(buf.capacity() > 5);
773         buf.position(1);
774         buf.limit(buf.capacity() - 1);
776         LongBuffer slice = buf.slice();
777         assertEquals(buf.isReadOnly(), slice.isReadOnly());
778         assertEquals(buf.isDirect(), slice.isDirect());
779         assertEquals(buf.order(), slice.order());
781         assertEquals(slice.limit(), buf.remaining());
782         assertEquals(slice.capacity(), buf.remaining());
790         // slice share the same content with buf
793             assertContentLikeTestData1(buf, 1, 0, slice.capacity());
794             buf.put(2, 500);
806         String str = buf.toString();
808         assertTrue(str.indexOf("" + buf.position()) >= 0);
809         assertTrue(str.indexOf("" + buf.limit()) >= 0);
810         assertTrue(str.indexOf("" + buf.capacity()) >= 0);
840         loadTestData2(array, 0, buf.capacity());
875         loadTestData2(array, 0, buf.capacity());
900     void loadTestData1(LongBuffer buf) {
901         buf.clear();
902         for (int i = 0; i < buf.capacity(); i++) {
903             buf.put(i, (long) i);
907     void loadTestData2(LongBuffer buf) {
908         buf.clear();
909         for (int i = 0; i < buf.capacity(); i++) {
910             buf.put(i, (long) buf.capacity() - i);
914     void assertContentEquals(LongBuffer buf, long array[],
917             assertEquals(buf.get(i), array[offset + i]);
921     void assertContentEquals(LongBuffer buf, LongBuffer other) {
922         assertEquals(buf.capacity(), other.capacity());
923         for (int i = 0; i < buf.capacity(); i++) {
924             assertEquals(buf.get(i), other.get(i));
928     void assertContentLikeTestData1(LongBuffer buf,
932             assertEquals(buf.get(startIndex + i), value);

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