?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed unused icon resources from app_list.
[chromium-blink-merge.git] / ui / gfx / render_text_unittest.cc
blob859689b5febce093495cea438fc1b3a3dd0d523d
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "ui/gfx/render_text.h"
6
7 #include <algorithm>
8
9 #include "base/format_macros.h"
10 #include "base/i18n/break_iterator.h"
11 #include "base/memory/scoped_ptr.h"
12 #include "base/strings/string_util.h"
13 #include "base/strings/stringprintf.h"
14 #include "base/strings/utf_string_conversions.h"
15 #include "testing/gtest/include/gtest/gtest.h"
16 #include "ui/gfx/break_list.h"
17 #include "ui/gfx/canvas.h"
18 #include "ui/gfx/font.h"
19 #include "ui/gfx/render_text_harfbuzz.h"
20
21 #if defined(OS_WIN)
22 #include "base/win/windows_version.h"
23 #include "ui/gfx/platform_font_win.h"
24 #include "ui/gfx/render_text_win.h"
25 #endif
26
27 #if defined(OS_LINUX) && !defined(USE_OZONE)
28 #include "ui/gfx/render_text_pango.h"
29 #endif
30
31 using base::ASCIIToUTF16;
32 using base::UTF8ToUTF16;
33 using base::WideToUTF16;
34 using base::WideToUTF8;
35
36 namespace gfx {
37
38 namespace {
39
40 // Various weak, LTR, RTL, and Bidi string cases with three characters each.
41 const wchar_t kWeak[] = L" . ";
42 const wchar_t kLtr[] = L"abc";
43 const wchar_t kRtl[] = L"\x5d0\x5d1\x5d2";
44 #if !defined(OS_MACOSX)
45 const wchar_t kLtrRtl[] = L"a" L"\x5d0\x5d1";
46 const wchar_t kLtrRtlLtr[] = L"a" L"\x5d1" L"b";
47 const wchar_t kRtlLtr[] = L"\x5d0\x5d1" L"a";
48 const wchar_t kRtlLtrRtl[] = L"\x5d0" L"a" L"\x5d1";
49 #endif
50
51 // Checks whether |range| contains |index|. This is not the same as calling
52 // range.Contains(Range(index)), which returns true if |index| == |range.end()|.
53 bool IndexInRange(const Range& range, size_t index) {
54 return index >= range.start() && index < range.end();
55 }
56
57 base::string16 GetSelectedText(RenderText* render_text) {
58 return render_text->text().substr(render_text->selection().GetMin(),
59 render_text->selection().length());
60 }
61
62 // A test utility function to set the application default text direction.
63 void SetRTL(bool rtl) {
64 // Override the current locale/direction.
65 base::i18n::SetICUDefaultLocale(rtl ? "he" : "en");
66 EXPECT_EQ(rtl, base::i18n::IsRTL());
67 }
68
69 #if !defined(OS_MACOSX)
70 // Ensure cursor movement in the specified |direction| yields |expected| values.
71 void RunMoveCursorLeftRightTest(RenderText* render_text,
72 const std::vector<SelectionModel>& expected,
73 VisualCursorDirection direction) {
74 for (size_t i = 0; i < expected.size(); ++i) {
75 SCOPED_TRACE(base::StringPrintf("Going %s; expected value index %d.",
76 direction == CURSOR_LEFT ? "left" : "right", static_cast<int>(i)));
77 EXPECT_EQ(expected[i], render_text->selection_model());
78 render_text->MoveCursor(CHARACTER_BREAK, direction, false);
79 }
80 // Check that cursoring is clamped at the line edge.
81 EXPECT_EQ(expected.back(), render_text->selection_model());
82 // Check that it is the line edge.
83 render_text->MoveCursor(LINE_BREAK, direction, false);
84 EXPECT_EQ(expected.back(), render_text->selection_model());
85 }
86 #endif // !defined(OS_MACOSX)
87
88 } // namespace
89
90 class RenderTextTest : public testing::Test {
91 };
92
93 TEST_F(RenderTextTest, DefaultStyle) {
94 // Check the default styles applied to new instances and adjusted text.
95 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
96 EXPECT_TRUE(render_text->text().empty());
97 const wchar_t* const cases[] = { kWeak, kLtr, L"Hello", kRtl, L"", L"" };
98 for (size_t i = 0; i < arraysize(cases); ++i) {
99 EXPECT_TRUE(render_text->colors().EqualsValueForTesting(SK_ColorBLACK));
100 for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
101 EXPECT_TRUE(render_text->styles()[style].EqualsValueForTesting(false));
102 render_text->SetText(WideToUTF16(cases[i]));
103 }
104 }
105
106 TEST_F(RenderTextTest, SetColorAndStyle) {
107 // Ensure custom default styles persist across setting and clearing text.
108 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
109 const SkColor color = SK_ColorRED;
110 render_text->SetColor(color);
111 render_text->SetStyle(BOLD, true);
112 render_text->SetStyle(UNDERLINE, false);
113 const wchar_t* const cases[] = { kWeak, kLtr, L"Hello", kRtl, L"", L"" };
114 for (size_t i = 0; i < arraysize(cases); ++i) {
115 EXPECT_TRUE(render_text->colors().EqualsValueForTesting(color));
116 EXPECT_TRUE(render_text->styles()[BOLD].EqualsValueForTesting(true));
117 EXPECT_TRUE(render_text->styles()[UNDERLINE].EqualsValueForTesting(false));
118 render_text->SetText(WideToUTF16(cases[i]));
119
120 // Ensure custom default styles can be applied after text has been set.
121 if (i == 1)
122 render_text->SetStyle(STRIKE, true);
123 if (i >= 1)
124 EXPECT_TRUE(render_text->styles()[STRIKE].EqualsValueForTesting(true));
125 }
126 }
127
128 TEST_F(RenderTextTest, ApplyColorAndStyle) {
129 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
130 render_text->SetText(ASCIIToUTF16("012345678"));
131
132 // Apply a ranged color and style and check the resulting breaks.
133 render_text->ApplyColor(SK_ColorRED, Range(1, 4));
134 render_text->ApplyStyle(BOLD, true, Range(2, 5));
135 std::vector<std::pair<size_t, SkColor> > expected_color;
136 expected_color.push_back(std::pair<size_t, SkColor>(0, SK_ColorBLACK));
137 expected_color.push_back(std::pair<size_t, SkColor>(1, SK_ColorRED));
138 expected_color.push_back(std::pair<size_t, SkColor>(4, SK_ColorBLACK));
139 EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color));
140 std::vector<std::pair<size_t, bool> > expected_style;
141 expected_style.push_back(std::pair<size_t, bool>(0, false));
142 expected_style.push_back(std::pair<size_t, bool>(2, true));
143 expected_style.push_back(std::pair<size_t, bool>(5, false));
144 EXPECT_TRUE(render_text->styles()[BOLD].EqualsForTesting(expected_style));
145
146 // Ensure setting a color and style overrides the ranged colors and styles.
147 render_text->SetColor(SK_ColorBLUE);
148 EXPECT_TRUE(render_text->colors().EqualsValueForTesting(SK_ColorBLUE));
149 render_text->SetStyle(BOLD, false);
150 EXPECT_TRUE(render_text->styles()[BOLD].EqualsValueForTesting(false));
151
152 // Apply a color and style over the text end and check the resulting breaks.
153 // (INT_MAX should be used instead of the text length for the range end)
154 const size_t text_length = render_text->text().length();
155 render_text->ApplyColor(SK_ColorRED, Range(0, text_length));
156 render_text->ApplyStyle(BOLD, true, Range(2, text_length));
157 std::vector<std::pair<size_t, SkColor> > expected_color_end;
158 expected_color_end.push_back(std::pair<size_t, SkColor>(0, SK_ColorRED));
159 EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color_end));
160 std::vector<std::pair<size_t, bool> > expected_style_end;
161 expected_style_end.push_back(std::pair<size_t, bool>(0, false));
162 expected_style_end.push_back(std::pair<size_t, bool>(2, true));
163 EXPECT_TRUE(render_text->styles()[BOLD].EqualsForTesting(expected_style_end));
164
165 // Ensure ranged values adjust to accommodate text length changes.
166 render_text->ApplyStyle(ITALIC, true, Range(0, 2));
167 render_text->ApplyStyle(ITALIC, true, Range(3, 6));
168 render_text->ApplyStyle(ITALIC, true, Range(7, text_length));
169 std::vector<std::pair<size_t, bool> > expected_italic;
170 expected_italic.push_back(std::pair<size_t, bool>(0, true));
171 expected_italic.push_back(std::pair<size_t, bool>(2, false));
172 expected_italic.push_back(std::pair<size_t, bool>(3, true));
173 expected_italic.push_back(std::pair<size_t, bool>(6, false));
174 expected_italic.push_back(std::pair<size_t, bool>(7, true));
175 EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
176
177 // Changing the text should clear any breaks except for the first one.
178 render_text->SetText(ASCIIToUTF16("0123456"));
179 expected_italic.resize(1);
180 EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
181 render_text->ApplyStyle(ITALIC, false, Range(2, 4));
182 render_text->SetText(ASCIIToUTF16("012345678"));
183 EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
184 render_text->ApplyStyle(ITALIC, false, Range(0, 1));
185 render_text->SetText(ASCIIToUTF16("0123456"));
186 expected_italic.begin()->second = false;
187 EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
188 render_text->ApplyStyle(ITALIC, true, Range(2, 4));
189 render_text->SetText(ASCIIToUTF16("012345678"));
190 EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
191
192 // TODO(tmoniuszko): Enable when RenderTextMac::IsValidCursorIndex is
193 // implemented.
194 #if !defined(OS_MACOSX)
195 // Styles shouldn't be changed mid-grapheme.
196 render_text->SetText(WideToUTF16(
197 L"0" L"\x0915\x093f" L"1" L"\x0915\x093f" L"2"));
198 render_text->ApplyStyle(UNDERLINE, true, Range(2, 5));
199 std::vector<std::pair<size_t, bool> > expected_underline;
200 expected_underline.push_back(std::pair<size_t, bool>(0, false));
201 expected_underline.push_back(std::pair<size_t, bool>(1, true));
202 expected_underline.push_back(std::pair<size_t, bool>(6, false));
203 EXPECT_TRUE(render_text->styles()[UNDERLINE].EqualsForTesting(
204 expected_underline));
205 #endif // OS_MACOSX
206 }
207
208 #if defined(OS_LINUX) && !defined(USE_OZONE)
209 TEST_F(RenderTextTest, PangoAttributes) {
210 scoped_ptr<RenderText> render_text(RenderText::CreateNativeInstance());
211 render_text->SetText(ASCIIToUTF16("012345678"));
212
213 // Apply ranged BOLD/ITALIC styles and check the resulting Pango attributes.
214 render_text->ApplyStyle(BOLD, true, Range(2, 4));
215 render_text->ApplyStyle(ITALIC, true, Range(1, 3));
216
217 struct {
218 int start;
219 int end;
220 bool bold;
221 bool italic;
222 } cases[] = {
223 { 0, 1, false, false },
224 { 1, 2, false, true },
225 { 2, 3, true, true },
226 { 3, 4, true, false },
227 { 4, INT_MAX, false, false },
228 };
229
230 int start = 0, end = 0;
231 RenderTextPango* rt_linux = static_cast<RenderTextPango*>(render_text.get());
232 rt_linux->EnsureLayout();
233 PangoAttrList* attributes = pango_layout_get_attributes(rt_linux->layout_);
234 PangoAttrIterator* iter = pango_attr_list_get_iterator(attributes);
235 for (size_t i = 0; i < arraysize(cases); ++i) {
236 pango_attr_iterator_range(iter, &start, &end);
237 EXPECT_EQ(cases[i].start, start);
238 EXPECT_EQ(cases[i].end, end);
239 PangoFontDescription* font = pango_font_description_new();
240 pango_attr_iterator_get_font(iter, font, NULL, NULL);
241 char* description_string = pango_font_description_to_string(font);
242 const base::string16 desc = ASCIIToUTF16(description_string);
243 const bool bold = desc.find(ASCIIToUTF16("Bold")) != std::string::npos;
244 EXPECT_EQ(cases[i].bold, bold);
245 const bool italic = desc.find(ASCIIToUTF16("Italic")) != std::string::npos;
246 EXPECT_EQ(cases[i].italic, italic);
247 pango_attr_iterator_next(iter);
248 pango_font_description_free(font);
249 g_free(description_string);
250 }
251 EXPECT_FALSE(pango_attr_iterator_next(iter));
252 pango_attr_iterator_destroy(iter);
253 }
254 #endif
255
256 // TODO(asvitkine): Cursor movements tests disabled on Mac because RenderTextMac
257 // does not implement this yet. http://crbug.com/131618
258 #if !defined(OS_MACOSX)
259 void TestVisualCursorMotionInObscuredField(RenderText* render_text,
260 const base::string16& text,
261 bool select) {
262 ASSERT_TRUE(render_text->obscured());
263 render_text->SetText(text);
264 int len = text.length();
265 render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, select);
266 EXPECT_EQ(SelectionModel(Range(select ? 0 : len, len), CURSOR_FORWARD),
267 render_text->selection_model());
268 render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, select);
269 EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
270 for (int j = 1; j <= len; ++j) {
271 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, select);
272 EXPECT_EQ(SelectionModel(Range(select ? 0 : j, j), CURSOR_BACKWARD),
273 render_text->selection_model());
274 }
275 for (int j = len - 1; j >= 0; --j) {
276 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, select);
277 EXPECT_EQ(SelectionModel(Range(select ? 0 : j, j), CURSOR_FORWARD),
278 render_text->selection_model());
279 }
280 render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, select);
281 EXPECT_EQ(SelectionModel(Range(select ? 0 : len, len), CURSOR_FORWARD),
282 render_text->selection_model());
283 render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, select);
284 EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
285 }
286
287 TEST_F(RenderTextTest, ObscuredText) {
288 const base::string16 seuss = ASCIIToUTF16("hop on pop");
289 const base::string16 no_seuss = ASCIIToUTF16("**********");
290 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
291
292 // GetLayoutText() returns asterisks when the obscured bit is set.
293 render_text->SetText(seuss);
294 render_text->SetObscured(true);
295 EXPECT_EQ(seuss, render_text->text());
296 EXPECT_EQ(no_seuss, render_text->GetLayoutText());
297 render_text->SetObscured(false);
298 EXPECT_EQ(seuss, render_text->text());
299 EXPECT_EQ(seuss, render_text->GetLayoutText());
300
301 render_text->SetObscured(true);
302
303 // Surrogate pairs are counted as one code point.
304 const base::char16 invalid_surrogates[] = {0xDC00, 0xD800, 0};
305 render_text->SetText(invalid_surrogates);
306 EXPECT_EQ(ASCIIToUTF16("**"), render_text->GetLayoutText());
307 const base::char16 valid_surrogates[] = {0xD800, 0xDC00, 0};
308 render_text->SetText(valid_surrogates);
309 EXPECT_EQ(ASCIIToUTF16("*"), render_text->GetLayoutText());
310 EXPECT_EQ(0U, render_text->cursor_position());
311 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
312 EXPECT_EQ(2U, render_text->cursor_position());
313
314 // Test index conversion and cursor validity with a valid surrogate pair.
315 EXPECT_EQ(0U, render_text->TextIndexToLayoutIndex(0U));
316 EXPECT_EQ(1U, render_text->TextIndexToLayoutIndex(1U));
317 EXPECT_EQ(1U, render_text->TextIndexToLayoutIndex(2U));
318 EXPECT_EQ(0U, render_text->LayoutIndexToTextIndex(0U));
319 EXPECT_EQ(2U, render_text->LayoutIndexToTextIndex(1U));
320 EXPECT_TRUE(render_text->IsValidCursorIndex(0U));
321 EXPECT_FALSE(render_text->IsValidCursorIndex(1U));
322 EXPECT_TRUE(render_text->IsValidCursorIndex(2U));
323
324 // FindCursorPosition() should not return positions between a surrogate pair.
325 render_text->SetDisplayRect(Rect(0, 0, 20, 20));
326 EXPECT_EQ(render_text->FindCursorPosition(Point(0, 0)).caret_pos(), 0U);
327 EXPECT_EQ(render_text->FindCursorPosition(Point(20, 0)).caret_pos(), 2U);
328 for (int x = -1; x <= 20; ++x) {
329 SelectionModel selection = render_text->FindCursorPosition(Point(x, 0));
330 EXPECT_TRUE(selection.caret_pos() == 0U || selection.caret_pos() == 2U);
331 }
332
333 // GetGlyphBounds() should yield the entire string bounds for text index 0.
334 EXPECT_EQ(render_text->GetStringSize().width(),
335 static_cast<int>(render_text->GetGlyphBounds(0U).length()));
336
337 // Cursoring is independent of underlying characters when text is obscured.
338 const wchar_t* const texts[] = {
339 kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl, kRtlLtr, kRtlLtrRtl,
340 L"hop on pop", // Check LTR word boundaries.
341 L"\x05d0\x05d1 \x05d0\x05d2 \x05d1\x05d2", // Check RTL word boundaries.
342 };
343 for (size_t i = 0; i < arraysize(texts); ++i) {
344 base::string16 text = WideToUTF16(texts[i]);
345 TestVisualCursorMotionInObscuredField(render_text.get(), text, false);
346 TestVisualCursorMotionInObscuredField(render_text.get(), text, true);
347 }
348 }
349
350 TEST_F(RenderTextTest, RevealObscuredText) {
351 const base::string16 seuss = ASCIIToUTF16("hop on pop");
352 const base::string16 no_seuss = ASCIIToUTF16("**********");
353 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
354
355 render_text->SetText(seuss);
356 render_text->SetObscured(true);
357 EXPECT_EQ(seuss, render_text->text());
358 EXPECT_EQ(no_seuss, render_text->GetLayoutText());
359
360 // Valid reveal index and new revealed index clears previous one.
361 render_text->RenderText::SetObscuredRevealIndex(0);
362 EXPECT_EQ(ASCIIToUTF16("h*********"), render_text->GetLayoutText());
363 render_text->RenderText::SetObscuredRevealIndex(1);
364 EXPECT_EQ(ASCIIToUTF16("*o********"), render_text->GetLayoutText());
365 render_text->RenderText::SetObscuredRevealIndex(2);
366 EXPECT_EQ(ASCIIToUTF16("**p*******"), render_text->GetLayoutText());
367
368 // Invalid reveal index.
369 render_text->RenderText::SetObscuredRevealIndex(-1);
370 EXPECT_EQ(no_seuss, render_text->GetLayoutText());
371 render_text->RenderText::SetObscuredRevealIndex(seuss.length() + 1);
372 EXPECT_EQ(no_seuss, render_text->GetLayoutText());
373
374 // SetObscured clears the revealed index.
375 render_text->RenderText::SetObscuredRevealIndex(0);
376 EXPECT_EQ(ASCIIToUTF16("h*********"), render_text->GetLayoutText());
377 render_text->SetObscured(false);
378 EXPECT_EQ(seuss, render_text->GetLayoutText());
379 render_text->SetObscured(true);
380 EXPECT_EQ(no_seuss, render_text->GetLayoutText());
381
382 // SetText clears the revealed index.
383 render_text->SetText(ASCIIToUTF16("new"));
384 EXPECT_EQ(ASCIIToUTF16("***"), render_text->GetLayoutText());
385 render_text->RenderText::SetObscuredRevealIndex(2);
386 EXPECT_EQ(ASCIIToUTF16("**w"), render_text->GetLayoutText());
387 render_text->SetText(ASCIIToUTF16("new longer"));
388 EXPECT_EQ(ASCIIToUTF16("**********"), render_text->GetLayoutText());
389
390 // Text with invalid surrogates.
391 const base::char16 invalid_surrogates[] = {0xDC00, 0xD800, 'h', 'o', 'p', 0};
392 render_text->SetText(invalid_surrogates);
393 EXPECT_EQ(ASCIIToUTF16("*****"), render_text->GetLayoutText());
394 render_text->RenderText::SetObscuredRevealIndex(0);
395 const base::char16 invalid_expect_0[] = {0xDC00, '*', '*', '*', '*', 0};
396 EXPECT_EQ(invalid_expect_0, render_text->GetLayoutText());
397 render_text->RenderText::SetObscuredRevealIndex(1);
398 const base::char16 invalid_expect_1[] = {'*', 0xD800, '*', '*', '*', 0};
399 EXPECT_EQ(invalid_expect_1, render_text->GetLayoutText());
400 render_text->RenderText::SetObscuredRevealIndex(2);
401 EXPECT_EQ(ASCIIToUTF16("**h**"), render_text->GetLayoutText());
402
403 // Text with valid surrogates before and after the reveal index.
404 const base::char16 valid_surrogates[] =
405 {0xD800, 0xDC00, 'h', 'o', 'p', 0xD800, 0xDC00, 0};
406 render_text->SetText(valid_surrogates);
407 EXPECT_EQ(ASCIIToUTF16("*****"), render_text->GetLayoutText());
408 render_text->RenderText::SetObscuredRevealIndex(0);
409 const base::char16 valid_expect_0_and_1[] =
410 {0xD800, 0xDC00, '*', '*', '*', '*', 0};
411 EXPECT_EQ(valid_expect_0_and_1, render_text->GetLayoutText());
412 render_text->RenderText::SetObscuredRevealIndex(1);
413 EXPECT_EQ(valid_expect_0_and_1, render_text->GetLayoutText());
414 render_text->RenderText::SetObscuredRevealIndex(2);
415 EXPECT_EQ(ASCIIToUTF16("*h***"), render_text->GetLayoutText());
416 render_text->RenderText::SetObscuredRevealIndex(5);
417 const base::char16 valid_expect_5_and_6[] =
418 {'*', '*', '*', '*', 0xD800, 0xDC00, 0};
419 EXPECT_EQ(valid_expect_5_and_6, render_text->GetLayoutText());
420 render_text->RenderText::SetObscuredRevealIndex(6);
421 EXPECT_EQ(valid_expect_5_and_6, render_text->GetLayoutText());
422 }
423
424 TEST_F(RenderTextTest, ElidedText) {
425 // TODO(skanuj) : Add more test cases for following
426 // - RenderText styles.
427 // - Cross interaction of truncate, elide and obscure.
428 // - ElideText tests from text_elider.cc.
429 struct {
430 const wchar_t* text;
431 const wchar_t* layout_text;
432 const bool elision_expected;
433 } cases[] = {
434 // Strings shorter than the elision width should be laid out in full.
435 { L"", L"" , false },
436 { L"M", L"" , false },
437 { L" . ", L" . " , false },
438 { kWeak, kWeak , false },
439 { kLtr, kLtr , false },
440 { kLtrRtl, kLtrRtl , false },
441 { kLtrRtlLtr, kLtrRtlLtr, false },
442 { kRtl, kRtl , false },
443 { kRtlLtr, kRtlLtr , false },
444 { kRtlLtrRtl, kRtlLtrRtl, false },
445 // Strings as long as the elision width should be laid out in full.
446 { L"012ab", L"012ab" , false },
447 // Long strings should be elided with an ellipsis appended at the end.
448 { L"012abc", L"012a\x2026", true },
449 { L"012ab" L"\x5d0\x5d1", L"012a\x2026", true },
450 { L"012a" L"\x5d1" L"b", L"012a\x2026", true },
451 // No RLM marker added as digits (012) have weak directionality.
452 { L"01" L"\x5d0\x5d1\x5d2", L"01\x5d0\x5d1\x2026", true },
453 // RLM marker added as "ab" have strong LTR directionality.
454 { L"ab" L"\x5d0\x5d1\x5d2", L"ab\x5d0\x5d1\x2026\x200f", true },
455 // Complex script is not handled. In this example, the "\x0915\x093f" is a
456 // compound glyph, but only half of it is elided.
457 { L"0123\x0915\x093f", L"0123\x0915\x2026", true },
458 // Surrogate pairs should be elided reasonably enough.
459 { L"0\x05e9\x05bc\x05c1\x05b8", L"0\x05e9\x05bc\x05c1\x05b8", false },
460 { L"0\x05e9\x05bc\x05c1\x05b8", L"0\x05e9\x05bc\x2026" , true },
461 { L"01\x05e9\x05bc\x05c1\x05b8", L"01\x05e9\x2026" , true },
462 { L"012\x05e9\x05bc\x05c1\x05b8", L"012\x2026\x200E" , true },
463 { L"012\xF0\x9D\x84\x9E", L"012\xF0\x2026" , true },
464 };
465
466 scoped_ptr<RenderText> expected_render_text(RenderText::CreateInstance());
467 expected_render_text->SetFontList(FontList("serif, Sans serif, 12px"));
468 expected_render_text->SetDisplayRect(Rect(0, 0, 9999, 100));
469
470 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
471 render_text->SetFontList(FontList("serif, Sans serif, 12px"));
472 render_text->SetElideBehavior(ELIDE_TAIL);
473
474 for (size_t i = 0; i < arraysize(cases); i++) {
475 // Compute expected width
476 expected_render_text->SetText(WideToUTF16(cases[i].layout_text));
477 int expected_width = expected_render_text->GetContentWidth();
478
479 base::string16 input = WideToUTF16(cases[i].text);
480 // Extend the input text to ensure that it is wider than the layout_text,
481 // and so it will get elided.
482 if (cases[i].elision_expected)
483 input.append(WideToUTF16(L" MMMMMMMMMMM"));
484
485 render_text->SetText(input);
486 render_text->SetDisplayRect(Rect(0, 0, expected_width, 100));
487 EXPECT_EQ(input, render_text->text())
488 << "->For case " << i << ": " << cases[i].text << "\n";
489 EXPECT_EQ(WideToUTF16(cases[i].layout_text), render_text->GetLayoutText())
490 << "->For case " << i << ": " << cases[i].text << "\n";
491 expected_render_text->SetText(base::string16());
492 }
493 }
494
495 TEST_F(RenderTextTest, ElidedObscuredText) {
496 scoped_ptr<RenderText> expected_render_text(RenderText::CreateInstance());
497 expected_render_text->SetFontList(FontList("serif, Sans serif, 12px"));
498 expected_render_text->SetDisplayRect(Rect(0, 0, 9999, 100));
499 expected_render_text->SetText(WideToUTF16(L"**\x2026"));
500
501 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
502 render_text->SetFontList(FontList("serif, Sans serif, 12px"));
503 render_text->SetElideBehavior(ELIDE_TAIL);
504 render_text->SetDisplayRect(
505 Rect(0, 0, expected_render_text->GetContentWidth(), 100));
506 render_text->SetObscured(true);
507 render_text->SetText(WideToUTF16(L"abcdef"));
508 EXPECT_EQ(WideToUTF16(L"abcdef"), render_text->text());
509 EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text->GetLayoutText());
510 }
511
512 TEST_F(RenderTextTest, TruncatedText) {
513 struct {
514 const wchar_t* text;
515 const wchar_t* layout_text;
516 } cases[] = {
517 // Strings shorter than the truncation length should be laid out in full.
518 { L"", L"" },
519 { kWeak, kWeak },
520 { kLtr, kLtr },
521 { kLtrRtl, kLtrRtl },
522 { kLtrRtlLtr, kLtrRtlLtr },
523 { kRtl, kRtl },
524 { kRtlLtr, kRtlLtr },
525 { kRtlLtrRtl, kRtlLtrRtl },
526 // Strings as long as the truncation length should be laid out in full.
527 { L"01234", L"01234" },
528 // Long strings should be truncated with an ellipsis appended at the end.
529 { L"012345", L"0123\x2026" },
530 { L"012" L" . ", L"012 \x2026" },
531 { L"012" L"abc", L"012a\x2026" },
532 { L"012" L"a" L"\x5d0\x5d1", L"012a\x2026" },
533 { L"012" L"a" L"\x5d1" L"b", L"012a\x2026" },
534 { L"012" L"\x5d0\x5d1\x5d2", L"012\x5d0\x2026" },
535 { L"012" L"\x5d0\x5d1" L"a", L"012\x5d0\x2026" },
536 { L"012" L"\x5d0" L"a" L"\x5d1", L"012\x5d0\x2026" },
537 // Surrogate pairs should be truncated reasonably enough.
538 { L"0123\x0915\x093f", L"0123\x2026" },
539 { L"0\x05e9\x05bc\x05c1\x05b8", L"0\x05e9\x05bc\x05c1\x05b8" },
540 { L"01\x05e9\x05bc\x05c1\x05b8", L"01\x05e9\x05bc\x2026" },
541 { L"012\x05e9\x05bc\x05c1\x05b8", L"012\x05e9\x2026" },
542 { L"0123\x05e9\x05bc\x05c1\x05b8", L"0123\x2026" },
543 { L"01234\x05e9\x05bc\x05c1\x05b8", L"0123\x2026" },
544 { L"012\xF0\x9D\x84\x9E", L"012\xF0\x2026" },
545 };
546
547 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
548 render_text->set_truncate_length(5);
549 for (size_t i = 0; i < arraysize(cases); i++) {
550 render_text->SetText(WideToUTF16(cases[i].text));
551 EXPECT_EQ(WideToUTF16(cases[i].text), render_text->text());
552 EXPECT_EQ(WideToUTF16(cases[i].layout_text), render_text->GetLayoutText())
553 << "For case " << i << ": " << cases[i].text;
554 }
555 }
556
557 TEST_F(RenderTextTest, TruncatedObscuredText) {
558 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
559 render_text->set_truncate_length(3);
560 render_text->SetObscured(true);
561 render_text->SetText(WideToUTF16(L"abcdef"));
562 EXPECT_EQ(WideToUTF16(L"abcdef"), render_text->text());
563 EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text->GetLayoutText());
564 }
565
566 TEST_F(RenderTextTest, TruncatedCursorMovementLTR) {
567 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
568 render_text->set_truncate_length(2);
569 render_text->SetText(WideToUTF16(L"abcd"));
570
571 EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
572 render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
573 EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text->selection_model());
574 render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
575 EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
576
577 std::vector<SelectionModel> expected;
578 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
579 expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
580 // The cursor hops over the ellipsis and elided text to the line end.
581 expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
582 expected.push_back(SelectionModel(4, CURSOR_FORWARD));
583 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
584
585 expected.clear();
586 expected.push_back(SelectionModel(4, CURSOR_FORWARD));
587 // The cursor hops over the elided text to preceeding text.
588 expected.push_back(SelectionModel(1, CURSOR_FORWARD));
589 expected.push_back(SelectionModel(0, CURSOR_FORWARD));
590 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
591 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
592 }
593
594 TEST_F(RenderTextTest, TruncatedCursorMovementRTL) {
595 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
596 render_text->set_truncate_length(2);
597 render_text->SetText(WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3"));
598
599 EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
600 render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
601 EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text->selection_model());
602 render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
603 EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
604
605 std::vector<SelectionModel> expected;
606 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
607 expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
608 // The cursor hops over the ellipsis and elided text to the line end.
609 expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
610 expected.push_back(SelectionModel(4, CURSOR_FORWARD));
611 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
612
613 expected.clear();
614 expected.push_back(SelectionModel(4, CURSOR_FORWARD));
615 // The cursor hops over the elided text to preceeding text.
616 expected.push_back(SelectionModel(1, CURSOR_FORWARD));
617 expected.push_back(SelectionModel(0, CURSOR_FORWARD));
618 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
619 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
620 }
621
622 TEST_F(RenderTextTest, GetTextDirection) {
623 struct {
624 const wchar_t* text;
625 const base::i18n::TextDirection text_direction;
626 } cases[] = {
627 // Blank strings and those with no/weak directionality default to LTR.
628 { L"", base::i18n::LEFT_TO_RIGHT },
629 { kWeak, base::i18n::LEFT_TO_RIGHT },
630 // Strings that begin with strong LTR characters.
631 { kLtr, base::i18n::LEFT_TO_RIGHT },
632 { kLtrRtl, base::i18n::LEFT_TO_RIGHT },
633 { kLtrRtlLtr, base::i18n::LEFT_TO_RIGHT },
634 // Strings that begin with strong RTL characters.
635 { kRtl, base::i18n::RIGHT_TO_LEFT },
636 { kRtlLtr, base::i18n::RIGHT_TO_LEFT },
637 { kRtlLtrRtl, base::i18n::RIGHT_TO_LEFT },
638 };
639
640 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
641 const bool was_rtl = base::i18n::IsRTL();
642
643 for (size_t i = 0; i < 2; ++i) {
644 // Toggle the application default text direction (to try each direction).
645 SetRTL(!base::i18n::IsRTL());
646 const base::i18n::TextDirection ui_direction = base::i18n::IsRTL() ?
647 base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT;
648
649 // Ensure that directionality modes yield the correct text directions.
650 for (size_t j = 0; j < arraysize(cases); j++) {
651 render_text->SetText(WideToUTF16(cases[j].text));
652 render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
653 EXPECT_EQ(render_text->GetTextDirection(), cases[j].text_direction);
654 render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_UI);
655 EXPECT_EQ(render_text->GetTextDirection(), ui_direction);
656 render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
657 EXPECT_EQ(render_text->GetTextDirection(), base::i18n::LEFT_TO_RIGHT);
658 render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_RTL);
659 EXPECT_EQ(render_text->GetTextDirection(), base::i18n::RIGHT_TO_LEFT);
660 }
661 }
662
663 EXPECT_EQ(was_rtl, base::i18n::IsRTL());
664
665 // Ensure that text changes update the direction for DIRECTIONALITY_FROM_TEXT.
666 render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
667 render_text->SetText(WideToUTF16(kLtr));
668 EXPECT_EQ(render_text->GetTextDirection(), base::i18n::LEFT_TO_RIGHT);
669 render_text->SetText(WideToUTF16(kRtl));
670 EXPECT_EQ(render_text->GetTextDirection(), base::i18n::RIGHT_TO_LEFT);
671 }
672
673 TEST_F(RenderTextTest, MoveCursorLeftRightInLtr) {
674 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
675
676 // Pure LTR.
677 render_text->SetText(ASCIIToUTF16("abc"));
678 // |expected| saves the expected SelectionModel when moving cursor from left
679 // to right.
680 std::vector<SelectionModel> expected;
681 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
682 expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
683 expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
684 expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
685 expected.push_back(SelectionModel(3, CURSOR_FORWARD));
686 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
687
688 expected.clear();
689 expected.push_back(SelectionModel(3, CURSOR_FORWARD));
690 expected.push_back(SelectionModel(2, CURSOR_FORWARD));
691 expected.push_back(SelectionModel(1, CURSOR_FORWARD));
692 expected.push_back(SelectionModel(0, CURSOR_FORWARD));
693 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
694 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
695 }
696
697 TEST_F(RenderTextTest, MoveCursorLeftRightInLtrRtl) {
698 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
699 // LTR-RTL
700 render_text->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
701 // The last one is the expected END position.
702 std::vector<SelectionModel> expected;
703 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
704 expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
705 expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
706 expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
707 expected.push_back(SelectionModel(5, CURSOR_FORWARD));
708 expected.push_back(SelectionModel(4, CURSOR_FORWARD));
709 expected.push_back(SelectionModel(3, CURSOR_FORWARD));
710 expected.push_back(SelectionModel(6, CURSOR_FORWARD));
711 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
712
713 expected.clear();
714 expected.push_back(SelectionModel(6, CURSOR_FORWARD));
715 expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
716 expected.push_back(SelectionModel(5, CURSOR_BACKWARD));
717 expected.push_back(SelectionModel(6, CURSOR_BACKWARD));
718 expected.push_back(SelectionModel(2, CURSOR_FORWARD));
719 expected.push_back(SelectionModel(1, CURSOR_FORWARD));
720 expected.push_back(SelectionModel(0, CURSOR_FORWARD));
721 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
722 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
723 }
724
725 TEST_F(RenderTextTest, MoveCursorLeftRightInLtrRtlLtr) {
726 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
727 // LTR-RTL-LTR.
728 render_text->SetText(WideToUTF16(L"a" L"\x05d1" L"b"));
729 std::vector<SelectionModel> expected;
730 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
731 expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
732 expected.push_back(SelectionModel(1, CURSOR_FORWARD));
733 expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
734 expected.push_back(SelectionModel(3, CURSOR_FORWARD));
735 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
736
737 expected.clear();
738 expected.push_back(SelectionModel(3, CURSOR_FORWARD));
739 expected.push_back(SelectionModel(2, CURSOR_FORWARD));
740 expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
741 expected.push_back(SelectionModel(0, CURSOR_FORWARD));
742 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
743 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
744 }
745
746 TEST_F(RenderTextTest, MoveCursorLeftRightInRtl) {
747 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
748 // Pure RTL.
749 render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2"));
750 render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
751 std::vector<SelectionModel> expected;
752
753 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
754 expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
755 expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
756 expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
757 expected.push_back(SelectionModel(3, CURSOR_FORWARD));
758 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
759
760 expected.clear();
761
762 expected.push_back(SelectionModel(3, CURSOR_FORWARD));
763 expected.push_back(SelectionModel(2, CURSOR_FORWARD));
764 expected.push_back(SelectionModel(1, CURSOR_FORWARD));
765 expected.push_back(SelectionModel(0, CURSOR_FORWARD));
766 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
767 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
768 }
769
770 TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtr) {
771 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
772 // RTL-LTR
773 render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2" L"abc"));
774 render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
775 std::vector<SelectionModel> expected;
776 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
777 expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
778 expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
779 expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
780 expected.push_back(SelectionModel(5, CURSOR_FORWARD));
781 expected.push_back(SelectionModel(4, CURSOR_FORWARD));
782 expected.push_back(SelectionModel(3, CURSOR_FORWARD));
783 expected.push_back(SelectionModel(6, CURSOR_FORWARD));
784 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
785
786 expected.clear();
787 expected.push_back(SelectionModel(6, CURSOR_FORWARD));
788 expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
789 expected.push_back(SelectionModel(5, CURSOR_BACKWARD));
790 expected.push_back(SelectionModel(6, CURSOR_BACKWARD));
791 expected.push_back(SelectionModel(2, CURSOR_FORWARD));
792 expected.push_back(SelectionModel(1, CURSOR_FORWARD));
793 expected.push_back(SelectionModel(0, CURSOR_FORWARD));
794 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
795 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
796 }
797
798 TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtrRtl) {
799 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
800 // RTL-LTR-RTL.
801 render_text->SetText(WideToUTF16(L"\x05d0" L"a" L"\x05d1"));
802 render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
803 std::vector<SelectionModel> expected;
804 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
805 expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
806 expected.push_back(SelectionModel(1, CURSOR_FORWARD));
807 expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
808 expected.push_back(SelectionModel(3, CURSOR_FORWARD));
809 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
810
811 expected.clear();
812 expected.push_back(SelectionModel(3, CURSOR_FORWARD));
813 expected.push_back(SelectionModel(2, CURSOR_FORWARD));
814 expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
815 expected.push_back(SelectionModel(0, CURSOR_FORWARD));
816 expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
817 RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
818 }
819
820 // TODO(xji): temporarily disable in platform Win since the complex script
821 // characters turned into empty square due to font regression. So, not able
822 // to test 2 characters belong to the same grapheme.
823 #if defined(OS_LINUX)
824 TEST_F(RenderTextTest, MoveCursorLeftRight_ComplexScript) {
825 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
826
827 render_text->SetText(WideToUTF16(L"\x0915\x093f\x0915\x094d\x0915"));
828 EXPECT_EQ(0U, render_text->cursor_position());
829 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
830 EXPECT_EQ(2U, render_text->cursor_position());
831 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
832 EXPECT_EQ(4U, render_text->cursor_position());
833 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
834 EXPECT_EQ(5U, render_text->cursor_position());
835 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
836 EXPECT_EQ(5U, render_text->cursor_position());
837
838 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
839 EXPECT_EQ(4U, render_text->cursor_position());
840 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
841 EXPECT_EQ(2U, render_text->cursor_position());
842 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
843 EXPECT_EQ(0U, render_text->cursor_position());
844 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
845 EXPECT_EQ(0U, render_text->cursor_position());
846 }
847 #endif
848
849 // TODO(ckocagil): Enable for RenderTextHarfBuzz. http://crbug.com/383265
850 TEST_F(RenderTextTest, MoveCursorLeftRight_MeiryoUILigatures) {
851 scoped_ptr<RenderText> render_text(RenderText::CreateNativeInstance());
852 // Meiryo UI uses single-glyph ligatures for 'ff' and 'ffi', but each letter
853 // (code point) has unique bounds, so mid-glyph cursoring should be possible.
854 render_text->SetFontList(FontList("Meiryo UI, 12px"));
855 render_text->SetText(WideToUTF16(L"ff ffi"));
856 EXPECT_EQ(0U, render_text->cursor_position());
857 for (size_t i = 0; i < render_text->text().length(); ++i) {
858 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
859 EXPECT_EQ(i + 1, render_text->cursor_position());
860 }
861 EXPECT_EQ(6U, render_text->cursor_position());
862 }
863
864 TEST_F(RenderTextTest, GraphemePositions) {
865 // LTR 2-character grapheme, LTR abc, LTR 2-character grapheme.
866 const base::string16 kText1 =
867 WideToUTF16(L"\x0915\x093f" L"abc" L"\x0915\x093f");
868
869 // LTR ab, LTR 2-character grapheme, LTR cd.
870 const base::string16 kText2 = WideToUTF16(L"ab" L"\x0915\x093f" L"cd");
871
872 // The below is 'MUSICAL SYMBOL G CLEF', which is represented in UTF-16 as
873 // two characters forming the surrogate pair 0x0001D11E.
874 const std::string kSurrogate = "\xF0\x9D\x84\x9E";
875
876 // LTR ab, UTF16 surrogate pair, LTR cd.
877 const base::string16 kText3 = UTF8ToUTF16("ab" + kSurrogate + "cd");
878
879 struct {
880 base::string16 text;
881 size_t index;
882 size_t expected_previous;
883 size_t expected_next;
884 } cases[] = {
885 { base::string16(), 0, 0, 0 },
886 { base::string16(), 1, 0, 0 },
887 { base::string16(), 50, 0, 0 },
888 { kText1, 0, 0, 2 },
889 { kText1, 1, 0, 2 },
890 { kText1, 2, 0, 3 },
891 { kText1, 3, 2, 4 },
892 { kText1, 4, 3, 5 },
893 { kText1, 5, 4, 7 },
894 { kText1, 6, 5, 7 },
895 { kText1, 7, 5, 7 },
896 { kText1, 8, 7, 7 },
897 { kText1, 50, 7, 7 },
898 { kText2, 0, 0, 1 },
899 { kText2, 1, 0, 2 },
900 { kText2, 2, 1, 4 },
901 { kText2, 3, 2, 4 },
902 { kText2, 4, 2, 5 },
903 { kText2, 5, 4, 6 },
904 { kText2, 6, 5, 6 },
905 { kText2, 7, 6, 6 },
906 { kText2, 50, 6, 6 },
907 { kText3, 0, 0, 1 },
908 { kText3, 1, 0, 2 },
909 { kText3, 2, 1, 4 },
910 { kText3, 3, 2, 4 },
911 { kText3, 4, 2, 5 },
912 { kText3, 5, 4, 6 },
913 { kText3, 6, 5, 6 },
914 { kText3, 7, 6, 6 },
915 { kText3, 50, 6, 6 },
916 };
917
918 #if defined(OS_WIN)
919 // TODO(msw): XP fails due to lack of font support: http://crbug.com/106450
920 if (base::win::GetVersion() < base::win::VERSION_VISTA)
921 return;
922 #endif
923
924 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
925 for (size_t i = 0; i < arraysize(cases); i++) {
926 SCOPED_TRACE(base::StringPrintf("Testing cases[%" PRIuS "]", i));
927 render_text->SetText(cases[i].text);
928
929 size_t next = render_text->IndexOfAdjacentGrapheme(cases[i].index,
930 CURSOR_FORWARD);
931 EXPECT_EQ(cases[i].expected_next, next);
932 EXPECT_TRUE(render_text->IsValidCursorIndex(next));
933
934 size_t previous = render_text->IndexOfAdjacentGrapheme(cases[i].index,
935 CURSOR_BACKWARD);
936 EXPECT_EQ(cases[i].expected_previous, previous);
937 EXPECT_TRUE(render_text->IsValidCursorIndex(previous));
938 }
939 }
940
941 TEST_F(RenderTextTest, MidGraphemeSelectionBounds) {
942 #if defined(OS_WIN)
943 // TODO(msw): XP fails due to lack of font support: http://crbug.com/106450
944 if (base::win::GetVersion() < base::win::VERSION_VISTA)
945 return;
946 #endif
947
948 // Test that selection bounds may be set amid multi-character graphemes.
949 const base::string16 kHindi = WideToUTF16(L"\x0915\x093f");
950 const base::string16 kThai = WideToUTF16(L"\x0e08\x0e33");
951 const base::string16 cases[] = { kHindi, kThai };
952
953 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
954 for (size_t i = 0; i < arraysize(cases); i++) {
955 SCOPED_TRACE(base::StringPrintf("Testing cases[%" PRIuS "]", i));
956 render_text->SetText(cases[i]);
957 EXPECT_TRUE(render_text->IsValidLogicalIndex(1));
958 #if !defined(OS_MACOSX)
959 EXPECT_FALSE(render_text->IsValidCursorIndex(1));
960 #endif
961 EXPECT_TRUE(render_text->SelectRange(Range(2, 1)));
962 EXPECT_EQ(Range(2, 1), render_text->selection());
963 EXPECT_EQ(1U, render_text->cursor_position());
964 // Although selection bounds may be set within a multi-character grapheme,
965 // cursor movement (e.g. via arrow key) should avoid those indices.
966 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
967 EXPECT_EQ(0U, render_text->cursor_position());
968 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
969 EXPECT_EQ(2U, render_text->cursor_position());
970 }
971 }
972
973 TEST_F(RenderTextTest, FindCursorPosition) {
974 const wchar_t* kTestStrings[] = { kLtrRtl, kLtrRtlLtr, kRtlLtr, kRtlLtrRtl };
975 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
976 render_text->SetDisplayRect(Rect(0, 0, 100, 20));
977 for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
978 SCOPED_TRACE(base::StringPrintf("Testing case[%" PRIuS "]", i));
979 render_text->SetText(WideToUTF16(kTestStrings[i]));
980 for(size_t j = 0; j < render_text->text().length(); ++j) {
981 const Range range(render_text->GetGlyphBounds(j));
982 // Test a point just inside the leading edge of the glyph bounds.
983 int x = range.is_reversed() ? range.GetMax() - 1 : range.GetMin() + 1;
984 EXPECT_EQ(j, render_text->FindCursorPosition(Point(x, 0)).caret_pos());
985 }
986 }
987 }
988
989 TEST_F(RenderTextTest, EdgeSelectionModels) {
990 // Simple Latin text.
991 const base::string16 kLatin = WideToUTF16(L"abc");
992 // LTR 2-character grapheme.
993 const base::string16 kLTRGrapheme = WideToUTF16(L"\x0915\x093f");
994 // LTR 2-character grapheme, LTR a, LTR 2-character grapheme.
995 const base::string16 kHindiLatin =
996 WideToUTF16(L"\x0915\x093f" L"a" L"\x0915\x093f");
997 // RTL 2-character grapheme.
998 const base::string16 kRTLGrapheme = WideToUTF16(L"\x05e0\x05b8");
999 // RTL 2-character grapheme, LTR a, RTL 2-character grapheme.
1000 const base::string16 kHebrewLatin =
1001 WideToUTF16(L"\x05e0\x05b8" L"a" L"\x05e0\x05b8");
1002
1003 struct {
1004 base::string16 text;
1005 base::i18n::TextDirection expected_text_direction;
1006 } cases[] = {
1007 { base::string16(), base::i18n::LEFT_TO_RIGHT },
1008 { kLatin, base::i18n::LEFT_TO_RIGHT },
1009 { kLTRGrapheme, base::i18n::LEFT_TO_RIGHT },
1010 { kHindiLatin, base::i18n::LEFT_TO_RIGHT },
1011 { kRTLGrapheme, base::i18n::RIGHT_TO_LEFT },
1012 { kHebrewLatin, base::i18n::RIGHT_TO_LEFT },
1013 };
1014
1015 #if defined(OS_WIN)
1016 // TODO(msw): XP fails due to lack of font support: http://crbug.com/106450
1017 if (base::win::GetVersion() < base::win::VERSION_VISTA)
1018 return;
1019 #endif
1020
1021 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1022 for (size_t i = 0; i < arraysize(cases); i++) {
1023 render_text->SetText(cases[i].text);
1024 bool ltr = (cases[i].expected_text_direction == base::i18n::LEFT_TO_RIGHT);
1025
1026 SelectionModel start_edge =
1027 render_text->EdgeSelectionModel(ltr ? CURSOR_LEFT : CURSOR_RIGHT);
1028 EXPECT_EQ(start_edge, SelectionModel(0, CURSOR_BACKWARD));
1029
1030 SelectionModel end_edge =
1031 render_text->EdgeSelectionModel(ltr ? CURSOR_RIGHT : CURSOR_LEFT);
1032 EXPECT_EQ(end_edge, SelectionModel(cases[i].text.length(), CURSOR_FORWARD));
1033 }
1034 }
1035
1036 TEST_F(RenderTextTest, SelectAll) {
1037 const wchar_t* const cases[] =
1038 { kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl, kRtlLtr, kRtlLtrRtl };
1039
1040 // Ensure that SelectAll respects the |reversed| argument regardless of
1041 // application locale and text content directionality.
1042 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1043 const SelectionModel expected_reversed(Range(3, 0), CURSOR_FORWARD);
1044 const SelectionModel expected_forwards(Range(0, 3), CURSOR_BACKWARD);
1045 const bool was_rtl = base::i18n::IsRTL();
1046
1047 for (size_t i = 0; i < 2; ++i) {
1048 SetRTL(!base::i18n::IsRTL());
1049 // Test that an empty string produces an empty selection model.
1050 render_text->SetText(base::string16());
1051 EXPECT_EQ(render_text->selection_model(), SelectionModel());
1052
1053 // Test the weak, LTR, RTL, and Bidi string cases.
1054 for (size_t j = 0; j < arraysize(cases); j++) {
1055 render_text->SetText(WideToUTF16(cases[j]));
1056 render_text->SelectAll(false);
1057 EXPECT_EQ(render_text->selection_model(), expected_forwards);
1058 render_text->SelectAll(true);
1059 EXPECT_EQ(render_text->selection_model(), expected_reversed);
1060 }
1061 }
1062
1063 EXPECT_EQ(was_rtl, base::i18n::IsRTL());
1064 }
1065
1066 TEST_F(RenderTextTest, MoveCursorLeftRightWithSelection) {
1067 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1068 render_text->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
1069 // Left arrow on select ranging (6, 4).
1070 render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
1071 EXPECT_EQ(Range(6), render_text->selection());
1072 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
1073 EXPECT_EQ(Range(4), render_text->selection());
1074 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
1075 EXPECT_EQ(Range(5), render_text->selection());
1076 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
1077 EXPECT_EQ(Range(6), render_text->selection());
1078 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, true);
1079 EXPECT_EQ(Range(6, 5), render_text->selection());
1080 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, true);
1081 EXPECT_EQ(Range(6, 4), render_text->selection());
1082 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
1083 EXPECT_EQ(Range(6), render_text->selection());
1084
1085 // Right arrow on select ranging (4, 6).
1086 render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
1087 EXPECT_EQ(Range(0), render_text->selection());
1088 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1089 EXPECT_EQ(Range(1), render_text->selection());
1090 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1091 EXPECT_EQ(Range(2), render_text->selection());
1092 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1093 EXPECT_EQ(Range(3), render_text->selection());
1094 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1095 EXPECT_EQ(Range(5), render_text->selection());
1096 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1097 EXPECT_EQ(Range(4), render_text->selection());
1098 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, true);
1099 EXPECT_EQ(Range(4, 5), render_text->selection());
1100 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, true);
1101 EXPECT_EQ(Range(4, 6), render_text->selection());
1102 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1103 EXPECT_EQ(Range(4), render_text->selection());
1104 }
1105
1106 TEST_F(RenderTextTest, CenteredDisplayOffset) {
1107 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1108 render_text->SetText(ASCIIToUTF16("abcdefghij"));
1109 render_text->SetHorizontalAlignment(ALIGN_CENTER);
1110
1111 const int kEnlargement = 10;
1112 const int content_width = render_text->GetContentWidth();
1113 Rect display_rect(0, 0, content_width / 2,
1114 render_text->font_list().GetHeight());
1115 render_text->SetDisplayRect(display_rect);
1116
1117 // Move the cursor to the beginning of the text and, by checking the cursor
1118 // bounds, make sure no empty space is to the left of the text.
1119 render_text->SetCursorPosition(0);
1120 EXPECT_EQ(display_rect.x(), render_text->GetUpdatedCursorBounds().x());
1121
1122 // Widen the display rect and, by checking the cursor bounds, make sure no
1123 // empty space is introduced to the left of the text.
1124 display_rect.Inset(0, 0, -kEnlargement, 0);
1125 render_text->SetDisplayRect(display_rect);
1126 EXPECT_EQ(display_rect.x(), render_text->GetUpdatedCursorBounds().x());
1127
1128 // Move the cursor to the end of the text and, by checking the cursor bounds,
1129 // make sure no empty space is to the right of the text.
1130 render_text->SetCursorPosition(render_text->text().length());
1131 EXPECT_EQ(display_rect.right(),
1132 render_text->GetUpdatedCursorBounds().right());
1133
1134 // Widen the display rect and, by checking the cursor bounds, make sure no
1135 // empty space is introduced to the right of the text.
1136 display_rect.Inset(0, 0, -kEnlargement, 0);
1137 render_text->SetDisplayRect(display_rect);
1138 EXPECT_EQ(display_rect.right(),
1139 render_text->GetUpdatedCursorBounds().right());
1140 }
1141 #endif // !defined(OS_MACOSX)
1142
1143 // TODO(xji): Make these work on Windows.
1144 #if defined(OS_LINUX)
1145 void MoveLeftRightByWordVerifier(RenderText* render_text,
1146 const wchar_t* str) {
1147 render_text->SetText(WideToUTF16(str));
1148
1149 // Test moving by word from left ro right.
1150 render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
1151 bool first_word = true;
1152 while (true) {
1153 // First, test moving by word from a word break position, such as from
1154 // "|abc def" to "abc| def".
1155 SelectionModel start = render_text->selection_model();
1156 render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1157 SelectionModel end = render_text->selection_model();
1158 if (end == start) // reach the end.
1159 break;
1160
1161 // For testing simplicity, each word is a 3-character word.
1162 int num_of_character_moves = first_word ? 3 : 4;
1163 first_word = false;
1164 render_text->MoveCursorTo(start);
1165 for (int j = 0; j < num_of_character_moves; ++j)
1166 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1167 EXPECT_EQ(end, render_text->selection_model());
1168
1169 // Then, test moving by word from positions inside the word, such as from
1170 // "a|bc def" to "abc| def", and from "ab|c def" to "abc| def".
1171 for (int j = 1; j < num_of_character_moves; ++j) {
1172 render_text->MoveCursorTo(start);
1173 for (int k = 0; k < j; ++k)
1174 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1175 render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1176 EXPECT_EQ(end, render_text->selection_model());
1177 }
1178 }
1179
1180 // Test moving by word from right to left.
1181 render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
1182 first_word = true;
1183 while (true) {
1184 SelectionModel start = render_text->selection_model();
1185 render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
1186 SelectionModel end = render_text->selection_model();
1187 if (end == start) // reach the end.
1188 break;
1189
1190 int num_of_character_moves = first_word ? 3 : 4;
1191 first_word = false;
1192 render_text->MoveCursorTo(start);
1193 for (int j = 0; j < num_of_character_moves; ++j)
1194 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
1195 EXPECT_EQ(end, render_text->selection_model());
1196
1197 for (int j = 1; j < num_of_character_moves; ++j) {
1198 render_text->MoveCursorTo(start);
1199 for (int k = 0; k < j; ++k)
1200 render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
1201 render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
1202 EXPECT_EQ(end, render_text->selection_model());
1203 }
1204 }
1205 }
1206
1207 TEST_F(RenderTextTest, MoveLeftRightByWordInBidiText) {
1208 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1209
1210 // For testing simplicity, each word is a 3-character word.
1211 std::vector<const wchar_t*> test;
1212 test.push_back(L"abc");
1213 test.push_back(L"abc def");
1214 test.push_back(L"\x05E1\x05E2\x05E3");
1215 test.push_back(L"\x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6");
1216 test.push_back(L"abc \x05E1\x05E2\x05E3");
1217 test.push_back(L"abc def \x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6");
1218 test.push_back(L"abc def hij \x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6"
1219 L" \x05E7\x05E8\x05E9");
1220
1221 test.push_back(L"abc \x05E1\x05E2\x05E3 hij");
1222 test.push_back(L"abc def \x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6 hij opq");
1223 test.push_back(L"abc def hij \x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6"
1224 L" \x05E7\x05E8\x05E9" L" opq rst uvw");
1225
1226 test.push_back(L"\x05E1\x05E2\x05E3 abc");
1227 test.push_back(L"\x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6 abc def");
1228 test.push_back(L"\x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6 \x05E7\x05E8\x05E9"
1229 L" abc def hij");
1230
1231 test.push_back(L"\x05D1\x05D2\x05D3 abc \x05E1\x05E2\x05E3");
1232 test.push_back(L"\x05D1\x05D2\x05D3 \x05D4\x05D5\x05D6 abc def"
1233 L" \x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6");
1234 test.push_back(L"\x05D1\x05D2\x05D3 \x05D4\x05D5\x05D6 \x05D7\x05D8\x05D9"
1235 L" abc def hij \x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6"
1236 L" \x05E7\x05E8\x05E9");
1237
1238 for (size_t i = 0; i < test.size(); ++i)
1239 MoveLeftRightByWordVerifier(render_text.get(), test[i]);
1240 }
1241
1242 TEST_F(RenderTextTest, MoveLeftRightByWordInBidiText_TestEndOfText) {
1243 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1244
1245 render_text->SetText(WideToUTF16(L"ab\x05E1"));
1246 // Moving the cursor by word from "abC|" to the left should return "|abC".
1247 // But since end of text is always treated as a word break, it returns
1248 // position "ab|C".
1249 // TODO(xji): Need to make it work as expected.
1250 render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
1251 render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
1252 // EXPECT_EQ(SelectionModel(), render_text->selection_model());
1253
1254 // Moving the cursor by word from "|abC" to the right returns "abC|".
1255 render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
1256 render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1257 EXPECT_EQ(SelectionModel(3, CURSOR_FORWARD), render_text->selection_model());
1258
1259 render_text->SetText(WideToUTF16(L"\x05E1\x05E2" L"a"));
1260 // For logical text "BCa", moving the cursor by word from "aCB|" to the left
1261 // returns "|aCB".
1262 render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
1263 render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
1264 EXPECT_EQ(SelectionModel(3, CURSOR_FORWARD), render_text->selection_model());
1265
1266 // Moving the cursor by word from "|aCB" to the right should return "aCB|".
1267 // But since end of text is always treated as a word break, it returns
1268 // position "a|CB".
1269 // TODO(xji): Need to make it work as expected.
1270 render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
1271 render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1272 // EXPECT_EQ(SelectionModel(), render_text->selection_model());
1273 }
1274
1275 TEST_F(RenderTextTest, MoveLeftRightByWordInTextWithMultiSpaces) {
1276 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1277 render_text->SetText(WideToUTF16(L"abc def"));
1278 render_text->MoveCursorTo(SelectionModel(5, CURSOR_FORWARD));
1279 render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1280 EXPECT_EQ(11U, render_text->cursor_position());
1281
1282 render_text->MoveCursorTo(SelectionModel(5, CURSOR_FORWARD));
1283 render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
1284 EXPECT_EQ(0U, render_text->cursor_position());
1285 }
1286
1287 TEST_F(RenderTextTest, MoveLeftRightByWordInChineseText) {
1288 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1289 render_text->SetText(WideToUTF16(L"\x6211\x4EEC\x53BB\x516C\x56ED\x73A9"));
1290 render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
1291 EXPECT_EQ(0U, render_text->cursor_position());
1292 render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1293 EXPECT_EQ(2U, render_text->cursor_position());
1294 render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1295 EXPECT_EQ(3U, render_text->cursor_position());
1296 render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1297 EXPECT_EQ(5U, render_text->cursor_position());
1298 render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1299 EXPECT_EQ(6U, render_text->cursor_position());
1300 render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1301 EXPECT_EQ(6U, render_text->cursor_position());
1302 }
1303 #endif
1304
1305 // TODO(ckocagil): Remove when RenderTextWin goes away.
1306 #if defined(OS_WIN)
1307 TEST_F(RenderTextTest, Win_LogicalClusters) {
1308 scoped_ptr<RenderTextWin> render_text(
1309 static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
1310
1311 const base::string16 test_string =
1312 WideToUTF16(L"\x0930\x0930\x0930\x0930\x0930");
1313 render_text->SetText(test_string);
1314 render_text->EnsureLayout();
1315 ASSERT_EQ(1U, render_text->runs_.size());
1316 WORD* logical_clusters = render_text->runs_[0]->logical_clusters.get();
1317 for (size_t i = 0; i < test_string.length(); ++i)
1318 EXPECT_EQ(i, logical_clusters[i]);
1319 }
1320 #endif // defined(OS_WIN)
1321
1322 TEST_F(RenderTextTest, StringSizeSanity) {
1323 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1324 render_text->SetText(UTF8ToUTF16("Hello World"));
1325 const Size string_size = render_text->GetStringSize();
1326 EXPECT_GT(string_size.width(), 0);
1327 EXPECT_GT(string_size.height(), 0);
1328 }
1329
1330 TEST_F(RenderTextTest, StringSizeLongStrings) {
1331 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1332 Size previous_string_size;
1333 for (size_t length = 10; length < 1000000; length *= 10) {
1334 render_text->SetText(base::string16(length, 'a'));
1335 const Size string_size = render_text->GetStringSize();
1336 EXPECT_GT(string_size.width(), previous_string_size.width());
1337 EXPECT_GT(string_size.height(), 0);
1338 previous_string_size = string_size;
1339 }
1340 }
1341
1342 // TODO(asvitkine): This test fails because PlatformFontMac uses point font
1343 // sizes instead of pixel sizes like other implementations.
1344 #if !defined(OS_MACOSX)
1345 TEST_F(RenderTextTest, StringSizeEmptyString) {
1346 // Ascent and descent of Arial and Symbol are different on most platforms.
1347 const FontList font_list("Arial,Symbol, 16px");
1348 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1349 render_text->SetFontList(font_list);
1350 render_text->SetDisplayRect(Rect(0, 0, 0, font_list.GetHeight()));
1351
1352 // The empty string respects FontList metrics for non-zero height
1353 // and baseline.
1354 render_text->SetText(base::string16());
1355 EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
1356 EXPECT_EQ(0, render_text->GetStringSize().width());
1357 EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
1358
1359 render_text->SetText(UTF8ToUTF16(" "));
1360 EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
1361 EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
1362 }
1363 #endif // !defined(OS_MACOSX)
1364
1365 TEST_F(RenderTextTest, StringSizeRespectsFontListMetrics) {
1366 // Check that Arial and Symbol have different font metrics.
1367 Font arial_font("Arial", 16);
1368 ASSERT_EQ("arial",
1369 base::StringToLowerASCII(arial_font.GetActualFontNameForTesting()));
1370 Font symbol_font("Symbol", 16);
1371 ASSERT_EQ("symbol",
1372 base::StringToLowerASCII(
1373 symbol_font.GetActualFontNameForTesting()));
1374 EXPECT_NE(arial_font.GetHeight(), symbol_font.GetHeight());
1375 EXPECT_NE(arial_font.GetBaseline(), symbol_font.GetBaseline());
1376 // "a" should be rendered with Arial, not with Symbol.
1377 const char* arial_font_text = "a";
1378 // "®" (registered trademark symbol) should be rendered with Symbol,
1379 // not with Arial.
1380 const char* symbol_font_text = "\xC2\xAE";
1381
1382 Font smaller_font = arial_font;
1383 Font larger_font = symbol_font;
1384 const char* smaller_font_text = arial_font_text;
1385 const char* larger_font_text = symbol_font_text;
1386 if (symbol_font.GetHeight() < arial_font.GetHeight() &&
1387 symbol_font.GetBaseline() < arial_font.GetBaseline()) {
1388 std::swap(smaller_font, larger_font);
1389 std::swap(smaller_font_text, larger_font_text);
1390 }
1391 ASSERT_LT(smaller_font.GetHeight(), larger_font.GetHeight());
1392 ASSERT_LT(smaller_font.GetBaseline(), larger_font.GetBaseline());
1393
1394 // Check |smaller_font_text| is rendered with the smaller font.
1395 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1396 render_text->SetText(UTF8ToUTF16(smaller_font_text));
1397 render_text->SetFontList(FontList(smaller_font));
1398 render_text->SetDisplayRect(Rect(0, 0, 0,
1399 render_text->font_list().GetHeight()));
1400 EXPECT_EQ(smaller_font.GetHeight(), render_text->GetStringSize().height());
1401 EXPECT_EQ(smaller_font.GetBaseline(), render_text->GetBaseline());
1402
1403 // Layout the same text with mixed fonts. The text should be rendered with
1404 // the smaller font, but the height and baseline are determined with the
1405 // metrics of the font list, which is equal to the larger font.
1406 std::vector<Font> fonts;
1407 fonts.push_back(smaller_font); // The primary font is the smaller font.
1408 fonts.push_back(larger_font);
1409 const FontList font_list(fonts);
1410 render_text->SetFontList(font_list);
1411 render_text->SetDisplayRect(Rect(0, 0, 0,
1412 render_text->font_list().GetHeight()));
1413 EXPECT_LT(smaller_font.GetHeight(), render_text->GetStringSize().height());
1414 EXPECT_LT(smaller_font.GetBaseline(), render_text->GetBaseline());
1415 EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
1416 EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
1417 }
1418
1419 TEST_F(RenderTextTest, SetFontList) {
1420 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1421 render_text->SetFontList(FontList("Arial,Symbol, 13px"));
1422 const std::vector<Font>& fonts = render_text->font_list().GetFonts();
1423 ASSERT_EQ(2U, fonts.size());
1424 EXPECT_EQ("Arial", fonts[0].GetFontName());
1425 EXPECT_EQ("Symbol", fonts[1].GetFontName());
1426 EXPECT_EQ(13, render_text->font_list().GetFontSize());
1427 }
1428
1429 TEST_F(RenderTextTest, StringSizeBoldWidth) {
1430 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1431 render_text->SetText(UTF8ToUTF16("Hello World"));
1432
1433 const int plain_width = render_text->GetStringSize().width();
1434 EXPECT_GT(plain_width, 0);
1435
1436 // Apply a bold style and check that the new width is greater.
1437 render_text->SetStyle(BOLD, true);
1438 const int bold_width = render_text->GetStringSize().width();
1439 EXPECT_GT(bold_width, plain_width);
1440
1441 // Now, apply a plain style over the first word only.
1442 render_text->ApplyStyle(BOLD, false, Range(0, 5));
1443 const int plain_bold_width = render_text->GetStringSize().width();
1444 EXPECT_GT(plain_bold_width, plain_width);
1445 EXPECT_LT(plain_bold_width, bold_width);
1446 }
1447
1448 TEST_F(RenderTextTest, StringSizeHeight) {
1449 base::string16 cases[] = {
1450 WideToUTF16(L"Hello World!"), // English
1451 WideToUTF16(L"\x6328\x62f6"), // Japanese
1452 WideToUTF16(L"\x0915\x093f"), // Hindi
1453 WideToUTF16(L"\x05e0\x05b8"), // Hebrew
1454 };
1455
1456 const FontList default_font_list;
1457 const FontList& larger_font_list = default_font_list.DeriveWithSizeDelta(24);
1458 EXPECT_GT(larger_font_list.GetHeight(), default_font_list.GetHeight());
1459
1460 for (size_t i = 0; i < arraysize(cases); i++) {
1461 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1462 render_text->SetFontList(default_font_list);
1463 render_text->SetText(cases[i]);
1464
1465 const int height1 = render_text->GetStringSize().height();
1466 EXPECT_GT(height1, 0);
1467
1468 // Check that setting the larger font increases the height.
1469 render_text->SetFontList(larger_font_list);
1470 const int height2 = render_text->GetStringSize().height();
1471 EXPECT_GT(height2, height1);
1472 }
1473 }
1474
1475 TEST_F(RenderTextTest, GetBaselineSanity) {
1476 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1477 render_text->SetText(UTF8ToUTF16("Hello World"));
1478 const int baseline = render_text->GetBaseline();
1479 EXPECT_GT(baseline, 0);
1480 }
1481
1482 TEST_F(RenderTextTest, CursorBoundsInReplacementMode) {
1483 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1484 render_text->SetText(ASCIIToUTF16("abcdefg"));
1485 render_text->SetDisplayRect(Rect(100, 17));
1486 SelectionModel sel_b(1, CURSOR_FORWARD);
1487 SelectionModel sel_c(2, CURSOR_FORWARD);
1488 Rect cursor_around_b = render_text->GetCursorBounds(sel_b, false);
1489 Rect cursor_before_b = render_text->GetCursorBounds(sel_b, true);
1490 Rect cursor_before_c = render_text->GetCursorBounds(sel_c, true);
1491 EXPECT_EQ(cursor_around_b.x(), cursor_before_b.x());
1492 EXPECT_EQ(cursor_around_b.right(), cursor_before_c.x());
1493 }
1494
1495 TEST_F(RenderTextTest, GetTextOffset) {
1496 // The default horizontal text offset differs for LTR and RTL, and is only set
1497 // when the RenderText object is created. This test will check the default in
1498 // LTR mode, and the next test will check the RTL default.
1499 const bool was_rtl = base::i18n::IsRTL();
1500 SetRTL(false);
1501 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1502 render_text->SetText(ASCIIToUTF16("abcdefg"));
1503 render_text->SetFontList(FontList("Arial, 13px"));
1504
1505 // Set display area's size equal to the font size.
1506 const Size font_size(render_text->GetContentWidth(),
1507 render_text->font_list().GetHeight());
1508 Rect display_rect(font_size);
1509 render_text->SetDisplayRect(display_rect);
1510
1511 Vector2d offset = render_text->GetLineOffset(0);
1512 EXPECT_TRUE(offset.IsZero());
1513
1514 const int kEnlargementX = 2;
1515 display_rect.Inset(0, 0, -kEnlargementX, 0);
1516 render_text->SetDisplayRect(display_rect);
1517
1518 // Check the default horizontal alignment.
1519 offset = render_text->GetLineOffset(0);
1520 EXPECT_EQ(0, offset.x());
1521
1522 // Check explicitly setting the horizontal alignment.
1523 render_text->SetHorizontalAlignment(ALIGN_LEFT);
1524 offset = render_text->GetLineOffset(0);
1525 EXPECT_EQ(0, offset.x());
1526 render_text->SetHorizontalAlignment(ALIGN_CENTER);
1527 offset = render_text->GetLineOffset(0);
1528 EXPECT_EQ(kEnlargementX / 2, offset.x());
1529 render_text->SetHorizontalAlignment(ALIGN_RIGHT);
1530 offset = render_text->GetLineOffset(0);
1531 EXPECT_EQ(kEnlargementX, offset.x());
1532
1533 // Check that text is vertically centered within taller display rects.
1534 const int kEnlargementY = display_rect.height();
1535 display_rect.Inset(0, 0, 0, -kEnlargementY);
1536 render_text->SetDisplayRect(display_rect);
1537 const Vector2d prev_offset = render_text->GetLineOffset(0);
1538 display_rect.Inset(0, 0, 0, -2 * kEnlargementY);
1539 render_text->SetDisplayRect(display_rect);
1540 offset = render_text->GetLineOffset(0);
1541 EXPECT_EQ(prev_offset.y() + kEnlargementY, offset.y());
1542
1543 SetRTL(was_rtl);
1544 }
1545
1546 TEST_F(RenderTextTest, GetTextOffsetHorizontalDefaultInRTL) {
1547 // This only checks the default horizontal alignment in RTL mode; all other
1548 // GetLineOffset(0) attributes are checked by the test above.
1549 const bool was_rtl = base::i18n::IsRTL();
1550 SetRTL(true);
1551 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1552 render_text->SetText(ASCIIToUTF16("abcdefg"));
1553 render_text->SetFontList(FontList("Arial, 13px"));
1554 const int kEnlargement = 2;
1555 const Size font_size(render_text->GetContentWidth() + kEnlargement,
1556 render_text->GetStringSize().height());
1557 Rect display_rect(font_size);
1558 render_text->SetDisplayRect(display_rect);
1559 Vector2d offset = render_text->GetLineOffset(0);
1560 EXPECT_EQ(kEnlargement, offset.x());
1561 SetRTL(was_rtl);
1562 }
1563
1564 TEST_F(RenderTextTest, SetDisplayOffset) {
1565 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1566 render_text->SetText(ASCIIToUTF16("abcdefg"));
1567 render_text->SetFontList(FontList("Arial, 13px"));
1568
1569 const Size font_size(render_text->GetContentWidth(),
1570 render_text->font_list().GetHeight());
1571 const int kEnlargement = 10;
1572
1573 // Set display width |kEnlargement| pixels greater than content width and test
1574 // different possible situations. In this case the only possible display
1575 // offset is zero.
1576 Rect display_rect(font_size);
1577 display_rect.Inset(0, 0, -kEnlargement, 0);
1578 render_text->SetDisplayRect(display_rect);
1579
1580 struct {
1581 HorizontalAlignment alignment;
1582 int offset;
1583 } small_content_cases[] = {
1584 { ALIGN_LEFT, -kEnlargement },
1585 { ALIGN_LEFT, 0 },
1586 { ALIGN_LEFT, kEnlargement },
1587 { ALIGN_RIGHT, -kEnlargement },
1588 { ALIGN_RIGHT, 0 },
1589 { ALIGN_RIGHT, kEnlargement },
1590 { ALIGN_CENTER, -kEnlargement },
1591 { ALIGN_CENTER, 0 },
1592 { ALIGN_CENTER, kEnlargement },
1593 };
1594
1595 for (size_t i = 0; i < arraysize(small_content_cases); i++) {
1596 render_text->SetHorizontalAlignment(small_content_cases[i].alignment);
1597 render_text->SetDisplayOffset(small_content_cases[i].offset);
1598 EXPECT_EQ(0, render_text->GetUpdatedDisplayOffset().x());
1599 }
1600
1601 // Set display width |kEnlargement| pixels less than content width and test
1602 // different possible situations.
1603 display_rect = Rect(font_size);
1604 display_rect.Inset(0, 0, kEnlargement, 0);
1605 render_text->SetDisplayRect(display_rect);
1606
1607 struct {
1608 HorizontalAlignment alignment;
1609 int offset;
1610 int expected_offset;
1611 } large_content_cases[] = {
1612 // When text is left-aligned, display offset can be in range
1613 // [-kEnlargement, 0].
1614 { ALIGN_LEFT, -2 * kEnlargement, -kEnlargement },
1615 { ALIGN_LEFT, -kEnlargement / 2, -kEnlargement / 2 },
1616 { ALIGN_LEFT, kEnlargement, 0 },
1617 // When text is right-aligned, display offset can be in range
1618 // [0, kEnlargement].
1619 { ALIGN_RIGHT, -kEnlargement, 0 },
1620 { ALIGN_RIGHT, kEnlargement / 2, kEnlargement / 2 },
1621 { ALIGN_RIGHT, 2 * kEnlargement, kEnlargement },
1622 // When text is center-aligned, display offset can be in range
1623 // [-kEnlargement / 2 - 1, (kEnlargement - 1) / 2].
1624 { ALIGN_CENTER, -kEnlargement, -kEnlargement / 2 - 1 },
1625 { ALIGN_CENTER, -kEnlargement / 4, -kEnlargement / 4 },
1626 { ALIGN_CENTER, kEnlargement / 4, kEnlargement / 4 },
1627 { ALIGN_CENTER, kEnlargement, (kEnlargement - 1) / 2 },
1628 };
1629
1630 for (size_t i = 0; i < arraysize(large_content_cases); i++) {
1631 render_text->SetHorizontalAlignment(large_content_cases[i].alignment);
1632 render_text->SetDisplayOffset(large_content_cases[i].offset);
1633 EXPECT_EQ(large_content_cases[i].expected_offset,
1634 render_text->GetUpdatedDisplayOffset().x());
1635 }
1636 }
1637
1638 TEST_F(RenderTextTest, SameFontForParentheses) {
1639 struct {
1640 const base::char16 left_char;
1641 const base::char16 right_char;
1642 } punctuation_pairs[] = {
1643 { '(', ')' },
1644 { '{', '}' },
1645 { '<', '>' },
1646 };
1647 struct {
1648 base::string16 text;
1649 } cases[] = {
1650 // English(English)
1651 { WideToUTF16(L"Hello World(a)") },
1652 // English(English)English
1653 { WideToUTF16(L"Hello World(a)Hello World") },
1654
1655 // Japanese(English)
1656 { WideToUTF16(L"\x6328\x62f6(a)") },
1657 // Japanese(English)Japanese
1658 { WideToUTF16(L"\x6328\x62f6(a)\x6328\x62f6") },
1659 // English(Japanese)English
1660 { WideToUTF16(L"Hello World(\x6328\x62f6)Hello World") },
1661
1662 // Hindi(English)
1663 { WideToUTF16(L"\x0915\x093f(a)") },
1664 // Hindi(English)Hindi
1665 { WideToUTF16(L"\x0915\x093f(a)\x0915\x093f") },
1666 // English(Hindi)English
1667 { WideToUTF16(L"Hello World(\x0915\x093f)Hello World") },
1668
1669 // Hebrew(English)
1670 { WideToUTF16(L"\x05e0\x05b8(a)") },
1671 // Hebrew(English)Hebrew
1672 { WideToUTF16(L"\x05e0\x05b8(a)\x05e0\x05b8") },
1673 // English(Hebrew)English
1674 { WideToUTF16(L"Hello World(\x05e0\x05b8)Hello World") },
1675 };
1676
1677 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1678 for (size_t i = 0; i < arraysize(cases); ++i) {
1679 base::string16 text = cases[i].text;
1680 const size_t start_paren_char_index = text.find('(');
1681 ASSERT_NE(base::string16::npos, start_paren_char_index);
1682 const size_t end_paren_char_index = text.find(')');
1683 ASSERT_NE(base::string16::npos, end_paren_char_index);
1684
1685 for (size_t j = 0; j < arraysize(punctuation_pairs); ++j) {
1686 text[start_paren_char_index] = punctuation_pairs[j].left_char;
1687 text[end_paren_char_index] = punctuation_pairs[j].right_char;
1688 render_text->SetText(text);
1689
1690 const std::vector<RenderText::FontSpan> spans =
1691 render_text->GetFontSpansForTesting();
1692
1693 int start_paren_span_index = -1;
1694 int end_paren_span_index = -1;
1695 for (size_t k = 0; k < spans.size(); ++k) {
1696 if (IndexInRange(spans[k].second, start_paren_char_index))
1697 start_paren_span_index = k;
1698 if (IndexInRange(spans[k].second, end_paren_char_index))
1699 end_paren_span_index = k;
1700 }
1701 ASSERT_NE(-1, start_paren_span_index);
1702 ASSERT_NE(-1, end_paren_span_index);
1703
1704 const Font& start_font = spans[start_paren_span_index].first;
1705 const Font& end_font = spans[end_paren_span_index].first;
1706 EXPECT_EQ(start_font.GetFontName(), end_font.GetFontName());
1707 EXPECT_EQ(start_font.GetFontSize(), end_font.GetFontSize());
1708 EXPECT_EQ(start_font.GetStyle(), end_font.GetStyle());
1709 }
1710 }
1711 }
1712
1713 // Make sure the caret width is always >=1 so that the correct
1714 // caret is drawn at high DPI. crbug.com/164100.
1715 TEST_F(RenderTextTest, CaretWidth) {
1716 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1717 render_text->SetText(ASCIIToUTF16("abcdefg"));
1718 EXPECT_GE(render_text->GetUpdatedCursorBounds().width(), 1);
1719 }
1720
1721 TEST_F(RenderTextTest, SelectWord) {
1722 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1723 render_text->SetText(ASCIIToUTF16(" foo a.bc.d bar"));
1724
1725 struct {
1726 size_t cursor;
1727 size_t selection_start;
1728 size_t selection_end;
1729 } cases[] = {
1730 { 0, 0, 1 },
1731 { 1, 1, 4 },
1732 { 2, 1, 4 },
1733 { 3, 1, 4 },
1734 { 4, 4, 6 },
1735 { 5, 4, 6 },
1736 { 6, 6, 7 },
1737 { 7, 7, 8 },
1738 { 8, 8, 10 },
1739 { 9, 8, 10 },
1740 { 10, 10, 11 },
1741 { 11, 11, 12 },
1742 { 12, 12, 13 },
1743 { 13, 13, 16 },
1744 { 14, 13, 16 },
1745 { 15, 13, 16 },
1746 { 16, 13, 16 },
1747 };
1748
1749 for (size_t i = 0; i < arraysize(cases); ++i) {
1750 render_text->SetCursorPosition(cases[i].cursor);
1751 render_text->SelectWord();
1752 EXPECT_EQ(Range(cases[i].selection_start, cases[i].selection_end),
1753 render_text->selection());
1754 }
1755 }
1756
1757 // Make sure the last word is selected when the cursor is at text.length().
1758 TEST_F(RenderTextTest, LastWordSelected) {
1759 const std::string kTestURL1 = "http://www.google.com";
1760 const std::string kTestURL2 = "http://www.google.com/something/";
1761
1762 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1763
1764 render_text->SetText(ASCIIToUTF16(kTestURL1));
1765 render_text->SetCursorPosition(kTestURL1.length());
1766 render_text->SelectWord();
1767 EXPECT_EQ(ASCIIToUTF16("com"), GetSelectedText(render_text.get()));
1768 EXPECT_FALSE(render_text->selection().is_reversed());
1769
1770 render_text->SetText(ASCIIToUTF16(kTestURL2));
1771 render_text->SetCursorPosition(kTestURL2.length());
1772 render_text->SelectWord();
1773 EXPECT_EQ(ASCIIToUTF16("/"), GetSelectedText(render_text.get()));
1774 EXPECT_FALSE(render_text->selection().is_reversed());
1775 }
1776
1777 // When given a non-empty selection, SelectWord should expand the selection to
1778 // nearest word boundaries.
1779 TEST_F(RenderTextTest, SelectMultipleWords) {
1780 const std::string kTestURL = "http://www.google.com";
1781
1782 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1783
1784 render_text->SetText(ASCIIToUTF16(kTestURL));
1785 render_text->SelectRange(Range(16, 20));
1786 render_text->SelectWord();
1787 EXPECT_EQ(ASCIIToUTF16("google.com"), GetSelectedText(render_text.get()));
1788 EXPECT_FALSE(render_text->selection().is_reversed());
1789
1790 // SelectWord should preserve the selection direction.
1791 render_text->SelectRange(Range(20, 16));
1792 render_text->SelectWord();
1793 EXPECT_EQ(ASCIIToUTF16("google.com"), GetSelectedText(render_text.get()));
1794 EXPECT_TRUE(render_text->selection().is_reversed());
1795 }
1796
1797 // TODO(asvitkine): Cursor movements tests disabled on Mac because RenderTextMac
1798 // does not implement this yet. http://crbug.com/131618
1799 #if !defined(OS_MACOSX)
1800 TEST_F(RenderTextTest, DisplayRectShowsCursorLTR) {
1801 ASSERT_FALSE(base::i18n::IsRTL());
1802 ASSERT_FALSE(base::i18n::ICUIsRTL());
1803
1804 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1805 render_text->SetText(WideToUTF16(L"abcdefghijklmnopqrstuvwxzyabcdefg"));
1806 render_text->MoveCursorTo(SelectionModel(render_text->text().length(),
1807 CURSOR_FORWARD));
1808 int width = render_text->GetStringSize().width();
1809 ASSERT_GT(width, 10);
1810
1811 // Ensure that the cursor is placed at the width of its preceding text.
1812 render_text->SetDisplayRect(Rect(width + 10, 1));
1813 EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
1814
1815 // Ensure that shrinking the display rectangle keeps the cursor in view.
1816 render_text->SetDisplayRect(Rect(width - 10, 1));
1817 EXPECT_EQ(render_text->display_rect().width(),
1818 render_text->GetUpdatedCursorBounds().right());
1819
1820 // Ensure that the text will pan to fill its expanding display rectangle.
1821 render_text->SetDisplayRect(Rect(width - 5, 1));
1822 EXPECT_EQ(render_text->display_rect().width(),
1823 render_text->GetUpdatedCursorBounds().right());
1824
1825 // Ensure that a sufficiently large display rectangle shows all the text.
1826 render_text->SetDisplayRect(Rect(width + 10, 1));
1827 EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
1828
1829 // Repeat the test with RTL text.
1830 render_text->SetText(WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3\x5d4\x5d5\x5d6\x5d7"
1831 L"\x5d8\x5d9\x5da\x5db\x5dc\x5dd\x5de\x5df"));
1832 render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
1833 width = render_text->GetStringSize().width();
1834 ASSERT_GT(width, 10);
1835
1836 // Ensure that the cursor is placed at the width of its preceding text.
1837 render_text->SetDisplayRect(Rect(width + 10, 1));
1838 EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
1839
1840 // Ensure that shrinking the display rectangle keeps the cursor in view.
1841 render_text->SetDisplayRect(Rect(width - 10, 1));
1842 EXPECT_EQ(render_text->display_rect().width(),
1843 render_text->GetUpdatedCursorBounds().right());
1844
1845 // Ensure that the text will pan to fill its expanding display rectangle.
1846 render_text->SetDisplayRect(Rect(width - 5, 1));
1847 EXPECT_EQ(render_text->display_rect().width(),
1848 render_text->GetUpdatedCursorBounds().right());
1849
1850 // Ensure that a sufficiently large display rectangle shows all the text.
1851 render_text->SetDisplayRect(Rect(width + 10, 1));
1852 EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
1853 }
1854
1855 TEST_F(RenderTextTest, DisplayRectShowsCursorRTL) {
1856 // Set the application default text direction to RTL.
1857 const bool was_rtl = base::i18n::IsRTL();
1858 SetRTL(true);
1859
1860 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1861 render_text->SetText(WideToUTF16(L"abcdefghijklmnopqrstuvwxzyabcdefg"));
1862 render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
1863 int width = render_text->GetStringSize().width();
1864 ASSERT_GT(width, 10);
1865
1866 // Ensure that the cursor is placed at the width of its preceding text.
1867 render_text->SetDisplayRect(Rect(width + 10, 1));
1868 EXPECT_EQ(render_text->display_rect().width() - width - 1,
1869 render_text->GetUpdatedCursorBounds().x());
1870
1871 // Ensure that shrinking the display rectangle keeps the cursor in view.
1872 render_text->SetDisplayRect(Rect(width - 10, 1));
1873 EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
1874
1875 // Ensure that the text will pan to fill its expanding display rectangle.
1876 render_text->SetDisplayRect(Rect(width - 5, 1));
1877 EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
1878
1879 // Ensure that a sufficiently large display rectangle shows all the text.
1880 render_text->SetDisplayRect(Rect(width + 10, 1));
1881 EXPECT_EQ(render_text->display_rect().width() - width - 1,
1882 render_text->GetUpdatedCursorBounds().x());
1883
1884 // Repeat the test with RTL text.
1885 render_text->SetText(WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3\x5d4\x5d5\x5d6\x5d7"
1886 L"\x5d8\x5d9\x5da\x5db\x5dc\x5dd\x5de\x5df"));
1887 render_text->MoveCursorTo(SelectionModel(render_text->text().length(),
1888 CURSOR_FORWARD));
1889 width = render_text->GetStringSize().width();
1890 ASSERT_GT(width, 10);
1891
1892 // Ensure that the cursor is placed at the width of its preceding text.
1893 render_text->SetDisplayRect(Rect(width + 10, 1));
1894 EXPECT_EQ(render_text->display_rect().width() - width - 1,
1895 render_text->GetUpdatedCursorBounds().x());
1896
1897 // Ensure that shrinking the display rectangle keeps the cursor in view.
1898 render_text->SetDisplayRect(Rect(width - 10, 1));
1899 EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
1900
1901 // Ensure that the text will pan to fill its expanding display rectangle.
1902 render_text->SetDisplayRect(Rect(width - 5, 1));
1903 EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
1904
1905 // Ensure that a sufficiently large display rectangle shows all the text.
1906 render_text->SetDisplayRect(Rect(width + 10, 1));
1907 EXPECT_EQ(render_text->display_rect().width() - width - 1,
1908 render_text->GetUpdatedCursorBounds().x());
1909
1910 // Reset the application default text direction to LTR.
1911 SetRTL(was_rtl);
1912 EXPECT_EQ(was_rtl, base::i18n::IsRTL());
1913 }
1914 #endif // !defined(OS_MACOSX)
1915
1916 // Changing colors between or inside ligated glyphs should not break shaping.
1917 TEST_F(RenderTextTest, SelectionKeepsLigatures) {
1918 const wchar_t* kTestStrings[] = { L"\x644\x623", L"\x633\x627" };
1919 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1920 render_text->set_selection_color(SK_ColorRED);
1921 Canvas canvas;
1922
1923 for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
1924 render_text->SetText(WideToUTF16(kTestStrings[i]));
1925 const int expected_width = render_text->GetStringSize().width();
1926 render_text->MoveCursorTo(SelectionModel(Range(0, 1), CURSOR_FORWARD));
1927 EXPECT_EQ(expected_width, render_text->GetStringSize().width());
1928 // Drawing the text should not DCHECK or crash; see http://crbug.com/262119
1929 render_text->Draw(&canvas);
1930 render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
1931 }
1932 }
1933
1934 #if defined(OS_WIN)
1935 // TODO(ckocagil): Enable for RenderTextHarfBuzz after implementing multiline.
1936 // Ensure strings wrap onto multiple lines for a small available width.
1937 TEST_F(RenderTextTest, Multiline_MinWidth) {
1938 const wchar_t* kTestStrings[] = { kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl,
1939 kRtlLtr, kRtlLtrRtl };
1940
1941 scoped_ptr<RenderTextWin> render_text(
1942 static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
1943 render_text->SetDisplayRect(Rect(1, 1000));
1944 render_text->SetMultiline(true);
1945 Canvas canvas;
1946
1947 for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
1948 SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
1949 render_text->SetText(WideToUTF16(kTestStrings[i]));
1950 render_text->Draw(&canvas);
1951 EXPECT_GT(render_text->lines_.size(), 1U);
1952 }
1953 }
1954
1955 // TODO(ckocagil): Enable for RenderTextHarfBuzz after implementing multiline.
1956 // Ensure strings wrap onto multiple lines for a normal available width.
1957 TEST_F(RenderTextTest, Multiline_NormalWidth) {
1958 const struct {
1959 const wchar_t* const text;
1960 const Range first_line_char_range;
1961 const Range second_line_char_range;
1962 } kTestStrings[] = {
1963 { L"abc defg hijkl", Range(0, 9), Range(9, 14) },
1964 { L"qwertyzxcvbn", Range(0, 8), Range(8, 12) },
1965 { L"\x062A\x0641\x0627\x062D\x05EA\x05E4\x05D5\x05D6\x05D9\x05DD",
1966 Range(4, 10), Range(0, 4) }
1967 };
1968
1969 scoped_ptr<RenderTextWin> render_text(
1970 static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
1971 render_text->SetDisplayRect(Rect(50, 1000));
1972 render_text->SetMultiline(true);
1973 Canvas canvas;
1974
1975 for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
1976 SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
1977 render_text->SetText(WideToUTF16(kTestStrings[i].text));
1978 render_text->Draw(&canvas);
1979 ASSERT_EQ(2U, render_text->lines_.size());
1980 ASSERT_EQ(1U, render_text->lines_[0].segments.size());
1981 EXPECT_EQ(kTestStrings[i].first_line_char_range,
1982 render_text->lines_[0].segments[0].char_range);
1983 ASSERT_EQ(1U, render_text->lines_[1].segments.size());
1984 EXPECT_EQ(kTestStrings[i].second_line_char_range,
1985 render_text->lines_[1].segments[0].char_range);
1986 }
1987 }
1988
1989 // TODO(ckocagil): Enable for RenderTextHarfBuzz after implementing multiline.
1990 // Ensure strings don't wrap onto multiple lines for a sufficient available
1991 // width.
1992 TEST_F(RenderTextTest, Multiline_SufficientWidth) {
1993 const wchar_t* kTestStrings[] = { L"", L" ", L".", L" . ", L"abc", L"a b c",
1994 L"\x62E\x628\x632", L"\x62E \x628 \x632" };
1995
1996 scoped_ptr<RenderTextWin> render_text(
1997 static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
1998 render_text->SetDisplayRect(Rect(30, 1000));
1999 render_text->SetMultiline(true);
2000 Canvas canvas;
2001
2002 for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
2003 SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
2004 render_text->SetText(WideToUTF16(kTestStrings[i]));
2005 render_text->Draw(&canvas);
2006 EXPECT_EQ(1U, render_text->lines_.size());
2007 }
2008 }
2009
2010 // TODO(ckocagil): Enable for RenderTextHarfBuzz after implementing multiline.
2011 TEST_F(RenderTextTest, Multiline_Newline) {
2012 const struct {
2013 const wchar_t* const text;
2014 // Ranges of the characters on each line preceding the newline.
2015 const Range first_line_char_range;
2016 const Range second_line_char_range;
2017 } kTestStrings[] = {
2018 { L"abc\ndef", Range(0, 3), Range(4, 7) },
2019 { L"a \n b ", Range(0, 2), Range(3, 6) },
2020 { L"\n" , Range::InvalidRange(), Range::InvalidRange() }
2021 };
2022
2023 scoped_ptr<RenderTextWin> render_text(
2024 static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
2025 render_text->SetDisplayRect(Rect(200, 1000));
2026 render_text->SetMultiline(true);
2027 Canvas canvas;
2028
2029 for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
2030 SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
2031 render_text->SetText(WideToUTF16(kTestStrings[i].text));
2032 render_text->Draw(&canvas);
2033
2034 ASSERT_EQ(2U, render_text->lines_.size());
2035
2036 const Range first_expected_range = kTestStrings[i].first_line_char_range;
2037 ASSERT_EQ(first_expected_range.IsValid() ? 2U : 1U,
2038 render_text->lines_[0].segments.size());
2039 if (first_expected_range.IsValid())
2040 EXPECT_EQ(first_expected_range,
2041 render_text->lines_[0].segments[0].char_range);
2042
2043 const internal::LineSegment& newline_segment =
2044 render_text->lines_[0].segments[first_expected_range.IsValid() ? 1 : 0];
2045 ASSERT_EQ(1U, newline_segment.char_range.length());
2046 EXPECT_EQ(L'\n', kTestStrings[i].text[newline_segment.char_range.start()]);
2047
2048 const Range second_expected_range = kTestStrings[i].second_line_char_range;
2049 ASSERT_EQ(second_expected_range.IsValid() ? 1U : 0U,
2050 render_text->lines_[1].segments.size());
2051 if (second_expected_range.IsValid())
2052 EXPECT_EQ(second_expected_range,
2053 render_text->lines_[1].segments[0].char_range);
2054 }
2055 }
2056
2057 // TODO(ckocagil): Remove when RenderTextWin goes away.
2058 TEST_F(RenderTextTest, BreakRunsByUnicodeBlocks) {
2059 scoped_ptr<RenderTextWin> render_text(
2060 static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
2061
2062 // The '\x25B6' "play character" should break runs. http://crbug.com/278913
2063 render_text->SetText(WideToUTF16(L"x\x25B6y"));
2064 render_text->EnsureLayout();
2065 ASSERT_EQ(3U, render_text->runs_.size());
2066 EXPECT_EQ(Range(0, 1), render_text->runs_[0]->range);
2067 EXPECT_EQ(Range(1, 2), render_text->runs_[1]->range);
2068 EXPECT_EQ(Range(2, 3), render_text->runs_[2]->range);
2069
2070 render_text->SetText(WideToUTF16(L"x \x25B6 y"));
2071 render_text->EnsureLayout();
2072 ASSERT_EQ(3U, render_text->runs_.size());
2073 EXPECT_EQ(Range(0, 2), render_text->runs_[0]->range);
2074 EXPECT_EQ(Range(2, 3), render_text->runs_[1]->range);
2075 EXPECT_EQ(Range(3, 5), render_text->runs_[2]->range);
2076 }
2077 #endif // defined(OS_WIN)
2078
2079 // Test TextRunHarfBuzz's cluster finding logic.
2080 TEST_F(RenderTextTest, HarfBuzz_Clusters) {
2081 struct {
2082 uint32 glyph_to_char[4];
2083 Range chars[4];
2084 Range glyphs[4];
2085 bool is_rtl;
2086 } cases[] = {
2087 { // From string "A B C D" to glyphs "a b c d".
2088 { 0, 1, 2, 3 },
2089 { Range(0, 1), Range(1, 2), Range(2, 3), Range(3, 4) },
2090 { Range(0, 1), Range(1, 2), Range(2, 3), Range(3, 4) },
2091 false
2092 },
2093 { // From string "A B C D" to glyphs "d c b a".
2094 { 3, 2, 1, 0 },
2095 { Range(0, 1), Range(1, 2), Range(2, 3), Range(3, 4) },
2096 { Range(3, 4), Range(2, 3), Range(1, 2), Range(0, 1) },
2097 true
2098 },
2099 { // From string "A B C D" to glyphs "ab c c d".
2100 { 0, 2, 2, 3 },
2101 { Range(0, 2), Range(0, 2), Range(2, 3), Range(3, 4) },
2102 { Range(0, 1), Range(0, 1), Range(1, 3), Range(3, 4) },
2103 false
2104 },
2105 { // From string "A B C D" to glyphs "d c c ba".
2106 { 3, 2, 2, 0 },
2107 { Range(0, 2), Range(0, 2), Range(2, 3), Range(3, 4) },
2108 { Range(3, 4), Range(3, 4), Range(1, 3), Range(0, 1) },
2109 true
2110 },
2111 };
2112
2113 internal::TextRunHarfBuzz run;
2114 run.range = Range(0, 4);
2115 run.glyph_count = 4;
2116 run.glyph_to_char.resize(4);
2117
2118 for (size_t i = 0; i < arraysize(cases); ++i) {
2119 std::copy(cases[i].glyph_to_char, cases[i].glyph_to_char + 4,
2120 run.glyph_to_char.begin());
2121 run.is_rtl = cases[i].is_rtl;
2122
2123 for (size_t j = 0; j < 4; ++j) {
2124 SCOPED_TRACE(base::StringPrintf("Case %" PRIuS ", char %" PRIuS, i, j));
2125 Range chars;
2126 Range glyphs;
2127 run.GetClusterAt(j, &chars, &glyphs);
2128 EXPECT_EQ(cases[i].chars[j], chars);
2129 EXPECT_EQ(cases[i].glyphs[j], glyphs);
2130 EXPECT_EQ(cases[i].glyphs[j], run.CharRangeToGlyphRange(chars));
2131 }
2132 }
2133 }
2134
2135 // Ensure that graphemes with multiple code points do not get split.
2136 TEST_F(RenderTextTest, HarfBuzz_SubglyphGraphemeCases) {
2137 const wchar_t* cases[] = {
2138 // "A" with a combining umlaut, followed by a "B".
2139 L"A\x0308" L"B",
2140 // Devanagari biconsonantal conjunct "ki", followed by an "a".
2141 L"\x0915\x093f\x0905",
2142 // Thai consonant and vowel pair "cho chan" + "sara am", followed by Thai
2143 // digit 0.
2144 L"\x0e08\x0e33\x0E50",
2145 };
2146
2147 RenderTextHarfBuzz render_text;
2148
2149 for (size_t i = 0; i < arraysize(cases); ++i) {
2150 SCOPED_TRACE(base::StringPrintf("Case %" PRIuS, i));
2151
2152 base::string16 text = WideToUTF16(cases[i]);
2153 render_text.SetText(text);
2154 render_text.EnsureLayout();
2155 ASSERT_EQ(1U, render_text.runs_.size());
2156 internal::TextRunHarfBuzz* run = render_text.runs_[0];
2157
2158 base::i18n::BreakIterator* iter = render_text.grapheme_iterator_.get();
2159 Range first_grapheme_bounds = run->GetGraphemeBounds(iter, 0);
2160 EXPECT_EQ(first_grapheme_bounds, run->GetGraphemeBounds(iter, 1));
2161 Range second_grapheme_bounds = run->GetGraphemeBounds(iter, 2);
2162 EXPECT_EQ(first_grapheme_bounds.end(), second_grapheme_bounds.start());
2163 }
2164 }
2165
2166 // Test the partition of a multi-grapheme cluster into grapheme ranges.
2167 TEST_F(RenderTextTest, HarfBuzz_SubglyphGraphemePartition) {
2168 struct {
2169 uint32 glyph_to_char[2];
2170 Range bounds[4];
2171 bool is_rtl;
2172 } cases[] = {
2173 { // From string "A B C D" to glyphs "a bcd".
2174 { 0, 1 },
2175 { Range(0, 10), Range(10, 13), Range(13, 17), Range(17, 20) },
2176 false
2177 },
2178 { // From string "A B C D" to glyphs "ab cd".
2179 { 0, 2 },
2180 { Range(0, 5), Range(5, 10), Range(10, 15), Range(15, 20) },
2181 false
2182 },
2183 { // From string "A B C D" to glyphs "dcb a".
2184 { 1, 0 },
2185 { Range(10, 20), Range(7, 10), Range(3, 7), Range(0, 3) },
2186 true
2187 },
2188 { // From string "A B C D" to glyphs "dc ba".
2189 { 2, 0 },
2190 { Range(15, 20), Range(10, 15), Range(5, 10), Range(0, 5) },
2191 true
2192 },
2193 };
2194
2195 internal::TextRunHarfBuzz run;
2196 run.range = Range(0, 4);
2197 run.glyph_count = 2;
2198 run.glyph_to_char.resize(2);
2199 run.positions.reset(new SkPoint[4]);
2200 run.width = 20;
2201
2202 const base::string16 kString = ASCIIToUTF16("abcd");
2203 scoped_ptr<base::i18n::BreakIterator> iter(new base::i18n::BreakIterator(
2204 kString, base::i18n::BreakIterator::BREAK_CHARACTER));
2205 ASSERT_TRUE(iter->Init());
2206
2207 for (size_t i = 0; i < arraysize(cases); ++i) {
2208 std::copy(cases[i].glyph_to_char, cases[i].glyph_to_char + 2,
2209 run.glyph_to_char.begin());
2210 run.is_rtl = cases[i].is_rtl;
2211 for (int j = 0; j < 2; ++j)
2212 run.positions[j].set(j * 10, 0);
2213
2214 for (size_t j = 0; j < 4; ++j) {
2215 SCOPED_TRACE(base::StringPrintf("Case %" PRIuS ", char %" PRIuS, i, j));
2216 EXPECT_EQ(cases[i].bounds[j], run.GetGraphemeBounds(iter.get(), j));
2217 }
2218 }
2219 }
2220
2221 TEST_F(RenderTextTest, HarfBuzz_RunDirection) {
2222 RenderTextHarfBuzz render_text;
2223 const base::string16 mixed =
2224 WideToUTF16(L"\x05D0\x05D1" L"1234" L"\x05D2\x05D3");
2225 render_text.SetText(mixed);
2226 render_text.EnsureLayout();
2227 ASSERT_EQ(3U, render_text.runs_.size());
2228 EXPECT_TRUE(render_text.runs_[0]->is_rtl);
2229 EXPECT_FALSE(render_text.runs_[1]->is_rtl);
2230 EXPECT_TRUE(render_text.runs_[2]->is_rtl);
2231 }
2232
2233 TEST_F(RenderTextTest, HarfBuzz_BreakRunsByUnicodeBlocks) {
2234 RenderTextHarfBuzz render_text;
2235
2236 // The '\x25B6' "play character" should break runs. http://crbug.com/278913
2237 render_text.SetText(WideToUTF16(L"x\x25B6y"));
2238 render_text.EnsureLayout();
2239 ASSERT_EQ(3U, render_text.runs_.size());
2240 EXPECT_EQ(Range(0, 1), render_text.runs_[0]->range);
2241 EXPECT_EQ(Range(1, 2), render_text.runs_[1]->range);
2242 EXPECT_EQ(Range(2, 3), render_text.runs_[2]->range);
2243
2244 render_text.SetText(WideToUTF16(L"x \x25B6 y"));
2245 render_text.EnsureLayout();
2246 ASSERT_EQ(3U, render_text.runs_.size());
2247 EXPECT_EQ(Range(0, 2), render_text.runs_[0]->range);
2248 EXPECT_EQ(Range(2, 3), render_text.runs_[1]->range);
2249 EXPECT_EQ(Range(3, 5), render_text.runs_[2]->range);
2250 }
2251
2252 // Disabled on Mac because RenderTextMac doesn't implement GetGlyphBounds.
2253 #if !defined(OS_MACOSX)
2254 TEST_F(RenderTextTest, GlyphBounds) {
2255 const wchar_t* kTestStrings[] = {
2256 L"asdf 1234 qwer", L"\x0647\x0654", L"\x0645\x0631\x062D\x0628\x0627"
2257 };
2258 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
2259
2260 for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
2261 render_text->SetText(WideToUTF16(kTestStrings[i]));
2262 render_text->EnsureLayout();
2263
2264 for (size_t j = 0; j < render_text->text().length(); ++j)
2265 EXPECT_FALSE(render_text->GetGlyphBounds(j).is_empty());
2266 }
2267 }
2268 #endif
2269
2270 // Remove this after making RTHB default in favor of RenderTextTest.GlyphBounds.
2271 TEST_F(RenderTextTest, HarfBuzz_GlyphBounds) {
2272 const wchar_t* kTestStrings[] = {
2273 L"asdf 1234 qwer", L"\x0647\x0654", L"\x0645\x0631\x062D\x0628\x0627"
2274 };
2275 scoped_ptr<RenderText> render_text(new RenderTextHarfBuzz);
2276
2277 for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
2278 render_text->SetText(WideToUTF16(kTestStrings[i]));
2279 render_text->EnsureLayout();
2280
2281 for (size_t j = 0; j < render_text->text().length(); ++j)
2282 EXPECT_FALSE(render_text->GetGlyphBounds(j).is_empty());
2283 }
2284 }
2285
2286 // Ensure that shaping with a non-existent font does not cause a crash.
2287 TEST_F(RenderTextTest, HarfBuzz_NonExistentFont) {
2288 RenderTextHarfBuzz render_text;
2289 render_text.SetText(ASCIIToUTF16("test"));
2290 render_text.EnsureLayout();
2291 ASSERT_EQ(1U, render_text.runs_.size());
2292 internal::TextRunHarfBuzz* run = render_text.runs_[0];
2293 render_text.ShapeRunWithFont(
2294 run, "TheFontThatDoesntExist", FontRenderParams());
2295 }
2296
2297 // Ensure an empty run returns sane values to queries.
2298 TEST_F(RenderTextTest, HarfBuzz_EmptyRun) {
2299 internal::TextRunHarfBuzz run;
2300 const base::string16 kString = ASCIIToUTF16("abcdefgh");
2301 scoped_ptr<base::i18n::BreakIterator> iter(new base::i18n::BreakIterator(
2302 kString, base::i18n::BreakIterator::BREAK_CHARACTER));
2303 ASSERT_TRUE(iter->Init());
2304
2305 run.range = Range(3, 8);
2306 run.glyph_count = 0;
2307 EXPECT_EQ(Range(0, 0), run.CharRangeToGlyphRange(Range(4, 5)));
2308 EXPECT_EQ(Range(0, 0), run.GetGraphemeBounds(iter.get(), 4));
2309 Range chars;
2310 Range glyphs;
2311 run.GetClusterAt(4, &chars, &glyphs);
2312 EXPECT_EQ(Range(3, 8), chars);
2313 EXPECT_EQ(Range(0, 0), glyphs);
2314 }
2315
2316 // Ensure a string fits in a display rect with a width equal to the string's.
2317 TEST_F(RenderTextTest, StringFitsOwnWidth) {
2318 scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
2319 const base::string16 kString = ASCIIToUTF16("www.example.com");
2320
2321 render_text->SetText(kString);
2322 render_text->ApplyStyle(BOLD, true, Range(0, 3));
2323 render_text->SetElideBehavior(ELIDE_TAIL);
2324
2325 render_text->SetDisplayRect(Rect(0, 0, 500, 100));
2326 EXPECT_EQ(kString, render_text->GetLayoutText());
2327 render_text->SetDisplayRect(Rect(0, 0, render_text->GetContentWidth(), 100));
2328 EXPECT_EQ(kString, render_text->GetLayoutText());
2329 }
2330
2331 // TODO(derat): Figure out why this fails on Windows: http://crbug.com/427184
2332 #if !defined(OS_WIN)
2333 // Ensure that RenderText examines all of the fonts in its FontList before
2334 // falling back to other fonts.
2335 TEST_F(RenderTextTest, HarfBuzz_FontListFallback) {
2336 // Double-check that the requested fonts are present.
2337 FontList font_list("Arial, Symbol, 12px");
2338 const std::vector<Font>& fonts = font_list.GetFonts();
2339 ASSERT_EQ(2u, fonts.size());
2340 ASSERT_EQ("arial",
2341 base::StringToLowerASCII(fonts[0].GetActualFontNameForTesting()));
2342 ASSERT_EQ("symbol",
2343 base::StringToLowerASCII(fonts[1].GetActualFontNameForTesting()));
2344
2345 // "⊕" (CIRCLED PLUS) should be rendered with Symbol rather than falling back
2346 // to some other font that's present on the system.
2347 RenderTextHarfBuzz render_text;
2348 render_text.SetFontList(font_list);
2349 render_text.SetText(UTF8ToUTF16("\xE2\x8A\x95"));
2350 const std::vector<RenderText::FontSpan> spans =
2351 render_text.GetFontSpansForTesting();
2352 ASSERT_EQ(static_cast<size_t>(1), spans.size());
2353 EXPECT_EQ("Symbol", spans[0].first.GetFontName());
2354 }
2355 #endif // !defined(OS_WIN)
2356
2357 // Ensure that the fallback fonts of the Uniscribe font are tried for shaping.
2358 #if defined(OS_WIN)
2359 TEST_F(RenderTextTest, HarfBuzz_UniscribeFallback) {
2360 RenderTextHarfBuzz render_text;
2361 PlatformFontWin* font_win = new PlatformFontWin("Meiryo", 12);
2362 // Japanese name for Meiryo. This name won't be found in the system's linked
2363 // fonts, forcing RTHB to try the Uniscribe font and its fallbacks.
2364 font_win->font_ref_->font_name_ = WideToUTF8(L"\x30e1\x30a4\x30ea\x30aa");
2365 FontList font_list((Font(font_win)));
2366
2367 render_text.SetFontList(font_list);
2368 // Korean character "han".
2369 render_text.SetText(WideToUTF16(L"\xd55c"));
2370 render_text.EnsureLayout();
2371 ASSERT_EQ(1U, render_text.runs_.size());
2372 EXPECT_EQ(0U, render_text.runs_[0]->CountMissingGlyphs());
2373 }
2374 #endif // defined(OS_WIN)
2375
2376 } // namespace gfx