1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 */
17
18package org.apache.harmony.nio.tests.java.nio;
19
20import java.nio.BufferOverflowException;
21import java.nio.BufferUnderflowException;
22import java.nio.ByteOrder;
23import java.nio.InvalidMarkException;
24import java.nio.LongBuffer;
25
26/**
27 * Tests java.nio.LongBuffer
28 *
29 */
30public class LongBufferTest extends AbstractBufferTest {
31
32
33    protected static final int SMALL_TEST_LENGTH = 5;
34
35    protected static final int BUFFER_LENGTH = 20;
36
37    protected LongBuffer buf;
38
39    protected void setUp() throws Exception {
40        buf = LongBuffer.allocate(BUFFER_LENGTH);
41        loadTestData1(buf);
42        baseBuf = buf;
43    }
44
45    protected void tearDown() throws Exception {
46        buf = null;
47        baseBuf = null;
48    }
49
50    public void testArray() {
51        long array[] = buf.array();
52        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
53
54        loadTestData1(array, buf.arrayOffset(), buf.capacity());
55        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
56
57        loadTestData2(array, buf.arrayOffset(), buf.capacity());
58        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
59
60        loadTestData1(buf);
61        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
62
63        loadTestData2(buf);
64        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
65    }
66
67    public void testArrayOffset() {
68        long array[] = buf.array();
69        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
70
71        loadTestData1(array, buf.arrayOffset(), buf.capacity());
72        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
73
74        loadTestData2(array, buf.arrayOffset(), buf.capacity());
75        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
76
77        loadTestData1(buf);
78        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
79
80        loadTestData2(buf);
81        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
82    }
83
84    public void testAsReadOnlyBuffer() {
85        buf.clear();
86        buf.mark();
87        buf.position(buf.limit());
88
89        // readonly's contents should be the same as buf
90        LongBuffer readonly = buf.asReadOnlyBuffer();
91        assertNotSame(buf, readonly);
92        assertTrue(readonly.isReadOnly());
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);
98
99        // readonly's position, mark, and limit should be independent to buf
100        readonly.reset();
101        assertEquals(readonly.position(), 0);
102        readonly.clear();
103        assertEquals(buf.position(), buf.limit());
104        buf.reset();
105        assertEquals(buf.position(), 0);
106    }
107
108    public void testCompact() {
109        // case: buffer is full
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());
118        try {
119            buf.reset();
120            fail("Should throw Exception"); //$NON-NLS-1$
121        } catch (InvalidMarkException e) {
122            // expected
123        }
124
125        // case: buffer is empty
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());
134        try {
135            buf.reset();
136            fail("Should throw Exception"); //$NON-NLS-1$
137        } catch (InvalidMarkException e) {
138            // expected
139        }
140
141        // case: normal
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);
151        try {
152            buf.reset();
153            fail("Should throw Exception"); //$NON-NLS-1$
154        } catch (InvalidMarkException e) {
155            // expected
156        }
157    }
158
159    public void testCompareTo() {
160        // compare to self
161        assertEquals(0, buf.compareTo(buf));
162
163        // normal cases
164        assertTrue(buf.capacity() > 5);
165        buf.clear();
166        LongBuffer other = LongBuffer.allocate(buf.capacity());
167        loadTestData1(other);
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);
173        other.position(2);
174        assertTrue(buf.compareTo(other) < 0);
175        assertTrue(other.compareTo(buf) > 0);
176        buf.position(2);
177        other.limit(5);
178        assertTrue(buf.compareTo(other) > 0);
179        assertTrue(other.compareTo(buf) < 0);
180    }
181
182    public void testDuplicate() {
183        buf.clear();
184        buf.mark();
185        buf.position(buf.limit());
186
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);
196
197        // duplicate's position, mark, and limit should be independent to buf
198        duplicate.reset();
199        assertEquals(duplicate.position(), 0);
200        duplicate.clear();
201        assertEquals(buf.position(), buf.limit());
202        buf.reset();
203        assertEquals(buf.position(), 0);
204
205        // duplicate share the same content with buf
206        if (!duplicate.isReadOnly()) {
207            loadTestData1(buf);
208            assertContentEquals(buf, duplicate);
209            loadTestData2(duplicate);
210            assertContentEquals(buf, duplicate);
211        }
212    }
213
214    public void testEquals() {
215        // equal to self
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));
221
222        // always false, if type mismatch
223        assertFalse(buf.equals(Boolean.TRUE));
224
225        assertTrue(buf.capacity() > 5);
226
227        buf.limit(buf.capacity()).position(0);
228        readonly.limit(readonly.capacity()).position(1);
229        assertFalse(buf.equals(readonly));
230
231        buf.limit(buf.capacity() - 1).position(0);
232        duplicate.limit(duplicate.capacity()).position(0);
233        assertFalse(buf.equals(duplicate));
234    }
235
236    /*
237     * Class under test for long get()
238     */
239    public void testGet() {
240        buf.clear();
241        for (int i = 0; i < buf.capacity(); i++) {
242            assertEquals(buf.position(), i);
243            assertEquals(buf.get(), buf.get(i));
244        }
245        try {
246            buf.get();
247            fail("Should throw Exception"); //$NON-NLS-1$
248        } catch (BufferUnderflowException e) {
249            // expected
250        }
251    }
252
253    /*
254     * Class under test for java.nio.LongBuffer get(long[])
255     */
256    public void testGetlongArray() {
257        long array[] = new long[1];
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);
264        }
265        try {
266            buf.get(array);
267            fail("Should throw Exception"); //$NON-NLS-1$
268        } catch (BufferUnderflowException e) {
269            // expected
270        }
271        try {
272            buf.position(buf.limit());
273            buf.get((long[])null);
274            fail("Should throw Exception"); //$NON-NLS-1$
275        } catch (NullPointerException e) {
276            // expected
277        }
278    }
279
280    /*
281     * Class under test for java.nio.LongBuffer get(long[], int, int)
282     */
283    public void testGetlongArrayintint() {
284        buf.clear();
285        long array[] = new long[buf.capacity()];
286
287        try {
288            buf.get(new long[buf.capacity() + 1], 0, buf.capacity() + 1);
289            fail("Should throw Exception"); //$NON-NLS-1$
290        } catch (BufferUnderflowException e) {
291            // expected
292        }
293        assertEquals(buf.position(), 0);
294        try {
295            buf.get(array, -1, array.length);
296            fail("Should throw Exception"); //$NON-NLS-1$
297        } catch (IndexOutOfBoundsException e) {
298            // expected
299        }
300        buf.get(array, array.length, 0);
301        try {
302            buf.get(array, array.length + 1, 1);
303            fail("Should throw Exception"); //$NON-NLS-1$
304        } catch (IndexOutOfBoundsException e) {
305            // expected
306        }
307        assertEquals(buf.position(), 0);
308        try {
309            buf.get(array, 2, -1);
310            fail("Should throw Exception"); //$NON-NLS-1$
311        } catch (IndexOutOfBoundsException e) {
312            // expected
313        }
314        try {
315            buf.get((long[])null, 2, -1);
316            fail("Should throw Exception"); //$NON-NLS-1$
317        } catch (NullPointerException e) {
318            // expected
319        }
320        try {
321            buf.get(array, 2, array.length);
322            fail("Should throw Exception"); //$NON-NLS-1$
323        } catch (IndexOutOfBoundsException e) {
324            // expected
325        }
326        try {
327            buf.get(array, 1, Integer.MAX_VALUE);
328            fail("Should throw Exception"); //$NON-NLS-1$
329        } catch (BufferUnderflowException expected) {
330        } catch (IndexOutOfBoundsException expected) {
331        }
332        try {
333            buf.get(array, Integer.MAX_VALUE, 1);
334            fail("Should throw Exception"); //$NON-NLS-1$
335        } catch (IndexOutOfBoundsException e) {
336            // expected
337        }
338        assertEquals(buf.position(), 0);
339
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);
345    }
346
347    /*
348     * Class under test for long get(int)
349     */
350    public void testGetint() {
351        buf.clear();
352        for (int i = 0; i < buf.capacity(); i++) {
353            assertEquals(buf.position(), i);
354            assertEquals(buf.get(), buf.get(i));
355        }
356        try {
357            buf.get(-1);
358            fail("Should throw Exception"); //$NON-NLS-1$
359        } catch (IndexOutOfBoundsException e) {
360            // expected
361        }
362        try {
363            buf.get(buf.limit());
364            fail("Should throw Exception"); //$NON-NLS-1$
365        } catch (IndexOutOfBoundsException e) {
366            // expected
367        }
368    }
369
370    public void testHasArray() {
371        assertNotNull(buf.array());
372    }
373
374    public void testHashCode() {
375        buf.clear();
376        LongBuffer readonly = buf.asReadOnlyBuffer();
377        LongBuffer duplicate = buf.duplicate();
378        assertTrue(buf.hashCode() == readonly.hashCode());
379
380        assertTrue(buf.capacity() > 5);
381        duplicate.position(buf.capacity() / 2);
382        assertTrue(buf.hashCode() != duplicate.hashCode());
383    }
384
385    public void testIsDirect() {
386        assertFalse(buf.isDirect());
387    }
388
389    public void testOrder() {
390        buf.order();
391        assertEquals(ByteOrder.nativeOrder(), buf.order());
392    }
393
394    /*
395     * Class under test for java.nio.LongBuffer put(long)
396     */
397    public void testPutlong() {
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);
404        }
405        try {
406            buf.put(0);
407            fail("Should throw Exception"); //$NON-NLS-1$
408        } catch (BufferOverflowException e) {
409            // expected
410        }
411    }
412
413    /*
414     * Class under test for java.nio.LongBuffer put(long[])
415     */
416    public void testPutlongArray() {
417        long array[] = new long[1];
418        buf.clear();
419        for (int i = 0; i < buf.capacity(); i++) {
420            assertEquals(buf.position(), i);
421            array[0] = (long) i;
422            LongBuffer ret = buf.put(array);
423            assertEquals(buf.get(i), (long) i);
424            assertSame(ret, buf);
425        }
426        try {
427            buf.put(array);
428            fail("Should throw Exception"); //$NON-NLS-1$
429        } catch (BufferOverflowException e) {
430            // expected
431        }
432        try {
433            buf.position(buf.limit());
434            buf.put((long[])null);
435            fail("Should throw Exception"); //$NON-NLS-1$
436        } catch (NullPointerException e) {
437            // expected
438        }
439    }
440
441    /*
442     * Class under test for java.nio.LongBuffer put(long[], int, int)
443     */
444    public void testPutlongArrayintint() {
445        buf.clear();
446        long array[] = new long[buf.capacity()];
447        try {
448            buf.put(new long[buf.capacity() + 1], 0, buf.capacity() + 1);
449            fail("Should throw Exception"); //$NON-NLS-1$
450        } catch (BufferOverflowException e) {
451            // expected
452        }
453        assertEquals(buf.position(), 0);
454        try {
455            buf.put(array, -1, array.length);
456            fail("Should throw Exception"); //$NON-NLS-1$
457        } catch (IndexOutOfBoundsException e) {
458            // expected
459        }
460        try {
461            buf.put(array, array.length + 1, 0);
462            fail("Should throw Exception"); //$NON-NLS-1$
463        } catch (IndexOutOfBoundsException e) {
464            // expected
465        }
466        buf.put(array, array.length, 0);
467        assertEquals(buf.position(), 0);
468        try {
469            buf.put(array, 0, -1);
470            fail("Should throw Exception"); //$NON-NLS-1$
471        } catch (IndexOutOfBoundsException e) {
472            // expected
473        }
474        try {
475            buf.put(array, 2, array.length);
476            fail("Should throw Exception"); //$NON-NLS-1$
477        } catch (IndexOutOfBoundsException e) {
478            // expected
479        }
480        try {
481            buf.put((long[])null, 0, -1);
482            fail("Should throw Exception"); //$NON-NLS-1$
483        } catch (NullPointerException e) {
484            // expected
485        }
486        try {
487            buf.put(array, 2, array.length);
488            fail("Should throw Exception"); //$NON-NLS-1$
489        } catch (IndexOutOfBoundsException e) {
490            // expected
491        }
492        try {
493            buf.put(array, Integer.MAX_VALUE, 1);
494            fail("Should throw Exception"); //$NON-NLS-1$
495        } catch (IndexOutOfBoundsException e) {
496            // expected
497        }
498        try {
499            buf.put(array, 1, Integer.MAX_VALUE);
500            fail("Should throw Exception"); //$NON-NLS-1$
501        } catch (BufferOverflowException expected) {
502        } catch (IndexOutOfBoundsException expected) {
503        }
504        assertEquals(buf.position(), 0);
505
506        loadTestData2(array, 0, array.length);
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);
511    }
512
513    /*
514     * Class under test for java.nio.LongBuffer put(java.nio.LongBuffer)
515     */
516    public void testPutLongBuffer() {
517        LongBuffer other = LongBuffer.allocate(buf.capacity());
518        try {
519            buf.put(buf);
520            fail("Should throw Exception"); //$NON-NLS-1$
521        } catch (IllegalArgumentException e) {
522            // expected
523        }
524        try {
525            buf.put(LongBuffer.allocate(buf.capacity() + 1));
526            fail("Should throw Exception"); //$NON-NLS-1$
527        } catch (BufferOverflowException e) {
528            // expected
529        }
530        try {
531            buf.flip();
532            buf.put((LongBuffer)null);
533            fail("Should throw Exception"); //$NON-NLS-1$
534        } catch (NullPointerException e) {
535            // expected
536        }
537
538        loadTestData2(other);
539        other.clear();
540        buf.clear();
541        LongBuffer ret = buf.put(other);
542        assertEquals(other.position(), other.capacity());
543        assertEquals(buf.position(), buf.capacity());
544        assertContentEquals(other, buf);
545        assertSame(ret, buf);
546    }
547
548    /*
549     * Class under test for java.nio.LongBuffer put(int, long)
550     */
551    public void testPutintlong() {
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);
558        }
559        try {
560            buf.put(-1, 0);
561            fail("Should throw Exception"); //$NON-NLS-1$
562        } catch (IndexOutOfBoundsException e) {
563            // expected
564        }
565        try {
566            buf.put(buf.limit(), 0);
567            fail("Should throw Exception"); //$NON-NLS-1$
568        } catch (IndexOutOfBoundsException e) {
569            // expected
570        }
571    }
572
573    public void testSlice() {
574        assertTrue(buf.capacity() > 5);
575        buf.position(1);
576        buf.limit(buf.capacity() - 1);
577
578        LongBuffer slice = buf.slice();
579        assertEquals(buf.isReadOnly(), slice.isReadOnly());
580        assertEquals(buf.isDirect(), slice.isDirect());
581        assertEquals(buf.order(), slice.order());
582        assertEquals(slice.position(), 0);
583        assertEquals(slice.limit(), buf.remaining());
584        assertEquals(slice.capacity(), buf.remaining());
585        try {
586            slice.reset();
587            fail("Should throw Exception"); //$NON-NLS-1$
588        } catch (InvalidMarkException e) {
589            // expected
590        }
591
592        // slice share the same content with buf
593        if (!slice.isReadOnly()) {
594            loadTestData1(slice);
595            assertContentLikeTestData1(buf, 1, 0, slice.capacity());
596            buf.put(2, 500);
597            assertEquals(slice.get(1), 500);
598        }
599    }
600
601    public void testToString() {
602        String str = buf.toString();
603        assertTrue(str.indexOf("Long") >= 0 || str.indexOf("long") >= 0);
604        assertTrue(str.indexOf("" + buf.position()) >= 0);
605        assertTrue(str.indexOf("" + buf.limit()) >= 0);
606        assertTrue(str.indexOf("" + buf.capacity()) >= 0);
607    }
608
609    void loadTestData1(long array[], int offset, int length) {
610        for (int i = 0; i < length; i++) {
611            array[offset + i] = (long) i;
612        }
613    }
614
615    void loadTestData2(long array[], int offset, int length) {
616        for (int i = 0; i < length; i++) {
617            array[offset + i] = (long) length - i;
618        }
619    }
620
621    void loadTestData1(LongBuffer buf) {
622        buf.clear();
623        for (int i = 0; i < buf.capacity(); i++) {
624            buf.put(i, (long) i);
625        }
626    }
627
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);
632        }
633    }
634
635    void assertContentEquals(LongBuffer buf, long array[],
636            int offset, int length) {
637        for (int i = 0; i < length; i++) {
638            assertEquals(buf.get(i), array[offset + i]);
639        }
640    }
641
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));
646        }
647    }
648
649    void assertContentLikeTestData1(LongBuffer buf,
650            int startIndex, long startValue, int length) {
651        long value = startValue;
652        for (int i = 0; i < length; i++) {
653            assertEquals(buf.get(startIndex + i), value);
654            value = value + 1;
655        }
656    }
657}
658