src/test/java/org/apache/commons/io/output/ByteArrayOutputStreamTest.java - commons-io - Git at Google

 /*
  * 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.commons.io.output;

 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;

 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.stream.Stream;

 import org.apache.commons.io.IOUtils;
 import org.apache.commons.io.function.IOFunction;
 import org.apache.commons.io.input.ClosedInputStream;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;

 /**
  * Tests the alternative ByteArrayOutputStream implementations.
  */
 public class ByteArrayOutputStreamTest {

     private interface BAOSFactory<T extends AbstractByteArrayOutputStream> {
         T newInstance();

         T newInstance(final int size);
     }

     private static final class ByteArrayOutputStreamFactory implements BAOSFactory<ByteArrayOutputStream> {
         @Override
         public ByteArrayOutputStream newInstance() {
             return new ByteArrayOutputStream();
         }

         @Override
         public ByteArrayOutputStream newInstance(final int size) {
             return new ByteArrayOutputStream(size);
         }
     }

     private static final class UnsynchronizedByteArrayOutputStreamFactory implements BAOSFactory<UnsynchronizedByteArrayOutputStream> {
         @Override
         public UnsynchronizedByteArrayOutputStream newInstance() {
             return new UnsynchronizedByteArrayOutputStream();
         }

         @Override
         public UnsynchronizedByteArrayOutputStream newInstance(final int size) {
             return new UnsynchronizedByteArrayOutputStream(size);
         }
     }

     private static final byte[] DATA;

     static {
         DATA = new byte[64];
         for (byte i = 0; i < 64; i++) {
             DATA[i] = i;
         }
     }

     private static Stream<Arguments> baosFactories() {
         return Stream.of(Arguments.of(ByteArrayOutputStream.class.getSimpleName(), new ByteArrayOutputStreamFactory()),
             Arguments.of(UnsynchronizedByteArrayOutputStream.class.getSimpleName(), new UnsynchronizedByteArrayOutputStreamFactory()));
     }

     private static boolean byteCmp(final byte[] src, final byte[] cmp) {
         for (int i = 0; i < cmp.length; i++) {
             if (src[i] != cmp[i]) {
                 return false;
             }
         }
         return true;
     }

     private static Stream<Arguments> toBufferedInputStreamFunctionFactories() {
         final IOFunction<InputStream, InputStream> syncBaosToBufferedInputStream = ByteArrayOutputStream::toBufferedInputStream;
         final IOFunction<InputStream, InputStream> syncBaosToBufferedInputStreamWithSize = is -> ByteArrayOutputStream.toBufferedInputStream(is, 1024);
         final IOFunction<InputStream, InputStream> unSyncBaosToBufferedInputStream = UnsynchronizedByteArrayOutputStream::toBufferedInputStream;
         final IOFunction<InputStream, InputStream> unSyncBaosToBufferedInputStreamWithSize = is -> UnsynchronizedByteArrayOutputStream.toBufferedInputStream(is,
             1024);

         return Stream.of(Arguments.of("ByteArrayOutputStream.toBufferedInputStream(InputStream)", syncBaosToBufferedInputStream),
             Arguments.of("ByteArrayOutputStream.toBufferedInputStream(InputStream, int)", syncBaosToBufferedInputStreamWithSize),
             Arguments.of("UnsynchronizedByteArrayOutputStream.toBufferedInputStream(InputStream)", unSyncBaosToBufferedInputStream),
             Arguments.of("UnsynchronizedByteArrayOutputStream.toBufferedInputStream(InputStream, int)", unSyncBaosToBufferedInputStreamWithSize));
     }

     private void checkByteArrays(final byte[] expected, final byte[] actual) {
         if (expected.length != actual.length) {
             fail("Resulting byte arrays are not equally long");
         }
         if (!byteCmp(expected, actual)) {
             fail("Resulting byte arrays are not equal");
         }
     }

     private void checkStreams(final AbstractByteArrayOutputStream actual, final java.io.ByteArrayOutputStream expected) {
         assertEquals(expected.size(), actual.size(), "Sizes are not equal");
         final byte[] buf = actual.toByteArray();
         final byte[] refbuf = expected.toByteArray();
         checkByteArrays(buf, refbuf);
     }

     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("baosFactories")
     public void testInvalidParameterizedConstruction(final String baosName, final BAOSFactory<?> baosFactory) {
         assertThrows(IllegalArgumentException.class, () -> baosFactory.newInstance(-1));
     }

     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("baosFactories")
     public void testInvalidWriteLenUnder(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
         try (AbstractByteArrayOutputStream baout = baosFactory.newInstance()) {
             assertThrows(IndexOutOfBoundsException.class, () -> baout.write(new byte[1], 0, -1));
         }
     }

     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("baosFactories")
     public void testInvalidWriteOffsetAndLenOver(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
         try (AbstractByteArrayOutputStream baout = baosFactory.newInstance()) {
             assertThrows(IndexOutOfBoundsException.class, () -> baout.write(new byte[1], 0, 2));
         }
     }

     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("baosFactories")
     public void testInvalidWriteOffsetAndLenUnder(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
         try (AbstractByteArrayOutputStream baout = baosFactory.newInstance()) {
             assertThrows(IndexOutOfBoundsException.class, () -> baout.write(new byte[1], 1, -2));
         }
     }

     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("baosFactories")
     public void testInvalidWriteOffsetOver(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
         try (AbstractByteArrayOutputStream baout = baosFactory.newInstance()) {
             assertThrows(IndexOutOfBoundsException.class, () -> baout.write(IOUtils.EMPTY_BYTE_ARRAY, 1, 0));
         }
     }

     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("baosFactories")
     public void testInvalidWriteOffsetUnder(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
         try (AbstractByteArrayOutputStream baout = baosFactory.newInstance()) {
             assertThrows(IndexOutOfBoundsException.class, () -> baout.write(null, -1, 0));
         }
     }

     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("baosFactories")
     public void testStream(final String baosName, final BAOSFactory<?> baosFactory) throws Exception {
         int written;

         // The ByteArrayOutputStream is initialized with 32 bytes to match
         // the original more closely for this test.
         try (AbstractByteArrayOutputStream baout = baosFactory.newInstance(32);
             final java.io.ByteArrayOutputStream ref = new java.io.ByteArrayOutputStream()) {

             // First three writes
             written = writeData(baout, ref, new int[] {4, 10, 22});
             assertEquals(36, written);
             checkStreams(baout, ref);

             // Another two writes to see if there are any bad effects after toByteArray()
             written = writeData(baout, ref, new int[] {20, 12});
             assertEquals(32, written);
             checkStreams(baout, ref);

             // Now reset the streams
             baout.reset();
             ref.reset();

             // Test again to see if reset() had any bad effects
             written = writeData(baout, ref, new int[] {5, 47, 33, 60, 1, 0, 8});
             assertEquals(155, written);
             checkStreams(baout, ref);

             // Test the readFrom(InputStream) method
             baout.reset();
             written = baout.write(new ByteArrayInputStream(ref.toByteArray()));
             assertEquals(155, written);
             checkStreams(baout, ref);

             // Write the commons Byte[]OutputStream to a java.io.Byte[]OutputStream
             // and vice-versa to test the writeTo() method.
             try (AbstractByteArrayOutputStream baout1 = baosFactory.newInstance(32)) {
                 ref.writeTo(baout1);
                 final java.io.ByteArrayOutputStream ref1 = new java.io.ByteArrayOutputStream();
                 baout.writeTo(ref1);
                 checkStreams(baout1, ref1);

                 // Testing toString(String)
                 final String baoutString = baout.toString("ASCII");
                 final String refString = ref.toString("ASCII");
                 assertEquals(refString, baoutString, "ASCII decoded String must be equal");

                 // Make sure that empty ByteArrayOutputStreams really don't create garbage
                 // on toByteArray()
                 try (AbstractByteArrayOutputStream baos1 = baosFactory.newInstance();
                     final AbstractByteArrayOutputStream baos2 = baosFactory.newInstance()) {
                     assertSame(baos1.toByteArray(), baos2.toByteArray());
                 }
             }
         }
     }

     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("toBufferedInputStreamFunctionFactories")
     public void testToBufferedInputStream(final String baosName, final IOFunction<InputStream, InputStream> toBufferedInputStreamFunction) throws IOException {
         final byte[] data = {(byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE};

         try (ByteArrayInputStream bain = new ByteArrayInputStream(data)) {
             assertEquals(data.length, bain.available());

             try (InputStream buffered = toBufferedInputStreamFunction.apply(bain)) {
                 assertEquals(data.length, buffered.available());

                 assertArrayEquals(data, IOUtils.toByteArray(buffered));

             }
         }
     }

     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("toBufferedInputStreamFunctionFactories")
     public void testToBufferedInputStreamEmpty(final String baosName, final IOFunction<InputStream, InputStream> toBufferedInputStreamFunction)
         throws IOException {
         try (ByteArrayInputStream bain = new ByteArrayInputStream(IOUtils.EMPTY_BYTE_ARRAY)) {
             assertEquals(0, bain.available());

             try (InputStream buffered = toBufferedInputStreamFunction.apply(bain)) {
                 assertEquals(0, buffered.available());

             }
         }
     }

     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("baosFactories")
     public void testToInputStream(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
         try (AbstractByteArrayOutputStream baout = baosFactory.newInstance();
             final java.io.ByteArrayOutputStream ref = new java.io.ByteArrayOutputStream()) {

             // Write 8224 bytes
             writeData(baout, ref, 32);
             for (int i = 0; i < 128; i++) {
                 writeData(baout, ref, 64);
             }

             // Get data before more writes
             try (InputStream in = baout.toInputStream()) {
                 byte[] refData = ref.toByteArray();

                 // Write some more data
                 writeData(baout, ref, new int[] {2, 4, 8, 16});

                 // Check original data
                 byte[] baoutData = IOUtils.toByteArray(in);
                 assertEquals(8224, baoutData.length);
                 checkByteArrays(refData, baoutData);

                 // Check all data written
                 try (InputStream in2 = baout.toInputStream()) {
                     baoutData = IOUtils.toByteArray(in2);
                 }
                 refData = ref.toByteArray();
                 assertEquals(8254, baoutData.length);
                 checkByteArrays(refData, baoutData);
             }
         }
     }

     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("baosFactories")
     public void testToInputStreamEmpty(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
         try (AbstractByteArrayOutputStream baout = baosFactory.newInstance();
             // Get data before more writes
             final InputStream in = baout.toInputStream()) {
             assertEquals(0, in.available());
             assertTrue(in instanceof ClosedInputStream);
         }
     }

     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("baosFactories")
     public void testToInputStreamWithReset(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
         // Make sure reset() do not destroy InputStream returned from toInputStream()
         try (AbstractByteArrayOutputStream baout = baosFactory.newInstance();
             final java.io.ByteArrayOutputStream ref = new java.io.ByteArrayOutputStream()) {

             // Write 8224 bytes
             writeData(baout, ref, 32);
             for (int i = 0; i < 128; i++) {
                 writeData(baout, ref, 64);
             }

             // Get data before reset
             try (InputStream in = baout.toInputStream()) {
                 byte[] refData = ref.toByteArray();

                 // Reset and write some new data
                 baout.reset();
                 ref.reset();
                 writeData(baout, ref, new int[] {2, 4, 8, 16});

                 // Check original data
                 byte[] baoutData = IOUtils.toByteArray(in);
                 assertEquals(8224, baoutData.length);
                 checkByteArrays(refData, baoutData);

                 // Check new data written after reset
                 try (InputStream in2 = baout.toInputStream()) {
                     baoutData = IOUtils.toByteArray(in2);
                 }
                 refData = ref.toByteArray();
                 assertEquals(30, baoutData.length);
                 checkByteArrays(refData, baoutData);
             }
         }
     }

     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("baosFactories")
     public void testWriteZero(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
         try (AbstractByteArrayOutputStream baout = baosFactory.newInstance()) {
             baout.write(IOUtils.EMPTY_BYTE_ARRAY, 0, 0);
             assertTrue(true, "Dummy");
         }
     }

     private int writeData(final AbstractByteArrayOutputStream baout, final java.io.ByteArrayOutputStream ref, final int count) {
         if (count > DATA.length) {
             throw new IllegalArgumentException("Requesting too many bytes");
         }
         if (count == 0) {
             baout.write(100);
             ref.write(100);
             return 1;
         }
         baout.write(DATA, 0, count);
         ref.write(DATA, 0, count);
         return count;
     }

     private int writeData(final AbstractByteArrayOutputStream baout, final java.io.ByteArrayOutputStream ref, final int[] instructions) {
         int written = 0;
         for (final int instruction : instructions) {
             written += writeData(baout, ref, instruction);
         }
         return written;
     }
 }
	/*
	* 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.commons.io.output;

	import static org.junit.jupiter.api.Assertions.assertArrayEquals;
	import static org.junit.jupiter.api.Assertions.assertEquals;
	import static org.junit.jupiter.api.Assertions.assertSame;
	import static org.junit.jupiter.api.Assertions.assertThrows;
	import static org.junit.jupiter.api.Assertions.assertTrue;
	import static org.junit.jupiter.api.Assertions.fail;

	import java.io.ByteArrayInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.util.stream.Stream;

	import org.apache.commons.io.IOUtils;
	import org.apache.commons.io.function.IOFunction;
	import org.apache.commons.io.input.ClosedInputStream;
	import org.junit.jupiter.params.ParameterizedTest;
	import org.junit.jupiter.params.provider.Arguments;
	import org.junit.jupiter.params.provider.MethodSource;

	/**
	* Tests the alternative ByteArrayOutputStream implementations.
	*/
	public class ByteArrayOutputStreamTest {

	private interface BAOSFactory<T extends AbstractByteArrayOutputStream> {
	T newInstance();

	T newInstance(final int size);
	}

	private static final class ByteArrayOutputStreamFactory implements BAOSFactory<ByteArrayOutputStream> {
	@Override
	public ByteArrayOutputStream newInstance() {
	return new ByteArrayOutputStream();
	}

	@Override
	public ByteArrayOutputStream newInstance(final int size) {
	return new ByteArrayOutputStream(size);
	}
	}

	private static final class UnsynchronizedByteArrayOutputStreamFactory implements BAOSFactory<UnsynchronizedByteArrayOutputStream> {
	@Override
	public UnsynchronizedByteArrayOutputStream newInstance() {
	return new UnsynchronizedByteArrayOutputStream();
	}

	@Override
	public UnsynchronizedByteArrayOutputStream newInstance(final int size) {
	return new UnsynchronizedByteArrayOutputStream(size);
	}
	}

	private static final byte[] DATA;

	static {
	DATA = new byte[64];
	for (byte i = 0; i < 64; i++) {
	DATA[i] = i;
	}
	}

	private static Stream<Arguments> baosFactories() {
	return Stream.of(Arguments.of(ByteArrayOutputStream.class.getSimpleName(), new ByteArrayOutputStreamFactory()),
	Arguments.of(UnsynchronizedByteArrayOutputStream.class.getSimpleName(), new UnsynchronizedByteArrayOutputStreamFactory()));
	}

	private static boolean byteCmp(final byte[] src, final byte[] cmp) {
	for (int i = 0; i < cmp.length; i++) {
	if (src[i] != cmp[i]) {
	return false;
	}
	}
	return true;
	}

	private static Stream<Arguments> toBufferedInputStreamFunctionFactories() {
	final IOFunction<InputStream, InputStream> syncBaosToBufferedInputStream = ByteArrayOutputStream::toBufferedInputStream;
	final IOFunction<InputStream, InputStream> syncBaosToBufferedInputStreamWithSize = is -> ByteArrayOutputStream.toBufferedInputStream(is, 1024);
	final IOFunction<InputStream, InputStream> unSyncBaosToBufferedInputStream = UnsynchronizedByteArrayOutputStream::toBufferedInputStream;
	final IOFunction<InputStream, InputStream> unSyncBaosToBufferedInputStreamWithSize = is -> UnsynchronizedByteArrayOutputStream.toBufferedInputStream(is,
	1024);

	return Stream.of(Arguments.of("ByteArrayOutputStream.toBufferedInputStream(InputStream)", syncBaosToBufferedInputStream),
	Arguments.of("ByteArrayOutputStream.toBufferedInputStream(InputStream, int)", syncBaosToBufferedInputStreamWithSize),
	Arguments.of("UnsynchronizedByteArrayOutputStream.toBufferedInputStream(InputStream)", unSyncBaosToBufferedInputStream),
	Arguments.of("UnsynchronizedByteArrayOutputStream.toBufferedInputStream(InputStream, int)", unSyncBaosToBufferedInputStreamWithSize));
	}

	private void checkByteArrays(final byte[] expected, final byte[] actual) {
	if (expected.length != actual.length) {
	fail("Resulting byte arrays are not equally long");
	}
	if (!byteCmp(expected, actual)) {
	fail("Resulting byte arrays are not equal");
	}
	}

	private void checkStreams(final AbstractByteArrayOutputStream actual, final java.io.ByteArrayOutputStream expected) {
	assertEquals(expected.size(), actual.size(), "Sizes are not equal");
	final byte[] buf = actual.toByteArray();
	final byte[] refbuf = expected.toByteArray();
	checkByteArrays(buf, refbuf);
	}

	@ParameterizedTest(name = "[{index}] {0}")
	@MethodSource("baosFactories")
	public void testInvalidParameterizedConstruction(final String baosName, final BAOSFactory<?> baosFactory) {
	assertThrows(IllegalArgumentException.class, () -> baosFactory.newInstance(-1));
	}

	@ParameterizedTest(name = "[{index}] {0}")
	@MethodSource("baosFactories")
	public void testInvalidWriteLenUnder(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
	try (AbstractByteArrayOutputStream baout = baosFactory.newInstance()) {
	assertThrows(IndexOutOfBoundsException.class, () -> baout.write(new byte[1], 0, -1));
	}
	}

	@ParameterizedTest(name = "[{index}] {0}")
	@MethodSource("baosFactories")
	public void testInvalidWriteOffsetAndLenOver(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
	try (AbstractByteArrayOutputStream baout = baosFactory.newInstance()) {
	assertThrows(IndexOutOfBoundsException.class, () -> baout.write(new byte[1], 0, 2));
	}
	}

	@ParameterizedTest(name = "[{index}] {0}")
	@MethodSource("baosFactories")
	public void testInvalidWriteOffsetAndLenUnder(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
	try (AbstractByteArrayOutputStream baout = baosFactory.newInstance()) {
	assertThrows(IndexOutOfBoundsException.class, () -> baout.write(new byte[1], 1, -2));
	}
	}

	@ParameterizedTest(name = "[{index}] {0}")
	@MethodSource("baosFactories")
	public void testInvalidWriteOffsetOver(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
	try (AbstractByteArrayOutputStream baout = baosFactory.newInstance()) {
	assertThrows(IndexOutOfBoundsException.class, () -> baout.write(IOUtils.EMPTY_BYTE_ARRAY, 1, 0));
	}
	}

	@ParameterizedTest(name = "[{index}] {0}")
	@MethodSource("baosFactories")
	public void testInvalidWriteOffsetUnder(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
	try (AbstractByteArrayOutputStream baout = baosFactory.newInstance()) {
	assertThrows(IndexOutOfBoundsException.class, () -> baout.write(null, -1, 0));
	}
	}

	@ParameterizedTest(name = "[{index}] {0}")
	@MethodSource("baosFactories")
	public void testStream(final String baosName, final BAOSFactory<?> baosFactory) throws Exception {
	int written;

	// The ByteArrayOutputStream is initialized with 32 bytes to match
	// the original more closely for this test.
	try (AbstractByteArrayOutputStream baout = baosFactory.newInstance(32);
	final java.io.ByteArrayOutputStream ref = new java.io.ByteArrayOutputStream()) {

	// First three writes
	written = writeData(baout, ref, new int[] {4, 10, 22});
	assertEquals(36, written);
	checkStreams(baout, ref);

	// Another two writes to see if there are any bad effects after toByteArray()
	written = writeData(baout, ref, new int[] {20, 12});
	assertEquals(32, written);
	checkStreams(baout, ref);

	// Now reset the streams
	baout.reset();
	ref.reset();

	// Test again to see if reset() had any bad effects
	written = writeData(baout, ref, new int[] {5, 47, 33, 60, 1, 0, 8});
	assertEquals(155, written);
	checkStreams(baout, ref);

	// Test the readFrom(InputStream) method
	baout.reset();
	written = baout.write(new ByteArrayInputStream(ref.toByteArray()));
	assertEquals(155, written);
	checkStreams(baout, ref);

	// Write the commons Byte[]OutputStream to a java.io.Byte[]OutputStream
	// and vice-versa to test the writeTo() method.
	try (AbstractByteArrayOutputStream baout1 = baosFactory.newInstance(32)) {
	ref.writeTo(baout1);
	final java.io.ByteArrayOutputStream ref1 = new java.io.ByteArrayOutputStream();
	baout.writeTo(ref1);
	checkStreams(baout1, ref1);

	// Testing toString(String)
	final String baoutString = baout.toString("ASCII");
	final String refString = ref.toString("ASCII");
	assertEquals(refString, baoutString, "ASCII decoded String must be equal");

	// Make sure that empty ByteArrayOutputStreams really don't create garbage
	// on toByteArray()
	try (AbstractByteArrayOutputStream baos1 = baosFactory.newInstance();
	final AbstractByteArrayOutputStream baos2 = baosFactory.newInstance()) {
	assertSame(baos1.toByteArray(), baos2.toByteArray());
	}
	}
	}
	}

	@ParameterizedTest(name = "[{index}] {0}")
	@MethodSource("toBufferedInputStreamFunctionFactories")
	public void testToBufferedInputStream(final String baosName, final IOFunction<InputStream, InputStream> toBufferedInputStreamFunction) throws IOException {
	final byte[] data = {(byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE};

	try (ByteArrayInputStream bain = new ByteArrayInputStream(data)) {
	assertEquals(data.length, bain.available());

	try (InputStream buffered = toBufferedInputStreamFunction.apply(bain)) {
	assertEquals(data.length, buffered.available());

	assertArrayEquals(data, IOUtils.toByteArray(buffered));

	}
	}
	}

	@ParameterizedTest(name = "[{index}] {0}")
	@MethodSource("toBufferedInputStreamFunctionFactories")
	public void testToBufferedInputStreamEmpty(final String baosName, final IOFunction<InputStream, InputStream> toBufferedInputStreamFunction)
	throws IOException {
	try (ByteArrayInputStream bain = new ByteArrayInputStream(IOUtils.EMPTY_BYTE_ARRAY)) {
	assertEquals(0, bain.available());

	try (InputStream buffered = toBufferedInputStreamFunction.apply(bain)) {
	assertEquals(0, buffered.available());

	}
	}
	}

	@ParameterizedTest(name = "[{index}] {0}")
	@MethodSource("baosFactories")
	public void testToInputStream(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
	try (AbstractByteArrayOutputStream baout = baosFactory.newInstance();
	final java.io.ByteArrayOutputStream ref = new java.io.ByteArrayOutputStream()) {

	// Write 8224 bytes
	writeData(baout, ref, 32);
	for (int i = 0; i < 128; i++) {
	writeData(baout, ref, 64);
	}

	// Get data before more writes
	try (InputStream in = baout.toInputStream()) {
	byte[] refData = ref.toByteArray();

	// Write some more data
	writeData(baout, ref, new int[] {2, 4, 8, 16});

	// Check original data
	byte[] baoutData = IOUtils.toByteArray(in);
	assertEquals(8224, baoutData.length);
	checkByteArrays(refData, baoutData);

	// Check all data written
	try (InputStream in2 = baout.toInputStream()) {
	baoutData = IOUtils.toByteArray(in2);
	}
	refData = ref.toByteArray();
	assertEquals(8254, baoutData.length);
	checkByteArrays(refData, baoutData);
	}
	}
	}

	@ParameterizedTest(name = "[{index}] {0}")
	@MethodSource("baosFactories")
	public void testToInputStreamEmpty(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
	try (AbstractByteArrayOutputStream baout = baosFactory.newInstance();
	// Get data before more writes
	final InputStream in = baout.toInputStream()) {
	assertEquals(0, in.available());
	assertTrue(in instanceof ClosedInputStream);
	}
	}

	@ParameterizedTest(name = "[{index}] {0}")
	@MethodSource("baosFactories")
	public void testToInputStreamWithReset(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
	// Make sure reset() do not destroy InputStream returned from toInputStream()
	try (AbstractByteArrayOutputStream baout = baosFactory.newInstance();
	final java.io.ByteArrayOutputStream ref = new java.io.ByteArrayOutputStream()) {

	// Write 8224 bytes
	writeData(baout, ref, 32);
	for (int i = 0; i < 128; i++) {
	writeData(baout, ref, 64);
	}

	// Get data before reset
	try (InputStream in = baout.toInputStream()) {
	byte[] refData = ref.toByteArray();

	// Reset and write some new data
	baout.reset();
	ref.reset();
	writeData(baout, ref, new int[] {2, 4, 8, 16});

	// Check original data
	byte[] baoutData = IOUtils.toByteArray(in);
	assertEquals(8224, baoutData.length);
	checkByteArrays(refData, baoutData);

	// Check new data written after reset
	try (InputStream in2 = baout.toInputStream()) {
	baoutData = IOUtils.toByteArray(in2);
	}
	refData = ref.toByteArray();
	assertEquals(30, baoutData.length);
	checkByteArrays(refData, baoutData);
	}
	}
	}

	@ParameterizedTest(name = "[{index}] {0}")
	@MethodSource("baosFactories")
	public void testWriteZero(final String baosName, final BAOSFactory<?> baosFactory) throws IOException {
	try (AbstractByteArrayOutputStream baout = baosFactory.newInstance()) {
	baout.write(IOUtils.EMPTY_BYTE_ARRAY, 0, 0);
	assertTrue(true, "Dummy");
	}
	}

	private int writeData(final AbstractByteArrayOutputStream baout, final java.io.ByteArrayOutputStream ref, final int count) {
	if (count > DATA.length) {
	throw new IllegalArgumentException("Requesting too many bytes");
	}
	if (count == 0) {
	baout.write(100);
	ref.write(100);
	return 1;
	}
	baout.write(DATA, 0, count);
	ref.write(DATA, 0, count);
	return count;
	}

	private int writeData(final AbstractByteArrayOutputStream baout, final java.io.ByteArrayOutputStream ref, final int[] instructions) {
	int written = 0;
	for (final int instruction : instructions) {
	written += writeData(baout, ref, instruction);
	}
	return written;
	}
	}