1/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.internal.util;
18
19import junit.framework.TestCase;
20
21import java.io.ByteArrayOutputStream;
22import java.io.IOException;
23import java.io.PrintWriter;
24import java.io.Writer;
25import java.util.ArrayList;
26import java.util.LinkedList;
27import java.util.List;
28
29/**
30 * Tests for {@link IndentingPrintWriter}.
31 */
32public class LineBreakBufferedWriterTest extends TestCase {
33
34    private ByteArrayOutputStream mStream;
35    private RecordingWriter mWriter;
36
37    @Override
38    protected void setUp() throws Exception {
39        super.setUp();
40
41        mWriter = new RecordingWriter();
42    }
43
44    public void testLessThanBufferSize() {
45        final LineBreakBufferedWriter lw = new LineBreakBufferedWriter(mWriter, 1000);
46
47        lw.println("Hello");
48        lw.println("World");
49        lw.println("Test");
50        lw.flush();
51
52        assertOutput("Hello\nWorld\nTest\n");
53    }
54
55    public void testMoreThanBufferSizeNoLineBreaks() {
56        final LineBreakBufferedWriter lw = new LineBreakBufferedWriter(mWriter, 20);
57
58        String literal = "aaaaaaaaaaaaaaa";
59        lw.print(literal);
60        lw.print(literal);
61        lw.flush();
62
63        // Have to manually inspect output.
64        List<String> result = mWriter.getStrings();
65        // Expect two strings.
66        assertEquals(2, result.size());
67        // Expect the strings to sum up to the original input.
68        assertEquals(2 * literal.length(), result.get(0).length() + result.get(1).length());
69        // Strings should only be a.
70        for (String s : result) {
71            for (int i = 0; i < s.length(); i++) {
72                assertEquals('a', s.charAt(i));
73            }
74        }
75    }
76
77    public void testMoreThanBufferSizeNoLineBreaksSingleString() {
78        final LineBreakBufferedWriter lw = new LineBreakBufferedWriter(mWriter, 20);
79
80        String literal = "aaaaaaaaaaaaaaa";
81        lw.print(literal + literal);
82        lw.flush();
83
84        // Have to manually inspect output.
85        List<String> result = mWriter.getStrings();
86        // Expect two strings.
87        assertEquals(2, result.size());
88        // Expect the strings to sum up to the original input.
89        assertEquals(2 * literal.length(), result.get(0).length() + result.get(1).length());
90        // Strings should only be a.
91        for (String s : result) {
92            for (int i = 0; i < s.length(); i++) {
93                assertEquals('a', s.charAt(i));
94            }
95        }
96    }
97
98    public void testMoreThanBufferSizeLineBreakBefore() {
99        final LineBreakBufferedWriter lw = new LineBreakBufferedWriter(mWriter, 20);
100
101        String literal1 = "aaaaaaaaaa\nbbbb";
102        String literal2 = "cccccccccc";
103        lw.print(literal1);
104        lw.print(literal2);
105        lw.flush();
106
107        assertOutput("aaaaaaaaaa", "bbbbcccccccccc");
108    }
109
110    public void testMoreThanBufferSizeLineBreakBeforeSingleString() {
111        final LineBreakBufferedWriter lw = new LineBreakBufferedWriter(mWriter, 20);
112
113        String literal1 = "aaaaaaaaaa\nbbbb";
114        String literal2 = "cccccccccc";
115        lw.print(literal1 + literal2);
116        lw.flush();
117
118        assertOutput("aaaaaaaaaa", "bbbbcccccccccc");
119    }
120
121    public void testMoreThanBufferSizeLineBreakNew() {
122        final LineBreakBufferedWriter lw = new LineBreakBufferedWriter(mWriter, 20);
123
124        String literal1 = "aaaaaaaaaabbbbb";
125        String literal2 = "c\nd\nddddddddd";
126        lw.print(literal1);
127        lw.print(literal2);
128        lw.flush();
129
130        assertOutput("aaaaaaaaaabbbbbc\nd", "ddddddddd");
131    }
132
133    public void testMoreThanBufferSizeLineBreakBeforeAndNew() {
134        final LineBreakBufferedWriter lw = new LineBreakBufferedWriter(mWriter, 20);
135
136        String literal1 = "aaaaaaaaaa\nbbbbb";
137        String literal2 = "c\nd\nddddddddd";
138        lw.print(literal1);
139        lw.print(literal2);
140        lw.flush();
141
142        assertOutput("aaaaaaaaaa\nbbbbbc\nd", "ddddddddd");
143    }
144
145    public void testMoreThanBufferSizeInt() {
146        final LineBreakBufferedWriter lw = new LineBreakBufferedWriter(mWriter, 15);
147
148        int literal1 = 1234567890;
149        int literal2 = 987654321;
150        lw.print(literal1);
151        lw.print(literal2);
152        lw.flush();
153
154        assertOutput("123456789098765", "4321");
155    }
156
157    public void testMoreThanBufferSizeChar() {
158        final LineBreakBufferedWriter lw = new LineBreakBufferedWriter(mWriter, 15);
159
160        for(int i = 0; i < 10; i++) {
161            lw.print('$');
162        }
163        for(int i = 0; i < 10; i++) {
164            lw.print('%');
165        }
166        lw.flush();
167
168        assertOutput("$$$$$$$$$$%%%%%", "%%%%%");
169    }
170
171    public void testMoreThanBufferSizeLineBreakNewChars() {
172        final LineBreakBufferedWriter lw = new LineBreakBufferedWriter(mWriter, 20);
173
174        String literal1 = "aaaaaaaaaabbbbb";
175        String literal2 = "c\nd\nddddddddd";
176        lw.print(literal1.toCharArray());
177        lw.print(literal2.toCharArray());
178        lw.flush();
179
180        assertOutput("aaaaaaaaaabbbbbc\nd", "ddddddddd");
181    }
182
183    public void testMoreThenInitialCapacitySimpleWrites() {
184        // This check is different from testMoreThanBufferSizeChar. The initial capacity is lower
185        // than the maximum buffer size here.
186        final LineBreakBufferedWriter lw = new LineBreakBufferedWriter(mWriter, 1024, 3);
187
188        for(int i = 0; i < 10; i++) {
189            lw.print('$');
190        }
191        for(int i = 0; i < 10; i++) {
192            lw.print('%');
193        }
194        lw.flush();
195
196        assertOutput("$$$$$$$$$$%%%%%%%%%%");
197    }
198
199    private void assertOutput(String... golden) {
200        List<String> goldList = createTestGolden(golden);
201        assertEquals(goldList, mWriter.getStrings());
202    }
203
204    private static List<String> createTestGolden(String... args) {
205        List<String> ret = new ArrayList<String>();
206        for (String s : args) {
207            ret.add(s);
208        }
209        return ret;
210    }
211
212    // A writer recording calls to write.
213    private final static class RecordingWriter extends Writer {
214
215        private List<String> strings = new ArrayList<String>();
216
217        public RecordingWriter() {
218        }
219
220        public List<String> getStrings() {
221            return strings;
222        }
223
224        @Override
225        public void write(char[] cbuf, int off, int len) {
226            strings.add(new String(cbuf, off, len));
227        }
228
229        @Override
230        public void flush() {
231            // Ignore.
232        }
233
234        @Override
235        public void close() {
236            // Ignore.
237        }
238    }
239}
240