Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3d1a53c2 authored by Jack Yu's avatar Jack Yu
Browse files

Removed CDMA related VTS 

CDMA has been deprecated and unsupported by telephony. Removing
the corresponding CDMA tests

Bug: 401603718
Test: VTS
Flag: EXEMPT test cleanup
Change-Id: I0291ed5de682905bd1c47e47c6875bdbf5f00022
parent 76c09aa6

radio/aidl/vts/radio_aidl_hal_utils.h

+0 −2
Original line number Diff line number Diff line
@@ -65,8 +65,6 @@ static constexpr const char* FEATURE_VOICE_CALL = "android.software.connectionse 


static constexpr const char* FEATURE_TELEPHONY = "android.hardware.telephony";



static constexpr const char* FEATURE_TELEPHONY_CDMA = "android.hardware.telephony.cdma";



static constexpr const char* FEATURE_TELEPHONY_IMS = "android.hardware.telephony.ims";



static constexpr const char* FEATURE_TELEPHONY_CALLING = "android.hardware.telephony.calling";

radio/aidl/vts/radio_messaging_test.cpp

+0 −318
Original line number Diff line number Diff line
@@ -112,104 +112,6 @@ TEST_P(RadioMessagingTest, sendSmsExpectMore) { 
    }

}



/*

 * Test IRadioMessaging.sendCdmaSms() for the response returned.

 */

TEST_P(RadioMessagingTest, sendCdmaSms) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping sendCdmaSms "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();



    // Create a CdmaSmsAddress

    CdmaSmsAddress cdmaSmsAddress;

    cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;

    cdmaSmsAddress.isNumberModeDataNetwork = false;

    cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;

    cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;

    cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};



    // Create a CdmaSmsSubAddress

    CdmaSmsSubaddress cdmaSmsSubaddress;

    cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;

    cdmaSmsSubaddress.odd = false;

    cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};



    // Create a CdmaSmsMessage

    CdmaSmsMessage cdmaSmsMessage;

    cdmaSmsMessage.teleserviceId = 4098;

    cdmaSmsMessage.isServicePresent = false;

    cdmaSmsMessage.serviceCategory = 0;

    cdmaSmsMessage.address = cdmaSmsAddress;

    cdmaSmsMessage.subAddress = cdmaSmsSubaddress;

    cdmaSmsMessage.bearerData =

            (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};



    radio_messaging->sendCdmaSms(serial, cdmaSmsMessage);



    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(CheckAnyOfErrors(

                radioRsp_messaging->rspInfo.error,

                {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE, RadioError::SIM_ABSENT},

                CHECK_GENERAL_ERROR));

    }

}



/*

 * Test IRadioMessaging.sendCdmaSmsExpectMore() for the response returned.

 */

TEST_P(RadioMessagingTest, sendCdmaSmsExpectMore) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping sendCdmaSmsExpectMore "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();



    // Create a CdmaSmsAddress

    CdmaSmsAddress cdmaSmsAddress;

    cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;

    cdmaSmsAddress.isNumberModeDataNetwork = false;

    cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;

    cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;

    cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};



    // Create a CdmaSmsSubAddress

    CdmaSmsSubaddress cdmaSmsSubaddress;

    cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;

    cdmaSmsSubaddress.odd = false;

    cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};



    // Create a CdmaSmsMessage

    CdmaSmsMessage cdmaSmsMessage;

    cdmaSmsMessage.teleserviceId = 4098;

    cdmaSmsMessage.isServicePresent = false;

    cdmaSmsMessage.serviceCategory = 0;

    cdmaSmsMessage.address = cdmaSmsAddress;

    cdmaSmsMessage.subAddress = cdmaSmsSubaddress;

    cdmaSmsMessage.bearerData =

            (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};



    radio_messaging->sendCdmaSmsExpectMore(serial, cdmaSmsMessage);



    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(CheckAnyOfErrors(

                radioRsp_messaging->rspInfo.error,

                {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE, RadioError::SIM_ABSENT},

                CHECK_GENERAL_ERROR));

    }

}



/*

 * Test IRadioMessaging.setGsmBroadcastConfig() for the response returned.

 */
@@ -303,85 +205,6 @@ TEST_P(RadioMessagingTest, getGsmBroadcastConfig) { 
    }

}



/*

 * Test IRadioMessaging.setCdmaBroadcastConfig() for the response returned.

 */

