org/apache/harmony/testframework/CharWrapperTester.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package org.apache.harmony.testframework;

import junit.framework.TestCase;
import junit.framework.TestSuite;

import java.io.IOException;
import java.io.Writer;

/**
 * Tests behaviour common to wrapping and filtering implementations of {@link
 * Writer}.
 */
public abstract class CharWrapperTester {

    private boolean throwsExceptions = true;

    /**
     * Creates a new output stream that receives one stream of chars, optionally
     * transforms it, and emits another stream of chars to {@code delegate}.
     */
    public abstract Writer create(Writer delegate) throws Exception;

    /**
     * Decodes the chars received by the delegate into their original form: the
     * chars originally received by this wrapper.
     */
    public abstract char[] decode(char[] delegateChars) throws Exception;

    /**
     * Configures whether the writer is expected to throw exceptions when an
     * error is encountered. Classes like {@code PrintWriter} report errors via
     * an API method instead.
     */
    public CharWrapperTester setThrowsExceptions(boolean throwsExceptions) {
        this.throwsExceptions = throwsExceptions;
        return this;
    }

    public final TestSuite createTests() {
        TestSuite result = new TestSuite();
        result.addTest(new WrapperSinkTester()
                .setThrowsExceptions(throwsExceptions)
                .createTests());

        if (throwsExceptions) {
            result.addTest(new WrapperTestCase("wrapperTestFlushThrowsViaFlush"));
            result.addTest(new WrapperTestCase("wrapperTestFlushThrowsViaClose"));
            result.addTest(new WrapperTestCase("wrapperTestCloseThrows"));
        } else {
            result.addTest(new WrapperTestCase("wrapperTestFlushThrowsViaFlushSuppressed"));
            result.addTest(new WrapperTestCase("wrapperTestFlushThrowsViaCloseSuppressed"));
            result.addTest(new WrapperTestCase("wrapperTestCloseThrowsSuppressed"));
        }

        return result;
    }

    @Override
    public String toString() {
        return getClass().getName();
    }

    private class WrapperSinkTester extends CharSinkTester {
        private ClosableStringWriter delegate;

        @Override
        public Writer create() throws Exception {
            delegate = new ClosableStringWriter();
            return CharWrapperTester.this.create(delegate);
        }

        @Override
        public char[] getChars() throws Exception {
            return decode(delegate.buffer.toString().toCharArray());
        }

        @Override
        public String toString() {
            return CharWrapperTester.this.toString();
        }
    }

    public class WrapperTestCase extends TestCase {

        private WrapperTestCase(String name) {
            super(name);
        }

        @Override
        public String getName() {
            return CharWrapperTester.this.toString() + ":" + super.getName();
        }

        public void wrapperTestFlushThrowsViaFlushSuppressed() throws Exception {
            FailOnFlushWriter delegate = new FailOnFlushWriter();
            Writer o = create(delegate);
            o.write("BUT");
            o.write("TERS");
            o.flush();
            assertTrue(delegate.flushed);
        }

        public void wrapperTestFlushThrowsViaCloseSuppressed() throws Exception {
            FailOnFlushWriter delegate = new FailOnFlushWriter();
            Writer o = create(delegate);
            o.write("BUT");
            o.write("TERS");
            o.close();
            assertTrue(delegate.flushed);
        }

        public void wrapperTestFlushThrowsViaFlush() throws Exception {
            FailOnFlushWriter delegate = new FailOnFlushWriter();

            Writer o = create(delegate);
            try {
                // any of these is permitted to flush
                o.write("BUT");
                o.write("TERS");
                o.flush();
                assertTrue(delegate.flushed);
                fail("flush exception ignored");
            } catch (IOException expected) {
                assertEquals("Flush failed", expected.getMessage());
            }
        }

        public void wrapperTestFlushThrowsViaClose() throws Exception {
            FailOnFlushWriter delegate = new FailOnFlushWriter();

            Writer o = create(delegate);
            try {
                // any of these is permitted to flush
                o.write("BUT");
                o.write("TERS");
                o.close();
                assertTrue(delegate.flushed);
                fail("flush exception ignored");
            } catch (IOException expected) {
                assertEquals("Flush failed", expected.getMessage());
            }

            try {
                o.write("BARK");
                fail("expected already closed exception");
            } catch (IOException expected) {
            }
        }

        public void wrapperTestCloseThrows() throws Exception {
            FailOnCloseWriter delegate = new FailOnCloseWriter();
            Writer o = create(delegate);
            try {
                o.close();
                assertTrue(delegate.closed);
                fail("close exception ignored");
            } catch (IOException expected) {
                assertEquals("Close failed", expected.getMessage());
            }
        }

        public void wrapperTestCloseThrowsSuppressed() throws Exception {
            FailOnCloseWriter delegate = new FailOnCloseWriter();
            Writer o = create(delegate);
            o.close();
            assertTrue(delegate.closed);
        }

        // adding a new test? Don't forget to update createTests().
    }

    /**
     * A custom Writer that respects the closed state. The built-in StringWriter
     * doesn't respect close(), which makes testing wrapped streams difficult.
     */
    private static class ClosableStringWriter extends Writer {
        private final StringBuilder buffer = new StringBuilder();
        private boolean closed = false;

        @Override
        public void close() throws IOException {
            closed = true;
        }

        @Override
        public void flush() throws IOException {
        }

        @Override
        public void write(char[] buf, int offset, int count) throws IOException {
            if (closed) {
                throw new IOException();
            }
            buffer.append(buf, offset, count);
        }
    }

    private static class FailOnFlushWriter extends Writer {
        boolean flushed = false;
        boolean closed = false;

        @Override
        public void write(char[] buf, int offset, int count) throws IOException {
            if (closed) {
                throw new IOException("Already closed");
            }
        }

        @Override
        public void close() throws IOException {
            closed = true;
            flush();
        }

        @Override
        public void flush() throws IOException {
            if (!flushed) {
                flushed = true;
                throw new IOException("Flush failed");
            }
        }
    }

    private static class FailOnCloseWriter extends Writer {
        boolean closed = false;

        @Override
        public void flush() throws IOException {
        }

        @Override
        public void write(char[] buf, int offset, int count) throws IOException {
        }

        @Override
        public void close() throws IOException {
            closed = true;
            throw new IOException("Close failed");
        }
    }
}