Beispiel #1
0
    def MeasurePage(self, page, tab, results):
        tab.WaitForJavaScriptExpression(
            'completed && !document.getElementById("progress-bar-container")',
            1200)

        self._power_metric.Stop(page, tab)
        self._power_metric.AddResults(tab, results)

        results_log = tab.EvaluateJavaScript('__results')
        all_scores = []
        for output in results_log:
            # Split the results into score and test name.
            # results log e.g., "Richards: 18343"
            score_and_name = output.split(': ', 2)
            assert len(score_and_name) == 2, \
              'Unexpected result format "%s"' % score_and_name
            if 'Skipped' not in score_and_name[1]:
                name = score_and_name[0]
                score = int(score_and_name[1])
                results.Add(name, 'score', score, data_type='unimportant')
                # Collect all test scores to compute geometric mean.
                all_scores.append(score)
        total = statistics.GeometricMean(all_scores)
        results.AddSummaryValue(
            scalar.ScalarValue(None, 'Total.Score', 'score', total))
Beispiel #2
0
  def ValidateAndMeasurePage(self, page, tab, results):
    del page  # unused
    tab.WaitForDocumentReadyStateToBeComplete()
    tab.EvaluateJavaScript('JetStream.start()')
    result = tab.WaitForJavaScriptCondition("""
        (function() {
          for (var i = 0; i < __results.length; i++) {
            if (!__results[i].indexOf('Raw results: ')) return __results[i];
          }
          return null;
        })();
        """, timeout=60*20)
    result = json.loads(result.partition(': ')[2])

    all_score_lists = []
    for k, v in result.iteritems():
      results.AddValue(list_of_scalar_values.ListOfScalarValues(
          results.current_page, k.replace('.', '_'), 'score', v['result'],
          important=False))
      # Collect all test scores to compute geometric mean.
      for i, score in enumerate(v['result']):
        if len(all_score_lists) <= i:
          all_score_lists.append([])
        all_score_lists[i].append(score)
    all_scores = []
    for score_list in all_score_lists:
      all_scores.append(statistics.GeometricMean(score_list))
    results.AddSummaryValue(list_of_scalar_values.ListOfScalarValues(
        None, 'Score', 'score', all_scores))
Beispiel #3
0
  def ValidateAndMeasurePage(self, page, tab, results):
    tab.WaitForJavaScriptExpression('window.completed', 10)
    tab.WaitForJavaScriptExpression(
        '!document.getElementById("progress-bar-container")', 1200)

    self._power_metric.Stop(page, tab)
    self._power_metric.AddResults(tab, results)

    results_log = tab.EvaluateJavaScript('__results')
    all_scores = []
    for output in results_log:
      # Split the results into score and test name.
      # results log e.g., "Richards: 18343"
      score_and_name = output.split(': ', 2)
      assert len(score_and_name) == 2, \
        'Unexpected result format "%s"' % score_and_name
      if 'Skipped' not in score_and_name[1]:
        name = score_and_name[0]
        score = int(score_and_name[1])
        results.AddValue(scalar.ScalarValue(
            results.current_page, name, 'score', score, important=False,
            description=DESCRIPTIONS.get(name)))

        # Collect all test scores to compute geometric mean.
        all_scores.append(score)
    total = statistics.GeometricMean(all_scores)
    results.AddSummaryValue(
        scalar.ScalarValue(None, 'Total.Score', 'score', total,
                           description='Geometric mean of the scores of each '
                                       'individual benchmark in the Octane '
                                       'benchmark collection.'))
Beispiel #4
0
    def ParseTestResults(self, action_runner):
        result = action_runner.WaitForJavaScriptCondition("""
        (function() {
          for (var i = 0; i < __results.length; i++) {
            if (!__results[i].indexOf('Raw results: ')) return __results[i];
          }
          return null;
        })();
        """,
                                                          timeout=60 * 20)
        result = json.loads(result.partition(': ')[2])

        all_score_lists = []
        for k, v in result.iteritems():
            self.AddJavascriptMetricValue(
                list_of_scalar_values.ListOfScalarValues(self,
                                                         k.replace('.', '_'),
                                                         'score',
                                                         v['result'],
                                                         important=False))
            # Collect all test scores to compute geometric mean.
            for i, score in enumerate(v['result']):
                if len(all_score_lists) <= i:
                    all_score_lists.append([])
                all_score_lists[i].append(score)
        all_scores = []
        for score_list in all_score_lists:
            all_scores.append(statistics.GeometricMean(score_list))
        self.AddJavascriptMetricSummaryValue(
            list_of_scalar_values.ListOfScalarValues(None, 'Score', 'score',
                                                     all_scores))
    def MeasurePage(self, page, tab, results):
        get_results_js = """
        (function() {
          for (var i = 0; i < __results.length; i++) {
            if (!__results[i].indexOf('Raw results: ')) return __results[i];
          }
          return null;
        })();
        """

        tab.WaitForDocumentReadyStateToBeComplete()
        tab.EvaluateJavaScript('JetStream.start()')
        tab.WaitForJavaScriptExpression(get_results_js, 600)

        result = tab.EvaluateJavaScript(get_results_js)
        result = json.loads(result.partition(': ')[2])

        all_scores = []
        for k, v in result.iteritems():
            results.Add(k.replace('.', '_'),
                        'score',
                        v['result'],
                        data_type='unimportant')
            # Collect all test scores to compute geometric mean.
            all_scores.extend(v['result'])
        total = statistics.GeometricMean(all_scores)
        results.AddSummaryValue(
            scalar.ScalarValue(None, 'Score', 'score', total))
    def ParseTestResults(self, action_runner):
        results_log = action_runner.EvaluateJavaScript('__results')
        all_scores = []
        for output in results_log:
            # Split the results into score and test name.
            # results log e.g., "Richards: 18343"
            score_and_name = output.split(': ', 2)
            assert len(score_and_name) == 2, \
              'Unexpected result format "%s"' % score_and_name
            if 'Skipped' not in score_and_name[1]:
                name = score_and_name[0]
                score = float(score_and_name[1])
                self.AddMeasurement(name,
                                    'score',
                                    score,
                                    description=DESCRIPTIONS.get(name))

                # Collect all test scores to compute geometric mean.
                all_scores.append(score)
        total = statistics.GeometricMean(all_scores)
        self.AddMeasurement('Total.Score',
                            'score',
                            total,
                            description='Geometric mean of the scores of each '
                            'individual benchmark in the Octane collection.')
Beispiel #7
0
 def DidRunTest(self, browser, results):
     # Calculate geometric mean as the total for the combined tests.
     combined = merge_values.MergeLikeValuesFromDifferentPages(
         results.all_page_specific_values, group_by_name_suffix=True)
     combined_score = [x for x in combined if x.name == 'Score'][0]
     total = statistics.GeometricMean(combined_score.values)
     results.AddSummaryValue(
         scalar.ScalarValue(None, 'Total.Score', 'score', total))