1 /*
2 * Copyright (c) 2021-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 #include <gtest/gtest.h>
17 #define private public
18 #include "event_report.h"
19 #undef private
20
21 using namespace testing;
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace AAFwk {
26 class EventReportTest : public testing::Test {
27 public:
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
30 void SetUp() override;
31 void TearDown() override;
32 };
33
SetUpTestCase(void)34 void EventReportTest::SetUpTestCase(void)
35 {}
TearDownTestCase(void)36 void EventReportTest::TearDownTestCase(void)
37 {}
SetUp()38 void EventReportTest::SetUp()
39 {}
TearDown()40 void EventReportTest::TearDown()
41 {}
42
43 /**
44 * @tc.name: SendAppEvent_0100
45 * @tc.desc: Check SendAppEvent Test
46 * @tc.type: FUNC
47 * @tc.require: issueI67H0J
48 */
49 HWTEST_F(EventReportTest, SendAppEvent_0100, TestSize.Level0)
50 {
51 EventName eventName = static_cast<EventName>(-1);
52 EXPECT_EQ(EventReport::ConvertEventName(eventName), "INVALIDEVENTNAME");
53 HiSysEventType type = HiSysEventType::BEHAVIOR;
54 EventInfo eventInfo;
55 EventReport::SendAppEvent(eventName, type, eventInfo);
56 }
57
58 /**
59 * @tc.name: SendAppEvent_0200
60 * @tc.desc: Check SendAppEvent Test
61 * @tc.type: FUNC
62 * @tc.require: issueI6HXXS
63 */
64 HWTEST_F(EventReportTest, SendAppEvent_0200, TestSize.Level0)
65 {
66 EventName eventName = EventName::PROCESS_START;
67 EXPECT_EQ(EventReport::ConvertEventName(eventName), "PROCESS_START");
68 HiSysEventType type = HiSysEventType::BEHAVIOR;
69 EventInfo eventInfo;
70 EventReport::SendAppEvent(eventName, type, eventInfo);
71 }
72
73 /**
74 * @tc.name: SendAppEvent_0300
75 * @tc.desc: Check SendAppEvent Test
76 * @tc.type: FUNC
77 * @tc.require: issueI6HXXS
78 */
79 HWTEST_F(EventReportTest, SendAppEvent_0300, TestSize.Level0)
80 {
81 EventName eventName = EventName::PROCESS_START;
82 EXPECT_EQ(EventReport::ConvertEventName(eventName), "PROCESS_START");
83 HiSysEventType type = HiSysEventType::BEHAVIOR;
84 EventInfo eventInfo;
85 eventInfo.extensionType = 0;
86 EventReport::SendAppEvent(eventName, type, eventInfo);
87 }
88
89 /**
90 * @tc.name: SendAppEvent_0400
91 * @tc.desc: Check SendAppEvent Test
92 * @tc.type: FUNC
93 * @tc.require: issueI6HXXS
94 */
95 HWTEST_F(EventReportTest, SendAppEvent_0400, TestSize.Level0)
96 {
97 EventName eventName = EventName::PROCESS_EXIT;
98 EXPECT_EQ(EventReport::ConvertEventName(eventName), "PROCESS_EXIT");
99 HiSysEventType type = HiSysEventType::BEHAVIOR;
100 EventInfo eventInfo;
101 EventReport::SendAppEvent(eventName, type, eventInfo);
102 }
103
104 /**
105 * @tc.name: SendAppEvent_0500
106 * @tc.desc: Check SendAppEvent Test
107 * @tc.type: FUNC
108 * @tc.require: issueI67H0J
109 */
110 HWTEST_F(EventReportTest, SendAppEvent_0500, TestSize.Level0)
111 {
112 EventName eventName = EventName::APP_ATTACH;
113 EXPECT_EQ(EventReport::ConvertEventName(eventName), "APP_ATTACH");
114 HiSysEventType type = HiSysEventType::BEHAVIOR;
115 EventInfo eventInfo;
116 EventReport::SendAppEvent(eventName, type, eventInfo);
117 }
118
119 /**
120 * @tc.name: SendAbilityEvent_0100
121 * @tc.desc: Check SendAbilityEvent Test
122 * @tc.type: FUNC
123 * @tc.require: issueI67H0J
124 */
125 HWTEST_F(EventReportTest, SendAbilityEvent_0100, TestSize.Level0)
126 {
127 EventName eventName = static_cast<EventName>(-1);
128 EXPECT_EQ(EventReport::ConvertEventName(eventName), "INVALIDEVENTNAME");
129 HiSysEventType type = HiSysEventType::BEHAVIOR;
130 EventInfo eventInfo;
131 EventReport::SendAbilityEvent(eventName, type, eventInfo);
132 }
133
134 /**
135 * @tc.name: SendAbilityEvent_0200
136 * @tc.desc: Check SendAbilityEvent Test
137 * @tc.type: FUNC
138 * @tc.require: issueI67H0J
139 */
140 HWTEST_F(EventReportTest, SendAbilityEvent_0200, TestSize.Level0)
141 {
142 EventName eventName = EventName::START_ABILITY_ERROR;
143 EXPECT_EQ(EventReport::ConvertEventName(eventName), "START_ABILITY_ERROR");
144 HiSysEventType type = HiSysEventType::FAULT;
145 EventInfo eventInfo;
146 EventReport::SendAbilityEvent(eventName, type, eventInfo);
147 }
148
149 /**
150 * @tc.name: SendAbilityEvent_0300
151 * @tc.desc: Check SendAbilityEvent Test
152 * @tc.type: FUNC
153 * @tc.require: issueI67H0J
154 */
155 HWTEST_F(EventReportTest, SendAbilityEvent_0300, TestSize.Level0)
156 {
157 EventName eventName = EventName::TERMINATE_ABILITY_ERROR;
158 EXPECT_EQ(EventReport::ConvertEventName(eventName), "TERMINATE_ABILITY_ERROR");
159 HiSysEventType type = HiSysEventType::FAULT;
160 EventInfo eventInfo;
161 EventReport::SendAbilityEvent(eventName, type, eventInfo);
162 }
163
164 /**
165 * @tc.name: SendAbilityEvent_0400
166 * @tc.desc: Check SendAbilityEvent Test
167 * @tc.type: FUNC
168 * @tc.require: issueI67H0J
169 */
170 HWTEST_F(EventReportTest, SendAbilityEvent_0400, TestSize.Level0)
171 {
172 EventName eventName = EventName::START_ABILITY;
173 EXPECT_EQ(EventReport::ConvertEventName(eventName), "START_ABILITY");
174 HiSysEventType type = HiSysEventType::BEHAVIOR;
175 EventInfo eventInfo;
176 EventReport::SendAbilityEvent(eventName, type, eventInfo);
177 }
178
179 /**
180 * @tc.name: SendAbilityEvent_0500
181 * @tc.desc: Check SendAbilityEvent Test
182 * @tc.type: FUNC
183 * @tc.require: issueI67H0J
184 */
185 HWTEST_F(EventReportTest, SendAbilityEvent_0500, TestSize.Level0)
186 {
187 EventName eventName = EventName::TERMINATE_ABILITY;
188 EXPECT_EQ(EventReport::ConvertEventName(eventName), "TERMINATE_ABILITY");
189 HiSysEventType type = HiSysEventType::BEHAVIOR;
190 EventInfo eventInfo;
191 EventReport::SendAbilityEvent(eventName, type, eventInfo);
192 }
193
194 /**
195 * @tc.name: SendAbilityEvent_0600
196 * @tc.desc: Check SendAbilityEvent Test
197 * @tc.type: FUNC
198 * @tc.require: issueI67H0J
199 */
200 HWTEST_F(EventReportTest, SendAbilityEvent_0600, TestSize.Level0)
201 {
202 EventName eventName = EventName::CLOSE_ABILITY;
203 EXPECT_EQ(EventReport::ConvertEventName(eventName), "CLOSE_ABILITY");
204 HiSysEventType type = HiSysEventType::BEHAVIOR;
205 EventInfo eventInfo;
206 EventReport::SendAbilityEvent(eventName, type, eventInfo);
207 }
208
209 /**
210 * @tc.name: SendAbilityEvent_0700
211 * @tc.desc: Check SendAbilityEvent Test
212 * @tc.type: FUNC
213 * @tc.require: issueI67H0J
214 */
215 HWTEST_F(EventReportTest, SendAbilityEvent_0700, TestSize.Level0)
216 {
217 EventName eventName = EventName::ABILITY_ONFOREGROUND;
218 EXPECT_EQ(EventReport::ConvertEventName(eventName), "ABILITY_ONFOREGROUND");
219 HiSysEventType type = HiSysEventType::BEHAVIOR;
220 EventInfo eventInfo;
221 EventReport::SendAbilityEvent(eventName, type, eventInfo);
222 }
223
224 /**
225 * @tc.name: SendAbilityEvent_0800
226 * @tc.desc: Check SendAbilityEvent Test
227 * @tc.type: FUNC
228 * @tc.require: issueI67H0J
229 */
230 HWTEST_F(EventReportTest, SendAbilityEvent_0800, TestSize.Level0)
231 {
232 EventName eventName = EventName::ABILITY_ONBACKGROUND;
233 EXPECT_EQ(EventReport::ConvertEventName(eventName), "ABILITY_ONBACKGROUND");
234 HiSysEventType type = HiSysEventType::BEHAVIOR;
235 EventInfo eventInfo;
236 EventReport::SendAbilityEvent(eventName, type, eventInfo);
237 }
238
239 /**
240 * @tc.name: SendAbilityEvent_0900
241 * @tc.desc: Check SendAbilityEvent Test
242 * @tc.type: FUNC
243 * @tc.require: issueI67H0J
244 */
245 HWTEST_F(EventReportTest, SendAbilityEvent_0900, TestSize.Level0)
246 {
247 EventName eventName = EventName::ABILITY_ONACTIVE;
248 std::string name = "ABILITY_ONACTIVE";
249 EXPECT_EQ(EventReport::ConvertEventName(eventName), name);
250 HiSysEventType type = HiSysEventType::BEHAVIOR;
251 EventInfo eventInfo;
252 EventReport::SendAbilityEvent(eventName, type, eventInfo);
253 }
254
255 /**
256 * @tc.name: SendAbilityEvent_1000
257 * @tc.desc: Check SendAbilityEvent Test
258 * @tc.type: FUNC
259 * @tc.require: issueI6A12D
260 */
261 HWTEST_F(EventReportTest, SendAbilityEvent_1000, TestSize.Level0)
262 {
263 EventName eventName = EventName::ABILITY_ONINACTIVE;
264 std::string name = "ABILITY_ONINACTIVE";
265 EXPECT_EQ(EventReport::ConvertEventName(eventName), name);
266 HiSysEventType type = HiSysEventType::BEHAVIOR;
267 EventInfo eventInfo;
268 EventReport::SendAbilityEvent(eventName, type, eventInfo);
269 }
270
271 /**
272 * @tc.name: SendAbilityEvent_1100
273 * @tc.desc: Check SendAbilityEvent Test
274 * @tc.type: FUNC
275 * @tc.require: issueI67H0J
276 */
277 HWTEST_F(EventReportTest, SendAbilityEvent_1100, TestSize.Level0)
278 {
279 EventName eventName = EventName::DISCONNECT_SERVICE;
280 std::string name = "DISCONNECT_SERVICE";
281 EXPECT_EQ(EventReport::ConvertEventName(eventName), name);
282 HiSysEventType type = HiSysEventType::BEHAVIOR;
283 EventInfo eventInfo;
284 EventReport::SendAbilityEvent(eventName, type, eventInfo);
285 }
286
287 /**
288 * @tc.name: SendExtensionEvent_0100
289 * @tc.desc: Check SendExtensionEvent Test
290 * @tc.type: FUNC
291 * @tc.require: issueI67H0J
292 */
293 HWTEST_F(EventReportTest, SendExtensionEvent_0100, TestSize.Level0)
294 {
295 EventName eventName = static_cast<EventName>(-1);
296 EXPECT_EQ(EventReport::ConvertEventName(eventName), "INVALIDEVENTNAME");
297 HiSysEventType type = HiSysEventType::BEHAVIOR;
298 EventInfo eventInfo;
299 EventReport::SendExtensionEvent(eventName, type, eventInfo);
300 }
301
302 /**
303 * @tc.name: SendExtensionEvent_0200
304 * @tc.desc: Check SendExtensionEvent Test
305 * @tc.type: FUNC
306 * @tc.require: issueI67H0J
307 */
308 HWTEST_F(EventReportTest, SendExtensionEvent_0200, TestSize.Level0)
309 {
310 EventName eventName = EventName::DISCONNECT_SERVICE;
311 EXPECT_EQ(EventReport::ConvertEventName(eventName), "DISCONNECT_SERVICE");
312 HiSysEventType type = HiSysEventType::BEHAVIOR;
313 EventInfo eventInfo;
314 EventReport::SendExtensionEvent(eventName, type, eventInfo);
315 }
316
317 /**
318 * @tc.name: SendExtensionEvent_0300
319 * @tc.desc: Check SendExtensionEvent Test
320 * @tc.type: FUNC
321 * @tc.require: issueI67H0J
322 */
323 HWTEST_F(EventReportTest, SendExtensionEvent_0300, TestSize.Level0)
324 {
325 EventName eventName = EventName::CONNECT_SERVICE;
326 EXPECT_EQ(EventReport::ConvertEventName(eventName), "CONNECT_SERVICE");
327 HiSysEventType type = HiSysEventType::BEHAVIOR;
328 EventInfo eventInfo;
329 EventReport::SendExtensionEvent(eventName, type, eventInfo);
330 }
331
332 /**
333 * @tc.name: SendExtensionEvent_0400
334 * @tc.desc: Check SendExtensionEvent Test
335 * @tc.type: FUNC
336 * @tc.require: issueI67H0J
337 */
338 HWTEST_F(EventReportTest, SendExtensionEvent_0400, TestSize.Level0)
339 {
340 EventName eventName = EventName::START_SERVICE;
341 EXPECT_EQ(EventReport::ConvertEventName(eventName), "START_SERVICE");
342 HiSysEventType type = HiSysEventType::BEHAVIOR;
343 EventInfo eventInfo;
344 EventReport::SendExtensionEvent(eventName, type, eventInfo);
345 }
346
347 /**
348 * @tc.name: SendExtensionEvent_0500
349 * @tc.desc: Check SendExtensionEvent Test
350 * @tc.type: FUNC
351 * @tc.require: issueI67H0J
352 */
353 HWTEST_F(EventReportTest, SendExtensionEvent_0500, TestSize.Level0)
354 {
355 EventName eventName = EventName::STOP_SERVICE;
356 EXPECT_EQ(EventReport::ConvertEventName(eventName), "STOP_SERVICE");
357 HiSysEventType type = HiSysEventType::BEHAVIOR;
358 EventInfo eventInfo;
359 EventReport::SendExtensionEvent(eventName, type, eventInfo);
360 }
361
362 /**
363 * @tc.name: SendExtensionEvent_0600
364 * @tc.desc: Check SendExtensionEvent Test
365 * @tc.type: FUNC
366 * @tc.require: issueI67H0J
367 */
368 HWTEST_F(EventReportTest, SendExtensionEvent_0600, TestSize.Level0)
369 {
370 EventName eventName = EventName::START_EXTENSION_ERROR;
371 EXPECT_EQ(EventReport::ConvertEventName(eventName), "START_EXTENSION_ERROR");
372 HiSysEventType type = HiSysEventType::FAULT;
373 EventInfo eventInfo;
374 EventReport::SendExtensionEvent(eventName, type, eventInfo);
375 }
376
377 /**
378 * @tc.name: SendExtensionEvent_0700
379 * @tc.desc: Check SendExtensionEvent Test
380 * @tc.type: FUNC
381 * @tc.require: issueI67H0J
382 */
383 HWTEST_F(EventReportTest, SendExtensionEvent_0700, TestSize.Level0)
384 {
385 EventName eventName = EventName::STOP_EXTENSION_ERROR;
386 EXPECT_EQ(EventReport::ConvertEventName(eventName), "STOP_EXTENSION_ERROR");
387 HiSysEventType type = HiSysEventType::FAULT;
388 EventInfo eventInfo;
389 EventReport::SendExtensionEvent(eventName, type, eventInfo);
390 }
391
392 /**
393 * @tc.name: SendExtensionEvent_0800
394 * @tc.desc: Check SendExtensionEvent Test
395 * @tc.type: FUNC
396 * @tc.require: issueI67H0J
397 */
398 HWTEST_F(EventReportTest, SendExtensionEvent_0800, TestSize.Level0)
399 {
400 EventName eventName = EventName::CONNECT_SERVICE_ERROR;
401 EXPECT_EQ(EventReport::ConvertEventName(eventName), "CONNECT_SERVICE_ERROR");
402 HiSysEventType type = HiSysEventType::FAULT;
403 EventInfo eventInfo;
404 EventReport::SendExtensionEvent(eventName, type, eventInfo);
405 }
406
407 /**
408 * @tc.name: SendExtensionEvent_0900
409 * @tc.desc: Check SendExtensionEvent Test
410 * @tc.type: FUNC
411 * @tc.require: issueI67H0J
412 */
413 HWTEST_F(EventReportTest, SendExtensionEvent_0900, TestSize.Level0)
414 {
415 EventName eventName = EventName::DISCONNECT_SERVICE_ERROR;
416 EXPECT_EQ(EventReport::ConvertEventName(eventName), "DISCONNECT_SERVICE_ERROR");
417 HiSysEventType type = HiSysEventType::FAULT;
418 EventInfo eventInfo;
419 EventReport::SendExtensionEvent(eventName, type, eventInfo);
420 }
421 } // namespace AAFwk
422 } // namespace OHOS
423