[lldb] Remove default argument from getBuildArtifact

[JDevlieghere]

Summary

Remove default argument from lldbtest.getBuildArtifact.

lldb/packages/Python/lldbsuite/test/lldbtest.py

class Base(unittest2.TestCase):
     def makeBuildDir(self):
         """Create the test-specific working directory, deleting any previous
         contents."""
         bdir = self.getBuildDir()
         if os.path.isdir(bdir):
             shutil.rmtree(bdir)
         lldbutil.mkdir_p(bdir)
 
-    def getBuildArtifact(self, name="a.out"):
+    def getBuildArtifact(self):
         """Return absolute path to an artifact in the test's build directory."""
         return os.path.join(self.getBuildDir(), name)
 
     def getSourcePath(self, name):
         """Return absolute path to a file in the test's source directory."""
         return os.path.join(self.getSourceDir(), name)
 
     @classmethod

lldb/test/API/functionalities/gdb_remote_client/TestPlatformKill.py

class TestPlatformKill(GDBRemoteTestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfRemote
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr52451")
     def test_kill_different_platform(self):
         """Test connecting to a remote linux platform"""
 
         self.build(dictionary={"CXX_SOURCES":"sleep.cpp"})
-        host_process = self.spawnSubprocess(self.getBuildArtifact())
+        host_process = self.spawnSubprocess(self.getBuildArtifact("a.out"))
 
         # Create a fake remote process with the same PID as host_process
         class MyResponder(MockGDBServerResponder):
             def __init__(self):
                 MockGDBServerResponder.__init__(self)
                 self.got_kill = False
 
             def qC(self):

lldb/test/API/iohandler/sigint/TestProcessIOHandlerInterrupt.py

 class TestCase(PExpectTest):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIf(compiler="clang", compiler_version=['<', '11.0'])
     @skipIf(oslist=["linux"], archs=["arm", "aarch64"])
     def test(self):
         self.build(dictionary={"CXX_SOURCES":"cat.cpp"})
-        self.launch(executable=self.getBuildArtifact())
+        self.launch(executable=self.getBuildArtifact("a.out"))
 
         self.child.sendline("process launch")
         self.child.expect("Process .* launched")
 
         self.child.sendline("Hello cat")
         self.child.expect_exact("read: Hello cat")
 
         self.child.sendintr()

lldb/test/API/lang/cpp/class_types/TestClassTypes.py

def test_with_python_api(self):
         self.assertTrue(target, VALID_TARGET)
 
         filespec = target.GetExecutable()
         self.assertTrue(filespec, VALID_FILESPEC)
 
         fsDir = os.path.normpath(filespec.GetDirectory())
         fsFile = filespec.GetFilename()
 
-        self.assertTrue(fsDir == os.path.dirname(self.getBuildArtifact())
+        self.assertTrue(fsDir == os.path.dirname(self.getBuildArtifact("a.out"))
                         and fsFile == "a.out",
                         "FileSpec matches the executable")
 
         bpfilespec = lldb.SBFileSpec("main.cpp", False)
 
         breakpoint = target.BreakpointCreateByLocation(bpfilespec, self.line)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
def test_with_constructor_name(self):
         self.assertTrue(target, VALID_TARGET)
 
         filespec = target.GetExecutable()
         self.assertTrue(filespec, VALID_FILESPEC)
 
         fsDir = os.path.normpath(filespec.GetDirectory())
         fsFile = filespec.GetFilename()
 
-        self.assertTrue(fsDir == os.path.dirname(self.getBuildArtifact())
+        self.assertTrue(fsDir == os.path.dirname(self.getBuildArtifact("a.out"))
                         and fsFile == "a.out",
                         "FileSpec matches the executable")
 
         bpfilespec = lldb.SBFileSpec("main.cpp", False)
 
         breakpoint = target.BreakpointCreateByLocation(bpfilespec, self.line)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 

lldb/test/API/macosx/simulator/TestSimulatorPlatform.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 import lldbsuite.test.lldbutil as lldbutil
 import json
 import unittest2
 
 
 class TestSimulatorPlatformLaunching(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     def check_load_commands(self, expected_load_command):
         """sanity check the built binary for the expected number of load commands"""
         load_cmds = subprocess.check_output(
-            ['otool', '-l', self.getBuildArtifact()]
+            ['otool', '-l', self.getBuildArtifact("a.out")]
         ).decode("utf-8")
         found = 0
         for line in load_cmds.split('\n'):
             if expected_load_command in line:
                 found += 1
         self.assertEquals(
             found, 1, "wrong number of load commands for {}".format(
                 expected_load_command))

lldb/test/API/qemu/TestQemuLaunch.py

def setUp(self):
                     """).format(exec=sys.executable, path=sys.path,
                         source=self.getSourcePath("qemu.py")))
 
         self.set_emulator_setting("architecture", self.getArchitecture())
         self.set_emulator_setting("emulator-path", emulator)
 
     def _create_target(self):
         self.build()
-        exe = self.getBuildArtifact()
+        exe = self.getBuildArtifact("a.out")
 
         # Create a target using our platform
         error = lldb.SBError()
         target = self.dbg.CreateTarget(exe, '', 'qemu-user', False, error)
         self.assertSuccess(error)
         self.assertEqual(target.GetPlatform().GetName(), "qemu-user")
         return target
 
def _run_and_get_state(self, target=None, info=None):
 
         # Verify the qemu invocation parameters.
         with open(self.getBuildArtifact("state.log")) as s:
             return json.load(s)
 
     def test_basic_launch(self):
         state = self._run_and_get_state()
 
-        self.assertEqual(state["program"], self.getBuildArtifact())
+        self.assertEqual(state["program"], self.getBuildArtifact("a.out"))
         self.assertEqual(state["args"],
                 ["dump:" + self.getBuildArtifact("state.log")])
 
     def test_stdio_pty(self):
         target = self._create_target()
 
         info = target.GetLaunchInfo()
         info.SetArguments([
def test_stdio_pty(self):
         self.assertEqual(process.GetSTDOUT(1000),
                 "STDIN CONTENT\r\nSTDOUT CONTENT\r\nSTDERR CONTENT\r\n")
         with open(self.getBuildArtifact("state.log")) as s:
             state = json.load(s)
         self.assertEqual(state["stdin"], "STDIN CONTENT\n")
 
     def test_stdio_redirect(self):
         self.build()
-        exe = self.getBuildArtifact()
+        exe = self.getBuildArtifact("a.out")
 
         # Create a target using our platform
         error = lldb.SBError()
         target = self.dbg.CreateTarget(exe, '', 'qemu-user', False, error)
         self.assertSuccess(error)
 
         info = lldb.SBLaunchInfo([
             "stdin:stdin",
def test_find_in_PATH(self):
         os.environ["PATH"] = (self.getBuildDir() +
             self.platformContext.shlib_path_separator + original_path)
         def cleanup():
             os.environ["PATH"] = original_path
 
         self.addTearDownHook(cleanup)
         state = self._run_and_get_state()
 
-        self.assertEqual(state["program"], self.getBuildArtifact())
+        self.assertEqual(state["program"], self.getBuildArtifact("a.out"))
         self.assertEqual(state["args"],
                 ["dump:" + self.getBuildArtifact("state.log")])
 
     def test_bad_emulator_path(self):
         self.set_emulator_setting("emulator-path",
                 self.getBuildArtifact("nonexistent.file"))
 
         target = self._create_target()
def test_env_vars(self):
         self.assertEqual(state["environ"]["QEMU_UNSET_ENV"],
                 "%s,%s,QEMU_SET_ENV,QEMU_UNSET_ENV" % (var(3), var(4)))
 
     def test_arg0(self):
         target = self._create_target()
         self.runCmd("settings set target.arg0 ARG0")
         state = self._run_and_get_state(target)
 
-        self.assertEqual(state["program"], self.getBuildArtifact())
+        self.assertEqual(state["program"], self.getBuildArtifact("a.out"))
         self.assertEqual(state["0"], "ARG0")
 
     def test_sysroot(self):
         sysroot = self.getBuildArtifact("sysroot")
         self.runCmd("platform select qemu-user --sysroot %s" % sysroot)
         state = self._run_and_get_state()
         self.assertEqual(state["environ"]["QEMU_LD_PREFIX"], sysroot)
         self.assertIn("QEMU_LD_PREFIX",
                 state["environ"]["QEMU_UNSET_ENV"].split(","))