Lady’s Gitweb - Pisces/blob - value.test.js

   1 // ♓🌟 Piscēs ∷ value.test.js
   2 // ====================================================================
   3 //
   4 // Copyright © 2022–2023 Lady [@ Lady’s Computer].
   5 //
   6 // This Source Code Form is subject to the terms of the Mozilla Public
   7 // License, v. 2.0. If a copy of the MPL was not distributed with this
   8 // file, You can obtain one at <https://mozilla.org/MPL/2.0/>.
   9
  10 import {
  11   assertStrictEquals,
  12   assertThrows,
  13   describe,
  14   it,
  15 } from "./dev-deps.js";
  16 import {
  17   ASYNC_ITERATOR,
  18   HAS_INSTANCE,
  19   IS_CONCAT_SPREADABLE,
  20   ITERATOR,
  21   MATCH,
  22   MATCH_ALL,
  23   NULL,
  24   ordinaryToPrimitive,
  25   REPLACE,
  26   sameValue,
  27   sameValueZero,
  28   SPECIES,
  29   SPLIT,
  30   TO_PRIMITIVE,
  31   TO_STRING_TAG,
  32   toPrimitive,
  33   type,
  34   UNDEFINED,
  35   UNSCOPABLES,
  36 } from "./value.js";
  37
  38 describe("ASYNC_ITERATOR", () => {
  39   it("[[Get]] is @@asyncIterator", () => {
  40     assertStrictEquals(ASYNC_ITERATOR, Symbol.asyncIterator);
  41   });
  42 });
  43
  44 describe("HAS_INSTANCE", () => {
  45   it("[[Get]] is @@hasInstance", () => {
  46     assertStrictEquals(HAS_INSTANCE, Symbol.hasInstance);
  47   });
  48 });
  49
  50 describe("IS_CONCAT_SPREADABLE", () => {
  51   it("[[Get]] is @@isConcatSpreadable", () => {
  52     assertStrictEquals(
  53       IS_CONCAT_SPREADABLE,
  54       Symbol.isConcatSpreadable,
  55     );
  56   });
  57 });
  58
  59 describe("ITERATOR", () => {
  60   it("[[Get]] is @@iterator", () => {
  61     assertStrictEquals(ITERATOR, Symbol.iterator);
  62   });
  63 });
  64
  65 describe("MATCH", () => {
  66   it("[[Get]] is @@match", () => {
  67     assertStrictEquals(MATCH, Symbol.match);
  68   });
  69 });
  70
  71 describe("MATCH_ALL", () => {
  72   it("[[Get]] is @@matchAll", () => {
  73     assertStrictEquals(MATCH_ALL, Symbol.matchAll);
  74   });
  75 });
  76
  77 describe("NULL", () => {
  78   it("[[Get]] is null", () => {
  79     assertStrictEquals(NULL, null);
  80   });
  81 });
  82
  83 describe("REPLACE", () => {
  84   it("[[Get]] is @@replace", () => {
  85     assertStrictEquals(REPLACE, Symbol.replace);
  86   });
  87 });
  88
  89 describe("SPECIES", () => {
  90   it("[[Get]] is @@species", () => {
  91     assertStrictEquals(SPECIES, Symbol.species);
  92   });
  93 });
  94
  95 describe("SPLIT", () => {
  96   it("[[Get]] is @@split", () => {
  97     assertStrictEquals(SPLIT, Symbol.split);
  98   });
  99 });
 100
 101 describe("TO_PRIMITIVE", () => {
 102   it("[[Get]] is @@toPrimitive", () => {
 103     assertStrictEquals(TO_PRIMITIVE, Symbol.toPrimitive);
 104   });
 105 });
 106
 107 describe("TO_STRING_TAG", () => {
 108   it("[[Get]] is @@toStringTag", () => {
 109     assertStrictEquals(TO_STRING_TAG, Symbol.toStringTag);
 110   });
 111 });
 112
 113 describe("UNDEFINED", () => {
 114   it("[[Get]] is undefined", () => {
 115     assertStrictEquals(UNDEFINED, void {});
 116   });
 117 });
 118
 119 describe("UNSCOPABLES", () => {
 120   it("[[Get]] is @@unscopables", () => {
 121     assertStrictEquals(UNSCOPABLES, Symbol.unscopables);
 122   });
 123 });
 124
 125 describe("ordinaryToPrimitive", () => {
 126   it("[[Call]] prefers `valueOf` by default", () => {
 127     const obj = {
 128       toString() {
 129         return "failure";
 130       },
 131       valueOf() {
 132         return "success";
 133       },
 134     };
 135     assertStrictEquals(ordinaryToPrimitive(obj), "success");
 136     assertStrictEquals(ordinaryToPrimitive(obj, "default"), "success");
 137   });
 138
 139   it('[[Call]] prefers `valueOf` for a "number" hint', () => {
 140     const obj = {
 141       toString() {
 142         return "failure";
 143       },
 144       valueOf() {
 145         return "success";
 146       },
 147     };
 148     assertStrictEquals(ordinaryToPrimitive(obj, "number"), "success");
 149   });
 150
 151   it('[[Call]] prefers `toString` for a "string" hint', () => {
 152     const obj = {
 153       toString() {
 154         return "success";
 155       },
 156       valueOf() {
 157         return "failure";
 158       },
 159     };
 160     assertStrictEquals(ordinaryToPrimitive(obj, "string"), "success");
 161   });
 162
 163   it("[[Call]] falls back to the other method if the first isn’t callable", () => {
 164     const obj = {
 165       toString() {
 166         return "success";
 167       },
 168       valueOf: "failure",
 169     };
 170     assertStrictEquals(ordinaryToPrimitive(obj), "success");
 171   });
 172
 173   it("[[Call]] falls back to the other method if the first returns an object", () => {
 174     const obj = {
 175       toString() {
 176         return "success";
 177       },
 178       valueOf() {
 179         return new String("failure");
 180       },
 181     };
 182     assertStrictEquals(ordinaryToPrimitive(obj), "success");
 183   });
 184
 185   it("[[Call]] throws an error if neither method is callable", () => {
 186     const obj = {
 187       toString: "failure",
 188       valueOf: "failure",
 189     };
 190     assertThrows(() => ordinaryToPrimitive(obj));
 191   });
 192
 193   it("[[Call]] throws an error if neither method returns an object", () => {
 194     const obj = {
 195       toString() {
 196         return new String("failure");
 197       },
 198       valueOf() {
 199         return new String("failure");
 200       },
 201     };
 202     assertThrows(() => ordinaryToPrimitive(obj));
 203   });
 204
 205   describe(".name", () => {
 206     it("[[Get]] returns the correct name", () => {
 207       assertStrictEquals(
 208         ordinaryToPrimitive.name,
 209         "ordinaryToPrimitive",
 210       );
 211     });
 212   });
 213 });
 214
 215 describe("sameValue", () => {
 216   it("[[Call]] returns false for null 🆚 undefined", () => {
 217     assertStrictEquals(sameValue(null, undefined), false);
 218   });
 219
 220   it("[[Call]] returns false for null 🆚 an object", () => {
 221     assertStrictEquals(sameValue(null, {}), false);
 222   });
 223
 224   it("[[Call]] returns true for null 🆚 null", () => {
 225     assertStrictEquals(sameValue(null, null), true);
 226   });
 227
 228   it("[[Call]] returns false for two different objects", () => {
 229     assertStrictEquals(sameValue({}, {}), false);
 230   });
 231
 232   it("[[Call]] returns true for the same object", () => {
 233     const obj = {};
 234     assertStrictEquals(sameValue(obj, obj), true);
 235   });
 236
 237   it("[[Call]] returns false for ±0", () => {
 238     assertStrictEquals(sameValue(0, -0), false);
 239   });
 240
 241   it("[[Call]] returns true for -0", () => {
 242     assertStrictEquals(sameValue(-0, -0), true);
 243   });
 244
 245   it("[[Call]] returns true for nan", () => {
 246     assertStrictEquals(sameValue(0 / 0, 0 / 0), true);
 247   });
 248
 249   it("[[Call]] returns false for a primitive and its wrapped object", () => {
 250     assertStrictEquals(sameValue(false, new Boolean(false)), false);
 251   });
 252
 253   describe(".name", () => {
 254     it("[[Get]] returns the correct name", () => {
 255       assertStrictEquals(sameValue.name, "sameValue");
 256     });
 257   });
 258 });
 259
 260 describe("sameValueZero", () => {
 261   it("[[Call]] returns false for null 🆚 undefined", () => {
 262     assertStrictEquals(sameValueZero(null, undefined), false);
 263   });
 264
 265   it("[[Call]] returns false for null 🆚 an object", () => {
 266     assertStrictEquals(sameValueZero(null, {}), false);
 267   });
 268
 269   it("[[Call]] returns true for null 🆚 null", () => {
 270     assertStrictEquals(sameValueZero(null, null), true);
 271   });
 272
 273   it("[[Call]] returns false for two different objects", () => {
 274     assertStrictEquals(sameValueZero({}, {}), false);
 275   });
 276
 277   it("[[Call]] returns true for the same object", () => {
 278     const obj = {};
 279     assertStrictEquals(sameValueZero(obj, obj), true);
 280   });
 281
 282   it("[[Call]] returns true for ±0", () => {
 283     assertStrictEquals(sameValueZero(0, -0), true);
 284   });
 285
 286   it("[[Call]] returns true for -0", () => {
 287     assertStrictEquals(sameValueZero(-0, -0), true);
 288   });
 289
 290   it("[[Call]] returns true for nan", () => {
 291     assertStrictEquals(sameValueZero(0 / 0, 0 / 0), true);
 292   });
 293
 294   it("[[Call]] returns false for a primitive and its wrapped object", () => {
 295     assertStrictEquals(
 296       sameValueZero(false, new Boolean(false)),
 297       false,
 298     );
 299   });
 300
 301   describe(".name", () => {
 302     it("[[Get]] returns the correct name", () => {
 303       assertStrictEquals(sameValueZero.name, "sameValueZero");
 304     });
 305   });
 306 });
 307
 308 describe("toPrimitive", () => {
 309   it("[[Call]] returns the argument when passed a primitive", () => {
 310     const value = Symbol();
 311     assertStrictEquals(toPrimitive(value), value);
 312   });
 313
 314   it("[[Call]] works with nullish values", () => {
 315     assertStrictEquals(toPrimitive(null), null);
 316     assertStrictEquals(toPrimitive(), void {});
 317   });
 318
 319   it("[[Call]] calls ordinaryToPrimitive by default", () => {
 320     const value = Object.assign(
 321       Object.create(null),
 322       {
 323         valueOf() {
 324           return "success";
 325         },
 326       },
 327     );
 328     assertStrictEquals(toPrimitive(value), "success");
 329   });
 330
 331   it("[[Call]] accepts a hint", () => {
 332     const value = Object.assign(
 333       Object.create(null),
 334       {
 335         toString() {
 336           return "success";
 337         },
 338         valueOf() {
 339           return "failure";
 340         },
 341       },
 342     );
 343     assertStrictEquals(toPrimitive(value, "string"), "success");
 344   });
 345
 346   it("[[Call]] uses the exotic toPrimitive method if available", () => {
 347     const value = Object.assign(
 348       Object.create(null),
 349       {
 350         [Symbol.toPrimitive]() {
 351           return "success";
 352         },
 353       },
 354     );
 355     assertStrictEquals(toPrimitive(value), "success");
 356   });
 357
 358   it("[[Call]] passes the hint to the exotic toPrimitive", () => {
 359     const value = Object.assign(
 360       Object.create(null),
 361       {
 362         [Symbol.toPrimitive](hint) {
 363           return hint === "string" ? "success" : "failure";
 364         },
 365       },
 366     );
 367     assertStrictEquals(toPrimitive(value, "string"), "success");
 368   });
 369
 370   it('[[Call]] passes a "default" hint by default', () => {
 371     const value = Object.assign(
 372       Object.create(null),
 373       {
 374         [Symbol.toPrimitive](hint) {
 375           return hint === "default" ? "success" : "failure";
 376         },
 377       },
 378     );
 379     assertStrictEquals(toPrimitive(value, "default"), "success");
 380   });
 381
 382   it("[[Call]] throws for an invalid hint", () => {
 383     const value1 = Object.assign(
 384       Object.create(null),
 385       {
 386         [Symbol.toPrimitive]() {
 387           return "success";
 388         },
 389       },
 390     );
 391     const value2 = Object.assign(
 392       Object.create(null),
 393       {
 394         valueOf() {
 395           return true;
 396         },
 397       },
 398     );
 399     assertThrows(() => toPrimitive(value1, "badhint"));
 400     assertThrows(() => toPrimitive(value2, "badhint"));
 401     assertThrows(() => toPrimitive(true, "badhint"));
 402   });
 403
 404   describe(".name", () => {
 405     it("[[Get]] returns the correct name", () => {
 406       assertStrictEquals(toPrimitive.name, "toPrimitive");
 407     });
 408   });
 409 });
 410
 411 describe("type", () => {
 412   it('[[Call]] returns "null" for null', () => {
 413     assertStrictEquals(type(null), "null");
 414   });
 415
 416   it('[[Call]] returns "undefined" for undefined', () => {
 417     assertStrictEquals(type(void {}), "undefined");
 418   });
 419
 420   it('[[Call]] returns "object" for non‐callable objects', () => {
 421     assertStrictEquals(type(Object.create(null)), "object");
 422   });
 423
 424   it('[[Call]] returns "object" for callable objects', () => {
 425     assertStrictEquals(type(() => {}), "object");
 426   });
 427
 428   it('[[Call]] returns "object" for constructable objects', () => {
 429     assertStrictEquals(type(class {}), "object");
 430   });
 431
 432   describe(".name", () => {
 433     it("[[Get]] returns the correct name", () => {
 434       assertStrictEquals(type.name, "type");
 435     });
 436   });
 437 });