[lit, windows] Disable a number of tests that are failing on Windows

[stella.stamenova]

Summary

They all correspond to bugs that are already logged and I've added the appropriate (or most appropriate) bug numbers. This leaves only a handful of failing tests.

lldb/trunk/lit/Breakpoint/case-insensitive.test

 # REQUIRES: windows
+# XFAIL: windows
+# -> llvm.org/pr24528
 #
 # RUN: %cc %p/Inputs/case-sensitive.c -g -o %t
 # RUN: lldb-test breakpoints %t %s | FileCheck %s
 
 breakpoint set -f case-sensitive.c -l 3
 # CHECK-LABEL: breakpoint set -f case-sensitive.c -l 3
 # CHECK: At least one location.
 

lldb/trunk/packages/Python/lldbsuite/test/functionalities/command_script/TestCommandScript.py

 """
 Test lldb Python commands.
 """
 
 from __future__ import print_function
 
 
 import os
 import time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
 
 class CmdPythonTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test(self):
         self.build()
         self.pycmd_tests()
 
     def pycmd_tests(self):
         self.runCmd("command source py_import")
 
         # Verify command that specifies eCommandRequiresTarget returns failure

lldb/trunk/packages/Python/lldbsuite/test/functionalities/frame-language/TestGuessLanguage.py

 """
 Test the SB API SBFrame::GuessLanguage.
 """
 
 from __future__ import print_function
 
 
 import os
 import time
 import re
 import lldb
 import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
 
 class TestFrameGuessLanguage(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     # If your test case doesn't stress debug info, the 
     # set this to true.  That way it won't be run once for
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37658")
     def test_guess_language(self):
         """Test GuessLanguage for C and C++."""
         self.build()
         self.do_test()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/inline-stepping/TestInlineStepping.py

 class TestInlineStepping(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
     @expectedFailureAll(
         compiler="icc",
         bugnumber="# Not really a bug.  ICC combines two inlined functions.")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test_with_python_api(self):
         """Test stepping over and into inlined functions."""
         self.build()
         self.inline_stepping()
 
     @add_test_categories(['pyapi'])
     def test_step_over_with_python_api(self):
         """Test stepping over and into inlined functions."""
         self.build()
         self.inline_stepping_step_over()
 
     @add_test_categories(['pyapi'])
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test_step_in_template_with_python_api(self):
         """Test stepping in to templated functions."""
         self.build()
         self.step_in_template()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump/TestMiniDump.py

def test_stack_info_in_mini_dump(self):
         self.assertEqual(thread.GetNumFrames(), len(pc_list))
         for i in range(len(pc_list)):
             frame = thread.GetFrameAtIndex(i)
             self.assertTrue(frame.IsValid())
             self.assertEqual(frame.GetPC(), pc_list[i])
             self.assertTrue(frame.GetModule().IsValid())
 
     @skipUnlessWindows # Minidump saving works only on windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test_deeper_stack_in_mini_dump(self):
         """Test that we can examine a more interesting stack in a mini dump."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         core = self.getBuildArtifact("core.dmp")
         try:
             # Set a breakpoint and capture a mini dump.
             target = self.dbg.CreateTarget(exe)
def test_deeper_stack_in_mini_dump(self):
 
         finally:
             # Clean up the mini dump file.
             self.assertTrue(self.dbg.DeleteTarget(target))
             if (os.path.isfile(core)):
                 os.unlink(core)
 
     @skipUnlessWindows # Minidump saving works only on windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test_local_variables_in_mini_dump(self):
         """Test that we can examine local variables in a mini dump."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         core = self.getBuildArtifact("core.dmp")
         try:
             # Set a breakpoint and capture a mini dump.
             target = self.dbg.CreateTarget(exe)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/register/register_command/TestRegisters.py

def test_register_commands(self):
             substrs=['invalid register set index: 4'],
             error=True)
 
     @skipIfiOSSimulator
     # Writing of mxcsr register fails, presumably due to a kernel/hardware
     # problem
     @skipIfTargetAndroid(archs=["i386"])
     @skipIf(archs=no_match(['amd64', 'arm', 'i386', 'x86_64']))
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
     def test_fp_register_write(self):
         """Test commands that write to registers, in particular floating-point registers."""
         self.build()
         self.fp_register_write()
 
     @skipIfiOSSimulator
     # "register read fstat" always return 0xffff
     @expectedFailureAndroid(archs=["i386"])
     @skipIfFreeBSD  # llvm.org/pr25057
     @skipIf(archs=no_match(['amd64', 'i386', 'x86_64']))
     @skipIfOutOfTreeDebugserver
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
     def test_fp_special_purpose_register_read(self):
         """Test commands that read fpu special purpose registers."""
         self.build()
         self.fp_special_purpose_register_read()
 
     @skipIfiOSSimulator
     @skipIf(archs=no_match(['amd64', 'arm', 'i386', 'x86_64']))
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
     def test_register_expressions(self):
         """Test expression evaluation with commands related to registers."""
         self.build()
         self.common_setup()
 
         if self.getArchitecture() in ['amd64', 'i386', 'x86_64']:
             gpr = "eax"
             vector = "xmm0"
def test_register_expressions(self):
 
         if self.getArchitecture() in ['amd64', 'x86_64']:
             self.expect(
                 "expr -- ($rax & 0xffffffff) == $eax",
                 substrs=['true'])
 
     @skipIfiOSSimulator
     @skipIf(archs=no_match(['amd64', 'x86_64']))
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
     def test_convenience_registers(self):
         """Test convenience registers."""
         self.build()
         self.convenience_registers()
 
     @skipIfiOSSimulator
     @skipIf(archs=no_match(['amd64', 'x86_64']))
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
     def test_convenience_registers_with_process_attach(self):
         """Test convenience registers after a 'process attach'."""
         self.build()
         self.convenience_registers_with_process_attach(test_16bit_regs=False)
 
     @skipIfiOSSimulator
     @skipIf(archs=no_match(['amd64', 'x86_64']))
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
     def test_convenience_registers_16bit_with_process_attach(self):
         """Test convenience registers after a 'process attach'."""
         self.build()
         self.convenience_registers_with_process_attach(test_16bit_regs=True)
 
     def common_setup(self):
         exe = self.getBuildArtifact("a.out")
 
def fp_register_write(self):
                  "{0x01 0x02 0x03 0x00 0x00 0x00 0x00 0x00 0x09 0x0a 0x2f 0x2f 0x2f 0x2f 0x0e 0x0f}",
                  False),
             ]
 
         for (reg, val, must) in reg_list:
             self.write_and_read(currentFrame, reg, val, must)
 
         if self.getArchitecture() in ['amd64', 'i386', 'x86_64']:
