Home | History | Annotate | Download | only in functional
      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 
     19 /*
     20  * Test IRadio.getIccCardStatus() for the response returned.
     21  */
     22 TEST_F(RadioHidlTest, getIccCardStatus) {
     23     EXPECT_LE(cardStatus.applications.size(), (unsigned int)RadioConst::CARD_MAX_APPS);
     24     EXPECT_LT(cardStatus.gsmUmtsSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
     25     EXPECT_LT(cardStatus.cdmaSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
     26     EXPECT_LT(cardStatus.imsSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
     27     }
     28 
     29     /*
     30      * Test IRadio.supplyIccPinForApp() for the response returned
     31      */
     32     TEST_F(RadioHidlTest, supplyIccPinForApp) {
     33         int serial = GetRandomSerialNumber();
     34 
     35         // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
     36         // 3GPP2 apps only
     37         for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
     38             if (cardStatus.applications[i].appType == AppType::SIM ||
     39                 cardStatus.applications[i].appType == AppType::USIM ||
     40                 cardStatus.applications[i].appType == AppType::RUIM ||
     41                 cardStatus.applications[i].appType == AppType::CSIM) {
     42                 radio->supplyIccPinForApp(serial, hidl_string("test1"),
     43                                           cardStatus.applications[i].aidPtr);
     44                 EXPECT_EQ(std::cv_status::no_timeout, wait());
     45                 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
     46                 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     47                 EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
     48             }
     49         }
     50     }
     51 
     52     /*
     53      * Test IRadio.supplyIccPukForApp() for the response returned.
     54      */
     55     TEST_F(RadioHidlTest, supplyIccPukForApp) {
     56         int serial = GetRandomSerialNumber();
     57 
     58         // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
     59         // 3GPP2 apps only
     60         for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
     61             if (cardStatus.applications[i].appType == AppType::SIM ||
     62                 cardStatus.applications[i].appType == AppType::USIM ||
     63                 cardStatus.applications[i].appType == AppType::RUIM ||
     64                 cardStatus.applications[i].appType == AppType::CSIM) {
     65                 radio->supplyIccPukForApp(serial, hidl_string("test1"), hidl_string("test2"),
     66                                           cardStatus.applications[i].aidPtr);
     67                 EXPECT_EQ(std::cv_status::no_timeout, wait());
     68                 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
     69                 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     70                 EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
     71             }
     72         }
     73     }
     74 
     75     /*
     76      * Test IRadio.supplyIccPin2ForApp() for the response returned.
     77      */
     78     TEST_F(RadioHidlTest, supplyIccPin2ForApp) {
     79         int serial = GetRandomSerialNumber();
     80 
     81         // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
     82         // 3GPP2 apps only
     83         for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
     84             if (cardStatus.applications[i].appType == AppType::SIM ||
     85                 cardStatus.applications[i].appType == AppType::USIM ||
     86                 cardStatus.applications[i].appType == AppType::RUIM ||
     87                 cardStatus.applications[i].appType == AppType::CSIM) {
     88                 radio->supplyIccPin2ForApp(serial, hidl_string("test1"),
     89                                            cardStatus.applications[i].aidPtr);
     90                 EXPECT_EQ(std::cv_status::no_timeout, wait());
     91                 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
     92                 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     93                 EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
     94             }
     95         }
     96     }
     97 
     98     /*
     99      * Test IRadio.supplyIccPuk2ForApp() for the response returned.
    100      */
    101     TEST_F(RadioHidlTest, supplyIccPuk2ForApp) {
    102         int serial = GetRandomSerialNumber();
    103 
    104         // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
    105         // 3GPP2 apps only
    106         for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
    107             if (cardStatus.applications[i].appType == AppType::SIM ||
    108                 cardStatus.applications[i].appType == AppType::USIM ||
    109                 cardStatus.applications[i].appType == AppType::RUIM ||
    110                 cardStatus.applications[i].appType == AppType::CSIM) {
    111                 radio->supplyIccPuk2ForApp(serial, hidl_string("test1"), hidl_string("test2"),
    112                                            cardStatus.applications[i].aidPtr);
    113                 EXPECT_EQ(std::cv_status::no_timeout, wait());
    114                 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    115                 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    116                 EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
    117             }
    118         }
    119     }
    120 
    121     /*
    122      * Test IRadio.changeIccPinForApp() for the response returned.
    123      */
    124     TEST_F(RadioHidlTest, changeIccPinForApp) {
    125         int serial = GetRandomSerialNumber();
    126 
    127         // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
    128         // 3GPP2 apps only
    129         for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
    130             if (cardStatus.applications[i].appType == AppType::SIM ||
    131                 cardStatus.applications[i].appType == AppType::USIM ||
    132                 cardStatus.applications[i].appType == AppType::RUIM ||
    133                 cardStatus.applications[i].appType == AppType::CSIM) {
    134                 radio->changeIccPinForApp(serial, hidl_string("test1"), hidl_string("test2"),
    135                                           cardStatus.applications[i].aidPtr);
    136                 EXPECT_EQ(std::cv_status::no_timeout, wait());
    137                 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    138                 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    139                 EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
    140             }
    141         }
    142     }
    143 
    144     /*
    145      * Test IRadio.changeIccPin2ForApp() for the response returned.
    146      */
    147     TEST_F(RadioHidlTest, changeIccPin2ForApp) {
    148         int serial = GetRandomSerialNumber();
    149 
    150         // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
    151         // 3GPP2 apps only
    152         for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
    153             if (cardStatus.applications[i].appType == AppType::SIM ||
    154                 cardStatus.applications[i].appType == AppType::USIM ||
    155                 cardStatus.applications[i].appType == AppType::RUIM ||
    156                 cardStatus.applications[i].appType == AppType::CSIM) {
    157                 radio->changeIccPin2ForApp(serial, hidl_string("test1"), hidl_string("test2"),
    158                                            cardStatus.applications[i].aidPtr);
    159                 EXPECT_EQ(std::cv_status::no_timeout, wait());
    160                 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    161                 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    162                 EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
    163             }
    164         }
    165     }
    166 
    167     /*
    168      * Test IRadio.getImsiForApp() for the response returned.
    169      */
    170     TEST_F(RadioHidlTest, getImsiForApp) {
    171         int serial = GetRandomSerialNumber();
    172 
    173         // Check success returned while getting imsi for 3GPP and 3GPP2 apps only
    174         for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
    175             if (cardStatus.applications[i].appType == AppType::SIM ||
    176                 cardStatus.applications[i].appType == AppType::USIM ||
    177                 cardStatus.applications[i].appType == AppType::RUIM ||
    178                 cardStatus.applications[i].appType == AppType::CSIM) {
    179                 radio->getImsiForApp(serial, cardStatus.applications[i].aidPtr);
    180                 EXPECT_EQ(std::cv_status::no_timeout, wait());
    181                 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    182                 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    183                 EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
    184 
    185                 // IMSI (MCC+MNC+MSIN) is at least 6 digits, but not more than 15
    186                 if (radioRsp->rspInfo.error == RadioError::NONE) {
    187                     EXPECT_NE(radioRsp->imsi, hidl_string());
    188                     EXPECT_GE((int)(radioRsp->imsi).size(), 6);
    189                     EXPECT_LE((int)(radioRsp->imsi).size(), 15);
    190                 }
    191             }
    192         }
    193     }
    194 
    195     /*
    196      * Test IRadio.iccIOForApp() for the response returned.
    197      */
    198     TEST_F(RadioHidlTest, iccIOForApp) {
    199         int serial = GetRandomSerialNumber();
    200 
    201         for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
    202             IccIo iccIo;
    203             iccIo.command = 0xc0;
    204             iccIo.fileId = 0x6f11;
    205             iccIo.path = hidl_string("3F007FFF");
    206             iccIo.p1 = 0;
    207             iccIo.p2 = 0;
    208             iccIo.p3 = 0;
    209             iccIo.data = hidl_string();
    210             iccIo.pin2 = hidl_string();
    211             iccIo.aid = cardStatus.applications[i].aidPtr;
    212 
    213             radio->iccIOForApp(serial, iccIo);
    214             EXPECT_EQ(std::cv_status::no_timeout, wait());
    215             EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    216             EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    217         }
    218     }
    219 
    220     /*
    221      * Test IRadio.iccTransmitApduBasicChannel() for the response returned.
    222      */
    223     TEST_F(RadioHidlTest, iccTransmitApduBasicChannel) {
    224         int serial = GetRandomSerialNumber();
    225         SimApdu msg;
    226         memset(&msg, 0, sizeof(msg));
    227         msg.data = hidl_string();
    228 
    229         radio->iccTransmitApduBasicChannel(serial, msg);
    230         EXPECT_EQ(std::cv_status::no_timeout, wait());
    231         EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    232         EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    233 
    234         // TODO(sanketpadawe): Add test for error code
    235     }
    236 
    237     /*
    238      * Test IRadio.iccOpenLogicalChannel() for the response returned.
    239      */
    240     TEST_F(RadioHidlTest, iccOpenLogicalChannel) {
    241         int serial = GetRandomSerialNumber();
    242         int p2 = 0x04;
    243         // Specified in ISO 7816-4 clause 7.1.1 0x04 means that FCP template is requested.
    244         for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
    245             radio->iccOpenLogicalChannel(serial, cardStatus.applications[i].aidPtr, p2);
    246             EXPECT_EQ(std::cv_status::no_timeout, wait());
    247             EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    248             EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    249         }
    250     }
    251 
    252     /*
    253      * Test IRadio.iccCloseLogicalChannel() for the response returned.
    254      */
    255     TEST_F(RadioHidlTest, iccCloseLogicalChannel) {
    256         int serial = GetRandomSerialNumber();
    257         // Try closing invalid channel and check INVALID_ARGUMENTS returned as error
    258         radio->iccCloseLogicalChannel(serial, 0);
    259         EXPECT_EQ(std::cv_status::no_timeout, wait());
    260         EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    261         EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    262 
    263         EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
    264     }
    265 
    266     /*
    267      * Test IRadio.iccTransmitApduLogicalChannel() for the response returned.
    268      */
    269     TEST_F(RadioHidlTest, iccTransmitApduLogicalChannel) {
    270         int serial = GetRandomSerialNumber();
    271         SimApdu msg;
    272         memset(&msg, 0, sizeof(msg));
    273         msg.data = hidl_string();
    274 
    275         radio->iccTransmitApduLogicalChannel(serial, msg);
    276         EXPECT_EQ(std::cv_status::no_timeout, wait());
    277         EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    278         EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    279 
    280         // TODO(sanketpadawe): Add test for error code
    281     }
    282 
    283     /*
    284      * Test IRadio.requestIccSimAuthentication() for the response returned.
    285      */
    286     TEST_F(RadioHidlTest, requestIccSimAuthentication) {
    287         int serial = GetRandomSerialNumber();
    288 
    289         // Pass wrong challenge string and check RadioError::INVALID_ARGUMENTS
    290         // returned as error.
    291         for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
    292             radio->requestIccSimAuthentication(serial, 0, hidl_string("test"),
    293                                                cardStatus.applications[i].aidPtr);
    294             EXPECT_EQ(std::cv_status::no_timeout, wait());
    295             EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    296             EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    297             EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
    298         }
    299     }
    300 
    301     /*
    302      * Test IRadio.supplyNetworkDepersonalization() for the response returned.
    303      */
    304     TEST_F(RadioHidlTest, supplyNetworkDepersonalization) {
    305         int serial = GetRandomSerialNumber();
    306 
    307         radio->supplyNetworkDepersonalization(serial, hidl_string("test"));
    308         EXPECT_EQ(std::cv_status::no_timeout, wait());
    309         EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    310         EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    311 
    312         if (cardStatus.cardState == CardState::ABSENT) {
    313             ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
    314                         radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
    315                         radioRsp->rspInfo.error == RadioError::NO_MEMORY ||
    316                         radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
    317                         radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
    318                         radioRsp->rspInfo.error == RadioError::INVALID_SIM_STATE ||
    319                         radioRsp->rspInfo.error == RadioError::PASSWORD_INCORRECT ||
    320                         radioRsp->rspInfo.error == RadioError::INTERNAL_ERR ||
    321                         radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
    322         }
    323     }
    324