def AddResultsForSafebrowsing(self, tab, results): count = 0 safebrowsing_count = 0 for resp in self.IterResponses(tab): count += 1 if resp.IsSafebrowsingResponse(): safebrowsing_count += 1 else: r = resp.response raise ChromeProxyMetricException, ( '%s: Not a valid safe browsing response.\n' 'Reponse: status=(%d, %s)\nHeaders:\n %s' % (r.url, r.status, r.status_text, r.headers)) if count == safebrowsing_count: results.AddValue( scalar.ScalarValue(results.current_page, 'safebrowsing', 'boolean', True)) else: raise ChromeProxyMetricException, ( 'Safebrowsing failed (count=%d, safebrowsing_count=%d)\n' % (count, safebrowsing_count))
def ValidateAndMeasurePage(self, page, tab, results): tab.WaitForJavaScriptExpression('__pc_load_time', 60) chart_name_prefix = ('cold_' if self.IsRunCold(page.url) else 'warm_') results.AddValue( scalar.ScalarValue( results.current_page, '%stimes.page_load_time' % chart_name_prefix, 'ms', tab.EvaluateJavaScript('__pc_load_time'), description='Average page load time. Measured from ' 'performance.timing.navigationStart until the completion ' 'time of a layout after the window.load event. Cold times ' 'are the times when the page is loaded cold, i.e. without ' 'loading it before, and warm times are times when the ' 'page is loaded after being loaded previously.')) self._has_loaded_page[page.url] += 1 self._power_metric.Stop(page, tab) self._memory_metric.Stop(page, tab) self._memory_metric.AddResults(tab, results) self._power_metric.AddResults(tab, results) self._cpu_metric.Stop(page, tab) self._cpu_metric.AddResults(tab, results) if self._report_speed_index: def SpeedIndexIsFinished(): return self._speedindex_metric.IsFinished(tab) util.WaitFor(SpeedIndexIsFinished, 60) self._speedindex_metric.Stop(page, tab) self._speedindex_metric.AddResults(tab, results, chart_name=chart_name_prefix + 'speed_index') keychain_metric.KeychainMetric().AddResults(tab, results)
def AddResultsForCorsBypass(self, tab, results): eligible_response_count = 0 bypass_count = 0 bypasses = {} for resp in self.IterResponses(tab): logging.warn('got a resource %s' % (resp.response.url)) for resp in self.IterResponses(tab): if resp.ShouldHaveChromeProxyViaHeader(): eligible_response_count += 1 if not resp.HasChromeProxyViaHeader(): bypass_count += 1 elif resp.response.status == 502: bypasses[resp.response.url] = 0 for resp in self.IterResponses(tab): if resp.ShouldHaveChromeProxyViaHeader(): if not resp.HasChromeProxyViaHeader(): if resp.response.status == 200: if (bypasses.has_key(resp.response.url)): bypasses[resp.response. url] = bypasses[resp.response.url] + 1 for url in bypasses: if bypasses[url] == 0: raise ChromeProxyMetricException, ( '%s: Got a 502 without a subsequent 200' % (url)) elif bypasses[url] > 1: raise ChromeProxyMetricException, ( '%s: Got a 502 and multiple 200s: %d' % (url, bypasses[url])) if bypass_count == 0: raise ChromeProxyMetricException, ( 'At least one response should be bypassed. ' '(eligible_response_count=%d, bypass_count=%d)\n' % (eligible_response_count, bypass_count)) results.AddValue( scalar.ScalarValue(results.current_page, 'cors_bypass', 'count', bypass_count))
def MeasurePage(self, page, tab, results): media_metric = tab.EvaluateJavaScript('window.__testMetrics') trace = media_metric['id'] if 'id' in media_metric else None metrics = media_metric['metrics'] if 'metrics' in media_metric else [] for m in metrics: trace_name = '%s.%s' % (m, trace) if isinstance(metrics[m], list): results.AddValue( list_of_scalar_values.ListOfScalarValues( results.current_page, trace_name, units='ms', values=[float(v) for v in metrics[m]], important=True)) else: results.AddValue( scalar.ScalarValue(results.current_page, trace_name, units='ms', value=float(metrics[m]), important=True))
def AddResultsForBypass(self, tab, results): bypass_count = 0 for resp in self.IterResponses(tab): if resp.HasChromeProxyViaHeader(): r = resp.response raise ChromeProxyMetricException, ( '%s: Should not have Via header (%s) (refer=%s, status=%d)' % (r.url, r.GetHeader('Via'), r.GetHeader('Referer'), r.status)) bypass_count += 1 if tab: info = GetProxyInfoFromNetworkInternals(tab) if not info['enabled']: raise ChromeProxyMetricException, ( 'Chrome proxy should be enabled. proxy info: %s' % info) _, expected_bad_proxies = self.IsProxyBypassed(tab) self.VerifyBadProxies(info['badProxies'], expected_bad_proxies) results.AddValue( scalar.ScalarValue(results.current_page, 'bypass', 'count', bypass_count))
def testAsDictWithOnePage(self): results = page_test_results.PageTestResults() results.telemetry_info.benchmark_start_epoch = 1501773200 results.telemetry_info.benchmark_name = 'benchmark_name' results.WillRunPage(self._story_set[0]) v0 = scalar.ScalarValue( results.current_page, 'foo', 'seconds', 3, improvement_direction=improvement_direction.DOWN) results.AddValue(v0) results.DidRunPage(self._story_set[0]) d = json_3_output_formatter.ResultsAsDict(results) self.assertTrue(_HasBenchmark(d['tests'], 'benchmark_name')) self.assertTrue(_HasStory(d['tests']['benchmark_name'], 'Foo')) story_result = d['tests']['benchmark_name']['Foo'] self.assertEquals(story_result['actual'], 'PASS') self.assertEquals(story_result['expected'], 'PASS') self.assertEquals(d['num_failures_by_type'], {'PASS': 1})
def _ComputeFrameTimeDiscrepancy(self, page, stats): """Returns a Value for the absolute discrepancy of frame time stamps.""" frame_discrepancy = None none_value_reason = None if self._HasEnoughFrames(stats.frame_timestamps): frame_discrepancy = round(statistics.TimestampsDiscrepancy( stats.frame_timestamps), 4) else: none_value_reason = NOT_ENOUGH_FRAMES_MESSAGE return scalar.ScalarValue( page, 'frame_time_discrepancy', 'ms', frame_discrepancy, description='Absolute discrepancy of frame time stamps, where ' 'discrepancy is a measure of irregularity. It quantifies ' 'the worst jank. For a single pause, discrepancy ' 'corresponds to the length of this pause in milliseconds. ' 'Consecutive pauses increase the discrepancy. This metric ' 'is important because even if the mean and 95th ' 'percentile are good, one long pause in the middle of an ' 'interaction is still bad.', none_value_reason=none_value_reason, improvement_direction=improvement_direction.DOWN)
def testPopulateHistogramSet_UsesScalarValueData(self): results = page_test_results.PageTestResults() results.telemetry_info.benchmark_start_epoch = 1501773200 results.WillRunPage(self.pages[0]) results.AddValue( scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3, improvement_direction=improvement_direction.UP)) results.DidRunPage(self.pages[0]) results.CleanUp() benchmark_metadata = benchmark.BenchmarkMetadata( 'benchmark_name', 'benchmark_description') results.PopulateHistogramSet(benchmark_metadata) histogram_dicts = results.AsHistogramDicts() self.assertEquals(1, len(histogram_dicts)) h = histogram_module.Histogram.FromDict(histogram_dicts[0]) self.assertEquals('a', h.name)
def _AddResultsInternal(self, events, interactions, results, inputs): times_by_event_id = collections.defaultdict(list) for event in events: if not any(interaction.start <= event.start <= interaction.end for interaction in interactions): continue event_id = TraceEventStatsInput.GetEventId(event.category, event.name) times_by_event_id[event_id].append( self.ThreadDurationIfPresent(event)) if not times_by_event_id: return inputs_by_event_id = dict([[input_obj.event_id, input_obj] for input_obj in inputs]) for (event_name, times) in times_by_event_id.iteritems(): input_for_event = inputs_by_event_id[event_name] name = input_for_event.metric_name results.AddValue( scalar.ScalarValue(page=results.current_page, tir_label=interactions[0].label, name=name + '-count', units='count', value=len(times), description='The number of times ' + name + ' was recorded.')) if len(times) == 0: continue results.AddValue( list_of_scalar_values.ListOfScalarValues( page=results.current_page, tir_label=interactions[0].label, name=name, units=input_for_event.units, values=times, description=input_for_event.metric_description))
def testSkipValueCannotBeFiltered(self): def AcceptValueNamed_a(value, _): return value.name == 'a' results = page_test_results.PageTestResults( value_can_be_added_predicate=AcceptValueNamed_a) results.WillRunPage(self.pages[0]) skip_value = skip.SkipValue(self.pages[0], 'skip for testing') results.AddValue( scalar.ScalarValue(self.pages[0], 'b', 'seconds', 8, improvement_direction=improvement_direction.UP)) results.AddValue(skip_value) results.DidRunPage(self.pages[0]) results.PrintSummary() # Although predicate says only accept value with named 'a', skip value is # added anyway. self.assertEquals(len(results.all_page_specific_values), 1) self.assertIn(skip_value, results.all_page_specific_values)
def testPopulateHistogramSet_UsesScalarValueData(self): benchmark_metadata = benchmark.BenchmarkMetadata( 'benchmark_name', 'benchmark_description') results = page_test_results.PageTestResults( benchmark_metadata=benchmark_metadata) results.telemetry_info.benchmark_start_epoch = 1501773200 results.WillRunPage(self.pages[0]) results.AddValue( scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3, improvement_direction=improvement_direction.UP)) results.DidRunPage(self.pages[0]) results.CleanUp() results.PopulateHistogramSet() hs = histogram_set.HistogramSet() hs.ImportDicts(results.AsHistogramDicts()) self.assertEquals(1, len(hs)) self.assertEquals('a', hs.GetFirstHistogram().name)
def _ComputeFirstGestureScrollUpdateLatency(self, page, stats): """Returns a Value for the first gesture scroll update latency.""" first_gesture_scroll_update_latency = None none_value_reason = None if self._HasEnoughFrames(stats.frame_timestamps): latency_list = FlattenList(stats.gesture_scroll_update_latency) if len(latency_list) == 0: return () first_gesture_scroll_update_latency = round(latency_list[0], 4) else: none_value_reason = NOT_ENOUGH_FRAMES_MESSAGE return (scalar.ScalarValue( page, 'first_gesture_scroll_update_latency', 'ms', first_gesture_scroll_update_latency, description= 'First gesture scroll update latency measures the time it ' 'takes to process the very first gesture scroll update ' 'input event. The first scroll gesture can often get ' 'delayed by work related to page loading.', none_value_reason=none_value_reason), )
def _ComputeMeanPixelsApproximated(self, page, stats): """Add the mean percentage of pixels approximated. This looks at tiles which are missing or of low or non-ideal resolution. """ mean_pixels_approximated = None none_value_reason = None if self._HasEnoughFrames(stats.frame_timestamps): mean_pixels_approximated = round( statistics.ArithmeticMean( perf_tests_helper.FlattenList( stats.approximated_pixel_percentages)), 3) else: none_value_reason = NOT_ENOUGH_FRAMES_MESSAGE return scalar.ScalarValue( page, 'mean_pixels_approximated', 'percent', mean_pixels_approximated, description='Percentage of pixels that were approximated ' '(checkerboarding, low-resolution tiles, etc.).', none_value_reason=none_value_reason)
def ValidateAndMeasurePage(self, page, tab, results): tab.WaitForJavaScriptCondition( 'document.title.indexOf("Results") != -1', timeout=700) tab.WaitForDocumentReadyStateToBeComplete() self._power_metric.Stop(page, tab) self._power_metric.AddResults(tab, results) result_dict = json.loads( tab.EvaluateJavaScript(""" var formElement = document.getElementsByTagName("input")[0]; decodeURIComponent(formElement.value.split("?")[1]); """)) total = 0 for key in result_dict: if key == 'v': continue results.AddValue( list_of_scalar_values.ListOfScalarValues( results.current_page, key, 'ms', result_dict[key], important=False, description=DESCRIPTIONS.get(key))) total += _Mean(result_dict[key]) # TODO(tonyg/nednguyen): This measurement shouldn't calculate Total. The # results system should do that for us. results.AddValue( scalar.ScalarValue( results.current_page, 'Total', 'ms', total, description='Total of the means of the results for each type ' 'of benchmark in [Mozilla\'s Kraken JavaScript benchmark]' '(http://krakenbenchmark.mozilla.org/)'))
def _ComputeFrameTimeMetric(self, prefix, page, frame_timestamps, frame_times): """Returns Values for the frame time metrics. This includes the raw and mean frame times, as well as the percentage of frames that were hitting 60 fps. """ flatten_frame_times = None percentage_smooth = None none_value_reason = None if self._HasEnoughFrames(frame_timestamps): flatten_frame_times = perf_tests_helper.FlattenList(frame_times) # We use 17ms as a somewhat looser threshold, instead of 1000.0/60.0. smooth_threshold = 17.0 smooth_count = sum(1 for t in flatten_frame_times if t < smooth_threshold) percentage_smooth = float(smooth_count) / len( flatten_frame_times) * 100.0 else: none_value_reason = NOT_ENOUGH_FRAMES_MESSAGE return (list_of_scalar_values.ListOfScalarValues( page, '%sframe_times' % prefix, 'ms', flatten_frame_times, description='List of raw frame times, helpful to understand the ' 'other metrics.', none_value_reason=none_value_reason, improvement_direction=improvement_direction.DOWN), scalar.ScalarValue( page, '%spercentage_smooth' % prefix, 'score', percentage_smooth, description= 'Percentage of frames that were hitting 60 fps.', none_value_reason=none_value_reason, improvement_direction=improvement_direction.UP))
def testStoryRunSkipped(self): run = story_run.StoryRun(self.story) run.SetFailed('oops') run.Skip('test', is_expected=True) self.assertFalse(run.ok) self.assertFalse(run.failed) self.assertTrue(run.skipped) self.assertEquals(run.expected, 'SKIP') self.assertEquals(run.failure_str, 'oops') run = story_run.StoryRun(self.story) run.AddValue( scalar.ScalarValue(self.story, 'a', 's', 1, improvement_direction=improvement_direction.UP)) run.Skip('test', is_expected=False) self.assertFalse(run.ok) self.assertFalse(run.failed) self.assertTrue(run.skipped) self.assertEquals(run.expected, 'PASS') self.assertEquals(run.failure_str, None)
def TranslateScalarValue(scalar_value, page): # Parses scalarDicts created by: # tracing/tracing/metrics/metric_map_function.html # back into ScalarValue's. value = scalar_value['numeric']['value'] none_value_reason = None if value is None: none_value_reason = 'Common scalar contained None' elif value in ['Infinity', '-Infinity', 'NaN']: none_value_reason = 'value was %s' % value value = None name = scalar_value['name'] unit_parts = scalar_value['numeric']['unit'].split('_') if len(unit_parts) != 2: raise ValueError('Must specify improvement direction for value ' + name) return scalar.ScalarValue(page, name, unit_parts[0], value, description=scalar_value['description'], none_value_reason=none_value_reason, improvement_direction=_DIRECTION[unit_parts[1]])
def testFailureValueCannotBeFiltered(self): def AcceptValueNamed_a(value, _): return value.name == 'a' results = page_test_results.PageTestResults( value_can_be_added_predicate=AcceptValueNamed_a) results.WillRunPage(self.pages[0]) results.AddValue( scalar.ScalarValue(self.pages[0], 'b', 'seconds', 8, improvement_direction=improvement_direction.UP)) failure_value = failure.FailureValue.FromMessage( self.pages[0], 'failure') results.AddValue(failure_value) results.DidRunPage(self.pages[0]) results.PrintSummary() # Although predicate says only accept values named 'a', the failure value is # added anyway. self.assertEquals(len(results.all_page_specific_values), 1) self.assertIn(failure_value, results.all_page_specific_values)
def AddResultsForHTTPSBypass(self, tab, results): bypass_count = 0 for resp in self.IterResponses(tab): # Only check https url's if "https://" not in resp.response.url: continue # If a Chrome Proxy Via appears fail the test if resp.HasChromeProxyViaHeader(): r = resp.response raise ChromeProxyMetricException, ( '%s: Should not have Via header (%s) (refer=%s, status=%d)' % ( r.url, r.GetHeader('Via'), r.GetHeader('Referer'), r.status)) bypass_count += 1 if bypass_count == 0: raise ChromeProxyMetricException, ( 'Expected at least one https response was expected, but zero such ' 'responses were received.') results.AddValue(scalar.ScalarValue( results.current_page, 'bypass', 'count', bypass_count))
def ValidateAndMeasurePage(self, page, tab, results): tab.WaitForJavaScriptExpression( '!document.getElementById("start-performance-tests").disabled', 60) tab.ExecuteJavaScript(""" window.__results = {}; window.console.log = function(str) { if (!str) return; var key_val = str.split(': '); if (!key_val.length == 2) return; __results[key_val[0]] = key_val[1]; }; document.getElementById('start-performance-tests').click(); """) num_results = 0 num_tests_in_spaceport = 24 while num_results < num_tests_in_spaceport: tab.WaitForJavaScriptExpression( 'Object.keys(window.__results).length > %d' % num_results, 180) num_results = tab.EvaluateJavaScript( 'Object.keys(window.__results).length') logging.info('Completed test %d of %d' % (num_results, num_tests_in_spaceport)) result_dict = eval(tab.EvaluateJavaScript( 'JSON.stringify(window.__results)')) for key in result_dict: chart, trace = key.split('.', 1) results.AddValue(scalar.ScalarValue( results.current_page, '%s.%s'% (chart, trace), 'objects (bigger is better)', float(result_dict[key]), important=False, description=DESCRIPTIONS.get(chart))) results.AddValue(list_of_scalar_values.ListOfScalarValues( results.current_page, 'Score', 'objects (bigger is better)', [float(x) for x in result_dict.values()], description='Combined score for all parts of the spaceport benchmark.'))
def AddResultsForHTTPFallback(self, tab, results, expected_proxies=None, expected_bad_proxies=None): info = GetProxyInfoFromNetworkInternals(tab) if not 'enabled' in info or not info['enabled']: raise ChromeProxyMetricException, ( 'Chrome proxy should be enabled. proxy info: %s' % info) if not expected_proxies: expected_proxies = [ self.effective_proxies['fallback'], self.effective_proxies['direct'] ] if not expected_bad_proxies: expected_bad_proxies = [] proxies = info['proxies'] if proxies != expected_proxies: raise ChromeProxyMetricException, ( 'Wrong effective proxies (%s). Expect: "%s"' % (str(proxies), str(expected_proxies))) bad_proxies = [] if 'badProxies' in info and info['badProxies']: bad_proxies = [ p['proxy'] for p in info['badProxies'] if 'proxy' in p and p['proxy'] ] if bad_proxies != expected_bad_proxies: raise ChromeProxyMetricException, ( 'Wrong bad proxies (%s). Expect: "%s"' % (str(bad_proxies), str(expected_bad_proxies))) results.AddValue( scalar.ScalarValue(results.current_page, 'http_fallback', 'boolean', True))
def AddOneResult(metric, unit): if metric in exclude_metrics: return metrics = media_metric['metrics'] for m in metrics: if m.startswith(metric): special_label = m[len(metric):] trace_name = '%s.%s%s' % (metric, trace, special_label) if isinstance(metrics[m], list): results.AddValue( list_of_scalar_values.ListOfScalarValues( results.current_page, trace_name, unit, values=[float(v) for v in metrics[m]], important=True)) else: results.AddValue( scalar.ScalarValue(results.current_page, trace_name, unit, value=float(metrics[m]), important=True))
def testBasicSummaryWithOnlyOnePage(self): page0 = self.pages[0] results = self.getPageTestResults() results.WillRunPage(page0) v0 = scalar.ScalarValue(page0, 'a', 'seconds', 3, improvement_direction=improvement_direction.UP) results.AddValue(v0) results.DidRunPage(page0) summary = summary_module.Summary(results) values = summary.interleaved_computed_per_page_values_and_summaries v0_list = list_of_scalar_values.ListOfScalarValues( page0, 'a', 'seconds', [3], improvement_direction=improvement_direction.UP) merged_list = list_of_scalar_values.ListOfScalarValues( None, 'a', 'seconds', [3], improvement_direction=improvement_direction.UP) self.assertEquals(2, len(values)) self.assertIn(v0_list, values) self.assertIn(merged_list, values)
def testBasic(self): formatter = html_output_formatter.HtmlOutputFormatter( self._output, reset_results=False) results = page_test_results.PageTestResults() results.WillRunPage(self._story_set[0]) v0 = scalar.ScalarValue( results.current_page, 'foo', 'seconds', 3, improvement_direction=improvement_direction.DOWN) results.AddValue(v0) results.DidRunPage(self._story_set[0]) results.PopulateHistogramSet() formatter.Format(results) html = self._output.getvalue() dicts = render_histograms_viewer.ReadExistingResults(html) histograms = histogram_set.HistogramSet() histograms.ImportDicts(dicts) self.assertEqual(len(histograms), 1) self.assertEqual(histograms.GetFirstHistogram().name, 'foo')
def ValidateAndMeasurePage(self, page, tab, results): # Wait until the page has loaded and come to a somewhat steady state. # Needs to be adjusted for every device (~2 seconds for workstation). time.sleep(self.options.start_wait_time) # Enqueue benchmark tab.ExecuteJavaScript(""" window.benchmark_results = {}; window.benchmark_results.done = false; chrome.gpuBenchmarking.runMicroBenchmark( "picture_record_benchmark", function(value) { window.benchmark_results.done = true; window.benchmark_results.results = value; }, [{width: 1, height: 1}, {width: 250, height: 250}, {width: 500, height: 500}, {width: 750, height: 750}, {width: 1000, height: 1000}, {width: 256, height: 1024}, {width: 1024, height: 256}]); """) tab.WaitForJavaScriptExpression('window.benchmark_results.done', 300) all_data = tab.EvaluateJavaScript('window.benchmark_results.results') for data in all_data: width = data['width'] height = data['height'] area = width * height time_ms = data['time_ms'] results.AddValue( scalar.ScalarValue(results.current_page, 'area_%07d_%dx%d' % (area, width, height), 'ms', time_ms))
def ValidateAndMeasurePage(self, page, tab, results): del page # unused timeline_data = tab.browser.platform.tracing_controller.StopTracing() # TODO(charliea): This is part of a three-sided Chromium/Telemetry patch # where we're changing the return type of StopTracing from a TraceValue to a # (TraceValue, nonfatal_exception_list) tuple. Once the tuple return value # lands in Chromium, the non-tuple logic should be deleted. if isinstance(timeline_data, tuple): timeline_data = timeline_data[0] timeline_model = model.TimelineModel(timeline_data) pt_avg = self.ComputeAverageOfDurations( timeline_model, 'LayerTreeHostCommon::ComputeVisibleRectsWithPropertyTrees') results.AddValue( scalar.ScalarValue( results.current_page, 'PT_avg_cost', 'ms', pt_avg, description='Average time spent processing property trees'))
def AddResults(self, tab, results, chart_name=None): """Calculate the speed index and add it to the results.""" try: if tab.video_capture_supported: index = self._impl.CalculateSpeedIndex(tab) none_value_reason = None else: index = None none_value_reason = 'Video capture is not supported.' finally: self._impl = None # Release the tab so that it can be disconnected. results.AddValue( scalar.ScalarValue( results.current_page, '%s_speed_index' % chart_name, 'ms', index, description= 'Speed Index. This focuses on time when visible parts of ' 'page are displayed and shows the time when the ' 'first look is "almost" composed. If the contents of the ' 'testing page are composed by only static resources, load ' 'time can measure more accurately and speed index will be ' 'smaller than the load time. On the other hand, If the ' 'contents are composed by many XHR requests with small ' 'main resource and javascript, speed index will be able to ' 'get the features of performance more accurately than load ' 'time because the load time will measure the time when ' 'static resources are loaded. If you want to get more ' 'detail, please refer to http://goo.gl/Rw3d5d. Currently ' 'there are two implementations: for Android and for ' 'Desktop. The Android version uses video capture; the ' 'Desktop one uses paint events and has extra overhead to ' 'catch paint events.', none_value_reason=none_value_reason))
def testDifferentPageMergeSingleValueStillMerges(self): page0 = self.pages[0] all_values = [ scalar.ScalarValue( page0, 'x', 'units', 1, improvement_direction=improvement_direction.DOWN) ] # Sort the results so that their order is predictable for the subsequent # assertions. merged_values = merge_values.MergeLikeValuesFromDifferentPages( all_values) self.assertEquals(1, len(merged_values)) self.assertEquals((None, 'x'), (merged_values[0].page, merged_values[0].name)) self.assertTrue( isinstance(merged_values[0], list_of_scalar_values.ListOfScalarValues)) self.assertEquals([1], merged_values[0].values)
def AddResults(self, tab, results, trace_name='cpu_utilization'): if not self._browser.supports_cpu_metrics: return assert self._stop_cpu, 'Must call Stop() first' cpu_stats = _SubtractCpuStats(self._stop_cpu, self._start_cpu) # FIXME: Renderer process CPU times are impossible to compare correctly. # http://crbug.com/419786#c11 if 'Renderer' in cpu_stats: del cpu_stats['Renderer'] # Add a result for each process type. for process_type in cpu_stats: trace_name_for_process = '%s_%s' % (trace_name, process_type.lower()) cpu_percent = 100 * cpu_stats[process_type] results.AddValue( scalar.ScalarValue(results.current_page, 'cpu_utilization.%s' % trace_name_for_process, '%', cpu_percent, important=False))
def AddResultsForHTTPFallback(self, tab, results): via_fallback_count = 0 for resp in self.IterResponses(tab): if resp.ShouldHaveChromeProxyViaHeader(): # All responses should have come through the HTTP fallback proxy, which # means that they should have the via header, and if a remote port is # defined, it should be port 80. if (not resp.HasChromeProxyViaHeader() or (resp.remote_port and resp.remote_port != 80)): r = resp.response raise ChromeProxyMetricException, ( '%s: Should have come through the fallback proxy.\n' 'Reponse: remote_port=%s status=(%d, %s)\nHeaders:\n %s' % ( r.url, str(resp.remote_port), r.status, r.status_text, r.headers)) via_fallback_count += 1 if via_fallback_count == 0: raise ChromeProxyMetricException, ( 'Expected at least one response through the fallback proxy, but zero ' 'such responses were received.') results.AddValue(scalar.ScalarValue( results.current_page, 'via_fallback', 'count', via_fallback_count))