Add methods for own entries and values to object.js

[Pisces] / function.test.js

diff --git a/function.test.js b/function.test.js
index 0a58a367af38433412a700d230bb5995d1da13ae..bf0e907a2df13688932447fbb084bc83940fdf82 100644 (file)
--- a/function.test.js
+++ b/function.test.js
@@ -10,10 +10,14 @@
 import {
   assert,
   assertEquals,
 import {
   assert,
   assertEquals,

+  assertNotStrictEquals,
+  assertSpyCall,
+  assertSpyCalls,

   assertStrictEquals,
   assertThrows,
   describe,
   it,
   assertStrictEquals,
   assertThrows,
   describe,
   it,

+  spy,

 } from "./dev-deps.js";
 import {
   bind,
 } from "./dev-deps.js";
 import {
   bind,


@@ -27,6 +31,7 @@ import {
   identity,
   isCallable,
   isConstructor,
   identity,
   isCallable,
   isConstructor,

+  maybe,

   ordinaryHasInstance,
 } from "./function.js";
 
   ordinaryHasInstance,
 } from "./function.js";
 


@@ -465,9 +470,6 @@ describe("createIllegalConstructor", () => {
       Object.getPrototypeOf(constructor.prototype),
       Object.prototype,
     );
       Object.getPrototypeOf(constructor.prototype),
       Object.prototype,
     );

-    console.dir(
-      Object.getOwnPropertyDescriptors(constructor.prototype),
-    );

     assertEquals(
       constructor.prototype,
       Object.create(Object.prototype, {
     assertEquals(
       constructor.prototype,
       Object.create(Object.prototype, {


@@ -708,6 +710,95 @@ describe("createProxyConstructor", () => {
     });
   });
 
     });
   });
 

+  describe("~is[[.name]]", () => {
+    it("[[GetOwnProperty]] defines the appropriate method", () => {
+      assertNotStrictEquals(
+        Object.getOwnPropertyDescriptor(
+          createProxyConstructor({}),
+          "isProxy",
+        ),
+        undefined,
+      );
+      assertNotStrictEquals(
+        Object.getOwnPropertyDescriptor(
+          createProxyConstructor({}, function Base() {}),
+          "isBaseProxy",
+        ),
+        undefined,
+      );
+      assertNotStrictEquals(
+        Object.getOwnPropertyDescriptor(
+          createProxyConstructor({}, function Bad() {}, undefined, {
+            name: "⸺",
+          }),
+          "is⸺",
+        ),
+        undefined,
+      );
+    });
+
+    it("[[GetOwnProperty]] has the correct descriptor", () => {
+      const proxyConstructor = createProxyConstructor({});
+      assertEquals(
+        Object.getOwnPropertyDescriptor(
+          proxyConstructor,
+          "isProxy",
+        ),
+        {
+          configurable: true,
+          enumerable: false,
+          value: proxyConstructor.isProxy,
+          writable: true,
+        },
+      );
+    });
+
+    it("[[Call]] returns true for created proxies", () => {
+      const proxyConstructor = createProxyConstructor({});
+      const proxy = new proxyConstructor();
+      assertStrictEquals(
+        proxyConstructor.isProxy(proxy),
+        true,
+      );
+    });
+
+    it("[[Call]] returns false for nonproxies", () => {
+      const constructor = function Base() {};
+      const proxyConstructor = createProxyConstructor({}, constructor);
+      assertStrictEquals(
+        proxyConstructor.isBaseProxy(new constructor()),
+        false,
+      );
+    });
+
+    it("[[Construct]] throws an error", () => {
+      const proxyConstructor = createProxyConstructor({});
+      assertThrows(() => new proxyConstructor.isProxy({}));
+    });
+
+    describe(".length", () => {
+      it("[[Get]] returns the correct length", () => {
+        const proxyConstructor = createProxyConstructor({});
+        assertStrictEquals(proxyConstructor.isProxy.length, 1);
+      });
+    });
+
+    describe(".name", () => {
+      it("[[Get]] returns the correct name", () => {
+        const proxyConstructor = createProxyConstructor({});
+        assertStrictEquals(proxyConstructor.isProxy.name, "isProxy");
+        const otherProxyConstructor = createProxyConstructor(
+          {},
+          function Base() {},
+        );
+        assertStrictEquals(
+          otherProxyConstructor.isBaseProxy.name,
+          "isBaseProxy",
+        );
+      });
+    });
+  });
+

   describe("~length", () => {
     it("[[GetOwnProperty]] has the correct descriptor", () => {
       assertEquals(
   describe("~length", () => {
     it("[[GetOwnProperty]] has the correct descriptor", () => {
       assertEquals(


@@ -735,7 +826,7 @@ describe("createProxyConstructor", () => {
         {
           configurable: true,
           enumerable: false,
         {
           configurable: true,
           enumerable: false,

-          value: "ObjectProxy",
+          value: "Proxy",

           writable: false,
         },
       );
           writable: false,
         },
       );


@@ -991,6 +1082,42 @@ describe("isConstructor", () => {
   });
 });
 
   });
 });
 

+describe("maybe", () => {
+  it("[[Call]] calls if not nullish", () => {
+    const wrapper = spy(() => "success");
+    assertStrictEquals(maybe(0, wrapper), "success");
+    assertSpyCalls(wrapper, 1);
+    assertSpyCall(wrapper, 0, {
+      args: [0],
+      self: undefined,
+      returned: "success",
+    });
+  });
+
+  it("[[Call]] does not call if nullish", () => {
+    const wrapper = spy(() => "success");
+    assertStrictEquals(maybe(null, wrapper), null);
+    assertStrictEquals(maybe(undefined, wrapper), undefined);
+    assertSpyCalls(wrapper, 0);
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new maybe(true, ($) => $));
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(maybe.length, 2);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(maybe.name, "maybe");
+    });
+  });
+});
+

 describe("ordinaryHasInstance", () => {
   it("[[Call]] walks the prototype chain", () => {
     const constructor = class {
 describe("ordinaryHasInstance", () => {
   it("[[Call]] walks the prototype chain", () => {
     const constructor = class {