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.getSignalStrength() for the response returned.
     21  */
     22 TEST_F(RadioHidlTest, getSignalStrength) {
     23     serial = GetRandomSerialNumber();
     24 
     25     radio->getSignalStrength(serial);
     26     EXPECT_EQ(std::cv_status::no_timeout, wait());
     27     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     28     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
     29 
     30     if (cardStatus.cardState == CardState::ABSENT) {
     31         EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
     32     }
     33 }
     34 
     35 /*
     36  * Test IRadio.getVoiceRegistrationState() for the response returned.
     37  */
     38 TEST_F(RadioHidlTest, getVoiceRegistrationState) {
     39     serial = GetRandomSerialNumber();
     40 
     41     radio->getVoiceRegistrationState(serial);
     42     EXPECT_EQ(std::cv_status::no_timeout, wait());
     43     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     44     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
     45 
     46     if (cardStatus.cardState == CardState::ABSENT) {
     47         EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
     48     }
     49 }
     50 
     51 /*
     52  * Test IRadio.getOperator() for the response returned.
     53  */
     54 TEST_F(RadioHidlTest, getOperator) {
     55     serial = GetRandomSerialNumber();
     56 
     57     radio->getOperator(serial);
     58     EXPECT_EQ(std::cv_status::no_timeout, wait());
     59     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     60     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
     61 
     62     if (cardStatus.cardState == CardState::ABSENT) {
     63         EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
     64     }
     65 }
     66 
     67 /*
     68  * Test IRadio.setRadioPower() for the response returned.
     69  */
     70 TEST_F(RadioHidlTest, setRadioPower) {
     71     serial = GetRandomSerialNumber();
     72 
     73     radio->setRadioPower(serial, 1);
     74     EXPECT_EQ(std::cv_status::no_timeout, wait());
     75     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     76     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
     77 
     78     if (cardStatus.cardState == CardState::ABSENT) {
     79         EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
     80     }
     81 }
     82 
     83 /*
     84  * Test IRadio.getNetworkSelectionMode() for the response returned.
     85  */
     86 TEST_F(RadioHidlTest, getNetworkSelectionMode) {
     87     serial = GetRandomSerialNumber();
     88 
     89     radio->getNetworkSelectionMode(serial);
     90     EXPECT_EQ(std::cv_status::no_timeout, wait());
     91     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     92     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
     93 
     94     if (cardStatus.cardState == CardState::ABSENT) {
     95         EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
     96     }
     97 }
     98 
     99 /*
    100  * Test IRadio.setNetworkSelectionModeAutomatic() for the response returned.
    101  */
    102 TEST_F(RadioHidlTest, setNetworkSelectionModeAutomatic) {
    103     serial = GetRandomSerialNumber();
    104 
    105     radio->setNetworkSelectionModeAutomatic(serial);
    106     EXPECT_EQ(std::cv_status::no_timeout, wait());
    107     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    108     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    109 
    110     if (cardStatus.cardState == CardState::ABSENT) {
    111         ASSERT_TRUE(CheckAnyOfErrors(
    112             radioRsp->rspInfo.error,
    113             {RadioError::NONE, RadioError::ILLEGAL_SIM_OR_ME, RadioError::OPERATION_NOT_ALLOWED},
    114             CHECK_GENERAL_ERROR));
    115     }
    116 }
    117 
    118 /*
    119  * Test IRadio.setNetworkSelectionModeManual() for the response returned.
    120  */
    121 TEST_F(RadioHidlTest, setNetworkSelectionModeManual) {
    122     serial = GetRandomSerialNumber();
    123 
    124     radio->setNetworkSelectionModeManual(serial, "123456");
    125     EXPECT_EQ(std::cv_status::no_timeout, wait());
    126     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    127     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    128 
    129     if (cardStatus.cardState == CardState::ABSENT) {
    130         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    131                                      {RadioError::NONE, RadioError::ILLEGAL_SIM_OR_ME,
    132                                       RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE},
    133                                      CHECK_GENERAL_ERROR));
    134     }
    135 }
    136 
    137 /*
    138  * Test IRadio.getAvailableNetworks() for the response returned.
    139  */
    140 TEST_F(RadioHidlTest, getAvailableNetworks) {
    141     serial = GetRandomSerialNumber();
    142 
    143     radio->getAvailableNetworks(serial);
    144     EXPECT_EQ(std::cv_status::no_timeout, wait(300));
    145     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    146     ASSERT_TRUE(radioRsp->rspInfo.type == RadioResponseType::SOLICITED ||
    147                 radioRsp->rspInfo.type == RadioResponseType::SOLICITED_ACK_EXP);
    148 
    149     if (cardStatus.cardState == CardState::ABSENT) {
    150         ASSERT_TRUE(
    151             CheckAnyOfErrors(radioRsp->rspInfo.error,
    152                              {RadioError::NONE, RadioError::CANCELLED, RadioError::DEVICE_IN_USE,
    153                               RadioError::MODEM_ERR, RadioError::OPERATION_NOT_ALLOWED},
    154                              CHECK_GENERAL_ERROR));
    155   }
    156 }
    157 
    158 /*
    159  * Test IRadio.getBasebandVersion() for the response returned.
    160  */
    161 TEST_F(RadioHidlTest, getBasebandVersion) {
    162     serial = GetRandomSerialNumber();
    163 
    164     radio->getBasebandVersion(serial);
    165     EXPECT_EQ(std::cv_status::no_timeout, wait());
    166     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    167     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    168 
    169     if (cardStatus.cardState == CardState::ABSENT) {
    170         EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
    171     }
    172 }
    173 
    174 /*
    175  * Test IRadio.setBandMode() for the response returned.
    176  */
    177 TEST_F(RadioHidlTest, setBandMode) {
    178     serial = GetRandomSerialNumber();
    179 
    180     radio->setBandMode(serial, RadioBandMode::BAND_MODE_USA);
    181     EXPECT_EQ(std::cv_status::no_timeout, wait());
    182     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    183     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    184 
    185     if (cardStatus.cardState == CardState::ABSENT) {
    186         ASSERT_TRUE(
    187             CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
    188     }
    189 }
    190 
    191 /*
    192  * Test IRadio.getAvailableBandModes() for the response returned.
    193  */
    194 TEST_F(RadioHidlTest, getAvailableBandModes) {
    195     serial = GetRandomSerialNumber();
    196 
    197     radio->getAvailableBandModes(serial);
    198     EXPECT_EQ(std::cv_status::no_timeout, wait());
    199     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    200     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    201 
    202     if (cardStatus.cardState == CardState::ABSENT) {
    203         EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
    204     }
    205 }
    206 
    207 /*
    208  * Test IRadio.setPreferredNetworkType() for the response returned.
    209  */
    210 TEST_F(RadioHidlTest, setPreferredNetworkType) {
    211     serial = GetRandomSerialNumber();
    212 
    213     radio->setPreferredNetworkType(serial, PreferredNetworkType::GSM_ONLY);
    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     if (cardStatus.cardState == CardState::ABSENT) {
    219         ASSERT_TRUE(
    220             CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
    221     }
    222 }
    223 
    224 /*
    225  * Test IRadio.getPreferredNetworkType() for the response returned.
    226  */
    227 TEST_F(RadioHidlTest, getPreferredNetworkType) {
    228     serial = GetRandomSerialNumber();
    229 
    230     radio->getPreferredNetworkType(serial);
    231     EXPECT_EQ(std::cv_status::no_timeout, wait());
    232     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    233     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    234 
    235     if (cardStatus.cardState == CardState::ABSENT) {
    236         EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
    237     }
    238 }
    239 
    240 /*
    241  * Test IRadio.getNeighboringCids() for the response returned.
    242  */
    243 TEST_F(RadioHidlTest, getNeighboringCids) {
    244     serial = GetRandomSerialNumber();
    245 
    246     radio->getNeighboringCids(serial);
    247     EXPECT_EQ(std::cv_status::no_timeout, wait());
    248     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    249     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    250 
    251     if (cardStatus.cardState == CardState::ABSENT) {
    252         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    253                                      {RadioError::NONE, RadioError::SIM_ABSENT},
    254                                      CHECK_GENERAL_ERROR));
    255     }
    256 }
    257 
    258 /*
    259  * Test IRadio.setLocationUpdates() for the response returned.
    260  */
    261 TEST_F(RadioHidlTest, setLocationUpdates) {
    262     serial = GetRandomSerialNumber();
    263 
    264     radio->setLocationUpdates(serial, true);
    265     EXPECT_EQ(std::cv_status::no_timeout, wait());
    266     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    267     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    268 
    269     if (cardStatus.cardState == CardState::ABSENT) {
    270         ASSERT_TRUE(
    271             CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE, RadioError::SIM_ABSENT}));
    272     }
    273 }
    274 
    275 /*
    276  * Test IRadio.setCdmaRoamingPreference() for the response returned.
    277  */
    278 TEST_F(RadioHidlTest, setCdmaRoamingPreference) {
    279     serial = GetRandomSerialNumber();
    280 
    281     radio->setCdmaRoamingPreference(serial, CdmaRoamingType::HOME_NETWORK);
    282     EXPECT_EQ(std::cv_status::no_timeout, wait());
    283     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    284     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    285 
    286     if (cardStatus.cardState == CardState::ABSENT) {
    287         ASSERT_TRUE(CheckAnyOfErrors(
    288             radioRsp->rspInfo.error,
    289             {RadioError::NONE, RadioError::SIM_ABSENT, RadioError::REQUEST_NOT_SUPPORTED}));
    290     }
    291 }
    292 
    293 /*
    294  * Test IRadio.getCdmaRoamingPreference() for the response returned.
    295  */
    296 TEST_F(RadioHidlTest, getCdmaRoamingPreference) {
    297     serial = GetRandomSerialNumber();
    298 
    299     radio->getCdmaRoamingPreference(serial);
    300     EXPECT_EQ(std::cv_status::no_timeout, wait());
    301     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    302     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    303 
    304     if (cardStatus.cardState == CardState::ABSENT) {
    305         ASSERT_TRUE(
    306             CheckAnyOfErrors(radioRsp->rspInfo.error,
    307                              {RadioError::NONE, RadioError::SIM_ABSENT, RadioError::MODEM_ERR},
    308                              CHECK_GENERAL_ERROR));
    309     }
    310 }
    311 
    312 /*
    313  * Test IRadio.getTTYMode() for the response returned.
    314  */
    315 TEST_F(RadioHidlTest, getTTYMode) {
    316     serial = GetRandomSerialNumber();
    317 
    318     radio->getTTYMode(serial);
    319     EXPECT_EQ(std::cv_status::no_timeout, wait());
    320     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    321     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    322 
    323     if (cardStatus.cardState == CardState::ABSENT) {
    324         EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
    325     }
    326 }
    327 
    328 /*
    329  * Test IRadio.setTTYMode() for the response returned.
    330  */
    331 TEST_F(RadioHidlTest, setTTYMode) {
    332     serial = GetRandomSerialNumber();
    333 
    334     radio->setTTYMode(serial, TtyMode::OFF);
    335     EXPECT_EQ(std::cv_status::no_timeout, wait());
    336     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    337     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    338 
    339     if (cardStatus.cardState == CardState::ABSENT) {
    340         EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
    341     }
    342 }
    343 
    344 /*
    345  * Test IRadio.setPreferredVoicePrivacy() for the response returned.
    346  */
    347 TEST_F(RadioHidlTest, setPreferredVoicePrivacy) {
    348     serial = GetRandomSerialNumber();
    349 
    350     radio->setPreferredVoicePrivacy(serial, true);
    351     EXPECT_EQ(std::cv_status::no_timeout, wait());
    352     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    353     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    354 
    355     if (cardStatus.cardState == CardState::ABSENT) {
    356         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    357                                      {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
    358     }
    359 }
    360 
    361 /*
    362  * Test IRadio.getPreferredVoicePrivacy() for the response returned.
    363  */
    364 TEST_F(RadioHidlTest, getPreferredVoicePrivacy) {
    365     serial = GetRandomSerialNumber();
    366 
    367     radio->getPreferredVoicePrivacy(serial);
    368     EXPECT_EQ(std::cv_status::no_timeout, wait());
    369     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    370     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    371 
    372     if (cardStatus.cardState == CardState::ABSENT) {
    373         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    374                                      {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
    375     }
    376 }
    377 
    378 /*
    379  * Test IRadio.getCDMASubscription() for the response returned.
    380  */
    381 TEST_F(RadioHidlTest, getCDMASubscription) {
    382     serial = GetRandomSerialNumber();
    383 
    384     radio->getCDMASubscription(serial);
    385     EXPECT_EQ(std::cv_status::no_timeout, wait());
    386     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    387     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    388 
    389     if (cardStatus.cardState == CardState::ABSENT) {
    390         ASSERT_TRUE(CheckAnyOfErrors(
    391             radioRsp->rspInfo.error,
    392             {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::SIM_ABSENT}));
    393     }
    394 }
    395 
    396 /*
    397  * Test IRadio.getDeviceIdentity() for the response returned.
    398  */
    399 TEST_F(RadioHidlTest, getDeviceIdentity) {
    400     serial = GetRandomSerialNumber();
    401 
    402     radio->getDeviceIdentity(serial);
    403     EXPECT_EQ(std::cv_status::no_timeout, wait());
    404     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    405     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    406 
    407     if (cardStatus.cardState == CardState::ABSENT) {
    408         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    409                                      {RadioError::NONE, RadioError::EMPTY_RECORD}));
    410     }
    411 }
    412 
    413 /*
    414  * Test IRadio.exitEmergencyCallbackMode() for the response returned.
    415  */
    416 TEST_F(RadioHidlTest, exitEmergencyCallbackMode) {
    417     serial = GetRandomSerialNumber();
    418 
    419     radio->exitEmergencyCallbackMode(serial);
    420     EXPECT_EQ(std::cv_status::no_timeout, wait());
    421     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    422     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    423 
    424     if (cardStatus.cardState == CardState::ABSENT) {
    425         ASSERT_TRUE(CheckAnyOfErrors(
    426             radioRsp->rspInfo.error,
    427             {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::SIM_ABSENT}));
    428     }
    429 }
    430 
    431 /*
    432  * Test IRadio.getCdmaSubscriptionSource() for the response returned.
    433  */
    434 TEST_F(RadioHidlTest, getCdmaSubscriptionSource) {
    435     serial = GetRandomSerialNumber();
    436 
    437     radio->getCdmaSubscriptionSource(serial);
    438     EXPECT_EQ(std::cv_status::no_timeout, wait());
    439     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    440     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    441 
    442     if (cardStatus.cardState == CardState::ABSENT) {
    443         ASSERT_TRUE(CheckAnyOfErrors(
    444             radioRsp->rspInfo.error,
    445             {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::SIM_ABSENT}));
    446     }
    447 }
    448 
    449 /*
    450  * Test IRadio.setCdmaSubscriptionSource() for the response returned.
    451  */
    452 TEST_F(RadioHidlTest, setCdmaSubscriptionSource) {
    453     serial = GetRandomSerialNumber();
    454 
    455     radio->setCdmaSubscriptionSource(serial, CdmaSubscriptionSource::RUIM_SIM);
    456     EXPECT_EQ(std::cv_status::no_timeout, wait());
    457     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    458     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    459 
    460     if (cardStatus.cardState == CardState::ABSENT) {
    461         ASSERT_TRUE(CheckAnyOfErrors(
    462             radioRsp->rspInfo.error,
    463             {RadioError::NONE, RadioError::SIM_ABSENT, RadioError::SUBSCRIPTION_NOT_AVAILABLE},
    464             CHECK_GENERAL_ERROR));
    465     }
    466 }
    467 
    468 /*
    469  * Test IRadio.getVoiceRadioTechnology() for the response returned.
    470  */
    471 TEST_F(RadioHidlTest, getVoiceRadioTechnology) {
    472     serial = GetRandomSerialNumber();
    473 
    474     radio->getVoiceRadioTechnology(serial);
    475     EXPECT_EQ(std::cv_status::no_timeout, wait());
    476     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    477     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    478 
    479     if (cardStatus.cardState == CardState::ABSENT) {
    480         EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
    481     }
    482 }
    483 
    484 /*
    485  * Test IRadio.getCellInfoList() for the response returned.
    486  */
    487 TEST_F(RadioHidlTest, getCellInfoList) {
    488     serial = GetRandomSerialNumber();
    489 
    490     radio->getCellInfoList(serial);
    491     EXPECT_EQ(std::cv_status::no_timeout, wait());
    492     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    493     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    494 
    495     if (cardStatus.cardState == CardState::ABSENT) {
    496         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    497                                      {RadioError::NONE, RadioError::NO_NETWORK_FOUND},
    498                                      CHECK_GENERAL_ERROR));
    499     }
    500 }
    501 
    502 /*
    503  * Test IRadio.setCellInfoListRate() for the response returned.
    504  */
    505 TEST_F(RadioHidlTest, setCellInfoListRate) {
    506     serial = GetRandomSerialNumber();
    507 
    508     // TODO(sanketpadawe): RIL crashes with value of rate = 10
    509     radio->setCellInfoListRate(serial, 10);
    510     EXPECT_EQ(std::cv_status::no_timeout, wait());
    511     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    512     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    513 
    514     if (cardStatus.cardState == CardState::ABSENT) {
    515         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    516                                      {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
    517     }
    518 }
    519 
    520 /*
    521  * Test IRadio.nvReadItem() for the response returned.
    522  */
    523 TEST_F(RadioHidlTest, nvReadItem) {
    524     serial = GetRandomSerialNumber();
    525 
    526     radio->nvReadItem(serial, NvItem::LTE_BAND_ENABLE_25);
    527     EXPECT_EQ(std::cv_status::no_timeout, wait());
    528     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    529     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    530 
    531     if (cardStatus.cardState == CardState::ABSENT) {
    532         ASSERT_TRUE(
    533             CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
    534     }
    535 }
    536 
    537 /*
    538  * Test IRadio.nvWriteItem() for the response returned.
    539  */
    540 TEST_F(RadioHidlTest, nvWriteItem) {
    541     serial = GetRandomSerialNumber();
    542     NvWriteItem item;
    543     memset(&item, 0, sizeof(item));
    544     item.value = hidl_string();
    545 
    546     radio->nvWriteItem(serial, item);
    547     EXPECT_EQ(std::cv_status::no_timeout, wait());
    548     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    549     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    550 
    551     if (cardStatus.cardState == CardState::ABSENT) {
    552         ASSERT_TRUE(
    553             CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
    554     }
    555 }
    556 
    557 /*
    558  * Test IRadio.nvWriteCdmaPrl() for the response returned.
    559  */
    560 TEST_F(RadioHidlTest, nvWriteCdmaPrl) {
    561     serial = GetRandomSerialNumber();
    562     std::vector<uint8_t> prl = {1, 2, 3, 4, 5};
    563 
    564     radio->nvWriteCdmaPrl(serial, hidl_vec<uint8_t>(prl));
    565     EXPECT_EQ(std::cv_status::no_timeout, wait());
    566     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    567     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    568 
    569     if (cardStatus.cardState == CardState::ABSENT) {
    570         ASSERT_TRUE(
    571             CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
    572     }
    573 }
    574 
    575 /*
    576  * Test IRadio.nvResetConfig() for the response returned.
    577  */
    578 TEST_F(RadioHidlTest, nvResetConfig) {
    579     serial = GetRandomSerialNumber();
    580 
    581     radio->nvResetConfig(serial, ResetNvType::ERASE);
    582     EXPECT_EQ(std::cv_status::no_timeout, wait());
    583     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    584     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    585 
    586     if (cardStatus.cardState == CardState::ABSENT) {
    587         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    588                                      {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
    589     }
    590 }
    591 
    592 /*
    593  * Test IRadio.setUiccSubscription() for the response returned.
    594  */
    595 TEST_F(RadioHidlTest, setUiccSubscription) {
    596     serial = GetRandomSerialNumber();
    597     SelectUiccSub item;
    598     memset(&item, 0, sizeof(item));
    599 
    600     radio->setUiccSubscription(serial, item);
    601     EXPECT_EQ(std::cv_status::no_timeout, wait());
    602     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    603     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    604 
    605     if (cardStatus.cardState == CardState::ABSENT) {
    606         ASSERT_TRUE(
    607             CheckAnyOfErrors(radioRsp->rspInfo.error,
    608                              {RadioError::NONE, RadioError::INVALID_ARGUMENTS,
    609                               RadioError::MODEM_ERR, RadioError::SUBSCRIPTION_NOT_SUPPORTED},
    610                              CHECK_GENERAL_ERROR));
    611     }
    612 }
    613 
    614 /*
    615  * Test IRadio.getHardwareConfig() for the response returned.
    616  */
    617 TEST_F(RadioHidlTest, getHardwareConfig) {
    618     serial = GetRandomSerialNumber();
    619 
    620     radio->getHardwareConfig(serial);
    621     EXPECT_EQ(std::cv_status::no_timeout, wait());
    622     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    623     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    624 
    625     if (cardStatus.cardState == CardState::ABSENT) {
    626         ASSERT_TRUE(
    627             CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
    628     }
    629 }
    630 
    631 /*
    632  * Test IRadio.requestShutdown() for the response returned.
    633  */
    634 TEST_F(RadioHidlTest, requestShutdown) {
    635     serial = GetRandomSerialNumber();
    636 
    637     radio->requestShutdown(serial);
    638     EXPECT_EQ(std::cv_status::no_timeout, wait());
    639     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    640     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    641 
    642     if (cardStatus.cardState == CardState::ABSENT) {
    643         ASSERT_TRUE(
    644             CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
    645     }
    646 }
    647 
    648 /*
    649  * Test IRadio.getRadioCapability() for the response returned.
    650  */
    651 TEST_F(RadioHidlTest, getRadioCapability) {
    652     serial = GetRandomSerialNumber();
    653 
    654     radio->getRadioCapability(serial);
    655     EXPECT_EQ(std::cv_status::no_timeout, wait());
    656     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    657     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    658 
    659     if (cardStatus.cardState == CardState::ABSENT) {
    660         EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
    661     }
    662 }
    663 
    664 /*
    665  * Test IRadio.setRadioCapability() for the response returned.
    666  */
    667 TEST_F(RadioHidlTest, setRadioCapability) {
    668     serial = GetRandomSerialNumber();
    669     RadioCapability rc;
    670     memset(&rc, 0, sizeof(rc));
    671     rc.logicalModemUuid = hidl_string();
    672 
    673     radio->setRadioCapability(serial, rc);
    674     EXPECT_EQ(std::cv_status::no_timeout, wait());
    675     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    676     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    677 
    678     if (cardStatus.cardState == CardState::ABSENT) {
    679         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    680                                      {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE},
    681                                      CHECK_GENERAL_ERROR));
    682     }
    683 }
    684 
    685 /*
    686  * Test IRadio.startLceService() for the response returned.
    687  */
    688 TEST_F(RadioHidlTest, startLceService) {
    689     serial = GetRandomSerialNumber();
    690 
    691     radio->startLceService(serial, 5, true);
    692     EXPECT_EQ(std::cv_status::no_timeout, wait());
    693     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    694     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    695 
    696     if (cardStatus.cardState == CardState::ABSENT) {
    697         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    698                                      {RadioError::INTERNAL_ERR, RadioError::LCE_NOT_SUPPORTED,
    699                                       RadioError::RADIO_NOT_AVAILABLE, RadioError::SIM_ABSENT}));
    700     }
    701 }
    702 
    703 /*
    704  * Test IRadio.stopLceService() for the response returned.
    705  */
    706 TEST_F(RadioHidlTest, stopLceService) {
    707     serial = GetRandomSerialNumber();
    708 
    709     radio->stopLceService(serial);
    710     EXPECT_EQ(std::cv_status::no_timeout, wait());
    711     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    712     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    713 
    714     if (cardStatus.cardState == CardState::ABSENT) {
    715         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    716                                      {RadioError::NONE, RadioError::LCE_NOT_SUPPORTED,
    717                                       RadioError::REQUEST_NOT_SUPPORTED, RadioError::SIM_ABSENT}));
    718     }
    719 }
    720 
    721 /*
    722  * Test IRadio.pullLceData() for the response returned.
    723  */
    724 TEST_F(RadioHidlTest, pullLceData) {
    725     serial = GetRandomSerialNumber();
    726 
    727     radio->pullLceData(serial);
    728     EXPECT_EQ(std::cv_status::no_timeout, wait());
    729     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    730     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    731 
    732     if (cardStatus.cardState == CardState::ABSENT) {
    733         ASSERT_TRUE(CheckAnyOfErrors(
    734             radioRsp->rspInfo.error,
    735             {RadioError::NONE, RadioError::INTERNAL_ERR, RadioError::RADIO_NOT_AVAILABLE},
    736             CHECK_OEM_ERROR));
    737     }
    738 }
    739 
    740 /*
    741  * Test IRadio.getModemActivityInfo() for the response returned.
    742  */
    743 TEST_F(RadioHidlTest, getModemActivityInfo) {
    744     serial = GetRandomSerialNumber();
    745 
    746     radio->getModemActivityInfo(serial);
    747     EXPECT_EQ(std::cv_status::no_timeout, wait());
    748     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    749     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    750 
    751     if (cardStatus.cardState == CardState::ABSENT) {
    752         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    753                                      {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
    754     }
    755 }
    756 
    757 /*
    758  * Test IRadio.setAllowedCarriers() for the response returned.
    759  */
    760 TEST_F(RadioHidlTest, setAllowedCarriers) {
    761     serial = GetRandomSerialNumber();
    762     CarrierRestrictions carriers;
    763     memset(&carriers, 0, sizeof(carriers));
    764     carriers.allowedCarriers.resize(1);
    765     carriers.excludedCarriers.resize(0);
    766     carriers.allowedCarriers[0].mcc = hidl_string();
    767     carriers.allowedCarriers[0].mnc = hidl_string();
    768     carriers.allowedCarriers[0].matchType = CarrierMatchType::ALL;
    769     carriers.allowedCarriers[0].matchData = hidl_string();
    770 
    771     radio->setAllowedCarriers(serial, false, carriers);
    772     EXPECT_EQ(std::cv_status::no_timeout, wait());
    773     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    774     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    775 
    776     if (cardStatus.cardState == CardState::ABSENT) {
    777         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    778                                      {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
    779     }
    780 
    781     /* Setting to carrier restriction needs some time */
    782     updateSimCardStatus();
    783     auto startTime = std::chrono::system_clock::now();
    784     while (cardStatus.cardState != CardState::RESTRICTED &&
    785            std::chrono::duration_cast<chrono::seconds>(std::chrono::system_clock::now() - startTime)
    786                    .count() < 10) {
    787         /* Set 2 seconds as interval to check card status */
    788         sleep(2);
    789         updateSimCardStatus();
    790     }
    791     EXPECT_EQ(CardState::RESTRICTED, cardStatus.cardState);
    792     sleep(10);
    793 
    794     /* Reset back to no carrier restriction */
    795     memset(&carriers, 0, sizeof(carriers));
    796     carriers.allowedCarriers.resize(0);
    797     carriers.excludedCarriers.resize(0);
    798 
    799     serial = GetRandomSerialNumber();
    800     radio->setAllowedCarriers(serial, true, carriers);
    801     EXPECT_EQ(std::cv_status::no_timeout, wait());
    802     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    803     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    804 
    805     if (cardStatus.cardState == CardState::ABSENT) {
    806         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    807                                      {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
    808     }
    809 
    810     /* Resetting back to no carrier restriction needs some time */
    811     updateSimCardStatus();
    812     startTime = std::chrono::system_clock::now();
    813     while (cardStatus.cardState == CardState::RESTRICTED &&
    814            std::chrono::duration_cast<chrono::seconds>(std::chrono::system_clock::now() - startTime)
    815                    .count() < 10) {
    816         /* Set 2 seconds as interval to check card status */
    817         sleep(2);
    818         updateSimCardStatus();
    819     }
    820     EXPECT_NE(CardState::RESTRICTED, cardStatus.cardState);
    821     sleep(10);
    822 }
    823 
    824 /*
    825  * Test IRadio.getAllowedCarriers() for the response returned.
    826  */
    827 TEST_F(RadioHidlTest, getAllowedCarriers) {
    828     serial = GetRandomSerialNumber();
    829 
    830     radio->getAllowedCarriers(serial);
    831     EXPECT_EQ(std::cv_status::no_timeout, wait());
    832     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    833     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    834 
    835     if (cardStatus.cardState == CardState::ABSENT) {
    836         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    837                                      {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
    838     }
    839 }
    840 
    841 /*
    842  * Test IRadio.sendDeviceState() for the response returned.
    843  */
    844 TEST_F(RadioHidlTest, sendDeviceState) {
    845     serial = GetRandomSerialNumber();
    846 
    847     radio->sendDeviceState(serial, DeviceStateType::POWER_SAVE_MODE, true);
    848     EXPECT_EQ(std::cv_status::no_timeout, wait());
    849     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    850     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    851 
    852     std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
    853 
    854     if (cardStatus.cardState == CardState::ABSENT) {
    855         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    856                                      {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
    857     }
    858 }
    859 
    860 /*
    861  * Test IRadio.setIndicationFilter() for the response returned.
    862  */
    863 TEST_F(RadioHidlTest, setIndicationFilter) {
    864     serial = GetRandomSerialNumber();
    865 
    866     radio->setIndicationFilter(serial, 1);
    867     EXPECT_EQ(std::cv_status::no_timeout, wait());
    868     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    869     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    870 
    871     std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
    872 
    873     if (cardStatus.cardState == CardState::ABSENT) {
    874         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    875                                      {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
    876     }
    877 }
    878 
    879 /*
    880  * Test IRadio.setSimCardPower() for the response returned.
    881  */
    882 TEST_F(RadioHidlTest, setSimCardPower) {
    883     serial = GetRandomSerialNumber();
    884 
    885     radio->setSimCardPower(serial, true);
    886     EXPECT_EQ(std::cv_status::no_timeout, wait());
    887     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    888     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    889 
    890     if (cardStatus.cardState == CardState::ABSENT) {
    891         ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
    892                                      {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
    893     }
    894 }
    895