Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 12978541 authored by Jordan Liu's avatar Jordan Liu
Browse files

Add radio config 1.2 VTS tests 

Bug: 122730535
Test: run vts -m VtsHalRadioConfigV1_2Target
Change-Id: Ib4fc17ea9f76caaf0cb0d4a2914595b7cfb7b041
parent 2adeb408

radio/config/1.2/vts/functional/Android.bp

0 → 100644
+35 −0
Original line number Diff line number Diff line 
//

// Copyright (C) 2019 The Android Open Source Project

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

//



cc_test {

    name: "VtsHalRadioConfigV1_2TargetTest",

    defaults: ["VtsHalTargetTestDefaults"],

    srcs: [

        "radio_config_hidl_hal_api.cpp",

        "radio_config_hidl_hal_test.cpp",

        "radio_config_response.cpp",

        "radio_config_indication.cpp",

        "VtsHalRadioConfigV1_2TargetTest.cpp",

    ],

    static_libs: [

        "RadioVtsTestUtilBase",

        "android.hardware.radio.config@1.0",

        "android.hardware.radio.config@1.1",

        "android.hardware.radio.config@1.2",

    ],

    header_libs: ["radio.util.header@1.0"],

    test_suites: ["general-tests"],

}

radio/config/1.2/vts/functional/VtsHalRadioConfigV1_2TargetTest.cpp

0 → 100644
+26 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <radio_config_hidl_hal_utils.h>



int main(int argc, char** argv) {

    ::testing::AddGlobalTestEnvironment(RadioConfigHidlEnvironment::Instance());

    ::testing::InitGoogleTest(&argc, argv);

    RadioConfigHidlEnvironment::Instance()->init(&argc, argv);

    int status = RUN_ALL_TESTS();

    LOG(INFO) << "Test result = " << status;

    return status;

}

radio/config/1.2/vts/functional/radio_config_hidl_hal_api.cpp

0 → 100644
+30 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <radio_config_hidl_hal_utils.h>



#define ASSERT_OK(ret) ASSERT_TRUE(ret.isOk())



/*

 * Test IRadioConfig.getSimSlotsStatus()

 */

TEST_F(RadioConfigHidlTest, getSimSlotsStatus) {

    const int serial = GetRandomSerialNumber();

    Return<void> res = radioConfig->getSimSlotsStatus(serial);

    ASSERT_OK(res);

    ALOGI("getIccSlotsStatus, rspInfo.error = %s\n",

          toString(radioConfigRsp->rspInfo.error).c_str());

}

radio/config/1.2/vts/functional/radio_config_hidl_hal_test.cpp

0 → 100644
+66 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <radio_config_hidl_hal_utils.h>



void RadioConfigHidlTest::SetUp() {

    radioConfig = ::testing::VtsHalHidlTargetTestBase::getService<IRadioConfig>(

            RadioConfigHidlEnvironment::Instance()->getServiceName<IRadioConfig>(

                    hidl_string(RADIO_SERVICE_NAME)));

    if (radioConfig == NULL) {

        sleep(60);

        radioConfig = ::testing::VtsHalHidlTargetTestBase::getService<IRadioConfig>(

                RadioConfigHidlEnvironment::Instance()->getServiceName<IRadioConfig>(

                        hidl_string(RADIO_SERVICE_NAME)));

    }

    ASSERT_NE(nullptr, radioConfig.get());



    radioConfigRsp = new (std::nothrow) RadioConfigResponse(*this);

    ASSERT_NE(nullptr, radioConfigRsp.get());



    count_ = 0;



    radioConfig->setResponseFunctions(radioConfigRsp, nullptr);

}



/*

 * Notify that the response message is received.

 */

void RadioConfigHidlTest::notify(int receivedSerial) {

    std::unique_lock<std::mutex> lock(mtx_);

    if (serial == receivedSerial) {

        count_++;

        cv_.notify_one();

    }

}



/*

 * Wait till the response message is notified or till TIMEOUT_PERIOD.

 */

std::cv_status RadioConfigHidlTest::wait() {

    std::unique_lock<std::mutex> lock(mtx_);



    std::cv_status status = std::cv_status::no_timeout;

    auto now = std::chrono::system_clock::now();

    while (count_ == 0) {

        status = cv_.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));

        if (status == std::cv_status::timeout) {

            return status;

        }

    }

    count_--;

    return status;

}

