Heap-use-after-free in WebCore::InlineFlowBox::deleteLine due to fullscreen issues.
[WebKit-https.git] / Tools / Scripts / webkitpy / test / main.py
1 # Copyright (C) 2012 Google, Inc.
2 # Copyright (C) 2010 Chris Jerdonek (cjerdonek@webkit.org)
3 #
4 # Redistribution and use in source and binary forms, with or without
5 # modification, are permitted provided that the following conditions
6 # are met:
7 # 1.  Redistributions of source code must retain the above copyright
8 #     notice, this list of conditions and the following disclaimer.
9 # 2.  Redistributions in binary form must reproduce the above copyright
10 #     notice, this list of conditions and the following disclaimer in the
11 #     documentation and/or other materials provided with the distribution.
12 #
13 # THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
14 # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16 # DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
17 # ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
19 # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
20 # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
21 # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
22 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23
24 """unit testing code for webkitpy."""
25
26 import logging
27 import optparse
28 import StringIO
29 import sys
30 import traceback
31 import unittest
32
33 from webkitpy.common.system.filesystem import FileSystem
34 from webkitpy.test.test_finder import TestFinder
35 from webkitpy.test.runner import TestRunner
36
37 _log = logging.getLogger(__name__)
38
39
40 class Tester(object):
41     def __init__(self, filesystem=None):
42         self.finder = TestFinder(filesystem or FileSystem())
43         self.stream = sys.stderr
44
45     def add_tree(self, top_directory, starting_subdirectory=None):
46         self.finder.add_tree(top_directory, starting_subdirectory)
47
48     def _parse_args(self):
49         parser = optparse.OptionParser(usage='usage: %prog [options] [args...]')
50         parser.add_option('-a', '--all', action='store_true', default=False,
51                           help='run all the tests'),
52         parser.add_option('-c', '--coverage', action='store_true', default=False,
53                           help='generate code coverage info (requires http://pypi.python.org/pypi/coverage)'),
54         parser.add_option('-q', '--quiet', action='store_true', default=False,
55                           help='run quietly (errors, warnings, and progress only)'),
56         parser.add_option('-t', '--timing', action='store_true', default=False,
57                           help='display per-test execution time (implies --verbose)'),
58         parser.add_option('-x', '--xml', action='store_true', default=False,
59                           help='output xUnit-style XML output')
60         parser.add_option('-v', '--verbose', action='count', default=0,
61                           help='verbose output (specify once for individual test results, twice for debug messages)')
62         parser.add_option('--skip-integrationtests', action='store_true', default=False,
63                           help='do not run the integration tests')
64
65         parser.epilog = ('[args...] is an optional list of modules, test_classes, or individual tests. '
66                          'If no args are given, all the tests will be run.')
67
68         return parser.parse_args()
69
70     def _configure(self, options):
71         self._options = options
72
73         if options.timing:
74             # --timing implies --verbose
75             options.verbose = max(options.verbose, 1)
76
77         log_level = logging.INFO
78         if options.quiet:
79             log_level = logging.WARNING
80         elif options.verbose == 2:
81             log_level = logging.DEBUG
82         self._configure_logging(log_level)
83
84     def _configure_logging(self, log_level):
85         """Configure the root logger.
86
87         Configure the root logger not to log any messages from webkitpy --
88         except for messages from the autoinstall module.  Also set the
89         logging level as described below.
90         """
91         handler = logging.StreamHandler(self.stream)
92         # We constrain the level on the handler rather than on the root
93         # logger itself.  This is probably better because the handler is
94         # configured and known only to this module, whereas the root logger
95         # is an object shared (and potentially modified) by many modules.
96         # Modifying the handler, then, is less intrusive and less likely to
97         # interfere with modifications made by other modules (e.g. in unit
98         # tests).
99         handler.name = __name__
100         handler.setLevel(log_level)
101         formatter = logging.Formatter("%(message)s")
102         handler.setFormatter(formatter)
103
104         logger = logging.getLogger()
105         logger.addHandler(handler)
106         logger.setLevel(logging.NOTSET)
107
108         # Filter out most webkitpy messages.
109         #
110         # Messages can be selectively re-enabled for this script by updating
111         # this method accordingly.
112         def filter(record):
113             """Filter out autoinstall and non-third-party webkitpy messages."""
114             # FIXME: Figure out a way not to use strings here, for example by
115             #        using syntax like webkitpy.test.__name__.  We want to be
116             #        sure not to import any non-Python 2.4 code, though, until
117             #        after the version-checking code has executed.
118             if (record.name.startswith("webkitpy.common.system.autoinstall") or
119                 record.name.startswith("webkitpy.test")):
120                 return True
121             if record.name.startswith("webkitpy"):
122                 return False
123             return True
124
125         testing_filter = logging.Filter()
126         testing_filter.filter = filter
127
128         # Display a message so developers are not mystified as to why
129         # logging does not work in the unit tests.
130         _log.info("Suppressing most webkitpy logging while running unit tests.")
131         handler.addFilter(testing_filter)
132
133     def run(self):
134         options, args = self._parse_args()
135         self._configure(options)
136
137         self.finder.clean_trees()
138
139         names = self.finder.find_names(args, self._options.skip_integrationtests, self._options.all)
140         return self._run_tests(names)
141
142     def _run_tests(self, names):
143         if self._options.coverage:
144             try:
145                 import webkitpy.thirdparty.autoinstalled.coverage as coverage
146             except ImportError, e:
147                 _log.error("Failed to import 'coverage'; can't generate coverage numbers.")
148                 return False
149             cov = coverage.coverage()
150             cov.start()
151
152         # Make sure PYTHONPATH is set up properly.
153         sys.path = self.finder.additional_paths(sys.path) + sys.path
154
155         _log.debug("Loading the tests...")
156
157         loader = unittest.defaultTestLoader
158         suites = []
159         for name in names:
160             if self.finder.is_module(name):
161                 # if we failed to load a name and it looks like a module,
162                 # try importing it directly, because loadTestsFromName()
163                 # produces lousy error messages for bad modules.
164                 try:
165                     __import__(name)
166                 except ImportError, e:
167                     _log.fatal('Failed to import %s:' % name)
168                     self._log_exception()
169                     return False
170
171             suites.append(loader.loadTestsFromName(name, None))
172
173         test_suite = unittest.TestSuite(suites)
174         if self._options.xml:
175             from webkitpy.thirdparty.autoinstalled.xmlrunner import XMLTestRunner
176             test_runner = XMLTestRunner(output='test-webkitpy-xml-reports')
177         else:
178             test_runner = TestRunner(self.stream, self._options, loader)
179
180         _log.debug("Running the tests.")
181         result = test_runner.run(test_suite)
182         if self._options.coverage:
183             cov.stop()
184             cov.save()
185             cov.report(show_missing=False)
186         return result.wasSuccessful()
187
188     def _log_exception(self):
189         s = StringIO.StringIO()
190         traceback.print_exc(file=s)
191         for l in s.buflist:
192             _log.error('  ' + l.rstrip())