// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 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

private func assertEqual(_ rect: CGRect,
                         x: CGFloat,
                         y: CGFloat,
                         width: CGFloat,
                         height: CGFloat,
                         accuracy: CGFloat? = nil,
                         _ message: @autoclosure () -> String = "",
                         file: StaticString = #file,
                         line: UInt = #line) {

    if let accuracy = accuracy {
        XCTAssertEqual(rect.origin.x, x, accuracy: accuracy, message, file: file, line: line)
        XCTAssertEqual(rect.origin.y, y, accuracy: accuracy, message, file: file, line: line)
        XCTAssertEqual(rect.size.width, width, accuracy: accuracy, message, file: file, line: line)
        XCTAssertEqual(rect.size.height, height, accuracy: accuracy, message, file: file, line: line)
    } else {
        XCTAssertEqual(rect.origin.x, x, message, file: file, line: line)
        XCTAssertEqual(rect.origin.y, y, message, file: file, line: line)
        XCTAssertEqual(rect.size.width, width, message, file: file, line: line)
        XCTAssertEqual(rect.size.height, height, message, file: file, line: line)
    }
}

class TestNSGeometry : XCTestCase {

    static var allTests: [(String, (TestNSGeometry) -> () throws -> Void)] {
        return [
            ("test_CGFloat_BasicConstruction", test_CGFloat_BasicConstruction),
            ("test_CGFloat_Equality", test_CGFloat_Equality),
            ("test_CGFloat_LessThanOrEqual", test_CGFloat_LessThanOrEqual),
            ("test_CGFloat_GreaterThanOrEqual", test_CGFloat_GreaterThanOrEqual),
            ("test_CGPoint_BasicConstruction", test_CGPoint_BasicConstruction),
            ("test_CGPoint_ExtendedConstruction", test_CGPoint_ExtendedConstruction),
            ("test_CGSize_BasicConstruction", test_CGSize_BasicConstruction),
            ("test_CGSize_ExtendedConstruction", test_CGSize_ExtendedConstruction),
            ("test_CGRect_BasicConstruction", test_CGRect_BasicConstruction),
            ("test_CGRect_ExtendedConstruction", test_CGRect_ExtendedConstruction),
            ("test_CGRect_SpecialValues", test_CGRect_SpecialValues),
            ("test_CGRect_IsNull", test_CGRect_IsNull),
            ("test_CGRect_IsInfinite", test_CGRect_IsInfinite),
            ("test_CGRect_IsEmpty", test_CGRect_IsEmpty),
            ("test_CGRect_Equatable", test_CGRect_Equatable),
            ("test_CGRect_CalculatedGeometricProperties", test_CGRect_CalculatedGeometricProperties),
            ("test_CGRect_Standardized", test_CGRect_Standardized),
            ("test_CGRect_Integral", test_CGRect_Integral),
            ("test_CGRect_ContainsPoint", test_CGRect_ContainsPoint),
            ("test_CGRect_ContainsRect", test_CGRect_ContainsRect),
            ("test_CGRect_Union", test_CGRect_Union),
            ("test_CGRect_Intersection", test_CGRect_Intersection),
            ("test_CGRect_Intersects", test_CGRect_Intersects),
            ("test_CGRect_OffsetBy", test_CGRect_OffsetBy),
            ("test_CGRect_Divide", test_CGRect_Divide),
            ("test_CGRect_InsetBy", test_CGRect_InsetBy),
            ("test_NSEdgeInsets_BasicConstruction", test_NSEdgeInsets_BasicConstruction),
            ("test_NSEdgeInsetsEqual", test_NSEdgeInsetsEqual),
            ("test_NSMakePoint", test_NSMakePoint),
            ("test_NSMakeSize", test_NSMakeSize),
            ("test_NSMakeRect", test_NSMakeRect),
            ("test_NSEdgeInsetsMake", test_NSEdgeInsetsMake),
            ("test_NSUnionRect", test_NSUnionRect),
            ("test_NSIntersectionRect", test_NSIntersectionRect),
            ("test_NSOffsetRect", test_NSOffsetRect),
            ("test_NSPointInRect", test_NSPointInRect),
            ("test_NSMouseInRect", test_NSMouseInRect),
            ("test_NSContainsRect", test_NSContainsRect),
            ("test_NSIntersectsRect", test_NSIntersectsRect),
            ("test_NSIntegralRect", test_NSIntegralRect),
            ("test_NSIntegralRectWithOptions", test_NSIntegralRectWithOptions),
            ("test_NSDivideRect", test_NSDivideRect),
            ("test_EncodeToNSString", test_EncodeToNSString),
            ("test_EncodeNegativeToNSString", test_EncodeNegativeToNSString),
            ("test_DecodeFromNSString", test_DecodeFromNSString),
            ("test_DecodeEmptyStrings", test_DecodeEmptyStrings),
            ("test_DecodeNegativeFromNSString", test_DecodeNegativeFromNSString),
            ("test_DecodeGarbageFromNSString", test_DecodeGarbageFromNSString),
        ]
    }

    func test_CGFloat_BasicConstruction() {
        XCTAssertEqual(CGFloat().native, 0.0)
        XCTAssertEqual(CGFloat(Double(3.0)).native, 3.0)
    }

    func test_CGFloat_Equality() {
        XCTAssertEqual(CGFloat(), CGFloat())
        XCTAssertEqual(CGFloat(1.0), CGFloat(1.0))
        XCTAssertEqual(CGFloat(-42.0), CGFloat(-42.0))

        XCTAssertNotEqual(CGFloat(1.0), CGFloat(1.4))
        XCTAssertNotEqual(CGFloat(37.3), CGFloat(-42.0))
        XCTAssertNotEqual(CGFloat(1.345), CGFloat())
    }

    func test_CGFloat_LessThanOrEqual() {
        let w = CGFloat(-4.5)
        let x = CGFloat(1.0)
        let y = CGFloat(2.2)

        XCTAssertLessThanOrEqual(CGFloat(), CGFloat())
        XCTAssertLessThanOrEqual(w, w)
        XCTAssertLessThanOrEqual(y, y)

        XCTAssertLessThan(w, x)
        XCTAssertLessThanOrEqual(w, x)
        XCTAssertLessThan(x, y)
        XCTAssertLessThanOrEqual(x, y)
        XCTAssertLessThan(w, y)
        XCTAssertLessThanOrEqual(w, y)
    }

    func test_CGFloat_GreaterThanOrEqual() {
        let w = CGFloat(-4.5)
        let x = CGFloat(1.0)
        let y = CGFloat(2.2)

        XCTAssertGreaterThanOrEqual(CGFloat(), CGFloat())
        XCTAssertGreaterThanOrEqual(w, w)
        XCTAssertGreaterThanOrEqual(y, y)

        XCTAssertGreaterThan(x, w)
        XCTAssertGreaterThanOrEqual(x, w)
        XCTAssertGreaterThan(y, x)
        XCTAssertGreaterThanOrEqual(y, x)
        XCTAssertGreaterThan(y, w)
        XCTAssertGreaterThanOrEqual(y, w)
    }

    func test_CGPoint_BasicConstruction() {
        let p1 = CGPoint()
        XCTAssertEqual(p1.x, CGFloat(0.0))
        XCTAssertEqual(p1.y, CGFloat(0.0))

        let p2 = CGPoint(x: CGFloat(3.6), y: CGFloat(4.5))
        XCTAssertEqual(p2.x, CGFloat(3.6))
        XCTAssertEqual(p2.y, CGFloat(4.5))
    }
    
    func test_CGPoint_ExtendedConstruction() {
        let p1 = CGPoint.zero
        XCTAssertEqual(p1.x, CGFloat(0))
        XCTAssertEqual(p1.y, CGFloat(0))
        
        let p2 = CGPoint(x: Int(3), y: Int(4))
        XCTAssertEqual(p2.x, CGFloat(3))
        XCTAssertEqual(p2.y, CGFloat(4))
        
        let p3 = CGPoint(x: Double(3.6), y: Double(4.5))
        XCTAssertEqual(p3.x, CGFloat(3.6))
        XCTAssertEqual(p3.y, CGFloat(4.5))
    }

    func test_CGSize_BasicConstruction() {
        let s1 = CGSize()
        XCTAssertEqual(s1.width, CGFloat(0.0))
        XCTAssertEqual(s1.height, CGFloat(0.0))

        let s2 = CGSize(width: CGFloat(3.6), height: CGFloat(4.5))
        XCTAssertEqual(s2.width, CGFloat(3.6))
        XCTAssertEqual(s2.height, CGFloat(4.5))
    }
    
    func test_CGSize_ExtendedConstruction() {
        let s1 = CGSize.zero
        XCTAssertEqual(s1.width, CGFloat(0))
        XCTAssertEqual(s1.height, CGFloat(0))
        
        let s2 = CGSize(width: Int(3), height: Int(4))
        XCTAssertEqual(s2.width, CGFloat(3))
        XCTAssertEqual(s2.height, CGFloat(4))
        
        let s3 = CGSize(width: Double(3.6), height: Double(4.5))
        XCTAssertEqual(s3.width, CGFloat(3.6))
        XCTAssertEqual(s3.height, CGFloat(4.5))
    }

    func test_CGRect_BasicConstruction() {
        let r1 = CGRect()
        XCTAssertEqual(r1.origin.x, CGFloat(0.0))
        XCTAssertEqual(r1.origin.y, CGFloat(0.0))
        XCTAssertEqual(r1.size.width, CGFloat(0.0))
        XCTAssertEqual(r1.size.height, CGFloat(0.0))

        let p = CGPoint(x: CGFloat(2.2), y: CGFloat(3.0))
        let s = CGSize(width: CGFloat(5.0), height: CGFloat(5.0))
        let r2 = CGRect(origin: p, size: s)
        XCTAssertEqual(r2.origin.x, p.x)
        XCTAssertEqual(r2.origin.y, p.y)
        XCTAssertEqual(r2.size.width, s.width)
        XCTAssertEqual(r2.size.height, s.height)
    }
    