TEST_P(RadioMessagingTest, setCdmaBroadcastConfig) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping setCdmaBroadcastConfig "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();



    CdmaBroadcastSmsConfigInfo cbSmsConfig;

    cbSmsConfig.serviceCategory = 4096;

    cbSmsConfig.language = 1;

    cbSmsConfig.selected = true;



    std::vector<CdmaBroadcastSmsConfigInfo> cdmaBroadcastSmsConfigInfoList = {cbSmsConfig};



    radio_messaging->setCdmaBroadcastConfig(serial, cdmaBroadcastSmsConfigInfoList);



    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,

                                     {RadioError::NONE, RadioError::INVALID_MODEM_STATE},

                                     CHECK_GENERAL_ERROR));

    }

}



/*

 * Test IRadioMessaging.getCdmaBroadcastConfig() for the response returned.

 */

TEST_P(RadioMessagingTest, getCdmaBroadcastConfig) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping getCdmaBroadcastConfig "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();



    radio_messaging->getCdmaBroadcastConfig(serial);



    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error, {RadioError::NONE},

                                     CHECK_GENERAL_ERROR));

    }

}



/*

 * Test IRadioMessaging.setCdmaBroadcastActivation() for the response returned.

 */

TEST_P(RadioMessagingTest, setCdmaBroadcastActivation) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping setCdmaBroadcastActivation "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();

    bool activate = false;



    radio_messaging->setCdmaBroadcastActivation(serial, activate);



    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,

                                     {RadioError::NONE, RadioError::INVALID_ARGUMENTS},

                                     CHECK_GENERAL_ERROR));

    }

}



/*

 * Test IRadioMessaging.setGsmBroadcastActivation() for the response returned.

 */
@@ -461,35 +284,6 @@ TEST_P(RadioMessagingTest, acknowledgeIncomingGsmSmsWithPdu) { 
    }

}



/*

 * Test IRadioMessaging.acknowledgeLastIncomingCdmaSms() for the response returned.

 */

TEST_P(RadioMessagingTest, acknowledgeLastIncomingCdmaSms) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping acknowledgeIncomingGsmSmsWithPdu "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();



    // Create a CdmaSmsAck

    CdmaSmsAck cdmaSmsAck;

    cdmaSmsAck.errorClass = false;

    cdmaSmsAck.smsCauseCode = 1;



    radio_messaging->acknowledgeLastIncomingCdmaSms(serial, cdmaSmsAck);



    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,

                                     {RadioError::INVALID_ARGUMENTS, RadioError::NO_SMS_TO_ACK},

                                     CHECK_GENERAL_ERROR));

    }

}



/*

 * Test IRadioMessaging.sendImsSms() for the response returned.

 */
@@ -655,118 +449,6 @@ TEST_P(RadioMessagingTest, deleteSmsOnSim) { 
    }

}



/*

 * Test IRadioMessaging.writeSmsToRuim() for the response returned.

 */

TEST_P(RadioMessagingTest, writeSmsToRuim) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping writeSmsToRuim "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();



    // Create a CdmaSmsAddress

    CdmaSmsAddress cdmaSmsAddress;

    cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;

    cdmaSmsAddress.isNumberModeDataNetwork = false;

    cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;

    cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;

    cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};



    // Create a CdmaSmsSubAddress

    CdmaSmsSubaddress cdmaSmsSubaddress;

    cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;

    cdmaSmsSubaddress.odd = false;

    cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};



    // Create a CdmaSmsMessage

    CdmaSmsMessage cdmaSmsMessage;

    cdmaSmsMessage.teleserviceId = 4098;

    cdmaSmsMessage.isServicePresent = false;

    cdmaSmsMessage.serviceCategory = 0;

    cdmaSmsMessage.address = cdmaSmsAddress;

    cdmaSmsMessage.subAddress = cdmaSmsSubaddress;

    cdmaSmsMessage.bearerData =

            (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};



    // Create a CdmaSmsWriteArgs

    CdmaSmsWriteArgs cdmaSmsWriteArgs;

    cdmaSmsWriteArgs.status = CdmaSmsWriteArgs::STATUS_REC_UNREAD;

    cdmaSmsWriteArgs.message = cdmaSmsMessage;



    radio_messaging->writeSmsToRuim(serial, cdmaSmsWriteArgs);



    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(CheckAnyOfErrors(

                radioRsp_messaging->rspInfo.error,

                {RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INVALID_SMS_FORMAT,

                 RadioError::INVALID_SMSC_ADDRESS, RadioError::INVALID_STATE, RadioError::MODEM_ERR,

                 RadioError::NO_SUCH_ENTRY, RadioError::SIM_ABSENT},

                CHECK_GENERAL_ERROR));

    }

}



/*

 * Test IRadioMessaging.deleteSmsOnRuim() for the response returned.

 */

