 
 private func Verify(value: Any, againstValue expectedValue: Any) throws {
     guard let expectedVerifiableValue = expectedValue as? Verifiable else {
-        throw VerificationError.CannotVerifyValue(expectedValue)
+        throw VerificationError.cannotVerifyValue(expectedValue)
     }
     
     guard let actualVerifiableValue = value as? Verifiable else {
-        throw VerificationError.CannotVerifyValue(value)
+        throw VerificationError.cannotVerifyValue(value)
     }
     
     if actualVerifiableValue.hashValue != expectedVerifiableValue.hashValue {


private func Verify(dictionary: WrappedDictionary, againstDictionary expectedDictionary: WrappedDictionary) throws {
    if dictionary.count != expectedDictionary.count {
        throw VerificationError.CountMismatch
    }
    
    for (key, expectedValue) in expectedDictionary {
        guard let actualValue = dictionary[key] else {
            throw VerificationError.MissingValueForKey(key)
        }
        
        if let expectedNestedDictionary = expectedValue as? WrappedDictionary {

            let expectedValueType = type(of: expectedVerifiableValue)
            
            guard let convertedObject = expectedValueType.convert(objectiveCObject: objectiveCObject) else {
                throw VerificationError.cannotVerifyValue(value)
            }
            
            return try Verify(value: convertedObject, againstValue: expectedVerifiableValue)
        }
        
        throw VerificationError.valueMismatchBetween(value, expectedValue)
    }
}

