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 package com.android.server.wifi.p2p;
18 
19 import static org.junit.Assert.assertEquals;
20 import static org.junit.Assert.assertFalse;
21 import static org.junit.Assert.assertTrue;
22 import static org.mockito.ArgumentMatchers.any;
23 import static org.mockito.ArgumentMatchers.anyBoolean;
24 import static org.mockito.ArgumentMatchers.anyInt;
25 import static org.mockito.ArgumentMatchers.anyString;
26 import static org.mockito.ArgumentMatchers.eq;
27 import static org.mockito.Mockito.doAnswer;
28 import static org.mockito.Mockito.verify;
29 import static org.mockito.Mockito.when;
30 
31 import android.app.test.MockAnswerUtil.AnswerWithArguments;
32 import android.net.wifi.WifiManager;
33 import android.net.wifi.nl80211.WifiNl80211Manager;
34 import android.net.wifi.p2p.WifiP2pConfig;
35 import android.net.wifi.p2p.WifiP2pDevice;
36 import android.net.wifi.p2p.WifiP2pGroup;
37 import android.net.wifi.p2p.WifiP2pGroupList;
38 import android.net.wifi.p2p.WifiP2pManager;
39 import android.net.wifi.p2p.nsd.WifiP2pDnsSdServiceInfo;
40 import android.net.wifi.p2p.nsd.WifiP2pServiceInfo;
41 import android.os.Handler;
42 
43 import androidx.test.filters.SmallTest;
44 
45 import com.android.server.wifi.HalDeviceManager;
46 import com.android.server.wifi.PropertyService;
47 import com.android.server.wifi.WifiBaseTest;
48 import com.android.server.wifi.WifiNative;
49 import com.android.server.wifi.WifiVendorHal;
50 
51 import org.junit.Before;
52 import org.junit.Test;
53 import org.mockito.ArgumentCaptor;
54 import org.mockito.Mock;
55 import org.mockito.MockitoAnnotations;
56 
57 import java.util.Collections;
58 import java.util.HashSet;
59 import java.util.Set;
60 
61 /**
62  * Unit tests for {@link com.android.server.wifi.WifiP2pMonitor}.
63  */
64 @SmallTest
65 public class WifiP2pNativeTest extends WifiBaseTest {
66 
67     private static final String TEST_DEVICE_NAME = "Android_HelloWorld";
68     private static final String TEST_IFACE = "p2p-p2p0-1";
69     private static final String TEST_BSSID = "de:ad:be:ef:01:02";
70     private static final String TEST_PIN = "12345678";
71     private static final String TEST_DEVICE_TYPE = "12-1234abcd-08";
72     private static final String TEST_WPS_CONFIG = "usba label display push_button keypad";
73     private static final String TEST_SSID_POSTFIX = "NiceBoat";
74     private static final int TEST_IDLE_TIME = 10;
75     private static final String TEST_NETWORK_NAME = "DIRECT-xy-NiceBoat";
76     private static final String TEST_PASSPHRASE = "DeadEnd!";
77     private static final int TEST_GROUP_FREQ = 5400;
78     private static final String TEST_WFD_DEVICE_INFO = "deadbeef";
79     private static final int TEST_P2P_FIND_TIMEOUT = 120;
80     private static final String TEST_SERVICE_DISCOVERY_IDENTIFIER = "identifier";
81     private static final String TEST_SERVICE_DISCOVERY_QUERY = "query";
82     private static final String TEST_NFC_REQUEST_MSG = "request";
83     private static final String TEST_NFC_SELECT_MSG = "select";
84     private static final String TEST_CLIENT_LIST = "aa:bb:cc:dd:ee:ff 11:22:33:44:55:66";
85 
86     @Mock private WifiNl80211Manager mWifiCondManager;
87     @Mock private WifiNative mWifiNative;
88     @Mock private WifiVendorHal mWifiVendorHalMock;
89     @Mock private SupplicantP2pIfaceHal mSupplicantP2pIfaceHalMock;
90     @Mock private HalDeviceManager mHalDeviceManagerMock;
91     @Mock private PropertyService mPropertyServiceMock;
92     @Mock private Handler mHandler;
93 
94     private WifiP2pNative mWifiP2pNative;
95     private WifiP2pGroupList mWifiP2pGroupList = new WifiP2pGroupList();
96     private Set<String> mWifiClientInterfaceNames = new HashSet<String>();
97 
createP2pGroup( int networkId, String networkName, String passphrase, boolean isGo, String goAddr)98     private WifiP2pGroup createP2pGroup(
99             int networkId, String networkName, String passphrase, boolean isGo, String goAddr) {
100         WifiP2pGroup group = new WifiP2pGroup();
101         group.setNetworkId(networkId);
102         group.setNetworkName(networkName);
103         group.setPassphrase(passphrase);
104         group.setIsGroupOwner(isGo);
105         group.setOwner(new WifiP2pDevice(goAddr));
106         return group;
107     }
108 
109     @Before
setUp()110     public void setUp() throws Exception {
111         MockitoAnnotations.initMocks(this);
112 
113         mWifiClientInterfaceNames.add("wlan0");
114         mWifiClientInterfaceNames.add("wlan1");
115 
116         mWifiP2pNative = new WifiP2pNative(
117                 mWifiCondManager,
118                 mWifiNative,
119                 mWifiVendorHalMock,
120                 mSupplicantP2pIfaceHalMock,
121                 mHalDeviceManagerMock,
122                 mPropertyServiceMock);
123 
124         when(mWifiNative.getClientInterfaceNames()).thenReturn(mWifiClientInterfaceNames);
125 
126         mWifiP2pGroupList.add(
127                 createP2pGroup(1, "testGroup1", "passphrase", true, "aa:bb:cc:dd:ee:f0"));
128         mWifiP2pGroupList.add(
129                 createP2pGroup(2, "testGroup2", "passphrase", false, "aa:bb:cc:dd:ee:f0"));
130         mWifiP2pGroupList.add(
131                 createP2pGroup(3, "testGroup3", "passphrase", true, "aa:bb:cc:dd:ee:aa"));
132         mWifiP2pGroupList.add(
133                 createP2pGroup(4, "testGroup4", "passphrase", true, "aa:bb:cc:dd:ee:bb"));
134 
135         // setup default mock behaviors
136         when(mHalDeviceManagerMock.isSupported()).thenReturn(true);
137 
138         doAnswer(new AnswerWithArguments() {
139                 public boolean answer(WifiP2pGroupList groupList) {
140                     for (WifiP2pGroup g : mWifiP2pGroupList.getGroupList()) {
141                         groupList.add(g);
142                     }
143                     return true;
144                 }
145         }).when(mSupplicantP2pIfaceHalMock).loadGroups(any());
146 
147     }
148 
149     /**
150      * Verifies that isHalInterfaceSupported returns correct values.
151      */
152     @Test
testIsHalInterfaceSupported()153     public void testIsHalInterfaceSupported() {
154         assertTrue(mWifiP2pNative.isHalInterfaceSupported());
155 
156         when(mHalDeviceManagerMock.isSupported()).thenReturn(false);
157         assertFalse(mWifiP2pNative.isHalInterfaceSupported());
158     }
159 
160     /**
161      * Verifies that the device name can be set.
162      */
163     @Test
testSetDeviceName()164     public void testSetDeviceName() {
165         when(mSupplicantP2pIfaceHalMock.setWpsDeviceName(anyString())).thenReturn(true);
166         assertTrue(mWifiP2pNative.setDeviceName(TEST_DEVICE_NAME));
167         verify(mSupplicantP2pIfaceHalMock).setWpsDeviceName(eq(TEST_DEVICE_NAME));
168     }
169 
170     /**
171      * Verifies that the device name can be set.
172      */
173     @Test
testSetP2pDeviceName()174     public void testSetP2pDeviceName() {
175         when(mSupplicantP2pIfaceHalMock.setWpsDeviceName(anyString())).thenReturn(true);
176         assertTrue(mWifiP2pNative.setP2pDeviceName(TEST_DEVICE_NAME));
177         verify(mSupplicantP2pIfaceHalMock).setWpsDeviceName(eq(TEST_DEVICE_NAME));
178     }
179 
180     /**
181      * Verifies that networks could be listed.
182      */
183     @Test
testP2pListNetworks()184     public void testP2pListNetworks() {
185         WifiP2pGroupList groupList = new WifiP2pGroupList();
186         assertTrue(mWifiP2pNative.p2pListNetworks(groupList));
187 
188         verify(mSupplicantP2pIfaceHalMock).loadGroups(any(WifiP2pGroupList.class));
189         assertEquals(mWifiP2pGroupList.toString(), groupList.toString());
190     }
191 
192     /**
193      * Verifies that WPS PBC starts without errors.
194      */
195     @Test
testStartWpsPbc()196     public void testStartWpsPbc() {
197         when(mSupplicantP2pIfaceHalMock.startWpsPbc(anyString(), anyString())).thenReturn(true);
198         assertTrue(mWifiP2pNative.startWpsPbc(TEST_IFACE, TEST_BSSID));
199         verify(mSupplicantP2pIfaceHalMock).startWpsPbc(eq(TEST_IFACE), eq(TEST_BSSID));
200     }
201 
202     /**
203      * Verifies that WPS Pin/Keypad starts without errors.
204      */
205     @Test
testStartWpsPinKeypad()206     public void testStartWpsPinKeypad() {
207         when(mSupplicantP2pIfaceHalMock.startWpsPinKeypad(anyString(), anyString()))
208                 .thenReturn(true);
209         assertTrue(mWifiP2pNative.startWpsPinKeypad(TEST_IFACE, TEST_PIN));
210         verify(mSupplicantP2pIfaceHalMock).startWpsPinKeypad(eq(TEST_IFACE), eq(TEST_PIN));
211     }
212 
213     /**
214      * Verifies that WPS Pin/Display starts without errors.
215      */
216     @Test
testStartWpsPinDisplay()217     public void testStartWpsPinDisplay() {
218         when(mSupplicantP2pIfaceHalMock.startWpsPinDisplay(anyString(), anyString()))
219                 .thenReturn(TEST_PIN);
220         assertEquals(TEST_PIN, mWifiP2pNative.startWpsPinDisplay(TEST_IFACE, TEST_BSSID));
221         verify(mSupplicantP2pIfaceHalMock).startWpsPinDisplay(eq(TEST_IFACE), eq(TEST_BSSID));
222     }
223 
224     /**
225      * Verifies removing a network.
226      */
227     @Test
testP2pRemoveNetwork()228     public void testP2pRemoveNetwork() {
229         when(mSupplicantP2pIfaceHalMock.removeNetwork(anyInt())).thenReturn(true);
230         assertTrue(mWifiP2pNative.removeP2pNetwork(1));
231         verify(mSupplicantP2pIfaceHalMock).removeNetwork(eq(1));
232     }
233 
234     /**
235      * Verifies setting the device type.
236      */
237     @Test
testSetP2pDeviceType()238     public void testSetP2pDeviceType() {
239         when(mSupplicantP2pIfaceHalMock.setWpsDeviceType(anyString())).thenReturn(true);
240         assertTrue(mWifiP2pNative.setP2pDeviceType(TEST_DEVICE_TYPE));
241         verify(mSupplicantP2pIfaceHalMock).setWpsDeviceType(eq(TEST_DEVICE_TYPE));
242     }
243 
244     /**
245      * Verifies setting WPS config method.
246      */
247     @Test
testSetConfigMethods()248     public void testSetConfigMethods() {
249         when(mSupplicantP2pIfaceHalMock.setWpsConfigMethods(anyString())).thenReturn(true);
250         assertTrue(mWifiP2pNative.setConfigMethods(TEST_WPS_CONFIG));
251         verify(mSupplicantP2pIfaceHalMock).setWpsConfigMethods(eq(TEST_WPS_CONFIG));
252     }
253 
254     /**
255      * Verifies setting SSID postfix.
256      */
257     @Test
testSetP2pSsidPostfix()258     public void testSetP2pSsidPostfix() {
259         when(mSupplicantP2pIfaceHalMock.setSsidPostfix(anyString())).thenReturn(true);
260         assertTrue(mWifiP2pNative.setP2pSsidPostfix(TEST_SSID_POSTFIX));
261         verify(mSupplicantP2pIfaceHalMock).setSsidPostfix(eq(TEST_SSID_POSTFIX));
262     }
263 
264     /**
265      * Verifies setting group idle time.
266      */
267     @Test
testSetP2pGroupIdle()268     public void testSetP2pGroupIdle() {
269         when(mSupplicantP2pIfaceHalMock.setGroupIdle(anyString(), anyInt())).thenReturn(true);
270         assertTrue(mWifiP2pNative.setP2pGroupIdle(TEST_IFACE, TEST_IDLE_TIME));
271         verify(mSupplicantP2pIfaceHalMock).setGroupIdle(eq(TEST_IFACE), eq(TEST_IDLE_TIME));
272     }
273 
274     /**
275      * Verifies setting power save mode.
276      */
277     @Test
testSetP2pPowerSave()278     public void testSetP2pPowerSave() {
279         when(mSupplicantP2pIfaceHalMock.setPowerSave(anyString(), anyBoolean())).thenReturn(true);
280         assertTrue(mWifiP2pNative.setP2pPowerSave(TEST_IFACE, true));
281         verify(mSupplicantP2pIfaceHalMock).setPowerSave(eq(TEST_IFACE), eq(true));
282     }
283 
284     /**
285      * Verifies enabling Wifi Display.
286      */
287     @Test
testSetWfdEnable()288     public void testSetWfdEnable() {
289         when(mSupplicantP2pIfaceHalMock.enableWfd(anyBoolean())).thenReturn(true);
290         assertTrue(mWifiP2pNative.setWfdEnable(true));
291         verify(mSupplicantP2pIfaceHalMock).enableWfd(eq(true));
292     }
293 
294     /**
295      * Verifies setting WFD info.
296      */
297     @Test
testSetWfdDeviceInfo()298     public void testSetWfdDeviceInfo() {
299         when(mSupplicantP2pIfaceHalMock.setWfdDeviceInfo(anyString())).thenReturn(true);
300         assertTrue(mWifiP2pNative.setWfdDeviceInfo(TEST_WFD_DEVICE_INFO));
301         verify(mSupplicantP2pIfaceHalMock).setWfdDeviceInfo(eq(TEST_WFD_DEVICE_INFO));
302     }
303 
304     /**
305      * Verifies initiating a P2P service discovery indefinitely.
306      */
307     @Test
testP2pFindIndefinitely()308     public void testP2pFindIndefinitely() {
309         when(mSupplicantP2pIfaceHalMock.find(anyInt())).thenReturn(true);
310         assertTrue(mWifiP2pNative.p2pFind());
311         verify(mSupplicantP2pIfaceHalMock).find(eq(0));
312     }
313 
314     /**
315      * Verifies initiating a P2P service discovery with timeout.
316      */
317     @Test
testP2pFindWithTimeout()318     public void testP2pFindWithTimeout() {
319         when(mSupplicantP2pIfaceHalMock.find(anyInt())).thenReturn(true);
320         assertTrue(mWifiP2pNative.p2pFind(TEST_P2P_FIND_TIMEOUT));
321         verify(mSupplicantP2pIfaceHalMock).find(eq(TEST_P2P_FIND_TIMEOUT));
322     }
323 
324     /**
325      * Verifies stopping a P2P service discovery.
326      */
327     @Test
testP2pStopFind()328     public void testP2pStopFind() {
329         when(mSupplicantP2pIfaceHalMock.stopFind()).thenReturn(true);
330         assertTrue(mWifiP2pNative.p2pStopFind());
331         verify(mSupplicantP2pIfaceHalMock).stopFind();
332     }
333 
334     /**
335      * Verifies configuring extended listen timing.
336      */
337     @Test
testP2pExtListen()338     public void testP2pExtListen() {
339         when(mSupplicantP2pIfaceHalMock.configureExtListen(anyBoolean(), anyInt(), anyInt()))
340                 .thenReturn(true);
341         assertTrue(mWifiP2pNative.p2pExtListen(true, 10000, 20000));
342         verify(mSupplicantP2pIfaceHalMock).configureExtListen(eq(true), eq(10000), eq(20000));
343     }
344 
345     /**
346      * Verifies setting p2p listen channel.
347      */
348     @Test
testP2pSetListenChannel()349     public void testP2pSetListenChannel() {
350         when(mSupplicantP2pIfaceHalMock.setListenChannel(anyInt()))
351                 .thenReturn(true);
352         assertTrue(mWifiP2pNative.p2pSetListenChannel(1));
353         verify(mSupplicantP2pIfaceHalMock).setListenChannel(eq(1));
354     }
355 
356     /**
357      * Verifies setting p2p operating channel.
358      */
359     @Test
testP2pSetOperatingChannel()360     public void testP2pSetOperatingChannel() {
361         when(mSupplicantP2pIfaceHalMock.setOperatingChannel(anyInt(), any()))
362                 .thenReturn(true);
363         assertTrue(mWifiP2pNative.p2pSetOperatingChannel(65, Collections.emptyList()));
364         verify(mSupplicantP2pIfaceHalMock).setOperatingChannel(eq(65), any());
365     }
366 
367     /**
368      * Verifies flushing P2P peer table and state.
369      */
370     @Test
testP2pFlush()371     public void testP2pFlush() {
372         when(mSupplicantP2pIfaceHalMock.flush()).thenReturn(true);
373         assertTrue(mWifiP2pNative.p2pFlush());
374         verify(mSupplicantP2pIfaceHalMock).flush();
375     }
376 
377     /**
378      * Verifies starting p2p group formation.
379      */
380     @Test
testP2pConnect()381     public void testP2pConnect() {
382         WifiP2pConfig config = new WifiP2pConfig();
383         config.deviceAddress = TEST_BSSID;
384         mWifiP2pNative.p2pConnect(config, true);
385         ArgumentCaptor<WifiP2pConfig> configCaptor = ArgumentCaptor.forClass(WifiP2pConfig.class);
386         verify(mSupplicantP2pIfaceHalMock).connect(configCaptor.capture(), eq(true));
387         // there is no equals operator for WifiP2pConfig.
388         assertEquals(config.toString(), configCaptor.getValue().toString());
389     }
390 
391     /**
392      * Verifies cancelling an ongoing P2P group formation and joining-a-group related operation.
393      */
394     @Test
testP2pCancelConnect()395     public void testP2pCancelConnect() {
396         when(mSupplicantP2pIfaceHalMock.cancelConnect()).thenReturn(true);
397         assertTrue(mWifiP2pNative.p2pCancelConnect());
398         verify(mSupplicantP2pIfaceHalMock).cancelConnect();
399     }
400 
401     /**
402      * Verifies sending P2P provision discovery request to the specified peer.
403      */
404     @Test
testP2pProvisionDiscovery()405     public void testP2pProvisionDiscovery() {
406         when(mSupplicantP2pIfaceHalMock.provisionDiscovery(any(WifiP2pConfig.class)))
407                 .thenReturn(true);
408         WifiP2pConfig config = new WifiP2pConfig();
409         config.deviceAddress = TEST_BSSID;
410         assertTrue(mWifiP2pNative.p2pProvisionDiscovery(config));
411         ArgumentCaptor<WifiP2pConfig> configCaptor =
412                 ArgumentCaptor.forClass(WifiP2pConfig.class);
413         verify(mSupplicantP2pIfaceHalMock).provisionDiscovery(configCaptor.capture());
414         // there is no equals operator for WifiP2pConfig.
415         assertEquals(config.toString(), configCaptor.getValue().toString());
416     }
417 
418     /**
419      * Verifies joining p2p group.
420      */
421     @Test
testJoinGroup()422     public void testJoinGroup() {
423         when(mSupplicantP2pIfaceHalMock.groupAdd(anyBoolean())).thenReturn(true);
424         assertTrue(mWifiP2pNative.p2pGroupAdd(true));
425         verify(mSupplicantP2pIfaceHalMock).groupAdd(eq(true));
426     }
427 
428     /**
429      * Verifies joining p2p group with network id.
430      */
431     @Test
testJoinGroupWithNetworkId()432     public void testJoinGroupWithNetworkId() {
433         when(mSupplicantP2pIfaceHalMock.groupAdd(anyInt(), anyBoolean())).thenReturn(true);
434         assertTrue(mWifiP2pNative.p2pGroupAdd(5));
435         verify(mSupplicantP2pIfaceHalMock).groupAdd(eq(5), eq(true));
436     }
437 
438     /**
439      * Verifies joining p2p group with config.
440      */
441     @Test
testJoinGroupWithConfig()442     public void testJoinGroupWithConfig() {
443         when(mSupplicantP2pIfaceHalMock.groupAdd(
444                 anyString(), anyString(), anyBoolean(),
445                 anyInt(), anyString(), anyBoolean())).thenReturn(true);
446         WifiP2pConfig config = new WifiP2pConfig.Builder()
447                 .setNetworkName(TEST_NETWORK_NAME)
448                 .setPassphrase(TEST_PASSPHRASE)
449                 .enablePersistentMode(true)
450                 .setGroupOperatingFrequency(TEST_GROUP_FREQ)
451                 .build();
452         assertTrue(mWifiP2pNative.p2pGroupAdd(config, true));
453 
454         for (String intf: mWifiClientInterfaceNames) {
455             verify(mWifiCondManager).abortScan(eq(intf));
456         }
457 
458         verify(mSupplicantP2pIfaceHalMock).groupAdd(
459                 eq(TEST_NETWORK_NAME),
460                 eq(TEST_PASSPHRASE),
461                 eq(true),
462                 eq(TEST_GROUP_FREQ),
463                 eq(config.deviceAddress),
464                 eq(true));
465     }
466 
467     /**
468      * Verifies removing p2p group.
469      */
470     @Test
testP2pGroupRemove()471     public void testP2pGroupRemove() {
472         when(mSupplicantP2pIfaceHalMock.groupRemove(anyString())).thenReturn(true);
473         assertTrue(mWifiP2pNative.p2pGroupRemove(TEST_IFACE));
474         verify(mSupplicantP2pIfaceHalMock).groupRemove(eq(TEST_IFACE));
475     }
476 
477     /**
478      * Verifies rejecting a connection attemp.
479      */
480     @Test
testP2pReject()481     public void testP2pReject() {
482         when(mSupplicantP2pIfaceHalMock.reject(anyString())).thenReturn(true);
483         assertTrue(mWifiP2pNative.p2pReject(TEST_BSSID));
484         verify(mSupplicantP2pIfaceHalMock).reject(eq(TEST_BSSID));
485     }
486 
487     /**
488      * Verifies inviting a peer to a group.
489      */
490     @Test
testP2pInvite()491     public void testP2pInvite() {
492         when(mSupplicantP2pIfaceHalMock.invite(any(WifiP2pGroup.class), anyString()))
493                 .thenReturn(true);
494         WifiP2pGroup group = new WifiP2pGroup();
495         assertTrue(mWifiP2pNative.p2pInvite(group, TEST_BSSID));
496         ArgumentCaptor<WifiP2pGroup> groupCaptor = ArgumentCaptor.forClass(WifiP2pGroup.class);
497         verify(mSupplicantP2pIfaceHalMock).invite(groupCaptor.capture(), eq(TEST_BSSID));
498         // no equals operator for WifiP2pGroup.
499         assertEquals(group.toString(), groupCaptor.getValue().toString());
500     }
501 
502     /**
503      * Verifies reinvoking a device from a persiste group..
504      */
505     @Test
testP2pReinvoke()506     public void testP2pReinvoke() {
507         when(mSupplicantP2pIfaceHalMock.reinvoke(anyInt(), anyString())).thenReturn(true);
508         assertTrue(mWifiP2pNative.p2pReinvoke(5, TEST_BSSID));
509         verify(mSupplicantP2pIfaceHalMock).reinvoke(eq(5), eq(TEST_BSSID));
510     }
511 
512     /**
513      * Verifies getting the operational SSID of the device.
514      */
515     @Test
testP2pGetSsid()516     public void testP2pGetSsid() {
517         when(mSupplicantP2pIfaceHalMock.getSsid(anyString())).thenReturn(TEST_NETWORK_NAME);
518         assertEquals(TEST_NETWORK_NAME, mWifiP2pNative.p2pGetSsid(TEST_BSSID));
519         verify(mSupplicantP2pIfaceHalMock).getSsid(eq(TEST_BSSID));
520     }
521 
522     /**
523      * Verifies getting the MAC address of the device.
524      */
525     @Test
testP2pGetDeviceAddress()526     public void testP2pGetDeviceAddress() {
527         when(mSupplicantP2pIfaceHalMock.getDeviceAddress()).thenReturn(TEST_BSSID);
528         assertEquals(TEST_BSSID, mWifiP2pNative.p2pGetDeviceAddress());
529         verify(mSupplicantP2pIfaceHalMock).getDeviceAddress();
530     }
531 
532     /**
533      * Verifies getting the group capabilities.
534      */
535     @Test
testGetGroupCapability()536     public void testGetGroupCapability() {
537         when(mSupplicantP2pIfaceHalMock.getGroupCapability(anyString())).thenReturn(0x156);
538         assertEquals(0x156, mWifiP2pNative.getGroupCapability(TEST_BSSID));
539         verify(mSupplicantP2pIfaceHalMock).getGroupCapability(eq(TEST_BSSID));
540     }
541 
542     /**
543      * Verifies adding a service..
544      */
545     @Test
testP2pServiceAdd()546     public void testP2pServiceAdd() {
547         when(mSupplicantP2pIfaceHalMock.serviceAdd(any(WifiP2pServiceInfo.class)))
548                 .thenReturn(true);
549         WifiP2pServiceInfo info =
550                 WifiP2pDnsSdServiceInfo.newInstance("MyPrinter", "_ipp._tcp", null);
551         assertTrue(mWifiP2pNative.p2pServiceAdd(info));
552         verify(mSupplicantP2pIfaceHalMock).serviceAdd(eq(info));
553     }
554 
555     /**
556      * Verifies deleting a service..
557      */
558     @Test
testP2pServiceDel()559     public void testP2pServiceDel() {
560         when(mSupplicantP2pIfaceHalMock.serviceRemove(any(WifiP2pServiceInfo.class)))
561                 .thenReturn(true);
562         WifiP2pServiceInfo info =
563                 WifiP2pDnsSdServiceInfo.newInstance("MyPrinter", "_ipp._tcp", null);
564         assertTrue(mWifiP2pNative.p2pServiceDel(info));
565         verify(mSupplicantP2pIfaceHalMock).serviceRemove(eq(info));
566     }
567 
568     /**
569      * Verifies flushing p2p services in this device.
570      */
571     @Test
testP2pServiceFlush()572     public void testP2pServiceFlush() {
573         when(mSupplicantP2pIfaceHalMock.serviceFlush()).thenReturn(true);
574         assertTrue(mWifiP2pNative.p2pServiceFlush());
575         verify(mSupplicantP2pIfaceHalMock).serviceFlush();
576     }
577 
578     /**
579      * Verifies scheduling a P2P service discovery request.
580      */
581     @Test
testP2pServDiscReq()582     public void testP2pServDiscReq() {
583         when(mSupplicantP2pIfaceHalMock.requestServiceDiscovery(anyString(), anyString()))
584                 .thenReturn(TEST_SERVICE_DISCOVERY_IDENTIFIER);
585         assertEquals(TEST_SERVICE_DISCOVERY_IDENTIFIER,
586                 mWifiP2pNative.p2pServDiscReq(TEST_BSSID, TEST_SERVICE_DISCOVERY_QUERY));
587         verify(mSupplicantP2pIfaceHalMock)
588                 .requestServiceDiscovery(eq(TEST_BSSID), eq(TEST_SERVICE_DISCOVERY_QUERY));
589     }
590 
591     /**
592      * Verifies canceling a p2p service discovery request.
593      */
594     @Test
testP2pServDiscCancelReq()595     public void testP2pServDiscCancelReq() {
596         when(mSupplicantP2pIfaceHalMock.cancelServiceDiscovery(anyString())).thenReturn(true);
597         assertTrue(mWifiP2pNative.p2pServDiscCancelReq(
598                 TEST_SERVICE_DISCOVERY_IDENTIFIER));
599         verify(mSupplicantP2pIfaceHalMock).cancelServiceDiscovery(
600                 TEST_SERVICE_DISCOVERY_IDENTIFIER);
601     }
602 
603     /**
604      * Verifies setting miracast mode.
605      */
606     @Test
testSetMiracastMode()607     public void testSetMiracastMode() {
608         mWifiP2pNative.setMiracastMode(WifiP2pManager.MIRACAST_SOURCE);
609         verify(mSupplicantP2pIfaceHalMock).setMiracastMode(eq(WifiP2pManager.MIRACAST_SOURCE));
610     }
611 
612     /**
613      * Verifies getting NFC handover request message.
614      */
615     @Test
testGetNfcHandoverRequest()616     public void testGetNfcHandoverRequest() {
617         when(mSupplicantP2pIfaceHalMock.getNfcHandoverRequest())
618                 .thenReturn(TEST_NFC_REQUEST_MSG);
619         assertEquals(TEST_NFC_REQUEST_MSG, mWifiP2pNative.getNfcHandoverRequest());
620         verify(mSupplicantP2pIfaceHalMock).getNfcHandoverRequest();
621     }
622 
623     /**
624      * Verifies getting NFC handover select message.
625      */
626     @Test
testGetNfcHandoverSelect()627     public void testGetNfcHandoverSelect() {
628         when(mSupplicantP2pIfaceHalMock.getNfcHandoverSelect())
629                 .thenReturn(TEST_NFC_SELECT_MSG);
630         assertEquals(TEST_NFC_SELECT_MSG, mWifiP2pNative.getNfcHandoverSelect());
631         verify(mSupplicantP2pIfaceHalMock).getNfcHandoverSelect();
632     }
633 
634     /**
635      * Verifies reporting NFC handover select message.
636      */
637     @Test
testInitiatorReportNfcHandover()638     public void testInitiatorReportNfcHandover() {
639         when(mSupplicantP2pIfaceHalMock.initiatorReportNfcHandover(anyString()))
640                 .thenReturn(true);
641         assertTrue(mWifiP2pNative.initiatorReportNfcHandover(TEST_NFC_SELECT_MSG));
642         verify(mSupplicantP2pIfaceHalMock).initiatorReportNfcHandover(eq(TEST_NFC_SELECT_MSG));
643     }
644 
645     /**
646      * Verifies reporting NFC handover request message.
647      */
648     @Test
testResponderReportNfcHandover()649     public void testResponderReportNfcHandover() {
650         when(mSupplicantP2pIfaceHalMock.responderReportNfcHandover(anyString()))
651                 .thenReturn(true);
652         assertTrue(mWifiP2pNative.responderReportNfcHandover(TEST_NFC_REQUEST_MSG));
653         verify(mSupplicantP2pIfaceHalMock).responderReportNfcHandover(eq(TEST_NFC_REQUEST_MSG));
654     }
655 
656     /**
657      * Verifies getting client list.
658      */
659     @Test
testGetP2pClientList()660     public void testGetP2pClientList() {
661         when(mSupplicantP2pIfaceHalMock.getClientList(anyInt()))
662                 .thenReturn(TEST_CLIENT_LIST);
663         assertEquals(TEST_CLIENT_LIST, mWifiP2pNative.getP2pClientList(5));
664         verify(mSupplicantP2pIfaceHalMock).getClientList(eq(5));
665     }
666 
667     /**
668      * Verifies setting client list.
669      */
670     @Test
testSetP2pClientList()671     public void testSetP2pClientList() {
672         when(mSupplicantP2pIfaceHalMock.setClientList(anyInt(), anyString()))
673                 .thenReturn(true);
674         assertTrue(mWifiP2pNative.setP2pClientList(5, TEST_CLIENT_LIST));
675         verify(mSupplicantP2pIfaceHalMock).setClientList(eq(5), eq(TEST_CLIENT_LIST));
676     }
677 
678     /**
679      * Verifies saving p2p config.
680      */
681     @Test
testSaveConfig()682     public void testSaveConfig() {
683         when(mSupplicantP2pIfaceHalMock.saveConfig())
684                 .thenReturn(true);
685         assertTrue(mWifiP2pNative.saveConfig());
686         verify(mSupplicantP2pIfaceHalMock).saveConfig();
687     }
688 
689     /**
690      * Verifies enabling MAC randomization.
691      */
692     @Test
testSetMacRandomization()693     public void testSetMacRandomization() {
694         when(mSupplicantP2pIfaceHalMock.setMacRandomization(anyBoolean()))
695                 .thenReturn(true);
696         assertTrue(mWifiP2pNative.setMacRandomization(true));
697         verify(mSupplicantP2pIfaceHalMock).setMacRandomization(eq(true));
698     }
699 
700     /**
701      * Verifies getting supported feature set.
702      */
703     @Test
testGetSupportedFeatureSet()704     public void testGetSupportedFeatureSet() {
705         when(mWifiVendorHalMock.getSupportedFeatureSet(anyString()))
706                 .thenReturn(WifiManager.WIFI_FEATURE_P2P_RAND_MAC);
707         assertEquals(WifiManager.WIFI_FEATURE_P2P_RAND_MAC,
708                 mWifiP2pNative.getSupportedFeatureSet(TEST_IFACE));
709         verify(mWifiVendorHalMock).getSupportedFeatureSet(eq(TEST_IFACE));
710     }
711 }
712