Commonize common tests

processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClassTests.kt

@@ -0,0 +1,24 @@
+package com.livefront.sealedenum.compilation.basic
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class EmptySealedClassTests {
+    @Test
+    fun empty_sealed_class() {
+        assertEquals(emptyList<EmptySealedClass>(), EmptySealedClass.values)
+    }
+
+    @Test
+    fun empty_enum_for_sealed_class() {
+        assertEquals(
+            EmptySealedClass.values.map(EmptySealedClass::enum),
+            enumValues<EmptySealedClassEnum>().toList()
+        )
+    }
+
+    @Test
+    fun correct_enum_class() {
+        assertEquals(EmptySealedClassEnum::class, EmptySealedClass.sealedEnum.enumClass)
+    }
+}

processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterfaceTests.kt

@@ -0,0 +1,24 @@
+package com.livefront.sealedenum.compilation.basic
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class EmptySealedInterfaceTests {
+    @Test
+    fun empty_sealed_interface() {
+        assertEquals(emptyList<EmptySealedInterface>(), EmptySealedInterface.values)
+    }
+
+    @Test
+    fun empty_enum_for_sealed_interface() {
+        assertEquals(
+            EmptySealedInterface.values.map(EmptySealedInterface::enum),
+            enumValues<EmptySealedInterfaceEnum>().toList()
+        )
+    }
+
+    @Test
+    fun correct_enum_class() {
+        assertEquals(EmptySealedInterfaceEnum::class, EmptySealedInterface.sealedEnum.enumClass)
+    }
+}

processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedClassTests.kt

@@ -0,0 +1,32 @@
+package com.livefront.sealedenum.compilation.basic
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class OneObjectSealedClassTests {
+    @Test
+    fun one_object_sealed_class() {
+        assertEquals(listOf(OneObjectSealedClass.FirstObject), OneObjectSealedClass.values)
+    }
+
+    @Test
+    fun one_enum_for_sealed_class() {
+        assertEquals(
+            listOf(OneObjectSealedClassEnum.OneObjectSealedClass_FirstObject),
+            enumValues<OneObjectSealedClassEnum>().toList()
+        )
+    }
+
+    @Test
+    fun one_enum_for_sealed_class_with_mapping() {
+        assertEquals(
+            OneObjectSealedClass.values.map(OneObjectSealedClass::enum),
+            enumValues<OneObjectSealedClassEnum>().toList()
+        )
+    }
+
+    @Test
+    fun correct_enum_class() {
+        assertEquals(OneObjectSealedClassEnum::class, OneObjectSealedClass.sealedEnum.enumClass)
+    }
+}

processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedInterfaceTests.kt

@@ -0,0 +1,32 @@
+package com.livefront.sealedenum.compilation.basic
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class OneObjectSealedInterfaceTests {
+    @Test
+    fun one_object_sealed_interface() {
+        assertEquals(listOf(OneObjectSealedInterface.FirstObject), OneObjectSealedInterface.values)
+    }
+
+    @Test
+    fun one_enum_for_sealed_interface() {
+        assertEquals(
+            listOf(OneObjectSealedInterfaceEnum.OneObjectSealedInterface_FirstObject),
+            enumValues<OneObjectSealedInterfaceEnum>().toList()
+        )
+    }
+
+    @Test
+    fun one_enum_for_sealed_interface_with_mapping() {
+        assertEquals(
+            OneObjectSealedInterface.values.map(OneObjectSealedInterface::enum),
+            enumValues<OneObjectSealedInterfaceEnum>().toList()
+        )
+    }
+
+    @Test
+    fun correct_enum_class() {
+        assertEquals(OneObjectSealedInterfaceEnum::class, OneObjectSealedInterface.sealedEnum.enumClass)
+    }
+}

processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedClassTests.kt

