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

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <android-base/logging.h>
  18
  19 #include <VtsHalHidlTargetTestBase.h>
  20
  21 #include <android/hardware/wifi/supplicant/1.0/ISupplicantP2pIface.h>
  22
  23 #include "supplicant_hidl_call_util.h"
  24 #include "supplicant_hidl_test_utils.h"
  25
  26 using ::android::sp;
  27 using ::android::hardware::hidl_array;
  28 using ::android::hardware::hidl_string;
  29 using ::android::hardware::hidl_vec;
  30 using ::android::hardware::Return;
  31 using ::android::hardware::Void;
  32 using ::android::hardware::wifi::supplicant::V1_0::IfaceType;
  33 using ::android::hardware::wifi::supplicant::V1_0::ISupplicantP2pIface;
  34 using ::android::hardware::wifi::supplicant::V1_0::ISupplicantP2pIfaceCallback;
  35 using ::android::hardware::wifi::supplicant::V1_0::SupplicantNetworkId;
  36 using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatus;
  37 using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatusCode;
  38
  39 namespace {
  40 constexpr uint8_t kTestSsidPostfix[] = {'t', 'e', 's', 't'};
  41 constexpr uint8_t kTestMacAddr[] = {0x56, 0x67, 0x67, 0xf4, 0x56, 0x92};
  42 constexpr uint8_t kTestPeerMacAddr[] = {0x56, 0x67, 0x55, 0xf4, 0x56, 0x92};
  43 constexpr char kTestConnectPin[] = "34556665";
  44 constexpr char kTestGroupIfName[] = "TestGroup";
  45 constexpr uint32_t kTestConnectGoIntent = 6;
  46 constexpr uint32_t kTestFindTimeout = 5;
  47 constexpr uint32_t kTestSetGroupIdleTimeout = 6;
  48 constexpr SupplicantNetworkId kTestNetworkId = 5;
  49 constexpr uint32_t kTestChannel = 1;
  50 constexpr uint32_t kTestOperatingClass = 81;
  51 constexpr uint32_t kTestFreqRange[] = {2412, 2432};
  52 constexpr uint32_t kTestExtListenPeriod = 400;
  53 constexpr uint32_t kTestExtListenInterval = 400;
  54 }  // namespace
  55
  56 class SupplicantP2pIfaceHidlTest : public ::testing::VtsHalHidlTargetTestBase {
  57    public:
  58     virtual void SetUp() override {
  59         startSupplicantAndWaitForHidlService();
  60         EXPECT_TRUE(turnOnExcessiveLogging());
  61         p2p_iface_ = getSupplicantP2pIface();
  62         ASSERT_NE(p2p_iface_.get(), nullptr);
  63
  64         memcpy(mac_addr_.data(), kTestMacAddr, mac_addr_.size());
  65         memcpy(peer_mac_addr_.data(), kTestPeerMacAddr, peer_mac_addr_.size());
  66     }
  67
  68     virtual void TearDown() override { stopSupplicant(); }
  69
  70    protected:
  71     // ISupplicantP2pIface object used for all tests in this fixture.
  72     sp<ISupplicantP2pIface> p2p_iface_;
  73     // MAC address to use for various tests.
  74     std::array<uint8_t, 6> mac_addr_;
  75     std::array<uint8_t, 6> peer_mac_addr_;
  76 };
  77
  78 class IfaceCallback : public ISupplicantP2pIfaceCallback {
  79     Return<void> onNetworkAdded(uint32_t /* id */) override { return Void(); }
  80     Return<void> onNetworkRemoved(uint32_t /* id */) override { return Void(); }
  81     Return<void> onDeviceFound(
  82         const hidl_array<uint8_t, 6>& /* srcAddress */,
  83         const hidl_array<uint8_t, 6>& /* p2pDeviceAddress */,
  84         const hidl_array<uint8_t, 8>& /* primaryDeviceType */,
  85         const hidl_string& /* deviceName */, uint16_t /* configMethods */,
  86         uint8_t /* deviceCapabilities */, uint32_t /* groupCapabilities */,
  87         const hidl_array<uint8_t, 6>& /* wfdDeviceInfo */) override {
  88         return Void();
  89     }
  90     Return<void> onDeviceLost(
  91         const hidl_array<uint8_t, 6>& /* p2pDeviceAddress */) override {
  92         return Void();
  93     }
  94     Return<void> onFindStopped() override { return Void(); }
  95     Return<void> onGoNegotiationRequest(
  96         const hidl_array<uint8_t, 6>& /* srcAddress */,
  97         ISupplicantP2pIfaceCallback::WpsDevPasswordId /* passwordId */)
  98         override {
  99         return Void();
 100     }
 101     Return<void> onGoNegotiationCompleted(
 102         ISupplicantP2pIfaceCallback::P2pStatusCode /* status */) override {
 103         return Void();
 104     }
 105     Return<void> onGroupFormationSuccess() override { return Void(); }
 106     Return<void> onGroupFormationFailure(
 107         const hidl_string& /* failureReason */) override {
 108         return Void();
 109     }
 110     Return<void> onGroupStarted(
 111         const hidl_string& /* groupIfname */, bool /* isGo */,
 112         const hidl_vec<uint8_t>& /* ssid */, uint32_t /* frequency */,
 113         const hidl_array<uint8_t, 32>& /* psk */,
 114         const hidl_string& /* passphrase */,
 115         const hidl_array<uint8_t, 6>& /* goDeviceAddress */,
 116         bool /* isPersistent */) override {
 117         return Void();
 118     }
 119     Return<void> onGroupRemoved(const hidl_string& /* groupIfname */,
 120                                 bool /* isGo */) override {
 121         return Void();
 122     }
 123     Return<void> onInvitationReceived(
 124         const hidl_array<uint8_t, 6>& /* srcAddress */,
 125         const hidl_array<uint8_t, 6>& /* goDeviceAddress */,
 126         const hidl_array<uint8_t, 6>& /* bssid */,
 127         uint32_t /* persistentNetworkId */,
 128         uint32_t /* operatingFrequency */) override {
 129         return Void();
 130     }
 131     Return<void> onInvitationResult(
 132         const hidl_array<uint8_t, 6>& /* bssid */,
 133         ISupplicantP2pIfaceCallback::P2pStatusCode /* status */) override {
 134         return Void();
 135     }
 136     Return<void> onProvisionDiscoveryCompleted(
 137         const hidl_array<uint8_t, 6>& /* p2pDeviceAddress */,
 138         bool /* isRequest */,
 139         ISupplicantP2pIfaceCallback::P2pProvDiscStatusCode /* status */,
 140         uint16_t /* configMethods */,
 141         const hidl_string& /* generatedPin */) override {
 142         return Void();
 143     }
 144     Return<void> onServiceDiscoveryResponse(
 145         const hidl_array<uint8_t, 6>& /* srcAddress */,
 146         uint16_t /* updateIndicator */,
 147         const hidl_vec<uint8_t>& /* tlvs */) override {
 148         return Void();
 149     }
 150     Return<void> onStaAuthorized(
 151         const hidl_array<uint8_t, 6>& /* srcAddress */,
 152         const hidl_array<uint8_t, 6>& /* p2pDeviceAddress */) override {
 153         return Void();
 154     }
 155     Return<void> onStaDeauthorized(
 156         const hidl_array<uint8_t, 6>& /* srcAddress */,
 157         const hidl_array<uint8_t, 6>& /* p2pDeviceAddress */) override {
 158         return Void();
 159     }
 160 };
 161
 162 /*
 163  * Create:
 164  * Ensures that an instance of the ISupplicantP2pIface proxy object is
 165  * successfully created.
 166  */
 167 TEST(SupplicantP2pIfaceHidlTestNoFixture, Create) {
 168     startSupplicantAndWaitForHidlService();
 169     EXPECT_NE(nullptr, getSupplicantP2pIface().get());
 170     stopSupplicant();
 171 }
 172
 173 /*
 174  * RegisterCallback
 175  */
 176 TEST_F(SupplicantP2pIfaceHidlTest, RegisterCallback) {
 177     p2p_iface_->registerCallback(
 178         new IfaceCallback(), [](const SupplicantStatus& status) {
 179             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
 180         });
 181 }
 182
 183 /*
 184  * GetName
 185  */
 186 TEST_F(SupplicantP2pIfaceHidlTest, GetName) {
 187     const auto& status_and_interface_name = HIDL_INVOKE(p2p_iface_, getName);
 188     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
 189               status_and_interface_name.first.code);
 190     EXPECT_FALSE(std::string(status_and_interface_name.second).empty());
 191 }
 192
 193 /*
 194  * GetType
 195  */
 196 TEST_F(SupplicantP2pIfaceHidlTest, GetType) {
 197     const auto& status_and_interface_type = HIDL_INVOKE(p2p_iface_, getType);
 198     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
 199               status_and_interface_type.first.code);
 200     EXPECT_EQ(status_and_interface_type.second, IfaceType::P2P);
 201 }
 202
 203 /*
 204  * GetDeviceAddress
 205  */
 206 TEST_F(SupplicantP2pIfaceHidlTest, GetDeviceAddress) {
 207     p2p_iface_->getDeviceAddress(
 208         [](const SupplicantStatus& status,
 209            const hidl_array<uint8_t, 6>& /* mac_addr */) {
 210             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
 211         });
 212 }
 213
 214 /*
 215  * SetSsidPostfix
 216  */
 217 TEST_F(SupplicantP2pIfaceHidlTest, SetSsidPostfix) {
 218     std::vector<uint8_t> ssid(kTestSsidPostfix,
 219                               kTestSsidPostfix + sizeof(kTestSsidPostfix));
 220     p2p_iface_->setSsidPostfix(ssid, [](const SupplicantStatus& status) {
 221         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
 222     });
 223 }
 224
 225 /*
 226  * Find
 227  */
 228 TEST_F(SupplicantP2pIfaceHidlTest, Find) {
 229     p2p_iface_->find(kTestFindTimeout, [](const SupplicantStatus& status) {
 230         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
 231     });
 232 }
 233
 234 /*
 235  * StopFind
 236  */
 237 TEST_F(SupplicantP2pIfaceHidlTest, StopFind) {
 238     p2p_iface_->find(kTestFindTimeout, [](const SupplicantStatus& status) {
 239         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
 240     });
 241
 242     p2p_iface_->stopFind([](const SupplicantStatus& status) {
 243         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
 244     });
 245 }
 246
 247 /*
 248  * Flush
 249  */
 250 TEST_F(SupplicantP2pIfaceHidlTest, Flush) {
 251     p2p_iface_->flush([](const SupplicantStatus& status) {
 252         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
 253     });
 254 }
 255
 256 /*
 257  * Connect
 258  */
 259 TEST_F(SupplicantP2pIfaceHidlTest, Connect) {
 260     p2p_iface_->connect(
 261         mac_addr_, ISupplicantP2pIface::WpsProvisionMethod::PBC,
 262         kTestConnectPin, false, false, kTestConnectGoIntent,
 263         [](const SupplicantStatus& status, const hidl_string& /* pin */) {
 264             // This is not going to work with fake values.
 265             EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code);
 266         });
 267 }
 268
 269 /*
 270  * CancelConnect
 271  */
 272 TEST_F(SupplicantP2pIfaceHidlTest, CancelConnect) {
 273     p2p_iface_->connect(
 274         mac_addr_, ISupplicantP2pIface::WpsProvisionMethod::PBC,
 275         kTestConnectPin, false, false, kTestConnectGoIntent,
 276         [](const SupplicantStatus& status, const hidl_string& /* pin */) {
 277             // This is not going to work with fake values.
 278             EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code);
 279         });
 280
 281     p2p_iface_->cancelConnect([](const SupplicantStatus& status) {
 282         EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code);
 283     });
 284 }
 285
 286 /*
 287  * ProvisionDiscovery
 288  */
 289 TEST_F(SupplicantP2pIfaceHidlTest, ProvisionDiscovery) {
 290     p2p_iface_->provisionDiscovery(
 291         mac_addr_, ISupplicantP2pIface::WpsProvisionMethod::PBC,
 292         [](const SupplicantStatus& status) {
 293             // This is not going to work with fake values.
 294             EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code);
 295         });
 296 }
 297
 298 /*
 299  * AddGroup
 300  */
 301 TEST_F(SupplicantP2pIfaceHidlTest, AddGroup) {
 302     p2p_iface_->addGroup(false, kTestNetworkId,
 303                          [](const SupplicantStatus& /* status */) {
 304                              // TODO: Figure out the initialization sequence for
 305                              // this to work.
 306                              // EXPECT_EQ(SupplicantStatusCode::SUCCESS,
 307                              // status.code);
 308                          });
 309 }
 310
 311 /*
 312  * Reject
 313  */
 314 TEST_F(SupplicantP2pIfaceHidlTest, Reject) {
 315     p2p_iface_->reject(mac_addr_, [](const SupplicantStatus& status) {
 316         // This is not going to work with fake values.
 317         EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code);
 318     });
 319 }
 320
 321 /*
 322  * Invite
 323  */
 324 TEST_F(SupplicantP2pIfaceHidlTest, Invite) {
 325     p2p_iface_->invite(kTestGroupIfName, mac_addr_, peer_mac_addr_,
 326                        [](const SupplicantStatus& status) {
 327                            // This is not going to work with fake values.
 328                            EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN,
 329                                      status.code);
 330                        });
 331 }
 332
 333 /*
 334  * Reinvoke
 335  */
 336 TEST_F(SupplicantP2pIfaceHidlTest, Reinvoke) {
 337     p2p_iface_->reinvoke(
 338         kTestNetworkId, mac_addr_, [](const SupplicantStatus& status) {
 339             // This is not going to work with fake values.
 340             EXPECT_EQ(SupplicantStatusCode::FAILURE_NETWORK_UNKNOWN,
 341                       status.code);
 342         });
 343 }
 344
 345 /*
 346  * ConfigureExtListen
 347  */
 348 TEST_F(SupplicantP2pIfaceHidlTest, ConfigureExtListen) {
 349     p2p_iface_->configureExtListen(kTestExtListenPeriod, kTestExtListenInterval,
 350                                    [](const SupplicantStatus& status) {
 351                                        EXPECT_EQ(SupplicantStatusCode::SUCCESS,
 352                                                  status.code);
 353                                    });
 354 }
 355
 356 /*
 357  * SetListenChannel
 358  */
 359 TEST_F(SupplicantP2pIfaceHidlTest, SetListenChannel) {
 360     p2p_iface_->setListenChannel(
 361         kTestChannel, kTestOperatingClass, [](const SupplicantStatus& status) {
 362             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
 363         });
 364 }
 365
 366 /*
 367  * SetDisallowedFrequencies
 368  */
 369 TEST_F(SupplicantP2pIfaceHidlTest, SetDisallowedFrequencies) {
 370     std::vector<ISupplicantP2pIface::FreqRange> ranges = {
 371         {kTestFreqRange[0], kTestFreqRange[1]}};
 372     p2p_iface_->setDisallowedFrequencies(
 373         ranges, [](const SupplicantStatus& status) {
 374             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
 375         });
 376 }
 377
 378 /*
 379  * GetSsid
 380  */
 381 TEST_F(SupplicantP2pIfaceHidlTest, GetSsid) {
 382     std::array<uint8_t, 6> mac_addr;
 383     memcpy(mac_addr.data(), kTestMacAddr, mac_addr.size());
 384     p2p_iface_->getSsid(mac_addr, [](const SupplicantStatus& status,
 385                                      const hidl_vec<uint8_t>& /* ssid */) {
 386         // This is not going to work with fake values.
 387         EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code);
 388     });
 389 }
 390
 391 /*
 392  * GetGroupCapability
 393  */
 394 TEST_F(SupplicantP2pIfaceHidlTest, GetGroupCapability) {
 395     std::array<uint8_t, 6> mac_addr;
 396     memcpy(mac_addr.data(), kTestMacAddr, mac_addr.size());
 397     p2p_iface_->getGroupCapability(
 398         mac_addr, [](const SupplicantStatus& status, uint32_t /* caps */) {
 399             // This is not going to work with fake values.
 400             EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code);
 401         });
 402 }
 403
 404 /*
 405  * FlushServices
 406  */
 407 TEST_F(SupplicantP2pIfaceHidlTest, FlushServices) {
 408     p2p_iface_->flushServices([](const SupplicantStatus& status) {
 409         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
 410     });
 411 }
 412
 413 /*
 414  * SetMiracastMode
 415  */
 416 TEST_F(SupplicantP2pIfaceHidlTest, SetMiracastMode) {
 417     p2p_iface_->setMiracastMode(ISupplicantP2pIface::MiracastMode::DISABLED,
 418                                 [](const SupplicantStatus& status) {
 419                                     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
 420                                               status.code);
 421                                 });
 422     p2p_iface_->setMiracastMode(ISupplicantP2pIface::MiracastMode::SOURCE,
 423                                 [](const SupplicantStatus& status) {
 424                                     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
 425                                               status.code);
 426                                 });
 427     p2p_iface_->setMiracastMode(ISupplicantP2pIface::MiracastMode::SINK,
 428                                 [](const SupplicantStatus& status) {
 429                                     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
 430                                               status.code);
 431                                 });
 432 }
 433
 434 /*
 435  * SetGroupIdle
 436  */
 437 TEST_F(SupplicantP2pIfaceHidlTest, SetGroupIdle) {
 438     // This is not going to work with fake values.
 439     EXPECT_NE(SupplicantStatusCode::SUCCESS,
 440               HIDL_INVOKE(p2p_iface_, setGroupIdle, kTestGroupIfName,
 441                           kTestSetGroupIdleTimeout)
 442                   .code);
 443 }
 444
 445 /*
 446  * SetPowerSave
 447  */
 448 TEST_F(SupplicantP2pIfaceHidlTest, SetPowerSave) {
 449     // This is not going to work with fake values.
 450     EXPECT_NE(
 451         SupplicantStatusCode::SUCCESS,
 452         HIDL_INVOKE(p2p_iface_, setPowerSave, kTestGroupIfName, true).code);
 453     // This is not going to work with fake values.
 454     EXPECT_NE(
 455         SupplicantStatusCode::SUCCESS,
 456         HIDL_INVOKE(p2p_iface_, setPowerSave, kTestGroupIfName, false).code);
 457 }