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