ui/views/controls/label_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/views/controls/label.h"
   6
   7 #include "base/i18n/rtl.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "ui/accessibility/ax_view_state.h"
  11 #include "ui/base/l10n/l10n_util.h"
  12 #include "ui/gfx/canvas.h"
  13 #include "ui/views/border.h"
  14
  15 using base::ASCIIToUTF16;
  16
  17 namespace views {
  18
  19 // All text sizing measurements (width and height) should be greater than this.
  20 const int kMinTextDimension = 4;
  21
  22 // A test utility function to set the application default text direction.
  23 void SetRTL(bool rtl) {
  24   // Override the current locale/direction.
  25   base::i18n::SetICUDefaultLocale(rtl ? "he" : "en");
  26   EXPECT_EQ(rtl, base::i18n::IsRTL());
  27 }
  28
  29 TEST(LabelTest, FontPropertySymbol) {
  30   Label label;
  31   std::string font_name("symbol");
  32   gfx::Font font(font_name, 26);
  33   label.SetFontList(gfx::FontList(font));
  34   gfx::Font font_used = label.font_list().GetPrimaryFont();
  35   EXPECT_EQ(font_name, font_used.GetFontName());
  36   EXPECT_EQ(26, font_used.GetFontSize());
  37 }
  38
  39 TEST(LabelTest, FontPropertyArial) {
  40   Label label;
  41   std::string font_name("arial");
  42   gfx::Font font(font_name, 30);
  43   label.SetFontList(gfx::FontList(font));
  44   gfx::Font font_used = label.font_list().GetPrimaryFont();
  45   EXPECT_EQ(font_name, font_used.GetFontName());
  46   EXPECT_EQ(30, font_used.GetFontSize());
  47 }
  48
  49 TEST(LabelTest, TextProperty) {
  50   Label label;
  51   base::string16 test_text(ASCIIToUTF16("A random string."));
  52   label.SetText(test_text);
  53   EXPECT_EQ(test_text, label.text());
  54 }
  55
  56 TEST(LabelTest, ColorProperty) {
  57   Label label;
  58   SkColor color = SkColorSetARGB(20, 40, 10, 5);
  59   label.SetAutoColorReadabilityEnabled(false);
  60   label.SetEnabledColor(color);
  61   EXPECT_EQ(color, label.enabled_color());
  62 }
  63
  64 TEST(LabelTest, AlignmentProperty) {
  65   const bool was_rtl = base::i18n::IsRTL();
  66
  67   Label label;
  68   for (size_t i = 0; i < 2; ++i) {
  69     // Toggle the application default text direction (to try each direction).
  70     SetRTL(!base::i18n::IsRTL());
  71     bool reverse_alignment = base::i18n::IsRTL();
  72
  73     // The alignment should be flipped in RTL UI.
  74     label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
  75     EXPECT_EQ(reverse_alignment ? gfx::ALIGN_LEFT : gfx::ALIGN_RIGHT,
  76               label.GetHorizontalAlignment());
  77     label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
  78     EXPECT_EQ(reverse_alignment ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT,
  79               label.GetHorizontalAlignment());
  80     label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
  81     EXPECT_EQ(gfx::ALIGN_CENTER, label.GetHorizontalAlignment());
  82
  83     for (size_t j = 0; j < 2; ++j) {
  84       label.SetHorizontalAlignment(gfx::ALIGN_TO_HEAD);
  85       const bool rtl = j == 0;
  86       label.SetText(rtl ? base::WideToUTF16(L"\x5d0") : ASCIIToUTF16("A"));
  87       EXPECT_EQ(rtl ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT,
  88                 label.GetHorizontalAlignment());
  89     }
  90   }
  91
  92   EXPECT_EQ(was_rtl, base::i18n::IsRTL());
  93 }
  94
  95 TEST(LabelTest, DirectionalityModeProperty) {
  96   Label label;
  97   EXPECT_EQ(gfx::DIRECTIONALITY_FROM_UI, label.directionality_mode());
  98
  99   label.set_directionality_mode(gfx::DIRECTIONALITY_FROM_TEXT);
 100   EXPECT_EQ(gfx::DIRECTIONALITY_FROM_TEXT, label.directionality_mode());
 101
 102   label.set_directionality_mode(gfx::DIRECTIONALITY_FROM_UI);
 103   EXPECT_EQ(gfx::DIRECTIONALITY_FROM_UI, label.directionality_mode());
 104 }
 105
 106 TEST(LabelTest, MultiLineProperty) {
 107   Label label;
 108   EXPECT_FALSE(label.is_multi_line());
 109   label.SetMultiLine(true);
 110   EXPECT_TRUE(label.is_multi_line());
 111   label.SetMultiLine(false);
 112   EXPECT_FALSE(label.is_multi_line());
 113 }
 114
 115 TEST(LabelTest, ObscuredProperty) {
 116   Label label;
 117   base::string16 test_text(ASCIIToUTF16("Password!"));
 118   label.SetText(test_text);
 119
 120   // Should be false by default...
 121   EXPECT_FALSE(label.is_obscured());
 122   EXPECT_EQ(test_text, label.layout_text());
 123   EXPECT_EQ(test_text, label.text());
 124
 125   label.SetObscured(true);
 126   EXPECT_TRUE(label.is_obscured());
 127   EXPECT_EQ(ASCIIToUTF16("*********"), label.layout_text());
 128   EXPECT_EQ(test_text, label.text());
 129
 130   label.SetText(test_text + test_text);
 131   EXPECT_EQ(ASCIIToUTF16("******************"), label.layout_text());
 132   EXPECT_EQ(test_text + test_text, label.text());
 133
 134   label.SetObscured(false);
 135   EXPECT_FALSE(label.is_obscured());
 136   EXPECT_EQ(test_text + test_text, label.layout_text());
 137   EXPECT_EQ(test_text + test_text, label.text());
 138 }
 139
 140 TEST(LabelTest, ObscuredSurrogatePair) {
 141   // 'MUSICAL SYMBOL G CLEF': represented in UTF-16 as two characters
 142   // forming the surrogate pair 0x0001D11E.
 143   Label label;
 144   base::string16 test_text = base::UTF8ToUTF16("\xF0\x9D\x84\x9E");
 145   label.SetText(test_text);
 146
 147   label.SetObscured(true);
 148   EXPECT_EQ(ASCIIToUTF16("*"), label.layout_text());
 149   EXPECT_EQ(test_text, label.text());
 150 }
 151
 152 TEST(LabelTest, TooltipProperty) {
 153   Label label;
 154   label.SetText(ASCIIToUTF16("My cool string."));
 155
 156   base::string16 tooltip;
 157   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
 158   EXPECT_EQ(label.text(), tooltip);
 159
 160   base::string16 tooltip_text(ASCIIToUTF16("The tooltip!"));
 161   label.SetTooltipText(tooltip_text);
 162   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
 163   EXPECT_EQ(tooltip_text, tooltip);
 164
 165   label.SetTooltipText(base::string16());
 166   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
 167   EXPECT_EQ(label.text(), tooltip);
 168
 169   // Make the label big enough to hold the text
 170   // and expect there to be no tooltip.
 171   label.SetBounds(0, 0, 1000, 40);
 172   EXPECT_FALSE(label.GetTooltipText(gfx::Point(), &tooltip));
 173
 174   // Verify that setting the tooltip still shows it.
 175   label.SetTooltipText(tooltip_text);
 176   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
 177   EXPECT_EQ(tooltip_text, tooltip);
 178   // Clear out the tooltip.
 179   label.SetTooltipText(base::string16());
 180
 181   // Shrink the bounds and the tooltip should come back.
 182   label.SetBounds(0, 0, 1, 1);
 183   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
 184
 185   // Make the label obscured and there is no tooltip.
 186   label.SetObscured(true);
 187   EXPECT_FALSE(label.GetTooltipText(gfx::Point(), &tooltip));
 188
 189   // Obscuring the text shouldn't permanently clobber the tooltip.
 190   label.SetObscured(false);
 191   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
 192
 193   // Make the label multiline and there is no tooltip.
 194   label.SetMultiLine(true);
 195   EXPECT_FALSE(label.GetTooltipText(gfx::Point(), &tooltip));
 196
 197   // Verify that setting the tooltip still shows it.
 198   label.SetTooltipText(tooltip_text);
 199   EXPECT_TRUE(label.GetTooltipText(gfx::Point(), &tooltip));
 200   EXPECT_EQ(tooltip_text, tooltip);
 201   // Clear out the tooltip.
 202   label.SetTooltipText(base::string16());
 203 }
 204
 205 TEST(LabelTest, Accessibility) {
 206   Label label;
 207   label.SetText(ASCIIToUTF16("My special text."));
 208
 209   ui::AXViewState state;
 210   label.GetAccessibleState(&state);
 211   EXPECT_EQ(ui::AX_ROLE_STATIC_TEXT, state.role);
 212   EXPECT_EQ(label.text(), state.name);
 213   EXPECT_TRUE(state.HasStateFlag(ui::AX_STATE_READ_ONLY));
 214 }
 215
 216 TEST(LabelTest, SingleLineSizing) {
 217   Label label;
 218   label.SetText(ASCIIToUTF16("A not so random string in one line."));
 219
 220   // GetPreferredSize
 221   gfx::Size required_size = label.GetPreferredSize();
 222   EXPECT_GT(required_size.height(), kMinTextDimension);
 223   EXPECT_GT(required_size.width(), kMinTextDimension);
 224
 225   // Test everything with borders.
 226   gfx::Insets border(10, 20, 30, 40);
 227   label.SetBorder(Border::CreateEmptyBorder(
 228       border.top(), border.left(), border.bottom(), border.right()));
 229
 230   // GetPreferredSize and borders.
 231   label.SetBounds(0, 0, 0, 0);
 232   gfx::Size required_size_with_border = label.GetPreferredSize();
 233   EXPECT_EQ(required_size_with_border.height(),
 234             required_size.height() + border.height());
 235   EXPECT_EQ(required_size_with_border.width(),
 236             required_size.width() + border.width());
 237 }
 238
 239 TEST(LabelTest, MultilineSmallAvailableWidthSizing) {
 240   Label label;
 241   label.SetMultiLine(true);
 242   label.SetAllowCharacterBreak(true);
 243   label.SetText(ASCIIToUTF16("Too Wide."));
 244
 245   // Check that Label can be laid out at a variety of small sizes,
 246   // splitting the words into up to one character per line if necessary.
 247   // Incorrect word splitting may cause infinite loops in text layout.
 248   gfx::Size required_size = label.GetPreferredSize();
 249   for (int i = 1; i < required_size.width(); ++i)
 250     EXPECT_GT(label.GetHeightForWidth(i), 0);
 251 }
 252
 253 TEST(LabelTest, MultiLineSizing) {
 254   Label label;
 255   label.SetFocusable(false);
 256   label.SetText(
 257       ASCIIToUTF16("A random string\nwith multiple lines\nand returns!"));
 258   label.SetMultiLine(true);
 259
 260   // GetPreferredSize
 261   gfx::Size required_size = label.GetPreferredSize();
 262   EXPECT_GT(required_size.height(), kMinTextDimension);
 263   EXPECT_GT(required_size.width(), kMinTextDimension);
 264
 265   // SizeToFit with unlimited width.
 266   label.SizeToFit(0);
 267   int required_width = label.GetLocalBounds().width();
 268   EXPECT_GT(required_width, kMinTextDimension);
 269
 270   // SizeToFit with limited width.
 271   label.SizeToFit(required_width - 1);
 272   int constrained_width = label.GetLocalBounds().width();
 273 #if defined(OS_WIN)
 274   // Canvas::SizeStringInt (in ui/gfx/canvas_linux.cc)
 275   // has to be fixed to return the size that fits to given width/height.
 276   EXPECT_LT(constrained_width, required_width);
 277 #endif
 278   EXPECT_GT(constrained_width, kMinTextDimension);
 279
 280   // Change the width back to the desire width.
 281   label.SizeToFit(required_width);
 282   EXPECT_EQ(required_width, label.GetLocalBounds().width());
 283
 284   // General tests for GetHeightForWidth.
 285   int required_height = label.GetHeightForWidth(required_width);
 286   EXPECT_GT(required_height, kMinTextDimension);
 287   int height_for_constrained_width = label.GetHeightForWidth(constrained_width);
 288 #if defined(OS_WIN)
 289   // Canvas::SizeStringInt (in ui/gfx/canvas_linux.cc)
 290   // has to be fixed to return the size that fits to given width/height.
 291   EXPECT_GT(height_for_constrained_width, required_height);
 292 #endif
 293   // Using the constrained width or the required_width - 1 should give the
 294   // same result for the height because the constrainted width is the tight
 295   // width when given "required_width - 1" as the max width.
 296   EXPECT_EQ(height_for_constrained_width,
 297             label.GetHeightForWidth(required_width - 1));
 298
 299   // Test everything with borders.
 300   gfx::Insets border(10, 20, 30, 40);
 301   label.SetBorder(Border::CreateEmptyBorder(
 302       border.top(), border.left(), border.bottom(), border.right()));
 303
 304   // SizeToFit and borders.
 305   label.SizeToFit(0);
 306   int required_width_with_border = label.GetLocalBounds().width();
 307   EXPECT_EQ(required_width_with_border, required_width + border.width());
 308
 309   // GetHeightForWidth and borders.
 310   int required_height_with_border =
 311       label.GetHeightForWidth(required_width_with_border);
 312   EXPECT_EQ(required_height_with_border, required_height + border.height());
 313
 314   // Test that the border width is subtracted before doing the height
 315   // calculation.  If it is, then the height will grow when width
 316   // is shrunk.
 317   int height1 = label.GetHeightForWidth(required_width_with_border - 1);
 318 #if defined(OS_WIN)
 319   // Canvas::SizeStringInt (in ui/gfx/canvas_linux.cc)
 320   // has to be fixed to return the size that fits to given width/height.
 321   EXPECT_GT(height1, required_height_with_border);
 322 #endif
 323   EXPECT_EQ(height1, height_for_constrained_width + border.height());
 324
 325   // GetPreferredSize and borders.
 326   label.SetBounds(0, 0, 0, 0);
 327   gfx::Size required_size_with_border = label.GetPreferredSize();
 328   EXPECT_EQ(required_size_with_border.height(),
 329             required_size.height() + border.height());
 330   EXPECT_EQ(required_size_with_border.width(),
 331             required_size.width() + border.width());
 332 }
 333
 334 TEST(LabelTest, DirectionalityFromText) {
 335   Label label;
 336   label.set_directionality_mode(gfx::DIRECTIONALITY_FROM_TEXT);
 337   label.SetBounds(0, 0, 1000, 1000);
 338   base::string16 paint_text;
 339   gfx::Rect text_bounds;
 340   int flags = -1;
 341
 342   // Test text starts with RTL character.
 343   label.SetText(base::WideToUTF16(L"  \x5d0\x5d1\x5d2 abc"));
 344   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 345   EXPECT_EQ(gfx::Canvas::FORCE_RTL_DIRECTIONALITY,
 346             flags & (gfx::Canvas::FORCE_RTL_DIRECTIONALITY |
 347                      gfx::Canvas::FORCE_LTR_DIRECTIONALITY));
 348
 349   // Test text starts with LTR character.
 350   label.SetText(base::WideToUTF16(L"ltr \x5d0\x5d1\x5d2 abc"));
 351   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 352   EXPECT_EQ(gfx::Canvas::FORCE_LTR_DIRECTIONALITY,
 353             flags & (gfx::Canvas::FORCE_RTL_DIRECTIONALITY |
 354                      gfx::Canvas::FORCE_LTR_DIRECTIONALITY));
 355 }
 356
 357 TEST(LabelTest, DrawSingleLineString) {
 358   Label label;
 359   label.SetFocusable(false);
 360   // Force a directionality to simplify alignment value testing.
 361   label.set_directionality_mode(gfx::DIRECTIONALITY_FORCE_LTR);
 362
 363   label.SetText(ASCIIToUTF16("Here's a string with no returns."));
 364   gfx::Size required_size(label.GetPreferredSize());
 365   gfx::Size extra(22, 8);
 366   label.SetBounds(0, 0, required_size.width() + extra.width(),
 367                   required_size.height() + extra.height());
 368
 369   // Do some basic verifications for all three alignments.
 370   base::string16 paint_text;
 371   gfx::Rect text_bounds;
 372   int flags = -1;
 373
 374   // Centered text.
 375   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 376   EXPECT_EQ(label.text(), paint_text);
 377   // The text should be centered horizontally and vertically.
 378   EXPECT_EQ(extra.width() / 2, text_bounds.x());
 379   EXPECT_EQ(extra.height() / 2 , text_bounds.y());
 380   EXPECT_EQ(required_size.width(), text_bounds.width());
 381   EXPECT_EQ(required_size.height(), text_bounds.height());
 382   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
 383             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
 384                      gfx::Canvas::TEXT_ALIGN_CENTER |
 385                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 386
 387   // Left aligned text.
 388   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
 389   paint_text.clear();
 390   text_bounds.SetRect(0, 0, 0, 0);
 391   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 392   EXPECT_EQ(label.text(), paint_text);
 393   // The text should be left aligned horizontally and centered vertically.
 394   EXPECT_EQ(0, text_bounds.x());
 395   EXPECT_EQ(extra.height() / 2 , text_bounds.y());
 396   EXPECT_EQ(required_size.width(), text_bounds.width());
 397   EXPECT_EQ(required_size.height(), text_bounds.height());
 398   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
 399             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
 400                      gfx::Canvas::TEXT_ALIGN_CENTER |
 401                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 402
 403   // Right aligned text.
 404   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
 405   paint_text.clear();
 406   text_bounds.SetRect(0, 0, 0, 0);
 407   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 408   EXPECT_EQ(label.text(), paint_text);
 409   // The text should be right aligned horizontally and centered vertically.
 410   EXPECT_EQ(extra.width(), text_bounds.x());
 411   EXPECT_EQ(extra.height() / 2 , text_bounds.y());
 412   EXPECT_EQ(required_size.width(), text_bounds.width());
 413   EXPECT_EQ(required_size.height(), text_bounds.height());
 414   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
 415             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
 416                      gfx::Canvas::TEXT_ALIGN_CENTER |
 417                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 418
 419   // Test single line drawing with a border.
 420   gfx::Insets border(39, 34, 8, 96);
 421   label.SetBorder(Border::CreateEmptyBorder(
 422       border.top(), border.left(), border.bottom(), border.right()));
 423
 424   gfx::Size required_size_with_border(label.GetPreferredSize());
 425   EXPECT_EQ(required_size.width() + border.width(),
 426             required_size_with_border.width());
 427   EXPECT_EQ(required_size.height() + border.height(),
 428             required_size_with_border.height());
 429   label.SetBounds(0, 0, required_size_with_border.width() + extra.width(),
 430                   required_size_with_border.height() + extra.height());
 431
 432   // Centered text with border.
 433   label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
 434   paint_text.clear();
 435   text_bounds.SetRect(0, 0, 0, 0);
 436   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 437   EXPECT_EQ(label.text(), paint_text);
 438   // The text should be centered horizontally and vertically within the border.
 439   EXPECT_EQ(border.left() + extra.width() / 2, text_bounds.x());
 440   EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
 441   EXPECT_EQ(required_size.width(), text_bounds.width());
 442   EXPECT_EQ(required_size.height(), text_bounds.height());
 443   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
 444             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
 445                      gfx::Canvas::TEXT_ALIGN_CENTER |
 446                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 447
 448   // Left aligned text with border.
 449   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
 450   paint_text.clear();
 451   text_bounds.SetRect(0, 0, 0, 0);
 452   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 453   EXPECT_EQ(label.text(), paint_text);
 454   // The text should be left aligned horizontally and centered vertically.
 455   EXPECT_EQ(border.left(), text_bounds.x());
 456   EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
 457   EXPECT_EQ(required_size.width(), text_bounds.width());
 458   EXPECT_EQ(required_size.height(), text_bounds.height());
 459   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
 460             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
 461                      gfx::Canvas::TEXT_ALIGN_CENTER |
 462                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 463
 464   // Right aligned text.
 465   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
 466   paint_text.clear();
 467   text_bounds.SetRect(0, 0, 0, 0);
 468   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 469   EXPECT_EQ(label.text(), paint_text);
 470   // The text should be right aligned horizontally and centered vertically.
 471   EXPECT_EQ(border.left() + extra.width(), text_bounds.x());
 472   EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
 473   EXPECT_EQ(required_size.width(), text_bounds.width());
 474   EXPECT_EQ(required_size.height(), text_bounds.height());
 475   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
 476             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
 477                      gfx::Canvas::TEXT_ALIGN_CENTER |
 478                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 479 }
 480
 481 // Pango needs a max height to elide multiline text; that is not supported here.
 482 TEST(LabelTest, DrawMultiLineString) {
 483   Label label;
 484   label.SetFocusable(false);
 485   // Force a directionality to simplify alignment value testing.
 486   label.set_directionality_mode(gfx::DIRECTIONALITY_FORCE_LTR);
 487   // Set a background color to prevent gfx::Canvas::NO_SUBPIXEL_RENDERING flags.
 488   label.SetBackgroundColor(SK_ColorWHITE);
 489
 490   label.SetText(ASCIIToUTF16("Another string\nwith returns\n\n!"));
 491   label.SetMultiLine(true);
 492   label.SizeToFit(0);
 493   gfx::Size extra(50, 10);
 494   label.SetBounds(label.x(), label.y(),
 495                   label.width() + extra.width(),
 496                   label.height() + extra.height());
 497
 498   // Do some basic verifications for all three alignments.
 499   base::string16 paint_text;
 500   gfx::Rect text_bounds;
 501   int flags = -1;
 502   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 503   EXPECT_EQ(label.text(), paint_text);
 504   EXPECT_EQ(extra.width() / 2, text_bounds.x());
 505   EXPECT_EQ(extra.height() / 2, text_bounds.y());
 506   EXPECT_GT(text_bounds.width(), kMinTextDimension);
 507   EXPECT_GT(text_bounds.height(), kMinTextDimension);
 508   int expected_flags = gfx::Canvas::MULTI_LINE |
 509                        gfx::Canvas::TEXT_ALIGN_CENTER |
 510                        gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
 511 #if !defined(OS_WIN)
 512   expected_flags |= gfx::Canvas::NO_ELLIPSIS;
 513 #endif
 514   EXPECT_EQ(expected_flags, expected_flags);
 515   gfx::Rect center_bounds(text_bounds);
 516
 517   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
 518   paint_text.clear();
 519   text_bounds.SetRect(0, 0, 0, 0);
 520   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 521   EXPECT_EQ(label.text(), paint_text);
 522   EXPECT_EQ(0, text_bounds.x());
 523   EXPECT_EQ(extra.height() / 2, text_bounds.y());
 524   EXPECT_GT(text_bounds.width(), kMinTextDimension);
 525   EXPECT_GT(text_bounds.height(), kMinTextDimension);
 526   expected_flags = gfx::Canvas::MULTI_LINE |
 527                    gfx::Canvas::TEXT_ALIGN_LEFT |
 528                    gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
 529 #if !defined(OS_WIN)
 530   expected_flags |= gfx::Canvas::NO_ELLIPSIS;
 531 #endif
 532   EXPECT_EQ(expected_flags, expected_flags);
 533
 534   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
 535   paint_text.clear();
 536   text_bounds.SetRect(0, 0, 0, 0);
 537   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 538   EXPECT_EQ(label.text(), paint_text);
 539   EXPECT_EQ(extra.width(), text_bounds.x());
 540   EXPECT_EQ(extra.height() / 2, text_bounds.y());
 541   EXPECT_GT(text_bounds.width(), kMinTextDimension);
 542   EXPECT_GT(text_bounds.height(), kMinTextDimension);
 543   expected_flags = gfx::Canvas::MULTI_LINE |
 544                    gfx::Canvas::TEXT_ALIGN_RIGHT |
 545                    gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
 546 #if !defined(OS_WIN)
 547   expected_flags |= gfx::Canvas::NO_ELLIPSIS;
 548 #endif
 549   EXPECT_EQ(expected_flags, expected_flags);
 550
 551   // Test multiline drawing with a border.
 552   gfx::Insets border(19, 92, 23, 2);
 553   label.SetBorder(Border::CreateEmptyBorder(
 554       border.top(), border.left(), border.bottom(), border.right()));
 555   label.SizeToFit(0);
 556   label.SetBounds(label.x(), label.y(),
 557                   label.width() + extra.width(),
 558                   label.height() + extra.height());
 559
 560   label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
 561   paint_text.clear();
 562   text_bounds.SetRect(0, 0, 0, 0);
 563   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 564   EXPECT_EQ(label.text(), paint_text);
 565   EXPECT_EQ(border.left() + extra.width() / 2, text_bounds.x());
 566   EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
 567   EXPECT_EQ(center_bounds.width(), text_bounds.width());
 568   EXPECT_EQ(center_bounds.height(), text_bounds.height());
 569   expected_flags = gfx::Canvas::MULTI_LINE |
 570                    gfx::Canvas::TEXT_ALIGN_CENTER |
 571                    gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
 572 #if !defined(OS_WIN)
 573   expected_flags |= gfx::Canvas::NO_ELLIPSIS;
 574 #endif
 575   EXPECT_EQ(expected_flags, expected_flags);
 576
 577   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
 578   paint_text.clear();
 579   text_bounds.SetRect(0, 0, 0, 0);
 580   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 581   EXPECT_EQ(label.text(), paint_text);
 582   EXPECT_EQ(border.left(), text_bounds.x());
 583   EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
 584   EXPECT_EQ(center_bounds.width(), text_bounds.width());
 585   EXPECT_EQ(center_bounds.height(), text_bounds.height());
 586   expected_flags = gfx::Canvas::MULTI_LINE |
 587                    gfx::Canvas::TEXT_ALIGN_LEFT |
 588                    gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
 589 #if !defined(OS_WIN)
 590   expected_flags |= gfx::Canvas::NO_ELLIPSIS;
 591 #endif
 592   EXPECT_EQ(expected_flags, expected_flags);
 593
 594   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
 595   paint_text.clear();
 596   text_bounds.SetRect(0, 0, 0, 0);
 597   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 598   EXPECT_EQ(label.text(), paint_text);
 599   EXPECT_EQ(extra.width() + border.left(), text_bounds.x());
 600   EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
 601   EXPECT_EQ(center_bounds.width(), text_bounds.width());
 602   EXPECT_EQ(center_bounds.height(), text_bounds.height());
 603   expected_flags = gfx::Canvas::MULTI_LINE |
 604                    gfx::Canvas::TEXT_ALIGN_RIGHT |
 605                    gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
 606 #if !defined(OS_WIN)
 607   expected_flags |= gfx::Canvas::NO_ELLIPSIS;
 608 #endif
 609   EXPECT_EQ(expected_flags, expected_flags);
 610 }
 611
 612 TEST(LabelTest, DrawSingleLineStringInRTL) {
 613   Label label;
 614   label.SetFocusable(false);
 615
 616   std::string locale = l10n_util::GetApplicationLocale("");
 617   base::i18n::SetICUDefaultLocale("he");
 618
 619   label.SetText(ASCIIToUTF16("Here's a string with no returns."));
 620   gfx::Size required_size(label.GetPreferredSize());
 621   gfx::Size extra(22, 8);
 622   label.SetBounds(0, 0, required_size.width() + extra.width(),
 623                   required_size.height() + extra.height());
 624
 625   // Do some basic verifications for all three alignments.
 626   base::string16 paint_text;
 627   gfx::Rect text_bounds;
 628   int flags = -1;
 629
 630   // Centered text.
 631   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 632   EXPECT_EQ(label.text(), paint_text);
 633   // The text should be centered horizontally and vertically.
 634   EXPECT_EQ(extra.width() / 2, text_bounds.x());
 635   EXPECT_EQ(extra.height() / 2 , text_bounds.y());
 636   EXPECT_EQ(required_size.width(), text_bounds.width());
 637   EXPECT_EQ(required_size.height(), text_bounds.height());
 638   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
 639             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
 640                      gfx::Canvas::TEXT_ALIGN_CENTER |
 641                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 642
 643   // ALIGN_LEFT label.
 644   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
 645   paint_text.clear();
 646   text_bounds.SetRect(0, 0, 0, 0);
 647   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 648   EXPECT_EQ(label.text(), paint_text);
 649   // The text should be right aligned horizontally and centered vertically.
 650   EXPECT_EQ(extra.width(), text_bounds.x());
 651   EXPECT_EQ(extra.height() / 2 , text_bounds.y());
 652   EXPECT_EQ(required_size.width(), text_bounds.width());
 653   EXPECT_EQ(required_size.height(), text_bounds.height());
 654   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
 655             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
 656                      gfx::Canvas::TEXT_ALIGN_CENTER |
 657                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 658
 659   // ALIGN_RIGHT label.
 660   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
 661   paint_text.clear();
 662   text_bounds.SetRect(0, 0, 0, 0);
 663   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 664   EXPECT_EQ(label.text(), paint_text);
 665   // The text should be left aligned horizontally and centered vertically.
 666   EXPECT_EQ(0, text_bounds.x());
 667   EXPECT_EQ(extra.height() / 2 , text_bounds.y());
 668   EXPECT_EQ(required_size.width(), text_bounds.width());
 669   EXPECT_EQ(required_size.height(), text_bounds.height());
 670   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
 671             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
 672                      gfx::Canvas::TEXT_ALIGN_CENTER |
 673                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 674
 675
 676   // Test single line drawing with a border.
 677   gfx::Insets border(39, 34, 8, 96);
 678   label.SetBorder(Border::CreateEmptyBorder(
 679       border.top(), border.left(), border.bottom(), border.right()));
 680
 681   gfx::Size required_size_with_border(label.GetPreferredSize());
 682   EXPECT_EQ(required_size.width() + border.width(),
 683             required_size_with_border.width());
 684   EXPECT_EQ(required_size.height() + border.height(),
 685             required_size_with_border.height());
 686   label.SetBounds(0, 0, required_size_with_border.width() + extra.width(),
 687                   required_size_with_border.height() + extra.height());
 688
 689   // Centered text with border.
 690   label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
 691   paint_text.clear();
 692   text_bounds.SetRect(0, 0, 0, 0);
 693   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 694   EXPECT_EQ(label.text(), paint_text);
 695   // The text should be centered horizontally and vertically within the border.
 696   EXPECT_EQ(border.left() + extra.width() / 2, text_bounds.x());
 697   EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
 698   EXPECT_EQ(required_size.width(), text_bounds.width());
 699   EXPECT_EQ(required_size.height(), text_bounds.height());
 700   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_CENTER,
 701             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
 702                      gfx::Canvas::TEXT_ALIGN_CENTER |
 703                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 704
 705   // ALIGN_LEFT text with border.
 706   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
 707   paint_text.clear();
 708   text_bounds.SetRect(0, 0, 0, 0);
 709   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 710   EXPECT_EQ(label.text(), paint_text);
 711   // The text should be right aligned horizontally and centered vertically.
 712   EXPECT_EQ(border.left() + extra.width(), text_bounds.x());
 713   EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
 714   EXPECT_EQ(required_size.width(), text_bounds.width());
 715   EXPECT_EQ(required_size.height(), text_bounds.height());
 716   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_RIGHT,
 717             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
 718                      gfx::Canvas::TEXT_ALIGN_CENTER |
 719                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 720
 721   // ALIGN_RIGHT text.
 722   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
 723   paint_text.clear();
 724   text_bounds.SetRect(0, 0, 0, 0);
 725   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 726   EXPECT_EQ(label.text(), paint_text);
 727   // The text should be left aligned horizontally and centered vertically.
 728   EXPECT_EQ(border.left(), text_bounds.x());
 729   EXPECT_EQ(border.top() + extra.height() / 2 , text_bounds.y());
 730   EXPECT_EQ(required_size.width(), text_bounds.width());
 731   EXPECT_EQ(required_size.height(), text_bounds.height());
 732   EXPECT_EQ(gfx::Canvas::TEXT_ALIGN_LEFT,
 733             flags & (gfx::Canvas::TEXT_ALIGN_LEFT |
 734                      gfx::Canvas::TEXT_ALIGN_CENTER |
 735                      gfx::Canvas::TEXT_ALIGN_RIGHT));
 736
 737   // Reset locale.
 738   base::i18n::SetICUDefaultLocale(locale);
 739 }
 740
 741 // On Linux the underlying pango routines require a max height in order to
 742 // ellide multiline text. So until that can be resolved, we set all
 743 // multiline lables to not ellide in Linux only.
 744 TEST(LabelTest, DrawMultiLineStringInRTL) {
 745   Label label;
 746   label.SetFocusable(false);
 747
 748   // Test for RTL.
 749   std::string locale = l10n_util::GetApplicationLocale("");
 750   base::i18n::SetICUDefaultLocale("he");
 751
 752   label.SetText(ASCIIToUTF16("Another string\nwith returns\n\n!"));
 753   label.SetMultiLine(true);
 754   label.SizeToFit(0);
 755   gfx::Size extra(50, 10);
 756   label.SetBounds(label.x(), label.y(),
 757                   label.width() + extra.width(),
 758                   label.height() + extra.height());
 759
 760   // Do some basic verifications for all three alignments.
 761   base::string16 paint_text;
 762   gfx::Rect text_bounds;
 763   int flags = -1;
 764   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 765   EXPECT_EQ(label.text(), paint_text);
 766   EXPECT_EQ(extra.width() / 2, text_bounds.x());
 767   EXPECT_EQ(extra.height() / 2, text_bounds.y());
 768   EXPECT_GT(text_bounds.width(), kMinTextDimension);
 769   EXPECT_GT(text_bounds.height(), kMinTextDimension);
 770   EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
 771   EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_CENTER & flags);
 772 #if !defined(OS_WIN)
 773   EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
 774 #endif
 775   gfx::Rect center_bounds(text_bounds);
 776
 777   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
 778   paint_text.clear();
 779   text_bounds.SetRect(0, 0, 0, 0);
 780   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 781   EXPECT_EQ(label.text(), paint_text);
 782   EXPECT_EQ(extra.width(), text_bounds.x());
 783   EXPECT_EQ(extra.height() / 2, text_bounds.y());
 784   EXPECT_GT(text_bounds.width(), kMinTextDimension);
 785   EXPECT_GT(text_bounds.height(), kMinTextDimension);
 786   EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
 787   EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_RIGHT & flags);
 788 #if !defined(OS_WIN)
 789   EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
 790 #endif
 791
 792   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
 793   paint_text.clear();
 794   text_bounds.SetRect(0, 0, 0, 0);
 795   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 796   EXPECT_EQ(label.text(), paint_text);
 797   EXPECT_EQ(0, text_bounds.x());
 798   EXPECT_EQ(extra.height() / 2, text_bounds.y());
 799   EXPECT_GT(text_bounds.width(), kMinTextDimension);
 800   EXPECT_GT(text_bounds.height(), kMinTextDimension);
 801   EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
 802   EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_LEFT & flags);
 803 #if !defined(OS_WIN)
 804   EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
 805 #endif
 806
 807   // Test multiline drawing with a border.
 808   gfx::Insets border(19, 92, 23, 2);
 809   label.SetBorder(Border::CreateEmptyBorder(
 810       border.top(), border.left(), border.bottom(), border.right()));
 811   label.SizeToFit(0);
 812   label.SetBounds(label.x(), label.y(),
 813                   label.width() + extra.width(),
 814                   label.height() + extra.height());
 815
 816   label.SetHorizontalAlignment(gfx::ALIGN_CENTER);
 817   paint_text.clear();
 818   text_bounds.SetRect(0, 0, 0, 0);
 819   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 820   EXPECT_EQ(label.text(), paint_text);
 821   EXPECT_EQ(border.left() + extra.width() / 2, text_bounds.x());
 822   EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
 823   EXPECT_EQ(center_bounds.width(), text_bounds.width());
 824   EXPECT_EQ(center_bounds.height(), text_bounds.height());
 825   EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
 826   EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_CENTER & flags);
 827 #if !defined(OS_WIN)
 828   EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
 829 #endif
 830
 831   label.SetHorizontalAlignment(gfx::ALIGN_LEFT);
 832   paint_text.clear();
 833   text_bounds.SetRect(0, 0, 0, 0);
 834   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 835   EXPECT_EQ(label.text(), paint_text);
 836   EXPECT_EQ(border.left() + extra.width(), text_bounds.x());
 837   EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
 838   EXPECT_EQ(center_bounds.width(), text_bounds.width());
 839   EXPECT_EQ(center_bounds.height(), text_bounds.height());
 840   EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
 841   EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_RIGHT & flags);
 842 #if !defined(OS_WIN)
 843   EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
 844 #endif
 845
 846   label.SetHorizontalAlignment(gfx::ALIGN_RIGHT);
 847   paint_text.clear();
 848   text_bounds.SetRect(0, 0, 0, 0);
 849   label.CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 850   EXPECT_EQ(label.text(), paint_text);
 851   EXPECT_EQ(border.left(), text_bounds.x());
 852   EXPECT_EQ(border.top() + extra.height() / 2, text_bounds.y());
 853   EXPECT_EQ(center_bounds.width(), text_bounds.width());
 854   EXPECT_EQ(center_bounds.height(), text_bounds.height());
 855   EXPECT_TRUE(gfx::Canvas::MULTI_LINE & flags);
 856   EXPECT_TRUE(gfx::Canvas::TEXT_ALIGN_LEFT & flags);
 857 #if !defined(OS_WIN)
 858   EXPECT_TRUE(gfx::Canvas::NO_ELLIPSIS & flags);
 859 #endif
 860
 861   // Reset Locale
 862   base::i18n::SetICUDefaultLocale(locale);
 863 }
 864
 865 // Ensure the subpixel rendering flag and background color alpha are respected.
 866 TEST(LabelTest, DisableSubpixelRendering) {
 867   Label label;
 868   label.SetBackgroundColor(SK_ColorWHITE);
 869   const int flag = gfx::Canvas::NO_SUBPIXEL_RENDERING;
 870   EXPECT_EQ(0, label.ComputeDrawStringFlags() & flag);
 871   label.set_subpixel_rendering_enabled(false);
 872   EXPECT_EQ(flag, label.ComputeDrawStringFlags() & flag);
 873   label.set_subpixel_rendering_enabled(true);
 874   EXPECT_EQ(0, label.ComputeDrawStringFlags() & flag);
 875   // Text cannot be drawn with subpixel rendering on transparent backgrounds.
 876   label.SetBackgroundColor(SkColorSetARGB(64, 255, 255, 255));
 877   EXPECT_EQ(flag, label.ComputeDrawStringFlags() & flag);
 878 }
 879
 880 // Check that labels support GetTooltipHandlerForPoint.
 881 TEST(LabelTest, GetTooltipHandlerForPoint) {
 882   Label label;
 883   label.SetText(
 884       ASCIIToUTF16("A string that's long enough to exceed the bounds"));
 885   label.SetBounds(0, 0, 10, 10);
 886   // There's a default tooltip if the text is too big to fit.
 887   EXPECT_EQ(&label, label.GetTooltipHandlerForPoint(gfx::Point(2, 2)));
 888
 889   // If there's no default tooltip, this should return NULL.
 890   label.SetBounds(0, 0, 500, 50);
 891   EXPECT_FALSE(label.GetTooltipHandlerForPoint(gfx::Point(2, 2)));
 892
 893   label.SetTooltipText(ASCIIToUTF16("a tooltip"));
 894   // If the point hits the label, and tooltip is set, the label should be
 895   // returned as its tooltip handler.
 896   EXPECT_EQ(&label, label.GetTooltipHandlerForPoint(gfx::Point(2, 2)));
 897
 898   // Additionally, GetTooltipHandlerForPoint should verify that the label
 899   // actually contains the point.
 900   EXPECT_FALSE(label.GetTooltipHandlerForPoint(gfx::Point(2, 51)));
 901   EXPECT_FALSE(label.GetTooltipHandlerForPoint(gfx::Point(-1, 20)));
 902
 903   // GetTooltipHandlerForPoint works should work in child bounds.
 904   label.SetBounds(2, 2, 10, 10);
 905   EXPECT_EQ(&label, label.GetTooltipHandlerForPoint(gfx::Point(1, 5)));
 906   EXPECT_FALSE(label.GetTooltipHandlerForPoint(gfx::Point(3, 11)));
 907 }
 908
 909 }  // namespace views