    func test_CGRect_ExtendedConstruction() {
        let r1 = CGRect.zero
        XCTAssertEqual(r1.origin.x, CGFloat(0.0))
        XCTAssertEqual(r1.origin.y, CGFloat(0.0))
        XCTAssertEqual(r1.size.width, CGFloat(0.0))
        XCTAssertEqual(r1.size.height, CGFloat(0.0))
        
        let r2 = CGRect(x: CGFloat(1.2), y: CGFloat(2.3), width: CGFloat(3.4), height: CGFloat(4.5))
        XCTAssertEqual(r2.origin.x, CGFloat(1.2))
        XCTAssertEqual(r2.origin.y, CGFloat(2.3))
        XCTAssertEqual(r2.size.width, CGFloat(3.4))
        XCTAssertEqual(r2.size.height, CGFloat(4.5))
        
        let r3 = CGRect(x: Double(1.2), y: Double(2.3), width: Double(3.4), height: Double(4.5))
        XCTAssertEqual(r3.origin.x, CGFloat(1.2))
        XCTAssertEqual(r3.origin.y, CGFloat(2.3))
        XCTAssertEqual(r3.size.width, CGFloat(3.4))
        XCTAssertEqual(r3.size.height, CGFloat(4.5))
        
        let r4 = CGRect(x: Int(1), y: Int(2), width: Int(3), height: Int(4))
        XCTAssertEqual(r4.origin.x, CGFloat(1))
        XCTAssertEqual(r4.origin.y, CGFloat(2))
        XCTAssertEqual(r4.size.width, CGFloat(3))
        XCTAssertEqual(r4.size.height, CGFloat(4))
    }

    func test_CGRect_IsNull() {
        XCTAssertTrue(CGRect.null.isNull)
        XCTAssertTrue(CGRect(x: CGFloat.infinity, y: CGFloat.infinity, width: 0, height: 0).isNull)
        XCTAssertTrue(CGRect(x: CGFloat.infinity, y: CGFloat.infinity, width: 10, height: 10).isNull)
        XCTAssertTrue(CGRect(x: CGFloat.infinity, y: CGFloat.infinity, width: -10, height: -10).isNull)
        XCTAssertTrue(CGRect(x: CGFloat.infinity, y: 0, width: 0, height: 0).isNull)
        XCTAssertTrue(CGRect(x: 0, y: CGFloat.infinity, width: 0, height: 0).isNull)
        XCTAssertFalse(CGRect(x: 0, y: 0, width: 0, height: 0).isNull)
    }

    func test_CGRect_IsInfinite() {
        XCTAssertTrue(CGRect.infinite.isInfinite)

        XCTAssertFalse(CGRect(x: 0,
                              y: CGRect.infinite.origin.y,
                              width: CGRect.infinite.size.width,
                              height: CGRect.infinite.size.height).isInfinite)

        XCTAssertFalse(CGRect(x: CGRect.infinite.origin.x,
                              y: 0,
                              width: CGRect.infinite.size.width,
                              height: CGRect.infinite.size.height).isInfinite)

        XCTAssertFalse(CGRect(x: CGRect.infinite.origin.x,
                              y: CGRect.infinite.origin.y,
                              width: 0,
                              height: CGRect.infinite.size.height).isInfinite)

        XCTAssertFalse(CGRect(x: CGRect.infinite.origin.x,
                              y: CGRect.infinite.origin.y,
                              width: CGRect.infinite.size.width,
                              height: 0).isInfinite)

        XCTAssertFalse(CGRect(x: CGFloat.infinity,
                              y: CGFloat.infinity,
                              width: CGFloat.infinity,
                              height: CGFloat.infinity).isInfinite)

        XCTAssertFalse(CGRect.null.isInfinite)
    }

    func test_CGRect_IsEmpty() {
        XCTAssertTrue(CGRect.zero.isEmpty)
        XCTAssertTrue(CGRect.null.isEmpty)
        XCTAssertTrue(CGRect(x: 10, y: 20, width: 30, height: 0).isEmpty)
        XCTAssertTrue(CGRect(x: 10, y: 20, width: 0, height: 30).isEmpty)
        XCTAssertTrue(CGRect(x: 10, y: 20, width: -30, height: 0).isEmpty)
        XCTAssertTrue(CGRect(x: 10, y: 20, width: 0, height: -30).isEmpty)

        var r1 = CGRect.null
        r1.origin.x = 0
        XCTAssertTrue(r1.isEmpty)

        var r2 = CGRect.null
        r2.origin.y = 0
        XCTAssertTrue(r2.isEmpty)

        var r3 = CGRect.null
        r3.size.width = 20
        XCTAssertTrue(r3.isEmpty)

        var r4 = CGRect.null
        r4.size.height = 20
        XCTAssertTrue(r4.isEmpty)

        var r5 = CGRect.null
        r5.size.width = 20
        r5.size.height = 20
        XCTAssertTrue(r5.isEmpty)

        XCTAssertFalse(CGRect.infinite.isEmpty)
        XCTAssertFalse(CGRect.infinite.isEmpty)
    }

    func test_CGRect_Equatable() {
        XCTAssertEqual(CGRect(x: 10, y: 20, width: 30, height: 40), CGRect(x: 10, y: 20, width: 30, height: 40))
        XCTAssertEqual(CGRect(x: -10, y: -20, width: -30, height: -40), CGRect(x: -10, y: -20, width: -30, height: -40))
        XCTAssertEqual(CGRect(x: -10, y: -20, width: 30, height: 40), CGRect(x: 20, y: 20, width: -30, height: -40))

        XCTAssertNotEqual(CGRect(x: 10, y: 20, width: 30, height: 40), CGRect(x: 10, y: 20, width: 30, height: -40))
        XCTAssertNotEqual(CGRect(x: 10, y: 20, width: 30, height: 40), CGRect(x: 10, y: 20, width: -30, height: 40))
        XCTAssertNotEqual(CGRect(x: 10, y: 20, width: 30, height: 40), CGRect(x: 10, y: -20, width: 30, height: 40))
        XCTAssertNotEqual(CGRect(x: 10, y: 20, width: 30, height: 40), CGRect(x: -10, y: 20, width: 30, height: 40))

        XCTAssertEqual(CGRect.infinite, CGRect.infinite)
        XCTAssertEqual(CGRect.null, CGRect.null)
        XCTAssertNotEqual(CGRect.infinite, CGRect.null)

        var r1 = CGRect.null
        r1.size = CGSize(width: 20, height: 20)
        XCTAssertEqual(r1, CGRect.null)

        var r2 = CGRect.null
        r2.origin.x = 20
        XCTAssertEqual(r2, CGRect.null)

        var r3 = CGRect.null
        r3.origin.y = 20
        XCTAssertEqual(r3, CGRect.null)

        var r4 = CGRect.null
        r4.origin = CGPoint(x: 10, y: 20)
        XCTAssertNotEqual(r4, CGRect.null)
    }

    func test_CGRect_CalculatedGeometricProperties() {
        let ε = CGFloat(0.00001)

        let r1 = CGRect(x: 1.2, y: 3.4, width: 5.6, height: 7.8)
        XCTAssertEqual(r1.width, 5.6, accuracy: ε)
        XCTAssertEqual(r1.height, 7.8, accuracy: ε)

        XCTAssertEqual(r1.minX, 1.2, accuracy: ε)
        XCTAssertEqual(r1.midX, 4, accuracy: ε)
        XCTAssertEqual(r1.maxX, 6.8, accuracy: ε)

        XCTAssertEqual(r1.minY, 3.4, accuracy: ε)
        XCTAssertEqual(r1.midY, 7.3, accuracy: ε)
        XCTAssertEqual(r1.maxY, 11.2, accuracy: ε)

        let r2 = CGRect(x: -1.2, y: -3.4, width: 5.6, height: 7.8)
        XCTAssertEqual(r2.width, 5.6, accuracy: ε)
        XCTAssertEqual(r2.height, 7.8, accuracy: ε)

        XCTAssertEqual(r2.minX, -1.2, accuracy: ε)
        XCTAssertEqual(r2.midX, 1.6, accuracy: ε)
        XCTAssertEqual(r2.maxX, 4.4, accuracy: ε)

        XCTAssertEqual(r2.minY, -3.4, accuracy: ε)
        XCTAssertEqual(r2.midY, 0.5, accuracy: ε)
        XCTAssertEqual(r2.maxY, 4.4, accuracy: ε)

        let r3 = CGRect(x: 1.2, y: 3.4, width: -5.6, height: -7.8)
        XCTAssertEqual(r3.width, 5.6, accuracy: ε)
        XCTAssertEqual(r3.height, 7.8, accuracy: ε)

        XCTAssertEqual(r3.minX, -4.4, accuracy: ε)
        XCTAssertEqual(r3.midX, -1.6, accuracy: ε)
        XCTAssertEqual(r3.maxX, 1.2, accuracy: ε)

        XCTAssertEqual(r3.minY, -4.4, accuracy: ε)
        XCTAssertEqual(r3.midY, -0.5, accuracy: ε)
        XCTAssertEqual(r3.maxY, 3.4, accuracy: ε)

        let r4 = CGRect(x: -1.2, y: -3.4, width: -5.6, height: -7.8)
        XCTAssertEqual(r4.width, 5.6, accuracy: ε)
        XCTAssertEqual(r4.height, 7.8, accuracy: ε)

        XCTAssertEqual(r4.minX, -6.8, accuracy: ε)
        XCTAssertEqual(r4.midX, -4.0, accuracy: ε)
        XCTAssertEqual(r4.maxX, -1.2, accuracy: ε)

        XCTAssertEqual(r4.minY, -11.2, accuracy: ε)
        XCTAssertEqual(r4.midY, -7.3, accuracy: ε)
        XCTAssertEqual(r4.maxY, -3.4, accuracy: ε)
    }

