[Predator] Add maximum number argument to delta test.

appengine/findit/util_scripts/crash_queries/delta_test/delta_test.py

 # Copyright 2016 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 json
 import os
 import pickle
 import subprocess
 
 from crash_queries import crash_iterator
@@ skipping 166 matching lines @@
   # ``run-predator``.
   with open(result_path) as f:
     return pickle.load(f)
 
   return {}
 
 
 # TODO(crbug.com/662540): Add unittests.
 def DeltaEvaluator(git_hash1, git_hash2,
                    client_id, app_id,
-                   start_date, end_date, batch_size,
+                   start_date, end_date, batch_size, max_n,
                    property_values=None, verbose=False):  # pragma: no cover.
   """Evaluates delta between git_hash1 and git_hash2 on a set of Testcases.
 
   Args:
     git_hash1 (str): A git hash of findit repository.
     git_hash2 (str): A git hash of findit repository.
     start_date (str): Run delta test on testcases after (including)
       the start_date, format should be '%Y-%m-%d'.
     end_date (str): Run delta test on testcases before (not including)
       the end_date, format should be '%Y-%m-%d'.
     client_id (CrashClient): Possible values are 'fracas', 'cracas',
       'cluterfuzz'.
     app_id (str): Appengine app id to query.
     batch_size (int): Size of a batch that can be queried at one time.
+    max_n: (int): Maximum total number of crashes.
     property_values (dict): Property values to query.
     batch_size (int): The size of crashes that can be queried at one time.
     verbose (bool): If True, print all the findit results.
   Return:
     (deltas, crash_count).
     deltas (dict): Mappings id to delta for each culprit value.
     crash_count (int): Total count of all the crashes.
   """
   head_branch_name = subprocess.check_output(
       ['git', 'rev-parse', '--abbrev-ref', 'HEAD']).replace('\n', '')
   try:
     deltas = {}
     crash_count = 0
     # Iterate batches of crash informations.
     for index, crashes in enumerate(
         crash_iterator.CachedCrashIterator(client_id, app_id,
                                            fields=CRASH_FIELDS,
                                            property_values=property_values,
                                            start_date=start_date,
                                            end_date=end_date,
                                            batch_size=batch_size,
                                            batch_run=True)):
+      # Truncates the crashes and make it contains at most max_n crashes.

[lijeffrey, 2017/01/24 02:22:49]

nit: Truncate crashes and make it contain at most max_n crashes.

[Sharu Jiang, 2017/01/25 19:17:29]

Done.

+      if crash_count + len(crashes) > max_n:
+        crashes = crashes[:(max_n - crash_count)]
+
       results = []
       for git_hash in [git_hash1, git_hash2]:
+        # Generate result path to store culprit results for this batch.
         result_path = os.path.join(
             PREDATOR_RESULTS_DIRECTORY, delta_util.GenerateFileName(
                 client_id, property_values, start_date, end_date,
-                batch_size, index, git_hash))
+                batch_size, index, max_n, git_hash))
         # Get the culprit results of this batch of crashes.
         results.append(GetResults(crashes, client_id, app_id,
                                   git_hash, result_path,
                                   verbose=verbose))
 
       crash_count += len(crashes)
       # Compute delta between 2 versions of culprit results for this batch.
       batch_deltas = GetDeltasFromTwoSetsOfResults(*results)
       # Print the deltas of the current batch.
       print '========= Delta of this batch ========='
       delta_util.PrintDelta(batch_deltas, len(crashes), app_id)
       deltas.update(batch_deltas)
+      if crash_count >= max_n:
+        break
 
     return deltas, crash_count
   finally:
     with open(os.devnull, 'w') as null_handle:
       subprocess.check_call(['git', 'checkout', head_branch_name],
                             stdout=null_handle,
                             stderr=null_handle)