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.h>
     18 
     19 /*
     20  * Test IRadio.getCurrentCalls() for the response returned.
     21  */
     22 TEST_F(RadioHidlTest, getCurrentCalls) {
     23     int serial = GetRandomSerialNumber();
     24 
     25     radio->getCurrentCalls(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         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
     32     }
     33 }
     34 
     35 /*
     36  * Test IRadio.dial() for the response returned.
     37  */
     38 TEST_F(RadioHidlTest, dial) {
     39     int serial = GetRandomSerialNumber();
     40 
     41     Dial dialInfo;
     42     memset(&dialInfo, 0, sizeof(dialInfo));
     43     dialInfo.address = hidl_string("123456789");
     44 
     45     radio->dial(serial, dialInfo);
     46     EXPECT_EQ(std::cv_status::no_timeout, wait());
     47     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     48     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
     49 
     50     if (cardStatus.cardState == CardState::ABSENT) {
     51         ASSERT_TRUE(CheckGeneralError() ||
     52                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
     53                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
     54                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
     55                     radioRsp->rspInfo.error == RadioError::FDN_CHECK_FAILURE ||
     56                     radioRsp->rspInfo.error == RadioError::NO_SUBSCRIPTION ||
     57                     radioRsp->rspInfo.error == RadioError::NO_NETWORK_FOUND ||
     58                     radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
     59                     radioRsp->rspInfo.error == RadioError::DEVICE_IN_USE ||
     60                     radioRsp->rspInfo.error == RadioError::MODE_NOT_SUPPORTED ||
     61                     radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
     62                     radioRsp->rspInfo.error == RadioError::CANCELLED);
     63     }
     64 }
     65 
     66 /*
     67  * Test IRadio.hangup() for the response returned.
     68  */
     69 TEST_F(RadioHidlTest, hangup) {
     70     int serial = GetRandomSerialNumber();
     71 
     72     radio->hangup(serial, 1);
     73     EXPECT_EQ(std::cv_status::no_timeout, wait());
     74     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     75     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
     76 
     77     if (cardStatus.cardState == CardState::ABSENT) {
     78         ASSERT_TRUE(CheckGeneralError() ||
     79                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
     80                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
     81                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
     82     }
     83 }
     84 
     85 /*
     86  * Test IRadio.hangupWaitingOrBackground() for the response returned.
     87  */
     88 TEST_F(RadioHidlTest, hangupWaitingOrBackground) {
     89     int serial = GetRandomSerialNumber();
     90 
     91     radio->hangupWaitingOrBackground(serial);
     92     EXPECT_EQ(std::cv_status::no_timeout, wait());
     93     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
     94     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
     95 
     96     if (cardStatus.cardState == CardState::ABSENT) {
     97         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
     98                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
     99     }
    100 }
    101 
    102 /*
    103  * Test IRadio.hangupForegroundResumeBackground() for the response returned.
    104  */
    105 TEST_F(RadioHidlTest, hangupForegroundResumeBackground) {
    106     int serial = GetRandomSerialNumber();
    107 
    108     radio->hangupForegroundResumeBackground(serial);
    109     EXPECT_EQ(std::cv_status::no_timeout, wait());
    110     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    111     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    112 
    113     if (cardStatus.cardState == CardState::ABSENT) {
    114         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
    115                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    116     }
    117 }
    118 
    119 /*
    120  * Test IRadio.switchWaitingOrHoldingAndActive() for the response returned.
    121  */
    122 TEST_F(RadioHidlTest, switchWaitingOrHoldingAndActive) {
    123     int serial = GetRandomSerialNumber();
    124 
    125     radio->switchWaitingOrHoldingAndActive(serial);
    126     EXPECT_EQ(std::cv_status::no_timeout, wait());
    127     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    128     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    129 
    130     if (cardStatus.cardState == CardState::ABSENT) {
    131         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
    132                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    133     }
    134 }
    135 
    136 /*
    137  * Test IRadio.conference() for the response returned.
    138  */
    139 TEST_F(RadioHidlTest, conference) {
    140     int serial = GetRandomSerialNumber();
    141 
    142     radio->conference(serial);
    143     EXPECT_EQ(std::cv_status::no_timeout, wait());
    144     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    145     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    146 
    147     if (cardStatus.cardState == CardState::ABSENT) {
    148         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
    149                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    150     }
    151 }
    152 
    153 /*
    154  * Test IRadio.rejectCall() for the response returned.
    155  */
    156 TEST_F(RadioHidlTest, rejectCall) {
    157     int serial = GetRandomSerialNumber();
    158 
    159     radio->rejectCall(serial);
    160     EXPECT_EQ(std::cv_status::no_timeout, wait());
    161     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    162     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    163 
    164     if (cardStatus.cardState == CardState::ABSENT) {
    165         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
    166                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    167     }
    168 }
    169 
    170 /*
    171  * Test IRadio.getLastCallFailCause() for the response returned.
    172  */
    173 TEST_F(RadioHidlTest, getLastCallFailCause) {
    174     int serial = GetRandomSerialNumber();
    175 
    176     radio->getLastCallFailCause(serial);
    177     EXPECT_EQ(std::cv_status::no_timeout, wait());
    178     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    179     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    180 
    181     if (cardStatus.cardState == CardState::ABSENT) {
    182         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
    183     }
    184 }
    185 
    186 /*
    187  * Test IRadio.sendUssd() for the response returned.
    188  */
    189 TEST_F(RadioHidlTest, sendUssd) {
    190     int serial = GetRandomSerialNumber();
    191     radio->sendUssd(serial, hidl_string("test"));
    192     EXPECT_EQ(std::cv_status::no_timeout, wait());
    193     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    194     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    195 
    196     if (cardStatus.cardState == CardState::ABSENT) {
    197         ASSERT_TRUE(CheckGeneralError() ||
    198                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
    199                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
    200                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    201     }
    202 }
    203 
    204 /*
    205  * Test IRadio.cancelPendingUssd() for the response returned.
    206  */
    207 TEST_F(RadioHidlTest, cancelPendingUssd) {
    208     int serial = GetRandomSerialNumber();
    209 
    210     radio->cancelPendingUssd(serial);
    211     EXPECT_EQ(std::cv_status::no_timeout, wait());
    212     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    213     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    214 
    215     if (cardStatus.cardState == CardState::ABSENT) {
    216         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
    217                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    218     }
    219 }
    220 
    221 /*
    222  * Test IRadio.getCallForwardStatus() for the response returned.
    223  */
    224 TEST_F(RadioHidlTest, getCallForwardStatus) {
    225     int serial = GetRandomSerialNumber();
    226     CallForwardInfo callInfo;
    227     memset(&callInfo, 0, sizeof(callInfo));
    228     callInfo.number = hidl_string();
    229 
    230     radio->getCallForwardStatus(serial, callInfo);
    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         ASSERT_TRUE(CheckGeneralError() ||
    237                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
    238                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
    239                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    240     }
    241 }
    242 
    243 /*
    244  * Test IRadio.setCallForward() for the response returned.
    245  */
    246 TEST_F(RadioHidlTest, setCallForward) {
    247     int serial = GetRandomSerialNumber();
    248     CallForwardInfo callInfo;
    249     memset(&callInfo, 0, sizeof(callInfo));
    250     callInfo.number = hidl_string();
    251 
    252     radio->setCallForward(serial, callInfo);
    253     EXPECT_EQ(std::cv_status::no_timeout, wait());
    254     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    255     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    256 
    257     if (cardStatus.cardState == CardState::ABSENT) {
    258         ASSERT_TRUE(CheckGeneralError() ||
    259                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
    260                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
    261                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    262     }
    263 }
    264 
    265 /*
    266  * Test IRadio.getCallWaiting() for the response returned.
    267  */
    268 TEST_F(RadioHidlTest, getCallWaiting) {
    269     int serial = GetRandomSerialNumber();
    270 
    271     radio->getCallWaiting(serial, 1);
    272     EXPECT_EQ(std::cv_status::no_timeout, wait());
    273     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    274     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    275 
    276     if (cardStatus.cardState == CardState::ABSENT) {
    277         ASSERT_TRUE(CheckGeneralError() ||
    278                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
    279                     radioRsp->rspInfo.error == RadioError::NONE ||
    280                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    281     }
    282 }
    283 
    284 /*
    285  * Test IRadio.setCallWaiting() for the response returned.
    286  */
    287 TEST_F(RadioHidlTest, setCallWaiting) {
    288     int serial = GetRandomSerialNumber();
    289 
    290     radio->setCallWaiting(serial, true, 1);
    291     EXPECT_EQ(std::cv_status::no_timeout, wait());
    292     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    293     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    294 
    295     if (cardStatus.cardState == CardState::ABSENT) {
    296         ASSERT_TRUE(CheckGeneralError() ||
    297                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
    298                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
    299                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    300     }
    301 }
    302 
    303 /*
    304  * Test IRadio.acceptCall() for the response returned.
    305  */
    306 TEST_F(RadioHidlTest, acceptCall) {
    307     int serial = GetRandomSerialNumber();
    308 
    309     radio->acceptCall(serial);
    310     EXPECT_EQ(std::cv_status::no_timeout, wait());
    311     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    312     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    313 
    314     if (cardStatus.cardState == CardState::ABSENT) {
    315         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
    316                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    317     }
    318 }
    319 
    320 /*
    321  * Test IRadio.separateConnection() for the response returned.
    322  */
    323 TEST_F(RadioHidlTest, separateConnection) {
    324     int serial = GetRandomSerialNumber();
    325 
    326     radio->separateConnection(serial, 1);
    327     EXPECT_EQ(std::cv_status::no_timeout, wait());
    328     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    329     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    330 
    331     if (cardStatus.cardState == CardState::ABSENT) {
    332         ASSERT_TRUE(CheckGeneralError() ||
    333                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
    334                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
    335                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    336     }
    337 }
    338 
    339 /*
    340  * Test IRadio.explicitCallTransfer() for the response returned.
    341  */
    342 TEST_F(RadioHidlTest, explicitCallTransfer) {
    343     int serial = GetRandomSerialNumber();
    344 
    345     radio->explicitCallTransfer(serial);
    346     EXPECT_EQ(std::cv_status::no_timeout, wait());
    347     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    348     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    349 
    350     if (cardStatus.cardState == CardState::ABSENT) {
    351         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
    352                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    353     }
    354 }
    355 
    356 /*
    357  * Test IRadio.sendCDMAFeatureCode() for the response returned.
    358  */
    359 TEST_F(RadioHidlTest, sendCDMAFeatureCode) {
    360     int serial = GetRandomSerialNumber();
    361 
    362     radio->sendCDMAFeatureCode(serial, hidl_string());
    363     EXPECT_EQ(std::cv_status::no_timeout, wait());
    364     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    365     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    366 
    367     if (cardStatus.cardState == CardState::ABSENT) {
    368         std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
    369         ASSERT_TRUE(CheckGeneralError() ||
    370                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
    371                     radioRsp->rspInfo.error == RadioError::NONE ||
    372                     radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
    373                     radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
    374                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
    375     }
    376 }
    377 
    378 /*
    379  * Test IRadio.sendDtmf() for the response returned.
    380  */
    381 TEST_F(RadioHidlTest, sendDtmf) {
    382     int serial = GetRandomSerialNumber();
    383 
    384     radio->sendDtmf(serial, "1");
    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(CheckGeneralError() ||
    391                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
    392                     radioRsp->rspInfo.error == RadioError::NONE ||
    393                     radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
    394                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
    395                     radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE);
    396     }
    397 }
    398 
    399 /*
    400  * Test IRadio.startDtmf() for the response returned.
    401  */
    402 TEST_F(RadioHidlTest, startDtmf) {
    403     int serial = GetRandomSerialNumber();
    404 
    405     radio->startDtmf(serial, "1");
    406     EXPECT_EQ(std::cv_status::no_timeout, wait());
    407     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    408     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    409 
    410     if (cardStatus.cardState == CardState::ABSENT) {
    411         ASSERT_TRUE(CheckGeneralError() ||
    412                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
    413                     radioRsp->rspInfo.error == RadioError::NONE ||
    414                     radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
    415                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
    416                     radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE);
    417     }
    418 }
    419 
    420 /*
    421  * Test IRadio.stopDtmf() for the response returned.
    422  */
    423 TEST_F(RadioHidlTest, stopDtmf) {
    424     int serial = GetRandomSerialNumber();
    425 
    426     radio->stopDtmf(serial);
    427     EXPECT_EQ(std::cv_status::no_timeout, wait());
    428     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    429     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    430 
    431     if (cardStatus.cardState == CardState::ABSENT) {
    432         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE ||
    433                     radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
    434                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
    435                     radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE);
    436     }
    437 }
    438 
    439 /*
    440  * Test IRadio.setMute() for the response returned.
    441  */
    442 TEST_F(RadioHidlTest, setMute) {
    443     int serial = GetRandomSerialNumber();
    444 
    445     radio->setMute(serial, true);
    446     EXPECT_EQ(std::cv_status::no_timeout, wait());
    447     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    448     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    449 
    450     if (cardStatus.cardState == CardState::ABSENT) {
    451         ASSERT_TRUE(CheckGeneralError() ||
    452                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
    453                     radioRsp->rspInfo.error == RadioError::NONE);
    454     }
    455 }
    456 
    457 /*
    458  * Test IRadio.getMute() for the response returned.
    459  */
    460 TEST_F(RadioHidlTest, getMute) {
    461     int serial = GetRandomSerialNumber();
    462 
    463     radio->getMute(serial);
    464     EXPECT_EQ(std::cv_status::no_timeout, wait());
    465     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    466     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    467 
    468     if (cardStatus.cardState == CardState::ABSENT) {
    469         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
    470     }
    471 }
    472 
    473 /*
    474  * Test IRadio.sendBurstDtmf() for the response returned.
    475  */
    476 TEST_F(RadioHidlTest, sendBurstDtmf) {
    477     int serial = GetRandomSerialNumber();
    478 
    479     radio->sendBurstDtmf(serial, "1", 0, 0);
    480     EXPECT_EQ(std::cv_status::no_timeout, wait());
    481     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
    482     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
    483 
    484     if (cardStatus.cardState == CardState::ABSENT) {
    485         ASSERT_TRUE(CheckGeneralError() ||
    486                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
    487                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
    488                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
    489                     radioRsp->rspInfo.error == RadioError::MODE_NOT_SUPPORTED);
    490     }
    491 }