BufferedWriterTest.java revision 2a68e06b23ceb5b401d5bc784e6882e71c662cae
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.luni.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 * @tests 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 * @tests 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 * @tests 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 * @tests java.io.BufferedWriter#close() 112 * 113 */ 114 public void test_close2() throws IOException { 115 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new ByteArrayOutputStream())); 116 bw.close(); 117 } 118 119 /** 120 * @tests java.io.BufferedWriter#flush() 121 */ 122 public void test_flush() throws Exception { 123 bw.write("This should not cause a flush"); 124 assertTrue("Bytes written without flush", sw.toString().equals("")); 125 bw.flush(); 126 assertEquals("Bytes not flushed", "This should not cause a flush", sw 127 .toString()); 128 } 129 130 /** 131 * @tests java.io.BufferedWriter#newLine() 132 */ 133 public void test_newLine() throws Exception { 134 String separator = System.getProperty("line.separator"); 135 bw.write("Hello"); 136 bw.newLine(); 137 bw.write("World"); 138 bw.flush(); 139 assertTrue("Incorrect string written: " + sw.toString(), sw.toString() 140 .equals("Hello" + separator + "World")); 141 } 142 143 /** 144 * @tests java.io.BufferedWriter#write(char[], int, int) 145 */ 146 public void test_write$CII() throws Exception { 147 char[] testCharArray = testString.toCharArray(); 148 bw.write(testCharArray, 500, 1000); 149 bw.flush(); 150 assertTrue("Incorrect string written", sw.toString().equals( 151 testString.substring(500, 1500))); 152 } 153 154 /** 155 * @tests java.io.BufferedWriter#write(char[], int, int) 156 */ 157 public void test_write_$CII_Exception() throws IOException { 158 BufferedWriter bWriter = new BufferedWriter(sw); 159 char[] nullCharArray = null; 160 161 try { 162 bWriter.write(nullCharArray, -1, -1); 163 fail("should throw IndexOutOfBoundsException"); 164 } catch (NullPointerException expected) { 165 } catch (IndexOutOfBoundsException expected) { 166 } 167 168 try { 169 bWriter.write(nullCharArray, -1, 0); 170 fail("should throw IndexOutOfBoundsException"); 171 } catch (IndexOutOfBoundsException e) { 172 // expected 173 } 174 175 try { 176 bWriter.write(nullCharArray, 0, -1); 177 fail("should throw NullPointerException"); 178 } catch (NullPointerException e) { 179 // expected 180 } 181 182 try { 183 bWriter.write(nullCharArray, 0, 0); 184 fail("should throw NullPointerException"); 185 } catch (NullPointerException e) { 186 // expected 187 } 188 189 char[] testCharArray = testString.toCharArray(); 190 191 bWriter.write(testCharArray, 0, 0); 192 193 bWriter.write(testCharArray, testCharArray.length, 0); 194 195 try { 196 bWriter.write(testCharArray, testCharArray.length + 1, 0); 197 fail("should throw IndexOutOfBoundsException"); 198 } catch (IndexOutOfBoundsException e) { 199 // expected 200 } 201 202 bWriter.close(); 203 204 try { 205 bWriter.write(nullCharArray, -1, -1); 206 fail("should throw IOException"); 207 } catch (IOException e) { 208 // expected 209 } 210 } 211 212 /** 213 * @tests java.io.BufferedWriter#write(int) 214 */ 215 public void test_writeI() throws Exception { 216 bw.write('T'); 217 assertTrue("Char written without flush", sw.toString().equals("")); 218 bw.flush(); 219 assertEquals("Incorrect char written", "T", sw.toString()); 220 } 221 222 /** 223 * @tests java.io.BufferedWriter#write(java.lang.String, int, int) 224 */ 225 public void test_writeLjava_lang_StringII() throws Exception { 226 bw.write(testString); 227 bw.flush(); 228 assertTrue("Incorrect string written", sw.toString().equals(testString)); 229 } 230 231 /** 232 * @tests java.io.BufferedWriter#write(java.lang.String, int, int) 233 */ 234 public void test_write_LStringII_Exception() throws IOException { 235 BufferedWriter bWriter = new BufferedWriter(sw); 236 237 bWriter.write((String) null, -1, -1); 238 bWriter.write((String) null, -1, 0); 239 bWriter.write((String) null, 0, -1); 240 bWriter.write((String) null, 0, 0); 241 242 try { 243 bWriter.write((String) null, -1, 1); 244 fail("should throw NullPointerException"); 245 } catch (NullPointerException e) { 246 // expected 247 } 248 249 bWriter.write(testString, 0, 0); 250 bWriter.write(testString, testString.length(), 0); 251 bWriter.write(testString, testString.length() + 1, 0); 252 253 try { 254 bWriter.write(testString, testString.length() + 1, 1); 255 fail("should throw StringIndexOutOfBoundsException"); 256 } catch (StringIndexOutOfBoundsException e) { 257 // expected 258 } 259 260 bWriter.close(); 261 262 try { 263 bWriter.write((String) null, -1, -1); 264 fail("should throw IOException"); 265 } catch (IOException e) { 266 // expected 267 } 268 269 try { 270 bWriter.write((String) null, -1, 1); 271 fail("should throw IOException"); 272 } catch (IOException e) { 273 // expected 274 } 275 276 try { 277 bWriter.write(testString, -1, -1); 278 fail("should throw IOException"); 279 } catch (IOException e) { 280 // expected 281 } 282 } 283 284 /** 285 * Sets up the fixture, for example, open a network connection. This method 286 * is called before a test is executed. 287 */ 288 protected void setUp() { 289 sw = new Support_StringWriter(); 290 bw = new BufferedWriter(sw, 500); 291 } 292 293 /** 294 * Tears down the fixture, for example, close a network connection. This 295 * method is called after a test is executed. 296 */ 297 protected void tearDown() { 298 try { 299 bw.close(); 300 } catch (Exception e) { 301 } 302 } 303} 304