]> Lady’s Gitweb - Pisces/blob - value.test.js
cfaded4e39569af25966ef94501a349027b6442d
[Pisces] / 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 });
This page took 0.071469 seconds and 3 git commands to generate.