//===--- NSNumberBridging.swift - Test bridging through NSNumber ----------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// RUN: %empty-directory(%t)
//
// RUN: %target-clang %S/Inputs/FoundationBridge/FoundationBridge.m -c -o %t/FoundationBridgeObjC.o -g
// RUN: %target-build-swift %s -I %S/Inputs/FoundationBridge/ -Xlinker %t/FoundationBridgeObjC.o -o %t/TestNSNumberBridging
// 
// RUN: %target-run %t/TestNSNumberBridging
// REQUIRES: executable_test
// REQUIRES: objc_interop

import StdlibUnittest
import Foundation
import CoreGraphics
import FoundationBridgeObjC

extension Float {
    init?(reasonably value: Float) {
        self = value
    }

    init?(reasonably value: Double) {
        guard !value.isNaN else {
            self = Float.nan
            return
        }

        guard !value.isInfinite else {
            if value.sign == .minus {
                self = -Float.infinity
            } else {
                self = Float.infinity
            }
            return
        }

        guard abs(value) <= Double(Float.greatestFiniteMagnitude) else {
            return nil
        }
        
        self = Float(value)
    }
}

extension Double {
    init?(reasonably value: Float) {
        guard !value.isNaN else {
            self = Double.nan
            return
        }

        guard !value.isInfinite else {
            if value.sign == .minus {
                self = -Double.infinity
            } else {
                self = Double.infinity
            }
            return
        }

        self = Double(value)
    }

    init?(reasonably value: Double) {
        self = value
    }
}

var nsNumberBridging = TestSuite("NSNumberBridging")

func testFloat(_ lhs: Float?, _ rhs: Float?, file: String = #file, line: UInt = #line) {
    let message = "\(String(describing: lhs)) != \(String(describing: rhs)) Float"
    if let lhsValue = lhs {
        if let rhsValue = rhs {
            if lhsValue.isNaN != rhsValue.isNaN {
                expectUnreachable(message, file: file, line: line)
            } else if lhsValue != rhsValue && !lhsValue.isNaN {
                expectUnreachable(message, file: file, line: line)
            }
        } else {
            expectUnreachable(message, file: file, line: line)
        }
    } else {
        if rhs != nil {
            expectUnreachable(message, file: file, line: line)
        }
    }
}

func testDouble(_ lhs: Double?, _ rhs: Double?, file: String = #file, line: UInt = #line) {
    let message = "\(String(describing: lhs)) != \(String(describing: rhs)) Double"
    if let lhsValue = lhs {
        if let rhsValue = rhs {
            if lhsValue.isNaN != rhsValue.isNaN {
                expectUnreachable(message, file: file, line: line)
            } else if lhsValue != rhsValue && !lhsValue.isNaN {
                expectUnreachable(message, file: file, line: line)
            }
        } else {
            expectUnreachable(message, file: file, line: line)
        }
    } else {
        if rhs != nil {
            expectUnreachable(message, file: file, line: line)
        }
    }
}


extension Int8 {
    static var _interestingValues: [Int8] {
        return [
            Int8.min,
            Int8.min + 1,
            Int8.max,
            Int8.max - 1,
            0,
            -1, 1,
            -42, 42,
        ]
    }
}

extension UInt8 {
    static var _interestingValues: [UInt8] {
        return [
            UInt8.min,
            UInt8.min + 1,
            UInt8.max,
            UInt8.max - 1,
            42,
        ]
    }
}

extension Int16 {
    static var _interestingValues: [Int16] {
        return [
            Int16.min,
            Int16.min + 1,
            Int16.max,
            Int16.max - 1,
            0,
            -1, 1,
            -42, 42,
        ]
    }
}

extension UInt16 {
    static var _interestingValues: [UInt16] {
        return [
            UInt16.min,
            UInt16.min + 1,
            UInt16.max,
            UInt16.max - 1,
            42,
        ]
    }
}

extension Int32 {
    static var _interestingValues: [Int32] {
        return [
            Int32.min,
            Int32.min + 1,
            Int32.max,
            Int32.max - 1,
            0,
            -1, 1,
            -42, 42,
        ]
    }
}

extension UInt32 {
    static var _interestingValues: [UInt32] {
        return [
            UInt32.min,
            UInt32.min + 1,
            UInt32.max,
            UInt32.max - 1,
            42,
        ]
    }
}

