Function iterableEquality

packages/expect/src/jest-utils.ts:435–577

(
  a: any,
  b: any,
  customTesters: Array<Tester> = [],
  aStack: Array<any> = [],
  bStack: Array<any> = [],
)

}

export function iterableEquality(
  a: any,
  b: any,
  customTesters: Array<Tester> = [],
  aStack: Array<any> = [],
  bStack: Array<any> = [],
): boolean | undefined {
  if (
    typeof a !== 'object'
    || typeof b !== 'object'
    || Array.isArray(a)
    || Array.isArray(b)
    || !hasIterator(a)
    || !hasIterator(b)
  ) {
    return undefined
  }

  if (a.constructor !== b.constructor) {
    return false
  }

  let length = aStack.length
  while (length--) {
    // Linear search. Performance is inversely proportional to the number of
    // unique nested structures.
    // circular references at same depth are equal
    // circular reference is not equal to non-circular one
    if (aStack[length] === a) {
      return bStack[length] === b
    }
  }
  aStack.push(a)
  bStack.push(b)

  const filteredCustomTesters: Array<Tester> = [
    ...customTesters.filter(t => t !== iterableEquality),
    iterableEqualityWithStack,
  ]

  function iterableEqualityWithStack(a: any, b: any) {
    return iterableEquality(a, b, [...customTesters], [...aStack], [...bStack])
  }

  if (a.size !== undefined) {
    if (a.size !== b.size) {
      return false
    }
    else if (isA('Set', a) || isImmutableUnorderedSet(a)) {
      let allFound = true
      for (const aValue of a) {
        if (!b.has(aValue)) {
          let has = false
          for (const bValue of b) {
            const isEqual = equals(aValue, bValue, filteredCustomTesters)
            if (isEqual === true) {
              has = true
            }