Dev: start working on new primitives tests with Int8Test

Author: andriydruk

sample/src/androidTest/java/com/readdle/swiftjava/sample/Int8Tests.java

@@ -0,0 +1,75 @@
+package com.readdle.swiftjava.sample;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.util.Log;
+
+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)
+public class Int8Tests {
+
+    @Before
+    public void setUp() {
+        System.loadLibrary("SampleAppCore");
+        JavaSwift.init();
+        SwiftEnvironment.initEnvironment();
+    }
+
+    @Test
+    public void testZero() {
+        Assert.assertEquals(Int8Test.testZero(), 0);
+    }
+
+    @Test
+    public void testMin() {
+        Assert.assertEquals(Int8Test.testMin(), Byte.MIN_VALUE);
+    }
+
+    @Test
+    public void testMax() {
+        Assert.assertEquals(Int8Test.testMax(), Byte.MAX_VALUE);
+    }
+
+    @Test
+    public void testParam() {
+        Assert.assertTrue(Int8Test.testParam(Byte.MAX_VALUE));
+        Assert.assertFalse(Int8Test.testParam(Byte.MIN_VALUE));
+    }
+
+    @Test
+    public void testReturnType() {
+        Assert.assertEquals(Int8Test.testReturnType(), Byte.MAX_VALUE);
+    }
+
+    @Test
+    public void testOptionalParam() {
+        Assert.assertTrue(Int8Test.testOptionalParam(Byte.MAX_VALUE));
+        Assert.assertFalse(Int8Test.testOptionalParam(Byte.MIN_VALUE));
+    }
+
+    @Test
+    public void testProtocolReturnType() {
+        byte result = Int8Test.testProtocolReturnType(() -> (byte) 42);
+        Assert.assertEquals(result, 42);
+    }
+
+    @Test
+    public void testEncode() {
+        Int8TestStruct result = Int8Test.testEncode();
+        Assert.assertEquals(result, new Int8TestStruct());
+    }
+
+    @Test
+    public void testDecode() {
+        Int8TestStruct goodParam = new Int8TestStruct();
+        Int8TestStruct badParam = new Int8TestStruct((byte) 42, (byte) 42, (byte) 42, (byte) 42, (byte) 42);
+        Assert.assertTrue(Int8Test.testDecode(goodParam));
+        Assert.assertFalse(Int8Test.testDecode(badParam));
+    }
+
+}

sample/src/main/java/com/readdle/swiftjava/sample/Int8Test.kt

@@ -0,0 +1,86 @@
+package com.readdle.swiftjava.sample
+
+import com.readdle.codegen.anotation.SwiftCallbackFunc
+import com.readdle.codegen.anotation.SwiftDelegate
+import com.readdle.codegen.anotation.SwiftReference
+import com.readdle.codegen.anotation.SwiftValue
+import java.lang.annotation.Native
+
+// TODO: fix it
+//    @SwiftDelegate(protocols = ["Int8TestParamProtocol"])
+//    interface ParamProtocol {
+//        @SwiftCallbackFunc
+//        fun testParam(param: Byte): Boolean
+//    }
+
+@SwiftDelegate(protocols = ["Int8TestReturnTypeProtocol"])
+interface ReturnTypeProtocol {
+    @SwiftCallbackFunc
+    fun testReturnType(): Byte
+}
+// TODO: fix it
+//    @SwiftDelegate(protocols = ["Int8TestOptionalParamProtocol"])
+//    interface OptionalParamProtocol {
+//        @SwiftCallbackFunc
+//        fun testOptionalParam(param: Byte?): Boolean
+//    }
+
+@SwiftDelegate(protocols = ["Int8TestOptionalReturnTypeProtocol"])
+interface OptionalReturnTypeProtocol {
+    @SwiftCallbackFunc
+    fun testOptionalReturnType(): Byte?
+}
+
+@SwiftValue
+data class Int8TestStruct(var zero: Byte = 0,
+                          var max: Byte = Byte.MAX_VALUE,
+                          var min: Byte = Byte.MIN_VALUE,
+                          var optional: Byte? = 0,
+                          var optionalNil: Byte? = null)
+
+@SwiftReference
+class Int8Test private constructor() {
+
+    companion object {
+        @JvmStatic
+        external fun testZero(): Byte
+
+        @JvmStatic
+        external fun testMin(): Byte
+
+        @JvmStatic
+        external fun testMax(): Byte
+
+        @JvmStatic
+        external fun testParam(param: Byte): Boolean
+
+        @JvmStatic
+        external fun testReturnType(): Byte
+
+        @JvmStatic
+        external fun testOptionalParam(param: Byte?): Boolean
+
+        // TODO: fix it
+//        @JvmStatic
+//        external fun testOptionalReturnType(): Byte?
+
+        @JvmStatic
+        external fun testProtocolReturnType(callback: ReturnTypeProtocol): Byte
+
+        // TODO: fix it
+//        @JvmStatic
+//        external fun testProtocolOptionalReturnType(callback: OptionalReturnTypeProtocol): Byte?
+
+        @JvmStatic
+        external fun testEncode():  Int8TestStruct
+
+        @JvmStatic
+        external fun testDecode(value: Int8TestStruct): Boolean
+    }
+
+    @Native
+    var nativePointer: Long = 0
+
+    external fun release()
+
+}

