[Android] Remove emma coverage logic for instrumentation tests.

build/android/pylib/instrumentation/test_runner.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.
 
 """Runs the Java tests. See more information on run_instrumentation_tests.py."""
 
 import logging
 import os
 import re
 import shutil
@@ skipping 30 matching lines @@
     test_files += [
         'net/data/ssl/certificates/',
     ]
   return test_files
 
 
 class TestRunner(base_test_runner.BaseTestRunner):
   """Responsible for running a series of tests connected to a single device."""
 
   _DEVICE_DATA_DIR = 'chrome/test/data'
-  _EMMA_JAR = os.path.join(os.environ.get('ANDROID_BUILD_TOP', ''),
-                           'external/emma/lib/emma.jar')
-  _COVERAGE_MERGED_FILENAME = 'unittest_coverage.es'
-  _COVERAGE_WEB_ROOT_DIR = os.environ.get('EMMA_WEB_ROOTDIR')
-  _COVERAGE_FILENAME = 'coverage.ec'
-  _COVERAGE_RESULT_PATH = ('/data/data/com.google.android.apps.chrome/files/' +
-                           _COVERAGE_FILENAME)
-  _COVERAGE_META_INFO_PATH = os.path.join(os.environ.get('ANDROID_BUILD_TOP',
-                                                         ''),
-                                          'out/target/common/obj/APPS',
-                                          'Chrome_intermediates/coverage.em')
   _HOSTMACHINE_PERF_OUTPUT_FILE = '/tmp/chrome-profile'
   _DEVICE_PERF_OUTPUT_SEARCH_PREFIX = (constants.DEVICE_PERF_OUTPUT_DIR +
                                        '/chrome-profile*')
   _DEVICE_HAS_TEST_FILES = {}
 
