From 768315232018eb96fa225cc3858fbc1404b01bfa Mon Sep 17 00:00:00 2001 From: Automerger Merge Worker Date: Fri, 13 Mar 2020 07:13:45 +0000 Subject: [PATCH 1/4] Add IpConfigurationTest for new @SystemApi Add new cts for @SystemApi in IpConfiguration. Bug: 139268426 Bug: 135998869 Test: atest android.net.cts.IpConfigurationTest Change-Id: I942791abbdccc10d0e2a0018339a2ee4f74c7645 Merged-In: I942791abbdccc10d0e2a0018339a2ee4f74c7645 (cherry picked from aosp/1171795) --- .../android/net/cts/IpConfigurationTest.java | 151 ++++++++++++++++++ 1 file changed, 151 insertions(+) create mode 100644 tests/cts/net/src/android/net/cts/IpConfigurationTest.java diff --git a/tests/cts/net/src/android/net/cts/IpConfigurationTest.java b/tests/cts/net/src/android/net/cts/IpConfigurationTest.java new file mode 100644 index 0000000000..21be35142d --- /dev/null +++ b/tests/cts/net/src/android/net/cts/IpConfigurationTest.java @@ -0,0 +1,151 @@ +/* + * Copyright (C) 2019 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.cts; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +import android.net.IpConfiguration; +import android.net.LinkAddress; +import android.net.ProxyInfo; +import android.net.StaticIpConfiguration; + +import androidx.test.runner.AndroidJUnit4; + +import libcore.net.InetAddressUtils; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.net.InetAddress; +import java.util.ArrayList; + +@RunWith(AndroidJUnit4.class) +public final class IpConfigurationTest { + private static final int TYPE_IPASSIGNMENT_STATIC = 0; + private static final int TYPE_IPASSIGNMENT_DHCP = 1; + + private static final int TYPE_PROXY_SETTINGS_NONE = 0; + private static final int TYPE_PROXY_SETTINGS_STATIC = 1; + private static final int TYPE_PROXY_SETTINGS_PAC = 2; + + private static final LinkAddress LINKADDR = new LinkAddress("192.0.2.2/25"); + private static final InetAddress GATEWAY = InetAddressUtils.parseNumericAddress("192.0.2.1"); + private static final InetAddress DNS1 = InetAddressUtils.parseNumericAddress("8.8.8.8"); + private static final InetAddress DNS2 = InetAddressUtils.parseNumericAddress("8.8.4.4"); + private static final String DOMAINS = "example.com"; + + private static final ArrayList dnsServers = new ArrayList<>(); + + private StaticIpConfiguration mStaticIpConfig; + private ProxyInfo mProxy; + + @Before + public void setUp() { + dnsServers.add(DNS1); + dnsServers.add(DNS2); + mStaticIpConfig = new StaticIpConfiguration.Builder() + .setIpAddress(LINKADDR) + .setGateway(GATEWAY) + .setDnsServers(dnsServers) + .setDomains(DOMAINS) + .build(); + + mProxy = ProxyInfo.buildDirectProxy("test", 8888); + } + + @Test + public void testConstructor() { + IpConfiguration ipConfig = new IpConfiguration(); + checkEmpty(ipConfig); + assertIpConfigurationEqual(ipConfig, new IpConfiguration()); + assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig)); + + ipConfig = createIpConfiguration(TYPE_IPASSIGNMENT_STATIC, + TYPE_PROXY_SETTINGS_PAC); + assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig)); + + ipConfig = createIpConfiguration(TYPE_IPASSIGNMENT_STATIC, + TYPE_PROXY_SETTINGS_STATIC); + assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig)); + + ipConfig = createIpConfiguration(TYPE_IPASSIGNMENT_DHCP, + TYPE_PROXY_SETTINGS_PAC); + assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig)); + + ipConfig = createIpConfiguration(TYPE_IPASSIGNMENT_DHCP, + TYPE_PROXY_SETTINGS_STATIC); + assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig)); + + ipConfig = createIpConfiguration(TYPE_IPASSIGNMENT_DHCP, + TYPE_PROXY_SETTINGS_NONE); + assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig)); + } + + private void checkEmpty(IpConfiguration config) { + assertEquals(IpConfiguration.IpAssignment.UNASSIGNED, + config.getIpAssignment().UNASSIGNED); + assertEquals(IpConfiguration.ProxySettings.UNASSIGNED, + config.getProxySettings().UNASSIGNED); + assertNull(config.getStaticIpConfiguration()); + assertNull(config.getHttpProxy()); + } + + private IpConfiguration createIpConfiguration(int ipAssignmentType, + int proxySettingType) { + + final IpConfiguration ipConfig = new IpConfiguration(); + + switch (ipAssignmentType) { + case TYPE_IPASSIGNMENT_STATIC: + ipConfig.setIpAssignment(IpConfiguration.IpAssignment.STATIC); + break; + case TYPE_IPASSIGNMENT_DHCP: + ipConfig.setIpAssignment(IpConfiguration.IpAssignment.DHCP); + break; + default: + throw new IllegalArgumentException("Unknown ip assignment type."); + } + + switch (proxySettingType) { + case TYPE_PROXY_SETTINGS_NONE: + ipConfig.setProxySettings(IpConfiguration.ProxySettings.NONE); + break; + case TYPE_PROXY_SETTINGS_STATIC: + ipConfig.setProxySettings(IpConfiguration.ProxySettings.STATIC); + break; + case TYPE_PROXY_SETTINGS_PAC: + ipConfig.setProxySettings(IpConfiguration.ProxySettings.PAC); + break; + default: + throw new IllegalArgumentException("Unknown proxy setting type."); + } + + ipConfig.setStaticIpConfiguration(mStaticIpConfig); + ipConfig.setHttpProxy(mProxy); + + return ipConfig; + } + + private void assertIpConfigurationEqual(IpConfiguration source, IpConfiguration target) { + assertEquals(source.getIpAssignment(), target.getIpAssignment()); + assertEquals(source.getProxySettings(), target.getProxySettings()); + assertEquals(source.getHttpProxy(), target.getHttpProxy()); + assertEquals(source.getStaticIpConfiguration(), target.getStaticIpConfiguration()); + } +} From 01cb32c3321112472f545a1cffccd3c277f70fbb Mon Sep 17 00:00:00 2001 From: Nate Jiang Date: Mon, 23 Mar 2020 11:47:04 -0700 Subject: [PATCH 2/4] Add test for aware rtt Bug: 150977837 Test: atest WifiRttTest Change-Id: If19b8708fd76df7f0be3fb5b338b4c58d7279402 --- .../android/net/wifi/rtt/cts/WifiRttTest.java | 37 +++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/tests/cts/net/src/android/net/wifi/rtt/cts/WifiRttTest.java b/tests/cts/net/src/android/net/wifi/rtt/cts/WifiRttTest.java index 25a90b55a1..49aa47ec38 100644 --- a/tests/cts/net/src/android/net/wifi/rtt/cts/WifiRttTest.java +++ b/tests/cts/net/src/android/net/wifi/rtt/cts/WifiRttTest.java @@ -18,7 +18,9 @@ package android.net.wifi.rtt.cts; import static org.mockito.Mockito.mock; +import android.net.MacAddress; import android.net.wifi.ScanResult; +import android.net.wifi.aware.PeerHandle; import android.net.wifi.rtt.RangingRequest; import android.net.wifi.rtt.RangingResult; import android.net.wifi.rtt.ResponderLocation; @@ -52,6 +54,9 @@ public class WifiRttTest extends TestBase { // Minimum valid RSSI value private static final int MIN_VALID_RSSI = -100; + // Valid Mac Address + private static final MacAddress MAC = MacAddress.fromString("00:01:02:03:04:05"); + /** * Test Wi-Fi RTT ranging operation: * - Scan for visible APs for the test AP (which is validated to support IEEE 802.11mc) @@ -368,4 +373,36 @@ public class WifiRttTest extends TestBase { assertNotNull("ColocatedBSSID list should be nonNull", responderLocation.getColocatedBssids()); } + + /** + * Verify ranging request with aware peer Mac address and peer handle. + */ + public void testAwareRttWithMacAddress() throws InterruptedException { + RangingRequest request = new RangingRequest.Builder() + .addWifiAwarePeer(MAC).build(); + ResultCallback callback = new ResultCallback(); + mWifiRttManager.startRanging(request, mExecutor, callback); + assertTrue("Wi-Fi RTT results: no callback", + callback.waitForCallback()); + List rangingResults = callback.getResults(); + assertNotNull("Wi-Fi RTT results: null results", rangingResults); + assertEquals(1, rangingResults.size()); + assertEquals(RangingResult.STATUS_FAIL, rangingResults.get(0).getStatus()); + } + + /** + * Verify ranging request with aware peer handle. + */ + public void testAwareRttWithPeerHandle() throws InterruptedException { + PeerHandle peerHandle = mock(PeerHandle.class); + RangingRequest request = new RangingRequest.Builder() + .addWifiAwarePeer(peerHandle).build(); + ResultCallback callback = new ResultCallback(); + mWifiRttManager.startRanging(request, mExecutor, callback); + assertTrue("Wi-Fi RTT results: no callback", + callback.waitForCallback()); + List rangingResults = callback.getResults(); + assertNotNull("Wi-Fi RTT results: null results", rangingResults); + assertEquals("Invalid peerHandle should return 0 result", 0, rangingResults.size()); + } } From 06aec03aba4f3e408f241243db5c6fe6d6e6ad03 Mon Sep 17 00:00:00 2001 From: Nate Jiang Date: Mon, 23 Mar 2020 14:57:59 -0700 Subject: [PATCH 3/4] Add test for WifiAwareNetworkSpecifier and ParcelablePeerHandle Test WifiAwareNetworkSpecifier satisfiedBy API Test ParcelablePeerHandle parcel Bug: 150975738 Bug: 150976784 Test: atest SingleDeviceTest Change-Id: I56f775774557b34935b7781f57c0b6f7b7e4e9b4 --- .../net/wifi/aware/cts/SingleDeviceTest.java | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/tests/cts/net/src/android/net/wifi/aware/cts/SingleDeviceTest.java b/tests/cts/net/src/android/net/wifi/aware/cts/SingleDeviceTest.java index 29f091b8b4..8f233244e8 100644 --- a/tests/cts/net/src/android/net/wifi/aware/cts/SingleDeviceTest.java +++ b/tests/cts/net/src/android/net/wifi/aware/cts/SingleDeviceTest.java @@ -16,7 +16,9 @@ package android.net.wifi.aware.cts; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotEquals; +import static org.mockito.Mockito.mock; import android.content.BroadcastReceiver; import android.content.Context; @@ -30,17 +32,21 @@ import android.net.NetworkRequest; import android.net.wifi.WifiManager; import android.net.wifi.aware.AttachCallback; import android.net.wifi.aware.Characteristics; +import android.net.wifi.aware.DiscoverySession; import android.net.wifi.aware.DiscoverySessionCallback; import android.net.wifi.aware.IdentityChangedListener; +import android.net.wifi.aware.ParcelablePeerHandle; import android.net.wifi.aware.PeerHandle; import android.net.wifi.aware.PublishConfig; import android.net.wifi.aware.PublishDiscoverySession; import android.net.wifi.aware.SubscribeConfig; import android.net.wifi.aware.SubscribeDiscoverySession; import android.net.wifi.aware.WifiAwareManager; +import android.net.wifi.aware.WifiAwareNetworkSpecifier; import android.net.wifi.aware.WifiAwareSession; import android.os.Handler; import android.os.HandlerThread; +import android.os.Parcel; import android.platform.test.annotations.AppModeFull; import android.test.AndroidTestCase; @@ -812,6 +818,43 @@ public class SingleDeviceTest extends AndroidTestCase { session.close(); } + /** + * Test WifiAwareNetworkSpecifier. + */ + public void testWifiAwareNetworkSpecifier() { + DiscoverySession session = mock(DiscoverySession.class); + PeerHandle handle = mock(PeerHandle.class); + WifiAwareNetworkSpecifier networkSpecifier = + new WifiAwareNetworkSpecifier.Builder(session, handle).build(); + assertFalse(networkSpecifier.satisfiedBy(null)); + assertTrue(networkSpecifier.satisfiedBy(networkSpecifier)); + + WifiAwareNetworkSpecifier anotherNetworkSpecifier = + new WifiAwareNetworkSpecifier.Builder(session, handle).setPmk(PMK_VALID).build(); + assertFalse(networkSpecifier.satisfiedBy(anotherNetworkSpecifier)); + } + + /** + * Test ParcelablePeerHandle parcel. + */ + public void testParcelablePeerHandle() { + PeerHandle peerHandle = mock(PeerHandle.class); + ParcelablePeerHandle parcelablePeerHandle = new ParcelablePeerHandle(peerHandle); + Parcel parcelW = Parcel.obtain(); + parcelablePeerHandle.writeToParcel(parcelW, 0); + byte[] bytes = parcelW.marshall(); + parcelW.recycle(); + + Parcel parcelR = Parcel.obtain(); + parcelR.unmarshall(bytes, 0, bytes.length); + parcelR.setDataPosition(0); + ParcelablePeerHandle rereadParcelablePeerHandle = + ParcelablePeerHandle.CREATOR.createFromParcel(parcelR); + + assertEquals(parcelablePeerHandle, rereadParcelablePeerHandle); + assertEquals(parcelablePeerHandle.hashCode(), rereadParcelablePeerHandle.hashCode()); + } + // local utilities private WifiAwareSession attachAndGetSession() { From 6b4a05b47485638d85eeec4633468bd4fbc46bf0 Mon Sep 17 00:00:00 2001 From: Roshan Pius Date: Mon, 23 Mar 2020 15:54:29 -0700 Subject: [PATCH 4/4] WifiManagerTest: Use addNetwork + enableNetwork instead of save WifiManager.save() is an asynchronous operation. This is sometime causing the tests to be flaky (dropShellIdentity occurs while this is being processed). Use the synchronous legacy API's instead for rewinding the effects of factory reset. Bug: 152048238 Test: atest android.net.wifi.cts.WifiManagerTest Change-Id: Ibb0e04cf931511fcda1b1a81fd6eda4583196c2e --- tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java b/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java index 9700ca1a6e..3153149629 100644 --- a/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java +++ b/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java @@ -2183,7 +2183,9 @@ public class WifiManagerTest extends AndroidTestCase { // Restore the original saved networks. if (savedNetworks != null) { for (WifiConfiguration network : savedNetworks) { - mWifiManager.save(network, null); + network.networkId = WifiConfiguration.INVALID_NETWORK_ID; + int networkId = mWifiManager.addNetwork(network); + mWifiManager.enableNetwork(networkId, false); } } uiAutomation.dropShellPermissionIdentity();