add FreeBSD elf-core test

[emaste]

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/TestLinuxCore.py

21–27

We'll probably want to rework these into a table of some sort, similar to

linux-i386, 32306, 32306, 4,
linux-x86_64, 32259, 32259, 5,
freebsd-x86_64, 0, 100283, 2,

29

I probably need to submit a PR for this (not extracting the pid from FreeBSD ELF cores) and reference it in a comment.

[labath]

Looks good. If we're going to put freebsd tests in the same file, we should rename the test file as well.

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/TestLinuxCore.py

21–27

Sounds good. Personally, I'd go for a two level structure data.linux_i386.pid or something like that.

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/TestLinuxCore.py

 from lldbsuite.test import lldbutil
 
 
 class LinuxCoreTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     mydir = TestBase.compute_mydir(__file__)
 
     _i386_pid = 32306
     _x86_64_pid = 32259
     _s390x_pid = 1045
 
     _i386_regions = 4
     _x86_64_regions = 5
     _s390x_regions = 2
 
+    _freebsd_x86_64_pid = 0
+    _freebsd_x86_64_tid = 100283
+    _freebsd_x86_64_regions = 2
+
     @skipIf(oslist=['windows'])
     @skipIf(triple='^mips')
     def test_i386(self):
         """Test that lldb can read the process information from an i386 linux core file."""
-        self.do_test("linux-i386", self._i386_pid, self._i386_regions)
+        self.do_test("linux-i386", self._i386_pid, self._i386_pid,
+          self._i386_regions)
 
     @skipIf(oslist=['windows'])
     @skipIf(triple='^mips')
     def test_x86_64(self):
         """Test that lldb can read the process information from an x86_64 linux core file."""
-        self.do_test("linux-x86_64", self._x86_64_pid, self._x86_64_regions)
+        self.do_test("linux-x86_64", self._x86_64_pid, self._x86_64_pid,
+          self._x86_64_regions)
 
     # This seems to hang on non-s390x platforms for some reason.  Disabling
     # for now.
     @skipIf(archs=no_match(['s390x']))
     @skipIf(triple='^mips')
     def test_s390x(self):
         """Test that lldb can read the process information from an s390x linux core file."""
-        self.do_test("linux-s390x", self._s390x_pid, self._s390x_regions)
+        self.do_test("linux-s390x", self._s390x_pid, self._s390x_pid,
+          self._s390x_regions)
 
     def test_freebsd_x86_64(self):
         """Test that lldb can read the process information from an x86_64 FreeBSD core file."""
-        self.do_test("freebsd-x86_64", self._x86_64_pid, self._x86_64_regions)
+        self.do_test("freebsd-x86_64", self._freebsd_x86_64_pid,
+            self._freebsd_x86_64_tid, self._freebsd_x86_64_regions)
 
     @skipIf(oslist=['windows'])
     @skipIf(triple='^mips')
     def test_same_pid_running(self):
         """Test that we read the information from the core correctly even if we have a running
         process with the same PID around"""
         try:
             shutil.copyfile("linux-x86_64.out", "linux-x86_64-pid.out")
def test_same_pid_running(self):
                             "<I",
                             f.read(4))[0],
                         self._x86_64_pid)
 
                     # We insert our own pid, and make sure the test still
                     # works.
                     f.seek(pid_offset)
                     f.write(struct.pack("<I", os.getpid()))
-            self.do_test("linux-x86_64-pid", os.getpid(), self._x86_64_regions)
+            self.do_test("linux-x86_64-pid", os.getpid(), os.getpid(),
+              self._x86_64_regions)
         finally:
             self.RemoveTempFile("linux-x86_64-pid.out")
             self.RemoveTempFile("linux-x86_64-pid.core")
 
     @skipIf(oslist=['windows'])
     @skipIf(triple='^mips')
     def test_two_cores_same_pid(self):
         """Test that we handle the situation if we have two core files with the same PID
def test_two_cores_same_pid(self):
         error = lldb.SBError()
         F = altprocess.ReadCStringFromMemory(
             altframe.FindVariable("F").GetValueAsUnsigned(), 256, error)
         self.assertTrue(error.Success())
         self.assertEqual(F, "_start")
 
         # without destroying this process, run the test which opens another core file with the
         # same pid
-        self.do_test("linux-x86_64", self._x86_64_pid, self._x86_64_regions)
+        self.do_test("linux-x86_64", self._x86_64_pid, self._x86_64_pid,
+          self._x86_64_regions)
 
     def check_memory_regions(self, process, region_count):
         region_list = process.GetMemoryRegions()
         self.assertEqual(region_list.GetSize(), region_count)
 
         region = lldb.SBMemoryRegionInfo()
 
         # Check we have the right number of regions.
def check_memory_regions(self, process, region_count):
         error = process.GetMemoryRegionInfo(
             last_region.GetRegionEnd(), end_region)
         self.assertFalse(end_region.IsMapped())
         self.assertEqual(
             last_region.GetRegionEnd(),
             end_region.GetRegionBase())
         self.assertEqual(end_region.GetRegionEnd(), lldb.LLDB_INVALID_ADDRESS)
 
-    def do_test(self, filename, pid, region_count):
+    def do_test(self, filename, pid, tid, region_count):
         target = self.dbg.CreateTarget(filename + ".out")
         process = target.LoadCore(filename + ".core")
         self.assertTrue(process, PROCESS_IS_VALID)
         self.assertEqual(process.GetNumThreads(), 1)
         self.assertEqual(process.GetProcessID(), pid)
 
         thread = process.GetSelectedThread()
         self.assertTrue(thread)
-        self.assertEqual(thread.GetThreadID(), pid)
+        self.assertEqual(thread.GetThreadID(), tid)
         backtrace = ["bar", "foo", "_start"]
         self.assertEqual(thread.GetNumFrames(), len(backtrace))
         for i in range(len(backtrace)):
             frame = thread.GetFrameAtIndex(i)
             self.assertTrue(frame)
             self.assertEqual(frame.GetFunctionName(), backtrace[i])
             self.assertEqual(frame.GetLineEntry().GetLine(),
                              line_number("main.c", "Frame " + backtrace[i]))
             self.assertEqual(
                 frame.FindVariable("F").GetValueAsUnsigned(), ord(
                     backtrace[i][0]))
 
         self.check_memory_regions(process, region_count)
 
         self.dbg.DeleteTarget(target)