Add isArraylikeObject

[Pisces] / collection.test.js

diff --git a/collection.test.js b/collection.test.js
index b490572c575e017727d55c00371ffb9aef99d37d..bdded97324472d1e5654d8ba5198f7e62bf1a58a 100644 (file)
--- a/collection.test.js
+++ b/collection.test.js
@@ -21,10 +21,11 @@ import {
   canonicalNumericIndexString,
   findIndexedEntry,
   isArrayIndexString,
   canonicalNumericIndexString,
   findIndexedEntry,
   isArrayIndexString,

+  isArraylikeObject,

   isCollection,
   isConcatSpreadable,
   isIntegerIndexString,
   isCollection,
   isConcatSpreadable,
   isIntegerIndexString,

-  lengthOfArrayLike,
+  lengthOfArraylike,

   toIndex,
   toLength,
 } from "./collection.js";
   toIndex,
   toLength,
 } from "./collection.js";


@@ -163,6 +164,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);
 describe("isCollection", () => {
   it("[[Call]] returns false for primitives", () => {
     assertStrictEquals(isCollection("failure"), false);


@@ -310,37 +344,37 @@ describe("isIntegerIndexString", () => {
   });
 });
 
   });
 });
 

-describe("lengthOfArrayLike", () => {
+describe("lengthOfArraylike", () => {

   it("[[Call]] returns the length", () => {
     assertStrictEquals(
   it("[[Call]] returns the length", () => {
     assertStrictEquals(

-      lengthOfArrayLike({ length: 9007199254740991 }),
+      lengthOfArraylike({ length: 9007199254740991 }),

       9007199254740991,
     );
   });
 
   it("[[Call]] returns a non·nan result", () => {
       9007199254740991,
     );
   });
 
   it("[[Call]] returns a non·nan result", () => {

-    assertStrictEquals(lengthOfArrayLike({ length: NaN }), 0);
-    assertStrictEquals(lengthOfArrayLike({ length: "failure" }), 0);
+    assertStrictEquals(lengthOfArraylike({ length: NaN }), 0);
+    assertStrictEquals(lengthOfArraylike({ length: "failure" }), 0);

   });
 
   it("[[Call]] returns an integral result", () => {
   });
 
   it("[[Call]] returns an integral result", () => {

-    assertStrictEquals(lengthOfArrayLike({ length: 0.25 }), 0);
-    assertStrictEquals(lengthOfArrayLike({ length: 1.1 }), 1);
+    assertStrictEquals(lengthOfArraylike({ length: 0.25 }), 0);
+    assertStrictEquals(lengthOfArraylike({ length: 1.1 }), 1);

   });
 
   it("[[Call]] returns a result greater than or equal to zero", () => {
   });
 
   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);
+    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(
   });
 
   it("[[Call]] returns a result less than 2 ** 53", () => {
     assertStrictEquals(

-      lengthOfArrayLike({ length: 9007199254740992 }),
+      lengthOfArraylike({ length: 9007199254740992 }),

       9007199254740991,
     );
     assertStrictEquals(
       9007199254740991,
     );
     assertStrictEquals(

-      lengthOfArrayLike({ length: Infinity }),
+      lengthOfArraylike({ length: Infinity }),

       9007199254740991,
     );
   });
       9007199254740991,
     );
   });