diff --git a/Foundation/NSGeometry.swift b/Foundation/NSGeometry.swift
index 4cddeacc3b..da860ff8b5 100644
--- a/Foundation/NSGeometry.swift
+++ b/Foundation/NSGeometry.swift
@@ -119,7 +119,7 @@ public struct CGSize {
 
 extension CGSize {
     public static var zero: CGSize {
-        return CGSize(width: CGFloat(0), height: CGFloat(0))
+        return CGSize(width: 0, height: 0)
     }
     
     public init(width: Int, height: Int) {
@@ -682,16 +682,16 @@ public func NSEdgeInsetsEqual(_ aInsets: NSEdgeInsets, _ bInsets: NSEdgeInsets)
 }
 
 public func NSInsetRect(_ aRect: NSRect, _ dX: CGFloat, _ dY: CGFloat) -> NSRect {
-    let x = CGFloat(aRect.origin.x.native + dX.native)
-    let y = CGFloat(aRect.origin.y.native + dY.native)
-    let w = CGFloat(aRect.size.width.native - (dX.native * 2))
-    let h = CGFloat(aRect.size.height.native - (dY.native * 2))
-    return NSMakeRect(x, y, w, h)
+    let x = aRect.origin.x.native + dX.native
+    let y = aRect.origin.y.native + dY.native
+    let w = aRect.size.width.native - (dX.native * 2)
+    let h = aRect.size.height.native - (dY.native * 2)
+    return NSRect(x: x, y: y, width: w, height: h)
 }
 
 public func NSIntegralRect(_ aRect: NSRect) -> NSRect {
     if aRect.size.height.native <= 0 || aRect.size.width.native <= 0 {
-        return NSZeroRect
+        return .zero
     }
     
     return NSIntegralRectWithOptions(aRect, [.alignMinXOutward, .alignMaxXOutward, .alignMinYOutward, .alignMaxYOutward])
@@ -840,7 +840,7 @@ public func NSIntegralRectWithOptions(_ aRect: NSRect, _ opts: AlignmentOptions)
         fatalError(listOfOptionsIsInconsistentErrorMessage)
     }
     
-    var result = NSZeroRect
+    var result = NSRect.zero
     result.origin.x.native = resultOriginX
     result.origin.y.native = resultOriginY
     result.size.width.native = resultWidth
@@ -850,31 +850,31 @@ public func NSIntegralRectWithOptions(_ aRect: NSRect, _ opts: AlignmentOptions)
 }
 
 public func NSUnionRect(_ aRect: NSRect, _ bRect: NSRect) -> NSRect {
-    let isEmptyFirstRect = NSIsEmptyRect(aRect)
-    let isEmptySecondRect = NSIsEmptyRect(bRect)
+    let isEmptyFirstRect = aRect.isEmpty
+    let isEmptySecondRect = bRect.isEmpty
     if isEmptyFirstRect && isEmptySecondRect {
-        return NSZeroRect
+        return .zero
     } else if isEmptyFirstRect {
         return bRect
     } else if isEmptySecondRect {
         return aRect
     }
-    let x = min(NSMinX(aRect), NSMinX(bRect))
-    let y = min(NSMinY(aRect), NSMinY(bRect))
-    let width = max(NSMaxX(aRect), NSMaxX(bRect)) - x
-    let height = max(NSMaxY(aRect), NSMaxY(bRect)) - y
-    return NSMakeRect(x, y, width, height)
+    let x = min(aRect.minX, bRect.minX)
+    let y = min(aRect.minY, bRect.minY)
+    let width = max(aRect.maxX, bRect.maxX) - x
+    let height = max(aRect.maxY, bRect.maxY) - y
+    return NSRect(x: x, y: y, width: width, height: height)
 }
 
 public func NSIntersectionRect(_ aRect: NSRect, _ bRect: NSRect) -> NSRect {
-    if NSMaxX(aRect) <= NSMinX(bRect) || NSMaxX(bRect) <= NSMinX(aRect) || NSMaxY(aRect) <= NSMinY(bRect) || NSMaxY(bRect) <= NSMinY(aRect) {
-        return NSZeroRect
-    }
-    let x = max(NSMinX(aRect), NSMinX(bRect))
-    let y = max(NSMinY(aRect), NSMinY(bRect))
-    let width = min(NSMaxX(aRect), NSMaxX(bRect)) - x
-    let height = min(NSMaxY(aRect), NSMaxY(bRect)) - y
-    return NSMakeRect(x, y, width, height)
+    if aRect.maxX <= bRect.minX || bRect.maxX <= aRect.minX || aRect.maxY <= bRect.minY || bRect.maxY <= aRect.minY {
+        return .zero
+    }
+    let x = max(aRect.minX, bRect.minX)
+    let y = max(aRect.minY, bRect.minY)
+    let width = min(aRect.maxX, bRect.maxX) - x
+    let height = min(aRect.maxY, bRect.maxY) - y
+    return NSRect(x: x, y: y, width: width, height: height)
 }
 
 public func NSOffsetRect(_ aRect: NSRect, _ dX: CGFloat, _ dY: CGFloat) -> NSRect {
@@ -885,47 +885,47 @@ public func NSOffsetRect(_ aRect: NSRect, _ dX: CGFloat, _ dY: CGFloat) -> NSRec
 }
 
 public func NSDivideRect(_ inRect: NSRect, _ slice: UnsafeMutablePointer<NSRect>, _ rem: UnsafeMutablePointer<NSRect>, _ amount: CGFloat, _ edge: NSRectEdge) {
-    if NSIsEmptyRect(inRect) {
-        slice.pointee = NSZeroRect
-        rem.pointee = NSZeroRect
+    if inRect.isEmpty {
+        slice.pointee = .zero
+        rem.pointee = .zero
         return
     }
 
-    let width = NSWidth(inRect)
-    let height = NSHeight(inRect)
+    let width = inRect.width
+    let height = inRect.height
 
     switch (edge, amount) {
     case (.minX, let amount) where amount > width:
         slice.pointee = inRect
-        rem.pointee = NSMakeRect(NSMaxX(inRect), NSMinY(inRect), CGFloat(0.0), height)
+        rem.pointee = NSRect(x: inRect.maxX, y: inRect.minY, width: CGFloat(0.0), height: height)
 
     case (.minX, _):
-        slice.pointee = NSMakeRect(NSMinX(inRect), NSMinY(inRect), amount, height)
-        rem.pointee = NSMakeRect(NSMaxX(slice.pointee), NSMinY(inRect), NSMaxX(inRect) - NSMaxX(slice.pointee), height)
+        slice.pointee = NSRect(x: inRect.minX, y: inRect.minY, width: amount, height: height)
+        rem.pointee = NSRect(x: NSMaxX(slice.pointee), y: inRect.minY, width: inRect.maxX - NSMaxX(slice.pointee), height: height)
 
     case (.minY, let amount) where amount > height:
         slice.pointee = inRect
-        rem.pointee = NSMakeRect(NSMinX(inRect), NSMaxY(inRect), width, CGFloat(0.0))
+        rem.pointee = NSRect(x: inRect.minX, y: inRect.maxY, width: width, height: CGFloat(0.0))
 
     case (.minY, _):
-        slice.pointee = NSMakeRect(NSMinX(inRect), NSMinY(inRect), width, amount)
-        rem.pointee = NSMakeRect(NSMinX(inRect), NSMaxY(slice.pointee), width, NSMaxY(inRect) - NSMaxY(slice.pointee))
+        slice.pointee = NSRect(x: inRect.minX, y: inRect.minY, width: width, height: amount)
+        rem.pointee = NSRect(x: inRect.minX, y: NSMaxY(slice.pointee), width: width, height: inRect.maxY - NSMaxY(slice.pointee))
 
     case (.maxX, let amount) where amount > width:
         slice.pointee = inRect
-        rem.pointee = NSMakeRect(NSMinX(inRect), NSMinY(inRect), CGFloat(0.0), height)
+        rem.pointee = NSRect(x: inRect.minX, y: inRect.minY, width: CGFloat(0.0), height: height)
 
     case (.maxX, _):
-        slice.pointee = NSMakeRect(NSMaxX(inRect) - amount, NSMinY(inRect), amount, height)
-        rem.pointee = NSMakeRect(NSMinX(inRect), NSMinY(inRect), NSMinX(slice.pointee) - NSMinX(inRect), height)
+        slice.pointee = NSRect(x: inRect.maxX - amount, y: inRect.minY, width: amount, height: height)
+        rem.pointee = NSRect(x: inRect.minX, y: inRect.minY, width: NSMinX(slice.pointee) - inRect.minX, height: height)
 
     case (.maxY, let amount) where amount > height:
         slice.pointee = inRect
-        rem.pointee = NSMakeRect(NSMinX(inRect), NSMinY(inRect), width, CGFloat(0.0))
+        rem.pointee = NSRect(x: inRect.minX, y: inRect.minY, width: width, height: CGFloat(0.0))
 
     case (.maxY, _):
-        slice.pointee = NSMakeRect(NSMinX(inRect), NSMaxY(inRect) - amount, width, amount)
-        rem.pointee = NSMakeRect(NSMinX(inRect), NSMinY(inRect), width, NSMinY(slice.pointee) - NSMinY(inRect))
+        slice.pointee = NSRect(x: inRect.minX, y: inRect.maxY - amount, width: width, height: amount)
+        rem.pointee = NSRect(x: inRect.minX, y: inRect.minY, width: width, height: NSMinY(slice.pointee) - inRect.minY)
     }
 }
 
@@ -935,19 +935,19 @@ public func NSPointInRect(_ aPoint: NSPoint, _ aRect: NSRect) -> Bool {
 
 public func NSMouseInRect(_ aPoint: NSPoint, _ aRect: NSRect, _ flipped: Bool) -> Bool {
     if flipped {
-        return aPoint.x >= NSMinX(aRect) && aPoint.y >= NSMinX(aRect) && aPoint.x < NSMaxX(aRect) && aPoint.y < NSMaxY(aRect)
+        return aPoint.x >= aRect.minX && aPoint.y >= aRect.minX && aPoint.x < aRect.maxX && aPoint.y < aRect.maxY
     }
-    return aPoint.x >= NSMinX(aRect) && aPoint.y > NSMinY(aRect) && aPoint.x < NSMaxX(aRect) && aPoint.y <= NSMaxY(aRect)
+    return aPoint.x >= aRect.minX && aPoint.y > aRect.minY && aPoint.x < aRect.maxX && aPoint.y <= aRect.maxY
 }
 
 public func NSContainsRect(_ aRect: NSRect, _ bRect: NSRect) -> Bool {
-    return !NSIsEmptyRect(bRect) && NSMaxX(bRect) <= NSMaxX(aRect) && NSMinX(bRect) >= NSMinX(aRect) &&
-        NSMaxY(bRect) <= NSMaxY(aRect) && NSMinY(bRect) >= NSMinY(aRect)
+    return !bRect.isEmpty && bRect.maxX <= aRect.maxX && bRect.minX >= aRect.minX &&
+        bRect.maxY <= aRect.maxY && bRect.minY >= aRect.minY
 }
 
 public func NSIntersectsRect(_ aRect: NSRect, _ bRect: NSRect) -> Bool {
-    return !(NSIsEmptyRect(aRect) || NSIsEmptyRect(bRect) ||
-        NSMaxX(aRect) <= NSMinX(bRect) || NSMaxX(bRect) <= NSMinX(aRect) || NSMaxY(aRect) <= NSMinY(bRect) || NSMaxY(bRect) <= NSMinY(aRect))
+    return !(aRect.isEmpty || bRect.isEmpty ||
+        aRect.maxX <= bRect.minX || bRect.maxX <= aRect.minX || aRect.maxY <= bRect.minY || bRect.maxY <= aRect.minY)
 }
 
 public func NSStringFromPoint(_ aPoint: NSPoint) -> String {
@@ -986,46 +986,36 @@ private func _scanDoublesFromString(_ aString: String, number: Int) -> [Double]
 
 public func NSPointFromString(_ aString: String) -> NSPoint {
     if aString.isEmpty {
-        return NSZeroPoint
+        return .zero
     }
 
     let parsedNumbers = _scanDoublesFromString(aString, number: 2)
-    
     let x = parsedNumbers[0]
     let y = parsedNumbers[1]
-    let result = NSMakePoint(CGFloat(x), CGFloat(y))
-    
-    return result
+    return NSPoint(x: x, y: y)
 }
 
 public func NSSizeFromString(_ aString: String) -> NSSize {
     if aString.isEmpty {
-        return NSZeroSize
+        return .zero
     }
     let parsedNumbers = _scanDoublesFromString(aString, number: 2)
-    
     let w = parsedNumbers[0]
     let h = parsedNumbers[1]
-    let result = NSMakeSize(CGFloat(w), CGFloat(h))
-    
-    return result
+    return NSSize(width: w, height: h)
 }
 
 public func NSRectFromString(_ aString: String) -> NSRect {
     if aString.isEmpty {
-        return NSZeroRect
+        return .zero
     }
     
     let parsedNumbers = _scanDoublesFromString(aString, number: 4)
-    
     let x = parsedNumbers[0]
     let y = parsedNumbers[1]
     let w = parsedNumbers[2]
     let h = parsedNumbers[3]
-    
-    let result = NSMakeRect(CGFloat(x), CGFloat(y), CGFloat(w), CGFloat(h))
-    
-    return result
+    return NSRect(x: x, y: y, width: w, height: h)
 }
 
 extension NSValue {
diff --git a/TestFoundation/TestAffineTransform.swift b/TestFoundation/TestAffineTransform.swift
index abc4c8518e..0a26d54231 100644
--- a/TestFoundation/TestAffineTransform.swift
+++ b/TestFoundation/TestAffineTransform.swift
@@ -83,21 +83,21 @@ class TestAffineTransform : XCTestCase {
             checkPointTransformation(identityTransform, point: point, expectedPoint: point)
         }
         
-        checkIdentityPointTransformation(NSPoint())
-        checkIdentityPointTransformation(NSMakePoint(CGFloat(24.5), CGFloat(10.0)))
-        checkIdentityPointTransformation(NSMakePoint(CGFloat(-7.5), CGFloat(2.0)))
+        checkIdentityPointTransformation(NSPoint.zero)
+        checkIdentityPointTransformation(NSPoint(x: 24.5, y: 10.0))
+        checkIdentityPointTransformation(NSPoint(x: -7.5, y: 2.0))
 
         func checkIdentitySizeTransformation(_ size: NSSize) {
             checkSizeTransformation(identityTransform, size: size, expectedSize: size)
         }
 
-        checkIdentitySizeTransformation(NSSize())
-        checkIdentitySizeTransformation(NSMakeSize(CGFloat(13.0), CGFloat(12.5)))
-        checkIdentitySizeTransformation(NSMakeSize(CGFloat(100.0), CGFloat(-100.0)))
+        checkIdentitySizeTransformation(NSSize.zero)
+        checkIdentitySizeTransformation(NSSize(width: 13.0, height: 12.5))
+        checkIdentitySizeTransformation(NSSize(width: 100.0, height: -100.0))
     }
     
     func test_Translation() {
-        let point = NSPoint(x: CGFloat(0.0), y: CGFloat(0.0))
+        let point = NSPoint.zero
 
         let noop = NSAffineTransform()
         noop.translateX(by: CGFloat(), yBy: CGFloat())
@@ -105,19 +105,19 @@ class TestAffineTransform : XCTestCase {
         
         let translateH = NSAffineTransform()
         translateH.translateX(by: CGFloat(10.0), yBy: CGFloat())
-        checkPointTransformation(translateH, point: point, expectedPoint: NSPoint(x: CGFloat(10.0), y: CGFloat()))
+        checkPointTransformation(translateH, point: point, expectedPoint: NSPoint(x: 10.0, y: 0.0))
         
         let translateV = NSAffineTransform()
         translateV.translateX(by: CGFloat(), yBy: CGFloat(20.0))
-        checkPointTransformation(translateV, point: point, expectedPoint: NSPoint(x: CGFloat(), y: CGFloat(20.0)))
+        checkPointTransformation(translateV, point: point, expectedPoint: NSPoint(x: 0.0, y: 20.0))
         
         let translate = NSAffineTransform()
         translate.translateX(by: CGFloat(-30.0), yBy: CGFloat(40.0))
-        checkPointTransformation(translate, point: point, expectedPoint: NSPoint(x: CGFloat(-30.0), y: CGFloat(40.0)))
+        checkPointTransformation(translate, point: point, expectedPoint: NSPoint(x: -30.0, y: 40.0))
     }
     
     func test_Scale() {
-        let size = NSSize(width: CGFloat(10.0), height: CGFloat(10.0))
+        let size = NSSize(width: 10.0, height: 10.0)
         
         let noop = NSAffineTransform()
         noop.scale(by: CGFloat(1.0))
@@ -125,20 +125,20 @@ class TestAffineTransform : XCTestCase {
         
         let shrink = NSAffineTransform()
         shrink.scale(by: CGFloat(0.5))
-        checkSizeTransformation(shrink, size: size, expectedSize: NSSize(width: CGFloat(5.0), height: CGFloat(5.0)))
+        checkSizeTransformation(shrink, size: size, expectedSize: NSSize(width: 5.0, height: 5.0))
         
         let grow = NSAffineTransform()
         grow.scale(by: CGFloat(3.0))
-        checkSizeTransformation(grow, size: size, expectedSize: NSSize(width: CGFloat(30.0), height: CGFloat(30.0)))
+        checkSizeTransformation(grow, size: size, expectedSize: NSSize(width: 30.0, height: 30.0))
         
         let stretch = NSAffineTransform()
         stretch.scaleX(by: CGFloat(2.0), yBy: CGFloat(0.5))
-        checkSizeTransformation(stretch, size: size, expectedSize: NSSize(width: CGFloat(20.0), height: CGFloat(5.0)))
+        checkSizeTransformation(stretch, size: size, expectedSize: NSSize(width: 20.0, height: 5.0))
     }
     
     func test_Rotation_Degrees() {
-        let point = NSPoint(x: CGFloat(10.0), y: CGFloat(10.0))
-        
+        let point = NSPoint(x: 10.0, y: 10.0)
+
         let noop = NSAffineTransform()
         noop.rotate(byDegrees: CGFloat())
         checkPointTransformation(noop, point: point, expectedPoint: point)
@@ -149,20 +149,20 @@ class TestAffineTransform : XCTestCase {
         
         let rotateCounterClockwise = NSAffineTransform()
         rotateCounterClockwise.rotate(byDegrees: CGFloat(90.0))
-        checkPointTransformation(rotateCounterClockwise, point: point, expectedPoint: NSPoint(x: CGFloat(-10.0), y: CGFloat(10.0)))
+        checkPointTransformation(rotateCounterClockwise, point: point, expectedPoint: NSPoint(x: -10.0, y: 10.0))
         
         let rotateClockwise = NSAffineTransform()
         rotateClockwise.rotate(byDegrees: CGFloat(-90.0))
-        checkPointTransformation(rotateClockwise, point: point, expectedPoint: NSPoint(x: CGFloat(10.0), y: CGFloat(-10.0)))
+        checkPointTransformation(rotateClockwise, point: point, expectedPoint: NSPoint(x: 10.0, y: -10.0))
         
         let reflectAboutOrigin = NSAffineTransform()
         reflectAboutOrigin.rotate(byDegrees: CGFloat(180.0))
-        checkPointTransformation(reflectAboutOrigin, point: point, expectedPoint: NSPoint(x: CGFloat(-10.0), y: CGFloat(-10.0)))
+        checkPointTransformation(reflectAboutOrigin, point: point, expectedPoint: NSPoint(x: -10.0, y: -10.0))
     }
     
     func test_Rotation_Radians() {
-        let point = NSPoint(x: CGFloat(10.0), y: CGFloat(10.0))
-        
+        let point = NSPoint(x: 10.0, y: 10.0)
+
         let noop = NSAffineTransform()
         noop.rotate(byRadians: CGFloat())
         checkPointTransformation(noop, point: point, expectedPoint: point)
@@ -173,20 +173,20 @@ class TestAffineTransform : XCTestCase {
         
         let rotateCounterClockwise = NSAffineTransform()
         rotateCounterClockwise.rotate(byRadians: .pi / 2)
-        checkPointTransformation(rotateCounterClockwise, point: point, expectedPoint: NSPoint(x: CGFloat(-10.0), y: CGFloat(10.0)))
+        checkPointTransformation(rotateCounterClockwise, point: point, expectedPoint: NSPoint(x: -10.0, y: 10.0))
         
         let rotateClockwise = NSAffineTransform()
         rotateClockwise.rotate(byRadians: -.pi / 2)
-        checkPointTransformation(rotateClockwise, point: point, expectedPoint: NSPoint(x: CGFloat(10.0), y: CGFloat(-10.0)))
+        checkPointTransformation(rotateClockwise, point: point, expectedPoint: NSPoint(x: 10.0, y: -10.0))
         
         let reflectAboutOrigin = NSAffineTransform()
         reflectAboutOrigin.rotate(byRadians: .pi)
-        checkPointTransformation(reflectAboutOrigin, point: point, expectedPoint: NSPoint(x: CGFloat(-10.0), y: CGFloat(-10.0)))
+        checkPointTransformation(reflectAboutOrigin, point: point, expectedPoint: NSPoint(x: -10.0, y: -10.0))
     }
     
     func test_Inversion() {
-        let point = NSPoint(x: CGFloat(10.0), y: CGFloat(10.0))
-        
+        let point = NSPoint(x: 10.0, y: 10.0)
+
         var translate = AffineTransform()
         translate.translate(x: CGFloat(-30.0), y: CGFloat(40.0))
         
@@ -221,22 +221,22 @@ class TestAffineTransform : XCTestCase {
         xyPlus5.translateX(by: CGFloat(2.0), yBy: CGFloat(3.0))
         xyPlus5.translateX(by: CGFloat(3.0), yBy: CGFloat(2.0))
 
-        checkPointTransformation(xyPlus5, point: NSMakePoint(CGFloat(-2.0), CGFloat(-3.0)),
-                                  expectedPoint: NSMakePoint(CGFloat(3.0), CGFloat(2.0)))
+        checkPointTransformation(xyPlus5, point: NSPoint(x: -2.0, y: -3.0),
+                                  expectedPoint: NSPoint(x: 3.0, y: 2.0))
     }
 
     func test_Scaling() {
         let xyTimes5 = NSAffineTransform()
         xyTimes5.scale(by: CGFloat(5.0))
 
-        checkPointTransformation(xyTimes5, point: NSMakePoint(CGFloat(-2.0), CGFloat(3.0)),
-                                   expectedPoint: NSMakePoint(CGFloat(-10.0), CGFloat(15.0)))
+        checkPointTransformation(xyTimes5, point: NSPoint(x: -2.0, y: 3.0),
+                                   expectedPoint: NSPoint(x: -10.0, y: 15.0))
 
         let xTimes2YTimes3 = NSAffineTransform()
         xTimes2YTimes3.scaleX(by: CGFloat(2.0), yBy: CGFloat(-3.0))
 
-        checkPointTransformation(xTimes2YTimes3, point: NSMakePoint(CGFloat(-1.0), CGFloat(3.5)),
-                                         expectedPoint: NSMakePoint(CGFloat(-2.0), CGFloat(-10.5)))
+        checkPointTransformation(xTimes2YTimes3, point: NSPoint(x: -1.0, y: 3.5),
+                                         expectedPoint: NSPoint(x: -2.0, y: -10.5))
     }
 
     func test_TranslationScaling() {
@@ -244,8 +244,8 @@ class TestAffineTransform : XCTestCase {
         xPlus2XYTimes5.translateX(by: CGFloat(2.0), yBy: CGFloat())
         xPlus2XYTimes5.scaleX(by: CGFloat(5.0), yBy: CGFloat(-5.0))
 
-        checkPointTransformation(xPlus2XYTimes5, point: NSMakePoint(CGFloat(1.0), CGFloat(2.0)),
-                                         expectedPoint: NSMakePoint(CGFloat(7.0), CGFloat(-10.0)))
+        checkPointTransformation(xPlus2XYTimes5, point: NSPoint(x: 1.0, y: 2.0),
+                                         expectedPoint: NSPoint(x: 7.0, y: -10.0))
     }
 
     func test_ScalingTranslation() {
@@ -253,13 +253,13 @@ class TestAffineTransform : XCTestCase {
         xyTimes5XPlus3.scale(by: CGFloat(5.0))
         xyTimes5XPlus3.translateX(by: CGFloat(3.0), yBy: CGFloat())
 
-        checkPointTransformation(xyTimes5XPlus3, point: NSMakePoint(CGFloat(1.0), CGFloat(2.0)),
-                                         expectedPoint: NSMakePoint(CGFloat(20.0), CGFloat(10.0)))
+        checkPointTransformation(xyTimes5XPlus3, point: NSPoint(x: 1.0, y: 2.0),
+                                         expectedPoint: NSPoint(x: 20.0, y: 10.0))
     }
     
     func test_AppendTransform() {
-        let point = NSPoint(x: CGFloat(10.0), y: CGFloat(10.0))
-        
+        let point = NSPoint(x: 10.0, y: 10.0)
+
         var identityTransform = AffineTransform()
         identityTransform.append(identityTransform)
         checkPointTransformation(NSAffineTransform(transform: identityTransform), point: point, expectedPoint: point)
@@ -272,11 +272,11 @@ class TestAffineTransform : XCTestCase {
         
         let translateThenScale = NSAffineTransform(transform: translate)
         translateThenScale.append(scale)
-        checkPointTransformation(translateThenScale, point: point, expectedPoint: NSPoint(x: CGFloat(40.0), y: CGFloat(20.0)))
+        checkPointTransformation(translateThenScale, point: point, expectedPoint: NSPoint(x: 40.0, y: 20.0))
     }
     
     func test_PrependTransform() {
-        let point = NSPoint(x: CGFloat(10.0), y: CGFloat(10.0))
+        let point = NSPoint(x: 10.0, y: 10.0)
         
         var identityTransform = AffineTransform()
         identityTransform.prepend(identityTransform)
@@ -290,15 +290,15 @@ class TestAffineTransform : XCTestCase {
         
         let scaleThenTranslate = NSAffineTransform(transform: translate)
         scaleThenTranslate.prepend(scale)
-        checkPointTransformation(scaleThenTranslate, point: point, expectedPoint: NSPoint(x: CGFloat(30.0), y: CGFloat(20.0)))
+        checkPointTransformation(scaleThenTranslate, point: point, expectedPoint: NSPoint(x: 30.0, y: 20.0))
     }
     
     
     func test_TransformComposition() {
-        let origin = NSPoint(x: CGFloat(10.0), y: CGFloat(10.0))
-        let size = NSSize(width: CGFloat(40.0), height: CGFloat(20.0))
+        let origin = NSPoint(x: 10.0, y: 10.0)
+        let size = NSSize(width: 40.0, height: 20.0)
         let rect = NSRect(origin: origin, size: size)
-        let center = NSPoint(x: NSMidX(rect), y: NSMidY(rect))
+        let center = NSPoint(x: rect.midX, y: rect.midY)
         
         let rotate = NSAffineTransform()
         rotate.rotate(byDegrees: CGFloat(90.0))
@@ -350,10 +350,10 @@ class TestAffineTransform : XCTestCase {
     }
 
     func test_translation_and_rotation() {
-        let point = NSPoint(x: CGFloat(10), y: CGFloat(10))
+        let point = NSPoint(x: 10, y: 10)
         var translateThenRotate = AffineTransform(translationByX: 20, byY: -30)
         translateThenRotate.rotate(byRadians: .pi / 2)
-        checkPointTransformation(NSAffineTransform(transform: translateThenRotate), point: point, expectedPoint: NSPoint(x: CGFloat(10), y: CGFloat(-20)))
+        checkPointTransformation(NSAffineTransform(transform: translateThenRotate), point: point, expectedPoint: NSPoint(x: 10, y: -20))
     }
 
     func test_Equal() {