extension Int64 {
    static var _interestingValues: [Int64] {
        return [
            Int64.min,
            Int64.min + 1,
            Int64.max,
            Int64.max - 1,
            0,
            -1, 1,
            -42, 42,
        ]
    }
}

extension UInt64 {
    static var _interestingValues: [UInt64] {
        return [
            UInt64.min,
            UInt64.min + 1,
            UInt64.max,
            UInt64.max - 1,
            42,
        ]
    }
}

extension Int {
    static var _interestingValues: [Int] {
        return [
            Int.min,
            Int.min + 1,
            Int.max,
            Int.max - 1,
            0,
            -1, 1,
            -42, 42,
        ]
    }
}

extension UInt {
    static var _interestingValues: [UInt] {
        return [
            UInt.min,
            UInt.min + 1,
            UInt.max,
            UInt.max - 1,
            42,
        ]
    }
}

extension Float {
    static var _interestingValues: [Float] {
        return [
            -Float.infinity,
            -Float.greatestFiniteMagnitude,
            -1.0,
            -Float.ulpOfOne,
            -Float.leastNormalMagnitude,
            -0.0,
            0.0,
            Float.leastNormalMagnitude,
            Float.ulpOfOne,
            1.0,
            Float.greatestFiniteMagnitude,
            Float.infinity,
            Float.nan,
        ]
    }
}

extension Double {
    static var _interestingValues: [Double] {
        return [
            -Double.infinity,
            -Double.greatestFiniteMagnitude,
            -1.0,
            -Double.ulpOfOne,
            -Double.leastNormalMagnitude,
            -0.0,
            0.0,
            Double.leastNormalMagnitude,
            Double.ulpOfOne,
            1.0,
            Double.greatestFiniteMagnitude,
            Double.infinity,
            Double.nan,
        ]
    }
}

extension CGFloat {
    static var _interestingValues: [CGFloat] {
        return [
            -CGFloat.infinity,
            -CGFloat.greatestFiniteMagnitude,
            -1.0,
            -CGFloat.ulpOfOne,
            -CGFloat.leastNormalMagnitude,
            -0.0,
            0.0,
            CGFloat.leastNormalMagnitude,
            CGFloat.ulpOfOne,
            1.0,
            CGFloat.greatestFiniteMagnitude,
            CGFloat.infinity,
            CGFloat.nan,
        ]
    }
}

extension Bool {
    static var _interestingValues: [Bool] {
        return [false, true]
    }
}

func testNSNumberBridgeFromInt8() {
    for interestingValue in Int8._interestingValues {
        func testNumber(_ number: NSNumber?) {
            expectNotNil(number)
            let int8 = (number!) as? Int8
            expectEqual(Int8(exactly: interestingValue), int8)
            let uint8 = (number!) as? UInt8
            expectEqual(UInt8(exactly: interestingValue), uint8)
            let int16 = (number!) as? Int16
            expectEqual(Int16(exactly: interestingValue), int16)
            let uint16 = (number!) as? UInt16
            expectEqual(UInt16(exactly: interestingValue), uint16)
            let int32 = (number!) as? Int32
            expectEqual(Int32(exactly: interestingValue), int32)
            let uint32 = (number!) as? UInt32
            expectEqual(UInt32(exactly: interestingValue), uint32)
            let int64 = (number!) as? Int64
            expectEqual(Int64(exactly: interestingValue), int64)
            let uint64 = (number!) as? UInt64
            expectEqual(UInt64(exactly: interestingValue), uint64)
            let int = (number!) as? Int
            expectEqual(Int(exactly: interestingValue), int)
            let uint = (number!) as? UInt
            expectEqual(UInt(exactly: interestingValue), uint)
            let float = (number!) as? Float
            expectEqual(Float(interestingValue), float)
        }
        let bridged = interestingValue as NSNumber
        testNumber(bridged)
        let created = NSNumber(value: interestingValue)
        testNumber(created)
    }
}

