From 036da68261170345c53c32ed8f59a30d42f1ceb8 Mon Sep 17 00:00:00 2001 From: Roshan Pius Date: Fri, 16 Dec 2016 11:10:01 -0800 Subject: [PATCH] supplicant(vts): More tests These tests just invoke the HIDL interface API's and ensure that they succeed or not. Some of these API's (especially P2P) need multi device testing (AP, Peer) to ensure that they work. Bug: 33457575 Test: adb shell /data/supplicant_hidl_test Change-Id: Ibf547b5ed95895c429c8bcb59e4c43b3b436338f --- .../vts/functional/supplicant_hidl_test.cpp | 153 +++++ .../functional/supplicant_hidl_test_utils.cpp | 4 +- .../supplicant_p2p_iface_hidl_test.cpp | 381 +++++++++++ .../supplicant_sta_iface_hidl_test.cpp | 368 ++++++++++ .../supplicant_sta_network_hidl_test.cpp | 628 ++++++++++++++++++ 5 files changed, 1532 insertions(+), 2 deletions(-) diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test.cpp index ab1b6a3e55..c6ac03ce64 100644 --- a/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test.cpp +++ b/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test.cpp @@ -18,8 +18,33 @@ #include +#include + #include "supplicant_hidl_test_utils.h" +using ::android::sp; +using ::android::hardware::hidl_vec; +using ::android::hardware::wifi::supplicant::V1_0::ISupplicant; +using ::android::hardware::wifi::supplicant::V1_0::ISupplicantIface; +using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatus; +using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatusCode; +using ::android::hardware::wifi::supplicant::V1_0::IfaceType; + +class SupplicantHidlTest : public ::testing::VtsHalHidlTargetTestBase { + public: + virtual void SetUp() override { + startSupplicantAndWaitForHidlService(); + supplicant_ = getSupplicant(); + ASSERT_NE(supplicant_.get(), nullptr); + } + + virtual void TearDown() override { stopSupplicant(); } + + protected: + // ISupplicant object used for all tests in this fixture. + sp supplicant_; +}; + /* * Create: * Ensures that an instance of the ISupplicant proxy object is @@ -30,3 +55,131 @@ TEST(SupplicantHidlTestNoFixture, Create) { EXPECT_NE(nullptr, getSupplicant().get()); stopSupplicant(); } + +/* + * ListInterfaces + */ +TEST_F(SupplicantHidlTest, ListInterfaces) { + std::vector ifaces; + supplicant_->listInterfaces( + [&](const SupplicantStatus& status, + const hidl_vec& hidl_ifaces) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + ifaces = hidl_ifaces; + }); + + EXPECT_NE(ifaces.end(), + std::find_if(ifaces.begin(), ifaces.end(), [](const auto& iface) { + return iface.type == IfaceType::STA; + })); + EXPECT_NE(ifaces.end(), + std::find_if(ifaces.begin(), ifaces.end(), [](const auto& iface) { + return iface.type == IfaceType::P2P; + })); +} + +/* + * GetInterface + */ +TEST_F(SupplicantHidlTest, GetInterface) { + std::vector ifaces; + supplicant_->listInterfaces( + [&](const SupplicantStatus& status, + const hidl_vec& hidl_ifaces) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + ifaces = hidl_ifaces; + }); + + ASSERT_NE(0u, ifaces.size()); + supplicant_->getInterface( + ifaces[0], + [&](const SupplicantStatus& status, const sp& iface) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_NE(nullptr, iface.get()); + }); +} + +/* + * SetDebugParams + */ +TEST_F(SupplicantHidlTest, SetDebugParams) { + bool show_timestamp = true; + bool show_keys = true; + ISupplicant::DebugLevel level = ISupplicant::DebugLevel::EXCESSIVE; + + supplicant_->setDebugParams(level, + show_timestamp, // show timestamps + show_keys, // show keys + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, + status.code); + }); +} + +/* + * GetDebugLevel + */ +TEST_F(SupplicantHidlTest, GetDebugLevel) { + bool show_timestamp = true; + bool show_keys = true; + ISupplicant::DebugLevel level = ISupplicant::DebugLevel::EXCESSIVE; + + supplicant_->setDebugParams(level, + show_timestamp, // show timestamps + show_keys, // show keys + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, + status.code); + }); + EXPECT_EQ(level, supplicant_->getDebugLevel()); +} + +/* + * IsDebugShowTimestampEnabled + */ +TEST_F(SupplicantHidlTest, IsDebugShowTimestampEnabled) { + bool show_timestamp = true; + bool show_keys = true; + ISupplicant::DebugLevel level = ISupplicant::DebugLevel::EXCESSIVE; + + supplicant_->setDebugParams(level, + show_timestamp, // show timestamps + show_keys, // show keys + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, + status.code); + }); + EXPECT_EQ(show_timestamp, supplicant_->isDebugShowTimestampEnabled()); +} + +/* + * IsDebugShowKeysEnabled + */ +TEST_F(SupplicantHidlTest, IsDebugShowKeysEnabled) { + bool show_timestamp = true; + bool show_keys = true; + ISupplicant::DebugLevel level = ISupplicant::DebugLevel::EXCESSIVE; + + supplicant_->setDebugParams(level, + show_timestamp, // show timestamps + show_keys, // show keys + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, + status.code); + }); + EXPECT_EQ(show_keys, supplicant_->isDebugShowKeysEnabled()); +} + +/* + * SetConcurrenyPriority + */ +TEST_F(SupplicantHidlTest, SetConcurrencyPriority) { + supplicant_->setConcurrencyPriority( + IfaceType::STA, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + supplicant_->setConcurrencyPriority( + IfaceType::P2P, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp index fdee0c6bff..1fcfc8c723 100644 --- a/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp +++ b/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp @@ -17,9 +17,9 @@ #include #include -#include #include #include +#include #include #include @@ -174,7 +174,7 @@ void startSupplicantAndWaitForHidlService() { } sp getSupplicant() { - return getService(kSupplicantServiceName); + return ::testing::VtsHalHidlTargetTestBase::getService(); } sp getSupplicantStaIface() { diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_p2p_iface_hidl_test.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_p2p_iface_hidl_test.cpp index 332b57bd04..c6cf01f8ab 100644 --- a/wifi/supplicant/1.0/vts/functional/supplicant_p2p_iface_hidl_test.cpp +++ b/wifi/supplicant/1.0/vts/functional/supplicant_p2p_iface_hidl_test.cpp @@ -18,8 +18,144 @@ #include +#include + #include "supplicant_hidl_test_utils.h" +using ::android::sp; +using ::android::hardware::hidl_array; +using ::android::hardware::hidl_string; +using ::android::hardware::hidl_vec; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::wifi::supplicant::V1_0::ISupplicantP2pIface; +using ::android::hardware::wifi::supplicant::V1_0::ISupplicantP2pIfaceCallback; +using ::android::hardware::wifi::supplicant::V1_0::SupplicantNetworkId; +using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatus; +using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatusCode; + +namespace { +constexpr uint8_t kTestSsidPostfix[] = {'t', 'e', 's', 't'}; +constexpr uint8_t kTestMacAddr[] = {0x56, 0x67, 0x67, 0xf4, 0x56, 0x92}; +constexpr uint8_t kTestPeerMacAddr[] = {0x56, 0x67, 0x55, 0xf4, 0x56, 0x92}; +constexpr char kTestConnectPin[] = "34556665"; +constexpr char kTestGroupIfName[] = "TestGroup"; +constexpr uint32_t kTestConnectGoIntent = 6; +constexpr uint32_t kTestFindTimeout = 5; +constexpr SupplicantNetworkId kTestNetworkId = 5; +constexpr uint32_t kTestChannel = 1; +constexpr uint32_t kTestOperatingClass = 81; +constexpr uint32_t kTestFreqRange[] = {2412, 2432}; +constexpr uint32_t kTestExtListenPeriod = 400; +constexpr uint32_t kTestExtListenInterval = 400; +} // namespace + +class SupplicantP2pIfaceHidlTest : public ::testing::VtsHalHidlTargetTestBase { + public: + virtual void SetUp() override { + startSupplicantAndWaitForHidlService(); + EXPECT_TRUE(turnOnExcessiveLogging()); + p2p_iface_ = getSupplicantP2pIface(); + ASSERT_NE(p2p_iface_.get(), nullptr); + + memcpy(mac_addr_.data(), kTestMacAddr, mac_addr_.size()); + memcpy(peer_mac_addr_.data(), kTestPeerMacAddr, peer_mac_addr_.size()); + } + + virtual void TearDown() override { stopSupplicant(); } + + protected: + // ISupplicantP2pIface object used for all tests in this fixture. + sp p2p_iface_; + // MAC address to use for various tests. + std::array mac_addr_; + std::array peer_mac_addr_; +}; + +class IfaceCallback : public ISupplicantP2pIfaceCallback { + Return onNetworkAdded(uint32_t /* id */) override { return Void(); } + Return onNetworkRemoved(uint32_t /* id */) override { return Void(); } + Return onDeviceFound( + const hidl_array& /* srcAddress */, + const hidl_array& /* p2pDeviceAddress */, + const hidl_array& /* primaryDeviceType */, + const hidl_string& /* deviceName */, uint16_t /* configMethods */, + uint8_t /* deviceCapabilities */, uint32_t /* groupCapabilities */, + const hidl_array& /* wfdDeviceInfo */) override { + return Void(); + } + Return onDeviceLost( + const hidl_array& /* p2pDeviceAddress */) override { + return Void(); + } + Return onFindStopped() override { return Void(); } + Return onGoNegotiationRequest( + const hidl_array& /* srcAddress */, + ISupplicantP2pIfaceCallback::WpsDevPasswordId /* passwordId */) + override { + return Void(); + } + Return onGoNegotiationCompleted( + ISupplicantP2pIfaceCallback::P2pStatusCode /* status */) override { + return Void(); + } + Return onGroupFormationSuccess() override { return Void(); } + Return onGroupFormationFailure( + const hidl_string& /* failureReason */) override { + return Void(); + } + Return onGroupStarted( + const hidl_string& /* groupIfname */, bool /* isGo */, + const hidl_vec& /* ssid */, uint32_t /* frequency */, + const hidl_array& /* psk */, + const hidl_string& /* passphrase */, + const hidl_array& /* goDeviceAddress */, + bool /* isPersistent */) override { + return Void(); + } + Return onGroupRemoved(const hidl_string& /* groupIfname */, + bool /* isGo */) override { + return Void(); + } + Return onInvitationReceived( + const hidl_array& /* srcAddress */, + const hidl_array& /* goDeviceAddress */, + const hidl_array& /* bssid */, + uint32_t /* persistentNetworkId */, + uint32_t /* operatingFrequency */) override { + return Void(); + } + Return onInvitationResult( + const hidl_array& /* bssid */, + ISupplicantP2pIfaceCallback::P2pStatusCode /* status */) override { + return Void(); + } + Return onProvisionDiscoveryCompleted( + const hidl_array& /* p2pDeviceAddress */, + bool /* isRequest */, + ISupplicantP2pIfaceCallback::P2pProvDiscStatusCode /* status */, + uint16_t /* configMethods */, + const hidl_string& /* generatedPin */) override { + return Void(); + } + Return onServiceDiscoveryResponse( + const hidl_array& /* srcAddress */, + uint16_t /* updateIndicator */, + const hidl_vec& /* tlvs */) override { + return Void(); + } + Return onStaAuthorized( + const hidl_array& /* srcAddress */, + const hidl_array& /* p2pDeviceAddress */) override { + return Void(); + } + Return onStaDeauthorized( + const hidl_array& /* srcAddress */, + const hidl_array& /* p2pDeviceAddress */) override { + return Void(); + } +}; + /* * Create: * Ensures that an instance of the ISupplicantP2pIface proxy object is @@ -30,3 +166,248 @@ TEST(SupplicantP2pIfaceHidlTestNoFixture, Create) { EXPECT_NE(nullptr, getSupplicantP2pIface().get()); stopSupplicant(); } + +/* + * RegisterCallback + */ +TEST_F(SupplicantP2pIfaceHidlTest, RegisterCallback) { + p2p_iface_->registerCallback( + new IfaceCallback(), [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * GetDeviceAddress + */ +TEST_F(SupplicantP2pIfaceHidlTest, GetDeviceAddress) { + p2p_iface_->getDeviceAddress( + [](const SupplicantStatus& status, + const hidl_array& /* mac_addr */) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * SetSsidPostfix + */ +TEST_F(SupplicantP2pIfaceHidlTest, SetSsidPostfix) { + std::vector ssid(kTestSsidPostfix, + kTestSsidPostfix + sizeof(kTestSsidPostfix)); + p2p_iface_->setSsidPostfix(ssid, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * Find + */ +TEST_F(SupplicantP2pIfaceHidlTest, Find) { + p2p_iface_->find(kTestFindTimeout, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * StopFind + */ +TEST_F(SupplicantP2pIfaceHidlTest, StopFind) { + p2p_iface_->find(kTestFindTimeout, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + p2p_iface_->stopFind([](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + p2p_iface_->stopFind([](const SupplicantStatus& status) { + EXPECT_NE(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * Flush + */ +TEST_F(SupplicantP2pIfaceHidlTest, Flush) { + p2p_iface_->flush([](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * Connect + */ +TEST_F(SupplicantP2pIfaceHidlTest, Connect) { + p2p_iface_->connect( + mac_addr_, ISupplicantP2pIface::WpsProvisionMethod::PBC, + kTestConnectPin, false, false, kTestConnectGoIntent, + [](const SupplicantStatus& status, const hidl_string& /* pin */) { + // This is not going to work with fake values. + EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code); + }); +} + +/* + * CancelConnect + */ +TEST_F(SupplicantP2pIfaceHidlTest, CancelConnect) { + p2p_iface_->connect( + mac_addr_, ISupplicantP2pIface::WpsProvisionMethod::PBC, + kTestConnectPin, false, false, kTestConnectGoIntent, + [](const SupplicantStatus& status, const hidl_string& /* pin */) { + // This is not going to work with fake values. + EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code); + }); + + p2p_iface_->cancelConnect([](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code); + }); +} + +/* + * ProvisionDiscovery + */ +TEST_F(SupplicantP2pIfaceHidlTest, ProvisionDiscovery) { + p2p_iface_->provisionDiscovery( + mac_addr_, ISupplicantP2pIface::WpsProvisionMethod::PBC, + [](const SupplicantStatus& status) { + // This is not going to work with fake values. + EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code); + }); +} + +/* + * AddGroup + */ +TEST_F(SupplicantP2pIfaceHidlTest, AddGroup) { + p2p_iface_->addGroup(false, kTestNetworkId, + [](const SupplicantStatus& /* status */) { + // TODO: Figure out the initialization sequence for + // this to work. + // EXPECT_EQ(SupplicantStatusCode::SUCCESS, + // status.code); + }); +} + +/* + * Reject + */ +TEST_F(SupplicantP2pIfaceHidlTest, Reject) { + p2p_iface_->reject(mac_addr_, [](const SupplicantStatus& status) { + // This is not going to work with fake values. + EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code); + }); +} + +/* + * Invite + */ +TEST_F(SupplicantP2pIfaceHidlTest, Invite) { + p2p_iface_->invite(kTestGroupIfName, mac_addr_, peer_mac_addr_, + [](const SupplicantStatus& status) { + // This is not going to work with fake values. + EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, + status.code); + }); +} + +/* + * Reinvoke + */ +TEST_F(SupplicantP2pIfaceHidlTest, Reinvoke) { + p2p_iface_->reinvoke( + kTestNetworkId, mac_addr_, [](const SupplicantStatus& status) { + // This is not going to work with fake values. + EXPECT_EQ(SupplicantStatusCode::FAILURE_NETWORK_UNKNOWN, + status.code); + }); +} + +/* + * ConfigureExtListen + */ +TEST_F(SupplicantP2pIfaceHidlTest, ConfigureExtListen) { + p2p_iface_->configureExtListen(kTestExtListenPeriod, kTestExtListenInterval, + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, + status.code); + }); +} + +/* + * SetListenChannel + */ +TEST_F(SupplicantP2pIfaceHidlTest, SetListenChannel) { + p2p_iface_->setListenChannel( + kTestChannel, kTestOperatingClass, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * SetDisallowedFrequencies + */ +TEST_F(SupplicantP2pIfaceHidlTest, SetDisallowedFrequencies) { + std::vector ranges = { + {kTestFreqRange[0], kTestFreqRange[1]}}; + p2p_iface_->setDisallowedFrequencies( + ranges, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * GetSsid + */ +TEST_F(SupplicantP2pIfaceHidlTest, GetSsid) { + std::array mac_addr; + memcpy(mac_addr.data(), kTestMacAddr, mac_addr.size()); + p2p_iface_->getSsid(mac_addr, [](const SupplicantStatus& status, + const hidl_vec& /* ssid */) { + // This is not going to work with fake values. + EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code); + }); +} + +/* + * GetGroupCapability + */ +TEST_F(SupplicantP2pIfaceHidlTest, GetGroupCapability) { + std::array mac_addr; + memcpy(mac_addr.data(), kTestMacAddr, mac_addr.size()); + p2p_iface_->getGroupCapability( + mac_addr, [](const SupplicantStatus& status, uint32_t /* caps */) { + // This is not going to work with fake values. + EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code); + }); +} + +/* + * FlushServices + */ +TEST_F(SupplicantP2pIfaceHidlTest, FlushServices) { + p2p_iface_->flushServices([](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * SetMiracastMode + */ +TEST_F(SupplicantP2pIfaceHidlTest, SetMiracastMode) { + p2p_iface_->setMiracastMode(ISupplicantP2pIface::MiracastMode::DISABLED, + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, + status.code); + }); + p2p_iface_->setMiracastMode(ISupplicantP2pIface::MiracastMode::SOURCE, + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, + status.code); + }); + p2p_iface_->setMiracastMode(ISupplicantP2pIface::MiracastMode::SINK, + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, + status.code); + }); +} diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp index c50539b0b7..c2a58b6009 100644 --- a/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp +++ b/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp @@ -18,8 +18,122 @@ #include +#include + #include "supplicant_hidl_test_utils.h" +using ::android::sp; +using ::android::hardware::hidl_array; +using ::android::hardware::hidl_string; +using ::android::hardware::hidl_vec; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::wifi::supplicant::V1_0::ISupplicantStaIface; +using ::android::hardware::wifi::supplicant::V1_0::ISupplicantStaIfaceCallback; +using ::android::hardware::wifi::supplicant::V1_0::ISupplicantStaNetwork; +using ::android::hardware::wifi::supplicant::V1_0::SupplicantNetworkId; +using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatus; +using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatusCode; + +namespace { +constexpr uint8_t kTestMacAddr[] = {0x56, 0x67, 0x67, 0xf4, 0x56, 0x92}; +constexpr ISupplicantStaIface::AnqpInfoId kTestAnqpInfoIds[] = { + ISupplicantStaIface::AnqpInfoId::VENUE_NAME, + ISupplicantStaIface::AnqpInfoId::NAI_REALM, + ISupplicantStaIface::AnqpInfoId::DOMAIN_NAME}; +constexpr ISupplicantStaIface::Hs20AnqpSubtypes kTestHs20Types[] = { + ISupplicantStaIface::Hs20AnqpSubtypes::WAN_METRICS, + ISupplicantStaIface::Hs20AnqpSubtypes::OPERATOR_FRIENDLY_NAME}; +constexpr char kTestHs20IconFile[] = "TestFile"; +constexpr int8_t kTestCountryCode[] = {'U', 'S'}; +} // namespace + +class SupplicantStaIfaceHidlTest : public ::testing::VtsHalHidlTargetTestBase { + public: + virtual void SetUp() override { + startSupplicantAndWaitForHidlService(); + EXPECT_TRUE(turnOnExcessiveLogging()); + sta_iface_ = getSupplicantStaIface(); + ASSERT_NE(sta_iface_.get(), nullptr); + + memcpy(mac_addr_.data(), kTestMacAddr, mac_addr_.size()); + } + + virtual void TearDown() override { stopSupplicant(); } + + protected: + // ISupplicantStaIface object used for all tests in this fixture. + sp sta_iface_; + // MAC address to use for various tests. + std::array mac_addr_; +}; + +class IfaceCallback : public ISupplicantStaIfaceCallback { + Return onNetworkAdded(uint32_t /* id */) override { return Void(); } + Return onNetworkRemoved(uint32_t /* id */) override { return Void(); } + Return onStateChanged( + ISupplicantStaIfaceCallback::State /* newState */, + const hidl_array& /*bssid */, uint32_t /* id */, + const hidl_vec& /* ssid */) override { + return Void(); + } + Return onAnqpQueryDone( + const hidl_array& /* bssid */, + const ISupplicantStaIfaceCallback::AnqpData& /* data */, + const ISupplicantStaIfaceCallback::Hs20AnqpData& /* hs20Data */) + override { + return Void(); + } + virtual Return onHs20IconQueryDone( + const hidl_array& /* bssid */, + const hidl_string& /* fileName */, + const hidl_vec& /* data */) override { + return Void(); + } + virtual Return onHs20SubscriptionRemediation( + const hidl_array& /* bssid */, + ISupplicantStaIfaceCallback::OsuMethod /* osuMethod */, + const hidl_string& /* url*/) override { + return Void(); + } + Return onHs20DeauthImminentNotice( + const hidl_array& /* bssid */, uint32_t /* reasonCode */, + uint32_t /* reAuthDelayInSec */, + const hidl_string& /* url */) override { + return Void(); + } + Return onDisconnected(const hidl_array& /* bssid */, + bool /* locallyGenerated */, + uint32_t /* reasonCode */) override { + return Void(); + } + Return onAssociationRejected( + const hidl_array& /* bssid */, uint32_t /* statusCode */, + bool /*timedOut */) override { + return Void(); + } + Return onAuthenticationTimeout( + const hidl_array& /* bssid */) override { + return Void(); + } + Return onEapFailure() override { return Void(); } + Return onWpsEventSuccess() override { return Void(); } + Return onWpsEventFail( + const hidl_array& /* bssid */, + ISupplicantStaIfaceCallback::WpsConfigError /* configError */, + ISupplicantStaIfaceCallback::WpsErrorIndication /* errorInd */) + override { + return Void(); + } + Return onWpsEventPbcOverlap() override { return Void(); } + Return onExtRadioWorkStart(uint32_t /* id */) override { + return Void(); + } + Return onExtRadioWorkTimeout(uint32_t /* id*/) override { + return Void(); + } +}; + /* * Create: * Ensures that an instance of the ISupplicantStaIface proxy object is @@ -30,3 +144,257 @@ TEST(SupplicantStaIfaceHidlTestNoFixture, Create) { EXPECT_NE(nullptr, getSupplicantStaIface().get()); stopSupplicant(); } + +/* + * RegisterCallback + */ +TEST_F(SupplicantStaIfaceHidlTest, RegisterCallback) { + sta_iface_->registerCallback( + new IfaceCallback(), [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * listNetworks. + */ +TEST_F(SupplicantStaIfaceHidlTest, listNetworks) { + sta_iface_->listNetworks([](const SupplicantStatus& status, + const hidl_vec& ids) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(0u, ids.size()); + }); + + sp sta_network = createSupplicantStaNetwork(); + EXPECT_NE(nullptr, sta_network.get()); + + sta_iface_->listNetworks([](const SupplicantStatus& status, + const hidl_vec& ids) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_LT(0u, ids.size()); + }); +} + +/* + * Reassociate. + */ +TEST_F(SupplicantStaIfaceHidlTest, Reassociate) { + sta_iface_->reassociate([](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * Reconnect. + */ +TEST_F(SupplicantStaIfaceHidlTest, Reconnect) { + sta_iface_->reconnect([](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::FAILURE_IFACE_NOT_DISCONNECTED, + status.code); + }); +} + +/* + * Disconnect. + */ +TEST_F(SupplicantStaIfaceHidlTest, Disconnect) { + sta_iface_->disconnect([](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * SetPowerSave. + */ +TEST_F(SupplicantStaIfaceHidlTest, SetPowerSave) { + sta_iface_->setPowerSave(true, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_iface_->setPowerSave(false, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * InitiateTdlsDiscover. + */ +TEST_F(SupplicantStaIfaceHidlTest, InitiateTdlsDiscover) { + sta_iface_->initiateTdlsDiscover( + mac_addr_, [](const SupplicantStatus& status) { + // These requests will fail unless the MAC address mentioned is + // actually around. + EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code); + }); +} + +/* + * InitiateTdlsSetup. + */ +TEST_F(SupplicantStaIfaceHidlTest, InitiateTdlsSetup) { + sta_iface_->initiateTdlsSetup( + mac_addr_, [](const SupplicantStatus& status) { + // These requests will fail unless the MAC address mentioned is + // actually around. + EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code); + }); +} + +/* + * InitiateTdlsTeardown. + */ +TEST_F(SupplicantStaIfaceHidlTest, InitiateTdlsTeardown) { + sta_iface_->initiateTdlsTeardown( + mac_addr_, [](const SupplicantStatus& status) { + // These requests will fail unless the MAC address mentioned is + // actually around. + EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code); + }); +} + +/* + * InitiateAnqpQuery. + */ +TEST_F(SupplicantStaIfaceHidlTest, InitiateAnqpQuery) { + std::vector anqp_ids( + kTestAnqpInfoIds, kTestAnqpInfoIds + sizeof(kTestAnqpInfoIds)); + std::vector hs_types( + kTestHs20Types, kTestHs20Types + sizeof(kTestHs20Types)); + sta_iface_->initiateAnqpQuery( + mac_addr_, anqp_ids, hs_types, [](const SupplicantStatus& status) { + // These requests will fail unless the BSSID mentioned is actually + // present in scan results. + EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code); + }); +} + +/* + * InitiateHs20IconQuery. + */ +TEST_F(SupplicantStaIfaceHidlTest, InitiateHs20IconQuery) { + sta_iface_->initiateHs20IconQuery( + mac_addr_, kTestHs20IconFile, [](const SupplicantStatus& status) { + // These requests will fail unless the BSSID mentioned is actually + // present in scan results. + EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code); + }); +} + +/* + * GetMacAddress. + */ +TEST_F(SupplicantStaIfaceHidlTest, GetMacAddress) { + sta_iface_->getMacAddress([](const SupplicantStatus& status, + const hidl_array& mac_addr) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + std::array std_mac_addr(mac_addr); + EXPECT_GT(6, std::count(std_mac_addr.begin(), std_mac_addr.end(), 0)); + }); +} + +/* + * StartRxFilter. + */ +TEST_F(SupplicantStaIfaceHidlTest, StartRxFilter) { + sta_iface_->startRxFilter([](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * StopRxFilter. + */ +TEST_F(SupplicantStaIfaceHidlTest, StopRxFilter) { + sta_iface_->stopRxFilter([](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * AddRxFilter. + */ +TEST_F(SupplicantStaIfaceHidlTest, AddRxFilter) { + sta_iface_->addRxFilter(ISupplicantStaIface::RxFilterType::V4_MULTICAST, + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, + status.code); + }); + sta_iface_->addRxFilter(ISupplicantStaIface::RxFilterType::V6_MULTICAST, + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, + status.code); + }); +} + +/* + * RemoveRxFilter. + */ +TEST_F(SupplicantStaIfaceHidlTest, RemoveRxFilter) { + sta_iface_->removeRxFilter(ISupplicantStaIface::RxFilterType::V4_MULTICAST, + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, + status.code); + }); + sta_iface_->removeRxFilter(ISupplicantStaIface::RxFilterType::V6_MULTICAST, + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, + status.code); + }); +} + +/* + * SetBtCoexistenceMode. + */ +TEST_F(SupplicantStaIfaceHidlTest, SetBtCoexistenceMode) { + sta_iface_->setBtCoexistenceMode( + ISupplicantStaIface::BtCoexistenceMode::ENABLED, + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_iface_->setBtCoexistenceMode( + ISupplicantStaIface::BtCoexistenceMode::DISABLED, + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_iface_->setBtCoexistenceMode( + ISupplicantStaIface::BtCoexistenceMode::SENSE, + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * SetBtCoexistenceScanModeEnabled. + */ +TEST_F(SupplicantStaIfaceHidlTest, SetBtCoexistenceScanModeEnabled) { + sta_iface_->setBtCoexistenceScanModeEnabled( + true, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_iface_->setBtCoexistenceScanModeEnabled( + false, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * SetSuspendModeEnabled. + */ +TEST_F(SupplicantStaIfaceHidlTest, SetSuspendModeEnabled) { + sta_iface_->setSuspendModeEnabled(true, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_iface_->setSuspendModeEnabled( + false, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * SetCountryCode. + */ +TEST_F(SupplicantStaIfaceHidlTest, SetCountryCode) { + sta_iface_->setCountryCode( + kTestCountryCode, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_sta_network_hidl_test.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_sta_network_hidl_test.cpp index cde75faed0..aa84e9ac84 100644 --- a/wifi/supplicant/1.0/vts/functional/supplicant_sta_network_hidl_test.cpp +++ b/wifi/supplicant/1.0/vts/functional/supplicant_sta_network_hidl_test.cpp @@ -18,8 +18,104 @@ #include +#include + +#include + #include "supplicant_hidl_test_utils.h" +using ::android::sp; +using ::android::hardware::hidl_array; +using ::android::hardware::hidl_string; +using ::android::hardware::hidl_vec; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::wifi::supplicant::V1_0::ISupplicantStaIface; +using ::android::hardware::wifi::supplicant::V1_0::ISupplicantStaNetwork; +using ::android::hardware::wifi::supplicant::V1_0:: + ISupplicantStaNetworkCallback; +using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatus; +using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatusCode; + +namespace { +constexpr char kTestSsidStr[] = "TestSsid1234"; +constexpr char kTestPsk[] = "TestPsk123"; +constexpr char kTestIdStr[] = "TestIdstr"; +constexpr char kTestEapPasswdStr[] = "TestEapPasswd1234"; +constexpr char kTestEapCert[] = "keystore://CERT"; +constexpr char kTestEapPrivateKeyId[] = "key_id"; +constexpr char kTestEapMatch[] = "match"; +constexpr char kTestEapEngineID[] = "engine_id"; +constexpr uint8_t kTestBssid[] = {0x56, 0x67, 0x67, 0xf4, 0x56, 0x92}; +constexpr uint8_t kTestWepKey[] = {0x56, 0x67, 0x67, 0xf4, 0x56}; +constexpr uint8_t kTestKc[] = {0x56, 0x67, 0x67, 0xf4, 0x76, 0x87, 0x98, 0x12}; +constexpr uint8_t kTestSres[] = {0x56, 0x67, 0x67, 0xf4}; +constexpr uint8_t kTestRes[] = {0x56, 0x67, 0x67, 0xf4, 0x67}; +constexpr uint8_t kTestIk[] = {[0 ... 15] = 0x65}; +constexpr uint8_t kTestCk[] = {[0 ... 15] = 0x45}; +constexpr uint8_t kTestIdentity[] = {0x45, 0x67, 0x98, 0x67, 0x56}; +constexpr uint32_t kTestWepTxKeyIdx = 2; +constexpr uint32_t kTestKeyMgmt = (ISupplicantStaNetwork::KeyMgmtMask::WPA_PSK | + ISupplicantStaNetwork::KeyMgmtMask::WPA_EAP); +constexpr uint32_t kTestProto = (ISupplicantStaNetwork::ProtoMask::OSEN | + ISupplicantStaNetwork::ProtoMask::RSN); +constexpr uint32_t kTestAuthAlg = (ISupplicantStaNetwork::AuthAlgMask::OPEN | + ISupplicantStaNetwork::AuthAlgMask::SHARED); +constexpr uint32_t kTestGroupCipher = + (ISupplicantStaNetwork::GroupCipherMask::CCMP | + ISupplicantStaNetwork::GroupCipherMask::WEP104); +constexpr uint32_t kTestPairwiseCipher = + (ISupplicantStaNetwork::PairwiseCipherMask::CCMP | + ISupplicantStaNetwork::PairwiseCipherMask::TKIP); +} // namespace + +class SupplicantStaNetworkHidlTest : public ::testing::VtsHalHidlTargetTestBase { + public: + virtual void SetUp() override { + startSupplicantAndWaitForHidlService(); + EXPECT_TRUE(turnOnExcessiveLogging()); + sta_network_ = createSupplicantStaNetwork(); + ASSERT_NE(sta_network_.get(), nullptr); + + ssid_.assign(kTestSsidStr, kTestSsidStr + strlen(kTestSsidStr)); + } + + virtual void TearDown() override { stopSupplicant(); } + + protected: + void removeNetwork() { + sp sta_iface = getSupplicantStaIface(); + ASSERT_NE(nullptr, sta_iface.get()); + uint32_t net_id; + sta_network_->getId([&](const SupplicantStatus& status, int network_id) { + ASSERT_EQ(SupplicantStatusCode::SUCCESS, status.code); + net_id = network_id; + }); + sta_iface->removeNetwork(net_id, [](const SupplicantStatus& status) { + ASSERT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + } + + // ISupplicantStaNetwork object used for all tests in this fixture. + sp sta_network_; + // SSID to use for various tests. + std::vector ssid_; +}; + +class NetworkCallback : public ISupplicantStaNetworkCallback { + Return onNetworkEapSimGsmAuthRequest( + const ISupplicantStaNetworkCallback::NetworkRequestEapSimGsmAuthParams& + /* params */) override { + return Void(); + } + Return onNetworkEapSimUmtsAuthRequest( + const ISupplicantStaNetworkCallback::NetworkRequestEapSimUmtsAuthParams& + /* params */) override { + return Void(); + } + Return onNetworkEapIdentityRequest() override { return Void(); } +}; + /* * Create: * Ensures that an instance of the ISupplicantStaNetwork proxy object is @@ -30,3 +126,535 @@ TEST(SupplicantStaNetworkHidlTestNoFixture, Create) { EXPECT_NE(nullptr, createSupplicantStaNetwork().get()); stopSupplicant(); } + +/* + * RegisterCallback + */ +TEST_F(SupplicantStaNetworkHidlTest, RegisterCallback) { + sta_network_->registerCallback( + new NetworkCallback(), [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* Tests out the various setter/getter methods. */ +/* + * SetGetSsid + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetSsid) { + sta_network_->setSsid(ssid_, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getSsid( + [&](const SupplicantStatus& status, const hidl_vec& get_ssid) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(ssid_, std::vector(get_ssid)); + }); +} + +/* + * SetGetBssid + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetBssid) { + std::array set_bssid; + memcpy(set_bssid.data(), kTestBssid, set_bssid.size()); + sta_network_->setBssid(set_bssid, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getBssid([&](const SupplicantStatus& status, + const hidl_array& get_bssid_hidl) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + std::array get_bssid; + memcpy(get_bssid.data(), get_bssid_hidl.data(), get_bssid.size()); + EXPECT_EQ(set_bssid, get_bssid); + }); +} + +/* + * SetGetKeyMgmt + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetKeyMgmt) { + sta_network_->setKeyMgmt(kTestKeyMgmt, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getKeyMgmt( + [&](const SupplicantStatus& status, uint32_t key_mgmt) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(key_mgmt, kTestKeyMgmt); + }); +} + +/* + * SetGetProto + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetProto) { + sta_network_->setProto(kTestProto, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getProto([&](const SupplicantStatus& status, uint32_t proto) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(proto, kTestProto); + }); +} + +/* + * SetGetKeyAuthAlg + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetAuthAlg) { + sta_network_->setAuthAlg(kTestAuthAlg, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getAuthAlg( + [&](const SupplicantStatus& status, uint32_t auth_alg) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(auth_alg, kTestAuthAlg); + }); +} + +/* + * SetGetGroupCipher + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetGroupCipher) { + sta_network_->setGroupCipher( + kTestGroupCipher, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getGroupCipher( + [&](const SupplicantStatus& status, uint32_t group_cipher) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(group_cipher, kTestGroupCipher); + }); +} + +/* + * SetGetPairwiseCipher + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetPairwiseCipher) { + sta_network_->setPairwiseCipher( + kTestPairwiseCipher, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getPairwiseCipher( + [&](const SupplicantStatus& status, uint32_t pairwise_cipher) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(pairwise_cipher, kTestPairwiseCipher); + }); +} + +/* + * SetGetPskPassphrase + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetPskPassphrase) { + sta_network_->setPskPassphrase( + kTestPsk, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getPskPassphrase( + [&](const SupplicantStatus& status, const hidl_string& psk) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(kTestPsk, std::string(psk.c_str())); + }); +} + +/* + * SetGetWepKeys + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetWepTxKeyIdx) { + sta_network_->setWepTxKeyIdx( + kTestWepTxKeyIdx, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getWepTxKeyIdx( + [&](const SupplicantStatus& status, uint32_t key_idx) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(kTestWepTxKeyIdx, key_idx); + }); +} + +/* + * SetGetWepKeys + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetWepKeys) { + for (uint32_t i = 0; + i < static_cast( + ISupplicantStaNetwork::ParamSizeLimits::WEP_KEYS_MAX_NUM); + i++) { + std::vector set_wep_key(std::begin(kTestWepKey), + std::end(kTestWepKey)); + sta_network_->setWepKey( + i, set_wep_key, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getWepKey(i, [&](const SupplicantStatus& status, + const hidl_vec& get_wep_key) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(set_wep_key, std::vector(get_wep_key)); + }); + } +} + +/* + * SetGetScanSsid + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetScanSsid) { + sta_network_->setScanSsid( + true, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getScanSsid( + [&](const SupplicantStatus& status, bool scan_ssid) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(true, scan_ssid); + }); +} + +/* + * SetGetRequirePmf + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetRequirePmf) { + sta_network_->setRequirePmf( + true, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getRequirePmf( + [&](const SupplicantStatus& status, bool require_pmf) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(true, require_pmf); + }); +} + +/* + * SetGetIdStr + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetIdStr) { + sta_network_->setIdStr( + kTestIdStr, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getIdStr( + [&](const SupplicantStatus& status, const hidl_string& id_str) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(kTestIdStr, std::string(id_str.c_str())); + }); +} + + +/* + * SetGetEapMethod + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetEapMethod) { + ISupplicantStaNetwork::EapMethod set_eap_method = + ISupplicantStaNetwork::EapMethod::PEAP; + sta_network_->setEapMethod( + set_eap_method, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getEapMethod( + [&](const SupplicantStatus& status, + ISupplicantStaNetwork::EapMethod eap_method) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(set_eap_method, eap_method); + }); +} + +/* + * SetGetEapPhase2Method + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetEapPhase2Method) { + ISupplicantStaNetwork::EapPhase2Method set_eap_phase2_method = + ISupplicantStaNetwork::EapPhase2Method::NONE; + sta_network_->setEapPhase2Method( + set_eap_phase2_method, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getEapPhase2Method( + [&](const SupplicantStatus& status, + ISupplicantStaNetwork::EapPhase2Method eap_phase2_method) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(set_eap_phase2_method, eap_phase2_method); + }); +} + +/* + * SetGetEapIdentity + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetEapIdentity) { + std::vector set_identity(kTestIdentity, kTestIdentity + sizeof(kTestIdentity)); + sta_network_->setEapIdentity( + set_identity, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getEapIdentity( + [&](const SupplicantStatus& status, const std::vector& identity) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(set_identity, identity); + }); +} + +/* + * SetGetEapAnonymousIdentity + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetEapAnonymousIdentity) { + std::vector set_identity(kTestIdentity, kTestIdentity + sizeof(kTestIdentity)); + sta_network_->setEapAnonymousIdentity( + set_identity, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getEapAnonymousIdentity( + [&](const SupplicantStatus& status, const std::vector& identity) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(set_identity, identity); + }); +} + +/* + * SetGetEapPassword + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetEapPassword) { + std::vector set_eap_passwd( + kTestEapPasswdStr, kTestEapPasswdStr + strlen(kTestEapPasswdStr)); + sta_network_->setEapPassword( + set_eap_passwd, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getEapPassword([&](const SupplicantStatus& status, + const hidl_vec& eap_passwd) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(set_eap_passwd, std::vector(eap_passwd)); + }); +} + +/* + * SetGetEapCACert + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetEapCACert) { + sta_network_->setEapCACert( + kTestEapCert, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getEapCACert([&](const SupplicantStatus& status, + const hidl_string& eap_cert) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(kTestEapCert, std::string(eap_cert.c_str())); + }); +} + +/* + * SetGetEapCAPath + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetEapCAPath) { + sta_network_->setEapCAPath( + kTestEapCert, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getEapCAPath([&](const SupplicantStatus& status, + const hidl_string& eap_cert) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(kTestEapCert, std::string(eap_cert.c_str())); + }); +} + +/* + * SetGetEapClientCert + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetEapClientCert) { + sta_network_->setEapClientCert( + kTestEapCert, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getEapClientCert([&](const SupplicantStatus& status, + const hidl_string& eap_cert) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(kTestEapCert, std::string(eap_cert.c_str())); + }); +} + +/* + * SetGetEapPrivateKeyId + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetEapPrivateKeyId) { + sta_network_->setEapPrivateKeyId( + kTestEapPrivateKeyId, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getEapPrivateKeyId([&](const SupplicantStatus& status, + const hidl_string& key_id) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(kTestEapPrivateKeyId, std::string(key_id.c_str())); + }); +} + +/* + * SetGetEapAltSubjectMatch + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetEapAltSubjectMatch) { + sta_network_->setEapAltSubjectMatch( + kTestEapMatch, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getEapAltSubjectMatch([&](const SupplicantStatus& status, + const hidl_string& match) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(kTestEapMatch, std::string(match.c_str())); + }); +} + +/* + * SetGetEapDomainSuffixMatch + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetEapDomainSuffixMatch) { + sta_network_->setEapDomainSuffixMatch( + kTestEapMatch, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getEapDomainSuffixMatch([&](const SupplicantStatus& status, + const hidl_string& match) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(kTestEapMatch, std::string(match.c_str())); + }); +} + +/* + * SetGetEapEngine + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetEapEngine) { + sta_network_->setEapEngine( + true, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getEapEngine([&](const SupplicantStatus& status, + bool enable) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(true, enable); + }); +} + +/* + * SetGetEapEngineID + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetEapEngineID) { + sta_network_->setEapEngineID( + kTestEapEngineID, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->getEapEngineID([&](const SupplicantStatus& status, + const hidl_string& id) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(kTestEapEngineID, std::string(id.c_str())); + }); +} + +/* + * Enable + */ +TEST_F(SupplicantStaNetworkHidlTest, Enable) { + // wpa_supplicant doesn't perform any connection initiation + // unless atleast the Ssid and Ket mgmt params are set. + sta_network_->setSsid(ssid_, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->setKeyMgmt(kTestKeyMgmt, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + sta_network_->enable(false, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->enable(true, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + // Now remove the network and ensure that the calls fail. + removeNetwork(); + sta_network_->enable(true, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::FAILURE_NETWORK_INVALID, status.code); + }); +} + +/* + * Disable + */ +TEST_F(SupplicantStaNetworkHidlTest, Disable) { + // wpa_supplicant doesn't perform any connection initiation + // unless atleast the Ssid and Ket mgmt params are set. + sta_network_->setSsid(ssid_, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->setKeyMgmt(kTestKeyMgmt, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + sta_network_->disable([](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + // Now remove the network and ensure that the calls fail. + removeNetwork(); + sta_network_->disable([](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::FAILURE_NETWORK_INVALID, status.code); + }); +} + +/* + * Select. + */ +TEST_F(SupplicantStaNetworkHidlTest, Select) { + // wpa_supplicant doesn't perform any connection initiation + // unless atleast the Ssid and Ket mgmt params are set. + sta_network_->setSsid(ssid_, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + sta_network_->setKeyMgmt(kTestKeyMgmt, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + sta_network_->select([](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + // Now remove the network and ensure that the calls fail. + removeNetwork(); + sta_network_->select([](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::FAILURE_NETWORK_INVALID, status.code); + }); +} + +/* + * SendNetworkEapSimGsmAuthResponse + */ +TEST_F(SupplicantStaNetworkHidlTest, SendNetworkEapSimGsmAuthResponse) { + std::vector + params; + ISupplicantStaNetwork::NetworkResponseEapSimGsmAuthParams param; + memcpy(param.kc.data(), kTestKc, param.kc.size()); + memcpy(param.sres.data(), kTestSres, param.sres.size()); + params.push_back(param); + sta_network_->sendNetworkEapSimGsmAuthResponse( + params, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * SendNetworkEapSimUmtsAuthResponse + */ +TEST_F(SupplicantStaNetworkHidlTest, SendNetworkEapSimUmtsAuthResponse) { + ISupplicantStaNetwork::NetworkResponseEapSimUmtsAuthParams params; + params.res = std::vector(kTestRes, kTestRes + sizeof(kTestRes)); + memcpy(params.ik.data(), kTestIk, params.ik.size()); + memcpy(params.ck.data(), kTestCk, params.ck.size()); + sta_network_->sendNetworkEapSimUmtsAuthResponse( + params, [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * SendNetworkEapIdentityResponse + */ +TEST_F(SupplicantStaNetworkHidlTest, SendNetworkEapIdentityResponse) { + sta_network_->sendNetworkEapIdentityResponse( + std::vector(kTestIdentity, + kTestIdentity + sizeof(kTestIdentity)), + [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +}