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 junit.framework.TestSuite;
21import org.apache.harmony.testframework.CharSinkTester;
22import org.apache.harmony.testframework.CharWrapperTester;
23import tests.support.Streams;
24
25import java.io.BufferedWriter;
26import java.io.ByteArrayOutputStream;
27import java.io.CharArrayWriter;
28import java.io.File;
29import java.io.FileReader;
30import java.io.FileWriter;
31import java.io.FilterWriter;
32import java.io.IOException;
33import java.io.OutputStreamWriter;
34import java.io.PipedReader;
35import java.io.PipedWriter;
36import java.io.PrintWriter;
37import java.io.StringWriter;
38import java.io.Writer;
39import java.util.concurrent.Callable;
40import java.util.concurrent.ExecutorService;
41import java.util.concurrent.Executors;
42import java.util.concurrent.Future;
43
44/**
45 * Tests basic {@link Writer} behaviors for the luni implementations of the type.
46 */
47public 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