// RUN: %target-run-simple-swiftgyb
// REQUIRES: executable_test

// FIXME(id-as-any): make Swift errors boxed in NSError eagerly bridged.

// FIXME(id-as-any): add tests for unboxing.

// FIXME(id-as-any): add tests for the _ObjectiveCBridgeable conformance.

%{
import re

class SwiftClass(object):
  def __init__(self, full_name):
    m = re.match(r'([A-Za-z0-9_]+)(<(.+)>)?', full_name)
    self.type_name = m.group(1)
    if m.group(3) is not None:
      self.generic_parameters_list = [m.group(3)]
    else:
      self.generic_parameters_list = []

  @property
  def is_generic(self):
    return len(self.generic_parameters_list) != 0

  @property
  def generic_parameters_decl(self):
    if not self.is_generic:
      return ''
    assert len(self.generic_parameters_list) == 1
    return '<%s>' % (self.generic_parameters_list[0])

  @property
  def full_name(self):
    return '%s%s' % (self.type_name, self.generic_parameters_decl)

  def specialize_with(self, substitutions):
    assert len(substitutions) == 1
    assert len(self.generic_parameters_list) == 1
    return SwiftClassSpecialization(
      '%s<%s>' % (
        self.type_name,
        substitutions[self.generic_parameters_list[0]]))

class SwiftClassSpecialization(object):
  def __init__(self, full_name):
    m = re.match(r'(.+)(<(.+)>)?', full_name)
    self.type_name = m.group(1)
    self.full_name = full_name

}%

import StdlibUnittest
#if _runtime(_ObjC)
import Foundation
#endif

let AnyHashableTests = TestSuite("AnyHashableTests")

AnyHashableTests.test("CustomStringConvertible, CustomDebugStringConvertible, CustomReflectable") {
  let v = AnyHashable(CustomPrintableValue(1))
  expectPrinted("(value: 1).description", v)
  expectDebugPrinted("AnyHashable((value: 1).debugDescription)", v)
  expectDumped(
    "▿ AnyHashable((value: 1).debugDescription)\n" +
    "  ▿ value: (value: 1).debugDescription\n" +
    "    - value: 1\n" +
    "    - identity: 0\n",
    v)
}

% for wrapped in ['MinimalHashableValue', 'MinimalHashableClass']:
AnyHashableTests.test("AnyHashable(${wrapped})/Hashable") {
  let xs = (0...5).flatMap {
    [ ${wrapped}($0, identity: 0),
      ${wrapped}($0, identity: 1) ]
  }
  checkHashable(xs, equalityOracle: { $0 / 2 == $1 / 2 })

  checkHashable(
    xs.map(AnyHashable.init),
    equalityOracle: { $0 / 2 == $1 / 2 })
}

AnyHashableTests.test("AnyHashable(${wrapped}).base") {
  let ah = AnyHashable(${wrapped}(42, identity: 0))
  expectEqual(${wrapped}.self, type(of: ah.base))
}
% end

#if _runtime(_ObjC)
AnyHashableTests.test("AnyHashable(MinimalHashableValue, SwiftValue(MinimalHashableValue))/Hashable") {
  let xs = (0...5).flatMap {
    [ MinimalHashableValue($0, identity: 0),
      MinimalHashableValue($0, identity: 1) ]
  }
  checkHashable(xs, equalityOracle: { $0 / 2 == $1 / 2 })

  let boxedXs = xs.flatMap {
    [ AnyHashable($0),
      AnyHashable(_bridgeAnythingToObjectiveC($0) as! NSObject) ]
  }
  for x in boxedXs {
    expectEqual(
      "MinimalHashableValue",
      String(describing: type(of: x.base)))
  }
  checkHashable(
    boxedXs,
    equalityOracle: { $0 / 4 == $1 / 4 })
}
#endif

% for wrapped in ['GenericMinimalHashableValue', 'GenericMinimalHashableClass']:
%   for payload in [ 'OpaqueValue<Int>', 'LifetimeTracked' ]:
AnyHashableTests.test("AnyHashable(${wrapped}<OpaqueValue<Int>>)/Hashable") {
  ${wrapped}_equalImpl.value = {
    ($0 as! ${payload}).value == ($1 as! ${payload}).value
  }
  ${wrapped}_hashIntoImpl.value = {
    $1.combine(($0 as! ${payload}).value)
  }
  let xs = (0...5).flatMap {
    [ ${wrapped}(${payload}($0), identity: 0),
      ${wrapped}(${payload}($0), identity: 1) ]
  }
  checkHashable(xs, equalityOracle: { $0 / 2 == $1 / 2 })

  checkHashable(
    xs.map(AnyHashable.init),
    equalityOracle: { $0 / 2 == $1 / 2 })
}

AnyHashableTests.test("AnyHashable(${wrapped}).base") {
  let ah = AnyHashable(${wrapped}(${payload}(42), identity: 0))
  expectEqual(${wrapped}<${payload}>.self, type(of: ah.base))
}
%   end
% end

