Home | History | Annotate | Download | only in functional 
      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_2.h>
     18 #include <vector>
     19 
     20 #define ASSERT_OK(ret) ASSERT_TRUE(ret.isOk())
     21 
     22 /*
     23  * Test IRadio.startNetworkScan() for the response returned.
     24  */
     25 TEST_F(RadioHidlTest_v1_2, startNetworkScan) {
     26     serial = GetRandomSerialNumber();
     27 
     28     RadioAccessSpecifier specifier = {
     29         .radioAccessNetwork = RadioAccessNetworks::GERAN,
     30         .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
     31         .channels = {1,2}};
     32 
     33     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
     34         .type = ScanType::ONE_SHOT, .interval = 60, .specifiers = {specifier}};
     35 
     36     Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
     37     ASSERT_OK(res);
     38     EXPECT_EQ(std::cv_status::no_timeout, wait());
     39     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
     40     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
     41 
     42     ALOGI("startNetworkScan, rspInfo.error = %s\n", toString(radioRsp_v1_2->rspInfo.error).c_str());
     43     if (cardStatus.base.cardState == CardState::ABSENT) {
     44         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::SIM_ABSENT}));
     45     } else if (cardStatus.base.cardState == CardState::PRESENT) {
     46         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
     47     }
     48 }
     49 
     50 /*
     51  * Test IRadio.startNetworkScan() with invalid specifier.
     52  */
     53 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidArgument) {
     54     serial = GetRandomSerialNumber();
     55 
     56     ::android::hardware::radio::V1_2::NetworkScanRequest request = {.type = ScanType::ONE_SHOT,
     57                                                                     .interval = 60};
     58 
     59     Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
     60     ASSERT_OK(res);
     61     EXPECT_EQ(std::cv_status::no_timeout, wait());
     62     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
     63     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
     64 
     65     ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
     66           toString(radioRsp_v1_2->rspInfo.error).c_str());
     67     if (cardStatus.base.cardState == CardState::ABSENT) {
     68         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
     69                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
     70     } else if (cardStatus.base.cardState == CardState::PRESENT) {
     71         ASSERT_TRUE(
     72             CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
     73     }
     74 }
     75 
     76 /*
     77  * Test IRadio.startNetworkScan() with invalid interval (lower boundary).
     78  */
     79 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidInterval1) {
     80     serial = GetRandomSerialNumber();
     81 
     82     RadioAccessSpecifier specifier = {
     83         .radioAccessNetwork = RadioAccessNetworks::GERAN,
     84         .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
     85         .channels = {1,2}};
     86 
     87     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
     88         .type = ScanType::ONE_SHOT,
     89         .interval = 4,
     90         .specifiers = {specifier},
     91         .maxSearchTime = 60,
     92         .incrementalResults = false,
     93         .incrementalResultsPeriodicity = 1};
     94 
     95     Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
     96     ASSERT_OK(res);
     97     EXPECT_EQ(std::cv_status::no_timeout, wait());
     98     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
     99     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    100 
    101     ALOGI("startNetworkScan_InvalidInterval1, rspInfo.error = %s\n",
    102           toString(radioRsp_v1_2->rspInfo.error).c_str());
    103     if (cardStatus.base.cardState == CardState::ABSENT) {
    104         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
    105                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
    106     } else if (cardStatus.base.cardState == CardState::PRESENT) {
    107         ASSERT_TRUE(
    108             CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
    109     }
    110 }
    111 
    112 /*
    113  * Test IRadio.startNetworkScan() with invalid interval (upper boundary).
    114  */
    115 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidInterval2) {
    116     serial = GetRandomSerialNumber();
    117 
    118     RadioAccessSpecifier specifier = {
    119         .radioAccessNetwork = RadioAccessNetworks::GERAN,
    120         .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
    121         .channels = {1,2}};
    122 
    123     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
    124         .type = ScanType::ONE_SHOT,
    125         .interval = 301,
    126         .specifiers = {specifier},
    127         .maxSearchTime = 60,
    128         .incrementalResults = false,
    129         .incrementalResultsPeriodicity = 1};
    130 
    131     Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
    132     ASSERT_OK(res);
    133     EXPECT_EQ(std::cv_status::no_timeout, wait());
    134     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    135     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    136 
    137     ALOGI("startNetworkScan_InvalidInterval2, rspInfo.error = %s\n",
    138           toString(radioRsp_v1_2->rspInfo.error).c_str());
    139     if (cardStatus.base.cardState == CardState::ABSENT) {
    140         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
    141                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
    142     } else if (cardStatus.base.cardState == CardState::PRESENT) {
    143         ASSERT_TRUE(
    144             CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
    145     }
    146 }
    147 
    148 /*
    149  * Test IRadio.startNetworkScan() with invalid max search time (lower boundary).
    150  */
    151 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidMaxSearchTime1) {
    152     serial = GetRandomSerialNumber();
    153 
    154     RadioAccessSpecifier specifier = {
    155         .radioAccessNetwork = RadioAccessNetworks::GERAN,
    156         .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
    157         .channels = {1,2}};
    158 
    159     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
    160         .type = ScanType::ONE_SHOT,
    161         .interval = 60,
    162         .specifiers = {specifier},
    163         .maxSearchTime = 59,
    164         .incrementalResults = false,
    165         .incrementalResultsPeriodicity = 1};
    166 
    167     Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
    168     ASSERT_OK(res);
    169     EXPECT_EQ(std::cv_status::no_timeout, wait());
    170     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    171     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    172 
    173     ALOGI("startNetworkScan_InvalidMaxSearchTime1, rspInfo.error = %s\n",
    174           toString(radioRsp_v1_2->rspInfo.error).c_str());
    175     if (cardStatus.base.cardState == CardState::ABSENT) {
    176         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
    177                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
    178     } else if (cardStatus.base.cardState == CardState::PRESENT) {
    179         ASSERT_TRUE(
    180             CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
    181     }
    182 }
    183 
    184 /*
    185  * Test IRadio.startNetworkScan() with invalid max search time (upper boundary).
    186  */
    187 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidMaxSearchTime2) {
    188     serial = GetRandomSerialNumber();
    189 
    190     RadioAccessSpecifier specifier = {
    191         .radioAccessNetwork = RadioAccessNetworks::GERAN,
    192         .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
    193         .channels = {1,2}};
    194 
    195     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
    196         .type = ScanType::ONE_SHOT,
    197         .interval = 60,
    198         .specifiers = {specifier},
    199         .maxSearchTime = 3601,
    200         .incrementalResults = false,
    201         .incrementalResultsPeriodicity = 1};
    202 
    203     Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
    204     ASSERT_OK(res);
    205     EXPECT_EQ(std::cv_status::no_timeout, wait());
    206     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    207     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    208 
    209     ALOGI("startNetworkScan_InvalidMaxSearchTime2, rspInfo.error = %s\n",
    210           toString(radioRsp_v1_2->rspInfo.error).c_str());
    211     if (cardStatus.base.cardState == CardState::ABSENT) {
    212         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
    213                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
    214     } else if (cardStatus.base.cardState == CardState::PRESENT) {
    215         ASSERT_TRUE(
    216             CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
    217     }
    218 }
    219 
    220 /*
    221  * Test IRadio.startNetworkScan() with invalid periodicity (lower boundary).
    222  */
    223 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidPeriodicity1) {
    224     serial = GetRandomSerialNumber();
    225 
    226     RadioAccessSpecifier specifier = {
    227         .radioAccessNetwork = RadioAccessNetworks::GERAN,
    228         .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
    229         .channels = {1,2}};
    230 
    231     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
    232         .type = ScanType::ONE_SHOT,
    233         .interval = 60,
    234         .specifiers = {specifier},
    235         .maxSearchTime = 600,
    236         .incrementalResults = false,
    237         .incrementalResultsPeriodicity = 0};
    238 
    239     Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
    240     ASSERT_OK(res);
    241     EXPECT_EQ(std::cv_status::no_timeout, wait());
    242     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    243     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    244 
    245     ALOGI("startNetworkScan_InvalidPeriodicity1, rspInfo.error = %s\n",
    246           toString(radioRsp_v1_2->rspInfo.error).c_str());
    247     if (cardStatus.base.cardState == CardState::ABSENT) {
    248         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
    249                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
    250     } else if (cardStatus.base.cardState == CardState::PRESENT) {
    251         ASSERT_TRUE(
    252             CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
    253     }
    254 }
    255 
    256 /*
    257  * Test IRadio.startNetworkScan() with invalid periodicity (upper boundary).
    258  */
    259 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidPeriodicity2) {
    260     serial = GetRandomSerialNumber();
    261 
    262     RadioAccessSpecifier specifier = {
    263         .radioAccessNetwork = RadioAccessNetworks::GERAN,
    264         .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
    265         .channels = {1,2}};
    266 
    267     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
    268         .type = ScanType::ONE_SHOT,
    269         .interval = 60,
    270         .specifiers = {specifier},
    271         .maxSearchTime = 600,
    272         .incrementalResults = false,
    273         .incrementalResultsPeriodicity = 11};
    274 
    275     Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
    276     ASSERT_OK(res);
    277     EXPECT_EQ(std::cv_status::no_timeout, wait());
    278     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    279     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    280 
    281     ALOGI("startNetworkScan_InvalidPeriodicity2, rspInfo.error = %s\n",
    282           toString(radioRsp_v1_2->rspInfo.error).c_str());
    283     if (cardStatus.base.cardState == CardState::ABSENT) {
    284         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
    285                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
    286     } else if (cardStatus.base.cardState == CardState::PRESENT) {
    287         ASSERT_TRUE(
    288             CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
    289     }
    290 }
    291 
    292 /*
    293  * Test IRadio.startNetworkScan() with valid periodicity
    294  */
    295 TEST_F(RadioHidlTest_v1_2, startNetworkScan_GoodRequest1) {
    296     serial = GetRandomSerialNumber();
    297 
    298     RadioAccessSpecifier specifier = {
    299         .radioAccessNetwork = RadioAccessNetworks::GERAN,
    300         .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
    301         .channels = {1,2}};
    302 
    303     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
    304         .type = ScanType::ONE_SHOT,
    305         .interval = 60,
    306         .specifiers = {specifier},
    307         .maxSearchTime = 600,
    308         .incrementalResults = false,
    309         .incrementalResultsPeriodicity = 10};
    310 
    311     Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
    312     ASSERT_OK(res);
    313     EXPECT_EQ(std::cv_status::no_timeout, wait());
    314     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    315     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    316 
    317     ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
    318           toString(radioRsp_v1_2->rspInfo.error).c_str());
    319     if (cardStatus.base.cardState == CardState::ABSENT) {
    320         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
    321                                      {RadioError::NONE, RadioError::SIM_ABSENT}));
    322     } else if (cardStatus.base.cardState == CardState::PRESENT) {
    323         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
    324     }
    325 }
    326 
    327 /*
    328  * Test IRadio.startNetworkScan() with valid periodicity and plmns
    329  */
    330 TEST_F(RadioHidlTest_v1_2, startNetworkScan_GoodRequest2) {
    331     serial = GetRandomSerialNumber();
    332 
    333     RadioAccessSpecifier specifier = {
    334         .radioAccessNetwork = RadioAccessNetworks::GERAN,
    335         .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
    336         .channels = {1,2}};
    337 
    338     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
    339         .type = ScanType::ONE_SHOT,
    340         .interval = 60,
    341         .specifiers = {specifier},
    342         .maxSearchTime = 600,
    343         .incrementalResults = false,
    344         .incrementalResultsPeriodicity = 10,
    345         .mccMncs = {"310410"}};
    346 
    347     Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
    348     ASSERT_OK(res);
    349     EXPECT_EQ(std::cv_status::no_timeout, wait());
    350     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    351     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    352 
    353     ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
    354           toString(radioRsp_v1_2->rspInfo.error).c_str());
    355     if (cardStatus.base.cardState == CardState::ABSENT) {
    356         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
    357                                      {RadioError::NONE, RadioError::SIM_ABSENT}));
    358     } else if (cardStatus.base.cardState == CardState::PRESENT) {
    359         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
    360     }
    361 }
    362 
    363 /*
    364  * Test IRadio.setIndicationFilter_1_2()
    365  */
    366 TEST_F(RadioHidlTest_v1_2, setIndicationFilter_1_2) {
    367     serial = GetRandomSerialNumber();
    368 
    369     Return<void> res = radio_v1_2->setIndicationFilter_1_2(
    370         serial, static_cast<int>(::android::hardware::radio::V1_2::IndicationFilter::ALL));
    371     ASSERT_OK(res);
    372     EXPECT_EQ(std::cv_status::no_timeout, wait());
    373     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    374     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    375 
    376     ALOGI("setIndicationFilter_1_2, rspInfo.error = %s\n",
    377           toString(radioRsp_v1_2->rspInfo.error).c_str());
    378     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
    379 }
    380 
    381 /*
    382  * Test IRadio.setSignalStrengthReportingCriteria() with invalid hysteresisDb
    383  */
    384 TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_invalidHysteresisDb) {
    385     serial = GetRandomSerialNumber();
    386 
    387     Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
    388         serial, 5000,
    389         10,  // hysteresisDb too large given threshold list deltas
    390         {-109, -103, -97, -89}, ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
    391     ASSERT_OK(res);
    392     EXPECT_EQ(std::cv_status::no_timeout, wait());
    393     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    394     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    395 
    396     ALOGI("setSignalStrengthReportingCriteria_invalidHysteresisDb, rspInfo.error = %s\n",
    397           toString(radioRsp_v1_2->rspInfo.error).c_str());
    398     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
    399 }
    400 
    401 /*
    402  * Test IRadio.setSignalStrengthReportingCriteria() with empty parameters
    403  */
    404 TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_EmptyParams) {
    405     serial = GetRandomSerialNumber();
    406 
    407     Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
    408         serial, 0, 0, {}, ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
    409     ASSERT_OK(res);
    410     EXPECT_EQ(std::cv_status::no_timeout, wait());
    411     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    412     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    413 
    414     ALOGI("setSignalStrengthReportingCriteria_EmptyParams, rspInfo.error = %s\n",
    415           toString(radioRsp_v1_2->rspInfo.error).c_str());
    416     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
    417 }
    418 
    419 /*
    420  * Test IRadio.setSignalStrengthReportingCriteria() for GERAN
    421  */
    422 TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Geran) {
    423     serial = GetRandomSerialNumber();
    424 
    425     Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
    426         serial, 5000, 2, {-109, -103, -97, -89},
    427         ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
    428     ASSERT_OK(res);
    429     EXPECT_EQ(std::cv_status::no_timeout, wait());
    430     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    431     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    432 
    433     ALOGI("setSignalStrengthReportingCriteria_Geran, rspInfo.error = %s\n",
    434           toString(radioRsp_v1_2->rspInfo.error).c_str());
    435     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
    436 }
    437 
    438 /*
    439  * Test IRadio.setSignalStrengthReportingCriteria() for UTRAN
    440  */
    441 TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Utran) {
    442     serial = GetRandomSerialNumber();
    443 
    444     Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
    445         serial, 5000, 2, {-110, -97, -73, -49, -25},
    446         ::android::hardware::radio::V1_2::AccessNetwork::UTRAN);
    447     ASSERT_OK(res);
    448     EXPECT_EQ(std::cv_status::no_timeout, wait());
    449     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    450     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    451 
    452     ALOGI("setSignalStrengthReportingCriteria_Utran, rspInfo.error = %s\n",
    453           toString(radioRsp_v1_2->rspInfo.error).c_str());
    454     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
    455 }
    456 
    457 /*
    458  * Test IRadio.setSignalStrengthReportingCriteria() for EUTRAN
    459  */
    460 TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Eutran) {
    461     serial = GetRandomSerialNumber();
    462 
    463     Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
    464         serial, 5000, 2, {-140, -128, -118, -108, -98, -44},
    465         ::android::hardware::radio::V1_2::AccessNetwork::EUTRAN);
    466     ASSERT_OK(res);
    467     EXPECT_EQ(std::cv_status::no_timeout, wait());
    468     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    469     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    470 
    471     ALOGI("setSignalStrengthReportingCriteria_Eutran, rspInfo.error = %s\n",
    472           toString(radioRsp_v1_2->rspInfo.error).c_str());
    473     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
    474 }
    475 
    476 /*
    477  * Test IRadio.setSignalStrengthReportingCriteria() for CDMA2000
    478  */
    479 TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Cdma2000) {
    480     serial = GetRandomSerialNumber();
    481 
    482     Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
    483         serial, 5000, 2, {-105, -90, -75, -65},
    484         ::android::hardware::radio::V1_2::AccessNetwork::CDMA2000);
    485     ASSERT_OK(res);
    486     EXPECT_EQ(std::cv_status::no_timeout, wait());
    487     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    488     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    489 
    490     ALOGI("setSignalStrengthReportingCriteria_Cdma2000, rspInfo.error = %s\n",
    491           toString(radioRsp_v1_2->rspInfo.error).c_str());
    492     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
    493 }
    494 
    495 /*
    496  * Test IRadio.setLinkCapacityReportingCriteria() invalid hysteresisDlKbps
    497  */
    498 TEST_F(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_invalidHysteresisDlKbps) {
    499     serial = GetRandomSerialNumber();
    500 
    501     Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
    502         serial, 5000,
    503         5000,  // hysteresisDlKbps too big for thresholds delta
    504         100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
    505         ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
    506     ASSERT_OK(res);
    507     EXPECT_EQ(std::cv_status::no_timeout, wait());
    508     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    509     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    510 
    511     ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisDlKbps, rspInfo.error = %s\n",
    512           toString(radioRsp_v1_2->rspInfo.error).c_str());
    513     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
    514 }
    515 
    516 /*
    517  * Test IRadio.setLinkCapacityReportingCriteria() invalid hysteresisUlKbps
    518  */
    519 TEST_F(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_invalidHysteresisUlKbps) {
    520     serial = GetRandomSerialNumber();
    521 
    522     Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
    523         serial, 5000, 500,
    524         1000,  // hysteresisUlKbps too big for thresholds delta
    525         {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
    526         ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
    527     ASSERT_OK(res);
    528     EXPECT_EQ(std::cv_status::no_timeout, wait());
    529     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    530     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    531 
    532     ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisUlKbps, rspInfo.error = %s\n",
    533           toString(radioRsp_v1_2->rspInfo.error).c_str());
    534     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
    535 }
    536 
    537 /*
    538  * Test IRadio.setLinkCapacityReportingCriteria() empty params
    539  */
    540 TEST_F(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_emptyParams) {
    541     serial = GetRandomSerialNumber();
    542 
    543     Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
    544         serial, 0, 0, 0, {}, {}, ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
    545     ASSERT_OK(res);
    546     EXPECT_EQ(std::cv_status::no_timeout, wait());
    547     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    548     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    549 
    550     ALOGI("setLinkCapacityReportingCriteria_emptyParams, rspInfo.error = %s\n",
    551           toString(radioRsp_v1_2->rspInfo.error).c_str());
    552     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
    553 }
    554 
    555 /*
    556  * Test IRadio.setLinkCapacityReportingCriteria() GERAN
    557  */
    558 TEST_F(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_Geran) {
    559     serial = GetRandomSerialNumber();
    560 
    561     Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
    562         serial, 5000, 500, 100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
    563         ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
    564     ASSERT_OK(res);
    565     EXPECT_EQ(std::cv_status::no_timeout, wait());
    566     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    567     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    568 
    569     ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisUlKbps, rspInfo.error = %s\n",
    570           toString(radioRsp_v1_2->rspInfo.error).c_str());
    571     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
    572 }
    573 
    574 /*
    575  * Test IRadio.setupDataCall_1_2() for the response returned.
    576  */
    577 TEST_F(RadioHidlTest_v1_2, setupDataCall_1_2) {
    578     serial = GetRandomSerialNumber();
    579 
    580     ::android::hardware::radio::V1_2::AccessNetwork accessNetwork =
    581         ::android::hardware::radio::V1_2::AccessNetwork::EUTRAN;
    582 
    583     DataProfileInfo dataProfileInfo;
    584     memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
    585     dataProfileInfo.profileId = DataProfileId::IMS;
    586     dataProfileInfo.apn = hidl_string("VZWIMS");
    587     dataProfileInfo.protocol = hidl_string("IPV4V6");
    588     dataProfileInfo.roamingProtocol = hidl_string("IPV6");
    589     dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
    590     dataProfileInfo.user = "";
    591     dataProfileInfo.password = "";
    592     dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
    593     dataProfileInfo.maxConnsTime = 300;
    594     dataProfileInfo.maxConns = 20;
    595     dataProfileInfo.waitTime = 0;
    596     dataProfileInfo.enabled = true;
    597     dataProfileInfo.supportedApnTypesBitmap = 320;
    598     dataProfileInfo.bearerBitmap = 161543;
    599     dataProfileInfo.mtu = 0;
    600     dataProfileInfo.mvnoType = MvnoType::NONE;
    601     dataProfileInfo.mvnoMatchData = hidl_string();
    602 
    603     bool modemCognitive = false;
    604     bool roamingAllowed = false;
    605     bool isRoaming = false;
    606 
    607     ::android::hardware::radio::V1_2::DataRequestReason reason =
    608         ::android::hardware::radio::V1_2::DataRequestReason::NORMAL;
    609     std::vector<hidl_string> addresses = {""};
    610     std::vector<hidl_string> dnses = {""};
    611 
    612     Return<void> res = radio_v1_2->setupDataCall_1_2(serial, accessNetwork, dataProfileInfo,
    613                                                      modemCognitive, roamingAllowed, isRoaming,
    614                                                      reason, addresses, dnses);
    615     ASSERT_OK(res);
    616 
    617     EXPECT_EQ(std::cv_status::no_timeout, wait());
    618     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    619     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    620 
    621     if (cardStatus.base.cardState == CardState::ABSENT) {
    622         ASSERT_TRUE(CheckAnyOfErrors(
    623             radioRsp_v1_2->rspInfo.error,
    624             {RadioError::SIM_ABSENT, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_ARGUMENTS,
    625              RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW, RadioError::REQUEST_NOT_SUPPORTED}));
    626     } else if (cardStatus.base.cardState == CardState::PRESENT) {
    627         ASSERT_TRUE(CheckAnyOfErrors(
    628             radioRsp_v1_2->rspInfo.error,
    629             {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_ARGUMENTS,
    630              RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW, RadioError::REQUEST_NOT_SUPPORTED}));
    631     }
    632 }
    633 
    634 /*
    635  * Test IRadio.deactivateDataCall_1_2() for the response returned.
    636  */
    637 TEST_F(RadioHidlTest_v1_2, deactivateDataCall_1_2) {
    638     serial = GetRandomSerialNumber();
    639     int cid = 1;
    640     ::android::hardware::radio::V1_2::DataRequestReason reason =
    641         ::android::hardware::radio::V1_2::DataRequestReason::NORMAL;
    642 
    643     Return<void> res = radio_v1_2->deactivateDataCall_1_2(serial, cid, reason);
    644     ASSERT_OK(res);
    645 
    646     EXPECT_EQ(std::cv_status::no_timeout, wait());
    647     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    648     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    649 
    650     if (cardStatus.base.cardState == CardState::ABSENT) {
    651         ASSERT_TRUE(CheckAnyOfErrors(
    652             radioRsp_v1_2->rspInfo.error,
    653             {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_CALL_ID,
    654              RadioError::INVALID_STATE, RadioError::INVALID_ARGUMENTS,
    655              RadioError::REQUEST_NOT_SUPPORTED, RadioError::CANCELLED, RadioError::SIM_ABSENT}));
    656     } else if (cardStatus.base.cardState == CardState::PRESENT) {
    657         ASSERT_TRUE(CheckAnyOfErrors(
    658             radioRsp_v1_2->rspInfo.error,
    659             {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_CALL_ID,
    660              RadioError::INVALID_STATE, RadioError::INVALID_ARGUMENTS,
    661              RadioError::REQUEST_NOT_SUPPORTED, RadioError::CANCELLED}));
    662     }
    663 }
    664 
    665 /*
    666  * Test IRadio.getCellInfoList() for the response returned.
    667  */
    668 TEST_F(RadioHidlTest_v1_2, getCellInfoList_1_2) {
    669     int serial = GetRandomSerialNumber();
    670 
    671     Return<void> res = radio_v1_2->getCellInfoList(serial);
    672     ASSERT_OK(res);
    673     EXPECT_EQ(std::cv_status::no_timeout, wait());
    674     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    675     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    676 
    677     ALOGI("getCellInfoList_1_2, rspInfo.error = %s\n",
    678           toString(radioRsp_v1_2->rspInfo.error).c_str());
    679     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
    680                                  {RadioError::NONE, RadioError::NO_NETWORK_FOUND}));
    681 }
    682 
    683 /*
    684  * Test IRadio.getVoiceRegistrationState() for the response returned.
    685  */
    686 TEST_F(RadioHidlTest_v1_2, getVoiceRegistrationState) {
    687     int serial = GetRandomSerialNumber();
    688 
    689     Return<void> res = radio_v1_2->getVoiceRegistrationState(serial);
    690     ASSERT_OK(res);
    691     EXPECT_EQ(std::cv_status::no_timeout, wait());
    692     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    693     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    694 
    695     ALOGI("getVoiceRegistrationStateResponse_1_2, rspInfo.error = %s\n",
    696           toString(radioRsp_v1_2->rspInfo.error).c_str());
    697     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
    698                                  {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
    699 }
    700 
    701 /*
    702  * Test IRadio.getDataRegistrationState() for the response returned.
    703  */
    704 TEST_F(RadioHidlTest_v1_2, getDataRegistrationState) {
    705     int serial = GetRandomSerialNumber();
    706 
    707     Return<void> res = radio_v1_2->getDataRegistrationState(serial);
    708     ASSERT_OK(res);
    709     EXPECT_EQ(std::cv_status::no_timeout, wait());
    710     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    711     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    712 
    713     ALOGI("getVoiceRegistrationStateResponse_1_2, rspInfo.error = %s\n",
    714           toString(radioRsp_v1_2->rspInfo.error).c_str());
    715     ASSERT_TRUE(CheckAnyOfErrors(
    716         radioRsp_v1_2->rspInfo.error,
    717         {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::NOT_PROVISIONED}));
    718 }
    719 
    720 /*
    721  * Test IRadio.getAvailableBandModes() for the response returned.
    722  */
    723 TEST_F(RadioHidlTest_v1_2, getAvailableBandModes) {
    724     int serial = GetRandomSerialNumber();
    725 
    726     Return<void> res = radio_v1_2->getAvailableBandModes(serial);
    727     ASSERT_OK(res);
    728     EXPECT_EQ(std::cv_status::no_timeout, wait());
    729     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
    730     EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
    731     ALOGI("getAvailableBandModes, rspInfo.error = %s\n",
    732           toString(radioRsp_v1_2->rspInfo.error).c_str());
    733     ASSERT_TRUE(
    734         CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
    735                          {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::MODEM_ERR,
    736                           RadioError::INTERNAL_ERR,
    737                           // If REQUEST_NOT_SUPPORTED is returned, then it should also be returned
    738                           // for setRandMode().
    739                           RadioError::REQUEST_NOT_SUPPORTED}));
    740     bool hasUnspecifiedBandMode = false;
    741     if (radioRsp_v1_2->rspInfo.error == RadioError::NONE) {
    742         for (const RadioBandMode& mode : radioRsp_v1_2->radioBandModes) {
    743             // Automatic mode selection must be supported
    744             if (mode == RadioBandMode::BAND_MODE_UNSPECIFIED) hasUnspecifiedBandMode = true;
    745         }
    746         ASSERT_TRUE(hasUnspecifiedBandMode);
    747     }
    748 }
    749