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

Snap for 6534196 from b0b4b5ed04e4b327f2c852cca408a29d73ae1139 to rvc-release

Browse Source 
Change-Id: I8c9455b4ee0cc7f70c35f8b7cc3a1fc48d4658b2
This commit is contained in:
android-build-team Robot
2020-05-28 01:05:13 +00:00
parent bf80ea3291 64db03e386
commit 783433cd62
7 changed files with 128 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
tests/cts/net/ipsec/AndroidTest.xml
View File

@@ -27,4 +27,7 @@
<option name="package" value="android.net.ipsec.cts" />
<option name="hidden-api-checks" value="false" />
</test>
<object type="module_controller" class="com.android.tradefed.testtype.suite.module.MainlineTestModuleController">
<option name="mainline-module-package-name" value="com.google.android.ipsec" />
</object>
</configuration>

63
tests/cts/net/ipsec/src/android/net/ipsec/ike/cts/IkeSessionPskTest.java
View File

@@ -99,19 +99,17 @@ public class IkeSessionPskTest extends IkeSessionTestBase {
.addInternalAddressRequest(AF_INET6)
.build();
private IkeSessionParams createIkeSessionParams(InetAddress mRemoteAddress) {
return new IkeSessionParams.Builder(sContext)
.setNetwork(mTunNetwork)
.setServerHostname(mRemoteAddress.getHostAddress())
.addSaProposal(SaProposalTest.buildIkeSaProposalWithNormalModeCipher())
.addSaProposal(SaProposalTest.buildIkeSaProposalWithCombinedModeCipher())
.setLocalIdentification(new IkeFqdnIdentification(LOCAL_HOSTNAME))
.setRemoteIdentification(new IkeFqdnIdentification(REMOTE_HOSTNAME))
.setAuthPsk(IKE_PSK)
.build();
}
private IkeSession openIkeSession(IkeSessionParams ikeParams) {
private IkeSession openIkeSessionWithRemoteAddress(InetAddress remoteAddress) {
IkeSessionParams ikeParams =
new IkeSessionParams.Builder(sContext)
.setNetwork(mTunNetwork)
.setServerHostname(remoteAddress.getHostAddress())
.addSaProposal(SaProposalTest.buildIkeSaProposalWithNormalModeCipher())
.addSaProposal(SaProposalTest.buildIkeSaProposalWithCombinedModeCipher())
.setLocalIdentification(new IkeFqdnIdentification(LOCAL_HOSTNAME))
.setRemoteIdentification(new IkeFqdnIdentification(REMOTE_HOSTNAME))
.setAuthPsk(IKE_PSK)
.build();
return new IkeSession(
sContext,
ikeParams,
@@ -122,9 +120,11 @@ public class IkeSessionPskTest extends IkeSessionTestBase {
}
@Test
public void testIkeSessionSetupAndManageChildSas() throws Exception {
public void testIkeSessionSetupAndChildSessionSetupWithTunnelMode() throws Exception {
if (!hasTunnelsFeature()) return;
// Open IKE Session
IkeSession ikeSession = openIkeSession(createIkeSessionParams(mRemoteAddress));
IkeSession ikeSession = openIkeSessionWithRemoteAddress(mRemoteAddress);
int expectedMsgId = 0;
mTunUtils.awaitReqAndInjectResp(
IKE_INIT_SPI,
@@ -165,6 +165,9 @@ public class IkeSessionPskTest extends IkeSessionTestBase {
assertTrue(firstChildConfig.getInternalDnsServers().isEmpty());
assertTrue(firstChildConfig.getInternalDhcpServers().isEmpty());
assertNotNull(mFirstChildSessionCallback.awaitNextCreatedIpSecTransform());
assertNotNull(mFirstChildSessionCallback.awaitNextCreatedIpSecTransform());
// Open additional Child Session
TestChildSessionCallback additionalChildCb = new TestChildSessionCallback();
ikeSession.openChildSession(CHILD_PARAMS, additionalChildCb);
@@ -181,9 +184,12 @@ public class IkeSessionPskTest extends IkeSessionTestBase {
Arrays.asList(EXPECTED_INBOUND_TS), firstChildConfig.getInboundTrafficSelectors());
assertEquals(Arrays.asList(DEFAULT_V4_TS), firstChildConfig.getOutboundTrafficSelectors());
assertTrue(additionalChildConfig.getInternalAddresses().isEmpty());
assertTrue(firstChildConfig.getInternalSubnets().isEmpty());
assertTrue(firstChildConfig.getInternalDnsServers().isEmpty());
assertTrue(firstChildConfig.getInternalDhcpServers().isEmpty());
assertTrue(additionalChildConfig.getInternalSubnets().isEmpty());
assertTrue(additionalChildConfig.getInternalDnsServers().isEmpty());
assertTrue(additionalChildConfig.getInternalDhcpServers().isEmpty());
assertNotNull(additionalChildCb.awaitNextCreatedIpSecTransform());
assertNotNull(additionalChildCb.awaitNextCreatedIpSecTransform());
// Close additional Child Session
ikeSession.closeChildSession(additionalChildCb);
@@ -193,6 +199,8 @@ public class IkeSessionPskTest extends IkeSessionTestBase {
true /* expectedUseEncap */,
hexStringToByteArray(SUCCESS_DELETE_CHILD_RESP));
assertNotNull(additionalChildCb.awaitNextDeletedIpSecTransform());
assertNotNull(additionalChildCb.awaitNextDeletedIpSecTransform());
additionalChildCb.awaitOnClosed();
// Close IKE Session
@@ -203,16 +211,20 @@ public class IkeSessionPskTest extends IkeSessionTestBase {
true /* expectedUseEncap */,
hexStringToByteArray(SUCCESS_DELETE_IKE_RESP));
assertNotNull(mFirstChildSessionCallback.awaitNextDeletedIpSecTransform());
assertNotNull(mFirstChildSessionCallback.awaitNextDeletedIpSecTransform());
mFirstChildSessionCallback.awaitOnClosed();
mIkeSessionCallback.awaitOnClosed();
// TODO: verify IpSecTransform pair is created and deleted
// TODO: verify created and deleted IpSecTransform pair and their directions
}
@Test
public void testIkeSessionKill() throws Exception {
public void testIkeSessionKillWithTunnelMode() throws Exception {
if (!hasTunnelsFeature()) return;
// Open IKE Session
IkeSession ikeSession = openIkeSession(createIkeSessionParams(mRemoteAddress));
IkeSession ikeSession = openIkeSessionWithRemoteAddress(mRemoteAddress);
int expectedMsgId = 0;
mTunUtils.awaitReqAndInjectResp(
IKE_INIT_SPI,
@@ -227,7 +239,6 @@ public class IkeSessionPskTest extends IkeSessionTestBase {
hexStringToByteArray(SUCCESS_IKE_AUTH_RESP));
ikeSession.kill();
mFirstChildSessionCallback.awaitOnClosed();
mIkeSessionCallback.awaitOnClosed();
}
@@ -238,7 +249,7 @@ public class IkeSessionPskTest extends IkeSessionTestBase {
"46B8ECA1E0D72A180000000000000000292022200000000000000024000000080000000E";
// Open IKE Session
IkeSession ikeSession = openIkeSession(createIkeSessionParams(mRemoteAddress));
IkeSession ikeSession = openIkeSessionWithRemoteAddress(mRemoteAddress);
int expectedMsgId = 0;
mTunUtils.awaitReqAndInjectResp(
IKE_INIT_SPI,
@@ -246,6 +257,8 @@ public class IkeSessionPskTest extends IkeSessionTestBase {
false /* expectedUseEncap */,
hexStringToByteArray(ikeInitFailRespHex));
mFirstChildSessionCallback.awaitOnClosed();
IkeException exception = mIkeSessionCallback.awaitOnClosedException();
assertNotNull(exception);
assertTrue(exception instanceof IkeProtocolException);
@@ -254,5 +267,7 @@ public class IkeSessionPskTest extends IkeSessionTestBase {
assertArrayEquals(EXPECTED_PROTOCOL_ERROR_DATA_NONE, protocolException.getErrorData());
}
// TODO(b/148689509): Verify rekey process and handling IKE_AUTH failure
// TODO(b/155821007): Verify rekey process and handling IKE_AUTH failure
// TODO(b/155821007): Test creating transport mode Child SA
}

25
tests/cts/net/ipsec/src/android/net/ipsec/ike/cts/IkeSessionTestBase.java
View File

@@ -20,6 +20,7 @@ import static android.app.AppOpsManager.OP_MANAGE_IPSEC_TUNNELS;
import android.annotation.NonNull;
import android.app.AppOpsManager;
import android.content.Context;
import android.content.pm.PackageManager;
import android.net.ConnectivityManager;
import android.net.InetAddresses;
import android.net.IpSecTransform;
@@ -39,7 +40,6 @@ import android.net.ipsec.ike.exceptions.IkeProtocolException;
import android.os.Binder;
import android.os.ParcelFileDescriptor;
import android.platform.test.annotations.AppModeFull;
import android.util.Log;
import androidx.test.InstrumentationRegistry;
import androidx.test.ext.junit.runners.AndroidJUnit4;
@@ -65,6 +65,13 @@ import java.util.concurrent.TimeUnit;
*
* <p>Subclasses MUST explicitly call #setUpTestNetwork and #tearDownTestNetwork to be able to use
* the test network
*
* <p>All IKE Sessions running in test mode will generate SPIs deterministically. That is to say
* each IKE Session will always generate the same IKE INIT SPI and test vectors are generated based
* on this deterministic IKE SPI. Each test will use different local and remote addresses to avoid
* the case that the next test try to allocate the same SPI before the previous test has released
* it, since SPI resources are not released in testing thread. Similarly, each test MUST use
* different Network instances to avoid sharing the same IkeSocket and hitting IKE SPI collision.
*/
@RunWith(AndroidJUnit4.class)
@AppModeFull(reason = "MANAGE_TEST_NETWORKS permission can't be granted to instant apps")
@@ -116,7 +123,7 @@ abstract class IkeSessionTestBase extends IkeTestBase {
InstrumentationRegistry.getInstrumentation()
.getUiAutomation()
.adoptShellPermissionIdentity();
sTNM = (TestNetworkManager) sContext.getSystemService(Context.TEST_NETWORK_SERVICE);
sTNM = sContext.getSystemService(TestNetworkManager.class);
// Under normal circumstances, the MANAGE_IPSEC_TUNNELS appop would be auto-granted, and
// a standard permission is insufficient. So we shell out the appop, to give us the
@@ -149,10 +156,6 @@ abstract class IkeSessionTestBase extends IkeTestBase {
@After
public void tearDown() throws Exception {
tearDownTestNetwork();
resetNextAvailableAddress(NEXT_AVAILABLE_IP4_ADDR_LOCAL, INITIAL_AVAILABLE_IP4_ADDR_LOCAL);
resetNextAvailableAddress(
NEXT_AVAILABLE_IP4_ADDR_REMOTE, INITIAL_AVAILABLE_IP4_ADDR_REMOTE);
}
void setUpTestNetwork(InetAddress localAddr) throws Exception {
@@ -185,9 +188,8 @@ abstract class IkeSessionTestBase extends IkeTestBase {
pkg, // Package name
opName, // Appop
(allow ? "allow" : "deny")); // Action
Log.d("IKE", "CTS setAppOp cmd " + cmd);
String result = SystemUtil.runShellCommand(cmd);
SystemUtil.runShellCommand(cmd);
}
}
@@ -229,6 +231,7 @@ abstract class IkeSessionTestBase extends IkeTestBase {
}
}
/** Testing callback that allows caller to block current thread until a method get called */
static class TestIkeSessionCallback implements IkeSessionCallback {
private CompletableFuture<IkeSessionConfiguration> mFutureIkeConfig =
new CompletableFuture<>();
@@ -282,6 +285,7 @@ abstract class IkeSessionTestBase extends IkeTestBase {
}
}
/** Testing callback that allows caller to block current thread until a method get called */
static class TestChildSessionCallback implements ChildSessionCallback {
private CompletableFuture<ChildSessionConfiguration> mFutureChildConfig =
new CompletableFuture<>();
@@ -368,6 +372,11 @@ abstract class IkeSessionTestBase extends IkeTestBase {
}
}
/** Package private method to check if device has IPsec tunnels feature */
static boolean hasTunnelsFeature() {
return sContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_IPSEC_TUNNELS);
}
// TODO(b/148689509): Verify IKE Session setup using EAP and digital-signature-based auth
// TODO(b/148689509): Verify hostname based creation

4
tests/cts/net/ipsec/src/android/net/ipsec/ike/cts/IkeTunUtils.java
View File

@@ -121,7 +121,9 @@ public class IkeTunUtils extends TunUtils {
+ " and message ID "
+ expectedMsgId);
}
return null;
throw new IllegalStateException(
"Hit an impossible case where fail() didn't throw an exception");
}
private static boolean isIke(

35
tests/cts/net/src/android/net/cts/DnsResolverTest.java
View File

@@ -86,7 +86,6 @@ public class DnsResolverTest extends AndroidTestCase {
static final int CANCEL_RETRY_TIMES = 5;
static final int QUERY_TIMES = 10;
static final int NXDOMAIN = 3;
static final int PRIVATE_DNS_SETTING_TIMEOUT_MS = 6_000;
private ContentResolver mCR;
private ConnectivityManager mCM;
@@ -107,32 +106,15 @@ public class DnsResolverTest extends AndroidTestCase {
mExecutorInline = (Runnable r) -> r.run();
mCR = getContext().getContentResolver();
mCtsNetUtils = new CtsNetUtils(getContext());
storePrivateDnsSetting();
mCtsNetUtils.storePrivateDnsSetting();
}
@Override
protected void tearDown() throws Exception {
restorePrivateDnsSetting();
mCtsNetUtils.restorePrivateDnsSetting();
super.tearDown();
}
private void storePrivateDnsSetting() {
// Store private DNS setting
mOldMode = Settings.Global.getString(mCR, Settings.Global.PRIVATE_DNS_MODE);
mOldDnsSpecifier = Settings.Global.getString(mCR, Settings.Global.PRIVATE_DNS_SPECIFIER);
}
private void restorePrivateDnsSetting() throws InterruptedException {
// restore private DNS setting
Settings.Global.putString(mCR, Settings.Global.PRIVATE_DNS_MODE, mOldMode);
if ("hostname".equals(mOldMode)) {
Settings.Global.putString(
mCR, Settings.Global.PRIVATE_DNS_SPECIFIER, mOldDnsSpecifier);
mCtsNetUtils.awaitPrivateDnsSetting("restorePrivateDnsSetting timeout",
mCM.getActiveNetwork(), mOldDnsSpecifier, PRIVATE_DNS_SETTING_TIMEOUT_MS, true);
}
}
private static String byteArrayToHexString(byte[] bytes) {
char[] hexChars = new char[bytes.length * 2];
for (int i = 0; i < bytes.length; ++i) {
@@ -416,16 +398,13 @@ public class DnsResolverTest extends AndroidTestCase {
final String msg = "RawQuery " + TEST_NX_DOMAIN + " with private DNS";
// Enable private DNS strict mode and set server to dns.google before doing NxDomain test.
// b/144521720
Settings.Global.putString(mCR, Settings.Global.PRIVATE_DNS_MODE, "hostname");
Settings.Global.putString(mCR,
Settings.Global.PRIVATE_DNS_SPECIFIER, GOOGLE_PRIVATE_DNS_SERVER);
mCtsNetUtils.setPrivateDnsStrictMode(GOOGLE_PRIVATE_DNS_SERVER);
for (Network network : getTestableNetworks()) {
final Network networkForPrivateDns =
(network != null) ? network : mCM.getActiveNetwork();
assertNotNull("Can't find network to await private DNS on", networkForPrivateDns);
mCtsNetUtils.awaitPrivateDnsSetting(msg + " wait private DNS setting timeout",
networkForPrivateDns, GOOGLE_PRIVATE_DNS_SERVER,
PRIVATE_DNS_SETTING_TIMEOUT_MS, true);
networkForPrivateDns, GOOGLE_PRIVATE_DNS_SERVER, true);
final VerifyCancelCallback callback = new VerifyCancelCallback(msg);
mDns.rawQuery(network, TEST_NX_DOMAIN, CLASS_IN, TYPE_AAAA, FLAG_NO_CACHE_LOOKUP,
executor, null, callback);
@@ -688,9 +667,7 @@ public class DnsResolverTest extends AndroidTestCase {
final Network[] testNetworks = getTestableNetworks();
// Set an invalid private DNS server
Settings.Global.putString(mCR, Settings.Global.PRIVATE_DNS_MODE, "hostname");
Settings.Global.putString(mCR,
Settings.Global.PRIVATE_DNS_SPECIFIER, INVALID_PRIVATE_DNS_SERVER);
mCtsNetUtils.setPrivateDnsStrictMode(INVALID_PRIVATE_DNS_SERVER);
final String msg = "Test PrivateDnsBypass " + TEST_DOMAIN;
for (Network network : testNetworks) {
// This test cannot be ran with null network because we need to explicitly pass a
@@ -699,7 +676,7 @@ public class DnsResolverTest extends AndroidTestCase {
// wait for private DNS setting propagating
mCtsNetUtils.awaitPrivateDnsSetting(msg + " wait private DNS setting timeout",
network, INVALID_PRIVATE_DNS_SERVER, PRIVATE_DNS_SETTING_TIMEOUT_MS, false);
network, INVALID_PRIVATE_DNS_SERVER, false);
final CountDownLatch latch = new CountDownLatch(1);
final DnsResolver.Callback<List<InetAddress>> errorCallback =

23
tests/cts/net/src/android/net/cts/MultinetworkApiTest.java
View File

@@ -41,7 +41,6 @@ public class MultinetworkApiTest extends AndroidTestCase {
private static final String TAG = "MultinetworkNativeApiTest";
static final String GOOGLE_PRIVATE_DNS_SERVER = "dns.google";
static final int PRIVATE_DNS_SETTING_TIMEOUT_MS = 2_000;
/**
* @return 0 on success
@@ -69,7 +68,7 @@ public class MultinetworkApiTest extends AndroidTestCase {
mCM = (ConnectivityManager) getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
mCR = getContext().getContentResolver();
mCtsNetUtils = new CtsNetUtils(getContext());
storePrivateDnsSetting();
mCtsNetUtils.storePrivateDnsSetting();
}
@Override
@@ -77,18 +76,6 @@ public class MultinetworkApiTest extends AndroidTestCase {
super.tearDown();
}
private void storePrivateDnsSetting() {
// Store private DNS setting
mOldMode = Settings.Global.getString(mCR, Settings.Global.PRIVATE_DNS_MODE);
mOldDnsSpecifier = Settings.Global.getString(mCR, Settings.Global.PRIVATE_DNS_SPECIFIER);
}
private void restorePrivateDnsSetting() {
// restore private DNS setting
Settings.Global.putString(mCR, Settings.Global.PRIVATE_DNS_MODE, mOldMode);
Settings.Global.putString(mCR, Settings.Global.PRIVATE_DNS_SPECIFIER, mOldDnsSpecifier);
}
private Network[] getTestableNetworks() {
final ArrayList<Network> testableNetworks = new ArrayList<Network>();
for (Network network : mCM.getAllNetworks()) {
@@ -239,17 +226,15 @@ public class MultinetworkApiTest extends AndroidTestCase {
// Enable private DNS strict mode and set server to dns.google before doing NxDomain test.
// b/144521720
try {
Settings.Global.putString(mCR, Settings.Global.PRIVATE_DNS_MODE, "hostname");
Settings.Global.putString(mCR,
Settings.Global.PRIVATE_DNS_SPECIFIER, GOOGLE_PRIVATE_DNS_SERVER);
mCtsNetUtils.setPrivateDnsStrictMode(GOOGLE_PRIVATE_DNS_SERVER);
for (Network network : getTestableNetworks()) {
// Wait for private DNS setting to propagate.
mCtsNetUtils.awaitPrivateDnsSetting("NxDomain test wait private DNS setting timeout",
network, GOOGLE_PRIVATE_DNS_SERVER, PRIVATE_DNS_SETTING_TIMEOUT_MS, true);
network, GOOGLE_PRIVATE_DNS_SERVER, true);
runResNnxDomainCheck(network.getNetworkHandle());
}
} finally {
restorePrivateDnsSetting();
mCtsNetUtils.restorePrivateDnsSetting();
}
}
}

62
tests/cts/net/util/java/android/net/cts/util/CtsNetUtils.java
View File

@@ -17,6 +17,7 @@
package android.net.cts.util;
import static android.Manifest.permission.NETWORK_SETTINGS;
import static android.net.ConnectivityManager.PRIVATE_DNS_MODE_OPPORTUNISTIC;
import static android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET;
import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
@@ -28,6 +29,7 @@ import static org.junit.Assert.fail;
import android.annotation.NonNull;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.ContentResolver;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
@@ -39,6 +41,7 @@ import android.net.NetworkInfo;
import android.net.NetworkInfo.State;
import android.net.NetworkRequest;
import android.net.wifi.WifiManager;
import android.provider.Settings;
import android.system.Os;
import android.system.OsConstants;
import android.util.Log;
@@ -59,6 +62,7 @@ public final class CtsNetUtils {
private static final int SOCKET_TIMEOUT_MS = 2000;
private static final int PRIVATE_DNS_PROBE_MS = 1_000;
public static final int PRIVATE_DNS_SETTING_TIMEOUT_MS = 6_000;
public static final int HTTP_PORT = 80;
public static final String TEST_HOST = "connectivitycheck.gstatic.com";
public static final String HTTP_REQUEST =
@@ -69,15 +73,19 @@ public final class CtsNetUtils {
public static final String NETWORK_CALLBACK_ACTION =
"ConnectivityManagerTest.NetworkCallbackAction";
private Context mContext;
private ConnectivityManager mCm;
private WifiManager mWifiManager;
private final Context mContext;
private final ConnectivityManager mCm;
private final ContentResolver mCR;
private final WifiManager mWifiManager;
private TestNetworkCallback mCellNetworkCallback;
private String mOldPrivateDnsMode;
private String mOldPrivateDnsSpecifier;
public CtsNetUtils(Context context) {
mContext = context;
mCm = (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
mCR = context.getContentResolver();
}
// Toggle WiFi twice, leaving it in the state it started in
@@ -249,9 +257,51 @@ public final class CtsNetUtils {
return s;
}
public void storePrivateDnsSetting() {
// Store private DNS setting
mOldPrivateDnsMode = Settings.Global.getString(mCR, Settings.Global.PRIVATE_DNS_MODE);
mOldPrivateDnsSpecifier = Settings.Global.getString(mCR,
Settings.Global.PRIVATE_DNS_SPECIFIER);
// It's possible that there is no private DNS default value in Settings.
// Give it a proper default mode which is opportunistic mode.
if (mOldPrivateDnsMode == null) {
mOldPrivateDnsSpecifier = "";
mOldPrivateDnsMode = PRIVATE_DNS_MODE_OPPORTUNISTIC;
Settings.Global.putString(mCR,
Settings.Global.PRIVATE_DNS_SPECIFIER, mOldPrivateDnsSpecifier);
Settings.Global.putString(mCR, Settings.Global.PRIVATE_DNS_MODE, mOldPrivateDnsMode);
}
}
public void restorePrivateDnsSetting() throws InterruptedException {
if (mOldPrivateDnsMode == null || mOldPrivateDnsSpecifier == null) {
return;
}
// restore private DNS setting
if ("hostname".equals(mOldPrivateDnsMode)) {
setPrivateDnsStrictMode(mOldPrivateDnsSpecifier);
awaitPrivateDnsSetting("restorePrivateDnsSetting timeout",
mCm.getActiveNetwork(),
mOldPrivateDnsSpecifier, true);
} else {
Settings.Global.putString(mCR, Settings.Global.PRIVATE_DNS_MODE, mOldPrivateDnsMode);
}
}
public void setPrivateDnsStrictMode(String server) {
// To reduce flake rate, set PRIVATE_DNS_SPECIFIER before PRIVATE_DNS_MODE. This ensures
// that if the previous private DNS mode was not "hostname", the system only sees one
// EVENT_PRIVATE_DNS_SETTINGS_CHANGED event instead of two.
Settings.Global.putString(mCR, Settings.Global.PRIVATE_DNS_SPECIFIER, server);
final String mode = Settings.Global.getString(mCR, Settings.Global.PRIVATE_DNS_MODE);
// If current private DNS mode is "hostname", we only need to set PRIVATE_DNS_SPECIFIER.
if (!"hostname".equals(mode)) {
Settings.Global.putString(mCR, Settings.Global.PRIVATE_DNS_MODE, "hostname");
}
}
public void awaitPrivateDnsSetting(@NonNull String msg, @NonNull Network network,
@NonNull String server, int timeoutMs,
boolean requiresValidatedServers) throws InterruptedException {
@NonNull String server, boolean requiresValidatedServers) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(1);
NetworkRequest request = new NetworkRequest.Builder().clearCapabilities().build();
NetworkCallback callback = new NetworkCallback() {
@@ -266,7 +316,7 @@ public final class CtsNetUtils {
}
};
mCm.registerNetworkCallback(request, callback);
assertTrue(msg, latch.await(timeoutMs, TimeUnit.MILLISECONDS));
assertTrue(msg, latch.await(PRIVATE_DNS_SETTING_TIMEOUT_MS, TimeUnit.MILLISECONDS));
mCm.unregisterNetworkCallback(callback);
// Wait some time for NetworkMonitor's private DNS probe to complete. If we do not do
// this, then the test could complete before the NetworkMonitor private DNS probe