#include <set>
+#include "base/basictypes.h"
#include "base/strings/utf_string_conversions.h"
+#include "ui/base/ime/text_input_client.h"
#include "ui/base/models/combobox_model.h"
#include "ui/events/event.h"
+#include "ui/events/event_constants.h"
#include "ui/events/keycodes/keyboard_codes.h"
+#include "ui/views/controls/combobox/combobox_listener.h"
+#include "ui/views/controls/menu/menu_runner.h"
+#include "ui/views/controls/menu/menu_runner_handler.h"
#include "ui/views/ime/mock_input_method.h"
+#include "ui/views/test/menu_runner_test_api.h"
#include "ui/views/test/views_test_base.h"
#include "ui/views/widget/widget.h"
+using base::ASCIIToUTF16;
+
+namespace views {
+
namespace {
+// An dummy implementation of MenuRunnerHandler to check if the dropdown menu is
+// shown or not.
+class TestMenuRunnerHandler : public MenuRunnerHandler {
+ public:
+ TestMenuRunnerHandler() : executed_(false) {}
+
+ bool executed() const { return executed_; }
+
+ virtual MenuRunner::RunResult RunMenuAt(Widget* parent,
+ MenuButton* button,
+ const gfx::Rect& bounds,
+ MenuItemView::AnchorPosition anchor,
+ ui::MenuSourceType source_type,
+ int32 types) OVERRIDE {
+ executed_ = true;
+ return MenuRunner::NORMAL_EXIT;
+ }
+
+ private:
+ bool executed_;
+
+ DISALLOW_COPY_AND_ASSIGN(TestMenuRunnerHandler);
+};
+
// A wrapper of Combobox to intercept the result of OnKeyPressed() and
// OnKeyReleased() methods.
-class TestCombobox : public views::Combobox {
+class TestCombobox : public Combobox {
public:
explicit TestCombobox(ui::ComboboxModel* model)
: Combobox(model),
key_handled_(false),
- key_received_(false) {
- }
+ key_received_(false) {}
virtual bool OnKeyPressed(const ui::KeyEvent& e) OVERRIDE {
key_received_ = true;
- key_handled_ = views::Combobox::OnKeyPressed(e);
+ key_handled_ = Combobox::OnKeyPressed(e);
return key_handled_;
}
virtual bool OnKeyReleased(const ui::KeyEvent& e) OVERRIDE {
key_received_ = true;
- key_handled_ = views::Combobox::OnKeyReleased(e);
+ key_handled_ = Combobox::OnKeyReleased(e);
return key_handled_;
}
virtual int GetItemCount() const OVERRIDE {
return 10;
}
- virtual string16 GetItemAt(int index) OVERRIDE {
- DCHECK(!IsItemSeparatorAt(index));
- return ASCIIToUTF16(IsItemSeparatorAt(index) ? "SEPARATOR" : "ITEM");
+ virtual base::string16 GetItemAt(int index) OVERRIDE {
+ if (IsItemSeparatorAt(index)) {
+ NOTREACHED();
+ return ASCIIToUTF16("SEPARATOR");
+ }
+ return ASCIIToUTF16(index % 2 == 0 ? "PEANUT BUTTER" : "JELLY");
}
virtual bool IsItemSeparatorAt(int index) OVERRIDE {
return separators_.find(index) != separators_.end();
DISALLOW_COPY_AND_ASSIGN(TestComboboxModel);
};
-} // namespace
+// A combobox model which refers to a vector.
+class VectorComboboxModel : public ui::ComboboxModel {
+ public:
+ explicit VectorComboboxModel(std::vector<std::string>* values)
+ : values_(values) {}
+ virtual ~VectorComboboxModel() {}
-namespace views {
+ // ui::ComboboxModel:
+ virtual int GetItemCount() const OVERRIDE {
+ return (int)values_->size();
+ }
+ virtual base::string16 GetItemAt(int index) OVERRIDE {
+ return ASCIIToUTF16(values_->at(index));
+ }
+ virtual bool IsItemSeparatorAt(int index) OVERRIDE {
+ return false;
+ }
+
+ private:
+ std::vector<std::string>* values_;
+};
+
+class EvilListener : public ComboboxListener {
+ public:
+ EvilListener() : deleted_(false) {}
+ virtual ~EvilListener() {};
+
+ // ComboboxListener:
+ virtual void OnPerformAction(Combobox* combobox) OVERRIDE {
+ delete combobox;
+ deleted_ = true;
+ }
+
+ bool deleted() const { return deleted_; }
+
+ private:
+ bool deleted_;
+
+ DISALLOW_COPY_AND_ASSIGN(EvilListener);
+};
+
+class TestComboboxListener : public views::ComboboxListener {
+ public:
+ TestComboboxListener() : perform_action_index_(-1), actions_performed_(0) {}
+ virtual ~TestComboboxListener() {}
+
+ virtual void OnPerformAction(views::Combobox* combobox) OVERRIDE {
+ perform_action_index_ = combobox->selected_index();
+ actions_performed_++;
+ }
+
+ int perform_action_index() const {
+ return perform_action_index_;
+ }
+
+ bool on_perform_action_called() const {
+ return actions_performed_ > 0;
+ }
+
+ int actions_performed() const {
+ return actions_performed_;
+ }
+
+ private:
+ int perform_action_index_;
+ int actions_performed_;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(TestComboboxListener);
+};
+
+} // namespace
class ComboboxTest : public ViewsTestBase {
public:
- ComboboxTest() : widget_(NULL), combobox_(NULL), input_method_(NULL) {}
+ ComboboxTest() : widget_(NULL), combobox_(NULL) {}
virtual void TearDown() OVERRIDE {
if (widget_)
widget_ = new Widget;
Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
- params.bounds = gfx::Rect(100, 100, 100, 100);
+ params.bounds = gfx::Rect(200, 200, 200, 200);
widget_->Init(params);
View* container = new View();
widget_->SetContentsView(container);
container->AddChildView(combobox_);
- input_method_ = new MockInputMethod();
- widget_->ReplaceInputMethod(input_method_);
+ widget_->ReplaceInputMethod(new MockInputMethod);
// Assumes the Widget is always focused.
- input_method_->OnFocus();
+ widget_->GetInputMethod()->OnFocus();
combobox_->RequestFocus();
+ combobox_->SizeToPreferredSize();
}
protected:
void SendKeyEvent(ui::KeyboardCode key_code) {
- ui::KeyEvent event(ui::ET_KEY_PRESSED, key_code, 0, false);
- input_method_->DispatchKeyEvent(event);
+ SendKeyEventWithType(key_code, ui::ET_KEY_PRESSED);
+ }
+
+ void SendKeyEventWithType(ui::KeyboardCode key_code, ui::EventType type) {
+ ui::KeyEvent event(type, key_code, 0, false);
+ widget_->GetInputMethod()->DispatchKeyEvent(event);
}
View* GetFocusedView() {
return widget_->GetFocusManager()->GetFocusedView();
}
+ void PerformClick(const gfx::Point& point) {
+ ui::MouseEvent pressed_event = ui::MouseEvent(ui::ET_MOUSE_PRESSED, point,
+ point,
+ ui::EF_LEFT_MOUSE_BUTTON,
+ ui::EF_LEFT_MOUSE_BUTTON);
+ widget_->OnMouseEvent(&pressed_event);
+ ui::MouseEvent released_event = ui::MouseEvent(ui::ET_MOUSE_RELEASED, point,
+ point,
+ ui::EF_LEFT_MOUSE_BUTTON,
+ ui::EF_LEFT_MOUSE_BUTTON);
+ widget_->OnMouseEvent(&released_event);
+ }
+
// We need widget to populate wrapper class.
Widget* widget_;
// Combobox does not take ownership of the model, hence it needs to be scoped.
scoped_ptr<TestComboboxModel> model_;
-
- // For testing input method related behaviors.
- MockInputMethod* input_method_;
};
TEST_F(ComboboxTest, KeyTest) {
separators.insert(9);
model_->SetSeparators(separators);
for (int i = 0; i < combobox_->GetRowCount(); ++i) {
- if (separators.count(i) != 0)
+ if (separators.count(i) != 0) {
EXPECT_TRUE(combobox_->GetTextForRow(i).empty()) << i;
- else
- EXPECT_EQ(ASCIIToUTF16("ITEM"), combobox_->GetTextForRow(i)) << i;
+ } else {
+ EXPECT_EQ(ASCIIToUTF16(i % 2 == 0 ? "PEANUT BUTTER" : "JELLY"),
+ combobox_->GetTextForRow(i)) << i;
+ }
}
}
+// Verifies selecting the first matching value (and returning whether found).
+TEST_F(ComboboxTest, SelectValue) {
+ InitCombobox();
+ ASSERT_EQ(model_->GetDefaultIndex(), combobox_->selected_index());
+ EXPECT_TRUE(combobox_->SelectValue(ASCIIToUTF16("PEANUT BUTTER")));
+ EXPECT_EQ(0, combobox_->selected_index());
+ EXPECT_TRUE(combobox_->SelectValue(ASCIIToUTF16("JELLY")));
+ EXPECT_EQ(1, combobox_->selected_index());
+ EXPECT_FALSE(combobox_->SelectValue(ASCIIToUTF16("BANANAS")));
+ EXPECT_EQ(1, combobox_->selected_index());
+
+ // With the action style, the selected index is always 0.
+ combobox_->SetStyle(Combobox::STYLE_ACTION);
+ EXPECT_FALSE(combobox_->SelectValue(ASCIIToUTF16("PEANUT BUTTER")));
+ EXPECT_EQ(0, combobox_->selected_index());
+ EXPECT_FALSE(combobox_->SelectValue(ASCIIToUTF16("JELLY")));
+ EXPECT_EQ(0, combobox_->selected_index());
+ EXPECT_FALSE(combobox_->SelectValue(ASCIIToUTF16("BANANAS")));
+ EXPECT_EQ(0, combobox_->selected_index());
+}
+
+TEST_F(ComboboxTest, SelectIndexActionStyle) {
+ InitCombobox();
+
+ // With the action style, the selected index is always 0.
+ combobox_->SetStyle(Combobox::STYLE_ACTION);
+ combobox_->SetSelectedIndex(1);
+ EXPECT_EQ(0, combobox_->selected_index());
+ combobox_->SetSelectedIndex(2);
+ EXPECT_EQ(0, combobox_->selected_index());
+ combobox_->SetSelectedIndex(3);
+ EXPECT_EQ(0, combobox_->selected_index());
+}
+
+TEST_F(ComboboxTest, ListenerHandlesDelete) {
+ TestComboboxModel model;
+
+ // |combobox| will be deleted on change.
+ TestCombobox* combobox = new TestCombobox(&model);
+ scoped_ptr<EvilListener> evil_listener(new EvilListener());
+ combobox->set_listener(evil_listener.get());
+ ASSERT_NO_FATAL_FAILURE(combobox->ExecuteCommand(2));
+ EXPECT_TRUE(evil_listener->deleted());
+
+ // With STYLE_ACTION
+ // |combobox| will be deleted on change.
+ combobox = new TestCombobox(&model);
+ evil_listener.reset(new EvilListener());
+ combobox->set_listener(evil_listener.get());
+ combobox->SetStyle(Combobox::STYLE_ACTION);
+ ASSERT_NO_FATAL_FAILURE(combobox->ExecuteCommand(2));
+ EXPECT_TRUE(evil_listener->deleted());
+}
+
+TEST_F(ComboboxTest, Click) {
+ InitCombobox();
+
+ TestComboboxListener listener;
+ combobox_->set_listener(&listener);
+
+ combobox_->Layout();
+
+ // Click the left side. The menu is shown.
+ TestMenuRunnerHandler* test_menu_runner_handler = new TestMenuRunnerHandler();
+ scoped_ptr<MenuRunnerHandler> menu_runner_handler(test_menu_runner_handler);
+ test::MenuRunnerTestAPI test_api(
+ combobox_->dropdown_list_menu_runner_.get());
+ test_api.SetMenuRunnerHandler(menu_runner_handler.Pass());
+ PerformClick(gfx::Point(combobox_->x() + 1,
+ combobox_->y() + combobox_->height() / 2));
+ EXPECT_FALSE(listener.on_perform_action_called());
+ EXPECT_TRUE(test_menu_runner_handler->executed());
+}
+
+TEST_F(ComboboxTest, NotifyOnClickWithReturnKey) {
+ InitCombobox();
+
+ TestComboboxListener listener;
+ combobox_->set_listener(&listener);
+
+ // With STYLE_NORMAL, the click event is ignored.
+ SendKeyEvent(ui::VKEY_RETURN);
+ EXPECT_FALSE(listener.on_perform_action_called());
+
+ // With STYLE_ACTION, the click event is notified.
+ combobox_->SetStyle(Combobox::STYLE_ACTION);
+ SendKeyEvent(ui::VKEY_RETURN);
+ EXPECT_TRUE(listener.on_perform_action_called());
+ EXPECT_EQ(0, listener.perform_action_index());
+}
+
+TEST_F(ComboboxTest, NotifyOnClickWithSpaceKey) {
+ InitCombobox();
+
+ TestComboboxListener listener;
+ combobox_->set_listener(&listener);
+
+ // With STYLE_NORMAL, the click event is ignored.
+ SendKeyEvent(ui::VKEY_SPACE);
+ EXPECT_FALSE(listener.on_perform_action_called());
+ SendKeyEventWithType(ui::VKEY_SPACE, ui::ET_KEY_RELEASED);
+ EXPECT_FALSE(listener.on_perform_action_called());
+
+ // With STYLE_ACTION, the click event is notified after releasing.
+ combobox_->SetStyle(Combobox::STYLE_ACTION);
+ SendKeyEvent(ui::VKEY_SPACE);
+ EXPECT_FALSE(listener.on_perform_action_called());
+ SendKeyEventWithType(ui::VKEY_SPACE, ui::ET_KEY_RELEASED);
+ EXPECT_TRUE(listener.on_perform_action_called());
+ EXPECT_EQ(0, listener.perform_action_index());
+}
+
+TEST_F(ComboboxTest, NotifyOnClickWithMouse) {
+ InitCombobox();
+
+ TestComboboxListener listener;
+ combobox_->set_listener(&listener);
+
+ combobox_->SetStyle(Combobox::STYLE_ACTION);
+ combobox_->Layout();
+
+ // Click the right side (arrow button). The menu is shown.
+ TestMenuRunnerHandler* test_menu_runner_handler = new TestMenuRunnerHandler();
+ scoped_ptr<MenuRunnerHandler> menu_runner_handler(test_menu_runner_handler);
+ scoped_ptr<test::MenuRunnerTestAPI> test_api(
+ new test::MenuRunnerTestAPI(combobox_->dropdown_list_menu_runner_.get()));
+ test_api->SetMenuRunnerHandler(menu_runner_handler.Pass());
+
+ PerformClick(gfx::Point(combobox_->x() + combobox_->width() - 1,
+ combobox_->y() + combobox_->height() / 2));
+ EXPECT_FALSE(listener.on_perform_action_called());
+ EXPECT_TRUE(test_menu_runner_handler->executed());
+
+ // Click the left side (text button). The click event is notified.
+ test_menu_runner_handler = new TestMenuRunnerHandler();
+ menu_runner_handler.reset(test_menu_runner_handler);
+ test_api.reset(
+ new test::MenuRunnerTestAPI(combobox_->dropdown_list_menu_runner_.get()));
+ test_api->SetMenuRunnerHandler(menu_runner_handler.Pass());
+ PerformClick(gfx::Point(combobox_->x() + 1,
+ combobox_->y() + combobox_->height() / 2));
+ EXPECT_TRUE(listener.on_perform_action_called());
+ EXPECT_FALSE(test_menu_runner_handler->executed());
+ EXPECT_EQ(0, listener.perform_action_index());
+}
+
+TEST_F(ComboboxTest, ConsumingPressKeyEvents) {
+ InitCombobox();
+
+ EXPECT_FALSE(combobox_->OnKeyPressed(
+ ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_RETURN, 0, false)));
+ EXPECT_FALSE(combobox_->OnKeyPressed(
+ ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_SPACE, 0, false)));
+
+ // When the combobox's style is STYLE_ACTION, pressing events of a space key
+ // or an enter key will be consumed.
+ combobox_->SetStyle(Combobox::STYLE_ACTION);
+ EXPECT_TRUE(combobox_->OnKeyPressed(
+ ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_RETURN, 0, false)));
+ EXPECT_TRUE(combobox_->OnKeyPressed(
+ ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_SPACE, 0, false)));
+}
+
+// Disabled because of memory leaks, see http://crbug.com/341042.
+TEST_F(ComboboxTest, DISABLED_ContentWidth) {
+ std::vector<std::string> values;
+
+ scoped_ptr<VectorComboboxModel> model(new VectorComboboxModel(&values));
+ combobox_ = new TestCombobox(model.get());
+
+ std::string long_item = "this is the long item";
+ std::string short_item = "s";
+
+ values.resize(1);
+ values[0] = long_item;
+ combobox_->ModelChanged();
+
+ const int long_item_width = combobox_->content_size_.width();
+
+ values[0] = short_item;
+ combobox_->ModelChanged();
+
+ const int short_item_width = combobox_->content_size_.width();
+
+ values.resize(2);
+ values[0] = short_item;
+ values[1] = long_item;
+ combobox_->ModelChanged();
+
+ // When the style is STYLE_NORMAL, the width will fit with the longest item.
+ combobox_->SetStyle(Combobox::STYLE_NORMAL);
+ EXPECT_EQ(long_item_width, combobox_->content_size_.width());
+
+ // When the style is STYLE_ACTION, the width will fit with the first items'
+ // width.
+ combobox_->SetStyle(Combobox::STYLE_ACTION);
+ EXPECT_EQ(short_item_width, combobox_->content_size_.width());
+}
+
+TEST_F(ComboboxTest, TypingPrefixNotifiesListener) {
+ InitCombobox();
+
+ TestComboboxListener listener;
+ combobox_->set_listener(&listener);
+
+ // Type the first character of the second menu item ("JELLY").
+ combobox_->GetTextInputClient()->InsertChar('J', ui::EF_NONE);
+ EXPECT_EQ(1, listener.actions_performed());
+ EXPECT_EQ(1, listener.perform_action_index());
+
+ // Type the second character of "JELLY", item shouldn't change and
+ // OnPerformAction() shouldn't be re-called.
+ combobox_->GetTextInputClient()->InsertChar('E', ui::EF_NONE);
+ EXPECT_EQ(1, listener.actions_performed());
+ EXPECT_EQ(1, listener.perform_action_index());
+
+ // Clears the typed text.
+ combobox_->OnBlur();
+
+ // Type the first character of "PEANUT BUTTER", which should change the
+ // selected index and perform an action.
+ combobox_->GetTextInputClient()->InsertChar('P', ui::EF_NONE);
+ EXPECT_EQ(2, listener.actions_performed());
+ EXPECT_EQ(2, listener.perform_action_index());
+}
+
} // namespace views
projects / platform / framework / web / crosswalk.git / blobdiff