From c19d38e5ba764b05f7f2e2ab5fe7d366c64982a0 Mon Sep 17 00:00:00 2001 From: Kuba Kleczkowski Date: Thu, 24 Nov 2022 16:20:32 +0100 Subject: [PATCH] [MOS-816] Add parse and filter IMSI Added reading IMSI and parsing US MCC and MNC. MCC and MNC are filterd if they are TMobile US. --- .../service-cellular/CMakeLists.txt | 8 +- .../src/ServiceCellularPriv.cpp | 15 +- .../src/ServiceCellularPriv.hpp | 3 + .../src/volte/ImsiParserInterface.hpp | 19 +++ .../src/volte/ImsiParserUS.cpp | 37 +++++ .../src/volte/ImsiParserUS.hpp | 15 ++ .../src/volte/OperatorInfo.hpp | 22 +++ .../src/volte/VolteAllowedListInterface.hpp | 18 +++ .../src/volte/VolteAllowedUSList.cpp | 37 +++++ .../src/volte/VolteAllowedUSList.hpp | 16 ++ .../src/volte/VolteCapabilityHandler.cpp | 43 ++++++ .../src/volte/VolteCapabilityHandler.hpp | 43 ++++++ .../volte/VolteCapabilityHandlerCellular.cpp | 29 ++++ .../volte/VolteCapabilityHandlerCellular.hpp | 29 ++++ ...VolteCapabiltyHandlerCellularInterface.hpp | 25 +++ .../service-cellular/tests/CMakeLists.txt | 9 ++ .../tests/unittest_volteCapabilityHandler.cpp | 146 ++++++++++++++++++ 17 files changed, 510 insertions(+), 4 deletions(-) create mode 100644 module-services/service-cellular/src/volte/ImsiParserInterface.hpp create mode 100644 module-services/service-cellular/src/volte/ImsiParserUS.cpp create mode 100644 module-services/service-cellular/src/volte/ImsiParserUS.hpp create mode 100644 module-services/service-cellular/src/volte/OperatorInfo.hpp create mode 100644 module-services/service-cellular/src/volte/VolteAllowedListInterface.hpp create mode 100644 module-services/service-cellular/src/volte/VolteAllowedUSList.cpp create mode 100644 module-services/service-cellular/src/volte/VolteAllowedUSList.hpp create mode 100644 module-services/service-cellular/src/volte/VolteCapabilityHandler.cpp create mode 100644 module-services/service-cellular/src/volte/VolteCapabilityHandler.hpp create mode 100644 module-services/service-cellular/src/volte/VolteCapabilityHandlerCellular.cpp create mode 100644 module-services/service-cellular/src/volte/VolteCapabilityHandlerCellular.hpp create mode 100644 module-services/service-cellular/src/volte/VolteCapabiltyHandlerCellularInterface.hpp create mode 100644 module-services/service-cellular/tests/unittest_volteCapabilityHandler.cpp diff --git a/module-services/service-cellular/CMakeLists.txt b/module-services/service-cellular/CMakeLists.txt index a7a2eea970d1dc4dd164d7d4339762e3d7b09d05..fa93fb3568f0a233ce7ebf2c2c474b69a4b806d2 100644 --- a/module-services/service-cellular/CMakeLists.txt +++ b/module-services/service-cellular/CMakeLists.txt @@ -15,7 +15,13 @@ set(SOURCES src/URCCounter.cpp src/VolteHandlerImpl.cpp src/CSQHandler.cpp - DTMFCode.cpp + + src/volte/VolteCapabilityHandler.cpp + src/volte/ImsiParserUS.cpp + src/volte/VolteAllowedUSList.cpp + src/volte/VolteCapabilityHandlerCellular.cpp + + DTMFCode.cpp CellularServiceAPI.cpp CellularUrcHandler.cpp diff --git a/module-services/service-cellular/src/ServiceCellularPriv.cpp b/module-services/service-cellular/src/ServiceCellularPriv.cpp index 9b8143d705da670bd1079634588f777d43b05b08..6841f6e385111f3d91081c0257dc1743e86f5fb5 100644 --- a/module-services/service-cellular/src/ServiceCellularPriv.cpp +++ b/module-services/service-cellular/src/ServiceCellularPriv.cpp @@ -8,6 +8,10 @@ #include #include +#include +#include +#include + #include #include @@ -38,9 +42,14 @@ namespace cellular::internal imeiGetHandler{std::make_unique()}, tetheringHandler{std::make_unique()}, volteHandler{std::make_unique>()}, - modemResetHandler{std::make_unique()}, csqHandler{ - std::make_unique(), - } + modemResetHandler{std::make_unique()}, + csqHandler{ + std::make_unique(), + }, + volteCapability{ + std::make_unique(std::make_unique(), + std::make_unique(), + std::make_unique())} { initSimCard(); initSMSSendHandler(); diff --git a/module-services/service-cellular/src/ServiceCellularPriv.hpp b/module-services/service-cellular/src/ServiceCellularPriv.hpp index a4886ebd500fe9cdefa1eea3fcbb50f97f4d7a3f..53ac2a2d6a4c3eb962f21da5a7957e93604be69e 100644 --- a/module-services/service-cellular/src/ServiceCellularPriv.hpp +++ b/module-services/service-cellular/src/ServiceCellularPriv.hpp @@ -16,6 +16,7 @@ #include "VolteHandlerImpl.hpp" #include "ModemResetHandler.hpp" #include "CSQHandler.hpp" +#include "volte/VolteCapabilityHandler.hpp" namespace cellular::internal { @@ -26,6 +27,7 @@ namespace cellular::internal using service::SimContacts; using service::State; using service::TetheringHandler; + using service::VolteCapabilityHandler; using service::VolteHandler; class ServiceCellularPriv @@ -42,6 +44,7 @@ namespace cellular::internal std::unique_ptr> volteHandler; std::unique_ptr modemResetHandler; std::unique_ptr csqHandler; + std::unique_ptr volteCapability; State::PowerState nextPowerState = State::PowerState::Off; std::uint8_t multiPartSMSUID = 0; diff --git a/module-services/service-cellular/src/volte/ImsiParserInterface.hpp b/module-services/service-cellular/src/volte/ImsiParserInterface.hpp new file mode 100644 index 0000000000000000000000000000000000000000..9934faffef315c5374e502204fa45cdb0fa8b44c --- /dev/null +++ b/module-services/service-cellular/src/volte/ImsiParserInterface.hpp @@ -0,0 +1,19 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include "OperatorInfo.hpp" +#include +#include + +namespace cellular::service +{ + class ImsiParserInteface + { + public: + virtual ~ImsiParserInteface() = default; + + virtual auto parse(const std::string &imsi) -> std::optional = 0; + }; +} // namespace cellular::service diff --git a/module-services/service-cellular/src/volte/ImsiParserUS.cpp b/module-services/service-cellular/src/volte/ImsiParserUS.cpp new file mode 100644 index 0000000000000000000000000000000000000000..95c573deda0ce0710bb66667df369a176330de80 --- /dev/null +++ b/module-services/service-cellular/src/volte/ImsiParserUS.cpp @@ -0,0 +1,37 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "ImsiParserUS.hpp" +#include +#include +#include +#include + +namespace cellular::service +{ + constexpr auto usMccCount = 7; + const std::array usMcc{"310", "311", "312", "313", "314", "315", "316"}; + + auto ImsiParserUS::parse(const std::string &imsi) -> std::optional + { + constexpr auto mccSize = 3; + constexpr auto mncSize = 3; + + std::string mcc, mnc; + try { + mcc = imsi.substr(0, mccSize); + mnc = imsi.substr(mccSize, mncSize); + } + catch (const std::out_of_range &e) { + LOG_ERROR("IMSI parsing error: %s", e.what()); + return std::nullopt; + } + + if (std::find(std::begin(usMcc), std::end(usMcc), mcc) == std::end(usMcc)) { + LOG_ERROR("Not US MCC."); + return std::nullopt; + } + + return OperatorInfo(mcc, mnc); + } +} // namespace cellular::service diff --git a/module-services/service-cellular/src/volte/ImsiParserUS.hpp b/module-services/service-cellular/src/volte/ImsiParserUS.hpp new file mode 100644 index 0000000000000000000000000000000000000000..c394fe018fd6990baf593e9932fc9cbc8f0b6468 --- /dev/null +++ b/module-services/service-cellular/src/volte/ImsiParserUS.hpp @@ -0,0 +1,15 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include "ImsiParserInterface.hpp" + +namespace cellular::service +{ + class ImsiParserUS : public ImsiParserInteface + { + public: + auto parse(const std::string &imsi) -> std::optional final; + }; +} // namespace cellular::service diff --git a/module-services/service-cellular/src/volte/OperatorInfo.hpp b/module-services/service-cellular/src/volte/OperatorInfo.hpp new file mode 100644 index 0000000000000000000000000000000000000000..a5b32edee5abf5ce248e3e34c79966eff55929c8 --- /dev/null +++ b/module-services/service-cellular/src/volte/OperatorInfo.hpp @@ -0,0 +1,22 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include + +namespace cellular::service +{ + struct OperatorInfo + { + OperatorInfo(const std::string &mcc, const std::string &mnc) : MCC(mcc), MNC(mnc) + {} + std::string MCC; + std::string MNC; + + friend bool operator==(const OperatorInfo &lhs, const OperatorInfo &rhs) + { + return lhs.MCC == rhs.MCC && lhs.MNC == rhs.MNC; + } + }; +} // namespace cellular::service diff --git a/module-services/service-cellular/src/volte/VolteAllowedListInterface.hpp b/module-services/service-cellular/src/volte/VolteAllowedListInterface.hpp new file mode 100644 index 0000000000000000000000000000000000000000..3b16202062cffe9ffb6d78752c55baf38bae19c8 --- /dev/null +++ b/module-services/service-cellular/src/volte/VolteAllowedListInterface.hpp @@ -0,0 +1,18 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include "OperatorInfo.hpp" +#include + +namespace cellular::service +{ + class VolteAllowedListInterface + { + public: + virtual ~VolteAllowedListInterface() = default; + + auto virtual isVolteAllowed(const OperatorInfo &operatorInfo) -> bool = 0; + }; +} // namespace cellular::service diff --git a/module-services/service-cellular/src/volte/VolteAllowedUSList.cpp b/module-services/service-cellular/src/volte/VolteAllowedUSList.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e340aa1e8e58f493b5014155bb4201caa5eb6fbe --- /dev/null +++ b/module-services/service-cellular/src/volte/VolteAllowedUSList.cpp @@ -0,0 +1,37 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "VolteAllowedUSList.hpp" +#include +#include +#include + +namespace cellular::service +{ + + constexpr auto allowedOperatorsCount = 12; + const std::array allowedOperators{OperatorInfo{"310", "053"}, + OperatorInfo{"310", "120"}, + OperatorInfo{"310", "260"}, + OperatorInfo{"310", "530"}, + OperatorInfo{"310", "770"}, + OperatorInfo{"311", "490"}, + OperatorInfo{"311", "660"}, + OperatorInfo{"311", "880"}, + OperatorInfo{"311", "882"}, + OperatorInfo{"312", "190"}, + OperatorInfo{"312", "250"}, + OperatorInfo{"312", "530"}}; + + auto VolteAllowedUSList::isVolteAllowed(const OperatorInfo &operatorInfo) -> bool + { + LOG_INFO("Trying to find MCC: %s, MNC: %s", operatorInfo.MCC.c_str(), operatorInfo.MNC.c_str()); + + if (std::find(std::begin(allowedOperators), std::end(allowedOperators), operatorInfo) == + std::end(allowedOperators)) { + LOG_ERROR("Unable to find. VoLTE not allowed."); + return false; + } + return true; + } +} // namespace cellular::service diff --git a/module-services/service-cellular/src/volte/VolteAllowedUSList.hpp b/module-services/service-cellular/src/volte/VolteAllowedUSList.hpp new file mode 100644 index 0000000000000000000000000000000000000000..ebe1142d3b74ba6c6f61d3181c7ae5ab3c0cf2f3 --- /dev/null +++ b/module-services/service-cellular/src/volte/VolteAllowedUSList.hpp @@ -0,0 +1,16 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include "VolteAllowedListInterface.hpp" +#include "OperatorInfo.hpp" + +namespace cellular::service +{ + class VolteAllowedUSList : public VolteAllowedListInterface + { + public: + auto isVolteAllowed(const OperatorInfo &operatorInfo) -> bool final; + }; +} // namespace cellular::service diff --git a/module-services/service-cellular/src/volte/VolteCapabilityHandler.cpp b/module-services/service-cellular/src/volte/VolteCapabilityHandler.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d36160963215c83fe5a47aa7a59c5ed803073731 --- /dev/null +++ b/module-services/service-cellular/src/volte/VolteCapabilityHandler.cpp @@ -0,0 +1,43 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "VolteCapabilityHandler.hpp" +#include +#include +namespace cellular::service +{ + VolteCapabilityHandler::VolteCapabilityHandler(std::unique_ptr imsiParser, + std::unique_ptr allowedList, + std::unique_ptr cellularInterface) + : imsiParser(std::move(imsiParser)), allowedList(std::move(allowedList)), + cellularInterface(std::move(cellularInterface)) + {} + + void VolteCapabilityHandler::setChannel(at::BaseChannel *channel) + { + if (cellularInterface.get() != nullptr) { + cellularInterface->setChannel(channel); + } + } + + auto VolteCapabilityHandler::isVolteAllowed() -> bool + { + const auto imsi = cellularInterface->getImsi(); + if (not imsi.has_value()) { + LOG_ERROR("Failed to read IMSI, disable VoLTE."); + return false; + } + + const auto operatorInfo = imsiParser->parse(imsi.value()); + if (not operatorInfo.has_value()) { + LOG_ERROR("Failed to parse IMSI, disable VoLTE."); + return false; + } + return allowedList->isVolteAllowed(operatorInfo.value()); + } + + auto VolteCapabilityHandler::isCellularInterfaceReady() -> bool + { + return cellularInterface.get() != nullptr; + } +} // namespace cellular::service diff --git a/module-services/service-cellular/src/volte/VolteCapabilityHandler.hpp b/module-services/service-cellular/src/volte/VolteCapabilityHandler.hpp new file mode 100644 index 0000000000000000000000000000000000000000..f17a50dc3dc20a6a282f82f24624cf1b2d2a3477 --- /dev/null +++ b/module-services/service-cellular/src/volte/VolteCapabilityHandler.hpp @@ -0,0 +1,43 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include "VolteCapabiltyHandlerCellularInterface.hpp" +#include "ImsiParserInterface.hpp" +#include "VolteAllowedListInterface.hpp" + +#include +#include + +namespace at +{ + class Result; + class BaseChannel; +} // namespace at + +namespace cellular::service +{ + class VolteCapabilityHandler + { + public: + VolteCapabilityHandler(std::unique_ptr imsiParser, + std::unique_ptr allowedList, + std::unique_ptr cellularInterface); + /** Set AT command channel + * \param channel channel (or nullptr to block communication): + */ + void setChannel(at::BaseChannel *channel); + /** Check if it is a possibility to enable VoLTE on current operator + * @return true when VoLTE is allowed, false when not + */ + auto isVolteAllowed() -> bool; + + private: + std::unique_ptr imsiParser; + std::unique_ptr allowedList; + std::unique_ptr cellularInterface; + + auto isCellularInterfaceReady() -> bool; + }; +} // namespace cellular::service diff --git a/module-services/service-cellular/src/volte/VolteCapabilityHandlerCellular.cpp b/module-services/service-cellular/src/volte/VolteCapabilityHandlerCellular.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e342d31c8bfd68378a947d02b27fb2daeb627c7f --- /dev/null +++ b/module-services/service-cellular/src/volte/VolteCapabilityHandlerCellular.cpp @@ -0,0 +1,29 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "VolteCapabilityHandlerCellular.hpp" +#include + +namespace cellular::service +{ + void VolteCapabilityCellular::setChannel(at::BaseChannel *channel) + { + this->channel = channel; + } + + auto VolteCapabilityCellular::getImsi() -> std::optional + { + if (channel == nullptr) { + LOG_ERROR("No channel provided. Request ignored"); + return std::nullopt; + } + + auto result = channel->cmd(at::AT::CIMI); + if (not result) { + LOG_ERROR("Failed to read IMSI, disable VoLTE."); + return std::nullopt; + } + + return result.response[0]; + } +} // namespace cellular::service diff --git a/module-services/service-cellular/src/volte/VolteCapabilityHandlerCellular.hpp b/module-services/service-cellular/src/volte/VolteCapabilityHandlerCellular.hpp new file mode 100644 index 0000000000000000000000000000000000000000..c00a503da571b087b9584eae17aaf72b438dd64c --- /dev/null +++ b/module-services/service-cellular/src/volte/VolteCapabilityHandlerCellular.hpp @@ -0,0 +1,29 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include "VolteCapabiltyHandlerCellularInterface.hpp" + +#include +#include + +namespace at +{ + class Result; + class BaseChannel; +} // namespace at + +namespace cellular::service +{ + + class VolteCapabilityCellular : public VolteCapabilityCellularInterface + { + public: + void setChannel(at::BaseChannel *channel) final; + auto getImsi() -> std::optional final; + + private: + at::BaseChannel *channel = nullptr; + }; +} // namespace cellular::service diff --git a/module-services/service-cellular/src/volte/VolteCapabiltyHandlerCellularInterface.hpp b/module-services/service-cellular/src/volte/VolteCapabiltyHandlerCellularInterface.hpp new file mode 100644 index 0000000000000000000000000000000000000000..d8ff64084bec966b2c41a72332c0f0d00741b730 --- /dev/null +++ b/module-services/service-cellular/src/volte/VolteCapabiltyHandlerCellularInterface.hpp @@ -0,0 +1,25 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include +#include + +namespace at +{ + class Result; + class BaseChannel; +} // namespace at + +namespace cellular::service +{ + + class VolteCapabilityCellularInterface + { + public: + virtual ~VolteCapabilityCellularInterface() = default; + virtual void setChannel(at::BaseChannel *channel) = 0; + virtual auto getImsi() -> std::optional = 0; + }; +} // namespace cellular::service diff --git a/module-services/service-cellular/tests/CMakeLists.txt b/module-services/service-cellular/tests/CMakeLists.txt index 76d40e65acc65509e2d70ddb3e68b04140584c1f..25311454d017b4816240a47fb536b43493cd17f7 100644 --- a/module-services/service-cellular/tests/CMakeLists.txt +++ b/module-services/service-cellular/tests/CMakeLists.txt @@ -113,3 +113,12 @@ add_catch2_executable( module-cellular module-utils ) + +add_catch2_executable( + NAME + cellular-volte-capability-handler + SRCS + unittest_volteCapabilityHandler.cpp + LIBS + module-cellular +) diff --git a/module-services/service-cellular/tests/unittest_volteCapabilityHandler.cpp b/module-services/service-cellular/tests/unittest_volteCapabilityHandler.cpp new file mode 100644 index 0000000000000000000000000000000000000000..00f9bd6227a1d8400a9798e08536d8ada9cb6e03 --- /dev/null +++ b/module-services/service-cellular/tests/unittest_volteCapabilityHandler.cpp @@ -0,0 +1,146 @@ +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include + +#include +#include +#include +#include + +TEST_CASE("VoLTE Capability handler") +{ + SECTION("ImsiParserUS success - US IMSI") + { + using namespace cellular::service; + + cellular::service::ImsiParserUS parser; + std::string imsi("3111231234567890"); + + auto result = parser.parse(imsi); + + REQUIRE(result.has_value() == true); + REQUIRE(result.value().MCC == "311"); + REQUIRE(result.value().MNC == "123"); + } + + SECTION("ImsiParserUS failure - non US IMSI") + { + using namespace cellular::service; + + cellular::service::ImsiParserUS parser; + std::string imsi("2601231234567890"); + + auto result = parser.parse(imsi); + + REQUIRE(result.has_value() == false); + } + + SECTION("ImsiParserUS failure -too short IMSI") + { + using namespace cellular::service; + + cellular::service::ImsiParserUS parser; + std::string imsi("2601"); + + auto result = parser.parse(imsi); + + REQUIRE(result.has_value() == false); + } + + SECTION("VolteAllowedUSList success - TMobileUS IMSI") + { + using namespace cellular::service; + + VolteAllowedUSList list; + OperatorInfo operatorInfo{"310", "120"}; + + auto result = list.isVolteAllowed(operatorInfo); + + REQUIRE(result == true); + } + + SECTION("VolteAllowedUSList failure - non TMobileUS MCC") + { + using namespace cellular::service; + + VolteAllowedUSList list; + OperatorInfo operatorInfo{"210", "120"}; + + auto result = list.isVolteAllowed(operatorInfo); + + REQUIRE(result == false); + } + + SECTION("VolteAllowedUSList failure - non TMobileUS MNC") + { + using namespace cellular::service; + + VolteAllowedUSList list; + OperatorInfo operatorInfo{"310", "999"}; + + auto result = list.isVolteAllowed(operatorInfo); + + REQUIRE(result == false); + } + + class MockTMobileUS : public cellular::service::VolteCapabilityCellularInterface + { + void setChannel(at::BaseChannel *channel) + {} + auto getImsi() -> std::optional + { + return "310120123456789"; + } + }; + + SECTION("VolteCapabilityHandler succes = TMobileUS") + { + using namespace cellular::service; + VolteCapabilityHandler handler{std::make_unique(), + std::make_unique(), + std::make_unique()}; + auto result = handler.isVolteAllowed(); + REQUIRE(result == true); + } + + class MockNonTMobileUS : public cellular::service::VolteCapabilityCellularInterface + { + void setChannel(at::BaseChannel *channel) + {} + auto getImsi() -> std::optional + { + return "310999123456789"; + } + }; + + SECTION("VolteCapabilityHandler failure = non TMobileUS") + { + using namespace cellular::service; + VolteCapabilityHandler handler{std::make_unique(), + std::make_unique(), + std::make_unique()}; + auto result = handler.isVolteAllowed(); + REQUIRE(result == false); + } + + class MockFailedToGetImsi : public cellular::service::VolteCapabilityCellularInterface + { + void setChannel(at::BaseChannel *channel) + {} + auto getImsi() -> std::optional + { + return std::nullopt; + } + }; + + SECTION("VolteCapabilityHandler failure = failed to get imsi") + { + using namespace cellular::service; + VolteCapabilityHandler handler{std::make_unique(), + std::make_unique(), + std::make_unique()}; + auto result = handler.isVolteAllowed(); + REQUIRE(result == false); + } +}