    func test_CGRect_Standardized() {
        let ε = CGFloat(0.00001)
        let nullX = CGRect.null.origin.x
        let nullY = CGRect.null.origin.y
        let nullWidth = CGRect.null.size.width
        let nullHeight = CGRect.null.size.height

        let r1 = CGRect(x: 1.9, y: 1.9, width: 10.1, height: 10.2).standardized
        assertEqual(r1, x: 1.9, y: 1.9, width: 10.1, height: 10.2, accuracy: ε)

        let r2 = CGRect(x: 1.9, y: 1.9, width: -10.1, height: -10.2).standardized
        assertEqual(r2, x: -8.2, y: -8.3, width: 10.1, height: 10.2, accuracy: ε)

        let r3 = CGRect(x: -1.9, y: -1.9, width: 10.1, height: 10.2).standardized
        assertEqual(r3, x: -1.9, y: -1.9, width: 10.1, height: 10.2, accuracy: ε)

        let r4 = CGRect(x: -1.9, y: -1.9, width: -10.1, height: -10.2).standardized
        assertEqual(r4, x: -12, y: -12.1, width: 10.1, height: 10.2, accuracy: ε)

        let r5 = CGRect.null.standardized
        assertEqual(r5, x: nullX, y: nullY, width: nullWidth, height: nullHeight)

        var r6 = CGRect.null
        r6.size = CGSize(width: 10, height: 20)
        r6 = r6.standardized
        assertEqual(r6, x: nullX, y: nullY, width: nullWidth, height: nullHeight)

        var r7 = CGRect.null
        r7.size = CGSize(width: -10, height: -20)
        r7 = r7.standardized
        assertEqual(r7, x: nullX, y: nullY, width: nullWidth, height: nullHeight)

        var r8 = CGRect.null
        r8.origin.x = 20
        r8 = r8.standardized
        assertEqual(r8, x: nullX, y: nullY, width: nullWidth, height: nullHeight)

        var r9 = CGRect.null
        r9.origin.y = 20
        r9 = r9.standardized
        assertEqual(r9, x: nullX, y: nullY, width: nullWidth, height: nullHeight)

        var r10 = CGRect.null
        r10.origin = CGPoint(x: 10, y: 20)
        r10 = r10.standardized
        assertEqual(r10, x: 10, y: 20, width: 0, height: 0)
    }

    func test_CGRect_Integral() {
        let ε = CGFloat(0.00001)

        let r1 = CGRect(x: 1.9, y: 1.9, width: 10.1, height: 10.2).integral
        XCTAssertEqual(r1.origin.x, 1, accuracy: ε)
        XCTAssertEqual(r1.origin.y, 1, accuracy: ε)
        XCTAssertEqual(r1.size.width, 11, accuracy: ε)
        XCTAssertEqual(r1.size.height, 12, accuracy: ε)

        let r2 = CGRect(x: 1.9, y: 1.9, width: -10.1, height: -10.2).integral
        XCTAssertEqual(r2.origin.x, -9, accuracy: ε)
        XCTAssertEqual(r2.origin.y, -9, accuracy: ε)
        XCTAssertEqual(r2.size.width, 11, accuracy: ε)
        XCTAssertEqual(r2.size.height, 11, accuracy: ε)

        let r3 = CGRect(x: -1.9, y: -1.9, width: 10.1, height: 10.2).integral
        XCTAssertEqual(r3.origin.x, -2, accuracy: ε)
        XCTAssertEqual(r3.origin.y, -2, accuracy: ε)
        XCTAssertEqual(r3.size.width, 11, accuracy: ε)
        XCTAssertEqual(r3.size.height, 11, accuracy: ε)

        let r4 = CGRect(x: -1.9, y: -1.9, width: -10.1, height: -10.2).integral
        XCTAssertEqual(r4.origin.x, -12, accuracy: ε)
        XCTAssertEqual(r4.origin.y, -13, accuracy: ε)
        XCTAssertEqual(r4.size.width, 11, accuracy: ε)
        XCTAssertEqual(r4.size.height, 12, accuracy: ε)

        let r5 = CGRect.null.integral
        XCTAssertEqual(r5.origin.x, CGRect.null.origin.x)
        XCTAssertEqual(r5.origin.y, CGRect.null.origin.y)
        XCTAssertEqual(r5.size.width, CGRect.null.size.width)
        XCTAssertEqual(r5.size.height, CGRect.null.size.height)

        var r6 = CGRect.null
        r6.origin.x = 10
        r6.size = CGSize(width: -20, height: -30)
        r6 = r6.integral
        XCTAssertEqual(r6.origin.x, 10)
        XCTAssertEqual(r6.origin.y, CGRect.null.origin.y)
        XCTAssertEqual(r6.size.width, -20)
        XCTAssertEqual(r6.size.height, -30)

        var r7 = CGRect.null
        r7.origin.y = 10
        r7.size = CGSize(width: -20, height: -30)
        r7 = r7.integral
        XCTAssertEqual(r7.origin.x, CGRect.null.origin.y)
        XCTAssertEqual(r7.origin.y, 10)
        XCTAssertEqual(r7.size.width, -20)
        XCTAssertEqual(r7.size.height, -30)

        var r8 = CGRect.null
        r8.origin = CGPoint(x: 10, y: 20)
        r8.size = CGSize(width: -30, height: -40)
        r8 = r8.integral
        XCTAssertEqual(r8.origin.x, -20)
        XCTAssertEqual(r8.origin.y, -20)
        XCTAssertEqual(r8.size.width, 30)
        XCTAssertEqual(r8.size.height, 40)
    }

    func test_CGRect_ContainsPoint() {
        XCTAssertFalse(CGRect.null.contains(CGPoint()))
        XCTAssertFalse(CGRect.zero.contains(CGPoint()))

        let r1 = CGRect(x: 5, y: 5, width: 10, height: 10)
        XCTAssertFalse(r1.contains(CGPoint(x: 1, y: 2)))
        XCTAssertFalse(r1.contains(CGPoint(x: 7, y: 2)))
        XCTAssertFalse(r1.contains(CGPoint(x: 2, y: 7)))
        XCTAssertFalse(r1.contains(CGPoint(x: -7, y: -7)))
        XCTAssertFalse(r1.contains(CGPoint(x: 15, y: 15)))
        XCTAssertTrue(r1.contains(CGPoint(x: 7, y: 7)))
        XCTAssertTrue(r1.contains(CGPoint(x: 10, y: 10)))
        XCTAssertTrue(r1.contains(CGPoint(x: 5, y: 5)))

        let r2 = CGRect(x: -5, y: -5, width: -10, height: -10)
        XCTAssertFalse(r2.contains(CGPoint(x: -1, y: -2)))
        XCTAssertFalse(r2.contains(CGPoint(x: -7, y: -2)))
        XCTAssertFalse(r2.contains(CGPoint(x: -2, y: -7)))
        XCTAssertFalse(r2.contains(CGPoint(x: 7, y: 7)))
        XCTAssertFalse(r2.contains(CGPoint(x: -5, y: -5)))
        XCTAssertTrue(r2.contains(CGPoint(x: -7, y: -7)))
        XCTAssertTrue(r2.contains(CGPoint(x: -10, y: -10)))
        XCTAssertTrue(r2.contains(CGPoint(x: -15, y: -15)))

        XCTAssertTrue(CGRect.infinite.contains(CGPoint()))
    }

    func test_CGRect_ContainsRect() {
        XCTAssertFalse(CGRect.zero.contains(.infinite))
        XCTAssertTrue(CGRect.zero.contains(.null))
        XCTAssertTrue(CGRect.zero.contains(CGRect.zero))
        XCTAssertFalse(CGRect.zero.contains(CGRect(x: -1.2, y: -3.4, width: 5.6, height: 7.8)))

        XCTAssertFalse(CGRect.null.contains(.infinite))
        XCTAssertTrue(CGRect.null.contains(.null))
        XCTAssertFalse(CGRect.null.contains(CGRect.zero))
        XCTAssertFalse(CGRect.null.contains(CGRect(x: -1.2, y: -3.4, width: 5.6, height: 7.8)))

        XCTAssertTrue(CGRect.infinite.contains(.infinite))
        XCTAssertTrue(CGRect.infinite.contains(.null))
        XCTAssertTrue(CGRect.infinite.contains(CGRect.zero))
        XCTAssertTrue(CGRect.infinite.contains(CGRect(x: -1.2, y: -3.4, width: 5.6, height: 7.8)))

        let r1 = CGRect(x: 10, y: 20, width: 30, height: 40)
        XCTAssertTrue(r1.contains(r1))

        let r2 = CGRect(x: -10, y: -20, width: -30, height: -40)
        XCTAssertTrue(r2.contains(r2))

        let r3 = CGRect(x: -10, y: -20, width: 30, height: 40)
        let r4 = CGRect(x: 20, y: 20, width: -30, height: -40)
        XCTAssertTrue(r3.contains(r4))

        let r5 = CGRect(x: -10, y: -10, width: 20, height: 20)
        let r6 = CGRect(x: -5, y: -5, width: 10, height: 10)
        XCTAssertTrue(r5.contains(r6))
        XCTAssertFalse(r6.contains(r5))
    }

    func test_CGRect_Union() {
        let r1 = CGRect.null
        let r2 = CGRect.null
        let u1 = r1.union(r2)
        XCTAssertEqual(u1.origin.x, CGRect.null.origin.x)
        XCTAssertEqual(u1.origin.y, CGRect.null.origin.y)
        XCTAssertEqual(u1.size.width, CGRect.null.size.width)
        XCTAssertEqual(u1.size.height, CGRect.null.size.height)

        let r3 = CGRect.null
        var r4 = CGRect.null
        r4.size = CGSize(width: 10, height: 20)
        let u2 = r3.union(r4)
        XCTAssertEqual(u2.origin.x, r4.origin.x)
        XCTAssertEqual(u2.origin.y, r4.origin.y)
        XCTAssertEqual(u2.size.width, r4.size.width)
        XCTAssertEqual(u2.size.height, r4.size.height)

        let u3 = r4.union(r3)
        XCTAssertEqual(u3.origin.x, r3.origin.x)
        XCTAssertEqual(u3.origin.y, r3.origin.y)
        XCTAssertEqual(u3.size.width, r3.size.width)
        XCTAssertEqual(u3.size.height, r3.size.height)

        let r5 = CGRect(x: -1.2, y: -3.4, width: -5.6, height: -7.8)
        let r6 = CGRect(x: 1.2, y: 3.4, width: 5.6, height: 7.8)
        let u4 = r5.union(r6)
        XCTAssertEqual(u4.origin.x, -6.8)
        XCTAssertEqual(u4.origin.y, -11.2)
        XCTAssertEqual(u4.size.width, 13.6)
        XCTAssertEqual(u4.size.height, 22.4)

        let r7 = CGRect(x: 1, y: 2, width: 3, height: 4)
        let r8 = CGRect.infinite
        let u5 = r7.union(r8)
        XCTAssertEqual(u5.origin.x, r8.origin.x)
        XCTAssertEqual(u5.origin.y, r8.origin.y)
        XCTAssertEqual(u5.size.width, r8.size.width)
        XCTAssertEqual(u5.size.height, r8.size.height)
    }

