dorkbox
/
Network
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Upgrade to Kryo 5rc2, updated to use utilities project as a maven release instead of compiling specific files

This commit is contained in:
nathan 2019-03-25 23:05:51 +01:00
parent 9a62e70b53
commit 8bd52dd202
31 changed files with 2658 additions and 8483 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

124
build.gradle.kts
View File

@ -16,11 +16,8 @@
import Build_gradle.Extras.bcVersion
import com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask
import org.gradle.internal.impldep.org.junit.experimental.categories.Categories.CategoryFilter.include
import org.jetbrains.kotlin.js.translate.context.Namer.kotlin
import java.time.Instant
import java.util.Properties
import kotlin.collections.ArrayList
import java.util.*
import kotlin.collections.component1
import kotlin.collections.component2
import kotlin.collections.set
@ -49,9 +46,9 @@ plugins {
id("com.dorkbox.VersionUpdate") version "1.4.1"
// setup checking for the latest version of a plugin or dependency
id("com.github.ben-manes.versions") version "0.20.0"
id("com.github.ben-manes.versions") version "0.21.0"
kotlin("jvm") version "1.3.11"
kotlin("jvm") version "1.3.21"
}
object Extras {
@ -247,91 +244,6 @@ repositories {
jcenter()
}
///////////////////////////////
////// UTILITIES COMPILE
///////////////////////////////
// as long as the 'Utilities' project is ALSO imported into IntelliJ, class resolution will work (add the sources in the intellij project)
val utils : Configuration by configurations.creating
fun javaFile(vararg fileNames: String): Iterable<String> {
val fileList = ArrayList<String>(fileNames.size)
fileNames.forEach { name ->
fileList.add(name.replace('.', '/') + ".java")
}
return fileList
}
task<JavaCompile>("compileUtils") {
// we don't want the default include of **/*.java
includes.clear()
source = fileTree("../Utilities/src")
include(javaFile(
"dorkbox.util.OS",
"dorkbox.util.OSType",
"dorkbox.util.Property",
"dorkbox.util.NamedThreadFactory",
"dorkbox.util.DelayTimer",
"dorkbox.util.IO",
"dorkbox.util.FileUtil",
"dorkbox.util.Base64Fast",
"dorkbox.util.RandomUtil",
"dorkbox.util.Sys",
"dorkbox.util.HashUtil",
"dorkbox.util.NativeLoader",
"dorkbox.util.FastThreadLocal",
"dorkbox.util.LocationResolver",
"dorkbox.util.MathUtil",
"dorkbox.util.MersenneTwisterFast",
"dorkbox.util.NativeLoader",
"dorkbox.util.generics.TypeResolver",
"dorkbox.util.generics.DefaultMethodHelper",
"dorkbox.util.generics.ClassHelper",
"dorkbox.util.bytes.BigEndian",
"dorkbox.util.bytes.UByte",
"dorkbox.util.bytes.UInteger",
"dorkbox.util.bytes.ULong",
"dorkbox.util.bytes.Unsigned",
"dorkbox.util.bytes.UNumber",
"dorkbox.util.bytes.UShort",
"dorkbox.util.bytes.ByteArrayWrapper",
"dorkbox.util.bytes.OptimizeUtilsByteArray",
"dorkbox.util.bytes.OptimizeUtilsByteBuf",
"dorkbox.util.exceptions.SecurityException",
"dorkbox.util.exceptions.InitializationException",
"dorkbox.util.collections.ObjectIntMap",
"dorkbox.util.collections.IntMap",
"dorkbox.util.collections.IntArray",
"dorkbox.util.collections.ConcurrentIterator",
"dorkbox.util.collections.ConcurrentEntry",
"dorkbox.util.collections.LockFreeHashMap",
"dorkbox.util.collections.LockFreeIntMap",
"dorkbox.util.collections.LockFreeIntBiMap",
"dorkbox.util.collections.LockFreeObjectIntBiMap",
"dorkbox.util.crypto.CryptoECC",
"dorkbox.util.crypto.CryptoAES"
))
// entire packages/directories
include("dorkbox/util/serialization/**/*.java")
include("dorkbox/util/entropy/**/*.java")
include("dorkbox/util/storage/**/*.java")
classpath = files(utils)
destinationDir = file("$rootDir/build/classes_utilities")
}
///////////////////////////////
////// Task defaults
///////////////////////////////
@ -347,9 +259,6 @@ tasks.withType<Jar> {
}
tasks.jar.get().apply {
// include applicable class files from subset of Utilities project
from((tasks["compileUtils"] as JavaCompile).outputs)
manifest {
// https://docs.oracle.com/javase/tutorial/deployment/jar/packageman.html
attributes["Name"] = Extras.name
@ -372,26 +281,25 @@ tasks.compileJava.get().apply {
dependencies {
val netty = api("io.netty:netty-all:4.1.32.Final")
val kryo = api("com.esotericsoftware:kryo:4.0.2")
api("net.jpountz.lz4:lz4:1.3.0")
implementation("io.netty:netty-all:4.1.34.Final")
implementation("com.esotericsoftware:kryo:5.0.0-RC2")
implementation("net.jpountz.lz4:lz4:1.3.0")
val bc = api("org.bouncycastle:bcprov-jdk15on:$bcVersion")
api("org.bouncycastle:bcpg-jdk15on:$bcVersion")
api("org.bouncycastle:bcmail-jdk15on:$bcVersion")
api("org.bouncycastle:bctls-jdk15on:$bcVersion")
implementation("org.bouncycastle:bcprov-jdk15on:$bcVersion")
implementation("org.bouncycastle:bcpg-jdk15on:$bcVersion")
implementation("org.bouncycastle:bcmail-jdk15on:$bcVersion")
implementation("org.bouncycastle:bctls-jdk15on:$bcVersion")
implementation("net.jodah:typetools:0.6.1")
implementation("de.javakaffee:kryo-serializers:0.45")
api("com.dorkbox:ObjectPool:2.11")
implementation("com.dorkbox:ObjectPool:2.11")
implementation("com.dorkbox:Utilities:1.1")
val slf4j = implementation ("org.slf4j:slf4j-api:1.7.25")
implementation("org.slf4j:slf4j-api:1.7.25")
testCompile("junit:junit:4.12")
testCompile("ch.qos.logback:logback-classic:1.2.3")
// add compile utils to dependencies
implementation(files((tasks["compileUtils"] as JavaCompile).outputs))
utils.dependencies += listOf(netty, kryo, slf4j, bc)
}
///////////////////////////////
@ -529,7 +437,7 @@ tasks.named<DependencyUpdatesTask>("dependencyUpdates") {
////// Gradle Wrapper Configuration.
///// Run this task, then refresh the gradle project
///////////////////////////////
val wrapperUpdate by tasks.creating(Wrapper::class) {
task<Wrapper>("wrapperUpdate") {
gradleVersion = "5.3"
distributionUrl = distributionUrl.replace("bin", "all")
}

2
src/dorkbox/network/connection/ConnectionManager.java
View File

@ -35,10 +35,10 @@ import dorkbox.network.connection.ping.PingMessage;
import dorkbox.util.Property;
import dorkbox.util.collections.ConcurrentEntry;
import dorkbox.util.generics.ClassHelper;
import dorkbox.util.generics.TypeResolver;
import io.netty.bootstrap.DatagramCloseMessage;
import io.netty.util.concurrent.ImmediateEventExecutor;
import io.netty.util.concurrent.Promise;
import net.jodah.typetools.TypeResolver;
// .equals() compares the identity on purpose,this because we cannot create two separate objects that are somehow equal to each other.
@SuppressWarnings("unchecked")

5
src/dorkbox/network/connection/KryoExtra.java
View File

@ -22,9 +22,6 @@ import org.bouncycastle.crypto.modes.GCMBlockCipher;
import org.bouncycastle.crypto.params.ParametersWithIV;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.util.DefaultClassResolver;
import com.esotericsoftware.kryo.util.DefaultStreamFactory;
import com.esotericsoftware.kryo.util.MapReferenceResolver;
import dorkbox.network.pipeline.ByteBufInput;
import dorkbox.network.pipeline.ByteBufOutput;
@ -93,7 +90,7 @@ class KryoExtra extends Kryo {
public
KryoExtra(final NetworkSerializationManager serializationManager) {
super(new DefaultClassResolver(), new MapReferenceResolver(), new DefaultStreamFactory());
super();
this.serializationManager = serializationManager;
}

1363
src/dorkbox/network/pipeline/ByteBufInput.java
View File

File diff suppressed because it is too large Load Diff

1210
src/dorkbox/network/pipeline/ByteBufOutput.java
View File

File diff suppressed because it is too large Load Diff

3
src/dorkbox/network/rmi/InvocationHandlerSerializer.java
View File

@ -43,9 +43,8 @@ class InvocationHandlerSerializer extends Serializer<Object> {
}
@Override
@SuppressWarnings({"unchecked", "AutoBoxing"})
public
Object read(Kryo kryo, Input input, Class<Object> type) {
Object read(final Kryo kryo, final Input input, final Class<?> type) {
int objectID = input.readInt(true);
KryoExtra kryoExtra = (KryoExtra) kryo;

3
src/dorkbox/network/rmi/InvocationResultSerializer.java
View File

@ -19,6 +19,7 @@ import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.serializers.FieldSerializer;
import dorkbox.network.connection.KryoExtra;
public
@ -37,7 +38,7 @@ class InvocationResultSerializer extends FieldSerializer<InvokeMethodResult> {
@Override
public
InvokeMethodResult read(Kryo kryo, Input input, Class<InvokeMethodResult> type) {
InvokeMethodResult read(final Kryo kryo, final Input input, final Class<? extends InvokeMethodResult> type) {
InvokeMethodResult result = super.read(kryo, input, type);
result.rmiObjectId = input.readInt(true);
return result;

2
src/dorkbox/network/rmi/InvokeMethodSerializer.java
View File

@ -91,7 +91,7 @@ class InvokeMethodSerializer extends Serializer<InvokeMethod> {
@Override
public
InvokeMethod read(final Kryo kryo, final Input input, final Class<InvokeMethod> type) {
InvokeMethod read(final Kryo kryo, final Input input, final Class<? extends InvokeMethod> type) {
int objectID = input.readInt(true);
int methodClassID = input.readInt(true);
byte methodIndex = input.readByte();

46
src/dorkbox/network/serialization/Serialization.java
View File

@ -25,21 +25,24 @@ import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.crypto.params.IESParameters;
import org.bouncycastle.crypto.params.IESWithCipherParameters;
import org.objenesis.strategy.StdInstantiatorStrategy;
import org.slf4j.Logger;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.KryoException;
import com.esotericsoftware.kryo.Registration;
import com.esotericsoftware.kryo.Serializer;
import com.esotericsoftware.kryo.factories.ReflectionSerializerFactory;
import com.esotericsoftware.kryo.factories.SerializerFactory;
import com.esotericsoftware.kryo.SerializerFactory;
import com.esotericsoftware.kryo.SerializerFactory.ReflectionSerializerFactory;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.serializers.CollectionSerializer;
import com.esotericsoftware.kryo.serializers.FieldSerializer;
import com.esotericsoftware.kryo.util.DefaultInstantiatorStrategy;
import com.esotericsoftware.kryo.util.IdentityMap;
import com.esotericsoftware.kryo.util.MapReferenceResolver;
import com.esotericsoftware.kryo.util.Util;
import de.javakaffee.kryoserializers.UnmodifiableCollectionsSerializer;
import dorkbox.network.connection.Connection_;
import dorkbox.network.connection.KryoExtra;
import dorkbox.network.connection.ping.PingMessage;
@ -55,14 +58,12 @@ import dorkbox.network.rmi.RmiRegistrationSerializer;
import dorkbox.network.rmi.RmiUtils;
import dorkbox.objectPool.ObjectPool;
import dorkbox.objectPool.PoolableObject;
import dorkbox.util.Property;
import dorkbox.util.OS;
import dorkbox.util.collections.IntMap;
import dorkbox.util.serialization.ArraysAsListSerializer;
import dorkbox.util.serialization.EccPrivateKeySerializer;
import dorkbox.util.serialization.EccPublicKeySerializer;
import dorkbox.util.serialization.IesParametersSerializer;
import dorkbox.util.serialization.IesWithCipherParametersSerializer;
import dorkbox.util.serialization.UnmodifiableCollectionsSerializer;
import io.netty.bootstrap.DatagramCloseMessage;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
@ -81,13 +82,6 @@ class Serialization implements NetworkSerializationManager {
private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(Serialization.class.getSimpleName());
/**
* Specify if we want KRYO to use unsafe memory for serialization, or to use the ASM backend. Unsafe memory use is WAY faster, but is
* limited to the "same endianess" on all endpoints, and unsafe DOES NOT work on android.
*/
@Property
public static boolean useUnsafeMemory = false;
public static
Serialization DEFAULT() {
return DEFAULT(true, true, null);
@ -115,7 +109,7 @@ class Serialization implements NetworkSerializationManager {
* Kryo#newDefaultSerializer(Class)
*/
public static
<C extends Connection_> Serialization DEFAULT(final boolean references, final boolean registrationRequired, final SerializerFactory factory) {
Serialization DEFAULT(final boolean references, final boolean registrationRequired, final SerializerFactory factory) {
final Serialization serialization = new Serialization(references,
registrationRequired,
@ -137,11 +131,19 @@ class Serialization implements NetworkSerializationManager {
serialization.register(StackTraceElement.class);
serialization.register(StackTraceElement[].class);
// extra serializers
//noinspection ArraysAsListWithZeroOrOneArgument
serialization.register(Arrays.asList("").getClass(), new ArraysAsListSerializer());
serialization.register(Arrays.asList().getClass());
UnmodifiableCollectionsSerializer.registerSerializers(serialization);
// hacky way to register unmodifiable serializers
Kryo kryo = new Kryo() {
@Override
public
Registration register(final Class type, final Serializer serializer) {
serialization.register(type, serializer);
return null;
}
};
UnmodifiableCollectionsSerializer.registerSerializers(kryo);
return serialization;
}
@ -173,7 +175,7 @@ class Serialization implements NetworkSerializationManager {
// reflectASM doesn't work on android
private final boolean useAsm = !useUnsafeMemory && !Util.IS_ANDROID;
private final boolean useAsm = !OS.isAndroid();
private Logger wireReadLogger;
private Logger wireWriteLogger;
@ -215,7 +217,11 @@ class Serialization implements NetworkSerializationManager {
// we HAVE to pre-allocate the KRYOs
KryoExtra kryo = new KryoExtra(Serialization.this);
kryo.getFieldSerializerConfig().setUseAsm(useAsm);
// BY DEFAULT, DefaultInstantiatorStrategy() will use ReflectASM
// StdInstantiatorStrategy will create classes bypasses the constructor (which can be useful in some cases) THIS IS A FALLBACK!
kryo.setInstantiatorStrategy(new DefaultInstantiatorStrategy(new StdInstantiatorStrategy()));
kryo.setRegistrationRequired(registrationRequired);
kryo.setReferences(references);

117
test/dorkbox/network/kryo/ArraySerializerTest.java
View File

@ -1,117 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import com.esotericsoftware.kryo.serializers.DefaultArraySerializers.ObjectArraySerializer;
/** @author Nathan Sweet <misc@n4te.com> */
public class ArraySerializerTest extends KryoTestCase {
{
supportsCopy = true;
}
public void testArraysASM () {
kryo.getFieldSerializerConfig().setUseAsm(true);
kryo.register(int[].class);
kryo.register(int[][].class);
kryo.register(int[][][].class);
kryo.register(String[].class);
kryo.register(Object[].class);
roundTrip(4, 4, new Object[] {null, null});
roundTrip(6, 6, new Object[] {null, "2"});
roundTrip(6, 18, new int[] {1, 2, 3, 4});
roundTrip(7, 18, new int[] {1, 2, -100, 4});
roundTrip(9, 18, new int[] {1, 2, -100, 40000});
roundTrip(9, 20, new int[][] { {1, 2}, {100, 4}});
roundTrip(11, 22, new int[][] { {1}, {2}, {100}, {4}});
roundTrip(13, 24, new int[][][] { { {1}, {2}}, { {100}, {4}}});
roundTrip(12, 12, new String[] {"11", "2222", "3", "4"});
roundTrip(11, 11, new String[] {"11", "2222", null, "4"});
roundTrip(28, 51,
new Object[] {new String[] {"11", "2222", null, "4"}, new int[] {1, 2, 3, 4}, new int[][] { {1, 2}, {100, 4}}});
ObjectArraySerializer serializer = new ObjectArraySerializer(kryo, String[].class);
kryo.register(String[].class, serializer);
serializer.setElementsAreSameType(true);
roundTrip(11, 11, new String[] {"11", "2222", null, "4"});
serializer.setElementsAreSameType(false);
roundTrip(11, 11, new String[] {"11", "2222", null, "4"});
roundTrip(5, 5, new String[] {null, null, null});
roundTrip(2, 2, new String[] {});
serializer.setElementsAreSameType(true);
roundTrip(12, 12, new String[] {"11", "2222", "3", "4"});
serializer.setElementsCanBeNull(false);
roundTrip(12, 12, new String[] {"11", "2222", "3", "4"});
serializer = new ObjectArraySerializer(kryo, Float[].class);
kryo.register(Float[][].class, serializer);
kryo.register(Float[].class, serializer);
Float[][] array = new Float[4][];
array[0] = new Float[] {0.0f, 1.0f};
array[1] = null;
array[2] = new Float[] {2.0f, 3.0f};
array[3] = new Float[] {3.0f};
roundTrip(31, 31, array);
}
public void testArraysUnsafe () {
kryo.getFieldSerializerConfig().setUseAsm(false);
kryo.register(int[].class);
kryo.register(int[][].class);
kryo.register(int[][][].class);
kryo.register(String[].class);
kryo.register(Object[].class);
roundTrip(6, 18, new int[] {1, 2, 3, 4});
roundTrip(7, 18, new int[] {1, 2, -100, 4});
roundTrip(9, 18, new int[] {1, 2, -100, 40000});
roundTrip(9, 20, new int[][] { {1, 2}, {100, 4}});
roundTrip(11, 22, new int[][] { {1}, {2}, {100}, {4}});
roundTrip(13, 24, new int[][][] { { {1}, {2}}, { {100}, {4}}});
roundTrip(12, 12, new String[] {"11", "2222", "3", "4"});
roundTrip(11, 11, new String[] {"11", "2222", null, "4"});
roundTrip(28, 51,
new Object[] {new String[] {"11", "2222", null, "4"}, new int[] {1, 2, 3, 4}, new int[][] { {1, 2}, {100, 4}}});
ObjectArraySerializer serializer = new ObjectArraySerializer(kryo, String[].class);
kryo.register(String[].class, serializer);
serializer.setElementsAreSameType(true);
roundTrip(11, 11, new String[] {"11", "2222", null, "4"});
serializer.setElementsAreSameType(false);
roundTrip(11, 11, new String[] {"11", "2222", null, "4"});
roundTrip(5, 5, new String[] {null, null, null});
roundTrip(2, 2, new String[] {});
serializer.setElementsAreSameType(true);
roundTrip(12, 12, new String[] {"11", "2222", "3", "4"});
serializer.setElementsCanBeNull(false);
roundTrip(12, 12, new String[] {"11", "2222", "3", "4"});
serializer = new ObjectArraySerializer(kryo, Float[].class);
kryo.register(Float[][].class, serializer);
kryo.register(Float[].class, serializer);
Float[][] array = new Float[4][];
array[0] = new Float[] {0.0f, 1.0f};
array[1] = null;
array[2] = new Float[] {2.0f, 3.0f};
array[3] = new Float[] {3.0f};
roundTrip(31, 31, array);
}
}

152
test/dorkbox/network/kryo/BeanSerializerTest.java
View File

@ -1,152 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import com.esotericsoftware.kryo.serializers.BeanSerializer;
/** @author Nathan Sweet <misc@n4te.com> */
public class BeanSerializerTest extends KryoTestCase {
{
supportsCopy = true;
}
@SuppressWarnings({"rawtypes"})
public void testBeanSerializer () {
kryo.register(TestClass.class, new BeanSerializer(kryo, TestClass.class));
TestClass test = new TestClass();
test.setOptional(12);
test.setNullField("value");
test.setText("123");
test.setChild(new TestClass());
roundTrip(37, 43, test);
test.setNullField(null);
roundTrip(33, 39, test);
}
static public class TestClass {
private String text = "something";
private String nullField;
private TestClass child;
private TestClass child2;
private float abc = 1.2f;
private int optional;
public String getText () {
return text;
}
public void setText (String text) {
this.text = text;
}
public String getNullField () {
return nullField;
}
public void setNullField (String nullField) {
this.nullField = nullField;
}
public TestClass getChild () {
return child;
}
public void setChild (TestClass child) {
this.child = child;
}
public TestClass getChild2 () {
return child2;
}
public void setChild2 (TestClass child2) {
this.child2 = child2;
}
public float getAbc () {
return abc;
}
public void setAbc (float abc) {
this.abc = abc;
}
public int getOptional () {
return optional;
}
public void setOptional (int optional) {
this.optional = optional;
}
@Override
public boolean equals (Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
TestClass other = (TestClass)obj;
if (Float.floatToIntBits(abc) != Float.floatToIntBits(other.abc)) {
return false;
}
if (child == null) {
if (other.child != null) {
return false;
}
} else if (child != this && !child.equals(other.child)) {
return false;
}
if (child2 == null) {
if (other.child2 != null) {
return false;
}
} else if (child2 != this && !child2.equals(other.child2)) {
return false;
}
if (nullField == null) {
if (other.nullField != null) {
return false;
}
} else if (!nullField.equals(other.nullField)) {
return false;
}
if (text == null) {
if (other.text != null) {
return false;
}
} else if (!text.equals(other.text)) {
return false;
}
return true;
}
@Override
public int hashCode() {
return super.hashCode();
}
}
}

30
test/dorkbox/network/kryo/BlowfishSerializerTest.java
View File

@ -1,30 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
/** @author Nathan Sweet <misc@n4te.com> */
public class BlowfishSerializerTest extends KryoTestCase {
public void testBlowfishCrypto () throws Exception {
System.err.println("BlowfishSerializerTest test is ignored because javax.crypto is not available in java 6");
// byte[] key = javax.crypto.KeyGenerator.getInstance("Blowfish").generateKey().getEncoded();
// kryo.register(String.class, new BlowfishSerializer(new StringSerializer(), key));
// roundTrip(49, 49, "abcdefabcdefabcdefabcdefabcdefabcdefabcdef");
}
}

61
test/dorkbox/network/kryo/ChunkedTest.java
View File

@ -1,61 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.InputChunked;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.io.OutputChunked;
/** @author Nathan Sweet <misc@n4te.com> */
public class ChunkedTest extends KryoTestCase {
public void testChunks () {
Output output = new Output(512);
output.writeInt(1234);
OutputChunked outputChunked = new OutputChunked(output);
outputChunked.writeInt(1);
outputChunked.endChunks();
outputChunked.writeInt(2);
outputChunked.endChunks();
outputChunked.writeInt(3);
outputChunked.endChunks();
outputChunked.writeInt(4);
outputChunked.endChunks();
outputChunked.writeInt(5);
outputChunked.endChunks();
output.writeInt(5678);
output.close();
outputChunked.close();
Input input = new Input(output.getBuffer());
assertEquals(1234, input.readInt());
InputChunked inputChunked = new InputChunked(input);
assertEquals(1, inputChunked.readInt());
inputChunked.nextChunks();
inputChunked.nextChunks(); // skip 3
assertEquals(3, inputChunked.readInt());
inputChunked.nextChunks();
inputChunked.nextChunks(); // skip 4
assertEquals(5, inputChunked.readInt());
assertEquals(5678, input.readInt());
input.close();
inputChunked.close();
}
}

60
test/dorkbox/network/kryo/CollectionSerializerTest.java
View File

@ -1,60 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import com.esotericsoftware.kryo.serializers.CollectionSerializer;
import com.esotericsoftware.kryo.serializers.DefaultSerializers.StringSerializer;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.concurrent.CopyOnWriteArrayList;
/** @author Nathan Sweet <misc@n4te.com> */
public class CollectionSerializerTest extends KryoTestCase {
{
supportsCopy = true;
}
@SuppressWarnings({"unchecked","rawtypes"})
public void testCollections () {
kryo.register(ArrayList.class);
kryo.register(LinkedList.class);
kryo.register(CopyOnWriteArrayList.class);
roundTrip(11, 11, list("1", "2", "3"));
roundTrip(13, 19, list("1", "2", null, 1, 2));
roundTrip(15, 24, list("1", "2", null, 1, 2, 5));
roundTrip(11, 11, list("1", "2", "3"));
roundTrip(11, 11, list("1", "2", "3"));
roundTrip(13, 13, list("1", "2", list("3")));
roundTrip(13, 13, new LinkedList(list("1", "2", list("3"))));
roundTrip(13, 13, new CopyOnWriteArrayList(list("1", "2", list("3"))));
CollectionSerializer serializer = new CollectionSerializer();
kryo.register(ArrayList.class, serializer);
kryo.register(LinkedList.class, serializer);
kryo.register(CopyOnWriteArrayList.class, serializer);
serializer.setElementClass(String.class, kryo.getSerializer(String.class));
roundTrip(8, 8, list("1", "2", "3"));
serializer.setElementClass(String.class, new StringSerializer());
roundTrip(8, 8, list("1", "2", "3"));
serializer.setElementsCanBeNull(false);
roundTrip(8, 8, list("1", "2", "3"));
}
}

511
test/dorkbox/network/kryo/CompatibleFieldSerializerTest.java
View File

@ -1,511 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import java.io.FileNotFoundException;
import com.esotericsoftware.kryo.serializers.CompatibleFieldSerializer;
import com.esotericsoftware.kryo.serializers.FieldSerializer;
/**
* @author Nathan Sweet <misc@n4te.com>
*/
public
class CompatibleFieldSerializerTest extends KryoTestCase {
{
supportsCopy = true;
}
public
void testCompatibleFieldSerializer() throws FileNotFoundException {
TestClass object1 = new TestClass();
object1.child = new TestClass();
object1.other = new AnotherClass();
object1.other.value = "meow";
kryo.setDefaultSerializer(CompatibleFieldSerializer.class);
kryo.register(TestClass.class);
kryo.register(AnotherClass.class);
roundTrip(107, 107, object1);
}
public
void testAddedField() throws FileNotFoundException {
TestClass object1 = new TestClass();
object1.child = new TestClass();
object1.other = new AnotherClass();
object1.other.value = "meow";
CompatibleFieldSerializer serializer = new CompatibleFieldSerializer(kryo, TestClass.class);
serializer.removeField("text");
kryo.register(TestClass.class, serializer);
kryo.register(AnotherClass.class, new CompatibleFieldSerializer(kryo, AnotherClass.class));
roundTrip(80, 80, object1);
kryo.register(TestClass.class, new CompatibleFieldSerializer(kryo, TestClass.class));
Object object2 = kryo.readClassAndObject(input);
assertEquals(object1, object2);
}
public
void testAddedFieldToClassWithManyFields() throws FileNotFoundException {
// class must have more than CompatibleFieldSerializer#THRESHOLD_BINARY_SEARCH number of fields
ClassWithManyFields object1 = new ClassWithManyFields();
object1.aa = "aa";
object1.a0 = "a0";
object1.bb = "bb";
object1.b0 = "b0";
object1.cc = "cc";
object1.c0 = "c0";
object1.dd = "dd";
object1.d0 = "d0";
object1.ee = "ee";
object1.e0 = "e0";
object1.ff = "ff";
object1.f0 = "f0";
object1.gg = "gg";
object1.g0 = "g0";
object1.hh = "hh";
object1.h0 = "h0";
object1.ii = "ii";
object1.i0 = "i0";
object1.jj = "jj";
object1.j0 = "j0";
object1.kk = "kk";
object1.k0 = "k0";
object1.ll = "ll";
object1.mm = "mm";
object1.nn = "nn";
object1.oo = "oo";
object1.pp = "pp";
object1.qq = "qq";
object1.rr = "rr";
object1.ss = "ss";
object1.tt = "tt";
object1.uu = "uu";
object1.vv = "vv";
object1.ww = "ww";
object1.xx = "xx";
object1.yy = "yy";
object1.zz = "zzaa";
CompatibleFieldSerializer serializer = new CompatibleFieldSerializer(kryo, ClassWithManyFields.class);
serializer.removeField("bAdd");
kryo.register(ClassWithManyFields.class, serializer);
roundTrip(226, 226, object1);
kryo.register(ClassWithManyFields.class, new CompatibleFieldSerializer(kryo, ClassWithManyFields.class));
Object object2 = kryo.readClassAndObject(input);
assertEquals(object1, object2);
}
public
void testRemovedField() throws FileNotFoundException {
TestClass object1 = new TestClass();
object1.child = new TestClass();
kryo.register(TestClass.class, new CompatibleFieldSerializer(kryo, TestClass.class));
roundTrip(94, 94, object1);
CompatibleFieldSerializer serializer = new CompatibleFieldSerializer(kryo, TestClass.class);
serializer.removeField("text");
kryo.register(TestClass.class, serializer);
Object object2 = kryo.readClassAndObject(input);
assertEquals(object1, object2);
}
public
void testRemovedFieldFromClassWithManyFields() throws FileNotFoundException {
// class must have more than CompatibleFieldSerializer#THRESHOLD_BINARY_SEARCH number of fields
ClassWithManyFields object1 = new ClassWithManyFields();
object1.aa = "aa";
object1.a0 = "a0";
object1.bAdd = "bAdd";
object1.bb = "bb";
object1.b0 = "b0";
object1.cc = "cc";
object1.c0 = "c0";
object1.dd = "dd";
object1.d0 = "d0";
object1.ee = "ee";
object1.e0 = "e0";
object1.ff = "ff";
object1.f0 = "f0";
object1.gg = "gg";
object1.g0 = "g0";
object1.hh = "hh";
object1.h0 = "h0";
object1.ii = "ii";
object1.i0 = "i0";
object1.jj = "jj";
object1.j0 = "j0";
object1.kk = "kk";
object1.k0 = "k0";
object1.ll = "ll";
object1.mm = "mm";
object1.nn = "nn";
object1.oo = "oo";
object1.pp = "pp";
object1.qq = "qq";
object1.rr = "rr";
object1.ss = "ss";
object1.tt = "tt";
object1.uu = "uu";
object1.vv = "vv";
object1.ww = "ww";
object1.xx = "xx";
object1.yy = "yy";
object1.zz = "zzaa";
kryo.register(ClassWithManyFields.class, new CompatibleFieldSerializer(kryo, ClassWithManyFields.class));
roundTrip(236, 236, object1);
CompatibleFieldSerializer serializer = new CompatibleFieldSerializer(kryo, ClassWithManyFields.class);
serializer.removeField("bAdd");
kryo.register(ClassWithManyFields.class, serializer);
Object object2 = kryo.readClassAndObject(input);
assertTrue(object2 instanceof ClassWithManyFields);
assertNull("the bAdd field should be null", ((ClassWithManyFields) object2).bAdd);
// update the field in order to verify the remainder of the object was deserialized correctly
((ClassWithManyFields) object2).bAdd = object1.bAdd;
assertEquals(object1, object2);
}
public
void testExtendedClass() throws FileNotFoundException {
ExtendedTestClass extendedObject = new ExtendedTestClass();
// this test would fail with DEFAULT field name strategy
kryo.getFieldSerializerConfig()
.setCachedFieldNameStrategy(FieldSerializer.CachedFieldNameStrategy.EXTENDED);
CompatibleFieldSerializer serializer = new CompatibleFieldSerializer(kryo, ExtendedTestClass.class);
kryo.register(ExtendedTestClass.class, serializer);
roundTrip(286, 286, extendedObject);
ExtendedTestClass object2 = (ExtendedTestClass) kryo.readClassAndObject(input);
assertEquals(extendedObject, object2);
}
static public
class TestClass {
public String text = "something";
public int moo = 120;
public long moo2 = 1234120;
public TestClass child;
public int zzz = 123;
public AnotherClass other;
public
boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
TestClass other = (TestClass) obj;
if (child == null) {
if (other.child != null)
return false;
}
else if (!child.equals(other.child))
return false;
if (moo != other.moo)
return false;
if (moo2 != other.moo2)
return false;
if (text == null) {
if (other.text != null)
return false;
}
else if (!text.equals(other.text))
return false;
if (zzz != other.zzz)
return false;
return true;
}
}
static public
class ExtendedTestClass extends TestClass {
// keep the same names of attributes like TestClass
public String text = "extendedSomething";
public int moo = 127;
public long moo2 = 5555;
public TestClass child;
public int zzz = 222;
public AnotherClass other;
public
boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
ExtendedTestClass other = (ExtendedTestClass) obj;
if (!super.equals(obj))
return false;
if (child == null) {
if (other.child != null)
return false;
}
else if (!child.equals(other.child))
return false;
if (moo != other.moo)
return false;
if (moo2 != other.moo2)
return false;
if (text == null) {
if (other.text != null)
return false;
}
else if (!text.equals(other.text))
return false;
if (zzz != other.zzz)
return false;
return true;
}
}
static public
class AnotherClass {
String value;
}
static public
class ClassWithManyFields {
public String aa;
public String bb;
public String bAdd;
public String cc;
public String dd;
public String ee;
public String ff;
public String gg;
public String hh;
public String ii;
public String jj;
public String kk;
public String ll;
public String mm;
public String nn;
public String oo;
public String pp;
public String qq;
public String rr;
public String ss;
public String tt;
public String uu;
public String vv;
public String ww;
public String xx;
public String yy;
public String zz;
public String a0;
public String b0;
public String c0;
public String d0;
public String e0;
public String f0;
public String g0;
public String h0;
public String i0;
public String j0;
public String k0;
@Override
public
boolean equals(final Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
final ClassWithManyFields that = (ClassWithManyFields) o;
if (aa != null ? !aa.equals(that.aa) : that.aa != null) {
return false;
}
if (bb != null ? !bb.equals(that.bb) : that.bb != null) {
return false;
}
if (bAdd != null ? !bAdd.equals(that.bAdd) : that.bAdd != null) {
return false;
}
if (cc != null ? !cc.equals(that.cc) : that.cc != null) {
return false;
}
if (dd != null ? !dd.equals(that.dd) : that.dd != null) {
return false;
}
if (ee != null ? !ee.equals(that.ee) : that.ee != null) {
return false;
}
if (ff != null ? !ff.equals(that.ff) : that.ff != null) {
return false;
}
if (gg != null ? !gg.equals(that.gg) : that.gg != null) {
return false;
}
if (hh != null ? !hh.equals(that.hh) : that.hh != null) {
return false;
}
if (ii != null ? !ii.equals(that.ii) : that.ii != null) {
return false;
}
if (jj != null ? !jj.equals(that.jj) : that.jj != null) {
return false;
}
if (kk != null ? !kk.equals(that.kk) : that.kk != null) {
return false;
}
if (ll != null ? !ll.equals(that.ll) : that.ll != null) {
return false;
}
if (mm != null ? !mm.equals(that.mm) : that.mm != null) {
return false;
}
if (nn != null ? !nn.equals(that.nn) : that.nn != null) {
return false;
}
if (oo != null ? !oo.equals(that.oo) : that.oo != null) {
return false;
}
if (pp != null ? !pp.equals(that.pp) : that.pp != null) {
return false;
}
if (qq != null ? !qq.equals(that.qq) : that.qq != null) {
return false;
}
if (rr != null ? !rr.equals(that.rr) : that.rr != null) {
return false;
}
if (ss != null ? !ss.equals(that.ss) : that.ss != null) {
return false;
}
if (tt != null ? !tt.equals(that.tt) : that.tt != null) {
return false;
}
if (uu != null ? !uu.equals(that.uu) : that.uu != null) {
return false;
}
if (vv != null ? !vv.equals(that.vv) : that.vv != null) {
return false;
}
if (ww != null ? !ww.equals(that.ww) : that.ww != null) {
return false;
}
if (xx != null ? !xx.equals(that.xx) : that.xx != null) {
return false;
}
if (yy != null ? !yy.equals(that.yy) : that.yy != null) {
return false;
}
if (zz != null ? !zz.equals(that.zz) : that.zz != null) {
return false;
}
if (a0 != null ? !a0.equals(that.a0) : that.a0 != null) {
return false;
}
if (b0 != null ? !b0.equals(that.b0) : that.b0 != null) {
return false;
}
if (c0 != null ? !c0.equals(that.c0) : that.c0 != null) {
return false;
}
if (d0 != null ? !d0.equals(that.d0) : that.d0 != null) {
return false;
}
if (e0 != null ? !e0.equals(that.e0) : that.e0 != null) {
return false;
}
if (f0 != null ? !f0.equals(that.f0) : that.f0 != null) {
return false;
}
if (g0 != null ? !g0.equals(that.g0) : that.g0 != null) {
return false;
}
if (h0 != null ? !h0.equals(that.h0) : that.h0 != null) {
return false;
}
if (i0 != null ? !i0.equals(that.i0) : that.i0 != null) {
return false;
}
if (j0 != null ? !j0.equals(that.j0) : that.j0 != null) {
return false;
}
return k0 != null ? k0.equals(that.k0) : that.k0 == null;
}
@Override
public
int hashCode() {
int result = aa != null ? aa.hashCode() : 0;
result = 31 * result + (bb != null ? bb.hashCode() : 0);
result = 31 * result + (bAdd != null ? bAdd.hashCode() : 0);
result = 31 * result + (cc != null ? cc.hashCode() : 0);
result = 31 * result + (dd != null ? dd.hashCode() : 0);
result = 31 * result + (ee != null ? ee.hashCode() : 0);
result = 31 * result + (ff != null ? ff.hashCode() : 0);
result = 31 * result + (gg != null ? gg.hashCode() : 0);
result = 31 * result + (hh != null ? hh.hashCode() : 0);
result = 31 * result + (ii != null ? ii.hashCode() : 0);
result = 31 * result + (jj != null ? jj.hashCode() : 0);
result = 31 * result + (kk != null ? kk.hashCode() : 0);
result = 31 * result + (ll != null ? ll.hashCode() : 0);
result = 31 * result + (mm != null ? mm.hashCode() : 0);
result = 31 * result + (nn != null ? nn.hashCode() : 0);
result = 31 * result + (oo != null ? oo.hashCode() : 0);
result = 31 * result + (pp != null ? pp.hashCode() : 0);
result = 31 * result + (qq != null ? qq.hashCode() : 0);
result = 31 * result + (rr != null ? rr.hashCode() : 0);
result = 31 * result + (ss != null ? ss.hashCode() : 0);
result = 31 * result + (tt != null ? tt.hashCode() : 0);
result = 31 * result + (uu != null ? uu.hashCode() : 0);
result = 31 * result + (vv != null ? vv.hashCode() : 0);
result = 31 * result + (ww != null ? ww.hashCode() : 0);
result = 31 * result + (xx != null ? xx.hashCode() : 0);
result = 31 * result + (yy != null ? yy.hashCode() : 0);
result = 31 * result + (zz != null ? zz.hashCode() : 0);
result = 31 * result + (a0 != null ? a0.hashCode() : 0);
result = 31 * result + (b0 != null ? b0.hashCode() : 0);
result = 31 * result + (c0 != null ? c0.hashCode() : 0);
result = 31 * result + (d0 != null ? d0.hashCode() : 0);
result = 31 * result + (e0 != null ? e0.hashCode() : 0);
result = 31 * result + (f0 != null ? f0.hashCode() : 0);
result = 31 * result + (g0 != null ? g0.hashCode() : 0);
result = 31 * result + (h0 != null ? h0.hashCode() : 0);
result = 31 * result + (i0 != null ? i0.hashCode() : 0);
result = 31 * result + (j0 != null ? j0.hashCode() : 0);
result = 31 * result + (k0 != null ? k0.hashCode() : 0);
return result;
}
}
}

142
test/dorkbox/network/kryo/CopyTest.java
View File

@ -1,142 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import java.util.ArrayList;
@SuppressWarnings({"rawtypes", "unchecked"})
public class CopyTest extends KryoTestCase {
@Override
protected void setUp () throws Exception {
super.setUp();
kryo.setRegistrationRequired(false);
}
public void testBasic () {
ArrayList test = new ArrayList();
test.add("one");
test.add("two");
test.add("three");
ArrayList copy = kryo.copy(test);
assertTrue(test != copy);
assertEquals(test, copy);
}
public void testNested () {
ArrayList test = new ArrayList();
test.add("one");
test.add("two");
test.add("three");
ArrayList test2 = new ArrayList();
test2.add(1);
test2.add(2f);
test2.add(3d);
test2.add((byte)4);
test2.add((short)5);
test.add(test2);
ArrayList copy = kryo.copy(test);
assertTrue(test != copy);
assertTrue(test.get(3) != copy.get(3));
assertEquals(test, copy);
}
public void testReferences () {
ArrayList test = new ArrayList();
test.add("one");
test.add("two");
test.add("three");
ArrayList test2 = new ArrayList();
test2.add(1);
test2.add(2f);
test2.add(3d);
test2.add((byte)4);
test2.add((short)5);
test.add(test2);
test.add(test2);
test.add(test2);
ArrayList copy = kryo.copy(test);
assertTrue(test != copy);
assertEquals(test, copy);
assertTrue(test.get(3) != copy.get(4));
assertTrue(copy.get(3) == copy.get(4));
assertTrue(copy.get(3) == copy.get(5));
}
public void testCircularReferences () {
ArrayList test = new ArrayList();
test.add("one");
test.add("two");
test.add("three");
test.add(test);
ArrayList copy = kryo.copy(test);
assertTrue(test != copy);
assertEquals(copy.get(0), "one");
assertEquals(copy.get(1), "two");
assertEquals(copy.get(2), "three");
assertTrue(copy.get(3) == copy);
Moo root = new Moo();
Moo moo1 = new Moo();
Moo moo2 = new Moo();
Moo moo3 = new Moo();
root.moo = moo1;
moo1.moo = moo2;
moo2.moo = moo3;
moo3.moo = root;
Moo root2 = kryo.copy(root);
assertTrue(root != root2);
assertTrue(root.moo != root2.moo);
assertTrue(root.moo.moo != root2.moo.moo);
assertTrue(root.moo.moo.moo != root2.moo.moo.moo);
assertTrue(root.moo.moo.moo.moo != root2.moo.moo.moo.moo);
assertTrue(root.moo.moo.moo.moo == root);
assertTrue(root2.moo.moo.moo.moo == root2);
}
public void testShallow () {
ArrayList test = new ArrayList();
test.add("one");
test.add("two");
test.add("three");
ArrayList test2 = new ArrayList();
test2.add(1);
test2.add(2f);
test2.add(3d);
test2.add((byte)4);
test2.add((short)5);
test.add(test2);
ArrayList copy = kryo.copyShallow(test);
assertTrue(test != copy);
assertTrue(test.get(3) == copy.get(3));
assertEquals(test, copy);
}
static public class Moo {
Moo moo;
}
}

310
test/dorkbox/network/kryo/DefaultSerializersTest.java
View File

@ -1,310 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.EnumSet;
import java.util.TimeZone;
/** @author Nathan Sweet <misc@n4te.com> */
public class DefaultSerializersTest extends KryoTestCase {
{
supportsCopy = true;
}
public void testBoolean () {
roundTrip(2, 2, true);
roundTrip(2, 2, false);
}
public void testByte () {
roundTrip(2, 2, (byte)1);
roundTrip(2, 2, (byte)125);
roundTrip(2, 2, (byte)-125);
}
public void testChar () {
roundTrip(3, 3, 'a');
roundTrip(3, 3, 'z');
}
public void testDouble () {
roundTrip(9, 9, 0d);
roundTrip(9, 9, 1234d);
roundTrip(9, 9, 1234.5678d);
}
public void testFloat () {
roundTrip(5, 5, 0f);
roundTrip(5, 5, 123f);
roundTrip(5, 5, 123.456f);
}
public void testInt () {
roundTrip(2, 5, 0);
roundTrip(2, 5, 63);
roundTrip(3, 5, 64);
roundTrip(3, 5, 127);
roundTrip(3, 5, 128);
roundTrip(3, 5, 8191);
roundTrip(4, 5, 8192);
roundTrip(4, 5, 16383);
roundTrip(4, 5, 16384);
roundTrip(5, 5, 2097151);
roundTrip(4, 5, 1048575);
roundTrip(5, 5, 134217727);
roundTrip(6, 5, 268435455);
roundTrip(6, 5, 134217728);
roundTrip(6, 5, 268435456);
roundTrip(2, 5, -64);
roundTrip(3, 5, -65);
roundTrip(3, 5, -8192);
roundTrip(4, 5, -1048576);
roundTrip(5, 5, -134217728);
roundTrip(6, 5, -134217729);
}
public void testLong () {
roundTrip(2, 9, 0l);
roundTrip(2, 9, 63l);
roundTrip(3, 9, 64l);
roundTrip(3, 9, 127l);
roundTrip(3, 9, 128l);
roundTrip(3, 9, 8191l);
roundTrip(4, 9, 8192l);
roundTrip(4, 9, 16383l);
roundTrip(4, 9, 16384l);
roundTrip(5, 9, 2097151l);
roundTrip(4, 9, 1048575l);
roundTrip(5, 9, 134217727l);
roundTrip(6, 9, 268435455l);
roundTrip(6, 9, 134217728l);
roundTrip(6, 9, 268435456l);
roundTrip(2, 9, -64l);
roundTrip(3, 9, -65l);
roundTrip(3, 9, -8192l);
roundTrip(4, 9, -1048576l);
roundTrip(5, 9, -134217728l);
roundTrip(6, 9, -134217729l);
roundTrip(10, 9, 2368365495612416452l);
roundTrip(10, 9, -2368365495612416452l);
}
public void testShort () {
roundTrip(3, 3, (short)0);
roundTrip(3, 3, (short)123);
roundTrip(3, 3, (short)123);
roundTrip(3, 3, (short)-123);
roundTrip(3, 3, (short)250);
roundTrip(3, 3, (short)123);
roundTrip(3, 3, (short)400);
}
public void testString () {
kryo = new Kryo();
kryo.setRegistrationRequired(true);
roundTrip(6, 6, "meow");
roundTrip(70, 70, "abcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdef");
kryo.setReferences(false);
roundTrip(5, 5, "meow");
roundTrip(3, 3, "a");
roundTrip(3, 3, "\n");
roundTrip(2, 2, "");
roundTrip(100, 100, "ABCDEFGHIJKLMNOPQRSTUVWXYZ\rabcdefghijklmnopqrstuvwxyz\n1234567890\t\"!`?'.,;:()[]{}<>|/@\\^$-%+=#_&~*");
roundTrip(21, 21, "abcdef\u00E1\u00E9\u00ED\u00F3\u00FA\u7C9F");
}
public void testNull () {
kryo = new Kryo();
kryo.setRegistrationRequired(true);
kryo.register(ArrayList.class);
roundTrip(1, 1, null);
testNull(Long.class);
testNull(ArrayList.class);
kryo.setReferences(false);
roundTrip(1, 1, null);
testNull(Long.class);
testNull(ArrayList.class);
}
@SuppressWarnings({"rawtypes", "unchecked"})
private void testNull (Class type) {
kryo.writeObjectOrNull(output, null, type);
input.setBuffer(output.toBytes());
Object object = kryo.readObjectOrNull(input, type);
assertNull(object);
}
public void testDateSerializer () {
kryo.register(Date.class);
roundTrip(10, 9, new Date(-1234567));
roundTrip(2, 9, new Date(0));
roundTrip(4, 9, new Date(1234567));
roundTrip(10, 9, new Date(-1234567));
}
public void testBigDecimalSerializer () {
kryo.register(BigDecimal.class);
roundTrip(5, 8, BigDecimal.valueOf(12345, 2));
}
public void testBigIntegerSerializer () {
kryo.register(BigInteger.class);
roundTrip(8, 8, BigInteger.valueOf(1270507903945L));
}
public void testEnumSerializer () {
kryo.register(TestEnum.class);
roundTrip(2, 2, TestEnum.a);
roundTrip(2, 2, TestEnum.b);
roundTrip(2, 2, TestEnum.c);
kryo = new Kryo();
kryo.setRegistrationRequired(false);
// 1 byte identifying it's a class name
// 1 byte for the class name id
// 57 bytes for the class name characters
// 1 byte for the reference id
// 1 byte for the enum value
// HACK offset by X from original because of changes in package name
roundTrip(61-packageOffset, 61-packageOffset, TestEnum.c);
}
public void testEnumSetSerializer () {
kryo.register(EnumSet.class);
kryo.register(TestEnum.class);
roundTrip(5, 8, EnumSet.of(TestEnum.a, TestEnum.c));
roundTrip(4, 7, EnumSet.of(TestEnum.a));
roundTrip(6, 9, EnumSet.allOf(TestEnum.class));
kryo = new Kryo();
kryo.setRegistrationRequired(false);
// HACK offset by X from original because of changes in package name
roundTrip(89-packageOffset, 92-packageOffset, EnumSet.of(TestEnum.a, TestEnum.c));
}
public void testEnumSerializerWithMethods () {
kryo.register(TestEnumWithMethods.class);
roundTrip(2, 2, TestEnumWithMethods.a);
roundTrip(2, 2, TestEnumWithMethods.b);
roundTrip(2, 2, TestEnumWithMethods.c);
kryo = new Kryo();
kryo.setRegistrationRequired(false);
// HACK offset by X from original because of changes in package name
roundTrip(76-packageOffset, 76-packageOffset, TestEnumWithMethods.c);
}
@SuppressWarnings({"rawtypes", "unchecked"})
public void testCollectionsMethods () {
kryo.setRegistrationRequired(false);
ArrayList test = new ArrayList();
test.add(Collections.EMPTY_LIST);
test.add(Collections.EMPTY_MAP);
test.add(Collections.EMPTY_SET);
test.add(Collections.singletonList("meow"));
test.add(Collections.singletonMap("moo", 1234));
test.add(Collections.singleton(12.34));
roundTrip(249, 251, test);
}
public void testCalendar () {
kryo.setRegistrationRequired(false);
Calendar calendar = Calendar.getInstance();
calendar.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles"));
calendar.set(1980, 7, 26, 12, 22, 46);
roundTrip(64, 73, calendar);
}
public void testClassSerializer() {
kryo.register(Class.class);
kryo.register(ArrayList.class);
kryo.setRegistrationRequired(false);
final Output out = new Output(1024);
kryo.writeObject(out, String.class);
kryo.writeObject(out, Integer.class);
kryo.writeObject(out, Short.class);
kryo.writeObject(out, Long.class);
kryo.writeObject(out, Double.class);
kryo.writeObject(out, Float.class);
kryo.writeObject(out, Boolean.class);
kryo.writeObject(out, Character.class);
kryo.writeObject(out, int.class);
kryo.writeObject(out, short.class);
kryo.writeObject(out, long.class);
kryo.writeObject(out, double.class);
kryo.writeObject(out, float.class);
kryo.writeObject(out, boolean.class);
kryo.writeObject(out, char.class);
kryo.writeObject(out, ArrayList.class);
kryo.writeObject(out, TestEnum.class);
final Input in = new Input(out.getBuffer());
assertEquals(String.class, kryo.readObject(in, Class.class));
assertEquals(Integer.class, kryo.readObject(in, Class.class));
assertEquals(Short.class, kryo.readObject(in, Class.class));
assertEquals(Long.class, kryo.readObject(in, Class.class));
assertEquals(Double.class, kryo.readObject(in, Class.class));
assertEquals(Float.class, kryo.readObject(in, Class.class));
assertEquals(Boolean.class, kryo.readObject(in, Class.class));
assertEquals(Character.class, kryo.readObject(in, Class.class));
assertEquals(int.class, kryo.readObject(in, Class.class));
assertEquals(short.class, kryo.readObject(in, Class.class));
assertEquals(long.class, kryo.readObject(in, Class.class));
assertEquals(double.class, kryo.readObject(in, Class.class));
assertEquals(float.class, kryo.readObject(in, Class.class));
assertEquals(boolean.class, kryo.readObject(in, Class.class));
assertEquals(char.class, kryo.readObject(in, Class.class));
assertEquals(ArrayList.class, kryo.readObject(in, Class.class));
assertEquals(TestEnum.class, kryo.readObject(in, Class.class));
}
public enum TestEnum {
a, b, c
}
public enum TestEnumWithMethods {
a {
},
b {
},
c {
}
}
}

100
test/dorkbox/network/kryo/DeflateSerializerTest.java
View File

@ -1,100 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import com.esotericsoftware.kryo.serializers.DefaultSerializers.StringSerializer;
import com.esotericsoftware.kryo.serializers.DeflateSerializer;
/** @author Nathan Sweet <misc@n4te.com> */
public class DeflateSerializerTest extends KryoTestCase {
public void testString () {
kryo.register(String.class, new DeflateSerializer(new StringSerializer()));
roundTrip(15, 15, "abcdefabcdefabcdefabcdefabcdefabcdefabcdef");
}
public void testGraph () {
kryo.register(Message.class);
kryo.register(MessageType.class);
kryo.register(ServerPhysicsUpdate.class, new DeflateSerializer(kryo.getDefaultSerializer(ServerPhysicsUpdate.class)));
ServerPhysicsUpdate physicsUpdate = new ServerPhysicsUpdate();
physicsUpdate.value = 1;
Message message = new Message();
message.type = MessageType.SERVER_UPDATE;
message.data = physicsUpdate;
roundTrip(8, 8, message);
}
public static class ServerPhysicsUpdate {
public int value;
public ServerPhysicsUpdate () {
}
public int hashCode () {
final int prime = 31;
int result = 1;
result = prime * result + value;
return result;
}
public boolean equals (Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
ServerPhysicsUpdate other = (ServerPhysicsUpdate)obj;
if (value != other.value) return false;
return true;
}
}
public static enum MessageType {
SERVER_UPDATE
}
public static class Message {
public MessageType type;
public Object data;
public Message () {
}
public int hashCode () {
final int prime = 31;
int result = 1;
result = prime * result + ((data == null) ? 0 : data.hashCode());
result = prime * result + ((type == null) ? 0 : type.hashCode());
return result;
}
public boolean equals (Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
Message other = (Message)obj;
if (data == null) {
if (other.data != null) return false;
} else if (!data.equals(other.data)) return false;
if (type != other.type) return false;
return true;
}
}
}

1477
test/dorkbox/network/kryo/FieldSerializerTest.java
View File

File diff suppressed because it is too large Load Diff

1014
test/dorkbox/network/kryo/InputOutputByteBufTest.java Normal file
View File

File diff suppressed because it is too large Load Diff

818
test/dorkbox/network/kryo/InputOutputTest.java
View File

@ -1,818 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.nio.ByteBuffer;
import java.util.Random;
import com.esotericsoftware.kryo.io.ByteBufferInputStream;
import com.esotericsoftware.kryo.io.ByteBufferOutputStream;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
/** @author Nathan Sweet <misc@n4te.com> */
@SuppressWarnings("resource")
public class InputOutputTest extends KryoTestCase {
public void testOutputStream () {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
Output output = new Output(buffer, 2);
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();
assertEquals(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.toByteArray());
output.close();
}
public void testInputStream () {
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};
ByteArrayInputStream buffer = new ByteArrayInputStream(bytes);
Input input = new Input(buffer, 2);
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);
assertEquals(bytes, temp2);
input.close();
input = new Input(bytes);
count = input.read(temp, 512, 512);
assertEquals(bytes.length, count);
temp2 = new byte[count];
System.arraycopy(temp, 512, temp2, 0, count);
assertEquals(bytes, temp2);
input.close();
}
public void testWriteBytes () {
Output buffer = new Output(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();
assertEquals(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());
buffer.close();
}
public void testStrings () {
runStringTest(new Output(4096));
runStringTest(new Output(897));
runStringTest(new Output(new ByteArrayOutputStream()));
Output write = new Output(21);
String value = "abcdef\u00E1\u00E9\u00ED\u00F3\u00FA\u1234";
write.writeString(value);
Input read = new Input(write.toBytes());
assertEquals(value, read.readString());
runStringTest(127);
runStringTest(256);
runStringTest(1024 * 1023);
runStringTest(1024 * 1024);
runStringTest(1024 * 1025);
runStringTest(1024 * 1026);
runStringTest(1024 * 1024 * 2);
write.close();
read.close();
}
public void runStringTest (int length) {
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);
Input read = new Input(write.toBytes());
assertEquals(value, read.readString());
assertEquals(value, read.readStringBuilder().toString());
read.close();
write.close();
write.clear();
write.writeString(buffer);
write.writeString(buffer);
read = new Input(write.toBytes());
assertEquals(value, read.readStringBuilder().toString());
assertEquals(value, read.readString());
if (length <= 127) {
write.clear();
write.writeAscii(value);
write.writeAscii(value);
read = new Input(write.toBytes());
assertEquals(value, read.readStringBuilder().toString());
assertEquals(value, read.readString());
}
}
public void runStringTest (Output write) {
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");
}
Input read = new Input(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());
assertEquals(null, 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.rewind();
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());
assertEquals(null, 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());
}
}
public void testCanReadInt () {
Output write = new Output(new ByteArrayOutputStream());
Input read = new Input(write.toBytes());
assertEquals(false, read.canReadInt());
write.writeInt(400, true);
read = new Input(write.toBytes());
assertEquals(true, read.canReadInt());
read.setLimit(read.limit() - 1);
assertEquals(false, read.canReadInt());
}
public void testInts () {
runIntTest(new Output(4096));
runIntTest(new Output(new ByteArrayOutputStream()));
}
private void runIntTest (Output write) {
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.writeInt(0, true));
assertEquals(1, write.writeInt(0, false));
assertEquals(1, write.writeInt(63, true));
assertEquals(1, write.writeInt(63, false));
assertEquals(1, write.writeInt(64, true));
assertEquals(2, write.writeInt(64, false));
assertEquals(1, write.writeInt(127, true));
assertEquals(2, write.writeInt(127, false));
assertEquals(2, write.writeInt(128, true));
assertEquals(2, write.writeInt(128, false));
assertEquals(2, write.writeInt(8191, true));
assertEquals(2, write.writeInt(8191, false));
assertEquals(2, write.writeInt(8192, true));
assertEquals(3, write.writeInt(8192, false));
assertEquals(2, write.writeInt(16383, true));
assertEquals(3, write.writeInt(16383, false));
assertEquals(3, write.writeInt(16384, true));
assertEquals(3, write.writeInt(16384, false));
assertEquals(3, write.writeInt(2097151, true));
assertEquals(4, write.writeInt(2097151, false));
assertEquals(3, write.writeInt(1048575, true));
assertEquals(3, write.writeInt(1048575, false));
assertEquals(4, write.writeInt(134217727, true));
assertEquals(4, write.writeInt(134217727, false));
assertEquals(4, write.writeInt(268435455, true));
assertEquals(5, write.writeInt(268435455, false));
assertEquals(4, write.writeInt(134217728, true));
assertEquals(5, write.writeInt(134217728, false));
assertEquals(5, write.writeInt(268435456, true));
assertEquals(5, write.writeInt(268435456, false));
assertEquals(1, write.writeInt(-64, false));
assertEquals(5, write.writeInt(-64, true));
assertEquals(2, write.writeInt(-65, false));
assertEquals(5, write.writeInt(-65, true));
assertEquals(2, write.writeInt(-8192, false));
assertEquals(5, write.writeInt(-8192, true));
assertEquals(3, write.writeInt(-1048576, false));
assertEquals(5, write.writeInt(-1048576, true));
assertEquals(4, write.writeInt(-134217728, false));
assertEquals(5, write.writeInt(-134217728, true));
assertEquals(5, write.writeInt(-134217729, false));
assertEquals(5, write.writeInt(-134217729, true));
Input read = new Input(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());
assertEquals(true, read.canReadInt());
assertEquals(true, read.canReadInt());
assertEquals(true, read.canReadInt());
assertEquals(0, read.readInt(true));
assertEquals(0, read.readInt(false));
assertEquals(63, read.readInt(true));
assertEquals(63, read.readInt(false));
assertEquals(64, read.readInt(true));
assertEquals(64, read.readInt(false));
assertEquals(127, read.readInt(true));
assertEquals(127, read.readInt(false));
assertEquals(128, read.readInt(true));
assertEquals(128, read.readInt(false));
assertEquals(8191, read.readInt(true));
assertEquals(8191, read.readInt(false));
assertEquals(8192, read.readInt(true));
assertEquals(8192, read.readInt(false));
assertEquals(16383, read.readInt(true));
assertEquals(16383, read.readInt(false));
assertEquals(16384, read.readInt(true));
assertEquals(16384, read.readInt(false));
assertEquals(2097151, read.readInt(true));
assertEquals(2097151, read.readInt(false));
assertEquals(1048575, read.readInt(true));
assertEquals(1048575, read.readInt(false));
assertEquals(134217727, read.readInt(true));
assertEquals(134217727, read.readInt(false));
assertEquals(268435455, read.readInt(true));
assertEquals(268435455, read.readInt(false));
assertEquals(134217728, read.readInt(true));
assertEquals(134217728, read.readInt(false));
assertEquals(268435456, read.readInt(true));
assertEquals(268435456, read.readInt(false));
assertEquals(-64, read.readInt(false));
assertEquals(-64, read.readInt(true));
assertEquals(-65, read.readInt(false));
assertEquals(-65, read.readInt(true));
assertEquals(-8192, read.readInt(false));
assertEquals(-8192, read.readInt(true));
assertEquals(-1048576, read.readInt(false));
assertEquals(-1048576, read.readInt(true));
assertEquals(-134217728, read.readInt(false));
assertEquals(-134217728, read.readInt(true));
assertEquals(-134217729, read.readInt(false));
assertEquals(-134217729, read.readInt(true));
assertEquals(false, read.canReadInt());
Random random = new Random();
for (int i = 0; i < 10000; i++) {
int value = random.nextInt();
write.clear();
write.writeInt(value);
write.writeInt(value, true);
write.writeInt(value, false);
read.setBuffer(write.toBytes());
assertEquals(value, read.readInt());
assertEquals(value, read.readInt(true));
assertEquals(value, read.readInt(false));
}
}
public void testLongs () {
runLongTest(new Output(4096));
runLongTest(new Output(new ByteArrayOutputStream()));
}
private void runLongTest (Output write) {
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.writeLong(0, true));
assertEquals(1, write.writeLong(0, false));
assertEquals(1, write.writeLong(63, true));
assertEquals(1, write.writeLong(63, false));
assertEquals(1, write.writeLong(64, true));
assertEquals(2, write.writeLong(64, false));
assertEquals(1, write.writeLong(127, true));
assertEquals(2, write.writeLong(127, false));
assertEquals(2, write.writeLong(128, true));
assertEquals(2, write.writeLong(128, false));
assertEquals(2, write.writeLong(8191, true));
assertEquals(2, write.writeLong(8191, false));
assertEquals(2, write.writeLong(8192, true));
assertEquals(3, write.writeLong(8192, false));
assertEquals(2, write.writeLong(16383, true));
assertEquals(3, write.writeLong(16383, false));
assertEquals(3, write.writeLong(16384, true));
assertEquals(3, write.writeLong(16384, false));
assertEquals(3, write.writeLong(2097151, true));
assertEquals(4, write.writeLong(2097151, false));
assertEquals(3, write.writeLong(1048575, true));
assertEquals(3, write.writeLong(1048575, false));
assertEquals(4, write.writeLong(134217727, true));
assertEquals(4, write.writeLong(134217727, false));
assertEquals(4, write.writeLong(268435455l, true));
assertEquals(5, write.writeLong(268435455l, false));
assertEquals(4, write.writeLong(134217728l, true));
assertEquals(5, write.writeLong(134217728l, false));
assertEquals(5, write.writeLong(268435456l, true));
assertEquals(5, write.writeLong(268435456l, false));
assertEquals(1, write.writeLong(-64, false));
assertEquals(9, write.writeLong(-64, true));
assertEquals(2, write.writeLong(-65, false));
assertEquals(9, write.writeLong(-65, true));
assertEquals(2, write.writeLong(-8192, false));
assertEquals(9, write.writeLong(-8192, true));
assertEquals(3, write.writeLong(-1048576, false));
assertEquals(9, write.writeLong(-1048576, true));
assertEquals(4, write.writeLong(-134217728, false));
assertEquals(9, write.writeLong(-134217728, true));
assertEquals(5, write.writeLong(-134217729, false));
assertEquals(9, write.writeLong(-134217729, true));
Input read = new Input(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.readLong(true));
assertEquals(0, read.readLong(false));
assertEquals(63, read.readLong(true));
assertEquals(63, read.readLong(false));
assertEquals(64, read.readLong(true));
assertEquals(64, read.readLong(false));
assertEquals(127, read.readLong(true));
assertEquals(127, read.readLong(false));
assertEquals(128, read.readLong(true));
assertEquals(128, read.readLong(false));
assertEquals(8191, read.readLong(true));
assertEquals(8191, read.readLong(false));
assertEquals(8192, read.readLong(true));
assertEquals(8192, read.readLong(false));
assertEquals(16383, read.readLong(true));
assertEquals(16383, read.readLong(false));
assertEquals(16384, read.readLong(true));
assertEquals(16384, read.readLong(false));
assertEquals(2097151, read.readLong(true));
assertEquals(2097151, read.readLong(false));
assertEquals(1048575, read.readLong(true));
assertEquals(1048575, read.readLong(false));
assertEquals(134217727, read.readLong(true));
assertEquals(134217727, read.readLong(false));
assertEquals(268435455, read.readLong(true));
assertEquals(268435455, read.readLong(false));
assertEquals(134217728, read.readLong(true));
assertEquals(134217728, read.readLong(false));
assertEquals(268435456, read.readLong(true));
assertEquals(268435456, read.readLong(false));
assertEquals(-64, read.readLong(false));
assertEquals(-64, read.readLong(true));
assertEquals(-65, read.readLong(false));
assertEquals(-65, read.readLong(true));
assertEquals(-8192, read.readLong(false));
assertEquals(-8192, read.readLong(true));
assertEquals(-1048576, read.readLong(false));
assertEquals(-1048576, read.readLong(true));
assertEquals(-134217728, read.readLong(false));
assertEquals(-134217728, read.readLong(true));
assertEquals(-134217729, read.readLong(false));
assertEquals(-134217729, read.readLong(true));
Random random = new Random();
for (int i = 0; i < 10000; i++) {
long value = random.nextLong();
write.clear();
write.writeLong(value);
write.writeLong(value, true);
write.writeLong(value, false);
read.setBuffer(write.toBytes());
assertEquals(value, read.readLong());
assertEquals(value, read.readLong(true));
assertEquals(value, read.readLong(false));
}
}
public void testShorts () {
runShortTest(new Output(4096));
runShortTest(new Output(new ByteArrayOutputStream()));
}
private void runShortTest (Output write) {
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);
Input read = new Input(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());
}
public void testFloats () {
runFloatTest(new Output(4096));
runFloatTest(new Output(new ByteArrayOutputStream()));
}
private void runFloatTest (Output write) {
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.writeFloat(0, 1000, true));
assertEquals(1, write.writeFloat(0, 1000, false));
assertEquals(3, write.writeFloat(63, 1000, true));
assertEquals(3, write.writeFloat(63, 1000, false));
assertEquals(3, write.writeFloat(64, 1000, true));
assertEquals(3, write.writeFloat(64, 1000, false));
assertEquals(3, write.writeFloat(127, 1000, true));
assertEquals(3, write.writeFloat(127, 1000, false));
assertEquals(3, write.writeFloat(128, 1000, true));
assertEquals(3, write.writeFloat(128, 1000, false));
assertEquals(4, write.writeFloat(8191, 1000, true));
assertEquals(4, write.writeFloat(8191, 1000, false));
assertEquals(4, write.writeFloat(8192, 1000, true));
assertEquals(4, write.writeFloat(8192, 1000, false));
assertEquals(4, write.writeFloat(16383, 1000, true));
assertEquals(4, write.writeFloat(16383, 1000, false));
assertEquals(4, write.writeFloat(16384, 1000, true));
assertEquals(4, write.writeFloat(16384, 1000, false));
assertEquals(4, write.writeFloat(32767, 1000, true));
assertEquals(4, write.writeFloat(32767, 1000, false));
assertEquals(3, write.writeFloat(-64, 1000, false));
assertEquals(5, write.writeFloat(-64, 1000, true));
assertEquals(3, write.writeFloat(-65, 1000, false));
assertEquals(5, write.writeFloat(-65, 1000, true));
assertEquals(4, write.writeFloat(-8192, 1000, false));
assertEquals(5, write.writeFloat(-8192, 1000, true));
Input read = new Input(write.toBytes());
assertEquals(read.readFloat(), 0f);
assertEquals(read.readFloat(), 63f);
assertEquals(read.readFloat(), 64f);
assertEquals(read.readFloat(), 127f);
assertEquals(read.readFloat(), 128f);
assertEquals(read.readFloat(), 8192f);
assertEquals(read.readFloat(), 16384f);
assertEquals(read.readFloat(), 32767f);
assertEquals(read.readFloat(), -63f);
assertEquals(read.readFloat(), -64f);
assertEquals(read.readFloat(), -127f);
assertEquals(read.readFloat(), -128f);
assertEquals(read.readFloat(), -8192f);
assertEquals(read.readFloat(), -16384f);
assertEquals(read.readFloat(), -32768f);
assertEquals(read.readFloat(1000, true), 0f);
assertEquals(read.readFloat(1000, false), 0f);
assertEquals(read.readFloat(1000, true), 63f);
assertEquals(read.readFloat(1000, false), 63f);
assertEquals(read.readFloat(1000, true), 64f);
assertEquals(read.readFloat(1000, false), 64f);
assertEquals(read.readFloat(1000, true), 127f);
assertEquals(read.readFloat(1000, false), 127f);
assertEquals(read.readFloat(1000, true), 128f);
assertEquals(read.readFloat(1000, false), 128f);
assertEquals(read.readFloat(1000, true), 8191f);
assertEquals(read.readFloat(1000, false), 8191f);
assertEquals(read.readFloat(1000, true), 8192f);
assertEquals(read.readFloat(1000, false), 8192f);
assertEquals(read.readFloat(1000, true), 16383f);
assertEquals(read.readFloat(1000, false), 16383f);
assertEquals(read.readFloat(1000, true), 16384f);
assertEquals(read.readFloat(1000, false), 16384f);
assertEquals(read.readFloat(1000, true), 32767f);
assertEquals(read.readFloat(1000, false), 32767f);
assertEquals(read.readFloat(1000, false), -64f);
assertEquals(read.readFloat(1000, true), -64f);
assertEquals(read.readFloat(1000, false), -65f);
assertEquals(read.readFloat(1000, true), -65f);
assertEquals(read.readFloat(1000, false), -8192f);
assertEquals(read.readFloat(1000, true), -8192f);
}
public void testDoubles () {
runDoubleTest(new Output(4096));
runDoubleTest(new Output(new ByteArrayOutputStream()));
}
private void runDoubleTest (Output write) {
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.writeDouble(0, 1000, true));
assertEquals(1, write.writeDouble(0, 1000, false));
assertEquals(3, write.writeDouble(63, 1000, true));
assertEquals(3, write.writeDouble(63, 1000, false));
assertEquals(3, write.writeDouble(64, 1000, true));
assertEquals(3, write.writeDouble(64, 1000, false));
assertEquals(3, write.writeDouble(127, 1000, true));
assertEquals(3, write.writeDouble(127, 1000, false));
assertEquals(3, write.writeDouble(128, 1000, true));
assertEquals(3, write.writeDouble(128, 1000, false));
assertEquals(4, write.writeDouble(8191, 1000, true));
assertEquals(4, write.writeDouble(8191, 1000, false));
assertEquals(4, write.writeDouble(8192, 1000, true));
assertEquals(4, write.writeDouble(8192, 1000, false));
assertEquals(4, write.writeDouble(16383, 1000, true));
assertEquals(4, write.writeDouble(16383, 1000, false));
assertEquals(4, write.writeDouble(16384, 1000, true));
assertEquals(4, write.writeDouble(16384, 1000, false));
assertEquals(4, write.writeDouble(32767, 1000, true));
assertEquals(4, write.writeDouble(32767, 1000, false));
assertEquals(3, write.writeDouble(-64, 1000, false));
assertEquals(9, write.writeDouble(-64, 1000, true));
assertEquals(3, write.writeDouble(-65, 1000, false));
assertEquals(9, write.writeDouble(-65, 1000, true));
assertEquals(4, write.writeDouble(-8192, 1000, false));
assertEquals(9, write.writeDouble(-8192, 1000, true));
write.writeDouble(1.23456d);
Input read = new Input(write.toBytes());
assertEquals(read.readDouble(), 0d);
assertEquals(read.readDouble(), 63d);
assertEquals(read.readDouble(), 64d);
assertEquals(read.readDouble(), 127d);
assertEquals(read.readDouble(), 128d);
assertEquals(read.readDouble(), 8192d);
assertEquals(read.readDouble(), 16384d);
assertEquals(read.readDouble(), 32767d);
assertEquals(read.readDouble(), -63d);
assertEquals(read.readDouble(), -64d);
assertEquals(read.readDouble(), -127d);
assertEquals(read.readDouble(), -128d);
assertEquals(read.readDouble(), -8192d);
assertEquals(read.readDouble(), -16384d);
assertEquals(read.readDouble(), -32768d);
assertEquals(read.readDouble(1000, true), 0d);
assertEquals(read.readDouble(1000, false), 0d);
assertEquals(read.readDouble(1000, true), 63d);
assertEquals(read.readDouble(1000, false), 63d);
assertEquals(read.readDouble(1000, true), 64d);
assertEquals(read.readDouble(1000, false), 64d);
assertEquals(read.readDouble(1000, true), 127d);
assertEquals(read.readDouble(1000, false), 127d);
assertEquals(read.readDouble(1000, true), 128d);
assertEquals(read.readDouble(1000, false), 128d);
assertEquals(read.readDouble(1000, true), 8191d);
assertEquals(read.readDouble(1000, false), 8191d);
assertEquals(read.readDouble(1000, true), 8192d);
assertEquals(read.readDouble(1000, false), 8192d);
assertEquals(read.readDouble(1000, true), 16383d);
assertEquals(read.readDouble(1000, false), 16383d);
assertEquals(read.readDouble(1000, true), 16384d);
assertEquals(read.readDouble(1000, false), 16384d);
assertEquals(read.readDouble(1000, true), 32767d);
assertEquals(read.readDouble(1000, false), 32767d);
assertEquals(read.readDouble(1000, false), -64d);
assertEquals(read.readDouble(1000, true), -64d);
assertEquals(read.readDouble(1000, false), -65d);
assertEquals(read.readDouble(1000, true), -65d);
assertEquals(read.readDouble(1000, false), -8192d);
assertEquals(read.readDouble(1000, true), -8192d);
assertEquals(1.23456d, read.readDouble());
}
public void testBooleans () {
runBooleanTest(new Output(4096));
runBooleanTest(new Output(new ByteArrayOutputStream()));
}
private void runBooleanTest (Output write) {
for (int i = 0; i < 100; i++) {
write.writeBoolean(true);
write.writeBoolean(false);
}
Input read = new Input(write.toBytes());
for (int i = 0; i < 100; i++) {
assertEquals(true, read.readBoolean());
assertEquals(false, read.readBoolean());
}
}
public void testChars () {
runCharTest(new Output(4096));
runCharTest(new Output(new ByteArrayOutputStream()));
}
private void runCharTest (Output write) {
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);
Input read = new Input(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());
}
public void testInputWithOffset () throws Exception {
final byte[] buf = new byte[30];
final Input in = new Input(buf, 10, 10);
assertEquals(10, in.available());
in.close();
}
public void testSmallBuffers() throws Exception {
ByteBuffer buf = ByteBuffer.allocate(1024);
ByteBufferOutputStream byteBufferOutputStream = new ByteBufferOutputStream(buf);
Output testOutput = new Output(byteBufferOutputStream);
testOutput.writeBytes(new byte[512]);
testOutput.writeBytes(new byte[512]);
testOutput.flush();
ByteBufferInputStream testInputs = new ByteBufferInputStream();
buf.flip();
testInputs.setByteBuffer(buf);
Input input = new Input(testInputs, 512);
byte[] toRead = new byte[512];
input.readBytes(toRead);
input.readBytes(toRead);
testOutput.close();
input.close();
}
}

78
test/dorkbox/network/kryo/JavaSerializerTest.java
View File

@ -1,78 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import com.esotericsoftware.kryo.serializers.JavaSerializer;
import java.io.Serializable;
/** @author Nathan Sweet <misc@n4te.com> */
public class JavaSerializerTest extends KryoTestCase {
public void testJavaSerializer () {
kryo.register(String.class, new JavaSerializer());
roundTrip(50, 50, "abcdefabcdefabcdefabcdefabcdefabcdefabcdef");
roundTrip(12, 12, "meow");
kryo.register(TestClass.class, new JavaSerializer());
TestClass test = new TestClass();
test.stringField = "fubar";
test.intField = 54321;
// HACK offset by ? from original because of changes in package name
roundTrip(134-packageOffset, 134-packageOffset, test);
roundTrip(134-packageOffset, 134-packageOffset, test);
roundTrip(134-packageOffset, 134-packageOffset, test);
}
@SuppressWarnings("serial")
static public class TestClass implements Serializable {
String stringField;
int intField;
@Override
public boolean equals (Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
TestClass other = (TestClass)obj;
if (intField != other.intField) {
return false;
}
if (stringField == null) {
if (other.stringField != null) {
return false;
}
} else if (!stringField.equals(other.stringField)) {
return false;
}
return true;
}
@Override
public int hashCode() {
return super.hashCode();
}
}
}

21
test/dorkbox/network/kryo/KryoAssert.java Normal file
View File

@ -0,0 +1,21 @@
package dorkbox.network.kryo;
import static org.junit.Assert.*;
/**
* Junit Assert wrapper methods class
*/
public class KryoAssert {
private KryoAssert() {
}
public static void assertDoubleEquals(double expected, double actual) {
assertEquals(expected, actual, 0.0);
}
public static void assertFloatEquals(float expected, double actual) {
assertEquals(expected, actual, 0.0);
}
}

319
test/dorkbox/network/kryo/KryoTestCase.java
View File

@ -1,4 +1,4 @@
/* Copyright (c) 2008, Nathan Sweet
/* 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
@ -15,40 +15,41 @@
* 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 dorkbox.network.kryo;
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.joran.JoranConfigurator;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.Serializer;
import com.esotericsoftware.kryo.io.*;
import junit.framework.TestCase;
import org.junit.Assert;
import org.slf4j.LoggerFactory;
package dorkbox.network.kryo;
import static com.esotericsoftware.minlog.Log.WARN;
import static com.esotericsoftware.minlog.Log.warn;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.nio.ByteBuffer;
import java.util.ArrayList;
/**
* Convenience methods for round tripping objects.
*
* @author Nathan Sweet <misc@n4te.com>
*/
import org.junit.Before;
@SuppressWarnings({"rawtypes", "unchecked"})
abstract public class KryoTestCase extends TestCase {
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.Serializer;
import com.esotericsoftware.kryo.io.ByteBufferInput;
import com.esotericsoftware.kryo.io.ByteBufferOutput;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.unsafe.UnsafeByteBufferInput;
import com.esotericsoftware.kryo.unsafe.UnsafeByteBufferOutput;
import com.esotericsoftware.kryo.unsafe.UnsafeInput;
import com.esotericsoftware.kryo.unsafe.UnsafeOutput;
public static final int ORIGINAL_PACKAGE_LENGTH = "com.esotericsoftware.kryo".length();
// HACK offset by 5 from original because of changes in package name + 5 because it has ANOTHER subclass
protected int packageOffset = ORIGINAL_PACKAGE_LENGTH - this.getClass().getPackage().getName().length();
/** Convenience methods for round tripping objects.
* @author Nathan Sweet */
abstract public class KryoTestCase {
// When true, roundTrip will only do a single write/read to make debugging easier (breaks some tests).
static private final boolean debug = false;
protected Kryo kryo;
protected Output output;
@ -56,175 +57,128 @@ abstract public class KryoTestCase extends TestCase {
protected Object object1, object2;
protected boolean supportsCopy;
static interface StreamFactory {
Output createOutput(OutputStream os);
static interface BufferFactory {
public Output createOutput(OutputStream os);
Output createOutput(OutputStream os, int size);
public Output createOutput(OutputStream os, int size);
Output createOutput(int size, int limit);
public Output createOutput(int size, int limit);
Input createInput(InputStream os, int size);
public Input createInput(InputStream os, int size);
Input createInput(byte[] buffer);
public Input createInput(byte[] buffer);
}
@Override
protected void setUp() throws Exception {
// assume SLF4J is bound to logback in the current environment
Logger rootLogger = (Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
LoggerContext context = rootLogger.getLoggerContext();
JoranConfigurator jc = new JoranConfigurator();
jc.setContext(context);
context.reset(); // override default configuration
rootLogger.setLevel(Level.TRACE);
@Before
public void setUp () throws Exception {
if (debug && WARN) warn("*** DEBUG TEST ***");
kryo = new Kryo();
kryo.setReferences(false);
kryo.setRegistrationRequired(true);
// kryo.setAsmEnabled(false);
}
public <T> T roundTrip(int length, int unsafeLength, T object1) {
roundTripWithStreamFactory(unsafeLength, object1, new StreamFactory() {
@Override
public Output createOutput(OutputStream os) {
return new UnsafeMemoryOutput(os);
/** @param length Pass Integer.MIN_VALUE to disable checking the length. */
public <T> T roundTrip (int length, T object1) {
T object2 = roundTripWithBufferFactory(length, object1, new BufferFactory() {
public Output createOutput (OutputStream os) {
return new Output(os);
}
@Override
public Output createOutput(OutputStream os, int size) {
return new UnsafeMemoryOutput(os, size);
public Output createOutput (OutputStream os, int size) {
return new Output(os, size);
}
@Override
public Output createOutput(int size, int limit) {
return new UnsafeMemoryOutput(size, limit);
public Output createOutput (int size, int limit) {
return new Output(size, limit);
}
@Override
public Input createInput(InputStream os, int size) {
return new UnsafeMemoryInput(os, size);
public Input createInput (InputStream os, int size) {
return new Input(os, size);
}
@Override
public Input createInput(byte[] buffer) {
return new UnsafeMemoryInput(buffer);
public Input createInput (byte[] buffer) {
return new Input(buffer);
}
});
roundTripWithStreamFactory(unsafeLength, object1, new StreamFactory() {
@Override
public Output createOutput(OutputStream os) {
if (debug) return object2;
roundTripWithBufferFactory(length, object1, new BufferFactory() {
public Output createOutput (OutputStream os) {
return new ByteBufferOutput(os);
}
public Output createOutput (OutputStream os, int size) {
return new ByteBufferOutput(os, size);
}
public Output createOutput (int size, int limit) {
return new ByteBufferOutput(size, limit);
}
public Input createInput (InputStream os, int size) {
return new ByteBufferInput(os, size);
}
public Input createInput (byte[] buffer) {
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(buffer.length);
byteBuffer.put(buffer).flip();
return new ByteBufferInput(byteBuffer);
}
});
roundTripWithBufferFactory(length, object1, new BufferFactory() {
public Output createOutput (OutputStream os) {
return new UnsafeOutput(os);
}
@Override
public Output createOutput(OutputStream os, int size) {
public Output createOutput (OutputStream os, int size) {
return new UnsafeOutput(os, size);
}
@Override
public Output createOutput(int size, int limit) {
public Output createOutput (int size, int limit) {
return new UnsafeOutput(size, limit);
}
@Override
public Input createInput(InputStream os, int size) {
public Input createInput (InputStream os, int size) {
return new UnsafeInput(os, size);
}
@Override
public Input createInput(byte[] buffer) {
public Input createInput (byte[] buffer) {
return new UnsafeInput(buffer);
}
});
roundTripWithStreamFactory(length, object1, new StreamFactory() {
@Override
public Output createOutput(OutputStream os) {
return new ByteBufferOutput(os);
roundTripWithBufferFactory(length, object1, new BufferFactory() {
public Output createOutput (OutputStream os) {
return new UnsafeByteBufferOutput(os);
}
@Override
public Output createOutput(OutputStream os, int size) {
return new ByteBufferOutput(os, size);
public Output createOutput (OutputStream os, int size) {
return new UnsafeByteBufferOutput(os, size);
}
@Override
public Output createOutput(int size, int limit) {
return new ByteBufferOutput(size, limit);
public Output createOutput (int size, int limit) {
return new UnsafeByteBufferOutput(size, limit);
}
@Override
public Input createInput(InputStream os, int size) {
return new ByteBufferInput(os, size);
public Input createInput (InputStream os, int size) {
return new UnsafeByteBufferInput(os, size);
}
@Override
public Input createInput(byte[] buffer) {
return new ByteBufferInput(buffer);
public Input createInput (byte[] buffer) {
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(buffer.length);
byteBuffer.put(buffer).flip();
return new UnsafeByteBufferInput(byteBuffer);
}
});
roundTripWithStreamFactory(unsafeLength, object1, new StreamFactory() {
@Override
public Output createOutput(OutputStream os) {
return new FastOutput(os);
}
@Override
public Output createOutput(OutputStream os, int size) {
return new FastOutput(os, size);
}
@Override
public Output createOutput(int size, int limit) {
return new FastOutput(size, limit);
}
@Override
public Input createInput(InputStream os, int size) {
return new FastInput(os, size);
}
@Override
public Input createInput(byte[] buffer) {
return new FastInput(buffer);
}
});
return roundTripWithStreamFactory(length, object1, new StreamFactory() {
@Override
public Output createOutput(OutputStream os) {
return new Output(os);
}
@Override
public Output createOutput(OutputStream os, int size) {
return new Output(os, size);
}
@Override
public Output createOutput(int size, int limit) {
return new Output(size, limit);
}
@Override
public Input createInput(InputStream os, int size) {
return new Input(os, size);
}
@Override
public Input createInput(byte[] buffer) {
return new Input(buffer);
}
});
return object2;
}
public <T> T roundTripWithStreamFactory(int length, T object1,
StreamFactory sf) {
/** @param length Pass Integer.MIN_VALUE to disable checking the length. */
public <T> T roundTripWithBufferFactory (int length, T object1, BufferFactory sf) {
boolean checkLength = length != Integer.MIN_VALUE;
this.object1 = object1;
// Test output to stream, large buffer.
@ -233,15 +187,19 @@ abstract public class KryoTestCase extends TestCase {
kryo.writeClassAndObject(output, object1);
output.flush();
if (debug) System.out.println();
// Test input from stream, large buffer.
@SuppressWarnings("unused")
byte[] out = outStream.toByteArray();
input = sf.createInput(
new ByteArrayInputStream(outStream.toByteArray()), 4096);
byte[] out = outStream.toByteArray();
input = sf.createInput(new ByteArrayInputStream(outStream.toByteArray()), 4096);
object2 = kryo.readClassAndObject(input);
assertEquals("Incorrect number of bytes read.", length, input.total());
assertEquals("Incorrect number of bytes written.", length, output.total());
assertEquals(object1, object2);
doAssertEquals(object1, object2);
if (checkLength) {
assertEquals("Incorrect number of bytes read.", length, input.total());
assertEquals("Incorrect number of bytes written.", length, output.total());
}
if (debug) return (T)object2;
// Test output to stream, small buffer.
outStream = new ByteArrayOutputStream();
@ -250,30 +208,25 @@ abstract public class KryoTestCase extends TestCase {
output.flush();
// Test input from stream, small buffer.
input = sf.createInput(
new ByteArrayInputStream(outStream.toByteArray()), 10);
input = sf.createInput(new ByteArrayInputStream(outStream.toByteArray()), 10);
object2 = kryo.readClassAndObject(input);
assertEquals("Incorrect number of bytes read.", length, input.total());
assertEquals(object1, object2);
doAssertEquals(object1, object2);
if (checkLength) assertEquals("Incorrect number of bytes read.", length, input.total());
if (object1 != null) {
// Test null with serializer.
Serializer serializer = kryo.getRegistration(object1.getClass())
.getSerializer();
output.clear();
Serializer serializer = kryo.getRegistration(object1.getClass()).getSerializer();
output.reset();
outStream.reset();
kryo.writeObjectOrNull(output, null, serializer);
output.flush();
// Test null from byte array with and without serializer.
input = sf.createInput(
new ByteArrayInputStream(outStream.toByteArray()), 10);
assertEquals(null, kryo.readObjectOrNull(input, object1.getClass(),
serializer));
input = sf.createInput(new ByteArrayInputStream(outStream.toByteArray()), 10);
assertNull(kryo.readObjectOrNull(input, object1.getClass(), serializer));
input = sf.createInput(
new ByteArrayInputStream(outStream.toByteArray()), 10);
assertEquals(null, kryo.readObjectOrNull(input, object1.getClass()));
input = sf.createInput(new ByteArrayInputStream(outStream.toByteArray()), 10);
assertNull(kryo.readObjectOrNull(input, object1.getClass()));
}
// Test output to byte array.
@ -284,42 +237,40 @@ abstract public class KryoTestCase extends TestCase {
// Test input from byte array.
input = sf.createInput(output.toBytes());
object2 = kryo.readClassAndObject(input);
assertEquals(object1, object2);
assertEquals("Incorrect length.", length, output.total());
assertEquals("Incorrect number of bytes read.", length, input.total());
input.rewind();
doAssertEquals(object1, object2);
if (checkLength) {
assertEquals("Incorrect length.", length, output.total());
assertEquals("Incorrect number of bytes read.", length, input.total());
}
input.reset();
if (supportsCopy) {
// Test copy.
T copy = kryo.copy(object1);
assertEquals(object1, copy);
doAssertEquals(object1, copy);
copy = kryo.copyShallow(object1);
assertEquals(object1, copy);
doAssertEquals(object1, copy);
}
return (T) object2;
return (T)object2;
}
static public void assertEquals(Object object1, Object object2) {
Assert.assertEquals(arrayToList(object1), arrayToList(object2));
protected void doAssertEquals (Object object1, Object object2) {
assertEquals(arrayToList(object1), arrayToList(object2));
}
static public Object arrayToList(Object array) {
if (array == null || !array.getClass().isArray()) {
return array;
}
static public Object arrayToList (Object array) {
if (array == null || !array.getClass().isArray()) return array;
ArrayList list = new ArrayList(Array.getLength(array));
for (int i = 0, n = Array.getLength(array); i < n; i++) {
list.add(arrayToList(Array.get(array, i)));
}
for (int i = 0, n = Array.getLength(array); i < n; i++)
list.add(arrayToList(Array.get(array, i)));
return list;
}
static public ArrayList list(Object... items) {
static public ArrayList list (Object... items) {
ArrayList list = new ArrayList();
for (Object item : items) {
list.add(item);
}
for (Object item : items)
list.add(item);
return list;
}
}

151
test/dorkbox/network/kryo/MapSerializerTest.java
View File

@ -1,151 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.serializers.MapSerializer;
import org.junit.Assert;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Random;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
/** @author Nathan Sweet <misc@n4te.com> */
public class MapSerializerTest extends KryoTestCase {
{
supportsCopy = true;
}
@SuppressWarnings({"rawtypes","unchecked"})
public void testMaps () {
kryo.register(HashMap.class);
kryo.register(LinkedHashMap.class);
HashMap map = new HashMap();
map.put("123", "456");
map.put("789", "abc");
roundTrip(18, 21, map);
roundTrip(2, 5, new LinkedHashMap());
roundTrip(18, 21, new LinkedHashMap(map));
MapSerializer serializer = new MapSerializer();
kryo.register(HashMap.class, serializer);
kryo.register(LinkedHashMap.class, serializer);
serializer.setKeyClass(String.class, kryo.getSerializer(String.class));
serializer.setKeysCanBeNull(false);
serializer.setValueClass(String.class, kryo.getSerializer(String.class));
roundTrip(14, 17, map);
serializer.setValuesCanBeNull(false);
roundTrip(14, 17, map);
}
public void testEmptyHashMap () {
execute(new HashMap<Object, Object>(), 0);
}
public void testNotEmptyHashMap () {
execute(new HashMap<Object, Object>(), 1000);
}
public void testEmptyConcurrentHashMap () {
execute(new ConcurrentHashMap<Object, Object>(), 0);
}
public void testNotEmptyConcurrentHashMap () {
execute(new ConcurrentHashMap<Object, Object>(), 1000);
}
public void testGenerics () {
kryo.register(HasGenerics.class);
kryo.register(Integer[].class);
kryo.register(HashMap.class);
HasGenerics test = new HasGenerics();
test.map.put("moo", new Integer[] {1, 2});
output = new Output(4096);
kryo.writeClassAndObject(output, test);
output.flush();
input = new Input(output.toBytes());
HasGenerics test2 = (HasGenerics)kryo.readClassAndObject(input);
assertEquals(test.map.get("moo"), test2.map.get("moo"));
}
private void execute (Map<Object, Object> map, int inserts) {
Random random = new Random();
for (int i = 0; i < inserts; i++) {
map.put(random.nextLong(), random.nextBoolean());
}
Kryo kryo = new Kryo();
kryo.register(HashMap.class, new MapSerializer());
kryo.register(ConcurrentHashMap.class, new MapSerializer());
Output output = new Output(2048, -1);
kryo.writeClassAndObject(output, map);
output.close();
Input input = new Input(output.toBytes());
Object deserialized = kryo.readClassAndObject(input);
input.close();
Assert.assertEquals(map, deserialized);
}
@SuppressWarnings({"unchecked","rawtypes"})
public void testTreeMap () {
kryo.register(TreeMap.class);
TreeMap map = new TreeMap();
map.put("123", "456");
map.put("789", "abc");
roundTrip(19, 22, map);
kryo.register(KeyThatIsntComparable.class);
kryo.register(KeyComparator.class);
map = new TreeMap(new KeyComparator());
KeyThatIsntComparable key = new KeyThatIsntComparable();
key.value = "123";
map.put(key, "456");
roundTrip(11, 14, map);
}
@SuppressWarnings({"unchecked","rawtypes"})
static public class HasGenerics {
public HashMap<String, Integer[]> map = new HashMap();
public HashMap<String, ?> map2 = new HashMap();
}
static public class KeyComparator implements Comparator<KeyThatIsntComparable> {
@Override
public int compare (KeyThatIsntComparable o1, KeyThatIsntComparable o2) {
return o1.value.compareTo(o2.value);
}
}
static public class KeyThatIsntComparable {
public String value;
}
}

184
test/dorkbox/network/kryo/ReferenceTest.java
View File

@ -1,184 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.Serializer;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.serializers.MapSerializer;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
@SuppressWarnings({"rawtypes", "unchecked"})
public class ReferenceTest extends KryoTestCase {
static public class Ordering {
public String order;
}
@SuppressWarnings("serial")
static public class Stuff extends TreeMap {
public Ordering ordering;
public Stuff (Ordering ordering) {
this.ordering = ordering;
}
}
public void testChildObjectBeforeReference () {
Ordering ordering = new Ordering();
ordering.order = "assbackwards";
Stuff stuff = new Stuff(ordering);
stuff.put("key", "value");
stuff.put("something", 456);
stuff.put("self", stuff);
Kryo kryo = new Kryo();
kryo.addDefaultSerializer(Stuff.class, new MapSerializer() {
@Override
public void write (Kryo kryo, Output output, Map object) {
kryo.writeObjectOrNull(output, ((Stuff)object).ordering, Ordering.class);
super.write(kryo, output, object);
}
@Override
protected Map create (Kryo kryo, Input input, Class<Map> type) {
Ordering ordering = kryo.readObjectOrNull(input, Ordering.class);
return new Stuff(ordering);
}
});
Output output = new Output(512, -1);
kryo.writeObject(output, stuff);
Input input = new Input(output.getBuffer(), 0, output.position());
Stuff stuff2 = kryo.readObject(input, Stuff.class);
assertEquals(stuff.ordering.order, stuff2.ordering.order);
assertEquals(stuff.get("key"), stuff2.get("key"));
assertEquals(stuff.get("something"), stuff2.get("something"));
assertTrue(stuff.get("self") == stuff);
assertTrue(stuff2.get("self") == stuff2);
}
public void testReadingNestedObjectsFirst () {
ArrayList list = new ArrayList();
list.add("1");
list.add("1");
list.add("2");
list.add("1");
list.add("1");
List subList = list.subList(0, 5);
kryo.setRegistrationRequired(false);
kryo.register(ArrayList.class);
Class<List> subListClass = (Class<List>)subList.getClass();
if(subListClass.getName().equals("java.util.ArrayList$SubList")) {
// This is JDK > = 1.7
kryo.register(subList.getClass(), new ArraySubListSerializer());
} else {
kryo.register(subList.getClass(), new SubListSerializer());
}
roundTrip(26, 26, subList);
}
static public class SubListSerializer extends Serializer<List> {
private Field listField, offsetField, sizeField;
public SubListSerializer () {
try {
Class sublistClass = Class.forName("java.util.SubList");
listField = sublistClass.getDeclaredField("l");
offsetField = sublistClass.getDeclaredField("offset");
sizeField = sublistClass.getDeclaredField("size");
listField.setAccessible(true);
offsetField.setAccessible(true);
sizeField.setAccessible(true);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
@Override
public void write (Kryo kryo, Output output, List list) {
try {
kryo.writeClassAndObject(output, listField.get(list));
int fromIndex = offsetField.getInt(list);
int count = sizeField.getInt(list);
output.writeInt(fromIndex);
output.writeInt(count);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
@Override
public List read (Kryo kryo, Input input, Class<List> type) {
List list = (List)kryo.readClassAndObject(input);
int fromIndex = input.readInt();
int count = input.readInt();
return list.subList(fromIndex, fromIndex + count);
}
}
static public class ArraySubListSerializer extends Serializer<List> {
private Field parentField, offsetField, sizeField;
public ArraySubListSerializer () {
try {
Class sublistClass = Class.forName("java.util.ArrayList$SubList");
parentField = sublistClass.getDeclaredField("parent");
offsetField = sublistClass.getDeclaredField("offset");
sizeField = sublistClass.getDeclaredField("size");
parentField.setAccessible(true);
offsetField.setAccessible(true);
sizeField.setAccessible(true);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
@Override
public void write (Kryo kryo, Output output, List list) {
try {
kryo.writeClassAndObject(output, parentField.get(list));
int offset = offsetField.getInt(list);
int size = sizeField.getInt(list);
output.writeInt(offset);
output.writeInt(size);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
@Override
public List read (Kryo kryo, Input input, Class<List> type) {
List list = (List)kryo.readClassAndObject(input);
int offset = input.readInt();
int size = input.readInt();
return list.subList(offset, offset + size);
}
}
}

877
test/dorkbox/network/kryo/SerializationBenchmarkTest.java
View File

@ -1,877 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.joran.JoranConfigurator;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.KryoSerializable;
import com.esotericsoftware.kryo.io.FastInput;
import com.esotericsoftware.kryo.io.FastOutput;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.io.UnsafeInput;
import com.esotericsoftware.kryo.io.UnsafeOutput;
import com.esotericsoftware.kryo.serializers.FieldSerializer;
import org.slf4j.LoggerFactory;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
/*** This test was originally taken from a GridGain blog. It is a compares the speed of serialization using Java serialization,
* Kryo, Kryo with Unsafe patches and GridGain's serialization.
*
* @author Roman Levenstein <romixlev@gmail.com> */
@SuppressWarnings({"unchecked","unused"})
public class SerializationBenchmarkTest extends KryoTestCase {
private static final int WARMUP_ITERATIONS = 1000;
/** Number of runs. */
private static final int RUN_CNT = 1;
/** Number of iterations. Set it to something rather big for obtaining meaningful results */
// private static final int ITER_CNT = 200000;
private static final int ITER_CNT = 100;
private static final int SLEEP_BETWEEN_RUNS = 100;
private static final int OUTPUT_BUFFER_SIZE = 4096 * 10 * 4;
SampleObject obj = createObject();
private static SampleObject createObject () {
long[] longArr = new long[3000];
for (int i = 0; i < longArr.length; i++) {
longArr[i] = i;
}
double[] dblArr = new double[3000];
for (int i = 0; i < dblArr.length; i++) {
dblArr[i] = 0.1 * i;
}
return new SampleObject(123, 123.456f, (short)321, longArr, dblArr);
}
// public static void main(String[] args) throws Exception {
// // Create sample object.
// SampleObject obj = createObject();
//
// SerializationBenchmarkTest benchmark = new SerializationBenchmarkTest();
//
// // Run Java serialization test.
// // benchmark.testJavaSerialization(obj);
// // benchmark.testJavaSerializationWithoutTryCatch(obj);
//
// // Run Kryo serialization test.
// // benchmark.kryoSerialization(obj);
// benchmark.testKryoSerializationUmodified(obj);
// benchmark.testKryoSerializationWithoutTryCatch(obj);
// benchmark.testKryoUnsafeSerializationWithoutTryCatch(obj);
//
// // Run GridGain serialization test.
// // benchmark.gridGainSerialization(obj);
// }
public void testDummyEntry() {
System.err.println("Edit the " + SerializationBenchmarkTest.class.getName() + " file to display benchmark metrics.");
}
// public void testJavaSerialization () throws Exception {
// // Warm-up phase: Perform 100000 iterations
// runJavaSerialization(1, WARMUP_ITERATIONS, false);
// runJavaSerialization(RUN_CNT, ITER_CNT, true);
// }
//
// public void testJavaSerializationWithoutTryCatch () throws Exception {
// // Warm-up phase: Perform 100000 iterations
// runJavaSerializationWithoutTryCatch(1, WARMUP_ITERATIONS, false);
// runJavaSerializationWithoutTryCatch(RUN_CNT, ITER_CNT, true);
// }
//
// public void testKryoSerialization () throws Exception {
// // Warm-up phase: Perform 100000 iterations
// runKryoSerialization(1, WARMUP_ITERATIONS, false);
// runKryoSerialization(RUN_CNT, ITER_CNT, true);
// }
//
// public void testKryoSerializationUnmodified () throws Exception {
// // Warm-up phase: Perform 100000 iterations
// runKryoSerializationUmodified(1, WARMUP_ITERATIONS, false);
// runKryoSerializationUmodified(RUN_CNT, ITER_CNT, true);
// }
//
// public void testKryoSerializationWithoutTryCatch () throws Exception {
// // Warm-up phase: Perform 100000 iterations
// runKryoSerializationWithoutTryCatch(1, WARMUP_ITERATIONS, false);
// runKryoSerializationWithoutTryCatch(RUN_CNT, ITER_CNT, true);
// }
//
// public void testKryoSerializationWithoutTryCatchWithFastStreams () throws Exception {
// // Warm-up phase: Perform 100000 iterations
// runKryoSerializationWithoutTryCatchWithFastStreams(1, WARMUP_ITERATIONS, false);
// runKryoSerializationWithoutTryCatchWithFastStreams(RUN_CNT, ITER_CNT, true);
// }
//
// public void testKryoUnsafeSerializationWithoutTryCatch () throws Exception {
// // Warm-up phase: Perform 100000 iterations
// runKryoUnsafeSerializationWithoutTryCatch(1, WARMUP_ITERATIONS, false);
// runKryoUnsafeSerializationWithoutTryCatch(RUN_CNT, ITER_CNT, true);
// }
//
// public void testKryoUnsafeSerializationWithoutTryCatchWithoutAsm () throws Exception {
// // Warm-up phase: Perform 100000 iterations
// runKryoUnsafeSerializationWithoutTryCatchWithoutAsm(1, WARMUP_ITERATIONS, false);
// runKryoUnsafeSerializationWithoutTryCatchWithoutAsm(RUN_CNT, ITER_CNT, true);
// }
//
// public void testKryoUnsafeSerializationWithoutTryCatchWithoutReferences () throws Exception {
// // Warm-up phase: Perform 100000 iterations
// runKryoUnsafeSerializationWithoutTryCatchWithoutReferences(1, WARMUP_ITERATIONS, false);
// runKryoUnsafeSerializationWithoutTryCatchWithoutReferences(RUN_CNT, ITER_CNT, true);
// }
@SuppressWarnings("null")
private void runJavaSerialization (final int RUN_CNT, final int ITER_CNT, boolean outputResults) throws Exception {
long avgDur = 0;
long bestTime = Long.MAX_VALUE;
for (int i = 0; i < RUN_CNT; i++) {
SampleObject newObj = null;
long start = System.nanoTime();
for (int j = 0; j < ITER_CNT; j++) {
ByteArrayOutputStream out = new ByteArrayOutputStream(OUTPUT_BUFFER_SIZE);
ObjectOutputStream objOut = null;
try {
objOut = new ObjectOutputStream(out);
objOut.writeObject(obj);
} finally {
objOut.close();
// U.close(objOut, null);
}
ObjectInputStream objIn = null;
try {
objIn = new ObjectInputStream(new ByteArrayInputStream(out.toByteArray()));
newObj = (SampleObject)objIn.readObject();
} finally {
objIn.close();
// U.close(objIn, null);
}
}
long dur = System.nanoTime() - start;
dur = TimeUnit.NANOSECONDS.toMillis(dur);
// Check that unmarshalled object is equal to original one (should
// never fail).
if (!obj.equals(newObj)) {
throw new RuntimeException("Unmarshalled object is not equal to original object.");
}
if (outputResults) {
System.out.format(">>> Java serialization via Externalizable (run %d): %,d ms\n", i + 1, dur);
}
avgDur += dur;
bestTime = Math.min(bestTime, dur);
systemCleanupAfterRun();
}
avgDur /= RUN_CNT;
if (outputResults) {
System.out.format("\n>>> Java serialization via Externalizable (average): %,d ms\n\n", avgDur);
System.out.format("\n>>> Java serialization via Externalizable (best time): %,d ms\n\n", bestTime);
}
}
private void systemCleanupAfterRun () throws InterruptedException {
System.gc();
Thread.sleep(SLEEP_BETWEEN_RUNS);
System.gc();
}
private void runJavaSerializationWithoutTryCatch (final int RUN_CNT, final int ITER_CNT, boolean outputResults)
throws Exception {
long avgDur = 0;
long bestTime = Long.MAX_VALUE;
for (int i = 0; i < RUN_CNT; i++) {
SampleObject newObj = null;
long start = System.nanoTime();
for (int j = 0; j < ITER_CNT; j++) {
ByteArrayOutputStream out = new ByteArrayOutputStream(OUTPUT_BUFFER_SIZE);
ObjectOutputStream objOut = null;
objOut = new ObjectOutputStream(out);
objOut.writeObject(obj);
objOut.close();
// U.close(objOut, null);
ObjectInputStream objIn = null;
objIn = new ObjectInputStream(new ByteArrayInputStream(out.toByteArray()));
newObj = (SampleObject)objIn.readObject();
objIn.close();
// U.close(objIn, null);
}
long dur = System.nanoTime() - start;
dur = TimeUnit.NANOSECONDS.toMillis(dur);
// Check that unmarshalled object is equal to original one (should
// never fail).
if (!obj.equals(newObj)) {
throw new RuntimeException("Unmarshalled object is not equal to original object.");
}
if (outputResults) {
System.out.format(">>> Java serialization without try-catch (run %d): %,d ms\n", i + 1, dur);
}
avgDur += dur;
bestTime = Math.min(bestTime, dur);
systemCleanupAfterRun();
}
avgDur /= RUN_CNT;
if (outputResults) {
System.out.format("\n>>> Java serialization without try-catch via Externalizable (average): %,d ms\n\n", avgDur);
System.out.format("\n>>> Java serialization without try-catch via Externalizable (best time): %,d ms\n\n", bestTime);
}
}
@SuppressWarnings("null")
private void runKryoSerialization (final int RUN_CNT, final int ITER_CNT, boolean outputResults) throws Exception {
Kryo marsh = new Kryo();
marsh.register(SampleObject.class, 40);
long avgDur = 0;
long bestTime = Long.MAX_VALUE;
byte[] out = new byte[OUTPUT_BUFFER_SIZE];
for (int i = 0; i < RUN_CNT; i++) {
SampleObject newObj = null;
long start = System.nanoTime();
for (int j = 0; j < ITER_CNT; j++) {
Output kryoOut = null;
try {
kryoOut = new Output(out);
marsh.writeObject(kryoOut, obj);
} finally {
kryoOut.close();
// U.close(kryoOut, null);
}
Input kryoIn = null;
try {
kryoIn = new Input(kryoOut.getBuffer(), 0, kryoOut.position());
newObj = marsh.readObject(kryoIn, SampleObject.class);
} finally {
kryoIn.close();
// U.close(kryoIn, null);
}
}
long dur = System.nanoTime() - start;
dur = TimeUnit.NANOSECONDS.toMillis(dur);
// Check that unmarshalled object is equal to original one (should
// never fail).
if (!obj.equals(newObj)) {
throw new RuntimeException("Unmarshalled object is not equal to original object.");
}
if (outputResults) {
System.out.format(">>> Kryo serialization (run %d): %,d ms\n", i + 1, dur);
}
avgDur += dur;
bestTime = Math.min(bestTime, dur);
systemCleanupAfterRun();
}
avgDur /= RUN_CNT;
if (outputResults) {
System.out.format("\n>>> Kryo serialization (average): %,d ms\n\n", avgDur);
System.out.format("\n>>> Kryo serialization (best time): %,d ms\n\n", bestTime);
}
}
@SuppressWarnings("null")
private void runKryoSerializationUmodified (final int RUN_CNT, final int ITER_CNT, boolean outputResults) throws Exception {
Kryo marsh = new Kryo();
long avgDur = 0;
long bestTime = Long.MAX_VALUE;
for (int i = 0; i < RUN_CNT; i++) {
SampleObject newObj = null;
long start = System.nanoTime();
for (int j = 0; j < ITER_CNT; j++) {
Output kryoOut = null;
try {
kryoOut = new Output(OUTPUT_BUFFER_SIZE);
marsh.writeObject(kryoOut, obj);
} finally {
// U.close(kryoOut, null);
kryoOut.close();
}
Input kryoIn = null;
try {
kryoIn = new Input(kryoOut.getBuffer(), 0, kryoOut.position());
newObj = marsh.readObject(kryoIn, SampleObject.class);
} finally {
// U.close(kryoIn, null);
kryoIn.close();
}
}
long dur = System.nanoTime() - start;
dur = TimeUnit.NANOSECONDS.toMillis(dur);
// Check that unmarshalled object is equal to original one (should
// never fail).
if (!obj.equals(newObj)) {
throw new RuntimeException("Unmarshalled object is not equal to original object.");
}
if (outputResults) {
System.out.format(">>> Kryo unmodified serialization (run %d): %,d ms\n", i + 1, dur);
}
avgDur += dur;
bestTime = Math.min(bestTime, dur);
systemCleanupAfterRun();
}
avgDur /= RUN_CNT;
if (outputResults) {
System.out.format("\n>>> Kryo unmodified serialization (average): %,d ms\n\n", avgDur);
System.out.format("\n>>> Kryo unmodified serialization (best time): %,d ms\n\n", bestTime);
}
}
private void runKryoSerializationWithoutTryCatch (final int RUN_CNT, final int ITER_CNT, boolean outputResults)
throws Exception {
Kryo marsh = new Kryo();
marsh.register(SampleObject.class, 40);
long avgDur = 0;
long bestTime = Long.MAX_VALUE;
byte[] out = new byte[OUTPUT_BUFFER_SIZE];
for (int i = 0; i < RUN_CNT; i++) {
SampleObject newObj = null;
long start = System.nanoTime();
for (int j = 0; j < ITER_CNT; j++) {
Output kryoOut = null;
kryoOut = new Output(out);
marsh.writeObject(kryoOut, obj);
kryoOut.close();
// U.close(kryoOut, null);
Input kryoIn = null;
kryoIn = new Input(kryoOut.getBuffer(), 0, kryoOut.position());
newObj = marsh.readObject(kryoIn, SampleObject.class);
kryoIn.close();
// U.close(kryoIn, null);
}
long dur = System.nanoTime() - start;
dur = TimeUnit.NANOSECONDS.toMillis(dur);
// Check that unmarshalled object is equal to original one (should
// never fail).
if (!obj.equals(newObj)) {
throw new RuntimeException("Unmarshalled object is not equal to original object.");
}
if (outputResults) {
System.out.format(">>> Kryo serialization without try-catch (run %d): %,d ms\n", i + 1, dur);
}
avgDur += dur;
bestTime = Math.min(bestTime, dur);
systemCleanupAfterRun();
}
avgDur /= RUN_CNT;
if (outputResults) {
System.out.format("\n>>> Kryo serialization without try-catch (average): %,d ms\n\n", avgDur);
System.out.format("\n>>> Kryo serialization without try-catch (best time): %,d ms\n\n", bestTime);
}
}
private void runKryoSerializationWithoutTryCatchWithFastStreams (final int RUN_CNT, final int ITER_CNT, boolean outputResults)
throws Exception {
Kryo marsh = new Kryo();
marsh.register(SampleObject.class, 40);
long avgDur = 0;
long bestTime = Long.MAX_VALUE;
byte[] out = new byte[OUTPUT_BUFFER_SIZE];
for (int i = 0; i < RUN_CNT; i++) {
SampleObject newObj = null;
long start = System.nanoTime();
for (int j = 0; j < ITER_CNT; j++) {
Output kryoOut = null;
kryoOut = new FastOutput(out);
marsh.writeObject(kryoOut, obj);
kryoOut.close();
// U.close(kryoOut, null);
Input kryoIn = null;
kryoIn = new FastInput(kryoOut.getBuffer(), 0, kryoOut.position());
newObj = marsh.readObject(kryoIn, SampleObject.class);
kryoIn.close();
// U.close(kryoIn, null);
}
long dur = System.nanoTime() - start;
dur = TimeUnit.NANOSECONDS.toMillis(dur);
// Check that unmarshalled object is equal to original one (should
// never fail).
if (!obj.equals(newObj)) {
throw new RuntimeException("Unmarshalled object is not equal to original object.");
}
if (outputResults) {
System.out.format(">>> Kryo serialization without try-catch with fast streams (run %d): %,d ms\n", i + 1, dur);
}
avgDur += dur;
bestTime = Math.min(bestTime, dur);
systemCleanupAfterRun();
}
avgDur /= RUN_CNT;
if (outputResults) {
System.out.format("\n>>> Kryo serialization without try-catch with fast streams (average): %,d ms\n\n", avgDur);
System.out.format("\n>>> Kryo serialization without try-catch with fast streams (best time): %,d ms\n\n", bestTime);
}
}
private void runKryoUnsafeSerializationWithoutTryCatch (final int RUN_CNT, final int ITER_CNT, boolean outputResults)
throws Exception {
Kryo marsh = new Kryo();
marsh.setRegistrationRequired(true);
marsh.register(double[].class, 30);
marsh.register(long[].class, 31);
// Explicitly tell to use Unsafe-based serializer
marsh.register(SampleObject.class, new FieldSerializer<SampleObject>(marsh, SampleObject.class), 40);
// Use fastest possible serialization of object fields
FieldSerializer<SampleObject> ser = (FieldSerializer<SampleObject>)marsh.getRegistration(SampleObject.class)
.getSerializer();
ser.setUseAsm(true);
long avgDur = 0;
long bestTime = Long.MAX_VALUE;
byte[] out = new byte[OUTPUT_BUFFER_SIZE];
for (int i = 0; i < RUN_CNT; i++) {
SampleObject newObj = null;
long start = System.nanoTime();
for (int j = 0; j < ITER_CNT; j++) {
Output kryoOut = null;
kryoOut = new UnsafeOutput(out);
marsh.writeObject(kryoOut, obj);
kryoOut.close();
// U.close(kryoOut, null);
Input kryoIn = null;
kryoIn = new UnsafeInput(kryoOut.getBuffer(), 0, kryoOut.position());
newObj = marsh.readObject(kryoIn, SampleObject.class);
kryoIn.close();
// U.close(kryoIn, null);
}
long dur = System.nanoTime() - start;
dur = TimeUnit.NANOSECONDS.toMillis(dur);
// Check that unmarshalled object is equal to original one (should
// never fail).
if (!obj.equals(newObj)) {
throw new RuntimeException("Unmarshalled object is not equal to original object.");
}
if (outputResults) {
System.out.format(">>> Kryo unsafe serialization without try-catch (run %d): %,d ms\n", i + 1, dur);
}
avgDur += dur;
bestTime = Math.min(bestTime, dur);
systemCleanupAfterRun();
}
avgDur /= RUN_CNT;
if (outputResults) {
System.out.format("\n>>> Kryo unsafe serialization without try-catch (average): %,d ms\n\n", avgDur);
System.out.format("\n>>> Kryo unsafe serialization without try-catch (best time): %,d ms\n\n", bestTime);
}
}
private void runKryoUnsafeSerializationWithoutTryCatchWithoutAsm (final int RUN_CNT, final int ITER_CNT, boolean outputResults)
throws Exception {
Kryo marsh = new Kryo();
marsh.setRegistrationRequired(true);
marsh.register(double[].class, 30);
marsh.register(long[].class, 31);
// Explicitly tell to use Unsafe-based serializer
marsh.register(SampleObject.class, new FieldSerializer<SampleObject>(marsh, SampleObject.class), 40);
// // Use fastest possible serialization of object fields
// FieldSerializer<SampleObject> ser = (FieldSerializer<SampleObject>) marsh.getRegistration(SampleObject.class).getSerializer();
// ser.setUseAsm(false);
long avgDur = 0;
long bestTime = Long.MAX_VALUE;
byte[] out = new byte[OUTPUT_BUFFER_SIZE];
for (int i = 0; i < RUN_CNT; i++) {
SampleObject newObj = null;
long start = System.nanoTime();
for (int j = 0; j < ITER_CNT; j++) {
Output kryoOut = null;
kryoOut = new UnsafeOutput(out);
marsh.writeObject(kryoOut, obj);
kryoOut.close();
// U.close(kryoOut, null);
Input kryoIn = null;
kryoIn = new UnsafeInput(kryoOut.getBuffer(), 0, kryoOut.position());
newObj = marsh.readObject(kryoIn, SampleObject.class);
kryoIn.close();
// U.close(kryoIn, null);
}
long dur = System.nanoTime() - start;
dur = TimeUnit.NANOSECONDS.toMillis(dur);
// Check that unmarshalled object is equal to original one (should
// never fail).
if (!obj.equals(newObj)) {
throw new RuntimeException("Unmarshalled object is not equal to original object.");
}
if (outputResults) {
System.out.format(">>> Kryo unsafe serialization without try-catch, without ASM (run %d): %,d ms\n", i + 1, dur);
}
avgDur += dur;
bestTime = Math.min(bestTime, dur);
systemCleanupAfterRun();
}
avgDur /= RUN_CNT;
if (outputResults) {
System.out.format("\n>>> Kryo unsafe serialization without try-catch, without ASM (average): %,d ms\n\n", avgDur);
System.out.format("\n>>> Kryo unsafe serialization without try-catch, without ASM (best time): %,d ms\n\n", bestTime);
}
}
private void runKryoUnsafeSerializationWithoutTryCatchWithoutReferences (final int RUN_CNT, final int ITER_CNT,
boolean outputResults) throws Exception {
Kryo marsh = new Kryo();
kryo.setReferences(false);
marsh.setRegistrationRequired(true);
marsh.register(double[].class, 30);
marsh.register(long[].class, 31);
// Explicitly tell to use Unsafe-based serializer
marsh.register(SampleObject.class, new FieldSerializer<SampleObject>(marsh, SampleObject.class), 40);
// Use fastest possible serialization of object fields
FieldSerializer<SampleObject> ser = (FieldSerializer<SampleObject>)marsh.getRegistration(SampleObject.class)
.getSerializer();
ser.setUseAsm(false);
long avgDur = 0;
long bestTime = Long.MAX_VALUE;
for (int i = 0; i < RUN_CNT; i++) {
SampleObject newObj = null;
byte[] out = new byte[OUTPUT_BUFFER_SIZE];
long start = System.nanoTime();
for (int j = 0; j < ITER_CNT; j++) {
Output kryoOut = null;
kryoOut = new UnsafeOutput(out);
marsh.writeObject(kryoOut, obj);
kryoOut.close();
// U.close(kryoOut, null);
Input kryoIn = null;
kryoIn = new UnsafeInput(kryoOut.getBuffer(), 0, kryoOut.position());
newObj = marsh.readObject(kryoIn, SampleObject.class);
kryoIn.close();
// U.close(kryoIn, null);
}
long dur = System.nanoTime() - start;
dur = TimeUnit.NANOSECONDS.toMillis(dur);
// Check that unmarshalled object is equal to original one (should
// never fail).
if (!obj.equals(newObj)) {
throw new RuntimeException("Unmarshalled object is not equal to original object.");
}
if (outputResults) {
System.out.format(
">>> Kryo unsafe serialization without try-catch, without ASM, without references (run %d): %,d ms\n", i + 1, dur);
}
avgDur += dur;
bestTime = Math.min(bestTime, dur);
systemCleanupAfterRun();
}
avgDur /= RUN_CNT;
if (outputResults) {
System.out.format(
"\n>>> Kryo unsafe serialization without try-catch, without ASM, without references (average): %,d ms\n\n", avgDur);
System.out.format(
"\n>>> Kryo unsafe serialization without try-catch, without ASM, without references (best time): %,d ms\n\n",
bestTime);
}
}
// private static long gridGainSerialization()
// throws Exception {
// GridMarshaller marsh = new GridOptimizedMarshaller(false,
// Arrays.asList(SampleObject.class.getName()), null);
//
// long avgDur = 0;
//
// for (int i = 0; i < RUN_CNT; i++) {
// SampleObject newObj = null;
//
// long start = System.currentTimeMillis();
//
// for (int j = 0; j < ITER_CNT; j++)
// newObj = marsh.unmarshal(marsh.marshal(obj), null);
//
// long dur = System.currentTimeMillis() - start;
//
// // Check that unmarshalled object is equal to original one (should
// // never fail).
// if (!obj.equals(newObj))
// throw new RuntimeException(
// "Unmarshalled object is not equal to original object.");
//
// System.out.format(">>> GridGain serialization (run %d): %,d ms\n",
// i + 1, dur);
//
// avgDur += dur;
// }
//
// avgDur /= RUN_CNT;
//
// System.out.format("\n>>> GridGain serialization (average): %,d ms\n\n",
// avgDur);
//
// return avgDur;
// }
@Override
protected void setUp () throws Exception {
super.setUp();
// assume SLF4J is bound to logback in the current environment
Logger rootLogger = (Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
LoggerContext context = rootLogger.getLoggerContext();
JoranConfigurator jc = new JoranConfigurator();
jc.setContext(context);
context.reset(); // override default configuration
rootLogger.setLevel(Level.WARN);
}
private static class SampleObject implements Externalizable, KryoSerializable {
private int intVal;
private float floatVal;
private Short shortVal;
private long[] longArr;
private double[] dblArr;
private SampleObject selfRef;
public SampleObject () {
}
SampleObject (int intVal, float floatVal, Short shortVal, long[] longArr, double[] dblArr) {
this.intVal = intVal;
this.floatVal = floatVal;
this.shortVal = shortVal;
this.longArr = longArr;
this.dblArr = dblArr;
selfRef = this;
}
/** {@inheritDoc} */
@Override
public boolean equals (Object other) {
if (this == other) {
return true;
}
if (other == null || getClass() != other.getClass()) {
return false;
}
SampleObject obj = (SampleObject)other;
assert this == selfRef;
assert obj == obj.selfRef;
return intVal == obj.intVal && floatVal == obj.floatVal && shortVal.equals(obj.shortVal)
&& Arrays.equals(dblArr, obj.dblArr) && Arrays.equals(longArr, obj.longArr);
}
// Required by Kryo serialization.
@Override
public void read (Kryo kryo, Input in) {
intVal = kryo.readObject(in, Integer.class);
floatVal = kryo.readObject(in, Float.class);
shortVal = kryo.readObject(in, Short.class);
longArr = kryo.readObject(in, long[].class);
dblArr = kryo.readObject(in, double[].class);
selfRef = kryo.readObject(in, SampleObject.class);
}
// Required by Java Externalizable.
@Override
public void readExternal (ObjectInput in) throws IOException, ClassNotFoundException {
intVal = in.readInt();
floatVal = in.readFloat();
shortVal = in.readShort();
longArr = (long[])in.readObject();
dblArr = (double[])in.readObject();
selfRef = (SampleObject)in.readObject();
}
// Required by Kryo serialization.
@Override
public void write (Kryo kryo, Output out) {
kryo.writeObject(out, intVal);
kryo.writeObject(out, floatVal);
kryo.writeObject(out, shortVal);
kryo.writeObject(out, longArr);
kryo.writeObject(out, dblArr);
kryo.writeObject(out, selfRef);
}
// Required by Java Externalizable.
@Override
public void writeExternal (ObjectOutput out) throws IOException {
out.writeInt(intVal);
out.writeFloat(floatVal);
out.writeShort(shortVal);
out.writeObject(longArr);
out.writeObject(dblArr);
out.writeObject(selfRef);
}
@Override
public int hashCode() {
return super.hashCode();
}
}
}

120
test/dorkbox/network/kryo/TaggedFieldSerializerTest.java
View File

@ -1,120 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import com.esotericsoftware.kryo.serializers.TaggedFieldSerializer;
import com.esotericsoftware.kryo.serializers.TaggedFieldSerializer.Tag;
@SuppressWarnings({"rawtypes"})
public class TaggedFieldSerializerTest extends KryoTestCase {
{
this.supportsCopy = true;
}
public void testTaggedFieldSerializer() {
TestClass object1 = new TestClass();
object1.moo = 2;
object1.child = new TestClass();
object1.child.moo = 5;
object1.other = new AnotherClass();
object1.other.value = "meow";
object1.ignored = 32;
this.kryo.setDefaultSerializer(TaggedFieldSerializer.class);
this.kryo.register(TestClass.class);
this.kryo.register(AnotherClass.class);
TestClass object2 = roundTrip(57, 75, object1);
assertTrue(object2.ignored == 0);
}
public void testAddedField() {
TestClass object1 = new TestClass();
object1.child = new TestClass();
object1.other = new AnotherClass();
object1.other.value = "meow";
TaggedFieldSerializer serializer = new TaggedFieldSerializer(this.kryo, TestClass.class);
serializer.removeField("text");
this.kryo.register(TestClass.class, serializer);
this.kryo.register(AnotherClass.class, new TaggedFieldSerializer(this.kryo, AnotherClass.class));
roundTrip(39, 55, object1);
this.kryo.register(TestClass.class, new TaggedFieldSerializer(this.kryo, TestClass.class));
Object object2 = this.kryo.readClassAndObject(this.input);
assertEquals(object1, object2);
}
static public class TestClass {
@Tag(0) public String text = "something";
@Tag(1) public int moo = 120;
@Tag(2) public long moo2 = 1234120;
@Tag(3) public TestClass child;
@Tag(4) public int zzz = 123;
@Tag(5) public AnotherClass other;
@Tag(6) @Deprecated public int ignored;
@Override
public boolean equals (Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
TestClass other = (TestClass)obj;
if (this.child == null) {
if (other.child != null) {
return false;
}
} else if (!this.child.equals(other.child)) {
return false;
}
if (this.moo != other.moo) {
return false;
}
if (this.moo2 != other.moo2) {
return false;
}
if (this.text == null) {
if (other.text != null) {
return false;
}
} else if (!this.text.equals(other.text)) {
return false;
}
if (this.zzz != other.zzz) {
return false;
}
return true;
}
@Override
public int hashCode() {
return super.hashCode();
}
}
static public class AnotherClass {
@Tag(1) String value;
}
}

824
test/dorkbox/network/kryo/UnsafeInputOutputTest.java
View File

@ -1,824 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.Random;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.io.UnsafeInput;
import com.esotericsoftware.kryo.io.UnsafeOutput;
/** @author Nathan Sweet <misc@n4te.com> */
@SuppressWarnings("resource")
public class UnsafeInputOutputTest extends KryoTestCase {
public void testOutputStream () {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
UnsafeOutput output = new UnsafeOutput(buffer, 2);
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();
assertEquals(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.toByteArray());
output.close();
}
public void testInputStream () {
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};
ByteArrayInputStream buffer = new ByteArrayInputStream(bytes);
Input input = new UnsafeInput(buffer, 2);
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);
assertEquals(bytes, temp2);
input.close();
input = new UnsafeInput(bytes);
count = input.read(temp, 512, 512);
assertEquals(bytes.length, count);
temp2 = new byte[count];
System.arraycopy(temp, 512, temp2, 0, count);
assertEquals(bytes, temp2);
input.close();
}
public void testWriteBytes () {
UnsafeOutput buffer = new UnsafeOutput(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();
assertEquals(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());
buffer.close();
}
public void testStrings () {
runStringTest(new UnsafeOutput(4096));
runStringTest(new UnsafeOutput(897));
runStringTest(new UnsafeOutput(new ByteArrayOutputStream()));
UnsafeOutput write = new UnsafeOutput(21);
String value = "abcdef\u00E1\u00E9\u00ED\u00F3\u00FA\u1234";
write.writeString(value);
Input read = new UnsafeInput(write.toBytes());
assertEquals(value, read.readString());
runStringTest(127);
runStringTest(256);
runStringTest(1024 * 1023);
runStringTest(1024 * 1024);
runStringTest(1024 * 1025);
runStringTest(1024 * 1026);
runStringTest(1024 * 1024 * 2);
}
public void runStringTest (int length) {
UnsafeOutput write = new UnsafeOutput(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);
Input read = new UnsafeInput(write.toBytes());
assertEquals(value, read.readString());
assertEquals(value, read.readStringBuilder().toString());
write.clear();
write.writeString(buffer);
write.writeString(buffer);
read = new UnsafeInput(write.toBytes());
assertEquals(value, read.readStringBuilder().toString());
assertEquals(value, read.readString());
if (length <= 127) {
write.clear();
write.writeAscii(value);
write.writeAscii(value);
read = new UnsafeInput(write.toBytes());
assertEquals(value, read.readStringBuilder().toString());
assertEquals(value, read.readString());
}
}
public void runStringTest (UnsafeOutput write) {
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");
}
Input read = new UnsafeInput(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());
assertEquals(null, 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.rewind();
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());
assertEquals(null, 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());
}
}
public void testCanReadInt () {
UnsafeOutput write = new UnsafeOutput(new ByteArrayOutputStream());
Input read = new UnsafeInput(write.toBytes());
assertEquals(false, read.canReadInt());
write.writeVarInt(400, true);
read = new UnsafeInput(write.toBytes());
assertEquals(true, read.canReadInt());
read.setLimit(read.limit() - 1);
assertEquals(false, read.canReadInt());
}
public void testInts () {
runIntTest(new UnsafeOutput(4096));
runIntTest(new UnsafeOutput(new ByteArrayOutputStream()));
}
private void runIntTest (UnsafeOutput write) {
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(4, write.writeInt(0, true));
assertEquals(4, write.writeInt(0, false));
assertEquals(4, write.writeInt(63, true));
assertEquals(4, write.writeInt(63, false));
assertEquals(4, write.writeInt(64, true));
assertEquals(4, write.writeInt(64, false));
assertEquals(4, write.writeInt(127, true));
assertEquals(4, write.writeInt(127, false));
assertEquals(4, write.writeInt(128, true));
assertEquals(4, write.writeInt(128, false));
assertEquals(4, write.writeInt(8191, true));
assertEquals(4, write.writeInt(8191, false));
assertEquals(4, write.writeInt(8192, true));
assertEquals(4, write.writeInt(8192, false));
assertEquals(4, write.writeInt(16383, true));
assertEquals(4, write.writeInt(16383, false));
assertEquals(4, write.writeInt(16384, true));
assertEquals(4, write.writeInt(16384, false));
assertEquals(4, write.writeInt(2097151, true));
assertEquals(4, write.writeInt(2097151, false));
assertEquals(4, write.writeInt(1048575, true));
assertEquals(4, write.writeInt(1048575, false));
assertEquals(4, write.writeInt(134217727, true));
assertEquals(4, write.writeInt(134217727, false));
assertEquals(4, write.writeInt(268435455, true));
assertEquals(4, write.writeInt(268435455, false));
assertEquals(4, write.writeInt(134217728, true));
assertEquals(4, write.writeInt(134217728, false));
assertEquals(4, write.writeInt(268435456, true));
assertEquals(4, write.writeInt(268435456, false));
assertEquals(4, write.writeInt(-64, false));
assertEquals(4, write.writeInt(-64, true));
assertEquals(4, write.writeInt(-65, false));
assertEquals(4, write.writeInt(-65, true));
assertEquals(4, write.writeInt(-8192, false));
assertEquals(4, write.writeInt(-8192, true));
assertEquals(4, write.writeInt(-1048576, false));
assertEquals(4, write.writeInt(-1048576, true));
assertEquals(4, write.writeInt(-134217728, false));
assertEquals(4, write.writeInt(-134217728, true));
assertEquals(4, write.writeInt(-134217729, false));
assertEquals(4, write.writeInt(-134217729, true));
Input read = new UnsafeInput(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());
assertEquals(true, read.canReadInt());
assertEquals(true, read.canReadInt());
assertEquals(true, read.canReadInt());
assertEquals(0, read.readInt(true));
assertEquals(0, read.readInt(false));
assertEquals(63, read.readInt(true));
assertEquals(63, read.readInt(false));
assertEquals(64, read.readInt(true));
assertEquals(64, read.readInt(false));
assertEquals(127, read.readInt(true));
assertEquals(127, read.readInt(false));
assertEquals(128, read.readInt(true));
assertEquals(128, read.readInt(false));
assertEquals(8191, read.readInt(true));
assertEquals(8191, read.readInt(false));
assertEquals(8192, read.readInt(true));
assertEquals(8192, read.readInt(false));
assertEquals(16383, read.readInt(true));
assertEquals(16383, read.readInt(false));
assertEquals(16384, read.readInt(true));
assertEquals(16384, read.readInt(false));
assertEquals(2097151, read.readInt(true));
assertEquals(2097151, read.readInt(false));
assertEquals(1048575, read.readInt(true));
assertEquals(1048575, read.readInt(false));
assertEquals(134217727, read.readInt(true));
assertEquals(134217727, read.readInt(false));
assertEquals(268435455, read.readInt(true));
assertEquals(268435455, read.readInt(false));
assertEquals(134217728, read.readInt(true));
assertEquals(134217728, read.readInt(false));
assertEquals(268435456, read.readInt(true));
assertEquals(268435456, read.readInt(false));
assertEquals(-64, read.readInt(false));
assertEquals(-64, read.readInt(true));
assertEquals(-65, read.readInt(false));
assertEquals(-65, read.readInt(true));
assertEquals(-8192, read.readInt(false));
assertEquals(-8192, read.readInt(true));
assertEquals(-1048576, read.readInt(false));
assertEquals(-1048576, read.readInt(true));
assertEquals(-134217728, read.readInt(false));
assertEquals(-134217728, read.readInt(true));
assertEquals(-134217729, read.readInt(false));
assertEquals(-134217729, read.readInt(true));
assertEquals(false, read.canReadInt());
Random random = new Random();
for (int i = 0; i < 10000; i++) {
int value = random.nextInt();
write.clear();
write.writeInt(value);
write.writeInt(value, true);
write.writeInt(value, false);
read.setBuffer(write.toBytes());
assertEquals(value, read.readInt());
assertEquals(value, read.readInt(true));
assertEquals(value, read.readInt(false));
}
}
public void testLongs () {
runLongTest(new UnsafeOutput(4096));
runLongTest(new UnsafeOutput(new ByteArrayOutputStream()));
}
private void runLongTest (UnsafeOutput write) {
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(8, write.writeLong(0, true));
assertEquals(8, write.writeLong(0, false));
assertEquals(8, write.writeLong(63, true));
assertEquals(8, write.writeLong(63, false));
assertEquals(8, write.writeLong(64, true));
assertEquals(8, write.writeLong(64, false));
assertEquals(8, write.writeLong(127, true));
assertEquals(8, write.writeLong(127, false));
assertEquals(8, write.writeLong(128, true));
assertEquals(8, write.writeLong(128, false));
assertEquals(8, write.writeLong(8191, true));
assertEquals(8, write.writeLong(8191, false));
assertEquals(8, write.writeLong(8192, true));
assertEquals(8, write.writeLong(8192, false));
assertEquals(8, write.writeLong(16383, true));
assertEquals(8, write.writeLong(16383, false));
assertEquals(8, write.writeLong(16384, true));
assertEquals(8, write.writeLong(16384, false));
assertEquals(8, write.writeLong(2097151, true));
assertEquals(8, write.writeLong(2097151, false));
assertEquals(8, write.writeLong(1048575, true));
assertEquals(8, write.writeLong(1048575, false));
assertEquals(8, write.writeLong(134217727, true));
assertEquals(8, write.writeLong(134217727, false));
assertEquals(8, write.writeLong(268435455l, true));
assertEquals(8, write.writeLong(268435455l, false));
assertEquals(8, write.writeLong(134217728l, true));
assertEquals(8, write.writeLong(134217728l, false));
assertEquals(8, write.writeLong(268435456l, true));
assertEquals(8, write.writeLong(268435456l, false));
assertEquals(8, write.writeLong(-64, false));
assertEquals(8, write.writeLong(-64, true));
assertEquals(8, write.writeLong(-65, false));
assertEquals(8, write.writeLong(-65, true));
assertEquals(8, write.writeLong(-8192, false));
assertEquals(8, write.writeLong(-8192, true));
assertEquals(8, write.writeLong(-1048576, false));
assertEquals(8, write.writeLong(-1048576, true));
assertEquals(8, write.writeLong(-134217728, false));
assertEquals(8, write.writeLong(-134217728, true));
assertEquals(8, write.writeLong(-134217729, false));
assertEquals(8, write.writeLong(-134217729, true));
Input read = new UnsafeInput(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.readLong(true));
assertEquals(0, read.readLong(false));
assertEquals(63, read.readLong(true));
assertEquals(63, read.readLong(false));
assertEquals(64, read.readLong(true));
assertEquals(64, read.readLong(false));
assertEquals(127, read.readLong(true));
assertEquals(127, read.readLong(false));
assertEquals(128, read.readLong(true));
assertEquals(128, read.readLong(false));
assertEquals(8191, read.readLong(true));
assertEquals(8191, read.readLong(false));
assertEquals(8192, read.readLong(true));
assertEquals(8192, read.readLong(false));
assertEquals(16383, read.readLong(true));
assertEquals(16383, read.readLong(false));
assertEquals(16384, read.readLong(true));
assertEquals(16384, read.readLong(false));
assertEquals(2097151, read.readLong(true));
assertEquals(2097151, read.readLong(false));
assertEquals(1048575, read.readLong(true));
assertEquals(1048575, read.readLong(false));
assertEquals(134217727, read.readLong(true));
assertEquals(134217727, read.readLong(false));
assertEquals(268435455, read.readLong(true));
assertEquals(268435455, read.readLong(false));
assertEquals(134217728, read.readLong(true));
assertEquals(134217728, read.readLong(false));
assertEquals(268435456, read.readLong(true));
assertEquals(268435456, read.readLong(false));
assertEquals(-64, read.readLong(false));
assertEquals(-64, read.readLong(true));
assertEquals(-65, read.readLong(false));
assertEquals(-65, read.readLong(true));
assertEquals(-8192, read.readLong(false));
assertEquals(-8192, read.readLong(true));
assertEquals(-1048576, read.readLong(false));
assertEquals(-1048576, read.readLong(true));
assertEquals(-134217728, read.readLong(false));
assertEquals(-134217728, read.readLong(true));
assertEquals(-134217729, read.readLong(false));
assertEquals(-134217729, read.readLong(true));
Random random = new Random();
for (int i = 0; i < 10000; i++) {
long value = random.nextLong();
write.clear();
write.writeLong(value);
write.writeLong(value, true);
write.writeLong(value, false);
read.setBuffer(write.toBytes());
assertEquals("Element " + i, value, read.readLong());
assertEquals("Element " + i, value, read.readLong(true));
assertEquals("Element " + i, value, read.readLong(false));
}
}
public void testShorts () {
runShortTest(new UnsafeOutput(4096));
runShortTest(new UnsafeOutput(new ByteArrayOutputStream()));
}
private void runShortTest (UnsafeOutput write) {
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);
Input read = new UnsafeInput(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());
}
public void testFloats () {
runFloatTest(new UnsafeOutput(4096));
runFloatTest(new UnsafeOutput(new ByteArrayOutputStream()));
}
private void runFloatTest (UnsafeOutput write) {
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(4, write.writeFloat(0, 1000, true));
assertEquals(4, write.writeFloat(0, 1000, false));
assertEquals(4, write.writeFloat(63, 1000, true));
assertEquals(4, write.writeFloat(63, 1000, false));
assertEquals(4, write.writeFloat(64, 1000, true));
assertEquals(4, write.writeFloat(64, 1000, false));
assertEquals(4, write.writeFloat(127, 1000, true));
assertEquals(4, write.writeFloat(127, 1000, false));
assertEquals(4, write.writeFloat(128, 1000, true));
assertEquals(4, write.writeFloat(128, 1000, false));
assertEquals(4, write.writeFloat(8191, 1000, true));
assertEquals(4, write.writeFloat(8191, 1000, false));
assertEquals(4, write.writeFloat(8192, 1000, true));
assertEquals(4, write.writeFloat(8192, 1000, false));
assertEquals(4, write.writeFloat(16383, 1000, true));
assertEquals(4, write.writeFloat(16383, 1000, false));
assertEquals(4, write.writeFloat(16384, 1000, true));
assertEquals(4, write.writeFloat(16384, 1000, false));
assertEquals(4, write.writeFloat(32767, 1000, true));
assertEquals(4, write.writeFloat(32767, 1000, false));
assertEquals(4, write.writeFloat(-64, 1000, false));
assertEquals(4, write.writeFloat(-64, 1000, true));
assertEquals(4, write.writeFloat(-65, 1000, false));
assertEquals(4, write.writeFloat(-65, 1000, true));
assertEquals(4, write.writeFloat(-8192, 1000, false));
assertEquals(4, write.writeFloat(-8192, 1000, true));
Input read = new UnsafeInput(write.toBytes());
assertEquals(read.readFloat(), 0f);
assertEquals(read.readFloat(), 63f);
assertEquals(read.readFloat(), 64f);
assertEquals(read.readFloat(), 127f);
assertEquals(read.readFloat(), 128f);
assertEquals(read.readFloat(), 8192f);
assertEquals(read.readFloat(), 16384f);
assertEquals(read.readFloat(), 32767f);
assertEquals(read.readFloat(), -63f);
assertEquals(read.readFloat(), -64f);
assertEquals(read.readFloat(), -127f);
assertEquals(read.readFloat(), -128f);
assertEquals(read.readFloat(), -8192f);
assertEquals(read.readFloat(), -16384f);
assertEquals(read.readFloat(), -32768f);
assertEquals(read.readFloat(1000, true), 0f);
assertEquals(read.readFloat(1000, false), 0f);
assertEquals(read.readFloat(1000, true), 63f);
assertEquals(read.readFloat(1000, false), 63f);
assertEquals(read.readFloat(1000, true), 64f);
assertEquals(read.readFloat(1000, false), 64f);
assertEquals(read.readFloat(1000, true), 127f);
assertEquals(read.readFloat(1000, false), 127f);
assertEquals(read.readFloat(1000, true), 128f);
assertEquals(read.readFloat(1000, false), 128f);
assertEquals(read.readFloat(1000, true), 8191f);
assertEquals(read.readFloat(1000, false), 8191f);
assertEquals(read.readFloat(1000, true), 8192f);
assertEquals(read.readFloat(1000, false), 8192f);
assertEquals(read.readFloat(1000, true), 16383f);
assertEquals(read.readFloat(1000, false), 16383f);
assertEquals(read.readFloat(1000, true), 16384f);
assertEquals(read.readFloat(1000, false), 16384f);
assertEquals(read.readFloat(1000, true), 32767f);
assertEquals(read.readFloat(1000, false), 32767f);
assertEquals(read.readFloat(1000, false), -64f);
assertEquals(read.readFloat(1000, true), -64f);
assertEquals(read.readFloat(1000, false), -65f);
assertEquals(read.readFloat(1000, true), -65f);
assertEquals(read.readFloat(1000, false), -8192f);
assertEquals(read.readFloat(1000, true), -8192f);
}
public void testDoubles () {
runDoubleTest(new UnsafeOutput(4096));
runDoubleTest(new UnsafeOutput(new ByteArrayOutputStream()));
}
private void runDoubleTest (UnsafeOutput write) {
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(8, write.writeDouble(0, 1000, true));
assertEquals(8, write.writeDouble(0, 1000, false));
assertEquals(8, write.writeDouble(63, 1000, true));
assertEquals(8, write.writeDouble(63, 1000, false));
assertEquals(8, write.writeDouble(64, 1000, true));
assertEquals(8, write.writeDouble(64, 1000, false));
assertEquals(8, write.writeDouble(127, 1000, true));
assertEquals(8, write.writeDouble(127, 1000, false));
assertEquals(8, write.writeDouble(128, 1000, true));
assertEquals(8, write.writeDouble(128, 1000, false));
assertEquals(8, write.writeDouble(8191, 1000, true));
assertEquals(8, write.writeDouble(8191, 1000, false));
assertEquals(8, write.writeDouble(8192, 1000, true));
assertEquals(8, write.writeDouble(8192, 1000, false));
assertEquals(8, write.writeDouble(16383, 1000, true));
assertEquals(8, write.writeDouble(16383, 1000, false));
assertEquals(8, write.writeDouble(16384, 1000, true));
assertEquals(8, write.writeDouble(16384, 1000, false));
assertEquals(8, write.writeDouble(32767, 1000, true));
assertEquals(8, write.writeDouble(32767, 1000, false));
assertEquals(8, write.writeDouble(-64, 1000, false));
assertEquals(8, write.writeDouble(-64, 1000, true));
assertEquals(8, write.writeDouble(-65, 1000, false));
assertEquals(8, write.writeDouble(-65, 1000, true));
assertEquals(8, write.writeDouble(-8192, 1000, false));
assertEquals(8, write.writeDouble(-8192, 1000, true));
write.writeDouble(1.23456d);
Input read = new UnsafeInput(write.toBytes());
assertEquals(read.readDouble(), 0d);
assertEquals(read.readDouble(), 63d);
assertEquals(read.readDouble(), 64d);
assertEquals(read.readDouble(), 127d);
assertEquals(read.readDouble(), 128d);
assertEquals(read.readDouble(), 8192d);
assertEquals(read.readDouble(), 16384d);
assertEquals(read.readDouble(), 32767d);
assertEquals(read.readDouble(), -63d);
assertEquals(read.readDouble(), -64d);
assertEquals(read.readDouble(), -127d);
assertEquals(read.readDouble(), -128d);
assertEquals(read.readDouble(), -8192d);
assertEquals(read.readDouble(), -16384d);
assertEquals(read.readDouble(), -32768d);
assertEquals(read.readDouble(1000, true), 0d);
assertEquals(read.readDouble(1000, false), 0d);
assertEquals(read.readDouble(1000, true), 63d);
assertEquals(read.readDouble(1000, false), 63d);
assertEquals(read.readDouble(1000, true), 64d);
assertEquals(read.readDouble(1000, false), 64d);
assertEquals(read.readDouble(1000, true), 127d);
assertEquals(read.readDouble(1000, false), 127d);
assertEquals(read.readDouble(1000, true), 128d);
assertEquals(read.readDouble(1000, false), 128d);
assertEquals(read.readDouble(1000, true), 8191d);
assertEquals(read.readDouble(1000, false), 8191d);
assertEquals(read.readDouble(1000, true), 8192d);
assertEquals(read.readDouble(1000, false), 8192d);
assertEquals(read.readDouble(1000, true), 16383d);
assertEquals(read.readDouble(1000, false), 16383d);
assertEquals(read.readDouble(1000, true), 16384d);
assertEquals(read.readDouble(1000, false), 16384d);
assertEquals(read.readDouble(1000, true), 32767d);
assertEquals(read.readDouble(1000, false), 32767d);
assertEquals(read.readDouble(1000, false), -64d);
assertEquals(read.readDouble(1000, true), -64d);
assertEquals(read.readDouble(1000, false), -65d);
assertEquals(read.readDouble(1000, true), -65d);
assertEquals(read.readDouble(1000, false), -8192d);
assertEquals(read.readDouble(1000, true), -8192d);
assertEquals(1.23456d, read.readDouble());
}
public void testBooleans () {
runBooleanTest(new UnsafeOutput(4096));
runBooleanTest(new UnsafeOutput(new ByteArrayOutputStream()));
}
private void runBooleanTest (UnsafeOutput write) {
for (int i = 0; i < 100; i++) {
write.writeBoolean(true);
write.writeBoolean(false);
}
Input read = new UnsafeInput(write.toBytes());
for (int i = 0; i < 100; i++) {
assertEquals(true, read.readBoolean());
assertEquals(false, read.readBoolean());
}
}
public void testChars () {
runCharTest(new UnsafeOutput(4096));
runCharTest(new UnsafeOutput(new ByteArrayOutputStream()));
}
private void runCharTest (UnsafeOutput write) {
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);
Input read = new UnsafeInput(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());
}
// Check if writing varInts may produce more bytes than expected
public void testWriteTooManyBytes () {
ByteArrayOutputStream os = new ByteArrayOutputStream(1);
runVarIntTest(new UnsafeOutput(os, 4), os);
}
private void runVarIntTest (UnsafeOutput write, ByteArrayOutputStream os) {
write.writeVarInt(0, true);
write.writeVarInt(63, true);
write.writeVarInt(64, true);
write.writeVarInt(65535, true);
assertEquals(6, write.total());
write.flush();
assertEquals(6, os.size());
Input read = new UnsafeInput(os.toByteArray());
assertEquals(0, read.readVarInt(true));
assertEquals(63, read.readVarInt(true));
assertEquals(64, read.readVarInt(true));
assertEquals(65535, read.readVarInt(true));
assertEquals(true, read.eof());
read.close();
}
public void testSimpleVarInt() {
final int value = 39117;
final Output out = new UnsafeOutput(1024);
out.writeVarInt(value, true);
out.flush();
final Input in = new UnsafeInput(out.toBytes());
final int actualValue = in.readVarInt(true);
assertEquals(value, actualValue);
out.close();
in.close();
}
}

829
test/dorkbox/network/kryo/UnsafeMemoryInputOutputTest.java
View File

@ -1,829 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.Random;
import com.esotericsoftware.kryo.io.ByteBufferInput;
import com.esotericsoftware.kryo.io.ByteBufferOutput;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.UnsafeMemoryInput;
import com.esotericsoftware.kryo.io.UnsafeMemoryOutput;
import com.esotericsoftware.kryo.util.UnsafeUtil;
/** @author Roman Levenstein <romixlev@gmail.com> */
@SuppressWarnings("resource")
public class UnsafeMemoryInputOutputTest extends KryoTestCase {
public void testByteBufferOutputWithPreallocatedMemory () {
long bufAddress = UnsafeUtil.unsafe().allocateMemory(4096);
try {
ByteBufferOutput outputBuffer = new ByteBufferOutput(bufAddress, 4096);
outputBuffer.writeInt(10);
ByteBufferInput inputBuffer = new ByteBufferInput(outputBuffer.getByteBuffer());
inputBuffer.readInt();
inputBuffer.release();
inputBuffer.close();
outputBuffer.close();
outputBuffer.release();
outputBuffer = new UnsafeMemoryOutput(bufAddress, 4096);
outputBuffer.writeInt(10);
inputBuffer = new UnsafeMemoryInput(outputBuffer.getByteBuffer());
inputBuffer.readInt();
inputBuffer.release();
outputBuffer.release();
outputBuffer.close();
} catch (Throwable t) {
System.err.println("Streams with preallocated direct memory are not supported on this JVM");
t.printStackTrace();
} finally {
UnsafeUtil.unsafe().freeMemory(bufAddress);
}
}
public void testOutputStream () {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
UnsafeMemoryOutput output = new UnsafeMemoryOutput(buffer, 2);
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();
assertEquals(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.toByteArray());
output.close();
}
public void testInputStream () {
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};
ByteArrayInputStream buffer = new ByteArrayInputStream(bytes);
Input input = new UnsafeMemoryInput(buffer, 2);
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);
assertEquals(bytes, temp2);
input.close();
input = new UnsafeMemoryInput(bytes);
count = input.read(temp, 512, 512);
assertEquals(bytes.length, count);
temp2 = new byte[count];
System.arraycopy(temp, 512, temp2, 0, count);
assertEquals(bytes, temp2);
input.close();
}
public void testWriteBytes () {
UnsafeMemoryOutput buffer = new UnsafeMemoryOutput(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();
assertEquals(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());
buffer.close();
}
public void testStrings () {
runStringTest(new UnsafeMemoryOutput(4096));
runStringTest(new UnsafeMemoryOutput(897));
runStringTest(new UnsafeMemoryOutput(new ByteArrayOutputStream()));
UnsafeMemoryOutput write = new UnsafeMemoryOutput(21);
String value = "abcdef\u00E1\u00E9\u00ED\u00F3\u00FA\u1234";
write.writeString(value);
Input read = new UnsafeMemoryInput(write.toBytes());
assertEquals(value, read.readString());
runStringTest(127);
runStringTest(256);
runStringTest(1024 * 1023);
runStringTest(1024 * 1024);
runStringTest(1024 * 1025);
runStringTest(1024 * 1026);
runStringTest(1024 * 1024 * 2);
write.close();
read.close();
}
public void runStringTest (int length) {
UnsafeMemoryOutput write = new UnsafeMemoryOutput(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);
Input read = new UnsafeMemoryInput(write.toBytes());
assertEquals(value, read.readString());
assertEquals(value, read.readStringBuilder().toString());
write.clear();
write.writeString(buffer);
write.writeString(buffer);
read = new UnsafeMemoryInput(write.toBytes());
assertEquals(value, read.readStringBuilder().toString());
assertEquals(value, read.readString());
if (length <= 127) {
write.clear();
write.writeAscii(value);
write.writeAscii(value);
read = new UnsafeMemoryInput(write.toBytes());
assertEquals(value, read.readStringBuilder().toString());
assertEquals(value, read.readString());
}
}
public void runStringTest (UnsafeMemoryOutput write) {
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");
}
Input read = new UnsafeMemoryInput(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());
assertEquals(null, 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.rewind();
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());
assertEquals(null, 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());
}
}
public void testCanReadInt () {
UnsafeMemoryOutput write = new UnsafeMemoryOutput(new ByteArrayOutputStream());
Input read = new UnsafeMemoryInput(write.toBytes());
assertEquals(false, read.canReadInt());
write.writeVarInt(400, true);
read = new UnsafeMemoryInput(write.toBytes());
assertEquals(true, read.canReadInt());
read.setLimit(read.limit() - 1);
assertEquals(false, read.canReadInt());
}
public void testInts () {
runIntTest(new UnsafeMemoryOutput(4096));
runIntTest(new UnsafeMemoryOutput(new ByteArrayOutputStream()));
}
private void runIntTest (UnsafeMemoryOutput write) {
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(4, write.writeInt(0, true));
assertEquals(4, write.writeInt(0, false));
assertEquals(4, write.writeInt(63, true));
assertEquals(4, write.writeInt(63, false));
assertEquals(4, write.writeInt(64, true));
assertEquals(4, write.writeInt(64, false));
assertEquals(4, write.writeInt(127, true));
assertEquals(4, write.writeInt(127, false));
assertEquals(4, write.writeInt(128, true));
assertEquals(4, write.writeInt(128, false));
assertEquals(4, write.writeInt(8191, true));
assertEquals(4, write.writeInt(8191, false));
assertEquals(4, write.writeInt(8192, true));
assertEquals(4, write.writeInt(8192, false));
assertEquals(4, write.writeInt(16383, true));
assertEquals(4, write.writeInt(16383, false));
assertEquals(4, write.writeInt(16384, true));
assertEquals(4, write.writeInt(16384, false));
assertEquals(4, write.writeInt(2097151, true));
assertEquals(4, write.writeInt(2097151, false));
assertEquals(4, write.writeInt(1048575, true));
assertEquals(4, write.writeInt(1048575, false));
assertEquals(4, write.writeInt(134217727, true));
assertEquals(4, write.writeInt(134217727, false));
assertEquals(4, write.writeInt(268435455, true));
assertEquals(4, write.writeInt(268435455, false));
assertEquals(4, write.writeInt(134217728, true));
assertEquals(4, write.writeInt(134217728, false));
assertEquals(4, write.writeInt(268435456, true));
assertEquals(4, write.writeInt(268435456, false));
assertEquals(4, write.writeInt(-64, false));
assertEquals(4, write.writeInt(-64, true));
assertEquals(4, write.writeInt(-65, false));
assertEquals(4, write.writeInt(-65, true));
assertEquals(4, write.writeInt(-8192, false));
assertEquals(4, write.writeInt(-8192, true));
assertEquals(4, write.writeInt(-1048576, false));
assertEquals(4, write.writeInt(-1048576, true));
assertEquals(4, write.writeInt(-134217728, false));
assertEquals(4, write.writeInt(-134217728, true));
assertEquals(4, write.writeInt(-134217729, false));
assertEquals(4, write.writeInt(-134217729, true));
Input read = new UnsafeMemoryInput(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());
assertEquals(true, read.canReadInt());
assertEquals(true, read.canReadInt());
assertEquals(true, read.canReadInt());
assertEquals(0, read.readInt(true));
assertEquals(0, read.readInt(false));
assertEquals(63, read.readInt(true));
assertEquals(63, read.readInt(false));
assertEquals(64, read.readInt(true));
assertEquals(64, read.readInt(false));
assertEquals(127, read.readInt(true));
assertEquals(127, read.readInt(false));
assertEquals(128, read.readInt(true));
assertEquals(128, read.readInt(false));
assertEquals(8191, read.readInt(true));
assertEquals(8191, read.readInt(false));
assertEquals(8192, read.readInt(true));
assertEquals(8192, read.readInt(false));
assertEquals(16383, read.readInt(true));
assertEquals(16383, read.readInt(false));
assertEquals(16384, read.readInt(true));
assertEquals(16384, read.readInt(false));
assertEquals(2097151, read.readInt(true));
assertEquals(2097151, read.readInt(false));
assertEquals(1048575, read.readInt(true));
assertEquals(1048575, read.readInt(false));
assertEquals(134217727, read.readInt(true));
assertEquals(134217727, read.readInt(false));
assertEquals(268435455, read.readInt(true));
assertEquals(268435455, read.readInt(false));
assertEquals(134217728, read.readInt(true));
assertEquals(134217728, read.readInt(false));
assertEquals(268435456, read.readInt(true));
assertEquals(268435456, read.readInt(false));
assertEquals(-64, read.readInt(false));
assertEquals(-64, read.readInt(true));
assertEquals(-65, read.readInt(false));
assertEquals(-65, read.readInt(true));
assertEquals(-8192, read.readInt(false));
assertEquals(-8192, read.readInt(true));
assertEquals(-1048576, read.readInt(false));
assertEquals(-1048576, read.readInt(true));
assertEquals(-134217728, read.readInt(false));
assertEquals(-134217728, read.readInt(true));
assertEquals(-134217729, read.readInt(false));
assertEquals(-134217729, read.readInt(true));
assertEquals(false, read.canReadInt());
Random random = new Random();
for (int i = 0; i < 10000; i++) {
int value = random.nextInt();
write.clear();
write.writeInt(value);
write.writeInt(value, true);
write.writeInt(value, false);
read.setBuffer(write.toBytes());
assertEquals(value, read.readInt());
assertEquals(value, read.readInt(true));
assertEquals(value, read.readInt(false));
}
}
public void testLongs () {
runLongTest(new UnsafeMemoryOutput(4096));
runLongTest(new UnsafeMemoryOutput(new ByteArrayOutputStream()));
}
private void runLongTest (UnsafeMemoryOutput write) {
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(8, write.writeLong(0, true));
assertEquals(8, write.writeLong(0, false));
assertEquals(8, write.writeLong(63, true));
assertEquals(8, write.writeLong(63, false));
assertEquals(8, write.writeLong(64, true));
assertEquals(8, write.writeLong(64, false));
assertEquals(8, write.writeLong(127, true));
assertEquals(8, write.writeLong(127, false));
assertEquals(8, write.writeLong(128, true));
assertEquals(8, write.writeLong(128, false));
assertEquals(8, write.writeLong(8191, true));
assertEquals(8, write.writeLong(8191, false));
assertEquals(8, write.writeLong(8192, true));
assertEquals(8, write.writeLong(8192, false));
assertEquals(8, write.writeLong(16383, true));
assertEquals(8, write.writeLong(16383, false));
assertEquals(8, write.writeLong(16384, true));
assertEquals(8, write.writeLong(16384, false));
assertEquals(8, write.writeLong(2097151, true));
assertEquals(8, write.writeLong(2097151, false));
assertEquals(8, write.writeLong(1048575, true));
assertEquals(8, write.writeLong(1048575, false));
assertEquals(8, write.writeLong(134217727, true));
assertEquals(8, write.writeLong(134217727, false));
assertEquals(8, write.writeLong(268435455l, true));
assertEquals(8, write.writeLong(268435455l, false));
assertEquals(8, write.writeLong(134217728l, true));
assertEquals(8, write.writeLong(134217728l, false));
assertEquals(8, write.writeLong(268435456l, true));
assertEquals(8, write.writeLong(268435456l, false));
assertEquals(8, write.writeLong(-64, false));
assertEquals(8, write.writeLong(-64, true));
assertEquals(8, write.writeLong(-65, false));
assertEquals(8, write.writeLong(-65, true));
assertEquals(8, write.writeLong(-8192, false));
assertEquals(8, write.writeLong(-8192, true));
assertEquals(8, write.writeLong(-1048576, false));
assertEquals(8, write.writeLong(-1048576, true));
assertEquals(8, write.writeLong(-134217728, false));
assertEquals(8, write.writeLong(-134217728, true));
assertEquals(8, write.writeLong(-134217729, false));
assertEquals(8, write.writeLong(-134217729, true));
Input read = new UnsafeMemoryInput(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.readLong(true));
assertEquals(0, read.readLong(false));
assertEquals(63, read.readLong(true));
assertEquals(63, read.readLong(false));
assertEquals(64, read.readLong(true));
assertEquals(64, read.readLong(false));
assertEquals(127, read.readLong(true));
assertEquals(127, read.readLong(false));
assertEquals(128, read.readLong(true));
assertEquals(128, read.readLong(false));
assertEquals(8191, read.readLong(true));
assertEquals(8191, read.readLong(false));
assertEquals(8192, read.readLong(true));
assertEquals(8192, read.readLong(false));
assertEquals(16383, read.readLong(true));
assertEquals(16383, read.readLong(false));
assertEquals(16384, read.readLong(true));
assertEquals(16384, read.readLong(false));
assertEquals(2097151, read.readLong(true));
assertEquals(2097151, read.readLong(false));
assertEquals(1048575, read.readLong(true));
assertEquals(1048575, read.readLong(false));
assertEquals(134217727, read.readLong(true));
assertEquals(134217727, read.readLong(false));
assertEquals(268435455, read.readLong(true));
assertEquals(268435455, read.readLong(false));
assertEquals(134217728, read.readLong(true));
assertEquals(134217728, read.readLong(false));
assertEquals(268435456, read.readLong(true));
assertEquals(268435456, read.readLong(false));
assertEquals(-64, read.readLong(false));
assertEquals(-64, read.readLong(true));
assertEquals(-65, read.readLong(false));
assertEquals(-65, read.readLong(true));
assertEquals(-8192, read.readLong(false));
assertEquals(-8192, read.readLong(true));
assertEquals(-1048576, read.readLong(false));
assertEquals(-1048576, read.readLong(true));
assertEquals(-134217728, read.readLong(false));
assertEquals(-134217728, read.readLong(true));
assertEquals(-134217729, read.readLong(false));
assertEquals(-134217729, read.readLong(true));
Random random = new Random();
for (int i = 0; i < 10000; i++) {
long value = random.nextLong();
write.clear();
write.writeLong(value);
write.writeLong(value, true);
write.writeLong(value, false);
read.setBuffer(write.toBytes());
assertEquals("Element " + i, value, read.readLong());
assertEquals("Element " + i, value, read.readLong(true));
assertEquals("Element " + i, value, read.readLong(false));
}
}
public void testShorts () {
runShortTest(new UnsafeMemoryOutput(4096));
runShortTest(new UnsafeMemoryOutput(new ByteArrayOutputStream()));
}
private void runShortTest (UnsafeMemoryOutput write) {
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);
Input read = new UnsafeMemoryInput(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());
}
public void testFloats () {
runFloatTest(new UnsafeMemoryOutput(4096));
runFloatTest(new UnsafeMemoryOutput(new ByteArrayOutputStream()));
}
private void runFloatTest (UnsafeMemoryOutput write) {
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(4, write.writeFloat(0, 1000, true));
assertEquals(4, write.writeFloat(0, 1000, false));
assertEquals(4, write.writeFloat(63, 1000, true));
assertEquals(4, write.writeFloat(63, 1000, false));
assertEquals(4, write.writeFloat(64, 1000, true));
assertEquals(4, write.writeFloat(64, 1000, false));
assertEquals(4, write.writeFloat(127, 1000, true));
assertEquals(4, write.writeFloat(127, 1000, false));
assertEquals(4, write.writeFloat(128, 1000, true));
assertEquals(4, write.writeFloat(128, 1000, false));
assertEquals(4, write.writeFloat(8191, 1000, true));
assertEquals(4, write.writeFloat(8191, 1000, false));
assertEquals(4, write.writeFloat(8192, 1000, true));
assertEquals(4, write.writeFloat(8192, 1000, false));
assertEquals(4, write.writeFloat(16383, 1000, true));
assertEquals(4, write.writeFloat(16383, 1000, false));
assertEquals(4, write.writeFloat(16384, 1000, true));
assertEquals(4, write.writeFloat(16384, 1000, false));
assertEquals(4, write.writeFloat(32767, 1000, true));
assertEquals(4, write.writeFloat(32767, 1000, false));
assertEquals(4, write.writeFloat(-64, 1000, false));
assertEquals(4, write.writeFloat(-64, 1000, true));
assertEquals(4, write.writeFloat(-65, 1000, false));
assertEquals(4, write.writeFloat(-65, 1000, true));
assertEquals(4, write.writeFloat(-8192, 1000, false));
assertEquals(4, write.writeFloat(-8192, 1000, true));
Input read = new UnsafeMemoryInput(write.toBytes());
assertEquals(read.readFloat(), 0f);
assertEquals(read.readFloat(), 63f);
assertEquals(read.readFloat(), 64f);
assertEquals(read.readFloat(), 127f);
assertEquals(read.readFloat(), 128f);
assertEquals(read.readFloat(), 8192f);
assertEquals(read.readFloat(), 16384f);
assertEquals(read.readFloat(), 32767f);
assertEquals(read.readFloat(), -63f);
assertEquals(read.readFloat(), -64f);
assertEquals(read.readFloat(), -127f);
assertEquals(read.readFloat(), -128f);
assertEquals(read.readFloat(), -8192f);
assertEquals(read.readFloat(), -16384f);
assertEquals(read.readFloat(), -32768f);
assertEquals(read.readFloat(1000, true), 0f);
assertEquals(read.readFloat(1000, false), 0f);
assertEquals(read.readFloat(1000, true), 63f);
assertEquals(read.readFloat(1000, false), 63f);
assertEquals(read.readFloat(1000, true), 64f);
assertEquals(read.readFloat(1000, false), 64f);
assertEquals(read.readFloat(1000, true), 127f);
assertEquals(read.readFloat(1000, false), 127f);
assertEquals(read.readFloat(1000, true), 128f);
assertEquals(read.readFloat(1000, false), 128f);
assertEquals(read.readFloat(1000, true), 8191f);
assertEquals(read.readFloat(1000, false), 8191f);
assertEquals(read.readFloat(1000, true), 8192f);
assertEquals(read.readFloat(1000, false), 8192f);
assertEquals(read.readFloat(1000, true), 16383f);
assertEquals(read.readFloat(1000, false), 16383f);
assertEquals(read.readFloat(1000, true), 16384f);
assertEquals(read.readFloat(1000, false), 16384f);
assertEquals(read.readFloat(1000, true), 32767f);
assertEquals(read.readFloat(1000, false), 32767f);
assertEquals(read.readFloat(1000, false), -64f);
assertEquals(read.readFloat(1000, true), -64f);
assertEquals(read.readFloat(1000, false), -65f);
assertEquals(read.readFloat(1000, true), -65f);
assertEquals(read.readFloat(1000, false), -8192f);
assertEquals(read.readFloat(1000, true), -8192f);
}
public void testDoubles () {
runDoubleTest(new UnsafeMemoryOutput(4096));
runDoubleTest(new UnsafeMemoryOutput(new ByteArrayOutputStream()));
}
private void runDoubleTest (UnsafeMemoryOutput write) {
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(8, write.writeDouble(0, 1000, true));
assertEquals(8, write.writeDouble(0, 1000, false));
assertEquals(8, write.writeDouble(63, 1000, true));
assertEquals(8, write.writeDouble(63, 1000, false));
assertEquals(8, write.writeDouble(64, 1000, true));
assertEquals(8, write.writeDouble(64, 1000, false));
assertEquals(8, write.writeDouble(127, 1000, true));
assertEquals(8, write.writeDouble(127, 1000, false));
assertEquals(8, write.writeDouble(128, 1000, true));
assertEquals(8, write.writeDouble(128, 1000, false));
assertEquals(8, write.writeDouble(8191, 1000, true));
assertEquals(8, write.writeDouble(8191, 1000, false));
assertEquals(8, write.writeDouble(8192, 1000, true));
assertEquals(8, write.writeDouble(8192, 1000, false));
assertEquals(8, write.writeDouble(16383, 1000, true));
assertEquals(8, write.writeDouble(16383, 1000, false));
assertEquals(8, write.writeDouble(16384, 1000, true));
assertEquals(8, write.writeDouble(16384, 1000, false));
assertEquals(8, write.writeDouble(32767, 1000, true));
assertEquals(8, write.writeDouble(32767, 1000, false));
assertEquals(8, write.writeDouble(-64, 1000, false));
assertEquals(8, write.writeDouble(-64, 1000, true));
assertEquals(8, write.writeDouble(-65, 1000, false));
assertEquals(8, write.writeDouble(-65, 1000, true));
assertEquals(8, write.writeDouble(-8192, 1000, false));
assertEquals(8, write.writeDouble(-8192, 1000, true));
write.writeDouble(1.23456d);
Input read = new UnsafeMemoryInput(write.toBytes());
assertEquals(read.readDouble(), 0d);
assertEquals(read.readDouble(), 63d);
assertEquals(read.readDouble(), 64d);
assertEquals(read.readDouble(), 127d);
assertEquals(read.readDouble(), 128d);
assertEquals(read.readDouble(), 8192d);
assertEquals(read.readDouble(), 16384d);
assertEquals(read.readDouble(), 32767d);
assertEquals(read.readDouble(), -63d);
assertEquals(read.readDouble(), -64d);
assertEquals(read.readDouble(), -127d);
assertEquals(read.readDouble(), -128d);
assertEquals(read.readDouble(), -8192d);
assertEquals(read.readDouble(), -16384d);
assertEquals(read.readDouble(), -32768d);
assertEquals(read.readDouble(1000, true), 0d);
assertEquals(read.readDouble(1000, false), 0d);
assertEquals(read.readDouble(1000, true), 63d);
assertEquals(read.readDouble(1000, false), 63d);
assertEquals(read.readDouble(1000, true), 64d);
assertEquals(read.readDouble(1000, false), 64d);
assertEquals(read.readDouble(1000, true), 127d);
assertEquals(read.readDouble(1000, false), 127d);
assertEquals(read.readDouble(1000, true), 128d);
assertEquals(read.readDouble(1000, false), 128d);
assertEquals(read.readDouble(1000, true), 8191d);
assertEquals(read.readDouble(1000, false), 8191d);
assertEquals(read.readDouble(1000, true), 8192d);
assertEquals(read.readDouble(1000, false), 8192d);
assertEquals(read.readDouble(1000, true), 16383d);
assertEquals(read.readDouble(1000, false), 16383d);
assertEquals(read.readDouble(1000, true), 16384d);
assertEquals(read.readDouble(1000, false), 16384d);
assertEquals(read.readDouble(1000, true), 32767d);
assertEquals(read.readDouble(1000, false), 32767d);
assertEquals(read.readDouble(1000, false), -64d);
assertEquals(read.readDouble(1000, true), -64d);
assertEquals(read.readDouble(1000, false), -65d);
assertEquals(read.readDouble(1000, true), -65d);
assertEquals(read.readDouble(1000, false), -8192d);
assertEquals(read.readDouble(1000, true), -8192d);
assertEquals(1.23456d, read.readDouble());
read.close();
}
public void testBooleans () {
runBooleanTest(new UnsafeMemoryOutput(4096));
runBooleanTest(new UnsafeMemoryOutput(new ByteArrayOutputStream()));
}
private void runBooleanTest (UnsafeMemoryOutput write) {
for (int i = 0; i < 100; i++) {
write.writeBoolean(true);
write.writeBoolean(false);
}
Input read = new UnsafeMemoryInput(write.toBytes());
for (int i = 0; i < 100; i++) {
assertEquals(true, read.readBoolean());
assertEquals(false, read.readBoolean());
}
read.close();
}
public void testChars () {
runCharTest(new UnsafeMemoryOutput(4096));
runCharTest(new UnsafeMemoryOutput(new ByteArrayOutputStream()));
}
private void runCharTest (UnsafeMemoryOutput write) {
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);
Input read = new UnsafeMemoryInput(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());
read.close();
}
}

188
test/dorkbox/network/kryo/pool/KryoPoolBenchmarkTest.java
View File

@ -1,188 +0,0 @@
/* Copyright (c) 2008, 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 dorkbox.network.kryo.pool;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
import com.esotericsoftware.kryo.Kryo;
import dorkbox.network.kryo.FieldSerializerTest;
import dorkbox.objectPool.ObjectPool;
import dorkbox.objectPool.PoolableObject;
public
class KryoPoolBenchmarkTest {
private static final int WARMUP_ITERATIONS = 10000;
/**
* Number of runs.
*/
private static final int RUN_CNT = 10;
/**
* Number of iterations. Set it to something rather big for obtaining meaningful results
*/
// private static final int ITER_CNT = 200000;
private static final int ITER_CNT = 10000;
private static final int SLEEP_BETWEEN_RUNS = 100;
// not private to prevent the synthetic accessor method
static PoolableObject<Kryo> poolableObject = new PoolableObject<Kryo>() {
@Override
public
Kryo create() {
Kryo kryo = new Kryo();
kryo.register(FieldSerializerTest.DefaultTypes.class);
kryo.register(SampleObject.class);
return kryo;
}
};
@Test
public
void testWithoutPool() throws Exception {
// Warm-up phase: Perform 100000 iterations
runWithoutPool(1, WARMUP_ITERATIONS, false);
runWithoutPool(RUN_CNT, ITER_CNT, true);
}
@Test
public
void testWithPool() throws Exception {
// Warm-up phase: Perform 100000 iterations
runWithPool(ObjectPool.NonBlocking(poolableObject), 1, WARMUP_ITERATIONS, false);
runWithPool(ObjectPool.NonBlocking(poolableObject), RUN_CNT, ITER_CNT, true);
}
@Test
public
void testWithPoolWithSoftReferences() throws Exception {
// Warm-up phase: Perform 100000 iterations
runWithPool(ObjectPool.NonBlockingSoftReference(poolableObject), 1, WARMUP_ITERATIONS, false);
runWithPool(ObjectPool.NonBlockingSoftReference(poolableObject), RUN_CNT, ITER_CNT, true);
}
private
void run(String description, Runnable runnable, final int runCount, final int iterCount, boolean outputResults) throws Exception {
long avgDur = 0;
long bestTime = Long.MAX_VALUE;
for (int i = 0; i < runCount; i++) {
long start = System.nanoTime();
for (int j = 0; j < iterCount; j++) {
runnable.run();
}
long dur = System.nanoTime() - start;
dur = TimeUnit.NANOSECONDS.toMillis(dur);
if (outputResults)
System.out.format(">>> %s (run %d): %,d ms\n", description, i + 1, dur);
avgDur += dur;
bestTime = Math.min(bestTime, dur);
systemCleanupAfterRun();
}
avgDur /= runCount;
if (outputResults) {
System.out.format("\n>>> %s (average): %,d ms", description, avgDur);
System.out.format("\n>>> %s (best time): %,d ms\n\n", description, bestTime);
}
}
private
void runWithoutPool(final int runCount, final int iterCount, boolean outputResults) throws Exception {
run("Without pool", new Runnable() {
@Override
public
void run() {
poolableObject.create();
}
}, runCount, iterCount, outputResults);
}
private
void runWithPool(final ObjectPool<Kryo> pool, final int runCount, final int iterCount, boolean outputResults) throws Exception {
run("With pool " + pool.toString(), new Runnable() {
@Override
public
void run() {
Kryo kryo = pool.take();
pool.put(kryo);
}
}, runCount, iterCount, outputResults);
}
private
void systemCleanupAfterRun() throws InterruptedException {
System.gc();
Thread.sleep(SLEEP_BETWEEN_RUNS);
System.gc();
}
private static
class SampleObject {
private int intVal;
private float floatVal;
private Short shortVal;
private long[] longArr;
private double[] dblArr;
private String str;
public
SampleObject() {
}
SampleObject(int intVal, float floatVal, Short shortVal, long[] longArr, double[] dblArr, String str) {
this.intVal = intVal;
this.floatVal = floatVal;
this.shortVal = shortVal;
this.longArr = longArr;
this.dblArr = dblArr;
this.str = str;
}
/**
* {@inheritDoc}
*/
@Override
public
boolean equals(Object other) {
if (this == other)
return true;
if (other == null || getClass() != other.getClass())
return false;
SampleObject obj = (SampleObject) other;
return intVal == obj.intVal && floatVal == obj.floatVal && shortVal.equals(obj.shortVal) && Arrays.equals(dblArr, obj.dblArr) &&
Arrays.equals(longArr, obj.longArr) && (str == null ? obj.str == null : str.equals(obj.str));
}
}
}