Initial load
diff --git a/test/java/lang/Appendable/Basic.java b/test/java/lang/Appendable/Basic.java
new file mode 100644
index 0000000..509105a
--- /dev/null
+++ b/test/java/lang/Appendable/Basic.java
@@ -0,0 +1,394 @@
+/*
+ * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+/* @test
+ * @bug 5067405
+ * @summary Basic test for classes which implement Appendable.
+ */
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.CharArrayWriter;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+
+interface BasicRunnable extends Runnable {
+ void init(Appendable a, String csq, String exp);
+ Appendable reset(Appendable csq);
+}
+
+public class Basic {
+
+ private static final String s = "Beware the Jabberwock, my son!";
+ private static CharArrayWriter gw = new CharArrayWriter();
+ private static ByteArrayOutputStream gos = new ByteArrayOutputStream();
+
+ private static File newFile() {
+ File f = null;
+ try {
+ f = File.createTempFile("append", ".txt");
+ f.deleteOnExit();
+ } catch (IOException x) {
+ fail(x);
+ }
+ return f;
+ }
+ private static File gf = newFile();
+
+ private static int fail = 0;
+ private static int pass = 0;
+
+ private static Throwable first;
+
+ static void pass() {
+ pass++;
+ }
+
+ static void fail(Throwable ex) {
+ if (first == null)
+ first = ex;
+ System.err.println("FAILED: unexpected exception");
+ fail++;
+ }
+
+ static void fail(String fs, Throwable ex) {
+ String s = "'" + fs + "': " + ex.getClass().getName() + " not thrown";
+ if (first == null)
+ first = ex;
+ System.err.println("FAILED: " + s);
+ fail++;
+ }
+
+ static void fail(String fs, String exp, String got) {
+ String s = "'" + fs + "': Expected '" + exp + "', got '" + got + "'";
+ if (first == null)
+ first = new RuntimeException(s);
+ System.err.println("FAILED: " + s);
+ fail++;
+ }
+
+ static void ck(String s, String exp, String got) {
+ if (!exp.equals(got))
+ fail(s, exp, got);
+ else
+ pass();
+ }
+
+ private static BasicRunnable testBufferedWriter =
+ new BasicRunnable() {
+ private String csn, exp;
+ public void init(Appendable bw, String csn, String exp) {
+ try {
+ ((BufferedWriter)bw).flush();
+ } catch (IOException x) {
+ fail(x);
+ }
+ this.csn = csn;
+ this.exp = exp;
+ }
+ public void run() {
+ ck("BufferedWriter.append(" + csn + ")", exp, gw.toString());
+ }
+ public Appendable reset(Appendable bw) {
+ gw.reset();
+ return bw;
+ }};
+
+ private static BasicRunnable testCharArrayWriter =
+ new BasicRunnable() {
+ private String csn, exp;
+ private CharArrayWriter cw;
+ public void init(Appendable cw, String csn, String exp) {
+ this.cw = (CharArrayWriter)cw;
+ this.csn = csn;
+ this.exp = exp;
+ }
+ public void run() {
+ ck("CharArrayWriter.append(" + csn + ")", exp, cw.toString());
+ }
+ public Appendable reset(Appendable cw) {
+ ((CharArrayWriter)cw).reset();
+ return cw;
+ }};
+
+ private static BasicRunnable testFileWriter =
+ new BasicRunnable() {
+ private String csn, exp;
+ public void init(Appendable fw, String csn, String exp) {
+ try {
+ ((FileWriter)fw).flush();
+ } catch (IOException x) {
+ fail(x);
+ }
+ this.csn = csn;
+ this.exp = exp;
+ }
+ public void run() {
+ StringBuilder sb = new StringBuilder();
+ try {
+ BufferedReader in = new BufferedReader(new FileReader(gf));
+ String line;
+ while (true) {
+ if ((line = in.readLine()) == null)
+ break;
+ sb.append(line);
+ }
+ } catch (IOException x) {
+ fail(x);
+ }
+ ck("FileWriter.append(" + csn + ")", exp, sb.toString());
+ }
+ public Appendable reset(Appendable fw) {
+ try {
+ fw = new FileWriter(gf);
+ } catch (IOException x) {
+ fail(x);
+ }
+ return fw;
+ }};
+
+ private static BasicRunnable testOutputStreamWriter =
+ new BasicRunnable() {
+ private String csn, exp;
+ public void init(Appendable osw, String csn, String exp) {
+ try {
+ ((OutputStreamWriter)osw).flush();
+ } catch (IOException x) {
+ fail(x);
+ }
+ this.csn = csn;
+ this.exp = exp;
+ }
+ public void run() {
+ ck("OutputStreamWriter.append(" + csn + ")", exp, gos.toString());
+ }
+ public Appendable reset(Appendable osw) {
+ gos.reset();
+ return osw;
+ }};
+
+ private static BasicRunnable testPrintWriter =
+ new BasicRunnable() {
+ private String csn, exp;
+ public void init(Appendable pw, String csn, String exp) {
+ ((PrintWriter)pw).flush();
+ this.csn = csn;
+ this.exp = exp;
+ }
+ public void run() {
+ ck("PrintWriter.append(" + csn + ")", exp, gw.toString());
+ }
+ public Appendable reset(Appendable pw) {
+ gw.reset();
+ return pw;
+ }};
+
+ private static BasicRunnable testStringWriter =
+ new BasicRunnable() {
+ private String csn, exp;
+ private StringWriter sw;
+ public void init(Appendable sw, String csn, String exp) {
+ this.sw = (StringWriter)sw;
+ this.csn = csn;
+ this.exp = exp;
+ }
+ public void run() {
+ ck("StringWriter.append(" + csn + ")", exp, sw.toString());
+ }
+ public Appendable reset(Appendable sw) {
+ return new StringWriter();
+ }};
+
+ private static BasicRunnable testPrintStream =
+ new BasicRunnable() {
+ private String csn, exp;
+ public void init(Appendable ps, String csn, String exp) {
+ ((PrintStream)ps).flush();
+ this.csn = csn;
+ this.exp = exp;
+ }
+ public void run() {
+ ck("PrintStream.append(" + csn + ")", exp, gos.toString());
+ }
+ public Appendable reset(Appendable ps) {
+ gos.reset();
+ return ps;
+ }};
+
+ private static BasicRunnable testCharBuffer =
+ new BasicRunnable() {
+ private String csn, exp;
+ private CharBuffer cb;
+ public void init(Appendable cb, String csn, String exp) {
+ this.cb = (CharBuffer)cb;
+ this.csn = csn;
+ this.exp = exp;
+ }
+ public void run() {
+ cb.limit(cb.position()).rewind();
+ ck("CharBuffer.append(" + csn + ")", exp, cb.toString());
+ }
+ public Appendable reset(Appendable cb) {
+ ((CharBuffer)cb).clear();
+ return cb;
+ }};
+
+ private static BasicRunnable testStringBuffer =
+ new BasicRunnable() {
+ private String csn, exp;
+ private StringBuffer sb;
+ public void init(Appendable sb, String csn, String exp) {
+ this.sb = (StringBuffer)sb;
+ this.csn = csn;
+ this.exp = exp;
+ }
+ public void run() {
+ ck("StringBuffer.append(" + csn + ")", exp, sb.toString());
+ }
+ public Appendable reset(Appendable sb) {
+ return new StringBuffer();
+ }};
+
+ private static BasicRunnable testStringBuilder =
+ new BasicRunnable() {
+ private String csn, exp;
+ private StringBuilder sb;
+ public void init(Appendable sb, String csn, String exp) {
+ this.sb = (StringBuilder)sb;
+ this.csn = csn;
+ this.exp = exp;
+ }
+ public void run() {
+ ck("StringBuilder.append(" + csn + ")", exp, sb.toString());
+ }
+ public Appendable reset(Appendable sb) {
+ return new StringBuilder();
+ }};
+
+ private static void test(Appendable a, CharSequence csq, BasicRunnable thunk) {
+ // appends that should always work
+ int [][] sp = { { 0, 0 }, { 11, 11 }, { 11, 21 }, { 0, 7 },
+ { 0, s.length() }, { s.length(), s.length() },
+ };
+ for (int j = 0; j < sp.length; j++) {
+ int start = sp[j][0];
+ int end = sp[j][1];
+ try {
+ thunk.init(a.append(csq, start, end),
+ csq.getClass().getName(),
+ s.subSequence(start, end).toString());
+ thunk.run();
+ a = thunk.reset(a);
+ } catch (IOException x) {
+ fail(x);
+ }
+ }
+
+ // appends that should always throw IndexOutOfBoundsException
+ int [][] sf = { { -1, 0 }, { 0, -1 }, { 11, 10 },
+ { 0, s.length() + 1},
+ };
+ for (int j = 0; j < sf.length; j++) {
+ int start = sf[j][0];
+ int end = sf[j][1];
+ try {
+ a.append(csq, start, end);
+ fail("start = " + start + ", end = " + end,
+ new IndexOutOfBoundsException());
+ a = thunk.reset(a);
+ } catch (IndexOutOfBoundsException x) {
+ pass();
+ } catch (IOException x) {
+ fail(x);
+ }
+ }
+
+ // appends of null
+ int start = 1;
+ int end = 2;
+ try {
+ thunk.init(a.append(null, start, end), "null",
+ "null".subSequence(start, end).toString());
+ thunk.run();
+ a = thunk.reset(a);
+ } catch (IOException x) {
+ fail(x);
+ }
+ }
+
+ public static void main(String [] args) throws Exception {
+ // CharSequences
+ CharBuffer cb = CharBuffer.allocate(128).put(s);
+ cb.limit(s.length()).rewind();
+ CharBuffer dcb = ByteBuffer.allocateDirect(128).asCharBuffer().put(s);
+ dcb.limit(s.length()).rewind();
+ CharSequence [] ca = { s,
+ new StringBuffer(s),
+ new StringBuilder(s),
+ cb,
+ dcb,
+ };
+
+ // Appendables/Writers
+ Object [][] wa = { { new CharArrayWriter(), testCharArrayWriter },
+ { new BufferedWriter(gw), testBufferedWriter },
+ // abstract, no implementing classes in jdk
+ // { new FilterWriter(), testFilterWriter },
+ { new FileWriter(gf), testFileWriter },
+ { new OutputStreamWriter(gos), testOutputStreamWriter },
+ // covered by previous two test cases
+ // { new PipedWriter(gw), testPipedWriter },
+ { new PrintWriter(gw), testPrintWriter },
+ { new StringWriter(), testStringWriter },
+ };
+
+ for (int i = 0; i < ca.length; i++) {
+ CharSequence a = ca[i];
+ for (int j = 0; j < wa.length; j++)
+ test((Writer)wa[j][0], a, (BasicRunnable)wa[j][1]);
+
+ // other Appendables
+ test(new PrintStream(gos), a, testPrintStream);
+ test(CharBuffer.allocate(128), a, testCharBuffer);
+ test(ByteBuffer.allocateDirect(128).asCharBuffer(), a, testCharBuffer);
+ test(new StringBuffer(), a, testStringBuffer);
+ test(new StringBuilder(), a, testStringBuilder);
+ }
+
+ if (fail != 0)
+ throw new RuntimeException((fail + pass) + " tests: "
+ + fail + " failure(s), first", first);
+ else
+ System.out.println("all " + (fail + pass) + " tests passed");
+ }
+}