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, 1);
  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         ASSERT_TRUE(CheckGeneralError() || 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         ASSERT_TRUE(CheckGeneralError() || 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                     radioRsp->rspInfo.error == RadioError::EMPTY_RECORD);
 402     }
 403 }
 404
 405 /*
 406  * Test IRadio.exitEmergencyCallbackMode() for the response returned.
 407  */
 408 TEST_F(RadioHidlTest, exitEmergencyCallbackMode) {
 409     int serial = GetRandomSerialNumber();
 410
 411     radio->exitEmergencyCallbackMode(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::NONE);
 418     }
 419 }
 420
 421 /*
 422  * Test IRadio.getCdmaSubscriptionSource() for the response returned.
 423  */
 424 TEST_F(RadioHidlTest, getCdmaSubscriptionSource) {
 425     int serial = GetRandomSerialNumber();
 426
 427     radio->getCdmaSubscriptionSource(serial);
 428     EXPECT_EQ(std::cv_status::no_timeout, wait());
 429     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 430     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 431
 432     if (cardStatus.cardState == CardState::ABSENT) {
 433         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
 434     }
 435 }
 436
 437 /*
 438  * Test IRadio.setCdmaSubscriptionSource() for the response returned.
 439  */
 440 TEST_F(RadioHidlTest, setCdmaSubscriptionSource) {
 441     int serial = GetRandomSerialNumber();
 442
 443     radio->setCdmaSubscriptionSource(serial, CdmaSubscriptionSource::RUIM_SIM);
 444     EXPECT_EQ(std::cv_status::no_timeout, wait());
 445     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 446     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 447
 448     if (cardStatus.cardState == CardState::ABSENT) {
 449         std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
 450         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::SIM_ABSENT ||
 451                     radioRsp->rspInfo.error == RadioError::SUBSCRIPTION_NOT_AVAILABLE ||
 452                     radioRsp->rspInfo.error == RadioError::NONE);
 453     }
 454 }
 455
 456 /*
 457  * Test IRadio.getVoiceRadioTechnology() for the response returned.
 458  */
 459 TEST_F(RadioHidlTest, getVoiceRadioTechnology) {
 460     int serial = GetRandomSerialNumber();
 461
 462     radio->getVoiceRadioTechnology(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.getCellInfoList() for the response returned.
 474  */
 475 TEST_F(RadioHidlTest, getCellInfoList) {
 476     int serial = GetRandomSerialNumber();
 477
 478     radio->getCellInfoList(serial);
 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() || radioRsp->rspInfo.error == RadioError::NONE ||
 485                     radioRsp->rspInfo.error == RadioError::NO_NETWORK_FOUND);
 486     }
 487 }
 488
 489 /*
 490  * Test IRadio.setCellInfoListRate() for the response returned.
 491  */
 492 TEST_F(RadioHidlTest, setCellInfoListRate) {
 493     int serial = GetRandomSerialNumber();
 494
 495     // TODO(sanketpadawe): RIL crashes with value of rate = 10
 496     radio->setCellInfoListRate(serial, 10);
 497     EXPECT_EQ(std::cv_status::no_timeout, wait());
 498     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 499     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 500
 501     if (cardStatus.cardState == CardState::ABSENT) {
 502         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 503                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 504     }
 505 }
 506
 507 /*
 508  * Test IRadio.nvReadItem() for the response returned.
 509  */
 510 TEST_F(RadioHidlTest, nvReadItem) {
 511     int serial = GetRandomSerialNumber();
 512
 513     radio->nvReadItem(serial, NvItem::LTE_BAND_ENABLE_25);
 514     EXPECT_EQ(std::cv_status::no_timeout, wait());
 515     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 516     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 517
 518     if (cardStatus.cardState == CardState::ABSENT) {
 519         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
 520     }
 521 }
 522
 523 /*
 524  * Test IRadio.nvWriteItem() for the response returned.
 525  */
 526 TEST_F(RadioHidlTest, nvWriteItem) {
 527     int serial = GetRandomSerialNumber();
 528     NvWriteItem item;
 529     memset(&item, 0, sizeof(item));
 530     item.value = hidl_string();
 531
 532     radio->nvWriteItem(serial, item);
 533     EXPECT_EQ(std::cv_status::no_timeout, wait());
 534     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 535     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 536
 537     if (cardStatus.cardState == CardState::ABSENT) {
 538         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
 539     }
 540 }
 541
 542 /*
 543  * Test IRadio.nvWriteCdmaPrl() for the response returned.
 544  */
 545 TEST_F(RadioHidlTest, nvWriteCdmaPrl) {
 546     int serial = GetRandomSerialNumber();
 547     std::vector<uint8_t> prl = {1, 2, 3, 4, 5};
 548
 549     radio->nvWriteCdmaPrl(serial, hidl_vec<uint8_t>(prl));
 550     EXPECT_EQ(std::cv_status::no_timeout, wait());
 551     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 552     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 553
 554     if (cardStatus.cardState == CardState::ABSENT) {
 555         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
 556     }
 557 }
 558
 559 /*
 560  * Test IRadio.nvResetConfig() for the response returned.
 561  */
 562 TEST_F(RadioHidlTest, nvResetConfig) {
 563     int serial = GetRandomSerialNumber();
 564
 565     radio->nvResetConfig(++serial, ResetNvType::ERASE);
 566     EXPECT_EQ(std::cv_status::no_timeout, wait());
 567     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 568     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 569
 570     if (cardStatus.cardState == CardState::ABSENT) {
 571         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 572                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 573     }
 574 }
 575
 576 /*
 577  * Test IRadio.setUiccSubscription() for the response returned.
 578  */
 579 TEST_F(RadioHidlTest, setUiccSubscription) {
 580     int serial = GetRandomSerialNumber();
 581     SelectUiccSub item;
 582     memset(&item, 0, sizeof(item));
 583
 584     radio->setUiccSubscription(serial, item);
 585     EXPECT_EQ(std::cv_status::no_timeout, wait());
 586     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 587     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 588
 589     if (cardStatus.cardState == CardState::ABSENT) {
 590         ASSERT_TRUE(CheckGeneralError() ||
 591                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 592                     radioRsp->rspInfo.error == RadioError::NONE ||
 593                     radioRsp->rspInfo.error == RadioError::SUBSCRIPTION_NOT_SUPPORTED ||
 594                     radioRsp->rspInfo.error == RadioError::MODEM_ERR);
 595     }
 596 }
 597
 598 /*
 599  * Test IRadio.getHardwareConfig() for the response returned.
 600  */
 601 TEST_F(RadioHidlTest, getHardwareConfig) {
 602     int serial = GetRandomSerialNumber();
 603
 604     radio->getHardwareConfig(serial);
 605     EXPECT_EQ(std::cv_status::no_timeout, wait());
 606     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 607     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 608
 609     if (cardStatus.cardState == CardState::ABSENT) {
 610         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
 611     }
 612 }
 613
 614 /*
 615  * Test IRadio.requestShutdown() for the response returned.
 616  */
 617 TEST_F(RadioHidlTest, requestShutdown) {
 618     int serial = GetRandomSerialNumber();
 619
 620     radio->requestShutdown(serial);
 621     EXPECT_EQ(std::cv_status::no_timeout, wait());
 622     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 623     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 624
 625     if (cardStatus.cardState == CardState::ABSENT) {
 626         ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
 627     }
 628 }
 629
 630 /*
 631  * Test IRadio.getRadioCapability() for the response returned.
 632  */
 633 TEST_F(RadioHidlTest, getRadioCapability) {
 634     int serial = GetRandomSerialNumber();
 635
 636     radio->getRadioCapability(serial);
 637     EXPECT_EQ(std::cv_status::no_timeout, wait());
 638     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 639     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 640
 641     if (cardStatus.cardState == CardState::ABSENT) {
 642         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
 643     }
 644 }
 645
 646 /*
 647  * Test IRadio.setRadioCapability() for the response returned.
 648  */
 649 TEST_F(RadioHidlTest, setRadioCapability) {
 650     int serial = GetRandomSerialNumber();
 651     RadioCapability rc;
 652     memset(&rc, 0, sizeof(rc));
 653     rc.logicalModemUuid = hidl_string();
 654
 655     radio->setRadioCapability(serial, rc);
 656     EXPECT_EQ(std::cv_status::no_timeout, wait());
 657     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 658     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 659
 660     if (cardStatus.cardState == CardState::ABSENT) {
 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                     radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
 684     }
 685 }
 686
 687 /*
 688  * Test IRadio.stopLceService() for the response returned.
 689  */
 690 TEST_F(RadioHidlTest, stopLceService) {
 691     int serial = GetRandomSerialNumber();
 692
 693     radio->stopLceService(serial);
 694     EXPECT_EQ(std::cv_status::no_timeout, wait());
 695     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 696     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 697
 698     if (cardStatus.cardState == CardState::ABSENT) {
 699         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 700                     radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED ||
 701                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED ||
 702                     radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
 703     }
 704 }
 705
 706 /*
 707  * Test IRadio.pullLceData() for the response returned.
 708  */
 709 TEST_F(RadioHidlTest, pullLceData) {
 710     int serial = GetRandomSerialNumber();
 711
 712     radio->pullLceData(serial);
 713     EXPECT_EQ(std::cv_status::no_timeout, wait());
 714     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 715     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 716
 717     if (cardStatus.cardState == CardState::ABSENT) {
 718         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::RADIO_NOT_AVAILABLE || CheckOEMError() ||
 719                     radioRsp->rspInfo.error == RadioError::INTERNAL_ERR ||
 720                     radioRsp->rspInfo.error == RadioError::NONE);
 721     }
 722 }
 723
 724 /*
 725  * Test IRadio.getModemActivityInfo() for the response returned.
 726  */
 727 TEST_F(RadioHidlTest, getModemActivityInfo) {
 728     int serial = GetRandomSerialNumber();
 729
 730     radio->getModemActivityInfo(serial);
 731     EXPECT_EQ(std::cv_status::no_timeout, wait());
 732     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 733     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 734
 735     if (cardStatus.cardState == CardState::ABSENT) {
 736         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 737                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 738     }
 739 }
 740
 741 /*
 742  * Test IRadio.setAllowedCarriers() for the response returned.
 743  */
 744 TEST_F(RadioHidlTest, setAllowedCarriers) {
 745     int serial = GetRandomSerialNumber();
 746     CarrierRestrictions carriers;
 747     memset(&carriers, 0, sizeof(carriers));
 748     carriers.allowedCarriers.resize(1);
 749     carriers.excludedCarriers.resize(0);
 750     carriers.allowedCarriers[0].mcc = hidl_string();
 751     carriers.allowedCarriers[0].mnc = hidl_string();
 752     carriers.allowedCarriers[0].matchType = CarrierMatchType::ALL;
 753     carriers.allowedCarriers[0].matchData = hidl_string();
 754
 755     radio->setAllowedCarriers(serial, false, carriers);
 756     EXPECT_EQ(std::cv_status::no_timeout, wait());
 757     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 758     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 759
 760     if (cardStatus.cardState == CardState::ABSENT) {
 761         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 762                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 763     }
 764
 765     /* Reset back to no carrier restriction */
 766     memset(&carriers, 0, sizeof(carriers));
 767     carriers.allowedCarriers.resize(0);
 768     carriers.excludedCarriers.resize(0);
 769
 770     radio->setAllowedCarriers(++serial, true, carriers);
 771     EXPECT_EQ(std::cv_status::no_timeout, wait());
 772     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 773     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 774
 775     if (cardStatus.cardState == CardState::ABSENT) {
 776         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 777                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 778     }
 779 }
 780
 781 /*
 782  * Test IRadio.getAllowedCarriers() for the response returned.
 783  */
 784 TEST_F(RadioHidlTest, getAllowedCarriers) {
 785     int serial = GetRandomSerialNumber();
 786
 787     radio->getAllowedCarriers(serial);
 788     EXPECT_EQ(std::cv_status::no_timeout, wait());
 789     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 790     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 791
 792     if (cardStatus.cardState == CardState::ABSENT) {
 793         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 794                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 795     }
 796 }
 797
 798 /*
 799  * Test IRadio.sendDeviceState() for the response returned.
 800  */
 801 TEST_F(RadioHidlTest, sendDeviceState) {
 802     int serial = GetRandomSerialNumber();
 803
 804     radio->sendDeviceState(serial, DeviceStateType::POWER_SAVE_MODE, true);
 805     EXPECT_EQ(std::cv_status::no_timeout, wait());
 806     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 807     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 808
 809     std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
 810
 811     if (cardStatus.cardState == CardState::ABSENT) {
 812         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 813                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 814     }
 815 }
 816
 817 /*
 818  * Test IRadio.setIndicationFilter() for the response returned.
 819  */
 820 TEST_F(RadioHidlTest, setIndicationFilter) {
 821     int serial = GetRandomSerialNumber();
 822
 823     radio->setIndicationFilter(serial, 1);
 824     EXPECT_EQ(std::cv_status::no_timeout, wait());
 825     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 826     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 827
 828     std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
 829
 830     if (cardStatus.cardState == CardState::ABSENT) {
 831         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 832                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 833     }
 834 }
 835
 836 /*
 837  * Test IRadio.setSimCardPower() for the response returned.
 838  */
 839 TEST_F(RadioHidlTest, setSimCardPower) {
 840     int serial = GetRandomSerialNumber();
 841
 842     radio->setSimCardPower(serial, true);
 843     EXPECT_EQ(std::cv_status::no_timeout, wait());
 844     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 845     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 846
 847     if (cardStatus.cardState == CardState::ABSENT) {
 848         ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
 849                     radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
 850     }
 851 }