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 tests.api.java.io;
19
20import java.io.BufferedWriter;
21import java.io.IOException;
22
23import tests.support.Support_ASimpleWriter;
24import tests.support.Support_StringWriter;
25import dalvik.annotation.TestLevel;
26import dalvik.annotation.TestTargetClass;
27import dalvik.annotation.TestTargetNew;
28
29@TestTargetClass(BufferedWriter.class)
30public class BufferedWriterTest extends junit.framework.TestCase {
31
32    BufferedWriter bw;
33
34    Support_StringWriter sw;
35
36    Support_ASimpleWriter ssw;
37
38    public String testString = "Test_All_Tests\nTest_java_io_BufferedInputStream\nTest_java_io_BufferedOutputStream\nTest_java_io_ByteArrayInputStream\nTest_java_io_ByteArrayOutputStream\nTest_java_io_DataInputStream\nTest_java_io_File\nTest_java_io_FileDescriptor\nTest_java_io_FileInputStream\nTest_java_io_FileNotFoundException\nTest_java_io_FileOutputStream\nTest_java_io_FilterInputStream\nTest_java_io_FilterOutputStream\nTest_java_io_InputStream\nTest_java_io_IOException\nTest_java_io_OutputStream\nTest_java_io_PrintStream\nTest_java_io_RandomAccessFile\nTest_java_io_SyncFailedException\nTest_java_lang_AbstractMethodError\nTest_java_lang_ArithmeticException\nTest_java_lang_ArrayIndexOutOfBoundsException\nTest_java_lang_ArrayStoreException\nTest_java_lang_Boolean\nTest_java_lang_Byte\nTest_java_lang_Character\nTest_java_lang_Class\nTest_java_lang_ClassCastException\nTest_java_lang_ClassCircularityError\nTest_java_lang_ClassFormatError\nTest_java_lang_ClassLoader\nTest_java_lang_ClassNotFoundException\nTest_java_lang_CloneNotSupportedException\nTest_java_lang_Double\nTest_java_lang_Error\nTest_java_lang_Exception\nTest_java_lang_ExceptionInInitializerError\nTest_java_lang_Float\nTest_java_lang_IllegalAccessError\nTest_java_lang_IllegalAccessException\nTest_java_lang_IllegalArgumentException\nTest_java_lang_IllegalMonitorStateException\nTest_java_lang_IllegalThreadStateException\nTest_java_lang_IncompatibleClassChangeError\nTest_java_lang_IndexOutOfBoundsException\nTest_java_lang_InstantiationError\nTest_java_lang_InstantiationException\nTest_java_lang_Integer\nTest_java_lang_InternalError\nTest_java_lang_InterruptedException\nTest_java_lang_LinkageError\nTest_java_lang_Long\nTest_java_lang_Math\nTest_java_lang_NegativeArraySizeException\nTest_java_lang_NoClassDefFoundError\nTest_java_lang_NoSuchFieldError\nTest_java_lang_NoSuchMethodError\nTest_java_lang_NullPointerException\nTest_java_lang_Number\nTest_java_lang_NumberFormatException\nTest_java_lang_Object\nTest_java_lang_OutOfMemoryError\nTest_java_lang_RuntimeException\nTest_java_lang_SecurityManager\nTest_java_lang_Short\nTest_java_lang_StackOverflowError\nTest_java_lang_String\nTest_java_lang_StringBuffer\nTest_java_lang_StringIndexOutOfBoundsException\nTest_java_lang_System\nTest_java_lang_Thread\nTest_java_lang_ThreadDeath\nTest_java_lang_ThreadGroup\nTest_java_lang_Throwable\nTest_java_lang_UnknownError\nTest_java_lang_UnsatisfiedLinkError\nTest_java_lang_VerifyError\nTest_java_lang_VirtualMachineError\nTest_java_lang_vm_Image\nTest_java_lang_vm_MemorySegment\nTest_java_lang_vm_ROMStoreException\nTest_java_lang_vm_VM\nTest_java_lang_Void\nTest_java_net_BindException\nTest_java_net_ConnectException\nTest_java_net_DatagramPacket\nTest_java_net_DatagramSocket\nTest_java_net_DatagramSocketImpl\nTest_java_net_InetAddress\nTest_java_net_NoRouteToHostException\nTest_java_net_PlainDatagramSocketImpl\nTest_java_net_PlainSocketImpl\nTest_java_net_Socket\nTest_java_net_SocketException\nTest_java_net_SocketImpl\nTest_java_net_SocketInputStream\nTest_java_net_SocketOutputStream\nTest_java_net_UnknownHostException\nTest_java_util_ArrayEnumerator\nTest_java_util_Date\nTest_java_util_EventObject\nTest_java_util_HashEnumerator\nTest_java_util_Hashtable\nTest_java_util_Properties\nTest_java_util_ResourceBundle\nTest_java_util_tm\nTest_java_util_Vector\n";
39
40    /**
41     * @tests java.io.BufferedWriter#BufferedWriter(java.io.Writer)
42     */
43    @TestTargetNew(
44        level = TestLevel.COMPLETE,
45        method = "BufferedWriter",
46        args = {java.io.Writer.class}
47    )
48    public void test_ConstructorLjava_io_Writer() {
49        bw = new BufferedWriter(sw);
50        try {
51            bw.write("Hi", 0, 2);
52            assertTrue("Test 1: Buffering failed.", sw.toString().equals(""));
53            bw.flush();
54            assertEquals("Test 2: Incorrect value;", "Hi", sw.toString());
55        } catch (IOException e) {
56            fail("Test 3: Unexpected IOException.");
57        }
58    }
59
60    /**
61     * @tests java.io.BufferedWriter#BufferedWriter(java.io.Writer, int)
62     */
63    @TestTargetNew(
64        level = TestLevel.COMPLETE,
65        method = "BufferedWriter",
66        args = {java.io.Writer.class, int.class}
67    )
68    public void test_ConstructorLjava_io_WriterI() {
69        try {
70            bw = new BufferedWriter(sw, 0);
71            fail("Test 1: IllegalArgumentException expected.");
72        } catch (IllegalArgumentException expected) {
73            // Expected.
74        }
75
76        bw = new BufferedWriter(sw, 10);
77        try {
78            bw.write("Hi", 0, 2);
79            assertTrue("Test 2: Buffering failed.", sw.toString().equals(""));
80            bw.flush();
81            assertEquals("Test 3: Incorrect value;", "Hi", sw.toString());
82        } catch (IOException e) {
83            fail("Test 4: Unexpected IOException.");
84        }
85    }
86
87    /**
88     * @tests java.io.BufferedWriter#close()
89     */
90    @TestTargetNew(
91        level = TestLevel.COMPLETE,
92        method = "close",
93        args = {}
94    )
95    public void test_close() {
96        // Test for method void java.io.BufferedWriter.close()
97        try {
98            bw.close();
99            bw.write(testString);
100            fail("Test 1: IOException expected.");
101        } catch (IOException e) {
102            // Expected.
103        }
104        assertFalse("Test 2: Write after close.", sw.toString().equals(testString));
105
106        bw = new BufferedWriter(ssw);
107        try {
108            bw.close();
109            fail("Test 3: IOException expected.");
110        } catch (IOException e) {
111            // Expected.
112        }
113    }
114
115    /**
116     * @tests java.io.BufferedWriter#flush()
117     */
118    @TestTargetNew(
119        level = TestLevel.COMPLETE,
120        method = "flush",
121        args = {}
122    )
123    public void test_flush() throws IOException {
124        bw.write("This should not cause a flush");
125        assertTrue("Test 1: Bytes written without flush.",
126                sw.toString().equals(""));
127        bw.flush();
128        assertEquals("Test 2: Bytes not flushed.",
129                "This should not cause a flush", sw.toString());
130
131        bw.close();
132        bw = new BufferedWriter(ssw);
133        try {
134            bw.flush();
135            fail("Test 3: IOException expected.");
136        } catch (IOException e) {
137            // Expected.
138        }
139    }
140
141    /**
142     * @tests java.io.BufferedWriter#newLine()
143     */
144    @TestTargetNew(
145        level = TestLevel.COMPLETE,
146        method = "newLine",
147        args = {}
148    )
149    public void test_newLine() throws IOException {
150        String separator = System.getProperty("line.separator");
151        bw.write("Hello");
152        bw.newLine();
153        bw.write("World");
154        bw.flush();
155        assertTrue("Test 1: Incorrect string written: " + sw.toString(),
156                sw.toString().equals("Hello" + separator + "World"));
157
158        bw.close();
159        bw = new BufferedWriter(ssw, 1);
160        try {
161            bw.newLine();
162            fail("Test 2: IOException expected.");
163        } catch (IOException e) {
164            // Expected.
165        }
166   }
167
168    /**
169     * @tests java.io.BufferedWriter#write(char[], int, int)
170     */
171    @TestTargetNew(
172        level = TestLevel.PARTIAL_COMPLETE,
173        method = "write",
174        args = {char[].class, int.class, int.class}
175    )
176    public void test_write$CII() {
177        // Test for method void java.io.BufferedWriter.write(char [], int, int)
178        try {
179            char[] testCharArray = testString.toCharArray();
180            bw.write(testCharArray, 500, 1000);
181            bw.flush();
182            assertTrue("Incorrect string written", sw.toString().equals(
183                    testString.substring(500, 1500)));
184
185            int idx = sw.toString().length();
186            bw.write(testCharArray, 0, testCharArray.length);
187            assertEquals(idx + testCharArray.length, sw.toString().length());
188            bw.write(testCharArray, 0, 0);
189            assertEquals(idx + testCharArray.length, sw.toString().length());
190            bw.write(testCharArray, testCharArray.length, 0);
191            assertEquals(idx + testCharArray.length, sw.toString().length());
192        } catch (Exception e) {
193            fail("Exception during write test");
194        }
195
196    }
197
198    /**
199     * @tests java.io.BufferedWriter#write(char[], int, int)
200     */
201    @TestTargetNew(
202        level = TestLevel.PARTIAL_COMPLETE,
203        notes = "Illegal argument tests.",
204        method = "write",
205        args = {char[].class, int.class, int.class}
206    )
207    public void test_write$CII_Exception() throws IOException {
208        char[] nullCharArray = null;
209        char[] charArray = testString.toCharArray();
210
211        try {
212            bw.write(nullCharArray, 0, 1);
213            fail("Test 1: NullPointerException expected.");
214        } catch (NullPointerException e) {
215            // Expected.
216        }
217
218        try {
219            bw.write(charArray, -1, 0);
220            fail("Test 2: IndexOutOfBoundsException expected.");
221        } catch (IndexOutOfBoundsException e) {
222            // Expected
223        }
224
225        try {
226            bw.write(charArray, 0, -1);
227            fail("Test 3: IndexOutOfBoundsException expected.");
228        } catch (IndexOutOfBoundsException e) {
229            // Expected
230        }
231
232        try {
233            bw.write(charArray, charArray.length + 1, 0);
234            fail("Test 4: IndexOutOfBoundsException expected.");
235        } catch (IndexOutOfBoundsException e) {
236            // Expected
237        }
238
239        try {
240            bw.write(charArray, charArray.length, 1);
241            fail("Test 5: IndexOutOfBoundsException expected.");
242        } catch (IndexOutOfBoundsException e) {
243            // Expected
244        }
245
246        try {
247            bw.write(charArray, 0, charArray.length + 1);
248            fail("Test 6: IndexOutOfBoundsException expected.");
249        } catch (IndexOutOfBoundsException e) {
250            // Expected
251        }
252
253        try {
254            bw.write(charArray, 1, charArray.length);
255            fail("Test 7: IndexOutOfBoundsException expected.");
256        } catch (IndexOutOfBoundsException e) {
257            // Expected
258        }
259
260        bw.close();
261
262        try {
263            bw.write(charArray, 0, 1);
264            fail("Test 7: IOException expected.");
265        } catch (IOException e) {
266            // Expected.
267        }
268
269        bw = new BufferedWriter(ssw, charArray.length / 2);
270        try {
271            bw.write(charArray, 0, charArray.length);
272            fail("Test 8: IOException expected.");
273        } catch (IOException e) {
274            // Expected.
275        }
276    }
277
278    /**
279     * @tests java.io.BufferedWriter#write(int)
280     */
281    @TestTargetNew(
282        level = TestLevel.COMPLETE,
283        method = "write",
284        args = {int.class}
285    )
286    public void test_writeI() throws IOException {
287        bw.write('T');
288        assertTrue("Test 1: Char written without flush.",
289                sw.toString().equals(""));
290        bw.flush();
291        assertEquals("Test 2: Incorrect char written;",
292                "T", sw.toString());
293
294        bw.close();
295        try {
296            bw.write('E');
297            fail("Test 3: IOException expected since the target writer is closed.");
298        } catch (IOException e) {
299            // Expected.
300        }
301
302        // IOException should be thrown when the buffer is full and data is
303        // written out to the target writer.
304        bw = new BufferedWriter(ssw, 1);
305        bw.write('S');
306        try {
307            bw.write('T');
308            fail("Test 4: IOException expected since the target writer throws it.");
309        } catch (IOException e) {
310            // Expected.
311        }
312    }
313
314    /**
315     * @tests java.io.BufferedWriter#write(java.lang.String, int, int)
316     */
317    @TestTargetNew(
318        level = TestLevel.PARTIAL_COMPLETE,
319        method = "write",
320        args = {java.lang.String.class, int.class, int.class}
321    )
322    public void test_writeLjava_lang_StringII() {
323        // Test for method void java.io.BufferedWriter.write(java.lang.String,
324        // int, int)
325        try {
326            bw.write(testString);
327            bw.flush();
328            assertTrue("Incorrect string written", sw.toString().equals(
329                    testString));
330        } catch (Exception e) {
331            fail("Exception during write test");
332        }
333    }
334
335    /**
336     * @tests java.io.BufferedWriter#write(java.lang.String, int, int)
337     */
338    @TestTargetNew(
339        level = TestLevel.PARTIAL_COMPLETE,
340        notes = "Illegal argument checking.",
341        method = "write",
342        args = {java.lang.String.class, int.class, int.class}
343    )
344    public void test_writeLjava_lang_StringII_Exception() throws IOException {
345
346        bw.write((String) null , -1, -1);
347        bw.write((String) null , -1, 0);
348        bw.write((String) null , 0 , -1);
349        bw.write((String) null , 0 , 0);
350
351        try {
352            bw.write((String) null, 0, 1);
353            fail("Test 1: NullPointerException expected.");
354        } catch (NullPointerException e) {
355            // Expected.
356        }
357
358        try {
359            bw.write(testString, -1, 1);
360            fail("Test 2: StringIndexOutOfBoundsException expected.");
361        } catch (StringIndexOutOfBoundsException e) {
362            // Expected.
363        }
364
365        try {
366            bw.write(testString, 1, testString.length());
367            fail("Test 3: StringIndexOutOfBoundsException expected.");
368        } catch (StringIndexOutOfBoundsException e) {
369            // Expected.
370        }
371
372        bw.close();
373
374        try {
375            bw.write(testString, 0, 1);
376            fail("Test 4: IOException expected.");
377        } catch (IOException e) {
378            // Expected.
379        }
380
381        bw = new BufferedWriter(ssw, testString.length() / 2);
382        try {
383            bw.write(testString, 0, testString.length());
384            fail("Test 5: IOException expected.");
385        } catch (IOException e) {
386            // Expected.
387        }
388    }
389
390    /**
391     * Sets up the fixture, for example, open a network connection. This method
392     * is called before a test is executed.
393     */
394    protected void setUp() {
395        sw = new Support_StringWriter();
396        ssw = new Support_ASimpleWriter(true);
397        bw = new BufferedWriter(sw, 500);
398    }
399
400    /**
401     * Tears down the fixture, for example, close a network connection. This
402     * method is called after a test is executed.
403     */
404    protected void tearDown() {
405
406        ssw.throwExceptionOnNextUse = false;
407        try {
408            bw.close();
409        } catch (Exception e) {
410        }
411    }
412}
413