1002 lines
39 KiB
Java
1002 lines
39 KiB
Java
/* Copyright (c) 2008-2018, Nathan Sweet
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
|
|
* conditions are met:
|
|
*
|
|
* - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
|
|
* - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided with the distribution.
|
|
* - Neither the name of Esoteric Software nor the names of its contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
|
|
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
|
* SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
|
|
|
|
package dorkboxTest.network.kryo;
|
|
|
|
import static org.junit.Assert.assertArrayEquals;
|
|
import static org.junit.Assert.assertEquals;
|
|
import static org.junit.Assert.assertFalse;
|
|
import static org.junit.Assert.assertNotNull;
|
|
import static org.junit.Assert.assertNull;
|
|
import static org.junit.Assert.assertTrue;
|
|
|
|
import java.io.IOException;
|
|
import java.util.Random;
|
|
|
|
import org.junit.Test;
|
|
|
|
import com.esotericsoftware.kryo.Kryo;
|
|
import com.esotericsoftware.kryo.Registration;
|
|
import com.esotericsoftware.kryo.io.Input;
|
|
import com.esotericsoftware.kryo.io.Output;
|
|
|
|
import dorkbox.network.serialization.AeronInput;
|
|
import dorkbox.network.serialization.AeronOutput;
|
|
|
|
/** @author Nathan Sweet */
|
|
@SuppressWarnings("all")
|
|
public class InputOutputByteBufTest extends KryoTestCase {
|
|
@Test
|
|
public void testByteBufferInputEnd () {
|
|
AeronInput in = new AeronInput(new byte[] {123, 0, 0, 0});
|
|
assertFalse(in.end());
|
|
in.setPosition(4);
|
|
assertTrue(in.end());
|
|
}
|
|
|
|
@Test
|
|
public void testOutputBytes () throws IOException {
|
|
AeronOutput output = new AeronOutput(0);
|
|
output.writeBytes(new byte[] {11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26});
|
|
output.writeBytes(new byte[] {31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46});
|
|
output.writeBytes(new byte[] {51, 52, 53, 54, 55, 56, 57, 58});
|
|
output.writeBytes(new byte[] {61, 62, 63, 64, 65});
|
|
output.flush();
|
|
|
|
assertArrayEquals(new byte[] { //
|
|
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, //
|
|
31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, //
|
|
51, 52, 53, 54, 55, 56, 57, 58, //
|
|
61, 62, 63, 64, 65}, output.toBytes());
|
|
}
|
|
|
|
@Test
|
|
public void testOutputBytesArray () throws IOException {
|
|
byte[] buffer = { //
|
|
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, //
|
|
31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, //
|
|
51, 52, 53, 54, 55, 56, 57, 58, //
|
|
61, 62, 63, 64, 65};
|
|
AeronOutput output = new AeronOutput(buffer);
|
|
output.setPosition(buffer.length);
|
|
|
|
assertArrayEquals(new byte[] { //
|
|
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, //
|
|
31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, //
|
|
51, 52, 53, 54, 55, 56, 57, 58, //
|
|
61, 62, 63, 64, 65}, output.toBytes());
|
|
}
|
|
|
|
@Test
|
|
public void testInputBytes () throws IOException {
|
|
byte[] bytes = new byte[] { //
|
|
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, //
|
|
31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, //
|
|
51, 52, 53, 54, 55, 56, 57, 58, //
|
|
61, 62, 63, 64, 65};
|
|
|
|
AeronInput input = new AeronInput(bytes);
|
|
byte[] temp = new byte[1024];
|
|
int count = input.read(temp, 512, bytes.length);
|
|
assertEquals(bytes.length, count);
|
|
byte[] temp2 = new byte[count];
|
|
System.arraycopy(temp, 512, temp2, 0, count);
|
|
assertArrayEquals(bytes, temp2);
|
|
|
|
input = new AeronInput(bytes);
|
|
count = input.read(temp, 512, 512);
|
|
assertEquals(bytes.length, count);
|
|
temp2 = new byte[count];
|
|
System.arraycopy(temp, 512, temp2, 0, count);
|
|
assertArrayEquals(bytes, temp2);
|
|
}
|
|
|
|
@Test
|
|
public void testWriteBytes () throws IOException {
|
|
AeronOutput buffer = new AeronOutput(512);
|
|
buffer.writeBytes(new byte[] {11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26});
|
|
buffer.writeBytes(new byte[] {31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46});
|
|
buffer.writeByte(51);
|
|
buffer.writeBytes(new byte[] {52, 53, 54, 55, 56, 57, 58});
|
|
buffer.writeByte(61);
|
|
buffer.writeByte(62);
|
|
buffer.writeByte(63);
|
|
buffer.writeByte(64);
|
|
buffer.writeByte(65);
|
|
buffer.flush();
|
|
|
|
assertArrayEquals(new byte[] { //
|
|
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, //
|
|
31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, //
|
|
51, 52, 53, 54, 55, 56, 57, 58, //
|
|
61, 62, 63, 64, 65}, buffer.toBytes());
|
|
}
|
|
|
|
@Test
|
|
public void testStrings () throws IOException {
|
|
runStringTest(new AeronOutput(4096));
|
|
runStringTest(new AeronOutput(897));
|
|
|
|
Output write = new AeronOutput(21);
|
|
String value = "abcdef\u00E1\u00E9\u00ED\u00F3\u00FA\u1234";
|
|
write.writeString(value);
|
|
|
|
Input read = new AeronInput(write.toBytes());
|
|
assertEquals(value, read.readString());
|
|
|
|
write.reset();
|
|
write.writeString(null);
|
|
read = new Input(write.toBytes());
|
|
assertNull(read.readString());
|
|
|
|
for (int i = 0; i <= 258; i++)
|
|
runStringTest(i);
|
|
runStringTest(1);
|
|
runStringTest(2);
|
|
runStringTest(127);
|
|
runStringTest(256);
|
|
runStringTest(1024 * 1023);
|
|
runStringTest(1024 * 1024);
|
|
runStringTest(1024 * 1025);
|
|
runStringTest(1024 * 1026);
|
|
runStringTest(1024 * 1024 * 2);
|
|
}
|
|
|
|
@Test
|
|
public void testGrowingBufferForAscii () {
|
|
// Initial size of 2.
|
|
final AeronOutput output = new AeronOutput(2);
|
|
// Check that it is possible to write an ASCII string into the output buffer.
|
|
output.writeString("node/read");
|
|
Input input = new AeronInput(output.toBytes(), 0, output.position());
|
|
assertEquals("node/read", input.readString());
|
|
}
|
|
|
|
private void runStringTest (int length) throws IOException {
|
|
Output write = new Output(1024, -1);
|
|
StringBuilder buffer = new StringBuilder();
|
|
for (int i = 0; i < length; i++)
|
|
buffer.append((char)i);
|
|
|
|
String value = buffer.toString();
|
|
write.writeString(value);
|
|
write.writeString(value);
|
|
|
|
AeronInput read = new AeronInput(write.toBytes());
|
|
assertEquals(value, read.readString());
|
|
assertEquals(value, read.readStringBuilder().toString());
|
|
|
|
write.reset();
|
|
write.writeString(buffer.toString());
|
|
write.writeString(buffer.toString());
|
|
read = new AeronInput(write.toBytes());
|
|
assertEquals(value, read.readStringBuilder().toString());
|
|
assertEquals(value, read.readString());
|
|
|
|
if (length <= 127) {
|
|
write.reset();
|
|
write.writeAscii(value);
|
|
write.writeAscii(value);
|
|
read = new AeronInput(write.toBytes());
|
|
assertEquals(value, read.readStringBuilder().toString());
|
|
assertEquals(value, read.readString());
|
|
}
|
|
}
|
|
|
|
private void runStringTest (AeronOutput write) throws IOException {
|
|
String value1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ\rabcdefghijklmnopqrstuvwxyz\n1234567890\t\"!`?'.,;:()[]{}<>|/@\\^$-%+=#_&~*";
|
|
String value2 = "abcdef\u00E1\u00E9\u00ED\u00F3\u00FA\u1234";
|
|
|
|
write.writeString("");
|
|
write.writeString("1");
|
|
write.writeString("22");
|
|
write.writeString("uno");
|
|
write.writeString("dos");
|
|
write.writeString("tres");
|
|
write.writeString(null);
|
|
write.writeString(value1);
|
|
write.writeString(value2);
|
|
for (int i = 0; i < 127; i++)
|
|
write.writeString(String.valueOf((char)i));
|
|
for (int i = 0; i < 127; i++)
|
|
write.writeString(String.valueOf((char)i) + "abc");
|
|
|
|
AeronInput read = new AeronInput(write.toBytes());
|
|
assertEquals("", read.readString());
|
|
assertEquals("1", read.readString());
|
|
assertEquals("22", read.readString());
|
|
assertEquals("uno", read.readString());
|
|
assertEquals("dos", read.readString());
|
|
assertEquals("tres", read.readString());
|
|
assertNull(read.readString());
|
|
assertEquals(value1, read.readString());
|
|
assertEquals(value2, read.readString());
|
|
for (int i = 0; i < 127; i++)
|
|
assertEquals(String.valueOf((char)i), read.readString());
|
|
for (int i = 0; i < 127; i++)
|
|
assertEquals(String.valueOf((char)i) + "abc", read.readString());
|
|
|
|
read.reset();
|
|
assertEquals("", read.readStringBuilder().toString());
|
|
assertEquals("1", read.readStringBuilder().toString());
|
|
assertEquals("22", read.readStringBuilder().toString());
|
|
assertEquals("uno", read.readStringBuilder().toString());
|
|
assertEquals("dos", read.readStringBuilder().toString());
|
|
assertEquals("tres", read.readStringBuilder().toString());
|
|
assertNull(read.readStringBuilder());
|
|
assertEquals(value1, read.readStringBuilder().toString());
|
|
assertEquals(value2, read.readStringBuilder().toString());
|
|
for (int i = 0; i < 127; i++)
|
|
assertEquals(String.valueOf((char)i), read.readStringBuilder().toString());
|
|
for (int i = 0; i < 127; i++)
|
|
assertEquals(String.valueOf((char)i) + "abc", read.readStringBuilder().toString());
|
|
}
|
|
|
|
@Test
|
|
public void testCanReadInt () throws IOException {
|
|
AeronOutput write = new AeronOutput();
|
|
|
|
AeronInput read = new AeronInput(write.toBytes());
|
|
assertFalse(read.canReadVarInt());
|
|
|
|
write.writeVarInt(400, true);
|
|
|
|
read = new AeronInput(write.toBytes());
|
|
assertTrue(read.canReadVarInt());
|
|
read.setLimit(read.limit() - 1);
|
|
assertFalse(read.canReadVarInt());
|
|
}
|
|
|
|
@Test
|
|
public void testVarIntFlagOutput () throws IOException {
|
|
AeronOutput output = new AeronOutput(4096);
|
|
AeronInput input = new AeronInput(output.getInternalBuffer());
|
|
runVarIntFlagsTest(output, input);
|
|
}
|
|
|
|
@Test
|
|
public void testVarIntFlagByteBufferOutput () throws IOException {
|
|
AeronOutput output = new AeronOutput(4096);
|
|
AeronInput input = new AeronInput(output.getInternalBuffer());
|
|
runVarIntFlagsTest(output, input);
|
|
}
|
|
|
|
private void runVarIntFlagsTest (Output output, Input input) throws IOException {
|
|
assertEquals(1, output.writeVarIntFlag(true, 63, true));
|
|
assertEquals(2, output.writeVarIntFlag(true, 64, true));
|
|
|
|
assertEquals(1, output.writeVarIntFlag(false, 63, true));
|
|
assertEquals(2, output.writeVarIntFlag(false, 64, true));
|
|
|
|
assertEquals(1, output.writeVarIntFlag(true, 31, false));
|
|
assertEquals(2, output.writeVarIntFlag(true, 32, false));
|
|
|
|
assertEquals(1, output.writeVarIntFlag(false, 31, false));
|
|
assertEquals(2, output.writeVarIntFlag(false, 32, false));
|
|
|
|
input.setPosition(0);
|
|
input.setLimit(output.position());
|
|
assertTrue(input.readVarIntFlag());
|
|
assertEquals(63, input.readVarIntFlag(true));
|
|
assertTrue(input.readVarIntFlag());
|
|
assertEquals(64, input.readVarIntFlag(true));
|
|
|
|
assertFalse(input.readVarIntFlag());
|
|
assertEquals(63, input.readVarIntFlag(true));
|
|
assertFalse(input.readVarIntFlag());
|
|
assertEquals(64, input.readVarIntFlag(true));
|
|
|
|
assertTrue(input.readVarIntFlag());
|
|
assertEquals(31, input.readVarIntFlag(false));
|
|
assertTrue(input.readVarIntFlag());
|
|
assertEquals(32, input.readVarIntFlag(false));
|
|
|
|
assertFalse(input.readVarIntFlag());
|
|
assertEquals(31, input.readVarIntFlag(false));
|
|
assertFalse(input.readVarIntFlag());
|
|
assertEquals(32, input.readVarIntFlag(false));
|
|
}
|
|
|
|
@Test
|
|
public void testInts () throws IOException {
|
|
runIntTest(new AeronOutput(4096));
|
|
runIntTest(new AeronOutput());
|
|
}
|
|
|
|
private void runIntTest (Output write) throws IOException {
|
|
write.writeInt(0);
|
|
write.writeInt(63);
|
|
write.writeInt(64);
|
|
write.writeInt(127);
|
|
write.writeInt(128);
|
|
write.writeInt(8192);
|
|
write.writeInt(16384);
|
|
write.writeInt(2097151);
|
|
write.writeInt(1048575);
|
|
write.writeInt(134217727);
|
|
write.writeInt(268435455);
|
|
write.writeInt(134217728);
|
|
write.writeInt(268435456);
|
|
write.writeInt(-2097151);
|
|
write.writeInt(-1048575);
|
|
write.writeInt(-134217727);
|
|
write.writeInt(-268435455);
|
|
write.writeInt(-134217728);
|
|
write.writeInt(-268435456);
|
|
assertEquals(1, write.writeVarInt(0, true));
|
|
assertEquals(1, write.writeVarInt(0, false));
|
|
assertEquals(1, write.writeVarInt(63, true));
|
|
assertEquals(1, write.writeVarInt(63, false));
|
|
assertEquals(1, write.writeVarInt(64, true));
|
|
assertEquals(2, write.writeVarInt(64, false));
|
|
assertEquals(1, write.writeVarInt(127, true));
|
|
assertEquals(2, write.writeVarInt(127, false));
|
|
assertEquals(2, write.writeVarInt(128, true));
|
|
assertEquals(2, write.writeVarInt(128, false));
|
|
assertEquals(2, write.writeVarInt(8191, true));
|
|
assertEquals(2, write.writeVarInt(8191, false));
|
|
assertEquals(2, write.writeVarInt(8192, true));
|
|
assertEquals(3, write.writeVarInt(8192, false));
|
|
assertEquals(2, write.writeVarInt(16383, true));
|
|
assertEquals(3, write.writeVarInt(16383, false));
|
|
assertEquals(3, write.writeVarInt(16384, true));
|
|
assertEquals(3, write.writeVarInt(16384, false));
|
|
assertEquals(3, write.writeVarInt(2097151, true));
|
|
assertEquals(4, write.writeVarInt(2097151, false));
|
|
assertEquals(3, write.writeVarInt(1048575, true));
|
|
assertEquals(3, write.writeVarInt(1048575, false));
|
|
assertEquals(4, write.writeVarInt(134217727, true));
|
|
assertEquals(4, write.writeVarInt(134217727, false));
|
|
assertEquals(4, write.writeVarInt(268435455, true));
|
|
assertEquals(5, write.writeVarInt(268435455, false));
|
|
assertEquals(4, write.writeVarInt(134217728, true));
|
|
assertEquals(5, write.writeVarInt(134217728, false));
|
|
assertEquals(5, write.writeVarInt(268435456, true));
|
|
assertEquals(5, write.writeVarInt(268435456, false));
|
|
assertEquals(1, write.writeVarInt(-64, false));
|
|
assertEquals(5, write.writeVarInt(-64, true));
|
|
assertEquals(2, write.writeVarInt(-65, false));
|
|
assertEquals(5, write.writeVarInt(-65, true));
|
|
assertEquals(2, write.writeVarInt(-8192, false));
|
|
assertEquals(5, write.writeVarInt(-8192, true));
|
|
assertEquals(3, write.writeVarInt(-1048576, false));
|
|
assertEquals(5, write.writeVarInt(-1048576, true));
|
|
assertEquals(4, write.writeVarInt(-134217728, false));
|
|
assertEquals(5, write.writeVarInt(-134217728, true));
|
|
assertEquals(5, write.writeVarInt(-134217729, false));
|
|
assertEquals(5, write.writeVarInt(-134217729, true));
|
|
assertEquals(5, write.writeVarInt(1000000000, false));
|
|
assertEquals(5, write.writeVarInt(1000000000, true));
|
|
assertEquals(5, write.writeVarInt(Integer.MAX_VALUE - 1, false));
|
|
assertEquals(5, write.writeVarInt(Integer.MAX_VALUE - 1, true));
|
|
assertEquals(5, write.writeVarInt(Integer.MAX_VALUE, false));
|
|
assertEquals(5, write.writeVarInt(Integer.MAX_VALUE, true));
|
|
|
|
AeronInput read = new AeronInput(write.toBytes());
|
|
assertEquals(0, read.readInt());
|
|
assertEquals(63, read.readInt());
|
|
assertEquals(64, read.readInt());
|
|
assertEquals(127, read.readInt());
|
|
assertEquals(128, read.readInt());
|
|
assertEquals(8192, read.readInt());
|
|
assertEquals(16384, read.readInt());
|
|
assertEquals(2097151, read.readInt());
|
|
assertEquals(1048575, read.readInt());
|
|
assertEquals(134217727, read.readInt());
|
|
assertEquals(268435455, read.readInt());
|
|
assertEquals(134217728, read.readInt());
|
|
assertEquals(268435456, read.readInt());
|
|
assertEquals(-2097151, read.readInt());
|
|
assertEquals(-1048575, read.readInt());
|
|
assertEquals(-134217727, read.readInt());
|
|
assertEquals(-268435455, read.readInt());
|
|
assertEquals(-134217728, read.readInt());
|
|
assertEquals(-268435456, read.readInt());
|
|
assertTrue(read.canReadVarInt());
|
|
assertTrue(read.canReadVarInt());
|
|
assertTrue(read.canReadVarInt());
|
|
assertEquals(0, read.readVarInt(true));
|
|
assertEquals(0, read.readVarInt(false));
|
|
assertEquals(63, read.readVarInt(true));
|
|
assertEquals(63, read.readVarInt(false));
|
|
assertEquals(64, read.readVarInt(true));
|
|
assertEquals(64, read.readVarInt(false));
|
|
assertEquals(127, read.readVarInt(true));
|
|
assertEquals(127, read.readVarInt(false));
|
|
assertEquals(128, read.readVarInt(true));
|
|
assertEquals(128, read.readVarInt(false));
|
|
assertEquals(8191, read.readVarInt(true));
|
|
assertEquals(8191, read.readVarInt(false));
|
|
assertEquals(8192, read.readVarInt(true));
|
|
assertEquals(8192, read.readVarInt(false));
|
|
assertEquals(16383, read.readVarInt(true));
|
|
assertEquals(16383, read.readVarInt(false));
|
|
assertEquals(16384, read.readVarInt(true));
|
|
assertEquals(16384, read.readVarInt(false));
|
|
assertEquals(2097151, read.readVarInt(true));
|
|
assertEquals(2097151, read.readVarInt(false));
|
|
assertEquals(1048575, read.readVarInt(true));
|
|
assertEquals(1048575, read.readVarInt(false));
|
|
assertEquals(134217727, read.readVarInt(true));
|
|
assertEquals(134217727, read.readVarInt(false));
|
|
assertEquals(268435455, read.readVarInt(true));
|
|
assertEquals(268435455, read.readVarInt(false));
|
|
assertEquals(134217728, read.readVarInt(true));
|
|
assertEquals(134217728, read.readVarInt(false));
|
|
assertEquals(268435456, read.readVarInt(true));
|
|
assertEquals(268435456, read.readVarInt(false));
|
|
assertEquals(-64, read.readVarInt(false));
|
|
assertEquals(-64, read.readVarInt(true));
|
|
assertEquals(-65, read.readVarInt(false));
|
|
assertEquals(-65, read.readVarInt(true));
|
|
assertEquals(-8192, read.readVarInt(false));
|
|
assertEquals(-8192, read.readVarInt(true));
|
|
assertEquals(-1048576, read.readVarInt(false));
|
|
assertEquals(-1048576, read.readVarInt(true));
|
|
assertEquals(-134217728, read.readVarInt(false));
|
|
assertEquals(-134217728, read.readVarInt(true));
|
|
assertEquals(-134217729, read.readVarInt(false));
|
|
assertEquals(-134217729, read.readVarInt(true));
|
|
assertEquals(1000000000, read.readVarInt(false));
|
|
assertEquals(1000000000, read.readVarInt(true));
|
|
assertEquals(Integer.MAX_VALUE - 1, read.readVarInt(false));
|
|
assertEquals(Integer.MAX_VALUE - 1, read.readVarInt(true));
|
|
assertEquals(Integer.MAX_VALUE, read.readVarInt(false));
|
|
assertEquals(Integer.MAX_VALUE, read.readVarInt(true));
|
|
assertFalse(read.canReadVarInt());
|
|
|
|
Random random = new Random();
|
|
for (int i = 0; i < 10000; i++) {
|
|
int value = random.nextInt();
|
|
write.reset();
|
|
write.writeInt(value);
|
|
write.writeVarInt(value, true);
|
|
write.writeVarInt(value, false);
|
|
|
|
read.setBuffer(write.toBytes());
|
|
assertEquals(value, read.readInt());
|
|
assertEquals(value, read.readVarInt(true));
|
|
assertEquals(value, read.readVarInt(false));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testLongs () throws IOException {
|
|
runLongTest(new AeronOutput(4096));
|
|
runLongTest(new AeronOutput());
|
|
}
|
|
|
|
private void runLongTest (Output write) throws IOException {
|
|
write.writeLong(0);
|
|
write.writeLong(63);
|
|
write.writeLong(64);
|
|
write.writeLong(127);
|
|
write.writeLong(128);
|
|
write.writeLong(8192);
|
|
write.writeLong(16384);
|
|
write.writeLong(2097151);
|
|
write.writeLong(1048575);
|
|
write.writeLong(134217727);
|
|
write.writeLong(268435455);
|
|
write.writeLong(134217728);
|
|
write.writeLong(268435456);
|
|
write.writeLong(-2097151);
|
|
write.writeLong(-1048575);
|
|
write.writeLong(-134217727);
|
|
write.writeLong(-268435455);
|
|
write.writeLong(-134217728);
|
|
write.writeLong(-268435456);
|
|
assertEquals(1, write.writeVarLong(0, true));
|
|
assertEquals(1, write.writeVarLong(0, false));
|
|
assertEquals(1, write.writeVarLong(63, true));
|
|
assertEquals(1, write.writeVarLong(63, false));
|
|
assertEquals(1, write.writeVarLong(64, true));
|
|
assertEquals(2, write.writeVarLong(64, false));
|
|
assertEquals(1, write.writeVarLong(127, true));
|
|
assertEquals(2, write.writeVarLong(127, false));
|
|
assertEquals(2, write.writeVarLong(128, true));
|
|
assertEquals(2, write.writeVarLong(128, false));
|
|
assertEquals(2, write.writeVarLong(8191, true));
|
|
assertEquals(2, write.writeVarLong(8191, false));
|
|
assertEquals(2, write.writeVarLong(8192, true));
|
|
assertEquals(3, write.writeVarLong(8192, false));
|
|
assertEquals(2, write.writeVarLong(16383, true));
|
|
assertEquals(3, write.writeVarLong(16383, false));
|
|
assertEquals(3, write.writeVarLong(16384, true));
|
|
assertEquals(3, write.writeVarLong(16384, false));
|
|
assertEquals(3, write.writeVarLong(2097151, true));
|
|
assertEquals(4, write.writeVarLong(2097151, false));
|
|
assertEquals(3, write.writeVarLong(1048575, true));
|
|
assertEquals(3, write.writeVarLong(1048575, false));
|
|
assertEquals(4, write.writeVarLong(134217727, true));
|
|
assertEquals(4, write.writeVarLong(134217727, false));
|
|
assertEquals(4, write.writeVarLong(268435455L, true));
|
|
assertEquals(5, write.writeVarLong(268435455L, false));
|
|
assertEquals(4, write.writeVarLong(134217728L, true));
|
|
assertEquals(5, write.writeVarLong(134217728L, false));
|
|
assertEquals(5, write.writeVarLong(268435456L, true));
|
|
assertEquals(5, write.writeVarLong(268435456L, false));
|
|
assertEquals(1, write.writeVarLong(-64, false));
|
|
assertEquals(9, write.writeVarLong(-64, true));
|
|
assertEquals(2, write.writeVarLong(-65, false));
|
|
assertEquals(9, write.writeVarLong(-65, true));
|
|
assertEquals(2, write.writeVarLong(-8192, false));
|
|
assertEquals(9, write.writeVarLong(-8192, true));
|
|
assertEquals(3, write.writeVarLong(-1048576, false));
|
|
assertEquals(9, write.writeVarLong(-1048576, true));
|
|
assertEquals(4, write.writeVarLong(-134217728, false));
|
|
assertEquals(9, write.writeVarLong(-134217728, true));
|
|
assertEquals(5, write.writeVarLong(-134217729, false));
|
|
assertEquals(9, write.writeVarLong(-134217729, true));
|
|
|
|
AeronInput read = new AeronInput(write.toBytes());
|
|
assertEquals(0, read.readLong());
|
|
assertEquals(63, read.readLong());
|
|
assertEquals(64, read.readLong());
|
|
assertEquals(127, read.readLong());
|
|
assertEquals(128, read.readLong());
|
|
assertEquals(8192, read.readLong());
|
|
assertEquals(16384, read.readLong());
|
|
assertEquals(2097151, read.readLong());
|
|
assertEquals(1048575, read.readLong());
|
|
assertEquals(134217727, read.readLong());
|
|
assertEquals(268435455, read.readLong());
|
|
assertEquals(134217728, read.readLong());
|
|
assertEquals(268435456, read.readLong());
|
|
assertEquals(-2097151, read.readLong());
|
|
assertEquals(-1048575, read.readLong());
|
|
assertEquals(-134217727, read.readLong());
|
|
assertEquals(-268435455, read.readLong());
|
|
assertEquals(-134217728, read.readLong());
|
|
assertEquals(-268435456, read.readLong());
|
|
assertEquals(0, read.readVarLong(true));
|
|
assertEquals(0, read.readVarLong(false));
|
|
assertEquals(63, read.readVarLong(true));
|
|
assertEquals(63, read.readVarLong(false));
|
|
assertEquals(64, read.readVarLong(true));
|
|
assertEquals(64, read.readVarLong(false));
|
|
assertEquals(127, read.readVarLong(true));
|
|
assertEquals(127, read.readVarLong(false));
|
|
assertEquals(128, read.readVarLong(true));
|
|
assertEquals(128, read.readVarLong(false));
|
|
assertEquals(8191, read.readVarLong(true));
|
|
assertEquals(8191, read.readVarLong(false));
|
|
assertEquals(8192, read.readVarLong(true));
|
|
assertEquals(8192, read.readVarLong(false));
|
|
assertEquals(16383, read.readVarLong(true));
|
|
assertEquals(16383, read.readVarLong(false));
|
|
assertEquals(16384, read.readVarLong(true));
|
|
assertEquals(16384, read.readVarLong(false));
|
|
assertEquals(2097151, read.readVarLong(true));
|
|
assertEquals(2097151, read.readVarLong(false));
|
|
assertEquals(1048575, read.readVarLong(true));
|
|
assertEquals(1048575, read.readVarLong(false));
|
|
assertEquals(134217727, read.readVarLong(true));
|
|
assertEquals(134217727, read.readVarLong(false));
|
|
assertEquals(268435455, read.readVarLong(true));
|
|
assertEquals(268435455, read.readVarLong(false));
|
|
assertEquals(134217728, read.readVarLong(true));
|
|
assertEquals(134217728, read.readVarLong(false));
|
|
assertEquals(268435456, read.readVarLong(true));
|
|
assertEquals(268435456, read.readVarLong(false));
|
|
assertEquals(-64, read.readVarLong(false));
|
|
assertEquals(-64, read.readVarLong(true));
|
|
assertEquals(-65, read.readVarLong(false));
|
|
assertEquals(-65, read.readVarLong(true));
|
|
assertEquals(-8192, read.readVarLong(false));
|
|
assertEquals(-8192, read.readVarLong(true));
|
|
assertEquals(-1048576, read.readVarLong(false));
|
|
assertEquals(-1048576, read.readVarLong(true));
|
|
assertEquals(-134217728, read.readVarLong(false));
|
|
assertEquals(-134217728, read.readVarLong(true));
|
|
assertEquals(-134217729, read.readVarLong(false));
|
|
assertEquals(-134217729, read.readVarLong(true));
|
|
|
|
Random random = new Random();
|
|
for (int i = 0; i < 10000; i++) {
|
|
long value = random.nextLong();
|
|
write.reset();
|
|
write.writeLong(value);
|
|
write.writeVarLong(value, true);
|
|
write.writeVarLong(value, false);
|
|
|
|
read.setBuffer(write.toBytes());
|
|
assertEquals(value, read.readLong());
|
|
assertEquals(value, read.readVarLong(true));
|
|
assertEquals(value, read.readVarLong(false));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testShorts () throws IOException {
|
|
runShortTest(new AeronOutput(4096));
|
|
runShortTest(new AeronOutput());
|
|
}
|
|
|
|
private void runShortTest (Output write) throws IOException {
|
|
write.writeShort(0);
|
|
write.writeShort(63);
|
|
write.writeShort(64);
|
|
write.writeShort(127);
|
|
write.writeShort(128);
|
|
write.writeShort(8192);
|
|
write.writeShort(16384);
|
|
write.writeShort(32767);
|
|
write.writeShort(-63);
|
|
write.writeShort(-64);
|
|
write.writeShort(-127);
|
|
write.writeShort(-128);
|
|
write.writeShort(-8192);
|
|
write.writeShort(-16384);
|
|
write.writeShort(-32768);
|
|
|
|
AeronInput read = new AeronInput(write.toBytes());
|
|
assertEquals(0, read.readShort());
|
|
assertEquals(63, read.readShort());
|
|
assertEquals(64, read.readShort());
|
|
assertEquals(127, read.readShort());
|
|
assertEquals(128, read.readShort());
|
|
assertEquals(8192, read.readShort());
|
|
assertEquals(16384, read.readShort());
|
|
assertEquals(32767, read.readShort());
|
|
assertEquals(-63, read.readShort());
|
|
assertEquals(-64, read.readShort());
|
|
assertEquals(-127, read.readShort());
|
|
assertEquals(-128, read.readShort());
|
|
assertEquals(-8192, read.readShort());
|
|
assertEquals(-16384, read.readShort());
|
|
assertEquals(-32768, read.readShort());
|
|
}
|
|
|
|
@Test
|
|
public void testFloats () throws IOException {
|
|
runFloatTest(new AeronOutput(4096));
|
|
runFloatTest(new AeronOutput());
|
|
}
|
|
|
|
private void runFloatTest (Output write) throws IOException {
|
|
write.writeFloat(0);
|
|
write.writeFloat(63);
|
|
write.writeFloat(64);
|
|
write.writeFloat(127);
|
|
write.writeFloat(128);
|
|
write.writeFloat(8192);
|
|
write.writeFloat(16384);
|
|
write.writeFloat(32767);
|
|
write.writeFloat(-63);
|
|
write.writeFloat(-64);
|
|
write.writeFloat(-127);
|
|
write.writeFloat(-128);
|
|
write.writeFloat(-8192);
|
|
write.writeFloat(-16384);
|
|
write.writeFloat(-32768);
|
|
assertEquals(1, write.writeVarFloat(0, 1000, true));
|
|
assertEquals(1, write.writeVarFloat(0, 1000, false));
|
|
assertEquals(3, write.writeVarFloat(63, 1000, true));
|
|
assertEquals(3, write.writeVarFloat(63, 1000, false));
|
|
assertEquals(3, write.writeVarFloat(64, 1000, true));
|
|
assertEquals(3, write.writeVarFloat(64, 1000, false));
|
|
assertEquals(3, write.writeVarFloat(127, 1000, true));
|
|
assertEquals(3, write.writeVarFloat(127, 1000, false));
|
|
assertEquals(3, write.writeVarFloat(128, 1000, true));
|
|
assertEquals(3, write.writeVarFloat(128, 1000, false));
|
|
assertEquals(4, write.writeVarFloat(8191, 1000, true));
|
|
assertEquals(4, write.writeVarFloat(8191, 1000, false));
|
|
assertEquals(4, write.writeVarFloat(8192, 1000, true));
|
|
assertEquals(4, write.writeVarFloat(8192, 1000, false));
|
|
assertEquals(4, write.writeVarFloat(16383, 1000, true));
|
|
assertEquals(4, write.writeVarFloat(16383, 1000, false));
|
|
assertEquals(4, write.writeVarFloat(16384, 1000, true));
|
|
assertEquals(4, write.writeVarFloat(16384, 1000, false));
|
|
assertEquals(4, write.writeVarFloat(32767, 1000, true));
|
|
assertEquals(4, write.writeVarFloat(32767, 1000, false));
|
|
assertEquals(3, write.writeVarFloat(-64, 1000, false));
|
|
assertEquals(5, write.writeVarFloat(-64, 1000, true));
|
|
assertEquals(3, write.writeVarFloat(-65, 1000, false));
|
|
assertEquals(5, write.writeVarFloat(-65, 1000, true));
|
|
assertEquals(4, write.writeVarFloat(-8192, 1000, false));
|
|
assertEquals(5, write.writeVarFloat(-8192, 1000, true));
|
|
|
|
AeronInput read = new AeronInput(write.toBytes());
|
|
KryoAssert.assertFloatEquals(read.readFloat(), 0f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), 63f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), 64f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), 127f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), 128f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), 8192f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), 16384f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), 32767f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), -63f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), -64f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), -127f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), -128f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), -8192f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), -16384f);
|
|
KryoAssert.assertFloatEquals(read.readFloat(), -32768f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 0f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 0f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 63f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 63f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 64f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 64f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 127f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 127f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 128f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 128f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 8191f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 8191f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 8192f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 8192f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 16383f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 16383f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 16384f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 16384f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 32767f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 32767f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), -64f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), -64f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), -65f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), -65f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), -8192f);
|
|
KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), -8192f);
|
|
}
|
|
|
|
@Test
|
|
public void testDoubles () throws IOException {
|
|
runDoubleTest(new AeronOutput(4096));
|
|
runDoubleTest(new AeronOutput());
|
|
}
|
|
|
|
private void runDoubleTest (Output write) throws IOException {
|
|
write.writeDouble(0);
|
|
write.writeDouble(63);
|
|
write.writeDouble(64);
|
|
write.writeDouble(127);
|
|
write.writeDouble(128);
|
|
write.writeDouble(8192);
|
|
write.writeDouble(16384);
|
|
write.writeDouble(32767);
|
|
write.writeDouble(-63);
|
|
write.writeDouble(-64);
|
|
write.writeDouble(-127);
|
|
write.writeDouble(-128);
|
|
write.writeDouble(-8192);
|
|
write.writeDouble(-16384);
|
|
write.writeDouble(-32768);
|
|
assertEquals(1, write.writeVarDouble(0, 1000, true));
|
|
assertEquals(1, write.writeVarDouble(0, 1000, false));
|
|
assertEquals(3, write.writeVarDouble(63, 1000, true));
|
|
assertEquals(3, write.writeVarDouble(63, 1000, false));
|
|
assertEquals(3, write.writeVarDouble(64, 1000, true));
|
|
assertEquals(3, write.writeVarDouble(64, 1000, false));
|
|
assertEquals(3, write.writeVarDouble(127, 1000, true));
|
|
assertEquals(3, write.writeVarDouble(127, 1000, false));
|
|
assertEquals(3, write.writeVarDouble(128, 1000, true));
|
|
assertEquals(3, write.writeVarDouble(128, 1000, false));
|
|
assertEquals(4, write.writeVarDouble(8191, 1000, true));
|
|
assertEquals(4, write.writeVarDouble(8191, 1000, false));
|
|
assertEquals(4, write.writeVarDouble(8192, 1000, true));
|
|
assertEquals(4, write.writeVarDouble(8192, 1000, false));
|
|
assertEquals(4, write.writeVarDouble(16383, 1000, true));
|
|
assertEquals(4, write.writeVarDouble(16383, 1000, false));
|
|
assertEquals(4, write.writeVarDouble(16384, 1000, true));
|
|
assertEquals(4, write.writeVarDouble(16384, 1000, false));
|
|
assertEquals(4, write.writeVarDouble(32767, 1000, true));
|
|
assertEquals(4, write.writeVarDouble(32767, 1000, false));
|
|
assertEquals(3, write.writeVarDouble(-64, 1000, false));
|
|
assertEquals(9, write.writeVarDouble(-64, 1000, true));
|
|
assertEquals(3, write.writeVarDouble(-65, 1000, false));
|
|
assertEquals(9, write.writeVarDouble(-65, 1000, true));
|
|
assertEquals(4, write.writeVarDouble(-8192, 1000, false));
|
|
assertEquals(9, write.writeVarDouble(-8192, 1000, true));
|
|
write.writeDouble(1.23456d);
|
|
|
|
AeronInput read = new AeronInput(write.toBytes());
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), 0d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), 63d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), 64d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), 127d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), 128d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), 8192d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), 16384d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), 32767d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), -63d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), -64d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), -127d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), -128d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), -8192d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), -16384d);
|
|
KryoAssert.assertDoubleEquals(read.readDouble(), -32768d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 0d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 0d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 63d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 63d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 64d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 64d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 127d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 127d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 128d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 128d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 8191d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 8191d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 8192d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 8192d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 16383d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 16383d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 16384d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 16384d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 32767d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 32767d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), -64d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), -64d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), -65d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), -65d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), -8192d);
|
|
KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), -8192d);
|
|
KryoAssert.assertDoubleEquals(1.23456d, read.readDouble());
|
|
}
|
|
|
|
@Test
|
|
public void testBooleans () throws IOException {
|
|
runBooleanTest(new AeronOutput(4096));
|
|
runBooleanTest(new AeronOutput());
|
|
}
|
|
|
|
private void runBooleanTest (Output write) throws IOException {
|
|
for (int i = 0; i < 100; i++) {
|
|
write.writeBoolean(true);
|
|
write.writeBoolean(false);
|
|
}
|
|
|
|
AeronInput read = new AeronInput(write.toBytes());
|
|
for (int i = 0; i < 100; i++) {
|
|
assertTrue(read.readBoolean());
|
|
assertFalse(read.readBoolean());
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testChars () throws IOException {
|
|
runCharTest(new AeronOutput(4096));
|
|
runCharTest(new AeronOutput());
|
|
}
|
|
|
|
private void runCharTest (Output write) throws IOException {
|
|
write.writeChar((char)0);
|
|
write.writeChar((char)63);
|
|
write.writeChar((char)64);
|
|
write.writeChar((char)127);
|
|
write.writeChar((char)128);
|
|
write.writeChar((char)8192);
|
|
write.writeChar((char)16384);
|
|
write.writeChar((char)32767);
|
|
write.writeChar((char)65535);
|
|
|
|
AeronInput read = new AeronInput(write.toBytes());
|
|
assertEquals(0, read.readChar());
|
|
assertEquals(63, read.readChar());
|
|
assertEquals(64, read.readChar());
|
|
assertEquals(127, read.readChar());
|
|
assertEquals(128, read.readChar());
|
|
assertEquals(8192, read.readChar());
|
|
assertEquals(16384, read.readChar());
|
|
assertEquals(32767, read.readChar());
|
|
assertEquals(65535, read.readChar());
|
|
}
|
|
|
|
@Test
|
|
public void testInputWithOffset () throws Exception {
|
|
final byte[] buf = new byte[30];
|
|
final AeronInput in = new AeronInput(buf, 10, 10);
|
|
assertEquals(10, in.available());
|
|
}
|
|
|
|
@Test
|
|
public void testSmallBuffers () throws Exception {
|
|
AeronOutput testOutput = new AeronOutput();
|
|
testOutput.writeBytes(new byte[512]);
|
|
testOutput.writeBytes(new byte[512]);
|
|
testOutput.flush();
|
|
|
|
AeronInput input = new AeronInput(testOutput.getInternalBuffer());
|
|
byte[] toRead = new byte[512];
|
|
input.readBytes(toRead);
|
|
|
|
input.readBytes(toRead);
|
|
}
|
|
|
|
@Test
|
|
public void testVerySmallBuffers () throws Exception {
|
|
Output out1 = new Output(4, -1);
|
|
Output out2 = new AeronOutput(4);
|
|
|
|
for (int i = 0; i < 16; i++) {
|
|
out1.writeVarInt(92, false);
|
|
}
|
|
|
|
for (int i = 0; i < 16; i++) {
|
|
out2.writeVarInt(92, false);
|
|
}
|
|
|
|
assertArrayEquals(out1.toBytes(), out2.toBytes());
|
|
}
|
|
|
|
@Test
|
|
public void testZeroLengthOutputs () throws Exception {
|
|
Output output = new Output(0, 10000);
|
|
kryo.writeClassAndObject(output, "Test string");
|
|
|
|
AeronOutput byteBufferOutput = new AeronOutput(0);
|
|
kryo.writeClassAndObject(byteBufferOutput, "Test string");
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Test
|
|
public void testFlushRoundTrip () throws Exception {
|
|
Kryo kryo = new Kryo();
|
|
|
|
String s1 = "12345";
|
|
|
|
AeronOutput output = new AeronOutput();
|
|
|
|
kryo.writeClass(output, s1.getClass());
|
|
kryo.writeObject(output, s1);
|
|
|
|
AeronInput input = new AeronInput(output.getInternalBuffer());
|
|
|
|
Registration r = kryo.readClass(input);
|
|
String s2 = (String)kryo.readObject(input, r.getType());
|
|
|
|
assertEquals(s1, s2);
|
|
}
|
|
|
|
|
|
@Test(expected = IllegalArgumentException.class)
|
|
public void testSetOutputBufferMinuxOne () {
|
|
int bufferSize = 2;
|
|
int maxBufferSize = 1;
|
|
|
|
AeronOutput output = new AeronOutput(-1);
|
|
assertNotNull(output);
|
|
|
|
output.setBuffer(new byte[bufferSize]);
|
|
}
|
|
|
|
@Test
|
|
public void testNewOutputMaxBufferSizeIsMinusOne () {
|
|
int bufferSize = 2;
|
|
int maxBufferSize = -1;
|
|
|
|
Output output = new Output(bufferSize, maxBufferSize);
|
|
assertNotNull(output);
|
|
// This test should pass as long as no exception thrown
|
|
}
|
|
|
|
@Test
|
|
public void testSetOutputMaxBufferSizeIsMinusOne () {
|
|
int bufferSize = 2;
|
|
int maxBufferSize = -1;
|
|
|
|
Output output = new AeronOutput(bufferSize);
|
|
assertNotNull(output);
|
|
output.setBuffer(new byte[bufferSize], maxBufferSize);
|
|
// This test should pass as long as no exception thrown
|
|
}
|
|
}
|