func testNSNumberBridgeFromUInt8() {
    for interestingValue in UInt8._interestingValues {
        func testNumber(_ number: NSNumber?) {
            expectNotNil(number)
            let int8 = (number!) as? Int8
            expectEqual(Int8(exactly: interestingValue), int8)
            let uint8 = (number!) as? UInt8
            expectEqual(UInt8(exactly: interestingValue), uint8)
            let int16 = (number!) as? Int16
            expectEqual(Int16(exactly: interestingValue), int16)
            let uint16 = (number!) as? UInt16
            expectEqual(UInt16(exactly: interestingValue), uint16)
            let int32 = (number!) as? Int32
            expectEqual(Int32(exactly: interestingValue), int32)
            let uint32 = (number!) as? UInt32
            expectEqual(UInt32(exactly: interestingValue), uint32)
            let int64 = (number!) as? Int64
            expectEqual(Int64(exactly: interestingValue), int64)
            let uint64 = (number!) as? UInt64
            expectEqual(UInt64(exactly: interestingValue), uint64)
            let int = (number!) as? Int
            expectEqual(Int(exactly: interestingValue), int)
            let uint = (number!) as? UInt
            expectEqual(UInt(exactly: interestingValue), uint)
            let float = (number!) as? Float
            expectEqual(Float(interestingValue), float)
        }
        let bridged = interestingValue as NSNumber
        testNumber(bridged)
        let created = NSNumber(value: interestingValue)
        testNumber(created)
    }
}

func testNSNumberBridgeFromInt16() {
    for interestingValue in Int16._interestingValues {
        func testNumber(_ number: NSNumber?) {
            expectNotNil(number)
            let int8 = (number!) as? Int8
            expectEqual(Int8(exactly: interestingValue), int8)
            let uint8 = (number!) as? UInt8
            expectEqual(UInt8(exactly: interestingValue), uint8)
            let int16 = (number!) as? Int16
            expectEqual(Int16(exactly: interestingValue), int16)
            let uint16 = (number!) as? UInt16
            expectEqual(UInt16(exactly: interestingValue), uint16)
            let int32 = (number!) as? Int32
            expectEqual(Int32(exactly: interestingValue), int32)
            let uint32 = (number!) as? UInt32
            expectEqual(UInt32(exactly: interestingValue), uint32)
            let int64 = (number!) as? Int64
            expectEqual(Int64(exactly: interestingValue), int64)
            let uint64 = (number!) as? UInt64
            expectEqual(UInt64(exactly: interestingValue), uint64)
            let int = (number!) as? Int
            expectEqual(Int(exactly: interestingValue), int)
            let uint = (number!) as? UInt
            expectEqual(UInt(exactly: interestingValue), uint)
            let float = (number!) as? Float
            expectEqual(Float(interestingValue), float)
        }
        let bridged = interestingValue as NSNumber
        testNumber(bridged)
        let created = NSNumber(value: interestingValue)
        testNumber(created)
    }
}

func testNSNumberBridgeFromUInt16() {
    for interestingValue in UInt8._interestingValues {
        func testNumber(_ number: NSNumber?) {
            expectNotNil(number)
            let int8 = (number!) as? Int8
            expectEqual(Int8(exactly: interestingValue), int8)
            let uint8 = (number!) as? UInt8
            expectEqual(UInt8(exactly: interestingValue), uint8)
            let int16 = (number!) as? Int16
            expectEqual(Int16(exactly: interestingValue), int16)
            let uint16 = (number!) as? UInt16
            expectEqual(UInt16(exactly: interestingValue), uint16)
            let int32 = (number!) as? Int32
            expectEqual(Int32(exactly: interestingValue), int32)
            let uint32 = (number!) as? UInt32
            expectEqual(UInt32(exactly: interestingValue), uint32)
            let int64 = (number!) as? Int64
            expectEqual(Int64(exactly: interestingValue), int64)
            let uint64 = (number!) as? UInt64
            expectEqual(UInt64(exactly: interestingValue), uint64)
            let int = (number!) as? Int
            expectEqual(Int(exactly: interestingValue), int)
            let uint = (number!) as? UInt
            expectEqual(UInt(exactly: interestingValue), uint)
            let float = (number!) as? Float
            expectEqual(Float(interestingValue), float)
        }
        let bridged = interestingValue as NSNumber
        testNumber(bridged)
        let created = NSNumber(value: interestingValue)
        testNumber(created)
    }
}

