1 /* 2 * Copyright (c) 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 "battery_event_test.h" 17 #include "battery_service.h" 18 #include "battery_service_event_handler.h" 19 #include "power_common.h" 20 #include <memory> 21 22 using namespace testing::ext; 23 24 namespace OHOS { 25 namespace PowerMgr { 26 namespace { 27 constexpr const char* TEST_BATTERY_SERVICE_NAME = "TestBatteryService"; 28 } // namespace 29 30 /** 31 * @tc.name: BatteryEvent001 32 * @tc.desc: eventId is EVENT_RETRY_REGISTER_HDI_STATUS_LISTENER, ProcessEvent 33 * @tc.type: FUNC 34 * @tc.require: issueI5YZR1 35 */ 36 HWTEST_F(BatteryEventTest, BatteryEvent001, TestSize.Level1) 37 { 38 BATTERY_HILOGD(LABEL_TEST, "BatteryEvent001 start."); 39 std::shared_ptr<AppExecFwk::EventRunner> eventRunner = AppExecFwk::EventRunner::Create(TEST_BATTERY_SERVICE_NAME); 40 std::shared_ptr<BatteryServiceEventHandler> eventHandler; 41 eventHandler = 42 std::make_shared<BatteryServiceEventHandler>(eventRunner, DelayedSpSingleton<BatteryService>::GetInstance()); 43 EXPECT_NE(nullptr, eventHandler); 44 45 int32_t eventId = static_cast<int32_t>(BatteryServiceEventHandler::EVENT_RETRY_REGISTER_HDI_STATUS_LISTENER); 46 auto event = AppExecFwk::InnerEvent::Get(eventId); 47 if (eventHandler) { 48 eventHandler->ProcessEvent(event); 49 } 50 EXPECT_TRUE(event->GetInnerEventId() == eventId); 51 BATTERY_HILOGD(LABEL_TEST, "BatteryEvent001 end."); 52 } 53 54 /** 55 * @tc.name: BatteryEvent002 56 * @tc.desc: eventId is EVENT_REGISTER_BATTERY_HDI_CALLBACK, ProcessEvent 57 * @tc.type: FUNC 58 * @tc.require: issueI5YZR1 59 */ 60 HWTEST_F(BatteryEventTest, BatteryEvent002, TestSize.Level1) 61 { 62 BATTERY_HILOGD(LABEL_TEST, "BatteryEvent002 start."); 63 std::shared_ptr<AppExecFwk::EventRunner> eventRunner = AppExecFwk::EventRunner::Create(TEST_BATTERY_SERVICE_NAME); 64 std::shared_ptr<BatteryServiceEventHandler> eventHandler; 65 eventHandler = 66 std::make_shared<BatteryServiceEventHandler>(eventRunner, DelayedSpSingleton<BatteryService>::GetInstance()); 67 EXPECT_NE(nullptr, eventHandler); 68 69 int32_t eventId = static_cast<int32_t>(BatteryServiceEventHandler::EVENT_REGISTER_BATTERY_HDI_CALLBACK); 70 auto event = AppExecFwk::InnerEvent::Get(eventId); 71 if (eventHandler) { 72 eventHandler->ProcessEvent(event); 73 } 74 EXPECT_TRUE(event->GetInnerEventId() == eventId); 75 BATTERY_HILOGD(LABEL_TEST, "BatteryEvent002 end."); 76 } 77 78 /** 79 * @tc.name: BatteryEvent003 80 * @tc.desc: eventId is default, ProcessEvent 81 * @tc.type: FUNC 82 * @tc.require: issueI5YZR1 83 */ 84 HWTEST_F(BatteryEventTest, BatteryEvent003, TestSize.Level1) 85 { 86 BATTERY_HILOGD(LABEL_TEST, "BatteryEvent003 start."); 87 std::shared_ptr<AppExecFwk::EventRunner> eventRunner = AppExecFwk::EventRunner::Create(TEST_BATTERY_SERVICE_NAME); 88 std::shared_ptr<BatteryServiceEventHandler> eventHandler; 89 eventHandler = 90 std::make_shared<BatteryServiceEventHandler>(eventRunner, DelayedSpSingleton<BatteryService>::GetInstance()); 91 EXPECT_NE(nullptr, eventHandler); 92 93 int32_t eventId = 100; 94 auto event = AppExecFwk::InnerEvent::Get(eventId); 95 if (eventHandler) { 96 eventHandler->ProcessEvent(event); 97 } 98 EXPECT_TRUE(event->GetInnerEventId() == eventId); 99 BATTERY_HILOGD(LABEL_TEST, "BatteryEvent003 end."); 100 } 101 102 /** 103 * @tc.name: BatteryEvent004 104 * @tc.desc: The batterService in EventRunner is empty 105 * @tc.type: FUNC 106 * @tc.require: issueI5YZR1 107 */ 108 HWTEST_F(BatteryEventTest, BatteryEvent004, TestSize.Level1) 109 { 110 BATTERY_HILOGD(LABEL_TEST, "BatteryEvent004 start."); 111 sptr<BatteryService> batterService = nullptr; 112 std::shared_ptr<AppExecFwk::EventRunner> eventRunner = AppExecFwk::EventRunner::Create(TEST_BATTERY_SERVICE_NAME); 113 std::shared_ptr<BatteryServiceEventHandler> eventHandler; 114 eventHandler = std::make_shared<BatteryServiceEventHandler>(eventRunner, batterService); 115 EXPECT_NE(nullptr, eventHandler); 116 117 int32_t eventId = static_cast<int32_t>(BatteryServiceEventHandler::EVENT_REGISTER_BATTERY_HDI_CALLBACK); 118 auto event = AppExecFwk::InnerEvent::Get(eventId); 119 if (eventHandler) { 120 eventHandler->ProcessEvent(event); 121 } 122 EXPECT_TRUE(event->GetInnerEventId() == eventId); 123 BATTERY_HILOGD(LABEL_TEST, "BatteryEvent004 end."); 124 } 125 } // namespace PowerMgr 126 } // namespace OHOS 127