Debian Codegraph @

lldb/packages/Python/lldbsuite/test/dotest.py

raw
1 """
2 A simple testing framework for lldb using python's unit testing framework.
3
4 Tests for lldb are written as python scripts which take advantage of the script
5 bridging provided by LLDB.framework to interact with lldb core.
6
7 A specific naming pattern is followed by the .py script to be recognized as
8 a module which implements a test scenario, namely, Test*.py.
9
10 To specify the directories where "Test*.py" python test scripts are located,
11 you need to pass in a list of directory names. By default, the current
12 working directory is searched if nothing is specified on the command line.
13
14 Type:
15
16 ./dotest.py -h
17
18 for available options.
19 """
20
21 # System modules
22 import atexit
23 import datetime
24 import errno
25 import logging
26 import os
27 import platform
28 import re
29 import shutil
30 import signal
31 import subprocess
32 import sys
33 import tempfile
34
35 # Third-party modules
36 import unittest
37
38 # LLDB Modules
39 import lldbsuite
40 from . import configuration
41 from . import dotest_args
42 from . import lldbtest_config
43 from . import test_categories
44 from . import test_result
45 from ..support import seven
46
47
48 def is_exe(fpath):
49 """Returns true if fpath is an executable."""
50 if fpath is None:
51 return False
52 if sys.platform == "win32":
53 if not fpath.endswith(".exe"):
54 fpath += ".exe"
55 return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
56
57
58 def which(program):
59 """Returns the full path to a program; None otherwise."""
60 fpath, _ = os.path.split(program)
61 if fpath:
62 if is_exe(program):
63 return program
64 else:
65 for path in os.environ["PATH"].split(os.pathsep):
66 exe_file = os.path.join(path, program)
67 if is_exe(exe_file):
68 return exe_file
69 return None
70
71
72 def usage(parser):
73 parser.print_help()
74 if configuration.verbose > 0:
75 print(
76 """
77 Examples:
78
79 This is an example of using the -f option to pinpoint to a specific test class
80 and test method to be run:
81
82 $ ./dotest.py -f ClassTypesTestCase.test_with_dsym_and_run_command
83 ----------------------------------------------------------------------
84 Collected 1 test
85
86 test_with_dsym_and_run_command (TestClassTypes.ClassTypesTestCase)
87 Test 'frame variable this' when stopped on a class constructor. ... ok
88
89 ----------------------------------------------------------------------
90 Ran 1 test in 1.396s
91
92 OK
93
94 And this is an example of using the -p option to run a single file (the filename
95 matches the pattern 'ObjC' and it happens to be 'TestObjCMethods.py'):
96
97 $ ./dotest.py -v -p ObjC
98 ----------------------------------------------------------------------
99 Collected 4 tests
100
101 test_break_with_dsym (TestObjCMethods.FoundationTestCase)
102 Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'. ... ok
103 test_break_with_dwarf (TestObjCMethods.FoundationTestCase)
104 Test setting objc breakpoints using '_regexp-break' and 'breakpoint set'. ... ok
105 test_data_type_and_expr_with_dsym (TestObjCMethods.FoundationTestCase)
106 Lookup objective-c data types and evaluate expressions. ... ok
107 test_data_type_and_expr_with_dwarf (TestObjCMethods.FoundationTestCase)
108 Lookup objective-c data types and evaluate expressions. ... ok
109
110 ----------------------------------------------------------------------
111 Ran 4 tests in 16.661s
112
113 OK
114
115 Running of this script also sets up the LLDB_TEST environment variable so that
116 individual test cases can locate their supporting files correctly. The script
117 tries to set up Python's search paths for modules by looking at the build tree
118 relative to this script. See also the '-i' option in the following example.
119
120 Finally, this is an example of using the lldb.py module distributed/installed by
121 Xcode4 to run against the tests under the 'forward' directory, and with the '-w'
122 option to add some delay between two tests. It uses ARCH=x86_64 to specify that
123 as the architecture and CC=clang to specify the compiler used for the test run:
124
125 $ PYTHONPATH=/Xcode4/Library/PrivateFrameworks/LLDB.framework/Versions/A/Resources/Python ARCH=x86_64 CC=clang ./dotest.py -v -w -i forward
126
127 Session logs for test failures/errors will go into directory '2010-11-11-13_56_16'
128 ----------------------------------------------------------------------
129 Collected 2 tests
130
131 test_with_dsym_and_run_command (TestForwardDeclaration.ForwardDeclarationTestCase)
132 Display *bar_ptr when stopped on a function with forward declaration of struct bar. ... ok
133 test_with_dwarf_and_run_command (TestForwardDeclaration.ForwardDeclarationTestCase)
134 Display *bar_ptr when stopped on a function with forward declaration of struct bar. ... ok
135
136 ----------------------------------------------------------------------
137 Ran 2 tests in 5.659s
138
139 OK
140
141 The 'Session ...' verbiage is recently introduced (see also the '-s' option) to
142 notify the directory containing the session logs for test failures or errors.
143 In case there is any test failure/error, a similar message is appended at the
144 end of the stderr output for your convenience.
145
146 ENABLING LOGS FROM TESTS
147
148 Option 1:
149
150 Writing logs into different files per test case::
151
152 $ ./dotest.py --channel "lldb all"
153
154 $ ./dotest.py --channel "lldb all" --channel "gdb-remote packets"
155
156 These log files are written to:
157
158 <session-dir>/<test-id>-host.log (logs from lldb host process)
159 <session-dir>/<test-id>-server.log (logs from debugserver/lldb-server)
160 <session-dir>/<test-id>-<test-result>.log (console logs)
161
162 By default, logs from successful runs are deleted. Use the --log-success flag
163 to create reference logs for debugging.
164
165 $ ./dotest.py --log-success
166
167 """
168 )
169 sys.exit(0)
170
171
172 def parseExclusion(exclusion_file):
173 """Parse an exclusion file, of the following format, where
174 'skip files', 'skip methods', 'xfail files', and 'xfail methods'
175 are the possible list heading values:
176
177 skip files
178 <file name>
179 <file name>
180
181 xfail methods
182 <method name>
183 """
184 excl_type = None
185
186 with open(exclusion_file) as f:
187 for line in f:
188 line = line.strip()
189 if not excl_type:
190 excl_type = line
191 continue
192
193 if not line:
194 excl_type = None
195 elif excl_type == "skip":
196 if not configuration.skip_tests:
197 configuration.skip_tests = []
198 configuration.skip_tests.append(line)
199 elif excl_type == "xfail":
200 if not configuration.xfail_tests:
201 configuration.xfail_tests = []
202 configuration.xfail_tests.append(line)
203
204
205 def parseOptionsAndInitTestdirs():
206 """Initialize the list of directories containing our unittest scripts.
207
208 '-h/--help as the first option prints out usage info and exit the program.
209 """
210
211 do_help = False
212
213 platform_system = platform.system()
214 platform_machine = platform.machine()
215
216 try:
217 parser = dotest_args.create_parser()
218 args = parser.parse_args()
219 except:
220 raise
221
222 if args.unset_env_varnames:
223 for env_var in args.unset_env_varnames:
224 if env_var in os.environ:
225 # From Python Doc: When unsetenv() is supported, deletion of items in os.environ
226 # is automatically translated into a corresponding call to
227 # unsetenv().
228 del os.environ[env_var]
229 # os.unsetenv(env_var)
230
231 if args.set_env_vars:
232 for env_var in args.set_env_vars:
233 parts = env_var.split("=", 1)
234 if len(parts) == 1:
235 os.environ[parts[0]] = ""
236 else:
237 os.environ[parts[0]] = parts[1]
238
239 if args.set_inferior_env_vars:
240 lldbtest_config.inferior_env = " ".join(args.set_inferior_env_vars)
241
242 if args.h:
243 do_help = True
244
245 if args.compiler:
246 configuration.compiler = os.path.abspath(args.compiler)
247 if not is_exe(configuration.compiler):
248 configuration.compiler = which(args.compiler)
249 if not is_exe(configuration.compiler):
250 logging.error(
251 '"%s" is not a valid compiler executable; aborting...', args.compiler
252 )
253 sys.exit(-1)
254 else:
255 # Use a compiler appropriate appropriate for the Apple SDK if one was
256 # specified
257 if platform_system == "Darwin" and args.apple_sdk:
258 configuration.compiler = seven.get_command_output(
259 'xcrun -sdk "%s" -find clang 2> /dev/null' % (args.apple_sdk)
260 )
261 else:
262 # 'clang' on ubuntu 14.04 is 3.4 so we try clang-3.5 first
263 candidateCompilers = ["clang-3.5", "clang", "gcc"]
264 for candidate in candidateCompilers:
265 if which(candidate):
266 configuration.compiler = candidate
267 break
268
269 if args.make:
270 configuration.make_path = args.make
271 elif platform_system == "FreeBSD" or platform_system == "NetBSD":
272 configuration.make_path = "gmake"
273 else:
274 configuration.make_path = "make"
275
276 if args.dsymutil:
277 configuration.dsymutil = args.dsymutil
278 elif platform_system == "Darwin":
279 configuration.dsymutil = seven.get_command_output(
280 "xcrun -find -toolchain default dsymutil"
281 )
282 if args.llvm_tools_dir:
283 configuration.filecheck = shutil.which("FileCheck", path=args.llvm_tools_dir)
284 configuration.yaml2obj = shutil.which("yaml2obj", path=args.llvm_tools_dir)
285
286 if not configuration.get_filecheck_path():
287 logging.warning("No valid FileCheck executable; some tests may fail...")
288 logging.warning("(Double-check the --llvm-tools-dir argument to dotest.py)")
289
290 if args.libcxx_include_dir or args.libcxx_library_dir:
291 if args.lldb_platform_name:
292 logging.warning(
293 "Custom libc++ is not supported for remote runs: ignoring --libcxx arguments"
294 )
295 elif not (args.libcxx_include_dir and args.libcxx_library_dir):
296 logging.error(
297 "Custom libc++ requires both --libcxx-include-dir and --libcxx-library-dir"
298 )
299 sys.exit(-1)
300 configuration.libcxx_include_dir = args.libcxx_include_dir
301 configuration.libcxx_include_target_dir = args.libcxx_include_target_dir
302 configuration.libcxx_library_dir = args.libcxx_library_dir
303
304 if args.channels:
305 lldbtest_config.channels = args.channels
306
307 if args.log_success:
308 lldbtest_config.log_success = args.log_success
309
310 if args.out_of_tree_debugserver:
311 lldbtest_config.out_of_tree_debugserver = args.out_of_tree_debugserver
312
313 # Set SDKROOT if we are using an Apple SDK
314 if args.sysroot is not None:
315 configuration.sdkroot = args.sysroot
316 elif platform_system == "Darwin" and args.apple_sdk:
317 configuration.sdkroot = seven.get_command_output(
318 'xcrun --sdk "%s" --show-sdk-path 2> /dev/null' % (args.apple_sdk)
319 )
320 if not configuration.sdkroot:
321 logging.error("No SDK found with the name %s; aborting...", args.apple_sdk)
322 sys.exit(-1)
323
324 if args.arch:
325 configuration.arch = args.arch
326 else:
327 configuration.arch = platform_machine
328
329 if args.categories_list:
330 configuration.categories_list = set(
331 test_categories.validate(args.categories_list, False)
332 )
333 configuration.use_categories = True
334 else:
335 configuration.categories_list = []
336
337 if args.skip_categories:
338 configuration.skip_categories += test_categories.validate(
339 args.skip_categories, False
340 )
341
342 if args.xfail_categories:
343 configuration.xfail_categories += test_categories.validate(
344 args.xfail_categories, False
345 )
346
347 if args.E:
348 os.environ["CFLAGS_EXTRAS"] = args.E
349
350 if args.dwarf_version:
351 configuration.dwarf_version = args.dwarf_version
352 # We cannot modify CFLAGS_EXTRAS because they're used in test cases
353 # that explicitly require no debug info.
354 os.environ["CFLAGS"] = "-gdwarf-{}".format(configuration.dwarf_version)
355
356 if args.settings:
357 for setting in args.settings:
358 if not len(setting) == 1 or not setting[0].count("="):
359 logging.error(
360 '"%s" is not a setting in the form "key=value"', setting[0]
361 )
362 sys.exit(-1)
363 setting_list = setting[0].split("=", 1)
364 configuration.settings.append((setting_list[0], setting_list[1]))
365
366 if args.d:
367 sys.stdout.write(
368 "Suspending the process %d to wait for debugger to attach...\n"
369 % os.getpid()
370 )
371 sys.stdout.flush()
372 os.kill(os.getpid(), signal.SIGSTOP)
373
374 if args.f:
375 if any([x.startswith("-") for x in args.f]):
376 usage(parser)
377 configuration.filters.extend(args.f)
378
379 if args.framework:
380 configuration.lldb_framework_path = args.framework
381
382 if args.executable:
383 # lldb executable is passed explicitly
384 lldbtest_config.lldbExec = os.path.abspath(args.executable)
385 if not is_exe(lldbtest_config.lldbExec):
386 lldbtest_config.lldbExec = which(args.executable)
387 if not is_exe(lldbtest_config.lldbExec):
388 logging.error(
389 "%s is not a valid executable to test; aborting...", args.executable
390 )
391 sys.exit(-1)
392
393 if args.excluded:
394 for excl_file in args.excluded:
395 parseExclusion(excl_file)
396
397 if args.p:
398 if args.p.startswith("-"):
399 usage(parser)
400 configuration.regexp = args.p
401
402 if args.t:
403 os.environ["LLDB_COMMAND_TRACE"] = "YES"
404
405 if args.v:
406 configuration.verbose = 2
407
408 # argparse makes sure we have a number
409 if args.sharp:
410 configuration.count = args.sharp
411
412 if sys.platform.startswith("win32"):
413 os.environ["LLDB_DISABLE_CRASH_DIALOG"] = str(args.disable_crash_dialog)
414 os.environ["LLDB_LAUNCH_INFERIORS_WITHOUT_CONSOLE"] = str(True)
415
416 if do_help:
417 usage(parser)
418
419 if args.lldb_platform_name:
420 configuration.lldb_platform_name = args.lldb_platform_name
421 if args.lldb_platform_url:
422 configuration.lldb_platform_url = args.lldb_platform_url
423 if args.lldb_platform_working_dir:
424 configuration.lldb_platform_working_dir = args.lldb_platform_working_dir
425 if platform_system == "Darwin" and args.apple_sdk:
426 configuration.apple_sdk = args.apple_sdk
427 if args.test_build_dir:
428 configuration.test_build_dir = args.test_build_dir
429 if args.lldb_module_cache_dir:
430 configuration.lldb_module_cache_dir = args.lldb_module_cache_dir
431 else:
432 configuration.lldb_module_cache_dir = os.path.join(
433 configuration.test_build_dir, "module-cache-lldb"
434 )
435
436 if args.clang_module_cache_dir:
437 configuration.clang_module_cache_dir = args.clang_module_cache_dir
438 else:
439 configuration.clang_module_cache_dir = os.path.join(
440 configuration.test_build_dir, "module-cache-clang"
441 )
442
443 if args.lldb_libs_dir:
444 configuration.lldb_libs_dir = args.lldb_libs_dir
445 if args.lldb_obj_root:
446 configuration.lldb_obj_root = args.lldb_obj_root
447
448 if args.enabled_plugins:
449 configuration.enabled_plugins = args.enabled_plugins
450
451 # Gather all the dirs passed on the command line.
452 if len(args.args) > 0:
453 configuration.testdirs = [
454 os.path.realpath(os.path.abspath(x)) for x in args.args
455 ]
456
457
458 def registerFaulthandler():
459 try:
460 import faulthandler
461 except ImportError:
462 # faulthandler is not available until python3
463 return
464
465 faulthandler.enable()
466 # faulthandler.register is not available on Windows.
467 if getattr(faulthandler, "register", None):
468 faulthandler.register(signal.SIGTERM, chain=True)
469
470
471 def setupSysPath():
472 """
473 Add LLDB.framework/Resources/Python to the search paths for modules.
474 As a side effect, we also discover the 'lldb' executable and export it here.
475 """
476
477 # Get the directory containing the current script.
478 if "DOTEST_PROFILE" in os.environ and "DOTEST_SCRIPT_DIR" in os.environ:
479 scriptPath = os.environ["DOTEST_SCRIPT_DIR"]
480 else:
481 scriptPath = os.path.dirname(os.path.abspath(__file__))
482 if not scriptPath.endswith("test"):
483 print("This script expects to reside in lldb's test directory.")
484 sys.exit(-1)
485
486 os.environ["LLDB_TEST"] = scriptPath
487
488 # Set up the root build directory.
489 if not configuration.test_build_dir:
490 raise Exception("test_build_dir is not set")
491 configuration.test_build_dir = os.path.abspath(configuration.test_build_dir)
492
493 # Set up the LLDB_SRC environment variable, so that the tests can locate
494 # the LLDB source code.
495 os.environ["LLDB_SRC"] = lldbsuite.lldb_root
496
497 pluginPath = os.path.join(scriptPath, "plugins")
498 toolsLLDBDAP = os.path.join(scriptPath, "tools", "lldb-dap")
499 toolsLLDBServerPath = os.path.join(scriptPath, "tools", "lldb-server")
500 intelpt = os.path.join(scriptPath, "tools", "intelpt")
501
502 # Insert script dir, plugin dir and lldb-server dir to the sys.path.
503 sys.path.insert(0, pluginPath)
504 # Adding test/tools/lldb-dap to the path makes it easy to
505 # "import lldb_dap_testcase" from the DAP tests
506 sys.path.insert(0, toolsLLDBDAP)
507 # Adding test/tools/lldb-server to the path makes it easy
508 # to "import lldbgdbserverutils" from the lldb-server tests
509 sys.path.insert(0, toolsLLDBServerPath)
510 # Adding test/tools/intelpt to the path makes it easy
511 # to "import intelpt_testcase" from the lldb-server tests
512 sys.path.insert(0, intelpt)
513
514 # This is the root of the lldb git/svn checkout
515 # When this changes over to a package instead of a standalone script, this
516 # will be `lldbsuite.lldb_root`
517 lldbRootDirectory = lldbsuite.lldb_root
518
519 # Some of the tests can invoke the 'lldb' command directly.
520 # We'll try to locate the appropriate executable right here.
521
522 # The lldb executable can be set from the command line
523 # if it's not set, we try to find it now
524 # first, we try the environment
525 if not lldbtest_config.lldbExec:
526 # First, you can define an environment variable LLDB_EXEC specifying the
527 # full pathname of the lldb executable.
528 if "LLDB_EXEC" in os.environ:
529 lldbtest_config.lldbExec = os.environ["LLDB_EXEC"]
530
531 if not lldbtest_config.lldbExec:
532 # Last, check the path
533 lldbtest_config.lldbExec = which("lldb")
534
535 if lldbtest_config.lldbExec and not is_exe(lldbtest_config.lldbExec):
536 print(
537 "'{}' is not a path to a valid executable".format(lldbtest_config.lldbExec)
538 )
539 lldbtest_config.lldbExec = None
540
541 if not lldbtest_config.lldbExec:
542 print(
543 "The 'lldb' executable cannot be located. Some of the tests may not be run as a result."
544 )
545 sys.exit(-1)
546
547 os.system("%s -v" % lldbtest_config.lldbExec)
548
549 lldbDir = os.path.dirname(lldbtest_config.lldbExec)
550
551 lldbDAPExec = os.path.join(lldbDir, "lldb-dap")
552 if is_exe(lldbDAPExec):
553 os.environ["LLDBDAP_EXEC"] = lldbDAPExec
554
555 lldbPythonDir = None # The directory that contains 'lldb/__init__.py'
556
557 # If our lldb supports the -P option, use it to find the python path:
558 lldb_dash_p_result = subprocess.check_output(
559 [lldbtest_config.lldbExec, "-P"], universal_newlines=True
560 )
561 if lldb_dash_p_result:
562 for line in lldb_dash_p_result.splitlines():
563 if os.path.isdir(line) and os.path.exists(
564 os.path.join(line, "lldb", "__init__.py")
565 ):
566 lldbPythonDir = line
567 break
568
569 if not lldbPythonDir:
570 print(
571 "Unable to load lldb extension module. Possible reasons for this include:"
572 )
573 print(" 1) LLDB was built with LLDB_ENABLE_PYTHON=0")
574 print(
575 " 2) PYTHONPATH and PYTHONHOME are not set correctly. PYTHONHOME should refer to"
576 )
577 print(
578 " the version of Python that LLDB built and linked against, and PYTHONPATH"
579 )
580 print(
581 " should contain the Lib directory for the same python distro, as well as the"
582 )
583 print(" location of LLDB's site-packages folder.")
584 print(
585 " 3) A different version of Python than that which was built against is exported in"
586 )
587 print(" the system's PATH environment variable, causing conflicts.")
588 print(
589 " 4) The executable '%s' could not be found. Please check "
590 % lldbtest_config.lldbExec
591 )
592 print(" that it exists and is executable.")
593
594 if lldbPythonDir:
595 lldbPythonDir = os.path.normpath(lldbPythonDir)
596 # Some of the code that uses this path assumes it hasn't resolved the Versions... link.
597 # If the path we've constructed looks like that, then we'll strip out
598 # the Versions/A part.
599 (before, frameWithVersion, after) = lldbPythonDir.rpartition(
600 "LLDB.framework/Versions/A"
601 )
602 if frameWithVersion != "":
603 lldbPythonDir = before + "LLDB.framework" + after
604
605 lldbPythonDir = os.path.abspath(lldbPythonDir)
606
607 if "freebsd" in sys.platform or "linux" in sys.platform:
608 os.environ["LLDB_LIB_DIR"] = os.path.join(lldbPythonDir, "..", "..")
609
610 # If tests need to find LLDB_FRAMEWORK, now they can do it
611 os.environ["LLDB_FRAMEWORK"] = os.path.dirname(os.path.dirname(lldbPythonDir))
612
613 # This is to locate the lldb.py module. Insert it right after
614 # sys.path[0].
615 sys.path[1:1] = [lldbPythonDir]
616
617
618 def visit_file(dir, name):
619 # Try to match the regexp pattern, if specified.
620 if configuration.regexp:
621 if not re.search(configuration.regexp, name):
622 # We didn't match the regex, we're done.
623 return
624
625 if configuration.skip_tests:
626 for file_regexp in configuration.skip_tests:
627 if re.search(file_regexp, name):
628 return
629
630 # We found a match for our test. Add it to the suite.
631
632 # Update the sys.path first.
633 if not sys.path.count(dir):
634 sys.path.insert(0, dir)
635 base = os.path.splitext(name)[0]
636
637 # Thoroughly check the filterspec against the base module and admit
638 # the (base, filterspec) combination only when it makes sense.
639
640 def check(obj, parts):
641 for part in parts:
642 try:
643 parent, obj = obj, getattr(obj, part)
644 except AttributeError:
645 # The filterspec has failed.
646 return False
647 return True
648
649 module = __import__(base)
650
651 def iter_filters():
652 for filterspec in configuration.filters:
653 parts = filterspec.split(".")
654 if check(module, parts):
655 yield filterspec
656 elif parts[0] == base and len(parts) > 1 and check(module, parts[1:]):
657 yield ".".join(parts[1:])
658 else:
659 for key, value in module.__dict__.items():
660 if check(value, parts):
661 yield key + "." + filterspec
662
663 filtered = False
664 for filterspec in iter_filters():
665 filtered = True
666 print("adding filter spec %s to module %s" % (filterspec, repr(module)))
667 tests = unittest.defaultTestLoader.loadTestsFromName(filterspec, module)
668 configuration.suite.addTests(tests)
669
670 # Forgo this module if the (base, filterspec) combo is invalid
671 if configuration.filters and not filtered:
672 return
673
674 if not filtered:
675 # Add the entire file's worth of tests since we're not filtered.
676 # Also the fail-over case when the filterspec branch
677 # (base, filterspec) combo doesn't make sense.
678 configuration.suite.addTests(unittest.defaultTestLoader.loadTestsFromName(base))
679
680
681 def visit(prefix, dir, names):
682 """Visitor function for os.path.walk(path, visit, arg)."""
683
684 dir_components = set(dir.split(os.sep))
685 excluded_components = set([".svn", ".git"])
686 if dir_components.intersection(excluded_components):
687 return
688
689 # Gather all the Python test file names that follow the Test*.py pattern.
690 python_test_files = [
691 name for name in names if name.endswith(".py") and name.startswith(prefix)
692 ]
693
694 # Visit all the python test files.
695 for name in python_test_files:
696 # Ensure we error out if we have multiple tests with the same
697 # base name.
698 # Future improvement: find all the places where we work with base
699 # names and convert to full paths. We have directory structure
700 # to disambiguate these, so we shouldn't need this constraint.
701 if name in configuration.all_tests:
702 raise Exception("Found multiple tests with the name %s" % name)
703 configuration.all_tests.add(name)
704
705 # Run the relevant tests in the python file.
706 visit_file(dir, name)
707
708
709 # ======================================== #
710 # #
711 # Execution of the test driver starts here #
712 # #
713 # ======================================== #
714
715
716 def checkDsymForUUIDIsNotOn():
717 cmd = ["defaults", "read", "com.apple.DebugSymbols"]
718 process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
719 cmd_output = process.stdout.read()
720 output_str = cmd_output.decode("utf-8")
721 if "DBGFileMappedPaths = " in output_str:
722 print("%s =>" % " ".join(cmd))
723 print(output_str)
724 print(
725 "Disable automatic lookup and caching of dSYMs before running the test suite!"
726 )
727 print("Exiting...")
728 sys.exit(0)
729
730
731 def exitTestSuite(exitCode=None):
732 # lldb.py does SBDebugger.Initialize().
733 # Call SBDebugger.Terminate() on exit.
734 import lldb
735
736 lldb.SBDebugger.Terminate()
737 if exitCode:
738 sys.exit(exitCode)
739
740
741 def getVersionForSDK(sdk):
742 sdk = str.lower(sdk)
743 full_path = seven.get_command_output("xcrun -sdk %s --show-sdk-path" % sdk)
744 basename = os.path.basename(full_path)
745 basename = os.path.splitext(basename)[0]
746 basename = str.lower(basename)
747 ver = basename.replace(sdk, "")
748 return ver
749
750
751 def checkCompiler():
752 # Add some intervention here to sanity check that the compiler requested is sane.
753 # If found not to be an executable program, we abort.
754 c = configuration.compiler
755 if which(c):
756 return
757
758 if not sys.platform.startswith("darwin"):
759 raise Exception(c + " is not a valid compiler")
760
761 pipe = subprocess.Popen(
762 ["xcrun", "-find", c], stdout=subprocess.PIPE, stderr=subprocess.STDOUT
763 )
764 cmd_output = pipe.stdout.read()
765 if not cmd_output or "not found" in cmd_output:
766 raise Exception(c + " is not a valid compiler")
767
768 configuration.compiler = cmd_output.split("\n")[0]
769 print("'xcrun -find %s' returning %s" % (c, configuration.compiler))
770
771
772 def canRunLibcxxTests():
773 from lldbsuite.test import lldbplatformutil
774
775 platform = lldbplatformutil.getPlatform()
776
777 if lldbplatformutil.target_is_android() or lldbplatformutil.platformIsDarwin():
778 return True, "libc++ always present"
779
780 if platform == "linux":
781 with tempfile.NamedTemporaryFile() as f:
782 cmd = [configuration.compiler, "-xc++", "-stdlib=libc++", "-o", f.name, "-"]
783 p = subprocess.Popen(
784 cmd,
785 stdin=subprocess.PIPE,
786 stdout=subprocess.PIPE,
787 stderr=subprocess.PIPE,
788 universal_newlines=True,
789 )
790 _, stderr = p.communicate("#include <cassert>\nint main() {}")
791 if not p.returncode:
792 return True, "Compiling with -stdlib=libc++ works"
793 return (
794 False,
795 "Compiling with -stdlib=libc++ fails with the error: %s" % stderr,
796 )
797
798 return False, "Don't know how to build with libc++ on %s" % platform
799
800
801 def checkLibcxxSupport():
802 result, reason = canRunLibcxxTests()
803 if result:
804 return # libc++ supported
805 if "libc++" in configuration.categories_list:
806 return # libc++ category explicitly requested, let it run.
807 if configuration.verbose:
808 print("libc++ tests will not be run because: " + reason)
809 configuration.skip_categories.append("libc++")
810
811
812 def canRunLibstdcxxTests():
813 from lldbsuite.test import lldbplatformutil
814
815 platform = lldbplatformutil.getPlatform()
816 if lldbplatformutil.target_is_android():
817 platform = "android"
818 if platform == "linux":
819 return True, "libstdcxx always present"
820 return False, "Don't know how to build with libstdcxx on %s" % platform
821
822
823 def checkLibstdcxxSupport():
824 result, reason = canRunLibstdcxxTests()
825 if result:
826 return # libstdcxx supported
827 if "libstdcxx" in configuration.categories_list:
828 return # libstdcxx category explicitly requested, let it run.
829 if configuration.verbose:
830 print("libstdcxx tests will not be run because: " + reason)
831 configuration.skip_categories.append("libstdcxx")
832
833
834 def canRunWatchpointTests():
835 from lldbsuite.test import lldbplatformutil
836
837 platform = lldbplatformutil.getPlatform()
838 if platform == "netbsd":
839 if os.geteuid() == 0:
840 return True, "root can always write dbregs"
841 try:
842 output = (
843 subprocess.check_output(
844 ["/sbin/sysctl", "-n", "security.models.extensions.user_set_dbregs"]
845 )
846 .decode()
847 .strip()
848 )
849 if output == "1":
850 return True, "security.models.extensions.user_set_dbregs enabled"
851 except subprocess.CalledProcessError:
852 pass
853 return False, "security.models.extensions.user_set_dbregs disabled"
854 elif platform == "freebsd" and configuration.arch == "aarch64":
855 import lldb
856
857 if lldb.SBPlatform.GetHostPlatform().GetOSMajorVersion() < 13:
858 return False, "Watchpoint support on arm64 requires FreeBSD 13.0"
859 return True, "watchpoint support available"
860
861
862 def checkWatchpointSupport():
863 result, reason = canRunWatchpointTests()
864 if result:
865 return # watchpoints supported
866 if "watchpoint" in configuration.categories_list:
867 return # watchpoint category explicitly requested, let it run.
868 if configuration.verbose:
869 print("watchpoint tests will not be run because: " + reason)
870 configuration.skip_categories.append("watchpoint")
871
872
873 def checkObjcSupport():
874 from lldbsuite.test import lldbplatformutil
875
876 if not lldbplatformutil.platformIsDarwin():
877 if configuration.verbose:
878 print("objc tests will be skipped because of unsupported platform")
879 configuration.skip_categories.append("objc")
880
881
882 def checkDebugInfoSupport():
883 from lldbsuite.test import lldbplatformutil
884
885 platform = lldbplatformutil.getPlatform()
886 compiler = configuration.compiler
887 for cat in test_categories.debug_info_categories:
888 if cat in configuration.categories_list:
889 continue # Category explicitly requested, let it run.
890 if test_categories.is_supported_on_platform(cat, platform, compiler):
891 continue
892 configuration.skip_categories.append(cat)
893
894
895 def checkDebugServerSupport():
896 from lldbsuite.test import lldbplatformutil
897 import lldb
898
899 skip_msg = "Skipping %s tests, as they are not compatible with remote testing on this platform"
900 if lldbplatformutil.platformIsDarwin():
901 configuration.skip_categories.append("llgs")
902 if lldb.remote_platform:
903 # <rdar://problem/34539270>
904 configuration.skip_categories.append("debugserver")
905 if configuration.verbose:
906 print(skip_msg % "debugserver")
907 else:
908 configuration.skip_categories.append("debugserver")
909 if lldb.remote_platform and lldbplatformutil.getPlatform() == "windows":
910 configuration.skip_categories.append("llgs")
911 if configuration.verbose:
912 print(skip_msg % "lldb-server")
913
914
915 def checkForkVForkSupport():
916 from lldbsuite.test import lldbplatformutil
917
918 platform = lldbplatformutil.getPlatform()
919 if platform not in ["freebsd", "linux", "netbsd"]:
920 configuration.skip_categories.append("fork")
921
922
923 def checkPexpectSupport():
924 from lldbsuite.test import lldbplatformutil
925
926 platform = lldbplatformutil.getPlatform()
927
928 # llvm.org/pr22274: need a pexpect replacement for windows
929 if platform in ["windows"]:
930 if configuration.verbose:
931 print("pexpect tests will be skipped because of unsupported platform")
932 configuration.skip_categories.append("pexpect")
933
934
935 def checkDAPSupport():
936 import lldb
937
938 if "LLDBDAP_EXEC" not in os.environ:
939 msg = (
940 "The 'lldb-dap' executable cannot be located and its tests will not be run."
941 )
942 elif lldb.remote_platform:
943 msg = "lldb-dap tests are not compatible with remote platforms and will not be run."
944 else:
945 msg = None
946
947 if msg:
948 if configuration.verbose:
949 print(msg)
950 configuration.skip_categories.append("lldb-dap")
951
952
953 def run_suite():
954 # On MacOS X, check to make sure that domain for com.apple.DebugSymbols defaults
955 # does not exist before proceeding to running the test suite.
956 if sys.platform.startswith("darwin"):
957 checkDsymForUUIDIsNotOn()
958
959 # Start the actions by first parsing the options while setting up the test
960 # directories, followed by setting up the search paths for lldb utilities;
961 # then, we walk the directory trees and collect the tests into our test suite.
962 #
963 parseOptionsAndInitTestdirs()
964
965 # Print a stack trace if the test hangs or is passed SIGTERM.
966 registerFaulthandler()
967
968 setupSysPath()
969
970 import lldb
971
972 lldb.SBDebugger.Initialize()
973 lldb.SBDebugger.PrintStackTraceOnError()
974
975 # Use host platform by default.
976 lldb.remote_platform = None
977 lldb.selected_platform = lldb.SBPlatform.GetHostPlatform()
978
979 # Now we can also import lldbutil
980 from lldbsuite.test import lldbutil
981
982 if configuration.lldb_platform_name:
983 print("Setting up remote platform '%s'" % (configuration.lldb_platform_name))
984 lldb.remote_platform = lldb.SBPlatform(configuration.lldb_platform_name)
985 lldb.selected_platform = lldb.remote_platform
986 if not lldb.remote_platform.IsValid():
987 print(
988 "error: unable to create the LLDB platform named '%s'."
989 % (configuration.lldb_platform_name)
990 )
991 exitTestSuite(1)
992 if configuration.lldb_platform_url:
993 # We must connect to a remote platform if a LLDB platform URL was
994 # specified
995 print(
996 "Connecting to remote platform '%s' at '%s'..."
997 % (configuration.lldb_platform_name, configuration.lldb_platform_url)
998 )
999 platform_connect_options = lldb.SBPlatformConnectOptions(
1000 configuration.lldb_platform_url
1001 )
1002 err = lldb.remote_platform.ConnectRemote(platform_connect_options)
1003 if err.Success():
1004 print("Connected.")
1005 else:
1006 print(
1007 "error: failed to connect to remote platform using URL '%s': %s"
1008 % (configuration.lldb_platform_url, err)
1009 )
1010 exitTestSuite(1)
1011 else:
1012 configuration.lldb_platform_url = None
1013
1014 if configuration.lldb_platform_working_dir:
1015 print(
1016 "Setting remote platform working directory to '%s'..."
1017 % (configuration.lldb_platform_working_dir)
1018 )
1019 error = lldb.remote_platform.MakeDirectory(
1020 configuration.lldb_platform_working_dir, 448
1021 ) # 448 = 0o700
1022 if error.Fail():
1023 raise Exception(
1024 "making remote directory '%s': %s"
1025 % (configuration.lldb_platform_working_dir, error)
1026 )
1027
1028 if not lldb.remote_platform.SetWorkingDirectory(
1029 configuration.lldb_platform_working_dir
1030 ):
1031 raise Exception(
1032 "failed to set working directory '%s'"
1033 % configuration.lldb_platform_working_dir
1034 )
1035 lldb.selected_platform = lldb.remote_platform
1036 else:
1037 lldb.remote_platform = None
1038 configuration.lldb_platform_working_dir = None
1039 configuration.lldb_platform_url = None
1040
1041 # Set up the working directory.
1042 # Note that it's not dotest's job to clean this directory.
1043 lldbutil.mkdir_p(configuration.test_build_dir)
1044
1045 checkLibcxxSupport()
1046 checkLibstdcxxSupport()
1047 checkWatchpointSupport()
1048 checkDebugInfoSupport()
1049 checkDebugServerSupport()
1050 checkObjcSupport()
1051 checkForkVForkSupport()
1052 checkPexpectSupport()
1053 checkDAPSupport()
1054
1055 skipped_categories_list = ", ".join(configuration.skip_categories)
1056 print(
1057 "Skipping the following test categories: {}".format(
1058 configuration.skip_categories
1059 )
1060 )
1061
1062 for testdir in configuration.testdirs:
1063 for dirpath, dirnames, filenames in os.walk(testdir):
1064 visit("Test", dirpath, filenames)
1065
1066 #
1067 # Now that we have loaded all the test cases, run the whole test suite.
1068 #
1069
1070 # Install the control-c handler.
1071 unittest.signals.installHandler()
1072
1073 #
1074 # Invoke the default TextTestRunner to run the test suite
1075 #
1076 checkCompiler()
1077
1078 if configuration.verbose:
1079 print("compiler=%s" % configuration.compiler)
1080
1081 # Iterating over all possible architecture and compiler combinations.
1082 configString = "arch=%s compiler=%s" % (configuration.arch, configuration.compiler)
1083
1084 # Output the configuration.
1085 if configuration.verbose:
1086 sys.stderr.write("\nConfiguration: " + configString + "\n")
1087
1088 # First, write out the number of collected test cases.
1089 if configuration.verbose:
1090 sys.stderr.write(configuration.separator + "\n")
1091 sys.stderr.write(
1092 "Collected %d test%s\n\n"
1093 % (
1094 configuration.suite.countTestCases(),
1095 configuration.suite.countTestCases() != 1 and "s" or "",
1096 )
1097 )
1098
1099 if configuration.suite.countTestCases() == 0:
1100 logging.error("did not discover any matching tests")
1101 exitTestSuite(1)
1102
1103 # Invoke the test runner.
1104 if configuration.count == 1:
1105 result = unittest.TextTestRunner(
1106 stream=sys.stderr,
1107 verbosity=configuration.verbose,
1108 resultclass=test_result.LLDBTestResult,
1109 ).run(configuration.suite)
1110 else:
1111 # We are invoking the same test suite more than once. In this case,
1112 # mark __ignore_singleton__ flag as True so the signleton pattern is
1113 # not enforced.
1114 test_result.LLDBTestResult.__ignore_singleton__ = True
1115 for i in range(configuration.count):
1116 result = unittest.TextTestRunner(
1117 stream=sys.stderr,
1118 verbosity=configuration.verbose,
1119 resultclass=test_result.LLDBTestResult,
1120 ).run(configuration.suite)
1121
1122 configuration.failed = not result.wasSuccessful()
1123
1124 if configuration.sdir_has_content and configuration.verbose:
1125 sys.stderr.write(
1126 "Session logs for test failures/errors/unexpected successes"
1127 " can be found in the test build directory\n"
1128 )
1129
1130 if configuration.use_categories and len(configuration.failures_per_category) > 0:
1131 sys.stderr.write("Failures per category:\n")
1132 for category in configuration.failures_per_category:
1133 sys.stderr.write(
1134 "%s - %d\n" % (category, configuration.failures_per_category[category])
1135 )
1136
1137 # Exiting.
1138 exitTestSuite(configuration.failed)
1139
1140
1141 if __name__ == "__main__":
1142 print(
1143 __file__
1144 + " is for use as a module only. It should not be run as a standalone script."
1145 )
1146 sys.exit(-1)