DOM Level 3 .code and .key value enumerations.

ui/events/keycodes/dom4/keycode_converter_unittest.cc

Index: ui/events/keycodes/dom4/keycode_converter_unittest.cc
diff --git a/ui/events/keycodes/dom4/keycode_converter_unittest.cc b/ui/events/keycodes/dom4/keycode_converter_unittest.cc
index 0b96583617b7c09d7867583991813043ccb5a081..f405ec7bd3453d5e79897347bc72e04aae803641 100644
--- a/ui/events/keycodes/dom4/keycode_converter_unittest.cc
+++ b/ui/events/keycodes/dom4/keycode_converter_unittest.cc
@@ -8,6 +8,7 @@
 
 #include "base/basictypes.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/events/keycodes/dom4/domcode.h"
 
 using ui::KeycodeConverter;
 
@@ -56,36 +57,29 @@ TEST(UsbKeycodeMap, Basic) {
         ui::KeycodeConverter::UsbKeycodeToNativeKeycode(entry->usb_keycode));
 
     // Verify CodeToNativeKeycode and NativeKeycodeToCode work correctly.
-    if (entry->code) {
+    if (entry->code != ui::DOM_CODE_NONE) {
       EXPECT_EQ(entry->native_keycode,
-                ui::KeycodeConverter::CodeToNativeKeycode(entry->code));
-      EXPECT_STREQ(
+                ui::KeycodeConverter::DomCodeToNativeKeycode(entry->code));
+      EXPECT_EQ(
           entry->code,
-          ui::KeycodeConverter::NativeKeycodeToCode(entry->native_keycode));
-    }
-    else {
+          ui::KeycodeConverter::NativeKeycodeToDomCode(entry->native_keycode));
+    } else {
       EXPECT_EQ(ui::KeycodeConverter::InvalidNativeKeycode(),
-                ui::KeycodeConverter::CodeToNativeKeycode(entry->code));
+                ui::KeycodeConverter::DomCodeToNativeKeycode(entry->code));
     }
 
     // Verify that the USB or native codes aren't duplicated.
     EXPECT_EQ(0U, usb_to_native.count(entry->usb_keycode))
         << " duplicate of USB code 0x" << std::hex << std::setfill('0')
-        << std::setw(6) << entry->usb_keycode
-        << " to native 0x"
-        << std::setw(4) << entry->native_keycode
-        << " (previous was 0x"
-        << std::setw(4) << usb_to_native[entry->usb_keycode]
-        << ")";
+        << std::setw(6) << entry->usb_keycode << " to native 0x" << std::setw(4)
+        << entry->native_keycode << " (previous was 0x" << std::setw(4)
+        << usb_to_native[entry->usb_keycode] << ")";
     usb_to_native[entry->usb_keycode] = entry->native_keycode;
     EXPECT_EQ(0U, native_to_usb.count(entry->native_keycode))
         << " duplicate of native code 0x" << std::hex << std::setfill('0')
-        << std::setw(4) << entry->native_keycode
-        << " to USB 0x"
-        << std::setw(6) << entry->usb_keycode
-        << " (previous was 0x"
-        << std::setw(6) << native_to_usb[entry->native_keycode]
-        << ")";
+        << std::setw(4) << entry->native_keycode << " to USB 0x" << std::setw(6)
+        << entry->usb_keycode << " (previous was 0x" << std::setw(6)
+        << native_to_usb[entry->native_keycode] << ")";
     native_to_usb[entry->native_keycode] = entry->usb_keycode;
   }
   ASSERT_EQ(usb_to_native.size(), native_to_usb.size());
@@ -109,4 +103,44 @@ TEST(UsbKeycodeMap, UsBackslashIsNonUsHash) {
             ui::KeycodeConverter::UsbKeycodeToNativeKeycode(kUsbNonUsHash));
 }
 
+TEST(KeycodeConverter, DomCode) {
+  size_t entries = ui::KeycodeConverter::NumDomCodeStringEntriesForTest();
+  EXPECT_NE(entries, static_cast<size_t>(0u));
+  // Test invalid and unknown arguments to CodeStringToDomCode()
+  EXPECT_EQ(ui::DOM_CODE_NONE,
+            ui::KeycodeConverter::CodeStringToDomCode(nullptr));
+  EXPECT_EQ(ui::DOM_CODE_NONE, ui::KeycodeConverter::CodeStringToDomCode("-"));
+  EXPECT_EQ(ui::DOM_CODE_NONE, ui::KeycodeConverter::CodeStringToDomCode(""));
+  // Round-trip test DOM Level 3 .code strings.
+  const char* const* string = ui::KeycodeConverter::DomCodeStringTableForTest();
+  for (size_t i = 0; i < entries; ++i) {
+    const char* s = string[i];
+    ui::DomCode code = ui::KeycodeConverter::CodeStringToDomCode(s);
+    if (s) {
+      EXPECT_STREQ(s, ui::KeycodeConverter::DomCodeToCodeString(code));
+    } else {
+      EXPECT_EQ(ui::DOM_CODE_NONE, code);
+    }
+  }
+}
+
+TEST(KeycodeConverter, DomKey) {
+  size_t entries = ui::KeycodeConverter::NumDomKeyStringEntriesForTest();
+  EXPECT_NE(entries, static_cast<size_t>(0u));
+  // Test invalid and unknown arguments to KeyStringToDomKey()
+  EXPECT_EQ(ui::DOM_KEY_NONE, ui::KeycodeConverter::KeyStringToDomKey(nullptr));
+  EXPECT_EQ(ui::DOM_KEY_NONE, ui::KeycodeConverter::KeyStringToDomKey("-"));
+  // Round-trip test DOM Level 3 .key strings.
+  const char* const* string = ui::KeycodeConverter::DomKeyStringTableForTest();
+  for (size_t i = 0; i < entries; ++i) {
+    const char* s = string[i];
+    ui::DomKey key = ui::KeycodeConverter::KeyStringToDomKey(s);
+    if (s) {
+      EXPECT_STREQ(s, ui::KeycodeConverter::DomKeyToKeyString(key));
+    } else {
+      EXPECT_EQ(ui::DOM_KEY_NONE, key);
+    }
+  }
+}
+
 }  // namespace