Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(852)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: ui/gfx/render_text_unittest.cc

Issue 2251893004: Use parameterized tests to test multiple render text implementations. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@selection_direction
Patch Set: Refer crbug. Created 4 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « ui/gfx/render_text_mac.h ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: ui/gfx/render_text_unittest.cc
diff --git a/ui/gfx/render_text_unittest.cc b/ui/gfx/render_text_unittest.cc
index d6534fbbbe3b7bea70e9b059433a494460ce5549..7e21e99f844ea668f6484c8a1231677c17ab26c2 100644
--- a/ui/gfx/render_text_unittest.cc
+++ b/ui/gfx/render_text_unittest.cc
@@ -62,8 +62,11 @@ class RenderTextTestApi {
return renderer->paint_;
}
- static internal::TextRunList* GetHarfbuzzRunList(
- RenderTextHarfBuzz* harfbuzz) {
+ // Callers should ensure that the associated RenderText object is a
+ // RenderTextHarfBuzz instance.
+ internal::TextRunList* GetHarfBuzzRunList() {
+ RenderTextHarfBuzz* harfbuzz =
+ static_cast<RenderTextHarfBuzz*>(render_text_);
return harfbuzz->GetRunList();
}
@@ -74,7 +77,6 @@ class RenderTextTestApi {
private:
RenderText* render_text_;
-
DISALLOW_COPY_AND_ASSIGN(RenderTextTestApi);
};
@@ -82,6 +84,12 @@ class RenderTextTestApi {
namespace {
+// An enum specifying the different RenderText implementations to be tested.
+enum RenderTextBackend {
+ RENDER_TEXT_HARFBUZZ,
+ RENDER_TEXT_MAC,
+};
+
// Various weak, LTR, RTL, and Bidi string cases with three characters each.
const wchar_t kWeak[] = L" . ";
const wchar_t kLtr[] = L"abc";
@@ -128,8 +136,6 @@ void RunMoveCursorTestAndClearExpectations(RenderText* render_text,
expected->clear();
}
-// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
-#if !defined(OS_MACOSX)
// Ensure cursor movement in the specified |direction| yields |expected| values.
void RunMoveCursorLeftRightTest(RenderText* render_text,
const std::vector<SelectionModel>& expected,
@@ -146,7 +152,6 @@ void RunMoveCursorLeftRightTest(RenderText* render_text,
render_text->MoveCursor(LINE_BREAK, direction, SELECTION_NONE);
EXPECT_EQ(expected.back(), render_text->selection_model());
}
-#endif // !defined(OS_MACOSX)
// The class which records the drawing operations so that the test case can
// verify where exactly the glyphs are drawn.
@@ -263,127 +268,138 @@ class TestRectangleBuffer {
DISALLOW_COPY_AND_ASSIGN(TestRectangleBuffer);
};
-// Helper to run the same test expectations on all RenderText backends.
-class RenderTextAllBackends {
- public:
- RenderTextAllBackends() : renderer_(&canvas_), current_(nullptr) {}
+} // namespace
- bool Advance() {
- if (!current_) {
- current_ = &render_text_harfbuzz_;
- return true;
- }
+// Test fixture class used to run parameterized tests on all RenderText
+// implementations.
+class RenderTextTestAll
+ : public testing::Test,
+ public ::testing::WithParamInterface<RenderTextBackend> {
+ public:
+ RenderTextTestAll()
+ : render_text_(CreateRenderTextInstance()),
+ test_api_(render_text_.get()),
+ renderer_(&canvas_){};
+
+ protected:
+ std::unique_ptr<RenderText> CreateRenderTextInstance() const {
+ std::unique_ptr<RenderText> render_text;
+ switch (GetParam()) {
+ case RENDER_TEXT_HARFBUZZ:
+ render_text.reset(new RenderTextHarfBuzz());
+ break;
+
+ case RENDER_TEXT_MAC:
#if defined(OS_MACOSX)
- if (current_ == &render_text_harfbuzz_) {
- current_ = &render_text_mac_;
- return true;
- }
+ render_text.reset(new RenderTextMac());
+#else
+ NOTREACHED();
#endif
-
- return false;
- }
-
- const char* GetName() const {
- return current_ == &render_text_harfbuzz_ ? "Harfbuzz" : "Mac";
- }
-
- RenderText* operator->() {
- return current_;
- }
-
- void DrawVisualText() {
- test::RenderTextTestApi test_api(current_);
- test_api.DrawVisualText(&renderer_);
- }
-
- void GetTextLogAndReset(std::vector<TestSkiaTextRenderer::TextLog>* log) {
- renderer_.GetTextLogAndReset(log);
+ break;
+ }
+ return render_text;
}
- SkPaint& paint() {
+ SkPaint& GetRendererPaint() {
return test::RenderTextTestApi::GetRendererPaint(&renderer_);
}
+ void DrawVisualText() { test_api_.DrawVisualText(&renderer_); }
+
internal::TextRunList* GetHarfbuzzRunList() {
- return test::RenderTextTestApi::GetHarfbuzzRunList(&render_text_harfbuzz_);
+ DCHECK_EQ(RENDER_TEXT_HARFBUZZ, GetParam());
+ return test_api_.GetHarfBuzzRunList();
}
- private:
+ std::unique_ptr<RenderText> render_text_;
+ test::RenderTextTestApi test_api_;
Canvas canvas_;
TestSkiaTextRenderer renderer_;
- RenderText* current_;
- RenderTextHarfBuzz render_text_harfbuzz_;
-#if defined(OS_MACOSX)
- RenderTextMac render_text_mac_;
+ private:
+#if defined(OS_WIN)
+ // Needed to bypass DCHECK in GetFallbackFont.
+ base::MessageLoopForUI message_loop_;
#endif
- DISALLOW_COPY_AND_ASSIGN(RenderTextAllBackends);
+ DISALLOW_COPY_AND_ASSIGN(RenderTextTestAll);
};
-} // namespace
+// Test fixture class. Use for tests which are only to be run for RenderTextMac.
+class RenderTextMacTest : public RenderTextTestAll {
+ public:
+ RenderTextMacTest() {}
+
+ // Overridden from testing::Test:
+ void SetUp() override { DCHECK_EQ(RENDER_TEXT_MAC, GetParam()); }
-class RenderTextTest : public testing::Test {
private:
-#if defined(OS_WIN)
- // Needed to bypass DCHECK in GetFallbackFont.
- base::MessageLoopForUI message_loop_;
-#endif
+ DISALLOW_COPY_AND_ASSIGN(RenderTextMacTest);
};
-TEST_F(RenderTextTest, DefaultStyles) {
+// Test fixture class. Use for tests which are only to be run on
+// RenderTextHarfBuzz.
+class RenderTextHarfBuzzTest : public RenderTextTestAll {
+ public:
+ RenderTextHarfBuzzTest() {}
+
+ // Overridden from testing::Test:
+ void SetUp() override { DCHECK_EQ(RENDER_TEXT_HARFBUZZ, GetParam()); }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(RenderTextHarfBuzzTest);
+};
+
+TEST_P(RenderTextTestAll, DefaultStyles) {
// Check the default styles applied to new instances and adjusted text.
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- EXPECT_TRUE(render_text->text().empty());
+ EXPECT_TRUE(render_text_->text().empty());
const wchar_t* const cases[] = { kWeak, kLtr, L"Hello", kRtl, L"", L"" };
for (size_t i = 0; i < arraysize(cases); ++i) {
- EXPECT_TRUE(render_text->colors().EqualsValueForTesting(SK_ColorBLACK));
+ EXPECT_TRUE(render_text_->colors().EqualsValueForTesting(SK_ColorBLACK));
EXPECT_TRUE(
- render_text->baselines().EqualsValueForTesting(NORMAL_BASELINE));
+ render_text_->baselines().EqualsValueForTesting(NORMAL_BASELINE));
for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
- EXPECT_TRUE(render_text->styles()[style].EqualsValueForTesting(false));
- render_text->SetText(WideToUTF16(cases[i]));
+ EXPECT_TRUE(render_text_->styles()[style].EqualsValueForTesting(false));
+ render_text_->SetText(WideToUTF16(cases[i]));
}
}
-TEST_F(RenderTextTest, SetStyles) {
+TEST_P(RenderTextTestAll, SetStyles) {
// Ensure custom default styles persist across setting and clearing text.
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
const SkColor color = SK_ColorRED;
- render_text->SetColor(color);
- render_text->SetBaselineStyle(SUPERSCRIPT);
- render_text->SetWeight(Font::Weight::BOLD);
- render_text->SetStyle(UNDERLINE, false);
+ render_text_->SetColor(color);
+ render_text_->SetBaselineStyle(SUPERSCRIPT);
+ render_text_->SetWeight(Font::Weight::BOLD);
+ render_text_->SetStyle(UNDERLINE, false);
const wchar_t* const cases[] = { kWeak, kLtr, L"Hello", kRtl, L"", L"" };
for (size_t i = 0; i < arraysize(cases); ++i) {
- EXPECT_TRUE(render_text->colors().EqualsValueForTesting(color));
- EXPECT_TRUE(render_text->baselines().EqualsValueForTesting(SUPERSCRIPT));
+ EXPECT_TRUE(render_text_->colors().EqualsValueForTesting(color));
+ EXPECT_TRUE(render_text_->baselines().EqualsValueForTesting(SUPERSCRIPT));
EXPECT_TRUE(
- render_text->weights().EqualsValueForTesting(Font::Weight::BOLD));
- EXPECT_TRUE(render_text->styles()[UNDERLINE].EqualsValueForTesting(false));
- render_text->SetText(WideToUTF16(cases[i]));
+ render_text_->weights().EqualsValueForTesting(Font::Weight::BOLD));
+ EXPECT_TRUE(render_text_->styles()[UNDERLINE].EqualsValueForTesting(false));
+ render_text_->SetText(WideToUTF16(cases[i]));
// Ensure custom default styles can be applied after text has been set.
if (i == 1)
- render_text->SetStyle(STRIKE, true);
+ render_text_->SetStyle(STRIKE, true);
if (i >= 1)
- EXPECT_TRUE(render_text->styles()[STRIKE].EqualsValueForTesting(true));
+ EXPECT_TRUE(render_text_->styles()[STRIKE].EqualsValueForTesting(true));
}
}
-TEST_F(RenderTextTest, ApplyStyles) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(ASCIIToUTF16("012345678"));
+TEST_P(RenderTextTestAll, ApplyStyles) {
+ render_text_->SetText(ASCIIToUTF16("012345678"));
// Apply a ranged color and style and check the resulting breaks.
- render_text->ApplyColor(SK_ColorRED, Range(1, 4));
- render_text->ApplyBaselineStyle(SUPERIOR, Range(2, 4));
- render_text->ApplyWeight(Font::Weight::BOLD, Range(2, 5));
+ render_text_->ApplyColor(SK_ColorRED, Range(1, 4));
+ render_text_->ApplyBaselineStyle(SUPERIOR, Range(2, 4));
+ render_text_->ApplyWeight(Font::Weight::BOLD, Range(2, 5));
std::vector<std::pair<size_t, SkColor> > expected_color;
expected_color.push_back(std::pair<size_t, SkColor>(0, SK_ColorBLACK));
expected_color.push_back(std::pair<size_t, SkColor>(1, SK_ColorRED));
expected_color.push_back(std::pair<size_t, SkColor>(4, SK_ColorBLACK));
- EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color));
+ EXPECT_TRUE(render_text_->colors().EqualsForTesting(expected_color));
std::vector<std::pair<size_t, BaselineStyle>> expected_baseline_style;
expected_baseline_style.push_back(
std::pair<size_t, BaselineStyle>(0, NORMAL_BASELINE));
@@ -392,7 +408,7 @@ TEST_F(RenderTextTest, ApplyStyles) {
expected_baseline_style.push_back(
std::pair<size_t, BaselineStyle>(4, NORMAL_BASELINE));
EXPECT_TRUE(
- render_text->baselines().EqualsForTesting(expected_baseline_style));
+ render_text_->baselines().EqualsForTesting(expected_baseline_style));
std::vector<std::pair<size_t, Font::Weight>> expected_weight;
expected_weight.push_back(
std::pair<size_t, Font::Weight>(0, Font::Weight::NORMAL));
@@ -400,111 +416,115 @@ TEST_F(RenderTextTest, ApplyStyles) {
std::pair<size_t, Font::Weight>(2, Font::Weight::BOLD));
expected_weight.push_back(
std::pair<size_t, Font::Weight>(5, Font::Weight::NORMAL));
- EXPECT_TRUE(render_text->weights().EqualsForTesting(expected_weight));
+ EXPECT_TRUE(render_text_->weights().EqualsForTesting(expected_weight));
// Ensure that setting a value overrides the ranged values.
- render_text->SetColor(SK_ColorBLUE);
- EXPECT_TRUE(render_text->colors().EqualsValueForTesting(SK_ColorBLUE));
- render_text->SetBaselineStyle(SUBSCRIPT);
- EXPECT_TRUE(render_text->baselines().EqualsValueForTesting(SUBSCRIPT));
- render_text->SetWeight(Font::Weight::NORMAL);
+ render_text_->SetColor(SK_ColorBLUE);
+ EXPECT_TRUE(render_text_->colors().EqualsValueForTesting(SK_ColorBLUE));
+ render_text_->SetBaselineStyle(SUBSCRIPT);
+ EXPECT_TRUE(render_text_->baselines().EqualsValueForTesting(SUBSCRIPT));
+ render_text_->SetWeight(Font::Weight::NORMAL);
EXPECT_TRUE(
- render_text->weights().EqualsValueForTesting(Font::Weight::NORMAL));
+ render_text_->weights().EqualsValueForTesting(Font::Weight::NORMAL));
// Apply a value over the text end and check the resulting breaks (INT_MAX
// should be used instead of the text length for the range end)
- const size_t text_length = render_text->text().length();
- render_text->ApplyColor(SK_ColorRED, Range(0, text_length));
- render_text->ApplyBaselineStyle(SUPERIOR, Range(0, text_length));
- render_text->ApplyWeight(Font::Weight::BOLD, Range(2, text_length));
+ const size_t text_length = render_text_->text().length();
+ render_text_->ApplyColor(SK_ColorRED, Range(0, text_length));
+ render_text_->ApplyBaselineStyle(SUPERIOR, Range(0, text_length));
+ render_text_->ApplyWeight(Font::Weight::BOLD, Range(2, text_length));
std::vector<std::pair<size_t, SkColor> > expected_color_end;
expected_color_end.push_back(std::pair<size_t, SkColor>(0, SK_ColorRED));
- EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color_end));
+ EXPECT_TRUE(render_text_->colors().EqualsForTesting(expected_color_end));
std::vector<std::pair<size_t, BaselineStyle>> expected_baseline_end;
expected_baseline_end.push_back(
std::pair<size_t, BaselineStyle>(0, SUPERIOR));
- EXPECT_TRUE(render_text->baselines().EqualsForTesting(expected_baseline_end));
+ EXPECT_TRUE(
+ render_text_->baselines().EqualsForTesting(expected_baseline_end));
std::vector<std::pair<size_t, Font::Weight>> expected_weight_end;
expected_weight_end.push_back(
std::pair<size_t, Font::Weight>(0, Font::Weight::NORMAL));
expected_weight_end.push_back(
std::pair<size_t, Font::Weight>(2, Font::Weight::BOLD));
- EXPECT_TRUE(render_text->weights().EqualsForTesting(expected_weight_end));
+ EXPECT_TRUE(render_text_->weights().EqualsForTesting(expected_weight_end));
// Ensure ranged values adjust to accommodate text length changes.
- render_text->ApplyStyle(ITALIC, true, Range(0, 2));
- render_text->ApplyStyle(ITALIC, true, Range(3, 6));
- render_text->ApplyStyle(ITALIC, true, Range(7, text_length));
+ render_text_->ApplyStyle(ITALIC, true, Range(0, 2));
+ render_text_->ApplyStyle(ITALIC, true, Range(3, 6));
+ render_text_->ApplyStyle(ITALIC, true, Range(7, text_length));
std::vector<std::pair<size_t, bool> > expected_italic;
expected_italic.push_back(std::pair<size_t, bool>(0, true));
expected_italic.push_back(std::pair<size_t, bool>(2, false));
expected_italic.push_back(std::pair<size_t, bool>(3, true));
expected_italic.push_back(std::pair<size_t, bool>(6, false));
expected_italic.push_back(std::pair<size_t, bool>(7, true));
- EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
+ EXPECT_TRUE(render_text_->styles()[ITALIC].EqualsForTesting(expected_italic));
// Changing the text should clear any breaks except for the first one.
- render_text->SetText(ASCIIToUTF16("0123456"));
+ render_text_->SetText(ASCIIToUTF16("0123456"));
expected_italic.resize(1);
- EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
- render_text->ApplyStyle(ITALIC, false, Range(2, 4));
- render_text->SetText(ASCIIToUTF16("012345678"));
- EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
- render_text->ApplyStyle(ITALIC, false, Range(0, 1));
- render_text->SetText(ASCIIToUTF16("0123456"));
+ EXPECT_TRUE(render_text_->styles()[ITALIC].EqualsForTesting(expected_italic));
+ render_text_->ApplyStyle(ITALIC, false, Range(2, 4));
+ render_text_->SetText(ASCIIToUTF16("012345678"));
+ EXPECT_TRUE(render_text_->styles()[ITALIC].EqualsForTesting(expected_italic));
+ render_text_->ApplyStyle(ITALIC, false, Range(0, 1));
+ render_text_->SetText(ASCIIToUTF16("0123456"));
expected_italic.begin()->second = false;
- EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
- render_text->ApplyStyle(ITALIC, true, Range(2, 4));
- render_text->SetText(ASCIIToUTF16("012345678"));
- EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
+ EXPECT_TRUE(render_text_->styles()[ITALIC].EqualsForTesting(expected_italic));
+ render_text_->ApplyStyle(ITALIC, true, Range(2, 4));
+ render_text_->SetText(ASCIIToUTF16("012345678"));
+ EXPECT_TRUE(render_text_->styles()[ITALIC].EqualsForTesting(expected_italic));
// TODO(tmoniuszko): Enable when RenderTextMac::IsValidCursorIndex is
// implemented.
-#if !defined(OS_MACOSX)
// Styles shouldn't be changed mid-grapheme.
- render_text->SetText(WideToUTF16(
- L"0" L"\x0915\x093f" L"1" L"\x0915\x093f" L"2"));
- render_text->ApplyStyle(UNDERLINE, true, Range(2, 5));
- std::vector<std::pair<size_t, bool> > expected_underline;
- expected_underline.push_back(std::pair<size_t, bool>(0, false));
- expected_underline.push_back(std::pair<size_t, bool>(1, true));
- expected_underline.push_back(std::pair<size_t, bool>(6, false));
- EXPECT_TRUE(render_text->styles()[UNDERLINE].EqualsForTesting(
- expected_underline));
-#endif // !defined(OS_MACOSX)
+ if (GetParam() != RENDER_TEXT_MAC) {
+ render_text_->SetText(
+ WideToUTF16(L"0"
+ L"\x0915\x093f"
+ L"1"
+ L"\x0915\x093f"
+ L"2"));
+ render_text_->ApplyStyle(UNDERLINE, true, Range(2, 5));
+ std::vector<std::pair<size_t, bool>> expected_underline;
+ expected_underline.push_back(std::pair<size_t, bool>(0, false));
+ expected_underline.push_back(std::pair<size_t, bool>(1, true));
+ expected_underline.push_back(std::pair<size_t, bool>(6, false));
+ EXPECT_TRUE(
+ render_text_->styles()[UNDERLINE].EqualsForTesting(expected_underline));
+ }
}
-TEST_F(RenderTextTest, AppendTextKeepsStyles) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
+TEST_P(RenderTextTestAll, AppendTextKeepsStyles) {
// Setup basic functionality.
- render_text->SetText(ASCIIToUTF16("abc"));
- render_text->ApplyColor(SK_ColorRED, Range(0, 1));
- render_text->ApplyBaselineStyle(SUPERSCRIPT, Range(1, 2));
- render_text->ApplyStyle(UNDERLINE, true, Range(2, 3));
+ render_text_->SetText(ASCIIToUTF16("abc"));
+ render_text_->ApplyColor(SK_ColorRED, Range(0, 1));
+ render_text_->ApplyBaselineStyle(SUPERSCRIPT, Range(1, 2));
+ render_text_->ApplyStyle(UNDERLINE, true, Range(2, 3));
// Verify basic functionality.
std::vector<std::pair<size_t, SkColor>> expected_color;
expected_color.push_back(std::pair<size_t, SkColor>(0, SK_ColorRED));
expected_color.push_back(std::pair<size_t, SkColor>(1, SK_ColorBLACK));
- EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color));
+ EXPECT_TRUE(render_text_->colors().EqualsForTesting(expected_color));
std::vector<std::pair<size_t, BaselineStyle>> expected_baseline;
expected_baseline.push_back(
std::pair<size_t, BaselineStyle>(0, NORMAL_BASELINE));
expected_baseline.push_back(std::pair<size_t, BaselineStyle>(1, SUPERSCRIPT));
expected_baseline.push_back(
std::pair<size_t, BaselineStyle>(2, NORMAL_BASELINE));
- EXPECT_TRUE(render_text->baselines().EqualsForTesting(expected_baseline));
+ EXPECT_TRUE(render_text_->baselines().EqualsForTesting(expected_baseline));
std::vector<std::pair<size_t, bool>> expected_style;
expected_style.push_back(std::pair<size_t, bool>(0, false));
expected_style.push_back(std::pair<size_t, bool>(2, true));
EXPECT_TRUE(
- render_text->styles()[UNDERLINE].EqualsForTesting(expected_style));
+ render_text_->styles()[UNDERLINE].EqualsForTesting(expected_style));
// Ensure AppendText maintains current text styles.
- render_text->AppendText(ASCIIToUTF16("def"));
- EXPECT_EQ(render_text->GetDisplayText(), ASCIIToUTF16("abcdef"));
- EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color));
- EXPECT_TRUE(render_text->baselines().EqualsForTesting(expected_baseline));
+ render_text_->AppendText(ASCIIToUTF16("def"));
+ EXPECT_EQ(render_text_->GetDisplayText(), ASCIIToUTF16("abcdef"));
+ EXPECT_TRUE(render_text_->colors().EqualsForTesting(expected_color));
+ EXPECT_TRUE(render_text_->baselines().EqualsForTesting(expected_baseline));
EXPECT_TRUE(
- render_text->styles()[UNDERLINE].EqualsForTesting(expected_style));
+ render_text_->styles()[UNDERLINE].EqualsForTesting(expected_style));
}
void TestVisualCursorMotionInObscuredField(
@@ -538,56 +558,54 @@ void TestVisualCursorMotionInObscuredField(
}
// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
-#if !defined(OS_MACOSX)
-TEST_F(RenderTextTest, ObscuredText) {
+TEST_P(RenderTextHarfBuzzTest, ObscuredText) {
const base::string16 seuss = ASCIIToUTF16("hop on pop");
const base::string16 no_seuss = ASCIIToUTF16("**********");
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
// GetLayoutText() returns asterisks when the obscured bit is set.
- render_text->SetText(seuss);
- render_text->SetObscured(true);
- EXPECT_EQ(seuss, render_text->text());
- EXPECT_EQ(no_seuss, render_text->GetDisplayText());
- render_text->SetObscured(false);
- EXPECT_EQ(seuss, render_text->text());
- EXPECT_EQ(seuss, render_text->GetDisplayText());
+ render_text_->SetText(seuss);
+ render_text_->SetObscured(true);
+ EXPECT_EQ(seuss, render_text_->text());
+ EXPECT_EQ(no_seuss, render_text_->GetDisplayText());
+ render_text_->SetObscured(false);
+ EXPECT_EQ(seuss, render_text_->text());
+ EXPECT_EQ(seuss, render_text_->GetDisplayText());
- render_text->SetObscured(true);
+ render_text_->SetObscured(true);
// Surrogate pairs are counted as one code point.
const base::char16 invalid_surrogates[] = {0xDC00, 0xD800, 0};
- render_text->SetText(invalid_surrogates);
- EXPECT_EQ(ASCIIToUTF16("**"), render_text->GetDisplayText());
+ render_text_->SetText(invalid_surrogates);
+ EXPECT_EQ(ASCIIToUTF16("**"), render_text_->GetDisplayText());
const base::char16 valid_surrogates[] = {0xD800, 0xDC00, 0};
- render_text->SetText(valid_surrogates);
- EXPECT_EQ(ASCIIToUTF16("*"), render_text->GetDisplayText());
- EXPECT_EQ(0U, render_text->cursor_position());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(2U, render_text->cursor_position());
+ render_text_->SetText(valid_surrogates);
+ EXPECT_EQ(ASCIIToUTF16("*"), render_text_->GetDisplayText());
+ EXPECT_EQ(0U, render_text_->cursor_position());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(2U, render_text_->cursor_position());
// Test index conversion and cursor validity with a valid surrogate pair.
- EXPECT_EQ(0U, render_text->TextIndexToDisplayIndex(0U));
- EXPECT_EQ(1U, render_text->TextIndexToDisplayIndex(1U));
- EXPECT_EQ(1U, render_text->TextIndexToDisplayIndex(2U));
- EXPECT_EQ(0U, render_text->DisplayIndexToTextIndex(0U));
- EXPECT_EQ(2U, render_text->DisplayIndexToTextIndex(1U));
- EXPECT_TRUE(render_text->IsValidCursorIndex(0U));
- EXPECT_FALSE(render_text->IsValidCursorIndex(1U));
- EXPECT_TRUE(render_text->IsValidCursorIndex(2U));
+ EXPECT_EQ(0U, render_text_->TextIndexToDisplayIndex(0U));
+ EXPECT_EQ(1U, render_text_->TextIndexToDisplayIndex(1U));
+ EXPECT_EQ(1U, render_text_->TextIndexToDisplayIndex(2U));
+ EXPECT_EQ(0U, render_text_->DisplayIndexToTextIndex(0U));
+ EXPECT_EQ(2U, render_text_->DisplayIndexToTextIndex(1U));
+ EXPECT_TRUE(render_text_->IsValidCursorIndex(0U));
+ EXPECT_FALSE(render_text_->IsValidCursorIndex(1U));
+ EXPECT_TRUE(render_text_->IsValidCursorIndex(2U));
// FindCursorPosition() should not return positions between a surrogate pair.
- render_text->SetDisplayRect(Rect(0, 0, 20, 20));
- EXPECT_EQ(render_text->FindCursorPosition(Point(0, 0)).caret_pos(), 0U);
- EXPECT_EQ(render_text->FindCursorPosition(Point(20, 0)).caret_pos(), 2U);
+ render_text_->SetDisplayRect(Rect(0, 0, 20, 20));
+ EXPECT_EQ(render_text_->FindCursorPosition(Point(0, 0)).caret_pos(), 0U);
+ EXPECT_EQ(render_text_->FindCursorPosition(Point(20, 0)).caret_pos(), 2U);
for (int x = -1; x <= 20; ++x) {
- SelectionModel selection = render_text->FindCursorPosition(Point(x, 0));
+ SelectionModel selection = render_text_->FindCursorPosition(Point(x, 0));
EXPECT_TRUE(selection.caret_pos() == 0U || selection.caret_pos() == 2U);
}
// GetGlyphBounds() should yield the entire string bounds for text index 0.
- EXPECT_EQ(render_text->GetStringSize().width(),
- static_cast<int>(render_text->GetGlyphBounds(0U).length()));
+ EXPECT_EQ(render_text_->GetStringSize().width(),
+ static_cast<int>(render_text_->GetGlyphBounds(0U).length()));
// Cursoring is independent of underlying characters when text is obscured.
const wchar_t* const texts[] = {
@@ -597,105 +615,102 @@ TEST_F(RenderTextTest, ObscuredText) {
};
for (size_t i = 0; i < arraysize(texts); ++i) {
base::string16 text = WideToUTF16(texts[i]);
- TestVisualCursorMotionInObscuredField(render_text.get(), text,
+ TestVisualCursorMotionInObscuredField(render_text_.get(), text,
SELECTION_NONE);
- TestVisualCursorMotionInObscuredField(render_text.get(), text,
+ TestVisualCursorMotionInObscuredField(render_text_.get(), text,
SELECTION_RETAIN);
}
}
-#endif // !defined(OS_MACOSX)
-TEST_F(RenderTextTest, RevealObscuredText) {
+TEST_P(RenderTextTestAll, RevealObscuredText) {
const base::string16 seuss = ASCIIToUTF16("hop on pop");
const base::string16 no_seuss = ASCIIToUTF16("**********");
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(seuss);
- render_text->SetObscured(true);
- EXPECT_EQ(seuss, render_text->text());
- EXPECT_EQ(no_seuss, render_text->GetDisplayText());
+ render_text_->SetText(seuss);
+ render_text_->SetObscured(true);
+ EXPECT_EQ(seuss, render_text_->text());
+ EXPECT_EQ(no_seuss, render_text_->GetDisplayText());
// Valid reveal index and new revealed index clears previous one.
- render_text->RenderText::SetObscuredRevealIndex(0);
- EXPECT_EQ(ASCIIToUTF16("h*********"), render_text->GetDisplayText());
- render_text->RenderText::SetObscuredRevealIndex(1);
- EXPECT_EQ(ASCIIToUTF16("*o********"), render_text->GetDisplayText());
- render_text->RenderText::SetObscuredRevealIndex(2);
- EXPECT_EQ(ASCIIToUTF16("**p*******"), render_text->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(0);
+ EXPECT_EQ(ASCIIToUTF16("h*********"), render_text_->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(1);
+ EXPECT_EQ(ASCIIToUTF16("*o********"), render_text_->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(2);
+ EXPECT_EQ(ASCIIToUTF16("**p*******"), render_text_->GetDisplayText());
// Invalid reveal index.
- render_text->RenderText::SetObscuredRevealIndex(-1);
- EXPECT_EQ(no_seuss, render_text->GetDisplayText());
- render_text->RenderText::SetObscuredRevealIndex(seuss.length() + 1);
- EXPECT_EQ(no_seuss, render_text->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(-1);
+ EXPECT_EQ(no_seuss, render_text_->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(seuss.length() + 1);
+ EXPECT_EQ(no_seuss, render_text_->GetDisplayText());
// SetObscured clears the revealed index.
- render_text->RenderText::SetObscuredRevealIndex(0);
- EXPECT_EQ(ASCIIToUTF16("h*********"), render_text->GetDisplayText());
- render_text->SetObscured(false);
- EXPECT_EQ(seuss, render_text->GetDisplayText());
- render_text->SetObscured(true);
- EXPECT_EQ(no_seuss, render_text->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(0);
+ EXPECT_EQ(ASCIIToUTF16("h*********"), render_text_->GetDisplayText());
+ render_text_->SetObscured(false);
+ EXPECT_EQ(seuss, render_text_->GetDisplayText());
+ render_text_->SetObscured(true);
+ EXPECT_EQ(no_seuss, render_text_->GetDisplayText());
// SetText clears the revealed index.
- render_text->SetText(ASCIIToUTF16("new"));
- EXPECT_EQ(ASCIIToUTF16("***"), render_text->GetDisplayText());
- render_text->RenderText::SetObscuredRevealIndex(2);
- EXPECT_EQ(ASCIIToUTF16("**w"), render_text->GetDisplayText());
- render_text->SetText(ASCIIToUTF16("new longer"));
- EXPECT_EQ(ASCIIToUTF16("**********"), render_text->GetDisplayText());
+ render_text_->SetText(ASCIIToUTF16("new"));
+ EXPECT_EQ(ASCIIToUTF16("***"), render_text_->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(2);
+ EXPECT_EQ(ASCIIToUTF16("**w"), render_text_->GetDisplayText());
+ render_text_->SetText(ASCIIToUTF16("new longer"));
+ EXPECT_EQ(ASCIIToUTF16("**********"), render_text_->GetDisplayText());
// Text with invalid surrogates.
const base::char16 invalid_surrogates[] = {0xDC00, 0xD800, 'h', 'o', 'p', 0};
- render_text->SetText(invalid_surrogates);
- EXPECT_EQ(ASCIIToUTF16("*****"), render_text->GetDisplayText());
- render_text->RenderText::SetObscuredRevealIndex(0);
+ render_text_->SetText(invalid_surrogates);
+ EXPECT_EQ(ASCIIToUTF16("*****"), render_text_->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(0);
const base::char16 invalid_expect_0[] = {0xDC00, '*', '*', '*', '*', 0};
- EXPECT_EQ(invalid_expect_0, render_text->GetDisplayText());
- render_text->RenderText::SetObscuredRevealIndex(1);
+ EXPECT_EQ(invalid_expect_0, render_text_->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(1);
const base::char16 invalid_expect_1[] = {'*', 0xD800, '*', '*', '*', 0};
- EXPECT_EQ(invalid_expect_1, render_text->GetDisplayText());
- render_text->RenderText::SetObscuredRevealIndex(2);
- EXPECT_EQ(ASCIIToUTF16("**h**"), render_text->GetDisplayText());
+ EXPECT_EQ(invalid_expect_1, render_text_->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(2);
+ EXPECT_EQ(ASCIIToUTF16("**h**"), render_text_->GetDisplayText());
// Text with valid surrogates before and after the reveal index.
const base::char16 valid_surrogates[] =
{0xD800, 0xDC00, 'h', 'o', 'p', 0xD800, 0xDC00, 0};
- render_text->SetText(valid_surrogates);
- EXPECT_EQ(ASCIIToUTF16("*****"), render_text->GetDisplayText());
- render_text->RenderText::SetObscuredRevealIndex(0);
+ render_text_->SetText(valid_surrogates);
+ EXPECT_EQ(ASCIIToUTF16("*****"), render_text_->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(0);
const base::char16 valid_expect_0_and_1[] =
{0xD800, 0xDC00, '*', '*', '*', '*', 0};
- EXPECT_EQ(valid_expect_0_and_1, render_text->GetDisplayText());
- render_text->RenderText::SetObscuredRevealIndex(1);
- EXPECT_EQ(valid_expect_0_and_1, render_text->GetDisplayText());
- render_text->RenderText::SetObscuredRevealIndex(2);
- EXPECT_EQ(ASCIIToUTF16("*h***"), render_text->GetDisplayText());
- render_text->RenderText::SetObscuredRevealIndex(5);
+ EXPECT_EQ(valid_expect_0_and_1, render_text_->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(1);
+ EXPECT_EQ(valid_expect_0_and_1, render_text_->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(2);
+ EXPECT_EQ(ASCIIToUTF16("*h***"), render_text_->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(5);
const base::char16 valid_expect_5_and_6[] =
{'*', '*', '*', '*', 0xD800, 0xDC00, 0};
- EXPECT_EQ(valid_expect_5_and_6, render_text->GetDisplayText());
- render_text->RenderText::SetObscuredRevealIndex(6);
- EXPECT_EQ(valid_expect_5_and_6, render_text->GetDisplayText());
+ EXPECT_EQ(valid_expect_5_and_6, render_text_->GetDisplayText());
+ render_text_->RenderText::SetObscuredRevealIndex(6);
+ EXPECT_EQ(valid_expect_5_and_6, render_text_->GetDisplayText());
}
-TEST_F(RenderTextTest, ObscuredEmoji) {
+TEST_P(RenderTextTestAll, ObscuredEmoji) {
// Ensures text itemization doesn't crash on obscured multi-char glyphs.
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetObscured(true);
- Canvas canvas;
+ render_text_->SetObscured(true);
// Test the "Grinning face with smiling eyes" character followed by 'y'.
- render_text->SetText(UTF8ToUTF16("\xF0\x9F\x98\x81y"));
- render_text->Draw(&canvas);
+ render_text_->SetText(UTF8ToUTF16("\xF0\x9F\x98\x81y"));
+ render_text_->Draw(&canvas_);
// Test two "Camera" characters in a row.
- render_text->SetText(UTF8ToUTF16("\xF0\x9F\x93\xB7\xF0\x9F\x93\xB7"));
- render_text->Draw(&canvas);
+ render_text_->SetText(UTF8ToUTF16("\xF0\x9F\x93\xB7\xF0\x9F\x93\xB7"));
+ render_text_->Draw(&canvas_);
}
// TODO(PORT): Fails for RenderTextMac.
+// Crashes on Mac with RenderTextHarfBuzz. See http://crbug.com/640068.
#if !defined(OS_MACOSX)
-TEST_F(RenderTextTest, ElidedText) {
+TEST_P(RenderTextTestAll, ElidedText) {
// TODO(skanuj) : Add more test cases for following
// - RenderText styles.
// - Cross interaction of truncate, elide and obscure.
@@ -744,14 +759,12 @@ TEST_F(RenderTextTest, ElidedText) {
{ L"012\xF0\x9D\x84\x9E", L"012\xF0\x2026" , true },
};
- std::unique_ptr<RenderText> expected_render_text(
- RenderText::CreateInstance());
+ std::unique_ptr<RenderText> expected_render_text(CreateRenderTextInstance());
expected_render_text->SetFontList(FontList("serif, Sans serif, 12px"));
expected_render_text->SetDisplayRect(Rect(0, 0, 9999, 100));
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetFontList(FontList("serif, Sans serif, 12px"));
- render_text->SetElideBehavior(ELIDE_TAIL);
+ render_text_->SetFontList(FontList("serif, Sans serif, 12px"));
+ render_text_->SetElideBehavior(ELIDE_TAIL);
for (size_t i = 0; i < arraysize(cases); i++) {
SCOPED_TRACE(base::StringPrintf("Testing cases[%" PRIuS "] '%ls'", i,
@@ -766,56 +779,55 @@ TEST_F(RenderTextTest, ElidedText) {
// and so it will get elided.
if (cases[i].elision_expected)
input.append(WideToUTF16(L" MMMMMMMMMMM"));
- render_text->SetText(input);
- render_text->SetDisplayRect(Rect(0, 0, expected_width, 100));
- EXPECT_EQ(input, render_text->text());
+ render_text_->SetText(input);
+ render_text_->SetDisplayRect(Rect(0, 0, expected_width, 100));
+ EXPECT_EQ(input, render_text_->text());
EXPECT_EQ(WideToUTF16(cases[i].display_text),
- render_text->GetDisplayText());
+ render_text_->GetDisplayText());
expected_render_text->SetText(base::string16());
}
}
-TEST_F(RenderTextTest, ElidedObscuredText) {
- std::unique_ptr<RenderText> expected_render_text(
- RenderText::CreateInstance());
+TEST_P(RenderTextTestAll, ElidedObscuredText) {
+ std::unique_ptr<RenderText> expected_render_text(CreateRenderTextInstance());
expected_render_text->SetFontList(FontList("serif, Sans serif, 12px"));
expected_render_text->SetDisplayRect(Rect(0, 0, 9999, 100));
expected_render_text->SetText(WideToUTF16(L"**\x2026"));
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetFontList(FontList("serif, Sans serif, 12px"));
- render_text->SetElideBehavior(ELIDE_TAIL);
- render_text->SetDisplayRect(
+ render_text_->SetFontList(FontList("serif, Sans serif, 12px"));
+ render_text_->SetElideBehavior(ELIDE_TAIL);
+ render_text_->SetDisplayRect(
Rect(0, 0, expected_render_text->GetContentWidth(), 100));
- render_text->SetObscured(true);
- render_text->SetText(WideToUTF16(L"abcdef"));
- EXPECT_EQ(WideToUTF16(L"abcdef"), render_text->text());
- EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text->GetDisplayText());
+ render_text_->SetObscured(true);
+ render_text_->SetText(WideToUTF16(L"abcdef"));
+ EXPECT_EQ(WideToUTF16(L"abcdef"), render_text_->text());
+ EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text_->GetDisplayText());
}
+#endif // !defined(OS_MACOSX)
-TEST_F(RenderTextTest, MultilineElide) {
- std::unique_ptr<RenderText> render_text(new RenderTextHarfBuzz);
+// TODO(PORT): Fails for RenderTextMac.
+TEST_P(RenderTextHarfBuzzTest, MultilineElide) {
base::string16 input_text;
// Aim for 3 lines of text.
for (int i = 0; i < 20; ++i)
input_text.append(ASCIIToUTF16("hello world "));
- render_text->SetText(input_text);
+ render_text_->SetText(input_text);
// Apply a style that tweaks the layout to make sure elision is calculated
// with these styles. This can expose a behavior in layout where text is
// slightly different width. This must be done after |SetText()|.
- render_text->ApplyWeight(Font::Weight::BOLD, Range(1, 20));
- render_text->ApplyStyle(ITALIC, true, Range(1, 20));
- render_text->ApplyStyle(DIAGONAL_STRIKE, true, Range(1, 20));
- render_text->SetMultiline(true);
- render_text->SetElideBehavior(ELIDE_TAIL);
- render_text->SetMaxLines(3);
- const Size size = render_text->GetStringSize();
+ render_text_->ApplyWeight(Font::Weight::BOLD, Range(1, 20));
+ render_text_->ApplyStyle(ITALIC, true, Range(1, 20));
+ render_text_->ApplyStyle(DIAGONAL_STRIKE, true, Range(1, 20));
+ render_text_->SetMultiline(true);
+ render_text_->SetElideBehavior(ELIDE_TAIL);
+ render_text_->SetMaxLines(3);
+ const Size size = render_text_->GetStringSize();
// Fit in 3 lines. (If we knew the width of a word, we could
// anticipate word wrap better.)
- render_text->SetDisplayRect(Rect((size.width() + 96) / 3, 0));
+ render_text_->SetDisplayRect(Rect((size.width() + 96) / 3, 0));
// Trigger rendering.
- render_text->GetStringSize();
- EXPECT_EQ(input_text, render_text->GetDisplayText());
+ render_text_->GetStringSize();
+ EXPECT_EQ(input_text, render_text_->GetDisplayText());
const base::char16 kEllipsisUTF16[] = {0x2026, 0};
base::string16 actual_text;
@@ -824,45 +836,42 @@ TEST_F(RenderTextTest, MultilineElide) {
// the edge of a word getting truncated, the estimate would be wrong
// and it would wrap instead.
for (int i = (size.width() - 12) / 3; i < (size.width() + 30) / 3; ++i) {
- render_text->SetDisplayRect(Rect(i, 0));
+ render_text_->SetDisplayRect(Rect(i, 0));
// Trigger rendering.
- render_text->GetStringSize();
- actual_text = render_text->GetDisplayText();
+ render_text_->GetStringSize();
+ actual_text = render_text_->GetDisplayText();
EXPECT_LT(actual_text.size(), input_text.size());
EXPECT_EQ(actual_text, input_text.substr(0, actual_text.size() - 1) +
base::string16(kEllipsisUTF16));
- EXPECT_EQ(3U, render_text->GetNumLines());
+ EXPECT_EQ(3U, render_text_->GetNumLines());
}
// Now remove line restriction.
- render_text->SetMaxLines(0);
- render_text->GetStringSize();
- EXPECT_EQ(input_text, render_text->GetDisplayText());
+ render_text_->SetMaxLines(0);
+ render_text_->GetStringSize();
+ EXPECT_EQ(input_text, render_text_->GetDisplayText());
// And put it back.
- render_text->SetMaxLines(3);
- render_text->GetStringSize();
+ render_text_->SetMaxLines(3);
+ render_text_->GetStringSize();
EXPECT_LT(actual_text.size(), input_text.size());
EXPECT_EQ(actual_text, input_text.substr(0, actual_text.size() - 1) +
base::string16(kEllipsisUTF16));
}
-#endif // !defined(OS_MACOSX)
-
-TEST_F(RenderTextTest, ElidedEmail) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(ASCIIToUTF16("test@example.com"));
- const Size size = render_text->GetStringSize();
+TEST_P(RenderTextTestAll, ElidedEmail) {
+ render_text_->SetText(ASCIIToUTF16("test@example.com"));
+ const Size size = render_text_->GetStringSize();
const base::string16 long_email =
ASCIIToUTF16("longemailaddresstest@example.com");
- render_text->SetText(long_email);
- render_text->SetElideBehavior(ELIDE_EMAIL);
- render_text->SetDisplayRect(Rect(size));
- EXPECT_GE(size.width(), render_text->GetStringSize().width());
- EXPECT_GT(long_email.size(), render_text->GetDisplayText().size());
+ render_text_->SetText(long_email);
+ render_text_->SetElideBehavior(ELIDE_EMAIL);
+ render_text_->SetDisplayRect(Rect(size));
+ EXPECT_GE(size.width(), render_text_->GetStringSize().width());
+ EXPECT_GT(long_email.size(), render_text_->GetDisplayText().size());
}
-TEST_F(RenderTextTest, TruncatedText) {
+TEST_P(RenderTextTestAll, TruncatedText) {
struct {
const wchar_t* text;
const wchar_t* display_text;
@@ -897,37 +906,36 @@ TEST_F(RenderTextTest, TruncatedText) {
{ L"012\xF0\x9D\x84\x9E", L"012\xF0\x2026" },
};
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->set_truncate_length(5);
+ render_text_->set_truncate_length(5);
for (size_t i = 0; i < arraysize(cases); i++) {
- render_text->SetText(WideToUTF16(cases[i].text));
- EXPECT_EQ(WideToUTF16(cases[i].text), render_text->text());
- EXPECT_EQ(WideToUTF16(cases[i].display_text), render_text->GetDisplayText())
+ render_text_->SetText(WideToUTF16(cases[i].text));
+ EXPECT_EQ(WideToUTF16(cases[i].text), render_text_->text());
+ EXPECT_EQ(WideToUTF16(cases[i].display_text),
+ render_text_->GetDisplayText())
<< "For case " << i << ": " << cases[i].text;
}
}
-TEST_F(RenderTextTest, TruncatedObscuredText) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->set_truncate_length(3);
- render_text->SetObscured(true);
- render_text->SetText(WideToUTF16(L"abcdef"));
- EXPECT_EQ(WideToUTF16(L"abcdef"), render_text->text());
- EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text->GetDisplayText());
+TEST_P(RenderTextTestAll, TruncatedObscuredText) {
+ render_text_->set_truncate_length(3);
+ render_text_->SetObscured(true);
+ render_text_->SetText(WideToUTF16(L"abcdef"));
+ EXPECT_EQ(WideToUTF16(L"abcdef"), render_text_->text());
+ EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text_->GetDisplayText());
}
// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
-#if !defined(OS_MACOSX)
-TEST_F(RenderTextTest, TruncatedCursorMovementLTR) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->set_truncate_length(2);
- render_text->SetText(WideToUTF16(L"abcd"));
-
- EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
- render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text->selection_model());
- render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
+TEST_P(RenderTextHarfBuzzTest, TruncatedCursorMovementLTR) {
+ render_text_->set_truncate_length(2);
+ render_text_->SetText(WideToUTF16(L"abcd"));
+
+ EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD),
+ render_text_->selection_model());
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text_->selection_model());
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD),
+ render_text_->selection_model());
std::vector<SelectionModel> expected;
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
@@ -935,7 +943,7 @@ TEST_F(RenderTextTest, TruncatedCursorMovementLTR) {
// The cursor hops over the ellipsis and elided text to the line end.
expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
expected.push_back(SelectionModel(4, CURSOR_FORWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_RIGHT);
expected.clear();
expected.push_back(SelectionModel(4, CURSOR_FORWARD));
@@ -943,19 +951,21 @@ TEST_F(RenderTextTest, TruncatedCursorMovementLTR) {
expected.push_back(SelectionModel(1, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_LEFT);
}
-TEST_F(RenderTextTest, TruncatedCursorMovementRTL) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->set_truncate_length(2);
- render_text->SetText(WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3"));
-
- EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
- render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text->selection_model());
- render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, TruncatedCursorMovementRTL) {
+ render_text_->set_truncate_length(2);
+ render_text_->SetText(WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3"));
+
+ EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD),
+ render_text_->selection_model());
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text_->selection_model());
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD),
+ render_text_->selection_model());
std::vector<SelectionModel> expected;
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
@@ -963,7 +973,7 @@ TEST_F(RenderTextTest, TruncatedCursorMovementRTL) {
// The cursor hops over the ellipsis and elided text to the line end.
expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
expected.push_back(SelectionModel(4, CURSOR_FORWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_LEFT);
expected.clear();
expected.push_back(SelectionModel(4, CURSOR_FORWARD));
@@ -971,240 +981,241 @@ TEST_F(RenderTextTest, TruncatedCursorMovementRTL) {
expected.push_back(SelectionModel(1, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_RIGHT);
}
-#endif // !defined(OS_MACOSX)
-TEST_F(RenderTextTest, MoveCursor_Character) {
- std::unique_ptr<RenderText> render_text(
- RenderText::CreateInstanceForEditing());
- render_text->SetText(WideToUTF16(L"123 456 789"));
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, MoveCursor_Character) {
+ render_text_->SetText(WideToUTF16(L"123 456 789"));
std::vector<Range> expected;
// SELECTION_NONE.
- render_text->SelectRange(Range(6));
+ render_text_->SelectRange(Range(6));
// Move right twice.
expected.push_back(Range(7));
expected.push_back(Range(8));
- RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), CHARACTER_BREAK,
CURSOR_RIGHT, SELECTION_NONE,
&expected);
// Move left twice.
expected.push_back(Range(7));
expected.push_back(Range(6));
- RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), CHARACTER_BREAK,
CURSOR_LEFT, SELECTION_NONE, &expected);
// SELECTION_CARET.
- render_text->SelectRange(Range(6));
+ render_text_->SelectRange(Range(6));
expected.push_back(Range(6, 7));
// Move right.
- RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), CHARACTER_BREAK,
CURSOR_RIGHT, SELECTION_CARET,
&expected);
// Move left twice.
expected.push_back(Range(6));
expected.push_back(Range(6, 5));
- RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), CHARACTER_BREAK,
CURSOR_LEFT, SELECTION_CARET,
&expected);
// SELECTION_RETAIN.
- render_text->SelectRange(Range(6));
+ render_text_->SelectRange(Range(6));
// Move right.
expected.push_back(Range(6, 7));
- RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), CHARACTER_BREAK,
CURSOR_RIGHT, SELECTION_RETAIN,
&expected);
// Move left twice.
expected.push_back(Range(6));
expected.push_back(Range(6, 5));
- RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), CHARACTER_BREAK,
CURSOR_LEFT, SELECTION_RETAIN,
&expected);
// SELECTION_EXTEND.
- render_text->SelectRange(Range(6));
+ render_text_->SelectRange(Range(6));
// Move right.
expected.push_back(Range(6, 7));
- RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), CHARACTER_BREAK,
CURSOR_RIGHT, SELECTION_EXTEND,
&expected);
// Move left twice.
expected.push_back(Range(7, 6));
expected.push_back(Range(7, 5));
- RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), CHARACTER_BREAK,
CURSOR_LEFT, SELECTION_EXTEND,
&expected);
}
-TEST_F(RenderTextTest, MoveCursor_Word) {
- std::unique_ptr<RenderText> render_text(
- RenderText::CreateInstanceForEditing());
- render_text->SetText(WideToUTF16(L"123 456 789"));
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, MoveCursor_Word) {
+ render_text_->SetText(WideToUTF16(L"123 456 789"));
std::vector<Range> expected;
// SELECTION_NONE.
- render_text->SelectRange(Range(6));
+ render_text_->SelectRange(Range(6));
// Move left twice.
expected.push_back(Range(4));
expected.push_back(Range(0));
- RunMoveCursorTestAndClearExpectations(render_text.get(), WORD_BREAK,
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), WORD_BREAK,
CURSOR_LEFT, SELECTION_NONE, &expected);
// Move right twice.
expected.push_back(Range(3));
expected.push_back(Range(7));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE, &expected);
+ render_text_.get(), WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE, &expected);
// SELECTION_CARET.
- render_text->SelectRange(Range(6));
+ render_text_->SelectRange(Range(6));
// Move left.
expected.push_back(Range(6, 4));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_CARET, &expected);
+ render_text_.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_CARET, &expected);
// Move right twice.
expected.push_back(Range(6));
expected.push_back(Range(6, 7));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), WORD_BREAK, CURSOR_RIGHT, SELECTION_CARET, &expected);
+ render_text_.get(), WORD_BREAK, CURSOR_RIGHT, SELECTION_CARET, &expected);
// Move left.
expected.push_back(Range(6));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_CARET, &expected);
+ render_text_.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_CARET, &expected);
// SELECTION_RETAIN.
- render_text->SelectRange(Range(6));
+ render_text_->SelectRange(Range(6));
// Move left.
expected.push_back(Range(6, 4));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_RETAIN, &expected);
+ render_text_.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_RETAIN, &expected);
// Move right twice.
expected.push_back(Range(6, 7));
expected.push_back(Range(6, 11));
- RunMoveCursorTestAndClearExpectations(
- render_text.get(), WORD_BREAK, CURSOR_RIGHT, SELECTION_RETAIN, &expected);
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), WORD_BREAK,
+ CURSOR_RIGHT, SELECTION_RETAIN,
+ &expected);
// Move left.
expected.push_back(Range(6, 8));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_RETAIN, &expected);
+ render_text_.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_RETAIN, &expected);
// SELECTION_EXTEND.
- render_text->SelectRange(Range(6));
+ render_text_->SelectRange(Range(6));
// Move left.
expected.push_back(Range(6, 4));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_EXTEND, &expected);
+ render_text_.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_EXTEND, &expected);
// Move right twice.
expected.push_back(Range(4, 7));
expected.push_back(Range(4, 11));
- RunMoveCursorTestAndClearExpectations(
- render_text.get(), WORD_BREAK, CURSOR_RIGHT, SELECTION_EXTEND, &expected);
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), WORD_BREAK,
+ CURSOR_RIGHT, SELECTION_EXTEND,
+ &expected);
// Move left.
expected.push_back(Range(4, 8));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_EXTEND, &expected);
+ render_text_.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_EXTEND, &expected);
}
-TEST_F(RenderTextTest, MoveCursor_Line) {
- std::unique_ptr<RenderText> render_text(
- RenderText::CreateInstanceForEditing());
- render_text->SetText(WideToUTF16(L"123 456 789"));
+TEST_P(RenderTextTestAll, MoveCursor_Line) {
+ render_text_->SetText(WideToUTF16(L"123 456 789"));
std::vector<Range> expected;
// SELECTION_NONE.
- render_text->SelectRange(Range(6));
+ render_text_->SelectRange(Range(6));
// Move right twice.
expected.push_back(Range(11));
expected.push_back(Range(11));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE, &expected);
+ render_text_.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE, &expected);
// Move left twice.
expected.push_back(Range(0));
expected.push_back(Range(0));
- RunMoveCursorTestAndClearExpectations(render_text.get(), LINE_BREAK,
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), LINE_BREAK,
CURSOR_LEFT, SELECTION_NONE, &expected);
// SELECTION_CARET.
- render_text->SelectRange(Range(6));
+ render_text_->SelectRange(Range(6));
// Move right.
expected.push_back(Range(6, 11));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_CARET, &expected);
+ render_text_.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_CARET, &expected);
// Move left twice.
expected.push_back(Range(6));
expected.push_back(Range(6, 0));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), LINE_BREAK, CURSOR_LEFT, SELECTION_CARET, &expected);
+ render_text_.get(), LINE_BREAK, CURSOR_LEFT, SELECTION_CARET, &expected);
// Move right.
expected.push_back(Range(6));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_CARET, &expected);
+ render_text_.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_CARET, &expected);
// SELECTION_RETAIN.
- render_text->SelectRange(Range(6));
+ render_text_->SelectRange(Range(6));
// Move right.
expected.push_back(Range(6, 11));
- RunMoveCursorTestAndClearExpectations(
- render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_RETAIN, &expected);
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), LINE_BREAK,
+ CURSOR_RIGHT, SELECTION_RETAIN,
+ &expected);
// Move left twice.
expected.push_back(Range(6, 0));
expected.push_back(Range(6, 0));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), LINE_BREAK, CURSOR_LEFT, SELECTION_RETAIN, &expected);
+ render_text_.get(), LINE_BREAK, CURSOR_LEFT, SELECTION_RETAIN, &expected);
// Move right.
expected.push_back(Range(6, 11));
- RunMoveCursorTestAndClearExpectations(
- render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_RETAIN, &expected);
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), LINE_BREAK,
+ CURSOR_RIGHT, SELECTION_RETAIN,
+ &expected);
// SELECTION_EXTEND.
- render_text->SelectRange(Range(6));
+ render_text_->SelectRange(Range(6));
// Move right.
expected.push_back(Range(6, 11));
- RunMoveCursorTestAndClearExpectations(
- render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_EXTEND, &expected);
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), LINE_BREAK,
+ CURSOR_RIGHT, SELECTION_EXTEND,
+ &expected);
// Move left twice.
expected.push_back(Range(11, 0));
expected.push_back(Range(11, 0));
RunMoveCursorTestAndClearExpectations(
- render_text.get(), LINE_BREAK, CURSOR_LEFT, SELECTION_EXTEND, &expected);
+ render_text_.get(), LINE_BREAK, CURSOR_LEFT, SELECTION_EXTEND, &expected);
// Move right.
expected.push_back(Range(0, 11));
- RunMoveCursorTestAndClearExpectations(
- render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_EXTEND, &expected);
+ RunMoveCursorTestAndClearExpectations(render_text_.get(), LINE_BREAK,
+ CURSOR_RIGHT, SELECTION_EXTEND,
+ &expected);
}
-TEST_F(RenderTextTest, GetDisplayTextDirection) {
+TEST_P(RenderTextTestAll, GetDisplayTextDirection) {
struct {
const wchar_t* text;
const base::i18n::TextDirection text_direction;
@@ -1222,7 +1233,6 @@ TEST_F(RenderTextTest, GetDisplayTextDirection) {
{ kRtlLtrRtl, base::i18n::RIGHT_TO_LEFT },
};
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
const bool was_rtl = base::i18n::IsRTL();
for (size_t i = 0; i < 2; ++i) {
@@ -1233,16 +1243,17 @@ TEST_F(RenderTextTest, GetDisplayTextDirection) {
// Ensure that directionality modes yield the correct text directions.
for (size_t j = 0; j < arraysize(cases); j++) {
- render_text->SetText(WideToUTF16(cases[j].text));
- render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
- EXPECT_EQ(render_text->GetDisplayTextDirection(),cases[j].text_direction);
- render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_UI);
- EXPECT_EQ(render_text->GetDisplayTextDirection(), ui_direction);
- render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
- EXPECT_EQ(render_text->GetDisplayTextDirection(),
+ render_text_->SetText(WideToUTF16(cases[j].text));
+ render_text_->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
+ EXPECT_EQ(render_text_->GetDisplayTextDirection(),
+ cases[j].text_direction);
+ render_text_->SetDirectionalityMode(DIRECTIONALITY_FROM_UI);
+ EXPECT_EQ(render_text_->GetDisplayTextDirection(), ui_direction);
+ render_text_->SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
+ EXPECT_EQ(render_text_->GetDisplayTextDirection(),
base::i18n::LEFT_TO_RIGHT);
- render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_RTL);
- EXPECT_EQ(render_text->GetDisplayTextDirection(),
+ render_text_->SetDirectionalityMode(DIRECTIONALITY_FORCE_RTL);
+ EXPECT_EQ(render_text_->GetDisplayTextDirection(),
base::i18n::RIGHT_TO_LEFT);
}
}
@@ -1250,20 +1261,17 @@ TEST_F(RenderTextTest, GetDisplayTextDirection) {
EXPECT_EQ(was_rtl, base::i18n::IsRTL());
// Ensure that text changes update the direction for DIRECTIONALITY_FROM_TEXT.
- render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
- render_text->SetText(WideToUTF16(kLtr));
- EXPECT_EQ(render_text->GetDisplayTextDirection(), base::i18n::LEFT_TO_RIGHT);
- render_text->SetText(WideToUTF16(kRtl));
- EXPECT_EQ(render_text->GetDisplayTextDirection(), base::i18n::RIGHT_TO_LEFT);
+ render_text_->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
+ render_text_->SetText(WideToUTF16(kLtr));
+ EXPECT_EQ(render_text_->GetDisplayTextDirection(), base::i18n::LEFT_TO_RIGHT);
+ render_text_->SetText(WideToUTF16(kRtl));
+ EXPECT_EQ(render_text_->GetDisplayTextDirection(), base::i18n::RIGHT_TO_LEFT);
}
// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
-#if !defined(OS_MACOSX)
-TEST_F(RenderTextTest, MoveCursorLeftRightInLtr) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
-
+TEST_P(RenderTextHarfBuzzTest, MoveCursorLeftRightInLtr) {
// Pure LTR.
- render_text->SetText(ASCIIToUTF16("abc"));
+ render_text_->SetText(ASCIIToUTF16("abc"));
// |expected| saves the expected SelectionModel when moving cursor from left
// to right.
std::vector<SelectionModel> expected;
@@ -1272,7 +1280,7 @@ TEST_F(RenderTextTest, MoveCursorLeftRightInLtr) {
expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
expected.push_back(SelectionModel(3, CURSOR_FORWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_RIGHT);
expected.clear();
expected.push_back(SelectionModel(3, CURSOR_FORWARD));
@@ -1280,13 +1288,13 @@ TEST_F(RenderTextTest, MoveCursorLeftRightInLtr) {
expected.push_back(SelectionModel(1, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_LEFT);
}
-TEST_F(RenderTextTest, MoveCursorLeftRightInLtrRtl) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, MoveCursorLeftRightInLtrRtl) {
// LTR-RTL
- render_text->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
+ render_text_->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
// The last one is the expected END position.
std::vector<SelectionModel> expected;
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
@@ -1297,7 +1305,7 @@ TEST_F(RenderTextTest, MoveCursorLeftRightInLtrRtl) {
expected.push_back(SelectionModel(4, CURSOR_FORWARD));
expected.push_back(SelectionModel(3, CURSOR_FORWARD));
expected.push_back(SelectionModel(6, CURSOR_FORWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_RIGHT);
expected.clear();
expected.push_back(SelectionModel(6, CURSOR_FORWARD));
@@ -1308,20 +1316,23 @@ TEST_F(RenderTextTest, MoveCursorLeftRightInLtrRtl) {
expected.push_back(SelectionModel(1, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_LEFT);
}
-TEST_F(RenderTextTest, MoveCursorLeftRightInLtrRtlLtr) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, MoveCursorLeftRightInLtrRtlLtr) {
// LTR-RTL-LTR.
- render_text->SetText(WideToUTF16(L"a" L"\x05d1" L"b"));
+ render_text_->SetText(
+ WideToUTF16(L"a"
+ L"\x05d1"
+ L"b"));
std::vector<SelectionModel> expected;
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
expected.push_back(SelectionModel(1, CURSOR_FORWARD));
expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
expected.push_back(SelectionModel(3, CURSOR_FORWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_RIGHT);
expected.clear();
expected.push_back(SelectionModel(3, CURSOR_FORWARD));
@@ -1329,14 +1340,14 @@ TEST_F(RenderTextTest, MoveCursorLeftRightInLtrRtlLtr) {
expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
expected.push_back(SelectionModel(0, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_LEFT);
}
-TEST_F(RenderTextTest, MoveCursorLeftRightInRtl) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, MoveCursorLeftRightInRtl) {
// Pure RTL.
- render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2"));
- render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ render_text_->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2"));
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
std::vector<SelectionModel> expected;
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
@@ -1344,7 +1355,7 @@ TEST_F(RenderTextTest, MoveCursorLeftRightInRtl) {
expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
expected.push_back(SelectionModel(3, CURSOR_FORWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_LEFT);
expected.clear();
@@ -1353,14 +1364,16 @@ TEST_F(RenderTextTest, MoveCursorLeftRightInRtl) {
expected.push_back(SelectionModel(1, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_RIGHT);
}
-TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtr) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, MoveCursorLeftRightInRtlLtr) {
// RTL-LTR
- render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2" L"abc"));
- render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ render_text_->SetText(
+ WideToUTF16(L"\x05d0\x05d1\x05d2"
+ L"abc"));
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
std::vector<SelectionModel> expected;
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
@@ -1370,7 +1383,7 @@ TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtr) {
expected.push_back(SelectionModel(4, CURSOR_FORWARD));
expected.push_back(SelectionModel(3, CURSOR_FORWARD));
expected.push_back(SelectionModel(6, CURSOR_FORWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_LEFT);
expected.clear();
expected.push_back(SelectionModel(6, CURSOR_FORWARD));
@@ -1381,21 +1394,24 @@ TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtr) {
expected.push_back(SelectionModel(1, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_RIGHT);
}
-TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtrRtl) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, MoveCursorLeftRightInRtlLtrRtl) {
// RTL-LTR-RTL.
- render_text->SetText(WideToUTF16(L"\x05d0" L"a" L"\x05d1"));
- render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ render_text_->SetText(
+ WideToUTF16(L"\x05d0"
+ L"a"
+ L"\x05d1"));
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
std::vector<SelectionModel> expected;
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
expected.push_back(SelectionModel(1, CURSOR_FORWARD));
expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
expected.push_back(SelectionModel(3, CURSOR_FORWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_LEFT);
expected.clear();
expected.push_back(SelectionModel(3, CURSOR_FORWARD));
@@ -1403,48 +1419,51 @@ TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtrRtl) {
expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
expected.push_back(SelectionModel(0, CURSOR_FORWARD));
expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
- RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
-}
-
-TEST_F(RenderTextTest, MoveCursorLeftRight_ComplexScript) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
-
- render_text->SetText(WideToUTF16(L"\x0915\x093f\x0915\x094d\x0915"));
- EXPECT_EQ(0U, render_text->cursor_position());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(2U, render_text->cursor_position());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(4U, render_text->cursor_position());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(5U, render_text->cursor_position());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(5U, render_text->cursor_position());
-
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(4U, render_text->cursor_position());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(2U, render_text->cursor_position());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(0U, render_text->cursor_position());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(0U, render_text->cursor_position());
-}
-
-TEST_F(RenderTextTest, MoveCursorLeftRight_MeiryoUILigatures) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
+ RunMoveCursorLeftRightTest(render_text_.get(), expected, CURSOR_RIGHT);
+}
+
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, MoveCursorLeftRight_ComplexScript) {
+ render_text_->SetText(WideToUTF16(L"\x0915\x093f\x0915\x094d\x0915"));
+ EXPECT_EQ(0U, render_text_->cursor_position());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(2U, render_text_->cursor_position());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(4U, render_text_->cursor_position());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(5U, render_text_->cursor_position());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(5U, render_text_->cursor_position());
+
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(4U, render_text_->cursor_position());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(2U, render_text_->cursor_position());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(0U, render_text_->cursor_position());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(0U, render_text_->cursor_position());
+}
+
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+// Crashes on Mac with RenderTextHarfBuzz. See http://crbug.com/640068.
+#if !defined(OS_MACOSX)
+TEST_P(RenderTextHarfBuzzTest, MoveCursorLeftRight_MeiryoUILigatures) {
// Meiryo UI uses single-glyph ligatures for 'ff' and 'ffi', but each letter
// (code point) has unique bounds, so mid-glyph cursoring should be possible.
- render_text->SetFontList(FontList("Meiryo UI, 12px"));
- render_text->SetText(WideToUTF16(L"ff ffi"));
- EXPECT_EQ(0U, render_text->cursor_position());
- for (size_t i = 0; i < render_text->text().length(); ++i) {
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(i + 1, render_text->cursor_position());
+ render_text_->SetFontList(FontList("Meiryo UI, 12px"));
+ render_text_->SetText(WideToUTF16(L"ff ffi"));
+ EXPECT_EQ(0U, render_text_->cursor_position());
+ for (size_t i = 0; i < render_text_->text().length(); ++i) {
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(i + 1, render_text_->cursor_position());
}
- EXPECT_EQ(6U, render_text->cursor_position());
+ EXPECT_EQ(6U, render_text_->cursor_position());
}
+#endif // !defined(OS_MACOSX)
-TEST_F(RenderTextTest, GraphemePositions) {
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, GraphemePositions) {
// LTR 2-character grapheme, LTR abc, LTR 2-character grapheme.
const base::string16 kText1 =
WideToUTF16(L"\x0915\x093f" L"abc" L"\x0915\x093f");
@@ -1504,24 +1523,24 @@ TEST_F(RenderTextTest, GraphemePositions) {
return;
#endif
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
for (size_t i = 0; i < arraysize(cases); i++) {
SCOPED_TRACE(base::StringPrintf("Testing cases[%" PRIuS "]", i));
- render_text->SetText(cases[i].text);
+ render_text_->SetText(cases[i].text);
- size_t next = render_text->IndexOfAdjacentGrapheme(cases[i].index,
- CURSOR_FORWARD);
+ size_t next =
+ render_text_->IndexOfAdjacentGrapheme(cases[i].index, CURSOR_FORWARD);
EXPECT_EQ(cases[i].expected_next, next);
- EXPECT_TRUE(render_text->IsValidCursorIndex(next));
+ EXPECT_TRUE(render_text_->IsValidCursorIndex(next));
- size_t previous = render_text->IndexOfAdjacentGrapheme(cases[i].index,
- CURSOR_BACKWARD);
+ size_t previous =
+ render_text_->IndexOfAdjacentGrapheme(cases[i].index, CURSOR_BACKWARD);
EXPECT_EQ(cases[i].expected_previous, previous);
- EXPECT_TRUE(render_text->IsValidCursorIndex(previous));
+ EXPECT_TRUE(render_text_->IsValidCursorIndex(previous));
}
}
-TEST_F(RenderTextTest, MidGraphemeSelectionBounds) {
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, MidGraphemeSelectionBounds) {
#if defined(OS_WIN)
// TODO(msw): XP fails due to lack of font support: http://crbug.com/106450
if (base::win::GetVersion() < base::win::VERSION_VISTA)
@@ -1533,42 +1552,40 @@ TEST_F(RenderTextTest, MidGraphemeSelectionBounds) {
const base::string16 kThai = WideToUTF16(L"\x0e08\x0e33");
const base::string16 cases[] = { kHindi, kThai };
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
for (size_t i = 0; i < arraysize(cases); i++) {
SCOPED_TRACE(base::StringPrintf("Testing cases[%" PRIuS "]", i));
- render_text->SetText(cases[i]);
- EXPECT_TRUE(render_text->IsValidLogicalIndex(1));
- EXPECT_FALSE(render_text->IsValidCursorIndex(1));
- EXPECT_TRUE(render_text->SelectRange(Range(2, 1)));
- EXPECT_EQ(Range(2, 1), render_text->selection());
- EXPECT_EQ(1U, render_text->cursor_position());
+ render_text_->SetText(cases[i]);
+ EXPECT_TRUE(render_text_->IsValidLogicalIndex(1));
+ EXPECT_FALSE(render_text_->IsValidCursorIndex(1));
+ EXPECT_TRUE(render_text_->SelectRange(Range(2, 1)));
+ EXPECT_EQ(Range(2, 1), render_text_->selection());
+ EXPECT_EQ(1U, render_text_->cursor_position());
// Although selection bounds may be set within a multi-character grapheme,
// cursor movement (e.g. via arrow key) should avoid those indices.
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(0U, render_text->cursor_position());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(2U, render_text->cursor_position());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(0U, render_text_->cursor_position());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(2U, render_text_->cursor_position());
}
}
-TEST_F(RenderTextTest, FindCursorPosition) {
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, FindCursorPosition) {
const wchar_t* kTestStrings[] = { kLtrRtl, kLtrRtlLtr, kRtlLtr, kRtlLtrRtl };
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetDisplayRect(Rect(0, 0, 100, 20));
+ render_text_->SetDisplayRect(Rect(0, 0, 100, 20));
for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
SCOPED_TRACE(base::StringPrintf("Testing case[%" PRIuS "]", i));
- render_text->SetText(WideToUTF16(kTestStrings[i]));
- for(size_t j = 0; j < render_text->text().length(); ++j) {
- const Range range(render_text->GetGlyphBounds(j));
+ render_text_->SetText(WideToUTF16(kTestStrings[i]));
+ for (size_t j = 0; j < render_text_->text().length(); ++j) {
+ const Range range(render_text_->GetGlyphBounds(j));
// Test a point just inside the leading edge of the glyph bounds.
int x = range.is_reversed() ? range.GetMax() - 1 : range.GetMin() + 1;
- EXPECT_EQ(j, render_text->FindCursorPosition(Point(x, 0)).caret_pos());
+ EXPECT_EQ(j, render_text_->FindCursorPosition(Point(x, 0)).caret_pos());
}
}
}
-#endif // !defined(OS_MACOSX)
-TEST_F(RenderTextTest, EdgeSelectionModels) {
+TEST_P(RenderTextTestAll, EdgeSelectionModels) {
// Simple Latin text.
const base::string16 kLatin = WideToUTF16(L"abc");
// LTR 2-character grapheme.
@@ -1600,28 +1617,26 @@ TEST_F(RenderTextTest, EdgeSelectionModels) {
return;
#endif
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
for (size_t i = 0; i < arraysize(cases); i++) {
- render_text->SetText(cases[i].text);
+ render_text_->SetText(cases[i].text);
bool ltr = (cases[i].expected_text_direction == base::i18n::LEFT_TO_RIGHT);
SelectionModel start_edge =
- render_text->EdgeSelectionModel(ltr ? CURSOR_LEFT : CURSOR_RIGHT);
+ render_text_->EdgeSelectionModel(ltr ? CURSOR_LEFT : CURSOR_RIGHT);
EXPECT_EQ(start_edge, SelectionModel(0, CURSOR_BACKWARD));
SelectionModel end_edge =
- render_text->EdgeSelectionModel(ltr ? CURSOR_RIGHT : CURSOR_LEFT);
+ render_text_->EdgeSelectionModel(ltr ? CURSOR_RIGHT : CURSOR_LEFT);
EXPECT_EQ(end_edge, SelectionModel(cases[i].text.length(), CURSOR_FORWARD));
}
}
-TEST_F(RenderTextTest, SelectAll) {
+TEST_P(RenderTextTestAll, SelectAll) {
const wchar_t* const cases[] =
{ kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl, kRtlLtr, kRtlLtrRtl };
// Ensure that SelectAll respects the |reversed| argument regardless of
// application locale and text content directionality.
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
const SelectionModel expected_reversed(Range(3, 0), CURSOR_FORWARD);
const SelectionModel expected_forwards(Range(0, 3), CURSOR_BACKWARD);
const bool was_rtl = base::i18n::IsRTL();
@@ -1629,16 +1644,16 @@ TEST_F(RenderTextTest, SelectAll) {
for (size_t i = 0; i < 2; ++i) {
SetRTL(!base::i18n::IsRTL());
// Test that an empty string produces an empty selection model.
- render_text->SetText(base::string16());
- EXPECT_EQ(render_text->selection_model(), SelectionModel());
+ render_text_->SetText(base::string16());
+ EXPECT_EQ(render_text_->selection_model(), SelectionModel());
// Test the weak, LTR, RTL, and Bidi string cases.
for (size_t j = 0; j < arraysize(cases); j++) {
- render_text->SetText(WideToUTF16(cases[j]));
- render_text->SelectAll(false);
- EXPECT_EQ(render_text->selection_model(), expected_forwards);
- render_text->SelectAll(true);
- EXPECT_EQ(render_text->selection_model(), expected_reversed);
+ render_text_->SetText(WideToUTF16(cases[j]));
+ render_text_->SelectAll(false);
+ EXPECT_EQ(render_text_->selection_model(), expected_forwards);
+ render_text_->SelectAll(true);
+ EXPECT_EQ(render_text_->selection_model(), expected_reversed);
}
}
@@ -1646,85 +1661,82 @@ TEST_F(RenderTextTest, SelectAll) {
}
// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
-#if !defined(OS_MACOSX)
-TEST_F(RenderTextTest, MoveCursorLeftRightWithSelection) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
+TEST_P(RenderTextHarfBuzzTest, MoveCursorLeftRightWithSelection) {
+ render_text_->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
// Left arrow on select ranging (6, 4).
- render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(Range(6), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(Range(4), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(Range(5), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(Range(6), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_RETAIN);
- EXPECT_EQ(Range(6, 5), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_RETAIN);
- EXPECT_EQ(Range(6, 4), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(Range(6), render_text->selection());
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(Range(6), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(Range(4), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(Range(5), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(Range(6), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_RETAIN);
+ EXPECT_EQ(Range(6, 5), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_RETAIN);
+ EXPECT_EQ(Range(6, 4), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(Range(6), render_text_->selection());
// Right arrow on select ranging (4, 6).
- render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(Range(0), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(Range(1), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(Range(2), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(Range(3), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(Range(5), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(Range(4), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_RETAIN);
- EXPECT_EQ(Range(4, 5), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_RETAIN);
- EXPECT_EQ(Range(4, 6), render_text->selection());
- render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(Range(4), render_text->selection());
-}
-#endif // !defined(OS_MACOSX)
-
-TEST_F(RenderTextTest, CenteredDisplayOffset) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(ASCIIToUTF16("abcdefghij"));
- render_text->SetHorizontalAlignment(ALIGN_CENTER);
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(Range(0), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(Range(1), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(Range(2), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(Range(3), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(Range(5), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(Range(4), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_RETAIN);
+ EXPECT_EQ(Range(4, 5), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_RETAIN);
+ EXPECT_EQ(Range(4, 6), render_text_->selection());
+ render_text_->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(Range(4), render_text_->selection());
+}
+
+TEST_P(RenderTextTestAll, CenteredDisplayOffset) {
+ render_text_->SetText(ASCIIToUTF16("abcdefghij"));
+ render_text_->SetHorizontalAlignment(ALIGN_CENTER);
const int kEnlargement = 10;
- const int content_width = render_text->GetContentWidth();
+ const int content_width = render_text_->GetContentWidth();
Rect display_rect(0, 0, content_width / 2,
- render_text->font_list().GetHeight());
- render_text->SetDisplayRect(display_rect);
+ render_text_->font_list().GetHeight());
+ render_text_->SetDisplayRect(display_rect);
// Move the cursor to the beginning of the text and, by checking the cursor
// bounds, make sure no empty space is to the left of the text.
- render_text->SetCursorPosition(0);
- EXPECT_EQ(display_rect.x(), render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetCursorPosition(0);
+ EXPECT_EQ(display_rect.x(), render_text_->GetUpdatedCursorBounds().x());
// Widen the display rect and, by checking the cursor bounds, make sure no
// empty space is introduced to the left of the text.
display_rect.Inset(0, 0, -kEnlargement, 0);
- render_text->SetDisplayRect(display_rect);
- EXPECT_EQ(display_rect.x(), render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetDisplayRect(display_rect);
+ EXPECT_EQ(display_rect.x(), render_text_->GetUpdatedCursorBounds().x());
-// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
-#if !defined(OS_MACOSX)
- // Move the cursor to the end of the text and, by checking the cursor bounds,
- // make sure no empty space is to the right of the text.
- render_text->SetCursorPosition(render_text->text().length());
- EXPECT_EQ(display_rect.right(),
- render_text->GetUpdatedCursorBounds().right());
+ // TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+ if (GetParam() != RENDER_TEXT_MAC) {
+ // Move the cursor to the end of the text and, by checking the cursor
+ // bounds,
+ // make sure no empty space is to the right of the text.
+ render_text_->SetCursorPosition(render_text_->text().length());
+ EXPECT_EQ(display_rect.right(),
+ render_text_->GetUpdatedCursorBounds().right());
- // Widen the display rect and, by checking the cursor bounds, make sure no
- // empty space is introduced to the right of the text.
- display_rect.Inset(0, 0, -kEnlargement, 0);
- render_text->SetDisplayRect(display_rect);
- EXPECT_EQ(display_rect.right(),
- render_text->GetUpdatedCursorBounds().right());
-#endif // !defined(OS_MACOSX)
+ // Widen the display rect and, by checking the cursor bounds, make sure no
+ // empty space is introduced to the right of the text.
+ display_rect.Inset(0, 0, -kEnlargement, 0);
+ render_text_->SetDisplayRect(display_rect);
+ EXPECT_EQ(display_rect.right(),
+ render_text_->GetUpdatedCursorBounds().right());
+ }
}
void MoveLeftRightByWordVerifier(RenderText* render_text,
@@ -1790,12 +1802,9 @@ void MoveLeftRightByWordVerifier(RenderText* render_text,
}
// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
-#if !defined(OS_MACOSX)
// TODO(msw): Make these work on Windows.
#if !defined(OS_WIN)
-TEST_F(RenderTextTest, MoveLeftRightByWordInBidiText) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
-
+TEST_P(RenderTextHarfBuzzTest, MoveLeftRightByWordInBidiText) {
// For testing simplicity, each word is a 3-character word.
std::vector<const wchar_t*> test;
test.push_back(L"abc");
@@ -1825,117 +1834,110 @@ TEST_F(RenderTextTest, MoveLeftRightByWordInBidiText) {
L" \x05E7\x05E8\x05E9");
for (size_t i = 0; i < test.size(); ++i)
- MoveLeftRightByWordVerifier(render_text.get(), test[i]);
+ MoveLeftRightByWordVerifier(render_text_.get(), test[i]);
}
-TEST_F(RenderTextTest, MoveLeftRightByWordInBidiText_TestEndOfText) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
-
- render_text->SetText(WideToUTF16(L"ab\x05E1"));
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, MoveLeftRightByWordInBidiText_TestEndOfText) {
+ render_text_->SetText(WideToUTF16(L"ab\x05E1"));
// Moving the cursor by word from "abC|" to the left should return "|abC".
// But since end of text is always treated as a word break, it returns
// position "ab|C".
// TODO(xji): Need to make it work as expected.
- render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
- // EXPECT_EQ(SelectionModel(), render_text->selection_model());
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ render_text_->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ // EXPECT_EQ(SelectionModel(), render_text_->selection_model());
// Moving the cursor by word from "|abC" to the right returns "abC|".
- render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
- render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(SelectionModel(3, CURSOR_FORWARD), render_text->selection_model());
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ render_text_->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(SelectionModel(3, CURSOR_FORWARD), render_text_->selection_model());
- render_text->SetText(WideToUTF16(L"\x05E1\x05E2" L"a"));
+ render_text_->SetText(
+ WideToUTF16(L"\x05E1\x05E2"
+ L"a"));
// For logical text "BCa", moving the cursor by word from "aCB|" to the left
// returns "|aCB".
- render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(SelectionModel(3, CURSOR_FORWARD), render_text->selection_model());
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ render_text_->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(SelectionModel(3, CURSOR_FORWARD), render_text_->selection_model());
// Moving the cursor by word from "|aCB" to the right should return "aCB|".
// But since end of text is always treated as a word break, it returns
// position "a|CB".
// TODO(xji): Need to make it work as expected.
- render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
- render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- // EXPECT_EQ(SelectionModel(), render_text->selection_model());
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ render_text_->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ // EXPECT_EQ(SelectionModel(), render_text_->selection_model());
}
-TEST_F(RenderTextTest, MoveLeftRightByWordInTextWithMultiSpaces) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(WideToUTF16(L"abc def"));
- render_text->MoveCursorTo(SelectionModel(5, CURSOR_FORWARD));
- render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(11U, render_text->cursor_position());
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, MoveLeftRightByWordInTextWithMultiSpaces) {
+ render_text_->SetText(WideToUTF16(L"abc def"));
+ render_text_->MoveCursorTo(SelectionModel(5, CURSOR_FORWARD));
+ render_text_->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(11U, render_text_->cursor_position());
- render_text->MoveCursorTo(SelectionModel(5, CURSOR_FORWARD));
- render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(0U, render_text->cursor_position());
+ render_text_->MoveCursorTo(SelectionModel(5, CURSOR_FORWARD));
+ render_text_->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(0U, render_text_->cursor_position());
}
#endif // !defined(OS_WIN)
-TEST_F(RenderTextTest, MoveLeftRightByWordInChineseText) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(WideToUTF16(L"\x6211\x4EEC\x53BB\x516C\x56ED\x73A9"));
- render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
- EXPECT_EQ(0U, render_text->cursor_position());
- render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(2U, render_text->cursor_position());
- render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(3U, render_text->cursor_position());
- render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(5U, render_text->cursor_position());
- render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(6U, render_text->cursor_position());
- render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
- EXPECT_EQ(6U, render_text->cursor_position());
-}
-#endif // !defined(OS_MACOSX)
-
-TEST_F(RenderTextTest, StringSizeSanity) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(UTF8ToUTF16("Hello World"));
- const Size string_size = render_text->GetStringSize();
+// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
+TEST_P(RenderTextHarfBuzzTest, MoveLeftRightByWordInChineseText) {
+ render_text_->SetText(WideToUTF16(L"\x6211\x4EEC\x53BB\x516C\x56ED\x73A9"));
+ render_text_->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+ EXPECT_EQ(0U, render_text_->cursor_position());
+ render_text_->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(2U, render_text_->cursor_position());
+ render_text_->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(3U, render_text_->cursor_position());
+ render_text_->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(5U, render_text_->cursor_position());
+ render_text_->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(6U, render_text_->cursor_position());
+ render_text_->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+ EXPECT_EQ(6U, render_text_->cursor_position());
+}
+
+TEST_P(RenderTextTestAll, StringSizeSanity) {
+ render_text_->SetText(UTF8ToUTF16("Hello World"));
+ const Size string_size = render_text_->GetStringSize();
EXPECT_GT(string_size.width(), 0);
EXPECT_GT(string_size.height(), 0);
}
-TEST_F(RenderTextTest, StringSizeLongStrings) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
+TEST_P(RenderTextTestAll, StringSizeLongStrings) {
Size previous_string_size;
for (size_t length = 10; length < 1000000; length *= 10) {
- render_text->SetText(base::string16(length, 'a'));
- const Size string_size = render_text->GetStringSize();
+ render_text_->SetText(base::string16(length, 'a'));
+ const Size string_size = render_text_->GetStringSize();
EXPECT_GT(string_size.width(), previous_string_size.width());
EXPECT_GT(string_size.height(), 0);
previous_string_size = string_size;
}
}
-// TODO(asvitkine): This test fails because PlatformFontMac uses point font
-// sizes instead of pixel sizes like other implementations.
-#if !defined(OS_MACOSX)
-TEST_F(RenderTextTest, StringSizeEmptyString) {
karandeepb 2016/08/24 03:36:27 This doesn't fail with RenderTextMac now.
+TEST_P(RenderTextTestAll, StringSizeEmptyString) {
// Ascent and descent of Arial and Symbol are different on most platforms.
const FontList font_list("Arial,Symbol, 16px");
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetFontList(font_list);
- render_text->SetDisplayRect(Rect(0, 0, 0, font_list.GetHeight()));
+ render_text_->SetFontList(font_list);
+ render_text_->SetDisplayRect(Rect(0, 0, 0, font_list.GetHeight()));
// The empty string respects FontList metrics for non-zero height
// and baseline.
- render_text->SetText(base::string16());
- EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
- EXPECT_EQ(0, render_text->GetStringSize().width());
- EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
+ render_text_->SetText(base::string16());
+ EXPECT_EQ(font_list.GetHeight(), render_text_->GetStringSize().height());
+ EXPECT_EQ(0, render_text_->GetStringSize().width());
+ EXPECT_EQ(font_list.GetBaseline(), render_text_->GetBaseline());
- render_text->SetText(UTF8ToUTF16(" "));
- EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
- EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
+ render_text_->SetText(UTF8ToUTF16(" "));
+ EXPECT_EQ(font_list.GetHeight(), render_text_->GetStringSize().height());
+ EXPECT_EQ(font_list.GetBaseline(), render_text_->GetBaseline());
}
-#endif // !defined(OS_MACOSX)
-TEST_F(RenderTextTest, StringSizeRespectsFontListMetrics) {
+TEST_P(RenderTextTestAll, StringSizeRespectsFontListMetrics) {
// Check that Arial and Symbol have different font metrics.
Font arial_font("Arial", 16);
ASSERT_EQ("arial",
@@ -1964,13 +1966,12 @@ TEST_F(RenderTextTest, StringSizeRespectsFontListMetrics) {
ASSERT_LT(smaller_font.GetBaseline(), larger_font.GetBaseline());
// Check |smaller_font_text| is rendered with the smaller font.
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(UTF8ToUTF16(smaller_font_text));
- render_text->SetFontList(FontList(smaller_font));
- render_text->SetDisplayRect(Rect(0, 0, 0,
- render_text->font_list().GetHeight()));
- EXPECT_EQ(smaller_font.GetHeight(), render_text->GetStringSize().height());
- EXPECT_EQ(smaller_font.GetBaseline(), render_text->GetBaseline());
+ render_text_->SetText(UTF8ToUTF16(smaller_font_text));
+ render_text_->SetFontList(FontList(smaller_font));
+ render_text_->SetDisplayRect(
+ Rect(0, 0, 0, render_text_->font_list().GetHeight()));
+ EXPECT_EQ(smaller_font.GetHeight(), render_text_->GetStringSize().height());
+ EXPECT_EQ(smaller_font.GetBaseline(), render_text_->GetBaseline());
// Layout the same text with mixed fonts. The text should be rendered with
// the smaller font, but the height and baseline are determined with the
@@ -1979,76 +1980,70 @@ TEST_F(RenderTextTest, StringSizeRespectsFontListMetrics) {
fonts.push_back(smaller_font); // The primary font is the smaller font.
fonts.push_back(larger_font);
const FontList font_list(fonts);
- render_text->SetFontList(font_list);
- render_text->SetDisplayRect(Rect(0, 0, 0,
- render_text->font_list().GetHeight()));
- EXPECT_LT(smaller_font.GetHeight(), render_text->GetStringSize().height());
- EXPECT_LT(smaller_font.GetBaseline(), render_text->GetBaseline());
- EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
- EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
-}
-
-TEST_F(RenderTextTest, MinLineHeight) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
-
- render_text->SetText(ASCIIToUTF16("Hello!"));
- SizeF default_size = render_text->GetStringSizeF();
+ render_text_->SetFontList(font_list);
+ render_text_->SetDisplayRect(
+ Rect(0, 0, 0, render_text_->font_list().GetHeight()));
+ EXPECT_LT(smaller_font.GetHeight(), render_text_->GetStringSize().height());
+ EXPECT_LT(smaller_font.GetBaseline(), render_text_->GetBaseline());
+ EXPECT_EQ(font_list.GetHeight(), render_text_->GetStringSize().height());
+ EXPECT_EQ(font_list.GetBaseline(), render_text_->GetBaseline());
+}
+
+TEST_P(RenderTextTestAll, MinLineHeight) {
+ render_text_->SetText(ASCIIToUTF16("Hello!"));
+ SizeF default_size = render_text_->GetStringSizeF();
ASSERT_NE(0, default_size.height());
ASSERT_NE(0, default_size.width());
- render_text->SetMinLineHeight(default_size.height() / 2);
- EXPECT_EQ(default_size.ToString(), render_text->GetStringSizeF().ToString());
+ render_text_->SetMinLineHeight(default_size.height() / 2);
+ EXPECT_EQ(default_size.ToString(), render_text_->GetStringSizeF().ToString());
- render_text->SetMinLineHeight(default_size.height() * 2);
- SizeF taller_size = render_text->GetStringSizeF();
+ render_text_->SetMinLineHeight(default_size.height() * 2);
+ SizeF taller_size = render_text_->GetStringSizeF();
EXPECT_EQ(default_size.height() * 2, taller_size.height());
EXPECT_EQ(default_size.width(), taller_size.width());
}
-TEST_F(RenderTextTest, SetFontList) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetFontList(FontList("Arial,Symbol, 13px"));
- const std::vector<Font>& fonts = render_text->font_list().GetFonts();
+TEST_P(RenderTextTestAll, SetFontList) {
+ render_text_->SetFontList(FontList("Arial,Symbol, 13px"));
+ const std::vector<Font>& fonts = render_text_->font_list().GetFonts();
ASSERT_EQ(2U, fonts.size());
EXPECT_EQ("Arial", fonts[0].GetFontName());
EXPECT_EQ("Symbol", fonts[1].GetFontName());
- EXPECT_EQ(13, render_text->font_list().GetFontSize());
+ EXPECT_EQ(13, render_text_->font_list().GetFontSize());
}
+// Todo check why parameterized tests fail if they have a MAYBE_ in their name?
// http://crbug/624513
-#if defined(OS_WIN)
-#define MAYBE_StringSizeBoldWidth DISABLED_StringSizeBoldWidth
-#else
-#define MAYBE_StringSizeBoldWidth StringSizeBoldWidth
-#endif
-TEST_F(RenderTextTest, MAYBE_StringSizeBoldWidth) {
+#if !defined(OS_WIN)
karandeepb 2016/08/24 03:36:28 It seems that the TEST_P macro doesn't work correc
+TEST_P(RenderTextTestAll, StringSizeBoldWidth) {
// TODO(mboc): Add some unittests for other weights (currently not
// implemented because of test system font configuration).
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(UTF8ToUTF16("Hello World"));
+ render_text_->SetText(UTF8ToUTF16("Hello World"));
- const int plain_width = render_text->GetStringSize().width();
+ const int plain_width = render_text_->GetStringSize().width();
EXPECT_GT(plain_width, 0);
// Apply a bold style and check that the new width is greater.
- render_text->SetWeight(Font::Weight::BOLD);
- const int bold_width = render_text->GetStringSize().width();
+ render_text_->SetWeight(Font::Weight::BOLD);
+ const int bold_width = render_text_->GetStringSize().width();
EXPECT_GT(bold_width, plain_width);
#if defined(OS_WIN)
- render_text->SetWeight(Font::Weight::SEMIBOLD);
- const int semibold_width = render_text->GetStringSize().width();
+ render_text_->SetWeight(Font::Weight::SEMIBOLD);
+ const int semibold_width = render_text_->GetStringSize().width();
EXPECT_GT(bold_width, semibold_width);
#endif
// Now, apply a plain style over the first word only.
- render_text->ApplyWeight(Font::Weight::NORMAL, Range(0, 5));
- const int plain_bold_width = render_text->GetStringSize().width();
+ render_text_->ApplyWeight(Font::Weight::NORMAL, Range(0, 5));
+ const int plain_bold_width = render_text_->GetStringSize().width();
EXPECT_GT(plain_bold_width, plain_width);
EXPECT_LT(plain_bold_width, bold_width);
}
+#endif
-TEST_F(RenderTextTest, StringSizeHeight) {
+TEST_P(RenderTextTestAll, StringSizeHeight) {
base::string16 cases[] = {
WideToUTF16(L"Hello World!"), // English
WideToUTF16(L"\x6328\x62f6"), // Japanese
@@ -2061,116 +2056,119 @@ TEST_F(RenderTextTest, StringSizeHeight) {
EXPECT_GT(larger_font_list.GetHeight(), default_font_list.GetHeight());
for (size_t i = 0; i < arraysize(cases); i++) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetFontList(default_font_list);
- render_text->SetText(cases[i]);
+ render_text_ = CreateRenderTextInstance();
+ render_text_->SetFontList(default_font_list);
+ render_text_->SetText(cases[i]);
- const int height1 = render_text->GetStringSize().height();
+ const int height1 = render_text_->GetStringSize().height();
EXPECT_GT(height1, 0);
// Check that setting the larger font increases the height.
- render_text->SetFontList(larger_font_list);
- const int height2 = render_text->GetStringSize().height();
+ render_text_->SetFontList(larger_font_list);
+ const int height2 = render_text_->GetStringSize().height();
EXPECT_GT(height2, height1);
}
}
-TEST_F(RenderTextTest, GetBaselineSanity) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(UTF8ToUTF16("Hello World"));
- const int baseline = render_text->GetBaseline();
+TEST_P(RenderTextTestAll, GetBaselineSanity) {
+ render_text_->SetText(UTF8ToUTF16("Hello World"));
+ const int baseline = render_text_->GetBaseline();
EXPECT_GT(baseline, 0);
}
-TEST_F(RenderTextTest, CursorBoundsInReplacementMode) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(ASCIIToUTF16("abcdefg"));
- render_text->SetDisplayRect(Rect(100, 17));
+TEST_P(RenderTextTestAll, CursorBoundsInReplacementMode) {
+ render_text_->SetText(ASCIIToUTF16("abcdefg"));
+ render_text_->SetDisplayRect(Rect(100, 17));
SelectionModel sel_b(1, CURSOR_FORWARD);
SelectionModel sel_c(2, CURSOR_FORWARD);
- Rect cursor_around_b = render_text->GetCursorBounds(sel_b, false);
- Rect cursor_before_b = render_text->GetCursorBounds(sel_b, true);
- Rect cursor_before_c = render_text->GetCursorBounds(sel_c, true);
+ Rect cursor_around_b = render_text_->GetCursorBounds(sel_b, false);
+ Rect cursor_before_b = render_text_->GetCursorBounds(sel_b, true);
+ Rect cursor_before_c = render_text_->GetCursorBounds(sel_c, true);
EXPECT_EQ(cursor_around_b.x(), cursor_before_b.x());
EXPECT_EQ(cursor_around_b.right(), cursor_before_c.x());
}
-TEST_F(RenderTextTest, GetTextOffset) {
+TEST_P(RenderTextTestAll, GetTextOffset) {
// The default horizontal text offset differs for LTR and RTL, and is only set
// when the RenderText object is created. This test will check the default in
// LTR mode, and the next test will check the RTL default.
const bool was_rtl = base::i18n::IsRTL();
SetRTL(false);
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(ASCIIToUTF16("abcdefg"));
- render_text->SetFontList(FontList("Arial, 13px"));
+
+ // Reset the render text instance since the locale was changed.
+ render_text_ = CreateRenderTextInstance();
+
+ render_text_->SetText(ASCIIToUTF16("abcdefg"));
+ render_text_->SetFontList(FontList("Arial, 13px"));
// Set display area's size equal to the font size.
- const Size font_size(render_text->GetContentWidth(),
- render_text->font_list().GetHeight());
+ const Size font_size(render_text_->GetContentWidth(),
+ render_text_->font_list().GetHeight());
Rect display_rect(font_size);
- render_text->SetDisplayRect(display_rect);
+ render_text_->SetDisplayRect(display_rect);
- Vector2d offset = render_text->GetLineOffset(0);
+ Vector2d offset = render_text_->GetLineOffset(0);
EXPECT_TRUE(offset.IsZero());
const int kEnlargementX = 2;
display_rect.Inset(0, 0, -kEnlargementX, 0);
- render_text->SetDisplayRect(display_rect);
+ render_text_->SetDisplayRect(display_rect);
// Check the default horizontal alignment.
- offset = render_text->GetLineOffset(0);
+ offset = render_text_->GetLineOffset(0);
EXPECT_EQ(0, offset.x());
// Check explicitly setting the horizontal alignment.
- render_text->SetHorizontalAlignment(ALIGN_LEFT);
- offset = render_text->GetLineOffset(0);
+ render_text_->SetHorizontalAlignment(ALIGN_LEFT);
+ offset = render_text_->GetLineOffset(0);
EXPECT_EQ(0, offset.x());
- render_text->SetHorizontalAlignment(ALIGN_CENTER);
- offset = render_text->GetLineOffset(0);
+ render_text_->SetHorizontalAlignment(ALIGN_CENTER);
+ offset = render_text_->GetLineOffset(0);
EXPECT_EQ(kEnlargementX / 2, offset.x());
- render_text->SetHorizontalAlignment(ALIGN_RIGHT);
- offset = render_text->GetLineOffset(0);
+ render_text_->SetHorizontalAlignment(ALIGN_RIGHT);
+ offset = render_text_->GetLineOffset(0);
EXPECT_EQ(kEnlargementX, offset.x());
// Check that text is vertically centered within taller display rects.
const int kEnlargementY = display_rect.height();
display_rect.Inset(0, 0, 0, -kEnlargementY);
- render_text->SetDisplayRect(display_rect);
- const Vector2d prev_offset = render_text->GetLineOffset(0);
+ render_text_->SetDisplayRect(display_rect);
+ const Vector2d prev_offset = render_text_->GetLineOffset(0);
display_rect.Inset(0, 0, 0, -2 * kEnlargementY);
- render_text->SetDisplayRect(display_rect);
- offset = render_text->GetLineOffset(0);
+ render_text_->SetDisplayRect(display_rect);
+ offset = render_text_->GetLineOffset(0);
EXPECT_EQ(prev_offset.y() + kEnlargementY, offset.y());
SetRTL(was_rtl);
}
-TEST_F(RenderTextTest, GetTextOffsetHorizontalDefaultInRTL) {
+TEST_P(RenderTextTestAll, GetTextOffsetHorizontalDefaultInRTL) {
// This only checks the default horizontal alignment in RTL mode; all other
// GetLineOffset(0) attributes are checked by the test above.
const bool was_rtl = base::i18n::IsRTL();
SetRTL(true);
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(ASCIIToUTF16("abcdefg"));
- render_text->SetFontList(FontList("Arial, 13px"));
+
+ // Reset the render text instance since the locale was changed.
+ render_text_ = CreateRenderTextInstance();
+
+ render_text_->SetText(ASCIIToUTF16("abcdefg"));
+ render_text_->SetFontList(FontList("Arial, 13px"));
const int kEnlargement = 2;
- const Size font_size(render_text->GetContentWidth() + kEnlargement,
- render_text->GetStringSize().height());
+ const Size font_size(render_text_->GetContentWidth() + kEnlargement,
+ render_text_->GetStringSize().height());
Rect display_rect(font_size);
- render_text->SetDisplayRect(display_rect);
- Vector2d offset = render_text->GetLineOffset(0);
+ render_text_->SetDisplayRect(display_rect);
+ Vector2d offset = render_text_->GetLineOffset(0);
EXPECT_EQ(kEnlargement, offset.x());
SetRTL(was_rtl);
}
-TEST_F(RenderTextTest, SetDisplayOffset) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(ASCIIToUTF16("abcdefg"));
- render_text->SetFontList(FontList("Arial, 13px"));
+TEST_P(RenderTextTestAll, SetDisplayOffset) {
+ render_text_->SetText(ASCIIToUTF16("abcdefg"));
+ render_text_->SetFontList(FontList("Arial, 13px"));
- const Size font_size(render_text->GetContentWidth(),
- render_text->font_list().GetHeight());
+ const Size font_size(render_text_->GetContentWidth(),
+ render_text_->font_list().GetHeight());
const int kEnlargement = 10;
// Set display width |kEnlargement| pixels greater than content width and test
@@ -2178,7 +2176,7 @@ TEST_F(RenderTextTest, SetDisplayOffset) {
// offset is zero.
Rect display_rect(font_size);
display_rect.Inset(0, 0, -kEnlargement, 0);
- render_text->SetDisplayRect(display_rect);
+ render_text_->SetDisplayRect(display_rect);
struct {
HorizontalAlignment alignment;
@@ -2196,16 +2194,16 @@ TEST_F(RenderTextTest, SetDisplayOffset) {
};
for (size_t i = 0; i < arraysize(small_content_cases); i++) {
- render_text->SetHorizontalAlignment(small_content_cases[i].alignment);
- render_text->SetDisplayOffset(small_content_cases[i].offset);
- EXPECT_EQ(0, render_text->GetUpdatedDisplayOffset().x());
+ render_text_->SetHorizontalAlignment(small_content_cases[i].alignment);
+ render_text_->SetDisplayOffset(small_content_cases[i].offset);
+ EXPECT_EQ(0, render_text_->GetUpdatedDisplayOffset().x());
}
// Set display width |kEnlargement| pixels less than content width and test
// different possible situations.
display_rect = Rect(font_size);
display_rect.Inset(0, 0, kEnlargement, 0);
- render_text->SetDisplayRect(display_rect);
+ render_text_->SetDisplayRect(display_rect);
struct {
HorizontalAlignment alignment;
@@ -2231,14 +2229,14 @@ TEST_F(RenderTextTest, SetDisplayOffset) {
};
for (size_t i = 0; i < arraysize(large_content_cases); i++) {
- render_text->SetHorizontalAlignment(large_content_cases[i].alignment);
- render_text->SetDisplayOffset(large_content_cases[i].offset);
+ render_text_->SetHorizontalAlignment(large_content_cases[i].alignment);
+ render_text_->SetDisplayOffset(large_content_cases[i].offset);
EXPECT_EQ(large_content_cases[i].expected_offset,
- render_text->GetUpdatedDisplayOffset().x());
+ render_text_->GetUpdatedDisplayOffset().x());
}
}
-TEST_F(RenderTextTest, SameFontForParentheses) {
+TEST_P(RenderTextTestAll, SameFontForParentheses) {
struct {
const base::char16 left_char;
const base::char16 right_char;
@@ -2277,7 +2275,6 @@ TEST_F(RenderTextTest, SameFontForParentheses) {
{ WideToUTF16(L"Hello World(\x05e0\x05b8)Hello World") },
};
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
for (size_t i = 0; i < arraysize(cases); ++i) {
base::string16 text = cases[i].text;
const size_t start_paren_char_index = text.find('(');
@@ -2288,10 +2285,10 @@ TEST_F(RenderTextTest, SameFontForParentheses) {
for (size_t j = 0; j < arraysize(punctuation_pairs); ++j) {
text[start_paren_char_index] = punctuation_pairs[j].left_char;
text[end_paren_char_index] = punctuation_pairs[j].right_char;
- render_text->SetText(text);
+ render_text_->SetText(text);
const std::vector<RenderText::FontSpan> spans =
- render_text->GetFontSpansForTesting();
+ render_text_->GetFontSpansForTesting();
int start_paren_span_index = -1;
int end_paren_span_index = -1;
@@ -2315,15 +2312,13 @@ TEST_F(RenderTextTest, SameFontForParentheses) {
// Make sure the caret width is always >=1 so that the correct
// caret is drawn at high DPI. crbug.com/164100.
-TEST_F(RenderTextTest, CaretWidth) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(ASCIIToUTF16("abcdefg"));
- EXPECT_GE(render_text->GetUpdatedCursorBounds().width(), 1);
+TEST_P(RenderTextTestAll, CaretWidth) {
+ render_text_->SetText(ASCIIToUTF16("abcdefg"));
+ EXPECT_GE(render_text_->GetUpdatedCursorBounds().width(), 1);
}
-TEST_F(RenderTextTest, SelectWord) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(ASCIIToUTF16(" foo a.bc.d bar"));
+TEST_P(RenderTextTestAll, SelectWord) {
+ render_text_->SetText(ASCIIToUTF16(" foo a.bc.d bar"));
struct {
size_t cursor;
@@ -2350,165 +2345,161 @@ TEST_F(RenderTextTest, SelectWord) {
};
for (size_t i = 0; i < arraysize(cases); ++i) {
- render_text->SetCursorPosition(cases[i].cursor);
- render_text->SelectWord();
+ render_text_->SetCursorPosition(cases[i].cursor);
+ render_text_->SelectWord();
EXPECT_EQ(Range(cases[i].selection_start, cases[i].selection_end),
- render_text->selection());
+ render_text_->selection());
}
}
// Make sure the last word is selected when the cursor is at text.length().
-TEST_F(RenderTextTest, LastWordSelected) {
+TEST_P(RenderTextTestAll, LastWordSelected) {
const std::string kTestURL1 = "http://www.google.com";
const std::string kTestURL2 = "http://www.google.com/something/";
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
-
- render_text->SetText(ASCIIToUTF16(kTestURL1));
- render_text->SetCursorPosition(kTestURL1.length());
- render_text->SelectWord();
- EXPECT_EQ(ASCIIToUTF16("com"), GetSelectedText(render_text.get()));
- EXPECT_FALSE(render_text->selection().is_reversed());
+ render_text_->SetText(ASCIIToUTF16(kTestURL1));
+ render_text_->SetCursorPosition(kTestURL1.length());
+ render_text_->SelectWord();
+ EXPECT_EQ(ASCIIToUTF16("com"), GetSelectedText(render_text_.get()));
+ EXPECT_FALSE(render_text_->selection().is_reversed());
- render_text->SetText(ASCIIToUTF16(kTestURL2));
- render_text->SetCursorPosition(kTestURL2.length());
- render_text->SelectWord();
- EXPECT_EQ(ASCIIToUTF16("/"), GetSelectedText(render_text.get()));
- EXPECT_FALSE(render_text->selection().is_reversed());
+ render_text_->SetText(ASCIIToUTF16(kTestURL2));
+ render_text_->SetCursorPosition(kTestURL2.length());
+ render_text_->SelectWord();
+ EXPECT_EQ(ASCIIToUTF16("/"), GetSelectedText(render_text_.get()));
+ EXPECT_FALSE(render_text_->selection().is_reversed());
}
// When given a non-empty selection, SelectWord should expand the selection to
// nearest word boundaries.
-TEST_F(RenderTextTest, SelectMultipleWords) {
+TEST_P(RenderTextTestAll, SelectMultipleWords) {
const std::string kTestURL = "http://www.google.com";
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
-
- render_text->SetText(ASCIIToUTF16(kTestURL));
- render_text->SelectRange(Range(16, 20));
- render_text->SelectWord();
- EXPECT_EQ(ASCIIToUTF16("google.com"), GetSelectedText(render_text.get()));
- EXPECT_FALSE(render_text->selection().is_reversed());
+ render_text_->SetText(ASCIIToUTF16(kTestURL));
+ render_text_->SelectRange(Range(16, 20));
+ render_text_->SelectWord();
+ EXPECT_EQ(ASCIIToUTF16("google.com"), GetSelectedText(render_text_.get()));
+ EXPECT_FALSE(render_text_->selection().is_reversed());
// SelectWord should preserve the selection direction.
- render_text->SelectRange(Range(20, 16));
- render_text->SelectWord();
- EXPECT_EQ(ASCIIToUTF16("google.com"), GetSelectedText(render_text.get()));
- EXPECT_TRUE(render_text->selection().is_reversed());
+ render_text_->SelectRange(Range(20, 16));
+ render_text_->SelectWord();
+ EXPECT_EQ(ASCIIToUTF16("google.com"), GetSelectedText(render_text_.get()));
+ EXPECT_TRUE(render_text_->selection().is_reversed());
}
// TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
-#if !defined(OS_MACOSX)
-TEST_F(RenderTextTest, DisplayRectShowsCursorLTR) {
+TEST_P(RenderTextHarfBuzzTest, DisplayRectShowsCursorLTR) {
ASSERT_FALSE(base::i18n::IsRTL());
ASSERT_FALSE(base::i18n::ICUIsRTL());
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(WideToUTF16(L"abcdefghijklmnopqrstuvwxzyabcdefg"));
- render_text->MoveCursorTo(SelectionModel(render_text->text().length(),
- CURSOR_FORWARD));
- int width = render_text->GetStringSize().width();
+ render_text_->SetText(WideToUTF16(L"abcdefghijklmnopqrstuvwxzyabcdefg"));
+ render_text_->MoveCursorTo(
+ SelectionModel(render_text_->text().length(), CURSOR_FORWARD));
+ int width = render_text_->GetStringSize().width();
ASSERT_GT(width, 10);
// Ensure that the cursor is placed at the width of its preceding text.
- render_text->SetDisplayRect(Rect(width + 10, 1));
- EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetDisplayRect(Rect(width + 10, 1));
+ EXPECT_EQ(width, render_text_->GetUpdatedCursorBounds().x());
// Ensure that shrinking the display rectangle keeps the cursor in view.
- render_text->SetDisplayRect(Rect(width - 10, 1));
- EXPECT_EQ(render_text->display_rect().width(),
- render_text->GetUpdatedCursorBounds().right());
+ render_text_->SetDisplayRect(Rect(width - 10, 1));
+ EXPECT_EQ(render_text_->display_rect().width(),
+ render_text_->GetUpdatedCursorBounds().right());
// Ensure that the text will pan to fill its expanding display rectangle.
- render_text->SetDisplayRect(Rect(width - 5, 1));
- EXPECT_EQ(render_text->display_rect().width(),
- render_text->GetUpdatedCursorBounds().right());
+ render_text_->SetDisplayRect(Rect(width - 5, 1));
+ EXPECT_EQ(render_text_->display_rect().width(),
+ render_text_->GetUpdatedCursorBounds().right());
// Ensure that a sufficiently large display rectangle shows all the text.
- render_text->SetDisplayRect(Rect(width + 10, 1));
- EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetDisplayRect(Rect(width + 10, 1));
+ EXPECT_EQ(width, render_text_->GetUpdatedCursorBounds().x());
// Repeat the test with RTL text.
- render_text->SetText(WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3\x5d4\x5d5\x5d6\x5d7"
- L"\x5d8\x5d9\x5da\x5db\x5dc\x5dd\x5de\x5df"));
- render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
- width = render_text->GetStringSize().width();
+ render_text_->SetText(
+ WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3\x5d4\x5d5\x5d6\x5d7"
+ L"\x5d8\x5d9\x5da\x5db\x5dc\x5dd\x5de\x5df"));
+ render_text_->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
+ width = render_text_->GetStringSize().width();
ASSERT_GT(width, 10);
// Ensure that the cursor is placed at the width of its preceding text.
- render_text->SetDisplayRect(Rect(width + 10, 1));
- EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetDisplayRect(Rect(width + 10, 1));
+ EXPECT_EQ(width, render_text_->GetUpdatedCursorBounds().x());
// Ensure that shrinking the display rectangle keeps the cursor in view.
- render_text->SetDisplayRect(Rect(width - 10, 1));
- EXPECT_EQ(render_text->display_rect().width(),
- render_text->GetUpdatedCursorBounds().right());
+ render_text_->SetDisplayRect(Rect(width - 10, 1));
+ EXPECT_EQ(render_text_->display_rect().width(),
+ render_text_->GetUpdatedCursorBounds().right());
// Ensure that the text will pan to fill its expanding display rectangle.
- render_text->SetDisplayRect(Rect(width - 5, 1));
- EXPECT_EQ(render_text->display_rect().width(),
- render_text->GetUpdatedCursorBounds().right());
+ render_text_->SetDisplayRect(Rect(width - 5, 1));
+ EXPECT_EQ(render_text_->display_rect().width(),
+ render_text_->GetUpdatedCursorBounds().right());
// Ensure that a sufficiently large display rectangle shows all the text.
- render_text->SetDisplayRect(Rect(width + 10, 1));
- EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetDisplayRect(Rect(width + 10, 1));
+ EXPECT_EQ(width, render_text_->GetUpdatedCursorBounds().x());
}
-#endif // !defined(OS_MACOSX)
-TEST_F(RenderTextTest, DisplayRectShowsCursorRTL) {
+TEST_P(RenderTextTestAll, DisplayRectShowsCursorRTL) {
// Set the application default text direction to RTL.
const bool was_rtl = base::i18n::IsRTL();
SetRTL(true);
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetText(WideToUTF16(L"abcdefghijklmnopqrstuvwxzyabcdefg"));
- render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
- int width = render_text->GetStringSize().width();
+ // Reset the render text instance since the locale was changed.
+ render_text_ = CreateRenderTextInstance();
+ render_text_->SetText(WideToUTF16(L"abcdefghijklmnopqrstuvwxzyabcdefg"));
+ render_text_->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
+ int width = render_text_->GetStringSize().width();
ASSERT_GT(width, 10);
// Ensure that the cursor is placed at the width of its preceding text.
- render_text->SetDisplayRect(Rect(width + 10, 1));
- EXPECT_EQ(render_text->display_rect().width() - width - 1,
- render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetDisplayRect(Rect(width + 10, 1));
+ EXPECT_EQ(render_text_->display_rect().width() - width - 1,
+ render_text_->GetUpdatedCursorBounds().x());
// Ensure that shrinking the display rectangle keeps the cursor in view.
- render_text->SetDisplayRect(Rect(width - 10, 1));
- EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetDisplayRect(Rect(width - 10, 1));
+ EXPECT_EQ(0, render_text_->GetUpdatedCursorBounds().x());
// Ensure that the text will pan to fill its expanding display rectangle.
- render_text->SetDisplayRect(Rect(width - 5, 1));
- EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetDisplayRect(Rect(width - 5, 1));
+ EXPECT_EQ(0, render_text_->GetUpdatedCursorBounds().x());
// Ensure that a sufficiently large display rectangle shows all the text.
- render_text->SetDisplayRect(Rect(width + 10, 1));
- EXPECT_EQ(render_text->display_rect().width() - width - 1,
- render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetDisplayRect(Rect(width + 10, 1));
+ EXPECT_EQ(render_text_->display_rect().width() - width - 1,
+ render_text_->GetUpdatedCursorBounds().x());
// Repeat the test with RTL text.
- render_text->SetText(WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3\x5d4\x5d5\x5d6\x5d7"
- L"\x5d8\x5d9\x5da\x5db\x5dc\x5dd\x5de\x5df"));
- render_text->MoveCursorTo(SelectionModel(render_text->text().length(),
- CURSOR_FORWARD));
- width = render_text->GetStringSize().width();
+ render_text_->SetText(
+ WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3\x5d4\x5d5\x5d6\x5d7"
+ L"\x5d8\x5d9\x5da\x5db\x5dc\x5dd\x5de\x5df"));
+ render_text_->MoveCursorTo(
+ SelectionModel(render_text_->text().length(), CURSOR_FORWARD));
+ width = render_text_->GetStringSize().width();
ASSERT_GT(width, 10);
// Ensure that the cursor is placed at the width of its preceding text.
- render_text->SetDisplayRect(Rect(width + 10, 1));
- EXPECT_EQ(render_text->display_rect().width() - width - 1,
- render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetDisplayRect(Rect(width + 10, 1));
+ EXPECT_EQ(render_text_->display_rect().width() - width - 1,
+ render_text_->GetUpdatedCursorBounds().x());
// Ensure that shrinking the display rectangle keeps the cursor in view.
- render_text->SetDisplayRect(Rect(width - 10, 1));
- EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetDisplayRect(Rect(width - 10, 1));
+ EXPECT_EQ(0, render_text_->GetUpdatedCursorBounds().x());
// Ensure that the text will pan to fill its expanding display rectangle.
- render_text->SetDisplayRect(Rect(width - 5, 1));
- EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetDisplayRect(Rect(width - 5, 1));
+ EXPECT_EQ(0, render_text_->GetUpdatedCursorBounds().x());
// Ensure that a sufficiently large display rectangle shows all the text.
- render_text->SetDisplayRect(Rect(width + 10, 1));
- EXPECT_EQ(render_text->display_rect().width() - width - 1,
- render_text->GetUpdatedCursorBounds().x());
+ render_text_->SetDisplayRect(Rect(width + 10, 1));
+ EXPECT_EQ(render_text_->display_rect().width() - width - 1,
+ render_text_->GetUpdatedCursorBounds().x());
// Reset the application default text direction to LTR.
SetRTL(was_rtl);
@@ -2516,44 +2507,40 @@ TEST_F(RenderTextTest, DisplayRectShowsCursorRTL) {
}
// Changing colors between or inside ligated glyphs should not break shaping.
-TEST_F(RenderTextTest, SelectionKeepsLigatures) {
+TEST_P(RenderTextTestAll, SelectionKeepsLigatures) {
const wchar_t* kTestStrings[] = { L"\x644\x623", L"\x633\x627" };
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->set_selection_color(SK_ColorRED);
- Canvas canvas;
+ render_text_->set_selection_color(SK_ColorRED);
for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
- render_text->SetText(WideToUTF16(kTestStrings[i]));
- const int expected_width = render_text->GetStringSize().width();
- render_text->MoveCursorTo(SelectionModel(Range(0, 1), CURSOR_FORWARD));
- EXPECT_EQ(expected_width, render_text->GetStringSize().width());
+ render_text_->SetText(WideToUTF16(kTestStrings[i]));
+ const int expected_width = render_text_->GetStringSize().width();
+ render_text_->MoveCursorTo(SelectionModel(Range(0, 1), CURSOR_FORWARD));
+ EXPECT_EQ(expected_width, render_text_->GetStringSize().width());
// Drawing the text should not DCHECK or crash; see http://crbug.com/262119
- render_text->Draw(&canvas);
- render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
+ render_text_->Draw(&canvas_);
+ render_text_->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
}
}
// Ensure strings wrap onto multiple lines for a small available width.
-TEST_F(RenderTextTest, Multiline_MinWidth) {
+TEST_P(RenderTextHarfBuzzTest, Multiline_MinWidth) {
const wchar_t* kTestStrings[] = { kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl,
kRtlLtr, kRtlLtrRtl };
- RenderTextHarfBuzz render_text;
- render_text.SetDisplayRect(Rect(1, 1000));
- render_text.SetMultiline(true);
- render_text.SetWordWrapBehavior(WRAP_LONG_WORDS);
- Canvas canvas;
+ render_text_->SetDisplayRect(Rect(1, 1000));
+ render_text_->SetMultiline(true);
+ render_text_->SetWordWrapBehavior(WRAP_LONG_WORDS);
for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
- render_text.SetText(WideToUTF16(kTestStrings[i]));
- render_text.Draw(&canvas);
- EXPECT_GT(render_text.lines_.size(), 1U);
+ render_text_->SetText(WideToUTF16(kTestStrings[i]));
+ render_text_->Draw(&canvas_);
+ EXPECT_GT(render_text_->lines_.size(), 1U);
}
}
// Ensure strings wrap onto multiple lines for a normal available width.
-TEST_F(RenderTextTest, Multiline_NormalWidth) {
+TEST_P(RenderTextHarfBuzzTest, Multiline_NormalWidth) {
const struct {
const wchar_t* const text;
const Range first_line_char_range;
@@ -2569,34 +2556,31 @@ TEST_F(RenderTextTest, Multiline_NormalWidth) {
L"\x05DA\x05DB\x05DD", Range(0, 5), Range(5, 13), false }
};
- RenderTextHarfBuzz render_text;
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
// Specify the fixed width for characters to suppress the possible variations
// of linebreak results.
- render_text.set_glyph_width_for_test(5);
- render_text.SetDisplayRect(Rect(50, 1000));
- render_text.SetMultiline(true);
- render_text.SetWordWrapBehavior(WRAP_LONG_WORDS);
- render_text.SetHorizontalAlignment(ALIGN_TO_HEAD);
-
- Canvas canvas;
- TestSkiaTextRenderer renderer(&canvas);
+ render_text->set_glyph_width_for_test(5);
+ render_text->SetDisplayRect(Rect(50, 1000));
+ render_text->SetMultiline(true);
+ render_text->SetWordWrapBehavior(WRAP_LONG_WORDS);
+ render_text->SetHorizontalAlignment(ALIGN_TO_HEAD);
for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
- render_text.SetText(WideToUTF16(kTestStrings[i].text));
- render_text.EnsureLayout();
- render_text.DrawVisualText(&renderer);
+ render_text->SetText(WideToUTF16(kTestStrings[i].text));
+ DrawVisualText();
- ASSERT_EQ(2U, render_text.lines_.size());
- ASSERT_EQ(1U, render_text.lines_[0].segments.size());
+ ASSERT_EQ(2U, render_text->lines_.size());
+ ASSERT_EQ(1U, render_text->lines_[0].segments.size());
EXPECT_EQ(kTestStrings[i].first_line_char_range,
- render_text.lines_[0].segments[0].char_range);
- ASSERT_EQ(1U, render_text.lines_[1].segments.size());
+ render_text->lines_[0].segments[0].char_range);
+ ASSERT_EQ(1U, render_text->lines_[1].segments.size());
EXPECT_EQ(kTestStrings[i].second_line_char_range,
- render_text.lines_[1].segments[0].char_range);
+ render_text->lines_[1].segments[0].char_range);
std::vector<TestSkiaTextRenderer::TextLog> text_log;
- renderer.GetTextLogAndReset(&text_log);
+ renderer_.GetTextLogAndReset(&text_log);
ASSERT_EQ(2U, text_log.size());
// NOTE: this expectation compares the character length and glyph counts,
// which isn't always equal. This is okay only because all the test
@@ -2619,24 +2603,22 @@ TEST_F(RenderTextTest, Multiline_NormalWidth) {
// Ensure strings don't wrap onto multiple lines for a sufficient available
// width.
-TEST_F(RenderTextTest, Multiline_SufficientWidth) {
+TEST_P(RenderTextHarfBuzzTest, Multiline_SufficientWidth) {
const wchar_t* kTestStrings[] = { L"", L" ", L".", L" . ", L"abc", L"a b c",
L"\x62E\x628\x632", L"\x62E \x628 \x632" };
- RenderTextHarfBuzz render_text;
- render_text.SetDisplayRect(Rect(1000, 1000));
- render_text.SetMultiline(true);
- Canvas canvas;
+ render_text_->SetDisplayRect(Rect(1000, 1000));
+ render_text_->SetMultiline(true);
for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
- render_text.SetText(WideToUTF16(kTestStrings[i]));
- render_text.Draw(&canvas);
- EXPECT_EQ(1U, render_text.lines_.size());
+ render_text_->SetText(WideToUTF16(kTestStrings[i]));
+ render_text_->Draw(&canvas_);
+ EXPECT_EQ(1U, render_text_->lines_.size());
}
}
-TEST_F(RenderTextTest, Multiline_Newline) {
+TEST_P(RenderTextHarfBuzzTest, Multiline_Newline) {
const struct {
const wchar_t* const text;
const size_t lines_count;
@@ -2651,77 +2633,76 @@ TEST_F(RenderTextTest, Multiline_Newline) {
{L"\n", 2ul, { Range(), Range(), Range::InvalidRange() } },
};
- RenderTextHarfBuzz render_text;
- render_text.SetDisplayRect(Rect(200, 1000));
- render_text.SetMultiline(true);
- Canvas canvas;
+ render_text_->SetDisplayRect(Rect(200, 1000));
+ render_text_->SetMultiline(true);
for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
- render_text.SetText(WideToUTF16(kTestStrings[i].text));
- render_text.Draw(&canvas);
- EXPECT_EQ(kTestStrings[i].lines_count, render_text.lines_.size());
- if (kTestStrings[i].lines_count != render_text.lines_.size())
+ render_text_->SetText(WideToUTF16(kTestStrings[i].text));
+ render_text_->Draw(&canvas_);
+ EXPECT_EQ(kTestStrings[i].lines_count, render_text_->lines_.size());
+ if (kTestStrings[i].lines_count != render_text_->lines_.size())
continue;
for (size_t j = 0; j < kTestStrings[i].lines_count; ++j) {
SCOPED_TRACE(base::StringPrintf("Line %" PRIuS "", j));
// There might be multiple segments in one line. Merge all the segments
// ranges in the same line.
- const size_t segment_size = render_text.lines()[j].segments.size();
+ const size_t segment_size = render_text_->lines()[j].segments.size();
Range line_range;
if (segment_size > 0)
- line_range = Range(
- render_text.lines()[j].segments[0].char_range.start(),
- render_text.lines()[j].segments[segment_size - 1].char_range.end());
+ line_range =
+ Range(render_text_->lines()[j].segments[0].char_range.start(),
+ render_text_->lines()[j]
+ .segments[segment_size - 1]
+ .char_range.end());
EXPECT_EQ(kTestStrings[i].line_char_ranges[j], line_range);
}
}
}
// Make sure that multiline mode ignores elide behavior.
-TEST_F(RenderTextTest, Multiline_IgnoreElide) {
+TEST_P(RenderTextHarfBuzzTest, Multiline_IgnoreElide) {
const wchar_t kTestString[] =
L"very very very long string xxxxxxxxxxxxxxxxxxxxxxxxxx";
const wchar_t kEllipsis[] = L"\x2026";
- RenderTextHarfBuzz render_text;
- render_text.SetElideBehavior(ELIDE_TAIL);
- render_text.SetDisplayRect(Rect(20, 1000));
- render_text.SetText(base::WideToUTF16(kTestString));
+ render_text_->SetElideBehavior(ELIDE_TAIL);
+ render_text_->SetDisplayRect(Rect(20, 1000));
+ render_text_->SetText(base::WideToUTF16(kTestString));
EXPECT_NE(base::string16::npos,
- render_text.GetDisplayText().find(base::WideToUTF16(kEllipsis)));
+ render_text_->GetDisplayText().find(base::WideToUTF16(kEllipsis)));
- render_text.SetMultiline(true);
+ render_text_->SetMultiline(true);
EXPECT_EQ(base::string16::npos,
- render_text.GetDisplayText().find(base::WideToUTF16(kEllipsis)));
+ render_text_->GetDisplayText().find(base::WideToUTF16(kEllipsis)));
}
-TEST_F(RenderTextTest, Multiline_NewlineCharacterReplacement) {
+TEST_P(RenderTextHarfBuzzTest, Multiline_NewlineCharacterReplacement) {
const wchar_t* kTestStrings[] = {
L"abc\ndef", L"a \n b ", L"ab\n", L"a\n\nb", L"\nab", L"\n",
};
for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
- RenderTextHarfBuzz render_text;
- render_text.SetDisplayRect(Rect(200, 1000));
- render_text.SetText(WideToUTF16(kTestStrings[i]));
+ render_text_ = CreateRenderTextInstance();
+ render_text_->SetDisplayRect(Rect(200, 1000));
+ render_text_->SetText(WideToUTF16(kTestStrings[i]));
- base::string16 display_text = render_text.GetDisplayText();
+ base::string16 display_text = render_text_->GetDisplayText();
// If RenderText is not multiline, the newline characters are replaced
// by symbols, therefore the character should be changed.
- EXPECT_NE(WideToUTF16(kTestStrings[i]), render_text.GetDisplayText());
+ EXPECT_NE(WideToUTF16(kTestStrings[i]), render_text_->GetDisplayText());
// Setting multiline will fix this, the newline characters will be back
// to the original text.
- render_text.SetMultiline(true);
- EXPECT_EQ(WideToUTF16(kTestStrings[i]), render_text.GetDisplayText());
+ render_text_->SetMultiline(true);
+ EXPECT_EQ(WideToUTF16(kTestStrings[i]), render_text_->GetDisplayText());
}
}
// Ensure horizontal alignment works in multiline mode.
-TEST_F(RenderTextTest, Multiline_HorizontalAlignment) {
+TEST_P(RenderTextHarfBuzzTest, Multiline_HorizontalAlignment) {
const struct {
const wchar_t* const text;
const HorizontalAlignment alignment;
@@ -2742,35 +2723,35 @@ TEST_F(RenderTextTest, Multiline_HorizontalAlignment) {
ALIGN_RIGHT },
};
const int kGlyphSize = 5;
- RenderTextHarfBuzz render_text;
- render_text.SetHorizontalAlignment(ALIGN_TO_HEAD);
- render_text.set_glyph_width_for_test(kGlyphSize);
- render_text.SetDisplayRect(Rect(100, 1000));
- render_text.SetMultiline(true);
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
+ render_text->SetHorizontalAlignment(ALIGN_TO_HEAD);
+ render_text->set_glyph_width_for_test(kGlyphSize);
+ render_text->SetDisplayRect(Rect(100, 1000));
+ render_text->SetMultiline(true);
- Canvas canvas;
for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "] %ls", i,
kTestStrings[i].text));
- render_text.SetText(WideToUTF16(kTestStrings[i].text));
- render_text.Draw(&canvas);
- ASSERT_LE(2u, render_text.lines().size());
+ render_text->SetText(WideToUTF16(kTestStrings[i].text));
+ render_text->Draw(&canvas_);
+ ASSERT_LE(2u, render_text->lines().size());
if (kTestStrings[i].alignment == ALIGN_LEFT) {
- EXPECT_EQ(0, render_text.GetAlignmentOffset(0).x());
- EXPECT_EQ(0, render_text.GetAlignmentOffset(1).x());
+ EXPECT_EQ(0, render_text->GetAlignmentOffset(0).x());
+ EXPECT_EQ(0, render_text->GetAlignmentOffset(1).x());
} else {
std::vector<base::string16> lines = base::SplitString(
base::WideToUTF16(kTestStrings[i].text),
base::string16(1, '\n'), base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
ASSERT_EQ(2u, lines.size());
int difference = (lines[0].length() - lines[1].length()) * kGlyphSize;
- EXPECT_EQ(render_text.GetAlignmentOffset(0).x() + difference,
- render_text.GetAlignmentOffset(1).x());
+ EXPECT_EQ(render_text->GetAlignmentOffset(0).x() + difference,
+ render_text->GetAlignmentOffset(1).x());
}
}
}
-TEST_F(RenderTextTest, Multiline_WordWrapBehavior) {
+TEST_P(RenderTextHarfBuzzTest, Multiline_WordWrapBehavior) {
const int kGlyphSize = 5;
const struct {
const WordWrapBehavior behavior;
@@ -2785,32 +2766,31 @@ TEST_F(RenderTextTest, Multiline_WordWrapBehavior) {
{ Range(0, 4), Range(4, 8), Range(8, 11), Range(11, 14) } },
// TODO(mukai): implement ELIDE_LONG_WORDS. It's not used right now.
};
- RenderTextHarfBuzz render_text;
- render_text.SetMultiline(true);
- render_text.SetText(ASCIIToUTF16("foo fooooo foo"));
- render_text.set_glyph_width_for_test(kGlyphSize);
- render_text.SetDisplayRect(Rect(0, 0, kGlyphSize * 4, 0));
-
- Canvas canvas;
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
+ render_text->SetMultiline(true);
+ render_text->SetText(ASCIIToUTF16("foo fooooo foo"));
+ render_text->set_glyph_width_for_test(kGlyphSize);
+ render_text->SetDisplayRect(Rect(0, 0, kGlyphSize * 4, 0));
for (size_t i = 0; i < arraysize(kTestScenarios); ++i) {
SCOPED_TRACE(base::StringPrintf(
"kTestScenarios[%" PRIuS "] %d", i, kTestScenarios[i].behavior));
- render_text.SetWordWrapBehavior(kTestScenarios[i].behavior);
- render_text.Draw(&canvas);
+ render_text->SetWordWrapBehavior(kTestScenarios[i].behavior);
+ render_text->Draw(&canvas_);
- ASSERT_EQ(kTestScenarios[i].num_lines, render_text.lines().size());
- for (size_t j = 0; j < render_text.lines().size(); ++j) {
+ ASSERT_EQ(kTestScenarios[i].num_lines, render_text->lines().size());
+ for (size_t j = 0; j < render_text->lines().size(); ++j) {
SCOPED_TRACE(base::StringPrintf("%" PRIuS "-th line", j));
EXPECT_EQ(kTestScenarios[i].char_ranges[j],
- render_text.lines()[j].segments[0].char_range);
+ render_text->lines()[j].segments[0].char_range);
EXPECT_EQ(kTestScenarios[i].char_ranges[j].length() * kGlyphSize,
- render_text.lines()[j].size.width());
+ render_text->lines()[j].size.width());
}
}
}
-TEST_F(RenderTextTest, Multiline_LineBreakerBehavior) {
+TEST_P(RenderTextHarfBuzzTest, Multiline_LineBreakerBehavior) {
const int kGlyphSize = 5;
const struct {
const wchar_t* const text;
@@ -2845,56 +2825,58 @@ TEST_F(RenderTextTest, Multiline_LineBreakerBehavior) {
{Range(0, 4), Range(4, 7), Range(7, 11) } },
};
- RenderTextHarfBuzz render_text;
- render_text.SetMultiline(true);
- render_text.set_glyph_width_for_test(kGlyphSize);
- render_text.SetDisplayRect(Rect(0, 0, kGlyphSize * 4, 0));
-
- Canvas canvas;
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
+ render_text->SetMultiline(true);
+ render_text->set_glyph_width_for_test(kGlyphSize);
+ render_text->SetDisplayRect(Rect(0, 0, kGlyphSize * 4, 0));
for (size_t i = 0; i < arraysize(kTestScenarios); ++i) {
SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
- render_text.SetText(WideToUTF16(kTestScenarios[i].text));
- render_text.SetWordWrapBehavior(kTestScenarios[i].behavior);
- render_text.Draw(&canvas);
+ render_text->SetText(WideToUTF16(kTestScenarios[i].text));
+ render_text->SetWordWrapBehavior(kTestScenarios[i].behavior);
+ render_text->Draw(&canvas_);
- ASSERT_EQ(3u, render_text.lines().size());
- for (size_t j = 0; j < render_text.lines().size(); ++j) {
+ ASSERT_EQ(3u, render_text->lines().size());
+ for (size_t j = 0; j < render_text->lines().size(); ++j) {
SCOPED_TRACE(base::StringPrintf("%" PRIuS "-th line", j));
// Merge all the segments ranges in the same line.
- size_t segment_size = render_text.lines()[j].segments.size();
+ size_t segment_size = render_text->lines()[j].segments.size();
Range line_range;
if (segment_size > 0)
- line_range = Range(
- render_text.lines()[j].segments[0].char_range.start(),
- render_text.lines()[j].segments[segment_size - 1].char_range.end());
+ line_range =
+ Range(render_text->lines()[j].segments[0].char_range.start(),
+ render_text->lines()[j]
+ .segments[segment_size - 1]
+ .char_range.end());
EXPECT_EQ(kTestScenarios[i].char_ranges[j], line_range);
EXPECT_EQ(kTestScenarios[i].char_ranges[j].length() * kGlyphSize,
- render_text.lines()[j].size.width());
+ render_text->lines()[j].size.width());
}
}
}
// Test that Surrogate pairs or combining character sequences do not get
// separated by line breaking.
-TEST_F(RenderTextTest, Multiline_SurrogatePairsOrCombiningChars) {
- RenderTextHarfBuzz render_text;
- render_text.SetMultiline(true);
- render_text.SetWordWrapBehavior(WRAP_LONG_WORDS);
+TEST_P(RenderTextHarfBuzzTest, Multiline_SurrogatePairsOrCombiningChars) {
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
+ render_text->SetMultiline(true);
+ render_text->SetWordWrapBehavior(WRAP_LONG_WORDS);
// Below is 'MUSICAL SYMBOL G CLEF' (U+1D11E), which is represented in UTF-16
// as two code units forming a surrogate pair: 0xD834 0xDD1E.
const base::char16 kSurrogate[] = {0xD834, 0xDD1E, 0};
const base::string16 text_surrogate(kSurrogate);
const int kSurrogateWidth =
- GetStringWidth(kSurrogate, render_text.font_list());
+ GetStringWidth(kSurrogate, render_text->font_list());
// Below is a Devanagari two-character combining sequence U+0921 U+093F. The
// sequence forms a single display character and should not be separated.
const base::char16 kCombiningChars[] = {0x921, 0x93F, 0};
const base::string16 text_combining(kCombiningChars);
const int kCombiningCharsWidth =
- GetStringWidth(kCombiningChars, render_text.font_list());
+ GetStringWidth(kCombiningChars, render_text->font_list());
const struct {
const base::string16 text;
@@ -2909,76 +2891,73 @@ TEST_F(RenderTextTest, Multiline_SurrogatePairsOrCombiningChars) {
{ Range(0, 2), Range(2, 3), Range(3, 5) } },
};
- Canvas canvas;
for (size_t i = 0; i < arraysize(kTestScenarios); ++i) {
SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
- render_text.SetText(kTestScenarios[i].text);
- render_text.SetDisplayRect(Rect(0, 0, kTestScenarios[i].display_width, 0));
- render_text.Draw(&canvas);
+ render_text->SetText(kTestScenarios[i].text);
+ render_text->SetDisplayRect(Rect(0, 0, kTestScenarios[i].display_width, 0));
+ render_text->Draw(&canvas_);
- ASSERT_EQ(3u, render_text.lines().size());
- for (size_t j = 0; j < render_text.lines().size(); ++j) {
+ ASSERT_EQ(3u, render_text->lines().size());
+ for (size_t j = 0; j < render_text->lines().size(); ++j) {
SCOPED_TRACE(base::StringPrintf("%" PRIuS "-th line", j));
// There is only one segment in each line.
EXPECT_EQ(kTestScenarios[i].char_ranges[j],
- render_text.lines()[j].segments[0].char_range);
+ render_text->lines()[j].segments[0].char_range);
}
}
}
// Test that Zero width characters have the correct line breaking behavior.
-TEST_F(RenderTextTest, Multiline_ZeroWidthChars) {
- RenderTextHarfBuzz render_text;
- render_text.SetMultiline(true);
- render_text.SetWordWrapBehavior(WRAP_LONG_WORDS);
+TEST_P(RenderTextHarfBuzzTest, Multiline_ZeroWidthChars) {
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
+ render_text->SetMultiline(true);
+ render_text->SetWordWrapBehavior(WRAP_LONG_WORDS);
const base::char16 kZeroWidthSpace = {0x200B};
const base::string16 text(UTF8ToUTF16("test") + kZeroWidthSpace +
UTF8ToUTF16("\n") + kZeroWidthSpace +
UTF8ToUTF16("test."));
const int kTestWidth =
- GetStringWidth(UTF8ToUTF16("test"), render_text.font_list());
+ GetStringWidth(UTF8ToUTF16("test"), render_text->font_list());
const Range char_ranges[3] = {Range(0, 5), Range(6, 11), Range(11, 12)};
- Canvas canvas;
- render_text.SetText(text);
- render_text.SetDisplayRect(Rect(0, 0, kTestWidth, 0));
- render_text.Draw(&canvas);
+ render_text->SetText(text);
+ render_text->SetDisplayRect(Rect(0, 0, kTestWidth, 0));
+ render_text->Draw(&canvas_);
- ASSERT_EQ(3u, render_text.lines().size());
- for (size_t j = 0; j < render_text.lines().size(); ++j) {
+ ASSERT_EQ(3u, render_text->lines().size());
+ for (size_t j = 0; j < render_text->lines().size(); ++j) {
SCOPED_TRACE(base::StringPrintf("%" PRIuS "-th line", j));
- int segment_size = render_text.lines()[j].segments.size();
+ int segment_size = render_text->lines()[j].segments.size();
ASSERT_GT(segment_size, 0);
Range line_range(
- render_text.lines()[j].segments[0].char_range.start(),
- render_text.lines()[j].segments[segment_size - 1].char_range.end());
+ render_text->lines()[j].segments[0].char_range.start(),
+ render_text->lines()[j].segments[segment_size - 1].char_range.end());
EXPECT_EQ(char_ranges[j], line_range);
}
}
-TEST_F(RenderTextTest, NewlineWithoutMultilineFlag) {
+TEST_P(RenderTextHarfBuzzTest, NewlineWithoutMultilineFlag) {
const wchar_t* kTestStrings[] = {
L"abc\ndef", L"a \n b ", L"ab\n", L"a\n\nb", L"\nab", L"\n",
};
- RenderTextHarfBuzz render_text;
- render_text.SetDisplayRect(Rect(200, 1000));
- Canvas canvas;
+ render_text_->SetDisplayRect(Rect(200, 1000));
for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
- render_text.SetText(WideToUTF16(kTestStrings[i]));
- render_text.Draw(&canvas);
+ render_text_->SetText(WideToUTF16(kTestStrings[i]));
+ render_text_->Draw(&canvas_);
- EXPECT_EQ(1U, render_text.lines_.size());
+ EXPECT_EQ(1U, render_text_->lines_.size());
}
}
// Make sure the horizontal positions of runs in a line (left-to-right for
// LTR languages and right-to-left for RTL languages).
-TEST_F(RenderTextTest, HarfBuzz_HorizontalPositions) {
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_HorizontalPositions) {
const struct {
const wchar_t* const text;
const Range first_run_char_range;
@@ -2991,16 +2970,15 @@ TEST_F(RenderTextTest, HarfBuzz_HorizontalPositions) {
Range(0, 4), Range(4, 12), true },
};
- RenderTextHarfBuzz render_text;
- Canvas canvas;
- TestSkiaTextRenderer renderer(&canvas);
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
- render_text.SetText(WideToUTF16(kTestStrings[i].text));
+ render_text->SetText(WideToUTF16(kTestStrings[i].text));
- render_text.EnsureLayout();
- const internal::TextRunList* run_list = render_text.GetRunList();
+ render_text->EnsureLayout();
+ const internal::TextRunList* run_list = render_text->GetRunList();
ASSERT_EQ(2U, run_list->runs().size());
EXPECT_EQ(kTestStrings[i].first_run_char_range, run_list->runs()[0]->range);
EXPECT_EQ(kTestStrings[i].second_run_char_range,
@@ -3014,10 +2992,10 @@ TEST_F(RenderTextTest, HarfBuzz_HorizontalPositions) {
EXPECT_EQ(1U, run_list->logical_to_visual(1));
}
- render_text.DrawVisualText(&renderer);
+ render_text->DrawVisualText(&renderer_);
std::vector<TestSkiaTextRenderer::TextLog> text_log;
- renderer.GetTextLogAndReset(&text_log);
+ renderer_.GetTextLogAndReset(&text_log);
EXPECT_EQ(2U, text_log.size());
@@ -3032,7 +3010,7 @@ TEST_F(RenderTextTest, HarfBuzz_HorizontalPositions) {
}
// Test TextRunHarfBuzz's cluster finding logic.
-TEST_F(RenderTextTest, HarfBuzz_Clusters) {
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_Clusters) {
struct {
uint32_t glyph_to_char[4];
Range chars[4];
@@ -3088,7 +3066,7 @@ TEST_F(RenderTextTest, HarfBuzz_Clusters) {
}
// Ensure that graphemes with multiple code points do not get split.
-TEST_F(RenderTextTest, HarfBuzz_SubglyphGraphemeCases) {
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_SubglyphGraphemeCases) {
const wchar_t* cases[] = {
// "A" with a combining umlaut, followed by a "B".
L"A\x0308" L"B",
@@ -3099,19 +3077,20 @@ TEST_F(RenderTextTest, HarfBuzz_SubglyphGraphemeCases) {
L"\x0e08\x0e33\x0E50",
};
- RenderTextHarfBuzz render_text;
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
for (size_t i = 0; i < arraysize(cases); ++i) {
SCOPED_TRACE(base::StringPrintf("Case %" PRIuS, i));
base::string16 text = WideToUTF16(cases[i]);
- render_text.SetText(text);
- render_text.EnsureLayout();
- internal::TextRunList* run_list = render_text.GetRunList();
+ render_text->SetText(text);
+ render_text->EnsureLayout();
+ internal::TextRunList* run_list = render_text->GetRunList();
ASSERT_EQ(1U, run_list->size());
internal::TextRunHarfBuzz* run = run_list->runs()[0];
- base::i18n::BreakIterator* iter = render_text.grapheme_iterator_.get();
+ base::i18n::BreakIterator* iter = render_text->grapheme_iterator_.get();
auto first_grapheme_bounds = run->GetGraphemeBounds(iter, 0);
EXPECT_EQ(first_grapheme_bounds, run->GetGraphemeBounds(iter, 1));
auto second_grapheme_bounds = run->GetGraphemeBounds(iter, 2);
@@ -3120,7 +3099,7 @@ TEST_F(RenderTextTest, HarfBuzz_SubglyphGraphemeCases) {
}
// Test the partition of a multi-grapheme cluster into grapheme ranges.
-TEST_F(RenderTextTest, HarfBuzz_SubglyphGraphemePartition) {
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_SubglyphGraphemePartition) {
struct {
uint32_t glyph_to_char[2];
Range bounds[4];
@@ -3175,19 +3154,20 @@ TEST_F(RenderTextTest, HarfBuzz_SubglyphGraphemePartition) {
}
}
-TEST_F(RenderTextTest, HarfBuzz_RunDirection) {
- RenderTextHarfBuzz render_text;
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_RunDirection) {
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
const base::string16 mixed = WideToUTF16(
L"\x05D0\x05D1"
L"1234"
L"\x05D2\x05D3"
L"abc");
- render_text.SetText(mixed);
+ render_text->SetText(mixed);
// Get the run list for both display directions.
- render_text.SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
- render_text.EnsureLayout();
- internal::TextRunList* run_list = render_text.GetRunList();
+ render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
+ render_text->EnsureLayout();
+ internal::TextRunList* run_list = render_text->GetRunList();
ASSERT_EQ(4U, run_list->size());
EXPECT_TRUE(run_list->runs()[0]->is_rtl);
EXPECT_FALSE(run_list->runs()[1]->is_rtl);
@@ -3200,9 +3180,9 @@ TEST_F(RenderTextTest, HarfBuzz_RunDirection) {
EXPECT_EQ(0U, run_list->logical_to_visual(2));
EXPECT_EQ(3U, run_list->logical_to_visual(3));
- render_text.SetDirectionalityMode(DIRECTIONALITY_FORCE_RTL);
- render_text.EnsureLayout();
- run_list = render_text.GetRunList();
+ render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_RTL);
+ render_text->EnsureLayout();
+ run_list = render_text->GetRunList();
ASSERT_EQ(4U, run_list->size());
EXPECT_TRUE(run_list->runs()[0]->is_rtl);
EXPECT_FALSE(run_list->runs()[1]->is_rtl);
@@ -3216,21 +3196,22 @@ TEST_F(RenderTextTest, HarfBuzz_RunDirection) {
EXPECT_EQ(0U, run_list->logical_to_visual(3));
}
-TEST_F(RenderTextTest, HarfBuzz_BreakRunsByUnicodeBlocks) {
- RenderTextHarfBuzz render_text;
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_BreakRunsByUnicodeBlocks) {
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
// The '\x25B6' "play character" should break runs. http://crbug.com/278913
- render_text.SetText(WideToUTF16(L"x\x25B6y"));
- render_text.EnsureLayout();
- internal::TextRunList* run_list = render_text.GetRunList();
+ render_text->SetText(WideToUTF16(L"x\x25B6y"));
+ render_text->EnsureLayout();
+ internal::TextRunList* run_list = render_text->GetRunList();
ASSERT_EQ(3U, run_list->size());
EXPECT_EQ(Range(0, 1), run_list->runs()[0]->range);
EXPECT_EQ(Range(1, 2), run_list->runs()[1]->range);
EXPECT_EQ(Range(2, 3), run_list->runs()[2]->range);
- render_text.SetText(WideToUTF16(L"x \x25B6 y"));
- render_text.EnsureLayout();
- run_list = render_text.GetRunList();
+ render_text->SetText(WideToUTF16(L"x \x25B6 y"));
+ render_text->EnsureLayout();
+ run_list = render_text->GetRunList();
ASSERT_EQ(4U, run_list->size());
EXPECT_EQ(Range(0, 2), run_list->runs()[0]->range);
EXPECT_EQ(Range(2, 3), run_list->runs()[1]->range);
@@ -3238,15 +3219,16 @@ TEST_F(RenderTextTest, HarfBuzz_BreakRunsByUnicodeBlocks) {
EXPECT_EQ(Range(4, 5), run_list->runs()[3]->range);
}
-TEST_F(RenderTextTest, HarfBuzz_BreakRunsByEmoji) {
- RenderTextHarfBuzz render_text;
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_BreakRunsByEmoji) {
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
// \xF0\x9F\x98\x81 (U+1F601) is smile icon emoji. \xE2\x9C\xA8 (U+2728) is
// a sparkle icon. Both can be drawn with color emoji fonts, so runs should be
// separated. See crbug.com/448909
- render_text.SetText(UTF8ToUTF16("x\xF0\x9F\x98\x81y\xE2\x9C\xA8"));
- render_text.EnsureLayout();
- internal::TextRunList* run_list = render_text.GetRunList();
+ render_text->SetText(UTF8ToUTF16("x\xF0\x9F\x98\x81y\xE2\x9C\xA8"));
+ render_text->EnsureLayout();
+ internal::TextRunList* run_list = render_text->GetRunList();
ASSERT_EQ(4U, run_list->size());
EXPECT_EQ(Range(0, 1), run_list->runs()[0]->range);
// The length is 2 since U+1F601 is represented as a surrogate pair in UTF16.
@@ -3255,50 +3237,51 @@ TEST_F(RenderTextTest, HarfBuzz_BreakRunsByEmoji) {
EXPECT_EQ(Range(4, 5), run_list->runs()[3]->range);
}
-TEST_F(RenderTextTest, HarfBuzz_BreakRunsByAscii) {
- RenderTextHarfBuzz render_text;
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_BreakRunsByAscii) {
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
// \xF0\x9F\x90\xB1 (U+1F431) is a cat face. It should be put into a separate
// run from the ASCII period character.
- render_text.SetText(UTF8ToUTF16("\xF0\x9F\x90\xB1."));
- render_text.EnsureLayout();
- internal::TextRunList* run_list = render_text.GetRunList();
+ render_text->SetText(UTF8ToUTF16("\xF0\x9F\x90\xB1."));
+ render_text->EnsureLayout();
+ internal::TextRunList* run_list = render_text->GetRunList();
ASSERT_EQ(2U, run_list->size());
// U+1F431 is represented as a surrogate pair in UTF16.
EXPECT_EQ(Range(0, 2), run_list->runs()[0]->range);
EXPECT_EQ(Range(2, 3), run_list->runs()[1]->range);
}
-TEST_F(RenderTextTest, GlyphBounds) {
+TEST_P(RenderTextHarfBuzzTest, GlyphBounds) {
const wchar_t* kTestStrings[] = {
L"asdf 1234 qwer", L"\x0647\x0654", L"\x0645\x0631\x062D\x0628\x0627"
};
- std::unique_ptr<RenderText> render_text(new RenderTextHarfBuzz);
for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
- render_text->SetText(WideToUTF16(kTestStrings[i]));
- render_text->EnsureLayout();
+ render_text_->SetText(WideToUTF16(kTestStrings[i]));
+ render_text_->EnsureLayout();
- for (size_t j = 0; j < render_text->text().length(); ++j)
- EXPECT_FALSE(render_text->GetGlyphBounds(j).is_empty());
+ for (size_t j = 0; j < render_text_->text().length(); ++j)
+ EXPECT_FALSE(render_text_->GetGlyphBounds(j).is_empty());
}
}
// Ensure that shaping with a non-existent font does not cause a crash.
-TEST_F(RenderTextTest, HarfBuzz_NonExistentFont) {
- RenderTextHarfBuzz render_text;
- render_text.SetText(ASCIIToUTF16("test"));
- render_text.EnsureLayout();
- internal::TextRunList* run_list = render_text.GetRunList();
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_NonExistentFont) {
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
+ render_text->SetText(ASCIIToUTF16("test"));
+ render_text->EnsureLayout();
+ internal::TextRunList* run_list = render_text->GetRunList();
ASSERT_EQ(1U, run_list->size());
internal::TextRunHarfBuzz* run = run_list->runs()[0];
- render_text.ShapeRunWithFont(render_text.text(),
- Font("TheFontThatDoesntExist", 13),
- FontRenderParams(), run);
+ render_text->ShapeRunWithFont(render_text->text(),
+ Font("TheFontThatDoesntExist", 13),
+ FontRenderParams(), run);
}
// Ensure an empty run returns sane values to queries.
-TEST_F(RenderTextTest, HarfBuzz_EmptyRun) {
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_EmptyRun) {
internal::TextRunHarfBuzz run((Font()));
const base::string16 kString = ASCIIToUTF16("abcdefgh");
std::unique_ptr<base::i18n::BreakIterator> iter(new base::i18n::BreakIterator(
@@ -3318,41 +3301,42 @@ TEST_F(RenderTextTest, HarfBuzz_EmptyRun) {
// Ensure the line breaker doesn't compute the word's width bigger than the
// actual size. See http://crbug.com/470073
-TEST_F(RenderTextTest, HarfBuzz_WordWidthWithDiacritics) {
- RenderTextHarfBuzz render_text;
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_WordWidthWithDiacritics) {
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
const base::string16 kWord = WideToUTF16(L"\u0906\u092A\u0915\u0947 ");
- render_text.SetText(kWord);
- const SizeF text_size = render_text.GetStringSizeF();
+ render_text->SetText(kWord);
+ const SizeF text_size = render_text->GetStringSizeF();
- render_text.SetText(kWord + kWord);
- render_text.SetMultiline(true);
- EXPECT_EQ(text_size.width() * 2, render_text.GetStringSizeF().width());
- EXPECT_EQ(text_size.height(), render_text.GetStringSizeF().height());
- render_text.SetDisplayRect(Rect(0, 0, std::ceil(text_size.width()), 0));
- EXPECT_NEAR(text_size.width(), render_text.GetStringSizeF().width(), 1.0f);
- EXPECT_EQ(text_size.height() * 2, render_text.GetStringSizeF().height());
+ render_text->SetText(kWord + kWord);
+ render_text->SetMultiline(true);
+ EXPECT_EQ(text_size.width() * 2, render_text->GetStringSizeF().width());
+ EXPECT_EQ(text_size.height(), render_text->GetStringSizeF().height());
+ render_text->SetDisplayRect(Rect(0, 0, std::ceil(text_size.width()), 0));
+ EXPECT_NEAR(text_size.width(), render_text->GetStringSizeF().width(), 1.0f);
+ EXPECT_EQ(text_size.height() * 2, render_text->GetStringSizeF().height());
}
// Ensure a string fits in a display rect with a width equal to the string's.
-TEST_F(RenderTextTest, StringFitsOwnWidth) {
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
+TEST_P(RenderTextTestAll, StringFitsOwnWidth) {
const base::string16 kString = ASCIIToUTF16("www.example.com");
- render_text->SetText(kString);
- render_text->ApplyWeight(Font::Weight::BOLD, Range(0, 3));
- render_text->SetElideBehavior(ELIDE_TAIL);
+ render_text_->SetText(kString);
+ render_text_->ApplyWeight(Font::Weight::BOLD, Range(0, 3));
+ render_text_->SetElideBehavior(ELIDE_TAIL);
- render_text->SetDisplayRect(Rect(0, 0, 500, 100));
- EXPECT_EQ(kString, render_text->GetDisplayText());
- render_text->SetDisplayRect(Rect(0, 0, render_text->GetContentWidth(), 100));
- EXPECT_EQ(kString, render_text->GetDisplayText());
+ render_text_->SetDisplayRect(Rect(0, 0, 500, 100));
+ EXPECT_EQ(kString, render_text_->GetDisplayText());
+ render_text_->SetDisplayRect(
+ Rect(0, 0, render_text_->GetContentWidth(), 100));
+ EXPECT_EQ(kString, render_text_->GetDisplayText());
}
// TODO(derat): Figure out why this fails on Windows: http://crbug.com/427184
#if !defined(OS_WIN)
// Ensure that RenderText examines all of the fonts in its FontList before
// falling back to other fonts.
-TEST_F(RenderTextTest, HarfBuzz_FontListFallback) {
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_FontListFallback) {
// Double-check that the requested fonts are present.
FontList font_list("Arial, Symbol, 12px");
const std::vector<Font>& fonts = font_list.GetFonts();
@@ -3364,11 +3348,12 @@ TEST_F(RenderTextTest, HarfBuzz_FontListFallback) {
// "⊕" (CIRCLED PLUS) should be rendered with Symbol rather than falling back
// to some other font that's present on the system.
- RenderTextHarfBuzz render_text;
- render_text.SetFontList(font_list);
- render_text.SetText(UTF8ToUTF16("\xE2\x8A\x95"));
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
+ render_text->SetFontList(font_list);
+ render_text->SetText(UTF8ToUTF16("\xE2\x8A\x95"));
const std::vector<RenderText::FontSpan> spans =
- render_text.GetFontSpansForTesting();
+ render_text->GetFontSpansForTesting();
ASSERT_EQ(static_cast<size_t>(1), spans.size());
EXPECT_EQ("Symbol", spans[0].first.GetFontName());
}
@@ -3376,19 +3361,20 @@ TEST_F(RenderTextTest, HarfBuzz_FontListFallback) {
// Ensure that the fallback fonts of the Uniscribe font are tried for shaping.
#if defined(OS_WIN)
-TEST_F(RenderTextTest, HarfBuzz_UniscribeFallback) {
- RenderTextHarfBuzz render_text;
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_UniscribeFallback) {
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
PlatformFontWin* font_win = new PlatformFontWin("Meiryo", 12);
// Japanese name for Meiryo. This name won't be found in the system's linked
// fonts, forcing RTHB to try the Uniscribe font and its fallbacks.
font_win->font_ref_->font_name_ = WideToUTF8(L"\x30e1\x30a4\x30ea\x30aa");
FontList font_list((Font(font_win)));
- render_text.SetFontList(font_list);
+ render_text->SetFontList(font_list);
// Korean character "han".
- render_text.SetText(WideToUTF16(L"\xd55c"));
- render_text.EnsureLayout();
- internal::TextRunList* run_list = render_text.GetRunList();
+ render_text->SetText(WideToUTF16(L"\xd55c"));
+ render_text->EnsureLayout();
+ internal::TextRunList* run_list = render_text->GetRunList();
ASSERT_EQ(1U, run_list->size());
EXPECT_EQ(0U, run_list->runs()[0]->CountMissingGlyphs());
}
@@ -3400,28 +3386,31 @@ TEST_F(RenderTextTest, HarfBuzz_UniscribeFallback) {
// font which does.
// TODO(msw): Fallback doesn't find a glyph on Linux.
#if !defined(OS_LINUX)
-TEST_F(RenderTextTest, HarfBuzz_UnicodeFallback) {
- RenderTextHarfBuzz render_text;
- render_text.SetFontList(FontList("Arial, 12px"));
+TEST_P(RenderTextHarfBuzzTest, HarfBuzz_UnicodeFallback) {
+ RenderTextHarfBuzz* render_text =
+ static_cast<RenderTextHarfBuzz*>(render_text_.get());
+ render_text->SetFontList(FontList("Arial, 12px"));
// Korean character "han".
- render_text.SetText(WideToUTF16(L"\xd55c"));
- render_text.EnsureLayout();
- internal::TextRunList* run_list = render_text.GetRunList();
+ render_text->SetText(WideToUTF16(L"\xd55c"));
+ render_text->EnsureLayout();
+ internal::TextRunList* run_list = render_text->GetRunList();
ASSERT_EQ(1U, run_list->size());
EXPECT_EQ(0U, run_list->runs()[0]->CountMissingGlyphs());
}
#endif // !defined(OS_LINUX)
// http://crbug/624513
-#if defined(OS_WIN)
-#define MAYBE_TextDoesntClip DISABLED_TextDoesntClip
-#else
-#define MAYBE_TextDoesntClip TextDoesntClip
-#endif
+#if !defined(OS_WIN)
// Ensure that the width reported by RenderText is sufficient for drawing. Draws
// to a canvas and checks if any pixel beyond the bounding rectangle is colored.
-TEST_F(RenderTextTest, MAYBE_TextDoesntClip) {
+TEST_P(RenderTextTestAll, TextDoesntClip) {
+// Fails on Mac with RenderTextHarfBuzz. See http://crbug.com/640068.
+#if defined(OS_MACOSX)
+ if (GetParam() == RENDER_TEXT_HARFBUZZ)
+ return;
+#endif
+
const wchar_t* kTestStrings[] = {
L" ",
// TODO(dschuyler): Underscores draw outside GetStringSize;
@@ -3441,26 +3430,25 @@ TEST_F(RenderTextTest, MAYBE_TextDoesntClip) {
sk_sp<SkSurface> surface =
SkSurface::MakeRasterN32Premul(kCanvasSize.width(), kCanvasSize.height());
Canvas canvas(sk_ref_sp(surface->getCanvas()), 1.0f);
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetHorizontalAlignment(ALIGN_LEFT);
- render_text->SetColor(SK_ColorBLACK);
+ render_text_->SetHorizontalAlignment(ALIGN_LEFT);
+ render_text_->SetColor(SK_ColorBLACK);
for (auto* string : kTestStrings) {
surface->getCanvas()->clear(SK_ColorWHITE);
- render_text->SetText(WideToUTF16(string));
- const Size string_size = render_text->GetStringSize();
- render_text->ApplyBaselineStyle(SUPERSCRIPT, Range(1, 2));
- render_text->ApplyBaselineStyle(SUPERIOR, Range(3, 4));
- render_text->ApplyBaselineStyle(INFERIOR, Range(5, 6));
- render_text->ApplyBaselineStyle(SUBSCRIPT, Range(7, 8));
- render_text->SetWeight(Font::Weight::BOLD);
- render_text->SetDisplayRect(
+ render_text_->SetText(WideToUTF16(string));
+ const Size string_size = render_text_->GetStringSize();
+ render_text_->ApplyBaselineStyle(SUPERSCRIPT, Range(1, 2));
+ render_text_->ApplyBaselineStyle(SUPERIOR, Range(3, 4));
+ render_text_->ApplyBaselineStyle(INFERIOR, Range(5, 6));
+ render_text_->ApplyBaselineStyle(SUBSCRIPT, Range(7, 8));
+ render_text_->SetWeight(Font::Weight::BOLD);
+ render_text_->SetDisplayRect(
Rect(kTestSize, kTestSize, string_size.width(), string_size.height()));
// Allow the RenderText to paint outside of its display rect.
- render_text->set_clip_to_display_rect(false);
+ render_text_->set_clip_to_display_rect(false);
ASSERT_LE(string_size.width() + kTestSize * 2, kCanvasSize.width());
- render_text->Draw(&canvas);
+ render_text_->Draw(&canvas);
ASSERT_LT(string_size.width() + kTestSize, kCanvasSize.width());
SkPixmap pixmap;
surface->peekPixels(&pixmap);
@@ -3522,10 +3510,11 @@ TEST_F(RenderTextTest, MAYBE_TextDoesntClip) {
}
}
}
+#endif // OS_WINDOWS
// Ensure that the text will clip to the display rect. Draws to a canvas and
// checks whether any pixel beyond the bounding rectangle is colored.
-TEST_F(RenderTextTest, TextDoesClip) {
+TEST_P(RenderTextTestAll, TextDoesClip) {
const wchar_t* kTestStrings[] = {L"TEST", L"W", L"WWWW", L"gAXAXWWWW"};
const Size kCanvasSize(300, 50);
const int kTestSize = 10;
@@ -3533,20 +3522,19 @@ TEST_F(RenderTextTest, TextDoesClip) {
sk_sp<SkSurface> surface =
SkSurface::MakeRasterN32Premul(kCanvasSize.width(), kCanvasSize.height());
Canvas canvas(sk_ref_sp(surface->getCanvas()), 1.0f);
- std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
- render_text->SetHorizontalAlignment(ALIGN_LEFT);
- render_text->SetColor(SK_ColorBLACK);
+ render_text_->SetHorizontalAlignment(ALIGN_LEFT);
+ render_text_->SetColor(SK_ColorBLACK);
for (auto* string : kTestStrings) {
surface->getCanvas()->clear(SK_ColorWHITE);
- render_text->SetText(WideToUTF16(string));
- const Size string_size = render_text->GetStringSize();
+ render_text_->SetText(WideToUTF16(string));
+ const Size string_size = render_text_->GetStringSize();
int fake_width = string_size.width() / 2;
int fake_height = string_size.height() / 2;
- render_text->SetDisplayRect(
+ render_text_->SetDisplayRect(
Rect(kTestSize, kTestSize, fake_width, fake_height));
- render_text->set_clip_to_display_rect(true);
- render_text->Draw(&canvas);
+ render_text_->set_clip_to_display_rect(true);
+ render_text_->Draw(&canvas);
ASSERT_LT(string_size.width() + kTestSize, kCanvasSize.width());
SkPixmap pixmap;
surface->peekPixels(&pixmap);
@@ -3579,114 +3567,116 @@ TEST_F(RenderTextTest, TextDoesClip) {
}
#if defined(OS_MACOSX)
-TEST_F(RenderTextTest, Mac_ElidedText) {
- RenderTextMac render_text;
+TEST_P(RenderTextMacTest, Mac_ElidedText) {
+ RenderTextMac* render_text = static_cast<RenderTextMac*>(render_text_.get());
base::string16 text(ASCIIToUTF16("This is an example."));
- render_text.SetText(text);
- Size string_size = render_text.GetStringSize();
- render_text.SetDisplayRect(Rect(string_size));
- render_text.EnsureLayout();
+ render_text->SetText(text);
+ Size string_size = render_text->GetStringSize();
+ render_text->SetDisplayRect(Rect(string_size));
+ render_text->EnsureLayout();
// NOTE: Character and glyph counts are only comparable for simple text.
EXPECT_EQ(text.size(),
- static_cast<size_t>(CTLineGetGlyphCount(render_text.line_)));
+ static_cast<size_t>(CTLineGetGlyphCount(render_text->line_)));
- render_text.SetElideBehavior(ELIDE_TAIL);
+ render_text->SetElideBehavior(ELIDE_TAIL);
string_size.set_width(string_size.width() / 2);
- render_text.SetDisplayRect(Rect(string_size));
- render_text.EnsureLayout();
- CFIndex glyph_count = CTLineGetGlyphCount(render_text.line_);
+ render_text->SetDisplayRect(Rect(string_size));
+ render_text->EnsureLayout();
+ CFIndex glyph_count = CTLineGetGlyphCount(render_text->line_);
EXPECT_GT(text.size(), static_cast<size_t>(glyph_count));
EXPECT_NE(0, glyph_count);
}
#endif
// Ensure color changes are picked up by the RenderText implementation.
-TEST_F(RenderTextTest, ColorChange) {
- RenderTextAllBackends backend;
+TEST_P(RenderTextTestAll, ColorChange) {
+ render_text_->SetText(ASCIIToUTF16("x"));
+ DrawVisualText();
- while (backend.Advance()) {
- SCOPED_TRACE(testing::Message() << "backend: " << backend.GetName());
- backend->SetText(ASCIIToUTF16("x"));
- backend.DrawVisualText();
+ std::vector<TestSkiaTextRenderer::TextLog> text_log;
+ renderer_.GetTextLogAndReset(&text_log);
+ EXPECT_EQ(1u, text_log.size());
+ EXPECT_EQ(SK_ColorBLACK, text_log[0].color);
- std::vector<TestSkiaTextRenderer::TextLog> text_log;
- backend.GetTextLogAndReset(&text_log);
- EXPECT_EQ(1u, text_log.size());
- EXPECT_EQ(SK_ColorBLACK, text_log[0].color);
-
- backend->SetColor(SK_ColorRED);
- backend.DrawVisualText();
- backend.GetTextLogAndReset(&text_log);
+ render_text_->SetColor(SK_ColorRED);
+ DrawVisualText();
+ renderer_.GetTextLogAndReset(&text_log);
- EXPECT_EQ(1u, text_log.size());
- EXPECT_EQ(SK_ColorRED, text_log[0].color);
- }
+ EXPECT_EQ(1u, text_log.size());
+ EXPECT_EQ(SK_ColorRED, text_log[0].color);
}
// Ensure style information propagates to the typeface on the text renderer.
-TEST_F(RenderTextTest, StylePropagated) {
- RenderTextAllBackends backend;
-
+TEST_P(RenderTextTestAll, StylePropagated) {
// Default-constructed fonts on Mac are system fonts. These can have all kinds
// of weird weights and style, which are preserved by PlatformFontMac, but do
// not map simply to a SkTypeface::Style (the full details in SkFontStyle is
// needed). They also vary depending on the OS version, so set a known font.
FontList font_list(Font("Arial", 10));
- while (backend.Advance()) {
- SCOPED_TRACE(testing::Message() << "backend: " << backend.GetName());
- backend->SetText(ASCIIToUTF16("x"));
- backend->SetFontList(font_list);
+ render_text_->SetText(ASCIIToUTF16("x"));
+ render_text_->SetFontList(font_list);
- backend.DrawVisualText();
- EXPECT_EQ(SkTypeface::kNormal, backend.paint().getTypeface()->style());
+ DrawVisualText();
+ EXPECT_EQ(SkTypeface::kNormal, GetRendererPaint().getTypeface()->style());
- backend->SetWeight(Font::Weight::BOLD);
- backend.DrawVisualText();
- EXPECT_EQ(SkTypeface::kBold, backend.paint().getTypeface()->style());
+ render_text_->SetWeight(Font::Weight::BOLD);
+ DrawVisualText();
+ EXPECT_EQ(SkTypeface::kBold, GetRendererPaint().getTypeface()->style());
- backend->SetStyle(TextStyle::ITALIC, true);
- backend.DrawVisualText();
- EXPECT_EQ(SkTypeface::kBoldItalic, backend.paint().getTypeface()->style());
+ render_text_->SetStyle(TextStyle::ITALIC, true);
+ DrawVisualText();
+ EXPECT_EQ(SkTypeface::kBoldItalic, GetRendererPaint().getTypeface()->style());
- backend->SetWeight(Font::Weight::NORMAL);
- backend.DrawVisualText();
- EXPECT_EQ(SkTypeface::kItalic, backend.paint().getTypeface()->style());
- }
+ render_text_->SetWeight(Font::Weight::NORMAL);
+ DrawVisualText();
+ EXPECT_EQ(SkTypeface::kItalic, GetRendererPaint().getTypeface()->style());
}
// Ensure the painter adheres to RenderText::subpixel_rendering_suppressed().
-TEST_F(RenderTextTest, SubpixelRenderingSuppressed) {
- RenderTextAllBackends backend;
-
- while (backend.Advance()) {
- SCOPED_TRACE(testing::Message() << "backend: " << backend.GetName());
- backend->SetText(ASCIIToUTF16("x"));
+TEST_P(RenderTextTestAll, SubpixelRenderingSuppressed) {
+ render_text_->SetText(ASCIIToUTF16("x"));
- backend.DrawVisualText();
+ DrawVisualText();
#if defined(OS_LINUX)
- // On Linux, whether subpixel AA is supported is determined by the platform
- // FontConfig. Force it into a particular style after computing runs. Other
- // platforms use a known default FontRenderParams from a static local.
- backend.GetHarfbuzzRunList()->runs()[0]->render_params.subpixel_rendering =
- FontRenderParams::SUBPIXEL_RENDERING_RGB;
- backend.DrawVisualText();
+ // On Linux, whether subpixel AA is supported is determined by the platform
+ // FontConfig. Force it into a particular style after computing runs. Other
+ // platforms use a known default FontRenderParams from a static local.
+ GetHarfbuzzRunList()->runs()[0]->render_params.subpixel_rendering =
+ FontRenderParams::SUBPIXEL_RENDERING_RGB;
+ DrawVisualText();
#endif
- EXPECT_TRUE(backend.paint().isLCDRenderText());
+ EXPECT_TRUE(GetRendererPaint().isLCDRenderText());
- backend->set_subpixel_rendering_suppressed(true);
- backend.DrawVisualText();
+ render_text_->set_subpixel_rendering_suppressed(true);
+ DrawVisualText();
#if defined(OS_LINUX)
// For Linux, runs shouldn't be re-calculated, and the suppression of the
// SUBPIXEL_RENDERING_RGB set above should now take effect. But, after
// checking, apply the override anyway to be explicit that it is suppressed.
- EXPECT_FALSE(backend.paint().isLCDRenderText());
- backend.GetHarfbuzzRunList()->runs()[0]->render_params.subpixel_rendering =
+ EXPECT_FALSE(GetRendererPaint().isLCDRenderText());
+ GetHarfbuzzRunList()->runs()[0]->render_params.subpixel_rendering =
FontRenderParams::SUBPIXEL_RENDERING_RGB;
- backend.DrawVisualText();
+ DrawVisualText();
#endif
- EXPECT_FALSE(backend.paint().isLCDRenderText());
- }
+ EXPECT_FALSE(GetRendererPaint().isLCDRenderText());
}
+#if defined(OS_MACOSX)
+INSTANTIATE_TEST_CASE_P(,
+ RenderTextTestAll,
+ ::testing::Values(RENDER_TEXT_HARFBUZZ,
+ RENDER_TEXT_MAC));
+INSTANTIATE_TEST_CASE_P(,
+ RenderTextMacTest,
+ ::testing::Values(RENDER_TEXT_MAC));
+#else
+INSTANTIATE_TEST_CASE_P(,
+ RenderTextTestAll,
+ ::testing::Values(RENDER_TEXT_HARFBUZZ));
+#endif
+
+INSTANTIATE_TEST_CASE_P(,
+ RenderTextHarfBuzzTest,
+ ::testing::Values(RENDER_TEXT_HARFBUZZ));
} // namespace gfx
« no previous file with comments | « ui/gfx/render_text_mac.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698