src/ui/gfx/text_elider_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 // Unit tests for eliding and formatting utility functions.
   6
   7 #include "ui/gfx/text_elider.h"
   8
   9 #include "base/files/file_path.h"
  10 #include "base/i18n/rtl.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/strings/string_util.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "ui/gfx/font.h"
  16 #include "ui/gfx/font_list.h"
  17 #include "ui/gfx/text_utils.h"
  18
  19 using base::ASCIIToUTF16;
  20 using base::UTF16ToUTF8;
  21 using base::UTF16ToWide;
  22 using base::UTF8ToUTF16;
  23 using base::WideToUTF16;
  24
  25 namespace gfx {
  26
  27 namespace {
  28
  29 struct Testcase {
  30   const std::string input;
  31   const std::string output;
  32 };
  33
  34 struct FileTestcase {
  35   const base::FilePath::StringType input;
  36   const std::string output;
  37 };
  38
  39 struct UTF16Testcase {
  40   const base::string16 input;
  41   const base::string16 output;
  42 };
  43
  44 struct TestData {
  45   const std::string a;
  46   const std::string b;
  47   const int compare_result;
  48 };
  49
  50 }  // namespace
  51
  52 // TODO(ios): This test fails on iOS because iOS version of GetStringWidthF
  53 // that calls [NSString sizeWithFont] returns the rounded string width.
  54 // TODO(338784): Enable this on android.
  55 #if defined(OS_IOS) || defined(OS_ANDROID)
  56 #define MAYBE_ElideEmail DISABLED_ElideEmail
  57 #else
  58 #define MAYBE_ElideEmail ElideEmail
  59 #endif
  60 TEST(TextEliderTest, MAYBE_ElideEmail) {
  61   const std::string kEllipsisStr(kEllipsis);
  62
  63   // Test emails and their expected elided forms (from which the available
  64   // widths will be derived).
  65   // For elided forms in which both the username and domain must be elided:
  66   // the result (how many characters are left on each side) can be font
  67   // dependent. To avoid this, the username is prefixed with the characters
  68   // expected to remain in the domain.
  69   Testcase testcases[] = {
  70       {"g@g.c", "g@g.c"},
  71       {"g@g.c", kEllipsisStr},
  72       {"ga@co.ca", "ga@c" + kEllipsisStr + "a"},
  73       {"short@small.com", "s" + kEllipsisStr + "@s" + kEllipsisStr},
  74       {"short@small.com", "s" + kEllipsisStr + "@small.com"},
  75       {"short@longbutlotsofspace.com", "short@longbutlotsofspace.com"},
  76       {"short@longbutnotverymuchspace.com",
  77        "short@long" + kEllipsisStr + ".com"},
  78       {"la_short@longbutverytightspace.ca",
  79        "la" + kEllipsisStr + "@l" + kEllipsisStr + "a"},
  80       {"longusername@gmail.com", "long" + kEllipsisStr + "@gmail.com"},
  81       {"elidetothemax@justfits.com", "e" + kEllipsisStr + "@justfits.com"},
  82       {"thatom_somelongemail@thatdoesntfit.com",
  83        "thatom" + kEllipsisStr + "@tha" + kEllipsisStr + "om"},
  84       {"namefits@butthedomaindoesnt.com",
  85        "namefits@butthedo" + kEllipsisStr + "snt.com"},
  86       {"widthtootight@nospace.com", kEllipsisStr},
  87       {"nospaceforusername@l", kEllipsisStr},
  88       {"little@littlespace.com", "l" + kEllipsisStr + "@l" + kEllipsisStr},
  89       {"l@llllllllllllllllllllllll.com", "l@lllll" + kEllipsisStr + ".com"},
  90       {"messed\"up@whyanat\"++@notgoogley.com",
  91        "messed\"up@whyanat\"++@notgoogley.com"},
  92       {"messed\"up@whyanat\"++@notgoogley.com",
  93        "messed\"up@why" + kEllipsisStr + "@notgoogley.com"},
  94       {"noca_messed\"up@whyanat\"++@notgoogley.ca",
  95        "noca" + kEllipsisStr + "@no" + kEllipsisStr + "ca"},
  96       {"at\"@@@@@@@@@...@@.@.@.@@@\"@madness.com",
  97        "at\"@@@@@@@@@...@@.@." + kEllipsisStr + "@madness.com"},
  98       // Special case: "m..." takes more than half of the available width; thus
  99       // the domain must elide to "l..." and not "l...l" as it must allow enough
 100       // space for the minimal username elision although its half of the
 101       // available width would normally allow it to elide to "l...l".
 102       {"mmmmm@llllllllll", "m" + kEllipsisStr + "@l" + kEllipsisStr},
 103   };
 104
 105   const FontList font_list;
 106   for (size_t i = 0; i < arraysize(testcases); ++i) {
 107     const base::string16 expected_output = UTF8ToUTF16(testcases[i].output);
 108     EXPECT_EQ(expected_output,
 109               ElideEmail(
 110                   UTF8ToUTF16(testcases[i].input),
 111                   font_list,
 112                   GetStringWidthF(expected_output, font_list)));
 113   }
 114 }
 115
 116 // TODO(338784): Enable this on android.
 117 #if defined(OS_ANDROID)
 118 #define MAYBE_ElideEmailMoreSpace DISABLED_ElideEmailMoreSpace
 119 #else
 120 #define MAYBE_ElideEmailMoreSpace ElideEmailMoreSpace
 121 #endif
 122 TEST(TextEliderTest, MAYBE_ElideEmailMoreSpace) {
 123   const int test_width_factors[] = {
 124       100,
 125       10000,
 126       1000000,
 127   };
 128   const std::string test_emails[] = {
 129       "a@c",
 130       "test@email.com",
 131       "short@verysuperdupperlongdomain.com",
 132       "supermegalongusername@withasuperlonnnggggdomain.gouv.qc.ca",
 133   };
 134
 135   const FontList font_list;
 136   for (size_t i = 0; i < arraysize(test_width_factors); ++i) {
 137     const int test_width =
 138         font_list.GetExpectedTextWidth(test_width_factors[i]);
 139     for (size_t j = 0; j < arraysize(test_emails); ++j) {
 140       // Extra space is available: the email should not be elided.
 141       const base::string16 test_email = UTF8ToUTF16(test_emails[j]);
 142       EXPECT_EQ(test_email, ElideEmail(test_email, font_list, test_width));
 143     }
 144   }
 145 }
 146
 147 // TODO(ios): This test fails on iOS because iOS version of GetStringWidthF
 148 // that calls [NSString sizeWithFont] returns the rounded string width.
 149 // TODO(338784): Enable this on android.
 150 #if defined(OS_IOS) || defined(OS_ANDROID)
 151 #define MAYBE_TestFilenameEliding DISABLED_TestFilenameEliding
 152 #else
 153 #define MAYBE_TestFilenameEliding TestFilenameEliding
 154 #endif
 155 TEST(TextEliderTest, MAYBE_TestFilenameEliding) {
 156   const std::string kEllipsisStr(kEllipsis);
 157   const base::FilePath::StringType kPathSeparator =
 158       base::FilePath::StringType().append(1, base::FilePath::kSeparators[0]);
 159
 160   FileTestcase testcases[] = {
 161     {FILE_PATH_LITERAL(""), ""},
 162     {FILE_PATH_LITERAL("."), "."},
 163     {FILE_PATH_LITERAL("filename.exe"), "filename.exe"},
 164     {FILE_PATH_LITERAL(".longext"), ".longext"},
 165     {FILE_PATH_LITERAL("pie"), "pie"},
 166     {FILE_PATH_LITERAL("c:") + kPathSeparator + FILE_PATH_LITERAL("path") +
 167       kPathSeparator + FILE_PATH_LITERAL("filename.pie"),
 168       "filename.pie"},
 169     {FILE_PATH_LITERAL("c:") + kPathSeparator + FILE_PATH_LITERAL("path") +
 170       kPathSeparator + FILE_PATH_LITERAL("longfilename.pie"),
 171       "long" + kEllipsisStr + ".pie"},
 172     {FILE_PATH_LITERAL("http://path.com/filename.pie"), "filename.pie"},
 173     {FILE_PATH_LITERAL("http://path.com/longfilename.pie"),
 174       "long" + kEllipsisStr + ".pie"},
 175     {FILE_PATH_LITERAL("piesmashingtacularpants"), "pie" + kEllipsisStr},
 176     {FILE_PATH_LITERAL(".piesmashingtacularpants"), ".pie" + kEllipsisStr},
 177     {FILE_PATH_LITERAL("cheese."), "cheese."},
 178     {FILE_PATH_LITERAL("file name.longext"),
 179       "file" + kEllipsisStr + ".longext"},
 180     {FILE_PATH_LITERAL("fil ename.longext"),
 181       "fil " + kEllipsisStr + ".longext"},
 182     {FILE_PATH_LITERAL("filename.longext"),
 183       "file" + kEllipsisStr + ".longext"},
 184     {FILE_PATH_LITERAL("filename.middleext.longext"),
 185       "filename.mid" + kEllipsisStr + ".longext"},
 186     {FILE_PATH_LITERAL("filename.superduperextremelylongext"),
 187       "filename.sup" + kEllipsisStr + "emelylongext"},
 188     {FILE_PATH_LITERAL("filenamereallylongtext.superduperextremelylongext"),
 189       "filenamereall" + kEllipsisStr + "emelylongext"},
 190     {FILE_PATH_LITERAL("file.name.really.long.text.superduperextremelylongext"),
 191       "file.name.re" + kEllipsisStr + "emelylongext"}
 192   };
 193
 194   static const FontList font_list;
 195   for (size_t i = 0; i < arraysize(testcases); ++i) {
 196     base::FilePath filepath(testcases[i].input);
 197     base::string16 expected = UTF8ToUTF16(testcases[i].output);
 198     expected = base::i18n::GetDisplayStringInLTRDirectionality(expected);
 199     EXPECT_EQ(expected, ElideFilename(filepath, font_list,
 200         GetStringWidthF(UTF8ToUTF16(testcases[i].output), font_list)));
 201   }
 202 }
 203
 204 // TODO(338784): Enable this on android.
 205 #if defined(OS_ANDROID)
 206 #define MAYBE_ElideTextTruncate DISABLED_ElideTextTruncate
 207 #else
 208 #define MAYBE_ElideTextTruncate ElideTextTruncate
 209 #endif
 210 TEST(TextEliderTest, MAYBE_ElideTextTruncate) {
 211   const FontList font_list;
 212   const float kTestWidth = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
 213   struct TestData {
 214     const char* input;
 215     float width;
 216     const char* output;
 217   } cases[] = {
 218     { "", 0, "" },
 219     { "Test", 0, "" },
 220     { "", kTestWidth, "" },
 221     { "Tes", kTestWidth, "Tes" },
 222     { "Test", kTestWidth, "Test" },
 223     { "Tests", kTestWidth, "Test" },
 224   };
 225
 226   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 227     base::string16 result = ElideText(UTF8ToUTF16(cases[i].input), font_list,
 228                                 cases[i].width, TRUNCATE_AT_END);
 229     EXPECT_EQ(cases[i].output, UTF16ToUTF8(result));
 230   }
 231 }
 232
 233 // TODO(338784): Enable this on android.
 234 #if defined(OS_ANDROID)
 235 #define MAYBE_ElideTextEllipsis DISABLED_ElideTextEllipsis
 236 #else
 237 #define MAYBE_ElideTextEllipsis ElideTextEllipsis
 238 #endif
 239 TEST(TextEliderTest, MAYBE_ElideTextEllipsis) {
 240   const FontList font_list;
 241   const float kTestWidth = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
 242   const char* kEllipsis = "\xE2\x80\xA6";
 243   const float kEllipsisWidth =
 244       GetStringWidthF(UTF8ToUTF16(kEllipsis), font_list);
 245   struct TestData {
 246     const char* input;
 247     float width;
 248     const char* output;
 249   } cases[] = {
 250     { "", 0, "" },
 251     { "Test", 0, "" },
 252     { "Test", kEllipsisWidth, kEllipsis },
 253     { "", kTestWidth, "" },
 254     { "Tes", kTestWidth, "Tes" },
 255     { "Test", kTestWidth, "Test" },
 256   };
 257
 258   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 259     base::string16 result = ElideText(UTF8ToUTF16(cases[i].input), font_list,
 260                                 cases[i].width, ELIDE_AT_END);
 261     EXPECT_EQ(cases[i].output, UTF16ToUTF8(result));
 262   }
 263 }
 264
 265 // TODO(338784): Enable this on android.
 266 #if defined(OS_ANDROID)
 267 #define MAYBE_ElideTextEllipsisFront DISABLED_ElideTextEllipsisFront
 268 #else
 269 #define MAYBE_ElideTextEllipsisFront ElideTextEllipsisFront
 270 #endif
 271 TEST(TextEliderTest, MAYBE_ElideTextEllipsisFront) {
 272   const FontList font_list;
 273   const float kTestWidth = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
 274   const std::string kEllipsisStr(kEllipsis);
 275   const float kEllipsisWidth =
 276       GetStringWidthF(UTF8ToUTF16(kEllipsis), font_list);
 277   const float kEllipsis23Width =
 278       GetStringWidthF(UTF8ToUTF16(kEllipsisStr + "23"), font_list);
 279   struct TestData {
 280     const char* input;
 281     float width;
 282     const base::string16 output;
 283   } cases[] = {
 284     { "",        0,                base::string16() },
 285     { "Test",    0,                base::string16() },
 286     { "Test",    kEllipsisWidth,   UTF8ToUTF16(kEllipsisStr) },
 287     { "",        kTestWidth,       base::string16() },
 288     { "Tes",     kTestWidth,       ASCIIToUTF16("Tes") },
 289     { "Test",    kTestWidth,       ASCIIToUTF16("Test") },
 290     { "Test123", kEllipsis23Width, UTF8ToUTF16(kEllipsisStr + "23") },
 291   };
 292
 293   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 294     base::string16 result = ElideText(UTF8ToUTF16(cases[i].input), font_list,
 295                                       cases[i].width, ELIDE_AT_BEGINNING);
 296     EXPECT_EQ(cases[i].output, result);
 297   }
 298 }
 299
 300 // Checks that all occurrences of |first_char| are followed by |second_char| and
 301 // all occurrences of |second_char| are preceded by |first_char| in |text|.
 302 static void CheckSurrogatePairs(const base::string16& text,
 303                                 base::char16 first_char,
 304                                 base::char16 second_char) {
 305   size_t index = text.find_first_of(first_char);
 306   while (index != base::string16::npos) {
 307     EXPECT_LT(index, text.length() - 1);
 308     EXPECT_EQ(second_char, text[index + 1]);
 309     index = text.find_first_of(first_char, index + 1);
 310   }
 311   index = text.find_first_of(second_char);
 312   while (index != base::string16::npos) {
 313     EXPECT_GT(index, 0U);
 314     EXPECT_EQ(first_char, text[index - 1]);
 315     index = text.find_first_of(second_char, index + 1);
 316   }
 317 }
 318
 319 // TODO(338784): Enable this on android.
 320 #if defined(OS_ANDROID)
 321 #define MAYBE_ElideTextSurrogatePairs DISABLED_ElideTextSurrogatePairs
 322 #else
 323 #define MAYBE_ElideTextSurrogatePairs ElideTextSurrogatePairs
 324 #endif
 325 TEST(TextEliderTest, MAYBE_ElideTextSurrogatePairs) {
 326   const FontList font_list;
 327   // The below is 'MUSICAL SYMBOL G CLEF', which is represented in UTF-16 as
 328   // two characters forming a surrogate pair 0x0001D11E.
 329   const std::string kSurrogate = "\xF0\x9D\x84\x9E";
 330   const base::string16 kTestString =
 331       UTF8ToUTF16(kSurrogate + "ab" + kSurrogate + kSurrogate + "cd");
 332   const float kTestStringWidth = GetStringWidthF(kTestString, font_list);
 333   const base::char16 kSurrogateFirstChar = kTestString[0];
 334   const base::char16 kSurrogateSecondChar = kTestString[1];
 335   base::string16 result;
 336
 337   // Elide |kTextString| to all possible widths and check that no instance of
 338   // |kSurrogate| was split in two.
 339   for (float width = 0; width <= kTestStringWidth; width++) {
 340     result = ElideText(kTestString, font_list, width, TRUNCATE_AT_END);
 341     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
 342
 343     result = ElideText(kTestString, font_list, width, ELIDE_AT_END);
 344     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
 345
 346     result = ElideText(kTestString, font_list, width, ELIDE_IN_MIDDLE);
 347     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
 348
 349     result = ElideText(kTestString, font_list, width, ELIDE_AT_BEGINNING);
 350     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
 351   }
 352 }
 353
 354 // TODO(338784): Enable this on android.
 355 #if defined(OS_ANDROID)
 356 #define MAYBE_ElideTextLongStrings DISABLED_ElideTextLongStrings
 357 #else
 358 #define MAYBE_ElideTextLongStrings ElideTextLongStrings
 359 #endif
 360 TEST(TextEliderTest, MAYBE_ElideTextLongStrings) {
 361   const base::string16 kEllipsisStr = UTF8ToUTF16(kEllipsis);
 362   base::string16 data_scheme(UTF8ToUTF16("data:text/plain,"));
 363   size_t data_scheme_length = data_scheme.length();
 364
 365   base::string16 ten_a(10, 'a');
 366   base::string16 hundred_a(100, 'a');
 367   base::string16 thousand_a(1000, 'a');
 368   base::string16 ten_thousand_a(10000, 'a');
 369   base::string16 hundred_thousand_a(100000, 'a');
 370   base::string16 million_a(1000000, 'a');
 371
 372   // TODO(gbillock): Improve these tests by adding more string diversity and
 373   // doing string compares instead of length compares. See bug 338836.
 374
 375   size_t number_of_as = 156;
 376   base::string16 long_string_end(
 377       data_scheme + base::string16(number_of_as, 'a') + kEllipsisStr);
 378   UTF16Testcase testcases_end[] = {
 379      { data_scheme + ten_a,              data_scheme + ten_a },
 380      { data_scheme + hundred_a,          data_scheme + hundred_a },
 381      { data_scheme + thousand_a,         long_string_end },
 382      { data_scheme + ten_thousand_a,     long_string_end },
 383      { data_scheme + hundred_thousand_a, long_string_end },
 384      { data_scheme + million_a,          long_string_end },
 385   };
 386
 387   const FontList font_list;
 388   float ellipsis_width = GetStringWidthF(kEllipsisStr, font_list);
 389   for (size_t i = 0; i < arraysize(testcases_end); ++i) {
 390     // Compare sizes rather than actual contents because if the test fails,
 391     // output is rather long.
 392     EXPECT_EQ(testcases_end[i].output.size(),
 393               ElideText(
 394                   testcases_end[i].input,
 395                   font_list,
 396                   GetStringWidthF(testcases_end[i].output, font_list),
 397                   ELIDE_AT_END).size());
 398     EXPECT_EQ(kEllipsisStr,
 399               ElideText(testcases_end[i].input, font_list, ellipsis_width,
 400                         ELIDE_AT_END));
 401   }
 402
 403   size_t number_of_trailing_as = (data_scheme_length + number_of_as) / 2;
 404   base::string16 long_string_middle(data_scheme +
 405       base::string16(number_of_as - number_of_trailing_as, 'a') + kEllipsisStr +
 406       base::string16(number_of_trailing_as, 'a'));
 407   UTF16Testcase testcases_middle[] = {
 408      { data_scheme + ten_a,              data_scheme + ten_a },
 409      { data_scheme + hundred_a,          data_scheme + hundred_a },
 410      { data_scheme + thousand_a,         long_string_middle },
 411      { data_scheme + ten_thousand_a,     long_string_middle },
 412      { data_scheme + hundred_thousand_a, long_string_middle },
 413      { data_scheme + million_a,          long_string_middle },
 414   };
 415
 416   for (size_t i = 0; i < arraysize(testcases_middle); ++i) {
 417     // Compare sizes rather than actual contents because if the test fails,
 418     // output is rather long.
 419     EXPECT_EQ(testcases_middle[i].output.size(),
 420               ElideText(
 421                   testcases_middle[i].input,
 422                   font_list,
 423                   GetStringWidthF(testcases_middle[i].output, font_list),
 424                   ELIDE_IN_MIDDLE).size());
 425     EXPECT_EQ(kEllipsisStr,
 426               ElideText(testcases_middle[i].input, font_list, ellipsis_width,
 427                         ELIDE_IN_MIDDLE));
 428   }
 429
 430   base::string16 long_string_beginning(
 431       kEllipsisStr + base::string16(number_of_as, 'a'));
 432   UTF16Testcase testcases_beginning[] = {
 433      { data_scheme + ten_a,              data_scheme + ten_a },
 434      { data_scheme + hundred_a,          data_scheme + hundred_a },
 435      { data_scheme + thousand_a,         long_string_beginning },
 436      { data_scheme + ten_thousand_a,     long_string_beginning },
 437      { data_scheme + hundred_thousand_a, long_string_beginning },
 438      { data_scheme + million_a,          long_string_beginning },
 439   };
 440   for (size_t i = 0; i < arraysize(testcases_beginning); ++i) {
 441     EXPECT_EQ(testcases_beginning[i].output.size(),
 442               ElideText(
 443                   testcases_beginning[i].input, font_list,
 444                   GetStringWidthF(testcases_beginning[i].output, font_list),
 445                   ELIDE_AT_BEGINNING).size());
 446     EXPECT_EQ(kEllipsisStr,
 447               ElideText(testcases_beginning[i].input, font_list, ellipsis_width,
 448                         ELIDE_AT_BEGINNING));
 449   }
 450 }
 451
 452 TEST(TextEliderTest, ElideString) {
 453   struct TestData {
 454     const char* input;
 455     int max_len;
 456     bool result;
 457     const char* output;
 458   } cases[] = {
 459     { "Hello", 0, true, "" },
 460     { "", 0, false, "" },
 461     { "Hello, my name is Tom", 1, true, "H" },
 462     { "Hello, my name is Tom", 2, true, "He" },
 463     { "Hello, my name is Tom", 3, true, "H.m" },
 464     { "Hello, my name is Tom", 4, true, "H..m" },
 465     { "Hello, my name is Tom", 5, true, "H...m" },
 466     { "Hello, my name is Tom", 6, true, "He...m" },
 467     { "Hello, my name is Tom", 7, true, "He...om" },
 468     { "Hello, my name is Tom", 10, true, "Hell...Tom" },
 469     { "Hello, my name is Tom", 100, false, "Hello, my name is Tom" }
 470   };
 471   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 472     base::string16 output;
 473     EXPECT_EQ(cases[i].result,
 474               ElideString(UTF8ToUTF16(cases[i].input),
 475                           cases[i].max_len, &output));
 476     EXPECT_EQ(cases[i].output, UTF16ToUTF8(output));
 477   }
 478 }
 479
 480 // TODO(338784): Enable this on android.
 481 #if defined(OS_ANDROID)
 482 #define MAYBE_ElideRectangleText DISABLED_ElideRectangleText
 483 #else
 484 #define MAYBE_ElideRectangleText ElideRectangleText
 485 #endif
 486 TEST(TextEliderTest, MAYBE_ElideRectangleText) {
 487   const FontList font_list;
 488   const int line_height = font_list.GetHeight();
 489   const float test_width = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
 490
 491   struct TestData {
 492     const char* input;
 493     float available_pixel_width;
 494     int available_pixel_height;
 495     bool truncated_y;
 496     const char* output;
 497   } cases[] = {
 498     { "", 0, 0, false, NULL },
 499     { "", 1, 1, false, NULL },
 500     { "Test", test_width, 0, true, NULL },
 501     { "Test", test_width, 1, false, "Test" },
 502     { "Test", test_width, line_height, false, "Test" },
 503     { "Test Test", test_width, line_height, true, "Test" },
 504     { "Test Test", test_width, line_height + 1, false, "Test|Test" },
 505     { "Test Test", test_width, line_height * 2, false, "Test|Test" },
 506     { "Test Test", test_width, line_height * 3, false, "Test|Test" },
 507     { "Test Test", test_width * 2, line_height * 2, false, "Test|Test" },
 508     { "Test Test", test_width * 3, line_height, false, "Test Test" },
 509     { "Test\nTest", test_width * 3, line_height * 2, false, "Test|Test" },
 510     { "Te\nst Te", test_width, line_height * 3, false, "Te|st|Te" },
 511     { "\nTest", test_width, line_height * 2, false, "|Test" },
 512     { "\nTest", test_width, line_height, true, "" },
 513     { "\n\nTest", test_width, line_height * 3, false, "||Test" },
 514     { "\n\nTest", test_width, line_height * 2, true, "|" },
 515     { "Test\n", 2 * test_width, line_height * 5, false, "Test|" },
 516     { "Test\n\n", 2 * test_width, line_height * 5, false, "Test||" },
 517     { "Test\n\n\n", 2 * test_width, line_height * 5, false, "Test|||" },
 518     { "Test\nTest\n\n", 2 * test_width, line_height * 5, false, "Test|Test||" },
 519     { "Test\n\nTest\n", 2 * test_width, line_height * 5, false, "Test||Test|" },
 520     { "Test\n\n\nTest", 2 * test_width, line_height * 5, false, "Test|||Test" },
 521     { "Te ", test_width, line_height, false, "Te" },
 522     { "Te  Te Test", test_width, 3 * line_height, false, "Te|Te|Test" },
 523   };
 524
 525   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 526     std::vector<base::string16> lines;
 527     EXPECT_EQ(cases[i].truncated_y ? INSUFFICIENT_SPACE_VERTICAL : 0,
 528               ElideRectangleText(UTF8ToUTF16(cases[i].input),
 529                                  font_list,
 530                                  cases[i].available_pixel_width,
 531                                  cases[i].available_pixel_height,
 532                                  TRUNCATE_LONG_WORDS,
 533                                  &lines));
 534     if (cases[i].output) {
 535       const std::string result = UTF16ToUTF8(JoinString(lines, '|'));
 536       EXPECT_EQ(cases[i].output, result) << "Case " << i << " failed!";
 537     } else {
 538       EXPECT_TRUE(lines.empty()) << "Case " << i << " failed!";
 539     }
 540   }
 541 }
 542
 543 // TODO(338784): Enable this on android.
 544 #if defined(OS_ANDROID)
 545 #define MAYBE_ElideRectangleTextPunctuation \
 546     DISABLED_ElideRectangleTextPunctuation
 547 #else
 548 #define MAYBE_ElideRectangleTextPunctuation ElideRectangleTextPunctuation
 549 #endif
 550 TEST(TextEliderTest, MAYBE_ElideRectangleTextPunctuation) {
 551   const FontList font_list;
 552   const int line_height = font_list.GetHeight();
 553   const float test_width = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
 554   const float test_t_width = GetStringWidthF(ASCIIToUTF16("Test T"), font_list);
 555
 556   struct TestData {
 557     const char* input;
 558     float available_pixel_width;
 559     int available_pixel_height;
 560     bool wrap_words;
 561     bool truncated_x;
 562     const char* output;
 563   } cases[] = {
 564     { "Test T.", test_t_width, line_height * 2, false, false, "Test|T." },
 565     { "Test T ?", test_t_width, line_height * 2, false, false, "Test|T ?" },
 566     { "Test. Test", test_width, line_height * 3, false, true, "Test|Test" },
 567     { "Test. Test", test_width, line_height * 3, true, false, "Test|.|Test" },
 568   };
 569
 570   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 571     std::vector<base::string16> lines;
 572     const WordWrapBehavior wrap_behavior =
 573         (cases[i].wrap_words ? WRAP_LONG_WORDS : TRUNCATE_LONG_WORDS);
 574     EXPECT_EQ(cases[i].truncated_x ? INSUFFICIENT_SPACE_HORIZONTAL : 0,
 575               ElideRectangleText(UTF8ToUTF16(cases[i].input),
 576                                  font_list,
 577                                  cases[i].available_pixel_width,
 578                                  cases[i].available_pixel_height,
 579                                  wrap_behavior,
 580                                  &lines));
 581     if (cases[i].output) {
 582       const std::string result = UTF16ToUTF8(JoinString(lines, '|'));
 583       EXPECT_EQ(cases[i].output, result) << "Case " << i << " failed!";
 584     } else {
 585       EXPECT_TRUE(lines.empty()) << "Case " << i << " failed!";
 586     }
 587   }
 588 }
 589
 590 // TODO(338784): Enable this on android.
 591 #if defined(OS_ANDROID)
 592 #define MAYBE_ElideRectangleTextLongWords DISABLED_ElideRectangleTextLongWords
 593 #else
 594 #define MAYBE_ElideRectangleTextLongWords ElideRectangleTextLongWords
 595 #endif
 596 TEST(TextEliderTest, MAYBE_ElideRectangleTextLongWords) {
 597   const FontList font_list;
 598   const int kAvailableHeight = 1000;
 599   const base::string16 kElidedTesting =
 600       UTF8ToUTF16(std::string("Tes") + kEllipsis);
 601   const float elided_width = GetStringWidthF(kElidedTesting, font_list);
 602   const float test_width = GetStringWidthF(ASCIIToUTF16("Test"), font_list);
 603
 604   struct TestData {
 605     const char* input;
 606     float available_pixel_width;
 607     WordWrapBehavior wrap_behavior;
 608     bool truncated_x;
 609     const char* output;
 610   } cases[] = {
 611     { "Testing", test_width, IGNORE_LONG_WORDS, false, "Testing" },
 612     { "X Testing", test_width, IGNORE_LONG_WORDS, false, "X|Testing" },
 613     { "Test Testing", test_width, IGNORE_LONG_WORDS, false, "Test|Testing" },
 614     { "Test\nTesting", test_width, IGNORE_LONG_WORDS, false, "Test|Testing" },
 615     { "Test Tests ", test_width, IGNORE_LONG_WORDS, false, "Test|Tests" },
 616     { "Test Tests T", test_width, IGNORE_LONG_WORDS, false, "Test|Tests|T" },
 617
 618     { "Testing", elided_width, ELIDE_LONG_WORDS, true, "Tes..." },
 619     { "X Testing", elided_width, ELIDE_LONG_WORDS, true, "X|Tes..." },
 620     { "Test Testing", elided_width, ELIDE_LONG_WORDS, true, "Test|Tes..." },
 621     { "Test\nTesting", elided_width, ELIDE_LONG_WORDS, true, "Test|Tes..." },
 622
 623     { "Testing", test_width, TRUNCATE_LONG_WORDS, true, "Test" },
 624     { "X Testing", test_width, TRUNCATE_LONG_WORDS, true, "X|Test" },
 625     { "Test Testing", test_width, TRUNCATE_LONG_WORDS, true, "Test|Test" },
 626     { "Test\nTesting", test_width, TRUNCATE_LONG_WORDS, true, "Test|Test" },
 627     { "Test Tests ", test_width, TRUNCATE_LONG_WORDS, true, "Test|Test" },
 628     { "Test Tests T", test_width, TRUNCATE_LONG_WORDS, true, "Test|Test|T" },
 629
 630     { "Testing", test_width, WRAP_LONG_WORDS, false, "Test|ing" },
 631     { "X Testing", test_width, WRAP_LONG_WORDS, false, "X|Test|ing" },
 632     { "Test Testing", test_width, WRAP_LONG_WORDS, false, "Test|Test|ing" },
 633     { "Test\nTesting", test_width, WRAP_LONG_WORDS, false, "Test|Test|ing" },
 634     { "Test Tests ", test_width, WRAP_LONG_WORDS, false, "Test|Test|s" },
 635     { "Test Tests T", test_width, WRAP_LONG_WORDS, false, "Test|Test|s T" },
 636     { "TestTestTest", test_width, WRAP_LONG_WORDS, false, "Test|Test|Test" },
 637     { "TestTestTestT", test_width, WRAP_LONG_WORDS, false, "Test|Test|Test|T" },
 638   };
 639
 640   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 641     std::vector<base::string16> lines;
 642     EXPECT_EQ(cases[i].truncated_x ? INSUFFICIENT_SPACE_HORIZONTAL : 0,
 643               ElideRectangleText(UTF8ToUTF16(cases[i].input),
 644                                  font_list,
 645                                  cases[i].available_pixel_width,
 646                                  kAvailableHeight,
 647                                  cases[i].wrap_behavior,
 648                                  &lines));
 649     std::string expected_output(cases[i].output);
 650     ReplaceSubstringsAfterOffset(&expected_output, 0, "...", kEllipsis);
 651     const std::string result = UTF16ToUTF8(JoinString(lines, '|'));
 652     EXPECT_EQ(expected_output, result) << "Case " << i << " failed!";
 653   }
 654 }
 655
 656 // This test is to make sure that the width of each wrapped line does not
 657 // exceed the available width. On some platform like Mac, this test used to
 658 // fail because the truncated integer width is returned for the string
 659 // and the accumulation of the truncated values causes the elide function
 660 // to wrap incorrectly.
 661 // TODO(338784): Enable this on android.
 662 #if defined(OS_ANDROID)
 663 #define MAYBE_ElideRectangleTextCheckLineWidth \
 664     DISABLED_ElideRectangleTextCheckLineWidth
 665 #else
 666 #define MAYBE_ElideRectangleTextCheckLineWidth ElideRectangleTextCheckLineWidth
 667 #endif
 668 TEST(TextEliderTest, MAYBE_ElideRectangleTextCheckLineWidth) {
 669   FontList font_list;
 670 #if defined(OS_MACOSX) && !defined(OS_IOS)
 671   // Use a specific font to expose the line width exceeding problem.
 672   font_list = FontList(Font("LucidaGrande", 12));
 673 #endif
 674   const float kAvailableWidth = 235;
 675   const int kAvailableHeight = 1000;
 676   const char text[] = "that Russian place we used to go to after fencing";
 677   std::vector<base::string16> lines;
 678   EXPECT_EQ(0, ElideRectangleText(UTF8ToUTF16(text),
 679                                   font_list,
 680                                   kAvailableWidth,
 681                                   kAvailableHeight,
 682                                   WRAP_LONG_WORDS,
 683                                   &lines));
 684   ASSERT_EQ(2u, lines.size());
 685   EXPECT_LE(GetStringWidthF(lines[0], font_list), kAvailableWidth);
 686   EXPECT_LE(GetStringWidthF(lines[1], font_list), kAvailableWidth);
 687 }
 688
 689 TEST(TextEliderTest, ElideRectangleString) {
 690   struct TestData {
 691     const char* input;
 692     int max_rows;
 693     int max_cols;
 694     bool result;
 695     const char* output;
 696   } cases[] = {
 697     { "", 0, 0, false, "" },
 698     { "", 1, 1, false, "" },
 699     { "Hi, my name is\nTom", 0, 0,  true,  "..." },
 700     { "Hi, my name is\nTom", 1, 0,  true,  "\n..." },
 701     { "Hi, my name is\nTom", 0, 1,  true,  "..." },
 702     { "Hi, my name is\nTom", 1, 1,  true,  "H\n..." },
 703     { "Hi, my name is\nTom", 2, 1,  true,  "H\ni\n..." },
 704     { "Hi, my name is\nTom", 3, 1,  true,  "H\ni\n,\n..." },
 705     { "Hi, my name is\nTom", 4, 1,  true,  "H\ni\n,\n \n..." },
 706     { "Hi, my name is\nTom", 5, 1,  true,  "H\ni\n,\n \nm\n..." },
 707     { "Hi, my name is\nTom", 0, 2,  true,  "..." },
 708     { "Hi, my name is\nTom", 1, 2,  true,  "Hi\n..." },
 709     { "Hi, my name is\nTom", 2, 2,  true,  "Hi\n, \n..." },
 710     { "Hi, my name is\nTom", 3, 2,  true,  "Hi\n, \nmy\n..." },
 711     { "Hi, my name is\nTom", 4, 2,  true,  "Hi\n, \nmy\n n\n..." },
 712     { "Hi, my name is\nTom", 5, 2,  true,  "Hi\n, \nmy\n n\nam\n..." },
 713     { "Hi, my name is\nTom", 0, 3,  true,  "..." },
 714     { "Hi, my name is\nTom", 1, 3,  true,  "Hi,\n..." },
 715     { "Hi, my name is\nTom", 2, 3,  true,  "Hi,\n my\n..." },
 716     { "Hi, my name is\nTom", 3, 3,  true,  "Hi,\n my\n na\n..." },
 717     { "Hi, my name is\nTom", 4, 3,  true,  "Hi,\n my\n na\nme \n..." },
 718     { "Hi, my name is\nTom", 5, 3,  true,  "Hi,\n my\n na\nme \nis\n..." },
 719     { "Hi, my name is\nTom", 1, 4,  true,  "Hi, \n..." },
 720     { "Hi, my name is\nTom", 2, 4,  true,  "Hi, \nmy n\n..." },
 721     { "Hi, my name is\nTom", 3, 4,  true,  "Hi, \nmy n\name \n..." },
 722     { "Hi, my name is\nTom", 4, 4,  true,  "Hi, \nmy n\name \nis\n..." },
 723     { "Hi, my name is\nTom", 5, 4,  false, "Hi, \nmy n\name \nis\nTom" },
 724     { "Hi, my name is\nTom", 1, 5,  true,  "Hi, \n..." },
 725     { "Hi, my name is\nTom", 2, 5,  true,  "Hi, \nmy na\n..." },
 726     { "Hi, my name is\nTom", 3, 5,  true,  "Hi, \nmy na\nme \n..." },
 727     { "Hi, my name is\nTom", 4, 5,  true,  "Hi, \nmy na\nme \nis\n..." },
 728     { "Hi, my name is\nTom", 5, 5,  false, "Hi, \nmy na\nme \nis\nTom" },
 729     { "Hi, my name is\nTom", 1, 6,  true,  "Hi, \n..." },
 730     { "Hi, my name is\nTom", 2, 6,  true,  "Hi, \nmy \n..." },
 731     { "Hi, my name is\nTom", 3, 6,  true,  "Hi, \nmy \nname \n..." },
 732     { "Hi, my name is\nTom", 4, 6,  true,  "Hi, \nmy \nname \nis\n..." },
 733     { "Hi, my name is\nTom", 5, 6,  false, "Hi, \nmy \nname \nis\nTom" },
 734     { "Hi, my name is\nTom", 1, 7,  true,  "Hi, \n..." },
 735     { "Hi, my name is\nTom", 2, 7,  true,  "Hi, \nmy \n..." },
 736     { "Hi, my name is\nTom", 3, 7,  true,  "Hi, \nmy \nname \n..." },
 737     { "Hi, my name is\nTom", 4, 7,  true,  "Hi, \nmy \nname \nis\n..." },
 738     { "Hi, my name is\nTom", 5, 7,  false, "Hi, \nmy \nname \nis\nTom" },
 739     { "Hi, my name is\nTom", 1, 8,  true,  "Hi, my \n..." },
 740     { "Hi, my name is\nTom", 2, 8,  true,  "Hi, my \nname \n..." },
 741     { "Hi, my name is\nTom", 3, 8,  true,  "Hi, my \nname \nis\n..." },
 742     { "Hi, my name is\nTom", 4, 8,  false, "Hi, my \nname \nis\nTom" },
 743     { "Hi, my name is\nTom", 1, 9,  true,  "Hi, my \n..." },
 744     { "Hi, my name is\nTom", 2, 9,  true,  "Hi, my \nname is\n..." },
 745     { "Hi, my name is\nTom", 3, 9,  false, "Hi, my \nname is\nTom" },
 746     { "Hi, my name is\nTom", 1, 10, true,  "Hi, my \n..." },
 747     { "Hi, my name is\nTom", 2, 10, true,  "Hi, my \nname is\n..." },
 748     { "Hi, my name is\nTom", 3, 10, false, "Hi, my \nname is\nTom" },
 749     { "Hi, my name is\nTom", 1, 11, true,  "Hi, my \n..." },
 750     { "Hi, my name is\nTom", 2, 11, true,  "Hi, my \nname is\n..." },
 751     { "Hi, my name is\nTom", 3, 11, false, "Hi, my \nname is\nTom" },
 752     { "Hi, my name is\nTom", 1, 12, true,  "Hi, my \n..." },
 753     { "Hi, my name is\nTom", 2, 12, true,  "Hi, my \nname is\n..." },
 754     { "Hi, my name is\nTom", 3, 12, false, "Hi, my \nname is\nTom" },
 755     { "Hi, my name is\nTom", 1, 13, true,  "Hi, my name \n..." },
 756     { "Hi, my name is\nTom", 2, 13, true,  "Hi, my name \nis\n..." },
 757     { "Hi, my name is\nTom", 3, 13, false, "Hi, my name \nis\nTom" },
 758     { "Hi, my name is\nTom", 1, 20, true,  "Hi, my name is\n..." },
 759     { "Hi, my name is\nTom", 2, 20, false, "Hi, my name is\nTom" },
 760     { "Hi, my name is Tom",  1, 40, false, "Hi, my name is Tom" },
 761   };
 762   base::string16 output;
 763   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 764     EXPECT_EQ(cases[i].result,
 765               ElideRectangleString(UTF8ToUTF16(cases[i].input),
 766                                    cases[i].max_rows, cases[i].max_cols,
 767                                    true, &output));
 768     EXPECT_EQ(cases[i].output, UTF16ToUTF8(output));
 769   }
 770 }
 771
 772 TEST(TextEliderTest, ElideRectangleStringNotStrict) {
 773   struct TestData {
 774     const char* input;
 775     int max_rows;
 776     int max_cols;
 777     bool result;
 778     const char* output;
 779   } cases[] = {
 780     { "", 0, 0, false, "" },
 781     { "", 1, 1, false, "" },
 782     { "Hi, my name_is\nDick", 0, 0,  true,  "..." },
 783     { "Hi, my name_is\nDick", 1, 0,  true,  "\n..." },
 784     { "Hi, my name_is\nDick", 0, 1,  true,  "..." },
 785     { "Hi, my name_is\nDick", 1, 1,  true,  "H\n..." },
 786     { "Hi, my name_is\nDick", 2, 1,  true,  "H\ni\n..." },
 787     { "Hi, my name_is\nDick", 3, 1,  true,  "H\ni\n,\n..." },
 788     { "Hi, my name_is\nDick", 4, 1,  true,  "H\ni\n,\n \n..." },
 789     { "Hi, my name_is\nDick", 5, 1,  true,  "H\ni\n,\n \nm\n..." },
 790     { "Hi, my name_is\nDick", 0, 2,  true,  "..." },
 791     { "Hi, my name_is\nDick", 1, 2,  true,  "Hi\n..." },
 792     { "Hi, my name_is\nDick", 2, 2,  true,  "Hi\n, \n..." },
 793     { "Hi, my name_is\nDick", 3, 2,  true,  "Hi\n, \nmy\n..." },
 794     { "Hi, my name_is\nDick", 4, 2,  true,  "Hi\n, \nmy\n n\n..." },
 795     { "Hi, my name_is\nDick", 5, 2,  true,  "Hi\n, \nmy\n n\nam\n..." },
 796     { "Hi, my name_is\nDick", 0, 3,  true,  "..." },
 797     { "Hi, my name_is\nDick", 1, 3,  true,  "Hi,\n..." },
 798     { "Hi, my name_is\nDick", 2, 3,  true,  "Hi,\n my\n..." },
 799     { "Hi, my name_is\nDick", 3, 3,  true,  "Hi,\n my\n na\n..." },
 800     { "Hi, my name_is\nDick", 4, 3,  true,  "Hi,\n my\n na\nme_\n..." },
 801     { "Hi, my name_is\nDick", 5, 3,  true,  "Hi,\n my\n na\nme_\nis\n..." },
 802     { "Hi, my name_is\nDick", 1, 4,  true,  "Hi, ..." },
 803     { "Hi, my name_is\nDick", 2, 4,  true,  "Hi, my n\n..." },
 804     { "Hi, my name_is\nDick", 3, 4,  true,  "Hi, my n\name_\n..." },
 805     { "Hi, my name_is\nDick", 4, 4,  true,  "Hi, my n\name_\nis\n..." },
 806     { "Hi, my name_is\nDick", 5, 4,  false, "Hi, my n\name_\nis\nDick" },
 807     { "Hi, my name_is\nDick", 1, 5,  true,  "Hi, ..." },
 808     { "Hi, my name_is\nDick", 2, 5,  true,  "Hi, my na\n..." },
 809     { "Hi, my name_is\nDick", 3, 5,  true,  "Hi, my na\nme_is\n..." },
 810     { "Hi, my name_is\nDick", 4, 5,  true,  "Hi, my na\nme_is\n\n..." },
 811     { "Hi, my name_is\nDick", 5, 5,  false, "Hi, my na\nme_is\n\nDick" },
 812     { "Hi, my name_is\nDick", 1, 6,  true,  "Hi, ..." },
 813     { "Hi, my name_is\nDick", 2, 6,  true,  "Hi, my nam\n..." },
 814     { "Hi, my name_is\nDick", 3, 6,  true,  "Hi, my nam\ne_is\n..." },
 815     { "Hi, my name_is\nDick", 4, 6,  false, "Hi, my nam\ne_is\nDick" },
 816     { "Hi, my name_is\nDick", 5, 6,  false, "Hi, my nam\ne_is\nDick" },
 817     { "Hi, my name_is\nDick", 1, 7,  true,  "Hi, ..." },
 818     { "Hi, my name_is\nDick", 2, 7,  true,  "Hi, my name\n..." },
 819     { "Hi, my name_is\nDick", 3, 7,  true,  "Hi, my name\n_is\n..." },
 820     { "Hi, my name_is\nDick", 4, 7,  false, "Hi, my name\n_is\nDick" },
 821     { "Hi, my name_is\nDick", 5, 7,  false, "Hi, my name\n_is\nDick" },
 822     { "Hi, my name_is\nDick", 1, 8,  true,  "Hi, my n\n..." },
 823     { "Hi, my name_is\nDick", 2, 8,  true,  "Hi, my n\name_is\n..." },
 824     { "Hi, my name_is\nDick", 3, 8,  false, "Hi, my n\name_is\nDick" },
 825     { "Hi, my name_is\nDick", 1, 9,  true,  "Hi, my ..." },
 826     { "Hi, my name_is\nDick", 2, 9,  true,  "Hi, my name_is\n..." },
 827     { "Hi, my name_is\nDick", 3, 9,  false, "Hi, my name_is\nDick" },
 828     { "Hi, my name_is\nDick", 1, 10, true,  "Hi, my ..." },
 829     { "Hi, my name_is\nDick", 2, 10, true,  "Hi, my name_is\n..." },
 830     { "Hi, my name_is\nDick", 3, 10, false, "Hi, my name_is\nDick" },
 831     { "Hi, my name_is\nDick", 1, 11, true,  "Hi, my ..." },
 832     { "Hi, my name_is\nDick", 2, 11, true,  "Hi, my name_is\n..." },
 833     { "Hi, my name_is\nDick", 3, 11, false, "Hi, my name_is\nDick" },
 834     { "Hi, my name_is\nDick", 1, 12, true,  "Hi, my ..." },
 835     { "Hi, my name_is\nDick", 2, 12, true,  "Hi, my name_is\n..." },
 836     { "Hi, my name_is\nDick", 3, 12, false, "Hi, my name_is\nDick" },
 837     { "Hi, my name_is\nDick", 1, 13, true,  "Hi, my ..." },
 838     { "Hi, my name_is\nDick", 2, 13, true,  "Hi, my name_is\n..." },
 839     { "Hi, my name_is\nDick", 3, 13, false, "Hi, my name_is\nDick" },
 840     { "Hi, my name_is\nDick", 1, 20, true,  "Hi, my name_is\n..." },
 841     { "Hi, my name_is\nDick", 2, 20, false, "Hi, my name_is\nDick" },
 842     { "Hi, my name_is Dick",  1, 40, false, "Hi, my name_is Dick" },
 843   };
 844   base::string16 output;
 845   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 846     EXPECT_EQ(cases[i].result,
 847               ElideRectangleString(UTF8ToUTF16(cases[i].input),
 848                                    cases[i].max_rows, cases[i].max_cols,
 849                                    false, &output));
 850     EXPECT_EQ(cases[i].output, UTF16ToUTF8(output));
 851   }
 852 }
 853
 854 TEST(TextEliderTest, ElideRectangleWide16) {
 855   // Two greek words separated by space.
 856   const base::string16 str(WideToUTF16(
 857       L"\x03a0\x03b1\x03b3\x03ba\x03cc\x03c3\x03bc\x03b9"
 858       L"\x03bf\x03c2\x0020\x0399\x03c3\x03c4\x03cc\x03c2"));
 859   const base::string16 out1(WideToUTF16(
 860       L"\x03a0\x03b1\x03b3\x03ba\n"
 861       L"\x03cc\x03c3\x03bc\x03b9\n"
 862       L"..."));
 863   const base::string16 out2(WideToUTF16(
 864       L"\x03a0\x03b1\x03b3\x03ba\x03cc\x03c3\x03bc\x03b9\x03bf\x03c2\x0020\n"
 865       L"\x0399\x03c3\x03c4\x03cc\x03c2"));
 866   base::string16 output;
 867   EXPECT_TRUE(ElideRectangleString(str, 2, 4, true, &output));
 868   EXPECT_EQ(out1, output);
 869   EXPECT_FALSE(ElideRectangleString(str, 2, 12, true, &output));
 870   EXPECT_EQ(out2, output);
 871 }
 872
 873 TEST(TextEliderTest, ElideRectangleWide32) {
 874   // Four U+1D49C MATHEMATICAL SCRIPT CAPITAL A followed by space "aaaaa".
 875   const base::string16 str(UTF8ToUTF16(
 876       "\xF0\x9D\x92\x9C\xF0\x9D\x92\x9C\xF0\x9D\x92\x9C\xF0\x9D\x92\x9C"
 877       " aaaaa"));
 878   const base::string16 out(UTF8ToUTF16(
 879       "\xF0\x9D\x92\x9C\xF0\x9D\x92\x9C\xF0\x9D\x92\x9C\n"
 880       "\xF0\x9D\x92\x9C \naaa\n..."));
 881   base::string16 output;
 882   EXPECT_TRUE(ElideRectangleString(str, 3, 3, true, &output));
 883   EXPECT_EQ(out, output);
 884 }
 885
 886 TEST(TextEliderTest, TruncateString) {
 887   base::string16 string = ASCIIToUTF16("foooooey    bxxxar baz");
 888
 889   // Make sure it doesn't modify the string if length > string length.
 890   EXPECT_EQ(string, TruncateString(string, 100));
 891
 892   // Test no characters.
 893   EXPECT_EQ(L"", UTF16ToWide(TruncateString(string, 0)));
 894
 895   // Test 1 character.
 896   EXPECT_EQ(L"\x2026", UTF16ToWide(TruncateString(string, 1)));
 897
 898   // Test adds ... at right spot when there is enough room to break at a
 899   // word boundary.
 900   EXPECT_EQ(L"foooooey\x2026", UTF16ToWide(TruncateString(string, 14)));
 901
 902   // Test adds ... at right spot when there is not enough space in first word.
 903   EXPECT_EQ(L"f\x2026", UTF16ToWide(TruncateString(string, 2)));
 904
 905   // Test adds ... at right spot when there is not enough room to break at a
 906   // word boundary.
 907   EXPECT_EQ(L"foooooey\x2026", UTF16ToWide(TruncateString(string, 11)));
 908
 909   // Test completely truncates string if break is on initial whitespace.
 910   EXPECT_EQ(L"\x2026", UTF16ToWide(TruncateString(ASCIIToUTF16("   "), 2)));
 911 }
 912
 913 }  // namespace gfx