From afdf5fb7179625271dd61a380c896db09fe69e02 Mon Sep 17 00:00:00 2001
From: Katelyn Baker <katelyn.baker@r3.com>
Date: Fri, 8 Dec 2017 14:21:30 +0000
Subject: [PATCH] Code tidy up, auto reformat, IntelliJ suggestions
---
.../amqp/EnumEvolutionSerializer.kt | 6 +-
.../serialization/amqp/PropertySerializer.kt | 19 ++-
.../serialization/amqp/TansformTypes.kt | 23 ++--
.../serialization/amqp/TransformsSchema.kt | 56 ++++----
.../amqp/EnumEvolvabilityTests.kt | 129 +++++++++---------
.../serialization/amqp/EnumEvolveTests.kt | 39 +++---
.../internal/serialization/amqp/EnumTests.kt | 19 ++-
.../serialization/amqp/EvolvabilityTests.kt | 7 +-
8 files changed, 148 insertions(+), 150 deletions(-)
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumEvolutionSerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumEvolutionSerializer.kt
index ec8a61c793..88639d466b 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumEvolutionSerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumEvolutionSerializer.kt
@@ -27,9 +27,9 @@ import java.util.*
* transformation rules we create a mapping between those values and the values that exist on the
* current class
*
- * @property clazz The enum as it exists now, not as it did when it was serialized (either in the past
+ * @property type The enum as it exists now, not as it did when it was serialized (either in the past
* or future).
- * @property factory the [SerializerFactory] that is building this serialization object.
+ * @param factory the [SerializerFactory] that is building this serialization object.
* @property conversions A mapping between all potential enum constants that could've been assigned to
* an instance of the enum as it existed at time of serialisation and those that exist now
* @property ordinals Convenience mapping of constant to ordinality
@@ -57,7 +57,7 @@ class EnumEvolutionSerializer(
* received AMQP header
* @param new The Serializer object we built based on the current state of the enum class on our classpath
* @param factory the [SerializerFactory] that is building this serialization object.
- * @param transformsFromBlob the transforms attached to the class in the AMQP header, i.e. the transforms
+ * @param schemas the transforms attached to the class in the AMQP header, i.e. the transforms
* known at serialization time
*/
fun make(old: RestrictedType,
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt
index 230a3eb4a8..d296a8fd91 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt
@@ -32,17 +32,16 @@ sealed class PropertySerializer(val name: String, val readMethod: Method?, val r
return if (isInterface) listOf(SerializerFactory.nameForType(resolvedType)) else emptyList()
}
- private fun generateDefault(): String? {
- if (isJVMPrimitive) {
- return when (resolvedType) {
- java.lang.Boolean.TYPE -> "false"
- java.lang.Character.TYPE -> "�"
- else -> "0"
+ private fun generateDefault(): String? =
+ if (isJVMPrimitive) {
+ when (resolvedType) {
+ java.lang.Boolean.TYPE -> "false"
+ java.lang.Character.TYPE -> "�"
+ else -> "0"
+ }
+ } else {
+ null
}
- } else {
- return null
- }
- }
private fun generateMandatory(): Boolean {
return isJVMPrimitive || readMethod?.returnsNullable() == false
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/TansformTypes.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/TansformTypes.kt
index 0003a48ba2..09c9be7746 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/TansformTypes.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/TansformTypes.kt
@@ -28,7 +28,7 @@ enum class TransformTypes(val build: (Annotation) -> Transform) : DescribedType
Unknown({ UnknownTransform() }) {
override fun getDescriptor(): Any = DESCRIPTOR
override fun getDescribed(): Any = ordinal
- override fun validate(l : List<Transform>, constants: Map<String, Int>) { }
+ override fun validate(list: List<Transform>, constants: Map<String, Int>) {}
},
EnumDefault({ a -> EnumDefaultSchemaTransform((a as CordaSerializationTransformEnumDefault).old, a.new) }) {
override fun getDescriptor(): Any = DESCRIPTOR
@@ -37,13 +37,13 @@ enum class TransformTypes(val build: (Annotation) -> Transform) : DescribedType
/**
* Validates a list of constant additions to an enumerated type. To be valid a default (the value
* that should be used when we cannot use the new value) must refer to a constant that exists in the
- * enum class as it exists now and it cannot refer to itself.
+ * enum class as it exists now and it cannot refer to itself.
*
- * @param l The list of transforms representing new constants and the mapping from that constant to an
+ * @param list The list of transforms representing new constants and the mapping from that constant to an
* existing value
* @param constants The list of enum constants on the type the transforms are being applied to
*/
- override fun validate(list : List<Transform>, constants: Map<String, Int>) {
+ override fun validate(list: List<Transform>, constants: Map<String, Int>) {
uncheckedCast<List<Transform>, List<EnumDefaultSchemaTransform>>(list).forEach {
if (!constants.contains(it.new)) {
throw NotSerializableException("Unknown enum constant ${it.new}")
@@ -62,7 +62,7 @@ enum class TransformTypes(val build: (Annotation) -> Transform) : DescribedType
if (constants[it.old]!! >= constants[it.new]!!) {
throw NotSerializableException(
"Enum extensions must default to older constants. ${it.new}[${constants[it.new]}] " +
- "defaults to ${it.old}[${constants[it.old]}] which is greater")
+ "defaults to ${it.old}[${constants[it.old]}] which is greater")
}
}
}
@@ -76,15 +76,16 @@ enum class TransformTypes(val build: (Annotation) -> Transform) : DescribedType
* that is a constant is renamed to something that used to exist in the enum. We do this for both
* the same constant (i.e. C -> D -> C) and multiple constants (C->D, B->C)
*
- * @param l The list of transforms representing the renamed constants and the mapping between their new
+ * @param list The list of transforms representing the renamed constants and the mapping between their new
* and old values
* @param constants The list of enum constants on the type the transforms are being applied to
*/
- override fun validate(l : List<Transform>, constants: Map<String, Int>) {
+ override fun validate(list: List<Transform>, constants: Map<String, Int>) {
object : Any() {
- val from : MutableSet<String> = mutableSetOf()
- val to : MutableSet<String> = mutableSetOf() }.apply {
- @Suppress("UNCHECKED_CAST") (l as List<RenameSchemaTransform>).forEach { rename ->
+ val from: MutableSet<String> = mutableSetOf()
+ val to: MutableSet<String> = mutableSetOf()
+ }.apply {
+ @Suppress("UNCHECKED_CAST") (list as List<RenameSchemaTransform>).forEach { rename ->
if (rename.to in this.to || rename.from in this.from) {
throw NotSerializableException("Cyclic renames are not allowed (${rename.to})")
}
@@ -104,7 +105,7 @@ enum class TransformTypes(val build: (Annotation) -> Transform) : DescribedType
//}
;
- abstract fun validate(l: List<Transform>, constants: Map<String, Int>)
+ abstract fun validate(list: List<Transform>, constants: Map<String, Int>)
companion object : DescribedTypeConstructor<TransformTypes> {
val DESCRIPTOR = AMQPDescriptorRegistry.TRANSFORM_ELEMENT_KEY.amqpDescriptor
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/TransformsSchema.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/TransformsSchema.kt
index 378675b84e..1d01f91f4f 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/TransformsSchema.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/TransformsSchema.kt
@@ -92,7 +92,7 @@ class UnknownTestTransform(val a: Int, val b: Int, val c: Int) : Transform() {
companion object : DescribedTypeConstructor<UnknownTestTransform> {
val typeName = "UnknownTest"
- override fun newInstance(obj: Any?) : UnknownTestTransform {
+ override fun newInstance(obj: Any?): UnknownTestTransform {
val described = obj as List<*>
return UnknownTestTransform(described[1] as Int, described[2] as Int, described[3] as Int)
}
@@ -201,41 +201,41 @@ data class TransformsSchema(val types: Map<String, EnumMap<TransformTypes, Mutab
* class loader and this dictates which classes we can and cannot see
*/
fun get(name: String, sf: SerializerFactory) = sf.transformsCache.computeIfAbsent(name) {
- val transforms = EnumMap<TransformTypes, MutableList<Transform>>(TransformTypes::class.java)
- try {
- val clazz = sf.classloader.loadClass(name)
+ val transforms = EnumMap<TransformTypes, MutableList<Transform>>(TransformTypes::class.java)
+ try {
+ val clazz = sf.classloader.loadClass(name)
- supportedTransforms.forEach { transform ->
- clazz.getAnnotation(transform.type)?.let { list ->
- transform.getAnnotations(list).forEach { annotation ->
- val t = transform.enum.build(annotation)
+ supportedTransforms.forEach { transform ->
+ clazz.getAnnotation(transform.type)?.let { list ->
+ transform.getAnnotations(list).forEach { annotation ->
+ val t = transform.enum.build(annotation)
- // we're explicitly rejecting repeated annotations, whilst it's fine and we'd just
- // ignore them it feels like a good thing to alert the user to since this is
- // more than likely a typo in their code so best make it an actual error
- if (transforms.computeIfAbsent(transform.enum) { mutableListOf() }
- .filter { t == it }
- .isNotEmpty()) {
- throw NotSerializableException(
- "Repeated unique transformation annotation of type ${t.name}")
- }
-
- transforms[transform.enum]!!.add(t)
+ // we're explicitly rejecting repeated annotations, whilst it's fine and we'd just
+ // ignore them it feels like a good thing to alert the user to since this is
+ // more than likely a typo in their code so best make it an actual error
+ if (transforms.computeIfAbsent(transform.enum) { mutableListOf() }
+ .filter { t == it }
+ .isNotEmpty()) {
+ throw NotSerializableException(
+ "Repeated unique transformation annotation of type ${t.name}")
}
- transform.enum.validate(
- transforms[transform.enum] ?: emptyList(),
- clazz.enumConstants.mapIndexed { i, s -> Pair(s.toString(), i) }.toMap())
+ transforms[transform.enum]!!.add(t)
}
- }
- } catch (_: ClassNotFoundException) {
- // if we can't load the class we'll end up caching an empty list which is fine as that
- // list, on lookup, won't be included in the schema because it's empty
- }
- transforms
+ transform.enum.validate(
+ transforms[transform.enum] ?: emptyList(),
+ clazz.enumConstants.mapIndexed { i, s -> Pair(s.toString(), i) }.toMap())
+ }
+ }
+ } catch (_: ClassNotFoundException) {
+ // if we can't load the class we'll end up caching an empty list which is fine as that
+ // list, on lookup, won't be included in the schema because it's empty
}
+ transforms
+ }
+
private fun getAndAdd(
type: String,
sf: SerializerFactory,
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumEvolvabilityTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumEvolvabilityTests.kt
index 969db89a54..d18b970cfa 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumEvolvabilityTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumEvolvabilityTests.kt
@@ -6,7 +6,6 @@ import org.assertj.core.api.Assertions
import org.junit.Test
import java.io.File
import java.io.NotSerializableException
-import java.net.URI
import kotlin.test.assertEquals
import kotlin.test.assertTrue
@@ -47,7 +46,7 @@ class EnumEvolvabilityTests {
@Test
fun noAnnotation() {
- data class C (val n: NotAnnotated)
+ data class C(val n: NotAnnotated)
val sf = testDefaultFactory()
val bAndS = TestSerializationOutput(VERBOSE, sf).serializeAndReturnSchema(C(NotAnnotated.A))
@@ -63,7 +62,7 @@ class EnumEvolvabilityTests {
@Test
fun missingDefaults() {
- data class C (val m: MissingDefaults)
+ data class C(val m: MissingDefaults)
val sf = testDefaultFactory()
val bAndS = TestSerializationOutput(VERBOSE, sf).serializeAndReturnSchema(C(MissingDefaults.A))
@@ -74,7 +73,7 @@ class EnumEvolvabilityTests {
@Test
fun missingRenames() {
- data class C (val m: MissingRenames)
+ data class C(val m: MissingRenames)
val sf = testDefaultFactory()
val bAndS = TestSerializationOutput(VERBOSE, sf).serializeAndReturnSchema(C(MissingRenames.A))
@@ -86,7 +85,7 @@ class EnumEvolvabilityTests {
@Test
fun defaultAnnotationIsAddedToEnvelope() {
- data class C (val annotatedEnum: AnnotatedEnumOnce)
+ data class C(val annotatedEnum: AnnotatedEnumOnce)
val sf = testDefaultFactory()
val bAndS = TestSerializationOutput(VERBOSE, sf).serializeAndReturnSchema(C(AnnotatedEnumOnce.D))
@@ -94,45 +93,45 @@ class EnumEvolvabilityTests {
// only the enum is decorated so schema sizes should be different (2 objects, only one evolved)
assertEquals(2, bAndS.schema.types.size)
assertEquals(1, bAndS.transformsSchema.types.size)
- assertEquals (AnnotatedEnumOnce::class.java.name, bAndS.transformsSchema.types.keys.first())
+ assertEquals(AnnotatedEnumOnce::class.java.name, bAndS.transformsSchema.types.keys.first())
val schema = bAndS.transformsSchema.types.values.first()
assertEquals(1, schema.size)
- assertTrue (schema.keys.contains(TransformTypes.EnumDefault))
- assertEquals (1, schema[TransformTypes.EnumDefault]!!.size)
- assertTrue (schema[TransformTypes.EnumDefault]!![0] is EnumDefaultSchemaTransform)
- assertEquals ("D", (schema[TransformTypes.EnumDefault]!![0] as EnumDefaultSchemaTransform).new)
- assertEquals ("A", (schema[TransformTypes.EnumDefault]!![0] as EnumDefaultSchemaTransform).old)
+ assertTrue(schema.keys.contains(TransformTypes.EnumDefault))
+ assertEquals(1, schema[TransformTypes.EnumDefault]!!.size)
+ assertTrue(schema[TransformTypes.EnumDefault]!![0] is EnumDefaultSchemaTransform)
+ assertEquals("D", (schema[TransformTypes.EnumDefault]!![0] as EnumDefaultSchemaTransform).new)
+ assertEquals("A", (schema[TransformTypes.EnumDefault]!![0] as EnumDefaultSchemaTransform).old)
}
@Test
fun doubleDefaultAnnotationIsAddedToEnvelope() {
- data class C (val annotatedEnum: AnnotatedEnumTwice)
+ data class C(val annotatedEnum: AnnotatedEnumTwice)
val sf = testDefaultFactory()
val bAndS = TestSerializationOutput(VERBOSE, sf).serializeAndReturnSchema(C(AnnotatedEnumTwice.E))
assertEquals(2, bAndS.schema.types.size)
assertEquals(1, bAndS.transformsSchema.types.size)
- assertEquals (AnnotatedEnumTwice::class.java.name, bAndS.transformsSchema.types.keys.first())
+ assertEquals(AnnotatedEnumTwice::class.java.name, bAndS.transformsSchema.types.keys.first())
val schema = bAndS.transformsSchema.types.values.first()
assertEquals(1, schema.size)
- assertTrue (schema.keys.contains(TransformTypes.EnumDefault))
- assertEquals (2, schema[TransformTypes.EnumDefault]!!.size)
- assertTrue (schema[TransformTypes.EnumDefault]!![0] is EnumDefaultSchemaTransform)
- assertEquals ("E", (schema[TransformTypes.EnumDefault]!![0] as EnumDefaultSchemaTransform).new)
- assertEquals ("D", (schema[TransformTypes.EnumDefault]!![0] as EnumDefaultSchemaTransform).old)
- assertTrue (schema[TransformTypes.EnumDefault]!![1] is EnumDefaultSchemaTransform)
- assertEquals ("D", (schema[TransformTypes.EnumDefault]!![1] as EnumDefaultSchemaTransform).new)
- assertEquals ("A", (schema[TransformTypes.EnumDefault]!![1] as EnumDefaultSchemaTransform).old)
+ assertTrue(schema.keys.contains(TransformTypes.EnumDefault))
+ assertEquals(2, schema[TransformTypes.EnumDefault]!!.size)
+ assertTrue(schema[TransformTypes.EnumDefault]!![0] is EnumDefaultSchemaTransform)
+ assertEquals("E", (schema[TransformTypes.EnumDefault]!![0] as EnumDefaultSchemaTransform).new)
+ assertEquals("D", (schema[TransformTypes.EnumDefault]!![0] as EnumDefaultSchemaTransform).old)
+ assertTrue(schema[TransformTypes.EnumDefault]!![1] is EnumDefaultSchemaTransform)
+ assertEquals("D", (schema[TransformTypes.EnumDefault]!![1] as EnumDefaultSchemaTransform).new)
+ assertEquals("A", (schema[TransformTypes.EnumDefault]!![1] as EnumDefaultSchemaTransform).old)
}
@Test
fun defaultAnnotationIsAddedToEnvelopeAndDeserialised() {
- data class C (val annotatedEnum: AnnotatedEnumOnce)
+ data class C(val annotatedEnum: AnnotatedEnumOnce)
val sf = testDefaultFactory()
val sb = TestSerializationOutput(VERBOSE, sf).serialize(C(AnnotatedEnumOnce.D))
@@ -152,11 +151,11 @@ class EnumEvolvabilityTests {
val schema = transforms[eName]
- assertTrue (schema!!.keys.contains(TransformTypes.EnumDefault))
- assertEquals (1, schema[TransformTypes.EnumDefault]!!.size)
- assertTrue (schema[TransformTypes.EnumDefault]!![0] is EnumDefaultSchemaTransform)
- assertEquals ("D", (schema[TransformTypes.EnumDefault]!![0] as EnumDefaultSchemaTransform).new)
- assertEquals ("A", (schema[TransformTypes.EnumDefault]!![0] as EnumDefaultSchemaTransform).old)
+ assertTrue(schema!!.keys.contains(TransformTypes.EnumDefault))
+ assertEquals(1, schema[TransformTypes.EnumDefault]!!.size)
+ assertTrue(schema[TransformTypes.EnumDefault]!![0] is EnumDefaultSchemaTransform)
+ assertEquals("D", (schema[TransformTypes.EnumDefault]!![0] as EnumDefaultSchemaTransform).new)
+ assertEquals("A", (schema[TransformTypes.EnumDefault]!![0] as EnumDefaultSchemaTransform).old)
}
@Test
@@ -174,9 +173,9 @@ class EnumEvolvabilityTests {
val transforms = db.envelope.transformsSchema.types
- assertTrue (transforms.contains(AnnotatedEnumTwice::class.java.name))
- assertTrue (transforms[AnnotatedEnumTwice::class.java.name]!!.contains(TransformTypes.EnumDefault))
- assertEquals (2, transforms[AnnotatedEnumTwice::class.java.name]!![TransformTypes.EnumDefault]!!.size)
+ assertTrue(transforms.contains(AnnotatedEnumTwice::class.java.name))
+ assertTrue(transforms[AnnotatedEnumTwice::class.java.name]!!.contains(TransformTypes.EnumDefault))
+ assertEquals(2, transforms[AnnotatedEnumTwice::class.java.name]!![TransformTypes.EnumDefault]!!.size)
val enumDefaults = transforms[AnnotatedEnumTwice::class.java.name]!![TransformTypes.EnumDefault]!!
@@ -188,7 +187,7 @@ class EnumEvolvabilityTests {
@Test
fun renameAnnotationIsAdded() {
- data class C (val annotatedEnum: RenameEnumOnce)
+ data class C(val annotatedEnum: RenameEnumOnce)
val sf = testDefaultFactory()
@@ -197,7 +196,7 @@ class EnumEvolvabilityTests {
assertEquals(2, bAndS.schema.types.size)
assertEquals(1, bAndS.transformsSchema.types.size)
- assertEquals (RenameEnumOnce::class.java.name, bAndS.transformsSchema.types.keys.first())
+ assertEquals(RenameEnumOnce::class.java.name, bAndS.transformsSchema.types.keys.first())
val serialisedSchema = bAndS.transformsSchema.types[RenameEnumOnce::class.java.name]!!
@@ -212,7 +211,7 @@ class EnumEvolvabilityTests {
assertEquals(2, cAndS.envelope.schema.types.size)
assertEquals(1, cAndS.envelope.transformsSchema.types.size)
- assertEquals (RenameEnumOnce::class.java.name, cAndS.envelope.transformsSchema.types.keys.first())
+ assertEquals(RenameEnumOnce::class.java.name, cAndS.envelope.transformsSchema.types.keys.first())
val deserialisedSchema = cAndS.envelope.transformsSchema.types[RenameEnumOnce::class.java.name]!!
@@ -232,7 +231,7 @@ class EnumEvolvabilityTests {
@Test
fun doubleRenameAnnotationIsAdded() {
- data class C (val annotatedEnum: RenameEnumTwice)
+ data class C(val annotatedEnum: RenameEnumTwice)
val sf = testDefaultFactory()
@@ -241,7 +240,7 @@ class EnumEvolvabilityTests {
assertEquals(2, bAndS.schema.types.size)
assertEquals(1, bAndS.transformsSchema.types.size)
- assertEquals (RenameEnumTwice::class.java.name, bAndS.transformsSchema.types.keys.first())
+ assertEquals(RenameEnumTwice::class.java.name, bAndS.transformsSchema.types.keys.first())
val serialisedSchema = bAndS.transformsSchema.types[RenameEnumTwice::class.java.name]!!
@@ -258,7 +257,7 @@ class EnumEvolvabilityTests {
assertEquals(2, cAndS.envelope.schema.types.size)
assertEquals(1, cAndS.envelope.transformsSchema.types.size)
- assertEquals (RenameEnumTwice::class.java.name, cAndS.envelope.transformsSchema.types.keys.first())
+ assertEquals(RenameEnumTwice::class.java.name, cAndS.envelope.transformsSchema.types.keys.first())
val deserialisedSchema = cAndS.envelope.transformsSchema.types[RenameEnumTwice::class.java.name]!!
@@ -271,15 +270,15 @@ class EnumEvolvabilityTests {
assertEquals("F", (deserialisedSchema[TransformTypes.Rename]!![1] as RenameSchemaTransform).to)
}
- @CordaSerializationTransformRename(from="A", to="X")
- @CordaSerializationTransformEnumDefault(old = "X", new="E")
+ @CordaSerializationTransformRename(from = "A", to = "X")
+ @CordaSerializationTransformEnumDefault(old = "X", new = "E")
enum class RenameAndExtendEnum {
X, B, C, D, E
}
@Test
fun bothAnnotationTypes() {
- data class C (val annotatedEnum: RenameAndExtendEnum)
+ data class C(val annotatedEnum: RenameAndExtendEnum)
val sf = testDefaultFactory()
@@ -288,15 +287,15 @@ class EnumEvolvabilityTests {
assertEquals(2, bAndS.schema.types.size)
assertEquals(1, bAndS.transformsSchema.types.size)
- assertEquals (RenameAndExtendEnum::class.java.name, bAndS.transformsSchema.types.keys.first())
+ assertEquals(RenameAndExtendEnum::class.java.name, bAndS.transformsSchema.types.keys.first())
val serialisedSchema = bAndS.transformsSchema.types[RenameAndExtendEnum::class.java.name]!!
// This time there should be two distinct transform types (all previous tests have had only
// a single type
assertEquals(2, serialisedSchema.size)
- assertTrue (serialisedSchema.containsKey(TransformTypes.Rename))
- assertTrue (serialisedSchema.containsKey(TransformTypes.EnumDefault))
+ assertTrue(serialisedSchema.containsKey(TransformTypes.Rename))
+ assertTrue(serialisedSchema.containsKey(TransformTypes.EnumDefault))
assertEquals(1, serialisedSchema[TransformTypes.Rename]!!.size)
assertEquals("A", (serialisedSchema[TransformTypes.Rename]!![0] as RenameSchemaTransform).from)
@@ -307,7 +306,7 @@ class EnumEvolvabilityTests {
assertEquals("X", (serialisedSchema[TransformTypes.EnumDefault]!![0] as EnumDefaultSchemaTransform).old)
}
- @CordaSerializationTransformEnumDefaults (
+ @CordaSerializationTransformEnumDefaults(
CordaSerializationTransformEnumDefault("D", "A"),
CordaSerializationTransformEnumDefault("D", "A"))
enum class RepeatedAnnotation {
@@ -316,7 +315,7 @@ class EnumEvolvabilityTests {
@Test
fun repeatedAnnotation() {
- data class C (val a: RepeatedAnnotation)
+ data class C(val a: RepeatedAnnotation)
val sf = testDefaultFactory()
@@ -330,40 +329,40 @@ class EnumEvolvabilityTests {
A, B, C, D
}
- @CordaSerializationTransformEnumDefaults (
+ @CordaSerializationTransformEnumDefaults(
CordaSerializationTransformEnumDefault("D", "A"),
CordaSerializationTransformEnumDefault("E", "A"))
enum class E2 {
A, B, C, D, E
}
- @CordaSerializationTransformEnumDefaults (CordaSerializationTransformEnumDefault("D", "A"))
+ @CordaSerializationTransformEnumDefaults(CordaSerializationTransformEnumDefault("D", "A"))
enum class E3 {
A, B, C, D
}
@Test
fun multiEnums() {
- data class A (val a: E1, val b: E2)
- data class B (val a: E3, val b: A, val c: E1)
- data class C (val a: B, val b: E2, val c: E3)
+ data class A(val a: E1, val b: E2)
+ data class B(val a: E3, val b: A, val c: E1)
+ data class C(val a: B, val b: E2, val c: E3)
- val c = C(B(E3.A,A(E1.A,E2.B),E1.C),E2.B,E3.A)
+ val c = C(B(E3.A, A(E1.A, E2.B), E1.C), E2.B, E3.A)
val sf = testDefaultFactory()
// Serialise the object
val bAndS = TestSerializationOutput(VERBOSE, sf).serializeAndReturnSchema(c)
- println (bAndS.transformsSchema)
+ println(bAndS.transformsSchema)
// we have six types and three of those, the enums, should have transforms
assertEquals(6, bAndS.schema.types.size)
assertEquals(3, bAndS.transformsSchema.types.size)
- assertTrue (E1::class.java.name in bAndS.transformsSchema.types)
- assertTrue (E2::class.java.name in bAndS.transformsSchema.types)
- assertTrue (E3::class.java.name in bAndS.transformsSchema.types)
+ assertTrue(E1::class.java.name in bAndS.transformsSchema.types)
+ assertTrue(E2::class.java.name in bAndS.transformsSchema.types)
+ assertTrue(E3::class.java.name in bAndS.transformsSchema.types)
val e1S = bAndS.transformsSchema.types[E1::class.java.name]!!
val e2S = bAndS.transformsSchema.types[E2::class.java.name]!!
@@ -404,7 +403,7 @@ class EnumEvolvabilityTests {
assertTrue(sf.transformsCache.containsKey(C2::class.java.name))
assertTrue(sf.transformsCache.containsKey(AnnotatedEnumOnce::class.java.name))
- assertEquals (sb1.transformsSchema.types[AnnotatedEnumOnce::class.java.name],
+ assertEquals(sb1.transformsSchema.types[AnnotatedEnumOnce::class.java.name],
sb2.transformsSchema.types[AnnotatedEnumOnce::class.java.name])
}
@@ -447,7 +446,7 @@ class EnumEvolvabilityTests {
//
// And we're not at 3. However, we ban this rename
//
- @CordaSerializationTransformRenames (
+ @CordaSerializationTransformRenames(
CordaSerializationTransformRename("D", "C"),
CordaSerializationTransformRename("C", "D")
)
@@ -455,7 +454,7 @@ class EnumEvolvabilityTests {
@Test
fun rejectCyclicRename() {
- data class C (val e: RejectCyclicRename)
+ data class C(val e: RejectCyclicRename)
val sf = testDefaultFactory()
Assertions.assertThatThrownBy {
@@ -468,7 +467,7 @@ class EnumEvolvabilityTests {
// unserailzble. However, in this case, it isn't a struct cycle, rather one element
// is renamed to match what a different element used to be called
//
- @CordaSerializationTransformRenames (
+ @CordaSerializationTransformRenames(
CordaSerializationTransformRename(from = "B", to = "C"),
CordaSerializationTransformRename(from = "C", to = "D")
)
@@ -476,7 +475,7 @@ class EnumEvolvabilityTests {
@Test
fun rejectCyclicRenameAlt() {
- data class C (val e: RejectCyclicRenameAlt)
+ data class C(val e: RejectCyclicRenameAlt)
val sf = testDefaultFactory()
Assertions.assertThatThrownBy {
@@ -484,7 +483,7 @@ class EnumEvolvabilityTests {
}.isInstanceOf(NotSerializableException::class.java)
}
- @CordaSerializationTransformRenames (
+ @CordaSerializationTransformRenames(
CordaSerializationTransformRename("G", "C"),
CordaSerializationTransformRename("F", "G"),
CordaSerializationTransformRename("E", "F"),
@@ -495,7 +494,7 @@ class EnumEvolvabilityTests {
@Test
fun rejectCyclicRenameRedux() {
- data class C (val e: RejectCyclicRenameRedux)
+ data class C(val e: RejectCyclicRenameRedux)
val sf = testDefaultFactory()
Assertions.assertThatThrownBy {
@@ -503,12 +502,12 @@ class EnumEvolvabilityTests {
}.isInstanceOf(NotSerializableException::class.java)
}
- @CordaSerializationTransformEnumDefault (new = "D", old = "X")
+ @CordaSerializationTransformEnumDefault(new = "D", old = "X")
enum class RejectBadDefault { A, B, C, D }
@Test
fun rejectBadDefault() {
- data class C (val e: RejectBadDefault)
+ data class C(val e: RejectBadDefault)
val sf = testDefaultFactory()
Assertions.assertThatThrownBy {
@@ -516,12 +515,12 @@ class EnumEvolvabilityTests {
}.isInstanceOf(NotSerializableException::class.java)
}
- @CordaSerializationTransformEnumDefault (new = "D", old = "D")
+ @CordaSerializationTransformEnumDefault(new = "D", old = "D")
enum class RejectBadDefaultToSelf { A, B, C, D }
@Test
fun rejectBadDefaultToSelf() {
- data class C (val e: RejectBadDefaultToSelf)
+ data class C(val e: RejectBadDefaultToSelf)
val sf = testDefaultFactory()
Assertions.assertThatThrownBy {
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumEvolveTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumEvolveTests.kt
index b2939d7fa9..bdcde9bf64 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumEvolveTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumEvolveTests.kt
@@ -1,12 +1,13 @@
package net.corda.nodeapi.internal.serialization.amqp
-import net.corda.core.serialization.*
+import net.corda.core.serialization.CordaSerializationTransformEnumDefault
+import net.corda.core.serialization.CordaSerializationTransformEnumDefaults
+import net.corda.core.serialization.SerializedBytes
import net.corda.testing.common.internal.ProjectStructure.projectRootDir
import org.assertj.core.api.Assertions
import org.junit.Test
import java.io.File
import java.io.NotSerializableException
-import java.net.URI
import kotlin.test.assertEquals
// NOTE: To recreate the test files used by these tests uncomment the original test classes and comment
@@ -30,7 +31,7 @@ class EnumEvolveTests {
val resource = "${javaClass.simpleName}.${testName()}"
val sf = testDefaultFactory()
- data class C (val e : DeserializeNewerSetToUnknown)
+ data class C(val e: DeserializeNewerSetToUnknown)
// Uncomment to re-generate test files
// File(URI("$localPath/$resource")).writeBytes(
@@ -40,7 +41,7 @@ class EnumEvolveTests {
val obj = DeserializationInput(sf).deserialize(SerializedBytes<C>(File(path.toURI()).readBytes()))
- assertEquals (DeserializeNewerSetToUnknown.C, obj.e)
+ assertEquals(DeserializeNewerSetToUnknown.C, obj.e)
}
// Version of the class as it was serialised
@@ -78,9 +79,9 @@ class EnumEvolveTests {
// of the evolution code
val obj3 = DeserializationInput(sf).deserialize(SerializedBytes<C>(File(path3.toURI()).readBytes()))
- assertEquals (DeserializeNewerSetToUnknown2.C, obj1.e)
- assertEquals (DeserializeNewerSetToUnknown2.C, obj2.e)
- assertEquals (DeserializeNewerSetToUnknown2.C, obj3.e)
+ assertEquals(DeserializeNewerSetToUnknown2.C, obj1.e)
+ assertEquals(DeserializeNewerSetToUnknown2.C, obj2.e)
+ assertEquals(DeserializeNewerSetToUnknown2.C, obj3.e)
}
@@ -149,7 +150,7 @@ class EnumEvolveTests {
data class C(val e: DeserializeWithRename)
// Uncomment to re-generate test files, needs to be done in three stages
- val so = SerializationOutput(sf)
+ // val so = SerializationOutput(sf)
// First change
// File(URI("$localPath/$resource.1.AA")).writeBytes(so.serialize(C(DeserializeWithRename.AA)).bytes)
// File(URI("$localPath/$resource.1.B")).writeBytes(so.serialize(C(DeserializeWithRename.B)).bytes)
@@ -271,7 +272,7 @@ class EnumEvolveTests {
data class C(val e: MultiOperations)
// Uncomment to re-generate test files, needs to be done in three stages
- val so = SerializationOutput(sf)
+ // val so = SerializationOutput(sf)
// First change
// File(URI("$localPath/$resource.1.A")).writeBytes(so.serialize(C(MultiOperations.A)).bytes)
// File(URI("$localPath/$resource.1.B")).writeBytes(so.serialize(C(MultiOperations.B)).bytes)
@@ -345,15 +346,15 @@ class EnumEvolveTests {
Pair("$resource.5.G", MultiOperations.C))
fun load(l: List<Pair<String, MultiOperations>>) = l.map {
- Pair (DeserializationInput(sf).deserialize(SerializedBytes<C>(
- File(EvolvabilityTests::class.java.getResource(it.first).toURI()).readBytes())), it.second)
+ Pair(DeserializationInput(sf).deserialize(SerializedBytes<C>(
+ File(EvolvabilityTests::class.java.getResource(it.first).toURI()).readBytes())), it.second)
}
- load (stage1Resources).forEach { assertEquals(it.second, it.first.e) }
- load (stage2Resources).forEach { assertEquals(it.second, it.first.e) }
- load (stage3Resources).forEach { assertEquals(it.second, it.first.e) }
- load (stage4Resources).forEach { assertEquals(it.second, it.first.e) }
- load (stage5Resources).forEach { assertEquals(it.second, it.first.e) }
+ load(stage1Resources).forEach { assertEquals(it.second, it.first.e) }
+ load(stage2Resources).forEach { assertEquals(it.second, it.first.e) }
+ load(stage3Resources).forEach { assertEquals(it.second, it.first.e) }
+ load(stage4Resources).forEach { assertEquals(it.second, it.first.e) }
+ load(stage5Resources).forEach { assertEquals(it.second, it.first.e) }
}
@CordaSerializationTransformEnumDefault(old = "A", new = "F")
@@ -363,7 +364,7 @@ class EnumEvolveTests {
fun badNewValue() {
val sf = testDefaultFactory()
- data class C (val e : BadNewValue)
+ data class C(val e: BadNewValue)
Assertions.assertThatThrownBy {
SerializationOutput(sf).serialize(C(BadNewValue.A))
@@ -374,13 +375,13 @@ class EnumEvolveTests {
CordaSerializationTransformEnumDefault(new = "D", old = "E"),
CordaSerializationTransformEnumDefault(new = "E", old = "A")
)
- enum class OutOfOrder { A, B, C, D, E}
+ enum class OutOfOrder { A, B, C, D, E }
@Test
fun outOfOrder() {
val sf = testDefaultFactory()
- data class C (val e : OutOfOrder)
+ data class C(val e: OutOfOrder)
Assertions.assertThatThrownBy {
SerializationOutput(sf).serialize(C(OutOfOrder.A))
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumTests.kt
index 1f20ac013f..60805c994f 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumTests.kt
@@ -2,17 +2,14 @@ package net.corda.nodeapi.internal.serialization.amqp
import net.corda.core.serialization.ClassWhitelist
import net.corda.core.serialization.CordaSerializable
-import org.junit.Test
-import java.time.DayOfWeek
-
-import kotlin.test.assertEquals
-import kotlin.test.assertNotNull
-
-import java.io.File
-import java.io.NotSerializableException
-
import net.corda.core.serialization.SerializedBytes
import org.assertj.core.api.Assertions
+import org.junit.Test
+import java.io.File
+import java.io.NotSerializableException
+import java.time.DayOfWeek
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
class EnumTests {
enum class Bras {
@@ -42,8 +39,8 @@ class EnumTests {
//}
// the new state, note in the test we serialised with value UNDERWIRE so the spacer
- // occuring after this won't have changed the ordinality of our serialised value
- // and thus should still be deserialisable
+ // occurring after this won't have changed the ordinality of our serialised value
+ // and thus should still be deserializable
enum class OldBras2 {
TSHIRT, UNDERWIRE, PUSHUP, SPACER, BRALETTE, SPACER2
}
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EvolvabilityTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EvolvabilityTests.kt
index 10a59e1414..6d084408f3 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EvolvabilityTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EvolvabilityTests.kt
@@ -6,7 +6,6 @@ import net.corda.testing.common.internal.ProjectStructure.projectRootDir
import org.junit.Test
import java.io.File
import java.io.NotSerializableException
-import java.net.URI
import kotlin.test.assertEquals
// To regenerate any of the binary test files do the following
@@ -19,13 +18,14 @@ import kotlin.test.assertEquals
// 5. Comment back out the generation code and uncomment the actual test
class EvolvabilityTests {
// When regenerating the test files this needs to be set to the file system location of the resource files
+ @Suppress("UNUSED")
var localPath = projectRootDir.toUri().resolve(
"node-api/src/test/resources/net/corda/nodeapi/internal/serialization/amqp")
@Test
fun simpleOrderSwapSameType() {
val sf = testDefaultFactory()
- val resource= "EvolvabilityTests.simpleOrderSwapSameType"
+ val resource = "EvolvabilityTests.simpleOrderSwapSameType"
val A = 1
val B = 2
@@ -89,7 +89,7 @@ class EvolvabilityTests {
assertEquals(A, deserializedC.a)
assertEquals(null, deserializedC.b)
- }
+ }
@Test(expected = NotSerializableException::class)
fun addAdditionalParam() {
@@ -369,6 +369,7 @@ class EvolvabilityTests {
// Add a parameter to inner but keep outer unchanged
data class Inner(val a: Int, val b: String?)
+
data class Outer(val a: Int, val b: Inner)
val path = EvolvabilityTests::class.java.getResource(resource)