joy/android_packages_modules_Connectivity
Watch
1
Fork
You've already forked android_packages_modules_Connectivity
 0
Code Issues Pull requests Projects Releases Wiki Activity

Merge "Refactoring hostside network restrictions tests" into main

Browse source
This commit is contained in:
Suprabh Shukla 2024-01-19 21:50:20 +00:00 • committed by Gerrit Code Review
commit 52113d6a9f
8 changed files with 81 additions and 108 deletions
Download patch file Download diff file Expand all files Collapse all files

6
tests/cts/hostside/app/src/com/android/cts/net/hostside/AbstractBatterySaverModeTestCase.java
View file

@ -59,13 +59,13 @@ abstract class AbstractBatterySaverModeTestCase extends AbstractRestrictBackgrou
setBatterySaverMode(false);
launchComponentAndAssertNetworkAccess(TYPE_COMPONENT_ACTIVTIY);
setBatterySaverMode(true);
assertForegroundNetworkAccess();
assertTopNetworkAccess(true);
// Although it should not have access while the screen is off.
turnScreenOff();
assertBackgroundNetworkAccess(false);
turnScreenOn();
assertForegroundNetworkAccess();
assertTopNetworkAccess(true);
// Goes back to background state.
finishActivity();
@ -75,7 +75,7 @@ abstract class AbstractBatterySaverModeTestCase extends AbstractRestrictBackgrou
setBatterySaverMode(false);
launchComponentAndAssertNetworkAccess(TYPE_COMPONENT_FOREGROUND_SERVICE);
setBatterySaverMode(true);
assertForegroundNetworkAccess();
assertForegroundServiceNetworkAccess();
stopForegroundService();
assertBackgroundNetworkAccess(false);
}

8
tests/cts/hostside/app/src/com/android/cts/net/hostside/AbstractDozeModeTestCase.java
View file

@ -16,6 +16,8 @@
package com.android.cts.net.hostside;
import static android.app.ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE;
import static com.android.cts.net.hostside.Property.DOZE_MODE;
import static com.android.cts.net.hostside.Property.NOT_LOW_RAM_DEVICE;
@ -62,9 +64,9 @@ abstract class AbstractDozeModeTestCase extends AbstractRestrictBackgroundNetwor
setDozeMode(false);
launchComponentAndAssertNetworkAccess(TYPE_COMPONENT_FOREGROUND_SERVICE);
setDozeMode(true);
assertForegroundNetworkAccess();
assertForegroundServiceNetworkAccess();
stopForegroundService();
assertBackgroundState();
assertProcessStateBelow(PROCESS_STATE_BOUND_FOREGROUND_SERVICE);
assertBackgroundNetworkAccess(false);
}
@ -136,6 +138,6 @@ abstract class AbstractDozeModeTestCase extends AbstractRestrictBackgroundNetwor
protected void assertsForegroundAlwaysHasNetworkAccess() throws Exception {
launchComponentAndAssertNetworkAccess(TYPE_COMPONENT_FOREGROUND_SERVICE);
stopForegroundService();
assertBackgroundState();
assertProcessStateBelow(PROCESS_STATE_BOUND_FOREGROUND_SERVICE);
}
}

145
tests/cts/hostside/app/src/com/android/cts/net/hostside/AbstractRestrictBackgroundNetworkTestCase.java
View file

