radio/1.0/vts/functional/radio_hidl_hal_misc.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_v1_0.h>
  18
  19 /*
  20  * Test IRadio.getSignalStrength() for the response returned.
  21  */
  22 TEST_F(RadioHidlTest, getSignalStrength) {
  23     int serial = GetRandomSerialNumber();
  24
  25     radio->getSignalStrength(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.getVoiceRegistrationState() for the response returned.
  37  */
  38 TEST_F(RadioHidlTest, getVoiceRegistrationState) {
  39     int serial = GetRandomSerialNumber();
  40
  41     radio->getVoiceRegistrationState(serial);
  42     EXPECT_EQ(std::cv_status::no_timeout, wait());
  43     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
  44     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
  45
  46     if (cardStatus.cardState == CardState::ABSENT) {
  47         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
  48     }
  49 }
  50
  51 /*
  52  * Test IRadio.getOperator() for the response returned.
  53  */
  54 TEST_F(RadioHidlTest, getOperator) {
  55     int serial = GetRandomSerialNumber();
  56
  57     radio->getOperator(serial);
  58     EXPECT_EQ(std::cv_status::no_timeout, wait());
  59     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
  60     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
  61
  62     if (cardStatus.cardState == CardState::ABSENT) {
  63         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
  64     }
  65 }
  66
  67 /*
  68  * Test IRadio.setRadioPower() for the response returned.
  69  */
  70 TEST_F(RadioHidlTest, setRadioPower) {
  71     int serial = GetRandomSerialNumber();
  72
  73     radio->setRadioPower(serial, 0);
  74     EXPECT_EQ(std::cv_status::no_timeout, wait());
  75     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
  76     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
  77
  78     if (cardStatus.cardState == CardState::ABSENT) {
  79         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
  80     }
  81 }
  82
  83 /*
  84  * Test IRadio.getNetworkSelectionMode() for the response returned.
  85  */
  86 TEST_F(RadioHidlTest, getNetworkSelectionMode) {
  87     int serial = GetRandomSerialNumber();
  88
  89     radio->getNetworkSelectionMode(serial);
  90     EXPECT_EQ(std::cv_status::no_timeout, wait());
  91     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
  92     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
  93
  94     if (cardStatus.cardState == CardState::ABSENT) {
  95         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
  96     }
  97 }
  98
  99 /*
 100  * Test IRadio.setNetworkSelectionModeAutomatic() for the response returned.
 101  */
 102 TEST_F(RadioHidlTest, setNetworkSelectionModeAutomatic) {
 103     int serial = GetRandomSerialNumber();
 104
 105     radio->setNetworkSelectionModeAutomatic(serial);
 106     EXPECT_EQ(std::cv_status::no_timeout, wait());
 107     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 108     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 109
 110     if (cardStatus.cardState == CardState::ABSENT) {
 111         ASSERT_TRUE(CheckGeneralError() ||
 112                     radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME ||
 113                     radioRsp->rspInfo.error == RadioError::NONE ||
 114                     radioRsp->rspInfo.error == RadioError::OPERATION_NOT_ALLOWED);
 115     }
 116 }
 117
 118 /*
 119  * Test IRadio.setNetworkSelectionModeManual() for the response returned.
 120  */
 121 TEST_F(RadioHidlTest, setNetworkSelectionModeManual) {
 122     int serial = GetRandomSerialNumber();
 123
 124     radio->setNetworkSelectionModeManual(serial, "123456");
 125     EXPECT_EQ(std::cv_status::no_timeout, wait());
 126     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 127     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 128
 129     if (cardStatus.cardState == CardState::ABSENT) {
 130         ASSERT_TRUE(CheckGeneralError() ||
 131                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 132                     radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME ||
 133                     radioRsp->rspInfo.error == RadioError::NONE ||
 134                     radioRsp->rspInfo.error == RadioError::INVALID_STATE);
 135     }
 136 }
 137
 138 /*
 139  * Test IRadio.getAvailableNetworks() for the response returned.
 140  */
 141 TEST_F(RadioHidlTest, getAvailableNetworks) {
 142     int serial = GetRandomSerialNumber();
 143
 144     radio->getAvailableNetworks(serial);
 145     EXPECT_EQ(std::cv_status::no_timeout, wait());
 146     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 147     ASSERT_TRUE(radioRsp->rspInfo.type == RadioResponseType::SOLICITED ||
 148                 radioRsp->rspInfo.type == RadioResponseType::SOLICITED_ACK_EXP);
 149
 150     if (cardStatus.cardState == CardState::ABSENT) {
 151         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE ||
 152                     radioRsp->rspInfo.error == RadioError::DEVICE_IN_USE ||
 153                     radioRsp->rspInfo.error == RadioError::CANCELLED ||
 154                     radioRsp->rspInfo.error == RadioError::OPERATION_NOT_ALLOWED ||
 155                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 156     }
 157 }
 158
 159 /*
 160  * Test IRadio.getBasebandVersion() for the response returned.
 161  */
 162 TEST_F(RadioHidlTest, getBasebandVersion) {
 163     int serial = GetRandomSerialNumber();
 164
 165     radio->getBasebandVersion(serial);
 166     EXPECT_EQ(std::cv_status::no_timeout, wait());
 167     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 168     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 169
 170     if (cardStatus.cardState == CardState::ABSENT) {
 171         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
 172     }
 173 }
 174
 175 /*
 176  * Test IRadio.setBandMode() for the response returned.
 177  */
 178 TEST_F(RadioHidlTest, setBandMode) {
 179     int serial = GetRandomSerialNumber();
 180
 181     radio->setBandMode(serial, RadioBandMode::BAND_MODE_USA);
 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         EXPECT_EQ(radioRsp->rspInfo.error, RadioError::NONE);
 188     }
 189 }
 190
 191 /*
 192  * Test IRadio.getAvailableBandModes() for the response returned.
 193  */
 194 TEST_F(RadioHidlTest, getAvailableBandModes) {
 195     int serial = GetRandomSerialNumber();
 196
 197     radio->getAvailableBandModes(serial);
 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(radioRsp->rspInfo.error == RadioError::NONE);
 204     }
 205 }
 206
 207 /*
 208  * Test IRadio.setPreferredNetworkType() for the response returned.
 209  */
 210 TEST_F(RadioHidlTest, setPreferredNetworkType) {
 211     int serial = GetRandomSerialNumber();
 212
 213     radio->setPreferredNetworkType(serial, PreferredNetworkType::GSM_ONLY);
 214     EXPECT_EQ(std::cv_status::no_timeout, wait());
 215     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 216     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 217
 218     if (cardStatus.cardState == CardState::ABSENT) {
 219         EXPECT_EQ(radioRsp->rspInfo.error, RadioError::NONE);
 220     }
 221 }
 222
 223 /*
 224  * Test IRadio.getPreferredNetworkType() for the response returned.
 225  */
 226 TEST_F(RadioHidlTest, getPreferredNetworkType) {
 227     int serial = GetRandomSerialNumber();
 228
 229     radio->getPreferredNetworkType(serial);
 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::NONE);
 236     }
 237 }
 238
 239 /*
 240  * Test IRadio.getNeighboringCids() for the response returned.
 241  */
 242 TEST_F(RadioHidlTest, getNeighboringCids) {
 243     int serial = GetRandomSerialNumber();
 244
 245     radio->getNeighboringCids(serial);
 246     EXPECT_EQ(std::cv_status::no_timeout, wait());
 247     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 248     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 249
 250     if (cardStatus.cardState == CardState::ABSENT) {
 251         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 252                     radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
 253     }
 254 }
 255
 256 /*
 257  * Test IRadio.setLocationUpdates() for the response returned.
 258  */
 259 TEST_F(RadioHidlTest, setLocationUpdates) {
 260     int serial = GetRandomSerialNumber();
 261
 262     radio->setLocationUpdates(serial, true);
 263     EXPECT_EQ(std::cv_status::no_timeout, wait());
 264     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 265     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 266
 267     if (cardStatus.cardState == CardState::ABSENT) {
 268         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
 269     }
 270 }
 271
 272 /*
 273  * Test IRadio.setCdmaRoamingPreference() for the response returned.
 274  */
 275 TEST_F(RadioHidlTest, setCdmaRoamingPreference) {
 276     int serial = GetRandomSerialNumber();
 277
 278     radio->setCdmaRoamingPreference(serial, CdmaRoamingType::HOME_NETWORK);
 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::NONE ||
 285                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 286     }
 287 }
 288
 289 /*
 290  * Test IRadio.getCdmaRoamingPreference() for the response returned.
 291  */
 292 TEST_F(RadioHidlTest, getCdmaRoamingPreference) {
 293     int serial = GetRandomSerialNumber();
 294
 295     radio->getCdmaRoamingPreference(serial);
 296     EXPECT_EQ(std::cv_status::no_timeout, wait());
 297     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 298     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 299
 300     if (cardStatus.cardState == CardState::ABSENT) {
 301         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE ||
 302                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 303     }
 304 }
 305
 306 /*
 307  * Test IRadio.getTTYMode() for the response returned.
 308  */
 309 TEST_F(RadioHidlTest, getTTYMode) {
 310     int serial = GetRandomSerialNumber();
 311
 312     radio->getTTYMode(serial);
 313     EXPECT_EQ(std::cv_status::no_timeout, wait());
 314     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 315     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 316
 317     if (cardStatus.cardState == CardState::ABSENT) {
 318         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
 319     }
 320 }
 321
 322 /*
 323  * Test IRadio.setTTYMode() for the response returned.
 324  */
 325 TEST_F(RadioHidlTest, setTTYMode) {
 326     int serial = GetRandomSerialNumber();
 327
 328     radio->setTTYMode(serial, TtyMode::OFF);
 329     EXPECT_EQ(std::cv_status::no_timeout, wait());
 330     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 331     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 332
 333     if (cardStatus.cardState == CardState::ABSENT) {
 334         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
 335     }
 336 }
 337
 338 /*
 339  * Test IRadio.setPreferredVoicePrivacy() for the response returned.
 340  */
 341 TEST_F(RadioHidlTest, setPreferredVoicePrivacy) {
 342     int serial = GetRandomSerialNumber();
 343
 344     radio->setPreferredVoicePrivacy(serial, true);
 345     EXPECT_EQ(std::cv_status::no_timeout, wait());
 346     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 347     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 348
 349     if (cardStatus.cardState == CardState::ABSENT) {
 350         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 351                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 352     }
 353 }
 354
 355 /*
 356  * Test IRadio.getPreferredVoicePrivacy() for the response returned.
 357  */
 358 TEST_F(RadioHidlTest, getPreferredVoicePrivacy) {
 359     int serial = GetRandomSerialNumber();
 360
 361     radio->getPreferredVoicePrivacy(serial);
 362     EXPECT_EQ(std::cv_status::no_timeout, wait());
 363     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 364     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 365
 366     if (cardStatus.cardState == CardState::ABSENT) {
 367         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 368                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 369     }
 370 }
 371
 372 /*
 373  * Test IRadio.getCDMASubscription() for the response returned.
 374  */
 375 TEST_F(RadioHidlTest, getCDMASubscription) {
 376     int serial = GetRandomSerialNumber();
 377
 378     radio->getCDMASubscription(serial);
 379     EXPECT_EQ(std::cv_status::no_timeout, wait());
 380     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 381     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 382
 383     if (cardStatus.cardState == CardState::ABSENT) {
 384         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
 385     }
 386 }
 387
 388 /*
 389  * Test IRadio.getDeviceIdentity() for the response returned.
 390  */
 391 TEST_F(RadioHidlTest, getDeviceIdentity) {
 392     int serial = GetRandomSerialNumber();
 393
 394     radio->getDeviceIdentity(serial);
 395     EXPECT_EQ(std::cv_status::no_timeout, wait());
 396     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 397     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 398
 399     if (cardStatus.cardState == CardState::ABSENT) {
 400         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
 401     }
 402 }
 403
 404 /*
 405  * Test IRadio.exitEmergencyCallbackMode() for the response returned.
 406  */
 407 TEST_F(RadioHidlTest, exitEmergencyCallbackMode) {
 408     int serial = GetRandomSerialNumber();
 409
 410     radio->exitEmergencyCallbackMode(serial);
 411     EXPECT_EQ(std::cv_status::no_timeout, wait());
 412     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 413     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 414
 415     if (cardStatus.cardState == CardState::ABSENT) {
 416         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
 417     }
 418 }
 419
 420 /*
 421  * Test IRadio.getCdmaSubscriptionSource() for the response returned.
 422  */
 423 TEST_F(RadioHidlTest, getCdmaSubscriptionSource) {
 424     int serial = GetRandomSerialNumber();
 425
 426     radio->getCdmaSubscriptionSource(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(radioRsp->rspInfo.error == RadioError::NONE);
 433     }
 434 }
 435
 436 /*
 437  * Test IRadio.setCdmaSubscriptionSource() for the response returned.
 438  */
 439 TEST_F(RadioHidlTest, setCdmaSubscriptionSource) {
 440     int serial = GetRandomSerialNumber();
 441
 442     radio->setCdmaSubscriptionSource(serial, CdmaSubscriptionSource::RUIM_SIM);
 443     EXPECT_EQ(std::cv_status::no_timeout, wait());
 444     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 445     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 446
 447     if (cardStatus.cardState == CardState::ABSENT) {
 448         std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
 449         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::SIM_ABSENT ||
 450                     radioRsp->rspInfo.error == RadioError::SUBSCRIPTION_NOT_AVAILABLE ||
 451                     radioRsp->rspInfo.error == RadioError::NONE);
 452     }
 453 }
 454
 455 /*
 456  * Test IRadio.getVoiceRadioTechnology() for the response returned.
 457  */
 458 TEST_F(RadioHidlTest, getVoiceRadioTechnology) {
 459     int serial = GetRandomSerialNumber();
 460
 461     radio->getVoiceRadioTechnology(serial);
 462     EXPECT_EQ(std::cv_status::no_timeout, wait());
 463     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 464     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 465
 466     if (cardStatus.cardState == CardState::ABSENT) {
 467         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
 468     }
 469 }
 470
 471 /*
 472  * Test IRadio.getCellInfoList() for the response returned.
 473  */
 474 TEST_F(RadioHidlTest, getCellInfoList) {
 475     int serial = GetRandomSerialNumber();
 476
 477     radio->getCellInfoList(serial);
 478     EXPECT_EQ(std::cv_status::no_timeout, wait());
 479     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 480     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 481
 482     if (cardStatus.cardState == CardState::ABSENT) {
 483         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE ||
 484                     radioRsp->rspInfo.error == RadioError::NO_NETWORK_FOUND);
 485     }
 486 }
 487
 488 /*
 489  * Test IRadio.setCellInfoListRate() for the response returned.
 490  */
 491 TEST_F(RadioHidlTest, setCellInfoListRate) {
 492     int serial = GetRandomSerialNumber();
 493
 494     // TODO(sanketpadawe): RIL crashes with value of rate = 10
 495     radio->setCellInfoListRate(serial, 10);
 496     EXPECT_EQ(std::cv_status::no_timeout, wait());
 497     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 498     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 499
 500     if (cardStatus.cardState == CardState::ABSENT) {
 501         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 502                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 503     }
 504 }
 505
 506 /*
 507  * Test IRadio.nvReadItem() for the response returned.
 508  */
 509 TEST_F(RadioHidlTest, nvReadItem) {
 510     int serial = GetRandomSerialNumber();
 511
 512     radio->nvReadItem(serial, NvItem::LTE_BAND_ENABLE_25);
 513     EXPECT_EQ(std::cv_status::no_timeout, wait());
 514     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 515     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 516
 517     if (cardStatus.cardState == CardState::ABSENT) {
 518         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
 519     }
 520 }
 521
 522 /*
 523  * Test IRadio.nvWriteItem() for the response returned.
 524  */
 525 TEST_F(RadioHidlTest, nvWriteItem) {
 526     int serial = GetRandomSerialNumber();
 527     NvWriteItem item;
 528     memset(&item, 0, sizeof(item));
 529     item.value = hidl_string();
 530
 531     radio->nvWriteItem(serial, item);
 532     EXPECT_EQ(std::cv_status::no_timeout, wait());
 533     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 534     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 535
 536     if (cardStatus.cardState == CardState::ABSENT) {
 537         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
 538     }
 539 }
 540
 541 /*
 542  * Test IRadio.nvWriteCdmaPrl() for the response returned.
 543  */
 544 TEST_F(RadioHidlTest, nvWriteCdmaPrl) {
 545     int serial = GetRandomSerialNumber();
 546     std::vector<uint8_t> prl = {1, 2, 3, 4, 5};
 547
 548     radio->nvWriteCdmaPrl(serial, hidl_vec<uint8_t>(prl));
 549     EXPECT_EQ(std::cv_status::no_timeout, wait());
 550     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 551     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 552
 553     if (cardStatus.cardState == CardState::ABSENT) {
 554         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
 555     }
 556 }
 557
 558 /*
 559  * Test IRadio.nvResetConfig() for the response returned.
 560  */
 561 TEST_F(RadioHidlTest, nvResetConfig) {
 562     int serial = GetRandomSerialNumber();
 563
 564     radio->nvResetConfig(++serial, ResetNvType::ERASE);
 565     EXPECT_EQ(std::cv_status::no_timeout, wait());
 566     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 567     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 568
 569     if (cardStatus.cardState == CardState::ABSENT) {
 570         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 571                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 572     }
 573 }
 574
 575 /*
 576  * Test IRadio.setUiccSubscription() for the response returned.
 577  */
 578 TEST_F(RadioHidlTest, setUiccSubscription) {
 579     int serial = GetRandomSerialNumber();
 580     SelectUiccSub item;
 581     memset(&item, 0, sizeof(item));
 582
 583     radio->setUiccSubscription(serial, item);
 584     EXPECT_EQ(std::cv_status::no_timeout, wait());
 585     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 586     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 587
 588     if (cardStatus.cardState == CardState::ABSENT) {
 589         ASSERT_TRUE(CheckGeneralError() ||
 590                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 591                     radioRsp->rspInfo.error == RadioError::NONE ||
 592                     radioRsp->rspInfo.error == RadioError::SUBSCRIPTION_NOT_SUPPORTED ||
 593                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 594     }
 595 }
 596
 597 /*
 598  * Test IRadio.getHardwareConfig() for the response returned.
 599  */
 600 TEST_F(RadioHidlTest, getHardwareConfig) {
 601     int serial = GetRandomSerialNumber();
 602
 603     radio->getHardwareConfig(serial);
 604     EXPECT_EQ(std::cv_status::no_timeout, wait());
 605     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 606     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 607
 608     if (cardStatus.cardState == CardState::ABSENT) {
 609         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
 610     }
 611 }
 612
 613 /*
 614  * Test IRadio.requestShutdown() for the response returned.
 615  */
 616 TEST_F(RadioHidlTest, requestShutdown) {
 617     int serial = GetRandomSerialNumber();
 618
 619     radio->requestShutdown(serial);
 620     EXPECT_EQ(std::cv_status::no_timeout, wait());
 621     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 622     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 623
 624     if (cardStatus.cardState == CardState::ABSENT) {
 625         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
 626     }
 627 }
 628
 629 /*
 630  * Test IRadio.getRadioCapability() for the response returned.
 631  */
 632 TEST_F(RadioHidlTest, getRadioCapability) {
 633     int serial = GetRandomSerialNumber();
 634
 635     radio->getRadioCapability(serial);
 636     EXPECT_EQ(std::cv_status::no_timeout, wait());
 637     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 638     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 639
 640     if (cardStatus.cardState == CardState::ABSENT) {
 641         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
 642     }
 643 }
 644
 645 /*
 646  * Test IRadio.setRadioCapability() for the response returned.
 647  */
 648 TEST_F(RadioHidlTest, setRadioCapability) {
 649     int serial = GetRandomSerialNumber();
 650     RadioCapability rc;
 651     memset(&rc, 0, sizeof(rc));
 652     rc.logicalModemUuid = hidl_string();
 653
 654     radio->setRadioCapability(serial, rc);
 655     EXPECT_EQ(std::cv_status::no_timeout, wait());
 656     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 657     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 658
 659     if (cardStatus.cardState == CardState::ABSENT) {
 660         std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
 661         ASSERT_TRUE(CheckGeneralError() ||
 662                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 663                     radioRsp->rspInfo.error == RadioError::INVALID_STATE);
 664     }
 665 }
 666
 667 /*
 668  * Test IRadio.startLceService() for the response returned.
 669  */
 670 TEST_F(RadioHidlTest, startLceService) {
 671     int serial = GetRandomSerialNumber();
 672
 673     radio->startLceService(serial, 5, true);
 674     EXPECT_EQ(std::cv_status::no_timeout, wait());
 675     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 676     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 677
 678     if (cardStatus.cardState == CardState::ABSENT) {
 679         std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
 680         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::RADIO_NOT_AVAILABLE ||
 681                     radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED ||
 682                     radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
 683     }
 684 }
 685
 686 /*
 687  * Test IRadio.stopLceService() for the response returned.
 688  */
 689 TEST_F(RadioHidlTest, stopLceService) {
 690     int serial = GetRandomSerialNumber();
 691
 692     radio->stopLceService(serial);
 693     EXPECT_EQ(std::cv_status::no_timeout, wait());
 694     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 695     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 696
 697     if (cardStatus.cardState == CardState::ABSENT) {
 698         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 699                     radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED ||
 700                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 701     }
 702 }
 703
 704 /*
 705  * Test IRadio.pullLceData() for the response returned.
 706  */
 707 TEST_F(RadioHidlTest, pullLceData) {
 708     int serial = GetRandomSerialNumber();
 709
 710     radio->pullLceData(serial);
 711     EXPECT_EQ(std::cv_status::no_timeout, wait());
 712     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 713     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 714
 715     if (cardStatus.cardState == CardState::ABSENT) {
 716         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::RADIO_NOT_AVAILABLE || CheckOEMError() ||
 717                     radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
 718     }
 719 }
 720
 721 /*
 722  * Test IRadio.getModemActivityInfo() for the response returned.
 723  */
 724 TEST_F(RadioHidlTest, getModemActivityInfo) {
 725     int serial = GetRandomSerialNumber();
 726
 727     radio->getModemActivityInfo(serial);
 728     EXPECT_EQ(std::cv_status::no_timeout, wait());
 729     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 730     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 731
 732     if (cardStatus.cardState == CardState::ABSENT) {
 733         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 734                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 735     }
 736 }
 737
 738 /*
 739  * Test IRadio.setAllowedCarriers() for the response returned.
 740  */
 741 TEST_F(RadioHidlTest, setAllowedCarriers) {
 742     int serial = GetRandomSerialNumber();
 743     CarrierRestrictions carriers;
 744     memset(&carriers, 0, sizeof(carriers));
 745     carriers.allowedCarriers.resize(1);
 746     carriers.excludedCarriers.resize(0);
 747     carriers.allowedCarriers[0].mcc = hidl_string();
 748     carriers.allowedCarriers[0].mnc = hidl_string();
 749     carriers.allowedCarriers[0].matchType = CarrierMatchType::ALL;
 750     carriers.allowedCarriers[0].matchData = hidl_string();
 751
 752     radio->setAllowedCarriers(serial, false, carriers);
 753     EXPECT_EQ(std::cv_status::no_timeout, wait());
 754     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 755     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 756
 757     if (cardStatus.cardState == CardState::ABSENT) {
 758         EXPECT_EQ(radioRsp->rspInfo.error, RadioError::NONE);
 759     }
 760
 761     /* Reset back to no carrier restriction */
 762     memset(&carriers, 0, sizeof(carriers));
 763     carriers.allowedCarriers.resize(0);
 764     carriers.excludedCarriers.resize(0);
 765
 766     radio->setAllowedCarriers(++serial, true, carriers);
 767     EXPECT_EQ(std::cv_status::no_timeout, wait());
 768     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 769     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 770
 771     if (cardStatus.cardState == CardState::ABSENT) {
 772         EXPECT_EQ(radioRsp->rspInfo.error, RadioError::NONE);
 773     }
 774 }
 775
 776 /*
 777  * Test IRadio.getAllowedCarriers() for the response returned.
 778  */
 779 TEST_F(RadioHidlTest, getAllowedCarriers) {
 780     int serial = GetRandomSerialNumber();
 781
 782     radio->getAllowedCarriers(serial);
 783     EXPECT_EQ(std::cv_status::no_timeout, wait());
 784     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 785     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 786
 787     if (cardStatus.cardState == CardState::ABSENT) {
 788         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 789                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 790     }
 791 }
 792
 793 /*
 794  * Test IRadio.sendDeviceState() for the response returned.
 795  */
 796 TEST_F(RadioHidlTest, sendDeviceState) {
 797     int serial = GetRandomSerialNumber();
 798
 799     radio->sendDeviceState(serial, DeviceStateType::POWER_SAVE_MODE, true);
 800     EXPECT_EQ(std::cv_status::no_timeout, wait());
 801     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 802     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 803
 804     std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
 805
 806     if (cardStatus.cardState == CardState::ABSENT) {
 807         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 808                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 809     }
 810 }
 811
 812 /*
 813  * Test IRadio.setIndicationFilter() for the response returned.
 814  */
 815 TEST_F(RadioHidlTest, setIndicationFilter) {
 816     int serial = GetRandomSerialNumber();
 817
 818     radio->setIndicationFilter(serial, 1);
 819     EXPECT_EQ(std::cv_status::no_timeout, wait());
 820     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 821     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 822
 823     std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
 824
 825     if (cardStatus.cardState == CardState::ABSENT) {
 826         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 827                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 828     }
 829 }
 830
 831 /*
 832  * Test IRadio.setSimCardPower() for the response returned.
 833  */
 834 TEST_F(RadioHidlTest, setSimCardPower) {
 835     int serial = GetRandomSerialNumber();
 836
 837     radio->setSimCardPower(serial, true);
 838     EXPECT_EQ(std::cv_status::no_timeout, wait());
 839     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 840     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 841
 842     if (cardStatus.cardState == CardState::ABSENT) {
 843         std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
 844         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 845                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 846     }
 847 }