Save / restore selected platform in tests that may change it

[jasonmolenda]

Summary

Running the testsuite against an iOS device, it seems like I can lose the remote platform when certain tests run (and running in single-threaded mode aka no-multiprocess mode). Attached is a patch to use the setUp/tearDown test class methods to save/restore the platform.

I'm not sure if fixing this on a test-by-test basis is the right place for it. It might be better to have dotest.py's run_suite() save the remote platform and lldbtest.py's class Base setUpClass() method re-set the platform before the test is invoked, in case it was mutated during a test run.

Pavel, what do you think about this?

[labath]

I'm not sure if fixing this on a test-by-test basis is the right place for it. It might be better to have dotest.py's run_suite() save the remote platform and lldbtest.py's class Base setUpClass() method re-set the platform before the test is invoked, in case it was mutated during a test run.

Yeah, I was thinking the same thing. I think that, at this point, we have enough tests needs things like this that a more general solution is justified.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/gdb_remote_client/TestWriteMemory.py

 from __future__ import print_function
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from gdbclientutils import *
 
 
 class TestWriteMemory(GDBRemoteTestBase):
 
     def test(self):
 
         class MyResponder(MockGDBServerResponder):
             def setBreakpoint(self, packet):
                 return "OK"
 
+    def setUp(self):
+        super(TestWriteMemory, self).setUp()
+        self._initial_platform = lldb.DBG.GetSelectedPlatform()
+
+    def tearDown(self):
+        lldb.DBG.SetSelectedPlatform(self._initial_platform)
+        super(TestWriteMemory, self).tearDown()
+
         self.server.responder = MyResponder()
         target = self.dbg.CreateTargetWithFileAndTargetTriple('', 'x86_64-pc-linux')
         process = self.connect(target)
 
         bp = target.BreakpointCreateByAddress(0x1000)
         self.assertTrue(bp.IsValid())
         self.assertEqual(bp.GetNumLocations(), 1)
         bp.SetEnabled(True)
         self.assertTrue(bp.IsEnabled())
 
         err = lldb.SBError()
         data = str("\x01\x02\x03\x04")
         result = process.WriteMemory(0x1000, data, err)
         self.assertEqual(result, 4)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/gcore/TestGCore.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class GCoreTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     mydir = TestBase.compute_mydir(__file__)
-    _initial_platform = lldb.DBG.GetSelectedPlatform()
+    def setUp(self):
+        super(GCoreTestCase, self).setUp()
+        self._initial_platform = lldb.DBG.GetSelectedPlatform()
+
+    def tearDown(self):
+        lldb.DBG.SetSelectedPlatform(self._initial_platform)
+        super(GCoreTestCase, self).tearDown()
 
     _i386_pid = 5586
     _x86_64_pid = 5669
 
     @skipIf(oslist=['windows'])
     @skipIf(triple='^mips')
     def test_i386(self):
         """Test that lldb can read the process information from an i386 linux core file."""
def do_test(self, filename, pid):
         for thread in process:
             reason = thread.GetStopReason()
             self.assertEqual(reason, lldb.eStopReasonSignal)
             signal = thread.GetStopReasonDataAtIndex(1)
             # Check we got signal 19 (SIGSTOP)
             self.assertEqual(signal, 19)
 
         self.dbg.DeleteTarget(target)
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/thread_crash/TestLinuxCoreThreads.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class LinuxCoreThreadsTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     mydir = TestBase.compute_mydir(__file__)
-    _initial_platform = lldb.DBG.GetSelectedPlatform()
+
+    def setUp(self):
+        super(LinuxCoreThreadsTestCase, self).setUp()
+        self._initial_platform = lldb.DBG.GetSelectedPlatform()
+
+    def tearDown(self):
+        lldb.DBG.SetSelectedPlatform(self._initial_platform)
+        super(LinuxCoreThreadsTestCase, self).tearDown()
 
     _i386_pid = 5193
     _x86_64_pid = 5222
 
     # Thread id for the failing thread.
     _i386_tid = 5195
     _x86_64_tid = 5250
 
def do_test(self, filename, pid, tid):
                 # Check we got signal 4 (SIGILL)
                 self.assertEqual(signal, 4)
             else:
                 signal = thread.GetStopReasonDataAtIndex(1)
                 # Check we got no signal on the other threads
                 self.assertEqual(signal, 0)
 
         self.dbg.DeleteTarget(target)
-        lldb.DBG.SetSelectedPlatform(self._initial_platform)

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/platform-process-connect/TestPlatformProcessConnect.py

 from __future__ import print_function
 
 import time
 
 import gdbremote_testcase
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestPlatformProcessConnect(gdbremote_testcase.GdbRemoteTestCaseBase):
     mydir = TestBase.compute_mydir(__file__)
 
+    def setUp(self):
+        super(TestPlatformProcessConnect, self).setUp()
+        self._initial_platform = lldb.DBG.GetSelectedPlatform()
+
+    def tearDown(self):
+        lldb.DBG.SetSelectedPlatform(self._initial_platform)
+        super(TestPlatformProcessConnect, self).tearDown()
+
     @llgs_test
     @no_debug_info_test
     @skipIf(remote=False)
     @expectedFailureAll(hostoslist=["windows"], triple='.*-android')
     def test_platform_process_connect(self):
         self.build()
         self.init_llgs_test(False)