| # Copyright 2014 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import unittest |
| |
| from telemetry.internal.results import page_test_results |
| from telemetry.page import page as page_module |
| from telemetry.web_perf.metrics import rendering_stats |
| from telemetry.web_perf.metrics import smoothness |
| |
| |
| class _MockRenderingStats(object): |
| |
| stats = ['refresh_period', 'frame_timestamps', 'frame_times', 'paint_times', |
| 'painted_pixel_counts', 'record_times', |
| 'recorded_pixel_counts', 'approximated_pixel_percentages', |
| 'checkerboarded_pixel_percentages', 'input_event_latency', |
| 'frame_queueing_durations', 'main_thread_scroll_latency', |
| 'gesture_scroll_update_latency'] |
| |
| def __init__(self, **kwargs): |
| self.input_event_latency = None # to avoid pylint no-member error |
| self.errors = {} |
| for stat in self.stats: |
| value = kwargs[stat] if stat in kwargs else None |
| setattr(self, stat, value) |
| |
| |
| #pylint: disable=protected-access |
| class SmoothnessMetricUnitTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.metric = smoothness.SmoothnessMetric() |
| self.page = page_module.Page('file://blank.html') |
| self.good_timestamps = [[10, 20], [30, 40, 50]] |
| self.not_enough_frames_timestamps = [[10], [20, 30, 40]] |
| |
| def testPopulateResultsFromStats(self): |
| stats = _MockRenderingStats() |
| for stat in _MockRenderingStats.stats: |
| # Just set fake data for all of the relevant arrays of stats typically |
| # found in a RenderingStats object. |
| setattr(stats, stat, [[10, 20], [30, 40, 50]]) |
| results = page_test_results.PageTestResults() |
| results.WillRunPage(self.page) |
| self.metric._PopulateResultsFromStats(results, stats, False) |
| current_page_run = results.current_page_run |
| self.assertTrue(current_page_run.ok) |
| expected_values_count = 12 |
| self.assertEquals(expected_values_count, len(current_page_run.values)) |
| |
| def testHasEnoughFrames(self): |
| # This list will pass since every sub-array has at least 2 frames. |
| has_enough_frames = self.metric._HasEnoughFrames(self.good_timestamps) |
| self.assertTrue(has_enough_frames) |
| |
| def testHasEnoughFramesWithNotEnoughFrames(self): |
| # This list will fail since the first sub-array only has a single frame. |
| has_enough_frames = self.metric._HasEnoughFrames( |
| self.not_enough_frames_timestamps) |
| self.assertFalse(has_enough_frames) |
| |
| def testComputeSurfaceFlingerMetricNoJank(self): |
| stats = _MockRenderingStats(refresh_period=10, |
| frame_timestamps=[[10, 20], [130, 140, 150]], |
| frame_times=[[10], [10, 10]]) |
| avg_surface_fps, jank_count, max_frame_delay, frame_lengths = ( |
| self.metric._ComputeSurfaceFlingerMetric(self.page, stats)) |
| self.assertEquals([1, 1, 1], frame_lengths.values) |
| self.assertEquals(1, max_frame_delay.value) |
| self.assertEquals(0, jank_count.value) |
| self.assertEquals(100, avg_surface_fps.value) |
| |
| def testComputeSurfaceFlingerMetricJank(self): |
| stats = _MockRenderingStats( |
| refresh_period=10, |
| frame_timestamps=[[10, 20, 50], [130, 140, 150, 170, 180]], |
| frame_times=[[10, 30], [10, 10, 20, 10]]) |
| avg_surface_fps, jank_count, max_frame_delay, frame_lengths = ( |
| self.metric._ComputeSurfaceFlingerMetric(self.page, stats)) |
| self.assertEquals([1, 3, 1, 1, 2, 1], frame_lengths.values) |
| self.assertEquals(3, max_frame_delay.value) |
| self.assertEquals(2, jank_count.value) |
| self.assertEquals(67, avg_surface_fps.value) |
| |
| def testComputeFrameTimeMetricWithNotEnoughFrames(self): |
| stats = _MockRenderingStats( |
| refresh_period=10, |
| frame_timestamps=self.not_enough_frames_timestamps, |
| frame_times=[[10, 20], [30, 40, 50]]) |
| avg_surface_fps, jank_count, max_frame_delay, frame_lengths = ( |
| self.metric._ComputeSurfaceFlingerMetric(self.page, stats)) |
| self.assertEquals(None, avg_surface_fps.value) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| avg_surface_fps.none_value_reason) |
| self.assertEquals(None, jank_count.value) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| jank_count.none_value_reason) |
| self.assertEquals(None, max_frame_delay.value) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| max_frame_delay.none_value_reason) |
| self.assertEquals(None, frame_lengths.values) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| frame_lengths.none_value_reason) |
| |
| def testComputeLatencyMetric(self): |
| stats = _MockRenderingStats(frame_timestamps=self.good_timestamps, |
| input_event_latency=[[10, 20], [30, 40, 50]]) |
| # pylint: disable=unbalanced-tuple-unpacking |
| mean_value, discrepancy_value = self.metric._ComputeLatencyMetric( |
| self.page, stats, 'input_event_latency', stats.input_event_latency) |
| self.assertEquals(30, mean_value.value) |
| self.assertEquals(60, discrepancy_value.value) |
| |
| def testComputeLatencyMetricWithMissingData(self): |
| stats = _MockRenderingStats(frame_timestamps=self.good_timestamps, |
| input_event_latency=[[], []]) |
| value = self.metric._ComputeLatencyMetric( |
| self.page, stats, 'input_event_latency', stats.input_event_latency) |
| self.assertEquals((), value) |
| |
| def testComputeLatencyMetricWithNotEnoughFrames(self): |
| stats = _MockRenderingStats( |
| frame_timestamps=self.not_enough_frames_timestamps, |
| input_event_latency=[[], []]) |
| # pylint: disable=unbalanced-tuple-unpacking |
| mean_value, discrepancy_value = self.metric._ComputeLatencyMetric( |
| self.page, stats, 'input_event_latency', stats.input_event_latency) |
| self.assertEquals(None, mean_value.value) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| mean_value.none_value_reason) |
| self.assertEquals(None, discrepancy_value.value) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| discrepancy_value.none_value_reason) |
| |
| def testComputeGestureScrollUpdateLatencies(self): |
| stats = _MockRenderingStats( |
| frame_timestamps=self.good_timestamps, |
| gesture_scroll_update_latency=[[10, 20], [30, 40, 50]]) |
| gesture_value = self.metric._ComputeFirstGestureScrollUpdateLatencies( |
| self.page, stats) |
| self.assertEquals([10, 30], gesture_value.values) |
| |
| def testComputeGestureScrollUpdateLatenciesWithMissingData(self): |
| stats = _MockRenderingStats( |
| frame_timestamps=self.good_timestamps, |
| gesture_scroll_update_latency=[[], []]) |
| value = self.metric._ComputeFirstGestureScrollUpdateLatencies( |
| self.page, stats) |
| self.assertEquals(None, value.values) |
| |
| def testComputeGestureScrollUpdateLatenciesWithNotEnoughFrames(self): |
| stats = _MockRenderingStats( |
| frame_timestamps=self.not_enough_frames_timestamps, |
| gesture_scroll_update_latency=[[10, 20], [30, 40, 50]]) |
| gesture_value = self.metric._ComputeFirstGestureScrollUpdateLatencies( |
| self.page, stats) |
| self.assertEquals(None, gesture_value.values) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| gesture_value.none_value_reason) |
| |
| def testComputeQueueingDuration(self): |
| stats = _MockRenderingStats(frame_timestamps=self.good_timestamps, |
| frame_queueing_durations=[[10, 20], [30, 40]]) |
| list_of_scalar_values = self.metric._ComputeQueueingDuration(self.page, |
| stats) |
| self.assertEquals([10, 20, 30, 40], list_of_scalar_values.values) |
| |
| def testComputeQueueingDurationWithMissingData(self): |
| stats = _MockRenderingStats(frame_timestamps=self.good_timestamps, |
| frame_queueing_durations=[[], []]) |
| list_of_scalar_values = self.metric._ComputeQueueingDuration( |
| self.page, stats) |
| self.assertEquals(None, list_of_scalar_values.values) |
| self.assertEquals('No frame queueing durations recorded.', |
| list_of_scalar_values.none_value_reason) |
| |
| def testComputeQueueingDurationWithMissingDataAndErrorValue(self): |
| stats = _MockRenderingStats(frame_timestamps=self.good_timestamps, |
| frame_queueing_durations=[[], []]) |
| stats.errors['frame_queueing_durations'] = ( |
| 'Current chrome version does not support the queueing delay metric.') |
| list_of_scalar_values = self.metric._ComputeQueueingDuration( |
| self.page, stats) |
| self.assertEquals(None, list_of_scalar_values.values) |
| self.assertEquals( |
| 'Current chrome version does not support the queueing delay metric.', |
| list_of_scalar_values.none_value_reason) |
| |
| def testComputeQueueingDurationWithNotEnoughFrames(self): |
| stats = _MockRenderingStats( |
| frame_timestamps=self.not_enough_frames_timestamps, |
| frame_queueing_durations=[[10, 20], [30, 40, 50]]) |
| list_of_scalar_values = self.metric._ComputeQueueingDuration(self.page, |
| stats) |
| self.assertEquals(None, list_of_scalar_values.values) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| list_of_scalar_values.none_value_reason) |
| |
| def testComputeFrameTimeMetric(self): |
| stats = _MockRenderingStats(frame_timestamps=self.good_timestamps, |
| frame_times=[[10, 20], [30, 40, 50]]) |
| frame_times_value, mean_frame_time_value, percentage_smooth_value = ( |
| self.metric._ComputeFrameTimeMetric(self.page, stats)) |
| self.assertEquals([10, 20, 30, 40, 50], frame_times_value.values) |
| self.assertEquals(30, mean_frame_time_value.value) |
| self.assertEquals(20, percentage_smooth_value.value) |
| |
| def testComputeFrameTimeMetricWithNotEnoughFrames2(self): |
| stats = _MockRenderingStats( |
| frame_timestamps=self.not_enough_frames_timestamps, |
| frame_times=[[10, 20], [30, 40, 50]]) |
| frame_times_value, mean_frame_time_value, percentage_smooth_value = ( |
| self.metric._ComputeFrameTimeMetric(self.page, stats)) |
| self.assertEquals(None, frame_times_value.values) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| frame_times_value.none_value_reason) |
| self.assertEquals(None, mean_frame_time_value.value) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| mean_frame_time_value.none_value_reason) |
| self.assertEquals(None, percentage_smooth_value.value) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| percentage_smooth_value.none_value_reason) |
| |
| def testComputeFrameTimeDiscrepancy(self): |
| stats = _MockRenderingStats(frame_timestamps=self.good_timestamps) |
| frame_time_discrepancy_value = self.metric._ComputeFrameTimeDiscrepancy( |
| self.page, stats) |
| self.assertEquals(10, frame_time_discrepancy_value.value) |
| |
| def testComputeFrameTimeDiscrepancyWithNotEnoughFrames(self): |
| stats = _MockRenderingStats( |
| frame_timestamps=self.not_enough_frames_timestamps) |
| frame_time_discrepancy_value = self.metric._ComputeFrameTimeDiscrepancy( |
| self.page, stats) |
| self.assertEquals(None, frame_time_discrepancy_value.value) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| frame_time_discrepancy_value.none_value_reason) |
| |
| def testComputeMeanPixelsApproximated(self): |
| stats = _MockRenderingStats( |
| frame_timestamps=self.good_timestamps, |
| approximated_pixel_percentages=[[10, 20], [30, 40, 50]]) |
| mean_pixels_value = self.metric._ComputeMeanPixelsApproximated( |
| self.page, stats) |
| self.assertEquals(30, mean_pixels_value.value) |
| |
| def testComputeMeanPixelsApproximatedWithNotEnoughFrames(self): |
| stats = _MockRenderingStats( |
| frame_timestamps=self.not_enough_frames_timestamps, |
| approximated_pixel_percentages=[[10, 20], [30, 40, 50]]) |
| mean_pixels_value = self.metric._ComputeMeanPixelsApproximated( |
| self.page, stats) |
| self.assertEquals(None, mean_pixels_value.value) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| mean_pixels_value.none_value_reason) |
| |
| def testComputeMeanPixelsCheckerboarded(self): |
| stats = _MockRenderingStats( |
| frame_timestamps=self.good_timestamps, |
| checkerboarded_pixel_percentages=[[10, 20], [30, 40, 50]]) |
| mean_pixels_value = self.metric._ComputeMeanPixelsCheckerboarded( |
| self.page, stats) |
| self.assertEquals(30, mean_pixels_value.value) |
| |
| def testComputeMeanPixelsCheckerboardedWithNotEnoughFrames(self): |
| stats = _MockRenderingStats( |
| frame_timestamps=self.not_enough_frames_timestamps, |
| checkerboarded_pixel_percentages=[[10, 20], [30, 40, 50]]) |
| mean_pixels_value = self.metric._ComputeMeanPixelsCheckerboarded( |
| self.page, stats) |
| self.assertEquals(None, mean_pixels_value.value) |
| self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE, |
| mean_pixels_value.none_value_reason) |
| |
| def testComputeMeanPixelsCheckerboardedWithNoData(self): |
| stats = _MockRenderingStats( |
| frame_timestamps=self.good_timestamps, |
| checkerboarded_pixel_percentages=None) |
| stats.errors[rendering_stats.CHECKERBOARDED_PIXEL_ERROR] = 'test error' |
| mean_pixels_value = self.metric._ComputeMeanPixelsCheckerboarded( |
| self.page, stats) |
| self.assertEquals(None, mean_pixels_value.value) |
| self.assertEquals('test error', |
| mean_pixels_value.none_value_reason) |
