ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-06-05 00:50:52 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Carpenter bug fixes

Browse Source 
Squashed commit messages:
	* Nested schema creation now works with dependencies recursvly created in
	  the carpenter

	* Remove spurious prints from tests

	* Remove warnings

	* Don't add cladd member dep by name

	  Since that's the name of the field, not the type we depend on. If we do
	  we'll never actually be able to craft the type as the dependency chain
	  will be horribly broken

	  Various bug fixes

	* Fix merge issue where types weren't being seen as Prims

	* IntelliJ auto code cleanup / reformat

	* Whitespace changes

	* Add comment blocking as I like seeing it in files
This commit is contained in:
Katelyn Baker 2017-06-28 16:55:42 +01:00
parent d76c1e75a4
commit 9ab6a72ea8
8 changed files with 395 additions and 308 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
core/src/main/kotlin/net/corda/core/serialization/amqp/SerializerFactory.kt
View File

@ -12,12 +12,6 @@ import java.lang.reflect.GenericArrayType
import java.lang.reflect.ParameterizedType import java.lang.reflect.ParameterizedType
import java.lang.reflect.Type import java.lang.reflect.Type
import java.lang.reflect.WildcardType 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.*
import java.util.concurrent.ConcurrentHashMap import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.CopyOnWriteArrayList import java.util.concurrent.CopyOnWriteArrayList

63
core/src/test/kotlin/net/corda/core/serialization/amqp/SerializationOutputTests.kt
View File

