android-13.0.0_r83/s

/*
 * Copyright (C) 2021 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 <VtsCoreUtil.h>
#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include <aidl/android/hardware/wifi/supplicant/BnSupplicant.h>
#include <aidl/android/hardware/wifi/supplicant/BnSupplicantStaIfaceCallback.h>
#include <android/binder_manager.h>
#include <android/binder_status.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
#include <cutils/properties.h>

#include "supplicant_test_utils.h"

using aidl::android::hardware::wifi::supplicant::AnqpInfoId;
using aidl::android::hardware::wifi::supplicant::BnSupplicantStaIfaceCallback;
using aidl::android::hardware::wifi::supplicant::BtCoexistenceMode;
using aidl::android::hardware::wifi::supplicant::ConnectionCapabilities;
using aidl::android::hardware::wifi::supplicant::DebugLevel;
using aidl::android::hardware::wifi::supplicant::DppAkm;
using aidl::android::hardware::wifi::supplicant::DppConnectionKeys;
using aidl::android::hardware::wifi::supplicant::DppCurve;
using aidl::android::hardware::wifi::supplicant::DppNetRole;
using aidl::android::hardware::wifi::supplicant::DppResponderBootstrapInfo;
using aidl::android::hardware::wifi::supplicant::Hs20AnqpSubtypes;
using aidl::android::hardware::wifi::supplicant::IfaceType;
using aidl::android::hardware::wifi::supplicant::ISupplicant;
using aidl::android::hardware::wifi::supplicant::ISupplicantStaIface;
using aidl::android::hardware::wifi::supplicant::ISupplicantStaNetwork;
using aidl::android::hardware::wifi::supplicant::KeyMgmtMask;
using aidl::android::hardware::wifi::supplicant::WpaDriverCapabilitiesMask;
using aidl::android::hardware::wifi::supplicant::WpsConfigMethods;
using android::ProcessState;

static constexpr int TIMEOUT_PERIOD = 60;
class IfaceDppCallback;

namespace {
const std::vector<uint8_t> kTestMacAddr = {0x56, 0x67, 0x67, 0xf4, 0x56, 0x92};
const std::string kTestUri =
    "DPP:C:81/1,117/"
    "40;M:48d6d5bd1de1;I:G1197843;K:MDkwEwYHKoZIzj0CAQYIKoZIzj"
    "0DAQcDIgAD0edY4X3N//HhMFYsZfMbQJTiNFtNIWF/cIwMB/gzqOM=;;";
}  // namespace

class SupplicantStaIfaceCallback : public BnSupplicantStaIfaceCallback {
   public:
    SupplicantStaIfaceCallback() = default;

    ::ndk::ScopedAStatus onAnqpQueryDone(
        const std::vector<uint8_t>& /* bssid */,
        const ::aidl::android::hardware::wifi::supplicant::AnqpData& /* data */,
        const ::aidl::android::hardware::wifi::supplicant::
            Hs20AnqpData& /* hs20Data */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onAssociationRejected(
        const ::aidl::android::hardware::wifi::supplicant::
            AssociationRejectionData& /* assocRejectData */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onAuthenticationTimeout(
        const std::vector<uint8_t>& /* bssid */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onAuxiliarySupplicantEvent(
            ::aidl::android::hardware::wifi::supplicant ::
                    AuxiliarySupplicantEventCode /* eventCode */,
            const std::vector<uint8_t>& /* bssid */,
            const std::string& /* reasonString */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onBssTmHandlingDone(
        const ::aidl::android::hardware::wifi::supplicant::
            BssTmData& /* tmData */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onBssidChanged(
        ::aidl::android::hardware::wifi::supplicant::
            BssidChangeReason /* reason */,
        const std::vector<uint8_t>& /* bssid */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onDisconnected(
        const std::vector<uint8_t>& /* bssid */, bool /* locallyGenerated */,
        ::aidl::android::hardware::wifi::supplicant::
            StaIfaceReasonCode /* reasonCode */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onDppFailure(
        ::aidl::android::hardware::wifi::supplicant::DppFailureCode /* code */,
        const std::string& /* ssid */, const std::string& /* channelList */,
        const std::vector<char16_t>& /* bandList */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onDppProgress(
        ::aidl::android::hardware::wifi::supplicant::DppProgressCode /* code */)
        override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onDppSuccess(
        ::aidl::android::hardware::wifi::supplicant::DppEventType /* type */)
        override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onDppSuccessConfigReceived(
            const std::vector<uint8_t>& /* ssid */, const std::string& /* password */,
            const std::vector<uint8_t>& /* psk */,
            ::aidl::android::hardware::wifi::supplicant::DppAkm /* securityAkm */,
            const ::aidl::android::hardware::wifi::supplicant::
                    DppConnectionKeys& /* DppConnectionKeys */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onDppSuccessConfigSent() override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onEapFailure(const std::vector<uint8_t>& /* bssid */,
                                      int32_t /* errorCode */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onExtRadioWorkStart(int32_t /* id */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onExtRadioWorkTimeout(int32_t /* id */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onHs20DeauthImminentNotice(
        const std::vector<uint8_t>& /* bssid */, int32_t /* reasonCode */,
        int32_t /* reAuthDelayInSec */, const std::string& /* url */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onHs20IconQueryDone(
        const std::vector<uint8_t>& /* bssid */,
        const std::string& /* fileName */,
        const std::vector<uint8_t>& /* data */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onHs20SubscriptionRemediation(
        const std::vector<uint8_t>& /* bssid */,
        ::aidl::android::hardware::wifi::supplicant::OsuMethod /* osuMethod */,
        const std::string& /* url */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus
    onHs20TermsAndConditionsAcceptanceRequestedNotification(
        const std::vector<uint8_t>& /* bssid */,
        const std::string& /* url */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onNetworkAdded(int32_t /* id */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onNetworkNotFound(
        const std::vector<uint8_t>& /* ssid */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onNetworkRemoved(int32_t /* id */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onPmkCacheAdded(
        int64_t /* expirationTimeInSec */,
        const std::vector<uint8_t>& /* serializedEntry */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onStateChanged(
        ::aidl::android::hardware::wifi::supplicant::
            StaIfaceCallbackState /* newState */,
        const std::vector<uint8_t>& /* bssid */, int32_t /* id */,
        const std::vector<uint8_t>& /* ssid */,
        bool /* filsHlpSent */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onWpsEventFail(
        const std::vector<uint8_t>& /* bssid */,
        ::aidl::android::hardware::wifi::supplicant::
            WpsConfigError /* configError */,
        ::aidl::android::hardware::wifi::supplicant::
            WpsErrorIndication /* errorInd */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onWpsEventPbcOverlap() override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onWpsEventSuccess() override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onQosPolicyReset() override { return ndk::ScopedAStatus::ok(); }
    ::ndk::ScopedAStatus onQosPolicyRequest(
            int32_t /* qosPolicyRequestId */,
            const std::vector<::aidl::android::hardware::wifi::supplicant ::
                                      QosPolicyData /* qosPolicyData */>&) override {
        return ndk::ScopedAStatus::ok();
    }
};

class SupplicantStaIfaceAidlTest : public testing::TestWithParam<std::string> {
   public:
    void SetUp() override {
        initializeService();
        supplicant_ = getSupplicant(GetParam().c_str());
        ASSERT_NE(supplicant_, nullptr);
        ASSERT_TRUE(supplicant_
                        ->setDebugParams(DebugLevel::EXCESSIVE,
                                         true,  // show timestamps
                                         true)
                        .isOk());
        EXPECT_TRUE(supplicant_->getStaInterface(getStaIfaceName(), &sta_iface_)
                        .isOk());
        ASSERT_NE(sta_iface_, nullptr);
    }

    void TearDown() override {
        stopSupplicantService();
        startWifiFramework();
    }

    enum DppCallbackType {
        ANY_CALLBACK = -2,
        INVALID = -1,
        EVENT_SUCCESS = 0,
        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<std::mutex> lock(mtx_);
        cv_.notify_one();
    }

    // Test code calls this function to wait for data/event callback
    inline std::cv_status wait(DppCallbackType waitForCallbackType) {
        std::unique_lock<std::mutex> 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;
    }

   protected:
    std::shared_ptr<ISupplicant> supplicant_;
    std::shared_ptr<ISupplicantStaIface> sta_iface_;

   private:
    // synchronization objects
    std::mutex mtx_;
    std::condition_variable cv_;
};

/*
 * RegisterCallback
 */
TEST_P(SupplicantStaIfaceAidlTest, RegisterCallback) {
    std::shared_ptr<SupplicantStaIfaceCallback> callback =
        ndk::SharedRefBase::make<SupplicantStaIfaceCallback>();
    ASSERT_NE(callback, nullptr);
    EXPECT_TRUE(sta_iface_->registerCallback(callback).isOk());
}

/*
 * GetConnectionCapabilities
 */
TEST_P(SupplicantStaIfaceAidlTest, GetConnectionCapabilities) {
    ConnectionCapabilities cap;
    EXPECT_TRUE(sta_iface_->getConnectionCapabilities(&cap).isOk());
}

/*
 * GetWpaDriverCapabilities
 */
TEST_P(SupplicantStaIfaceAidlTest, GetWpaDriverCapabilities) {
    WpaDriverCapabilitiesMask cap;
    EXPECT_TRUE(sta_iface_->getWpaDriverCapabilities(&cap).isOk());
}

/*
 * GetKeyMgmtCapabilities
 */
TEST_P(SupplicantStaIfaceAidlTest, GetKeyMgmtCapabilities) {
    KeyMgmtMask cap;
    EXPECT_TRUE(sta_iface_->getKeyMgmtCapabilities(&cap).isOk());

    // Even though capabilities vary, these two are always set.
    EXPECT_TRUE(!!(static_cast<uint32_t>(cap) &
                   static_cast<uint32_t>(KeyMgmtMask::NONE)));
    EXPECT_TRUE(!!(static_cast<uint32_t>(cap) &
                   static_cast<uint32_t>(KeyMgmtMask::IEEE8021X)));
}

/*
 * GetName
 */
TEST_P(SupplicantStaIfaceAidlTest, GetName) {
    std::string name;
    EXPECT_TRUE(sta_iface_->getName(&name).isOk());
    EXPECT_NE(name.size(), 0);
}

/*
 * GetType
 */
TEST_P(SupplicantStaIfaceAidlTest, GetType) {
    IfaceType type;
    EXPECT_TRUE(sta_iface_->getType(&type).isOk());
    EXPECT_EQ(type, IfaceType::STA);
}

/*
 * GetMacAddress
 */
TEST_P(SupplicantStaIfaceAidlTest, GetMacAddress) {
    std::vector<uint8_t> macAddr;
    EXPECT_TRUE(sta_iface_->getMacAddress(&macAddr).isOk());
    EXPECT_EQ(macAddr.size(), 6);
}

/*
 * ListNetworks
 */
TEST_P(SupplicantStaIfaceAidlTest, ListNetworks) {
    std::vector<int32_t> networks;
    EXPECT_TRUE(sta_iface_->listNetworks(&networks).isOk());
}

/*
 * SetBtCoexistenceMode
 */
TEST_P(SupplicantStaIfaceAidlTest, SetBtCoexistenceMode) {
    EXPECT_TRUE(
        sta_iface_->setBtCoexistenceMode(BtCoexistenceMode::ENABLED).isOk());
    EXPECT_TRUE(
        sta_iface_->setBtCoexistenceMode(BtCoexistenceMode::DISABLED).isOk());
    EXPECT_TRUE(
        sta_iface_->setBtCoexistenceMode(BtCoexistenceMode::SENSE).isOk());
}

/*
 * SetBtCoexistenceScanModeEnabled
 */
TEST_P(SupplicantStaIfaceAidlTest, SetBtCoexistenceScanModeEnabled) {
    EXPECT_TRUE(sta_iface_->setBtCoexistenceScanModeEnabled(true).isOk());
    EXPECT_TRUE(sta_iface_->setBtCoexistenceScanModeEnabled(false).isOk());
}

/*
 * SetSuspendModeEnabled
 */
TEST_P(SupplicantStaIfaceAidlTest, SetSuspendModeEnabled) {
    EXPECT_TRUE(sta_iface_->setSuspendModeEnabled(true).isOk());
    EXPECT_TRUE(sta_iface_->setSuspendModeEnabled(false).isOk());
}

/*
 * SetCountryCode
 */
TEST_P(SupplicantStaIfaceAidlTest, SetCountryCode) {
    const std::vector<uint8_t> countryCode = {'M', 'X'};
    EXPECT_TRUE(sta_iface_->setCountryCode(countryCode).isOk());
}

/*
 * SetWpsDeviceName
 */
TEST_P(SupplicantStaIfaceAidlTest, SetWpsDeviceName) {
    const std::string deviceName = "TestWpsDeviceName";
    EXPECT_TRUE(sta_iface_->setWpsDeviceName(deviceName).isOk());
}

/*
 * SetWpsDeviceType
 */
TEST_P(SupplicantStaIfaceAidlTest, SetWpsDeviceType) {
    const std::vector<uint8_t> deviceType = {8, 0x1};
    EXPECT_TRUE(sta_iface_->setWpsDeviceType(deviceType).isOk());
}

/*
 * SetWpsManufacturer
 */
TEST_P(SupplicantStaIfaceAidlTest, SetWpsManufacturer) {
    const std::string wpsManufacturer = "TestManufacturer";
    EXPECT_TRUE(sta_iface_->setWpsManufacturer(wpsManufacturer).isOk());
}

/*
 * SetWpsModelName
 */
TEST_P(SupplicantStaIfaceAidlTest, SetWpsModelName) {
    const std::string modelName = "TestModelName";
    EXPECT_TRUE(sta_iface_->setWpsModelName(modelName).isOk());
}

/*
 * SetWpsModelNumber
 */
TEST_P(SupplicantStaIfaceAidlTest, SetWpsModelNumber) {
    const std::string modelNumber = "TestModelNumber";
    EXPECT_TRUE(sta_iface_->setWpsModelNumber(modelNumber).isOk());
}

/*
 * SetWpsSerialNumber
 */
TEST_P(SupplicantStaIfaceAidlTest, SetWpsSerialNumber) {
    const std::string serialNumber = "TestSerialNumber";
    EXPECT_TRUE(sta_iface_->setWpsSerialNumber(serialNumber).isOk());
}

/*
 * SetWpsConfigMethods
 */
TEST_P(SupplicantStaIfaceAidlTest, SetWpsConfigMethods) {
    const WpsConfigMethods configMethods = WpsConfigMethods::KEYPAD;
    EXPECT_TRUE(sta_iface_->setWpsConfigMethods(configMethods).isOk());
}

/*
 * SetExternalSim
 */
TEST_P(SupplicantStaIfaceAidlTest, SetExternalSim) {
    EXPECT_TRUE(sta_iface_->setExternalSim(true).isOk());
    EXPECT_TRUE(sta_iface_->setExternalSim(false).isOk());
}

/*
 * SetMboCellularDataStatus
 */
TEST_P(SupplicantStaIfaceAidlTest, SetMboCellularDataStatus) {
    WpaDriverCapabilitiesMask cap;
    EXPECT_TRUE(sta_iface_->getWpaDriverCapabilities(&cap).isOk());

    // Operation should succeed if MBO is supported, or fail if it's not.
    bool mboSupported =
        !!(static_cast<uint32_t>(cap) &
           static_cast<uint32_t>(WpaDriverCapabilitiesMask::MBO));
    EXPECT_EQ(mboSupported, sta_iface_->setMboCellularDataStatus(true).isOk());
}

/*
 * InitiateTdlsDiscover
 */
TEST_P(SupplicantStaIfaceAidlTest, InitiateTdlsDiscover) {
    EXPECT_TRUE(sta_iface_->initiateTdlsDiscover(kTestMacAddr).isOk());
}

/*
 * InitiateTdlsSetup
 */
TEST_P(SupplicantStaIfaceAidlTest, InitiateTdlsSetup) {
    EXPECT_TRUE(sta_iface_->initiateTdlsSetup(kTestMacAddr).isOk());
}

/*
 * InitiateTdlsTeardown
 */
TEST_P(SupplicantStaIfaceAidlTest, InitiateTdlsTeardown) {
    EXPECT_TRUE(sta_iface_->initiateTdlsTeardown(kTestMacAddr).isOk());
}

/*
 * InitiateAnqpQuery
 */
TEST_P(SupplicantStaIfaceAidlTest, InitiateAnqpQuery) {
    const std::vector<AnqpInfoId> anqpIds = {
        AnqpInfoId::VENUE_NAME, AnqpInfoId::NAI_REALM, AnqpInfoId::DOMAIN_NAME};
    const std::vector<Hs20AnqpSubtypes> hsTypes = {
        Hs20AnqpSubtypes::WAN_METRICS,
        Hs20AnqpSubtypes::OPERATOR_FRIENDLY_NAME};

    // Request should fail since the BSSID mentioned
    // is not present in the scan results
    EXPECT_FALSE(
        sta_iface_->initiateAnqpQuery(kTestMacAddr, anqpIds, hsTypes).isOk());
}

/*
 * InitiateHs20IconQuery
 */
TEST_P(SupplicantStaIfaceAidlTest, InitiateHs20IconQuery) {
    // Request should fail since the BSSID mentioned
    // is not present in the scan results
    const std::string hs20IconFile = "TestFile";
    EXPECT_FALSE(
        sta_iface_->initiateHs20IconQuery(kTestMacAddr, hs20IconFile).isOk());
}

/*
 * InitiateVenueUrlAnqpQuery.
 */
TEST_P(SupplicantStaIfaceAidlTest, InitiateVenueUrlAnqpQuery) {
    // Request should fail since the BSSID mentioned
    // is not present in the scan results
    EXPECT_FALSE(sta_iface_->initiateVenueUrlAnqpQuery(kTestMacAddr).isOk());
}

/*
 * Reassociate
 */
TEST_P(SupplicantStaIfaceAidlTest, Reassociate) {
    EXPECT_TRUE(sta_iface_->reassociate().isOk());
}

/*
 * Reconnect
 */
TEST_P(SupplicantStaIfaceAidlTest, Reconnect) {
    EXPECT_FALSE(sta_iface_->reconnect().isOk());
}

/*
 * Disconnect
 */
TEST_P(SupplicantStaIfaceAidlTest, Disconnect) {
    EXPECT_TRUE(sta_iface_->disconnect().isOk());
}

/*
 * SetPowerSave
 */
TEST_P(SupplicantStaIfaceAidlTest, SetPowerSave) {
    EXPECT_TRUE(sta_iface_->setPowerSave(true).isOk());
    EXPECT_TRUE(sta_iface_->setPowerSave(false).isOk());
}

/*
 * AddExtRadioWork
 */
TEST_P(SupplicantStaIfaceAidlTest, AddExtRadioWork) {
    const std::string radioWorkName = "TestRadioWork";
    const int32_t radioWorkFreq = 2412;
    const int32_t radioWorkTimeout = 8;
    int32_t radioWorkId;
    EXPECT_TRUE(sta_iface_
                    ->addExtRadioWork(radioWorkName, radioWorkFreq,
                                      radioWorkTimeout, &radioWorkId)
                    .isOk());
    // removeExtRadio only succeeds if the added radio work hasn't started yet,
    // so there is no guaranteed result from calling removeExtRadioWork here.
    // Given that, we can't currently test removeExtRadioWork following
    // a call to addExtRadioWork.
}

/*
 * RemoveExtRadioWork
 */
TEST_P(SupplicantStaIfaceAidlTest, RemoveExtRadioWork) {
    // This fails because there is no ongoing radio work with radioWorkId
    const int32_t radioWorkId = 16;
    EXPECT_FALSE(sta_iface_->removeExtRadioWork(radioWorkId).isOk());
}

/*
 * Add/Remove DppPeerUri
 */
TEST_P(SupplicantStaIfaceAidlTest, AddRemoveDppPeerUri) {
    if (!keyMgmtSupported(sta_iface_, KeyMgmtMask::DPP)) {
        GTEST_SKIP() << "Missing DPP support";
    }
    // Add a peer URI and then remove it.
    int32_t peerId;
    EXPECT_TRUE(sta_iface_->addDppPeerUri(kTestUri, &peerId).isOk());
    EXPECT_TRUE(sta_iface_->removeDppUri(peerId).isOk());
}

/*
 * FilsHlpAddRequest
 */
TEST_P(SupplicantStaIfaceAidlTest, FilsHlpAddRequest) {
    if (!isFilsSupported(sta_iface_)) {
        GTEST_SKIP()
            << "Skipping test since driver/supplicant doesn't support FILS";
    }
    const std::vector<uint8_t> destMacAddr = {0x00, 0x11, 0x22,
                                              0x33, 0x44, 0x55};
    const std::vector<uint8_t> pktBuffer = std::vector<uint8_t>(300, 0x3a);
    EXPECT_TRUE(sta_iface_->filsHlpAddRequest(destMacAddr, pktBuffer).isOk());
}

/*
 * FilsHlpFlushRequest
 */
TEST_P(SupplicantStaIfaceAidlTest, FilsHlpFlushRequest) {
    if (!isFilsSupported(sta_iface_)) {
        GTEST_SKIP()
            << "Skipping test since driver/supplicant doesn't support FILS";
    }
    EXPECT_TRUE(sta_iface_->filsHlpFlushRequest().isOk());
}

/*
 * StartDppEnrolleeResponder
 */
TEST_P(SupplicantStaIfaceAidlTest, StartDppEnrolleeResponder) {
    if (!keyMgmtSupported(sta_iface_, KeyMgmtMask::DPP)) {
        GTEST_SKIP() << "Missing DPP support";
    }

    const std::string deviceInfo = "DPP_Responder_Mode_VTS_Test";
    const std::vector<uint8_t> mac_address = {0x22, 0x33, 0x44,
                                              0x55, 0x66, 0x77};

    // Generate DPP bootstrap information.
    DppResponderBootstrapInfo bootstrapInfo;
    EXPECT_TRUE(
        sta_iface_
            ->generateDppBootstrapInfoForResponder(
                mac_address, deviceInfo, DppCurve::PRIME256V1, &bootstrapInfo)
            .isOk());
    EXPECT_NE(-1, bootstrapInfo.bootstrapId);
    EXPECT_NE(0, bootstrapInfo.bootstrapId);
    EXPECT_NE(0, bootstrapInfo.listenChannel);
    const uint32_t bootstrap_id = bootstrapInfo.bootstrapId;
    const uint32_t listen_channel = bootstrapInfo.listenChannel;

    // Start DPP as Enrollee-Responder.
    EXPECT_TRUE(sta_iface_->startDppEnrolleeResponder(listen_channel).isOk());

    // Stop DPP Enrollee-Responder mode, ie remove the URI and stop listen.
    EXPECT_TRUE(sta_iface_->stopDppResponder(bootstrap_id).isOk());
}

class IfaceDppCallback : public SupplicantStaIfaceCallback {
    SupplicantStaIfaceAidlTest& parent_;
    ::ndk::ScopedAStatus onDppSuccess(
        ::aidl::android::hardware::wifi::supplicant::DppEventType event)
        override {
        parent_.code = (uint32_t)event;
        parent_.dppCallbackType =
            SupplicantStaIfaceAidlTest::DppCallbackType::EVENT_SUCCESS;
        parent_.notify();
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onDppProgress(
        aidl::android::hardware::wifi::supplicant::DppProgressCode code)
        override {
        parent_.code = (uint32_t)code;
        parent_.dppCallbackType =
            SupplicantStaIfaceAidlTest::DppCallbackType::EVENT_PROGRESS;
        parent_.notify();
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onDppFailure(
        aidl::android::hardware::wifi::supplicant::DppFailureCode code,
        const std::string& ssid __attribute__((unused)),
        const std::string& channelList __attribute__((unused)),
        const std::vector<char16_t>& bandList
        __attribute__((unused))) override {
        parent_.code = (uint32_t)code;
        parent_.dppCallbackType =
            SupplicantStaIfaceAidlTest::DppCallbackType::EVENT_FAILURE;
        parent_.notify();
        return ndk::ScopedAStatus::ok();
    }

   public:
    IfaceDppCallback(SupplicantStaIfaceAidlTest& parent) : parent_(parent){};
};

/*
 * StartDppEnrolleeInitiator
 */
TEST_P(SupplicantStaIfaceAidlTest, StartDppEnrolleeInitiator) {
    if (!keyMgmtSupported(sta_iface_, KeyMgmtMask::DPP)) {
        GTEST_SKIP() << "Missing DPP support";
    }

    // Register callback
    std::shared_ptr<IfaceDppCallback> callback =
        ndk::SharedRefBase::make<IfaceDppCallback>(*this);
    EXPECT_NE(callback, nullptr);
    EXPECT_TRUE(sta_iface_->registerCallback(callback).isOk());

    // Add a peer URI
    int32_t peer_id = 0;
    EXPECT_TRUE(sta_iface_->addDppPeerUri(kTestUri, &peer_id).isOk());
    EXPECT_NE(0, peer_id);
    EXPECT_NE(-1, peer_id);

    // Start DPP as Enrollee-Initiator. Since this operation requires two
    // devices, we start the operation and expect a timeout.
    EXPECT_TRUE(sta_iface_->startDppEnrolleeInitiator(peer_id, 0).isOk());

    // Wait for the timeout callback
    EXPECT_EQ(std::cv_status::no_timeout,
              wait(SupplicantStaIfaceAidlTest::DppCallbackType::EVENT_FAILURE));
    EXPECT_EQ(SupplicantStaIfaceAidlTest::DppCallbackType::EVENT_FAILURE,
              dppCallbackType);

    // ...and then remove the peer URI.
    EXPECT_TRUE(sta_iface_->removeDppUri(peer_id).isOk());
}

/*
 * StartDppConfiguratorInitiator
 */
TEST_P(SupplicantStaIfaceAidlTest, StartDppConfiguratorInitiator) {
    if (!keyMgmtSupported(sta_iface_, KeyMgmtMask::DPP)) {
        GTEST_SKIP() << "Missing DPP support";
    }

    // Register callback
    std::shared_ptr<IfaceDppCallback> callback =
        ndk::SharedRefBase::make<IfaceDppCallback>(*this);
    EXPECT_NE(callback, nullptr);
    EXPECT_TRUE(sta_iface_->registerCallback(callback).isOk());

    // Add a peer URI
    int32_t peer_id = 0;
    EXPECT_TRUE(sta_iface_->addDppPeerUri(kTestUri, &peer_id).isOk());
    EXPECT_NE(0, peer_id);
    EXPECT_NE(-1, peer_id);

    const std::string ssid =
        "6D795F746573745F73736964";  // 'my_test_ssid' encoded in hex
    const std::string password =
        "746F70736563726574";  // 'topsecret' encoded in hex
    const std::vector<uint8_t> eckey_in = {0x2, 0x3, 0x4};
    std::vector<uint8_t> eckey_out = {};

    // Start DPP as Configurator-Initiator. Since this operation requires two
    // devices, we start the operation and expect a timeout.
    EXPECT_TRUE(sta_iface_
                        ->startDppConfiguratorInitiator(peer_id, 0, ssid, password, "",
                                                        DppNetRole::STA, DppAkm::PSK, eckey_in,
                                                        &eckey_out)
                        .isOk());

    // Wait for the timeout callback
    ASSERT_EQ(std::cv_status::no_timeout,
              wait(SupplicantStaIfaceAidlTest::DppCallbackType::EVENT_FAILURE));
    ASSERT_EQ(SupplicantStaIfaceAidlTest::DppCallbackType::EVENT_FAILURE,
              dppCallbackType);

    // ...and then remove the peer URI.
    EXPECT_TRUE(sta_iface_->removeDppUri(peer_id).isOk());
}

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SupplicantStaIfaceAidlTest);
INSTANTIATE_TEST_SUITE_P(Supplicant, SupplicantStaIfaceAidlTest,
                         testing::ValuesIn(android::getAidlHalInstanceNames(
                             ISupplicant::descriptor)),
                         android::PrintInstanceNameToString);

int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    ProcessState::self()->setThreadPoolMaxThreadCount(1);
    ProcessState::self()->startThreadPool();
    return RUN_ALL_TESTS();
}