我想测试两个Swift enum值的相等性。例如:
enum SimpleToken {
case Name(String)
case Number(Int)
}
let t1 = SimpleToken.Number(123)
let t2 = SimpleToken.Number(123)
XCTAssert(t1 == t2)
但是，编译器不会编译等式表达式:
error: could not find an overload for '==' that accepts the supplied arguments
XCTAssert(t1 == t2)
^~~~~~~~~~~~~~~~~~~
我需要自己定义重载的相等运算符吗?我希望Swift编译器能自动处理它，就像Scala和Ocaml那样。
当前回答
在我看来，实现Equatable有点过头了。想象你有一个复杂的大枚举，有很多case和不同的参数。这些参数也都必须实现Equatable。此外，谁说你在全有或全无的基础上比较枚举案例?如果您正在测试值，并且只存根了一个特定的enum参数怎么办?我强烈建议简单的方法，比如:
if case .NotRecognized = error {
// Success
} else {
XCTFail("wrong error")
}
…或者对于参数求值:
if case .Unauthorized401(_, let response, _) = networkError {
XCTAssertEqual(response.statusCode, 401)
} else {
XCTFail("Unauthorized401 was expected")
}
在这里找到更详细的描述:https://mdcdeveloper.wordpress.com/2016/12/16/unit-testing-swift-enums/
其他回答
你可以用switch来比较
enum SimpleToken {
case Name(String)
case Number(Int)
}
let t1 = SimpleToken.Number(123)
let t2 = SimpleToken.Number(123)
switch(t1) {
case let .Number(a):
switch(t2) {
case let . Number(b):
if a == b
{
println("Equal")
}
default:
println("Not equal")
}
default:
println("No Match")
}
t1和t2不是数字，它们是带有关联值的simpletoken实例。
你可以说
var t1 = SimpleToken.Number(123)
你可以说
t1 = SimpleToken.Name(“Smith”)
没有编译器错误。
要从t1中检索值，使用switch语句:
switch t1 {
case let .Number(numValue):
println("Number: \(numValue)")
case let .Name(strValue):
println("Name: \(strValue)")
}
enum MyEnum {
case none
case simple(text: String)
case advanced(x: Int, y: Int)
}
func ==(lhs: MyEnum, rhs: MyEnum) -> Bool {
switch (lhs, rhs) {
case (.none, .none):
return true
case let (.simple(v0), .simple(v1)):
return v0 == v1
case let (.advanced(x0, y0), .advanced(x1, y1)):
return x0 == x1 && y0 == y1
default:
return false
}
}
我在单元测试代码中使用这个简单的解决方法:
extension SimpleToken: Equatable {}
func ==(lhs: SimpleToken, rhs: SimpleToken) -> Bool {
return String(stringInterpolationSegment: lhs) == String(stringInterpolationSegment: rhs)
}
它使用字符串插值来执行比较。我不建议在生产代码中使用它，但是它很简洁，并且可以用于单元测试。
这是另一个选择。除了使用if大小写语法避免了嵌套的switch语句外，它主要与其他的相同。我认为这使它更具可读性(/可接受性)，并具有完全避免默认情况的优点。
enum SimpleToken: Equatable {
case Name(String)
case Number(Int)
}
extension SimpleToken {
func isEqual(st: SimpleToken)->Bool {
switch self {
case .Name(let v1):
if case .Name(let v2) = st where v1 == v2 { return true }
case .Number(let i1):
if case .Number(let i2) = st where i1 == i2 { return true }
}
return false
}
}
func ==(lhs: SimpleToken, rhs: SimpleToken)->Bool {
return lhs.isEqual(rhs)
}
let t1 = SimpleToken.Number(1)
let t2 = SimpleToken.Number(2)
let t3 = SimpleToken.Name("a")
let t4 = SimpleToken.Name("b")
t1 == t1 // true
t1 == t2 // false
t3 == t3 // true
t3 == t4 // false
t1 == t3 // false
