| /* |
| * Copyright (C) 2009 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.os; |
| |
| import android.os.PerformanceCollector.PerformanceResultsWriter; |
| import android.test.suitebuilder.annotation.MediumTest; |
| import android.test.suitebuilder.annotation.SmallTest; |
| |
| import java.lang.reflect.Field; |
| import java.util.ArrayList; |
| import java.util.Random; |
| |
| import junit.framework.TestCase; |
| |
| public class PerformanceCollectorTest extends TestCase { |
| |
| private PerformanceCollector mPerfCollector; |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| mPerfCollector = new PerformanceCollector(); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| mPerfCollector = null; |
| } |
| |
| @SmallTest |
| public void testBeginSnapshotNoWriter() throws Exception { |
| mPerfCollector.beginSnapshot("testBeginSnapshotNoWriter"); |
| |
| assertTrue((Long)readPrivateField("mSnapshotCpuTime", mPerfCollector) > 0); |
| assertTrue((Long)readPrivateField("mSnapshotExecTime", mPerfCollector) > 0); |
| Bundle snapshot = (Bundle)readPrivateField("mPerfSnapshot", mPerfCollector); |
| assertNotNull(snapshot); |
| assertEquals(2, snapshot.size()); |
| } |
| |
| @MediumTest |
| public void testEndSnapshotNoWriter() throws Exception { |
| mPerfCollector.beginSnapshot("testEndSnapshotNoWriter"); |
| workForRandomLongPeriod(); |
| Bundle snapshot = mPerfCollector.endSnapshot(); |
| |
| verifySnapshotBundle(snapshot); |
| } |
| |
| @SmallTest |
| public void testStartTimingNoWriter() throws Exception { |
| mPerfCollector.startTiming("testStartTimingNoWriter"); |
| |
| assertTrue((Long)readPrivateField("mCpuTime", mPerfCollector) > 0); |
| assertTrue((Long)readPrivateField("mExecTime", mPerfCollector) > 0); |
| Bundle measurement = (Bundle)readPrivateField("mPerfMeasurement", mPerfCollector); |
| assertNotNull(measurement); |
| verifyTimingBundle(measurement, new ArrayList<String>()); |
| } |
| |
| @SmallTest |
| public void testAddIterationNoWriter() throws Exception { |
| mPerfCollector.startTiming("testAddIterationNoWriter"); |
| workForRandomTinyPeriod(); |
| Bundle iteration = mPerfCollector.addIteration("timing1"); |
| |
| verifyIterationBundle(iteration, "timing1"); |
| } |
| |
| @SmallTest |
| public void testStopTimingNoWriter() throws Exception { |
| mPerfCollector.startTiming("testStopTimingNoWriter"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("timing2"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("timing3"); |
| workForRandomShortPeriod(); |
| Bundle timing = mPerfCollector.stopTiming("timing4"); |
| |
| ArrayList<String> labels = new ArrayList<String>(); |
| labels.add("timing2"); |
| labels.add("timing3"); |
| labels.add("timing4"); |
| verifyTimingBundle(timing, labels); |
| } |
| |
| @SmallTest |
| public void testBeginSnapshot() throws Exception { |
| MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter(); |
| mPerfCollector.setPerformanceResultsWriter(writer); |
| mPerfCollector.beginSnapshot("testBeginSnapshot"); |
| |
| assertEquals("testBeginSnapshot", writer.snapshotLabel); |
| assertTrue((Long)readPrivateField("mSnapshotCpuTime", mPerfCollector) > 0); |
| assertTrue((Long)readPrivateField("mSnapshotExecTime", mPerfCollector) > 0); |
| Bundle snapshot = (Bundle)readPrivateField("mPerfSnapshot", mPerfCollector); |
| assertNotNull(snapshot); |
| assertEquals(2, snapshot.size()); |
| } |
| |
| @MediumTest |
| public void testEndSnapshot() throws Exception { |
| MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter(); |
| mPerfCollector.setPerformanceResultsWriter(writer); |
| mPerfCollector.beginSnapshot("testEndSnapshot"); |
| workForRandomLongPeriod(); |
| Bundle snapshot1 = mPerfCollector.endSnapshot(); |
| Bundle snapshot2 = writer.snapshotResults; |
| |
| assertEqualsBundle(snapshot1, snapshot2); |
| verifySnapshotBundle(snapshot1); |
| } |
| |
| @SmallTest |
| public void testStartTiming() throws Exception { |
| MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter(); |
| mPerfCollector.setPerformanceResultsWriter(writer); |
| mPerfCollector.startTiming("testStartTiming"); |
| |
| assertEquals("testStartTiming", writer.timingLabel); |
| assertTrue((Long)readPrivateField("mCpuTime", mPerfCollector) > 0); |
| assertTrue((Long)readPrivateField("mExecTime", mPerfCollector) > 0); |
| Bundle measurement = (Bundle)readPrivateField("mPerfMeasurement", mPerfCollector); |
| assertNotNull(measurement); |
| verifyTimingBundle(measurement, new ArrayList<String>()); |
| } |
| |
| @SmallTest |
| public void testAddIteration() throws Exception { |
| mPerfCollector.startTiming("testAddIteration"); |
| workForRandomTinyPeriod(); |
| Bundle iteration = mPerfCollector.addIteration("timing5"); |
| |
| verifyIterationBundle(iteration, "timing5"); |
| } |
| |
| @SmallTest |
| public void testStopTiming() throws Exception { |
| mPerfCollector.startTiming("testStopTiming"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("timing6"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("timing7"); |
| workForRandomShortPeriod(); |
| Bundle timing = mPerfCollector.stopTiming("timing8"); |
| |
| ArrayList<String> labels = new ArrayList<String>(); |
| labels.add("timing6"); |
| labels.add("timing7"); |
| labels.add("timing8"); |
| verifyTimingBundle(timing, labels); |
| } |
| |
| @SmallTest |
| public void testAddMeasurementLong() throws Exception { |
| MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter(); |
| mPerfCollector.setPerformanceResultsWriter(writer); |
| mPerfCollector.startTiming("testAddMeasurementLong"); |
| mPerfCollector.addMeasurement("testAddMeasurementLongZero", 0); |
| mPerfCollector.addMeasurement("testAddMeasurementLongPos", 348573); |
| mPerfCollector.addMeasurement("testAddMeasurementLongNeg", -19354); |
| mPerfCollector.stopTiming(""); |
| |
| assertEquals("testAddMeasurementLong", writer.timingLabel); |
| Bundle results = writer.timingResults; |
| assertEquals(4, results.size()); |
| assertTrue(results.containsKey("testAddMeasurementLongZero")); |
| assertEquals(0, results.getLong("testAddMeasurementLongZero")); |
| assertTrue(results.containsKey("testAddMeasurementLongPos")); |
| assertEquals(348573, results.getLong("testAddMeasurementLongPos")); |
| assertTrue(results.containsKey("testAddMeasurementLongNeg")); |
| assertEquals(-19354, results.getLong("testAddMeasurementLongNeg")); |
| } |
| |
| @SmallTest |
| public void testAddMeasurementFloat() throws Exception { |
| MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter(); |
| mPerfCollector.setPerformanceResultsWriter(writer); |
| mPerfCollector.startTiming("testAddMeasurementFloat"); |
| mPerfCollector.addMeasurement("testAddMeasurementFloatZero", 0.0f); |
| mPerfCollector.addMeasurement("testAddMeasurementFloatPos", 348573.345f); |
| mPerfCollector.addMeasurement("testAddMeasurementFloatNeg", -19354.093f); |
| mPerfCollector.stopTiming(""); |
| |
| assertEquals("testAddMeasurementFloat", writer.timingLabel); |
| Bundle results = writer.timingResults; |
| assertEquals(4, results.size()); |
| assertTrue(results.containsKey("testAddMeasurementFloatZero")); |
| assertEquals(0.0f, results.getFloat("testAddMeasurementFloatZero")); |
| assertTrue(results.containsKey("testAddMeasurementFloatPos")); |
| assertEquals(348573.345f, results.getFloat("testAddMeasurementFloatPos")); |
| assertTrue(results.containsKey("testAddMeasurementFloatNeg")); |
| assertEquals(-19354.093f, results.getFloat("testAddMeasurementFloatNeg")); |
| } |
| |
| @SmallTest |
| public void testAddMeasurementString() throws Exception { |
| MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter(); |
| mPerfCollector.setPerformanceResultsWriter(writer); |
| mPerfCollector.startTiming("testAddMeasurementString"); |
| mPerfCollector.addMeasurement("testAddMeasurementStringNull", null); |
| mPerfCollector.addMeasurement("testAddMeasurementStringEmpty", ""); |
| mPerfCollector.addMeasurement("testAddMeasurementStringNonEmpty", "Hello World"); |
| mPerfCollector.stopTiming(""); |
| |
| assertEquals("testAddMeasurementString", writer.timingLabel); |
| Bundle results = writer.timingResults; |
| assertEquals(4, results.size()); |
| assertTrue(results.containsKey("testAddMeasurementStringNull")); |
| assertNull(results.getString("testAddMeasurementStringNull")); |
| assertTrue(results.containsKey("testAddMeasurementStringEmpty")); |
| assertEquals("", results.getString("testAddMeasurementStringEmpty")); |
| assertTrue(results.containsKey("testAddMeasurementStringNonEmpty")); |
| assertEquals("Hello World", results.getString("testAddMeasurementStringNonEmpty")); |
| } |
| |
| @MediumTest |
| public void testSimpleSequence() throws Exception { |
| MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter(); |
| mPerfCollector.setPerformanceResultsWriter(writer); |
| mPerfCollector.beginSnapshot("testSimpleSequence"); |
| mPerfCollector.startTiming("testSimpleSequenceTiming"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration1"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration2"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration3"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration4"); |
| workForRandomShortPeriod(); |
| Bundle timing = mPerfCollector.stopTiming("iteration5"); |
| workForRandomLongPeriod(); |
| Bundle snapshot1 = mPerfCollector.endSnapshot(); |
| Bundle snapshot2 = writer.snapshotResults; |
| |
| assertEqualsBundle(snapshot1, snapshot2); |
| verifySnapshotBundle(snapshot1); |
| |
| ArrayList<String> labels = new ArrayList<String>(); |
| labels.add("iteration1"); |
| labels.add("iteration2"); |
| labels.add("iteration3"); |
| labels.add("iteration4"); |
| labels.add("iteration5"); |
| verifyTimingBundle(timing, labels); |
| } |
| |
| @MediumTest |
| public void testLongSequence() throws Exception { |
| MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter(); |
| mPerfCollector.setPerformanceResultsWriter(writer); |
| mPerfCollector.beginSnapshot("testLongSequence"); |
| mPerfCollector.startTiming("testLongSequenceTiming1"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration1"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration2"); |
| workForRandomShortPeriod(); |
| Bundle timing1 = mPerfCollector.stopTiming("iteration3"); |
| workForRandomLongPeriod(); |
| |
| mPerfCollector.startTiming("testLongSequenceTiming2"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration4"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration5"); |
| workForRandomShortPeriod(); |
| Bundle timing2 = mPerfCollector.stopTiming("iteration6"); |
| workForRandomLongPeriod(); |
| |
| mPerfCollector.startTiming("testLongSequenceTiming3"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration7"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration8"); |
| workForRandomShortPeriod(); |
| Bundle timing3 = mPerfCollector.stopTiming("iteration9"); |
| workForRandomLongPeriod(); |
| |
| mPerfCollector.startTiming("testLongSequenceTiming4"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration10"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration11"); |
| workForRandomShortPeriod(); |
| Bundle timing4 = mPerfCollector.stopTiming("iteration12"); |
| workForRandomLongPeriod(); |
| |
| mPerfCollector.startTiming("testLongSequenceTiming5"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration13"); |
| workForRandomTinyPeriod(); |
| mPerfCollector.addIteration("iteration14"); |
| workForRandomShortPeriod(); |
| Bundle timing5 = mPerfCollector.stopTiming("iteration15"); |
| workForRandomLongPeriod(); |
| Bundle snapshot1 = mPerfCollector.endSnapshot(); |
| Bundle snapshot2 = writer.snapshotResults; |
| |
| assertEqualsBundle(snapshot1, snapshot2); |
| verifySnapshotBundle(snapshot1); |
| |
| ArrayList<String> labels1 = new ArrayList<String>(); |
| labels1.add("iteration1"); |
| labels1.add("iteration2"); |
| labels1.add("iteration3"); |
| verifyTimingBundle(timing1, labels1); |
| ArrayList<String> labels2 = new ArrayList<String>(); |
| labels2.add("iteration4"); |
| labels2.add("iteration5"); |
| labels2.add("iteration6"); |
| verifyTimingBundle(timing2, labels2); |
| ArrayList<String> labels3 = new ArrayList<String>(); |
| labels3.add("iteration7"); |
| labels3.add("iteration8"); |
| labels3.add("iteration9"); |
| verifyTimingBundle(timing3, labels3); |
| ArrayList<String> labels4 = new ArrayList<String>(); |
| labels4.add("iteration10"); |
| labels4.add("iteration11"); |
| labels4.add("iteration12"); |
| verifyTimingBundle(timing4, labels4); |
| ArrayList<String> labels5 = new ArrayList<String>(); |
| labels5.add("iteration13"); |
| labels5.add("iteration14"); |
| labels5.add("iteration15"); |
| verifyTimingBundle(timing5, labels5); |
| } |
| |
| /* |
| * Verify that snapshotting and timing do not interfere w/ each other, |
| * by staggering calls to snapshot and timing functions. |
| */ |
| @MediumTest |
| public void testOutOfOrderSequence() { |
| MockPerformanceResultsWriter writer = new MockPerformanceResultsWriter(); |
| mPerfCollector.setPerformanceResultsWriter(writer); |
| mPerfCollector.startTiming("testOutOfOrderSequenceTiming"); |
| workForRandomShortPeriod(); |
| mPerfCollector.beginSnapshot("testOutOfOrderSequenceSnapshot"); |
| workForRandomShortPeriod(); |
| Bundle timing1 = mPerfCollector.stopTiming("timing1"); |
| workForRandomShortPeriod(); |
| Bundle snapshot1 = mPerfCollector.endSnapshot(); |
| |
| Bundle timing2 = writer.timingResults; |
| Bundle snapshot2 = writer.snapshotResults; |
| |
| assertEqualsBundle(snapshot1, snapshot2); |
| verifySnapshotBundle(snapshot1); |
| |
| assertEqualsBundle(timing1, timing2); |
| ArrayList<String> labels = new ArrayList<String>(); |
| labels.add("timing1"); |
| verifyTimingBundle(timing1, labels); |
| } |
| |
| private void workForRandomPeriod(int minDuration, int maxDuration) { |
| Random random = new Random(); |
| int period = minDuration + random.nextInt(maxDuration - minDuration); |
| long start = Process.getElapsedCpuTime(); |
| // Generate positive amount of work, so cpu time is measurable in |
| // milliseconds |
| while (Process.getElapsedCpuTime() - start < period) { |
| for (int i = 0, temp = 0; i < 50; i++ ) { |
| temp += i; |
| } |
| } |
| } |
| |
| private void workForRandomTinyPeriod() { |
| workForRandomPeriod(2, 5); |
| } |
| |
| private void workForRandomShortPeriod() { |
| workForRandomPeriod(10, 25); |
| } |
| |
| private void workForRandomLongPeriod() { |
| workForRandomPeriod(50, 100); |
| } |
| |
| private void verifySnapshotBundle(Bundle snapshot) { |
| assertTrue("At least 26 metrics collected", 26 <= snapshot.size()); |
| |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_CPU_TIME)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_CPU_TIME) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_EXECUTION_TIME)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_EXECUTION_TIME) > 0); |
| |
| assertTrue(snapshot.containsKey( |
| PerformanceCollector.METRIC_KEY_PRE_RECEIVED_TRANSACTIONS)); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_PRE_SENT_TRANSACTIONS)); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_RECEIVED_TRANSACTIONS)); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_SENT_TRANSACTIONS)); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_GC_INVOCATION_COUNT)); |
| |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_JAVA_ALLOCATED)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_JAVA_ALLOCATED) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_JAVA_FREE)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_JAVA_FREE) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_JAVA_PRIVATE_DIRTY)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_JAVA_PRIVATE_DIRTY) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_JAVA_PSS)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_JAVA_PSS) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_JAVA_SHARED_DIRTY)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_JAVA_SHARED_DIRTY) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_JAVA_SIZE)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_JAVA_SIZE) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_NATIVE_ALLOCATED)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_NATIVE_ALLOCATED) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_NATIVE_FREE)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_NATIVE_FREE) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_NATIVE_PRIVATE_DIRTY)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_NATIVE_PRIVATE_DIRTY) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_NATIVE_PSS)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_NATIVE_PSS) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_NATIVE_SHARED_DIRTY)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_NATIVE_SHARED_DIRTY) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_NATIVE_SIZE)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_NATIVE_SIZE) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_GLOBAL_ALLOC_COUNT)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_GLOBAL_ALLOC_COUNT) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_GLOBAL_ALLOC_SIZE)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_GLOBAL_ALLOC_SIZE) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_GLOBAL_FREED_COUNT)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_GLOBAL_FREED_COUNT) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_GLOBAL_FREED_SIZE)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_GLOBAL_FREED_SIZE) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_OTHER_PRIVATE_DIRTY)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_OTHER_PRIVATE_DIRTY) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_OTHER_PSS)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_OTHER_PSS) > 0); |
| assertTrue(snapshot.containsKey(PerformanceCollector.METRIC_KEY_OTHER_SHARED_DIRTY)); |
| assertTrue(snapshot.getLong(PerformanceCollector.METRIC_KEY_OTHER_SHARED_DIRTY) > 0); |
| } |
| |
| private void verifyIterationBundle(Bundle iteration, String label) { |
| assertEquals(3, iteration.size()); |
| assertTrue(iteration.containsKey(PerformanceCollector.METRIC_KEY_LABEL)); |
| assertEquals(label, iteration.getString(PerformanceCollector.METRIC_KEY_LABEL)); |
| assertTrue(iteration.containsKey(PerformanceCollector.METRIC_KEY_CPU_TIME)); |
| assertTrue(iteration.getLong(PerformanceCollector.METRIC_KEY_CPU_TIME) > 0); |
| assertTrue(iteration.containsKey(PerformanceCollector.METRIC_KEY_EXECUTION_TIME)); |
| assertTrue(iteration.getLong(PerformanceCollector.METRIC_KEY_EXECUTION_TIME) > 0); |
| } |
| |
| private void verifyTimingBundle(Bundle timing, ArrayList<String> labels) { |
| assertEquals(1, timing.size()); |
| assertTrue(timing.containsKey(PerformanceCollector.METRIC_KEY_ITERATIONS)); |
| ArrayList<Parcelable> iterations = timing.getParcelableArrayList( |
| PerformanceCollector.METRIC_KEY_ITERATIONS); |
| assertNotNull(iterations); |
| assertEquals(labels.size(), iterations.size()); |
| for (int i = 0; i < labels.size(); i ++) { |
| Bundle iteration = (Bundle)iterations.get(i); |
| verifyIterationBundle(iteration, labels.get(i)); |
| } |
| } |
| |
| private void assertEqualsBundle(Bundle b1, Bundle b2) { |
| assertEquals(b1.keySet(), b2.keySet()); |
| for (String key : b1.keySet()) { |
| assertEquals(b1.get(key), b2.get(key)); |
| } |
| } |
| |
| private Object readPrivateField(String fieldName, Object object) throws Exception { |
| Field f = object.getClass().getDeclaredField(fieldName); |
| f.setAccessible(true); |
| return f.get(object); |
| } |
| |
| private class MockPerformanceResultsWriter implements PerformanceResultsWriter { |
| |
| public String snapshotLabel; |
| public Bundle snapshotResults = new Bundle(); |
| public String timingLabel; |
| public Bundle timingResults = new Bundle(); |
| |
| public void writeBeginSnapshot(String label) { |
| snapshotLabel = label; |
| } |
| |
| public void writeEndSnapshot(Bundle results) { |
| snapshotResults.putAll(results); |
| } |
| |
| public void writeStartTiming(String label) { |
| timingLabel = label; |
| } |
| |
| public void writeStopTiming(Bundle results) { |
| timingResults.putAll(results); |
| } |
| |
| public void writeMeasurement(String label, long value) { |
| timingResults.putLong(label, value); |
| } |
| |
| public void writeMeasurement(String label, float value) { |
| timingResults.putFloat(label, value); |
| } |
| |
| public void writeMeasurement(String label, String value) { |
| timingResults.putString(label, value); |
| } |
| } |
| } |
