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 <gtest/gtest.h> 17 18 #include "cJSON.h" 19 #include "util.h" 20 21 #include "ability_manager_client.h" 22 #include "common_event_support.h" 23 #include "display_event_monitor.h" 24 #include "event_log_helper.h" 25 #include "gesturesense_wrapper.h" 26 #include "input_event_handler.h" 27 #include "input_handler_type.h" 28 #include "input_windows_manager.h" 29 #include "key_command_handler.h" 30 #include "mmi_log.h" 31 #include "multimodal_event_handler.h" 32 #include "multimodal_input_preferences_manager.h" 33 #include "stylus_key_handler.h" 34 #include "system_info.h" 35 36 #undef MMI_LOG_TAG 37 #define MMI_LOG_TAG "KeyCmdSendKeyEventTest" 38 39 namespace OHOS { 40 namespace MMI { 41 namespace { 42 using namespace testing::ext; 43 } // namespace 44 class KeyCmdSendKeyEventTest : public testing::Test { 45 public: SetUpTestCase(void)46 static void SetUpTestCase(void) {} TearDownTestCase(void)47 static void TearDownTestCase(void) {} 48 }; 49 50 /** 51 * @tc.name: KeyCmdSendKeyEventTest_SendKeyEvent_001 52 * @tc.desc: Test if (!isHandleSequence_) 53 * @tc.type: FUNC 54 * @tc.require: 55 */ 56 HWTEST_F(KeyCmdSendKeyEventTest, KeyCmdSendKeyEventTest_SendKeyEvent_001, TestSize.Level1) 57 { 58 CALL_TEST_DEBUG; 59 KeyCommandHandler handler; 60 handler.isHandleSequence_ = true; 61 ASSERT_NO_FATAL_FAILURE(handler.SendKeyEvent()); 62 } 63 64 /** 65 * @tc.name: KeyCmdSendKeyEventTest_SendKeyEvent_002 66 * @tc.desc: Test if (!isHandleSequence_) 67 * @tc.type: FUNC 68 * @tc.require: 69 */ 70 HWTEST_F(KeyCmdSendKeyEventTest, KeyCmdSendKeyEventTest_SendKeyEvent_002, TestSize.Level1) 71 { 72 CALL_TEST_DEBUG; 73 KeyCommandHandler handler; 74 handler.isHandleSequence_ = false; 75 ASSERT_NO_FATAL_FAILURE(handler.SendKeyEvent()); 76 } 77 78 /** 79 * @tc.name: KeyCmdSendKeyEventTest_SendKeyEvent_003 80 * @tc.desc: Test if (IsSpecialType(keycode, SpecialType::KEY_DOWN_ACTION)) 81 * @tc.type: FUNC 82 * @tc.require: 83 */ 84 HWTEST_F(KeyCmdSendKeyEventTest, KeyCmdSendKeyEventTest_SendKeyEvent_003, TestSize.Level1) 85 { 86 CALL_TEST_DEBUG; 87 KeyCommandHandler handler; 88 handler.isHandleSequence_ = false; 89 handler.launchAbilityCount_ = 0; 90 handler.count_ = 1; 91 handler.repeatKey_.keyCode = KeyEvent::KEYCODE_POWER; 92 ASSERT_NO_FATAL_FAILURE(handler.SendKeyEvent()); 93 } 94 95 /** 96 * @tc.name: KeyCmdSendKeyEventTest_SendKeyEvent_004 97 * @tc.desc: Test if (IsSpecialType(keycode, SpecialType::KEY_DOWN_ACTION)) 98 * @tc.type: FUNC 99 * @tc.require: 100 */ 101 HWTEST_F(KeyCmdSendKeyEventTest, KeyCmdSendKeyEventTest_SendKeyEvent_004, TestSize.Level1) 102 { 103 CALL_TEST_DEBUG; 104 KeyCommandHandler handler; 105 handler.isHandleSequence_ = false; 106 handler.launchAbilityCount_ = 0; 107 handler.count_ = 1; 108 handler.repeatKey_.keyCode = KeyEvent::KEYCODE_CAMERA; 109 ASSERT_NO_FATAL_FAILURE(handler.SendKeyEvent()); 110 } 111 112 /** 113 * @tc.name: KeyCmdSendKeyEventTest_SendKeyEvent_005 114 * @tc.desc: Test if (count_ == repeatKeyMaxTimes_[keycode] - 1 && keycode == KeyEvent::KEYCODE_POWER) 115 * @tc.type: FUNC 116 * @tc.require: 117 */ 118 HWTEST_F(KeyCmdSendKeyEventTest, KeyCmdSendKeyEventTest_SendKeyEvent_005, TestSize.Level1) 119 { 120 CALL_TEST_DEBUG; 121 KeyCommandHandler handler; 122 handler.isHandleSequence_ = false; 123 handler.launchAbilityCount_ = 0; 124 handler.count_ = 1; 125 handler.repeatKey_.keyCode = KeyEvent::KEYCODE_POWER; 126 handler.repeatKeyMaxTimes_.emplace(KeyEvent::KEYCODE_POWER, 2); 127 ASSERT_NO_FATAL_FAILURE(handler.SendKeyEvent()); 128 } 129 130 /** 131 * @tc.name: KeyCmdSendKeyEventTest_SendKeyEvent_006 132 * @tc.desc: Test if (count_ == repeatKeyMaxTimes_[keycode] - 1 && keycode == KeyEvent::KEYCODE_POWER) 133 * @tc.type: FUNC 134 * @tc.require: 135 */ 136 HWTEST_F(KeyCmdSendKeyEventTest, KeyCmdSendKeyEventTest_SendKeyEvent_006, TestSize.Level1) 137 { 138 CALL_TEST_DEBUG; 139 KeyCommandHandler handler; 140 handler.isHandleSequence_ = false; 141 handler.launchAbilityCount_ = 0; 142 handler.count_ = 1; 143 handler.repeatKey_.keyCode = KeyEvent::KEYCODE_POWER; 144 handler.repeatKeyMaxTimes_.emplace(KeyEvent::KEYCODE_POWER, 1); 145 ASSERT_NO_FATAL_FAILURE(handler.SendKeyEvent()); 146 } 147 148 /** 149 * @tc.name: KeyCmdSendKeyEventTest_SendKeyEvent_007 150 * @tc.desc: Test if (i != 0) 151 * @tc.type: FUNC 152 * @tc.require: 153 */ 154 HWTEST_F(KeyCmdSendKeyEventTest, KeyCmdSendKeyEventTest_SendKeyEvent_007, TestSize.Level1) 155 { 156 CALL_TEST_DEBUG; 157 KeyCommandHandler handler; 158 handler.isHandleSequence_ = false; 159 handler.launchAbilityCount_ = 0; 160 handler.count_ = 1; 161 handler.repeatKey_.keyCode = KeyEvent::KEYCODE_POWER; 162 handler.repeatKeyMaxTimes_.emplace(KeyEvent::KEYCODE_POWER, 1); 163 ASSERT_NO_FATAL_FAILURE(handler.SendKeyEvent()); 164 } 165 166 /** 167 * @tc.name: KeyCmdSendKeyEventTest_SendKeyEvent_008 168 * @tc.desc: Test if (i != 0) 169 * @tc.type: FUNC 170 * @tc.require: 171 */ 172 HWTEST_F(KeyCmdSendKeyEventTest, KeyCmdSendKeyEventTest_SendKeyEvent_008, TestSize.Level1) 173 { 174 CALL_TEST_DEBUG; 175 KeyCommandHandler handler; 176 handler.isHandleSequence_ = false; 177 handler.launchAbilityCount_ = 1; 178 handler.count_ = 2; 179 handler.repeatKey_.keyCode = KeyEvent::KEYCODE_POWER; 180 handler.repeatKeyMaxTimes_.emplace(KeyEvent::KEYCODE_POWER, 1); 181 ASSERT_NO_FATAL_FAILURE(handler.SendKeyEvent()); 182 } 183 } // namespace MMI 184 } // namespace OHOS