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
stats.recordData(TEST_START, TEST_START + SECOND_IN_MILLIS, 1024L, 2048L);
assertEquals(1, stats.bucketCount);
assertBucket(stats, 0, 1024L, 2048L);
assertEquals(1, stats.size());
assertEntry(stats, 0, 1024L, 2048L);
}
public void testRecordEqualBuckets() throws Exception {
@@ -66,9 +66,9 @@ public class NetworkStatsHistoryTest extends TestCase {
final long recordStart = TEST_START + (bucketDuration / 2);
stats.recordData(recordStart, recordStart + bucketDuration, 1024L, 128L);
assertEquals(2, stats.bucketCount);
assertBucket(stats, 0, 512L, 64L);
assertBucket(stats, 1, 512L, 64L);
assertEquals(2, stats.size());
assertEntry(stats, 0, 512L, 64L);
assertEntry(stats, 1, 512L, 64L);
}
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);
stats.recordData(recordStart, recordEnd, 1000L, 5000L);
assertEquals(3, stats.bucketCount);
assertEquals(3, stats.size());
// 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)
assertBucket(stats, 1, 750L, 3750L);
assertEntry(stats, 1, 750L, 3750L);
// final bucket should have (4/20 of value)
assertBucket(stats, 2, 200L, 1000L);
assertEntry(stats, 2, 200L, 1000L);
}
public void testRecordGapBuckets() throws Exception {
@@ -101,9 +101,9 @@ public class NetworkStatsHistoryTest extends TestCase {
stats.recordData(lastStart, lastStart + SECOND_IN_MILLIS, 64L, 512L);
// we should have two buckets, far apart from each other
assertEquals(2, stats.bucketCount);
assertBucket(stats, 0, 128L, 256L);
assertBucket(stats, 1, 64L, 512L);
assertEquals(2, stats.size());
assertEntry(stats, 0, 128L, 256L);
assertEntry(stats, 1, 64L, 512L);
// now record something in middle, spread across two buckets
final long middleStart = TEST_START + DAY_IN_MILLIS;
@@ -111,11 +111,11 @@ public class NetworkStatsHistoryTest extends TestCase {
stats.recordData(middleStart, middleEnd, 2048L, 2048L);
// now should have four buckets, with new record in middle two buckets
assertEquals(4, stats.bucketCount);
assertBucket(stats, 0, 128L, 256L);
assertBucket(stats, 1, 1024L, 1024L);
assertBucket(stats, 2, 1024L, 1024L);
assertBucket(stats, 3, 64L, 512L);
assertEquals(4, stats.size());
assertEntry(stats, 0, 128L, 256L);
assertEntry(stats, 1, 1024L, 1024L);
assertEntry(stats, 2, 1024L, 1024L);
assertEntry(stats, 3, 64L, 512L);
}
public void testRecordOverlapBuckets() throws Exception {
@@ -128,9 +128,9 @@ public class NetworkStatsHistoryTest extends TestCase {
stats.recordData(midStart, midStart + HOUR_IN_MILLIS, 1024L, 1024L);
// should have two buckets, with some data mixed together
assertEquals(2, stats.bucketCount);
assertBucket(stats, 0, 768L, 768L);
assertBucket(stats, 1, 512L, 512L);
assertEquals(2, stats.size());
assertEntry(stats, 0, 768L, 768L);
assertEntry(stats, 1, 512L, 512L);
}
public void testRecordEntireGapIdentical() throws Exception {
@@ -154,10 +154,10 @@ public class NetworkStatsHistoryTest extends TestCase {
assertTotalEquals(total, 3000L, 1500L);
// now inspect internal buckets
assertBucket(stats, 0, 1000L, 500L);
assertBucket(stats, 1, 1000L, 500L);
assertBucket(stats, 2, 500L, 250L);
assertBucket(stats, 3, 500L, 250L);
assertEntry(stats, 0, 1000L, 500L);
assertEntry(stats, 1, 1000L, 500L);
assertEntry(stats, 2, 500L, 250L);
assertEntry(stats, 3, 500L, 250L);
}
public void testRecordEntireOverlapVaryingBuckets() throws Exception {
@@ -181,13 +181,13 @@ public class NetworkStatsHistoryTest extends TestCase {
assertTotalEquals(total, 650L, 650L);
// now inspect internal buckets
assertBucket(stats, 0, 10L, 10L);
assertBucket(stats, 1, 20L, 20L);
assertBucket(stats, 2, 20L, 20L);
assertBucket(stats, 3, 20L, 20L);
assertBucket(stats, 4, 20L, 20L);
assertBucket(stats, 5, 20L, 20L);
assertBucket(stats, 6, 10L, 10L);
assertEntry(stats, 0, 10L, 10L);
assertEntry(stats, 1, 20L, 20L);
assertEntry(stats, 2, 20L, 20L);
assertEntry(stats, 3, 20L, 20L);
assertEntry(stats, 4, 20L, 20L);
assertEntry(stats, 5, 20L, 20L);
assertEntry(stats, 6, 10L, 10L);
// now combine using 15min buckets
stats = new NetworkStatsHistory(HOUR_IN_MILLIS / 4);
@@ -199,10 +199,10 @@ public class NetworkStatsHistoryTest extends TestCase {
assertTotalEquals(total, 650L, 650L);
// and inspect buckets
assertBucket(stats, 0, 200L, 200L);
assertBucket(stats, 1, 150L, 150L);
assertBucket(stats, 2, 150L, 150L);
assertBucket(stats, 3, 150L, 150L);
assertEntry(stats, 0, 200L, 200L);
assertEntry(stats, 1, 150L, 150L);
assertEntry(stats, 2, 150L, 150L);
assertEntry(stats, 3, 150L, 150L);
}
public void testRemove() throws Exception {
@@ -210,28 +210,28 @@ public class NetworkStatsHistoryTest extends TestCase {
// record some data across 24 buckets
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
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
// since that bucket contains data beyond the cutoff
stats.removeBucketsBefore(TEST_START + SECOND_IN_MILLIS);
assertEquals(24, stats.bucketCount);
assertEquals(24, stats.size());
// try removing single bucket
stats.removeBucketsBefore(TEST_START + HOUR_IN_MILLIS);
assertEquals(23, stats.bucketCount);
assertEquals(23, stats.size());
// try removing multiple buckets
stats.removeBucketsBefore(TEST_START + (4 * HOUR_IN_MILLIS));
assertEquals(20, stats.bucketCount);
assertEquals(20, stats.size());
// try removing all buckets
stats.removeBucketsBefore(TEST_START + YEAR_IN_MILLIS);
assertEquals(0, stats.bucketCount);
assertEquals(0, stats.size());
}
public void testTotalData() throws Exception {
@@ -293,19 +293,25 @@ public class NetworkStatsHistoryTest extends TestCase {
private static void assertConsistent(NetworkStatsHistory stats) {
// verify timestamps are monotonic
for (int i = 1; i < stats.bucketCount; i++) {
assertTrue(stats.bucketStart[i - 1] < stats.bucketStart[i]);
long lastStart = Long.MIN_VALUE;
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) {
assertEquals("unexpected rx", rx, total[0]);
assertEquals("unexpected tx", tx, total[1]);
private static void assertTotalEquals(long[] total, long rxBytes, long txBytes) {
assertEquals("unexpected rxBytes", rxBytes, total[0]);
assertEquals("unexpected txBytes", txBytes, total[1]);
}
private static void assertBucket(NetworkStatsHistory stats, int index, long rx, long tx) {
assertEquals("unexpected rx", rx, stats.rx[index]);
assertEquals("unexpected tx", tx, stats.tx[index]);
private static void assertEntry(
NetworkStatsHistory stats, int index, long rxBytes, long txBytes) {
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 {
final NetworkStats stats = new NetworkStats(TEST_START, 3)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L)
.addEntry(TEST_IFACE, 102, TAG_NONE, 1024L, 1024L);
.addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
.addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L)
.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));
@@ -45,109 +45,105 @@ public class NetworkStatsTest extends TestCase {
final NetworkStats stats = new NetworkStats(TEST_START, 2);
assertEquals(0, stats.size());
assertEquals(2, stats.iface.length);
assertEquals(2, stats.internalSize());
stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 1L, 2L);
stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 2L, 2L);
stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 1L, 1L, 2L, 2L);
stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 2L, 2L, 2L, 2L);
assertEquals(2, stats.size());
assertEquals(2, stats.iface.length);
assertEquals(2, stats.internalSize());
stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 3L, 4L);
stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 4L, 4L);
stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 5L, 5L);
stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 3L, 30L, 4L, 40L);
stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 4L, 40L, 4L, 40L);
stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 5L, 50L, 5L, 50L);
assertEquals(5, stats.size());
assertTrue(stats.iface.length >= 5);
assertTrue(stats.internalSize() >= 5);
assertEquals(1L, stats.rx[0]);
assertEquals(2L, stats.rx[1]);
assertEquals(3L, stats.rx[2]);
assertEquals(4L, stats.rx[3]);
assertEquals(5L, stats.rx[4]);
assertEntry(stats, 0, TEST_IFACE, TEST_UID, TAG_NONE, 1L, 1L, 2L, 2L);
assertEntry(stats, 1, TEST_IFACE, TEST_UID, TAG_NONE, 2L, 2L, 2L, 2L);
assertEntry(stats, 2, TEST_IFACE, TEST_UID, TAG_NONE, 3L, 30L, 4L, 40L);
assertEntry(stats, 3, TEST_IFACE, TEST_UID, TAG_NONE, 4L, 40L, 4L, 40L);
assertEntry(stats, 4, TEST_IFACE, TEST_UID, TAG_NONE, 5L, 50L, 5L, 50L);
}
public void testCombineExisting() throws Exception {
final NetworkStats stats = new NetworkStats(TEST_START, 10);
stats.addEntry(TEST_IFACE, 1001, TAG_NONE, 512L, 256L);
stats.addEntry(TEST_IFACE, 1001, 0xff, 128L, 128L);
stats.combineEntry(TEST_IFACE, 1001, TAG_NONE, -128L, -128L);
stats.addValues(TEST_IFACE, 1001, TAG_NONE, 512L, 4L, 256L, 2L);
stats.addValues(TEST_IFACE, 1001, 0xff, 128L, 1L, 128L, 1L);
stats.combineValues(TEST_IFACE, 1001, TAG_NONE, -128L, -1L, -128L, -1L);
assertStatsEntry(stats, 0, TEST_IFACE, 1001, TAG_NONE, 384L, 128L);
assertStatsEntry(stats, 1, TEST_IFACE, 1001, 0xff, 128L, 128L);
assertEntry(stats, 0, TEST_IFACE, 1001, TAG_NONE, 384L, 3L, 128L, 1L);
assertEntry(stats, 1, TEST_IFACE, 1001, 0xff, 128L, 1L, 128L, 1L);
// now try combining that should create row
stats.combineEntry(TEST_IFACE, 5005, TAG_NONE, 128L, 128L);
assertStatsEntry(stats, 2, TEST_IFACE, 5005, TAG_NONE, 128L, 128L);
stats.combineEntry(TEST_IFACE, 5005, TAG_NONE, 128L, 128L);
assertStatsEntry(stats, 2, TEST_IFACE, 5005, TAG_NONE, 256L, 256L);
stats.combineValues(TEST_IFACE, 5005, TAG_NONE, 128L, 1L, 128L, 1L);
assertEntry(stats, 2, TEST_IFACE, 5005, TAG_NONE, 128L, 1L, 128L, 1L);
stats.combineValues(TEST_IFACE, 5005, TAG_NONE, 128L, 1L, 128L, 1L);
assertEntry(stats, 2, TEST_IFACE, 5005, TAG_NONE, 256L, 2L, 256L, 2L);
}
public void testSubtractIdenticalData() throws Exception {
final NetworkStats before = new NetworkStats(TEST_START, 2)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L);
.addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
.addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L);
final NetworkStats after = new NetworkStats(TEST_START, 2)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L);
.addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
.addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L);
final NetworkStats result = after.subtract(before);
// identical data should result in zero delta
assertEquals(0, result.rx[0]);
assertEquals(0, result.tx[0]);
assertEquals(0, result.rx[1]);
assertEquals(0, result.tx[1]);
assertEntry(result, 0, TEST_IFACE, 100, TAG_NONE, 0L, 0L, 0L, 0L);
assertEntry(result, 1, TEST_IFACE, 101, TAG_NONE, 0L, 0L, 0L, 0L);
}
public void testSubtractIdenticalRows() throws Exception {
final NetworkStats before = new NetworkStats(TEST_START, 2)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L);
.addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
.addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L);
final NetworkStats after = new NetworkStats(TEST_START, 2)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1025L, 2L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 3L, 1028L);
.addValues(TEST_IFACE, 100, TAG_NONE, 1025L, 9L, 2L, 1L)
.addValues(TEST_IFACE, 101, TAG_NONE, 3L, 1L, 1028L, 9L);
final NetworkStats result = after.subtract(before);
// expect delta between measurements
assertEquals(1, result.rx[0]);
assertEquals(2, result.tx[0]);
assertEquals(3, result.rx[1]);
assertEquals(4, result.tx[1]);
assertEntry(result, 0, TEST_IFACE, 100, TAG_NONE, 1L, 1L, 2L, 1L);
assertEntry(result, 1, TEST_IFACE, 101, TAG_NONE, 3L, 1L, 4L, 1L);
}
public void testSubtractNewRows() throws Exception {
final NetworkStats before = new NetworkStats(TEST_START, 2)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L);
.addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
.addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L);
final NetworkStats after = new NetworkStats(TEST_START, 3)
.addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L)
.addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L)
.addEntry(TEST_IFACE, 102, TAG_NONE, 1024L, 1024L);
.addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
.addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L)
.addValues(TEST_IFACE, 102, TAG_NONE, 1024L, 8L, 1024L, 8L);
final NetworkStats result = after.subtract(before);
// its okay to have new rows
assertEquals(0, result.rx[0]);
assertEquals(0, result.tx[0]);
assertEquals(0, result.rx[1]);
assertEquals(0, result.tx[1]);
assertEquals(1024, result.rx[2]);
assertEquals(1024, result.tx[2]);
assertEntry(result, 0, TEST_IFACE, 100, TAG_NONE, 0L, 0L, 0L, 0L);
assertEntry(result, 1, TEST_IFACE, 101, TAG_NONE, 0L, 0L, 0L, 0L);
assertEntry(result, 2, TEST_IFACE, 102, TAG_NONE, 1024L, 8L, 1024L, 8L);
}
private static void assertStatsEntry(
NetworkStats stats, int i, String iface, int uid, int tag, long rx, long tx) {
assertEquals(iface, stats.iface[i]);
assertEquals(uid, stats.uid[i]);
assertEquals(tag, stats.tag[i]);
assertEquals(rx, stats.rx[i]);
assertEquals(tx, stats.tx[i]);
private static void assertEntry(NetworkStats stats, int index, String iface, int uid, int tag,
long rxBytes, long rxPackets, long txBytes, long txPackets) {
final NetworkStats.Entry entry = stats.getValues(index, null);
assertEquals(iface, entry.iface);
assertEquals(uid, entry.uid);
assertEquals(tag, entry.tag);
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);
expectDefaultSettings();
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));
replay();
@@ -184,7 +184,7 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectTime(TEST_START + elapsedRealtime);
expectDefaultSettings();
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));
replay();
@@ -219,10 +219,10 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectTime(TEST_START + elapsedRealtime);
expectDefaultSettings();
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)
.addEntry(TEST_IFACE, UID_RED, TAG_NONE, 512L, 256L)
.addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 128L, 128L));
.addValues(TEST_IFACE, UID_RED, TAG_NONE, 512L, 4L, 256L, 2L)
.addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 128L, 1L, 128L, 1L));
replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -284,7 +284,7 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectTime(TEST_START + elapsedRealtime);
expectSettings(0L, HOUR_IN_MILLIS, WEEK_IN_MILLIS);
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));
replay();
@@ -295,8 +295,8 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
total = history.getTotalData(Long.MIN_VALUE, Long.MAX_VALUE, null);
assertEquals(512L, total[0]);
assertEquals(512L, total[1]);
assertEquals(HOUR_IN_MILLIS, history.bucketDuration);
assertEquals(2, history.bucketCount);
assertEquals(HOUR_IN_MILLIS, history.getBucketDuration());
assertEquals(2, history.size());
verifyAndReset();
// 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);
assertEquals(512L, total[0]);
assertEquals(512L, total[1]);
assertEquals(30 * MINUTE_IN_MILLIS, history.bucketDuration);
assertEquals(4, history.bucketCount);
assertEquals(30 * MINUTE_IN_MILLIS, history.getBucketDuration());
assertEquals(4, history.size());
verifyAndReset();
}
@@ -338,11 +338,11 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectTime(TEST_START + elapsedRealtime);
expectDefaultSettings();
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)
.addEntry(TEST_IFACE, UID_RED, TAG_NONE, 1536L, 512L)
.addEntry(TEST_IFACE, UID_RED, 0xF00D, 512L, 512L)
.addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 512L, 0L));
.addValues(TEST_IFACE, UID_RED, TAG_NONE, 1536L, 12L, 512L, 4L)
.addValues(TEST_IFACE, UID_RED, 0xF00D, 512L, 4L, 512L, 4L)
.addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 512L, 4L, 0L, 0L));
replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -373,9 +373,9 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectTime(TEST_START + elapsedRealtime);
expectDefaultSettings();
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)
.addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 128L, 1024L));
.addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 128L, 1L, 1024L, 8L));
replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -412,11 +412,11 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectTime(TEST_START + elapsedRealtime);
expectDefaultSettings();
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)
.addEntry(TEST_IFACE, UID_RED, TAG_NONE, 16L, 16L)
.addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 4096L, 512L)
.addEntry(TEST_IFACE, UID_GREEN, TAG_NONE, 16L, 16L));
.addValues(TEST_IFACE, UID_RED, TAG_NONE, 16L, 1L, 16L, 1L)
.addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 4096L, 258L, 512L, 32L)
.addValues(TEST_IFACE, UID_GREEN, TAG_NONE, 16L, 1L, 16L, 1L));
replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -468,8 +468,8 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectDefaultSettings();
expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime));
expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_RED, TAG_NONE, 1024L, 1024L)
.addEntry(TEST_IFACE, UID_RED, 0xF00D, 512L, 512L));
.addValues(TEST_IFACE, UID_RED, TAG_NONE, 1024L, 8L, 1024L, 8L)
.addValues(TEST_IFACE, UID_RED, 0xF00D, 512L, 4L, 512L, 4L));
replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -497,7 +497,7 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectDefaultSettings();
expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime));
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();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -548,9 +548,9 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectDefaultSettings();
expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime));
expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
.addEntry(TEST_IFACE, UID_RED, TAG_NONE, 50L, 50L)
.addEntry(TEST_IFACE, UID_RED, 0xF00D, 10L, 10L)
.addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 1024L, 512L));
.addValues(TEST_IFACE, UID_RED, TAG_NONE, 50L, 5L, 50L, 5L)
.addValues(TEST_IFACE, UID_RED, 0xF00D, 10L, 1L, 10L, 1L)
.addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 1024L, 8L, 512L, 4L));
replay();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -566,7 +566,7 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
expectDefaultSettings();
expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime));
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();
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -574,17 +574,17 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
// first verify entire history present
NetworkStats stats = mService.getSummaryForAllUid(
sTemplateWifi, Long.MIN_VALUE, Long.MAX_VALUE, true);
assertEquals(3, stats.size);
assertStatsEntry(stats, 0, IFACE_ALL, UID_RED, TAG_NONE, 50L, 50L);
assertStatsEntry(stats, 1, IFACE_ALL, UID_RED, 0xF00D, 10L, 10L);
assertStatsEntry(stats, 2, IFACE_ALL, UID_BLUE, TAG_NONE, 2048L, 1024L);
assertEquals(3, stats.size());
assertEntry(stats, 0, IFACE_ALL, UID_RED, TAG_NONE, 50L, 5L, 50L, 5L);
assertEntry(stats, 1, IFACE_ALL, UID_RED, 0xF00D, 10L, 1L, 10L, 1L);
assertEntry(stats, 2, IFACE_ALL, UID_BLUE, TAG_NONE, 2048L, 16L, 1024L, 8L);
// now verify that recent history only contains one uid
final long currentTime = TEST_START + elapsedRealtime;
stats = mService.getSummaryForAllUid(
sTemplateWifi, currentTime - HOUR_IN_MILLIS, currentTime, true);
assertEquals(1, stats.size);
assertStatsEntry(stats, 0, IFACE_ALL, UID_BLUE, TAG_NONE, 1024L, 512L);
assertEquals(1, stats.size());
assertEntry(stats, 0, IFACE_ALL, UID_BLUE, TAG_NONE, 1024L, 8L, 512L, 4L);
verifyAndReset();
}
@@ -660,13 +660,17 @@ public class NetworkStatsServiceTest extends AndroidTestCase {
}
}
private static void assertStatsEntry(
NetworkStats stats, int i, String iface, int uid, int tag, long rx, long tx) {
assertEquals(iface, stats.iface[i]);
assertEquals(uid, stats.uid[i]);
assertEquals(tag, stats.tag[i]);
assertEquals(rx, stats.rx[i]);
assertEquals(tx, stats.tx[i]);
private static void assertEntry(NetworkStats stats, int i, String iface, int uid, int tag,
long rxBytes, long rxPackets, long txBytes, long txPackets) {
final NetworkStats.Entry entry = stats.getValues(i, null);
assertEquals(iface, entry.iface);
assertEquals(uid, entry.uid);
assertEquals(tag, entry.tag);
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() {