radio/1.0/vts/functional/radio_hidl_hal_voice.cpp

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <radio_hidl_hal_utils.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         ASSERT_TRUE(CheckGeneralError() ||
 369                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 370                     radioRsp->rspInfo.error == RadioError::NONE ||
 371                     radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
 372                     radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
 373                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 374     }
 375 }
 376
 377 /*
 378  * Test IRadio.sendDtmf() for the response returned.
 379  */
 380 TEST_F(RadioHidlTest, sendDtmf) {
 381     int serial = GetRandomSerialNumber();
 382
 383     radio->sendDtmf(serial, "1");
 384     EXPECT_EQ(std::cv_status::no_timeout, wait());
 385     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 386     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 387
 388     if (cardStatus.cardState == CardState::ABSENT) {
 389         ASSERT_TRUE(CheckGeneralError() ||
 390                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 391                     radioRsp->rspInfo.error == RadioError::NONE ||
 392                     radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
 393                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
 394                     radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE);
 395     }
 396 }
 397
 398 /*
 399  * Test IRadio.startDtmf() for the response returned.
 400  */
 401 TEST_F(RadioHidlTest, startDtmf) {
 402     int serial = GetRandomSerialNumber();
 403
 404     radio->startDtmf(serial, "1");
 405     EXPECT_EQ(std::cv_status::no_timeout, wait());
 406     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 407     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 408
 409     if (cardStatus.cardState == CardState::ABSENT) {
 410         ASSERT_TRUE(CheckGeneralError() ||
 411                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 412                     radioRsp->rspInfo.error == RadioError::NONE ||
 413                     radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
 414                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
 415                     radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE);
 416     }
 417 }
 418
 419 /*
 420  * Test IRadio.stopDtmf() for the response returned.
 421  */
 422 TEST_F(RadioHidlTest, stopDtmf) {
 423     int serial = GetRandomSerialNumber();
 424
 425     radio->stopDtmf(serial);
 426     EXPECT_EQ(std::cv_status::no_timeout, wait());
 427     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 428     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 429
 430     if (cardStatus.cardState == CardState::ABSENT) {
 431         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE ||
 432                     radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
 433                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
 434                     radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE);
 435     }
 436 }
 437
 438 /*
 439  * Test IRadio.setMute() for the response returned.
 440  */
 441 TEST_F(RadioHidlTest, setMute) {
 442     int serial = GetRandomSerialNumber();
 443
 444     radio->setMute(serial, true);
 445     EXPECT_EQ(std::cv_status::no_timeout, wait());
 446     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 447     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 448
 449     if (cardStatus.cardState == CardState::ABSENT) {
 450         ASSERT_TRUE(CheckGeneralError() ||
 451                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 452                     radioRsp->rspInfo.error == RadioError::NONE);
 453     }
 454 }
 455
 456 /*
 457  * Test IRadio.getMute() for the response returned.
 458  */
 459 TEST_F(RadioHidlTest, getMute) {
 460     int serial = GetRandomSerialNumber();
 461
 462     radio->getMute(serial);
 463     EXPECT_EQ(std::cv_status::no_timeout, wait());
 464     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 465     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 466
 467     if (cardStatus.cardState == CardState::ABSENT) {
 468         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
 469     }
 470 }
 471
 472 /*
 473  * Test IRadio.sendBurstDtmf() for the response returned.
 474  */
 475 TEST_F(RadioHidlTest, sendBurstDtmf) {
 476     int serial = GetRandomSerialNumber();
 477
 478     radio->sendBurstDtmf(serial, "1", 0, 0);
 479     EXPECT_EQ(std::cv_status::no_timeout, wait());
 480     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 481     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 482
 483     if (cardStatus.cardState == CardState::ABSENT) {
 484         ASSERT_TRUE(CheckGeneralError() ||
 485                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 486                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 487                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
 488                     radioRsp->rspInfo.error == RadioError::MODE_NOT_SUPPORTED);
 489     }
 490 }