• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #ifndef BATTERY_THREAD_TEST_H
17 #define BATTERY_THREAD_TEST_H
18 
19 #include "battery_thread.h"
20 #include "charger_thread.h"
21 
22 namespace OHOS {
23 namespace HDI {
24 namespace Battery {
25 namespace V1_0 {
26 namespace {
27     struct BatteryThreadUnitTest {};
28     struct BatteryConfigUnitTest {};
29     struct ChargerThreadUnitTest {};
30 }
31 
32 int32_t OpenUeventSocketTest(BatteryThread& bthread);
33 void UpdateEpollIntervalTest(const int32_t chargeState, BatteryThread& bthread);
34 int GetEpollIntervalTest(BatteryThread& bthread);
35 int32_t InitTest(void* service, BatteryThread& bthread);
36 int32_t GetEpollFdTest(BatteryThread& bthread);
37 int32_t InitTimerTest(BatteryThread& bthread);
38 void SetTimerFdTest(const int32_t fd, BatteryThread& bthread);
39 int32_t GetTimerFdTest(BatteryThread& bthread);
40 void SetTimerIntervalTest(const int interval, BatteryThread& bthread);
41 int32_t GetTimerIntervalTest(BatteryThread& bthread);
42 int32_t InitUeventTest(BatteryThread& bthread);
43 int32_t GetUeventFdTest(BatteryThread& bthread);
44 int32_t ParseConfigTest(const std::string filename, BatteryConfig& bconfig);
45 void ChargerThreadInitTest(ChargerThread& cthread);
46 void CycleMattersTest(ChargerThread& cthread);
47 bool GetBatteryInfoTest(ChargerThread& cthread);
48 void SetChargeStateTest(const int32_t state, ChargerThread& cthread);
49 int32_t GetChargeStateTest(ChargerThread& cthread);
50 void HandleCapacityTest(const int32_t& capacity, ChargerThread& cthread);
51 void ChargerThreadHandleTemperatureTest(const int32_t& temperature, ChargerThread& cthread);
52 
53 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
54 class OpenUeventSocketImplement {
OpenUeventSocketTest(BatteryThread & bthread)55     friend int32_t OpenUeventSocketTest(BatteryThread& bthread)
56     {
57         return (bthread.*privateFun)();
58     }
59 };
60 
61 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
62 class UpdateEpollIntervalImplement {
UpdateEpollIntervalTest(const int32_t chargeState,BatteryThread & bthread)63     friend void UpdateEpollIntervalTest(const int32_t chargeState, BatteryThread& bthread)
64     {
65         (bthread.*privateFun)(chargeState);
66     }
67 };
68 
69 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
70 class GetEpollIntervalImplement {
GetEpollIntervalTest(BatteryThread & bthread)71     friend int GetEpollIntervalTest(BatteryThread& bthread)
72     {
73         return (bthread.*privateFun);
74     }
75 };
76 
77 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
78 class InitImplement {
InitTest(void * service,BatteryThread & bthread)79     friend int32_t InitTest(void* service, BatteryThread& bthread)
80     {
81         return (bthread.*privateFun)(service);
82     }
83 };
84 
85 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
86 class GetEpollFdImplement {
GetEpollFdTest(BatteryThread & bthread)87     friend int32_t GetEpollFdTest(BatteryThread& bthread)
88     {
89         return (bthread.*privateFun);
90     }
91 };
92 
93 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
94 class InitTimerImplement {
InitTimerTest(BatteryThread & bthread)95     friend int32_t InitTimerTest(BatteryThread& bthread)
96     {
97         return (bthread.*privateFun)();
98     }
99 };
100 
101 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
102 class GetTimerFdImplement {
GetTimerFdTest(BatteryThread & bthread)103     friend int32_t GetTimerFdTest(BatteryThread& bthread)
104     {
105         return (bthread.*privateFun);
106     }
107 };
108 
109 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
110 class SetTimerFdImplement {
SetTimerFdTest(const int32_t fd,BatteryThread & bthread)111     friend void SetTimerFdTest(const int32_t fd, BatteryThread& bthread)
112     {
113         (bthread.*privateFun) = fd;
114     }
115 };
116 
117 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
118 class GetTimerIntervalImplement {
GetTimerIntervalTest(BatteryThread & bthread)119     friend int32_t GetTimerIntervalTest(BatteryThread& bthread)
120     {
121         return (bthread.*privateFun);
122     }
123 };
124 
125 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
126 class SetTimerIntervalImplement {
SetTimerIntervalTest(const int interval,BatteryThread & bthread)127     friend void SetTimerIntervalTest(const int interval, BatteryThread& bthread)
128     {
129         (bthread.*privateFun) = interval;
130     }
131 };
132 
133 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
134 class InitUeventImplement {
InitUeventTest(BatteryThread & bthread)135     friend int32_t InitUeventTest(BatteryThread& bthread)
136     {
137         return (bthread.*privateFun)();
138     }
139 };
140 
141 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
142 class ChargerThreadInitImplement {
ChargerThreadInitTest(ChargerThread & cthread)143     friend void ChargerThreadInitTest(ChargerThread& cthread)
144     {
145         (cthread.*privateFun)();
146     }
147 };
148 
149 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
150 class GetUeventFdImplement {
GetUeventFdTest(BatteryThread & bthread)151     friend int32_t GetUeventFdTest(BatteryThread& bthread)
152     {
153         return (bthread.*privateFun);
154     }
155 };
156 
157 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
158 class ParseConfigImplement {
ParseConfigTest(const std::string filename,BatteryConfig & bconfig)159     friend int32_t ParseConfigTest(const std::string filename, BatteryConfig& bconfig)
160     {
161         return (bconfig.*privateFun)(filename);
162     }
163 };
164 
165 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
166 class CycleMattersImplement {
CycleMattersTest(ChargerThread & cthread)167     friend void CycleMattersTest(ChargerThread& cthread)
168     {
169         (cthread.*privateFun)();
170     }
171 };
172 
173 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
174 class GetBatteryInfoImplement {
GetBatteryInfoTest(ChargerThread & cthread)175     friend bool GetBatteryInfoTest(ChargerThread& cthread)
176     {
177         return (cthread.*privateFun);
178     }
179 };
180 
181 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
182 class HandleCapacityImplement {
HandleCapacityTest(const int32_t & capacity,ChargerThread & cthread)183     friend void HandleCapacityTest(const int32_t& capacity, ChargerThread& cthread)
184     {
185         (cthread.*privateFun)(capacity);
186     }
187 };
188 
189 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
190 class GetChargeStateImplement {
GetChargeStateTest(ChargerThread & cthread)191     friend int32_t GetChargeStateTest(ChargerThread& cthread)
192     {
193         return (cthread.*privateFun);
194     }
195 };
196 
197 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
198 class SetChargeStateImplement {
SetChargeStateTest(const int32_t state,ChargerThread & cthread)199     friend void SetChargeStateTest(const int32_t state, ChargerThread& cthread)
200     {
201         (cthread.*privateFun) = state;
202     }
203 };
204 
205 template<typename Tag, typename PrivateFun, PrivateFun privateFun>
206 class ChargerThreadHandleTemperatureImplement {
ChargerThreadHandleTemperatureTest(const int32_t & temperature,ChargerThread & cthread)207     friend void ChargerThreadHandleTemperatureTest(const int32_t& temperature, ChargerThread& cthread)
208     {
209         (cthread.*privateFun)(temperature);
210     }
211 };
212 
213 template class OpenUeventSocketImplement <
214     BatteryThreadUnitTest,
215     decltype(&BatteryThread::OpenUeventSocket),
216     &BatteryThread::OpenUeventSocket
217 >;
218 
219 template class UpdateEpollIntervalImplement <
220     BatteryThreadUnitTest,
221     decltype(&BatteryThread::UpdateEpollInterval),
222     &BatteryThread::UpdateEpollInterval
223 >;
224 
225 template class GetEpollIntervalImplement <
226     BatteryThreadUnitTest,
227     decltype(&BatteryThread::epollInterval_),
228     &BatteryThread::epollInterval_
229 >;
230 
231 template class InitImplement <
232     BatteryThreadUnitTest,
233     decltype(&BatteryThread::Init),
234     &BatteryThread::Init
235 >;
236 
237 template class GetEpollFdImplement <
238     BatteryThreadUnitTest,
239     decltype(&BatteryThread::epFd_),
240     &BatteryThread::epFd_
241 >;
242 
243 template class InitTimerImplement <
244     BatteryThreadUnitTest,
245     decltype(&BatteryThread::InitTimer),
246     &BatteryThread::InitTimer
247 >;
248 
249 template class GetTimerFdImplement <
250     BatteryThreadUnitTest,
251     decltype(&BatteryThread::timerFd_),
252     &BatteryThread::timerFd_
253 >;
254 
255 template class SetTimerFdImplement <
256     BatteryThreadUnitTest,
257     decltype(&BatteryThread::timerFd_),
258     &BatteryThread::timerFd_
259 >;
260 
261 template class GetTimerIntervalImplement <
262     BatteryThreadUnitTest,
263     decltype(&BatteryThread::timerInterval_),
264     &BatteryThread::timerInterval_
265 >;
266 
267 template class SetTimerIntervalImplement <
268     BatteryThreadUnitTest,
269     decltype(&BatteryThread::timerInterval_),
270     &BatteryThread::timerInterval_
271 >;
272 
273 template class InitUeventImplement <
274     BatteryThreadUnitTest,
275     decltype(&BatteryThread::InitUevent),
276     &BatteryThread::InitUevent
277 >;
278 
279 template class ChargerThreadInitImplement <
280     ChargerThreadUnitTest,
281     decltype(&ChargerThread::Init),
282     &ChargerThread::Init
283 >;
284 
285 template class CycleMattersImplement <
286     ChargerThreadUnitTest,
287     decltype(&ChargerThread::CycleMatters),
288     &ChargerThread::CycleMatters
289 >;
290 
291 template class GetUeventFdImplement <
292     BatteryThreadUnitTest,
293     decltype(&BatteryThread::ueventFd_),
294     &BatteryThread::ueventFd_
295 >;
296 
297 template class ParseConfigImplement <
298     BatteryConfigUnitTest,
299     decltype(&BatteryConfig::ParseConfig),
300     &BatteryConfig::ParseConfig
301 >;
302 
303 template class GetBatteryInfoImplement <
304     ChargerThreadUnitTest,
305     decltype(&ChargerThread::started_),
306     &ChargerThread::started_
307 >;
308 
309 template class HandleCapacityImplement <
310     ChargerThreadUnitTest,
311     decltype(&ChargerThread::HandleCapacity),
312     &ChargerThread::HandleCapacity
313 >;
314 
315 template class GetChargeStateImplement <
316     ChargerThreadUnitTest,
317     decltype(&ChargerThread::chargeState_),
318     &ChargerThread::chargeState_
319 >;
320 
321 template class SetChargeStateImplement <
322     ChargerThreadUnitTest,
323     decltype(&ChargerThread::chargeState_),
324     &ChargerThread::chargeState_
325 >;
326 
327 template class ChargerThreadHandleTemperatureImplement <
328     ChargerThreadUnitTest,
329     decltype(&ChargerThread::HandleTemperature),
330     &ChargerThread::HandleTemperature
331 >;
332 
333 class BatteryThreadTest {
334 public:
SetKeyState(int code,int value,int64_t now,ChargerThread & ct)335     void SetKeyState(int code, int value, int64_t now, ChargerThread& ct)
336     {
337         ct.SetKeyState(code, value, now);
338     }
339 
HandlePowerKey(int keycode,int64_t now,ChargerThread & ct)340     void HandlePowerKey(int keycode, int64_t now, ChargerThread& ct)
341     {
342         ct.HandlePowerKey(keycode, now);
343     }
344 
UpdateBatteryInfo(void * arg,ChargerThread & ct)345     void UpdateBatteryInfo(void* arg, ChargerThread& ct)
346     {
347         ct.UpdateBatteryInfo(arg);
348     }
349 
Init(ChargerThread & ct)350     void Init(ChargerThread& ct)
351     {
352         ct.Init();
353     }
354 };
355 } // namespace V1_0
356 } // namespace Battery
357 } // namespace HDI
358 } // namespace OHOS
359 #endif // BATTERY_THREAD_TEST_H
360