AnyHashableTests.test("AnyHashable(mixed minimal hashables)/Hashable") {
  var xs: [AnyHashable] = []

% for wrapped in ['MinimalHashableValue', 'MinimalHashableClass']:
  xs += (0..<6).flatMap {
    [ ${wrapped}($0, identity: 0),
      ${wrapped}($0, identity: 1) ].map(AnyHashable.init)
  }
% end

% for wrapped in ['GenericMinimalHashableValue', 'GenericMinimalHashableClass']:
  ${wrapped}_equalImpl.value = {
    (lhs, rhs) in
    if let lhs = lhs as? OpaqueValue<Int>,
      let rhs = rhs as? OpaqueValue<Int> {
      return lhs.value == rhs.value
    }
    return (lhs as! LifetimeTracked) == (rhs as! LifetimeTracked)
  }
  ${wrapped}_hashIntoImpl.value = { payload, hasher in
    if let x = payload as? OpaqueValue<Int> {
      hasher.combine(x.value)
      return
    }
    hasher.combine((payload as! LifetimeTracked).value)
  }
% end

% for wrapped in ['GenericMinimalHashableValue', 'GenericMinimalHashableClass']:
%   for payload in [ 'OpaqueValue<Int>', 'LifetimeTracked' ]:
  xs += (0..<6).flatMap {
    [ ${wrapped}(${payload}($0), identity: 0),
      ${wrapped}(${payload}($0), identity: 1) ].map(AnyHashable.init)
  }
%   end
% end

  checkHashable(
    xs,
    equalityOracle: { $0 / 2 == $1 / 2 },
    // FIXME: Types that hash the same way will produce hash collisions when
    // converted to AnyHashable. Arguably, the type id should be used as a hash
    // discriminator.
    hashEqualityOracle: { $0 / 2 % 6 == $1 / 2 % 6 })
}

% for (kw, name) in [
%   ('class', 'Class'),
%   ('struct', 'PODStruct'),
%   ('struct', 'RCStruct'),
% ]:
${kw} HasCustomRepresentation_${name}
  : Hashable, _HasCustomAnyHashableRepresentation
{
%   if name == 'RCStruct':
  var lifetimeTrackedValue: LifetimeTracked
  var value: Int {
    return lifetimeTrackedValue.value
  }
%   else:
  var value: Int
%   end
  var identity: Int
  var hasDefaultAnyHashableRepresentation: Bool
  init(_ value: Int, identity: Int, hasDefaultAnyHashableRepresentation: Bool) {
%   if name == 'RCStruct':
    self.lifetimeTrackedValue = LifetimeTracked(value)
%   else:
    self.value = value
%   end
    self.identity = identity
    self.hasDefaultAnyHashableRepresentation = hasDefaultAnyHashableRepresentation
  }
  var hashValue: Int {
    return value
  }
  func hash(into hasher: inout Hasher) {
    hasher.combine(value)
  }
  func _toCustomAnyHashable() -> AnyHashable? {
    if hasDefaultAnyHashableRepresentation {
      return nil
    }
    let customRepresentation =
      MinimalHashableValue(value, identity: identity)
    return AnyHashable(customRepresentation)
  }
  static func == (
    lhs: HasCustomRepresentation_${name},
    rhs: HasCustomRepresentation_${name}
  ) -> Bool {
    return lhs.value == rhs.value
  }
}

${kw} HasCustomRepresentation_Generic${name}<Wrapped>
  : Hashable, _HasCustomAnyHashableRepresentation
{
  var value: Wrapped
  var identity: Int
  var hasDefaultAnyHashableRepresentation: Bool
  init(
    _ value: Wrapped,
    identity: Int,
    hasDefaultAnyHashableRepresentation: Bool
  ) {
    self.value = value
    self.identity = identity
    self.hasDefaultAnyHashableRepresentation = hasDefaultAnyHashableRepresentation
  }
  var hashValue: Int {
    return asGenericMinimalHashableValue.hashValue
  }
  func hash(into hasher: inout Hasher) {
    hasher.combine(asGenericMinimalHashableValue)
  }
  func _toCustomAnyHashable() -> AnyHashable? {
    if hasDefaultAnyHashableRepresentation {
      return nil
    }
    let customRepresentation =
      GenericMinimalHashableValue(value, identity: identity)
    return AnyHashable(customRepresentation)
  }
  var asGenericMinimalHashableValue: GenericMinimalHashableValue<Wrapped> {
    return GenericMinimalHashableValue(value, identity: identity)
  }
  static func == <Wrapped> (
    lhs: HasCustomRepresentation_Generic${name}<Wrapped>,
    rhs: HasCustomRepresentation_Generic${name}<Wrapped>
  ) -> Bool {
    return
      lhs.asGenericMinimalHashableValue ==
      rhs.asGenericMinimalHashableValue
  }
}
% end

% for name in [ 'Class', 'PODStruct', 'RCStruct' ]:
%   wrapped = 'HasCustomRepresentation_%s' % name
%   genericWrapped = 'HasCustomRepresentation_Generic%s' % name
AnyHashableTests.test("AnyHashable(${wrapped})/Hashable") {
  let xs = (-2...2).flatMap {
    [ ${wrapped}(
        $0, identity: 0,
        hasDefaultAnyHashableRepresentation: $0 < 0),
      ${wrapped}(
        $0, identity: 1,
        hasDefaultAnyHashableRepresentation: $0 < 0) ]
  }
  checkHashable(xs, equalityOracle: { $0 / 2 == $1 / 2 })

  checkHashable(
    xs.map(AnyHashable.init),
    equalityOracle: { $0 / 2 == $1 / 2 })
}

