Move bisect-perf-regression.py into auto_bisect directory.

tools/auto_bisect/bisect_perf_regression_test.py

 # 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 os
 import re
 import unittest
 
-from auto_bisect import source_control as source_control_module
+import bisect_perf_regression
+import source_control as source_control_module
 
-# Special import necessary because filename contains dash characters.
-bisect_perf_module = __import__('bisect-perf-regression')
 
 def _GetBisectPerformanceMetricsInstance():
   """Returns an instance of the BisectPerformanceMetrics class."""
   options_dict = {
     'debug_ignore_build': True,
     'debug_ignore_sync': True,
     'debug_ignore_perf_test': True,
     'command': 'fake_command',
     'metric': 'fake/metric',
     'good_revision': 280000,
     'bad_revision': 280005,
   }
-  bisect_options = bisect_perf_module.BisectOptions.FromDict(options_dict)
+  bisect_options = bisect_perf_regression.BisectOptions.FromDict(options_dict)
   source_control = source_control_module.DetermineAndCreateSourceControl(
       bisect_options)
-  bisect_instance = bisect_perf_module.BisectPerformanceMetrics(
+  bisect_instance = bisect_perf_regression.BisectPerformanceMetrics(
       source_control, bisect_options)
-  bisect_instance.src_cwd = os.path.abspath(
-      os.path.join(os.path.dirname(__file__), os.path.pardir))
   return bisect_instance
 
 
 class BisectPerfRegressionTest(unittest.TestCase):
   """Test case for other functions and classes in bisect-perf-regression.py."""
 
   def _AssertConfidence(self, score, bad_values, good_values):
     """Checks whether the given sets of values have a given confidence score.
 
     The score represents our confidence that the two sets of values wouldn't
     be as different as they are just by chance; that is, that some real change
     occurred between the two sets of values.
 
     Args:
       score: Expected confidence score.
       bad_values: First list of numbers.
       good_values: Second list of numbers.
     """
     # ConfidenceScore takes a list of lists but these lists are flattened
     # inside the function.
-    confidence = bisect_perf_module.ConfidenceScore(
+    confidence = bisect_perf_regression.ConfidenceScore(
         [[v] for v in bad_values],
         [[v] for v in good_values])
     self.assertEqual(score, confidence)
 
   def testConfidenceScore_ZeroConfidence(self):
     # The good and bad sets contain the same values, so the confidence that
     # they're different should be zero.
     self._AssertConfidence(0.0, [4, 5, 7, 6, 8, 7], [8, 7, 6, 7, 5, 4])
 
   def testConfidenceScore_MediumConfidence(self):
@@ skipping 58 matching lines @@
 
     # Should only expect SVN/git revisions to come through, and URLs should be
     # filtered out.
     expected_vars_dict = {
         'ffmpeg_hash': '@ac4a9f31fe2610bd146857bbd55d7a260003a888',
         'webkit_rev': '@e01ac0a267d1017288bc67fa3c366b10469d8a24',
         'angle_revision': '74697cf2064c0a2c0d7e1b1b28db439286766a05'
     }
     # Testing private function.
     # pylint: disable=W0212
-    vars_dict = bisect_perf_module._ParseRevisionsFromDEPSFileManually(
+    vars_dict = bisect_perf_regression._ParseRevisionsFromDEPSFileManually(
         deps_file_contents)
     self.assertEqual(vars_dict, expected_vars_dict)
 
   def _AssertParseResult(self, expected_values, result_string):
     """Asserts some values are parsed from a RESULT line."""
     results_template = ('RESULT other_chart: other_trace= 123 count\n'
                         'RESULT my_chart: my_trace= %(value)s\n')
     results = results_template % {'value': result_string}
     metric = ['my_chart', 'my_trace']
     # Testing private function.
     # pylint: disable=W0212
-    values = bisect_perf_module._TryParseResultValuesFromOutput(metric, results)
+    values = bisect_perf_regression._TryParseResultValuesFromOutput(
+        metric, results)
     self.assertEqual(expected_values, values)
 
   def testTryParseResultValuesFromOutput_WithSingleValue(self):
     """Tests result pattern <*>RESULT <graph>: <trace>= <value>"""
     self._AssertParseResult([66.88], '66.88 kb')
     self._AssertParseResult([66.88], '66.88 ')
     self._AssertParseResult([-66.88], '-66.88 kb')
     self._AssertParseResult([66], '66 kb')
     self._AssertParseResult([0.66], '.66 kb')
     self._AssertParseResult([], '. kb')
@@ skipping 31 matching lines @@
 
     This modification to the command is done in order to get a Telemetry
     command that works; before some revisions, the browser name that Telemetry
     expects is different in some cases, but we want it to work anyway.
 
     Specifically, only for android:
       After r276628, only android-chrome-shell works.
       Prior to r274857, only android-chromium-testshell works.
       In the range [274857, 276628], both work.
     """
-    bisect_options = bisect_perf_module.BisectOptions()
+    bisect_options = bisect_perf_regression.BisectOptions()
     bisect_options.output_buildbot_annotations = None
     source_control = source_control_module.DetermineAndCreateSourceControl(
         bisect_options)
-    bisect_instance = bisect_perf_module.BisectPerformanceMetrics(
+    bisect_instance = bisect_perf_regression.BisectPerformanceMetrics(
         source_control, bisect_options)
     bisect_instance.opts.target_platform = target_platform
     git_revision = bisect_instance.source_control.ResolveToRevision(
-        revision, 'chromium', bisect_perf_module.DEPOT_DEPS_NAME, 100)
+        revision, 'chromium', bisect_perf_regression.DEPOT_DEPS_NAME, 100)
     depot = 'chromium'
     command = bisect_instance.GetCompatibleCommand(
         original_command, git_revision, depot)
     self.assertEqual(expected_command, command)
 
   def testGetCompatibleCommand_ChangeToTestShell(self):
     # For revisions <= r274857, only android-chromium-testshell is used.
     self._AssertCompatibleCommand(
         'tools/perf/run_benchmark -v --browser=android-chromium-testshell foo',
         'tools/perf/run_benchmark -v --browser=android-chrome-shell foo',
@@ skipping 47 matching lines @@
     self.assertEqual(
         291765, bisect_instance.source_control.GetCommitPosition(cp_git_rev))
 
     svn_git_rev = 'e6db23a037cad47299a94b155b95eebd1ee61a58'
     self.assertEqual(
         291467, bisect_instance.source_control.GetCommitPosition(svn_git_rev))
 
   def testGetCommitPositionForV8(self):
     bisect_instance = _GetBisectPerformanceMetricsInstance()
     v8_rev = '21d700eedcdd6570eff22ece724b63a5eefe78cb'
-    depot_path = os.path.join(bisect_instance.src_cwd, 'src', 'v8')
+    depot_path = os.path.join(bisect_perf_regression.SRC_DIR, 'v8')
     self.assertEqual(
         23634,
         bisect_instance.source_control.GetCommitPosition(v8_rev, depot_path))
 
   def testGetCommitPositionForWebKit(self):
     bisect_instance = _GetBisectPerformanceMetricsInstance()
     wk_rev = 'a94d028e0f2c77f159b3dac95eb90c3b4cf48c61'
-    depot_path = os.path.join(bisect_instance.src_cwd, 'src', 'third_party',
+    depot_path = os.path.join(bisect_perf_regression.SRC_DIR, 'third_party',
                               'WebKit')
     self.assertEqual(
         181660,
         bisect_instance.source_control.GetCommitPosition(wk_rev, depot_path))
 
   def testUpdateDepsContent(self):
     bisect_instance = _GetBisectPerformanceMetricsInstance()
     deps_file = 'DEPS'
     # We are intentionally reading DEPS file contents instead of string literal
     # with few lines from DEPS because to check if the format we are expecting
     # to search is not changed in DEPS content.
     # TODO (prasadv): Add a separate test to validate the DEPS contents with the
     # format that bisect script expects.
-    deps_contents = bisect_perf_module.ReadStringFromFile(deps_file)
+    deps_contents = bisect_perf_regression.ReadStringFromFile(deps_file)
     deps_key = 'v8_revision'
     depot = 'v8'
     git_revision = 'a12345789a23456789a123456789a123456789'
     updated_content = bisect_instance.UpdateDepsContents(
         deps_contents, depot, git_revision, deps_key)
     self.assertIsNotNone(updated_content)
     ss = re.compile('["\']%s["\']: ["\']%s["\']' % (deps_key, git_revision))
     self.assertIsNotNone(re.search(ss, updated_content))
 
 
 if __name__ == '__main__':
   unittest.main()