Quick fix for NativeTextfieldViewsTest on win aura.

views/controls/textfield/native_textfield_views_unittest.cc

 // Copyright (c) 2011 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.
 
 #include <string>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 16 matching lines @@
 #include "views/events/event.h"
 #include "views/focus/focus_manager.h"
 #include "views/ime/mock_input_method.h"
 #include "views/ime/text_input_client.h"
 #include "views/test/test_views_delegate.h"
 #include "views/test/views_test_base.h"
 #include "views/views_delegate.h"
 #include "views/widget/native_widget_private.h"
 #include "views/widget/widget.h"
 
-// Bug 99128.

[oshima, 2011/10/05 21:02:19]

Can you keep the comment and say still a lot of tests fails on linux? You can
assign it to me once you fixed win side.

[sadrul, 2011/10/05 21:44:56]

FYI http://codereview.chromium.org/8143021/

Some of the tests also need to be marked DISABLED_ on linux.

[msw, 2011/10/05 22:52:20]

I merged with your changes from http://codereview.chromium.org/8143021.

-#if defined(USE_AURA)
-#define MAYBE_KeyTest FAILS_KeyTest
-#define MAYBE_ControlAndSelectTest FAILS_ControlAndSelectTest
-#define MAYBE_InsertionDeletionTest FAILS_InsertionDeletionTest
-#define MAYBE_OnKeyPressReturnValueTest FAILS_OnKeyPressReturnValueTest
-#define MAYBE_CursorMovement FAILS_CursorMovement
-#define MAYBE_DragAndDrop_ToTheRight FAILS_DragAndDrop_ToTheRight
-#define MAYBE_DragAndDrop_ToTheLeft FAILS_DragAndDrop_ToTheLeft
-#define MAYBE_ReadOnlyTest FAILS_ReadOnlyTest
-#define MAYBE_TextInputClientTest FAILS_TextInputClientTest
-#define MAYBE_UndoRedoTest FAILS_UndoRedoTest
-#define MAYBE_TextCursorDisplayTest FAILS_TextCursorDisplayTest
-#define MAYBE_TextCursorDisplayInRTLTest FAILS_TextCursorDisplayInRTLTest
-#define MAYBE_HitOutsideTextAreaTest FAILS_HitOutsideTextAreaTest
-#define MAYBE_HitOutsideTextAreaInRTLTest FAILS_HitOutsideTextAreaInRTLTest
-#define MAYBE_OverflowTest FAILS_OverflowTest
-#define MAYBE_OverflowInRTLTest FAILS_OverflowInRTLTest
-#else
-#define MAYBE_KeyTest KeyTest
-#define MAYBE_ControlAndSelectTest ControlAndSelectTest
-#define MAYBE_InsertionDeletionTest InsertionDeletionTest
-#define MAYBE_OnKeyPressReturnValueTest OnKeyPressReturnValueTest
-#define MAYBE_CursorMovement CursorMovement
-#define MAYBE_DragAndDrop_ToTheRight DragAndDrop_ToTheRight
-#define MAYBE_DragAndDrop_ToTheLeft DragAndDrop_ToTheLeft
-#define MAYBE_ReadOnlyTest ReadOnlyTest
-#define MAYBE_TextInputClientTest TextInputClientTest
-#define MAYBE_UndoRedoTest UndoRedoTest
-#define MAYBE_TextCursorDisplayTest TextCursorDisplayTest
-#define MAYBE_TextCursorDisplayInRTLTest TextCursorDisplayInRTLTest
-#define MAYBE_HitOutsideTextAreaTest HitOutsideTextAreaTest
-#define MAYBE_HitOutsideTextAreaInRTLTest HitOutsideTextAreaInRTLTest
-#define MAYBE_OverflowTest OverflowTest
-#define MAYBE_OverflowInRTLTest OverflowInRTLTest
-#endif
-
 namespace {
 
 // A wrapper of Textfield to intercept the result of OnKeyPressed() and
 // OnKeyReleased() methods.
 class TestTextfield : public views::Textfield {
  public:
   TestTextfield()
       : key_handled_(false),
         key_received_(false) {
   }
@@ skipping 280 matching lines @@
   EXPECT_STR_EQ("this is a test", model_->GetText());
   EXPECT_STR_EQ("this is a test", textfield_->text());
   EXPECT_TRUE(last_contents_.empty());
 
   EXPECT_EQ(string16(), textfield_->GetSelectedText());
   textfield_->SelectAll();
   EXPECT_STR_EQ("this is a test", textfield_->GetSelectedText());
   EXPECT_TRUE(last_contents_.empty());
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_KeyTest) {
+TEST_F(NativeTextfieldViewsTest, KeyTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   SendKeyEvent(ui::VKEY_C, true, false);
   EXPECT_STR_EQ("C", textfield_->text());
   EXPECT_STR_EQ("C", last_contents_);
   last_contents_.clear();
 
   SendKeyEvent(ui::VKEY_R, false, false);
   EXPECT_STR_EQ("Cr", textfield_->text());
   EXPECT_STR_EQ("Cr", last_contents_);
 
   textfield_->SetText(ASCIIToUTF16(""));
   SendKeyEvent(ui::VKEY_C, true, false, true);
   SendKeyEvent(ui::VKEY_C, false, false, true);
   SendKeyEvent(ui::VKEY_1, false, false, true);
   SendKeyEvent(ui::VKEY_1, true, false, true);
   SendKeyEvent(ui::VKEY_1, true, false, false);
   EXPECT_STR_EQ("cC1!!", textfield_->text());
   EXPECT_STR_EQ("cC1!!", last_contents_);
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_ControlAndSelectTest) {
+TEST_F(NativeTextfieldViewsTest, ControlAndSelectTest) {
   // Insert a test string in a textfield.
   InitTextfield(Textfield::STYLE_DEFAULT);
   textfield_->SetText(ASCIIToUTF16("one two three"));
   SendKeyEvent(ui::VKEY_RIGHT,
                               true /* shift */, false /* control */);
   SendKeyEvent(ui::VKEY_RIGHT, true, false);
   SendKeyEvent(ui::VKEY_RIGHT, true, false);
 
   EXPECT_STR_EQ("one", textfield_->GetSelectedText());
 
@@ skipping 14 matching lines @@
   SendKeyEvent(ui::VKEY_O, true, false);
   SendKeyEvent(ui::VKEY_SPACE, false, false);
   EXPECT_STR_EQ("ZERO two three", textfield_->text());
 
   SendKeyEvent(ui::VKEY_END, true, false);
   EXPECT_STR_EQ("two three", textfield_->GetSelectedText());
   SendKeyEvent(ui::VKEY_HOME, true, false);
   EXPECT_STR_EQ("ZERO ", textfield_->GetSelectedText());
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_InsertionDeletionTest) {
+TEST_F(NativeTextfieldViewsTest, InsertionDeletionTest) {
   // Insert a test string in a textfield.
   InitTextfield(Textfield::STYLE_DEFAULT);
   char test_str[] = "this is a test";
   for (size_t i = 0; i < sizeof(test_str); i++) {
     // This is ugly and should be replaced by a utility standard function.
     // See comment in NativeTextfieldViews::GetPrintableChar.
     char c = test_str[i];
     ui::KeyboardCode code =
         c == ' ' ? ui::VKEY_SPACE :
         static_cast<ui::KeyboardCode>(ui::VKEY_A + c - 'a');
@@ skipping 108 matching lines @@
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, GetTextInputType());
 
   textfield_->SetReadOnly(false);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_URL, GetTextInputType());
 
   // As do disabled textfields
   textfield_->SetEnabled(false);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, GetTextInputType());
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_OnKeyPressReturnValueTest) {
+TEST_F(NativeTextfieldViewsTest, OnKeyPressReturnValueTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
 
   // Character keys will be handled by input method.
   SendKeyEvent(ui::VKEY_A);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_FALSE(textfield_->key_handled());
   textfield_->clear();
 
   // Home will be handled.
   SendKeyEvent(ui::VKEY_HOME);
@@ skipping 10 matching lines @@
   SendKeyEvent(ui::VKEY_UP);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_FALSE(textfield_->key_handled());
   textfield_->clear();
 
   SendKeyEvent(ui::VKEY_DOWN);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_FALSE(textfield_->key_handled());
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_CursorMovement) {
+TEST_F(NativeTextfieldViewsTest, CursorMovement) {
   InitTextfield(Textfield::STYLE_DEFAULT);
 
   // Test with trailing whitespace.
   textfield_->SetText(ASCIIToUTF16("one two hre "));
 
   // Send the cursor at the end.
   SendKeyEvent(ui::VKEY_END);
 
   // Ctrl+Left should move the cursor just before the last word.
   SendKeyEvent(ui::VKEY_LEFT, false, true);
@@ skipping 239 matching lines @@
                                                     gfx::Point()));
   EXPECT_EQ(ui::DragDropTypes::DRAG_COPY,
             textfield_view_->GetDragOperationsForView(NULL, kStringPoint));
   EXPECT_TRUE(textfield_view_->CanStartDragForView(NULL, kStringPoint,
                                                    gfx::Point()));
   // Ensure that textfields support local moves.
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY,
       textfield_view_->GetDragOperationsForView(textfield_view_, kStringPoint));
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_DragAndDrop_ToTheRight) {
+TEST_F(NativeTextfieldViewsTest, DragAndDrop_ToTheRight) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   string16 string;
   ui::OSExchangeData data;
   int formats = 0;
   int operations = 0;
   std::set<OSExchangeData::CustomFormat> custom_formats;
 
   // Start dragging "ello".
@@ skipping 33 matching lines @@
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("hello world", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("h welloorld", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("h welloorld", textfield_->text());
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_DragAndDrop_ToTheLeft) {
+TEST_F(NativeTextfieldViewsTest, DragAndDrop_ToTheLeft) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   string16 string;
   ui::OSExchangeData data;
   int formats = 0;
   int operations = 0;
   std::set<OSExchangeData::CustomFormat> custom_formats;
 
   // Start dragging " worl".
@@ skipping 60 matching lines @@
                   ui::EF_LEFT_BUTTON_DOWN);
   MouseEvent release(ui::ET_MOUSE_RELEASED, GetCursorPositionX(9), 0,
                      ui::EF_LEFT_BUTTON_DOWN);
   textfield_view_->OnMouseDragged(drag);
   textfield_view_->OnMouseReleased(release);
   textfield_view_->OnDragDone();
   EXPECT_EQ(ASCIIToUTF16("hello world"), textfield_->text());
 }
 #endif
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_ReadOnlyTest) {
+TEST_F(NativeTextfieldViewsTest, ReadOnlyTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   textfield_->SetText(ASCIIToUTF16(" one two three "));
   textfield_->SetReadOnly(true);
   SendKeyEvent(ui::VKEY_HOME);
   EXPECT_EQ(0U, textfield_->GetCursorPosition());
 
   SendKeyEvent(ui::VKEY_END);
   EXPECT_EQ(15U, textfield_->GetCursorPosition());
 
   SendKeyEvent(ui::VKEY_LEFT, false, false);
@@ skipping 13 matching lines @@
   SendKeyEvent(ui::VKEY_X, false, true);
   EXPECT_STR_EQ(" one two three ", textfield_->GetSelectedText());
   string16 str;
   views::ViewsDelegate::views_delegate->GetClipboard()->
       ReadText(ui::Clipboard::BUFFER_STANDARD, &str);
   EXPECT_STR_NE(" one two three ", str);
 
   SendKeyEvent(ui::VKEY_C, false, true);
   views::ViewsDelegate::views_delegate->GetClipboard()->
       ReadText(ui::Clipboard::BUFFER_STANDARD, &str);
   EXPECT_STR_EQ(" one two three ", str);

[oshima, 2011/10/05 20:15:09]

Did this work? It failed on linux because clipboard implmentation is empty for
aura. I wonder if aura/windows build is using window's clipboard.

[msw, 2011/10/05 20:45:34]

Yes, it does work, via clipboard_win's ui::Clipboard. It seems like it should be
using clipboard_aura and failing. Recommendations?

[oshima, 2011/10/05 21:02:19]

I see. I think we added aura because linux impl uses gtk.
I think win build can keep using window's clipboard. I'm okay as it is now.

 
   // SetText should work even in read only mode.
   textfield_->SetText(ASCIIToUTF16(" four five six "));
   EXPECT_STR_EQ(" four five six ", textfield_->text());
 
   // Paste shouldn't work.
   SendKeyEvent(ui::VKEY_V, false, true);
   EXPECT_STR_EQ(" four five six ", textfield_->text());
   EXPECT_TRUE(textfield_->GetSelectedText().empty());
 
   textfield_->SelectAll();
   EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
 
   // Text field is unmodifiable and selection shouldn't change.
   SendKeyEvent(ui::VKEY_DELETE);
   EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
   SendKeyEvent(ui::VKEY_BACK);
   EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
   SendKeyEvent(ui::VKEY_T);
   EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_TextInputClientTest) {
+TEST_F(NativeTextfieldViewsTest, TextInputClientTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   TextInputClient* client = textfield_->GetTextInputClient();
   EXPECT_TRUE(client);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, client->GetTextInputType());
 
   textfield_->SetText(ASCIIToUTF16("0123456789"));
   ui::Range range;
   EXPECT_TRUE(client->GetTextRange(&range));
   EXPECT_EQ(0U, range.start());
   EXPECT_EQ(10U, range.end());
@@ skipping 69 matching lines @@
   EXPECT_TRUE(input_method_->text_input_type_changed());
   EXPECT_FALSE(textfield_->GetTextInputClient());
 
   textfield_->SetReadOnly(false);
   input_method_->Clear();
   textfield_->SetPassword(true);
   EXPECT_TRUE(input_method_->text_input_type_changed());
   EXPECT_TRUE(textfield_->GetTextInputClient());
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_UndoRedoTest) {
+TEST_F(NativeTextfieldViewsTest, UndoRedoTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   SendKeyEvent(ui::VKEY_A);
   EXPECT_STR_EQ("a", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("a", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
@@ skipping 87 matching lines @@
   SendKeyEvent(ui::VKEY_A);
   EXPECT_STR_EQ("a23", textfield_->text());
   SendKeyEvent(ui::VKEY_B);
   EXPECT_STR_EQ("ab3", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("123", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("ab3", textfield_->text());
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_TextCursorDisplayTest) {
+TEST_F(NativeTextfieldViewsTest, TextCursorDisplayTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   // LTR-RTL string in LTR context.
   SendKeyEvent('a');
   EXPECT_STR_EQ("a", textfield_->text());
   int x = GetCursorBounds().x();
   int prev_x = x;
 
   SendKeyEvent('b');
   EXPECT_STR_EQ("ab", textfield_->text());
   x = GetCursorBounds().x();
@@ skipping 31 matching lines @@
   x = GetCursorBounds().x();
   EXPECT_LT(prev_x, x);
   prev_x = x;
 
   SendKeyEvent('b');
   EXPECT_EQ(WideToUTF16(L"\x05E1\x5E2"L"ab"), textfield_->text());
   x = GetCursorBounds().x();
   EXPECT_LT(prev_x, x);
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_TextCursorDisplayInRTLTest) {
+TEST_F(NativeTextfieldViewsTest, TextCursorDisplayInRTLTest) {
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 
   InitTextfield(Textfield::STYLE_DEFAULT);
   // LTR-RTL string in RTL context.
   SendKeyEvent('a');
   EXPECT_STR_EQ("a", textfield_->text());
   int x = GetCursorBounds().x();
   EXPECT_EQ(GetDisplayRect().right() - 1, x);
   int prev_x = x;
@@ skipping 97 matching lines @@
     // for the test to run if using sleep().
     NonClientMouseClick();
 
     MouseClick(cursor_bounds[i + 1], - (half_width / 2));
     EXPECT_EQ(cursor_pos_expected[index++], textfield_->GetCursorPosition());
 
     NonClientMouseClick();
   }
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_HitOutsideTextAreaTest) {
+TEST_F(NativeTextfieldViewsTest, HitOutsideTextAreaTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
 
   // LTR-RTL string in LTR context.
   textfield_->SetText(WideToUTF16(L"ab\x05E1\x5E2"));
 
   SendKeyEvent(ui::VKEY_HOME);
   gfx::Rect bound = GetCursorBounds();
   MouseClick(bound, -10);
   EXPECT_EQ(bound, GetCursorBounds());
 
@@ skipping 19 matching lines @@
   SendKeyEvent(ui::VKEY_END);
   bound = GetCursorBounds();
 #if defined(OS_WIN)
   MouseClick(bound, 10);
 #else
   MouseClick(bound, -10);
 #endif
   EXPECT_EQ(bound, GetCursorBounds());
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_HitOutsideTextAreaInRTLTest) {
+TEST_F(NativeTextfieldViewsTest, HitOutsideTextAreaInRTLTest) {
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 
   InitTextfield(Textfield::STYLE_DEFAULT);
 
   // RTL-LTR string in RTL context.
   textfield_->SetText(WideToUTF16(L"\x05E1\x5E2"L"ab"));
   SendKeyEvent(ui::VKEY_HOME);
   gfx::Rect bound = GetCursorBounds();
   MouseClick(bound, 10);
@@ skipping 33 matching lines @@
 // This verifies that |bound| is contained by |display|. |bound|'s right edge
 // must be less than |diaplay|'s right edge.
 void OverflowCursorBoundTestVerifier(const gfx::Rect& display,
                                      const gfx::Rect& bound) {
   EXPECT_LE(display.x(), bound.x());
   EXPECT_GT(display.right(), bound.right());
   EXPECT_LE(display.y(), bound.y());
   EXPECT_GE(display.bottom(), bound.bottom());
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_OverflowTest) {
+TEST_F(NativeTextfieldViewsTest, OverflowTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
 
   string16 str;
   for (int i = 0; i < 500; ++i)
     SendKeyEvent('a');
   SendKeyEvent(kHebrewLetterSamekh);
   gfx::Rect bound = GetCursorBounds();
   gfx::Rect display = GetDisplayRect();
   OverflowCursorBoundTestVerifier(display, bound);
 
   // Test mouse pointing.
   MouseClick(bound, -1);
   EXPECT_EQ(500U, textfield_->GetCursorPosition());
 
   // Clear text.
   SendKeyEvent(ui::VKEY_A, false, true);
   SendKeyEvent('\n');
 
   for (int i = 0; i < 500; ++i)
     SendKeyEvent(kHebrewLetterSamekh);
   SendKeyEvent('a');
   bound = GetCursorBounds();
   display = GetDisplayRect();
   OverflowCursorBoundTestVerifier(display, bound);
 
   MouseClick(bound, -1);
   EXPECT_EQ(501U, textfield_->GetCursorPosition());
 }
 
-TEST_F(NativeTextfieldViewsTest, MAYBE_OverflowInRTLTest) {
+TEST_F(NativeTextfieldViewsTest, OverflowInRTLTest) {
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 
   InitTextfield(Textfield::STYLE_DEFAULT);
 
   string16 str;
   for (int i = 0; i < 500; ++i)
     SendKeyEvent('a');
   SendKeyEvent(kHebrewLetterSamekh);
   gfx::Rect bound = GetCursorBounds();
@@ skipping 22 matching lines @@
   EXPECT_EQ(0U, textfield_->GetCursorPosition());
 #else
   EXPECT_EQ(500U, textfield_->GetCursorPosition());
 #endif
 
   // Reset locale.
   base::i18n::SetICUDefaultLocale(locale);
 }
 
 }  // namespace views