diff --git a/.gitmodules b/.gitmodules deleted file mode 100644 index 7e78803a..00000000 --- a/.gitmodules +++ /dev/null @@ -1,3 +0,0 @@ -[submodule "Carthage/Checkouts/Nimble"] - url = https://github.com/Quick/Nimble.git - path = Carthage/Checkouts/Nimble diff --git a/Cartfile.private b/Cartfile.private deleted file mode 100644 index 8f3964d8..00000000 --- a/Cartfile.private +++ /dev/null @@ -1 +0,0 @@ -github "Quick/Nimble" ~> 3.0.0 diff --git a/Cartfile.resolved b/Cartfile.resolved deleted file mode 100644 index 9e13a1ec..00000000 --- a/Cartfile.resolved +++ /dev/null @@ -1 +0,0 @@ -github "Quick/Nimble" "v3.0.0" diff --git a/Carthage/Checkouts/Nimble b/Carthage/Checkouts/Nimble deleted file mode 160000 index 10e1906a..00000000 --- a/Carthage/Checkouts/Nimble +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 10e1906a76085b26f050ced40754640add4ebcf4 diff --git a/ObjectMapper.xcodeproj/project.pbxproj b/ObjectMapper.xcodeproj/project.pbxproj index b40de612..10593cbd 100644 --- a/ObjectMapper.xcodeproj/project.pbxproj +++ b/ObjectMapper.xcodeproj/project.pbxproj @@ -37,7 +37,6 @@ 6AAC8FD119F048FE00E7A677 /* ToJSON.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6AAC8FC719F048FE00E7A677 /* ToJSON.swift */; }; 6AAC8FD319F048FE00E7A677 /* DateTransform.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6AAC8FCB19F048FE00E7A677 /* DateTransform.swift */; }; 6AAE6A431ACED93500FBC899 /* ObjectMapper.framework in CopyFiles */ = {isa = PBXBuildFile; fileRef = CD1602FF1AC023D5000CD69A /* ObjectMapper.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; }; - 6AAE6A441ACED93B00FBC899 /* Nimble.framework in CopyFiles */ = {isa = PBXBuildFile; fileRef = CD208C981AC10D2B00E21781 /* Nimble.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; }; 6AC458191BA350CF00054758 /* ObjectMapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 6AAC8F7B19F03C2900E7A677 /* ObjectMapper.h */; settings = {ATTRIBUTES = (Public, ); }; }; 6AC692341BE3FD3A004C119A /* Map.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6ACB15D11BC7F1D0006C029C /* Map.swift */; }; 6AC692351BE3FD3A004C119A /* Mapper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6AAC8FC419F048FE00E7A677 /* Mapper.swift */; }; @@ -83,9 +82,6 @@ CD1603281AC02480000CD69A /* CustomTransformTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6A51372E1AADE12C00B82516 /* CustomTransformTests.swift */; }; CD1603291AC02480000CD69A /* NestedKeysTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = CD44374C1AAE9C1100A271BA /* NestedKeysTests.swift */; }; CD16032A1AC02480000CD69A /* ObjectMapperTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6AAC8F8519F03C2900E7A677 /* ObjectMapperTests.swift */; }; - CD208C991AC10D2B00E21781 /* Nimble.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = CD208C981AC10D2B00E21781 /* Nimble.framework */; }; - CD208C9A1AC10D2B00E21781 /* Nimble.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = CD208C981AC10D2B00E21781 /* Nimble.framework */; }; - CD208C9B1AC10D6D00E21781 /* Nimble.framework in Copy Frameworks */ = {isa = PBXBuildFile; fileRef = CD208C981AC10D2B00E21781 /* Nimble.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; }; CD4437491AAD692B00A271BA /* ObjectMapper.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 6AAC8F7619F03C2900E7A677 /* ObjectMapper.framework */; }; CD44374B1AAD698400A271BA /* ObjectMapper.framework in Copy Frameworks */ = {isa = PBXBuildFile; fileRef = 6AAC8F7619F03C2900E7A677 /* ObjectMapper.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; }; CD44374D1AAE9C1100A271BA /* NestedKeysTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = CD44374C1AAE9C1100A271BA /* NestedKeysTests.swift */; }; @@ -125,7 +121,6 @@ dstPath = ""; dstSubfolderSpec = 10; files = ( - 6AAE6A441ACED93B00FBC899 /* Nimble.framework in CopyFiles */, 6AAE6A431ACED93500FBC899 /* ObjectMapper.framework in CopyFiles */, ); runOnlyForDeploymentPostprocessing = 0; @@ -137,7 +132,6 @@ dstSubfolderSpec = 10; files = ( CD44374B1AAD698400A271BA /* ObjectMapper.framework in Copy Frameworks */, - CD208C9B1AC10D6D00E21781 /* Nimble.framework in Copy Frameworks */, ); name = "Copy Frameworks"; runOnlyForDeploymentPostprocessing = 0; @@ -172,7 +166,6 @@ BC1E7F361ABC44C000F9B1CF /* EnumTransform.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = EnumTransform.swift; sourceTree = ""; }; CD1602FF1AC023D5000CD69A /* ObjectMapper.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = ObjectMapper.framework; sourceTree = BUILT_PRODUCTS_DIR; }; CD1603091AC023D6000CD69A /* ObjectMapper-MacTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "ObjectMapper-MacTests.xctest"; sourceTree = BUILT_PRODUCTS_DIR; }; - CD208C981AC10D2B00E21781 /* Nimble.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = Nimble.framework; sourceTree = BUILT_PRODUCTS_DIR; }; CD44374C1AAE9C1100A271BA /* NestedKeysTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; lineEnding = 0; path = NestedKeysTests.swift; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.swift; }; CD50B6FC1A82518300744312 /* TransformType.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TransformType.swift; sourceTree = ""; }; CD71C8C01A7218AD009D4161 /* TransformOf.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; lineEnding = 0; path = TransformOf.swift; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.swift; }; @@ -214,7 +207,6 @@ buildActionMask = 2147483647; files = ( CD4437491AAD692B00A271BA /* ObjectMapper.framework in Frameworks */, - CD208C991AC10D2B00E21781 /* Nimble.framework in Frameworks */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -230,7 +222,6 @@ buildActionMask = 2147483647; files = ( CD16030A1AC023D6000CD69A /* ObjectMapper.framework in Frameworks */, - CD208C9A1AC10D2B00E21781 /* Nimble.framework in Frameworks */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -310,7 +301,6 @@ 6AAC8F8319F03C2900E7A677 /* Supporting Files */ = { isa = PBXGroup; children = ( - CD208C981AC10D2B00E21781 /* Nimble.framework */, 6AAC8F8419F03C2900E7A677 /* Info.plist */, ); name = "Supporting Files"; diff --git a/ObjectMapper.xcworkspace/contents.xcworkspacedata b/ObjectMapper.xcworkspace/contents.xcworkspacedata index 77ec4eff..2ff47793 100644 --- a/ObjectMapper.xcworkspace/contents.xcworkspacedata +++ b/ObjectMapper.xcworkspace/contents.xcworkspacedata @@ -4,7 +4,4 @@ - - diff --git a/ObjectMapperTests/BasicTypesTestsFromJSON.swift b/ObjectMapperTests/BasicTypesTestsFromJSON.swift index befb1fc1..1a9f14e6 100644 --- a/ObjectMapperTests/BasicTypesTestsFromJSON.swift +++ b/ObjectMapperTests/BasicTypesTestsFromJSON.swift @@ -9,7 +9,6 @@ import Foundation import XCTest import ObjectMapper -import Nimble class BasicTypesTestsFromJSON: XCTestCase { @@ -33,10 +32,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.bool).to(equal(value)) - expect(mappedObject?.boolOptional).to(equal(value)) - expect(mappedObject?.boolImplicityUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.bool, value) + XCTAssertEqual(mappedObject?.boolOptional, value) + XCTAssertEqual(mappedObject?.boolImplicityUnwrapped, value) } func testMappingIntFromJSON(){ @@ -45,10 +44,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.int).to(equal(value)) - expect(mappedObject?.intOptional).to(equal(value)) - expect(mappedObject?.intImplicityUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.int, value) + XCTAssertEqual(mappedObject?.intOptional, value) + XCTAssertEqual(mappedObject?.intImplicityUnwrapped, value) } func testMappingDoubleFromJSON(){ @@ -57,10 +56,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.double).to(equal(value)) - expect(mappedObject?.doubleOptional).to(equal(value)) - expect(mappedObject?.doubleImplicityUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.double, value) + XCTAssertEqual(mappedObject?.doubleOptional, value) + XCTAssertEqual(mappedObject?.doubleImplicityUnwrapped, value) } func testMappingFloatFromJSON(){ @@ -69,10 +68,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.float).to(equal(value)) - expect(mappedObject?.floatOptional).to(equal(value)) - expect(mappedObject?.floatImplicityUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.float, value) + XCTAssertEqual(mappedObject?.floatOptional, value) + XCTAssertEqual(mappedObject?.floatImplicityUnwrapped, value) } func testMappingStringFromJSON(){ @@ -81,10 +80,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.string).to(equal(value)) - expect(mappedObject?.stringOptional).to(equal(value)) - expect(mappedObject?.stringImplicityUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.string, value) + XCTAssertEqual(mappedObject?.stringOptional, value) + XCTAssertEqual(mappedObject?.stringImplicityUnwrapped, value) } func testMappingAnyObjectFromJSON(){ @@ -95,10 +94,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.anyObject as? String).to(equal(value1)) - expect(mappedObject?.anyObjectOptional as? Int).to(equal(value2)) - expect(mappedObject?.anyObjectImplicitlyUnwrapped as? Double).to(equal(value3)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.anyObject as? String, value1) + XCTAssertEqual(mappedObject?.anyObjectOptional as? Int, value2) + XCTAssertEqual(mappedObject?.anyObjectImplicitlyUnwrapped as? Double, value3) } func testMappingStringFromNSStringJSON(){ @@ -106,11 +105,11 @@ class BasicTypesTestsFromJSON: XCTestCase { let JSONNSString : NSString = "{\"string\" : \"\(value)\", \"stringOpt\" : \"\(value)\", \"stringImp\" : \"\(value)\"}" let mappedObject = mapper.map(JSONNSString) - - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.string).to(equal(value)) - expect(mappedObject?.stringOptional).to(equal(value)) - expect(mappedObject?.stringImplicityUnwrapped).to(equal(value)) + + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.string, value) + XCTAssertEqual(mappedObject?.stringOptional, value) + XCTAssertEqual(mappedObject?.stringImplicityUnwrapped, value) } // MARK: Test mapping Arrays to JSON and back (with basic types in them Bool, Int, Double, Float, String) @@ -121,10 +120,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayBool.first).to(equal(value)) - expect(mappedObject?.arrayBoolImplicityUnwrapped.first).to(equal(value)) - expect(mappedObject?.arrayBoolOptional?.first).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayBool.first, value) + XCTAssertEqual(mappedObject?.arrayBoolOptional?.first, value) + XCTAssertEqual(mappedObject?.arrayBoolImplicityUnwrapped.first, value) } func testMappingIntArrayFromJSON(){ @@ -133,10 +132,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayInt.first).to(equal(value)) - expect(mappedObject?.arrayIntImplicityUnwrapped.first).to(equal(value)) - expect(mappedObject?.arrayIntOptional?.first).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayInt.first, value) + XCTAssertEqual(mappedObject?.arrayIntOptional?.first, value) + XCTAssertEqual(mappedObject?.arrayIntImplicityUnwrapped.first, value) } func testMappingDoubleArrayFromJSON(){ @@ -145,10 +144,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayDouble.first).to(equal(value)) - expect(mappedObject?.arrayDoubleImplicityUnwrapped.first).to(equal(value)) - expect(mappedObject?.arrayDoubleOptional?.first).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayDouble.first, value) + XCTAssertEqual(mappedObject?.arrayDoubleOptional?.first, value) + XCTAssertEqual(mappedObject?.arrayDoubleImplicityUnwrapped.first, value) } func testMappingFloatArrayFromJSON(){ @@ -157,10 +156,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayFloat.first).to(equal(value)) - expect(mappedObject?.arrayFloatImplicityUnwrapped.first).to(equal(value)) - expect(mappedObject?.arrayFloatOptional?.first).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayFloat.first, value) + XCTAssertEqual(mappedObject?.arrayFloatOptional?.first, value) + XCTAssertEqual(mappedObject?.arrayFloatImplicityUnwrapped.first, value) } func testMappingStringArrayFromJSON(){ @@ -169,10 +168,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayString.first).to(equal(value)) - expect(mappedObject?.arrayStringImplicityUnwrapped.first).to(equal(value)) - expect(mappedObject?.arrayStringOptional?.first).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayString.first, value) + XCTAssertEqual(mappedObject?.arrayStringOptional?.first, value) + XCTAssertEqual(mappedObject?.arrayStringImplicityUnwrapped.first, value) } func testMappingAnyObjectArrayFromJSON(){ @@ -183,10 +182,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayAnyObject.first as? String).to(equal(value1)) - expect(mappedObject?.arrayAnyObjectOptional?.first as? Int).to(equal(value2)) - expect(mappedObject?.arrayAnyObjectImplicitlyUnwrapped.first as? Double).to(equal(value3)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayAnyObject.first as? String, value1) + XCTAssertEqual(mappedObject?.arrayAnyObjectOptional?.first as? Int, value2) + XCTAssertEqual(mappedObject?.arrayAnyObjectImplicitlyUnwrapped.first as? Double, value3) } // MARK: Test mapping Dictionaries to JSON and back (with basic types in them Bool, Int, Double, Float, String) @@ -198,10 +197,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictBoolOptional?[key]).to(equal(value)) - expect(mappedObject?.dictBoolImplicityUnwrapped[key]).to(equal(value)) - expect(mappedObject?.dictBool[key]).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictBool[key], value) + XCTAssertEqual(mappedObject?.dictBoolOptional?[key], value) + XCTAssertEqual(mappedObject?.dictBoolImplicityUnwrapped[key], value) } func testMappingIntDictionaryFromJSON(){ @@ -211,10 +210,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictIntOptional?[key]).to(equal(value)) - expect(mappedObject?.dictIntImplicityUnwrapped[key]).to(equal(value)) - expect(mappedObject?.dictInt[key]).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictInt[key], value) + XCTAssertEqual(mappedObject?.dictIntOptional?[key], value) + XCTAssertEqual(mappedObject?.dictIntImplicityUnwrapped[key], value) } func testMappingDoubleDictionaryFromJSON(){ @@ -224,10 +223,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictDoubleOptional?[key]).to(equal(value)) - expect(mappedObject?.dictDoubleImplicityUnwrapped[key]).to(equal(value)) - expect(mappedObject?.dictDouble[key]).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictDouble[key], value) + XCTAssertEqual(mappedObject?.dictDoubleOptional?[key], value) + XCTAssertEqual(mappedObject?.dictDoubleImplicityUnwrapped[key], value) } func testMappingFloatDictionaryFromJSON(){ @@ -237,10 +236,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictFloat[key]).to(equal(value)) - expect(mappedObject?.dictFloatOptional?[key]).to(equal(value)) - expect(mappedObject?.dictFloatImplicityUnwrapped[key]).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictFloat[key], value) + XCTAssertEqual(mappedObject?.dictFloatOptional?[key], value) + XCTAssertEqual(mappedObject?.dictFloatImplicityUnwrapped[key], value) } func testMappingStringDictionaryFromJSON(){ @@ -250,10 +249,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictString[key]).to(equal(value)) - expect(mappedObject?.dictStringOptional?[key]).to(equal(value)) - expect(mappedObject?.dictStringImplicityUnwrapped[key]).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictString[key], value) + XCTAssertEqual(mappedObject?.dictStringOptional?[key], value) + XCTAssertEqual(mappedObject?.dictStringImplicityUnwrapped[key], value) } func testMappingAnyObjectDictionaryFromJSON(){ @@ -265,10 +264,10 @@ class BasicTypesTestsFromJSON: XCTestCase { let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictAnyObject[key] as? String).to(equal(value1)) - expect(mappedObject?.dictAnyObjectOptional?[key] as? Int).to(equal(value2)) - expect(mappedObject?.dictAnyObjectImplicitlyUnwrapped[key] as? Double).to(equal(value3)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictAnyObject[key] as? String, value1) + XCTAssertEqual(mappedObject?.dictAnyObjectOptional?[key] as? Int, value2) + XCTAssertEqual(mappedObject?.dictAnyObjectImplicitlyUnwrapped[key] as? Double, value3) } func testMappingIntEnumFromJSON(){ @@ -276,10 +275,11 @@ class BasicTypesTestsFromJSON: XCTestCase { let JSONString = "{\"enumInt\" : \(value.rawValue), \"enumIntOpt\" : \(value.rawValue), \"enumIntImp\" : \(value.rawValue) }" let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.enumInt).to(equal(value)) - expect(mappedObject?.enumIntOptional).to(equal(value)) - expect(mappedObject?.enumIntImplicitlyUnwrapped).to(equal(value)) + + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.enumInt, value) + XCTAssertEqual(mappedObject?.enumIntOptional, value) + XCTAssertEqual(mappedObject?.enumIntImplicitlyUnwrapped, value) } func testMappingIntEnumFromJSONShouldNotCrashWithNonDefinedvalue() { @@ -287,10 +287,11 @@ class BasicTypesTestsFromJSON: XCTestCase { let JSONString = "{\"enumInt\" : \(value), \"enumIntOpt\" : \(value), \"enumIntImp\" : \(value) }" let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.enumInt).to(equal(BasicTypes.EnumInt.Default)) - expect(mappedObject?.enumIntOptional).to(beNil()) - expect(mappedObject?.enumIntImplicitlyUnwrapped).to(beNil()) + + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.enumInt, BasicTypes.EnumInt.Default) + XCTAssertNil(mappedObject?.enumIntOptional) + XCTAssertNil(mappedObject?.enumIntImplicitlyUnwrapped) } func testMappingDoubleEnumFromJSON(){ @@ -298,10 +299,11 @@ class BasicTypesTestsFromJSON: XCTestCase { let JSONString = "{\"enumDouble\" : \(value.rawValue), \"enumDoubleOpt\" : \(value.rawValue), \"enumDoubleImp\" : \(value.rawValue) }" let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.enumDouble).to(equal(value)) - expect(mappedObject?.enumDoubleOptional).to(equal(value)) - expect(mappedObject?.enumDoubleImplicitlyUnwrapped).to(equal(value)) + + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.enumDouble, value) + XCTAssertEqual(mappedObject?.enumDoubleOptional, value) + XCTAssertEqual(mappedObject?.enumDoubleImplicitlyUnwrapped, value) } func testMappingFloatEnumFromJSON(){ @@ -309,10 +311,11 @@ class BasicTypesTestsFromJSON: XCTestCase { let JSONString = "{\"enumFloat\" : \(value.rawValue), \"enumFloatOpt\" : \(value.rawValue), \"enumFloatImp\" : \(value.rawValue) }" let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.enumFloat).to(equal(value)) - expect(mappedObject?.enumFloatOptional).to(equal(value)) - expect(mappedObject?.enumFloatImplicitlyUnwrapped).to(equal(value)) + + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.enumFloat, value) + XCTAssertEqual(mappedObject?.enumFloatOptional, value) + XCTAssertEqual(mappedObject?.enumFloatImplicitlyUnwrapped, value) } func testMappingStringEnumFromJSON(){ @@ -320,10 +323,11 @@ class BasicTypesTestsFromJSON: XCTestCase { let JSONString = "{\"enumString\" : \"\(value.rawValue)\", \"enumStringOpt\" : \"\(value.rawValue)\", \"enumStringImp\" : \"\(value.rawValue)\" }" let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.enumString).to(equal(value)) - expect(mappedObject?.enumStringOptional).to(equal(value)) - expect(mappedObject?.enumStringImplicitlyUnwrapped).to(equal(value)) + + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.enumString, value) + XCTAssertEqual(mappedObject?.enumStringOptional, value) + XCTAssertEqual(mappedObject?.enumStringImplicitlyUnwrapped, value) } func testMappingEnumIntArrayFromJSON(){ @@ -331,10 +335,11 @@ class BasicTypesTestsFromJSON: XCTestCase { let JSONString = "{ \"arrayEnumInt\" : [\(value.rawValue)], \"arrayEnumIntOpt\" : [\(value.rawValue)], \"arrayEnumIntImp\" : [\(value.rawValue)] }" let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayEnumInt.first).to(equal(value)) - expect(mappedObject?.arrayEnumIntOptional?.first).to(equal(value)) - expect(mappedObject?.arrayEnumIntImplicitlyUnwrapped?.first).to(equal(value)) + + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayEnumInt.first, value) + XCTAssertEqual(mappedObject?.arrayEnumIntOptional?.first, value) + XCTAssertEqual(mappedObject?.arrayEnumIntImplicitlyUnwrapped.first, value) } func testMappingEnumIntArrayFromJSONShouldNotCrashWithNonDefinedvalue() { @@ -342,10 +347,11 @@ class BasicTypesTestsFromJSON: XCTestCase { let JSONString = "{ \"arrayEnumInt\" : [\(value)], \"arrayEnumIntOpt\" : [\(value)], \"arrayEnumIntImp\" : [\(value)] }" let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayEnumInt.first).to(beNil()) - expect(mappedObject?.arrayEnumIntOptional?.first).to(beNil()) - expect(mappedObject?.arrayEnumIntImplicitlyUnwrapped?.first).to(beNil()) + + XCTAssertNotNil(mappedObject) + XCTAssertNil(mappedObject?.arrayEnumInt.first) + XCTAssertNil(mappedObject?.arrayEnumIntOptional?.first) + XCTAssertNil(mappedObject?.arrayEnumIntImplicitlyUnwrapped.first) } func testMappingEnumIntDictionaryFromJSON(){ @@ -354,10 +360,11 @@ class BasicTypesTestsFromJSON: XCTestCase { let JSONString = "{ \"dictEnumInt\" : { \"\(key)\" : \(value.rawValue) }, \"dictEnumIntOpt\" : { \"\(key)\" : \(value.rawValue) }, \"dictEnumIntImp\" : { \"\(key)\" : \(value.rawValue) } }" let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictEnumInt[key]).to(equal(value)) - expect(mappedObject?.dictEnumIntOptional?[key]).to(equal(value)) - expect(mappedObject?.dictEnumIntImplicitlyUnwrapped?[key]).to(equal(value)) + + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictEnumInt[key], value) + XCTAssertEqual(mappedObject?.dictEnumIntOptional?[key], value) + XCTAssertEqual(mappedObject?.dictEnumIntImplicitlyUnwrapped[key], value) } func testMappingEnumIntDictionaryFromJSONShouldNotCrashWithNonDefinedvalue() { @@ -366,10 +373,11 @@ class BasicTypesTestsFromJSON: XCTestCase { let JSONString = "{ \"dictEnumInt\" : { \"\(key)\" : \(value) }, \"dictEnumIntOpt\" : { \"\(key)\" : \(value) }, \"dictEnumIntImp\" : { \"\(key)\" : \(value) } }" let mappedObject = mapper.map(JSONString) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayEnumInt.first).to(beNil()) - expect(mappedObject?.dictEnumIntOptional?[key]).to(beNil()) - expect(mappedObject?.dictEnumIntImplicitlyUnwrapped?[key]).to(beNil()) + + XCTAssertNotNil(mappedObject) + XCTAssertNil(mappedObject?.dictEnumInt[key]) + XCTAssertNil(mappedObject?.dictEnumIntOptional?[key]) + XCTAssertNil(mappedObject?.dictEnumIntImplicitlyUnwrapped[key]) } func testObjectModelOptionalDictionnaryOfPrimitives() { @@ -377,12 +385,13 @@ class BasicTypesTestsFromJSON: XCTestCase { let mapper = Mapper() let testSet: TestCollectionOfPrimitives! = mapper.map(JSON) - expect(testSet).notTo(beNil()) - expect(testSet.dictStringString).notTo(beEmpty()) - expect(testSet.dictStringInt).notTo(beEmpty()) - expect(testSet.dictStringBool).notTo(beEmpty()) - expect(testSet.dictStringDouble).notTo(beEmpty()) - expect(testSet.dictStringFloat).notTo(beEmpty()) + XCTAssertNotNil(testSet) + + XCTAssertTrue(testSet.dictStringString.count > 0) + XCTAssertTrue(testSet.dictStringInt.count > 0) + XCTAssertTrue(testSet.dictStringBool.count > 0) + XCTAssertTrue(testSet.dictStringDouble.count > 0) + XCTAssertTrue(testSet.dictStringFloat.count > 0) } } diff --git a/ObjectMapperTests/BasicTypesTestsToJSON.swift b/ObjectMapperTests/BasicTypesTestsToJSON.swift index 7e6ce355..67f9ff3c 100644 --- a/ObjectMapperTests/BasicTypesTestsToJSON.swift +++ b/ObjectMapperTests/BasicTypesTestsToJSON.swift @@ -9,7 +9,6 @@ import Foundation import XCTest import ObjectMapper -import Nimble class BasicTypesTestsToJSON: XCTestCase { @@ -37,10 +36,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.bool).to(equal(value)) - expect(mappedObject?.boolOptional).to(equal(value)) - expect(mappedObject?.boolImplicityUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.bool, value) + XCTAssertEqual(mappedObject?.boolOptional, value) + XCTAssertEqual(mappedObject?.boolImplicityUnwrapped, value) } func testMappingIntToJSON(){ @@ -53,10 +52,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.int).to(equal(value)) - expect(mappedObject?.intOptional).to(equal(value)) - expect(mappedObject?.intImplicityUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.int, value) + XCTAssertEqual(mappedObject?.intOptional, value) + XCTAssertEqual(mappedObject?.intImplicityUnwrapped, value) } func testMappingDoubleToJSON(){ @@ -69,10 +68,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.double).to(equal(value)) - expect(mappedObject?.doubleOptional).to(equal(value)) - expect(mappedObject?.doubleImplicityUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.double, value) + XCTAssertEqual(mappedObject?.doubleOptional, value) + XCTAssertEqual(mappedObject?.doubleImplicityUnwrapped, value) } func testMappingFloatToJSON(){ @@ -85,10 +84,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.float).to(equal(value)) - expect(mappedObject?.floatOptional).to(equal(value)) - expect(mappedObject?.floatImplicityUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.float, value) + XCTAssertEqual(mappedObject?.floatOptional, value) + XCTAssertEqual(mappedObject?.floatImplicityUnwrapped, value) } func testMappingStringToJSON(){ @@ -101,10 +100,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.string).to(equal(value)) - expect(mappedObject?.stringOptional).to(equal(value)) - expect(mappedObject?.stringImplicityUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.string, value) + XCTAssertEqual(mappedObject?.stringOptional, value) + XCTAssertEqual(mappedObject?.stringImplicityUnwrapped, value) } func testMappingAnyObjectToJSON(){ @@ -117,10 +116,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.anyObject as? String).to(equal(value)) - expect(mappedObject?.anyObjectOptional as? String).to(equal(value)) - expect(mappedObject?.anyObjectImplicitlyUnwrapped as? String).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.anyObject as? String, value) + XCTAssertEqual(mappedObject?.anyObjectOptional as? String, value) + XCTAssertEqual(mappedObject?.anyObjectImplicitlyUnwrapped as? String, value) } // MARK: Test mapping Arrays to JSON and back (with basic types in them Bool, Int, Double, Float, String) @@ -134,10 +133,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayBool).to(equal([])) - expect(mappedObject?.arrayBoolOptional!).to(equal([])) - expect(mappedObject?.arrayBoolImplicityUnwrapped).to(equal([])) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject!.arrayBool, []) + XCTAssertEqual(mappedObject!.arrayBoolOptional!, []) + XCTAssertEqual(mappedObject!.arrayBoolImplicityUnwrapped, []) } func testMappingBoolArrayToJSON(){ @@ -150,10 +149,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayBool.first).to(equal(value)) - expect(mappedObject?.arrayBoolOptional?.first).to(equal(value)) - expect(mappedObject?.arrayBoolImplicityUnwrapped.first).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayBool.first, value) + XCTAssertEqual(mappedObject?.arrayBoolOptional?.first, value) + XCTAssertEqual(mappedObject?.arrayBoolImplicityUnwrapped.first, value) } func testMappingIntArrayToJSON(){ @@ -166,10 +165,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayInt.first).to(equal(value)) - expect(mappedObject?.arrayIntOptional?.first).to(equal(value)) - expect(mappedObject?.arrayIntImplicityUnwrapped.first).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayInt.first, value) + XCTAssertEqual(mappedObject?.arrayIntOptional?.first, value) + XCTAssertEqual(mappedObject?.arrayIntImplicityUnwrapped.first, value) } func testMappingDoubleArrayToJSON(){ @@ -182,10 +181,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayDouble.first).to(equal(value)) - expect(mappedObject?.arrayDoubleOptional?.first).to(equal(value)) - expect(mappedObject?.arrayDoubleImplicityUnwrapped.first).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayDouble.first, value) + XCTAssertEqual(mappedObject?.arrayDoubleOptional?.first, value) + XCTAssertEqual(mappedObject?.arrayDoubleImplicityUnwrapped.first, value) } func testMappingFloatArrayToJSON(){ @@ -198,10 +197,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayFloat.first).to(equal(value)) - expect(mappedObject?.arrayFloatOptional?.first).to(equal(value)) - expect(mappedObject?.arrayFloatImplicityUnwrapped.first).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayFloat.first, value) + XCTAssertEqual(mappedObject?.arrayFloatOptional?.first, value) + XCTAssertEqual(mappedObject?.arrayFloatImplicityUnwrapped.first, value) } func testMappingStringArrayToJSON(){ @@ -214,10 +213,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayString.first).to(equal(value)) - expect(mappedObject?.arrayStringOptional?.first).to(equal(value)) - expect(mappedObject?.arrayStringImplicityUnwrapped.first).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayString.first, value) + XCTAssertEqual(mappedObject?.arrayStringOptional?.first, value) + XCTAssertEqual(mappedObject?.arrayStringImplicityUnwrapped.first, value) } func testMappingAnyObjectArrayToJSON(){ @@ -230,10 +229,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayAnyObject.first as? String).to(equal(value)) - expect(mappedObject?.arrayAnyObjectOptional?.first as? String).to(equal(value)) - expect(mappedObject?.arrayAnyObjectImplicitlyUnwrapped.first as? String).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayAnyObject.first as? String, value) + XCTAssertEqual(mappedObject?.arrayAnyObjectOptional?.first as? String, value) + XCTAssertEqual(mappedObject?.arrayAnyObjectImplicitlyUnwrapped.first as? String, value) } // MARK: Test mapping Dictionaries to JSON and back (with basic types in them Bool, Int, Double, Float, String) @@ -247,10 +246,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictBool).to(equal([:])) - expect(mappedObject?.dictBoolOptional!).to(equal([:])) - expect(mappedObject?.dictBoolImplicityUnwrapped).to(equal([:])) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject!.dictBool, [:]) + XCTAssertEqual(mappedObject!.dictBoolOptional!, [:]) + XCTAssertEqual(mappedObject!.dictBoolImplicityUnwrapped, [:]) } func testMappingBoolDictionaryToJSON(){ @@ -264,10 +263,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictBool[key]).to(equal(value)) - expect(mappedObject?.dictBoolOptional?[key]).to(equal(value)) - expect(mappedObject?.dictBoolImplicityUnwrapped[key]).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictBool[key], value) + XCTAssertEqual(mappedObject?.dictBoolOptional?[key], value) + XCTAssertEqual(mappedObject?.dictBoolImplicityUnwrapped[key], value) } func testMappingIntDictionaryToJSON(){ @@ -281,10 +280,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictInt[key]).to(equal(value)) - expect(mappedObject?.dictIntOptional?[key]).to(equal(value)) - expect(mappedObject?.dictIntImplicityUnwrapped[key]).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictInt[key], value) + XCTAssertEqual(mappedObject?.dictIntOptional?[key], value) + XCTAssertEqual(mappedObject?.dictIntImplicityUnwrapped[key], value) } func testMappingDoubleDictionaryToJSON(){ @@ -298,10 +297,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictDouble[key]).to(equal(value)) - expect(mappedObject?.dictDoubleOptional?[key]).to(equal(value)) - expect(mappedObject?.dictDoubleImplicityUnwrapped[key]).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictDouble[key], value) + XCTAssertEqual(mappedObject?.dictDoubleOptional?[key], value) + XCTAssertEqual(mappedObject?.dictDoubleImplicityUnwrapped[key], value) } func testMappingFloatDictionaryToJSON(){ @@ -315,10 +314,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictFloat[key]).to(equal(value)) - expect(mappedObject?.dictFloatOptional?[key]).to(equal(value)) - expect(mappedObject?.dictFloatImplicityUnwrapped[key]).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictFloat[key], value) + XCTAssertEqual(mappedObject?.dictFloatOptional?[key], value) + XCTAssertEqual(mappedObject?.dictFloatImplicityUnwrapped[key], value) } func testMappingStringDictionaryToJSON(){ @@ -332,10 +331,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictString[key]).to(equal(value)) - expect(mappedObject?.dictStringOptional?[key]).to(equal(value)) - expect(mappedObject?.dictStringImplicityUnwrapped[key]).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictString[key], value) + XCTAssertEqual(mappedObject?.dictStringOptional?[key], value) + XCTAssertEqual(mappedObject?.dictStringImplicityUnwrapped[key], value) } func testMappingAnyObjectDictionaryToJSON(){ @@ -349,10 +348,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictAnyObject[key] as? String).to(equal(value)) - expect(mappedObject?.dictAnyObjectOptional?[key] as? String).to(equal(value)) - expect(mappedObject?.dictAnyObjectImplicitlyUnwrapped[key] as? String).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictAnyObject[key] as? String, value) + XCTAssertEqual(mappedObject?.dictAnyObjectOptional?[key] as? String, value) + XCTAssertEqual(mappedObject?.dictAnyObjectImplicitlyUnwrapped[key] as? String, value) } func testMappingIntEnumToJSON(){ @@ -365,10 +364,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.enumInt).to(equal(value)) - expect(mappedObject?.enumIntOptional).to(equal(value)) - expect(mappedObject?.enumIntImplicitlyUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.enumInt, value) + XCTAssertEqual(mappedObject?.enumIntOptional, value) + XCTAssertEqual(mappedObject?.enumIntImplicitlyUnwrapped, value) } func testMappingDoubleEnumToJSON(){ @@ -381,10 +380,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.enumDouble).to(equal(value)) - expect(mappedObject?.enumDoubleOptional).to(equal(value)) - expect(mappedObject?.enumDoubleImplicitlyUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.enumDouble, value) + XCTAssertEqual(mappedObject?.enumDoubleOptional, value) + XCTAssertEqual(mappedObject?.enumDoubleImplicitlyUnwrapped, value) } func testMappingFloatEnumToJSON(){ @@ -397,10 +396,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.enumFloat).to(equal(value)) - expect(mappedObject?.enumFloatOptional).to(equal(value)) - expect(mappedObject?.enumFloatImplicitlyUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.enumFloat, value) + XCTAssertEqual(mappedObject?.enumFloatOptional, value) + XCTAssertEqual(mappedObject?.enumFloatImplicitlyUnwrapped, value) } func testMappingStringEnumToJSON(){ @@ -413,10 +412,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.enumString).to(equal(value)) - expect(mappedObject?.enumStringOptional).to(equal(value)) - expect(mappedObject?.enumStringImplicitlyUnwrapped).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.enumString, value) + XCTAssertEqual(mappedObject?.enumStringOptional, value) + XCTAssertEqual(mappedObject?.enumStringImplicitlyUnwrapped, value) } func testMappingEnumIntArrayToJSON(){ @@ -429,10 +428,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.arrayEnumInt.first).to(equal(value)) - expect(mappedObject?.arrayEnumIntOptional?.first).to(equal(value)) - expect(mappedObject?.arrayEnumIntImplicitlyUnwrapped?.first).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.arrayEnumInt.first, value) + XCTAssertEqual(mappedObject?.arrayEnumIntOptional?.first, value) + XCTAssertEqual(mappedObject?.arrayEnumIntImplicitlyUnwrapped.first, value) } func testMappingEnumIntDictionaryToJSON(){ @@ -446,10 +445,10 @@ class BasicTypesTestsToJSON: XCTestCase { let JSONString = Mapper().toJSONString(object, prettyPrint: true) let mappedObject = mapper.map(JSONString!) - expect(mappedObject).notTo(beNil()) - expect(mappedObject?.dictEnumInt[key]).to(equal(value)) - expect(mappedObject?.dictEnumIntOptional?[key]).to(equal(value)) - expect(mappedObject?.dictEnumIntImplicitlyUnwrapped?[key]).to(equal(value)) + XCTAssertNotNil(mappedObject) + XCTAssertEqual(mappedObject?.dictEnumInt[key], value) + XCTAssertEqual(mappedObject?.dictEnumIntOptional?[key], value) + XCTAssertEqual(mappedObject?.dictEnumIntImplicitlyUnwrapped[key], value) } func testObjectToModelDictionnaryOfPrimitives() { @@ -462,11 +461,11 @@ class BasicTypesTestsToJSON: XCTestCase { let json = Mapper().toJSON(object) - expect(json["dictStringString"] as? [String:String]).notTo(beEmpty()) - expect(json["dictStringBool"] as? [String:Bool]).notTo(beEmpty()) - expect(json["dictStringInt"] as? [String:Int]).notTo(beEmpty()) - expect(json["dictStringDouble"] as? [String:Double]).notTo(beEmpty()) - expect(json["dictStringFloat"] as? [String:Float]).notTo(beEmpty()) - expect(json["dictStringString"]?["string"]).to(equal("string")) + XCTAssertTrue((json["dictStringString"] as? [String:String])?.count > 0) + XCTAssertTrue((json["dictStringBool"] as? [String:Bool])?.count > 0) + XCTAssertTrue((json["dictStringInt"] as? [String:Int])?.count > 0) + XCTAssertTrue((json["dictStringDouble"] as? [String:Double])?.count > 0) + XCTAssertTrue((json["dictStringFloat"] as? [String:Float])?.count > 0) + XCTAssertEqual(json["dictStringString"]?["string"], "string") } } diff --git a/ObjectMapperTests/CustomTransformTests.swift b/ObjectMapperTests/CustomTransformTests.swift index 443ef2d5..2aa7aa6b 100644 --- a/ObjectMapperTests/CustomTransformTests.swift +++ b/ObjectMapperTests/CustomTransformTests.swift @@ -9,7 +9,6 @@ import Foundation import XCTest import ObjectMapper -import Nimble class CustomTransformTests: XCTestCase { @@ -32,9 +31,9 @@ class CustomTransformTests: XCTestCase { let JSON = mapper.toJSON(transforms) let parsedTransforms = mapper.map(JSON) - expect(parsedTransforms).notTo(beNil()) - expect(parsedTransforms?.date).to(equal(transforms.date)) - expect(parsedTransforms?.dateOpt).to(equal(transforms.dateOpt)) + XCTAssertNotNil(parsedTransforms) + XCTAssertEqual(parsedTransforms?.date, transforms.date) + XCTAssertEqual(parsedTransforms?.dateOpt, transforms.dateOpt) } func testISO8601DateTransform() { @@ -44,33 +43,33 @@ class CustomTransformTests: XCTestCase { let JSON = mapper.toJSON(transforms) let parsedTransforms = mapper.map(JSON) - expect(parsedTransforms).notTo(beNil()) - expect(parsedTransforms?.ISO8601Date).to(equal(transforms.ISO8601Date)) - expect(parsedTransforms?.ISO8601DateOpt).to(equal(transforms.ISO8601DateOpt)) + XCTAssertNotNil(parsedTransforms) + XCTAssertEqual(parsedTransforms?.ISO8601Date, transforms.ISO8601Date) + XCTAssertEqual(parsedTransforms?.ISO8601DateOpt, transforms.ISO8601DateOpt) } func testISO8601DateTransformWithInvalidInput() { var JSON: [String: AnyObject] = ["ISO8601Date": ""] let transforms = mapper.map(JSON) - expect(transforms?.ISO8601DateOpt).to(beNil()) + XCTAssertNil(transforms?.ISO8601DateOpt) JSON["ISO8601Date"] = "incorrect format" let transforms2 = mapper.map(JSON) - expect(transforms2?.ISO8601DateOpt).to(beNil()) + XCTAssertNil(transforms2?.ISO8601DateOpt) } func testCustomFormatDateTransform(){ let dateString = "2015-03-03T02:36:44" let JSON: [String: AnyObject] = ["customFormateDate": dateString] let transform: Transforms! = mapper.map(JSON) - expect(transform).notTo(beNil()) + XCTAssertNotNil(transform) let JSONOutput = mapper.toJSON(transform) - expect(JSONOutput["customFormateDate"] as? String).to(equal(dateString)) + XCTAssertEqual(JSONOutput["customFormateDate"] as? String, dateString) } func testIntToStringTransformOf() { @@ -78,7 +77,7 @@ class CustomTransformTests: XCTestCase { let JSON: [String: AnyObject] = ["intWithString": "\(intValue)"] let transforms = mapper.map(JSON) - expect(transforms?.intWithString).to(equal(intValue)) + XCTAssertEqual(transforms?.intWithString, intValue) } func testInt64MaxValue() { @@ -88,8 +87,8 @@ class CustomTransformTests: XCTestCase { let JSON = mapper.toJSON(transforms) let parsedTransforms = mapper.map(JSON) - expect(parsedTransforms).notTo(beNil()) - expect(parsedTransforms?.int64Value).to(equal(transforms.int64Value)) + XCTAssertNotNil(parsedTransforms) + XCTAssertEqual(parsedTransforms?.int64Value, transforms.int64Value) } func testURLTranform() { @@ -100,9 +99,10 @@ class CustomTransformTests: XCTestCase { let JSON = mapper.toJSON(transforms) let parsedTransforms = mapper.map(JSON) - expect(parsedTransforms).notTo(beNil()) - expect(parsedTransforms?.URL).to(equal(transforms.URL)) - expect(parsedTransforms?.URLOpt).to(equal(transforms.URLOpt)) + + XCTAssertNotNil(parsedTransforms) + XCTAssertEqual(parsedTransforms?.URL, transforms.URL) + XCTAssertEqual(parsedTransforms?.URLOpt, transforms.URLOpt) } func testEnumTransform() { @@ -110,8 +110,8 @@ class CustomTransformTests: XCTestCase { let transforms = mapper.map(JSON) let imageType = Transforms.ImageType.self - expect(transforms?.firstImageType).to(equal(imageType.Cover)) - expect(transforms?.secondImageType).to(equal(imageType.Thumbnail)) + XCTAssertEqual(transforms?.firstImageType, imageType.Cover) + XCTAssertEqual(transforms?.secondImageType, imageType.Thumbnail) } } diff --git a/ObjectMapperTests/NestedArrayTests.swift b/ObjectMapperTests/NestedArrayTests.swift index 3ab1774a..a32df6ce 100644 --- a/ObjectMapperTests/NestedArrayTests.swift +++ b/ObjectMapperTests/NestedArrayTests.swift @@ -9,7 +9,6 @@ import Foundation import XCTest import ObjectMapper -import Nimble class NestedArrayTests: XCTestCase { @@ -29,17 +28,15 @@ class NestedArrayTests: XCTestCase { let mapper = Mapper() let value: NestedArray! = mapper.map(JSON) - expect(value).notTo(beNil()) + XCTAssertNotNil(value) let JSONFromValue = mapper.toJSON(value) let valueFromParsedJSON: NestedArray! = mapper.map(JSONFromValue) - expect(valueFromParsedJSON).notTo(beNil()) - - expect(value.value_0).to(equal(valueFromParsedJSON.value_0)) - expect(value.value_1).to(equal(valueFromParsedJSON.value_1)) + XCTAssertNotNil(valueFromParsedJSON) + XCTAssertEqual(value.value_0, valueFromParsedJSON.value_0) + XCTAssertEqual(value.value_1, valueFromParsedJSON.value_1) } - } class NestedArray: Mappable { @@ -52,9 +49,7 @@ class NestedArray: Mappable { } func mapping(map: Map) { - value_0 <- map["nested.0.value"] value_1 <- map["nested.1.value"] - } } \ No newline at end of file diff --git a/ObjectMapperTests/NestedKeysTests.swift b/ObjectMapperTests/NestedKeysTests.swift index ee94ec45..b7c56c5e 100644 --- a/ObjectMapperTests/NestedKeysTests.swift +++ b/ObjectMapperTests/NestedKeysTests.swift @@ -9,7 +9,6 @@ import Foundation import XCTest import ObjectMapper -import Nimble class NestedKeysTests: XCTestCase { @@ -67,44 +66,44 @@ class NestedKeysTests: XCTestCase { let mapper = Mapper() let value: NestedKeys! = mapper.map(JSON) - expect(value).notTo(beNil()) + XCTAssertNotNil(value) let JSONFromValue = mapper.toJSON(value) let valueFromParsedJSON: NestedKeys! = mapper.map(JSONFromValue) - expect(valueFromParsedJSON).notTo(beNil()) + XCTAssertNotNil(valueFromParsedJSON) - expect(value.nonNestedString!).to(equal(valueFromParsedJSON.nonNestedString)) + XCTAssertEqual(value.nonNestedString, valueFromParsedJSON.nonNestedString) - expect(value.int64).to(equal(valueFromParsedJSON.int64)) - expect(value.bool).to(equal(valueFromParsedJSON.bool)) - expect(value.int).to(equal(valueFromParsedJSON.int)) - expect(value.double).to(equal(valueFromParsedJSON.double)) - expect(value.float).to(equal(valueFromParsedJSON.float)) - expect(value.string).to(equal(valueFromParsedJSON.string)) - - expect(value.int64Array).to(equal(valueFromParsedJSON.int64Array)) - expect(value.boolArray).to(equal(valueFromParsedJSON.boolArray)) - expect(value.intArray).to(equal(valueFromParsedJSON.intArray)) - expect(value.doubleArray).to(equal(valueFromParsedJSON.doubleArray)) - expect(value.floatArray).to(equal(valueFromParsedJSON.floatArray)) - expect(value.stringArray).to(equal(valueFromParsedJSON.stringArray)) - - expect(value.int64Dict).to(equal(valueFromParsedJSON.int64Dict)) - expect(value.boolDict).to(equal(valueFromParsedJSON.boolDict)) - expect(value.intDict).to(equal(valueFromParsedJSON.intDict)) - expect(value.doubleDict).to(equal(valueFromParsedJSON.doubleDict)) - expect(value.floatDict).to(equal(valueFromParsedJSON.floatDict)) - expect(value.stringDict).to(equal(valueFromParsedJSON.stringDict)) - - expect(value.int64Enum).to(equal(valueFromParsedJSON.int64Enum)) - expect(value.intEnum).to(equal(valueFromParsedJSON.intEnum)) - expect(value.doubleEnum).to(equal(valueFromParsedJSON.doubleEnum)) - expect(value.floatEnum).to(equal(valueFromParsedJSON.floatEnum)) - expect(value.stringEnum).to(equal(valueFromParsedJSON.stringEnum)) - - expect(value.object).to(equal(valueFromParsedJSON.object)) - expect(value.objectArray).to(equal(valueFromParsedJSON.objectArray)) - expect(value.objectDict).to(equal(valueFromParsedJSON.objectDict)) + XCTAssertEqual(value.int64, valueFromParsedJSON.int64) + XCTAssertEqual(value.bool, valueFromParsedJSON.bool) + XCTAssertEqual(value.int, valueFromParsedJSON.int) + XCTAssertEqual(value.double, valueFromParsedJSON.double) + XCTAssertEqual(value.float, valueFromParsedJSON.float) + XCTAssertEqual(value.string, valueFromParsedJSON.string) + + XCTAssertEqual(value.int64Array, valueFromParsedJSON.int64Array) + XCTAssertEqual(value.boolArray, valueFromParsedJSON.boolArray) + XCTAssertEqual(value.intArray, valueFromParsedJSON.intArray) + XCTAssertEqual(value.doubleArray, valueFromParsedJSON.doubleArray) + XCTAssertEqual(value.floatArray, valueFromParsedJSON.floatArray) + XCTAssertEqual(value.stringArray, valueFromParsedJSON.stringArray) + + XCTAssertEqual(value.int64Dict, valueFromParsedJSON.int64Dict) + XCTAssertEqual(value.boolDict, valueFromParsedJSON.boolDict) + XCTAssertEqual(value.intDict, valueFromParsedJSON.intDict) + XCTAssertEqual(value.doubleDict, valueFromParsedJSON.doubleDict) + XCTAssertEqual(value.floatDict, valueFromParsedJSON.floatDict) + XCTAssertEqual(value.stringDict, valueFromParsedJSON.stringDict) + + XCTAssertEqual(value.int64Enum, valueFromParsedJSON.int64Enum) + XCTAssertEqual(value.intEnum, valueFromParsedJSON.intEnum) + XCTAssertEqual(value.doubleEnum, valueFromParsedJSON.doubleEnum) + XCTAssertEqual(value.floatEnum, valueFromParsedJSON.floatEnum) + XCTAssertEqual(value.stringEnum, valueFromParsedJSON.stringEnum) + + XCTAssertEqual(value.object, valueFromParsedJSON.object) + XCTAssertEqual(value.objectArray, valueFromParsedJSON.objectArray) + XCTAssertEqual(value.objectDict, valueFromParsedJSON.objectDict) } } diff --git a/ObjectMapperTests/ObjectMapperTests.swift b/ObjectMapperTests/ObjectMapperTests.swift index feaf514a..3ecbe865 100644 --- a/ObjectMapperTests/ObjectMapperTests.swift +++ b/ObjectMapperTests/ObjectMapperTests.swift @@ -9,7 +9,6 @@ import Foundation import XCTest import ObjectMapper -import Nimble class ObjectMapperTests: XCTestCase { @@ -41,17 +40,17 @@ class ObjectMapperTests: XCTestCase { let user = userMapper.map(userJSONString)! - expect(user).notTo(beNil()) - expect(username).to(equal(user.username)) - expect(identifier).to(equal(user.identifier)) - expect(photoCount).to(equal(user.photoCount)) - expect(age).to(equal(user.age)) - expect(weight).to(equal(user.weight)) - expect(float).to(equal(user.float)) - expect(drinker).to(equal(user.drinker)) - expect(smoker).to(equal(user.smoker)) - expect(sex).to(equal(user.sex)) - + XCTAssertNotNil(user) + XCTAssertEqual(username, user.username) + XCTAssertEqual(identifier, user.identifier) + XCTAssertEqual(photoCount, user.photoCount) + XCTAssertEqual(age, user.age) + XCTAssertEqual(weight, user.weight) + XCTAssertEqual(float, user.float) + XCTAssertEqual(drinker, user.drinker) + XCTAssertEqual(smoker, user.smoker) + XCTAssertEqual(sex, user.sex) + //print(Mapper().toJSONString(user, prettyPrint: true)) } @@ -71,16 +70,16 @@ class ObjectMapperTests: XCTestCase { let user = userMapper.map(userJSONString)! - expect(user).notTo(beNil()) - expect(username).to(equal(user.username)) - expect(identifier).to(equal(user.identifier)) - expect(photoCount).to(equal(user.photoCount)) - expect(age).to(equal(user.age)) - expect(weight).to(equal(user.weight)) - expect(float).to(equal(user.float)) - expect(drinker).to(equal(user.drinker)) - expect(smoker).to(equal(user.smoker)) - expect(sex).to(equal(user.sex)) + XCTAssertNotNil(user) + XCTAssertEqual(username, user.username) + XCTAssertEqual(identifier, user.identifier) + XCTAssertEqual(photoCount, user.photoCount) + XCTAssertEqual(age, user.age) + XCTAssertEqual(weight, user.weight) + XCTAssertEqual(float, user.float) + XCTAssertEqual(drinker, user.drinker) + XCTAssertEqual(smoker, user.smoker) + XCTAssertEqual(sex, user.sex) } func testInstanceParsing() { @@ -99,15 +98,15 @@ class ObjectMapperTests: XCTestCase { let user = Mapper().map(userJSONString, toObject: User()) - expect(username).to(equal(user.username)) - expect(identifier).to(equal(user.identifier)) - expect(photoCount).to(equal(user.photoCount)) - expect(age).to(equal(user.age)) - expect(weight).to(equal(user.weight)) - expect(float).to(equal(user.float)) - expect(drinker).to(equal(user.drinker)) - expect(smoker).to(equal(user.smoker)) - expect(sex).to(equal(user.sex)) + XCTAssertEqual(username, user.username) + XCTAssertEqual(identifier, user.identifier) + XCTAssertEqual(photoCount, user.photoCount) + XCTAssertEqual(age, user.age) + XCTAssertEqual(weight, user.weight) + XCTAssertEqual(float, user.float) + XCTAssertEqual(drinker, user.drinker) + XCTAssertEqual(smoker, user.smoker) + XCTAssertEqual(sex, user.sex) //print(Mapper().toJSONString(user, prettyPrint: true)) } @@ -124,10 +123,10 @@ class ObjectMapperTests: XCTestCase { s.minor = minor let student = Mapper().map(json, toObject: s) - expect(student.name).to(equal(name)) - expect(student.UUID).to(equal(UUID)) - expect(student.major).to(equal(major)) - expect(student.minor).to(equal(minor)) + XCTAssertEqual(name, student.name) + XCTAssertEqual(UUID, student.UUID) + XCTAssertEqual(major, student.major) + XCTAssertEqual(minor, student.minor) //Test that mapping a reference type works as expected while not relying on the return value let username: String = "Barack Obama" @@ -137,17 +136,19 @@ class ObjectMapperTests: XCTestCase { let json2: [String: AnyObject] = ["username": username, "identifier": identifier, "photoCount": photoCount] let user = User() Mapper().map(json2, toObject: user) - expect(user.username).to(equal(username)) - expect(user.identifier).to(equal(identifier)) - expect(user.photoCount).to(equal(photoCount)) + + XCTAssertEqual(username, user.username) + XCTAssertEqual(identifier, user.identifier) + XCTAssertEqual(photoCount, user.photoCount) } func testNullObject() { let JSONString = "{\"username\":\"bob\"}" let user = userMapper.map(JSONString) - expect(user).notTo(beNil()) - expect(user?.age).to(beNil()) + + XCTAssertNotNil(user) + XCTAssertNil(user?.age) } func testToObjectFromString() { @@ -159,7 +160,7 @@ class ObjectMapperTests: XCTestCase { Mapper().map(JSONString, toObject: user) - expect(user.username).to(equal(username)) + XCTAssertEqual(user.username, username) } func testToObjectFromJSON() { @@ -171,7 +172,7 @@ class ObjectMapperTests: XCTestCase { Mapper().map(JSON, toObject: user) - expect(user.username).to(equal(username)) + XCTAssertEqual(username, user.username) } func testToObjectFromAnyObject() { @@ -183,7 +184,7 @@ class ObjectMapperTests: XCTestCase { Mapper().map(userJSON as AnyObject?, toObject: user) - expect(user.username).to(equal(username)) + XCTAssertEqual(user.username, username) } func testToJSONAndBack(){ @@ -202,14 +203,15 @@ class ObjectMapperTests: XCTestCase { //print(JSONString) let parsedUser = userMapper.map(JSONString!)! - expect(parsedUser).notTo(beNil()) - expect(user.identifier).to(equal(parsedUser.identifier)) - expect(user.photoCount).to(equal(parsedUser.photoCount)) - expect(user.age).to(equal(parsedUser.age)) - expect(user.weight).to(equal(parsedUser.weight)) - expect(user.drinker).to(equal(parsedUser.drinker)) - expect(user.smoker).to(equal(parsedUser.smoker)) - expect(user.sex).to(equal(parsedUser.sex)) + + XCTAssertNotNil(parsedUser) + XCTAssertEqual(user.identifier, parsedUser.identifier) + XCTAssertEqual(user.photoCount, parsedUser.photoCount) + XCTAssertEqual(user.age, parsedUser.age) + XCTAssertEqual(user.weight, parsedUser.weight) + XCTAssertEqual(user.drinker, parsedUser.drinker) + XCTAssertEqual(user.smoker, parsedUser.smoker) + XCTAssertEqual(user.sex, parsedUser.sex) } func testUnknownPropertiesIgnored() { @@ -217,7 +219,7 @@ class ObjectMapperTests: XCTestCase { let user = userMapper.map(JSONString) - expect(user).notTo(beNil()) + XCTAssertNotNil(user) } func testInvalidJsonResultsInNilObject() { @@ -225,7 +227,7 @@ class ObjectMapperTests: XCTestCase { let user = userMapper.map(JSONString) - expect(user).to(beNil()) + XCTAssertNil(user) } func testMapArrayJSON(){ @@ -236,10 +238,10 @@ class ObjectMapperTests: XCTestCase { let students = Mapper().mapArray(JSONString) - expect(students).notTo(beEmpty()) - expect(students?.count).to(equal(2)) - expect(students?[0].name).to(equal(name1)) - expect(students?[1].name).to(equal(name2)) + XCTAssertTrue(students?.count > 0) + XCTAssertTrue(students?.count == 2) + XCTAssertEqual(students?[0].name, name1) + XCTAssertEqual(students?[1].name, name2) } // test mapArray() with JSON string that is not an array form @@ -251,9 +253,9 @@ class ObjectMapperTests: XCTestCase { let students = Mapper().mapArray(JSONString) - expect(students).notTo(beEmpty()) - expect(students?.count).to(equal(1)) - expect(students?[0].name).to(equal(name1)) + XCTAssertTrue(students?.count > 0) + XCTAssertTrue(students?.count == 1) + XCTAssertEqual(students?[0].name, name1) } func testMapArrayJSONWithEmptyArray() { @@ -261,8 +263,8 @@ class ObjectMapperTests: XCTestCase { let students = Mapper().mapArray(JSONString) - expect(students).to(beEmpty()) - expect(students?.count).to(equal(0)) + XCTAssertNotNil(students) + XCTAssertTrue(students?.count == 0) } func testArrayOfCustomObjects(){ @@ -274,9 +276,10 @@ class ObjectMapperTests: XCTestCase { let plan = Mapper().map(JSONString) let tasks = plan?.tasks - expect(tasks).notTo(beNil()) - expect(tasks?[0].percentage).to(equal(percentage1)) - expect(tasks?[1].percentage).to(equal(percentage2)) + + XCTAssertNotNil(tasks) + XCTAssertEqual(tasks?[0].percentage, percentage1) + XCTAssertEqual(tasks?[1].percentage, percentage2) } func testDictionaryOfArrayOfCustomObjects(){ @@ -288,18 +291,18 @@ class ObjectMapperTests: XCTestCase { let plan = Mapper().map(JSONString) let dictionaryOfTasks = plan?.dictionaryOfTasks - expect(dictionaryOfTasks).notTo(beNil()) - expect(dictionaryOfTasks?["mondayTasks"]?[0].percentage).to(equal(percentage1)) - expect(dictionaryOfTasks?["mondayTasks"]?[1].percentage).to(equal(percentage2)) + XCTAssertNotNil(dictionaryOfTasks) + XCTAssertEqual(dictionaryOfTasks?["mondayTasks"]?[0].percentage, percentage1) + XCTAssertEqual(dictionaryOfTasks?["mondayTasks"]?[1].percentage, percentage2) let planToJSON = Mapper().toJSONString(plan!, prettyPrint: true) //print(planToJSON!) let planFromJSON = Mapper().map(planToJSON!) let dictionaryOfTasks2 = planFromJSON?.dictionaryOfTasks - expect(dictionaryOfTasks2).notTo(beNil()) - expect(dictionaryOfTasks2?["mondayTasks"]?[0].percentage).to(equal(percentage1)) - expect(dictionaryOfTasks2?["mondayTasks"]?[1].percentage).to(equal(percentage2)) + XCTAssertNotNil(dictionaryOfTasks2) + XCTAssertEqual(dictionaryOfTasks2?["mondayTasks"]?[0].percentage, percentage1) + XCTAssertEqual(dictionaryOfTasks2?["mondayTasks"]?[1].percentage, percentage2) } func testArrayOfEnumObjects(){ @@ -311,11 +314,12 @@ class ObjectMapperTests: XCTestCase { let enumArray = Mapper().map(JSONString) let enums = enumArray?.enums - expect(enums).notTo(beNil()) - expect(enums?.count).to(equal(3)) - expect(enums?[0]).to(equal(a)) - expect(enums?[1]).to(equal(b)) - expect(enums?[2]).to(equal(c)) + + XCTAssertNotNil(enums) + XCTAssertTrue(enums?.count == 3) + XCTAssertEqual(enums?[0], a) + XCTAssertEqual(enums?[1], b) + XCTAssertEqual(enums?[2], c) } func testDictionaryOfCustomObjects(){ @@ -327,8 +331,8 @@ class ObjectMapperTests: XCTestCase { let taskDict = Mapper().map(JSONString) let task = taskDict?.tasks?["task1"] - expect(task).notTo(beNil()) - expect(task?.percentage).to(equal(percentage1)) + XCTAssertNotNil(task) + XCTAssertEqual(task?.percentage, percentage1) } func testDictionryOfEnumObjects(){ @@ -340,8 +344,9 @@ class ObjectMapperTests: XCTestCase { let enumDict = Mapper().map(JSONString) let enums = enumDict?.enums - expect(enums).notTo(beNil()) - expect(enums?.count).to(equal(3)) + + XCTAssertNotNil(enums) + XCTAssertTrue(enums?.count == 3) } func testDoubleParsing(){ @@ -351,8 +356,8 @@ class ObjectMapperTests: XCTestCase { let task = Mapper().map(JSONString) - expect(task).notTo(beNil()) - expect(task?.percentage).to(equal(percentage1)) + XCTAssertNotNil(task) + XCTAssertEqual(task?.percentage, percentage1) } func testMappingAGenericObject(){ @@ -362,8 +367,9 @@ class ObjectMapperTests: XCTestCase { let response = Mapper>().map(JSONString) let status = response?.result?.status - expect(status).notTo(beNil()) - expect(status).to(equal(code)) + + XCTAssertNotNil(status) + XCTAssertEqual(status, code) } func testToJSONArray(){ @@ -384,20 +390,20 @@ class ObjectMapperTests: XCTestCase { let taskId1 = JSONArray[0]["taskId"] as? Int let percentage1 = JSONArray[0]["percentage"] as? Double - expect(taskId1).to(equal(task1.taskId)) - expect(percentage1).to(equal(task1.percentage)) + XCTAssertEqual(taskId1, task1.taskId) + XCTAssertEqual(percentage1, task1.percentage) let taskId2 = JSONArray[1]["taskId"] as? Int let percentage2 = JSONArray[1]["percentage"] as? Double - expect(taskId2).to(equal(task2.taskId)) - expect(percentage2).to(equal(task2.percentage)) + XCTAssertEqual(taskId2, task2.taskId) + XCTAssertEqual(percentage2, task2.percentage) let taskId3 = JSONArray[2]["taskId"] as? Int let percentage3 = JSONArray[2]["percentage"] as? Double - expect(taskId3).to(equal(task3.taskId)) - expect(percentage3).to(equal(task3.percentage)) + XCTAssertEqual(taskId3, task3.taskId) + XCTAssertEqual(percentage3, task3.percentage) } func testSubclass() { @@ -408,8 +414,8 @@ class ObjectMapperTests: XCTestCase { let json = Mapper().toJSON(object) let parsedObject = Mapper().map(json) - expect(object.base).to(equal(parsedObject?.base)) - expect(object.sub).to(equal(parsedObject?.sub)) + XCTAssertEqual(object.base, parsedObject?.base) + XCTAssertEqual(object.sub, parsedObject?.sub) } func testGenericSubclass() { @@ -420,8 +426,8 @@ class ObjectMapperTests: XCTestCase { let json = Mapper().toJSON(object) let parsedObject = Mapper>().map(json) - expect(object.base).to(equal(parsedObject?.base)) - expect(object.sub).to(equal(parsedObject?.sub)) + XCTAssertEqual(object.base, parsedObject?.base) + XCTAssertEqual(object.sub, parsedObject?.sub) } func testSubclassWithGenericArrayInSuperclass() { @@ -430,9 +436,10 @@ class ObjectMapperTests: XCTestCase { let parsedObject = Mapper>().map(JSONString) let genericItems = parsedObject?.genericItems - expect(genericItems).notTo(beNil()) - expect(genericItems?[0].value).to(equal("value0")) - expect(genericItems?[1].value).to(equal("value1")) + + XCTAssertNotNil(genericItems) + XCTAssertEqual(genericItems?[0].value, "value0") + XCTAssertEqual(genericItems?[1].value, "value1") } func testImmutableMappable() { @@ -440,18 +447,18 @@ class ObjectMapperTests: XCTestCase { let JSON = ["prop1": "Immutable!", "prop2": 255, "prop3": true ] let immutable: Immutable! = mapper.map(JSON) - expect(immutable).notTo(beNil()) - expect(immutable?.prop1).to(equal("Immutable!")) - expect(immutable?.prop2).to(equal(255)) - expect(immutable?.prop3).to(equal(true)) - expect(immutable?.prop4).to(equal(DBL_MAX)) + XCTAssertNotNil(immutable) + XCTAssertEqual(immutable.prop1, "Immutable!") + XCTAssertEqual(immutable.prop2, 255) + XCTAssertEqual(immutable.prop3, true) + XCTAssertEqual(immutable.prop4, DBL_MAX) let JSON2 = [ "prop1": "prop1", "prop2": NSNull() ] let immutable2 = mapper.map(JSON2) - expect(immutable2).to(beNil()) + XCTAssertNil(immutable2) let JSONFromObject = mapper.toJSON(immutable) - expect(mapper.map(JSONFromObject)).to(equal(immutable)) + XCTAssertEqual(mapper.map(JSONFromObject), immutable) } func testArrayOfArrayOfMappable() { @@ -465,22 +472,23 @@ class ObjectMapperTests: XCTestCase { let JSON = ["twoDimensionalArray":[array1, array2]] let arrayTest = Mapper().map(JSON) - expect(arrayTest).notTo(beNil()) - expect(arrayTest?.twoDimensionalArray?[0][0].base).to(equal(base1)) - expect(arrayTest?.twoDimensionalArray?[0][1].base).to(equal(base2)) - expect(arrayTest?.twoDimensionalArray?[0][2].base).to(equal(base3)) - expect(arrayTest?.twoDimensionalArray?[1][0].base).to(equal(base4)) - expect(arrayTest?.twoDimensionalArray?[0].count).to(equal(array1.count)) - expect(arrayTest?.twoDimensionalArray?[1].count).to(equal(array2.count)) + XCTAssertNotNil(arrayTest) + XCTAssertEqual(arrayTest?.twoDimensionalArray?[0][0].base, base1) + XCTAssertEqual(arrayTest?.twoDimensionalArray?[0][1].base, base2) + XCTAssertEqual(arrayTest?.twoDimensionalArray?[0][2].base, base3) + XCTAssertEqual(arrayTest?.twoDimensionalArray?[1][0].base, base4) + + XCTAssertEqual(arrayTest?.twoDimensionalArray?[0].count, array1.count) + XCTAssertEqual(arrayTest?.twoDimensionalArray?[1].count, array2.count) let backToJSON = Mapper().toJSON(arrayTest!) - expect(backToJSON).notTo(beNil()) + XCTAssertNotNil(backToJSON) let arrayTest2 = Mapper().map(backToJSON) - expect(arrayTest2).notTo(beNil()) - expect(arrayTest2?.twoDimensionalArray?[0][0].base).to(equal(arrayTest?.twoDimensionalArray?[0][0].base)) - expect(arrayTest2?.twoDimensionalArray?[0][1].base).to(equal(arrayTest?.twoDimensionalArray?[0][1].base)) + XCTAssertNotNil(arrayTest2) + XCTAssertEqual(arrayTest2?.twoDimensionalArray?[0][0].base, arrayTest?.twoDimensionalArray?[0][0].base) + XCTAssertEqual(arrayTest2?.twoDimensionalArray?[0][1].base, arrayTest?.twoDimensionalArray?[0][1].base) } }