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