AnyHashableTests.test("AnyHashable(${wrapped}).base") {
  do {
    let ah = AnyHashable(
      ${wrapped}(
        42, identity: 1,
        hasDefaultAnyHashableRepresentation: true))
    expectEqual(${wrapped}.self, type(of: ah.base))
  }
  do {
    let ah = AnyHashable(
      ${wrapped}(
        42, identity: 1,
        hasDefaultAnyHashableRepresentation: false))
    expectEqual(MinimalHashableValue.self, type(of: ah.base))
  }
}

%   for payload in [ 'OpaqueValue<Int>', 'LifetimeTracked' ]:
AnyHashableTests.test("AnyHashable(${genericWrapped}<${payload}>)/Hashable") {
  GenericMinimalHashableValue_equalImpl.value = {
    ($0 as! ${payload}).value == ($1 as! ${payload}).value
  }
  GenericMinimalHashableValue_hashIntoImpl.value = { v, hasher in
    hasher.combine((v as! ${payload}).value)
  }
  let xs = (-2...2).flatMap {
    [ ${genericWrapped}(
        ${payload}($0), identity: 0,
        hasDefaultAnyHashableRepresentation: $0 < 0),
      ${genericWrapped}(
        ${payload}($0), identity: 1,
        hasDefaultAnyHashableRepresentation: $0 < 0) ]
  }
  checkHashable(xs, equalityOracle: { $0 / 2 == $1 / 2 })

  checkHashable(
    xs.map(AnyHashable.init),
    equalityOracle: { $0 / 2 == $1 / 2 })
}

AnyHashableTests.test("AnyHashable(${genericWrapped}<${payload}>)/Hashable") {
  do {
    let ah = AnyHashable(
      ${genericWrapped}(
        ${payload}(42), identity: 0,
        hasDefaultAnyHashableRepresentation: true))
    expectEqual(${genericWrapped}<${payload}>.self, type(of: ah.base))
  }
  do {
    let ah = AnyHashable(
      ${genericWrapped}(
        ${payload}(42), identity: 0,
        hasDefaultAnyHashableRepresentation: false))
    expectEqual(
      GenericMinimalHashableValue<${payload}>.self,
      type(of: ah.base))
  }
}
%   end
% end

struct HasCustomRepresentationRecursively
  : Hashable, _HasCustomAnyHashableRepresentation {

  var value: Int
  init(_ value: Int) {
    self.value = value
  }
  var hashValue: Int {
    return value
  }
  func hash(into hasher: inout Hasher) {
    hasher.combine(value)
  }
  func _toCustomAnyHashable() -> AnyHashable? {
    if value == 0 {
      return AnyHashable(HasCustomRepresentationRecursively(value + 1))
    } else {
      return nil
    }
  }
  static func == (
    lhs: HasCustomRepresentationRecursively,
    rhs: HasCustomRepresentationRecursively
  ) -> Bool {
    return lhs.value == rhs.value
  }
}

AnyHashableTests.test("AnyHashable containing values with recursive custom representations") {
  GenericMinimalHashableValue_equalImpl.value = {
    ($0 as! ${payload}).value == ($1 as! ${payload}).value
  }
  GenericMinimalHashableValue_hashIntoImpl.value = { v, hasher in
    hasher.combine((v as! ${payload}).value)
  }
  // If the custom representation has its own custom representation,
  // we ignore it.
  let ah = AnyHashable(HasCustomRepresentationRecursively(0))
  expectPrinted("HasCustomRepresentationRecursively(value: 1)", ah)
  expectEqual(HasCustomRepresentationRecursively.self, type(of: ah.base))
}

class T2_Base {}
class T3_Base {}
class T4_Base1 {}
class T4_Base : T4_Base1 {}
class T5_Base1 {}
class T5_Base : T5_Base1 {}

class T6_GenericBase<T> {}
class T7_GenericBase<T> {}
class T8_GenericBase1<T> {}
class T8_GenericBase<T> : T8_GenericBase1<T> {}
class T9_GenericBase1<T> {}
class T9_GenericBase<T> : T9_GenericBase1<T> {}

#if _runtime(_ObjC)
class T10_ObjC_Base : NSObject {}
class T11_ObjC_GenericBase<T> : NSObject {}
#endif

% for prefix in [ 'T0', 'T1', 'T2', 'T3', 'T4', 'T5', 'T6', 'T7', 'T8', 'T9', 'T10_ObjC', 'T11_ObjC' ]:
%   base = None
%   if prefix in ['T0', 'T1']:
%     pass
%   elif prefix in ['T2', 'T3', 'T4', 'T5', 'T10_ObjC']:
%     base = SwiftClass(prefix + '_Base')
%   elif prefix in ['T6', 'T7', 'T8', 'T9', 'T11_ObjC']:
%     base = SwiftClass(prefix + '_GenericBase<T>')
%   else:
%     assert False
%   end
%   hashable_base = None
%   if prefix in ['T0', 'T2', 'T4', 'T6', 'T8', 'T10_ObjC']:
%     hashable_base = SwiftClass(prefix + '_HashableBase')
%   elif prefix in ['T1', 'T3', 'T5', 'T7', 'T9', 'T11_ObjC']:
%     hashable_base = SwiftClass(prefix + '_HashableGenericBase<T>')
%   else:
%       assert False
%   end
%   if base and base.is_generic and not hashable_base.is_generic:
%     base = base.specialize_with({'T':'Int'})
%   end
%   bases = []
%   if base:
%     bases += [base]
%   if not 'ObjC' in prefix:
%     bases += [SwiftClass('Hashable')]
%   end

