Synthesiser / Serializer integration working

node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt

@@ -293,6 +293,7 @@ class SerializerFactory(val whitelist: ClassWhitelist = AllWhitelist) {
 
         private val primitiveTypeNames: Map<Class<*>, String> = mapOf(
                 Character::class.java to "char",
+                Char::class.java to "char",
                 Boolean::class.java to "boolean",
                 Byte::class.java to "byte",
                 UnsignedByte::class.java to "ubyte",
@@ -307,7 +308,6 @@ class SerializerFactory(val whitelist: ClassWhitelist = AllWhitelist) {
                 Decimal32::class.java to "decimal32",
                 Decimal64::class.java to "decimal62",
                 Decimal128::class.java to "decimal128",
-                Char::class.java to "char",
                 Date::class.java to "timestamp",
                 UUID::class.java to "uuid",
                 ByteArray::class.java to "binary",

node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/AMQPSchemaExtensions.kt

@@ -63,8 +63,7 @@ fun CompositeType.carpenterSchema(
 
         try {
             providesList.add(classLoaders.loadIfExists(it))
-        }
+        } catch (e: ClassNotFoundException) {
-        catch (e: ClassNotFoundException) {
             carpenterSchemas.addDepPair(this, name, it)
             isCreatable = false
         }
@@ -75,8 +74,7 @@ fun CompositeType.carpenterSchema(
     fields.forEach {
         try {
             m[it.name] = FieldFactory.newInstance(it.mandatory, it.name, it.getTypeAsClass(classLoaders))
-        }
+        } catch (e: ClassNotFoundException) {
-        catch (e: ClassNotFoundException) {
             carpenterSchemas.addDepPair(this, name, it.typeAsString())
             isCreatable = false
         }
@@ -91,17 +89,31 @@ fun CompositeType.carpenterSchema(
     }
 }
 
+// map a pair of (typename, mandatory) to the corresponding class type
+// where the mandatory AMQP flag maps to the types nullability
+val typeStrToType: Map<Pair<String, Boolean>, Class<out Any?>> = mapOf(
+        Pair("int", true) to Int::class.javaPrimitiveType!!,
+        Pair("int", false) to Integer::class.javaObjectType,
+        Pair("short", true) to Short::class.javaPrimitiveType!!,
+        Pair("short", false) to Short::class.javaObjectType,
+        Pair("long", true) to Long::class.javaPrimitiveType!!,
+        Pair("long", false) to Long::class.javaObjectType,
+        Pair("char", true) to Char::class.javaPrimitiveType!!,
+        Pair("char", false) to java.lang.Character::class.java,
+        Pair("boolean", true) to Boolean::class.javaPrimitiveType!!,
+        Pair("boolean", false) to Boolean::class.javaObjectType,
+        Pair("double", true) to Double::class.javaPrimitiveType!!,
+        Pair("double", false) to Double::class.javaObjectType,
+        Pair("float", true) to Float::class.javaPrimitiveType!!,
+        Pair("float", false) to Float::class.javaObjectType,
+        Pair("byte", true) to Byte::class.javaPrimitiveType!!,
+        Pair("byte", false) to Byte::class.javaObjectType
+)
+
 fun AMQPField.getTypeAsClass(
         classLoaders: List<ClassLoader> = listOf<ClassLoader>(ClassLoader.getSystemClassLoader())
-) = when (type) {
+) = typeStrToType[Pair(type, mandatory)] ?: when (type) {
-    "int"     -> if (mandatory) Integer::class.java else Int::class.javaPrimitiveType!!
     "string" -> String::class.java
-    "short"   -> Short::class.javaPrimitiveType!!
-    "long"    -> Long::class.javaPrimitiveType!!
-    "char"    -> Char::class.javaPrimitiveType!!
-    "boolean" -> Boolean::class.javaPrimitiveType!!
-    "double"  -> Double::class.javaPrimitiveType!!
-    "float"   -> Float::class.javaPrimitiveType!!
     "*" -> classLoaders.loadIfExists(requires[0])
     else -> classLoaders.loadIfExists(type)
 }
@@ -109,13 +121,14 @@ fun AMQPField.getTypeAsClass(
 fun AMQPField.validateType(
         classLoaders: List<ClassLoader> = listOf<ClassLoader>(ClassLoader.getSystemClassLoader())
 ) = when (type) {
-    "int", "string", "short", "long", "char", "boolean", "double", "float" -> true
+    "byte", "int", "string", "short", "long", "char", "boolean", "double", "float" -> true
     "*" -> classLoaders.exists(requires[0])
     else -> classLoaders.exists(type)
 }
 
-private fun List<ClassLoader>.exists (clazz: String) =
+private fun List<ClassLoader>.exists(clazz: String) = this.find {
-        this.find { try { it.loadClass(clazz); true } catch (e: ClassNotFoundException) { false } } != null
+    try { it.loadClass(clazz); true } catch (e: ClassNotFoundException) { false }
+} != null
 
 private fun List<ClassLoader>.loadIfExists(clazz: String): Class<*> {
     this.forEach {

node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializeNeedingCarpentryTests.kt

@@ -3,7 +3,7 @@ package net.corda.core.serialization.amqp
 import org.junit.Test
 import kotlin.test.*
 import net.corda.core.serialization.carpenter.*
-import java.lang.Character
+import org.apache.qpid.proton.codec.Data
 
 interface I {
     fun getName() : String
@@ -16,18 +16,331 @@ interface I {
  * replicates the situation where a reciever doesn't have some or all elements of a schema present on it's classpath
  */
 class DeserializeNeedingCarpentryTests {
+    class TestSerializationOutput(
+            private val verbose: Boolean,
+            serializerFactory: SerializerFactory = SerializerFactory()) : SerializationOutput(serializerFactory) {
+
+        override fun writeSchema(schema: Schema, data: Data) {
+            if (verbose) println(schema)
+            super.writeSchema(schema, data)
+        }
+    }
+
+    companion object {
+        /**
+         * If you want to see the schema encoded into the envelope after serialisation change this to true
+         */
+        private const val VERBOSE = false
+    }
+
+    val sf = SerializerFactory()
+
     @Test
     fun verySimpleType() {
         val testVal = 10
         val clazz = ClassCarpenter().build(ClassSchema("oneType", mapOf("a" to NonNullableField(Int::class.java))))
         val classInstance = clazz.constructors[0].newInstance(testVal)
 
-        val serialisedBytes = SerializationOutput().serialize(classInstance)
+        val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(classInstance)
-        val deserializedObj = DeserializationInput().deserialize(serialisedBytes)
+        val deserializedObj = DeserializationInput(sf).deserialize(serialisedBytes)
 
         assertEquals (testVal, deserializedObj::class.java.getMethod("getA").invoke(deserializedObj))
     }
 
+    @Test
+    fun singleInt() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "int" to NonNullableField(Integer::class.javaPrimitiveType!!)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(1))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(1, db::class.java.getMethod("getInt").invoke(db))
+    }
+
+    @Test
+    fun singleIntNullable() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "int" to NullableField(Integer::class.java)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(1))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(1, db::class.java.getMethod("getInt").invoke(db))
+    }
+
+    @Test
+    fun singleIntNullableNull() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "int" to NullableField(Integer::class.java)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(null))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(null, db::class.java.getMethod("getInt").invoke(db))
+    }
+
+    @Test
+    fun singleChar() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "char" to NonNullableField(Character::class.javaPrimitiveType!!)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance('a'))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals('a', db::class.java.getMethod("getChar").invoke(db))
+    }
+
+    @Test
+    fun singleCharNullable() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "char" to NullableField(Character::class.javaObjectType)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance('a'))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals('a', db::class.java.getMethod("getChar").invoke(db))
+    }
+
+    @Test
+    fun singleCharNullableNull() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "char" to NullableField(java.lang.Character::class.java)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(null))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(null, db::class.java.getMethod("getChar").invoke(db))
+    }
+
+    @Test
+    fun singleLong() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "long" to NonNullableField(Long::class.javaPrimitiveType!!)
+        )))
+
+        val l : Long  = 1
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(l))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(l, (db::class.java.getMethod("getLong").invoke(db)))
+    }
+
+    @Test
+    fun singleLongNullable() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "long" to NullableField(Long::class.javaObjectType)
+        )))
+
+        val l : Long  = 1
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(l))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(l, (db::class.java.getMethod("getLong").invoke(db)))
+    }
+
+    @Test
+    fun singleLongNullableNull() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "long" to NullableField(Long::class.javaObjectType)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(null))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(null, (db::class.java.getMethod("getLong").invoke(db)))
+    }
+
+    @Test
+    fun singleBoolean() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "boolean" to NonNullableField(Boolean::class.javaPrimitiveType!!)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(true))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(true, db::class.java.getMethod("getBoolean").invoke(db))
+    }
+
+    @Test
+    fun singleBooleanNullable() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "boolean" to NullableField(Boolean::class.javaObjectType)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(true))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(true, db::class.java.getMethod("getBoolean").invoke(db))
+    }
+
+    @Test
+    fun singleBooleanNullableNull() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "boolean" to NullableField(Boolean::class.javaObjectType)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(null))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(null, db::class.java.getMethod("getBoolean").invoke(db))
+    }
+
+    @Test
+    fun singleDouble() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "double" to NonNullableField(Double::class.javaPrimitiveType!!)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(10.0))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(10.0, db::class.java.getMethod("getDouble").invoke(db))
+    }
+
+    @Test
+    fun singleDoubleNullable() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "double" to NullableField(Double::class.javaObjectType)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(10.0))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(10.0, db::class.java.getMethod("getDouble").invoke(db))
+    }
+
+    @Test
+    fun singleDoubleNullableNull() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "double" to NullableField(Double::class.javaObjectType)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(null))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(null, db::class.java.getMethod("getDouble").invoke(db))
+    }
+
+    @Test
+    fun singleShort() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "short" to NonNullableField(Short::class.javaPrimitiveType!!)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(3.toShort()))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(3.toShort(), db::class.java.getMethod("getShort").invoke(db))
+    }
+
+    @Test
+    fun singleShortNullable() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "short" to NullableField(Short::class.javaObjectType)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(3.toShort()))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(3.toShort(), db::class.java.getMethod("getShort").invoke(db))
+    }
+
+    @Test
+    fun singleShortNullableNull() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "short" to NullableField(Short::class.javaObjectType)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(null))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(null, db::class.java.getMethod("getShort").invoke(db))
+    }
+
+    @Test
+    fun singleFloat() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "float" to NonNullableField(Float::class.javaPrimitiveType!!)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(10.0F))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(10.0F, db::class.java.getMethod("getFloat").invoke(db))
+    }
+
+    @Test
+    fun singleFloatNullable() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "float" to NullableField(Float::class.javaObjectType)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(10.0F))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(10.0F, db::class.java.getMethod("getFloat").invoke(db))
+    }
+
+    @Test
+    fun singleFloatNullableNull() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "float" to NullableField(Float::class.javaObjectType)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(null))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(null, db::class.java.getMethod("getFloat").invoke(db))
+    }
+
+    @Test
+    fun singleByte() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "byte" to NonNullableField(Byte::class.javaPrimitiveType!!)
+        )))
+
+        val b : Byte = 0b0101
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(b))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(b, db::class.java.getMethod("getByte").invoke(db))
+        assertEquals(0b0101, (db::class.java.getMethod("getByte").invoke(db) as Byte))
+    }
+
+    @Test
+    fun singleByteNullable() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "byte" to NullableField(Byte::class.javaObjectType)
+        )))
+
+        val b : Byte = 0b0101
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(b))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(b, db::class.java.getMethod("getByte").invoke(db))
+        assertEquals(0b0101, (db::class.java.getMethod("getByte").invoke(db) as Byte))
+    }
+
+    @Test
+    fun singleByteNullableNull() {
+        val clazz = ClassCarpenter().build(ClassSchema("single", mapOf(
+                "byte" to NullableField(Byte::class.javaObjectType)
+        )))
+
+        val sb = TestSerializationOutput(VERBOSE, sf).serialize(clazz.constructors.first().newInstance(null))
+        val db = DeserializationInput(sf).deserialize(sb)
+
+        assertEquals(null, db::class.java.getMethod("getByte").invoke(db))
+    }
+
     @Test
     fun simpleTypeKnownInterface() {
         val clazz = ClassCarpenter().build (ClassSchema(
@@ -36,8 +349,8 @@ class DeserializeNeedingCarpentryTests {
         val testVal = "Some Person"
         val classInstance = clazz.constructors[0].newInstance(testVal)
 
-        val serialisedBytes = SerializationOutput().serialize(classInstance)
+        val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(classInstance)
-        val deserializedObj = DeserializationInput().deserialize(serialisedBytes)
+        val deserializedObj = DeserializationInput(sf).deserialize(serialisedBytes)
 
         assertTrue(deserializedObj is I)
         assertEquals(testVal, (deserializedObj as I).getName())
@@ -53,8 +366,8 @@ class DeserializeNeedingCarpentryTests {
                 mapOf("inner" to NonNullableField(nestedClass))))
 
         val classInstance = outerClass.constructors.first().newInstance(nestedClass.constructors.first().newInstance("name"))
-        val serialisedBytes = SerializationOutput().serialize(classInstance)
+        val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(classInstance)
-        val deserializedObj = DeserializationInput().deserialize(serialisedBytes)
+        val deserializedObj = DeserializationInput(sf).deserialize(serialisedBytes)
 
         val inner = deserializedObj::class.java.getMethod("getInner").invoke(deserializedObj)
         assertEquals("name", inner::class.java.getMethod("getName").invoke(inner))
@@ -72,8 +385,8 @@ class DeserializeNeedingCarpentryTests {
                 nestedClass.constructors.first().newInstance("foo"),
                 nestedClass.constructors.first().newInstance("bar"))
 
-        val serialisedBytes = SerializationOutput().serialize(classInstance)
+        val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(classInstance)
-        val deserializedObj = DeserializationInput().deserialize(serialisedBytes)
+        val deserializedObj = DeserializationInput(sf).deserialize(serialisedBytes)
 
         assertEquals ("foo", deserializedObj.a::class.java.getMethod("getName").invoke(deserializedObj.a))
         assertEquals ("bar", deserializedObj.b::class.java.getMethod("getName").invoke(deserializedObj.b))
@@ -92,8 +405,8 @@ class DeserializeNeedingCarpentryTests {
                 unknownClass.constructors.first().newInstance(5, 6),
                 unknownClass.constructors.first().newInstance(7, 8)))
 
-        val serialisedBytes = SerializationOutput().serialize(toSerialise)
+        val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(toSerialise)
-        val deserializedObj = DeserializationInput().deserialize(serialisedBytes)
+        val deserializedObj = DeserializationInput(sf).deserialize(serialisedBytes)
         var sentinel = 1
         deserializedObj.l.forEach {
             assertEquals(sentinel++, it::class.java.getMethod("getV1").invoke(it))
@@ -114,9 +427,9 @@ class DeserializeNeedingCarpentryTests {
                 "name" to NonNullableField(String::class.java)),
                 interfaces = listOf (I::class.java, interfaceClass)))
 
-        val serialisedBytes = SerializationOutput().serialize(
+        val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(
                 concreteClass.constructors.first().newInstance(12, "timmy"))
-        val deserializedObj = DeserializationInput().deserialize(serialisedBytes)
+        val deserializedObj = DeserializationInput(sf).deserialize(serialisedBytes)
 
         assertTrue(deserializedObj is I)
         assertEquals("timmy", (deserializedObj as I).getName())
@@ -128,19 +441,75 @@ class DeserializeNeedingCarpentryTests {
     fun manyTypes() {
         val cc = ClassCarpenter()
 
-        val manyClass = cc.build (ClassSchema(
+        val manyClass = cc.build (ClassSchema("many", mapOf(
-                "many",
-                mapOf(
                 "intA" to NonNullableField (Int::class.java),
                 "intB" to NullableField (Integer::class.java),
+                "intC" to NullableField (Integer::class.java),
                 "strA" to NonNullableField (String::class.java),
                 "strB" to NullableField (String::class.java),
+                "strC" to NullableField (String::class.java),
                 "charA" to NonNullableField (Char::class.java),
-                        "charB" to NullableField (Character::class.java))))
+                "charB" to NullableField (Character::class.javaObjectType),
+                "charC" to NullableField (Character::class.javaObjectType),
+                "shortA" to NonNullableField (Short::class.javaPrimitiveType!!),
+                "shortB" to NullableField (Short::class.javaObjectType),
+                "shortC" to NullableField (Short::class.javaObjectType),
+                "longA" to NonNullableField (Long::class.javaPrimitiveType!!),
+                "longB" to NullableField(Long::class.javaObjectType),
+                "longC" to NullableField(Long::class.javaObjectType),
+                "booleanA" to NonNullableField (Boolean::class.javaPrimitiveType!!),
+                "booleanB" to NullableField (Boolean::class.javaObjectType),
+                "booleanC" to NullableField (Boolean::class.javaObjectType),
+                "doubleA" to NonNullableField (Double::class.javaPrimitiveType!!),
+                "doubleB" to NullableField (Double::class.javaObjectType),
+                "doubleC" to NullableField (Double::class.javaObjectType),
+                "floatA" to NonNullableField (Float::class.javaPrimitiveType!!),
+                "floatB" to NullableField (Float::class.javaObjectType),
+                "floatC" to NullableField (Float::class.javaObjectType),
+                "byteA" to NonNullableField (Byte::class.javaPrimitiveType!!),
+                "byteB" to NullableField (Byte::class.javaObjectType),
+                "byteC" to NullableField (Byte::class.javaObjectType))))
 
-        val serialisedBytes = SerializationOutput().serialize(
+        val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(
-                manyClass.constructors.first().newInstance(1, 2, "a", "b", 'c', 'd'))
+                manyClass.constructors.first().newInstance(
+                        1, 2, null,
+                        "a", "b", null,
+                        'c', 'd', null,
+                        3.toShort(), 4.toShort(), null,
+                        100.toLong(), 200.toLong(), null,
+                        true, false, null,
+                        10.0, 20.0, null,
+                        10.0F, 20.0F, null,
+                        0b0101.toByte(), 0b1010.toByte(), null))
 
-        val deserializedObj = DeserializationInput().deserialize(serialisedBytes)
+        val deserializedObj = DeserializationInput(sf).deserialize(serialisedBytes)
+
+        assertEquals(1,    deserializedObj::class.java.getMethod("getIntA").invoke(deserializedObj))
+        assertEquals(2,    deserializedObj::class.java.getMethod("getIntB").invoke(deserializedObj))
+        assertEquals(null, deserializedObj::class.java.getMethod("getIntC").invoke(deserializedObj))
+        assertEquals("a",  deserializedObj::class.java.getMethod("getStrA").invoke(deserializedObj))
+        assertEquals("b",  deserializedObj::class.java.getMethod("getStrB").invoke(deserializedObj))
+        assertEquals(null, deserializedObj::class.java.getMethod("getStrC").invoke(deserializedObj))
+        assertEquals('c',  deserializedObj::class.java.getMethod("getCharA").invoke(deserializedObj))
+        assertEquals('d',  deserializedObj::class.java.getMethod("getCharB").invoke(deserializedObj))
+        assertEquals(null, deserializedObj::class.java.getMethod("getCharC").invoke(deserializedObj))
+        assertEquals(3.toShort(), deserializedObj::class.java.getMethod("getShortA").invoke(deserializedObj))
+        assertEquals(4.toShort(), deserializedObj::class.java.getMethod("getShortB").invoke(deserializedObj))
+        assertEquals(null,        deserializedObj::class.java.getMethod("getShortC").invoke(deserializedObj))
+        assertEquals(100.toLong(), deserializedObj::class.java.getMethod("getLongA").invoke(deserializedObj))
+        assertEquals(200.toLong(), deserializedObj::class.java.getMethod("getLongB").invoke(deserializedObj))
+        assertEquals(null,         deserializedObj::class.java.getMethod("getLongC").invoke(deserializedObj))
+        assertEquals(true,  deserializedObj::class.java.getMethod("getBooleanA").invoke(deserializedObj))
+        assertEquals(false, deserializedObj::class.java.getMethod("getBooleanB").invoke(deserializedObj))
+        assertEquals(null,  deserializedObj::class.java.getMethod("getBooleanC").invoke(deserializedObj))
+        assertEquals(10.0, deserializedObj::class.java.getMethod("getDoubleA").invoke(deserializedObj))
+        assertEquals(20.0, deserializedObj::class.java.getMethod("getDoubleB").invoke(deserializedObj))
+        assertEquals(null, deserializedObj::class.java.getMethod("getDoubleC").invoke(deserializedObj))
+        assertEquals(10.0F, deserializedObj::class.java.getMethod("getFloatA").invoke(deserializedObj))
+        assertEquals(20.0F, deserializedObj::class.java.getMethod("getFloatB").invoke(deserializedObj))
+        assertEquals(null,  deserializedObj::class.java.getMethod("getFloatC").invoke(deserializedObj))
+        assertEquals(0b0101.toByte(), deserializedObj::class.java.getMethod("getByteA").invoke(deserializedObj))
+        assertEquals(0b1010.toByte(), deserializedObj::class.java.getMethod("getByteB").invoke(deserializedObj))
+        assertEquals(null,            deserializedObj::class.java.getMethod("getByteC").invoke(deserializedObj))
     }
 }