Dev: add Int16 test

Author: andriydruk

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

@@ -0,0 +1,99 @@
+package com.readdle.swiftjava.sample;
+
+import android.support.test.runner.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)
+public class Int16Tests {
+
+    @Before
+    public void setUp() {
+        System.loadLibrary("SampleAppCore");
+        JavaSwift.init();
+        SwiftEnvironment.initEnvironment();
+    }
+
+    @Test
+    public void testZero() {
+        Assert.assertEquals(Int16Test.testZero(), 0);
+    }
+
+    @Test
+    public void testMin() {
+        Assert.assertEquals(Int16Test.testMin(), Short.MIN_VALUE);
+    }
+
+    @Test
+    public void testMax() {
+        Assert.assertEquals(Int16Test.testMax(), Short.MAX_VALUE);
+    }
+
+    @Test
+    public void testParam() {
+        Assert.assertTrue(Int16Test.testParam(Short.MAX_VALUE));
+        Assert.assertFalse(Int16Test.testParam(Short.MIN_VALUE));
+    }
+
+    @Test
+    public void testReturnType() {
+        Assert.assertEquals(Int16Test.testReturnType(), Short.MAX_VALUE);
+    }
+
+    @Test
+    public void testOptionalParam() {
+        Assert.assertTrue(Int16Test.testOptionalParam(Short.MAX_VALUE));
+        Assert.assertFalse(Int16Test.testOptionalParam(Short.MIN_VALUE));
+    }
+
+    public void testOptionalReturnType() {
+        Short result = Int16Test.testOptionalReturnType();
+        Assert.assertNotNull(result);
+        Assert.assertEquals(result.shortValue(), Short.MAX_VALUE);
+    }
+
+    @Test
+    public void testProtocolParam() {
+        boolean result = Int16Test.testProtocolParam(param -> param == Short.MAX_VALUE);
+        Assert.assertTrue(result);
+    }
+
+    @Test
+    public void testProtocolReturnType() {
+        short result = Int16Test.testProtocolReturnType(() -> (short) 42);
+        Assert.assertEquals(result, 42);
+    }
+
+    @Test
+    public void testProtocolOptionalParam() {
+        boolean result = Int16Test.testProtocolOptionalParam(param -> param != null && param == Short.MAX_VALUE);
+        Assert.assertTrue(result);
+    }
+
+    @Test
+    public void testProtocolOptionalReturnType() {
+        Short result = Int16Test.testProtocolOptionalReturnType(() -> (short) 42);
+        Assert.assertNotNull(result);
+        Assert.assertEquals(result.shortValue(), 42);
+    }
+
+    @Test
+    public void testEncode() {
+        Int16TestStruct result = Int16Test.testEncode();
+        Assert.assertEquals(result, new Int16TestStruct());
+    }
+
+    @Test
+    public void testDecode() {
+        Int16TestStruct goodParam = new Int16TestStruct();
+        Int16TestStruct badParam = new Int16TestStruct((short) 42, (short) 42, (short) 42, (short) 42, (short) 42);
+        Assert.assertTrue(Int16Test.testDecode(goodParam));
+        Assert.assertFalse(Int16Test.testDecode(badParam));
+    }
+
+}

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