func testNSNumberBridgeFromInt32() {
    for interestingValue in Int32._interestingValues {
        func testNumber(_ number: NSNumber?) {
            expectNotNil(number)
            let int8 = (number!) as? Int8
            expectEqual(Int8(exactly: interestingValue), int8)
            let uint8 = (number!) as? UInt8
            expectEqual(UInt8(exactly: interestingValue), uint8)
            let int16 = (number!) as? Int16
            expectEqual(Int16(exactly: interestingValue), int16)
            let uint16 = (number!) as? UInt16
            expectEqual(UInt16(exactly: interestingValue), uint16)
            let int32 = (number!) as? Int32
            expectEqual(Int32(exactly: interestingValue), int32)
            let uint32 = (number!) as? UInt32
            expectEqual(UInt32(exactly: interestingValue), uint32)
            let int64 = (number!) as? Int64
            expectEqual(Int64(exactly: interestingValue), int64)
            let uint64 = (number!) as? UInt64
            expectEqual(UInt64(exactly: interestingValue), uint64)
            let int = (number!) as? Int
            expectEqual(Int(exactly: interestingValue), int)
            let uint = (number!) as? UInt
            expectEqual(UInt(exactly: interestingValue), uint)
            
            let float = (number!) as? Float
            let expectedFloat = Float(exactly: int32!)
            // these are disabled because of https://bugs.swift.org/browse/SR-4634
            if (int32! != Int32.min && int32! != Int32.max &&
                int32! != Int32.min + 1 && int32! != Int32.max - 1) {
                testFloat(expectedFloat, float)
            }
            
            
            let double = (number!) as? Double
            let expectedDouble = Double(int32!)
            testDouble(expectedDouble, double)
        }
        let bridged = interestingValue as NSNumber
        testNumber(bridged)
        let created = NSNumber(value: interestingValue)
        testNumber(created)
    }
}

func testNSNumberBridgeFromUInt32() {
    for interestingValue in UInt32._interestingValues {
        func testNumber(_ number: NSNumber?) {
            expectNotNil(number)
            let int8 = (number!) as? Int8
            expectEqual(Int8(exactly: interestingValue), int8)
            let uint8 = (number!) as? UInt8
            expectEqual(UInt8(exactly: interestingValue), uint8)
            let int16 = (number!) as? Int16
            expectEqual(Int16(exactly: interestingValue), int16)
            let uint16 = (number!) as? UInt16
            expectEqual(UInt16(exactly: interestingValue), uint16)
            let int32 = (number!) as? Int32
            expectEqual(Int32(exactly: interestingValue), int32)
            let uint32 = (number!) as? UInt32
            expectEqual(UInt32(exactly: interestingValue), uint32)
            let int64 = (number!) as? Int64
            expectEqual(Int64(exactly: interestingValue), int64)
            let uint64 = (number!) as? UInt64
            expectEqual(UInt64(exactly: interestingValue), uint64)
            let int = (number!) as? Int
            expectEqual(Int(exactly: interestingValue), int)
            let uint = (number!) as? UInt
            expectEqual(UInt(exactly: interestingValue), uint)
            
            let float = (number!) as? Float
            let expectedFloat = Float(uint32!)
            // these are disabled because of https://bugs.swift.org/browse/SR-4634
            if (uint32! != UInt32.max && uint32! != UInt32.max - UInt32(1)) {
                testFloat(expectedFloat, float)
            }
            
            let double = (number!) as? Double
            let expectedDouble = Double(uint32!)
            testDouble(expectedDouble, double)
        }
        let bridged = interestingValue as NSNumber
        testNumber(bridged)
        let created = NSNumber(value: interestingValue)
        testNumber(created)
    }
}