TEST_P(RadioMessagingTest, deleteSmsOnRuim) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping deleteSmsOnRuim "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();

    int index = 1;



    // Create a CdmaSmsAddress

    CdmaSmsAddress cdmaSmsAddress;

    cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;

    cdmaSmsAddress.isNumberModeDataNetwork = false;

    cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;

    cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;

    cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};



    // Create a CdmaSmsSubAddress

    CdmaSmsSubaddress cdmaSmsSubaddress;

    cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;

    cdmaSmsSubaddress.odd = false;

    cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};



    // Create a CdmaSmsMessage

    CdmaSmsMessage cdmaSmsMessage;

    cdmaSmsMessage.teleserviceId = 4098;

    cdmaSmsMessage.isServicePresent = false;

    cdmaSmsMessage.serviceCategory = 0;

    cdmaSmsMessage.address = cdmaSmsAddress;

    cdmaSmsMessage.subAddress = cdmaSmsSubaddress;

    cdmaSmsMessage.bearerData =

            (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};



    // Create a CdmaSmsWriteArgs

    CdmaSmsWriteArgs cdmaSmsWriteArgs;

    cdmaSmsWriteArgs.status = CdmaSmsWriteArgs::STATUS_REC_UNREAD;

    cdmaSmsWriteArgs.message = cdmaSmsMessage;



    radio_messaging->deleteSmsOnRuim(serial, index);



    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(CheckAnyOfErrors(

                radioRsp_messaging->rspInfo.error,

                {RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INVALID_MODEM_STATE,

                 RadioError::MODEM_ERR, RadioError::NO_SUCH_ENTRY, RadioError::SIM_ABSENT},

                CHECK_GENERAL_ERROR));

    }

}



/*

 * Test IRadioMessaging.reportSmsMemoryStatus() for the response returned.

 */

radio/aidl/vts/radio_modem_test.cpp

+0 −23
Original line number Diff line number Diff line
@@ -284,29 +284,6 @@ TEST_P(RadioModemTest, nvWriteItem) { 
    }

}



/*

 * Test IRadioModem.nvWriteCdmaPrl() for the response returned.

 */

TEST_P(RadioModemTest, nvWriteCdmaPrl) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping nvWriteCdmaPrl "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();

    std::vector<uint8_t> prl = {1, 2, 3, 4, 5};



    radio_modem->nvWriteCdmaPrl(serial, std::vector<uint8_t>(prl));

    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_modem->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_modem->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(CheckAnyOfErrors(radioRsp_modem->rspInfo.error, {RadioError::NONE},

                                     CHECK_GENERAL_ERROR));

    }

}



/*

 * Test IRadioModem.nvResetConfig() for the response returned.

 */

radio/aidl/vts/radio_network_test.cpp

+0 −95
Original line number Diff line number Diff line
@@ -589,42 +589,6 @@ TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Eutran_RSSNR) { 
    EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);

}



/*

 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for CDMA2000

 */

TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Cdma2000) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {

        GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_Cdma2000 "

                        "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";

    }



    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_Cdma2000 "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();



    SignalThresholdInfo signalThresholdInfo;

    signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;

    signalThresholdInfo.hysteresisMs = 5000;

    signalThresholdInfo.hysteresisDb = 2;

    signalThresholdInfo.thresholds = {-105, -90, -75, -65};

    signalThresholdInfo.isEnabled = true;

    signalThresholdInfo.ran = AccessNetwork::CDMA2000;



    ndk::ScopedAStatus res =

            radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});

    ASSERT_OK(res);

    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);



    ALOGI("setSignalStrengthReportingCriteria_Cdma2000, rspInfo.error = %s\n",

          toString(radioRsp_network->rspInfo.error).c_str());

    ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));

}



/*

 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for NGRAN_SSRSRP

 */
@@ -790,15 +754,6 @@ TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_multiRansPerRequest) 
    signalThresholdInfoEutran.isEnabled = true;

    signalThresholdInfoEutran.ran = AccessNetwork::EUTRAN;



    SignalThresholdInfo signalThresholdInfoCdma2000;

    signalThresholdInfoCdma2000.signalMeasurement =

            SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;

    signalThresholdInfoCdma2000.hysteresisMs = 5000;

    signalThresholdInfoCdma2000.hysteresisDb = 2;

    signalThresholdInfoCdma2000.thresholds = {-105, -90, -75, -65};

    signalThresholdInfoCdma2000.isEnabled = true;

    signalThresholdInfoCdma2000.ran = AccessNetwork::CDMA2000;



    SignalThresholdInfo signalThresholdInfoNgran;

    signalThresholdInfoNgran.signalMeasurement =

            SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_SSRSRP;
