OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "core/editing/state_machines/ForwardGraphemeBoundaryStateMachine.h" | 5 #include "core/editing/state_machines/ForwardGraphemeBoundaryStateMachine.h" |
6 | 6 |
7 #include "core/editing/state_machines/StateMachineTestUtil.h" | 7 #include "core/editing/state_machines/StateMachineTestUtil.h" |
8 #include "testing/gtest/include/gtest/gtest.h" | 8 #include "testing/gtest/include/gtest/gtest.h" |
9 #include "wtf/text/CharacterNames.h" | 9 #include "wtf/text/CharacterNames.h" |
10 | 10 |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
54 ForwardGraphemeBoundaryStateMachine machine; | 54 ForwardGraphemeBoundaryStateMachine machine; |
55 | 55 |
56 EXPECT_EQ(0, machine.finalizeAndGetBoundaryOffset()); | 56 EXPECT_EQ(0, machine.finalizeAndGetBoundaryOffset()); |
57 EXPECT_EQ(0, machine.finalizeAndGetBoundaryOffset()); | 57 EXPECT_EQ(0, machine.finalizeAndGetBoundaryOffset()); |
58 } | 58 } |
59 | 59 |
60 TEST_F(ForwardGraphemeBoundaryStatemachineTest, PrecedingText) { | 60 TEST_F(ForwardGraphemeBoundaryStatemachineTest, PrecedingText) { |
61 ForwardGraphemeBoundaryStateMachine machine; | 61 ForwardGraphemeBoundaryStateMachine machine; |
62 // Preceding text should not affect the result except for flags. | 62 // Preceding text should not affect the result except for flags. |
63 // SOT + | + 'a' + 'a' | 63 // SOT + | + 'a' + 'a' |
64 EXPECT_EQ("SRF", processSequenceForward(&machine, asCodePoints(), | 64 EXPECT_EQ( |
65 asCodePoints('a', 'a'))); | 65 "SRF", |
| 66 processSequenceForward(&machine, asCodePoints(), asCodePoints('a', 'a'))); |
66 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 67 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
67 // SOT + [U] + | + 'a' + 'a' | 68 // SOT + [U] + | + 'a' + 'a' |
68 EXPECT_EQ("RRSRF", processSequenceForward(&machine, asCodePoints(kRisU), | 69 EXPECT_EQ("RRSRF", |
69 asCodePoints('a', 'a'))); | 70 processSequenceForward(&machine, asCodePoints(kRisU), |
| 71 asCodePoints('a', 'a'))); |
70 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 72 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
71 // SOT + [U] + [S] + | + 'a' + 'a' | 73 // SOT + [U] + [S] + | + 'a' + 'a' |
72 EXPECT_EQ("RRRRSRF", | 74 EXPECT_EQ("RRRRSRF", |
73 processSequenceForward(&machine, asCodePoints(kRisU, kRisS), | 75 processSequenceForward(&machine, asCodePoints(kRisU, kRisS), |
74 asCodePoints('a', 'a'))); | 76 asCodePoints('a', 'a'))); |
75 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 77 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
76 | 78 |
77 // U+0000 + | + 'a' + 'a' | 79 // U+0000 + | + 'a' + 'a' |
78 EXPECT_EQ("SRF", processSequenceForward(&machine, asCodePoints(0), | 80 EXPECT_EQ("SRF", |
79 asCodePoints('a', 'a'))); | 81 processSequenceForward(&machine, asCodePoints(0), |
| 82 asCodePoints('a', 'a'))); |
80 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 83 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
81 // U+0000 + [U] + | + 'a' + 'a' | 84 // U+0000 + [U] + | + 'a' + 'a' |
82 EXPECT_EQ("RRSRF", processSequenceForward(&machine, asCodePoints(0, kRisU), | 85 EXPECT_EQ("RRSRF", |
83 asCodePoints('a', 'a'))); | 86 processSequenceForward(&machine, asCodePoints(0, kRisU), |
| 87 asCodePoints('a', 'a'))); |
84 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 88 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
85 // U+0000 + [U] + [S] + | + 'a' + 'a' | 89 // U+0000 + [U] + [S] + | + 'a' + 'a' |
86 EXPECT_EQ("RRRRSRF", | 90 EXPECT_EQ("RRRRSRF", |
87 processSequenceForward(&machine, asCodePoints(0, kRisU, kRisS), | 91 processSequenceForward(&machine, asCodePoints(0, kRisU, kRisS), |
88 asCodePoints('a', 'a'))); | 92 asCodePoints('a', 'a'))); |
89 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 93 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
90 | 94 |
91 // 'a' + | + 'a' + 'a' | 95 // 'a' + | + 'a' + 'a' |
92 EXPECT_EQ("SRF", processSequenceForward(&machine, asCodePoints('a'), | 96 EXPECT_EQ("SRF", |
93 asCodePoints('a', 'a'))); | 97 processSequenceForward(&machine, asCodePoints('a'), |
| 98 asCodePoints('a', 'a'))); |
94 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 99 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
95 // 'a' + [U] + | + 'a' + 'a' | 100 // 'a' + [U] + | + 'a' + 'a' |
96 EXPECT_EQ("RRSRF", processSequenceForward(&machine, asCodePoints('a', kRisU), | 101 EXPECT_EQ("RRSRF", |
97 asCodePoints('a', 'a'))); | 102 processSequenceForward(&machine, asCodePoints('a', kRisU), |
| 103 asCodePoints('a', 'a'))); |
98 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 104 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
99 // 'a' + [U] + [S] + | + 'a' + 'a' | 105 // 'a' + [U] + [S] + | + 'a' + 'a' |
100 EXPECT_EQ("RRRRSRF", | 106 EXPECT_EQ("RRRRSRF", |
101 processSequenceForward(&machine, asCodePoints('a', kRisU, kRisS), | 107 processSequenceForward(&machine, asCodePoints('a', kRisU, kRisS), |
102 asCodePoints('a', 'a'))); | 108 asCodePoints('a', 'a'))); |
103 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 109 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
104 | 110 |
105 // U+1F441 + | + 'a' + 'a' | 111 // U+1F441 + | + 'a' + 'a' |
106 EXPECT_EQ("RSRF", processSequenceForward(&machine, asCodePoints(kEye), | 112 EXPECT_EQ("RSRF", |
107 asCodePoints('a', 'a'))); | 113 processSequenceForward(&machine, asCodePoints(kEye), |
| 114 asCodePoints('a', 'a'))); |
108 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 115 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
109 // U+1F441 + [U] + | + 'a' + 'a' | 116 // U+1F441 + [U] + | + 'a' + 'a' |
110 EXPECT_EQ("RRRSRF", | 117 EXPECT_EQ("RRRSRF", |
111 processSequenceForward(&machine, asCodePoints(kEye, kRisU), | 118 processSequenceForward(&machine, asCodePoints(kEye, kRisU), |
112 asCodePoints('a', 'a'))); | 119 asCodePoints('a', 'a'))); |
113 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 120 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
114 // U+1F441 + [U] + [S] + | + 'a' + 'a' | 121 // U+1F441 + [U] + [S] + | + 'a' + 'a' |
115 EXPECT_EQ("RRRRRSRF", | 122 EXPECT_EQ("RRRRRSRF", |
116 processSequenceForward(&machine, asCodePoints(kEye, kRisU, kRisS), | 123 processSequenceForward(&machine, asCodePoints(kEye, kRisU, kRisS), |
117 asCodePoints('a', 'a'))); | 124 asCodePoints('a', 'a'))); |
118 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 125 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
119 | 126 |
120 // Broken surrogates in preceding text. | 127 // Broken surrogates in preceding text. |
121 | 128 |
122 // [Lead] + | + 'a' + 'a' | 129 // [Lead] + | + 'a' + 'a' |
123 EXPECT_EQ("SRF", processSequenceForward(&machine, asCodePoints(kLead), | 130 EXPECT_EQ("SRF", |
124 asCodePoints('a', 'a'))); | 131 processSequenceForward(&machine, asCodePoints(kLead), |
| 132 asCodePoints('a', 'a'))); |
125 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 133 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
126 // [Lead] + [U] + | + 'a' + 'a' | 134 // [Lead] + [U] + | + 'a' + 'a' |
127 EXPECT_EQ("RRSRF", | 135 EXPECT_EQ("RRSRF", |
128 processSequenceForward(&machine, asCodePoints(kLead, kRisU), | 136 processSequenceForward(&machine, asCodePoints(kLead, kRisU), |
129 asCodePoints('a', 'a'))); | 137 asCodePoints('a', 'a'))); |
130 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 138 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
131 // [Lead] + [U] + [S] + | + 'a' + 'a' | 139 // [Lead] + [U] + [S] + | + 'a' + 'a' |
132 EXPECT_EQ("RRRRSRF", | 140 EXPECT_EQ("RRRRSRF", |
133 processSequenceForward(&machine, asCodePoints(kLead, kRisU, kRisS), | 141 processSequenceForward(&machine, asCodePoints(kLead, kRisU, kRisS), |
134 asCodePoints('a', 'a'))); | 142 asCodePoints('a', 'a'))); |
135 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 143 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
136 | 144 |
137 // 'a' + [Trail] + | + 'a' + 'a' | 145 // 'a' + [Trail] + | + 'a' + 'a' |
138 EXPECT_EQ("RSRF", processSequenceForward(&machine, asCodePoints('a', kTrail), | 146 EXPECT_EQ("RSRF", |
139 asCodePoints('a', 'a'))); | 147 processSequenceForward(&machine, asCodePoints('a', kTrail), |
| 148 asCodePoints('a', 'a'))); |
140 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 149 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
141 // 'a' + [Trail] + [U] + | + 'a' + 'a' | 150 // 'a' + [Trail] + [U] + | + 'a' + 'a' |
142 EXPECT_EQ("RRRSRF", | 151 EXPECT_EQ("RRRSRF", |
143 processSequenceForward(&machine, asCodePoints('a', kTrail, kRisU), | 152 processSequenceForward(&machine, asCodePoints('a', kTrail, kRisU), |
144 asCodePoints('a', 'a'))); | 153 asCodePoints('a', 'a'))); |
145 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 154 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
146 // 'a' + [Trail] + [U] + [S] + | + 'a' + 'a' | 155 // 'a' + [Trail] + [U] + [S] + | + 'a' + 'a' |
147 EXPECT_EQ("RRRRRSRF", processSequenceForward( | 156 EXPECT_EQ( |
148 &machine, asCodePoints('a', kTrail, kRisU, kRisS), | 157 "RRRRRSRF", |
149 asCodePoints('a', 'a'))); | 158 processSequenceForward(&machine, asCodePoints('a', kTrail, kRisU, kRisS), |
| 159 asCodePoints('a', 'a'))); |
150 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 160 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
151 | 161 |
152 // [Trail] + [Trail] + | + 'a' + 'a' | 162 // [Trail] + [Trail] + | + 'a' + 'a' |
153 EXPECT_EQ("RSRF", | 163 EXPECT_EQ("RSRF", |
154 processSequenceForward(&machine, asCodePoints(kTrail, kTrail), | 164 processSequenceForward(&machine, asCodePoints(kTrail, kTrail), |
155 asCodePoints('a', 'a'))); | 165 asCodePoints('a', 'a'))); |
156 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 166 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
157 // [Trail] + [Trail] + [U] + | + 'a' + 'a' | 167 // [Trail] + [Trail] + [U] + | + 'a' + 'a' |
158 EXPECT_EQ("RRRSRF", processSequenceForward( | 168 EXPECT_EQ( |
159 &machine, asCodePoints(kTrail, kTrail, kRisU), | 169 "RRRSRF", |
160 asCodePoints('a', 'a'))); | 170 processSequenceForward(&machine, asCodePoints(kTrail, kTrail, kRisU), |
| 171 asCodePoints('a', 'a'))); |
161 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 172 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
162 // [Trail] + [Trail] + [U] + [S] + | + 'a' + 'a' | 173 // [Trail] + [Trail] + [U] + [S] + | + 'a' + 'a' |
163 EXPECT_EQ("RRRRRSRF", | 174 EXPECT_EQ("RRRRRSRF", |
164 processSequenceForward(&machine, | 175 processSequenceForward(&machine, |
165 asCodePoints(kTrail, kTrail, kRisU, kRisS), | 176 asCodePoints(kTrail, kTrail, kRisU, kRisS), |
166 asCodePoints('a', 'a'))); | 177 asCodePoints('a', 'a'))); |
167 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 178 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
168 | 179 |
169 // SOT + [Trail] + | + 'a' + 'a' | 180 // SOT + [Trail] + | + 'a' + 'a' |
170 EXPECT_EQ("RSRF", processSequenceForward(&machine, asCodePoints(kTrail), | 181 EXPECT_EQ("RSRF", |
171 asCodePoints('a', 'a'))); | 182 processSequenceForward(&machine, asCodePoints(kTrail), |
| 183 asCodePoints('a', 'a'))); |
172 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 184 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
173 // SOT + [Trail] + [U] + | + 'a' + 'a' | 185 // SOT + [Trail] + [U] + | + 'a' + 'a' |
174 EXPECT_EQ("RRRSRF", | 186 EXPECT_EQ("RRRSRF", |
175 processSequenceForward(&machine, asCodePoints(kTrail, kRisU), | 187 processSequenceForward(&machine, asCodePoints(kTrail, kRisU), |
176 asCodePoints('a', 'a'))); | 188 asCodePoints('a', 'a'))); |
177 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 189 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
178 // SOT + [Trail] + [U] + [S] + | + 'a' + 'a' | 190 // SOT + [Trail] + [U] + [S] + | + 'a' + 'a' |
179 EXPECT_EQ("RRRRRSRF", | 191 EXPECT_EQ("RRRRRSRF", |
180 processSequenceForward(&machine, asCodePoints(kTrail, kRisU, kRisS), | 192 processSequenceForward(&machine, asCodePoints(kTrail, kRisU, kRisS), |
181 asCodePoints('a', 'a'))); | 193 asCodePoints('a', 'a'))); |
182 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 194 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
183 } | 195 } |
184 | 196 |
185 TEST_F(ForwardGraphemeBoundaryStatemachineTest, BrokenSurrogatePair) { | 197 TEST_F(ForwardGraphemeBoundaryStatemachineTest, BrokenSurrogatePair) { |
186 ForwardGraphemeBoundaryStateMachine machine; | 198 ForwardGraphemeBoundaryStateMachine machine; |
187 // SOT + | + [Trail] | 199 // SOT + | + [Trail] |
188 EXPECT_EQ("SF", processSequenceForward(&machine, asCodePoints(), | 200 EXPECT_EQ( |
189 asCodePoints(kTrail))); | 201 "SF", |
| 202 processSequenceForward(&machine, asCodePoints(), asCodePoints(kTrail))); |
190 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 203 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
191 // SOT + | + [Lead] + 'a' | 204 // SOT + | + [Lead] + 'a' |
192 EXPECT_EQ("SRF", processSequenceForward(&machine, asCodePoints(), | 205 EXPECT_EQ("SRF", |
193 asCodePoints(kLead, 'a'))); | 206 processSequenceForward(&machine, asCodePoints(), |
| 207 asCodePoints(kLead, 'a'))); |
194 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 208 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
195 // SOT + | + [Lead] + [Lead] | 209 // SOT + | + [Lead] + [Lead] |
196 EXPECT_EQ("SRF", processSequenceForward(&machine, asCodePoints(), | 210 EXPECT_EQ("SRF", |
197 asCodePoints(kLead, kLead))); | 211 processSequenceForward(&machine, asCodePoints(), |
| 212 asCodePoints(kLead, kLead))); |
198 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 213 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
199 // SOT + | + [Lead] + EOT | 214 // SOT + | + [Lead] + EOT |
200 EXPECT_EQ("SR", processSequenceForward(&machine, asCodePoints(), | 215 EXPECT_EQ( |
201 asCodePoints(kLead))); | 216 "SR", |
| 217 processSequenceForward(&machine, asCodePoints(), asCodePoints(kLead))); |
202 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 218 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
203 } | 219 } |
204 | 220 |
205 TEST_F(ForwardGraphemeBoundaryStatemachineTest, BreakImmediately_BMP) { | 221 TEST_F(ForwardGraphemeBoundaryStatemachineTest, BreakImmediately_BMP) { |
206 ForwardGraphemeBoundaryStateMachine machine; | 222 ForwardGraphemeBoundaryStateMachine machine; |
207 | 223 |
208 // SOT + | + U+0000 + U+0000 | 224 // SOT + | + U+0000 + U+0000 |
209 EXPECT_EQ("SRF", processSequenceForward(&machine, asCodePoints(), | 225 EXPECT_EQ( |
210 asCodePoints(0, 0))); | 226 "SRF", |
| 227 processSequenceForward(&machine, asCodePoints(), asCodePoints(0, 0))); |
211 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 228 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
212 | 229 |
213 // SOT + | + 'a' + 'a' | 230 // SOT + | + 'a' + 'a' |
214 EXPECT_EQ("SRF", processSequenceForward(&machine, asCodePoints(), | 231 EXPECT_EQ( |
215 asCodePoints('a', 'a'))); | 232 "SRF", |
| 233 processSequenceForward(&machine, asCodePoints(), asCodePoints('a', 'a'))); |
216 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 234 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
217 | 235 |
218 // SOT + | + 'a' + U+1F441 | 236 // SOT + | + 'a' + U+1F441 |
219 EXPECT_EQ("SRRF", processSequenceForward(&machine, asCodePoints(), | 237 EXPECT_EQ("SRRF", |
220 asCodePoints('a', kEye))); | 238 processSequenceForward(&machine, asCodePoints(), |
| 239 asCodePoints('a', kEye))); |
221 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 240 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
222 | 241 |
223 // SOT + | + 'a' + EOT | 242 // SOT + | + 'a' + EOT |
224 EXPECT_EQ("SR", processSequenceForward(&machine, asCodePoints(), | 243 EXPECT_EQ( |
225 asCodePoints('a'))); | 244 "SR", |
| 245 processSequenceForward(&machine, asCodePoints(), asCodePoints('a'))); |
226 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 246 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
227 | 247 |
228 // SOT + | + 'a' + [Trail] | 248 // SOT + | + 'a' + [Trail] |
229 EXPECT_EQ("SRF", processSequenceForward(&machine, asCodePoints(), | 249 EXPECT_EQ("SRF", |
230 asCodePoints('a', kTrail))); | 250 processSequenceForward(&machine, asCodePoints(), |
| 251 asCodePoints('a', kTrail))); |
231 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 252 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
232 | 253 |
233 // SOT + | + 'a' + [Lead] + 'a' | 254 // SOT + | + 'a' + [Lead] + 'a' |
234 EXPECT_EQ("SRRF", processSequenceForward(&machine, asCodePoints(), | 255 EXPECT_EQ("SRRF", |
235 asCodePoints('a', kLead, 'a'))); | 256 processSequenceForward(&machine, asCodePoints(), |
| 257 asCodePoints('a', kLead, 'a'))); |
236 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 258 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
237 | 259 |
238 // SOT + | + 'a' + [Lead] + [Lead] | 260 // SOT + | + 'a' + [Lead] + [Lead] |
239 EXPECT_EQ("SRRF", processSequenceForward(&machine, asCodePoints(), | 261 EXPECT_EQ("SRRF", |
240 asCodePoints('a', kLead, kLead))); | 262 processSequenceForward(&machine, asCodePoints(), |
| 263 asCodePoints('a', kLead, kLead))); |
241 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 264 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
242 | 265 |
243 // SOT + | + 'a' + [Lead] + EOT | 266 // SOT + | + 'a' + [Lead] + EOT |
244 EXPECT_EQ("SRR", processSequenceForward(&machine, asCodePoints(), | 267 EXPECT_EQ("SRR", |
245 asCodePoints('a', kLead))); | 268 processSequenceForward(&machine, asCodePoints(), |
| 269 asCodePoints('a', kLead))); |
246 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); | 270 EXPECT_EQ(1, machine.finalizeAndGetBoundaryOffset()); |
247 } | 271 } |
248 | 272 |
249 TEST_F(ForwardGraphemeBoundaryStatemachineTest, | 273 TEST_F(ForwardGraphemeBoundaryStatemachineTest, |
250 BreakImmediately_Supplementary) { | 274 BreakImmediately_Supplementary) { |
251 ForwardGraphemeBoundaryStateMachine machine; | 275 ForwardGraphemeBoundaryStateMachine machine; |
252 | 276 |
253 // SOT + | + U+1F441 + 'a' | 277 // SOT + | + U+1F441 + 'a' |
254 EXPECT_EQ("SRRF", processSequenceForward(&machine, asCodePoints(), | 278 EXPECT_EQ("SRRF", |
255 asCodePoints(kEye, 'a'))); | 279 processSequenceForward(&machine, asCodePoints(), |
| 280 asCodePoints(kEye, 'a'))); |
256 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 281 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
257 | 282 |
258 // SOT + | + U+1F441 + U+1F441 | 283 // SOT + | + U+1F441 + U+1F441 |
259 EXPECT_EQ("SRRRF", processSequenceForward(&machine, asCodePoints(), | 284 EXPECT_EQ("SRRRF", |
260 asCodePoints(kEye, kEye))); | 285 processSequenceForward(&machine, asCodePoints(), |
| 286 asCodePoints(kEye, kEye))); |
261 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 287 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
262 | 288 |
263 // SOT + | + U+1F441 + EOT | 289 // SOT + | + U+1F441 + EOT |
264 EXPECT_EQ("SRR", processSequenceForward(&machine, asCodePoints(), | 290 EXPECT_EQ( |
265 asCodePoints(kEye))); | 291 "SRR", |
| 292 processSequenceForward(&machine, asCodePoints(), asCodePoints(kEye))); |
266 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 293 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
267 | 294 |
268 // SOT + | + U+1F441 + [Trail] | 295 // SOT + | + U+1F441 + [Trail] |
269 EXPECT_EQ("SRRF", processSequenceForward(&machine, asCodePoints(), | 296 EXPECT_EQ("SRRF", |
270 asCodePoints(kEye, kTrail))); | 297 processSequenceForward(&machine, asCodePoints(), |
| 298 asCodePoints(kEye, kTrail))); |
271 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 299 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
272 | 300 |
273 // SOT + | + U+1F441 + [Lead] + 'a' | 301 // SOT + | + U+1F441 + [Lead] + 'a' |
274 EXPECT_EQ("SRRRF", processSequenceForward(&machine, asCodePoints(), | 302 EXPECT_EQ("SRRRF", |
275 asCodePoints(kEye, kLead, 'a'))); | 303 processSequenceForward(&machine, asCodePoints(), |
| 304 asCodePoints(kEye, kLead, 'a'))); |
276 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 305 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
277 | 306 |
278 // SOT + | + U+1F441 + [Lead] + [Lead] | 307 // SOT + | + U+1F441 + [Lead] + [Lead] |
279 EXPECT_EQ("SRRRF", processSequenceForward(&machine, asCodePoints(), | 308 EXPECT_EQ("SRRRF", |
280 asCodePoints(kEye, kLead, kLead))); | 309 processSequenceForward(&machine, asCodePoints(), |
| 310 asCodePoints(kEye, kLead, kLead))); |
281 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 311 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
282 | 312 |
283 // SOT + | + U+1F441 + [Lead] + EOT | 313 // SOT + | + U+1F441 + [Lead] + EOT |
284 EXPECT_EQ("SRRR", processSequenceForward(&machine, asCodePoints(), | 314 EXPECT_EQ("SRRR", |
285 asCodePoints(kEye, kLead))); | 315 processSequenceForward(&machine, asCodePoints(), |
| 316 asCodePoints(kEye, kLead))); |
286 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 317 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
287 } | 318 } |
288 | 319 |
289 TEST_F(ForwardGraphemeBoundaryStatemachineTest, | 320 TEST_F(ForwardGraphemeBoundaryStatemachineTest, |
290 NotBreakImmediatelyAfter_BMP_BMP) { | 321 NotBreakImmediatelyAfter_BMP_BMP) { |
291 ForwardGraphemeBoundaryStateMachine machine; | 322 ForwardGraphemeBoundaryStateMachine machine; |
292 | 323 |
293 // SOT + | + U+231A + U+FE0F + 'a' | 324 // SOT + | + U+231A + U+FE0F + 'a' |
294 EXPECT_EQ("SRRF", processSequenceForward(&machine, asCodePoints(), | 325 EXPECT_EQ("SRRF", |
295 asCodePoints(kWatch, kVS16, 'a'))); | 326 processSequenceForward(&machine, asCodePoints(), |
| 327 asCodePoints(kWatch, kVS16, 'a'))); |
296 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 328 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
297 | 329 |
298 // SOT + | + U+231A + U+FE0F + U+1F441 | 330 // SOT + | + U+231A + U+FE0F + U+1F441 |
299 EXPECT_EQ("SRRRF", processSequenceForward(&machine, asCodePoints(), | 331 EXPECT_EQ("SRRRF", |
300 asCodePoints(kWatch, kVS16, kEye))); | 332 processSequenceForward(&machine, asCodePoints(), |
| 333 asCodePoints(kWatch, kVS16, kEye))); |
301 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 334 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
302 | 335 |
303 // SOT + | + U+231A + U+FE0F + EOT | 336 // SOT + | + U+231A + U+FE0F + EOT |
304 EXPECT_EQ("SRR", processSequenceForward(&machine, asCodePoints(), | 337 EXPECT_EQ("SRR", |
305 asCodePoints(kWatch, kVS16))); | 338 processSequenceForward(&machine, asCodePoints(), |
| 339 asCodePoints(kWatch, kVS16))); |
306 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 340 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
307 | 341 |
308 // SOT + | + U+231A + U+FE0F + [Trail] | 342 // SOT + | + U+231A + U+FE0F + [Trail] |
309 EXPECT_EQ("SRRF", | 343 EXPECT_EQ("SRRF", |
310 processSequenceForward(&machine, asCodePoints(), | 344 processSequenceForward(&machine, asCodePoints(), |
311 asCodePoints(kWatch, kVS16, kTrail))); | 345 asCodePoints(kWatch, kVS16, kTrail))); |
312 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 346 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
313 | 347 |
314 // SOT + | + U+231A + U+FE0F + [Lead] + 'a' | 348 // SOT + | + U+231A + U+FE0F + [Lead] + 'a' |
315 EXPECT_EQ("SRRRF", | 349 EXPECT_EQ("SRRRF", |
316 processSequenceForward(&machine, asCodePoints(), | 350 processSequenceForward(&machine, asCodePoints(), |
317 asCodePoints(kWatch, kVS16, kLead, 'a'))); | 351 asCodePoints(kWatch, kVS16, kLead, 'a'))); |
318 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 352 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
319 | 353 |
320 // SOT + | + U+231A + U+FE0F + [Lead] + [Lead] | 354 // SOT + | + U+231A + U+FE0F + [Lead] + [Lead] |
321 EXPECT_EQ("SRRRF", | 355 EXPECT_EQ("SRRRF", |
322 processSequenceForward(&machine, asCodePoints(), | 356 processSequenceForward(&machine, asCodePoints(), |
323 asCodePoints(kWatch, kVS16, kLead, kLead))); | 357 asCodePoints(kWatch, kVS16, kLead, kLead))); |
324 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 358 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
325 | 359 |
326 // SOT + | + U+231A + U+FE0F + [Lead] + EOT | 360 // SOT + | + U+231A + U+FE0F + [Lead] + EOT |
327 EXPECT_EQ("SRRR", processSequenceForward(&machine, asCodePoints(), | 361 EXPECT_EQ("SRRR", |
328 asCodePoints(kWatch, kVS16, kLead))); | 362 processSequenceForward(&machine, asCodePoints(), |
| 363 asCodePoints(kWatch, kVS16, kLead))); |
329 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 364 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
330 } | 365 } |
331 | 366 |
332 TEST_F(ForwardGraphemeBoundaryStatemachineTest, | 367 TEST_F(ForwardGraphemeBoundaryStatemachineTest, |
333 NotBreakImmediatelyAfter_Supplementary_BMP) { | 368 NotBreakImmediatelyAfter_Supplementary_BMP) { |
334 ForwardGraphemeBoundaryStateMachine machine; | 369 ForwardGraphemeBoundaryStateMachine machine; |
335 | 370 |
336 // SOT + | + U+1F441 + U+FE0F + 'a' | 371 // SOT + | + U+1F441 + U+FE0F + 'a' |
337 EXPECT_EQ("SRRRF", processSequenceForward(&machine, asCodePoints(), | 372 EXPECT_EQ("SRRRF", |
338 asCodePoints(kEye, kVS16, 'a'))); | 373 processSequenceForward(&machine, asCodePoints(), |
| 374 asCodePoints(kEye, kVS16, 'a'))); |
339 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); | 375 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); |
340 | 376 |
341 // SOT + | + U+1F441 + U+FE0F + U+1F441 | 377 // SOT + | + U+1F441 + U+FE0F + U+1F441 |
342 EXPECT_EQ("SRRRRF", processSequenceForward(&machine, asCodePoints(), | 378 EXPECT_EQ("SRRRRF", |
343 asCodePoints(kEye, kVS16, kEye))); | 379 processSequenceForward(&machine, asCodePoints(), |
| 380 asCodePoints(kEye, kVS16, kEye))); |
344 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); | 381 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); |
345 | 382 |
346 // SOT + | + U+1F441 + U+FE0F + EOT | 383 // SOT + | + U+1F441 + U+FE0F + EOT |
347 EXPECT_EQ("SRRR", processSequenceForward(&machine, asCodePoints(), | 384 EXPECT_EQ("SRRR", |
348 asCodePoints(kEye, kVS16))); | 385 processSequenceForward(&machine, asCodePoints(), |
| 386 asCodePoints(kEye, kVS16))); |
349 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); | 387 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); |
350 | 388 |
351 // SOT + | + U+1F441 + U+FE0F + [Trail] | 389 // SOT + | + U+1F441 + U+FE0F + [Trail] |
352 EXPECT_EQ("SRRRF", processSequenceForward(&machine, asCodePoints(), | 390 EXPECT_EQ("SRRRF", |
353 asCodePoints(kEye, kVS16, kTrail))); | 391 processSequenceForward(&machine, asCodePoints(), |
| 392 asCodePoints(kEye, kVS16, kTrail))); |
354 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); | 393 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); |
355 | 394 |
356 // SOT + | + U+1F441 + U+FE0F + [Lead] + 'a' | 395 // SOT + | + U+1F441 + U+FE0F + [Lead] + 'a' |
357 EXPECT_EQ("SRRRRF", | 396 EXPECT_EQ("SRRRRF", |
358 processSequenceForward(&machine, asCodePoints(), | 397 processSequenceForward(&machine, asCodePoints(), |
359 asCodePoints(kEye, kVS16, kLead, 'a'))); | 398 asCodePoints(kEye, kVS16, kLead, 'a'))); |
360 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); | 399 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); |
361 | 400 |
362 // SOT + | + U+1F441 + U+FE0F + [Lead] + [Lead] | 401 // SOT + | + U+1F441 + U+FE0F + [Lead] + [Lead] |
363 EXPECT_EQ("SRRRRF", | 402 EXPECT_EQ("SRRRRF", |
364 processSequenceForward(&machine, asCodePoints(), | 403 processSequenceForward(&machine, asCodePoints(), |
365 asCodePoints(kEye, kVS16, kLead, kLead))); | 404 asCodePoints(kEye, kVS16, kLead, kLead))); |
366 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); | 405 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); |
367 | 406 |
368 // SOT + | + U+1F441 + U+FE0F + [Lead] + EOT | 407 // SOT + | + U+1F441 + U+FE0F + [Lead] + EOT |
369 EXPECT_EQ("SRRRR", processSequenceForward(&machine, asCodePoints(), | 408 EXPECT_EQ("SRRRR", |
370 asCodePoints(kEye, kVS16, kLead))); | 409 processSequenceForward(&machine, asCodePoints(), |
| 410 asCodePoints(kEye, kVS16, kLead))); |
371 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); | 411 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); |
372 } | 412 } |
373 | 413 |
374 TEST_F(ForwardGraphemeBoundaryStatemachineTest, | 414 TEST_F(ForwardGraphemeBoundaryStatemachineTest, |
375 NotBreakImmediatelyAfter_BMP_Supplementary) { | 415 NotBreakImmediatelyAfter_BMP_Supplementary) { |
376 ForwardGraphemeBoundaryStateMachine machine; | 416 ForwardGraphemeBoundaryStateMachine machine; |
377 | 417 |
378 // SOT + | + U+845B + U+E0100 + 'a' | 418 // SOT + | + U+845B + U+E0100 + 'a' |
379 EXPECT_EQ("SRRRF", processSequenceForward(&machine, asCodePoints(), | 419 EXPECT_EQ("SRRRF", |
380 asCodePoints(kHanBMP, kVS17, 'a'))); | 420 processSequenceForward(&machine, asCodePoints(), |
| 421 asCodePoints(kHanBMP, kVS17, 'a'))); |
381 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); | 422 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); |
382 | 423 |
383 // SOT + | + U+845B + U+E0100 + U+1F441 | 424 // SOT + | + U+845B + U+E0100 + U+1F441 |
384 EXPECT_EQ("SRRRRF", | 425 EXPECT_EQ("SRRRRF", |
385 processSequenceForward(&machine, asCodePoints(), | 426 processSequenceForward(&machine, asCodePoints(), |
386 asCodePoints(kHanBMP, kVS17, kEye))); | 427 asCodePoints(kHanBMP, kVS17, kEye))); |
387 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); | 428 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); |
388 | 429 |
389 // SOT + | + U+845B + U+E0100 + EOT | 430 // SOT + | + U+845B + U+E0100 + EOT |
390 EXPECT_EQ("SRRR", processSequenceForward(&machine, asCodePoints(), | 431 EXPECT_EQ("SRRR", |
391 asCodePoints(kHanBMP, kVS17))); | 432 processSequenceForward(&machine, asCodePoints(), |
| 433 asCodePoints(kHanBMP, kVS17))); |
392 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); | 434 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); |
393 | 435 |
394 // SOT + | + U+845B + U+E0100 + [Trail] | 436 // SOT + | + U+845B + U+E0100 + [Trail] |
395 EXPECT_EQ("SRRRF", | 437 EXPECT_EQ("SRRRF", |
396 processSequenceForward(&machine, asCodePoints(), | 438 processSequenceForward(&machine, asCodePoints(), |
397 asCodePoints(kHanBMP, kVS17, kTrail))); | 439 asCodePoints(kHanBMP, kVS17, kTrail))); |
398 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); | 440 EXPECT_EQ(3, machine.finalizeAndGetBoundaryOffset()); |
399 | 441 |
400 // SOT + | + U+845B + U+E0100 + [Lead] + 'a' | 442 // SOT + | + U+845B + U+E0100 + [Lead] + 'a' |
401 EXPECT_EQ("SRRRRF", | 443 EXPECT_EQ("SRRRRF", |
(...skipping 24 matching lines...) Expand all Loading... |
426 asCodePoints(kHanSIP, kVS17, 'a'))); | 468 asCodePoints(kHanSIP, kVS17, 'a'))); |
427 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 469 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
428 | 470 |
429 // SOT + | + U+20000 + U+E0100 + U+1F441 | 471 // SOT + | + U+20000 + U+E0100 + U+1F441 |
430 EXPECT_EQ("SRRRRRF", | 472 EXPECT_EQ("SRRRRRF", |
431 processSequenceForward(&machine, asCodePoints(), | 473 processSequenceForward(&machine, asCodePoints(), |
432 asCodePoints(kHanSIP, kVS17, kEye))); | 474 asCodePoints(kHanSIP, kVS17, kEye))); |
433 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 475 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
434 | 476 |
435 // SOT + | + U+20000 + U+E0100 + EOT | 477 // SOT + | + U+20000 + U+E0100 + EOT |
436 EXPECT_EQ("SRRRR", processSequenceForward(&machine, asCodePoints(), | 478 EXPECT_EQ("SRRRR", |
437 asCodePoints(kHanSIP, kVS17))); | 479 processSequenceForward(&machine, asCodePoints(), |
| 480 asCodePoints(kHanSIP, kVS17))); |
438 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 481 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
439 | 482 |
440 // SOT + | + U+20000 + U+E0100 + [Trail] | 483 // SOT + | + U+20000 + U+E0100 + [Trail] |
441 EXPECT_EQ("SRRRRF", | 484 EXPECT_EQ("SRRRRF", |
442 processSequenceForward(&machine, asCodePoints(), | 485 processSequenceForward(&machine, asCodePoints(), |
443 asCodePoints(kHanSIP, kVS17, kTrail))); | 486 asCodePoints(kHanSIP, kVS17, kTrail))); |
444 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 487 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
445 | 488 |
446 // SOT + | + U+20000 + U+E0100 + [Lead] + 'a' | 489 // SOT + | + U+20000 + U+E0100 + [Lead] + 'a' |
447 EXPECT_EQ("SRRRRRF", | 490 EXPECT_EQ("SRRRRRF", |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
494 EXPECT_EQ(11, machine.finalizeAndGetBoundaryOffset()); | 537 EXPECT_EQ(11, machine.finalizeAndGetBoundaryOffset()); |
495 | 538 |
496 // SOT + | + ZWJ Emoji Sequence + [Trail] | 539 // SOT + | + ZWJ Emoji Sequence + [Trail] |
497 EXPECT_EQ("SRRRRRRRRRRRF", | 540 EXPECT_EQ("SRRRRRRRRRRRF", |
498 processSequenceForward(&machine, asCodePoints(), | 541 processSequenceForward(&machine, asCodePoints(), |
499 asCodePoints(kMan, kZwj, kHeart, kVS16, kZwj, | 542 asCodePoints(kMan, kZwj, kHeart, kVS16, kZwj, |
500 kKiss, kZwj, kMan, kTrail))); | 543 kKiss, kZwj, kMan, kTrail))); |
501 EXPECT_EQ(11, machine.finalizeAndGetBoundaryOffset()); | 544 EXPECT_EQ(11, machine.finalizeAndGetBoundaryOffset()); |
502 | 545 |
503 // SOT + | + ZWJ Emoji Sequence + [Lead] + 'a' | 546 // SOT + | + ZWJ Emoji Sequence + [Lead] + 'a' |
504 EXPECT_EQ("SRRRRRRRRRRRRF", processSequenceForward( | 547 EXPECT_EQ( |
505 &machine, asCodePoints(), | 548 "SRRRRRRRRRRRRF", |
506 asCodePoints(kMan, kZwj, kHeart, kVS16, kZwj, | 549 processSequenceForward(&machine, asCodePoints(), |
507 kKiss, kZwj, kMan, kLead, 'a'))); | 550 asCodePoints(kMan, kZwj, kHeart, kVS16, kZwj, |
| 551 kKiss, kZwj, kMan, kLead, 'a'))); |
508 EXPECT_EQ(11, machine.finalizeAndGetBoundaryOffset()); | 552 EXPECT_EQ(11, machine.finalizeAndGetBoundaryOffset()); |
509 | 553 |
510 // SOT + | + ZWJ Emoji Sequence + [Lead] + [Lead] | 554 // SOT + | + ZWJ Emoji Sequence + [Lead] + [Lead] |
511 EXPECT_EQ( | 555 EXPECT_EQ( |
512 "SRRRRRRRRRRRRF", | 556 "SRRRRRRRRRRRRF", |
513 processSequenceForward(&machine, asCodePoints(), | 557 processSequenceForward(&machine, asCodePoints(), |
514 asCodePoints(kMan, kZwj, kHeart, kVS16, kZwj, | 558 asCodePoints(kMan, kZwj, kHeart, kVS16, kZwj, |
515 kKiss, kZwj, kMan, kLead, kLead))); | 559 kKiss, kZwj, kMan, kLead, kLead))); |
516 EXPECT_EQ(11, machine.finalizeAndGetBoundaryOffset()); | 560 EXPECT_EQ(11, machine.finalizeAndGetBoundaryOffset()); |
517 | 561 |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
577 processSequenceForward(&machine, asCodePoints('a', kRisU, kRisS), | 621 processSequenceForward(&machine, asCodePoints('a', kRisU, kRisS), |
578 asCodePoints(kMan, kZwj, kHeart, kVS16, kZwj, | 622 asCodePoints(kMan, kZwj, kHeart, kVS16, kZwj, |
579 kKiss, kZwj, kMan, 'a'))); | 623 kKiss, kZwj, kMan, 'a'))); |
580 EXPECT_EQ(11, machine.finalizeAndGetBoundaryOffset()); | 624 EXPECT_EQ(11, machine.finalizeAndGetBoundaryOffset()); |
581 } | 625 } |
582 | 626 |
583 TEST_F(ForwardGraphemeBoundaryStatemachineTest, singleFlags) { | 627 TEST_F(ForwardGraphemeBoundaryStatemachineTest, singleFlags) { |
584 ForwardGraphemeBoundaryStateMachine machine; | 628 ForwardGraphemeBoundaryStateMachine machine; |
585 | 629 |
586 // SOT + | + [U] + [S] | 630 // SOT + | + [U] + [S] |
587 EXPECT_EQ("SRRRF", processSequenceForward(&machine, asCodePoints(), | 631 EXPECT_EQ("SRRRF", |
588 asCodePoints(kRisU, kRisS))); | 632 processSequenceForward(&machine, asCodePoints(), |
| 633 asCodePoints(kRisU, kRisS))); |
589 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 634 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
590 | 635 |
591 // 'a' + | + [U] + [S] | 636 // 'a' + | + [U] + [S] |
592 EXPECT_EQ("SRRRF", processSequenceForward(&machine, asCodePoints('a'), | 637 EXPECT_EQ("SRRRF", |
593 asCodePoints(kRisU, kRisS))); | 638 processSequenceForward(&machine, asCodePoints('a'), |
| 639 asCodePoints(kRisU, kRisS))); |
594 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 640 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
595 | 641 |
596 // U+1F441 + | + [U] + [S] | 642 // U+1F441 + | + [U] + [S] |
597 EXPECT_EQ("RSRRRF", processSequenceForward(&machine, asCodePoints(kEye), | 643 EXPECT_EQ("RSRRRF", |
598 asCodePoints(kRisU, kRisS))); | 644 processSequenceForward(&machine, asCodePoints(kEye), |
| 645 asCodePoints(kRisU, kRisS))); |
599 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 646 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
600 | 647 |
601 // [Lead] + | + [U] + [S] | 648 // [Lead] + | + [U] + [S] |
602 EXPECT_EQ("SRRRF", processSequenceForward(&machine, asCodePoints(kLead), | 649 EXPECT_EQ("SRRRF", |
603 asCodePoints(kRisU, kRisS))); | 650 processSequenceForward(&machine, asCodePoints(kLead), |
| 651 asCodePoints(kRisU, kRisS))); |
604 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 652 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
605 | 653 |
606 // 'a' + [Trail] + | + [U] + [S] | 654 // 'a' + [Trail] + | + [U] + [S] |
607 EXPECT_EQ("RSRRRF", | 655 EXPECT_EQ("RSRRRF", |
608 processSequenceForward(&machine, asCodePoints('a', kTrail), | 656 processSequenceForward(&machine, asCodePoints('a', kTrail), |
609 asCodePoints(kRisU, kRisS))); | 657 asCodePoints(kRisU, kRisS))); |
610 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 658 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
611 | 659 |
612 // [Trail] + [Trail] + | + [U] + [S] | 660 // [Trail] + [Trail] + | + [U] + [S] |
613 EXPECT_EQ("RSRRRF", | 661 EXPECT_EQ("RSRRRF", |
614 processSequenceForward(&machine, asCodePoints(kTrail, kTrail), | 662 processSequenceForward(&machine, asCodePoints(kTrail, kTrail), |
615 asCodePoints(kRisU, kRisS))); | 663 asCodePoints(kRisU, kRisS))); |
616 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 664 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
617 | 665 |
618 // SOT + [Trail] + | + [U] + [S] | 666 // SOT + [Trail] + | + [U] + [S] |
619 EXPECT_EQ("RSRRRF", processSequenceForward(&machine, asCodePoints(kTrail), | 667 EXPECT_EQ("RSRRRF", |
620 asCodePoints(kRisU, kRisS))); | 668 processSequenceForward(&machine, asCodePoints(kTrail), |
| 669 asCodePoints(kRisU, kRisS))); |
621 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 670 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
622 } | 671 } |
623 | 672 |
624 TEST_F(ForwardGraphemeBoundaryStatemachineTest, twoFlags) { | 673 TEST_F(ForwardGraphemeBoundaryStatemachineTest, twoFlags) { |
625 ForwardGraphemeBoundaryStateMachine machine; | 674 ForwardGraphemeBoundaryStateMachine machine; |
626 | 675 |
627 // SOT + [U] + [S] + | + [U] + [S] | 676 // SOT + [U] + [S] + | + [U] + [S] |
628 EXPECT_EQ("RRRRSRRRF", | 677 EXPECT_EQ("RRRRSRRRF", |
629 processSequenceForward(&machine, asCodePoints(kRisU, kRisS), | 678 processSequenceForward(&machine, asCodePoints(kRisU, kRisS), |
630 asCodePoints(kRisU, kRisS))); | 679 asCodePoints(kRisU, kRisS))); |
(...skipping 11 matching lines...) Expand all Loading... |
642 asCodePoints(kRisU, kRisS))); | 691 asCodePoints(kRisU, kRisS))); |
643 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 692 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
644 | 693 |
645 // [Lead] + [U] + [S] + | + [U] + [S] | 694 // [Lead] + [U] + [S] + | + [U] + [S] |
646 EXPECT_EQ("RRRRSRRRF", | 695 EXPECT_EQ("RRRRSRRRF", |
647 processSequenceForward(&machine, asCodePoints(kLead, kRisU, kRisS), | 696 processSequenceForward(&machine, asCodePoints(kLead, kRisU, kRisS), |
648 asCodePoints(kRisU, kRisS))); | 697 asCodePoints(kRisU, kRisS))); |
649 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 698 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
650 | 699 |
651 // 'a' + [Trail] + [U] + [S] + | + [U] + [S] | 700 // 'a' + [Trail] + [U] + [S] + | + [U] + [S] |
652 EXPECT_EQ("RRRRRSRRRF", processSequenceForward( | 701 EXPECT_EQ( |
653 &machine, asCodePoints('a', kTrail, kRisU, kRisS), | 702 "RRRRRSRRRF", |
654 asCodePoints(kRisU, kRisS))); | 703 processSequenceForward(&machine, asCodePoints('a', kTrail, kRisU, kRisS), |
| 704 asCodePoints(kRisU, kRisS))); |
655 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 705 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
656 | 706 |
657 // [Trail] + [Trail] + [U] + [S] + | + [U] + [S] | 707 // [Trail] + [Trail] + [U] + [S] + | + [U] + [S] |
658 EXPECT_EQ("RRRRRSRRRF", | 708 EXPECT_EQ("RRRRRSRRRF", |
659 processSequenceForward(&machine, | 709 processSequenceForward(&machine, |
660 asCodePoints(kTrail, kTrail, kRisU, kRisS), | 710 asCodePoints(kTrail, kTrail, kRisU, kRisS), |
661 asCodePoints(kRisU, kRisS))); | 711 asCodePoints(kRisU, kRisS))); |
662 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 712 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
663 | 713 |
664 // SOT + [Trail] + [U] + [S] + | + [U] + [S] | 714 // SOT + [Trail] + [U] + [S] + | + [U] + [S] |
665 EXPECT_EQ("RRRRRSRRRF", | 715 EXPECT_EQ("RRRRRSRRRF", |
666 processSequenceForward(&machine, asCodePoints(kTrail, kRisU, kRisS), | 716 processSequenceForward(&machine, asCodePoints(kTrail, kRisU, kRisS), |
667 asCodePoints(kRisU, kRisS))); | 717 asCodePoints(kRisU, kRisS))); |
668 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); | 718 EXPECT_EQ(4, machine.finalizeAndGetBoundaryOffset()); |
669 } | 719 } |
670 | 720 |
671 TEST_F(ForwardGraphemeBoundaryStatemachineTest, oddNumberedFlags) { | 721 TEST_F(ForwardGraphemeBoundaryStatemachineTest, oddNumberedFlags) { |
672 ForwardGraphemeBoundaryStateMachine machine; | 722 ForwardGraphemeBoundaryStateMachine machine; |
673 | 723 |
674 // SOT + [U] + | + [S] + [S] | 724 // SOT + [U] + | + [S] + [S] |
675 EXPECT_EQ("RRSRRRF", processSequenceForward(&machine, asCodePoints(kRisU), | 725 EXPECT_EQ("RRSRRRF", |
676 asCodePoints(kRisS, kRisU))); | 726 processSequenceForward(&machine, asCodePoints(kRisU), |
| 727 asCodePoints(kRisS, kRisU))); |
677 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 728 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
678 | 729 |
679 // 'a' + [U] + | + [S] + [S] | 730 // 'a' + [U] + | + [S] + [S] |
680 EXPECT_EQ("RRSRRRF", | 731 EXPECT_EQ("RRSRRRF", |
681 processSequenceForward(&machine, asCodePoints('a', kRisU), | 732 processSequenceForward(&machine, asCodePoints('a', kRisU), |
682 asCodePoints(kRisS, kRisU))); | 733 asCodePoints(kRisS, kRisU))); |
683 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 734 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
684 | 735 |
685 // U+1F441 + [U] + | + [S] + [S] | 736 // U+1F441 + [U] + | + [S] + [S] |
686 EXPECT_EQ("RRRSRRRF", | 737 EXPECT_EQ("RRRSRRRF", |
687 processSequenceForward(&machine, asCodePoints(kEye, kRisU), | 738 processSequenceForward(&machine, asCodePoints(kEye, kRisU), |
688 asCodePoints(kRisS, kRisU))); | 739 asCodePoints(kRisS, kRisU))); |
689 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 740 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
690 | 741 |
691 // [Lead] + [U] + | + [S] + [S] | 742 // [Lead] + [U] + | + [S] + [S] |
692 EXPECT_EQ("RRSRRRF", | 743 EXPECT_EQ("RRSRRRF", |
693 processSequenceForward(&machine, asCodePoints(kLead, kRisU), | 744 processSequenceForward(&machine, asCodePoints(kLead, kRisU), |
694 asCodePoints(kRisS, kRisU))); | 745 asCodePoints(kRisS, kRisU))); |
695 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 746 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
696 | 747 |
697 // 'a' + [Trail] + [U] + | + [S] + [S] | 748 // 'a' + [Trail] + [U] + | + [S] + [S] |
698 EXPECT_EQ("RRRSRRRF", | 749 EXPECT_EQ("RRRSRRRF", |
699 processSequenceForward(&machine, asCodePoints('a', kTrail, kRisU), | 750 processSequenceForward(&machine, asCodePoints('a', kTrail, kRisU), |
700 asCodePoints(kRisS, kRisU))); | 751 asCodePoints(kRisS, kRisU))); |
701 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 752 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
702 | 753 |
703 // [Trail] + [Trail] + [U] + | + [S] + [S] | 754 // [Trail] + [Trail] + [U] + | + [S] + [S] |
704 EXPECT_EQ("RRRSRRRF", processSequenceForward( | 755 EXPECT_EQ( |
705 &machine, asCodePoints(kTrail, kTrail, kRisU), | 756 "RRRSRRRF", |
706 asCodePoints(kRisS, kRisU))); | 757 processSequenceForward(&machine, asCodePoints(kTrail, kTrail, kRisU), |
| 758 asCodePoints(kRisS, kRisU))); |
707 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 759 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
708 | 760 |
709 // SOT + [Trail] + [U] + | + [S] + [S] | 761 // SOT + [Trail] + [U] + | + [S] + [S] |
710 EXPECT_EQ("RRRSRRRF", | 762 EXPECT_EQ("RRRSRRRF", |
711 processSequenceForward(&machine, asCodePoints(kTrail, kRisU), | 763 processSequenceForward(&machine, asCodePoints(kTrail, kRisU), |
712 asCodePoints(kRisS, kRisU))); | 764 asCodePoints(kRisS, kRisU))); |
713 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); | 765 EXPECT_EQ(2, machine.finalizeAndGetBoundaryOffset()); |
714 } | 766 } |
715 | 767 |
716 } // namespace blink | 768 } // namespace blink |
OLD | NEW |