func testNSNumberBridgeFromInt64() {
    for interestingValue in Int64._interestingValues {
        func testNumber(_ number: NSNumber?) {
            expectNotNil(number)
            let int8 = (number!) as? Int8
            expectEqual(Int8(exactly: interestingValue), int8)
            let uint8 = (number!) as? UInt8
            expectEqual(UInt8(exactly: interestingValue), uint8)
            let int16 = (number!) as? Int16
            expectEqual(Int16(exactly: interestingValue), int16)
            let uint16 = (number!) as? UInt16
            expectEqual(UInt16(exactly: interestingValue), uint16)
            let int32 = (number!) as? Int32
            expectEqual(Int32(exactly: interestingValue), int32)
            let uint32 = (number!) as? UInt32
            expectEqual(UInt32(exactly: interestingValue), uint32)
            let int64 = (number!) as? Int64
            expectEqual(Int64(exactly: interestingValue), int64)
            let uint64 = (number!) as? UInt64
            expectEqual(UInt64(exactly: interestingValue), uint64)
            let int = (number!) as? Int
            expectEqual(Int(exactly: interestingValue), int)
            let uint = (number!) as? UInt
            expectEqual(UInt(exactly: interestingValue), uint)
        }
        let bridged = interestingValue as NSNumber
        testNumber(bridged)
        let created = NSNumber(value: interestingValue)
        testNumber(created)
    }
}

func testNSNumberBridgeFromUInt64() {
    for interestingValue in UInt64._interestingValues {
        func testNumber(_ number: NSNumber?) {
            expectNotNil(number)
            let int8 = (number!) as? Int8
            expectEqual(Int8(exactly: interestingValue), int8)
            let uint8 = (number!) as? UInt8
            expectEqual(UInt8(exactly: interestingValue), uint8)
            let int16 = (number!) as? Int16
            expectEqual(Int16(exactly: interestingValue), int16)
            let uint16 = (number!) as? UInt16
            expectEqual(UInt16(exactly: interestingValue), uint16)
            let int32 = (number!) as? Int32
            expectEqual(Int32(exactly: interestingValue), int32)
            let uint32 = (number!) as? UInt32
            expectEqual(UInt32(exactly: interestingValue), uint32)
            let int64 = (number!) as? Int64
            expectEqual(Int64(exactly: interestingValue), int64)
            let uint64 = (number!) as? UInt64
            expectEqual(UInt64(exactly: interestingValue), uint64)
            let int = (number!) as? Int
            expectEqual(Int(exactly: interestingValue), int)
            let uint = (number!) as? UInt
            expectEqual(UInt(exactly: interestingValue), uint)
        }
        let bridged = interestingValue as NSNumber
        testNumber(bridged)
        let created = NSNumber(value: interestingValue)
        testNumber(created)
    }
}

func testNSNumberBridgeFromInt() {
    for interestingValue in Int._interestingValues {
        func testNumber(_ number: NSNumber?) {
            expectNotNil(number)
            let int8 = (number!) as? Int8
            expectEqual(Int8(exactly: interestingValue), int8)
            let uint8 = (number!) as? UInt8
            expectEqual(UInt8(exactly: interestingValue), uint8)
            let int16 = (number!) as? Int16
            expectEqual(Int16(exactly: interestingValue), int16)
            let uint16 = (number!) as? UInt16
            expectEqual(UInt16(exactly: interestingValue), uint16)
            let int32 = (number!) as? Int32
            expectEqual(Int32(exactly: interestingValue), int32)
            let uint32 = (number!) as? UInt32
            expectEqual(UInt32(exactly: interestingValue), uint32)
            let int64 = (number!) as? Int64
            expectEqual(Int64(exactly: interestingValue), int64)
            let uint64 = (number!) as? UInt64
            expectEqual(UInt64(exactly: interestingValue), uint64)
            let int = (number!) as? Int
            expectEqual(Int(exactly: interestingValue), int)
            let uint = (number!) as? UInt
            expectEqual(UInt(exactly: interestingValue), uint)
        }
        let bridged = interestingValue as NSNumber
        testNumber(bridged)
        let created = NSNumber(value: interestingValue)
        testNumber(created)
    }
}

