OLD | NEW |
| (Empty) |
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 = 168; | |
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 | |
OLD | NEW |