Move some NetworkStats tests to tests/net.
This groups them together with the rest of the networking unit
tests. It also speeds up compile/test cycles ("runtest -x" of one
file goes from 1m15s to 30s).
Test: runtest frameworks-net passes on internal tree
Change-Id: I53cb0c51355fe4b4b30e451fa09fbbf58da39efd
This commit is contained in:
Lorenzo Colitti
555
tests/net/java/android/net/NetworkStatsHistoryTest.java
Normal file
555
tests/net/java/android/net/NetworkStatsHistoryTest.java
Normal file
@@ -0,0 +1,555 @@
|
||||
/*
|
||||
* Copyright (C) 2011 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package android.net;
|
||||
|
||||
import static android.net.NetworkStatsHistory.FIELD_ALL;
|
||||
import static android.net.NetworkStatsHistory.FIELD_OPERATIONS;
|
||||
import static android.net.NetworkStatsHistory.FIELD_RX_BYTES;
|
||||
import static android.net.NetworkStatsHistory.FIELD_RX_PACKETS;
|
||||
import static android.net.NetworkStatsHistory.FIELD_TX_BYTES;
|
||||
import static android.net.NetworkStatsHistory.DataStreamUtils.readVarLong;
|
||||
import static android.net.NetworkStatsHistory.DataStreamUtils.writeVarLong;
|
||||
import static android.net.NetworkStatsHistory.Entry.UNKNOWN;
|
||||
import static android.net.TrafficStats.GB_IN_BYTES;
|
||||
import static android.net.TrafficStats.MB_IN_BYTES;
|
||||
import static android.text.format.DateUtils.DAY_IN_MILLIS;
|
||||
import static android.text.format.DateUtils.HOUR_IN_MILLIS;
|
||||
import static android.text.format.DateUtils.MINUTE_IN_MILLIS;
|
||||
import static android.text.format.DateUtils.SECOND_IN_MILLIS;
|
||||
import static android.text.format.DateUtils.WEEK_IN_MILLIS;
|
||||
import static android.text.format.DateUtils.YEAR_IN_MILLIS;
|
||||
|
||||
import android.test.AndroidTestCase;
|
||||
import android.test.suitebuilder.annotation.SmallTest;
|
||||
import android.test.suitebuilder.annotation.Suppress;
|
||||
import android.util.Log;
|
||||
|
||||
import com.android.frameworks.tests.net.R;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.DataInputStream;
|
||||
import java.io.DataOutputStream;
|
||||
import java.util.Random;
|
||||
|
||||
@SmallTest
|
||||
public class NetworkStatsHistoryTest extends AndroidTestCase {
|
||||
private static final String TAG = "NetworkStatsHistoryTest";
|
||||
|
||||
private static final long TEST_START = 1194220800000L;
|
||||
|
||||
private NetworkStatsHistory stats;
|
||||
|
||||
@Override
|
||||
protected void tearDown() throws Exception {
|
||||
super.tearDown();
|
||||
if (stats != null) {
|
||||
assertConsistent(stats);
|
||||
}
|
||||
}
|
||||
|
||||
public void testReadOriginalVersion() throws Exception {
|
||||
final DataInputStream in = new DataInputStream(
|
||||
getContext().getResources().openRawResource(R.raw.history_v1));
|
||||
|
||||
NetworkStatsHistory.Entry entry = null;
|
||||
try {
|
||||
final NetworkStatsHistory history = new NetworkStatsHistory(in);
|
||||
assertEquals(15 * SECOND_IN_MILLIS, history.getBucketDuration());
|
||||
|
||||
entry = history.getValues(0, entry);
|
||||
assertEquals(29143L, entry.rxBytes);
|
||||
assertEquals(6223L, entry.txBytes);
|
||||
|
||||
entry = history.getValues(history.size() - 1, entry);
|
||||
assertEquals(1476L, entry.rxBytes);
|
||||
assertEquals(838L, entry.txBytes);
|
||||
|
||||
entry = history.getValues(Long.MIN_VALUE, Long.MAX_VALUE, entry);
|
||||
assertEquals(332401L, entry.rxBytes);
|
||||
assertEquals(64314L, entry.txBytes);
|
||||
|
||||
} finally {
|
||||
in.close();
|
||||
}
|
||||
}
|
||||
|
||||
public void testRecordSingleBucket() throws Exception {
|
||||
final long BUCKET_SIZE = HOUR_IN_MILLIS;
|
||||
stats = new NetworkStatsHistory(BUCKET_SIZE);
|
||||
|
||||
// record data into narrow window to get single bucket
|
||||
stats.recordData(TEST_START, TEST_START + SECOND_IN_MILLIS,
|
||||
new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 2L));
|
||||
|
||||
assertEquals(1, stats.size());
|
||||
assertValues(stats, 0, SECOND_IN_MILLIS, 1024L, 10L, 2048L, 20L, 2L);
|
||||
}
|
||||
|
||||
public void testRecordEqualBuckets() throws Exception {
|
||||
final long bucketDuration = HOUR_IN_MILLIS;
|
||||
stats = new NetworkStatsHistory(bucketDuration);
|
||||
|
||||
// split equally across two buckets
|
||||
final long recordStart = TEST_START + (bucketDuration / 2);
|
||||
stats.recordData(recordStart, recordStart + bucketDuration,
|
||||
new NetworkStats.Entry(1024L, 10L, 128L, 2L, 2L));
|
||||
|
||||
assertEquals(2, stats.size());
|
||||
assertValues(stats, 0, HOUR_IN_MILLIS / 2, 512L, 5L, 64L, 1L, 1L);
|
||||
assertValues(stats, 1, HOUR_IN_MILLIS / 2, 512L, 5L, 64L, 1L, 1L);
|
||||
}
|
||||
|
||||
public void testRecordTouchingBuckets() throws Exception {
|
||||
final long BUCKET_SIZE = 15 * MINUTE_IN_MILLIS;
|
||||
stats = new NetworkStatsHistory(BUCKET_SIZE);
|
||||
|
||||
// split almost completely into middle bucket, but with a few minutes
|
||||
// overlap into neighboring buckets. total record is 20 minutes.
|
||||
final long recordStart = (TEST_START + BUCKET_SIZE) - MINUTE_IN_MILLIS;
|
||||
final long recordEnd = (TEST_START + (BUCKET_SIZE * 2)) + (MINUTE_IN_MILLIS * 4);
|
||||
stats.recordData(recordStart, recordEnd,
|
||||
new NetworkStats.Entry(1000L, 2000L, 5000L, 10000L, 100L));
|
||||
|
||||
assertEquals(3, stats.size());
|
||||
// first bucket should have (1/20 of value)
|
||||
assertValues(stats, 0, MINUTE_IN_MILLIS, 50L, 100L, 250L, 500L, 5L);
|
||||
// second bucket should have (15/20 of value)
|
||||
assertValues(stats, 1, 15 * MINUTE_IN_MILLIS, 750L, 1500L, 3750L, 7500L, 75L);
|
||||
// final bucket should have (4/20 of value)
|
||||
assertValues(stats, 2, 4 * MINUTE_IN_MILLIS, 200L, 400L, 1000L, 2000L, 20L);
|
||||
}
|
||||
|
||||
public void testRecordGapBuckets() throws Exception {
|
||||
final long BUCKET_SIZE = HOUR_IN_MILLIS;
|
||||
stats = new NetworkStatsHistory(BUCKET_SIZE);
|
||||
|
||||
// record some data today and next week with large gap
|
||||
final long firstStart = TEST_START;
|
||||
final long lastStart = TEST_START + WEEK_IN_MILLIS;
|
||||
stats.recordData(firstStart, firstStart + SECOND_IN_MILLIS,
|
||||
new NetworkStats.Entry(128L, 2L, 256L, 4L, 1L));
|
||||
stats.recordData(lastStart, lastStart + SECOND_IN_MILLIS,
|
||||
new NetworkStats.Entry(64L, 1L, 512L, 8L, 2L));
|
||||
|
||||
// we should have two buckets, far apart from each other
|
||||
assertEquals(2, stats.size());
|
||||
assertValues(stats, 0, SECOND_IN_MILLIS, 128L, 2L, 256L, 4L, 1L);
|
||||
assertValues(stats, 1, SECOND_IN_MILLIS, 64L, 1L, 512L, 8L, 2L);
|
||||
|
||||
// now record something in middle, spread across two buckets
|
||||
final long middleStart = TEST_START + DAY_IN_MILLIS;
|
||||
final long middleEnd = middleStart + (HOUR_IN_MILLIS * 2);
|
||||
stats.recordData(middleStart, middleEnd,
|
||||
new NetworkStats.Entry(2048L, 4L, 2048L, 4L, 2L));
|
||||
|
||||
// now should have four buckets, with new record in middle two buckets
|
||||
assertEquals(4, stats.size());
|
||||
assertValues(stats, 0, SECOND_IN_MILLIS, 128L, 2L, 256L, 4L, 1L);
|
||||
assertValues(stats, 1, HOUR_IN_MILLIS, 1024L, 2L, 1024L, 2L, 1L);
|
||||
assertValues(stats, 2, HOUR_IN_MILLIS, 1024L, 2L, 1024L, 2L, 1L);
|
||||
assertValues(stats, 3, SECOND_IN_MILLIS, 64L, 1L, 512L, 8L, 2L);
|
||||
}
|
||||
|
||||
public void testRecordOverlapBuckets() throws Exception {
|
||||
final long BUCKET_SIZE = HOUR_IN_MILLIS;
|
||||
stats = new NetworkStatsHistory(BUCKET_SIZE);
|
||||
|
||||
// record some data in one bucket, and another overlapping buckets
|
||||
stats.recordData(TEST_START, TEST_START + SECOND_IN_MILLIS,
|
||||
new NetworkStats.Entry(256L, 2L, 256L, 2L, 1L));
|
||||
final long midStart = TEST_START + (HOUR_IN_MILLIS / 2);
|
||||
stats.recordData(midStart, midStart + HOUR_IN_MILLIS,
|
||||
new NetworkStats.Entry(1024L, 10L, 1024L, 10L, 10L));
|
||||
|
||||
// should have two buckets, with some data mixed together
|
||||
assertEquals(2, stats.size());
|
||||
assertValues(stats, 0, SECOND_IN_MILLIS + (HOUR_IN_MILLIS / 2), 768L, 7L, 768L, 7L, 6L);
|
||||
assertValues(stats, 1, (HOUR_IN_MILLIS / 2), 512L, 5L, 512L, 5L, 5L);
|
||||
}
|
||||
|
||||
public void testRecordEntireGapIdentical() throws Exception {
|
||||
// first, create two separate histories far apart
|
||||
final NetworkStatsHistory stats1 = new NetworkStatsHistory(HOUR_IN_MILLIS);
|
||||
stats1.recordData(TEST_START, TEST_START + 2 * HOUR_IN_MILLIS, 2000L, 1000L);
|
||||
|
||||
final long TEST_START_2 = TEST_START + DAY_IN_MILLIS;
|
||||
final NetworkStatsHistory stats2 = new NetworkStatsHistory(HOUR_IN_MILLIS);
|
||||
stats2.recordData(TEST_START_2, TEST_START_2 + 2 * HOUR_IN_MILLIS, 1000L, 500L);
|
||||
|
||||
// combine together with identical bucket size
|
||||
stats = new NetworkStatsHistory(HOUR_IN_MILLIS);
|
||||
stats.recordEntireHistory(stats1);
|
||||
stats.recordEntireHistory(stats2);
|
||||
|
||||
// first verify that totals match up
|
||||
assertValues(stats, TEST_START - WEEK_IN_MILLIS, TEST_START + WEEK_IN_MILLIS, 3000L, 1500L);
|
||||
|
||||
// now inspect internal buckets
|
||||
assertValues(stats, 0, 1000L, 500L);
|
||||
assertValues(stats, 1, 1000L, 500L);
|
||||
assertValues(stats, 2, 500L, 250L);
|
||||
assertValues(stats, 3, 500L, 250L);
|
||||
}
|
||||
|
||||
public void testRecordEntireOverlapVaryingBuckets() throws Exception {
|
||||
// create history just over hour bucket boundary
|
||||
final NetworkStatsHistory stats1 = new NetworkStatsHistory(HOUR_IN_MILLIS);
|
||||
stats1.recordData(TEST_START, TEST_START + MINUTE_IN_MILLIS * 60, 600L, 600L);
|
||||
|
||||
final long TEST_START_2 = TEST_START + MINUTE_IN_MILLIS;
|
||||
final NetworkStatsHistory stats2 = new NetworkStatsHistory(MINUTE_IN_MILLIS);
|
||||
stats2.recordData(TEST_START_2, TEST_START_2 + MINUTE_IN_MILLIS * 5, 50L, 50L);
|
||||
|
||||
// combine together with minute bucket size
|
||||
stats = new NetworkStatsHistory(MINUTE_IN_MILLIS);
|
||||
stats.recordEntireHistory(stats1);
|
||||
stats.recordEntireHistory(stats2);
|
||||
|
||||
// first verify that totals match up
|
||||
assertValues(stats, TEST_START - WEEK_IN_MILLIS, TEST_START + WEEK_IN_MILLIS, 650L, 650L);
|
||||
|
||||
// now inspect internal buckets
|
||||
assertValues(stats, 0, 10L, 10L);
|
||||
assertValues(stats, 1, 20L, 20L);
|
||||
assertValues(stats, 2, 20L, 20L);
|
||||
assertValues(stats, 3, 20L, 20L);
|
||||
assertValues(stats, 4, 20L, 20L);
|
||||
assertValues(stats, 5, 20L, 20L);
|
||||
assertValues(stats, 6, 10L, 10L);
|
||||
|
||||
// now combine using 15min buckets
|
||||
stats = new NetworkStatsHistory(HOUR_IN_MILLIS / 4);
|
||||
stats.recordEntireHistory(stats1);
|
||||
stats.recordEntireHistory(stats2);
|
||||
|
||||
// first verify that totals match up
|
||||
assertValues(stats, TEST_START - WEEK_IN_MILLIS, TEST_START + WEEK_IN_MILLIS, 650L, 650L);
|
||||
|
||||
// and inspect buckets
|
||||
assertValues(stats, 0, 200L, 200L);
|
||||
assertValues(stats, 1, 150L, 150L);
|
||||
assertValues(stats, 2, 150L, 150L);
|
||||
assertValues(stats, 3, 150L, 150L);
|
||||
}
|
||||
|
||||
public void testRemove() throws Exception {
|
||||
stats = new NetworkStatsHistory(HOUR_IN_MILLIS);
|
||||
|
||||
// record some data across 24 buckets
|
||||
stats.recordData(TEST_START, TEST_START + DAY_IN_MILLIS, 24L, 24L);
|
||||
assertEquals(24, stats.size());
|
||||
|
||||
// try removing invalid data; should be no change
|
||||
stats.removeBucketsBefore(0 - DAY_IN_MILLIS);
|
||||
assertEquals(24, stats.size());
|
||||
|
||||
// try removing far before buckets; should be no change
|
||||
stats.removeBucketsBefore(TEST_START - YEAR_IN_MILLIS);
|
||||
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.size());
|
||||
|
||||
// try removing single bucket
|
||||
stats.removeBucketsBefore(TEST_START + HOUR_IN_MILLIS);
|
||||
assertEquals(23, stats.size());
|
||||
|
||||
// try removing multiple buckets
|
||||
stats.removeBucketsBefore(TEST_START + (4 * HOUR_IN_MILLIS));
|
||||
assertEquals(20, stats.size());
|
||||
|
||||
// try removing all buckets
|
||||
stats.removeBucketsBefore(TEST_START + YEAR_IN_MILLIS);
|
||||
assertEquals(0, stats.size());
|
||||
}
|
||||
|
||||
public void testTotalData() throws Exception {
|
||||
final long BUCKET_SIZE = HOUR_IN_MILLIS;
|
||||
stats = new NetworkStatsHistory(BUCKET_SIZE);
|
||||
|
||||
// record uniform data across day
|
||||
stats.recordData(TEST_START, TEST_START + DAY_IN_MILLIS, 2400L, 4800L);
|
||||
|
||||
// verify that total outside range is 0
|
||||
assertValues(stats, TEST_START - WEEK_IN_MILLIS, TEST_START - DAY_IN_MILLIS, 0L, 0L);
|
||||
|
||||
// verify total in first hour
|
||||
assertValues(stats, TEST_START, TEST_START + HOUR_IN_MILLIS, 100L, 200L);
|
||||
|
||||
// verify total across 1.5 hours
|
||||
assertValues(stats, TEST_START, TEST_START + (long) (1.5 * HOUR_IN_MILLIS), 150L, 300L);
|
||||
|
||||
// verify total beyond end
|
||||
assertValues(stats, TEST_START + (23 * HOUR_IN_MILLIS), TEST_START + WEEK_IN_MILLIS, 100L, 200L);
|
||||
|
||||
// verify everything total
|
||||
assertValues(stats, TEST_START - WEEK_IN_MILLIS, TEST_START + WEEK_IN_MILLIS, 2400L, 4800L);
|
||||
|
||||
}
|
||||
|
||||
@Suppress
|
||||
public void testFuzzing() throws Exception {
|
||||
try {
|
||||
// fuzzing with random events, looking for crashes
|
||||
final NetworkStats.Entry entry = new NetworkStats.Entry();
|
||||
final Random r = new Random();
|
||||
for (int i = 0; i < 500; i++) {
|
||||
stats = new NetworkStatsHistory(r.nextLong());
|
||||
for (int j = 0; j < 10000; j++) {
|
||||
if (r.nextBoolean()) {
|
||||
// add range
|
||||
final long start = r.nextLong();
|
||||
final long end = start + r.nextInt();
|
||||
entry.rxBytes = nextPositiveLong(r);
|
||||
entry.rxPackets = nextPositiveLong(r);
|
||||
entry.txBytes = nextPositiveLong(r);
|
||||
entry.txPackets = nextPositiveLong(r);
|
||||
entry.operations = nextPositiveLong(r);
|
||||
stats.recordData(start, end, entry);
|
||||
} else {
|
||||
// trim something
|
||||
stats.removeBucketsBefore(r.nextLong());
|
||||
}
|
||||
}
|
||||
assertConsistent(stats);
|
||||
}
|
||||
} catch (Throwable e) {
|
||||
Log.e(TAG, String.valueOf(stats));
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
private static long nextPositiveLong(Random r) {
|
||||
final long value = r.nextLong();
|
||||
return value < 0 ? -value : value;
|
||||
}
|
||||
|
||||
public void testIgnoreFields() throws Exception {
|
||||
final NetworkStatsHistory history = new NetworkStatsHistory(
|
||||
MINUTE_IN_MILLIS, 0, FIELD_RX_BYTES | FIELD_TX_BYTES);
|
||||
|
||||
history.recordData(0, MINUTE_IN_MILLIS,
|
||||
new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 4L));
|
||||
history.recordData(0, 2 * MINUTE_IN_MILLIS,
|
||||
new NetworkStats.Entry(2L, 2L, 2L, 2L, 2L));
|
||||
|
||||
assertFullValues(history, UNKNOWN, 1026L, UNKNOWN, 2050L, UNKNOWN, UNKNOWN);
|
||||
}
|
||||
|
||||
public void testIgnoreFieldsRecordIn() throws Exception {
|
||||
final NetworkStatsHistory full = new NetworkStatsHistory(MINUTE_IN_MILLIS, 0, FIELD_ALL);
|
||||
final NetworkStatsHistory partial = new NetworkStatsHistory(
|
||||
MINUTE_IN_MILLIS, 0, FIELD_RX_PACKETS | FIELD_OPERATIONS);
|
||||
|
||||
full.recordData(0, MINUTE_IN_MILLIS,
|
||||
new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 4L));
|
||||
partial.recordEntireHistory(full);
|
||||
|
||||
assertFullValues(partial, UNKNOWN, UNKNOWN, 10L, UNKNOWN, UNKNOWN, 4L);
|
||||
}
|
||||
|
||||
public void testIgnoreFieldsRecordOut() throws Exception {
|
||||
final NetworkStatsHistory full = new NetworkStatsHistory(MINUTE_IN_MILLIS, 0, FIELD_ALL);
|
||||
final NetworkStatsHistory partial = new NetworkStatsHistory(
|
||||
MINUTE_IN_MILLIS, 0, FIELD_RX_PACKETS | FIELD_OPERATIONS);
|
||||
|
||||
partial.recordData(0, MINUTE_IN_MILLIS,
|
||||
new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 4L));
|
||||
full.recordEntireHistory(partial);
|
||||
|
||||
assertFullValues(full, MINUTE_IN_MILLIS, 0L, 10L, 0L, 0L, 4L);
|
||||
}
|
||||
|
||||
public void testSerialize() throws Exception {
|
||||
final NetworkStatsHistory before = new NetworkStatsHistory(MINUTE_IN_MILLIS, 40, FIELD_ALL);
|
||||
before.recordData(0, 4 * MINUTE_IN_MILLIS,
|
||||
new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 4L));
|
||||
before.recordData(DAY_IN_MILLIS, DAY_IN_MILLIS + MINUTE_IN_MILLIS,
|
||||
new NetworkStats.Entry(10L, 20L, 30L, 40L, 50L));
|
||||
|
||||
final ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
before.writeToStream(new DataOutputStream(out));
|
||||
out.close();
|
||||
|
||||
final ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
|
||||
final NetworkStatsHistory after = new NetworkStatsHistory(new DataInputStream(in));
|
||||
|
||||
// must have identical totals before and after
|
||||
assertFullValues(before, 5 * MINUTE_IN_MILLIS, 1034L, 30L, 2078L, 60L, 54L);
|
||||
assertFullValues(after, 5 * MINUTE_IN_MILLIS, 1034L, 30L, 2078L, 60L, 54L);
|
||||
}
|
||||
|
||||
public void testVarLong() throws Exception {
|
||||
assertEquals(0L, performVarLong(0L));
|
||||
assertEquals(-1L, performVarLong(-1L));
|
||||
assertEquals(1024L, performVarLong(1024L));
|
||||
assertEquals(-1024L, performVarLong(-1024L));
|
||||
assertEquals(40 * MB_IN_BYTES, performVarLong(40 * MB_IN_BYTES));
|
||||
assertEquals(512 * GB_IN_BYTES, performVarLong(512 * GB_IN_BYTES));
|
||||
assertEquals(Long.MIN_VALUE, performVarLong(Long.MIN_VALUE));
|
||||
assertEquals(Long.MAX_VALUE, performVarLong(Long.MAX_VALUE));
|
||||
assertEquals(Long.MIN_VALUE + 40, performVarLong(Long.MIN_VALUE + 40));
|
||||
assertEquals(Long.MAX_VALUE - 40, performVarLong(Long.MAX_VALUE - 40));
|
||||
}
|
||||
|
||||
public void testIndexBeforeAfter() throws Exception {
|
||||
final long BUCKET_SIZE = HOUR_IN_MILLIS;
|
||||
stats = new NetworkStatsHistory(BUCKET_SIZE);
|
||||
|
||||
final long FIRST_START = TEST_START;
|
||||
final long FIRST_END = FIRST_START + (2 * HOUR_IN_MILLIS);
|
||||
final long SECOND_START = TEST_START + WEEK_IN_MILLIS;
|
||||
final long SECOND_END = SECOND_START + HOUR_IN_MILLIS;
|
||||
final long THIRD_START = TEST_START + (2 * WEEK_IN_MILLIS);
|
||||
final long THIRD_END = THIRD_START + (2 * HOUR_IN_MILLIS);
|
||||
|
||||
stats.recordData(FIRST_START, FIRST_END,
|
||||
new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 2L));
|
||||
stats.recordData(SECOND_START, SECOND_END,
|
||||
new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 2L));
|
||||
stats.recordData(THIRD_START, THIRD_END,
|
||||
new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 2L));
|
||||
|
||||
// should have buckets: 2+1+2
|
||||
assertEquals(5, stats.size());
|
||||
|
||||
assertIndexBeforeAfter(stats, 0, 0, Long.MIN_VALUE);
|
||||
assertIndexBeforeAfter(stats, 0, 1, FIRST_START);
|
||||
assertIndexBeforeAfter(stats, 0, 1, FIRST_START + MINUTE_IN_MILLIS);
|
||||
assertIndexBeforeAfter(stats, 0, 2, FIRST_START + HOUR_IN_MILLIS);
|
||||
assertIndexBeforeAfter(stats, 1, 2, FIRST_START + HOUR_IN_MILLIS + MINUTE_IN_MILLIS);
|
||||
assertIndexBeforeAfter(stats, 1, 2, FIRST_END - MINUTE_IN_MILLIS);
|
||||
assertIndexBeforeAfter(stats, 1, 2, FIRST_END);
|
||||
assertIndexBeforeAfter(stats, 1, 2, FIRST_END + MINUTE_IN_MILLIS);
|
||||
assertIndexBeforeAfter(stats, 1, 2, SECOND_START - MINUTE_IN_MILLIS);
|
||||
assertIndexBeforeAfter(stats, 1, 3, SECOND_START);
|
||||
assertIndexBeforeAfter(stats, 2, 3, SECOND_END);
|
||||
assertIndexBeforeAfter(stats, 2, 3, SECOND_END + MINUTE_IN_MILLIS);
|
||||
assertIndexBeforeAfter(stats, 2, 3, THIRD_START - MINUTE_IN_MILLIS);
|
||||
assertIndexBeforeAfter(stats, 2, 4, THIRD_START);
|
||||
assertIndexBeforeAfter(stats, 3, 4, THIRD_START + MINUTE_IN_MILLIS);
|
||||
assertIndexBeforeAfter(stats, 3, 4, THIRD_START + HOUR_IN_MILLIS);
|
||||
assertIndexBeforeAfter(stats, 4, 4, THIRD_END);
|
||||
assertIndexBeforeAfter(stats, 4, 4, THIRD_END + MINUTE_IN_MILLIS);
|
||||
assertIndexBeforeAfter(stats, 4, 4, Long.MAX_VALUE);
|
||||
}
|
||||
|
||||
public void testIntersects() throws Exception {
|
||||
final long BUCKET_SIZE = HOUR_IN_MILLIS;
|
||||
stats = new NetworkStatsHistory(BUCKET_SIZE);
|
||||
|
||||
final long FIRST_START = TEST_START;
|
||||
final long FIRST_END = FIRST_START + (2 * HOUR_IN_MILLIS);
|
||||
final long SECOND_START = TEST_START + WEEK_IN_MILLIS;
|
||||
final long SECOND_END = SECOND_START + HOUR_IN_MILLIS;
|
||||
final long THIRD_START = TEST_START + (2 * WEEK_IN_MILLIS);
|
||||
final long THIRD_END = THIRD_START + (2 * HOUR_IN_MILLIS);
|
||||
|
||||
stats.recordData(FIRST_START, FIRST_END,
|
||||
new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 2L));
|
||||
stats.recordData(SECOND_START, SECOND_END,
|
||||
new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 2L));
|
||||
stats.recordData(THIRD_START, THIRD_END,
|
||||
new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 2L));
|
||||
|
||||
assertFalse(stats.intersects(10, 20));
|
||||
assertFalse(stats.intersects(TEST_START + YEAR_IN_MILLIS, TEST_START + YEAR_IN_MILLIS + 1));
|
||||
assertFalse(stats.intersects(Long.MAX_VALUE, Long.MIN_VALUE));
|
||||
|
||||
assertTrue(stats.intersects(Long.MIN_VALUE, Long.MAX_VALUE));
|
||||
assertTrue(stats.intersects(10, TEST_START + YEAR_IN_MILLIS));
|
||||
assertTrue(stats.intersects(TEST_START, TEST_START));
|
||||
assertTrue(stats.intersects(TEST_START + DAY_IN_MILLIS, TEST_START + DAY_IN_MILLIS + 1));
|
||||
assertTrue(stats.intersects(TEST_START + DAY_IN_MILLIS, Long.MAX_VALUE));
|
||||
assertTrue(stats.intersects(TEST_START + 1, Long.MAX_VALUE));
|
||||
|
||||
assertFalse(stats.intersects(Long.MIN_VALUE, TEST_START - 1));
|
||||
assertTrue(stats.intersects(Long.MIN_VALUE, TEST_START));
|
||||
assertTrue(stats.intersects(Long.MIN_VALUE, TEST_START + 1));
|
||||
}
|
||||
|
||||
private static void assertIndexBeforeAfter(
|
||||
NetworkStatsHistory stats, int before, int after, long time) {
|
||||
assertEquals("unexpected before", before, stats.getIndexBefore(time));
|
||||
assertEquals("unexpected after", after, stats.getIndexAfter(time));
|
||||
}
|
||||
|
||||
private static long performVarLong(long before) throws Exception {
|
||||
final ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
writeVarLong(new DataOutputStream(out), before);
|
||||
|
||||
final ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
|
||||
return readVarLong(new DataInputStream(in));
|
||||
}
|
||||
|
||||
private static void assertConsistent(NetworkStatsHistory stats) {
|
||||
// verify timestamps are monotonic
|
||||
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 assertValues(
|
||||
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);
|
||||
}
|
||||
|
||||
private static void assertValues(
|
||||
NetworkStatsHistory stats, long start, long end, long rxBytes, long txBytes) {
|
||||
final NetworkStatsHistory.Entry entry = stats.getValues(start, end, null);
|
||||
assertEquals("unexpected rxBytes", rxBytes, entry.rxBytes);
|
||||
assertEquals("unexpected txBytes", txBytes, entry.txBytes);
|
||||
}
|
||||
|
||||
private static void assertValues(NetworkStatsHistory stats, int index, long activeTime,
|
||||
long rxBytes, long rxPackets, long txBytes, long txPackets, long operations) {
|
||||
final NetworkStatsHistory.Entry entry = stats.getValues(index, null);
|
||||
assertEquals("unexpected activeTime", activeTime, entry.activeTime);
|
||||
assertEquals("unexpected rxBytes", rxBytes, entry.rxBytes);
|
||||
assertEquals("unexpected rxPackets", rxPackets, entry.rxPackets);
|
||||
assertEquals("unexpected txBytes", txBytes, entry.txBytes);
|
||||
assertEquals("unexpected txPackets", txPackets, entry.txPackets);
|
||||
assertEquals("unexpected operations", operations, entry.operations);
|
||||
}
|
||||
|
||||
private static void assertFullValues(NetworkStatsHistory stats, long activeTime, long rxBytes,
|
||||
long rxPackets, long txBytes, long txPackets, long operations) {
|
||||
assertValues(stats, Long.MIN_VALUE, Long.MAX_VALUE, activeTime, rxBytes, rxPackets, txBytes,
|
||||
txPackets, operations);
|
||||
}
|
||||
|
||||
private static void assertValues(NetworkStatsHistory stats, long start, long end,
|
||||
long activeTime, long rxBytes, long rxPackets, long txBytes, long txPackets,
|
||||
long operations) {
|
||||
final NetworkStatsHistory.Entry entry = stats.getValues(start, end, null);
|
||||
assertEquals("unexpected activeTime", activeTime, entry.activeTime);
|
||||
assertEquals("unexpected rxBytes", rxBytes, entry.rxBytes);
|
||||
assertEquals("unexpected rxPackets", rxPackets, entry.rxPackets);
|
||||
assertEquals("unexpected txBytes", txBytes, entry.txBytes);
|
||||
assertEquals("unexpected txPackets", txPackets, entry.txPackets);
|
||||
assertEquals("unexpected operations", operations, entry.operations);
|
||||
}
|
||||
}
|
||||
649
tests/net/java/android/net/NetworkStatsTest.java
Normal file
649
tests/net/java/android/net/NetworkStatsTest.java
Normal file
@@ -0,0 +1,649 @@
|
||||
/*
|
||||
* Copyright (C) 2011 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package android.net;
|
||||
|
||||
import static android.net.NetworkStats.METERED_ALL;
|
||||
import static android.net.NetworkStats.METERED_NO;
|
||||
import static android.net.NetworkStats.METERED_YES;
|
||||
import static android.net.NetworkStats.ROAMING_ALL;
|
||||
import static android.net.NetworkStats.ROAMING_NO;
|
||||
import static android.net.NetworkStats.ROAMING_YES;
|
||||
import static android.net.NetworkStats.SET_DEFAULT;
|
||||
import static android.net.NetworkStats.SET_FOREGROUND;
|
||||
import static android.net.NetworkStats.SET_DBG_VPN_IN;
|
||||
import static android.net.NetworkStats.SET_DBG_VPN_OUT;
|
||||
import static android.net.NetworkStats.SET_ALL;
|
||||
import static android.net.NetworkStats.IFACE_ALL;
|
||||
import static android.net.NetworkStats.TAG_NONE;
|
||||
import static android.net.NetworkStats.UID_ALL;
|
||||
|
||||
import android.test.suitebuilder.annotation.SmallTest;
|
||||
|
||||
import com.google.android.collect.Sets;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
import java.util.HashSet;
|
||||
|
||||
@SmallTest
|
||||
public class NetworkStatsTest extends TestCase {
|
||||
|
||||
private static final String TEST_IFACE = "test0";
|
||||
private static final String TEST_IFACE2 = "test2";
|
||||
private static final int TEST_UID = 1001;
|
||||
private static final long TEST_START = 1194220800000L;
|
||||
|
||||
public void testFindIndex() throws Exception {
|
||||
final NetworkStats stats = new NetworkStats(TEST_START, 5)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 1024L,
|
||||
8L, 0L, 0L, 10)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 0L, 0L,
|
||||
1024L, 8L, 11)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_YES, ROAMING_NO, 0L, 0L,
|
||||
1024L, 8L, 11)
|
||||
.addValues(TEST_IFACE, 102, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 1024L,
|
||||
8L, 1024L, 8L, 12)
|
||||
.addValues(TEST_IFACE, 102, SET_DEFAULT, TAG_NONE, METERED_YES, ROAMING_YES, 1024L,
|
||||
8L, 1024L, 8L, 12);
|
||||
|
||||
assertEquals(4, stats.findIndex(TEST_IFACE, 102, SET_DEFAULT, TAG_NONE, METERED_YES,
|
||||
ROAMING_YES));
|
||||
assertEquals(3, stats.findIndex(TEST_IFACE, 102, SET_DEFAULT, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO));
|
||||
assertEquals(2, stats.findIndex(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_YES,
|
||||
ROAMING_NO));
|
||||
assertEquals(1, stats.findIndex(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO));
|
||||
assertEquals(0, stats.findIndex(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO));
|
||||
assertEquals(-1, stats.findIndex(TEST_IFACE, 6, SET_DEFAULT, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO));
|
||||
}
|
||||
|
||||
public void testFindIndexHinted() {
|
||||
final NetworkStats stats = new NetworkStats(TEST_START, 3)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 1024L,
|
||||
8L, 0L, 0L, 10)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 0L, 0L,
|
||||
1024L, 8L, 11)
|
||||
.addValues(TEST_IFACE, 102, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 1024L,
|
||||
8L, 1024L, 8L, 12)
|
||||
.addValues(TEST_IFACE2, 100, SET_FOREGROUND, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
1024L, 8L, 0L, 0L, 10)
|
||||
.addValues(TEST_IFACE2, 101, SET_DEFAULT, 0xF00D, METERED_NO, ROAMING_NO, 0L, 0L,
|
||||
1024L, 8L, 11)
|
||||
.addValues(TEST_IFACE2, 101, SET_DEFAULT, 0xF00D, METERED_YES, ROAMING_NO, 0L, 0L,
|
||||
1024L, 8L, 11)
|
||||
.addValues(TEST_IFACE2, 102, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 1024L,
|
||||
8L, 1024L, 8L, 12)
|
||||
.addValues(TEST_IFACE2, 102, SET_DEFAULT, TAG_NONE, METERED_YES, ROAMING_YES, 1024L,
|
||||
8L, 1024L, 8L, 12);
|
||||
|
||||
// verify that we correctly find across regardless of hinting
|
||||
for (int hint = 0; hint < stats.size(); hint++) {
|
||||
assertEquals(0, stats.findIndexHinted(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE,
|
||||
METERED_NO, ROAMING_NO, hint));
|
||||
assertEquals(1, stats.findIndexHinted(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE,
|
||||
METERED_NO, ROAMING_NO, hint));
|
||||
assertEquals(2, stats.findIndexHinted(TEST_IFACE, 102, SET_DEFAULT, TAG_NONE,
|
||||
METERED_NO, ROAMING_NO, hint));
|
||||
assertEquals(3, stats.findIndexHinted(TEST_IFACE2, 100, SET_FOREGROUND, TAG_NONE,
|
||||
METERED_NO, ROAMING_NO, hint));
|
||||
assertEquals(4, stats.findIndexHinted(TEST_IFACE2, 101, SET_DEFAULT, 0xF00D,
|
||||
METERED_NO, ROAMING_NO, hint));
|
||||
assertEquals(5, stats.findIndexHinted(TEST_IFACE2, 101, SET_DEFAULT, 0xF00D,
|
||||
METERED_YES, ROAMING_NO, hint));
|
||||
assertEquals(6, stats.findIndexHinted(TEST_IFACE2, 102, SET_DEFAULT, TAG_NONE,
|
||||
METERED_NO, ROAMING_NO, hint));
|
||||
assertEquals(7, stats.findIndexHinted(TEST_IFACE2, 102, SET_DEFAULT, TAG_NONE,
|
||||
METERED_YES, ROAMING_YES, hint));
|
||||
assertEquals(-1, stats.findIndexHinted(TEST_IFACE, 6, SET_DEFAULT, TAG_NONE,
|
||||
METERED_NO, ROAMING_NO, hint));
|
||||
}
|
||||
}
|
||||
|
||||
public void testAddEntryGrow() throws Exception {
|
||||
final NetworkStats stats = new NetworkStats(TEST_START, 4);
|
||||
|
||||
assertEquals(0, stats.size());
|
||||
assertEquals(4, stats.internalSize());
|
||||
|
||||
stats.addValues(TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 1L, 1L,
|
||||
2L, 2L, 3);
|
||||
stats.addValues(TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 2L, 2L,
|
||||
2L, 2L, 4);
|
||||
stats.addValues(TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_YES, 3L,
|
||||
3L, 2L, 2L, 5);
|
||||
stats.addValues(TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_YES, ROAMING_YES, 3L,
|
||||
3L, 2L, 2L, 5);
|
||||
|
||||
assertEquals(4, stats.size());
|
||||
assertEquals(4, stats.internalSize());
|
||||
|
||||
stats.addValues(TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 4L,
|
||||
40L, 4L, 40L, 7);
|
||||
stats.addValues(TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 5L,
|
||||
50L, 4L, 40L, 8);
|
||||
stats.addValues(TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 6L,
|
||||
60L, 5L, 50L, 10);
|
||||
stats.addValues(TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_YES, 7L,
|
||||
70L, 5L, 50L, 11);
|
||||
stats.addValues(TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_YES, ROAMING_YES, 7L,
|
||||
70L, 5L, 50L, 11);
|
||||
|
||||
assertEquals(9, stats.size());
|
||||
assertTrue(stats.internalSize() >= 9);
|
||||
|
||||
assertValues(stats, 0, TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
1L, 1L, 2L, 2L, 3);
|
||||
assertValues(stats, 1, TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
2L, 2L, 2L, 2L, 4);
|
||||
assertValues(stats, 2, TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_YES,
|
||||
3L, 3L, 2L, 2L, 5);
|
||||
assertValues(stats, 3, TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_YES,
|
||||
ROAMING_YES, 3L, 3L, 2L, 2L, 5);
|
||||
assertValues(stats, 4, TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
4L, 40L, 4L, 40L, 7);
|
||||
assertValues(stats, 5, TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
5L, 50L, 4L, 40L, 8);
|
||||
assertValues(stats, 6, TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
6L, 60L, 5L, 50L, 10);
|
||||
assertValues(stats, 7, TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_YES,
|
||||
7L, 70L, 5L, 50L, 11);
|
||||
assertValues(stats, 8, TEST_IFACE, TEST_UID, SET_DEFAULT, TAG_NONE, METERED_YES,
|
||||
ROAMING_YES, 7L, 70L, 5L, 50L, 11);
|
||||
}
|
||||
|
||||
public void testCombineExisting() throws Exception {
|
||||
final NetworkStats stats = new NetworkStats(TEST_START, 10);
|
||||
|
||||
stats.addValues(TEST_IFACE, 1001, SET_DEFAULT, TAG_NONE, 512L, 4L, 256L, 2L, 10);
|
||||
stats.addValues(TEST_IFACE, 1001, SET_DEFAULT, 0xff, 128L, 1L, 128L, 1L, 2);
|
||||
stats.combineValues(TEST_IFACE, 1001, SET_DEFAULT, TAG_NONE, -128L, -1L,
|
||||
-128L, -1L, -1);
|
||||
|
||||
assertValues(stats, 0, TEST_IFACE, 1001, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
384L, 3L, 128L, 1L, 9);
|
||||
assertValues(stats, 1, TEST_IFACE, 1001, SET_DEFAULT, 0xff, METERED_NO, ROAMING_NO, 128L,
|
||||
1L, 128L, 1L, 2);
|
||||
|
||||
// now try combining that should create row
|
||||
stats.combineValues(TEST_IFACE, 5005, SET_DEFAULT, TAG_NONE, 128L, 1L, 128L, 1L, 3);
|
||||
assertValues(stats, 2, TEST_IFACE, 5005, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
128L, 1L, 128L, 1L, 3);
|
||||
stats.combineValues(TEST_IFACE, 5005, SET_DEFAULT, TAG_NONE, 128L, 1L, 128L, 1L, 3);
|
||||
assertValues(stats, 2, TEST_IFACE, 5005, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
256L, 2L, 256L, 2L, 6);
|
||||
}
|
||||
|
||||
public void testSubtractIdenticalData() throws Exception {
|
||||
final NetworkStats before = new NetworkStats(TEST_START, 2)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, 1024L, 8L, 0L, 0L, 11)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, 0L, 0L, 1024L, 8L, 12);
|
||||
|
||||
final NetworkStats after = new NetworkStats(TEST_START, 2)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, 1024L, 8L, 0L, 0L, 11)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, 0L, 0L, 1024L, 8L, 12);
|
||||
|
||||
final NetworkStats result = after.subtract(before);
|
||||
|
||||
// identical data should result in zero delta
|
||||
assertValues(result, 0, TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 0L,
|
||||
0L, 0L, 0L, 0);
|
||||
assertValues(result, 1, TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 0L,
|
||||
0L, 0L, 0L, 0);
|
||||
}
|
||||
|
||||
public void testSubtractIdenticalRows() throws Exception {
|
||||
final NetworkStats before = new NetworkStats(TEST_START, 2)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, 1024L, 8L, 0L, 0L, 11)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, 0L, 0L, 1024L, 8L, 12);
|
||||
|
||||
final NetworkStats after = new NetworkStats(TEST_START, 2)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, 1025L, 9L, 2L, 1L, 15)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, 3L, 1L, 1028L, 9L, 20);
|
||||
|
||||
final NetworkStats result = after.subtract(before);
|
||||
|
||||
// expect delta between measurements
|
||||
assertValues(result, 0, TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 1L,
|
||||
1L, 2L, 1L, 4);
|
||||
assertValues(result, 1, TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 3L,
|
||||
1L, 4L, 1L, 8);
|
||||
}
|
||||
|
||||
public void testSubtractNewRows() throws Exception {
|
||||
final NetworkStats before = new NetworkStats(TEST_START, 2)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, 1024L, 8L, 0L, 0L, 11)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, 0L, 0L, 1024L, 8L, 12);
|
||||
|
||||
final NetworkStats after = new NetworkStats(TEST_START, 3)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, 1024L, 8L, 0L, 0L, 11)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, 0L, 0L, 1024L, 8L, 12)
|
||||
.addValues(TEST_IFACE, 102, SET_DEFAULT, TAG_NONE, 1024L, 8L, 1024L, 8L, 20);
|
||||
|
||||
final NetworkStats result = after.subtract(before);
|
||||
|
||||
// its okay to have new rows
|
||||
assertValues(result, 0, TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 0L,
|
||||
0L, 0L, 0L, 0);
|
||||
assertValues(result, 1, TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 0L,
|
||||
0L, 0L, 0L, 0);
|
||||
assertValues(result, 2, TEST_IFACE, 102, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
1024L, 8L, 1024L, 8L, 20);
|
||||
}
|
||||
|
||||
public void testSubtractMissingRows() throws Exception {
|
||||
final NetworkStats before = new NetworkStats(TEST_START, 2)
|
||||
.addValues(TEST_IFACE, UID_ALL, SET_DEFAULT, TAG_NONE, 1024L, 0L, 0L, 0L, 0)
|
||||
.addValues(TEST_IFACE2, UID_ALL, SET_DEFAULT, TAG_NONE, 2048L, 0L, 0L, 0L, 0);
|
||||
|
||||
final NetworkStats after = new NetworkStats(TEST_START, 1)
|
||||
.addValues(TEST_IFACE2, UID_ALL, SET_DEFAULT, TAG_NONE, 2049L, 2L, 3L, 4L, 0);
|
||||
|
||||
final NetworkStats result = after.subtract(before);
|
||||
|
||||
// should silently drop omitted rows
|
||||
assertEquals(1, result.size());
|
||||
assertValues(result, 0, TEST_IFACE2, UID_ALL, SET_DEFAULT, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 1L, 2L, 3L, 4L, 0);
|
||||
assertEquals(4L, result.getTotalBytes());
|
||||
}
|
||||
|
||||
public void testTotalBytes() throws Exception {
|
||||
final NetworkStats iface = new NetworkStats(TEST_START, 2)
|
||||
.addValues(TEST_IFACE, UID_ALL, SET_DEFAULT, TAG_NONE, 128L, 0L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE2, UID_ALL, SET_DEFAULT, TAG_NONE, 256L, 0L, 0L, 0L, 0L);
|
||||
assertEquals(384L, iface.getTotalBytes());
|
||||
|
||||
final NetworkStats uidSet = new NetworkStats(TEST_START, 3)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, 32L, 0L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, 32L, 0L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_FOREGROUND, TAG_NONE, 32L, 0L, 0L, 0L, 0L);
|
||||
assertEquals(96L, uidSet.getTotalBytes());
|
||||
|
||||
final NetworkStats uidTag = new NetworkStats(TEST_START, 6)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, 16L, 0L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE2, 100, SET_DEFAULT, TAG_NONE, 16L, 0L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE2, 100, SET_DEFAULT, 0xF00D, 8L, 0L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE2, 100, SET_FOREGROUND, TAG_NONE, 16L, 0L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, 16L, 0L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, 0xF00D, 8L, 0L, 0L, 0L, 0L);
|
||||
assertEquals(64L, uidTag.getTotalBytes());
|
||||
|
||||
final NetworkStats uidMetered = new NetworkStats(TEST_START, 3)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 32L, 0L,
|
||||
0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_YES, ROAMING_NO, 32L, 0L,
|
||||
0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_YES, ROAMING_NO, 32L, 0L,
|
||||
0L, 0L, 0L);
|
||||
assertEquals(96L, uidMetered.getTotalBytes());
|
||||
|
||||
final NetworkStats uidRoaming = new NetworkStats(TEST_START, 3)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 32L, 0L,
|
||||
0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_YES, ROAMING_NO, 32L, 0L,
|
||||
0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_YES, 32L, 0L,
|
||||
0L, 0L, 0L);
|
||||
assertEquals(96L, uidRoaming.getTotalBytes());
|
||||
}
|
||||
|
||||
public void testGroupedByIfaceEmpty() throws Exception {
|
||||
final NetworkStats uidStats = new NetworkStats(TEST_START, 3);
|
||||
final NetworkStats grouped = uidStats.groupedByIface();
|
||||
|
||||
assertEquals(0, uidStats.size());
|
||||
assertEquals(0, grouped.size());
|
||||
}
|
||||
|
||||
public void testGroupedByIfaceAll() throws Exception {
|
||||
final NetworkStats uidStats = new NetworkStats(TEST_START, 3)
|
||||
.addValues(IFACE_ALL, 100, SET_ALL, TAG_NONE, METERED_NO, ROAMING_NO, 128L, 8L, 0L,
|
||||
2L, 20L)
|
||||
.addValues(IFACE_ALL, 101, SET_FOREGROUND, TAG_NONE, METERED_YES, ROAMING_NO, 128L,
|
||||
8L, 0L, 2L, 20L)
|
||||
.addValues(IFACE_ALL, 101, SET_ALL, TAG_NONE, METERED_NO, ROAMING_YES, 128L, 8L, 0L,
|
||||
2L, 20L);
|
||||
final NetworkStats grouped = uidStats.groupedByIface();
|
||||
|
||||
assertEquals(3, uidStats.size());
|
||||
assertEquals(1, grouped.size());
|
||||
|
||||
assertValues(grouped, 0, IFACE_ALL, UID_ALL, SET_ALL, TAG_NONE, METERED_ALL, ROAMING_ALL,
|
||||
384L, 24L, 0L, 6L, 0L);
|
||||
}
|
||||
|
||||
public void testGroupedByIface() throws Exception {
|
||||
final NetworkStats uidStats = new NetworkStats(TEST_START, 7)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 128L, 8L,
|
||||
0L, 2L, 20L)
|
||||
.addValues(TEST_IFACE2, 100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 512L,
|
||||
32L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE2, 100, SET_DEFAULT, 0xF00D, METERED_NO, ROAMING_NO, 64L, 4L,
|
||||
0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE2, 100, SET_FOREGROUND, TAG_NONE, METERED_NO, ROAMING_NO, 512L,
|
||||
32L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 128L, 8L,
|
||||
0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, 0xF00D, METERED_YES, ROAMING_NO, 128L, 8L,
|
||||
0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_YES, 128L,
|
||||
8L, 0L, 0L, 0L);
|
||||
|
||||
final NetworkStats grouped = uidStats.groupedByIface();
|
||||
|
||||
assertEquals(7, uidStats.size());
|
||||
|
||||
assertEquals(2, grouped.size());
|
||||
assertValues(grouped, 0, TEST_IFACE, UID_ALL, SET_ALL, TAG_NONE, METERED_ALL, ROAMING_ALL,
|
||||
384L, 24L, 0L, 2L, 0L);
|
||||
assertValues(grouped, 1, TEST_IFACE2, UID_ALL, SET_ALL, TAG_NONE, METERED_ALL, ROAMING_ALL,
|
||||
1024L, 64L, 0L, 0L, 0L);
|
||||
}
|
||||
|
||||
public void testAddAllValues() {
|
||||
final NetworkStats first = new NetworkStats(TEST_START, 5)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_YES, ROAMING_NO, 32L, 0L,
|
||||
0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 100, SET_FOREGROUND, TAG_NONE, METERED_NO, ROAMING_NO, 32L,
|
||||
0L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 100, SET_FOREGROUND, TAG_NONE, METERED_YES, ROAMING_YES, 32L,
|
||||
0L, 0L, 0L, 0L);
|
||||
|
||||
final NetworkStats second = new NetworkStats(TEST_START, 2)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_YES, ROAMING_NO, 32L, 0L,
|
||||
0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE2, UID_ALL, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 32L,
|
||||
0L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 100, SET_FOREGROUND, TAG_NONE, METERED_YES, ROAMING_YES, 32L,
|
||||
0L, 0L, 0L, 0L);
|
||||
|
||||
first.combineAllValues(second);
|
||||
|
||||
assertEquals(4, first.size());
|
||||
assertValues(first, 0, TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_YES, ROAMING_NO, 64L,
|
||||
0L, 0L, 0L, 0L);
|
||||
assertValues(first, 1, TEST_IFACE, 100, SET_FOREGROUND, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
32L, 0L, 0L, 0L, 0L);
|
||||
assertValues(first, 2, TEST_IFACE, 100, SET_FOREGROUND, TAG_NONE, METERED_YES, ROAMING_YES,
|
||||
64L, 0L, 0L, 0L, 0L);
|
||||
assertValues(first, 3, TEST_IFACE2, UID_ALL, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
32L, 0L, 0L, 0L, 0L);
|
||||
}
|
||||
|
||||
public void testGetTotal() {
|
||||
final NetworkStats stats = new NetworkStats(TEST_START, 7)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 128L, 8L,
|
||||
0L, 2L, 20L)
|
||||
.addValues(TEST_IFACE2, 100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 512L,
|
||||
32L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE2, 100, SET_DEFAULT, 0xF00D, METERED_NO, ROAMING_NO, 64L, 4L,
|
||||
0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE2, 100, SET_FOREGROUND, TAG_NONE, METERED_NO, ROAMING_NO, 512L,
|
||||
32L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_YES, ROAMING_NO, 128L,
|
||||
8L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, 0xF00D, METERED_NO, ROAMING_NO, 128L, 8L,
|
||||
0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_YES, 128L,
|
||||
8L, 0L, 0L, 0L);
|
||||
|
||||
assertValues(stats.getTotal(null), 1408L, 88L, 0L, 2L, 20L);
|
||||
assertValues(stats.getTotal(null, 100), 1280L, 80L, 0L, 2L, 20L);
|
||||
assertValues(stats.getTotal(null, 101), 128L, 8L, 0L, 0L, 0L);
|
||||
|
||||
final HashSet<String> ifaces = Sets.newHashSet();
|
||||
assertValues(stats.getTotal(null, ifaces), 0L, 0L, 0L, 0L, 0L);
|
||||
|
||||
ifaces.add(TEST_IFACE2);
|
||||
assertValues(stats.getTotal(null, ifaces), 1024L, 64L, 0L, 0L, 0L);
|
||||
}
|
||||
|
||||
public void testWithoutUid() throws Exception {
|
||||
final NetworkStats before = new NetworkStats(TEST_START, 3)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, 128L, 8L, 0L, 2L, 20L)
|
||||
.addValues(TEST_IFACE2, 100, SET_DEFAULT, TAG_NONE, 512L, 32L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE2, 100, SET_DEFAULT, 0xF00D, 64L, 4L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE2, 100, SET_FOREGROUND, TAG_NONE, 512L, 32L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, 128L, 8L, 0L, 0L, 0L)
|
||||
.addValues(TEST_IFACE, 101, SET_DEFAULT, 0xF00D, 128L, 8L, 0L, 0L, 0L);
|
||||
|
||||
final NetworkStats after = before.withoutUids(new int[] { 100 });
|
||||
assertEquals(6, before.size());
|
||||
assertEquals(2, after.size());
|
||||
assertValues(after, 0, TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
128L, 8L, 0L, 0L, 0L);
|
||||
assertValues(after, 1, TEST_IFACE, 101, SET_DEFAULT, 0xF00D, METERED_NO, ROAMING_NO, 128L,
|
||||
8L, 0L, 0L, 0L);
|
||||
}
|
||||
|
||||
public void testClone() throws Exception {
|
||||
final NetworkStats original = new NetworkStats(TEST_START, 5)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, 128L, 8L, 0L, 2L, 20L)
|
||||
.addValues(TEST_IFACE2, 100, SET_DEFAULT, TAG_NONE, 512L, 32L, 0L, 0L, 0L);
|
||||
|
||||
// make clone and mutate original
|
||||
final NetworkStats clone = original.clone();
|
||||
original.addValues(TEST_IFACE, 101, SET_DEFAULT, TAG_NONE, 128L, 8L, 0L, 0L, 0L);
|
||||
|
||||
assertEquals(3, original.size());
|
||||
assertEquals(2, clone.size());
|
||||
|
||||
assertEquals(128L + 512L + 128L, original.getTotalBytes());
|
||||
assertEquals(128L + 512L, clone.getTotalBytes());
|
||||
}
|
||||
|
||||
public void testAddWhenEmpty() throws Exception {
|
||||
final NetworkStats red = new NetworkStats(TEST_START, -1);
|
||||
final NetworkStats blue = new NetworkStats(TEST_START, 5)
|
||||
.addValues(TEST_IFACE, 100, SET_DEFAULT, TAG_NONE, 128L, 8L, 0L, 2L, 20L)
|
||||
.addValues(TEST_IFACE2, 100, SET_DEFAULT, TAG_NONE, 512L, 32L, 0L, 0L, 0L);
|
||||
|
||||
// We're mostly checking that we don't crash
|
||||
red.combineAllValues(blue);
|
||||
}
|
||||
|
||||
public void testMigrateTun() throws Exception {
|
||||
final int tunUid = 10030;
|
||||
final String tunIface = "tun0";
|
||||
final String underlyingIface = "wlan0";
|
||||
final int testTag1 = 8888;
|
||||
NetworkStats delta = new NetworkStats(TEST_START, 17)
|
||||
.addValues(tunIface, 10100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 39605L, 46L,
|
||||
12259L, 55L, 0L)
|
||||
.addValues(tunIface, 10100, SET_FOREGROUND, TAG_NONE, METERED_NO, ROAMING_NO, 0L, 0L,
|
||||
0L, 0L, 0L)
|
||||
.addValues(tunIface, 10120, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 72667L, 197L,
|
||||
43909L, 241L, 0L)
|
||||
.addValues(tunIface, 10120, SET_FOREGROUND, TAG_NONE, METERED_NO, ROAMING_NO, 9297L,
|
||||
17L, 4128L, 21L, 0L)
|
||||
// VPN package also uses some traffic through unprotected network.
|
||||
.addValues(tunIface, tunUid, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 4983L, 10L,
|
||||
1801L, 12L, 0L)
|
||||
.addValues(tunIface, tunUid, SET_FOREGROUND, TAG_NONE, METERED_NO, ROAMING_NO, 0L, 0L,
|
||||
0L, 0L, 0L)
|
||||
// Tag entries
|
||||
.addValues(tunIface, 10120, SET_DEFAULT, testTag1, METERED_NO, ROAMING_NO, 21691L, 41L,
|
||||
13820L, 51L, 0L)
|
||||
.addValues(tunIface, 10120, SET_FOREGROUND, testTag1, METERED_NO, ROAMING_NO, 1281L, 2L,
|
||||
665L, 2L, 0L)
|
||||
// Irrelevant entries
|
||||
.addValues(TEST_IFACE, 10100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 1685L, 5L,
|
||||
2070L, 6L, 0L)
|
||||
// Underlying Iface entries
|
||||
.addValues(underlyingIface, 10100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 5178L,
|
||||
8L, 2139L, 11L, 0L)
|
||||
.addValues(underlyingIface, 10100, SET_FOREGROUND, TAG_NONE, METERED_NO, ROAMING_NO, 0L,
|
||||
0L, 0L, 0L, 0L)
|
||||
.addValues(underlyingIface, tunUid, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
149873L, 287L, 59217L /* smaller than sum(tun0) */,
|
||||
299L /* smaller than sum(tun0) */, 0L)
|
||||
.addValues(underlyingIface, tunUid, SET_FOREGROUND, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
0L, 0L, 0L, 0L, 0L);
|
||||
|
||||
assertTrue(delta.migrateTun(tunUid, tunIface, underlyingIface));
|
||||
assertEquals(20, delta.size());
|
||||
|
||||
// tunIface and TEST_IFACE entries are not changed.
|
||||
assertValues(delta, 0, tunIface, 10100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
39605L, 46L, 12259L, 55L, 0L);
|
||||
assertValues(delta, 1, tunIface, 10100, SET_FOREGROUND, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
0L, 0L, 0L, 0L, 0L);
|
||||
assertValues(delta, 2, tunIface, 10120, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
72667L, 197L, 43909L, 241L, 0L);
|
||||
assertValues(delta, 3, tunIface, 10120, SET_FOREGROUND, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
9297L, 17L, 4128L, 21L, 0L);
|
||||
assertValues(delta, 4, tunIface, tunUid, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
4983L, 10L, 1801L, 12L, 0L);
|
||||
assertValues(delta, 5, tunIface, tunUid, SET_FOREGROUND, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
0L, 0L, 0L, 0L, 0L);
|
||||
assertValues(delta, 6, tunIface, 10120, SET_DEFAULT, testTag1, METERED_NO, ROAMING_NO,
|
||||
21691L, 41L, 13820L, 51L, 0L);
|
||||
assertValues(delta, 7, tunIface, 10120, SET_FOREGROUND, testTag1, METERED_NO, ROAMING_NO,
|
||||
1281L, 2L, 665L, 2L, 0L);
|
||||
assertValues(delta, 8, TEST_IFACE, 10100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
1685L, 5L, 2070L, 6L, 0L);
|
||||
|
||||
// Existing underlying Iface entries are updated
|
||||
assertValues(delta, 9, underlyingIface, 10100, SET_DEFAULT, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 44783L, 54L, 14178L, 62L, 0L);
|
||||
assertValues(delta, 10, underlyingIface, 10100, SET_FOREGROUND, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 0L, 0L, 0L, 0L, 0L);
|
||||
|
||||
// VPN underlying Iface entries are updated
|
||||
assertValues(delta, 11, underlyingIface, tunUid, SET_DEFAULT, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 28304L, 27L, 1L, 2L, 0L);
|
||||
assertValues(delta, 12, underlyingIface, tunUid, SET_FOREGROUND, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 0L, 0L, 0L, 0L, 0L);
|
||||
|
||||
// New entries are added for new application's underlying Iface traffic
|
||||
assertContains(delta, underlyingIface, 10120, SET_DEFAULT, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 72667L, 197L, 43123L, 227L, 0L);
|
||||
assertContains(delta, underlyingIface, 10120, SET_FOREGROUND, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 9297L, 17L, 4054, 19L, 0L);
|
||||
assertContains(delta, underlyingIface, 10120, SET_DEFAULT, testTag1, METERED_NO,
|
||||
ROAMING_NO, 21691L, 41L, 13572L, 48L, 0L);
|
||||
assertContains(delta, underlyingIface, 10120, SET_FOREGROUND, testTag1, METERED_NO,
|
||||
ROAMING_NO, 1281L, 2L, 653L, 1L, 0L);
|
||||
|
||||
// New entries are added for debug purpose
|
||||
assertContains(delta, underlyingIface, 10100, SET_DBG_VPN_IN, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 39605L, 46L, 12039, 51, 0);
|
||||
assertContains(delta, underlyingIface, 10120, SET_DBG_VPN_IN, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 81964, 214, 47177, 246, 0);
|
||||
assertContains(delta, underlyingIface, tunUid, SET_DBG_VPN_OUT, TAG_NONE, METERED_ALL,
|
||||
ROAMING_ALL, 121569, 260, 59216, 297, 0);
|
||||
|
||||
}
|
||||
|
||||
// Tests a case where all of the data received by the tun0 interface is echo back into the tun0
|
||||
// interface by the vpn app before it's sent out of the underlying interface. The VPN app should
|
||||
// not be charged for the echoed data but it should still be charged for any extra data it sends
|
||||
// via the underlying interface.
|
||||
public void testMigrateTun_VpnAsLoopback() {
|
||||
final int tunUid = 10030;
|
||||
final String tunIface = "tun0";
|
||||
final String underlyingIface = "wlan0";
|
||||
NetworkStats delta = new NetworkStats(TEST_START, 9)
|
||||
// 2 different apps sent/receive data via tun0.
|
||||
.addValues(tunIface, 10100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 50000L, 25L,
|
||||
100000L, 50L, 0L)
|
||||
.addValues(tunIface, 20100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 500L, 2L,
|
||||
200L, 5L, 0L)
|
||||
// VPN package resends data through the tunnel (with exaggerated overhead)
|
||||
.addValues(tunIface, tunUid, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 240000,
|
||||
100L, 120000L, 60L, 0L)
|
||||
// 1 app already has some traffic on the underlying interface, the other doesn't yet
|
||||
.addValues(underlyingIface, 10100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO, 1000L,
|
||||
10L, 2000L, 20L, 0L)
|
||||
// Traffic through the underlying interface via the vpn app.
|
||||
// This test should redistribute this data correctly.
|
||||
.addValues(underlyingIface, tunUid, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
75500L, 37L, 130000L, 70L, 0L);
|
||||
|
||||
assertTrue(delta.migrateTun(tunUid, tunIface, underlyingIface));
|
||||
assertEquals(9, delta.size());
|
||||
|
||||
// tunIface entries should not be changed.
|
||||
assertValues(delta, 0, tunIface, 10100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
50000L, 25L, 100000L, 50L, 0L);
|
||||
assertValues(delta, 1, tunIface, 20100, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
500L, 2L, 200L, 5L, 0L);
|
||||
assertValues(delta, 2, tunIface, tunUid, SET_DEFAULT, TAG_NONE, METERED_NO, ROAMING_NO,
|
||||
240000L, 100L, 120000L, 60L, 0L);
|
||||
|
||||
// Existing underlying Iface entries are updated
|
||||
assertValues(delta, 3, underlyingIface, 10100, SET_DEFAULT, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 51000L, 35L, 102000L, 70L, 0L);
|
||||
|
||||
// VPN underlying Iface entries are updated
|
||||
assertValues(delta, 4, underlyingIface, tunUid, SET_DEFAULT, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 25000L, 10L, 29800L, 15L, 0L);
|
||||
|
||||
// New entries are added for new application's underlying Iface traffic
|
||||
assertContains(delta, underlyingIface, 20100, SET_DEFAULT, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 500L, 2L, 200L, 5L, 0L);
|
||||
|
||||
// New entries are added for debug purpose
|
||||
assertContains(delta, underlyingIface, 10100, SET_DBG_VPN_IN, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 50000L, 25L, 100000L, 50L, 0L);
|
||||
assertContains(delta, underlyingIface, 20100, SET_DBG_VPN_IN, TAG_NONE, METERED_NO,
|
||||
ROAMING_NO, 500, 2L, 200L, 5L, 0L);
|
||||
assertContains(delta, underlyingIface, tunUid, SET_DBG_VPN_OUT, TAG_NONE, METERED_ALL,
|
||||
ROAMING_ALL, 50500L, 27L, 100200L, 55, 0);
|
||||
}
|
||||
|
||||
private static void assertContains(NetworkStats stats, String iface, int uid, int set,
|
||||
int tag, int metered, int roaming, long rxBytes, long rxPackets, long txBytes,
|
||||
long txPackets, long operations) {
|
||||
int index = stats.findIndex(iface, uid, set, tag, metered, roaming);
|
||||
assertTrue(index != -1);
|
||||
assertValues(stats, index, iface, uid, set, tag, metered, roaming,
|
||||
rxBytes, rxPackets, txBytes, txPackets, operations);
|
||||
}
|
||||
|
||||
private static void assertValues(NetworkStats stats, int index, String iface, int uid, int set,
|
||||
int tag, int metered, int roaming, long rxBytes, long rxPackets, long txBytes,
|
||||
long txPackets, long operations) {
|
||||
final NetworkStats.Entry entry = stats.getValues(index, null);
|
||||
assertValues(entry, iface, uid, set, tag, metered, roaming);
|
||||
assertValues(entry, rxBytes, rxPackets, txBytes, txPackets, operations);
|
||||
}
|
||||
|
||||
private static void assertValues(
|
||||
NetworkStats.Entry entry, String iface, int uid, int set, int tag, int metered,
|
||||
int roaming) {
|
||||
assertEquals(iface, entry.iface);
|
||||
assertEquals(uid, entry.uid);
|
||||
assertEquals(set, entry.set);
|
||||
assertEquals(tag, entry.tag);
|
||||
assertEquals(metered, entry.metered);
|
||||
assertEquals(roaming, entry.roaming);
|
||||
}
|
||||
|
||||
private static void assertValues(NetworkStats.Entry entry, long rxBytes, long rxPackets,
|
||||
long txBytes, long txPackets, long operations) {
|
||||
assertEquals(rxBytes, entry.rxBytes);
|
||||
assertEquals(rxPackets, entry.rxPackets);
|
||||
assertEquals(txBytes, entry.txBytes);
|
||||
assertEquals(txPackets, entry.txPackets);
|
||||
assertEquals(operations, entry.operations);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,180 @@
|
||||
/*
|
||||
* Copyright (C) 2011 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package com.android.internal.net;
|
||||
|
||||
import static android.net.NetworkStats.METERED_NO;
|
||||
import static android.net.NetworkStats.ROAMING_NO;
|
||||
import static android.net.NetworkStats.SET_ALL;
|
||||
import static android.net.NetworkStats.SET_DEFAULT;
|
||||
import static android.net.NetworkStats.SET_FOREGROUND;
|
||||
import static android.net.NetworkStats.TAG_NONE;
|
||||
import static android.net.NetworkStats.UID_ALL;
|
||||
import static com.android.server.NetworkManagementSocketTagger.kernelToTag;
|
||||
|
||||
import android.content.res.Resources;
|
||||
import android.net.NetworkStats;
|
||||
import android.net.TrafficStats;
|
||||
import android.test.AndroidTestCase;
|
||||
|
||||
import com.android.frameworks.tests.net.R;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.FileWriter;
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
|
||||
import libcore.io.IoUtils;
|
||||
import libcore.io.Streams;
|
||||
|
||||
/**
|
||||
* Tests for {@link NetworkStatsFactory}.
|
||||
*/
|
||||
public class NetworkStatsFactoryTest extends AndroidTestCase {
|
||||
private File mTestProc;
|
||||
private NetworkStatsFactory mFactory;
|
||||
|
||||
@Override
|
||||
public void setUp() throws Exception {
|
||||
super.setUp();
|
||||
|
||||
mTestProc = new File(getContext().getFilesDir(), "proc");
|
||||
if (mTestProc.exists()) {
|
||||
IoUtils.deleteContents(mTestProc);
|
||||
}
|
||||
|
||||
mFactory = new NetworkStatsFactory(mTestProc);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void tearDown() throws Exception {
|
||||
mFactory = null;
|
||||
|
||||
if (mTestProc.exists()) {
|
||||
IoUtils.deleteContents(mTestProc);
|
||||
}
|
||||
|
||||
super.tearDown();
|
||||
}
|
||||
|
||||
public void testNetworkStatsDetail() throws Exception {
|
||||
stageFile(R.raw.xt_qtaguid_typical, new File(mTestProc, "net/xt_qtaguid/stats"));
|
||||
|
||||
final NetworkStats stats = mFactory.readNetworkStatsDetail();
|
||||
assertEquals(70, stats.size());
|
||||
assertStatsEntry(stats, "wlan0", 0, SET_DEFAULT, 0x0, 18621L, 2898L);
|
||||
assertStatsEntry(stats, "wlan0", 10011, SET_DEFAULT, 0x0, 35777L, 5718L);
|
||||
assertStatsEntry(stats, "wlan0", 10021, SET_DEFAULT, 0x7fffff01, 562386L, 49228L);
|
||||
assertStatsEntry(stats, "rmnet1", 10021, SET_DEFAULT, 0x30100000, 219110L, 227423L);
|
||||
assertStatsEntry(stats, "rmnet2", 10001, SET_DEFAULT, 0x0, 1125899906842624L, 984L);
|
||||
}
|
||||
|
||||
public void testKernelTags() throws Exception {
|
||||
assertEquals(0, kernelToTag("0x0000000000000000"));
|
||||
assertEquals(0x32, kernelToTag("0x0000003200000000"));
|
||||
assertEquals(2147483647, kernelToTag("0x7fffffff00000000"));
|
||||
assertEquals(0, kernelToTag("0x0000000000000000"));
|
||||
assertEquals(2147483136, kernelToTag("0x7FFFFE0000000000"));
|
||||
|
||||
assertEquals(0, kernelToTag("0x0"));
|
||||
assertEquals(0, kernelToTag("0xf00d"));
|
||||
assertEquals(1, kernelToTag("0x100000000"));
|
||||
assertEquals(14438007, kernelToTag("0xdc4e7700000000"));
|
||||
assertEquals(TrafficStats.TAG_SYSTEM_DOWNLOAD, kernelToTag("0xffffff0100000000"));
|
||||
}
|
||||
|
||||
public void testNetworkStatsWithSet() throws Exception {
|
||||
stageFile(R.raw.xt_qtaguid_typical, new File(mTestProc, "net/xt_qtaguid/stats"));
|
||||
|
||||
final NetworkStats stats = mFactory.readNetworkStatsDetail();
|
||||
assertEquals(70, stats.size());
|
||||
assertStatsEntry(stats, "rmnet1", 10021, SET_DEFAULT, 0x30100000, 219110L, 578L, 227423L,
|
||||
676L);
|
||||
assertStatsEntry(stats, "rmnet1", 10021, SET_FOREGROUND, 0x30100000, 742L, 3L, 1265L, 3L);
|
||||
}
|
||||
|
||||
public void testNetworkStatsSingle() throws Exception {
|
||||
stageFile(R.raw.xt_qtaguid_iface_typical,
|
||||
new File(mTestProc, "net/xt_qtaguid/iface_stat_all"));
|
||||
|
||||
final NetworkStats stats = mFactory.readNetworkStatsSummaryDev();
|
||||
assertEquals(6, stats.size());
|
||||
assertStatsEntry(stats, "rmnet0", UID_ALL, SET_ALL, TAG_NONE, 2112L, 24L, 700L, 10L);
|
||||
assertStatsEntry(stats, "test1", UID_ALL, SET_ALL, TAG_NONE, 6L, 8L, 10L, 12L);
|
||||
assertStatsEntry(stats, "test2", UID_ALL, SET_ALL, TAG_NONE, 1L, 2L, 3L, 4L);
|
||||
}
|
||||
|
||||
public void testNetworkStatsXt() throws Exception {
|
||||
stageFile(R.raw.xt_qtaguid_iface_fmt_typical,
|
||||
new File(mTestProc, "net/xt_qtaguid/iface_stat_fmt"));
|
||||
|
||||
final NetworkStats stats = mFactory.readNetworkStatsSummaryXt();
|
||||
assertEquals(3, stats.size());
|
||||
assertStatsEntry(stats, "rmnet0", UID_ALL, SET_ALL, TAG_NONE, 6824L, 16L, 5692L, 10L);
|
||||
assertStatsEntry(stats, "rmnet1", UID_ALL, SET_ALL, TAG_NONE, 11153922L, 8051L, 190226L,
|
||||
2468L);
|
||||
assertStatsEntry(stats, "rmnet2", UID_ALL, SET_ALL, TAG_NONE, 4968L, 35L, 3081L, 39L);
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy a {@link Resources#openRawResource(int)} into {@link File} for
|
||||
* testing purposes.
|
||||
*/
|
||||
private void stageFile(int rawId, File file) throws Exception {
|
||||
new File(file.getParent()).mkdirs();
|
||||
InputStream in = null;
|
||||
OutputStream out = null;
|
||||
try {
|
||||
in = getContext().getResources().openRawResource(rawId);
|
||||
out = new FileOutputStream(file);
|
||||
Streams.copy(in, out);
|
||||
} finally {
|
||||
IoUtils.closeQuietly(in);
|
||||
IoUtils.closeQuietly(out);
|
||||
}
|
||||
}
|
||||
|
||||
private void stageLong(long value, File file) throws Exception {
|
||||
new File(file.getParent()).mkdirs();
|
||||
FileWriter out = null;
|
||||
try {
|
||||
out = new FileWriter(file);
|
||||
out.write(Long.toString(value));
|
||||
} finally {
|
||||
IoUtils.closeQuietly(out);
|
||||
}
|
||||
}
|
||||
|
||||
private static void assertStatsEntry(NetworkStats stats, String iface, int uid, int set,
|
||||
int tag, long rxBytes, long txBytes) {
|
||||
final int i = stats.findIndex(iface, uid, set, tag, METERED_NO, ROAMING_NO);
|
||||
final NetworkStats.Entry entry = stats.getValues(i, null);
|
||||
assertEquals("unexpected rxBytes", rxBytes, entry.rxBytes);
|
||||
assertEquals("unexpected txBytes", txBytes, entry.txBytes);
|
||||
}
|
||||
|
||||
private static void assertStatsEntry(NetworkStats stats, String iface, int uid, int set,
|
||||
int tag, long rxBytes, long rxPackets, long txBytes, long txPackets) {
|
||||
final int i = stats.findIndex(iface, uid, set, tag, METERED_NO, ROAMING_NO);
|
||||
final NetworkStats.Entry entry = stats.getValues(i, null);
|
||||
assertEquals("unexpected rxBytes", rxBytes, entry.rxBytes);
|
||||
assertEquals("unexpected rxPackets", rxPackets, entry.rxPackets);
|
||||
assertEquals("unexpected txBytes", txBytes, entry.txBytes);
|
||||
assertEquals("unexpected txPackets", txPackets, entry.txPackets);
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user