func testNSNumberBridgeFromUInt() {
    for interestingValue in UInt._interestingValues {
        func testNumber(_ number: NSNumber?) {
            expectNotNil(number)
            let int8 = (number!) as? Int8
            expectEqual(Int8(exactly: interestingValue), int8)
            let uint8 = (number!) as? UInt8
            expectEqual(UInt8(exactly: interestingValue), uint8)
            let int16 = (number!) as? Int16
            expectEqual(Int16(exactly: interestingValue), int16)
            let uint16 = (number!) as? UInt16
            expectEqual(UInt16(exactly: interestingValue), uint16)
            let int32 = (number!) as? Int32
            expectEqual(Int32(exactly: interestingValue), int32)
            let uint32 = (number!) as? UInt32
            expectEqual(UInt32(exactly: interestingValue), uint32)
            let int64 = (number!) as? Int64
            expectEqual(Int64(exactly: interestingValue), int64)
            let uint64 = (number!) as? UInt64
            expectEqual(UInt64(exactly: interestingValue), uint64)
            let int = (number!) as? Int
            expectEqual(Int(exactly: interestingValue), int)
            let uint = (number!) as? UInt
            expectEqual(UInt(exactly: interestingValue), uint)

            let float = (number!) as? Float
            let expectedFloat = Float(exactly: uint!)
            if UInt.bitWidth == 32 && uint! >= UInt.max - 1 {
              expectNil(expectedFloat)
            } else {
              testFloat(expectedFloat, float)
            }
          
            let double = (number!) as? Double
            let expectedDouble = Double(exactly: uint!)
            testDouble(expectedDouble, double)
        }
        let bridged = interestingValue as NSNumber
        testNumber(bridged)
        let created = NSNumber(value: interestingValue)
        testNumber(created)
    }
}

func testNSNumberBridgeFromFloat() {
    for interestingValue in Float._interestingValues {
        func testNumber(_ number: NSNumber?) {
            expectNotNil(number)
            let int8 = (number!) as? Int8
            expectEqual(Int8(exactly: interestingValue), int8)
            let uint8 = (number!) as? UInt8
            expectEqual(UInt8(exactly: interestingValue), uint8)
            let int16 = (number!) as? Int16
            expectEqual(Int16(exactly: interestingValue), int16)
            let uint16 = (number!) as? UInt16
            expectEqual(UInt16(exactly: interestingValue), uint16)
            let int32 = (number!) as? Int32
            expectEqual(Int32(exactly: interestingValue), int32)
            let uint32 = (number!) as? UInt32
            expectEqual(UInt32(exactly: interestingValue), uint32)
            let int64 = (number!) as? Int64
            expectEqual(Int64(exactly: interestingValue), int64)
            let uint64 = (number!) as? UInt64
            expectEqual(UInt64(exactly: interestingValue), uint64)
            let int = (number!) as? Int
            expectEqual(Int(exactly: interestingValue), int)
            let uint = (number!) as? UInt
            expectEqual(UInt(exactly: interestingValue), uint)

            let float = (number!) as? Float
            let expectedFloat = Float(reasonably: interestingValue)
            testFloat(expectedFloat, float)
            
            let double = (number!) as? Double
            let expectedDouble = Double(interestingValue)
            testDouble(expectedDouble, double)
        }
        let bridged = interestingValue as NSNumber
        testNumber(bridged)
        let created = NSNumber(value: interestingValue)
        testNumber(created)
    }
}

func testNSNumberBridgeFromDouble() {
    for interestingValue in Double._interestingValues {
        func testNumber(_ number: NSNumber?) {
            expectNotNil(number)
            let int8 = (number!) as? Int8
            expectEqual(Int8(exactly: interestingValue), int8)
            let uint8 = (number!) as? UInt8
            expectEqual(UInt8(exactly: interestingValue), uint8)
            let int16 = (number!) as? Int16
            expectEqual(Int16(exactly: interestingValue), int16)
            let uint16 = (number!) as? UInt16
            expectEqual(UInt16(exactly: interestingValue), uint16)
            let int32 = (number!) as? Int32
            expectEqual(Int32(exactly: interestingValue), int32)
            let uint32 = (number!) as? UInt32
            expectEqual(UInt32(exactly: interestingValue), uint32)
            let int64 = (number!) as? Int64
            expectEqual(Int64(exactly: interestingValue), int64)
            let uint64 = (number!) as? UInt64
            expectEqual(UInt64(exactly: interestingValue), uint64)
            let int = (number!) as? Int
            expectEqual(Int(exactly: interestingValue), int)
            let uint = (number!) as? UInt
            expectEqual(UInt(exactly: interestingValue), uint)

            let float = (number!) as? Float
            let expectedFloat = Float(reasonably: interestingValue)
            testFloat(expectedFloat, float)
            
            let double = (number!) as? Double
            let expectedDouble = interestingValue
            testDouble(expectedDouble, double)
        }
        let bridged = interestingValue as NSNumber
        testNumber(bridged)
        let created = NSNumber(value: interestingValue)
        testNumber(created)
    }
}

