1 /*
2  * Copyright (C) 2019, 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 #include <android-base/macros.h>
19 #include <cutils/properties.h>
20 #include <gmock/gmock.h>
21 
22 #undef NAN  // This is weird, NAN is defined in bionic/libc/include/math.h:38
23 #include "wifi_nan_iface.h"
24 
25 #include "mock_interface_tool.h"
26 #include "mock_wifi_feature_flags.h"
27 #include "mock_wifi_iface_util.h"
28 #include "mock_wifi_legacy_hal.h"
29 
30 using testing::NiceMock;
31 using testing::Return;
32 using testing::Test;
33 
34 namespace {
35 constexpr char kIfaceName[] = "mockWlan0";
36 }  // namespace
37 
38 namespace android {
39 namespace hardware {
40 namespace wifi {
41 namespace V1_5 {
42 namespace implementation {
43 
44 using android::hardware::wifi::V1_2::NanDataPathConfirmInd;
45 
CaptureIfaceEventHandlers(const std::string &,iface_util::IfaceEventHandlers in_iface_event_handlers,iface_util::IfaceEventHandlers * out_iface_event_handlers)46 bool CaptureIfaceEventHandlers(
47     const std::string& /* iface_name*/,
48     iface_util::IfaceEventHandlers in_iface_event_handlers,
49     iface_util::IfaceEventHandlers* out_iface_event_handlers) {
50     *out_iface_event_handlers = in_iface_event_handlers;
51     return true;
52 }
53 
54 class MockNanIfaceEventCallback : public IWifiNanIfaceEventCallback {
55    public:
56     MockNanIfaceEventCallback() = default;
57 
58     MOCK_METHOD3(
59         notifyCapabilitiesResponse,
60         Return<void>(uint16_t, const WifiNanStatus&,
61                      const android::hardware::wifi::V1_0::NanCapabilities&));
62     MOCK_METHOD2(notifyEnableResponse,
63                  Return<void>(uint16_t, const WifiNanStatus&));
64     MOCK_METHOD2(notifyConfigResponse,
65                  Return<void>(uint16_t, const WifiNanStatus&));
66     MOCK_METHOD2(notifyDisableResponse,
67                  Return<void>(uint16_t, const WifiNanStatus&));
68     MOCK_METHOD3(notifyStartPublishResponse,
69                  Return<void>(uint16_t, const WifiNanStatus&, uint8_t));
70     MOCK_METHOD2(notifyStopPublishResponse,
71                  Return<void>(uint16_t, const WifiNanStatus&));
72     MOCK_METHOD3(notifyStartSubscribeResponse,
73                  Return<void>(uint16_t, const WifiNanStatus&, uint8_t));
74     MOCK_METHOD2(notifyStopSubscribeResponse,
75                  Return<void>(uint16_t, const WifiNanStatus&));
76     MOCK_METHOD2(notifyTransmitFollowupResponse,
77                  Return<void>(uint16_t, const WifiNanStatus&));
78     MOCK_METHOD2(notifyCreateDataInterfaceResponse,
79                  Return<void>(uint16_t, const WifiNanStatus&));
80     MOCK_METHOD2(notifyDeleteDataInterfaceResponse,
81                  Return<void>(uint16_t, const WifiNanStatus&));
82     MOCK_METHOD3(notifyInitiateDataPathResponse,
83                  Return<void>(uint16_t, const WifiNanStatus&, uint32_t));
84     MOCK_METHOD2(notifyRespondToDataPathIndicationResponse,
85                  Return<void>(uint16_t, const WifiNanStatus&));
86     MOCK_METHOD2(notifyTerminateDataPathResponse,
87                  Return<void>(uint16_t, const WifiNanStatus&));
88     MOCK_METHOD1(eventClusterEvent, Return<void>(const NanClusterEventInd&));
89     MOCK_METHOD1(eventDisabled, Return<void>(const WifiNanStatus&));
90     MOCK_METHOD2(eventPublishTerminated,
91                  Return<void>(uint8_t, const WifiNanStatus&));
92     MOCK_METHOD2(eventSubscribeTerminated,
93                  Return<void>(uint8_t, const WifiNanStatus&));
94     MOCK_METHOD1(eventMatch, Return<void>(const NanMatchInd&));
95     MOCK_METHOD2(eventMatchExpired, Return<void>(uint8_t, uint32_t));
96     MOCK_METHOD1(eventFollowupReceived,
97                  Return<void>(const NanFollowupReceivedInd&));
98     MOCK_METHOD2(eventTransmitFollowup,
99                  Return<void>(uint16_t, const WifiNanStatus&));
100     MOCK_METHOD1(eventDataPathRequest,
101                  Return<void>(const NanDataPathRequestInd&));
102     MOCK_METHOD1(
103         eventDataPathConfirm,
104         Return<void>(
105             const android::hardware::wifi::V1_0::NanDataPathConfirmInd&));
106     MOCK_METHOD1(eventDataPathTerminated, Return<void>(uint32_t));
107     MOCK_METHOD1(eventDataPathConfirm_1_2,
108                  Return<void>(const NanDataPathConfirmInd&));
109     MOCK_METHOD1(eventDataPathScheduleUpdate,
110                  Return<void>(const NanDataPathScheduleUpdateInd&));
111     MOCK_METHOD3(notifyCapabilitiesResponse_1_5,
112                  Return<void>(uint16_t, const WifiNanStatus&,
113                               const NanCapabilities&));
114 };
115 
116 class WifiNanIfaceTest : public Test {
117    protected:
118     legacy_hal::wifi_hal_fn fake_func_table_;
119     std::shared_ptr<NiceMock<wifi_system::MockInterfaceTool>> iface_tool_{
120         new NiceMock<wifi_system::MockInterfaceTool>};
121     std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
122         new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_,
123                                                     fake_func_table_, true)};
124     std::shared_ptr<NiceMock<iface_util::MockWifiIfaceUtil>> iface_util_{
125         new NiceMock<iface_util::MockWifiIfaceUtil>(iface_tool_, legacy_hal_)};
126 };
127 
TEST_F(WifiNanIfaceTest,IfacEventHandlers_OnStateToggleOffOn)128 TEST_F(WifiNanIfaceTest, IfacEventHandlers_OnStateToggleOffOn) {
129     iface_util::IfaceEventHandlers captured_iface_event_handlers = {};
130     EXPECT_CALL(*legacy_hal_,
131                 nanRegisterCallbackHandlers(testing::_, testing::_))
132         .WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
133     EXPECT_CALL(*iface_util_,
134                 registerIfaceEventHandlers(testing::_, testing::_))
135         .WillOnce(testing::Invoke(
136             bind(CaptureIfaceEventHandlers, std::placeholders::_1,
137                  std::placeholders::_2, &captured_iface_event_handlers)));
138     sp<WifiNanIface> nan_iface =
139         new WifiNanIface(kIfaceName, false, legacy_hal_, iface_util_);
140 
141     // Register a mock nan event callback.
142     sp<NiceMock<MockNanIfaceEventCallback>> mock_event_callback{
143         new NiceMock<MockNanIfaceEventCallback>};
144     nan_iface->registerEventCallback(
145         mock_event_callback, [](const WifiStatus& status) {
146             ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
147         });
148     // Ensure that the eventDisabled() function in mock callback will be
149     // invoked.
150     WifiNanStatus expected_nan_status = {
151         NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED, ""};
152     EXPECT_CALL(*mock_event_callback, eventDisabled(expected_nan_status))
153         .Times(1);
154 
155     // Trigger the iface state toggle callback.
156     captured_iface_event_handlers.on_state_toggle_off_on(kIfaceName);
157 }
158 }  // namespace implementation
159 }  // namespace V1_5
160 }  // namespace wifi
161 }  // namespace hardware
162 }  // namespace android
163