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 17 package com.android.internal.util; 18 19 import junit.framework.TestCase; 20 21 import java.io.ByteArrayOutputStream; 22 import java.io.IOException; 23 import java.io.PrintWriter; 24 import java.io.Writer; 25 import java.util.ArrayList; 26 import java.util.LinkedList; 27 import java.util.List; 28 29 /** 30 * Tests for {@link IndentingPrintWriter}. 31 */ 32 public 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
