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()); + } +} 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() { 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(); 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()); + } }