1/*
2 * Copyright (C) 2017 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 <radio_hidl_hal_utils_v1_0.h>
18
19using namespace ::android::hardware::radio::V1_0;
20
21/*
22 * Test IRadio.sendSms() for the response returned.
23 */
24TEST_F(RadioHidlTest, sendSms) {
25    int serial = GetRandomSerialNumber();
26    GsmSmsMessage msg;
27    msg.smscPdu = "";
28    msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
29
30    radio->sendSms(serial, msg);
31
32    EXPECT_EQ(std::cv_status::no_timeout, wait());
33    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
34    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
35
36    if (cardStatus.cardState == CardState::ABSENT) {
37        ASSERT_TRUE(CheckGeneralError() ||
38                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
39                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
40                    radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
41        EXPECT_EQ(0, radioRsp->sendSmsResult.errorCode);
42    }
43}
44
45/*
46 * Test IRadio.sendSMSExpectMore() for the response returned.
47 */
48TEST_F(RadioHidlTest, sendSMSExpectMore) {
49    int serial = GetRandomSerialNumber();
50    GsmSmsMessage msg;
51    msg.smscPdu = "";
52    msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
53
54    radio->sendSMSExpectMore(serial, msg);
55
56    // TODO(shuoq): add more test for this API when inserted sim card is
57    // considered
58
59    EXPECT_EQ(std::cv_status::no_timeout, wait());
60    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
61    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
62
63    if (cardStatus.cardState == CardState::ABSENT) {
64        ASSERT_TRUE(CheckGeneralError() ||
65                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
66                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
67                    radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
68    }
69}
70
71/*
72 * Test IRadio.acknowledgeLastIncomingGsmSms() for the response returned.
73 */
74TEST_F(RadioHidlTest, acknowledgeLastIncomingGsmSms) {
75    int serial = GetRandomSerialNumber();
76    bool success = true;
77
78    radio->acknowledgeLastIncomingGsmSms(serial, success,
79                                         SmsAcknowledgeFailCause::MEMORY_CAPACITY_EXCEEDED);
80
81    EXPECT_EQ(std::cv_status::no_timeout, wait());
82    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
83    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
84
85    if (cardStatus.cardState == CardState::ABSENT) {
86        ASSERT_TRUE(CheckGeneralError() ||
87                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
88                    radioRsp->rspInfo.error == RadioError::INVALID_STATE);
89    }
90}
91
92/*
93 * Test IRadio.acknowledgeIncomingGsmSmsWithPdu() for the response returned.
94 */
95TEST_F(RadioHidlTest, acknowledgeIncomingGsmSmsWithPdu) {
96    int serial = GetRandomSerialNumber();
97    bool success = true;
98    std::string ackPdu = "";
99
100    radio->acknowledgeIncomingGsmSmsWithPdu(serial, success, ackPdu);
101
102    EXPECT_EQ(std::cv_status::no_timeout, wait());
103    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
104    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
105
106    if (cardStatus.cardState == CardState::ABSENT) {
107        // TODO(shuoq): Will add error check when we know the expected error from QC
108    }
109}
110
111/*
112 * Test IRadio.sendCdmaSms() for the response returned.
113 */
114TEST_F(RadioHidlTest, sendCdmaSms) {
115    int serial = GetRandomSerialNumber();
116
117    // Create a CdmaSmsAddress
118    CdmaSmsAddress cdmaSmsAddress;
119    cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
120    cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
121    cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
122    cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
123    cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
124
125    // Create a CdmaSmsSubAddress
126    CdmaSmsSubaddress cdmaSmsSubaddress;
127    cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
128    cdmaSmsSubaddress.odd = false;
129    cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
130
131    // Create a CdmaSmsMessage
132    android::hardware::radio::V1_0::CdmaSmsMessage cdmaSmsMessage;
133    cdmaSmsMessage.teleserviceId = 4098;
134    cdmaSmsMessage.isServicePresent = false;
135    cdmaSmsMessage.serviceCategory = 0;
136    cdmaSmsMessage.address = cdmaSmsAddress;
137    cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
138    cdmaSmsMessage.bearerData =
139        (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
140
141    radio->sendCdmaSms(serial, cdmaSmsMessage);
142
143    EXPECT_EQ(std::cv_status::no_timeout, wait());
144    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
145    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
146
147    if (cardStatus.cardState == CardState::ABSENT) {
148        ASSERT_TRUE(CheckGeneralError() ||
149                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
150                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
151                    radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
152    }
153}
154
155/*
156 * Test IRadio.acknowledgeLastIncomingCdmaSms() for the response returned.
157 */
158TEST_F(RadioHidlTest, acknowledgeLastIncomingCdmaSms) {
159    int serial = GetRandomSerialNumber();
160
161    // Create a CdmaSmsAck
162    CdmaSmsAck cdmaSmsAck;
163    cdmaSmsAck.errorClass = CdmaSmsErrorClass::NO_ERROR;
164    cdmaSmsAck.smsCauseCode = 1;
165
166    radio->acknowledgeLastIncomingCdmaSms(serial, cdmaSmsAck);
167
168    EXPECT_EQ(std::cv_status::no_timeout, wait());
169    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
170    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
171
172    if (cardStatus.cardState == CardState::ABSENT) {
173        ASSERT_TRUE(CheckGeneralError() ||
174                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
175                    radioRsp->rspInfo.error == RadioError::NO_SMS_TO_ACK);
176    }
177}
178
179/*
180 * Test IRadio.sendImsSms() for the response returned.
181 */
182TEST_F(RadioHidlTest, sendImsSms) {
183    int serial = GetRandomSerialNumber();
184
185    // Create a CdmaSmsAddress
186    CdmaSmsAddress cdmaSmsAddress;
187    cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
188    cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
189    cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
190    cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
191    cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
192
193    // Create a CdmaSmsSubAddress
194    CdmaSmsSubaddress cdmaSmsSubaddress;
195    cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
196    cdmaSmsSubaddress.odd = false;
197    cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
198
199    // Create a CdmaSmsMessage
200    CdmaSmsMessage cdmaSmsMessage;
201    cdmaSmsMessage.teleserviceId = 4098;
202    cdmaSmsMessage.isServicePresent = false;
203    cdmaSmsMessage.serviceCategory = 0;
204    cdmaSmsMessage.address = cdmaSmsAddress;
205    cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
206    cdmaSmsMessage.bearerData =
207        (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
208
209    // Creata an ImsSmsMessage
210    ImsSmsMessage msg;
211    msg.tech = RadioTechnologyFamily::THREE_GPP2;
212    msg.retry = false;
213    msg.messageRef = 0;
214    msg.cdmaMessage = (std::vector<CdmaSmsMessage>){cdmaSmsMessage};
215    msg.gsmMessage = (std::vector<GsmSmsMessage>){};
216
217    radio->sendImsSms(serial, msg);
218
219    EXPECT_EQ(std::cv_status::no_timeout, wait());
220    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
221    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
222
223    if (cardStatus.cardState == CardState::ABSENT) {
224        ASSERT_TRUE(CheckGeneralError() ||
225                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
226    }
227}
228
229/*
230 * Test IRadio.getSmscAddress() for the response returned.
231 */
232TEST_F(RadioHidlTest, getSmscAddress) {
233    int serial = GetRandomSerialNumber();
234
235    radio->getSmscAddress(serial);
236
237    EXPECT_EQ(std::cv_status::no_timeout, wait());
238    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
239    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
240
241    if (cardStatus.cardState == CardState::ABSENT) {
242        ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
243                    radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
244                    radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
245    }
246}
247
248/*
249 * Test IRadio.setSmscAddress() for the response returned.
250 */
251TEST_F(RadioHidlTest, setSmscAddress) {
252    int serial = GetRandomSerialNumber();
253    hidl_string address = hidl_string("smscAddress");
254
255    radio->setSmscAddress(serial, address);
256
257    EXPECT_EQ(std::cv_status::no_timeout, wait());
258    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
259    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
260
261    if (cardStatus.cardState == CardState::ABSENT) {
262        ASSERT_TRUE(CheckGeneralError() ||
263                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
264                    radioRsp->rspInfo.error == RadioError::INVALID_SMS_FORMAT ||
265                    radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
266    }
267}
268
269/*
270 * Test IRadio.writeSmsToSim() for the response returned.
271 */
272TEST_F(RadioHidlTest, writeSmsToSim) {
273    int serial = GetRandomSerialNumber();
274    SmsWriteArgs smsWriteArgs;
275    smsWriteArgs.status = SmsWriteArgsStatus::REC_UNREAD;
276    smsWriteArgs.smsc = "";
277    smsWriteArgs.pdu = "01000b916105770203f3000006d4f29c3e9b01";
278
279    radio->writeSmsToSim(serial, smsWriteArgs);
280
281    EXPECT_EQ(std::cv_status::no_timeout, wait());
282    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
283    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
284
285    if (cardStatus.cardState == CardState::ABSENT) {
286        ASSERT_TRUE(CheckGeneralError() ||
287                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
288                    radioRsp->rspInfo.error == RadioError::NONE ||
289                    radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
290                    radioRsp->rspInfo.error == RadioError::ENCODING_ERR ||
291                    radioRsp->rspInfo.error == RadioError::NO_RESOURCES ||
292                    radioRsp->rspInfo.error == RadioError::NETWORK_NOT_READY ||
293                    radioRsp->rspInfo.error == RadioError::INVALID_SMSC_ADDRESS ||
294                    radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
295    }
296}
297
298/*
299 * Test IRadio.deleteSmsOnSim() for the response returned.
300 */
301TEST_F(RadioHidlTest, deleteSmsOnSim) {
302    int serial = GetRandomSerialNumber();
303    int index = 1;
304
305    radio->deleteSmsOnSim(serial, index);
306
307    EXPECT_EQ(std::cv_status::no_timeout, wait());
308    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
309    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
310
311    if (cardStatus.cardState == CardState::ABSENT) {
312        ASSERT_TRUE(CheckGeneralError() ||
313                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
314                    radioRsp->rspInfo.error == RadioError::NONE ||
315                    radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
316                    radioRsp->rspInfo.error == RadioError::NO_SUCH_ENTRY ||
317                    radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
318                    radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
319    }
320}
321
322/*
323 * Test IRadio.writeSmsToRuim() for the response returned.
324 */
325TEST_F(RadioHidlTest, writeSmsToRuim) {
326    int serial = GetRandomSerialNumber();
327
328    // Create a CdmaSmsAddress
329    CdmaSmsAddress cdmaSmsAddress;
330    cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
331    cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
332    cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
333    cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
334    cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
335
336    // Create a CdmaSmsSubAddress
337    CdmaSmsSubaddress cdmaSmsSubaddress;
338    cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
339    cdmaSmsSubaddress.odd = false;
340    cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
341
342    // Create a CdmaSmsMessage
343    CdmaSmsMessage cdmaSmsMessage;
344    cdmaSmsMessage.teleserviceId = 4098;
345    cdmaSmsMessage.isServicePresent = false;
346    cdmaSmsMessage.serviceCategory = 0;
347    cdmaSmsMessage.address = cdmaSmsAddress;
348    cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
349    cdmaSmsMessage.bearerData =
350        (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
351
352    // Create a CdmaSmsWriteArgs
353    CdmaSmsWriteArgs cdmaSmsWriteArgs;
354    cdmaSmsWriteArgs.status = CdmaSmsWriteArgsStatus::REC_UNREAD;
355    cdmaSmsWriteArgs.message = cdmaSmsMessage;
356
357    radio->writeSmsToRuim(serial, cdmaSmsWriteArgs);
358
359    EXPECT_EQ(std::cv_status::no_timeout, wait());
360    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
361    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
362
363    if (cardStatus.cardState == CardState::ABSENT) {
364        ASSERT_TRUE(CheckGeneralError() ||
365                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
366                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
367                    radioRsp->rspInfo.error == RadioError::INVALID_SMS_FORMAT ||
368                    radioRsp->rspInfo.error == RadioError::NONE ||
369                    radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
370                    radioRsp->rspInfo.error == RadioError::NO_SUCH_ENTRY ||
371                    radioRsp->rspInfo.error == RadioError::INVALID_SMSC_ADDRESS ||
372                    radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
373    }
374}
375
376/*
377 * Test IRadio.deleteSmsOnRuim() for the response returned.
378 */
379TEST_F(RadioHidlTest, deleteSmsOnRuim) {
380    int serial = GetRandomSerialNumber();
381    int index = 1;
382
383    // Create a CdmaSmsAddress
384    CdmaSmsAddress cdmaSmsAddress;
385    cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
386    cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
387    cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
388    cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
389    cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
390
391    // Create a CdmaSmsSubAddress
392    CdmaSmsSubaddress cdmaSmsSubaddress;
393    cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
394    cdmaSmsSubaddress.odd = false;
395    cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
396
397    // Create a CdmaSmsMessage
398    CdmaSmsMessage cdmaSmsMessage;
399    cdmaSmsMessage.teleserviceId = 4098;
400    cdmaSmsMessage.isServicePresent = false;
401    cdmaSmsMessage.serviceCategory = 0;
402    cdmaSmsMessage.address = cdmaSmsAddress;
403    cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
404    cdmaSmsMessage.bearerData =
405        (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
406
407    // Create a CdmaSmsWriteArgs
408    CdmaSmsWriteArgs cdmaSmsWriteArgs;
409    cdmaSmsWriteArgs.status = CdmaSmsWriteArgsStatus::REC_UNREAD;
410    cdmaSmsWriteArgs.message = cdmaSmsMessage;
411
412    radio->deleteSmsOnRuim(serial, index);
413
414    EXPECT_EQ(std::cv_status::no_timeout, wait());
415    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
416    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
417
418    if (cardStatus.cardState == CardState::ABSENT) {
419        ASSERT_TRUE(CheckGeneralError() ||
420                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
421                    radioRsp->rspInfo.error == RadioError::NONE ||
422                    radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
423                    radioRsp->rspInfo.error == RadioError::NO_SUCH_ENTRY ||
424                    radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
425                    radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
426    }
427}
428
429/*
430 * Test IRadio.reportSmsMemoryStatus() for the response returned.
431 */
432TEST_F(RadioHidlTest, reportSmsMemoryStatus) {
433    int serial = GetRandomSerialNumber();
434    bool available = true;
435
436    radio->reportSmsMemoryStatus(serial, available);
437
438    EXPECT_EQ(std::cv_status::no_timeout, wait());
439    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
440    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
441
442    if (cardStatus.cardState == CardState::ABSENT) {
443        ASSERT_TRUE(CheckGeneralError() ||
444                    radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
445                    radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
446                    radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
447                    radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
448    }
449}
450