@@ -0,0 +1,89 @@
+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
+
+@SwiftValue
+data class Int16TestStruct(var zero: Short = 0,
+                          var max: Short = Short.MAX_VALUE,
+                          var min: Short = Short.MIN_VALUE,
+                          var optional: Short? = 0,
+                          var optionalNil: Short? = null)
+
+@SwiftReference
+class Int16Test private constructor() {
+
+    @SwiftDelegate(protocols = ["Int16TestParamProtocol"])
+    interface Int16ParamProtocol {
+        @SwiftCallbackFunc
+        fun testParam(param: Short): Boolean
+    }
+
+    @SwiftDelegate(protocols = ["Int16TestReturnTypeProtocol"])
+    interface Int16ReturnTypeProtocol {
+        @SwiftCallbackFunc
+        fun testReturnType(): Short
+    }
+
+    @SwiftDelegate(protocols = ["Int16TestOptionalParamProtocol"])
+    interface Int16OptionalParamProtocol {
+        @SwiftCallbackFunc
+        fun testOptionalParam(param: Short?): Boolean
+    }
+
+    @SwiftDelegate(protocols = ["Int16TestOptionalReturnTypeProtocol"])
+    interface Int16OptionalReturnTypeProtocol {
+        @SwiftCallbackFunc
+        fun testOptionalReturnType(): Short?
+    }
+
+    companion object {
+        @JvmStatic
+        external fun testZero(): Short
+
+        @JvmStatic
+        external fun testMin(): Short
+
+        @JvmStatic
+        external fun testMax(): Short
+
+        @JvmStatic
+        external fun testParam(param: Short): Boolean
+
+        @JvmStatic
+        external fun testReturnType(): Short
+
+        @JvmStatic
+        external fun testOptionalParam(param: Short?): Boolean
+
+        @JvmStatic
+        external fun testOptionalReturnType(): Short?
+
+        @JvmStatic
+        external fun testProtocolParam(callback: Int16ParamProtocol): Boolean
+
+        @JvmStatic
+        external fun testProtocolReturnType(callback: Int16ReturnTypeProtocol): Short
+
+        @JvmStatic
+        external fun testProtocolOptionalParam(callback: Int16OptionalParamProtocol): Boolean
+
+        @JvmStatic
+        external fun testProtocolOptionalReturnType(callback: Int16OptionalReturnTypeProtocol): Short?
+
+        @JvmStatic
+        external fun testEncode():  Int16TestStruct
+
+        @JvmStatic
+        external fun testDecode(value: Int16TestStruct): Boolean
+    }
+
+    @Native
+    var nativePointer: Long = 0
+
+    external fun release()
+
+}

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

@@ -0,0 +1,86 @@
+//
+// Created by Andrew on 2/4/18.
+//
+
+import Foundation
+
+public struct Int16TestStruct: Codable, Hashable {
+    public var zero: Int16 = Int16.zero
+    public var max: Int16 = Int16.max
+    public var min: Int16 = Int16.min
+    public var optional: Int16? = Int16.zero
+    public var optionalNil: Int16? = nil
+}
+
+public protocol Int16TestParamProtocol {
+    func testParam(_ param: Int16) -> Bool
+}
+
+public protocol Int16TestReturnTypeProtocol {
+    func testReturnType() -> Int16
+}
+
+public protocol Int16TestOptionalParamProtocol {
+    func testOptionalParam(_ param: Int16?) -> Bool
+}
+
+public protocol Int16TestOptionalReturnTypeProtocol {
+    func testOptionalReturnType() -> Int16?
+}
+
+public class Int16Test {
+
+    public static func testZero() -> Int16 {
+        return 0
+    }
+
+    public static func testMin() -> Int16 {
+        return Int16.min
+    }
+
+    public static func testMax() -> Int16 {
+        return Int16.max
+    }
+
+    public static func testParam(_ param: Int16) -> Bool {
+        return param == Int16.max
+    }
+
+    public static func testReturnType() -> Int16 {
+        return Int16.max
+    }
+
+    public static func testOptionalParam(_ param: Int16?) -> Bool {
+        return param == Int16.max
+    }
+
+    public static func testOptionalReturnType() -> Int16? {
+        return Int16.max
+    }
+
+    public static func testProtocolParam(_ callback: Int16TestParamProtocol) -> Bool {
+        return callback.testParam(Int16.max)
+    }
+
+    public static func testProtocolReturnType(_ callback: Int16TestReturnTypeProtocol) -> Int16 {
+        return callback.testReturnType()
+    }
+
+    public static func testProtocolOptionalParam(_ callback: Int16TestOptionalParamProtocol) -> Bool {
+        return callback.testOptionalParam(Int16.max)
+    }
+
+    public static func testProtocolOptionalReturnType(_ callback: Int16TestOptionalReturnTypeProtocol) -> Int16? {
+        return callback.testOptionalReturnType()
+    }
+
+    public static func testEncode() ->  Int16TestStruct {
+        return Int16TestStruct()
+    }
+
+    public static func testDecode(_ value: Int16TestStruct) -> Bool {
+        return value == Int16TestStruct()
+    }
+
+
+}