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/BackwardGraphemeBoundaryStateMachine.h" | 5 #include "core/editing/state_machines/BackwardGraphemeBoundaryStateMachine.h" |
6 | 6 |
7 #include "core/editing/state_machines/StateMachineTestUtil.h" | 7 #include "core/editing/state_machines/StateMachineTestUtil.h" |
8 #include "wtf/text/CharacterNames.h" | 8 #include "wtf/text/CharacterNames.h" |
9 | 9 |
10 namespace blink { | 10 namespace blink { |
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
98 // [Lead] + 'a' | 98 // [Lead] + 'a' |
99 EXPECT_EQ("RF", processSequenceBackward(&machine, asCodePoints(kLead, 'a'))); | 99 EXPECT_EQ("RF", processSequenceBackward(&machine, asCodePoints(kLead, 'a'))); |
100 EXPECT_EQ(-1, machine.finalizeAndGetBoundaryOffset()); | 100 EXPECT_EQ(-1, machine.finalizeAndGetBoundaryOffset()); |
101 | 101 |
102 // 'a' + [Trail] + 'a' | 102 // 'a' + [Trail] + 'a' |
103 EXPECT_EQ("RRF", | 103 EXPECT_EQ("RRF", |
104 processSequenceBackward(&machine, asCodePoints('a', kTrail, 'a'))); | 104 processSequenceBackward(&machine, asCodePoints('a', kTrail, 'a'))); |
105 EXPECT_EQ(-1, machine.finalizeAndGetBoundaryOffset()); | 105 EXPECT_EQ(-1, machine.finalizeAndGetBoundaryOffset()); |
106 | 106 |
107 // [Trail] + [Trail] + 'a' | 107 // [Trail] + [Trail] + 'a' |
108 EXPECT_EQ("RRF", processSequenceBackward(&machine, | 108 EXPECT_EQ( |
109 asCodePoints(kTrail, kTrail, 'a'))); | 109 "RRF", |
| 110 processSequenceBackward(&machine, asCodePoints(kTrail, kTrail, 'a'))); |
110 EXPECT_EQ(-1, machine.finalizeAndGetBoundaryOffset()); | 111 EXPECT_EQ(-1, machine.finalizeAndGetBoundaryOffset()); |
111 | 112 |
112 // SOT + [Trail] + 'a' | 113 // SOT + [Trail] + 'a' |
113 EXPECT_EQ("RRF", | 114 EXPECT_EQ("RRF", |
114 processSequenceBackward(&machine, asCodePoints(kTrail, 'a'))); | 115 processSequenceBackward(&machine, asCodePoints(kTrail, 'a'))); |
115 EXPECT_EQ(-1, machine.finalizeAndGetBoundaryOffset()); | 116 EXPECT_EQ(-1, machine.finalizeAndGetBoundaryOffset()); |
116 } | 117 } |
117 | 118 |
118 TEST_F(BackwardGraphemeBoundaryStatemachineTest, | 119 TEST_F(BackwardGraphemeBoundaryStatemachineTest, |
119 BreakImmediately_SupplementaryPlane) { | 120 BreakImmediately_SupplementaryPlane) { |
(...skipping 17 matching lines...) Expand all Loading... |
137 EXPECT_EQ("RRF", | 138 EXPECT_EQ("RRF", |
138 processSequenceBackward(&machine, asCodePoints(kLead, kEye))); | 139 processSequenceBackward(&machine, asCodePoints(kLead, kEye))); |
139 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 140 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
140 | 141 |
141 // 'a' + [Trail] + U+1F441 | 142 // 'a' + [Trail] + U+1F441 |
142 EXPECT_EQ("RRRF", | 143 EXPECT_EQ("RRRF", |
143 processSequenceBackward(&machine, asCodePoints('a', kTrail, kEye))); | 144 processSequenceBackward(&machine, asCodePoints('a', kTrail, kEye))); |
144 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 145 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
145 | 146 |
146 // [Trail] + [Trail] + U+1F441 | 147 // [Trail] + [Trail] + U+1F441 |
147 EXPECT_EQ("RRRF", processSequenceBackward( | 148 EXPECT_EQ( |
148 &machine, asCodePoints(kTrail, kTrail, kEye))); | 149 "RRRF", |
| 150 processSequenceBackward(&machine, asCodePoints(kTrail, kTrail, kEye))); |
149 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 151 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
150 | 152 |
151 // SOT + [Trail] + U+1F441 | 153 // SOT + [Trail] + U+1F441 |
152 EXPECT_EQ("RRRF", | 154 EXPECT_EQ("RRRF", |
153 processSequenceBackward(&machine, asCodePoints(kTrail, kEye))); | 155 processSequenceBackward(&machine, asCodePoints(kTrail, kEye))); |
154 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 156 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
155 } | 157 } |
156 | 158 |
157 TEST_F(BackwardGraphemeBoundaryStatemachineTest, | 159 TEST_F(BackwardGraphemeBoundaryStatemachineTest, |
158 NotBreakImmediatelyBefore_BMP_BMP) { | 160 NotBreakImmediatelyBefore_BMP_BMP) { |
159 BackwardGraphemeBoundaryStateMachine machine; | 161 BackwardGraphemeBoundaryStateMachine machine; |
160 | 162 |
161 // 'a' + U+231A + U+FE0F | 163 // 'a' + U+231A + U+FE0F |
162 EXPECT_EQ("RRF", processSequenceBackward(&machine, | 164 EXPECT_EQ( |
163 asCodePoints('a', kWatch, kVS16))); | 165 "RRF", |
| 166 processSequenceBackward(&machine, asCodePoints('a', kWatch, kVS16))); |
164 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 167 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
165 | 168 |
166 // U+1F441 + U+231A + U+FE0F | 169 // U+1F441 + U+231A + U+FE0F |
167 EXPECT_EQ("RRRF", processSequenceBackward(&machine, | 170 EXPECT_EQ( |
168 asCodePoints(kEye, kWatch, kVS16))); | 171 "RRRF", |
| 172 processSequenceBackward(&machine, asCodePoints(kEye, kWatch, kVS16))); |
169 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 173 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
170 | 174 |
171 // SOT + U+231A + U+FE0F | 175 // SOT + U+231A + U+FE0F |
172 EXPECT_EQ("RRF", | 176 EXPECT_EQ("RRF", |
173 processSequenceBackward(&machine, asCodePoints(kWatch, kVS16))); | 177 processSequenceBackward(&machine, asCodePoints(kWatch, kVS16))); |
174 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 178 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
175 | 179 |
176 // [Lead] + U+231A + U+FE0F | 180 // [Lead] + U+231A + U+FE0F |
177 EXPECT_EQ("RRF", processSequenceBackward(&machine, | 181 EXPECT_EQ( |
178 asCodePoints(kLead, kWatch, kVS16))); | 182 "RRF", |
| 183 processSequenceBackward(&machine, asCodePoints(kLead, kWatch, kVS16))); |
179 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 184 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
180 | 185 |
181 // 'a' + [Trail] + U+231A + U+FE0F | 186 // 'a' + [Trail] + U+231A + U+FE0F |
182 EXPECT_EQ("RRRF", processSequenceBackward( | 187 EXPECT_EQ("RRRF", |
183 &machine, asCodePoints('a', kTrail, kWatch, kVS16))); | 188 processSequenceBackward(&machine, |
| 189 asCodePoints('a', kTrail, kWatch, kVS16))); |
184 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 190 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
185 | 191 |
186 // [Trail] + [Trail] + U+231A + U+FE0F | 192 // [Trail] + [Trail] + U+231A + U+FE0F |
187 EXPECT_EQ("RRRF", processSequenceBackward( | 193 EXPECT_EQ("RRRF", |
188 &machine, asCodePoints(kTrail, kTrail, kWatch, kVS16))); | 194 processSequenceBackward( |
| 195 &machine, asCodePoints(kTrail, kTrail, kWatch, kVS16))); |
189 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 196 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
190 | 197 |
191 // SOT + [Trail] + U+231A + U+FE0F | 198 // SOT + [Trail] + U+231A + U+FE0F |
192 EXPECT_EQ("RRRF", processSequenceBackward( | 199 EXPECT_EQ( |
193 &machine, asCodePoints(kTrail, kWatch, kVS16))); | 200 "RRRF", |
| 201 processSequenceBackward(&machine, asCodePoints(kTrail, kWatch, kVS16))); |
194 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 202 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
195 } | 203 } |
196 | 204 |
197 TEST_F(BackwardGraphemeBoundaryStatemachineTest, | 205 TEST_F(BackwardGraphemeBoundaryStatemachineTest, |
198 NotBreakImmediatelyBefore_Supplementary_BMP) { | 206 NotBreakImmediatelyBefore_Supplementary_BMP) { |
199 BackwardGraphemeBoundaryStateMachine machine; | 207 BackwardGraphemeBoundaryStateMachine machine; |
200 | 208 |
201 // 'a' + U+1F441 + U+FE0F | 209 // 'a' + U+1F441 + U+FE0F |
202 EXPECT_EQ("RRRF", | 210 EXPECT_EQ("RRRF", |
203 processSequenceBackward(&machine, asCodePoints('a', kEye, kVS16))); | 211 processSequenceBackward(&machine, asCodePoints('a', kEye, kVS16))); |
204 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 212 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
205 | 213 |
206 // U+1F441 + U+1F441 + U+FE0F | 214 // U+1F441 + U+1F441 + U+FE0F |
207 EXPECT_EQ("RRRRF", | 215 EXPECT_EQ("RRRRF", |
208 processSequenceBackward(&machine, asCodePoints(kEye, kEye, kVS16))); | 216 processSequenceBackward(&machine, asCodePoints(kEye, kEye, kVS16))); |
209 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 217 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
210 | 218 |
211 // SOT + U+1F441 + U+FE0F | 219 // SOT + U+1F441 + U+FE0F |
212 EXPECT_EQ("RRRF", | 220 EXPECT_EQ("RRRF", |
213 processSequenceBackward(&machine, asCodePoints(kEye, kVS16))); | 221 processSequenceBackward(&machine, asCodePoints(kEye, kVS16))); |
214 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 222 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
215 | 223 |
216 // [Lead] + U+1F441 + U+FE0F | 224 // [Lead] + U+1F441 + U+FE0F |
217 EXPECT_EQ("RRRF", processSequenceBackward(&machine, | 225 EXPECT_EQ( |
218 asCodePoints(kLead, kEye, kVS16))); | 226 "RRRF", |
| 227 processSequenceBackward(&machine, asCodePoints(kLead, kEye, kVS16))); |
219 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 228 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
220 | 229 |
221 // 'a' + [Trail] + U+1F441 + U+FE0F | 230 // 'a' + [Trail] + U+1F441 + U+FE0F |
222 EXPECT_EQ("RRRRF", processSequenceBackward( | 231 EXPECT_EQ("RRRRF", |
223 &machine, asCodePoints('a', kTrail, kEye, kVS16))); | 232 processSequenceBackward(&machine, |
| 233 asCodePoints('a', kTrail, kEye, kVS16))); |
224 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 234 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
225 | 235 |
226 // [Trail] + [Trail] + U+1F441 + U+FE0F | 236 // [Trail] + [Trail] + U+1F441 + U+FE0F |
227 EXPECT_EQ("RRRRF", processSequenceBackward( | 237 EXPECT_EQ("RRRRF", |
228 &machine, asCodePoints(kTrail, kTrail, kEye, kVS16))); | 238 processSequenceBackward(&machine, |
| 239 asCodePoints(kTrail, kTrail, kEye, kVS16))); |
229 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 240 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
230 | 241 |
231 // SOT + [Trail] + U+1F441 + U+FE0F | 242 // SOT + [Trail] + U+1F441 + U+FE0F |
232 EXPECT_EQ("RRRRF", processSequenceBackward( | 243 EXPECT_EQ( |
233 &machine, asCodePoints(kTrail, kEye, kVS16))); | 244 "RRRRF", |
| 245 processSequenceBackward(&machine, asCodePoints(kTrail, kEye, kVS16))); |
234 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 246 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
235 } | 247 } |
236 | 248 |
237 TEST_F(BackwardGraphemeBoundaryStatemachineTest, | 249 TEST_F(BackwardGraphemeBoundaryStatemachineTest, |
238 NotBreakImmediatelyBefore_BMP_Supplementary) { | 250 NotBreakImmediatelyBefore_BMP_Supplementary) { |
239 BackwardGraphemeBoundaryStateMachine machine; | 251 BackwardGraphemeBoundaryStateMachine machine; |
240 | 252 |
241 // 'a' + U+845B + U+E0100 | 253 // 'a' + U+845B + U+E0100 |
242 EXPECT_EQ("RRRF", processSequenceBackward(&machine, | 254 EXPECT_EQ( |
243 asCodePoints('a', kHanBMP, kVS17))); | 255 "RRRF", |
| 256 processSequenceBackward(&machine, asCodePoints('a', kHanBMP, kVS17))); |
244 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 257 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
245 | 258 |
246 // U+1F441 + U+845B + U+E0100 | 259 // U+1F441 + U+845B + U+E0100 |
247 EXPECT_EQ("RRRRF", processSequenceBackward( | 260 EXPECT_EQ( |
248 &machine, asCodePoints(kEye, kHanBMP, kVS17))); | 261 "RRRRF", |
| 262 processSequenceBackward(&machine, asCodePoints(kEye, kHanBMP, kVS17))); |
249 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 263 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
250 | 264 |
251 // SOT + U+845B + U+E0100 | 265 // SOT + U+845B + U+E0100 |
252 EXPECT_EQ("RRRF", | 266 EXPECT_EQ("RRRF", |
253 processSequenceBackward(&machine, asCodePoints(kHanBMP, kVS17))); | 267 processSequenceBackward(&machine, asCodePoints(kHanBMP, kVS17))); |
254 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 268 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
255 | 269 |
256 // [Lead] + U+845B + U+E0100 | 270 // [Lead] + U+845B + U+E0100 |
257 EXPECT_EQ("RRRF", processSequenceBackward( | 271 EXPECT_EQ( |
258 &machine, asCodePoints(kLead, kHanBMP, kVS17))); | 272 "RRRF", |
| 273 processSequenceBackward(&machine, asCodePoints(kLead, kHanBMP, kVS17))); |
259 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 274 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
260 | 275 |
261 // 'a' + [Trail] + U+845B + U+E0100 | 276 // 'a' + [Trail] + U+845B + U+E0100 |
262 EXPECT_EQ("RRRRF", processSequenceBackward( | 277 EXPECT_EQ("RRRRF", |
263 &machine, asCodePoints('a', kTrail, kHanBMP, kVS17))); | 278 processSequenceBackward(&machine, |
| 279 asCodePoints('a', kTrail, kHanBMP, kVS17))); |
264 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 280 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
265 | 281 |
266 // [Trail] + [Trail] + U+845B + U+E0100 | 282 // [Trail] + [Trail] + U+845B + U+E0100 |
267 EXPECT_EQ("RRRRF", | 283 EXPECT_EQ("RRRRF", |
268 processSequenceBackward( | 284 processSequenceBackward( |
269 &machine, asCodePoints(kTrail, kTrail, kHanBMP, kVS17))); | 285 &machine, asCodePoints(kTrail, kTrail, kHanBMP, kVS17))); |
270 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 286 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
271 | 287 |
272 // SOT + [Trail] + U+845B + U+E0100 | 288 // SOT + [Trail] + U+845B + U+E0100 |
273 EXPECT_EQ("RRRRF", processSequenceBackward( | 289 EXPECT_EQ( |
274 &machine, asCodePoints(kTrail, kHanBMP, kVS17))); | 290 "RRRRF", |
| 291 processSequenceBackward(&machine, asCodePoints(kTrail, kHanBMP, kVS17))); |
275 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); | 292 EXPECT_EQ(-3, machine.finalizeAndGetBoundaryOffset()); |
276 } | 293 } |
277 | 294 |
278 TEST_F(BackwardGraphemeBoundaryStatemachineTest, | 295 TEST_F(BackwardGraphemeBoundaryStatemachineTest, |
279 NotBreakImmediatelyBefore_Supplementary_Supplementary) { | 296 NotBreakImmediatelyBefore_Supplementary_Supplementary) { |
280 BackwardGraphemeBoundaryStateMachine machine; | 297 BackwardGraphemeBoundaryStateMachine machine; |
281 | 298 |
282 // 'a' + U+20000 + U+E0100 | 299 // 'a' + U+20000 + U+E0100 |
283 EXPECT_EQ("RRRRF", processSequenceBackward( | 300 EXPECT_EQ( |
284 &machine, asCodePoints('a', kHanSIP, kVS17))); | 301 "RRRRF", |
| 302 processSequenceBackward(&machine, asCodePoints('a', kHanSIP, kVS17))); |
285 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 303 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
286 | 304 |
287 // U+1F441 + U+20000 + U+E0100 | 305 // U+1F441 + U+20000 + U+E0100 |
288 EXPECT_EQ("RRRRRF", processSequenceBackward( | 306 EXPECT_EQ( |
289 &machine, asCodePoints(kEye, kHanSIP, kVS17))); | 307 "RRRRRF", |
| 308 processSequenceBackward(&machine, asCodePoints(kEye, kHanSIP, kVS17))); |
290 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 309 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
291 | 310 |
292 // SOT + U+20000 + U+E0100 | 311 // SOT + U+20000 + U+E0100 |
293 EXPECT_EQ("RRRRF", | 312 EXPECT_EQ("RRRRF", |
294 processSequenceBackward(&machine, asCodePoints(kHanSIP, kVS17))); | 313 processSequenceBackward(&machine, asCodePoints(kHanSIP, kVS17))); |
295 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 314 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
296 | 315 |
297 // [Lead] + U+20000 + U+E0100 | 316 // [Lead] + U+20000 + U+E0100 |
298 EXPECT_EQ("RRRRF", processSequenceBackward( | 317 EXPECT_EQ( |
299 &machine, asCodePoints(kLead, kHanSIP, kVS17))); | 318 "RRRRF", |
| 319 processSequenceBackward(&machine, asCodePoints(kLead, kHanSIP, kVS17))); |
300 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 320 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
301 | 321 |
302 // 'a' + [Trail] + U+20000 + U+E0100 | 322 // 'a' + [Trail] + U+20000 + U+E0100 |
303 EXPECT_EQ("RRRRRF", processSequenceBackward( | 323 EXPECT_EQ("RRRRRF", |
304 &machine, asCodePoints('a', kTrail, kHanSIP, kVS17))); | 324 processSequenceBackward(&machine, |
| 325 asCodePoints('a', kTrail, kHanSIP, kVS17))); |
305 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 326 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
306 | 327 |
307 // [Trail] + [Trail] + U+20000 + U+E0100 | 328 // [Trail] + [Trail] + U+20000 + U+E0100 |
308 EXPECT_EQ("RRRRRF", | 329 EXPECT_EQ("RRRRRF", |
309 processSequenceBackward( | 330 processSequenceBackward( |
310 &machine, asCodePoints(kTrail, kTrail, kHanSIP, kVS17))); | 331 &machine, asCodePoints(kTrail, kTrail, kHanSIP, kVS17))); |
311 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 332 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
312 | 333 |
313 // SOT + [Trail] + U+20000 + U+E0100 | 334 // SOT + [Trail] + U+20000 + U+E0100 |
314 EXPECT_EQ("RRRRRF", processSequenceBackward( | 335 EXPECT_EQ( |
315 &machine, asCodePoints(kTrail, kHanSIP, kVS17))); | 336 "RRRRRF", |
| 337 processSequenceBackward(&machine, asCodePoints(kTrail, kHanSIP, kVS17))); |
316 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 338 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
317 } | 339 } |
318 | 340 |
319 TEST_F(BackwardGraphemeBoundaryStatemachineTest, MuchLongerCase) { | 341 TEST_F(BackwardGraphemeBoundaryStatemachineTest, MuchLongerCase) { |
320 const UChar32 kMan = WTF::Unicode::manCharacter; | 342 const UChar32 kMan = WTF::Unicode::manCharacter; |
321 const UChar32 kZwj = WTF::Unicode::zeroWidthJoinerCharacter; | 343 const UChar32 kZwj = WTF::Unicode::zeroWidthJoinerCharacter; |
322 const UChar32 kHeart = WTF::Unicode::heavyBlackHeartCharacter; | 344 const UChar32 kHeart = WTF::Unicode::heavyBlackHeartCharacter; |
323 const UChar32 kKiss = WTF::Unicode::kissMarkCharacter; | 345 const UChar32 kKiss = WTF::Unicode::kissMarkCharacter; |
324 | 346 |
325 BackwardGraphemeBoundaryStateMachine machine; | 347 BackwardGraphemeBoundaryStateMachine machine; |
326 | 348 |
327 // U+1F468 U+200D U+2764 U+FE0F U+200D U+1F48B U+200D U+1F468 is a valid ZWJ | 349 // U+1F468 U+200D U+2764 U+FE0F U+200D U+1F48B U+200D U+1F468 is a valid ZWJ |
328 // emoji sequence. | 350 // emoji sequence. |
329 // 'a' + ZWJ Emoji Sequence | 351 // 'a' + ZWJ Emoji Sequence |
330 EXPECT_EQ("RRRRRRRRRRRF", | 352 EXPECT_EQ("RRRRRRRRRRRF", |
331 processSequenceBackward( | 353 processSequenceBackward(&machine, |
332 &machine, asCodePoints('a', kMan, kZwj, kHeart, kVS16, kZwj, | 354 asCodePoints('a', kMan, kZwj, kHeart, kVS16, |
333 kKiss, kZwj, kMan))); | 355 kZwj, kKiss, kZwj, kMan))); |
334 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); | 356 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); |
335 | 357 |
336 // U+1F441 + ZWJ Emoji Sequence | 358 // U+1F441 + ZWJ Emoji Sequence |
337 EXPECT_EQ("RRRRRRRRRRRRF", | 359 EXPECT_EQ( |
338 processSequenceBackward( | 360 "RRRRRRRRRRRRF", |
339 &machine, asCodePoints(kEye, kMan, kZwj, kHeart, kVS16, kZwj, | 361 processSequenceBackward(&machine, |
340 kKiss, kZwj, kMan))); | 362 asCodePoints(kEye, kMan, kZwj, kHeart, kVS16, |
| 363 kZwj, kKiss, kZwj, kMan))); |
341 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); | 364 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); |
342 | 365 |
343 // SOT + ZWJ Emoji Sequence | 366 // SOT + ZWJ Emoji Sequence |
344 EXPECT_EQ( | 367 EXPECT_EQ("RRRRRRRRRRRF", |
345 "RRRRRRRRRRRF", | 368 processSequenceBackward(&machine, |
346 processSequenceBackward(&machine, asCodePoints(kMan, kZwj, kHeart, kVS16, | 369 asCodePoints(kMan, kZwj, kHeart, kVS16, |
347 kZwj, kKiss, kZwj, kMan))); | 370 kZwj, kKiss, kZwj, kMan))); |
348 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); | 371 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); |
349 | 372 |
350 // [Lead] + ZWJ Emoji Sequence | 373 // [Lead] + ZWJ Emoji Sequence |
351 EXPECT_EQ("RRRRRRRRRRRF", | 374 EXPECT_EQ( |
352 processSequenceBackward( | 375 "RRRRRRRRRRRF", |
353 &machine, asCodePoints(kLead, kMan, kZwj, kHeart, kVS16, kZwj, | 376 processSequenceBackward(&machine, |
354 kKiss, kZwj, kMan))); | 377 asCodePoints(kLead, kMan, kZwj, kHeart, kVS16, |
| 378 kZwj, kKiss, kZwj, kMan))); |
355 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); | 379 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); |
356 | 380 |
357 // 'a' + [Trail] + ZWJ Emoji Sequence | 381 // 'a' + [Trail] + ZWJ Emoji Sequence |
358 EXPECT_EQ("RRRRRRRRRRRRF", | 382 EXPECT_EQ( |
359 processSequenceBackward( | 383 "RRRRRRRRRRRRF", |
360 &machine, asCodePoints('a', kTrail, kMan, kZwj, kHeart, kVS16, | 384 processSequenceBackward(&machine, |
361 kZwj, kKiss, kZwj, kMan))); | 385 asCodePoints('a', kTrail, kMan, kZwj, kHeart, |
| 386 kVS16, kZwj, kKiss, kZwj, kMan))); |
362 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); | 387 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); |
363 | 388 |
364 // [Trail] + [Trail] + ZWJ Emoji Sequence | 389 // [Trail] + [Trail] + ZWJ Emoji Sequence |
365 EXPECT_EQ("RRRRRRRRRRRRF", | 390 EXPECT_EQ( |
366 processSequenceBackward( | 391 "RRRRRRRRRRRRF", |
367 &machine, asCodePoints(kTrail, kTrail, kMan, kZwj, kHeart, | 392 processSequenceBackward(&machine, |
368 kVS16, kZwj, kKiss, kZwj, kMan))); | 393 asCodePoints(kTrail, kTrail, kMan, kZwj, kHeart, |
| 394 kVS16, kZwj, kKiss, kZwj, kMan))); |
369 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); | 395 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); |
370 | 396 |
371 // SOT + [Trail] + ZWJ Emoji Sequence | 397 // SOT + [Trail] + ZWJ Emoji Sequence |
372 EXPECT_EQ("RRRRRRRRRRRRF", | 398 EXPECT_EQ( |
373 processSequenceBackward( | 399 "RRRRRRRRRRRRF", |
374 &machine, asCodePoints(kTrail, kMan, kZwj, kHeart, kVS16, kZwj, | 400 processSequenceBackward(&machine, |
375 kKiss, kZwj, kMan))); | 401 asCodePoints(kTrail, kMan, kZwj, kHeart, kVS16, |
| 402 kZwj, kKiss, kZwj, kMan))); |
376 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); | 403 EXPECT_EQ(-11, machine.finalizeAndGetBoundaryOffset()); |
377 } | 404 } |
378 | 405 |
379 TEST_F(BackwardGraphemeBoundaryStatemachineTest, Flags_singleFlag) { | 406 TEST_F(BackwardGraphemeBoundaryStatemachineTest, Flags_singleFlag) { |
380 BackwardGraphemeBoundaryStateMachine machine; | 407 BackwardGraphemeBoundaryStateMachine machine; |
381 | 408 |
382 // 'a' + [U] + [S] | 409 // 'a' + [U] + [S] |
383 EXPECT_EQ("RRRRF", | 410 EXPECT_EQ("RRRRF", |
384 processSequenceBackward(&machine, asCodePoints('a', kRisU, kRisS))); | 411 processSequenceBackward(&machine, asCodePoints('a', kRisU, kRisS))); |
385 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 412 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
386 | 413 |
387 // U+1F441 + [U] + [S] | 414 // U+1F441 + [U] + [S] |
388 EXPECT_EQ("RRRRRF", processSequenceBackward( | 415 EXPECT_EQ( |
389 &machine, asCodePoints(kEye, kRisU, kRisS))); | 416 "RRRRRF", |
| 417 processSequenceBackward(&machine, asCodePoints(kEye, kRisU, kRisS))); |
390 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 418 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
391 | 419 |
392 // SOT + [U] + [S] | 420 // SOT + [U] + [S] |
393 EXPECT_EQ("RRRRF", | 421 EXPECT_EQ("RRRRF", |
394 processSequenceBackward(&machine, asCodePoints(kRisU, kRisS))); | 422 processSequenceBackward(&machine, asCodePoints(kRisU, kRisS))); |
395 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 423 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
396 | 424 |
397 // [Lead] + [U] + [S] | 425 // [Lead] + [U] + [S] |
398 EXPECT_EQ("RRRRF", processSequenceBackward( | 426 EXPECT_EQ( |
399 &machine, asCodePoints(kLead, kRisU, kRisS))); | 427 "RRRRF", |
| 428 processSequenceBackward(&machine, asCodePoints(kLead, kRisU, kRisS))); |
400 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 429 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
401 | 430 |
402 // 'a' + [Trail] + [U] + [S] | 431 // 'a' + [Trail] + [U] + [S] |
403 EXPECT_EQ("RRRRRF", processSequenceBackward( | 432 EXPECT_EQ("RRRRRF", |
404 &machine, asCodePoints('a', kTrail, kRisU, kRisS))); | 433 processSequenceBackward(&machine, |
| 434 asCodePoints('a', kTrail, kRisU, kRisS))); |
405 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 435 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
406 | 436 |
407 // [Trail] + [Trail] + [U] + [S] | 437 // [Trail] + [Trail] + [U] + [S] |
408 EXPECT_EQ("RRRRRF", | 438 EXPECT_EQ("RRRRRF", |
409 processSequenceBackward( | 439 processSequenceBackward( |
410 &machine, asCodePoints(kTrail, kTrail, kRisU, kRisS))); | 440 &machine, asCodePoints(kTrail, kTrail, kRisU, kRisS))); |
411 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 441 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
412 | 442 |
413 // SOT + [Trail] + [U] + [S] | 443 // SOT + [Trail] + [U] + [S] |
414 EXPECT_EQ("RRRRRF", processSequenceBackward( | 444 EXPECT_EQ( |
415 &machine, asCodePoints(kTrail, kRisU, kRisS))); | 445 "RRRRRF", |
| 446 processSequenceBackward(&machine, asCodePoints(kTrail, kRisU, kRisS))); |
416 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 447 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
417 } | 448 } |
418 | 449 |
419 TEST_F(BackwardGraphemeBoundaryStatemachineTest, Flags_twoFlags) { | 450 TEST_F(BackwardGraphemeBoundaryStatemachineTest, Flags_twoFlags) { |
420 BackwardGraphemeBoundaryStateMachine machine; | 451 BackwardGraphemeBoundaryStateMachine machine; |
421 | 452 |
422 // 'a' + [U] + [S] + [U] + [S] | 453 // 'a' + [U] + [S] + [U] + [S] |
423 EXPECT_EQ("RRRRRRRRF", | 454 EXPECT_EQ("RRRRRRRRF", |
424 processSequenceBackward( | 455 processSequenceBackward( |
425 &machine, asCodePoints('a', kRisU, kRisS, kRisU, kRisS))); | 456 &machine, asCodePoints('a', kRisU, kRisS, kRisU, kRisS))); |
(...skipping 11 matching lines...) Expand all Loading... |
437 asCodePoints(kRisU, kRisS, kRisU, kRisS))); | 468 asCodePoints(kRisU, kRisS, kRisU, kRisS))); |
438 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 469 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
439 | 470 |
440 // [Lead] + [U] + [S] + [U] + [S] | 471 // [Lead] + [U] + [S] + [U] + [S] |
441 EXPECT_EQ("RRRRRRRRF", | 472 EXPECT_EQ("RRRRRRRRF", |
442 processSequenceBackward( | 473 processSequenceBackward( |
443 &machine, asCodePoints(kLead, kRisU, kRisS, kRisU, kRisS))); | 474 &machine, asCodePoints(kLead, kRisU, kRisS, kRisU, kRisS))); |
444 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 475 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
445 | 476 |
446 // 'a' + [Trail] + [U] + [S] + [U] + [S] | 477 // 'a' + [Trail] + [U] + [S] + [U] + [S] |
447 EXPECT_EQ("RRRRRRRRRF", processSequenceBackward( | 478 EXPECT_EQ( |
448 &machine, asCodePoints('a', kTrail, kRisU, kRisS, | 479 "RRRRRRRRRF", |
449 kRisU, kRisS))); | 480 processSequenceBackward( |
| 481 &machine, asCodePoints('a', kTrail, kRisU, kRisS, kRisU, kRisS))); |
450 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 482 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
451 | 483 |
452 // [Trail] + [Trail] + [U] + [S] + [U] + [S] | 484 // [Trail] + [Trail] + [U] + [S] + [U] + [S] |
453 EXPECT_EQ("RRRRRRRRRF", processSequenceBackward( | 485 EXPECT_EQ( |
454 &machine, asCodePoints(kTrail, kTrail, kRisU, | 486 "RRRRRRRRRF", |
455 kRisS, kRisU, kRisS))); | 487 processSequenceBackward( |
| 488 &machine, asCodePoints(kTrail, kTrail, kRisU, kRisS, kRisU, kRisS))); |
456 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 489 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
457 | 490 |
458 // SOT + [Trail] + [U] + [S] + [U] + [S] | 491 // SOT + [Trail] + [U] + [S] + [U] + [S] |
459 EXPECT_EQ("RRRRRRRRRF", | 492 EXPECT_EQ("RRRRRRRRRF", |
460 processSequenceBackward( | 493 processSequenceBackward( |
461 &machine, asCodePoints(kTrail, kRisU, kRisS, kRisU, kRisS))); | 494 &machine, asCodePoints(kTrail, kRisU, kRisS, kRisU, kRisS))); |
462 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); | 495 EXPECT_EQ(-4, machine.finalizeAndGetBoundaryOffset()); |
463 } | 496 } |
464 | 497 |
465 TEST_F(BackwardGraphemeBoundaryStatemachineTest, Flags_oddNumberedRIS) { | 498 TEST_F(BackwardGraphemeBoundaryStatemachineTest, Flags_oddNumberedRIS) { |
466 BackwardGraphemeBoundaryStateMachine machine; | 499 BackwardGraphemeBoundaryStateMachine machine; |
467 | 500 |
468 // 'a' + [U] + [S] + [U] | 501 // 'a' + [U] + [S] + [U] |
469 EXPECT_EQ("RRRRRRF", processSequenceBackward( | 502 EXPECT_EQ("RRRRRRF", |
470 &machine, asCodePoints('a', kRisU, kRisS, kRisU))); | 503 processSequenceBackward(&machine, |
| 504 asCodePoints('a', kRisU, kRisS, kRisU))); |
471 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 505 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
472 | 506 |
473 // U+1F441 + [U] + [S] + [U] | 507 // U+1F441 + [U] + [S] + [U] |
474 EXPECT_EQ("RRRRRRRF", processSequenceBackward( | 508 EXPECT_EQ("RRRRRRRF", |
475 &machine, asCodePoints(kEye, kRisU, kRisS, kRisU))); | 509 processSequenceBackward(&machine, |
| 510 asCodePoints(kEye, kRisU, kRisS, kRisU))); |
476 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 511 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
477 | 512 |
478 // SOT + [U] + [S] + [U] | 513 // SOT + [U] + [S] + [U] |
479 EXPECT_EQ("RRRRRRF", processSequenceBackward( | 514 EXPECT_EQ( |
480 &machine, asCodePoints(kRisU, kRisS, kRisU))); | 515 "RRRRRRF", |
| 516 processSequenceBackward(&machine, asCodePoints(kRisU, kRisS, kRisU))); |
481 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 517 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
482 | 518 |
483 // [Lead] + [U] + [S] + [U] | 519 // [Lead] + [U] + [S] + [U] |
484 EXPECT_EQ("RRRRRRF", processSequenceBackward( | 520 EXPECT_EQ("RRRRRRF", |
485 &machine, asCodePoints(kLead, kRisU, kRisS, kRisU))); | 521 processSequenceBackward(&machine, |
| 522 asCodePoints(kLead, kRisU, kRisS, kRisU))); |
486 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 523 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
487 | 524 |
488 // 'a' + [Trail] + [U] + [S] + [U] | 525 // 'a' + [Trail] + [U] + [S] + [U] |
489 EXPECT_EQ("RRRRRRRF", | 526 EXPECT_EQ("RRRRRRRF", |
490 processSequenceBackward( | 527 processSequenceBackward( |
491 &machine, asCodePoints('a', kTrail, kRisU, kRisS, kRisU))); | 528 &machine, asCodePoints('a', kTrail, kRisU, kRisS, kRisU))); |
492 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 529 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
493 | 530 |
494 // [Trail] + [Trail] + [U] + [S] + [U] | 531 // [Trail] + [Trail] + [U] + [S] + [U] |
495 EXPECT_EQ("RRRRRRRF", | 532 EXPECT_EQ("RRRRRRRF", |
496 processSequenceBackward( | 533 processSequenceBackward( |
497 &machine, asCodePoints(kTrail, kTrail, kRisU, kRisS, kRisU))); | 534 &machine, asCodePoints(kTrail, kTrail, kRisU, kRisS, kRisU))); |
498 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 535 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
499 | 536 |
500 // SOT + [Trail] + [U] + [S] + [U] | 537 // SOT + [Trail] + [U] + [S] + [U] |
501 EXPECT_EQ("RRRRRRRF", | 538 EXPECT_EQ("RRRRRRRF", |
502 processSequenceBackward(&machine, | 539 processSequenceBackward(&machine, |
503 asCodePoints(kTrail, kRisU, kRisS, kRisU))); | 540 asCodePoints(kTrail, kRisU, kRisS, kRisU))); |
504 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); | 541 EXPECT_EQ(-2, machine.finalizeAndGetBoundaryOffset()); |
505 } | 542 } |
506 } // namespace blink | 543 } // namespace blink |
OLD | NEW |