BufferedWriterTest.java revision ab762bb740405d0fefcccf4a0899a234f995be13
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.tests.java.io; 19 20import java.io.BufferedWriter; 21import java.io.ByteArrayOutputStream; 22import java.io.IOException; 23import java.io.OutputStreamWriter; 24import java.io.Writer; 25 26import tests.support.Support_StringWriter; 27 28public class BufferedWriterTest extends junit.framework.TestCase { 29 30 BufferedWriter bw; 31 32 Support_StringWriter sw; 33 34 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"; 35 36 /** 37 * java.io.BufferedWriter#BufferedWriter(java.io.Writer) 38 */ 39 public void test_ConstructorLjava_io_Writer() { 40 sw = new Support_StringWriter(); 41 bw = new BufferedWriter(sw); 42 sw.write("Hi"); 43 assertEquals("Constructor failed", "Hi", sw.toString()); 44 } 45 46 /** 47 * java.io.BufferedWriter#BufferedWriter(java.io.Writer, int) 48 */ 49 public void test_ConstructorLjava_io_WriterI() { 50 assertTrue("Used in tests", true); 51 } 52 53 private static class MockWriter extends Writer { 54 StringBuffer sb = new StringBuffer(); 55 boolean flushCalled = false; 56 57 public void write(char[] buf, int off, int len) throws IOException { 58 for (int i = off; i < off + len; i++) { 59 sb.append(buf[i]); 60 } 61 } 62 63 public void close() throws IOException { 64 // Empty 65 } 66 67 public void flush() throws IOException { 68 flushCalled = true; 69 } 70 71 public String getWritten() { 72 return sb.toString(); 73 } 74 75 public boolean isFlushCalled() { 76 return flushCalled; 77 } 78 } 79 80 /** 81 * java.io.BufferedWriter#close() 82 */ 83 public void test_close() throws IOException { 84 try { 85 bw.close(); 86 bw.write(testString); 87 fail("Writing to a closed stream should throw IOException"); 88 } catch (IOException e) { 89 // Expected 90 } 91 assertTrue("Write after close", !sw.toString().equals(testString)); 92 93 // Regression test for HARMONY-4178 94 MockWriter mw = new MockWriter(); 95 BufferedWriter bw = new BufferedWriter(mw); 96 bw.write('a'); 97 bw.close(); 98 99 // flush should not be called on underlying stream 100 assertFalse("Flush was called in the underlying stream", mw 101 .isFlushCalled()); 102 103 // on the other hand the BufferedWriter itself should flush the 104 // buffer 105 assertEquals("BufferdWriter do not flush itself before close", "a", mw 106 .getWritten()); 107 } 108 109 /** 110 * @throws IOException 111 * java.io.BufferedWriter#close() 112 */ 113 public void test_close2() throws IOException { 114 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new ByteArrayOutputStream())); 115 bw.close(); 116 } 117 118 /** 119 * java.io.BufferedWriter#flush() 120 */ 121 public void test_flush() throws Exception { 122 bw.write("This should not cause a flush"); 123 assertTrue("Bytes written without flush", sw.toString().equals("")); 124 bw.flush(); 125 assertEquals("Bytes not flushed", "This should not cause a flush", sw 126 .toString()); 127 } 128 129 /** 130 * java.io.BufferedWriter#newLine() 131 */ 132 public void test_newLine() throws Exception { 133 String separator = System.getProperty("line.separator"); 134 bw.write("Hello"); 135 bw.newLine(); 136 bw.write("World"); 137 bw.flush(); 138 assertTrue("Incorrect string written: " + sw.toString(), sw.toString() 139 .equals("Hello" + separator + "World")); 140 } 141 142 /** 143 * java.io.BufferedWriter#write(char[], int, int) 144 */ 145 public void test_write$CII() throws Exception { 146 char[] testCharArray = testString.toCharArray(); 147 bw.write(testCharArray, 500, 1000); 148 bw.flush(); 149 assertTrue("Incorrect string written", sw.toString().equals( 150 testString.substring(500, 1500))); 151 } 152 153 /** 154 * java.io.BufferedWriter#write(char[], int, int) 155 */ 156 public void test_write_$CII_Exception() throws IOException { 157 BufferedWriter bWriter = new BufferedWriter(sw); 158 char[] nullCharArray = null; 159 160 try { 161 bWriter.write(nullCharArray, -1, -1); 162 fail("should throw IndexOutOfBoundsException"); 163 } catch (NullPointerException expected) { 164 } catch (IndexOutOfBoundsException expected) { 165 } 166 167 try { 168 bWriter.write(nullCharArray, -1, 0); 169 fail(); 170 } catch (NullPointerException expected) { 171 } catch (IndexOutOfBoundsException expected) { 172 } 173 174 try { 175 bWriter.write(nullCharArray, 0, -1); 176 fail("should throw NullPointerException"); 177 } catch (NullPointerException e) { 178 // expected 179 } 180 181 try { 182 bWriter.write(nullCharArray, 0, 0); 183 fail("should throw NullPointerException"); 184 } catch (NullPointerException e) { 185 // expected 186 } 187 188 char[] testCharArray = testString.toCharArray(); 189 190 bWriter.write(testCharArray, 0, 0); 191 192 bWriter.write(testCharArray, testCharArray.length, 0); 193 194 try { 195 bWriter.write(testCharArray, testCharArray.length + 1, 0); 196 fail("should throw IndexOutOfBoundsException"); 197 } catch (IndexOutOfBoundsException e) { 198 // expected 199 } 200 201 bWriter.close(); 202 203 try { 204 bWriter.write(nullCharArray, -1, -1); 205 fail("should throw IOException"); 206 } catch (IOException e) { 207 // expected 208 } 209 } 210 211 /** 212 * java.io.BufferedWriter#write(int) 213 */ 214 public void test_writeI() throws Exception { 215 bw.write('T'); 216 assertTrue("Char written without flush", sw.toString().equals("")); 217 bw.flush(); 218 assertEquals("Incorrect char written", "T", sw.toString()); 219 } 220 221 /** 222 * java.io.BufferedWriter#write(java.lang.String, int, int) 223 */ 224 public void test_writeLjava_lang_StringII() throws Exception { 225 bw.write(testString); 226 bw.flush(); 227 assertTrue("Incorrect string written", sw.toString().equals(testString)); 228 } 229 230 /** 231 * java.io.BufferedWriter#write(java.lang.String, int, int) 232 */ 233 public void test_write_LStringII_Exception() throws IOException { 234 BufferedWriter bWriter = new BufferedWriter(sw); 235 236 bWriter.write((String) null, -1, -1); 237 bWriter.write((String) null, -1, 0); 238 bWriter.write((String) null, 0, -1); 239 bWriter.write((String) null, 0, 0); 240 241 try { 242 bWriter.write((String) null, -1, 1); 243 fail("should throw NullPointerException"); 244 } catch (NullPointerException e) { 245 // expected 246 } 247 248 bWriter.write(testString, 0, 0); 249 bWriter.write(testString, testString.length(), 0); 250 bWriter.write(testString, testString.length() + 1, 0); 251 252 try { 253 bWriter.write(testString, testString.length() + 1, 1); 254 fail("should throw StringIndexOutOfBoundsException"); 255 } catch (StringIndexOutOfBoundsException e) { 256 // expected 257 } 258 259 bWriter.close(); 260 261 try { 262 bWriter.write((String) null, -1, -1); 263 fail("should throw IOException"); 264 } catch (IOException e) { 265 // expected 266 } 267 268 try { 269 bWriter.write((String) null, -1, 1); 270 fail("should throw IOException"); 271 } catch (IOException e) { 272 // expected 273 } 274 275 try { 276 bWriter.write(testString, -1, -1); 277 fail("should throw IOException"); 278 } catch (IOException e) { 279 // expected 280 } 281 } 282 283 /** 284 * Sets up the fixture, for example, open a network connection. This method 285 * is called before a test is executed. 286 */ 287 protected void setUp() { 288 sw = new Support_StringWriter(); 289 bw = new BufferedWriter(sw, 500); 290 } 291 292 /** 293 * Tears down the fixture, for example, close a network connection. This 294 * method is called after a test is executed. 295 */ 296 protected void tearDown() { 297 try { 298 bw.close(); 299 } catch (Exception e) { 300 } 301 } 302} 303