比较 Swift 单元测试中的字符串

Question

How do you test whether two Strings are equal in a Swift unit test? I've tried the == operator but it doesn't recognize it:

import XCTest
@testable import MyProject

class MyProject: XCTestCase {

override func setUp() {
    super.setUp()
    // Put setup code here. This method is called before the invocation of each test method in the class.
}

override func tearDown() {
    // Put teardown code here. This method is called after the invocation of each test method in the class.
    super.tearDown()
}

func testExample() {
    // This is an example of a functional test case.
    // Use XCTAssert and related functions to verify your tests produce the correct results.
    XCTAssertNil(nil, "This test works")
}

func toJSONTest() {
    let currentLocation = deviceLocation(timestamp: "2015-11-02 16:32:15 +0000",latitude: "40.2736577695212",longitude: "-111.715408331498")
    var MyProjectStatuses = [MyProjectStatus(id: "", currentLocation: currentLocation)]
    let json = ""
    XCTAssertTrue(json == "")
}

func testPerformanceExample() {
    // This is an example of a performance test case.
    self.measureBlock {
        // Put the code you want to measure the time of here.
    }
}

}

And the actual method being tested from MyProject.swift:

func toJSON ()->String{
    var json = ""
    json = "{\"myproject_status\":"
    json = json + "{\"id\":\"" + self.Id + "\""
    return json 
}

This part:

XCTAssertTrue(json == "")

Throws:

Operator is not a known binary operator

Answer 1

The problem is that toJSONTest is not a test. Change the name to testToJSON .

This works fine on my machine:

func testToJSON() {
    let json = ""
    XCTAssertTrue(json == "")
}

The test runs, and passes. However, I would probably write it like this:

func testToJSON() {
    let json = ""
    XCTAssertEqual(json, "", "They are not equal")
}

Answer 2

Although this question is explicitly about how to compare two Strings in a Swift unit test, what's implicit in the question is how to compare two JSON Strings. I just wanted to point out that the right thing to do when comparing two JSON strings is to parse the JSON Strings to a Foundation object with the JSONSerialization class and then to compare the resulting Foundation objects. This approach takes care of the problem of the two JSON Strings having slightly different formatting or fields in a different order. So, for example, it's important that "{\\"a\\":1,\\"b\\":2}" and "{\\"b\\":2,\\"a\\":1}" are deemed to be equal because they are logically equal.

Here's a Swift function I put together which helps with this comparison:

class JSONAssert {

    class func assertEquals(expected: String, actual: String) {
    
        let expectedData = Data(expected.utf8)
        let actualData = Data(actual.utf8)
    
        let expectedObject: Any
        let actualObject: Any
    
        do {
            expectedObject = try JSONSerialization.jsonObject(with: expectedData, options: [])
        } catch {
            XCTFail("Failed constructing a Foundation object from `expected` (i.e. \(expected)): \(error)")
            return
        }
    
        do {
            actualObject = try JSONSerialization.jsonObject(with: actualData, options: [])
        } catch {
            XCTFail("Failed constructing a Foundation object from `actual` (i.e. \(actual)): \(error)")
            return
        }
    
        guard let expectedDictionary = expectedObject as? NSDictionary else {
            XCTFail("Failed casting expected object (i.e. \(expectedObject)) to an NSDictionary")
            return
        }
    
        guard let actualDictionary = actualObject as? NSDictionary else {
            XCTFail("Failed casting actual object (i.e. \(actualObject)) to an NSDictionary")
            return
        }
    
        XCTAssertEqual(expectedDictionary, actualDictionary)
    }
}