@@ -0,0 +1,38 @@
+package com.livefront.sealedenum.compilation.basic
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class TwoObjectSealedClassTests {
+    @Test
+    fun two_objects_sealed_class() {
+        assertEquals(
+            listOf(TwoObjectSealedClass.FirstObject, TwoObjectSealedClass.SecondObject),
+            TwoObjectSealedClassSealedEnum.values
+        )
+    }
+
+    @Test
+    fun two_enums_for_sealed_class() {
+        assertEquals(
+            listOf(
+                TwoObjectSealedClassEnum.TwoObjectSealedClass_FirstObject,
+                TwoObjectSealedClassEnum.TwoObjectSealedClass_SecondObject
+            ),
+            enumValues<TwoObjectSealedClassEnum>().toList()
+        )
+    }
+
+    @Test
+    fun two_enums_for_sealed_class_with_mapping() {
+        assertEquals(
+            TwoObjectSealedClass.values.map(TwoObjectSealedClass::enum),
+            enumValues<TwoObjectSealedClassEnum>().toList()
+        )
+    }
+
+    @Test
+    fun correct_enum_class() {
+        assertEquals(TwoObjectSealedClassEnum::class, TwoObjectSealedClassSealedEnum.enumClass)
+    }
+}

processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedInterfaceTests.kt

@@ -0,0 +1,38 @@
+package com.livefront.sealedenum.compilation.basic
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class TwoObjectSealedInterfaceTests {
+    @Test
+    fun two_objects_sealed_interface() {
+        assertEquals(
+            listOf(TwoObjectSealedInterface.FirstObject, TwoObjectSealedInterface.SecondObject),
+            TwoObjectSealedInterface.values
+        )
+    }
+
+    @Test
+    fun two_enums_for_sealed_interface() {
+        assertEquals(
+            listOf(
+                TwoObjectSealedInterfaceEnum.TwoObjectSealedInterface_FirstObject,
+                TwoObjectSealedInterfaceEnum.TwoObjectSealedInterface_SecondObject
+            ),
+            enumValues<TwoObjectSealedInterfaceEnum>().toList()
+        )
+    }
+
+    @Test
+    fun two_enums_for_sealed_interface_with_mapping() {
+        assertEquals(
+            TwoObjectSealedInterface.values.map(TwoObjectSealedInterface::enum),
+            enumValues<TwoObjectSealedInterfaceEnum>().toList()
+        )
+    }
+
+    @Test
+    fun correct_enum_class() {
+        assertEquals(TwoObjectSealedInterfaceEnum::class, TwoObjectSealedInterface.sealedEnum.enumClass)
+    }
+}

processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/GenericSealedClassTests.kt

@@ -0,0 +1,50 @@
+package com.livefront.sealedenum.compilation.generics
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class GenericSealedClassTests {
+    @Test
+    fun one_type_parameter_sealed_class() {
+        assertEquals(
+            listOf(
+                OneTypeParameterSealedClass.FirstObject,
+                OneTypeParameterSealedClass.SecondObject,
+                OneTypeParameterSealedClass.ThirdObject
+            ),
+            OneTypeParameterSealedClass.values
+        )
+    }
+
+    @Test
+    fun two_type_parameter_sealed_class() {
+        assertEquals(
+            listOf(
+                TwoTypeParameterSealedClass.FirstObject,
+                TwoTypeParameterSealedClass.SecondObject
+            ),
+            TwoTypeParameterSealedClass.values
+        )
+    }
+
+    @Test
+    fun limited_type_parameter_sealed_class() {
+        assertEquals(
+            listOf(
+                LimitedTypeParameterSealedClass.FirstObject,
+                LimitedTypeParameterSealedClass.SecondObject
+            ),
+            LimitedTypeParameterSealedClass.values
+        )
+    }
+
+    @Test
+    fun multiple_bounds_sealed_class() {
+        assertEquals(
+            listOf(
+                MultipleBoundsSealedClass.FirstObject
+            ),
+            MultipleBoundsSealedClass.values
+        )
+    }
+}

processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithAbstractBaseClassesTests.kt

