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

Hide NetworkStatsHistory internals.

Browse Source 
Instead of exposing internal storage details, offer getValues()
accessor which populates values into a recycled structure.

Change-Id: I5228d7099a8f61b2018a435a813435a67dae49b4
This commit is contained in:
Jeff Sharkey
2011-07-12 13:57:00 -07:00
parent 337b986b98
commit aa731e75a9
3 changed files with 154 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
core/tests/coretests/src/android/net/NetworkStatsHistoryTest.java
View File

@@ -54,8 +54,8 @@ public class NetworkStatsHistoryTest extends TestCase {
// record data into narrow window to get single bucket // record data into narrow window to get single bucket
stats.recordData(TEST_START, TEST_START + SECOND_IN_MILLIS, 1024L, 2048L); stats.recordData(TEST_START, TEST_START + SECOND_IN_MILLIS, 1024L, 2048L);
assertEquals(1, stats.bucketCount); assertEquals(1, stats.size());
assertBucket(stats, 0, 1024L, 2048L); assertEntry(stats, 0, 1024L, 2048L);
} }
public void testRecordEqualBuckets() throws Exception { public void testRecordEqualBuckets() throws Exception {
@@ -66,9 +66,9 @@ public class NetworkStatsHistoryTest extends TestCase {
final long recordStart = TEST_START + (bucketDuration / 2); final long recordStart = TEST_START + (bucketDuration / 2);
stats.recordData(recordStart, recordStart + bucketDuration, 1024L, 128L); stats.recordData(recordStart, recordStart + bucketDuration, 1024L, 128L);
assertEquals(2, stats.bucketCount); assertEquals(2, stats.size());
assertBucket(stats, 0, 512L, 64L); assertEntry(stats, 0, 512L, 64L);
assertBucket(stats, 1, 512L, 64L); assertEntry(stats, 1, 512L, 64L);
} }
public void testRecordTouchingBuckets() throws Exception { public void testRecordTouchingBuckets() throws Exception {
@@ -81,13 +81,13 @@ public class NetworkStatsHistoryTest extends TestCase {
final long recordEnd = (TEST_START + (BUCKET_SIZE * 2)) + (MINUTE_IN_MILLIS * 4); final long recordEnd = (TEST_START + (BUCKET_SIZE * 2)) + (MINUTE_IN_MILLIS * 4);
stats.recordData(recordStart, recordEnd, 1000L, 5000L); stats.recordData(recordStart, recordEnd, 1000L, 5000L);
assertEquals(3, stats.bucketCount); assertEquals(3, stats.size());
// first bucket should have (1/20 of value) // first bucket should have (1/20 of value)
assertBucket(stats, 0, 50L, 250L); assertEntry(stats, 0, 50L, 250L);
// second bucket should have (15/20 of value) // second bucket should have (15/20 of value)
assertBucket(stats, 1, 750L, 3750L); assertEntry(stats, 1, 750L, 3750L);
// final bucket should have (4/20 of value) // final bucket should have (4/20 of value)
assertBucket(stats, 2, 200L, 1000L); assertEntry(stats, 2, 200L, 1000L);
} }
public void testRecordGapBuckets() throws Exception { public void testRecordGapBuckets() throws Exception {
@@ -101,9 +101,9 @@ public class NetworkStatsHistoryTest extends TestCase {
stats.recordData(lastStart, lastStart + SECOND_IN_MILLIS, 64L, 512L); stats.recordData(lastStart, lastStart + SECOND_IN_MILLIS, 64L, 512L);
// we should have two buckets, far apart from each other // we should have two buckets, far apart from each other
assertEquals(2, stats.bucketCount); assertEquals(2, stats.size());
assertBucket(stats, 0, 128L, 256L); assertEntry(stats, 0, 128L, 256L);
assertBucket(stats, 1, 64L, 512L); assertEntry(stats, 1, 64L, 512L);
// now record something in middle, spread across two buckets // now record something in middle, spread across two buckets
final long middleStart = TEST_START + DAY_IN_MILLIS; final long middleStart = TEST_START + DAY_IN_MILLIS;
@@ -111,11 +111,11 @@ public class NetworkStatsHistoryTest extends TestCase {
stats.recordData(middleStart, middleEnd, 2048L, 2048L); stats.recordData(middleStart, middleEnd, 2048L, 2048L);
// now should have four buckets, with new record in middle two buckets // now should have four buckets, with new record in middle two buckets
assertEquals(4, stats.bucketCount); assertEquals(4, stats.size());
assertBucket(stats, 0, 128L, 256L); assertEntry(stats, 0, 128L, 256L);
assertBucket(stats, 1, 1024L, 1024L); assertEntry(stats, 1, 1024L, 1024L);
assertBucket(stats, 2, 1024L, 1024L); assertEntry(stats, 2, 1024L, 1024L);
assertBucket(stats, 3, 64L, 512L); assertEntry(stats, 3, 64L, 512L);
} }
public void testRecordOverlapBuckets() throws Exception { public void testRecordOverlapBuckets() throws Exception {
@@ -128,9 +128,9 @@ public class NetworkStatsHistoryTest extends TestCase {
stats.recordData(midStart, midStart + HOUR_IN_MILLIS, 1024L, 1024L); stats.recordData(midStart, midStart + HOUR_IN_MILLIS, 1024L, 1024L);
// should have two buckets, with some data mixed together // should have two buckets, with some data mixed together
assertEquals(2, stats.bucketCount); assertEquals(2, stats.size());
assertBucket(stats, 0, 768L, 768L); assertEntry(stats, 0, 768L, 768L);
assertBucket(stats, 1, 512L, 512L); assertEntry(stats, 1, 512L, 512L);
} }
public void testRecordEntireGapIdentical() throws Exception { public void testRecordEntireGapIdentical() throws Exception {
@@ -154,10 +154,10 @@ public class NetworkStatsHistoryTest extends TestCase {
assertTotalEquals(total, 3000L, 1500L); assertTotalEquals(total, 3000L, 1500L);
// now inspect internal buckets // now inspect internal buckets
assertBucket(stats, 0, 1000L, 500L); assertEntry(stats, 0, 1000L, 500L);
assertBucket(stats, 1, 1000L, 500L); assertEntry(stats, 1, 1000L, 500L);
assertBucket(stats, 2, 500L, 250L); assertEntry(stats, 2, 500L, 250L);
assertBucket(stats, 3, 500L, 250L); assertEntry(stats, 3, 500L, 250L);
} }
public void testRecordEntireOverlapVaryingBuckets() throws Exception { public void testRecordEntireOverlapVaryingBuckets() throws Exception {
@@ -181,13 +181,13 @@ public class NetworkStatsHistoryTest extends TestCase {
assertTotalEquals(total, 650L, 650L); assertTotalEquals(total, 650L, 650L);
// now inspect internal buckets // now inspect internal buckets
assertBucket(stats, 0, 10L, 10L); assertEntry(stats, 0, 10L, 10L);
assertBucket(stats, 1, 20L, 20L); assertEntry(stats, 1, 20L, 20L);
assertBucket(stats, 2, 20L, 20L); assertEntry(stats, 2, 20L, 20L);
assertBucket(stats, 3, 20L, 20L); assertEntry(stats, 3, 20L, 20L);
assertBucket(stats, 4, 20L, 20L); assertEntry(stats, 4, 20L, 20L);
assertBucket(stats, 5, 20L, 20L); assertEntry(stats, 5, 20L, 20L);
assertBucket(stats, 6, 10L, 10L); assertEntry(stats, 6, 10L, 10L);
// now combine using 15min buckets // now combine using 15min buckets
stats = new NetworkStatsHistory(HOUR_IN_MILLIS / 4); stats = new NetworkStatsHistory(HOUR_IN_MILLIS / 4);
@@ -199,10 +199,10 @@ public class NetworkStatsHistoryTest extends TestCase {
assertTotalEquals(total, 650L, 650L); assertTotalEquals(total, 650L, 650L);
// and inspect buckets // and inspect buckets
assertBucket(stats, 0, 200L, 200L); assertEntry(stats, 0, 200L, 200L);
assertBucket(stats, 1, 150L, 150L); assertEntry(stats, 1, 150L, 150L);
assertBucket(stats, 2, 150L, 150L); assertEntry(stats, 2, 150L, 150L);
assertBucket(stats, 3, 150L, 150L); assertEntry(stats, 3, 150L, 150L);
} }
public void testRemove() throws Exception { public void testRemove() throws Exception {
@@ -210,28 +210,28 @@ public class NetworkStatsHistoryTest extends TestCase {
// record some data across 24 buckets // record some data across 24 buckets
stats.recordData(TEST_START, TEST_START + DAY_IN_MILLIS, 24L, 24L); stats.recordData(TEST_START, TEST_START + DAY_IN_MILLIS, 24L, 24L);
assertEquals(24, stats.bucketCount); assertEquals(24, stats.size());
// try removing far before buckets; should be no change // try removing far before buckets; should be no change
stats.removeBucketsBefore(TEST_START - YEAR_IN_MILLIS); stats.removeBucketsBefore(TEST_START - YEAR_IN_MILLIS);
assertEquals(24, stats.bucketCount); assertEquals(24, stats.size());
// try removing just moments into first bucket; should be no change // try removing just moments into first bucket; should be no change
// since that bucket contains data beyond the cutoff // since that bucket contains data beyond the cutoff
stats.removeBucketsBefore(TEST_START + SECOND_IN_MILLIS); stats.removeBucketsBefore(TEST_START + SECOND_IN_MILLIS);
assertEquals(24, stats.bucketCount); assertEquals(24, stats.size());
// try removing single bucket // try removing single bucket
stats.removeBucketsBefore(TEST_START + HOUR_IN_MILLIS); stats.removeBucketsBefore(TEST_START + HOUR_IN_MILLIS);
assertEquals(23, stats.bucketCount); assertEquals(23, stats.size());
// try removing multiple buckets // try removing multiple buckets
stats.removeBucketsBefore(TEST_START + (4 * HOUR_IN_MILLIS)); stats.removeBucketsBefore(TEST_START + (4 * HOUR_IN_MILLIS));
assertEquals(20, stats.bucketCount); assertEquals(20, stats.size());
// try removing all buckets // try removing all buckets
stats.removeBucketsBefore(TEST_START + YEAR_IN_MILLIS); stats.removeBucketsBefore(TEST_START + YEAR_IN_MILLIS);
assertEquals(0, stats.bucketCount); assertEquals(0, stats.size());
} }
public void testTotalData() throws Exception { public void testTotalData() throws Exception {
@@ -293,19 +293,25 @@ public class NetworkStatsHistoryTest extends TestCase {
private static void assertConsistent(NetworkStatsHistory stats) { private static void assertConsistent(NetworkStatsHistory stats) {
// verify timestamps are monotonic // verify timestamps are monotonic
for (int i = 1; i < stats.bucketCount; i++) { long lastStart = Long.MIN_VALUE;
assertTrue(stats.bucketStart[i - 1] < stats.bucketStart[i]); NetworkStatsHistory.Entry entry = null;
for (int i = 0; i < stats.size(); i++) {
entry = stats.getValues(i, entry);
assertTrue(lastStart < entry.bucketStart);
lastStart = entry.bucketStart;
} }
} }
private static void assertTotalEquals(long[] total, long rx, long tx) { private static void assertTotalEquals(long[] total, long rxBytes, long txBytes) {
assertEquals("unexpected rx", rx, total[0]); assertEquals("unexpected rxBytes", rxBytes, total[0]);
assertEquals("unexpected tx", tx, total[1]); assertEquals("unexpected txBytes", txBytes, total[1]);
} }
private static void assertBucket(NetworkStatsHistory stats, int index, long rx, long tx) { private static void assertEntry(
assertEquals("unexpected rx", rx, stats.rx[index]); NetworkStatsHistory stats, int index, long rxBytes, long txBytes) {
assertEquals("unexpected tx", tx, stats.tx[index]); final NetworkStatsHistory.Entry entry = stats.getValues(index, null);
assertEquals("unexpected rxBytes", rxBytes, entry.rxBytes);
assertEquals("unexpected txBytes", txBytes, entry.txBytes);
} }
} }

114
core/tests/coretests/src/android/net/NetworkStatsTest.java
View File

@@ -31,9 +31,9 @@ public class NetworkStatsTest extends TestCase {
public void testFindIndex() throws Exception { public void testFindIndex() throws Exception {
final NetworkStats stats = new NetworkStats(TEST_START, 3) final NetworkStats stats = new NetworkStats(TEST_START, 3)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L) .addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L) .addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L)
.addEntry(TEST_IFACE, 102, TAG_NONE, 1024L, 1024L); .addValues(TEST_IFACE, 102, TAG_NONE, 1024L, 8L, 1024L, 8L);
assertEquals(2, stats.findIndex(TEST_IFACE, 102, TAG_NONE)); assertEquals(2, stats.findIndex(TEST_IFACE, 102, TAG_NONE));
assertEquals(2, stats.findIndex(TEST_IFACE, 102, TAG_NONE)); assertEquals(2, stats.findIndex(TEST_IFACE, 102, TAG_NONE));
@@ -45,109 +45,105 @@ public class NetworkStatsTest extends TestCase {
final NetworkStats stats = new NetworkStats(TEST_START, 2); final NetworkStats stats = new NetworkStats(TEST_START, 2);
assertEquals(0, stats.size()); assertEquals(0, stats.size());
assertEquals(2, stats.iface.length); assertEquals(2, stats.internalSize());
stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 1L, 2L); stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 1L, 1L, 2L, 2L);
stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 2L, 2L); stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 2L, 2L, 2L, 2L);
assertEquals(2, stats.size()); assertEquals(2, stats.size());
assertEquals(2, stats.iface.length); assertEquals(2, stats.internalSize());
stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 3L, 4L); stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 3L, 30L, 4L, 40L);
stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 4L, 4L); stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 4L, 40L, 4L, 40L);
stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 5L, 5L); stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 5L, 50L, 5L, 50L);
assertEquals(5, stats.size()); assertEquals(5, stats.size());
assertTrue(stats.iface.length >= 5); assertTrue(stats.internalSize() >= 5);
assertEquals(1L, stats.rx[0]); assertEntry(stats, 0, TEST_IFACE, TEST_UID, TAG_NONE, 1L, 1L, 2L, 2L);
assertEquals(2L, stats.rx[1]); assertEntry(stats, 1, TEST_IFACE, TEST_UID, TAG_NONE, 2L, 2L, 2L, 2L);
assertEquals(3L, stats.rx[2]); assertEntry(stats, 2, TEST_IFACE, TEST_UID, TAG_NONE, 3L, 30L, 4L, 40L);
assertEquals(4L, stats.rx[3]); assertEntry(stats, 3, TEST_IFACE, TEST_UID, TAG_NONE, 4L, 40L, 4L, 40L);
assertEquals(5L, stats.rx[4]); assertEntry(stats, 4, TEST_IFACE, TEST_UID, TAG_NONE, 5L, 50L, 5L, 50L);
} }
public void testCombineExisting() throws Exception { public void testCombineExisting() throws Exception {
final NetworkStats stats = new NetworkStats(TEST_START, 10); final NetworkStats stats = new NetworkStats(TEST_START, 10);
stats.addEntry(TEST_IFACE, 1001, TAG_NONE, 512L, 256L); stats.addValues(TEST_IFACE, 1001, TAG_NONE, 512L, 4L, 256L, 2L);
stats.addEntry(TEST_IFACE, 1001, 0xff, 128L, 128L); stats.addValues(TEST_IFACE, 1001, 0xff, 128L, 1L, 128L, 1L);
stats.combineEntry(TEST_IFACE, 1001, TAG_NONE, -128L, -128L); stats.combineValues(TEST_IFACE, 1001, TAG_NONE, -128L, -1L, -128L, -1L);
assertStatsEntry(stats, 0, TEST_IFACE, 1001, TAG_NONE, 384L, 128L); assertEntry(stats, 0, TEST_IFACE, 1001, TAG_NONE, 384L, 3L, 128L, 1L);
assertStatsEntry(stats, 1, TEST_IFACE, 1001, 0xff, 128L, 128L); assertEntry(stats, 1, TEST_IFACE, 1001, 0xff, 128L, 1L, 128L, 1L);
// now try combining that should create row // now try combining that should create row
stats.combineEntry(TEST_IFACE, 5005, TAG_NONE, 128L, 128L); stats.combineValues(TEST_IFACE, 5005, TAG_NONE, 128L, 1L, 128L, 1L);
assertStatsEntry(stats, 2, TEST_IFACE, 5005, TAG_NONE, 128L, 128L); assertEntry(stats, 2, TEST_IFACE, 5005, TAG_NONE, 128L, 1L, 128L, 1L);
stats.combineEntry(TEST_IFACE, 5005, TAG_NONE, 128L, 128L); stats.combineValues(TEST_IFACE, 5005, TAG_NONE, 128L, 1L, 128L, 1L);
assertStatsEntry(stats, 2, TEST_IFACE, 5005, TAG_NONE, 256L, 256L); assertEntry(stats, 2, TEST_IFACE, 5005, TAG_NONE, 256L, 2L, 256L, 2L);
} }
public void testSubtractIdenticalData() throws Exception { public void testSubtractIdenticalData() throws Exception {
final NetworkStats before = new NetworkStats(TEST_START, 2) final NetworkStats before = new NetworkStats(TEST_START, 2)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L) .addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L); .addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L);
final NetworkStats after = new NetworkStats(TEST_START, 2) final NetworkStats after = new NetworkStats(TEST_START, 2)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L) .addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L); .addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L);
final NetworkStats result = after.subtract(before); final NetworkStats result = after.subtract(before);
// identical data should result in zero delta // identical data should result in zero delta
assertEquals(0, result.rx[0]); assertEntry(result, 0, TEST_IFACE, 100, TAG_NONE, 0L, 0L, 0L, 0L);
assertEquals(0, result.tx[0]); assertEntry(result, 1, TEST_IFACE, 101, TAG_NONE, 0L, 0L, 0L, 0L);
assertEquals(0, result.rx[1]);
assertEquals(0, result.tx[1]);
} }
public void testSubtractIdenticalRows() throws Exception { public void testSubtractIdenticalRows() throws Exception {
final NetworkStats before = new NetworkStats(TEST_START, 2) final NetworkStats before = new NetworkStats(TEST_START, 2)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L) .addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L); .addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L);
final NetworkStats after = new NetworkStats(TEST_START, 2) final NetworkStats after = new NetworkStats(TEST_START, 2)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1025L, 2L) .addValues(TEST_IFACE, 100, TAG_NONE, 1025L, 9L, 2L, 1L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 3L, 1028L); .addValues(TEST_IFACE, 101, TAG_NONE, 3L, 1L, 1028L, 9L);
final NetworkStats result = after.subtract(before); final NetworkStats result = after.subtract(before);
// expect delta between measurements // expect delta between measurements
assertEquals(1, result.rx[0]); assertEntry(result, 0, TEST_IFACE, 100, TAG_NONE, 1L, 1L, 2L, 1L);
assertEquals(2, result.tx[0]); assertEntry(result, 1, TEST_IFACE, 101, TAG_NONE, 3L, 1L, 4L, 1L);
assertEquals(3, result.rx[1]);
assertEquals(4, result.tx[1]);
} }
public void testSubtractNewRows() throws Exception { public void testSubtractNewRows() throws Exception {
final NetworkStats before = new NetworkStats(TEST_START, 2) final NetworkStats before = new NetworkStats(TEST_START, 2)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L) .addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L); .addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L);
final NetworkStats after = new NetworkStats(TEST_START, 3) final NetworkStats after = new NetworkStats(TEST_START, 3)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L) .addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L) .addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L)
.addEntry(TEST_IFACE, 102, TAG_NONE, 1024L, 1024L); .addValues(TEST_IFACE, 102, TAG_NONE, 1024L, 8L, 1024L, 8L);
final NetworkStats result = after.subtract(before); final NetworkStats result = after.subtract(before);
// its okay to have new rows // its okay to have new rows
assertEquals(0, result.rx[0]); assertEntry(result, 0, TEST_IFACE, 100, TAG_NONE, 0L, 0L, 0L, 0L);
assertEquals(0, result.tx[0]); assertEntry(result, 1, TEST_IFACE, 101, TAG_NONE, 0L, 0L, 0L, 0L);
assertEquals(0, result.rx[1]); assertEntry(result, 2, TEST_IFACE, 102, TAG_NONE, 1024L, 8L, 1024L, 8L);
assertEquals(0, result.tx[1]);
assertEquals(1024, result.rx[2]);
assertEquals(1024, result.tx[2]);
} }
private static void assertStatsEntry( private static void assertEntry(NetworkStats stats, int index, String iface, int uid, int tag,
NetworkStats stats, int i, String iface, int uid, int tag, long rx, long tx) { long rxBytes, long rxPackets, long txBytes, long txPackets) {
assertEquals(iface, stats.iface[i]); final NetworkStats.Entry entry = stats.getValues(index, null);
assertEquals(uid, stats.uid[i]); assertEquals(iface, entry.iface);
assertEquals(tag, stats.tag[i]); assertEquals(uid, entry.uid);
assertEquals(rx, stats.rx[i]); assertEquals(tag, entry.tag);
assertEquals(tx, stats.tx[i]); assertEquals(rxBytes, entry.rxBytes);
assertEquals(rxPackets, entry.rxPackets);
assertEquals(txBytes, entry.txBytes);
assertEquals(txPackets, entry.txPackets);
} }
} }

