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 java.io.BufferedReader; 21import java.io.ByteArrayInputStream; 22import java.io.ByteArrayOutputStream; 23import java.io.File; 24import java.io.IOException; 25import java.io.InputStreamReader; 26import java.io.OutputStream; 27import java.io.PrintWriter; 28import java.nio.charset.Charset; 29import java.util.Locale; 30 31import tests.support.Support_StringReader; 32import tests.support.Support_StringWriter; 33 34public class PrintWriterTest extends junit.framework.TestCase { 35 36 static class Bogus { 37 public String toString() { 38 return "Bogus"; 39 } 40 } 41 42 /** 43 * @since 1.6 44 */ 45 static class MockPrintWriter extends PrintWriter { 46 47 public MockPrintWriter(OutputStream out, boolean autoflush) { 48 super(out, autoflush); 49 } 50 51 @Override 52 public void clearError() { 53 super.clearError(); 54 } 55 56 } 57 58 PrintWriter pw; 59 60 ByteArrayOutputStream bao; 61 62 ByteArrayInputStream bai; 63 64 BufferedReader br; 65 66 /** 67 * @tests java.io.PrintWriter#PrintWriter(java.io.OutputStream) 68 */ 69 public void test_ConstructorLjava_io_OutputStream() { 70 // Test for method java.io.PrintWriter(java.io.OutputStream) 71 String s; 72 pw.println("Random Chars"); 73 pw.write("Hello World"); 74 pw.flush(); 75 try { 76 br = new BufferedReader(new Support_StringReader(bao.toString())); 77 s = br.readLine(); 78 assertTrue("Incorrect string written/read: " + s, s 79 .equals("Random Chars")); 80 s = br.readLine(); 81 assertTrue("Incorrect string written/read: " + s, s 82 .equals("Hello World")); 83 } catch (IOException e) { 84 fail("IOException during test : " + e.getMessage()); 85 } 86 } 87 88 /** 89 * @tests java.io.PrintWriter#PrintWriter(java.io.OutputStream, boolean) 90 */ 91 public void test_ConstructorLjava_io_OutputStreamZ() { 92 // Test for method java.io.PrintWriter(java.io.OutputStream, boolean) 93 String s; 94 pw = new PrintWriter(bao, true); 95 pw.println("Random Chars"); 96 pw.write("Hello World"); 97 try { 98 br = new BufferedReader(new Support_StringReader(bao.toString())); 99 s = br.readLine(); 100 assertTrue("Incorrect string written/read: " + s, s 101 .equals("Random Chars")); 102 pw.flush(); 103 br = new BufferedReader(new Support_StringReader(bao.toString())); 104 s = br.readLine(); 105 assertTrue("Incorrect string written/read: " + s, s 106 .equals("Random Chars")); 107 s = br.readLine(); 108 assertTrue("Incorrect string written/read: " + s, s 109 .equals("Hello World")); 110 } catch (IOException e) { 111 fail("IOException during test : " + e.getMessage()); 112 } 113 } 114 115 /** 116 * @tests java.io.PrintWriter#PrintWriter(java.io.Writer) 117 */ 118 public void test_ConstructorLjava_io_Writer() { 119 // Test for method java.io.PrintWriter(java.io.Writer) 120 Support_StringWriter sw; 121 pw = new PrintWriter(sw = new Support_StringWriter()); 122 pw.print("Hello"); 123 pw.flush(); 124 assertEquals("Failed to construct proper writer", 125 "Hello", sw.toString()); 126 } 127 128 /** 129 * @tests java.io.PrintWriter#PrintWriter(java.io.Writer, boolean) 130 */ 131 public void test_ConstructorLjava_io_WriterZ() { 132 // Test for method java.io.PrintWriter(java.io.Writer, boolean) 133 Support_StringWriter sw; 134 pw = new PrintWriter(sw = new Support_StringWriter(), true); 135 pw.print("Hello"); 136 // Auto-flush should have happened 137 assertEquals("Failed to construct proper writer", 138 "Hello", sw.toString()); 139 } 140 141 /** 142 * @tests java.io.PrintWriter#PrintWriter(java.io.File) 143 */ 144 public void test_ConstructorLjava_io_File() throws Exception { 145 File file = File.createTempFile(getClass().getName(), null); 146 try { 147 PrintWriter writer = new PrintWriter(file); 148 writer.close(); 149 } finally { 150 file.delete(); 151 } 152 } 153 154 /** 155 * @tests java.io.PrintWriter#PrintWriter(java.io.File, java.lang.String) 156 */ 157 public void test_ConstructorLjava_io_File_Ljava_lang_String() throws Exception { 158 File file = File.createTempFile(getClass().getName(), null); 159 try { 160 PrintWriter writer = new PrintWriter(file, 161 Charset.defaultCharset().name()); 162 writer.close(); 163 } finally { 164 file.delete(); 165 } 166 } 167 168 /** 169 * @tests java.io.PrintWriter#PrintWriter(java.lang.String) 170 */ 171 public void test_ConstructorLjava_lang_String() throws Exception { 172 File file = File.createTempFile(getClass().getName(), null); 173 try { 174 PrintWriter writer = new PrintWriter(file.getPath()); 175 writer.close(); 176 } finally { 177 file.delete(); 178 } 179 } 180 181 /** 182 * @tests java.io.PrintWriter#PrintWriter(java.lang.String, java.lang.String) 183 */ 184 public void test_ConstructorLjava_lang_String_Ljava_lang_String() throws Exception { 185 File file = File.createTempFile(getClass().getName(), null); 186 try { 187 PrintWriter writer = new PrintWriter(file.getPath(), 188 Charset.defaultCharset().name()); 189 writer.close(); 190 } finally { 191 file.delete(); 192 } 193 } 194 195 /** 196 * @tests java.io.PrintWriter#checkError() 197 */ 198 public void test_checkError() { 199 // Test for method boolean java.io.PrintWriter.checkError() 200 pw.close(); 201 pw.print(490000000000.08765); 202 assertTrue("Failed to return error", pw.checkError()); 203 } 204 205 /** 206 * @tests java.io.PrintWriter#clearError() 207 * @since 1.6 208 */ 209 public void test_clearError() { 210 // Test for method boolean java.io.PrintWriter.clearError() 211 MockPrintWriter mpw = new MockPrintWriter(new ByteArrayOutputStream(), false); 212 mpw.close(); 213 mpw.print(490000000000.08765); 214 assertTrue("Failed to return error", mpw.checkError()); 215 mpw.clearError(); 216 assertFalse("Internal error state has not be cleared", mpw.checkError()); 217 } 218 219 /** 220 * @tests java.io.PrintWriter#close() 221 */ 222 public void test_close() { 223 // Test for method void java.io.PrintWriter.close() 224 pw.close(); 225 pw.println("l"); 226 assertTrue("Write on closed stream failed to generate error", pw 227 .checkError()); 228 } 229 230 /** 231 * @tests java.io.PrintWriter#flush() 232 */ 233 public void test_flush() { 234 // Test for method void java.io.PrintWriter.flush() 235 final double dub = 490000000000.08765; 236 pw.print(dub); 237 pw.flush(); 238 assertTrue("Failed to flush", new String(bao.toByteArray()) 239 .equals(String.valueOf(dub))); 240 } 241 242 /** 243 * @tests java.io.PrintWriter#print(char[]) 244 */ 245 public void test_print$C() { 246 // Test for method void java.io.PrintWriter.print(char []) 247 String s = null; 248 char[] schars = new char[11]; 249 "Hello World".getChars(0, 11, schars, 0); 250 pw.print(schars); 251 pw.flush(); 252 try { 253 br = new BufferedReader(new Support_StringReader(bao.toString())); 254 s = br.readLine(); 255 } catch (IOException e) { 256 fail("IOException during test : " + e.getMessage()); 257 } 258 assertTrue("Wrote incorrect char[] string: " + s, s 259 .equals("Hello World")); 260 int r = 0; 261 try { 262 pw.print((char[]) null); 263 } catch (NullPointerException e) { 264 r = 1; 265 } 266 assertEquals("null pointer exception for printing null char[] is not caught", 267 1, r); 268 } 269 270 /** 271 * @tests java.io.PrintWriter#print(char) 272 */ 273 public void test_printC() { 274 // Test for method void java.io.PrintWriter.print(char) 275 pw.print('c'); 276 pw.flush(); 277 assertEquals("Wrote incorrect char string", "c", new String(bao.toByteArray()) 278 ); 279 } 280 281 /** 282 * @tests java.io.PrintWriter#print(double) 283 */ 284 public void test_printD() { 285 // Test for method void java.io.PrintWriter.print(double) 286 final double dub = 490000000000.08765; 287 pw.print(dub); 288 pw.flush(); 289 assertTrue("Wrote incorrect double string", new String(bao 290 .toByteArray()).equals(String.valueOf(dub))); 291 } 292 293 /** 294 * @tests java.io.PrintWriter#print(float) 295 */ 296 public void test_printF() { 297 // Test for method void java.io.PrintWriter.print(float) 298 final float flo = 49.08765f; 299 pw.print(flo); 300 pw.flush(); 301 assertTrue("Wrote incorrect float string", 302 new String(bao.toByteArray()).equals(String.valueOf(flo))); 303 } 304 305 /** 306 * @tests java.io.PrintWriter#print(int) 307 */ 308 public void test_printI() { 309 // Test for method void java.io.PrintWriter.print(int) 310 pw.print(4908765); 311 pw.flush(); 312 assertEquals("Wrote incorrect int string", "4908765", new String(bao.toByteArray()) 313 ); 314 } 315 316 /** 317 * @tests java.io.PrintWriter#print(long) 318 */ 319 public void test_printJ() { 320 // Test for method void java.io.PrintWriter.print(long) 321 pw.print(49087650000L); 322 pw.flush(); 323 assertEquals("Wrote incorrect long string", "49087650000", new String(bao.toByteArray()) 324 ); 325 } 326 327 /** 328 * @tests java.io.PrintWriter#print(java.lang.Object) 329 */ 330 public void test_printLjava_lang_Object() { 331 // Test for method void java.io.PrintWriter.print(java.lang.Object) 332 pw.print((Object) null); 333 pw.flush(); 334 assertEquals("Did not write null", "null", new String(bao.toByteArray()) 335 ); 336 bao.reset(); 337 338 pw.print(new Bogus()); 339 pw.flush(); 340 assertEquals("Wrote in incorrect Object string", "Bogus", new String(bao 341 .toByteArray())); 342 } 343 344 /** 345 * @tests java.io.PrintWriter#print(java.lang.String) 346 */ 347 public void test_printLjava_lang_String() { 348 // Test for method void java.io.PrintWriter.print(java.lang.String) 349 pw.print((String) null); 350 pw.flush(); 351 assertEquals("did not write null", "null", new String(bao.toByteArray()) 352 ); 353 bao.reset(); 354 355 pw.print("Hello World"); 356 pw.flush(); 357 assertEquals("Wrote incorrect string", "Hello World", new String(bao.toByteArray()) 358 ); 359 } 360 361 /** 362 * @tests java.io.PrintWriter#print(boolean) 363 */ 364 public void test_printZ() { 365 // Test for method void java.io.PrintWriter.print(boolean) 366 pw.print(true); 367 pw.flush(); 368 assertEquals("Wrote in incorrect boolean string", "true", new String(bao 369 .toByteArray())); 370 } 371 372 /** 373 * @tests java.io.PrintWriter#println() 374 */ 375 public void test_println() { 376 // Test for method void java.io.PrintWriter.println() 377 String s; 378 pw.println("Blarg"); 379 pw.println(); 380 pw.println("Bleep"); 381 pw.flush(); 382 try { 383 br = new BufferedReader(new Support_StringReader(bao.toString())); 384 s = br.readLine(); 385 assertTrue("Wrote incorrect line: " + s, s.equals("Blarg")); 386 s = br.readLine(); 387 assertTrue("Wrote incorrect line: " + s, s.equals("")); 388 s = br.readLine(); 389 assertTrue("Wrote incorrect line: " + s, s.equals("Bleep")); 390 } catch (IOException e) { 391 fail("IOException during test : " + e.getMessage()); 392 } 393 } 394 395 /** 396 * @tests java.io.PrintWriter#println(char[]) 397 */ 398 public void test_println$C() { 399 // Test for method void java.io.PrintWriter.println(char []) 400 String s = null; 401 char[] schars = new char[11]; 402 "Hello World".getChars(0, 11, schars, 0); 403 pw.println("Random Chars"); 404 pw.println(schars); 405 pw.flush(); 406 try { 407 br = new BufferedReader(new Support_StringReader(bao.toString())); 408 s = br.readLine(); 409 s = br.readLine(); 410 } catch (IOException e) { 411 fail("IOException during test : " + e.getMessage()); 412 } 413 assertTrue("Wrote incorrect char[] string: " + s, s 414 .equals("Hello World")); 415 } 416 417 /** 418 * @tests java.io.PrintWriter#println(char) 419 */ 420 public void test_printlnC() { 421 // Test for method void java.io.PrintWriter.println(char) 422 String s = null; 423 pw.println("Random Chars"); 424 pw.println('c'); 425 pw.flush(); 426 try { 427 br = new BufferedReader(new Support_StringReader(bao.toString())); 428 s = br.readLine(); 429 s = br.readLine(); 430 } catch (IOException e) { 431 fail("IOException during test : " + e.getMessage()); 432 } 433 assertTrue("Wrote incorrect char string: " + s, s.equals("c")); 434 } 435 436 /** 437 * @tests java.io.PrintWriter#println(double) 438 */ 439 public void test_printlnD() { 440 // Test for method void java.io.PrintWriter.println(double) 441 String s = null; 442 final double dub = 4000000000000000.657483; 443 pw.println("Random Chars"); 444 pw.println(dub); 445 pw.flush(); 446 try { 447 br = new BufferedReader(new Support_StringReader(bao.toString())); 448 br.readLine(); 449 s = br.readLine(); 450 } catch (IOException e) { 451 fail("IOException during test : " + e.getMessage()); 452 } 453 assertTrue("Wrote incorrect double string: " + s, s.equals(String 454 .valueOf(dub))); 455 } 456 457 /** 458 * @tests java.io.PrintWriter#println(float) 459 */ 460 public void test_printlnF() { 461 // Test for method void java.io.PrintWriter.println(float) 462 String s; 463 final float flo = 40.4646464f; 464 pw.println("Random Chars"); 465 pw.println(flo); 466 pw.flush(); 467 try { 468 br = new BufferedReader(new Support_StringReader(bao.toString())); 469 br.readLine(); 470 s = br.readLine(); 471 assertTrue("Wrote incorrect float string: " + s + " wanted: " 472 + String.valueOf(flo), s.equals(String.valueOf(flo))); 473 } catch (IOException e) { 474 fail("IOException during test : " + e.getMessage()); 475 } 476 477 } 478 479 /** 480 * @tests java.io.PrintWriter#println(int) 481 */ 482 public void test_printlnI() { 483 // Test for method void java.io.PrintWriter.println(int) 484 String s = null; 485 pw.println("Random Chars"); 486 pw.println(400000); 487 pw.flush(); 488 try { 489 br = new BufferedReader(new Support_StringReader(bao.toString())); 490 br.readLine(); 491 s = br.readLine(); 492 } catch (IOException e) { 493 fail("IOException during test : " + e.getMessage()); 494 } 495 assertTrue("Wrote incorrect int string: " + s, s.equals("400000")); 496 } 497 498 /** 499 * @tests java.io.PrintWriter#println(long) 500 */ 501 public void test_printlnJ() { 502 // Test for method void java.io.PrintWriter.println(long) 503 String s = null; 504 pw.println("Random Chars"); 505 pw.println(4000000000000L); 506 pw.flush(); 507 try { 508 br = new BufferedReader(new Support_StringReader(bao.toString())); 509 br.readLine(); 510 s = br.readLine(); 511 } catch (IOException e) { 512 fail("IOException during test : " + e.getMessage()); 513 } 514 assertTrue("Wrote incorrect long string: " + s, s 515 .equals("4000000000000")); 516 } 517 518 /** 519 * @tests java.io.PrintWriter#println(java.lang.Object) 520 */ 521 public void test_printlnLjava_lang_Object() { 522 // Test for method void java.io.PrintWriter.println(java.lang.Object) 523 String s = null; 524 pw.println("Random Chars"); 525 pw.println(new Bogus()); 526 pw.flush(); 527 try { 528 br = new BufferedReader(new Support_StringReader(bao.toString())); 529 br.readLine(); 530 s = br.readLine(); 531 } catch (IOException e) { 532 fail("IOException during test : " + e.getMessage()); 533 } 534 assertTrue("Wrote incorrect Object string: " + s, s.equals("Bogus")); 535 } 536 537 /** 538 * @tests java.io.PrintWriter#println(java.lang.String) 539 */ 540 public void test_printlnLjava_lang_String() { 541 // Test for method void java.io.PrintWriter.println(java.lang.String) 542 String s = null; 543 pw.println("Random Chars"); 544 pw.println("Hello World"); 545 pw.flush(); 546 try { 547 br = new BufferedReader(new Support_StringReader(bao.toString())); 548 br.readLine(); 549 s = br.readLine(); 550 } catch (IOException e) { 551 fail("IOException during test : " + e.getMessage()); 552 } 553 assertTrue("Wrote incorrect string: " + s, s.equals("Hello World")); 554 } 555 556 /** 557 * @tests java.io.PrintWriter#println(boolean) 558 */ 559 public void test_printlnZ() { 560 // Test for method void java.io.PrintWriter.println(boolean) 561 String s = null; 562 pw.println("Random Chars"); 563 pw.println(false); 564 pw.flush(); 565 try { 566 br = new BufferedReader(new Support_StringReader(bao.toString())); 567 br.readLine(); 568 s = br.readLine(); 569 } catch (IOException e) { 570 fail("IOException during test : " + e.getMessage()); 571 } 572 assertTrue("Wrote incorrect boolean string: " + s, s.equals("false")); 573 } 574 575 /** 576 * @tests java.io.PrintWriter#write(char[]) 577 */ 578 public void test_write$C() { 579 // Test for method void java.io.PrintWriter.write(char []) 580 String s = null; 581 char[] schars = new char[11]; 582 "Hello World".getChars(0, 11, schars, 0); 583 pw.println("Random Chars"); 584 pw.write(schars); 585 pw.flush(); 586 try { 587 br = new BufferedReader(new Support_StringReader(bao.toString())); 588 br.readLine(); 589 s = br.readLine(); 590 } catch (IOException e) { 591 fail("IOException during test: " + e.getMessage()); 592 } 593 assertTrue("Wrote incorrect char[] string: " + s, s 594 .equals("Hello World")); 595 } 596 597 /** 598 * @tests java.io.PrintWriter#write(char[], int, int) 599 */ 600 public void test_write$CII() { 601 // Test for method void java.io.PrintWriter.write(char [], int, int) 602 String s = null; 603 char[] schars = new char[11]; 604 "Hello World".getChars(0, 11, schars, 0); 605 pw.println("Random Chars"); 606 pw.write(schars, 6, 5); 607 pw.flush(); 608 try { 609 br = new BufferedReader(new Support_StringReader(bao.toString())); 610 br.readLine(); 611 s = br.readLine(); 612 } catch (IOException e) { 613 fail("IOException during test : " + e.getMessage()); 614 } 615 assertTrue("Wrote incorrect char[] string: " + s, s.equals("World")); 616 } 617 618 /** 619 * @tests java.io.PrintWriter#write(int) 620 */ 621 public void test_writeI() throws IOException { 622 // Test for method void java.io.PrintWriter.write(int) 623 char[] cab = new char[3]; 624 pw.write('a'); 625 pw.write('b'); 626 pw.write('c'); 627 pw.flush(); 628 InputStreamReader isr = new InputStreamReader(new ByteArrayInputStream(bao.toByteArray())); 629 cab[0] = (char) isr.read(); 630 cab[1] = (char) isr.read(); 631 cab[2] = (char) isr.read(); 632 assertTrue("Wrote incorrect ints", cab[0] == 'a' && cab[1] == 'b' 633 && cab[2] == 'c'); 634 635 } 636 637 /** 638 * @tests java.io.PrintWriter#write(java.lang.String) 639 */ 640 public void test_writeLjava_lang_String() { 641 // Test for method void java.io.PrintWriter.write(java.lang.String) 642 String s = null; 643 pw.println("Random Chars"); 644 pw.write("Hello World"); 645 pw.flush(); 646 try { 647 br = new BufferedReader(new Support_StringReader(bao.toString())); 648 br.readLine(); 649 s = br.readLine(); 650 } catch (IOException e) { 651 fail("IOException during test : " + e.getMessage()); 652 } 653 assertTrue("Wrote incorrect char[] string: " + s, s 654 .equals("Hello World")); 655 } 656 657 /** 658 * @tests java.io.PrintWriter#write(java.lang.String, int, int) 659 */ 660 public void test_writeLjava_lang_StringII() { 661 // Test for method void java.io.PrintWriter.write(java.lang.String, int, 662 // int) 663 String s = null; 664 pw.println("Random Chars"); 665 pw.write("Hello World", 6, 5); 666 pw.flush(); 667 try { 668 br = new BufferedReader(new Support_StringReader(bao.toString())); 669 br.readLine(); 670 s = br.readLine(); 671 } catch (IOException e) { 672 fail("IOException during test : " + e.getMessage()); 673 } 674 assertTrue("Wrote incorrect char[] string: " + s, s.equals("World")); 675 } 676 677 /** 678 * @tests java.io.PrintWriter#append(char) 679 */ 680 public void test_appendChar() { 681 char testChar = ' '; 682 ByteArrayOutputStream out = new ByteArrayOutputStream(); 683 PrintWriter printWriter = new PrintWriter(out); 684 printWriter.append(testChar); 685 printWriter.flush(); 686 assertEquals(String.valueOf(testChar),out.toString()); 687 printWriter.close(); 688 } 689 /** 690 * @tests java.io.PrintWriter#append(CharSequence) 691 */ 692 public void test_appendCharSequence() { 693 694 String testString = "My Test String"; 695 ByteArrayOutputStream out = new ByteArrayOutputStream(); 696 PrintWriter printWriter = new PrintWriter(out); 697 printWriter.append(testString); 698 printWriter.flush(); 699 assertEquals(testString, out.toString()); 700 printWriter.close(); 701 702 } 703 704 /** 705 * @tests java.io.PrintWriter#append(CharSequence, int, int) 706 */ 707 public void test_appendCharSequenceIntInt() { 708 String testString = "My Test String"; 709 ByteArrayOutputStream out = new ByteArrayOutputStream(); 710 PrintWriter printWriter = new PrintWriter(out); 711 printWriter.append(testString, 1, 3); 712 printWriter.flush(); 713 assertEquals(testString.substring(1, 3), out.toString()); 714 printWriter.close(); 715 716 } 717 718 /** 719 * @tests java.io.PrintWriter#format(java.lang.String, java.lang.Object...) 720 */ 721 public void test_formatLjava_lang_String$Ljava_lang_Object() { 722 pw.format("%s %s", "Hello", "World"); 723 pw.flush(); 724 assertEquals("Wrote incorrect string", "Hello World", 725 new String(bao.toByteArray())); 726 } 727 728 /** 729 * @tests java.io.PrintWriter#format(java.util.Locale, java.lang.String, java.lang.Object...) 730 */ 731 public void test_formatLjava_util_Locale_Ljava_lang_String_$Ljava_lang_Object() { 732 pw.format(Locale.US, "%s %s", "Hello", "World"); 733 pw.flush(); 734 assertEquals("Wrote incorrect string", "Hello World", 735 new String(bao.toByteArray())); 736 } 737 738 /** 739 * @tests java.io.PrintWriter#printf(java.lang.String, java.lang.Object...) 740 */ 741 public void test_printfLjava_lang_String$Ljava_lang_Object() { 742 pw.printf("%s %s", "Hello", "World"); 743 pw.flush(); 744 assertEquals("Wrote incorrect string", "Hello World", 745 new String(bao.toByteArray())); 746 } 747 748 /** 749 * @tests java.io.PrintWriter#printf(java.util.Locale, java.lang.String, java.lang.Object...) 750 */ 751 public void test_printfLjava_util_Locale_Ljava_lang_String_$Ljava_lang_Object() { 752 pw.printf(Locale.US, "%s %s", "Hello", "World"); 753 pw.flush(); 754 assertEquals("Wrote incorrect string", "Hello World", 755 new String(bao.toByteArray())); 756 } 757 758 /** 759 * Sets up the fixture, for example, open a network connection. This method 760 * is called before a test is executed. 761 */ 762 protected void setUp() { 763 bao = new ByteArrayOutputStream(); 764 pw = new PrintWriter(bao, false); 765 766 } 767 768 /** 769 * Tears down the fixture, for example, close a network connection. This 770 * method is called after a test is executed. 771 */ 772 protected void tearDown() { 773 try { 774 pw.close(); 775 } catch (Exception e) { 776 } 777 } 778} 779