Disable failing TextEliderTest.* and FontListTest.*

ui/gfx/text_elider_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Unit tests for eliding and formatting utility functions.
 
 #include "ui/gfx/text_elider.h"
 
 #include <vector>
 
@@ skipping 821 matching lines @@
   SetFontRenderParamsDeviceScaleFactor(1.25f);
 #define WIDTH(x) GetStringWidthF(UTF8ToUTF16(x), font_list)
   EXPECT_EQ(WIDTH("The administrator for this account has"),
             WIDTH("The ") + WIDTH("administrator ") + WIDTH("for ") +
                 WIDTH("this ") + WIDTH("account ") + WIDTH("has"));
 #undef WIDTH
   SetFontRenderParamsDeviceScaleFactor(1.0f);
 }
 #endif // OS_CHROMEOS
 
-TEST(TextEliderTest, ElideRectangleString) {
+// TODO(338784): Enable this on android.
+#if defined(OS_ANDROID)
+#define MAYBE_ElideRectangleString DISABLED_ElideRectangleString
+#else
+#define MAYBE_ElideRectangleString ElideRectangleString
+#endif
+TEST(TextEliderTest, MAYBE_ElideRectangleString) {
   struct TestData {
     const char* input;
     int max_rows;
     int max_cols;
     bool result;
     const char* output;
   } cases[] = {
     { "", 0, 0, false, "" },
     { "", 1, 1, false, "" },
     { "Hi, my name is\nTom", 0, 0,  true,  "..." },
@@ skipping 62 matching lines @@
   base::string16 output;
   for (size_t i = 0; i < arraysize(cases); ++i) {
     EXPECT_EQ(cases[i].result,
               ElideRectangleString(UTF8ToUTF16(cases[i].input),
                                    cases[i].max_rows, cases[i].max_cols,
                                    true, &output));
     EXPECT_EQ(cases[i].output, UTF16ToUTF8(output));
   }
 }
 
-TEST(TextEliderTest, ElideRectangleStringNotStrict) {
+// TODO(338784): Enable this on android.
+#if defined(OS_ANDROID)
+#define MAYBE_ElideRectangleStringNotStrict \
+    DISABLED_ElideRectangleStringNotStrict
+#else
+#define MAYBE_ElideRectangleStringNotStrict ElideRectangleStringNotStrict
+#endif
+TEST(TextEliderTest, MAYBE_ElideRectangleStringNotStrict) {
   struct TestData {
     const char* input;
     int max_rows;
     int max_cols;
     bool result;
     const char* output;
   } cases[] = {
     { "", 0, 0, false, "" },
     { "", 1, 1, false, "" },
     { "Hi, my name_is\nDick", 0, 0,  true,  "..." },
@@ skipping 61 matching lines @@
   base::string16 output;
   for (size_t i = 0; i < arraysize(cases); ++i) {
     EXPECT_EQ(cases[i].result,
               ElideRectangleString(UTF8ToUTF16(cases[i].input),
                                    cases[i].max_rows, cases[i].max_cols,
                                    false, &output));
     EXPECT_EQ(cases[i].output, UTF16ToUTF8(output));
   }
 }
 
-TEST(TextEliderTest, ElideRectangleWide16) {
+// TODO(338784): Enable this on android.
+#if defined(OS_ANDROID)
+#define MAYBE_ElideRectangleWide16 DISABLED_ElideRectangleWide16
+#else
+#define MAYBE_ElideRectangleWide16 ElideRectangleWide16
+#endif
+TEST(TextEliderTest, MAYBE_ElideRectangleWide16) {
   // Two greek words separated by space.
   const base::string16 str(WideToUTF16(
       L"\x03a0\x03b1\x03b3\x03ba\x03cc\x03c3\x03bc\x03b9"
       L"\x03bf\x03c2\x0020\x0399\x03c3\x03c4\x03cc\x03c2"));
   const base::string16 out1(WideToUTF16(
       L"\x03a0\x03b1\x03b3\x03ba\n"
       L"\x03cc\x03c3\x03bc\x03b9\n"
       L"..."));
   const base::string16 out2(WideToUTF16(
       L"\x03a0\x03b1\x03b3\x03ba\x03cc\x03c3\x03bc\x03b9\x03bf\x03c2\x0020\n"
       L"\x0399\x03c3\x03c4\x03cc\x03c2"));
   base::string16 output;
   EXPECT_TRUE(ElideRectangleString(str, 2, 4, true, &output));
   EXPECT_EQ(out1, output);
   EXPECT_FALSE(ElideRectangleString(str, 2, 12, true, &output));
   EXPECT_EQ(out2, output);
 }
 
-TEST(TextEliderTest, ElideRectangleWide32) {
+// TODO(338784): Enable this on android.
+#if defined(OS_ANDROID)
+#define MAYBE_ElideRectangleWide32 DISABLED_ElideRectangleWide32
+#else
+#define MAYBE_ElideRectangleWide32 ElideRectangleWide32
+#endif
+TEST(TextEliderTest, MAYBE_ElideRectangleWide32) {
   // Four U+1D49C MATHEMATICAL SCRIPT CAPITAL A followed by space "aaaaa".
   const base::string16 str(UTF8ToUTF16(
       "\xF0\x9D\x92\x9C\xF0\x9D\x92\x9C\xF0\x9D\x92\x9C\xF0\x9D\x92\x9C"
       " aaaaa"));
   const base::string16 out(UTF8ToUTF16(
       "\xF0\x9D\x92\x9C\xF0\x9D\x92\x9C\xF0\x9D\x92\x9C\n"
       "\xF0\x9D\x92\x9C \naaa\n..."));
   base::string16 output;
   EXPECT_TRUE(ElideRectangleString(str, 3, 3, true, &output));
   EXPECT_EQ(out, output);
 }
 
-TEST(TextEliderTest, TruncateString) {
+// TODO(338784): Enable this on android.
+#if defined(OS_ANDROID)
+#define MAYBE_TruncateString DISABLED_TruncateString
+#else
+#define MAYBE_TruncateString TruncateString
+#endif
+TEST(TextEliderTest, MAYBE_TruncateString) {
   base::string16 string = ASCIIToUTF16("foooooey    bxxxar baz");
 
   // Tests that apply to both break behaviors:
 
   // Make sure it doesn't modify the string if length > string length.
   EXPECT_EQ(string, TruncateString(string, 100, WORD_BREAK));
   EXPECT_EQ(string, TruncateString(string, 100, CHARACTER_BREAK));
 
   // Test no characters.
   EXPECT_EQ(L"", UTF16ToWide(TruncateString(string, 0, WORD_BREAK)));
@@ skipping 30 matching lines @@
   // Test adds ... at right spot within a word.
   EXPECT_EQ(L"f\x2026", UTF16ToWide(TruncateString(string, 2,
                                                    CHARACTER_BREAK)));
 
   // Test removes trailing whitespace if break falls between words.
   EXPECT_EQ(L"foooooey\x2026", UTF16ToWide(TruncateString(string, 12,
                                                           CHARACTER_BREAK)));
 }
 
 }  // namespace gfx