Enabled a bunch of tests on Linux

[vharron]

Summary

Removed expectedFailureLinux from failures that I was unable to reproduce,
updated and improved some other comments near XFAIL tests

[sivachandra]

LGTM.
Couple of inline notes.

I was auditing the tests in http://reviews.llvm.org/D6910. Since you have already done, I am going to abandon that patch.

test/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py

24

This is failing because of a completely different issue. If you replace the "continue" commands with "next", this test passes. I was digging into this exact test when I saw your patch.

test/python_api/thread/TestThreadAPI.py

78

May be a PR for this as well?

[vharron]

test/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py

24

The build server seems to indicate that this is working on Darwin. The fact that it doesn't work on Linux concerns me.

test/python_api/thread/TestThreadAPI.py

78

I will if I have more information than I can fit in the comment.

[sivachandra]

Please do not view my comments as blockers. As indicated in my first post, they are only notes for the trail.

test/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py

24

What I am trying to hint here is that the test fails, but not because what is being tested is failing. This test case surfaces another, IMO fairly serious, issue.

test/python_api/thread/TestThreadAPI.py

78

Your comment seems to be a workaround, which is good enough to be in a PR.

test/expression_command/formatters/TestFormatters.py

class ExprFormattersTestCase(TestBase):
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     @dsym_test
     def test_with_dsym(self):
         """Test expr + formatters for good interoperability."""
         self.buildDsym()
         self.do_my_test()
 
     @expectedFailureFreeBSD('llvm.org/pr19011') # Newer Clang omits C1 complete object constructor
-    @expectedFailureLinux('llvm.org/pr20230')
     @dwarf_test
     def test_with_dwarf(self):
         """Test expr + formatters for good interoperability."""
         self.buildDwarf()
         self.do_my_test()
 
     def do_my_test(self):
         

test/functionalities/attach_resume/TestAttachResume.py

class AttachResumeTestCase(TestBase):
     @expectedFailureFreeBSD('llvm.org/pr19310')
     @skipIfRemote
     @dwarf_test
     def test_attach_continue_interrupt_detach(self):
         """Test attach/continue/interrupt/detach"""
         self.buildDwarf()
         self.process_attach_continue_interrupt_detach()
 
-    @expectedFailureLinux('llvm.org/pr19478')
+    @expectedFailureLinux('llvm.org/pr19478') # intermittent ~2/14 runs
     @skipIfRemote
     def process_attach_continue_interrupt_detach(self):
         """Test attach/continue/interrupt/detach"""
 
         exe = os.path.join(os.getcwd(), exe_name)
 
         popen = self.spawnSubprocess(exe)
         self.addTearDownHook(self.cleanupSubprocesses)

test/functionalities/data-formatter/data-formatter-synthval/TestDataFormatterSynthVal.py

class DataFormatterSynthValueTestCase(TestBase):
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     @dsym_test
     def test_with_dsym_and_run_command(self):
         """Test using Python synthetic children provider to provide a value."""
         self.buildDsym()
         self.data_formatter_commands()
 
     @skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser
-    @expectedFailureLinux # non-core functionality, need to reenable and fix
-                          # later (DES 2014.11.07). Most likely failing because
-                          # of mis-match is version of libstdc++ supported by
-                          # the data-formatters.
     @dwarf_test
     def test_with_dwarf_and_run_command(self):
         """Test using Python synthetic children provider to provide a value."""
         self.buildDwarf()
         self.data_formatter_commands()
 
     def setUp(self):
         # Call super's setUp().

test/functionalities/data-formatter/rdar-9974002/Test-rdar-9974002.py

class Radar9974002DataFormatterTestCase(TestBase):
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     @dsym_test
     def test_with_dsym_and_run_command(self):
         """Test data formatter commands."""
         self.buildDsym()
         self.data_formatter_commands()
 
     @dwarf_test
-    @expectedFailureLinux("llvm.org/pr20232")
     def test_with_dwarf_and_run_command(self):
         """Test data formatter commands."""
         self.buildDwarf()
         self.data_formatter_commands()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

test/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py

