src/ui/events/event_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 #include "base/memory/scoped_ptr.h"
   6 #include "testing/gtest/include/gtest/gtest.h"
   7 #include "ui/events/event.h"
   8 #include "ui/events/event_utils.h"
   9 #include "ui/events/keycodes/dom4/keycode_converter.h"
  10 #include "ui/events/test/events_test_utils.h"
  11
  12 #if defined(USE_X11)
  13 #include <X11/Xlib.h>
  14 #include "ui/events/test/events_test_utils_x11.h"
  15 #include "ui/gfx/x/x11_types.h"
  16 #endif
  17
  18 namespace ui {
  19
  20 TEST(EventTest, NoNativeEvent) {
  21   KeyEvent keyev(ET_KEY_PRESSED, VKEY_SPACE, EF_NONE);
  22   EXPECT_FALSE(keyev.HasNativeEvent());
  23 }
  24
  25 TEST(EventTest, NativeEvent) {
  26 #if defined(OS_WIN)
  27   MSG native_event = { NULL, WM_KEYUP, VKEY_A, 0 };
  28   KeyEvent keyev(native_event);
  29   EXPECT_TRUE(keyev.HasNativeEvent());
  30 #elif defined(USE_X11)
  31   ScopedXI2Event event;
  32   event.InitKeyEvent(ET_KEY_RELEASED, VKEY_A, EF_NONE);
  33   KeyEvent keyev(event);
  34   EXPECT_TRUE(keyev.HasNativeEvent());
  35 #endif
  36 }
  37
  38 TEST(EventTest, GetCharacter) {
  39   // Check if Control+Enter returns 10.
  40   KeyEvent keyev1(ET_KEY_PRESSED, VKEY_RETURN, EF_CONTROL_DOWN);
  41   EXPECT_EQ(10, keyev1.GetCharacter());
  42   // Check if Enter returns 13.
  43   KeyEvent keyev2(ET_KEY_PRESSED, VKEY_RETURN, EF_NONE);
  44   EXPECT_EQ(13, keyev2.GetCharacter());
  45
  46 #if defined(USE_X11)
  47   // For X11, test the functions with native_event() as well. crbug.com/107837
  48   ScopedXI2Event event;
  49   event.InitKeyEvent(ET_KEY_PRESSED, VKEY_RETURN, EF_CONTROL_DOWN);
  50   KeyEvent keyev3(event);
  51   EXPECT_EQ(10, keyev3.GetCharacter());
  52
  53   event.InitKeyEvent(ET_KEY_PRESSED, VKEY_RETURN, EF_NONE);
  54   KeyEvent keyev4(event);
  55   EXPECT_EQ(13, keyev4.GetCharacter());
  56 #endif
  57 }
  58
  59 TEST(EventTest, ClickCount) {
  60   const gfx::Point origin(0, 0);
  61   MouseEvent mouseev(ET_MOUSE_PRESSED, origin, origin, 0, 0);
  62   for (int i = 1; i <=3 ; ++i) {
  63     mouseev.SetClickCount(i);
  64     EXPECT_EQ(i, mouseev.GetClickCount());
  65   }
  66 }
  67
  68 TEST(EventTest, RepeatedClick) {
  69   const gfx::Point origin(0, 0);
  70   MouseEvent mouse_ev1(ET_MOUSE_PRESSED, origin, origin, 0, 0);
  71   MouseEvent mouse_ev2(ET_MOUSE_PRESSED, origin, origin, 0, 0);
  72   LocatedEventTestApi test_ev1(&mouse_ev1);
  73   LocatedEventTestApi test_ev2(&mouse_ev2);
  74
  75   base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
  76   base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1);
  77   base::TimeDelta later = start + base::TimeDelta::FromMilliseconds(1000);
  78
  79   // Close point.
  80   test_ev1.set_location(gfx::Point(0, 0));
  81   test_ev2.set_location(gfx::Point(1, 0));
  82   test_ev1.set_time_stamp(start);
  83   test_ev2.set_time_stamp(soon);
  84   EXPECT_TRUE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2));
  85
  86   // Too far.
  87   test_ev1.set_location(gfx::Point(0, 0));
  88   test_ev2.set_location(gfx::Point(10, 0));
  89   test_ev1.set_time_stamp(start);
  90   test_ev2.set_time_stamp(soon);
  91   EXPECT_FALSE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2));
  92
  93   // Too long a time between clicks.
  94   test_ev1.set_location(gfx::Point(0, 0));
  95   test_ev2.set_location(gfx::Point(0, 0));
  96   test_ev1.set_time_stamp(start);
  97   test_ev2.set_time_stamp(later);
  98   EXPECT_FALSE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2));
  99 }
 100
 101 // Tests that an event only increases the click count and gets marked as a
 102 // double click if a release event was seen for the previous click. This
 103 // prevents the same PRESSED event from being processed twice:
 104 // http://crbug.com/389162
 105 TEST(EventTest, DoubleClickRequiresRelease) {
 106   const gfx::Point origin1(0, 0);
 107   const gfx::Point origin2(100, 0);
 108   scoped_ptr<MouseEvent> ev;
 109   base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
 110
 111   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin1, origin1, 0, 0));
 112   ev->set_time_stamp(start);
 113   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
 114   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin1, origin1, 0, 0));
 115   ev->set_time_stamp(start);
 116   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
 117
 118   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin2, origin2, 0, 0));
 119   ev->set_time_stamp(start);
 120   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
 121   ev.reset(new MouseEvent(ET_MOUSE_RELEASED, origin2, origin2, 0, 0));
 122   ev->set_time_stamp(start);
 123   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
 124   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin2, origin2, 0, 0));
 125   ev->set_time_stamp(start);
 126   EXPECT_EQ(2, MouseEvent::GetRepeatCount(*ev));
 127   ev.reset(new MouseEvent(ET_MOUSE_RELEASED, origin2, origin2, 0, 0));
 128   ev->set_time_stamp(start);
 129   EXPECT_EQ(2, MouseEvent::GetRepeatCount(*ev));
 130   MouseEvent::ResetLastClickForTest();
 131 }
 132
 133 // Tests that clicking right and then left clicking does not generate a double
 134 // click.
 135 TEST(EventTest, SingleClickRightLeft) {
 136   const gfx::Point origin(0, 0);
 137   scoped_ptr<MouseEvent> ev;
 138   base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
 139
 140   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin,
 141                           ui::EF_RIGHT_MOUSE_BUTTON,
 142                           ui::EF_RIGHT_MOUSE_BUTTON));
 143   ev->set_time_stamp(start);
 144   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
 145   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin,
 146                           ui::EF_LEFT_MOUSE_BUTTON,
 147                           ui::EF_LEFT_MOUSE_BUTTON));
 148   ev->set_time_stamp(start);
 149   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
 150   ev.reset(new MouseEvent(ET_MOUSE_RELEASED, origin, origin,
 151                           ui::EF_LEFT_MOUSE_BUTTON,
 152                           ui::EF_LEFT_MOUSE_BUTTON));
 153   ev->set_time_stamp(start);
 154   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
 155   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin,
 156                           ui::EF_LEFT_MOUSE_BUTTON,
 157                           ui::EF_LEFT_MOUSE_BUTTON));
 158   ev->set_time_stamp(start);
 159   EXPECT_EQ(2, MouseEvent::GetRepeatCount(*ev));
 160   MouseEvent::ResetLastClickForTest();
 161 }
 162
 163 TEST(EventTest, KeyEvent) {
 164   static const struct {
 165     KeyboardCode key_code;
 166     int flags;
 167     uint16 character;
 168   } kTestData[] = {
 169     { VKEY_A, 0, 'a' },
 170     { VKEY_A, EF_SHIFT_DOWN, 'A' },
 171     { VKEY_A, EF_CAPS_LOCK_DOWN, 'A' },
 172     { VKEY_A, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, 'a' },
 173     { VKEY_A, EF_CONTROL_DOWN, 0x01 },
 174     { VKEY_A, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x01' },
 175     { VKEY_Z, 0, 'z' },
 176     { VKEY_Z, EF_SHIFT_DOWN, 'Z' },
 177     { VKEY_Z, EF_CAPS_LOCK_DOWN, 'Z' },
 178     { VKEY_Z, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, 'z' },
 179     { VKEY_Z, EF_CONTROL_DOWN, '\x1A' },
 180     { VKEY_Z, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x1A' },
 181
 182     { VKEY_2, EF_CONTROL_DOWN, '\0' },
 183     { VKEY_2, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
 184     { VKEY_6, EF_CONTROL_DOWN, '\0' },
 185     { VKEY_6, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x1E' },
 186     { VKEY_OEM_MINUS, EF_CONTROL_DOWN, '\0' },
 187     { VKEY_OEM_MINUS, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x1F' },
 188     { VKEY_OEM_4, EF_CONTROL_DOWN, '\x1B' },
 189     { VKEY_OEM_4, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
 190     { VKEY_OEM_5, EF_CONTROL_DOWN, '\x1C' },
 191     { VKEY_OEM_5, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
 192     { VKEY_OEM_6, EF_CONTROL_DOWN, '\x1D' },
 193     { VKEY_OEM_6, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
 194     { VKEY_RETURN, EF_CONTROL_DOWN, '\x0A' },
 195
 196     { VKEY_0, 0, '0' },
 197     { VKEY_0, EF_SHIFT_DOWN, ')' },
 198     { VKEY_0, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, ')' },
 199     { VKEY_0, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
 200
 201     { VKEY_9, 0, '9' },
 202     { VKEY_9, EF_SHIFT_DOWN, '(' },
 203     { VKEY_9, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, '(' },
 204     { VKEY_9, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
 205
 206     { VKEY_NUMPAD0, EF_CONTROL_DOWN, '\0' },
 207     { VKEY_NUMPAD0, EF_SHIFT_DOWN, '0' },
 208
 209     { VKEY_NUMPAD9, EF_CONTROL_DOWN, '\0' },
 210     { VKEY_NUMPAD9, EF_SHIFT_DOWN, '9' },
 211
 212     { VKEY_TAB, EF_CONTROL_DOWN, '\0' },
 213     { VKEY_TAB, EF_SHIFT_DOWN, '\t' },
 214
 215     { VKEY_MULTIPLY, EF_CONTROL_DOWN, '\0' },
 216     { VKEY_MULTIPLY, EF_SHIFT_DOWN, '*' },
 217     { VKEY_ADD, EF_CONTROL_DOWN, '\0' },
 218     { VKEY_ADD, EF_SHIFT_DOWN, '+' },
 219     { VKEY_SUBTRACT, EF_CONTROL_DOWN, '\0' },
 220     { VKEY_SUBTRACT, EF_SHIFT_DOWN, '-' },
 221     { VKEY_DECIMAL, EF_CONTROL_DOWN, '\0' },
 222     { VKEY_DECIMAL, EF_SHIFT_DOWN, '.' },
 223     { VKEY_DIVIDE, EF_CONTROL_DOWN, '\0' },
 224     { VKEY_DIVIDE, EF_SHIFT_DOWN, '/' },
 225
 226     { VKEY_OEM_1, EF_CONTROL_DOWN, '\0' },
 227     { VKEY_OEM_1, EF_SHIFT_DOWN, ':' },
 228     { VKEY_OEM_PLUS, EF_CONTROL_DOWN, '\0' },
 229     { VKEY_OEM_PLUS, EF_SHIFT_DOWN, '+' },
 230     { VKEY_OEM_COMMA, EF_CONTROL_DOWN, '\0' },
 231     { VKEY_OEM_COMMA, EF_SHIFT_DOWN, '<' },
 232     { VKEY_OEM_PERIOD, EF_CONTROL_DOWN, '\0' },
 233     { VKEY_OEM_PERIOD, EF_SHIFT_DOWN, '>' },
 234     { VKEY_OEM_3, EF_CONTROL_DOWN, '\0' },
 235     { VKEY_OEM_3, EF_SHIFT_DOWN, '~' },
 236   };
 237
 238   for (size_t i = 0; i < arraysize(kTestData); ++i) {
 239     KeyEvent key(ET_KEY_PRESSED,
 240                  kTestData[i].key_code,
 241                  kTestData[i].flags);
 242     EXPECT_EQ(kTestData[i].character, key.GetCharacter())
 243         << " Index:" << i << " key_code:" << kTestData[i].key_code;
 244   }
 245 }
 246
 247 TEST(EventTest, KeyEventDirectUnicode) {
 248   KeyEvent key(0x1234U, ui::VKEY_UNKNOWN, ui::EF_NONE);
 249   EXPECT_EQ(0x1234U, key.GetCharacter());
 250   EXPECT_EQ(ET_KEY_PRESSED, key.type());
 251   EXPECT_TRUE(key.is_char());
 252 }
 253
 254 TEST(EventTest, NormalizeKeyEventFlags) {
 255 #if defined(USE_X11)
 256   // Normalize flags when KeyEvent is created from XEvent.
 257   ScopedXI2Event event;
 258   {
 259     event.InitKeyEvent(ET_KEY_PRESSED, VKEY_SHIFT, EF_SHIFT_DOWN);
 260     KeyEvent keyev(event);
 261     EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags());
 262   }
 263   {
 264     event.InitKeyEvent(ET_KEY_RELEASED, VKEY_SHIFT, EF_SHIFT_DOWN);
 265     KeyEvent keyev(event);
 266     EXPECT_EQ(EF_NONE, keyev.flags());
 267   }
 268   {
 269     event.InitKeyEvent(ET_KEY_PRESSED, VKEY_CONTROL, EF_CONTROL_DOWN);
 270     KeyEvent keyev(event);
 271     EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags());
 272   }
 273   {
 274     event.InitKeyEvent(ET_KEY_RELEASED, VKEY_CONTROL, EF_CONTROL_DOWN);
 275     KeyEvent keyev(event);
 276     EXPECT_EQ(EF_NONE, keyev.flags());
 277   }
 278   {
 279     event.InitKeyEvent(ET_KEY_PRESSED, VKEY_MENU,  EF_ALT_DOWN);
 280     KeyEvent keyev(event);
 281     EXPECT_EQ(EF_ALT_DOWN, keyev.flags());
 282   }
 283   {
 284     event.InitKeyEvent(ET_KEY_RELEASED, VKEY_MENU, EF_ALT_DOWN);
 285     KeyEvent keyev(event);
 286     EXPECT_EQ(EF_NONE, keyev.flags());
 287   }
 288 #endif
 289
 290   // Do not normalize flags for synthesized events without
 291   // KeyEvent::NormalizeFlags called explicitly.
 292   {
 293     KeyEvent keyev(ET_KEY_PRESSED, VKEY_SHIFT, EF_SHIFT_DOWN);
 294     EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags());
 295   }
 296   {
 297     KeyEvent keyev(ET_KEY_RELEASED, VKEY_SHIFT, EF_SHIFT_DOWN);
 298     EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags());
 299     keyev.NormalizeFlags();
 300     EXPECT_EQ(EF_NONE, keyev.flags());
 301   }
 302   {
 303     KeyEvent keyev(ET_KEY_PRESSED, VKEY_CONTROL, EF_CONTROL_DOWN);
 304     EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags());
 305   }
 306   {
 307     KeyEvent keyev(ET_KEY_RELEASED, VKEY_CONTROL, EF_CONTROL_DOWN);
 308     EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags());
 309     keyev.NormalizeFlags();
 310     EXPECT_EQ(EF_NONE, keyev.flags());
 311   }
 312   {
 313     KeyEvent keyev(ET_KEY_PRESSED, VKEY_MENU,  EF_ALT_DOWN);
 314     EXPECT_EQ(EF_ALT_DOWN, keyev.flags());
 315   }
 316   {
 317     KeyEvent keyev(ET_KEY_RELEASED, VKEY_MENU, EF_ALT_DOWN);
 318     EXPECT_EQ(EF_ALT_DOWN, keyev.flags());
 319     keyev.NormalizeFlags();
 320     EXPECT_EQ(EF_NONE, keyev.flags());
 321   }
 322 }
 323
 324 TEST(EventTest, KeyEventCopy) {
 325   KeyEvent key(ET_KEY_PRESSED, VKEY_A, EF_NONE);
 326   scoped_ptr<KeyEvent> copied_key(new KeyEvent(key));
 327   EXPECT_EQ(copied_key->type(), key.type());
 328   EXPECT_EQ(copied_key->key_code(), key.key_code());
 329 }
 330
 331 TEST(EventTest, KeyEventCode) {
 332   const char kCodeForSpace[] = "Space";
 333   const uint16 kNativeCodeSpace =
 334       ui::KeycodeConverter::CodeToNativeKeycode(kCodeForSpace);
 335   ASSERT_NE(ui::KeycodeConverter::InvalidNativeKeycode(), kNativeCodeSpace);
 336
 337   {
 338     KeyEvent key(ET_KEY_PRESSED, VKEY_SPACE, kCodeForSpace, EF_NONE);
 339     EXPECT_EQ(kCodeForSpace, key.code());
 340   }
 341   {
 342     // Regardless the KeyEvent.key_code (VKEY_RETURN), code should be
 343     // the specified value.
 344     KeyEvent key(ET_KEY_PRESSED, VKEY_RETURN, kCodeForSpace, EF_NONE);
 345     EXPECT_EQ(kCodeForSpace, key.code());
 346   }
 347   {
 348     // If the synthetic event is initialized without code, it returns
 349     // an empty string.
 350     // TODO(komatsu): Fill a fallback value assuming the US keyboard layout.
 351     KeyEvent key(ET_KEY_PRESSED, VKEY_SPACE, EF_NONE);
 352     EXPECT_TRUE(key.code().empty());
 353   }
 354 #if defined(USE_X11)
 355   {
 356     // KeyEvent converts from the native keycode (XKB) to the code.
 357     ScopedXI2Event xevent;
 358     xevent.InitKeyEvent(ET_KEY_PRESSED, VKEY_SPACE, kNativeCodeSpace);
 359     KeyEvent key(xevent);
 360     EXPECT_EQ(kCodeForSpace, key.code());
 361   }
 362 #endif  // USE_X11
 363 #if defined(OS_WIN)
 364   {
 365     // Test a non extended key.
 366     ASSERT_EQ((kNativeCodeSpace & 0xFF), kNativeCodeSpace);
 367
 368     const LPARAM lParam = GetLParamFromScanCode(kNativeCodeSpace);
 369     MSG native_event = { NULL, WM_KEYUP, VKEY_SPACE, lParam };
 370     KeyEvent key(native_event);
 371
 372     // KeyEvent converts from the native keycode (scan code) to the code.
 373     EXPECT_EQ(kCodeForSpace, key.code());
 374   }
 375   {
 376     const char kCodeForHome[]  = "Home";
 377     const uint16 kNativeCodeHome  = 0xe047;
 378
 379     // 'Home' is an extended key with 0xe000 bits.
 380     ASSERT_NE((kNativeCodeHome & 0xFF), kNativeCodeHome);
 381     const LPARAM lParam = GetLParamFromScanCode(kNativeCodeHome);
 382
 383     MSG native_event = { NULL, WM_KEYUP, VKEY_HOME, lParam };
 384     KeyEvent key(native_event);
 385
 386     // KeyEvent converts from the native keycode (scan code) to the code.
 387     EXPECT_EQ(kCodeForHome, key.code());
 388   }
 389 #endif  // OS_WIN
 390 }
 391
 392 namespace {
 393 #if defined(USE_X11)
 394 void SetKeyEventTimestamp(XEvent* event, long time) {
 395   event->xkey.time = time;
 396 }
 397
 398 #elif defined(OS_WIN)
 399 void SetKeyEventTimestamp(MSG& msg, long time) {
 400   msg.time = time;
 401 }
 402 #endif
 403 }  // namespace
 404
 405 #if defined(USE_X11) || defined(OS_WIN)
 406 TEST(EventTest, AutoRepeat) {
 407   const uint16 kNativeCodeA = ui::KeycodeConverter::CodeToNativeKeycode("KeyA");
 408   const uint16 kNativeCodeB = ui::KeycodeConverter::CodeToNativeKeycode("KeyB");
 409 #if defined(USE_X11)
 410   ScopedXI2Event native_event_a_pressed;
 411   native_event_a_pressed.InitKeyEvent(ET_KEY_PRESSED, VKEY_A, kNativeCodeA);
 412   ScopedXI2Event native_event_a_pressed_1500;
 413   native_event_a_pressed_1500.InitKeyEvent(
 414       ET_KEY_PRESSED, VKEY_A, kNativeCodeA);
 415   ScopedXI2Event native_event_a_pressed_3000;
 416   native_event_a_pressed_3000.InitKeyEvent(
 417       ET_KEY_PRESSED, VKEY_A, kNativeCodeA);
 418
 419   ScopedXI2Event native_event_a_released;
 420   native_event_a_released.InitKeyEvent(ET_KEY_RELEASED, VKEY_A, kNativeCodeA);
 421   ScopedXI2Event native_event_b_pressed;
 422   native_event_b_pressed.InitKeyEvent(ET_KEY_PRESSED, VKEY_B, kNativeCodeB);
 423   ScopedXI2Event native_event_a_pressed_nonstandard_state;
 424   native_event_a_pressed_nonstandard_state.InitKeyEvent(
 425       ET_KEY_PRESSED, VKEY_A, kNativeCodeA);
 426   // IBUS-GTK uses the mask (1 << 25) to detect reposted event.
 427   static_cast<XEvent*>(native_event_a_pressed_nonstandard_state)->xkey.state |=
 428       1 << 25;
 429 #elif defined(OS_WIN)
 430   const LPARAM lParam_a = GetLParamFromScanCode(kNativeCodeA);
 431   const LPARAM lParam_b = GetLParamFromScanCode(kNativeCodeB);
 432   MSG native_event_a_pressed = { NULL, WM_KEYDOWN, VKEY_A, lParam_a };
 433   MSG native_event_a_pressed_1500 = { NULL, WM_KEYDOWN, VKEY_A, lParam_a };
 434   MSG native_event_a_pressed_3000 = { NULL, WM_KEYDOWN, VKEY_A, lParam_a };
 435   MSG native_event_a_released = { NULL, WM_KEYUP, VKEY_A, lParam_a };
 436   MSG native_event_b_pressed = { NULL, WM_KEYUP, VKEY_B, lParam_b };
 437 #endif
 438   SetKeyEventTimestamp(native_event_a_pressed_1500, 1500);
 439   SetKeyEventTimestamp(native_event_a_pressed_3000, 3000);
 440
 441   {
 442     KeyEvent key_a1(native_event_a_pressed);
 443     EXPECT_FALSE(key_a1.IsRepeat());
 444     KeyEvent key_a1_released(native_event_a_released);
 445     EXPECT_FALSE(key_a1_released.IsRepeat());
 446
 447     KeyEvent key_a2(native_event_a_pressed);
 448     EXPECT_FALSE(key_a2.IsRepeat());
 449     KeyEvent key_a2_repeated(native_event_a_pressed);
 450     EXPECT_TRUE(key_a2_repeated.IsRepeat());
 451     KeyEvent key_a2_released(native_event_a_released);
 452     EXPECT_FALSE(key_a2_released.IsRepeat());
 453   }
 454
 455   {
 456     KeyEvent key_a3(native_event_a_pressed);
 457     EXPECT_FALSE(key_a3.IsRepeat());
 458     KeyEvent key_b(native_event_b_pressed);
 459     EXPECT_FALSE(key_b.IsRepeat());
 460     KeyEvent key_a3_again(native_event_a_pressed);
 461     EXPECT_FALSE(key_a3_again.IsRepeat());
 462     KeyEvent key_a3_repeated(native_event_a_pressed);
 463     EXPECT_TRUE(key_a3_repeated.IsRepeat());
 464     KeyEvent key_a3_repeated2(native_event_a_pressed);
 465     EXPECT_TRUE(key_a3_repeated2.IsRepeat());
 466     KeyEvent key_a3_released(native_event_a_released);
 467     EXPECT_FALSE(key_a3_released.IsRepeat());
 468   }
 469
 470   // Hold the key longer than max auto repeat timeout.
 471   {
 472     KeyEvent key_a4_0(native_event_a_pressed);
 473     EXPECT_FALSE(key_a4_0.IsRepeat());
 474     KeyEvent key_a4_1500(native_event_a_pressed_1500);
 475     EXPECT_TRUE(key_a4_1500.IsRepeat());
 476     KeyEvent key_a4_3000(native_event_a_pressed_3000);
 477     EXPECT_TRUE(key_a4_3000.IsRepeat());
 478     KeyEvent key_a4_released(native_event_a_released);
 479     EXPECT_FALSE(key_a4_released.IsRepeat());
 480   }
 481
 482 #if defined(USE_X11)
 483   {
 484     KeyEvent key_a4_pressed(native_event_a_pressed);
 485     EXPECT_FALSE(key_a4_pressed.IsRepeat());
 486
 487     KeyEvent key_a4_pressed_nonstandard_state(
 488         native_event_a_pressed_nonstandard_state);
 489     EXPECT_FALSE(key_a4_pressed_nonstandard_state.IsRepeat());
 490   }
 491 #endif
 492 }
 493 #endif  // USE_X11 || OS_WIN
 494
 495 }  // namespace ui