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                 || radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
  33     }
  34 }
  35
  36 /*
  37  * Test IRadio.dial() for the response returned.
  38  */
  39 TEST_F(RadioHidlTest, dial) {
  40     int serial = 1;
  41
  42     Dial dialInfo;
  43     memset(&dialInfo, 0, sizeof(dialInfo));
  44     dialInfo.address = hidl_string("123456789");
  45
  46     radio->dial(serial, dialInfo);
  47     EXPECT_EQ(std::cv_status::no_timeout, wait());
  48     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
  49     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
  50
  51     if (cardStatus.cardState == CardState::ABSENT) {
  52         ASSERT_TRUE(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::INTERNAL_ERR);
  56     }
  57 }
  58
  59 /*
  60  * Test IRadio.hangup() for the response returned.
  61  */
  62 TEST_F(RadioHidlTest, hangup) {
  63     int serial = 1;
  64
  65     radio->hangup(serial, 1);
  66     EXPECT_EQ(std::cv_status::no_timeout, wait());
  67     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
  68     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
  69
  70     if (cardStatus.cardState == CardState::ABSENT) {
  71         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
  72                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
  73                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
  74                 || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
  75     }
  76 }
  77
  78 /*
  79  * Test IRadio.hangupWaitingOrBackground() for the response returned.
  80  */
  81 TEST_F(RadioHidlTest, hangupWaitingOrBackground) {
  82     int serial = 1;
  83
  84     radio->hangupWaitingOrBackground(serial);
  85     EXPECT_EQ(std::cv_status::no_timeout, wait());
  86     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
  87     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
  88
  89     if (cardStatus.cardState == CardState::ABSENT) {
  90         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
  91                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
  92                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
  93                 || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
  94     }
  95 }
  96
  97 /*
  98  * Test IRadio.hangupForegroundResumeBackground() for the response returned.
  99  */
 100 TEST_F(RadioHidlTest, hangupForegroundResumeBackground) {
 101     int serial = 1;
 102
 103     radio->hangupForegroundResumeBackground(serial);
 104     EXPECT_EQ(std::cv_status::no_timeout, wait());
 105     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 106     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 107
 108     if (cardStatus.cardState == CardState::ABSENT) {
 109         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 110                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
 111                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 112                 || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
 113     }
 114 }
 115
 116 /*
 117  * Test IRadio.switchWaitingOrHoldingAndActive() for the response returned.
 118  */
 119 TEST_F(RadioHidlTest, switchWaitingOrHoldingAndActive) {
 120     int serial = 1;
 121
 122     radio->switchWaitingOrHoldingAndActive(serial);
 123     EXPECT_EQ(std::cv_status::no_timeout, wait());
 124     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 125     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 126
 127     if (cardStatus.cardState == CardState::ABSENT) {
 128         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 129                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
 130                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 131                 || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
 132     }
 133 }
 134
 135 /*
 136  * Test IRadio.conference() for the response returned.
 137  */
 138 TEST_F(RadioHidlTest, conference) {
 139     int serial = 1;
 140
 141     radio->conference(serial);
 142     EXPECT_EQ(std::cv_status::no_timeout, wait());
 143     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 144     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 145
 146     if (cardStatus.cardState == CardState::ABSENT) {
 147         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 148                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
 149                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 150                 || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
 151     }
 152 }
 153
 154 /*
 155  * Test IRadio.rejectCall() for the response returned.
 156  */
 157 TEST_F(RadioHidlTest, rejectCall) {
 158     int serial = 1;
 159
 160     radio->rejectCall(serial);
 161     EXPECT_EQ(std::cv_status::no_timeout, wait());
 162     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 163     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 164
 165     if (cardStatus.cardState == CardState::ABSENT) {
 166         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 167                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
 168                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 169                 || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
 170     }
 171 }
 172
 173 /*
 174  * Test IRadio.getLastCallFailCause() for the response returned.
 175  */
 176 TEST_F(RadioHidlTest, getLastCallFailCause) {
 177     int serial = 1;
 178
 179     radio->getLastCallFailCause(serial);
 180     EXPECT_EQ(std::cv_status::no_timeout, wait());
 181     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 182     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 183
 184     if (cardStatus.cardState == CardState::ABSENT) {
 185         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 186                 || radioRsp->rspInfo.error == RadioError::NONE);
 187     }
 188 }
 189
 190 /*
 191  * Test IRadio.sendUssd() for the response returned.
 192  */
 193 TEST_F(RadioHidlTest, sendUssd) {
 194     int serial = 1;
 195     radio->sendUssd(serial, hidl_string("test"));
 196     EXPECT_EQ(std::cv_status::no_timeout, wait());
 197     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 198     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 199
 200     if (cardStatus.cardState == CardState::ABSENT) {
 201         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 202                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
 203                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 204                 || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
 205                 || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
 206     }
 207 }
 208
 209 /*
 210  * Test IRadio.cancelPendingUssd() for the response returned.
 211  */
 212 TEST_F(RadioHidlTest, cancelPendingUssd) {
 213     int serial = 1;
 214
 215     radio->cancelPendingUssd(serial);
 216     EXPECT_EQ(std::cv_status::no_timeout, wait());
 217     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 218     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 219
 220     if (cardStatus.cardState == CardState::ABSENT) {
 221         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 222                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
 223                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 224                 || radioRsp->rspInfo.error == RadioError::INTERNAL_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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 244                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
 245                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 246                 || radioRsp->rspInfo.error == RadioError::INTERNAL_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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 266                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
 267                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 268                 || radioRsp->rspInfo.error == RadioError::INTERNAL_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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 285                 || radioRsp->rspInfo.error == RadioError::NONE
 286                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 287                 || radioRsp->rspInfo.error == RadioError::INTERNAL_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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 304                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
 305                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 306                 || radioRsp->rspInfo.error == RadioError::INTERNAL_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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 323                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
 324                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 325                 || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
 326     }
 327 }
 328
 329 /*
 330  * Test IRadio.separateConnection() for the response returned.
 331  */
 332 TEST_F(RadioHidlTest, separateConnection) {
 333     int serial = 1;
 334
 335     radio->separateConnection(serial, 1);
 336     EXPECT_EQ(std::cv_status::no_timeout, wait());
 337     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 338     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 339
 340     if (cardStatus.cardState == CardState::ABSENT) {
 341         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 342                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
 343                 || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
 344                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 345                 || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
 346     }
 347 }
 348
 349 /*
 350  * Test IRadio.explicitCallTransfer() for the response returned.
 351  */
 352 TEST_F(RadioHidlTest, explicitCallTransfer) {
 353     int serial = 1;
 354
 355     radio->explicitCallTransfer(serial);
 356     EXPECT_EQ(std::cv_status::no_timeout, wait());
 357     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 358     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 359
 360     if (cardStatus.cardState == CardState::ABSENT) {
 361         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 362                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE
 363                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 364                 || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
 365     }
 366 }
 367
 368 /*
 369  * Test IRadio.sendDtmf() for the response returned.
 370  */
 371 TEST_F(RadioHidlTest, sendDtmf) {
 372     int serial = 1;
 373
 374     radio->sendDtmf(serial, "1");
 375     EXPECT_EQ(std::cv_status::no_timeout, wait());
 376     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 377     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 378
 379     if (cardStatus.cardState == CardState::ABSENT) {
 380         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 381                 || radioRsp->rspInfo.error == RadioError::NO_RESOURCES
 382                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 383     }
 384 }
 385
 386 /*
 387  * Test IRadio.startDtmf() for the response returned.
 388  */
 389 TEST_F(RadioHidlTest, startDtmf) {
 390     int serial = 1;
 391
 392     radio->startDtmf(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(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 399                 || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
 400                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 401                 || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
 402     }
 403 }
 404
 405 /*
 406  * Test IRadio.stopDtmf() for the response returned.
 407  */
 408 TEST_F(RadioHidlTest, stopDtmf) {
 409     int serial = 1;
 410
 411     radio->stopDtmf(serial);
 412     EXPECT_EQ(std::cv_status::no_timeout, wait());
 413     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 414     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 415
 416     if (cardStatus.cardState == CardState::ABSENT) {
 417         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 418                 || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
 419                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 420                 || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
 421     }
 422 }
 423
 424 /*
 425  * Test IRadio.setMute() for the response returned.
 426  */
 427 TEST_F(RadioHidlTest, setMute) {
 428     int serial = 1;
 429
 430     radio->setMute(serial, true);
 431     EXPECT_EQ(std::cv_status::no_timeout, wait());
 432     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 433     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 434
 435     if (cardStatus.cardState == CardState::ABSENT) {
 436         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 437                 || radioRsp->rspInfo.error == RadioError::NONE);
 438     }
 439 }
 440
 441 /*
 442  * Test IRadio.getMute() for the response returned.
 443  */
 444 TEST_F(RadioHidlTest, getMute) {
 445     int serial = 1;
 446
 447     radio->getMute(serial);
 448     EXPECT_EQ(std::cv_status::no_timeout, wait());
 449     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 450     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 451
 452     if (cardStatus.cardState == CardState::ABSENT) {
 453         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 454                 || radioRsp->rspInfo.error == RadioError::NONE);
 455     }
 456 }
 457
 458 /*
 459  * Test IRadio.sendBurstDtmf() for the response returned.
 460  */
 461 TEST_F(RadioHidlTest, sendBurstDtmf) {
 462     int serial = 1;
 463
 464     radio->sendBurstDtmf(serial, "1", 0, 0);
 465     EXPECT_EQ(std::cv_status::no_timeout, wait());
 466     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 467     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 468
 469     if (cardStatus.cardState == CardState::ABSENT) {
 470         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
 471                 || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
 472                 || radioRsp->rspInfo.error == RadioError::MODEM_ERR
 473                 || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR
 474                 || radioRsp->rspInfo.error == RadioError::INVALID_STATE);
 475     }
 476 }