Update sys.platform switched behavior in tests to use self.getPlatform (remote target platform)

[flackr]

Summary

Uses target platform when determining which platform specific behavior to use or expect in tests. TestHelp.py was unchanged because this is asserting behavior of the local lldb binary.

[emaste]

lgtm

test/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py

218 ↗

(On Diff #23006)

should we change these cases to be if (self.getPlatform() != "darwin")?

test/functionalities/load_unload/TestLoadUnload.py

41 ↗

(On Diff #23006)

Independent of this change, seems like this test would benefit from a little refactoring

test/functionalities/register/TestRegisters.py

92 ↗

(On Diff #23006)

same comment about refactoring

lldb/trunk/test/api/check_public_api_headers/TestPublicAPIHeaders.py

def setUp(self):
         self.source = 'main.cpp'
         self.exe_name = 'a.out'
 
     @skipIfNoSBHeaders
     def test_sb_api_directory(self):
         """Test the SB API directory and make sure there's no unwanted stuff."""
 
         # Only proceed if this is "darwin", "x86_64", and local platform.
-        if not (sys.platform.startswith("darwin") and self.getArchitecture() == "x86_64" and not lldb.test_remote):
+        if not (self.getPlatform() == "darwin" and self.getArchitecture() == "x86_64" and not lldb.test_remote):
             self.skipTest("This test is only for LLDB.framework built 64-bit and !lldb.test_remote")
         if self.getArchitecture() == "i386":
             self.skipTest("LLDB is 64-bit and cannot be linked to 32-bit test program.")
 
         # Generate main.cpp, build it, and execute.
         self.generate_main_cpp()
         self.buildDriver(self.source, self.exe_name)
         self.sanity_check_executable(self.exe_name)
 
     def generate_main_cpp(self):
         """Generate main.cpp from main.cpp.template."""
         temp = os.path.join(os.getcwd(), self.template)
         with open(temp, 'r') as f:
             content = f.read()
 
         public_api_dir = os.path.join(os.environ["LLDB_SRC"], "include", "lldb", "API")
 
         # Look under the include/lldb/API directory and add #include statements
         # for all the SB API headers.
         public_headers = os.listdir(public_api_dir)
         # For different platforms, the include statement can vary.
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             include_stmt = "'#include <%s>' % os.path.join('LLDB', header)"
-        if sys.platform.startswith('freebsd') or sys.platform.startswith("linux") or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile':
+        if self.getPlatform() == "freebsd" or self.getPlatform() == "linux" or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile':
             include_stmt = "'#include <%s>' % os.path.join(public_api_dir, header)"
         list = [eval(include_stmt) for header in public_headers if (header.startswith("SB") and
                                                                     header.endswith(".h"))]
         includes = '\n'.join(list)
         new_content = content.replace('%include_SB_APIs%', includes)
         src = os.path.join(os.getcwd(), self.source)
         with open(src, 'w') as f:
             f.write(new_content)

lldb/trunk/test/functionalities/abbreviation/TestAbbreviations.py

def running_abbreviations (self):
                     patterns = ["Dumping sections for [0-9]+ modules."])
 
         self.expect("i d symf",
                     patterns = ["Dumping debug symbols for [0-9]+ modules."])
 
         self.expect("i d symt",
                     patterns = ["Dumping symbol table for [0-9]+ modules."])
 
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             self.expect("i li",
                         substrs = [ 'a.out',
                                     '/usr/lib/dyld',
                                     '/usr/lib/libSystem.B.dylib'])
 
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()
 

lldb/trunk/test/functionalities/inferior-changed/TestInferiorChanged.py

class ChangedInferiorTestCase(TestBase):
 
     def inferior_crashing(self):
         """Inferior crashes upon launching; lldb should catch the event and stop."""
         self.exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + self.exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             stop_reason = 'stop reason = EXC_BAD_ACCESS'
         else:
             stop_reason = 'stop reason = invalid address'
 
         # The stop reason of the thread should be a bad access exception.
         self.expect("thread list", STOPPED_DUE_TO_EXC_BAD_ACCESS,
             substrs = ['stopped',
                        stop_reason])
 
         # And it should report the correct line number.
         self.expect("thread backtrace all",
             substrs = [stop_reason,
                        'main.c:%d' % self.line1])
 
     def inferior_not_crashing(self):
         """Test lldb reloads the inferior after it was changed during the session."""
         self.runCmd("process kill")
         # Prod the lldb-platform that we have a newly built inferior ready.
         if lldb.lldbtest_remote_sandbox:
             self.runCmd("file " + self.exe, CURRENT_EXECUTABLE_SET)
         self.runCmd("run", RUN_SUCCEEDED)
         self.runCmd("process status")
 
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             stop_reason = 'EXC_BAD_ACCESS'
         else:
             stop_reason = 'invalid address'
 
         if stop_reason in self.res.GetOutput():
             self.fail("Inferior changed, but lldb did not perform a reload")
 
         # Break inside the main.

lldb/trunk/test/functionalities/inferior-crashing/TestInferiorCrashing.py

def test_inferior_crashing_expr_step_and_expr_dwarf(self):
         """Test that lldb expressions work before and after stepping after a crash."""
         self.buildDwarf()
         self.inferior_crashing_expr_step_expr()
 
     def set_breakpoint(self, line):
         lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True)
 
     def check_stop_reason(self):
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             stop_reason = 'stop reason = EXC_BAD_ACCESS'
         else:
             stop_reason = 'stop reason = invalid address'
 
         # The stop reason of the thread should be a bad access exception.
         self.expect("thread list", STOPPED_DUE_TO_EXC_BAD_ACCESS,
             substrs = ['stopped',
                        stop_reason])

lldb/trunk/test/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py

def test_recursive_inferior_crashing_expr_step_and_expr_dwarf(self):
         """Test that lldb expressions work before and after stepping after a crash."""
         self.buildDwarf()
         self.recursive_inferior_crashing_expr_step_expr()
 
     def set_breakpoint(self, line):
         lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True)
 
     def check_stop_reason(self):
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             stop_reason = 'stop reason = EXC_BAD_ACCESS'
         else:
             stop_reason = 'stop reason = invalid address'
 
         # The stop reason of the thread should be a bad access exception.
         self.expect("thread list", STOPPED_DUE_TO_EXC_BAD_ACCESS,
             substrs = ['stopped',
                        stop_reason])