@ -7,10 +7,12 @@ import net.corda.core.identity.AbstractParty
import net.corda.core.serialization.CordaSerializable import net.corda.core.serialization.CordaSerializable
import net.corda.core.serialization.EmptyWhitelist import net.corda.core.serialization.EmptyWhitelist
import net.corda.core.serialization.KryoAMQPSerializer 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.nodeapi.RPCException
import net.corda.testing.MEGA_CORP import net.corda.testing.MEGA_CORP
import net.corda.testing.MEGA_CORP_PUBKEY 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.DecoderImpl
import org.apache.qpid.proton.codec.EncoderImpl import org.apache.qpid.proton.codec.EncoderImpl
import org.junit.Test import org.junit.Test
@ -27,6 +29,14 @@ import kotlin.test.assertTrue
class SerializationOutputTests { class SerializationOutputTests {
data class Foo(val bar: String, val pub: Int) 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 { interface FooInterface {
val pub: Int val pub: Int
} }
@ -159,12 +169,61 @@ class SerializationOutputTests {
return desObj2 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 @Test
fun `test foo`() { fun `test foo`() {
val obj = Foo("Hello World!", 123) val obj = Foo("Hello World!", 123)
serdes(obj) 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 @Test
fun `test foo implements`() { fun `test foo implements`() {
val obj = FooImplements("Hello World!", 123) val obj = FooImplements("Hello World!", 123)
@ -524,4 +583,4 @@ class SerializationOutputTests {
val obj = StateRef(SecureHash.randomSHA256(), 0) val obj = StateRef(SecureHash.randomSHA256(), 0)
serdes(obj, factory, factory2) serdes(obj, factory, factory2)
} }
} }

8
experimental/src/main/kotlin/net/corda/carpenter/MetaCapenter.kt
View File

@ -5,6 +5,8 @@ import net.corda.core.serialization.carpenter.Schema
import net.corda.core.serialization.amqp.CompositeType import net.corda.core.serialization.amqp.CompositeType
/**********************************************************************************************************************/
abstract class MetaCarpenterBase (val schemas : CarpenterSchemas) { abstract class MetaCarpenterBase (val schemas : CarpenterSchemas) {
private val cc = ClassCarpenter() private val cc = ClassCarpenter()
@ -35,6 +37,8 @@ abstract class MetaCarpenterBase (val schemas : CarpenterSchemas) {
abstract fun build() abstract fun build()
} }
/**********************************************************************************************************************/
class MetaCarpenter (schemas : CarpenterSchemas) : MetaCarpenterBase (schemas) { class MetaCarpenter (schemas : CarpenterSchemas) : MetaCarpenterBase (schemas) {
override fun build() { override fun build() {
while (schemas.carpenterSchemas.isNotEmpty()) { while (schemas.carpenterSchemas.isNotEmpty()) {
@ -44,6 +48,8 @@ class MetaCarpenter (schemas : CarpenterSchemas) : MetaCarpenterBase (schemas) {
} }
} }
/**********************************************************************************************************************/
class TestMetaCarpenter (schemas : CarpenterSchemas) : MetaCarpenterBase (schemas) { class TestMetaCarpenter (schemas : CarpenterSchemas) : MetaCarpenterBase (schemas) {
override fun build() { override fun build() {
println ("TestMetaCarpenter::build") println ("TestMetaCarpenter::build")
@ -51,3 +57,5 @@ class TestMetaCarpenter (schemas : CarpenterSchemas) : MetaCarpenterBase (schema
step (schemas.carpenterSchemas.removeAt(0)) step (schemas.carpenterSchemas.removeAt(0))
} }
} }
/**********************************************************************************************************************/

21
experimental/src/test/kotlin/net/corda/carpenter/ClassCarpenterTestUtils.kt
View File

@ -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 /* given a list of class names work through the amqp envelope schema and alter any that
match in the fashion defined above */ match in the fashion defined above */
fun Schema.curruptName (names: List<String>) : Schema { fun Schema.curruptName(names: List<String>): Schema {
val newTypes : MutableList<TypeNotation> = mutableListOf() val newTypes: MutableList<TypeNotation> = mutableListOf()
for (type in types) { 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 { 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<Field>() val newFields = mutableListOf<Field>()
(type as CompositeType).fields.forEach { (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)) 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<String>) : Schema {
open class AmqpCarpenterBase { open class AmqpCarpenterBase {
var factory = SerializerFactory() 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 fun testName() = Thread.currentThread().stackTrace[2].methodName
inline fun classTestName(clazz: String) = "${this.javaClass.name}\$${testName()}\$$clazz" inline fun classTestName(clazz: String) = "${this.javaClass.name}\$${testName()}\$$clazz"
} }

112
experimental/src/test/kotlin/net/corda/carpenter/CompositeMemberCompositeSchemaToClassCarpenterTests.kt
View File

@ -20,7 +20,7 @@ interface I_ {
class CompositeMembers : AmqpCarpenterBase() { class CompositeMembers : AmqpCarpenterBase() {
@Test @Test
fun bothKnown () { fun bothKnown() {
val testA = 10 val testA = 10
val testB = 20 val testB = 20
@ -28,7 +28,7 @@ class CompositeMembers : AmqpCarpenterBase() {
data class A(val a: Int) data class A(val a: Int)
@CordaSerializable @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) 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[0] is CompositeType)
assert(obj.second.schema.types[1] is CompositeType) assert(obj.second.schema.types[1] is CompositeType)
println (obj.second.schema.types[0] as CompositeType) var amqpSchemaA: CompositeType? = null
println (obj.second.schema.types[1] as CompositeType) var amqpSchemaB: CompositeType? = null
var amqpSchemaA : CompositeType? = null
var amqpSchemaB : CompositeType? = null
for (type in obj.second.schema.types) { for (type in obj.second.schema.types) {
when (type.name.split ("$").last()) { when (type.name.split ("$").last()) {
@ -57,37 +54,36 @@ class CompositeMembers : AmqpCarpenterBase() {
} }
} }
assert (amqpSchemaA != null) assert(amqpSchemaA != null)
assert (amqpSchemaB != null) assert(amqpSchemaB != null)
/* /*
* Just ensure the amqp schema matches what we want before we go messing * Just ensure the amqp schema matches what we want before we go messing
* around with the internals * around with the internals
*/ */
assertEquals(1, amqpSchemaA?.fields?.size) assertEquals(1, amqpSchemaA?.fields?.size)
assertEquals("a", amqpSchemaA!!.fields[0].name) assertEquals("a", amqpSchemaA!!.fields[0].name)
assertEquals("int", amqpSchemaA.fields[0].type) assertEquals("int", amqpSchemaA.fields[0].type)
assertEquals(2, amqpSchemaB?.fields?.size)
assertEquals(2, amqpSchemaB?.fields?.size) assertEquals("a", amqpSchemaB!!.fields[0].name)
assertEquals("a", amqpSchemaB!!.fields[0].name)
assertEquals(classTestName("A"), amqpSchemaB.fields[0].type) 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) assertEquals("int", amqpSchemaB.fields[1].type)
val metaSchema = obj.second.schema.carpenterSchema() val metaSchema = obj.second.schema.carpenterSchema()
/* if we know all the classes there is nothing to really achieve here */ /* if we know all the classes there is nothing to really achieve here */
assert (metaSchema.carpenterSchemas.isEmpty()) assert(metaSchema.carpenterSchemas.isEmpty())
assert (metaSchema.dependsOn.isEmpty()) assert(metaSchema.dependsOn.isEmpty())
assert (metaSchema.dependencies.isEmpty()) assert(metaSchema.dependencies.isEmpty())
} }
/* you cannot have an element of a composite class we know about /* 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 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 */ class in the class path then we must have all of it's constituent elements */
@Test(expected = UncarpentableException::class) @Test(expected = UncarpentableException::class)
fun nestedIsUnknown () { fun nestedIsUnknown() {
val testA = 10 val testA = 10
val testB = 20 val testB = 20
@ -96,7 +92,8 @@ class CompositeMembers : AmqpCarpenterBase() {
@CordaSerializable @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)
val b = B(A(testA), testB)
val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b)) val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b))
val amqpSchema = obj.second.schema.curruptName(listOf (classTestName ("A"))) val amqpSchema = obj.second.schema.curruptName(listOf (classTestName ("A")))
@ -107,7 +104,7 @@ class CompositeMembers : AmqpCarpenterBase() {
} }
@Test @Test
fun ParentIsUnknown () { fun ParentIsUnknown() {
val testA = 10 val testA = 10
val testB = 20 val testB = 20
@ -116,27 +113,28 @@ class CompositeMembers : AmqpCarpenterBase() {
@CordaSerializable @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) val b = B(A(testA), testB)
val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b)) val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b))
assert(obj.first is 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() val carpenterSchema = amqpSchema.carpenterSchema()
assertEquals (1, carpenterSchema.size) assertEquals(1, carpenterSchema.size)
val metaCarpenter = MetaCarpenter (carpenterSchema) val metaCarpenter = MetaCarpenter(carpenterSchema)
metaCarpenter.build() metaCarpenter.build()
assert (curruptName(classTestName("B")) in metaCarpenter.objects) assert(curruptName(classTestName("B")) in metaCarpenter.objects)
} }
@Test @Test
fun BothUnkown () { fun BothUnkown() {
val testA = 10 val testA = 10
val testB = 20 val testB = 20
@ -145,54 +143,55 @@ class CompositeMembers : AmqpCarpenterBase() {
@CordaSerializable @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) val b = B(A(testA), testB)
val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b)) val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b))
assert(obj.first is 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() val carpenterSchema = amqpSchema.carpenterSchema()
/* just verify we're in the expected initial state, A is carpentable, B is not because /* 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 */ it depends on A and the dependency chains are in place */
assertEquals (1, carpenterSchema.size) assertEquals(1, carpenterSchema.size)
assertEquals (curruptName(classTestName("A")), carpenterSchema.carpenterSchemas.first().name) assertEquals(curruptName(classTestName("A")), carpenterSchema.carpenterSchemas.first().name)
assertEquals (1, carpenterSchema.dependencies.size) assertEquals(1, carpenterSchema.dependencies.size)
assert (curruptName(classTestName("B")) in carpenterSchema.dependencies) assert(curruptName(classTestName("B")) in carpenterSchema.dependencies)
assertEquals (1, carpenterSchema.dependsOn.size) assertEquals(1, carpenterSchema.dependsOn.size)
assert (curruptName(classTestName("A")) in carpenterSchema.dependsOn) assert(curruptName(classTestName("A")) in carpenterSchema.dependsOn)
/* test meta carpenter lets us single step over the creation */ /* 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 */ /* 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 */ /* first iteration, carpent A, resolve deps and mark B as carpentable */
metaCarpenter.build() metaCarpenter.build()
/* one build iteration should have carpetned up A and worked out that B is now buildable /* one build iteration should have carpetned up A and worked out that B is now buildable
given it's depedencies have been satisfied */ given it's depedencies have been satisfied */
assertTrue (curruptName(classTestName("A")) in metaCarpenter.objects) assertTrue(curruptName(classTestName("A")) in metaCarpenter.objects)
assertFalse (curruptName(classTestName("B")) in metaCarpenter.objects) assertFalse(curruptName(classTestName("B")) in metaCarpenter.objects)
assertEquals (1, carpenterSchema.carpenterSchemas.size) assertEquals(1, carpenterSchema.carpenterSchemas.size)
assertEquals (curruptName(classTestName("B")), carpenterSchema.carpenterSchemas.first().name) assertEquals(curruptName(classTestName("B")), carpenterSchema.carpenterSchemas.first().name)
assertTrue (carpenterSchema.dependencies.isEmpty()) assertTrue(carpenterSchema.dependencies.isEmpty())
assertTrue (carpenterSchema.dependsOn.isEmpty()) assertTrue(carpenterSchema.dependsOn.isEmpty())
/* second manual iteration, will carpent B */ /* second manual iteration, will carpent B */
metaCarpenter.build() metaCarpenter.build()
assert (curruptName(classTestName("A")) in metaCarpenter.objects) assert(curruptName(classTestName("A")) in metaCarpenter.objects)
assert (curruptName(classTestName("B")) in metaCarpenter.objects) assert(curruptName(classTestName("B")) in metaCarpenter.objects)
assertTrue (carpenterSchema.carpenterSchemas.isEmpty()) assertTrue(carpenterSchema.carpenterSchemas.isEmpty())
} }
@Test(expected = UncarpentableException::class) @Test(expected = UncarpentableException::class)
fun nestedIsUnkownInherited () { fun nestedIsUnkownInherited() {
val testA = 10 val testA = 10
val testB = 20 val testB = 20
val testC = 30 val testC = 30
@ -201,7 +200,7 @@ class CompositeMembers : AmqpCarpenterBase() {
open class A(val a: Int) open class A(val a: Int)
@CordaSerializable @CordaSerializable
class B(a: Int, var b: Int) : A (a) class B(a: Int, var b: Int) : A(a)
@CordaSerializable @CordaSerializable
data class C(val b: B, var c: Int) data class C(val b: B, var c: Int)
@ -212,13 +211,13 @@ class CompositeMembers : AmqpCarpenterBase() {
assert(obj.first is C) 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() amqpSchema.carpenterSchema()
} }
@Test(expected = UncarpentableException::class) @Test(expected = UncarpentableException::class)
fun nestedIsUnknownInheritedUnkown () { fun nestedIsUnknownInheritedUnkown() {
val testA = 10 val testA = 10
val testB = 20 val testB = 20
val testC = 30 val testC = 30
@ -227,7 +226,7 @@ class CompositeMembers : AmqpCarpenterBase() {
open class A(val a: Int) open class A(val a: Int)
@CordaSerializable @CordaSerializable
class B(a: Int, var b: Int) : A (a) class B(a: Int, var b: Int) : A(a)
@CordaSerializable @CordaSerializable
data class C(val b: B, var c: Int) data class C(val b: B, var c: Int)
@ -238,13 +237,13 @@ class CompositeMembers : AmqpCarpenterBase() {
assert(obj.first is C) 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() amqpSchema.carpenterSchema()
} }
@Test @Test
fun parentsIsUnknownWithUnkownInheritedMember () { fun parentsIsUnknownWithUnkownInheritedMember() {
val testA = 10 val testA = 10
val testB = 20 val testB = 20
val testC = 30 val testC = 30
@ -253,7 +252,7 @@ class CompositeMembers : AmqpCarpenterBase() {
open class A(val a: Int) open class A(val a: Int)
@CordaSerializable @CordaSerializable
class B(a: Int, var b: Int) : A (a) class B(a: Int, var b: Int) : A(a)
@CordaSerializable @CordaSerializable
data class C(val b: B, var c: Int) data class C(val b: B, var c: Int)
@ -264,7 +263,7 @@ class CompositeMembers : AmqpCarpenterBase() {
assert(obj.first is C) 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_ * but we do know about I_
*/ */
@Test @Test
fun nestedIsInterfaceToUnknown () { fun nestedIsInterfaceToUnknown() {
val testA = 10 val testA = 10
val testB = 20 val testB = 20
@ -282,7 +281,8 @@ class CompositeMembers : AmqpCarpenterBase() {
@CordaSerializable @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)
val b = B(A(testA), testB)
val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b)) val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b))
@ -299,6 +299,7 @@ class CompositeMembers : AmqpCarpenterBase() {
@CordaSerializable @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) val b = B(A(testA), testB)
val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b)) val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b))
@ -316,6 +317,7 @@ class CompositeMembers : AmqpCarpenterBase() {
@CordaSerializable @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) val b = B(A(testA), testB)
val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b)) val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(b))

231
experimental/src/test/kotlin/net/corda/carpenter/InheritanceSchemaToClassCarpenterTests.kt
View File

@ -11,31 +11,31 @@ import kotlin.test.*
@CordaSerializable @CordaSerializable
interface J { interface J {
val j : Int val j: Int
} }
/*******************************************************************************************************/ /*******************************************************************************************************/
@CordaSerializable @CordaSerializable
interface I { interface I {
val i : Int val i: Int
} }
@CordaSerializable @CordaSerializable
interface II { interface II {
val ii : Int val ii: Int
} }
@CordaSerializable @CordaSerializable
interface III : I { interface III : I {
val iii : Int val iii: Int
override val i: Int override val i: Int
} }
@CordaSerializable @CordaSerializable
interface IIII { interface IIII {
val iiii : Int val iiii: Int
val i : I val i: I
} }
/*******************************************************************************************************/ /*******************************************************************************************************/
@ -66,14 +66,14 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() {
it's extremely unlikely we'd need to carpent any classes */ it's extremely unlikely we'd need to carpent any classes */
assertEquals(0, l1.size) assertEquals(0, l1.size)
val curruptSchema = serSchema.curruptName (listOf (classTestName ("A"))) val curruptSchema = serSchema.curruptName(listOf(classTestName("A")))
val l2 = curruptSchema.carpenterSchema() val l2 = curruptSchema.carpenterSchema()
assertEquals(1, l2.size) assertEquals(1, l2.size)
val aSchema = l2.carpenterSchemas.find { it.name == curruptName(classTestName("A")) } val aSchema = l2.carpenterSchemas.find { it.name == curruptName(classTestName("A")) }
assertNotEquals (null, aSchema) assertNotEquals(null, aSchema)
assertEquals(curruptName(classTestName("A")), aSchema!!.name) assertEquals(curruptName(classTestName("A")), aSchema!!.name)
assertEquals(1, aSchema.interfaces.size) assertEquals(1, aSchema.interfaces.size)
@ -115,7 +115,7 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() {
it's extremely unlikely we'd need to carpent any classes */ it's extremely unlikely we'd need to carpent any classes */
assertEquals(0, l1.size) assertEquals(0, l1.size)
val curruptSchema = serSchema.curruptName (listOf (classTestName("A"))) val curruptSchema = serSchema.curruptName(listOf(classTestName("A")))
val aName = curruptName(classTestName("A")) val aName = curruptName(classTestName("A"))
val l2 = curruptSchema.carpenterSchema() val l2 = curruptSchema.carpenterSchema()
@ -143,13 +143,13 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() {
@Test @Test
fun multipleInterfaces() { fun multipleInterfaces() {
val testI = 20 val testI = 20
val testII = 40 val testII = 40
class A(override val i: Int, override val ii: Int) : I, II class A(override val i: Int, override val ii: Int) : I, II
val a = A(testI, testII) val a = A(testI, testII)
val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(a)) val obj = DeserializationInput(factory).deserializeAndReturnEnvelope(serialise(a))
assert(obj.first is 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 /* 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 */ needs some carpentry */
val curruptSchema = serSchema.curruptName (listOf (classTestName ("A"))) val curruptSchema = serSchema.curruptName(listOf(classTestName("A")))
val l2 = curruptSchema.carpenterSchema() val l2 = curruptSchema.carpenterSchema()
val aName = curruptName(classTestName("A")) val aName = curruptName(classTestName("A"))
assertEquals(1, l2.size) assertEquals(1, l2.size)
@ -178,31 +178,31 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() {
assertEquals(aName, aSchema!!.name) assertEquals(aName, aSchema!!.name)
assertEquals(2, aSchema.interfaces.size) assertEquals(2, aSchema.interfaces.size)
assert (net.corda.carpenter.I::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) assert(net.corda.carpenter.II::class.java in aSchema.interfaces)
val aBuilder = ClassCarpenter().build(aSchema) val aBuilder = ClassCarpenter().build(aSchema)
val objA = aBuilder.constructors[0].newInstance(testI, testII) val objA = aBuilder.constructors[0].newInstance(testI, testII)
val i = objA as I val i = objA as I
val ii = objA as II val ii = objA as II
assertEquals(aBuilder.getMethod("getI").invoke(objA), testI) assertEquals(aBuilder.getMethod("getI").invoke(objA), testI)
assertEquals(aBuilder.getMethod("getIi").invoke(objA), testII) assertEquals(aBuilder.getMethod("getIi").invoke(objA), testII)
assertEquals(a.i, i.i) assertEquals(a.i, i.i)
assertEquals(a.ii, ii.ii) assertEquals(a.ii, ii.ii)
} }
@Test @Test
fun nestedInterfaces() { fun nestedInterfaces() {
val testI = 20 val testI = 20
val testIII = 60 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 a = A(testI, testIII)
val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise(a)) val obj = DeserializationInput(factory).deserializeAndReturnEnvelope(serialise(a))
assert(obj.first is A) assert(obj.first is A)
@ -216,7 +216,7 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() {
it's extremely unlikely we'd need to carpent any classes */ it's extremely unlikely we'd need to carpent any classes */
assertEquals(0, l1.size) assertEquals(0, l1.size)
val curruptSchema = serSchema.curruptName (listOf (classTestName ("A"))) val curruptSchema = serSchema.curruptName(listOf(classTestName("A")))
val l2 = curruptSchema.carpenterSchema() val l2 = curruptSchema.carpenterSchema()
val aName = curruptName(classTestName("A")) val aName = curruptName(classTestName("A"))
@ -228,30 +228,30 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() {
assertEquals(aName, aSchema!!.name) assertEquals(aName, aSchema!!.name)
assertEquals(2, aSchema.interfaces.size) assertEquals(2, aSchema.interfaces.size)
assert (net.corda.carpenter.I::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) assert(net.corda.carpenter.III::class.java in aSchema.interfaces)
val aBuilder = ClassCarpenter().build(aSchema) val aBuilder = ClassCarpenter().build(aSchema)
val objA = aBuilder.constructors[0].newInstance(testI, testIII) val objA = aBuilder.constructors[0].newInstance(testI, testIII)
val i = objA as I val i = objA as I
val iii = objA as III val iii = objA as III
assertEquals(aBuilder.getMethod("getI").invoke(objA), testI) assertEquals(aBuilder.getMethod("getI").invoke(objA), testI)
assertEquals(aBuilder.getMethod("getIii").invoke(objA), testIII) assertEquals(aBuilder.getMethod("getIii").invoke(objA), testIII)
assertEquals(a.i, i.i) assertEquals(a.i, i.i)
assertEquals(a.i, iii.i) assertEquals(a.i, iii.i)
assertEquals(a.iii, iii.iii) assertEquals(a.iii, iii.iii)
} }
@Test @Test
fun memberInterface() { fun memberInterface() {
val testI = 25 val testI = 25
val testIIII = 50 val testIIII = 50
class A(override val i: Int) : I 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 a = A(testI)
val b = B(a, testIIII) val b = B(a, testIIII)
@ -270,20 +270,20 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() {
*/ */
assertEquals(4, serSchema.types.size) assertEquals(4, serSchema.types.size)
val curruptSchema = serSchema.curruptName (listOf (classTestName ("A"), classTestName ("B"))) val curruptSchema = serSchema.curruptName(listOf(classTestName("A"), classTestName("B")))
val cSchema = curruptSchema.carpenterSchema() val cSchema = curruptSchema.carpenterSchema()
val aName = curruptName(classTestName("A")) val aName = curruptName(classTestName("A"))
val bName = curruptName(classTestName("B")) val bName = curruptName(classTestName("B"))
assertEquals(2, cSchema.size) assertEquals(2, cSchema.size)
val aCarpenterSchema = cSchema.carpenterSchemas.find { it.name == aName } val aCarpenterSchema = cSchema.carpenterSchemas.find { it.name == aName }
val bCarpenterSchema = cSchema.carpenterSchemas.find { it.name == bName } val bCarpenterSchema = cSchema.carpenterSchemas.find { it.name == bName }
assertNotEquals (null, aCarpenterSchema) assertNotEquals(null, aCarpenterSchema)
assertNotEquals (null, bCarpenterSchema) assertNotEquals(null, bCarpenterSchema)
val cc = ClassCarpenter() val cc = ClassCarpenter()
val cc2 = ClassCarpenter() val cc2 = ClassCarpenter()
val bBuilder = cc.build(bCarpenterSchema!!) 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 */ to have a concrete class loaded without having access to all of it's elements */
@Test(expected = UncarpentableException::class) @Test(expected = UncarpentableException::class)
fun memberInterface2() { fun memberInterface2() {
val testI = 25 val testI = 25
val testIIII = 50 val testIIII = 50
class A(override val i: Int) : I 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 a = A(testI)
val b = B(a, testIIII) val b = B(a, testIIII)
@ -331,13 +332,13 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() {
assertEquals(4, serSchema.types.size) assertEquals(4, serSchema.types.size)
/* ignore the return as we expect this to throw */ /* ignore the return as we expect this to throw */
serSchema.curruptName (listOf ( serSchema.curruptName(listOf(
classTestName("A"), "${this.javaClass.`package`.name}.I")).carpenterSchema() classTestName("A"), "${this.javaClass.`package`.name}.I")).carpenterSchema()
} }
@Test @Test
fun interfaceAndImplementation() { fun interfaceAndImplementation() {
val testI = 25 val testI = 25
class A(override val i: Int) : I class A(override val i: Int) : I
@ -356,38 +357,38 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() {
*/ */
assertEquals(2, serSchema.types.size) 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 aName = curruptName(classTestName("A"))
val iName = curruptName ("${this.javaClass.`package`.name}.I") val iName = curruptName("${this.javaClass.`package`.name}.I")
val carpenterSchema = amqpSchema.carpenterSchema() val carpenterSchema = amqpSchema.carpenterSchema()
/* whilst there are two unknown classes within the envelope A depends on I so we can't construct a /* 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 */ schema for A until we have for I */
assertEquals (1, carpenterSchema.size) assertEquals(1, carpenterSchema.size)
assertNotEquals (null, carpenterSchema.carpenterSchemas.find { it.name == iName }) assertNotEquals(null, carpenterSchema.carpenterSchemas.find { it.name == iName })
/* since we can't build A it should list I as a dependency*/ /* since we can't build A it should list I as a dependency*/
assert (aName in carpenterSchema.dependencies) assert(aName in carpenterSchema.dependencies)
assertEquals (1, carpenterSchema.dependencies[aName]!!.second.size) assertEquals(1, carpenterSchema.dependencies[aName]!!.second.size)
assertEquals (iName, carpenterSchema.dependencies[aName]!!.second[0]) assertEquals(iName, carpenterSchema.dependencies[aName]!!.second[0])
/* and conversly I should have A listed as a dependent */ /* and conversly I should have A listed as a dependent */
assert(iName in carpenterSchema.dependsOn) assert(iName in carpenterSchema.dependsOn)
assertEquals(1, carpenterSchema.dependsOn[iName]!!.size) assertEquals(1, carpenterSchema.dependsOn[iName]!!.size)
assertEquals(aName, carpenterSchema.dependsOn[iName]!![0]) assertEquals(aName, carpenterSchema.dependsOn[iName]!![0])
val mc = MetaCarpenter (carpenterSchema) val mc = MetaCarpenter(carpenterSchema)
mc.build() mc.build()
assertEquals (0, mc.schemas.carpenterSchemas.size) assertEquals(0, mc.schemas.carpenterSchemas.size)
assertEquals (0, mc.schemas.dependencies.size) assertEquals(0, mc.schemas.dependencies.size)
assertEquals (0, mc.schemas.dependsOn.size) assertEquals(0, mc.schemas.dependsOn.size)
assertEquals (2, mc.objects.size) assertEquals(2, mc.objects.size)
assert (aName in mc.objects) assert(aName in mc.objects)
assert (iName in mc.objects) assert(iName in mc.objects)
mc.objects[aName]!!.constructors[0].newInstance(testI) mc.objects[aName]!!.constructors[0].newInstance(testI)
} }
@ -408,51 +409,51 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() {
"${this.javaClass.`package`.name}.I", "${this.javaClass.`package`.name}.I",
"${this.javaClass.`package`.name}.II")) "${this.javaClass.`package`.name}.II"))
val aName = curruptName (classTestName("A")) val aName = curruptName(classTestName("A"))
val iName = curruptName ("${this.javaClass.`package`.name}.I") val iName = curruptName("${this.javaClass.`package`.name}.I")
val iiName = curruptName ("${this.javaClass.`package`.name}.II") val iiName = curruptName("${this.javaClass.`package`.name}.II")
val carpenterSchema = amqpSchema.carpenterSchema() val carpenterSchema = amqpSchema.carpenterSchema()
/* there is nothing preventing us from carpenting up the two interfaces so /* 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 our initial list should contain both interface with A being dependent on both
and each having A as a dependent */ and each having A as a dependent */
assertEquals (2, carpenterSchema.carpenterSchemas.size) assertEquals(2, carpenterSchema.carpenterSchemas.size)
assertNotNull (carpenterSchema.carpenterSchemas.find { it.name == iName }) assertNotNull(carpenterSchema.carpenterSchemas.find { it.name == iName })
assertNotNull (carpenterSchema.carpenterSchemas.find { it.name == iiName }) assertNotNull(carpenterSchema.carpenterSchemas.find { it.name == iiName })
assertNull (carpenterSchema.carpenterSchemas.find { it.name == aName }) assertNull(carpenterSchema.carpenterSchemas.find { it.name == aName })
assert (iName in carpenterSchema.dependsOn) assert(iName in carpenterSchema.dependsOn)
assertEquals (1, carpenterSchema.dependsOn[iName]?.size) assertEquals(1, carpenterSchema.dependsOn[iName]?.size)
assertNotNull (carpenterSchema.dependsOn[iName]?.find ( { it == aName })) assertNotNull(carpenterSchema.dependsOn[iName]?.find({ it == aName }))
assert (iiName in carpenterSchema.dependsOn) assert(iiName in carpenterSchema.dependsOn)
assertEquals (1, carpenterSchema.dependsOn[iiName]?.size) assertEquals(1, carpenterSchema.dependsOn[iiName]?.size)
assertNotNull (carpenterSchema.dependsOn[iiName]?.find { it == aName }) assertNotNull(carpenterSchema.dependsOn[iiName]?.find { it == aName })
assert (aName in carpenterSchema.dependencies) assert(aName in carpenterSchema.dependencies)
assertEquals (2, carpenterSchema.dependencies[aName]!!.second.size) assertEquals(2, carpenterSchema.dependencies[aName]!!.second.size)
assertNotNull (carpenterSchema.dependencies[aName]!!.second.find { it == iName }) assertNotNull(carpenterSchema.dependencies[aName]!!.second.find { it == iName })
assertNotNull (carpenterSchema.dependencies[aName]!!.second.find { it == iiName }) assertNotNull(carpenterSchema.dependencies[aName]!!.second.find { it == iiName })
val mc = MetaCarpenter (carpenterSchema) val mc = MetaCarpenter(carpenterSchema)
mc.build() mc.build()
assertEquals (0, mc.schemas.carpenterSchemas.size) assertEquals(0, mc.schemas.carpenterSchemas.size)
assertEquals (0, mc.schemas.dependencies.size) assertEquals(0, mc.schemas.dependencies.size)
assertEquals (0, mc.schemas.dependsOn.size) assertEquals(0, mc.schemas.dependsOn.size)
assertEquals (3, mc.objects.size) assertEquals(3, mc.objects.size)
assert (aName in mc.objects) assert(aName in mc.objects)
assert (iName in mc.objects) assert(iName in mc.objects)
assert (iiName in mc.objects) assert(iiName in mc.objects)
} }
@Test @Test
fun nestedInterfacesAndImplementation() { fun nestedInterfacesAndImplementation() {
val testI = 7 val testI = 7
val testIII = 11 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) val a = A(testI, testIII)
@ -463,51 +464,51 @@ class InheritanceSchemaToClassCarpenterTests : AmqpCarpenterBase() {
"${this.javaClass.`package`.name}.I", "${this.javaClass.`package`.name}.I",
"${this.javaClass.`package`.name}.III")) "${this.javaClass.`package`.name}.III"))
val aName = curruptName (classTestName("A")) val aName = curruptName(classTestName("A"))
val iName = curruptName ("${this.javaClass.`package`.name}.I") val iName = curruptName("${this.javaClass.`package`.name}.I")
val iiiName = curruptName ("${this.javaClass.`package`.name}.III") val iiiName = curruptName("${this.javaClass.`package`.name}.III")
val carpenterSchema = amqpSchema.carpenterSchema() val carpenterSchema = amqpSchema.carpenterSchema()
/* Since A depends on III and III extends I we will have to construct them /* Since A depends on III and III extends I we will have to construct them
* in that reverse order (I -> III -> A) */ * in that reverse order (I -> III -> A) */
assertEquals (1, carpenterSchema.carpenterSchemas.size) assertEquals(1, carpenterSchema.carpenterSchemas.size)
assertNotNull (carpenterSchema.carpenterSchemas.find { it.name == iName }) assertNotNull(carpenterSchema.carpenterSchemas.find { it.name == iName })
assertNull (carpenterSchema.carpenterSchemas.find { it.name == iiiName }) assertNull(carpenterSchema.carpenterSchemas.find { it.name == iiiName })
assertNull (carpenterSchema.carpenterSchemas.find { it.name == aName }) assertNull(carpenterSchema.carpenterSchemas.find { it.name == aName })
/* I has III as a direct dependent and A as an indirect one */ /* I has III as a direct dependent and A as an indirect one */
assert (iName in carpenterSchema.dependsOn) assert(iName in carpenterSchema.dependsOn)
assertEquals (2, carpenterSchema.dependsOn[iName]?.size) assertEquals(2, carpenterSchema.dependsOn[iName]?.size)
assertNotNull (carpenterSchema.dependsOn[iName]?.find ( { it == iiiName })) assertNotNull(carpenterSchema.dependsOn[iName]?.find({ it == iiiName }))
assertNotNull (carpenterSchema.dependsOn[iName]?.find ( { it == aName })) assertNotNull(carpenterSchema.dependsOn[iName]?.find({ it == aName }))
/* III has A as a dependent */ /* III has A as a dependent */
assert (iiiName in carpenterSchema.dependsOn) assert(iiiName in carpenterSchema.dependsOn)
assertEquals (1, carpenterSchema.dependsOn[iiiName]?.size) assertEquals(1, carpenterSchema.dependsOn[iiiName]?.size)
assertNotNull (carpenterSchema.dependsOn[iiiName]?.find { it == aName }) assertNotNull(carpenterSchema.dependsOn[iiiName]?.find { it == aName })
/* converly III depends on I */ /* converly III depends on I */
assert (iiiName in carpenterSchema.dependencies) assert(iiiName in carpenterSchema.dependencies)
assertEquals (1, carpenterSchema.dependencies[iiiName]!!.second.size) assertEquals(1, carpenterSchema.dependencies[iiiName]!!.second.size)
assertNotNull (carpenterSchema.dependencies[iiiName]!!.second.find { it == iName }) assertNotNull(carpenterSchema.dependencies[iiiName]!!.second.find { it == iName })
/* and A depends on III and I*/ /* and A depends on III and I*/
assert (aName in carpenterSchema.dependencies) assert(aName in carpenterSchema.dependencies)
assertEquals (2, carpenterSchema.dependencies[aName]!!.second.size) assertEquals(2, carpenterSchema.dependencies[aName]!!.second.size)
assertNotNull (carpenterSchema.dependencies[aName]!!.second.find { it == iiiName }) assertNotNull(carpenterSchema.dependencies[aName]!!.second.find { it == iiiName })
assertNotNull (carpenterSchema.dependencies[aName]!!.second.find { it == iName }) assertNotNull(carpenterSchema.dependencies[aName]!!.second.find { it == iName })
val mc = MetaCarpenter (carpenterSchema) val mc = MetaCarpenter(carpenterSchema)
mc.build() mc.build()
assertEquals (0, mc.schemas.carpenterSchemas.size) assertEquals(0, mc.schemas.carpenterSchemas.size)
assertEquals (0, mc.schemas.dependencies.size) assertEquals(0, mc.schemas.dependencies.size)
assertEquals (0, mc.schemas.dependsOn.size) assertEquals(0, mc.schemas.dependsOn.size)
assertEquals (3, mc.objects.size) assertEquals(3, mc.objects.size)
assert (aName in mc.objects) assert(aName in mc.objects)
assert (iName in mc.objects) assert(iName in mc.objects)
assert (iiiName in mc.objects) assert(iiiName in mc.objects)
} }
} }

22
experimental/src/test/kotlin/net/corda/carpenter/MultiMemberCompositeSchemaToClassCarpenterTests.kt
View File

@ -32,19 +32,19 @@ class MultiMemberCompositeSchemaToClassCarpenterTests : AmqpCarpenterBase() {
var amqpSchema = obj.second.schema.types[0] as CompositeType var amqpSchema = obj.second.schema.types[0] as CompositeType
assertEquals(2, amqpSchema.fields.size) assertEquals(2, amqpSchema.fields.size)
assertEquals("a", amqpSchema.fields[0].name) assertEquals("a", amqpSchema.fields[0].name)
assertEquals("int", amqpSchema.fields[0].type) assertEquals("int", amqpSchema.fields[0].type)
assertEquals("b", amqpSchema.fields[1].name) assertEquals("b", amqpSchema.fields[1].name)
assertEquals("int", amqpSchema.fields[1].type) assertEquals("int", amqpSchema.fields[1].type)
val carpenterSchema = CarpenterSchemas.newInstance() val carpenterSchema = CarpenterSchemas.newInstance()
amqpSchema.carpenterSchema(carpenterSchemas = carpenterSchema, force = true) amqpSchema.carpenterSchema(carpenterSchemas = carpenterSchema, force = true)
assertEquals (1, carpenterSchema.size) assertEquals(1, carpenterSchema.size)
val aSchema = carpenterSchema.carpenterSchemas.find { it.name == classTestName ("A") } val aSchema = carpenterSchema.carpenterSchemas.find { it.name == classTestName("A") }
assertNotEquals (null, aSchema) assertNotEquals(null, aSchema)
val pinochio = ClassCarpenter().build(aSchema!!) val pinochio = ClassCarpenter().build(aSchema!!)
@ -76,16 +76,16 @@ class MultiMemberCompositeSchemaToClassCarpenterTests : AmqpCarpenterBase() {
val amqpSchema = obj.second.schema.types[0] as CompositeType val amqpSchema = obj.second.schema.types[0] as CompositeType
assertEquals(2, amqpSchema.fields.size) assertEquals(2, amqpSchema.fields.size)
assertEquals("a", amqpSchema.fields[0].name) assertEquals("a", amqpSchema.fields[0].name)
assertEquals("int", amqpSchema.fields[0].type) assertEquals("int", amqpSchema.fields[0].type)
assertEquals("b", amqpSchema.fields[1].name) assertEquals("b", amqpSchema.fields[1].name)
assertEquals("string", amqpSchema.fields[1].type) assertEquals("string", amqpSchema.fields[1].type)
val carpenterSchema = CarpenterSchemas.newInstance() val carpenterSchema = CarpenterSchemas.newInstance()
amqpSchema.carpenterSchema(carpenterSchemas = carpenterSchema, force = true) amqpSchema.carpenterSchema(carpenterSchemas = carpenterSchema, force = true)
assertEquals (1, carpenterSchema.size) assertEquals(1, carpenterSchema.size)
val aSchema = carpenterSchema.carpenterSchemas.find { it.name == classTestName("A") } val aSchema = carpenterSchema.carpenterSchemas.find { it.name == classTestName("A") }
assertNotEquals(null, aSchema) assertNotEquals(null, aSchema)

240
experimental/src/test/kotlin/net/corda/carpenter/SingleMemberCompositeSchemaToClassCarpenterTests.kt
View File

@ -1,44 +1,47 @@
package net.corda.carpenter package net.corda.carpenter
import net.corda.carpenter.test.AmqpCarpenterBase
import net.corda.core.serialization.CordaSerializable import net.corda.core.serialization.CordaSerializable
import net.corda.core.serialization.amqp.* import net.corda.core.serialization.amqp.*
import net.corda.core.serialization.carpenter.CarpenterSchemas
import org.junit.Test import org.junit.Test
import kotlin.test.assertEquals import kotlin.test.assertEquals
class SingleMemberCompositeSchemaToClassCarpenterTests { class SingleMemberCompositeSchemaToClassCarpenterTests : AmqpCarpenterBase() {
private var factory = SerializerFactory()
fun serialise (clazz : Any) = SerializationOutput(factory).serialize(clazz)
@Test @Test
fun singleInteger() { fun singleInteger() {
val test = 10 val test = 10
@CordaSerializable @CordaSerializable
data class A(val a : Int) data class A(val a: Int)
val 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) assert(obj.obj is A)
val amqpObj = obj.first as A val amqpObj = obj.obj as A
assertEquals (test, amqpObj.a) assertEquals(test, amqpObj.a)
assertEquals (1, obj.second.schema.types.size) assertEquals(1, obj.envelope.schema.types.size)
assert (obj.second.schema.types[0] is CompositeType) 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(1, amqpSchema.fields.size)
assertEquals ("a", amqpSchema.fields[0].name) assertEquals("a", amqpSchema.fields[0].name)
assertEquals ("int", amqpSchema.fields[0].type) 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 @Test
@ -46,29 +49,30 @@ class SingleMemberCompositeSchemaToClassCarpenterTests {
val test = "ten" val test = "ten"
@CordaSerializable @CordaSerializable
data class A(val a : String) data class A(val a: String)
var a = A (test)
val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise (a)) val a = A(test)
assert (obj.first is A) val obj = DeserializationInput(factory).deserializeAndReturnEnvelope(serialise(a))
val amqpObj = obj.first as A
assertEquals (test, amqpObj.a) assert(obj.obj is A)
assertEquals (1, obj.second.schema.types.size) val amqpObj = obj.obj as A
assert (obj.second.schema.types[0] is CompositeType)
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) val amqpSchema = obj.envelope.schema.types[0] as CompositeType
assertEquals ("a", amqpSchema.fields[0].name)
assertEquals ("string", 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)
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 @CordaSerializable
data class A(val a : Char) 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) assert (obj.obj is A)
val amqpObj = obj.first as A val amqpObj = obj.obj as A
assertEquals (test, amqpObj.a) assertEquals (test, amqpObj.a)
assertEquals (1, obj.second.schema.types.size) assertEquals (1, obj.envelope.schema.types.size)
assertEquals (1, obj.second.schema.types.size) assertEquals (1, obj.envelope.schema.types.size)
assert (obj.second.schema.types[0] is CompositeType) 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 (1, amqpSchema.fields.size)
assertEquals ("a", amqpSchema.fields[0].name) assertEquals ("a", amqpSchema.fields[0].name)
assertEquals ("char", amqpSchema.fields[0].type) 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) val p = pinochio.constructors[0].newInstance (test)
@ -109,30 +119,33 @@ class SingleMemberCompositeSchemaToClassCarpenterTests {
val test = 10L val test = 10L
@CordaSerializable @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) assert(obj.obj is A)
val amqpObj = obj.first as A val amqpObj = obj.obj as A
assertEquals (test, amqpObj.a) assertEquals(test, amqpObj.a)
assertEquals (1, obj.second.schema.types.size) assertEquals(1, obj.envelope.schema.types.size)
assert (obj.second.schema.types[0] is CompositeType) 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(1, amqpSchema.fields.size)
assertEquals ("a", amqpSchema.fields[0].name) assertEquals("a", amqpSchema.fields[0].name)
assertEquals ("long", amqpSchema.fields[0].type) 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 @Test
@ -140,30 +153,33 @@ class SingleMemberCompositeSchemaToClassCarpenterTests {
val test = 10.toShort() val test = 10.toShort()
@CordaSerializable @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) assert(obj.obj is A)
val amqpObj = obj.first as A val amqpObj = obj.obj as A
assertEquals (test, amqpObj.a) assertEquals(test, amqpObj.a)
assertEquals (1, obj.second.schema.types.size) assertEquals(1, obj.envelope.schema.types.size)
assert (obj.second.schema.types[0] is CompositeType) 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(1, amqpSchema.fields.size)
assertEquals ("a", amqpSchema.fields[0].name) assertEquals("a", amqpSchema.fields[0].name)
assertEquals ("short", amqpSchema.fields[0].type) 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)) val obj = DeserializationInput(factory).deserializeRtnEnvelope(serialise (a))
assert (obj.first is A) assert (obj.obj is A)
val amqpObj = obj.first as A val amqpObj = obj.obj as A
assertEquals (test, amqpObj.a) assertEquals (test, amqpObj.a)
assertEquals (1, obj.second.schema.types.size) assertEquals (1, obj.envelope.schema.types.size)
assert (obj.second.schema.types[0] is CompositeType) 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 (1, amqpSchema.fields.size)
assertEquals ("a", amqpSchema.fields[0].name) assertEquals ("a", amqpSchema.fields[0].name)
@ -204,60 +220,66 @@ class SingleMemberCompositeSchemaToClassCarpenterTests {
val test = 10.0 val test = 10.0
@CordaSerializable @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) assert(obj.obj is A)
val amqpObj = obj.first as A val amqpObj = obj.obj as A
assertEquals (test, amqpObj.a) assertEquals(test, amqpObj.a)
assertEquals (1, obj.second.schema.types.size) assertEquals(1, obj.envelope.schema.types.size)
assert (obj.second.schema.types[0] is CompositeType) 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(1, amqpSchema.fields.size)
assertEquals ("a", amqpSchema.fields[0].name) assertEquals("a", amqpSchema.fields[0].name)
assertEquals ("double", amqpSchema.fields[0].type) 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 @Test
fun singleFloat() { fun singleFloat() {
val test = 10.0F val test: Float = 10.0F
@CordaSerializable @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) assert(obj.obj is A)
val amqpObj = obj.first as A val amqpObj = obj.obj as A
assertEquals (test, amqpObj.a) assertEquals(test, amqpObj.a)
assertEquals (1, obj.second.schema.types.size) assertEquals(1, obj.envelope.schema.types.size)
assert (obj.second.schema.types[0] is CompositeType) 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(1, amqpSchema.fields.size)
assertEquals ("a", amqpSchema.fields[0].name) assertEquals("a", amqpSchema.fields[0].name)
assertEquals ("float", amqpSchema.fields[0].type) 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)
} }
} }