${'#if _runtime(_ObjC)' if 'ObjC' in prefix else ''}
class ${hashable_base.full_name} : ${', '.join([b.full_name for b in bases])} {
  var value: Int
  init(_ value: Int) {
    self.value = value
  }
%   if 'ObjC' in prefix:
  override var hash: Int {
    return value
  }
  override func isEqual(_ object: Any?) -> Bool {
    guard let rhs = object as? ${hashable_base.full_name} else {
      return false
    }
    return self.value == rhs.value
  }
%   else:
  var hashValue: Int {
    return value
  }
  func hash(into hasher: inout Hasher) {
    hasher.combine(value)
  }
  static func == ${hashable_base.generic_parameters_decl} (
    lhs: ${hashable_base.full_name},
    rhs: ${hashable_base.full_name}
  ) -> Bool {
    return lhs.value == rhs.value
  }
%   end
}

%{
generic = hashable_base.generic_parameters_decl
derivedA = SwiftClass(prefix + '_DerivedA' + generic)
derivedB = SwiftClass(prefix + '_DerivedB' + generic)
derivedAA = SwiftClass(prefix + '_DerivedAA' + generic)
derivedAB = SwiftClass(prefix + '_DerivedAB' + generic)
derivedBA = SwiftClass(prefix + '_DerivedBA' + generic)
derivedBB = SwiftClass(prefix + '_DerivedBB' + generic)
derivedAAA = SwiftClass(prefix + '_DerivedAAA' + generic)
derivedAAB = SwiftClass(prefix + '_DerivedAAB' + generic)
derivedABA = SwiftClass(prefix + '_DerivedABA' + generic)
derivedABB = SwiftClass(prefix + '_DerivedABB' + generic)
derivedBAA = SwiftClass(prefix + '_DerivedBAA' + generic)
derivedBAB = SwiftClass(prefix + '_DerivedBAB' + generic)
derivedBBA = SwiftClass(prefix + '_DerivedBBA' + generic)
derivedBBB = SwiftClass(prefix + '_DerivedBBB' + generic)

types = [
  (hashable_base, base),
  (derivedA, hashable_base),
  (derivedB, hashable_base),
  (derivedAA, derivedA),
  (derivedAB, derivedA),
  (derivedBA, derivedB),
  (derivedBB, derivedB),
  (derivedAAA, derivedAA),
  (derivedAAB, derivedAA),
  (derivedABA, derivedAB),
  (derivedABB, derivedAB),
  (derivedBAA, derivedBA),
  (derivedBAB, derivedBA),
  (derivedBBA, derivedBB),
  (derivedBBB, derivedBB),
]
}%

% for (Self, Super) in types:
%   if 'Base' not in Self.type_name:
class ${Self.full_name} : ${Super.full_name} {}
%   end
% end

AnyHashableTests.test("AnyHashable containing classes from the ${prefix} hierarchy") {
  typealias T = Int
% bunch = 2
  let xs = [
% for (i, (Self, _)) in enumerate(types):
%   ConcreteSelf = Self
%   if ConcreteSelf.is_generic:
%     ConcreteSelf = ConcreteSelf.specialize_with({'T':'Int'})
%   end
    ${Self.full_name}(${bunch + i}),
%   for j in range(0, bunch):
    ${Self.full_name}(${j}),
%   end
% end
  ]
  func equalityOracle(_ lhs: Int, rhs: Int) -> Bool {
    if lhs == rhs {
      return true
    }
    let p = ${bunch + 1}
    if lhs % p == 0 || rhs % p == 0 {
      return false
    }
    return lhs % p == rhs % p
  }
  checkHashable(xs, equalityOracle: equalityOracle)

  let anyHashables = xs.map(AnyHashable.init)
  checkHashable(anyHashables, equalityOracle: equalityOracle)
  for (x, ah) in zip(xs, anyHashables) {
    expectEqual(type(of: x), type(of: ah.base))
  }
}
${'#endif' if 'ObjC' in prefix else ''}

% end

#if _runtime(_ObjC)
// There is no public way to define new CF types, so we are using
// CFBitVector and CFMutableBitVector.
extension CFBitVector {
  static func makeImmutable(from values: Array<UInt8>) -> CFBitVector {
    return CFBitVectorCreate(/*allocator:*/ nil, values, values.count * 8)
  }
  var asArray: Array<UInt8> {
    var result = [UInt8](repeating: 0, count: CFBitVectorGetCount(self) / 8)
    CFBitVectorGetBits(
      self,
      CFRange(location: 0, length: result.count * 8),
      &result)
    return result
  }
}

extension CFMutableBitVector {
  static func makeMutable(from values: Array<UInt8>) -> CFMutableBitVector {
    return CFBitVectorCreateMutableCopy(
      /*allocator:*/ nil,
      /*capacity:*/ 0,
      CFBitVector.makeImmutable(from: values))
  }
}

let interestingBitVectorArrays: [[UInt8]] = [
  [],
  [0x00],
  [0xaa],
  [0xff],
  [0xff, 0x00],
  [0x00, 0xff],
  [0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88],
]

