radio/1.0/vts/functional/radio_hidl_hal_icc.cpp - platform/hardware/interfaces - Git at Google

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <android-base/logging.h>
 #include <radio_hidl_hal_utils_v1_0.h>

 /*
  * Test IRadio.getIccCardStatus() for the response returned.
  */
 TEST_P(RadioHidlTest, getIccCardStatus) {
     LOG(DEBUG) << "getIccCardStatus";
     EXPECT_LE(cardStatus.applications.size(), (unsigned int)RadioConst::CARD_MAX_APPS);
     EXPECT_LT(cardStatus.gsmUmtsSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
     EXPECT_LT(cardStatus.cdmaSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
     EXPECT_LT(cardStatus.imsSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
     LOG(DEBUG) << "getIccCardStatus finished";
 }

 /*
  * Test IRadio.supplyIccPinForApp() for the response returned
  */
 TEST_P(RadioHidlTest, supplyIccPinForApp) {
     LOG(DEBUG) << "supplyIccPinForApp";
     serial = GetRandomSerialNumber();

     // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
     // 3GPP2 apps only
     for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
         if (cardStatus.applications[i].appType == AppType::SIM ||
             cardStatus.applications[i].appType == AppType::USIM ||
             cardStatus.applications[i].appType == AppType::RUIM ||
             cardStatus.applications[i].appType == AppType::CSIM) {
             radio->supplyIccPinForApp(serial, hidl_string("test1"),
                                       cardStatus.applications[i].aidPtr);
             EXPECT_EQ(std::cv_status::no_timeout, wait());
             EXPECT_EQ(serial, radioRsp->rspInfo.serial);
             EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
             ASSERT_TRUE(CheckAnyOfErrors(
                 radioRsp->rspInfo.error,
                 {RadioError::PASSWORD_INCORRECT, RadioError::REQUEST_NOT_SUPPORTED}));
         }
     }
     LOG(DEBUG) << "supplyIccPinForApp finished";
 }

 /*
  * Test IRadio.supplyIccPukForApp() for the response returned.
  */
 TEST_P(RadioHidlTest, supplyIccPukForApp) {
     LOG(DEBUG) << "supplyIccPukForApp";
     serial = GetRandomSerialNumber();

     // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
     // 3GPP2 apps only
     for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
         if (cardStatus.applications[i].appType == AppType::SIM ||
             cardStatus.applications[i].appType == AppType::USIM ||
             cardStatus.applications[i].appType == AppType::RUIM ||
             cardStatus.applications[i].appType == AppType::CSIM) {
             radio->supplyIccPukForApp(serial, hidl_string("test1"), hidl_string("test2"),
                                       cardStatus.applications[i].aidPtr);
             EXPECT_EQ(std::cv_status::no_timeout, wait());
             EXPECT_EQ(serial, radioRsp->rspInfo.serial);
             EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
             ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::PASSWORD_INCORRECT,
                                                                    RadioError::INVALID_SIM_STATE}));
         }
     }
     LOG(DEBUG) << "supplyIccPukForApp finished";
 }

 /*
  * Test IRadio.supplyIccPin2ForApp() for the response returned.
  */
 TEST_P(RadioHidlTest, supplyIccPin2ForApp) {
     LOG(DEBUG) << "supplyIccPin2ForApp";
     serial = GetRandomSerialNumber();

     // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
     // 3GPP2 apps only
     for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
         if (cardStatus.applications[i].appType == AppType::SIM ||
             cardStatus.applications[i].appType == AppType::USIM ||
             cardStatus.applications[i].appType == AppType::RUIM ||
             cardStatus.applications[i].appType == AppType::CSIM) {
             radio->supplyIccPin2ForApp(serial, hidl_string("test1"),
                                        cardStatus.applications[i].aidPtr);
             EXPECT_EQ(std::cv_status::no_timeout, wait());
             EXPECT_EQ(serial, radioRsp->rspInfo.serial);
             EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
             ASSERT_TRUE(
                 CheckAnyOfErrors(radioRsp->rspInfo.error,
                                  {RadioError::PASSWORD_INCORRECT, RadioError::REQUEST_NOT_SUPPORTED,
                                   RadioError::SIM_PUK2}));
         }
     }
     LOG(DEBUG) << "supplyIccPin2ForApp finished";
 }

 /*
  * Test IRadio.supplyIccPuk2ForApp() for the response returned.
  */
 TEST_P(RadioHidlTest, supplyIccPuk2ForApp) {
     LOG(DEBUG) << "supplyIccPuk2ForApp";
     serial = GetRandomSerialNumber();

     // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
     // 3GPP2 apps only
     for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
         if (cardStatus.applications[i].appType == AppType::SIM ||
             cardStatus.applications[i].appType == AppType::USIM ||
             cardStatus.applications[i].appType == AppType::RUIM ||
             cardStatus.applications[i].appType == AppType::CSIM) {
             radio->supplyIccPuk2ForApp(serial, hidl_string("test1"), hidl_string("test2"),
                                        cardStatus.applications[i].aidPtr);
             EXPECT_EQ(std::cv_status::no_timeout, wait());
             EXPECT_EQ(serial, radioRsp->rspInfo.serial);
             EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
             ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::PASSWORD_INCORRECT,
                                                                    RadioError::INVALID_SIM_STATE}));
         }
     }
     LOG(DEBUG) << "supplyIccPuk2ForApp finished";
 }

 /*
  * Test IRadio.changeIccPinForApp() for the response returned.
  */
 TEST_P(RadioHidlTest, changeIccPinForApp) {
     LOG(DEBUG) << "changeIccPinForApp";
     serial = GetRandomSerialNumber();

     // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
     // 3GPP2 apps only
     for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
         if (cardStatus.applications[i].appType == AppType::SIM ||
             cardStatus.applications[i].appType == AppType::USIM ||
             cardStatus.applications[i].appType == AppType::RUIM ||
             cardStatus.applications[i].appType == AppType::CSIM) {
             radio->changeIccPinForApp(serial, hidl_string("test1"), hidl_string("test2"),
                                       cardStatus.applications[i].aidPtr);
             EXPECT_EQ(std::cv_status::no_timeout, wait());
             EXPECT_EQ(serial, radioRsp->rspInfo.serial);
             EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
             ASSERT_TRUE(CheckAnyOfErrors(
                 radioRsp->rspInfo.error,
                 {RadioError::PASSWORD_INCORRECT, RadioError::REQUEST_NOT_SUPPORTED}));
         }
     }
     LOG(DEBUG) << "changeIccPinForApp finished";
 }

 /*
  * Test IRadio.changeIccPin2ForApp() for the response returned.
  */
 TEST_P(RadioHidlTest, changeIccPin2ForApp) {
     LOG(DEBUG) << "changeIccPin2ForApp";
     serial = GetRandomSerialNumber();

     // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
     // 3GPP2 apps only
     for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
         if (cardStatus.applications[i].appType == AppType::SIM ||
             cardStatus.applications[i].appType == AppType::USIM ||
             cardStatus.applications[i].appType == AppType::RUIM ||
             cardStatus.applications[i].appType == AppType::CSIM) {
             radio->changeIccPin2ForApp(serial, hidl_string("test1"), hidl_string("test2"),
                                        cardStatus.applications[i].aidPtr);
             EXPECT_EQ(std::cv_status::no_timeout, wait());
             EXPECT_EQ(serial, radioRsp->rspInfo.serial);
             EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
             ASSERT_TRUE(
                 CheckAnyOfErrors(radioRsp->rspInfo.error,
                                  {RadioError::PASSWORD_INCORRECT, RadioError::REQUEST_NOT_SUPPORTED,
                                   RadioError::SIM_PUK2}));
         }
     }
     LOG(DEBUG) << "changeIccPin2ForApp finished";
 }

 /*
  * The following test is disabled due to b/109889468
  *
  * Test IRadio.getImsiForApp() for the response returned.
  */
 TEST_P(RadioHidlTest, DISABLED_getImsiForApp) {
     LOG(DEBUG) << "DISABLED_getImsiForApp";
     serial = GetRandomSerialNumber();

     // Check success returned while getting imsi for 3GPP and 3GPP2 apps only
     for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
         if (cardStatus.applications[i].appType == AppType::SIM ||
             cardStatus.applications[i].appType == AppType::USIM ||
             cardStatus.applications[i].appType == AppType::RUIM ||
             cardStatus.applications[i].appType == AppType::CSIM) {
             radio->getImsiForApp(serial, cardStatus.applications[i].aidPtr);
             EXPECT_EQ(std::cv_status::no_timeout, wait());
             EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
             EXPECT_EQ(serial, radioRsp->rspInfo.serial);
             ASSERT_TRUE(
                 CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));

             // IMSI (MCC+MNC+MSIN) is at least 6 digits, but not more than 15
             if (radioRsp->rspInfo.error == RadioError::NONE) {
                 EXPECT_NE(radioRsp->imsi, hidl_string());
                 EXPECT_GE((int)(radioRsp->imsi).size(), 6);
                 EXPECT_LE((int)(radioRsp->imsi).size(), 15);
             }
         }
     }
     LOG(DEBUG) << "DISABLED_getImsiForApp finished";
 }

 /*
  * Test IRadio.iccIOForApp() for the response returned.
  */
 TEST_P(RadioHidlTest, iccIOForApp) {
     LOG(DEBUG) << "iccIOForApp";
     serial = GetRandomSerialNumber();

     for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
         IccIo iccIo;
         iccIo.command = 0xc0;
         iccIo.fileId = 0x6f11;
         iccIo.path = hidl_string("3F007FFF");
         iccIo.p1 = 0;
         iccIo.p2 = 0;
         iccIo.p3 = 0;
         iccIo.data = hidl_string();
         iccIo.pin2 = hidl_string();
         iccIo.aid = cardStatus.applications[i].aidPtr;

         radio->iccIOForApp(serial, iccIo);
         EXPECT_EQ(std::cv_status::no_timeout, wait());
         EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
         EXPECT_EQ(serial, radioRsp->rspInfo.serial);
     }
     LOG(DEBUG) << "iccIOForApp finished";
 }

 /*
  * Test IRadio.iccTransmitApduBasicChannel() for the response returned.
  */
 TEST_P(RadioHidlTest, iccTransmitApduBasicChannel) {
     LOG(DEBUG) << "iccTransmitApduBasicChannel";
     serial = GetRandomSerialNumber();
     SimApdu msg;
     memset(&msg, 0, sizeof(msg));
     msg.data = hidl_string();

     radio->iccTransmitApduBasicChannel(serial, msg);
     EXPECT_EQ(std::cv_status::no_timeout, wait());
     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     EXPECT_EQ(serial, radioRsp->rspInfo.serial);

     // TODO(sanketpadawe): Add test for error code
     LOG(DEBUG) << "iccTransmitApduBasicChannel finished";
 }

 /*
  * Test IRadio.iccOpenLogicalChannel() for the response returned.
  */
 TEST_P(RadioHidlTest, iccOpenLogicalChannel) {
     LOG(DEBUG) << "iccOpenLogicalChannel";
     serial = GetRandomSerialNumber();
     int p2 = 0x04;
     // Specified in ISO 7816-4 clause 7.1.1 0x04 means that FCP template is requested.
     for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
         radio->iccOpenLogicalChannel(serial, cardStatus.applications[i].aidPtr, p2);
         EXPECT_EQ(std::cv_status::no_timeout, wait());
         EXPECT_EQ(serial, radioRsp->rspInfo.serial);
         EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     }
     LOG(DEBUG) << "iccOpenLogicalChannel finished";
 }

 /*
  * Test IRadio.iccCloseLogicalChannel() for the response returned.
  */
 TEST_P(RadioHidlTest, iccCloseLogicalChannel) {
     LOG(DEBUG) << "iccCloseLogicalChannel";
     serial = GetRandomSerialNumber();
     // Try closing invalid channel and check INVALID_ARGUMENTS returned as error
     radio->iccCloseLogicalChannel(serial, 0);
     EXPECT_EQ(std::cv_status::no_timeout, wait());
     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     EXPECT_EQ(serial, radioRsp->rspInfo.serial);

     EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
     LOG(DEBUG) << "iccCloseLogicalChannel finished";
 }

 /*
  * Test IRadio.iccTransmitApduLogicalChannel() for the response returned.
  */
 TEST_P(RadioHidlTest, iccTransmitApduLogicalChannel) {
     LOG(DEBUG) << "iccTransmitApduLogicalChannel";
     serial = GetRandomSerialNumber();
     SimApdu msg;
     memset(&msg, 0, sizeof(msg));
     msg.data = hidl_string();

     radio->iccTransmitApduLogicalChannel(serial, msg);
     EXPECT_EQ(std::cv_status::no_timeout, wait());
     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     EXPECT_EQ(serial, radioRsp->rspInfo.serial);

     // TODO(sanketpadawe): Add test for error code
     LOG(DEBUG) << "iccTransmitApduLogicalChannel finished";
 }

 /*
  * Test IRadio.requestIccSimAuthentication() for the response returned.
  */
 TEST_P(RadioHidlTest, requestIccSimAuthentication) {
     LOG(DEBUG) << "requestIccSimAuthentication";
     serial = GetRandomSerialNumber();

     // Pass wrong challenge string and check RadioError::INVALID_ARGUMENTS
     // or REQUEST_NOT_SUPPORTED returned as error.
     for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
         radio->requestIccSimAuthentication(serial, 0, hidl_string("test"),
                                            cardStatus.applications[i].aidPtr);
         EXPECT_EQ(std::cv_status::no_timeout, wait());
         EXPECT_EQ(serial, radioRsp->rspInfo.serial);
         EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::INVALID_ARGUMENTS,
                                                                RadioError::REQUEST_NOT_SUPPORTED}));
     }
     LOG(DEBUG) << "requestIccSimAuthentication finished";
 }

 /*
  * Test IRadio.supplyNetworkDepersonalization() for the response returned.
  */
 TEST_P(RadioHidlTest, supplyNetworkDepersonalization) {
     LOG(DEBUG) << "supplyNetworkDepersonalization";
     serial = GetRandomSerialNumber();

     radio->supplyNetworkDepersonalization(serial, hidl_string("test"));
     EXPECT_EQ(std::cv_status::no_timeout, wait());
     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     EXPECT_EQ(serial, radioRsp->rspInfo.serial);

     if (cardStatus.cardState == CardState::ABSENT) {
         ASSERT_TRUE(CheckAnyOfErrors(
             radioRsp->rspInfo.error,
             {RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INTERNAL_ERR,
              RadioError::INVALID_SIM_STATE, RadioError::MODEM_ERR, RadioError::NO_MEMORY,
              RadioError::PASSWORD_INCORRECT, RadioError::SIM_ABSENT, RadioError::SYSTEM_ERR}));
     }
     LOG(DEBUG) << "supplyNetworkDepersonalization finished";
 }
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <android-base/logging.h>
	#include <radio_hidl_hal_utils_v1_0.h>

	/*
	* Test IRadio.getIccCardStatus() for the response returned.
	*/
	TEST_P(RadioHidlTest, getIccCardStatus) {
	LOG(DEBUG) << "getIccCardStatus";
	EXPECT_LE(cardStatus.applications.size(), (unsigned int)RadioConst::CARD_MAX_APPS);
	EXPECT_LT(cardStatus.gsmUmtsSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
	EXPECT_LT(cardStatus.cdmaSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
	EXPECT_LT(cardStatus.imsSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
	LOG(DEBUG) << "getIccCardStatus finished";
	}

	/*
	* Test IRadio.supplyIccPinForApp() for the response returned
	*/
	TEST_P(RadioHidlTest, supplyIccPinForApp) {
	LOG(DEBUG) << "supplyIccPinForApp";
	serial = GetRandomSerialNumber();

	// Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
	// 3GPP2 apps only
	for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
	if (cardStatus.applications[i].appType == AppType::SIM \|\|
	cardStatus.applications[i].appType == AppType::USIM \|\|
	cardStatus.applications[i].appType == AppType::RUIM \|\|
	cardStatus.applications[i].appType == AppType::CSIM) {
	radio->supplyIccPinForApp(serial, hidl_string("test1"),
	cardStatus.applications[i].aidPtr);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	ASSERT_TRUE(CheckAnyOfErrors(
	radioRsp->rspInfo.error,
	{RadioError::PASSWORD_INCORRECT, RadioError::REQUEST_NOT_SUPPORTED}));
	}
	}
	LOG(DEBUG) << "supplyIccPinForApp finished";
	}

	/*
	* Test IRadio.supplyIccPukForApp() for the response returned.
	*/
	TEST_P(RadioHidlTest, supplyIccPukForApp) {
	LOG(DEBUG) << "supplyIccPukForApp";
	serial = GetRandomSerialNumber();

	// Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
	// 3GPP2 apps only
	for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
	if (cardStatus.applications[i].appType == AppType::SIM \|\|
	cardStatus.applications[i].appType == AppType::USIM \|\|
	cardStatus.applications[i].appType == AppType::RUIM \|\|
	cardStatus.applications[i].appType == AppType::CSIM) {
	radio->supplyIccPukForApp(serial, hidl_string("test1"), hidl_string("test2"),
	cardStatus.applications[i].aidPtr);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::PASSWORD_INCORRECT,
	RadioError::INVALID_SIM_STATE}));
	}
	}
	LOG(DEBUG) << "supplyIccPukForApp finished";
	}

	/*
	* Test IRadio.supplyIccPin2ForApp() for the response returned.
	*/
	TEST_P(RadioHidlTest, supplyIccPin2ForApp) {
	LOG(DEBUG) << "supplyIccPin2ForApp";
	serial = GetRandomSerialNumber();

	// Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
	// 3GPP2 apps only
	for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
	if (cardStatus.applications[i].appType == AppType::SIM \|\|
	cardStatus.applications[i].appType == AppType::USIM \|\|
	cardStatus.applications[i].appType == AppType::RUIM \|\|
	cardStatus.applications[i].appType == AppType::CSIM) {
	radio->supplyIccPin2ForApp(serial, hidl_string("test1"),
	cardStatus.applications[i].aidPtr);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	ASSERT_TRUE(
	CheckAnyOfErrors(radioRsp->rspInfo.error,
	{RadioError::PASSWORD_INCORRECT, RadioError::REQUEST_NOT_SUPPORTED,
	RadioError::SIM_PUK2}));
	}
	}
	LOG(DEBUG) << "supplyIccPin2ForApp finished";
	}

	/*
	* Test IRadio.supplyIccPuk2ForApp() for the response returned.
	*/
	TEST_P(RadioHidlTest, supplyIccPuk2ForApp) {
	LOG(DEBUG) << "supplyIccPuk2ForApp";
	serial = GetRandomSerialNumber();

	// Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
	// 3GPP2 apps only
	for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
	if (cardStatus.applications[i].appType == AppType::SIM \|\|
	cardStatus.applications[i].appType == AppType::USIM \|\|
	cardStatus.applications[i].appType == AppType::RUIM \|\|
	cardStatus.applications[i].appType == AppType::CSIM) {
	radio->supplyIccPuk2ForApp(serial, hidl_string("test1"), hidl_string("test2"),
	cardStatus.applications[i].aidPtr);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::PASSWORD_INCORRECT,
	RadioError::INVALID_SIM_STATE}));
	}
	}
	LOG(DEBUG) << "supplyIccPuk2ForApp finished";
	}

	/*
	* Test IRadio.changeIccPinForApp() for the response returned.
	*/
	TEST_P(RadioHidlTest, changeIccPinForApp) {
	LOG(DEBUG) << "changeIccPinForApp";
	serial = GetRandomSerialNumber();

	// Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
	// 3GPP2 apps only
	for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
	if (cardStatus.applications[i].appType == AppType::SIM \|\|
	cardStatus.applications[i].appType == AppType::USIM \|\|
	cardStatus.applications[i].appType == AppType::RUIM \|\|
	cardStatus.applications[i].appType == AppType::CSIM) {
	radio->changeIccPinForApp(serial, hidl_string("test1"), hidl_string("test2"),
	cardStatus.applications[i].aidPtr);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	ASSERT_TRUE(CheckAnyOfErrors(
	radioRsp->rspInfo.error,
	{RadioError::PASSWORD_INCORRECT, RadioError::REQUEST_NOT_SUPPORTED}));
	}
	}
	LOG(DEBUG) << "changeIccPinForApp finished";
	}

	/*
	* Test IRadio.changeIccPin2ForApp() for the response returned.
	*/
	TEST_P(RadioHidlTest, changeIccPin2ForApp) {
	LOG(DEBUG) << "changeIccPin2ForApp";
	serial = GetRandomSerialNumber();

	// Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
	// 3GPP2 apps only
	for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
	if (cardStatus.applications[i].appType == AppType::SIM \|\|
	cardStatus.applications[i].appType == AppType::USIM \|\|
	cardStatus.applications[i].appType == AppType::RUIM \|\|
	cardStatus.applications[i].appType == AppType::CSIM) {
	radio->changeIccPin2ForApp(serial, hidl_string("test1"), hidl_string("test2"),
	cardStatus.applications[i].aidPtr);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	ASSERT_TRUE(
	CheckAnyOfErrors(radioRsp->rspInfo.error,
	{RadioError::PASSWORD_INCORRECT, RadioError::REQUEST_NOT_SUPPORTED,
	RadioError::SIM_PUK2}));
	}
	}
	LOG(DEBUG) << "changeIccPin2ForApp finished";
	}

	/*
	* The following test is disabled due to b/109889468
	*
	* Test IRadio.getImsiForApp() for the response returned.
	*/
	TEST_P(RadioHidlTest, DISABLED_getImsiForApp) {
	LOG(DEBUG) << "DISABLED_getImsiForApp";
	serial = GetRandomSerialNumber();

	// Check success returned while getting imsi for 3GPP and 3GPP2 apps only
	for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
	if (cardStatus.applications[i].appType == AppType::SIM \|\|
	cardStatus.applications[i].appType == AppType::USIM \|\|
	cardStatus.applications[i].appType == AppType::RUIM \|\|
	cardStatus.applications[i].appType == AppType::CSIM) {
	radio->getImsiForApp(serial, cardStatus.applications[i].aidPtr);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);
	ASSERT_TRUE(
	CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));

	// IMSI (MCC+MNC+MSIN) is at least 6 digits, but not more than 15
	if (radioRsp->rspInfo.error == RadioError::NONE) {
	EXPECT_NE(radioRsp->imsi, hidl_string());
	EXPECT_GE((int)(radioRsp->imsi).size(), 6);
	EXPECT_LE((int)(radioRsp->imsi).size(), 15);
	}
	}
	}
	LOG(DEBUG) << "DISABLED_getImsiForApp finished";
	}

	/*
	* Test IRadio.iccIOForApp() for the response returned.
	*/
	TEST_P(RadioHidlTest, iccIOForApp) {
	LOG(DEBUG) << "iccIOForApp";
	serial = GetRandomSerialNumber();

	for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
	IccIo iccIo;
	iccIo.command = 0xc0;
	iccIo.fileId = 0x6f11;
	iccIo.path = hidl_string("3F007FFF");
	iccIo.p1 = 0;
	iccIo.p2 = 0;
	iccIo.p3 = 0;
	iccIo.data = hidl_string();
	iccIo.pin2 = hidl_string();
	iccIo.aid = cardStatus.applications[i].aidPtr;

	radio->iccIOForApp(serial, iccIo);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);
	}
	LOG(DEBUG) << "iccIOForApp finished";
	}

	/*
	* Test IRadio.iccTransmitApduBasicChannel() for the response returned.
	*/
	TEST_P(RadioHidlTest, iccTransmitApduBasicChannel) {
	LOG(DEBUG) << "iccTransmitApduBasicChannel";
	serial = GetRandomSerialNumber();
	SimApdu msg;
	memset(&msg, 0, sizeof(msg));
	msg.data = hidl_string();

	radio->iccTransmitApduBasicChannel(serial, msg);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);

	// TODO(sanketpadawe): Add test for error code
	LOG(DEBUG) << "iccTransmitApduBasicChannel finished";
	}

	/*
	* Test IRadio.iccOpenLogicalChannel() for the response returned.
	*/
	TEST_P(RadioHidlTest, iccOpenLogicalChannel) {
	LOG(DEBUG) << "iccOpenLogicalChannel";
	serial = GetRandomSerialNumber();
	int p2 = 0x04;
	// Specified in ISO 7816-4 clause 7.1.1 0x04 means that FCP template is requested.
	for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
	radio->iccOpenLogicalChannel(serial, cardStatus.applications[i].aidPtr, p2);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	}
	LOG(DEBUG) << "iccOpenLogicalChannel finished";
	}

	/*
	* Test IRadio.iccCloseLogicalChannel() for the response returned.
	*/
	TEST_P(RadioHidlTest, iccCloseLogicalChannel) {
	LOG(DEBUG) << "iccCloseLogicalChannel";
	serial = GetRandomSerialNumber();
	// Try closing invalid channel and check INVALID_ARGUMENTS returned as error
	radio->iccCloseLogicalChannel(serial, 0);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);

	EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
	LOG(DEBUG) << "iccCloseLogicalChannel finished";
	}

	/*
	* Test IRadio.iccTransmitApduLogicalChannel() for the response returned.
	*/
	TEST_P(RadioHidlTest, iccTransmitApduLogicalChannel) {
	LOG(DEBUG) << "iccTransmitApduLogicalChannel";
	serial = GetRandomSerialNumber();
	SimApdu msg;
	memset(&msg, 0, sizeof(msg));
	msg.data = hidl_string();

	radio->iccTransmitApduLogicalChannel(serial, msg);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);

	// TODO(sanketpadawe): Add test for error code
	LOG(DEBUG) << "iccTransmitApduLogicalChannel finished";
	}

	/*
	* Test IRadio.requestIccSimAuthentication() for the response returned.
	*/
	TEST_P(RadioHidlTest, requestIccSimAuthentication) {
	LOG(DEBUG) << "requestIccSimAuthentication";
	serial = GetRandomSerialNumber();

	// Pass wrong challenge string and check RadioError::INVALID_ARGUMENTS
	// or REQUEST_NOT_SUPPORTED returned as error.
	for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
	radio->requestIccSimAuthentication(serial, 0, hidl_string("test"),
	cardStatus.applications[i].aidPtr);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::INVALID_ARGUMENTS,
	RadioError::REQUEST_NOT_SUPPORTED}));
	}
	LOG(DEBUG) << "requestIccSimAuthentication finished";
	}

	/*
	* Test IRadio.supplyNetworkDepersonalization() for the response returned.
	*/
	TEST_P(RadioHidlTest, supplyNetworkDepersonalization) {
	LOG(DEBUG) << "supplyNetworkDepersonalization";
	serial = GetRandomSerialNumber();

	radio->supplyNetworkDepersonalization(serial, hidl_string("test"));
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
	EXPECT_EQ(serial, radioRsp->rspInfo.serial);

	if (cardStatus.cardState == CardState::ABSENT) {
	ASSERT_TRUE(CheckAnyOfErrors(
	radioRsp->rspInfo.error,
	{RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INTERNAL_ERR,
	RadioError::INVALID_SIM_STATE, RadioError::MODEM_ERR, RadioError::NO_MEMORY,
	RadioError::PASSWORD_INCORRECT, RadioError::SIM_ABSENT, RadioError::SYSTEM_ERR}));
	}
	LOG(DEBUG) << "supplyNetworkDepersonalization finished";
	}