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

Commit a1020f0d authored by Chienyuan Huang's avatar Chienyuan Huang
Browse files

Add VTS for Channel Sounding 

Bug: 312862898
Test: atest VtsHalBluetoothRangingTargetTest
Change-Id: I38e84dca07dd3c995875471b0bd0a823d5d7b325
parent 64930a63

bluetooth/ranging/OWNERS

0 → 100644
+5 −0
Original line number Diff line number Diff line 
# Bug component: 27441



include platform/packages/modules/Bluetooth:/OWNERS



chienyuanhuang@google.com

bluetooth/ranging/aidl/vts/Android.bp

0 → 100644
+27 −0
Original line number Diff line number Diff line 
package {

    default_applicable_licenses: ["hardware_interfaces_license"],

}



cc_test {

    name: "VtsHalBluetoothRangingTargetTest",

    defaults: [

        "use_libaidlvintf_gtest_helper_static",

    ],

    srcs: ["VtsHalBluetoothRangingTargetTest.cpp"],

    shared_libs: [

        "libbase",

        "libbinder_ndk",

        "libcutils",

        "liblog",

        "libutils",

    ],

    static_libs: [

        "android.hardware.bluetooth.ranging-V1-ndk",

        "libbluetooth-types",

    ],

    test_config: "VtsHalBluetoothRangingTargetTest.xml",

    test_suites: [

        "general-tests",

        "vts",

    ],

}

bluetooth/ranging/aidl/vts/VtsHalBluetoothRangingTargetTest.cpp

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

 * Copyright (C) 2023 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 <aidl/Gtest.h>

#include <aidl/Vintf.h>

#include <aidl/android/hardware/bluetooth/ranging/BnBluetoothChannelSoundingSessionCallback.h>

#include <aidl/android/hardware/bluetooth/ranging/IBluetoothChannelSounding.h>

#include <aidl/android/hardware/bluetooth/ranging/IBluetoothChannelSoundingSessionCallback.h>

#include <android-base/logging.h>

#include <android/binder_manager.h>

#include <android/binder_process.h>

#include <binder/IServiceManager.h>

#include <utils/Log.h>



using aidl::android::hardware::bluetooth::ranging::

    BluetoothChannelSoundingParameters;

using aidl::android::hardware::bluetooth::ranging::

    BnBluetoothChannelSoundingSessionCallback;

using aidl::android::hardware::bluetooth::ranging::ChannelSoudingRawData;

using aidl::android::hardware::bluetooth::ranging::CsSecurityLevel;

using aidl::android::hardware::bluetooth::ranging::IBluetoothChannelSounding;

using aidl::android::hardware::bluetooth::ranging::

    IBluetoothChannelSoundingSession;

using aidl::android::hardware::bluetooth::ranging::

    IBluetoothChannelSoundingSessionCallback;

using aidl::android::hardware::bluetooth::ranging::RangingResult;

using aidl::android::hardware::bluetooth::ranging::Reason;

using aidl::android::hardware::bluetooth::ranging::ResultType;

using aidl::android::hardware::bluetooth::ranging::SessionType;

using aidl::android::hardware::bluetooth::ranging::VendorSpecificData;

using ndk::ScopedAStatus;



class BluetoothChannelSoundingSessionCallback

    : public BnBluetoothChannelSoundingSessionCallback {

 public:

  ScopedAStatus onOpened(Reason reason) override;

  ScopedAStatus onOpenFailed(Reason reason) override;

  ScopedAStatus onResult(const RangingResult& in_result) override;

  ScopedAStatus onClose(Reason reason) override;

  ScopedAStatus onCloseFailed(Reason reason) override;

};



ScopedAStatus BluetoothChannelSoundingSessionCallback::onOpened(

    Reason /*reason*/) {

  return ::ndk::ScopedAStatus::ok();

}

ScopedAStatus BluetoothChannelSoundingSessionCallback::onOpenFailed(

    Reason /*reason*/) {

  return ::ndk::ScopedAStatus::ok();

}

ScopedAStatus BluetoothChannelSoundingSessionCallback::onResult(

    const RangingResult& /*in_result*/) {

  return ::ndk::ScopedAStatus::ok();

}

ScopedAStatus BluetoothChannelSoundingSessionCallback::onClose(

    Reason /*reason*/) {

  return ::ndk::ScopedAStatus::ok();

}