AnyHashableTests.test("AnyHashable(CFBitVector)/Hashable, .base") {
  let bitVectors: [CFBitVector] =
    interestingBitVectorArrays.map(CFBitVector.makeImmutable)
  let hashEqualityOracle: (Int, Int) -> Bool = {
    // CFBitVector returns its count as the hash.
    interestingBitVectorArrays[$0].count == interestingBitVectorArrays[$1].count
  }
  let arrays = bitVectors.map { $0.asArray }
  func isEq(_ lhs: [[UInt8]], _ rhs: [[UInt8]]) -> Bool {
    return zip(lhs, rhs).map { $0 == $1 }.reduce(true, { $0 && $1 })
  }
  expectEqualTest(interestingBitVectorArrays, arrays, sameValue: isEq)
  checkHashable(
    bitVectors,
    equalityOracle: { $0 == $1 },
    hashEqualityOracle: hashEqualityOracle)

  do {
    expectEqual("ForeignClass", SwiftRuntime.metadataKind(of: bitVectors.first!))

    let anyHashables = bitVectors.map(AnyHashable.init)
    checkHashable(anyHashables,
      equalityOracle: { $0 == $1 },
      hashEqualityOracle: hashEqualityOracle)

    let v = anyHashables.first!.base
    expectTrue(type(of: v) is CFBitVector.Type)
  }
  do {
    let bitVectorsAsAnyObjects: [NSObject] = bitVectors.map {
      ($0 as AnyObject) as! NSObject
    }
    expectEqual(
      "ObjCClassWrapper",
      SwiftRuntime.metadataKind(of: bitVectorsAsAnyObjects.first!))

    let anyHashables = bitVectorsAsAnyObjects.map(AnyHashable.init)
    checkHashable(anyHashables,
      equalityOracle: { $0 == $1 },
      hashEqualityOracle: hashEqualityOracle)

    let v = anyHashables.first!.base
    expectTrue(type(of: v) is CFBitVector.Type)
  }
}

AnyHashableTests.test("AnyHashable(CFMutableBitVector)/Hashable, .base") {
  // CFMutableBitVector inherits the Hashable conformance from
  // CFBitVector.
  let bitVectors: [CFMutableBitVector] =
    interestingBitVectorArrays.map(CFMutableBitVector.makeMutable)
  let hashEqualityOracle: (Int, Int) -> Bool = {
    // CFBitVector returns its count as the hash.
    interestingBitVectorArrays[$0].count == interestingBitVectorArrays[$1].count
  }
  let arrays = bitVectors.map { $0.asArray }
  func isEq(_ lhs: [[UInt8]], _ rhs: [[UInt8]]) -> Bool {
    return zip(lhs, rhs).map { $0 == $1 }.reduce(true, { $0 && $1 })
  }
  expectEqualTest(interestingBitVectorArrays, arrays, sameValue: isEq)
  checkHashable(
    bitVectors,
    equalityOracle: { $0 == $1 },
    hashEqualityOracle: hashEqualityOracle)

  do {
    expectEqual(
      "ForeignClass",
      SwiftRuntime.metadataKind(of: bitVectors.first!))

    let anyHashables = bitVectors.map(AnyHashable.init)
    checkHashable(
      anyHashables,
      equalityOracle: { $0 == $1 },
      hashEqualityOracle: hashEqualityOracle)

    let v = anyHashables.first!.base
    expectTrue(type(of: v) is CFMutableBitVector.Type)
  }
  do {
    let bitVectorsAsAnyObjects: [NSObject] = bitVectors.map {
      ($0 as AnyObject) as! NSObject
    }
    checkHashable(
      bitVectorsAsAnyObjects,
      equalityOracle: { $0 == $1 },
      hashEqualityOracle: hashEqualityOracle)

    expectEqual(
      "ObjCClassWrapper",
      SwiftRuntime.metadataKind(of: bitVectorsAsAnyObjects.first!))

    let anyHashables = bitVectorsAsAnyObjects.map(AnyHashable.init)
    checkHashable(
      anyHashables,
      equalityOracle: { $0 == $1 },
      hashEqualityOracle: hashEqualityOracle)

    let v = anyHashables.first!.base
    expectTrue(type(of: v) is CFMutableBitVector.Type)
  }
}

#endif

enum MinimalHashablePODSwiftError : Error, Hashable {
  case caseA
  case caseB
  case caseC
}

enum MinimalHashableRCSwiftError : Error, Hashable {
  case caseA(LifetimeTracked)
  case caseB(LifetimeTracked)
  case caseC(LifetimeTracked)

  func hash(into hasher: inout Hasher) {
    switch self {
    case .caseA:
      hasher.combine(10)
    case .caseB:
      hasher.combine(20)
    case .caseC:
      hasher.combine(30)
    }
  }

  static func == (
    lhs: MinimalHashableRCSwiftError,
    rhs: MinimalHashableRCSwiftError
  ) -> Bool {
    switch (lhs, rhs) {
    case (.caseA(let lhs), .caseA(let rhs)):
      return lhs == rhs
    case (.caseB(let lhs), .caseB(let rhs)):
      return lhs == rhs
    case (.caseC(let lhs), .caseC(let rhs)):
      return lhs == rhs
    default:
      return false
    }
  }
}

