Quellcode-Bibliothek

^© Kompilation durch diese Firma

[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]

Datei: Sprache: JAVA

/*
* Copyright (c) 2004, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.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");
    }
}

¤ Dauer der Verarbeitung: 0.23 Sekunden (vorverarbeitet) ¤

Download des Quellennavigators
Download des sprechenden Kalenders
in der Quellcodebibliothek suchen

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.