1import os
2import sys
3
4import Test
5import TestRunner
6import Util
7
8kIsWindows = sys.platform in ['win32', 'cygwin']
9
10class GoogleTest(object):
11    def __init__(self, test_sub_dir, test_suffix):
12        self.test_sub_dir = os.path.normcase(str(test_sub_dir)).split(';')
13        self.test_suffix = str(test_suffix)
14
15        # On Windows, assume tests will also end in '.exe'.
16        if kIsWindows:
17            self.test_suffix += '.exe'
18
19    def getGTestTests(self, path, litConfig, localConfig):
20        """getGTestTests(path) - [name]
21
22        Return the tests available in gtest executable.
23
24        Args:
25          path: String path to a gtest executable
26          litConfig: LitConfig instance
27          localConfig: TestingConfig instance"""
28
29        try:
30            lines = Util.capture([path, '--gtest_list_tests'],
31                                 env=localConfig.environment)
32            if kIsWindows:
33              lines = lines.replace('\r', '')
34            lines = lines.split('\n')
35        except:
36            litConfig.error("unable to discover google-tests in %r" % path)
37            raise StopIteration
38
39        nested_tests = []
40        for ln in lines:
41            if not ln.strip():
42                continue
43
44            prefix = ''
45            index = 0
46            while ln[index*2:index*2+2] == '  ':
47                index += 1
48            while len(nested_tests) > index:
49                nested_tests.pop()
50
51            ln = ln[index*2:]
52            if ln.endswith('.'):
53                nested_tests.append(ln)
54            else:
55                yield ''.join(nested_tests) + ln
56
57    def getTestsInDirectory(self, testSuite, path_in_suite,
58                            litConfig, localConfig):
59        source_path = testSuite.getSourcePath(path_in_suite)
60        for filename in os.listdir(source_path):
61            # Check for the one subdirectory (build directory) tests will be in.
62            if not '.' in self.test_sub_dir:
63                if not os.path.normcase(filename) in self.test_sub_dir:
64                    continue
65
66            filepath = os.path.join(source_path, filename)
67            if not os.path.isdir(filepath):
68                continue
69
70            for subfilename in os.listdir(filepath):
71                if subfilename.endswith(self.test_suffix):
72                    execpath = os.path.join(filepath, subfilename)
73
74                    # Discover the tests in this executable.
75                    for name in self.getGTestTests(execpath, litConfig,
76                                                   localConfig):
77                        testPath = path_in_suite + (filename, subfilename, name)
78                        yield Test.Test(testSuite, testPath, localConfig)
79
80    def execute(self, test, litConfig):
81        testPath,testName = os.path.split(test.getSourcePath())
82        while not os.path.exists(testPath):
83            # Handle GTest parametrized and typed tests, whose name includes
84            # some '/'s.
85            testPath, namePrefix = os.path.split(testPath)
86            testName = os.path.join(namePrefix, testName)
87
88        cmd = [testPath, '--gtest_filter=' + testName]
89        if litConfig.useValgrind:
90            cmd = litConfig.valgrindArgs + cmd
91
92        out, err, exitCode = TestRunner.executeCommand(
93            cmd, env=test.config.environment)
94
95        if not exitCode:
96            return Test.PASS,''
97
98        return Test.FAIL, out + err
99
100###
101
102class FileBasedTest(object):
103    def getTestsInDirectory(self, testSuite, path_in_suite,
104                            litConfig, localConfig):
105        source_path = testSuite.getSourcePath(path_in_suite)
106        for filename in os.listdir(source_path):
107            # Ignore dot files and excluded tests.
108            if (filename.startswith('.') or
109                filename in localConfig.excludes):
110                continue
111
112            filepath = os.path.join(source_path, filename)
113            if not os.path.isdir(filepath):
114                base,ext = os.path.splitext(filename)
115                if ext in localConfig.suffixes:
116                    yield Test.Test(testSuite, path_in_suite + (filename,),
117                                    localConfig)
118
119class ShTest(FileBasedTest):
120    def __init__(self, execute_external = False):
121        self.execute_external = execute_external
122
123    def execute(self, test, litConfig):
124        return TestRunner.executeShTest(test, litConfig,
125                                        self.execute_external)
126
127class TclTest(FileBasedTest):
128    def __init__(self, ignoreStdErr=False):
129        self.ignoreStdErr = ignoreStdErr
130
131    def execute(self, test, litConfig):
132        litConfig.ignoreStdErr = self.ignoreStdErr
133        return TestRunner.executeTclTest(test, litConfig)
134
135###
136
137import re
138import tempfile
139
140class OneCommandPerFileTest:
141    # FIXME: Refactor into generic test for running some command on a directory
142    # of inputs.
143
144    def __init__(self, command, dir, recursive=False,
145                 pattern=".*", useTempInput=False):
146        if isinstance(command, str):
147            self.command = [command]
148        else:
149            self.command = list(command)
150        if dir is not None:
151            dir = str(dir)
152        self.dir = dir
153        self.recursive = bool(recursive)
154        self.pattern = re.compile(pattern)
155        self.useTempInput = useTempInput
156
157    def getTestsInDirectory(self, testSuite, path_in_suite,
158                            litConfig, localConfig):
159        dir = self.dir
160        if dir is None:
161            dir = testSuite.getSourcePath(path_in_suite)
162
163        for dirname,subdirs,filenames in os.walk(dir):
164            if not self.recursive:
165                subdirs[:] = []
166
167            subdirs[:] = [d for d in subdirs
168                          if (d != '.svn' and
169                              d not in localConfig.excludes)]
170
171            for filename in filenames:
172                if (filename.startswith('.') or
173                    not self.pattern.match(filename) or
174                    filename in localConfig.excludes):
175                    continue
176
177                path = os.path.join(dirname,filename)
178                suffix = path[len(dir):]
179                if suffix.startswith(os.sep):
180                    suffix = suffix[1:]
181                test = Test.Test(testSuite,
182                                 path_in_suite + tuple(suffix.split(os.sep)),
183                                 localConfig)
184                # FIXME: Hack?
185                test.source_path = path
186                yield test
187
188    def createTempInput(self, tmp, test):
189        abstract
190
191    def execute(self, test, litConfig):
192        if test.config.unsupported:
193            return (Test.UNSUPPORTED, 'Test is unsupported')
194
195        cmd = list(self.command)
196
197        # If using temp input, create a temporary file and hand it to the
198        # subclass.
199        if self.useTempInput:
200            tmp = tempfile.NamedTemporaryFile(suffix='.cpp')
201            self.createTempInput(tmp, test)
202            tmp.flush()
203            cmd.append(tmp.name)
204        elif hasattr(test, 'source_path'):
205            cmd.append(test.source_path)
206        else:
207            cmd.append(test.getSourcePath())
208
209        out, err, exitCode = TestRunner.executeCommand(cmd)
210
211        diags = out + err
212        if not exitCode and not diags.strip():
213            return Test.PASS,''
214
215        # Try to include some useful information.
216        report = """Command: %s\n""" % ' '.join(["'%s'" % a
217                                                 for a in cmd])
218        if self.useTempInput:
219            report += """Temporary File: %s\n""" % tmp.name
220            report += "--\n%s--\n""" % open(tmp.name).read()
221        report += """Output:\n--\n%s--""" % diags
222
223        return Test.FAIL, report
224
225class SyntaxCheckTest(OneCommandPerFileTest):
226    def __init__(self, compiler, dir, extra_cxx_args=[], *args, **kwargs):
227        cmd = [compiler, '-x', 'c++', '-fsyntax-only'] + extra_cxx_args
228        OneCommandPerFileTest.__init__(self, cmd, dir,
229                                       useTempInput=1, *args, **kwargs)
230
231    def createTempInput(self, tmp, test):
232        print >>tmp, '#include "%s"' % test.source_path
233