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 = 1;
  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 = 1;
  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 = 1;
  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 = 1;
  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() ||
  98                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
  99                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 100   }
 101 }
 102
 103 /*
 104  * Test IRadio.hangupForegroundResumeBackground() for the response returned.
 105  */
 106 TEST_F(RadioHidlTest, hangupForegroundResumeBackground) {
 107   int serial = 1;
 108
 109   radio->hangupForegroundResumeBackground(serial);
 110   EXPECT_EQ(std::cv_status::no_timeout, wait());
 111   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 112   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 113
 114   if (cardStatus.cardState == CardState::ABSENT) {
 115       ASSERT_TRUE(CheckGeneralError() ||
 116                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 117                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 118   }
 119 }
 120
 121 /*
 122  * Test IRadio.switchWaitingOrHoldingAndActive() for the response returned.
 123  */
 124 TEST_F(RadioHidlTest, switchWaitingOrHoldingAndActive) {
 125   int serial = 1;
 126
 127   radio->switchWaitingOrHoldingAndActive(serial);
 128   EXPECT_EQ(std::cv_status::no_timeout, wait());
 129   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 130   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 131
 132   if (cardStatus.cardState == CardState::ABSENT) {
 133       ASSERT_TRUE(CheckGeneralError() ||
 134                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 135                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 136   }
 137 }
 138
 139 /*
 140  * Test IRadio.conference() for the response returned.
 141  */
 142 TEST_F(RadioHidlTest, conference) {
 143   int serial = 1;
 144
 145   radio->conference(serial);
 146   EXPECT_EQ(std::cv_status::no_timeout, wait());
 147   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 148   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 149
 150   if (cardStatus.cardState == CardState::ABSENT) {
 151       ASSERT_TRUE(CheckGeneralError() ||
 152                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 153                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 154   }
 155 }
 156
 157 /*
 158  * Test IRadio.rejectCall() for the response returned.
 159  */
 160 TEST_F(RadioHidlTest, rejectCall) {
 161   int serial = 1;
 162
 163   radio->rejectCall(serial);
 164   EXPECT_EQ(std::cv_status::no_timeout, wait());
 165   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 166   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 167
 168   if (cardStatus.cardState == CardState::ABSENT) {
 169       ASSERT_TRUE(CheckGeneralError() ||
 170                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 171                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 172   }
 173 }
 174
 175 /*
 176  * Test IRadio.getLastCallFailCause() for the response returned.
 177  */
 178 TEST_F(RadioHidlTest, getLastCallFailCause) {
 179   int serial = 1;
 180
 181   radio->getLastCallFailCause(serial);
 182   EXPECT_EQ(std::cv_status::no_timeout, wait());
 183   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 184   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 185
 186   if (cardStatus.cardState == CardState::ABSENT) {
 187       ASSERT_TRUE(CheckGeneralError() ||
 188                   radioRsp->rspInfo.error == RadioError::NONE);
 189   }
 190 }
 191
 192 /*
 193  * Test IRadio.sendUssd() for the response returned.
 194  */
 195 TEST_F(RadioHidlTest, sendUssd) {
 196   int serial = 1;
 197   radio->sendUssd(serial, hidl_string("test"));
 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       ASSERT_TRUE(CheckGeneralError() ||
 204                   radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 205                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 206                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 207   }
 208 }
 209
 210 /*
 211  * Test IRadio.cancelPendingUssd() for the response returned.
 212  */
 213 TEST_F(RadioHidlTest, cancelPendingUssd) {
 214   int serial = 1;
 215
 216   radio->cancelPendingUssd(serial);
 217   EXPECT_EQ(std::cv_status::no_timeout, wait());
 218   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 219   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 220
 221   if (cardStatus.cardState == CardState::ABSENT) {
 222       ASSERT_TRUE(CheckGeneralError() ||
 223                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 224                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 225   }
 226 }
 227
 228 /*
 229  * Test IRadio.getCallForwardStatus() for the response returned.
 230  */
 231 TEST_F(RadioHidlTest, getCallForwardStatus) {
 232   int serial = 1;
 233   CallForwardInfo callInfo;
 234   memset(&callInfo, 0, sizeof(callInfo));
 235   callInfo.number = hidl_string();
 236
 237   radio->getCallForwardStatus(serial, callInfo);
 238   EXPECT_EQ(std::cv_status::no_timeout, wait());
 239   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 240   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 241
 242   if (cardStatus.cardState == CardState::ABSENT) {
 243       ASSERT_TRUE(CheckGeneralError() ||
 244                   radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 245                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 246                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 247   }
 248 }
 249
 250 /*
 251  * Test IRadio.setCallForward() for the response returned.
 252  */
 253 TEST_F(RadioHidlTest, setCallForward) {
 254   int serial = 1;
 255   CallForwardInfo callInfo;
 256   memset(&callInfo, 0, sizeof(callInfo));
 257   callInfo.number = hidl_string();
 258
 259   radio->setCallForward(serial, callInfo);
 260   EXPECT_EQ(std::cv_status::no_timeout, wait());
 261   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 262   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 263
 264   if (cardStatus.cardState == CardState::ABSENT) {
 265       ASSERT_TRUE(CheckGeneralError() ||
 266                   radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 267                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 268                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 269   }
 270 }
 271
 272 /*
 273  * Test IRadio.getCallWaiting() for the response returned.
 274  */
 275 TEST_F(RadioHidlTest, getCallWaiting) {
 276   int serial = 1;
 277
 278   radio->getCallWaiting(serial, 1);
 279   EXPECT_EQ(std::cv_status::no_timeout, wait());
 280   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 281   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 282
 283   if (cardStatus.cardState == CardState::ABSENT) {
 284       ASSERT_TRUE(CheckGeneralError() ||
 285                   radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 286                   radioRsp->rspInfo.error == RadioError::NONE ||
 287                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 288   }
 289 }
 290
 291 /*
 292  * Test IRadio.setCallWaiting() for the response returned.
 293  */
 294 TEST_F(RadioHidlTest, setCallWaiting) {
 295   int serial = 1;
 296
 297   radio->setCallWaiting(serial, true, 1);
 298   EXPECT_EQ(std::cv_status::no_timeout, wait());
 299   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 300   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 301
 302   if (cardStatus.cardState == CardState::ABSENT) {
 303       ASSERT_TRUE(CheckGeneralError() ||
 304                   radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 305                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 306                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 307   }
 308 }
 309
 310 /*
 311  * Test IRadio.acceptCall() for the response returned.
 312  */
 313 TEST_F(RadioHidlTest, acceptCall) {
 314   int serial = 1;
 315
 316   radio->acceptCall(serial);
 317   EXPECT_EQ(std::cv_status::no_timeout, wait());
 318   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 319   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 320
 321   if (cardStatus.cardState == CardState::ABSENT) {
 322       ASSERT_TRUE(CheckGeneralError() ||
 323                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 324                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 325   }
 326 }
 327
 328 /*
 329  * Test IRadio.separateConnection() for the response returned.
 330  */
 331 TEST_F(RadioHidlTest, separateConnection) {
 332   int serial = 1;
 333
 334   radio->separateConnection(serial, 1);
 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       ASSERT_TRUE(CheckGeneralError() ||
 341                   radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 342                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 343                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 344   }
 345 }
 346
 347 /*
 348  * Test IRadio.explicitCallTransfer() for the response returned.
 349  */
 350 TEST_F(RadioHidlTest, explicitCallTransfer) {
 351   int serial = 1;
 352
 353   radio->explicitCallTransfer(serial);
 354   EXPECT_EQ(std::cv_status::no_timeout, wait());
 355   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 356   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 357
 358   if (cardStatus.cardState == CardState::ABSENT) {
 359       ASSERT_TRUE(CheckGeneralError() ||
 360                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 361                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 362   }
 363 }
 364
 365 /*
 366  * Test IRadio.sendCDMAFeatureCode() for the response returned.
 367  */
 368 TEST_F(RadioHidlTest, sendCDMAFeatureCode) {
 369   int serial = 1;
 370
 371   radio->sendCDMAFeatureCode(serial, hidl_string());
 372   EXPECT_EQ(std::cv_status::no_timeout, wait());
 373   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 374   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 375
 376   if (cardStatus.cardState == CardState::ABSENT) {
 377       ASSERT_TRUE(CheckGeneralError() ||
 378                   radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 379                   radioRsp->rspInfo.error == RadioError::NONE ||
 380                   radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
 381                   radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
 382                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 383   }
 384 }
 385
 386 /*
 387  * Test IRadio.sendDtmf() for the response returned.
 388  */
 389 TEST_F(RadioHidlTest, sendDtmf) {
 390   int serial = 1;
 391
 392   radio->sendDtmf(serial, "1");
 393   EXPECT_EQ(std::cv_status::no_timeout, wait());
 394   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 395   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 396
 397   if (cardStatus.cardState == CardState::ABSENT) {
 398       ASSERT_TRUE(CheckGeneralError() ||
 399                   radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 400                   radioRsp->rspInfo.error == RadioError::NONE ||
 401                   radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
 402                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 403   }
 404 }
 405
 406 /*
 407  * Test IRadio.startDtmf() for the response returned.
 408  */
 409 TEST_F(RadioHidlTest, startDtmf) {
 410   int serial = 1;
 411
 412   radio->startDtmf(serial, "1");
 413   EXPECT_EQ(std::cv_status::no_timeout, wait());
 414   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 415   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 416
 417   if (cardStatus.cardState == CardState::ABSENT) {
 418       ASSERT_TRUE(CheckGeneralError() ||
 419                   radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 420                   radioRsp->rspInfo.error == RadioError::NONE ||
 421                   radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
 422                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 423   }
 424 }
 425
 426 /*
 427  * Test IRadio.stopDtmf() for the response returned.
 428  */
 429 TEST_F(RadioHidlTest, stopDtmf) {
 430   int serial = 1;
 431
 432   radio->stopDtmf(serial);
 433   EXPECT_EQ(std::cv_status::no_timeout, wait());
 434   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 435   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 436
 437   if (cardStatus.cardState == CardState::ABSENT) {
 438       ASSERT_TRUE(CheckGeneralError() ||
 439                   radioRsp->rspInfo.error == RadioError::NONE ||
 440                   radioRsp->rspInfo.error == RadioError::INVALID_CALL_ID ||
 441                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 442   }
 443 }
 444
 445 /*
 446  * Test IRadio.setMute() for the response returned.
 447  */
 448 TEST_F(RadioHidlTest, setMute) {
 449   int serial = 1;
 450
 451   radio->setMute(serial, true);
 452   EXPECT_EQ(std::cv_status::no_timeout, wait());
 453   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 454   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 455
 456   if (cardStatus.cardState == CardState::ABSENT) {
 457       ASSERT_TRUE(CheckGeneralError() ||
 458                   radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 459                   radioRsp->rspInfo.error == RadioError::NONE);
 460   }
 461 }
 462
 463 /*
 464  * Test IRadio.getMute() for the response returned.
 465  */
 466 TEST_F(RadioHidlTest, getMute) {
 467   int serial = 1;
 468
 469   radio->getMute(serial);
 470   EXPECT_EQ(std::cv_status::no_timeout, wait());
 471   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 472   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 473
 474   if (cardStatus.cardState == CardState::ABSENT) {
 475     ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
 476   }
 477 }
 478
 479 /*
 480  * Test IRadio.sendBurstDtmf() for the response returned.
 481  */
 482 TEST_F(RadioHidlTest, sendBurstDtmf) {
 483   int serial = 1;
 484
 485   radio->sendBurstDtmf(serial, "1", 0, 0);
 486   EXPECT_EQ(std::cv_status::no_timeout, wait());
 487   EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 488   EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 489
 490   if (cardStatus.cardState == CardState::ABSENT) {
 491       ASSERT_TRUE(CheckGeneralError() ||
 492                   radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 493                   radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 494                   radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 495   }
 496 }