1 /*
2  * Copyright (c) 2022-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 #include <numeric>
18 #define private public
19 #include "common_event.h"
20 #include "common_event_manager.h"
21 #include "common_event_stub.h"
22 #include "common_event_subscriber_manager.h"
23 #include "inner_common_event_manager.h"
24 #undef private
25 
26 using namespace testing::ext;
27 using namespace OHOS;
28 using namespace OHOS::EventFwk;
29 using namespace OHOS::AppExecFwk;
30 
31 class InnerCommonEventManagerTest : public testing::Test {
32 public:
InnerCommonEventManagerTest()33     InnerCommonEventManagerTest()
34     {}
~InnerCommonEventManagerTest()35     ~InnerCommonEventManagerTest()
36     {}
37 
38     static void SetUpTestCase(void);
39     static void TearDownTestCase(void);
40     void SetUp();
41     void TearDown();
42 };
43 
44 class DreivedSubscriber : public CommonEventSubscriber {
45 public:
DreivedSubscriber(const CommonEventSubscribeInfo & sp)46     explicit DreivedSubscriber(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp)
47     {}
48 
~DreivedSubscriber()49     ~DreivedSubscriber()
50     {}
51 
OnReceiveEvent(const CommonEventData & data)52     virtual void OnReceiveEvent(const CommonEventData &data)
53     {}
54 };
55 
SetUpTestCase(void)56 void InnerCommonEventManagerTest::SetUpTestCase(void)
57 {}
58 
TearDownTestCase(void)59 void InnerCommonEventManagerTest::TearDownTestCase(void)
60 {}
61 
SetUp(void)62 void InnerCommonEventManagerTest::SetUp(void)
63 {}
64 
TearDown(void)65 void InnerCommonEventManagerTest::TearDown(void)
66 {}
67 
68 /**
69  * @tc.name: InnerCommonEventManager_0100
70  * @tc.desc: test UnsubscribeCommonEvent function and commonEventListener is nullptr.
71  * @tc.type: FUNC
72  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_0100,Level1)73 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_0100, Level1)
74 {
75     GTEST_LOG_(INFO) << "InnerCommonEventManager_0100 start";
76     InnerCommonEventManager innerCommonEventManager;
77     sptr<IRemoteObject> commonEventListener = nullptr;
78     EXPECT_EQ(false, innerCommonEventManager.UnsubscribeCommonEvent(commonEventListener));
79     GTEST_LOG_(INFO) << "InnerCommonEventManager_0100 end";
80 }
81 
82 /**
83  * @tc.name: InnerCommonEventManager_0200
84  * @tc.desc: test UnsubscribeCommonEvent function.
85  * @tc.type: FUNC
86  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_0200,Level1)87 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_0200, Level1)
88 {
89     GTEST_LOG_(INFO) << "InnerCommonEventManager_0200 start";
90     InnerCommonEventManager innerCommonEventManager;
91     // set commonEventListener
92     MatchingSkills matchingSkills_;
93     CommonEventSubscribeInfo subscribeInfo(matchingSkills_);
94     std::shared_ptr<DreivedSubscriber> subscriber = std::make_shared<DreivedSubscriber>(subscribeInfo);
95     sptr<IRemoteObject> commonEventListener = new CommonEventListener(subscriber);
96     // set controlPtr_ is nullptr
97     innerCommonEventManager.controlPtr_ = nullptr;
98     EXPECT_EQ(false, innerCommonEventManager.UnsubscribeCommonEvent(commonEventListener));
99     GTEST_LOG_(INFO) << "InnerCommonEventManager_0200 end";
100 }
101 
102 /**
103  * @tc.name: InnerCommonEventManager_0300
104  * @tc.desc: test DumpState function.
105  * @tc.type: FUNC
106  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_0300,Level1)107 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_0300, Level1)
108 {
109     GTEST_LOG_(INFO) << "InnerCommonEventManager_0300 start";
110     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
111     ASSERT_NE(nullptr, innerCommonEventManager);
112     uint8_t dumpType = DumpEventType::PENDING;
113     std::string event = "";
114     int32_t userId = 1;
115     std::vector<std::string> state;
116     // set controlPtr_ is nullptr
117     innerCommonEventManager->controlPtr_ = nullptr;
118     innerCommonEventManager->DumpState(dumpType, event, userId, state);
119     GTEST_LOG_(INFO) << "InnerCommonEventManager_0300 end";
120 }
121 
122 /**
123  * @tc.name: InnerCommonEventManager_0400
124  * @tc.desc: test DumpState function and controlPtr_ is not nullptr.
125  * @tc.type: FUNC
126  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_0400,Level1)127 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_0400, Level1)
128 {
129     GTEST_LOG_(INFO) << "InnerCommonEventManager_0400 start";
130     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
131     ASSERT_NE(nullptr, innerCommonEventManager);
132     uint8_t dumpType = DumpEventType::PENDING;
133     std::string event = "";
134     int32_t userId = 1;
135     std::vector<std::string> state;
136     innerCommonEventManager->DumpState(dumpType, event, userId, state);
137     GTEST_LOG_(INFO) << "InnerCommonEventManager_0400 end";
138 }
139 
140 /**
141  * @tc.name: InnerCommonEventManager_0500
142  * @tc.desc: test DumpState function and controlPtr_ is not nullptr.
143  * @tc.type: FUNC
144  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_0500,Level1)145 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_0500, Level1)
146 {
147     GTEST_LOG_(INFO) << "InnerCommonEventManager_0500 start";
148     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
149     ASSERT_NE(nullptr, innerCommonEventManager);
150     uint8_t dumpType = DumpEventType::HISTORY;
151     std::string event = "";
152     int32_t userId = 1;
153     std::vector<std::string> state;
154     innerCommonEventManager->DumpState(dumpType, event, userId, state);
155     GTEST_LOG_(INFO) << "InnerCommonEventManager_0500 end";
156 }
157 
158 /**
159  * @tc.name: InnerCommonEventManager_0600
160  * @tc.desc: test DumpState function.
161  * @tc.type: FUNC
162  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_0600,Level1)163 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_0600, Level1)
164 {
165     GTEST_LOG_(INFO) << "InnerCommonEventManager_0600 start";
166     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
167     ASSERT_NE(nullptr, innerCommonEventManager);
168     uint8_t dumpType = DumpEventType::HISTORY;
169     std::string event = "";
170     int32_t userId = 1;
171     std::vector<std::string> state;
172     // set controlPtr_ is nullptr
173     innerCommonEventManager->controlPtr_ = nullptr;
174     innerCommonEventManager->DumpState(dumpType, event, userId, state);
175     GTEST_LOG_(INFO) << "InnerCommonEventManager_0600 end";
176 }
177 
178 /**
179  * @tc.name: InnerCommonEventManager_0700
180  * @tc.desc: test DumpState function and dumpType is default.
181  * @tc.type: FUNC
182  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_0700,Level1)183 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_0700, Level1)
184 {
185     GTEST_LOG_(INFO) << "InnerCommonEventManager_0700 start";
186     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
187     ASSERT_NE(nullptr, innerCommonEventManager);
188     uint8_t dumpType = 100;
189     std::string event = "";
190     int32_t userId = 1;
191     std::vector<std::string> state;
192     // set controlPtr_ is nullptr
193     innerCommonEventManager->controlPtr_ = nullptr;
194     innerCommonEventManager->DumpState(dumpType, event, userId, state);
195     GTEST_LOG_(INFO) << "InnerCommonEventManager_0700 end";
196 }
197 
198 /**
199  * @tc.name: InnerCommonEventManager_0800
200  * @tc.desc: test DumpState function and dumpType is default controlPtr_ is not nullptr.
201  * @tc.type: FUNC
202  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_0800,Level1)203 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_0800, Level1)
204 {
205     GTEST_LOG_(INFO) << "InnerCommonEventManager_0800 start";
206     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
207     ASSERT_NE(nullptr, innerCommonEventManager);
208     uint8_t dumpType = 100;
209     std::string event = "";
210     int32_t userId = 1;
211     std::vector<std::string> state;
212     innerCommonEventManager->DumpState(dumpType, event, userId, state);
213     GTEST_LOG_(INFO) << "InnerCommonEventManager_0800 end";
214 }
215 
216 /**
217  * @tc.name: InnerCommonEventManager_0900
218  * @tc.desc: test FinishReceiver function.
219  * @tc.type: FUNC
220  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_0900,Level1)221 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_0900, Level1)
222 {
223     GTEST_LOG_(INFO) << "InnerCommonEventManager_0900 start";
224     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
225     ASSERT_NE(nullptr, innerCommonEventManager);
226     sptr<IRemoteObject> proxy = nullptr;
227     int32_t code = 1;
228     std::string receiverData = "";
229     bool abortEvent = true;
230     // set controlPtr_ is nullptr
231     innerCommonEventManager->controlPtr_ = nullptr;
232     innerCommonEventManager->FinishReceiver(proxy, code, receiverData, abortEvent);
233     GTEST_LOG_(INFO) << "InnerCommonEventManager_0900 end";
234 }
235 
236 /**
237  * @tc.name: InnerCommonEventManager_1000
238  * @tc.desc: test Unfreeze function.
239  * @tc.type: FUNC
240  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_1000,Level1)241 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_1000, Level1)
242 {
243     GTEST_LOG_(INFO) << "InnerCommonEventManager_1000 start";
244     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
245     ASSERT_NE(nullptr, innerCommonEventManager);
246     uid_t uid = 1;
247     // set controlPtr_ is nullptr
248     innerCommonEventManager->controlPtr_ = nullptr;
249     innerCommonEventManager->Unfreeze(uid);
250     GTEST_LOG_(INFO) << "InnerCommonEventManager_1000 end";
251 }
252 
253 /**
254  * @tc.name: InnerCommonEventManager_1100
255  * @tc.desc: test UnfreezeAll function.
256  * @tc.type: FUNC
257  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_1100,Level1)258 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_1100, Level1)
259 {
260     GTEST_LOG_(INFO) << "InnerCommonEventManager_1100 start";
261     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
262     ASSERT_NE(nullptr, innerCommonEventManager);
263     // set controlPtr_ is nullptr
264     innerCommonEventManager->controlPtr_ = nullptr;
265     innerCommonEventManager->UnfreezeAll();
266     GTEST_LOG_(INFO) << "InnerCommonEventManager_1100 end";
267 }
268 
269 /**
270  * @tc.name: InnerCommonEventManager_1200
271  * @tc.desc: test PublishStickyEvent function.
272  * @tc.type: FUNC
273  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_1200,Level1)274 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_1200, Level1)
275 {
276     GTEST_LOG_(INFO) << "InnerCommonEventManager_1200 start";
277     InnerCommonEventManager innerCommonEventManager;
278     std::shared_ptr<CommonEventSubscribeInfo> sp = nullptr;
279     std::shared_ptr<EventSubscriberRecord> subscriberRecord = nullptr;
280     EXPECT_EQ(false, innerCommonEventManager.PublishStickyEvent(sp, subscriberRecord));
281     GTEST_LOG_(INFO) << "InnerCommonEventManager_1200 end";
282 }
283 
284 /**
285  * @tc.name: InnerCommonEventManager_1300
286  * @tc.desc: test PublishStickyEvent function.
287  * @tc.type: FUNC
288  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_1300,Level1)289 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_1300, Level1)
290 {
291     GTEST_LOG_(INFO) << "InnerCommonEventManager_1300 start";
292     InnerCommonEventManager innerCommonEventManager;
293     MatchingSkills matchingSkills_;
294     std::shared_ptr<CommonEventSubscribeInfo> sp = std::make_shared<CommonEventSubscribeInfo>(matchingSkills_);
295     std::shared_ptr<EventSubscriberRecord> subscriberRecord = nullptr;
296     EXPECT_EQ(false, innerCommonEventManager.PublishStickyEvent(sp, subscriberRecord));
297     GTEST_LOG_(INFO) << "InnerCommonEventManager_1300 end";
298 }
299 
300 /**
301  * @tc.name: InnerCommonEventManager_1400
302  * @tc.desc: test HiDump function.
303  * @tc.type: FUNC
304  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_1400,Level1)305 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_1400, Level1)
306 {
307     GTEST_LOG_(INFO) << "InnerCommonEventManager_1400 start";
308     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
309     ASSERT_NE(nullptr, innerCommonEventManager);
310     std::vector<std::u16string> args;
311     std::string result = "";
312     innerCommonEventManager->HiDump(args, result);
313     GTEST_LOG_(INFO) << "InnerCommonEventManager_1400 end";
314 }
315 
316 /**
317  * @tc.name: InnerCommonEventManager_1500
318  * @tc.desc: test HiDump function.
319  * @tc.type: FUNC
320  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_1500,Level1)321 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_1500, Level1)
322 {
323     GTEST_LOG_(INFO) << "InnerCommonEventManager_1500 start";
324     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
325     ASSERT_NE(nullptr, innerCommonEventManager);
326     std::u16string aa = u"aa";
327     std::u16string bb = u"bb";
328     std::u16string cc = u"cc";
329     std::vector<std::u16string> args;
330     args.emplace_back(aa);
331     args.emplace_back(bb);
332     args.emplace_back(cc);
333     std::string result = "";
334     innerCommonEventManager->HiDump(args, result);
335     GTEST_LOG_(INFO) << "InnerCommonEventManager_1500 end";
336 }
337 
338 /**
339  * @tc.name: InnerCommonEventManager_1600
340  * @tc.desc: test HiDump function.
341  * @tc.type: FUNC
342  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_1600,Level1)343 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_1600, Level1)
344 {
345     GTEST_LOG_(INFO) << "InnerCommonEventManager_1600 start";
346     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
347     ASSERT_NE(nullptr, innerCommonEventManager);
348     std::u16string aa = u"aa";
349     std::vector<std::u16string> args;
350     args.emplace_back(aa);
351     std::string result = "";
352     innerCommonEventManager->HiDump(args, result);
353     GTEST_LOG_(INFO) << "InnerCommonEventManager_1600 end";
354 }
355 
356 /**
357  * @tc.name: InnerCommonEventManager_1700
358  * @tc.desc: test HiDump function.
359  * @tc.type: FUNC
360  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_1700,Level1)361 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_1700, Level1)
362 {
363     GTEST_LOG_(INFO) << "InnerCommonEventManager_1700 start";
364     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
365     ASSERT_NE(nullptr, innerCommonEventManager);
366     std::u16string aa = u"-h";
367     std::vector<std::u16string> args;
368     args.emplace_back(aa);
369     std::string result = "";
370     innerCommonEventManager->HiDump(args, result);
371     GTEST_LOG_(INFO) << "InnerCommonEventManager_1700 end";
372 }
373 
374 /**
375  * @tc.name: InnerCommonEventManager_1800
376  * @tc.desc: test HiDump function.
377  * @tc.type: FUNC
378  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_1800,Level1)379 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_1800, Level1)
380 {
381     GTEST_LOG_(INFO) << "InnerCommonEventManager_1800 start";
382     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
383     ASSERT_NE(nullptr, innerCommonEventManager);
384     std::u16string aa = u"-h";
385     std::u16string bb = u"-a";
386     std::vector<std::u16string> args;
387     args.emplace_back(aa);
388     args.emplace_back(bb);
389     std::string result = "";
390     innerCommonEventManager->HiDump(args, result);
391     GTEST_LOG_(INFO) << "InnerCommonEventManager_1800 end";
392 }
393 
394 /**
395  * @tc.name: InnerCommonEventManager_1900
396  * @tc.desc: test HiDump function.
397  * @tc.type: FUNC
398  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_1900,Level1)399 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_1900, Level1)
400 {
401     GTEST_LOG_(INFO) << "InnerCommonEventManager_1900 start";
402     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
403     ASSERT_NE(nullptr, innerCommonEventManager);
404     std::u16string aa = u"-a";
405     std::vector<std::u16string> args;
406     args.emplace_back(aa);
407     std::string result = "";
408     innerCommonEventManager->HiDump(args, result);
409     GTEST_LOG_(INFO) << "InnerCommonEventManager_1900 end";
410 }
411 
412 /**
413  * @tc.name: InnerCommonEventManager_2000
414  * @tc.desc: test HiDump function.
415  * @tc.type: FUNC
416  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_2000,Level1)417 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_2000, Level1)
418 {
419     GTEST_LOG_(INFO) << "InnerCommonEventManager_2000 start";
420     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
421     ASSERT_NE(nullptr, innerCommonEventManager);
422     std::u16string aa = u"-e";
423     std::vector<std::u16string> args;
424     args.emplace_back(aa);
425     std::string result = "";
426     innerCommonEventManager->HiDump(args, result);
427     GTEST_LOG_(INFO) << "InnerCommonEventManager_2000 end";
428 }
429 
430 /**
431  * @tc.name: InnerCommonEventManager_2100
432  * @tc.desc: test HiDump function.
433  * @tc.type: FUNC
434  */
HWTEST_F(InnerCommonEventManagerTest,InnerCommonEventManager_2100,Level1)435 HWTEST_F(InnerCommonEventManagerTest, InnerCommonEventManager_2100, Level1)
436 {
437     GTEST_LOG_(INFO) << "InnerCommonEventManager_2100 start";
438     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
439     ASSERT_NE(nullptr, innerCommonEventManager);
440     std::u16string aa = u"-e";
441     std::u16string bb = u"-a";
442     std::vector<std::u16string> args;
443     args.emplace_back(aa);
444     args.emplace_back(bb);
445     std::string result = "";
446     innerCommonEventManager->HiDump(args, result);
447     GTEST_LOG_(INFO) << "InnerCommonEventManager_2100 end";
448 }
449 
450 /**
451  * @tc.name: SetStaticSubscriberStateWithTwoParameters_0100
452  * @tc.desc: Failed to call SetStaticSubscriberState API to obtain commonEventproxy.
453  * @tc.type: FUNC
454  */
HWTEST_F(InnerCommonEventManagerTest,SetStaticSubscriberStateWithTwoParameters_0100,Level1)455 HWTEST_F(InnerCommonEventManagerTest, SetStaticSubscriberStateWithTwoParameters_0100, Level1)
456 {
457     auto innerCommonEventManager = std::make_shared<InnerCommonEventManager>();
458     ASSERT_NE(nullptr, innerCommonEventManager);
459     innerCommonEventManager->staticSubscriberManager_ = nullptr;
460     std::vector<std::string> events;
461     events.push_back("StaticCommonEventA");
462     const int32_t ERR_NOTIFICATION_CESM_ERROR = 1500008;
463     int32_t result = innerCommonEventManager->SetStaticSubscriberState(events, true);
464     EXPECT_EQ(result, ERR_NOTIFICATION_CESM_ERROR);
465 }
466