Move arraylike & index functions → values.js

[Pisces] / collection.test.js

diff --git a/collection.test.js b/collection.test.js
index b490572c575e017727d55c00371ffb9aef99d37d..544f454849a8dd4507eaa770ad1960db5798ac96 100644 (file)
--- a/collection.test.js
+++ b/collection.test.js
@@ -12,57 +12,19 @@ import {
   assertSpyCall,
   assertSpyCalls,
   assertStrictEquals,
-  assertThrows,
   describe,
   it,
   spy,
 } from "./dev-deps.js";
 import {
-  canonicalNumericIndexString,
   findIndexedEntry,
   isArrayIndexString,
+  isArraylikeObject,
   isCollection,
   isConcatSpreadable,
   isIntegerIndexString,
-  lengthOfArrayLike,
-  toIndex,
-  toLength,
 } from "./collection.js";
 
-describe("canonicalNumericIndexString", () => {
-  it("[[Call]] returns undefined for nonstrings", () => {
-    assertStrictEquals(canonicalNumericIndexString(1), void {});
-  });
-
-  it("[[Call]] returns undefined for noncanonical strings", () => {
-    assertStrictEquals(canonicalNumericIndexString(""), void {});
-    assertStrictEquals(canonicalNumericIndexString("01"), void {});
-    assertStrictEquals(
-      canonicalNumericIndexString("9007199254740993"),
-      void {},
-    );
-  });
-
-  it('[[Call]] returns -0 for "-0"', () => {
-    assertStrictEquals(canonicalNumericIndexString("-0"), -0);
-  });
-
-  it("[[Call]] returns the corresponding number for canonical strings", () => {
-    assertStrictEquals(canonicalNumericIndexString("0"), 0);
-    assertStrictEquals(canonicalNumericIndexString("-0.25"), -0.25);
-    assertStrictEquals(
-      canonicalNumericIndexString("9007199254740992"),
-      9007199254740992,
-    );
-    assertStrictEquals(canonicalNumericIndexString("NaN"), 0 / 0);
-    assertStrictEquals(canonicalNumericIndexString("Infinity"), 1 / 0);
-    assertStrictEquals(
-      canonicalNumericIndexString("-Infinity"),
-      -1 / 0,
-    );
-  });
-});
-
 describe("findIndexedEntry", () => {
   it("[[Call]] returns undefined if no matching entry exists", () => {
     assertStrictEquals(findIndexedEntry([], () => true), void {});
@@ -163,6 +125,39 @@ describe("isArrayIndexString", () => {
   });
 });
 
+describe("isArraylikeObject", () => {
+  it("[[Call]] returns false for primitives", () => {
+    assertStrictEquals(isArraylikeObject("failure"), false);
+  });
+
+  it("[[Call]] returns false if length throws", () => {
+    assertStrictEquals(
+      isArraylikeObject({
+        get length() {
+          throw void {};
+        },
+      }),
+      false,
+    );
+  });
+
+  it("[[Call]] returns false if length is not a number and cannot be converted to one", () => {
+    assertStrictEquals(isArraylikeObject({ length: 1n }), false);
+  });
+
+  it("[[Call]] returns true if length is convertable to a number", () => {
+    assertStrictEquals(isArraylikeObject({ length: -0 }), true);
+    assertStrictEquals(isArraylikeObject({ length: 1 }), true);
+    assertStrictEquals(isArraylikeObject({ length: -1.25 }), true);
+    assertStrictEquals(
+      isArraylikeObject({ length: 9007199254740992 }),
+      true,
+    );
+    assertStrictEquals(isArraylikeObject({ length: Infinity }), true);
+    assertStrictEquals(isArraylikeObject({ length: "success" }), true);
+  });
+});
+
 describe("isCollection", () => {
   it("[[Call]] returns false for primitives", () => {
     assertStrictEquals(isCollection("failure"), false);
@@ -309,93 +304,3 @@ describe("isIntegerIndexString", () => {
     assertStrictEquals(isIntegerIndexString("9007199254740991"), true);
   });
 });
-
-describe("lengthOfArrayLike", () => {
-  it("[[Call]] returns the length", () => {
-    assertStrictEquals(
-      lengthOfArrayLike({ length: 9007199254740991 }),
-      9007199254740991,
-    );
-  });
-
-  it("[[Call]] returns a non·nan result", () => {
-    assertStrictEquals(lengthOfArrayLike({ length: NaN }), 0);
-    assertStrictEquals(lengthOfArrayLike({ length: "failure" }), 0);
-  });
-
-  it("[[Call]] returns an integral result", () => {
-    assertStrictEquals(lengthOfArrayLike({ length: 0.25 }), 0);
-    assertStrictEquals(lengthOfArrayLike({ length: 1.1 }), 1);
-  });
-
-  it("[[Call]] returns a result greater than or equal to zero", () => {
-    assertStrictEquals(lengthOfArrayLike({ length: -0 }), 0);
-    assertStrictEquals(lengthOfArrayLike({ length: -1 }), 0);
-    assertStrictEquals(lengthOfArrayLike({ length: -Infinity }), 0);
-  });
-
-  it("[[Call]] returns a result less than 2 ** 53", () => {
-    assertStrictEquals(
-      lengthOfArrayLike({ length: 9007199254740992 }),
-      9007199254740991,
-    );
-    assertStrictEquals(
-      lengthOfArrayLike({ length: Infinity }),
-      9007199254740991,
-    );
-  });
-});
-
-describe("toIndex", () => {
-  it("[[Call]] returns an index", () => {
-    assertStrictEquals(toIndex(9007199254740991), 9007199254740991);
-  });
-
-  it("[[Call]] returns zero for a zerolike result", () => {
-    assertStrictEquals(toIndex(NaN), 0);
-    assertStrictEquals(toIndex("failure"), 0);
-    assertStrictEquals(toIndex(-0), 0);
-  });
-
-  it("[[Call]] rounds down to the nearest integer", () => {
-    assertStrictEquals(toIndex(0.25), 0);
-    assertStrictEquals(toIndex(1.1), 1);
-  });
-
-  it("[[Call]] throws when provided a negative number", () => {
-    assertThrows(() => toIndex(-1));
-    assertThrows(() => toIndex(-Infinity));
-  });
-
-  it("[[Call]] throws when provided a number greater than or equal to 2 ** 53", () => {
-    assertThrows(() => toIndex(9007199254740992));
-    assertThrows(() => toIndex(Infinity));
-  });
-});
-
-describe("toLength", () => {
-  it("[[Call]] returns a length", () => {
-    assertStrictEquals(toLength(9007199254740991), 9007199254740991);
-  });
-
-  it("[[Call]] returns a non·nan result", () => {
-    assertStrictEquals(toLength(NaN), 0);
-    assertStrictEquals(toLength("failure"), 0);
-  });
-
-  it("[[Call]] returns an integral result", () => {
-    assertStrictEquals(toLength(0.25), 0);
-    assertStrictEquals(toLength(1.1), 1);
-  });
-
-  it("[[Call]] returns a result greater than or equal to zero", () => {
-    assertStrictEquals(toLength(-0), 0);
-    assertStrictEquals(toLength(-1), 0);
-    assertStrictEquals(toLength(-Infinity), 0);
-  });
-
-  it("[[Call]] returns a result less than 2 ** 53", () => {
-    assertStrictEquals(toLength(9007199254740992), 9007199254740991);
-    assertStrictEquals(toLength(Infinity), 9007199254740991);
-  });
-});