1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #define private public
17 #define protected public
18
19 #include "gtest/gtest.h"
20 #include "cellular_call_data_struct.h"
21 #include "call_manager_inner_type.h"
22 #include "mmi_code_message.h"
23
24
25 namespace OHOS {
26 namespace Telephony {
27 using namespace testing::ext;
28 class MmiCodeMessageTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp();
33 void TearDown();
34 };
SetUpTestCase()35 void MmiCodeMessageTest::SetUpTestCase() {}
36
TearDownTestCase()37 void MmiCodeMessageTest::TearDownTestCase() {}
38
SetUp()39 void MmiCodeMessageTest::SetUp() {}
40
TearDown()41 void MmiCodeMessageTest::TearDown() {}
42
43 /**
44 * @tc.number Telephony_MmiCodeMessageTest_0001
45 * @tc.name Test MmiCodeMessage CreateGetCallWaitingResultMessage
46 * @tc.desc Function test
47 */
48 HWTEST_F(MmiCodeMessageTest, MmiCodeMessageTest_0001, Function | MediumTest | Level1)
49 {
50 CallWaitResponse response;
51 std::string resultMessage;
52 std::string compareMessage;
53 compareMessage.append("\n");
54 compareMessage.append(SERVICE_DISABLE);
55 CreateGetCallWaitingResultMessage(resultMessage, response);
56 EXPECT_EQ(resultMessage, compareMessage);
57
58 response.status = 1;
59 response.classCw = ServiceClassType::VOICE;
60 resultMessage = "";
61 compareMessage = "";
62 compareMessage.append("\n");
63 compareMessage.append(SERVICE_ENABLE_FOR);
64 compareMessage.append("\nVoice");
65 CreateGetCallWaitingResultMessage(resultMessage, response);
66 EXPECT_EQ(resultMessage, compareMessage);
67
68 response.classCw = ServiceClassType::FAX;
69 resultMessage = "";
70 compareMessage = "";
71 compareMessage.append("\n");
72 compareMessage.append(SERVICE_ENABLE_FOR);
73 compareMessage.append("\nFax");
74 CreateGetCallWaitingResultMessage(resultMessage, response);
75 EXPECT_EQ(resultMessage, compareMessage);
76
77 response.classCw = ServiceClassType::SHORT_MESSAGE_SERVICE;
78 resultMessage = "";
79 compareMessage = "";
80 compareMessage.append("\n");
81 compareMessage.append(SERVICE_ENABLE_FOR);
82 compareMessage.append("\nMessage");
83 CreateGetCallWaitingResultMessage(resultMessage, response);
84 EXPECT_EQ(resultMessage, compareMessage);
85
86 response.classCw = ServiceClassType::DATA_CIRCUIT_SYNC;
87 resultMessage = "";
88 compareMessage = "";
89 compareMessage.append("\n");
90 compareMessage.append(SERVICE_ENABLE_FOR);
91 compareMessage.append("\nSync");
92 CreateGetCallWaitingResultMessage(resultMessage, response);
93 EXPECT_EQ(resultMessage, compareMessage);
94 }
95
96 /**
97 * @tc.number Telephony_MmiCodeMessageTest_0002
98 * @tc.name Test MmiCodeMessage CreateGetCallWaitingResultMessage
99 * @tc.desc Function test
100 */
101 HWTEST_F(MmiCodeMessageTest, MmiCodeMessageTest_0002, Function | MediumTest | Level1)
102 {
103 CallWaitResponse response;
104 std::string resultMessage;
105 std::string compareMessage;
106
107 response.status = 1;
108 response.classCw = ServiceClassType::DATA_CIRCUIT_ASYNC;
109 resultMessage = "";
110 compareMessage = "";
111 compareMessage.append("\n");
112 compareMessage.append(SERVICE_ENABLE_FOR);
113 compareMessage.append("\nAsync");
114 CreateGetCallWaitingResultMessage(resultMessage, response);
115 EXPECT_EQ(resultMessage, compareMessage);
116
117 response.classCw = ServiceClassType::DEDICATED_PACKET_ACCESS;
118 resultMessage = "";
119 compareMessage = "";
120 compareMessage.append("\n");
121 compareMessage.append(SERVICE_ENABLE_FOR);
122 compareMessage.append("\nPackage");
123 CreateGetCallWaitingResultMessage(resultMessage, response);
124 EXPECT_EQ(resultMessage, compareMessage);
125
126 response.classCw = ServiceClassType::DEDICATED_PAD_ACCESS;
127 resultMessage = "";
128 compareMessage = "";
129 compareMessage.append("\n");
130 compareMessage.append(SERVICE_ENABLE_FOR);
131 compareMessage.append("\nPad");
132 CreateGetCallWaitingResultMessage(resultMessage, response);
133 EXPECT_EQ(resultMessage, compareMessage);
134
135 response.classCw = 256;
136 resultMessage = "";
137 compareMessage = "\nService was enabled for:";
138 CreateGetCallWaitingResultMessage(resultMessage, response);
139 EXPECT_EQ(resultMessage, compareMessage);
140 }
141
142 /**
143 * @tc.number Telephony_MmiCodeMessageTest_0003
144 * @tc.name Test MmiCodeMessage GetServiceClassName
145 * @tc.desc Function test
146 */
147 HWTEST_F(MmiCodeMessageTest, MmiCodeMessageTest_0003, Function | MediumTest | Level1)
148 {
149 int32_t classex;
150 classex = ServiceClassType::VOICE;
151 EXPECT_EQ(GetServiceClassName(classex), "Voice");
152
153 classex = ServiceClassType::FAX;
154 EXPECT_EQ(GetServiceClassName(classex), "Fax");
155
156 classex = ServiceClassType::SHORT_MESSAGE_SERVICE;
157 EXPECT_EQ(GetServiceClassName(classex), "Message");
158
159 classex = ServiceClassType::DATA_CIRCUIT_SYNC;
160 EXPECT_EQ(GetServiceClassName(classex), "Sync");
161
162 classex = ServiceClassType::DATA_CIRCUIT_ASYNC;
163 EXPECT_EQ(GetServiceClassName(classex), "Async");
164
165 classex = ServiceClassType::DEDICATED_PACKET_ACCESS;
166 EXPECT_EQ(GetServiceClassName(classex), "Package");
167
168 classex = ServiceClassType::DEDICATED_PAD_ACCESS;
169 EXPECT_EQ(GetServiceClassName(classex), "Pad");
170
171 classex = 256;
172 EXPECT_EQ(GetServiceClassName(classex), "Unknow");
173 }
174
175 /**
176 * @tc.number Telephony_MmiCodeMessageTest_0004
177 * @tc.name Test MmiCodeMessage CreateServiceClassMessage
178 * @tc.desc Function test
179 */
180 HWTEST_F(MmiCodeMessageTest, MmiCodeMessageTest_0004, Function | MediumTest | Level1)
181 {
182 std::string resultMessage;
183 int32_t classex = ServiceClassType::VOICE;
184 CreateServiceClassMessage(resultMessage, classex);
185 EXPECT_EQ(resultMessage, "\nVoice");
186
187 classex = ServiceClassType::FAX;
188 resultMessage = "";
189 CreateServiceClassMessage(resultMessage, classex);
190 EXPECT_EQ(resultMessage, "\nFax");
191
192 classex = ServiceClassType::SHORT_MESSAGE_SERVICE;
193 resultMessage = "";
194 CreateServiceClassMessage(resultMessage, classex);
195 EXPECT_EQ(resultMessage, "\nMessage");
196
197 classex = ServiceClassType::DATA_CIRCUIT_SYNC;
198 resultMessage = "";
199 CreateServiceClassMessage(resultMessage, classex);
200 EXPECT_EQ(resultMessage, "\nSync");
201
202 classex = ServiceClassType::DATA_CIRCUIT_ASYNC;
203 resultMessage = "";
204 CreateServiceClassMessage(resultMessage, classex);
205 EXPECT_EQ(resultMessage, "\nAsync");
206
207 classex = ServiceClassType::DEDICATED_PACKET_ACCESS;
208 resultMessage = "";
209 CreateServiceClassMessage(resultMessage, classex);
210 EXPECT_EQ(resultMessage, "\nPackage");
211
212 classex = ServiceClassType::DEDICATED_PAD_ACCESS;
213 resultMessage = "";
214 CreateServiceClassMessage(resultMessage, classex);
215 EXPECT_EQ(resultMessage, "\nPad");
216
217 classex = 256;
218 resultMessage = "";
219 CreateServiceClassMessage(resultMessage, classex);
220 EXPECT_EQ(resultMessage, "");
221 }
222
223 /**
224 * @tc.number Telephony_MmiCodeMessageTest_0005
225 * @tc.name Test MmiCodeMessage CreateSuppSvcQueryResultMessage
226 * @tc.desc Function test
227 */
228 HWTEST_F(MmiCodeMessageTest, MmiCodeMessageTest_0005, Function | MediumTest | Level1)
229 {
230 std::string resultMessage;
231 int32_t result = TELEPHONY_SUCCESS;
232 int32_t status = SS_DISABLED;
233 std::string compareMessage;
234 compareMessage.append("\n");
235 compareMessage.append(SERVICE_DISABLE);
236 CreateSuppSvcQueryResultMessage(resultMessage, result, status);
237 EXPECT_EQ(resultMessage, compareMessage);
238
239 status = SS_ENABLED;
240 resultMessage = "";
241 compareMessage = "";
242 compareMessage.append("\n");
243 compareMessage.append(SERVICE_ENABLE);
244 CreateSuppSvcQueryResultMessage(resultMessage, result, status);
245 EXPECT_EQ(resultMessage, compareMessage);
246
247 result = TELEPHONY_ERROR;
248 resultMessage = "";
249 compareMessage = "";
250 CreateSuppSvcQueryResultMessage(resultMessage, result, status);
251 EXPECT_EQ(resultMessage, compareMessage);
252 }
253
254 /**
255 * @tc.number Telephony_MmiCodeMessageTest_0006
256 * @tc.name Test MmiCodeMessage CreateGetCallTransferResultMessage
257 * @tc.desc Function test
258 */
259 HWTEST_F(MmiCodeMessageTest, MmiCodeMessageTest_0006, Function | MediumTest | Level1)
260 {
261 std::string resultMessage;
262 std::string compareMessage;
263 CallTransferResponse response;
264
265 response.classx = ServiceClassType::VOICE;
266 response.result = TELEPHONY_ERROR;
267 CreateGetCallTransferResultMessage(resultMessage, response);
268 EXPECT_EQ(resultMessage, compareMessage);
269
270 response.result = TELEPHONY_SUCCESS;
271 resultMessage = "";
272 compareMessage = "\nVoice: Not forwarded";
273 CreateGetCallTransferResultMessage(resultMessage, response);
274 EXPECT_EQ(resultMessage, compareMessage);
275
276 response.classx = ServiceClassType::FAX;
277 compareMessage = "\nFax: Not forwarded";
278 resultMessage = "";
279 CreateGetCallTransferResultMessage(resultMessage, response);
280 EXPECT_EQ(resultMessage, compareMessage);
281
282 response.classx = ServiceClassType::SHORT_MESSAGE_SERVICE;
283 compareMessage = "\nMessage: Not forwarded";
284 resultMessage = "";
285 CreateGetCallTransferResultMessage(resultMessage, response);
286 EXPECT_EQ(resultMessage, compareMessage);
287
288 response.classx = ServiceClassType::DATA_CIRCUIT_SYNC;
289 compareMessage = "\nSync: Not forwarded";
290 resultMessage = "";
291 CreateGetCallTransferResultMessage(resultMessage, response);
292 EXPECT_EQ(resultMessage, compareMessage);
293
294 response.classx = ServiceClassType::DATA_CIRCUIT_ASYNC;
295 compareMessage = "\nAsync: Not forwarded";
296 resultMessage = "";
297 CreateGetCallTransferResultMessage(resultMessage, response);
298 EXPECT_EQ(resultMessage, compareMessage);
299 }
300
301 /**
302 * @tc.number Telephony_MmiCodeMessageTest_0007
303 * @tc.name Test MmiCodeMessage CreateGetCallTransferResultMessage
304 * @tc.desc Function test
305 */
306 HWTEST_F(MmiCodeMessageTest, MmiCodeMessageTest_0007, Function | MediumTest | Level1)
307 {
308 std::string resultMessage;
309 CallTransferResponse response;
310
311 response.classx = ServiceClassType::DEDICATED_PACKET_ACCESS;
312 std::string compareMessage = "\nPackage: Not forwarded";
313 CreateGetCallTransferResultMessage(resultMessage, response);
314 EXPECT_EQ(resultMessage, compareMessage);
315
316 response.classx = ServiceClassType::DEDICATED_PAD_ACCESS;
317 compareMessage = "\nPad: Not forwarded";
318 resultMessage = "";
319 CreateGetCallTransferResultMessage(resultMessage, response);
320 EXPECT_EQ(resultMessage, compareMessage);
321
322 response.classx = 256;
323 compareMessage = "\n";
324 resultMessage = "";
325 CreateGetCallTransferResultMessage(resultMessage, response);
326 EXPECT_EQ(resultMessage, compareMessage);
327 }
328
329 /**
330 * @tc.number Telephony_MmiCodeMessageTest_0008
331 * @tc.name Test MmiCodeMessage MakeCallTransferMessageEx
332 * @tc.desc Function test
333 */
334 HWTEST_F(MmiCodeMessageTest, MmiCodeMessageTest_0008, Function | MediumTest | Level1)
335 {
336 std::string resultMessage;
337 CallTransferResponse response;
338 response.status = SS_ENABLED;
339
340 int32_t classex = ServiceClassType::VOICE;
341 MakeCallTransferMessageEx(resultMessage, response, classex);
342 EXPECT_EQ(resultMessage, "Voice: ");
343
344 classex = ServiceClassType::FAX;
345 resultMessage = "";
346 MakeCallTransferMessageEx(resultMessage, response, classex);
347 EXPECT_EQ(resultMessage, "Fax: ");
348
349 classex = ServiceClassType::SHORT_MESSAGE_SERVICE;
350 resultMessage = "";
351 MakeCallTransferMessageEx(resultMessage, response, classex);
352 EXPECT_EQ(resultMessage, "Message: ");
353
354 classex = ServiceClassType::DATA_CIRCUIT_SYNC;
355 resultMessage = "";
356 MakeCallTransferMessageEx(resultMessage, response, classex);
357 EXPECT_EQ(resultMessage, "Sync: ");
358
359 classex = ServiceClassType::DATA_CIRCUIT_ASYNC;
360 resultMessage = "";
361 MakeCallTransferMessageEx(resultMessage, response, classex);
362 EXPECT_EQ(resultMessage, "Async: ");
363
364 classex = ServiceClassType::DEDICATED_PACKET_ACCESS;
365 resultMessage = "";
366 MakeCallTransferMessageEx(resultMessage, response, classex);
367 EXPECT_EQ(resultMessage, "Package: ");
368
369 classex = ServiceClassType::DEDICATED_PAD_ACCESS;
370 resultMessage = "";
371 MakeCallTransferMessageEx(resultMessage, response, classex);
372 EXPECT_EQ(resultMessage, "Pad: ");
373
374 classex = 256;
375 resultMessage = "";
376 MakeCallTransferMessageEx(resultMessage, response, classex);
377 EXPECT_EQ(resultMessage, "Unknow: ");
378 }
379
380 /**
381 * @tc.number Telephony_MmiCodeMessageTest_0009
382 * @tc.name Test MmiCodeMessage MakeCallTransferMessageEx
383 * @tc.desc Function test
384 */
385 HWTEST_F(MmiCodeMessageTest, MmiCodeMessageTest_0009, Function | MediumTest | Level1)
386 {
387 std::string resultMessage;
388 CallTransferResponse response;
389 response.status = SS_ENABLED;
390 response.reason = TRANSFER_REASON_TYPE_NO_REPLY;
391
392 int32_t classex = ServiceClassType::VOICE;
393 MakeCallTransferMessageEx(resultMessage, response, classex);
394 EXPECT_EQ(resultMessage, "Voice: after 0 seconds");
395
396 classex = ServiceClassType::FAX;
397 resultMessage = "";
398 MakeCallTransferMessageEx(resultMessage, response, classex);
399 EXPECT_EQ(resultMessage, "Fax: after 0 seconds");
400
401 classex = ServiceClassType::SHORT_MESSAGE_SERVICE;
402 resultMessage = "";
403 MakeCallTransferMessageEx(resultMessage, response, classex);
404 EXPECT_EQ(resultMessage, "Message: after 0 seconds");
405
406 classex = ServiceClassType::DATA_CIRCUIT_SYNC;
407 resultMessage = "";
408 MakeCallTransferMessageEx(resultMessage, response, classex);
409 EXPECT_EQ(resultMessage, "Sync: after 0 seconds");
410
411 classex = ServiceClassType::DATA_CIRCUIT_ASYNC;
412 resultMessage = "";
413 MakeCallTransferMessageEx(resultMessage, response, classex);
414 EXPECT_EQ(resultMessage, "Async: after 0 seconds");
415
416 classex = ServiceClassType::DEDICATED_PACKET_ACCESS;
417 resultMessage = "";
418 MakeCallTransferMessageEx(resultMessage, response, classex);
419 EXPECT_EQ(resultMessage, "Package: after 0 seconds");
420
421 classex = ServiceClassType::DEDICATED_PAD_ACCESS;
422 resultMessage = "";
423 MakeCallTransferMessageEx(resultMessage, response, classex);
424 EXPECT_EQ(resultMessage, "Pad: after 0 seconds");
425
426 classex = 256;
427 resultMessage = "";
428 MakeCallTransferMessageEx(resultMessage, response, classex);
429 EXPECT_EQ(resultMessage, "Unknow: after 0 seconds");
430 }
431
432 /**
433 * @tc.number Telephony_MmiCodeMessageTest_0010
434 * @tc.name Test MmiCodeMessage MakeCallTransferMessageEx
435 * @tc.desc Function test
436 */
437 HWTEST_F(MmiCodeMessageTest, MmiCodeMessageTest_0010, Function | MediumTest | Level1)
438 {
439 std::string resultMessage;
440 CallTransferResponse response;
441 response.status = SS_DISABLED;
442
443 int32_t classex = ServiceClassType::VOICE;
444 MakeCallTransferMessageEx(resultMessage, response, classex);
445 EXPECT_EQ(resultMessage, "Voice: Not forwarded");
446
447 classex = ServiceClassType::FAX;
448 resultMessage = "";
449 MakeCallTransferMessageEx(resultMessage, response, classex);
450 EXPECT_EQ(resultMessage, "Fax: Not forwarded");
451
452 classex = ServiceClassType::SHORT_MESSAGE_SERVICE;
453 resultMessage = "";
454 MakeCallTransferMessageEx(resultMessage, response, classex);
455 EXPECT_EQ(resultMessage, "Message: Not forwarded");
456
457 classex = ServiceClassType::DATA_CIRCUIT_SYNC;
458 resultMessage = "";
459 MakeCallTransferMessageEx(resultMessage, response, classex);
460 EXPECT_EQ(resultMessage, "Sync: Not forwarded");
461
462 classex = ServiceClassType::DATA_CIRCUIT_ASYNC;
463 resultMessage = "";
464 MakeCallTransferMessageEx(resultMessage, response, classex);
465 EXPECT_EQ(resultMessage, "Async: Not forwarded");
466
467 classex = ServiceClassType::DEDICATED_PACKET_ACCESS;
468 resultMessage = "";
469 MakeCallTransferMessageEx(resultMessage, response, classex);
470 EXPECT_EQ(resultMessage, "Package: Not forwarded");
471
472 classex = ServiceClassType::DEDICATED_PAD_ACCESS;
473 resultMessage = "";
474 MakeCallTransferMessageEx(resultMessage, response, classex);
475 EXPECT_EQ(resultMessage, "Pad: Not forwarded");
476
477 classex = 256;
478 resultMessage = "";
479 MakeCallTransferMessageEx(resultMessage, response, classex);
480 EXPECT_EQ(resultMessage, "Unknow: Not forwarded");
481 }
482 } // namespace Telephony
483 } // namespace OHOS