class DynamicValueChildCountTestCase(TestBase):
     @python_api_test
     @dsym_test
     @expectedFailurei386("to be figured out")
     def test_get_dynamic_vals_with_dsym(self):
         """Test fetching C++ dynamic values from pointers & references."""
         self.buildDsym(dictionary=self.getBuildFlags())
         self.do_get_dynamic_vals()
 
-    @expectedFailureLinux # FIXME: This needs to be root-caused.  It looks like the DWARF info is anticipating the derived class assignment.
+    @expectedFailureLinux("llvm.org/pr23039")
     @expectedFailureFreeBSD("llvm.org/pr19311") # continue at a breakpoint does not work
     @python_api_test
     @dwarf_test
     @expectedFailurei386("to be figured out")
     def test_get_dynamic_vals_with_dwarf(self):
         """Test fetching C++ dynamic values from pointers & references."""
         self.buildDwarf(dictionary=self.getBuildFlags())
         self.do_get_dynamic_vals()

test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py

class ExprDoesntDeadlockTestCase(TestBase):
     @dsym_test
     def test_with_dsym_and_run_command(self):
         """Test that expr will time out and allow other threads to run if it blocks - with dsym."""
         self.buildDsym()
         self.expr_doesnt_deadlock()
 
     @dwarf_test
     @expectedFailureFreeBSD('llvm.org/pr17946')
-    @expectedFailureLinux('llvm.org/pr15258') # disabled due to assertion failure in ProcessMonitor::GetCrashReasonForSIGSEGV:
     def test_with_dwarf_and_run_command(self):
         """Test that expr will time out and allow other threads to run if it blocks."""
         self.buildDwarf()
         self.expr_doesnt_deadlock()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

test/functionalities/inferior-assert/TestInferiorAssert.py

class AssertingInferiorTestCase(TestBase):
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     def test_inferior_asserting_register_dwarf(self):
         """Test that lldb reliably reads registers from the inferior after asserting (command)."""
         self.buildDwarf()
         self.inferior_asserting_registers()
 
     @expectedFailurei386("llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly")
     @expectedFailureFreeBSD('llvm.org/pr18533 - PC in __assert frame is outside of function')
-    @expectedFailureLinux("PC in __GI___assert_fail frame is just after the function (this is a no-return so there is no epilogue afterwards)")
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     def test_inferior_asserting_disassemble(self):
         """Test that lldb reliably disassembles frames after asserting (command)."""
         self.buildDefault()
         self.inferior_asserting_disassemble()
 
     @python_api_test
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")

test/functionalities/inferior-crashing/TestInferiorCrashing.py

class CrashingInferiorTestCase(TestBase):
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     def test_inferior_crashing_step_after_break_dsym(self):
         """Test that stepping after a crash behaves correctly."""
         self.buildDsym()
         self.inferior_crashing_step_after_break()
 
     @skipIfFreeBSD # llvm.org/pr16684
-    @expectedFailureLinux # due to llvm.org/pr15988 -- step over misbehaves after crash
     def test_inferior_crashing_step_after_break_dwarf(self):
         """Test that lldb functions correctly after stepping through a crash."""
         self.buildDwarf()
         self.inferior_crashing_step_after_break()
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     def test_inferior_crashing_expr_step_and_expr_dsym(self):
         """Test that lldb expressions work before and after stepping after a crash."""
         self.buildDsym()
         self.inferior_crashing_expr_step_expr()
 
     @expectedFailureFreeBSD('llvm.org/pr15989') # Couldn't allocate space for the stack frame
-    @expectedFailureLinux # due to llvm.org/pr15989 -- expression fails after crash and step
     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)
 

test/functionalities/watchpoint/multiple_threads/TestWatchpointMultipleThreads.py

class WatchpointForMultipleThreadsTestCase(TestBase):
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     @dsym_test
     def test_watchpoint_multiple_threads_with_dsym(self):
         """Test that lldb watchpoint works for multiple threads."""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.hello_multiple_threads()
 
