LineageOS/android_packages_modules_Connectivity
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Snap for 6329815 from eb6e8795ec16bb756e44c8188f16898402255f37 to rvc-release

Browse Source 
Change-Id: I19c9b92b8ee3d1dac6e5fba41efb91962158c440
This commit is contained in:
android-build-team Robot
2020-03-25 02:10:39 +00:00
parent c9b0f6a71f f5b3082156
commit ab897ab95c
4 changed files with 234 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

151
tests/cts/net/src/android/net/cts/IpConfigurationTest.java Normal file
View File

@@ -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<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 = 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());
}
}

43
tests/cts/net/src/android/net/wifi/aware/cts/SingleDeviceTest.java
View File

@@ -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() {

4
tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java
View File

@@ -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();

37
tests/cts/net/src/android/net/wifi/rtt/cts/WifiRttTest.java
View File

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