/*
* 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;
import org.junit.Test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.EOFException;
import java.io.IOException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
/**
* @version $Id$
*/
public class EndianUtilsTest {
@Test
public void testCtor() {
new EndianUtils();
// Constructor does not blow up.
}
@Test
public void testEOFException() throws IOException {
final ByteArrayInputStream input = new ByteArrayInputStream(new byte[] {});
try {
EndianUtils.readSwappedDouble(input);
fail("Expected EOFException");
} catch (final EOFException e) {
// expected
}
}
@Test
public void testSwapShort() {
assertEquals( (short) 0, EndianUtils.swapShort( (short) 0 ) );
assertEquals( (short) 0x0201, EndianUtils.swapShort( (short) 0x0102 ) );
assertEquals( (short) 0xffff, EndianUtils.swapShort( (short) 0xffff ) );
assertEquals( (short) 0x0102, EndianUtils.swapShort( (short) 0x0201 ) );
}
@Test
public void testSwapInteger() {
assertEquals( 0, EndianUtils.swapInteger( 0 ) );
assertEquals( 0x04030201, EndianUtils.swapInteger( 0x01020304 ) );
assertEquals( 0x01000000, EndianUtils.swapInteger( 0x00000001 ) );
assertEquals( 0x00000001, EndianUtils.swapInteger( 0x01000000 ) );
assertEquals( 0x11111111, EndianUtils.swapInteger( 0x11111111 ) );
assertEquals( 0xabcdef10, EndianUtils.swapInteger( 0x10efcdab ) );
assertEquals( 0xab, EndianUtils.swapInteger( 0xab000000 ) );
}
@Test
public void testSwapLong() {
assertEquals( 0, EndianUtils.swapLong( 0 ) );
assertEquals( 0x0807060504030201L, EndianUtils.swapLong( 0x0102030405060708L ) );
assertEquals( 0xffffffffffffffffL, EndianUtils.swapLong( 0xffffffffffffffffL ) );
assertEquals( 0xab, EndianUtils.swapLong( 0xab00000000000000L ) );
}
@Test
public void testSwapFloat() {
assertEquals( 0.0f, EndianUtils.swapFloat( 0.0f ), 0.0 );
final float f1 = Float.intBitsToFloat( 0x01020304 );
final float f2 = Float.intBitsToFloat( 0x04030201 );
assertEquals( f2, EndianUtils.swapFloat( f1 ), 0.0 );
}
@Test
public void testSwapDouble() {
assertEquals( 0.0, EndianUtils.swapDouble( 0.0 ), 0.0 );
final double d1 = Double.longBitsToDouble( 0x0102030405060708L );
final double d2 = Double.longBitsToDouble( 0x0807060504030201L );
assertEquals( d2, EndianUtils.swapDouble( d1 ), 0.0 );
}
/**
* Tests all swapXxxx methods for symmetry when going from one endian
* to another and back again.
*/
@Test
public void testSymmetry() {
assertEquals( (short) 0x0102, EndianUtils.swapShort( EndianUtils.swapShort( (short) 0x0102 ) ) );
assertEquals( 0x01020304, EndianUtils.swapInteger( EndianUtils.swapInteger( 0x01020304 ) ) );
assertEquals( 0x0102030405060708L, EndianUtils.swapLong( EndianUtils.swapLong( 0x0102030405060708L ) ) );
final float f1 = Float.intBitsToFloat( 0x01020304 );
assertEquals( f1, EndianUtils.swapFloat( EndianUtils.swapFloat( f1 ) ), 0.0 );
final double d1 = Double.longBitsToDouble( 0x0102030405060708L );
assertEquals( d1, EndianUtils.swapDouble( EndianUtils.swapDouble( d1 ) ), 0.0 );
}
@Test
public void testReadSwappedShort() throws IOException {
final byte[] bytes = new byte[] { 0x02, 0x01 };
assertEquals( 0x0102, EndianUtils.readSwappedShort( bytes, 0 ) );
final ByteArrayInputStream input = new ByteArrayInputStream(bytes);
assertEquals( 0x0102, EndianUtils.readSwappedShort( input ) );
}
@Test
public void testWriteSwappedShort() throws IOException {
byte[] bytes = new byte[2];
EndianUtils.writeSwappedShort( bytes, 0, (short) 0x0102 );
assertEquals( 0x02, bytes[0] );
assertEquals( 0x01, bytes[1] );
final ByteArrayOutputStream baos = new ByteArrayOutputStream(2);
EndianUtils.writeSwappedShort( baos, (short) 0x0102 );
bytes = baos.toByteArray();
assertEquals( 0x02, bytes[0] );
assertEquals( 0x01, bytes[1] );
}
@Test
public void testReadSwappedUnsignedShort() throws IOException {
final byte[] bytes = new byte[] { 0x02, 0x01 };
assertEquals( 0x00000102, EndianUtils.readSwappedUnsignedShort( bytes, 0 ) );
final ByteArrayInputStream input = new ByteArrayInputStream(bytes);
assertEquals( 0x00000102, EndianUtils.readSwappedUnsignedShort( input ) );
}
@Test
public void testReadSwappedInteger() throws IOException {
final byte[] bytes = new byte[] { 0x04, 0x03, 0x02, 0x01 };
assertEquals( 0x01020304, EndianUtils.readSwappedInteger( bytes, 0 ) );
final ByteArrayInputStream input = new ByteArrayInputStream(bytes);
assertEquals( 0x01020304, EndianUtils.readSwappedInteger( input ) );
}
@Test
public void testWriteSwappedInteger() throws IOException {
byte[] bytes = new byte[4];
EndianUtils.writeSwappedInteger( bytes, 0, 0x01020304 );
assertEquals( 0x04, bytes[0] );
assertEquals( 0x03, bytes[1] );
assertEquals( 0x02, bytes[2] );
assertEquals( 0x01, bytes[3] );
final ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
EndianUtils.writeSwappedInteger( baos, 0x01020304 );
bytes = baos.toByteArray();
assertEquals( 0x04, bytes[0] );
assertEquals( 0x03, bytes[1] );
assertEquals( 0x02, bytes[2] );
assertEquals( 0x01, bytes[3] );
}
@Test
public void testReadSwappedUnsignedInteger() throws IOException {
final byte[] bytes = new byte[] { 0x04, 0x03, 0x02, 0x01 };
assertEquals( 0x0000000001020304L, EndianUtils.readSwappedUnsignedInteger( bytes, 0 ) );
final ByteArrayInputStream input = new ByteArrayInputStream(bytes);
assertEquals( 0x0000000001020304L, EndianUtils.readSwappedUnsignedInteger( input ) );
}
@Test
public void testReadSwappedLong() throws IOException {
final byte[] bytes = new byte[] { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 };
assertEquals( 0x0102030405060708L, EndianUtils.readSwappedLong( bytes, 0 ) );
final ByteArrayInputStream input = new ByteArrayInputStream(bytes);
assertEquals( 0x0102030405060708L, EndianUtils.readSwappedLong( input ) );
}
@Test
public void testWriteSwappedLong() throws IOException {
byte[] bytes = new byte[8];
EndianUtils.writeSwappedLong( bytes, 0, 0x0102030405060708L );
assertEquals( 0x08, bytes[0] );
assertEquals( 0x07, bytes[1] );
assertEquals( 0x06, bytes[2] );
assertEquals( 0x05, bytes[3] );
assertEquals( 0x04, bytes[4] );
assertEquals( 0x03, bytes[5] );
assertEquals( 0x02, bytes[6] );
assertEquals( 0x01, bytes[7] );
final ByteArrayOutputStream baos = new ByteArrayOutputStream(8);
EndianUtils.writeSwappedLong( baos, 0x0102030405060708L );
bytes = baos.toByteArray();
assertEquals( 0x08, bytes[0] );
assertEquals( 0x07, bytes[1] );
assertEquals( 0x06, bytes[2] );
assertEquals( 0x05, bytes[3] );
assertEquals( 0x04, bytes[4] );
assertEquals( 0x03, bytes[5] );
assertEquals( 0x02, bytes[6] );
assertEquals( 0x01, bytes[7] );
}
@Test
public void testReadSwappedFloat() throws IOException {
final byte[] bytes = new byte[] { 0x04, 0x03, 0x02, 0x01 };
final float f1 = Float.intBitsToFloat( 0x01020304 );
final float f2 = EndianUtils.readSwappedFloat( bytes, 0 );
assertEquals( f1, f2, 0.0 );
final ByteArrayInputStream input = new ByteArrayInputStream(bytes);
assertEquals( f1, EndianUtils.readSwappedFloat( input ), 0.0 );
}
@Test
public void testWriteSwappedFloat() throws IOException {
byte[] bytes = new byte[4];
final float f1 = Float.intBitsToFloat( 0x01020304 );
EndianUtils.writeSwappedFloat( bytes, 0, f1 );
assertEquals( 0x04, bytes[0] );
assertEquals( 0x03, bytes[1] );
assertEquals( 0x02, bytes[2] );
assertEquals( 0x01, bytes[3] );
final ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
EndianUtils.writeSwappedFloat( baos, f1 );
bytes = baos.toByteArray();
assertEquals( 0x04, bytes[0] );
assertEquals( 0x03, bytes[1] );
assertEquals( 0x02, bytes[2] );
assertEquals( 0x01, bytes[3] );
}
@Test
public void testReadSwappedDouble() throws IOException {
final byte[] bytes = new byte[] { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 };
final double d1 = Double.longBitsToDouble( 0x0102030405060708L );
final double d2 = EndianUtils.readSwappedDouble( bytes, 0 );
assertEquals( d1, d2, 0.0 );
final ByteArrayInputStream input = new ByteArrayInputStream(bytes);
assertEquals( d1, EndianUtils.readSwappedDouble( input ), 0.0 );
}
@Test
public void testWriteSwappedDouble() throws IOException {
byte[] bytes = new byte[8];
final double d1 = Double.longBitsToDouble( 0x0102030405060708L );
EndianUtils.writeSwappedDouble( bytes, 0, d1 );
assertEquals( 0x08, bytes[0] );
assertEquals( 0x07, bytes[1] );
assertEquals( 0x06, bytes[2] );
assertEquals( 0x05, bytes[3] );
assertEquals( 0x04, bytes[4] );
assertEquals( 0x03, bytes[5] );
assertEquals( 0x02, bytes[6] );
assertEquals( 0x01, bytes[7] );
final ByteArrayOutputStream baos = new ByteArrayOutputStream(8);
EndianUtils.writeSwappedDouble( baos, d1 );
bytes = baos.toByteArray();
assertEquals( 0x08, bytes[0] );
assertEquals( 0x07, bytes[1] );
assertEquals( 0x06, bytes[2] );
assertEquals( 0x05, bytes[3] );
assertEquals( 0x04, bytes[4] );
assertEquals( 0x03, bytes[5] );
assertEquals( 0x02, bytes[6] );
assertEquals( 0x01, bytes[7] );
}
// tests #IO-101
@Test
public void testSymmetryOfLong() {
final double[] tests = new double[] {34.345, -345.5645, 545.12, 10.043, 7.123456789123};
for (final double test : tests) {
// testing the real problem
byte[] buffer = new byte[8];
final long ln1 = Double.doubleToLongBits( test );
EndianUtils.writeSwappedLong(buffer, 0, ln1);
final long ln2 = EndianUtils.readSwappedLong(buffer, 0);
assertEquals( ln1, ln2 );
// testing the bug report
buffer = new byte[8];
EndianUtils.writeSwappedDouble(buffer, 0, test);
final double val = EndianUtils.readSwappedDouble(buffer, 0);
assertEquals( test, val, 0 );
}
}
// tests #IO-117
@Test
public void testUnsignedOverrun() throws Exception {
final byte[] target = new byte[] { 0, 0, 0, (byte)0x80 };
final long expected = 0x80000000L;
long actual = EndianUtils.readSwappedUnsignedInteger(target, 0);
assertEquals("readSwappedUnsignedInteger(byte[], int) was incorrect", expected, actual);
final ByteArrayInputStream in = new ByteArrayInputStream(target);
actual = EndianUtils.readSwappedUnsignedInteger(in);
assertEquals("readSwappedUnsignedInteger(InputStream) was incorrect", expected, actual);
}
}