@ -16,6 +16,9 @@
package com.android.cts.net.hostside;
import static android.app.ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE;
import static android.app.ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE;
import static android.app.ActivityManager.PROCESS_STATE_TOP;
import static android.app.job.JobScheduler.RESULT_SUCCESS;
import static android.net.ConnectivityManager.ACTION_RESTRICT_BACKGROUND_CHANGED;
import static android.os.BatteryManager.BATTERY_PLUGGED_ANY;
@ -38,7 +41,6 @@ import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import android.annotation.NonNull;
import android.app.ActivityManager;
import android.app.Instrumentation;
import android.app.NotificationManager;
import android.app.job.JobInfo;
@ -67,6 +69,7 @@ import androidx.annotation.Nullable;
import com.android.compatibility.common.util.AmUtils;
import com.android.compatibility.common.util.BatteryUtils;
import com.android.compatibility.common.util.DeviceConfigStateHelper;
import com.android.compatibility.common.util.ThrowingRunnable;
import org.junit.Rule;
import org.junit.rules.RuleChain;
@ -76,6 +79,7 @@ import java.util.ArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.function.Predicate;
/**
* Superclass for tests related to background network restrictions.
@ -126,8 +130,6 @@ public abstract class AbstractRestrictBackgroundNetworkTestCase {
private static final int SECOND_IN_MS = 1000;
static final int NETWORK_TIMEOUT_MS = 15 * SECOND_IN_MS;
private static int PROCESS_STATE_FOREGROUND_SERVICE;
private static final String KEY_NETWORK_STATE_OBSERVER = TEST_PKG + ".observer";
private static final String KEY_SKIP_VALIDATION_CHECKS = TEST_PKG + ".skip_validation_checks";
@ -171,9 +173,6 @@ public abstract class AbstractRestrictBackgroundNetworkTestCase {
.around(new MeterednessConfigurationRule());
protected void setUp() throws Exception {
// TODO: Annotate these constants with @TestApi instead of obtaining them using reflection
PROCESS_STATE_FOREGROUND_SERVICE = (Integer) ActivityManager.class
.getDeclaredField("PROCESS_STATE_FOREGROUND_SERVICE").get(null);
mInstrumentation = getInstrumentation();
mContext = getContext();
mCm = getConnectivityManager();
@ -284,44 +283,20 @@ public abstract class AbstractRestrictBackgroundNetworkTestCase {
restrictBackgroundValueToString(Integer.parseInt(status)));
}
protected void assertBackgroundNetworkAccess(boolean expectAllowed) throws Exception {
assertBackgroundNetworkAccess(expectAllowed, null);
}
/**
* Asserts whether the active network is available or not for the background app. If the network
* is unavailable, also checks whether it is blocked by the expected error.
*
* @param expectAllowed expect background network access to be allowed or not.
* @param expectedUnavailableError the expected error when {@code expectAllowed} is false. It's
* meaningful only when the {@code expectAllowed} is 'false'.
* Throws an IllegalArgumentException when {@code expectAllowed}
* is true and this parameter is not null. When the
* {@code expectAllowed} is 'false' and this parameter is null,
* this function does not compare error type of the networking
* access failure.
* @deprecated The definition of "background" can be ambiguous. Use separate calls to
* {@link #assertProcessStateBelow(int)} with
* {@link #assertNetworkAccess(boolean, boolean, String)} to be explicit, instead.
*/
protected void assertBackgroundNetworkAccess(boolean expectAllowed,
@Nullable final String expectedUnavailableError) throws Exception {
assertBackgroundState();
if (expectAllowed && expectedUnavailableError != null) {
throw new IllegalArgumentException("expectedUnavailableError is not null");
}
assertNetworkAccess(expectAllowed /* expectAvailable */, false /* needScreenOn */,
expectedUnavailableError);
@Deprecated
protected void assertBackgroundNetworkAccess(boolean expectAllowed) throws Exception {
assertProcessStateBelow(PROCESS_STATE_BOUND_FOREGROUND_SERVICE);
assertNetworkAccess(expectAllowed, false, null);
}
protected void assertForegroundNetworkAccess() throws Exception {
assertForegroundNetworkAccess(true);
}
protected void assertForegroundNetworkAccess(boolean expectAllowed) throws Exception {
assertForegroundState();
// We verified that app is in foreground state but if the screen turns-off while
// verifying for network access, the app will go into background state (in case app's
// foreground status was due to top activity). So, turn the screen on when verifying
// network connectivity.
assertNetworkAccess(expectAllowed /* expectAvailable */, true /* needScreenOn */);
protected void assertTopNetworkAccess(boolean expectAllowed) throws Exception {
assertTopState();
assertNetworkAccess(expectAllowed, true /* needScreenOn */);
}
protected void assertForegroundServiceNetworkAccess() throws Exception {
@ -355,75 +330,65 @@ public abstract class AbstractRestrictBackgroundNetworkTestCase {
finishExpeditedJob();
}
protected final void assertBackgroundState() throws Exception {
final int maxTries = 30;
ProcessState state = null;
for (int i = 1; i <= maxTries; i++) {
state = getProcessStateByUid(mUid);
Log.v(TAG, "assertBackgroundState(): status for app2 (" + mUid + ") on attempt #" + i
+ ": " + state);
if (isBackground(state.state)) {
return;
}
Log.d(TAG, "App not on background state (" + state + ") on attempt #" + i
+ "; sleeping 1s before trying again");
// No sleep after the last turn
if (i < maxTries) {
SystemClock.sleep(SECOND_IN_MS);
}
}
fail("App2 (" + mUid + ") is not on background state after "
+ maxTries + " attempts: " + state);
/**
* Asserts that the process state of the test app is below, in priority, to the given
* {@link android.app.ActivityManager.ProcessState}.
*/
protected final void assertProcessStateBelow(int processState) throws Exception {
assertProcessState(ps -> ps.state > processState, null);
}
protected final void assertForegroundState() throws Exception {
final int maxTries = 30;
ProcessState state = null;
for (int i = 1; i <= maxTries; i++) {
state = getProcessStateByUid(mUid);
Log.v(TAG, "assertForegroundState(): status for app2 (" + mUid + ") on attempt #" + i
+ ": " + state);
if (!isBackground(state.state)) {
return;
}
Log.d(TAG, "App not on foreground state on attempt #" + i
+ "; sleeping 1s before trying again");
turnScreenOn();
// No sleep after the last turn
if (i < maxTries) {
SystemClock.sleep(SECOND_IN_MS);
}
}
fail("App2 (" + mUid + ") is not on foreground state after "
+ maxTries + " attempts: " + state);
protected final void assertTopState() throws Exception {
assertProcessState(ps -> ps.state == PROCESS_STATE_TOP, () -> turnScreenOn());
}
protected final void assertForegroundServiceState() throws Exception {
assertProcessState(ps -> ps.state == PROCESS_STATE_FOREGROUND_SERVICE, null);
}
private void assertProcessState(Predicate<ProcessState> statePredicate,
ThrowingRunnable onRetry) throws Exception {
final int maxTries = 30;
ProcessState state = null;
for (int i = 1; i <= maxTries; i++) {
if (onRetry != null) {
onRetry.run();
}
state = getProcessStateByUid(mUid);
Log.v(TAG, "assertForegroundServiceState(): status for app2 (" + mUid + ") on attempt #"
+ i + ": " + state);
if (state.state == PROCESS_STATE_FOREGROUND_SERVICE) {
Log.v(TAG, "assertProcessState(): status for app2 (" + mUid + ") on attempt #" + i
+ ": " + state);
if (statePredicate.test(state)) {
return;
}
Log.d(TAG, "App not on foreground service state on attempt #" + i
Log.i(TAG, "App not in desired process state on attempt #" + i
+ "; sleeping 1s before trying again");
// No sleep after the last turn
if (i < maxTries) {
SystemClock.sleep(SECOND_IN_MS);
}
}
fail("App2 (" + mUid + ") is not on foreground service state after "
+ maxTries + " attempts: " + state);
fail("App2 (" + mUid + ") is not in the desired process state after " + maxTries
+ " attempts: " + state);
}
/**
* Returns whether an app state should be considered "background" for restriction purposes.
* Asserts whether the active network is available or not. If the network is unavailable, also
* checks whether it is blocked by the expected error.
*
* @param expectAllowed expect background network access to be allowed or not.
* @param expectedUnavailableError the expected error when {@code expectAllowed} is false. It's
* meaningful only when the {@code expectAllowed} is 'false'.
* Throws an IllegalArgumentException when {@code expectAllowed}
* is true and this parameter is not null. When the
* {@code expectAllowed} is 'false' and this parameter is null,
* this function does not compare error type of the networking
* access failure.
*/
protected boolean isBackground(int state) {
return state > PROCESS_STATE_FOREGROUND_SERVICE;
protected void assertNetworkAccess(boolean expectAllowed, String expectedUnavailableError)
throws Exception {
if (expectAllowed && expectedUnavailableError != null) {
throw new IllegalArgumentException("expectedUnavailableError is not null");
}
assertNetworkAccess(expectAllowed, false, expectedUnavailableError);
}
/**
@ -958,7 +923,7 @@ public abstract class AbstractRestrictBackgroundNetworkTestCase {
} else if (resultCode == INetworkStateObserver.RESULT_ERROR_UNEXPECTED_PROC_STATE) {
Log.d(TAG, resultData);
// App didn't come to foreground when the activity is started, so try again.
assertForegroundNetworkAccess();
assertTopNetworkAccess(true);
} else {
fail("Unexpected resultCode=" + resultCode + "; received=[" + resultData + "]");
}

4
tests/cts/hostside/app/src/com/android/cts/net/hostside/ConnOnActivityStartTest.java
View file

@ -17,6 +17,8 @@
package com.android.cts.net.hostside;
import static android.app.ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE;
import static com.android.cts.net.hostside.NetworkPolicyTestUtils.getUiDevice;
import static com.android.cts.net.hostside.NetworkPolicyTestUtils.setRestrictBackground;
import static com.android.cts.net.hostside.Property.APP_STANDBY_MODE;
@ -95,7 +97,7 @@ public class ConnOnActivityStartTest extends AbstractRestrictBackgroundNetworkTe
Log.i(TAG, testName + " start #" + i);
launchComponentAndAssertNetworkAccess(TYPE_COMPONENT_ACTIVTIY);
getUiDevice().pressHome();
assertBackgroundState();
assertProcessStateBelow(PROCESS_STATE_BOUND_FOREGROUND_SERVICE);
Log.i(TAG, testName + " end #" + i);
}
}

6
tests/cts/hostside/app/src/com/android/cts/net/hostside/DataSaverModeTest.java
View file

@ -108,7 +108,7 @@ public class DataSaverModeTest extends AbstractRestrictBackgroundNetworkTestCase
setRestrictBackground(false);
launchComponentAndAssertNetworkAccess(TYPE_COMPONENT_ACTIVTIY);
setRestrictBackground(true);
assertForegroundNetworkAccess();
assertTopNetworkAccess(true);
// Although it should not have access while the screen is off.
turnScreenOff();
@ -119,7 +119,7 @@ public class DataSaverModeTest extends AbstractRestrictBackgroundNetworkTestCase
if (isTV()) {
startActivity();
}
assertForegroundNetworkAccess();
assertTopNetworkAccess(true);
// Goes back to background state.
finishActivity();
@ -129,7 +129,7 @@ public class DataSaverModeTest extends AbstractRestrictBackgroundNetworkTestCase
setRestrictBackground(false);
launchComponentAndAssertNetworkAccess(TYPE_COMPONENT_FOREGROUND_SERVICE);
setRestrictBackground(true);
assertForegroundNetworkAccess();
assertForegroundServiceNetworkAccess();
stopForegroundService();
assertBackgroundNetworkAccess(false);
}

7
tests/cts/hostside/app/src/com/android/cts/net/hostside/NetworkCallbackTest.java
View file

@ -16,6 +16,7 @@
package com.android.cts.net.hostside;
import static android.app.ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE;
import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_METERED;
import static android.net.NetworkCapabilities.SIGNAL_STRENGTH_UNSPECIFIED;
@ -313,7 +314,8 @@ public class NetworkCallbackTest extends AbstractRestrictBackgroundNetworkTestCa
// Enable Power Saver
setBatterySaverMode(true);
if (SdkLevel.isAtLeastT()) {
assertBackgroundNetworkAccess(false, "java.net.UnknownHostException");
assertProcessStateBelow(PROCESS_STATE_BOUND_FOREGROUND_SERVICE);
assertNetworkAccess(false, "java.net.UnknownHostException");
} else {
assertBackgroundNetworkAccess(false);
}
@ -337,7 +339,8 @@ public class NetworkCallbackTest extends AbstractRestrictBackgroundNetworkTestCa
// Enable Power Saver
setBatterySaverMode(true);
if (SdkLevel.isAtLeastT()) {
assertBackgroundNetworkAccess(false, "java.net.UnknownHostException");
assertProcessStateBelow(PROCESS_STATE_BOUND_FOREGROUND_SERVICE);
assertNetworkAccess(false, "java.net.UnknownHostException");
} else {
assertBackgroundNetworkAccess(false);
}

9
tests/cts/hostside/app/src/com/android/cts/net/hostside/NetworkPolicyManagerTest.java
View file

@ -16,6 +16,7 @@
package com.android.cts.net.hostside;
import static android.app.ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE;
import static android.os.Process.SYSTEM_UID;
import static com.android.cts.net.hostside.NetworkPolicyTestUtils.assertIsUidRestrictedOnMeteredNetworks;
@ -137,13 +138,13 @@ public class NetworkPolicyManagerTest extends AbstractRestrictBackgroundNetworkT
// Make TEST_APP2_PKG go to foreground and mUid will be allowed temporarily.
launchActivity();
assertForegroundState();
assertTopState();
assertNetworkingBlockedStatusForUid(mUid, METERED,
false /* expectedResult */); // Match NTWK_ALLOWED_TMP_ALLOWLIST
// Back to background.
finishActivity();
assertBackgroundState();
assertProcessStateBelow(PROCESS_STATE_BOUND_FOREGROUND_SERVICE);
assertNetworkingBlockedStatusForUid(mUid, METERED,
true /* expectedResult */); // Match NTWK_BLOCKED_BG_RESTRICT
} finally {
@ -219,11 +220,11 @@ public class NetworkPolicyManagerTest extends AbstractRestrictBackgroundNetworkT
// Make TEST_APP2_PKG go to foreground and isUidRestrictedOnMeteredNetworks() will
// return false.
launchActivity();
assertForegroundState();
assertTopState();
assertIsUidRestrictedOnMeteredNetworks(mUid, false /* expectedResult */);
// Back to background.
finishActivity();
assertBackgroundState();
assertProcessStateBelow(PROCESS_STATE_BOUND_FOREGROUND_SERVICE);
// Add mUid into restrict background whitelist and isUidRestrictedOnMeteredNetworks()
// will return false.

4
tests/cts/hostside/app/src/com/android/cts/net/hostside/RestrictedModeTest.java
View file

@ -38,7 +38,7 @@ public final class RestrictedModeTest extends AbstractRestrictBackgroundNetworkT
// go to foreground state and enable restricted mode
launchComponentAndAssertNetworkAccess(TYPE_COMPONENT_ACTIVTIY);
setRestrictedNetworkingMode(true);
assertForegroundNetworkAccess(false);
assertTopNetworkAccess(false);
// go to background state
finishActivity();
@ -47,7 +47,7 @@ public final class RestrictedModeTest extends AbstractRestrictBackgroundNetworkT
// disable restricted mode and assert network access in foreground and background states
setRestrictedNetworkingMode(false);
launchComponentAndAssertNetworkAccess(TYPE_COMPONENT_ACTIVTIY);
assertForegroundNetworkAccess(true);
assertTopNetworkAccess(true);
// go to background state
finishActivity();