Home | History | Annotate | Download | only in net 
      1 /*
      2  * Copyright (C) 2011 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 
     17 package com.android.server.net;
     18 
     19 import static android.content.Intent.ACTION_UID_REMOVED;
     20 import static android.content.Intent.EXTRA_UID;
     21 import static android.net.ConnectivityManager.TYPE_MOBILE;
     22 import static android.net.ConnectivityManager.TYPE_WIFI;
     23 import static android.net.ConnectivityManager.TYPE_WIMAX;
     24 import static android.net.NetworkStats.IFACE_ALL;
     25 import static android.net.NetworkStats.ROAMING_ALL;
     26 import static android.net.NetworkStats.ROAMING_NO;
     27 import static android.net.NetworkStats.ROAMING_YES;
     28 import static android.net.NetworkStats.SET_ALL;
     29 import static android.net.NetworkStats.SET_DEFAULT;
     30 import static android.net.NetworkStats.SET_FOREGROUND;
     31 import static android.net.NetworkStats.TAG_NONE;
     32 import static android.net.NetworkStats.UID_ALL;
     33 import static android.net.NetworkStatsHistory.FIELD_ALL;
     34 import static android.net.NetworkTemplate.buildTemplateMobileAll;
     35 import static android.net.NetworkTemplate.buildTemplateWifiWildcard;
     36 import static android.net.TrafficStats.MB_IN_BYTES;
     37 import static android.net.TrafficStats.UID_REMOVED;
     38 import static android.net.TrafficStats.UID_TETHERING;
     39 import static android.text.format.DateUtils.DAY_IN_MILLIS;
     40 import static android.text.format.DateUtils.HOUR_IN_MILLIS;
     41 import static android.text.format.DateUtils.MINUTE_IN_MILLIS;
     42 import static android.text.format.DateUtils.WEEK_IN_MILLIS;
     43 import static com.android.server.net.NetworkStatsService.ACTION_NETWORK_STATS_POLL;
     44 import static org.easymock.EasyMock.anyInt;
     45 import static org.easymock.EasyMock.anyLong;
     46 import static org.easymock.EasyMock.anyObject;
     47 import static org.easymock.EasyMock.capture;
     48 import static org.easymock.EasyMock.createMock;
     49 import static org.easymock.EasyMock.eq;
     50 import static org.easymock.EasyMock.expect;
     51 import static org.easymock.EasyMock.expectLastCall;
     52 import static org.easymock.EasyMock.isA;
     53 
     54 import android.app.AlarmManager;
     55 import android.app.IAlarmListener;
     56 import android.app.IAlarmManager;
     57 import android.app.PendingIntent;
     58 import android.app.usage.NetworkStatsManager;
     59 import android.content.Context;
     60 import android.content.Intent;
     61 import android.net.DataUsageRequest;
     62 import android.net.IConnectivityManager;
     63 import android.net.INetworkManagementEventObserver;
     64 import android.net.INetworkStatsSession;
     65 import android.net.LinkProperties;
     66 import android.net.NetworkInfo;
     67 import android.net.NetworkInfo.DetailedState;
     68 import android.net.NetworkState;
     69 import android.net.NetworkStats;
     70 import android.net.NetworkStatsHistory;
     71 import android.net.NetworkTemplate;
     72 import android.os.ConditionVariable;
     73 import android.os.Handler;
     74 import android.os.HandlerThread;
     75 import android.os.INetworkManagementService;
     76 import android.os.IBinder;
     77 import android.os.Looper;
     78 import android.os.Messenger;
     79 import android.os.MessageQueue;
     80 import android.os.MessageQueue.IdleHandler;
     81 import android.os.Message;
     82 import android.os.PowerManager;
     83 import android.os.WorkSource;
     84 import android.telephony.TelephonyManager;
     85 import android.test.AndroidTestCase;
     86 import android.test.suitebuilder.annotation.LargeTest;
     87 import android.test.suitebuilder.annotation.Suppress;
     88 import android.util.TrustedTime;
     89 
     90 import com.android.internal.net.VpnInfo;
     91 import com.android.server.BroadcastInterceptingContext;
     92 import com.android.server.net.NetworkStatsService;
     93 import com.android.server.net.NetworkStatsService.NetworkStatsSettings;
     94 import com.android.server.net.NetworkStatsService.NetworkStatsSettings.Config;
     95 
     96 import libcore.io.IoUtils;
     97 
     98 import org.easymock.Capture;
     99 import org.easymock.EasyMock;
    100 
    101 import java.io.File;
    102 import java.util.ArrayList;
    103 import java.util.Objects;
    104 import java.util.List;
    105 
    106 /**
    107  * Tests for {@link NetworkStatsService}.
    108  *
    109  * TODO: This test is really brittle, largely due to overly-strict use of Easymock.
    110  * Rewrite w/ Mockito.
    111  */
    112 @LargeTest
    113 public class NetworkStatsServiceTest extends AndroidTestCase {
    114     private static final String TAG = "NetworkStatsServiceTest";
    115 
    116     private static final String TEST_IFACE = "test0";
    117     private static final String TEST_IFACE2 = "test1";
    118     private static final long TEST_START = 1194220800000L;
    119 
    120     private static final String IMSI_1 = "310004";
    121     private static final String IMSI_2 = "310260";
    122     private static final String TEST_SSID = "AndroidAP";
    123 
    124     private static NetworkTemplate sTemplateWifi = buildTemplateWifiWildcard();
    125     private static NetworkTemplate sTemplateImsi1 = buildTemplateMobileAll(IMSI_1);
    126     private static NetworkTemplate sTemplateImsi2 = buildTemplateMobileAll(IMSI_2);
    127 
    128     private static final int UID_RED = 1001;
    129     private static final int UID_BLUE = 1002;
    130     private static final int UID_GREEN = 1003;
    131 
    132     private static final long WAIT_TIMEOUT = 2 * 1000;  // 2 secs
    133     private static final int INVALID_TYPE = -1;
    134 
    135     private long mElapsedRealtime;
    136 
    137     private BroadcastInterceptingContext mServiceContext;
    138     private File mStatsDir;
    139 
    140     private INetworkManagementService mNetManager;
    141     private TrustedTime mTime;
    142     private NetworkStatsSettings mSettings;
    143     private IConnectivityManager mConnManager;
    144     private IdleableHandlerThread mHandlerThread;
    145     private Handler mHandler;
    146 
    147     private NetworkStatsService mService;
    148     private INetworkStatsSession mSession;
    149     private INetworkManagementEventObserver mNetworkObserver;
    150 
    151     @Override
    152     public void setUp() throws Exception {
    153         super.setUp();
    154 
    155         mServiceContext = new BroadcastInterceptingContext(getContext());
    156         mStatsDir = getContext().getFilesDir();
    157         if (mStatsDir.exists()) {
    158             IoUtils.deleteContents(mStatsDir);
    159         }
    160 
    161         mNetManager = createMock(INetworkManagementService.class);
    162 
    163         // TODO: Mock AlarmManager when migrating this test to Mockito.
    164         AlarmManager alarmManager = (AlarmManager) mServiceContext
    165                 .getSystemService(Context.ALARM_SERVICE);
    166         mTime = createMock(TrustedTime.class);
    167         mSettings = createMock(NetworkStatsSettings.class);
    168         mConnManager = createMock(IConnectivityManager.class);
    169 
    170         PowerManager powerManager = (PowerManager) mServiceContext.getSystemService(
    171                 Context.POWER_SERVICE);
    172         PowerManager.WakeLock wakeLock =
    173                 powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
    174 
    175         mService = new NetworkStatsService(
    176                 mServiceContext, mNetManager, alarmManager, wakeLock, mTime,
    177                 TelephonyManager.getDefault(), mSettings, new NetworkStatsObservers(),
    178                 mStatsDir, getBaseDir(mStatsDir));
    179         mHandlerThread = new IdleableHandlerThread("HandlerThread");
    180         mHandlerThread.start();
    181         Handler.Callback callback = new NetworkStatsService.HandlerCallback(mService);
    182         mHandler = new Handler(mHandlerThread.getLooper(), callback);
    183         mService.setHandler(mHandler, callback);
    184         mService.bindConnectivityManager(mConnManager);
    185 
    186         mElapsedRealtime = 0L;
    187 
    188         expectCurrentTime();
    189         expectDefaultSettings();
    190         expectNetworkStatsUidDetail(buildEmptyStats());
    191         expectSystemReady();
    192 
    193         // catch INetworkManagementEventObserver during systemReady()
    194         final Capture<INetworkManagementEventObserver> networkObserver = new Capture<
    195                 INetworkManagementEventObserver>();
    196         mNetManager.registerObserver(capture(networkObserver));
    197         expectLastCall().atLeastOnce();
    198 
    199         replay();
    200         mService.systemReady();
    201         mSession = mService.openSession();
    202         verifyAndReset();
    203 
    204         mNetworkObserver = networkObserver.getValue();
    205 
    206     }
    207 
    208     @Override
    209     public void tearDown() throws Exception {
    210         IoUtils.deleteContents(mStatsDir);
    211 
    212         mServiceContext = null;
    213         mStatsDir = null;
    214 
    215         mNetManager = null;
    216         mTime = null;
    217         mSettings = null;
    218         mConnManager = null;
    219 
    220         mSession.close();
    221         mService = null;
    222 
    223         super.tearDown();
    224     }
    225 
    226     public void testNetworkStatsWifi() throws Exception {
    227         // pretend that wifi network comes online; service should ask about full
    228         // network state, and poll any existing interfaces before updating.
    229         expectCurrentTime();
    230         expectDefaultSettings();
    231         expectNetworkState(buildWifiState());
    232         expectNetworkStatsSummary(buildEmptyStats());
    233         expectNetworkStatsUidDetail(buildEmptyStats());
    234         expectNetworkStatsPoll();
    235         expectBandwidthControlCheck();
    236 
    237         replay();
    238         mService.forceUpdateIfaces();
    239 
    240         // verify service has empty history for wifi
    241         assertNetworkTotal(sTemplateWifi, 0L, 0L, 0L, 0L, 0);
    242         verifyAndReset();
    243 
    244         // modify some number on wifi, and trigger poll event
    245         incrementCurrentTime(HOUR_IN_MILLIS);
    246         expectCurrentTime();
    247         expectDefaultSettings();
    248         expectNetworkStatsSummary(new NetworkStats(getElapsedRealtime(), 1)
    249                 .addIfaceValues(TEST_IFACE, 1024L, 1L, 2048L, 2L));
    250         expectNetworkStatsUidDetail(buildEmptyStats());
    251         expectNetworkStatsPoll();
    252 
    253         replay();
    254         forcePollAndWaitForIdle();
    255 
    256         // verify service recorded history
    257         assertNetworkTotal(sTemplateWifi, 1024L, 1L, 2048L, 2L, 0);
    258         verifyAndReset();
    259 
    260         // and bump forward again, with counters going higher. this is
    261         // important, since polling should correctly subtract last snapshot.
    262         incrementCurrentTime(DAY_IN_MILLIS);
    263         expectCurrentTime();
    264         expectDefaultSettings();
    265         expectNetworkStatsSummary(new NetworkStats(getElapsedRealtime(), 1)
    266                 .addIfaceValues(TEST_IFACE, 4096L, 4L, 8192L, 8L));
    267         expectNetworkStatsUidDetail(buildEmptyStats());
    268         expectNetworkStatsPoll();
    269 
    270         replay();
    271         forcePollAndWaitForIdle();
    272 
    273         // verify service recorded history
    274         assertNetworkTotal(sTemplateWifi, 4096L, 4L, 8192L, 8L, 0);
    275         verifyAndReset();
    276 
    277     }
    278 
    279     public void testStatsRebootPersist() throws Exception {
    280         assertStatsFilesExist(false);
    281 
    282         // pretend that wifi network comes online; service should ask about full
    283         // network state, and poll any existing interfaces before updating.
    284         expectCurrentTime();
    285         expectDefaultSettings();
    286         expectNetworkState(buildWifiState());
    287         expectNetworkStatsSummary(buildEmptyStats());
    288         expectNetworkStatsUidDetail(buildEmptyStats());
    289         expectNetworkStatsPoll();
    290         expectBandwidthControlCheck();
    291 
    292         replay();
    293         mService.forceUpdateIfaces();
    294 
    295         // verify service has empty history for wifi
    296         assertNetworkTotal(sTemplateWifi, 0L, 0L, 0L, 0L, 0);
    297         verifyAndReset();
    298 
    299         // modify some number on wifi, and trigger poll event
    300         incrementCurrentTime(HOUR_IN_MILLIS);
    301         expectCurrentTime();
    302         expectDefaultSettings();
    303         expectNetworkStatsSummary(new NetworkStats(getElapsedRealtime(), 1)
    304                 .addIfaceValues(TEST_IFACE, 1024L, 8L, 2048L, 16L));
    305         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 2)
    306                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 512L, 4L, 256L, 2L, 0L)
    307                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xFAAD, 256L, 2L, 128L, 1L, 0L)
    308                 .addValues(TEST_IFACE, UID_RED, SET_FOREGROUND, TAG_NONE, 512L, 4L, 256L, 2L, 0L)
    309                 .addValues(TEST_IFACE, UID_RED, SET_FOREGROUND, 0xFAAD, 256L, 2L, 128L, 1L, 0L)
    310                 .addValues(TEST_IFACE, UID_BLUE, SET_DEFAULT, TAG_NONE, 128L, 1L, 128L, 1L, 0L));
    311         expectNetworkStatsPoll();
    312 
    313         mService.setUidForeground(UID_RED, false);
    314         mService.incrementOperationCount(UID_RED, 0xFAAD, 4);
    315         mService.setUidForeground(UID_RED, true);
    316         mService.incrementOperationCount(UID_RED, 0xFAAD, 6);
    317 
    318         replay();
    319         forcePollAndWaitForIdle();
    320 
    321         // verify service recorded history
    322         assertNetworkTotal(sTemplateWifi, 1024L, 8L, 2048L, 16L, 0);
    323         assertUidTotal(sTemplateWifi, UID_RED, 1024L, 8L, 512L, 4L, 10);
    324         assertUidTotal(sTemplateWifi, UID_RED, SET_DEFAULT, ROAMING_NO, 512L, 4L, 256L, 2L, 4);
    325         assertUidTotal(sTemplateWifi, UID_RED, SET_FOREGROUND, ROAMING_NO, 512L, 4L, 256L, 2L,
    326                 6);
    327         assertUidTotal(sTemplateWifi, UID_BLUE, 128L, 1L, 128L, 1L, 0);
    328         verifyAndReset();
    329 
    330         // graceful shutdown system, which should trigger persist of stats, and
    331         // clear any values in memory.
    332         expectCurrentTime();
    333         expectDefaultSettings();
    334         replay();
    335         mServiceContext.sendBroadcast(new Intent(Intent.ACTION_SHUTDOWN));
    336         verifyAndReset();
    337 
    338         assertStatsFilesExist(true);
    339 
    340         // boot through serviceReady() again
    341         expectCurrentTime();
    342         expectDefaultSettings();
    343         expectNetworkStatsUidDetail(buildEmptyStats());
    344         expectSystemReady();
    345 
    346         // catch INetworkManagementEventObserver during systemReady()
    347         final Capture<INetworkManagementEventObserver> networkObserver = new Capture<
    348                 INetworkManagementEventObserver>();
    349         mNetManager.registerObserver(capture(networkObserver));
    350         expectLastCall().atLeastOnce();
    351 
    352         replay();
    353         mService.systemReady();
    354 
    355         mNetworkObserver = networkObserver.getValue();
    356 
    357         // after systemReady(), we should have historical stats loaded again
    358         assertNetworkTotal(sTemplateWifi, 1024L, 8L, 2048L, 16L, 0);
    359         assertUidTotal(sTemplateWifi, UID_RED, 1024L, 8L, 512L, 4L, 10);
    360         assertUidTotal(sTemplateWifi, UID_RED, SET_DEFAULT, ROAMING_NO, 512L, 4L, 256L, 2L, 4);
    361         assertUidTotal(sTemplateWifi, UID_RED, SET_FOREGROUND, ROAMING_NO, 512L, 4L, 256L, 2L,
    362                 6);
    363         assertUidTotal(sTemplateWifi, UID_BLUE, 128L, 1L, 128L, 1L, 0);
    364         verifyAndReset();
    365 
    366     }
    367 
    368     // TODO: simulate reboot to test bucket resize
    369     @Suppress
    370     public void testStatsBucketResize() throws Exception {
    371         NetworkStatsHistory history = null;
    372 
    373         assertStatsFilesExist(false);
    374 
    375         // pretend that wifi network comes online; service should ask about full
    376         // network state, and poll any existing interfaces before updating.
    377         expectCurrentTime();
    378         expectSettings(0L, HOUR_IN_MILLIS, WEEK_IN_MILLIS);
    379         expectNetworkState(buildWifiState());
    380         expectNetworkStatsSummary(buildEmptyStats());
    381         expectNetworkStatsUidDetail(buildEmptyStats());
    382         expectNetworkStatsPoll();
    383         expectBandwidthControlCheck();
    384 
    385         replay();
    386         mService.forceUpdateIfaces();
    387         verifyAndReset();
    388 
    389         // modify some number on wifi, and trigger poll event
    390         incrementCurrentTime(2 * HOUR_IN_MILLIS);
    391         expectCurrentTime();
    392         expectSettings(0L, HOUR_IN_MILLIS, WEEK_IN_MILLIS);
    393         expectNetworkStatsSummary(new NetworkStats(getElapsedRealtime(), 1)
    394                 .addIfaceValues(TEST_IFACE, 512L, 4L, 512L, 4L));
    395         expectNetworkStatsUidDetail(buildEmptyStats());
    396         expectNetworkStatsPoll();
    397 
    398         replay();
    399         forcePollAndWaitForIdle();
    400 
    401         // verify service recorded history
    402         history = mSession.getHistoryForNetwork(sTemplateWifi, FIELD_ALL);
    403         assertValues(history, Long.MIN_VALUE, Long.MAX_VALUE, 512L, 4L, 512L, 4L, 0);
    404         assertEquals(HOUR_IN_MILLIS, history.getBucketDuration());
    405         assertEquals(2, history.size());
    406         verifyAndReset();
    407 
    408         // now change bucket duration setting and trigger another poll with
    409         // exact same values, which should resize existing buckets.
    410         expectCurrentTime();
    411         expectSettings(0L, 30 * MINUTE_IN_MILLIS, WEEK_IN_MILLIS);
    412         expectNetworkStatsSummary(buildEmptyStats());
    413         expectNetworkStatsUidDetail(buildEmptyStats());
    414         expectNetworkStatsPoll();
    415 
    416         replay();
    417         forcePollAndWaitForIdle();
    418 
    419         // verify identical stats, but spread across 4 buckets now
    420         history = mSession.getHistoryForNetwork(sTemplateWifi, FIELD_ALL);
    421         assertValues(history, Long.MIN_VALUE, Long.MAX_VALUE, 512L, 4L, 512L, 4L, 0);
    422         assertEquals(30 * MINUTE_IN_MILLIS, history.getBucketDuration());
    423         assertEquals(4, history.size());
    424         verifyAndReset();
    425 
    426     }
    427 
    428     public void testUidStatsAcrossNetworks() throws Exception {
    429         // pretend first mobile network comes online
    430         expectCurrentTime();
    431         expectDefaultSettings();
    432         expectNetworkState(buildMobile3gState(IMSI_1));
    433         expectNetworkStatsSummary(buildEmptyStats());
    434         expectNetworkStatsUidDetail(buildEmptyStats());
    435         expectNetworkStatsPoll();
    436         expectBandwidthControlCheck();
    437 
    438         replay();
    439         mService.forceUpdateIfaces();
    440         verifyAndReset();
    441 
    442         // create some traffic on first network
    443         incrementCurrentTime(HOUR_IN_MILLIS);
    444         expectCurrentTime();
    445         expectDefaultSettings();
    446         expectNetworkStatsSummary(new NetworkStats(getElapsedRealtime(), 1)
    447                 .addIfaceValues(TEST_IFACE, 2048L, 16L, 512L, 4L));
    448         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 3)
    449                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 1536L, 12L, 512L, 4L, 0L)
    450                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xF00D, 512L, 4L, 512L, 4L, 0L)
    451                 .addValues(TEST_IFACE, UID_BLUE, SET_DEFAULT, TAG_NONE, 512L, 4L, 0L, 0L, 0L));
    452         expectNetworkStatsPoll();
    453 
    454         mService.incrementOperationCount(UID_RED, 0xF00D, 10);
    455 
    456         replay();
    457         forcePollAndWaitForIdle();
    458 
    459         // verify service recorded history
    460         assertNetworkTotal(sTemplateImsi1, 2048L, 16L, 512L, 4L, 0);
    461         assertNetworkTotal(sTemplateWifi, 0L, 0L, 0L, 0L, 0);
    462         assertUidTotal(sTemplateImsi1, UID_RED, 1536L, 12L, 512L, 4L, 10);
    463         assertUidTotal(sTemplateImsi1, UID_BLUE, 512L, 4L, 0L, 0L, 0);
    464         verifyAndReset();
    465 
    466         // now switch networks; this also tests that we're okay with interfaces
    467         // disappearing, to verify we don't count backwards.
    468         incrementCurrentTime(HOUR_IN_MILLIS);
    469         expectCurrentTime();
    470         expectDefaultSettings();
    471         expectNetworkState(buildMobile3gState(IMSI_2));
    472         expectNetworkStatsSummary(new NetworkStats(getElapsedRealtime(), 1)
    473                 .addIfaceValues(TEST_IFACE, 2048L, 16L, 512L, 4L));
    474         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 3)
    475                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 1536L, 12L, 512L, 4L, 0L)
    476                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xF00D, 512L, 4L, 512L, 4L, 0L)
    477                 .addValues(TEST_IFACE, UID_BLUE, SET_DEFAULT, TAG_NONE, 512L, 4L, 0L, 0L, 0L));
    478         expectNetworkStatsPoll();
    479         expectBandwidthControlCheck();
    480 
    481         replay();
    482         mService.forceUpdateIfaces();
    483         forcePollAndWaitForIdle();
    484         verifyAndReset();
    485 
    486         // create traffic on second network
    487         incrementCurrentTime(HOUR_IN_MILLIS);
    488         expectCurrentTime();
    489         expectDefaultSettings();
    490         expectNetworkStatsSummary(new NetworkStats(getElapsedRealtime(), 1)
    491                 .addIfaceValues(TEST_IFACE, 2176L, 17L, 1536L, 12L));
    492         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 1)
    493                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 1536L, 12L, 512L, 4L, 0L)
    494                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xF00D, 512L, 4L, 512L, 4L, 0L)
    495                 .addValues(TEST_IFACE, UID_BLUE, SET_DEFAULT, TAG_NONE, 640L, 5L, 1024L, 8L, 0L)
    496                 .addValues(TEST_IFACE, UID_BLUE, SET_DEFAULT, 0xFAAD, 128L, 1L, 1024L, 8L, 0L));
    497         expectNetworkStatsPoll();
    498 
    499         mService.incrementOperationCount(UID_BLUE, 0xFAAD, 10);
    500 
    501         replay();
    502         forcePollAndWaitForIdle();
    503 
    504         // verify original history still intact
    505         assertNetworkTotal(sTemplateImsi1, 2048L, 16L, 512L, 4L, 0);
    506         assertUidTotal(sTemplateImsi1, UID_RED, 1536L, 12L, 512L, 4L, 10);
    507         assertUidTotal(sTemplateImsi1, UID_BLUE, 512L, 4L, 0L, 0L, 0);
    508 
    509         // and verify new history also recorded under different template, which
    510         // verifies that we didn't cross the streams.
    511         assertNetworkTotal(sTemplateImsi2, 128L, 1L, 1024L, 8L, 0);
    512         assertNetworkTotal(sTemplateWifi, 0L, 0L, 0L, 0L, 0);
    513         assertUidTotal(sTemplateImsi2, UID_BLUE, 128L, 1L, 1024L, 8L, 10);
    514         verifyAndReset();
    515 
    516     }
    517 
    518     public void testUidRemovedIsMoved() throws Exception {
    519         // pretend that network comes online
    520         expectCurrentTime();
    521         expectDefaultSettings();
    522         expectNetworkState(buildWifiState());
    523         expectNetworkStatsSummary(buildEmptyStats());
    524         expectNetworkStatsUidDetail(buildEmptyStats());
    525         expectNetworkStatsPoll();
    526         expectBandwidthControlCheck();
    527 
    528         replay();
    529         mService.forceUpdateIfaces();
    530         verifyAndReset();
    531 
    532         // create some traffic
    533         incrementCurrentTime(HOUR_IN_MILLIS);
    534         expectCurrentTime();
    535         expectDefaultSettings();
    536         expectNetworkStatsSummary(new NetworkStats(getElapsedRealtime(), 1)
    537                 .addIfaceValues(TEST_IFACE, 4128L, 258L, 544L, 34L));
    538         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 1)
    539                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 16L, 1L, 16L, 1L, 0L)
    540                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xFAAD, 16L, 1L, 16L, 1L, 0L)
    541                 .addValues(TEST_IFACE, UID_BLUE, SET_DEFAULT, TAG_NONE, 4096L, 258L, 512L, 32L, 0L)
    542                 .addValues(TEST_IFACE, UID_GREEN, SET_DEFAULT, TAG_NONE, 16L, 1L, 16L, 1L, 0L));
    543         expectNetworkStatsPoll();
    544 
    545         mService.incrementOperationCount(UID_RED, 0xFAAD, 10);
    546 
    547         replay();
    548         forcePollAndWaitForIdle();
    549 
    550         // verify service recorded history
    551         assertNetworkTotal(sTemplateWifi, 4128L, 258L, 544L, 34L, 0);
    552         assertUidTotal(sTemplateWifi, UID_RED, 16L, 1L, 16L, 1L, 10);
    553         assertUidTotal(sTemplateWifi, UID_BLUE, 4096L, 258L, 512L, 32L, 0);
    554         assertUidTotal(sTemplateWifi, UID_GREEN, 16L, 1L, 16L, 1L, 0);
    555         verifyAndReset();
    556 
    557         // now pretend two UIDs are uninstalled, which should migrate stats to
    558         // special "removed" bucket.
    559         expectCurrentTime();
    560         expectDefaultSettings();
    561         expectNetworkStatsSummary(new NetworkStats(getElapsedRealtime(), 1)
    562                 .addIfaceValues(TEST_IFACE, 4128L, 258L, 544L, 34L));
    563         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 1)
    564                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 16L, 1L, 16L, 1L, 0L)
    565                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xFAAD, 16L, 1L, 16L, 1L, 0L)
    566                 .addValues(TEST_IFACE, UID_BLUE, SET_DEFAULT, TAG_NONE, 4096L, 258L, 512L, 32L, 0L)
    567                 .addValues(TEST_IFACE, UID_GREEN, SET_DEFAULT, TAG_NONE, 16L, 1L, 16L, 1L, 0L));
    568         expectNetworkStatsPoll();
    569 
    570         replay();
    571         final Intent intent = new Intent(ACTION_UID_REMOVED);
    572         intent.putExtra(EXTRA_UID, UID_BLUE);
    573         mServiceContext.sendBroadcast(intent);
    574         intent.putExtra(EXTRA_UID, UID_RED);
    575         mServiceContext.sendBroadcast(intent);
    576 
    577         // existing uid and total should remain unchanged; but removed UID
    578         // should be gone completely.
    579         assertNetworkTotal(sTemplateWifi, 4128L, 258L, 544L, 34L, 0);
    580         assertUidTotal(sTemplateWifi, UID_RED, 0L, 0L, 0L, 0L, 0);
    581         assertUidTotal(sTemplateWifi, UID_BLUE, 0L, 0L, 0L, 0L, 0);
    582         assertUidTotal(sTemplateWifi, UID_GREEN, 16L, 1L, 16L, 1L, 0);
    583         assertUidTotal(sTemplateWifi, UID_REMOVED, 4112L, 259L, 528L, 33L, 10);
    584         verifyAndReset();
    585 
    586     }
    587 
    588     public void testUid3g4gCombinedByTemplate() throws Exception {
    589         // pretend that network comes online
    590         expectCurrentTime();
    591         expectDefaultSettings();
    592         expectNetworkState(buildMobile3gState(IMSI_1));
    593         expectNetworkStatsSummary(buildEmptyStats());
    594         expectNetworkStatsUidDetail(buildEmptyStats());
    595         expectNetworkStatsPoll();
    596         expectBandwidthControlCheck();
    597 
    598         replay();
    599         mService.forceUpdateIfaces();
    600         verifyAndReset();
    601 
    602         // create some traffic
    603         incrementCurrentTime(HOUR_IN_MILLIS);
    604         expectCurrentTime();
    605         expectDefaultSettings();
    606         expectNetworkStatsSummary(buildEmptyStats());
    607         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 1)
    608                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 1024L, 8L, 1024L, 8L, 0L)
    609                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xF00D, 512L, 4L, 512L, 4L, 0L));
    610         expectNetworkStatsPoll();
    611 
    612         mService.incrementOperationCount(UID_RED, 0xF00D, 5);
    613 
    614         replay();
    615         forcePollAndWaitForIdle();
    616 
    617         // verify service recorded history
    618         assertUidTotal(sTemplateImsi1, UID_RED, 1024L, 8L, 1024L, 8L, 5);
    619         verifyAndReset();
    620 
    621         // now switch over to 4g network
    622         incrementCurrentTime(HOUR_IN_MILLIS);
    623         expectCurrentTime();
    624         expectDefaultSettings();
    625         expectNetworkState(buildMobile4gState(TEST_IFACE2));
    626         expectNetworkStatsSummary(buildEmptyStats());
    627         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 1)
    628                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 1024L, 8L, 1024L, 8L, 0L)
    629                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xF00D, 512L, 4L, 512L, 4L, 0L));
    630         expectNetworkStatsPoll();
    631         expectBandwidthControlCheck();
    632 
    633         replay();
    634         mService.forceUpdateIfaces();
    635         forcePollAndWaitForIdle();
    636         verifyAndReset();
    637 
    638         // create traffic on second network
    639         incrementCurrentTime(HOUR_IN_MILLIS);
    640         expectCurrentTime();
    641         expectDefaultSettings();
    642         expectNetworkStatsSummary(buildEmptyStats());
    643         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 1)
    644                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 1024L, 8L, 1024L, 8L, 0L)
    645                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xF00D, 512L, 4L, 512L, 4L, 0L)
    646                 .addValues(TEST_IFACE2, UID_RED, SET_DEFAULT, TAG_NONE, 512L, 4L, 256L, 2L, 0L)
    647                 .addValues(TEST_IFACE2, UID_RED, SET_DEFAULT, 0xFAAD, 512L, 4L, 256L, 2L, 0L));
    648         expectNetworkStatsPoll();
    649 
    650         mService.incrementOperationCount(UID_RED, 0xFAAD, 5);
    651 
    652         replay();
    653         forcePollAndWaitForIdle();
    654 
    655         // verify that ALL_MOBILE template combines both
    656         assertUidTotal(sTemplateImsi1, UID_RED, 1536L, 12L, 1280L, 10L, 10);
    657 
    658         verifyAndReset();
    659     }
    660 
    661     public void testSummaryForAllUid() throws Exception {
    662         // pretend that network comes online
    663         expectCurrentTime();
    664         expectDefaultSettings();
    665         expectNetworkState(buildWifiState());
    666         expectNetworkStatsSummary(buildEmptyStats());
    667         expectNetworkStatsUidDetail(buildEmptyStats());
    668         expectNetworkStatsPoll();
    669         expectBandwidthControlCheck();
    670 
    671         replay();
    672         mService.forceUpdateIfaces();
    673         verifyAndReset();
    674 
    675         // create some traffic for two apps
    676         incrementCurrentTime(HOUR_IN_MILLIS);
    677         expectCurrentTime();
    678         expectDefaultSettings();
    679         expectNetworkStatsSummary(buildEmptyStats());
    680         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 1)
    681                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 50L, 5L, 50L, 5L, 0L)
    682                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xF00D, 10L, 1L, 10L, 1L, 0L)
    683                 .addValues(TEST_IFACE, UID_BLUE, SET_DEFAULT, TAG_NONE, 1024L, 8L, 512L, 4L, 0L));
    684         expectNetworkStatsPoll();
    685 
    686         mService.incrementOperationCount(UID_RED, 0xF00D, 1);
    687 
    688         replay();
    689         forcePollAndWaitForIdle();
    690 
    691         // verify service recorded history
    692         assertUidTotal(sTemplateWifi, UID_RED, 50L, 5L, 50L, 5L, 1);
    693         assertUidTotal(sTemplateWifi, UID_BLUE, 1024L, 8L, 512L, 4L, 0);
    694         verifyAndReset();
    695 
    696         // now create more traffic in next hour, but only for one app
    697         incrementCurrentTime(HOUR_IN_MILLIS);
    698         expectCurrentTime();
    699         expectDefaultSettings();
    700         expectNetworkStatsSummary(buildEmptyStats());
    701         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 1)
    702                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 50L, 5L, 50L, 5L, 0L)
    703                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xF00D, 10L, 1L, 10L, 1L, 0L)
    704                 .addValues(TEST_IFACE, UID_BLUE, SET_DEFAULT, TAG_NONE, 2048L, 16L, 1024L, 8L, 0L));
    705         expectNetworkStatsPoll();
    706 
    707         replay();
    708         forcePollAndWaitForIdle();
    709 
    710         // first verify entire history present
    711         NetworkStats stats = mSession.getSummaryForAllUid(
    712                 sTemplateWifi, Long.MIN_VALUE, Long.MAX_VALUE, true);
    713         assertEquals(3, stats.size());
    714         assertValues(stats, IFACE_ALL, UID_RED, SET_DEFAULT, TAG_NONE, ROAMING_NO, 50L, 5L,
    715                 50L, 5L, 1);
    716         assertValues(stats, IFACE_ALL, UID_RED, SET_DEFAULT, 0xF00D, ROAMING_NO, 10L, 1L, 10L,
    717                 1L, 1);
    718         assertValues(stats, IFACE_ALL, UID_BLUE, SET_DEFAULT, TAG_NONE, ROAMING_NO, 2048L, 16L,
    719                 1024L, 8L, 0);
    720 
    721         // now verify that recent history only contains one uid
    722         final long currentTime = currentTimeMillis();
    723         stats = mSession.getSummaryForAllUid(
    724                 sTemplateWifi, currentTime - HOUR_IN_MILLIS, currentTime, true);
    725         assertEquals(1, stats.size());
    726         assertValues(stats, IFACE_ALL, UID_BLUE, SET_DEFAULT, TAG_NONE, ROAMING_NO, 1024L, 8L,
    727                 512L, 4L, 0);
    728 
    729         verifyAndReset();
    730     }
    731 
    732     public void testForegroundBackground() throws Exception {
    733         // pretend that network comes online
    734         expectCurrentTime();
    735         expectDefaultSettings();
    736         expectNetworkState(buildWifiState());
    737         expectNetworkStatsSummary(buildEmptyStats());
    738         expectNetworkStatsUidDetail(buildEmptyStats());
    739         expectNetworkStatsPoll();
    740         expectBandwidthControlCheck();
    741 
    742         replay();
    743         mService.forceUpdateIfaces();
    744         verifyAndReset();
    745 
    746         // create some initial traffic
    747         incrementCurrentTime(HOUR_IN_MILLIS);
    748         expectCurrentTime();
    749         expectDefaultSettings();
    750         expectNetworkStatsSummary(buildEmptyStats());
    751         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 1)
    752                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 128L, 2L, 128L, 2L, 0L)
    753                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xF00D, 64L, 1L, 64L, 1L, 0L));
    754         expectNetworkStatsPoll();
    755 
    756         mService.incrementOperationCount(UID_RED, 0xF00D, 1);
    757 
    758         replay();
    759         forcePollAndWaitForIdle();
    760 
    761         // verify service recorded history
    762         assertUidTotal(sTemplateWifi, UID_RED, 128L, 2L, 128L, 2L, 1);
    763         verifyAndReset();
    764 
    765         // now switch to foreground
    766         incrementCurrentTime(HOUR_IN_MILLIS);
    767         expectCurrentTime();
    768         expectDefaultSettings();
    769         expectNetworkStatsSummary(buildEmptyStats());
    770         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 1)
    771                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 128L, 2L, 128L, 2L, 0L)
    772                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xF00D, 64L, 1L, 64L, 1L, 0L)
    773                 .addValues(TEST_IFACE, UID_RED, SET_FOREGROUND, TAG_NONE, 32L, 2L, 32L, 2L, 0L)
    774                 .addValues(TEST_IFACE, UID_RED, SET_FOREGROUND, 0xFAAD, 1L, 1L, 1L, 1L, 0L));
    775         expectNetworkStatsPoll();
    776 
    777         mService.setUidForeground(UID_RED, true);
    778         mService.incrementOperationCount(UID_RED, 0xFAAD, 1);
    779 
    780         replay();
    781         forcePollAndWaitForIdle();
    782 
    783         // test that we combined correctly
    784         assertUidTotal(sTemplateWifi, UID_RED, 160L, 4L, 160L, 4L, 2);
    785 
    786         // verify entire history present
    787         final NetworkStats stats = mSession.getSummaryForAllUid(
    788                 sTemplateWifi, Long.MIN_VALUE, Long.MAX_VALUE, true);
    789         assertEquals(4, stats.size());
    790         assertValues(stats, IFACE_ALL, UID_RED, SET_DEFAULT, TAG_NONE, ROAMING_NO, 128L, 2L,
    791                 128L, 2L, 1);
    792         assertValues(stats, IFACE_ALL, UID_RED, SET_DEFAULT, 0xF00D, ROAMING_NO, 64L, 1L, 64L,
    793                 1L, 1);
    794         assertValues(stats, IFACE_ALL, UID_RED, SET_FOREGROUND, TAG_NONE, ROAMING_NO, 32L, 2L,
    795                 32L, 2L, 1);
    796         assertValues(stats, IFACE_ALL, UID_RED, SET_FOREGROUND, 0xFAAD, ROAMING_NO, 1L, 1L, 1L,
    797                 1L, 1);
    798 
    799         verifyAndReset();
    800     }
    801 
    802     public void testRoaming() throws Exception {
    803         // pretend that network comes online
    804         expectCurrentTime();
    805         expectDefaultSettings();
    806         expectNetworkState(buildMobile3gState(IMSI_1, true /* isRoaming */));
    807         expectNetworkStatsSummary(buildEmptyStats());
    808         expectNetworkStatsUidDetail(buildEmptyStats());
    809         expectNetworkStatsPoll();
    810         expectBandwidthControlCheck();
    811 
    812         replay();
    813         mService.forceUpdateIfaces();
    814         verifyAndReset();
    815 
    816         // Create some traffic
    817         incrementCurrentTime(HOUR_IN_MILLIS);
    818         expectCurrentTime();
    819         expectDefaultSettings();
    820         expectNetworkStatsSummary(buildEmptyStats());
    821         // Note that all traffic from NetworkManagementService is tagged as ROAMING_NO, because
    822         // roaming isn't tracked at that layer. We layer it on top by inspecting the iface
    823         // properties.
    824         expectNetworkStatsUidDetail(new NetworkStats(getElapsedRealtime(), 1)
    825                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, ROAMING_NO, 128L, 2L,
    826                         128L, 2L, 0L)
    827                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, 0xF00D, ROAMING_NO, 64L, 1L, 64L,
    828                         1L, 0L));
    829         expectNetworkStatsPoll();
    830 
    831         replay();
    832         forcePollAndWaitForIdle();
    833 
    834         // verify service recorded history
    835         assertUidTotal(sTemplateImsi1, UID_RED, 128L, 2L, 128L, 2L, 0);
    836 
    837         // verify entire history present
    838         final NetworkStats stats = mSession.getSummaryForAllUid(
    839                 sTemplateImsi1, Long.MIN_VALUE, Long.MAX_VALUE, true);
    840         assertEquals(2, stats.size());
    841         assertValues(stats, IFACE_ALL, UID_RED, SET_DEFAULT, TAG_NONE, ROAMING_YES, 128L, 2L,
    842                 128L, 2L, 0);
    843         assertValues(stats, IFACE_ALL, UID_RED, SET_DEFAULT, 0xF00D, ROAMING_YES, 64L, 1L, 64L,
    844                 1L, 0);
    845 
    846         verifyAndReset();
    847     }
    848 
    849     public void testTethering() throws Exception {
    850         // pretend first mobile network comes online
    851         expectCurrentTime();
    852         expectDefaultSettings();
    853         expectNetworkState(buildMobile3gState(IMSI_1));
    854         expectNetworkStatsSummary(buildEmptyStats());
    855         expectNetworkStatsUidDetail(buildEmptyStats());
    856         expectNetworkStatsPoll();
    857         expectBandwidthControlCheck();
    858 
    859         replay();
    860         mService.forceUpdateIfaces();
    861         verifyAndReset();
    862 
    863         // create some tethering traffic
    864         incrementCurrentTime(HOUR_IN_MILLIS);
    865         expectCurrentTime();
    866         expectDefaultSettings();
    867         expectNetworkStatsSummary(new NetworkStats(getElapsedRealtime(), 1)
    868                 .addIfaceValues(TEST_IFACE, 2048L, 16L, 512L, 4L));
    869 
    870         final NetworkStats uidStats = new NetworkStats(getElapsedRealtime(), 1)
    871                 .addValues(TEST_IFACE, UID_RED, SET_DEFAULT, TAG_NONE, 128L, 2L, 128L, 2L, 0L);
    872         final String[] tetherIfacePairs = new String[] { TEST_IFACE, "wlan0" };
    873         final NetworkStats tetherStats = new NetworkStats(getElapsedRealtime(), 1)
    874                 .addValues(TEST_IFACE, UID_TETHERING, SET_DEFAULT, TAG_NONE, 1920L, 14L, 384L, 2L, 0L);
    875 
    876         expectNetworkStatsUidDetail(uidStats, tetherIfacePairs, tetherStats);
    877         expectNetworkStatsPoll();
    878 
    879         replay();
    880         forcePollAndWaitForIdle();
    881 
    882         // verify service recorded history
    883         assertNetworkTotal(sTemplateImsi1, 2048L, 16L, 512L, 4L, 0);
    884         assertUidTotal(sTemplateImsi1, UID_RED, 128L, 2L, 128L, 2L, 0);
    885         assertUidTotal(sTemplateImsi1, UID_TETHERING, 1920L, 14L, 384L, 2L, 0);
    886         verifyAndReset();
    887 
    888     }
    889 
    890     public void testRegisterUsageCallback() throws Exception {
    891         // pretend that wifi network comes online; service should ask about full
    892         // network state, and poll any existing interfaces before updating.
    893         expectCurrentTime();
    894         expectDefaultSettings();
    895         expectNetworkState(buildWifiState());
    896         expectNetworkStatsSummary(buildEmptyStats());
    897         expectNetworkStatsUidDetail(buildEmptyStats());
    898         expectNetworkStatsPoll();
    899         expectBandwidthControlCheck();
    900 
    901         replay();
    902         mService.forceUpdateIfaces();
    903 
    904         // verify service has empty history for wifi
    905         assertNetworkTotal(sTemplateWifi, 0L, 0L, 0L, 0L, 0);
    906         verifyAndReset();
    907 
    908         String callingPackage = "the.calling.package";
    909         long thresholdInBytes = 1L;  // very small; should be overriden by framework
    910         DataUsageRequest inputRequest = new DataUsageRequest(
    911                 DataUsageRequest.REQUEST_ID_UNSET, sTemplateWifi, thresholdInBytes);
    912 
    913         // Create a messenger that waits for callback activity
    914         ConditionVariable cv = new ConditionVariable(false);
    915         LatchedHandler latchedHandler = new LatchedHandler(Looper.getMainLooper(), cv);
    916         Messenger messenger = new Messenger(latchedHandler);
    917 
    918         // Allow binder to connect
    919         IBinder mockBinder = createMock(IBinder.class);
    920         mockBinder.linkToDeath((IBinder.DeathRecipient) anyObject(), anyInt());
    921         EasyMock.replay(mockBinder);
    922 
    923         // Force poll
    924         expectCurrentTime();
    925         expectDefaultSettings();
    926         expectNetworkStatsSummary(buildEmptyStats());
    927         expectNetworkStatsUidDetail(buildEmptyStats());
    928         expectNetworkStatsPoll();
    929         replay();
    930 
    931         // Register and verify request and that binder was called
    932         DataUsageRequest request =
    933                 mService.registerUsageCallback(callingPackage, inputRequest,
    934                         messenger, mockBinder);
    935         assertTrue(request.requestId > 0);
    936         assertTrue(Objects.equals(sTemplateWifi, request.template));
    937         long minThresholdInBytes = 2 * 1024 * 1024; // 2 MB
    938         assertEquals(minThresholdInBytes, request.thresholdInBytes);
    939 
    940         // Send dummy message to make sure that any previous message has been handled
    941         mHandler.sendMessage(mHandler.obtainMessage(-1));
    942         mHandlerThread.waitForIdle(WAIT_TIMEOUT);
    943 
    944         verifyAndReset();
    945 
    946         // Make sure that the caller binder gets connected
    947         EasyMock.verify(mockBinder);
    948         EasyMock.reset(mockBinder);
    949 
    950         // modify some number on wifi, and trigger poll event
    951         // not enough traffic to call data usage callback
    952         incrementCurrentTime(HOUR_IN_MILLIS);
    953         expectCurrentTime();
    954         expectDefaultSettings();
    955         expectNetworkStatsSummary(new NetworkStats(getElapsedRealtime(), 1)
    956                 .addIfaceValues(TEST_IFACE, 1024L, 1L, 2048L, 2L));
    957         expectNetworkStatsUidDetail(buildEmptyStats());
    958         expectNetworkStatsPoll();
    959 
    960         replay();
    961         forcePollAndWaitForIdle();
    962 
    963         // verify service recorded history
    964         verifyAndReset();
    965         assertNetworkTotal(sTemplateWifi, 1024L, 1L, 2048L, 2L, 0);
    966 
    967         // make sure callback has not being called
    968         assertEquals(INVALID_TYPE, latchedHandler.mLastMessageType);
    969 
    970         // and bump forward again, with counters going higher. this is
    971         // important, since it will trigger the data usage callback
    972         incrementCurrentTime(DAY_IN_MILLIS);
    973         expectCurrentTime();
    974         expectDefaultSettings();
    975         expectNetworkStatsSummary(new NetworkStats(getElapsedRealtime(), 1)
    976                 .addIfaceValues(TEST_IFACE, 4096000L, 4L, 8192000L, 8L));
    977         expectNetworkStatsUidDetail(buildEmptyStats());
    978         expectNetworkStatsPoll();
    979 
    980         replay();
    981         forcePollAndWaitForIdle();
    982 
    983         // verify service recorded history
    984         assertNetworkTotal(sTemplateWifi, 4096000L, 4L, 8192000L, 8L, 0);
    985         verifyAndReset();
    986 
    987         // Wait for the caller to ack receipt of CALLBACK_LIMIT_REACHED
    988         assertTrue(cv.block(WAIT_TIMEOUT));
    989         assertEquals(NetworkStatsManager.CALLBACK_LIMIT_REACHED, latchedHandler.mLastMessageType);
    990         cv.close();
    991 
    992         // Allow binder to disconnect
    993         expect(mockBinder.unlinkToDeath((IBinder.DeathRecipient) anyObject(), anyInt()))
    994                 .andReturn(true);
    995         EasyMock.replay(mockBinder);
    996 
    997         // Unregister request
    998         mService.unregisterUsageRequest(request);
    999 
   1000         // Wait for the caller to ack receipt of CALLBACK_RELEASED
   1001         assertTrue(cv.block(WAIT_TIMEOUT));
   1002         assertEquals(NetworkStatsManager.CALLBACK_RELEASED, latchedHandler.mLastMessageType);
   1003 
   1004         // Make sure that the caller binder gets disconnected
   1005         EasyMock.verify(mockBinder);
   1006     }
   1007 
   1008     public void testUnregisterUsageCallback_unknown_noop() throws Exception {
   1009         String callingPackage = "the.calling.package";
   1010         long thresholdInBytes = 10 * 1024 * 1024;  // 10 MB
   1011         DataUsageRequest unknownRequest = new DataUsageRequest(
   1012                 2 /* requestId */, sTemplateImsi1, thresholdInBytes);
   1013 
   1014         mService.unregisterUsageRequest(unknownRequest);
   1015     }
   1016 
   1017     private static File getBaseDir(File statsDir) {
   1018         File baseDir = new File(statsDir, "netstats");
   1019         baseDir.mkdirs();
   1020         return baseDir;
   1021     }
   1022 
   1023     private void assertNetworkTotal(NetworkTemplate template, long rxBytes, long rxPackets,
   1024             long txBytes, long txPackets, int operations) throws Exception {
   1025         assertNetworkTotal(template, Long.MIN_VALUE, Long.MAX_VALUE, rxBytes, rxPackets, txBytes,
   1026                 txPackets, operations);
   1027     }
   1028 
   1029     private void assertNetworkTotal(NetworkTemplate template, long start, long end, long rxBytes,
   1030             long rxPackets, long txBytes, long txPackets, int operations) throws Exception {
   1031         // verify history API
   1032         final NetworkStatsHistory history = mSession.getHistoryForNetwork(template, FIELD_ALL);
   1033         assertValues(history, start, end, rxBytes, rxPackets, txBytes, txPackets, operations);
   1034 
   1035         // verify summary API
   1036         final NetworkStats stats = mSession.getSummaryForNetwork(template, start, end);
   1037         assertValues(stats, IFACE_ALL, UID_ALL, SET_DEFAULT, TAG_NONE, ROAMING_NO, rxBytes,
   1038                 rxPackets, txBytes, txPackets, operations);
   1039     }
   1040 
   1041     private void assertUidTotal(NetworkTemplate template, int uid, long rxBytes, long rxPackets,
   1042             long txBytes, long txPackets, int operations) throws Exception {
   1043         assertUidTotal(template, uid, SET_ALL, ROAMING_ALL, rxBytes, rxPackets, txBytes, txPackets,
   1044                 operations);
   1045     }
   1046 
   1047     private void assertUidTotal(NetworkTemplate template, int uid, int set, int roaming,
   1048             long rxBytes, long rxPackets, long txBytes, long txPackets, int operations)
   1049             throws Exception {
   1050         // verify history API
   1051         final NetworkStatsHistory history = mSession.getHistoryForUid(
   1052                 template, uid, set, TAG_NONE, FIELD_ALL);
   1053         assertValues(history, Long.MIN_VALUE, Long.MAX_VALUE, rxBytes, rxPackets, txBytes,
   1054                 txPackets, operations);
   1055 
   1056         // verify summary API
   1057         final NetworkStats stats = mSession.getSummaryForAllUid(
   1058                 template, Long.MIN_VALUE, Long.MAX_VALUE, false);
   1059         assertValues(stats, IFACE_ALL, uid, set, TAG_NONE, roaming, rxBytes, rxPackets, txBytes,
   1060                 txPackets, operations);
   1061     }
   1062 
   1063     private void expectSystemReady() throws Exception {
   1064         mNetManager.setGlobalAlert(anyLong());
   1065         expectLastCall().atLeastOnce();
   1066 
   1067         expectNetworkStatsSummary(buildEmptyStats());
   1068         expectBandwidthControlCheck();
   1069     }
   1070 
   1071     private void expectNetworkState(NetworkState... state) throws Exception {
   1072         expect(mConnManager.getAllNetworkState()).andReturn(state).atLeastOnce();
   1073 
   1074         final LinkProperties linkProp = state.length > 0 ? state[0].linkProperties : null;
   1075         expect(mConnManager.getActiveLinkProperties()).andReturn(linkProp).atLeastOnce();
   1076     }
   1077 
   1078     private void expectNetworkStatsSummary(NetworkStats summary) throws Exception {
   1079         expect(mConnManager.getAllVpnInfo()).andReturn(new VpnInfo[0]).atLeastOnce();
   1080 
   1081         expectNetworkStatsSummaryDev(summary);
   1082         expectNetworkStatsSummaryXt(summary);
   1083     }
   1084 
   1085     private void expectNetworkStatsSummaryDev(NetworkStats summary) throws Exception {
   1086         expect(mNetManager.getNetworkStatsSummaryDev()).andReturn(summary).atLeastOnce();
   1087     }
   1088 
   1089     private void expectNetworkStatsSummaryXt(NetworkStats summary) throws Exception {
   1090         expect(mNetManager.getNetworkStatsSummaryXt()).andReturn(summary).atLeastOnce();
   1091     }
   1092 
   1093     private void expectNetworkStatsUidDetail(NetworkStats detail) throws Exception {
   1094         expectNetworkStatsUidDetail(detail, new String[0], new NetworkStats(0L, 0));
   1095     }
   1096 
   1097     private void expectNetworkStatsUidDetail(
   1098             NetworkStats detail, String[] tetherIfacePairs, NetworkStats tetherStats)
   1099             throws Exception {
   1100         expect(mNetManager.getNetworkStatsUidDetail(eq(UID_ALL))).andReturn(detail).atLeastOnce();
   1101 
   1102         // also include tethering details, since they are folded into UID
   1103         expect(mNetManager.getNetworkStatsTethering())
   1104                 .andReturn(tetherStats).atLeastOnce();
   1105     }
   1106 
   1107     private void expectDefaultSettings() throws Exception {
   1108         expectSettings(0L, HOUR_IN_MILLIS, WEEK_IN_MILLIS);
   1109     }
   1110 
   1111     private void expectSettings(long persistBytes, long bucketDuration, long deleteAge)
   1112             throws Exception {
   1113         expect(mSettings.getPollInterval()).andReturn(HOUR_IN_MILLIS).anyTimes();
   1114         expect(mSettings.getTimeCacheMaxAge()).andReturn(DAY_IN_MILLIS).anyTimes();
   1115         expect(mSettings.getSampleEnabled()).andReturn(true).anyTimes();
   1116 
   1117         final Config config = new Config(bucketDuration, deleteAge, deleteAge);
   1118         expect(mSettings.getDevConfig()).andReturn(config).anyTimes();
   1119         expect(mSettings.getXtConfig()).andReturn(config).anyTimes();
   1120         expect(mSettings.getUidConfig()).andReturn(config).anyTimes();
   1121         expect(mSettings.getUidTagConfig()).andReturn(config).anyTimes();
   1122 
   1123         expect(mSettings.getGlobalAlertBytes(anyLong())).andReturn(MB_IN_BYTES).anyTimes();
   1124         expect(mSettings.getDevPersistBytes(anyLong())).andReturn(MB_IN_BYTES).anyTimes();
   1125         expect(mSettings.getXtPersistBytes(anyLong())).andReturn(MB_IN_BYTES).anyTimes();
   1126         expect(mSettings.getUidPersistBytes(anyLong())).andReturn(MB_IN_BYTES).anyTimes();
   1127         expect(mSettings.getUidTagPersistBytes(anyLong())).andReturn(MB_IN_BYTES).anyTimes();
   1128     }
   1129 
   1130     private void expectCurrentTime() throws Exception {
   1131         expect(mTime.forceRefresh()).andReturn(false).anyTimes();
   1132         expect(mTime.hasCache()).andReturn(true).anyTimes();
   1133         expect(mTime.currentTimeMillis()).andReturn(currentTimeMillis()).anyTimes();
   1134         expect(mTime.getCacheAge()).andReturn(0L).anyTimes();
   1135         expect(mTime.getCacheCertainty()).andReturn(0L).anyTimes();
   1136     }
   1137 
   1138     private void expectNetworkStatsPoll() throws Exception {
   1139         mNetManager.setGlobalAlert(anyLong());
   1140         expectLastCall().anyTimes();
   1141     }
   1142 
   1143     private void expectBandwidthControlCheck() throws Exception {
   1144         expect(mNetManager.isBandwidthControlEnabled()).andReturn(true).atLeastOnce();
   1145     }
   1146 
   1147     private void assertStatsFilesExist(boolean exist) {
   1148         final File basePath = new File(mStatsDir, "netstats");
   1149         if (exist) {
   1150             assertTrue(basePath.list().length > 0);
   1151         } else {
   1152             assertTrue(basePath.list().length == 0);
   1153         }
   1154     }
   1155 
   1156     private static void assertValues(NetworkStats stats, String iface, int uid, int set,
   1157             int tag, int roaming, long rxBytes, long rxPackets, long txBytes, long txPackets,
   1158             int operations) {
   1159         final NetworkStats.Entry entry = new NetworkStats.Entry();
   1160         List<Integer> sets = new ArrayList<>();
   1161         if (set == SET_DEFAULT || set == SET_ALL) {
   1162             sets.add(SET_DEFAULT);
   1163         }
   1164         if (set == SET_FOREGROUND || set == SET_ALL) {
   1165             sets.add(SET_FOREGROUND);
   1166         }
   1167 
   1168         List<Integer> roamings = new ArrayList<>();
   1169         if (roaming == ROAMING_NO || roaming == ROAMING_ALL) {
   1170             roamings.add(ROAMING_NO);
   1171         }
   1172         if (roaming == ROAMING_YES || roaming == ROAMING_ALL) {
   1173             roamings.add(ROAMING_YES);
   1174         }
   1175 
   1176         for (int s : sets) {
   1177             for (int r : roamings) {
   1178                 final int i = stats.findIndex(iface, uid, s, tag, r);
   1179                 if (i != -1) {
   1180                     entry.add(stats.getValues(i, null));
   1181                 }
   1182             }
   1183         }
   1184 
   1185         assertEquals("unexpected rxBytes", rxBytes, entry.rxBytes);
   1186         assertEquals("unexpected rxPackets", rxPackets, entry.rxPackets);
   1187         assertEquals("unexpected txBytes", txBytes, entry.txBytes);
   1188         assertEquals("unexpected txPackets", txPackets, entry.txPackets);
   1189         assertEquals("unexpected operations", operations, entry.operations);
   1190     }
   1191 
   1192     private static void assertValues(NetworkStatsHistory stats, long start, long end, long rxBytes,
   1193             long rxPackets, long txBytes, long txPackets, int operations) {
   1194         final NetworkStatsHistory.Entry entry = stats.getValues(start, end, null);
   1195         assertEquals("unexpected rxBytes", rxBytes, entry.rxBytes);
   1196         assertEquals("unexpected rxPackets", rxPackets, entry.rxPackets);
   1197         assertEquals("unexpected txBytes", txBytes, entry.txBytes);
   1198         assertEquals("unexpected txPackets", txPackets, entry.txPackets);
   1199         assertEquals("unexpected operations", operations, entry.operations);
   1200     }
   1201 
   1202     private static NetworkState buildWifiState() {
   1203         final NetworkInfo info = new NetworkInfo(TYPE_WIFI, 0, null, null);
   1204         info.setDetailedState(DetailedState.CONNECTED, null, null);
   1205         final LinkProperties prop = new LinkProperties();
   1206         prop.setInterfaceName(TEST_IFACE);
   1207         return new NetworkState(info, prop, null, null, null, TEST_SSID);
   1208     }
   1209 
   1210     private static NetworkState buildMobile3gState(String subscriberId) {
   1211         return buildMobile3gState(subscriberId, false /* isRoaming */);
   1212     }
   1213 
   1214     private static NetworkState buildMobile3gState(String subscriberId, boolean isRoaming) {
   1215         final NetworkInfo info = new NetworkInfo(
   1216                 TYPE_MOBILE, TelephonyManager.NETWORK_TYPE_UMTS, null, null);
   1217         info.setDetailedState(DetailedState.CONNECTED, null, null);
   1218         info.setRoaming(isRoaming);
   1219         final LinkProperties prop = new LinkProperties();
   1220         prop.setInterfaceName(TEST_IFACE);
   1221         return new NetworkState(info, prop, null, null, subscriberId, null);
   1222     }
   1223 
   1224     private static NetworkState buildMobile4gState(String iface) {
   1225         final NetworkInfo info = new NetworkInfo(TYPE_WIMAX, 0, null, null);
   1226         info.setDetailedState(DetailedState.CONNECTED, null, null);
   1227         final LinkProperties prop = new LinkProperties();
   1228         prop.setInterfaceName(iface);
   1229         return new NetworkState(info, prop, null, null, null, null);
   1230     }
   1231 
   1232     private NetworkStats buildEmptyStats() {
   1233         return new NetworkStats(getElapsedRealtime(), 0);
   1234     }
   1235 
   1236     private long getElapsedRealtime() {
   1237         return mElapsedRealtime;
   1238     }
   1239 
   1240     private long startTimeMillis() {
   1241         return TEST_START;
   1242     }
   1243 
   1244     private long currentTimeMillis() {
   1245         return startTimeMillis() + mElapsedRealtime;
   1246     }
   1247 
   1248     private void incrementCurrentTime(long duration) {
   1249         mElapsedRealtime += duration;
   1250     }
   1251 
   1252     private void replay() {
   1253         EasyMock.replay(mNetManager, mTime, mSettings, mConnManager);
   1254     }
   1255 
   1256     private void verifyAndReset() {
   1257         EasyMock.verify(mNetManager, mTime, mSettings, mConnManager);
   1258         EasyMock.reset(mNetManager, mTime, mSettings, mConnManager);
   1259     }
   1260 
   1261     private void forcePollAndWaitForIdle() {
   1262         mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
   1263         // Send dummy message to make sure that any previous message has been handled
   1264         mHandler.sendMessage(mHandler.obtainMessage(-1));
   1265         mHandlerThread.waitForIdle(WAIT_TIMEOUT);
   1266     }
   1267 
   1268     static class LatchedHandler extends Handler {
   1269         private final ConditionVariable mCv;
   1270         int mLastMessageType = INVALID_TYPE;
   1271 
   1272         LatchedHandler(Looper looper, ConditionVariable cv) {
   1273             super(looper);
   1274             mCv = cv;
   1275         }
   1276 
   1277         @Override
   1278         public void handleMessage(Message msg) {
   1279             mLastMessageType = msg.what;
   1280             mCv.open();
   1281             super.handleMessage(msg);
   1282         }
   1283     }
   1284 
   1285     /**
   1286      * A subclass of HandlerThread that allows callers to wait for it to become idle. waitForIdle
   1287      * will return immediately if the handler is already idle.
   1288      */
   1289     static class IdleableHandlerThread extends HandlerThread {
   1290         private IdleHandler mIdleHandler;
   1291 
   1292         public IdleableHandlerThread(String name) {
   1293             super(name);
   1294         }
   1295 
   1296         public void waitForIdle(long timeoutMs) {
   1297             final ConditionVariable cv = new ConditionVariable();
   1298             final MessageQueue queue = getLooper().getQueue();
   1299 
   1300             synchronized (queue) {
   1301                 if (queue.isIdle()) {
   1302                     return;
   1303                 }
   1304 
   1305                 assertNull("BUG: only one idle handler allowed", mIdleHandler);
   1306                 mIdleHandler = new IdleHandler() {
   1307                     public boolean queueIdle() {
   1308                         cv.open();
   1309                         mIdleHandler = null;
   1310                         return false;  // Remove the handler.
   1311                     }
   1312                 };
   1313                 queue.addIdleHandler(mIdleHandler);
   1314             }
   1315 
   1316             if (!cv.block(timeoutMs)) {
   1317                 fail("HandlerThread " + getName() + " did not become idle after " + timeoutMs
   1318                         + " ms");
   1319                 queue.removeIdleHandler(mIdleHandler);
   1320             }
   1321         }
   1322     }
   1323 
   1324 }
   1325