src/chrome/browser/chromeos/keyboard_driven_event_rewriter_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 "base/basictypes.h"
   6 #include "base/compiler_specific.h"
   7 #include "base/strings/stringprintf.h"
   8 #include "chrome/browser/chromeos/keyboard_driven_event_rewriter.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "ui/events/event.h"
  11 #include "ui/events/x/events_x_utils.h"
  12
  13 #include <X11/keysym.h>
  14 #include <X11/XF86keysym.h>
  15 #include <X11/Xlib.h>
  16
  17 namespace chromeos {
  18
  19 // Creates an XKeyEvent to initialize a ui::KeyEvent that is passed to
  20 // KeyboardDrivenEventRewriter for processing.
  21 void InitXKeyEvent(ui::KeyboardCode ui_keycode,
  22                    int ui_flags,
  23                    ui::EventType ui_type,
  24                    KeyCode x_keycode,
  25                    unsigned int x_state,
  26                    XEvent* event) {
  27   ui::InitXKeyEventForTesting(ui_type,
  28                               ui_keycode,
  29                               ui_flags,
  30                               event);
  31   event->xkey.keycode = x_keycode;
  32   event->xkey.state = x_state;
  33 }
  34
  35 class KeyboardDrivenEventRewriterTest : public testing::Test {
  36  public:
  37   KeyboardDrivenEventRewriterTest()
  38       : display_(gfx::GetXDisplay()),
  39         keycode_a_(XKeysymToKeycode(display_, XK_a)),
  40         keycode_up_(XKeysymToKeycode(display_, XK_Up)),
  41         keycode_down_(XKeysymToKeycode(display_, XK_Down)),
  42         keycode_left_(XKeysymToKeycode(display_, XK_Left)),
  43         keycode_right_(XKeysymToKeycode(display_, XK_Right)),
  44         keycode_return_(XKeysymToKeycode(display_, XK_Return)),
  45         keycode_f6_(XKeysymToKeycode(display_, XK_F6)) {
  46   }
  47
  48   virtual ~KeyboardDrivenEventRewriterTest() {}
  49
  50  protected:
  51   std::string GetRewrittenEventAsString(ui::KeyboardCode ui_keycode,
  52                                         int ui_flags,
  53                                         ui::EventType ui_type,
  54                                         KeyCode x_keycode,
  55                                         unsigned int x_state) {
  56     XEvent xev;
  57     InitXKeyEvent(ui_keycode, ui_flags, ui_type, x_keycode, x_state, &xev);
  58     ui::KeyEvent keyevent(&xev, false /* is_char */);
  59     bool changed = rewriter_.RewriteForTesting(&keyevent);
  60     return base::StringPrintf("ui_flags=%d x_state=%u changed=%d",
  61                               keyevent.flags(),
  62                               xev.xkey.state,
  63                               changed);
  64   }
  65
  66   std::string GetExpectedResultAsString(int ui_flags,
  67                                         unsigned int x_state,
  68                                         bool changed) {
  69     return base::StringPrintf(
  70         "ui_flags=%d x_state=%u changed=%d", ui_flags, x_state, changed);
  71   }
  72
  73   XDisplay* display_;
  74   const KeyCode keycode_a_;
  75   const KeyCode keycode_up_;
  76   const KeyCode keycode_down_;
  77   const KeyCode keycode_left_;
  78   const KeyCode keycode_right_;
  79   const KeyCode keycode_return_;
  80   const KeyCode keycode_f6_;
  81
  82   KeyboardDrivenEventRewriter rewriter_;
  83
  84  private:
  85   DISALLOW_COPY_AND_ASSIGN(KeyboardDrivenEventRewriterTest);
  86 };
  87
  88 TEST_F(KeyboardDrivenEventRewriterTest, PassThrough) {
  89   struct {
  90     ui::KeyboardCode ui_keycode;
  91     int ui_flags;
  92     KeyCode x_keycode;
  93     unsigned int x_state;
  94   } kTests[] = {
  95     { ui::VKEY_A, ui::EF_NONE, keycode_a_, 0 },
  96     { ui::VKEY_A, ui::EF_CONTROL_DOWN, keycode_a_, ControlMask },
  97     { ui::VKEY_A, ui::EF_ALT_DOWN, keycode_a_, Mod1Mask },
  98     { ui::VKEY_A, ui::EF_SHIFT_DOWN, keycode_a_, ShiftMask },
  99     { ui::VKEY_A, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
 100         keycode_a_, ControlMask | Mod1Mask },
 101     { ui::VKEY_A, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | ui::EF_SHIFT_DOWN,
 102         keycode_a_, ControlMask | Mod1Mask | ShiftMask },
 103
 104     { ui::VKEY_LEFT, ui::EF_NONE, keycode_left_, 0 },
 105     { ui::VKEY_LEFT, ui::EF_CONTROL_DOWN, keycode_left_, ControlMask },
 106     { ui::VKEY_LEFT, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
 107         keycode_left_, ControlMask | Mod1Mask },
 108
 109     { ui::VKEY_RIGHT, ui::EF_NONE, keycode_right_, 0 },
 110     { ui::VKEY_RIGHT, ui::EF_CONTROL_DOWN, keycode_right_, ControlMask },
 111     { ui::VKEY_RIGHT, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
 112         keycode_right_, ControlMask | Mod1Mask },
 113
 114     { ui::VKEY_UP, ui::EF_NONE, keycode_up_, 0 },
 115     { ui::VKEY_UP, ui::EF_CONTROL_DOWN, keycode_up_, ControlMask },
 116     { ui::VKEY_UP, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
 117         keycode_up_, ControlMask | Mod1Mask },
 118
 119     { ui::VKEY_DOWN, ui::EF_NONE, keycode_down_, 0 },
 120     { ui::VKEY_DOWN, ui::EF_CONTROL_DOWN, keycode_down_, ControlMask },
 121     { ui::VKEY_DOWN, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
 122         keycode_down_, ControlMask | Mod1Mask },
 123
 124     { ui::VKEY_RETURN, ui::EF_NONE, keycode_return_, 0 },
 125     { ui::VKEY_RETURN, ui::EF_CONTROL_DOWN, keycode_return_, ControlMask },
 126     { ui::VKEY_RETURN, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
 127         keycode_return_, ControlMask | Mod1Mask },
 128   };
 129
 130   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTests); ++i) {
 131     EXPECT_EQ(GetExpectedResultAsString(kTests[i].ui_flags,
 132                                         kTests[i].x_state,
 133                                         false),
 134               GetRewrittenEventAsString(kTests[i].ui_keycode,
 135                                         kTests[i].ui_flags,
 136                                         ui::ET_KEY_PRESSED,
 137                                         kTests[i].x_keycode,
 138                                         kTests[i].x_state))
 139     << "Test case " << i;
 140   }
 141 }
 142
 143 TEST_F(KeyboardDrivenEventRewriterTest, Rewrite) {
 144   const int kModifierMask = ui::EF_SHIFT_DOWN;
 145   const unsigned int kXState = ShiftMask;
 146
 147   struct {
 148     ui::KeyboardCode ui_keycode;
 149     int ui_flags;
 150     KeyCode x_keycode;
 151     unsigned int x_state;
 152   } kTests[] = {
 153     { ui::VKEY_LEFT, kModifierMask, keycode_left_, kXState },
 154     { ui::VKEY_RIGHT, kModifierMask, keycode_right_, kXState },
 155     { ui::VKEY_UP, kModifierMask, keycode_up_, kXState },
 156     { ui::VKEY_DOWN, kModifierMask, keycode_down_, kXState },
 157     { ui::VKEY_RETURN, kModifierMask, keycode_return_, kXState },
 158     { ui::VKEY_F6, kModifierMask, keycode_f6_, kXState },
 159   };
 160
 161   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTests); ++i) {
 162     EXPECT_EQ(GetExpectedResultAsString(ui::EF_NONE, 0, true),
 163               GetRewrittenEventAsString(kTests[i].ui_keycode,
 164                                         kTests[i].ui_flags,
 165                                         ui::ET_KEY_PRESSED,
 166                                         kTests[i].x_keycode,
 167                                         kTests[i].x_state))
 168     << "Test case " << i;
 169   }
 170 }
 171
 172 }  // namespace chromeos