Modify the test cases (there are a bunch of them) under test/types so that they

employ different executable names when creating the target for lldb to debug.
Comparing the log files for the same test case with success/failure results show
that the failed one was setting the breakpoint on some different address than the
succeeded one, leading us to suspect that the file system maybe think it knows better
and caches the wrong executable file (they were all named 'a.out' before) which lldb
subsequently reads from.

Now './dotest.py -v types' passes without specifying the '-w' option.

rdar://problem/9644488
rdar://problem/9649573

llvm-svn: 133649

Author: Johnny Chen

lldb/test/types/AbstractBase.py

@@ -20,23 +20,12 @@ class GenericTester(TestBase):
     # Assert message.
     DATA_TYPE_GROKKED = "Data type from expr parser output is parsed correctly"
 
-    # FIXME: Remove this method when/if we find out the cause of the failures
-    # if no delays are inserted between test cases.
-#     def setUp(self):
-#         # Call super's setUp().
-#         TestBase.setUp(self)
-#         # Insert some delay for running test cases under test/types if not
-#         # already so by the TestBase.setUp().
-#         if "LLDB_WAIT_BETWEEN_TEST_CASES" not in os.environ:
-#             #print "some delay, please ...."
-#             time.sleep(1.0)
-
-    def generic_type_tester(self, atoms, quotedDisplay=False):
+    def generic_type_tester(self, exe_name, atoms, quotedDisplay=False):
         """Test that variables with basic types are displayed correctly."""
 
         # First, capture the golden output emitted by the oracle, i.e., the
         # series of printf statements.
-        go = system("./a.out", sender=self)[0]
+        go = system("./%s" % exe_name, sender=self)[0]
         # This golden list contains a list of (variable, value) pairs extracted
         # from the golden output.
         gl = []
@@ -54,7 +43,7 @@ def generic_type_tester(self, atoms, quotedDisplay=False):
 
         # Bring the program to the point where we can issue a series of
         # 'frame variable -T' command.