+            if st0regname is None:
+                self.fail("st0regname could not be determined")
             self.runCmd(
                 "register write " +
                 st0regname +
                 " \"{0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}\"")
             self.expect(
                 "register read " +
                 st0regname +
                 " --format f",

lldb/trunk/packages/Python/lldbsuite/test/functionalities/step-avoids-no-debug/TestStepNoDebug.py

 from lldbsuite.test import lldbutil
 
 
 class ReturnValueTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test_step_out_with_python(self):
         """Test stepping out using avoid-no-debug with dsyms."""
         self.build()
         self.get_to_starting_point()
         self.do_step_out_past_nodebug()
 
     @add_test_categories(['pyapi'])
     @decorators.expectedFailureAll(
         compiler="gcc", bugnumber="llvm.org/pr28549")
     @decorators.expectedFailureAll(
         compiler="clang",
         compiler_version=[
             ">=",
             "3.9"],
         archs=["i386"],
         bugnumber="llvm.org/pr28549")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test_step_over_with_python(self):
         """Test stepping over using avoid-no-debug with dwarf."""
         self.build()
         self.get_to_starting_point()
         self.do_step_over_past_nodebug()
 
     @add_test_categories(['pyapi'])
     @decorators.expectedFailureAll(
         compiler="gcc", bugnumber="llvm.org/pr28549")
     @decorators.expectedFailureAll(
         compiler="clang",
         compiler_version=[
             ">=",
             "3.9"],
         archs=["i386"],
         bugnumber="llvm.org/pr28549")
     @expectedFailureAll(oslist=["ios", "tvos", "bridgeos"], bugnumber="<rdar://problem/34026777>")  # lldb doesn't step past last source line in function on arm64
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test_step_in_with_python(self):
         """Test stepping in using avoid-no-debug with dwarf."""
         self.build()
         self.get_to_starting_point()
         self.do_step_in_past_nodebug()
 
     def setUp(self):
         TestBase.setUp(self)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/thread/jump/TestThreadJump.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ThreadJumpTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test(self):
         """Test thread jump handling."""
         self.build(dictionary=self.getBuildFlags())
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Find the line numbers for our breakpoints.
         self.mark1 = line_number('main.cpp', '// 1st marker')

lldb/trunk/packages/Python/lldbsuite/test/functionalities/thread/num_threads/TestNumThreads.py

def test_number_of_threads(self):
 
         # Using std::thread may involve extra threads, so we assert that there are
         # at least 4 rather than exactly 4.
         self.assertTrue(
             num_threads >= 13,
             'Number of expected threads and actual threads do not match.')
 
     @skipIfDarwin # rdar://33462362
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37658")
     def test_unique_stacks(self):
         """Test backtrace unique with multiple threads executing the same stack."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Set a break point on the thread3 notify all (should get hit on threads 4-13).
         lldbutil.run_break_set_by_file_and_line(

lldb/trunk/packages/Python/lldbsuite/test/lang/c/conflicting-symbol/TestConflictingSymbol.py

class TestConflictingSymbols(TestBase):
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         TestBase.setUp(self)
         lldbutil.mkdir_p(self.getBuildArtifact("One"))
         lldbutil.mkdir_p(self.getBuildArtifact("Two"))
 
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
     def test_conflicting_symbols(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Register our shared libraries for remote targets so they get
         # automatically uploaded

lldb/trunk/packages/Python/lldbsuite/test/lang/c/step-target/TestStepTarget.py

def get_to_start(self):
             process, break_in_main)
 
         if len(threads) != 1:
             self.fail("Failed to stop at first breakpoint in main.")
 
         thread = threads[0]
         return thread
 
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test_with_end_line(self):
         """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
 
         thread = self.get_to_start()
 
         error = lldb.SBError()
         thread.StepInto("lotsOfArgs", self.end_line, error)
         frame = thread.frames[0]
 
         self.assertTrue(frame.name == "lotsOfArgs", "Stepped to lotsOfArgs.")
 
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test_with_end_line_bad_name(self):
         """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
 
         thread = self.get_to_start()
 
         error = lldb.SBError()
         thread.StepInto("lotsOfArgssss", self.end_line, error)
         frame = thread.frames[0]
         self.assertTrue(
             frame.line_entry.line == self.end_line,
             "Stepped to the block end.")
 
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test_with_end_line_deeper(self):
         """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
 
         thread = self.get_to_start()
 
         error = lldb.SBError()
         thread.StepInto("modifyInt", self.end_line, error)
         frame = thread.frames[0]
         self.assertTrue(frame.name == "modifyInt", "Stepped to modifyInt.")
 
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test_with_command_and_block(self):
         """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
 
         thread = self.get_to_start()
 
         result = lldb.SBCommandReturnObject()
         self.dbg.GetCommandInterpreter().HandleCommand(
             'thread step-in -t "lotsOfArgs" -e block', result)
         self.assertTrue(
             result.Succeeded(),
             "thread step-in command succeeded.")
 
         frame = thread.frames[0]
         self.assertTrue(frame.name == "lotsOfArgs", "Stepped to lotsOfArgs.")
 
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr32343")
     def test_with_command_and_block_and_bad_name(self):
         """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
 
         thread = self.get_to_start()
 
         result = lldb.SBCommandReturnObject()
         self.dbg.GetCommandInterpreter().HandleCommand(
             'thread step-in -t "lotsOfArgsssss" -e block', result)

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/class_static/TestStaticVariables.py

class StaticVariableTestCase(TestBase):
     @expectedFailureAll(
         compiler=["gcc"],
         bugnumber="Compiler emits incomplete debug info")
     @expectedFailureAll(
         compiler=["clang"],
         compiler_version=["<", "3.9"],
         bugnumber='llvm.org/pr20550')
     @add_test_categories(['pyapi'])
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
     def test_with_python_api(self):
         """Test Python APIs on file and class static variables."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespace.py

def test_breakpoints_func_auto(self):
             "func", lldb.eFunctionNameTypeAuto, module_list, cu_list)
         for bp_loc in bp:
             name = bp_loc.GetAddress().GetFunction().GetName()
             self.assertTrue(
                 name in names,
                 "make sure breakpoint locations are correct for 'func' with eFunctionNameTypeAuto")
 
     @expectedFailureAll(bugnumber="llvm.org/pr28548", compiler="gcc")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
     def test_breakpoints_func_full(self):
         """Test that we can set breakpoints correctly by fullname to find all functions whose fully qualified name is "func"
            (no namespaces)."""
         self.build()
 
         names = ["func()", "func(int)"]
 
         # Create a target by the debugger.

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/signed_types/TestSignedTypes.py

 """
 Test that variables with signed types display correctly.
 """
 
 from __future__ import print_function
 
 
 import os
 import time
 import re
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 
 
 class SignedTypesTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.source = 'main.cpp'
         self.line = line_number(
             self.source, '// Set break point at this line.')
 
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
     def test(self):
         """Test that variables with signed types display correctly."""
         self.build()
 
         # Run in synchronous mode
         self.dbg.SetAsync(False)
 
         # Create a target by the debugger.

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/template/TestTemplateArgs.py

def test_integer_args(self):
             'got a valid expression result from expression "testneg.getArg()"')
         self.assertTrue(
             expr_result.GetValue() == "-1",
             "testneg.getArg() == -1")
         self.assertTrue(
             expr_result.GetType().GetName() == "int",
             'expr_result.GetType().GetName() == "int"')
 
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
     def test_template_template_args(self):
         frame = self.prepareProcess()
 
         c1 = frame.FindVariable('c1')
         self.assertTrue(
             c1.IsValid(),
             'make sure we find a local variabble named "c1"')
         self.assertTrue(c1.GetType().GetName() == 'C<float, T1>')

lldb/trunk/packages/Python/lldbsuite/test/python_api/function_symbol/TestDisasmAPI.py

def setUp(self):
         TestBase.setUp(self)
         # Find the line number to of function 'c'.
         self.line1 = line_number(
             'main.c', '// Find the line number for breakpoint 1 here.')
         self.line2 = line_number(
             'main.c', '// Find the line number for breakpoint 2 here.')
 
     @add_test_categories(['pyapi'])
+    @expectedFailureAll(oslist=["windows"], bugnumber='llvm.org/pr21765')
     def test(self):
         """Exercise getting SBAddress objects, disassembly, and SBAddress APIs."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/packages/Python/lldbsuite/test/python_api/function_symbol/TestSymbolAPI.py

def setUp(self):
         TestBase.setUp(self)
         # Find the line number to of function 'c'.
         self.line1 = line_number(
             'main.c', '// Find the line number for breakpoint 1 here.')
         self.line2 = line_number(
             'main.c', '// Find the line number for breakpoint 2 here.')
 
     @add_test_categories(['pyapi'])
+    @expectedFailureAll(oslist=["windows"], bugnumber='llvm.org/pr21765')
     def test(self):
         """Exercise some SBSymbol and SBAddress APIs."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/packages/Python/lldbsuite/test/python_api/name_lookup/TestNameLookup.py

 from lldbsuite.test import lldbutil
 
 
 class TestNameLookup(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
+    @expectedFailureAll(oslist=["windows"], bugnumber='llvm.org/pr21765')
     def test_target(self):
         """Exercise SBTarget.FindFunctions() with various name masks.
         
         A previous regression caused mangled names to not be able to be looked up.
         This test verifies that using a mangled name with eFunctionNameTypeFull works
         and that using a function basename with eFunctionNameTypeFull works for all
         C++ functions that are at the global namespace level."""
         self.build();

lldb/trunk/packages/Python/lldbsuite/test/python_api/target/TestTargetAPI.py

class TargetAPITestCase(TestBase):
 
     @add_test_categories(['pyapi'])
     def test_get_description(self):
         """Exercise SBTarget.GetDescription() API."""
         self.build()
         self.get_description()
 
     @add_test_categories(['pyapi'])
+    @expectedFailureAll(oslist=["windows"], bugnumber='llvm.org/pr21765')
     def test_resolve_symbol_context_with_address(self):
         """Exercise SBTarget.ResolveSymbolContextForAddress() API."""
         self.build()
         self.resolve_symbol_context_with_address()
 
     @add_test_categories(['pyapi'])
     def test_get_platform(self):
         d = {'EXE': 'b.out'}

lldb/trunk/packages/Python/lldbsuite/test/python_api/thread/TestThreadAPI.py

def test_step_out_of_malloc_into_function_b(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 build() does.
         d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.step_out_of_malloc_into_function_b(self.exe_name)
 
     @add_test_categories(['pyapi'])
+    @expectedFailureAll(oslist=["windows"], bugnumber='llvm.org/pr32343')
     def test_step_over_3_times(self):
         """Test Python SBThread.StepOver() API."""
         # We build a different executable than the default build() does.
         d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.step_over_3_times(self.exe_name)