sample/src/main/swift/Sources/SampleAppCore/Int8Test.swift

@@ -0,0 +1,87 @@
+//
+// Created by Andrew on 2/4/18.
+//
+
+import Foundation
+
+public struct Int8TestStruct: Codable, Hashable {
+    public var zero: Int8 = Int8.zero
+    public var max: Int8 = Int8.max
+    public var min: Int8 = Int8.min
+    public var optional: Int8? = Int8.zero
+    public var optionalNil: Int8? = nil
+}
+
+public protocol Int8TestParamProtocol {
+    func testParam(_ param: Int8) -> Bool
+}
+
+public protocol Int8TestReturnTypeProtocol {
+    func testReturnType() -> Int8
+}
+
+public protocol Int8TestOptionalParamProtocol {
+    func testOptionalParam(_ param: Int8?) -> Bool
+}
+
+public protocol Int8TestOptionalReturnTypeProtocol {
+    func testOptionalReturnType() -> Int8?
+}
+
+public class Int8Test {
+
+    public static func testZero() -> Int8 {
+        return 0
+    }
+
+    public static func testMin() -> Int8 {
+        return Int8.min
+    }
+
+    public static func testMax() -> Int8 {
+        return Int8.max
+    }
+
+    public static func testParam(_ param: Int8) -> Bool {
+        return param == Int8.max
+    }
+
+    public static func testReturnType() -> Int8 {
+        return Int8.max
+    }
+
+    public static func testOptionalParam(_ param: Int8?) -> Bool {
+        return param == Int8.max
+    }
+
+    public static func testOptionalReturnType() -> Int8? {
+        return Int8.max
+    }
+
+    public static func testProtocolParam(_ callback: Int8TestParamProtocol) -> Bool {
+        return callback.testParam(Int8.max)
+    }
+
+    public static func testProtocolReturnType(_ callback: Int8TestReturnTypeProtocol) -> Int8 {
+        return callback.testReturnType()
+    }
+
+    public static func testProtocolOptionalParam(_ callback: Int8TestOptionalParamProtocol) -> Bool {
+        return callback.testOptionalParam(Int8.max)
+    }
+
+    public static func testProtocolOptionalReturnType(_ callback: Int8TestOptionalReturnTypeProtocol) -> Int8? {
+        return callback.testOptionalReturnType()
+    }
+
+    public static func testEncode() ->  Int8TestStruct {
+        return Int8TestStruct()
+    }
+
+    public static func testDecode(_ value: Int8TestStruct) -> Bool {
+        NSLog("!!!\(value.max)!!!")
+        return value == Int8TestStruct()
+    }
+
+
+}