Merge "CTS: Add tests for RssiCurve" into rvc-dev
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 0000000..c6bc077
--- /dev/null
+++ b/tests/cts/net/src/android/net/cts/IpConfigurationTest.java
@@ -0,0 +1,123 @@
+/*
+ * 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 com.android.testutils.ParcelUtilsKt.assertParcelSane;
+
+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 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<InetAddress> 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.setStaticIpConfiguration(mStaticIpConfig);
+ ipConfig.setHttpProxy(mProxy);
+
+ ipConfig.setIpAssignment(IpConfiguration.IpAssignment.STATIC);
+ ipConfig.setProxySettings(IpConfiguration.ProxySettings.PAC);
+ assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig));
+
+ ipConfig.setIpAssignment(IpConfiguration.IpAssignment.STATIC);
+ ipConfig.setProxySettings(IpConfiguration.ProxySettings.STATIC);
+ assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig));
+
+ ipConfig.setIpAssignment(IpConfiguration.IpAssignment.DHCP);
+ ipConfig.setProxySettings(IpConfiguration.ProxySettings.PAC);
+ assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig));
+
+ ipConfig.setIpAssignment(IpConfiguration.IpAssignment.DHCP);
+ ipConfig.setProxySettings(IpConfiguration.ProxySettings.PAC);
+ assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig));
+
+ ipConfig.setIpAssignment(IpConfiguration.IpAssignment.DHCP);
+ ipConfig.setProxySettings(IpConfiguration.ProxySettings.STATIC);
+ assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig));
+
+ ipConfig.setIpAssignment(IpConfiguration.IpAssignment.DHCP);
+ ipConfig.setProxySettings(IpConfiguration.ProxySettings.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 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());
+ }
+
+ @Test
+ public void testParcel() {
+ final IpConfiguration config = new IpConfiguration();
+ assertParcelSane(config, 4);
+ }
+}
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 29f091b..8f23324 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.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 @@
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 3153149..4cbdf62 100644
--- a/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java
+++ b/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java
@@ -1403,13 +1403,13 @@
mWifiManager.setSoftApConfiguration(targetConfig);
// Bssid set dodesn't support for tethered hotspot
SoftApConfiguration currentConfig = mWifiManager.getSoftApConfiguration();
- assertNull(currentConfig.getBssid());
compareSoftApConfiguration(targetConfig, currentConfig);
}
private void compareSoftApConfiguration(SoftApConfiguration currentConfig,
SoftApConfiguration testSoftApConfig) {
assertEquals(currentConfig.getSsid(), testSoftApConfig.getSsid());
+ assertEquals(currentConfig.getBssid(), testSoftApConfig.getBssid());
assertEquals(currentConfig.getSecurityType(), testSoftApConfig.getSecurityType());
assertEquals(currentConfig.getPassphrase(), testSoftApConfig.getPassphrase());
assertEquals(currentConfig.isHiddenSsid(), testSoftApConfig.isHiddenSsid());
diff --git a/tests/cts/net/src/android/net/wifi/cts/WifiNetworkSpecifierTest.java b/tests/cts/net/src/android/net/wifi/cts/WifiNetworkSpecifierTest.java
index 83018fa..eb6d684 100644
--- a/tests/cts/net/src/android/net/wifi/cts/WifiNetworkSpecifierTest.java
+++ b/tests/cts/net/src/android/net/wifi/cts/WifiNetworkSpecifierTest.java
@@ -363,13 +363,17 @@
testConnectionFlowWithSpecifier(specifier, true);
}
+ private static String removeDoubleQuotes(String string) {
+ return WifiInfo.sanitizeSsid(string);
+ }
+
private WifiNetworkSpecifier.Builder createSpecifierBuilderWithCredentialFromSavedNetwork() {
WifiNetworkSpecifier.Builder specifierBuilder = new WifiNetworkSpecifier.Builder();
if (mTestNetwork.preSharedKey != null) {
if (mTestNetwork.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_PSK)) {
- specifierBuilder.setWpa2Passphrase(mTestNetwork.preSharedKey);
+ specifierBuilder.setWpa2Passphrase(removeDoubleQuotes(mTestNetwork.preSharedKey));
} else if (mTestNetwork.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.SAE)) {
- specifierBuilder.setWpa3Passphrase(mTestNetwork.preSharedKey);
+ specifierBuilder.setWpa3Passphrase(removeDoubleQuotes(mTestNetwork.preSharedKey));
} else {
fail("Unsupported security type found in saved networks");
}
@@ -391,7 +395,7 @@
return;
}
WifiNetworkSpecifier specifier = createSpecifierBuilderWithCredentialFromSavedNetwork()
- .setSsid(WifiInfo.sanitizeSsid(mTestNetwork.SSID))
+ .setSsid(removeDoubleQuotes(mTestNetwork.SSID))
.build();
testSuccessfulConnectionWithSpecifier(specifier);
}
@@ -406,7 +410,7 @@
}
// Creates a ssid pattern by dropping the last char in the saved network & pass that
// as a prefix match pattern in the request.
- String ssidUnquoted = WifiInfo.sanitizeSsid(mTestNetwork.SSID);
+ String ssidUnquoted = removeDoubleQuotes(mTestNetwork.SSID);
assertThat(ssidUnquoted.length()).isAtLeast(2);
String ssidPrefix = ssidUnquoted.substring(0, ssidUnquoted.length() - 1);
// Note: The match may return more than 1 network in this case since we use a prefix match,
@@ -460,7 +464,7 @@
List<ScanResult> scanResults = mWifiManager.getScanResults();
if (scanResults == null || scanResults.isEmpty()) fail("No scan results available");
for (ScanResult scanResult : scanResults) {
- if (TextUtils.equals(scanResult.SSID, WifiInfo.sanitizeSsid(mTestNetwork.SSID))) {
+ if (TextUtils.equals(scanResult.SSID, removeDoubleQuotes(mTestNetwork.SSID))) {
return scanResult;
}
}
@@ -511,7 +515,7 @@
return;
}
WifiNetworkSpecifier specifier = createSpecifierBuilderWithCredentialFromSavedNetwork()
- .setSsid(WifiInfo.sanitizeSsid(mTestNetwork.SSID))
+ .setSsid(removeDoubleQuotes(mTestNetwork.SSID))
.build();
testUserRejectionWithSpecifier(specifier);
}
@@ -526,11 +530,11 @@
return;
}
WifiNetworkSpecifier specifier1 = new WifiNetworkSpecifier.Builder()
- .setSsid(WifiInfo.sanitizeSsid(mTestNetwork.SSID))
+ .setSsid(removeDoubleQuotes(mTestNetwork.SSID))
.setWpa2EnterpriseConfig(new WifiEnterpriseConfig())
.build();
WifiNetworkSpecifier specifier2 = new WifiNetworkSpecifier.Builder()
- .setSsid(WifiInfo.sanitizeSsid(mTestNetwork.SSID))
+ .setSsid(removeDoubleQuotes(mTestNetwork.SSID))
.setWpa2EnterpriseConfig(new WifiEnterpriseConfig())
.build();
assertThat(specifier1.satisfiedBy(specifier2)).isTrue();
@@ -546,11 +550,11 @@
return;
}
WifiNetworkSpecifier specifier1 = new WifiNetworkSpecifier.Builder()
- .setSsid(WifiInfo.sanitizeSsid(mTestNetwork.SSID))
+ .setSsid(removeDoubleQuotes(mTestNetwork.SSID))
.setWpa3EnterpriseConfig(new WifiEnterpriseConfig())
.build();
WifiNetworkSpecifier specifier2 = new WifiNetworkSpecifier.Builder()
- .setSsid(WifiInfo.sanitizeSsid(mTestNetwork.SSID))
+ .setSsid(removeDoubleQuotes(mTestNetwork.SSID))
.setWpa3EnterpriseConfig(new WifiEnterpriseConfig())
.build();
assertThat(specifier1.satisfiedBy(specifier2)).isTrue();
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 25a90b5..49aa47e 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 @@
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 @@
// 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 @@
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<RangingResult> 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<RangingResult> rangingResults = callback.getResults();
+ assertNotNull("Wi-Fi RTT results: null results", rangingResults);
+ assertEquals("Invalid peerHandle should return 0 result", 0, rangingResults.size());
+ }
}