enum_equatable_hashable_correctness.swift

// RUN: %target-run-simple-swift
// RUN: %target-run-simple-swift(-Xfrontend -unavailable-decl-optimization=complete)
// REQUIRES: executable_test

import StdlibUnittest

enumToken:Hashable{
case string(String)
case number(Int)
case comma
case colon
}

enumCombo<T:Hashable, U:Hashable>:Hashable{
case none
case first(T)
case second(U)
case both(T,U)
}

@available(*, unavailable)
structUnavailableStruct:Hashable{}

enumHasUnavailableCases:Hashable{
case available
case availablePayload(Int)

@available(*, unavailable)
case unavailable

@available(*, unavailable)
case unavailablePayload(UnavailableStruct)
}

enumAllUnavailableCases:Hashable{
@available(*, unavailable)
case nope
}

varEnumSynthesisTests=TestSuite("EnumSynthesis")

EnumSynthesisTests.test("BasicEquatability/Hashability"){
checkHashable([
Token.string("foo"),
Token.number(10),
Token.comma,
Token.colon,
], equalityOracle:{ $0 == $1 })
}

// Not guaranteed by the semantics of Hashable, but we soundness check that the
// synthesized hash function is good enough to not let nearby values collide.
EnumSynthesisTests.test("CloseValuesDoNotCollide"){
expectNotEqual(Token.string("foo").hashValue,Token.string("goo").hashValue)
expectNotEqual(Token.number(10).hashValue,Token.number(11).hashValue)
}

EnumSynthesisTests.test("GenericEquatability/Hashability"){
checkHashable([
Combo<String,Int>.none,
Combo<String,Int>.first("a"),
Combo<String,Int>.second(5),
Combo<String,Int>.both("foo",5),
], equalityOracle:{ $0 == $1 })
}

EnumSynthesisTests.test("CloseGenericValuesDoNotCollide"){
expectNotEqual(Combo<String,Int>.first("foo").hashValue,Combo<String,Int>.first("goo").hashValue)
expectNotEqual(Combo<String,Int>.second(3).hashValue,Combo<String,Int>.second(4).hashValue)
expectNotEqual(Combo<String,Int>.both("foo",3).hashValue,Combo<String,Int>.both("goo",3).hashValue)
expectNotEqual(Combo<String,Int>.both("foo",3).hashValue,Combo<String,Int>.both("foo",4).hashValue)
expectNotEqual(Combo<String,Int>.both("foo",3).hashValue,Combo<String,Int>.both("goo",4).hashValue)
}

EnumSynthesisTests.test("HasUnavailableCasesEquatability/Hashability"){
checkHashable([
HasUnavailableCases.available,
HasUnavailableCases.availablePayload(2),
], equalityOracle:{ $0 == $1 })
}

func hashEncode(_ body:(inoutHasher)->())->Int{
varhasher=Hasher()
body(&hasher)
return hasher.finalize()
}

// Make sure that if the user overrides the synthesized member, that one gets
// used instead.
enumOverrides:Hashable{
case a(Int), b(String)
varhashValue:Int{return2}
func hash(into hasher:inoutHasher){
 hasher.combine(2)
}
staticfunc==(lhs:Overrides, rhs:Overrides)->Bool{returntrue}
}

EnumSynthesisTests.test("ExplicitOverridesSynthesized"){
checkHashable(expectedEqual:true,Overrides.a(4),.b("foo"))
expectEqual(Overrides.a(4).hashValue,2)
expectEqual(
hashEncode{ $0.combine(Overrides.a(4))},
hashEncode{ $0.combine(2)})
}

// ...even in an extension.
enumOverridesInExtension:Hashable{
case a(Int), b(String)
}
extensionOverridesInExtension{
varhashValue:Int{return2}
func hash(into hasher:inoutHasher){
 hasher.combine(2)
}
staticfunc==(lhs:OverridesInExtension, rhs:OverridesInExtension)->Bool{returntrue}
}

EnumSynthesisTests.test("ExplicitOverridesSynthesizedInExtension"){
checkHashable(expectedEqual:true,OverridesInExtension.a(4),.b("foo"))
expectEqual(OverridesInExtension.a(4).hashValue,2)
expectEqual(
hashEncode{ $0.combine(OverridesInExtension.a(4))},
hashEncode{ $0.combine(2)})
}

// Try an indirect enum.
enumBinaryTree<Element:Hashable>:Hashable{
indirectcase tree(BinaryTree,BinaryTree)
case leaf(Element)
}

EnumSynthesisTests.test("IndirectEquatability/Hashability"){
letone= BinaryTree<Int>.tree(.leaf(10),.leaf(20))
lettwo= BinaryTree<Int>.tree(.leaf(10),.leaf(30))
letthree= BinaryTree<Int>.tree(.leaf(15),.leaf(20))
letfour= BinaryTree<Int>.tree(.leaf(15),.leaf(30))
checkHashable([one, two, three, four], equalityOracle:{ $0 == $1 })
}

runAllTests()