| assertEq(isLatin1("Foo123\u1200"), false); |
| |
| s = "Foo123"; |
| assertEq(isLatin1(s), true); |
| |
| function testEq(s) { |
| assertEq(isLatin1(s), true); |
| assertEq(s === "foo02", false); |
| assertEq(s == "foo02", false); |
| |
| // Non-atomized to force char comparison. |
| var nonAtomized = "\u1234foo01\u00c7".substr(1); |
| assertEq(isLatin1(nonAtomized), false); |
| assertEq(s === nonAtomized, true); |
| assertEq(nonAtomized !== s, false); |
| assertEq(nonAtomized == s, true); |
| assertEq(s, nonAtomized); |
| |
| nonAtomized = "\u1234foo02".substr(1); |
| assertEq(isLatin1(nonAtomized), false); |
| assertEq(s === nonAtomized, false); |
| assertEq(nonAtomized == s, false); |
| } |
| |
| s = "foo01\u00c7"; |
| testEq(s); |
| testEq(s); |
| |
| function testConcat() { |
| function concat(s1, s2) { |
| return s1 + s2; |
| } |
| |
| // Following tests create fat inline strings. |
| assertEq(concat("abc", "def"), "abcdef"); |
| var s1 = "ABC"; |
| var s2 = "DEF"; |
| assertEq(concat(s1, s2), "ABCDEF"); |
| assertEq(concat(s1, "GHI\u0580"), "ABCGHI\u0580"); |
| assertEq(concat("GHI\u0580", s2), "GHI\u0580DEF"); |
| assertEq(concat(concat("GHI\u0580", s2), s1), "GHI\u0580DEFABC"); |
| assertEq(isLatin1(s1), true); |
| assertEq(isLatin1(s2), true); |
| |
| // Create a Latin1 rope. |
| var s3 = "0123456789012345678901234567890123456789"; |
| var rope = concat(s1, s3); |
| assertEq(isLatin1(rope), true); |
| assertEq(rope, "ABC0123456789012345678901234567890123456789"); |
| assertEq(isLatin1(rope), true); // Still Latin1 after flattening. |
| |
| // Latin1 + TwoByte => TwoByte rope. |
| assertEq(isLatin1(s3), true); |
| rope = concat(s3, "someTwoByteString\u0580"); |
| assertEq(isLatin1(rope), false); |
| assertEq(rope, "0123456789012345678901234567890123456789someTwoByteString\u0580"); |
| assertEq(isLatin1(rope), false); |
| |
| assertEq(isLatin1(s3), true); |
| rope = concat("twoByteString\u0580", concat(s3, "otherTwoByte\u0580")); |
| assertEq(isLatin1(rope), false); |
| assertEq(rope, "twoByteString\u05800123456789012345678901234567890123456789otherTwoByte\u0580"); |
| assertEq(isLatin1(rope), false); |
| |
| // Build a Latin1 rope with left-most string an extensible string. |
| var s4 = "adsfasdfjkasdfkjasdfasasdfasdf"; |
| for (var i=0; i<5; i++) { |
| s4 = concat(s4, s1); |
| assertEq(s4 === ".".repeat(s4.length), false); // Flatten rope. |
| } |
| |
| assertEq(isLatin1(s4), true); |
| |
| // Appending a TwoByte string must inflate. |
| s4 = concat(s4, "--\u0580"); |
| assertEq(s4, "adsfasdfjkasdfkjasdfasasdfasdfABCABCABCABCABC--\u0580"); |
| } |
| testConcat(); |
| |
| function testFlattenDependent() { |
| function concat(s1, s2) { |
| return s1 + s2; |
| } |
| |
| // Create some latin1 strings. |
| var s1 = "Foo0123456789bar012345---"; |
| var s2 = "Foo0123456789bar012345+++"; |
| assertEq(isLatin1(s1), true); |
| assertEq(isLatin1(s2), true); |
| |
| // And some ropes. |
| var rope1 = concat(s1, s1); |
| assertEq(isLatin1(rope1), true); |
| |
| var rope2 = concat(rope1, s2); |
| assertEq(isLatin1(rope2), true); |
| |
| var rope3 = concat("twoByte\u0581", rope2); |
| assertEq(isLatin1(rope3), false); |
| |
| // Flatten everything. |
| assertEq(rope3, "twoByte\u0581Foo0123456789bar012345---Foo0123456789bar012345---Foo0123456789bar012345+++"); |
| assertEq(isLatin1(rope3), false); |
| |
| // rope1 and rope2 were Latin1, but flattening rope3 turned them into |
| // dependent strings, so rope1 and rope2 must also be TwoByte now. |
| assertEq(isLatin1(rope1), false); |
| assertEq(isLatin1(rope2), false); |
| |
| assertEq(rope1, "Foo0123456789bar012345---Foo0123456789bar012345---"); |
| assertEq(rope2, "Foo0123456789bar012345---Foo0123456789bar012345---Foo0123456789bar012345+++"); |
| } |
| testFlattenDependent(); |