ScopedAStatus BluetoothChannelSoundingSessionCallback::onCloseFailed(

    Reason /*reason*/) {

  return ::ndk::ScopedAStatus::ok();

}



class BluetoothRangingTest : public ::testing::TestWithParam<std::string> {

 public:

  virtual void SetUp() override {

    ALOGI("SetUp Ranging Test");

    bluetooth_channel_sounding_ = IBluetoothChannelSounding::fromBinder(

        ndk::SpAIBinder(AServiceManager_waitForService(GetParam().c_str())));

    ASSERT_NE(bluetooth_channel_sounding_, nullptr);

  }



  virtual void TearDown() override {

    ALOGI("TearDown Ranging Test");

    bluetooth_channel_sounding_ = nullptr;

    ASSERT_EQ(bluetooth_channel_sounding_, nullptr);

  }



  ScopedAStatus getVendorSpecificData(

      std::optional<std::vector<std::optional<VendorSpecificData>>>*

          _aidl_return);

  ScopedAStatus getSupportedSessionTypes(

      std::optional<std::vector<SessionType>>* _aidl_return);

  ScopedAStatus getMaxSupportedCsSecurityLevel(CsSecurityLevel* _aidl_return);

  ScopedAStatus openSession(

      const BluetoothChannelSoundingParameters& in_params,

      const std::shared_ptr<IBluetoothChannelSoundingSessionCallback>&

          in_callback,

      std::shared_ptr<IBluetoothChannelSoundingSession>* _aidl_return);



  ScopedAStatus initBluetoothChannelSoundingSession(

      std::shared_ptr<IBluetoothChannelSoundingSession>* session) {

    BluetoothChannelSoundingParameters params;

    std::shared_ptr<BluetoothChannelSoundingSessionCallback> callback = nullptr;

    callback =

        ndk::SharedRefBase::make<BluetoothChannelSoundingSessionCallback>();

    ScopedAStatus status = openSession(params, callback, session);

    return status;

  }



 private:

  std::shared_ptr<IBluetoothChannelSounding> bluetooth_channel_sounding_;

};



ScopedAStatus BluetoothRangingTest::getVendorSpecificData(

    std::optional<std::vector<std::optional<VendorSpecificData>>>*

        _aidl_return) {

  return bluetooth_channel_sounding_->getVendorSpecificData(_aidl_return);

}

ScopedAStatus BluetoothRangingTest::getSupportedSessionTypes(

    std::optional<std::vector<SessionType>>* _aidl_return) {

  return bluetooth_channel_sounding_->getSupportedSessionTypes(_aidl_return);

}



ScopedAStatus BluetoothRangingTest::getMaxSupportedCsSecurityLevel(

    CsSecurityLevel* _aidl_return) {

  return bluetooth_channel_sounding_->getMaxSupportedCsSecurityLevel(

      _aidl_return);

}

ScopedAStatus BluetoothRangingTest::openSession(

    const BluetoothChannelSoundingParameters& in_params,

    const std::shared_ptr<IBluetoothChannelSoundingSessionCallback>&

        in_callback,

    std::shared_ptr<IBluetoothChannelSoundingSession>* _aidl_return) {

  return bluetooth_channel_sounding_->openSession(in_params, in_callback,

                                                  _aidl_return);

}



TEST_P(BluetoothRangingTest, SetupAndTearDown) {}



TEST_P(BluetoothRangingTest, GetVendorSpecificData) {

  std::optional<std::vector<std::optional<VendorSpecificData>>>

      vendor_specific_data;

  ScopedAStatus status = getVendorSpecificData(&vendor_specific_data);

  ASSERT_TRUE(status.isOk());

}



TEST_P(BluetoothRangingTest, GetSupportedSessionTypes) {

  std::optional<std::vector<SessionType>> supported_session_types;

  ScopedAStatus status = getSupportedSessionTypes(&supported_session_types);

  ASSERT_TRUE(status.isOk());

}



TEST_P(BluetoothRangingTest, GetMaxSupportedCsSecurityLevel) {

  CsSecurityLevel security_level;

  ScopedAStatus status = getMaxSupportedCsSecurityLevel(&security_level);

  ASSERT_TRUE(status.isOk());

}



