/development/testrunner/test_defs/instrumentation_test.py
Python | 364 lines | 225 code | 38 blank | 101 comment | 47 complexity | 80c08dd590a0c2e9091d5f046e9c5aca MD5 | raw file
- #!/usr/bin/python2.4
- #
- #
- # Copyright 2008, The Android Open Source Project
- #
- # Licensed under the Apache License, Version 2.0 (the "License");
- # you may not use this file except in compliance with the License.
- # You may obtain a copy of the License at
- #
- # http://www.apache.org/licenses/LICENSE-2.0
- #
- # Unless required by applicable law or agreed to in writing, software
- # distributed under the License is distributed on an "AS IS" BASIS,
- # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- # See the License for the specific language governing permissions and
- # limitations under the License.
- """TestSuite definition for Android instrumentation tests."""
- import os
- import re
- # local imports
- import android_manifest
- from coverage import coverage
- import errors
- import logger
- import test_suite
- class InstrumentationTestSuite(test_suite.AbstractTestSuite):
- """Represents a java instrumentation test suite definition run on device."""
- DEFAULT_RUNNER = "android.test.InstrumentationTestRunner"
- def __init__(self):
- test_suite.AbstractTestSuite.__init__(self)
- self._package_name = None
- self._runner_name = self.DEFAULT_RUNNER
- self._class_name = None
- self._target_name = None
- self._java_package = None
- def GetPackageName(self):
- return self._package_name
- def SetPackageName(self, package_name):
- self._package_name = package_name
- return self
- def GetRunnerName(self):
- return self._runner_name
- def SetRunnerName(self, runner_name):
- self._runner_name = runner_name
- return self
- def GetClassName(self):
- return self._class_name
- def SetClassName(self, class_name):
- self._class_name = class_name
- return self
- def GetJavaPackageFilter(self):
- return self._java_package
- def SetJavaPackageFilter(self, java_package_name):
- """Configure the suite to only run tests in given java package."""
- self._java_package = java_package_name
- return self
- def GetTargetName(self):
- """Retrieve module that this test is targeting.
- Used for generating code coverage metrics.
- Returns:
- the module target name
- """
- return self._target_name
- def SetTargetName(self, target_name):
- self._target_name = target_name
- return self
- def GetBuildDependencies(self, options):
- if options.coverage_target_path:
- return [options.coverage_target_path]
- return []
- def Run(self, options, adb):
- """Run the provided test suite.
- Builds up an adb instrument command using provided input arguments.
- Args:
- options: command line options to provide to test run
- adb: adb_interface to device under test
- Raises:
- errors.AbortError: if fatal error occurs
- """
- test_class = self.GetClassName()
- if options.test_class is not None:
- test_class = options.test_class.lstrip()
- if test_class.startswith("."):
- test_class = self.GetPackageName() + test_class
- if options.test_method is not None:
- test_class = "%s#%s" % (test_class, options.test_method)
- test_package = self.GetJavaPackageFilter()
- if options.test_package:
- test_package = options.test_package
- if test_class and test_package:
- logger.Log('Error: both class and java package options are specified')
- instrumentation_args = {}
- if test_class is not None:
- instrumentation_args["class"] = test_class
- if test_package:
- instrumentation_args["package"] = test_package
- if options.test_size:
- instrumentation_args["size"] = options.test_size
- if options.wait_for_debugger:
- instrumentation_args["debug"] = "true"
- if options.suite_assign_mode:
- instrumentation_args["suiteAssignment"] = "true"
- if options.coverage:
- instrumentation_args["coverage"] = "true"
- if options.test_annotation:
- instrumentation_args["annotation"] = options.test_annotation
- if options.test_not_annotation:
- instrumentation_args["notAnnotation"] = options.test_not_annotation
- if options.preview:
- adb_cmd = adb.PreviewInstrumentationCommand(
- package_name=self.GetPackageName(),
- runner_name=self.GetRunnerName(),
- raw_mode=options.raw_mode,
- instrumentation_args=instrumentation_args)
- logger.Log(adb_cmd)
- elif options.coverage:
- coverage_gen = coverage.CoverageGenerator(adb)
- if options.coverage_target_path:
- coverage_target = coverage_gen.GetCoverageTargetForPath(options.coverage_target_path)
- elif self.GetTargetName():
- coverage_target = coverage_gen.GetCoverageTarget(self.GetTargetName())
- self._CheckInstrumentationInstalled(adb)
- # need to parse test output to determine path to coverage file
- logger.Log("Running in coverage mode, suppressing test output")
- try:
- (test_results, status_map) = adb.StartInstrumentationForPackage(
- package_name=self.GetPackageName(),
- runner_name=self.GetRunnerName(),
- timeout_time=60*60,
- instrumentation_args=instrumentation_args)
- except errors.InstrumentationError, errors.DeviceUnresponsiveError:
- return
- self._PrintTestResults(test_results)
- device_coverage_path = status_map.get("coverageFilePath", None)
- if device_coverage_path is None:
- logger.Log("Error: could not find coverage data on device")
- return
- coverage_file = coverage_gen.ExtractReport(
- self.GetName(), coverage_target, device_coverage_path,
- test_qualifier=options.test_size)
- if coverage_file is not None:
- logger.Log("Coverage report generated at %s" % coverage_file)
- else:
- self._CheckInstrumentationInstalled(adb)
- adb.StartInstrumentationNoResults(package_name=self.GetPackageName(),
- runner_name=self.GetRunnerName(),
- raw_mode=options.raw_mode,
- instrumentation_args=
- instrumentation_args)
- def _CheckInstrumentationInstalled(self, adb):
- if not adb.IsInstrumentationInstalled(self.GetPackageName(),
- self.GetRunnerName()):
- msg=("Could not find instrumentation %s/%s on device. Try forcing a "
- "rebuild by updating a source file, and re-executing runtest." %
- (self.GetPackageName(), self.GetRunnerName()))
- raise errors.AbortError(msg=msg)
- def _PrintTestResults(self, test_results):
- """Prints a summary of test result data to stdout.
- Args:
- test_results: a list of am_instrument_parser.TestResult
- """
- total_count = 0
- error_count = 0
- fail_count = 0
- for test_result in test_results:
- if test_result.GetStatusCode() == -1: # error
- logger.Log("Error in %s: %s" % (test_result.GetTestName(),
- test_result.GetFailureReason()))
- error_count+=1
- elif test_result.GetStatusCode() == -2: # failure
- logger.Log("Failure in %s: %s" % (test_result.GetTestName(),
- test_result.GetFailureReason()))
- fail_count+=1
- total_count+=1
- logger.Log("Tests run: %d, Failures: %d, Errors: %d" %
- (total_count, fail_count, error_count))
- def HasInstrumentationTest(path):
- """Determine if given path defines an instrumentation test.
- Args:
- path: file system path to instrumentation test.
- """
- manifest_parser = android_manifest.CreateAndroidManifest(path)
- if manifest_parser:
- return manifest_parser.GetInstrumentationNames()
- return False
- class InstrumentationTestFactory(test_suite.AbstractTestFactory):
- """A factory for creating InstrumentationTestSuites"""
- def __init__(self, test_root_path, build_path):
- test_suite.AbstractTestFactory.__init__(self, test_root_path,
- build_path)
- def CreateTests(self, sub_tests_path=None):
- """Create tests found in test_path.
- Will create a single InstrumentationTestSuite based on info found in
- AndroidManifest.xml found at build_path. Will set additional filters if
- test_path refers to a java package or java class.
- """
- tests = []
- class_name_arg = None
- java_package_name = None
- if sub_tests_path:
- # if path is java file, populate class name
- if self._IsJavaFile(sub_tests_path):
- class_name_arg = self._GetClassNameFromFile(sub_tests_path)
- logger.SilentLog('Using java test class %s' % class_name_arg)
- elif self._IsJavaPackage(sub_tests_path):
- java_package_name = self._GetPackageNameFromDir(sub_tests_path)
- logger.SilentLog('Using java package %s' % java_package_name)
- try:
- manifest_parser = android_manifest.AndroidManifest(app_path=
- self.GetTestsRootPath())
- instrs = manifest_parser.GetInstrumentationNames()
- if not instrs:
- logger.Log('Could not find instrumentation declarations in %s at %s' %
- (android_manifest.AndroidManifest.FILENAME,
- self.GetBuildPath()))
- return tests
- elif len(instrs) > 1:
- logger.Log("Found multiple instrumentation declarations in %s/%s. "
- "Only using first declared." %
- (self.GetBuildPath(),
- android_manifest.AndroidManifest.FILENAME))
- instr_name = manifest_parser.GetInstrumentationNames()[0]
- # escape inner class names
- instr_name = instr_name.replace('$', '\$')
- pkg_name = manifest_parser.GetPackageName()
- if instr_name.find(".") < 0:
- instr_name = "." + instr_name
- logger.SilentLog('Found instrumentation %s/%s' % (pkg_name, instr_name))
- suite = InstrumentationTestSuite()
- suite.SetPackageName(pkg_name)
- suite.SetBuildPath(self.GetBuildPath())
- suite.SetRunnerName(instr_name)
- suite.SetName(pkg_name)
- suite.SetClassName(class_name_arg)
- suite.SetJavaPackageFilter(java_package_name)
- # this is a bit of a hack, assume if 'com.android.cts' is in
- # package name, this is a cts test
- # this logic can be removed altogether when cts tests no longer require
- # custom build steps
- if suite.GetPackageName().startswith('com.android.cts'):
- suite.SetSuite('cts')
- tests.append(suite)
- return tests
- except:
- logger.Log('Could not find or parse %s at %s' %
- (android_manifest.AndroidManifest.FILENAME,
- self.GetBuildPath()))
- return tests
- def _IsJavaFile(self, path):
- """Returns true if given file system path is a java file."""
- return os.path.isfile(path) and self._IsJavaFileName(path)
- def _IsJavaFileName(self, filename):
- """Returns true if given file name is a java file name."""
- return os.path.splitext(filename)[1] == '.java'
- def _IsJavaPackage(self, path):
- """Returns true if given file path is a java package.
- Currently assumes if any java file exists in this directory, than it
- represents a java package.
- Args:
- path: file system path of directory to check
- Returns:
- True if path is a java package
- """
- if not os.path.isdir(path):
- return False
- for file_name in os.listdir(path):
- if self._IsJavaFileName(file_name):
- return True
- return False
- def _GetClassNameFromFile(self, java_file_path):
- """Gets the fully qualified java class name from path.
- Args:
- java_file_path: file system path of java file
- Returns:
- fully qualified java class name or None.
- """
- package_name = self._GetPackageNameFromFile(java_file_path)
- if package_name:
- filename = os.path.basename(java_file_path)
- class_name = os.path.splitext(filename)[0]
- return '%s.%s' % (package_name, class_name)
- return None
- def _GetPackageNameFromDir(self, path):
- """Gets the java package name associated with given directory path.
- Caveat: currently just parses defined java package name from first java
- file found in directory.
- Args:
- path: file system path of directory
- Returns:
- the java package name or None
- """
- for filename in os.listdir(path):
- if self._IsJavaFileName(filename):
- return self._GetPackageNameFromFile(os.path.join(path, filename))
- def _GetPackageNameFromFile(self, java_file_path):
- """Gets the java package name associated with given java file path.
- Args:
- java_file_path: file system path of java file
- Returns:
- the java package name or None
- """
- logger.SilentLog('Looking for java package name in %s' % java_file_path)
- re_package = re.compile(r'package\s+(.*);')
- file_handle = open(java_file_path, 'r')
- for line in file_handle:
- match = re_package.match(line)
- if match:
- return match.group(1)
- return None