radio/1.0/vts/functional/radio_hidl_hal_icc.cpp

   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     }