-  def __init__(self, options, device, shard_index, coverage, test_pkg,
+  def __init__(self, options, device, shard_index, test_pkg,
                ports_to_forward, is_uiautomator_test=False):
     """Create a new TestRunner.
 
     Args:
       options: An options object with the following required attributes:
       -  build_type: 'Release' or 'Debug'.
       -  install_apk: Re-installs the apk if opted.
       -  save_perf_json: Whether or not to save the JSON file from UI perf
             tests.
       -  screenshot_failures: Take a screenshot for a test failure
       -  tool: Name of the Valgrind tool.
       -  wait_for_debugger: blocks until the debugger is connected.
       -  disable_assertions: Whether to disable java assertions on the device.
       device: Attached android device.
       shard_index: Shard index.
-      coverage: Collects coverage information if opted.
       test_pkg: A TestPackage object.
       ports_to_forward: A list of port numbers for which to set up forwarders.
                         Can be optionally requested by a test case.
       is_uiautomator_test: Whether this is a uiautomator test.
-    Raises:
-      Exception: if coverage metadata is not available.
     """
     super(TestRunner, self).__init__(device, options.tool, options.build_type)
     self._lighttp_port = constants.LIGHTTPD_RANDOM_PORT_FIRST + shard_index
 
     self.build_type = options.build_type
     self.test_data = options.test_data
     self.save_perf_json = options.save_perf_json
     self.screenshot_failures = options.screenshot_failures
     self.wait_for_debugger = options.wait_for_debugger
     self.disable_assertions = options.disable_assertions
-    self.coverage = coverage
     self.test_pkg = test_pkg
     self.ports_to_forward = ports_to_forward
     self.is_uiautomator_test = is_uiautomator_test
     if self.is_uiautomator_test:
       self.package_name = options.package_name
     else:
       self.install_apk = options.install_apk
 
     self.forwarder = None
 
-    if self.coverage:
-      if os.path.exists(TestRunner._COVERAGE_MERGED_FILENAME):
-        os.remove(TestRunner._COVERAGE_MERGED_FILENAME)
-      if not os.path.exists(TestRunner._COVERAGE_META_INFO_PATH):
-        raise Exception('FATAL ERROR in ' + sys.argv[0] +
-                        ' : Coverage meta info [' +
-                        TestRunner._COVERAGE_META_INFO_PATH +
-                        '] does not exist.')
-      if (not TestRunner._COVERAGE_WEB_ROOT_DIR or
-          not os.path.exists(TestRunner._COVERAGE_WEB_ROOT_DIR)):
-        raise Exception('FATAL ERROR in ' + sys.argv[0] +
-                        ' : Path specified in $EMMA_WEB_ROOTDIR [' +
-                        TestRunner._COVERAGE_WEB_ROOT_DIR +
-                        '] does not exist.')
-
   #override.
   def PushDependencies(self):
     # TODO(frankf): Implement a general approach for copying/installing
     # once across test runners.
     if TestRunner._DEVICE_HAS_TEST_FILES.get(self.device, False):
       logging.warning('Already copied test files to device %s, skipping.',
                       self.device)
       return
 
     test_data = _GetDataFilesForTestSuite(self.test_pkg.GetApkName())
@@ skipping 12 matching lines @@
       host_test_files_path = constants.CHROME_DIR + '/' + host_src
       if os.path.exists(host_test_files_path):
         self.adb.PushIfNeeded(host_test_files_path,
                               self.adb.GetExternalStorage() + '/' +
                               TestRunner._DEVICE_DATA_DIR + '/' + dst_layer)
     if self.is_uiautomator_test or self.install_apk:
       self.test_pkg.Install(self.adb)
     self.tool.CopyFiles()
     TestRunner._DEVICE_HAS_TEST_FILES[self.device] = True
 
-  def SaveCoverageData(self, test):
-    """Saves the Emma coverage data before it's overwritten by the next test.
-
-    Args:
-      test: the test whose coverage data is collected.
-    """
-    if not self.coverage:
-      return
-    if not self.adb.Adb().Pull(TestRunner._COVERAGE_RESULT_PATH,
-                               constants.CHROME_DIR):
-      logging.error('ERROR: Unable to find file ' +
-                    TestRunner._COVERAGE_RESULT_PATH +
-                    ' on the device for test ' + test)
-    pulled_coverage_file = os.path.join(constants.CHROME_DIR,
-                                        TestRunner._COVERAGE_FILENAME)
-    if os.path.exists(TestRunner._COVERAGE_MERGED_FILENAME):
-      cmd = ['java', '-classpath', TestRunner._EMMA_JAR, 'emma', 'merge',
-             '-in', pulled_coverage_file,
-             '-in', TestRunner._COVERAGE_MERGED_FILENAME,
-             '-out', TestRunner._COVERAGE_MERGED_FILENAME]
-      cmd_helper.RunCmd(cmd)
-    else:
-      shutil.copy(pulled_coverage_file,
-                  TestRunner._COVERAGE_MERGED_FILENAME)
-    os.remove(pulled_coverage_file)
-
-  def GenerateCoverageReportIfNeeded(self):
-    """Uses the Emma to generate a coverage report and a html page."""
-    if not self.coverage:
-      return
-    cmd = ['java', '-classpath', TestRunner._EMMA_JAR,
-           'emma', 'report', '-r', 'html',
-           '-in', TestRunner._COVERAGE_MERGED_FILENAME,
-           '-in', TestRunner._COVERAGE_META_INFO_PATH]
-    cmd_helper.RunCmd(cmd)
-    new_dir = os.path.join(TestRunner._COVERAGE_WEB_ROOT_DIR,
-                           time.strftime('Coverage_for_%Y_%m_%d_%a_%H:%M'))
-    shutil.copytree('coverage', new_dir)
-
-    latest_dir = os.path.join(TestRunner._COVERAGE_WEB_ROOT_DIR,
-                              'Latest_Coverage_Run')
-    if os.path.exists(latest_dir):
-      shutil.rmtree(latest_dir)
-    os.mkdir(latest_dir)
-    webserver_new_index = os.path.join(new_dir, 'index.html')
-    webserver_new_files = os.path.join(new_dir, '_files')
-    webserver_latest_index = os.path.join(latest_dir, 'index.html')
-    webserver_latest_files = os.path.join(latest_dir, '_files')
-    # Setup new softlinks to last result.
-    os.symlink(webserver_new_index, webserver_latest_index)
-    os.symlink(webserver_new_files, webserver_latest_files)
-    cmd_helper.RunCmd(['chmod', '755', '-R', latest_dir, new_dir])
-
   def _GetInstrumentationArgs(self):
     ret = {}
-    if self.coverage:
-      ret['coverage'] = 'true'
     if self.wait_for_debugger:
       ret['debug'] = 'true'
     return ret
 
   def _TakeScreenshot(self, test):
     """Takes a screenshot from the device."""
     screenshot_name = os.path.join(constants.SCREENSHOTS_DIR, test + '.png')
     logging.info('Taking screenshot named %s', screenshot_name)
     self.adb.TakeScreenshot(screenshot_name)
 
@@ skipping 18 matching lines @@
       # forwarder will stomp on them otherwise.
       port_pairs.append(http_server_ports)
       self.forwarder = forwarder.Forwarder(self.adb, self.build_type)
       self.forwarder.Run(port_pairs, self.tool, '127.0.0.1')
     self.flags.AddFlags(['--enable-test-intents'])
 
   def TearDown(self):
     """Cleans up the test harness and saves outstanding data from test run."""
     if self.forwarder:
       self.forwarder.Close()
-    self.GenerateCoverageReportIfNeeded()
     super(TestRunner, self).TearDown()
 
   def TestSetup(self, test):
     """Sets up the test harness for running a particular test.
 
     Args:
       test: The name of the test that will be run.
     """
     self.SetupPerfMonitoringIfNeeded(test)
     self._SetupIndividualTestTimeoutScale(test)
@@ skipping 21 matching lines @@
     """
     if not self._IsPerfTest(test):
       return
     self.adb.Adb().SendCommand('shell rm ' +
                                TestRunner._DEVICE_PERF_OUTPUT_SEARCH_PREFIX)
     self.adb.StartMonitoringLogcat()
 
   def TestTeardown(self, test, raw_result):
     """Cleans up the test harness after running a particular test.
 
-    Depending on the options of this TestRunner this might handle coverage
-    tracking or performance tracking.  This method will only be called if the
-    test passed.
+    Depending on the options of this TestRunner this might handle performance
+    tracking.  This method will only be called if the test passed.
 
     Args:
       test: The name of the test that was just run.
       raw_result: result for this test.
     """
 
     self.tool.CleanUpEnvironment()
 
     # The logic below relies on the test passing.
     if not raw_result or raw_result.GetStatusCode():
       return
 
     self.TearDownPerfMonitoring(test)
-    self.SaveCoverageData(test)
 
   def TearDownPerfMonitoring(self, test):
     """Cleans up performance monitoring if the specified test required it.
 
     Args:
       test: The name of the test that was just run.
     Raises:
       Exception: if there's anything wrong with the perf data.
     """
     if not self._IsPerfTest(test):
@@ skipping 140 matching lines @@
         duration_ms = 0
       message = str(e)
       if not message:
         message = 'No information.'
       results.AddResult(test_result.InstrumentationTestResult(
           test, base_test_result.ResultType.CRASH, start_date_ms, duration_ms,
           log=message))
       raw_result = None
     self.TestTeardown(test, raw_result)
     return (results, None if results.DidRunPass() else test)