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

Commit 036da682 authored by Roshan Pius's avatar Roshan Pius
Browse files

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
parent 2e429d6b

wifi/supplicant/1.0/vts/functional/supplicant_hidl_test.cpp

+153 −0
Original line number Diff line number Diff line
@@ -18,8 +18,33 @@ 


#include <VtsHalHidlTargetTestBase.h>



#include <android/hardware/wifi/supplicant/1.0/ISupplicant.h>



#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<ISupplicant> 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<ISupplicant::IfaceInfo> ifaces;

    supplicant_->listInterfaces(

        [&](const SupplicantStatus& status,

            const hidl_vec<ISupplicant::IfaceInfo>& 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<ISupplicant::IfaceInfo> ifaces;

    supplicant_->listInterfaces(

        [&](const SupplicantStatus& status,

            const hidl_vec<ISupplicant::IfaceInfo>& 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<ISupplicantIface>& 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);

        });

}

wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp

+2 −2
Original line number Diff line number Diff line
@@ -17,9 +17,9 @@ 
#include <android-base/logging.h>

#include <VtsHalHidlTargetTestBase.h>



#include <hidl/HidlTransportSupport.h>

#include <android/hidl/manager/1.0/IServiceManager.h>

#include <android/hidl/manager/1.0/IServiceNotification.h>

#include <hidl/HidlTransportSupport.h>



#include <wifi_hal/driver_tool.h>

#include <wifi_system/interface_tool.h>
@@ -174,7 +174,7 @@ void startSupplicantAndWaitForHidlService() { 
}



sp<ISupplicant> getSupplicant() {

    return getService<ISupplicant>(kSupplicantServiceName);

    return ::testing::VtsHalHidlTargetTestBase::getService<ISupplicant>();

}



sp<ISupplicantStaIface> getSupplicantStaIface() {

wifi/supplicant/1.0/vts/functional/supplicant_p2p_iface_hidl_test.cpp

+381 −0
Original line number Diff line number Diff line
@@ -18,8 +18,144 @@ 


#include <VtsHalHidlTargetTestBase.h>



#include <android/hardware/wifi/supplicant/1.0/ISupplicantP2pIface.h>



#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<ISupplicantP2pIface> p2p_iface_;

    // MAC address to use for various tests.

    std::array<uint8_t, 6> mac_addr_;

    std::array<uint8_t, 6> peer_mac_addr_;

};



class IfaceCallback : public ISupplicantP2pIfaceCallback {

    Return<void> onNetworkAdded(uint32_t /* id */) override { return Void(); }

    Return<void> onNetworkRemoved(uint32_t /* id */) override { return Void(); }

    Return<void> onDeviceFound(

        const hidl_array<uint8_t, 6>& /* srcAddress */,

        const hidl_array<uint8_t, 6>& /* p2pDeviceAddress */,

        const hidl_array<uint8_t, 8>& /* primaryDeviceType */,

        const hidl_string& /* deviceName */, uint16_t /* configMethods */,

        uint8_t /* deviceCapabilities */, uint32_t /* groupCapabilities */,

        const hidl_array<uint8_t, 8>& /* wfdDeviceInfo */) override {

        return Void();

    }

    Return<void> onDeviceLost(

        const hidl_array<uint8_t, 6>& /* p2pDeviceAddress */) override {

        return Void();

    }

    Return<void> onFindStopped() override { return Void(); }

    Return<void> onGoNegotiationRequest(

        const hidl_array<uint8_t, 6>& /* srcAddress */,

        ISupplicantP2pIfaceCallback::WpsDevPasswordId /* passwordId */)

        override {

        return Void();

    }

    Return<void> onGoNegotiationCompleted(

        ISupplicantP2pIfaceCallback::P2pStatusCode /* status */) override {

        return Void();

    }

    Return<void> onGroupFormationSuccess() override { return Void(); }

    Return<void> onGroupFormationFailure(

        const hidl_string& /* failureReason */) override {

        return Void();

    }

    Return<void> onGroupStarted(

        const hidl_string& /* groupIfname */, bool /* isGo */,

        const hidl_vec<uint8_t>& /* ssid */, uint32_t /* frequency */,

        const hidl_array<uint8_t, 32>& /* psk */,

        const hidl_string& /* passphrase */,

        const hidl_array<uint8_t, 6>& /* goDeviceAddress */,

        bool /* isPersistent */) override {

        return Void();

    }

    Return<void> onGroupRemoved(const hidl_string& /* groupIfname */,

                                bool /* isGo */) override {

        return Void();

    }

    Return<void> onInvitationReceived(

        const hidl_array<uint8_t, 6>& /* srcAddress */,

        const hidl_array<uint8_t, 6>& /* goDeviceAddress */,

        const hidl_array<uint8_t, 6>& /* bssid */,

        uint32_t /* persistentNetworkId */,

        uint32_t /* operatingFrequency */) override {

        return Void();

    }

    Return<void> onInvitationResult(

        const hidl_array<uint8_t, 6>& /* bssid */,

        ISupplicantP2pIfaceCallback::P2pStatusCode /* status */) override {

        return Void();

    }

    Return<void> onProvisionDiscoveryCompleted(

        const hidl_array<uint8_t, 6>& /* p2pDeviceAddress */,

        bool /* isRequest */,

        ISupplicantP2pIfaceCallback::P2pProvDiscStatusCode /* status */,

        uint16_t /* configMethods */,

        const hidl_string& /* generatedPin */) override {

        return Void();

    }

    Return<void> onServiceDiscoveryResponse(

        const hidl_array<uint8_t, 6>& /* srcAddress */,

        uint16_t /* updateIndicator */,

        const hidl_vec<uint8_t>& /* tlvs */) override {

        return Void();

    }

    Return<void> onStaAuthorized(

        const hidl_array<uint8_t, 6>& /* srcAddress */,

        const hidl_array<uint8_t, 6>& /* p2pDeviceAddress */) override {

        return Void();

    }

    Return<void> onStaDeauthorized(

        const hidl_array<uint8_t, 6>& /* srcAddress */,

        const hidl_array<uint8_t, 6>& /* 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<uint8_t, 6>& /* mac_addr */) {

            EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);

        });

}



/*

 * SetSsidPostfix

 */

TEST_F(SupplicantP2pIfaceHidlTest, SetSsidPostfix) {

    std::vector<uint8_t> 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<ISupplicantP2pIface::FreqRange> 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<uint8_t, 6> mac_addr;

    memcpy(mac_addr.data(), kTestMacAddr, mac_addr.size());

    p2p_iface_->getSsid(mac_addr, [](const SupplicantStatus& status,

                                     const hidl_vec<uint8_t>& /* ssid */) {

        // This is not going to work with fake values.

        EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code);

    });

}



/*

 * GetGroupCapability

 */

TEST_F(SupplicantP2pIfaceHidlTest, GetGroupCapability) {

    std::array<uint8_t, 6> 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);

                                });

}