radio/config/1.2/vts/functional/radio_config_hidl_hal_utils.h

0 → 100644
+140 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <android-base/logging.h>



#include <VtsHalHidlTargetTestBase.h>

#include <VtsHalHidlTargetTestEnvBase.h>

#include <chrono>

#include <condition_variable>

#include <mutex>



#include <android/hardware/radio/config/1.1/IRadioConfig.h>

#include <android/hardware/radio/config/1.1/types.h>

#include <android/hardware/radio/config/1.2/IRadioConfigIndication.h>

#include <android/hardware/radio/config/1.2/IRadioConfigResponse.h>

#include <android/hardware/radio/config/1.2/types.h>



#include "vts_test_util.h"



using namespace ::android::hardware::radio::config::V1_2;



using ::android::sp;

using ::android::hardware::hidl_string;

using ::android::hardware::hidl_vec;

using ::android::hardware::Return;

using ::android::hardware::Void;

using ::android::hardware::radio::config::V1_1::IRadioConfig;

using ::android::hardware::radio::config::V1_1::ModemsConfig;

using ::android::hardware::radio::config::V1_1::PhoneCapability;

using ::android::hardware::radio::config::V1_2::SimSlotStatus;

using ::android::hardware::radio::V1_0::RadioResponseInfo;

using ::android::hardware::radio::V1_0::RadioResponseType;



#define TIMEOUT_PERIOD 75

#define RADIO_SERVICE_NAME "slot1"



class RadioConfigHidlTest;



/* Callback class for radio config response */

class RadioConfigResponse : public IRadioConfigResponse {

  protected:

    RadioConfigHidlTest& parent;



  public:

    RadioResponseInfo rspInfo;

    PhoneCapability phoneCap;



    RadioConfigResponse(RadioConfigHidlTest& parent);

    virtual ~RadioConfigResponse() = default;



    Return<void> getSimSlotsStatusResponse(

            const RadioResponseInfo& info,

            const ::android::hardware::hidl_vec<

                    ::android::hardware::radio::config::V1_0::SimSlotStatus>& slotStatus);



    Return<void> getSimSlotsStatusResponse_1_2(

            const RadioResponseInfo& info,

            const ::android::hardware::hidl_vec<SimSlotStatus>& slotStatus);



    Return<void> setSimSlotsMappingResponse(const RadioResponseInfo& info);



    Return<void> getPhoneCapabilityResponse(const RadioResponseInfo& info,

                                            const PhoneCapability& phoneCapability);



    Return<void> setPreferredDataModemResponse(const RadioResponseInfo& info);



    Return<void> getModemsConfigResponse(const RadioResponseInfo& info,

                                         const ModemsConfig& mConfig);



    Return<void> setModemsConfigResponse(const RadioResponseInfo& info);

};



/* Callback class for radio config indication */

class RadioConfigIndication : public IRadioConfigIndication {

  protected:

    RadioConfigHidlTest& parent;



  public:

    RadioConfigIndication(RadioConfigHidlTest& parent);

    virtual ~RadioConfigIndication() = default;



    Return<void> simSlotsStatusChanged_1_2(

            ::android::hardware::radio::V1_0::RadioIndicationType type,

            const ::android::hardware::hidl_vec<SimSlotStatus>& slotStatus);

};



// Test environment for Radio HIDL HAL.

class RadioConfigHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {

  public:

    // get the test environment singleton

    static RadioConfigHidlEnvironment* Instance() {

        static RadioConfigHidlEnvironment* instance = new RadioConfigHidlEnvironment;

        return instance;

    }

    virtual void registerTestServices() override { registerTestService<IRadioConfig>(); }



  private:

    RadioConfigHidlEnvironment() {}

};



// The main test class for Radio config HIDL.

class RadioConfigHidlTest : public ::testing::VtsHalHidlTargetTestBase {

  protected:

    std::mutex mtx_;

    std::condition_variable cv_;

    int count_;



  public:

    virtual void SetUp() override;



    /* Used as a mechanism to inform the test about data/event callback */

    void notify(int receivedSerial);



    /* Test code calls this function to wait for response */

    std::cv_status wait();



    void updateSimCardStatus();



    /* Serial number for radio request */

    int serial;



    /* radio config service handle */

    sp<IRadioConfig> radioConfig;



    /* radio config response handle */

    sp<RadioConfigResponse> radioConfigRsp;

};