ui/views/controls/combobox/combobox_unittest.cc

   1 // Copyright 2013 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/combobox/combobox.h"
   6
   7 #include <set>
   8
   9 #include "base/basictypes.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "ui/base/ime/text_input_client.h"
  12 #include "ui/base/models/combobox_model.h"
  13 #include "ui/events/event.h"
  14 #include "ui/events/event_constants.h"
  15 #include "ui/events/keycodes/keyboard_codes.h"
  16 #include "ui/views/controls/combobox/combobox_listener.h"
  17 #include "ui/views/controls/menu/menu_runner.h"
  18 #include "ui/views/controls/menu/menu_runner_handler.h"
  19 #include "ui/views/ime/mock_input_method.h"
  20 #include "ui/views/test/menu_runner_test_api.h"
  21 #include "ui/views/test/views_test_base.h"
  22 #include "ui/views/widget/widget.h"
  23
  24 using base::ASCIIToUTF16;
  25
  26 namespace views {
  27
  28 namespace {
  29
  30 // An dummy implementation of MenuRunnerHandler to check if the dropdown menu is
  31 // shown or not.
  32 class TestMenuRunnerHandler : public MenuRunnerHandler {
  33  public:
  34   TestMenuRunnerHandler() : executed_(false) {}
  35
  36   bool executed() const { return executed_; }
  37
  38   virtual MenuRunner::RunResult RunMenuAt(Widget* parent,
  39                                           MenuButton* button,
  40                                           const gfx::Rect& bounds,
  41                                           MenuAnchorPosition anchor,
  42                                           ui::MenuSourceType source_type,
  43                                           int32 types) OVERRIDE {
  44     executed_ = true;
  45     return MenuRunner::NORMAL_EXIT;
  46   }
  47
  48  private:
  49   bool executed_;
  50
  51   DISALLOW_COPY_AND_ASSIGN(TestMenuRunnerHandler);
  52 };
  53
  54 // A wrapper of Combobox to intercept the result of OnKeyPressed() and
  55 // OnKeyReleased() methods.
  56 class TestCombobox : public Combobox {
  57  public:
  58   explicit TestCombobox(ui::ComboboxModel* model)
  59       : Combobox(model),
  60         key_handled_(false),
  61         key_received_(false) {}
  62
  63   virtual bool OnKeyPressed(const ui::KeyEvent& e) OVERRIDE {
  64     key_received_ = true;
  65     key_handled_ = Combobox::OnKeyPressed(e);
  66     return key_handled_;
  67   }
  68
  69   virtual bool OnKeyReleased(const ui::KeyEvent& e) OVERRIDE {
  70     key_received_ = true;
  71     key_handled_ = Combobox::OnKeyReleased(e);
  72     return key_handled_;
  73   }
  74
  75   bool key_handled() const { return key_handled_; }
  76   bool key_received() const { return key_received_; }
  77
  78   void clear() {
  79     key_received_ = key_handled_ = false;
  80   }
  81
  82  private:
  83   bool key_handled_;
  84   bool key_received_;
  85
  86   DISALLOW_COPY_AND_ASSIGN(TestCombobox);
  87 };
  88
  89 // A concrete class is needed to test the combobox.
  90 class TestComboboxModel : public ui::ComboboxModel {
  91  public:
  92   TestComboboxModel() {}
  93   virtual ~TestComboboxModel() {}
  94
  95   // ui::ComboboxModel:
  96   virtual int GetItemCount() const OVERRIDE {
  97     return 10;
  98   }
  99   virtual base::string16 GetItemAt(int index) OVERRIDE {
 100     if (IsItemSeparatorAt(index)) {
 101       NOTREACHED();
 102       return ASCIIToUTF16("SEPARATOR");
 103     }
 104     return ASCIIToUTF16(index % 2 == 0 ? "PEANUT BUTTER" : "JELLY");
 105   }
 106   virtual bool IsItemSeparatorAt(int index) OVERRIDE {
 107     return separators_.find(index) != separators_.end();
 108   }
 109
 110   void SetSeparators(const std::set<int>& separators) {
 111     separators_ = separators;
 112   }
 113
 114  private:
 115   std::set<int> separators_;
 116
 117   DISALLOW_COPY_AND_ASSIGN(TestComboboxModel);
 118 };
 119
 120 // A combobox model which refers to a vector.
 121 class VectorComboboxModel : public ui::ComboboxModel {
 122  public:
 123   explicit VectorComboboxModel(std::vector<std::string>* values)
 124       : values_(values) {}
 125   virtual ~VectorComboboxModel() {}
 126
 127   // ui::ComboboxModel:
 128   virtual int GetItemCount() const OVERRIDE {
 129     return (int)values_->size();
 130   }
 131   virtual base::string16 GetItemAt(int index) OVERRIDE {
 132     return ASCIIToUTF16(values_->at(index));
 133   }
 134   virtual bool IsItemSeparatorAt(int index) OVERRIDE {
 135     return false;
 136   }
 137
 138  private:
 139   std::vector<std::string>* values_;
 140 };
 141
 142 class EvilListener : public ComboboxListener {
 143  public:
 144   EvilListener() : deleted_(false) {}
 145   virtual ~EvilListener() {};
 146
 147   // ComboboxListener:
 148   virtual void OnPerformAction(Combobox* combobox) OVERRIDE {
 149     delete combobox;
 150     deleted_ = true;
 151   }
 152
 153   bool deleted() const { return deleted_; }
 154
 155  private:
 156   bool deleted_;
 157
 158   DISALLOW_COPY_AND_ASSIGN(EvilListener);
 159 };
 160
 161 class TestComboboxListener : public views::ComboboxListener {
 162  public:
 163   TestComboboxListener() : perform_action_index_(-1), actions_performed_(0) {}
 164   virtual ~TestComboboxListener() {}
 165
 166   virtual void OnPerformAction(views::Combobox* combobox) OVERRIDE {
 167     perform_action_index_ = combobox->selected_index();
 168     actions_performed_++;
 169   }
 170
 171   int perform_action_index() const {
 172     return perform_action_index_;
 173   }
 174
 175   bool on_perform_action_called() const {
 176     return actions_performed_ > 0;
 177   }
 178
 179   int actions_performed() const {
 180     return actions_performed_;
 181   }
 182
 183  private:
 184   int perform_action_index_;
 185   int actions_performed_;
 186
 187  private:
 188   DISALLOW_COPY_AND_ASSIGN(TestComboboxListener);
 189 };
 190
 191 }  // namespace
 192
 193 class ComboboxTest : public ViewsTestBase {
 194  public:
 195   ComboboxTest() : widget_(NULL), combobox_(NULL) {}
 196
 197   virtual void TearDown() OVERRIDE {
 198     if (widget_)
 199       widget_->Close();
 200     ViewsTestBase::TearDown();
 201   }
 202
 203   void InitCombobox() {
 204     model_.reset(new TestComboboxModel());
 205
 206     ASSERT_FALSE(combobox_);
 207     combobox_ = new TestCombobox(model_.get());
 208     combobox_->set_id(1);
 209
 210     widget_ = new Widget;
 211     Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
 212     params.bounds = gfx::Rect(200, 200, 200, 200);
 213     widget_->Init(params);
 214     View* container = new View();
 215     widget_->SetContentsView(container);
 216     container->AddChildView(combobox_);
 217
 218     widget_->ReplaceInputMethod(new MockInputMethod);
 219
 220     // Assumes the Widget is always focused.
 221     widget_->GetInputMethod()->OnFocus();
 222
 223     combobox_->RequestFocus();
 224     combobox_->SizeToPreferredSize();
 225   }
 226
 227  protected:
 228   void SendKeyEvent(ui::KeyboardCode key_code) {
 229     SendKeyEventWithType(key_code, ui::ET_KEY_PRESSED);
 230   }
 231
 232   void SendKeyEventWithType(ui::KeyboardCode key_code, ui::EventType type) {
 233     ui::KeyEvent event(type, key_code, 0, false);
 234     widget_->GetInputMethod()->DispatchKeyEvent(event);
 235   }
 236
 237   View* GetFocusedView() {
 238     return widget_->GetFocusManager()->GetFocusedView();
 239   }
 240
 241   void PerformClick(const gfx::Point& point) {
 242     ui::MouseEvent pressed_event = ui::MouseEvent(ui::ET_MOUSE_PRESSED, point,
 243                                                   point,
 244                                                   ui::EF_LEFT_MOUSE_BUTTON,
 245                                                   ui::EF_LEFT_MOUSE_BUTTON);
 246     widget_->OnMouseEvent(&pressed_event);
 247     ui::MouseEvent released_event = ui::MouseEvent(ui::ET_MOUSE_RELEASED, point,
 248                                                    point,
 249                                                    ui::EF_LEFT_MOUSE_BUTTON,
 250                                                    ui::EF_LEFT_MOUSE_BUTTON);
 251     widget_->OnMouseEvent(&released_event);
 252   }
 253
 254   // We need widget to populate wrapper class.
 255   Widget* widget_;
 256
 257   // |combobox_| will be allocated InitCombobox() and then owned by |widget_|.
 258   TestCombobox* combobox_;
 259
 260   // Combobox does not take ownership of the model, hence it needs to be scoped.
 261   scoped_ptr<TestComboboxModel> model_;
 262 };
 263
 264 TEST_F(ComboboxTest, KeyTest) {
 265   InitCombobox();
 266   SendKeyEvent(ui::VKEY_END);
 267   EXPECT_EQ(combobox_->selected_index() + 1, model_->GetItemCount());
 268   SendKeyEvent(ui::VKEY_HOME);
 269   EXPECT_EQ(combobox_->selected_index(), 0);
 270   SendKeyEvent(ui::VKEY_DOWN);
 271   SendKeyEvent(ui::VKEY_DOWN);
 272   EXPECT_EQ(combobox_->selected_index(), 2);
 273   SendKeyEvent(ui::VKEY_RIGHT);
 274   EXPECT_EQ(combobox_->selected_index(), 2);
 275   SendKeyEvent(ui::VKEY_LEFT);
 276   EXPECT_EQ(combobox_->selected_index(), 2);
 277   SendKeyEvent(ui::VKEY_UP);
 278   EXPECT_EQ(combobox_->selected_index(), 1);
 279   SendKeyEvent(ui::VKEY_PRIOR);
 280   EXPECT_EQ(combobox_->selected_index(), 0);
 281   SendKeyEvent(ui::VKEY_NEXT);
 282   EXPECT_EQ(combobox_->selected_index(), model_->GetItemCount() - 1);
 283 }
 284
 285 // Check that if a combobox is disabled before it has a native wrapper, then the
 286 // native wrapper inherits the disabled state when it gets created.
 287 TEST_F(ComboboxTest, DisabilityTest) {
 288   model_.reset(new TestComboboxModel());
 289
 290   ASSERT_FALSE(combobox_);
 291   combobox_ = new TestCombobox(model_.get());
 292   combobox_->SetEnabled(false);
 293
 294   widget_ = new Widget;
 295   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
 296   params.bounds = gfx::Rect(100, 100, 100, 100);
 297   widget_->Init(params);
 298   View* container = new View();
 299   widget_->SetContentsView(container);
 300   container->AddChildView(combobox_);
 301   EXPECT_FALSE(combobox_->enabled());
 302 }
 303
 304 // Verifies that we don't select a separator line in combobox when navigating
 305 // through keyboard.
 306 TEST_F(ComboboxTest, SkipSeparatorSimple) {
 307   InitCombobox();
 308   std::set<int> separators;
 309   separators.insert(2);
 310   model_->SetSeparators(separators);
 311   EXPECT_EQ(0, combobox_->selected_index());
 312   SendKeyEvent(ui::VKEY_DOWN);
 313   EXPECT_EQ(1, combobox_->selected_index());
 314   SendKeyEvent(ui::VKEY_DOWN);
 315   EXPECT_EQ(3, combobox_->selected_index());
 316   SendKeyEvent(ui::VKEY_UP);
 317   EXPECT_EQ(1, combobox_->selected_index());
 318   SendKeyEvent(ui::VKEY_HOME);
 319   EXPECT_EQ(0, combobox_->selected_index());
 320   SendKeyEvent(ui::VKEY_PRIOR);
 321   EXPECT_EQ(0, combobox_->selected_index());
 322   SendKeyEvent(ui::VKEY_END);
 323   EXPECT_EQ(9, combobox_->selected_index());
 324 }
 325
 326 // Verifies that we never select the separator that is in the beginning of the
 327 // combobox list when navigating through keyboard.
 328 TEST_F(ComboboxTest, SkipSeparatorBeginning) {
 329   InitCombobox();
 330   std::set<int> separators;
 331   separators.insert(0);
 332   model_->SetSeparators(separators);
 333   EXPECT_EQ(0, combobox_->selected_index());
 334   SendKeyEvent(ui::VKEY_DOWN);
 335   EXPECT_EQ(1, combobox_->selected_index());
 336   SendKeyEvent(ui::VKEY_DOWN);
 337   EXPECT_EQ(2, combobox_->selected_index());
 338   SendKeyEvent(ui::VKEY_UP);
 339   EXPECT_EQ(1, combobox_->selected_index());
 340   SendKeyEvent(ui::VKEY_HOME);
 341   EXPECT_EQ(1, combobox_->selected_index());
 342   SendKeyEvent(ui::VKEY_PRIOR);
 343   EXPECT_EQ(1, combobox_->selected_index());
 344   SendKeyEvent(ui::VKEY_END);
 345   EXPECT_EQ(9, combobox_->selected_index());
 346 }
 347
 348 // Verifies that we never select the separator that is in the end of the
 349 // combobox list when navigating through keyboard.
 350 TEST_F(ComboboxTest, SkipSeparatorEnd) {
 351   InitCombobox();
 352   std::set<int> separators;
 353   separators.insert(model_->GetItemCount() - 1);
 354   model_->SetSeparators(separators);
 355   combobox_->SetSelectedIndex(8);
 356   SendKeyEvent(ui::VKEY_DOWN);
 357   EXPECT_EQ(8, combobox_->selected_index());
 358   SendKeyEvent(ui::VKEY_UP);
 359   EXPECT_EQ(7, combobox_->selected_index());
 360   SendKeyEvent(ui::VKEY_END);
 361   EXPECT_EQ(8, combobox_->selected_index());
 362 }
 363
 364 // Verifies that we never select any of the adjacent separators (multiple
 365 // consecutive) that appear in the beginning of the combobox list when
 366 // navigating through keyboard.
 367 TEST_F(ComboboxTest, SkipMultipleSeparatorsAtBeginning) {
 368   InitCombobox();
 369   std::set<int> separators;
 370   separators.insert(0);
 371   separators.insert(1);
 372   separators.insert(2);
 373   model_->SetSeparators(separators);
 374   EXPECT_EQ(0, combobox_->selected_index());
 375   SendKeyEvent(ui::VKEY_DOWN);
 376   EXPECT_EQ(3, combobox_->selected_index());
 377   SendKeyEvent(ui::VKEY_UP);
 378   EXPECT_EQ(3, combobox_->selected_index());
 379   SendKeyEvent(ui::VKEY_NEXT);
 380   EXPECT_EQ(9, combobox_->selected_index());
 381   SendKeyEvent(ui::VKEY_HOME);
 382   EXPECT_EQ(3, combobox_->selected_index());
 383   SendKeyEvent(ui::VKEY_END);
 384   EXPECT_EQ(9, combobox_->selected_index());
 385   SendKeyEvent(ui::VKEY_PRIOR);
 386   EXPECT_EQ(3, combobox_->selected_index());
 387 }
 388
 389 // Verifies that we never select any of the adjacent separators (multiple
 390 // consecutive) that appear in the middle of the combobox list when navigating
 391 // through keyboard.
 392 TEST_F(ComboboxTest, SkipMultipleAdjacentSeparatorsAtMiddle) {
 393   InitCombobox();
 394   std::set<int> separators;
 395   separators.insert(4);
 396   separators.insert(5);
 397   separators.insert(6);
 398   model_->SetSeparators(separators);
 399   combobox_->SetSelectedIndex(3);
 400   SendKeyEvent(ui::VKEY_DOWN);
 401   EXPECT_EQ(7, combobox_->selected_index());
 402   SendKeyEvent(ui::VKEY_UP);
 403   EXPECT_EQ(3, combobox_->selected_index());
 404 }
 405
 406 // Verifies that we never select any of the adjacent separators (multiple
 407 // consecutive) that appear in the end of the combobox list when navigating
 408 // through keyboard.
 409 TEST_F(ComboboxTest, SkipMultipleSeparatorsAtEnd) {
 410   InitCombobox();
 411   std::set<int> separators;
 412   separators.insert(7);
 413   separators.insert(8);
 414   separators.insert(9);
 415   model_->SetSeparators(separators);
 416   combobox_->SetSelectedIndex(6);
 417   SendKeyEvent(ui::VKEY_DOWN);
 418   EXPECT_EQ(6, combobox_->selected_index());
 419   SendKeyEvent(ui::VKEY_UP);
 420   EXPECT_EQ(5, combobox_->selected_index());
 421   SendKeyEvent(ui::VKEY_HOME);
 422   EXPECT_EQ(0, combobox_->selected_index());
 423   SendKeyEvent(ui::VKEY_NEXT);
 424   EXPECT_EQ(6, combobox_->selected_index());
 425   SendKeyEvent(ui::VKEY_PRIOR);
 426   EXPECT_EQ(0, combobox_->selected_index());
 427   SendKeyEvent(ui::VKEY_END);
 428   EXPECT_EQ(6, combobox_->selected_index());
 429 }
 430
 431 TEST_F(ComboboxTest, GetTextForRowTest) {
 432   InitCombobox();
 433   std::set<int> separators;
 434   separators.insert(0);
 435   separators.insert(1);
 436   separators.insert(9);
 437   model_->SetSeparators(separators);
 438   for (int i = 0; i < combobox_->GetRowCount(); ++i) {
 439     if (separators.count(i) != 0) {
 440       EXPECT_TRUE(combobox_->GetTextForRow(i).empty()) << i;
 441     } else {
 442       EXPECT_EQ(ASCIIToUTF16(i % 2 == 0 ? "PEANUT BUTTER" : "JELLY"),
 443                 combobox_->GetTextForRow(i)) << i;
 444     }
 445   }
 446 }
 447
 448 // Verifies selecting the first matching value (and returning whether found).
 449 TEST_F(ComboboxTest, SelectValue) {
 450   InitCombobox();
 451   ASSERT_EQ(model_->GetDefaultIndex(), combobox_->selected_index());
 452   EXPECT_TRUE(combobox_->SelectValue(ASCIIToUTF16("PEANUT BUTTER")));
 453   EXPECT_EQ(0, combobox_->selected_index());
 454   EXPECT_TRUE(combobox_->SelectValue(ASCIIToUTF16("JELLY")));
 455   EXPECT_EQ(1, combobox_->selected_index());
 456   EXPECT_FALSE(combobox_->SelectValue(ASCIIToUTF16("BANANAS")));
 457   EXPECT_EQ(1, combobox_->selected_index());
 458
 459   // With the action style, the selected index is always 0.
 460   combobox_->SetStyle(Combobox::STYLE_ACTION);
 461   EXPECT_FALSE(combobox_->SelectValue(ASCIIToUTF16("PEANUT BUTTER")));
 462   EXPECT_EQ(0, combobox_->selected_index());
 463   EXPECT_FALSE(combobox_->SelectValue(ASCIIToUTF16("JELLY")));
 464   EXPECT_EQ(0, combobox_->selected_index());
 465   EXPECT_FALSE(combobox_->SelectValue(ASCIIToUTF16("BANANAS")));
 466   EXPECT_EQ(0, combobox_->selected_index());
 467 }
 468
 469 TEST_F(ComboboxTest, SelectIndexActionStyle) {
 470   InitCombobox();
 471
 472   // With the action style, the selected index is always 0.
 473   combobox_->SetStyle(Combobox::STYLE_ACTION);
 474   combobox_->SetSelectedIndex(1);
 475   EXPECT_EQ(0, combobox_->selected_index());
 476   combobox_->SetSelectedIndex(2);
 477   EXPECT_EQ(0, combobox_->selected_index());
 478   combobox_->SetSelectedIndex(3);
 479   EXPECT_EQ(0, combobox_->selected_index());
 480 }
 481
 482 TEST_F(ComboboxTest, ListenerHandlesDelete) {
 483   TestComboboxModel model;
 484
 485   // |combobox| will be deleted on change.
 486   TestCombobox* combobox = new TestCombobox(&model);
 487   scoped_ptr<EvilListener> evil_listener(new EvilListener());
 488   combobox->set_listener(evil_listener.get());
 489   ASSERT_NO_FATAL_FAILURE(combobox->ExecuteCommand(2));
 490   EXPECT_TRUE(evil_listener->deleted());
 491
 492   // With STYLE_ACTION
 493   // |combobox| will be deleted on change.
 494   combobox = new TestCombobox(&model);
 495   evil_listener.reset(new EvilListener());
 496   combobox->set_listener(evil_listener.get());
 497   combobox->SetStyle(Combobox::STYLE_ACTION);
 498   ASSERT_NO_FATAL_FAILURE(combobox->ExecuteCommand(2));
 499   EXPECT_TRUE(evil_listener->deleted());
 500 }
 501
 502 TEST_F(ComboboxTest, Click) {
 503   InitCombobox();
 504
 505   TestComboboxListener listener;
 506   combobox_->set_listener(&listener);
 507
 508   combobox_->Layout();
 509
 510   // Click the left side. The menu is shown.
 511   TestMenuRunnerHandler* test_menu_runner_handler = new TestMenuRunnerHandler();
 512   scoped_ptr<MenuRunnerHandler> menu_runner_handler(test_menu_runner_handler);
 513   test::MenuRunnerTestAPI test_api(
 514       combobox_->dropdown_list_menu_runner_.get());
 515   test_api.SetMenuRunnerHandler(menu_runner_handler.Pass());
 516   PerformClick(gfx::Point(combobox_->x() + 1,
 517                           combobox_->y() + combobox_->height() / 2));
 518   EXPECT_FALSE(listener.on_perform_action_called());
 519   EXPECT_TRUE(test_menu_runner_handler->executed());
 520 }
 521
 522 TEST_F(ComboboxTest, ClickButDisabled) {
 523   InitCombobox();
 524
 525   TestComboboxListener listener;
 526   combobox_->set_listener(&listener);
 527
 528   combobox_->Layout();
 529   combobox_->SetEnabled(false);
 530
 531   // Click the left side, but nothing happens since the combobox is disabled.
 532   TestMenuRunnerHandler* test_menu_runner_handler = new TestMenuRunnerHandler();
 533   scoped_ptr<MenuRunnerHandler> menu_runner_handler(test_menu_runner_handler);
 534   test::MenuRunnerTestAPI test_api(
 535       combobox_->dropdown_list_menu_runner_.get());
 536   test_api.SetMenuRunnerHandler(menu_runner_handler.Pass());
 537   PerformClick(gfx::Point(combobox_->x() + 1,
 538                           combobox_->y() + combobox_->height() / 2));
 539   EXPECT_FALSE(listener.on_perform_action_called());
 540   EXPECT_FALSE(test_menu_runner_handler->executed());
 541 }
 542
 543 TEST_F(ComboboxTest, NotifyOnClickWithReturnKey) {
 544   InitCombobox();
 545
 546   TestComboboxListener listener;
 547   combobox_->set_listener(&listener);
 548
 549   // With STYLE_NORMAL, the click event is ignored.
 550   SendKeyEvent(ui::VKEY_RETURN);
 551   EXPECT_FALSE(listener.on_perform_action_called());
 552
 553   // With STYLE_ACTION, the click event is notified.
 554   combobox_->SetStyle(Combobox::STYLE_ACTION);
 555   SendKeyEvent(ui::VKEY_RETURN);
 556   EXPECT_TRUE(listener.on_perform_action_called());
 557   EXPECT_EQ(0, listener.perform_action_index());
 558 }
 559
 560 TEST_F(ComboboxTest, NotifyOnClickWithSpaceKey) {
 561   InitCombobox();
 562
 563   TestComboboxListener listener;
 564   combobox_->set_listener(&listener);
 565
 566   // With STYLE_NORMAL, the click event is ignored.
 567   SendKeyEvent(ui::VKEY_SPACE);
 568   EXPECT_FALSE(listener.on_perform_action_called());
 569   SendKeyEventWithType(ui::VKEY_SPACE, ui::ET_KEY_RELEASED);
 570   EXPECT_FALSE(listener.on_perform_action_called());
 571
 572   // With STYLE_ACTION, the click event is notified after releasing.
 573   combobox_->SetStyle(Combobox::STYLE_ACTION);
 574   SendKeyEvent(ui::VKEY_SPACE);
 575   EXPECT_FALSE(listener.on_perform_action_called());
 576   SendKeyEventWithType(ui::VKEY_SPACE, ui::ET_KEY_RELEASED);
 577   EXPECT_TRUE(listener.on_perform_action_called());
 578   EXPECT_EQ(0, listener.perform_action_index());
 579 }
 580
 581 TEST_F(ComboboxTest, NotifyOnClickWithMouse) {
 582   InitCombobox();
 583
 584   TestComboboxListener listener;
 585   combobox_->set_listener(&listener);
 586
 587   combobox_->SetStyle(Combobox::STYLE_ACTION);
 588   combobox_->Layout();
 589
 590   // Click the right side (arrow button). The menu is shown.
 591   TestMenuRunnerHandler* test_menu_runner_handler = new TestMenuRunnerHandler();
 592   scoped_ptr<MenuRunnerHandler> menu_runner_handler(test_menu_runner_handler);
 593   scoped_ptr<test::MenuRunnerTestAPI> test_api(
 594       new test::MenuRunnerTestAPI(combobox_->dropdown_list_menu_runner_.get()));
 595   test_api->SetMenuRunnerHandler(menu_runner_handler.Pass());
 596
 597   PerformClick(gfx::Point(combobox_->x() + combobox_->width() - 1,
 598                           combobox_->y() + combobox_->height() / 2));
 599   EXPECT_FALSE(listener.on_perform_action_called());
 600   EXPECT_TRUE(test_menu_runner_handler->executed());
 601
 602   // Click the left side (text button). The click event is notified.
 603   test_menu_runner_handler = new TestMenuRunnerHandler();
 604   menu_runner_handler.reset(test_menu_runner_handler);
 605   test_api.reset(
 606       new test::MenuRunnerTestAPI(combobox_->dropdown_list_menu_runner_.get()));
 607   test_api->SetMenuRunnerHandler(menu_runner_handler.Pass());
 608   PerformClick(gfx::Point(combobox_->x() + 1,
 609                           combobox_->y() + combobox_->height() / 2));
 610   EXPECT_TRUE(listener.on_perform_action_called());
 611   EXPECT_FALSE(test_menu_runner_handler->executed());
 612   EXPECT_EQ(0, listener.perform_action_index());
 613 }
 614
 615 TEST_F(ComboboxTest, ConsumingPressKeyEvents) {
 616   InitCombobox();
 617
 618   EXPECT_FALSE(combobox_->OnKeyPressed(
 619       ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_RETURN, 0, false)));
 620   EXPECT_FALSE(combobox_->OnKeyPressed(
 621       ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_SPACE, 0, false)));
 622
 623   // When the combobox's style is STYLE_ACTION, pressing events of a space key
 624   // or an enter key will be consumed.
 625   combobox_->SetStyle(Combobox::STYLE_ACTION);
 626   EXPECT_TRUE(combobox_->OnKeyPressed(
 627       ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_RETURN, 0, false)));
 628   EXPECT_TRUE(combobox_->OnKeyPressed(
 629       ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_SPACE, 0, false)));
 630 }
 631
 632 TEST_F(ComboboxTest, ContentWidth) {
 633   std::vector<std::string> values;
 634   VectorComboboxModel model(&values);
 635   TestCombobox combobox(&model);
 636
 637   std::string long_item = "this is the long item";
 638   std::string short_item = "s";
 639
 640   values.resize(1);
 641   values[0] = long_item;
 642   combobox.ModelChanged();
 643
 644   const int long_item_width = combobox.content_size_.width();
 645
 646   values[0] = short_item;
 647   combobox.ModelChanged();
 648
 649   const int short_item_width = combobox.content_size_.width();
 650
 651   values.resize(2);
 652   values[0] = short_item;
 653   values[1] = long_item;
 654   combobox.ModelChanged();
 655
 656   // When the style is STYLE_NORMAL, the width will fit with the longest item.
 657   combobox.SetStyle(Combobox::STYLE_NORMAL);
 658   EXPECT_EQ(long_item_width, combobox.content_size_.width());
 659
 660   // When the style is STYLE_ACTION, the width will fit with the first items'
 661   // width.
 662   combobox.SetStyle(Combobox::STYLE_ACTION);
 663   EXPECT_EQ(short_item_width, combobox.content_size_.width());
 664 }
 665
 666 TEST_F(ComboboxTest, TypingPrefixNotifiesListener) {
 667   InitCombobox();
 668
 669   TestComboboxListener listener;
 670   combobox_->set_listener(&listener);
 671
 672   // Type the first character of the second menu item ("JELLY").
 673   combobox_->GetTextInputClient()->InsertChar('J', ui::EF_NONE);
 674   EXPECT_EQ(1, listener.actions_performed());
 675   EXPECT_EQ(1, listener.perform_action_index());
 676
 677   // Type the second character of "JELLY", item shouldn't change and
 678   // OnPerformAction() shouldn't be re-called.
 679   combobox_->GetTextInputClient()->InsertChar('E', ui::EF_NONE);
 680   EXPECT_EQ(1, listener.actions_performed());
 681   EXPECT_EQ(1, listener.perform_action_index());
 682
 683   // Clears the typed text.
 684   combobox_->OnBlur();
 685
 686   // Type the first character of "PEANUT BUTTER", which should change the
 687   // selected index and perform an action.
 688   combobox_->GetTextInputClient()->InsertChar('P', ui::EF_NONE);
 689   EXPECT_EQ(2, listener.actions_performed());
 690   EXPECT_EQ(2, listener.perform_action_index());
 691 }
 692
 693 }  // namespace views