Vladimir Sukharev
1448 lines
51 KiB
Swift
Vendored
1448 lines
51 KiB
Swift
Vendored
/*
|
|
* Copyright 2010-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
|
|
* that can be found in the LICENSE file.
|
|
*/
|
|
|
|
import Foundation
|
|
import Kt
|
|
|
|
// -------- Tests --------
|
|
|
|
func testVals() throws {
|
|
print("Values from Swift")
|
|
let dbl = ValuesKt.dbl
|
|
let flt = ValuesKt.flt
|
|
let int = ValuesKt.integer
|
|
let long = ValuesKt.longInt
|
|
|
|
print(dbl)
|
|
print(flt)
|
|
print(int)
|
|
print(long)
|
|
|
|
try assertEquals(actual: dbl, expected: 3.14 as Double, "Double value isn't equal.")
|
|
try assertEquals(actual: flt, expected: 2.73 as Float, "Float value isn't equal.")
|
|
try assertEquals(actual: int, expected: 42)
|
|
try assertEquals(actual: long, expected: 1984)
|
|
}
|
|
|
|
func testVars() throws {
|
|
print("Variables from Swift")
|
|
var intVar = ValuesKt.intVar
|
|
var strVar = ValuesKt.str
|
|
var strAsId = ValuesKt.strAsAny
|
|
|
|
print(intVar)
|
|
print(strVar)
|
|
print(strAsId)
|
|
|
|
try assertEquals(actual: intVar, expected: 451)
|
|
try assertEquals(actual: strVar, expected: "Kotlin String")
|
|
try assertEquals(actual: strAsId as! String, expected: "Kotlin String as Any")
|
|
|
|
strAsId = "Swift str"
|
|
ValuesKt.strAsAny = strAsId
|
|
print(ValuesKt.strAsAny)
|
|
try assertEquals(actual: ValuesKt.strAsAny as! String, expected: strAsId as! String)
|
|
|
|
// property with custom getter/setter backed by the Kotlin's var
|
|
var intProp : Int32 {
|
|
get {
|
|
return ValuesKt.intVar * 2
|
|
}
|
|
set(value) {
|
|
ValuesKt.intVar = 123 + value
|
|
}
|
|
}
|
|
intProp += 10
|
|
print(intProp)
|
|
print(ValuesKt.intVar)
|
|
try assertEquals(actual: ValuesKt.intVar * 2, expected: intProp, "Property backed by var")
|
|
}
|
|
|
|
func testDoubles() throws {
|
|
print("Doubles in Swift")
|
|
let minDouble = ValuesKt.minDoubleVal as! Double
|
|
let maxDouble = ValuesKt.maxDoubleVal as! NSNumber
|
|
|
|
print(minDouble)
|
|
print(maxDouble)
|
|
print(ValuesKt.nanDoubleVal)
|
|
print(ValuesKt.nanFloatVal)
|
|
print(ValuesKt.infDoubleVal)
|
|
print(ValuesKt.infFloatVal)
|
|
|
|
try assertEquals(actual: minDouble, expected: Double.leastNonzeroMagnitude, "Min double")
|
|
try assertEquals(actual: maxDouble, expected: Double.greatestFiniteMagnitude as NSNumber, "Max double")
|
|
try assertTrue(ValuesKt.nanDoubleVal.isNaN, "NaN double")
|
|
try assertTrue(ValuesKt.nanFloatVal.isNaN, "NaN float")
|
|
try assertEquals(actual: ValuesKt.infDoubleVal, expected: Double.infinity, "Inf double")
|
|
try assertEquals(actual: ValuesKt.infFloatVal, expected: -Float.infinity, "-Inf float")
|
|
}
|
|
|
|
func testNumbers() throws {
|
|
try assertEquals(actual: KotlinBoolean(value: true).boolValue, expected: true)
|
|
try assertEquals(actual: KotlinBoolean(value: false).intValue, expected: 0)
|
|
try assertEquals(actual: KotlinBoolean(value: true), expected: true)
|
|
try assertFalse(KotlinBoolean(value: false) as! Bool)
|
|
|
|
try assertEquals(actual: KotlinByte(value: -1).int8Value, expected: -1)
|
|
try assertEquals(actual: KotlinByte(value: -1).int32Value, expected: -1)
|
|
try assertEquals(actual: KotlinByte(value: -1).doubleValue, expected: -1.0)
|
|
try assertEquals(actual: KotlinByte(value: -1), expected: NSNumber(value: Int64(-1)))
|
|
try assertFalse(KotlinByte(value: -1) == NSNumber(value: -1.5))
|
|
try assertEquals(actual: KotlinByte(value: -1), expected: -1)
|
|
try assertTrue(KotlinByte(value: -1) == -1)
|
|
try assertFalse(KotlinByte(value: -1) == 1)
|
|
try assertEquals(actual: KotlinByte(value: -1) as! Int32, expected: -1)
|
|
|
|
try assertEquals(actual: KotlinShort(value: 111).int16Value, expected: 111)
|
|
try assertEquals(actual: KotlinShort(value: -15) as! Int16, expected: -15)
|
|
try assertEquals(actual: KotlinShort(value: 47), expected: 47)
|
|
|
|
try assertEquals(actual: KotlinInt(value: 99).int32Value, expected: 99)
|
|
try assertEquals(actual: KotlinInt(value: -1) as! Int32, expected: -1)
|
|
try assertEquals(actual: KotlinInt(value: 72), expected: 72)
|
|
|
|
try assertEquals(actual: KotlinLong(value: 65).int64Value, expected: 65)
|
|
try assertEquals(actual: KotlinLong(value: 10000000000) as! Int64, expected: 10000000000)
|
|
try assertEquals(actual: KotlinLong(value: 8), expected: 8)
|
|
|
|
try assertEquals(actual: KotlinUByte(value: 17).uint8Value, expected: 17)
|
|
try assertEquals(actual: KotlinUByte(value: 42) as! UInt8, expected: 42)
|
|
try assertEquals(actual: 88, expected: KotlinUByte(value: 88))
|
|
|
|
try assertEquals(actual: KotlinUShort(value: 40000).uint16Value, expected: 40000)
|
|
try assertEquals(actual: KotlinUShort(value: 1) as! UInt16, expected: UInt16(1))
|
|
try assertEquals(actual: KotlinUShort(value: 65000), expected: 65000)
|
|
|
|
try assertEquals(actual: KotlinUInt(value: 3).uint32Value, expected: 3)
|
|
try assertEquals(actual: KotlinUInt(value: UInt32.max) as! UInt32, expected: UInt32.max)
|
|
try assertEquals(actual: KotlinUInt(value: 2), expected: 2)
|
|
|
|
try assertEquals(actual: KotlinULong(value: 55).uint64Value, expected: 55)
|
|
try assertEquals(actual: KotlinULong(value: 0) as! UInt64, expected: 0)
|
|
try assertEquals(actual: KotlinULong(value: 7), expected: 7)
|
|
|
|
try assertEquals(actual: KotlinFloat(value: 1.0).floatValue, expected: 1.0)
|
|
try assertEquals(actual: KotlinFloat(value: 22.0) as! Float, expected: 22)
|
|
try assertEquals(actual: KotlinFloat(value: 41.0), expected: 41)
|
|
try assertEquals(actual: KotlinFloat(value: -5.5), expected: -5.5)
|
|
|
|
try assertEquals(actual: KotlinDouble(value: 0.5).doubleValue, expected: 0.5)
|
|
try assertEquals(actual: KotlinDouble(value: 45.0) as! Double, expected: 45)
|
|
try assertEquals(actual: KotlinDouble(value: 89.0), expected: 89)
|
|
try assertEquals(actual: KotlinDouble(value: -3.7), expected: -3.7)
|
|
|
|
ValuesKt.ensureEqualBooleans(actual: KotlinBoolean(value: true), expected: true)
|
|
ValuesKt.ensureEqualBooleans(actual: false, expected: false)
|
|
|
|
ValuesKt.ensureEqualBooleansAsAny(actual: true, expected: true)
|
|
ValuesKt.ensureEqualBooleansAsAny(actual: false, expected: false)
|
|
|
|
ValuesKt.ensureEqualBytes(actual: KotlinByte(value: 42), expected: 42)
|
|
ValuesKt.ensureEqualBytes(actual: -11, expected: -11)
|
|
|
|
ValuesKt.ensureEqualShorts(actual: KotlinShort(value: 256), expected: 256)
|
|
ValuesKt.ensureEqualShorts(actual: -1, expected: -1)
|
|
|
|
ValuesKt.ensureEqualInts(actual: KotlinInt(value: 100000), expected: 100000)
|
|
ValuesKt.ensureEqualInts(actual: -7, expected: -7)
|
|
|
|
ValuesKt.ensureEqualLongs(actual: KotlinLong(value: Int64.max), expected: Int64.max)
|
|
ValuesKt.ensureEqualLongs(actual: 17, expected: 17)
|
|
|
|
ValuesKt.ensureEqualUBytes(actual: KotlinUByte(value: 6), expected: 6)
|
|
ValuesKt.ensureEqualUBytes(actual: 255, expected: 255)
|
|
|
|
ValuesKt.ensureEqualUShorts(actual: KotlinUShort(value: 300), expected: 300)
|
|
ValuesKt.ensureEqualUShorts(actual: 65535, expected: UInt16.max)
|
|
|
|
ValuesKt.ensureEqualUInts(actual: KotlinUInt(value: 70000), expected: 70000)
|
|
ValuesKt.ensureEqualUInts(actual: 48, expected: 48)
|
|
|
|
ValuesKt.ensureEqualULongs(actual: KotlinULong(value: UInt64.max), expected: UInt64.max)
|
|
ValuesKt.ensureEqualULongs(actual: 39, expected: 39)
|
|
|
|
ValuesKt.ensureEqualFloats(actual: KotlinFloat(value: 36.6), expected: 36.6)
|
|
ValuesKt.ensureEqualFloats(actual: 49.5, expected: 49.5)
|
|
ValuesKt.ensureEqualFloats(actual: 18, expected: 18.0)
|
|
|
|
ValuesKt.ensureEqualDoubles(actual: KotlinDouble(value: 12.34), expected: 12.34)
|
|
ValuesKt.ensureEqualDoubles(actual: 56.78, expected: 56.78)
|
|
ValuesKt.ensureEqualDoubles(actual: 3, expected: 3)
|
|
|
|
func checkBox<T: Equatable, B : NSObject>(_ value: T, _ boxFunction: (T) -> B?) throws {
|
|
let box = boxFunction(value)!
|
|
try assertEquals(actual: box as! T, expected: value)
|
|
print(type(of: box))
|
|
print(B.self)
|
|
try assertTrue(box.isKind(of: B.self))
|
|
}
|
|
|
|
try checkBox(true, ValuesKt.box)
|
|
try checkBox(Int8(-1), ValuesKt.box)
|
|
try checkBox(Int16(-2), ValuesKt.box)
|
|
try checkBox(Int32(-3), ValuesKt.box)
|
|
try checkBox(Int64(-4), ValuesKt.box)
|
|
try checkBox(UInt8(5), ValuesKt.box)
|
|
try checkBox(UInt16(6), ValuesKt.box)
|
|
try checkBox(UInt32(7), ValuesKt.box)
|
|
try checkBox(UInt64(8), ValuesKt.box)
|
|
try checkBox(Float(8.7), ValuesKt.box)
|
|
try checkBox(Double(9.4), ValuesKt.box)
|
|
}
|
|
|
|
func testLists() throws {
|
|
let numbersList = ValuesKt.numbersList
|
|
let gold = [1, 2, 13]
|
|
for i in 0..<gold.count {
|
|
try assertEquals(actual: gold[i], expected: Int(numbersList[i] as! NSNumber), "Numbers list")
|
|
}
|
|
|
|
let anyList = ValuesKt.anyList
|
|
for i in anyList {
|
|
print(i)
|
|
}
|
|
// try assertEquals(actual: gold, expected: anyList, "Numbers list")
|
|
}
|
|
|
|
func testLazyVal() throws {
|
|
let lazyVal = ValuesKt.lazyVal
|
|
print(lazyVal)
|
|
try assertEquals(actual: lazyVal, expected: "Lazily initialized string", "lazy value")
|
|
}
|
|
|
|
let goldenArray = ["Delegated", "global", "array", "property"]
|
|
|
|
func testDelegatedProp() throws {
|
|
let delegatedGlobalArray = ValuesKt.delegatedGlobalArray
|
|
guard Int(delegatedGlobalArray.size) == goldenArray.count else {
|
|
throw TestError.assertFailed("Size differs")
|
|
}
|
|
for i in 0..<delegatedGlobalArray.size {
|
|
print(delegatedGlobalArray.get(index: i)!)
|
|
}
|
|
}
|
|
|
|
func testGetterDelegate() throws {
|
|
let delegatedList = ValuesKt.delegatedList
|
|
guard delegatedList.count == goldenArray.count else {
|
|
throw TestError.assertFailed("Size differs")
|
|
}
|
|
for val in delegatedList {
|
|
print(val)
|
|
}
|
|
}
|
|
|
|
func testNulls() throws {
|
|
let nilVal : Any? = ValuesKt.nullVal
|
|
try assertTrue(nilVal == nil, "Null value")
|
|
|
|
ValuesKt.nullVar = nil
|
|
var nilVar : Any? = ValuesKt.nullVar
|
|
try assertTrue(nilVar == nil, "Null variable")
|
|
}
|
|
|
|
func testAnyVar() throws {
|
|
let anyVar : Any = ValuesKt.anyValue
|
|
print(anyVar)
|
|
if let str = anyVar as? String {
|
|
print(str)
|
|
try assertEquals(actual: str, expected: "Str")
|
|
} else {
|
|
throw TestError.assertFailed("Incorrect type passed from Any")
|
|
}
|
|
}
|
|
|
|
func testFunctions() throws {
|
|
let _: Any? = ValuesKt.emptyFun()
|
|
|
|
let str = ValuesKt.strFun()
|
|
try assertEquals(actual: str, expected: "fooStr")
|
|
|
|
try assertEquals(actual: ValuesKt.argsFun(i: 10, l: 20, d: 3.5, s: "res") as! String,
|
|
expected: "res10203.5")
|
|
|
|
try assertEquals(actual: ValuesKt.multiply(int: 3, long: 2), expected: 6)
|
|
}
|
|
|
|
class SwiftThrowing : SwiftOverridableMethodsWithThrows {
|
|
class E : Error {}
|
|
|
|
func unit() throws -> Void { throw E() }
|
|
func nothing() throws -> Void { throw E() }
|
|
func any() throws -> Any { throw E() }
|
|
func block() throws -> () -> KotlinInt { throw E() }
|
|
}
|
|
|
|
class TestThrowingConstructorRelease : Throwing {
|
|
static var deinitialized = false
|
|
deinit {
|
|
TestThrowingConstructorRelease.deinitialized = true
|
|
}
|
|
}
|
|
|
|
class SwiftNotThrowing : SwiftOverridableMethodsWithThrows {
|
|
func unit() throws -> Void { }
|
|
func nothing() throws -> Void { throw SwiftThrowing.E() }
|
|
func any() throws -> Any { return 42 as Int32 }
|
|
func block() throws -> () -> KotlinInt { return { 17 } }
|
|
}
|
|
|
|
class SwiftUnitCaller : MethodsWithThrowsUnitCaller {
|
|
func call(methods: MethodsWithThrows) throws -> Void {
|
|
try methods.unit()
|
|
}
|
|
}
|
|
|
|
class SwiftThrowingWithBridge : ThrowsWithBridge {
|
|
override func plusOne(x: Int32) throws -> KotlinInt {
|
|
throw SwiftThrowing.E()
|
|
}
|
|
}
|
|
|
|
class SwiftNotThrowingWithBridge : ThrowsWithBridge {
|
|
override func plusOne(x: Int32) throws -> KotlinInt {
|
|
return KotlinInt(value: x + 1)
|
|
}
|
|
}
|
|
|
|
private func testThrowing(file: String = #file, line: Int = #line, _ block: () throws -> Void) throws {
|
|
try assertFailsWithKotlin(MyException.self, file: file, line: line, block: block)
|
|
}
|
|
|
|
func testExceptions() throws {
|
|
try testThrowing { try ValuesKt.throwException(error: false) }
|
|
do {
|
|
try ValuesKt.throwException(error: true)
|
|
} catch let error as NSError {
|
|
try assertTrue(error.kotlinException is MyError)
|
|
}
|
|
|
|
#if !NOOP_GC
|
|
try assertFalse(TestThrowingConstructorRelease.deinitialized)
|
|
try testThrowing { try TestThrowingConstructorRelease(doThrow: true) }
|
|
ValuesKt.gc()
|
|
try assertTrue(TestThrowingConstructorRelease.deinitialized)
|
|
#endif
|
|
|
|
try testThrowing { try Throwing(doThrow: true) }
|
|
|
|
let throwing = try Throwing(doThrow: false)
|
|
try testThrowing { try throwing.unit() }
|
|
try testThrowing { try throwing.nothing() }
|
|
try testThrowing { try throwing.nothingN() }
|
|
try testThrowing { try throwing.any() }
|
|
try testThrowing { try throwing.anyN() }
|
|
try testThrowing { try throwing.block()() }
|
|
try testThrowing { try throwing.blockN() }
|
|
try testThrowing { try throwing.pointer() }
|
|
try testThrowing { try throwing.pointerN() }
|
|
try testThrowing { try throwing.int() }
|
|
try testThrowing { try throwing.longN() }
|
|
try testThrowing { try throwing.double() }
|
|
|
|
let notThrowing = try NotThrowing()
|
|
|
|
try notThrowing.unit()
|
|
try assertEquals(actual: notThrowing.nothingN(), expected: nil)
|
|
try assertTrue(notThrowing.any() is KotlinBase)
|
|
try assertTrue(notThrowing.anyN() is KotlinBase)
|
|
try assertEquals(actual: notThrowing.block()(), expected: 42)
|
|
try assertTrue(notThrowing.blockN() == nil)
|
|
try assertEquals(actual: Int(bitPattern: notThrowing.pointer()), expected: 1)
|
|
try assertEquals(actual: notThrowing.pointerN(), expected: nil)
|
|
try assertEquals(actual: notThrowing.int(), expected: 42)
|
|
try assertEquals(actual: notThrowing.longN(), expected: nil)
|
|
try assertEquals(actual: notThrowing.double(), expected: 3.14)
|
|
|
|
try ValuesKt.testSwiftThrowing(methods: SwiftThrowing())
|
|
try ValuesKt.testSwiftNotThrowing(methods: SwiftNotThrowing())
|
|
|
|
do {
|
|
try ValuesKt.callUnit(methods: SwiftThrowing())
|
|
} catch let e as SwiftThrowing.E {
|
|
// Ok.
|
|
}
|
|
|
|
try ValuesKt.callUnitCaller(caller: SwiftUnitCaller(), methods: throwing)
|
|
|
|
try ValuesKt.testSwiftThrowing(test: SwiftThrowingWithBridge(), flag: false)
|
|
try ValuesKt.testSwiftThrowing(test: SwiftThrowingWithBridge(), flag: true)
|
|
try ValuesKt.testSwiftNotThrowing(test: SwiftNotThrowingWithBridge())
|
|
}
|
|
|
|
func testFuncType() throws {
|
|
let s = "str"
|
|
let fFunc: () -> String = { return s }
|
|
try assertEquals(actual: ValuesKt.funArgument(foo: fFunc), expected: s, "Using function type arguments failed")
|
|
}
|
|
|
|
func testGenericsFoo() throws {
|
|
let fun = { (i: Int) -> String in return "S \(i)" }
|
|
// wrap lambda to workaround issue with type conversion inability:
|
|
// (Int) -> String can't be cast to (Any?) -> Any?
|
|
let wrapper = { (t: Any?) -> Any? in return fun(t as! Int) }
|
|
let res = ValuesKt.genericFoo(t: 42, foo: wrapper)
|
|
try assertEquals(actual: res as! String, expected: "S 42")
|
|
}
|
|
|
|
func testVararg() throws {
|
|
#if NO_GENERICS
|
|
let ktArray = KotlinArray(size: 3, init: { (_) -> NSNumber in return 42 })
|
|
#else
|
|
let ktArray = KotlinArray<AnyObject>(size: 3, init: { (_) -> NSNumber in return 42 })
|
|
#endif
|
|
let arr: [Int] = ValuesKt.varargToList(args: ktArray) as! [Int]
|
|
try assertEquals(actual: arr, expected: [42, 42, 42])
|
|
}
|
|
|
|
func testStrExtFun() throws {
|
|
try assertEquals(actual: ValuesKt.subExt("String", i: 2), expected: "r")
|
|
try assertEquals(actual: ValuesKt.subExt("A", i: 2), expected: "nothing")
|
|
}
|
|
|
|
func testAnyToString() throws {
|
|
try assertEquals(actual: ValuesKt.toString(nil), expected: "null")
|
|
try assertEquals(actual: ValuesKt.toString(42), expected: "42")
|
|
}
|
|
|
|
func testAnyPrint() throws {
|
|
print("BEGIN")
|
|
ValuesKt.print(nil)
|
|
ValuesKt.print("Print")
|
|
ValuesKt.print(123456789)
|
|
ValuesKt.print(3.14)
|
|
ValuesKt.print([3, 2, 1])
|
|
print("END")
|
|
}
|
|
|
|
func testCharExtensions() throws {
|
|
try assertTrue(ValuesKt.isA(ValuesKt.boxChar(65)))
|
|
try assertFalse(ValuesKt.isA(ValuesKt.boxChar(66)))
|
|
}
|
|
|
|
func testLambda() throws {
|
|
try assertEquals(actual: ValuesKt.sumLambda(3, 4), expected: 7)
|
|
|
|
var blockRuns = 0
|
|
|
|
try assertTrue(ValuesKt.runUnitBlock { blockRuns += 1 })
|
|
try assertEquals(actual: blockRuns, expected: 1)
|
|
|
|
let unitBlock: () -> Void = ValuesKt.asUnitBlock {
|
|
blockRuns += 1
|
|
return 42
|
|
}
|
|
try assertTrue(unitBlock() == Void())
|
|
try assertEquals(actual: blockRuns, expected: 2)
|
|
|
|
let nothingBlock: () -> Void = { blockRuns += 1 }
|
|
ValuesKt.runNothingBlock(block: nothingBlock)
|
|
try assertEquals(actual: blockRuns, expected: 3)
|
|
|
|
try assertTrue(ValuesKt.getNullBlock() == nil)
|
|
try assertTrue(ValuesKt.isBlockNull(block: nil))
|
|
|
|
// Test dynamic conversion:
|
|
let intBlocks = IntBlocksImpl()
|
|
try assertEquals(actual: intBlocks.getPlusOneBlock()(1), expected: 2)
|
|
try assertEquals(actual: intBlocks.callBlock(argument: 2) { KotlinInt(value: $0.int32Value + 2) }, expected: 4)
|
|
|
|
// Test round trip with dynamic conversion:
|
|
let coercedUnitBlock: () -> KotlinUnit = UnitBlockCoercionImpl().coerce { blockRuns += 1 }
|
|
try assertTrue(coercedUnitBlock() === KotlinUnit())
|
|
try assertEquals(actual: blockRuns, expected: 4)
|
|
|
|
let uncoercedUnitBlock: () -> Void = UnitBlockCoercionImpl().uncoerce {
|
|
blockRuns += 1
|
|
return KotlinUnit()
|
|
}
|
|
try assertTrue(uncoercedUnitBlock() == Void())
|
|
try assertEquals(actual: blockRuns, expected: 5)
|
|
|
|
let blockMustBeFunction0: @convention(block) () -> AnyObject? = { return nil }
|
|
try assertTrue(ValuesKt.isFunction(obj: blockMustBeFunction0))
|
|
try assertTrue(ValuesKt.isFunction0(obj: blockMustBeFunction0))
|
|
try assertFalse(ValuesKt.isFunction(obj: NSObject()))
|
|
try assertFalse(ValuesKt.isFunction0(obj: NSObject()))
|
|
|
|
// Test no function class for dynamic conversion:
|
|
let blockAsMissingFunction: @convention(block) (AnyObject?, AnyObject?, AnyObject?, AnyObject?, AnyObject?) -> AnyObject?
|
|
= { return $0 ?? $1 ?? $2 ?? $3 ?? $4 }
|
|
|
|
try assertTrue(ValuesKt.isFunction(obj: blockAsMissingFunction))
|
|
try assertFalse(ValuesKt.isFunction0(obj: blockAsMissingFunction))
|
|
}
|
|
|
|
// -------- Tests for classes and interfaces -------
|
|
class ValIEmptyExt : I {
|
|
func iFun() -> String {
|
|
return "ValIEmptyExt::iFun"
|
|
}
|
|
}
|
|
|
|
class ValIExt : I {
|
|
func iFun() -> String {
|
|
return "ValIExt::iFun"
|
|
}
|
|
}
|
|
|
|
func testInterfaceExtension() throws {
|
|
try assertEquals(actual: ValIEmptyExt().iFun(), expected: "ValIEmptyExt::iFun")
|
|
try assertEquals(actual: ValIExt().iFun(), expected: "ValIExt::iFun")
|
|
}
|
|
|
|
func testClassInstances() throws {
|
|
try assertEquals(actual: OpenClassI().iFun(), expected: "OpenClassI::iFun")
|
|
try assertEquals(actual: DefaultInterfaceExt().iFun(), expected: "I::iFun")
|
|
try assertEquals(actual: FinalClassExtOpen().iFun(), expected: "FinalClassExtOpen::iFun")
|
|
try assertEquals(actual: MultiExtClass().iFun(), expected: "PI::iFun")
|
|
try assertEquals(actual: MultiExtClass().piFun() as! Int, expected: 42)
|
|
try assertEquals(actual: ConstrClass(i: 1, s: "str", a: "Any").iFun(), expected: "OpenClassI::iFun")
|
|
try assertEquals(actual: ExtConstrClass(i: 123).iFun(), expected: "ExtConstrClass::iFun::123-String-AnyS")
|
|
}
|
|
|
|
func testEnum() throws {
|
|
try assertEquals(actual: ValuesKt.passEnum(), expected: Enumeration.answer)
|
|
try assertEquals(actual: ValuesKt.passEnum().enumValue, expected: 42)
|
|
try assertEquals(actual: ValuesKt.passEnum().name, expected: "ANSWER")
|
|
ValuesKt.receiveEnum(e: 1)
|
|
}
|
|
|
|
func testDataClass() throws {
|
|
let f = "1"
|
|
let s = "2"
|
|
let t = "3"
|
|
|
|
#if NO_GENERICS
|
|
let tripleVal = TripleVals(first: f as NSString, second: s as NSString, third: t as NSString)
|
|
#else
|
|
let tripleVal = TripleVals<NSString>(first: f as NSString, second: s as NSString, third: t as NSString)
|
|
#endif
|
|
try assertEquals(actual: tripleVal.first as! String, expected: f, "Data class' value")
|
|
print(tripleVal)
|
|
try assertEquals(actual: String(describing: tripleVal), expected: "TripleVals(first=\(f), second=\(s), third=\(t))")
|
|
|
|
#if NO_GENERICS
|
|
let tripleVar = TripleVars(first: f as NSString, second: s as NSString, third: t as NSString)
|
|
#else
|
|
let tripleVar = TripleVars<NSString>(first: f as NSString, second: s as NSString, third: t as NSString)
|
|
#endif
|
|
try assertEquals(actual: tripleVar.first as! String, expected: f, "Data class' value")
|
|
print(tripleVar)
|
|
try assertEquals(actual: String(describing: tripleVar), expected: "[\(f), \(s), \(t)]")
|
|
|
|
tripleVar.first = t as NSString
|
|
tripleVar.second = f as NSString
|
|
tripleVar.third = s as NSString
|
|
try assertEquals(actual: String(describing: tripleVar), expected: "[\(t), \(f), \(s)]")
|
|
}
|
|
|
|
func testCompanionObj() throws {
|
|
try assertEquals(actual: WithCompanionAndObject.Companion().str, expected: "String")
|
|
try assertEquals(actual: ValuesKt.getCompanionObject().str, expected: "String")
|
|
|
|
let namedFromCompanion = ValuesKt.getCompanionObject().named
|
|
let named = ValuesKt.getNamedObject()
|
|
try assertTrue(named === namedFromCompanion, "Should be the same Named object")
|
|
|
|
try assertEquals(actual: ValuesKt.getNamedObjectInterface().iFun(), expected: named.iFun(), "Named object's method")
|
|
}
|
|
|
|
func testInlineClasses() throws {
|
|
let ic1: Int32 = 42
|
|
let ic1N = ValuesKt.box(ic1: 17)
|
|
let ic2 = "foo"
|
|
let ic2N = "bar"
|
|
#if NO_GENERICS
|
|
let ic3 = TripleVals(first: 1, second: 2, third: 3)
|
|
#else
|
|
let ic3 = TripleVals<NSNumber>(first: 1, second: 2, third: 3)
|
|
#endif
|
|
let ic3N = ValuesKt.box(ic3: nil)
|
|
|
|
try assertEquals(
|
|
actual: ValuesKt.concatenateInlineClassValues(ic1: ic1, ic1N: ic1N, ic2: ic2, ic2N: ic2N, ic3: ic3, ic3N: ic3N),
|
|
expected: "42 17 foo bar TripleVals(first=1, second=2, third=3) null"
|
|
)
|
|
|
|
try assertEquals(
|
|
actual: ValuesKt.concatenateInlineClassValues(ic1: ic1, ic1N: nil, ic2: ic2, ic2N: nil, ic3: nil, ic3N: nil),
|
|
expected: "42 null foo null null null"
|
|
)
|
|
|
|
try assertEquals(actual: ValuesKt.getValue1(ic1), expected: 42)
|
|
try assertEquals(actual: ValuesKt.getValueOrNull1(ic1N) as! Int, expected: 17)
|
|
|
|
try assertEquals(actual: ValuesKt.getValue2(ic2), expected: "foo")
|
|
try assertEquals(actual: ValuesKt.getValueOrNull2(ic2N), expected: "bar")
|
|
|
|
try assertEquals(actual: ValuesKt.getValue3(ic3), expected: ic3)
|
|
try assertEquals(actual: ValuesKt.getValueOrNull3(ic3N), expected: nil)
|
|
}
|
|
|
|
class TestSharedIImpl : NSObject, I {
|
|
func iFun() -> String {
|
|
return "TestSharedIImpl::iFun"
|
|
}
|
|
}
|
|
|
|
func testShared() throws {
|
|
if !ValuesKt.isFreezingEnabled() {
|
|
return;
|
|
}
|
|
func assertFrozen(_ obj: AnyObject) throws {
|
|
try assertTrue(ValuesKt.isFrozen(obj: obj), "isFrozen(\(obj))")
|
|
}
|
|
|
|
func assertNotFrozen(_ obj: AnyObject) throws {
|
|
try assertFalse(ValuesKt.isFrozen(obj: obj), "isFrozen(\(obj))")
|
|
}
|
|
|
|
try assertFrozen(NSObject())
|
|
try assertFrozen(TestSharedIImpl())
|
|
try assertFrozen(ValuesKt.kotlinLambda(block: { return $0 }) as AnyObject)
|
|
try assertNotFrozen(FinalClassExtOpen())
|
|
}
|
|
|
|
class PureSwiftClass {
|
|
}
|
|
|
|
struct PureSwiftStruct {
|
|
var x: Int
|
|
}
|
|
class PureSwiftKotlinInterfaceImpl : I {
|
|
func iFun() -> String {
|
|
return "pure"
|
|
}
|
|
}
|
|
|
|
func testPureSwiftClasses() throws {
|
|
let pureSwiftClass = PureSwiftClass()
|
|
try assertTrue(ValuesKt.same(pureSwiftClass) as? AnyObject === pureSwiftClass)
|
|
|
|
try assertEquals(actual: 123, expected: (ValuesKt.same(PureSwiftStruct(x: 123)) as? PureSwiftStruct)?.x)
|
|
try assertEquals(actual: "pure", expected: ValuesKt.iFunExt(PureSwiftKotlinInterfaceImpl()))
|
|
}
|
|
|
|
func testNames() throws {
|
|
try assertEquals(actual: ValuesKt.PROPERTY_NAME_MUST_NOT_BE_ALTERED_BY_SWIFT, expected: 111)
|
|
try assertEquals(actual: Deeply.NestedType().thirtyTwo, expected: 32)
|
|
#if NO_GENERICS
|
|
try assertEquals(actual: WithGenericDeeply.NestedType().thirtyThree, expected: 33)
|
|
#else
|
|
try assertEquals(actual: WithGenericDeeplyNestedType<AnyObject>().thirtyThree, expected: 33)
|
|
#endif
|
|
try assertEquals(actual: CKeywords(float: 1.0, enum : 42, goto: true).goto_, expected: true)
|
|
try assertEquals(actual: TypeOuter.Type_().thirtyFour, expected: 34)
|
|
try assertTrue(String(describing: DeeplyNestedIType.self).hasSuffix("DeeplyNestedIType"))
|
|
}
|
|
|
|
class Base123 : Base23, ExtendedBase1 {
|
|
override func same(value: KotlinInt?) -> KotlinInt {
|
|
return value!
|
|
}
|
|
}
|
|
|
|
func testSwiftOverride() throws {
|
|
let impl = Base123()
|
|
try assertEquals(actual: ValuesKt.call(base1: impl, value: 1), expected: 1)
|
|
try assertEquals(actual: ValuesKt.call(extendedBase1: impl, value: 2), expected: 2)
|
|
try assertEquals(actual: ValuesKt.call(base2: impl, value: 3), expected: 3)
|
|
try assertEquals(actual: ValuesKt.call(base3: impl, value: 4), expected: 4)
|
|
try assertEquals(actual: ValuesKt.call(base23: impl, value: 5), expected: 5)
|
|
}
|
|
|
|
class TransformIntToLongCallingSuper : TransformIntToLong {
|
|
override func map(value: KotlinInt) -> KotlinLong {
|
|
return super.map(value: value)
|
|
}
|
|
}
|
|
|
|
func testKotlinOverride() throws {
|
|
#if NO_GENERICS
|
|
try assertEquals(actual: TransformInheritingDefault().map(value: 1) as! Int32, expected: 1)
|
|
#else
|
|
try assertEquals(actual: TransformInheritingDefault<NSNumber>().map(value: 1) as! Int32, expected: 1)
|
|
#endif
|
|
try assertEquals(actual: TransformIntToDecimalString().map(value: 2), expected: "2")
|
|
try assertEquals(actual: TransformIntToDecimalString().map(intValue: 3), expected: "3")
|
|
try assertEquals(actual: ValuesKt.createTransformDecimalStringToInt().map(value: "4") as! Int32, expected: 4)
|
|
try assertEquals(actual: TransformIntToLongCallingSuper().map(value: 5), expected: 5)
|
|
}
|
|
|
|
// See https://github.com/JetBrains/kotlin-native/issues/2945
|
|
func testGH2945() throws {
|
|
let gh2945 = GH2945(errno: 1)
|
|
try assertEquals(actual: 1, expected: gh2945.errno)
|
|
gh2945.errno = 2
|
|
try assertEquals(actual: 2, expected: gh2945.errno)
|
|
|
|
try assertEquals(actual: 7, expected: gh2945.testErrnoInSelector(p: 3, errno: 4))
|
|
}
|
|
|
|
// See https://github.com/JetBrains/kotlin-native/issues/2830
|
|
func testGH2830() throws {
|
|
try assertTrue(GH2830().getI() is GH2830I)
|
|
}
|
|
|
|
// See https://github.com/JetBrains/kotlin-native/issues/2959
|
|
func testGH2959() throws {
|
|
try assertEquals(actual: GH2959().getI(id: 2959)[0].id, expected: 2959)
|
|
}
|
|
|
|
func testKClass() throws {
|
|
let test = TestKClass()
|
|
|
|
let testKClass = test.getKotlinClass(clazz: TestKClass.self)!
|
|
try assertTrue(test.isTestKClass(kClass: testKClass))
|
|
try assertFalse(test.isI(kClass: testKClass))
|
|
try assertEquals(actual: testKClass.simpleName, expected: "TestKClass")
|
|
|
|
let iKClass = test.getKotlinClass(protocol: TestKClassI.self)!
|
|
try assertFalse(test.isTestKClass(kClass: iKClass))
|
|
try assertTrue(test.isI(kClass: iKClass))
|
|
try assertEquals(actual: iKClass.simpleName, expected: "I")
|
|
|
|
try assertTrue(test.getKotlinClass(clazz: NSObject.self) == nil)
|
|
try assertTrue(test.getKotlinClass(clazz: PureSwiftClass.self) == nil)
|
|
try assertTrue(test.getKotlinClass(clazz: PureSwiftKotlinInterfaceImpl.self) == nil)
|
|
try assertTrue(test.getKotlinClass(clazz: Base123.self) == nil)
|
|
|
|
try assertTrue(test.getKotlinClass(protocol: NSObjectProtocol.self) == nil)
|
|
}
|
|
|
|
open class TestSR10177WorkaroundBase<T> {}
|
|
class TestSR10177WorkaroundDerived : TestSR10177WorkaroundBase<TestSR10177Workaround> {}
|
|
|
|
// See https://bugs.swift.org/browse/SR-10177 and https://bugs.swift.org/browse/SR-10217
|
|
func testSR10177Workaround() throws {
|
|
let test = TestSR10177WorkaroundDerived()
|
|
try assertTrue(String(describing: test).contains("TestSR10177WorkaroundDerived"))
|
|
}
|
|
|
|
func testClashes() throws {
|
|
let test = TestClashesImpl()
|
|
let test1: TestClashes1 = test
|
|
let test2: TestClashes2 = test
|
|
|
|
try assertEquals(actual: 1, expected: test1.clashingProperty)
|
|
|
|
#if !DISABLE_MEMBER_NAME_MANGLING && !DISABLE_INTERFACE_METHOD_NAME_MANGLING
|
|
try assertEquals(actual: 1, expected: test2.clashingProperty_ as! Int32)
|
|
try assertEquals(actual: 2, expected: test2.clashingProperty__ as! Int32)
|
|
#endif
|
|
}
|
|
|
|
func testInvalidIdentifiers() throws {
|
|
let test = TestInvalidIdentifiers()
|
|
|
|
try assertEquals(actual: 42, expected: test.aSdSd(S1: 13, _2: 14, _3: 15))
|
|
|
|
try assertEquals(actual: TestInvalidIdentifiers.E._4s.value, expected: 4)
|
|
try assertEquals(actual: TestInvalidIdentifiers.E._5s.value, expected: 5)
|
|
try assertEquals(actual: TestInvalidIdentifiers.E.__.value, expected: 6)
|
|
try assertEquals(actual: TestInvalidIdentifiers.E.___.value, expected: 7)
|
|
|
|
try assertEquals(actual: TestInvalidIdentifiers.CompanionS()._42, expected: 42)
|
|
|
|
#if !DISABLE_MEMBER_NAME_MANGLING
|
|
try assertEquals(actual: Set([test.__, test.___]), expected: Set(["_".utf16.first, "_".utf16.first]))
|
|
#endif
|
|
}
|
|
|
|
class ImplementingHiddenSubclass : TestDeprecation.ImplementingHidden {
|
|
override func effectivelyHidden() -> Int32 {
|
|
return -2
|
|
}
|
|
}
|
|
|
|
func testDeprecation() throws {
|
|
let test = TestDeprecation()
|
|
try assertEquals(actual: test.openNormal(), expected: 1)
|
|
|
|
let testHiddenOverride: TestDeprecation = TestDeprecation.HiddenOverride()
|
|
try assertEquals(actual: testHiddenOverride.openNormal(), expected: 2)
|
|
|
|
let testErrorOverride: TestDeprecation = TestDeprecation.ErrorOverride()
|
|
try assertEquals(actual: testErrorOverride.openNormal(), expected: 3)
|
|
|
|
let testWarningOverride: TestDeprecation = TestDeprecation.WarningOverride()
|
|
try assertEquals(actual: testWarningOverride.openNormal(), expected: 4)
|
|
|
|
try assertEquals(actual: test.callEffectivelyHidden(obj: ImplementingHiddenSubclass()), expected: -2)
|
|
}
|
|
|
|
func setAssociatedObject(object: AnyObject, value: AnyObject) {
|
|
objc_setAssociatedObject(
|
|
object,
|
|
UnsafeRawPointer(bitPattern: 1)!,
|
|
value,
|
|
objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN
|
|
)
|
|
}
|
|
|
|
func testWeakRefs() throws {
|
|
#if !NOOP_GC
|
|
try testWeakRefs0(frozen: false)
|
|
try testWeakRefs0(frozen: true)
|
|
#endif
|
|
}
|
|
|
|
func testWeakRefs0(frozen: Bool) throws {
|
|
func getObj(test: TestWeakRefs) -> AnyObject {
|
|
return autoreleasepool { test.getObj() as AnyObject }
|
|
}
|
|
|
|
func test1() throws {
|
|
var test = TestWeakRefs(frozen: frozen)
|
|
|
|
var obj: AnyObject? = getObj(test: test)
|
|
weak var ref = getObj(test: test)
|
|
|
|
ValuesKt.gc()
|
|
try assertTrue(ref === getObj(test: test)) // There are both Kotlin and Swift references to the object.
|
|
|
|
obj = nil
|
|
ValuesKt.gc()
|
|
try assertTrue(ref === getObj(test: test)) // There are only Kotlin references to the object.
|
|
|
|
test.clearObj()
|
|
ValuesKt.gc()
|
|
try assertTrue(ref === nil)
|
|
}
|
|
|
|
func test2() throws {
|
|
var test = TestWeakRefs(frozen: frozen)
|
|
|
|
var obj: AnyObject? = getObj(test: test)
|
|
weak var ref = getObj(test: test)
|
|
|
|
ValuesKt.gc()
|
|
try assertTrue(ref === obj!) // There are both Kotlin and Swift references to the object.
|
|
|
|
test.clearObj()
|
|
ValuesKt.gc()
|
|
try assertTrue(ref === obj!) // There are only Swift references to the object.
|
|
|
|
obj = nil
|
|
ValuesKt.gc()
|
|
try assertTrue(ref === nil)
|
|
}
|
|
|
|
func test3() throws {
|
|
class Holder {
|
|
static weak var ref: AnyObject? = nil
|
|
static var deinitialized = false
|
|
|
|
deinit {
|
|
// Access weak ref to Kotlin object during its counterpart dealloc:
|
|
try! assertTrue(Holder.ref === nil)
|
|
Holder.deinitialized = true
|
|
}
|
|
}
|
|
|
|
Holder.deinitialized = false
|
|
Holder.ref = nil
|
|
|
|
var test = TestWeakRefs(frozen: frozen)
|
|
|
|
Holder.ref = getObj(test: test)
|
|
|
|
// Prepare Holder() to get deinitialized along with getObj(test: test):
|
|
setAssociatedObject(
|
|
object: getObj(test: test),
|
|
value: Holder()
|
|
)
|
|
|
|
try assertFalse(Holder.ref === nil)
|
|
try assertFalse(Holder.deinitialized)
|
|
|
|
test.clearObj()
|
|
ValuesKt.gc()
|
|
|
|
try assertTrue(Holder.ref === nil)
|
|
try assertTrue(Holder.deinitialized)
|
|
}
|
|
|
|
func test4() throws {
|
|
class Holder {
|
|
static weak var ref1: AnyObject? = nil
|
|
static weak var ref2: AnyObject? = nil
|
|
static var deinitialized: Int = 0
|
|
|
|
deinit {
|
|
// Access weak ref to Kotlin object during its counterpart dealloc:
|
|
try! assertTrue(Holder.ref1 === nil)
|
|
try! assertTrue(Holder.ref2 === nil)
|
|
Holder.deinitialized += 1
|
|
}
|
|
}
|
|
|
|
Holder.deinitialized = 0
|
|
Holder.ref1 = nil
|
|
Holder.ref2 = nil
|
|
|
|
var test = TestWeakRefs(frozen: frozen)
|
|
|
|
autoreleasepool {
|
|
let cycle = test.createCycle()
|
|
|
|
let obj1 = cycle[0] as AnyObject
|
|
let obj2 = cycle[1] as AnyObject
|
|
|
|
// Prepare Holders to get deinitialized along with obj1 and obj2:
|
|
setAssociatedObject(object: obj1, value: Holder())
|
|
setAssociatedObject(object: obj2, value: Holder())
|
|
|
|
Holder.ref1 = obj1
|
|
Holder.ref2 = obj2
|
|
}
|
|
|
|
ValuesKt.gc()
|
|
|
|
try assertTrue(Holder.ref1 === nil)
|
|
try assertTrue(Holder.ref2 === nil)
|
|
try assertEquals(actual: Holder.deinitialized, expected: 2)
|
|
}
|
|
|
|
try test1()
|
|
try test2()
|
|
try test3()
|
|
try test4()
|
|
}
|
|
|
|
var falseFlag = false
|
|
|
|
class TestSharedRefs {
|
|
private func testLambdaSimple() throws {
|
|
func getClosure() -> (() -> Void) {
|
|
let lambda = autoreleasepool {
|
|
SharedRefs().createLambda()
|
|
}
|
|
return { if falseFlag { lambda() } }
|
|
}
|
|
|
|
DispatchQueue.global().async(execute: getClosure())
|
|
}
|
|
|
|
private static func launchInNewThread(initializeKotlinRuntime: Bool, block: @escaping () -> Void) -> pthread_t {
|
|
class Closure {
|
|
static var currentBlock: (() -> Void)? = nil
|
|
static var initializeKotlinRuntime: Bool = false
|
|
}
|
|
|
|
Closure.currentBlock = block
|
|
Closure.initializeKotlinRuntime = initializeKotlinRuntime
|
|
|
|
var thread: pthread_t? = nil
|
|
let createCode = pthread_create(&thread, nil, { _ in
|
|
if Closure.initializeKotlinRuntime {
|
|
let ignore = SharedRefs() // Ensures that Kotlin runtime gets initialized.
|
|
}
|
|
|
|
// Take the block from Closure to avoid races when block() execution triggers
|
|
// calling launchInNewThread on another thread (e.g. on the finalizer thread).
|
|
let block = Closure.currentBlock!
|
|
Closure.currentBlock = nil
|
|
|
|
block()
|
|
|
|
return nil
|
|
}, nil)
|
|
try! assertEquals(actual: createCode, expected: 0)
|
|
return thread!
|
|
}
|
|
|
|
private static func joinThread(thread: pthread_t) {
|
|
let joinCode = pthread_join(thread, nil)
|
|
try! assertEquals(actual: joinCode, expected: 0)
|
|
}
|
|
|
|
private static func runInNewThread(initializeKotlinRuntime: Bool, block: @escaping () -> Void) {
|
|
let thread = launchInNewThread(initializeKotlinRuntime: initializeKotlinRuntime, block: block)
|
|
joinThread(thread: thread)
|
|
}
|
|
|
|
private func runInNewThread(initializeKotlinRuntime: Bool, block: @escaping () -> Void) {
|
|
return TestSharedRefs.runInNewThread(initializeKotlinRuntime: initializeKotlinRuntime, block: block)
|
|
}
|
|
|
|
private func testObjectPartialRelease() {
|
|
let object = autoreleasepool { SharedRefs().createRegularObject() }
|
|
var objectVar: AnyObject? = object
|
|
|
|
runInNewThread(initializeKotlinRuntime: true) {
|
|
objectVar = nil
|
|
}
|
|
}
|
|
|
|
private func testRunRefCount<T>(
|
|
run: (@escaping () -> Void) -> Void,
|
|
createObject: @escaping (SharedRefs) -> T
|
|
) throws {
|
|
let refs = SharedRefs()
|
|
|
|
var objectVar1: T? = autoreleasepool { createObject(refs) }
|
|
var objectVar2: T? = nil
|
|
|
|
try assertTrue(refs.hasAliveObjects())
|
|
|
|
run {
|
|
objectVar2 = objectVar1!
|
|
objectVar1 = nil
|
|
}
|
|
|
|
try assertTrue(refs.hasAliveObjects())
|
|
|
|
run {
|
|
objectVar2 = nil
|
|
}
|
|
|
|
try assertFalse(refs.hasAliveObjects())
|
|
}
|
|
|
|
private func testBackgroundRefCount<T>(createObject: @escaping (SharedRefs) -> T) throws {
|
|
try testRunRefCount(
|
|
run: { runInNewThread(initializeKotlinRuntime: false, block: $0) },
|
|
createObject: createObject
|
|
)
|
|
|
|
try testRunRefCount(
|
|
run: { runInNewThread(initializeKotlinRuntime: true, block: $0) },
|
|
createObject: createObject
|
|
)
|
|
}
|
|
|
|
private func testReferenceOutlivesThread(releaseWithKotlinRuntime: Bool) throws {
|
|
var objectVar: AnyObject? = nil
|
|
weak var objectWeakVar: AnyObject? = nil
|
|
var collection: AnyObject? = nil
|
|
|
|
runInNewThread(initializeKotlinRuntime: false) {
|
|
autoreleasepool {
|
|
let refs = SharedRefs()
|
|
collection = refs.createCollection()
|
|
|
|
let object = refs.createRegularObject()
|
|
objectVar = object
|
|
objectWeakVar = object
|
|
|
|
try! assertTrue(objectWeakVar === object)
|
|
}
|
|
}
|
|
|
|
runInNewThread(initializeKotlinRuntime: releaseWithKotlinRuntime) {
|
|
objectVar = nil
|
|
collection = nil
|
|
ValuesKt.gc()
|
|
try! assertTrue(objectWeakVar === nil)
|
|
}
|
|
|
|
}
|
|
|
|
private func testMoreWorkBeforeThreadExit() throws {
|
|
class Deinit {
|
|
static var object1: AnyObject? = nil
|
|
static var object2: AnyObject? = nil
|
|
static weak var weakVar2: AnyObject? = nil
|
|
|
|
deinit {
|
|
TestSharedRefs.runInNewThread(initializeKotlinRuntime: false) {
|
|
Deinit.object2 = nil
|
|
}
|
|
}
|
|
}
|
|
|
|
runInNewThread(initializeKotlinRuntime: false) {
|
|
autoreleasepool {
|
|
let object1 = SharedRefs.MutableData()
|
|
Deinit.object1 = object1
|
|
setAssociatedObject(object: object1, value: Deinit())
|
|
|
|
let object2 = SharedRefs.MutableData()
|
|
Deinit.object2 = object2
|
|
Deinit.weakVar2 = object2
|
|
}
|
|
|
|
TestSharedRefs.runInNewThread(initializeKotlinRuntime: false) {
|
|
Deinit.object1 = nil
|
|
}
|
|
}
|
|
|
|
// This will free `object1` and release+dealloc its associated `Deinit` which nils `Deinit.object2`
|
|
ValuesKt.gc()
|
|
// This will free `object2`.
|
|
ValuesKt.gc()
|
|
|
|
try assertTrue(Deinit.weakVar2 === nil)
|
|
}
|
|
|
|
func testRememberNewObject(createObject: @escaping (SharedRefs) -> AnyObject) throws {
|
|
|
|
class TestImpl : TestRememberNewObject {
|
|
let cleanupFinishedSemaphore = DispatchSemaphore(value: 0)
|
|
let threadWaitingForCleanupSemaphore = DispatchSemaphore(value: 0)
|
|
|
|
var obj: AnyObject? = nil
|
|
|
|
func getObject() -> Any {
|
|
return obj!
|
|
}
|
|
|
|
func waitForCleanup() {
|
|
threadWaitingForCleanupSemaphore.signal()
|
|
cleanupFinishedSemaphore.wait()
|
|
}
|
|
}
|
|
|
|
let test = TestImpl()
|
|
|
|
let refs = SharedRefs()
|
|
try assertFalse(refs.hasAliveObjects())
|
|
|
|
autoreleasepool {
|
|
test.obj = createObject(refs)
|
|
}
|
|
|
|
try assertTrue(refs.hasAliveObjects())
|
|
|
|
let thread = TestSharedRefs.launchInNewThread(initializeKotlinRuntime: false) {
|
|
ValuesKt.testRememberNewObject(test: test)
|
|
}
|
|
|
|
test.threadWaitingForCleanupSemaphore.wait()
|
|
test.obj = nil
|
|
ValuesKt.gc()
|
|
|
|
try assertTrue(refs.hasAliveObjects())
|
|
|
|
test.cleanupFinishedSemaphore.signal()
|
|
|
|
TestSharedRefs.joinThread(thread: thread)
|
|
try assertFalse(refs.hasAliveObjects())
|
|
}
|
|
|
|
// Based on https://youtrack.jetbrains.com/issue/KT-49497.
|
|
|
|
func testKT49497() throws {
|
|
var model: KT49497Model? = nil
|
|
|
|
for i in 1...10 {
|
|
model = KT49497Model() // Frozen and has a reference to itself, so becomes aggregating frozen container.
|
|
ValuesKt.gc() // Just in case, to ensure there are no other references except `model`.
|
|
|
|
runInNewThread(initializeKotlinRuntime: false) {
|
|
// Thread has no runtime initialized, so this should enqueue release ref to the original thread:
|
|
model = nil
|
|
}
|
|
|
|
ValuesKt.gc() // Process the enqueued release ref.
|
|
}
|
|
}
|
|
|
|
func test() throws {
|
|
try testLambdaSimple()
|
|
try testObjectPartialRelease()
|
|
|
|
#if !NOOP_GC
|
|
try testBackgroundRefCount(createObject: { $0.createLambda() })
|
|
try testBackgroundRefCount(createObject: { $0.createRegularObject() })
|
|
try testBackgroundRefCount(createObject: { $0.createCollection() })
|
|
|
|
try testBackgroundRefCount(createObject: { $0.createFrozenLambda() })
|
|
try testBackgroundRefCount(createObject: { $0.createFrozenRegularObject() })
|
|
try testBackgroundRefCount(createObject: { $0.createFrozenCollection() })
|
|
|
|
try testReferenceOutlivesThread(releaseWithKotlinRuntime: false)
|
|
try testReferenceOutlivesThread(releaseWithKotlinRuntime: true)
|
|
try testMoreWorkBeforeThreadExit()
|
|
|
|
try testRememberNewObject(createObject: { $0.createFrozenRegularObject() })
|
|
try testRememberNewObject(createObject: { $0.createFrozenCollection() })
|
|
#endif
|
|
|
|
try testKT49497()
|
|
|
|
usleep(300 * 1000)
|
|
}
|
|
}
|
|
|
|
// See https://github.com/JetBrains/kotlin-native/issues/2931
|
|
func testGH2931() throws {
|
|
for i in 0..<50000 {
|
|
let holder = GH2931.Holder()
|
|
let queue = DispatchQueue.global(qos: .background)
|
|
let group = DispatchGroup()
|
|
|
|
for j in 0..<2 {
|
|
group.enter()
|
|
queue.async {
|
|
autoreleasepool {
|
|
holder.data
|
|
}
|
|
group.leave()
|
|
}
|
|
}
|
|
|
|
group.wait()
|
|
}
|
|
}
|
|
|
|
class ClassForTypeCheckInheritor : ClassForTypeCheck { }
|
|
|
|
func testClassTypeCheck() throws {
|
|
try assertTrue(ValuesKt.testClassTypeCheck(x: ClassForTypeCheckInheritor()))
|
|
}
|
|
|
|
class ClassForInterfaceTypeCheckInheritor1 : InterfaceForTypeCheck { }
|
|
class ClassForInterfaceTypeCheckInheritor2 : Base23, InterfaceForTypeCheck { }
|
|
class ClassForInterfaceTypeCheckInheritor3 : Base23, ExtendedBase1, InterfaceForTypeCheck { }
|
|
class ClassForInterfaceTypeCheck_Fail : Base23 { }
|
|
|
|
func testInterfaceTypeCheck() throws {
|
|
try assertTrue(ValuesKt.testInterfaceTypeCheck(x: ClassForInterfaceTypeCheckInheritor1()))
|
|
try assertTrue(ValuesKt.testInterfaceTypeCheck(x: ClassForInterfaceTypeCheckInheritor2()))
|
|
try assertTrue(ValuesKt.testInterfaceTypeCheck(x: ClassForInterfaceTypeCheckInheritor3()))
|
|
try assertFalse(ValuesKt.testInterfaceTypeCheck(x: ClassForInterfaceTypeCheck_Fail()))
|
|
}
|
|
|
|
class AbstractInterface : AbstractInterfaceBase {
|
|
override func bar() -> Int32 {
|
|
return 42
|
|
}
|
|
}
|
|
|
|
// See https://github.com/JetBrains/kotlin-native/issues/3503
|
|
func testGH3503_1() throws {
|
|
try assertEquals(actual: ValuesKt.testAbstractInterfaceCall(x: AbstractInterface()), expected: 42)
|
|
}
|
|
|
|
class AbstractInterface2 : AbstractInterfaceBase2 {
|
|
|
|
}
|
|
|
|
func testGH3503_2() throws {
|
|
try assertEquals(actual: ValuesKt.testAbstractInterfaceCall2(x: AbstractInterface2()), expected: 42)
|
|
}
|
|
|
|
class AbstractInterface3 : AbstractInterfaceBase3 {
|
|
override func foo() -> Int32 {
|
|
return 42
|
|
}
|
|
}
|
|
|
|
func testGH3503_3() throws {
|
|
try assertEquals(actual: ValuesKt.testAbstractInterfaceCall(x: AbstractInterface3()), expected: 42)
|
|
}
|
|
|
|
func testGH3525() throws {
|
|
try assertEquals(actual: ValuesKt.gh3525BaseInitCount, expected: 0)
|
|
try assertEquals(actual: ValuesKt.gh3525InitCount, expected: 0)
|
|
|
|
let gh3525_1 = GH3525()
|
|
try assertTrue(gh3525_1 is GH3525)
|
|
|
|
try assertEquals(actual: ValuesKt.gh3525BaseInitCount, expected: 1)
|
|
try assertEquals(actual: ValuesKt.gh3525InitCount, expected: 1)
|
|
|
|
let gh3525_2 = GH3525()
|
|
try assertTrue(gh3525_2 is GH3525)
|
|
|
|
try assertEquals(actual: ValuesKt.gh3525BaseInitCount, expected: 1)
|
|
try assertEquals(actual: ValuesKt.gh3525InitCount, expected: 1)
|
|
|
|
try assertTrue(gh3525_1 === gh3525_2)
|
|
}
|
|
|
|
func testStringConversion() throws {
|
|
func test1() throws {
|
|
let test = TestStringConversion()
|
|
|
|
let buffer = NSMutableString()
|
|
buffer.append("a")
|
|
test.str = buffer
|
|
buffer.append("b")
|
|
|
|
try assertEquals(actual: buffer, expected: "ab")
|
|
// Ensure test.str isn't affected by buffer mutation:
|
|
try assertEquals(actual: test.str as! NSString, expected: "a")
|
|
}
|
|
|
|
func ensureNoCopy(nsStr: NSString) throws {
|
|
let test = TestStringConversion()
|
|
|
|
test.str = nsStr
|
|
let nsStr2 = test.str as! NSString
|
|
|
|
// Ensure no additional NSString created on both conversions:
|
|
try assertTrue(nsStr === nsStr2)
|
|
}
|
|
|
|
func test2() throws {
|
|
var str = "a"
|
|
str += NSObject().description
|
|
try ensureNoCopy(nsStr: str as NSString)
|
|
|
|
try ensureNoCopy(nsStr: NSString("abc"))
|
|
|
|
try ensureNoCopy(nsStr: NSString(format: "%d%d%d", 3, 2, 1))
|
|
}
|
|
|
|
try test1()
|
|
try test2()
|
|
}
|
|
|
|
class GH3825SwiftImpl : GH3825 {
|
|
class E : Error {}
|
|
|
|
func call0(callback: () -> KotlinBoolean) throws {
|
|
if callback().boolValue { throw E() }
|
|
}
|
|
|
|
func call1(doThrow: Bool, callback: () -> Void) throws {
|
|
if doThrow { throw E() }
|
|
callback()
|
|
}
|
|
|
|
func call2(callback: () -> Void, doThrow: Bool) throws {
|
|
if doThrow { throw E() }
|
|
callback()
|
|
}
|
|
}
|
|
|
|
func testGH3825() throws {
|
|
try ValuesKt.testGH3825(gh3825: GH3825SwiftImpl())
|
|
|
|
let test = GH3825KotlinImpl()
|
|
var count = 0
|
|
|
|
try testThrowing { try test.call0 { true } }
|
|
try test.call0 {
|
|
count += 1
|
|
return false
|
|
}
|
|
try assertEquals(actual: count, expected: 1)
|
|
|
|
try testThrowing { try test.call1(doThrow: true) { count += 1 } }
|
|
try test.call1(doThrow: false) { count += 1 }
|
|
try assertEquals(actual: count, expected: 2)
|
|
|
|
try testThrowing { try test.call2(callback: { count += 1 }, doThrow: true)}
|
|
try test.call2(callback: { count += 1 }, doThrow: false)
|
|
try assertEquals(actual: count, expected: 3)
|
|
}
|
|
|
|
|
|
func testMapsExport() throws {
|
|
// Original reproducer failed in different way for MutableMap (iOS 11) and Map (MacOS 10.14, iOS 13)
|
|
|
|
try assertEquals(actual: ValuesKt.mapBoolean2String()[true], expected: "true")
|
|
try assertEquals(actual: ValuesKt.mapByte2Short()[-1], expected: 2)
|
|
try assertEquals(actual: ValuesKt.mapShort2Byte()[-2], expected: 1)
|
|
try assertEquals(actual: ValuesKt.mapInt2Long()[-4], expected: 8)
|
|
try assertEquals(actual: ValuesKt.mapLong2Long()[-8], expected: 8)
|
|
try assertEquals(actual: ValuesKt.mapUByte2Boolean()[128], expected: true)
|
|
try assertEquals(actual: ValuesKt.mapUShort2Byte()[0x8000], expected: 1)
|
|
try assertEquals(actual: ValuesKt.mapUInt2Long()[0x7FFFFFFF], expected: 7)
|
|
// the following samples require explicit cast to KotlinUInt or KotlinULong
|
|
try assertEquals(actual: ValuesKt.mapUInt2Long()[KotlinUInt(-0x8000_0000)], expected: 8)
|
|
_ = ValuesKt.mapULong2Long() as! [KotlinULong: KotlinLong] // test cast
|
|
var u64: UInt64 = 0x8000_0000_0000_0000
|
|
try assertEquals(actual: ValuesKt.mapULong2Long()[KotlinULong(value: u64)], expected: 8)
|
|
|
|
_ = ValuesKt.mapFloat2Float() as! [KotlinFloat: KotlinFloat] // test cast
|
|
try assertEquals(actual: ValuesKt.mapFloat2Float()[3.14], expected: 100.0)
|
|
try assertEquals(actual: ValuesKt.mapDouble2String()[2.718281828459045], expected: "2.718281828459045")
|
|
|
|
// test also explicit cast to [:] of primitiva types, e.g. [Int: Int]
|
|
try assertEquals(actual: (ValuesKt.mutBoolean2String() as! [Bool: String])[true], expected: "true")
|
|
try assertEquals(actual: (ValuesKt.mutByte2Short() as! [Int8: Int16])[-1], expected: 2)
|
|
try assertEquals(actual: (ValuesKt.mutShort2Byte() as! [Int16: Int8])[-2], expected: 1)
|
|
try assertEquals(actual: (ValuesKt.mutInt2Long() as! [Int: Int64])[-4], expected: 8)
|
|
try assertEquals(actual: (ValuesKt.mutLong2Long() as! [Int64: Int64])[-8], expected: 8)
|
|
|
|
try assertEquals(actual: (ValuesKt.mutUByte2Boolean() as! [UInt8: Bool])[128], expected: true)
|
|
try assertEquals(actual: (ValuesKt.mutUShort2Byte() as! [UInt16: Int8])[0x8000], expected: 1)
|
|
// the following samples require explicit cast to KotlinUInt or KotlinULong
|
|
try assertEquals(actual: (ValuesKt.mutUInt2Long() as! [UInt: Int64])[UInt(0x8000_0000)], expected: 8)
|
|
|
|
try assertEquals(actual: (ValuesKt.mutULong2Long() as! [UInt64: Int64])[u64], expected: 8)
|
|
|
|
try assertEquals(actual: (ValuesKt.mutFloat2Float() as! [Float: Float])[3.14], expected: 100.0)
|
|
try assertEquals(actual: (ValuesKt.mutDouble2String() as! [Double: String])[2.718281828459045], expected: "2.718281828459045")
|
|
}
|
|
|
|
class Baz_FakeOverrideInInterface : Bar_FakeOverrideInInterface {
|
|
func foo(t: Any?) {}
|
|
}
|
|
|
|
func testFakeOverrideInInterface() throws {
|
|
ValuesKt.callFoo_FakeOverrideInInterface(obj: Baz_FakeOverrideInInterface())
|
|
}
|
|
|
|
// -------- Execution of the test --------
|
|
|
|
class ValuesTests : SimpleTestProvider {
|
|
override init() {
|
|
super.init()
|
|
|
|
test("TestValues", testVals)
|
|
test("TestVars", testVars)
|
|
test("TestDoubles", testDoubles)
|
|
test("TestNumbers", testNumbers)
|
|
test("TestLists", testLists)
|
|
test("TestLazyValues", testLazyVal)
|
|
test("TestDelegatedProperties", testDelegatedProp)
|
|
test("TestGetterDelegate", testGetterDelegate)
|
|
test("TestNulls", testNulls)
|
|
test("TestAnyVar", testAnyVar)
|
|
test("TestFunctions", testFunctions)
|
|
test("TestExceptions", testExceptions)
|
|
test("TestFuncType", testFuncType)
|
|
test("TestGenericsFoo", testGenericsFoo)
|
|
test("TestVararg", testVararg)
|
|
test("TestStringExtension", testStrExtFun)
|
|
test("TestAnyToString", testAnyToString)
|
|
test("TestAnyPrint", testAnyPrint)
|
|
test("TestCharExtensions", testCharExtensions)
|
|
test("TestLambda", testLambda)
|
|
test("TestInterfaceExtension", testInterfaceExtension)
|
|
test("TestClassInstances", testClassInstances)
|
|
test("TestEnum", testEnum)
|
|
test("TestDataClass", testDataClass)
|
|
test("TestCompanionObj", testCompanionObj)
|
|
test("TestInlineClasses", testInlineClasses)
|
|
test("TestShared", testShared)
|
|
test("TestPureSwiftClasses", testPureSwiftClasses)
|
|
test("TestNames", testNames)
|
|
test("TestSwiftOverride", testSwiftOverride)
|
|
test("TestKotlinOverride", testKotlinOverride)
|
|
test("TestGH2945", testGH2945)
|
|
test("TestGH2830", testGH2830)
|
|
test("TestGH2959", testGH2959)
|
|
test("TestKClass", testKClass)
|
|
test("TestSR10177Workaround", testSR10177Workaround)
|
|
test("TestClashes", testClashes)
|
|
test("TestInvalidIdentifiers", testInvalidIdentifiers)
|
|
test("TestDeprecation", testDeprecation)
|
|
test("TestWeakRefs", testWeakRefs)
|
|
test("TestSharedRefs", TestSharedRefs().test)
|
|
test("TestClassTypeCheck", testClassTypeCheck)
|
|
test("TestInterfaceTypeCheck", testInterfaceTypeCheck)
|
|
test("TestGH3503_1", testGH3503_1)
|
|
test("TestGH3503_2", testGH3503_2)
|
|
test("TestGH3503_3", testGH3503_3)
|
|
test("TestGH3525", testGH3525)
|
|
test("TestStringConversion", testStringConversion)
|
|
test("TestGH3825", testGH3825)
|
|
test("TestMapsExport", testMapsExport)
|
|
test("TestFakeOverrideInInterface", testFakeOverrideInInterface)
|
|
|
|
// Stress test, must remain the last one:
|
|
test("TestGH2931", testGH2931)
|
|
}
|
|
}
|