#include "base/i18n/rtl.h"
#include "base/strings/utf_string_conversions.h"
#include "testing/gtest/include/gtest/gtest.h"
-#include "ui/base/accessibility/accessible_view_state.h"
+#include "ui/accessibility/ax_view_state.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/gfx/canvas.h"
#include "ui/views/border.h"
+#include "ui/views/test/views_test_base.h"
+#include "ui/views/widget/widget.h"
using base::ASCIIToUTF16;
namespace views {
+typedef ViewsTestBase LabelTest;
+
// All text sizing measurements (width and height) should be greater than this.
const int kMinTextDimension = 4;
-TEST(LabelTest, FontPropertySymbol) {
+// A test utility function to set the application default text direction.
+void SetRTL(bool rtl) {
+ // Override the current locale/direction.
+ base::i18n::SetICUDefaultLocale(rtl ? "he" : "en");
+ EXPECT_EQ(rtl, base::i18n::IsRTL());
+}
+
+TEST_F(LabelTest, FontPropertySymbol) {
Label label;
std::string font_name("symbol");
gfx::Font font(font_name, 26);
EXPECT_EQ(26, font_used.GetFontSize());
}
-TEST(LabelTest, FontPropertyArial) {
+TEST_F(LabelTest, FontPropertyArial) {
Label label;
std::string font_name("arial");
gfx::Font font(font_name, 30);
EXPECT_EQ(30, font_used.GetFontSize());
}
-TEST(LabelTest, TextProperty) {
+TEST_F(LabelTest, TextProperty) {
Label label;
base::string16 test_text(ASCIIToUTF16("A random string."));
label.SetText(test_text);
EXPECT_EQ(test_text, label.text());
}
-TEST(LabelTest, ColorProperty) {
+TEST_F(LabelTest, ColorProperty) {
Label label;
SkColor color = SkColorSetARGB(20, 40, 10, 5);
label.SetAutoColorReadabilityEnabled(false);
EXPECT_EQ(color, label.enabled_color());
}
-TEST(LabelTest, AlignmentProperty) {
+TEST_F(LabelTest, AlignmentProperty) {
+ const bool was_rtl = base::i18n::IsRTL();
+
Label label;
- bool reverse_alignment = base::i18n::IsRTL();
+ for (size_t i = 0; i < 2; ++i) {
+ // Toggle the application default text direction (to try each direction).
+ SetRTL(!base::i18n::IsRTL());
+ bool reverse_alignment = base::i18n::IsRTL();
+
+ // The alignment should be flipped in RTL UI.
+ label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
+ EXPECT_EQ(reverse_alignment ? gfx::ALIGN_LEFT : gfx::ALIGN_RIGHT,
+ label.GetHorizontalAlignment());
+ label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
+ EXPECT_EQ(reverse_alignment ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT,
+ label.GetHorizontalAlignment());
+ label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
+ EXPECT_EQ(gfx::ALIGN_CENTER, label.GetHorizontalAlignment());
+
+ for (size_t j = 0; j < 2; ++j) {
+ label.SetHorizontalAlignment(gfx::ALIGN_TO_HEAD);
+ const bool rtl = j == 0;
+ label.SetText(rtl ? base::WideToUTF16(L"\x5d0") : ASCIIToUTF16("A"));
+ EXPECT_EQ(rtl ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT,
+ label.GetHorizontalAlignment());
+ }
+ }
- label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
- EXPECT_EQ(reverse_alignment ? gfx::ALIGN_LEFT : gfx::ALIGN_RIGHT,
- label.horizontal_alignment());
- label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
- EXPECT_EQ(reverse_alignment ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT,
- label.horizontal_alignment());
- label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
- EXPECT_EQ(gfx::ALIGN_CENTER, label.horizontal_alignment());
+ EXPECT_EQ(was_rtl, base::i18n::IsRTL());
+}
- // The label's alignment should not be flipped if the directionality mode is
- // AUTO_DETECT_DIRECTIONALITY.
- label.set_directionality_mode(Label::AUTO_DETECT_DIRECTIONALITY);
- label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
- EXPECT_EQ(gfx::ALIGN_RIGHT, label.horizontal_alignment());
- label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
- EXPECT_EQ(gfx::ALIGN_LEFT, label.horizontal_alignment());
- label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
- EXPECT_EQ(gfx::ALIGN_CENTER, label.horizontal_alignment());
+TEST_F(LabelTest, MultiLineProperty) {
+ Label label;
+ EXPECT_FALSE(label.multi_line());
+ label.SetMultiLine(true);
+ EXPECT_TRUE(label.multi_line());
+ label.SetMultiLine(false);
+ EXPECT_FALSE(label.multi_line());
}
-TEST(LabelTest, DirectionalityModeProperty) {
+TEST_F(LabelTest, ObscuredProperty) {
Label label;
- EXPECT_EQ(Label::USE_UI_DIRECTIONALITY, label.directionality_mode());
+ base::string16 test_text(ASCIIToUTF16("Password!"));
+ label.SetText(test_text);
+
+ // The text should be unobscured by default.
+ EXPECT_FALSE(label.obscured());
+ EXPECT_EQ(test_text, label.GetLayoutTextForTesting());
+ EXPECT_EQ(test_text, label.text());
+
+ label.SetObscured(true);
+ EXPECT_TRUE(label.obscured());
+ EXPECT_EQ(ASCIIToUTF16("*********"), label.GetLayoutTextForTesting());
+ EXPECT_EQ(test_text, label.text());
- label.set_directionality_mode(Label::AUTO_DETECT_DIRECTIONALITY);
- EXPECT_EQ(Label::AUTO_DETECT_DIRECTIONALITY, label.directionality_mode());
+ label.SetText(test_text + test_text);
+ EXPECT_EQ(ASCIIToUTF16("******************"),
+ label.GetLayoutTextForTesting());
+ EXPECT_EQ(test_text + test_text, label.text());
- label.set_directionality_mode(Label::USE_UI_DIRECTIONALITY);
- EXPECT_EQ(Label::USE_UI_DIRECTIONALITY, label.directionality_mode());
+ label.SetObscured(false);
+ EXPECT_FALSE(label.obscured());
+ EXPECT_EQ(test_text + test_text, label.GetLayoutTextForTesting());
+ EXPECT_EQ(test_text + test_text, label.text());
}
-TEST(LabelTest, MultiLineProperty) {
+TEST_F(LabelTest, ObscuredSurrogatePair) {
+ // 'MUSICAL SYMBOL G CLEF': represented in UTF-16 as two characters
+ // forming the surrogate pair 0x0001D11E.
Label label;
- EXPECT_FALSE(label.is_multi_line());
- label.SetMultiLine(true);
- EXPECT_TRUE(label.is_multi_line());
- label.SetMultiLine(false);
- EXPECT_FALSE(label.is_multi_line());
+ base::string16 test_text = base::UTF8ToUTF16("\xF0\x9D\x84\x9E");
+ label.SetText(test_text);
+
+ label.SetObscured(true);
+ EXPECT_EQ(ASCIIToUTF16("*"), label.GetLayoutTextForTesting());
+ EXPECT_EQ(test_text, label.text());
}
-TEST(LabelTest, TooltipProperty) {
+TEST_F(LabelTest, TooltipProperty) {
Label label;
- base::string16 test_text(ASCIIToUTF16("My cool string."));
- label.SetText(test_text);
+ label.SetText(ASCIIToUTF16("My cool string."));
base::string16 tooltip;
EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
- EXPECT_EQ(test_text, tooltip);
+ EXPECT_EQ(label.text(), tooltip);
base::string16 tooltip_text(ASCIIToUTF16("The tooltip!"));
label.SetTooltipText(tooltip_text);
EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
EXPECT_EQ(tooltip_text, tooltip);
- base::string16 empty_text;
- label.SetTooltipText(empty_text);
+ label.SetTooltipText(base::string16());
EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
- EXPECT_EQ(test_text, tooltip);
+ EXPECT_EQ(label.text(), tooltip);
// Make the label big enough to hold the text
// and expect there to be no tooltip.
label.SetBounds(0, 0, 1000, 40);
EXPECT_FALSE(label.GetTooltipText(gfx::Point(), &tooltip));
- // Verify that setting the tooltip still shows it.
+ // Shrinking the single-line label's height shouldn't trigger a tooltip.
+ label.SetBounds(0, 0, 1000, label.GetPreferredSize().height() / 2);
+ EXPECT_FALSE(label.GetTooltipText(gfx::Point(), &tooltip));
+
+ // Verify that explicitly set tooltip text is shown, regardless of size.
label.SetTooltipText(tooltip_text);
EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
EXPECT_EQ(tooltip_text, tooltip);
- // Clear out the tooltip.
- label.SetTooltipText(empty_text);
+ // Clear out the explicitly set tooltip text.
+ label.SetTooltipText(base::string16());
// Shrink the bounds and the tooltip should come back.
- label.SetBounds(0, 0, 1, 1);
+ label.SetBounds(0, 0, 10, 10);
EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
- // Make the label multiline and there is no tooltip again.
+ // Make the label obscured and there is no tooltip.
+ label.SetObscured(true);
+ EXPECT_FALSE(label.GetTooltipText(gfx::Point(), &tooltip));
+
+ // Obscuring the text shouldn't permanently clobber the tooltip.
+ label.SetObscured(false);
+ EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
+
+ // Making the label multiline shouldn't eliminate the tooltip.
label.SetMultiLine(true);
+ EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
+ // Expanding the multiline label bounds should eliminate the tooltip.
+ label.SetBounds(0, 0, 1000, 1000);
EXPECT_FALSE(label.GetTooltipText(gfx::Point(), &tooltip));
// Verify that setting the tooltip still shows it.
EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
EXPECT_EQ(tooltip_text, tooltip);
// Clear out the tooltip.
- label.SetTooltipText(empty_text);
+ label.SetTooltipText(base::string16());
}
-TEST(LabelTest, Accessibility) {
+TEST_F(LabelTest, Accessibility) {
Label label;
- base::string16 test_text(ASCIIToUTF16("My special text."));
- label.SetText(test_text);
+ label.SetText(ASCIIToUTF16("My special text."));
- ui::AccessibleViewState state;
+ ui::AXViewState state;
label.GetAccessibleState(&state);
- EXPECT_EQ(ui::AccessibilityTypes::ROLE_STATICTEXT, state.role);
- EXPECT_EQ(test_text, state.name);
- EXPECT_TRUE(ui::AccessibilityTypes::STATE_READONLY & state.state);
+ EXPECT_EQ(ui::AX_ROLE_STATIC_TEXT, state.role);
+ EXPECT_EQ(label.text(), state.name);
+ EXPECT_TRUE(state.HasStateFlag(ui::AX_STATE_READ_ONLY));
}
-TEST(LabelTest, SingleLineSizing) {
+TEST_F(LabelTest, EmptyLabelSizing) {
Label label;
- base::string16 test_text(ASCIIToUTF16("A not so random string in one line."));
- label.SetText(test_text);
+ const gfx::Size expected_size(0, gfx::FontList().GetHeight());
+ EXPECT_EQ(expected_size, label.GetPreferredSize());
+ label.SetMultiLine(!label.multi_line());
+ EXPECT_EQ(expected_size, label.GetPreferredSize());
+}
- // GetPreferredSize
- gfx::Size required_size = label.GetPreferredSize();
- EXPECT_GT(required_size.height(), kMinTextDimension);
- EXPECT_GT(required_size.width(), kMinTextDimension);
+TEST_F(LabelTest, SingleLineSizing) {
+ Label label;
+ label.SetText(ASCIIToUTF16("A not so random string in one line."));
+ const gfx::Size size = label.GetPreferredSize();
+ EXPECT_GT(size.height(), kMinTextDimension);
+ EXPECT_GT(size.width(), kMinTextDimension);
- // Test everything with borders.
- gfx::Insets border(10, 20, 30, 40);
+ // Setting a size smaller than preferred should not change the preferred size.
+ label.SetSize(gfx::Size(size.width() / 2, size.height() / 2));
+ EXPECT_EQ(size, label.GetPreferredSize());
+
+ const gfx::Insets border(10, 20, 30, 40);
label.SetBorder(Border::CreateEmptyBorder(
border.top(), border.left(), border.bottom(), border.right()));
-
- // GetPreferredSize and borders.
- label.SetBounds(0, 0, 0, 0);
- gfx::Size required_size_with_border = label.GetPreferredSize();
- EXPECT_EQ(required_size_with_border.height(),
- required_size.height() + border.height());
- EXPECT_EQ(required_size_with_border.width(),
- required_size.width() + border.width());
+ const gfx::Size size_with_border = label.GetPreferredSize();
+ EXPECT_EQ(size_with_border.height(), size.height() + border.height());
+ EXPECT_EQ(size_with_border.width(), size.width() + border.width());
}
-TEST(LabelTest, MultilineSmallAvailableWidthSizing) {
+TEST_F(LabelTest, MultilineSmallAvailableWidthSizing) {
Label label;
- base::string16 test_text(ASCIIToUTF16("Too Wide."));
-
label.SetMultiLine(true);
label.SetAllowCharacterBreak(true);
- label.SetElideBehavior(Label::ELIDE_AT_END);
- label.SetText(test_text);
+ label.SetText(ASCIIToUTF16("Too Wide."));
// Check that Label can be laid out at a variety of small sizes,
// splitting the words into up to one character per line if necessary.
// Incorrect word splitting may cause infinite loops in text layout.
gfx::Size required_size = label.GetPreferredSize();
- for (int i = 1; i < required_size.width(); ++i) {
+ for (int i = 1; i < required_size.width(); ++i)
EXPECT_GT(label.GetHeightForWidth(i), 0);
- }
}
-TEST(LabelTest, MultiLineSizing) {
+TEST_F(LabelTest, MultiLineSizing) {
Label label;
label.SetFocusable(false);
- base::string16 test_text(
+ label.SetText(
ASCIIToUTF16("A random string\nwith multiple lines\nand returns!"));
- label.SetText(test_text);
label.SetMultiLine(true);
// GetPreferredSize
required_size.width() + border.width());
}
-TEST(LabelTest, AutoDetectDirectionality) {
+TEST_F(LabelTest, DirectionalityFromText) {
Label label;
- label.set_directionality_mode(Label::AUTO_DETECT_DIRECTIONALITY);
-
- // Test text starts with RTL character.
- base::string16 test_text(base::WideToUTF16(L" \x5d0\x5d1\x5d2 abc"));
- label.SetText(test_text);
- gfx::Size required_size(label.GetPreferredSize());
- gfx::Size extra(22, 8);
- label.SetBounds(0,
- 0,
- required_size.width() + extra.width(),
- required_size.height() + extra.height());
-
+ label.SetBounds(0, 0, 1000, 1000);
base::string16 paint_text;
gfx::Rect text_bounds;
- int flags;
+ int flags = -1;
+
+ // Test text starts with RTL character.
+ label.SetText(base::WideToUTF16(L" \x5d0\x5d1\x5d2 abc"));
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
EXPECT_EQ(gfx::Canvas::FORCE_RTL_DIRECTIONALITY,
flags & (gfx::Canvas::FORCE_RTL_DIRECTIONALITY |
gfx::Canvas::FORCE_LTR_DIRECTIONALITY));
// Test text starts with LTR character.
- test_text = (base::WideToUTF16(L"ltr \x5d0\x5d1\x5d2 abc"));
- label.SetText(test_text);
- required_size = label.GetPreferredSize();
- label.SetBounds(0,
- 0,
- required_size.width() + extra.width(),
- required_size.height() + extra.height());
-
+ label.SetText(base::WideToUTF16(L"ltr \x5d0\x5d1\x5d2 abc"));
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
EXPECT_EQ(gfx::Canvas::FORCE_LTR_DIRECTIONALITY,
flags & (gfx::Canvas::FORCE_RTL_DIRECTIONALITY |
gfx::Canvas::FORCE_LTR_DIRECTIONALITY));
}
-TEST(LabelTest, DrawSingleLineString) {
+TEST_F(LabelTest, DrawSingleLineString) {
Label label;
label.SetFocusable(false);
- // Turn off mirroring so that we don't need to figure out if
- // align right really means align left.
- label.set_directionality_mode(Label::AUTO_DETECT_DIRECTIONALITY);
-
- base::string16 test_text(ASCIIToUTF16("Here's a string with no returns."));
- label.SetText(test_text);
+ label.SetText(ASCIIToUTF16("Here's a string with no returns."));
gfx::Size required_size(label.GetPreferredSize());
gfx::Size extra(22, 8);
- label.SetBounds(0,
- 0,
- required_size.width() + extra.width(),
+ label.SetBounds(0, 0, required_size.width() + extra.width(),
required_size.height() + extra.height());
// Do some basic verifications for all three alignments.
base::string16 paint_text;
gfx::Rect text_bounds;
- int flags;
+ int flags = -1;
// Centered text.
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
// The text should be centered horizontally and vertically.
EXPECT_EQ(extra.width() / 2, text_bounds.x());
- EXPECT_EQ(extra.height() / 2 , text_bounds.y());
+ EXPECT_EQ(0, text_bounds.y());
EXPECT_EQ(required_size.width(), text_bounds.width());
- EXPECT_EQ(required_size.height(), text_bounds.height());
+ EXPECT_EQ(label.height(), text_bounds.height());
EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::TEXT_ALIGN_CENTER |
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
// The text should be left aligned horizontally and centered vertically.
EXPECT_EQ(0, text_bounds.x());
- EXPECT_EQ(extra.height() / 2 , text_bounds.y());
+ EXPECT_EQ(0, text_bounds.y());
EXPECT_EQ(required_size.width(), text_bounds.width());
- EXPECT_EQ(required_size.height(), text_bounds.height());
+ EXPECT_EQ(label.height(), text_bounds.height());
EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::TEXT_ALIGN_CENTER |
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
// The text should be right aligned horizontally and centered vertically.
EXPECT_EQ(extra.width(), text_bounds.x());
- EXPECT_EQ(extra.height() / 2 , text_bounds.y());
+ EXPECT_EQ(0, text_bounds.y());
EXPECT_EQ(required_size.width(), text_bounds.width());
- EXPECT_EQ(required_size.height(), text_bounds.height());
+ EXPECT_EQ(label.height(), text_bounds.height());
EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::TEXT_ALIGN_CENTER |
required_size_with_border.width());
EXPECT_EQ(required_size.height() + border.height(),
required_size_with_border.height());
- label.SetBounds(0,
- 0,
- required_size_with_border.width() + extra.width(),
+ label.SetBounds(0, 0, required_size_with_border.width() + extra.width(),
required_size_with_border.height() + extra.height());
// Centered text with border.
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
// The text should be centered horizontally and vertically within the border.
EXPECT_EQ(border.left() + extra.width() / 2, text_bounds.x());
- EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
+ EXPECT_EQ(border.top(), text_bounds.y());
EXPECT_EQ(required_size.width(), text_bounds.width());
- EXPECT_EQ(required_size.height(), text_bounds.height());
+ EXPECT_EQ(label.GetContentsBounds().height(), text_bounds.height());
EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::TEXT_ALIGN_CENTER |
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
// The text should be left aligned horizontally and centered vertically.
EXPECT_EQ(border.left(), text_bounds.x());
- EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
+ EXPECT_EQ(border.top(), text_bounds.y());
EXPECT_EQ(required_size.width(), text_bounds.width());
- EXPECT_EQ(required_size.height(), text_bounds.height());
+ EXPECT_EQ(label.GetContentsBounds().height(), text_bounds.height());
EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::TEXT_ALIGN_CENTER |
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
// The text should be right aligned horizontally and centered vertically.
EXPECT_EQ(border.left() + extra.width(), text_bounds.x());
- EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
+ EXPECT_EQ(border.top(), text_bounds.y());
EXPECT_EQ(required_size.width(), text_bounds.width());
- EXPECT_EQ(required_size.height(), text_bounds.height());
+ EXPECT_EQ(label.GetContentsBounds().height(), text_bounds.height());
EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::TEXT_ALIGN_CENTER |
gfx::Canvas::TEXT_ALIGN_RIGHT));
}
-// On Linux the underlying pango routines require a max height in order to
-// ellide multiline text. So until that can be resolved, we set all
-// multiline lables to not ellide in Linux only.
-TEST(LabelTest, DrawMultiLineString) {
+// Pango needs a max height to elide multiline text; that is not supported here.
+TEST_F(LabelTest, DrawMultiLineString) {
Label label;
label.SetFocusable(false);
+ // Set a background color to prevent gfx::Canvas::NO_SUBPIXEL_RENDERING flags.
+ label.SetBackgroundColor(SK_ColorWHITE);
- // Turn off mirroring so that we don't need to figure out if
- // align right really means align left.
- label.set_directionality_mode(Label::AUTO_DETECT_DIRECTIONALITY);
-
- base::string16 test_text(ASCIIToUTF16("Another string\nwith returns\n\n!"));
- label.SetText(test_text);
+ label.SetText(ASCIIToUTF16("Another string\nwith returns\n\n!"));
label.SetMultiLine(true);
label.SizeToFit(0);
gfx::Size extra(50, 10);
- label.SetBounds(label.x(),
- label.y(),
+ label.SetBounds(label.x(), label.y(),
label.width() + extra.width(),
label.height() + extra.height());
// Do some basic verifications for all three alignments.
base::string16 paint_text;
gfx::Rect text_bounds;
- int flags;
+ int flags = -1;
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
EXPECT_EQ(extra.width() / 2, text_bounds.x());
- EXPECT_EQ(extra.height() / 2, text_bounds.y());
+ EXPECT_EQ(0, text_bounds.y());
EXPECT_GT(text_bounds.width(), kMinTextDimension);
- EXPECT_GT(text_bounds.height(), kMinTextDimension);
+ EXPECT_EQ(text_bounds.height(), label.height());
int expected_flags = gfx::Canvas::MULTI_LINE |
gfx::Canvas::TEXT_ALIGN_CENTER |
gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
-#if defined(OS_WIN)
- EXPECT_EQ(expected_flags, flags);
-#else
- EXPECT_EQ(expected_flags | gfx::Canvas::NO_ELLIPSIS, flags);
+#if !defined(OS_WIN)
+ expected_flags |= gfx::Canvas::NO_ELLIPSIS;
#endif
+ EXPECT_EQ(expected_flags, expected_flags);
gfx::Rect center_bounds(text_bounds);
label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
EXPECT_EQ(0, text_bounds.x());
- EXPECT_EQ(extra.height() / 2, text_bounds.y());
+ EXPECT_EQ(0, text_bounds.y());
EXPECT_GT(text_bounds.width(), kMinTextDimension);
- EXPECT_GT(text_bounds.height(), kMinTextDimension);
+ EXPECT_EQ(text_bounds.height(), label.height());
expected_flags = gfx::Canvas::MULTI_LINE |
gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
-#if defined(OS_WIN)
- EXPECT_EQ(expected_flags, flags);
-#else
- EXPECT_EQ(expected_flags | gfx::Canvas::NO_ELLIPSIS, flags);
+#if !defined(OS_WIN)
+ expected_flags |= gfx::Canvas::NO_ELLIPSIS;
#endif
+ EXPECT_EQ(expected_flags, expected_flags);
label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
EXPECT_EQ(extra.width(), text_bounds.x());
- EXPECT_EQ(extra.height() / 2, text_bounds.y());
+ EXPECT_EQ(0, text_bounds.y());
EXPECT_GT(text_bounds.width(), kMinTextDimension);
- EXPECT_GT(text_bounds.height(), kMinTextDimension);
+ EXPECT_EQ(text_bounds.height(), label.height());
expected_flags = gfx::Canvas::MULTI_LINE |
gfx::Canvas::TEXT_ALIGN_RIGHT |
gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
-#if defined(OS_WIN)
- EXPECT_EQ(expected_flags, flags);
-#else
- EXPECT_EQ(expected_flags | gfx::Canvas::NO_ELLIPSIS, flags);
+#if !defined(OS_WIN)
+ expected_flags |= gfx::Canvas::NO_ELLIPSIS;
#endif
+ EXPECT_EQ(expected_flags, expected_flags);
// Test multiline drawing with a border.
gfx::Insets border(19, 92, 23, 2);
label.SetBorder(Border::CreateEmptyBorder(
border.top(), border.left(), border.bottom(), border.right()));
label.SizeToFit(0);
- label.SetBounds(label.x(),
- label.y(),
+ label.SetBounds(label.x(), label.y(),
label.width() + extra.width(),
label.height() + extra.height());
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
EXPECT_EQ(border.left() + extra.width() / 2, text_bounds.x());
- EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
+ EXPECT_EQ(border.top(), text_bounds.y());
EXPECT_EQ(center_bounds.width(), text_bounds.width());
EXPECT_EQ(center_bounds.height(), text_bounds.height());
expected_flags = gfx::Canvas::MULTI_LINE |
gfx::Canvas::TEXT_ALIGN_CENTER |
gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
-#if defined(OS_WIN)
- EXPECT_EQ(expected_flags, flags);
-#else
- EXPECT_EQ(expected_flags | gfx::Canvas::NO_ELLIPSIS, flags);
+#if !defined(OS_WIN)
+ expected_flags |= gfx::Canvas::NO_ELLIPSIS;
#endif
+ EXPECT_EQ(expected_flags, expected_flags);
label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
EXPECT_EQ(border.left(), text_bounds.x());
- EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
+ EXPECT_EQ(border.top(), text_bounds.y());
EXPECT_EQ(center_bounds.width(), text_bounds.width());
EXPECT_EQ(center_bounds.height(), text_bounds.height());
expected_flags = gfx::Canvas::MULTI_LINE |
gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
-#if defined(OS_WIN)
- EXPECT_EQ(expected_flags, flags);
-#else
- EXPECT_EQ(expected_flags | gfx::Canvas::NO_ELLIPSIS, flags);
+#if !defined(OS_WIN)
+ expected_flags |= gfx::Canvas::NO_ELLIPSIS;
#endif
+ EXPECT_EQ(expected_flags, expected_flags);
label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
EXPECT_EQ(extra.width() + border.left(), text_bounds.x());
- EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
+ EXPECT_EQ(border.top(), text_bounds.y());
EXPECT_EQ(center_bounds.width(), text_bounds.width());
EXPECT_EQ(center_bounds.height(), text_bounds.height());
expected_flags = gfx::Canvas::MULTI_LINE |
gfx::Canvas::TEXT_ALIGN_RIGHT |
gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
-#if defined(OS_WIN)
- EXPECT_EQ(expected_flags, flags);
-#else
- EXPECT_EQ(expected_flags | gfx::Canvas::NO_ELLIPSIS, flags);
+#if !defined(OS_WIN)
+ expected_flags |= gfx::Canvas::NO_ELLIPSIS;
#endif
+ EXPECT_EQ(expected_flags, expected_flags);
}
-TEST(LabelTest, DrawSingleLineStringInRTL) {
+TEST_F(LabelTest, DrawSingleLineStringInRTL) {
Label label;
label.SetFocusable(false);
std::string locale = l10n_util::GetApplicationLocale("");
base::i18n::SetICUDefaultLocale("he");
- base::string16 test_text(ASCIIToUTF16("Here's a string with no returns."));
- label.SetText(test_text);
+ label.SetText(ASCIIToUTF16("Here's a string with no returns."));
gfx::Size required_size(label.GetPreferredSize());
gfx::Size extra(22, 8);
- label.SetBounds(0,
- 0,
- required_size.width() + extra.width(),
+ label.SetBounds(0, 0, required_size.width() + extra.width(),
required_size.height() + extra.height());
// Do some basic verifications for all three alignments.
base::string16 paint_text;
gfx::Rect text_bounds;
- int flags;
+ int flags = -1;
// Centered text.
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
// The text should be centered horizontally and vertically.
EXPECT_EQ(extra.width() / 2, text_bounds.x());
- EXPECT_EQ(extra.height() / 2 , text_bounds.y());
+ EXPECT_EQ(0, text_bounds.y());
EXPECT_EQ(required_size.width(), text_bounds.width());
- EXPECT_EQ(required_size.height(), text_bounds.height());
+ EXPECT_EQ(label.height(), text_bounds.height());
EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::TEXT_ALIGN_CENTER |
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
// The text should be right aligned horizontally and centered vertically.
EXPECT_EQ(extra.width(), text_bounds.x());
- EXPECT_EQ(extra.height() / 2 , text_bounds.y());
+ EXPECT_EQ(0, text_bounds.y());
EXPECT_EQ(required_size.width(), text_bounds.width());
- EXPECT_EQ(required_size.height(), text_bounds.height());
+ EXPECT_EQ(label.height(), text_bounds.height());
EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::TEXT_ALIGN_CENTER |
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
// The text should be left aligned horizontally and centered vertically.
EXPECT_EQ(0, text_bounds.x());
- EXPECT_EQ(extra.height() / 2 , text_bounds.y());
+ EXPECT_EQ(0, text_bounds.y());
EXPECT_EQ(required_size.width(), text_bounds.width());
- EXPECT_EQ(required_size.height(), text_bounds.height());
+ EXPECT_EQ(label.height(), text_bounds.height());
EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::TEXT_ALIGN_CENTER |
required_size_with_border.width());
EXPECT_EQ(required_size.height() + border.height(),
required_size_with_border.height());
- label.SetBounds(0,
- 0,
- required_size_with_border.width() + extra.width(),
+ label.SetBounds(0, 0, required_size_with_border.width() + extra.width(),
required_size_with_border.height() + extra.height());
// Centered text with border.
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
// The text should be centered horizontally and vertically within the border.
EXPECT_EQ(border.left() + extra.width() / 2, text_bounds.x());
- EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
+ EXPECT_EQ(border.top(), text_bounds.y());
EXPECT_EQ(required_size.width(), text_bounds.width());
- EXPECT_EQ(required_size.height(), text_bounds.height());
+ EXPECT_EQ(label.GetContentsBounds().height(), text_bounds.height());
EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::TEXT_ALIGN_CENTER |
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
// The text should be right aligned horizontally and centered vertically.
EXPECT_EQ(border.left() + extra.width(), text_bounds.x());
- EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
+ EXPECT_EQ(border.top(), text_bounds.y());
EXPECT_EQ(required_size.width(), text_bounds.width());
- EXPECT_EQ(required_size.height(), text_bounds.height());
+ EXPECT_EQ(label.GetContentsBounds().height(), text_bounds.height());
EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::TEXT_ALIGN_CENTER |
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
// The text should be left aligned horizontally and centered vertically.
EXPECT_EQ(border.left(), text_bounds.x());
- EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
+ EXPECT_EQ(border.top(), text_bounds.y());
EXPECT_EQ(required_size.width(), text_bounds.width());
- EXPECT_EQ(required_size.height(), text_bounds.height());
+ EXPECT_EQ(label.GetContentsBounds().height(), text_bounds.height());
EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
gfx::Canvas::TEXT_ALIGN_CENTER |
// On Linux the underlying pango routines require a max height in order to
// ellide multiline text. So until that can be resolved, we set all
// multiline lables to not ellide in Linux only.
-TEST(LabelTest, DrawMultiLineStringInRTL) {
+TEST_F(LabelTest, DrawMultiLineStringInRTL) {
Label label;
label.SetFocusable(false);
std::string locale = l10n_util::GetApplicationLocale("");
base::i18n::SetICUDefaultLocale("he");
- base::string16 test_text(ASCIIToUTF16("Another string\nwith returns\n\n!"));
- label.SetText(test_text);
+ label.SetText(ASCIIToUTF16("Another string\nwith returns\n\n!"));
label.SetMultiLine(true);
label.SizeToFit(0);
gfx::Size extra(50, 10);
- label.SetBounds(label.x(),
- label.y(),
+ label.SetBounds(label.x(), label.y(),
label.width() + extra.width(),
label.height() + extra.height());
// Do some basic verifications for all three alignments.
base::string16 paint_text;
gfx::Rect text_bounds;
- int flags;
+ int flags = -1;
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
EXPECT_EQ(extra.width() / 2, text_bounds.x());
- EXPECT_EQ(extra.height() / 2, text_bounds.y());
+ EXPECT_EQ(0, text_bounds.y());
EXPECT_GT(text_bounds.width(), kMinTextDimension);
- EXPECT_GT(text_bounds.height(), kMinTextDimension);
-#if defined(OS_WIN)
- EXPECT_EQ(gfx::Canvas::MULTI_LINE | gfx::Canvas::TEXT_ALIGN_CENTER, flags);
-#else
- EXPECT_EQ(
- gfx::Canvas::MULTI_LINE |
- gfx::Canvas::TEXT_ALIGN_CENTER |
- gfx::Canvas::NO_ELLIPSIS,
- flags);
+ EXPECT_EQ(text_bounds.height(), label.height());
+ EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
+ EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_CENTER & flags);
+#if !defined(OS_WIN)
+ EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
#endif
gfx::Rect center_bounds(text_bounds);
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
EXPECT_EQ(extra.width(), text_bounds.x());
- EXPECT_EQ(extra.height() / 2, text_bounds.y());
+ EXPECT_EQ(0, text_bounds.y());
EXPECT_GT(text_bounds.width(), kMinTextDimension);
- EXPECT_GT(text_bounds.height(), kMinTextDimension);
-#if defined(OS_WIN)
- EXPECT_EQ(gfx::Canvas::MULTI_LINE | gfx::Canvas::TEXT_ALIGN_RIGHT, flags);
-#else
- EXPECT_EQ(
- gfx::Canvas::MULTI_LINE |
- gfx::Canvas::TEXT_ALIGN_RIGHT |
- gfx::Canvas::NO_ELLIPSIS,
- flags);
+ EXPECT_EQ(text_bounds.height(), label.height());
+ EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
+ EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_RIGHT & flags);
+#if !defined(OS_WIN)
+ EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
#endif
label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
EXPECT_EQ(0, text_bounds.x());
- EXPECT_EQ(extra.height() / 2, text_bounds.y());
+ EXPECT_EQ(0, text_bounds.y());
EXPECT_GT(text_bounds.width(), kMinTextDimension);
- EXPECT_GT(text_bounds.height(), kMinTextDimension);
-#if defined(OS_WIN)
- EXPECT_EQ(gfx::Canvas::MULTI_LINE | gfx::Canvas::TEXT_ALIGN_LEFT, flags);
-#else
- EXPECT_EQ(
- gfx::Canvas::MULTI_LINE |
- gfx::Canvas::TEXT_ALIGN_LEFT |
- gfx::Canvas::NO_ELLIPSIS,
- flags);
+ EXPECT_EQ(text_bounds.height(), label.height());
+ EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
+ EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_LEFT & flags);
+#if !defined(OS_WIN)
+ EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
#endif
// Test multiline drawing with a border.
label.SetBorder(Border::CreateEmptyBorder(
border.top(), border.left(), border.bottom(), border.right()));
label.SizeToFit(0);
- label.SetBounds(label.x(),
- label.y(),
+ label.SetBounds(label.x(), label.y(),
label.width() + extra.width(),
label.height() + extra.height());
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
EXPECT_EQ(border.left() + extra.width() / 2, text_bounds.x());
- EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
+ EXPECT_EQ(border.top(), text_bounds.y());
EXPECT_EQ(center_bounds.width(), text_bounds.width());
- EXPECT_EQ(center_bounds.height(), text_bounds.height());
-#if defined(OS_WIN)
- EXPECT_EQ(gfx::Canvas::MULTI_LINE | gfx::Canvas::TEXT_ALIGN_CENTER, flags);
-#else
- EXPECT_EQ(
- gfx::Canvas::MULTI_LINE |
- gfx::Canvas::TEXT_ALIGN_CENTER |
- gfx::Canvas::NO_ELLIPSIS,
- flags);
+ EXPECT_EQ(label.GetContentsBounds().height(), text_bounds.height());
+ EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
+ EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_CENTER & flags);
+#if !defined(OS_WIN)
+ EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
#endif
label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
EXPECT_EQ(border.left() + extra.width(), text_bounds.x());
- EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
+ EXPECT_EQ(border.top(), text_bounds.y());
EXPECT_EQ(center_bounds.width(), text_bounds.width());
- EXPECT_EQ(center_bounds.height(), text_bounds.height());
-#if defined(OS_WIN)
- EXPECT_EQ(gfx::Canvas::MULTI_LINE | gfx::Canvas::TEXT_ALIGN_RIGHT, flags);
-#else
- EXPECT_EQ(
- gfx::Canvas::MULTI_LINE |
- gfx::Canvas::TEXT_ALIGN_RIGHT |
- gfx::Canvas::NO_ELLIPSIS,
- flags);
+ EXPECT_EQ(label.GetContentsBounds().height(), text_bounds.height());
+ EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
+ EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_RIGHT & flags);
+#if !defined(OS_WIN)
+ EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
#endif
label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
paint_text.clear();
text_bounds.SetRect(0, 0, 0, 0);
label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
- EXPECT_EQ(test_text, paint_text);
+ EXPECT_EQ(label.text(), paint_text);
EXPECT_EQ(border.left(), text_bounds.x());
- EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
+ EXPECT_EQ(border.top(), text_bounds.y());
EXPECT_EQ(center_bounds.width(), text_bounds.width());
- EXPECT_EQ(center_bounds.height(), text_bounds.height());
-#if defined(OS_WIN)
- EXPECT_EQ(gfx::Canvas::MULTI_LINE | gfx::Canvas::TEXT_ALIGN_LEFT, flags);
-#else
- EXPECT_EQ(
- gfx::Canvas::MULTI_LINE |
- gfx::Canvas::TEXT_ALIGN_LEFT |
- gfx::Canvas::NO_ELLIPSIS,
- flags);
+ EXPECT_EQ(label.GetContentsBounds().height(), text_bounds.height());
+ EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
+ EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_LEFT & flags);
+#if !defined(OS_WIN)
+ EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
#endif
// Reset Locale
base::i18n::SetICUDefaultLocale(locale);
}
-// Check that we disable subpixel rendering when a transparent background is
-// being used.
-TEST(LabelTest, DisableSubpixelRendering) {
+// Ensure the subpixel rendering flag and background color alpha are respected.
+TEST_F(LabelTest, DisableSubpixelRendering) {
Label label;
label.SetBackgroundColor(SK_ColorWHITE);
- EXPECT_EQ(
- 0, label.ComputeDrawStringFlags() & gfx::Canvas::NO_SUBPIXEL_RENDERING);
-
+ const int flag = gfx::Canvas::NO_SUBPIXEL_RENDERING;
+ EXPECT_EQ(0, label.ComputeDrawStringFlags() & flag);
+ label.SetSubpixelRenderingEnabled(false);
+ EXPECT_EQ(flag, label.ComputeDrawStringFlags() & flag);
+ label.SetSubpixelRenderingEnabled(true);
+ EXPECT_EQ(0, label.ComputeDrawStringFlags() & flag);
+ // Text cannot be drawn with subpixel rendering on transparent backgrounds.
label.SetBackgroundColor(SkColorSetARGB(64, 255, 255, 255));
- EXPECT_EQ(
- gfx::Canvas::NO_SUBPIXEL_RENDERING,
- label.ComputeDrawStringFlags() & gfx::Canvas::NO_SUBPIXEL_RENDERING);
+ EXPECT_EQ(flag, label.ComputeDrawStringFlags() & flag);
}
// Check that labels support GetTooltipHandlerForPoint.
-TEST(LabelTest, GetTooltipHandlerForPoint) {
+TEST_F(LabelTest, GetTooltipHandlerForPoint) {
+ // A root view must be defined for this test because the hit-testing
+ // behaviour used by GetTooltipHandlerForPoint() is defined by
+ // the ViewTargeter installed on the root view.
+ Widget widget;
+ Widget::InitParams init_params =
+ CreateParams(Widget::InitParams::TYPE_POPUP);
+ init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+ init_params.bounds = gfx::Rect(0, 0, 200, 200);
+ widget.Init(init_params);
+
Label label;
label.SetText(
ASCIIToUTF16("A string that's long enough to exceed the bounds"));
label.SetBounds(0, 0, 10, 10);
+ widget.SetContentsView(&label);
+
// There's a default tooltip if the text is too big to fit.
EXPECT_EQ(&label, label.GetTooltipHandlerForPoint(gfx::Point(2, 2)));
projects / platform / framework / web / crosswalk.git / blobdiff