X-Git-Url: https://git.ladys.computer/Pisces/blobdiff_plain/5f5b986d80f54cca184a03a7f5ddb17a19abacbf..refs/heads/current:/string.test.js diff --git a/string.test.js b/string.test.js index 4f257f9..ee0e209 100644 --- a/string.test.js +++ b/string.test.js @@ -20,6 +20,7 @@ import { import { asciiLowercase, asciiUppercase, + canonicalNumericIndexString, characters, codepoints, codeUnits, @@ -28,12 +29,13 @@ import { getCodeUnit, getFirstSubstringIndex, getLastSubstringIndex, + isArrayIndexString, + isIntegerIndexString, join, Matcher, rawString, scalarValues, - scalarValueString, - splitOnASCIIWhitespace, + splitOnAsciiWhitespace, splitOnCommas, stringCatenate, stringEndsWith, @@ -53,9 +55,10 @@ import { stringSplit, stringStartsWith, stringValue, - stripAndCollapseASCIIWhitespace, - stripLeadingAndTrailingASCIIWhitespace, + stripAndCollapseAsciiWhitespace, + stripLeadingAndTrailingAsciiWhitespace, substring, + toScalarValueString, toString, } from "./string.js"; @@ -107,6 +110,12 @@ describe("Matcher", () => { }); }); + describe("::constructor", () => { + it("[[Get]] returns the same constructor", () => { + assertStrictEquals(new Matcher(/(?:)/su).constructor, Matcher); + }); + }); + describe("::dotAll", () => { it("[[Get]] returns true when the dotAll flag is present", () => { assertStrictEquals(new Matcher(/(?:)/su).dotAll, true); @@ -559,6 +568,59 @@ describe("asciiUppercase", () => { }); }); +describe("canonicalNumericIndexString", () => { + it("[[Call]] returns undefined for nonstrings", () => { + assertStrictEquals(canonicalNumericIndexString(1), void {}); + }); + + it("[[Call]] returns undefined for noncanonical strings", () => { + assertStrictEquals(canonicalNumericIndexString(""), void {}); + assertStrictEquals(canonicalNumericIndexString("01"), void {}); + assertStrictEquals( + canonicalNumericIndexString("9007199254740993"), + void {}, + ); + }); + + it('[[Call]] returns -0 for "-0"', () => { + assertStrictEquals(canonicalNumericIndexString("-0"), -0); + }); + + it("[[Call]] returns the corresponding number for canonical strings", () => { + assertStrictEquals(canonicalNumericIndexString("0"), 0); + assertStrictEquals(canonicalNumericIndexString("-0.25"), -0.25); + assertStrictEquals( + canonicalNumericIndexString("9007199254740992"), + 9007199254740992, + ); + assertStrictEquals(canonicalNumericIndexString("NaN"), 0 / 0); + assertStrictEquals(canonicalNumericIndexString("Infinity"), 1 / 0); + assertStrictEquals( + canonicalNumericIndexString("-Infinity"), + -1 / 0, + ); + }); + + it("[[Construct]] throws an error", () => { + assertThrows(() => new canonicalNumericIndexString("")); + }); + + describe(".length", () => { + it("[[Get]] returns the correct length", () => { + assertStrictEquals(canonicalNumericIndexString.length, 1); + }); + }); + + describe(".name", () => { + it("[[Get]] returns the correct name", () => { + assertStrictEquals( + canonicalNumericIndexString.name, + "canonicalNumericIndexString", + ); + }); + }); +}); + describe("characters", () => { it("[[Call]] returns an iterable", () => { assertStrictEquals( @@ -879,82 +941,182 @@ describe("getLastSubstringIndex", () => { }); }); -describe("join", () => { - it("[[Call]] joins the provided iterator with the provided separartor", () => { - assertStrictEquals(join([1, 2, 3, 4].values(), "☂"), "1☂2☂3☂4"); +describe("isArrayIndexString", () => { + it("[[Call]] returns false for nonstrings", () => { + assertStrictEquals(isArrayIndexString(1), false); }); - it('[[Call]] uses "," if no separator is provided', () => { - assertStrictEquals(join([1, 2, 3, 4].values()), "1,2,3,4"); + it("[[Call]] returns false for noncanonical strings", () => { + assertStrictEquals(isArrayIndexString(""), false); + assertStrictEquals(isArrayIndexString("01"), false); + assertStrictEquals(isArrayIndexString("9007199254740993"), false); }); - it("[[Call]] uses the empty sting for nullish values", () => { + it("[[Call]] returns false for nonfinite numbers", () => { + assertStrictEquals(isArrayIndexString("NaN"), false); + assertStrictEquals(isArrayIndexString("Infinity"), false); + assertStrictEquals(isArrayIndexString("-Infinity"), false); + }); + + it("[[Call]] returns false for negative numbers", () => { + assertStrictEquals(isArrayIndexString("-0"), false); + assertStrictEquals(isArrayIndexString("-1"), false); + }); + + it("[[Call]] returns false for nonintegers", () => { + assertStrictEquals(isArrayIndexString("0.25"), false); + assertStrictEquals(isArrayIndexString("1.1"), false); + }); + + it("[[Call]] returns false for numbers greater than or equal to -1 >>> 0", () => { + assertStrictEquals(isArrayIndexString(String(-1 >>> 0)), false); assertStrictEquals( - join([null, , null, undefined].values(), "☂"), - "☂☂☂", + isArrayIndexString(String((-1 >>> 0) + 1)), + false, + ); + }); + + it("[[Call]] returns true for array lengths less than -1 >>> 0", () => { + assertStrictEquals(isArrayIndexString("0"), true); + assertStrictEquals( + isArrayIndexString(String((-1 >>> 0) - 1)), + true, ); }); it("[[Construct]] throws an error", () => { - assertThrows(() => new join([])); + assertThrows(() => new isArrayIndexString("0")); }); describe(".length", () => { it("[[Get]] returns the correct length", () => { - assertStrictEquals(join.length, 2); + assertStrictEquals(isArrayIndexString.length, 1); }); }); describe(".name", () => { it("[[Get]] returns the correct name", () => { - assertStrictEquals(join.name, "join"); + assertStrictEquals( + isArrayIndexString.name, + "isArrayIndexString", + ); }); }); }); -describe("rawString", () => { - it("[[Call]] acts like String.raw", () => { - assertStrictEquals(rawString`\nraw${" string"}`, "\\nraw string"); +describe("isIntegerIndexString", () => { + it("[[Call]] returns false for nonstrings", () => { + assertStrictEquals(isIntegerIndexString(1), false); + }); + + it("[[Call]] returns false for noncanonical strings", () => { + assertStrictEquals(isIntegerIndexString(""), false); + assertStrictEquals(isIntegerIndexString("01"), false); + assertStrictEquals( + isIntegerIndexString("9007199254740993"), + false, + ); + }); + + it("[[Call]] returns false for nonfinite numbers", () => { + assertStrictEquals(isIntegerIndexString("NaN"), false); + assertStrictEquals(isIntegerIndexString("Infinity"), false); + assertStrictEquals(isIntegerIndexString("-Infinity"), false); + }); + + it("[[Call]] returns false for negative numbers", () => { + assertStrictEquals(isIntegerIndexString("-0"), false); + assertStrictEquals(isIntegerIndexString("-1"), false); + }); + + it("[[Call]] returns false for nonintegers", () => { + assertStrictEquals(isIntegerIndexString("0.25"), false); + assertStrictEquals(isIntegerIndexString("1.1"), false); + }); + + it("[[Call]] returns false for numbers greater than or equal to 2 ** 53", () => { + assertStrictEquals( + isIntegerIndexString("9007199254740992"), + false, + ); + }); + + it("[[Call]] returns true for safe canonical integer strings", () => { + assertStrictEquals(isIntegerIndexString("0"), true); + assertStrictEquals(isIntegerIndexString("9007199254740991"), true); }); it("[[Construct]] throws an error", () => { - assertThrows(() => new rawString(["string"])); + assertThrows(() => new isIntegerIndexString("0")); }); describe(".length", () => { it("[[Get]] returns the correct length", () => { - assertStrictEquals(rawString.length, 1); + assertStrictEquals(isIntegerIndexString.length, 1); }); }); describe(".name", () => { it("[[Get]] returns the correct name", () => { - assertStrictEquals(rawString.name, "rawString"); + assertStrictEquals( + isIntegerIndexString.name, + "isIntegerIndexString", + ); }); }); }); -describe("scalarValueString", () => { - it("[[Call]] replaces invalid values", () => { +describe("join", () => { + it("[[Call]] joins the provided iterator with the provided separartor", () => { + assertStrictEquals(join([1, 2, 3, 4].values(), "☂"), "1☂2☂3☂4"); + }); + + it('[[Call]] uses "," if no separator is provided', () => { + assertStrictEquals(join([1, 2, 3, 4].values()), "1,2,3,4"); + }); + + it("[[Call]] uses the empty sting for nullish values", () => { assertStrictEquals( - scalarValueString("Ii🎙\uDFFF\uDD96\uD83C\uD800🆗☺"), - "Ii🎙\uFFFD\uFFFD\uFFFD\uFFFD🆗☺", + join([null, , null, undefined].values(), "☂"), + "☂☂☂", ); }); it("[[Construct]] throws an error", () => { - assertThrows(() => new scalarValueString("")); + assertThrows(() => new join([])); + }); + + describe(".length", () => { + it("[[Get]] returns the correct length", () => { + assertStrictEquals(join.length, 2); + }); + }); + + describe(".name", () => { + it("[[Get]] returns the correct name", () => { + assertStrictEquals(join.name, "join"); + }); + }); +}); + +describe("rawString", () => { + it("[[Call]] acts like String.raw", () => { + assertStrictEquals(rawString`\nraw${" string"}`, "\\nraw string"); + }); + + it("[[Construct]] throws an error", () => { + assertThrows(() => new rawString(["string"])); }); describe(".length", () => { it("[[Get]] returns the correct length", () => { - assertStrictEquals(scalarValueString.length, 1); + assertStrictEquals(rawString.length, 1); }); }); describe(".name", () => { it("[[Get]] returns the correct name", () => { - assertStrictEquals(scalarValueString.name, "scalarValueString"); + assertStrictEquals(rawString.name, "rawString"); }); }); }); @@ -1011,67 +1173,67 @@ describe("scalarValues", () => { }); }); -describe("splitOnASCIIWhitespace", () => { +describe("splitOnAsciiWhitespace", () => { it("[[Call]] splits on sequences of spaces", () => { assertEquals( - splitOnASCIIWhitespace("🅰️ 🅱️ 🆎 🅾️"), + splitOnAsciiWhitespace("🅰️ 🅱️ 🆎 🅾️"), ["🅰️", "🅱️", "🆎", "🅾️"], ); }); it("[[Call]] splits on sequences of tabs", () => { assertEquals( - splitOnASCIIWhitespace("🅰️\t\t\t🅱️\t🆎\t\t🅾️"), + splitOnAsciiWhitespace("🅰️\t\t\t🅱️\t🆎\t\t🅾️"), ["🅰️", "🅱️", "🆎", "🅾️"], ); }); it("[[Call]] splits on sequences of carriage returns", () => { assertEquals( - splitOnASCIIWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"), + splitOnAsciiWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"), ["🅰️", "🅱️", "🆎", "🅾️"], ); }); it("[[Call]] splits on sequences of newlines", () => { assertEquals( - splitOnASCIIWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"), + splitOnAsciiWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"), ["🅰️", "🅱️", "🆎", "🅾️"], ); }); it("[[Call]] splits on sequences of form feeds", () => { assertEquals( - splitOnASCIIWhitespace("🅰️\f\f\f🅱️\f🆎\f\f🅾️"), + splitOnAsciiWhitespace("🅰️\f\f\f🅱️\f🆎\f\f🅾️"), ["🅰️", "🅱️", "🆎", "🅾️"], ); }); it("[[Call]] splits on mixed whitespace", () => { assertEquals( - splitOnASCIIWhitespace("🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️"), + splitOnAsciiWhitespace("🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️"), ["🅰️", "🅱️", "🆎", "🅾️"], ); }); it("[[Call]] returns an array of just the empty string for the empty string", () => { - assertEquals(splitOnASCIIWhitespace(""), [""]); + assertEquals(splitOnAsciiWhitespace(""), [""]); }); it("[[Call]] returns a single token if there are no spaces", () => { - assertEquals(splitOnASCIIWhitespace("abcd"), ["abcd"]); + assertEquals(splitOnAsciiWhitespace("abcd"), ["abcd"]); }); it("[[Call]] does not split on other kinds of whitespace", () => { assertEquals( - splitOnASCIIWhitespace("a\u202F\u205F\xa0\v\0\bb"), + splitOnAsciiWhitespace("a\u202F\u205F\xa0\v\0\bb"), ["a\u202F\u205F\xa0\v\0\bb"], ); }); it("[[Call]] trims leading and trailing whitespace", () => { assertEquals( - splitOnASCIIWhitespace( + splitOnAsciiWhitespace( "\f\r\n\r\n \n\t🅰️\f \t\n🅱️\r🆎\n\f🅾️\n\f", ), ["🅰️", "🅱️", "🆎", "🅾️"], @@ -1079,20 +1241,20 @@ describe("splitOnASCIIWhitespace", () => { }); it("[[Construct]] throws an error", () => { - assertThrows(() => new splitOnASCIIWhitespace("")); + assertThrows(() => new splitOnAsciiWhitespace("")); }); describe(".length", () => { it("[[Get]] returns the correct length", () => { - assertStrictEquals(splitOnASCIIWhitespace.length, 1); + assertStrictEquals(splitOnAsciiWhitespace.length, 1); }); }); describe(".name", () => { it("[[Get]] returns the correct name", () => { assertStrictEquals( - splitOnASCIIWhitespace.name, - "splitOnASCIIWhitespace", + splitOnAsciiWhitespace.name, + "splitOnAsciiWhitespace", ); }); }); @@ -1778,17 +1940,17 @@ describe("stringStartsWith", () => { }); }); -describe("stripAndCollapseASCIIWhitespace", () => { +describe("stripAndCollapseAsciiWhitespace", () => { it("[[Call]] collapses mixed inner whitespace", () => { assertEquals( - stripAndCollapseASCIIWhitespace("🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️"), + stripAndCollapseAsciiWhitespace("🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️"), "🅰️ 🅱️ 🆎 🅾️", ); }); it("[[Call]] trims leading and trailing whitespace", () => { assertStrictEquals( - stripAndCollapseASCIIWhitespace( + stripAndCollapseAsciiWhitespace( "\f\r\n\r\n \n\t\f 🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️\n\f", ), "🅰️ 🅱️ 🆎 🅾️", @@ -1797,42 +1959,42 @@ describe("stripAndCollapseASCIIWhitespace", () => { it("[[Call]] returns the empty string for strings of whitespace", () => { assertStrictEquals( - stripAndCollapseASCIIWhitespace("\f\r\n\r\n \n\t\f \n\f"), + stripAndCollapseAsciiWhitespace("\f\r\n\r\n \n\t\f \n\f"), "", ); }); it("[[Call]] does not collapse other kinds of whitespace", () => { assertEquals( - stripAndCollapseASCIIWhitespace("a\u202F\u205F\xa0\v\0\bb"), + stripAndCollapseAsciiWhitespace("a\u202F\u205F\xa0\v\0\bb"), "a\u202F\u205F\xa0\v\0\bb", ); }); it("[[Construct]] throws an error", () => { - assertThrows(() => new stripAndCollapseASCIIWhitespace("")); + assertThrows(() => new stripAndCollapseAsciiWhitespace("")); }); describe(".length", () => { it("[[Get]] returns the correct length", () => { - assertStrictEquals(stripAndCollapseASCIIWhitespace.length, 1); + assertStrictEquals(stripAndCollapseAsciiWhitespace.length, 1); }); }); describe(".name", () => { it("[[Get]] returns the correct name", () => { assertStrictEquals( - stripAndCollapseASCIIWhitespace.name, - "stripAndCollapseASCIIWhitespace", + stripAndCollapseAsciiWhitespace.name, + "stripAndCollapseAsciiWhitespace", ); }); }); }); -describe("stripLeadingAndTrailingASCIIWhitespace", () => { +describe("stripLeadingAndTrailingAsciiWhitespace", () => { it("[[Call]] trims leading and trailing whitespace", () => { assertStrictEquals( - stripLeadingAndTrailingASCIIWhitespace( + stripLeadingAndTrailingAsciiWhitespace( "\f\r\n\r\n \n\t\f 🅰️🅱️🆎🅾️\n\f", ), "🅰️🅱️🆎🅾️", @@ -1841,14 +2003,14 @@ describe("stripLeadingAndTrailingASCIIWhitespace", () => { it("[[Call]] returns the empty string for strings of whitespace", () => { assertStrictEquals( - stripLeadingAndTrailingASCIIWhitespace("\f\r\n\r\n \n\t\f \n\f"), + stripLeadingAndTrailingAsciiWhitespace("\f\r\n\r\n \n\t\f \n\f"), "", ); }); it("[[Call]] does not trim other kinds of whitespace", () => { assertEquals( - stripLeadingAndTrailingASCIIWhitespace( + stripLeadingAndTrailingAsciiWhitespace( "\v\u202F\u205Fx\0\b\xa0", ), "\v\u202F\u205Fx\0\b\xa0", @@ -1857,19 +2019,19 @@ describe("stripLeadingAndTrailingASCIIWhitespace", () => { it("[[Call]] does not adjust inner whitespace", () => { assertEquals( - stripLeadingAndTrailingASCIIWhitespace("a b"), + stripLeadingAndTrailingAsciiWhitespace("a b"), "a b", ); }); it("[[Construct]] throws an error", () => { - assertThrows(() => new stripLeadingAndTrailingASCIIWhitespace("")); + assertThrows(() => new stripLeadingAndTrailingAsciiWhitespace("")); }); describe(".length", () => { it("[[Get]] returns the correct length", () => { assertStrictEquals( - stripLeadingAndTrailingASCIIWhitespace.length, + stripLeadingAndTrailingAsciiWhitespace.length, 1, ); }); @@ -1878,8 +2040,8 @@ describe("stripLeadingAndTrailingASCIIWhitespace", () => { describe(".name", () => { it("[[Get]] returns the correct name", () => { assertStrictEquals( - stripLeadingAndTrailingASCIIWhitespace.name, - "stripLeadingAndTrailingASCIIWhitespace", + stripLeadingAndTrailingAsciiWhitespace.name, + "stripLeadingAndTrailingAsciiWhitespace", ); }); }); @@ -1914,6 +2076,34 @@ describe("substring", () => { }); }); +describe("toScalarValueString", () => { + it("[[Call]] replaces invalid values", () => { + assertStrictEquals( + toScalarValueString("Ii🎙\uDFFF\uDD96\uD83C\uD800🆗☺"), + "Ii🎙\uFFFD\uFFFD\uFFFD\uFFFD🆗☺", + ); + }); + + it("[[Construct]] throws an error", () => { + assertThrows(() => new toScalarValueString("")); + }); + + describe(".length", () => { + it("[[Get]] returns the correct length", () => { + assertStrictEquals(toScalarValueString.length, 1); + }); + }); + + describe(".name", () => { + it("[[Get]] returns the correct name", () => { + assertStrictEquals( + toScalarValueString.name, + "toScalarValueString", + ); + }); + }); +}); + describe("toString", () => { it("[[Call]] converts to a string", () => { assertStrictEquals(