84
services/tests/servicestests/src/com/android/server/NetworkStatsServiceTest.java
View File

@@ -168,7 +168,7 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectTime(TEST_START + elapsedRealtime); expectTime(TEST_START + elapsedRealtime);
expectDefaultSettings(); expectDefaultSettings();
expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1) expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 1024L, 2048L)); .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 1024L, 1L, 2048L, 2L));
expectNetworkStatsDetail(buildEmptyStats(elapsedRealtime)); expectNetworkStatsDetail(buildEmptyStats(elapsedRealtime));
replay(); replay();
@@ -184,7 +184,7 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectTime(TEST_START + elapsedRealtime); expectTime(TEST_START + elapsedRealtime);
expectDefaultSettings(); expectDefaultSettings();
expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1) expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 4096L, 8192L)); .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 4096L, 4L, 8192L, 8L));
expectNetworkStatsDetail(buildEmptyStats(elapsedRealtime)); expectNetworkStatsDetail(buildEmptyStats(elapsedRealtime));
replay(); replay();
@@ -219,10 +219,10 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectTime(TEST_START + elapsedRealtime); expectTime(TEST_START + elapsedRealtime);
expectDefaultSettings(); expectDefaultSettings();
expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1) expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 1024L, 2048L)); .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 1024L, 8L, 2048L, 16L));
expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 2) expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 2)
.addEntry(TEST_IFACE, UID_RED, TAG_NONE, 512L, 256L) .addValues(TEST_IFACE, UID_RED, TAG_NONE, 512L, 4L, 256L, 2L)
.addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 128L, 128L)); .addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 128L, 1L, 128L, 1L));
replay(); replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL)); mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -284,7 +284,7 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectTime(TEST_START + elapsedRealtime); expectTime(TEST_START + elapsedRealtime);
expectSettings(0L, HOUR_IN_MILLIS, WEEK_IN_MILLIS); expectSettings(0L, HOUR_IN_MILLIS, WEEK_IN_MILLIS);
expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1) expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 512L, 512L)); .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 512L, 4L, 512L, 4L));
expectNetworkStatsDetail(buildEmptyStats(elapsedRealtime)); expectNetworkStatsDetail(buildEmptyStats(elapsedRealtime));
replay(); replay();
@@ -295,8 +295,8 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
total = history.getTotalData(Long.MIN_VALUE, Long.MAX_VALUE, null); total = history.getTotalData(Long.MIN_VALUE, Long.MAX_VALUE, null);
assertEquals(512L, total[0]); assertEquals(512L, total[0]);
assertEquals(512L, total[1]); assertEquals(512L, total[1]);
assertEquals(HOUR_IN_MILLIS, history.bucketDuration); assertEquals(HOUR_IN_MILLIS, history.getBucketDuration());
assertEquals(2, history.bucketCount); assertEquals(2, history.size());
verifyAndReset(); verifyAndReset();
// now change bucket duration setting and trigger another poll with // now change bucket duration setting and trigger another poll with
@@ -314,8 +314,8 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
total = history.getTotalData(Long.MIN_VALUE, Long.MAX_VALUE, null); total = history.getTotalData(Long.MIN_VALUE, Long.MAX_VALUE, null);
assertEquals(512L, total[0]); assertEquals(512L, total[0]);
assertEquals(512L, total[1]); assertEquals(512L, total[1]);
assertEquals(30 * MINUTE_IN_MILLIS, history.bucketDuration); assertEquals(30 * MINUTE_IN_MILLIS, history.getBucketDuration());
assertEquals(4, history.bucketCount); assertEquals(4, history.size());
verifyAndReset(); verifyAndReset();
} }
@@ -338,11 +338,11 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectTime(TEST_START + elapsedRealtime); expectTime(TEST_START + elapsedRealtime);
expectDefaultSettings(); expectDefaultSettings();
expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1) expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 2048L, 512L)); .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 2048L, 16L, 512L, 4L));
expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 3) expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 3)
.addEntry(TEST_IFACE, UID_RED, TAG_NONE, 1536L, 512L) .addValues(TEST_IFACE, UID_RED, TAG_NONE, 1536L, 12L, 512L, 4L)
.addEntry(TEST_IFACE, UID_RED, 0xF00D, 512L, 512L) .addValues(TEST_IFACE, UID_RED, 0xF00D, 512L, 4L, 512L, 4L)
.addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 512L, 0L)); .addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 512L, 4L, 0L, 0L));
replay(); replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL)); mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -373,9 +373,9 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectTime(TEST_START + elapsedRealtime); expectTime(TEST_START + elapsedRealtime);
expectDefaultSettings(); expectDefaultSettings();
expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1) expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 128L, 1024L)); .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 128L, 1L, 1024L, 8L));
expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1) expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 128L, 1024L)); .addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 128L, 1L, 1024L, 8L));
replay(); replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL)); mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -412,11 +412,11 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectTime(TEST_START + elapsedRealtime); expectTime(TEST_START + elapsedRealtime);
expectDefaultSettings(); expectDefaultSettings();
expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1) expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 4128L, 544L)); .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 4128L, 258L, 544L, 34L));
expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1) expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_RED, TAG_NONE, 16L, 16L) .addValues(TEST_IFACE, UID_RED, TAG_NONE, 16L, 1L, 16L, 1L)
.addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 4096L, 512L) .addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 4096L, 258L, 512L, 32L)
.addEntry(TEST_IFACE, UID_GREEN, TAG_NONE, 16L, 16L)); .addValues(TEST_IFACE, UID_GREEN, TAG_NONE, 16L, 1L, 16L, 1L));
replay(); replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL)); mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -468,8 +468,8 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectDefaultSettings(); expectDefaultSettings();
expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime)); expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime));
expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1) expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_RED, TAG_NONE, 1024L, 1024L) .addValues(TEST_IFACE, UID_RED, TAG_NONE, 1024L, 8L, 1024L, 8L)
.addEntry(TEST_IFACE, UID_RED, 0xF00D, 512L, 512L)); .addValues(TEST_IFACE, UID_RED, 0xF00D, 512L, 4L, 512L, 4L));
replay(); replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL)); mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -497,7 +497,7 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectDefaultSettings(); expectDefaultSettings();
expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime)); expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime));
expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1) expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_RED, TAG_NONE, 512L, 256L)); .addValues(TEST_IFACE, UID_RED, TAG_NONE, 512L, 4L, 256L, 2L));
replay(); replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL)); mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -548,9 +548,9 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectDefaultSettings(); expectDefaultSettings();
expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime)); expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime));
expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1) expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_RED, TAG_NONE, 50L, 50L) .addValues(TEST_IFACE, UID_RED, TAG_NONE, 50L, 5L, 50L, 5L)
.addEntry(TEST_IFACE, UID_RED, 0xF00D, 10L, 10L) .addValues(TEST_IFACE, UID_RED, 0xF00D, 10L, 1L, 10L, 1L)
.addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 1024L, 512L)); .addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 1024L, 8L, 512L, 4L));
replay(); replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL)); mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -566,7 +566,7 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectDefaultSettings(); expectDefaultSettings();
expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime)); expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime));
expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1) expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 2048L, 1024L)); .addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 2048L, 16L, 1024L, 8L));
replay(); replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL)); mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -574,17 +574,17 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
// first verify entire history present // first verify entire history present
NetworkStats stats = mService.getSummaryForAllUid( NetworkStats stats = mService.getSummaryForAllUid(
sTemplateWifi, Long.MIN_VALUE, Long.MAX_VALUE, true); sTemplateWifi, Long.MIN_VALUE, Long.MAX_VALUE, true);
assertEquals(3, stats.size); assertEquals(3, stats.size());
assertStatsEntry(stats, 0, IFACE_ALL, UID_RED, TAG_NONE, 50L, 50L); assertEntry(stats, 0, IFACE_ALL, UID_RED, TAG_NONE, 50L, 5L, 50L, 5L);
assertStatsEntry(stats, 1, IFACE_ALL, UID_RED, 0xF00D, 10L, 10L); assertEntry(stats, 1, IFACE_ALL, UID_RED, 0xF00D, 10L, 1L, 10L, 1L);
assertStatsEntry(stats, 2, IFACE_ALL, UID_BLUE, TAG_NONE, 2048L, 1024L); assertEntry(stats, 2, IFACE_ALL, UID_BLUE, TAG_NONE, 2048L, 16L, 1024L, 8L);
// now verify that recent history only contains one uid // now verify that recent history only contains one uid
final long currentTime = TEST_START + elapsedRealtime; final long currentTime = TEST_START + elapsedRealtime;
stats = mService.getSummaryForAllUid( stats = mService.getSummaryForAllUid(
sTemplateWifi, currentTime - HOUR_IN_MILLIS, currentTime, true); sTemplateWifi, currentTime - HOUR_IN_MILLIS, currentTime, true);
assertEquals(1, stats.size); assertEquals(1, stats.size());
assertStatsEntry(stats, 0, IFACE_ALL, UID_BLUE, TAG_NONE, 1024L, 512L); assertEntry(stats, 0, IFACE_ALL, UID_BLUE, TAG_NONE, 1024L, 8L, 512L, 4L);
verifyAndReset(); verifyAndReset();
} }
@@ -660,13 +660,17 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
} }
} }
private static void assertStatsEntry( private static void assertEntry(NetworkStats stats, int i, String iface, int uid, int tag,
NetworkStats stats, int i, String iface, int uid, int tag, long rx, long tx) { long rxBytes, long rxPackets, long txBytes, long txPackets) {
assertEquals(iface, stats.iface[i]); final NetworkStats.Entry entry = stats.getValues(i, null);
assertEquals(uid, stats.uid[i]); assertEquals(iface, entry.iface);
assertEquals(tag, stats.tag[i]); assertEquals(uid, entry.uid);
assertEquals(rx, stats.rx[i]); assertEquals(tag, entry.tag);
assertEquals(tx, stats.tx[i]); assertEquals(rxBytes, entry.rxBytes);
// TODO: enable testing packet counts once stored in history
// assertEquals(rxPackets, entry.rxPackets);
assertEquals(txBytes, entry.txBytes);
// assertEquals(txPackets, entry.txPackets);
} }
private static NetworkState buildWifiState() { private static NetworkState buildWifiState() {