@@ -811,9 +766,6 @@ TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_multiRansPerRequest) 
    std::vector<SignalThresholdInfo> candidateSignalThresholdInfos = {

            signalThresholdInfoGeran, signalThresholdInfoUtran, signalThresholdInfoEutran,

            signalThresholdInfoNgran};

    if (deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        candidateSignalThresholdInfos.push_back(signalThresholdInfoCdma2000);

    }



    std::vector<SignalThresholdInfo> supportedSignalThresholdInfos;

    for (size_t i = 0; i < candidateSignalThresholdInfos.size(); i++) {
@@ -2014,53 +1966,6 @@ TEST_P(RadioNetworkTest, setLocationUpdates) { 
    }

}



/*

 * Test IRadioNetwork.setCdmaRoamingPreference() for the response returned.

 */

TEST_P(RadioNetworkTest, setCdmaRoamingPreference) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping setCdmaRoamingPreference "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();



    radio_network->setCdmaRoamingPreference(serial, CdmaRoamingType::HOME_NETWORK);

    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(CheckAnyOfErrors(

                radioRsp_network->rspInfo.error,

                {RadioError::NONE, RadioError::SIM_ABSENT, RadioError::REQUEST_NOT_SUPPORTED}));

    }

}



/*

 * Test IRadioNetwork.getCdmaRoamingPreference() for the response returned.

 */

TEST_P(RadioNetworkTest, getCdmaRoamingPreference) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping getCdmaRoamingPreference "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();



    radio_network->getCdmaRoamingPreference(serial);

    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(

                CheckAnyOfErrors(radioRsp_network->rspInfo.error,

                                 {RadioError::NONE, RadioError::SIM_ABSENT, RadioError::MODEM_ERR},

                                 CHECK_GENERAL_ERROR));

    }

}



/*

 * Test IRadioNetwork.getVoiceRadioTechnology() for the response returned.

 */

radio/aidl/vts/radio_sim_test.cpp

+0 −100
Original line number Diff line number Diff line
@@ -1065,106 +1065,6 @@ TEST_P(RadioSimTest, setFacilityLockForApp) { 
    }

}



/*

 * Test IRadioSim.getCdmaSubscription() for the response returned.

 */

TEST_P(RadioSimTest, getCdmaSubscription) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping getCdmaSubscription "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();



    radio_sim->getCdmaSubscription(serial);

    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_sim->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_sim->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(CheckAnyOfErrors(

                radioRsp_sim->rspInfo.error,

                {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::SIM_ABSENT}));

    }

}



/*

 * Test IRadioSim.getCdmaSubscriptionSource() for the response returned.

 */

TEST_P(RadioSimTest, getCdmaSubscriptionSource) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping getCdmaSubscriptionSource "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();



    radio_sim->getCdmaSubscriptionSource(serial);

    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_sim->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_sim->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(CheckAnyOfErrors(

                radioRsp_sim->rspInfo.error,

                {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::SIM_ABSENT}));

    }

}



/*

 * Test IRadioSim.setCdmaSubscriptionSource() for the response returned.

 */

TEST_P(RadioSimTest, setCdmaSubscriptionSource) {

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {

        GTEST_SKIP() << "Skipping setCdmaSubscriptionSource "

                        "due to undefined FEATURE_TELEPHONY_CDMA";

    }



    serial = GetRandomSerialNumber();



    radio_sim->setCdmaSubscriptionSource(serial, CdmaSubscriptionSource::RUIM_SIM);

    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_sim->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_sim->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(CheckAnyOfErrors(

                radioRsp_sim->rspInfo.error,

                {RadioError::NONE, RadioError::SIM_ABSENT, RadioError::SUBSCRIPTION_NOT_AVAILABLE},

                CHECK_GENERAL_ERROR));

    }

}



/*

 * Test IRadioSim.setUiccSubscription() for the response returned.

 */

TEST_P(RadioSimTest, setUiccSubscription) {

    if (!shouldTestCdma()) {

        GTEST_SKIP() << "Skipping CDMA testing (deprecated)";

    }

    if (!deviceSupportsFeature(FEATURE_TELEPHONY_SUBSCRIPTION)) {

        GTEST_SKIP() << "Skipping setUiccSubscription "

                        "due to undefined FEATURE_TELEPHONY_SUBSCRIPTION";

    }



    serial = GetRandomSerialNumber();

    SelectUiccSub item;

    memset(&item, 0, sizeof(item));



    radio_sim->setUiccSubscription(serial, item);

    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_sim->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_sim->rspInfo.serial);



    if (cardStatus.cardState == CardStatus::STATE_ABSENT) {

        ASSERT_TRUE(

                CheckAnyOfErrors(radioRsp_sim->rspInfo.error,

                                 {RadioError::NONE, RadioError::INVALID_ARGUMENTS,

                                  RadioError::MODEM_ERR, RadioError::SUBSCRIPTION_NOT_SUPPORTED},

                                 CHECK_GENERAL_ERROR));

    }

}



/*

 * Test IRadioSim.sendEnvelope() for the response returned.

 */