func testNSNumberBridgeFromCGFloat() {
    for interestingValue in CGFloat._interestingValues {
        func testNumber(_ number: NSNumber?) {
            expectNotNil(number)
            let int8 = (number!) as? Int8
            expectEqual(Int8(exactly: interestingValue.native), int8)
            let uint8 = (number!) as? UInt8
            expectEqual(UInt8(exactly: interestingValue.native), uint8)
            let int16 = (number!) as? Int16
            expectEqual(Int16(exactly: interestingValue.native), int16)
            let uint16 = (number!) as? UInt16
            expectEqual(UInt16(exactly: interestingValue.native), uint16)
            let int32 = (number!) as? Int32
            expectEqual(Int32(exactly: interestingValue.native), int32)
            let uint32 = (number!) as? UInt32
            expectEqual(UInt32(exactly: interestingValue.native), uint32)
            let int64 = (number!) as? Int64
            expectEqual(Int64(exactly: interestingValue.native), int64)
            let uint64 = (number!) as? UInt64
            expectEqual(UInt64(exactly: interestingValue.native), uint64)
            let int = (number!) as? Int
            expectEqual(Int(exactly: interestingValue.native), int)
            let uint = (number!) as? UInt
            expectEqual(UInt(exactly: interestingValue.native), uint)
            
            let float = (number!) as? Float
            let expectedFloat = Float(reasonably: interestingValue.native)
            testFloat(expectedFloat, float)
            
            let double = (number!) as? Double
            let expectedDouble = Double(interestingValue)
            testDouble(expectedDouble, double)
        }
        let bridged = interestingValue as NSNumber
        testNumber(bridged)
        let created = NSNumber(value: interestingValue.native)
        testNumber(created)
    }
}

func test_numericBitPatterns_to_floatingPointTypes() {
    let signed_numbers: [NSNumber] = [
        NSNumber(value: Int64(6)),
        NSNumber(value: Int64(bitPattern: 1 << 56)),
        NSNumber(value: Int64(bitPattern: 1 << 53)),
        NSNumber(value: Int64(bitPattern: 1 << 52)),
        NSNumber(value: Int64(bitPattern: 1 << 25)),
        NSNumber(value: Int64(bitPattern: 1 << 24)),
        NSNumber(value: Int64(bitPattern: 1 << 23)),
        NSNumber(value: -Int64(bitPattern: 1 << 53)),
        NSNumber(value: -Int64(bitPattern: 1 << 52)),
        NSNumber(value: -Int64(6)),
        NSNumber(value: -Int64(bitPattern: 1 << 56)),
        NSNumber(value: -Int64(bitPattern: 1 << 25)),
        NSNumber(value: -Int64(bitPattern: 1 << 24)),
        NSNumber(value: -Int64(bitPattern: 1 << 23)),
    ]

    let signed_values: [Int64] = [
        Int64(6),
        Int64(bitPattern: 1 << 56),
        Int64(bitPattern: 1 << 53),
        Int64(bitPattern: 1 << 52),
        Int64(bitPattern: 1 << 25),
        Int64(bitPattern: 1 << 24),
        Int64(bitPattern: 1 << 23),
        -Int64(bitPattern: 1 << 53),
        -Int64(bitPattern: 1 << 52),
        -Int64(6),
        -Int64(bitPattern: 1 << 56),
        -Int64(bitPattern: 1 << 25),
        -Int64(bitPattern: 1 << 24),
        -Int64(bitPattern: 1 << 23),
    ]

    let unsigned_numbers: [NSNumber] = [
        NSNumber(value: UInt64(bitPattern: 6)),
        NSNumber(value: UInt64(bitPattern: 1 << 56)),
        NSNumber(value: UInt64(bitPattern: 1 << 63)),
        NSNumber(value: UInt64(bitPattern: 1 << 53)),
        NSNumber(value: UInt64(bitPattern: 1 << 52)),
        NSNumber(value: UInt64(bitPattern: 1 << 25)),
        NSNumber(value: UInt64(bitPattern: 1 << 24)),
        NSNumber(value: UInt64(bitPattern: 1 << 23)),
    ]

    let unsigned_values: [UInt64] = [
        UInt64(bitPattern: 6),
        UInt64(bitPattern: 1 << 56),
        UInt64(bitPattern: 1 << 63),
        UInt64(bitPattern: 1 << 53),
        UInt64(bitPattern: 1 << 52),
        UInt64(bitPattern: 1 << 25),
        UInt64(bitPattern: 1 << 24),
        UInt64(bitPattern: 1 << 23)
    ]

    for (number, value) in zip(signed_numbers, signed_values) {
        let numberCast = Double(exactly: number)
        let valueCast = Double(exactly: value)
        expectEqual(numberCast, valueCast)
    }

    for (number, value) in zip(unsigned_numbers, unsigned_values) {
        let numberCast = Double(exactly: number)
        let valueCast = Double(exactly: value)
        expectEqual(numberCast, valueCast)
    }

    for (number, value) in zip(signed_numbers, signed_values) {
        let numberCast = Float(exactly: number)
        let valueCast = Float(exactly: value)
        expectEqual(numberCast, valueCast)
    }

    for (number, value) in zip(unsigned_numbers, unsigned_values) {
        let numberCast = Float(exactly: number)
        let valueCast = Float(exactly: value)
        expectEqual(numberCast, valueCast)
    }
}

