diff --git a/compatibility_matrices/compatibility_matrix.current.xml b/compatibility_matrices/compatibility_matrix.current.xml index a4259c1142..e1a4203167 100644 --- a/compatibility_matrices/compatibility_matrix.current.xml +++ b/compatibility_matrices/compatibility_matrix.current.xml @@ -504,7 +504,7 @@ android.hardware.wifi.supplicant - 1.0-1 + 1.0-2 ISupplicant default diff --git a/wifi/supplicant/1.2/vts/functional/Android.bp b/wifi/supplicant/1.2/vts/functional/Android.bp index 9bd998c4de..1b970e1ce6 100644 --- a/wifi/supplicant/1.2/vts/functional/Android.bp +++ b/wifi/supplicant/1.2/vts/functional/Android.bp @@ -36,6 +36,32 @@ cc_library_static { ], } +cc_test { + name: "VtsHalWifiSupplicantV1_2TargetTest", + defaults: ["VtsHalTargetTestDefaults"], + srcs: [ + "VtsHalWifiSupplicantV1_2TargetTest.cpp", + "supplicant_sta_iface_hidl_test.cpp", + "supplicant_sta_network_hidl_test.cpp", + ], + static_libs: [ + "VtsHalWifiV1_0TargetTestUtil", + "VtsHalWifiSupplicantV1_0TargetTestUtil", + "VtsHalWifiSupplicantV1_1TargetTestUtil", + "VtsHalWifiSupplicantV1_2TargetTestUtil", + "android.hardware.wifi.supplicant@1.0", + "android.hardware.wifi.supplicant@1.1", + "android.hardware.wifi.supplicant@1.2", + "android.hardware.wifi@1.0", + "android.hardware.wifi@1.1", + "libcrypto", + "libgmock", + "libwifi-system", + "libwifi-system-iface", + ], + test_suites: ["general-tests"], +} + cc_test { name: "VtsHalWifiSupplicantP2pV1_2TargetTest", defaults: ["VtsHalTargetTestDefaults"], @@ -52,9 +78,11 @@ cc_test { "android.hardware.wifi.supplicant@1.1", "android.hardware.wifi.supplicant@1.2", "android.hardware.wifi@1.0", + "android.hardware.wifi@1.1", "libcrypto", "libgmock", "libwifi-system", "libwifi-system-iface", ], } + diff --git a/wifi/supplicant/1.2/vts/functional/VtsHalWifiSupplicantV1_2TargetTest.cpp b/wifi/supplicant/1.2/vts/functional/VtsHalWifiSupplicantV1_2TargetTest.cpp index 9d0e960435..267fa67364 100644 --- a/wifi/supplicant/1.2/vts/functional/VtsHalWifiSupplicantV1_2TargetTest.cpp +++ b/wifi/supplicant/1.2/vts/functional/VtsHalWifiSupplicantV1_2TargetTest.cpp @@ -15,8 +15,7 @@ */ #include - -#include +#include #include #include "supplicant_hidl_test_utils.h" @@ -32,6 +31,7 @@ class WifiSupplicantHidlEnvironment_1_2 : public WifiSupplicantHidlEnvironment { } virtual void registerTestServices() override { registerTestService<::android::hardware::wifi::V1_0::IWifi>(); + registerTestService<::android::hardware::wifi::V1_1::IWifi>(); registerTestService< ::android::hardware::wifi::supplicant::V1_0::ISupplicant>(); registerTestService< diff --git a/wifi/supplicant/1.2/vts/functional/supplicant_hidl_test_utils_1_2.cpp b/wifi/supplicant/1.2/vts/functional/supplicant_hidl_test_utils_1_2.cpp index 5b5d4e9234..f270bff673 100644 --- a/wifi/supplicant/1.2/vts/functional/supplicant_hidl_test_utils_1_2.cpp +++ b/wifi/supplicant/1.2/vts/functional/supplicant_hidl_test_utils_1_2.cpp @@ -21,7 +21,22 @@ #include "supplicant_hidl_test_utils_1_2.h" using ::android::sp; +using ::android::hardware::wifi::supplicant::V1_2::ISupplicant; using ::android::hardware::wifi::supplicant::V1_2::ISupplicantP2pIface; +using ::android::hardware::wifi::supplicant::V1_2::ISupplicantStaIface; +using ::android::hardware::wifi::supplicant::V1_2::ISupplicantStaNetwork; + +sp getSupplicant_1_2() { + return ISupplicant::castFrom(getSupplicant()); +} + +sp getSupplicantStaIface_1_2() { + return ISupplicantStaIface::castFrom(getSupplicantStaIface()); +} + +sp createSupplicantStaNetwork_1_2() { + return ISupplicantStaNetwork::castFrom(createSupplicantStaNetwork()); +} sp getSupplicantP2pIface_1_2() { return ISupplicantP2pIface::castFrom(getSupplicantP2pIface()); diff --git a/wifi/supplicant/1.2/vts/functional/supplicant_hidl_test_utils_1_2.h b/wifi/supplicant/1.2/vts/functional/supplicant_hidl_test_utils_1_2.h index 48be08d7ed..8a7ccc5dac 100644 --- a/wifi/supplicant/1.2/vts/functional/supplicant_hidl_test_utils_1_2.h +++ b/wifi/supplicant/1.2/vts/functional/supplicant_hidl_test_utils_1_2.h @@ -17,7 +17,19 @@ #ifndef SUPPLICANT_HIDL_TEST_UTILS_1_2_H #define SUPPLICANT_HIDL_TEST_UTILS_1_2_H +#include #include +#include +#include + +android::sp +getSupplicant_1_2(); + +android::sp +getSupplicantStaIface_1_2(); + +android::sp +createSupplicantStaNetwork_1_2(); android::sp getSupplicantP2pIface_1_2(); diff --git a/wifi/supplicant/1.2/vts/functional/supplicant_sta_iface_hidl_test.cpp b/wifi/supplicant/1.2/vts/functional/supplicant_sta_iface_hidl_test.cpp new file mode 100644 index 0000000000..4425281b75 --- /dev/null +++ b/wifi/supplicant/1.2/vts/functional/supplicant_sta_iface_hidl_test.cpp @@ -0,0 +1,418 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "supplicant_hidl_test_utils.h" +#include "supplicant_hidl_test_utils_1_2.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::SupplicantStatus; +using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatusCode; +using ::android::hardware::wifi::supplicant::V1_2::DppAkm; +using ::android::hardware::wifi::supplicant::V1_2::DppFailureCode; +using ::android::hardware::wifi::supplicant::V1_2::DppNetRole; +using ::android::hardware::wifi::supplicant::V1_2::DppProgressCode; +using ::android::hardware::wifi::supplicant::V1_2::DppSuccessCode; +using ::android::hardware::wifi::supplicant::V1_2::ISupplicantStaIface; +using ::android::hardware::wifi::supplicant::V1_2::ISupplicantStaIfaceCallback; +using ::android::hardware::wifi::supplicant::V1_2::ISupplicantStaNetwork; + +#define TIMEOUT_PERIOD 60 +class IfaceDppCallback; + +class SupplicantStaIfaceHidlTest : public ::testing::VtsHalHidlTargetTestBase { + public: + virtual void SetUp() override { + startSupplicantAndWaitForHidlService(); + EXPECT_TRUE(turnOnExcessiveLogging()); + sta_iface_ = getSupplicantStaIface_1_2(); + ASSERT_NE(sta_iface_.get(), nullptr); + count_ = 0; + } + + virtual void TearDown() override { stopSupplicant(); } + + enum DppCallbackType { + ANY_CALLBACK = -2, + INVALID = -1, + + EVENT_SUCCESS = 0, + EVENT_SUCCESS_CONFIG_RECEIVED, + EVENT_PROGRESS, + EVENT_FAILURE, + }; + + DppCallbackType dppCallbackType; + uint32_t code; + + /* Used as a mechanism to inform the test about data/event callback */ + inline void notify() { + std::unique_lock lock(mtx_); + count_++; + cv_.notify_one(); + } + + /* Test code calls this function to wait for data/event callback */ + inline std::cv_status wait(DppCallbackType waitForCallbackType) { + std::unique_lock lock(mtx_); + EXPECT_NE(INVALID, waitForCallbackType); // can't ASSERT in a + // non-void-returning method + auto now = std::chrono::system_clock::now(); + std::cv_status status = + cv_.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD)); + return status; + } + + private: + // synchronization objects + std::mutex mtx_; + std::condition_variable cv_; + int count_; + + protected: + // ISupplicantStaIface object used for all tests in this fixture. + sp sta_iface_; + bool isDppSupported() { + uint32_t keyMgmtMask = 0; + + // We need to first get the key management capabilities from the device. + // If DPP is not supported, we just pass the test. + sta_iface_->getKeyMgmtCapabilities( + [&](const SupplicantStatus& status, uint32_t keyMgmtMaskInternal) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + + keyMgmtMask = keyMgmtMaskInternal; + }); + + if (!(keyMgmtMask & ISupplicantStaNetwork::KeyMgmtMask::DPP)) { + // DPP not supported + return false; + } + + return true; + } +}; + +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 */, + ISupplicantStaIfaceCallback::ReasonCode + /* reasonCode */) override { + return Void(); + } + Return onAssociationRejected( + const hidl_array& /* bssid */, + ISupplicantStaIfaceCallback::StatusCode /* statusCode */, + bool /*timedOut */) override { + return Void(); + } + Return onAuthenticationTimeout( + const hidl_array& /* bssid */) override { + return Void(); + } + Return onBssidChanged( + ISupplicantStaIfaceCallback::BssidChangeReason /* reason */, + const hidl_array& /* bssid */) override { + return Void(); + } + Return onEapFailure() override { return Void(); } + Return onEapFailure_1_1( + ISupplicantStaIfaceCallback::EapErrorCode /* eapErrorCode */) 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(); + } + Return onDppSuccessConfigReceived( + const hidl_vec& /* ssid */, const hidl_string& /* password */, + const hidl_array& /* psk */, + DppAkm /* securityAkm */) override { + return Void(); + } + Return onDppSuccess(DppSuccessCode /* code */) override { + return Void(); + } + Return onDppProgress(DppProgressCode /* code */) override { + return Void(); + } + Return onDppFailure(DppFailureCode /* code */) override { + return Void(); + } +}; + +class IfaceDppCallback : public IfaceCallback { + SupplicantStaIfaceHidlTest& parent_; + + Return onDppSuccessConfigReceived( + const hidl_vec& /* ssid */, const hidl_string& /* password */, + const hidl_array& /* psk */, + DppAkm /* securityAkm */) override { + parent_.code = 0; + parent_.dppCallbackType = SupplicantStaIfaceHidlTest::DppCallbackType:: + EVENT_SUCCESS_CONFIG_RECEIVED; + parent_.notify(); + return Void(); + } + Return onDppSuccess(DppSuccessCode code) override { + parent_.code = (uint32_t)code; + parent_.dppCallbackType = + SupplicantStaIfaceHidlTest::DppCallbackType::EVENT_SUCCESS; + parent_.notify(); + return Void(); + } + Return onDppProgress(DppProgressCode code) override { + parent_.code = (uint32_t)code; + parent_.dppCallbackType = + SupplicantStaIfaceHidlTest::DppCallbackType::EVENT_PROGRESS; + parent_.notify(); + return Void(); + } + Return onDppFailure(DppFailureCode code) override { + parent_.code = (uint32_t)code; + parent_.dppCallbackType = + SupplicantStaIfaceHidlTest::DppCallbackType::EVENT_FAILURE; + parent_.notify(); + return Void(); + } + + public: + IfaceDppCallback(SupplicantStaIfaceHidlTest& parent) : parent_(parent){}; +}; + +/* + * RegisterCallback_1_2 + */ +TEST_F(SupplicantStaIfaceHidlTest, RegisterCallback_1_2) { + sta_iface_->registerCallback_1_2( + new IfaceCallback(), [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * GetKeyMgmtCapabilities + */ +TEST_F(SupplicantStaIfaceHidlTest, GetKeyMgmtCapabilities) { + sta_iface_->getKeyMgmtCapabilities( + [&](const SupplicantStatus& status, uint32_t keyMgmtMask) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + + // Even though capabilities vary, these two are always set in HAL + // v1.2 + EXPECT_TRUE(keyMgmtMask & ISupplicantStaNetwork::KeyMgmtMask::NONE); + EXPECT_TRUE(keyMgmtMask & + ISupplicantStaNetwork::KeyMgmtMask::IEEE8021X); + }); +} + +/* + * AddDppPeerUriAndRomveUri + */ +TEST_F(SupplicantStaIfaceHidlTest, AddDppPeerUriAndRomveUri) { + // We need to first get the key management capabilities from the device. + // If DPP is not supported, we just pass the test. + if (!isDppSupported()) { + // DPP not supported + return; + } + + hidl_string uri = + "DPP:C:81/1;M:48d6d5bd1de1;I:G1197843;K:MDkwEwYHKoZIzj0CAQYIKoZIzj" + "0DAQcDIgAD0edY4X3N//HhMFYsZfMbQJTiNFtNIWF/cIwMB/gzqOM=;;"; + uint32_t peer_id = 0; + + // Add a peer URI + sta_iface_->addDppPeerUri( + uri, [&](const SupplicantStatus& status, uint32_t id) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_NE(0, id); + EXPECT_NE(-1, id); + + peer_id = id; + }); + + // ...and then remove it. + sta_iface_->removeDppUri(peer_id, [&](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * StartDppEnrolleeInitiator + */ +TEST_F(SupplicantStaIfaceHidlTest, StartDppEnrolleeInitiator) { + // We need to first get the key management capabilities from the device. + // If DPP is not supported, we just pass the test. + if (!isDppSupported()) { + // DPP not supported + return; + } + + hidl_string uri = + "DPP:C:81/1;M:48d6d5bd1de1;I:G1197843;K:MDkwEwYHKoZIzj0CAQYIKoZIzj" + "0DAQcDIgAD0edY4X3N//HhMFYsZfMbQJTiNFtNIWF/cIwMB/gzqOM=;;"; + uint32_t peer_id = 0; + + // Register callbacks + sta_iface_->registerCallback_1_2( + new IfaceDppCallback(*this), [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + // Add a peer URI + sta_iface_->addDppPeerUri( + uri, [&](const SupplicantStatus& status, uint32_t id) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_NE(0, id); + EXPECT_NE(-1, id); + + peer_id = id; + }); + + // Start DPP as Enrollee-Initiator. Since this operation requires two + // devices, we start the operation and expect a timeout. + sta_iface_->startDppEnrolleeInitiator( + peer_id, 0, [&](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + // Wait for the timeout callback + ASSERT_EQ(std::cv_status::no_timeout, + wait(SupplicantStaIfaceHidlTest::DppCallbackType::EVENT_FAILURE)); + ASSERT_EQ(SupplicantStaIfaceHidlTest::DppCallbackType::EVENT_FAILURE, + dppCallbackType); + + // ...and then remove the peer URI. + sta_iface_->removeDppUri(peer_id, [&](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * StartDppConfiguratorInitiator + */ +TEST_F(SupplicantStaIfaceHidlTest, StartDppConfiguratorInitiator) { + // We need to first get the key management capabilities from the device. + // If DPP is not supported, we just pass the test. + if (!isDppSupported()) { + // DPP not supported + return; + } + + hidl_string uri = + "DPP:C:81/1;M:48d6d5bd1de1;I:G1197843;K:MDkwEwYHKoZIzj0CAQYIKoZIzj" + "0DAQcDIgAD0edY4X3N//HhMFYsZfMbQJTiNFtNIWF/cIwMB/gzqOM=;;"; + uint32_t peer_id = 0; + + // Register callbacks + sta_iface_->registerCallback_1_2( + new IfaceDppCallback(*this), [](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + // Add a peer URI + sta_iface_->addDppPeerUri( + uri, [&](const SupplicantStatus& status, uint32_t id) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_NE(0, id); + EXPECT_NE(-1, id); + + peer_id = id; + }); + + std::string ssid = + "6D795F746573745F73736964"; // 'my_test_ssid' encoded in hex + std::string password = "746F70736563726574"; // 'topsecret' encoded in hex + + // Start DPP as Configurator-Initiator. Since this operation requires two + // devices, we start the operation and expect a timeout. + sta_iface_->startDppConfiguratorInitiator( + peer_id, 0, ssid, password, NULL, DppNetRole::STA, DppAkm::PSK, + [&](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + // Wait for the timeout callback + ASSERT_EQ(std::cv_status::no_timeout, + wait(SupplicantStaIfaceHidlTest::DppCallbackType::EVENT_FAILURE)); + ASSERT_EQ(SupplicantStaIfaceHidlTest::DppCallbackType::EVENT_FAILURE, + dppCallbackType); + + // ...and then remove the peer URI. + sta_iface_->removeDppUri(peer_id, [&](const SupplicantStatus& status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} diff --git a/wifi/supplicant/1.2/vts/functional/supplicant_sta_network_hidl_test.cpp b/wifi/supplicant/1.2/vts/functional/supplicant_sta_network_hidl_test.cpp new file mode 100644 index 0000000000..ed421d73d7 --- /dev/null +++ b/wifi/supplicant/1.2/vts/functional/supplicant_sta_network_hidl_test.cpp @@ -0,0 +1,192 @@ +/* + * 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 + +#include +#include + +#include "supplicant_hidl_test_utils.h" +#include "supplicant_hidl_test_utils_1_2.h" + +using ::android::sp; +using ::android::hardware::hidl_vec; +using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatus; +using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatusCode; +using ::android::hardware::wifi::supplicant::V1_2::ISupplicantStaNetwork; +// namespace { +// constexpr uint8_t kTestIdentity[] = {0x45, 0x67, 0x98, 0x67, 0x56}; +// constexpr uint8_t kTestEncryptedIdentity[] = {0x35, 0x37, 0x58, 0x57, 0x26}; +//} // namespace + +class SupplicantStaNetworkHidlTest + : public ::testing::VtsHalHidlTargetTestBase { + public: + virtual void SetUp() override { + startSupplicantAndWaitForHidlService(); + EXPECT_TRUE(turnOnExcessiveLogging()); + sta_network_ = createSupplicantStaNetwork_1_2(); + ASSERT_NE(sta_network_.get(), nullptr); + } + + virtual void TearDown() override { stopSupplicant(); } + + protected: + // ISupplicantStaNetwork object used for all tests in this fixture. + sp sta_network_; +}; + +/* + * SetGetSaePassword + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetSaePassword) { + std::string password = "topsecret"; + + sta_network_->setSaePassword(password, [](const SupplicantStatus &status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + sta_network_->getSaePassword( + [&password](const SupplicantStatus &status, std::string passwordOut) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(passwordOut.compare(password), 0); + }); +} + +/* + * SetGetSaePasswordId + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetSaePasswordId) { + std::string passwordId = "id1"; + + sta_network_->setSaePasswordId( + passwordId, [](const SupplicantStatus &status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + sta_network_->getSaePasswordId([&passwordId](const SupplicantStatus &status, + std::string passwordIdOut) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(passwordIdOut.compare(passwordId), 0); + }); +} + +/* + * SetGetGroupMgmtCipher + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetGroupMgmtCipher) { + uint32_t groupMgmtCipher = + (uint32_t)ISupplicantStaNetwork::GroupMgmtCipherMask::BIP_GMAC_256; + + sta_network_->setGroupMgmtCipher( + groupMgmtCipher, [](const SupplicantStatus &status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + sta_network_->getGroupMgmtCipher( + [&groupMgmtCipher](const SupplicantStatus &status, + uint32_t groupMgmtCipherOut) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(groupMgmtCipherOut, groupMgmtCipher); + }); +} + +/* + * SetGetKeyMgmt_1_2 + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetKeyMgmt_1_2) { + uint32_t keyMgmt = (uint32_t)ISupplicantStaNetwork::KeyMgmtMask::SAE; + + sta_network_->setKeyMgmt_1_2(keyMgmt, [](const SupplicantStatus &status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + sta_network_->getKeyMgmt_1_2( + [&keyMgmt](const SupplicantStatus &status, uint32_t keyMgmtOut) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(keyMgmtOut, keyMgmt); + }); +} + +/* + * SetGetGroupCipher_1_2 + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetGroupCipher_1_2) { + uint32_t groupCipher = + (uint32_t)ISupplicantStaNetwork::GroupCipherMask::GCMP_256; + + sta_network_->setGroupCipher_1_2( + groupCipher, [](const SupplicantStatus &status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + sta_network_->getGroupCipher_1_2( + [&groupCipher](const SupplicantStatus &status, + uint32_t groupCipherOut) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(groupCipherOut, groupCipher); + }); +} + +/* + * SetGetPairwiseCipher_1_2 + */ +TEST_F(SupplicantStaNetworkHidlTest, SetGetPairwiseCipher_1_2) { + uint32_t pairwiseCipher = + (uint32_t)ISupplicantStaNetwork::PairwiseCipherMask::GCMP_256; + + sta_network_->setPairwiseCipher_1_2( + pairwiseCipher, [](const SupplicantStatus &status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + sta_network_->getPairwiseCipher_1_2( + [&pairwiseCipher](const SupplicantStatus &status, + uint32_t pairwiseCipherOut) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + EXPECT_EQ(pairwiseCipherOut, pairwiseCipher); + }); +} + +/* + * EnableSuiteBEapOpenSslCiphers + */ +TEST_F(SupplicantStaNetworkHidlTest, EnableSuiteBEapOpenSslCiphers) { + sta_network_->enableSuiteBEapOpenSslCiphers( + [](const SupplicantStatus &status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + sta_network_->enableSuiteBEapOpenSslCiphers( + [](const SupplicantStatus &status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +} + +/* + * EnableTlsSuiteBEapPhase1Param + */ +TEST_F(SupplicantStaNetworkHidlTest, EnableTlsSuiteBEapPhase1Param) { + sta_network_->enableTlsSuiteBEapPhase1Param( + true, [](const SupplicantStatus &status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); + + sta_network_->enableTlsSuiteBEapPhase1Param( + false, [](const SupplicantStatus &status) { + EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code); + }); +}