1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
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();
|
