1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2  * contributor license agreements.  See the NOTICE file distributed with
3  * this work for additional information regarding copyright ownership.
4  * The ASF licenses this file to You under the Apache License, Version 2.0
5  * (the "License"); you may not use this file except in compliance with
6  * the License.  You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package org.apache.harmony.tests.java.nio;
18 
19 import java.nio.Buffer;
20 import java.nio.ByteBuffer;
21 import java.nio.InvalidMarkException;
22 
23 import junit.framework.TestCase;
24 
25 /**
26  * Tests a java.nio.Buffer instance.
27  */
28 public class AbstractBufferTest extends TestCase {
29 
30     protected Buffer baseBuf;
31 
setUp()32     protected void setUp() throws Exception{
33     	super.setUp();
34     	baseBuf = ByteBuffer.allocate(10);
35     }
36 
tearDown()37     protected void tearDown() throws Exception{
38     	super.tearDown();
39     }
40 
testCapacity()41     public void testCapacity() {
42         assertTrue(0 <= baseBuf.position() && baseBuf.position() <= baseBuf.limit()
43                 && baseBuf.limit() <= baseBuf.capacity());
44     }
45 
testClear()46     public void testClear() {
47         // save state
48         int oldPosition = baseBuf.position();
49         int oldLimit = baseBuf.limit();
50 
51         Buffer ret = baseBuf.clear();
52         assertSame(ret, baseBuf);
53         assertEquals(baseBuf.position(), 0);
54         assertEquals(baseBuf.limit(), baseBuf.capacity());
55         try {
56             baseBuf.reset();
57             fail("Should throw Exception"); //$NON-NLS-1$S
58         } catch (InvalidMarkException e) {
59             // expected
60         }
61 
62         // restore state
63         baseBuf.limit(oldLimit);
64         baseBuf.position(oldPosition);
65     }
66 
testFlip()67     public void testFlip() {
68         // save state
69         int oldPosition = baseBuf.position();
70         int oldLimit = baseBuf.limit();
71 
72         Buffer ret = baseBuf.flip();
73         assertSame(ret, baseBuf);
74         assertEquals(baseBuf.position(), 0);
75         assertEquals(baseBuf.limit(), oldPosition);
76         try {
77             baseBuf.reset();
78             fail("Should throw Exception"); //$NON-NLS-1$
79         } catch (InvalidMarkException e) {
80             // expected
81         }
82 
83         // restore state
84         baseBuf.limit(oldLimit);
85         baseBuf.position(oldPosition);
86     }
87 
testHasRemaining()88     public void testHasRemaining() {
89         // save state
90         int oldPosition = baseBuf.position();
91         int oldLimit = baseBuf.limit();
92 
93         assertEquals(baseBuf.hasRemaining(), baseBuf.position() < baseBuf.limit());
94         baseBuf.position(baseBuf.limit());
95         assertFalse(baseBuf.hasRemaining());
96 
97         // restore state
98         baseBuf.limit(oldLimit);
99         baseBuf.position(oldPosition);
100     }
101 
102     public void testIsReadOnly() {
103         baseBuf.isReadOnly();
104     }
105 
106     /*
107      * Class under test for int limit()
108      */
109     public void testLimit() {
110         assertTrue(0 <= baseBuf.position() && baseBuf.position() <= baseBuf.limit()
111                 && baseBuf.limit() <= baseBuf.capacity());
112     }
113 
114     /*
115      * Class under test for Buffer limit(int)
116      */
117     public void testLimitint() {
118         // save state
119         int oldPosition = baseBuf.position();
120         int oldLimit = baseBuf.limit();
121 
122         Buffer ret = baseBuf.limit(baseBuf.limit());
123         assertSame(ret, baseBuf);
124 
125         baseBuf.mark();
126         baseBuf.limit(baseBuf.capacity());
127         assertEquals(baseBuf.limit(), baseBuf.capacity());
128         // position should not change
129         assertEquals(baseBuf.position(), oldPosition);
130         // mark should be valid
131         baseBuf.reset();
132 
133         if (baseBuf.capacity() > 0) {
134             baseBuf.limit(baseBuf.capacity());
135             baseBuf.position(baseBuf.capacity());
136             baseBuf.mark();
137             baseBuf.limit(baseBuf.capacity() - 1);
138             // position should be the new limit
139             assertEquals(baseBuf.position(), baseBuf.limit());
140             // mark should be invalid
141             try {
142                 baseBuf.reset();
143                 fail("Should throw Exception"); //$NON-NLS-1$
144             } catch (InvalidMarkException e) {
145                 // expected
146             }
147         }
148 
149         try {
150             baseBuf.limit(-1);
151             fail("Should throw Exception"); //$NON-NLS-1$
152         } catch (IllegalArgumentException e) {
153             // expected
154         }
155         try {
156             baseBuf.limit(baseBuf.capacity() + 1);
157             fail("Should throw Exception"); //$NON-NLS-1$
158         } catch (IllegalArgumentException e) {
159             // expected
160         }
161 
162         // restore state
163         baseBuf.limit(oldLimit);
164         baseBuf.position(oldPosition);
165     }
166 
167     public void testMark() {
168         // save state
169         int oldPosition = baseBuf.position();
170         int oldLimit = baseBuf.limit();
171 
172         Buffer ret = baseBuf.mark();
173         assertSame(ret, baseBuf);
174 
175         baseBuf.mark();
176         baseBuf.position(baseBuf.limit());
177         baseBuf.reset();
178         assertEquals(baseBuf.position(), oldPosition);
179 
180         baseBuf.mark();
181         baseBuf.position(baseBuf.limit());
182         baseBuf.reset();
183         assertEquals(baseBuf.position(), oldPosition);
184 
185         // restore state
186         baseBuf.limit(oldLimit);
187         baseBuf.position(oldPosition);
188     }
189 
190     /*
191      * Class under test for int position()
192      */
193     public void testPosition() {
194         assertTrue(0 <= baseBuf.position() && baseBuf.position() <= baseBuf.limit()
195                 && baseBuf.limit() <= baseBuf.capacity());
196     }
197 
198     /*
199      * Class under test for Buffer position(int)
200      */
201     public void testPositionint() {
202         // save state
203         int oldPosition = baseBuf.position();
204         int oldLimit = baseBuf.limit();
205 
206         try {
207             baseBuf.position(-1);
208             fail("Should throw Exception"); //$NON-NLS-1$
209         } catch (IllegalArgumentException e) {
210             // expected
211         }
212         try {
213             baseBuf.position(baseBuf.limit() + 1);
214             fail("Should throw Exception"); //$NON-NLS-1$
215         } catch (IllegalArgumentException e) {
216             // expected
217         }
218 
219         baseBuf.mark();
220         baseBuf.position(baseBuf.position());
221         baseBuf.reset();
222         assertEquals(baseBuf.position(), oldPosition);
223 
224         baseBuf.position(0);
225         assertEquals(baseBuf.position(), 0);
226         baseBuf.position(baseBuf.limit());
227         assertEquals(baseBuf.position(), baseBuf.limit());
228 
229         if (baseBuf.capacity() > 0) {
230             baseBuf.limit(baseBuf.capacity());
231             baseBuf.position(baseBuf.limit());
232             baseBuf.mark();
233             baseBuf.position(baseBuf.limit() - 1);
234             assertEquals(baseBuf.position(), baseBuf.limit() - 1);
235             // mark should be invalid
236             try {
237                 baseBuf.reset();
238                 fail("Should throw Exception"); //$NON-NLS-1$
239             } catch (InvalidMarkException e) {
240                 // expected
241             }
242         }
243 
244         Buffer ret = baseBuf.position(0);
245         assertSame(ret, baseBuf);
246 
247         // restore state
248         baseBuf.limit(oldLimit);
249         baseBuf.position(oldPosition);
250     }
251 
252     public void testRemaining() {
253         assertEquals(baseBuf.remaining(), baseBuf.limit() - baseBuf.position());
254     }
255 
256     public void testReset() {
257         // save state
258         int oldPosition = baseBuf.position();
259         int oldLimit = baseBuf.limit();
260 
261         baseBuf.mark();
262         baseBuf.position(baseBuf.limit());
263         baseBuf.reset();
264         assertEquals(baseBuf.position(), oldPosition);
265 
266         baseBuf.mark();
267         baseBuf.position(baseBuf.limit());
268         baseBuf.reset();
269         assertEquals(baseBuf.position(), oldPosition);
270 
271         Buffer ret = baseBuf.reset();
272         assertSame(ret, baseBuf);
273 
274         baseBuf.clear();
275         try {
276             baseBuf.reset();
277             fail("Should throw Exception"); //$NON-NLS-1$
278         } catch (InvalidMarkException e) {
279             // expected
280         }
281 
282         // restore state
283         baseBuf.limit(oldLimit);
284         baseBuf.position(oldPosition);
285     }
286 
287     public void testRewind() {
288         // save state
289         int oldPosition = baseBuf.position();
290         int oldLimit = baseBuf.limit();
291 
292         Buffer ret = baseBuf.rewind();
293         assertEquals(baseBuf.position(), 0);
294         assertSame(ret, baseBuf);
295         try {
296             baseBuf.reset();
297             fail("Should throw Exception"); //$NON-NLS-1$
298         } catch (InvalidMarkException e) {
299             // expected
300         }
301 
302         // restore state
303         baseBuf.limit(oldLimit);
304         baseBuf.position(oldPosition);
305     }
306 }
307