AnyHashableTests.test("AnyHashable(MinimalHashablePODSwiftError)/Hashable") {
  let xs: [MinimalHashablePODSwiftError] = [
    .caseA, .caseA,
    .caseB, .caseB,
    .caseC, .caseC,
  ]
  expectEqual("Enum", SwiftRuntime.metadataKind(of: xs.first!))
  checkHashable(xs, equalityOracle: { $0 / 2 == $1 / 2 })
  checkHashable(
    xs.map(AnyHashable.init),
    equalityOracle: { $0 / 2 == $1 / 2 })
}

AnyHashableTests.test("AnyHashable(MinimalHashablePODSwiftError).base") {
  let ah = AnyHashable(MinimalHashablePODSwiftError.caseA)
  expectEqual(MinimalHashablePODSwiftError.self, type(of: ah.base))
}

AnyHashableTests.test("AnyHashable(MinimalHashableRCSwiftError)/Hashable") {
  let xs: [MinimalHashableRCSwiftError] = [
    .caseA(LifetimeTracked(1)), .caseA(LifetimeTracked(1)),
    .caseA(LifetimeTracked(2)), .caseA(LifetimeTracked(2)),
    .caseB(LifetimeTracked(1)), .caseB(LifetimeTracked(1)),
    .caseB(LifetimeTracked(2)), .caseB(LifetimeTracked(2)),
    .caseC(LifetimeTracked(1)), .caseC(LifetimeTracked(1)),
    .caseC(LifetimeTracked(2)), .caseC(LifetimeTracked(2)),
  ]
  expectEqual("Enum", SwiftRuntime.metadataKind(of: xs.first!))
  checkHashable(
    xs,
    equalityOracle: { $0 / 2 == $1 / 2 },
    hashEqualityOracle: { $0 / 4 == $1 / 4 })
  checkHashable(
    xs.map(AnyHashable.init),
    equalityOracle: { $0 / 2 == $1 / 2 },
    hashEqualityOracle: { $0 / 4 == $1 / 4 })
}

AnyHashableTests.test("AnyHashable(MinimalHashableRCSwiftError).base") {
  let ah = AnyHashable(MinimalHashableRCSwiftError.caseA(LifetimeTracked(1)))
  expectEqual(MinimalHashableRCSwiftError.self, type(of: ah.base))
}

AnyHashableTests.test("AnyHashable(NumericTypes)/Hashable") {
  // Numeric types holding mathematically equal values must compare equal and
  // hash the same way when converted to AnyHashable.
  let groups: [[AnyHashable]] = [
    [
      1 as Int,
      1 as UInt,
      1 as Int8,
      1 as UInt8,
      1 as Int16,
      1 as UInt16,
      1 as Int32,
      1 as UInt32,
      1 as Int64,
      1 as UInt64,
      1 as Float,
      1 as Double,
    ],
    [
      42 as Int,
      42 as UInt,
      42 as Int8,
      42 as UInt8,
      42 as Int16,
      42 as UInt16,
      42 as Int32,
      42 as UInt32,
      42 as Int64,
      42 as UInt64,
      42 as Float,
      42 as Double,
    ],
    [
      Int(Int32.max),
      UInt(Int32.max),
      Int32.max,
      UInt32(Int32.max),
      Int64(Int32.max),
      UInt64(Int32.max),
      Double(Int32.max),
    ],
    [
      Float.infinity,
      Double.infinity,
    ],
    [
      0x1.aP1 as Float, // 3.25
      0x1.aP1 as Double,
    ],
    [
      0x1.a000000000001P1, // 3.25.nextUp, not representable by a Float
    ]
  ]
  checkHashableGroups(groups)
}

#if !os(Windows) && (arch(i386) || arch(x86_64))
AnyHashableTests.test("AnyHashable(Float80)/Hashable") {
  let groups: [[AnyHashable]] = [
    [
      42 as Int,
      42 as Float,
      42 as Double,
      42 as Float80,
    ],
    [
      Float.infinity,
      Double.infinity,
      Float80.infinity,
    ],
    [
      3.25 as Float,
      3.25 as Double,
      3.25 as Float80,
    ],
    [
      0x1.a000000000001P1 as Double, // 3.25.nextUp
      0x1.a000000000001P1 as Float80,
    ],
    [
      0x1.a000000000000002p1 as Float80, // (3.25 as Float80).nextUp
    ],
  ]
  checkHashableGroups(groups)
}
#endif

#if _runtime(_ObjC)
// A wrapper type around an Int that bridges to NSNumber.
struct IntWrapper1 : _SwiftNewtypeWrapper, Hashable, _ObjectiveCBridgeable {
  let rawValue: Int
}

// A wrapper type around an Int that bridges to NSNumber.
struct IntWrapper2 : _SwiftNewtypeWrapper, Hashable, _ObjectiveCBridgeable {
  let rawValue: Int
}

// A wrapper type around an Int that bridges to NSNumber.
struct Int8Wrapper : _SwiftNewtypeWrapper, Hashable, _ObjectiveCBridgeable {
  let rawValue: Int8
}

AnyHashableTests.test("AnyHashable(IntWrappers)/Hashable") {
  let groups: [[AnyHashable]] = [
    [
      IntWrapper1(rawValue: 42),
      IntWrapper2(rawValue: 42),
      Int8Wrapper(rawValue: 42),
      42,
      42 as Double,
      42 as NSNumber,
    ],
    [
      IntWrapper1(rawValue: -23),
      IntWrapper2(rawValue: -23),
      Int8Wrapper(rawValue: -23),
      -23,
      -23 as Double,
      -23 as NSNumber,
    ],
  ]
  checkHashableGroups(groups)
}
#endif

