diff --git a/core/src/main/kotlin/net/corda/core/serialization/amqp/SerializerFactory.kt b/core/src/main/kotlin/net/corda/core/serialization/amqp/SerializerFactory.kt index 436e4fac60..7f2d95fddc 100644 --- a/core/src/main/kotlin/net/corda/core/serialization/amqp/SerializerFactory.kt +++ b/core/src/main/kotlin/net/corda/core/serialization/amqp/SerializerFactory.kt @@ -12,12 +12,6 @@ import java.lang.reflect.GenericArrayType import java.lang.reflect.ParameterizedType import java.lang.reflect.Type import java.lang.reflect.WildcardType -import java.lang.Float -import java.lang.Long -import java.lang.Short -import java.lang.Double -import java.lang.Character -//import java.lang.Boolean import java.util.* import java.util.concurrent.ConcurrentHashMap import java.util.concurrent.CopyOnWriteArrayList diff --git a/core/src/test/kotlin/net/corda/core/serialization/amqp/SerializationOutputTests.kt b/core/src/test/kotlin/net/corda/core/serialization/amqp/SerializationOutputTests.kt index 54771ac805..36d84c26a6 100644 --- a/core/src/test/kotlin/net/corda/core/serialization/amqp/SerializationOutputTests.kt +++ b/core/src/test/kotlin/net/corda/core/serialization/amqp/SerializationOutputTests.kt @@ -7,10 +7,12 @@ import net.corda.core.identity.AbstractParty import net.corda.core.serialization.CordaSerializable import net.corda.core.serialization.EmptyWhitelist import net.corda.core.serialization.KryoAMQPSerializer -import net.corda.core.CordaRuntimeException +import net.corda.core.serialization.amqp.SerializerFactory.Companion.isPrimitive +import net.corda.core.utilities.CordaRuntimeException import net.corda.nodeapi.RPCException import net.corda.testing.MEGA_CORP import net.corda.testing.MEGA_CORP_PUBKEY +import org.apache.qpid.proton.amqp.* import org.apache.qpid.proton.codec.DecoderImpl import org.apache.qpid.proton.codec.EncoderImpl import org.junit.Test @@ -27,6 +29,14 @@ import kotlin.test.assertTrue class SerializationOutputTests { data class Foo(val bar: String, val pub: Int) + data class testFloat(val f: Float) + + data class testDouble(val d: Double) + + data class testShort(val s: Short) + + data class testBoolean(val b : Boolean) + interface FooInterface { val pub: Int } @@ -159,12 +169,61 @@ class SerializationOutputTests { return desObj2 } + @Test + fun isPrimitive() { + assertTrue(isPrimitive(Character::class.java)) + assertTrue(isPrimitive(Boolean::class.java)) + assertTrue(isPrimitive(Byte::class.java)) + assertTrue(isPrimitive(UnsignedByte::class.java)) + assertTrue(isPrimitive(Short::class.java)) + assertTrue(isPrimitive(UnsignedShort::class.java)) + assertTrue(isPrimitive(Int::class.java)) + assertTrue(isPrimitive(UnsignedInteger::class.java)) + assertTrue(isPrimitive(Long::class.java)) + assertTrue(isPrimitive(UnsignedLong::class.java)) + assertTrue(isPrimitive(Float::class.java)) + assertTrue(isPrimitive(Double::class.java)) + assertTrue(isPrimitive(Decimal32::class.java)) + assertTrue(isPrimitive(Decimal64::class.java)) + assertTrue(isPrimitive(Decimal128::class.java)) + assertTrue(isPrimitive(Char::class.java)) + assertTrue(isPrimitive(Date::class.java)) + assertTrue(isPrimitive(UUID::class.java)) + assertTrue(isPrimitive(ByteArray::class.java)) + assertTrue(isPrimitive(String::class.java)) + assertTrue(isPrimitive(Symbol::class.java)) + } + @Test fun `test foo`() { val obj = Foo("Hello World!", 123) serdes(obj) } + @Test + fun `test float`() { + val obj = testFloat(10.0F) + serdes(obj) + } + + @Test + fun `test double`() { + val obj = testDouble(10.0) + serdes(obj) + } + + @Test + fun `test short`() { + val obj = testShort(1) + serdes(obj) + } + + @Test + fun `test bool`() { + val obj = testBoolean(true) + serdes(obj) + } + @Test fun `test foo implements`() { val obj = FooImplements("Hello World!", 123) @@ -524,4 +583,4 @@ class SerializationOutputTests { val obj = StateRef(SecureHash.randomSHA256(), 0) serdes(obj, factory, factory2) } -} \ No newline at end of file +} diff --git a/experimental/src/main/kotlin/net/corda/carpenter/MetaCapenter.kt b/experimental/src/main/kotlin/net/corda/carpenter/MetaCapenter.kt index 3595716cf2..cdbdcadf58 100644 --- a/experimental/src/main/kotlin/net/corda/carpenter/MetaCapenter.kt +++ b/experimental/src/main/kotlin/net/corda/carpenter/MetaCapenter.kt @@ -5,6 +5,8 @@ import net.corda.core.serialization.carpenter.Schema import net.corda.core.serialization.amqp.CompositeType +/**********************************************************************************************************************/ + abstract class MetaCarpenterBase (val schemas : CarpenterSchemas) { private val cc = ClassCarpenter() @@ -35,6 +37,8 @@ abstract class MetaCarpenterBase (val schemas : CarpenterSchemas) { abstract fun build() } +/**********************************************************************************************************************/ + class MetaCarpenter (schemas : CarpenterSchemas) : MetaCarpenterBase (schemas) { override fun build() { while (schemas.carpenterSchemas.isNotEmpty()) { @@ -44,6 +48,8 @@ class MetaCarpenter (schemas : CarpenterSchemas) : MetaCarpenterBase (schemas) { } } +/**********************************************************************************************************************/ + class TestMetaCarpenter (schemas : CarpenterSchemas) : MetaCarpenterBase (schemas) { override fun build() { println ("TestMetaCarpenter::build") @@ -51,3 +57,5 @@ class TestMetaCarpenter (schemas : CarpenterSchemas) : MetaCarpenterBase (schema step (schemas.carpenterSchemas.removeAt(0)) } } + +/**********************************************************************************************************************/ diff --git a/experimental/src/test/kotlin/net/corda/carpenter/ClassCarpenterTestUtils.kt b/experimental/src/test/kotlin/net/corda/carpenter/ClassCarpenterTestUtils.kt index 09f768dcef..8b2c97cf07 100644 --- a/experimental/src/test/kotlin/net/corda/carpenter/ClassCarpenterTestUtils.kt +++ b/experimental/src/test/kotlin/net/corda/carpenter/ClassCarpenterTestUtils.kt @@ -15,31 +15,32 @@ fun curruptName(name: String) = "${name}__carpenter" /* given a list of class names work through the amqp envelope schema and alter any that match in the fashion defined above */ -fun Schema.curruptName (names: List) : Schema { - val newTypes : MutableList = mutableListOf() +fun Schema.curruptName(names: List): Schema { + val newTypes: MutableList = mutableListOf() for (type in types) { - val newName = if (type.name in names) curruptName (type.name) else type.name + val newName = if (type.name in names) curruptName(type.name) else type.name val newProvides = type.provides.map { - it -> if (it in names) curruptName (it) else it + it -> + if (it in names) curruptName(it) else it } val newFields = mutableListOf() (type as CompositeType).fields.forEach { - val type = if (it.type in names) curruptName (it.type) else it.type + val type = if (it.type in names) curruptName(it.type) else it.type val requires = if (it.requires.isNotEmpty() && (it.requires[0] in names)) - listOf (curruptName (it.requires[0])) else it.requires + listOf(curruptName(it.requires[0])) else it.requires - newFields.add (it.copy (type=type, requires=requires)) + newFields.add(it.copy(type = type, requires = requires)) } - newTypes.add (type.copy (name=newName, provides=newProvides, fields=newFields)) + newTypes.add(type.copy(name = newName, provides = newProvides, fields = newFields)) } - return Schema (types=newTypes) + return Schema(types = newTypes) } /**********************************************************************************************************************/ @@ -47,7 +48,7 @@ fun Schema.curruptName (names: List) : Schema { open class AmqpCarpenterBase { var factory = SerializerFactory() - fun serialise (clazz : Any) = SerializationOutput(factory).serialize(clazz) + fun serialise(clazz: Any) = SerializationOutput(factory).serialize(clazz) fun testName() = Thread.currentThread().stackTrace[2].methodName inline fun classTestName(clazz: String) = "${this.javaClass.name}\$${testName()}\$$clazz" } diff --git a/experimental/src/test/kotlin/net/corda/carpenter/CompositeMemberCompositeSchemaToClassCarpenterTests.kt b/experimental/src/test/kotlin/net/corda/carpenter/CompositeMemberCompositeSchemaToClassCarpenterTests.kt index 046a331f89..07c0898f13 100644 --- a/experimental/src/test/kotlin/net/corda/carpenter/CompositeMemberCompositeSchemaToClassCarpenterTests.kt +++ b/experimental/src/test/kotlin/net/corda/carpenter/CompositeMemberCompositeSchemaToClassCarpenterTests.kt @@ -20,7 +20,7 @@ interface I_ { class CompositeMembers : AmqpCarpenterBase() { @Test - fun bothKnown () { + fun bothKnown() { val testA = 10 val testB = 20 @@ -28,7 +28,7 @@ class CompositeMembers : AmqpCarpenterBase() { data class A(val a: Int) @CordaSerializable - data class B (val a: A, var b: Int) + data class B(val a: A, var b: Int) val b = B(A(testA), testB) @@ -44,11 +44,8 @@ class CompositeMembers : AmqpCarpenterBase() { assert(obj.second.schema.types[0] is CompositeType) assert(obj.second.schema.types[1] is CompositeType) - println (obj.second.schema.types[0] as CompositeType) - println (obj.second.schema.types[1] as CompositeType) - - var amqpSchemaA : CompositeType? = null - var amqpSchemaB : CompositeType? = null + var amqpSchemaA: CompositeType? = null + var amqpSchemaB: CompositeType? = null for (type in obj.second.schema.types) { when (type.name.split ("$").last()) { @@ -57,37 +54,36 @@ class CompositeMembers : AmqpCarpenterBase() { } } - assert (amqpSchemaA != null) - assert (amqpSchemaB != null) + assert(amqpSchemaA != null) + assert(amqpSchemaB != null) /* * Just ensure the amqp schema matches what we want before we go messing * around with the internals */ - assertEquals(1, amqpSchemaA?.fields?.size) - assertEquals("a", amqpSchemaA!!.fields[0].name) + assertEquals(1, amqpSchemaA?.fields?.size) + assertEquals("a", amqpSchemaA!!.fields[0].name) assertEquals("int", amqpSchemaA.fields[0].type) - - assertEquals(2, amqpSchemaB?.fields?.size) - assertEquals("a", amqpSchemaB!!.fields[0].name) + assertEquals(2, amqpSchemaB?.fields?.size) + assertEquals("a", amqpSchemaB!!.fields[0].name) assertEquals(classTestName("A"), amqpSchemaB.fields[0].type) - assertEquals("b", amqpSchemaB.fields[1].name) + assertEquals("b", amqpSchemaB.fields[1].name) assertEquals("int", amqpSchemaB.fields[1].type) val metaSchema = obj.second.schema.carpenterSchema() /* if we know all the classes there is nothing to really achieve here */ - assert (metaSchema.carpenterSchemas.isEmpty()) - assert (metaSchema.dependsOn.isEmpty()) - assert (metaSchema.dependencies.isEmpty()) + assert(metaSchema.carpenterSchemas.isEmpty()) + assert(metaSchema.dependsOn.isEmpty()) + assert(metaSchema.dependencies.isEmpty()) } /* you cannot have an element of a composite class we know about that is unknown as that should be impossible. If we have the containing class in the class path then we must have all of it's constituent elements */ @Test(expected = UncarpentableException::class) - fun nestedIsUnknown () { + fun nestedIsUnknown() { val testA = 10 val testB = 20 @@ -96,7 +92,8 @@ class CompositeMembers : AmqpCarpenterBase() { @CordaSerializable data class B(val a: A, var b: Int) - val b = B(A(testA), testB) + + val b = B(A(testA), testB) val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b)) val amqpSchema = obj.second.schema.curruptName(listOf (classTestName ("A"))) @@ -107,7 +104,7 @@ class CompositeMembers : AmqpCarpenterBase() { } @Test - fun ParentIsUnknown () { + fun ParentIsUnknown() { val testA = 10 val testB = 20 @@ -116,27 +113,28 @@ class CompositeMembers : AmqpCarpenterBase() { @CordaSerializable data class B(val a: A, var b: Int) + val b = B(A(testA), testB) val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b)) assert(obj.first is B) - val amqpSchema = obj.second.schema.curruptName(listOf (classTestName ("B"))) + val amqpSchema = obj.envelope.schema.curruptName(listOf(classTestName("B"))) val carpenterSchema = amqpSchema.carpenterSchema() - assertEquals (1, carpenterSchema.size) + assertEquals(1, carpenterSchema.size) - val metaCarpenter = MetaCarpenter (carpenterSchema) + val metaCarpenter = MetaCarpenter(carpenterSchema) metaCarpenter.build() - assert (curruptName(classTestName("B")) in metaCarpenter.objects) + assert(curruptName(classTestName("B")) in metaCarpenter.objects) } @Test - fun BothUnkown () { + fun BothUnkown() { val testA = 10 val testB = 20 @@ -145,54 +143,55 @@ class CompositeMembers : AmqpCarpenterBase() { @CordaSerializable data class B(val a: A, var b: Int) + val b = B(A(testA), testB) val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b)) assert(obj.first is B) - val amqpSchema = obj.second.schema.curruptName(listOf (classTestName ("A"), classTestName ("B"))) + val amqpSchema = obj.envelope.schema.curruptName(listOf(classTestName("A"), classTestName("B"))) val carpenterSchema = amqpSchema.carpenterSchema() /* just verify we're in the expected initial state, A is carpentable, B is not because it depends on A and the dependency chains are in place */ - assertEquals (1, carpenterSchema.size) - assertEquals (curruptName(classTestName("A")), carpenterSchema.carpenterSchemas.first().name) - assertEquals (1, carpenterSchema.dependencies.size) - assert (curruptName(classTestName("B")) in carpenterSchema.dependencies) - assertEquals (1, carpenterSchema.dependsOn.size) - assert (curruptName(classTestName("A")) in carpenterSchema.dependsOn) + assertEquals(1, carpenterSchema.size) + assertEquals(curruptName(classTestName("A")), carpenterSchema.carpenterSchemas.first().name) + assertEquals(1, carpenterSchema.dependencies.size) + assert(curruptName(classTestName("B")) in carpenterSchema.dependencies) + assertEquals(1, carpenterSchema.dependsOn.size) + assert(curruptName(classTestName("A")) in carpenterSchema.dependsOn) /* test meta carpenter lets us single step over the creation */ - val metaCarpenter = TestMetaCarpenter (carpenterSchema) + val metaCarpenter = TestMetaCarpenter(carpenterSchema) /* we've built nothing so nothing should be there */ - assertEquals (0, metaCarpenter.objects.size) + assertEquals(0, metaCarpenter.objects.size) /* first iteration, carpent A, resolve deps and mark B as carpentable */ metaCarpenter.build() /* one build iteration should have carpetned up A and worked out that B is now buildable given it's depedencies have been satisfied */ - assertTrue (curruptName(classTestName("A")) in metaCarpenter.objects) - assertFalse (curruptName(classTestName("B")) in metaCarpenter.objects) + assertTrue(curruptName(classTestName("A")) in metaCarpenter.objects) + assertFalse(curruptName(classTestName("B")) in metaCarpenter.objects) - assertEquals (1, carpenterSchema.carpenterSchemas.size) - assertEquals (curruptName(classTestName("B")), carpenterSchema.carpenterSchemas.first().name) - assertTrue (carpenterSchema.dependencies.isEmpty()) - assertTrue (carpenterSchema.dependsOn.isEmpty()) + assertEquals(1, carpenterSchema.carpenterSchemas.size) + assertEquals(curruptName(classTestName("B")), carpenterSchema.carpenterSchemas.first().name) + assertTrue(carpenterSchema.dependencies.isEmpty()) + assertTrue(carpenterSchema.dependsOn.isEmpty()) /* second manual iteration, will carpent B */ metaCarpenter.build() - assert (curruptName(classTestName("A")) in metaCarpenter.objects) - assert (curruptName(classTestName("B")) in metaCarpenter.objects) + assert(curruptName(classTestName("A")) in metaCarpenter.objects) + assert(curruptName(classTestName("B")) in metaCarpenter.objects) - assertTrue (carpenterSchema.carpenterSchemas.isEmpty()) + assertTrue(carpenterSchema.carpenterSchemas.isEmpty()) } @Test(expected = UncarpentableException::class) - fun nestedIsUnkownInherited () { + fun nestedIsUnkownInherited() { val testA = 10 val testB = 20 val testC = 30 @@ -201,7 +200,7 @@ class CompositeMembers : AmqpCarpenterBase() { open class A(val a: Int) @CordaSerializable - class B(a: Int, var b: Int) : A (a) + class B(a: Int, var b: Int) : A(a) @CordaSerializable data class C(val b: B, var c: Int) @@ -212,13 +211,13 @@ class CompositeMembers : AmqpCarpenterBase() { assert(obj.first is C) - val amqpSchema = obj.second.schema.curruptName(listOf (classTestName ("A"), classTestName ("B"))) + val amqpSchema = obj.envelope.schema.curruptName(listOf(classTestName("A"), classTestName("B"))) amqpSchema.carpenterSchema() } @Test(expected = UncarpentableException::class) - fun nestedIsUnknownInheritedUnkown () { + fun nestedIsUnknownInheritedUnkown() { val testA = 10 val testB = 20 val testC = 30 @@ -227,7 +226,7 @@ class CompositeMembers : AmqpCarpenterBase() { open class A(val a: Int) @CordaSerializable - class B(a: Int, var b: Int) : A (a) + class B(a: Int, var b: Int) : A(a) @CordaSerializable data class C(val b: B, var c: Int) @@ -238,13 +237,13 @@ class CompositeMembers : AmqpCarpenterBase() { assert(obj.first is C) - val amqpSchema = obj.second.schema.curruptName(listOf (classTestName ("A"), classTestName ("B"))) + val amqpSchema = obj.envelope.schema.curruptName(listOf(classTestName("A"), classTestName("B"))) amqpSchema.carpenterSchema() } @Test - fun parentsIsUnknownWithUnkownInheritedMember () { + fun parentsIsUnknownWithUnkownInheritedMember() { val testA = 10 val testB = 20 val testC = 30 @@ -253,7 +252,7 @@ class CompositeMembers : AmqpCarpenterBase() { open class A(val a: Int) @CordaSerializable - class B(a: Int, var b: Int) : A (a) + class B(a: Int, var b: Int) : A(a) @CordaSerializable data class C(val b: B, var c: Int) @@ -264,7 +263,7 @@ class CompositeMembers : AmqpCarpenterBase() { assert(obj.first is C) - val amqpSchema = obj.second.schema.curruptName(listOf (classTestName ("A"), classTestName ("B"))) + val amqpSchema = obj.envelope.schema.curruptName(listOf(classTestName("A"), classTestName("B"))) } @@ -273,7 +272,7 @@ class CompositeMembers : AmqpCarpenterBase() { * but we do know about I_ */ @Test - fun nestedIsInterfaceToUnknown () { + fun nestedIsInterfaceToUnknown() { val testA = 10 val testB = 20 @@ -282,7 +281,8 @@ class CompositeMembers : AmqpCarpenterBase() { @CordaSerializable data class B(val a: A, var b: Int) - val b = B(A(testA), testB) + + val b = B(A(testA), testB) val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b)) @@ -299,6 +299,7 @@ class CompositeMembers : AmqpCarpenterBase() { @CordaSerializable data class B(val a: A, var b: Int) + val b = B(A(testA), testB) val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b)) @@ -316,6 +317,7 @@ class CompositeMembers : AmqpCarpenterBase() { @CordaSerializable data class B(val a: A, var b: Int) + val b = B(A(testA), testB) val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b)) diff --git a/experimental/src/test/kotlin/net/corda/carpenter/InheritanceSchemaToClassCarpenterTests.kt b/experimental/src/test/kotlin/net/corda/carpenter/InheritanceSchemaToClassCarpenterTests.kt index a9c61866a8..a7d25841be 100644 --- a/experimental/src/test/kotlin/net/corda/carpenter/InheritanceSchemaToClassCarpenterTests.kt +++ b/experimental/src/test/kotlin/net/corda/carpenter/InheritanceSchemaToClassCarpenterTests.kt @@ -11,31 +11,31 @@ import kotlin.test.* @CordaSerializable interface J { - val j : Int + val j: Int } /*******************************************************************************************************/ @CordaSerializable interface I { - val i : Int + val i: Int } @CordaSerializable interface II { - val ii : Int + val ii: Int } @CordaSerializable interface III : I { - val iii : Int + val iii: Int override val i: Int } @CordaSerializable interface IIII { - val iiii : Int - val i : I + val iiii: Int + val i: I } /*******************************************************************************************************/ @@ -66,14 +66,14 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() { it's extremely unlikely we'd need to carpent any classes */ assertEquals(0, l1.size) - val curruptSchema = serSchema.curruptName (listOf (classTestName ("A"))) + val curruptSchema = serSchema.curruptName(listOf(classTestName("A"))) val l2 = curruptSchema.carpenterSchema() assertEquals(1, l2.size) val aSchema = l2.carpenterSchemas.find { it.name == curruptName(classTestName("A")) } - assertNotEquals (null, aSchema) + assertNotEquals(null, aSchema) assertEquals(curruptName(classTestName("A")), aSchema!!.name) assertEquals(1, aSchema.interfaces.size) @@ -115,7 +115,7 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() { it's extremely unlikely we'd need to carpent any classes */ assertEquals(0, l1.size) - val curruptSchema = serSchema.curruptName (listOf (classTestName("A"))) + val curruptSchema = serSchema.curruptName(listOf(classTestName("A"))) val aName = curruptName(classTestName("A")) val l2 = curruptSchema.carpenterSchema() @@ -143,13 +143,13 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() { @Test fun multipleInterfaces() { - val testI = 20 + val testI = 20 val testII = 40 class A(override val i: Int, override val ii: Int) : I, II - val a = A(testI, testII) - val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(a)) + val a = A(testI, testII) + val obj = DeserializationInput(factory).deserializeAndReturnEnvelope(serialise(a)) assert(obj.first is A) @@ -166,8 +166,8 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() { /* pretend we don't know the class we've been sent, i.e. it's unknown to the class loader, and thus needs some carpentry */ - val curruptSchema = serSchema.curruptName (listOf (classTestName ("A"))) - val l2 = curruptSchema.carpenterSchema() + val curruptSchema = serSchema.curruptName(listOf(classTestName("A"))) + val l2 = curruptSchema.carpenterSchema() val aName = curruptName(classTestName("A")) assertEquals(1, l2.size) @@ -178,31 +178,31 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() { assertEquals(aName, aSchema!!.name) assertEquals(2, aSchema.interfaces.size) - assert (net.corda.carpenter.I::class.java in aSchema.interfaces) - assert (net.corda.carpenter.II::class.java in aSchema.interfaces) + assert(net.corda.carpenter.I::class.java in aSchema.interfaces) + assert(net.corda.carpenter.II::class.java in aSchema.interfaces) val aBuilder = ClassCarpenter().build(aSchema) val objA = aBuilder.constructors[0].newInstance(testI, testII) - val i = objA as I + val i = objA as I val ii = objA as II assertEquals(aBuilder.getMethod("getI").invoke(objA), testI) assertEquals(aBuilder.getMethod("getIi").invoke(objA), testII) - assertEquals(a.i, i.i) + assertEquals(a.i, i.i) assertEquals(a.ii, ii.ii) } @Test fun nestedInterfaces() { - val testI = 20 - val testIII = 60 + val testI = 20 + val testIII = 60 - class A(override val i: Int, override val iii : Int) : III + class A(override val i: Int, override val iii: Int) : III - val a = A(testI, testIII) - val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(a)) + val a = A(testI, testIII) + val obj = DeserializationInput(factory).deserializeAndReturnEnvelope(serialise(a)) assert(obj.first is A) @@ -216,7 +216,7 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() { it's extremely unlikely we'd need to carpent any classes */ assertEquals(0, l1.size) - val curruptSchema = serSchema.curruptName (listOf (classTestName ("A"))) + val curruptSchema = serSchema.curruptName(listOf(classTestName("A"))) val l2 = curruptSchema.carpenterSchema() val aName = curruptName(classTestName("A")) @@ -228,30 +228,30 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() { assertEquals(aName, aSchema!!.name) assertEquals(2, aSchema.interfaces.size) - assert (net.corda.carpenter.I::class.java in aSchema.interfaces) - assert (net.corda.carpenter.III::class.java in aSchema.interfaces) + assert(net.corda.carpenter.I::class.java in aSchema.interfaces) + assert(net.corda.carpenter.III::class.java in aSchema.interfaces) val aBuilder = ClassCarpenter().build(aSchema) val objA = aBuilder.constructors[0].newInstance(testI, testIII) - val i = objA as I + val i = objA as I val iii = objA as III assertEquals(aBuilder.getMethod("getI").invoke(objA), testI) assertEquals(aBuilder.getMethod("getIii").invoke(objA), testIII) - assertEquals(a.i, i.i) - assertEquals(a.i, iii.i) + assertEquals(a.i, i.i) + assertEquals(a.i, iii.i) assertEquals(a.iii, iii.iii) } @Test fun memberInterface() { - val testI = 25 - val testIIII = 50 + val testI = 25 + val testIIII = 50 class A(override val i: Int) : I - class B(override val i : I, override val iiii : Int) : IIII + class B(override val i: I, override val iiii: Int) : IIII val a = A(testI) val b = B(a, testIIII) @@ -270,20 +270,20 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() { */ assertEquals(4, serSchema.types.size) - val curruptSchema = serSchema.curruptName (listOf (classTestName ("A"), classTestName ("B"))) - val cSchema = curruptSchema.carpenterSchema() - val aName = curruptName(classTestName("A")) - val bName = curruptName(classTestName("B")) + val curruptSchema = serSchema.curruptName(listOf(classTestName("A"), classTestName("B"))) + val cSchema = curruptSchema.carpenterSchema() + val aName = curruptName(classTestName("A")) + val bName = curruptName(classTestName("B")) assertEquals(2, cSchema.size) val aCarpenterSchema = cSchema.carpenterSchemas.find { it.name == aName } val bCarpenterSchema = cSchema.carpenterSchemas.find { it.name == bName } - assertNotEquals (null, aCarpenterSchema) - assertNotEquals (null, bCarpenterSchema) + assertNotEquals(null, aCarpenterSchema) + assertNotEquals(null, bCarpenterSchema) - val cc = ClassCarpenter() + val cc = ClassCarpenter() val cc2 = ClassCarpenter() val bBuilder = cc.build(bCarpenterSchema!!) @@ -307,10 +307,11 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() { to have a concrete class loaded without having access to all of it's elements */ @Test(expected = UncarpentableException::class) fun memberInterface2() { - val testI = 25 - val testIIII = 50 + val testI = 25 + val testIIII = 50 + class A(override val i: Int) : I - class B(override val i : I, override val iiii : Int) : IIII + class B(override val i: I, override val iiii: Int) : IIII val a = A(testI) val b = B(a, testIIII) @@ -331,13 +332,13 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() { assertEquals(4, serSchema.types.size) /* ignore the return as we expect this to throw */ - serSchema.curruptName (listOf ( + serSchema.curruptName(listOf( classTestName("A"), "${this.javaClass.`package`.name}.I")).carpenterSchema() } @Test fun interfaceAndImplementation() { - val testI = 25 + val testI = 25 class A(override val i: Int) : I @@ -356,38 +357,38 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() { */ assertEquals(2, serSchema.types.size) - val amqpSchema = serSchema.curruptName (listOf (classTestName("A"), "${this.javaClass.`package`.name}.I")) + val amqpSchema = serSchema.curruptName(listOf(classTestName("A"), "${this.javaClass.`package`.name}.I")) - val aName = curruptName (classTestName("A")) - val iName = curruptName ("${this.javaClass.`package`.name}.I") + val aName = curruptName(classTestName("A")) + val iName = curruptName("${this.javaClass.`package`.name}.I") val carpenterSchema = amqpSchema.carpenterSchema() /* whilst there are two unknown classes within the envelope A depends on I so we can't construct a schema for A until we have for I */ - assertEquals (1, carpenterSchema.size) - assertNotEquals (null, carpenterSchema.carpenterSchemas.find { it.name == iName }) + assertEquals(1, carpenterSchema.size) + assertNotEquals(null, carpenterSchema.carpenterSchemas.find { it.name == iName }) /* since we can't build A it should list I as a dependency*/ - assert (aName in carpenterSchema.dependencies) - assertEquals (1, carpenterSchema.dependencies[aName]!!.second.size) - assertEquals (iName, carpenterSchema.dependencies[aName]!!.second[0]) + assert(aName in carpenterSchema.dependencies) + assertEquals(1, carpenterSchema.dependencies[aName]!!.second.size) + assertEquals(iName, carpenterSchema.dependencies[aName]!!.second[0]) /* and conversly I should have A listed as a dependent */ assert(iName in carpenterSchema.dependsOn) assertEquals(1, carpenterSchema.dependsOn[iName]!!.size) assertEquals(aName, carpenterSchema.dependsOn[iName]!![0]) - val mc = MetaCarpenter (carpenterSchema) + val mc = MetaCarpenter(carpenterSchema) mc.build() - assertEquals (0, mc.schemas.carpenterSchemas.size) - assertEquals (0, mc.schemas.dependencies.size) - assertEquals (0, mc.schemas.dependsOn.size) - assertEquals (2, mc.objects.size) - assert (aName in mc.objects) - assert (iName in mc.objects) + assertEquals(0, mc.schemas.carpenterSchemas.size) + assertEquals(0, mc.schemas.dependencies.size) + assertEquals(0, mc.schemas.dependsOn.size) + assertEquals(2, mc.objects.size) + assert(aName in mc.objects) + assert(iName in mc.objects) mc.objects[aName]!!.constructors[0].newInstance(testI) } @@ -408,51 +409,51 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() { "${this.javaClass.`package`.name}.I", "${this.javaClass.`package`.name}.II")) - val aName = curruptName (classTestName("A")) - val iName = curruptName ("${this.javaClass.`package`.name}.I") - val iiName = curruptName ("${this.javaClass.`package`.name}.II") + val aName = curruptName(classTestName("A")) + val iName = curruptName("${this.javaClass.`package`.name}.I") + val iiName = curruptName("${this.javaClass.`package`.name}.II") val carpenterSchema = amqpSchema.carpenterSchema() /* there is nothing preventing us from carpenting up the two interfaces so our initial list should contain both interface with A being dependent on both and each having A as a dependent */ - assertEquals (2, carpenterSchema.carpenterSchemas.size) - assertNotNull (carpenterSchema.carpenterSchemas.find { it.name == iName }) - assertNotNull (carpenterSchema.carpenterSchemas.find { it.name == iiName }) - assertNull (carpenterSchema.carpenterSchemas.find { it.name == aName }) + assertEquals(2, carpenterSchema.carpenterSchemas.size) + assertNotNull(carpenterSchema.carpenterSchemas.find { it.name == iName }) + assertNotNull(carpenterSchema.carpenterSchemas.find { it.name == iiName }) + assertNull(carpenterSchema.carpenterSchemas.find { it.name == aName }) - assert (iName in carpenterSchema.dependsOn) - assertEquals (1, carpenterSchema.dependsOn[iName]?.size) - assertNotNull (carpenterSchema.dependsOn[iName]?.find ( { it == aName })) + assert(iName in carpenterSchema.dependsOn) + assertEquals(1, carpenterSchema.dependsOn[iName]?.size) + assertNotNull(carpenterSchema.dependsOn[iName]?.find({ it == aName })) - assert (iiName in carpenterSchema.dependsOn) - assertEquals (1, carpenterSchema.dependsOn[iiName]?.size) - assertNotNull (carpenterSchema.dependsOn[iiName]?.find { it == aName }) + assert(iiName in carpenterSchema.dependsOn) + assertEquals(1, carpenterSchema.dependsOn[iiName]?.size) + assertNotNull(carpenterSchema.dependsOn[iiName]?.find { it == aName }) - assert (aName in carpenterSchema.dependencies) - assertEquals (2, carpenterSchema.dependencies[aName]!!.second.size) - assertNotNull (carpenterSchema.dependencies[aName]!!.second.find { it == iName }) - assertNotNull (carpenterSchema.dependencies[aName]!!.second.find { it == iiName }) + assert(aName in carpenterSchema.dependencies) + assertEquals(2, carpenterSchema.dependencies[aName]!!.second.size) + assertNotNull(carpenterSchema.dependencies[aName]!!.second.find { it == iName }) + assertNotNull(carpenterSchema.dependencies[aName]!!.second.find { it == iiName }) - val mc = MetaCarpenter (carpenterSchema) + val mc = MetaCarpenter(carpenterSchema) mc.build() - assertEquals (0, mc.schemas.carpenterSchemas.size) - assertEquals (0, mc.schemas.dependencies.size) - assertEquals (0, mc.schemas.dependsOn.size) - assertEquals (3, mc.objects.size) - assert (aName in mc.objects) - assert (iName in mc.objects) - assert (iiName in mc.objects) + assertEquals(0, mc.schemas.carpenterSchemas.size) + assertEquals(0, mc.schemas.dependencies.size) + assertEquals(0, mc.schemas.dependsOn.size) + assertEquals(3, mc.objects.size) + assert(aName in mc.objects) + assert(iName in mc.objects) + assert(iiName in mc.objects) } @Test fun nestedInterfacesAndImplementation() { - val testI = 7 + val testI = 7 val testIII = 11 - class A(override val i: Int, override val iii : Int) : III + class A(override val i: Int, override val iii: Int) : III val a = A(testI, testIII) @@ -463,51 +464,51 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() { "${this.javaClass.`package`.name}.I", "${this.javaClass.`package`.name}.III")) - val aName = curruptName (classTestName("A")) - val iName = curruptName ("${this.javaClass.`package`.name}.I") - val iiiName = curruptName ("${this.javaClass.`package`.name}.III") + val aName = curruptName(classTestName("A")) + val iName = curruptName("${this.javaClass.`package`.name}.I") + val iiiName = curruptName("${this.javaClass.`package`.name}.III") val carpenterSchema = amqpSchema.carpenterSchema() /* Since A depends on III and III extends I we will have to construct them * in that reverse order (I -> III -> A) */ - assertEquals (1, carpenterSchema.carpenterSchemas.size) - assertNotNull (carpenterSchema.carpenterSchemas.find { it.name == iName }) - assertNull (carpenterSchema.carpenterSchemas.find { it.name == iiiName }) - assertNull (carpenterSchema.carpenterSchemas.find { it.name == aName }) + assertEquals(1, carpenterSchema.carpenterSchemas.size) + assertNotNull(carpenterSchema.carpenterSchemas.find { it.name == iName }) + assertNull(carpenterSchema.carpenterSchemas.find { it.name == iiiName }) + assertNull(carpenterSchema.carpenterSchemas.find { it.name == aName }) /* I has III as a direct dependent and A as an indirect one */ - assert (iName in carpenterSchema.dependsOn) - assertEquals (2, carpenterSchema.dependsOn[iName]?.size) - assertNotNull (carpenterSchema.dependsOn[iName]?.find ( { it == iiiName })) - assertNotNull (carpenterSchema.dependsOn[iName]?.find ( { it == aName })) + assert(iName in carpenterSchema.dependsOn) + assertEquals(2, carpenterSchema.dependsOn[iName]?.size) + assertNotNull(carpenterSchema.dependsOn[iName]?.find({ it == iiiName })) + assertNotNull(carpenterSchema.dependsOn[iName]?.find({ it == aName })) /* III has A as a dependent */ - assert (iiiName in carpenterSchema.dependsOn) - assertEquals (1, carpenterSchema.dependsOn[iiiName]?.size) - assertNotNull (carpenterSchema.dependsOn[iiiName]?.find { it == aName }) + assert(iiiName in carpenterSchema.dependsOn) + assertEquals(1, carpenterSchema.dependsOn[iiiName]?.size) + assertNotNull(carpenterSchema.dependsOn[iiiName]?.find { it == aName }) /* converly III depends on I */ - assert (iiiName in carpenterSchema.dependencies) - assertEquals (1, carpenterSchema.dependencies[iiiName]!!.second.size) - assertNotNull (carpenterSchema.dependencies[iiiName]!!.second.find { it == iName }) + assert(iiiName in carpenterSchema.dependencies) + assertEquals(1, carpenterSchema.dependencies[iiiName]!!.second.size) + assertNotNull(carpenterSchema.dependencies[iiiName]!!.second.find { it == iName }) /* and A depends on III and I*/ - assert (aName in carpenterSchema.dependencies) - assertEquals (2, carpenterSchema.dependencies[aName]!!.second.size) - assertNotNull (carpenterSchema.dependencies[aName]!!.second.find { it == iiiName }) - assertNotNull (carpenterSchema.dependencies[aName]!!.second.find { it == iName }) + assert(aName in carpenterSchema.dependencies) + assertEquals(2, carpenterSchema.dependencies[aName]!!.second.size) + assertNotNull(carpenterSchema.dependencies[aName]!!.second.find { it == iiiName }) + assertNotNull(carpenterSchema.dependencies[aName]!!.second.find { it == iName }) - val mc = MetaCarpenter (carpenterSchema) + val mc = MetaCarpenter(carpenterSchema) mc.build() - assertEquals (0, mc.schemas.carpenterSchemas.size) - assertEquals (0, mc.schemas.dependencies.size) - assertEquals (0, mc.schemas.dependsOn.size) - assertEquals (3, mc.objects.size) - assert (aName in mc.objects) - assert (iName in mc.objects) - assert (iiiName in mc.objects) + assertEquals(0, mc.schemas.carpenterSchemas.size) + assertEquals(0, mc.schemas.dependencies.size) + assertEquals(0, mc.schemas.dependsOn.size) + assertEquals(3, mc.objects.size) + assert(aName in mc.objects) + assert(iName in mc.objects) + assert(iiiName in mc.objects) } } diff --git a/experimental/src/test/kotlin/net/corda/carpenter/MultiMemberCompositeSchemaToClassCarpenterTests.kt b/experimental/src/test/kotlin/net/corda/carpenter/MultiMemberCompositeSchemaToClassCarpenterTests.kt index 0a22d5b132..0e53d438f9 100644 --- a/experimental/src/test/kotlin/net/corda/carpenter/MultiMemberCompositeSchemaToClassCarpenterTests.kt +++ b/experimental/src/test/kotlin/net/corda/carpenter/MultiMemberCompositeSchemaToClassCarpenterTests.kt @@ -32,19 +32,19 @@ class MultiMemberCompositeSchemaToClassCarpenterTests : AmqpCarpenterBase() { var amqpSchema = obj.second.schema.types[0] as CompositeType - assertEquals(2, amqpSchema.fields.size) - assertEquals("a", amqpSchema.fields[0].name) + assertEquals(2, amqpSchema.fields.size) + assertEquals("a", amqpSchema.fields[0].name) assertEquals("int", amqpSchema.fields[0].type) - assertEquals("b", amqpSchema.fields[1].name) + assertEquals("b", amqpSchema.fields[1].name) assertEquals("int", amqpSchema.fields[1].type) val carpenterSchema = CarpenterSchemas.newInstance() amqpSchema.carpenterSchema(carpenterSchemas = carpenterSchema, force = true) - assertEquals (1, carpenterSchema.size) - val aSchema = carpenterSchema.carpenterSchemas.find { it.name == classTestName ("A") } + assertEquals(1, carpenterSchema.size) + val aSchema = carpenterSchema.carpenterSchemas.find { it.name == classTestName("A") } - assertNotEquals (null, aSchema) + assertNotEquals(null, aSchema) val pinochio = ClassCarpenter().build(aSchema!!) @@ -76,16 +76,16 @@ class MultiMemberCompositeSchemaToClassCarpenterTests : AmqpCarpenterBase() { val amqpSchema = obj.second.schema.types[0] as CompositeType - assertEquals(2, amqpSchema.fields.size) - assertEquals("a", amqpSchema.fields[0].name) - assertEquals("int", amqpSchema.fields[0].type) - assertEquals("b", amqpSchema.fields[1].name) + assertEquals(2, amqpSchema.fields.size) + assertEquals("a", amqpSchema.fields[0].name) + assertEquals("int", amqpSchema.fields[0].type) + assertEquals("b", amqpSchema.fields[1].name) assertEquals("string", amqpSchema.fields[1].type) val carpenterSchema = CarpenterSchemas.newInstance() amqpSchema.carpenterSchema(carpenterSchemas = carpenterSchema, force = true) - assertEquals (1, carpenterSchema.size) + assertEquals(1, carpenterSchema.size) val aSchema = carpenterSchema.carpenterSchemas.find { it.name == classTestName("A") } assertNotEquals(null, aSchema) diff --git a/experimental/src/test/kotlin/net/corda/carpenter/SingleMemberCompositeSchemaToClassCarpenterTests.kt b/experimental/src/test/kotlin/net/corda/carpenter/SingleMemberCompositeSchemaToClassCarpenterTests.kt index 21dbd972f2..0150e34a76 100644 --- a/experimental/src/test/kotlin/net/corda/carpenter/SingleMemberCompositeSchemaToClassCarpenterTests.kt +++ b/experimental/src/test/kotlin/net/corda/carpenter/SingleMemberCompositeSchemaToClassCarpenterTests.kt @@ -1,44 +1,47 @@ package net.corda.carpenter +import net.corda.carpenter.test.AmqpCarpenterBase import net.corda.core.serialization.CordaSerializable import net.corda.core.serialization.amqp.* +import net.corda.core.serialization.carpenter.CarpenterSchemas import org.junit.Test import kotlin.test.assertEquals -class SingleMemberCompositeSchemaToClassCarpenterTests { - private var factory = SerializerFactory() - - fun serialise (clazz : Any) = SerializationOutput(factory).serialize(clazz) +class SingleMemberCompositeSchemaToClassCarpenterTests : AmqpCarpenterBase() { @Test fun singleInteger() { val test = 10 @CordaSerializable - data class A(val a : Int) + data class A(val a: Int) - val a = A (test) - val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise (a)) + val a = A(test) + val obj = DeserializationInput(factory).deserializeAndReturnEnvelope(serialise(a)) - assert (obj.first is A) - val amqpObj = obj.first as A + assert(obj.obj is A) + val amqpObj = obj.obj as A - assertEquals (test, amqpObj.a) - assertEquals (1, obj.second.schema.types.size) - assert (obj.second.schema.types[0] is CompositeType) + assertEquals(test, amqpObj.a) + assertEquals(1, obj.envelope.schema.types.size) + assert(obj.envelope.schema.types[0] is CompositeType) - val amqpSchema = obj.second.schema.types[0] as CompositeType + val amqpSchema = obj.envelope.schema.types[0] as CompositeType - assertEquals (1, amqpSchema.fields.size) - assertEquals ("a", amqpSchema.fields[0].name) - assertEquals ("int", amqpSchema.fields[0].type) + assertEquals(1, amqpSchema.fields.size) + assertEquals("a", amqpSchema.fields[0].name) + assertEquals("int", amqpSchema.fields[0].type) - val pinochio = ClassCarpenter().build(amqpSchema.carpenterSchema()) + val carpenterSchema = CarpenterSchemas.newInstance() + amqpSchema.carpenterSchema(carpenterSchemas = carpenterSchema, force = true) - val p = pinochio.constructors[0].newInstance (test) + val aSchema = carpenterSchema.carpenterSchemas.find { it.name == classTestName("A") }!! + val pinochio = ClassCarpenter().build(aSchema) - assertEquals (pinochio.getMethod("getA").invoke (p), amqpObj.a) + val p = pinochio.constructors[0].newInstance(test) + + assertEquals(pinochio.getMethod("getA").invoke(p), amqpObj.a) } @Test @@ -46,29 +49,30 @@ class SingleMemberCompositeSchemaToClassCarpenterTests { val test = "ten" @CordaSerializable - data class A(val a : String) - var a = A (test) + data class A(val a: String) - val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise (a)) + val a = A(test) - assert (obj.first is A) - val amqpObj = obj.first as A + val obj = DeserializationInput(factory).deserializeAndReturnEnvelope(serialise(a)) - assertEquals (test, amqpObj.a) - assertEquals (1, obj.second.schema.types.size) - assert (obj.second.schema.types[0] is CompositeType) + assert(obj.obj is A) + val amqpObj = obj.obj as A - var amqpSchema = obj.second.schema.types[0] as CompositeType + assertEquals(test, amqpObj.a) + assertEquals(1, obj.envelope.schema.types.size) + assert(obj.envelope.schema.types[0] is CompositeType) - assertEquals (1, amqpSchema.fields.size) - assertEquals ("a", amqpSchema.fields[0].name) - assertEquals ("string", amqpSchema.fields[0].type) + val amqpSchema = obj.envelope.schema.types[0] as CompositeType - var pinochio = ClassCarpenter().build(amqpSchema.carpenterSchema()) + val carpenterSchema = CarpenterSchemas.newInstance() + amqpSchema.carpenterSchema(carpenterSchemas = carpenterSchema, force = true) - val p = pinochio.constructors[0].newInstance (test) + val aSchema = carpenterSchema.carpenterSchemas.find { it.name == classTestName("A") }!! + val pinochio = ClassCarpenter().build(aSchema) - assertEquals (pinochio.getMethod("getA").invoke (p), amqpObj.a) + val p = pinochio.constructors[0].newInstance(test) + + assertEquals(pinochio.getMethod("getA").invoke(p), amqpObj.a) } /* @@ -78,25 +82,31 @@ class SingleMemberCompositeSchemaToClassCarpenterTests { @CordaSerializable data class A(val a : Char) - var a = A (test) + val a = A(test) - val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise (a)) + val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(a)) - assert (obj.first is A) - val amqpObj = obj.first as A + assert (obj.obj is A) + val amqpObj = obj.obj as A assertEquals (test, amqpObj.a) - assertEquals (1, obj.second.schema.types.size) - assertEquals (1, obj.second.schema.types.size) - assert (obj.second.schema.types[0] is CompositeType) + assertEquals (1, obj.envelope.schema.types.size) + assertEquals (1, obj.envelope.schema.types.size) + assert (obj.envelope.schema.types[0] is CompositeType) - var amqpSchema = obj.second.schema.types[0] as CompositeType + val amqpSchema = obj.envelope.schema.types[0] as CompositeType assertEquals (1, amqpSchema.fields.size) assertEquals ("a", amqpSchema.fields[0].name) assertEquals ("char", amqpSchema.fields[0].type) - var pinochio = ClassCarpenter().build(ClassCarpenter.Schema(amqpSchema.name, amqpSchema.carpenterSchema())) + val carpenterSchema = CarpenterSchema.newInstance() + amqpSchema.carpenterSchema(carpenterSchema = carpenterSchema, force = true) + + assert (classTestName ("A") in carpenterSchema.carpenterSchemas) + + val aSchema = carpenterSchema.carpenterSchemas[classTestName ("A")]!! + val pinochio = ClassCarpenter().build(aSchema) val p = pinochio.constructors[0].newInstance (test) @@ -109,30 +119,33 @@ class SingleMemberCompositeSchemaToClassCarpenterTests { val test = 10L @CordaSerializable - data class A(val a : Long) + data class A(val a: Long) - var a = A (test) + var a = A(test) - val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise (a)) + val obj = DeserializationInput(factory).deserializeAndReturnEnvelope(serialise(a)) - assert (obj.first is A) - val amqpObj = obj.first as A + assert(obj.obj is A) + val amqpObj = obj.obj as A - assertEquals (test, amqpObj.a) - assertEquals (1, obj.second.schema.types.size) - assert (obj.second.schema.types[0] is CompositeType) + assertEquals(test, amqpObj.a) + assertEquals(1, obj.envelope.schema.types.size) + assert(obj.envelope.schema.types[0] is CompositeType) - var amqpSchema = obj.second.schema.types[0] as CompositeType + var amqpSchema = obj.envelope.schema.types[0] as CompositeType - assertEquals (1, amqpSchema.fields.size) - assertEquals ("a", amqpSchema.fields[0].name) - assertEquals ("long", amqpSchema.fields[0].type) + assertEquals(1, amqpSchema.fields.size) + assertEquals("a", amqpSchema.fields[0].name) + assertEquals("long", amqpSchema.fields[0].type) - var pinochio = ClassCarpenter().build(amqpSchema.carpenterSchema()) + val carpenterSchema = CarpenterSchemas.newInstance() + amqpSchema.carpenterSchema(carpenterSchemas = carpenterSchema, force = true) - val p = pinochio.constructors[0].newInstance (test) + val aSchema = carpenterSchema.carpenterSchemas.find { it.name == classTestName("A") }!! + val pinochio = ClassCarpenter().build(aSchema) + val p = pinochio.constructors[0].newInstance(test) - assertEquals (pinochio.getMethod("getA").invoke (p), amqpObj.a) + assertEquals(pinochio.getMethod("getA").invoke(p), amqpObj.a) } @Test @@ -140,30 +153,33 @@ class SingleMemberCompositeSchemaToClassCarpenterTests { val test = 10.toShort() @CordaSerializable - data class A(val a : Short) + data class A(val a: Short) - var a = A (test) + var a = A(test) - val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise (a)) + val obj = DeserializationInput(factory).deserializeAndReturnEnvelope(serialise(a)) - assert (obj.first is A) - val amqpObj = obj.first as A + assert(obj.obj is A) + val amqpObj = obj.obj as A - assertEquals (test, amqpObj.a) - assertEquals (1, obj.second.schema.types.size) - assert (obj.second.schema.types[0] is CompositeType) + assertEquals(test, amqpObj.a) + assertEquals(1, obj.envelope.schema.types.size) + assert(obj.envelope.schema.types[0] is CompositeType) - var amqpSchema = obj.second.schema.types[0] as CompositeType + var amqpSchema = obj.envelope.schema.types[0] as CompositeType - assertEquals (1, amqpSchema.fields.size) - assertEquals ("a", amqpSchema.fields[0].name) - assertEquals ("short", amqpSchema.fields[0].type) + assertEquals(1, amqpSchema.fields.size) + assertEquals("a", amqpSchema.fields[0].name) + assertEquals("short", amqpSchema.fields[0].type) - var pinochio = ClassCarpenter().build(amqpSchema.carpenterSchema()) + val carpenterSchema = CarpenterSchemas.newInstance() + amqpSchema.carpenterSchema(carpenterSchemas = carpenterSchema, force = true) - val p = pinochio.constructors[0].newInstance (test) + val aSchema = carpenterSchema.carpenterSchemas.find { it.name == classTestName("A") }!! + val pinochio = ClassCarpenter().build(aSchema) + val p = pinochio.constructors[0].newInstance(test) - assertEquals (pinochio.getMethod("getA").invoke (p), amqpObj.a) + assertEquals(pinochio.getMethod("getA").invoke(p), amqpObj.a) } /* @@ -178,14 +194,14 @@ class SingleMemberCompositeSchemaToClassCarpenterTests { val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise (a)) - assert (obj.first is A) - val amqpObj = obj.first as A + assert (obj.obj is A) + val amqpObj = obj.obj as A assertEquals (test, amqpObj.a) - assertEquals (1, obj.second.schema.types.size) - assert (obj.second.schema.types[0] is CompositeType) + assertEquals (1, obj.envelope.schema.types.size) + assert (obj.envelope.schema.types[0] is CompositeType) - var amqpSchema = obj.second.schema.types[0] as CompositeType + var amqpSchema = obj.envelope.schema.types[0] as CompositeType assertEquals (1, amqpSchema.fields.size) assertEquals ("a", amqpSchema.fields[0].name) @@ -204,60 +220,66 @@ class SingleMemberCompositeSchemaToClassCarpenterTests { val test = 10.0 @CordaSerializable - data class A(val a : Double) + data class A(val a: Double) - var a = A (test) + val a = A(test) - val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise (a)) + val obj = DeserializationInput(factory).deserializeAndReturnEnvelope(serialise(a)) - assert (obj.first is A) - val amqpObj = obj.first as A + assert(obj.obj is A) + val amqpObj = obj.obj as A - assertEquals (test, amqpObj.a) - assertEquals (1, obj.second.schema.types.size) - assert (obj.second.schema.types[0] is CompositeType) + assertEquals(test, amqpObj.a) + assertEquals(1, obj.envelope.schema.types.size) + assert(obj.envelope.schema.types[0] is CompositeType) - var amqpSchema = obj.second.schema.types[0] as CompositeType + val amqpSchema = obj.envelope.schema.types[0] as CompositeType - assertEquals (1, amqpSchema.fields.size) - assertEquals ("a", amqpSchema.fields[0].name) - assertEquals ("double", amqpSchema.fields[0].type) + assertEquals(1, amqpSchema.fields.size) + assertEquals("a", amqpSchema.fields[0].name) + assertEquals("double", amqpSchema.fields[0].type) - var pinochio = ClassCarpenter().build(amqpSchema.carpenterSchema()) + val carpenterSchema = CarpenterSchemas.newInstance() + amqpSchema.carpenterSchema(carpenterSchemas = carpenterSchema, force = true) - val p = pinochio.constructors[0].newInstance (test) + val aSchema = carpenterSchema.carpenterSchemas.find { it.name == classTestName("A") }!! + val pinochio = ClassCarpenter().build(aSchema) + val p = pinochio.constructors[0].newInstance(test) - assertEquals (pinochio.getMethod("getA").invoke (p), amqpObj.a) + assertEquals(pinochio.getMethod("getA").invoke(p), amqpObj.a) } @Test fun singleFloat() { - val test = 10.0F + val test: Float = 10.0F @CordaSerializable - data class A(val a : Float) + data class A(val a: Float) - var a = A (test) + val a = A(test) - val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise (a)) + val obj = DeserializationInput(factory).deserializeAndReturnEnvelope(serialise(a)) - assert (obj.first is A) - val amqpObj = obj.first as A + assert(obj.obj is A) + val amqpObj = obj.obj as A - assertEquals (test, amqpObj.a) - assertEquals (1, obj.second.schema.types.size) - assert (obj.second.schema.types[0] is CompositeType) + assertEquals(test, amqpObj.a) + assertEquals(1, obj.envelope.schema.types.size) + assert(obj.envelope.schema.types[0] is CompositeType) - var amqpSchema = obj.second.schema.types[0] as CompositeType + val amqpSchema = obj.envelope.schema.types[0] as CompositeType - assertEquals (1, amqpSchema.fields.size) - assertEquals ("a", amqpSchema.fields[0].name) - assertEquals ("float", amqpSchema.fields[0].type) + assertEquals(1, amqpSchema.fields.size) + assertEquals("a", amqpSchema.fields[0].name) + assertEquals("float", amqpSchema.fields[0].type) - var pinochio = ClassCarpenter().build(amqpSchema.carpenterSchema()) + val carpenterSchema = CarpenterSchemas.newInstance() + amqpSchema.carpenterSchema(carpenterSchemas = carpenterSchema, force = true) - val p = pinochio.constructors[0].newInstance (test) + val aSchema = carpenterSchema.carpenterSchemas.find { it.name == classTestName("A") }!! + val pinochio = ClassCarpenter().build(aSchema) + val p = pinochio.constructors[0].newInstance(test) -// assertEquals (pinochio.getMethod("getA").invoke (p), amqpObj.a) + assertEquals(pinochio.getMethod("getA").invoke(p), amqpObj.a) } } \ No newline at end of file