Update Python tests for lldb-server on Windows

[asmith]

Summary

Thanks to Hui Huang and reviewers for all the help with this patch!

[labath]

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteKill.py

17–23 ↗

(On Diff #198674)

If I understand correctly, the regexes differ only in the first letter. If that's the case, then you could just factor out the rest of the regex and just compute the letter differently:

stop_type = 'W' if windows else 'X'
reg_expr = r"^\${}...".format(stop_type)

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteModuleInfo.py

24–27 ↗

(On Diff #198674)

It sounds like you could just unconditionally replace all backslashes with double-backslashes here. That would result in us also correctly handling posix paths that happen to contain a backslash.

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteProcessInfo.py

178–191 ↗

(On Diff #198674)

I'm not sure why the original test was made linux-specific, but I think you can just drop the os name from the test and have a single test which checks for both the presence of parent-pid and triple. No @skipUnless needed as all platforms that currently have a working lldb-server should support these fields.

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py

208–212 ↗

(On Diff #198674)

Is this something that we consider to be a bug, or is it just how debugging is supposed to work on windows? If it's a bug then fine, but if not then we might consider adjusting the expectations in the test (or just skipping it).

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemote_qThreadStopInfo.py

146–153 ↗

(On Diff #198674)

I think this assertion should just be deleted. If the assertion below (that one thread has a stop reason) is true, then it trivially true that the rest of the threads don't have one. Whether or not a platforms spawns an extra thread does not seem to be relevant for this test.

packages/Python/lldbsuite/test/tools/lldb-server/inferior-crash/TestGdbRemoteAbort.py

40 ↗

(On Diff #198674)

Do you have any plans for changing this? Given that windows does not support signals, maybe it should stay 0...

[clayborg]

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteKill.py

17 ↗

(On Diff #198674)

Just make one if there can be two letters?:

reg_expr = r"^\$[XW][0-9a-fA-F]+([^#]*)#[0-9A-Fa-f]{2}"

20–23 ↗

(On Diff #198674)

Remove

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteModuleInfo.py

22 ↗

(On Diff #198674)

Use json.dumps:

module_path = json.dumps(lldbutil.append_to_process_working_directory(self, "a.out"))

24–27 ↗

(On Diff #198674)

Remove

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteSingleStep.py

23 ↗

(On Diff #198674)

We probably don't need pty support just to support STDIO redirection to a child process we spawn. That is how it is done for linux, but doens't need to be how it is done on windows. Be great if we can fix this.

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemote_qThreadStopInfo.py

59–61 ↗

(On Diff #198674)

Will this always be "thread_count+1" for window? Or can there be more threads.

This leads to a higher level question: Does the user ever want to see the "DebugBreakProcess" thread in the IDE? Should we just never report this thread from lldb-server and avoid these mismatch issues? We should be consistent with what other windows debuggers do (show DebugBreakProcess or not).

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemote_vCont.py

108 ↗

(On Diff #198674)

We probably don't need pty support just to support STDIO redirection to a child process we spawn. That is how it is done for linux, but doens't need to be how it is done on windows. Be great if we can fix this.

[Hui]

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteModuleInfo.py

24–27 ↗

(On Diff #198674)

The 'jModulesInfo' packet is a json string. I tested with json.loads as follows.
It seemed to me that module_path needs to be escaped, i.e. 'd:\\\\abc' or be 'd:/abc'.

not-working case:

>>> module_path = 'd:\abc'
>>> json.dumps(module_path)
'"d:\\u0007bc"'
>>> json.loads('[{"[file":"%s"}]' % json.dumps(module_path))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.7/json/__init__.py", line 339, in loads
    return _default_decoder.decode(s)
  File "/usr/lib/python2.7/json/decoder.py", line 364, in decode
    obj, end = self.raw_decode(s, idx=_w(s, 0).end())
  File "/usr/lib/python2.7/json/decoder.py", line 380, in raw_decode
    obj, end = self.scan_once(s, idx)
ValueError: Expecting , delimiter: line 1 column 13 (char 12)

working case:

>>> module_path = 'd:\\\\abc'
>>> json.loads('[{"[file":"%s"}]' % module_path)
[{u'[file': u'd:\\abc'}]

[labath]

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteModuleInfo.py

24–27 ↗

(On Diff #198674)

There are multiple levels of quoting happening here, and I believe you're getting them mixed up:

module_path = 'd:\abc'

This is already wrong, because python will interpret the \a as the ASCII BEL character, resulting in the string consisting of: 'd', ':', BEL, 'b', 'c'

>>> "d:\abc"
'd:\x07bc'

The easiest fix is to use "raw" python strings:

r"d:\abc"
'd:\\abc'

Note that the '\' in the output string it's not doubled, it is just how the python dumper makes sure the output is unambiguous. You can for instance check that with: len(r"d:\abc") which returns 6 as expected.

After that, your not-working case works almost fine:

>>> json.loads('[{"[file":"%s"}]' % json.dumps(module_path))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib64/python3.6/json/__init__.py", line 354, in loads
    return _default_decoder.decode(s)
  File "/usr/lib64/python3.6/json/decoder.py", line 339, in decode
    obj, end = self.raw_decode(s, idx=_w(s, 0).end())
  File "/usr/lib64/python3.6/json/decoder.py", line 355, in raw_decode
    obj, end = self.scan_once(s, idx)
json.decoder.JSONDecodeError: Expecting ',' delimiter: line 1 column 13 (char 12)
>>> json.loads('[{"[file":%s}]' % json.dumps(module_path))
[{'[file': 'd:\\abc'}]

Note I removed the superfluous quotes in the second attempt. However, if we're going to be using the json package for this, then there's an even simpler way to write this:

>>> json.dumps([{"file": module_path}])
'[{"file": "d:\\\\abc"}]'
>>> json.loads(json.dumps([{"file": module_path}]))
[{'file': 'd:\\abc'}]

[labath]

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteProcessInfo.py

205–217 ↗

(On Diff #199554)

These two tests can also be merged and made @skipIfDarwin as that is the only platform using the cpu(sub)type fields.

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py

208–212 ↗

(On Diff #198674)

You marked this as done, but it's not obvious how is this comment resolved (or indeed, if it needs to be resolved). Can you elaborate?

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemote_qThreadStopInfo.py

146–153 ↗

(On Diff #198674)

This comment doesn't appear to be "done".

packages/Python/lldbsuite/test/tools/lldb-server/inferior-crash/TestGdbRemoteAbort.py

40 ↗

(On Diff #198674)

I'd like to hear your thoughts on this...

If the idea is for the signal number to stay zero, then the comment shouldn't say "for now" but instead say something to the effect that abort() does not cause a signal to be raised on windows because windows doesn't have signals. If the idea is to change this later, then I'd like to understand how/why.

[clayborg]

packages/Python/lldbsuite/test/dotest.py

1313 ↗

(On Diff #199554)

Update comment

[Hui]

packages/Python/lldbsuite/test/tools/lldb-server/inferior-crash/TestGdbRemoteAbort.py

40 ↗

(On Diff #198674)

I think the signal number can just stay zero (treated as invalid) unless there is any strategy that will
need valid ones in the future for Windows user-mode debugging(or for kernel-mode debugging?).
The proposed implementation of native process/thread for windows in D56233 is mainly signal free.

There will be several slight difference(worth mentioning) by always filling with zero signo

(1) In remote debugging case, T* packet is to detail the stopped reason for a thread.
W or w/o a valid signal the messages shown on lldb are slightly different.
(StopReason::eStopReasonBreakpoint vs StopReason::eStopReasonException)

On Linux,

thread #1, name = 'a.out', stop reason = signal SIGSEGV: invalid address (fault address: 0x0)

On Windows,
thread #1, name = 'a.out', stop reason = Exception 0xc0000005 encountered at address 0x7ff6011c1093

(2) The GDB remote serial protocol does have several signals related packets,
like "vCont;S" to resume a thread by single stepping with signal or "vCont;C" to continue with signal.
For example, vCont;S06 to single step with signo=6 (SIGABRT).

Such packets won't be available on Windows. The continuation of a stopped thread relies on how
the exception is dispatched and handled. This is mentioned at

https://docs.microsoft.com/en-us/windows/desktop/debug/exception-dispatching

In this python test case, if a segfault happens, the EXCEPTION_ACCESS_VIOLATION (0xc0000005) is raised.
Since there is no eh installed in user application, the exception will be dispatched to lldb Debugger for the second time
where a default eh or ExitProcess will be called. ( D56233 patch might need such changes)

[Hui]

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py

208–212 ↗

(On Diff #198674)

DebugBreakProcess is supposed to spawn a new thread in the debugged process and then the thread exits after the irq is handled.

See below thread #1 is main thread of the debugged process and thread #2 is the newly spawned.
json string contains two stopped threads information.

looks like the stopped threads number is supposed to +1, but in order to be consistent with Visual Studio,
it shall be possible to only report the thread #1 stop info.

To modify the python script for Windows is at some cost. Maybe just skip them?

(lldb) process interrupt
 GDBRemoteClientBase::Lock::Lock sent packet: \x03
...
 <  16> send packet: $jThreadsInfo#c1
 < 354> read packet: $[{"name":"main.exe","reason":"trace","registers":{"16":"dc6b5a9af77f0000","6":"0000000000000000","7":"80fa1e8aca000000"}],"tid":23108}],{"description":"Exception 0x80000003 encountered at address 0x7ffa1701e370","name":"main.exe","reason":"exception","registers":{"16":"71e30117fa7f0000","6":"0000000000000000","7":"28fa4f8aca000000"}],"tid":23716}]]#f0

Process 27544 stopped
* thread #1, name = 'main.exe', stop reason = trace
    frame #0: 0x00007ff79a5a6bdc main.exe`main at main.cpp:7
   4    {
   5
   6      printf("abc");
-> 7      while(1);
   8      return 1;
   9    }
  thread #2, name = 'main.exe', stop reason = Exception 0x80000003 encountered at address 0x7ffa1701e370
    frame #0: 0x00007ffa1701e371
->  0x7ffa1701e371: retq
    0x7ffa1701e372: int3
    0x7ffa1701e373: int3
    0x7ffa1701e374: int3

[labath]

Thanks for explaining. I think this is good to go, sans the merging of the two tests I requested, and the comment fix that @clayborg noticed.

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py

208–212 ↗

(On Diff #198674)

Ok, I see. Hiding the thread sounds like the right thing to do, though I'm not sure if it should be done at lldb-server level. My feeling is it should be done at a higher level, because lldb-server should report the thing that the OS sees, and the OS definitely sees two threads here. It may be better to hide this in the higher levels of the debugger (unless the user has requested some sort of a verbose view).

If we go down that path, then I think it would be worth it to update these tests to have the correct expectation, but it does not have to happen now. We can leave them XFAILed for the time being. Thanks for explaining.

packages/Python/lldbsuite/test/tools/lldb-server/inferior-crash/TestGdbRemoteAbort.py

40 ↗

(On Diff #198674)

thread #1, name = 'a.out', stop reason = Exception 0xc0000005 encountered at address 0x7ff6011c1093

That sounds like the right thing to report, as that is what actually happened.

vCont;S06

Yeah, I think lldb-server on windows should just not support these packets (return an error or something). I don't know if there is a concept of "injecting" exceptions on windows, but if there is, we can have a discussion later on how to implement that.

So overall I think skipping this test is the right thing to do. I just think the message giving the reason could be a bit better. Maybe just "abort() does not send a signal on windows" ?

[labath]

Ok, let's give this a shot.

[asmith]

Any more comments on the tests for Windows?

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

def run_suite():
     checkLibcxxSupport()
     checkLibstdcxxSupport()
     checkWatchpointSupport()
     checkDebugInfoSupport()
 
     # Don't do debugserver tests on anything except OS X.
     configuration.dont_do_debugserver_test = "linux" in target_platform or "freebsd" in target_platform or "windows" in target_platform
 
-    # Don't do lldb-server (llgs) tests on anything except Linux.
-    configuration.dont_do_llgs_test = not ("linux" in target_platform)
+    # Don't do lldb-server (llgs) tests on anything except Linux and Windows.
+    configuration.dont_do_llgs_test = not ("linux" in target_platform) and not ("windows" in target_platform)
 
     # Collect tests from the specified testing directories. If a test
     # subdirectory filter is explicitly specified, limit the search to that
     # subdirectory.
     exclusive_test_subdir = configuration.get_absolute_path_to_exclusive_test_subdir()
     if exclusive_test_subdir:
         dirs_to_search = [exclusive_test_subdir]
     else:

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteAuxvSupport.py

class TestGdbRemoteAuxvSupport(gdbremote_testcase.GdbRemoteTestCaseBase):
     #
     # We skip the "supports_auxv" test on debugserver.  The rest of the tests
     # appropriately skip the auxv tests if the support flag is not present
     # in the qSupported response, so the debugserver test bits are still there
     # in case debugserver code one day does have auxv support and thus those
     # tests don't get skipped.
     #
 
+    @skipIfWindows # no auxv support.
     @llgs_test
     def test_supports_auxv_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.supports_auxv()
 
     def auxv_data_is_correct_size(self):
         (word_size, auxv_data) = self.get_raw_auxv_data()
         self.assertIsNotNone(auxv_data)
 
         # Ensure auxv data is a multiple of 2*word_size (there should be two
         # unsigned long fields per auxv entry).
         self.assertEqual(len(auxv_data) % (2 * word_size), 0)
         # print("auxv contains {} entries".format(len(auxv_data) / (2*word_size)))
 
     @debugserver_test
     def test_auxv_data_is_correct_size_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_data_is_correct_size()
 
+    @skipIfWindows
     @llgs_test
     def test_auxv_data_is_correct_size_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_data_is_correct_size()
 
     def auxv_keys_look_valid(self):
class TestGdbRemoteAuxvSupport(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     @debugserver_test
     def test_auxv_keys_look_valid_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_keys_look_valid()
 
+    @skipIfWindows
     @llgs_test
     def test_auxv_keys_look_valid_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_keys_look_valid()
 
     def auxv_chunked_reads_work(self):
class TestGdbRemoteAuxvSupport(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     @debugserver_test
     def test_auxv_chunked_reads_work_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_chunked_reads_work()
 
+    @skipIfWindows
     @llgs_test
     def test_auxv_chunked_reads_work_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_chunked_reads_work()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteKill.py

 from __future__ import print_function
 
 
 import gdbremote_testcase
 import lldbgdbserverutils
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestGdbRemoteKill(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
 
     def attach_commandline_kill_after_initial_stop(self):
+        reg_expr = r"^\$[XW][0-9a-fA-F]+([^#]*)#[0-9A-Fa-f]{2}"
         procs = self.prep_debug_monitor_and_inferior()
         self.test_sequence.add_log_lines([
             "read packet: $k#6b",
-            {"direction": "send", "regex": r"^\$X[0-9a-fA-F]+([^#]*)#[0-9A-Fa-f]{2}"},
+            {"direction": "send", "regex": reg_expr},
         ], True)
 
         if self.stub_sends_two_stop_notifications_on_kill:
             # Add an expectation for a second X result for stubs that send two
             # of these.
             self.test_sequence.add_log_lines([
-                {"direction": "send", "regex": r"^\$X[0-9a-fA-F]+([^#]*)#[0-9A-Fa-f]{2}"},
+                {"direction": "send", "regex": reg_expr},
             ], True)
 
         self.expect_gdbremote_sequence()
 
         # Wait a moment for completed and now-detached inferior process to
         # clear.
         time.sleep(1)
 

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteModuleInfo.py

 from __future__ import print_function
 
-
+import json
 import gdbremote_testcase
 import lldbgdbserverutils
 from lldbsuite.support import seven
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestGdbRemoteModuleInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def module_info(self):
         procs = self.prep_debug_monitor_and_inferior()
         self.add_process_info_collection_packets()
         context = self.expect_gdbremote_sequence()
         info = self.parse_process_info_response(context)
 
         self.test_sequence.add_log_lines([
-            'read packet: $jModulesInfo:[{"file":"%s","triple":"%s"}]]#00' % (
-                lldbutil.append_to_process_working_directory(self, "a.out"),
-                seven.unhexlify(info["triple"])),
+            'read packet: $jModulesInfo:%s]#00' % json.dumps(
+                [{"file":lldbutil.append_to_process_working_directory(self, "a.out"),
+                  "triple":seven.unhexlify(info["triple"])}]),
             {"direction": "send",
              "regex": r'^\$\[{(.*)}\]\]#[0-9A-Fa-f]{2}',
              "capture": {1: "spec"}},
         ], True)
 
         context = self.expect_gdbremote_sequence()
         spec = context.get("spec")
         self.assertRegexpMatches(spec, '"file_path":".*"')

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteProcessInfo.py

class TestGdbRemoteProcessInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     @skipUnlessDarwin
     @llgs_test
     def test_qProcessInfo_contains_cputype_cpusubtype_llgs_darwin(self):
         self.init_llgs_test()
         self.build()
         self.qProcessInfo_contains_keys(set(['cputype', 'cpusubtype']))
 
-    @skipUnlessPlatform(["linux"])
     @llgs_test
-    def test_qProcessInfo_contains_triple_llgs_linux(self):
+    def test_qProcessInfo_contains_triple_ppid_llgs(self):
         self.init_llgs_test()
         self.build()
-        self.qProcessInfo_contains_keys(set(['triple']))
+        self.qProcessInfo_contains_keys(set(['triple', 'parent-pid']))
 
     @skipUnlessDarwin
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_qProcessInfo_does_not_contain_triple_debugserver_darwin(self):
         self.init_debugserver_test()
         self.build()
         # We don't expect to see triple on darwin.  If we do, we'll prefer triple
         # to cputype/cpusubtype and skip some darwin-based ProcessGDBRemote ArchSpec setup
         # for the remote Host and Process.
         self.qProcessInfo_does_not_contain_keys(set(['triple']))
 
     @skipUnlessDarwin
     @llgs_test
     def test_qProcessInfo_does_not_contain_triple_llgs_darwin(self):
         self.init_llgs_test()
         self.build()
         # We don't expect to see triple on darwin.  If we do, we'll prefer triple
         # to cputype/cpusubtype and skip some darwin-based ProcessGDBRemote ArchSpec setup
         # for the remote Host and Process.
         self.qProcessInfo_does_not_contain_keys(set(['triple']))
 
-    @skipUnlessPlatform(["linux"])
+    @skipIfDarwin
     @llgs_test
-    def test_qProcessInfo_does_not_contain_cputype_cpusubtype_llgs_linux(self):
+    def test_qProcessInfo_does_not_contain_cputype_cpusubtype_llgs(self):
         self.init_llgs_test()
         self.build()
         self.qProcessInfo_does_not_contain_keys(set(['cputype', 'cpusubtype']))

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteSingleStep.py

class TestGdbRemoteSingleStep(gdbremote_testcase.GdbRemoteTestCaseBase):
     @debugserver_test
     def test_single_step_only_steps_one_instruction_with_s_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.single_step_only_steps_one_instruction(
             use_Hc_packet=True, step_instruction="s")
 
+    @skipIfWindows # No pty support to test any inferior std -i/e/o
     @llgs_test
     @expectedFailureAndroid(
         bugnumber="llvm.org/pr24739",
         archs=[
             "arm",
             "aarch64"])
     @expectedFailureAll(
         oslist=["linux"],

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py

class TestGdbRemoteThreadsInStopReply(
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     @debugserver_test
     def test_stop_reply_reports_multiple_threads_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.stop_reply_reports_multiple_threads(5)
 
+    # In current implementation of llgs on Windows, as a response to '\x03' packet, the debugger
+    # of the native process will trigger a call to DebugBreakProcess that will create a new thread
+    # to handle the exception debug event. So one more stop thread will be notified to the
+    # delegate, e.g. llgs.  So tests below to assert the stop threads number will all fail.
+    @expectedFailureAll(oslist=["windows"])
     @llgs_test
     def test_stop_reply_reports_multiple_threads_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.stop_reply_reports_multiple_threads(5)
 
     def no_QListThreadsInStopReply_supplies_no_threads(self, thread_count):
         # Gather threads from stop notification when QThreadsInStopReply is not
         # enabled.
         stop_reply_threads = self.gather_stop_reply_threads(None, thread_count)
         self.assertEqual(len(stop_reply_threads), 0)
 
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     @debugserver_test
     def test_no_QListThreadsInStopReply_supplies_no_threads_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.no_QListThreadsInStopReply_supplies_no_threads(5)
 
+    @expectedFailureAll(oslist=["windows"])
     @llgs_test
     def test_no_QListThreadsInStopReply_supplies_no_threads_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.no_QListThreadsInStopReply_supplies_no_threads(5)
 
     def stop_reply_reports_correct_threads(self, thread_count):
class TestGdbRemoteThreadsInStopReply(
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     @debugserver_test
     def test_stop_reply_reports_correct_threads_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.stop_reply_reports_correct_threads(5)
 
+    @expectedFailureAll(oslist=["windows"])
     @llgs_test
     def test_stop_reply_reports_correct_threads_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.stop_reply_reports_correct_threads(5)
 
     def stop_reply_contains_thread_pcs(self, thread_count):
         results = self.gather_stop_reply_pcs(
                 self.ENABLE_THREADS_IN_STOP_REPLY_ENTRIES, thread_count)
         stop_reply_pcs = results["thread_pcs"]
         pc_register = results["pc_register"]
         little_endian = results["little_endian"]
         self.assertEqual(len(stop_reply_pcs), thread_count)
 
         threads_info_pcs = self.gather_threads_info_pcs(pc_register,
                 little_endian)
 
         self.assertEqual(len(threads_info_pcs), thread_count)
         for thread_id in stop_reply_pcs:
             self.assertTrue(thread_id in threads_info_pcs)
             self.assertTrue(int(stop_reply_pcs[thread_id], 16)
                     == int(threads_info_pcs[thread_id], 16))
 
+    @expectedFailureAll(oslist=["windows"])
     @llgs_test
     def test_stop_reply_contains_thread_pcs_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.stop_reply_contains_thread_pcs(5)
 
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     @debugserver_test
     def test_stop_reply_contains_thread_pcs_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.stop_reply_contains_thread_pcs(5)

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemote_qThreadStopInfo.py

def gather_stop_replies_via_qThreadStopInfo(self, thread_count):
             ],
             True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Wait until all threads have started.
         threads = self.wait_for_thread_count(thread_count, timeout_seconds=3)
         self.assertIsNotNone(threads)
+
+        # On Windows, there could be more threads spawned. For example, DebugBreakProcess will
+        # create a new thread from the debugged process to handle an exception event. So here we
+        # assert 'GreaterEqual' condition.
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+        if re.match(".*-.*-windows", triple):
+            self.assertGreaterEqual(len(threads), thread_count)
+        else:
             self.assertEqual(len(threads), thread_count)
 
         # Grab stop reply for each thread via qThreadStopInfo{tid:hex}.
         stop_replies = {}
         thread_dicts = {}
         for thread in threads:
             # Run the qThreadStopInfo command.
             self.reset_test_sequence()
             self.test_sequence.add_log_lines(
def gather_stop_replies_via_qThreadStopInfo(self, thread_count):
 
             # Hang on to the key-val dictionary for the thread.
             thread_dicts[kv_thread_id] = kv_dict
 
         return (stop_replies, thread_dicts)
 
     def qThreadStopInfo_works_for_multiple_threads(self, thread_count):
         (stop_replies, _) = self.gather_stop_replies_via_qThreadStopInfo(thread_count)
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+        # Consider one more thread created by calling DebugBreakProcess.
+        if re.match(".*-.*-windows", triple):
+            self.assertGreaterEqual(len(stop_replies), thread_count)
+        else:
             self.assertEqual(len(stop_replies), thread_count)
 
     @debugserver_test
     def test_qThreadStopInfo_works_for_multiple_threads_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qThreadStopInfo_works_for_multiple_threads(self.THREAD_COUNT)
 
def qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt(
         no_stop_reason_count = sum(
             1 for stop_reason in list(
                 stop_replies.values()) if stop_reason == 0)
         with_stop_reason_count = sum(
             1 for stop_reason in list(
                 stop_replies.values()) if stop_reason != 0)
 
         # All but one thread should report no stop reason.
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+
+        # Consider one more thread created by calling DebugBreakProcess.
+        if re.match(".*-.*-windows", triple):
+            self.assertGreaterEqual(no_stop_reason_count, thread_count - 1)
+        else:
             self.assertEqual(no_stop_reason_count, thread_count - 1)
 
         # Only one thread should should indicate a stop reason.
         self.assertEqual(with_stop_reason_count, 1)
 
     @debugserver_test
     def test_qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt_debugserver(
             self):
         self.init_debugserver_test()
class TestGdbRemote_qThreadStopInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
     @debugserver_test
     def test_qThreadStopInfo_has_valid_thread_names_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qThreadStopInfo_has_valid_thread_names(self.THREAD_COUNT, "a.out")
 
     # test requires OS with set, equal thread names by default.
-    @skipUnlessPlatform(["linux"])
+    # Windows thread does not have name property, equal names as the process's by default.
+    @skipUnlessPlatform(["linux", "windows"])
     @llgs_test
     def test_qThreadStopInfo_has_valid_thread_names_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qThreadStopInfo_has_valid_thread_names(self.THREAD_COUNT, "a.out")

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemote_vCont.py

class TestGdbRemote_vCont(gdbremote_testcase.GdbRemoteTestCaseBase):
     def test_single_step_only_steps_one_instruction_with_Hc_vCont_s_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.single_step_only_steps_one_instruction(
             use_Hc_packet=True, step_instruction="vCont;s")
 
+    @skipIfWindows # No pty support to test O* & I* notification packets.
     @llgs_test
     @expectedFailureAndroid(
         bugnumber="llvm.org/pr24739",
         archs=[
             "arm",
             "aarch64"])
     @expectedFailureAll(
         oslist=["linux"],
class TestGdbRemote_vCont(gdbremote_testcase.GdbRemoteTestCaseBase):
     def test_single_step_only_steps_one_instruction_with_vCont_s_thread_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.single_step_only_steps_one_instruction(
             use_Hc_packet=False, step_instruction="vCont;s:{thread}")
 
+    @skipIfWindows # No pty support to test O* & I* notification packets.
     @llgs_test
     @expectedFailureAndroid(
         bugnumber="llvm.org/pr24739",
         archs=[
             "arm",
             "aarch64"])
     @expectedFailureAll(
         oslist=["linux"],

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestLldbGdbServer.py

class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
 
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_inferior_print_exit_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.inferior_print_exit()
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     @expectedFlakeyLinux("llvm.org/pr25652")
     def test_inferior_print_exit_llgs(self):
         self.init_llgs_test()
         self.build()
         self.inferior_print_exit()
 
     def first_launch_stop_reply_thread_matches_first_qC(self):
def qRegisterInfo_contains_avx_registers(self):
 
         # Collect all generics found.
         register_sets = {
             reg_info['set']: 1 for reg_info in reg_infos if 'set' in reg_info}
         self.assertEqual(
             self.targetHasAVX(),
             "Advanced Vector Extensions" in register_sets)
 
+    @expectedFailureAll(oslist=["windows"]) # no avx for now.
     @llgs_test
     def test_qRegisterInfo_contains_avx_registers_llgs(self):
         self.init_llgs_test()
         self.build()
         self.qRegisterInfo_contains_avx_registers()
 
     def qThreadInfo_contains_thread(self):
         procs = self.prep_debug_monitor_and_inferior()
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_qThreadInfo_contains_thread_attach_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_attach()
         self.qThreadInfo_contains_thread()
 
+    @expectedFailureAll(oslist=["windows"]) # expect one more thread stopped
     @llgs_test
     def test_qThreadInfo_contains_thread_attach_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_attach()
         self.qThreadInfo_contains_thread()
 
     def qThreadInfo_matches_qC(self):
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_qThreadInfo_matches_qC_attach_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_attach()
         self.qThreadInfo_matches_qC()
 
+    @expectedFailureAll(oslist=["windows"]) # expect one more thread stopped
     @llgs_test
     def test_qThreadInfo_matches_qC_attach_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_attach()
         self.qThreadInfo_matches_qC()
 
     def p_returns_correct_data_size_for_each_qRegisterInfo(self):
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_Hg_switches_to_3_threads_launch_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.Hg_switches_to_3_threads()
 
+    @expectedFailureAll(oslist=["windows"]) # expect 4 threads
     @llgs_test
     def test_Hg_switches_to_3_threads_launch_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.Hg_switches_to_3_threads()
 
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_Hg_switches_to_3_threads_attach_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_attach()
         self.Hg_switches_to_3_threads()
 
+    @expectedFailureAll(oslist=["windows"]) # expecting one more thread
     @llgs_test
     def test_Hg_switches_to_3_threads_attach_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_attach()
         self.Hg_switches_to_3_threads()
 
     def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     def test_Hc_then_Csignal_signals_correct_thread_launch_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         # Darwin debugserver translates some signals like SIGSEGV into some gdb
         # expectations about fixed signal numbers.
         self.Hc_then_Csignal_signals_correct_thread(self.TARGET_EXC_BAD_ACCESS)
 
+    @skipIfWindows # no SIGSEGV support
     @llgs_test
     def test_Hc_then_Csignal_signals_correct_thread_launch_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.Hc_then_Csignal_signals_correct_thread(
             lldbutil.get_signal_number('SIGSEGV'))
 
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_m_packet_reads_memory_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.m_packet_reads_memory()
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     def test_m_packet_reads_memory_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.m_packet_reads_memory()
 
     def qMemoryRegionInfo_is_supported(self):
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_qMemoryRegionInfo_reports_code_address_as_executable_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_code_address_as_executable()
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     def test_qMemoryRegionInfo_reports_code_address_as_executable_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_code_address_as_executable()
 
     def qMemoryRegionInfo_reports_stack_address_as_readable_writeable(self):

     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_qMemoryRegionInfo_reports_stack_address_as_readable_writeable_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_stack_address_as_readable_writeable()
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     def test_qMemoryRegionInfo_reports_stack_address_as_readable_writeable_llgs(
             self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_stack_address_as_readable_writeable()
 

     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_qMemoryRegionInfo_reports_heap_address_as_readable_writeable_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_heap_address_as_readable_writeable()
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     def test_qMemoryRegionInfo_reports_heap_address_as_readable_writeable_llgs(
             self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_heap_address_as_readable_writeable()
 
def test_software_breakpoint_set_and_remove_work_debugserver(self):
         if self.getArchitecture() == "arm":
             # TODO: Handle case when setting breakpoint in thumb code
             self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
         else:
             self.build()
         self.set_inferior_startup_launch()
         self.breakpoint_set_and_remove_work(want_hardware=False)
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     @expectedFlakeyLinux("llvm.org/pr25652")
     def test_software_breakpoint_set_and_remove_work_llgs(self):
         self.init_llgs_test()
         if self.getArchitecture() == "arm":
             # TODO: Handle case when setting breakpoint in thumb code
             self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
         else:

     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_written_M_content_reads_back_correctly_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.written_M_content_reads_back_correctly()
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     @expectedFlakeyLinux("llvm.org/pr25652")
     def test_written_M_content_reads_back_correctly_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.written_M_content_reads_back_correctly()
 

     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_P_and_p_thread_suffix_work_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.P_and_p_thread_suffix_work()
 
+    @skipIfWindows
     @llgs_test
     def test_P_and_p_thread_suffix_work_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.P_and_p_thread_suffix_work()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/commandline/TestStubSetSID.py

class TestStubSetSIDTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     @debugserver_test
     @skipIfRemote  # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
     def test_sid_is_same_without_setsid_debugserver(self):
         self.init_debugserver_test()
         self.set_inferior_startup_launch()
         self.sid_is_same_without_setsid()
 
+    @skipIfWindows
     @llgs_test
     @skipIfRemote  # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
     @expectedFailureAll(oslist=['freebsd'])
     def test_sid_is_same_without_setsid_llgs(self):
         self.init_llgs_test()
         self.set_inferior_startup_launch()
         self.sid_is_same_without_setsid()
 
     @debugserver_test
     @skipIfRemote  # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
     def test_sid_is_different_with_setsid_debugserver(self):
         self.init_debugserver_test()
         self.set_inferior_startup_launch()
         self.sid_is_different_with_setsid()
 
+    @skipIfWindows
     @llgs_test
     @skipIfRemote  # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
     def test_sid_is_different_with_setsid_llgs(self):
         self.init_llgs_test()
         self.set_inferior_startup_launch()
         self.sid_is_different_with_setsid()
 
     @debugserver_test
     @skipIfRemote  # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
     def test_sid_is_different_with_S_debugserver(self):
         self.init_debugserver_test()
         self.set_inferior_startup_launch()
         self.sid_is_different_with_S()
 
+    @skipIfWindows
     @llgs_test
     @skipIfRemote  # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
     def test_sid_is_different_with_S_llgs(self):
         self.init_llgs_test()
         self.set_inferior_startup_launch()
         self.sid_is_different_with_S()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def get_stub_port_from_named_socket(self, read_timeout_seconds=5):
 
         return stub_port
 
     def init_llgs_test(self, use_named_pipe=True):
         if lldb.remote_platform:
             # Remote platforms don't support named pipe based port negotiation
             use_named_pipe = False
 
+            triple = self.dbg.GetSelectedPlatform().GetTriple()
+            if re.match(".*-.*-windows", triple):
+                self.skipTest("Remotely testing is not supported on Windows yet.")
+
             # Grab the ppid from /proc/[shell pid]/stat
             err, retcode, shell_stat = self.run_platform_command(
                 "cat /proc/$$/stat")
             self.assertTrue(
                 err.Success() and retcode == 0,
                 "Failed to read file /proc/$$/stat: %s, retcode: %d" %
                 (err.GetCString(),
                  retcode))
def init_llgs_test(self, use_named_pipe=True):
                  err.GetCString(),
                  retcode))
             exe = ls_output.split()[-1]
 
             # If the binary has been deleted, the link name has " (deleted)" appended.
             # Remove if it's there.
             self.debug_monitor_exe = re.sub(r' \(deleted\)$', '', exe)
         else:
+            # Need to figure out how to create a named pipe on Windows.
+            if platform.system() == 'Windows':
+                use_named_pipe = False
+
             self.debug_monitor_exe = get_lldb_server_exe()
             if not self.debug_monitor_exe:
                 self.skipTest("lldb-server exe not found")
 
         self.debug_monitor_extra_args = ["gdbserver"]
         self.setUpServerLogging(is_llgs=True)
 
         if use_named_pipe:

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/inferior-crash/TestGdbRemoteAbort.py

def inferior_abort_received(self):
                          lldbutil.get_signal_number('SIGABRT'))
 
     @debugserver_test
     def test_inferior_abort_received_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.inferior_abort_received()
 
+    @skipIfWindows # No signal is sent on Windows.
     @llgs_test
     # std::abort() on <= API 16 raises SIGSEGV - b.android.com/179836
     @expectedFailureAndroid(api_levels=list(range(16 + 1)))
     def test_inferior_abort_received_llgs(self):
         self.init_llgs_test()
         self.build()
         self.inferior_abort_received()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/inferior-crash/TestGdbRemoteSegFault.py

def inferior_seg_fault_received(self, expected_signo):
         self.assertEqual(int(hex_exit_code, 16), expected_signo)
 
     @debugserver_test
     def test_inferior_seg_fault_received_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.inferior_seg_fault_received(self.GDB_REMOTE_STOP_CODE_BAD_ACCESS)
 
+    @skipIfWindows # No signal is sent on Windows.
     @llgs_test
     def test_inferior_seg_fault_received_llgs(self):
         self.init_llgs_test()
         self.build()
         self.inferior_seg_fault_received(lldbutil.get_signal_number('SIGSEGV'))

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/lldbgdbserverutils.py

def process_is_running(pid, unknown_value=True):
     elif platform.system() in ['Darwin', 'Linux', 'FreeBSD', 'NetBSD']:
         # Build the list of running process ids
         output = subprocess.check_output(
             "ps ax | awk '{ print $1; }'", shell=True).decode("utf-8")
         text_process_ids = output.split('\n')[1:]
         # Convert text pids to ints
         process_ids = [int(text_pid)
                        for text_pid in text_process_ids if text_pid != '']
+    elif platform.system() == 'Windows':
+        output = subprocess.check_output(
+            "for /f \"tokens=2 delims=,\" %F in ('tasklist /nh /fi \"PID ne 0\" /fo csv') do @echo %~F", shell=True).decode("utf-8")
+        text_process_ids = output.split('\n')[1:]
+        process_ids = [int(text_pid)
+                       for text_pid in text_process_ids if text_pid != '']
     # elif {your_platform_here}:
     #   fill in process_ids as a list of int type process IDs running on
     #   the local system.
     else:
         # Don't know how to get list of running process IDs on this
         # OS, so return the "don't know" value.
         return unknown_value
 

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/signal-filtering/TestGdbRemote_QPassSignals.py

def test_change_signals_at_runtime(self):
 
         for signal_name in expected_signals:
             signo = lldbutil.get_signal_number(signal_name)
             self.expect_signal(signo)
             if signal_name == "SIGALRM":
                 self.ignore_signals(signals_to_ignore)
         self.expect_exit_code(len(signals_to_ignore))
 
+    @skipIfWindows # no signal support
     @llgs_test
     def test_default_signals_behavior(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         procs = self.prep_debug_monitor_and_inferior()
         expected_signals = ["SIGSEGV", "SIGUSR1", "SIGUSR2",
             "SIGALRM", "SIGFPE", "SIGBUS", "SIGINT", "SIGHUP"]

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/thread-name/TestGdbRemoteThreadName.py

def run_and_check_name(self, expected_name):
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         sigint = lldbutil.get_signal_number("SIGINT")
         self.assertEqual(sigint, int(context.get("signal"), 16))
         kv_dict = self.parse_key_val_dict(context.get("key_vals_text"))
         self.assertEqual(expected_name, kv_dict.get("name"))
 
+    @skipIfWindows # the test is not updated for Windows.
     @llgs_test
     def test(self):
         """ Make sure lldb-server can retrieve inferior thread name"""
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         procs = self.prep_debug_monitor_and_inferior()
 
         self.run_and_check_name("hello world")
         self.run_and_check_name("goodbye world")