| """ | |
| Test that lldb can target and debug an executable whose path is longer than the | |
| Windows MAX_PATH limit (260 characters). | |
| """ | |
| import os | |
| import shutil | |
| import lldb | |
| from lldbsuite.test.decorators import * | |
| from lldbsuite.test.lldbtest import * | |
| from lldbsuite.test import lldbutil | |
| MAX_PATH = 260 | |
| @requireWindows | |
| class LongPathTargetTestCase(TestBase): | |
| NO_DEBUG_INFO_TESTCASE = True | |
| def _long_path(self, path): | |
| return lldbutil.get_extended_windows_path(path) | |
| def _normalize(self, path): | |
| if path.startswith("\\\\?\\"): | |
| path = path[4:] | |
| return os.path.normcase(os.path.normpath(path)) | |
| def _make_long_dir(self): | |
| """Create (and return) a directory whose absolute path comfortably | |
| exceeds MAX_PATH, or None if the OS refuses to create it.""" | |
| components = [self.getBuildArtifact("deep")] + ["d" * 80] * 3 | |
| target_dir = os.path.join(*components) | |
| try: | |
| os.makedirs(self._long_path(target_dir), exist_ok=True) | |
| except OSError: | |
| return None | |
| return target_dir | |
| def _find_module(self, target, long_exe): | |
| """Return the module in `target` whose path matches `long_exe`, or an | |
| invalid module if none does.""" | |
| wanted = self._normalize(long_exe) | |
| for i in range(target.GetNumModules()): | |
| mod = target.GetModuleAtIndex(i) | |
| if self._normalize(mod.GetFileSpec().fullpath) == wanted: | |
| return mod | |
| return lldb.SBModule() | |
| def test_target_with_long_path(self): | |
| """CreateTarget, launch and break in an executable located past | |
| MAX_PATH, and verify the full path is preserved (not truncated).""" | |
| self.build() | |
| src_exe = self.getBuildArtifact("a.out") | |
| long_dir = self._make_long_dir() | |
| if long_dir is None: | |
| self.skipTest("OS cannot create paths longer than MAX_PATH") | |
| exe_basename = os.path.basename(src_exe) | |
| long_exe = os.path.join(long_dir, exe_basename) | |
| shutil.copyfile(src_exe, self._long_path(long_exe)) | |
| long_exe_abs = os.path.abspath(long_exe) | |
| self.assertGreater( | |
| len(long_exe_abs), | |
| MAX_PATH, | |
| "the test executable path must exceed MAX_PATH to be meaningful", | |
| ) | |
| # Creating the target has to open and parse the file at the long path. | |
| target = self.dbg.CreateTarget(long_exe) | |
| self.assertTrue(target.IsValid(), VALID_TARGET) | |
| # The main executable module must report its full, untruncated path. | |
| module = self._find_module(target, long_exe) | |
| self.assertTrue( | |
| module.IsValid(), | |
| "the executable module should be found by its full long path", | |
| ) | |
| self.assertGreater( | |
| len(module.GetFileSpec().fullpath), MAX_PATH, "module path truncated" | |
| ) | |
| bp = target.BreakpointCreateByName("main", exe_basename) | |
| self.assertGreater(bp.GetNumLocations(), 0, "main breakpoint has a location") | |
| process = target.LaunchSimple(None, None, self.get_process_working_directory()) | |
| self.assertTrue(process.IsValid(), PROCESS_IS_VALID) | |
| self.assertState( | |
| process.GetState(), lldb.eStateStopped, "process stopped at main" | |
| ) | |
| thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint) | |
| self.assertIsNotNone(thread, "stopped at the main breakpoint") | |
| self.assertEqual(thread.GetFrameAtIndex(0).GetFunctionName(), "main") | |
| # After launch the loaded executable module still carries the full path. | |
| live_module = self._find_module(process.GetTarget(), long_exe) | |
| self.assertTrue(live_module.IsValid(), "loaded module found by long path") | |
| self.assertGreater( | |
| len(live_module.GetFileSpec().fullpath), | |
| MAX_PATH, | |
| "loaded module path truncated", | |
| ) | |
| process.Continue() | |
| self.assertState(process.GetState(), lldb.eStateExited) | |
| self.assertEqual(process.GetExitStatus(), 0) |