]>
Lady’s Gitweb - Pisces/blob - binary.test.js
c5c2600cce71a5a6f28a19c13a180ae9461c203a
1 // ♓🌟 Piscēs ∷ binary.test.js
2 // ====================================================================
4 // Copyright © 2020–2023 Lady [@ Lady’s Computer].
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/>.
17 } from "./dev-deps.js";
26 filenameSafeBase64Binary
,
27 filenameSafeBase64String
,
42 // These tests assume a LITTLE‐ENDIAN environment.
43 const data
= new Map([
51 base16
: "006200610073006500360034",
52 base32
: "ABRAAYIAOMAGKABWAA2A====",
53 base64
: "AGIAYQBzAGUANgA0",
54 wrmg
: "01H00R80EC06A01P00T0",
56 [new Uint16Array([62535]), {
62 [new Uint8ClampedArray([75, 73, 66, 73]).buffer
, {
68 [new DataView(new Uint8Array([98, 97, 115, 101, 54, 52]).buffer
), {
69 base16
: "626173653634",
70 base32
: "MJQXGZJWGQ======",
75 // The following three examples are from RFC 3548.
76 [new Uint8Array([0x14, 0xFB, 0x9C, 0x03, 0xD9, 0x7E]), {
77 base16
: "14FB9C03D97E",
78 base32
: "CT5ZYA6ZPY======",
82 [new Uint8Array([0x14, 0xFB, 0x9C, 0x03, 0xD9]), {
88 [new Uint8Array([0x14, 0xFB, 0x9C, 0x03]), {
95 // The following examples are from the Ruby base32 gem.
96 [new Uint8Array([0x28]), {
102 [new Uint8Array([0xD6]), {
108 [new Uint16Array([0xF8D6]), {
114 [new Uint8Array([0xD6, 0xF8, 0x00]), {
120 [new Uint8Array([0xD6, 0xF8, 0x10]), {
126 [new Uint32Array([0x0C11F8D6]), {
132 [new Uint8Array([0xD6, 0xF8, 0x11, 0x0C, 0x80]), {
133 base16
: "D6F8110C80",
138 [new Uint16Array([0xF8D6, 0x0C11, 0x3085]), {
139 base16
: "D6F8110C8530",
140 base32
: "234BCDEFGA======",
146 describe("arrayBufferSlice", () => {
147 it("[[Call]] slices an `ArrayBuffer`", () => {
148 const baseBuffer
= Uint8Array
.from([2, 3, 1, 9, 8, 5]).buffer
;
150 new Uint8Array(arrayBufferSlice(baseBuffer
, 1, 4)),
151 Uint8Array
.from([3, 1, 9]),
155 it("[[Call]] slices an `SharedArrayBuffer`", () => {
156 const baseBuffer
= new SharedArrayBuffer(6);
157 new Uint8Array(baseBuffer
).set([2, 3, 1, 9, 8, 5], 0);
159 new Uint8Array(arrayBufferSlice(baseBuffer
, 1, 4)),
160 Uint8Array
.from([3, 1, 9]),
164 it("[[Call]] throws for others", () => {
177 new DataView(new ArrayBuffer()),
180 assertThrows(() => arrayBufferSlice(value
, 0, 0))
185 describe("base16Binary", () => {
186 it("[[Call]] returns the correct data", () => {
188 new Uint8Array(base16Binary("")),
193 new Uint8Array(base16Binary("006200610073006500360034")),
195 "\u{0}b\u{0}a\u{0}s\u{0}e\u{0}6\u{0}4",
196 ($) => $.charCodeAt(0),
198 "006200610073006500360034",
201 new Uint16Array(base16Binary("47F4")),
202 new Uint16Array([62535]),
206 new Uint8ClampedArray(base16Binary("4B494249")),
207 new Uint8ClampedArray([75, 73, 66, 73]),
211 new Uint8Array(base16Binary("626173653634")),
212 new Uint8Array([98, 97, 115, 101, 54, 52]),
216 new Uint8Array(base16Binary("14FB9C03D97E")),
217 new Uint8Array([0x14, 0xFB, 0x9C, 0x03, 0xD9, 0x7E]),
221 new Uint8Array(base16Binary("14FB9C03D9")),
222 new Uint8Array([0x14, 0xFB, 0x9C, 0x03, 0xD9]),
226 new Uint8Array(base16Binary("14FB9C03")),
227 new Uint8Array([0x14, 0xFB, 0x9C, 0x03]),
231 new Uint8Array(base16Binary("28")),
232 new Uint8Array([0x28]),
236 new Uint8Array(base16Binary("D6")),
237 new Uint8Array([0xD6]),
241 new Uint16Array(base16Binary("D6F8")),
242 new Uint16Array([0xF8D6]),
246 new Uint8Array(base16Binary("D6F800")),
247 new Uint8Array([0xD6, 0xF8, 0x00]),
251 new Uint8Array(base16Binary("D6F810")),
252 new Uint8Array([0xD6, 0xF8, 0x10]),
256 new Uint32Array(base16Binary("D6F8110C")),
257 new Uint32Array([0x0C11F8D6]),
261 new Uint8Array(base16Binary("D6F8110C80")),
262 new Uint8Array([0xD6, 0xF8, 0x11, 0x0C, 0x80]),
266 new Uint16Array(base16Binary("D6F8110C8530")),
267 new Uint16Array([0xF8D6, 0x0C11, 0x3085]),
272 it("[[Call]] is case‐insensitive", () => {
274 new Uint8Array(base16Binary("d6f8110C80")),
275 new Uint8Array([0xD6, 0xF8, 0x11, 0x0C, 0x80]),
280 it("[[Call]] throws when provided with an invalid character", () => {
281 assertThrows(() => base16Binary("ABCG"));
284 it("[[Call]] throws when provided with a length with a remainder of 1 when divided by 2", () => {
285 assertThrows(() => base16Binary("A"));
286 assertThrows(() => base16Binary("ABC"));
290 describe("base16String", () => {
291 it("[[Call]] returns the correct string", () => {
292 for (const [source
, { base16
}] of data
) {
293 assertStrictEquals(base16String(source
), base16
);
298 describe("base32Binary", () => {
299 it("[[Call]] returns the correct data", () => {
301 new Uint8Array(base32Binary("")),
306 new Uint8Array(base32Binary("ABRAAYIAOMAGKABWAA2A====")),
308 "\u{0}b\u{0}a\u{0}s\u{0}e\u{0}6\u{0}4",
309 ($) => $.charCodeAt(0),
311 "ABRAAYIAOMAGKABWAA2A====",
314 new Uint16Array(base32Binary("I72A====")),
315 new Uint16Array([62535]),
319 new Uint8ClampedArray(base32Binary("JNEUESI=")),
320 new Uint8ClampedArray([75, 73, 66, 73]),
324 new Uint8Array(base32Binary("MJQXGZJWGQ======")),
325 new Uint8Array([98, 97, 115, 101, 54, 52]),
329 new Uint8Array(base32Binary("CT5ZYA6ZPY======")),
330 new Uint8Array([0x14, 0xFB, 0x9C, 0x03, 0xD9, 0x7E]),
334 new Uint8Array(base32Binary("CT5ZYA6Z")),
335 new Uint8Array([0x14, 0xFB, 0x9C, 0x03, 0xD9]),
339 new Uint8Array(base32Binary("CT5ZYAY=")),
340 new Uint8Array([0x14, 0xFB, 0x9C, 0x03]),
344 new Uint8Array(base32Binary("FA======")),
345 new Uint8Array([0x28]),
349 new Uint8Array(base32Binary("2Y======")),
350 new Uint8Array([0xD6]),
354 new Uint16Array(base32Binary("234A====")),
355 new Uint16Array([0xF8D6]),
359 new Uint8Array(base32Binary("234AA===")),
360 new Uint8Array([0xD6, 0xF8, 0x00]),
364 new Uint8Array(base32Binary("234BA===")),
365 new Uint8Array([0xD6, 0xF8, 0x10]),
369 new Uint32Array(base32Binary("234BCDA=")),
370 new Uint32Array([0x0C11F8D6]),
374 new Uint8Array(base32Binary("234BCDEA")),
375 new Uint8Array([0xD6, 0xF8, 0x11, 0x0C, 0x80]),
379 new Uint16Array(base32Binary("234BCDEFGA======")),
380 new Uint16Array([0xF8D6, 0x0C11, 0x3085]),
385 it("[[Call]] is case‐insensitive", () => {
387 new Uint8Array(base32Binary("234bcdEA")),
388 new Uint8Array([0xD6, 0xF8, 0x11, 0x0C, 0x80]),
393 it("[[Call]] throws when provided with an invalid character", () => {
394 assertThrows(() => base32Binary("ABC0"));
395 assertThrows(() => base32Binary("ABC1"));
396 assertThrows(() => base32Binary("ABC8"));
397 assertThrows(() => base32Binary("ABC9"));
400 it("[[Call]] throws when provided with an invalid equals", () => {
401 assertThrows(() => base32Binary("CT3ZYAY=="));
404 it("[[Call]] throws when provided with a length with a remainder of 1, 3 ∣ 6 when divided by 8", () => {
405 assertThrows(() => base32Binary("234BCDEAA"));
406 assertThrows(() => base32Binary("234BCDEAA======="));
407 assertThrows(() => base32Binary("UHI"));
408 assertThrows(() => base32Binary("UHIUJD"));
412 describe("base32String", () => {
413 it("[[Call]] returns the correct string", () => {
414 for (const [source
, { base32
}] of data
) {
415 assertStrictEquals(base32String(source
), base32
);
420 describe("base64Binary", () => {
421 it("[[Call]] returns the correct data", () => {
423 new Uint8Array(base64Binary("")),
428 new Uint8Array(base64Binary("AGIAYQBzAGUANgA0")),
430 "\u{0}b\u{0}a\u{0}s\u{0}e\u{0}6\u{0}4",
431 ($) => $.charCodeAt(0),
436 new Uint16Array(base64Binary("R/Q=")),
437 new Uint16Array([62535]),
441 new Uint8ClampedArray(base64Binary("S0lCSQ==")),
442 new Uint8ClampedArray([75, 73, 66, 73]),
446 new Uint8Array(base64Binary("YmFzZTY0")),
447 new Uint8Array([98, 97, 115, 101, 54, 52]),
451 new Uint8Array(base64Binary("FPucA9l+")),
452 new Uint8Array([0x14, 0xFB, 0x9C, 0x03, 0xD9, 0x7E]),
456 new Uint8Array(base64Binary("FPucA9k=")),
457 new Uint8Array([0x14, 0xFB, 0x9C, 0x03, 0xD9]),
461 new Uint8Array(base64Binary("FPucAw==")),
462 new Uint8Array([0x14, 0xFB, 0x9C, 0x03]),
466 new Uint8Array(base64Binary("KA==")),
467 new Uint8Array([0x28]),
471 new Uint8Array(base64Binary("1g==")),
472 new Uint8Array([0xD6]),
476 new Uint16Array(base64Binary("1vg")),
477 new Uint16Array([0xF8D6]),
481 new Uint8Array(base64Binary("1vgA")),
482 new Uint8Array([0xD6, 0xF8, 0x00]),
486 new Uint8Array(base64Binary("1vgQ")),
487 new Uint8Array([0xD6, 0xF8, 0x10]),
491 new Uint32Array(base64Binary("1vgRDA==")),
492 new Uint32Array([0x0C11F8D6]),
496 new Uint8Array(base64Binary("1vgRDIA=")),
497 new Uint8Array([0xD6, 0xF8, 0x11, 0x0C, 0x80]),
501 new Uint16Array(base64Binary("1vgRDIUw")),
502 new Uint16Array([0xF8D6, 0x0C11, 0x3085]),
507 it("[[Call]] throws when provided with an invalid character", () => {
508 assertThrows(() => base64Binary("abc_"));
511 it("[[Call]] throws when provided with an invalid equals", () => {
512 assertThrows(() => base64Binary("abc=="));
515 it("[[Call]] throws when provided with a length with a remainder of 1 when divided by 4", () => {
516 assertThrows(() => base64Binary("abcde"));
517 assertThrows(() => base64Binary("abcde==="));
521 describe("base64String", () => {
522 it("[[Call]] returns the correct string", () => {
523 for (const [source
, { base64
}] of data
) {
524 assertStrictEquals(base64String(source
), base64
);
529 describe("filenameSafeBase64Binary", () => {
530 it("[[Call]] returns the correct data", () => {
532 new Uint8Array(filenameSafeBase64Binary("")),
537 new Uint8Array(filenameSafeBase64Binary("AGIAYQBzAGUANgA0")),
539 "\u{0}b\u{0}a\u{0}s\u{0}e\u{0}6\u{0}4",
540 ($) => $.charCodeAt(0),
545 new Uint16Array(filenameSafeBase64Binary("R_Q=")),
546 new Uint16Array([62535]),
550 new Uint8ClampedArray(filenameSafeBase64Binary("S0lCSQ==")),
551 new Uint8ClampedArray([75, 73, 66, 73]),
555 new Uint8Array(filenameSafeBase64Binary("YmFzZTY0")),
556 new Uint8Array([98, 97, 115, 101, 54, 52]),
560 new Uint8Array(filenameSafeBase64Binary("KA==")),
561 new Uint8Array([0x28]),
565 new Uint8Array(filenameSafeBase64Binary("1g==")),
566 new Uint8Array([0xD6]),
570 new Uint16Array(filenameSafeBase64Binary("1vg")),
571 new Uint16Array([0xF8D6]),
575 new Uint8Array(filenameSafeBase64Binary("1vgA")),
576 new Uint8Array([0xD6, 0xF8, 0x00]),
580 new Uint8Array(filenameSafeBase64Binary("1vgQ")),
581 new Uint8Array([0xD6, 0xF8, 0x10]),
585 new Uint32Array(filenameSafeBase64Binary("1vgQDA==")),
586 new Uint32Array([0x0C10F8D6]),
590 new Uint8Array(filenameSafeBase64Binary("1vgQDIA=")),
591 new Uint8Array([0xD6, 0xF8, 0x10, 0x0C, 0x80]),
595 new Uint16Array(filenameSafeBase64Binary("1vgQDIUw")),
596 new Uint16Array([0xF8D6, 0x0C10, 0x3085]),
601 it("[[Call]] throws when provided with an invalid character", () => {
602 assertThrows(() => filenameSafeBase64Binary("abc/"));
605 it("[[Call]] throws when provided with an invalid equals", () => {
606 assertThrows(() => filenameSafeBase64Binary("abc=="));
609 it("[[Call]] throws when provided with a length with a remainder of 1 when divided by 4", () => {
610 assertThrows(() => filenameSafeBase64Binary("abcde"));
611 assertThrows(() => filenameSafeBase64Binary("abcde==="));
615 describe("filenameSafeBase64String", () => {
616 it("[[Call]] returns the correct string", () => {
617 for (const [source
, { base64
}] of data
) {
619 filenameSafeBase64String(source
),
620 base64
.replace("+", "-").replace("/", "_"),
626 describe("isArrayBuffer", () => {
627 it("[[Call]] returns true for array buffers", () => {
629 isArrayBuffer(new ArrayBuffer()),
633 isArrayBuffer(new SharedArrayBuffer()),
638 it("[[Call]] returns false for others", () => {
651 new DataView(new ArrayBuffer()),
654 assertStrictEquals(isArrayBuffer(value
), false)
659 describe("isArrayBufferView", () => {
660 it("[[Call]] returns true for data views", () => {
662 isArrayBufferView(new DataView(new ArrayBuffer())),
667 it("[[Call]] returns true for typed arrays", () => {
669 isArrayBufferView(new Uint8ClampedArray()),
672 assertStrictEquals(isArrayBufferView(new BigInt64Array()), true);
675 it("[[Call]] returns false for others", () => {
689 new SharedArrayBuffer(),
691 assertStrictEquals(isArrayBufferView(value
), false)
696 describe("isBase16", () => {
697 it("[[Call]] returns true for base64 strings", () => {
698 for (const { base16
} of data
.values()) {
699 assertStrictEquals(isBase16(base16
), true);
700 assertStrictEquals(isBase16(base16
.toLowerCase()), true);
704 it("[[Call]] returns false for others", () => {
720 ].forEach((value
) => assertStrictEquals(isBase16(value
), false));
724 describe("isBase32", () => {
725 it("[[Call]] returns true for base32 strings", () => {
726 for (const { base32
} of data
.values()) {
727 assertStrictEquals(isBase32(base32
), true);
728 assertStrictEquals(isBase32(base32
.toLowerCase()), true);
732 it("[[Call]] returns false for others", () => {
747 ].forEach((value
) => assertStrictEquals(isBase32(value
), false));
751 describe("isBase64", () => {
752 it("[[Call]] returns true for base64 strings", () => {
753 for (const { base64
} of data
.values()) {
754 assertStrictEquals(isBase64(base64
), true);
758 it("[[Call]] returns false for others", () => {
773 ].forEach((value
) => assertStrictEquals(isBase64(value
), false));
777 describe("isFilenameSafeBase64", () => {
778 it("[[Call]] returns true for filename‐safe base64 strings", () => {
779 for (const { base64
} of data
.values()) {
781 isFilenameSafeBase64(
782 base64
.replace("+", "-").replace("/", "_"),
789 it("[[Call]] returns false for others", () => {
805 assertStrictEquals(isFilenameSafeBase64(value
), false)
810 describe("isSharedArrayBuffer", () => {
811 it("[[Call]] returns true for shared array buffers", () => {
813 isSharedArrayBuffer(new SharedArrayBuffer()),
818 it("[[Call]] returns false for others", () => {
832 new DataView(new ArrayBuffer()),
835 assertStrictEquals(isSharedArrayBuffer(value
), false)
840 describe("isTypedArray", () => {
841 it("[[Call]] returns true for typed arrays", () => {
843 isTypedArray(new Uint8Array()),
847 isTypedArray(new BigInt64Array()),
852 it("[[Call]] returns false for others", () => {
866 new SharedArrayBuffer(),
867 new DataView(new ArrayBuffer()),
869 assertStrictEquals(isTypedArray(value
), false)
874 describe("isWRMGBase32", () => {
875 it("[[Call]] returns true for W·R·M·G base32 strings", () => {
876 for (const { wrmg
} of data
.values()) {
877 assertStrictEquals(isWRMGBase32(wrmg
), true);
878 assertStrictEquals(isWRMGBase32(wrmg
.toLowerCase()), true);
879 assertStrictEquals(isWRMGBase32(`--${wrmg}--`), true);
881 isWRMGBase32(wrmg
.replaceAll(/1/gu
, "I")),
885 isWRMGBase32(wrmg
.replaceAll(/1/gu
, "L")),
889 isWRMGBase32(wrmg
.replaceAll(/0/gu
, "O")),
893 isWRMGBase32(wrmg
.replaceAll(/1/gu
, "i")),
897 isWRMGBase32(wrmg
.replaceAll(/1/gu
, "l")),
901 isWRMGBase32(wrmg
.replaceAll(/0/gu
, "o")),
905 isWRMGBase32(wrmg
.replaceAll(/./gu
, ($) => {
906 const rand
= Math
.random();
920 it("[[Call]] returns false for others", () => {
936 assertStrictEquals(isWRMGBase32(value
), false)
941 describe("toArrayBuffer", () => {
942 it("[[Call]] returns the argument for array buffers", () => {
943 const buffer
= new ArrayBuffer();
944 assertStrictEquals(toArrayBuffer(buffer
), buffer
);
947 it("[[Call]] returns the buffer for data views", () => {
948 const src
= Uint8Array
.from([2, 3, 1]);
949 const buffer
= toArrayBuffer(new DataView(src
.buffer
));
950 assert(buffer
instanceof ArrayBuffer
);
951 assertEquals(new Uint8Array(buffer
), src
);
954 it("[[Call]] returns the buffer for typed arrays", () => {
955 const src
= Uint8Array
.from([2, 3, 1]);
956 const buffer
= toArrayBuffer(src
);
957 assert(buffer
instanceof ArrayBuffer
);
958 assertEquals(new Uint8Array(buffer
), src
);
961 it("[[Call]] throws for others", () => {
976 toArrayBuffer(value
);
982 describe("wrmgBase32Binary", () => {
983 it("[[Call]] returns the correct data", () => {
985 new Uint8Array(wrmgBase32Binary("")),
990 new Uint8Array(wrmgBase32Binary("01H00R80EC06A01P00T0")),
992 "\u{0}b\u{0}a\u{0}s\u{0}e\u{0}6\u{0}4",
993 ($) => $.charCodeAt(0),
995 "01H00R80EC06A01P00T0",
998 new Uint16Array(wrmgBase32Binary("8ZT0")),
999 new Uint16Array([62535]),
1003 new Uint8ClampedArray(wrmgBase32Binary("9D4M4J8")),
1004 new Uint8ClampedArray([75, 73, 66, 73]),
1008 new Uint8Array(wrmgBase32Binary("C9GQ6S9P6G")),
1009 new Uint8Array([98, 97, 115, 101, 54, 52]),
1013 new Uint8Array(wrmgBase32Binary("2KXSR0YSFR")),
1014 new Uint8Array([0x14, 0xFB, 0x9C, 0x03, 0xD9, 0x7E]),
1018 new Uint8Array(wrmgBase32Binary("2KXSR0YS")),
1019 new Uint8Array([0x14, 0xFB, 0x9C, 0x03, 0xD9]),
1023 new Uint8Array(wrmgBase32Binary("2KXSR0R")),
1024 new Uint8Array([0x14, 0xFB, 0x9C, 0x03]),
1028 new Uint8Array(wrmgBase32Binary("50")),
1029 new Uint8Array([0x28]),
1033 new Uint8Array(wrmgBase32Binary("TR")),
1034 new Uint8Array([0xD6]),
1038 new Uint16Array(wrmgBase32Binary("TVW0")),
1039 new Uint16Array([0xF8D6]),
1043 new Uint8Array(wrmgBase32Binary("TVW00")),
1044 new Uint8Array([0xD6, 0xF8, 0x00]),
1048 new Uint8Array(wrmgBase32Binary("TVW10")),
1049 new Uint8Array([0xD6, 0xF8, 0x10]),
1053 new Uint32Array(wrmgBase32Binary("TVW1230")),
1054 new Uint32Array([0x0C11F8D6]),
1058 new Uint8Array(wrmgBase32Binary("TVW12340")),
1059 new Uint8Array([0xD6, 0xF8, 0x11, 0x0C, 0x80]),
1063 new Uint16Array(wrmgBase32Binary("TVW1234560")),
1064 new Uint16Array([0xF8D6, 0x0C11, 0x3085]),
1069 it("[[Call]] is case‐insensitive", () => {
1071 new Uint8Array(wrmgBase32Binary("tVw12340")),
1072 new Uint8Array([0xD6, 0xF8, 0x11, 0x0C, 0x80]),
1077 it("[[Call]] casts I, L & O", () => {
1079 new Uint8Array(wrmgBase32Binary("TVWI234O")),
1080 new Uint8Array([0xD6, 0xF8, 0x11, 0x0C, 0x80]),
1084 new Uint8Array(wrmgBase32Binary("TVWi234o")),
1085 new Uint8Array([0xD6, 0xF8, 0x11, 0x0C, 0x80]),
1089 new Uint8Array(wrmgBase32Binary("TVWL234O")),
1090 new Uint8Array([0xD6, 0xF8, 0x11, 0x0C, 0x80]),
1094 new Uint8Array(wrmgBase32Binary("TVWl234o")),
1095 new Uint8Array([0xD6, 0xF8, 0x11, 0x0C, 0x80]),
1100 it("[[Call]] ignores hyphens", () => {
1102 new Uint8Array(wrmgBase32Binary("--TVW---123-40-----")),
1103 new Uint8Array([0xD6, 0xF8, 0x11, 0x0C, 0x80]),
1104 "--TVW---123-40-----",
1108 it("[[Call]] throws when provided with an invalid character", () => {
1109 assertThrows(() => wrmgBase32Binary("ABCu"));
1110 assertThrows(() => wrmgBase32Binary("ABCU"));
1111 assertThrows(() => wrmgBase32Binary("ABC="));
1114 it("[[Call]] throws when provided with a length with a remainder of 1, 3 ∣ 6 when divided by 8", () => {
1115 assertThrows(() => base32Binary("TVW123400"));
1116 assertThrows(() => base32Binary("TVW123400======="));
1117 assertThrows(() => base32Binary("M78"));
1118 assertThrows(() => base32Binary("M78M93"));
1121 it("[[Call]] throws when provided with a length with a remainder of 1 when divided by 4", () => {
1122 assertThrows(() => wrmgBase32Binary("234BCDEAA"));
1123 assertThrows(() => wrmgBase32Binary("2-34-B--CD-EA-A-"));
1127 describe("wrmgBase32String", () => {
1128 it("[[Call]] returns the correct string", () => {
1129 for (const [source
, { wrmg
}] of data
) {
1130 assertStrictEquals(wrmgBase32String(source
), wrmg
);
This page took 0.193778 seconds and 3 git commands to generate.