    func test_CGRect_Intersection() {
        let r1 = CGRect(x: 10, y: 10, width: 50, height: 60)
        let r2 = CGRect(x: 25, y: 25, width: 60, height: 70)
        let i1 = r1.intersection(r2)
        XCTAssertEqual(i1.origin.x, 25)
        XCTAssertEqual(i1.origin.y, 25)
        XCTAssertEqual(i1.size.width, 35)
        XCTAssertEqual(i1.size.height, 45)

        let r3 = CGRect(x: 85, y: 95, width: -60, height: -70)
        let i2 = r1.intersection(r3)
        XCTAssertEqual(i2.origin.x, 25)
        XCTAssertEqual(i2.origin.y, 25)
        XCTAssertEqual(i2.size.width, 35)
        XCTAssertEqual(i2.size.height, 45)

        let r4 = CGRect(x: -10, y: -10, width: -30, height: -30)
        let i3 = r1.intersection(r4)
        XCTAssertEqual(i3.origin.x, CGRect.null.origin.x)
        XCTAssertEqual(i3.origin.y, CGRect.null.origin.y)
        XCTAssertEqual(i3.size.width, CGRect.null.size.width)
        XCTAssertEqual(i3.size.height, CGRect.null.size.height)

        let r5 = CGRect.null
        let i4 = r1.intersection(r5)
        XCTAssertEqual(i4.origin.x, CGRect.null.origin.x)
        XCTAssertEqual(i4.origin.y, CGRect.null.origin.y)
        XCTAssertEqual(i4.size.width, CGRect.null.size.width)
        XCTAssertEqual(i4.size.height, CGRect.null.size.height)

        let i5 = r5.intersection(r1)
        XCTAssertEqual(i5.origin.x, CGRect.null.origin.x)
        XCTAssertEqual(i5.origin.y, CGRect.null.origin.y)
        XCTAssertEqual(i5.size.width, CGRect.null.size.width)
        XCTAssertEqual(i5.size.height, CGRect.null.size.height)

        var r6 = CGRect.null
        r6.size = CGSize(width: 10, height: 20)
        r6.origin.x = 30
        let i6 = r5.intersection(r6)
        XCTAssertEqual(i6.origin.x, CGRect.null.origin.x)
        XCTAssertEqual(i6.origin.y, CGRect.null.origin.y)
        XCTAssertEqual(i6.size.width, CGRect.null.size.width)
        XCTAssertEqual(i6.size.height, CGRect.null.size.height)

        let i7 = r1.intersection(.infinite)
        XCTAssertEqual(i7.origin.x, r1.origin.x)
        XCTAssertEqual(i7.origin.y, r1.origin.y)
        XCTAssertEqual(i7.size.width, r1.size.width)
        XCTAssertEqual(i7.size.height, r1.size.height)

        let i8 = CGRect.infinite.intersection(.infinite)
        XCTAssertEqual(i8.origin.x, CGRect.infinite.origin.x)
        XCTAssertEqual(i8.origin.y, CGRect.infinite.origin.y)
        XCTAssertEqual(i8.size.width, CGRect.infinite.size.width)
        XCTAssertEqual(i8.size.height, CGRect.infinite.size.height)

        let r7 = CGRect(x: -10, y: -10, width: 20, height: 20)
        let i9 = r7.intersection(.zero)
        XCTAssertEqual(i9.origin.x, 0)
        XCTAssertEqual(i9.origin.y, 0)
        XCTAssertEqual(i9.size.width, 0)
        XCTAssertEqual(i9.size.height, 0)
    }

    func test_CGRect_Intersects() {
        let r1 = CGRect(x: 10, y: 10, width: 50, height: 60)
        let r2 = CGRect(x: 25, y: 25, width: 60, height: 70)
        XCTAssertTrue(r1.intersects(r2))

        let r3 = CGRect(x: 85, y: 95, width: -60, height: -70)
        XCTAssertTrue(r1.intersects(r3))

        let r4 = CGRect(x: -10, y: -10, width: -30, height: -30)
        XCTAssertFalse(r1.intersects(r4))

        let r5 = CGRect.null
        XCTAssertFalse(r1.intersects(r5))
        XCTAssertFalse(r5.intersects(r1))

        var r6 = CGRect.null
        r6.size = CGSize(width: 10, height: 20)
        r6.origin.x = 30
        XCTAssertFalse(r5.intersects(r6))

        XCTAssertTrue(r1.intersects(.infinite))

        XCTAssertTrue(CGRect.infinite.intersects(.infinite))

        let r7 = CGRect(x: -10, y: -10, width: 20, height: 20)
        XCTAssertTrue(r7.intersects(.zero))
    }

    func test_CGRect_OffsetBy() {
        var r1 = CGRect.null
        r1.size = CGSize(width: 10, height: 20)
        r1.origin.x = 30
        let o1 = r1.offsetBy(dx: 40, dy: 50)
        XCTAssertEqual(o1.origin.x, r1.origin.x)
        XCTAssertEqual(o1.origin.y, r1.origin.y)
        XCTAssertEqual(o1.size.width, r1.size.width)
        XCTAssertEqual(o1.size.height, r1.size.height)

        var r2 = CGRect.null
        r2.size = CGSize(width: 10, height: 20)
        r2.origin.y = 30
        let o2 = r2.offsetBy(dx: 40, dy: 50)
        XCTAssertEqual(o2.origin.x, r2.origin.x)
        XCTAssertEqual(o2.origin.y, r2.origin.y)
        XCTAssertEqual(o2.size.width, r2.size.width)
        XCTAssertEqual(o2.size.height, r2.size.height)

        let o3 = CGRect(x: 1.2, y: 3.4, width: 5.6, height: 7.8).offsetBy(dx: 10.5, dy: 20.5)
        XCTAssertEqual(o3.origin.x, 11.7)
        XCTAssertEqual(o3.origin.y, 23.9)
        XCTAssertEqual(o3.size.width, 5.6)
        XCTAssertEqual(o3.size.height, 7.8)

        let o4 = CGRect(x: -1.2, y: -3.4, width: -5.6, height: -7.8).offsetBy(dx: -10.5, dy: -20.5)
        XCTAssertEqual(o4.origin.x, -17.3)
        XCTAssertEqual(o4.origin.y, -31.7)
        XCTAssertEqual(o4.size.width, 5.6)
        XCTAssertEqual(o4.size.height, 7.8)
    }

