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