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_UNSAFE(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   KeycodeConverter* conv = KeycodeConverter::GetInstance();
 333
 334   const char kCodeForSpace[] = "Space";
 335   const uint16 kNativeCodeSpace = conv->CodeToNativeKeycode(kCodeForSpace);
 336   ASSERT_NE(conv->InvalidNativeKeycode(), kNativeCodeSpace);
 337
 338   {
 339     KeyEvent key(ET_KEY_PRESSED, VKEY_SPACE, kCodeForSpace, EF_NONE);
 340     EXPECT_EQ(kCodeForSpace, key.code());
 341   }
 342   {
 343     // Regardless the KeyEvent.key_code (VKEY_RETURN), code should be
 344     // the specified value.
 345     KeyEvent key(ET_KEY_PRESSED, VKEY_RETURN, kCodeForSpace, EF_NONE);
 346     EXPECT_EQ(kCodeForSpace, key.code());
 347   }
 348   {
 349     // If the synthetic event is initialized without code, it returns
 350     // an empty string.
 351     // TODO(komatsu): Fill a fallback value assuming the US keyboard layout.
 352     KeyEvent key(ET_KEY_PRESSED, VKEY_SPACE, EF_NONE);
 353     EXPECT_TRUE(key.code().empty());
 354   }
 355 #if defined(USE_X11)
 356   {
 357     // KeyEvent converts from the native keycode (XKB) to the code.
 358     ScopedXI2Event xevent;
 359     xevent.InitKeyEvent(ET_KEY_PRESSED, VKEY_SPACE, kNativeCodeSpace);
 360     KeyEvent key(xevent);
 361     EXPECT_EQ(kCodeForSpace, key.code());
 362   }
 363 #endif  // USE_X11
 364 #if defined(OS_WIN)
 365   {
 366     // Test a non extended key.
 367     ASSERT_EQ((kNativeCodeSpace & 0xFF), kNativeCodeSpace);
 368
 369     const LPARAM lParam = GetLParamFromScanCode(kNativeCodeSpace);
 370     MSG native_event = { NULL, WM_KEYUP, VKEY_SPACE, lParam };
 371     KeyEvent key(native_event);
 372
 373     // KeyEvent converts from the native keycode (scan code) to the code.
 374     EXPECT_EQ(kCodeForSpace, key.code());
 375   }
 376   {
 377     const char kCodeForHome[]  = "Home";
 378     const uint16 kNativeCodeHome  = 0xe047;
 379
 380     // 'Home' is an extended key with 0xe000 bits.
 381     ASSERT_NE((kNativeCodeHome & 0xFF), kNativeCodeHome);
 382     const LPARAM lParam = GetLParamFromScanCode(kNativeCodeHome);
 383
 384     MSG native_event = { NULL, WM_KEYUP, VKEY_HOME, lParam };
 385     KeyEvent key(native_event);
 386
 387     // KeyEvent converts from the native keycode (scan code) to the code.
 388     EXPECT_EQ(kCodeForHome, key.code());
 389   }
 390 #endif  // OS_WIN
 391 }
 392
 393 #if defined(USE_X11) || defined(OS_WIN)
 394 TEST(EventTest, AutoRepeat) {
 395   KeycodeConverter* conv = KeycodeConverter::GetInstance();
 396
 397   const uint16 kNativeCodeA = conv->CodeToNativeKeycode("KeyA");
 398   const uint16 kNativeCodeB = conv->CodeToNativeKeycode("KeyB");
 399 #if defined(USE_X11)
 400   ScopedXI2Event native_event_a_pressed;
 401   native_event_a_pressed.InitKeyEvent(ET_KEY_PRESSED, VKEY_A, kNativeCodeA);
 402   ScopedXI2Event native_event_a_released;
 403   native_event_a_released.InitKeyEvent(ET_KEY_RELEASED, VKEY_A, kNativeCodeA);
 404   ScopedXI2Event native_event_b_pressed;
 405   native_event_b_pressed.InitKeyEvent(ET_KEY_PRESSED, VKEY_B, kNativeCodeB);
 406   ScopedXI2Event native_event_a_pressed_nonstandard_state;
 407   native_event_a_pressed_nonstandard_state.InitKeyEvent(
 408       ET_KEY_PRESSED, VKEY_A, kNativeCodeA);
 409   // IBUS-GTK uses the mask (1 << 25) to detect reposted event.
 410   static_cast<XEvent*>(native_event_a_pressed_nonstandard_state)->xkey.state |=
 411       1 << 25;
 412 #elif defined(OS_WIN)
 413   const LPARAM lParam_a = GetLParamFromScanCode(kNativeCodeA);
 414   const LPARAM lParam_b = GetLParamFromScanCode(kNativeCodeB);
 415   MSG native_event_a_pressed = { NULL, WM_KEYDOWN, VKEY_A, lParam_a };
 416   MSG native_event_a_released = { NULL, WM_KEYUP, VKEY_A, lParam_a };
 417   MSG native_event_b_pressed = { NULL, WM_KEYUP, VKEY_B, lParam_b };
 418 #endif
 419   KeyEvent key_a1(native_event_a_pressed);
 420   EXPECT_FALSE(key_a1.IsRepeat());
 421   KeyEvent key_a1_released(native_event_a_released);
 422   EXPECT_FALSE(key_a1_released.IsRepeat());
 423
 424   KeyEvent key_a2(native_event_a_pressed);
 425   EXPECT_FALSE(key_a2.IsRepeat());
 426   KeyEvent key_a2_repeated(native_event_a_pressed);
 427   EXPECT_TRUE(key_a2_repeated.IsRepeat());
 428   KeyEvent key_a2_released(native_event_a_released);
 429   EXPECT_FALSE(key_a2_released.IsRepeat());
 430
 431   KeyEvent key_a3(native_event_a_pressed);
 432   EXPECT_FALSE(key_a3.IsRepeat());
 433   KeyEvent key_b(native_event_b_pressed);
 434   EXPECT_FALSE(key_b.IsRepeat());
 435   KeyEvent key_a3_again(native_event_a_pressed);
 436   EXPECT_FALSE(key_a3_again.IsRepeat());
 437   KeyEvent key_a3_repeated(native_event_a_pressed);
 438   EXPECT_TRUE(key_a3_repeated.IsRepeat());
 439   KeyEvent key_a3_repeated2(native_event_a_pressed);
 440   EXPECT_TRUE(key_a3_repeated2.IsRepeat());
 441   KeyEvent key_a3_released(native_event_a_released);
 442   EXPECT_FALSE(key_a3_released.IsRepeat());
 443
 444 #if defined(USE_X11)
 445   KeyEvent key_a4_pressed(native_event_a_pressed);
 446   EXPECT_FALSE(key_a4_pressed.IsRepeat());
 447
 448   KeyEvent key_a4_pressed_nonstandard_state(
 449       native_event_a_pressed_nonstandard_state);
 450   EXPECT_FALSE(key_a4_pressed_nonstandard_state.IsRepeat());
 451 #endif
 452 }
 453 #endif  // USE_X11 || OS_WIN
 454
 455 }  // namespace ui