    func test_CGRect_Divide() {
        let r1 = CGRect(x: 10, y: 20, width: 30, height: 40)
        let d1 = r1.divided(atDistance: 10, from: .minXEdge)
        XCTAssertEqual(d1.slice.origin.x, 10)
        XCTAssertEqual(d1.slice.origin.y, 20)
        XCTAssertEqual(d1.slice.size.width, 10)
        XCTAssertEqual(d1.slice.size.height, 40)
        XCTAssertEqual(d1.remainder.origin.x, 20)
        XCTAssertEqual(d1.remainder.origin.y, 20)
        XCTAssertEqual(d1.remainder.size.width, 20)
        XCTAssertEqual(d1.remainder.size.height, 40)

        let d2 = r1.divided(atDistance: 10, from: .maxXEdge)
        XCTAssertEqual(d2.slice.origin.x, 30)
        XCTAssertEqual(d2.slice.origin.y, 20)
        XCTAssertEqual(d2.slice.size.width, 10)
        XCTAssertEqual(d2.slice.size.height, 40)
        XCTAssertEqual(d2.remainder.origin.x, 10)
        XCTAssertEqual(d2.remainder.origin.y, 20)
        XCTAssertEqual(d2.remainder.size.width, 20)
        XCTAssertEqual(d2.remainder.size.height, 40)

        let d3 = r1.divided(atDistance: 10, from: .minYEdge)
        XCTAssertEqual(d3.slice.origin.x, 10)
        XCTAssertEqual(d3.slice.origin.y, 20)
        XCTAssertEqual(d3.slice.size.width, 30)
        XCTAssertEqual(d3.slice.size.height, 10)
        XCTAssertEqual(d3.remainder.origin.x, 10)
        XCTAssertEqual(d3.remainder.origin.y, 30)
        XCTAssertEqual(d3.remainder.size.width, 30)
        XCTAssertEqual(d3.remainder.size.height, 30)

        let d4 = r1.divided(atDistance: 10, from: .maxYEdge)
        XCTAssertEqual(d4.slice.origin.x, 10)
        XCTAssertEqual(d4.slice.origin.y, 50)
        XCTAssertEqual(d4.slice.size.width, 30)
        XCTAssertEqual(d4.slice.size.height, 10)
        XCTAssertEqual(d4.remainder.origin.x, 10)
        XCTAssertEqual(d4.remainder.origin.y, 20)
        XCTAssertEqual(d4.remainder.size.width, 30)
        XCTAssertEqual(d4.remainder.size.height, 30)

        let d5 = r1.divided(atDistance: 31, from: .minXEdge)
        XCTAssertEqual(d5.slice.origin.x, 10)
        XCTAssertEqual(d5.slice.origin.y, 20)
        XCTAssertEqual(d5.slice.size.width, 30)
        XCTAssertEqual(d5.slice.size.height, 40)
        XCTAssertEqual(d5.remainder.origin.x, 40)
        XCTAssertEqual(d5.remainder.origin.y, 20)
        XCTAssertEqual(d5.remainder.size.width, 0)
        XCTAssertEqual(d5.remainder.size.height, 40)

        let d6 = r1.divided(atDistance: 31, from: .maxXEdge)
        XCTAssertEqual(d6.slice.origin.x, 10)
        XCTAssertEqual(d6.slice.origin.y, 20)
        XCTAssertEqual(d6.slice.size.width, 30)
        XCTAssertEqual(d6.slice.size.height, 40)
        XCTAssertEqual(d6.remainder.origin.x, 10)
        XCTAssertEqual(d6.remainder.origin.y, 20)
        XCTAssertEqual(d6.remainder.size.width, 0)
        XCTAssertEqual(d6.remainder.size.height, 40)

        let d7 = r1.divided(atDistance: 41, from: .minYEdge)
        XCTAssertEqual(d7.slice.origin.x, 10)
        XCTAssertEqual(d7.slice.origin.y, 20)
        XCTAssertEqual(d7.slice.size.width, 30)
        XCTAssertEqual(d7.slice.size.height, 40)
        XCTAssertEqual(d7.remainder.origin.x, 10)
        XCTAssertEqual(d7.remainder.origin.y, 60)
        XCTAssertEqual(d7.remainder.size.width, 30)
        XCTAssertEqual(d7.remainder.size.height, 0)

        let d8 = r1.divided(atDistance: 41, from: .maxYEdge)
        XCTAssertEqual(d8.slice.origin.x, 10)
        XCTAssertEqual(d8.slice.origin.y, 20)
        XCTAssertEqual(d8.slice.size.width, 30)
        XCTAssertEqual(d8.slice.size.height, 40)
        XCTAssertEqual(d8.remainder.origin.x, 10)
        XCTAssertEqual(d8.remainder.origin.y, 20)
        XCTAssertEqual(d8.remainder.size.width, 30)
        XCTAssertEqual(d8.remainder.size.height, 0)

        let d9 = CGRect(x: -10, y: -20, width: -30, height: -40).divided(atDistance: 10, from: .minXEdge)
        XCTAssertEqual(d9.slice.origin.x, -40)
        XCTAssertEqual(d9.slice.origin.y, -60)
        XCTAssertEqual(d9.slice.size.width, 10)
        XCTAssertEqual(d9.slice.size.height, 40)
        XCTAssertEqual(d9.remainder.origin.x, -30)
        XCTAssertEqual(d9.remainder.origin.y, -60)
        XCTAssertEqual(d9.remainder.size.width, 20)
        XCTAssertEqual(d9.remainder.size.height, 40)

        var r2 = CGRect.null
        r2.size = CGSize(width: 10, height: 20)
        r2.origin.x = 30
        let d10 = r2.divided(atDistance: 10, from: .minXEdge)
        XCTAssertEqual(d10.slice.origin.x, CGRect.null.origin.x)
        XCTAssertEqual(d10.slice.origin.y, CGRect.null.origin.y)
        XCTAssertEqual(d10.slice.size.width, CGRect.null.size.width)
        XCTAssertEqual(d10.slice.size.height, CGRect.null.size.height)
        XCTAssertEqual(d10.remainder.origin.x, CGRect.null.origin.x)
        XCTAssertEqual(d10.remainder.origin.y, CGRect.null.origin.y)
        XCTAssertEqual(d10.remainder.size.width, CGRect.null.size.width)
        XCTAssertEqual(d10.remainder.size.height, CGRect.null.size.height)

        var r3 = CGRect.null
        r3.size = CGSize(width: 10, height: 20)
        r3.origin.y = 30
        let d11 = r3.divided(atDistance: 10, from: .minXEdge)
        XCTAssertEqual(d11.slice.origin.x, CGRect.null.origin.x)
        XCTAssertEqual(d11.slice.origin.y, CGRect.null.origin.y)
        XCTAssertEqual(d11.slice.size.width, CGRect.null.size.width)
        XCTAssertEqual(d11.slice.size.height, CGRect.null.size.height)
        XCTAssertEqual(d11.remainder.origin.x, CGRect.null.origin.x)
        XCTAssertEqual(d11.remainder.origin.y, CGRect.null.origin.y)
        XCTAssertEqual(d11.remainder.size.width, CGRect.null.size.width)
        XCTAssertEqual(d11.remainder.size.height, CGRect.null.size.height)
    }

    func test_CGRect_InsetBy() {
        let ε = CGFloat(0.00001)
        let nullX = CGRect.null.origin.x
        let nullY = CGRect.null.origin.y
        let nullWidth = CGRect.null.size.width
        let nullHeight = CGRect.null.size.height

        let r1 = CGRect(x: 1.2, y: 3.4, width: 5.6, height: 7.8)
        assertEqual(r1.insetBy(dx: 2.8, dy: 0), x: 4, y: 3.4, width: 0, height: 7.8, accuracy: ε)
        assertEqual(r1.insetBy(dx: 0, dy: 3.9), x: 1.2, y: 7.3, width: 5.6, height: 0, accuracy: ε)
        assertEqual(r1.insetBy(dx: 10, dy: 10), x: nullX, y: nullY, width: nullWidth, height: nullHeight)
        assertEqual(r1.insetBy(dx: 10, dy: -10), x: nullX, y: nullY, width: nullWidth, height: nullHeight)
        assertEqual(r1.insetBy(dx: -10, dy: 10), x: nullX, y: nullY, width: nullWidth, height: nullHeight)
        assertEqual(r1.insetBy(dx: -10, dy: -10), x: -8.8, y: -6.6, width: 25.6, height: 27.8, accuracy: ε)

        let r2 = CGRect(x: 1.2, y: 3.4, width: -5.6, height: -7.8)
        assertEqual(r2.insetBy(dx: 2.8, dy: 0), x: -1.6, y: -4.4, width: 0, height: 7.8, accuracy: ε)
        assertEqual(r2.insetBy(dx: 0, dy: 3.9), x: -4.4, y: -0.5, width: 5.6, height: 0, accuracy: ε)
        assertEqual(r2.insetBy(dx: 10, dy: 10), x: nullX, y: nullY, width: nullWidth, height: nullHeight)
        assertEqual(r2.insetBy(dx: 10, dy: -10), x: nullX, y: nullY, width: nullWidth, height: nullHeight)
        assertEqual(r2.insetBy(dx: -10, dy: 10), x: nullX, y: nullY, width: nullWidth, height: nullHeight)
        assertEqual(r2.insetBy(dx: -10, dy: -10), x: -14.4, y: -14.4, width: 25.6, height: 27.8, accuracy: ε)

        let r3 = CGRect(x: -1.2, y: -3.4, width: 5.6, height: 7.8)
        assertEqual(r3.insetBy(dx: 2.8, dy: 0), x: 1.6, y: -3.4, width: 0, height: 7.8, accuracy: ε)
        assertEqual(r3.insetBy(dx: 0, dy: 3.9), x: -1.2, y: 0.5, width: 5.6, height: 0, accuracy: ε)
        assertEqual(r3.insetBy(dx: 10, dy: 10), x: nullX, y: nullY, width: nullWidth, height: nullHeight)
        assertEqual(r3.insetBy(dx: 10, dy: -10), x: nullX, y: nullY, width: nullWidth, height: nullHeight)
        assertEqual(r3.insetBy(dx: -10, dy: 10), x: nullX, y: nullY, width: nullWidth, height: nullHeight)
        assertEqual(r3.insetBy(dx: -10, dy: -10), x: -11.2, y: -13.4, width: 25.6, height: 27.8, accuracy: ε)

        let r4 = CGRect(x: -1.2, y: -3.4, width: -5.6, height: -7.8)
        assertEqual(r4.insetBy(dx: 2.8, dy: 0), x: -4, y: -11.2, width: 0, height: 7.8, accuracy: ε)
        assertEqual(r4.insetBy(dx: 0, dy: 3.9), x: -6.8, y: -7.3, width: 5.6, height: 0, accuracy: ε)
        assertEqual(r4.insetBy(dx: 10, dy: 10), x: nullX, y: nullY, width: nullWidth, height: nullHeight)
        assertEqual(r4.insetBy(dx: 10, dy: -10), x: nullX, y: nullY, width: nullWidth, height: nullHeight)
        assertEqual(r4.insetBy(dx: -10, dy: 10), x: nullX, y: nullY, width: nullWidth, height: nullHeight)
        assertEqual(r4.insetBy(dx: -10, dy: -10), x: -16.8, y: -21.2, width: 25.6, height: 27.8, accuracy: ε)

        var r5 = CGRect.null
        r5.size = CGSize(width: 10, height: 20)
        r5.origin.x = 30
        let i1 = r5.insetBy(dx: 50, dy: 60)
        XCTAssertEqual(i1.origin.x, 30)
        XCTAssertEqual(i1.origin.y, r5.origin.y)
        XCTAssertEqual(i1.size.width, 10)
        XCTAssertEqual(i1.size.height, 20)

        var r6 = CGRect.null
        r6.size = CGSize(width: 10, height: 20)
        r6.origin.y = 30
        let i2 = r6.insetBy(dx: 50, dy: 60)
        XCTAssertEqual(i2.origin.x, r6.origin.x)
        XCTAssertEqual(i2.origin.y, 30)
        XCTAssertEqual(i2.size.width, 10)
        XCTAssertEqual(i2.size.height, 20)
    }
    
    func test_CGRect_SpecialValues() {
        let r1 = CGRect.null
        XCTAssertEqual(r1.origin.x, CGFloat.infinity)
        XCTAssertEqual(r1.origin.y, CGFloat.infinity)
        XCTAssertEqual(r1.size.width, CGFloat(0.0))
        XCTAssertEqual(r1.size.height, CGFloat(0.0))
        
        let r2 = CGRect.infinite
        XCTAssertEqual(r2.origin.x, -CGFloat.greatestFiniteMagnitude / 2)
        XCTAssertEqual(r2.origin.y, -CGFloat.greatestFiniteMagnitude / 2)
        XCTAssertEqual(r2.size.width, CGFloat.greatestFiniteMagnitude)
        XCTAssertEqual(r2.size.height, CGFloat.greatestFiniteMagnitude)
    }

