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