#if _runtime(_ObjC)
// A wrapper type around a String that bridges to NSString.
struct StringWrapper1 : _SwiftNewtypeWrapper, Hashable, _ObjectiveCBridgeable {
  let rawValue: String
}

// A wrapper type around a String that bridges to NSString.
struct StringWrapper2 : _SwiftNewtypeWrapper, Hashable, _ObjectiveCBridgeable {
  let rawValue: String
}

AnyHashableTests.test("AnyHashable(StringWrappers)/Hashable") {
  let groups: [[AnyHashable]] = [
    [
      StringWrapper1(rawValue: "hello"),
      StringWrapper2(rawValue: "hello"),
      "hello" as String,
      "hello" as NSString,
    ],
    [
      StringWrapper1(rawValue: "world"),
      StringWrapper2(rawValue: "world"),
      "world" as String,
      "world" as NSString,
    ]
  ]
  checkHashableGroups(groups)
}

AnyHashableTests.test("AnyHashable(Set)/Hashable") {
  let groups: [[AnyHashable]] = [
    [
      Set([1, 2, 3]),
      Set([1, 2, 3] as [Int8]),
      Set([1, 2, 3] as [Float]),
      NSSet(set: [1, 2, 3]),
    ],
    [
      Set([2, 3, 4]),
      NSSet(set: [2, 3, 4]),
    ],
    [
      Set([Set([1, 2]), Set([3, 4])]),
      NSSet(set: [NSSet(set: [1, 2]), NSSet(set: [3, 4])]),
    ],
    [
      Set([Set([1, 3]), Set([2, 4])]),
      NSSet(set: [NSSet(set: [1, 3]), NSSet(set: [2, 4])]),
    ],
  ]
  checkHashableGroups(groups)
}

AnyHashableTests.test("AnyHashable(Array)/Hashable") {
  let groups: [[AnyHashable]] = [
    [
      [1, 2, 3],
      [1, 2, 3] as [Int8],
      [1, 2, 3] as [Double],
      NSArray(array: [1, 2, 3]),
    ],
    [
      [3, 2, 1],
      [3, 2, 1] as [AnyHashable],
      NSArray(array: [3, 2, 1]),
    ],
    [
      [[1, 2], [3, 4]],
      NSArray(array: [NSArray(array: [1, 2]), NSArray(array: [3, 4])]),
    ],
    [
      [[3, 4], [1, 2]],
      NSArray(array: [NSArray(array: [3, 4]), NSArray(array: [1, 2])]),
    ]
  ]
  checkHashableGroups(groups)
}

AnyHashableTests.test("AnyHashable(Dictionary)/Hashable") {
  let groups: [[AnyHashable]] = [
    [
      ["hello": 1, "world": 2] as [String: Int],
      ["hello": 1, "world": 2] as [String: Int16],
      ["hello": 1, "world": 2] as [String: Float],
      NSDictionary(dictionary: ["hello": 1, "world": 2]),
    ],
    [
      ["hello": 2, "world": 1],
      NSDictionary(dictionary: ["hello": 2, "world": 1]),
    ],
    [
      ["hello": ["foo": 1, "bar": 2],
        "world": ["foo": 2, "bar": 1]],
      NSDictionary(dictionary: [
          "hello": ["foo": 1, "bar": 2],
          "world": ["foo": 2, "bar": 1]]),
    ],
    [
      ["hello": ["foo": 2, "bar": 1],
        "world": ["foo": 1, "bar": 2]],
      NSDictionary(dictionary: [
          "hello": ["foo": 2, "bar": 1],
          "world": ["foo": 1, "bar": 2]]),
    ],
  ]
  checkHashableGroups(groups)
}

AnyHashableTests.test("AnyHashable(__SwiftNativeNSError(MinimalHashablePODSwiftError))/Hashable") {
  let swiftErrors: [MinimalHashablePODSwiftError] = [
    .caseA, .caseA,
    .caseB, .caseB,
    .caseC, .caseC,
  ]
  let nsErrors: [NSError] = swiftErrors.flatMap {
    swiftError -> [NSError] in
    let bridgedNSError = swiftError as NSError
    return [
      bridgedNSError,
      NSError(domain: bridgedNSError.domain, code: bridgedNSError.code)
    ]
  }
  expectEqual(
    "ObjCClassWrapper",
    SwiftRuntime.metadataKind(of: nsErrors[0]))
  expectEqual("__SwiftNativeNSError", String(describing: type(of: nsErrors[0])))

  func equalityOracle(_ lhs: Int, _ rhs: Int) -> Bool {
    // Swift errors compare equal to the `NSError`s that have the same domain
    // and code.
    return lhs / 4 == rhs / 4
  }

  checkHashable(nsErrors, equalityOracle: equalityOracle)
  checkHashable(
    nsErrors.map(AnyHashable.init),
    equalityOracle: equalityOracle)

  // FIXME(id-as-any): run `checkHashable` on an array of mixed
  // `AnyHashable(MinimalHashablePODSwiftError)` and
  // `AnyHashable(__SwiftNativeNSError(MinimalHashablePODSwiftError))`.  For
  // this to succeed, we need to eagerly bridge Swift errors into the Swift
  // representation when wrapped in `AnyHashable`.
}