    func test_NSEdgeInsets_BasicConstruction() {
        let i1 = NSEdgeInsets()
        XCTAssertEqual(i1.top, CGFloat(0.0))
        XCTAssertEqual(i1.left, CGFloat(0.0))
        XCTAssertEqual(i1.bottom, CGFloat(0.0))
        XCTAssertEqual(i1.right, CGFloat(0.0))

        let i2 = NSEdgeInsets(top: CGFloat(3.6), left: CGFloat(4.5), bottom: CGFloat(5.0), right: CGFloat(-1.0))
        XCTAssertEqual(i2.top, CGFloat(3.6))
        XCTAssertEqual(i2.left, CGFloat(4.5))
        XCTAssertEqual(i2.bottom, CGFloat(5.0))
        XCTAssertEqual(i2.right, CGFloat(-1.0))
    }

    func test_NSEdgeInsetsEqual() {
        let variant1 = NSEdgeInsets(top: CGFloat(3.6), left: CGFloat(4.5), bottom: CGFloat(5.0), right: CGFloat(-1.0))
        let variant1Copy = NSEdgeInsets(top: CGFloat(3.6), left: CGFloat(4.5), bottom: CGFloat(5.0), right: CGFloat(-1.0))
        let variant2 = NSEdgeInsets(top: CGFloat(3.1), left: CGFloat(4.5), bottom: CGFloat(5.0), right: CGFloat(-1.0))
        XCTAssertTrue(NSEdgeInsetsEqual(variant1, variant1Copy))
        XCTAssertFalse(NSEdgeInsetsEqual(variant1, variant2))
    }

    func test_NSMakePoint() {
        let p2 = NSMakePoint(CGFloat(3.6), CGFloat(4.5))
        XCTAssertEqual(p2.x, CGFloat(3.6))
        XCTAssertEqual(p2.y, CGFloat(4.5))
    }

    func test_NSMakeSize() {
        let s2 = NSMakeSize(CGFloat(3.6), CGFloat(4.5))
        XCTAssertEqual(s2.width, CGFloat(3.6))
        XCTAssertEqual(s2.height, CGFloat(4.5))
    }

    func test_NSMakeRect() {
        let r2 = NSMakeRect(CGFloat(2.2), CGFloat(3.0), CGFloat(5.0), CGFloat(5.0))
        XCTAssertEqual(r2.origin.x, CGFloat(2.2))
        XCTAssertEqual(r2.origin.y, CGFloat(3.0))
        XCTAssertEqual(r2.size.width, CGFloat(5.0))
        XCTAssertEqual(r2.size.height, CGFloat(5.0))
    }

    func test_NSEdgeInsetsMake() {
        let i2 = NSEdgeInsetsMake(CGFloat(2.2), CGFloat(3.0), CGFloat(5.0), CGFloat(5.0))
        XCTAssertEqual(i2.top, CGFloat(2.2))
        XCTAssertEqual(i2.left, CGFloat(3.0))
        XCTAssertEqual(i2.bottom, CGFloat(5.0))
        XCTAssertEqual(i2.right, CGFloat(5.0))
    }

    func test_NSUnionRect() {
        let r1 = NSMakeRect(CGFloat(1.2), CGFloat(3.1), CGFloat(10.0), CGFloat(10.0))
        let r2 = NSMakeRect(CGFloat(10.2), CGFloat(2.5), CGFloat(5.0), CGFloat(5.0))

        XCTAssertTrue(NSIsEmptyRect(NSUnionRect(NSZeroRect, NSZeroRect)))
        XCTAssertTrue(NSEqualRects(r1, NSUnionRect(r1, NSZeroRect)))
        XCTAssertTrue(NSEqualRects(r2, NSUnionRect(NSZeroRect, r2)))

        let r3 = NSUnionRect(r1, r2)
        XCTAssertEqual(r3.origin.x, CGFloat(1.2))
        XCTAssertEqual(r3.origin.y, CGFloat(2.5))
        XCTAssertEqual(r3.size.width, CGFloat(14.0))
        XCTAssertEqual(r3.size.height, CGFloat(10.6))
    }

    func test_NSIntersectionRect() {
        let r1 = NSMakeRect(CGFloat(1.2), CGFloat(3.1), CGFloat(10.0), CGFloat(10.0))
        let r2 = NSMakeRect(CGFloat(-2.3), CGFloat(-1.5), CGFloat(1.0), CGFloat(1.0))
        let r3 = NSMakeRect(CGFloat(10.2), CGFloat(2.5), CGFloat(5.0), CGFloat(5.0))

        XCTAssertTrue(NSIsEmptyRect(NSIntersectionRect(r1, r2)))

        let r4 = NSIntersectionRect(r1, r3)
        XCTAssertEqual(r4.origin.x, CGFloat(10.2))
        XCTAssertEqual(r4.origin.y, CGFloat(3.1))
        XCTAssertEqual(r4.size.width, CGFloat(1.0))
        XCTAssertEqual(r4.size.height, CGFloat(4.4))
    }

    func test_NSOffsetRect() {
        let r1 = NSMakeRect(CGFloat(1.2), CGFloat(3.1), CGFloat(10.0), CGFloat(10.0))
        let r2 = NSOffsetRect(r1, CGFloat(2.0), CGFloat(-5.0))
        let expectedRect = NSMakeRect(CGFloat(3.2), CGFloat(-1.9), CGFloat(10.0), CGFloat(10.0))
        
        XCTAssertTrue(_NSRect(expectedRect, equalsToRect: r2))
    }

    func test_NSPointInRect() {
        let p1 = NSMakePoint(CGFloat(2.2), CGFloat(5.3))
        let p2 = NSMakePoint(CGFloat(1.2), CGFloat(3.1))
        let p3 = NSMakePoint(CGFloat(1.2), CGFloat(5.3))
        let p4 = NSMakePoint(CGFloat(5.2), CGFloat(3.1))
        let p5 = NSMakePoint(CGFloat(11.2), CGFloat(13.1))
        let r1 = NSMakeRect(CGFloat(1.2), CGFloat(3.1), CGFloat(10.0), CGFloat(10.0))
        let r2 = NSMakeRect(CGFloat(-2.3), CGFloat(-1.5), CGFloat(1.0), CGFloat(1.0))

        XCTAssertFalse(NSPointInRect(NSZeroPoint, NSZeroRect))
        XCTAssertFalse(NSPointInRect(p1, r2))
        XCTAssertTrue(NSPointInRect(p1, r1))
        XCTAssertTrue(NSPointInRect(p2, r1))
        XCTAssertTrue(NSPointInRect(p3, r1))
        XCTAssertTrue(NSPointInRect(p4, r1))
        XCTAssertFalse(NSPointInRect(p5, r1))
    }

    func test_NSMouseInRect() {
        let p1 = NSMakePoint(CGFloat(2.2), CGFloat(5.3))
        let r1 = NSMakeRect(CGFloat(1.2), CGFloat(3.1), CGFloat(10.0), CGFloat(10.0))
        let r2 = NSMakeRect(CGFloat(-2.3), CGFloat(-1.5), CGFloat(1.0), CGFloat(1.0))

        XCTAssertFalse(NSMouseInRect(NSZeroPoint, NSZeroRect, true))
        XCTAssertFalse(NSMouseInRect(p1, r2, true))
        XCTAssertTrue(NSMouseInRect(p1, r1, true))

        let p2 = NSMakePoint(NSMinX(r1), NSMaxY(r1))
        XCTAssertFalse(NSMouseInRect(p2, r1, true))
        XCTAssertTrue(NSMouseInRect(p2, r1, false))

        let p3 = NSMakePoint(NSMinX(r1), NSMinY(r1))
        XCTAssertFalse(NSMouseInRect(p3, r1, false))
        XCTAssertTrue(NSMouseInRect(p3, r1, true))
    }

    func test_NSContainsRect() {
        let r1 = NSMakeRect(CGFloat(1.2), CGFloat(3.1), CGFloat(10.0), CGFloat(10.0))
        let r2 = NSMakeRect(CGFloat(-2.3), CGFloat(-1.5), CGFloat(1.0), CGFloat(1.0))
        let r3 = NSMakeRect(CGFloat(10.2), CGFloat(5.5), CGFloat(0.5), CGFloat(5.0))

        XCTAssertFalse(NSContainsRect(r1, NSZeroRect))
        XCTAssertFalse(NSContainsRect(r1, r2))
        XCTAssertFalse(NSContainsRect(r2, r1))
        XCTAssertTrue(NSContainsRect(r1, r3))
    }

    func test_NSIntersectsRect() {
        let r1 = NSMakeRect(CGFloat(1.2), CGFloat(3.1), CGFloat(10.0), CGFloat(10.0))
        let r2 = NSMakeRect(CGFloat(-2.3), CGFloat(-1.5), CGFloat(1.0), CGFloat(1.0))
        let r3 = NSMakeRect(CGFloat(10.2), CGFloat(2.5), CGFloat(5.0), CGFloat(5.0))

        XCTAssertFalse(NSIntersectsRect(NSZeroRect, NSZeroRect))
        XCTAssertFalse(NSIntersectsRect(r1, NSZeroRect))
        XCTAssertFalse(NSIntersectsRect(NSZeroRect, r2))
        XCTAssertFalse(NSIntersectsRect(r1, r2))
        XCTAssertTrue(NSIntersectsRect(r1, r3))
    }

    func test_NSIntegralRect() {
        let referenceNegativeRect = NSMakeRect(CGFloat(-0.6), CGFloat(-5.4), CGFloat(-105.7), CGFloat(-24.3))
        XCTAssertEqual(NSIntegralRect(referenceNegativeRect), NSZeroRect)

        
        let referenceRect = NSMakeRect(CGFloat(0.6), CGFloat(5.4), CGFloat(105.7), CGFloat(24.3))
        let referenceNegativeOriginRect = NSMakeRect(CGFloat(-0.6), CGFloat(-5.4), CGFloat(105.7), CGFloat(24.3))
        
        var expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(5.0), CGFloat(107.0), CGFloat(25.0))
        var result = NSIntegralRect(referenceRect)
        XCTAssertEqual(result, expectedResult)

