Home | History | Annotate | Download | only in hostside 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 package com.android.cts.net.hostside;
     17 
     18 import android.os.SystemClock;
     19 import android.util.Log;
     20 
     21 /**
     22  * Test cases for the more complex scenarios where multiple restrictions (like Battery Saver Mode
     23  * and Data Saver Mode) are applied simultaneously.
     24  * <p>
     25  * <strong>NOTE: </strong>it might sound like the test methods on this class are testing too much,
     26  * which would make it harder to diagnose individual failures, but the assumption is that such
     27  * failure most likely will happen when the restriction is tested individually as well.
     28  */
     29 public class MixedModesTest extends AbstractRestrictBackgroundNetworkTestCase {
     30     private static final String TAG = "MixedModesTest";
     31 
     32     @Override
     33     public void setUp() throws Exception {
     34         super.setUp();
     35 
     36         if (!isSupported()) return;
     37 
     38         // Set initial state.
     39         removeRestrictBackgroundWhitelist(mUid);
     40         removeRestrictBackgroundBlacklist(mUid);
     41         removePowerSaveModeWhitelist(TEST_APP2_PKG);
     42         removePowerSaveModeExceptIdleWhitelist(TEST_APP2_PKG);
     43 
     44         registerBroadcastReceiver();
     45     }
     46 
     47     @Override
     48     protected void tearDown() throws Exception {
     49         super.tearDown();
     50 
     51         if (!isSupported()) return;
     52 
     53         try {
     54             setRestrictBackground(false);
     55         } finally {
     56             setBatterySaverMode(false);
     57         }
     58     }
     59 
     60     @Override
     61     public boolean isSupported() throws Exception {
     62         if (!isDozeModeEnabled()) {
     63             Log.i(TAG, "Skipping " + getClass() + "." + getName()
     64                     + "() because device does not support Doze Mode");
     65             return false;
     66         }
     67         return true;
     68     }
     69 
     70     /**
     71      * Tests all DS ON and BS ON scenarios from network-policy-restrictions.md on metered networks.
     72      */
     73     public void testDataAndBatterySaverModes_meteredNetwork() throws Exception {
     74         if (!isSupported()) return;
     75 
     76         Log.i(TAG, "testDataAndBatterySaverModes_meteredNetwork() tests");
     77         if (!setMeteredNetwork()) {
     78             Log.w(TAG, "testDataAndBatterySaverModes_meteredNetwork() skipped because "
     79                     + "device cannot use a metered network");
     80             return;
     81         }
     82 
     83         try {
     84             setRestrictBackground(true);
     85             setBatterySaverMode(true);
     86 
     87             Log.v(TAG, "Not whitelisted for any.");
     88             assertBackgroundNetworkAccess(false);
     89             assertsForegroundAlwaysHasNetworkAccess();
     90             assertBackgroundNetworkAccess(false);
     91 
     92             Log.v(TAG, "Whitelisted for Data Saver but not for Battery Saver.");
     93             addRestrictBackgroundWhitelist(mUid);
     94             removePowerSaveModeWhitelist(TEST_APP2_PKG);
     95             assertBackgroundNetworkAccess(false);
     96             assertsForegroundAlwaysHasNetworkAccess();
     97             assertBackgroundNetworkAccess(false);
     98             removeRestrictBackgroundWhitelist(mUid);
     99 
    100             Log.v(TAG, "Whitelisted for Battery Saver but not for Data Saver.");
    101             addPowerSaveModeWhitelist(TEST_APP2_PKG);
    102             removeRestrictBackgroundWhitelist(mUid);
    103             assertBackgroundNetworkAccess(false);
    104             assertsForegroundAlwaysHasNetworkAccess();
    105             assertBackgroundNetworkAccess(false);
    106             removePowerSaveModeWhitelist(TEST_APP2_PKG);
    107 
    108             Log.v(TAG, "Whitelisted for both.");
    109             addRestrictBackgroundWhitelist(mUid);
    110             addPowerSaveModeWhitelist(TEST_APP2_PKG);
    111             assertBackgroundNetworkAccess(true);
    112             assertsForegroundAlwaysHasNetworkAccess();
    113             assertBackgroundNetworkAccess(true);
    114             removePowerSaveModeWhitelist(TEST_APP2_PKG);
    115             assertBackgroundNetworkAccess(false);
    116             removeRestrictBackgroundWhitelist(mUid);
    117 
    118             Log.v(TAG, "Blacklisted for Data Saver, not whitelisted for Battery Saver.");
    119             addRestrictBackgroundBlacklist(mUid);
    120             removePowerSaveModeWhitelist(TEST_APP2_PKG);
    121             assertBackgroundNetworkAccess(false);
    122             assertsForegroundAlwaysHasNetworkAccess();
    123             assertBackgroundNetworkAccess(false);
    124             removeRestrictBackgroundBlacklist(mUid);
    125 
    126             Log.v(TAG, "Blacklisted for Data Saver, whitelisted for Battery Saver.");
    127             addRestrictBackgroundBlacklist(mUid);
    128             addPowerSaveModeWhitelist(TEST_APP2_PKG);
    129             assertBackgroundNetworkAccess(false);
    130             assertsForegroundAlwaysHasNetworkAccess();
    131             assertBackgroundNetworkAccess(false);
    132             removeRestrictBackgroundBlacklist(mUid);
    133             removePowerSaveModeWhitelist(TEST_APP2_PKG);
    134         } finally {
    135             resetMeteredNetwork();
    136         }
    137     }
    138 
    139     /**
    140      * Tests all DS ON and BS ON scenarios from network-policy-restrictions.md on non-metered
    141      * networks.
    142      */
    143     public void testDataAndBatterySaverModes_nonMeteredNetwork() throws Exception {
    144         if (!isSupported()) return;
    145 
    146         if (!setUnmeteredNetwork()) {
    147             Log.w(TAG, "testDataAndBatterySaverModes_nonMeteredNetwork() skipped because network"
    148                     + " is metered");
    149             return;
    150         }
    151         Log.i(TAG, "testDataAndBatterySaverModes_nonMeteredNetwork() tests");
    152         setRestrictBackground(true);
    153         setBatterySaverMode(true);
    154 
    155         Log.v(TAG, "Not whitelisted for any.");
    156         assertBackgroundNetworkAccess(false);
    157         assertsForegroundAlwaysHasNetworkAccess();
    158         assertBackgroundNetworkAccess(false);
    159 
    160         Log.v(TAG, "Whitelisted for Data Saver but not for Battery Saver.");
    161         addRestrictBackgroundWhitelist(mUid);
    162         removePowerSaveModeWhitelist(TEST_APP2_PKG);
    163         assertBackgroundNetworkAccess(false);
    164         assertsForegroundAlwaysHasNetworkAccess();
    165         assertBackgroundNetworkAccess(false);
    166         removeRestrictBackgroundWhitelist(mUid);
    167 
    168         Log.v(TAG, "Whitelisted for Battery Saver but not for Data Saver.");
    169         addPowerSaveModeWhitelist(TEST_APP2_PKG);
    170         removeRestrictBackgroundWhitelist(mUid);
    171         assertBackgroundNetworkAccess(true);
    172         assertsForegroundAlwaysHasNetworkAccess();
    173         assertBackgroundNetworkAccess(true);
    174         removePowerSaveModeWhitelist(TEST_APP2_PKG);
    175 
    176         Log.v(TAG, "Whitelisted for both.");
    177         addRestrictBackgroundWhitelist(mUid);
    178         addPowerSaveModeWhitelist(TEST_APP2_PKG);
    179         assertBackgroundNetworkAccess(true);
    180         assertsForegroundAlwaysHasNetworkAccess();
    181         assertBackgroundNetworkAccess(true);
    182         removePowerSaveModeWhitelist(TEST_APP2_PKG);
    183         assertBackgroundNetworkAccess(false);
    184         removeRestrictBackgroundWhitelist(mUid);
    185 
    186         Log.v(TAG, "Blacklisted for Data Saver, not whitelisted for Battery Saver.");
    187         addRestrictBackgroundBlacklist(mUid);
    188         removePowerSaveModeWhitelist(TEST_APP2_PKG);
    189         assertBackgroundNetworkAccess(false);
    190         assertsForegroundAlwaysHasNetworkAccess();
    191         assertBackgroundNetworkAccess(false);
    192         removeRestrictBackgroundBlacklist(mUid);
    193 
    194         Log.v(TAG, "Blacklisted for Data Saver, whitelisted for Battery Saver.");
    195         addRestrictBackgroundBlacklist(mUid);
    196         addPowerSaveModeWhitelist(TEST_APP2_PKG);
    197         assertBackgroundNetworkAccess(true);
    198         assertsForegroundAlwaysHasNetworkAccess();
    199         assertBackgroundNetworkAccess(true);
    200         removeRestrictBackgroundBlacklist(mUid);
    201         removePowerSaveModeWhitelist(TEST_APP2_PKG);
    202     }
    203 
    204     /**
    205      * Tests that powersave whitelists works as expected when doze and battery saver modes
    206      * are enabled.
    207      */
    208     public void testDozeAndBatterySaverMode_powerSaveWhitelists() throws Exception {
    209         if (!isSupported()) {
    210             return;
    211         }
    212 
    213         setBatterySaverMode(true);
    214         setDozeMode(true);
    215 
    216         try {
    217             addPowerSaveModeWhitelist(TEST_APP2_PKG);
    218             assertBackgroundNetworkAccess(true);
    219 
    220             removePowerSaveModeWhitelist(TEST_APP2_PKG);
    221             assertBackgroundNetworkAccess(false);
    222 
    223             addPowerSaveModeExceptIdleWhitelist(TEST_APP2_PKG);
    224             assertBackgroundNetworkAccess(false);
    225 
    226             removePowerSaveModeExceptIdleWhitelist(TEST_APP2_PKG);
    227             assertBackgroundNetworkAccess(false);
    228         } finally {
    229             setBatterySaverMode(false);
    230             setDozeMode(false);
    231         }
    232     }
    233 
    234     /**
    235      * Tests that powersave whitelists works as expected when doze and appIdle modes
    236      * are enabled.
    237      */
    238     public void testDozeAndAppIdle_powerSaveWhitelists() throws Exception {
    239         if (!isSupported()) {
    240             return;
    241         }
    242 
    243         setDozeMode(true);
    244         setAppIdle(true);
    245 
    246         try {
    247             addPowerSaveModeWhitelist(TEST_APP2_PKG);
    248             assertBackgroundNetworkAccess(true);
    249 
    250             removePowerSaveModeWhitelist(TEST_APP2_PKG);
    251             assertBackgroundNetworkAccess(false);
    252 
    253             addPowerSaveModeExceptIdleWhitelist(TEST_APP2_PKG);
    254             assertBackgroundNetworkAccess(false);
    255 
    256             removePowerSaveModeExceptIdleWhitelist(TEST_APP2_PKG);
    257             assertBackgroundNetworkAccess(false);
    258         } finally {
    259             setAppIdle(false);
    260             setDozeMode(false);
    261         }
    262     }
    263 
    264     public void testAppIdleAndDoze_tempPowerSaveWhitelists() throws Exception {
    265         if (!isSupported()) {
    266             return;
    267         }
    268 
    269         setDozeMode(true);
    270         setAppIdle(true);
    271 
    272         try {
    273             assertBackgroundNetworkAccess(false);
    274 
    275             addTempPowerSaveModeWhitelist(TEST_APP2_PKG, TEMP_POWERSAVE_WHITELIST_DURATION_MS);
    276             assertBackgroundNetworkAccess(true);
    277 
    278             // Wait until the whitelist duration is expired.
    279             SystemClock.sleep(TEMP_POWERSAVE_WHITELIST_DURATION_MS);
    280             assertBackgroundNetworkAccess(false);
    281         } finally {
    282             setAppIdle(false);
    283             setDozeMode(false);
    284         }
    285     }
    286 
    287     public void testAppIdleAndBatterySaver_tempPowerSaveWhitelists() throws Exception {
    288         if (!isSupported()) {
    289             return;
    290         }
    291 
    292         setBatterySaverMode(true);
    293         setAppIdle(true);
    294 
    295         try {
    296             assertBackgroundNetworkAccess(false);
    297 
    298             addTempPowerSaveModeWhitelist(TEST_APP2_PKG, TEMP_POWERSAVE_WHITELIST_DURATION_MS);
    299             assertBackgroundNetworkAccess(true);
    300 
    301             // Wait until the whitelist duration is expired.
    302             SystemClock.sleep(TEMP_POWERSAVE_WHITELIST_DURATION_MS);
    303             assertBackgroundNetworkAccess(false);
    304         } finally {
    305             setAppIdle(false);
    306             setBatterySaverMode(false);
    307         }
    308     }
    309 }
    310