-        self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
+        self.runCmd("file %s" % exe_name, CURRENT_EXECUTABLE_SET)
         puts_line = line_number ("basic_type.cpp", "// Here is the line we will break on to check variables")
         self.expect("breakpoint set -f basic_type.cpp -l %d" % puts_line,
                     BREAKPOINT_CREATED,
@@ -98,12 +87,12 @@ def generic_type_tester(self, atoms, quotedDisplay=False):
             self.expect(output, Msg(var, val, True), exe=False,
                 substrs = [nv])
 
-    def generic_type_expr_tester(self, atoms, quotedDisplay=False):
+    def generic_type_expr_tester(self, exe_name, atoms, quotedDisplay=False):
         """Test that variable expressions with basic types are evaluated correctly."""
 
         # First, capture the golden output emitted by the oracle, i.e., the
         # series of printf statements.
-        go = system("./a.out", sender=self)[0]
+        go = system("./%s" % exe_name, sender=self)[0]
         # This golden list contains a list of (variable, value) pairs extracted
         # from the golden output.
         gl = []
@@ -121,7 +110,7 @@ def generic_type_expr_tester(self, atoms, quotedDisplay=False):
 
         # Bring the program to the point where we can issue a series of
         # 'expr' command.
-        self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
+        self.runCmd("file %s" % exe_name, CURRENT_EXECUTABLE_SET)
         puts_line = line_number ("basic_type.cpp", "// Here is the line we will break on to check variables.")
         self.expect("breakpoint set -f basic_type.cpp -l %d" % puts_line,
                     BREAKPOINT_CREATED,

lldb/test/types/TestFailures.py lldb/test/types/HideTestFailures.pylldb/test/types/TestFailures.py renamed to lldb/test/types/HideTestFailures.py

@@ -12,42 +12,42 @@ class FloatTypesTestCase(AbstractBase.GenericTester):
     mydir = "types"
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
-    def test_float_types_with_dsym(self):
+    def test_float_type_with_dsym(self):
         """Test that float-type variables are displayed correctly."""
-        d = {'CXX_SOURCES': 'float.cpp'}
+        d = {'CXX_SOURCES': 'float.cpp', 'EXE': 'float_type_dsym'}
         self.buildDsym(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        self.float_type()
+        self.float_type('float_type_dsym')
 
     def test_float_type_with_dwarf(self):
         """Test that float-type variables are displayed correctly."""
-        d = {'CXX_SOURCES': 'float.cpp'}
+        d = {'CXX_SOURCES': 'float.cpp', 'EXE': 'float_type_dwarf'}
         self.buildDwarf(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        self.float_type()
+        self.float_type('float_type_dwarf')
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     def test_double_type_with_dsym(self):
         """Test that double-type variables are displayed correctly."""
-        d = {'CXX_SOURCES': 'double.cpp'}
+        d = {'CXX_SOURCES': 'double.cpp', 'EXE': 'double_type_dsym'}
         self.buildDsym(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        self.double_type()
+        self.double_type('double_type_dsym')
 
     def test_double_type_with_dwarf(self):
         """Test that double-type variables are displayed correctly."""
-        d = {'CXX_SOURCES': 'double.cpp'}
+        d = {'CXX_SOURCES': 'double.cpp', 'EXE': 'double_type_dwarf'}
         self.buildDwarf(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        self.double_type()
+        self.double_type('double_type_dwarf')
 
-    def float_type(self):
+    def float_type(self, exe_name):
         """Test that float-type variables are displayed correctly."""
-        self.generic_type_tester(set(['float']))
+        self.generic_type_tester(exe_name, set(['float']))
 
-    def double_type(self):
+    def double_type(self, exe_name):
         """Test that double-type variables are displayed correctly."""
-        self.generic_type_tester(set(['double']))
+        self.generic_type_tester(exe_name, set(['double']))
 
 
 if __name__ == '__main__':

lldb/test/types/TestFloatTypes.py

@@ -15,42 +15,42 @@ class FloatTypesExprTestCase(AbstractBase.GenericTester):
     # test/types failures for Test*TypesExpr.py: element offset computed wrong and sign error?
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
-    def test_float_types_with_dsym(self):
+    def test_float_type_with_dsym(self):
         """Test that float-type variable expressions are evaluated correctly."""
-        d = {'CXX_SOURCES': 'float.cpp'}
+        d = {'CXX_SOURCES': 'float.cpp', 'EXE': 'float_type_dsym'}
         self.buildDsym(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        self.float_type_expr()
+        self.float_type_expr('float_type_dsym')
 
     def test_float_type_with_dwarf(self):
         """Test that float-type variable expressions are evaluated correctly."""
-        d = {'CXX_SOURCES': 'float.cpp'}
+        d = {'CXX_SOURCES': 'float.cpp', 'EXE': 'float_type_dwarf'}
         self.buildDwarf(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        self.float_type_expr()
+        self.float_type_expr('float_type_dwarf')
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     def test_double_type_with_dsym(self):
         """Test that double-type variable expressions are evaluated correctly."""
-        d = {'CXX_SOURCES': 'double.cpp'}
+        d = {'CXX_SOURCES': 'double.cpp', 'EXE': 'double_type_dsym'}
         self.buildDsym(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        self.double_type_expr()
+        self.double_type_expr('double_type_dsym')
 
     def test_double_type_with_dwarf(self):
         """Test that double-type variable expressions are evaluated correctly."""
-        d = {'CXX_SOURCES': 'double.cpp'}
+        d = {'CXX_SOURCES': 'double.cpp', 'EXE': 'double_type_dwarf'}
         self.buildDwarf(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        self.double_type_expr()
+        self.double_type_expr('double_type_dwarf')
 
-    def float_type_expr(self):
+    def float_type_expr(self, exe_name):
         """Test that float-type variable expressions are evaluated correctly."""
-        self.generic_type_expr_tester(set(['float']))
+        self.generic_type_expr_tester(exe_name, set(['float']))
 
-    def double_type_expr(self):
+    def double_type_expr(self, exe_name):
         """Test that double-type variable expressions are evaluated correctly."""
-        self.generic_type_expr_tester(set(['double']))
+        self.generic_type_expr_tester(exe_name, set(['double']))
 
 
 if __name__ == '__main__':