text: // Copyright (c) 2012 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 "base/memory/scoped_ptr.h"
  #include "testing/gtest/include/gtest/gtest.h"
  #include "ui/events/event.h"
  #include "ui/events/event_utils.h"
  #include "ui/events/keycodes/dom4/keycode_converter.h"
  #include "ui/events/test/events_test_utils.h"
  
  #if defined(USE_X11)
  #include <X11/Xlib.h>
  #include "ui/events/test/events_test_utils_x11.h"
  #include "ui/gfx/x/x11_types.h"
  #endif
  
  namespace ui {
  
  TEST(EventTest, NoNativeEvent) {
    KeyEvent keyev(ET_KEY_PRESSED, VKEY_SPACE, EF_NONE);
    EXPECT_FALSE(keyev.HasNativeEvent());
  }
  
  TEST(EventTest, NativeEvent) {
  #if defined(OS_WIN)
    MSG native_event = { NULL, WM_KEYUP, VKEY_A, 0 };
    KeyEvent keyev(native_event);
    EXPECT_TRUE(keyev.HasNativeEvent());
  #elif defined(USE_X11)
    ScopedXI2Event event;
    event.InitKeyEvent(ET_KEY_RELEASED, VKEY_A, EF_NONE);
    KeyEvent keyev(event);
    EXPECT_TRUE(keyev.HasNativeEvent());
  #endif
  }
  
  TEST(EventTest, GetCharacter) {
    // Check if Control+Enter returns 10.
    KeyEvent keyev1(ET_KEY_PRESSED, VKEY_RETURN, EF_CONTROL_DOWN);
    EXPECT_EQ(10, keyev1.GetCharacter());
    // Check if Enter returns 13.
    KeyEvent keyev2(ET_KEY_PRESSED, VKEY_RETURN, EF_NONE);
    EXPECT_EQ(13, keyev2.GetCharacter());
  
  #if defined(USE_X11)
    // For X11, test the functions with native_event() as well. crbug.com/107837
    ScopedXI2Event event;
    event.InitKeyEvent(ET_KEY_PRESSED, VKEY_RETURN, EF_CONTROL_DOWN);
    KeyEvent keyev3(event);
    EXPECT_EQ(10, keyev3.GetCharacter());
  
    event.InitKeyEvent(ET_KEY_PRESSED, VKEY_RETURN, EF_NONE);
    KeyEvent keyev4(event);
    EXPECT_EQ(13, keyev4.GetCharacter());
  #endif
  }
  
  TEST(EventTest, ClickCount) {
    const gfx::Point origin(0, 0);
    MouseEvent mouseev(ET_MOUSE_PRESSED, origin, origin, 0, 0);
    for (int i = 1; i <=3 ; ++i) {
      mouseev.SetClickCount(i);
      EXPECT_EQ(i, mouseev.GetClickCount());
    }
  }
  
  TEST(EventTest, RepeatedClick) {
    const gfx::Point origin(0, 0);
    MouseEvent mouse_ev1(ET_MOUSE_PRESSED, origin, origin, 0, 0);
    MouseEvent mouse_ev2(ET_MOUSE_PRESSED, origin, origin, 0, 0);
    LocatedEventTestApi test_ev1(&mouse_ev1);
    LocatedEventTestApi test_ev2(&mouse_ev2);
  
    base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
    base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1);
    base::TimeDelta later = start + base::TimeDelta::FromMilliseconds(1000);
  
    // Close point.
    test_ev1.set_location(gfx::Point(0, 0));
    test_ev2.set_location(gfx::Point(1, 0));
    test_ev1.set_time_stamp(start);
    test_ev2.set_time_stamp(soon);
    EXPECT_TRUE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2));
  
    // Too far.
    test_ev1.set_location(gfx::Point(0, 0));
    test_ev2.set_location(gfx::Point(10, 0));
    test_ev1.set_time_stamp(start);
    test_ev2.set_time_stamp(soon);
    EXPECT_FALSE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2));
  
    // Too long a time between clicks.
    test_ev1.set_location(gfx::Point(0, 0));
    test_ev2.set_location(gfx::Point(0, 0));
    test_ev1.set_time_stamp(start);
    test_ev2.set_time_stamp(later);
    EXPECT_FALSE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2));
  }
  
  // Tests that an event only increases the click count and gets marked as a
  // double click if a release event was seen for the previous click. This
  // prevents the same PRESSED event from being processed twice:
  // http://crbug.com/389162
  TEST(EventTest, DoubleClickRequiresRelease) {
    const gfx::Point origin1(0, 0);
    const gfx::Point origin2(100, 0);
    scoped_ptr<MouseEvent> ev;
    base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
  
    ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin1, origin1, 0, 0));
    ev->set_time_stamp(start);
    EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
    ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin1, origin1, 0, 0));
    ev->set_time_stamp(start);
    EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
  
    ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin2, origin2, 0, 0));
    ev->set_time_stamp(start);
    EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
    ev.reset(new MouseEvent(ET_MOUSE_RELEASED, origin2, origin2, 0, 0));
    ev->set_time_stamp(start);
    EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
    ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin2, origin2, 0, 0));
    ev->set_time_stamp(start);
    EXPECT_EQ(2, MouseEvent::GetRepeatCount(*ev));
    ev.reset(new MouseEvent(ET_MOUSE_RELEASED, origin2, origin2, 0, 0));
    ev->set_time_stamp(start);
    EXPECT_EQ(2, MouseEvent::GetRepeatCount(*ev));
    MouseEvent::ResetLastClickForTest();
  }
  
  // Tests that clicking right and then left clicking does not generate a double
  // click.
  TEST(EventTest, SingleClickRightLeft) {
    const gfx::Point origin(0, 0);
    scoped_ptr<MouseEvent> ev;
    base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
  
    ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin,
                            ui::EF_RIGHT_MOUSE_BUTTON,
                            ui::EF_RIGHT_MOUSE_BUTTON));
    ev->set_time_stamp(start);
    EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
    ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin,
                            ui::EF_LEFT_MOUSE_BUTTON,
                            ui::EF_LEFT_MOUSE_BUTTON));
    ev->set_time_stamp(start);
    EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
    ev.reset(new MouseEvent(ET_MOUSE_RELEASED, origin, origin,
                            ui::EF_LEFT_MOUSE_BUTTON,
                            ui::EF_LEFT_MOUSE_BUTTON));
    ev->set_time_stamp(start);
    EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
    ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin,
                            ui::EF_LEFT_MOUSE_BUTTON,
                            ui::EF_LEFT_MOUSE_BUTTON));
    ev->set_time_stamp(start);
    EXPECT_EQ(2, MouseEvent::GetRepeatCount(*ev));
    MouseEvent::ResetLastClickForTest();
  }
  
  TEST(EventTest, KeyEvent) {
    static const struct {
      KeyboardCode key_code;
      int flags;
      uint16 character;
    } kTestData[] = {
      { VKEY_A, 0, 'a' },
      { VKEY_A, EF_SHIFT_DOWN, 'A' },
      { VKEY_A, EF_CAPS_LOCK_DOWN, 'A' },
      { VKEY_A, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, 'a' },
      { VKEY_A, EF_CONTROL_DOWN, 0x01 },
      { VKEY_A, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x01' },
      { VKEY_Z, 0, 'z' },
      { VKEY_Z, EF_SHIFT_DOWN, 'Z' },
      { VKEY_Z, EF_CAPS_LOCK_DOWN, 'Z' },
      { VKEY_Z, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, 'z' },
      { VKEY_Z, EF_CONTROL_DOWN, '\x1A' },
      { VKEY_Z, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x1A' },
  
      { VKEY_2, EF_CONTROL_DOWN, '\0' },
      { VKEY_2, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
      { VKEY_6, EF_CONTROL_DOWN, '\0' },
      { VKEY_6, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x1E' },
      { VKEY_OEM_MINUS, EF_CONTROL_DOWN, '\0' },
      { VKEY_OEM_MINUS, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x1F' },
      { VKEY_OEM_4, EF_CONTROL_DOWN, '\x1B' },
      { VKEY_OEM_4, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
      { VKEY_OEM_5, EF_CONTROL_DOWN, '\x1C' },
      { VKEY_OEM_5, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
      { VKEY_OEM_6, EF_CONTROL_DOWN, '\x1D' },
      { VKEY_OEM_6, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
      { VKEY_RETURN, EF_CONTROL_DOWN, '\x0A' },
  
      { VKEY_0, 0, '0' },
      { VKEY_0, EF_SHIFT_DOWN, ')' },
      { VKEY_0, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, ')' },
      { VKEY_0, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
  
      { VKEY_9, 0, '9' },
      { VKEY_9, EF_SHIFT_DOWN, '(' },
      { VKEY_9, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, '(' },
      { VKEY_9, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
  
      { VKEY_NUMPAD0, EF_CONTROL_DOWN, '\0' },
      { VKEY_NUMPAD0, EF_SHIFT_DOWN, '0' },
  
      { VKEY_NUMPAD9, EF_CONTROL_DOWN, '\0' },
      { VKEY_NUMPAD9, EF_SHIFT_DOWN, '9' },
  
      { VKEY_TAB, EF_CONTROL_DOWN, '\0' },
      { VKEY_TAB, EF_SHIFT_DOWN, '\t' },
  
      { VKEY_MULTIPLY, EF_CONTROL_DOWN, '\0' },
      { VKEY_MULTIPLY, EF_SHIFT_DOWN, '*' },
      { VKEY_ADD, EF_CONTROL_DOWN, '\0' },
      { VKEY_ADD, EF_SHIFT_DOWN, '+' },
      { VKEY_SUBTRACT, EF_CONTROL_DOWN, '\0' },
      { VKEY_SUBTRACT, EF_SHIFT_DOWN, '-' },
      { VKEY_DECIMAL, EF_CONTROL_DOWN, '\0' },
      { VKEY_DECIMAL, EF_SHIFT_DOWN, '.' },
      { VKEY_DIVIDE, EF_CONTROL_DOWN, '\0' },
      { VKEY_DIVIDE, EF_SHIFT_DOWN, '/' },
  
      { VKEY_OEM_1, EF_CONTROL_DOWN, '\0' },
      { VKEY_OEM_1, EF_SHIFT_DOWN, ':' },
      { VKEY_OEM_PLUS, EF_CONTROL_DOWN, '\0' },
      { VKEY_OEM_PLUS, EF_SHIFT_DOWN, '+' },
      { VKEY_OEM_COMMA, EF_CONTROL_DOWN, '\0' },
      { VKEY_OEM_COMMA, EF_SHIFT_DOWN, '<' },
      { VKEY_OEM_PERIOD, EF_CONTROL_DOWN, '\0' },
      { VKEY_OEM_PERIOD, EF_SHIFT_DOWN, '>' },
      { VKEY_OEM_3, EF_CONTROL_DOWN, '\0' },
      { VKEY_OEM_3, EF_SHIFT_DOWN, '~' },
    };
  
    for (size_t i = 0; i < arraysize(kTestData); ++i) {
      KeyEvent key(ET_KEY_PRESSED,
                   kTestData[i].key_code,
                   kTestData[i].flags);
      EXPECT_EQ(kTestData[i].character, key.GetCharacter())
          << " Index:" << i << " key_code:" << kTestData[i].key_code;
    }
  }
  
  TEST(EventTest, KeyEventDirectUnicode) {
    KeyEvent key(0x1234U, ui::VKEY_UNKNOWN, ui::EF_NONE);
    EXPECT_EQ(0x1234U, key.GetCharacter());
    EXPECT_EQ(ET_KEY_PRESSED, key.type());
    EXPECT_TRUE(key.is_char());
  }
  
  TEST(EventTest, NormalizeKeyEventFlags) {
  #if defined(USE_X11)
    // Normalize flags when KeyEvent is created from XEvent.
    ScopedXI2Event event;
    {
      event.InitKeyEvent(ET_KEY_PRESSED, VKEY_SHIFT, EF_SHIFT_DOWN);
      KeyEvent keyev(event);
      EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags());
    }
    {
      event.InitKeyEvent(ET_KEY_RELEASED, VKEY_SHIFT, EF_SHIFT_DOWN);
      KeyEvent keyev(event);
      EXPECT_EQ(EF_NONE, keyev.flags());
    }
    {
      event.InitKeyEvent(ET_KEY_PRESSED, VKEY_CONTROL, EF_CONTROL_DOWN);
      KeyEvent keyev(event);
      EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags());
    }
    {
      event.InitKeyEvent(ET_KEY_RELEASED, VKEY_CONTROL, EF_CONTROL_DOWN);
      KeyEvent keyev(event);
      EXPECT_EQ(EF_NONE, keyev.flags());
    }
    {
      event.InitKeyEvent(ET_KEY_PRESSED, VKEY_MENU,  EF_ALT_DOWN);
      KeyEvent keyev(event);
      EXPECT_EQ(EF_ALT_DOWN, keyev.flags());
    }
    {
      event.InitKeyEvent(ET_KEY_RELEASED, VKEY_MENU, EF_ALT_DOWN);
      KeyEvent keyev(event);
      EXPECT_EQ(EF_NONE, keyev.flags());
    }
  #endif
  
    // Do not normalize flags for synthesized events without
    // KeyEvent::NormalizeFlags called explicitly.
    {
      KeyEvent keyev(ET_KEY_PRESSED, VKEY_SHIFT, EF_SHIFT_DOWN);
      EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags());
    }
    {
      KeyEvent keyev(ET_KEY_RELEASED, VKEY_SHIFT, EF_SHIFT_DOWN);
      EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags());
      keyev.NormalizeFlags();
      EXPECT_EQ(EF_NONE, keyev.flags());
    }
    {
      KeyEvent keyev(ET_KEY_PRESSED, VKEY_CONTROL, EF_CONTROL_DOWN);
      EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags());
    }
    {
      KeyEvent keyev(ET_KEY_RELEASED, VKEY_CONTROL, EF_CONTROL_DOWN);
      EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags());
      keyev.NormalizeFlags();
      EXPECT_EQ(EF_NONE, keyev.flags());
    }
    {
      KeyEvent keyev(ET_KEY_PRESSED, VKEY_MENU,  EF_ALT_DOWN);
      EXPECT_EQ(EF_ALT_DOWN, keyev.flags());
    }
    {
      KeyEvent keyev(ET_KEY_RELEASED, VKEY_MENU, EF_ALT_DOWN);
      EXPECT_EQ(EF_ALT_DOWN, keyev.flags());
      keyev.NormalizeFlags();
      EXPECT_EQ(EF_NONE, keyev.flags());
    }
  }
  
  TEST(EventTest, KeyEventCopy) {
    KeyEvent key(ET_KEY_PRESSED, VKEY_A, EF_NONE);
    scoped_ptr<KeyEvent> copied_key(new KeyEvent(key));
    EXPECT_EQ(copied_key->type(), key.type());
    EXPECT_EQ(copied_key->key_code(), key.key_code());
  }
  
  TEST(EventTest, KeyEventCode) {
    const char kCodeForSpace[] = "Space";
    const uint16 kNativeCodeSpace =
        ui::KeycodeConverter::CodeToNativeKeycode(kCodeForSpace);
    ASSERT_NE(ui::KeycodeConverter::InvalidNativeKeycode(), kNativeCodeSpace);
  
    {
      KeyEvent key(ET_KEY_PRESSED, VKEY_SPACE, kCodeForSpace, EF_NONE);
      EXPECT_EQ(kCodeForSpace, key.code());
    }
    {
      // Regardless the KeyEvent.key_code (VKEY_RETURN), code should be
      // the specified value.
      KeyEvent key(ET_KEY_PRESSED, VKEY_RETURN, kCodeForSpace, EF_NONE);
      EXPECT_EQ(kCodeForSpace, key.code());
    }
    {
      // If the synthetic event is initialized without code, it returns
      // an empty string.
      // TODO(komatsu): Fill a fallback value assuming the US keyboard layout.
      KeyEvent key(ET_KEY_PRESSED, VKEY_SPACE, EF_NONE);
      EXPECT_TRUE(key.code().empty());
    }
  #if defined(USE_X11)
    {
      // KeyEvent converts from the native keycode (XKB) to the code.
      ScopedXI2Event xevent;
      xevent.InitKeyEvent(ET_KEY_PRESSED, VKEY_SPACE, kNativeCodeSpace);
      KeyEvent key(xevent);
      EXPECT_EQ(kCodeForSpace, key.code());
    }
  #endif  // USE_X11
  #if defined(OS_WIN)
    {
      // Test a non extended key.
      ASSERT_EQ((kNativeCodeSpace & 0xFF), kNativeCodeSpace);
  
      const LPARAM lParam = GetLParamFromScanCode(kNativeCodeSpace);
      MSG native_event = { NULL, WM_KEYUP, VKEY_SPACE, lParam };
      KeyEvent key(native_event);
  
      // KeyEvent converts from the native keycode (scan code) to the code.
      EXPECT_EQ(kCodeForSpace, key.code());
    }
    {
      const char kCodeForHome[]  = "Home";
      const uint16 kNativeCodeHome  = 0xe047;
  
      // 'Home' is an extended key with 0xe000 bits.
      ASSERT_NE((kNativeCodeHome & 0xFF), kNativeCodeHome);
      const LPARAM lParam = GetLParamFromScanCode(kNativeCodeHome);
  
      MSG native_event = { NULL, WM_KEYUP, VKEY_HOME, lParam };
      KeyEvent key(native_event);
  
      // KeyEvent converts from the native keycode (scan code) to the code.
      EXPECT_EQ(kCodeForHome, key.code());
    }
  #endif  // OS_WIN
  }
  
  #if defined(USE_X11) || defined(OS_WIN)
  TEST(EventTest, AutoRepeat) {
    const uint16 kNativeCodeA = ui::KeycodeConverter::CodeToNativeKeycode("KeyA");
    const uint16 kNativeCodeB = ui::KeycodeConverter::CodeToNativeKeycode("KeyB");
  #if defined(USE_X11)
    ScopedXI2Event native_event_a_pressed;
    native_event_a_pressed.InitKeyEvent(ET_KEY_PRESSED, VKEY_A, kNativeCodeA);
    ScopedXI2Event native_event_a_released;
    native_event_a_released.InitKeyEvent(ET_KEY_RELEASED, VKEY_A, kNativeCodeA);
    ScopedXI2Event native_event_b_pressed;
    native_event_b_pressed.InitKeyEvent(ET_KEY_PRESSED, VKEY_B, kNativeCodeB);
    ScopedXI2Event native_event_a_pressed_nonstandard_state;
    native_event_a_pressed_nonstandard_state.InitKeyEvent(
        ET_KEY_PRESSED, VKEY_A, kNativeCodeA);
    // IBUS-GTK uses the mask (1 << 25) to detect reposted event.
    static_cast<XEvent*>(native_event_a_pressed_nonstandard_state)->xkey.state |=
        1 << 25;
  #elif defined(OS_WIN)
    const LPARAM lParam_a = GetLParamFromScanCode(kNativeCodeA);
    const LPARAM lParam_b = GetLParamFromScanCode(kNativeCodeB);
    MSG native_event_a_pressed = { NULL, WM_KEYDOWN, VKEY_A, lParam_a };
    MSG native_event_a_released = { NULL, WM_KEYUP, VKEY_A, lParam_a };
    MSG native_event_b_pressed = { NULL, WM_KEYUP, VKEY_B, lParam_b };
  #endif
    KeyEvent key_a1(native_event_a_pressed);
    EXPECT_FALSE(key_a1.IsRepeat());
    KeyEvent key_a1_released(native_event_a_released);
    EXPECT_FALSE(key_a1_released.IsRepeat());
  
    KeyEvent key_a2(native_event_a_pressed);
    EXPECT_FALSE(key_a2.IsRepeat());
    KeyEvent key_a2_repeated(native_event_a_pressed);
    EXPECT_TRUE(key_a2_repeated.IsRepeat());
    KeyEvent key_a2_released(native_event_a_released);
    EXPECT_FALSE(key_a2_released.IsRepeat());
  
    KeyEvent key_a3(native_event_a_pressed);
    EXPECT_FALSE(key_a3.IsRepeat());
    KeyEvent key_b(native_event_b_pressed);
    EXPECT_FALSE(key_b.IsRepeat());
    KeyEvent key_a3_again(native_event_a_pressed);
    EXPECT_FALSE(key_a3_again.IsRepeat());
    KeyEvent key_a3_repeated(native_event_a_pressed);
    EXPECT_TRUE(key_a3_repeated.IsRepeat());
    KeyEvent key_a3_repeated2(native_event_a_pressed);
    EXPECT_TRUE(key_a3_repeated2.IsRepeat());
    KeyEvent key_a3_released(native_event_a_released);
    EXPECT_FALSE(key_a3_released.IsRepeat());
  
  #if defined(USE_X11)
    KeyEvent key_a4_pressed(native_event_a_pressed);
    EXPECT_FALSE(key_a4_pressed.IsRepeat());
  
    KeyEvent key_a4_pressed_nonstandard_state(
        native_event_a_pressed_nonstandard_state);
    EXPECT_FALSE(key_a4_pressed_nonstandard_state.IsRepeat());
  #endif
  }
  #endif  // USE_X11 || OS_WIN
  
  }  // namespace ui
  