diff --git a/compiler/src/main/java/com/readdle/codegen/SwiftValueDescriptor.java b/compiler/src/main/java/com/readdle/codegen/SwiftValueDescriptor.java index d9c5825..5019177 100644 --- a/compiler/src/main/java/com/readdle/codegen/SwiftValueDescriptor.java +++ b/compiler/src/main/java/com/readdle/codegen/SwiftValueDescriptor.java @@ -67,13 +67,6 @@ class SwiftValueDescriptor { enclosingElement = enclosingElement.getEnclosingElement(); } - - // Check if it's an abstract class - if (classElement.getModifiers().contains(Modifier.ABSTRACT)) { - throw new IllegalArgumentException(String.format("The class %s is abstract. You can't annotate abstract classes with @%s", - classElement.getQualifiedName().toString(), SwiftValue.class.getSimpleName())); - } - boolean hasEmptyConstructor = false; // Check if an empty constructor is given diff --git a/sample/src/androidTest/java/com/readdle/swiftjava/sample/SampleEnumWithValueTests.kt b/sample/src/androidTest/java/com/readdle/swiftjava/sample/SampleEnumWithValueTests.kt new file mode 100644 index 0000000..1bfd1db --- /dev/null +++ b/sample/src/androidTest/java/com/readdle/swiftjava/sample/SampleEnumWithValueTests.kt @@ -0,0 +1,182 @@ +package com.readdle.swiftjava.sample + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.readdle.codegen.anotation.JavaSwift +import org.junit.Assert +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +@RunWith(AndroidJUnit4::class) +class SampleEnumWithValueTests { + + @Before + fun setUp() { + System.loadLibrary("SampleAppCore") + JavaSwift.init() + } + + @Test + fun testNone() { + val value = SampleEnumWithValue.copy(SampleEnumWithValue.None) + Assert.assertTrue(value is SampleEnumWithValue.None) + } + + @Test + fun testStringValue() { + val value = SampleEnumWithValue.copy(SampleEnumWithValue.StringValue("42")) + Assert.assertEquals((value as SampleEnumWithValue.StringValue).value, "42") + } + + @Test + fun testIntegerValue() { + val value = SampleEnumWithValue.copy(SampleEnumWithValue.IntegerValue(42)) + Assert.assertEquals((value as SampleEnumWithValue.IntegerValue).value, 42) + } + + @Test + fun testInt8Value() { + val value = SampleEnumWithValue.copy(SampleEnumWithValue.Int8Value(42)) + Assert.assertEquals((value as SampleEnumWithValue.Int8Value).value.toInt(), 42) + } + + @Test + fun testInt16Value() { + val value = SampleEnumWithValue.copy(SampleEnumWithValue.Int16Value(42)) + Assert.assertEquals((value as SampleEnumWithValue.Int16Value).value.toInt(), 42) + } + + @Test + fun testInt32Value() { + val value = SampleEnumWithValue.copy(SampleEnumWithValue.Int32Value(42)) + Assert.assertEquals((value as SampleEnumWithValue.Int32Value).value, 42) + } + + @Test + fun testInt64Value() { + val value = SampleEnumWithValue.copy(SampleEnumWithValue.Int64Value(42)) + Assert.assertEquals((value as SampleEnumWithValue.Int64Value).value, 42) + } + + @Test + fun testUIntValue() { + val value = SampleEnumWithValue.copy(SampleEnumWithValue.UintValue(42U)) + Assert.assertEquals((value as SampleEnumWithValue.UintValue).value, 42U) + } + + @Test + fun testUInt8Value() { + val value = SampleEnumWithValue.copy(SampleEnumWithValue.Uint8Value(42U)) + Assert.assertEquals((value as SampleEnumWithValue.Uint8Value).value.toUInt(), 42U) + } + + @Test + fun testUInt16Value() { + val value = SampleEnumWithValue.copy(SampleEnumWithValue.Uint16Value(42U)) + Assert.assertEquals((value as SampleEnumWithValue.Uint16Value).value.toUInt(), 42U) + } + + @Test + fun testUInt32Value() { + val value = SampleEnumWithValue.copy(SampleEnumWithValue.Uint32Value(42U)) + Assert.assertEquals((value as SampleEnumWithValue.Uint32Value).value, 42U) + } + + @Test + fun testUInt64Value() { + val value = SampleEnumWithValue.copy(SampleEnumWithValue.Uint64Value(42U)) + Assert.assertEquals((value as SampleEnumWithValue.Uint64Value).value.toUInt(), 42U) + } + + @Test + fun testObjectArrayValue() { + val array = arrayListOf(SampleValue.getRandomValue()) + val value = SampleEnumWithValue.copy(SampleEnumWithValue.ObjectArrayValue(array)) + Assert.assertEquals((value as SampleEnumWithValue.ObjectArrayValue).value, array) + } + + @Test + fun testStringArrayValue() { + val array = arrayListOf("42") + val value = SampleEnumWithValue.copy(SampleEnumWithValue.StringArrayValue(array)) + Assert.assertEquals((value as SampleEnumWithValue.StringArrayValue).value, array) + } + + @Test + fun testNumberArrayValue() { + val array = arrayListOf(42) + val value = SampleEnumWithValue.copy(SampleEnumWithValue.NumberArrayValue(array)) + Assert.assertEquals((value as SampleEnumWithValue.NumberArrayValue).value, array) + } + + @Test + fun testArrayInArrayValue() { + val array = arrayListOf(arrayListOf(42)) + val value = SampleEnumWithValue.copy(SampleEnumWithValue.ArrayInArrayValue(array)) + Assert.assertEquals((value as SampleEnumWithValue.ArrayInArrayValue).value, array) + } + + @Test + fun testDictInArrayValue() { + val array = arrayListOf(hashMapOf(42 to 42)) + val value = SampleEnumWithValue.copy(SampleEnumWithValue.DictInArrayValue(array)) + Assert.assertEquals((value as SampleEnumWithValue.DictInArrayValue).value, array) + } + + @Test + fun testDictSampleClassValue() { + val dict = hashMapOf("abc" to SampleValue.getRandomValue()) + val value = SampleEnumWithValue.copy(SampleEnumWithValue.DictSampleClassValue(dict)) + Assert.assertEquals((value as SampleEnumWithValue.DictSampleClassValue).value, dict) + } + + @Test + fun testDictStringsValue() { + val dict = hashMapOf("abc" to "42") + val value = SampleEnumWithValue.copy(SampleEnumWithValue.DictStringsValue(dict)) + Assert.assertEquals((value as SampleEnumWithValue.DictStringsValue).value, dict) + } + + @Test + fun testDictNumbersValue() { + val dict = hashMapOf(42 to 42) + val value = SampleEnumWithValue.copy(SampleEnumWithValue.DictNumbersValue(dict)) + Assert.assertEquals((value as SampleEnumWithValue.DictNumbersValue).value, dict) + } + + @Test + fun testDict64NumbersValue() { + val dict = hashMapOf(10 to 10) + val value = SampleEnumWithValue.copy(SampleEnumWithValue.Dict64NumbersValue(dict)) + Assert.assertEquals((value as SampleEnumWithValue.Dict64NumbersValue).value, dict) + } + + @Test + fun testDictInDictValue() { + val dict = hashMapOf(10 to hashMapOf(10 to 10)) + val value = SampleEnumWithValue.copy(SampleEnumWithValue.DictInDictValue(dict)) + Assert.assertEquals((value as SampleEnumWithValue.DictInDictValue).value, dict) + } + + @Test + fun testArrayInDictValue() { + val dict = hashMapOf(10 to arrayListOf(10, 10)) + val value = SampleEnumWithValue.copy(SampleEnumWithValue.ArrayInDictValue(dict)) + Assert.assertEquals((value as SampleEnumWithValue.ArrayInDictValue).value, dict) + } + + @Test + fun testSetValue() { + val set = hashSetOf(42) + val value = SampleEnumWithValue.copy(SampleEnumWithValue.SetValue(set)) + Assert.assertEquals((value as SampleEnumWithValue.SetValue).value, set) + } + + @Test + fun testSetValuesValue() { + val set = hashSetOf(SampleValue.getRandomValue()) + val value = SampleEnumWithValue.copy(SampleEnumWithValue.SetValuesValue(set)) + Assert.assertEquals((value as SampleEnumWithValue.SetValuesValue).value, set) + } + +} \ No newline at end of file diff --git a/sample/src/main/java/com/readdle/swiftjava/sample/SampleEnumWithValue.kt b/sample/src/main/java/com/readdle/swiftjava/sample/SampleEnumWithValue.kt new file mode 100644 index 0000000..137dfb8 --- /dev/null +++ b/sample/src/main/java/com/readdle/swiftjava/sample/SampleEnumWithValue.kt @@ -0,0 +1,41 @@ +package com.readdle.swiftjava.sample + +import com.readdle.codegen.anotation.SwiftFunc +import com.readdle.codegen.anotation.SwiftValue + +@SwiftValue +sealed class SampleEnumWithValue { + + object None : SampleEnumWithValue() + data class StringValue(val value: String) : SampleEnumWithValue() + data class IntegerValue(val value: Int) : SampleEnumWithValue() + data class Int8Value(val value: Byte) : SampleEnumWithValue() + data class Int16Value(val value: Short) : SampleEnumWithValue() + data class Int32Value(val value: Int) : SampleEnumWithValue() + data class Int64Value(val value: Long) : SampleEnumWithValue() + data class UintValue(val value: UInt) : SampleEnumWithValue() + data class Uint8Value(val value: UByte) : SampleEnumWithValue() + data class Uint16Value(val value: UShort) : SampleEnumWithValue() + data class Uint32Value(val value: UInt) : SampleEnumWithValue() + data class Uint64Value(val value: ULong) : SampleEnumWithValue() + data class ObjectArrayValue(val value: ArrayList) : SampleEnumWithValue() + data class StringArrayValue(val value: ArrayList) : SampleEnumWithValue() + data class NumberArrayValue(val value: ArrayList) : SampleEnumWithValue() + data class ArrayInArrayValue(val value: ArrayList>) : SampleEnumWithValue() + data class DictInArrayValue(val value: ArrayList>) : SampleEnumWithValue() + data class DictSampleClassValue(val value: HashMap) : SampleEnumWithValue() + data class DictStringsValue(val value: HashMap) : SampleEnumWithValue() + data class DictNumbersValue(val value: HashMap) : SampleEnumWithValue() + data class Dict64NumbersValue(val value: HashMap) : SampleEnumWithValue() + data class DictInDictValue(val value: HashMap>) : SampleEnumWithValue() + data class ArrayInDictValue(val value: HashMap>) : SampleEnumWithValue() + data class SetValue(val value: HashSet) : SampleEnumWithValue() + data class SetValuesValue(val value: HashSet) : SampleEnumWithValue() + + companion object { + + @JvmStatic + @SwiftFunc("copy(value:)") + external fun copy(value: SampleEnumWithValue): SampleEnumWithValue + } +} \ No newline at end of file diff --git a/sample/src/main/swift/Package.resolved b/sample/src/main/swift/Package.resolved index 88b8795..50411e6 100644 --- a/sample/src/main/swift/Package.resolved +++ b/sample/src/main/swift/Package.resolved @@ -6,8 +6,8 @@ "repositoryURL": "https://github.com/readdle/java_swift.git", "state": { "branch": null, - "revision": "c1ed735ca2e82d961511ee6e938157f78c31278b", - "version": "2.2.0" + "revision": "f50fd0845ef22caa955444e72b25b72a59cf7b71", + "version": "2.2.2" } }, { @@ -42,8 +42,8 @@ "repositoryURL": "https://github.com/readdle/swift-java-coder.git", "state": { "branch": null, - "revision": "b0b66fa90d7b04c7214da15a17ec5ba14df61c8d", - "version": "1.1.0" + "revision": "d65e2ca83c524e9fde6ff90d291115c57a268217", + "version": "1.1.1" } } ] diff --git a/sample/src/main/swift/Package.swift b/sample/src/main/swift/Package.swift index 55a47e8..b26084e 100755 --- a/sample/src/main/swift/Package.swift +++ b/sample/src/main/swift/Package.swift @@ -15,7 +15,7 @@ let package = Package( dependencies: [ .package(url: "https://github.com/readdle/java_swift.git", .upToNextMinor(from: "2.2.0")), .package(url: "https://github.com/readdle/swift-java.git", .upToNextMinor(from: "0.3.0")), - .package(url: "https://github.com/readdle/swift-java-coder.git", .upToNextMinor(from: "1.1.0")), + .package(url: "https://github.com/readdle/swift-java-coder.git", .upToNextMinor(from: "1.1.1")), .package(url: "https://github.com/readdle/swift-anycodable.git", .upToNextMinor(from: "1.0.3")), ], targets: [ diff --git a/sample/src/main/swift/Sources/SampleAppCore/SampleEnumWithValue.swift b/sample/src/main/swift/Sources/SampleAppCore/SampleEnumWithValue.swift new file mode 100644 index 0000000..a0a6a2f --- /dev/null +++ b/sample/src/main/swift/Sources/SampleAppCore/SampleEnumWithValue.swift @@ -0,0 +1,47 @@ +// +// Created by Andrew Druk on 06.05.2024. +// + +import Foundation + +public enum SampleEnumWithValue: Codable { + case none + case stringValue(value: String) + case integerValue(value: Int) + case int8Value(value: Int8) + case int16Value(value: Int16) + case int32Value(value: Int32) + case int64Value(value: Int64) + case uintValue(value: UInt) + case uint8Value(value: UInt8) + case uint16Value(value: UInt16) + case uint32Value(value: UInt32) + case uint64Value(value: UInt64) + case optionalIntegerValue(value: Int?) + case optionalInt8Value(value: Int8?) + case optionalInt16Value(value: Int16?) + case optionalInt32Value(value: Int32?) + case optionalInt64Value(value: Int64?) + case optionalUintValue(value: UInt?) + case optionalUint8Value(value: UInt8?) + case optionalUint16Value(value: UInt16?) + case optionalUint32Value(value: UInt32?) + case optionalUint64Value(value: UInt64?) + case objectArrayValue(value: [SampleValue]) + case stringArrayValue(value: [String]) + case numberArrayValue(value: [Int]) + case arrayInArrayValue(value: [[Int]]) + case dictInArrayValue(value: [[Int: Int]]) + case dictSampleClassValue(value: [String: SampleValue]) + case dictStringsValue(value: [String: String]) + case dictNumbersValue(value: [Int: Int]) + case dict64NumbersValue(value: [Int: Int]) + case dictInDictValue(value: [Int: [Int: Int]]) + case arrayInDictValue(value: [Int: [Int]]) + case setValue(value: Set) + case setValuesValue(value: Set) + + public static func copy(value: SampleEnumWithValue) -> SampleEnumWithValue { + return value + } +} \ No newline at end of file