Add ui/base/accelerators/accelerator_manager_unittest.cc.

Since I'll add some features to the manager for crbug.com/116950, _unittest.cc is needed.

BUG=116950
TEST=ui_unittests


Review URL: http://codereview.chromium.org/9651029

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@126026 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 183 insertions, 0 deletions

diff --git a/ui/base/accelerators/accelerator_manager_unittest.cc b/ui/base/accelerators/accelerator_manager_unittest.cc
new file mode 100644
index 0000000..0193692
--- /dev/null
+++ b/ui/base/accelerators/accelerator_manager_unittest.cc
@@ -0,0 +1,183 @@
+// 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 "ui/base/accelerators/accelerator_manager.h"
+
+#include "base/compiler_specific.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/events.h"
+#include "ui/base/keycodes/keyboard_codes.h"
+
+namespace ui {
+namespace test {
+
+namespace {
+
+class TestTarget : public AcceleratorTarget {
+ public:
+  TestTarget() : accelerator_pressed_count_(0) {}
+  virtual ~TestTarget() {}
+
+  int accelerator_pressed_count() const {
+    return accelerator_pressed_count_;
+  }
+
+  void set_accelerator_pressed_count(int accelerator_pressed_count) {
+    accelerator_pressed_count_ = accelerator_pressed_count;
+  }
+
+  // Overridden from AcceleratorTarget:
+  virtual bool AcceleratorPressed(const Accelerator& accelerator) OVERRIDE;
+  virtual bool CanHandleAccelerators() const OVERRIDE;
+
+ private:
+  int accelerator_pressed_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestTarget);
+};
+
+bool TestTarget::AcceleratorPressed(const Accelerator& accelerator) {
+  ++accelerator_pressed_count_;
+  return true;
+}
+
+bool TestTarget::CanHandleAccelerators() const {
+  return true;
+}
+
+Accelerator GetAccelerator(KeyboardCode code, int mask) {
+  return Accelerator(code, mask & (1 << 0), mask & (1 << 1), mask & (1 << 2));
+}
+
+}  // namespace
+
+class AcceleratorManagerTest : public testing::Test {
+ public:
+  AcceleratorManagerTest() {}
+  virtual ~AcceleratorManagerTest() {}
+
+  AcceleratorManager manager_;
+};
+
+TEST_F(AcceleratorManagerTest, Register) {
+  const Accelerator accelerator_a(VKEY_A, false, false, false);
+  TestTarget target;
+  manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
+                    &target);
+
+  // The registered accelerator is processed.
+  EXPECT_TRUE(manager_.Process(accelerator_a));
+  EXPECT_EQ(1, target.accelerator_pressed_count());
+}
+
+TEST_F(AcceleratorManagerTest, RegisterMultipleTarget) {
+  const Accelerator accelerator_a(VKEY_A, false, false, false);
+  TestTarget target1;
+  manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
+                    &target1);
+  TestTarget target2;
+  manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
+                    &target2);
+
+  // If multiple targets are registered with the same accelerator, the target
+  // registered later processes the accelerator.
+  EXPECT_TRUE(manager_.Process(accelerator_a));
+  EXPECT_EQ(0, target1.accelerator_pressed_count());
+  EXPECT_EQ(1, target2.accelerator_pressed_count());
+}
+
+TEST_F(AcceleratorManagerTest, Unregister) {
+  const Accelerator accelerator_a(VKEY_A, false, false, false);
+  TestTarget target;
+  manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
+                    &target);
+  const Accelerator accelerator_b(VKEY_B, false, false, false);
+  manager_.Register(accelerator_b, AcceleratorManager::kNormalPriority,
+                    &target);
+
+  // Unregistering a different accelerator does not affect the other
+  // accelerator.
+  manager_.Unregister(accelerator_b, &target);
+  EXPECT_TRUE(manager_.Process(accelerator_a));
+  EXPECT_EQ(1, target.accelerator_pressed_count());
+
+  // The unregistered accelerator is no longer processed.
+  target.set_accelerator_pressed_count(0);
+  manager_.Unregister(accelerator_a, &target);
+  EXPECT_FALSE(manager_.Process(accelerator_a));
+  EXPECT_EQ(0, target.accelerator_pressed_count());
+}
+
+TEST_F(AcceleratorManagerTest, UnregisterAll) {
+  const Accelerator accelerator_a(VKEY_A, false, false, false);
+  TestTarget target1;
+  manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
+                    &target1);
+  const Accelerator accelerator_b(VKEY_B, false, false, false);
+  manager_.Register(accelerator_b, AcceleratorManager::kNormalPriority,
+                    &target1);
+  const Accelerator accelerator_c(VKEY_C, false, false, false);
+  TestTarget target2;
+  manager_.Register(accelerator_c, AcceleratorManager::kNormalPriority,
+                    &target2);
+  manager_.UnregisterAll(&target1);
+
+  // All the accelerators registered for |target1| are no longer processed.
+  EXPECT_FALSE(manager_.Process(accelerator_a));
+  EXPECT_FALSE(manager_.Process(accelerator_b));
+  EXPECT_EQ(0, target1.accelerator_pressed_count());
+
+  // UnregisterAll with a different target does not affect the other target.
+  EXPECT_TRUE(manager_.Process(accelerator_c));
+  EXPECT_EQ(1, target2.accelerator_pressed_count());
+}
+
+TEST_F(AcceleratorManagerTest, Process) {
+  TestTarget target;
+
+  // Test all 2*2*2 cases (shift/control/alt = on/off).
+  for (int mask = 0; mask < 2 * 2 * 2; ++mask) {
+    Accelerator accelerator(GetAccelerator(VKEY_A, mask));
+    const string16 text = accelerator.GetShortcutText();
+    manager_.Register(accelerator, AcceleratorManager::kNormalPriority,
+                      &target);
+
+    // The registered accelerator is processed.
+    const int last_count = target.accelerator_pressed_count();
+    EXPECT_TRUE(manager_.Process(accelerator)) << text;
+    EXPECT_EQ(last_count + 1, target.accelerator_pressed_count()) << text;
+
+    // The non-registered accelerators are not processed.
+    accelerator.set_type(ET_UNKNOWN);
+    EXPECT_FALSE(manager_.Process(accelerator)) << text;  // different type
+    accelerator.set_type(ET_TRANSLATED_KEY_PRESS);
+    EXPECT_FALSE(manager_.Process(accelerator)) << text;  // different type
+    accelerator.set_type(ET_KEY_RELEASED);
+    EXPECT_FALSE(manager_.Process(accelerator)) << text;  // different type
+    accelerator.set_type(ET_TRANSLATED_KEY_RELEASE);
+    EXPECT_FALSE(manager_.Process(accelerator)) << text;  // different type
+
+    EXPECT_FALSE(manager_.Process(GetAccelerator(VKEY_UNKNOWN, mask)))
+        << text;  // different vkey
+    EXPECT_FALSE(manager_.Process(GetAccelerator(VKEY_B, mask)))
+        << text;  // different vkey
+    EXPECT_FALSE(manager_.Process(GetAccelerator(VKEY_SHIFT, mask)))
+        << text;  // different vkey
+
+    for (int test_mask = 0; test_mask < 2 * 2 * 2; ++test_mask) {
+      if (test_mask == mask)
+        continue;
+      const Accelerator test_accelerator(GetAccelerator(VKEY_A, test_mask));
+      const string16 test_text = test_accelerator.GetShortcutText();
+      EXPECT_FALSE(manager_.Process(test_accelerator))
+          << text << ", " << test_text;  // different modifiers
+    }
+
+    EXPECT_EQ(last_count + 1, target.accelerator_pressed_count()) << text;
+    manager_.UnregisterAll(&target);
+  }
+}
+
+}  // namespace test
+}  // namespace ui