Upgrade to Kryo 5rc2, updated to use utilities project as a maven release instead of compiling specific files
This commit is contained in:
parent
9a62e70b53
commit
8bd52dd202
124
build.gradle.kts
124
build.gradle.kts
@ -16,11 +16,8 @@
|
|||||||
|
|
||||||
import Build_gradle.Extras.bcVersion
|
import Build_gradle.Extras.bcVersion
|
||||||
import com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask
|
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.time.Instant
|
||||||
import java.util.Properties
|
import java.util.*
|
||||||
import kotlin.collections.ArrayList
|
|
||||||
import kotlin.collections.component1
|
import kotlin.collections.component1
|
||||||
import kotlin.collections.component2
|
import kotlin.collections.component2
|
||||||
import kotlin.collections.set
|
import kotlin.collections.set
|
||||||
@ -49,9 +46,9 @@ plugins {
|
|||||||
id("com.dorkbox.VersionUpdate") version "1.4.1"
|
id("com.dorkbox.VersionUpdate") version "1.4.1"
|
||||||
|
|
||||||
// setup checking for the latest version of a plugin or dependency
|
// 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 {
|
object Extras {
|
||||||
@ -247,91 +244,6 @@ repositories {
|
|||||||
jcenter()
|
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
|
////// Task defaults
|
||||||
///////////////////////////////
|
///////////////////////////////
|
||||||
@ -347,9 +259,6 @@ tasks.withType<Jar> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
tasks.jar.get().apply {
|
tasks.jar.get().apply {
|
||||||
// include applicable class files from subset of Utilities project
|
|
||||||
from((tasks["compileUtils"] as JavaCompile).outputs)
|
|
||||||
|
|
||||||
manifest {
|
manifest {
|
||||||
// https://docs.oracle.com/javase/tutorial/deployment/jar/packageman.html
|
// https://docs.oracle.com/javase/tutorial/deployment/jar/packageman.html
|
||||||
attributes["Name"] = Extras.name
|
attributes["Name"] = Extras.name
|
||||||
@ -372,26 +281,25 @@ tasks.compileJava.get().apply {
|
|||||||
|
|
||||||
|
|
||||||
dependencies {
|
dependencies {
|
||||||
val netty = api("io.netty:netty-all:4.1.32.Final")
|
implementation("io.netty:netty-all:4.1.34.Final")
|
||||||
val kryo = api("com.esotericsoftware:kryo:4.0.2")
|
implementation("com.esotericsoftware:kryo:5.0.0-RC2")
|
||||||
api("net.jpountz.lz4:lz4:1.3.0")
|
implementation("net.jpountz.lz4:lz4:1.3.0")
|
||||||
|
|
||||||
val bc = api("org.bouncycastle:bcprov-jdk15on:$bcVersion")
|
implementation("org.bouncycastle:bcprov-jdk15on:$bcVersion")
|
||||||
api("org.bouncycastle:bcpg-jdk15on:$bcVersion")
|
implementation("org.bouncycastle:bcpg-jdk15on:$bcVersion")
|
||||||
api("org.bouncycastle:bcmail-jdk15on:$bcVersion")
|
implementation("org.bouncycastle:bcmail-jdk15on:$bcVersion")
|
||||||
api("org.bouncycastle:bctls-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("junit:junit:4.12")
|
||||||
testCompile("ch.qos.logback:logback-classic:1.2.3")
|
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.
|
////// Gradle Wrapper Configuration.
|
||||||
///// Run this task, then refresh the gradle project
|
///// Run this task, then refresh the gradle project
|
||||||
///////////////////////////////
|
///////////////////////////////
|
||||||
val wrapperUpdate by tasks.creating(Wrapper::class) {
|
task<Wrapper>("wrapperUpdate") {
|
||||||
gradleVersion = "5.3"
|
gradleVersion = "5.3"
|
||||||
distributionUrl = distributionUrl.replace("bin", "all")
|
distributionUrl = distributionUrl.replace("bin", "all")
|
||||||
}
|
}
|
||||||
|
@ -35,10 +35,10 @@ import dorkbox.network.connection.ping.PingMessage;
|
|||||||
import dorkbox.util.Property;
|
import dorkbox.util.Property;
|
||||||
import dorkbox.util.collections.ConcurrentEntry;
|
import dorkbox.util.collections.ConcurrentEntry;
|
||||||
import dorkbox.util.generics.ClassHelper;
|
import dorkbox.util.generics.ClassHelper;
|
||||||
import dorkbox.util.generics.TypeResolver;
|
|
||||||
import io.netty.bootstrap.DatagramCloseMessage;
|
import io.netty.bootstrap.DatagramCloseMessage;
|
||||||
import io.netty.util.concurrent.ImmediateEventExecutor;
|
import io.netty.util.concurrent.ImmediateEventExecutor;
|
||||||
import io.netty.util.concurrent.Promise;
|
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.
|
// .equals() compares the identity on purpose,this because we cannot create two separate objects that are somehow equal to each other.
|
||||||
@SuppressWarnings("unchecked")
|
@SuppressWarnings("unchecked")
|
||||||
|
@ -22,9 +22,6 @@ import org.bouncycastle.crypto.modes.GCMBlockCipher;
|
|||||||
import org.bouncycastle.crypto.params.ParametersWithIV;
|
import org.bouncycastle.crypto.params.ParametersWithIV;
|
||||||
|
|
||||||
import com.esotericsoftware.kryo.Kryo;
|
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.ByteBufInput;
|
||||||
import dorkbox.network.pipeline.ByteBufOutput;
|
import dorkbox.network.pipeline.ByteBufOutput;
|
||||||
@ -93,7 +90,7 @@ class KryoExtra extends Kryo {
|
|||||||
|
|
||||||
public
|
public
|
||||||
KryoExtra(final NetworkSerializationManager serializationManager) {
|
KryoExtra(final NetworkSerializationManager serializationManager) {
|
||||||
super(new DefaultClassResolver(), new MapReferenceResolver(), new DefaultStreamFactory());
|
super();
|
||||||
|
|
||||||
this.serializationManager = serializationManager;
|
this.serializationManager = serializationManager;
|
||||||
}
|
}
|
||||||
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -43,9 +43,8 @@ class InvocationHandlerSerializer extends Serializer<Object> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
@SuppressWarnings({"unchecked", "AutoBoxing"})
|
|
||||||
public
|
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);
|
int objectID = input.readInt(true);
|
||||||
|
|
||||||
KryoExtra kryoExtra = (KryoExtra) kryo;
|
KryoExtra kryoExtra = (KryoExtra) kryo;
|
||||||
|
@ -19,6 +19,7 @@ import com.esotericsoftware.kryo.Kryo;
|
|||||||
import com.esotericsoftware.kryo.io.Input;
|
import com.esotericsoftware.kryo.io.Input;
|
||||||
import com.esotericsoftware.kryo.io.Output;
|
import com.esotericsoftware.kryo.io.Output;
|
||||||
import com.esotericsoftware.kryo.serializers.FieldSerializer;
|
import com.esotericsoftware.kryo.serializers.FieldSerializer;
|
||||||
|
|
||||||
import dorkbox.network.connection.KryoExtra;
|
import dorkbox.network.connection.KryoExtra;
|
||||||
|
|
||||||
public
|
public
|
||||||
@ -37,7 +38,7 @@ class InvocationResultSerializer extends FieldSerializer<InvokeMethodResult> {
|
|||||||
|
|
||||||
@Override
|
@Override
|
||||||
public
|
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);
|
InvokeMethodResult result = super.read(kryo, input, type);
|
||||||
result.rmiObjectId = input.readInt(true);
|
result.rmiObjectId = input.readInt(true);
|
||||||
return result;
|
return result;
|
||||||
|
@ -91,7 +91,7 @@ class InvokeMethodSerializer extends Serializer<InvokeMethod> {
|
|||||||
|
|
||||||
@Override
|
@Override
|
||||||
public
|
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 objectID = input.readInt(true);
|
||||||
int methodClassID = input.readInt(true);
|
int methodClassID = input.readInt(true);
|
||||||
byte methodIndex = input.readByte();
|
byte methodIndex = input.readByte();
|
||||||
|
@ -25,21 +25,24 @@ import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
|
|||||||
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
|
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
|
||||||
import org.bouncycastle.crypto.params.IESParameters;
|
import org.bouncycastle.crypto.params.IESParameters;
|
||||||
import org.bouncycastle.crypto.params.IESWithCipherParameters;
|
import org.bouncycastle.crypto.params.IESWithCipherParameters;
|
||||||
|
import org.objenesis.strategy.StdInstantiatorStrategy;
|
||||||
import org.slf4j.Logger;
|
import org.slf4j.Logger;
|
||||||
|
|
||||||
import com.esotericsoftware.kryo.Kryo;
|
import com.esotericsoftware.kryo.Kryo;
|
||||||
import com.esotericsoftware.kryo.KryoException;
|
import com.esotericsoftware.kryo.KryoException;
|
||||||
|
import com.esotericsoftware.kryo.Registration;
|
||||||
import com.esotericsoftware.kryo.Serializer;
|
import com.esotericsoftware.kryo.Serializer;
|
||||||
import com.esotericsoftware.kryo.factories.ReflectionSerializerFactory;
|
import com.esotericsoftware.kryo.SerializerFactory;
|
||||||
import com.esotericsoftware.kryo.factories.SerializerFactory;
|
import com.esotericsoftware.kryo.SerializerFactory.ReflectionSerializerFactory;
|
||||||
import com.esotericsoftware.kryo.io.Input;
|
import com.esotericsoftware.kryo.io.Input;
|
||||||
import com.esotericsoftware.kryo.io.Output;
|
import com.esotericsoftware.kryo.io.Output;
|
||||||
import com.esotericsoftware.kryo.serializers.CollectionSerializer;
|
import com.esotericsoftware.kryo.serializers.CollectionSerializer;
|
||||||
import com.esotericsoftware.kryo.serializers.FieldSerializer;
|
import com.esotericsoftware.kryo.serializers.FieldSerializer;
|
||||||
|
import com.esotericsoftware.kryo.util.DefaultInstantiatorStrategy;
|
||||||
import com.esotericsoftware.kryo.util.IdentityMap;
|
import com.esotericsoftware.kryo.util.IdentityMap;
|
||||||
import com.esotericsoftware.kryo.util.MapReferenceResolver;
|
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.Connection_;
|
||||||
import dorkbox.network.connection.KryoExtra;
|
import dorkbox.network.connection.KryoExtra;
|
||||||
import dorkbox.network.connection.ping.PingMessage;
|
import dorkbox.network.connection.ping.PingMessage;
|
||||||
@ -55,14 +58,12 @@ import dorkbox.network.rmi.RmiRegistrationSerializer;
|
|||||||
import dorkbox.network.rmi.RmiUtils;
|
import dorkbox.network.rmi.RmiUtils;
|
||||||
import dorkbox.objectPool.ObjectPool;
|
import dorkbox.objectPool.ObjectPool;
|
||||||
import dorkbox.objectPool.PoolableObject;
|
import dorkbox.objectPool.PoolableObject;
|
||||||
import dorkbox.util.Property;
|
import dorkbox.util.OS;
|
||||||
import dorkbox.util.collections.IntMap;
|
import dorkbox.util.collections.IntMap;
|
||||||
import dorkbox.util.serialization.ArraysAsListSerializer;
|
|
||||||
import dorkbox.util.serialization.EccPrivateKeySerializer;
|
import dorkbox.util.serialization.EccPrivateKeySerializer;
|
||||||
import dorkbox.util.serialization.EccPublicKeySerializer;
|
import dorkbox.util.serialization.EccPublicKeySerializer;
|
||||||
import dorkbox.util.serialization.IesParametersSerializer;
|
import dorkbox.util.serialization.IesParametersSerializer;
|
||||||
import dorkbox.util.serialization.IesWithCipherParametersSerializer;
|
import dorkbox.util.serialization.IesWithCipherParametersSerializer;
|
||||||
import dorkbox.util.serialization.UnmodifiableCollectionsSerializer;
|
|
||||||
import io.netty.bootstrap.DatagramCloseMessage;
|
import io.netty.bootstrap.DatagramCloseMessage;
|
||||||
import io.netty.buffer.ByteBuf;
|
import io.netty.buffer.ByteBuf;
|
||||||
import io.netty.buffer.ByteBufUtil;
|
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());
|
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
|
public static
|
||||||
Serialization DEFAULT() {
|
Serialization DEFAULT() {
|
||||||
return DEFAULT(true, true, null);
|
return DEFAULT(true, true, null);
|
||||||
@ -115,7 +109,7 @@ class Serialization implements NetworkSerializationManager {
|
|||||||
* Kryo#newDefaultSerializer(Class)
|
* Kryo#newDefaultSerializer(Class)
|
||||||
*/
|
*/
|
||||||
public static
|
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,
|
final Serialization serialization = new Serialization(references,
|
||||||
registrationRequired,
|
registrationRequired,
|
||||||
@ -137,11 +131,19 @@ class Serialization implements NetworkSerializationManager {
|
|||||||
serialization.register(StackTraceElement.class);
|
serialization.register(StackTraceElement.class);
|
||||||
serialization.register(StackTraceElement[].class);
|
serialization.register(StackTraceElement[].class);
|
||||||
|
|
||||||
// extra serializers
|
serialization.register(Arrays.asList().getClass());
|
||||||
//noinspection ArraysAsListWithZeroOrOneArgument
|
|
||||||
serialization.register(Arrays.asList("").getClass(), new ArraysAsListSerializer());
|
|
||||||
|
|
||||||
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;
|
return serialization;
|
||||||
}
|
}
|
||||||
@ -173,7 +175,7 @@ class Serialization implements NetworkSerializationManager {
|
|||||||
|
|
||||||
|
|
||||||
// reflectASM doesn't work on android
|
// 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 wireReadLogger;
|
||||||
private Logger wireWriteLogger;
|
private Logger wireWriteLogger;
|
||||||
|
|
||||||
@ -215,7 +217,11 @@ class Serialization implements NetworkSerializationManager {
|
|||||||
// we HAVE to pre-allocate the KRYOs
|
// we HAVE to pre-allocate the KRYOs
|
||||||
KryoExtra kryo = new KryoExtra(Serialization.this);
|
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.setRegistrationRequired(registrationRequired);
|
||||||
|
|
||||||
kryo.setReferences(references);
|
kryo.setReferences(references);
|
||||||
|
@ -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);
|
|
||||||
}
|
|
||||||
}
|
|
@ -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();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
@ -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");
|
|
||||||
}
|
|
||||||
}
|
|
@ -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();
|
|
||||||
}
|
|
||||||
}
|
|
@ -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"));
|
|
||||||
}
|
|
||||||
}
|
|
@ -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;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
@ -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;
|
|
||||||
}
|
|
||||||
}
|
|
@ -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 {
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
@ -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;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
File diff suppressed because it is too large
Load Diff
1014
test/dorkbox/network/kryo/InputOutputByteBufTest.java
Normal file
1014
test/dorkbox/network/kryo/InputOutputByteBufTest.java
Normal file
File diff suppressed because it is too large
Load Diff
@ -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();
|
|
||||||
}
|
|
||||||
}
|
|
@ -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
21
test/dorkbox/network/kryo/KryoAssert.java
Normal 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);
|
||||||
|
}
|
||||||
|
}
|
@ -1,4 +1,4 @@
|
|||||||
/* Copyright (c) 2008, Nathan Sweet
|
/* Copyright (c) 2008-2018, Nathan Sweet
|
||||||
* All rights reserved.
|
* All rights reserved.
|
||||||
*
|
*
|
||||||
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
|
* 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
|
* 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
|
* 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
|
* 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.
|
* 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;
|
package dorkbox.network.kryo;
|
||||||
import ch.qos.logback.classic.Logger;
|
|
||||||
import ch.qos.logback.classic.LoggerContext;
|
import static com.esotericsoftware.minlog.Log.WARN;
|
||||||
import ch.qos.logback.classic.joran.JoranConfigurator;
|
import static com.esotericsoftware.minlog.Log.warn;
|
||||||
import com.esotericsoftware.kryo.Kryo;
|
import static org.junit.Assert.assertEquals;
|
||||||
import com.esotericsoftware.kryo.Serializer;
|
import static org.junit.Assert.assertNull;
|
||||||
import com.esotericsoftware.kryo.io.*;
|
|
||||||
import junit.framework.TestCase;
|
|
||||||
import org.junit.Assert;
|
|
||||||
import org.slf4j.LoggerFactory;
|
|
||||||
|
|
||||||
import java.io.ByteArrayInputStream;
|
import java.io.ByteArrayInputStream;
|
||||||
import java.io.ByteArrayOutputStream;
|
import java.io.ByteArrayOutputStream;
|
||||||
import java.io.InputStream;
|
import java.io.InputStream;
|
||||||
import java.io.OutputStream;
|
import java.io.OutputStream;
|
||||||
import java.lang.reflect.Array;
|
import java.lang.reflect.Array;
|
||||||
|
import java.nio.ByteBuffer;
|
||||||
import java.util.ArrayList;
|
import java.util.ArrayList;
|
||||||
|
|
||||||
/**
|
import org.junit.Before;
|
||||||
* Convenience methods for round tripping objects.
|
|
||||||
*
|
|
||||||
* @author Nathan Sweet <misc@n4te.com>
|
|
||||||
*/
|
|
||||||
|
|
||||||
@SuppressWarnings({"rawtypes", "unchecked"})
|
import com.esotericsoftware.kryo.Kryo;
|
||||||
abstract public class KryoTestCase extends TestCase {
|
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();
|
/** Convenience methods for round tripping objects.
|
||||||
|
* @author Nathan Sweet */
|
||||||
// HACK offset by 5 from original because of changes in package name + 5 because it has ANOTHER subclass
|
abstract public class KryoTestCase {
|
||||||
protected int packageOffset = ORIGINAL_PACKAGE_LENGTH - this.getClass().getPackage().getName().length();
|
// 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 Kryo kryo;
|
||||||
protected Output output;
|
protected Output output;
|
||||||
@ -56,175 +57,128 @@ abstract public class KryoTestCase extends TestCase {
|
|||||||
protected Object object1, object2;
|
protected Object object1, object2;
|
||||||
protected boolean supportsCopy;
|
protected boolean supportsCopy;
|
||||||
|
|
||||||
static interface StreamFactory {
|
static interface BufferFactory {
|
||||||
Output createOutput(OutputStream os);
|
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
|
@Before
|
||||||
protected void setUp() throws Exception {
|
public void setUp () throws Exception {
|
||||||
// assume SLF4J is bound to logback in the current environment
|
if (debug && WARN) warn("*** DEBUG TEST ***");
|
||||||
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);
|
|
||||||
|
|
||||||
kryo = new Kryo();
|
kryo = new Kryo();
|
||||||
kryo.setReferences(false);
|
|
||||||
kryo.setRegistrationRequired(true);
|
|
||||||
// kryo.setAsmEnabled(false);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
public <T> T roundTrip(int length, int unsafeLength, T object1) {
|
/** @param length Pass Integer.MIN_VALUE to disable checking the length. */
|
||||||
roundTripWithStreamFactory(unsafeLength, object1, new StreamFactory() {
|
public <T> T roundTrip (int length, T object1) {
|
||||||
@Override
|
T object2 = roundTripWithBufferFactory(length, object1, new BufferFactory() {
|
||||||
public Output createOutput(OutputStream os) {
|
public Output createOutput (OutputStream os) {
|
||||||
return new UnsafeMemoryOutput(os);
|
return new Output(os);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
public Output createOutput (OutputStream os, int size) {
|
||||||
public Output createOutput(OutputStream os, int size) {
|
return new Output(os, size);
|
||||||
return new UnsafeMemoryOutput(os, size);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
public Output createOutput (int size, int limit) {
|
||||||
public Output createOutput(int size, int limit) {
|
return new Output(size, limit);
|
||||||
return new UnsafeMemoryOutput(size, limit);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
public Input createInput (InputStream os, int size) {
|
||||||
public Input createInput(InputStream os, int size) {
|
return new Input(os, size);
|
||||||
return new UnsafeMemoryInput(os, size);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
public Input createInput (byte[] buffer) {
|
||||||
public Input createInput(byte[] buffer) {
|
return new Input(buffer);
|
||||||
return new UnsafeMemoryInput(buffer);
|
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
||||||
roundTripWithStreamFactory(unsafeLength, object1, new StreamFactory() {
|
if (debug) return object2;
|
||||||
@Override
|
|
||||||
public Output createOutput(OutputStream os) {
|
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);
|
return new UnsafeOutput(os);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
public Output createOutput (OutputStream os, int size) {
|
||||||
public Output createOutput(OutputStream os, int size) {
|
|
||||||
return new UnsafeOutput(os, 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);
|
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);
|
return new UnsafeInput(os, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
public Input createInput (byte[] buffer) {
|
||||||
public Input createInput(byte[] buffer) {
|
|
||||||
return new UnsafeInput(buffer);
|
return new UnsafeInput(buffer);
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
||||||
roundTripWithStreamFactory(length, object1, new StreamFactory() {
|
roundTripWithBufferFactory(length, object1, new BufferFactory() {
|
||||||
@Override
|
public Output createOutput (OutputStream os) {
|
||||||
public Output createOutput(OutputStream os) {
|
return new UnsafeByteBufferOutput(os);
|
||||||
return new ByteBufferOutput(os);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
public Output createOutput (OutputStream os, int size) {
|
||||||
public Output createOutput(OutputStream os, int size) {
|
return new UnsafeByteBufferOutput(os, size);
|
||||||
return new ByteBufferOutput(os, size);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
public Output createOutput (int size, int limit) {
|
||||||
public Output createOutput(int size, int limit) {
|
return new UnsafeByteBufferOutput(size, limit);
|
||||||
return new ByteBufferOutput(size, limit);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
public Input createInput (InputStream os, int size) {
|
||||||
public Input createInput(InputStream os, int size) {
|
return new UnsafeByteBufferInput(os, size);
|
||||||
return new ByteBufferInput(os, size);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
public Input createInput (byte[] buffer) {
|
||||||
public Input createInput(byte[] buffer) {
|
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(buffer.length);
|
||||||
return new ByteBufferInput(buffer);
|
byteBuffer.put(buffer).flip();
|
||||||
|
return new UnsafeByteBufferInput(byteBuffer);
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
||||||
roundTripWithStreamFactory(unsafeLength, object1, new StreamFactory() {
|
return object2;
|
||||||
@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);
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}
|
}
|
||||||
|
|
||||||
public <T> T roundTripWithStreamFactory(int length, T object1,
|
/** @param length Pass Integer.MIN_VALUE to disable checking the length. */
|
||||||
StreamFactory sf) {
|
public <T> T roundTripWithBufferFactory (int length, T object1, BufferFactory sf) {
|
||||||
|
boolean checkLength = length != Integer.MIN_VALUE;
|
||||||
|
|
||||||
this.object1 = object1;
|
this.object1 = object1;
|
||||||
|
|
||||||
// Test output to stream, large buffer.
|
// Test output to stream, large buffer.
|
||||||
@ -233,15 +187,19 @@ abstract public class KryoTestCase extends TestCase {
|
|||||||
kryo.writeClassAndObject(output, object1);
|
kryo.writeClassAndObject(output, object1);
|
||||||
output.flush();
|
output.flush();
|
||||||
|
|
||||||
|
if (debug) System.out.println();
|
||||||
|
|
||||||
// Test input from stream, large buffer.
|
// Test input from stream, large buffer.
|
||||||
@SuppressWarnings("unused")
|
byte[] out = outStream.toByteArray();
|
||||||
byte[] out = outStream.toByteArray();
|
input = sf.createInput(new ByteArrayInputStream(outStream.toByteArray()), 4096);
|
||||||
input = sf.createInput(
|
|
||||||
new ByteArrayInputStream(outStream.toByteArray()), 4096);
|
|
||||||
object2 = kryo.readClassAndObject(input);
|
object2 = kryo.readClassAndObject(input);
|
||||||
assertEquals("Incorrect number of bytes read.", length, input.total());
|
doAssertEquals(object1, object2);
|
||||||
assertEquals("Incorrect number of bytes written.", length, output.total());
|
if (checkLength) {
|
||||||
assertEquals(object1, object2);
|
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.
|
// Test output to stream, small buffer.
|
||||||
outStream = new ByteArrayOutputStream();
|
outStream = new ByteArrayOutputStream();
|
||||||
@ -250,30 +208,25 @@ abstract public class KryoTestCase extends TestCase {
|
|||||||
output.flush();
|
output.flush();
|
||||||
|
|
||||||
// Test input from stream, small buffer.
|
// Test input from stream, small buffer.
|
||||||
input = sf.createInput(
|
input = sf.createInput(new ByteArrayInputStream(outStream.toByteArray()), 10);
|
||||||
new ByteArrayInputStream(outStream.toByteArray()), 10);
|
|
||||||
object2 = kryo.readClassAndObject(input);
|
object2 = kryo.readClassAndObject(input);
|
||||||
assertEquals("Incorrect number of bytes read.", length, input.total());
|
doAssertEquals(object1, object2);
|
||||||
assertEquals(object1, object2);
|
if (checkLength) assertEquals("Incorrect number of bytes read.", length, input.total());
|
||||||
|
|
||||||
if (object1 != null) {
|
if (object1 != null) {
|
||||||
// Test null with serializer.
|
// Test null with serializer.
|
||||||
Serializer serializer = kryo.getRegistration(object1.getClass())
|
Serializer serializer = kryo.getRegistration(object1.getClass()).getSerializer();
|
||||||
.getSerializer();
|
output.reset();
|
||||||
output.clear();
|
|
||||||
outStream.reset();
|
outStream.reset();
|
||||||
kryo.writeObjectOrNull(output, null, serializer);
|
kryo.writeObjectOrNull(output, null, serializer);
|
||||||
output.flush();
|
output.flush();
|
||||||
|
|
||||||
// Test null from byte array with and without serializer.
|
// Test null from byte array with and without serializer.
|
||||||
input = sf.createInput(
|
input = sf.createInput(new ByteArrayInputStream(outStream.toByteArray()), 10);
|
||||||
new ByteArrayInputStream(outStream.toByteArray()), 10);
|
assertNull(kryo.readObjectOrNull(input, object1.getClass(), serializer));
|
||||||
assertEquals(null, kryo.readObjectOrNull(input, object1.getClass(),
|
|
||||||
serializer));
|
|
||||||
|
|
||||||
input = sf.createInput(
|
input = sf.createInput(new ByteArrayInputStream(outStream.toByteArray()), 10);
|
||||||
new ByteArrayInputStream(outStream.toByteArray()), 10);
|
assertNull(kryo.readObjectOrNull(input, object1.getClass()));
|
||||||
assertEquals(null, kryo.readObjectOrNull(input, object1.getClass()));
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Test output to byte array.
|
// Test output to byte array.
|
||||||
@ -284,42 +237,40 @@ abstract public class KryoTestCase extends TestCase {
|
|||||||
// Test input from byte array.
|
// Test input from byte array.
|
||||||
input = sf.createInput(output.toBytes());
|
input = sf.createInput(output.toBytes());
|
||||||
object2 = kryo.readClassAndObject(input);
|
object2 = kryo.readClassAndObject(input);
|
||||||
assertEquals(object1, object2);
|
doAssertEquals(object1, object2);
|
||||||
assertEquals("Incorrect length.", length, output.total());
|
if (checkLength) {
|
||||||
assertEquals("Incorrect number of bytes read.", length, input.total());
|
assertEquals("Incorrect length.", length, output.total());
|
||||||
input.rewind();
|
assertEquals("Incorrect number of bytes read.", length, input.total());
|
||||||
|
}
|
||||||
|
input.reset();
|
||||||
|
|
||||||
if (supportsCopy) {
|
if (supportsCopy) {
|
||||||
// Test copy.
|
// Test copy.
|
||||||
T copy = kryo.copy(object1);
|
T copy = kryo.copy(object1);
|
||||||
assertEquals(object1, copy);
|
doAssertEquals(object1, copy);
|
||||||
copy = kryo.copyShallow(object1);
|
copy = kryo.copyShallow(object1);
|
||||||
assertEquals(object1, copy);
|
doAssertEquals(object1, copy);
|
||||||
}
|
}
|
||||||
|
|
||||||
return (T) object2;
|
return (T)object2;
|
||||||
}
|
}
|
||||||
|
|
||||||
static public void assertEquals(Object object1, Object object2) {
|
protected void doAssertEquals (Object object1, Object object2) {
|
||||||
Assert.assertEquals(arrayToList(object1), arrayToList(object2));
|
assertEquals(arrayToList(object1), arrayToList(object2));
|
||||||
}
|
}
|
||||||
|
|
||||||
static public Object arrayToList(Object array) {
|
static public Object arrayToList (Object array) {
|
||||||
if (array == null || !array.getClass().isArray()) {
|
if (array == null || !array.getClass().isArray()) return array;
|
||||||
return array;
|
|
||||||
}
|
|
||||||
ArrayList list = new ArrayList(Array.getLength(array));
|
ArrayList list = new ArrayList(Array.getLength(array));
|
||||||
for (int i = 0, n = Array.getLength(array); i < n; i++) {
|
for (int i = 0, n = Array.getLength(array); i < n; i++)
|
||||||
list.add(arrayToList(Array.get(array, i)));
|
list.add(arrayToList(Array.get(array, i)));
|
||||||
}
|
|
||||||
return list;
|
return list;
|
||||||
}
|
}
|
||||||
|
|
||||||
static public ArrayList list(Object... items) {
|
static public ArrayList list (Object... items) {
|
||||||
ArrayList list = new ArrayList();
|
ArrayList list = new ArrayList();
|
||||||
for (Object item : items) {
|
for (Object item : items)
|
||||||
list.add(item);
|
list.add(item);
|
||||||
}
|
|
||||||
return list;
|
return list;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -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;
|
|
||||||
}
|
|
||||||
}
|
|
@ -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);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
@ -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();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
@ -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;
|
|
||||||
}
|
|
||||||
}
|
|
@ -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();
|
|
||||||
}
|
|
||||||
}
|
|
@ -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();
|
|
||||||
}
|
|
||||||
}
|
|
@ -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));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
Loading…
Reference in New Issue
Block a user