Merge pull request #1473 from corda/feature/kat/carpentEnum

CORDA-539 - Add enum support to the carpenter

node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterTest.kt

@@ -15,12 +15,12 @@ class ClassCarpenterTest {
         val b: Int
     }
 
-    val cc = ClassCarpenter()
+    private val cc = ClassCarpenter()
 
     // We have to ignore synthetic fields even though ClassCarpenter doesn't create any because the JaCoCo
     // coverage framework auto-magically injects one method and one field into every class loaded into the JVM.
-    val Class<*>.nonSyntheticFields: List<Field> get() = declaredFields.filterNot { it.isSynthetic }
-    val Class<*>.nonSyntheticMethods: List<Method> get() = declaredMethods.filterNot { it.isSynthetic }
+    private val Class<*>.nonSyntheticFields: List<Field> get() = declaredFields.filterNot { it.isSynthetic }
+    private val Class<*>.nonSyntheticMethods: List<Method> get() = declaredMethods.filterNot { it.isSynthetic }
 
     @Test
     fun empty() {

node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterTestUtils.kt

@@ -3,6 +3,7 @@ package net.corda.nodeapi.internal.serialization.carpenter
 import net.corda.nodeapi.internal.serialization.amqp.*
 import net.corda.nodeapi.internal.serialization.amqp.Field
 import net.corda.nodeapi.internal.serialization.amqp.Schema
+import net.corda.nodeapi.internal.serialization.AllWhitelist
 
 fun mangleName(name: String) = "${name}__carpenter"
 
@@ -34,7 +35,8 @@ fun Schema.mangleNames(names: List<String>): Schema {
 }
 
 open class AmqpCarpenterBase {
-    var factory = testDefaultFactory()
+    var cc = ClassCarpenter()
+    var  factory = SerializerFactory(AllWhitelist, cc.classloader)
 
     fun serialise(clazz: Any) = SerializationOutput(factory).serialize(clazz)
     fun testName(): String = Thread.currentThread().stackTrace[2].methodName

node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/EnumClassTests.kt

@@ -0,0 +1,105 @@
+package net.corda.nodeapi.internal.serialization.carpenter
+
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class EnumClassTests : AmqpCarpenterBase() {
+
+    @Test
+    fun oneValue() {
+        val enumConstants = mapOf("A" to EnumField())
+
+        val schema = EnumSchema("gen.enum", enumConstants)
+
+        assertTrue(cc.build(schema).isEnum)
+    }
+
+    @Test
+    fun oneValueInstantiate() {
+        val enumConstants = mapOf("A" to EnumField())
+        val schema = EnumSchema("gen.enum", enumConstants)
+        val clazz = cc.build(schema)
+
+        assertTrue(clazz.isEnum)
+        assertEquals(enumConstants.size, clazz.enumConstants.size)
+        assertEquals("A", clazz.enumConstants.first().toString())
+        assertEquals(0, (clazz.enumConstants.first() as Enum<*>).ordinal)
+        assertEquals("A", (clazz.enumConstants.first() as Enum<*>).name)
+    }
+
+    @Test
+    fun twoValuesInstantiate() {
+        val enumConstants = mapOf("left" to EnumField(), "right" to EnumField())
+        val schema = EnumSchema("gen.enum", enumConstants)
+        val clazz = cc.build(schema)
+
+        assertTrue(clazz.isEnum)
+        assertEquals(enumConstants.size, clazz.enumConstants.size)
+
+        val left = clazz.enumConstants[0] as Enum<*>
+        val right = clazz.enumConstants[1] as Enum<*>
+
+        assertEquals(0, left.ordinal)
+        assertEquals("left", left.name)
+        assertEquals(1, right.ordinal)
+        assertEquals("right", right.name)
+    }
+
+    @Test
+    fun manyValues() {
+        val enumConstants = listOf("AAA", "BBB", "CCC", "DDD", "EEE", "FFF",
+                "GGG", "HHH", "III", "JJJ").associateBy({ it }, { EnumField() })
+        val schema = EnumSchema("gen.enum", enumConstants)
+        val clazz = cc.build(schema)
+
+        assertTrue(clazz.isEnum)
+        assertEquals(enumConstants.size, clazz.enumConstants.size)
+
+        var idx = 0
+        enumConstants.forEach {
+            val constant = clazz.enumConstants[idx] as Enum<*>
+            assertEquals(idx++, constant.ordinal)
+            assertEquals(it.key, constant.name)
+        }
+    }
+
+    @Test
+    fun assignment() {
+        val enumConstants = listOf("AAA", "BBB", "CCC", "DDD", "EEE", "FFF").associateBy({ it }, { EnumField() })
+        val schema = EnumSchema("gen.enum", enumConstants)
+        val clazz = cc.build(schema)
+
+        assertEquals("CCC", clazz.getMethod("valueOf", String::class.java).invoke(null, "CCC").toString())
+        assertEquals("CCC", (clazz.getMethod("valueOf", String::class.java).invoke(null, "CCC") as Enum<*>).name)
+
+        val ddd = clazz.getMethod("valueOf", String::class.java).invoke(null, "DDD") as Enum<*>
+
+        assertTrue(ddd::class.java.isEnum)
+        assertEquals("DDD", ddd.name)
+        assertEquals(3, ddd.ordinal)
+    }
+
+    // if anything goes wrong with this test it's going to end up throwing *some*
+    // exception, hence the lack of asserts
+    @Test
+    fun assignAndTest() {
+        val cc2 = ClassCarpenter()
+
+        val schema1 = EnumSchema("gen.enum",
+                listOf("AAA", "BBB", "CCC", "DDD", "EEE", "FFF").associateBy({ it }, { EnumField() }))
+
+        val enumClazz = cc2.build(schema1)
+
+        val schema2 = ClassSchema("gen.class",
+                mapOf(
+                        "a" to NonNullableField(Int::class.java),
+                        "b" to NonNullableField(enumClazz)))
+
+        val classClazz = cc2.build(schema2)
+
+        // make sure we can construct a class that has an enum we've constructed as a member
+        classClazz.constructors[0].newInstance(1, enumClazz.getMethod(
+                "valueOf", String::class.java).invoke(null, "BBB"))
+    }
+}