CORDA-1497 enum evolution (#4343)

* Get enum transforms during type info building

* Eliminate transforms cache

* Allow combined renaming and defaulting for enums

* Comments and moving build method to EnumTransforms

* Force validation on EnumTransforms creation

* Remove commented code

* Cope with multiple renames

serialization/src/test/kotlin/net/corda/serialization/internal/amqp/EnumEvolvabilityTests.kt

@@ -516,27 +516,6 @@ class EnumEvolvabilityTests {
         }.isInstanceOf(NotSerializableException::class.java)
     }
 
-    //
-    // In this test, like the above, we're looking to ensure repeated renames are rejected as
-    // 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(
-            CordaSerializationTransformRename(from = "B", to = "C"),
-            CordaSerializationTransformRename(from = "C", to = "D")
-    )
-    enum class RejectCyclicRenameAlt { A, C, D }
-
-    @Test
-    fun rejectCyclicRenameAlt() {
-        data class C(val e: RejectCyclicRenameAlt)
-
-        val sf = testDefaultFactory()
-        assertThatThrownBy {
-            SerializationOutput(sf).serialize(C(RejectCyclicRenameAlt.A))
-        }.isInstanceOf(NotSerializableException::class.java)
-    }
-
     @CordaSerializationTransformRenames(
             CordaSerializationTransformRename("G", "C"),
             CordaSerializationTransformRename("F", "G"),

serialization/src/test/kotlin/net/corda/serialization/internal/amqp/EnumTransformationTests.kt

@@ -0,0 +1,56 @@
+package net.corda.serialization.internal.amqp
+
+import net.corda.core.serialization.CordaSerializationTransformEnumDefault
+import net.corda.core.serialization.CordaSerializationTransformEnumDefaults
+import net.corda.core.serialization.CordaSerializationTransformRename
+import net.corda.core.serialization.CordaSerializationTransformRenames
+import net.corda.serialization.internal.model.EnumTransforms
+import net.corda.serialization.internal.model.InvalidEnumTransformsException
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import kotlin.test.assertFailsWith
+
+class EnumTransformationTests {
+
+    @CordaSerializationTransformEnumDefaults(
+            CordaSerializationTransformEnumDefault(old = "C", new = "D"),
+            CordaSerializationTransformEnumDefault(old = "D", new = "E")
+    )
+    @CordaSerializationTransformRenames(
+        CordaSerializationTransformRename(to = "BOB", from = "FRED"),
+        CordaSerializationTransformRename(to = "FRED", from = "E")
+    )
+    enum class MultiOperations { A, B, C, D, BOB }
+
+    // See https://r3-cev.atlassian.net/browse/CORDA-1497
+    @Test
+    fun defaultAndRename() {
+        val transforms = EnumTransforms.build(
+                TransformsAnnotationProcessor.getTransformsSchema(MultiOperations::class.java),
+                MultiOperations::class.java.constants)
+
+        assertEquals(mapOf("BOB" to "FRED", "FRED" to "E"), transforms.renames)
+        assertEquals(mapOf("D" to "C", "E" to "D"), transforms.defaults)
+    }
+
+    @CordaSerializationTransformRenames(
+            CordaSerializationTransformRename(from = "A", to = "C"),
+            CordaSerializationTransformRename(from = "B", to = "D"),
+            CordaSerializationTransformRename(from = "C", to = "E"),
+            CordaSerializationTransformRename(from = "E", to = "B"),
+            CordaSerializationTransformRename(from = "D", to = "A")
+    )
+    enum class RenameCycle { A, B, C, D, E}
+
+    @Test
+    fun cycleDetection() {
+        assertFailsWith<InvalidEnumTransformsException> {
+            EnumTransforms.build(
+                    TransformsAnnotationProcessor.getTransformsSchema(RenameCycle::class.java),
+                    RenameCycle::class.java.constants)
+        }
+    }
+
+    private val Class<*>.constants: Map<String, Int> get() =
+        enumConstants.asSequence().mapIndexed { index, constant -> constant.toString() to index }.toMap()
+}