Tools/Scripts/webkitpy/layout_tests/layout_package/json_results_generator.py

   1 # Copyright (C) 2010 Google Inc. All rights reserved.
   2 #
   3 # Redistribution and use in source and binary forms, with or without
   4 # modification, are permitted provided that the following conditions are
   5 # met:
   6 #
   7 #     * Redistributions of source code must retain the above copyright
   8 # notice, this list of conditions and the following disclaimer.
   9 #     * Redistributions in binary form must reproduce the above
  10 # copyright notice, this list of conditions and the following disclaimer
  11 # in the documentation and/or other materials provided with the
  12 # distribution.
  13 #     * Neither the name of Google Inc. nor the names of its
  14 # contributors may be used to endorse or promote products derived from
  15 # this software without specific prior written permission.
  16 #
  17 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 import logging
  30 import os
  31 import subprocess
  32 import sys
  33 import time
  34 import urllib2
  35 import xml.dom.minidom
  36
  37 from webkitpy.common.net.file_uploader import FileUploader
  38
  39 try:
  40     import json
  41 except ImportError:
  42     # python 2.5 compatibility
  43     import webkitpy.thirdparty.simplejson as json
  44
  45 # A JSON results generator for generic tests.
  46 # FIXME: move this code out of the layout_package directory.
  47
  48 _log = logging.getLogger(__name__)
  49
  50 _JSON_PREFIX = "ADD_RESULTS("
  51 _JSON_SUFFIX = ");"
  52
  53
  54 def has_json_wrapper(string):
  55     return string.startswith(_JSON_PREFIX) and string.endswith(_JSON_SUFFIX)
  56
  57
  58 def strip_json_wrapper(json_content):
  59     if has_json_wrapper(json_content):
  60         return json_content[len(_JSON_PREFIX):len(json_content) - len(_JSON_SUFFIX)]
  61     return json_content
  62
  63
  64 def load_json(filesystem, file_path):
  65     content = filesystem.read_text_file(file_path)
  66     content = strip_json_wrapper(content)
  67     return json.loads(content)
  68
  69
  70 def write_json(filesystem, json_object, file_path):
  71     # Specify separators in order to get compact encoding.
  72     json_data = json.dumps(json_object, separators=(',', ':'))
  73     json_string = _JSON_PREFIX + json_data + _JSON_SUFFIX
  74     filesystem.write_text_file(file_path, json_string)
  75
  76
  77 def convert_trie_to_flat_paths(trie, prefix=None):
  78     """Converts the directory structure in the given trie to flat paths, prepending a prefix to each."""
  79     result = {}
  80     for name, data in trie.iteritems():
  81         if prefix:
  82             name = prefix + "/" + name
  83
  84         if len(data) and not "results" in data:
  85             result.update(convert_trie_to_flat_paths(data, name))
  86         else:
  87             result[name] = data
  88
  89     return result
  90
  91
  92 def add_path_to_trie(path, value, trie):
  93     """Inserts a single flat directory path and associated value into a directory trie structure."""
  94     if not "/" in path:
  95         trie[path] = value
  96         return
  97
  98     directory, slash, rest = path.partition("/")
  99     if not directory in trie:
 100         trie[directory] = {}
 101     add_path_to_trie(rest, value, trie[directory])
 102
 103 def test_timings_trie(port, individual_test_timings):
 104     """Breaks a test name into chunks by directory and puts the test time as a value in the lowest part, e.g.
 105     foo/bar/baz.html: 1ms
 106     foo/bar/baz1.html: 3ms
 107
 108     becomes
 109     foo: {
 110         bar: {
 111             baz.html: 1,
 112             baz1.html: 3
 113         }
 114     }
 115     """
 116     trie = {}
 117     for test_result in individual_test_timings:
 118         test = test_result.test_name
 119
 120         add_path_to_trie(test, int(1000 * test_result.test_run_time), trie)
 121
 122     return trie
 123
 124 # FIXME: We already have a TestResult class in test_results.py
 125 class TestResult(object):
 126     """A simple class that represents a single test result."""
 127
 128     # Test modifier constants.
 129     (NONE, FAILS, FLAKY, DISABLED) = range(4)
 130
 131     def __init__(self, test, failed=False, elapsed_time=0):
 132         self.test_name = test
 133         self.failed = failed
 134         self.test_run_time = elapsed_time
 135
 136         test_name = test
 137         try:
 138             test_name = test.split('.')[1]
 139         except IndexError:
 140             _log.warn("Invalid test name: %s.", test)
 141             pass
 142
 143         if test_name.startswith('FAILS_'):
 144             self.modifier = self.FAILS
 145         elif test_name.startswith('FLAKY_'):
 146             self.modifier = self.FLAKY
 147         elif test_name.startswith('DISABLED_'):
 148             self.modifier = self.DISABLED
 149         else:
 150             self.modifier = self.NONE
 151
 152     def fixable(self):
 153         return self.failed or self.modifier == self.DISABLED
 154
 155
 156 class JSONResultsGeneratorBase(object):
 157     """A JSON results generator for generic tests."""
 158
 159     MAX_NUMBER_OF_BUILD_RESULTS_TO_LOG = 750
 160     # Min time (seconds) that will be added to the JSON.
 161     MIN_TIME = 1
 162
 163     # Note that in non-chromium tests those chars are used to indicate
 164     # test modifiers (FAILS, FLAKY, etc) but not actual test results.
 165     PASS_RESULT = "P"
 166     SKIP_RESULT = "X"
 167     FAIL_RESULT = "F"
 168     FLAKY_RESULT = "L"
 169     NO_DATA_RESULT = "N"
 170
 171     MODIFIER_TO_CHAR = {TestResult.NONE: PASS_RESULT,
 172                         TestResult.DISABLED: SKIP_RESULT,
 173                         TestResult.FAILS: FAIL_RESULT,
 174                         TestResult.FLAKY: FLAKY_RESULT}
 175
 176     VERSION = 4
 177     VERSION_KEY = "version"
 178     RESULTS = "results"
 179     TIMES = "times"
 180     BUILD_NUMBERS = "buildNumbers"
 181     TIME = "secondsSinceEpoch"
 182     TESTS = "tests"
 183
 184     FIXABLE_COUNT = "fixableCount"
 185     FIXABLE = "fixableCounts"
 186     ALL_FIXABLE_COUNT = "allFixableCount"
 187
 188     RESULTS_FILENAME = "results.json"
 189     TIMES_MS_FILENAME = "times_ms.json"
 190     INCREMENTAL_RESULTS_FILENAME = "incremental_results.json"
 191
 192     URL_FOR_TEST_LIST_JSON = \
 193         "http://%s/testfile?builder=%s&name=%s&testlistjson=1&testtype=%s"
 194
 195     # FIXME: Remove generate_incremental_results once the reference to it in
 196     # http://src.chromium.org/viewvc/chrome/trunk/tools/build/scripts/slave/gtest_slave_utils.py
 197     # has been removed.
 198     def __init__(self, port, builder_name, build_name, build_number,
 199         results_file_base_path, builder_base_url,
 200         test_results_map, svn_repositories=None,
 201         test_results_server=None,
 202         test_type="",
 203         master_name="",
 204         generate_incremental_results=None):
 205         """Modifies the results.json file. Grabs it off the archive directory
 206         if it is not found locally.
 207
 208         Args
 209           port: port-specific wrapper
 210           builder_name: the builder name (e.g. Webkit).
 211           build_name: the build name (e.g. webkit-rel).
 212           build_number: the build number.
 213           results_file_base_path: Absolute path to the directory containing the
 214               results json file.
 215           builder_base_url: the URL where we have the archived test results.
 216               If this is None no archived results will be retrieved.
 217           test_results_map: A dictionary that maps test_name to TestResult.
 218           svn_repositories: A (json_field_name, svn_path) pair for SVN
 219               repositories that tests rely on.  The SVN revision will be
 220               included in the JSON with the given json_field_name.
 221           test_results_server: server that hosts test results json.
 222           test_type: test type string (e.g. 'layout-tests').
 223           master_name: the name of the buildbot master.
 224         """
 225         self._port = port
 226         self._fs = port._filesystem
 227         self._builder_name = builder_name
 228         self._build_name = build_name
 229         self._build_number = build_number
 230         self._builder_base_url = builder_base_url
 231         self._results_directory = results_file_base_path
 232
 233         self._test_results_map = test_results_map
 234         self._test_results = test_results_map.values()
 235
 236         self._svn_repositories = svn_repositories
 237         if not self._svn_repositories:
 238             self._svn_repositories = {}
 239
 240         self._test_results_server = test_results_server
 241         self._test_type = test_type
 242         self._master_name = master_name
 243
 244         self._archived_results = None
 245
 246     def generate_json_output(self):
 247         json_object = self.get_json()
 248         if json_object:
 249             file_path = self._fs.join(self._results_directory, self.INCREMENTAL_RESULTS_FILENAME)
 250             write_json(self._fs, json_object, file_path)
 251
 252     def generate_times_ms_file(self):
 253         # FIXME: rename to generate_times_ms_file. This needs to be coordinated with
 254         # changing the calls to this on the chromium build slaves.
 255         times = test_timings_trie(self._port, self._test_results_map.values())
 256         file_path = self._fs.join(self._results_directory, self.TIMES_MS_FILENAME)
 257         write_json(self._fs, times, file_path)
 258
 259     def get_json(self):
 260         """Gets the results for the results.json file."""
 261         results_json = {}
 262
 263         if not results_json:
 264             results_json, error = self._get_archived_json_results()
 265             if error:
 266                 # If there was an error don't write a results.json
 267                 # file at all as it would lose all the information on the
 268                 # bot.
 269                 _log.error("Archive directory is inaccessible. Not "
 270                            "modifying or clobbering the results.json "
 271                            "file: " + str(error))
 272                 return None
 273
 274         builder_name = self._builder_name
 275         if results_json and builder_name not in results_json:
 276             _log.debug("Builder name (%s) is not in the results.json file."
 277                        % builder_name)
 278
 279         self._convert_json_to_current_version(results_json)
 280
 281         if builder_name not in results_json:
 282             results_json[builder_name] = (
 283                 self._create_results_for_builder_json())
 284
 285         results_for_builder = results_json[builder_name]
 286
 287         self._insert_generic_metadata(results_for_builder)
 288
 289         self._insert_failure_summaries(results_for_builder)
 290
 291         # Update the all failing tests with result type and time.
 292         tests = results_for_builder[self.TESTS]
 293         all_failing_tests = self._get_failed_test_names()
 294         all_failing_tests.update(convert_trie_to_flat_paths(tests))
 295
 296         for test in all_failing_tests:
 297             self._insert_test_time_and_result(test, tests)
 298
 299         return results_json
 300
 301     def set_archived_results(self, archived_results):
 302         self._archived_results = archived_results
 303
 304     def upload_json_files(self, json_files):
 305         """Uploads the given json_files to the test_results_server (if the
 306         test_results_server is given)."""
 307         if not self._test_results_server:
 308             return
 309
 310         if not self._master_name:
 311             _log.error("--test-results-server was set, but --master-name was not.  Not uploading JSON files.")
 312             return
 313
 314         _log.info("Uploading JSON files for builder: %s", self._builder_name)
 315         attrs = [("builder", self._builder_name),
 316                  ("testtype", self._test_type),
 317                  ("master", self._master_name)]
 318
 319         files = [(file, self._fs.join(self._results_directory, file))
 320             for file in json_files]
 321
 322         url = "http://%s/testfile/upload" % self._test_results_server
 323         uploader = FileUploader(url)
 324         try:
 325             # Set uploading timeout in case appengine server is having problem.
 326             # 120 seconds are more than enough to upload test results.
 327             uploader.upload(attrs, files, 120)
 328         except Exception, err:
 329             _log.error("Upload failed: %s" % err)
 330             return
 331
 332         _log.info("JSON files uploaded.")
 333
 334     def _get_test_timing(self, test_name):
 335         """Returns test timing data (elapsed time) in second
 336         for the given test_name."""
 337         if test_name in self._test_results_map:
 338             # Floor for now to get time in seconds.
 339             return int(self._test_results_map[test_name].test_run_time)
 340         return 0
 341
 342     def _get_failed_test_names(self):
 343         """Returns a set of failed test names."""
 344         return set([r.test_name for r in self._test_results if r.failed])
 345
 346     def _get_modifier_char(self, test_name):
 347         """Returns a single char (e.g. SKIP_RESULT, FAIL_RESULT,
 348         PASS_RESULT, NO_DATA_RESULT, etc) that indicates the test modifier
 349         for the given test_name.
 350         """
 351         if test_name not in self._test_results_map:
 352             return self.__class__.NO_DATA_RESULT
 353
 354         test_result = self._test_results_map[test_name]
 355         if test_result.modifier in self.MODIFIER_TO_CHAR.keys():
 356             return self.MODIFIER_TO_CHAR[test_result.modifier]
 357
 358         return self.__class__.PASS_RESULT
 359
 360     def _get_result_char(self, test_name):
 361         """Returns a single char (e.g. SKIP_RESULT, FAIL_RESULT,
 362         PASS_RESULT, NO_DATA_RESULT, etc) that indicates the test result
 363         for the given test_name.
 364         """
 365         if test_name not in self._test_results_map:
 366             return self.__class__.NO_DATA_RESULT
 367
 368         test_result = self._test_results_map[test_name]
 369         if test_result.modifier == TestResult.DISABLED:
 370             return self.__class__.SKIP_RESULT
 371
 372         if test_result.failed:
 373             return self.__class__.FAIL_RESULT
 374
 375         return self.__class__.PASS_RESULT
 376
 377     # FIXME: Callers should use scm.py instead.
 378     # FIXME: Identify and fix the run-time errors that were observed on Windows
 379     # chromium buildbot when we had updated this code to use scm.py once before.
 380     def _get_svn_revision(self, in_directory):
 381         """Returns the svn revision for the given directory.
 382
 383         Args:
 384           in_directory: The directory where svn is to be run.
 385         """
 386         if self._fs.exists(self._fs.join(in_directory, '.svn')):
 387             # Note: Not thread safe: http://bugs.python.org/issue2320
 388             output = subprocess.Popen(["svn", "info", "--xml"],
 389                                       cwd=in_directory,
 390                                       shell=(sys.platform == 'win32'),
 391                                       stdout=subprocess.PIPE).communicate()[0]
 392             try:
 393                 dom = xml.dom.minidom.parseString(output)
 394                 return dom.getElementsByTagName('entry')[0].getAttribute(
 395                     'revision')
 396             except xml.parsers.expat.ExpatError:
 397                 return ""
 398         return ""
 399
 400     def _get_archived_json_results(self):
 401         """Download JSON file that only contains test
 402         name list from test-results server. This is for generating incremental
 403         JSON so the file generated has info for tests that failed before but
 404         pass or are skipped from current run.
 405
 406         Returns (archived_results, error) tuple where error is None if results
 407         were successfully read.
 408         """
 409         results_json = {}
 410         old_results = None
 411         error = None
 412
 413         if not self._test_results_server:
 414             return {}, None
 415
 416         results_file_url = (self.URL_FOR_TEST_LIST_JSON %
 417             (urllib2.quote(self._test_results_server),
 418              urllib2.quote(self._builder_name),
 419              self.RESULTS_FILENAME,
 420              urllib2.quote(self._test_type)))
 421
 422         try:
 423             # FIXME: We should talk to the network via a Host object.
 424             results_file = urllib2.urlopen(results_file_url)
 425             info = results_file.info()
 426             old_results = results_file.read()
 427         except urllib2.HTTPError, http_error:
 428             # A non-4xx status code means the bot is hosed for some reason
 429             # and we can't grab the results.json file off of it.
 430             if (http_error.code < 400 and http_error.code >= 500):
 431                 error = http_error
 432         except urllib2.URLError, url_error:
 433             error = url_error
 434
 435         if old_results:
 436             # Strip the prefix and suffix so we can get the actual JSON object.
 437             old_results = strip_json_wrapper(old_results)
 438
 439             try:
 440                 results_json = json.loads(old_results)
 441             except:
 442                 _log.debug("results.json was not valid JSON. Clobbering.")
 443                 # The JSON file is not valid JSON. Just clobber the results.
 444                 results_json = {}
 445         else:
 446             _log.debug('Old JSON results do not exist. Starting fresh.')
 447             results_json = {}
 448
 449         return results_json, error
 450
 451     def _insert_failure_summaries(self, results_for_builder):
 452         """Inserts aggregate pass/failure statistics into the JSON.
 453         This method reads self._test_results and generates
 454         FIXABLE, FIXABLE_COUNT and ALL_FIXABLE_COUNT entries.
 455
 456         Args:
 457           results_for_builder: Dictionary containing the test results for a
 458               single builder.
 459         """
 460         # Insert the number of tests that failed or skipped.
 461         fixable_count = len([r for r in self._test_results if r.fixable()])
 462         self._insert_item_into_raw_list(results_for_builder,
 463             fixable_count, self.FIXABLE_COUNT)
 464
 465         # Create a test modifiers (FAILS, FLAKY etc) summary dictionary.
 466         entry = {}
 467         for test_name in self._test_results_map.iterkeys():
 468             result_char = self._get_modifier_char(test_name)
 469             entry[result_char] = entry.get(result_char, 0) + 1
 470
 471         # Insert the pass/skip/failure summary dictionary.
 472         self._insert_item_into_raw_list(results_for_builder, entry,
 473                                         self.FIXABLE)
 474
 475         # Insert the number of all the tests that are supposed to pass.
 476         all_test_count = len(self._test_results)
 477         self._insert_item_into_raw_list(results_for_builder,
 478             all_test_count, self.ALL_FIXABLE_COUNT)
 479
 480     def _insert_item_into_raw_list(self, results_for_builder, item, key):
 481         """Inserts the item into the list with the given key in the results for
 482         this builder. Creates the list if no such list exists.
 483
 484         Args:
 485           results_for_builder: Dictionary containing the test results for a
 486               single builder.
 487           item: Number or string to insert into the list.
 488           key: Key in results_for_builder for the list to insert into.
 489         """
 490         if key in results_for_builder:
 491             raw_list = results_for_builder[key]
 492         else:
 493             raw_list = []
 494
 495         raw_list.insert(0, item)
 496         raw_list = raw_list[:self.MAX_NUMBER_OF_BUILD_RESULTS_TO_LOG]
 497         results_for_builder[key] = raw_list
 498
 499     def _insert_item_run_length_encoded(self, item, encoded_results):
 500         """Inserts the item into the run-length encoded results.
 501
 502         Args:
 503           item: String or number to insert.
 504           encoded_results: run-length encoded results. An array of arrays, e.g.
 505               [[3,'A'],[1,'Q']] encodes AAAQ.
 506         """
 507         if len(encoded_results) and item == encoded_results[0][1]:
 508             num_results = encoded_results[0][0]
 509             if num_results <= self.MAX_NUMBER_OF_BUILD_RESULTS_TO_LOG:
 510                 encoded_results[0][0] = num_results + 1
 511         else:
 512             # Use a list instead of a class for the run-length encoding since
 513             # we want the serialized form to be concise.
 514             encoded_results.insert(0, [1, item])
 515
 516     def _insert_generic_metadata(self, results_for_builder):
 517         """ Inserts generic metadata (such as version number, current time etc)
 518         into the JSON.
 519
 520         Args:
 521           results_for_builder: Dictionary containing the test results for
 522               a single builder.
 523         """
 524         self._insert_item_into_raw_list(results_for_builder,
 525             self._build_number, self.BUILD_NUMBERS)
 526
 527         # Include SVN revisions for the given repositories.
 528         for (name, path) in self._svn_repositories:
 529             self._insert_item_into_raw_list(results_for_builder,
 530                 self._get_svn_revision(path),
 531                 name + 'Revision')
 532
 533         self._insert_item_into_raw_list(results_for_builder,
 534             int(time.time()),
 535             self.TIME)
 536
 537     def _insert_test_time_and_result(self, test_name, tests):
 538         """ Insert a test item with its results to the given tests dictionary.
 539
 540         Args:
 541           tests: Dictionary containing test result entries.
 542         """
 543
 544         result = self._get_result_char(test_name)
 545         time = self._get_test_timing(test_name)
 546
 547         this_test = tests
 548         for segment in test_name.split("/"):
 549             if segment not in this_test:
 550                 this_test[segment] = {}
 551             this_test = this_test[segment]
 552
 553         if not len(this_test):
 554             self._populate_results_and_times_json(this_test)
 555
 556         if self.RESULTS in this_test:
 557             self._insert_item_run_length_encoded(result, this_test[self.RESULTS])
 558         else:
 559             this_test[self.RESULTS] = [[1, result]]
 560
 561         if self.TIMES in this_test:
 562             self._insert_item_run_length_encoded(time, this_test[self.TIMES])
 563         else:
 564             this_test[self.TIMES] = [[1, time]]
 565
 566     def _convert_json_to_current_version(self, results_json):
 567         """If the JSON does not match the current version, converts it to the
 568         current version and adds in the new version number.
 569         """
 570         if self.VERSION_KEY in results_json:
 571             archive_version = results_json[self.VERSION_KEY]
 572             if archive_version == self.VERSION:
 573                 return
 574         else:
 575             archive_version = 3
 576
 577         # version 3->4
 578         if archive_version == 3:
 579             num_results = len(results_json.values())
 580             for builder, results in results_json.iteritems():
 581                 self._convert_tests_to_trie(results)
 582
 583         results_json[self.VERSION_KEY] = self.VERSION
 584
 585     def _convert_tests_to_trie(self, results):
 586         if not self.TESTS in results:
 587             return
 588
 589         test_results = results[self.TESTS]
 590         test_results_trie = {}
 591         for test in test_results.iterkeys():
 592             single_test_result = test_results[test]
 593             add_path_to_trie(test, single_test_result, test_results_trie)
 594
 595         results[self.TESTS] = test_results_trie
 596
 597     def _populate_results_and_times_json(self, results_and_times):
 598         results_and_times[self.RESULTS] = []
 599         results_and_times[self.TIMES] = []
 600         return results_and_times
 601
 602     def _create_results_for_builder_json(self):
 603         results_for_builder = {}
 604         results_for_builder[self.TESTS] = {}
 605         return results_for_builder
 606
 607     def _remove_items_over_max_number_of_builds(self, encoded_list):
 608         """Removes items from the run-length encoded list after the final
 609         item that exceeds the max number of builds to track.
 610
 611         Args:
 612           encoded_results: run-length encoded results. An array of arrays, e.g.
 613               [[3,'A'],[1,'Q']] encodes AAAQ.
 614         """
 615         num_builds = 0
 616         index = 0
 617         for result in encoded_list:
 618             num_builds = num_builds + result[0]
 619             index = index + 1
 620             if num_builds > self.MAX_NUMBER_OF_BUILD_RESULTS_TO_LOG:
 621                 return encoded_list[:index]
 622         return encoded_list
 623
 624     def _normalize_results_json(self, test, test_name, tests):
 625         """ Prune tests where all runs pass or tests that no longer exist and
 626         truncate all results to maxNumberOfBuilds.
 627
 628         Args:
 629           test: ResultsAndTimes object for this test.
 630           test_name: Name of the test.
 631           tests: The JSON object with all the test results for this builder.
 632         """
 633         test[self.RESULTS] = self._remove_items_over_max_number_of_builds(
 634             test[self.RESULTS])
 635         test[self.TIMES] = self._remove_items_over_max_number_of_builds(
 636             test[self.TIMES])
 637
 638         is_all_pass = self._is_results_all_of_type(test[self.RESULTS],
 639                                                    self.PASS_RESULT)
 640         is_all_no_data = self._is_results_all_of_type(test[self.RESULTS],
 641             self.NO_DATA_RESULT)
 642         max_time = max([time[1] for time in test[self.TIMES]])
 643
 644         # Remove all passes/no-data from the results to reduce noise and
 645         # filesize. If a test passes every run, but takes > MIN_TIME to run,
 646         # don't throw away the data.
 647         if is_all_no_data or (is_all_pass and max_time <= self.MIN_TIME):
 648             del tests[test_name]
 649
 650     def _is_results_all_of_type(self, results, type):
 651         """Returns whether all the results are of the given type
 652         (e.g. all passes)."""
 653         return len(results) == 1 and results[0][1] == type
 654
 655
 656 # Left here not to break anything.
 657 class JSONResultsGenerator(JSONResultsGeneratorBase):
 658     pass