ui/events/keycodes/dom4/keycode_converter_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 "ui/events/keycodes/dom4/keycode_converter.h"
   6
   7 #include <map>
   8
   9 #include "base/basictypes.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11 #include "ui/events/keycodes/dom3/dom_code.h"
  12 #include "ui/events/keycodes/dom3/dom_key.h"
  13
  14 using ui::KeycodeConverter;
  15
  16 namespace {
  17
  18 #if defined(OS_WIN)
  19 const size_t kExpectedMappedKeyCount = 138;
  20 #elif defined(OS_LINUX)
  21 const size_t kExpectedMappedKeyCount = 155;
  22 #elif defined(OS_MACOSX)
  23 const size_t kExpectedMappedKeyCount = 118;
  24 #else
  25 const size_t kExpectedMappedKeyCount = 0;
  26 #endif
  27
  28 const uint32_t kUsbNonExistentKeycode = 0xffffff;
  29 const uint32_t kUsbUsBackslash =        0x070031;
  30 const uint32_t kUsbNonUsHash =          0x070032;
  31
  32 TEST(UsbKeycodeMap, Basic) {
  33   // Verify that the first element in the table is the "invalid" code.
  34   const ui::KeycodeMapEntry* keycode_map =
  35       ui::KeycodeConverter::GetKeycodeMapForTest();
  36   EXPECT_EQ(ui::KeycodeConverter::InvalidUsbKeycode(),
  37             keycode_map[0].usb_keycode);
  38   EXPECT_EQ(ui::KeycodeConverter::InvalidNativeKeycode(),
  39             keycode_map[0].native_keycode);
  40   EXPECT_EQ(ui::KeycodeConverter::InvalidNativeKeycode(),
  41             ui::KeycodeConverter::CodeToNativeKeycode("Unidentified"));
  42
  43   // Verify that there are no duplicate entries in the mapping.
  44   std::map<uint32_t, uint16_t> usb_to_native;
  45   std::map<uint16_t, uint32_t> native_to_usb;
  46   size_t numEntries = ui::KeycodeConverter::NumKeycodeMapEntriesForTest();
  47   for (size_t i = 0; i < numEntries; ++i) {
  48     const ui::KeycodeMapEntry* entry = &keycode_map[i];
  49     // Don't test keys with no native keycode mapping on this platform.
  50     if (entry->native_keycode == ui::KeycodeConverter::InvalidNativeKeycode())
  51       continue;
  52
  53     // Verify UsbKeycodeToNativeKeycode works for this key.
  54     EXPECT_EQ(
  55         entry->native_keycode,
  56         ui::KeycodeConverter::UsbKeycodeToNativeKeycode(entry->usb_keycode));
  57
  58     // Verify CodeToNativeKeycode and NativeKeycodeToCode work correctly.
  59     if (entry->code) {
  60       EXPECT_EQ(entry->native_keycode,
  61                 ui::KeycodeConverter::CodeToNativeKeycode(entry->code));
  62       EXPECT_STREQ(
  63           entry->code,
  64           ui::KeycodeConverter::NativeKeycodeToCode(entry->native_keycode));
  65     }
  66     else {
  67       EXPECT_EQ(ui::KeycodeConverter::InvalidNativeKeycode(),
  68                 ui::KeycodeConverter::CodeToNativeKeycode(entry->code));
  69     }
  70
  71     // Verify that the USB or native codes aren't duplicated.
  72     EXPECT_EQ(0U, usb_to_native.count(entry->usb_keycode))
  73         << " duplicate of USB code 0x" << std::hex << std::setfill('0')
  74         << std::setw(6) << entry->usb_keycode
  75         << " to native 0x"
  76         << std::setw(4) << entry->native_keycode
  77         << " (previous was 0x"
  78         << std::setw(4) << usb_to_native[entry->usb_keycode]
  79         << ")";
  80     usb_to_native[entry->usb_keycode] = entry->native_keycode;
  81     EXPECT_EQ(0U, native_to_usb.count(entry->native_keycode))
  82         << " duplicate of native code 0x" << std::hex << std::setfill('0')
  83         << std::setw(4) << entry->native_keycode
  84         << " to USB 0x"
  85         << std::setw(6) << entry->usb_keycode
  86         << " (previous was 0x"
  87         << std::setw(6) << native_to_usb[entry->native_keycode]
  88         << ")";
  89     native_to_usb[entry->native_keycode] = entry->usb_keycode;
  90   }
  91   ASSERT_EQ(usb_to_native.size(), native_to_usb.size());
  92
  93   // Verify that the number of mapped keys is what we expect, i.e. we haven't
  94   // lost any, and if we've added some then the expectation has been updated.
  95   EXPECT_EQ(kExpectedMappedKeyCount, usb_to_native.size());
  96 }
  97
  98 TEST(UsbKeycodeMap, NonExistent) {
  99   // Verify that UsbKeycodeToNativeKeycode works for a non-existent USB keycode.
 100   EXPECT_EQ(
 101       ui::KeycodeConverter::InvalidNativeKeycode(),
 102       ui::KeycodeConverter::UsbKeycodeToNativeKeycode(kUsbNonExistentKeycode));
 103 }
 104
 105 TEST(UsbKeycodeMap, UsBackslashIsNonUsHash) {
 106   // Verify that UsbKeycodeToNativeKeycode treats the non-US "hash" key
 107   // as equivalent to the US "backslash" key.
 108   EXPECT_EQ(ui::KeycodeConverter::UsbKeycodeToNativeKeycode(kUsbUsBackslash),
 109             ui::KeycodeConverter::UsbKeycodeToNativeKeycode(kUsbNonUsHash));
 110 }
 111
 112 TEST(KeycodeConverter, DomCode) {
 113   // Test invalid and unknown arguments to CodeStringToDomCode()
 114   EXPECT_EQ(ui::DomCode::NONE,
 115             ui::KeycodeConverter::CodeStringToDomCode(nullptr));
 116   EXPECT_EQ(ui::DomCode::NONE, ui::KeycodeConverter::CodeStringToDomCode("-"));
 117   EXPECT_EQ(ui::DomCode::NONE, ui::KeycodeConverter::CodeStringToDomCode(""));
 118   // Round-trip test DOM Level 3 .code strings.
 119   const ui::KeycodeMapEntry* keycode_map =
 120       ui::KeycodeConverter::GetKeycodeMapForTest();
 121   size_t numEntries = ui::KeycodeConverter::NumKeycodeMapEntriesForTest();
 122   for (size_t i = 0; i < numEntries; ++i) {
 123     SCOPED_TRACE(i);
 124     const ui::KeycodeMapEntry* entry = &keycode_map[i];
 125     ui::DomCode code = ui::KeycodeConverter::CodeStringToDomCode(entry->code);
 126     if (entry->code) {
 127       EXPECT_STREQ(entry->code,
 128                    ui::KeycodeConverter::DomCodeToCodeString(code));
 129     } else {
 130       EXPECT_EQ(static_cast<int>(ui::DomCode::NONE),
 131                 static_cast<int>(code));
 132     }
 133   }
 134 }
 135
 136 TEST(KeycodeConverter, DomKey) {
 137   // Test invalid and unknown arguments to KeyStringToDomKey()
 138   EXPECT_EQ(ui::DomKey::NONE, ui::KeycodeConverter::KeyStringToDomKey(nullptr));
 139   EXPECT_EQ(ui::DomKey::NONE, ui::KeycodeConverter::KeyStringToDomKey("-"));
 140   // Round-trip test DOM Level 3 .key strings.
 141   const char* s = nullptr;
 142   for (size_t i = 0;
 143        (s = ui::KeycodeConverter::DomKeyStringForTest(i)) != nullptr;
 144        ++i) {
 145     SCOPED_TRACE(i);
 146     ui::DomKey key = ui::KeycodeConverter::KeyStringToDomKey(s);
 147     if (s) {
 148       EXPECT_STREQ(s, ui::KeycodeConverter::DomKeyToKeyString(key));
 149     } else {
 150       EXPECT_EQ(ui::DomKey::NONE, key);
 151     }
 152   }
 153 }
 154
 155 }  // namespace