// 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 http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//


#if DEPLOYMENT_RUNTIME_OBJC || os(Linux)
import Foundation
import XCTest
#else
import SwiftFoundation
import SwiftXCTest
#endif

class TestNSNumberBridging : XCTestCase {
    static var allTests: [(String, (TestNSNumberBridging) -> () throws -> Void)] {
        return [
            ("testNSNumberBridgeFromInt8", testNSNumberBridgeFromInt8),
            ("testNSNumberBridgeFromUInt8", testNSNumberBridgeFromUInt8),
            ("testNSNumberBridgeFromInt16", testNSNumberBridgeFromInt16),
            ("testNSNumberBridgeFromUInt16", testNSNumberBridgeFromUInt16),
            ("testNSNumberBridgeFromInt32", testNSNumberBridgeFromInt32),
            ("testNSNumberBridgeFromUInt32", testNSNumberBridgeFromUInt32),
            ("testNSNumberBridgeFromInt64", testNSNumberBridgeFromInt64),
            ("testNSNumberBridgeFromUInt64", testNSNumberBridgeFromUInt64),
            ("testNSNumberBridgeFromInt", testNSNumberBridgeFromInt),
            ("testNSNumberBridgeFromUInt", testNSNumberBridgeFromUInt),
            ("testNSNumberBridgeFromFloat", testNSNumberBridgeFromFloat),
            ("testNSNumberBridgeFromDouble", testNSNumberBridgeFromDouble),
            ("test_numericBitPatterns_to_floatingPointTypes", test_numericBitPatterns_to_floatingPointTypes),
            ("testNSNumberBridgeAnyHashable", testNSNumberBridgeAnyHashable),
        ]
    }

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

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

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

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

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

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

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

                let float = Float(exactly: number!)
                let expectedFloat = Float(exactly: int32!)
                testFloat(expectedFloat, float)

                let double = Double(exactly: number!)
                let expectedDouble = Double(exactly: int32!)
                testDouble(expectedDouble, double)
            }
            let bridged = interestingValue._bridgeToObjectiveC()
            testNumber(bridged)
            let created = NSNumber(value: interestingValue)
            testNumber(created)
        }
    }

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

                let float = Float(exactly: number!)
                let expectedFloat = Float(exactly: uint32!)
                testFloat(expectedFloat, float)

                let double = Double(exactly: number!)
                let expectedDouble = Double(exactly: uint32!)
                testDouble(expectedDouble, double)
            }
            let bridged = interestingValue._bridgeToObjectiveC()
            testNumber(bridged)
            let created = NSNumber(value: interestingValue)
            testNumber(created)
        }
    }

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

                let float = Float(exactly: number!)
                let expectedFloat = Float(exactly: int64!)
                testFloat(expectedFloat, float)

                let double = Double(exactly: number!)
                let expectedDouble = Double(exactly: int64!)
                testDouble(expectedDouble, double)
            }
            let bridged = interestingValue._bridgeToObjectiveC()
            testNumber(bridged)
            let created = NSNumber(value: interestingValue)
            testNumber(created)
        }
    }

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

                let float = Float(exactly: number!)
                let expectedFloat = Float(exactly: uint64!)
                testFloat(expectedFloat, float)

                let double = Double(exactly: number!)
                let expectedDouble = Double(exactly: uint64!)
                testDouble(expectedDouble, double)
            }
            let bridged = interestingValue._bridgeToObjectiveC()
            testNumber(bridged)
            let created = NSNumber(value: interestingValue)
            testNumber(created)
        }
    }

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

                let float = Float(exactly: number!)
                let expectedFloat = Float(exactly: int!)
                testFloat(expectedFloat, float)

                let double = Double(exactly: number!)
                let expectedDouble = Double(exactly: int!)
                testDouble(expectedDouble, double)
            }
            let bridged = interestingValue._bridgeToObjectiveC()
            testNumber(bridged)
            let created = NSNumber(value: interestingValue)
            testNumber(created)
        }
    }

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

                let float = Float(exactly: number!)
                let expectedFloat = Float(exactly: uint!)
                testFloat(expectedFloat, float)

                let double = Double(exactly: number!)
                let expectedDouble = Double(exactly: uint!)
                testDouble(expectedDouble, double)
            }
            let bridged = interestingValue._bridgeToObjectiveC()
            testNumber(bridged)
            let created = NSNumber(value: interestingValue)
            testNumber(created)
        }
    }

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

                let float = Float(exactly: number!)
                let expectedFloat = Float(exactly: interestingValue)
                testFloat(expectedFloat, float)
              
                let double = Double(exactly: number!)
                let expectedDouble = Double(exactly: interestingValue)
                testDouble(expectedDouble, double)
            }
            let bridged = interestingValue._bridgeToObjectiveC()
            testNumber(bridged)
            let created = NSNumber(value: interestingValue)
            testNumber(created)
        }
    }

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

                let float = Float(exactly: number!)
                let expectedFloat = Float(exactly: interestingValue)
                testFloat(expectedFloat, float)
              
                let double = Double(exactly: number!)
                let expectedDouble = Double(exactly: interestingValue)
                testDouble(expectedDouble, double)
            }
            let bridged = interestingValue._bridgeToObjectiveC()
            testNumber(bridged)
            let created = NSNumber(value: interestingValue)
            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)
            XCTAssertEqual(numberCast, valueCast)
        }

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

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

        for (number, value) in zip(unsigned_numbers, unsigned_values) {
            let numberCast = Float(exactly: number)
            let valueCast = Float(exactly: value)
            XCTAssertEqual(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._bridgeToObjectiveC()
        for i in -Int(UInt8.min) ... Int(UInt8.max) {
            guard let value = ns_dict[i] as? String else {
                XCTFail("Unable to look up value by Int key.")
                continue
            }

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

            XCTAssertEqual(value, ns_value)
        }
    }
}

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
    }
}

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,
        ]
    }
}