     // MARK: - AffineTransform
 #if os(OSX)
     // FIXME: Comment the tests back in once rdar://problem/33363218 is in the SDK.
-    lazy var affineTransformValues: [AffineTransform] = [
-        AffineTransform.identity,
-        AffineTransform(),
-        AffineTransform(translationByX: 2.0, byY: 2.0),
-        AffineTransform(scale: 2.0),
-        AffineTransform(rotationByDegrees: .pi / 2),
-
-        AffineTransform(m11: 1.0, m12: 2.5, m21: 66.2, m22: 40.2, tX: -5.5, tY: 3.7),
-        // AffineTransform(m11: -55.66, m12: 22.7, m21: 1.5, m22: 0.0, tX: -22, tY: -33),
-        AffineTransform(m11: 4.5, m12: 1.1, m21: 0.025, m22: 0.077, tX: -0.55, tY: 33.2),
-        // AffineTransform(m11: 7.0, m12: -2.3, m21: 6.7, m22: 0.25, tX: 0.556, tY: 0.99),
-        // AffineTransform(m11: 0.498, m12: -0.284, m21: -0.742, m22: 0.3248, tX: 12, tY: 44)
+    lazy var affineTransformValues: [Int : AffineTransform] = [
+        #line : AffineTransform.identity,
+        #line : AffineTransform(),
+        #line : AffineTransform(translationByX: 2.0, byY: 2.0),
+        #line : AffineTransform(scale: 2.0),
+        #line : AffineTransform(rotationByDegrees: .pi / 2),
+
+        #line : AffineTransform(m11: 1.0, m12: 2.5, m21: 66.2, m22: 40.2, tX: -5.5, tY: 3.7),
+        // #line : AffineTransform(m11: -55.66, m12: 22.7, m21: 1.5, m22: 0.0, tX: -22, tY: -33),
+        #line : AffineTransform(m11: 4.5, m12: 1.1, m21: 0.025, m22: 0.077, tX: -0.55, tY: 33.2),
+        // #line : AffineTransform(m11: 7.0, m12: -2.3, m21: 6.7, m22: 0.25, tX: 0.556, tY: 0.99),
+        // #line : AffineTransform(m11: 0.498, m12: -0.284, m21: -0.742, m22: 0.3248, tX: 12, tY: 44)
     ]
 
     func test_AffineTransform_JSON() {
-        for transform in affineTransformValues {
-            expectRoundTripEqualityThroughJSON(for: transform)
+        for (testLine, transform) in affineTransformValues {
+            expectRoundTripEqualityThroughJSON(for: transform, lineNumber: testLine)
         }
     }
 
     func test_AffineTransform_Plist() {
-        for transform in affineTransformValues {
-            expectRoundTripEqualityThroughPlist(for: transform)
+        for (testLine, transform) in affineTransformValues {
+            expectRoundTripEqualityThroughPlist(for: transform, lineNumber: testLine)
         }
     }
 #endif
 
     // MARK: - Calendar
-    lazy var calendarValues: [Calendar] = [
-        Calendar(identifier: .gregorian),
-        Calendar(identifier: .buddhist),
-        Calendar(identifier: .chinese),
-        Calendar(identifier: .coptic),
-        Calendar(identifier: .ethiopicAmeteMihret),
-        Calendar(identifier: .ethiopicAmeteAlem),
-        Calendar(identifier: .hebrew),
-        Calendar(identifier: .iso8601),
-        Calendar(identifier: .indian),
-        Calendar(identifier: .islamic),
-        Calendar(identifier: .islamicCivil),
-        Calendar(identifier: .japanese),
-        Calendar(identifier: .persian),
-        Calendar(identifier: .republicOfChina),
+    lazy var calendarValues: [Int : Calendar] = [
+        #line : Calendar(identifier: .gregorian),
+        #line : Calendar(identifier: .buddhist),
+        #line : Calendar(identifier: .chinese),
+        #line : Calendar(identifier: .coptic),
+        #line : Calendar(identifier: .ethiopicAmeteMihret),
+        #line : Calendar(identifier: .ethiopicAmeteAlem),
+        #line : Calendar(identifier: .hebrew),
+        #line : Calendar(identifier: .iso8601),
+        #line : Calendar(identifier: .indian),
+        #line : Calendar(identifier: .islamic),
+        #line : Calendar(identifier: .islamicCivil),
+        #line : Calendar(identifier: .japanese),
+        #line : Calendar(identifier: .persian),
+        #line : Calendar(identifier: .republicOfChina),
     ]
 
     func test_Calendar_JSON() {
-        for calendar in calendarValues {
-            expectRoundTripEqualityThroughJSON(for: calendar)
+        for (testLine, calendar) in calendarValues {
+            expectRoundTripEqualityThroughJSON(for: calendar, lineNumber: testLine)
         }
     }
 
     func test_Calendar_Plist() {
-        for calendar in calendarValues {
-            expectRoundTripEqualityThroughPlist(for: calendar)
+        for (testLine, calendar) in calendarValues {
+            expectRoundTripEqualityThroughPlist(for: calendar, lineNumber: testLine)
         }
     }
 
     // MARK: - CharacterSet
-    lazy var characterSetValues: [CharacterSet] = [
-        CharacterSet.controlCharacters,
-        CharacterSet.whitespaces,
-        CharacterSet.whitespacesAndNewlines,
-        CharacterSet.decimalDigits,
-        CharacterSet.letters,
-        CharacterSet.lowercaseLetters,
-        CharacterSet.uppercaseLetters,
-        CharacterSet.nonBaseCharacters,
-        CharacterSet.alphanumerics,
-        CharacterSet.decomposables,
-        CharacterSet.illegalCharacters,
-        CharacterSet.punctuationCharacters,
-        CharacterSet.capitalizedLetters,
-        CharacterSet.symbols,
-        CharacterSet.newlines
+    lazy var characterSetValues: [Int : CharacterSet] = [
+        #line : CharacterSet.controlCharacters,
+        #line : CharacterSet.whitespaces,
+        #line : CharacterSet.whitespacesAndNewlines,
+        #line : CharacterSet.decimalDigits,
+        #line : CharacterSet.letters,
+        #line : CharacterSet.lowercaseLetters,
+        #line : CharacterSet.uppercaseLetters,
+        #line : CharacterSet.nonBaseCharacters,
+        #line : CharacterSet.alphanumerics,
+        #line : CharacterSet.decomposables,
+        #line : CharacterSet.illegalCharacters,
+        #line : CharacterSet.punctuationCharacters,
+        #line : CharacterSet.capitalizedLetters,
+        #line : CharacterSet.symbols,
+        #line : CharacterSet.newlines
     ]
 
     func test_CharacterSet_JSON() {
-        for characterSet in characterSetValues {
-            expectRoundTripEqualityThroughJSON(for: characterSet)
+        for (testLine, characterSet) in characterSetValues {
+            expectRoundTripEqualityThroughJSON(for: characterSet, lineNumber: testLine)
         }
     }
 
     func test_CharacterSet_Plist() {
-        for characterSet in characterSetValues {
-            expectRoundTripEqualityThroughPlist(for: characterSet)
+        for (testLine, characterSet) in characterSetValues {
+            expectRoundTripEqualityThroughPlist(for: characterSet, lineNumber: testLine)
         }
     }
 
     // MARK: - CGAffineTransform
-    lazy var cg_affineTransformValues: [CGAffineTransform] = {
+    lazy var cg_affineTransformValues: [Int : CGAffineTransform] = {
         // FIXME: Comment the tests back in once rdar://problem/33363218 is in the SDK.
         var values = [
-            CGAffineTransform.identity,
-            CGAffineTransform(),
-            CGAffineTransform(translationX: 2.0, y: 2.0),
-            CGAffineTransform(scaleX: 2.0, y: 2.0),
-            CGAffineTransform(a: 1.0, b: 2.5, c: 66.2, d: 40.2, tx: -5.5, ty: 3.7),
-            // CGAffineTransform(a: -55.66, b: 22.7, c: 1.5, d: 0.0, tx: -22, ty: -33),
-            CGAffineTransform(a: 4.5, b: 1.1, c: 0.025, d: 0.077, tx: -0.55, ty: 33.2),
-            // CGAffineTransform(a: 7.0, b: -2.3, c: 6.7, d: 0.25, tx: 0.556, ty: 0.99),
-            // CGAffineTransform(a: 0.498, b: -0.284, c: -0.742, d: 0.3248, tx: 12, ty: 44)
+            #line : CGAffineTransform.identity,
+            #line : CGAffineTransform(),
+            #line : CGAffineTransform(translationX: 2.0, y: 2.0),
+            #line : CGAffineTransform(scaleX: 2.0, y: 2.0),
+            #line : CGAffineTransform(a: 1.0, b: 2.5, c: 66.2, d: 40.2, tx: -5.5, ty: 3.7),
+            // #line : CGAffineTransform(a: -55.66, b: 22.7, c: 1.5, d: 0.0, tx: -22, ty: -33),
+            #line : CGAffineTransform(a: 4.5, b: 1.1, c: 0.025, d: 0.077, tx: -0.55, ty: 33.2),
+            // #line : CGAffineTransform(a: 7.0, b: -2.3, c: 6.7, d: 0.25, tx: 0.556, ty: 0.99),
+            // #line : CGAffineTransform(a: 0.498, b: -0.284, c: -0.742, d: 0.3248, tx: 12, ty: 44)
         ]
 
         if #available(OSX 10.13, iOS 11.0, watchOS 4.0, tvOS 11.0, *) {
-            values.append(CGAffineTransform(rotationAngle: .pi / 2))
+            values[#line] = CGAffineTransform(rotationAngle: .pi / 2)
         }
 
         return values
     }()
 
     func test_CGAffineTransform_JSON() {
-        for transform in cg_affineTransformValues {
-            expectRoundTripEqualityThroughJSON(for: transform)
+        for (testLine, transform) in cg_affineTransformValues {
+            expectRoundTripEqualityThroughJSON(for: transform, lineNumber: testLine)
         }
     }
 
     func test_CGAffineTransform_Plist() {
-        for transform in cg_affineTransformValues {
-            expectRoundTripEqualityThroughPlist(for: transform)
+        for (testLine, transform) in cg_affineTransformValues {
+            expectRoundTripEqualityThroughPlist(for: transform, lineNumber: testLine)
         }
     }
 
     // MARK: - CGPoint
-    lazy var cg_pointValues: [CGPoint] = {
+    lazy var cg_pointValues: [Int : CGPoint] = {
         var values = [
-            CGPoint.zero,
-            CGPoint(x: 10, y: 20)
+            #line : CGPoint.zero,
+            #line : CGPoint(x: 10, y: 20)
         ]
 
         if #available(OSX 10.13, iOS 11.0, watchOS 4.0, tvOS 11.0, *) {
             // Limit on magnitude in JSON. See rdar://problem/12717407
-            values.append(CGPoint(x: CGFloat.greatestFiniteMagnitude,
-                                  y: CGFloat.greatestFiniteMagnitude))
+            values[#line] = CGPoint(x: CGFloat.greatestFiniteMagnitude,
+                                    y: CGFloat.greatestFiniteMagnitude)
         }
 
         return values
     }()
 
     func test_CGPoint_JSON() {
-        for point in cg_pointValues {
-            expectRoundTripEqualityThroughJSON(for: point)
+        for (testLine, point) in cg_pointValues {
+            expectRoundTripEqualityThroughJSON(for: point, lineNumber: testLine)
         }
     }
 
     func test_CGPoint_Plist() {
-        for point in cg_pointValues {
-            expectRoundTripEqualityThroughPlist(for: point)
+        for (testLine, point) in cg_pointValues {
+            expectRoundTripEqualityThroughPlist(for: point, lineNumber: testLine)
         }
     }
 
     // MARK: - CGSize
-    lazy var cg_sizeValues: [CGSize] = {
+    lazy var cg_sizeValues: [Int : CGSize] = {
         var values = [
-            CGSize.zero,
-            CGSize(width: 30, height: 40)
+            #line : CGSize.zero,
+            #line : CGSize(width: 30, height: 40)
         ]
 
         if #available(OSX 10.13, iOS 11.0, watchOS 4.0, tvOS 11.0, *) {
             // Limit on magnitude in JSON. See rdar://problem/12717407
-            values.append(CGSize(width: CGFloat.greatestFiniteMagnitude,
-                                 height: CGFloat.greatestFiniteMagnitude))
+            values[#line] = CGSize(width: CGFloat.greatestFiniteMagnitude,
+                                   height: CGFloat.greatestFiniteMagnitude)
         }
 
         return values
     }()
 
     func test_CGSize_JSON() {
-        for size in cg_sizeValues {
-            expectRoundTripEqualityThroughJSON(for: size)
+        for (testLine, size) in cg_sizeValues {
+            expectRoundTripEqualityThroughJSON(for: size, lineNumber: testLine)
         }
     }
 
     func test_CGSize_Plist() {
-        for size in cg_sizeValues {
-            expectRoundTripEqualityThroughPlist(for: size)
+        for (testLine, size) in cg_sizeValues {
+            expectRoundTripEqualityThroughPlist(for: size, lineNumber: testLine)
         }
     }
 
     // MARK: - CGRect
-    lazy var cg_rectValues: [CGRect] = {
+    lazy var cg_rectValues: [Int : CGRect] = {
         // FIXME: Comment the tests back in once rdar://problem/33363218 is in the SDK.
         var values = [
-            CGRect.zero,
-            // CGRect.null,
-            CGRect(x: 10, y: 20, width: 30, height: 40)
+            #line : CGRect.zero,
+            // #line : CGRect.null,
+            #line : CGRect(x: 10, y: 20, width: 30, height: 40)
         ]
 
         if #available(OSX 10.13, iOS 11.0, watchOS 4.0, tvOS 11.0, *) {
             // Limit on magnitude in JSON. See rdar://problem/12717407
-            // values.append(CGRect.infinite)
+            // values[#line] = CGRect.infinite
         }
 
         return values
     }()
 
     func test_CGRect_JSON() {
-        for rect in cg_rectValues {
-            expectRoundTripEqualityThroughJSON(for: rect)
+        for (testLine, rect) in cg_rectValues {
+            expectRoundTripEqualityThroughJSON(for: rect, lineNumber: testLine)
         }
     }
 
     func test_CGRect_Plist() {
-        for rect in cg_rectValues {
-            expectRoundTripEqualityThroughPlist(for: rect)
+        for (testLine, rect) in cg_rectValues {
+            expectRoundTripEqualityThroughPlist(for: rect, lineNumber: testLine)
         }
     }
 
     // MARK: - CGVector
-    lazy var cg_vectorValues: [CGVector] = {
+    lazy var cg_vectorValues: [Int : CGVector] = {
         // FIXME: Comment the tests back in once rdar://problem/33363218 is in the SDK.
         var values = [
-            CGVector.zero,
-            // CGVector(dx: 0.0, dy: -9.81)
+            #line : CGVector.zero,
+            // #line : CGVector(dx: 0.0, dy: -9.81)
         ]
 
         if #available(OSX 10.13, iOS 11.0, watchOS 4.0, tvOS 11.0, *) {
             // Limit on magnitude in JSON. See rdar://problem/12717407
-            values.append(CGVector(dx: CGFloat.greatestFiniteMagnitude,
-                                   dy: CGFloat.greatestFiniteMagnitude))
+            values[#line] = CGVector(dx: CGFloat.greatestFiniteMagnitude,
+                                     dy: CGFloat.greatestFiniteMagnitude)
         }
 
         return values
     }()
 
     func test_CGVector_JSON() {
-        for vector in cg_vectorValues {
-            expectRoundTripEqualityThroughJSON(for: vector)
+        for (testLine, vector) in cg_vectorValues {
+            expectRoundTripEqualityThroughJSON(for: vector, lineNumber: testLine)
         }
     }
 
     func test_CGVector_Plist() {
-        for vector in cg_vectorValues {
-            expectRoundTripEqualityThroughPlist(for: vector)
+        for (testLine, vector) in cg_vectorValues {
+            expectRoundTripEqualityThroughPlist(for: vector, lineNumber: testLine)
         }
     }
 

    return result
}

func expectRoundTripEquality<T : Codable>(of value: T, encode: (T) throws -> Data, decode: (Data) throws -> T) where T : Equatable {
    let data: Data
    do {
        data = try encode(value)
    } catch {
        fatalError("Unable to encode \(T.self) <\(value)>: \(error)")
    }

    let decoded: T
    do {
        decoded = try decode(data)
    } catch {
        fatalError("Unable to decode \(T.self) <\(value)>: \(error)")
    }

    expectEqual(value, decoded, "Decoded \(T.self) <\(decoded)> not equal to original <\(value)>")
}

func expectRoundTripEqualityThroughJSON<T : Codable>(for value: T) where T : Equatable {
    let inf = "INF", negInf = "-INF", nan = "NaN"
    let encode = { (_ value: T) throws -> Data in
        let encoder = JSONEncoder()

        return try PropertyListDecoder().decode(T.self, from: data)
    }

    expectRoundTripEquality(of: value, encode: encode, decode: decode, lineNumber: lineNumber)
}

// MARK: - Helper Types
