• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#!/usr/bin/python2.4
2#
3#
4# Copyright 2008, The Android Open Source Project
5#
6# Licensed under the Apache License, Version 2.0 (the "License");
7# you may not use this file except in compliance with the License.
8# You may obtain a copy of the License at
9#
10#     http://www.apache.org/licenses/LICENSE-2.0
11#
12# Unless required by applicable law or agreed to in writing, software
13# distributed under the License is distributed on an "AS IS" BASIS,
14# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15# See the License for the specific language governing permissions and
16# limitations under the License.
17
18"""TestSuite definition for Android instrumentation tests."""
19
20import os
21import re
22
23# local imports
24import android_manifest
25import coverage
26import errors
27import logger
28import test_suite
29
30
31class InstrumentationTestSuite(test_suite.AbstractTestSuite):
32  """Represents a java instrumentation test suite definition run on device."""
33
34  DEFAULT_RUNNER = "android.test.InstrumentationTestRunner"
35
36  # dependency on libcore (used for Emma)
37  _LIBCORE_BUILD_PATH = "libcore"
38
39  def __init__(self):
40    test_suite.AbstractTestSuite.__init__(self)
41    self._package_name = None
42    self._runner_name = self.DEFAULT_RUNNER
43    self._class_name = None
44    self._target_name = None
45    self._java_package = None
46
47  def GetPackageName(self):
48    return self._package_name
49
50  def SetPackageName(self, package_name):
51    self._package_name = package_name
52    return self
53
54  def GetRunnerName(self):
55    return self._runner_name
56
57  def SetRunnerName(self, runner_name):
58    self._runner_name = runner_name
59    return self
60
61  def GetClassName(self):
62    return self._class_name
63
64  def SetClassName(self, class_name):
65    self._class_name = class_name
66    return self
67
68  def GetJavaPackageFilter(self):
69    return self._java_package
70
71  def SetJavaPackageFilter(self, java_package_name):
72    """Configure the suite to only run tests in given java package."""
73    self._java_package = java_package_name
74    return self
75
76  def GetTargetName(self):
77    """Retrieve module that this test is targeting.
78
79    Used for generating code coverage metrics.
80    Returns:
81      the module target name
82    """
83    return self._target_name
84
85  def SetTargetName(self, target_name):
86    self._target_name = target_name
87    return self
88
89  def GetBuildDependencies(self, options):
90    if options.coverage:
91      return [self._LIBCORE_BUILD_PATH]
92    return []
93
94  def Run(self, options, adb):
95    """Run the provided test suite.
96
97    Builds up an adb instrument command using provided input arguments.
98
99    Args:
100      options: command line options to provide to test run
101      adb: adb_interface to device under test
102
103    Raises:
104      errors.AbortError: if fatal error occurs
105    """
106
107    test_class = self.GetClassName()
108    if options.test_class is not None:
109      test_class = options.test_class.lstrip()
110      if test_class.startswith("."):
111        test_class = self.GetPackageName() + test_class
112    if options.test_method is not None:
113      test_class = "%s#%s" % (test_class, options.test_method)
114
115    test_package = self.GetJavaPackageFilter()
116    if options.test_package:
117      test_package = options.test_package
118
119    if test_class and test_package:
120      logger.Log('Error: both class and java package options are specified')
121
122    instrumentation_args = {}
123    if test_class is not None:
124      instrumentation_args["class"] = test_class
125    if test_package:
126      instrumentation_args["package"] = test_package
127    if options.test_size:
128      instrumentation_args["size"] = options.test_size
129    if options.wait_for_debugger:
130      instrumentation_args["debug"] = "true"
131    if options.suite_assign_mode:
132      instrumentation_args["suiteAssignment"] = "true"
133    if options.coverage:
134      instrumentation_args["coverage"] = "true"
135    if options.test_annotation:
136      instrumentation_args["annotation"] = options.test_annotation
137    if options.test_not_annotation:
138      instrumentation_args["notAnnotation"] = options.test_not_annotation
139    if options.preview:
140      adb_cmd = adb.PreviewInstrumentationCommand(
141          package_name=self.GetPackageName(),
142          runner_name=self.GetRunnerName(),
143          raw_mode=options.raw_mode,
144          instrumentation_args=instrumentation_args)
145      logger.Log(adb_cmd)
146    elif options.coverage:
147      coverage_gen = coverage.CoverageGenerator(adb)
148      adb.WaitForInstrumentation(self.GetPackageName(),
149                                 self.GetRunnerName())
150      # need to parse test output to determine path to coverage file
151      logger.Log("Running in coverage mode, suppressing test output")
152      try:
153        (test_results, status_map) = adb.StartInstrumentationForPackage(
154            package_name=self.GetPackageName(),
155            runner_name=self.GetRunnerName(),
156            timeout_time=60*60,
157            instrumentation_args=instrumentation_args)
158      except errors.InstrumentationError, errors.DeviceUnresponsiveError:
159        return
160      self._PrintTestResults(test_results)
161      device_coverage_path = status_map.get("coverageFilePath", None)
162      if device_coverage_path is None:
163        logger.Log("Error: could not find coverage data on device")
164        return
165
166      coverage_file = coverage_gen.ExtractReport(
167          self, device_coverage_path, test_qualifier=options.test_size)
168      if coverage_file is not None:
169        logger.Log("Coverage report generated at %s" % coverage_file)
170    else:
171      adb.WaitForInstrumentation(self.GetPackageName(),
172                                 self.GetRunnerName())
173      adb.StartInstrumentationNoResults(
174          package_name=self.GetPackageName(),
175          runner_name=self.GetRunnerName(),
176          raw_mode=options.raw_mode,
177          instrumentation_args=instrumentation_args)
178
179  def _PrintTestResults(self, test_results):
180    """Prints a summary of test result data to stdout.
181
182    Args:
183      test_results: a list of am_instrument_parser.TestResult
184    """
185    total_count = 0
186    error_count = 0
187    fail_count = 0
188    for test_result in test_results:
189      if test_result.GetStatusCode() == -1:  # error
190        logger.Log("Error in %s: %s" % (test_result.GetTestName(),
191                                        test_result.GetFailureReason()))
192        error_count+=1
193      elif test_result.GetStatusCode() == -2:  # failure
194        logger.Log("Failure in %s: %s" % (test_result.GetTestName(),
195                                          test_result.GetFailureReason()))
196        fail_count+=1
197      total_count+=1
198    logger.Log("Tests run: %d, Failures: %d, Errors: %d" %
199               (total_count, fail_count, error_count))
200
201
202def HasInstrumentationTest(path):
203  """Determine if given path defines an instrumentation test.
204
205  Args:
206    path: file system path to instrumentation test.
207  """
208  manifest_parser = android_manifest.CreateAndroidManifest(path)
209  if manifest_parser:
210    return manifest_parser.GetInstrumentationNames()
211  return False
212
213class InstrumentationTestFactory(test_suite.AbstractTestFactory):
214  """A factory for creating InstrumentationTestSuites"""
215
216  def __init__(self, test_root_path, build_path):
217    test_suite.AbstractTestFactory.__init__(self, test_root_path,
218                                            build_path)
219
220  def CreateTests(self, sub_tests_path=None):
221    """Create tests found in test_path.
222
223    Will create a single InstrumentationTestSuite based on info found in
224    AndroidManifest.xml found at build_path. Will set additional filters if
225    test_path refers to a java package or java class.
226    """
227    tests = []
228    class_name_arg = None
229    java_package_name = None
230    if sub_tests_path:
231      # if path is java file, populate class name
232      if self._IsJavaFile(sub_tests_path):
233        class_name_arg = self._GetClassNameFromFile(sub_tests_path)
234        logger.SilentLog('Using java test class %s' % class_name_arg)
235      elif self._IsJavaPackage(sub_tests_path):
236        java_package_name = self._GetPackageNameFromDir(sub_tests_path)
237        logger.SilentLog('Using java package %s' % java_package_name)
238    try:
239      manifest_parser = android_manifest.AndroidManifest(app_path=
240                                                         self.GetTestsRootPath())
241      instrs = manifest_parser.GetInstrumentationNames()
242      if not instrs:
243        logger.Log('Could not find instrumentation declarations in %s at %s' %
244                   (android_manifest.AndroidManifest.FILENAME,
245                    self.GetBuildPath()))
246        return tests
247
248      for instr_name in manifest_parser.GetInstrumentationNames():
249        pkg_name = manifest_parser.GetPackageName()
250        if instr_name.find(".") < 0:
251          instr_name = "." + instr_name
252        logger.SilentLog('Found instrumentation %s/%s' % (pkg_name, instr_name))
253        suite = InstrumentationTestSuite()
254        suite.SetPackageName(pkg_name)
255        suite.SetBuildPath(self.GetBuildPath())
256        suite.SetRunnerName(instr_name)
257        suite.SetName(pkg_name)
258        suite.SetClassName(class_name_arg)
259        suite.SetJavaPackageFilter(java_package_name)
260        # this is a bit of a hack, assume if 'com.android.cts' is in
261        # package name, this is a cts test
262        # this logic can be removed altogether when cts tests no longer require
263        # custom build steps
264        if suite.GetPackageName().startswith('com.android.cts'):
265          suite.SetSuite('cts')
266        tests.append(suite)
267      return tests
268
269    except:
270      logger.Log('Could not find or parse %s at %s' %
271                 (android_manifest.AndroidManifest.FILENAME,
272                  self.GetBuildPath()))
273    return tests
274
275  def _IsJavaFile(self, path):
276    """Returns true if given file system path is a java file."""
277    return os.path.isfile(path) and self._IsJavaFileName(path)
278
279  def _IsJavaFileName(self, filename):
280    """Returns true if given file name is a java file name."""
281    return os.path.splitext(filename)[1] == '.java'
282
283  def _IsJavaPackage(self, path):
284    """Returns true if given file path is a java package.
285
286    Currently assumes if any java file exists in this directory, than it
287    represents a java package.
288
289    Args:
290      path: file system path of directory to check
291
292    Returns:
293      True if path is a java package
294    """
295    if not os.path.isdir(path):
296      return False
297    for file_name in os.listdir(path):
298      if self._IsJavaFileName(file_name):
299        return True
300    return False
301
302  def _GetClassNameFromFile(self, java_file_path):
303    """Gets the fully qualified java class name from path.
304
305    Args:
306      java_file_path: file system path of java file
307
308    Returns:
309      fully qualified java class name or None.
310    """
311    package_name = self._GetPackageNameFromFile(java_file_path)
312    if package_name:
313      filename = os.path.basename(java_file_path)
314      class_name = os.path.splitext(filename)[0]
315      return '%s.%s' % (package_name, class_name)
316    return None
317
318  def _GetPackageNameFromDir(self, path):
319    """Gets the java package name associated with given directory path.
320
321    Caveat: currently just parses defined java package name from first java
322    file found in directory.
323
324    Args:
325      path: file system path of directory
326
327    Returns:
328      the java package name or None
329    """
330    for filename in os.listdir(path):
331      if self._IsJavaFileName(filename):
332        return self._GetPackageNameFromFile(os.path.join(path, filename))
333
334  def _GetPackageNameFromFile(self, java_file_path):
335    """Gets the java package name associated with given java file path.
336
337    Args:
338      java_file_path: file system path of java file
339
340    Returns:
341      the java package name or None
342    """
343    logger.SilentLog('Looking for java package name in %s' % java_file_path)
344    re_package = re.compile(r'package\s+(.*);')
345    file_handle = open(java_file_path, 'r')
346    for line in file_handle:
347      match = re_package.match(line)
348      if match:
349        return match.group(1)
350    return None
351