1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.net;
18
19import static android.net.NetworkStatsHistory.FIELD_ALL;
20import static android.net.NetworkStatsHistory.FIELD_OPERATIONS;
21import static android.net.NetworkStatsHistory.FIELD_RX_BYTES;
22import static android.net.NetworkStatsHistory.FIELD_RX_PACKETS;
23import static android.net.NetworkStatsHistory.FIELD_TX_BYTES;
24import static android.net.NetworkStatsHistory.DataStreamUtils.readVarLong;
25import static android.net.NetworkStatsHistory.DataStreamUtils.writeVarLong;
26import static android.net.NetworkStatsHistory.Entry.UNKNOWN;
27import static android.net.TrafficStats.GB_IN_BYTES;
28import static android.net.TrafficStats.MB_IN_BYTES;
29import static android.text.format.DateUtils.DAY_IN_MILLIS;
30import static android.text.format.DateUtils.HOUR_IN_MILLIS;
31import static android.text.format.DateUtils.MINUTE_IN_MILLIS;
32import static android.text.format.DateUtils.SECOND_IN_MILLIS;
33import static android.text.format.DateUtils.WEEK_IN_MILLIS;
34import static android.text.format.DateUtils.YEAR_IN_MILLIS;
35
36import android.test.AndroidTestCase;
37import android.test.suitebuilder.annotation.SmallTest;
38import android.test.suitebuilder.annotation.Suppress;
39import android.util.Log;
40
41import com.android.frameworks.coretests.R;
42
43import java.io.ByteArrayInputStream;
44import java.io.ByteArrayOutputStream;
45import java.io.DataInputStream;
46import java.io.DataOutputStream;
47import java.util.Random;
48
49@SmallTest
50public class NetworkStatsHistoryTest extends AndroidTestCase {
51    private static final String TAG = "NetworkStatsHistoryTest";
52
53    private static final long TEST_START = 1194220800000L;
54
55    private NetworkStatsHistory stats;
56
57    @Override
58    protected void tearDown() throws Exception {
59        super.tearDown();
60        if (stats != null) {
61            assertConsistent(stats);
62        }
63    }
64
65    public void testReadOriginalVersion() throws Exception {
66        final DataInputStream in = new DataInputStream(
67                getContext().getResources().openRawResource(R.raw.history_v1));
68
69        NetworkStatsHistory.Entry entry = null;
70        try {
71            final NetworkStatsHistory history = new NetworkStatsHistory(in);
72            assertEquals(15 * SECOND_IN_MILLIS, history.getBucketDuration());
73
74            entry = history.getValues(0, entry);
75            assertEquals(29143L, entry.rxBytes);
76            assertEquals(6223L, entry.txBytes);
77
78            entry = history.getValues(history.size() - 1, entry);
79            assertEquals(1476L, entry.rxBytes);
80            assertEquals(838L, entry.txBytes);
81
82            entry = history.getValues(Long.MIN_VALUE, Long.MAX_VALUE, entry);
83            assertEquals(332401L, entry.rxBytes);
84            assertEquals(64314L, entry.txBytes);
85
86        } finally {
87            in.close();
88        }
89    }
90
91    public void testRecordSingleBucket() throws Exception {
92        final long BUCKET_SIZE = HOUR_IN_MILLIS;
93        stats = new NetworkStatsHistory(BUCKET_SIZE);
94
95        // record data into narrow window to get single bucket
96        stats.recordData(TEST_START, TEST_START + SECOND_IN_MILLIS,
97                new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 2L));
98
99        assertEquals(1, stats.size());
100        assertValues(stats, 0, SECOND_IN_MILLIS, 1024L, 10L, 2048L, 20L, 2L);
101    }
102
103    public void testRecordEqualBuckets() throws Exception {
104        final long bucketDuration = HOUR_IN_MILLIS;
105        stats = new NetworkStatsHistory(bucketDuration);
106
107        // split equally across two buckets
108        final long recordStart = TEST_START + (bucketDuration / 2);
109        stats.recordData(recordStart, recordStart + bucketDuration,
110                new NetworkStats.Entry(1024L, 10L, 128L, 2L, 2L));
111
112        assertEquals(2, stats.size());
113        assertValues(stats, 0, HOUR_IN_MILLIS / 2, 512L, 5L, 64L, 1L, 1L);
114        assertValues(stats, 1, HOUR_IN_MILLIS / 2, 512L, 5L, 64L, 1L, 1L);
115    }
116
117    public void testRecordTouchingBuckets() throws Exception {
118        final long BUCKET_SIZE = 15 * MINUTE_IN_MILLIS;
119        stats = new NetworkStatsHistory(BUCKET_SIZE);
120
121        // split almost completely into middle bucket, but with a few minutes
122        // overlap into neighboring buckets. total record is 20 minutes.
123        final long recordStart = (TEST_START + BUCKET_SIZE) - MINUTE_IN_MILLIS;
124        final long recordEnd = (TEST_START + (BUCKET_SIZE * 2)) + (MINUTE_IN_MILLIS * 4);
125        stats.recordData(recordStart, recordEnd,
126                new NetworkStats.Entry(1000L, 2000L, 5000L, 10000L, 100L));
127
128        assertEquals(3, stats.size());
129        // first bucket should have (1/20 of value)
130        assertValues(stats, 0, MINUTE_IN_MILLIS, 50L, 100L, 250L, 500L, 5L);
131        // second bucket should have (15/20 of value)
132        assertValues(stats, 1, 15 * MINUTE_IN_MILLIS, 750L, 1500L, 3750L, 7500L, 75L);
133        // final bucket should have (4/20 of value)
134        assertValues(stats, 2, 4 * MINUTE_IN_MILLIS, 200L, 400L, 1000L, 2000L, 20L);
135    }
136
137    public void testRecordGapBuckets() throws Exception {
138        final long BUCKET_SIZE = HOUR_IN_MILLIS;
139        stats = new NetworkStatsHistory(BUCKET_SIZE);
140
141        // record some data today and next week with large gap
142        final long firstStart = TEST_START;
143        final long lastStart = TEST_START + WEEK_IN_MILLIS;
144        stats.recordData(firstStart, firstStart + SECOND_IN_MILLIS,
145                new NetworkStats.Entry(128L, 2L, 256L, 4L, 1L));
146        stats.recordData(lastStart, lastStart + SECOND_IN_MILLIS,
147                new NetworkStats.Entry(64L, 1L, 512L, 8L, 2L));
148
149        // we should have two buckets, far apart from each other
150        assertEquals(2, stats.size());
151        assertValues(stats, 0, SECOND_IN_MILLIS, 128L, 2L, 256L, 4L, 1L);
152        assertValues(stats, 1, SECOND_IN_MILLIS, 64L, 1L, 512L, 8L, 2L);
153
154        // now record something in middle, spread across two buckets
155        final long middleStart = TEST_START + DAY_IN_MILLIS;
156        final long middleEnd = middleStart + (HOUR_IN_MILLIS * 2);
157        stats.recordData(middleStart, middleEnd,
158                new NetworkStats.Entry(2048L, 4L, 2048L, 4L, 2L));
159
160        // now should have four buckets, with new record in middle two buckets
161        assertEquals(4, stats.size());
162        assertValues(stats, 0, SECOND_IN_MILLIS, 128L, 2L, 256L, 4L, 1L);
163        assertValues(stats, 1, HOUR_IN_MILLIS, 1024L, 2L, 1024L, 2L, 1L);
164        assertValues(stats, 2, HOUR_IN_MILLIS, 1024L, 2L, 1024L, 2L, 1L);
165        assertValues(stats, 3, SECOND_IN_MILLIS, 64L, 1L, 512L, 8L, 2L);
166    }
167
168    public void testRecordOverlapBuckets() throws Exception {
169        final long BUCKET_SIZE = HOUR_IN_MILLIS;
170        stats = new NetworkStatsHistory(BUCKET_SIZE);
171
172        // record some data in one bucket, and another overlapping buckets
173        stats.recordData(TEST_START, TEST_START + SECOND_IN_MILLIS,
174                new NetworkStats.Entry(256L, 2L, 256L, 2L, 1L));
175        final long midStart = TEST_START + (HOUR_IN_MILLIS / 2);
176        stats.recordData(midStart, midStart + HOUR_IN_MILLIS,
177                new NetworkStats.Entry(1024L, 10L, 1024L, 10L, 10L));
178
179        // should have two buckets, with some data mixed together
180        assertEquals(2, stats.size());
181        assertValues(stats, 0, SECOND_IN_MILLIS + (HOUR_IN_MILLIS / 2), 768L, 7L, 768L, 7L, 6L);
182        assertValues(stats, 1, (HOUR_IN_MILLIS / 2), 512L, 5L, 512L, 5L, 5L);
183    }
184
185    public void testRecordEntireGapIdentical() throws Exception {
186        // first, create two separate histories far apart
187        final NetworkStatsHistory stats1 = new NetworkStatsHistory(HOUR_IN_MILLIS);
188        stats1.recordData(TEST_START, TEST_START + 2 * HOUR_IN_MILLIS, 2000L, 1000L);
189
190        final long TEST_START_2 = TEST_START + DAY_IN_MILLIS;
191        final NetworkStatsHistory stats2 = new NetworkStatsHistory(HOUR_IN_MILLIS);
192        stats2.recordData(TEST_START_2, TEST_START_2 + 2 * HOUR_IN_MILLIS, 1000L, 500L);
193
194        // combine together with identical bucket size
195        stats = new NetworkStatsHistory(HOUR_IN_MILLIS);
196        stats.recordEntireHistory(stats1);
197        stats.recordEntireHistory(stats2);
198
199        // first verify that totals match up
200        assertValues(stats, TEST_START - WEEK_IN_MILLIS, TEST_START + WEEK_IN_MILLIS, 3000L, 1500L);
201
202        // now inspect internal buckets
203        assertValues(stats, 0, 1000L, 500L);
204        assertValues(stats, 1, 1000L, 500L);
205        assertValues(stats, 2, 500L, 250L);
206        assertValues(stats, 3, 500L, 250L);
207    }
208
209    public void testRecordEntireOverlapVaryingBuckets() throws Exception {
210        // create history just over hour bucket boundary
211        final NetworkStatsHistory stats1 = new NetworkStatsHistory(HOUR_IN_MILLIS);
212        stats1.recordData(TEST_START, TEST_START + MINUTE_IN_MILLIS * 60, 600L, 600L);
213
214        final long TEST_START_2 = TEST_START + MINUTE_IN_MILLIS;
215        final NetworkStatsHistory stats2 = new NetworkStatsHistory(MINUTE_IN_MILLIS);
216        stats2.recordData(TEST_START_2, TEST_START_2 + MINUTE_IN_MILLIS * 5, 50L, 50L);
217
218        // combine together with minute bucket size
219        stats = new NetworkStatsHistory(MINUTE_IN_MILLIS);
220        stats.recordEntireHistory(stats1);
221        stats.recordEntireHistory(stats2);
222
223        // first verify that totals match up
224        assertValues(stats, TEST_START - WEEK_IN_MILLIS, TEST_START + WEEK_IN_MILLIS, 650L, 650L);
225
226        // now inspect internal buckets
227        assertValues(stats, 0, 10L, 10L);
228        assertValues(stats, 1, 20L, 20L);
229        assertValues(stats, 2, 20L, 20L);
230        assertValues(stats, 3, 20L, 20L);
231        assertValues(stats, 4, 20L, 20L);
232        assertValues(stats, 5, 20L, 20L);
233        assertValues(stats, 6, 10L, 10L);
234
235        // now combine using 15min buckets
236        stats = new NetworkStatsHistory(HOUR_IN_MILLIS / 4);
237        stats.recordEntireHistory(stats1);
238        stats.recordEntireHistory(stats2);
239
240        // first verify that totals match up
241        assertValues(stats, TEST_START - WEEK_IN_MILLIS, TEST_START + WEEK_IN_MILLIS, 650L, 650L);
242
243        // and inspect buckets
244        assertValues(stats, 0, 200L, 200L);
245        assertValues(stats, 1, 150L, 150L);
246        assertValues(stats, 2, 150L, 150L);
247        assertValues(stats, 3, 150L, 150L);
248    }
249
250    public void testRemove() throws Exception {
251        stats = new NetworkStatsHistory(HOUR_IN_MILLIS);
252
253        // record some data across 24 buckets
254        stats.recordData(TEST_START, TEST_START + DAY_IN_MILLIS, 24L, 24L);
255        assertEquals(24, stats.size());
256
257        // try removing invalid data; should be no change
258        stats.removeBucketsBefore(0 - DAY_IN_MILLIS);
259        assertEquals(24, stats.size());
260
261        // try removing far before buckets; should be no change
262        stats.removeBucketsBefore(TEST_START - YEAR_IN_MILLIS);
263        assertEquals(24, stats.size());
264
265        // try removing just moments into first bucket; should be no change
266        // since that bucket contains data beyond the cutoff
267        stats.removeBucketsBefore(TEST_START + SECOND_IN_MILLIS);
268        assertEquals(24, stats.size());
269
270        // try removing single bucket
271        stats.removeBucketsBefore(TEST_START + HOUR_IN_MILLIS);
272        assertEquals(23, stats.size());
273
274        // try removing multiple buckets
275        stats.removeBucketsBefore(TEST_START + (4 * HOUR_IN_MILLIS));
276        assertEquals(20, stats.size());
277
278        // try removing all buckets
279        stats.removeBucketsBefore(TEST_START + YEAR_IN_MILLIS);
280        assertEquals(0, stats.size());
281    }
282
283    public void testTotalData() throws Exception {
284        final long BUCKET_SIZE = HOUR_IN_MILLIS;
285        stats = new NetworkStatsHistory(BUCKET_SIZE);
286
287        // record uniform data across day
288        stats.recordData(TEST_START, TEST_START + DAY_IN_MILLIS, 2400L, 4800L);
289
290        // verify that total outside range is 0
291        assertValues(stats, TEST_START - WEEK_IN_MILLIS, TEST_START - DAY_IN_MILLIS, 0L, 0L);
292
293        // verify total in first hour
294        assertValues(stats, TEST_START, TEST_START + HOUR_IN_MILLIS, 100L, 200L);
295
296        // verify total across 1.5 hours
297        assertValues(stats, TEST_START, TEST_START + (long) (1.5 * HOUR_IN_MILLIS), 150L, 300L);
298
299        // verify total beyond end
300        assertValues(stats, TEST_START + (23 * HOUR_IN_MILLIS), TEST_START + WEEK_IN_MILLIS, 100L, 200L);
301
302        // verify everything total
303        assertValues(stats, TEST_START - WEEK_IN_MILLIS, TEST_START + WEEK_IN_MILLIS, 2400L, 4800L);
304
305    }
306
307    @Suppress
308    public void testFuzzing() throws Exception {
309        try {
310            // fuzzing with random events, looking for crashes
311            final NetworkStats.Entry entry = new NetworkStats.Entry();
312            final Random r = new Random();
313            for (int i = 0; i < 500; i++) {
314                stats = new NetworkStatsHistory(r.nextLong());
315                for (int j = 0; j < 10000; j++) {
316                    if (r.nextBoolean()) {
317                        // add range
318                        final long start = r.nextLong();
319                        final long end = start + r.nextInt();
320                        entry.rxBytes = nextPositiveLong(r);
321                        entry.rxPackets = nextPositiveLong(r);
322                        entry.txBytes = nextPositiveLong(r);
323                        entry.txPackets = nextPositiveLong(r);
324                        entry.operations = nextPositiveLong(r);
325                        stats.recordData(start, end, entry);
326                    } else {
327                        // trim something
328                        stats.removeBucketsBefore(r.nextLong());
329                    }
330                }
331                assertConsistent(stats);
332            }
333        } catch (Throwable e) {
334            Log.e(TAG, String.valueOf(stats));
335            throw new RuntimeException(e);
336        }
337    }
338
339    private static long nextPositiveLong(Random r) {
340        final long value = r.nextLong();
341        return value < 0 ? -value : value;
342    }
343
344    public void testIgnoreFields() throws Exception {
345        final NetworkStatsHistory history = new NetworkStatsHistory(
346                MINUTE_IN_MILLIS, 0, FIELD_RX_BYTES | FIELD_TX_BYTES);
347
348        history.recordData(0, MINUTE_IN_MILLIS,
349                new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 4L));
350        history.recordData(0, 2 * MINUTE_IN_MILLIS,
351                new NetworkStats.Entry(2L, 2L, 2L, 2L, 2L));
352
353        assertFullValues(history, UNKNOWN, 1026L, UNKNOWN, 2050L, UNKNOWN, UNKNOWN);
354    }
355
356    public void testIgnoreFieldsRecordIn() throws Exception {
357        final NetworkStatsHistory full = new NetworkStatsHistory(MINUTE_IN_MILLIS, 0, FIELD_ALL);
358        final NetworkStatsHistory partial = new NetworkStatsHistory(
359                MINUTE_IN_MILLIS, 0, FIELD_RX_PACKETS | FIELD_OPERATIONS);
360
361        full.recordData(0, MINUTE_IN_MILLIS,
362                new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 4L));
363        partial.recordEntireHistory(full);
364
365        assertFullValues(partial, UNKNOWN, UNKNOWN, 10L, UNKNOWN, UNKNOWN, 4L);
366    }
367
368    public void testIgnoreFieldsRecordOut() throws Exception {
369        final NetworkStatsHistory full = new NetworkStatsHistory(MINUTE_IN_MILLIS, 0, FIELD_ALL);
370        final NetworkStatsHistory partial = new NetworkStatsHistory(
371                MINUTE_IN_MILLIS, 0, FIELD_RX_PACKETS | FIELD_OPERATIONS);
372
373        partial.recordData(0, MINUTE_IN_MILLIS,
374                new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 4L));
375        full.recordEntireHistory(partial);
376
377        assertFullValues(full, MINUTE_IN_MILLIS, 0L, 10L, 0L, 0L, 4L);
378    }
379
380    public void testSerialize() throws Exception {
381        final NetworkStatsHistory before = new NetworkStatsHistory(MINUTE_IN_MILLIS, 40, FIELD_ALL);
382        before.recordData(0, 4 * MINUTE_IN_MILLIS,
383                new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 4L));
384        before.recordData(DAY_IN_MILLIS, DAY_IN_MILLIS + MINUTE_IN_MILLIS,
385                new NetworkStats.Entry(10L, 20L, 30L, 40L, 50L));
386
387        final ByteArrayOutputStream out = new ByteArrayOutputStream();
388        before.writeToStream(new DataOutputStream(out));
389        out.close();
390
391        final ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
392        final NetworkStatsHistory after = new NetworkStatsHistory(new DataInputStream(in));
393
394        // must have identical totals before and after
395        assertFullValues(before, 5 * MINUTE_IN_MILLIS, 1034L, 30L, 2078L, 60L, 54L);
396        assertFullValues(after, 5 * MINUTE_IN_MILLIS, 1034L, 30L, 2078L, 60L, 54L);
397    }
398
399    public void testVarLong() throws Exception {
400        assertEquals(0L, performVarLong(0L));
401        assertEquals(-1L, performVarLong(-1L));
402        assertEquals(1024L, performVarLong(1024L));
403        assertEquals(-1024L, performVarLong(-1024L));
404        assertEquals(40 * MB_IN_BYTES, performVarLong(40 * MB_IN_BYTES));
405        assertEquals(512 * GB_IN_BYTES, performVarLong(512 * GB_IN_BYTES));
406        assertEquals(Long.MIN_VALUE, performVarLong(Long.MIN_VALUE));
407        assertEquals(Long.MAX_VALUE, performVarLong(Long.MAX_VALUE));
408        assertEquals(Long.MIN_VALUE + 40, performVarLong(Long.MIN_VALUE + 40));
409        assertEquals(Long.MAX_VALUE - 40, performVarLong(Long.MAX_VALUE - 40));
410    }
411
412    public void testIndexBeforeAfter() throws Exception {
413        final long BUCKET_SIZE = HOUR_IN_MILLIS;
414        stats = new NetworkStatsHistory(BUCKET_SIZE);
415
416        final long FIRST_START = TEST_START;
417        final long FIRST_END = FIRST_START + (2 * HOUR_IN_MILLIS);
418        final long SECOND_START = TEST_START + WEEK_IN_MILLIS;
419        final long SECOND_END = SECOND_START + HOUR_IN_MILLIS;
420        final long THIRD_START = TEST_START + (2 * WEEK_IN_MILLIS);
421        final long THIRD_END = THIRD_START + (2 * HOUR_IN_MILLIS);
422
423        stats.recordData(FIRST_START, FIRST_END,
424                new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 2L));
425        stats.recordData(SECOND_START, SECOND_END,
426                new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 2L));
427        stats.recordData(THIRD_START, THIRD_END,
428                new NetworkStats.Entry(1024L, 10L, 2048L, 20L, 2L));
429
430        // should have buckets: 2+1+2
431        assertEquals(5, stats.size());
432
433        assertIndexBeforeAfter(stats, 0, 0, Long.MIN_VALUE);
434        assertIndexBeforeAfter(stats, 0, 1, FIRST_START);
435        assertIndexBeforeAfter(stats, 0, 1, FIRST_START + MINUTE_IN_MILLIS);
436        assertIndexBeforeAfter(stats, 0, 2, FIRST_START + HOUR_IN_MILLIS);
437        assertIndexBeforeAfter(stats, 1, 2, FIRST_START + HOUR_IN_MILLIS + MINUTE_IN_MILLIS);
438        assertIndexBeforeAfter(stats, 1, 2, FIRST_END - MINUTE_IN_MILLIS);
439        assertIndexBeforeAfter(stats, 1, 2, FIRST_END);
440        assertIndexBeforeAfter(stats, 1, 2, FIRST_END + MINUTE_IN_MILLIS);
441        assertIndexBeforeAfter(stats, 1, 2, SECOND_START - MINUTE_IN_MILLIS);
442        assertIndexBeforeAfter(stats, 1, 3, SECOND_START);
443        assertIndexBeforeAfter(stats, 2, 3, SECOND_END);
444        assertIndexBeforeAfter(stats, 2, 3, SECOND_END + MINUTE_IN_MILLIS);
445        assertIndexBeforeAfter(stats, 2, 3, THIRD_START - MINUTE_IN_MILLIS);
446        assertIndexBeforeAfter(stats, 2, 4, THIRD_START);
447        assertIndexBeforeAfter(stats, 3, 4, THIRD_START + MINUTE_IN_MILLIS);
448        assertIndexBeforeAfter(stats, 3, 4, THIRD_START + HOUR_IN_MILLIS);
449        assertIndexBeforeAfter(stats, 4, 4, THIRD_END);
450        assertIndexBeforeAfter(stats, 4, 4, THIRD_END + MINUTE_IN_MILLIS);
451        assertIndexBeforeAfter(stats, 4, 4, Long.MAX_VALUE);
452    }
453
454    private static void assertIndexBeforeAfter(
455            NetworkStatsHistory stats, int before, int after, long time) {
456        assertEquals("unexpected before", before, stats.getIndexBefore(time));
457        assertEquals("unexpected after", after, stats.getIndexAfter(time));
458    }
459
460    private static long performVarLong(long before) throws Exception {
461        final ByteArrayOutputStream out = new ByteArrayOutputStream();
462        writeVarLong(new DataOutputStream(out), before);
463
464        final ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
465        return readVarLong(new DataInputStream(in));
466    }
467
468    private static void assertConsistent(NetworkStatsHistory stats) {
469        // verify timestamps are monotonic
470        long lastStart = Long.MIN_VALUE;
471        NetworkStatsHistory.Entry entry = null;
472        for (int i = 0; i < stats.size(); i++) {
473            entry = stats.getValues(i, entry);
474            assertTrue(lastStart < entry.bucketStart);
475            lastStart = entry.bucketStart;
476        }
477    }
478
479    private static void assertValues(
480            NetworkStatsHistory stats, int index, long rxBytes, long txBytes) {
481        final NetworkStatsHistory.Entry entry = stats.getValues(index, null);
482        assertEquals("unexpected rxBytes", rxBytes, entry.rxBytes);
483        assertEquals("unexpected txBytes", txBytes, entry.txBytes);
484    }
485
486    private static void assertValues(
487            NetworkStatsHistory stats, long start, long end, long rxBytes, long txBytes) {
488        final NetworkStatsHistory.Entry entry = stats.getValues(start, end, null);
489        assertEquals("unexpected rxBytes", rxBytes, entry.rxBytes);
490        assertEquals("unexpected txBytes", txBytes, entry.txBytes);
491    }
492
493    private static void assertValues(NetworkStatsHistory stats, int index, long activeTime,
494            long rxBytes, long rxPackets, long txBytes, long txPackets, long operations) {
495        final NetworkStatsHistory.Entry entry = stats.getValues(index, null);
496        assertEquals("unexpected activeTime", activeTime, entry.activeTime);
497        assertEquals("unexpected rxBytes", rxBytes, entry.rxBytes);
498        assertEquals("unexpected rxPackets", rxPackets, entry.rxPackets);
499        assertEquals("unexpected txBytes", txBytes, entry.txBytes);
500        assertEquals("unexpected txPackets", txPackets, entry.txPackets);
501        assertEquals("unexpected operations", operations, entry.operations);
502    }
503
504    private static void assertFullValues(NetworkStatsHistory stats, long activeTime, long rxBytes,
505            long rxPackets, long txBytes, long txPackets, long operations) {
506        assertValues(stats, Long.MIN_VALUE, Long.MAX_VALUE, activeTime, rxBytes, rxPackets, txBytes,
507                txPackets, operations);
508    }
509
510    private static void assertValues(NetworkStatsHistory stats, long start, long end,
511            long activeTime, long rxBytes, long rxPackets, long txBytes, long txPackets,
512            long operations) {
513        final NetworkStatsHistory.Entry entry = stats.getValues(start, end, null);
514        assertEquals("unexpected activeTime", activeTime, entry.activeTime);
515        assertEquals("unexpected rxBytes", rxBytes, entry.rxBytes);
516        assertEquals("unexpected rxPackets", rxPackets, entry.rxPackets);
517        assertEquals("unexpected txBytes", txBytes, entry.txBytes);
518        assertEquals("unexpected txPackets", txPackets, entry.txPackets);
519        assertEquals("unexpected operations", operations, entry.operations);
520    }
521}
522