telemetry: Remove PageTest support from benchmark_runner

tools/telemetry/telemetry/benchmark_runner.py

 # Copyright 2013 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.
 
 """Parses the command line, discovers the appropriate tests, and runs them.
 
 Handles test configuration, but all the logic for
 actually running the test is in Test and PageRunner."""
 
 import hashlib
 import inspect
 import json
 import os
 import sys
 
 from telemetry import benchmark
 from telemetry import decorators
 from telemetry.core import browser_finder
 from telemetry.core import browser_options
 from telemetry.core import command_line
 from telemetry.core import discover
 from telemetry.core import environment
 from telemetry.core import util
 from telemetry.page import page_set
-from telemetry.page import page_test
-from telemetry.page import profile_creator
 from telemetry.util import find_dependencies
 
 
 class Deps(find_dependencies.FindDependenciesCommand):
   """Prints all dependencies"""
 
   def Run(self, args):
     main_module = sys.modules['__main__']
     args.positional_args.append(os.path.realpath(main_module.__file__))
     return super(Deps, self).Run(args)
@@ skipping 62 matching lines @@
         f.write(_GetJsonTestList(possible_browser, possible_reference_browser,
                                  args.tests, args.num_shards))
     else:
       _PrintTestList(args.tests)
     return 0
 
 
 class Run(command_line.OptparseCommand):
   """Run one or more tests (default)"""
 
   usage = 'test_name [page_set] [<options>]'

[nednguyen, 2014/10/16 02:25:31]

Remove [page_set]. I would also change the word "test" to "benchmark"

 
   @classmethod
   def CreateParser(cls):
     options = browser_options.BrowserFinderOptions()
     parser = options.CreateParser('%%prog %s %s' % (cls.Name(), cls.usage))
     return parser
 
   @classmethod
   def AddCommandLineArgs(cls, parser):
     benchmark.AddCommandLineArgs(parser)
@@ skipping 26 matching lines @@
       sys.exit(-1)
 
     if len(matching_tests) > 1:
       print >> sys.stderr, 'Multiple tests named "%s".' % input_test_name
       print >> sys.stderr, 'Did you mean one of these?'
       print >> sys.stderr
       _PrintTestList(matching_tests)
       sys.exit(-1)
 
     test_class = matching_tests.pop()
-    if issubclass(test_class, page_test.PageTest):
-      if len(args.positional_args) < 2:
-        parser.error('Need to specify a page set for "%s".' % test_class.Name())
-      if len(args.positional_args) > 2:
-        parser.error('Too many arguments.')
-      page_set_name = args.positional_args[1]
-      page_set_class = _MatchPageSetName(page_set_name)
-      if page_set_class is None:
-        parser.error("Page set %s not found. Available sets:\n%s" %
-                     (page_set_name, _AvailablePageSetNamesString()))
-
-      class TestWrapper(benchmark.Benchmark):
-        test = test_class
-
-        @classmethod
-        def CreatePageSet(cls, options):
-          return page_set_class()
-
-      test_class = TestWrapper
-    else:
-      if len(args.positional_args) > 1:
-        parser.error('Too many arguments.')
+    if len(args.positional_args) > 1:
+      parser.error('Too many arguments.')
 
     assert issubclass(test_class, benchmark.Benchmark), (
         'Trying to run a non-Benchmark?!')
 
     benchmark.ProcessCommandLineArgs(parser, args)
     test_class.ProcessCommandLineArgs(parser, args)
 
     cls._test = test_class
 
   def Run(self, args):
@@ skipping 11 matching lines @@
       continue
     if not issubclass(cls, command_line.Command):
       continue
     yield cls
 
 def _MatchingCommands(string):
   return [command for command in _Commands()
          if command.Name().startswith(string)]
 
 @decorators.Cache
 def _Tests():

[nednguyen, 2014/10/16 02:25:31]

s/_Tests/_Benchmarks. 

[ernstm, 2014/10/16 17:54:28]

Done.

   tests = []
   for base_dir in config.base_paths:
     tests += discover.DiscoverClasses(base_dir, base_dir, benchmark.Benchmark,
                                       index_by_class_name=True).values()
-    page_tests = discover.DiscoverClasses(base_dir, base_dir,
-                                          page_test.PageTest,
-                                          index_by_class_name=True).values()
-    tests += [test_class for test_class in page_tests
-              if not issubclass(test_class, profile_creator.ProfileCreator)]
   return tests
 
 
 # TODO(ariblue): Use discover.py's abstracted _MatchName class (in pending CL
 # 432543003) and eliminate _MatchPageSetName and _MatchTestName.
 def _MatchPageSetName(input_name):

[nednguyen, 2014/10/16 02:25:31]

Remove this?

[ernstm, 2014/10/16 17:54:28]

Done.

   page_sets = []
   for base_dir in config.base_paths:
     page_sets += discover.DiscoverClasses(base_dir, base_dir, page_set.PageSet,
                                           index_by_class_name=True).values()
   for p in page_sets:
     if input_name == p.Name():
       return p
   return None
 
 
 def _AvailablePageSetNamesString():

[nednguyen, 2014/10/16 02:25:31]

Dead code.

[ernstm, 2014/10/16 17:54:28]

Done.

   result = ""
   for base_dir in config.base_paths:
     for p in discover.DiscoverClasses(base_dir, base_dir, page_set.PageSet,
                                       index_by_class_name=True).values():
       result += p.Name() + "\n"
   return result
 
 
 def _MatchTestName(input_test_name, exact_matches=True):

[nednguyen, 2014/10/16 02:25:31]

_MatchBenchmarkName

[ernstm, 2014/10/16 17:54:28]

Done.

   def _Matches(input_string, search_string):
     if search_string.startswith(input_string):
       return True
     for part in search_string.split('.'):
       if part.startswith(input_string):
         return True
     return False
 
   # Exact matching.
   if exact_matches:
@@ skipping 79 matching lines @@
 
   filtered_tests = [test_class for test_class in tests
                     if issubclass(test_class, benchmark.Benchmark)]
   if filtered_tests:
     print >> sys.stderr, 'Available tests are:'
     for test_class in sorted(filtered_tests, key=lambda t: t.Name()):
       print >> sys.stderr, format_string % (
           test_class.Name(), test_class.Description())
     print >> sys.stderr
 
-  filtered_tests = [test_class for test_class in tests
-                    if issubclass(test_class, page_test.PageTest)]
-  if filtered_tests:
-    print >> sys.stderr, 'Available page tests are:'
-    for test_class in sorted(filtered_tests, key=lambda t: t.Name()):
-      print >> sys.stderr, format_string % (
-          test_class.Name(), test_class.Description())
-    print >> sys.stderr
-
 
 config = environment.Environment([util.GetBaseDir()])
 
 
 def main():
   # Get the command name from the command line.
   if len(sys.argv) > 1 and sys.argv[1] == '--help':
     sys.argv[1] = 'help'
 
   command_name = 'run'
@@ skipping 18 matching lines @@
 
   # Parse and run the command.
   parser = command.CreateParser()
   command.AddCommandLineArgs(parser)
   options, args = parser.parse_args()
   if commands:
     args = args[1:]
   options.positional_args = args
   command.ProcessCommandLineArgs(parser, options)
   return command().Run(options)