Fix [undefined] vs. []

Author: compulim

packages/base/src/utils/iterateEquals.spec.ts

@@ -1,9 +1,48 @@
-import { expect, test } from '@jest/globals';
+import { beforeEach, describe, expect, test } from '@jest/globals';
 import iterateEquals from './iterateEquals';
 
-test('comparing empty arrays', () => expect(iterateEquals([].values(), [].values())).toBe(true));
-test('comparing different arrays', () => expect(iterateEquals([1].values(), [2].values())).toBe(false));
-test('comparing bigger array to smaller array', () => expect(iterateEquals([1, 2].values(), [1].values())).toBe(false));
-test('comparing smaller array to bigger array', () => expect(iterateEquals([1].values(), [1, 2].values())).toBe(false));
-test('comparing non-empty array to empty array', () => expect(iterateEquals([1].values(), [].values())).toBe(false));
-test('comparing empty array to non-empty array', () => expect(iterateEquals([].values(), [1].values())).toBe(false));
+const iterateEqualsFlip: typeof iterateEquals = (x, y) => iterateEquals(y, x);
+
+describe.each([['normal'], ['flip']])('with %s order', mode => {
+  let fn: typeof iterateEqualsFlip;
+
+  beforeEach(() => {
+    fn = mode === 'normal' ? iterateEquals : iterateEqualsFlip;
+  });
+
+  test('should throw on same iterator instance', () => {
+    const iterator = [1, 2, 3].values();
+
+    expect(() => fn(iterator, iterator)).toThrow();
+  });
+
+  test('should return true on same iterable instance', () => {
+    const iterator = [1, 2, 3];
+
+    expect(fn(iterator, iterator)).toBe(true);
+  });
+
+  test('should return true on same value', () => {
+    expect(fn([1, 2, 3].values(), [1, 2, 3].values())).toBe(true);
+  });
+
+  test('should return false on shorter start', () => {
+    expect(fn([1, 2, 3].values(), [2, 3].values())).toBe(false);
+  });
+
+  test('should return false on shorter end', () => {
+    expect(fn([1, 2, 3].values(), [1, 2].values())).toBe(false);
+  });
+
+  test('should return false against empty array', () => {
+    expect(fn([1, 2, 3].values(), [].values())).toBe(false);
+  });
+
+  test('undefined should be treated as an element', () => {
+    expect(fn([].values(), [undefined].values())).toBe(false);
+  });
+
+  test('null should be treated as an element', () => {
+    expect(fn([].values(), [null].values())).toBe(false);
+  });
+});

packages/base/src/utils/iterateEquals.ts

@@ -4,15 +4,21 @@ export default function iterateEquals<T>(x: Iterable<T>, y: Iterable<T>): boolea
   const xIterator = x[Symbol.iterator]();
   const yIterator = y[Symbol.iterator]();
 
+  if (Object.is(xIterator, yIterator)) {
+    throw new Error('Must not pass same instance twice');
+  }
+
+  // eslint-disable-next-line no-magic-numbers
   for (let count = 0; count < MAX_ITERATION; count++) {
     const resultX = xIterator.next();
     const resultY = yIterator.next();
 
-    if (resultX.done && resultY.done) {
-      return true;
-    }
+    const { done: xDone } = resultX;
+    const { done: yDone } = resultY;
 
-    if (!Object.is(resultX.value, resultY.value)) {
+    if (xDone && yDone) {
+      return true;
+    } else if (xDone || yDone || !Object.is(resultX.value, resultY.value)) {
       break;
     }
   }