@@ -0,0 +1,36 @@
+package com.livefront.sealedenum.compilation.generics
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+@OptIn(ExperimentalStdlibApi::class)
+class SealedEnumWithAbstractBaseClassesTests {
+    @Test
+    fun enum_implements_correct_interfaces_with_type_arguments() {
+        // Check for compilation
+        val emptyValues1: Array<out BaseClassInterface1<BaseClassInterface1<Any?>>> =
+            SealedEnumWithAbstractBaseClassesEnum.values()
+        val emptyValues2: Array<out BaseClassInterface2<String>> = SealedEnumWithAbstractBaseClassesEnum.values()
+
+        assertEquals(
+            emptyList<BaseClassInterface1<BaseClassInterface1<Any?>>>(),
+            emptyValues1.toList()
+        )
+
+        assertEquals(
+            emptyList<BaseClassInterface2<String>>(),
+            emptyValues2.toList()
+        )
+    }
+
+    @Test
+    fun covariant_type_enum_implements_correct_interfaces_with_type_arguments() {
+        val emptyValues: Array<out BaseClassInterface3<BaseClassInterface3<*>>> =
+            SealedEnumWithAbstractBaseClassesCovariantTypeEnum.values()
+
+        assertEquals(
+            emptyList<BaseClassInterface3<BaseClassInterface3<*>>>(),
+            emptyValues.toList()
+        )
+    }
+}

processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfaces.kt

@@ -375,9 +375,10 @@ public fun TwoObjectSealedClassWithGenericInterface.Companion.valueOf(name: Stri
 
 """.trimIndent()
 
+var hasGetBeenCalled = false
+
 sealed class SealedClassWithGetterInterface : TestGetterInterface {
     object FirstObject : SealedClassWithGetterInterface() {
-        var hasGetBeenCalled = false
 
         override fun get(): String {
             hasGetBeenCalled = true

processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfacesTests.kt

@@ -0,0 +1,91 @@
+package com.livefront.sealedenum.compilation.generics
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class SealedEnumWithInterfacesTests {
+    @Test
+    fun empty_sealed_enum_implements_interface() {
+        // Check for compilation
+        val emptyValues: List<TestInterface> = EmptySealedClassWithInterface.values
+
+        assertEquals(
+            emptyList<TestInterface>(),
+            emptyValues
+        )
+    }
+
+    @Test
+    fun empty_enum_implements_interface() {
+        // Check for compilation
+        val emptyValues: Array<out TestInterface> = EmptySealedClassWithInterfaceEnum.values()
+
+        assertEquals(
+            emptyList<TestInterface>(),
+            emptyValues.toList()
+        )
+    }
+
+    @Test
+    fun single_object_sealed_enum_implements_interface() {
+        // Check for compilation
+        val oneObjectValues: List<TestInterface> = OneObjectSealedClassWithInterface.values
+
+        assertEquals(
+            listOf(OneObjectSealedClassWithInterface.FirstObject),
+            oneObjectValues
+        )
+    }
+
+    @Test
+    fun single_object_enum_implements_interface() {
+        val oneObjectValues: Array<out TestInterface> = OneObjectSealedClassWithInterfaceEnum.values()
+
+        assertEquals(
+            listOf(OneObjectSealedClassWithInterfaceEnum.OneObjectSealedClassWithInterface_FirstObject),
+            oneObjectValues.toList()
+        )
+    }
+
+    @Test
+    fun two_object_sealed_enum_implements_generic_interface() {
+        // Check for compilation
+        val twoObjectValues: List<TestGenericInterface<TestInterface>> =
+            TwoObjectSealedClassWithGenericInterface.values
+
+        assertEquals(
+            listOf(
+                TwoObjectSealedClassWithGenericInterface.FirstObject,
+                TwoObjectSealedClassWithGenericInterface.SecondObject
+            ),
+            twoObjectValues
+        )
+    }
+
+    @Test
+    fun two_object_enum_implements_generic_interface() {
+        val twoObjectValues: Array<out TestGenericInterface<TestInterface>> =
+            TwoObjectSealedClassWithGenericInterfaceEnum.values()
+
+        assertEquals(
+            listOf(
+                TwoObjectSealedClassWithGenericInterfaceEnum.TwoObjectSealedClassWithGenericInterface_FirstObject,
+                TwoObjectSealedClassWithGenericInterfaceEnum.TwoObjectSealedClassWithGenericInterface_SecondObject
+            ),
+            twoObjectValues.toList()
+        )
+    }
+
+    @Test
+    fun enum_delegates_to_sealed_class() {
+        val enumValue = SealedClassWithGetterInterfaceEnum.SealedClassWithGetterInterface_FirstObject
+
+        assertFalse(hasGetBeenCalled)
+
+        assertEquals("First", enumValue.get())
+
+        assertTrue(hasGetBeenCalled)
+    }
+}