1 /*
2 * Copyright (c) 2021 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 "charger_offline_shutdown_test.h"
17
18 #include <csignal>
19 #include <iostream>
20 #include "utils/hdf_log.h"
21
22 #include "power_supply_provider.h"
23 #include "battery_thread_test.h"
24 #include "charger_thread.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::HDI::Battery::V1_0;
28 using namespace std;
29
30 namespace ChargerOfflineShutdownTest {
SetUpTestCase(void)31 void ChargerOfflineShutdownTest::SetUpTestCase(void)
32 {
33 }
34
TearDownTestCase(void)35 void ChargerOfflineShutdownTest::TearDownTestCase(void)
36 {
37 }
38
SetUp(void)39 void ChargerOfflineShutdownTest::SetUp(void)
40 {
41 }
42
TearDown(void)43 void ChargerOfflineShutdownTest::TearDown(void)
44 {
45 }
46
47 namespace {
48 struct ChargerThreadUnitTest {};
49 }
50
51 void HandleChargingStateTest(ChargerThread& cthread);
52 std::unique_ptr<BatteryBacklight> GetBacklightTest(ChargerThread& cthread);
53
54 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
55 class HandleChargingStateImplement {
HandleChargingStateTest(ChargerThread & cthread)56 friend void HandleChargingStateTest(ChargerThread& cthread)
57 {
58 (cthread.*privateFun)();
59 }
60 };
61
62 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
63 class GetBacklightImplement {
GetBacklightTest(ChargerThread & cthread)64 friend std::unique_ptr<BatteryBacklight> GetBacklightTest(ChargerThread& cthread)
65 {
66 return std::move(cthread.*privateFun);
67 }
68 };
69
70 template class HandleChargingStateImplement <
71 ChargerThreadUnitTest,
72 decltype(&ChargerThread::HandleChargingState),
73 &ChargerThread::HandleChargingState
74 >;
75
76 template class GetBacklightImplement <
77 ChargerThreadUnitTest,
78 decltype(&ChargerThread::backlight_),
79 &ChargerThread::backlight_
80 >;
81
82 /**
83 * @tc.name: BatteryST_011
84 * @tc.desc: Test functions shutdown during charing and offline less than 2 seconds
85 * @tc.type: FUNC
86 */
87 HWTEST_F (ChargerOfflineShutdownTest, BatteryST_011, TestSize.Level1)
88 {
89 HDF_LOGD("%{public}s: BatteryST_011 start.", __func__);
90 ChargerThread ct;
91 int32_t chargestate = PowerSupplyProvider::CHARGE_STATE_NONE;
92
93 ChargerThreadInitTest(ct);
94 SetChargeStateTest(chargestate, ct);
95 HandleChargingStateTest(ct);
96 bool screenOn = GetBacklightTest(ct)->GetScreenState();
97 HDF_LOGD("%{public}s: screenOn=%{public}d", __func__, screenOn);
98 ASSERT_TRUE(screenOn);
99
100 usleep(1900000);
101 HandleChargingStateTest(ct); // do not shutdown
102 HDF_LOGD("%{public}s: BatteryST_011 end.", __func__);
103 }
104
105 /**
106 * @tc.name: BatteryST_012
107 * @tc.desc: Test functions shutdown during charing and offline 2 seconds
108 * @tc.type: FUNC
109 */
110 HWTEST_F (ChargerOfflineShutdownTest, BatteryST_012, TestSize.Level1)
111 {
112 HDF_LOGD("%{public}s: BatteryST_012 start.", __func__);
113 ChargerThread ct;
114 int32_t chargestate = PowerSupplyProvider::CHARGE_STATE_ENABLE;
115 ChargerThreadInitTest(ct);
116 SetChargeStateTest(chargestate, ct);
117
118 chargestate = PowerSupplyProvider::CHARGE_STATE_NONE;
119 SetChargeStateTest(chargestate, ct);
120 HandleChargingStateTest(ct);
121 bool screenOn = GetBacklightTest(ct)->GetScreenState();
122 HDF_LOGD("%{public}s: screenOn=%{public}d", __func__, screenOn);
123 ASSERT_TRUE(screenOn);
124
125 sleep(2);
126 if (false) {
127 HandleChargingStateTest(ct); // shutdown
128 }
129 HDF_LOGD("%{public}s: BatteryST_012 end.", __func__);
130 }
131 }
132