AnyHashableTests.test("AnyHashable(__SwiftNativeNSError(MinimalHashablePODSwiftError)).base") {
  let ah = AnyHashable(MinimalHashablePODSwiftError.caseA as NSError)
  expectTrue(type(of: ah.base) is NSError.Type)
}

AnyHashableTests.test("AnyHashable(__SwiftNativeNSError(MinimalHashableRCSwiftError))/Hashable") {
  let swiftErrors: [MinimalHashableRCSwiftError] = [
    .caseA(LifetimeTracked(1)), .caseA(LifetimeTracked(1)),
    .caseA(LifetimeTracked(2)), .caseA(LifetimeTracked(2)),
    .caseB(LifetimeTracked(1)), .caseB(LifetimeTracked(1)),
    .caseB(LifetimeTracked(2)), .caseB(LifetimeTracked(2)),
    .caseC(LifetimeTracked(1)), .caseC(LifetimeTracked(1)),
    .caseC(LifetimeTracked(2)), .caseC(LifetimeTracked(2)),
  ]
  checkHashable(
    swiftErrors,
    equalityOracle: { $0 / 2 == $1 / 2 },
    hashEqualityOracle: { $0 / 4 == $1 / 4 },
    allowBrokenTransitivity: false)

  let nsErrors: [NSError] = swiftErrors.flatMap {
    swiftError -> [NSError] in
    let bridgedNSError = swiftError as NSError
    return [
      bridgedNSError,
      NSError(domain: bridgedNSError.domain, code: bridgedNSError.code)
    ]
  }

  expectEqual(
    "ObjCClassWrapper",
    SwiftRuntime.metadataKind(of: nsErrors[0]))
  expectEqual("__SwiftNativeNSError", String(describing: type(of: nsErrors[0])))

  expectEqual(
    "ObjCClassWrapper",
    SwiftRuntime.metadataKind(of: nsErrors[1]))
  expectEqual("NSError", String(describing: type(of: nsErrors[1])))

  func equalityOracle(_ lhs: Int, _ rhs: Int) -> Bool {
    // Equality of bridged Swift errors takes the payload into account, so for
    // a fixed X, Y, all `.caseX(LifetimeTracked(Y))` compare equal.
    // They also compare equal to the `NSError`s that have the same domain
    // and code.
    if lhs / 4 == rhs / 4 {
      return true
    }
    // `NSError`s that have the same domain and code as a bridged Swift
    // error compare equal to all Swift errors with the same domain and code
    // regardless of the payload.
    if (lhs % 2 == 1 || rhs % 2 == 1) && (lhs / 8 == rhs / 8) {
      return true
    }
    return false
  }

  func hashEqualityOracle(_ lhs: Int, _ rhs: Int) -> Bool {
    // Every NSError that has the same domain and code hash the same way.
    return lhs / 8 == rhs / 8
  }

  // FIXME: transitivity is broken because pure `NSError`s can compare equal to
  // Swift errors with payloads just based on the domain and code, and Swift
  // errors with payloads don't compare equal when payloads differ.
  checkHashable(
    nsErrors,
    equalityOracle: equalityOracle,
    hashEqualityOracle: hashEqualityOracle,
    allowBrokenTransitivity: true)
  checkHashable(
    nsErrors.map(AnyHashable.init),
    equalityOracle: equalityOracle,
    hashEqualityOracle: hashEqualityOracle,
    allowBrokenTransitivity: true)

  // FIXME(id-as-any): run `checkHashable` on an array of mixed
  // `AnyHashable(MinimalHashableRCSwiftError)` and
  // `AnyHashable(__SwiftNativeNSError(MinimalHashableRCSwiftError))`.  For
  // this to succeed, we need to eagerly bridge Swift errors into the Swift
  // representation when wrapped in `AnyHashable`.
}

AnyHashableTests.test("AnyHashable(__SwiftNativeNSError(MinimalHashableRCSwiftError)).base") {
  let ah = AnyHashable(
    MinimalHashableRCSwiftError.caseA(LifetimeTracked(1)) as NSError)
  expectTrue(type(of: ah.base) is NSError.Type)
}

AnyHashableTests.test("AnyHashable(NSError)/Hashable") {
  let nsErrors: [NSError] = [
    NSError(domain: "Foo", code: 0),
    NSError(domain: "Foo", code: 0),
    NSError(domain: "Foo", code: 1),
    NSError(domain: "Foo", code: 1),
    NSError(domain: "Foo", code: 2),
    NSError(domain: "Foo", code: 2),
  ]
  expectEqual(
    "ObjCClassWrapper",
    SwiftRuntime.metadataKind(of: nsErrors.first!))
  checkHashable(nsErrors, equalityOracle: { $0 / 2 == $1 / 2 })
  checkHashable(
    nsErrors.map(AnyHashable.init),
    equalityOracle: { $0 / 2 == $1 / 2 })
}

AnyHashableTests.test("AnyHashable(NSError).base") {
  let ah = AnyHashable(NSError(domain: "Foo", code: 0))
  expectTrue(type(of: ah.base) is NSError.Type)
}
#endif

runAllTests()