         let subUserJSON = "{\"identifier\" : \"user8723\", \"drinker\" : true, \"age\": 17, \"username\" : \"sub user\" }"
         
         let userJSONString = "{\"username\":\"\(username)\",\"identifier\":\"\(identifier)\",\"photoCount\":\(photoCount),\"age\":\(age),\"drinker\":\(drinker),\"smoker\":\(smoker), \"arr\":[ \"bla\", true, 42 ], \"dict\":{ \"key1\" : \"value1\", \"key2\" : false, \"key3\" : 142 }, \"arrOpt\":[ \"bla\", true, 42 ], \"dictOpt\":{ \"key1\" : \"value1\", \"key2\" : false, \"key3\" : 142 }, \"weight\": \(weight), \"float\": \(float), \"friend\": \(subUserJSON), \"friendDictionary\":{ \"bestFriend\": \(subUserJSON)}}"
-		
-		if let user = userMapper.map(string: userJSONString) {
-			XCTAssertEqual(username, user.username, "Username should be the same")
-			XCTAssertEqual(identifier, user.identifier!, "Identifier should be the same")
-			XCTAssertEqual(photoCount, user.photoCount, "PhotoCount should be the same")
-			XCTAssertEqual(age, user.age!, "Age should be the same")
-			XCTAssertEqual(weight, user.weight!, "Weight should be the same")
-			XCTAssertEqual(float, user.float!, "float should be the same")
-			XCTAssertEqual(drinker, user.drinker, "Drinker should be the same")
-			XCTAssertEqual(smoker, user.smoker!, "Smoker should be the same")
-
-			//println(Mapper().toJSONString(user, prettyPrint: true))
-		} else {
-			XCTAssert(false, "Mapping user object failed")
-		}
-    }
-	
+
+		let user = userMapper.map(string: 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))
+
+		//println(Mapper().toJSONString(user, prettyPrint: true))
+    }
+
     func testInstanceParsing() {
         let username = "John Doe"
         let identifier = "user8723"

		let JSON = "{\"tasks\": { \"task1\": {\"taskId\":103,\"percentage\":\(percentage1)}, \"task2\": {\"taskId\":108,\"percentage\":\(percentage2)}}}"
		
		let taskDict = Mapper<TaskDictionary>().map(string: JSON)
		if let task = taskDict?.tasks?["task1"] {
			XCTAssertEqual(task.percentage!, percentage1, "Percentage 1 should be the same")
		} else {
			XCTAssert(false, "Dictionary not mapped")
		}
	}
	
	func testDoubleParsing(){

        
        let jsonString = Mapper().toJSONString(user, prettyPrint: true)
        println(jsonString)

		let parsedUser = userMapper.map(string: 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))
    }

    func testUnknownPropertiesIgnored() {
        let userJSONString = "{\"username\":\"bob\",\"identifier\":\"bob1987\", \"foo\" : \"bar\", \"fooArr\" : [ 1, 2, 3], \"fooObj\" : { \"baz\" : \"qux\" } }"
		let user = userMapper.map(string: userJSONString)

		expect(user).notTo(beNil())
    }
    
    func testInvalidJsonResultsInNilObject() {
        let userJSONString = "{\"username\":\"bob\",\"identifier\":\"bob1987\"" // missing ending brace

        let user = userMapper.map(string: userJSONString)

		expect(user).to(beNil())
    }
	
	func testMapArrayJSON(){
