From a3b321401a2ba06f37817d534b1cf20977638d4a Mon Sep 17 00:00:00 2001 From: Jimmy Chen Date: Tue, 10 Mar 2020 16:14:30 +0800 Subject: [PATCH 1/5] Wifi: add CTS tests for WifiP2pManager Bug: 150979686 Bug: 150979837 Test: atest android.net.wifi.cts.ConcurrencyTest Change-Id: Id9c18ae602be23cbcc5d9c605c27b10424e1d1d9 --- .../android/net/wifi/cts/ConcurrencyTest.java | 300 +++++++++++++++--- 1 file changed, 260 insertions(+), 40 deletions(-) diff --git a/tests/cts/net/src/android/net/wifi/cts/ConcurrencyTest.java b/tests/cts/net/src/android/net/wifi/cts/ConcurrencyTest.java index ba0832f8b6..f7ea750d18 100644 --- a/tests/cts/net/src/android/net/wifi/cts/ConcurrencyTest.java +++ b/tests/cts/net/src/android/net/wifi/cts/ConcurrencyTest.java @@ -30,15 +30,22 @@ import android.net.NetworkCapabilities; import android.net.NetworkInfo; import android.net.NetworkRequest; import android.net.wifi.WifiManager; +import android.net.wifi.p2p.WifiP2pDevice; +import android.net.wifi.p2p.WifiP2pGroupList; +import android.net.wifi.p2p.WifiP2pInfo; import android.net.wifi.p2p.WifiP2pManager; +import android.net.wifi.p2p.nsd.WifiP2pServiceInfo; +import android.net.wifi.p2p.nsd.WifiP2pUpnpServiceInfo; import android.provider.Settings; import android.platform.test.annotations.AppModeFull; import android.test.AndroidTestCase; import android.util.Log; +import com.android.compatibility.common.util.ShellIdentityUtils; import com.android.compatibility.common.util.SystemUtil; import java.util.Arrays; +import java.util.ArrayList; import java.util.BitSet; import java.util.LinkedList; import java.util.List; @@ -69,6 +76,9 @@ public class ConcurrencyTest extends AndroidTestCase { public int p2pState; public int discoveryState; public NetworkInfo networkInfo; + public WifiP2pInfo p2pInfo; + public String deviceName; + public WifiP2pGroupList persistentGroups; } private WifiManager mWifiManager; @@ -76,6 +86,7 @@ public class ConcurrencyTest extends AndroidTestCase { private WifiP2pManager.Channel mWifiP2pChannel; private MySync mMySync = new MySync(); private MyResponse mMyResponse = new MyResponse(); + private boolean mWasVerboseLoggingEnabled; private static final String TAG = "ConcurrencyTest"; private static final int TIMEOUT_MSEC = 6000; @@ -119,6 +130,27 @@ public class ConcurrencyTest extends AndroidTestCase { } }; + private WifiP2pManager.ActionListener mActionListener = new WifiP2pManager.ActionListener() { + @Override + public void onSuccess() { + synchronized (mMyResponse) { + mMyResponse.valid = true; + mMyResponse.success = true; + mMyResponse.notify(); + } + } + + @Override + public void onFailure(int reason) { + synchronized (mMyResponse) { + Log.d(TAG, "failure reason: " + reason); + mMyResponse.valid = true; + mMyResponse.success = false; + mMyResponse.notify(); + } + } + }; + @Override protected void setUp() throws Exception { super.setUp(); @@ -127,6 +159,7 @@ public class ConcurrencyTest extends AndroidTestCase { // skip the test if WiFi && p2p are not supported return; } + mIntentFilter = new IntentFilter(); mIntentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION); mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION); @@ -140,6 +173,13 @@ public class ConcurrencyTest extends AndroidTestCase { SystemUtil.runShellCommand("svc wifi disable"); Thread.sleep(DURATION); } + + // turn on verbose logging for tests + mWasVerboseLoggingEnabled = ShellIdentityUtils.invokeWithShellPermissions( + () -> mWifiManager.isVerboseLoggingEnabled()); + ShellIdentityUtils.invokeWithShellPermissions( + () -> mWifiManager.setVerboseLoggingEnabled(true)); + assertTrue(!mWifiManager.isWifiEnabled()); mMySync.expectedWifiState = WifiManager.WIFI_STATE_DISABLED; mMySync.expectedP2pState = WifiP2pManager.WIFI_P2P_STATE_DISABLED; @@ -157,6 +197,9 @@ public class ConcurrencyTest extends AndroidTestCase { } mContext.unregisterReceiver(mReceiver); + ShellIdentityUtils.invokeWithShellPermissions( + () -> mWifiManager.setVerboseLoggingEnabled(mWasVerboseLoggingEnabled)); + enableWifi(); super.tearDown(); } @@ -221,6 +264,9 @@ public class ConcurrencyTest extends AndroidTestCase { synchronized (responseObj) { responseObj.valid = false; responseObj.networkInfo = null; + responseObj.p2pInfo = null; + responseObj.deviceName = null; + responseObj.persistentGroups = null; } } @@ -344,26 +390,7 @@ public class ConcurrencyTest extends AndroidTestCase { assertEquals(WifiP2pManager.WIFI_P2P_DISCOVERY_STOPPED, mMyResponse.discoveryState); resetResponse(mMyResponse); - mWifiP2pManager.discoverPeers(mWifiP2pChannel, new WifiP2pManager.ActionListener() { - @Override - public void onSuccess() { - synchronized (mMyResponse) { - mMyResponse.valid = true; - mMyResponse.success = true; - mMyResponse.notify(); - } - } - - @Override - public void onFailure(int reason) { - synchronized (mMyResponse) { - Log.d(TAG, "discoveryPeers failure reason: " + reason); - mMyResponse.valid = true; - mMyResponse.success = false; - mMyResponse.notify(); - } - } - }); + mWifiP2pManager.discoverPeers(mWifiP2pChannel, mActionListener); assertTrue(waitForServiceResponse(mMyResponse)); assertTrue(mMyResponse.success); assertTrue(waitForBroadcasts(MySync.DISCOVERY_STATE)); @@ -411,26 +438,7 @@ public class ConcurrencyTest extends AndroidTestCase { mMySync.expectedNetworkInfo.getDetailedState()); resetResponse(mMyResponse); - mWifiP2pManager.createGroup(mWifiP2pChannel, new WifiP2pManager.ActionListener() { - @Override - public void onSuccess() { - synchronized (mMyResponse) { - mMyResponse.valid = true; - mMyResponse.success = true; - mMyResponse.notify(); - } - } - - @Override - public void onFailure(int reason) { - synchronized (mMyResponse) { - Log.d(TAG, "createGroup failure reason: " + reason); - mMyResponse.valid = true; - mMyResponse.success = false; - mMyResponse.notify(); - } - } - }); + mWifiP2pManager.createGroup(mWifiP2pChannel, mActionListener); assertTrue(waitForServiceResponse(mMyResponse)); assertTrue(mMyResponse.success); assertTrue(waitForBroadcasts(MySync.NETWORK_INFO)); @@ -455,7 +463,219 @@ public class ConcurrencyTest extends AndroidTestCase { assertEquals(NetworkInfo.DetailedState.CONNECTED, mMyResponse.networkInfo.getDetailedState()); + resetResponse(mMyResponse); + mWifiP2pManager.requestConnectionInfo(mWifiP2pChannel, + new WifiP2pManager.ConnectionInfoListener() { + @Override + public void onConnectionInfoAvailable(WifiP2pInfo info) { + synchronized (mMyResponse) { + mMyResponse.valid = true; + mMyResponse.p2pInfo = new WifiP2pInfo(info); + mMyResponse.notify(); + } + } + }); + assertTrue(waitForServiceResponse(mMyResponse)); + assertNotNull(mMyResponse.p2pInfo); + assertTrue(mMyResponse.p2pInfo.groupFormed); + assertTrue(mMyResponse.p2pInfo.isGroupOwner); + mWifiP2pManager.removeGroup(mWifiP2pChannel, null); } + private String getDeviceName() { + resetResponse(mMyResponse); + mWifiP2pManager.requestDeviceInfo(mWifiP2pChannel, + new WifiP2pManager.DeviceInfoListener() { + @Override + public void onDeviceInfoAvailable(WifiP2pDevice wifiP2pDevice) { + synchronized (mMyResponse) { + mMyResponse.deviceName = wifiP2pDevice.deviceName; + mMyResponse.valid = true; + mMyResponse.notify(); + } + } + }); + assertTrue(waitForServiceResponse(mMyResponse)); + return mMyResponse.deviceName; + } + + public void testSetDeviceName() { + if (!setupWifiP2p()) { + return; + } + + String testDeviceName = "test"; + String originalDeviceName = getDeviceName(); + assertNotNull(originalDeviceName); + + ShellIdentityUtils.invokeWithShellPermissions(() -> { + mWifiP2pManager.setDeviceName( + mWifiP2pChannel, testDeviceName, mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + }); + + String currentDeviceName = getDeviceName(); + assertEquals(testDeviceName, currentDeviceName); + + // restore the device name at the end + ShellIdentityUtils.invokeWithShellPermissions(() -> { + mWifiP2pManager.setDeviceName( + mWifiP2pChannel, originalDeviceName, mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + }); + } + + private WifiP2pGroupList getPersistentGroups() { + resetResponse(mMyResponse); + ShellIdentityUtils.invokeWithShellPermissions(() -> { + mWifiP2pManager.requestPersistentGroupInfo(mWifiP2pChannel, + new WifiP2pManager.PersistentGroupInfoListener() { + @Override + public void onPersistentGroupInfoAvailable(WifiP2pGroupList groups) { + synchronized (mMyResponse) { + mMyResponse.persistentGroups = groups; + mMyResponse.valid = true; + mMyResponse.notify(); + } + } + }); + assertTrue(waitForServiceResponse(mMyResponse)); + }); + return mMyResponse.persistentGroups; + } + + public void testPersistentGroupOperation() { + if (!setupWifiP2p()) { + return; + } + + resetResponse(mMyResponse); + mWifiP2pManager.createGroup(mWifiP2pChannel, mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + assertTrue(waitForBroadcasts(MySync.NETWORK_INFO)); + assertNotNull(mMySync.expectedNetworkInfo); + assertEquals(NetworkInfo.DetailedState.CONNECTED, + mMySync.expectedNetworkInfo.getDetailedState()); + + resetResponse(mMyResponse); + mWifiP2pManager.removeGroup(mWifiP2pChannel, mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + + WifiP2pGroupList persistentGroups = getPersistentGroups(); + assertNotNull(persistentGroups); + assertEquals(1, persistentGroups.getGroupList().size()); + + resetResponse(mMyResponse); + final int firstNetworkId = persistentGroups.getGroupList().get(0).getNetworkId(); + ShellIdentityUtils.invokeWithShellPermissions(() -> { + mWifiP2pManager.deletePersistentGroup(mWifiP2pChannel, + firstNetworkId, + mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + }); + + persistentGroups = getPersistentGroups(); + assertNotNull(persistentGroups); + assertEquals(0, persistentGroups.getGroupList().size()); + + resetResponse(mMyResponse); + mWifiP2pManager.createGroup(mWifiP2pChannel, mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + assertTrue(waitForBroadcasts(MySync.NETWORK_INFO)); + assertNotNull(mMySync.expectedNetworkInfo); + assertEquals(NetworkInfo.DetailedState.CONNECTED, + mMySync.expectedNetworkInfo.getDetailedState()); + + resetResponse(mMyResponse); + mWifiP2pManager.removeGroup(mWifiP2pChannel, mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + + resetResponse(mMyResponse); + ShellIdentityUtils.invokeWithShellPermissions(() -> { + mWifiP2pManager.factoryReset(mWifiP2pChannel, mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + }); + + persistentGroups = getPersistentGroups(); + assertNotNull(persistentGroups); + assertEquals(0, persistentGroups.getGroupList().size()); + } + + public void testP2pListening() { + if (!setupWifiP2p()) { + return; + } + + resetResponse(mMyResponse); + ShellIdentityUtils.invokeWithShellPermissions(() -> { + mWifiP2pManager.setWifiP2pChannels(mWifiP2pChannel, 6, 11, mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + }); + + resetResponse(mMyResponse); + ShellIdentityUtils.invokeWithShellPermissions(() -> { + mWifiP2pManager.startListening(mWifiP2pChannel, mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + }); + + resetResponse(mMyResponse); + ShellIdentityUtils.invokeWithShellPermissions(() -> { + mWifiP2pManager.stopListening(mWifiP2pChannel, mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + }); + } + + public void testP2pService() { + if (!setupWifiP2p()) { + return; + } + + // This only store the listener to the WifiP2pManager internal variable, nothing to fail. + mWifiP2pManager.setServiceResponseListener(mWifiP2pChannel, + new WifiP2pManager.ServiceResponseListener() { + @Override + public void onServiceAvailable( + int protocolType, byte[] responseData, WifiP2pDevice srcDevice) { + } + }); + + resetResponse(mMyResponse); + List services = new ArrayList(); + services.add("urn:schemas-upnp-org:service:AVTransport:1"); + services.add("urn:schemas-upnp-org:service:ConnectionManager:1"); + WifiP2pServiceInfo rendererService = WifiP2pUpnpServiceInfo.newInstance( + "6859dede-8574-59ab-9332-123456789011", + "urn:schemas-upnp-org:device:MediaRenderer:1", + services); + mWifiP2pManager.addLocalService(mWifiP2pChannel, + rendererService, + mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + + resetResponse(mMyResponse); + mWifiP2pManager.removeLocalService(mWifiP2pChannel, + rendererService, + mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + + resetResponse(mMyResponse); + mWifiP2pManager.clearLocalServices(mWifiP2pChannel, + mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); + } } From 73f2d68b301094e421f5f9cf9fe986ae2c15b55a Mon Sep 17 00:00:00 2001 From: Jimmy Chen Date: Tue, 10 Mar 2020 16:33:24 +0800 Subject: [PATCH 2/5] Wifi: add CTS tests for WifiP2pWfdInfo Bug: 150979414 Test: atest android.net.wifi.p2p.cts.WifiP2pWfdInfoTest Change-Id: I8537c68ede48a5990695da1261b58bc26d255ef1 --- .../net/wifi/p2p/cts/WifiP2pWfdInfoTest.java | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 tests/cts/net/src/android/net/wifi/p2p/cts/WifiP2pWfdInfoTest.java diff --git a/tests/cts/net/src/android/net/wifi/p2p/cts/WifiP2pWfdInfoTest.java b/tests/cts/net/src/android/net/wifi/p2p/cts/WifiP2pWfdInfoTest.java new file mode 100644 index 0000000000..75df5bf928 --- /dev/null +++ b/tests/cts/net/src/android/net/wifi/p2p/cts/WifiP2pWfdInfoTest.java @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2020 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. + */ + +package android.net.wifi.p2p.cts; + +import android.net.wifi.p2p.WifiP2pWfdInfo; +import android.test.AndroidTestCase; + +public class WifiP2pWfdInfoTest extends AndroidTestCase { + + private final int TEST_DEVICE_TYPE = WifiP2pWfdInfo.DEVICE_TYPE_WFD_SOURCE; + private final boolean TEST_DEVICE_ENABLE_STATUS = true; + private final boolean TEST_SESSION_STATUS = true; + private final int TEST_CONTROL_PORT = 9999; + private final int TEST_MAX_THROUGHPUT = 1024; + private final boolean TEST_CONTENT_PROTECTION_SUPPORTED_STATUS = true; + + public void testWifiP2pWfdInfo() { + WifiP2pWfdInfo info = new WifiP2pWfdInfo(); + + info.setDeviceType(TEST_DEVICE_TYPE); + info.setEnabled(TEST_DEVICE_ENABLE_STATUS); + info.setSessionAvailable(true); + info.setControlPort(TEST_CONTROL_PORT); + info.setMaxThroughput(TEST_MAX_THROUGHPUT); + info.setContentProtectionSupported(true); + + WifiP2pWfdInfo copiedInfo = new WifiP2pWfdInfo(info); + assertEquals(TEST_DEVICE_TYPE, copiedInfo.getDeviceType()); + assertEquals(TEST_DEVICE_ENABLE_STATUS, copiedInfo.isEnabled()); + assertEquals(TEST_SESSION_STATUS, copiedInfo.isSessionAvailable()); + assertEquals(TEST_CONTROL_PORT, copiedInfo.getControlPort()); + assertEquals(TEST_MAX_THROUGHPUT, copiedInfo.getMaxThroughput()); + assertEquals(TEST_CONTENT_PROTECTION_SUPPORTED_STATUS, + copiedInfo.isContentProtectionSupported()); + } +} From 2344863d542963908fc874ea11c6fc16c834bbd6 Mon Sep 17 00:00:00 2001 From: Jimmy Chen Date: Tue, 10 Mar 2020 16:47:15 +0800 Subject: [PATCH 3/5] Wifi: add CTS tests for WifiP2pInfo Bug: 150979333 Test: atest android.net.wifi.p2p.cts.WifiP2pInfoTest Change-Id: Ib62975af468182e79a19bf5ce7125876af26ef7d --- .../net/wifi/p2p/cts/WifiP2pInfoTest.java | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 tests/cts/net/src/android/net/wifi/p2p/cts/WifiP2pInfoTest.java diff --git a/tests/cts/net/src/android/net/wifi/p2p/cts/WifiP2pInfoTest.java b/tests/cts/net/src/android/net/wifi/p2p/cts/WifiP2pInfoTest.java new file mode 100644 index 0000000000..8504f15e43 --- /dev/null +++ b/tests/cts/net/src/android/net/wifi/p2p/cts/WifiP2pInfoTest.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2020 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. + */ + +package android.net.wifi.p2p.cts; + +import android.net.InetAddresses; +import android.net.wifi.p2p.WifiP2pInfo; +import android.test.AndroidTestCase; + +public class WifiP2pInfoTest extends AndroidTestCase { + + public String TEST_GROUP_OWNER_ADDRESS = "192.168.43.1"; + + public void testWifiP2pInfoNoGroup() { + WifiP2pInfo info = new WifiP2pInfo(); + info.groupFormed = false; + + WifiP2pInfo copiedInfo = new WifiP2pInfo(info); + assertEquals(info.groupFormed, copiedInfo.groupFormed); + assertEquals(info.isGroupOwner, copiedInfo.isGroupOwner); + assertEquals(info.groupOwnerAddress, copiedInfo.groupOwnerAddress); + } + + public void testWifiP2pInfoGroupOwner() { + WifiP2pInfo info = new WifiP2pInfo(); + info.groupFormed = true; + info.isGroupOwner = true; + info.groupOwnerAddress = InetAddresses.parseNumericAddress(TEST_GROUP_OWNER_ADDRESS); + + WifiP2pInfo copiedInfo = new WifiP2pInfo(info); + assertEquals(info.groupFormed, copiedInfo.groupFormed); + assertEquals(info.isGroupOwner, copiedInfo.isGroupOwner); + assertEquals(info.groupOwnerAddress, copiedInfo.groupOwnerAddress); + } + + public void testWifiP2pInfoGroupClient() { + WifiP2pInfo info = new WifiP2pInfo(); + info.groupFormed = true; + info.isGroupOwner = false; + info.groupOwnerAddress = InetAddresses.parseNumericAddress(TEST_GROUP_OWNER_ADDRESS); + + WifiP2pInfo copiedInfo = new WifiP2pInfo(info); + assertEquals(info.groupFormed, copiedInfo.groupFormed); + assertEquals(info.isGroupOwner, copiedInfo.isGroupOwner); + assertEquals(info.groupOwnerAddress, copiedInfo.groupOwnerAddress); + } +} From 1ba90ccc4e925d44c01bab0d88b331d3c45c2c88 Mon Sep 17 00:00:00 2001 From: Jimmy Chen Date: Tue, 10 Mar 2020 16:52:19 +0800 Subject: [PATCH 4/5] Wifi: add CTS tests for WifiP2pConfig WpsInfo copy constructor is also covered in WifiP2pConfig copy constructor. Bug: 150978801 Bug: 150973669 Test: android.net.wifi.p2p.cts.WifiP2pConfigTest Change-Id: I3d94ddecb5b6b131117bbf2eebe8057a542e17e5 --- .../net/wifi/p2p/cts/WifiP2pConfigTest.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tests/cts/net/src/android/net/wifi/p2p/cts/WifiP2pConfigTest.java b/tests/cts/net/src/android/net/wifi/p2p/cts/WifiP2pConfigTest.java index ee7e1ed5bf..0a2a2e6779 100644 --- a/tests/cts/net/src/android/net/wifi/p2p/cts/WifiP2pConfigTest.java +++ b/tests/cts/net/src/android/net/wifi/p2p/cts/WifiP2pConfigTest.java @@ -28,6 +28,24 @@ public class WifiP2pConfigTest extends AndroidTestCase { private static final int TEST_OWNER_FREQ = 2447; private static final String TEST_DEVICE_ADDRESS = "aa:bb:cc:dd:ee:ff"; + public void testWifiP2pConfigCopyConstructor() { + WifiP2pConfig config = new WifiP2pConfig.Builder() + .setNetworkName(TEST_NETWORK_NAME) + .setPassphrase(TEST_PASSPHRASE) + .setGroupOperatingBand(TEST_OWNER_BAND) + .setDeviceAddress(MacAddress.fromString(TEST_DEVICE_ADDRESS)) + .enablePersistentMode(true) + .build(); + + WifiP2pConfig copiedConfig = new WifiP2pConfig(config); + + assertEquals(copiedConfig.deviceAddress, TEST_DEVICE_ADDRESS); + assertEquals(copiedConfig.getNetworkName(), TEST_NETWORK_NAME); + assertEquals(copiedConfig.getPassphrase(), TEST_PASSPHRASE); + assertEquals(copiedConfig.getGroupOwnerBand(), TEST_OWNER_BAND); + assertEquals(copiedConfig.getNetworkId(), WifiP2pGroup.NETWORK_ID_PERSISTENT); + } + public void testWifiP2pConfigBuilderForPersist() { WifiP2pConfig config = new WifiP2pConfig.Builder() .setNetworkName(TEST_NETWORK_NAME) From a35ad640dbcffb9b04ea6cc8a6a43ea59cf1439d Mon Sep 17 00:00:00 2001 From: Jimmy Chen Date: Tue, 10 Mar 2020 17:58:07 +0800 Subject: [PATCH 5/5] Wifi: add CTS tests for WifiP2pGroup Bug: 150979638 Test: atest android.net.wifi.cts.ConcurrencyTest Change-Id: I5e9c994129e9eebf7c079c5a064991463afb417d --- .../android/net/wifi/cts/ConcurrencyTest.java | 25 ++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/tests/cts/net/src/android/net/wifi/cts/ConcurrencyTest.java b/tests/cts/net/src/android/net/wifi/cts/ConcurrencyTest.java index f7ea750d18..d91bce8319 100644 --- a/tests/cts/net/src/android/net/wifi/cts/ConcurrencyTest.java +++ b/tests/cts/net/src/android/net/wifi/cts/ConcurrencyTest.java @@ -31,6 +31,7 @@ import android.net.NetworkInfo; import android.net.NetworkRequest; import android.net.wifi.WifiManager; import android.net.wifi.p2p.WifiP2pDevice; +import android.net.wifi.p2p.WifiP2pGroup; import android.net.wifi.p2p.WifiP2pGroupList; import android.net.wifi.p2p.WifiP2pInfo; import android.net.wifi.p2p.WifiP2pManager; @@ -79,6 +80,7 @@ public class ConcurrencyTest extends AndroidTestCase { public WifiP2pInfo p2pInfo; public String deviceName; public WifiP2pGroupList persistentGroups; + public WifiP2pGroup group = new WifiP2pGroup(); } private WifiManager mWifiManager; @@ -267,6 +269,7 @@ public class ConcurrencyTest extends AndroidTestCase { responseObj.p2pInfo = null; responseObj.deviceName = null; responseObj.persistentGroups = null; + responseObj.group = null; } } @@ -480,7 +483,27 @@ public class ConcurrencyTest extends AndroidTestCase { assertTrue(mMyResponse.p2pInfo.groupFormed); assertTrue(mMyResponse.p2pInfo.isGroupOwner); - mWifiP2pManager.removeGroup(mWifiP2pChannel, null); + resetResponse(mMyResponse); + mWifiP2pManager.requestGroupInfo(mWifiP2pChannel, + new WifiP2pManager.GroupInfoListener() { + @Override + public void onGroupInfoAvailable(WifiP2pGroup group) { + synchronized (mMyResponse) { + mMyResponse.group = new WifiP2pGroup(group); + mMyResponse.valid = true; + mMyResponse.notify(); + } + } + }); + assertTrue(waitForServiceResponse(mMyResponse)); + assertNotNull(mMyResponse.group); + assertNotEquals(0, mMyResponse.group.getFrequency()); + assertTrue(mMyResponse.group.getNetworkId() >= 0); + + resetResponse(mMyResponse); + mWifiP2pManager.removeGroup(mWifiP2pChannel, mActionListener); + assertTrue(waitForServiceResponse(mMyResponse)); + assertTrue(mMyResponse.success); } private String getDeviceName() {