| /* |
| Derby - Class org.apache.derbyTesting.functionTests.tests.derbynet.ByteArrayCombinerStreamTest |
| |
| 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.derbyTesting.functionTests.tests.derbynet; |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import junit.framework.Test; |
| import org.apache.derby.client.am.ByteArrayCombinerStream; |
| import org.apache.derbyTesting.junit.BaseTestCase; |
| import org.apache.derbyTesting.junit.BaseTestSuite; |
| |
| /** |
| * Test functionality of <code>ByteArrayCombinerStream</code>. |
| */ |
| public class ByteArrayCombinerStreamTest |
| extends BaseTestCase { |
| |
| private static final byte[] defaultArray = { |
| 65,66,67,68,69,70,71,72,73,74,75,76, |
| 77,78,79,80,81,82,83,84,85,86,87,88}; |
| |
| private ByteArrayCombinerStream combiner; |
| |
| public ByteArrayCombinerStreamTest(String name) { |
| super(name); |
| } |
| |
| public void testCombineNullRead() |
| throws IOException { |
| combiner = new ByteArrayCombinerStream(null, 0); |
| assertEquals(-1, combiner.read()); |
| } |
| |
| public void testCombineNullReadArray() |
| throws IOException { |
| combiner = new ByteArrayCombinerStream(null, 0); |
| assertEquals(-1, combiner.read(new byte[10], 0, 10)); |
| } |
| |
| public void testCombineAvailableNull() |
| throws IOException { |
| combiner = new ByteArrayCombinerStream(null, 0); |
| assertEquals(0, combiner.available()); |
| } |
| |
| public void testCombineAvailable4bytes() |
| throws IOException { |
| byte[] array = {65,66,77,79}; |
| ArrayList<byte[]> list = new ArrayList<byte[]>(1); |
| list.add(array); |
| combiner = new ByteArrayCombinerStream(list, 4); |
| assertEquals(4, combiner.available()); |
| } |
| |
| /** |
| * Make sure an extra "empty" array doesn't cause errors. |
| * This test is based on knowledge of the implementation, where an extra |
| * byte array was not removed during the reducation process. This can |
| * cause <code>nextArray</code> to not return <code>null</code> when it |
| * should, causing an <code>ArrayIndexOutOfBoundsException</code>. |
| * This bug was corrected by DERBY-1417. |
| */ |
| public void testCombineWithExtraEmptyByteArray() |
| throws IOException { |
| byte[] array = {65,66,77,79}; |
| ArrayList<byte[]> list = new ArrayList<byte[]>(2); |
| list.add(array); |
| list.add(new byte[4]); |
| combiner = new ByteArrayCombinerStream(list, array.length); |
| byte[] resArray = new byte[array.length]; |
| assertEquals(array.length, |
| combiner.read(resArray, 0, resArray.length)); |
| assertTrue(combiner.read() == -1); |
| } |
| |
| public void testCombineOneArray() |
| throws IOException { |
| ArrayList<byte[]> list = new ArrayList<byte[]>(1); |
| list.add(defaultArray); |
| combiner = new ByteArrayCombinerStream(list, defaultArray.length); |
| byte[] resArray = new byte[defaultArray.length]; |
| assertEquals(defaultArray.length, |
| combiner.read(resArray,0, resArray.length)); |
| assertTrue(combiner.read() == -1); |
| assertTrue(Arrays.equals(defaultArray, resArray)); |
| } |
| |
| public void testCominbe100SmallArrays() |
| throws IOException { |
| int arrays = 100; |
| byte[] array = {65,66,77,79}; |
| ArrayList<byte[]> list = new ArrayList<byte[]>(arrays); |
| long length = 0; |
| for (int i=0; i < arrays; i++) { |
| list.add(array); |
| length += array.length; |
| } |
| byte[] targetArray = new byte[(int)length]; |
| int offset = 0; |
| for (int i=0; i < arrays; i++) { |
| System.arraycopy(array, 0, targetArray, offset, array.length); |
| offset += array.length; |
| } |
| combiner = new ByteArrayCombinerStream(list, length); |
| byte[] resArray = new byte[(int)length]; |
| assertEquals(length, combiner.read(resArray, 0, resArray.length)); |
| assertTrue(combiner.read() == -1); |
| assertTrue(combiner.read() == -1); |
| assertTrue(Arrays.equals(targetArray, resArray)); |
| } |
| |
| public void testTruncateDataFromOneArray() |
| throws IOException { |
| int length = defaultArray.length -5; |
| ArrayList<byte[]> list = new ArrayList<byte[]>(1); |
| list.add(defaultArray); |
| byte[] targetArray = new byte[length]; |
| System.arraycopy(defaultArray, 0, |
| targetArray, 0, length); |
| byte[] resArray = new byte[length]; |
| combiner = new ByteArrayCombinerStream(list, length); |
| assertEquals(length, combiner.read(resArray, 0, length)); |
| assertTrue(combiner.read() == -1); |
| assertTrue(Arrays.equals(targetArray, resArray)); |
| } |
| |
| public void testTruncateDataFromTwoArrays() |
| throws IOException { |
| int length = (defaultArray.length *2) -7; |
| ArrayList<byte[]> list = new ArrayList<byte[]>(2); |
| list.add(defaultArray); |
| list.add(defaultArray); |
| byte[] targetArray = new byte[length]; |
| System.arraycopy(defaultArray, 0, |
| targetArray, 0, defaultArray.length); |
| System.arraycopy(defaultArray, 0, |
| targetArray, defaultArray.length, |
| length - defaultArray.length); |
| byte[] resArray = new byte[length]; |
| combiner = new ByteArrayCombinerStream(list, length); |
| assertEquals(length, combiner.read(resArray, 0, length)); |
| assertTrue(combiner.read() == -1); |
| assertTrue(Arrays.equals(targetArray, resArray)); |
| } |
| |
| /** |
| * Make sure an exception is thrown if there is less data available than |
| * the specified length. |
| */ |
| public void testTooLittleDataNoCombine() { |
| ArrayList<byte[]> list = new ArrayList<byte[]>(1); |
| list.add(new byte[5]); |
| try { |
| combiner = new ByteArrayCombinerStream(list, 10); |
| fail("An IllegalArgumentException singalling too little data " + |
| "should have been thrown"); |
| } catch (IllegalArgumentException iae) { |
| // This should happen, continue. |
| } |
| } |
| |
| /** |
| * Make sure an exception is thrown if there is less data available than |
| * the specified length. |
| */ |
| public void testTooLittleDataWithCombine() { |
| ArrayList<byte[]> list = new ArrayList<byte[]>(3); |
| byte[] data = {65,66,67,68,69}; |
| list.add(data); |
| list.add(data); |
| list.add(data); |
| try { |
| combiner = new ByteArrayCombinerStream(list, data.length *3 + 1); |
| fail("An IllegalArgumentException singalling too little data " + |
| "should have been thrown"); |
| } catch (IllegalArgumentException iae) { |
| // This should happen, continue. |
| } |
| } |
| |
| /** |
| * Make sure an exception is thrown if a negative length is specified. |
| */ |
| public void testNegativeLengthArgument() { |
| ArrayList<byte[]> list = new ArrayList<byte[]>(1); |
| list.add(new byte[1234]); |
| try { |
| combiner = new ByteArrayCombinerStream(list, -54); |
| fail("An IllegalArgumentException singalling negative length " + |
| "should have been thrown"); |
| } catch (IllegalArgumentException iae) { |
| // This should happen, continue. |
| |
| } |
| } |
| |
| /** |
| * Demonstrate that the stream does not change negative values in the |
| * underlying data. |
| * This can cause code to believe the stream is exhausted even though it is |
| * not. |
| */ |
| public void testNegativeValueInDataCausesEndOfStream() |
| throws IOException { |
| byte[] data = {66,67,-123,68,69}; |
| byte[] targetData = {66,67,0,0,0}; |
| byte[] resData = new byte[5]; |
| ArrayList<byte[]> list = new ArrayList<byte[]>(1); |
| list.add(data); |
| combiner = new ByteArrayCombinerStream(list, data.length); |
| byte b; |
| int index = 0; |
| while ((b = (byte)combiner.read()) > 0) { |
| resData[index++] = b; |
| } |
| assertTrue(Arrays.equals(targetData, resData)); |
| // Even though we think the stream is exhausted, it is not... |
| assertEquals(data[3], (byte)combiner.read()); |
| assertEquals(data[4], (byte)combiner.read()); |
| assertEquals(-1, (byte)combiner.read()); |
| } |
| |
| public static Test suite() { |
| return new BaseTestSuite(ByteArrayCombinerStreamTest.class, |
| "ByteArrayCombinerStreamTest"); |
| } |
| } // End class ByteArrayCombinerStreamTest |