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 18 package org.apache.harmony.tests.java.io; 19 20 import junit.framework.TestSuite; 21 import org.apache.harmony.testframework.CharSinkTester; 22 import org.apache.harmony.testframework.CharWrapperTester; 23 import tests.support.Streams; 24 25 import java.io.BufferedWriter; 26 import java.io.ByteArrayOutputStream; 27 import java.io.CharArrayWriter; 28 import java.io.File; 29 import java.io.FileReader; 30 import java.io.FileWriter; 31 import java.io.FilterWriter; 32 import java.io.IOException; 33 import java.io.OutputStreamWriter; 34 import java.io.PipedReader; 35 import java.io.PipedWriter; 36 import java.io.PrintWriter; 37 import java.io.StringWriter; 38 import java.io.Writer; 39 import java.util.concurrent.Callable; 40 import java.util.concurrent.ExecutorService; 41 import java.util.concurrent.Executors; 42 import java.util.concurrent.Future; 43 44 /** 45 * Tests basic {@link Writer} behaviors for the luni implementations of the type. 46 */ 47 public class WriterTesterTest { 48 49 // TODO: Rewrite this test so that id doesn't need a suite(). 50 private static junit.framework.Test suite() { 51 TestSuite suite = new TestSuite(); 52 53 // sink tests 54 suite.addTest(new FileWriterCharSinkTester(true).createTests()); 55 suite.addTest(new FileWriterCharSinkTester(false).createTests()); 56 suite.addTest(new CharArrayWriterCharSinkTester().setThrowsExceptions(false).createTests()); 57 suite.addTest(new StringWriterCharSinkTester().setThrowsExceptions(false).createTests()); 58 suite.addTest(new PipedWriterCharSinkTester().createTests()); 59 60 // wrapper tests 61 suite.addTest(new BufferedWriterCharSinkTester(1).createTests()); 62 suite.addTest(new BufferedWriterCharSinkTester(5).createTests()); 63 suite.addTest(new BufferedWriterCharSinkTester(1024).createTests()); 64 suite.addTest(new FilterWriterCharSinkTester().createTests()); 65 suite.addTest(new PrintWriterCharSinkTester().setThrowsExceptions(false).createTests()); 66 suite.addTest(new OutputStreamWriterCharSinkTester().createTests()); 67 68 return suite; 69 } 70 71 private static class FileWriterCharSinkTester extends CharSinkTester { 72 private final boolean append; 73 private File file; 74 75 public FileWriterCharSinkTester(boolean append) { 76 this.append = append; 77 } 78 79 @Override 80 public Writer create() throws Exception { 81 file = File.createTempFile("FileOutputStreamSinkTester", "tmp"); 82 file.deleteOnExit(); 83 return new FileWriter(file, append); 84 } 85 86 @Override 87 public char[] getChars() throws Exception { 88 return Streams.streamToString(new FileReader(file)).toCharArray(); 89 } 90 } 91 92 private static class CharArrayWriterCharSinkTester extends CharSinkTester { 93 private CharArrayWriter writer; 94 95 @Override 96 public Writer create() throws Exception { 97 writer = new CharArrayWriter(); 98 return writer; 99 } 100 101 @Override 102 public char[] getChars() throws Exception { 103 return writer.toCharArray(); 104 } 105 } 106 107 private static class PipedWriterCharSinkTester extends CharSinkTester { 108 109 private ExecutorService executor; 110 private Future<char[]> future; 111 112 public Writer create() throws IOException { 113 final PipedReader in = new PipedReader(); 114 PipedWriter out = new PipedWriter(in); 115 116 executor = Executors.newSingleThreadExecutor(); 117 future = executor.submit(new Callable<char[]>() { 118 final CharArrayWriter chars = new CharArrayWriter(); 119 120 public char[] call() throws Exception { 121 char[] buffer = new char[256]; 122 int count; 123 while ((count = in.read(buffer)) != -1) { 124 chars.write(buffer, 0, count); 125 } 126 return chars.toCharArray(); 127 } 128 }); 129 130 return out; 131 } 132 133 @Override 134 public char[] getChars() throws Exception { 135 executor.shutdown(); 136 return future.get(); 137 } 138 } 139 140 private static class StringWriterCharSinkTester extends CharSinkTester { 141 private StringWriter writer; 142 143 @Override 144 public Writer create() throws Exception { 145 writer = new StringWriter(); 146 return writer; 147 } 148 149 @Override 150 public char[] getChars() throws Exception { 151 return writer.toString().toCharArray(); 152 } 153 } 154 155 private static class BufferedWriterCharSinkTester extends CharWrapperTester { 156 private final int bufferSize; 157 158 private BufferedWriterCharSinkTester(int bufferSize) { 159 this.bufferSize = bufferSize; 160 } 161 162 @Override 163 public Writer create(Writer delegate) throws Exception { 164 return new BufferedWriter(delegate, bufferSize); 165 } 166 167 @Override 168 public char[] decode(char[] delegateChars) throws Exception { 169 return delegateChars; 170 } 171 } 172 173 private static class FilterWriterCharSinkTester extends CharWrapperTester { 174 @Override 175 public Writer create(Writer delegate) throws Exception { 176 return new FilterWriter(delegate) { 177 }; 178 } 179 180 @Override 181 public char[] decode(char[] delegateChars) throws Exception { 182 return delegateChars; 183 } 184 } 185 186 private static class PrintWriterCharSinkTester extends CharWrapperTester { 187 @Override 188 public Writer create(Writer delegate) throws Exception { 189 return new PrintWriter(delegate) { 190 }; 191 } 192 193 @Override 194 public char[] decode(char[] delegateChars) throws Exception { 195 return delegateChars; 196 } 197 } 198 199 private static class OutputStreamWriterCharSinkTester extends CharSinkTester { 200 private ByteArrayOutputStream out; 201 202 @Override 203 public Writer create() throws Exception { 204 out = new ByteArrayOutputStream(); 205 return new OutputStreamWriter(out, "UTF-8"); 206 } 207 208 @Override 209 public char[] getChars() throws Exception { 210 return new String(out.toByteArray(), "UTF-8").toCharArray(); 211 } 212 } 213 } 214