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 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    public static junit.framework.Test suite() {
50        TestSuite suite = new TestSuite();
51
52        // sink tests
53        suite.addTest(new FileWriterCharSinkTester(true).createTests());
54        suite.addTest(new FileWriterCharSinkTester(false).createTests());
55        suite.addTest(new CharArrayWriterCharSinkTester().setThrowsExceptions(false).createTests());
56        suite.addTest(new StringWriterCharSinkTester().setThrowsExceptions(false).createTests());
57        suite.addTest(new PipedWriterCharSinkTester().createTests());
58
59        // wrapper tests
60        suite.addTest(new BufferedWriterCharSinkTester(1).createTests());
61        suite.addTest(new BufferedWriterCharSinkTester(5).createTests());
62        suite.addTest(new BufferedWriterCharSinkTester(1024).createTests());
63        suite.addTest(new FilterWriterCharSinkTester().createTests());
64        suite.addTest(new PrintWriterCharSinkTester().setThrowsExceptions(false).createTests());
65        suite.addTest(new OutputStreamWriterCharSinkTester().createTests());
66
67        return suite;
68    }
69
70    private static class FileWriterCharSinkTester extends CharSinkTester {
71        private final boolean append;
72        private File file;
73
74        public FileWriterCharSinkTester(boolean append) {
75            this.append = append;
76        }
77
78        @Override public Writer create() throws Exception {
79            file = File.createTempFile("FileOutputStreamSinkTester", "tmp");
80            file.deleteOnExit();
81            return new FileWriter(file, append);
82        }
83
84        @Override public char[] getChars() throws Exception {
85            return Streams.streamToString(new FileReader(file)).toCharArray();
86        }
87    }
88
89    private static class CharArrayWriterCharSinkTester extends CharSinkTester {
90        private CharArrayWriter writer;
91
92        @Override public Writer create() throws Exception {
93            writer = new CharArrayWriter();
94            return writer;
95        }
96
97        @Override public char[] getChars() throws Exception {
98            return writer.toCharArray();
99        }
100    }
101
102    private static class PipedWriterCharSinkTester extends CharSinkTester {
103
104        private ExecutorService executor;
105        private Future<char[]> future;
106
107        public Writer create() throws IOException {
108            final PipedReader in = new PipedReader();
109            PipedWriter out = new PipedWriter(in);
110
111            executor = Executors.newSingleThreadExecutor();
112            future = executor.submit(new Callable<char[]>() {
113                final CharArrayWriter chars = new CharArrayWriter();
114                public char[] call() throws Exception {
115                    char[] buffer = new char[256];
116                    int count;
117                    while ((count = in.read(buffer)) != -1) {
118                        chars.write(buffer, 0, count);
119                    }
120                    return chars.toCharArray();
121                }
122            });
123
124            return out;
125        }
126
127        @Override public char[] getChars() throws Exception {
128            executor.shutdown();
129            return future.get();
130        }
131    }
132
133    private static class StringWriterCharSinkTester extends CharSinkTester {
134        private StringWriter writer;
135
136        @Override public Writer create() throws Exception {
137            writer = new StringWriter();
138            return writer;
139        }
140
141        @Override public char[] getChars() throws Exception {
142            return writer.toString().toCharArray();
143        }
144    }
145
146    private static class BufferedWriterCharSinkTester extends CharWrapperTester {
147        private final int bufferSize;
148
149        private BufferedWriterCharSinkTester(int bufferSize) {
150            this.bufferSize = bufferSize;
151        }
152
153        @Override public Writer create(Writer delegate) throws Exception {
154            return new BufferedWriter(delegate, bufferSize);
155        }
156
157        @Override public char[] decode(char[] delegateChars) throws Exception {
158            return delegateChars;
159        }
160    }
161
162    private static class FilterWriterCharSinkTester extends CharWrapperTester {
163        @Override public Writer create(Writer delegate) throws Exception {
164            return new FilterWriter(delegate) {};
165        }
166
167        @Override public char[] decode(char[] delegateChars) throws Exception {
168            return delegateChars;
169        }
170    }
171
172    private static class PrintWriterCharSinkTester extends CharWrapperTester {
173        @Override public Writer create(Writer delegate) throws Exception {
174            return new PrintWriter(delegate) {};
175        }
176
177        @Override public char[] decode(char[] delegateChars) throws Exception {
178            return delegateChars;
179        }
180    }
181
182    private static class OutputStreamWriterCharSinkTester extends CharSinkTester {
183        private ByteArrayOutputStream out;
184
185        @Override public Writer create() throws Exception {
186            out = new ByteArrayOutputStream();
187            return new OutputStreamWriter(out, "UTF-8");
188        }
189
190        @Override public char[] getChars() throws Exception {
191            return new String(out.toByteArray(), "UTF-8").toCharArray();
192        }
193    }
194}
195