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
 206 describe("sameValue", () => {
 207   it("[[Call]] returns false for null 🆚 undefined", () => {
 208     assertStrictEquals(sameValue(null, undefined), false);
 209   });
 210
 211   it("[[Call]] returns false for null 🆚 an object", () => {
 212     assertStrictEquals(sameValue(null, {}), false);
 213   });
 214
 215   it("[[Call]] returns true for null 🆚 null", () => {
 216     assertStrictEquals(sameValue(null, null), true);
 217   });
 218
 219   it("[[Call]] returns false for two different objects", () => {
 220     assertStrictEquals(sameValue({}, {}), false);
 221   });
 222
 223   it("[[Call]] returns true for the same object", () => {
 224     const obj = {};
 225     assertStrictEquals(sameValue(obj, obj), true);
 226   });
 227
 228   it("[[Call]] returns false for ±0", () => {
 229     assertStrictEquals(sameValue(0, -0), false);
 230   });
 231
 232   it("[[Call]] returns true for -0", () => {
 233     assertStrictEquals(sameValue(-0, -0), true);
 234   });
 235
 236   it("[[Call]] returns true for nan", () => {
 237     assertStrictEquals(sameValue(0 / 0, 0 / 0), true);
 238   });
 239
 240   it("[[Call]] returns false for a primitive and its wrapped object", () => {
 241     assertStrictEquals(sameValue(false, new Boolean(false)), false);
 242   });
 243 });
 244
 245 describe("sameValueZero", () => {
 246   it("[[Call]] returns false for null 🆚 undefined", () => {
 247     assertStrictEquals(sameValueZero(null, undefined), false);
 248   });
 249
 250   it("[[Call]] returns false for null 🆚 an object", () => {
 251     assertStrictEquals(sameValueZero(null, {}), false);
 252   });
 253
 254   it("[[Call]] returns true for null 🆚 null", () => {
 255     assertStrictEquals(sameValueZero(null, null), true);
 256   });
 257
 258   it("[[Call]] returns false for two different objects", () => {
 259     assertStrictEquals(sameValueZero({}, {}), false);
 260   });
 261
 262   it("[[Call]] returns true for the same object", () => {
 263     const obj = {};
 264     assertStrictEquals(sameValueZero(obj, obj), true);
 265   });
 266
 267   it("[[Call]] returns true for ±0", () => {
 268     assertStrictEquals(sameValueZero(0, -0), true);
 269   });
 270
 271   it("[[Call]] returns true for -0", () => {
 272     assertStrictEquals(sameValueZero(-0, -0), true);
 273   });
 274
 275   it("[[Call]] returns true for nan", () => {
 276     assertStrictEquals(sameValueZero(0 / 0, 0 / 0), true);
 277   });
 278
 279   it("[[Call]] returns false for a primitive and its wrapped object", () => {
 280     assertStrictEquals(
 281       sameValueZero(false, new Boolean(false)),
 282       false,
 283     );
 284   });
 285 });
 286
 287 describe("toPrimitive", () => {
 288   it("[[Call]] returns the argument when passed a primitive", () => {
 289     const value = Symbol();
 290     assertStrictEquals(toPrimitive(value), value);
 291   });
 292
 293   it("[[Call]] works with nullish values", () => {
 294     assertStrictEquals(toPrimitive(null), null);
 295     assertStrictEquals(toPrimitive(), void {});
 296   });
 297
 298   it("[[Call]] calls ordinaryToPrimitive by default", () => {
 299     const value = Object.assign(
 300       Object.create(null),
 301       {
 302         valueOf() {
 303           return "success";
 304         },
 305       },
 306     );
 307     assertStrictEquals(toPrimitive(value), "success");
 308   });
 309
 310   it("[[Call]] accepts a hint", () => {
 311     const value = Object.assign(
 312       Object.create(null),
 313       {
 314         toString() {
 315           return "success";
 316         },
 317         valueOf() {
 318           return "failure";
 319         },
 320       },
 321     );
 322     assertStrictEquals(toPrimitive(value, "string"), "success");
 323   });
 324
 325   it("[[Call]] uses the exotic toPrimitive method if available", () => {
 326     const value = Object.assign(
 327       Object.create(null),
 328       {
 329         [Symbol.toPrimitive]() {
 330           return "success";
 331         },
 332       },
 333     );
 334     assertStrictEquals(toPrimitive(value), "success");
 335   });
 336
 337   it("[[Call]] passes the hint to the exotic toPrimitive", () => {
 338     const value = Object.assign(
 339       Object.create(null),
 340       {
 341         [Symbol.toPrimitive](hint) {
 342           return hint === "string" ? "success" : "failure";
 343         },
 344       },
 345     );
 346     assertStrictEquals(toPrimitive(value, "string"), "success");
 347   });
 348
 349   it('[[Call]] passes a "default" hint by default', () => {
 350     const value = Object.assign(
 351       Object.create(null),
 352       {
 353         [Symbol.toPrimitive](hint) {
 354           return hint === "default" ? "success" : "failure";
 355         },
 356       },
 357     );
 358     assertStrictEquals(toPrimitive(value, "default"), "success");
 359   });
 360
 361   it("[[Call]] throws for an invalid hint", () => {
 362     const value1 = Object.assign(
 363       Object.create(null),
 364       {
 365         [Symbol.toPrimitive]() {
 366           return "success";
 367         },
 368       },
 369     );
 370     const value2 = Object.assign(
 371       Object.create(null),
 372       {
 373         valueOf() {
 374           return true;
 375         },
 376       },
 377     );
 378     assertThrows(() => toPrimitive(value1, "badhint"));
 379     assertThrows(() => toPrimitive(value2, "badhint"));
 380     assertThrows(() => toPrimitive(true, "badhint"));
 381   });
 382 });
 383
 384 describe("type", () => {
 385   it('[[Call]] returns "null" for null', () => {
 386     assertStrictEquals(type(null), "null");
 387   });
 388
 389   it('[[Call]] returns "undefined" for undefined', () => {
 390     assertStrictEquals(type(void {}), "undefined");
 391   });
 392
 393   it('[[Call]] returns "object" for non‐callable objects', () => {
 394     assertStrictEquals(type(Object.create(null)), "object");
 395   });
 396
 397   it('[[Call]] returns "object" for callable objects', () => {
 398     assertStrictEquals(type(() => {}), "object");
 399   });
 400
 401   it('[[Call]] returns "object" for constructable objects', () => {
 402     assertStrictEquals(type(class {}), "object");
 403   });
 404 });