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#include <gtest/gtest.h>
16
17#include "bootstage.h"
18#include "init_jobs_internal.h"
19#include "init_log.h"
20#include "init_param.h"
21#include "init_utils.h"
22#include "init_hashmap.h"
23#include "loop_event.h"
24#include "param_manager.h"
25#include "param_stub.h"
26#include "param_utils.h"
27#include "securec.h"
28#include "trigger_checker.h"
29#include "trigger_manager.h"
30
31using namespace testing::ext;
32using namespace std;
33
34static const int triggerBuffer = 512;
35static uint32_t g_execCmdId = 0;
36static int g_matchTrigger = 0;
37static char g_matchTriggerName[triggerBuffer] = { 0 };
38static void BootStateChange(int start, const char *content)
39{
40    UNUSED(content);
41    return;
42}
43
44static int TestCmdExec(const TriggerNode *trigger, const char *content, uint32_t size)
45{
46    PARAM_CHECK(trigger != nullptr, return -1, "Invalid trigger");
47    PARAM_LOGI("DoTriggerExecute_ trigger type: %d %s", trigger->type, GetTriggerName(trigger));
48    PARAM_CHECK(trigger->type <= TRIGGER_UNKNOW, return -1, "Invalid trigger type %d", trigger->type);
49    CommandNode *cmd = GetNextCmdNode(reinterpret_cast<const JobNode *>(trigger), nullptr);
50    while (cmd != nullptr) {
51        g_execCmdId = cmd->cmdKeyIndex;
52        cmd = GetNextCmdNode(reinterpret_cast<const JobNode *>(trigger), cmd);
53    }
54    return 0;
55}
56
57static int TestTriggerExecute(TriggerNode *trigger, const char *content, uint32_t size)
58{
59    JobNode *node = reinterpret_cast<JobNode *>(trigger);
60    int ret = memcpy_s(g_matchTriggerName, (int)sizeof(g_matchTriggerName) - 1, node->name, strlen(node->name));
61    EXPECT_EQ(ret, 0);
62    g_matchTriggerName[strlen(node->name)] = '\0';
63    g_matchTrigger++;
64    return 0;
65}
66
67static void Test_JobParseHook(JOB_PARSE_CTX *jobParseCtx)
68{
69    return;
70}
71
72class TriggerUnitTest : public ::testing::Test {
73public:
74    TriggerUnitTest() {}
75    virtual ~TriggerUnitTest() {}
76
77    void SetUp()
78    {
79        SetTestPermissionResult(0);
80    }
81    void TearDown() {}
82    void TestBody() {}
83
84    int ParseInitCfg(const char *configFile)
85    {
86        char *fileBuf = ReadFileToBuf(configFile);
87        INIT_ERROR_CHECK(fileBuf != nullptr, return -1, "Failed to read file content %s", configFile);
88        cJSON *fileRoot = cJSON_Parse(fileBuf);
89        INIT_ERROR_CHECK(fileRoot != nullptr, return -1, "Failed to parse json file %s", configFile);
90        ParseTriggerConfig(fileRoot, nullptr, nullptr);
91        cJSON_Delete(fileRoot);
92        free(fileBuf);
93        fileBuf = nullptr;
94        return 0;
95    }
96
97    int TestLoadTrigger()
98    {
99        RegisterBootStateChange(BootStateChange);
100        InitAddJobParseHook(Test_JobParseHook);
101
102        int cmdKeyIndex = 0;
103        const char *matchCmd = GetMatchCmd("setparam aaaa aaaa", &cmdKeyIndex);
104        printf("cmd %d \n", matchCmd != nullptr);
105        EXPECT_NE(matchCmd, nullptr);
106
107        ReadConfig();
108        ParseInitCfg(STARTUP_INIT_UT_PATH "/trigger_test.cfg");
109        // trigger
110        PostTrigger(EVENT_TRIGGER_BOOT, "pre-init", strlen("pre-init"));
111        PostTrigger(EVENT_TRIGGER_BOOT, "init", strlen("init"));
112        PostTrigger(EVENT_TRIGGER_BOOT, "post-init", strlen("post-init"));
113        LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
114        return 0;
115    }
116
117    TriggerHeader *GetTriggerHeader(int type)
118    {
119        return &GetTriggerWorkSpace()->triggerHead[type];
120    }
121
122    JobNode *AddTrigger(int type, const char *name, const char *condition, uint32_t size)
123    {
124        return UpdateJobTrigger(GetTriggerWorkSpace(), type, condition, name);
125    }
126
127    int TestAddTriggerForBoot()
128    {
129        JobNode *node = AddTrigger(TRIGGER_BOOT, "init-later", "", 0);
130        JobNode *trigger = GetTriggerByName(GetTriggerWorkSpace(), "init-later");
131        EXPECT_EQ(node, trigger);
132        if (trigger == nullptr) {
133            return -1;
134        }
135        EXPECT_EQ(strcmp(trigger->name, "init-later"), 0);
136
137        // add command
138        int cmdIndex = 0;
139        GetMatchCmd("reboot ", &cmdIndex);
140        int ret = AddCommand(trigger, cmdIndex, nullptr, nullptr);
141        EXPECT_EQ(ret, 0);
142        ret = AddCommand(trigger, cmdIndex, "update: aaaaaaa", nullptr);
143        EXPECT_EQ(ret, 0);
144        return 0;
145    }
146
147    int TestAddTriggerForParm()
148    {
149        const char *triggerName = "param:test_param.000";
150        int id = 0;
151        JobNode *node = AddTrigger(TRIGGER_PARAM, triggerName, "test_param.000=1", 0);
152        JobNode *trigger = GetTriggerByName(GetTriggerWorkSpace(), triggerName);
153        GetTriggerHeader(TRIGGER_PARAM)->compareData(reinterpret_cast<struct tagTriggerNode_ *>(trigger), &id);
154        EXPECT_EQ(trigger, node);
155        if (trigger == nullptr) {
156            return -1;
157        }
158        EXPECT_EQ(strcmp(trigger->name, triggerName), 0);
159
160        // add command
161        int cmdIndex = 0;
162        GetMatchCmd("reboot ", &cmdIndex);
163        int ret = AddCommand(trigger, cmdIndex, nullptr, nullptr);
164        EXPECT_EQ(ret, 0);
165        ret = AddCommand(trigger, cmdIndex, "update: aaaaaaa", nullptr);
166        EXPECT_EQ(ret, 0);
167        return 0;
168    }
169
170    int TestParamEvent()
171    {
172        PostParamTrigger(EVENT_TRIGGER_PARAM, "net.tcp.default_init_rwnd", "60");
173        const char *sysctrl = "ohos.startup.powerctrl=reboot, shutdown";
174        PostTrigger(EVENT_TRIGGER_PARAM, sysctrl, strlen(sysctrl));
175        PostParamTrigger(EVENT_TRIGGER_PARAM, "ohos.startup.powerctrl", "reboot, shutdown");
176
177        const char *startCmd = "ohos.ctl.start=hdc -t";
178        PostTrigger(EVENT_TRIGGER_PARAM, startCmd, strlen(startCmd));
179        PostParamTrigger(EVENT_TRIGGER_PARAM, "ohos.ctl.start", "hdc -t");
180
181        const char *stopCmd = "ohos.ctl.stop=hdc -t";
182        PostTrigger(EVENT_TRIGGER_PARAM, stopCmd, strlen(stopCmd));
183        PostParamTrigger(EVENT_TRIGGER_PARAM, "ohos.ctl.stop", "hdc -t");
184        return 0;
185    }
186
187    int TestBootEvent(const char *boot)
188    {
189        PostTrigger(EVENT_TRIGGER_BOOT, boot, strlen(boot));
190        return 0;
191    }
192
193    int TestCheckParamTrigger1()
194    {
195        const char *triggerName = "param:test_param.111";
196        const char *param = "test_param.aaa.111.2222";
197        const char *value = "1";
198        char buffer[triggerBuffer];
199        int ret = sprintf_s(buffer, sizeof(buffer), "%s=%s", param, value);
200        EXPECT_GE(ret, 0);
201        JobNode *node = AddTrigger(TRIGGER_PARAM, triggerName, buffer, 0);
202        JobNode *trigger = GetTriggerByName(GetTriggerWorkSpace(), triggerName);
203        EXPECT_EQ(trigger, node);
204
205        g_matchTrigger = 0;
206        ret = sprintf_s(buffer, sizeof(buffer), "%s=%s", param, "2");
207        EXPECT_GE(ret, 0);
208        CheckTrigger(GetTriggerWorkSpace(), TRIGGER_PARAM, buffer, strlen(buffer), TestTriggerExecute);
209        EXPECT_EQ(0, g_matchTrigger);
210
211        g_matchTrigger = 0;
212        ret = sprintf_s(buffer, sizeof(buffer), "%s=%s", param, value);
213        EXPECT_GE(ret, 0);
214        CheckTrigger(GetTriggerWorkSpace(), TRIGGER_PARAM, buffer, strlen(buffer), TestTriggerExecute);
215        EXPECT_EQ(1, g_matchTrigger);
216        EXPECT_EQ(0, strcmp(triggerName, g_matchTriggerName));
217
218        // check for bug
219        g_matchTrigger = 0;
220        ret = sprintf_s(buffer, sizeof(buffer), "%s=%s", "2222", value);
221        EXPECT_GE(ret, 0);
222        CheckTrigger(GetTriggerWorkSpace(), TRIGGER_PARAM, buffer, strlen(buffer), TestTriggerExecute);
223        EXPECT_EQ(0, g_matchTrigger);
224
225        CheckTrigger(GetTriggerWorkSpace(), TRIGGER_PARAM_WATCH, buffer, strlen(buffer), TestTriggerExecute);
226        return 0;
227    }
228
229    int TestCheckParamTrigger2()
230    {
231        const char *triggerName = "param:test_param.222";
232        const char *param = "test_param.aaa.222.2222";
233        char buffer[triggerBuffer];
234        int ret = sprintf_s(buffer, sizeof(buffer), "%s=*", param);
235        EXPECT_GE(ret, 0);
236        JobNode *node = AddTrigger(TRIGGER_PARAM, triggerName, buffer, 0);
237        JobNode *trigger = GetTriggerByName(GetTriggerWorkSpace(), triggerName);
238        EXPECT_EQ(trigger, node);
239
240        g_matchTrigger = 0;
241        ret = sprintf_s(buffer, sizeof(buffer), "%s=%s", param, "2");
242        EXPECT_GE(ret, 0);
243        CheckTrigger(GetTriggerWorkSpace(), TRIGGER_PARAM, buffer, strlen(buffer), TestTriggerExecute);
244        EXPECT_EQ(1, g_matchTrigger);
245        EXPECT_EQ(0, strcmp(triggerName, g_matchTriggerName));
246
247        g_matchTrigger = 0;
248        CheckTrigger(GetTriggerWorkSpace(), TRIGGER_PARAM, param, strlen(param), TestTriggerExecute);
249        EXPECT_EQ(1, g_matchTrigger);
250        EXPECT_EQ(0, strcmp(triggerName, g_matchTriggerName));
251        return 0;
252    }
253
254    int TestCheckParamTrigger3()
255    {
256        const char *triggerName = "param:test_param.333";
257        const char *param1 = "test_param.aaa.333.2222=1";
258        const char *param2 = "test_param.aaa.333.3333=2";
259        char buffer[triggerBuffer];
260        int ret = sprintf_s(buffer, sizeof(buffer), "%s || %s", param1, param2);
261        EXPECT_GE(ret, 0);
262        JobNode *node = AddTrigger(TRIGGER_PARAM, triggerName, buffer, 0);
263        JobNode *trigger = GetTriggerByName(GetTriggerWorkSpace(), triggerName);
264        EXPECT_EQ(trigger, node);
265
266        g_matchTrigger = 0;
267        CheckTrigger(GetTriggerWorkSpace(), TRIGGER_PARAM, param1, strlen(param1), TestTriggerExecute);
268        EXPECT_EQ(1, g_matchTrigger);
269        EXPECT_EQ(0, strcmp(triggerName, g_matchTriggerName));
270
271        g_matchTrigger = 0;
272        CheckTrigger(GetTriggerWorkSpace(), TRIGGER_PARAM, param2, strlen(param2), TestTriggerExecute);
273        EXPECT_EQ(1, g_matchTrigger);
274        EXPECT_EQ(0, strcmp(triggerName, g_matchTriggerName));
275        return 0;
276    }
277
278    int TestCheckParamTrigger4()
279    {
280        const char *triggerName = "param:test_param.444";
281        const char *param1 = "test_param.aaa.444.2222";
282        const char *param2 = "test_param.aaa.444.3333";
283        char buffer[triggerBuffer];
284        int ret = sprintf_s(buffer, sizeof(buffer), "%s=%s && %s=%s", param1, "1", param2, "2");
285        EXPECT_GE(ret, 0);
286        JobNode *node = AddTrigger(TRIGGER_PARAM, triggerName, buffer, 0);
287        JobNode *trigger = GetTriggerByName(GetTriggerWorkSpace(), triggerName);
288        EXPECT_EQ(trigger, node);
289        DoJobNow(triggerName);
290        ClearTrigger(nullptr, 0);
291        g_matchTrigger = 0;
292        SystemWriteParam(param1, "1");
293        ret = sprintf_s(buffer, sizeof(buffer), "%s=%s", param1, "1");
294        EXPECT_GE(ret, 0);
295        CheckTrigger(GetTriggerWorkSpace(), TRIGGER_PARAM, buffer, strlen(buffer), TestTriggerExecute);
296        EXPECT_EQ(0, g_matchTrigger);
297
298        SystemWriteParam(param2, "2");
299        g_matchTrigger = 0;
300        ret = sprintf_s(buffer, sizeof(buffer), "%s=%s", param2, "2");
301        EXPECT_GE(ret, 0);
302        CheckTrigger(GetTriggerWorkSpace(), TRIGGER_PARAM, buffer, strlen(buffer), TestTriggerExecute);
303        EXPECT_EQ(1, g_matchTrigger);
304        EXPECT_EQ(0, strcmp(triggerName, g_matchTriggerName));
305        return 0;
306    }
307
308    // test for trigger aaaa:test_param.aaa 被加入unknown执行
309    int TestCheckParamTrigger5()
310    {
311        const char *triggerName = "aaaa:test_param.aaa";
312        const char *param1 = "test_param.aaa.aaa.2222";
313        const char *param2 = "test_param.aaa.aaa.3333";
314        char buffer[triggerBuffer];
315        int ret = sprintf_s(buffer, sizeof(buffer), "aaaa && %s=%s && %s=%s", param1, "1", param2, "2");
316        EXPECT_GE(ret, 0);
317        JobNode *node = AddTrigger(TRIGGER_UNKNOW, triggerName, buffer, 0);
318        JobNode *trigger = GetTriggerByName(GetTriggerWorkSpace(), triggerName);
319        EXPECT_EQ(trigger, node);
320
321        g_matchTrigger = 0;
322        SystemWriteParam(param1, "1");
323        ret = sprintf_s(buffer, sizeof(buffer), "%s=%s", param1, "1");
324        EXPECT_GE(ret, 0);
325        CheckTrigger(GetTriggerWorkSpace(), TRIGGER_PARAM, buffer, strlen(buffer), TestTriggerExecute);
326        EXPECT_EQ(0, g_matchTrigger);
327
328        SystemWriteParam(param2, "2");
329        g_matchTrigger = 0;
330        CheckTrigger(GetTriggerWorkSpace(), TRIGGER_UNKNOW, "aaaa", strlen("aaaa"), TestTriggerExecute);
331        EXPECT_EQ(1, g_matchTrigger);
332        EXPECT_EQ(0, strcmp(triggerName, g_matchTriggerName));
333        return 0;
334    }
335
336    int TestComputeCondition(const char *condition)
337    {
338        u_int32_t size = strlen(condition) + CONDITION_EXTEND_LEN;
339        char *prefix = reinterpret_cast<char *>(malloc(size));
340        if (prefix == nullptr) {
341            printf("prefix is null.\n");
342            return -1;
343        }
344        ConvertInfixToPrefix(condition, prefix, size);
345        printf("prefix %s \n", prefix);
346        free(prefix);
347        return 0;
348    }
349
350    // 普通的属性trigger
351    int TestExecuteParamTrigger1()
352    {
353        const char *triggerName = "aaaa:test_param.eee";
354        const char *param = "test_param.eee.aaa.1111";
355        const char *value = "eee";
356        char buffer[triggerBuffer];
357        int ret = sprintf_s(buffer, sizeof(buffer), "%s=%s", param, value);
358        EXPECT_GE(ret, 0);
359        JobNode *node = AddTrigger(TRIGGER_PARAM, triggerName, buffer, 0);
360        JobNode *trigger = GetTriggerByName(GetTriggerWorkSpace(), triggerName);
361        EXPECT_EQ(trigger, node);
362
363        const uint32_t cmdIndex = 100;
364        ret = AddCommand(trigger, cmdIndex, value, nullptr);
365        EXPECT_EQ(ret, 0);
366        // 修改命令为测试执行
367        RegisterTriggerExec(TRIGGER_PARAM, TestCmdExec);
368        SystemWriteParam(param, value);
369        LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
370        EXPECT_EQ(g_execCmdId, cmdIndex);
371        return 0;
372    }
373
374    int TestExecuteParamTrigger2()
375    {
376        const char *triggerName = "param:test_param.dddd";
377        const char *param = "test_param.dddd.aaa.2222";
378        const char *value = "2222";
379        char buffer[triggerBuffer];
380        int ret = sprintf_s(buffer, sizeof(buffer), "%s=%s", param, value);
381        EXPECT_GE(ret, 0);
382        JobNode *node = AddTrigger(TRIGGER_PARAM, triggerName, buffer, 0);
383        JobNode *trigger = GetTriggerByName(GetTriggerWorkSpace(), triggerName);
384        EXPECT_EQ(trigger, node);
385        const uint32_t cmdIndex = 102;
386        ret = AddCommand(trigger, cmdIndex, value, nullptr);
387        EXPECT_EQ(ret, 0);
388        RegisterTriggerExec(TRIGGER_PARAM, TestCmdExec);
389        SystemWriteParam(param, value);
390        LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
391        EXPECT_EQ(g_execCmdId, cmdIndex);
392        return 0;
393    }
394
395    // 测试执行后立刻删除
396    int TestExecuteParamTrigger3()
397    {
398        const char *triggerName = "param:test_param.3333";
399        const char *param = "test_param.dddd.aaa.3333";
400        const char *value = "3333";
401        char buffer[triggerBuffer];
402        int ret = sprintf_s(buffer, sizeof(buffer), "%s=%s", param, value);
403        EXPECT_GE(ret, 0);
404        JobNode *node = AddTrigger(TRIGGER_PARAM, triggerName, buffer, 0);
405        JobNode *trigger = GetTriggerByName(GetTriggerWorkSpace(), triggerName);
406        EXPECT_EQ(trigger, node);
407        if (trigger == nullptr) {
408            return -1;
409        }
410        const uint32_t cmdIndex = 103;
411        ret = AddCommand(trigger, cmdIndex, value, nullptr);
412        EXPECT_EQ(ret, 0);
413        TRIGGER_SET_FLAG(trigger, TRIGGER_FLAGS_ONCE);
414        SystemWriteParam(param, value);
415
416        RegisterTriggerExec(TRIGGER_PARAM, TestCmdExec);
417        LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
418        EXPECT_EQ(g_execCmdId, cmdIndex);
419        trigger = GetTriggerByName(GetTriggerWorkSpace(), triggerName);
420        if (trigger != nullptr) {
421            EXPECT_EQ(1, 0);
422        }
423        return 0;
424    }
425
426    // 测试删除队列中的trigger
427    int TestExecuteParamTrigger4()
428    {
429        const char *triggerName = "param:test_param.4444";
430        const char *param = "test_param.dddd.aaa.4444";
431        const char *value = "4444";
432        char buffer[triggerBuffer];
433        int ret = sprintf_s(buffer, sizeof(buffer), "%s=%s", param, value);
434        EXPECT_GE(ret, 0);
435        JobNode *node = AddTrigger(TRIGGER_PARAM, triggerName, buffer, 0);
436        JobNode *trigger = GetTriggerByName(GetTriggerWorkSpace(), triggerName);
437        EXPECT_EQ(trigger, node);
438        if (trigger == nullptr) {
439            return -1;
440        }
441        const uint32_t cmdIndex = 105;
442        ret = AddCommand(trigger, cmdIndex, value, nullptr);
443        EXPECT_EQ(ret, 0);
444        TRIGGER_SET_FLAG(trigger, TRIGGER_FLAGS_ONCE);
445        SystemWriteParam(param, value);
446
447        RegisterTriggerExec(TRIGGER_PARAM, TestCmdExec);
448        FreeTrigger(GetTriggerWorkSpace(), reinterpret_cast<TriggerNode *>(trigger));
449        LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
450        EXPECT_NE(g_execCmdId, cmdIndex);
451        trigger = GetTriggerByName(GetTriggerWorkSpace(), triggerName);
452        if (trigger != nullptr) {
453            EXPECT_EQ(1, 0);
454        }
455        return 0;
456    }
457
458    // 测试执行后检查子trigger执行
459    int TestExecuteParamTrigger5()
460    {
461        const char *boot = "boot2";
462        const char *triggerName = "boot2:test_param.5555";
463        const char *param = "test_param.dddd.aaa.5555";
464        const char *value = "5555";
465        JobNode *trigger = AddTrigger(TRIGGER_BOOT, boot, nullptr, 0);
466        const int testCmdIndex = 1105;
467        int ret = AddCommand(trigger, testCmdIndex, value, nullptr);
468        EXPECT_EQ(ret, 0);
469        if (trigger == nullptr) {
470            return -1;
471        }
472        TRIGGER_SET_FLAG(trigger, TRIGGER_FLAGS_SUBTRIGGER);
473
474        char buffer[triggerBuffer];
475        ret = sprintf_s(buffer, sizeof(buffer), "boot2 && %s=%s", param, value);
476        EXPECT_GE(ret, 0);
477        trigger = AddTrigger(TRIGGER_UNKNOW, triggerName, buffer, 0);
478        const int testCmdIndex2 = 105;
479        ret = AddCommand(trigger, testCmdIndex2, value, nullptr);
480
481        RegisterTriggerExec(TRIGGER_UNKNOW, TestCmdExec);
482        SystemWriteParam(param, value);
483
484        TestBootEvent(boot);
485        LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
486        EXPECT_EQ(g_execCmdId, (uint32_t)testCmdIndex2);
487        return 0;
488    }
489
490    int TestDumpTrigger()
491    {
492        (void)AddCompleteJob("param:ohos.servicectrl.display", "ohos.servicectrl.display=*", "display system");
493        DoTriggerExec("param:ohos.servicectrl.display");
494        return 0;
495    }
496};
497
498HWTEST_F(TriggerUnitTest, Init_TestLoadTrigger_001, TestSize.Level0)
499{
500    TriggerUnitTest test;
501    test.TestLoadTrigger();
502}
503
504HWTEST_F(TriggerUnitTest, Init_TestBootEvent_001, TestSize.Level0)
505{
506    TriggerUnitTest test;
507    test.TestBootEvent("pre-init");
508    test.TestBootEvent("init");
509    test.TestBootEvent("post-init");
510    test.TestBootEvent("early-init");
511}
512
513HWTEST_F(TriggerUnitTest, Init_TestAddTriggerForBoot_001, TestSize.Level0)
514{
515    TriggerUnitTest test;
516    test.TestAddTriggerForBoot();
517}
518
519HWTEST_F(TriggerUnitTest, Init_TestAddTriggerForParm_001, TestSize.Level0)
520{
521    TriggerUnitTest test;
522    test.TestAddTriggerForParm();
523}
524
525HWTEST_F(TriggerUnitTest, Init_TestCheckParamTrigger_001, TestSize.Level0)
526{
527    TriggerUnitTest test;
528    test.TestCheckParamTrigger1();
529}
530
531HWTEST_F(TriggerUnitTest, Init_TestCheckParamTrigger_002, TestSize.Level0)
532{
533    TriggerUnitTest test;
534    test.TestCheckParamTrigger2();
535}
536
537HWTEST_F(TriggerUnitTest, Init_TestCheckParamTrigger_003, TestSize.Level0)
538{
539    TriggerUnitTest test;
540    test.TestCheckParamTrigger3();
541}
542
543HWTEST_F(TriggerUnitTest, Init_TestCheckParamTrigger_004, TestSize.Level0)
544{
545    TriggerUnitTest test;
546    test.TestCheckParamTrigger4();
547}
548
549HWTEST_F(TriggerUnitTest, Init_TestCheckParamTrigger_005, TestSize.Level0)
550{
551    TriggerUnitTest test;
552    test.TestCheckParamTrigger5();
553}
554
555HWTEST_F(TriggerUnitTest, Init_TestParamEvent_001, TestSize.Level0)
556{
557    TriggerUnitTest test;
558    test.TestParamEvent();
559}
560
561HWTEST_F(TriggerUnitTest, Init_TestComputerCondition_001, TestSize.Level0)
562{
563    TriggerUnitTest test;
564    test.TestComputeCondition("aaa=111||aaa=222||aaa=333");
565    test.TestComputeCondition("aaa=111||aaa=222&&aaa=333");
566    test.TestComputeCondition("(aaa=111||aaa=222)&&aaa=333");
567    test.TestComputeCondition("aaa=111||(aaa=222&&aaa=333)");
568}
569
570HWTEST_F(TriggerUnitTest, Init_TestExecuteParamTrigger_001, TestSize.Level0)
571{
572    TriggerUnitTest test;
573    test.TestExecuteParamTrigger1();
574}
575
576HWTEST_F(TriggerUnitTest, Init_TestExecuteParamTrigger_002, TestSize.Level0)
577{
578    TriggerUnitTest test;
579    test.TestExecuteParamTrigger2();
580}
581
582HWTEST_F(TriggerUnitTest, Init_TestExecuteParamTrigger_003, TestSize.Level0)
583{
584    TriggerUnitTest test;
585    test.TestExecuteParamTrigger3();
586}
587
588HWTEST_F(TriggerUnitTest, Init_TestExecuteParamTrigger_004, TestSize.Level0)
589{
590    TriggerUnitTest test;
591    test.TestExecuteParamTrigger4();
592}
593
594HWTEST_F(TriggerUnitTest, Init_TestExecuteParamTrigger_005, TestSize.Level0)
595{
596    TriggerUnitTest test;
597    test.TestExecuteParamTrigger5();
598}
599
600HWTEST_F(TriggerUnitTest, Init_TestExecuteParamTrigger_006, TestSize.Level0)
601{
602    TriggerUnitTest test;
603    test.TestDumpTrigger();
604
605}
606