/*
 * 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)
    }
}