Fixed intermittent failures in TestGdbRemote*/TestLldbGdbServer

[vharron]

Summary

test/tools/lldb-server/commandline/Test* were actually executing in
their parent directory. This looks fine at first because they aren't
compiling an inferior executable.

Unfortunately, they still call "make clean" during their cleanup,
which is likely causing all kinds of havok in tests running in the
parent directory

lldb/trunk/test/tools/lldb-server/TestGdbRemoteAttach.py

 import gdbremote_testcase
 import lldbgdbserverutils
 import unittest2
 
 from lldbtest import *
 
 class TestGdbRemoteAttach(gdbremote_testcase.GdbRemoteTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     def attach_with_vAttach(self):
         # Start the inferior, start the debug monitor, nothing is attached yet.
         procs = self.prep_debug_monitor_and_inferior(inferior_args=["sleep:60"])
         self.assertIsNotNone(procs)
 
         # Make sure the target process has been launched.
         inferior = procs.get("inferior")
         self.assertIsNotNone(inferior)

lldb/trunk/test/tools/lldb-server/TestGdbRemoteAuxvSupport.py

 import unittest2
 
 import gdbremote_testcase
 from lldbtest import *
 
 class TestGdbRemoteAuxvSupport(gdbremote_testcase.GdbRemoteTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     AUXV_SUPPORT_FEATURE_NAME = "qXfer:auxv:read"
 
     def has_auxv_support(self):
         inferior_args = ["message:main entered", "sleep:5"]
         procs = self.prep_debug_monitor_and_inferior(inferior_args=inferior_args)
 
         # Don't do anything until we match the launched inferior main entry output.
         # Then immediately interrupt the process.

lldb/trunk/test/tools/lldb-server/TestGdbRemoteExpeditedRegisters.py

 import unittest2
 
 import gdbremote_testcase
 from lldbtest import *
 
 class TestGdbRemoteExpeditedRegisters(gdbremote_testcase.GdbRemoteTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     def gather_expedited_registers(self):
         # Setup the stub and set the gdb remote command stream.
         procs = self.prep_debug_monitor_and_inferior(inferior_args=["sleep:2"])
         self.test_sequence.add_log_lines([
             # Start up the inferior.
             "read packet: $c#63",
             # Immediately tell it to stop.  We want to see what it reports.
             "read packet: {}".format(chr(03)),

lldb/trunk/test/tools/lldb-server/TestGdbRemoteKill.py

 import unittest2
 
 import gdbremote_testcase
 import lldbgdbserverutils
 
 from lldbtest import *
 
 class TestGdbRemoteKill(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
     def attach_commandline_kill_after_initial_stop(self):
         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}" },
             ], True)
 
         if self.stub_sends_two_stop_notifications_on_kill:

lldb/trunk/test/tools/lldb-server/TestGdbRemoteProcessInfo.py

 import gdbremote_testcase
 import lldbgdbserverutils
 import sys
 import unittest2
 
 from lldbtest import *
 
 class TestGdbRemoteProcessInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     def qProcessInfo_returns_running_process(self):
         procs = self.prep_debug_monitor_and_inferior()
         self.add_process_info_collection_packets()
 
         # Run the stream
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 

lldb/trunk/test/tools/lldb-server/TestGdbRemoteRegisterState.py

 import unittest2
 
 import gdbremote_testcase
 from lldbtest import *
 
 class TestGdbRemoteRegisterState(gdbremote_testcase.GdbRemoteTestCaseBase):
     """Test QSaveRegisterState/QRestoreRegisterState support."""
 
+    mydir = TestBase.compute_mydir(__file__)
+
     def grp_register_save_restore_works(self, with_suffix):
         # Start up the process, use thread suffix, grab main thread id.
         inferior_args = ["message:main entered", "sleep:5"]
         procs = self.prep_debug_monitor_and_inferior(inferior_args=inferior_args)
 
         self.add_process_info_collection_packets()
         self.add_register_info_collection_packets()
         if with_suffix:

lldb/trunk/test/tools/lldb-server/TestGdbRemoteSingleStep.py

 import unittest2
 
 import gdbremote_testcase
 from lldbtest import *
 
 class TestGdbRemoteSingleStep(gdbremote_testcase.GdbRemoteTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @debugserver_test
     @dsym_test
     def test_single_step_only_steps_one_instruction_with_s_debugserver_dsym(self):
         self.init_debugserver_test()
         self.buildDsym()
         self.set_inferior_startup_launch()
         self.single_step_only_steps_one_instruction(use_Hc_packet=True, step_instruction="s")
 

lldb/trunk/test/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py

 import unittest2
 
 import gdbremote_testcase
 from lldbtest import *
 
 class TestGdbRemoteThreadsInStopReply(gdbremote_testcase.GdbRemoteTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     ENABLE_THREADS_IN_STOP_REPLY_ENTRIES = [
         "read packet: $QListThreadsInStopReply#21",
         "send packet: $OK#00",
     ]
 
     def gather_stop_reply_threads(self, post_startup_log_lines, thread_count):
         # Set up the inferior args.
         inferior_args=[]

lldb/trunk/test/tools/lldb-server/TestGdbRemote_qThreadStopInfo.py

 import sys
 import unittest2
 
 import gdbremote_testcase
 from lldbtest import *
 
 class TestGdbRemote_qThreadStopInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
     THREAD_COUNT = 5
 
     def gather_stop_replies_via_qThreadStopInfo(self, thread_count):
         # Set up the inferior args.
         inferior_args=[]
         for i in range(thread_count - 1):
             inferior_args.append("thread:new")
         inferior_args.append("sleep:10")

lldb/trunk/test/tools/lldb-server/TestGdbRemote_vCont.py

 import unittest2
 
 import gdbremote_testcase
 from lldbtest import *
 
 class TestGdbRemote_vCont(gdbremote_testcase.GdbRemoteTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     def vCont_supports_mode(self, mode, inferior_args=None):
         # Setup the stub and set the gdb remote command stream.
         procs = self.prep_debug_monitor_and_inferior(inferior_args=inferior_args)
         self.add_vCont_query_packets()
 
         # Run the gdb remote command stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)

lldb/trunk/test/tools/lldb-server/TestLldbGdbServer.py

 import lldbgdbserverutils
 import platform
 import signal
 import unittest2
 from lldbtest import *
 
 class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @debugserver_test
     def test_exe_starts_debugserver(self):
         self.init_debugserver_test()
         server = self.connect_to_debug_monitor()
 
     @llgs_test
     def test_exe_starts_llgs(self):
         self.init_llgs_test()

lldb/trunk/test/tools/lldb-server/commandline/TestStubReverseConnect.py

 import gdbremote_testcase
 import lldbgdbserverutils
 import re
 import select
 import socket
 import time
 from lldbtest import *
 
 class TestStubReverseConnect(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
     _DEFAULT_TIMEOUT = 20
 
     def setUp(self):
         # Set up the test.
         gdbremote_testcase.GdbRemoteTestCaseBase.setUp(self)
 
         # Create a listener on a local port.
         self.listener_socket = self.create_listener_socket()

lldb/trunk/test/tools/lldb-server/commandline/TestStubSetSID.py

 import unittest2
 
 import gdbremote_testcase
 import lldbgdbserverutils
 import os
 import select
 import tempfile
 import time
 from lldbtest import *
 
 class TestStubSetSIDTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
     def get_stub_sid(self, extra_stub_args=None):
         # Launch debugserver
         if extra_stub_args:
             self.debug_monitor_extra_args += extra_stub_args
 
         server = self.launch_debug_monitor()
         self.assertIsNotNone(server)
         self.assertTrue(lldbgdbserverutils.process_is_running(server.pid, True))

lldb/trunk/test/tools/lldb-server/gdbremote_testcase.py

 import time
 import unittest2
 from lldbtest import *
 from lldbgdbserverutils import *
 import logging
 
 class GdbRemoteTestCaseBase(TestBase):
 
-    mydir = TestBase.compute_mydir(__file__)
-
     _TIMEOUT_SECONDS = 5
 
     _GDBREMOTE_KILL_PACKET = "$k#6b"
 
     _LOGGING_LEVEL = logging.WARNING
     # _LOGGING_LEVEL = logging.DEBUG
 
     # Start the inferior separately, attach to the inferior on the stub command line.