1 /* 2 * Copyright (c) 2021-2022 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 "input_event.h" 19 #include "mmi_log.h" 20 21 #undef MMI_LOG_TAG 22 #define MMI_LOG_TAG "InputEventTest" 23 24 namespace OHOS { 25 namespace MMI { 26 namespace { 27 using namespace testing::ext; 28 } // namespace 29 30 class InputEventTest : public testing::Test { 31 public: SetUpTestCase(void)32 static void SetUpTestCase(void) {} TearDownTestCase(void)33 static void TearDownTestCase(void) {} 34 }; 35 36 /** 37 * @tc.name: InputEventTest_EventTypeToString_001 38 * @tc.desc: Test EventTypeToString 39 * @tc.type: FUNC 40 * @tc.require: 41 */ 42 HWTEST_F(InputEventTest, InputEventTest_EventTypeToString_001, TestSize.Level1) 43 { 44 CALL_TEST_DEBUG; 45 auto InputEvent = InputEvent::Create(); 46 ASSERT_NE(InputEvent, nullptr); 47 int32_t eventType = InputEvent::EVENT_TYPE_BASE; 48 auto ret = InputEvent->EventTypeToString(eventType); 49 ASSERT_STREQ(ret, "base"); 50 eventType = InputEvent::EVENT_TYPE_KEY; 51 ret = InputEvent->EventTypeToString(eventType); 52 ASSERT_STREQ(ret, "key"); 53 eventType = InputEvent::EVENT_TYPE_POINTER; 54 ret = InputEvent->EventTypeToString(eventType); 55 ASSERT_STREQ(ret, "pointer"); 56 eventType = InputEvent::EVENT_TYPE_AXIS; 57 ret = InputEvent->EventTypeToString(eventType); 58 ASSERT_STREQ(ret, "axis"); 59 eventType = InputEvent::EVENT_TYPE_FINGERPRINT; 60 ret = InputEvent->EventTypeToString(eventType); 61 ASSERT_STREQ(ret, "fingerprint"); 62 eventType = InputEvent::ACTION_CANCEL; 63 ret = InputEvent->EventTypeToString(eventType); 64 ASSERT_STREQ(ret, "unknown"); 65 } 66 67 /** 68 * @tc.name: InputEventTest_MarkProcessed_001 69 * @tc.desc: Test MarkProcessed 70 * @tc.type: FUNC 71 * @tc.require: 72 */ 73 HWTEST_F(InputEventTest, InputEventTest_MarkProcessed_001, TestSize.Level1) 74 { 75 CALL_TEST_DEBUG; 76 auto InputEvent = InputEvent::Create(); 77 ASSERT_NE(InputEvent, nullptr); __anonc87c01da0202(int a, int b) 78 auto callback = [](int a, int b) {}; 79 InputEvent->processedCallback_ = callback; 80 InputEvent->processedCallback_(10, 20); 81 ASSERT_NE(InputEvent->processedCallback_, nullptr); 82 InputEvent->markEnabled_ = false; 83 ASSERT_NO_FATAL_FAILURE(InputEvent->MarkProcessed()); 84 InputEvent->markEnabled_ = true; 85 ASSERT_NO_FATAL_FAILURE(InputEvent->MarkProcessed()); 86 } 87 88 /** 89 * @tc.name: InputEventTest_SetExtraData_001 90 * @tc.desc: Test SetExtraData 91 * @tc.type: FUNC 92 * @tc.require: 93 */ 94 HWTEST_F(InputEventTest, InputEventTest_SetExtraData_001, TestSize.Level1) 95 { 96 CALL_TEST_DEBUG; 97 auto InputEvent = InputEvent::Create(); 98 ASSERT_NE(InputEvent, nullptr); 99 ASSERT_NO_FATAL_FAILURE(InputEvent->SetExtraData(nullptr, 0)); 100 ASSERT_NO_FATAL_FAILURE(InputEvent->SetExtraData(nullptr, 100)); 101 ASSERT_NO_FATAL_FAILURE(InputEvent->SetExtraData(nullptr, 1500)); 102 uint8_t datas[5] = {1, 2, 3, 4, 5}; __anonc87c01da0302(const uint8_t*) 103 std::shared_ptr<const uint8_t[]> sharedData(datas, [](const uint8_t*) {}); 104 ASSERT_NE(sharedData, nullptr); 105 ASSERT_NO_FATAL_FAILURE(InputEvent->SetExtraData(sharedData, 0)); 106 ASSERT_NO_FATAL_FAILURE(InputEvent->SetExtraData(sharedData, 100)); 107 ASSERT_NO_FATAL_FAILURE(InputEvent->SetExtraData(sharedData, 1500)); 108 } 109 110 /** 111 * @tc.name: InputEventTest_WriteToParcel_001 112 * @tc.desc: Test WriteToParcel 113 * @tc.type: FUNC 114 * @tc.require: 115 */ 116 HWTEST_F(InputEventTest, InputEventTest_WriteToParcel_001, TestSize.Level1) 117 { 118 CALL_TEST_DEBUG; 119 auto InputEvent = InputEvent::Create(); 120 ASSERT_NE(InputEvent, nullptr); 121 Parcel out; 122 InputEvent->extraData_ = nullptr; 123 InputEvent->extraDataLength_ = 0; 124 bool ret = InputEvent->WriteToParcel(out); 125 ASSERT_TRUE(ret); 126 InputEvent->extraDataLength_ = 5; 127 ret = InputEvent->WriteToParcel(out); 128 ASSERT_TRUE(ret); 129 uint8_t datas[5] = {1, 2, 3, 4, 5}; __anonc87c01da0402(const uint8_t*) 130 std::shared_ptr<const uint8_t[]> sharedData(datas, [](const uint8_t*) {}); 131 InputEvent->extraData_ = sharedData; 132 InputEvent->extraDataLength_ = 0; 133 ret = InputEvent->WriteToParcel(out); 134 ASSERT_TRUE(ret); 135 InputEvent->extraDataLength_ = 5; 136 ret = InputEvent->WriteToParcel(out); 137 ASSERT_TRUE(ret); 138 } 139 140 /** 141 * @tc.name: InputEventTest_ReadFromParcel_001 142 * @tc.desc: Test ReadFromParcel 143 * @tc.type: FUNC 144 * @tc.require: 145 */ 146 HWTEST_F(InputEventTest, InputEventTest_ReadFromParcel_001, TestSize.Level1) 147 { 148 CALL_TEST_DEBUG; 149 auto InputEvent = InputEvent::Create(); 150 ASSERT_NE(InputEvent, nullptr); 151 Parcel in; 152 InputEvent->extraDataLength_ = 0; 153 bool ret = InputEvent->ReadFromParcel(in); 154 ASSERT_FALSE(ret); 155 InputEvent->extraDataLength_ = 1050; 156 ret = InputEvent->ReadFromParcel(in); 157 ASSERT_FALSE(ret); 158 InputEvent->extraDataLength_ = 10; 159 ret = InputEvent->ReadFromParcel(in); 160 ASSERT_FALSE(ret); 161 } 162 163 /** 164 * @tc.name: InputEventTest_ActionToShortStr_001 165 * @tc.desc: Test ActionToShortStr 166 * @tc.type: FUNC 167 * @tc.require: 168 */ 169 HWTEST_F(InputEventTest, InputEventTest_ActionToShortStr_001, TestSize.Level1) 170 { 171 CALL_TEST_DEBUG; 172 auto InputEvent = InputEvent::Create(); 173 ASSERT_NE(InputEvent, nullptr); 174 int32_t action = InputEvent::ACTION_CANCEL; 175 std::string_view ret = InputEvent->ActionToShortStr(action); 176 ASSERT_EQ(ret, "B:C:"); 177 action = InputEvent::ACTION_UNKNOWN; 178 ret = InputEvent->ActionToShortStr(action); 179 ASSERT_EQ(ret, "B:UK:"); 180 action = InputEvent::EVENT_TYPE_AXIS; 181 ret = InputEvent->ActionToShortStr(action); 182 ASSERT_EQ(ret, "B:?:"); 183 } 184 185 /** 186 * @tc.name: InputEventTest_operator_001 187 * @tc.desc: Test operator 188 * @tc.type: FUNC 189 * @tc.require: 190 */ 191 HWTEST_F(InputEventTest, InputEventTest_operator_001, TestSize.Level1) 192 { 193 CALL_TEST_DEBUG; 194 LogTracer source1(300, 5, 6); 195 LogTracer destination; 196 destination = std::move(source1); 197 LogTracer source2(400, 7, 8); 198 destination = std::move(source2); 199 } 200 } // namespace MMI 201 } // namespace OHOS