-    @skipIfGcc # causes intermittent gcc debian buildbot failures, skip until we can investigate
-    @expectedFailureLinux("llvm.org/pr20233") # note due to a @skipIfGcc above, this is going to check failure on Linux if using non-GCC (most likely clang)
+    @expectedFailureGcc("llvm.org/pr20233")
     @dwarf_test
     def test_watchpoint_multiple_threads_with_dwarf(self):
         """Test that lldb watchpoint works for multiple threads."""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.hello_multiple_threads()
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")

test/lang/cpp/class_types/TestClassTypes.py

 """Test breakpoint on a class constructor; and variable list the this object."""
 
 import os, time
 import unittest2
 import lldb
 import lldbutil
 from lldbtest import *
 import lldbutil
 
 class ClassTypesTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
-    failing_compilers = ['clang', 'gcc']
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     @dsym_test
     def test_with_dsym_and_run_command(self):
         """Test 'frame variable this' when stopped on a class constructor."""
         self.buildDsym()
         self.class_types()
 
def test_with_dsym_and_constructor_name(self):
         """Test 'frame variable this' and 'expr this' when stopped inside a constructor."""
         self.buildDsym()
         self.class_types_constructor_name()
 
     # rdar://problem/8557478
     # test/class_types test failures: runCmd: expr this->m_c_int
     @dwarf_test
     @expectedFailureFreeBSD('llvm.org/pr14540')
-    @expectedFailureLinux('llvm.org/pr14540', failing_compilers)
     @expectedFailureDarwin(16362674)
     def test_with_dwarf_and_constructor_name (self):
         """Test 'frame variable this' and 'expr this' when stopped inside a constructor."""
         self.buildDwarf()
         self.class_types_constructor_name()
 
     def setUp(self):
         # Call super's setUp().

test/lang/cpp/dynamic-value/TestDynamicValue.py

class DynamicValueTestCase(TestBase):
     @python_api_test
     @dsym_test
     def test_get_dynamic_vals_with_dsym(self):
         """Test fetching C++ dynamic values from pointers & references."""
         self.buildDsym(dictionary=self.getBuildFlags())
         self.do_get_dynamic_vals()
 
     @expectedFailureFreeBSD # FIXME: This needs to be root-caused.
-    @expectedFailureLinux # FIXME: This needs to be root-caused.  It looks like the DWARF info is anticipating the derived class assignment.
     @python_api_test
     @dwarf_test
     def test_get_dynamic_vals_with_dwarf(self):
         """Test fetching C++ dynamic values from pointers & references."""
         self.buildDwarf(dictionary=self.getBuildFlags())
         self.do_get_dynamic_vals()
 
     def setUp(self):

test/python_api/thread/TestThreadAPI.py

def test_step_out_of_malloc_into_function_b_with_dsym(self):
         """Test Python SBThread.StepOut() API to step out of a malloc call where the call site is at function b()."""
         # We build a different executable than the default buildDsym() does.
         d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
         self.buildDsym(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.step_out_of_malloc_into_function_b(self.exe_name)
 
     @expectedFailureFreeBSD # llvm.org/pr20476
-    @expectedFailureLinux # llvm.org/pr14416
+    @expectedFailureLinux # need to 'thread step-out' twice to get out of malloc
     @python_api_test
     @dwarf_test
     def test_step_out_of_malloc_into_function_b_with_dwarf(self):
         """Test Python SBThread.StepOut() API to step out of a malloc call where the call site is at function b()."""
         # We build a different executable than the default buildDwarf() does.
         d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
         self.buildDwarf(dictionary=d)
         self.setTearDownCleanup(dictionary=d)

test/python_api/value_var_update/TestValueVarUpdate.py

class HelloWorldTestCase(TestBase):
     @python_api_test
     @dsym_test
     def test_with_dsym_and_process_launch_api(self):
         """Test SBValue::GetValueDidChange"""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.do_test()
 
-    @expectedFailureLinux # non-core functionality, need to reenable and fix later (DES 2014.11.07)
     @expectedFailureFreeBSD("llvm.org/pr21620 GetValueDidChange() wrong")
     @python_api_test
     @dwarf_test
     def test_with_dwarf_and_process_launch_api(self):
         """Test SBValue::GetValueDidChange"""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.do_test()