src/tools/perf/measurements/timeline_based_measurement_unittest.py

   1 # Copyright 2014 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import os
   6 import unittest
   7
   8 from measurements import timeline_based_measurement as tbm_module
   9 from metrics import timeline_based_metric
  10 from telemetry.core import wpr_modes
  11 from telemetry.core.timeline import model as model_module
  12 from telemetry.core.timeline import async_slice
  13 from telemetry.page import page_measurement_results
  14 from telemetry.page import page_measurement_unittest_base
  15 from telemetry.page import page_set
  16 from telemetry.unittest import options_for_unittests
  17
  18 class TimelineBasedMetricsTests(unittest.TestCase):
  19   def setUp(self):
  20     model = model_module.TimelineModel()
  21     renderer_thread = model.GetOrCreateProcess(1).GetOrCreateThread(2)
  22     renderer_thread.name = 'CrRendererMain'
  23
  24     # [      X       ]
  25     #      [  Y  ]
  26     renderer_thread.BeginSlice('cat1', 'x.y', 10, 0)
  27     renderer_thread.EndSlice(20, 20)
  28
  29     renderer_thread.async_slices.append(async_slice.AsyncSlice(
  30         'cat', 'Interaction.LogicalName1/is_smooth',
  31         timestamp=0, duration=20,
  32         start_thread=renderer_thread, end_thread=renderer_thread))
  33     renderer_thread.async_slices.append(async_slice.AsyncSlice(
  34         'cat', 'Interaction.LogicalName2/is_loading_resources',
  35         timestamp=25, duration=5,
  36         start_thread=renderer_thread, end_thread=renderer_thread))
  37     model.FinalizeImport()
  38
  39     self.model = model
  40     self.renderer_thread = renderer_thread
  41
  42   def testFindTimelineInteractionRecords(self):
  43     metric = tbm_module._TimelineBasedMetrics( # pylint: disable=W0212
  44       self.model, self.renderer_thread, lambda _: [] )
  45     interactions = metric.FindTimelineInteractionRecords()
  46     self.assertEquals(2, len(interactions))
  47     self.assertTrue(interactions[0].is_smooth)
  48     self.assertEquals(0, interactions[0].start)
  49     self.assertEquals(20, interactions[0].end)
  50
  51     self.assertTrue(interactions[1].is_loading_resources)
  52     self.assertEquals(25, interactions[1].start)
  53     self.assertEquals(30, interactions[1].end)
  54
  55   def testAddResults(self):
  56     results = page_measurement_results.PageMeasurementResults()
  57     class FakeSmoothMetric(timeline_based_metric.TimelineBasedMetric):
  58       def AddResults(self, model, renderer_thread,
  59                      interaction_record, results):
  60         results.Add('FakeSmoothMetric', 'ms', 1)
  61
  62     class FakeLoadingMetric(timeline_based_metric.TimelineBasedMetric):
  63       def AddResults(self, model, renderer_thread,
  64                      interaction_record, results):
  65         assert interaction_record.logical_name == 'LogicalName2'
  66         results.Add('FakeLoadingMetric', 'ms', 2)
  67
  68     def CreateMetricsForTimelineInteractionRecord(interaction):
  69       res = []
  70       if interaction.is_smooth:
  71         res.append(FakeSmoothMetric())
  72       if interaction.is_loading_resources:
  73         res.append(FakeLoadingMetric())
  74       return res
  75
  76     metric = tbm_module._TimelineBasedMetrics( # pylint: disable=W0212
  77         self.model, self.renderer_thread,
  78         CreateMetricsForTimelineInteractionRecord)
  79     ps = page_set.PageSet.FromDict({
  80       "description": "hello",
  81       "archive_path": "foo.wpr",
  82       "pages": [
  83         {"url": "http://www.bar.com/"}
  84       ]
  85     }, os.path.dirname(__file__))
  86     results.WillMeasurePage(ps.pages[0])
  87     metric.AddResults(results)
  88     results.DidMeasurePage()
  89
  90     v = results.FindAllPageSpecificValuesNamed('LogicalName1-FakeSmoothMetric')
  91     self.assertEquals(len(v), 1)
  92     v = results.FindAllPageSpecificValuesNamed('LogicalName2-FakeLoadingMetric')
  93     self.assertEquals(len(v), 1)
  94
  95
  96 class TimelineBasedMeasurementTest(
  97       page_measurement_unittest_base.PageMeasurementUnitTestBase):
  98   def setUp(self):
  99     self._options = options_for_unittests.GetCopy()
 100     self._options.browser_options.wpr_mode = wpr_modes.WPR_OFF
 101
 102   def testTimelineBasedForSmoke(self):
 103     ps = self.CreatePageSetFromFileInUnittestDataDir(
 104         'interaction_enabled_page.html')
 105     setattr(ps.pages[0], 'RunSmoothness', {'action': 'wait',
 106                                         'javascript': 'window.animationDone'})
 107     measurement = tbm_module.TimelineBasedMeasurement()
 108     results = self.RunMeasurement(measurement, ps,
 109                                   options=self._options)
 110     self.assertEquals(0, len(results.failures))
 111     v = results.FindAllPageSpecificValuesNamed('CenterAnimation-jank')
 112     self.assertEquals(len(v), 2)
 113     v = results.FindAllPageSpecificValuesNamed('DrawerAnimation-jank')
 114     self.assertEquals(len(v), 2)
 115