        expectedResult = NSMakeRect(CGFloat(-1.0), CGFloat(-6.0), CGFloat(107.0), CGFloat(25.0))
        result = NSIntegralRect(referenceNegativeOriginRect)
        XCTAssertEqual(result, expectedResult)
    
    }
    
    func test_NSIntegralRectWithOptions() {
        let referenceRect = NSMakeRect(CGFloat(0.6), CGFloat(5.4), CGFloat(105.7), CGFloat(24.3))
        let referenceNegativeRect = NSMakeRect(CGFloat(-0.6), CGFloat(-5.4), CGFloat(-105.7), CGFloat(-24.3))
        let referenceNegativeOriginRect = NSMakeRect(CGFloat(-0.6), CGFloat(-5.4), CGFloat(105.7), CGFloat(24.3))

        var options: AlignmentOptions = [.alignMinXInward, .alignMinYInward, .alignHeightInward, .alignWidthInward]
        var expectedResult = NSMakeRect(CGFloat(1.0), CGFloat(6.0), CGFloat(105.0), CGFloat(24.0))
        var result = NSIntegralRectWithOptions(referenceRect, options)
        XCTAssertEqual(result, expectedResult)

        options = [.alignMinXOutward, .alignMinYOutward, .alignHeightOutward, .alignWidthOutward]
        expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(5.0), CGFloat(106.0), CGFloat(25.0))
        result = NSIntegralRectWithOptions(referenceRect, options)
        XCTAssertEqual(result, expectedResult)

        options = [.alignMinXInward, .alignMinYInward, .alignHeightInward, .alignWidthInward]
        expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(0.0), CGFloat(0.0))
        result = NSIntegralRectWithOptions(referenceNegativeRect, options)
        XCTAssertEqual(result, expectedResult)
        
        options = [.alignMinXInward, .alignMinYInward, .alignHeightInward, .alignWidthInward]
        expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(105.0), CGFloat(24.0))
        result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
        XCTAssertEqual(result, expectedResult)

        options = [.alignMinXOutward, .alignMinYOutward, .alignHeightOutward, .alignWidthOutward]
        expectedResult = NSMakeRect(CGFloat(-1.0), CGFloat(-6.0), CGFloat(106.0), CGFloat(25.0))
        result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
        XCTAssertEqual(result, expectedResult)

        options = [.alignMaxXOutward, .alignMaxYOutward, .alignHeightOutward, .alignWidthOutward]
        expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(-6.0), CGFloat(106.0), CGFloat(25.0))
        result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
        XCTAssertEqual(result, expectedResult)

        options = [.alignMinXOutward, .alignMaxXOutward, .alignMinYOutward, .alignMaxYOutward]
        expectedResult = NSMakeRect(CGFloat(-1.0), CGFloat(-6.0), CGFloat(107.0), CGFloat(25.0))
        result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
        XCTAssertEqual(result, expectedResult)

        options = [.alignMaxXOutward, .alignMaxYOutward, .alignHeightOutward, .alignWidthOutward]
        expectedResult = NSMakeRect(CGFloat(1.0), CGFloat(5.0), CGFloat(106.0), CGFloat(25.0))
        result = NSIntegralRectWithOptions(referenceRect, options)
        XCTAssertEqual(result, expectedResult)

        options = [.alignMaxXInward, .alignMaxYInward, .alignHeightOutward, .alignWidthOutward]
        expectedResult = NSMakeRect(CGFloat(-1.0), CGFloat(-7.0), CGFloat(106.0), CGFloat(25.0))
        result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
        XCTAssertEqual(result, expectedResult)

        options = [.alignMaxXInward, .alignMaxYInward, .alignHeightOutward, .alignWidthOutward]
        expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(4.0), CGFloat(106.0), CGFloat(25.0))
        result = NSIntegralRectWithOptions(referenceRect, options)
        XCTAssertEqual(result, expectedResult)

        options = [.alignMinXNearest, .alignMinYNearest, .alignHeightNearest, .alignWidthNearest]
        expectedResult = NSMakeRect(CGFloat(1.0), CGFloat(5.0), CGFloat(106.0), CGFloat(24.0))
        result = NSIntegralRectWithOptions(referenceRect, options)
        XCTAssertEqual(result, expectedResult)
        
        options = [.alignMinXNearest, .alignMinYNearest, .alignHeightNearest, .alignWidthNearest]
        expectedResult = NSMakeRect(CGFloat(-1.0), CGFloat(-5.0), CGFloat(106.0), CGFloat(24.0))
        result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
        XCTAssertEqual(result, expectedResult)

        options = [.alignMaxXNearest, .alignMaxYNearest, .alignHeightNearest, .alignWidthNearest]
        expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(6.0), CGFloat(106.0), CGFloat(24.0))
        result = NSIntegralRectWithOptions(referenceRect, options)
        XCTAssertEqual(result, expectedResult)
        
        options = [.alignMaxXNearest, .alignMaxYNearest, .alignHeightNearest, .alignWidthNearest]
        expectedResult = NSMakeRect(CGFloat(-1.0), CGFloat(-5.0), CGFloat(106.0), CGFloat(24.0))
        result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
        XCTAssertEqual(result, expectedResult)

        options = [.alignMinXInward, .alignMaxXInward, .alignMinYInward, .alignMaxYInward]
        expectedResult = NSMakeRect(CGFloat(1.0), CGFloat(6.0), CGFloat(105.0), CGFloat(23.0))
        result = NSIntegralRectWithOptions(referenceRect, options)
        XCTAssertEqual(result, expectedResult)
        
        options = [.alignMinXInward, .alignMaxXInward, .alignMinYInward, .alignMaxYInward]
        expectedResult = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(105.0), CGFloat(23.0))
        result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
        XCTAssertEqual(result, expectedResult)

        options = [.alignMinXNearest, .alignMaxXInward, .alignMinYInward, .alignMaxYNearest]
        expectedResult = NSMakeRect(CGFloat(-1.0), CGFloat(-5.0), CGFloat(106.0), CGFloat(24.0))
        result = NSIntegralRectWithOptions(referenceNegativeOriginRect, options)
        XCTAssertEqual(result, expectedResult)
    }

    func test_NSDivideRect() {

        // divide empty rect
        var inRect = NSZeroRect
        var slice = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(25.0), CGFloat(35.0))
        var remainder = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(25.0), CGFloat(35.0))
        NSDivideRect(inRect, &slice, &remainder, CGFloat(0.0), .maxX)
        var expectedSlice = NSZeroRect
        var expectedRemainder = NSZeroRect
        XCTAssertEqual(slice, expectedSlice)
        XCTAssertEqual(remainder, expectedRemainder)

        // divide rect by MinX edge
        inRect = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(25.0), CGFloat(35.0))
        slice = NSZeroRect
        remainder = NSZeroRect
        NSDivideRect(inRect, &slice, &remainder, CGFloat(10.0), .minX)
        expectedSlice = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(10.0), CGFloat(35.0))
        expectedRemainder = NSMakeRect(CGFloat(10.0), CGFloat(-5.0), CGFloat(15.0), CGFloat(35.0))
        XCTAssertEqual(slice, expectedSlice)
        XCTAssertEqual(remainder, expectedRemainder)

        // divide rect by MinX edge with amount > width
        inRect = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(25.0), CGFloat(35.0))
        slice = NSZeroRect
        remainder = NSZeroRect
        NSDivideRect(inRect, &slice, &remainder, NSWidth(inRect) + CGFloat(1.0), .minX)
        expectedSlice = inRect
        expectedRemainder = NSMakeRect(CGFloat(25.0), CGFloat(-5.0), CGFloat(0.0), CGFloat(35.0))
        XCTAssertEqual(slice, expectedSlice)
        XCTAssertEqual(remainder, expectedRemainder)

        // divide rect by MinY edge
        inRect = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(25.0), CGFloat(35.0))
        slice = NSZeroRect
        remainder = NSZeroRect
        NSDivideRect(inRect, &slice, &remainder, CGFloat(10.0), .minY)
        expectedSlice = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(25.0), CGFloat(10.0))
        expectedRemainder = NSMakeRect(CGFloat(0.0), CGFloat(5.0), CGFloat(25.0), CGFloat(25.0))
        XCTAssertEqual(slice, expectedSlice)
        XCTAssertEqual(remainder, expectedRemainder)

        // divide rect by MinY edge with amount > height
        inRect = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(25.0), CGFloat(35.0))
        slice = NSZeroRect
        remainder = NSZeroRect
        NSDivideRect(inRect, &slice, &remainder, NSHeight(inRect) + CGFloat(1.0), .minY)
        expectedSlice = inRect
        expectedRemainder = NSMakeRect(CGFloat(0.0), CGFloat(30.0), CGFloat(25.0), CGFloat(0.0))
        XCTAssertEqual(slice, expectedSlice)
        XCTAssertEqual(remainder, expectedRemainder)

        // divide rect by MaxX edge
        inRect = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(25.0), CGFloat(35.0))
        slice = NSZeroRect
        remainder = NSZeroRect
        NSDivideRect(inRect, &slice, &remainder, CGFloat(10.0), .maxX)
        expectedSlice = NSMakeRect(CGFloat(15.0), CGFloat(-5.0), CGFloat(10.0), CGFloat(35.0))
        expectedRemainder = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(15.0), CGFloat(35.0))
        XCTAssertEqual(slice, expectedSlice)
        XCTAssertEqual(remainder, expectedRemainder)

        // divide rect by MaxX edge with amount > width
        inRect = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(25.0), CGFloat(35.0))
        slice = NSZeroRect
        remainder = NSZeroRect
        NSDivideRect(inRect, &slice, &remainder, NSWidth(inRect) + CGFloat(1.0), .maxX)
        expectedSlice = inRect
        expectedRemainder = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(0.0), CGFloat(35.0))
        XCTAssertEqual(slice, expectedSlice)
        XCTAssertEqual(remainder, expectedRemainder)

        // divide rect by MaxY edge
        inRect = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(25.0), CGFloat(35.0))
        slice = NSZeroRect
        remainder = NSZeroRect
        NSDivideRect(inRect, &slice, &remainder, CGFloat(10.0), .maxY)
        expectedSlice = NSMakeRect(CGFloat(0.0), CGFloat(20.0), CGFloat(25.0), CGFloat(10.0))
        expectedRemainder = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(25.0), CGFloat(25.0))
        XCTAssertEqual(slice, expectedSlice)
        XCTAssertEqual(remainder, expectedRemainder)

        // divide rect by MaxY edge with amount > height
        inRect = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(25.0), CGFloat(35.0))
        slice = NSZeroRect
        remainder = NSZeroRect
        NSDivideRect(inRect, &slice, &remainder, NSHeight(inRect) + CGFloat(1.0), .maxY)
        expectedSlice = inRect
        expectedRemainder = NSMakeRect(CGFloat(0.0), CGFloat(-5.0), CGFloat(25.0), CGFloat(0.0))
        XCTAssertEqual(slice, expectedSlice)
        XCTAssertEqual(remainder, expectedRemainder)
    }
    
    func test_EncodeToNSString() {
        let referenceRect = NSMakeRect(CGFloat(0.6), CGFloat(5.4), CGFloat(105.7), CGFloat(24.3))
        
        var expectedString = "{0.6, 5.4}"
        var string = NSStringFromPoint(referenceRect.origin)
        XCTAssertEqual(expectedString, string,
                       "\(string) is not equal to expected \(expectedString)")
        
        expectedString = "{105.7, 24.3}"
        string = NSStringFromSize(referenceRect.size)
        XCTAssertEqual(expectedString, string,
                       "\(string) is not equal to expected \(expectedString)")
        
        expectedString = "{{0.6, 5.4}, {105.7, 24.3}}"
        string = NSStringFromRect(referenceRect)
        XCTAssertEqual(expectedString, string,
                       "\(string) is not equal to expected \(expectedString)")
    }
    
    func test_EncodeNegativeToNSString() {
        let referenceNegativeRect = NSMakeRect(CGFloat(-0.6), CGFloat(-5.4), CGFloat(-105.7), CGFloat(-24.3))
        
        var expectedString = "{-0.6, -5.4}"
        var string = NSStringFromPoint(referenceNegativeRect.origin)
        XCTAssertEqual(expectedString, string,
                       "\(string) is not equal to expected \(expectedString)")
        
        expectedString = "{-105.7, -24.3}"
        string = NSStringFromSize(referenceNegativeRect.size)
        XCTAssertEqual(expectedString, string,
                       "\(string) is not equal to expected \(expectedString)")
        
        expectedString = "{{-0.6, -5.4}, {-105.7, -24.3}}"
        string = NSStringFromRect(referenceNegativeRect)
        XCTAssertEqual(expectedString, string,
                       "\(string) is not equal to expected \(expectedString)")
    }
    
    func test_DecodeFromNSString() {
        var stringPoint = "{0.6, 5.4}"
        var stringSize = "{105.7, 24.3}"
        var stringRect = "{{0.6, 5.4}, {105.7, 24.3}}"
        
        let expectedPoint = NSMakePoint(CGFloat(0.6), CGFloat(5.4))
        var point = NSPointFromString(stringPoint)
        XCTAssertTrue(_NSPoint(expectedPoint, equalsToPoint: point),
                       "\(NSStringFromPoint(point)) is not equal to expected \(NSStringFromPoint(expectedPoint))")
        
        let expectedSize = NSMakeSize(CGFloat(105.7), CGFloat(24.3))
        var size = NSSizeFromString(stringSize)
        XCTAssertTrue(_NSSize(expectedSize, equalsToSize: size),
                       "\(NSStringFromSize(size)) is not equal to expected \(NSStringFromSize(expectedSize))")
        
        let expectedRect = NSMakeRect(CGFloat(0.6), CGFloat(5.4), CGFloat(105.7), CGFloat(24.3))
        var rect = NSRectFromString(stringRect)
        XCTAssertTrue(_NSRect(expectedRect, equalsToRect: rect),
                       "\(NSStringFromRect(rect)) is not equal to expected \(NSStringFromRect(expectedRect))")
        
        // No spaces
        stringPoint = "{0.6,5.4}"
        stringSize = "{105.7,24.3}"
        stringRect = "{{0.6,5.4},{105.7,24.3}}"
        
        point = NSPointFromString(stringPoint)
        XCTAssertTrue(_NSPoint(expectedPoint, equalsToPoint: point),
                       "\(NSStringFromPoint(point)) is not equal to expected \(NSStringFromPoint(expectedPoint))")
        
        size = NSSizeFromString(stringSize)
        XCTAssertTrue(_NSSize(expectedSize, equalsToSize: size),
                       "\(NSStringFromSize(size)) is not equal to expected \(NSStringFromSize(expectedSize))")
        
        rect = NSRectFromString(stringRect)
        XCTAssertTrue(_NSRect(expectedRect, equalsToRect: rect),
                       "\(NSStringFromRect(rect)) is not equal to expected \(NSStringFromRect(expectedRect))")
        
        // Random spaces
        stringPoint = "{  0.6   , 5.4   }"
        stringSize = "{ 105.7, 24.3       }"
        stringRect = "{{0.6 , 5.4}   ,{105.7 ,24.3}}"
        
        point = NSPointFromString(stringPoint)
        XCTAssertTrue(_NSPoint(expectedPoint, equalsToPoint: point),
                       "\(NSStringFromPoint(point)) is not equal to expected \(NSStringFromPoint(expectedPoint))")
        
        size = NSSizeFromString(stringSize)
        XCTAssertTrue(_NSSize(expectedSize, equalsToSize: size),
                       "\(NSStringFromSize(size)) is not equal to expected \(NSStringFromSize(expectedSize))")
        
        rect = NSRectFromString(stringRect)
        XCTAssertTrue(_NSRect(expectedRect, equalsToRect: rect),
                       "\(NSStringFromRect(rect)) is not equal to expected \(NSStringFromRect(expectedRect))")
    
    }
    
    func test_DecodeEmptyStrings() {
        let stringPoint = ""
        let stringSize = ""
        let stringRect = ""
        
        let expectedPoint = NSZeroPoint
        let point = NSPointFromString(stringPoint)
        XCTAssertTrue(_NSPoint(expectedPoint, equalsToPoint: point),
                       "\(NSStringFromPoint(point)) is not equal to expected \(NSStringFromPoint(expectedPoint))")

        let expectedSize = NSZeroSize
        let size = NSSizeFromString(stringSize)
        XCTAssertTrue(_NSSize(expectedSize, equalsToSize: size),
                       "\(NSStringFromSize(size)) is not equal to expected \(NSStringFromSize(expectedSize))")
        
        let expectedRect = NSZeroRect
        let rect = NSRectFromString(stringRect)
        XCTAssertTrue(_NSRect(expectedRect, equalsToRect: rect),
                       "\(NSStringFromRect(rect)) is not equal to expected \(NSStringFromRect(expectedRect))")
    }
    
    func test_DecodeNegativeFromNSString() {
        let stringPoint = "{-0.6, -5.4}"
        let stringSize = "{-105.7, -24.3}"
        let stringRect = "{{-0.6, -5.4}, {-105.7, -24.3}}"
        
        let expectedPoint = NSMakePoint(CGFloat(-0.6), CGFloat(-5.4))
        let point = NSPointFromString(stringPoint)
        XCTAssertTrue(_NSPoint(expectedPoint, equalsToPoint: point),
            "\(NSStringFromPoint(point)) is not equal to expected \(NSStringFromPoint(expectedPoint))")
        
        let expectedSize = NSMakeSize(CGFloat(-105.7), CGFloat(-24.3))
        let size = NSSizeFromString(stringSize)
        XCTAssertTrue(_NSSize(expectedSize, equalsToSize: size),
                       "\(NSStringFromSize(size)) is not equal to expected \(NSStringFromSize(expectedSize))")
        
        let expectedRect = NSMakeRect(CGFloat(-0.6), CGFloat(-5.4), CGFloat(-105.7), CGFloat(-24.3))
        let rect = NSRectFromString(stringRect)
        XCTAssertTrue(_NSRect(expectedRect, equalsToRect: rect),
                       "\(NSStringFromRect(rect)) is not equal to expected \(NSStringFromRect(expectedRect))")
        
    }
    
    func test_DecodeGarbageFromNSString() {
        var stringRect = "-0.6a5.4das-105.7bfh24.3dfas;hk312}}"
        var expectedRect = NSMakeRect(CGFloat(-0.6), CGFloat(5.4), CGFloat(-105.7), CGFloat(24.3))
        var rect = NSRectFromString(stringRect)
        XCTAssertTrue(_NSRect(expectedRect, equalsToRect: rect),
                       "\(NSStringFromRect(rect)) is not equal to expected \(NSStringFromRect(expectedRect))")

        stringRect = "-0.6a5.4da}}"
        expectedRect = NSMakeRect(CGFloat(-0.6), CGFloat(5.4), CGFloat(0.0), CGFloat(0.0))
        rect = NSRectFromString(stringRect)
        XCTAssertTrue(_NSRect(expectedRect, equalsToRect: rect),
                       "\(NSStringFromRect(rect)) is not equal to expected \(NSStringFromRect(expectedRect))")

    }
    
    // MARK: Private
    
    func _NSRect(_ rect: NSRect, equalsToRect rect2: NSRect, withPrecision precision: CGFloat.NativeType = .ulpOfOne) -> Bool {
        return _NSPoint(rect.origin, equalsToPoint: rect2.origin, withPrecision: precision)
            && _NSSize(rect.size, equalsToSize: rect2.size, withPrecision: precision)
    }

    func _NSSize(_ size: NSSize, equalsToSize size2: NSSize, withPrecision precision: CGFloat.NativeType = .ulpOfOne) -> Bool {
        return _CGFloat(size.width, equalsToCGFloat: size2.width, withPrecision: precision)
            && _CGFloat(size.height, equalsToCGFloat: size2.height, withPrecision: precision)
    }

    func _NSPoint(_ point: NSPoint, equalsToPoint point2: NSPoint, withPrecision precision: CGFloat.NativeType = .ulpOfOne) -> Bool {
        return _CGFloat(point.x, equalsToCGFloat: point2.x, withPrecision: precision)
            && _CGFloat(point.y, equalsToCGFloat: point2.y, withPrecision: precision)
    }

    func _CGFloat(_ float: CGFloat, equalsToCGFloat float2: CGFloat, withPrecision precision: CGFloat.NativeType = .ulpOfOne) -> Bool {
        return fabs(float.native - float2.native) <= precision
    }

}