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 17 package android.os; 18 19 import android.os.PerformanceCollector.PerformanceResultsWriter; 20 import android.test.suitebuilder.annotation.MediumTest; 21 import android.test.suitebuilder.annotation.SmallTest; 22 23 import java.lang.reflect.Field; 24 import java.util.ArrayList; 25 import java.util.Random; 26 27 import junit.framework.TestCase; 28 29 public class PerformanceCollectorTest extends TestCase { 30 31 private PerformanceCollector mPerfCollector; 32 33 @Override setUp()34 protected void setUp() throws Exception { 35 super.setUp(); 36 mPerfCollector = new PerformanceCollector(); 37 } 38 39 @Override tearDown()40 protected void tearDown() throws Exception { 41 super.tearDown(); 42 mPerfCollector = null; 43 } 44 45 @SmallTest testBeginSnapshotNoWriter()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 testEndSnapshotNoWriter()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 testStartTimingNoWriter()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 testAddIterationNoWriter()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 testStopTimingNoWriter()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 testBeginSnapshot()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 testEndSnapshot()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 testStartTiming()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 testAddIteration()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 testStopTiming()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 testAddMeasurementLong()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 testAddMeasurementFloat()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 testAddMeasurementString()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 testSimpleSequence()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 testLongSequence()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 testOutOfOrderSequence()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 workForRandomPeriod(int minDuration, int maxDuration)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 workForRandomTinyPeriod()387 private void workForRandomTinyPeriod() { 388 workForRandomPeriod(2, 5); 389 } 390 workForRandomShortPeriod()391 private void workForRandomShortPeriod() { 392 workForRandomPeriod(10, 25); 393 } 394 workForRandomLongPeriod()395 private void workForRandomLongPeriod() { 396 workForRandomPeriod(50, 100); 397 } 398 verifySnapshotBundle(Bundle snapshot)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 verifyIterationBundle(Bundle iteration, String label)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 verifyTimingBundle(Bundle timing, ArrayList<String> labels)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 assertEqualsBundle(Bundle b1, Bundle b2)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 readPrivateField(String fieldName, Object object)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 writeBeginSnapshot(String label)497 public void writeBeginSnapshot(String label) { 498 snapshotLabel = label; 499 } 500 writeEndSnapshot(Bundle results)501 public void writeEndSnapshot(Bundle results) { 502 snapshotResults.putAll(results); 503 } 504 writeStartTiming(String label)505 public void writeStartTiming(String label) { 506 timingLabel = label; 507 } 508 writeStopTiming(Bundle results)509 public void writeStopTiming(Bundle results) { 510 timingResults.putAll(results); 511 } 512 writeMeasurement(String label, long value)513 public void writeMeasurement(String label, long value) { 514 timingResults.putLong(label, value); 515 } 516 writeMeasurement(String label, float value)517 public void writeMeasurement(String label, float value) { 518 timingResults.putFloat(label, value); 519 } 520 writeMeasurement(String label, String value)521 public void writeMeasurement(String label, String value) { 522 timingResults.putString(label, value); 523 } 524 } 525 } 526