diff --git a/acextract/AssetsCatalog.swift b/acextract/AssetsCatalog.swift
index 23514a4..7fcdffb 100644
--- a/acextract/AssetsCatalog.swift
+++ b/acextract/AssetsCatalog.swift
@@ -88,7 +88,7 @@ struct AssetsCatalog {
 
 extension AssetsCatalog {
     func performOperation(operation: Operation) throws {
-        try operation.read(catalg: self)
+        try operation.read(catalog: self)
     }
 
     func performOperations(operations: [Operation]) throws {
diff --git a/acextract/CoreUI_Swift.swift b/acextract/CoreUI_Swift.swift
index 169e12a..c4dbd7e 100644
--- a/acextract/CoreUI_Swift.swift
+++ b/acextract/CoreUI_Swift.swift
@@ -382,7 +382,7 @@ extension CUINamedImage {
         // image size
         let width = self.size.width
         let height = self.size.height
-        let size = width>0 ? "\(Int(width))x\(Int(height))" : ""
+        let size = width > 0 ? "\(Int(width))x\(Int(height))" : ""
 
         // Graphical class
         let graphics = self.graphicsClass().name
diff --git a/acextract/Operation.swift b/acextract/Operation.swift
index 9985b13..8614957 100644
--- a/acextract/Operation.swift
+++ b/acextract/Operation.swift
@@ -27,15 +27,15 @@ import Foundation
 
 // MARK: - Protocols
 protocol Operation {
-    func read(catalg: AssetsCatalog) throws
+    func read(catalog: AssetsCatalog) throws
 }
 
 struct CompoundOperation: Operation {
     let operations: [Operation]
 
-    func read(catalg: AssetsCatalog) throws {
+    func read(catalog: AssetsCatalog) throws {
         for operation in operations {
-            try operation.read(catalg: catalg)
+            try operation.read(catalog: catalog)
         }
     }
 }
@@ -65,11 +65,11 @@ struct ExtractOperation: Operation {
     }
 
     // MARK: Methods
-    func read(catalg: AssetsCatalog) throws {
+    func read(catalog: AssetsCatalog) throws {
         // Create output folder if needed
         try checkAndCreateFolder()
         // For every image set and every named image.
-        for imageSet in catalg.imageSets {
+        for imageSet in catalog.imageSets {
             for namedImage in imageSet.namedImages {
                 // Save image to file.
                 extractNamedImage(namedImage: namedImage)
diff --git a/acextract/PrintInformationOperation.swift b/acextract/PrintInformationOperation.swift
index 8f02816..36cd448 100644
--- a/acextract/PrintInformationOperation.swift
+++ b/acextract/PrintInformationOperation.swift
@@ -92,9 +92,9 @@ struct PrintInformationOperation: Operation {
         case veryVeryVerbose
     }
 
-    func read(catalg: AssetsCatalog) {
-        print("Assets catalog: \(catalg.filePath)")
-        for imageSet in catalg.imageSets {
+    func read(catalog: AssetsCatalog) {
+        print("Assets catalog: \(catalog.filePath)")
+        for imageSet in catalog.imageSets {
             printImageSetData(imageSet: imageSet)
         }
     }
diff --git a/acextractTests/Assets.swift b/acextractTests/Assets.swift
index d8e6402..7181c0e 100644
--- a/acextractTests/Assets.swift
+++ b/acextractTests/Assets.swift
@@ -29,11 +29,11 @@ enum Asset: String {
 
     // MARK: Static
     static let bundleIdentifer = "com.bjanda.acextractTests"
-    static let bundle = NSBundle(identifier: bundleIdentifer)!
-    static func path(name name: String) -> String? {
-        return bundle.pathForResource(name, ofType: "car")
+    static let bundle = Bundle(identifier: bundleIdentifer)!
+    static func path(name: String) -> String? {
+        return bundle.path(forResource: name, ofType: "car")
     }
-    static func path(catalog catalog: Asset) -> String? {
+    static func path(catalog: Asset) -> String? {
         return path(name: catalog.rawValue)
     }
 }
diff --git a/acextractTests/AssetsCatalogTests.swift b/acextractTests/AssetsCatalogTests.swift
index f94cb12..0b5874f 100644
--- a/acextractTests/AssetsCatalogTests.swift
+++ b/acextractTests/AssetsCatalogTests.swift
@@ -37,7 +37,7 @@ class AssetsCatalogTests: XCTestCase {
         do {
             _ = try AssetsCatalog(path: "Fake path")
             XCTFail("AssetsCatalog should not be created")
-        } catch AssetsCatalogError.FileDoesntExists {
+        } catch AssetsCatalogError.fileDoesntExists {
 
         } catch {
             XCTFail("Unknown exception \(error)")
@@ -48,7 +48,7 @@ class AssetsCatalogTests: XCTestCase {
      Incorrect file.
      */
     func testCreateAssetsCatalog03() {
-        guard let path = Asset.bundle.pathForResource("data/fake_assets", ofType: nil) else {
+        guard let path = Asset.bundle.path(forResource: "data/fake_assets", ofType: nil) else {
             XCTFail("Cannot find fake asset")
             return
         }
@@ -56,7 +56,7 @@ class AssetsCatalogTests: XCTestCase {
         do {
             _ = try AssetsCatalog(path: path)
             XCTFail("AssetsCatalog should not be created")
-        } catch AssetsCatalogError.CannotOpenAssetsCatalog {
+        } catch AssetsCatalogError.cannotOpenAssetsCatalog {
 
         } catch {
             XCTFail("Unknown exception \(error)")
@@ -69,7 +69,7 @@ class AssetsCatalogTests: XCTestCase {
     func testOperation01() {
         do {
             let operation = FakeOperation()
-            try assetsContainer.iOS.performOperation(operation)
+            try assetsContainer.iOS.performOperation(operation: operation)
             XCTAssertTrue(operation.executed)
         } catch {
             XCTFail("Unknown exception \(error)")
@@ -83,7 +83,7 @@ class AssetsCatalogTests: XCTestCase {
         do {
             let operation1 = FakeOperation()
             let operation2 = FakeOperation()
-            try assetsContainer.iOS.performOperations([operation1, operation2])
+            try assetsContainer.iOS.performOperations(operations: [operation1, operation2])
             XCTAssertTrue(operation1.executed)
             XCTAssertTrue(operation2.executed)
         } catch {
diff --git a/acextractTests/CorrectnessTests.swift b/acextractTests/CorrectnessTests.swift
index 888b34e..832d267 100644
--- a/acextractTests/CorrectnessTests.swift
+++ b/acextractTests/CorrectnessTests.swift
@@ -11,42 +11,42 @@ import XCTest
 // Check correctness by printing verbose information
 class CorrectnessTests: XCTestCase {
     // MARK: Properties
-    let printOperation = PrintInformationOperation(verbose: .VeryVeryVerbose)
+    let printOperation = PrintInformationOperation(verbose: .veryVeryVerbose)
 
     // MARK: Test correctness
     func testIOSCorrectness() {
-        printOperation.read(assetsContainer.iOS)
+        printOperation.read(catalog: assetsContainer.iOS)
     }
 
     func testIPadCorrectness() {
-        printOperation.read(assetsContainer.iPad)
+        printOperation.read(catalog: assetsContainer.iPad)
     }
 
     func testIPhoneCorrectness() {
-        printOperation.read(assetsContainer.iPhone)
+        printOperation.read(catalog: assetsContainer.iPhone)
     }
 
     func testMacCorrectness() {
-        printOperation.read(assetsContainer.macOS)
+        printOperation.read(catalog: assetsContainer.macOS)
     }
 
     func testTVCorrectness() {
-        printOperation.read(assetsContainer.tvOS)
+        printOperation.read(catalog: assetsContainer.tvOS)
     }
 
     func testWatchCorrectness() {
-        printOperation.read(assetsContainer.watchOS)
+        printOperation.read(catalog: assetsContainer.watchOS)
     }
 
     func testPrintInformationName() {
-        PrintInformationOperation(verbose: .Name).read(assetsContainer.iOS)
+        PrintInformationOperation(verbose: .name).read(catalog: assetsContainer.iOS)
     }
 
     func testPrintInformationVerbose() {
-        PrintInformationOperation(verbose: .Verbose).read(assetsContainer.iOS)
+        PrintInformationOperation(verbose: .verbose).read(catalog: assetsContainer.iOS)
     }
 
     func testPrintInformationVeryVerbose() {
-        PrintInformationOperation(verbose: .VeryVerbose).read(assetsContainer.iOS)
+        PrintInformationOperation(verbose: .veryVerbose).read(catalog: assetsContainer.iOS)
     }
 }
diff --git a/acextractTests/DeviceTests.swift b/acextractTests/DeviceTests.swift
index 1cf24b6..8dd6ce7 100644
--- a/acextractTests/DeviceTests.swift
+++ b/acextractTests/DeviceTests.swift
@@ -82,8 +82,8 @@ class DeviceTests: XCTestCase {
         let images = imageSet.namedImages
         XCTAssertEqual(images.count, 2)
         if let image = images.filter({ return $0.scale == 1.0 }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.IPad)
-            XCTAssertEqual(image.subtype(), CUISubtype.Normal)
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.iPad)
+            XCTAssertEqual(image.subtype(), CUISubtype.normal)
             XCTAssertEqual(image.acScale.name, "")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_ipad~ipad.png")
@@ -93,8 +93,8 @@ class DeviceTests: XCTestCase {
         }
 
         if let image = images.filter({ return $0.scale == 2.0 }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.IPad)
-            XCTAssertEqual(image.subtype(), CUISubtype.Normal)
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.iPad)
+            XCTAssertEqual(image.subtype(), CUISubtype.normal)
             XCTAssertEqual(image.acScale.name, "@2x")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_ipad@2x~ipad.png")
@@ -109,8 +109,8 @@ class DeviceTests: XCTestCase {
         let images = imageSet.namedImages
         XCTAssertEqual(images.count, 3)
         if let image = images.filter({ return $0.scale == 1.0 }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.IPhone)
-            XCTAssertEqual(image.subtype(), CUISubtype.Normal)
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.iPhone)
+            XCTAssertEqual(image.subtype(), CUISubtype.normal)
             XCTAssertEqual(image.acScale.name, "")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_iphone~iphone.png")
@@ -120,8 +120,8 @@ class DeviceTests: XCTestCase {
         }
 
         if let image = images.filter({ return $0.scale == 2.0 }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.IPhone)
-            XCTAssertEqual(image.subtype(), CUISubtype.Normal)
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.iPhone)
+            XCTAssertEqual(image.subtype(), CUISubtype.normal)
             XCTAssertEqual(image.acScale.name, "@2x")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_iphone@2x~iphone.png")
@@ -131,8 +131,8 @@ class DeviceTests: XCTestCase {
         }
 
         if let image = images.filter({ return $0.scale == 3.0 }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.IPhone)
-            XCTAssertEqual(image.subtype(), CUISubtype.Normal)
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.iPhone)
+            XCTAssertEqual(image.subtype(), CUISubtype.normal)
             XCTAssertEqual(image.acScale.name, "@3x")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_iphone@3x~iphone.png")
@@ -146,9 +146,9 @@ class DeviceTests: XCTestCase {
         let imageSet = assetsContainer.iPhone.imageSet(withName: "d_iphone4")
         let images = imageSet.namedImages
         XCTAssertEqual(images.count, 2)
-        if let image = images.filter({ return $0.subtype() == .Normal }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.IPhone)
-            XCTAssertEqual(image.subtype(), CUISubtype.Normal)
+        if let image = images.filter({ return $0.subtype() == .normal }).first {
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.iPhone)
+            XCTAssertEqual(image.subtype(), CUISubtype.normal)
             XCTAssertEqual(image.acScale.name, "@2x")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_iphone4@2x~iphone.png")
@@ -157,9 +157,9 @@ class DeviceTests: XCTestCase {
             XCTFail("Cannot find image")
         }
 
-        if let image = images.filter({ return $0.subtype() == .IPhone4Inch }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.IPhone)
-            XCTAssertEqual(image.subtype(), CUISubtype.IPhone4Inch)
+        if let image = images.filter({ return $0.subtype() == .iPhone4Inch }).first {
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.iPhone)
+            XCTAssertEqual(image.subtype(), CUISubtype.iPhone4Inch)
             XCTAssertEqual(image.acScale.name, "@2x")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_iphone4-568h@2x~iphone.png")
@@ -174,8 +174,8 @@ class DeviceTests: XCTestCase {
         let images = imageSet.namedImages
         XCTAssertEqual(images.count, 2)
         if let image = images.filter({ return $0.scale == 1.0 }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.Universal)
-            XCTAssertEqual(image.subtype(), CUISubtype.Normal)
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.universal)
+            XCTAssertEqual(image.subtype(), CUISubtype.normal)
             XCTAssertEqual(image.acScale.name, "")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_mac.png")
@@ -185,8 +185,8 @@ class DeviceTests: XCTestCase {
         }
 
         if let image = images.filter({ return $0.scale == 2.0 }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.Universal)
-            XCTAssertEqual(image.subtype(), CUISubtype.Normal)
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.universal)
+            XCTAssertEqual(image.subtype(), CUISubtype.normal)
             XCTAssertEqual(image.acScale.name, "@2x")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_mac@2x.png")
@@ -201,8 +201,8 @@ class DeviceTests: XCTestCase {
         let images = imageSet.namedImages
         XCTAssertEqual(images.count, 1)
         if let image = images.filter({ return $0.scale == 1.0 }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.AppleTV)
-            XCTAssertEqual(image.subtype(), CUISubtype.Normal)
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.appleTV)
+            XCTAssertEqual(image.subtype(), CUISubtype.normal)
             XCTAssertEqual(image.acScale.name, "")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_tv~tv.png")
@@ -217,8 +217,8 @@ class DeviceTests: XCTestCase {
         let images = imageSet.namedImages
         XCTAssertEqual(images.count, 3)
         if let image = images.filter({ return $0.scale == 1.0 }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.Universal)
-            XCTAssertEqual(image.subtype(), CUISubtype.Normal)
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.universal)
+            XCTAssertEqual(image.subtype(), CUISubtype.normal)
             XCTAssertEqual(image.acScale.name, "")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_universal.png")
@@ -228,8 +228,8 @@ class DeviceTests: XCTestCase {
         }
 
         if let image = images.filter({ return $0.scale == 2.0 }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.Universal)
-            XCTAssertEqual(image.subtype(), CUISubtype.Normal)
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.universal)
+            XCTAssertEqual(image.subtype(), CUISubtype.normal)
             XCTAssertEqual(image.acScale.name, "@2x")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_universal@2x.png")
@@ -239,8 +239,8 @@ class DeviceTests: XCTestCase {
         }
 
         if let image = images.filter({ return $0.scale == 3.0 }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.Universal)
-            XCTAssertEqual(image.subtype(), CUISubtype.Normal)
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.universal)
+            XCTAssertEqual(image.subtype(), CUISubtype.normal)
             XCTAssertEqual(image.acScale.name, "@3x")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_universal@3x.png")
@@ -254,9 +254,9 @@ class DeviceTests: XCTestCase {
         let imageSet = assetsContainer.watchOS.imageSet(withName: "d_watch")
         let images = imageSet.namedImages
         XCTAssertEqual(images.count, 3)
-        if let image = images.filter({ return $0.subtype() == .Normal }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.AppleWatch)
-            XCTAssertEqual(image.subtype(), CUISubtype.Normal)
+        if let image = images.filter({ return $0.subtype() == .normal }).first {
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.appleWatch)
+            XCTAssertEqual(image.subtype(), CUISubtype.normal)
             XCTAssertEqual(image.acScale.name, "@2x")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_watch@2x~watch.png")
@@ -265,9 +265,9 @@ class DeviceTests: XCTestCase {
             XCTFail("Cannot find image")
         }
 
-        if let image = images.filter({ return $0.subtype() == .AppleWatch38 }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.AppleWatch)
-            XCTAssertEqual(image.subtype(), CUISubtype.AppleWatch38)
+        if let image = images.filter({ return $0.subtype() == .appleWatch38 }).first {
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.appleWatch)
+            XCTAssertEqual(image.subtype(), CUISubtype.appleWatch38)
             XCTAssertEqual(image.acScale.name, "@2x")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_watch-38@2x~watch.png")
@@ -276,9 +276,9 @@ class DeviceTests: XCTestCase {
             XCTFail("Cannot find image")
         }
 
-        if let image = images.filter({ return $0.subtype() == .AppleWatch42 }).first {
-            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.AppleWatch)
-            XCTAssertEqual(image.subtype(), CUISubtype.AppleWatch42)
+        if let image = images.filter({ return $0.subtype() == .appleWatch42 }).first {
+            XCTAssertEqual(image.idiom(), CUIDeviceIdiom.appleWatch)
+            XCTAssertEqual(image.subtype(), CUISubtype.appleWatch42)
             XCTAssertEqual(image.acScale.name, "@2x")
             XCTAssertEqual(image.acIsPDF, false)
             XCTAssertEqual(image.acImageName, "d_watch-42@2x~watch.png")
diff --git a/acextractTests/GraphicalClassTests.swift b/acextractTests/GraphicalClassTests.swift
index dba6dc3..edf6878 100644
--- a/acextractTests/GraphicalClassTests.swift
+++ b/acextractTests/GraphicalClassTests.swift
@@ -17,9 +17,9 @@ class GraphicalClassTests: XCTestCase {
 
         // Default 1x
         if let image = images.filter({ return $0.scale == 1.0 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_none.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -28,9 +28,9 @@ class GraphicalClassTests: XCTestCase {
 
         // Default 2x
         if let image = images.filter({ return $0.scale == 2.0 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_none@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -39,9 +39,9 @@ class GraphicalClassTests: XCTestCase {
 
         // Default 3x
         if let image = images.filter({ return $0.scale == 3.0 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_none@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -55,10 +55,10 @@ class GraphicalClassTests: XCTestCase {
         XCTAssertEqual(images.count, 6)
 
         // Default 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .Default }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .default }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_1v2.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -66,10 +66,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Default 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .Default }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .default }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_1v2@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -77,10 +77,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Default 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .Default }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .default }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_1v2@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -88,10 +88,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 1v2 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .Metal1v2 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal1v2)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal1v2)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal1v2)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .metal1v2 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal1v2)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal1v2)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal1v2)
             XCTAssertEqual(image.acImageName, "g_1v21v2.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -99,10 +99,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 1v2 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .Metal1v2 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal1v2)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal1v2)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal1v2)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .metal1v2 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal1v2)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal1v2)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal1v2)
             XCTAssertEqual(image.acImageName, "g_1v21v2@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -110,10 +110,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 1v2 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .Metal1v2 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal1v2)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal1v2)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal1v2)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .metal1v2 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal1v2)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal1v2)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal1v2)
             XCTAssertEqual(image.acImageName, "g_1v21v2@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -127,10 +127,10 @@ class GraphicalClassTests: XCTestCase {
         XCTAssertEqual(images.count, 6)
 
         // Default 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .Default }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .default }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_2v2.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -138,10 +138,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Default 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .Default }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .default }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_2v2@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -149,10 +149,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Default 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .Default }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .default }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_2v2@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -160,10 +160,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 2v2 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .Metal2v2 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal2v2)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal2v2)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal2v2)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .metal2v2 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal2v2)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal2v2)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal2v2)
             XCTAssertEqual(image.acImageName, "g_2v22v2.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -171,10 +171,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 2v2 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .Metal2v2 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal2v2)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal2v2)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal2v2)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .metal2v2 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal2v2)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal2v2)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal2v2)
             XCTAssertEqual(image.acImageName, "g_2v22v2@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -182,10 +182,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 2v2 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .Metal2v2 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal2v2)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal2v2)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal2v2)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .metal2v2 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal2v2)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal2v2)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal2v2)
             XCTAssertEqual(image.acImageName, "g_2v22v2@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -199,10 +199,10 @@ class GraphicalClassTests: XCTestCase {
         XCTAssertEqual(images.count, 6)
 
         // Default 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .Default }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .default }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_3v1.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -210,10 +210,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Default 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .Default }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .default }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_3v1@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -221,10 +221,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Default 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .Default }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .default }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_3v1@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -232,10 +232,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 3v1 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .Metal3v1 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal3v1)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal3v1)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal3v1)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .metal3v1 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal3v1)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal3v1)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal3v1)
             XCTAssertEqual(image.acImageName, "g_3v13v1.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -243,10 +243,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 3v1 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .Metal3v1 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal3v1)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal3v1)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal3v1)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .metal3v1 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal3v1)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal3v1)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal3v1)
             XCTAssertEqual(image.acImageName, "g_3v13v1@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -254,10 +254,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 3v1 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .Metal3v1 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal3v1)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal3v1)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal3v1)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .metal3v1 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal3v1)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal3v1)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal3v1)
             XCTAssertEqual(image.acImageName, "g_3v13v1@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -271,10 +271,10 @@ class GraphicalClassTests: XCTestCase {
         XCTAssertEqual(images.count, 12)
 
         // Default 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .Default }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .default }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_mix.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -282,10 +282,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Default 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .Default }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .default }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_mix@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -293,10 +293,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Default 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .Default }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Default)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Default)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .default }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.default)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.default)
             XCTAssertEqual(image.acImageName, "g_mix@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -304,10 +304,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 1v2 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .Metal1v2 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal1v2)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal1v2)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal1v2)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .metal1v2 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal1v2)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal1v2)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal1v2)
             XCTAssertEqual(image.acImageName, "g_mix1v2.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -315,10 +315,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 1v2 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .Metal1v2 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal1v2)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal1v2)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal1v2)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .metal1v2 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal1v2)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal1v2)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal1v2)
             XCTAssertEqual(image.acImageName, "g_mix1v2@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -326,10 +326,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 1v2 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .Metal1v2 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal1v2)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal1v2)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal1v2)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .metal1v2 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal1v2)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal1v2)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal1v2)
             XCTAssertEqual(image.acImageName, "g_mix1v2@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -343,10 +343,10 @@ class GraphicalClassTests: XCTestCase {
         XCTAssertEqual(images.count, 12)
 
         // Metal 2v2 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .Metal2v2 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal2v2)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal2v2)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal2v2)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .metal2v2 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal2v2)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal2v2)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal2v2)
             XCTAssertEqual(image.acImageName, "g_mix2v2.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -354,10 +354,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 2v2 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .Metal2v2 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal2v2)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal2v2)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal2v2)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .metal2v2 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal2v2)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal2v2)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal2v2)
             XCTAssertEqual(image.acImageName, "g_mix2v2@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -365,10 +365,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 2v2 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .Metal2v2 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal2v2)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal2v2)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal2v2)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .metal2v2 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal2v2)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal2v2)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal2v2)
             XCTAssertEqual(image.acImageName, "g_mix2v2@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -376,10 +376,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 3v1 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .Metal3v1 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal3v1)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal3v1)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal3v1)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.graphicsClass() == .metal3v1 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal3v1)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal3v1)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal3v1)
             XCTAssertEqual(image.acImageName, "g_mix3v1.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -387,10 +387,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 3v1 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .Metal3v1 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal3v1)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal3v1)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal3v1)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.graphicsClass() == .metal3v1 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal3v1)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal3v1)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal3v1)
             XCTAssertEqual(image.acImageName, "g_mix3v1@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -398,10 +398,10 @@ class GraphicalClassTests: XCTestCase {
         }
 
         // Metal 3v1 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .Metal3v1 }).first {
-            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.Metal3v1)
-            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.Metal3v1)
-            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.Metal3v1)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.graphicsClass() == .metal3v1 }).first {
+            XCTAssertEqual(image.graphicsClass(), CUIGraphicalClass.metal3v1)
+            XCTAssertEqual(image.baseKey().themeGraphicsClass(), CUIGraphicalClass.metal3v1)
+            XCTAssertEqual(image.renditionKey().themeGraphicsClass(), CUIGraphicalClass.metal3v1)
             XCTAssertEqual(image.acImageName, "g_mix3v1@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
diff --git a/acextractTests/MemoryClassTests.swift b/acextractTests/MemoryClassTests.swift
index 433aef7..55e9dfc 100644
--- a/acextractTests/MemoryClassTests.swift
+++ b/acextractTests/MemoryClassTests.swift
@@ -17,9 +17,9 @@ class MemoryClassTests: XCTestCase {
 
         // Default 1x
         if let image = images.filter({ return $0.scale == 1.0 }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Default)
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.default)
             XCTAssertEqual(image.acImageName, "m_no.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -28,9 +28,9 @@ class MemoryClassTests: XCTestCase {
 
         // Default 2x
         if let image = images.filter({ return $0.scale == 2.0 }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Default)
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.default)
             XCTAssertEqual(image.acImageName, "m_no@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -39,9 +39,9 @@ class MemoryClassTests: XCTestCase {
 
         // Default 3x
         if let image = images.filter({ return $0.scale == 3.0 }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Default)
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.default)
             XCTAssertEqual(image.acImageName, "m_no@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -55,10 +55,10 @@ class MemoryClassTests: XCTestCase {
         XCTAssertEqual(images.count, 6)
 
         // Default 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.memoryClass() == .Default }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Default)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.memoryClass() == .default }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.default)
             XCTAssertEqual(image.acImageName, "m_1gb.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -66,10 +66,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // Default 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.memoryClass() == .Default }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Default)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.memoryClass() == .default }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.default)
             XCTAssertEqual(image.acImageName, "m_1gb@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -77,10 +77,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // Default 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.memoryClass() == .Default }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Default)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.memoryClass() == .default }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.default)
             XCTAssertEqual(image.acImageName, "m_1gb@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -88,10 +88,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // 1GB 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.memoryClass() == .Memory1GB }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Memory1GB)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Memory1GB)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Memory1GB)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.memoryClass() == .memory1GB }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.memory1GB)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.memory1GB)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.memory1GB)
             XCTAssertEqual(image.acImageName, "m_1gb1gb.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -99,10 +99,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // 1GB 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.memoryClass() == .Memory1GB }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Memory1GB)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Memory1GB)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Memory1GB)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.memoryClass() == .memory1GB }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.memory1GB)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.memory1GB)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.memory1GB)
             XCTAssertEqual(image.acImageName, "m_1gb1gb@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -110,10 +110,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // 1GB 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.memoryClass() == .Memory1GB }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Memory1GB)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Memory1GB)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Memory1GB)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.memoryClass() == .memory1GB }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.memory1GB)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.memory1GB)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.memory1GB)
             XCTAssertEqual(image.acImageName, "m_1gb1gb@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -127,10 +127,10 @@ class MemoryClassTests: XCTestCase {
         XCTAssertEqual(images.count, 6)
 
         // Default 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.memoryClass() == .Default }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Default)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.memoryClass() == .default }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.default)
             XCTAssertEqual(image.acImageName, "m_2gb.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -138,10 +138,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // Default 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.memoryClass() == .Default }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Default)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.memoryClass() == .default }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.default)
             XCTAssertEqual(image.acImageName, "m_2gb@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -149,10 +149,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // Default 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.memoryClass() == .Default }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Default)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.memoryClass() == .default }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.default)
             XCTAssertEqual(image.acImageName, "m_2gb@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -160,10 +160,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // 2GB 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.memoryClass() == .Memory2GB }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Memory2GB)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Memory2GB)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Memory2GB)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.memoryClass() == .memory2GB }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.memory2GB)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.memory2GB)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.memory2GB)
             XCTAssertEqual(image.acImageName, "m_2gb2gb.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -171,10 +171,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // 2GB 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.memoryClass() == .Memory2GB }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Memory2GB)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Memory2GB)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Memory2GB)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.memoryClass() == .memory2GB }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.memory2GB)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.memory2GB)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.memory2GB)
             XCTAssertEqual(image.acImageName, "m_2gb2gb@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -182,10 +182,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // 2GB 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.memoryClass() == .Memory2GB }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Memory2GB)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Memory2GB)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Memory2GB)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.memoryClass() == .memory2GB }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.memory2GB)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.memory2GB)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.memory2GB)
             XCTAssertEqual(image.acImageName, "m_2gb2gb@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -199,10 +199,10 @@ class MemoryClassTests: XCTestCase {
         XCTAssertEqual(images.count, 6)
 
         // Default 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.memoryClass() == .Default }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Default)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.memoryClass() == .default }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.default)
             XCTAssertEqual(image.acImageName, "m_4gb.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -210,10 +210,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // Default 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.memoryClass() == .Default }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Default)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.memoryClass() == .default }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.default)
             XCTAssertEqual(image.acImageName, "m_4gb@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -221,10 +221,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // Default 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.memoryClass() == .Default }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Default)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Default)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.memoryClass() == .default }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.default)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.default)
             XCTAssertEqual(image.acImageName, "m_4gb@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -232,10 +232,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // 4GB 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.memoryClass() == .Memory4GB }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Memory4GB)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Memory4GB)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Memory4GB)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.memoryClass() == .memory4GB }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.memory4GB)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.memory4GB)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.memory4GB)
             XCTAssertEqual(image.acImageName, "m_4gb4gb.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -243,10 +243,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // 4GB 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.memoryClass() == .Memory4GB }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Memory4GB)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Memory4GB)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Memory4GB)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.memoryClass() == .memory4GB }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.memory4GB)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.memory4GB)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.memory4GB)
             XCTAssertEqual(image.acImageName, "m_4gb4gb@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -254,10 +254,10 @@ class MemoryClassTests: XCTestCase {
         }
 
         // 4GB 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.memoryClass() == .Memory4GB }).first {
-            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.Memory4GB)
-            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.Memory4GB)
-            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.Memory4GB)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.memoryClass() == .memory4GB }).first {
+            XCTAssertEqual(image.memoryClass(), CUIMemoryClass.memory4GB)
+            XCTAssertEqual(image.baseKey().themeMemoryClass(), CUIMemoryClass.memory4GB)
+            XCTAssertEqual(image.renditionKey().themeMemoryClass(), CUIMemoryClass.memory4GB)
             XCTAssertEqual(image.acImageName, "m_4gb4gb@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
diff --git a/acextractTests/SizeClassTests.swift b/acextractTests/SizeClassTests.swift
index cf6583d..1d39cbb 100644
--- a/acextractTests/SizeClassTests.swift
+++ b/acextractTests/SizeClassTests.swift
@@ -16,9 +16,9 @@ class SizeClassTests: XCTestCase {
         XCTAssertEqual(images.count, 6)
 
         // Any 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.sizeClassHorizontal() == .Any }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.sizeClassHorizontal() == .any }).first {
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_w_a&c.png")
@@ -28,9 +28,9 @@ class SizeClassTests: XCTestCase {
         }
 
         // Any 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.sizeClassHorizontal() == .Any }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.sizeClassHorizontal() == .any }).first {
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_w_a&c@2x.png")
@@ -40,9 +40,9 @@ class SizeClassTests: XCTestCase {
         }
 
         // Any 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.sizeClassHorizontal() == .Any }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.sizeClassHorizontal() == .any }).first {
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_w_a&c@3x.png")
@@ -52,9 +52,9 @@ class SizeClassTests: XCTestCase {
         }
 
         // Compact 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.sizeClassHorizontal() == .Compact }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Compact)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.sizeClassHorizontal() == .compact }).first {
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.compact)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "-")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_w_a&c-*.png")
@@ -64,9 +64,9 @@ class SizeClassTests: XCTestCase {
         }
 
         // Compact 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.sizeClassHorizontal() == .Compact }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Compact)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.sizeClassHorizontal() == .compact }).first {
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.compact)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "-")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_w_a&c-*@2x.png")
@@ -76,9 +76,9 @@ class SizeClassTests: XCTestCase {
         }
 
         // Compact 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.sizeClassHorizontal() == .Compact }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Compact)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.sizeClassHorizontal() == .compact }).first {
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.compact)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "-")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_w_a&c-*@3x.png")
@@ -94,9 +94,9 @@ class SizeClassTests: XCTestCase {
         XCTAssertEqual(images.count, 6)
 
         // Any 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.sizeClassVertical() == .Any }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.sizeClassVertical() == .any }).first {
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_h_a&r.png")
@@ -106,9 +106,9 @@ class SizeClassTests: XCTestCase {
         }
 
         // Any 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.sizeClassVertical() == .Any }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.sizeClassVertical() == .any }).first {
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_h_a&r@2x.png")
@@ -118,9 +118,9 @@ class SizeClassTests: XCTestCase {
         }
 
         // Any 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.sizeClassVertical() == .Any }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.sizeClassVertical() == .any }).first {
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_h_a&r@3x.png")
@@ -130,9 +130,9 @@ class SizeClassTests: XCTestCase {
         }
 
         // Regular 1x
-        if let image = images.filter({ return $0.scale == 1.0 && $0.sizeClassVertical() == .Regular }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Regular)
+        if let image = images.filter({ return $0.scale == 1.0 && $0.sizeClassVertical() == .regular }).first {
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.regular)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "+")
             XCTAssertEqual(image.acImageName, "sc_h_a&r*+.png")
@@ -142,9 +142,9 @@ class SizeClassTests: XCTestCase {
         }
 
         // Regular 2x
-        if let image = images.filter({ return $0.scale == 2.0 && $0.sizeClassVertical() == .Regular }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Regular)
+        if let image = images.filter({ return $0.scale == 2.0 && $0.sizeClassVertical() == .regular }).first {
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.regular)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "+")
             XCTAssertEqual(image.acImageName, "sc_h_a&r*+@2x.png")
@@ -154,9 +154,9 @@ class SizeClassTests: XCTestCase {
         }
 
         // Regular 3x
-        if let image = images.filter({ return $0.scale == 3.0 && $0.sizeClassVertical() == .Regular }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Regular)
+        if let image = images.filter({ return $0.scale == 3.0 && $0.sizeClassVertical() == .regular }).first {
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.regular)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "+")
             XCTAssertEqual(image.acImageName, "sc_h_a&r*+@3x.png")
@@ -172,10 +172,10 @@ class SizeClassTests: XCTestCase {
         XCTAssertEqual(images.count, 12)
 
         // Any Any 1x
-        let aaImages = images.filter({ $0.sizeClassHorizontal() == .Any && $0.sizeClassVertical() == .Any })
+        let aaImages = images.filter({ $0.sizeClassHorizontal() == .any && $0.sizeClassVertical() == .any })
         if let image = aaImages.filter({ $0.scale == 1.0 }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_wh_a&r&c.png")
@@ -186,8 +186,8 @@ class SizeClassTests: XCTestCase {
 
         // Any Any 2x
         if let image = aaImages.filter({ return $0.scale == 2.0 }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_wh_a&r&c@2x.png")
@@ -198,8 +198,8 @@ class SizeClassTests: XCTestCase {
 
         // Any Any 3x
         if let image = aaImages.filter({ return $0.scale == 3.0 }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_wh_a&r&c@3x.png")
@@ -209,10 +209,10 @@ class SizeClassTests: XCTestCase {
         }
 
         // Any Compact 1x
-        let acImages = images.filter({ $0.sizeClassHorizontal() == .Any && $0.sizeClassVertical() == .Compact })
+        let acImages = images.filter({ $0.sizeClassHorizontal() == .any && $0.sizeClassVertical() == .compact })
         if let image = acImages.filter({ $0.scale == 1.0 }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Compact)
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.compact)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "-")
             XCTAssertEqual(image.acImageName, "sc_wh_a&r&c*-.png")
@@ -223,8 +223,8 @@ class SizeClassTests: XCTestCase {
 
         // Any Compact 2x
         if let image = acImages.filter({ return $0.scale == 2.0 }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Compact)
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.compact)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "-")
             XCTAssertEqual(image.acImageName, "sc_wh_a&r&c*-@2x.png")
@@ -235,8 +235,8 @@ class SizeClassTests: XCTestCase {
 
         // Any Compact 3x
         if let image = acImages.filter({ return $0.scale == 3.0 }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Any)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Compact)
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.any)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.compact)
             XCTAssertEqual(image.sizeClassHorizontal().name, "*")
             XCTAssertEqual(image.sizeClassVertical().name, "-")
             XCTAssertEqual(image.acImageName, "sc_wh_a&r&c*-@3x.png")
@@ -252,10 +252,10 @@ class SizeClassTests: XCTestCase {
         XCTAssertEqual(images.count, 12)
 
         // Regular Any 1x
-        let raImages = images.filter({ $0.sizeClassHorizontal() == .Regular && $0.sizeClassVertical() == .Any })
+        let raImages = images.filter({ $0.sizeClassHorizontal() == .regular && $0.sizeClassVertical() == .any })
         if let image = raImages.filter({ $0.scale == 1.0 }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Regular)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.regular)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "+")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_wh_a&r&c+*.png")
@@ -266,8 +266,8 @@ class SizeClassTests: XCTestCase {
 
         // Regular Any 2x
         if let image = raImages.filter({ return $0.scale == 2.0 }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Regular)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.regular)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "+")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_wh_a&r&c+*@2x.png")
@@ -278,8 +278,8 @@ class SizeClassTests: XCTestCase {
 
         // Regular Any 3x
         if let image = raImages.filter({ return $0.scale == 3.0 }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Regular)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Any)
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.regular)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.any)
             XCTAssertEqual(image.sizeClassHorizontal().name, "+")
             XCTAssertEqual(image.sizeClassVertical().name, "*")
             XCTAssertEqual(image.acImageName, "sc_wh_a&r&c+*@3x.png")
@@ -289,10 +289,10 @@ class SizeClassTests: XCTestCase {
         }
 
         // Regular Compact 1x
-        let rcImages = images.filter({ $0.sizeClassHorizontal() == .Regular && $0.sizeClassVertical() == .Compact })
+        let rcImages = images.filter({ $0.sizeClassHorizontal() == .regular && $0.sizeClassVertical() == .compact })
         if let image = rcImages.filter({ $0.scale == 1.0 }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Regular)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Compact)
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.regular)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.compact)
             XCTAssertEqual(image.sizeClassHorizontal().name, "+")
             XCTAssertEqual(image.sizeClassVertical().name, "-")
             XCTAssertEqual(image.acImageName, "sc_wh_a&r&c+-.png")
@@ -303,8 +303,8 @@ class SizeClassTests: XCTestCase {
 
         // Regular Compact 2x
         if let image = rcImages.filter({ return $0.scale == 2.0 }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Regular)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Compact)
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.regular)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.compact)
             XCTAssertEqual(image.sizeClassHorizontal().name, "+")
             XCTAssertEqual(image.sizeClassVertical().name, "-")
             XCTAssertEqual(image.acImageName, "sc_wh_a&r&c+-@2x.png")
@@ -315,8 +315,8 @@ class SizeClassTests: XCTestCase {
 
         // Regular Compact 3x
         if let image = rcImages.filter({ return $0.scale == 3.0 }).first {
-            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.Regular)
-            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.Compact)
+            XCTAssertEqual(image.sizeClassHorizontal(), CUIUserInterfaceSizeClass.regular)
+            XCTAssertEqual(image.sizeClassVertical(), CUIUserInterfaceSizeClass.compact)
             XCTAssertEqual(image.sizeClassHorizontal().name, "+")
             XCTAssertEqual(image.sizeClassVertical().name, "-")
             XCTAssertEqual(image.acImageName, "sc_wh_a&r&c+-@3x.png")
diff --git a/acextractTests/SlicesTests.swift b/acextractTests/SlicesTests.swift
index 1dee40d..a15ed22 100644
--- a/acextractTests/SlicesTests.swift
+++ b/acextractTests/SlicesTests.swift
@@ -17,9 +17,9 @@ class SlicesTests: XCTestCase {
         XCTAssertEqual(images.count, 3)
         if let image = images.filter({ return $0.scale == 1.0 }).first {
             XCTAssertFalse(image.hasSliceInformation)
-            XCTAssertEqual(image.resizingMode, CUIResizingMode.Stretches)
-            XCTAssertEqual(image.imageType, CUIImageType.None)
-            XCTAssertEqual(image._rendition().type(), CUIImageType.None)
+            XCTAssertEqual(image.resizingMode, CUIResizingMode.stretches)
+            XCTAssertEqual(image.imageType, CUIImageType.none)
+            XCTAssertEqual(image._rendition().type(), CUIImageType.none)
             XCTAssertEqual(image.acImageName, "s_none.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -28,9 +28,9 @@ class SlicesTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 2.0 }).first {
             XCTAssertFalse(image.hasSliceInformation)
-            XCTAssertEqual(image.resizingMode, CUIResizingMode.Stretches)
-            XCTAssertEqual(image.imageType, CUIImageType.None)
-            XCTAssertEqual(image._rendition().type(), CUIImageType.None)
+            XCTAssertEqual(image.resizingMode, CUIResizingMode.stretches)
+            XCTAssertEqual(image.imageType, CUIImageType.none)
+            XCTAssertEqual(image._rendition().type(), CUIImageType.none)
             XCTAssertEqual(image.acImageName, "s_none@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -39,9 +39,9 @@ class SlicesTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 3.0 }).first {
             XCTAssertFalse(image.hasSliceInformation)
-            XCTAssertEqual(image.resizingMode, CUIResizingMode.Stretches)
-            XCTAssertEqual(image.imageType, CUIImageType.None)
-            XCTAssertEqual(image._rendition().type(), CUIImageType.None)
+            XCTAssertEqual(image.resizingMode, CUIResizingMode.stretches)
+            XCTAssertEqual(image.imageType, CUIImageType.none)
+            XCTAssertEqual(image._rendition().type(), CUIImageType.none)
             XCTAssertEqual(image.acImageName, "s_none@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -55,10 +55,10 @@ class SlicesTests: XCTestCase {
         XCTAssertEqual(images.count, 3)
         if let image = images.filter({ return $0.scale == 1.0 }).first {
             XCTAssertTrue(image.hasSliceInformation)
-            XCTAssertEqual(image.resizingMode, CUIResizingMode.Tiles)
-            XCTAssertEqual(image.imageType, CUIImageType.Vertical)
-            XCTAssertEqual(image._rendition().type(), CUIImageType.Vertical)
-            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.Vertical)
+            XCTAssertEqual(image.resizingMode, CUIResizingMode.tiles)
+            XCTAssertEqual(image.imageType, CUIImageType.vertical)
+            XCTAssertEqual(image._rendition().type(), CUIImageType.vertical)
+            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.vertical)
             XCTAssertEqual(image._rendition().sliceInformation()?.edgeInsets, NSEdgeInsets(top: 10, left: 0, bottom: 10, right: 0))
             XCTAssertEqual(image.acImageName, "s_vertical.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
@@ -68,10 +68,10 @@ class SlicesTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 2.0 }).first {
             XCTAssertTrue(image.hasSliceInformation)
-            XCTAssertEqual(image.resizingMode, CUIResizingMode.Stretches)
-            XCTAssertEqual(image.imageType, CUIImageType.Vertical)
-            XCTAssertEqual(image._rendition().type(), CUIImageType.Vertical)
-            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.Vertical)
+            XCTAssertEqual(image.resizingMode, CUIResizingMode.stretches)
+            XCTAssertEqual(image.imageType, CUIImageType.vertical)
+            XCTAssertEqual(image._rendition().type(), CUIImageType.vertical)
+            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.vertical)
             XCTAssertEqual(image._rendition().sliceInformation()?.edgeInsets, NSEdgeInsets(top: 20, left: 0, bottom: 20, right: 0))
             XCTAssertEqual(image.acImageName, "s_vertical@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
@@ -81,10 +81,10 @@ class SlicesTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 3.0 }).first {
             XCTAssertTrue(image.hasSliceInformation)
-            XCTAssertEqual(image.resizingMode, CUIResizingMode.Tiles)
-            XCTAssertEqual(image.imageType, CUIImageType.Vertical)
-            XCTAssertEqual(image._rendition().type(), CUIImageType.Vertical)
-            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.Vertical)
+            XCTAssertEqual(image.resizingMode, CUIResizingMode.tiles)
+            XCTAssertEqual(image.imageType, CUIImageType.vertical)
+            XCTAssertEqual(image._rendition().type(), CUIImageType.vertical)
+            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.vertical)
             XCTAssertEqual(image._rendition().sliceInformation()?.edgeInsets, NSEdgeInsets(top: 29, left: 0, bottom: 29, right: 0))
             XCTAssertEqual(image.acImageName, "s_vertical@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
@@ -99,10 +99,10 @@ class SlicesTests: XCTestCase {
         XCTAssertEqual(images.count, 3)
         if let image = images.filter({ return $0.scale == 1.0 }).first {
             XCTAssertTrue(image.hasSliceInformation)
-            XCTAssertEqual(image.resizingMode, CUIResizingMode.Tiles)
-            XCTAssertEqual(image.imageType, CUIImageType.Horizontal)
-            XCTAssertEqual(image._rendition().type(), CUIImageType.Horizontal)
-            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.Horizontal)
+            XCTAssertEqual(image.resizingMode, CUIResizingMode.tiles)
+            XCTAssertEqual(image.imageType, CUIImageType.horizontal)
+            XCTAssertEqual(image._rendition().type(), CUIImageType.horizontal)
+            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.horizontal)
             XCTAssertEqual(image._rendition().sliceInformation()?.edgeInsets, NSEdgeInsets(top: 0, left: 10, bottom: 0, right: 10))
             XCTAssertEqual(image.acImageName, "s_horizontal.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
@@ -112,10 +112,10 @@ class SlicesTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 2.0 }).first {
             XCTAssertTrue(image.hasSliceInformation)
-            XCTAssertEqual(image.resizingMode, CUIResizingMode.Stretches)
-            XCTAssertEqual(image.imageType, CUIImageType.Horizontal)
-            XCTAssertEqual(image._rendition().type(), CUIImageType.Horizontal)
-            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.Horizontal)
+            XCTAssertEqual(image.resizingMode, CUIResizingMode.stretches)
+            XCTAssertEqual(image.imageType, CUIImageType.horizontal)
+            XCTAssertEqual(image._rendition().type(), CUIImageType.horizontal)
+            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.horizontal)
             XCTAssertEqual(image._rendition().sliceInformation()?.edgeInsets, NSEdgeInsets(top: 0, left: 20, bottom: 0, right: 19))
             XCTAssertEqual(image.acImageName, "s_horizontal@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
@@ -125,10 +125,10 @@ class SlicesTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 3.0 }).first {
             XCTAssertTrue(image.hasSliceInformation)
-            XCTAssertEqual(image.resizingMode, CUIResizingMode.Stretches)
-            XCTAssertEqual(image.imageType, CUIImageType.Horizontal)
-            XCTAssertEqual(image._rendition().type(), CUIImageType.Horizontal)
-            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.Horizontal)
+            XCTAssertEqual(image.resizingMode, CUIResizingMode.stretches)
+            XCTAssertEqual(image.imageType, CUIImageType.horizontal)
+            XCTAssertEqual(image._rendition().type(), CUIImageType.horizontal)
+            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.horizontal)
             XCTAssertEqual(image._rendition().sliceInformation()?.edgeInsets, NSEdgeInsets(top: 0, left: 29, bottom: 0, right: 29))
             XCTAssertEqual(image.acImageName, "s_horizontal@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
@@ -143,10 +143,10 @@ class SlicesTests: XCTestCase {
         XCTAssertEqual(images.count, 3)
         if let image = images.filter({ return $0.scale == 1.0 }).first {
             XCTAssertTrue(image.hasSliceInformation)
-            XCTAssertEqual(image.resizingMode, CUIResizingMode.Stretches)
-            XCTAssertEqual(image.imageType, CUIImageType.HorizontalAndVertical)
-            XCTAssertEqual(image._rendition().type(), CUIImageType.HorizontalAndVertical)
-            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.HorizontalAndVertical)
+            XCTAssertEqual(image.resizingMode, CUIResizingMode.stretches)
+            XCTAssertEqual(image.imageType, CUIImageType.horizontalAndVertical)
+            XCTAssertEqual(image._rendition().type(), CUIImageType.horizontalAndVertical)
+            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.horizontalAndVertical)
             XCTAssertEqual(image._rendition().sliceInformation()?.edgeInsets, NSEdgeInsets(top: 10, left: 11, bottom: 12, right: 13))
             XCTAssertEqual(image.acImageName, "s_horizontal_vertical.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
@@ -156,10 +156,10 @@ class SlicesTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 2.0 }).first {
             XCTAssertTrue(image.hasSliceInformation)
-            XCTAssertEqual(image.resizingMode, CUIResizingMode.Tiles)
-            XCTAssertEqual(image.imageType, CUIImageType.HorizontalAndVertical)
-            XCTAssertEqual(image._rendition().type(), CUIImageType.HorizontalAndVertical)
-            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.HorizontalAndVertical)
+            XCTAssertEqual(image.resizingMode, CUIResizingMode.tiles)
+            XCTAssertEqual(image.imageType, CUIImageType.horizontalAndVertical)
+            XCTAssertEqual(image._rendition().type(), CUIImageType.horizontalAndVertical)
+            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.horizontalAndVertical)
             XCTAssertEqual(image._rendition().sliceInformation()?.edgeInsets, NSEdgeInsets(top: 20, left: 20, bottom: 20, right: 19))
             XCTAssertEqual(image.acImageName, "s_horizontal_vertical@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
@@ -169,10 +169,10 @@ class SlicesTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 3.0 }).first {
             XCTAssertTrue(image.hasSliceInformation)
-            XCTAssertEqual(image.resizingMode, CUIResizingMode.Tiles)
-            XCTAssertEqual(image.imageType, CUIImageType.HorizontalAndVertical)
-            XCTAssertEqual(image._rendition().type(), CUIImageType.HorizontalAndVertical)
-            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.HorizontalAndVertical)
+            XCTAssertEqual(image.resizingMode, CUIResizingMode.tiles)
+            XCTAssertEqual(image.imageType, CUIImageType.horizontalAndVertical)
+            XCTAssertEqual(image._rendition().type(), CUIImageType.horizontalAndVertical)
+            XCTAssertEqual(image._rendition().sliceInformation()?.renditionType, CUIImageType.horizontalAndVertical)
             XCTAssertEqual(image._rendition().sliceInformation()?.edgeInsets, NSEdgeInsets(top: 30, left: 30, bottom: 30, right: 29))
             XCTAssertEqual(image.acImageName, "s_horizontal_vertical@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
diff --git a/acextractTests/TemplateRenderingTests.swift b/acextractTests/TemplateRenderingTests.swift
index f15b6bb..5ac63e4 100644
--- a/acextractTests/TemplateRenderingTests.swift
+++ b/acextractTests/TemplateRenderingTests.swift
@@ -16,7 +16,7 @@ class TemplateRenderingTests: XCTestCase {
         XCTAssertEqual(images.count, 3)
         if let image = images.filter({ return $0.scale == 1.0 }).first {
             XCTAssertFalse(image.isTemplate)
-            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.Default)
+            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.default)
             XCTAssertEqual(image.acImageName, "r_default.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -25,7 +25,7 @@ class TemplateRenderingTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 2.0 }).first {
             XCTAssertFalse(image.isTemplate)
-            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.Default)
+            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.default)
             XCTAssertEqual(image.acImageName, "r_default@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -34,7 +34,7 @@ class TemplateRenderingTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 3.0 }).first {
             XCTAssertFalse(image.isTemplate)
-            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.Default)
+            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.default)
             XCTAssertEqual(image.acImageName, "r_default@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -48,7 +48,7 @@ class TemplateRenderingTests: XCTestCase {
         XCTAssertEqual(images.count, 3)
         if let image = images.filter({ return $0.scale == 1.0 }).first {
             XCTAssertFalse(image.isTemplate)
-            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.Original)
+            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.original)
             XCTAssertEqual(image.acImageName, "r_original.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -57,7 +57,7 @@ class TemplateRenderingTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 2.0 }).first {
             XCTAssertFalse(image.isTemplate)
-            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.Original)
+            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.original)
             XCTAssertEqual(image.acImageName, "r_original@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -66,7 +66,7 @@ class TemplateRenderingTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 3.0 }).first {
             XCTAssertFalse(image.isTemplate)
-            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.Original)
+            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.original)
             XCTAssertEqual(image.acImageName, "r_original@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -80,7 +80,7 @@ class TemplateRenderingTests: XCTestCase {
         XCTAssertEqual(images.count, 3)
         if let image = images.filter({ return $0.scale == 1.0 }).first {
             XCTAssertTrue(image.isTemplate)
-            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.Template)
+            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.template)
             XCTAssertEqual(image.acImageName, "r_template.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -89,7 +89,7 @@ class TemplateRenderingTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 2.0 }).first {
             XCTAssertTrue(image.isTemplate)
-            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.Template)
+            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.template)
             XCTAssertEqual(image.acImageName, "r_template@2x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {
@@ -98,7 +98,7 @@ class TemplateRenderingTests: XCTestCase {
 
         if let image = images.filter({ return $0.scale == 3.0 }).first {
             XCTAssertTrue(image.isTemplate)
-            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.Template)
+            XCTAssertEqual(image.templateRenderingMode, CUIRenderMode.template)
             XCTAssertEqual(image.acImageName, "r_template@3x.png")
             XCTAssertNotNil(image._rendition().unslicedImage())
         } else {