1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <cstdio> 17 18 #include <gtest/gtest.h> 19 20 #include "key_unicode_transformation.h" 21 #include "key_event.h" 22 #include "hos_key_event.h" 23 24 25 #undef MMI_LOG_TAG 26 #define MMI_LOG_TAG "KeyUnicodeTransformationTest" 27 28 namespace OHOS { 29 namespace MMI { 30 namespace { 31 using namespace testing::ext; 32 } 33 class KeyUnicodeTransformationTest : public testing::Test { 34 public: SetUpTestCase(void)35 static void SetUpTestCase(void) {} TearDownTestCase(void)36 static void TearDownTestCase(void) {} SetUp()37 void SetUp(){}; TearDown()38 void TearDown(){}; 39 }; 40 41 struct KeyUnicode { 42 uint32_t original { 0 }; 43 uint32_t transitioned { 0 }; 44 }; 45 constexpr uint32_t DEFAULT_UNICODE = 0x0000; 46 const std::map<int32_t, KeyUnicode> KEY_UNICODE_TRANSFORMATION = { 47 { HOS_KEY_A, { 0x0061, 0x0041 } }, 48 { HOS_KEY_B, { 0x0062, 0x0042 } }, 49 { HOS_KEY_C, { 0x0063, 0x0043 } }, 50 { HOS_KEY_D, { 0x0064, 0x0044 } }, 51 { HOS_KEY_E, { 0x0065, 0x0045 } }, 52 { HOS_KEY_F, { 0x0066, 0x0046 } }, 53 { HOS_KEY_G, { 0x0067, 0x0047 } }, 54 { HOS_KEY_H, { 0x0068, 0x0048 } }, 55 { HOS_KEY_I, { 0x0069, 0x0049 } }, 56 { HOS_KEY_J, { 0x006A, 0x004A } }, 57 { HOS_KEY_K, { 0x006B, 0x004B } }, 58 { HOS_KEY_L, { 0x006C, 0x004C } }, 59 { HOS_KEY_M, { 0x006D, 0x004D } }, 60 { HOS_KEY_N, { 0x006E, 0x004E } }, 61 { HOS_KEY_O, { 0x006F, 0x004F } }, 62 { HOS_KEY_P, { 0x0070, 0x0050 } }, 63 { HOS_KEY_Q, { 0x0071, 0x0051 } }, 64 { HOS_KEY_R, { 0x0072, 0x0052 } }, 65 { HOS_KEY_S, { 0x0073, 0x0053 } }, 66 { HOS_KEY_T, { 0x0074, 0x0054 } }, 67 { HOS_KEY_U, { 0x0075, 0x0055 } }, 68 { HOS_KEY_V, { 0x0076, 0x0056 } }, 69 { HOS_KEY_W, { 0x0077, 0x0057 } }, 70 { HOS_KEY_X, { 0x0078, 0x0058 } }, 71 { HOS_KEY_Y, { 0x0079, 0x0059 } }, 72 { HOS_KEY_Z, { 0x007A, 0x005A } }, 73 { HOS_KEY_0, { 0x0030, 0x0029 } }, 74 { HOS_KEY_1, { 0x0031, 0x0021 } }, 75 { HOS_KEY_2, { 0x0032, 0x0040 } }, 76 { HOS_KEY_3, { 0x0033, 0x0023 } }, 77 { HOS_KEY_4, { 0x0034, 0x0024 } }, 78 { HOS_KEY_5, { 0x0035, 0x0025 } }, 79 { HOS_KEY_6, { 0x0036, 0x005E } }, 80 { HOS_KEY_7, { 0x0037, 0x0026 } }, 81 { HOS_KEY_8, { 0x0038, 0x002A } }, 82 { HOS_KEY_9, { 0x0039, 0x0028 } }, 83 { HOS_KEY_GRAVE, { 0x0060, 0x007E } }, 84 { HOS_KEY_MINUS, { 0x002D, 0x005F } }, 85 { HOS_KEY_EQUALS, { 0x002B, 0x003D } }, 86 { HOS_KEY_LEFT_BRACKET, { 0x005B, 0x007B } }, 87 { HOS_KEY_RIGHT_BRACKET, { 0x005D, 0x007D } }, 88 { HOS_KEY_BACKSLASH, { 0x005C, 0x007C } }, 89 { HOS_KEY_SEMICOLON, { 0x003B, 0x003A } }, 90 { HOS_KEY_APOSTROPHE, { 0x0027, 0x0022 } }, 91 { HOS_KEY_SLASH, { 0x002F, 0x003F } }, 92 { HOS_KEY_COMMA, { 0x002C, 0x003C } }, 93 { HOS_KEY_PERIOD, { 0x002E, 0x003E } }, 94 { HOS_KEY_NUMPAD_0, { 0x0030, 0x0000 } }, 95 { HOS_KEY_NUMPAD_1, { 0x0031, 0x0000 } }, 96 { HOS_KEY_NUMPAD_2, { 0x0032, 0x0000 } }, 97 { HOS_KEY_NUMPAD_3, { 0x0033, 0x0000 } }, 98 { HOS_KEY_NUMPAD_4, { 0x0034, 0x0000 } }, 99 { HOS_KEY_NUMPAD_5, { 0x0035, 0x0000 } }, 100 { HOS_KEY_NUMPAD_6, { 0x0036, 0x0000 } }, 101 { HOS_KEY_NUMPAD_7, { 0x0037, 0x0000 } }, 102 { HOS_KEY_NUMPAD_8, { 0x0038, 0x0000 } }, 103 { HOS_KEY_NUMPAD_9, { 0x0039, 0x0000 } }, 104 { HOS_KEY_NUMPAD_DIVIDE, { 0x002F, 0x0000 } }, 105 { HOS_KEY_NUMPAD_MULTIPLY, { 0x0038, 0x0000 } }, 106 { HOS_KEY_NUMPAD_SUBTRACT, { 0x002D, 0x0000 } }, 107 { HOS_KEY_NUMPAD_ADD, { 0x002B, 0x0000 } }, 108 { HOS_KEY_NUMPAD_DOT, { 0x002E, 0x0000 } } 109 }; 110 111 /** 112 * @tc.name: ShouldReturnOriginal 113 * @tc.desc: Test IsShiftPressed 114 * @tc.type: FUNC 115 * @tc.require: 116 */ 117 HWTEST_F(KeyUnicodeTransformationTest, ShouldReturnOriginal, TestSize.Level1) 118 { 119 CALL_TEST_DEBUG; 120 auto keyEvent = KeyEvent::Create(); 121 EXPECT_EQ(IsShiftPressed(keyEvent), false); 122 } 123 124 /** 125 * @tc.name: ShouldReturnOriginalUnicodeWhenKeyCode 126 * @tc.desc: Test KeyCodeToUnicode 127 * @tc.type: FUNC 128 * @tc.require: 129 */ 130 HWTEST_F(KeyUnicodeTransformationTest, ShouldReturnOriginalUnicodeWhenKeyCode, TestSize.Level1) 131 { 132 CALL_TEST_DEBUG; 133 int32_t keyCode = 0; 134 std::shared_ptr<KeyEvent> keyEvent = nullptr; 135 EXPECT_EQ(KeyCodeToUnicode(keyCode, keyEvent), DEFAULT_UNICODE); 136 } 137 138 /** 139 * @tc.name: ShouldReturnOriginalUnicode_001 140 * @tc.desc: Test KeyCodeToUnicode 141 * @tc.type: FUNC 142 * @tc.require: 143 */ 144 HWTEST_F(KeyUnicodeTransformationTest, ShouldReturnOriginalUnicode_001, TestSize.Level1) 145 { 146 CALL_TEST_DEBUG; 147 int32_t keyCode = 0; 148 auto keyEvent = KeyEvent::Create(); 149 EXPECT_EQ(KeyCodeToUnicode(keyCode, keyEvent), DEFAULT_UNICODE); 150 } 151 152 /** 153 * @tc.name: ShouldReturnOriginalUnicode_002 154 * @tc.desc: Test KeyCodeToUnicode 155 * @tc.type: FUNC 156 * @tc.require: 157 */ 158 HWTEST_F(KeyUnicodeTransformationTest, ShouldReturnOriginalUnicode_002, TestSize.Level1) 159 { 160 CALL_TEST_DEBUG; 161 int32_t keyCode = HOS_KEY_A; 162 auto keyEvent = KeyEvent::Create(); 163 ASSERT_NE(keyEvent, nullptr); 164 KeyEvent::KeyItem item; 165 item.SetKeyCode(KeyEvent::KEYCODE_DPAD_DOWN); 166 keyEvent->AddKeyItem(item); 167 EXPECT_NO_FATAL_FAILURE(KeyCodeToUnicode(keyCode, keyEvent)); 168 } 169 170 /** 171 * @tc.name: ShouldReturnTransitionedUnicode_003 172 * @tc.desc: Test KeyCodeToUnicode 173 * @tc.type: FUNC 174 * @tc.require: 175 */ 176 HWTEST_F(KeyUnicodeTransformationTest, ShouldReturnTransitionedUnicode_003, TestSize.Level1) 177 { 178 CALL_TEST_DEBUG; 179 int32_t keyCode = HOS_KEY_NUMPAD_DOT; 180 auto keyEvent = KeyEvent::Create(); 181 ASSERT_NE(keyEvent, nullptr); 182 KeyEvent::KeyItem item; 183 item.SetKeyCode(KeyEvent::KEYCODE_DPAD_DOWN); 184 keyEvent->AddKeyItem(item); 185 EXPECT_NO_FATAL_FAILURE(KeyCodeToUnicode(keyCode, keyEvent)); 186 } 187 /** 188 * @tc.name: ShouldReturnTransitionedUnicode_004 189 * @tc.desc: Test KeyCodeToUnicode 190 * @tc.type: FUNC 191 * @tc.require: 192 */ 193 HWTEST_F(KeyUnicodeTransformationTest, ShouldReturnTransitionedUnicode_004, TestSize.Level1) 194 { 195 CALL_TEST_DEBUG; 196 int32_t keyCode = HOS_KEY_A; 197 auto keyEvent = KeyEvent::Create(); 198 ASSERT_NE(keyEvent, nullptr); 199 KeyEvent::KeyItem item; 200 item.SetKeyCode(HOS_KEY_SHIFT_LEFT); 201 item.SetPressed(true); 202 keyEvent->AddKeyItem(item); 203 EXPECT_NO_FATAL_FAILURE(KeyCodeToUnicode(keyCode, keyEvent)); 204 } 205 206 /** 207 * @tc.name: ShouldReturnTransitionedUnicode_005 208 * @tc.desc: Test KeyCodeToUnicode 209 * @tc.type: FUNC 210 * @tc.require: 211 */ 212 HWTEST_F(KeyUnicodeTransformationTest, ShouldReturnTransitionedUnicode_005, TestSize.Level1) 213 { 214 CALL_TEST_DEBUG; 215 int32_t keyCode = HOS_KEY_NUMPAD_DOT; 216 auto keyEvent = KeyEvent::Create(); 217 ASSERT_NE(keyEvent, nullptr); 218 KeyEvent::KeyItem item; 219 item.SetKeyCode(HOS_KEY_SHIFT_LEFT); 220 item.SetPressed(true); 221 keyEvent->AddKeyItem(item); 222 EXPECT_NO_FATAL_FAILURE(KeyCodeToUnicode(keyCode, keyEvent)); 223 } 224 225 /** 226 * @tc.name: Test_IsShiftPressed_002 227 * @tc.desc: Test IsShiftPressed 228 * @tc.type: FUNC 229 * @tc.require: 230 */ 231 HWTEST_F(KeyUnicodeTransformationTest, Test_IsShiftPressed_002, TestSize.Level1) 232 { 233 CALL_TEST_DEBUG; 234 auto keyEvent = KeyEvent::Create(); 235 KeyEvent::KeyItem item1; 236 item1.SetKeyCode(HOS_KEY_SHIFT_LEFT); 237 item1.SetPressed(true); 238 item1.SetDownTime(500); 239 keyEvent->keys_.push_back(item1); 240 EXPECT_EQ(IsShiftPressed(keyEvent), true); 241 } 242 243 /** 244 * @tc.name: Test_IsShiftPressed_003 245 * @tc.desc: Test IsShiftPressed 246 * @tc.type: FUNC 247 * @tc.require: 248 */ 249 HWTEST_F(KeyUnicodeTransformationTest, Test_IsShiftPressed_003, TestSize.Level1) 250 { 251 CALL_TEST_DEBUG; 252 auto keyEvent = KeyEvent::Create(); 253 KeyEvent::KeyItem item1; 254 item1.SetKeyCode(HOS_KEY_SHIFT_RIGHT); 255 item1.SetPressed(true); 256 item1.SetDownTime(500); 257 keyEvent->keys_.push_back(item1); 258 EXPECT_EQ(IsShiftPressed(keyEvent), true); 259 } 260 /** 261 * @tc.name: Test_IsShiftPressed_004 262 * @tc.desc: Test IsShiftPressed 263 * @tc.type: FUNC 264 * @tc.require: 265 */ 266 HWTEST_F(KeyUnicodeTransformationTest, Test_IsShiftPressed_004, TestSize.Level1) 267 { 268 CALL_TEST_DEBUG; 269 auto keyEvent = KeyEvent::Create(); 270 KeyEvent::KeyItem item1; 271 item1.SetKeyCode(HOS_KEY_ALT_RIGHT); 272 item1.SetPressed(true); 273 item1.SetDownTime(500); 274 keyEvent->keys_.push_back(item1); 275 EXPECT_EQ(IsShiftPressed(keyEvent), false); 276 } 277 278 } 279 }