TEST_P(BluetoothRangingTest, OpenSession) {

  BluetoothChannelSoundingParameters params;

  std::shared_ptr<BluetoothChannelSoundingSessionCallback> callback = nullptr;

  callback =

      ndk::SharedRefBase::make<BluetoothChannelSoundingSessionCallback>();

  std::shared_ptr<IBluetoothChannelSoundingSession> session;

  ScopedAStatus status = openSession(params, callback, &session);

  ASSERT_TRUE(status.isOk());

}



TEST_P(BluetoothRangingTest, GetVendorSpecificReplies) {

  std::shared_ptr<IBluetoothChannelSoundingSession> session;

  auto status = initBluetoothChannelSoundingSession(&session);

  ASSERT_TRUE(status.isOk());

  if (session != nullptr) {

    std::optional<std::vector<std::optional<VendorSpecificData>>>

        vendor_specific_data;

    status = session->getVendorSpecificReplies(&vendor_specific_data);

    ASSERT_TRUE(status.isOk());

  }

}



TEST_P(BluetoothRangingTest, GetSupportedResultTypes) {

  std::shared_ptr<IBluetoothChannelSoundingSession> session;

  auto status = initBluetoothChannelSoundingSession(&session);

  ASSERT_TRUE(status.isOk());

  if (session != nullptr) {

    std::vector<ResultType> supported_result_types;

    status = session->getSupportedResultTypes(&supported_result_types);

    ASSERT_TRUE(status.isOk());

  }

}



TEST_P(BluetoothRangingTest, IsAbortedProcedureRequired) {

  std::shared_ptr<IBluetoothChannelSoundingSession> session;

  auto status = initBluetoothChannelSoundingSession(&session);

  ASSERT_TRUE(status.isOk());

  if (session != nullptr) {

    bool is_abort_procedure_required = true;

    status = session->isAbortedProcedureRequired(&is_abort_procedure_required);

    ASSERT_TRUE(status.isOk());

  }

}



TEST_P(BluetoothRangingTest, WriteRawData) {

  std::shared_ptr<IBluetoothChannelSoundingSession> session;

  auto status = initBluetoothChannelSoundingSession(&session);

  ASSERT_TRUE(status.isOk());

  if (session != nullptr) {

    ChannelSoudingRawData raw_data;

    status = session->writeRawData(raw_data);

    ASSERT_TRUE(status.isOk());

  }

}



TEST_P(BluetoothRangingTest, CloseSession) {

  std::shared_ptr<IBluetoothChannelSoundingSession> session;

  auto status = initBluetoothChannelSoundingSession(&session);

  ASSERT_TRUE(status.isOk());

  if (session != nullptr) {

    status = session->close(Reason::LOCAL_STACK_REQUEST);

    ASSERT_TRUE(status.isOk());

  }

}



GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(BluetoothRangingTest);

INSTANTIATE_TEST_SUITE_P(PerInstance, BluetoothRangingTest,

                         testing::ValuesIn(android::getAidlHalInstanceNames(

                             IBluetoothChannelSounding::descriptor)),

                         android::PrintInstanceNameToString);



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

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

  ABinderProcess_startThreadPool();

  int status = RUN_ALL_TESTS();

  ALOGI("Test result = %d", status);

  return status;

}
 
 No newline at end of file

bluetooth/ranging/aidl/vts/VtsHalBluetoothRangingTargetTest.xml

0 → 100644
+33 −0
Original line number Diff line number Diff line 
<!--

  Copyright (C) 2023 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.

-->



<configuration description="Runs VtsHalBluetoothRangingTargetTest.">

    <option name="test-suite-tag" value="apct" />

    <option name="test-suite-tag" value="apct-native" />



    <target_preparer class="com.android.tradefed.targetprep.RootTargetPreparer">

    </target_preparer>



    <target_preparer class="com.android.tradefed.targetprep.PushFilePreparer">

        <option name="cleanup" value="true" />

        <option name="push" value="VtsHalBluetoothRangingTargetTest->/data/local/tmp/VtsHalBluetoothRangingTargetTest" />

    </target_preparer>



    <test class="com.android.tradefed.testtype.GTest" >

        <option name="native-test-device-path" value="/data/local/tmp" />

        <option name="module-name" value="VtsHalBluetoothRangingTargetTest" />

    </test>

</configuration>