Remove --performance_test from Android gtest runner.

build/android/pylib/test_package.py

 # Copyright (c) 2012 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 logging
 import re
 import os
 
 import constants
 from perf_tests_helper import PrintPerfResult
 from pylib import pexpect
 from test_result import BaseTestResult, TestResults
 
 from android_commands import errors
 
 
 class TestPackage(object):
   """A helper base class for both APK and stand-alone executables.
 
   Args:
     adb: ADB interface the tests are using.
     device: Device to run the tests.
     test_suite: A specific test suite to run, empty to run all.
     timeout: Timeout for each test.
-    performance_test: Whether or not performance test(s).
     cleanup_test_files: Whether or not to cleanup test files on device.
     tool: Name of the Valgrind tool.
     dump_debug_info: A debug_info object.
   """
 
   def __init__(self, adb, device, test_suite, timeout,
-               performance_test, cleanup_test_files, tool, dump_debug_info):
+               cleanup_test_files, tool, dump_debug_info):
     self.adb = adb
     self.device = device
     self.test_suite_full = test_suite
     self.test_suite = os.path.splitext(test_suite)[0]
     self.test_suite_basename = self._GetTestSuiteBaseName()
     self.test_suite_dirname = os.path.dirname(
         self.test_suite.split(self.test_suite_basename)[0])
-    self.performance_test = performance_test
     self.cleanup_test_files = cleanup_test_files
     self.tool = tool
     if timeout == 0:
       timeout = 60
     # On a VM (e.g. chromium buildbots), this timeout is way too small.
     if os.environ.get('BUILDBOT_SLAVENAME'):
       timeout = timeout * 2
     self.timeout = timeout * self.tool.GetTimeoutScale()
     self.dump_debug_info = dump_debug_info
 
-  def _BeginGetIOStats(self):
-    """Gets I/O statistics before running test.
-
-    Return:
-      I/O stats object.The I/O stats object may be None if the test is not
-      performance test.
-    """
-    initial_io_stats = None
-    # Try to get the disk I/O statistics for all performance tests.
-    if self.performance_test:
-      initial_io_stats = self.adb.GetIoStats()
-    return initial_io_stats
-
-  def _EndGetIOStats(self, initial_io_stats):
-    """Gets I/O statistics after running test and calcuate the I/O delta.
-
-    Args:
-      initial_io_stats: I/O stats object got from _BeginGetIOStats.
-
-    Return:
-      String for formated diso I/O statistics.
-    """
-    disk_io = ''
-    if self.performance_test and initial_io_stats:
-      final_io_stats = self.adb.GetIoStats()
-      for stat in final_io_stats:
-        disk_io += '\n' + PrintPerfResult(stat, stat,
-                                          [final_io_stats[stat] -
-                                           initial_io_stats[stat]],
-                                          stat.split('_')[1],
-                                          print_to_stdout=False)
-      logging.info(disk_io)
-    return disk_io
-
   def GetDisabledPrefixes(self):
     return ['DISABLED_', 'FLAKY_', 'FAILS_']
 
   def _ParseGTestListTests(self, all_tests):
     """Parses and filters the raw test lists.
 
     Args:
     all_tests: The raw test listing with the following format:
 
       IPCChannelTest.
@@ skipping 66 matching lines @@
     overall_fail = False
     re_run = re.compile('\[ RUN      \] ?(.*)\r\n')
     # APK tests rely on the PASSED tag.
     re_passed = re.compile('\[  PASSED  \] ?(.*)\r\n')
     # Signal handlers are installed before starting tests
     # to output the CRASHED marker when a crash happens.
     re_crash = re.compile('\[ CRASHED      \](.*)\r\n')
     re_fail = re.compile('\[  FAILED  \] ?(.*)\r\n')
     re_runner_fail = re.compile('\[ RUNNER_FAILED \] ?(.*)\r\n')
     re_ok = re.compile('\[       OK \] ?(.*?) .*\r\n')
-    io_stats_before = self._BeginGetIOStats()
     try:
       while True:
         found = p.expect([re_run, re_passed, re_runner_fail],
                          timeout=self.timeout)
         if found == 1:  # matched PASSED.
           break
         if found == 2:  # RUNNER_FAILED
           logging.error('RUNNER_FAILED')
           overall_fail = True
           break
@@ skipping 14 matching lines @@
     except pexpect.EOF:
       logging.error('Test terminated - EOF')
       raise errors.DeviceUnresponsiveError('Device may be offline')
     except pexpect.TIMEOUT:
       logging.error('Test terminated after %d second timeout.',
                     self.timeout)
       timed_out = True
     finally:
       p.close()
 
-    ok_tests += self._EndGetIOStats(io_stats_before)
     ret_code = self._GetGTestReturnCode()
     if ret_code:
       failed_tests += [BaseTestResult('gtest exit code: %d' % ret_code,
                                       'pexpect.before: %s'
                                       '\npexpect.after: %s'
                                       % (p.before,
                                          p.after))]
     # Create TestResults and return
     return TestResults.FromRun(ok=ok_tests, failed=failed_tests,
                                crashed=crashed_tests, timed_out=timed_out,
                                overall_fail=overall_fail)