         
         struct Model {
             let dictionary = [
-                Key.First : "First value",
-                Key.Second : "Second value"
+                Key.first : "First value",
+                Key.second : "Second value"
             ]
         }
         

    
    func testEnumProperties() {
        enum Enum {
            case First
            case Second(String)
            case Third(intValue: Int)
        }
        
        enum IntEnum: Int, WrappableEnum {
            case First
            case Second = 17
        }
        
        enum StringEnum: String, WrappableEnum {
            case First = "First string"
            case Second = "Second string"
        }
        
        struct Model {
            let first = Enum.First
            let second = Enum.Second("Hello")
            let third = Enum.Third(intValue: 15)
            let firstInt = IntEnum.First
            let secondInt = IntEnum.Second
            let firstString = StringEnum.First
            let secondString = StringEnum.Second
        }
        
        do {
            try Verify(dictionary: wrap(Model()), againstDictionary: [
                "first" : "First",
                "second" : [
                    "Second" : "Hello"
                ],
                "third" : [
                    "Third" : 15
                ],
                "firstInt" : 0,
                "secondInt" : 17,

    
    func testRootEnum() {
        enum Enum {
            case first
            case second(String)
        }
        
        do {
            try Verify(dictionary: wrap(Enum.first), againstDictionary: [:])
            
            try Verify(dictionary: wrap(Enum.second("Hello")), againstDictionary: [
                "second" : "Hello"
            ])
        } catch {
            XCTFail(error.toString())
