org/apache/harmony/testframework/SinkTester.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.Assert;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import java.io.IOException;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Random;

/**
 * Tests behaviour common to all implementations of {@link OutputStream}. This
 * adapts streams that collects untransformed bytes so that they may be tested.
 */
public abstract class SinkTester {

    private boolean throwsExceptions = true;

    /**
     * Creates a new output stream ready to receive an arbitrary number of
     * bytes. Each time this method is invoked, any previously returned output
     * streams may be discarded.
     */
    public abstract OutputStream create() throws Exception;

    /**
     * Returns the current set of bytes written to the output stream last
     * returned by {@link #create}, and releases any resources held by that
     * stream.
     */
    public abstract byte[] getBytes() throws Exception;

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

    public final TestSuite createTests() {
        TestSuite result = new TestSuite();
        result.addTest(new SinkTestCase("sinkTestNoWriting"));
        result.addTest(new SinkTestCase("sinkTestWriteZeroBytes"));
        result.addTest(new SinkTestCase("sinkTestWriteByteByByte"));
        result.addTest(new SinkTestCase("sinkTestWriteArray"));
        result.addTest(new SinkTestCase("sinkTestWriteOffset"));
        result.addTest(new SinkTestCase("sinkTestWriteLargeArray"));

        if (throwsExceptions) {
            result.addTest(new SinkTestCase("sinkTestWriteAfterClose"));
        } else {
            result.addTest(new SinkTestCase("sinkTestWriteAfterCloseSuppressed"));
        }

        return result;
    }

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

    private static void assertArrayEquals(byte[] expected, byte[] actual) {
        Assert.assertEquals(Arrays.toString(expected), Arrays.toString(actual));
    }

    public class SinkTestCase extends TestCase {

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

        public void sinkTestNoWriting() throws Exception {
            byte[] expected = new byte[] { };

            OutputStream out = create();
            out.close();
            assertArrayEquals(expected, getBytes());
        }

        public void sinkTestWriteZeroBytes() throws Exception {
            byte[] expected = new byte[] { };

            OutputStream out = create();
            byte[] a = new byte[1024];
            out.write(a, 1000, 0);
            out.write(a, 0, 0);
            out.write(new byte[] { });

            out.close();
            assertArrayEquals(expected, getBytes());
        }

        public void sinkTestWriteByteByByte() throws Exception {
            byte[] expected = new byte[] { 5, 6, 7, 3, 4, 5, 3, 2, 1 };

            OutputStream out = create();
            for (byte b : expected) {
                out.write(b);
            }

            out.close();
            assertArrayEquals(expected, getBytes());
        }

        public void sinkTestWriteArray() throws Exception {
            byte[] expected = new byte[] {
                    5, 6,
                    7, 3, 4, 5,
                    3, 2, 1
            };

            OutputStream out = create();

            byte[] a = new byte[] { 5, 6 };
            out.write(a);

            byte[] b = new byte[] { 7, 3, 4, 5 };
            out.write(b);

            byte[] c = new byte[] { 3, 2, 1 };
            out.write(c);

            out.close();
            assertArrayEquals(expected, getBytes());
        }

        public void sinkTestWriteOffset() throws Exception {
            byte[] expected = new byte[] {
                    5, 6,
                    7, 3, 4, 5,
                    3, 2, 1
            };

            OutputStream out = create();

            byte[] a = new byte[1024];
            a[1000] = 5;
            a[1001] = 6;
            out.write(a, 1000, 2);

            byte[] b = new byte[1024];
            b[1020] = 7;
            b[1021] = 3;
            b[1022] = 4;
            b[1023] = 5;
            out.write(b, 1020, 4);

            byte[] c = new byte[1024];
            c[0] = 3;
            c[1] = 2;
            c[2] = 1;
            out.write(c, 0, 3);

            out.close();
            assertArrayEquals(expected, getBytes());
        }

        public void sinkTestWriteLargeArray() throws Exception {
            byte[] expected = new byte[(1024 * 1024) + 1]; // 1 MB + 1 byte
            new Random().nextBytes(expected);

            OutputStream out = create();
            out.write(expected);
            out.close();

            assertArrayEquals(expected, getBytes());
        }

        public void sinkTestWriteAfterClose() throws Exception {
            byte[] expectedBytes = { 5, 6 };
            OutputStream out = create();

            out.write(expectedBytes);
            out.close();

            try {
                out.write(new byte[] { 7, 3, 4, 5 });
                fail("expected already closed exception");
            } catch (IOException expected) {
            }

            assertArrayEquals(expectedBytes, getBytes());
        }

        public void sinkTestWriteAfterCloseSuppressed() throws Exception {
            OutputStream out = create();
            out.write(new byte[] { 5, 6 });
            out.close();
            out.write(new byte[] { 7, 3, 4, 5 }); // no exception expected!
        }

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

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