From 7b15e1c83bb8287a2a68c74c0bdeaa4e4f277a89 Mon Sep 17 00:00:00 2001 From: Alex Vanyo Date: Mon, 18 Oct 2021 18:27:28 -0700 Subject: [PATCH] Commonize common tests --- .../basic/EmptySealedClassTests.kt | 24 ++ .../basic/EmptySealedInterfaceTests.kt | 24 ++ .../basic/OneObjectSealedClassTests.kt | 32 ++ .../basic/OneObjectSealedInterfaceTests.kt | 32 ++ .../basic/TwoObjectSealedClassTests.kt | 38 +++ .../basic/TwoObjectSealedInterfaceTests.kt | 38 +++ .../generics/GenericSealedClassTests.kt | 50 +++ .../SealedEnumWithAbstractBaseClassesTests.kt | 36 +++ .../generics/SealedEnumWithInterfaces.kt | 3 +- .../generics/SealedEnumWithInterfacesTests.kt | 91 ++++++ .../hierarchy/SealedClassHierarchyTests.kt | 149 +++++++++ .../SealedInterfaceHierarchyTests.kt | 149 +++++++++ .../compilation/location/NestedClassTests.kt | 28 ++ .../location/OutsideSealedClassTests.kt | 122 ++++++++ .../SplitAcrossFilesSealedClassTests.kt | 26 ++ .../traversal/TraversalOrderTests.kt | 59 ++-- .../visibility/VisibilitySealedClassTests.kt | 152 +++++++++ ...kt => EmptySealedClassCompilationTests.kt} | 24 +- ...> EmptySealedInterfaceCompilationTests.kt} | 24 +- ...> OneObjectSealedClassCompilationTests.kt} | 32 +- ...eObjectSealedInterfaceCompilationTests.kt} | 32 +- .../TwoObjectSealedClassCompilationTests.kt | 30 ++ .../basic/TwoObjectSealedClassTests.kt | 60 ---- ...woObjectSealedInterfaceCompilationTests.kt | 34 ++ .../basic/TwoObjectSealedInterfaceTests.kt | 64 ---- ... => GenericSealedClassCompilationTests.kt} | 51 +-- ...WithAbstractBaseClassesCompilationTests.kt | 54 ++++ .../SealedEnumWithAbstractBaseClassesTests.kt | 127 -------- ...ealedEnumWithInterfacesCompilationTests.kt | 94 ++++++ .../generics/SealedEnumWithInterfacesTests.kt | 235 -------------- ...> SealedClassHierarchyCompilationTests.kt} | 150 +-------- ...ealedInterfaceHierarchyCompilationTests.kt | 154 +++++++++ .../SealedInterfaceHierarchyTests.kt | 296 ------------------ ...ests.kt => NestedClassCompilationTests.kt} | 29 +- .../OutsideSealedClassCompilationTests.kt | 75 +++++ .../location/OutsideSealedClassTests.kt | 193 ------------ ...AcrossFilesSealedClassCompilationTests.kt} | 24 +- .../TraversalOrderCompilationTests.kt | 30 ++ .../EnvironmentsSealedEnumCompilationTests.kt | 27 ++ .../usecases/EnvironmentsSealedEnumTests.kt | 22 -- .../VisibilitySealedClassCompilationTests.kt | 87 +++++ .../visibility/VisibilitySealedClassTests.kt | 285 ----------------- .../VisibilitySealedClassVisibilityTests.kt | 39 +++ .../processor-tests/build.gradle.kts | 1 + 44 files changed, 1665 insertions(+), 1661 deletions(-) create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClassTests.kt create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterfaceTests.kt create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedClassTests.kt create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedInterfaceTests.kt create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedClassTests.kt create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedInterfaceTests.kt create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/GenericSealedClassTests.kt create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithAbstractBaseClassesTests.kt create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfacesTests.kt create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedClassHierarchyTests.kt create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedInterfaceHierarchyTests.kt create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/location/NestedClassTests.kt create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/location/OutsideSealedClassTests.kt create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/location/SplitAcrossFilesSealedClassTests.kt rename processing-tests/common/src/{jvmTest => commonTest}/kotlin/com/livefront/sealedenum/compilation/traversal/TraversalOrderTests.kt (80%) create mode 100644 processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassTests.kt rename processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/{EmptySealedClassTests.kt => EmptySealedClassCompilationTests.kt} (61%) rename processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/{EmptySealedInterfaceTests.kt => EmptySealedInterfaceCompilationTests.kt} (60%) rename processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/{OneObjectSealedClassTests.kt => OneObjectSealedClassCompilationTests.kt} (52%) rename processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/{OneObjectSealedInterfaceTests.kt => OneObjectSealedInterfaceCompilationTests.kt} (52%) create mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedClassCompilationTests.kt delete mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedClassTests.kt create mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedInterfaceCompilationTests.kt delete mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedInterfaceTests.kt rename processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/{GenericSealedClassTests.kt => GenericSealedClassCompilationTests.kt} (68%) create mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithAbstractBaseClassesCompilationTests.kt delete mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithAbstractBaseClassesTests.kt create mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfacesCompilationTests.kt delete mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfacesTests.kt rename processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/{SealedClassHierarchyTests.kt => SealedClassHierarchyCompilationTests.kt} (50%) create mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedInterfaceHierarchyCompilationTests.kt delete mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedInterfaceHierarchyTests.kt rename processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/{NestedClassTests.kt => NestedClassCompilationTests.kt} (67%) create mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/OutsideSealedClassCompilationTests.kt delete mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/OutsideSealedClassTests.kt rename processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/{SplitAcrossFilesSealedClassTests.kt => SplitAcrossFilesSealedClassCompilationTests.kt} (73%) create mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/traversal/TraversalOrderCompilationTests.kt create mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/usecases/EnvironmentsSealedEnumCompilationTests.kt create mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassCompilationTests.kt delete mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassTests.kt create mode 100644 processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassVisibilityTests.kt diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClassTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClassTests.kt new file mode 100644 index 00000000..400fdf82 --- /dev/null +++ b/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.values) + } + + @Test + fun empty_enum_for_sealed_class() { + assertEquals( + EmptySealedClass.values.map(EmptySealedClass::enum), + enumValues().toList() + ) + } + + @Test + fun correct_enum_class() { + assertEquals(EmptySealedClassEnum::class, EmptySealedClass.sealedEnum.enumClass) + } +} diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterfaceTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterfaceTests.kt new file mode 100644 index 00000000..e4038b07 --- /dev/null +++ b/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.values) + } + + @Test + fun empty_enum_for_sealed_interface() { + assertEquals( + EmptySealedInterface.values.map(EmptySealedInterface::enum), + enumValues().toList() + ) + } + + @Test + fun correct_enum_class() { + assertEquals(EmptySealedInterfaceEnum::class, EmptySealedInterface.sealedEnum.enumClass) + } +} diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedClassTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedClassTests.kt new file mode 100644 index 00000000..6e144911 --- /dev/null +++ b/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().toList() + ) + } + + @Test + fun one_enum_for_sealed_class_with_mapping() { + assertEquals( + OneObjectSealedClass.values.map(OneObjectSealedClass::enum), + enumValues().toList() + ) + } + + @Test + fun correct_enum_class() { + assertEquals(OneObjectSealedClassEnum::class, OneObjectSealedClass.sealedEnum.enumClass) + } +} diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedInterfaceTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedInterfaceTests.kt new file mode 100644 index 00000000..ed320868 --- /dev/null +++ b/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().toList() + ) + } + + @Test + fun one_enum_for_sealed_interface_with_mapping() { + assertEquals( + OneObjectSealedInterface.values.map(OneObjectSealedInterface::enum), + enumValues().toList() + ) + } + + @Test + fun correct_enum_class() { + assertEquals(OneObjectSealedInterfaceEnum::class, OneObjectSealedInterface.sealedEnum.enumClass) + } +} diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedClassTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedClassTests.kt new file mode 100644 index 00000000..7eaae86d --- /dev/null +++ b/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().toList() + ) + } + + @Test + fun two_enums_for_sealed_class_with_mapping() { + assertEquals( + TwoObjectSealedClass.values.map(TwoObjectSealedClass::enum), + enumValues().toList() + ) + } + + @Test + fun correct_enum_class() { + assertEquals(TwoObjectSealedClassEnum::class, TwoObjectSealedClassSealedEnum.enumClass) + } +} diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedInterfaceTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedInterfaceTests.kt new file mode 100644 index 00000000..6e5ccee4 --- /dev/null +++ b/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().toList() + ) + } + + @Test + fun two_enums_for_sealed_interface_with_mapping() { + assertEquals( + TwoObjectSealedInterface.values.map(TwoObjectSealedInterface::enum), + enumValues().toList() + ) + } + + @Test + fun correct_enum_class() { + assertEquals(TwoObjectSealedInterfaceEnum::class, TwoObjectSealedInterface.sealedEnum.enumClass) + } +} diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/GenericSealedClassTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/GenericSealedClassTests.kt new file mode 100644 index 00000000..0b2e4012 --- /dev/null +++ b/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 + ) + } +} diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithAbstractBaseClassesTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithAbstractBaseClassesTests.kt new file mode 100644 index 00000000..b4f4c6cf --- /dev/null +++ b/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>> = + SealedEnumWithAbstractBaseClassesEnum.values() + val emptyValues2: Array> = SealedEnumWithAbstractBaseClassesEnum.values() + + assertEquals( + emptyList>>(), + emptyValues1.toList() + ) + + assertEquals( + emptyList>(), + emptyValues2.toList() + ) + } + + @Test + fun covariant_type_enum_implements_correct_interfaces_with_type_arguments() { + val emptyValues: Array>> = + SealedEnumWithAbstractBaseClassesCovariantTypeEnum.values() + + assertEquals( + emptyList>>(), + emptyValues.toList() + ) + } +} diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfaces.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfaces.kt index 95684acd..1589a707 100644 --- a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfaces.kt +++ b/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 diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfacesTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfacesTests.kt new file mode 100644 index 00000000..343eb743 --- /dev/null +++ b/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 = EmptySealedClassWithInterface.values + + assertEquals( + emptyList(), + emptyValues + ) + } + + @Test + fun empty_enum_implements_interface() { + // Check for compilation + val emptyValues: Array = EmptySealedClassWithInterfaceEnum.values() + + assertEquals( + emptyList(), + emptyValues.toList() + ) + } + + @Test + fun single_object_sealed_enum_implements_interface() { + // Check for compilation + val oneObjectValues: List = OneObjectSealedClassWithInterface.values + + assertEquals( + listOf(OneObjectSealedClassWithInterface.FirstObject), + oneObjectValues + ) + } + + @Test + fun single_object_enum_implements_interface() { + val oneObjectValues: Array = OneObjectSealedClassWithInterfaceEnum.values() + + assertEquals( + listOf(OneObjectSealedClassWithInterfaceEnum.OneObjectSealedClassWithInterface_FirstObject), + oneObjectValues.toList() + ) + } + + @Test + fun two_object_sealed_enum_implements_generic_interface() { + // Check for compilation + val twoObjectValues: List> = + TwoObjectSealedClassWithGenericInterface.values + + assertEquals( + listOf( + TwoObjectSealedClassWithGenericInterface.FirstObject, + TwoObjectSealedClassWithGenericInterface.SecondObject + ), + twoObjectValues + ) + } + + @Test + fun two_object_enum_implements_generic_interface() { + val twoObjectValues: Array> = + 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) + } +} diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedClassHierarchyTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedClassHierarchyTests.kt new file mode 100644 index 00000000..dbb72a84 --- /dev/null +++ b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedClassHierarchyTests.kt @@ -0,0 +1,149 @@ +package com.livefront.sealedenum.compilation.hierarchy + +import kotlin.test.Test +import kotlin.test.assertEquals + +class SealedClassHierarchyTests { + @Test + fun first_hierarchy_class_A_values() { + assertEquals(listOf(FirstClassHierarchy.A.B.C), FirstClassHierarchy.A.values) + } + + @Test + fun first_hierarchy_class_A_ordinal_of_A_B_C() { + assertEquals(0, (FirstClassHierarchy.A.B.C as FirstClassHierarchy.A).ordinal) + } + + @Test + fun first_hierarchy_class_B_values() { + assertEquals(listOf(FirstClassHierarchy.A.B.C), FirstClassHierarchy.A.B.values) + } + + @Test + fun first_hierarchy_class_B_ordinal() { + assertEquals(0, (FirstClassHierarchy.A.B.C as FirstClassHierarchy.A.B).ordinal) + } + + @Test + fun `second hierarchy class Z values`() { + assertEquals( + listOf( + SecondClassHierarchy.Z.Y, + SecondClassHierarchy.Z.X.W, + SecondClassHierarchy.Z.X.V, + SecondClassHierarchy.Z.X.U.T, + SecondClassHierarchy.Z.X.S.R, + SecondClassHierarchy.Z.Q.P, + SecondClassHierarchy.Z.O + ), + SecondClassHierarchy.Z.values + ) + } + + @Test + fun `second hierarchy class Z ordinal of Z_Y`() { + assertEquals(0, (SecondClassHierarchy.Z.Y as SecondClassHierarchy.Z).ordinal) + } + + @Test + fun `second hierarchy class Z ordinal of Z_X_W`() { + assertEquals(1, (SecondClassHierarchy.Z.X.W as SecondClassHierarchy.Z).ordinal) + } + + @Test + fun `second hierarchy class Z ordinal of Z_X_V`() { + assertEquals(2, (SecondClassHierarchy.Z.X.V as SecondClassHierarchy.Z).ordinal) + } + + @Test + fun `second hierarchy class Z ordinal of Z_X_U_T`() { + assertEquals(3, (SecondClassHierarchy.Z.X.U.T as SecondClassHierarchy.Z).ordinal) + } + + @Test + fun `second hierarchy class Z ordinal of Z_X_S_R`() { + assertEquals(4, (SecondClassHierarchy.Z.X.S.R as SecondClassHierarchy.Z).ordinal) + } + + @Test + fun `second hierarchy class Z ordinal of Z_Q_P`() { + assertEquals(5, (SecondClassHierarchy.Z.Q.P as SecondClassHierarchy.Z).ordinal) + } + + @Test + fun `second hierarchy class Z ordinal of Z_O`() { + assertEquals(6, (SecondClassHierarchy.Z.O as SecondClassHierarchy.Z).ordinal) + } + + @Test + fun `second hierarchy class X values`() { + assertEquals( + listOf( + SecondClassHierarchy.Z.X.W, + SecondClassHierarchy.Z.X.V, + SecondClassHierarchy.Z.X.U.T, + SecondClassHierarchy.Z.X.S.R + ), + SecondClassHierarchy.Z.X.values + ) + } + + @Test + fun `second hierarchy class X ordinal of Z_X_W`() { + assertEquals(0, (SecondClassHierarchy.Z.X.W as SecondClassHierarchy.Z.X).ordinal) + } + + @Test + fun `second hierarchy class X ordinal of Z_X_V`() { + assertEquals(1, (SecondClassHierarchy.Z.X.V as SecondClassHierarchy.Z.X).ordinal) + } + + @Test + fun `second hierarchy class X ordinal of Z_X_U_T`() { + assertEquals(2, (SecondClassHierarchy.Z.X.U.T as SecondClassHierarchy.Z.X).ordinal) + } + + @Test + fun `second hierarchy class X ordinal of Z_X_S_R`() { + assertEquals(3, (SecondClassHierarchy.Z.X.S.R as SecondClassHierarchy.Z.X).ordinal) + } + + @Test + fun `second hierarchy class U values`() { + assertEquals( + listOf(SecondClassHierarchy.Z.X.U.T), + SecondClassHierarchy.Z.X.U.values + ) + } + + @Test + fun `second hierarchy class U ordinal of Z_X_U_T`() { + assertEquals(0, (SecondClassHierarchy.Z.X.U.T as SecondClassHierarchy.Z.X.U).ordinal) + } + + @Test + fun `second hierarchy class S values`() { + assertEquals( + listOf(SecondClassHierarchy.Z.X.S.R), + SecondClassHierarchy.Z.X.S.values + ) + } + + @Test + fun `second hierarchy class S ordinal of Z_X_S_R`() { + assertEquals(0, (SecondClassHierarchy.Z.X.S.R as SecondClassHierarchy.Z.X.S).ordinal) + } + + @Test + fun `second hierarchy class Q values`() { + assertEquals( + listOf(SecondClassHierarchy.Z.Q.P), + SecondClassHierarchy.Z.Q.values + ) + } + + @Test + fun `second hierarchy class Q ordinal of Z_Q_P`() { + assertEquals(0, (SecondClassHierarchy.Z.Q.P as SecondClassHierarchy.Z.Q).ordinal) + } +} diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedInterfaceHierarchyTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedInterfaceHierarchyTests.kt new file mode 100644 index 00000000..51a93278 --- /dev/null +++ b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedInterfaceHierarchyTests.kt @@ -0,0 +1,149 @@ +package com.livefront.sealedenum.compilation.hierarchy + +import kotlin.test.Test +import kotlin.test.assertEquals + +class SealedInterfaceHierarchyTests { + @Test + fun first_hierarchy_class_A_values() { + assertEquals(listOf(FirstInterfaceHierarchy.A.B.C), FirstInterfaceHierarchy.A.values) + } + + @Test + fun first_hierarchy_class_A_ordinal_of_A_B_C() { + assertEquals(0, (FirstInterfaceHierarchy.A.B.C as FirstInterfaceHierarchy.A).ordinal) + } + + @Test + fun first_hierarchy_class_B_values() { + assertEquals(listOf(FirstInterfaceHierarchy.A.B.C), FirstInterfaceHierarchy.A.B.values) + } + + @Test + fun first_hierarchy_class_B_ordinal() { + assertEquals(0, (FirstInterfaceHierarchy.A.B.C as FirstInterfaceHierarchy.A.B).ordinal) + } + + @Test + fun second_hierarchy_class_A_values() { + assertEquals( + listOf( + SecondInterfaceHierarchy.A.B, + SecondInterfaceHierarchy.A.C.D, + SecondInterfaceHierarchy.A.C.E, + SecondInterfaceHierarchy.A.C.F.G, + SecondInterfaceHierarchy.A.C.H.I, + SecondInterfaceHierarchy.A.J.K, + SecondInterfaceHierarchy.A.L + ), + SecondInterfaceHierarchy.A.values + ) + } + + @Test + fun second_hierarchy_class_A_ordinal_of_A_B() { + assertEquals(0, (SecondInterfaceHierarchy.A.B as SecondInterfaceHierarchy.A).ordinal) + } + + @Test + fun second_hierarchy_class_A_ordinal_of_A_C_D() { + assertEquals(1, (SecondInterfaceHierarchy.A.C.D as SecondInterfaceHierarchy.A).ordinal) + } + + @Test + fun second_hierarchy_class_A_ordinal_of_A_C_E() { + assertEquals(2, (SecondInterfaceHierarchy.A.C.E as SecondInterfaceHierarchy.A).ordinal) + } + + @Test + fun second_hierarchy_class_A_ordinal_of_A_C_F_G() { + assertEquals(3, (SecondInterfaceHierarchy.A.C.F.G as SecondInterfaceHierarchy.A).ordinal) + } + + @Test + fun second_hierarchy_class_A_ordinal_of_A_C_H_I() { + assertEquals(4, (SecondInterfaceHierarchy.A.C.H.I as SecondInterfaceHierarchy.A).ordinal) + } + + @Test + fun second_hierarchy_class_A_ordinal_of_A_J_K() { + assertEquals(5, (SecondInterfaceHierarchy.A.J.K as SecondInterfaceHierarchy.A).ordinal) + } + + @Test + fun second_hierarchy_class_A_ordinal_of_A_L() { + assertEquals(6, (SecondInterfaceHierarchy.A.L as SecondInterfaceHierarchy.A).ordinal) + } + + @Test + fun second_hierarchy_class_C_values() { + assertEquals( + listOf( + SecondInterfaceHierarchy.A.C.D, + SecondInterfaceHierarchy.A.C.E, + SecondInterfaceHierarchy.A.C.F.G, + SecondInterfaceHierarchy.A.C.H.I + ), + SecondInterfaceHierarchy.A.C.values + ) + } + + @Test + fun second_hierarchy_class_C_ordinal_of_A_C_D() { + assertEquals(0, (SecondInterfaceHierarchy.A.C.D as SecondInterfaceHierarchy.A.C).ordinal) + } + + @Test + fun second_hierarchy_class_C_ordinal_of_A_C_E() { + assertEquals(1, (SecondInterfaceHierarchy.A.C.E as SecondInterfaceHierarchy.A.C).ordinal) + } + + @Test + fun second_hierarchy_class_C_ordinal_of_A_C_F_G() { + assertEquals(2, (SecondInterfaceHierarchy.A.C.F.G as SecondInterfaceHierarchy.A.C).ordinal) + } + + @Test + fun second_hierarchy_class_C_ordinal_of_A_C_H_I() { + assertEquals(3, (SecondInterfaceHierarchy.A.C.H.I as SecondInterfaceHierarchy.A.C).ordinal) + } + + @Test + fun second_hierarchy_class_F_values() { + assertEquals( + listOf(SecondInterfaceHierarchy.A.C.F.G), + SecondInterfaceHierarchy.A.C.F.values + ) + } + + @Test + fun second_hierarchy_class_F_ordinal_of_A_L() { + assertEquals(0, (SecondInterfaceHierarchy.A.C.F.G as SecondInterfaceHierarchy.A.C.F).ordinal) + } + + @Test + fun second_hierarchy_class_H_values() { + assertEquals( + listOf(SecondInterfaceHierarchy.A.C.H.I), + SecondInterfaceHierarchy.A.C.H.values + ) + } + + @Test + fun second_hierarchy_class_H_ordinal_of_A_C_H_I() { + assertEquals(0, (SecondInterfaceHierarchy.A.C.H.I as SecondInterfaceHierarchy.A.C.H).ordinal) + } + + @Test + fun second_hierarchy_class_J_values() { + assertEquals( + listOf(SecondInterfaceHierarchy.A.J.K), + SecondInterfaceHierarchy.A.J.values + ) + } + + @Test + fun second_hierarchy_class_J_ordinal_of_A_J_K() { + assertEquals(0, (SecondInterfaceHierarchy.A.J.K as SecondInterfaceHierarchy.A.J).ordinal) + } +} diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/location/NestedClassTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/location/NestedClassTests.kt new file mode 100644 index 00000000..b89c89fc --- /dev/null +++ b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/location/NestedClassTests.kt @@ -0,0 +1,28 @@ +package com.livefront.sealedenum.compilation.location + +import kotlin.test.Test +import kotlin.test.assertEquals + +class NestedClassTests { + @Test + fun inside_one_class() { + assertEquals( + listOf( + OuterClass.InsideOneClassSealedClass.FirstObject, + OuterClass.InsideOneClassSealedClass.SecondObject + ), + OuterClass.InsideOneClassSealedClass.values + ) + } + + @Test + fun inside_two_classes() { + assertEquals( + listOf( + FirstOuterClass.SecondOuterClass.InsideTwoClassesSealedClass.FirstObject, + FirstOuterClass.SecondOuterClass.InsideTwoClassesSealedClass.SecondObject + ), + FirstOuterClass.SecondOuterClass.InsideTwoClassesSealedClass.values + ) + } +} diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/location/OutsideSealedClassTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/location/OutsideSealedClassTests.kt new file mode 100644 index 00000000..594a4746 --- /dev/null +++ b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/location/OutsideSealedClassTests.kt @@ -0,0 +1,122 @@ +package com.livefront.sealedenum.compilation.location + +import kotlin.test.Test +import kotlin.test.assertEquals + +class OutsideSealedClassTests { + @Test + fun one_object_outside_sealed_class() { + assertEquals(listOf(AlphaFirstObject), AlphaOutsideSealedClass.values) + } + + @Test + fun one_enum_outside_sealed_class() { + assertEquals( + listOf(AlphaOutsideSealedClassEnum.AlphaFirstObject), + enumValues().toList() + ) + } + + @Test + fun one_enum_outside_sealed_class_with_mapping() { + assertEquals( + AlphaOutsideSealedClass.values.map(AlphaOutsideSealedClass::enum), + enumValues().toList() + ) + } + + @Test + fun two_objects_outside_sealed_class() { + assertEquals( + listOf( + BetaFirstObject, + BetaFourthObject, + BetaSecondObject, + BetaThirdObject, + ), + BetaOutsideSealedClass.values + ) + } + + @Test + fun two_enums_outside_sealed_class() { + assertEquals( + listOf( + BetaOutsideSealedClassEnum.BetaFirstObject, + BetaOutsideSealedClassEnum.BetaFourthObject, + BetaOutsideSealedClassEnum.BetaSecondObject, + BetaOutsideSealedClassEnum.BetaThirdObject, + ), + enumValues().toList() + ) + } + + @Test + fun two_enums_outside_sealed_class_with_mapping() { + assertEquals( + BetaOutsideSealedClass.values.map(BetaOutsideSealedClass::enum), + enumValues().toList() + ) + } + + @Test + fun outside_object_ordering() { + assertEquals( + listOf( + GammaOutsideSealedClass.GammaSecondObject, + GammaFirstObject, + GammaFourthObject, + GammaThirdObject, + ), + GammaOutsideSealedClass.values + ) + } + + @Test + fun outside_enum_ordering() { + assertEquals( + listOf( + GammaOutsideSealedClassEnum.GammaOutsideSealedClass_GammaSecondObject, + GammaOutsideSealedClassEnum.GammaFirstObject, + GammaOutsideSealedClassEnum.GammaFourthObject, + GammaOutsideSealedClassEnum.GammaThirdObject, + ), + enumValues().toList() + ) + } + + @Test + fun outside_enum_ordering_with_mapping() { + assertEquals( + GammaOutsideSealedClass.values.map(GammaOutsideSealedClass::enum), + enumValues().toList() + ) + } + + @Test + fun duplicate_name_objects() { + assertEquals( + listOf(DeltaOutsideSealedClass.DeltaObject, DeltaObject), + DeltaOutsideSealedClass.values + ) + } + + @Test + fun duplicate_name_enums() { + assertEquals( + listOf( + DeltaOutsideSealedClassEnum.DeltaOutsideSealedClass_DeltaObject, + DeltaOutsideSealedClassEnum.DeltaObject, + ), + enumValues().toList() + ) + } + + @Test + fun duplicate_name_enums_with_mapping() { + assertEquals( + DeltaOutsideSealedClass.values.map(DeltaOutsideSealedClass::enum), + enumValues().toList() + ) + } +} diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/location/SplitAcrossFilesSealedClassTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/location/SplitAcrossFilesSealedClassTests.kt new file mode 100644 index 00000000..e0c4c861 --- /dev/null +++ b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/location/SplitAcrossFilesSealedClassTests.kt @@ -0,0 +1,26 @@ +package com.livefront.sealedenum.compilation.location + +import kotlin.test.Test +import kotlin.test.assertEquals + +class SplitAcrossFilesSealedClassTests { + @Test + fun object_split_across_files() { + assertEquals( + listOf( + SplitAcrossFilesSubclassA, + SplitAcrossFilesSubclassB, + SplitAcrossFilesSubclassC + ), + SplitAcrossFilesSealedClass.values + ) + } + + @Test + fun enum_for_objects_split_across_files() { + assertEquals( + SplitAcrossFilesSealedClass.values.map(SplitAcrossFilesSealedClass::enum), + enumValues().toList() + ) + } +} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/traversal/TraversalOrderTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/traversal/TraversalOrderTests.kt similarity index 80% rename from processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/traversal/TraversalOrderTests.kt rename to processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/traversal/TraversalOrderTests.kt index a1c48da7..cc3f9c61 100644 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/traversal/TraversalOrderTests.kt +++ b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/traversal/TraversalOrderTests.kt @@ -1,18 +1,11 @@ package com.livefront.sealedenum.compilation.traversal -import com.livefront.sealedenum.testing.PlatformSourceType -import com.livefront.sealedenum.testing.SharableProcessingSourceType -import com.livefront.sealedenum.testing.assertCompiles -import com.livefront.sealedenum.testing.assertGeneratedFileMatches -import com.livefront.sealedenum.testing.compile -import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Test +import kotlin.test.Test +import kotlin.test.assertEquals class TraversalOrderTests { - @Test - fun `pre order objects`() { + fun pre_order_objects() { assertEquals( listOf( Tree.A, @@ -35,7 +28,7 @@ class TraversalOrderTests { } @Test - fun `pre order objects in sealed enum`() { + fun pre_order_objects_in_sealed_enum() { assertEquals( Tree.preOrderValues, TreePreOrderSealedEnum.values @@ -43,7 +36,7 @@ class TraversalOrderTests { } @Test - fun `pre order enum`() { + fun pre_order_enum() { assertEquals( listOf( TreePreOrderEnum.Tree_A, @@ -66,7 +59,7 @@ class TraversalOrderTests { } @Test - fun `pre order enum mapping`() { + fun pre_order_enum_mapping() { assertEquals( Tree.preOrderValues.map(Tree::preOrderEnum), enumValues().toList() @@ -74,7 +67,7 @@ class TraversalOrderTests { } @Test - fun `in order objects`() { + fun in_order_objects() { assertEquals( listOf( Tree.A, @@ -97,7 +90,7 @@ class TraversalOrderTests { } @Test - fun `in order objects in sealed enum`() { + fun in_order_objects_in_sealed_enum() { assertEquals( Tree.inOrderValues, TreeInOrderSealedEnum.values @@ -105,7 +98,7 @@ class TraversalOrderTests { } @Test - fun `in order enum`() { + fun in_order_enum() { assertEquals( listOf( TreeInOrderEnum.Tree_A, @@ -128,7 +121,7 @@ class TraversalOrderTests { } @Test - fun `in order enum mapping`() { + fun in_order_enum_mapping() { assertEquals( Tree.inOrderValues.map(Tree::inOrderEnum), enumValues().toList() @@ -136,7 +129,7 @@ class TraversalOrderTests { } @Test - fun `post order objects`() { + fun post_order_objects() { assertEquals( listOf( Tree.B.C.F.G, @@ -159,7 +152,7 @@ class TraversalOrderTests { } @Test - fun `post order objects in sealed enum`() { + fun post_order_objects_in_sealed_enum() { assertEquals( Tree.postOrderValues, TreePostOrderSealedEnum.values @@ -167,7 +160,7 @@ class TraversalOrderTests { } @Test - fun `post order enum`() { + fun post_order_enum() { assertEquals( listOf( TreePostOrderEnum.Tree_B_C_F_G, @@ -190,7 +183,7 @@ class TraversalOrderTests { } @Test - fun `post order enum mapping`() { + fun post_order_enum_mapping() { assertEquals( Tree.postOrderValues.map(Tree::postOrderEnum), enumValues().toList() @@ -198,7 +191,7 @@ class TraversalOrderTests { } @Test - fun `level order objects`() { + fun level_order_objects() { assertEquals( listOf( Tree.A, @@ -221,7 +214,7 @@ class TraversalOrderTests { } @Test - fun `level order objects in sealed enum`() { + fun level_order_objects_in_sealed_enum() { assertEquals( Tree.levelOrderValues, TreeLevelOrderSealedEnum.values @@ -229,7 +222,7 @@ class TraversalOrderTests { } @Test - fun `level order enum`() { + fun level_order_enum() { assertEquals( listOf( TreeLevelOrderEnum.Tree_A, @@ -252,26 +245,10 @@ class TraversalOrderTests { } @Test - fun `level order enum with mapping`() { + fun level_order_enum_with_mapping() { assertEquals( Tree.levelOrderValues.map(Tree::levelOrderEnum), enumValues().toList() ) } - - @Test - fun `compilation generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "traversal", - "TraversalOrder.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches("Tree_SealedEnum.kt", treeGenerated, result) - } } diff --git a/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassTests.kt b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassTests.kt new file mode 100644 index 00000000..f976835f --- /dev/null +++ b/processing-tests/common/src/commonTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassTests.kt @@ -0,0 +1,152 @@ +package com.livefront.sealedenum.compilation.visibility + +import com.livefront.sealedenum.SealedEnum +import kotlin.test.Test +import kotlin.test.assertEquals + +/** + * Verifies that generated [SealedEnum] implementations, extension properties and methods have valid visibilities. + */ +class VisibilitySealedClassTests { + @Test + fun internal_objects_values_are_correct() { + assertEquals( + listOf( + InternalObjectsSealedClass.FirstObject, + InternalObjectsSealedClass.SecondObject, + InternalObjectsSealedClass.InnerSealedClass.ThirdObject + ), + InternalObjectsSealedClass.values + ) + } + + @Test + fun internal_objects_enums_values_are_correct() { + assertEquals( + listOf( + InternalObjectsSealedClassEnum.InternalObjectsSealedClass_FirstObject, + InternalObjectsSealedClassEnum.InternalObjectsSealedClass_SecondObject, + InternalObjectsSealedClassEnum.InternalObjectsSealedClass_InnerSealedClass_ThirdObject + ), + enumValues().toList() + ) + } + + @Test + fun internal_objects_enums_values_are_correct_with_mapping() { + assertEquals( + InternalObjectsSealedClass.values.map(InternalObjectsSealedClass::enum), + enumValues().toList() + ) + } + + @Test + fun internal_objects_correct_enum_class() { + assertEquals(InternalObjectsSealedClassEnum::class, InternalObjectsSealedClass.sealedEnum.enumClass) + } + + @Test + fun internal_sealed_class_values_are_correct() { + assertEquals( + listOf(InternalSealedClass.FirstObject, InternalSealedClass.SecondObject), + InternalSealedClass.values + ) + } + + @Test + fun internal_seald_class_enums_values_are_correct() { + assertEquals( + listOf( + InternalSealedClassEnum.InternalSealedClass_FirstObject, + InternalSealedClassEnum.InternalSealedClass_SecondObject + ), + enumValues().toList() + ) + } + + @Test + fun internal_sealed_class_enums_values_are_correct_with_mapping() { + assertEquals( + InternalSealedClass.values.map(InternalSealedClass::enum), + enumValues().toList() + ) + } + + @Test + fun internal_sealed_class_correct_enum_class() { + assertEquals(InternalSealedClassEnum::class, InternalSealedClass.sealedEnum.enumClass) + } + + @Test + fun internal_companion_object_internal_values_are_correct() { + assertEquals( + listOf(InternalCompanionSealedClass.FirstObject, InternalCompanionSealedClass.SecondObject), + InternalCompanionSealedClass.values + ) + } + + @Test + fun internal_companion_object_enums_values_are_correct() { + assertEquals( + listOf( + InternalCompanionSealedClassEnum.InternalCompanionSealedClass_FirstObject, + InternalCompanionSealedClassEnum.InternalCompanionSealedClass_SecondObject + ), + enumValues().toList() + ) + } + + @Test + fun internal_companion_object_enums_values_are_correct_with_mapping() { + assertEquals( + InternalCompanionSealedClass.values.map(InternalCompanionSealedClass::enum), + enumValues().toList() + ) + } + + @Test + fun internal_companion_object_correct_enum_class() { + assertEquals( + InternalCompanionSealedClassEnum::class, + InternalCompanionSealedClass.sealedEnum.enumClass + ) + } + + @Test + fun internal_sealed_class_and_companion_object_values_are_correct() { + assertEquals( + listOf( + InternalSealedAndCompanionSealedClass.FirstObject, + InternalSealedAndCompanionSealedClass.SecondObject + ), + InternalSealedAndCompanionSealedClass.values + ) + } + + @Test + fun internal_sealed_class_and_companion_object_enums_values_are_correct() { + assertEquals( + listOf( + InternalSealedAndCompanionSealedClassEnum.InternalSealedAndCompanionSealedClass_FirstObject, + InternalSealedAndCompanionSealedClassEnum.InternalSealedAndCompanionSealedClass_SecondObject + ), + enumValues().toList() + ) + } + + @Test + fun internal_sealed_class_and_companion_object_enums_values_are_correct_with_mapping() { + assertEquals( + InternalSealedAndCompanionSealedClass.values.map(InternalSealedAndCompanionSealedClass::enum), + enumValues().toList() + ) + } + + @Test + fun internal_sealed_class_and_companion_object_correct_enum_class() { + assertEquals( + InternalSealedAndCompanionSealedClassEnum::class, + InternalSealedAndCompanionSealedClass.sealedEnum.enumClass + ) + } +} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClassTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClassCompilationTests.kt similarity index 61% rename from processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClassTests.kt rename to processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClassCompilationTests.kt index 519eda91..5ee1ac60 100644 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClassTests.kt +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClassCompilationTests.kt @@ -6,28 +6,12 @@ import com.livefront.sealedenum.testing.assertCompiles import com.livefront.sealedenum.testing.assertGeneratedFileMatches import com.livefront.sealedenum.testing.compile import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Test -class EmptySealedClassTests { - @Test - fun `empty sealed class`() { - assertEquals(emptyList(), EmptySealedClass.values) - } - - @Test - fun `empty enum for sealed class`() { - assertEquals( - EmptySealedClass.values.map(EmptySealedClass::enum), - enumValues().toList() - ) - } - - @Test - fun `correct enum class`() { - assertEquals(EmptySealedClassEnum::class, EmptySealedClass.sealedEnum.enumClass) - } - +/** + * @see EmptySealedClassTests + */ +class EmptySealedClassCompilationTests { @Test fun `compilation generates correct code`() { val result = compile( diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterfaceTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterfaceCompilationTests.kt similarity index 60% rename from processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterfaceTests.kt rename to processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterfaceCompilationTests.kt index b7f02623..4f8d33c1 100644 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterfaceTests.kt +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterfaceCompilationTests.kt @@ -6,28 +6,12 @@ import com.livefront.sealedenum.testing.assertCompiles import com.livefront.sealedenum.testing.assertGeneratedFileMatches import com.livefront.sealedenum.testing.compile import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Test -class EmptySealedInterfaceTests { - @Test - fun `empty sealed interface`() { - assertEquals(emptyList(), EmptySealedInterface.values) - } - - @Test - fun `empty enum for sealed interface`() { - assertEquals( - EmptySealedInterface.values.map(EmptySealedInterface::enum), - enumValues().toList() - ) - } - - @Test - fun `correct enum class`() { - assertEquals(EmptySealedInterfaceEnum::class, EmptySealedInterface.sealedEnum.enumClass) - } - +/** + * @see EmptySealedInterfaceTests + */ +class EmptySealedInterfaceCompilationTests { @Test fun `compilation generates correct code`() { val result = compile( diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedClassTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedClassCompilationTests.kt similarity index 52% rename from processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedClassTests.kt rename to processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedClassCompilationTests.kt index 354532c1..924a5d78 100644 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedClassTests.kt +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedClassCompilationTests.kt @@ -6,36 +6,12 @@ import com.livefront.sealedenum.testing.assertCompiles import com.livefront.sealedenum.testing.assertGeneratedFileMatches import com.livefront.sealedenum.testing.compile import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Test -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().toList() - ) - } - - @Test - fun `one enum for sealed class with mapping`() { - assertEquals( - OneObjectSealedClass.values.map(OneObjectSealedClass::enum), - enumValues().toList() - ) - } - - @Test - fun `correct enum class`() { - assertEquals(OneObjectSealedClassEnum::class, OneObjectSealedClass.sealedEnum.enumClass) - } - +/** + * @see OneObjectSealedClassTests + */ +class OneObjectSealedClassCompilationTests { @Test fun `compilation generates correct code`() { val result = compile( diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedInterfaceTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedInterfaceCompilationTests.kt similarity index 52% rename from processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedInterfaceTests.kt rename to processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedInterfaceCompilationTests.kt index 647b71bc..daee3c9f 100644 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedInterfaceTests.kt +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/OneObjectSealedInterfaceCompilationTests.kt @@ -6,36 +6,12 @@ import com.livefront.sealedenum.testing.assertCompiles import com.livefront.sealedenum.testing.assertGeneratedFileMatches import com.livefront.sealedenum.testing.compile import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Test -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().toList() - ) - } - - @Test - fun `one enum for sealed interface with mapping`() { - assertEquals( - OneObjectSealedInterface.values.map(OneObjectSealedInterface::enum), - enumValues().toList() - ) - } - - @Test - fun `correct enum class`() { - assertEquals(OneObjectSealedInterfaceEnum::class, OneObjectSealedInterface.sealedEnum.enumClass) - } - +/** + * @see OneObjectSealedInterfaceTests + */ +class OneObjectSealedInterfaceCompilationTests { @Test fun `compilation generates correct code`() { val result = compile( diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedClassCompilationTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedClassCompilationTests.kt new file mode 100644 index 00000000..dc09aac1 --- /dev/null +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedClassCompilationTests.kt @@ -0,0 +1,30 @@ +package com.livefront.sealedenum.compilation.basic + +import com.livefront.sealedenum.testing.PlatformSourceType +import com.livefront.sealedenum.testing.SharableProcessingSourceType +import com.livefront.sealedenum.testing.assertCompiles +import com.livefront.sealedenum.testing.assertGeneratedFileMatches +import com.livefront.sealedenum.testing.compile +import com.livefront.sealedenum.testing.getSourceFile +import org.junit.jupiter.api.Test + +/** + * @see TwoObjectSealedClassTests + */ +class TwoObjectSealedClassCompilationTests { + @Test + fun `compilation generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "basic", + "TwoObjectSealedClass.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches("TwoObjectSealedClass_SealedEnum.kt", twoObjectSealedClassGenerated, result) + } +} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedClassTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedClassTests.kt deleted file mode 100644 index 8901f4da..00000000 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedClassTests.kt +++ /dev/null @@ -1,60 +0,0 @@ -package com.livefront.sealedenum.compilation.basic - -import com.livefront.sealedenum.testing.PlatformSourceType -import com.livefront.sealedenum.testing.SharableProcessingSourceType -import com.livefront.sealedenum.testing.assertCompiles -import com.livefront.sealedenum.testing.assertGeneratedFileMatches -import com.livefront.sealedenum.testing.compile -import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Test - -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().toList() - ) - } - - @Test - fun `two enums for sealed class with mapping`() { - assertEquals( - TwoObjectSealedClass.values.map(TwoObjectSealedClass::enum), - enumValues().toList() - ) - } - - @Test - fun `correct enum class`() { - assertEquals(TwoObjectSealedClassEnum::class, TwoObjectSealedClassSealedEnum.enumClass) - } - - @Test - fun `compilation generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "basic", - "TwoObjectSealedClass.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches("TwoObjectSealedClass_SealedEnum.kt", twoObjectSealedClassGenerated, result) - } -} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedInterfaceCompilationTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedInterfaceCompilationTests.kt new file mode 100644 index 00000000..7ee34838 --- /dev/null +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedInterfaceCompilationTests.kt @@ -0,0 +1,34 @@ +package com.livefront.sealedenum.compilation.basic + +import com.livefront.sealedenum.testing.PlatformSourceType +import com.livefront.sealedenum.testing.SharableProcessingSourceType +import com.livefront.sealedenum.testing.assertCompiles +import com.livefront.sealedenum.testing.assertGeneratedFileMatches +import com.livefront.sealedenum.testing.compile +import com.livefront.sealedenum.testing.getSourceFile +import org.junit.jupiter.api.Test + +/** + * @see TwoObjectSealedInterfaceTests + */ +class TwoObjectSealedInterfaceCompilationTests { + @Test + fun `compilation generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "basic", + "TwoObjectSealedInterface.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "TwoObjectSealedInterface_SealedEnum.kt", + twoObjectSealedInterfaceGenerated, + result + ) + } +} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedInterfaceTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedInterfaceTests.kt deleted file mode 100644 index fb9079db..00000000 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/TwoObjectSealedInterfaceTests.kt +++ /dev/null @@ -1,64 +0,0 @@ -package com.livefront.sealedenum.compilation.basic - -import com.livefront.sealedenum.testing.PlatformSourceType -import com.livefront.sealedenum.testing.SharableProcessingSourceType -import com.livefront.sealedenum.testing.assertCompiles -import com.livefront.sealedenum.testing.assertGeneratedFileMatches -import com.livefront.sealedenum.testing.compile -import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Test - -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().toList() - ) - } - - @Test - fun `two enums for sealed interface with mapping`() { - assertEquals( - TwoObjectSealedInterface.values.map(TwoObjectSealedInterface::enum), - enumValues().toList() - ) - } - - @Test - fun `correct enum class`() { - assertEquals(TwoObjectSealedInterfaceEnum::class, TwoObjectSealedInterface.sealedEnum.enumClass) - } - - @Test - fun `compilation generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "basic", - "TwoObjectSealedInterface.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "TwoObjectSealedInterface_SealedEnum.kt", - twoObjectSealedInterfaceGenerated, - result - ) - } -} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/GenericSealedClassTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/GenericSealedClassCompilationTests.kt similarity index 68% rename from processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/GenericSealedClassTests.kt rename to processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/GenericSealedClassCompilationTests.kt index d5773fb7..d35b0b65 100644 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/GenericSealedClassTests.kt +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/GenericSealedClassCompilationTests.kt @@ -6,23 +6,12 @@ import com.livefront.sealedenum.testing.assertCompiles import com.livefront.sealedenum.testing.assertGeneratedFileMatches import com.livefront.sealedenum.testing.compile import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Test -class GenericSealedClassTests { - - @Test - fun `one type parameter sealed class`() { - assertEquals( - listOf( - OneTypeParameterSealedClass.FirstObject, - OneTypeParameterSealedClass.SecondObject, - OneTypeParameterSealedClass.ThirdObject - ), - OneTypeParameterSealedClass.values - ) - } - +/** + * @see GenericSealedClassTests + */ +class GenericSealedClassCompilationTests { @Test fun `compilation for one type parameter generates correct code`() { val result = compile( @@ -43,17 +32,6 @@ class GenericSealedClassTests { ) } - @Test - fun `two type parameter sealed class`() { - assertEquals( - listOf( - TwoTypeParameterSealedClass.FirstObject, - TwoTypeParameterSealedClass.SecondObject - ), - TwoTypeParameterSealedClass.values - ) - } - @Test fun `compilation for two type parameter generates correct code`() { val result = compile( @@ -74,17 +52,6 @@ class GenericSealedClassTests { ) } - @Test - fun `limited type parameter sealed class`() { - assertEquals( - listOf( - LimitedTypeParameterSealedClass.FirstObject, - LimitedTypeParameterSealedClass.SecondObject - ), - LimitedTypeParameterSealedClass.values - ) - } - @Test fun `compilation for limited type parameter generates correct code`() { val result = compile( @@ -105,16 +72,6 @@ class GenericSealedClassTests { ) } - @Test - fun `multiple bounds sealed class`() { - assertEquals( - listOf( - MultipleBoundsSealedClass.FirstObject - ), - MultipleBoundsSealedClass.values - ) - } - @Test fun `compilation for multiple bounds sealed class generates correct code`() { val result = compile( diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithAbstractBaseClassesCompilationTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithAbstractBaseClassesCompilationTests.kt new file mode 100644 index 00000000..13c27d56 --- /dev/null +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithAbstractBaseClassesCompilationTests.kt @@ -0,0 +1,54 @@ +package com.livefront.sealedenum.compilation.generics + +import com.livefront.sealedenum.testing.PlatformSourceType +import com.livefront.sealedenum.testing.SharableProcessingSourceType +import com.livefront.sealedenum.testing.assertCompiles +import com.livefront.sealedenum.testing.assertGeneratedFileMatches +import com.livefront.sealedenum.testing.compile +import com.livefront.sealedenum.testing.getSourceFile +import org.junit.jupiter.api.Test + +/** + * @see SealedEnumWithAbstractBaseClassesTests + */ +class SealedEnumWithAbstractBaseClassesCompilationTests { + @Test + fun `compilation for invariant type generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "generics", + "SealedEnumWithAbstractBaseClasses.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "SealedEnumWithAbstractBaseClasses_SealedEnum.kt", + sealedEnumWithAbstractBaseClassesGenerated, + result + ) + } + + @Test + fun `compilation for covariant type generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "generics", + "SealedEnumWithAbstractBaseClasses.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "SealedEnumWithAbstractBaseClassesCovariantType_SealedEnum.kt", + sealedEnumWithAbstractBaseClassesCovariantTypeGenerated, + result + ) + } +} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithAbstractBaseClassesTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithAbstractBaseClassesTests.kt deleted file mode 100644 index dc2e03bf..00000000 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithAbstractBaseClassesTests.kt +++ /dev/null @@ -1,127 +0,0 @@ -package com.livefront.sealedenum.compilation.generics - -import com.livefront.sealedenum.testing.PlatformSourceType -import com.livefront.sealedenum.testing.SharableProcessingSourceType -import com.livefront.sealedenum.testing.assertCompiles -import com.livefront.sealedenum.testing.assertGeneratedFileMatches -import com.livefront.sealedenum.testing.compile -import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertTrue -import org.junit.jupiter.api.Test -import kotlin.reflect.KTypeProjection -import kotlin.reflect.full.createType -import kotlin.reflect.full.isSubtypeOf - -class SealedEnumWithAbstractBaseClassesTests { - @Test - fun `enum implements correct interfaces with type arguments`() { - assertTrue( - SealedEnumWithAbstractBaseClassesEnum::class.createType().isSubtypeOf( - BaseClassInterface1::class.createType( - arguments = listOf( - KTypeProjection.invariant( - BaseClassInterface1::class.createType( - arguments = listOf( - KTypeProjection.invariant(Any::class.createType(nullable = true)) - ) - ) - ) - ) - ) - ) - ) - - assertTrue( - SealedEnumWithAbstractBaseClassesEnum::class.createType().isSubtypeOf( - BaseClassInterface2::class.createType( - arguments = listOf( - KTypeProjection.invariant(String::class.createType()) - ) - ) - ) - ) - - // Check for compilation - val emptyValues1: Array>> = - SealedEnumWithAbstractBaseClassesEnum.values() - val emptyValues2: Array> = SealedEnumWithAbstractBaseClassesEnum.values() - - assertEquals( - emptyList>(), - emptyValues1.toList() - ) - - assertEquals( - emptyList>(), - emptyValues2.toList() - ) - } - - @Test - fun `compilation for invariant type generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "generics", - "SealedEnumWithAbstractBaseClasses.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "SealedEnumWithAbstractBaseClasses_SealedEnum.kt", - sealedEnumWithAbstractBaseClassesGenerated, - result - ) - } - - @Test - fun `covariant type enum implements correct interfaces with type arguments`() { - assertTrue( - SealedEnumWithAbstractBaseClassesCovariantTypeEnum::class.createType().isSubtypeOf( - BaseClassInterface3::class.createType( - arguments = listOf( - KTypeProjection.covariant( - BaseClassInterface3::class.createType( - arguments = listOf( - KTypeProjection.covariant(Any::class.createType(nullable = true)) - ) - ) - ) - ) - ) - ) - ) - - val emptyValues: Array>> = - SealedEnumWithAbstractBaseClassesCovariantTypeEnum.values() - - assertEquals( - emptyList>>(), - emptyValues.toList() - ) - } - - @Test - fun `compilation for covariant type generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "generics", - "SealedEnumWithAbstractBaseClasses.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "SealedEnumWithAbstractBaseClassesCovariantType_SealedEnum.kt", - sealedEnumWithAbstractBaseClassesCovariantTypeGenerated, - result - ) - } -} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfacesCompilationTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfacesCompilationTests.kt new file mode 100644 index 00000000..5cb42b87 --- /dev/null +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfacesCompilationTests.kt @@ -0,0 +1,94 @@ +package com.livefront.sealedenum.compilation.generics + +import com.livefront.sealedenum.testing.PlatformSourceType +import com.livefront.sealedenum.testing.SharableProcessingSourceType +import com.livefront.sealedenum.testing.assertCompiles +import com.livefront.sealedenum.testing.assertGeneratedFileMatches +import com.livefront.sealedenum.testing.compile +import com.livefront.sealedenum.testing.getSourceFile +import org.junit.jupiter.api.Test + +/** + * @see SealedEnumWithInterfacesTests + */ +class SealedEnumWithInterfacesCompilationTests { + @Test + fun `compilation for empty sealed class generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "generics", + "SealedEnumWithInterfaces.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "EmptySealedClassWithInterface_SealedEnum.kt", + emptySealedClassWithInterfaceGenerated, + result + ) + } + + @Test + fun `compilation for one object sealed class generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "generics", + "SealedEnumWithInterfaces.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "OneObjectSealedClassWithInterface_SealedEnum.kt", + oneObjectSealedClassWithInterfaceGenerated, + result + ) + } + + @Test + fun `compilation for two object sealed class generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "generics", + "SealedEnumWithInterfaces.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "TwoObjectSealedClassWithGenericInterface_SealedEnum.kt", + twoObjectSealedClassWithGenericInterfaceGenerated, + result + ) + } + + @Test + fun `compilation for sealed class with getter interface generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "generics", + "SealedEnumWithInterfaces.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "SealedClassWithGetterInterface_SealedEnum.kt", + sealedClassWithGetterInterface, + result + ) + } +} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfacesTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfacesTests.kt deleted file mode 100644 index 0042c7f9..00000000 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/generics/SealedEnumWithInterfacesTests.kt +++ /dev/null @@ -1,235 +0,0 @@ -package com.livefront.sealedenum.compilation.generics - -import com.livefront.sealedenum.SealedEnum -import com.livefront.sealedenum.testing.PlatformSourceType -import com.livefront.sealedenum.testing.SharableProcessingSourceType -import com.livefront.sealedenum.testing.assertCompiles -import com.livefront.sealedenum.testing.assertGeneratedFileMatches -import com.livefront.sealedenum.testing.compile -import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertFalse -import org.junit.jupiter.api.Assertions.assertTrue -import org.junit.jupiter.api.Test -import kotlin.reflect.KTypeProjection -import kotlin.reflect.full.createType -import kotlin.reflect.full.isSubclassOf -import kotlin.reflect.full.isSubtypeOf - -class SealedEnumWithInterfacesTests { - - @Test - fun `empty sealed enum implements interface`() { - assertTrue( - EmptySealedClassWithInterfaceSealedEnum::class.createType().isSubtypeOf( - SealedEnum::class.createType( - arguments = listOf( - KTypeProjection.invariant(EmptySealedClassWithInterface::class.createType()) - ) - ) - ) - ) - - // Check for compilation - val emptyValues: List = EmptySealedClassWithInterface.values - - assertEquals( - emptyList(), - emptyValues - ) - } - - @Test - fun `empty enum implements interface`() { - assertTrue(EmptySealedClassWithInterfaceEnum::class.isSubclassOf(TestInterface::class)) - - // Check for compilation - val emptyValues: Array = EmptySealedClassWithInterfaceEnum.values() - - assertEquals( - emptyList(), - emptyValues.toList() - ) - } - - @Test - fun `compilation for empty sealed class generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "generics", - "SealedEnumWithInterfaces.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "EmptySealedClassWithInterface_SealedEnum.kt", - emptySealedClassWithInterfaceGenerated, - result - ) - } - - @Test - fun `single object sealed enum implements interface`() { - assertTrue( - OneObjectSealedClassWithInterfaceSealedEnum::class.createType().isSubtypeOf( - SealedEnum::class.createType( - arguments = listOf( - KTypeProjection.invariant(OneObjectSealedClassWithInterface::class.createType()) - ) - ) - ) - ) - - // Check for compilation - val oneObjectValues: List = OneObjectSealedClassWithInterface.values - - assertEquals( - listOf(OneObjectSealedClassWithInterface.FirstObject), - oneObjectValues - ) - } - - @Test - fun `single object enum implements interface`() { - assertTrue(OneObjectSealedClassWithInterfaceEnum::class.isSubclassOf(TestInterface::class)) - - val oneObjectValues: Array = OneObjectSealedClassWithInterfaceEnum.values() - - assertEquals( - listOf(OneObjectSealedClassWithInterfaceEnum.OneObjectSealedClassWithInterface_FirstObject), - oneObjectValues.toList() - ) - } - - @Test - fun `compilation for one object sealed class generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "generics", - "SealedEnumWithInterfaces.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "OneObjectSealedClassWithInterface_SealedEnum.kt", - oneObjectSealedClassWithInterfaceGenerated, - result - ) - } - - @Test - fun `two object sealed enum implements generic interface`() { - assertTrue( - TwoObjectSealedClassWithGenericInterfaceSealedEnum::class.createType().isSubtypeOf( - SealedEnum::class.createType( - arguments = listOf( - KTypeProjection.invariant( - TwoObjectSealedClassWithGenericInterface::class.createType( - arguments = listOf( - KTypeProjection.invariant(TestInterface::class.createType()) - ) - ) - ) - ) - ) - ) - ) - - // Check for compilation - val twoObjectValues: List> = - TwoObjectSealedClassWithGenericInterface.values - - assertEquals( - listOf( - TwoObjectSealedClassWithGenericInterface.FirstObject, - TwoObjectSealedClassWithGenericInterface.SecondObject - ), - twoObjectValues - ) - } - - @Test - fun `two object enum implements generic interface`() { - assertTrue( - TwoObjectSealedClassWithGenericInterfaceEnum::class.createType().isSubtypeOf( - TestGenericInterface::class.createType( - arguments = listOf( - KTypeProjection.invariant(TestInterface::class.createType()) - ) - ) - ) - ) - - val twoObjectValues: Array> = - TwoObjectSealedClassWithGenericInterfaceEnum.values() - - assertEquals( - listOf( - TwoObjectSealedClassWithGenericInterfaceEnum.TwoObjectSealedClassWithGenericInterface_FirstObject, - TwoObjectSealedClassWithGenericInterfaceEnum.TwoObjectSealedClassWithGenericInterface_SecondObject - ), - twoObjectValues.toList() - ) - } - - @Test - fun `compilation for two object sealed class generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "generics", - "SealedEnumWithInterfaces.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "TwoObjectSealedClassWithGenericInterface_SealedEnum.kt", - twoObjectSealedClassWithGenericInterfaceGenerated, - result - ) - } - - @Test - fun `enum delegates to sealed class`() { - val sealedObject = SealedClassWithGetterInterface.FirstObject - - val enumValue = SealedClassWithGetterInterfaceEnum.SealedClassWithGetterInterface_FirstObject - - assertFalse(sealedObject.hasGetBeenCalled) - - assertEquals("First", enumValue.get()) - - assertTrue(sealedObject.hasGetBeenCalled) - } - - @Test - fun `compilation for sealed class with getter interface generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "generics", - "SealedEnumWithInterfaces.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "SealedClassWithGetterInterface_SealedEnum.kt", - sealedClassWithGetterInterface, - result - ) - } -} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedClassHierarchyTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedClassHierarchyCompilationTests.kt similarity index 50% rename from processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedClassHierarchyTests.kt rename to processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedClassHierarchyCompilationTests.kt index 58ee344a..205d18b7 100644 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedClassHierarchyTests.kt +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedClassHierarchyCompilationTests.kt @@ -6,21 +6,12 @@ import com.livefront.sealedenum.testing.assertCompiles import com.livefront.sealedenum.testing.assertGeneratedFileMatches import com.livefront.sealedenum.testing.compile import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Test -class SealedClassHierarchyTests { - - @Test - fun `first hierarchy class A values`() { - assertEquals(listOf(FirstClassHierarchy.A.B.C), FirstClassHierarchy.A.values) - } - - @Test - fun `first hierarchy class A ordinal of A_B_C`() { - assertEquals(0, (FirstClassHierarchy.A.B.C as FirstClassHierarchy.A).ordinal) - } - +/** + * @see SealedClassHierarchyTests + */ +class SealedClassHierarchyCompilationTests { @Test fun `compilation for first hierarchy A generates correct code`() { val result = compile( @@ -41,16 +32,6 @@ class SealedClassHierarchyTests { ) } - @Test - fun `first hierarchy class B values`() { - assertEquals(listOf(FirstClassHierarchy.A.B.C), FirstClassHierarchy.A.B.values) - } - - @Test - fun `first hierarchy class B ordinal`() { - assertEquals(0, (FirstClassHierarchy.A.B.C as FirstClassHierarchy.A.B).ordinal) - } - @Test fun `compilation for first hierarchy B generates correct code`() { val result = compile( @@ -71,57 +52,6 @@ class SealedClassHierarchyTests { ) } - @Test - fun `second hierarchy class Z values`() { - assertEquals( - listOf( - SecondClassHierarchy.Z.Y, - SecondClassHierarchy.Z.X.W, - SecondClassHierarchy.Z.X.V, - SecondClassHierarchy.Z.X.U.T, - SecondClassHierarchy.Z.X.S.R, - SecondClassHierarchy.Z.Q.P, - SecondClassHierarchy.Z.O - ), - SecondClassHierarchy.Z.values - ) - } - - @Test - fun `second hierarchy class Z ordinal of Z_Y`() { - assertEquals(0, (SecondClassHierarchy.Z.Y as SecondClassHierarchy.Z).ordinal) - } - - @Test - fun `second hierarchy class Z ordinal of Z_X_W`() { - assertEquals(1, (SecondClassHierarchy.Z.X.W as SecondClassHierarchy.Z).ordinal) - } - - @Test - fun `second hierarchy class Z ordinal of Z_X_V`() { - assertEquals(2, (SecondClassHierarchy.Z.X.V as SecondClassHierarchy.Z).ordinal) - } - - @Test - fun `second hierarchy class Z ordinal of Z_X_U_T`() { - assertEquals(3, (SecondClassHierarchy.Z.X.U.T as SecondClassHierarchy.Z).ordinal) - } - - @Test - fun `second hierarchy class Z ordinal of Z_X_S_R`() { - assertEquals(4, (SecondClassHierarchy.Z.X.S.R as SecondClassHierarchy.Z).ordinal) - } - - @Test - fun `second hierarchy class Z ordinal of Z_Q_P`() { - assertEquals(5, (SecondClassHierarchy.Z.Q.P as SecondClassHierarchy.Z).ordinal) - } - - @Test - fun `second hierarchy class Z ordinal of Z_O`() { - assertEquals(6, (SecondClassHierarchy.Z.O as SecondClassHierarchy.Z).ordinal) - } - @Test fun `compilation for second hierarchy Z generates correct code`() { val result = compile( @@ -142,39 +72,6 @@ class SealedClassHierarchyTests { ) } - @Test - fun `second hierarchy class X values`() { - assertEquals( - listOf( - SecondClassHierarchy.Z.X.W, - SecondClassHierarchy.Z.X.V, - SecondClassHierarchy.Z.X.U.T, - SecondClassHierarchy.Z.X.S.R - ), - SecondClassHierarchy.Z.X.values - ) - } - - @Test - fun `second hierarchy class X ordinal of Z_X_W`() { - assertEquals(0, (SecondClassHierarchy.Z.X.W as SecondClassHierarchy.Z.X).ordinal) - } - - @Test - fun `second hierarchy class X ordinal of Z_X_V`() { - assertEquals(1, (SecondClassHierarchy.Z.X.V as SecondClassHierarchy.Z.X).ordinal) - } - - @Test - fun `second hierarchy class X ordinal of Z_X_U_T`() { - assertEquals(2, (SecondClassHierarchy.Z.X.U.T as SecondClassHierarchy.Z.X).ordinal) - } - - @Test - fun `second hierarchy class X ordinal of Z_X_S_R`() { - assertEquals(3, (SecondClassHierarchy.Z.X.S.R as SecondClassHierarchy.Z.X).ordinal) - } - @Test fun `compilation for second hierarchy X generates correct code`() { val result = compile( @@ -195,19 +92,6 @@ class SealedClassHierarchyTests { ) } - @Test - fun `second hierarchy class U values`() { - assertEquals( - listOf(SecondClassHierarchy.Z.X.U.T), - SecondClassHierarchy.Z.X.U.values - ) - } - - @Test - fun `second hierarchy class U ordinal of Z_X_U_T`() { - assertEquals(0, (SecondClassHierarchy.Z.X.U.T as SecondClassHierarchy.Z.X.U).ordinal) - } - @Test fun `compilation for second hierarchy U generates correct code`() { val result = compile( @@ -228,19 +112,6 @@ class SealedClassHierarchyTests { ) } - @Test - fun `second hierarchy class S values`() { - assertEquals( - listOf(SecondClassHierarchy.Z.X.S.R), - SecondClassHierarchy.Z.X.S.values - ) - } - - @Test - fun `second hierarchy class S ordinal of Z_X_S_R`() { - assertEquals(0, (SecondClassHierarchy.Z.X.S.R as SecondClassHierarchy.Z.X.S).ordinal) - } - @Test fun `compilation for second hierarchy S generates correct code`() { val result = compile( @@ -261,19 +132,6 @@ class SealedClassHierarchyTests { ) } - @Test - fun `second hierarchy class Q values`() { - assertEquals( - listOf(SecondClassHierarchy.Z.Q.P), - SecondClassHierarchy.Z.Q.values - ) - } - - @Test - fun `second hierarchy class Q ordinal of Z_Q_P`() { - assertEquals(0, (SecondClassHierarchy.Z.Q.P as SecondClassHierarchy.Z.Q).ordinal) - } - @Test fun `compilation for second hierarchy Q generates correct code`() { val result = compile( diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedInterfaceHierarchyCompilationTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedInterfaceHierarchyCompilationTests.kt new file mode 100644 index 00000000..4cdf5c19 --- /dev/null +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedInterfaceHierarchyCompilationTests.kt @@ -0,0 +1,154 @@ +package com.livefront.sealedenum.compilation.hierarchy + +import com.livefront.sealedenum.testing.PlatformSourceType +import com.livefront.sealedenum.testing.SharableProcessingSourceType +import com.livefront.sealedenum.testing.assertCompiles +import com.livefront.sealedenum.testing.assertGeneratedFileMatches +import com.livefront.sealedenum.testing.compile +import com.livefront.sealedenum.testing.getSourceFile +import org.junit.jupiter.api.Test + +/** + * @see SealedInterfaceHierarchyTests + */ +class SealedInterfaceHierarchyCompilationTests { + @Test + fun `compilation for first hierarchy A generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "hierarchy", + "SealedInterfaceHierarchy.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "FirstInterfaceHierarchy.A_SealedEnum.kt", + firstInterfaceHierarchyAGenerated, + result + ) + } + + @Test + fun `compilation for first hierarchy B generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "hierarchy", + "SealedInterfaceHierarchy.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "FirstInterfaceHierarchy.A.B_SealedEnum.kt", + firstInterfaceHierarchyBGenerated, + result + ) + } + + @Test + fun `compilation for second hierarchy A generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "hierarchy", + "SealedInterfaceHierarchy.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "SecondInterfaceHierarchy.A_SealedEnum.kt", + secondInterfaceHierarchyAGenerated, + result + ) + } + + @Test + fun `compilation for second hierarchy C generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "hierarchy", + "SealedInterfaceHierarchy.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "SecondInterfaceHierarchy.A.C_SealedEnum.kt", + secondInterfaceHierarchyACGenerated, + result + ) + } + + @Test + fun `compilation for second hierarchy F generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "hierarchy", + "SealedInterfaceHierarchy.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "SecondInterfaceHierarchy.A.C.F_SealedEnum.kt", + secondInterfaceHierarchyACFGenerated, + result + ) + } + + @Test + fun `compilation for second hierarchy H generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "hierarchy", + "SealedInterfaceHierarchy.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "SecondInterfaceHierarchy.A.C.H_SealedEnum.kt", + secondInterfaceHierarchyACHGenerated, + result + ) + } + + @Test + fun `compilation for second hierarchy J generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "hierarchy", + "SealedInterfaceHierarchy.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "SecondInterfaceHierarchy.A.J_SealedEnum.kt", + secondInterfaceHierarchyAJGenerated, + result + ) + } +} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedInterfaceHierarchyTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedInterfaceHierarchyTests.kt deleted file mode 100644 index 43337a5a..00000000 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/hierarchy/SealedInterfaceHierarchyTests.kt +++ /dev/null @@ -1,296 +0,0 @@ -package com.livefront.sealedenum.compilation.hierarchy - -import com.livefront.sealedenum.testing.PlatformSourceType -import com.livefront.sealedenum.testing.SharableProcessingSourceType -import com.livefront.sealedenum.testing.assertCompiles -import com.livefront.sealedenum.testing.assertGeneratedFileMatches -import com.livefront.sealedenum.testing.compile -import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Test - -class SealedInterfaceHierarchyTests { - - @Test - fun `first hierarchy class A values`() { - assertEquals(listOf(FirstInterfaceHierarchy.A.B.C), FirstInterfaceHierarchy.A.values) - } - - @Test - fun `first hierarchy class A ordinal of A_B_C`() { - assertEquals(0, (FirstInterfaceHierarchy.A.B.C as FirstInterfaceHierarchy.A).ordinal) - } - - @Test - fun `compilation for first hierarchy A generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "hierarchy", - "SealedInterfaceHierarchy.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "FirstInterfaceHierarchy.A_SealedEnum.kt", - firstInterfaceHierarchyAGenerated, - result - ) - } - - @Test - fun `first hierarchy class B values`() { - assertEquals(listOf(FirstInterfaceHierarchy.A.B.C), FirstInterfaceHierarchy.A.B.values) - } - - @Test - fun `first hierarchy class B ordinal`() { - assertEquals(0, (FirstInterfaceHierarchy.A.B.C as FirstInterfaceHierarchy.A.B).ordinal) - } - - @Test - fun `compilation for first hierarchy B generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "hierarchy", - "SealedInterfaceHierarchy.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "FirstInterfaceHierarchy.A.B_SealedEnum.kt", - firstInterfaceHierarchyBGenerated, - result - ) - } - - @Test - fun `second hierarchy class A values`() { - assertEquals( - listOf( - SecondInterfaceHierarchy.A.B, - SecondInterfaceHierarchy.A.C.D, - SecondInterfaceHierarchy.A.C.E, - SecondInterfaceHierarchy.A.C.F.G, - SecondInterfaceHierarchy.A.C.H.I, - SecondInterfaceHierarchy.A.J.K, - SecondInterfaceHierarchy.A.L - ), - SecondInterfaceHierarchy.A.values - ) - } - - @Test - fun `second hierarchy class A ordinal of A_B`() { - assertEquals(0, (SecondInterfaceHierarchy.A.B as SecondInterfaceHierarchy.A).ordinal) - } - - @Test - fun `second hierarchy class A ordinal of A_C_D`() { - assertEquals(1, (SecondInterfaceHierarchy.A.C.D as SecondInterfaceHierarchy.A).ordinal) - } - - @Test - fun `second hierarchy class A ordinal of A_C_E`() { - assertEquals(2, (SecondInterfaceHierarchy.A.C.E as SecondInterfaceHierarchy.A).ordinal) - } - - @Test - fun `second hierarchy class A ordinal of A_C_F_G`() { - assertEquals(3, (SecondInterfaceHierarchy.A.C.F.G as SecondInterfaceHierarchy.A).ordinal) - } - - @Test - fun `second hierarchy class A ordinal of A_C_H_I`() { - assertEquals(4, (SecondInterfaceHierarchy.A.C.H.I as SecondInterfaceHierarchy.A).ordinal) - } - - @Test - fun `second hierarchy class A ordinal of A_J_K`() { - assertEquals(5, (SecondInterfaceHierarchy.A.J.K as SecondInterfaceHierarchy.A).ordinal) - } - - @Test - fun `second hierarchy class A ordinal of A_L`() { - assertEquals(6, (SecondInterfaceHierarchy.A.L as SecondInterfaceHierarchy.A).ordinal) - } - - @Test - fun `compilation for second hierarchy A generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "hierarchy", - "SealedInterfaceHierarchy.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "SecondInterfaceHierarchy.A_SealedEnum.kt", - secondInterfaceHierarchyAGenerated, - result - ) - } - - @Test - fun `second hierarchy class C values`() { - assertEquals( - listOf( - SecondInterfaceHierarchy.A.C.D, - SecondInterfaceHierarchy.A.C.E, - SecondInterfaceHierarchy.A.C.F.G, - SecondInterfaceHierarchy.A.C.H.I - ), - SecondInterfaceHierarchy.A.C.values - ) - } - - @Test - fun `second hierarchy class C ordinal of A_C_D`() { - assertEquals(0, (SecondInterfaceHierarchy.A.C.D as SecondInterfaceHierarchy.A.C).ordinal) - } - - @Test - fun `second hierarchy class C ordinal of A_C_E`() { - assertEquals(1, (SecondInterfaceHierarchy.A.C.E as SecondInterfaceHierarchy.A.C).ordinal) - } - - @Test - fun `second hierarchy class C ordinal of A_C_F_G`() { - assertEquals(2, (SecondInterfaceHierarchy.A.C.F.G as SecondInterfaceHierarchy.A.C).ordinal) - } - - @Test - fun `second hierarchy class C ordinal of A_C_H_I`() { - assertEquals(3, (SecondInterfaceHierarchy.A.C.H.I as SecondInterfaceHierarchy.A.C).ordinal) - } - - @Test - fun `compilation for second hierarchy C generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "hierarchy", - "SealedInterfaceHierarchy.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "SecondInterfaceHierarchy.A.C_SealedEnum.kt", - secondInterfaceHierarchyACGenerated, - result - ) - } - - @Test - fun `second hierarchy class F values`() { - assertEquals( - listOf(SecondInterfaceHierarchy.A.C.F.G), - SecondInterfaceHierarchy.A.C.F.values - ) - } - - @Test - fun `second hierarchy class F ordinal of A_L`() { - assertEquals(0, (SecondInterfaceHierarchy.A.C.F.G as SecondInterfaceHierarchy.A.C.F).ordinal) - } - - @Test - fun `compilation for second hierarchy F generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "hierarchy", - "SealedInterfaceHierarchy.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "SecondInterfaceHierarchy.A.C.F_SealedEnum.kt", - secondInterfaceHierarchyACFGenerated, - result - ) - } - - @Test - fun `second hierarchy class H values`() { - assertEquals( - listOf(SecondInterfaceHierarchy.A.C.H.I), - SecondInterfaceHierarchy.A.C.H.values - ) - } - - @Test - fun `second hierarchy class H ordinal of A_C_H_I`() { - assertEquals(0, (SecondInterfaceHierarchy.A.C.H.I as SecondInterfaceHierarchy.A.C.H).ordinal) - } - - @Test - fun `compilation for second hierarchy H generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "hierarchy", - "SealedInterfaceHierarchy.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "SecondInterfaceHierarchy.A.C.H_SealedEnum.kt", - secondInterfaceHierarchyACHGenerated, - result - ) - } - - @Test - fun `second hierarchy class J values`() { - assertEquals( - listOf(SecondInterfaceHierarchy.A.J.K), - SecondInterfaceHierarchy.A.J.values - ) - } - - @Test - fun `second hierarchy class J ordinal of A_J_K`() { - assertEquals(0, (SecondInterfaceHierarchy.A.J.K as SecondInterfaceHierarchy.A.J).ordinal) - } - - @Test - fun `compilation for second hierarchy J generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "hierarchy", - "SealedInterfaceHierarchy.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "SecondInterfaceHierarchy.A.J_SealedEnum.kt", - secondInterfaceHierarchyAJGenerated, - result - ) - } -} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/NestedClassTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/NestedClassCompilationTests.kt similarity index 67% rename from processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/NestedClassTests.kt rename to processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/NestedClassCompilationTests.kt index 148c5e28..179c2d1f 100644 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/NestedClassTests.kt +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/NestedClassCompilationTests.kt @@ -6,22 +6,12 @@ import com.livefront.sealedenum.testing.assertCompiles import com.livefront.sealedenum.testing.assertGeneratedFileMatches import com.livefront.sealedenum.testing.compile import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Test -class NestedClassTests { - - @Test - fun `inside one class`() { - assertEquals( - listOf( - OuterClass.InsideOneClassSealedClass.FirstObject, - OuterClass.InsideOneClassSealedClass.SecondObject - ), - OuterClass.InsideOneClassSealedClass.values - ) - } - +/** + * @see NestedClassTests + */ +class NestedClassCompilationTests { @Test fun `compilation for inside one class generates correct code`() { val result = compile( @@ -42,17 +32,6 @@ class NestedClassTests { ) } - @Test - fun `inside two classes`() { - assertEquals( - listOf( - FirstOuterClass.SecondOuterClass.InsideTwoClassesSealedClass.FirstObject, - FirstOuterClass.SecondOuterClass.InsideTwoClassesSealedClass.SecondObject - ), - FirstOuterClass.SecondOuterClass.InsideTwoClassesSealedClass.values - ) - } - @Test fun `compilation for inside two classes generates correct code`() { val result = compile( diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/OutsideSealedClassCompilationTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/OutsideSealedClassCompilationTests.kt new file mode 100644 index 00000000..d68005c7 --- /dev/null +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/OutsideSealedClassCompilationTests.kt @@ -0,0 +1,75 @@ +package com.livefront.sealedenum.compilation.location + +import com.livefront.sealedenum.testing.PlatformSourceType +import com.livefront.sealedenum.testing.SharableProcessingSourceType +import com.livefront.sealedenum.testing.assertCompiles +import com.livefront.sealedenum.testing.assertGeneratedFileMatches +import com.livefront.sealedenum.testing.compile +import com.livefront.sealedenum.testing.getSourceFile +import org.junit.jupiter.api.Test + +class OutsideSealedClassCompilationTests { + @Test + fun `compilation for alpha outside sealed class generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "location", + "OutsideSealedClass.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches("AlphaOutsideSealedClass_SealedEnum.kt", alphaOutsideSealedClassGenerated, result) + } + + @Test + fun `compilation for beta outside sealed class generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "location", + "OutsideSealedClass.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches("BetaOutsideSealedClass_SealedEnum.kt", betaOutsideSealedClassGenerated, result) + } + + @Test + fun `compilation for gamma outside sealed class generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "location", + "OutsideSealedClass.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches("GammaOutsideSealedClass_SealedEnum.kt", gammaOutsideSealedClassGenerated, result) + } + + @Test + fun `compilation for delta outside sealed class generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "location", + "OutsideSealedClass.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches("DeltaOutsideSealedClass_SealedEnum.kt", deltaOutsideSealedClassGenerated, result) + } +} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/OutsideSealedClassTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/OutsideSealedClassTests.kt deleted file mode 100644 index dbf494a0..00000000 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/OutsideSealedClassTests.kt +++ /dev/null @@ -1,193 +0,0 @@ -package com.livefront.sealedenum.compilation.location - -import com.livefront.sealedenum.testing.PlatformSourceType -import com.livefront.sealedenum.testing.SharableProcessingSourceType -import com.livefront.sealedenum.testing.assertCompiles -import com.livefront.sealedenum.testing.assertGeneratedFileMatches -import com.livefront.sealedenum.testing.compile -import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Test - -class OutsideSealedClassTests { - - @Test - fun `one object outside sealed class`() { - assertEquals(listOf(AlphaFirstObject), AlphaOutsideSealedClass.values) - } - - @Test - fun `one enum outside sealed class`() { - assertEquals( - listOf(AlphaOutsideSealedClassEnum.AlphaFirstObject), - enumValues().toList() - ) - } - - @Test - fun `one enum outside sealed class with mapping`() { - assertEquals( - AlphaOutsideSealedClass.values.map(AlphaOutsideSealedClass::enum), - enumValues().toList() - ) - } - - @Test - fun `compilation for alpha outside sealed class generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "location", - "OutsideSealedClass.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches("AlphaOutsideSealedClass_SealedEnum.kt", alphaOutsideSealedClassGenerated, result) - } - - @Test - fun `two objects outside sealed class`() { - assertEquals( - listOf( - BetaFirstObject, - BetaFourthObject, - BetaSecondObject, - BetaThirdObject, - ), - BetaOutsideSealedClass.values - ) - } - - @Test - fun `two enums outside sealed class`() { - assertEquals( - listOf( - BetaOutsideSealedClassEnum.BetaFirstObject, - BetaOutsideSealedClassEnum.BetaFourthObject, - BetaOutsideSealedClassEnum.BetaSecondObject, - BetaOutsideSealedClassEnum.BetaThirdObject, - ), - enumValues().toList() - ) - } - - @Test - fun `two enums outside sealed class with mapping`() { - assertEquals( - BetaOutsideSealedClass.values.map(BetaOutsideSealedClass::enum), - enumValues().toList() - ) - } - - @Test - fun `compilation for beta outside sealed class generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "location", - "OutsideSealedClass.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches("BetaOutsideSealedClass_SealedEnum.kt", betaOutsideSealedClassGenerated, result) - } - - @Test - fun `outside object ordering`() { - assertEquals( - listOf( - GammaOutsideSealedClass.GammaSecondObject, - GammaFirstObject, - GammaFourthObject, - GammaThirdObject, - ), - GammaOutsideSealedClass.values - ) - } - - @Test - fun `outside enum ordering`() { - assertEquals( - listOf( - GammaOutsideSealedClassEnum.GammaOutsideSealedClass_GammaSecondObject, - GammaOutsideSealedClassEnum.GammaFirstObject, - GammaOutsideSealedClassEnum.GammaFourthObject, - GammaOutsideSealedClassEnum.GammaThirdObject, - ), - enumValues().toList() - ) - } - - @Test - fun `outside enum ordering with mapping`() { - assertEquals( - GammaOutsideSealedClass.values.map(GammaOutsideSealedClass::enum), - enumValues().toList() - ) - } - - @Test - fun `compilation for gamma outside sealed class generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "location", - "OutsideSealedClass.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches("GammaOutsideSealedClass_SealedEnum.kt", gammaOutsideSealedClassGenerated, result) - } - - @Test - fun `duplicate name objects`() { - assertEquals( - listOf(DeltaOutsideSealedClass.DeltaObject, DeltaObject), - DeltaOutsideSealedClass.values - ) - } - - @Test - fun `duplicate name enums`() { - assertEquals( - listOf( - DeltaOutsideSealedClassEnum.DeltaOutsideSealedClass_DeltaObject, - DeltaOutsideSealedClassEnum.DeltaObject, - ), - enumValues().toList() - ) - } - - @Test - fun `duplicate name enums with mapping`() { - assertEquals( - DeltaOutsideSealedClass.values.map(DeltaOutsideSealedClass::enum), - enumValues().toList() - ) - } - - @Test - fun `compilation for delta outside sealed class generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "location", - "OutsideSealedClass.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches("DeltaOutsideSealedClass_SealedEnum.kt", deltaOutsideSealedClassGenerated, result) - } -} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/SplitAcrossFilesSealedClassTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/SplitAcrossFilesSealedClassCompilationTests.kt similarity index 73% rename from processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/SplitAcrossFilesSealedClassTests.kt rename to processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/SplitAcrossFilesSealedClassCompilationTests.kt index 3ad8045d..9193e336 100644 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/SplitAcrossFilesSealedClassTests.kt +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/location/SplitAcrossFilesSealedClassCompilationTests.kt @@ -6,31 +6,9 @@ import com.livefront.sealedenum.testing.assertCompiles import com.livefront.sealedenum.testing.assertGeneratedFileMatches import com.livefront.sealedenum.testing.compile import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Test -class SplitAcrossFilesSealedClassTests { - - @Test - fun `object split across files`() { - assertEquals( - listOf( - SplitAcrossFilesSubclassA, - SplitAcrossFilesSubclassB, - SplitAcrossFilesSubclassC - ), - SplitAcrossFilesSealedClass.values - ) - } - - @Test - fun `enum for objects split across files`() { - assertEquals( - SplitAcrossFilesSealedClass.values.map(SplitAcrossFilesSealedClass::enum), - enumValues().toList() - ) - } - +class SplitAcrossFilesSealedClassCompilationTests { @Test fun `compilation for objects split across files generates correct code`() { val result = compile( diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/traversal/TraversalOrderCompilationTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/traversal/TraversalOrderCompilationTests.kt new file mode 100644 index 00000000..a2b9e83b --- /dev/null +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/traversal/TraversalOrderCompilationTests.kt @@ -0,0 +1,30 @@ +package com.livefront.sealedenum.compilation.traversal + +import com.livefront.sealedenum.testing.PlatformSourceType +import com.livefront.sealedenum.testing.SharableProcessingSourceType +import com.livefront.sealedenum.testing.assertCompiles +import com.livefront.sealedenum.testing.assertGeneratedFileMatches +import com.livefront.sealedenum.testing.compile +import com.livefront.sealedenum.testing.getSourceFile +import org.junit.jupiter.api.Test + +/** + * @see TraversalOrderTests + */ +class TraversalOrderCompilationTests { + @Test + fun `compilation generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "traversal", + "TraversalOrder.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches("Tree_SealedEnum.kt", treeGenerated, result) + } +} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/usecases/EnvironmentsSealedEnumCompilationTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/usecases/EnvironmentsSealedEnumCompilationTests.kt new file mode 100644 index 00000000..51d6e742 --- /dev/null +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/usecases/EnvironmentsSealedEnumCompilationTests.kt @@ -0,0 +1,27 @@ +package com.livefront.sealedenum.compilation.usecases + +import com.livefront.sealedenum.testing.PlatformSourceType +import com.livefront.sealedenum.testing.SharableProcessingSourceType +import com.livefront.sealedenum.testing.assertCompiles +import com.livefront.sealedenum.testing.assertGeneratedFileMatches +import com.livefront.sealedenum.testing.compile +import com.livefront.sealedenum.testing.getSourceFile +import org.junit.jupiter.api.Test + +class EnvironmentsSealedEnumCompilationTests { + @Test + fun `compilation generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "usecases", + "EnvironmentsSealedEnum.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches("Environments_SealedEnum.kt", environmentsGenerated, result) + } +} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/usecases/EnvironmentsSealedEnumTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/usecases/EnvironmentsSealedEnumTests.kt index 0d1e2a38..6791fb67 100644 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/usecases/EnvironmentsSealedEnumTests.kt +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/usecases/EnvironmentsSealedEnumTests.kt @@ -1,11 +1,5 @@ package com.livefront.sealedenum.compilation.usecases -import com.livefront.sealedenum.testing.PlatformSourceType -import com.livefront.sealedenum.testing.SharableProcessingSourceType -import com.livefront.sealedenum.testing.assertCompiles -import com.livefront.sealedenum.testing.assertGeneratedFileMatches -import com.livefront.sealedenum.testing.compile -import com.livefront.sealedenum.testing.getSourceFile import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Test @@ -66,20 +60,4 @@ class EnvironmentsSealedEnumTests { environmentManager.currentEnvironment.sealedObject ) } - - @Test - fun `compilation generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "usecases", - "EnvironmentsSealedEnum.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches("Environments_SealedEnum.kt", environmentsGenerated, result) - } } diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassCompilationTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassCompilationTests.kt new file mode 100644 index 00000000..a93a67e7 --- /dev/null +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassCompilationTests.kt @@ -0,0 +1,87 @@ +package com.livefront.sealedenum.compilation.visibility + +import com.livefront.sealedenum.testing.PlatformSourceType +import com.livefront.sealedenum.testing.SharableProcessingSourceType +import com.livefront.sealedenum.testing.assertCompiles +import com.livefront.sealedenum.testing.assertGeneratedFileMatches +import com.livefront.sealedenum.testing.compile +import com.livefront.sealedenum.testing.getSourceFile +import org.junit.jupiter.api.Test + +class VisibilitySealedClassCompilationTests { + @Test + fun `internal objects compilation generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "visibility", + "VisibilitySealedClass.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "InternalObjectsSealedClass_SealedEnum.kt", + internalObjectsSealedClassGenerated, + result + ) + } + + @Test + fun `internal sealed class generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "visibility", + "VisibilitySealedClass.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches("InternalSealedClass_SealedEnum.kt", internalSealedClassGenerated, result) + } + + @Test + fun `internal companion compilation generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "visibility", + "VisibilitySealedClass.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "InternalCompanionSealedClass_SealedEnum.kt", + internalCompanionSealedClassGenerated, + result + ) + } + + @Test + fun `internal sealed class and companion compilation generates correct code`() { + val result = compile( + getSourceFile( + SharableProcessingSourceType.COMMMON, + PlatformSourceType.COMMON, + "compilation", + "visibility", + "VisibilitySealedClass.kt" + ) + ) + + assertCompiles(result) + assertGeneratedFileMatches( + "InternalSealedAndCompanionSealedClass_SealedEnum.kt", + internalSealedAndCompanionSealedClassGenerated, + result + ) + } +} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassTests.kt deleted file mode 100644 index fef9b893..00000000 --- a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassTests.kt +++ /dev/null @@ -1,285 +0,0 @@ -package com.livefront.sealedenum.compilation.visibility - -import com.livefront.sealedenum.SealedEnum -import com.livefront.sealedenum.testing.PlatformSourceType -import com.livefront.sealedenum.testing.SharableProcessingSourceType -import com.livefront.sealedenum.testing.assertCompiles -import com.livefront.sealedenum.testing.assertGeneratedFileMatches -import com.livefront.sealedenum.testing.compile -import com.livefront.sealedenum.testing.getSourceFile -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Nested -import org.junit.jupiter.api.Test -import kotlin.reflect.KVisibility - -/** - * Verifies that generated [SealedEnum] implementations, extension properties and methods have valid visibilities. - */ -class VisibilitySealedClassTests { - - @Nested - inner class InternalObjects { - - @Test - fun `sealed enum class has correct visibility`() { - assertEquals( - KVisibility.PUBLIC, - InternalObjectsSealedClassSealedEnum::class.visibility - ) - } - - @Test - fun `internal objects have correct values`() { - assertEquals( - listOf( - InternalObjectsSealedClass.FirstObject, - InternalObjectsSealedClass.SecondObject, - InternalObjectsSealedClass.InnerSealedClass.ThirdObject - ), - InternalObjectsSealedClass.values - ) - } - - @Test - fun `enums values are correct`() { - assertEquals( - listOf( - InternalObjectsSealedClassEnum.InternalObjectsSealedClass_FirstObject, - InternalObjectsSealedClassEnum.InternalObjectsSealedClass_SecondObject, - InternalObjectsSealedClassEnum.InternalObjectsSealedClass_InnerSealedClass_ThirdObject - ), - enumValues().toList() - ) - } - - @Test - fun `enums values are correct with mapping`() { - assertEquals( - InternalObjectsSealedClass.values.map(InternalObjectsSealedClass::enum), - enumValues().toList() - ) - } - - @Test - fun `correct enum class`() { - assertEquals(InternalObjectsSealedClassEnum::class, InternalObjectsSealedClass.sealedEnum.enumClass) - } - - @Test - fun `compilation generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "visibility", - "VisibilitySealedClass.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "InternalObjectsSealedClass_SealedEnum.kt", - internalObjectsSealedClassGenerated, - result - ) - } - } - - @Nested - inner class Internal { - - @Test - fun `sealed enum class has correct visibility`() { - assertEquals( - KVisibility.INTERNAL, - InternalSealedClassSealedEnum::class.visibility - ) - } - - @Test - fun `internal objects have correct values`() { - assertEquals( - listOf(InternalSealedClass.FirstObject, InternalSealedClass.SecondObject), - InternalSealedClass.values - ) - } - - @Test - fun `enums values are correct`() { - assertEquals( - listOf( - InternalSealedClassEnum.InternalSealedClass_FirstObject, - InternalSealedClassEnum.InternalSealedClass_SecondObject - ), - enumValues().toList() - ) - } - - @Test - fun `enums values are correct with mapping`() { - assertEquals( - InternalSealedClass.values.map(InternalSealedClass::enum), - enumValues().toList() - ) - } - - @Test - fun `correct enum class`() { - assertEquals(InternalSealedClassEnum::class, InternalSealedClass.sealedEnum.enumClass) - } - - @Test - fun `compilation generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "visibility", - "VisibilitySealedClass.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches("InternalSealedClass_SealedEnum.kt", internalSealedClassGenerated, result) - } - } - - @Nested - inner class InternalCompanion { - - @Test - fun `sealed enum class has correct visibility`() { - assertEquals( - KVisibility.PUBLIC, - InternalCompanionSealedClassSealedEnum::class.visibility - ) - } - - @Test - fun `internal objects have correct values`() { - assertEquals( - listOf(InternalCompanionSealedClass.FirstObject, InternalCompanionSealedClass.SecondObject), - InternalCompanionSealedClass.values - ) - } - - @Test - fun `enums values are correct`() { - assertEquals( - listOf( - InternalCompanionSealedClassEnum.InternalCompanionSealedClass_FirstObject, - InternalCompanionSealedClassEnum.InternalCompanionSealedClass_SecondObject - ), - enumValues().toList() - ) - } - - @Test - fun `enums values are correct with mapping`() { - assertEquals( - InternalCompanionSealedClass.values.map(InternalCompanionSealedClass::enum), - enumValues().toList() - ) - } - - @Test - fun `correct enum class`() { - assertEquals( - InternalCompanionSealedClassEnum::class, - InternalCompanionSealedClass.sealedEnum.enumClass - ) - } - - @Test - fun `compilation generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "visibility", - "VisibilitySealedClass.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "InternalCompanionSealedClass_SealedEnum.kt", - internalCompanionSealedClassGenerated, - result - ) - } - } - - @Nested - inner class InternalSealedAndCompanion { - - @Test - fun `sealed enum class has correct visibility`() { - assertEquals( - KVisibility.INTERNAL, - InternalSealedAndCompanionSealedClassSealedEnum::class.visibility - ) - } - - @Test - fun `internal objects have correct values`() { - assertEquals( - listOf( - InternalSealedAndCompanionSealedClass.FirstObject, - InternalSealedAndCompanionSealedClass.SecondObject - ), - InternalSealedAndCompanionSealedClass.values - ) - } - - @Test - fun `enums values are correct`() { - assertEquals( - listOf( - InternalSealedAndCompanionSealedClassEnum.InternalSealedAndCompanionSealedClass_FirstObject, - InternalSealedAndCompanionSealedClassEnum.InternalSealedAndCompanionSealedClass_SecondObject - ), - enumValues().toList() - ) - } - - @Test - fun `enums values are correct with mapping`() { - assertEquals( - InternalSealedAndCompanionSealedClass.values.map(InternalSealedAndCompanionSealedClass::enum), - enumValues().toList() - ) - } - - @Test - fun `correct enum class`() { - assertEquals( - InternalSealedAndCompanionSealedClassEnum::class, - InternalSealedAndCompanionSealedClass.sealedEnum.enumClass - ) - } - - @Test - fun `compilation generates correct code`() { - val result = compile( - getSourceFile( - SharableProcessingSourceType.COMMMON, - PlatformSourceType.COMMON, - "compilation", - "visibility", - "VisibilitySealedClass.kt" - ) - ) - - assertCompiles(result) - assertGeneratedFileMatches( - "InternalSealedAndCompanionSealedClass_SealedEnum.kt", - internalSealedAndCompanionSealedClassGenerated, - result - ) - } - } -} diff --git a/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassVisibilityTests.kt b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassVisibilityTests.kt new file mode 100644 index 00000000..0b1d2b8c --- /dev/null +++ b/processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/visibility/VisibilitySealedClassVisibilityTests.kt @@ -0,0 +1,39 @@ +package com.livefront.sealedenum.compilation.visibility + +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Test +import kotlin.reflect.KVisibility + +class VisibilitySealedClassVisibilityTests { + @Test + fun `internal objects sealed enum class has correct visibility`() { + assertEquals( + KVisibility.PUBLIC, + InternalObjectsSealedClassSealedEnum::class.visibility + ) + } + + @Test + fun `internal sealed class sealed enum class has correct visibility`() { + kotlin.test.assertEquals( + KVisibility.INTERNAL, + InternalSealedClassSealedEnum::class.visibility + ) + } + + @Test + fun `internal companion object sealed enum class has correct visibility`() { + kotlin.test.assertEquals( + KVisibility.PUBLIC, + InternalCompanionSealedClassSealedEnum::class.visibility + ) + } + + @Test + fun `internal sealed class and companion object sealed enum class has correct visibility`() { + kotlin.test.assertEquals( + KVisibility.INTERNAL, + InternalSealedAndCompanionSealedClassSealedEnum::class.visibility + ) + } +} diff --git a/processing-tests/processor-tests/build.gradle.kts b/processing-tests/processor-tests/build.gradle.kts index 71c075d2..3f26ff68 100644 --- a/processing-tests/processor-tests/build.gradle.kts +++ b/processing-tests/processor-tests/build.gradle.kts @@ -16,6 +16,7 @@ kotlin { val commonTest by getting { dependencies { implementation(kotlin("reflect")) + implementation(kotlin("test")) implementation(projects.runtime) } if (!debugKsp) {