1 /*
2 * Copyright (C) 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <aidl/android/hardware/radio/config/IRadioConfig.h>
18 #include <android/binder_manager.h>
19
20 #include "radio_messaging_utils.h"
21
22 #define ASSERT_OK(ret) ASSERT_TRUE(ret.isOk())
23
SetUp()24 void RadioMessagingTest::SetUp() {
25 RadioServiceTest::SetUp();
26 std::string serviceName = GetParam();
27
28 if (!isServiceValidForDeviceConfiguration(serviceName)) {
29 ALOGI("Skipped the test due to device configuration.");
30 GTEST_SKIP();
31 }
32
33 radio_messaging = IRadioMessaging::fromBinder(
34 ndk::SpAIBinder(AServiceManager_waitForService(GetParam().c_str())));
35 ASSERT_NE(nullptr, radio_messaging.get());
36
37 radioRsp_messaging = ndk::SharedRefBase::make<RadioMessagingResponse>(*this);
38 ASSERT_NE(nullptr, radioRsp_messaging.get());
39
40 radioInd_messaging = ndk::SharedRefBase::make<RadioMessagingIndication>(*this);
41 ASSERT_NE(nullptr, radioInd_messaging.get());
42
43 radio_messaging->setResponseFunctions(radioRsp_messaging, radioInd_messaging);
44
45 // Assert IRadioSim exists and SIM is present before testing
46 radio_sim = sim::IRadioSim::fromBinder(ndk::SpAIBinder(
47 AServiceManager_waitForService("android.hardware.radio.sim.IRadioSim/slot1")));
48 ASSERT_NE(nullptr, radio_sim.get());
49 updateSimCardStatus();
50 EXPECT_EQ(CardStatus::STATE_PRESENT, cardStatus.cardState);
51
52 // Assert IRadioConfig exists before testing
53 radio_config = config::IRadioConfig::fromBinder(ndk::SpAIBinder(
54 AServiceManager_waitForService("android.hardware.radio.config.IRadioConfig/default")));
55 ASSERT_NE(nullptr, radio_config.get());
56 }
57
58 /*
59 * Test IRadioMessaging.sendSms() for the response returned.
60 */
TEST_P(RadioMessagingTest,sendSms)61 TEST_P(RadioMessagingTest, sendSms) {
62 serial = GetRandomSerialNumber();
63 GsmSmsMessage msg;
64 msg.smscPdu = "";
65 msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
66
67 radio_messaging->sendSms(serial, msg);
68
69 EXPECT_EQ(std::cv_status::no_timeout, wait());
70 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
71 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
72
73 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
74 ASSERT_TRUE(CheckAnyOfErrors(
75 radioRsp_messaging->rspInfo.error,
76 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE, RadioError::SIM_ABSENT},
77 CHECK_GENERAL_ERROR));
78 EXPECT_EQ(0, radioRsp_messaging->sendSmsResult.errorCode);
79 }
80 }
81
82 /*
83 * Test IRadioMessaging.sendSmsExpectMore() for the response returned.
84 */
TEST_P(RadioMessagingTest,sendSmsExpectMore)85 TEST_P(RadioMessagingTest, sendSmsExpectMore) {
86 serial = GetRandomSerialNumber();
87 GsmSmsMessage msg;
88 msg.smscPdu = "";
89 msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
90
91 radio_messaging->sendSmsExpectMore(serial, msg);
92
93 EXPECT_EQ(std::cv_status::no_timeout, wait());
94 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
95 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
96
97 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
98 ASSERT_TRUE(CheckAnyOfErrors(
99 radioRsp_messaging->rspInfo.error,
100 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE, RadioError::SIM_ABSENT},
101 CHECK_GENERAL_ERROR));
102 }
103 }
104
105 /*
106 * Test IRadioMessaging.sendCdmaSms() for the response returned.
107 */
TEST_P(RadioMessagingTest,sendCdmaSms)108 TEST_P(RadioMessagingTest, sendCdmaSms) {
109 serial = GetRandomSerialNumber();
110
111 // Create a CdmaSmsAddress
112 CdmaSmsAddress cdmaSmsAddress;
113 cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
114 cdmaSmsAddress.isNumberModeDataNetwork = false;
115 cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
116 cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
117 cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
118
119 // Create a CdmaSmsSubAddress
120 CdmaSmsSubaddress cdmaSmsSubaddress;
121 cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
122 cdmaSmsSubaddress.odd = false;
123 cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
124
125 // Create a CdmaSmsMessage
126 CdmaSmsMessage cdmaSmsMessage;
127 cdmaSmsMessage.teleserviceId = 4098;
128 cdmaSmsMessage.isServicePresent = false;
129 cdmaSmsMessage.serviceCategory = 0;
130 cdmaSmsMessage.address = cdmaSmsAddress;
131 cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
132 cdmaSmsMessage.bearerData =
133 (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
134
135 radio_messaging->sendCdmaSms(serial, cdmaSmsMessage);
136
137 EXPECT_EQ(std::cv_status::no_timeout, wait());
138 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
139 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
140
141 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
142 ASSERT_TRUE(CheckAnyOfErrors(
143 radioRsp_messaging->rspInfo.error,
144 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE, RadioError::SIM_ABSENT},
145 CHECK_GENERAL_ERROR));
146 }
147 }
148
149 /*
150 * Test IRadioMessaging.sendCdmaSmsExpectMore() for the response returned.
151 */
TEST_P(RadioMessagingTest,sendCdmaSmsExpectMore)152 TEST_P(RadioMessagingTest, sendCdmaSmsExpectMore) {
153 serial = GetRandomSerialNumber();
154
155 // Create a CdmaSmsAddress
156 CdmaSmsAddress cdmaSmsAddress;
157 cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
158 cdmaSmsAddress.isNumberModeDataNetwork = false;
159 cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
160 cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
161 cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
162
163 // Create a CdmaSmsSubAddress
164 CdmaSmsSubaddress cdmaSmsSubaddress;
165 cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
166 cdmaSmsSubaddress.odd = false;
167 cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
168
169 // Create a CdmaSmsMessage
170 CdmaSmsMessage cdmaSmsMessage;
171 cdmaSmsMessage.teleserviceId = 4098;
172 cdmaSmsMessage.isServicePresent = false;
173 cdmaSmsMessage.serviceCategory = 0;
174 cdmaSmsMessage.address = cdmaSmsAddress;
175 cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
176 cdmaSmsMessage.bearerData =
177 (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
178
179 radio_messaging->sendCdmaSmsExpectMore(serial, cdmaSmsMessage);
180
181 EXPECT_EQ(std::cv_status::no_timeout, wait());
182 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
183 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
184
185 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
186 ASSERT_TRUE(CheckAnyOfErrors(
187 radioRsp_messaging->rspInfo.error,
188 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE, RadioError::SIM_ABSENT},
189 CHECK_GENERAL_ERROR));
190 }
191 }
192
193 /*
194 * Test IRadioMessaging.setGsmBroadcastConfig() for the response returned.
195 */
TEST_P(RadioMessagingTest,setGsmBroadcastConfig)196 TEST_P(RadioMessagingTest, setGsmBroadcastConfig) {
197 serial = GetRandomSerialNumber();
198
199 // Create GsmBroadcastSmsConfigInfo #1
200 GsmBroadcastSmsConfigInfo gbSmsConfig1;
201 gbSmsConfig1.fromServiceId = 4352;
202 gbSmsConfig1.toServiceId = 4354;
203 gbSmsConfig1.fromCodeScheme = 0;
204 gbSmsConfig1.toCodeScheme = 255;
205 gbSmsConfig1.selected = true;
206
207 // Create GsmBroadcastSmsConfigInfo #2
208 GsmBroadcastSmsConfigInfo gbSmsConfig2;
209 gbSmsConfig2.fromServiceId = 4356;
210 gbSmsConfig2.toServiceId = 4356;
211 gbSmsConfig2.fromCodeScheme = 0;
212 gbSmsConfig2.toCodeScheme = 255;
213 gbSmsConfig2.selected = true;
214
215 // Create GsmBroadcastSmsConfigInfo #3
216 GsmBroadcastSmsConfigInfo gbSmsConfig3;
217 gbSmsConfig3.fromServiceId = 4370;
218 gbSmsConfig3.toServiceId = 4379;
219 gbSmsConfig3.fromCodeScheme = 0;
220 gbSmsConfig3.toCodeScheme = 255;
221 gbSmsConfig3.selected = true;
222
223 // Create GsmBroadcastSmsConfigInfo #4
224 GsmBroadcastSmsConfigInfo gbSmsConfig4;
225 gbSmsConfig4.fromServiceId = 4383;
226 gbSmsConfig4.toServiceId = 4391;
227 gbSmsConfig4.fromCodeScheme = 0;
228 gbSmsConfig4.toCodeScheme = 255;
229 gbSmsConfig4.selected = true;
230
231 // Create GsmBroadcastSmsConfigInfo #5
232 GsmBroadcastSmsConfigInfo gbSmsConfig5;
233 gbSmsConfig5.fromServiceId = 4392;
234 gbSmsConfig5.toServiceId = 4392;
235 gbSmsConfig5.fromCodeScheme = 0;
236 gbSmsConfig5.toCodeScheme = 255;
237 gbSmsConfig5.selected = true;
238
239 std::vector<GsmBroadcastSmsConfigInfo> gsmBroadcastSmsConfigsInfoList = {
240 gbSmsConfig1, gbSmsConfig2, gbSmsConfig3, gbSmsConfig4, gbSmsConfig5};
241
242 radio_messaging->setGsmBroadcastConfig(serial, gsmBroadcastSmsConfigsInfoList);
243
244 EXPECT_EQ(std::cv_status::no_timeout, wait());
245 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
246 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
247
248 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
249 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
250 {RadioError::NONE, RadioError::INVALID_ARGUMENTS,
251 RadioError::INVALID_MODEM_STATE, RadioError::INVALID_STATE},
252 CHECK_GENERAL_ERROR));
253 }
254 }
255
256 /*
257 * Test IRadioMessaging.getGsmBroadcastConfig() for the response returned.
258 */
TEST_P(RadioMessagingTest,getGsmBroadcastConfig)259 TEST_P(RadioMessagingTest, getGsmBroadcastConfig) {
260 serial = GetRandomSerialNumber();
261
262 radio_messaging->getGsmBroadcastConfig(serial);
263
264 EXPECT_EQ(std::cv_status::no_timeout, wait());
265 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
266 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
267
268 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
269 ASSERT_TRUE(CheckAnyOfErrors(
270 radioRsp_messaging->rspInfo.error,
271 {RadioError::NONE, RadioError::INVALID_MODEM_STATE, RadioError::INVALID_STATE},
272 CHECK_GENERAL_ERROR));
273 }
274 }
275
276 /*
277 * Test IRadioMessaging.setCdmaBroadcastConfig() for the response returned.
278 */
TEST_P(RadioMessagingTest,setCdmaBroadcastConfig)279 TEST_P(RadioMessagingTest, setCdmaBroadcastConfig) {
280 serial = GetRandomSerialNumber();
281
282 CdmaBroadcastSmsConfigInfo cbSmsConfig;
283 cbSmsConfig.serviceCategory = 4096;
284 cbSmsConfig.language = 1;
285 cbSmsConfig.selected = true;
286
287 std::vector<CdmaBroadcastSmsConfigInfo> cdmaBroadcastSmsConfigInfoList = {cbSmsConfig};
288
289 radio_messaging->setCdmaBroadcastConfig(serial, cdmaBroadcastSmsConfigInfoList);
290
291 EXPECT_EQ(std::cv_status::no_timeout, wait());
292 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
293 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
294
295 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
296 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
297 {RadioError::NONE, RadioError::INVALID_MODEM_STATE},
298 CHECK_GENERAL_ERROR));
299 }
300 }
301
302 /*
303 * Test IRadioMessaging.getCdmaBroadcastConfig() for the response returned.
304 */
TEST_P(RadioMessagingTest,getCdmaBroadcastConfig)305 TEST_P(RadioMessagingTest, getCdmaBroadcastConfig) {
306 serial = GetRandomSerialNumber();
307
308 radio_messaging->getCdmaBroadcastConfig(serial);
309
310 EXPECT_EQ(std::cv_status::no_timeout, wait());
311 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
312 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
313
314 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
315 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error, {RadioError::NONE},
316 CHECK_GENERAL_ERROR));
317 }
318 }
319
320 /*
321 * Test IRadioMessaging.setCdmaBroadcastActivation() for the response returned.
322 */
TEST_P(RadioMessagingTest,setCdmaBroadcastActivation)323 TEST_P(RadioMessagingTest, setCdmaBroadcastActivation) {
324 serial = GetRandomSerialNumber();
325 bool activate = false;
326
327 radio_messaging->setCdmaBroadcastActivation(serial, activate);
328
329 EXPECT_EQ(std::cv_status::no_timeout, wait());
330 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
331 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
332
333 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
334 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
335 {RadioError::NONE, RadioError::INVALID_ARGUMENTS},
336 CHECK_GENERAL_ERROR));
337 }
338 }
339
340 /*
341 * Test IRadioMessaging.setGsmBroadcastActivation() for the response returned.
342 */
TEST_P(RadioMessagingTest,setGsmBroadcastActivation)343 TEST_P(RadioMessagingTest, setGsmBroadcastActivation) {
344 serial = GetRandomSerialNumber();
345 bool activate = false;
346
347 radio_messaging->setGsmBroadcastActivation(serial, activate);
348
349 EXPECT_EQ(std::cv_status::no_timeout, wait());
350 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
351 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
352
353 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
354 ASSERT_TRUE(CheckAnyOfErrors(
355 radioRsp_messaging->rspInfo.error,
356 {RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INVALID_MODEM_STATE,
357 RadioError::INVALID_STATE, RadioError::OPERATION_NOT_ALLOWED},
358 CHECK_GENERAL_ERROR));
359 }
360 }
361
362 /*
363 * Test IRadioMessaging.acknowledgeLastIncomingGsmSms() for the response returned.
364 */
TEST_P(RadioMessagingTest,acknowledgeLastIncomingGsmSms)365 TEST_P(RadioMessagingTest, acknowledgeLastIncomingGsmSms) {
366 serial = GetRandomSerialNumber();
367 bool success = true;
368
369 radio_messaging->acknowledgeLastIncomingGsmSms(
370 serial, success, SmsAcknowledgeFailCause::MEMORY_CAPACITY_EXCEEDED);
371
372 EXPECT_EQ(std::cv_status::no_timeout, wait());
373 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
374 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
375
376 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
377 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
378 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE},
379 CHECK_GENERAL_ERROR));
380 }
381 }
382
383 /*
384 * Test IRadioMessaging.acknowledgeIncomingGsmSmsWithPdu() for the response returned.
385 */
TEST_P(RadioMessagingTest,acknowledgeIncomingGsmSmsWithPdu)386 TEST_P(RadioMessagingTest, acknowledgeIncomingGsmSmsWithPdu) {
387 serial = GetRandomSerialNumber();
388 bool success = true;
389 std::string ackPdu = "";
390
391 radio_messaging->acknowledgeIncomingGsmSmsWithPdu(serial, success, ackPdu);
392
393 EXPECT_EQ(std::cv_status::no_timeout, wait());
394 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
395 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
396
397 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
398 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
399 {RadioError::INVALID_ARGUMENTS, RadioError::NO_SMS_TO_ACK},
400 CHECK_GENERAL_ERROR));
401 }
402 }
403
404 /*
405 * Test IRadioMessaging.acknowledgeLastIncomingCdmaSms() for the response returned.
406 */
TEST_P(RadioMessagingTest,acknowledgeLastIncomingCdmaSms)407 TEST_P(RadioMessagingTest, acknowledgeLastIncomingCdmaSms) {
408 serial = GetRandomSerialNumber();
409
410 // Create a CdmaSmsAck
411 CdmaSmsAck cdmaSmsAck;
412 cdmaSmsAck.errorClass = false;
413 cdmaSmsAck.smsCauseCode = 1;
414
415 radio_messaging->acknowledgeLastIncomingCdmaSms(serial, cdmaSmsAck);
416
417 EXPECT_EQ(std::cv_status::no_timeout, wait());
418 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
419 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
420
421 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
422 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
423 {RadioError::INVALID_ARGUMENTS, RadioError::NO_SMS_TO_ACK},
424 CHECK_GENERAL_ERROR));
425 }
426 }
427
428 /*
429 * Test IRadioMessaging.sendImsSms() for the response returned.
430 */
TEST_P(RadioMessagingTest,sendImsSms)431 TEST_P(RadioMessagingTest, sendImsSms) {
432 serial = GetRandomSerialNumber();
433
434 // Create a CdmaSmsAddress
435 CdmaSmsAddress cdmaSmsAddress;
436 cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
437 cdmaSmsAddress.isNumberModeDataNetwork = false;
438 cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
439 cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
440 cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
441
442 // Create a CdmaSmsSubAddress
443 CdmaSmsSubaddress cdmaSmsSubaddress;
444 cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
445 cdmaSmsSubaddress.odd = false;
446 cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
447
448 // Create a CdmaSmsMessage
449 CdmaSmsMessage cdmaSmsMessage;
450 cdmaSmsMessage.teleserviceId = 4098;
451 cdmaSmsMessage.isServicePresent = false;
452 cdmaSmsMessage.serviceCategory = 0;
453 cdmaSmsMessage.address = cdmaSmsAddress;
454 cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
455 cdmaSmsMessage.bearerData =
456 (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
457
458 // Create an ImsSmsMessage
459 ImsSmsMessage msg;
460 msg.tech = RadioTechnologyFamily::THREE_GPP2;
461 msg.retry = false;
462 msg.messageRef = 0;
463 msg.cdmaMessage = (std::vector<CdmaSmsMessage>){cdmaSmsMessage};
464 msg.gsmMessage = (std::vector<GsmSmsMessage>){};
465
466 radio_messaging->sendImsSms(serial, msg);
467
468 EXPECT_EQ(std::cv_status::no_timeout, wait());
469 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
470 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
471
472 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
473 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
474 {RadioError::INVALID_ARGUMENTS}, CHECK_GENERAL_ERROR));
475 }
476 }
477
478 /*
479 * Test IRadioMessaging.getSmscAddress() for the response returned.
480 */
TEST_P(RadioMessagingTest,getSmscAddress)481 TEST_P(RadioMessagingTest, getSmscAddress) {
482 serial = GetRandomSerialNumber();
483
484 radio_messaging->getSmscAddress(serial);
485
486 EXPECT_EQ(std::cv_status::no_timeout, wait());
487 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
488 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
489
490 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
491 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
492 {RadioError::INVALID_MODEM_STATE, RadioError::INVALID_STATE,
493 RadioError::SIM_ABSENT},
494 CHECK_GENERAL_ERROR));
495 }
496 }
497
498 /*
499 * Test IRadioMessaging.setSmscAddress() for the response returned.
500 */
TEST_P(RadioMessagingTest,setSmscAddress)501 TEST_P(RadioMessagingTest, setSmscAddress) {
502 serial = GetRandomSerialNumber();
503 std::string address = std::string("smscAddress");
504
505 radio_messaging->setSmscAddress(serial, address);
506
507 EXPECT_EQ(std::cv_status::no_timeout, wait());
508 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
509 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
510
511 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
512 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
513 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_SMS_FORMAT,
514 RadioError::SIM_ABSENT},
515 CHECK_GENERAL_ERROR));
516 }
517 }
518
519 /*
520 * Test IRadioMessaging.writeSmsToSim() for the response returned.
521 */
TEST_P(RadioMessagingTest,writeSmsToSim)522 TEST_P(RadioMessagingTest, writeSmsToSim) {
523 serial = GetRandomSerialNumber();
524 SmsWriteArgs smsWriteArgs;
525 smsWriteArgs.status = SmsWriteArgs::STATUS_REC_UNREAD;
526 smsWriteArgs.smsc = "";
527 smsWriteArgs.pdu = "01000b916105770203f3000006d4f29c3e9b01";
528
529 radio_messaging->writeSmsToSim(serial, smsWriteArgs);
530
531 EXPECT_EQ(std::cv_status::no_timeout, wait());
532 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
533 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
534
535 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
536 ASSERT_TRUE(CheckAnyOfErrors(
537 radioRsp_messaging->rspInfo.error,
538 {RadioError::NONE, RadioError::ENCODING_ERR, RadioError::INVALID_ARGUMENTS,
539 RadioError::INVALID_SMSC_ADDRESS, RadioError::MODEM_ERR,
540 RadioError::NETWORK_NOT_READY, RadioError::NO_RESOURCES, RadioError::SIM_ABSENT},
541 CHECK_GENERAL_ERROR));
542 }
543 }
544
545 /*
546 * Test IRadioMessaging.deleteSmsOnSim() for the response returned.
547 */
TEST_P(RadioMessagingTest,deleteSmsOnSim)548 TEST_P(RadioMessagingTest, deleteSmsOnSim) {
549 serial = GetRandomSerialNumber();
550 int index = 1;
551
552 radio_messaging->deleteSmsOnSim(serial, index);
553
554 EXPECT_EQ(std::cv_status::no_timeout, wait());
555 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
556 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
557
558 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
559 ASSERT_TRUE(CheckAnyOfErrors(
560 radioRsp_messaging->rspInfo.error,
561 {RadioError::NONE, RadioError::ENCODING_ERR, RadioError::INVALID_ARGUMENTS,
562 RadioError::INVALID_MODEM_STATE, RadioError::NO_SUCH_ENTRY, RadioError::MODEM_ERR,
563 RadioError::SIM_ABSENT},
564 CHECK_GENERAL_ERROR));
565 }
566 }
567
568 /*
569 * Test IRadioMessaging.writeSmsToRuim() for the response returned.
570 */
TEST_P(RadioMessagingTest,writeSmsToRuim)571 TEST_P(RadioMessagingTest, writeSmsToRuim) {
572 serial = GetRandomSerialNumber();
573
574 // Create a CdmaSmsAddress
575 CdmaSmsAddress cdmaSmsAddress;
576 cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
577 cdmaSmsAddress.isNumberModeDataNetwork = false;
578 cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
579 cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
580 cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
581
582 // Create a CdmaSmsSubAddress
583 CdmaSmsSubaddress cdmaSmsSubaddress;
584 cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
585 cdmaSmsSubaddress.odd = false;
586 cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
587
588 // Create a CdmaSmsMessage
589 CdmaSmsMessage cdmaSmsMessage;
590 cdmaSmsMessage.teleserviceId = 4098;
591 cdmaSmsMessage.isServicePresent = false;
592 cdmaSmsMessage.serviceCategory = 0;
593 cdmaSmsMessage.address = cdmaSmsAddress;
594 cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
595 cdmaSmsMessage.bearerData =
596 (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
597
598 // Create a CdmaSmsWriteArgs
599 CdmaSmsWriteArgs cdmaSmsWriteArgs;
600 cdmaSmsWriteArgs.status = CdmaSmsWriteArgs::STATUS_REC_UNREAD;
601 cdmaSmsWriteArgs.message = cdmaSmsMessage;
602
603 radio_messaging->writeSmsToRuim(serial, cdmaSmsWriteArgs);
604
605 EXPECT_EQ(std::cv_status::no_timeout, wait());
606 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
607 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
608
609 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
610 ASSERT_TRUE(CheckAnyOfErrors(
611 radioRsp_messaging->rspInfo.error,
612 {RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INVALID_SMS_FORMAT,
613 RadioError::INVALID_SMSC_ADDRESS, RadioError::INVALID_STATE, RadioError::MODEM_ERR,
614 RadioError::NO_SUCH_ENTRY, RadioError::SIM_ABSENT},
615 CHECK_GENERAL_ERROR));
616 }
617 }
618
619 /*
620 * Test IRadioMessaging.deleteSmsOnRuim() for the response returned.
621 */
TEST_P(RadioMessagingTest,deleteSmsOnRuim)622 TEST_P(RadioMessagingTest, deleteSmsOnRuim) {
623 serial = GetRandomSerialNumber();
624 int index = 1;
625
626 // Create a CdmaSmsAddress
627 CdmaSmsAddress cdmaSmsAddress;
628 cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
629 cdmaSmsAddress.isNumberModeDataNetwork = false;
630 cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
631 cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
632 cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
633
634 // Create a CdmaSmsSubAddress
635 CdmaSmsSubaddress cdmaSmsSubaddress;
636 cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
637 cdmaSmsSubaddress.odd = false;
638 cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
639
640 // Create a CdmaSmsMessage
641 CdmaSmsMessage cdmaSmsMessage;
642 cdmaSmsMessage.teleserviceId = 4098;
643 cdmaSmsMessage.isServicePresent = false;
644 cdmaSmsMessage.serviceCategory = 0;
645 cdmaSmsMessage.address = cdmaSmsAddress;
646 cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
647 cdmaSmsMessage.bearerData =
648 (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
649
650 // Create a CdmaSmsWriteArgs
651 CdmaSmsWriteArgs cdmaSmsWriteArgs;
652 cdmaSmsWriteArgs.status = CdmaSmsWriteArgs::STATUS_REC_UNREAD;
653 cdmaSmsWriteArgs.message = cdmaSmsMessage;
654
655 radio_messaging->deleteSmsOnRuim(serial, index);
656
657 EXPECT_EQ(std::cv_status::no_timeout, wait());
658 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
659 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
660
661 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
662 ASSERT_TRUE(CheckAnyOfErrors(
663 radioRsp_messaging->rspInfo.error,
664 {RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INVALID_MODEM_STATE,
665 RadioError::MODEM_ERR, RadioError::NO_SUCH_ENTRY, RadioError::SIM_ABSENT},
666 CHECK_GENERAL_ERROR));
667 }
668 }
669
670 /*
671 * Test IRadioMessaging.reportSmsMemoryStatus() for the response returned.
672 */
TEST_P(RadioMessagingTest,reportSmsMemoryStatus)673 TEST_P(RadioMessagingTest, reportSmsMemoryStatus) {
674 serial = GetRandomSerialNumber();
675 bool available = true;
676
677 radio_messaging->reportSmsMemoryStatus(serial, available);
678
679 EXPECT_EQ(std::cv_status::no_timeout, wait());
680 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
681 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
682
683 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
684 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
685 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE,
686 RadioError::MODEM_ERR, RadioError::SIM_ABSENT},
687 CHECK_GENERAL_ERROR));
688 }
689 }
690