1/*
2 * Copyright (C) 2009 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.os;
18
19import android.os.PerformanceCollector.PerformanceResultsWriter;
20import android.test.suitebuilder.annotation.MediumTest;
21import android.test.suitebuilder.annotation.SmallTest;
22
23import java.lang.reflect.Field;
24import java.util.ArrayList;
25import java.util.Random;
26
27import junit.framework.TestCase;
28
29public class PerformanceCollectorTest extends TestCase {
30
31    private PerformanceCollector mPerfCollector;
32
33    @Override
34    protected void setUp() throws Exception {
35        super.setUp();
36        mPerfCollector = new PerformanceCollector();
37    }
38
39    @Override
40    protected void tearDown() throws Exception {
41        super.tearDown();
42        mPerfCollector = null;
43    }
44
45    @SmallTest
46    public void testBeginSnapshotNoWriter() throws Exception {
47        mPerfCollector.beginSnapshot("testBeginSnapshotNoWriter");
48
49        assertTrue((Long)readPrivateField("mSnapshotCpuTime", mPerfCollector) > 0);
50        assertTrue((Long)readPrivateField("mSnapshotExecTime", mPerfCollector) > 0);
51        Bundle snapshot = (Bundle)readPrivateField("mPerfSnapshot", mPerfCollector);
52        assertNotNull(snapshot);
53        assertEquals(2, snapshot.size());
54    }
55
56    @MediumTest
57    public void testEndSnapshotNoWriter() throws Exception {
58        mPerfCollector.beginSnapshot("testEndSnapshotNoWriter");
59        workForRandomLongPeriod();
60        Bundle snapshot = mPerfCollector.endSnapshot();
61
62        verifySnapshotBundle(snapshot);
63    }
64
65    @SmallTest
66    public void testStartTimingNoWriter() throws Exception {
67        mPerfCollector.startTiming("testStartTimingNoWriter");
68
69        assertTrue((Long)readPrivateField("mCpuTime", mPerfCollector) > 0);
70        assertTrue((Long)readPrivateField("mExecTime", mPerfCollector) > 0);
71        Bundle measurement = (Bundle)readPrivateField("mPerfMeasurement", mPerfCollector);
72        assertNotNull(measurement);
73        verifyTimingBundle(measurement, new ArrayList<String>());
74    }
75
76    @SmallTest
77    public void testAddIterationNoWriter() throws Exception {
78        mPerfCollector.startTiming("testAddIterationNoWriter");
79        workForRandomTinyPeriod();
80        Bundle iteration = mPerfCollector.addIteration("timing1");
81
82        verifyIterationBundle(iteration, "timing1");
83    }
84
85    @SmallTest
86    public void testStopTimingNoWriter() throws Exception {
87        mPerfCollector.startTiming("testStopTimingNoWriter");
88        workForRandomTinyPeriod();
89        mPerfCollector.addIteration("timing2");
90        workForRandomTinyPeriod();
91        mPerfCollector.addIteration("timing3");
92        workForRandomShortPeriod();
93        Bundle timing = mPerfCollector.stopTiming("timing4");
94
95        ArrayList<String> labels = new ArrayList<String>();
96        labels.add("timing2");
97        labels.add("timing3");
98        labels.add("timing4");
99        verifyTimingBundle(timing, labels);
100    }
101
102    @SmallTest
103    public void testBeginSnapshot() throws Exception {
104        MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter();
105        mPerfCollector.setPerformanceResultsWriter(writer);
106        mPerfCollector.beginSnapshot("testBeginSnapshot");
107
108        assertEquals("testBeginSnapshot", writer.snapshotLabel);
109        assertTrue((Long)readPrivateField("mSnapshotCpuTime", mPerfCollector) > 0);
110        assertTrue((Long)readPrivateField("mSnapshotExecTime", mPerfCollector) > 0);
111        Bundle snapshot = (Bundle)readPrivateField("mPerfSnapshot", mPerfCollector);
112        assertNotNull(snapshot);
113        assertEquals(2, snapshot.size());
114    }
115
116    @MediumTest
117    public void testEndSnapshot() throws Exception {
118        MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter();
119        mPerfCollector.setPerformanceResultsWriter(writer);
120        mPerfCollector.beginSnapshot("testEndSnapshot");
121        workForRandomLongPeriod();
122        Bundle snapshot1 = mPerfCollector.endSnapshot();
123        Bundle snapshot2 = writer.snapshotResults;
124
125        assertEqualsBundle(snapshot1, snapshot2);
126        verifySnapshotBundle(snapshot1);
127    }
128
129    @SmallTest
130    public void testStartTiming() throws Exception {
131        MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter();
132        mPerfCollector.setPerformanceResultsWriter(writer);
133        mPerfCollector.startTiming("testStartTiming");
134
135        assertEquals("testStartTiming", writer.timingLabel);
136        assertTrue((Long)readPrivateField("mCpuTime", mPerfCollector) > 0);
137        assertTrue((Long)readPrivateField("mExecTime", mPerfCollector) > 0);
138        Bundle measurement = (Bundle)readPrivateField("mPerfMeasurement", mPerfCollector);
139        assertNotNull(measurement);
140        verifyTimingBundle(measurement, new ArrayList<String>());
141    }
142
143    @SmallTest
144    public void testAddIteration() throws Exception {
145        mPerfCollector.startTiming("testAddIteration");
146        workForRandomTinyPeriod();
147        Bundle iteration = mPerfCollector.addIteration("timing5");
148
149        verifyIterationBundle(iteration, "timing5");
150    }
151
152    @SmallTest
153    public void testStopTiming() throws Exception {
154        mPerfCollector.startTiming("testStopTiming");
155        workForRandomTinyPeriod();
156        mPerfCollector.addIteration("timing6");
157        workForRandomTinyPeriod();
158        mPerfCollector.addIteration("timing7");
159        workForRandomShortPeriod();
160        Bundle timing = mPerfCollector.stopTiming("timing8");
161
162        ArrayList<String> labels = new ArrayList<String>();
163        labels.add("timing6");
164        labels.add("timing7");
165        labels.add("timing8");
166        verifyTimingBundle(timing, labels);
167    }
168
169    @SmallTest
170    public void testAddMeasurementLong() throws Exception {
171        MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter();
172        mPerfCollector.setPerformanceResultsWriter(writer);
173        mPerfCollector.startTiming("testAddMeasurementLong");
174        mPerfCollector.addMeasurement("testAddMeasurementLongZero", 0);
175        mPerfCollector.addMeasurement("testAddMeasurementLongPos", 348573);
176        mPerfCollector.addMeasurement("testAddMeasurementLongNeg", -19354);
177        mPerfCollector.stopTiming("");
178
179        assertEquals("testAddMeasurementLong", writer.timingLabel);
180        Bundle results = writer.timingResults;
181        assertEquals(4, results.size());
182        assertTrue(results.containsKey("testAddMeasurementLongZero"));
183        assertEquals(0, results.getLong("testAddMeasurementLongZero"));
184        assertTrue(results.containsKey("testAddMeasurementLongPos"));
185        assertEquals(348573, results.getLong("testAddMeasurementLongPos"));
186        assertTrue(results.containsKey("testAddMeasurementLongNeg"));
187        assertEquals(-19354, results.getLong("testAddMeasurementLongNeg"));
188    }
189
190    @SmallTest
191    public void testAddMeasurementFloat() throws Exception {
192        MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter();
193        mPerfCollector.setPerformanceResultsWriter(writer);
194        mPerfCollector.startTiming("testAddMeasurementFloat");
195        mPerfCollector.addMeasurement("testAddMeasurementFloatZero", 0.0f);
196        mPerfCollector.addMeasurement("testAddMeasurementFloatPos", 348573.345f);
197        mPerfCollector.addMeasurement("testAddMeasurementFloatNeg", -19354.093f);
198        mPerfCollector.stopTiming("");
199
200        assertEquals("testAddMeasurementFloat", writer.timingLabel);
201        Bundle results = writer.timingResults;
202        assertEquals(4, results.size());
203        assertTrue(results.containsKey("testAddMeasurementFloatZero"));
204        assertEquals(0.0f, results.getFloat("testAddMeasurementFloatZero"));
205        assertTrue(results.containsKey("testAddMeasurementFloatPos"));
206        assertEquals(348573.345f, results.getFloat("testAddMeasurementFloatPos"));
207        assertTrue(results.containsKey("testAddMeasurementFloatNeg"));
208        assertEquals(-19354.093f, results.getFloat("testAddMeasurementFloatNeg"));
209    }
210
211    @SmallTest
212    public void testAddMeasurementString() throws Exception {
213        MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter();
214        mPerfCollector.setPerformanceResultsWriter(writer);
215        mPerfCollector.startTiming("testAddMeasurementString");
216        mPerfCollector.addMeasurement("testAddMeasurementStringNull", null);
217        mPerfCollector.addMeasurement("testAddMeasurementStringEmpty", "");
218        mPerfCollector.addMeasurement("testAddMeasurementStringNonEmpty", "Hello World");
219        mPerfCollector.stopTiming("");
220
221        assertEquals("testAddMeasurementString", writer.timingLabel);
222        Bundle results = writer.timingResults;
223        assertEquals(4, results.size());
224        assertTrue(results.containsKey("testAddMeasurementStringNull"));
225        assertNull(results.getString("testAddMeasurementStringNull"));
226        assertTrue(results.containsKey("testAddMeasurementStringEmpty"));
227        assertEquals("", results.getString("testAddMeasurementStringEmpty"));
228        assertTrue(results.containsKey("testAddMeasurementStringNonEmpty"));
229        assertEquals("Hello World", results.getString("testAddMeasurementStringNonEmpty"));
230    }
231
232    @MediumTest
233    public void testSimpleSequence() throws Exception {
234        MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter();
235        mPerfCollector.setPerformanceResultsWriter(writer);
236        mPerfCollector.beginSnapshot("testSimpleSequence");
237        mPerfCollector.startTiming("testSimpleSequenceTiming");
238        workForRandomTinyPeriod();
239        mPerfCollector.addIteration("iteration1");
240        workForRandomTinyPeriod();
241        mPerfCollector.addIteration("iteration2");
242        workForRandomTinyPeriod();
243        mPerfCollector.addIteration("iteration3");
244        workForRandomTinyPeriod();
245        mPerfCollector.addIteration("iteration4");
246        workForRandomShortPeriod();
247        Bundle timing = mPerfCollector.stopTiming("iteration5");
248        workForRandomLongPeriod();
249        Bundle snapshot1 = mPerfCollector.endSnapshot();
250        Bundle snapshot2 = writer.snapshotResults;
251
252        assertEqualsBundle(snapshot1, snapshot2);
253        verifySnapshotBundle(snapshot1);
254
255        ArrayList<String> labels = new ArrayList<String>();
256        labels.add("iteration1");
257        labels.add("iteration2");
258        labels.add("iteration3");
259        labels.add("iteration4");
260        labels.add("iteration5");
261        verifyTimingBundle(timing, labels);
262    }
263
264    @MediumTest
265    public void testLongSequence() throws Exception {
266        MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter();
267        mPerfCollector.setPerformanceResultsWriter(writer);
268        mPerfCollector.beginSnapshot("testLongSequence");
269        mPerfCollector.startTiming("testLongSequenceTiming1");
270        workForRandomTinyPeriod();
271        mPerfCollector.addIteration("iteration1");
272        workForRandomTinyPeriod();
273        mPerfCollector.addIteration("iteration2");
274        workForRandomShortPeriod();
275        Bundle timing1 = mPerfCollector.stopTiming("iteration3");
276        workForRandomLongPeriod();
277
278        mPerfCollector.startTiming("testLongSequenceTiming2");
279        workForRandomTinyPeriod();
280        mPerfCollector.addIteration("iteration4");
281        workForRandomTinyPeriod();
282        mPerfCollector.addIteration("iteration5");
283        workForRandomShortPeriod();
284        Bundle timing2 = mPerfCollector.stopTiming("iteration6");
285        workForRandomLongPeriod();
286
287        mPerfCollector.startTiming("testLongSequenceTiming3");
288        workForRandomTinyPeriod();
289        mPerfCollector.addIteration("iteration7");
290        workForRandomTinyPeriod();
291        mPerfCollector.addIteration("iteration8");
292        workForRandomShortPeriod();
293        Bundle timing3 = mPerfCollector.stopTiming("iteration9");
294        workForRandomLongPeriod();
295
296        mPerfCollector.startTiming("testLongSequenceTiming4");
297        workForRandomTinyPeriod();
298        mPerfCollector.addIteration("iteration10");
299        workForRandomTinyPeriod();
300        mPerfCollector.addIteration("iteration11");
301        workForRandomShortPeriod();
302        Bundle timing4 = mPerfCollector.stopTiming("iteration12");
303        workForRandomLongPeriod();
304
305        mPerfCollector.startTiming("testLongSequenceTiming5");
306        workForRandomTinyPeriod();
307        mPerfCollector.addIteration("iteration13");
308        workForRandomTinyPeriod();
309        mPerfCollector.addIteration("iteration14");
310        workForRandomShortPeriod();
311        Bundle timing5 = mPerfCollector.stopTiming("iteration15");
312        workForRandomLongPeriod();
313        Bundle snapshot1 = mPerfCollector.endSnapshot();
314        Bundle snapshot2 = writer.snapshotResults;
315
316        assertEqualsBundle(snapshot1, snapshot2);
317        verifySnapshotBundle(snapshot1);
318
319        ArrayList<String> labels1 = new ArrayList<String>();
320        labels1.add("iteration1");
321        labels1.add("iteration2");
322        labels1.add("iteration3");
323        verifyTimingBundle(timing1, labels1);
324        ArrayList<String> labels2 = new ArrayList<String>();
325        labels2.add("iteration4");
326        labels2.add("iteration5");
327        labels2.add("iteration6");
328        verifyTimingBundle(timing2, labels2);
329        ArrayList<String> labels3 = new ArrayList<String>();
330        labels3.add("iteration7");
331        labels3.add("iteration8");
332        labels3.add("iteration9");
333        verifyTimingBundle(timing3, labels3);
334        ArrayList<String> labels4 = new ArrayList<String>();
335        labels4.add("iteration10");
336        labels4.add("iteration11");
337        labels4.add("iteration12");
338        verifyTimingBundle(timing4, labels4);
339        ArrayList<String> labels5 = new ArrayList<String>();
340        labels5.add("iteration13");
341        labels5.add("iteration14");
342        labels5.add("iteration15");
343        verifyTimingBundle(timing5, labels5);
344    }
345
346    /*
347     * Verify that snapshotting and timing do not interfere w/ each other,
348     * by staggering calls to snapshot and timing functions.
349     */
350    @MediumTest
351    public void testOutOfOrderSequence() {
352        MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter();
353        mPerfCollector.setPerformanceResultsWriter(writer);
354        mPerfCollector.startTiming("testOutOfOrderSequenceTiming");
355        workForRandomShortPeriod();
356        mPerfCollector.beginSnapshot("testOutOfOrderSequenceSnapshot");
357        workForRandomShortPeriod();
358        Bundle timing1 = mPerfCollector.stopTiming("timing1");
359        workForRandomShortPeriod();
360        Bundle snapshot1 = mPerfCollector.endSnapshot();
361
362        Bundle timing2 = writer.timingResults;
363        Bundle snapshot2 = writer.snapshotResults;
364
365        assertEqualsBundle(snapshot1, snapshot2);
366        verifySnapshotBundle(snapshot1);
367
368        assertEqualsBundle(timing1, timing2);
369        ArrayList<String> labels = new ArrayList<String>();
370        labels.add("timing1");
371        verifyTimingBundle(timing1, labels);
372    }
373
374    private void workForRandomPeriod(int minDuration, int maxDuration) {
375        Random random = new Random();
376        int period = minDuration + random.nextInt(maxDuration - minDuration);
377        long start = Process.getElapsedCpuTime();
378        // Generate positive amount of work, so cpu time is measurable in
379        // milliseconds
380        while (Process.getElapsedCpuTime() - start < period) {
381            for (int i = 0, temp = 0; i < 50; i++ ) {
382                temp += i;
383            }
384        }
385    }
386
387    private void workForRandomTinyPeriod() {
388        workForRandomPeriod(2, 5);
389    }
390
391    private void workForRandomShortPeriod() {
392        workForRandomPeriod(10, 25);
393    }
394
395    private void workForRandomLongPeriod() {
396        workForRandomPeriod(50, 100);
397    }
398
399    private void verifySnapshotBundle(Bundle snapshot) {
400        assertTrue("At least 26 metrics collected", 26 <= snapshot.size());
401
402        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_CPU_TIME));
403        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_CPU_TIME) > 0);
404        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_EXECUTION_TIME));
405        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_EXECUTION_TIME) > 0);
406
407        assertTrue(snapshot.containsKey(
408                PerformanceCollector.METRIC_KEY_PRE_RECEIVED_TRANSACTIONS));
409        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_PRE_SENT_TRANSACTIONS));
410        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_RECEIVED_TRANSACTIONS));
411        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_SENT_TRANSACTIONS));
412        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_GC_INVOCATION_COUNT));
413
414        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_JAVA_ALLOCATED));
415        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_JAVA_ALLOCATED) > 0);
416        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_JAVA_FREE));
417        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_JAVA_FREE) > 0);
418        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_JAVA_PRIVATE_DIRTY));
419        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_JAVA_PRIVATE_DIRTY) > 0);
420        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_JAVA_PSS));
421        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_JAVA_PSS) > 0);
422        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_JAVA_SHARED_DIRTY));
423        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_JAVA_SHARED_DIRTY) > 0);
424        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_JAVA_SIZE));
425        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_JAVA_SIZE) > 0);
426        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_NATIVE_ALLOCATED));
427        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_NATIVE_ALLOCATED) > 0);
428        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_NATIVE_FREE));
429        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_NATIVE_FREE) > 0);
430        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_NATIVE_PRIVATE_DIRTY));
431        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_NATIVE_PRIVATE_DIRTY) > 0);
432        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_NATIVE_PSS));
433        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_NATIVE_PSS) > 0);
434        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_NATIVE_SHARED_DIRTY));
435        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_NATIVE_SHARED_DIRTY) > 0);
436        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_NATIVE_SIZE));
437        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_NATIVE_SIZE) > 0);
438        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_GLOBAL_ALLOC_COUNT));
439        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_GLOBAL_ALLOC_COUNT) > 0);
440        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_GLOBAL_ALLOC_SIZE));
441        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_GLOBAL_ALLOC_SIZE) > 0);
442        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_GLOBAL_FREED_COUNT));
443        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_GLOBAL_FREED_COUNT) > 0);
444        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_GLOBAL_FREED_SIZE));
445        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_GLOBAL_FREED_SIZE) > 0);
446        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_OTHER_PRIVATE_DIRTY));
447        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_OTHER_PRIVATE_DIRTY) > 0);
448        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_OTHER_PSS));
449        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_OTHER_PSS) > 0);
450        assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_OTHER_SHARED_DIRTY));
451        assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_OTHER_SHARED_DIRTY) > 0);
452    }
453
454    private void verifyIterationBundle(Bundle iteration, String label) {
455        assertEquals(3, iteration.size());
456        assertTrue(iteration.containsKey(PerformanceCollector.METRIC_KEY_LABEL));
457        assertEquals(label, iteration.getString(PerformanceCollector.METRIC_KEY_LABEL));
458        assertTrue(iteration.containsKey(PerformanceCollector.METRIC_KEY_CPU_TIME));
459        assertTrue(iteration.getLong(PerformanceCollector.METRIC_KEY_CPU_TIME) > 0);
460        assertTrue(iteration.containsKey(PerformanceCollector.METRIC_KEY_EXECUTION_TIME));
461        assertTrue(iteration.getLong(PerformanceCollector.METRIC_KEY_EXECUTION_TIME) > 0);
462    }
463
464    private void verifyTimingBundle(Bundle timing, ArrayList<String> labels) {
465        assertEquals(1, timing.size());
466        assertTrue(timing.containsKey(PerformanceCollector.METRIC_KEY_ITERATIONS));
467        ArrayList<Parcelable> iterations = timing.getParcelableArrayList(
468                PerformanceCollector.METRIC_KEY_ITERATIONS);
469        assertNotNull(iterations);
470        assertEquals(labels.size(), iterations.size());
471        for (int i = 0; i < labels.size(); i ++) {
472            Bundle iteration = (Bundle)iterations.get(i);
473            verifyIterationBundle(iteration, labels.get(i));
474        }
475    }
476
477    private void assertEqualsBundle(Bundle b1, Bundle b2) {
478        assertEquals(b1.keySet(), b2.keySet());
479        for (String key : b1.keySet()) {
480            assertEquals(b1.get(key), b2.get(key));
481        }
482    }
483
484    private Object readPrivateField(String fieldName, Object object) throws Exception {
485        Field f = object.getClass().getDeclaredField(fieldName);
486        f.setAccessible(true);
487        return f.get(object);
488    }
489
490    private class MockPerformanceResultsWriter implements PerformanceResultsWriter {
491
492        public String snapshotLabel;
493        public Bundle snapshotResults = new Bundle();
494        public String timingLabel;
495        public Bundle timingResults = new Bundle();
496
497        public void writeBeginSnapshot(String label) {
498            snapshotLabel = label;
499        }
500
501        public void writeEndSnapshot(Bundle results) {
502            snapshotResults.putAll(results);
503        }
504
505        public void writeStartTiming(String label) {
506            timingLabel = label;
507        }
508
509        public void writeStopTiming(Bundle results) {
510            timingResults.putAll(results);
511        }
512
513        public void writeMeasurement(String label, long value) {
514            timingResults.putLong(label, value);
515        }
516
517        public void writeMeasurement(String label, float value) {
518            timingResults.putFloat(label, value);
519        }
520
521        public void writeMeasurement(String label, String value) {
522            timingResults.putString(label, value);
523        }
524    }
525}
526