1 /*
2  * Copyright (c) 2023-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 #include <iostream>
16 #include <unistd.h>
17 
18 #include <gtest/gtest.h>
19 
20 #include "app_event_processor_mgr.h"
21 #include "app_event_observer_mgr.h"
22 #include "hiappevent_base.h"
23 #include "hiappevent_config.h"
24 
25 using namespace testing::ext;
26 using namespace OHOS::HiviewDFX;
27 using namespace OHOS::HiviewDFX::ErrorCode;
28 using namespace OHOS::HiviewDFX::HiAppEvent;
29 namespace {
30 const std::string TEST_PROCESSOR_NAME = "test_processor";
31 const std::string TEST_EVENT_DOMAIN = "test_domain";
32 const std::string TEST_EVENT_NAME = "test_name";
33 constexpr int TEST_EVENT_TYPE = 1;
34 constexpr int32_t TEST_UID = 200000 * 100;
35 
WriteEventOnce()36 void WriteEventOnce()
37 {
38     auto event = std::make_shared<AppEventPack>(TEST_EVENT_DOMAIN, TEST_EVENT_NAME, TEST_EVENT_TYPE);
39     constexpr int testInt = 1;
40     event->AddParam("int_key", testInt);
41     constexpr double testDou = 1.2;
42     event->AddParam("double_key", testDou);
43     constexpr bool testBool = false;
44     event->AddParam("bool_key", testBool);
45     const std::string testStr = "str";
46     event->AddParam("str_key", testStr);
47     std::vector<std::shared_ptr<AppEventPack>> events;
48     events.emplace_back(event);
49     AppEventObserverMgr::GetInstance().HandleEvents(events);
50     sleep(1); // 1s
51 }
52 
CheckRegisterObserver(const std::string & observer,std::shared_ptr<AppEventProcessor> processor,int64_t & processorSeq)53 void CheckRegisterObserver(const std::string& observer,
54     std::shared_ptr<AppEventProcessor> processor, int64_t& processorSeq)
55 {
56     ASSERT_EQ(AppEventProcessorMgr::RegisterProcessor(observer, processor), 0);
57     processorSeq = AppEventObserverMgr::GetInstance().RegisterObserver(observer);
58     ASSERT_GT(processorSeq, 0);
59 }
60 
CheckRegisterObserverWithConfig(const std::string & observer,std::shared_ptr<AppEventProcessor> processor,const ReportConfig & config,int64_t & processorSeq)61 void CheckRegisterObserverWithConfig(
62     const std::string& observer,
63     std::shared_ptr<AppEventProcessor> processor,
64     const ReportConfig& config,
65     int64_t& processorSeq)
66 {
67     ASSERT_EQ(AppEventProcessorMgr::RegisterProcessor(observer, processor), 0);
68     processorSeq = AppEventObserverMgr::GetInstance().RegisterObserver(observer, config);
69     ASSERT_GT(processorSeq, 0);
70 }
71 
CheckUnregisterObserver(const std::string & observer)72 void CheckUnregisterObserver(const std::string& observer)
73 {
74     ASSERT_EQ(AppEventProcessorMgr::UnregisterProcessor(observer), 0);
75 }
76 
CheckGetEmptyConfig(int64_t processorSeq)77 void CheckGetEmptyConfig(int64_t processorSeq)
78 {
79     ReportConfig config;
80     ASSERT_EQ(AppEventProcessorMgr::GetProcessorConfig(processorSeq, config), 0);
81     ASSERT_TRUE(config.name.empty());
82     ASSERT_FALSE(config.debugMode);
83     ASSERT_TRUE(config.routeInfo.empty());
84     ASSERT_TRUE(config.appId.empty());
85     ASSERT_EQ(config.triggerCond.row, 0);
86     ASSERT_EQ(config.triggerCond.size, 0);
87     ASSERT_EQ(config.triggerCond.timeout, 0);
88     ASSERT_FALSE(config.triggerCond.onStartup);
89     ASSERT_FALSE(config.triggerCond.onBackground);
90     ASSERT_TRUE(config.userIdNames.empty());
91     ASSERT_TRUE(config.userPropertyNames.empty());
92     ASSERT_TRUE(config.eventConfigs.empty());
93     ASSERT_EQ(config.configId, 0);
94     ASSERT_TRUE(config.customConfigs.empty());
95 }
96 
CheckGetSeqs(const std::string & observer,const std::vector<int64_t> & expectSeqs)97 void CheckGetSeqs(const std::string& observer, const std::vector<int64_t>& expectSeqs)
98 {
99     std::vector<int64_t> processorSeqs;
100     ASSERT_EQ(AppEventProcessorMgr::GetProcessorSeqs(observer, processorSeqs), 0);
101     ASSERT_EQ(processorSeqs.size(), expectSeqs.size());
102 
103     // test repeated getting seqs
104     ASSERT_EQ(AppEventProcessorMgr::GetProcessorSeqs(observer, processorSeqs), 0);
105     ASSERT_EQ(processorSeqs.size(), expectSeqs.size());
106 }
107 
CheckSameConfig(const ReportConfig & configA,const ReportConfig & configB)108 void CheckSameConfig(const ReportConfig& configA, const ReportConfig& configB)
109 {
110     ASSERT_EQ(configA.name, configB.name);
111     ASSERT_EQ(configA.debugMode, configB.debugMode);
112     ASSERT_EQ(configA.routeInfo, configB.routeInfo);
113     ASSERT_EQ(configA.appId, configB.appId);
114     ASSERT_EQ(configA.triggerCond.row, configB.triggerCond.row);
115     ASSERT_EQ(configA.triggerCond.size, configB.triggerCond.size);
116     ASSERT_EQ(configA.triggerCond.timeout, configB.triggerCond.timeout);
117     ASSERT_EQ(configA.triggerCond.onStartup, configB.triggerCond.onStartup);
118     ASSERT_EQ(configA.triggerCond.onBackground, configB.triggerCond.onBackground);
119     ASSERT_EQ(configA.userIdNames.size(), configB.userIdNames.size());
120     ASSERT_EQ(configA.userPropertyNames.size(), configB.userPropertyNames.size());
121     ASSERT_EQ(configA.eventConfigs.size(), configB.eventConfigs.size());
122     ASSERT_EQ(configA.configId, configB.configId);
123     ASSERT_EQ(configA.customConfigs.size(), configB.customConfigs.size());
124 }
125 
CheckSameConfig(int64_t processorSeq,const ReportConfig & testConfig)126 void CheckSameConfig(int64_t processorSeq, const ReportConfig& testConfig)
127 {
128     ReportConfig getConfig;
129     ASSERT_EQ(AppEventProcessorMgr::GetProcessorConfig(processorSeq, getConfig), 0);
130     CheckSameConfig(testConfig, getConfig);
131 }
132 
CheckSetConfig(int64_t processorSeq)133 void CheckSetConfig(int64_t processorSeq)
134 {
135     ReportConfig testConfig = {
136         .name = "test_name",
137         .debugMode = true,
138         .routeInfo = "test_routeInfo",
139         .appId = "test_appid",
140         .triggerCond = {1, 1, 1, true, true},
141         .userIdNames = {"test_id"},
142         .userPropertyNames = {"test_property"},
143         .eventConfigs = {{"test_domain", "test_name", true}},
144         .configId = 1,
145         .customConfigs = {{"str_key", "str_value"}},
146     };
147     ASSERT_EQ(AppEventProcessorMgr::SetProcessorConfig(processorSeq, testConfig), 0);
148     ReportConfig getConfig;
149     ASSERT_EQ(AppEventProcessorMgr::GetProcessorConfig(processorSeq, getConfig), 0);
150     CheckSameConfig(testConfig, getConfig);
151 }
152 
CheckSetRealTimeConfig(int64_t processorSeq)153 void CheckSetRealTimeConfig(int64_t processorSeq)
154 {
155     ReportConfig testConfig = {
156         .eventConfigs = {{TEST_EVENT_DOMAIN, TEST_EVENT_NAME, true}},
157     };
158     ASSERT_EQ(AppEventProcessorMgr::SetProcessorConfig(processorSeq, testConfig), 0);
159 }
160 
CheckSetRowConfig(int64_t processorSeq)161 void CheckSetRowConfig(int64_t processorSeq)
162 {
163     ReportConfig testConfig = {
164         .triggerCond = {
165             .row = 2, // 2 events
166         },
167         .eventConfigs = {{TEST_EVENT_DOMAIN, TEST_EVENT_NAME}},
168     };
169     ASSERT_EQ(AppEventProcessorMgr::SetProcessorConfig(processorSeq, testConfig), 0);
170 }
171 
CheckSetSizeConfig(int64_t processorSeq)172 void CheckSetSizeConfig(int64_t processorSeq)
173 {
174     ReportConfig testConfig = {
175         .triggerCond = {
176             .size = 300, // 300 byte, 2 events
177         },
178         .eventConfigs = {{TEST_EVENT_DOMAIN, TEST_EVENT_NAME}},
179     };
180     ASSERT_EQ(AppEventProcessorMgr::SetProcessorConfig(processorSeq, testConfig), 0);
181 }
182 
CheckSetTimeoutConfig(int64_t processorSeq)183 void CheckSetTimeoutConfig(int64_t processorSeq)
184 {
185     ReportConfig testConfig = {
186         .triggerCond = {
187             .timeout = 2, // 2s
188         },
189         .eventConfigs = {{TEST_EVENT_DOMAIN, TEST_EVENT_NAME}},
190     };
191     ASSERT_EQ(AppEventProcessorMgr::SetProcessorConfig(processorSeq, testConfig), 0);
192 }
193 
CheckSetOnBackgroundConfig(int64_t processorSeq)194 void CheckSetOnBackgroundConfig(int64_t processorSeq)
195 {
196     ReportConfig testConfig = {
197         .triggerCond = {
198             .onBackground = true,
199         },
200         .eventConfigs = {{TEST_EVENT_DOMAIN, TEST_EVENT_NAME}},
201     };
202     ASSERT_EQ(AppEventProcessorMgr::SetProcessorConfig(processorSeq, testConfig), 0);
203 }
204 
CheckOnReport(const std::vector<UserId> & userIds,const std::vector<UserProperty> & userProperties,const std::vector<AppEventInfo> & events)205 void CheckOnReport(
206     const std::vector<UserId>& userIds,
207     const std::vector<UserProperty>& userProperties,
208     const std::vector<AppEventInfo>& events)
209 {
210     ASSERT_EQ(userIds.size(), 0);
211     ASSERT_EQ(userProperties.size(), 0);
212     ASSERT_GT(events.size(), 0);
213     for (const auto& event : events) {
214         ASSERT_EQ(event.domain, TEST_EVENT_DOMAIN);
215         ASSERT_EQ(event.name, TEST_EVENT_NAME);
216         ASSERT_EQ(event.eventType, TEST_EVENT_TYPE);
217         ASSERT_GT(event.timestamp, 0);
218         ASSERT_EQ(event.params, "{\"int_key\":1,\"double_key\":1.2,\"bool_key\":false,\"str_key\":\"str\"}\n");
219     }
220 }
221 }
222 
223 class HiAppEventInnerApiTest : public testing::Test {
224 public:
SetUp()225     void SetUp()
226     {
227         // set app uid
228         setuid(TEST_UID);
229         HiAppEventConfig::GetInstance().SetStorageDir("/data/test/hiappevent/");
230     }
231 
TearDown()232     void TearDown() {}
233 };
234 
235 class AppEventProcessorTest : public AppEventProcessor {
236 public:
237     int OnReport(
238         int64_t processorSeq,
239         const std::vector<UserId>& userIds,
240         const std::vector<UserProperty>& userProperties,
241         const std::vector<AppEventInfo>& events) override;
242     int ValidateUserId(const UserId& userId) override;
243     int ValidateUserProperty(const UserProperty& userProperty) override;
244     int ValidateEvent(const AppEventInfo& event) override;
GetReportTimes()245     int GetReportTimes() { return reportTimes_; }
246 
247 private:
248     int reportTimes_ = 0;
249 };
250 
OnReport(int64_t processorSeq,const std::vector<UserId> & userIds,const std::vector<UserProperty> & userProperties,const std::vector<AppEventInfo> & events)251 int AppEventProcessorTest::OnReport(
252     int64_t processorSeq,
253     const std::vector<UserId>& userIds,
254     const std::vector<UserProperty>& userProperties,
255     const std::vector<AppEventInfo>& events)
256 {
257     reportTimes_++;
258 
259     std::cout << "UserId size=" << userIds.size() << std::endl;
260     std::cout << "UserProperty size=" << userProperties.size() << std::endl;
261     std::cout << "AppEventInfo size=" << events.size() << std::endl;
262     for (const auto& event : events) {
263         std::cout << "AppEventInfo.domain=" << event.domain << std::endl;
264         std::cout << "AppEventInfo.name=" << event.name << std::endl;
265         std::cout << "AppEventInfo.eventType=" << event.eventType << std::endl;
266         std::cout << "AppEventInfo.timestamp=" << event.timestamp << std::endl;
267         std::cout << "AppEventInfo.params=" << event.params << std::endl;
268     }
269     CheckOnReport(userIds, userProperties, events);
270     return 0;
271 }
272 
ValidateUserId(const UserId & userId)273 int AppEventProcessorTest::ValidateUserId(const UserId& userId)
274 {
275     return (userId.name.find("test") == std::string::npos) ? -1 : 0;
276 }
277 
ValidateUserProperty(const UserProperty & userProperty)278 int AppEventProcessorTest::ValidateUserProperty(const UserProperty& userProperty)
279 {
280     return (userProperty.name.find("test") == std::string::npos) ? -1 : 0;
281 }
282 
ValidateEvent(const AppEventInfo & event)283 int AppEventProcessorTest::ValidateEvent(const AppEventInfo& event)
284 {
285     return (event.domain.find("test") == std::string::npos) ? -1 : 0;
286 }
287 
288 /**
289  * @tc.name: HiAppEventInnerApiTest001
290  * @tc.desc: check the api AppEventProcessorMgr.
291  * @tc.type: FUNC
292  */
293 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest001, TestSize.Level0)
294 {
295     /**
296      * @tc.steps: step1. Create an AppEventProcessor object.
297      * @tc.steps: step2. Register the AppEventProcessor object.
298      * @tc.steps: step3. Get processor sequence by name.
299      * @tc.steps: step4. Get processor config by sequence.
300      * @tc.steps: step5. Set processor config by sequence.
301      * @tc.steps: step6. Unregister the AppEventProcessor object.
302      */
303     auto processor = std::make_shared<AppEventProcessorTest>();
304     int64_t processorSeq = 0;
305     CheckRegisterObserver(TEST_PROCESSOR_NAME, processor, processorSeq);
306     CheckGetSeqs(TEST_PROCESSOR_NAME, {processorSeq});
307     CheckGetEmptyConfig(processorSeq);
308     CheckSetConfig(processorSeq);
309     WriteEventOnce();
310     CheckUnregisterObserver(TEST_PROCESSOR_NAME);
311 }
312 
313 /**
314  * @tc.name: HiAppEventInnerApiTest002
315  * @tc.desc: check the api AppEventProcessorMgr.
316  * @tc.type: FUNC
317  */
318 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest002, TestSize.Level0)
319 {
320     /**
321      * @tc.steps: step1. Create an AppEventProcessor object.
322      * @tc.steps: step2. Register the AppEventProcessor object.
323      * @tc.steps: step3. Register the same AppEventProcessor object.
324      * @tc.steps: step4. Unregister the AppEventProcessor object.
325      * @tc.steps: step5. Unregister the same AppEventProcessor object.
326      */
327     auto processor = std::make_shared<AppEventProcessorTest>();
328     auto ret = AppEventProcessorMgr::RegisterProcessor(TEST_PROCESSOR_NAME, processor);
329     ASSERT_EQ(ret, 0);
330     ret = AppEventProcessorMgr::RegisterProcessor(TEST_PROCESSOR_NAME, processor);
331     ASSERT_EQ(ret, -1);
332     ret = AppEventProcessorMgr::UnregisterProcessor(TEST_PROCESSOR_NAME);
333     ASSERT_EQ(ret, 0);
334     ret = AppEventProcessorMgr::UnregisterProcessor(TEST_PROCESSOR_NAME);
335     ASSERT_EQ(ret, -1);
336 }
337 
338 /**
339  * @tc.name: HiAppEventInnerApiTest003
340  * @tc.desc: check the real-time event callback AppEventProcessor.
341  * @tc.type: FUNC
342  */
343 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest003, TestSize.Level0)
344 {
345     /**
346      * @tc.steps: step1. Register an AppEventProcessor object.
347      * @tc.steps: step2. Set config to the AppEventProcessor object.
348      * @tc.steps: step3. Write an test event.
349      * @tc.steps: step4. Unregister the AppEventProcessor object.
350      */
351     auto processor = std::make_shared<AppEventProcessorTest>();
352     int64_t processorSeq = 0;
353     CheckRegisterObserver(TEST_PROCESSOR_NAME, processor, processorSeq);
354     CheckSetRealTimeConfig(processorSeq);
355     WriteEventOnce();
356     ASSERT_EQ(processor->GetReportTimes(), 1);
357     CheckUnregisterObserver(TEST_PROCESSOR_NAME);
358 }
359 
360 /**
361  * @tc.name: HiAppEventInnerApiTest004
362  * @tc.desc: check the row callback AppEventProcessor.
363  * @tc.type: FUNC
364  */
365 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest004, TestSize.Level0)
366 {
367     /**
368      * @tc.steps: step1. Register an AppEventProcessor object.
369      * @tc.steps: step2. Set config to the AppEventProcessor object.
370      * @tc.steps: step3. Write an test event.
371      * @tc.steps: step4. Unregister the AppEventProcessor object.
372      */
373     auto processor = std::make_shared<AppEventProcessorTest>();
374     int64_t processorSeq = 0;
375     CheckRegisterObserver(TEST_PROCESSOR_NAME, processor, processorSeq);
376     CheckSetRowConfig(processorSeq);
377 
378     ASSERT_EQ(processor->GetReportTimes(), 0);
379     WriteEventOnce();
380     ASSERT_EQ(processor->GetReportTimes(), 0);
381     WriteEventOnce();
382     ASSERT_EQ(processor->GetReportTimes(), 1);
383 
384     CheckUnregisterObserver(TEST_PROCESSOR_NAME);
385 }
386 
387 /**
388  * @tc.name: HiAppEventInnerApiTest005
389  * @tc.desc: check the size callback AppEventProcessor.
390  * @tc.type: FUNC
391  */
392 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest005, TestSize.Level0)
393 {
394     /**
395      * @tc.steps: step1. Register an AppEventProcessor object.
396      * @tc.steps: step2. Set config to the AppEventProcessor object.
397      * @tc.steps: step3. Write an test event.
398      * @tc.steps: step4. Unregister the AppEventProcessor object.
399      */
400     auto processor = std::make_shared<AppEventProcessorTest>();
401     int64_t processorSeq = 0;
402     CheckRegisterObserver(TEST_PROCESSOR_NAME, processor, processorSeq);
403     CheckSetSizeConfig(processorSeq);
404 
405     ASSERT_EQ(processor->GetReportTimes(), 0);
406     WriteEventOnce();
407     ASSERT_EQ(processor->GetReportTimes(), 0);
408     WriteEventOnce();
409     ASSERT_EQ(processor->GetReportTimes(), 1);
410 
411     CheckUnregisterObserver(TEST_PROCESSOR_NAME);
412 }
413 
414 /**
415  * @tc.name: HiAppEventInnerApiTest006
416  * @tc.desc: check the timeout callback AppEventProcessor.
417  * @tc.type: FUNC
418  */
419 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest006, TestSize.Level0)
420 {
421     /**
422      * @tc.steps: step1. Register an AppEventProcessor object.
423      * @tc.steps: step2. Set config to the AppEventProcessor object.
424      * @tc.steps: step3. Write an test event.
425      * @tc.steps: step4. Unregister the AppEventProcessor object.
426      */
427     auto processor = std::make_shared<AppEventProcessorTest>();
428     int64_t processorSeq = 0;
429     CheckRegisterObserver(TEST_PROCESSOR_NAME, processor, processorSeq);
430     CheckSetTimeoutConfig(processorSeq);
431 
432     ASSERT_EQ(processor->GetReportTimes(), 0);
433     WriteEventOnce();
434     ASSERT_EQ(processor->GetReportTimes(), 0);
435     sleep(HiAppEvent::TIMEOUT_STEP + 1); // 31s
436     ASSERT_EQ(processor->GetReportTimes(), 1);
437 
438     CheckUnregisterObserver(TEST_PROCESSOR_NAME);
439 }
440 
441 /**
442  * @tc.name: HiAppEventInnerApiTest007
443  * @tc.desc: check the background callback AppEventProcessor.
444  * @tc.type: FUNC
445  */
446 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest007, TestSize.Level0)
447 {
448     /**
449      * @tc.steps: step1. Register an AppEventProcessor object.
450      * @tc.steps: step2. Set config to the AppEventProcessor object.
451      * @tc.steps: step3. Write an test event.
452      * @tc.steps: step4. Unregister the AppEventProcessor object.
453      */
454     auto processor = std::make_shared<AppEventProcessorTest>();
455     int64_t processorSeq = 0;
456     CheckRegisterObserver(TEST_PROCESSOR_NAME, processor, processorSeq);
457     CheckSetOnBackgroundConfig(processorSeq);
458 
459     ASSERT_EQ(processor->GetReportTimes(), 0);
460     WriteEventOnce();
461     ASSERT_EQ(processor->GetReportTimes(), 0);
462     AppEventObserverMgr::GetInstance().HandleBackground();
463     sleep(1); // 1s
464     ASSERT_EQ(processor->GetReportTimes(), 1);
465 
466     CheckUnregisterObserver(TEST_PROCESSOR_NAME);
467 }
468 
469 /**
470  * @tc.name: HiAppEventInnerApiTest008
471  * @tc.desc: check the startup callback AppEventProcessor.
472  * @tc.type: FUNC
473  */
474 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest008, TestSize.Level0)
475 {
476     /**
477      * @tc.steps: step1. Register an AppEventProcessor object.
478      * @tc.steps: step2. Write an test event.
479      * @tc.steps: step3. Register an AppEventProcessor object with same configuration.
480      * @tc.steps: step4. Unregister the AppEventProcessor object.
481      */
482     auto processor = std::make_shared<AppEventProcessorTest>();
483     int64_t processorSeq1 = 0;
484     ReportConfig config = {
485         .name = TEST_PROCESSOR_NAME,
486         .triggerCond = {
487             .onStartup = true,
488         },
489         .eventConfigs = {{TEST_EVENT_DOMAIN, TEST_EVENT_NAME}},
490     };
491     CheckRegisterObserverWithConfig(TEST_PROCESSOR_NAME, processor, config, processorSeq1);
492 
493     ASSERT_EQ(processor->GetReportTimes(), 0);
494     WriteEventOnce();
495     ASSERT_EQ(processor->GetReportTimes(), 0);
496 
497     int64_t processorSeq2 = AppEventObserverMgr::GetInstance().RegisterObserver(TEST_PROCESSOR_NAME, config);
498     ASSERT_EQ(processorSeq1, processorSeq2);
499     sleep(1); // 1s
500     ASSERT_EQ(processor->GetReportTimes(), 1);
501 
502     CheckUnregisterObserver(TEST_PROCESSOR_NAME);
503 }
504 
505 /**
506  * @tc.name: HiAppEventInnerApiTest009
507  * @tc.desc: Adding a processor that does not exist.
508  * @tc.type: FUNC
509  */
510 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest009, TestSize.Level1)
511 {
512     ReportConfig config = {
513         .name = "invalid_processor",
514     };
515     int64_t processorId = AppEventProcessorMgr::AddProcessor(config);
516     ASSERT_EQ(processorId, -1);
517     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
518 }
519 
520 /**
521  * @tc.name: HiAppEventInnerApiTest010
522  * @tc.desc: Adding an existing processor.
523  * @tc.type: FUNC
524  */
525 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest010, TestSize.Level1)
526 {
527     ReportConfig config = {
528         .name = "test_processor",
529         .debugMode = true,
530         .routeInfo = "test_routeInfo",
531         .appId = "test_appid",
532         .triggerCond = {
533             .row = 1,
534             .timeout = 0,
535             .onStartup = false,
536             .onBackground = false,
537         },
538         .userIdNames = {"test_id"},
539         .userPropertyNames = {"test_property"},
540         .eventConfigs = {{"test_domain", "test_name", true}, {"test_domain", "test_realtime"}},
541         .configId = 1,
542         .customConfigs = {{"str_key", "str_value"}, {"str_key1", "str_value1"}},
543     };
544     int64_t processorId = AppEventProcessorMgr::AddProcessor(config);
545     ASSERT_GT(processorId, 0);
546     CheckSameConfig(processorId, config);
547     WriteEventOnce();
548     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
549 }
550 
551 /**
552  * @tc.name: HiAppEventInnerApiTest011
553  * @tc.desc: Adding an invalid processor with invalid name.
554  * @tc.type: FUNC
555  */
556 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest011, TestSize.Level1)
557 {
558     ReportConfig config = {
559         .name = "",
560     };
561     ASSERT_EQ(AppEventProcessorMgr::AddProcessor(config), -1);
562 
563     constexpr size_t limitLen = 256;
564     config.name = std::string(limitLen, 'a');
565     ASSERT_EQ(AppEventProcessorMgr::AddProcessor(config), -1);
566 
567     config.name = "***dddd";
568     ASSERT_EQ(AppEventProcessorMgr::AddProcessor(config), -1);
569 
570     config.name = "999aaaa";
571     ASSERT_EQ(AppEventProcessorMgr::AddProcessor(config), -1);
572 }
573 
574 /**
575  * @tc.name: HiAppEventInnerApiTest012
576  * @tc.desc: Adding an processor with invalid routeInfo.
577  * @tc.type: FUNC
578  */
579 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest012, TestSize.Level1)
580 {
581     constexpr size_t limitLen = 8 * 1024;
582     ReportConfig config = {
583         .name = "test_processor",
584         .routeInfo = std::string(limitLen, 'a'),
585     };
586     int64_t processorId1 = AppEventProcessorMgr::AddProcessor(config);
587     ASSERT_GT(processorId1, 0);
588     CheckSameConfig(processorId1, config);
589     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId1), 0);
590 
591     config.routeInfo = std::string(limitLen + 1, 'a');
592     int64_t processorId2 = AppEventProcessorMgr::AddProcessor(config);
593     ASSERT_GT(processorId2, 0);
594 
595     ReportConfig expectConfig = {
596         .name = "test_processor",
597         .routeInfo = "", // default routeInfo value
598     };
599     CheckSameConfig(processorId2, expectConfig);
600 
601     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId2), 0);
602 }
603 
604 /**
605  * @tc.name: HiAppEventInnerApiTest013
606  * @tc.desc: Adding an processor with invalid appId.
607  * @tc.type: FUNC
608  */
609 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest013, TestSize.Level1)
610 {
611     constexpr size_t limitLen = 8 * 1024;
612     ReportConfig config = {
613         .name = "test_processor",
614         .appId = std::string(limitLen, 'a'),
615     };
616     int64_t processorId1 = AppEventProcessorMgr::AddProcessor(config);
617     ASSERT_GT(processorId1, 0);
618     CheckSameConfig(processorId1, config);
619     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId1), 0);
620 
621     config.appId = std::string(limitLen + 1, 'a');
622     int64_t processorId2 = AppEventProcessorMgr::AddProcessor(config);
623     ASSERT_GT(processorId2, 0);
624 
625     ReportConfig expectConfig = {
626         .name = "test_processor",
627         .appId = "", // default appId value
628     };
629     CheckSameConfig(processorId2, expectConfig);
630 
631     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId2), 0);
632 }
633 
634 /**
635  * @tc.name: HiAppEventInnerApiTest014
636  * @tc.desc: Adding an processor with invalid triggerCond.row.
637  * @tc.type: FUNC
638  */
639 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest014, TestSize.Level1)
640 {
641     constexpr int limitRow = 1000;
642     ReportConfig config = {
643         .name = "test_processor",
644         .triggerCond = {
645             .row = limitRow,
646         },
647     };
648     int64_t processorId1 = AppEventProcessorMgr::AddProcessor(config);
649     ASSERT_GT(processorId1, 0);
650     CheckSameConfig(processorId1, config);
651     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId1), 0);
652 
653     config.triggerCond.row = -1;
654     int64_t processorId2 = AppEventProcessorMgr::AddProcessor(config);
655     ASSERT_GT(processorId2, 0);
656     ReportConfig expectConfig = {
657         .name = "test_processor",
658         .triggerCond.row = 0, // default row value
659     };
660     CheckSameConfig(processorId2, expectConfig);
661     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId2), 0);
662 
663     config.triggerCond.row = limitRow + 1;
664     int64_t processorId3 = AppEventProcessorMgr::AddProcessor(config);
665     ASSERT_GT(processorId3, 0);
666     CheckSameConfig(processorId3, expectConfig);
667     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId3), 0);
668 }
669 
670 /**
671  * @tc.name: HiAppEventInnerApiTest015
672  * @tc.desc: Adding an processor with invalid triggerCond.timeout.
673  * @tc.type: FUNC
674  */
675 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest015, TestSize.Level1)
676 {
677     ReportConfig config = {
678         .name = "test_processor",
679         .triggerCond = {
680             .timeout = -1,
681         },
682     };
683     int64_t processorId1 = AppEventProcessorMgr::AddProcessor(config);
684     ASSERT_GT(processorId1, 0);
685     ReportConfig expectConfig = {
686         .name = "test_processor",
687         .triggerCond.timeout = 0, // default timeout value
688     };
689     CheckSameConfig(processorId1, expectConfig);
690     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId1), 0);
691 }
692 
693 /**
694  * @tc.name: HiAppEventInnerApiTest016
695  * @tc.desc: Adding an processor with invalid userIdNames.
696  * @tc.type: FUNC
697  */
698 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest016, TestSize.Level1)
699 {
700     constexpr size_t limitLen = 256;
701     ReportConfig config = {
702         .name = "test_processor",
703         .userIdNames = {
704             std::string(limitLen, 'a'), "id1"
705         },
706     };
707     int64_t processorId = AppEventProcessorMgr::AddProcessor(config);
708     ASSERT_GT(processorId, 0);
709     CheckSameConfig(processorId, config);
710     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
711 
712     config.userIdNames = {"***xxxx", "id1"};
713     processorId = AppEventProcessorMgr::AddProcessor(config);
714     ASSERT_GT(processorId, 0);
715     ReportConfig expectConfig = {
716         .name = "test_processor",
717         .userIdNames = {}, // default userIdNames value
718     };
719     CheckSameConfig(processorId, expectConfig);
720     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
721 
722     config.userIdNames = {"", "id1"};
723     processorId = AppEventProcessorMgr::AddProcessor(config);
724     ASSERT_GT(processorId, 0);
725     CheckSameConfig(processorId, expectConfig);
726     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
727 
728     config.userIdNames = {std::string(limitLen + 1, 'a'), "id1"};
729     processorId = AppEventProcessorMgr::AddProcessor(config);
730     ASSERT_GT(processorId, 0);
731     CheckSameConfig(processorId, expectConfig);
732     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
733 }
734 
735 /**
736  * @tc.name: HiAppEventInnerApiTest017
737  * @tc.desc: Adding an processor with invalid userIdNames.
738  * @tc.type: FUNC
739  */
740 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest017, TestSize.Level1)
741 {
742     constexpr size_t limitLen = 256;
743     ReportConfig config = {
744         .name = "test_processor",
745         .userPropertyNames = {
746             std::string(limitLen, 'a'), "id1"
747         },
748     };
749     int64_t processorId = AppEventProcessorMgr::AddProcessor(config);
750     ASSERT_GT(processorId, 0);
751     CheckSameConfig(processorId, config);
752     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
753 
754     config.userPropertyNames = {"***xxxx", "id1"};
755     processorId = AppEventProcessorMgr::AddProcessor(config);
756     ASSERT_GT(processorId, 0);
757     ReportConfig expectConfig = {
758         .name = "test_processor",
759         .userPropertyNames = {}, // default userPropertyNames value
760     };
761     CheckSameConfig(processorId, expectConfig);
762     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
763 
764     config.userPropertyNames = {"", "id1"};
765     processorId = AppEventProcessorMgr::AddProcessor(config);
766     ASSERT_GT(processorId, 0);
767     CheckSameConfig(processorId, expectConfig);
768     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
769 
770     config.userPropertyNames = {std::string(limitLen + 1, 'a'), "id1"};
771     processorId = AppEventProcessorMgr::AddProcessor(config);
772     ASSERT_GT(processorId, 0);
773     CheckSameConfig(processorId, expectConfig);
774     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
775 }
776 
777 /**
778  * @tc.name: HiAppEventInnerApiTest018
779  * @tc.desc: Adding an processor with invalid eventConfigs.
780  * @tc.type: FUNC
781  */
782 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest018, TestSize.Level1)
783 {
784     ReportConfig config = {
785         .name = "test_processor",
786         .eventConfigs = {
787             {"***domain", "name"}
788         },
789     };
790     int64_t processorId = AppEventProcessorMgr::AddProcessor(config);
791     ASSERT_GT(processorId, 0);
792     ReportConfig expectConfig = {
793         .name = "test_processor",
794         .eventConfigs = {}, // default eventConfigs value
795     };
796     CheckSameConfig(processorId, expectConfig);
797     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
798 
799     config.eventConfigs = {{"domain", "***name"}};
800     processorId = AppEventProcessorMgr::AddProcessor(config);
801     ASSERT_GT(processorId, 0);
802     CheckSameConfig(processorId, expectConfig);
803     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
804 
805     config.eventConfigs = {{"", "", true}, {"test_domain", "test_name"}};
806     processorId = AppEventProcessorMgr::AddProcessor(config);
807     ASSERT_GT(processorId, 0);
808     CheckSameConfig(processorId, expectConfig);
809     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
810 }
811 
812 /**
813  * @tc.name: HiAppEventInnerApiTest019
814  * @tc.desc: Adding an existing processor with empty domain.
815  * @tc.type: FUNC
816  */
817 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest019, TestSize.Level1)
818 {
819     ReportConfig config = {
820         .name = "test_processor",
821         .eventConfigs = {
822             {"", TEST_EVENT_NAME, true}
823         },
824     };
825     int64_t processorId = AppEventProcessorMgr::AddProcessor(config);
826     ASSERT_GT(processorId, 0);
827     CheckSameConfig(processorId, config);
828     WriteEventOnce();
829     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
830 }
831 
832 /**
833  * @tc.name: HiAppEventInnerApiTest020
834  * @tc.desc: Adding an existing processor with empty name.
835  * @tc.type: FUNC
836  */
837 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest020, TestSize.Level1)
838 {
839     ReportConfig config = {
840         .name = "test_processor",
841         .eventConfigs = {
842             {TEST_EVENT_DOMAIN, "", true}
843         },
844     };
845     int64_t processorId = AppEventProcessorMgr::AddProcessor(config);
846     ASSERT_GT(processorId, 0);
847     CheckSameConfig(processorId, config);
848     WriteEventOnce();
849     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
850 }
851 
852 /**
853  * @tc.name: HiAppEventInnerApiTest021
854  * @tc.desc: Adding an processor with same processorId.
855  * @tc.type: FUNC
856  */
857 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest021, TestSize.Level1)
858 {
859     ReportConfig config = {
860         .name = "test_processor",
861         .configId = 1,
862     };
863     int64_t processorId1 = AppEventProcessorMgr::AddProcessor(config);
864     ASSERT_GT(processorId1, 0);
865 
866     config.eventConfigs = {{"test_domain", "test_name", true}, {"test_domain", "test_realtime"}};
867     int64_t processorId2 = AppEventProcessorMgr::AddProcessor(config);
868     ASSERT_GT(processorId2, 0);
869     ASSERT_EQ(processorId1, processorId2);
870 
871     config.configId = 0;
872     int64_t processorId3 = AppEventProcessorMgr::AddProcessor(config);
873     ASSERT_GT(processorId3, 0);
874     ASSERT_NE(processorId2, processorId3);
875 
876     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId1), 0);
877     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId2), 0);
878     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId3), 0);
879 }
880 
881 /**
882  * @tc.name: HiAppEventInnerApiTest022
883  * @tc.desc: Adding an processor with invalid configId.
884  * @tc.type: FUNC
885  */
886 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest022, TestSize.Level1)
887 {
888     ReportConfig config = {
889         .name = "test_processor",
890         .configId = -1,
891     };
892     int64_t processorId = AppEventProcessorMgr::AddProcessor(config);
893     ASSERT_GT(processorId, 0);
894     ReportConfig expectConfig = {
895         .name = "test_processor",
896         .configId = 0, // default configId
897     };
898     CheckSameConfig(processorId, expectConfig);
899     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
900 }
901 
902 /**
903  * @tc.name: HiAppEventInnerApiTest023
904  * @tc.desc: Adding an processor with invalid customConfigs.
905  * @tc.type: FUNC
906  */
907 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest023, TestSize.Level1)
908 {
909     ReportConfig config = {
910         .name = "test_processor",
911         .customConfigs = {{"", "test_str"}},
912     };
913     int64_t processorId = AppEventProcessorMgr::AddProcessor(config);
914     ASSERT_GT(processorId, 0);
915     ReportConfig expectConfig = {
916         .name = "test_processor",
917         .customConfigs = {}, // default customConfigs value
918     };
919     CheckSameConfig(processorId, expectConfig);
920     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
921 
922     config.customConfigs = {{"**name", "value"}};
923     processorId = AppEventProcessorMgr::AddProcessor(config);
924     ASSERT_GT(processorId, 0);
925     CheckSameConfig(processorId, expectConfig);
926     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
927 
928     constexpr size_t limitLen = 1024;
929     config.customConfigs = {{"test_name", std::string(limitLen + 1, 'a')}};
930     processorId = AppEventProcessorMgr::AddProcessor(config);
931     ASSERT_GT(processorId, 0);
932     CheckSameConfig(processorId, expectConfig);
933     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorId), 0);
934 }
935 
936 /**
937  * @tc.name: HiAppEventInnerApiTest024
938  * @tc.desc: check the api AppEventProcessorMgr not app.
939  * @tc.type: FUNC
940  */
941 HWTEST_F(HiAppEventInnerApiTest, HiAppEventInnerApiTest024, TestSize.Level0)
942 {
943     setuid(0); // 0 means root uid
944 
945     auto processor = std::make_shared<AppEventProcessorTest>();
946     ASSERT_EQ(AppEventProcessorMgr::RegisterProcessor(TEST_PROCESSOR_NAME, processor), ERROR_NOT_APP);
947     ASSERT_EQ(AppEventProcessorMgr::UnregisterProcessor(TEST_PROCESSOR_NAME), ERROR_NOT_APP);
948 
949     std::vector<int64_t> processorSeqs;
950     ASSERT_EQ(AppEventProcessorMgr::GetProcessorSeqs(TEST_PROCESSOR_NAME, processorSeqs), ERROR_NOT_APP);
951 
952     int64_t processorSeq = 0;
953     ReportConfig config = {
954         .name = TEST_PROCESSOR_NAME,
955     };
956     ASSERT_EQ(AppEventProcessorMgr::SetProcessorConfig(processorSeq, config), ERROR_NOT_APP);
957     ASSERT_EQ(AppEventProcessorMgr::GetProcessorConfig(processorSeq, config), ERROR_NOT_APP);
958 
959     ASSERT_EQ(AppEventProcessorMgr::AddProcessor(config), ERROR_NOT_APP);
960     ASSERT_EQ(AppEventProcessorMgr::RemoveProcessor(processorSeq), ERROR_NOT_APP);
961 
962     // set app uid
963     setuid(TEST_UID);
964 }
965