def recursive_inferior_crashing_step_after_break(self):
         """Test that lldb behaves correctly when stepping after a crash."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
 
         expected_state = 'exited' # Provide the exit code.
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             expected_state = 'stopped' # TODO: Determine why 'next' and 'continue' have no effect after a crash.
 
         self.expect("next",
             substrs = ['Process', expected_state])
 
-        if not(sys.platform.startswith("darwin")): # if stopped, we will have a process around
+        if self.getPlatform() != "darwin": # if stopped, we will have a process around
             self.expect("thread list", error=True,substrs = ['Process must be launched'])
 
     def recursive_inferior_crashing_expr_step_expr(self):
         """Test that lldb expressions work before and after stepping after a crash."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)

lldb/trunk/test/functionalities/inline-stepping/TestInlineStepping.py

def run_step_sequence(self, step_sequence):
            correctly for the operation in the sequence."""
 
         target_line_entry = lldb.SBLineEntry()
         target_line_entry.SetFileSpec(self.main_source_spec)
 
         test_stack_depth = True
         # Work around for <rdar://problem/16363195>, the darwin unwinder seems flakey about whether it duplicates the first frame 
         # or not, which makes counting stack depth unreliable.
-        if "darwin" in sys.platform:
+        if self.getPlatform() == "darwin":
             test_stack_depth = False
 
         for step_pattern in step_sequence:
             step_stop_line = line_number (self.main_source, step_pattern[0])
             target_line_entry.SetLine(step_stop_line)
             self.do_step (step_pattern[1], target_line_entry, test_stack_depth)
         
 

lldb/trunk/test/functionalities/load_unload/TestLoadUnload.py

class LoadUnloadTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.cpp.
         self.line = line_number('main.c',
                                 '// Set break point at this line for test_lldb_process_load_and_unload_commands().')
         self.line_d_function = line_number('d.c',
                                            '// Find this line number within d_dunction().')
-        if not sys.platform.startswith("darwin"):
+        if self.getPlatform() != "darwin":
             if "LD_LIBRARY_PATH" in os.environ:
                 self.runCmd("settings set target.env-vars " + self.dylibPath + "=" + os.environ["LD_LIBRARY_PATH"] + ":" + os.getcwd())
             else:
                 self.runCmd("settings set target.env-vars " + self.dylibPath + "=" + os.getcwd())
 
     @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
     @not_remote_testsuite_ready
     def test_modules_search_paths(self):
         """Test target modules list after loading a different copy of the library libd.dylib, and verifies that it works with 'target modules search-paths add'."""
 
         # Invoke the default build rule.
         self.buildDefault()
 
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             dylibName = 'libloadunload_d.dylib'
         else:
             dylibName = 'libloadunload_d.so'
 
         # The directory with the dynamic library we did not link to.
         new_dir = os.path.join(os.getcwd(), "hidden")
 
         old_dylib = os.path.join(os.getcwd(), dylibName)
def test_dyld_library_path(self):
         """Test (DY)LD_LIBRARY_PATH after moving libd.dylib, which defines d_function, somewhere else."""
 
         # Invoke the default build rule.
         self.buildDefault()
 
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             dylibName = 'libloadunload_d.dylib'
             dsymName = 'libloadunload_d.dylib.dSYM'
         else:
             dylibName = 'libloadunload_d.so'
 
         # The directory to relocate the dynamic library and its debugging info.
         special_dir = "hidden"
         new_dir = os.path.join(os.getcwd(), special_dir)
 
         old_dylib = os.path.join(os.getcwd(), dylibName)
         new_dylib = os.path.join(new_dir, dylibName)
 
         #system(["ls", "-lR", "."])
 
         # Try running with the (DY)LD_LIBRARY_PATH environment variable set, make sure
         # we pick up the hidden dylib.
 
         env_cmd_string = "settings set target.env-vars " + self.dylibPath + "=" + new_dir
-        if not sys.platform.startswith("darwin"):
+        if self.getPlatform() != "darwin":
             env_cmd_string += ":" + os.getcwd()
 
         if self.TraceOn():
             print "Set environment to: ", env_cmd_string
         self.runCmd(env_cmd_string)
         self.runCmd("settings show target.env-vars")
 
         remove_dyld_path_cmd = "settings remove target.env-vars " + self.dylibPath
def test_lldb_process_load_and_unload_commands(self):
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # Make sure that a_function does not exist at this point.
         self.expect("image lookup -n a_function", "a_function should not exist yet",
                     error=True, matching=False,
             patterns = ["1 match found .* %s" % self.mydir])
 
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             dylibName = 'libloadunload_a.dylib'
         else:
             dylibName = 'libloadunload_a.so'
 
         # Use lldb 'process load' to load the dylib.
         self.expect("process load %s" % dylibName, "%s loaded correctly" % dylibName,
             patterns = ['Loading "%s".*ok' % dylibName,
                         'Image [0-9]+ loaded'])

lldb/trunk/test/functionalities/register/TestRegisters.py

class RegisterCommandsTestCase(TestBase):
     def remove_log(self):
         """ Remove the temporary log file generated by some tests."""
         if os.path.exists(self.log_file):
             os.remove(self.log_file)
 
     # platform specific logging of the specified category
     def log_enable(self, category):
         self.platform = ""
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             self.platform = "" # TODO: add support for "log enable darwin registers"
 
-        if sys.platform.startswith("freebsd"):
+        if self.getPlatform() == "freebsd":
             self.platform = "freebsd"
 
-        if sys.platform.startswith("linux"):
+        if self.getPlatform() == "linux":
             self.platform = "linux"
 
         if self.platform != "":
             self.log_file = os.path.join(os.getcwd(), 'TestRegisters.log')
             self.runCmd("log enable " + self.platform + " " + str(category) + " registers -v -f " + self.log_file, RUN_SUCCEEDED)
             if not self.has_teardown:
                 self.has_teardown = True
                 self.addTearDownHook(self.remove_log)

lldb/trunk/test/lang/c/array_types/TestArrayTypes.py

def array_types_python(self):
         thread = process.GetThreadAtIndex(0)
         if thread.GetStopReason() != lldb.eStopReasonBreakpoint:
             from lldbutil import stop_reason_to_str
             self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS %
                       stop_reason_to_str(thread.GetStopReason()))
 
         # Sanity check the print representation of thread.
         thr = str(thread)
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             tidstr = "tid = 0x%4.4x" % thread.GetThreadID()
         else:
             tidstr = "tid = %u" % thread.GetThreadID()
         self.expect(thr, "Thread looks good with stop reason = breakpoint", exe=False,
             substrs = [tidstr])
 
         # The breakpoint should have a hit count of 1.
         self.assertTrue(breakpoint.GetHitCount() == 1, BREAKPOINT_HIT_ONCE)

lldb/trunk/test/lang/c/function_types/TestFunctionTypes.py

class FunctionTypesTestCase(TestBase):
     def function_pointers(self):
         """Test that a function pointer to 'printf' works and can be called."""
         
         self.runToBreakpoint()
 
         self.expect("expr string_not_empty",
                     substrs = ['(int (*)(const char *)) $0 = ', '(a.out`'])
 
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             regexps = ['lib.*\.dylib`printf']
         else:
             regexps = ['printf']
         self.expect("expr (int (*)(const char*, ...))printf",
                     substrs = ['(int (*)(const char *, ...)) $1 = '],
                     patterns = regexps)
 
         self.expect("expr $1(\"Hello world\\n\")",
                     startstr = '(int) $2 = 12')
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

lldb/trunk/test/lang/c/tls_globals/TestTlsGlobals.py

class TlsGlobalTestCase(TestBase):
     def test_with_dwarf(self):
         """Test thread-local storage."""
         self.buildDwarf()
         self.tls_globals()
 
     def setUp(self):
         TestBase.setUp(self)
 
-        if sys.platform.startswith("freebsd") or sys.platform.startswith("linux"):
+        if self.getPlatform() == "freebsd" or self.getPlatform() == "linux":
             # LD_LIBRARY_PATH must be set so the shared libraries are found on startup
             if "LD_LIBRARY_PATH" in os.environ:
                 self.runCmd("settings set target.env-vars " + self.dylibPath + "=" + os.environ["LD_LIBRARY_PATH"] + ":" + os.getcwd())
             else:
                 self.runCmd("settings set target.env-vars " + self.dylibPath + "=" + os.getcwd())
             self.addTearDownHook(lambda: self.runCmd("settings remove target.env-vars " + self.dylibPath))
 
     def tls_globals(self):

lldb/trunk/test/lang/cpp/class_static/TestStaticVariables.py

def static_variable_commands(self):
         # global variables are no longer displayed with the "frame variable" command. 
         self.expect('target variable A::g_points', VARIABLES_DISPLAYED_CORRECTLY,
             patterns=['\(PointType \[[1-9]*\]\) A::g_points = {.*}'])
         self.expect('target variable g_points', VARIABLES_DISPLAYED_CORRECTLY,
             substrs = ['(PointType [2]) g_points'])
 
         # On Mac OS X, gcc 4.2 emits the wrong debug info for A::g_points.
         # A::g_points is an array of two elements.
-        if sys.platform.startswith("darwin") or sys.platform.startswith("linux"):
+        if self.getPlatform() == "darwin" or self.getPlatform() == "linux":
             self.expect("target variable A::g_points[1].x", VARIABLES_DISPLAYED_CORRECTLY,
                 startstr = "(int) A::g_points[1].x = 11")
 
     def static_variable_python(self):
         """Test Python APIs on file and class static variables."""
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)

lldb/trunk/test/lang/cpp/namespace/TestNamespace.py

def namespace_variable_commands(self):
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
             substrs = ['stopped',
                        'stop reason = breakpoint'])
 
         # On Mac OS X, gcc 4.2 emits the wrong debug info with respect to types.
         slist = ['(int) a = 12', 'anon_uint', 'a_uint', 'b_uint', 'y_uint']
-        if sys.platform.startswith("darwin") and self.getCompiler() in ['clang', 'llvm-gcc']:
+        if self.getPlatform() == "darwin" and self.getCompiler() in ['clang', 'llvm-gcc']:
             slist = ['(int) a = 12',
                      '::my_uint_t', 'anon_uint = 0',
                      '(A::uint_t) a_uint = 1',
                      '(A::B::uint_t) b_uint = 2',
                      '(Y::uint_t) y_uint = 3']
 
         # 'frame variable' displays the local variables with type information.
         self.expect('frame variable', VARIABLES_DISPLAYED_CORRECTLY,

lldb/trunk/test/lang/objc/modules/TestObjCModules.py

 """Test that importing modules in Objective-C works as expected."""
 
 import os, time
 import unittest2
 import lldb
 import platform
 import lldbutil
 
 from distutils.version import StrictVersion
 
 from lldbtest import *
 
 class ObjCModulesTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
+    @skipUnlessDarwin
     @dsym_test
     def test_expr_with_dsym(self):
         self.buildDsym()
         self.expr()
 
     @dwarf_test
     @skipIfFreeBSD
     @skipIfLinux

lldb/trunk/test/terminal/TestSTTYBeforeAndAfter.py

def test_stty_dash_a_before_and_afetr_invoking_lldb_command(self):
         self.child = pexpect.spawn('expect')
         child = self.child
 
         child.expect(expect_prompt)
         child.setecho(True)
         if self.TraceOn():
             child.logfile = sys.stdout
 
-        if sys.platform.startswith("darwin"):
+        if self.getPlatform() == "darwin":
             child.sendline('set env(TERM) xterm')
         else:
             child.sendline('set env(TERM) vt100')
         child.expect(expect_prompt)
         child.sendline('puts $env(TERM)')
         child.expect(expect_prompt)
 
         # Turn on loggings for input/output to/from the child.