func testNSNumberBridgeAnyHashable() {
    var dict = [AnyHashable : Any]()
    for i in -Int(UInt8.min) ... Int(UInt8.max) {
        dict[i] = "\(i)"
    }

    // When bridging a dictionary to NSDictionary, we should be able to access
    // the keys through either an Int (the original type boxed in AnyHashable)
    // or NSNumber (the type Int bridged to).
    let ns_dict = dict as NSDictionary
    for i in -Int(UInt8.min) ... Int(UInt8.max) {
        guard let value = ns_dict[i] as? String else {
            expectUnreachable("Unable to look up value by Int key.")
            continue
        }

        guard let ns_value = ns_dict[NSNumber(value: i)] as? String else {
            expectUnreachable("Unable to look up value by NSNumber key.")
            continue
        }
        
        expectEqual(value, ns_value)
    }
}

func testNSNumberBridgeAnyHashableObjc() {
    let range = -Int(UInt8.min) ... Int(UInt8.max)
    var dict = [AnyHashable : Any]()
    for i in range {
        dict[i] = "\(i)"
    }

    let verifier = NumberBridgingTester()
    expectTrue(verifier.verifyKeys(in: NSRange(range), existIn: dict))
}

nsNumberBridging.test("Bridge Int8") { testNSNumberBridgeFromInt8() }
nsNumberBridging.test("Bridge UInt8") { testNSNumberBridgeFromUInt8() }
nsNumberBridging.test("Bridge Int16") { testNSNumberBridgeFromInt16() }
nsNumberBridging.test("Bridge UInt16") { testNSNumberBridgeFromUInt16() }
nsNumberBridging.test("Bridge Int32") { testNSNumberBridgeFromInt32() }
nsNumberBridging.test("Bridge UInt32") { testNSNumberBridgeFromUInt32() }
nsNumberBridging.test("Bridge Int64") { testNSNumberBridgeFromInt64() }
nsNumberBridging.test("Bridge UInt64") { testNSNumberBridgeFromUInt64() }
nsNumberBridging.test("Bridge Int") { testNSNumberBridgeFromInt() }
nsNumberBridging.test("Bridge UInt") { testNSNumberBridgeFromUInt() }
nsNumberBridging.test("Bridge Float") { testNSNumberBridgeFromFloat() }
nsNumberBridging.test("Bridge Double") { testNSNumberBridgeFromDouble() }
nsNumberBridging.test("Bridge CGFloat") { testNSNumberBridgeFromCGFloat() }
nsNumberBridging.test("bitPattern to exactly") { test_numericBitPatterns_to_floatingPointTypes() }
nsNumberBridging.test("Bridge AnyHashable") { testNSNumberBridgeAnyHashable() }
nsNumberBridging.test("Bridge AnyHashable (ObjC)") { testNSNumberBridgeAnyHashableObjc() }
runAllTests()
