Merge pull request #5303 from secondlife/marchcat/slua-ed-dev-lnx

Merge develop-linux into SLua editor PV branch

4 files changed, 341 insertions, 42 deletions

diff --git a/indra/llcommon/tests/llfile_test.cpp b/indra/llcommon/tests/llfile_test.cpp
new file mode 100644
index 0000000000..ab4616cfb2
--- /dev/null
+++ b/indra/llcommon/tests/llfile_test.cpp
@@ -0,0 +1,299 @@
+/**
+ * @file llfile_test.cpp
+ * @author Frederick Martian
+ * @date 2025-11
+ * @brief LLFile test cases.
+ *
+ * $LicenseInfo:firstyear=2025&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2025, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include <tut/tut.hpp>
+#include "lltut.h"
+#include "linden_common.h"
+#include "llfile.h"
+
+namespace tut
+{
+    static void clear_entire_dir(const std::filesystem::path& dir_path)
+    {
+        std::error_code ec;
+        std::filesystem::remove_all(dir_path, ec);
+    }
+
+    static std::filesystem::path append_filename(const std::filesystem::path& dir, const std::u8string& element)
+    {
+        std::filesystem::path path = dir;
+        return path.append(element);
+    }
+
+    static std::filesystem::path get_testdir(const std::filesystem::path& tempdir)
+    {
+        return append_filename(tempdir, std::u8string(u8"test_dir"));
+    }
+
+    static std::filesystem::path get_testdir_unicode(const std::filesystem::path& tempdir)
+    {
+        // Example Unicode directory name: "test_ユニコード_dir"
+        return append_filename(tempdir, std::u8string(u8"test_\xE3\x83\xA6\xE3\x83\x8B\xE3\x82\xB3\xE3\x83\xBC\xE3\x83\x89_dir"));
+    }
+
+    struct llfile_test
+    {
+        std::filesystem::path tempdir = LLFile::tmpdir();
+        std::filesystem::path testdir = get_testdir(tempdir);
+    };
+    typedef test_group<llfile_test> llfile_test_t;
+    typedef llfile_test_t::object   llfile_test_object_t;
+    tut::llfile_test_t              tut_llfile_test("llfile_test");
+
+    template<> template<>
+    void llfile_test_object_t::test<1>()
+    {
+        // Test creating directories and files and deleting them and checking if the
+        // relevant status functions work as expected
+        ensure("LLFile::tmpdir() empty", !tempdir.empty());
+        ensure("LLFile::tmpdir() doesn't exist", LLFile::exists(tempdir));
+        ensure("LLFile::tmpdir() is not a directory", LLFile::isdir(tempdir));
+        ensure("LLFile::tmpdir() should not be a file", !LLFile::isfile(tempdir));
+
+        // Make sure there is nothing left from a previous test run
+        clear_entire_dir(testdir);
+        ensure("llfile_test should not exist anymore", !LLFile::exists(testdir));
+
+        int rc = LLFile::mkdir(testdir);
+        ensure("LLFile::mkdir() failed", rc == 0);
+        ensure("llfile_test should be a directory", LLFile::isdir(testdir));
+        rc = LLFile::mkdir(testdir);
+        ensure("LLFile::mkdir() should not fail when the directory already exists", rc == 0);
+
+        std::filesystem::path testfile1 = testdir;
+        testfile1.append("llfile_test.dat");
+        ensure("llfile_test1.dat should not yet exist", !LLFile::exists(testfile1));
+
+        const char* testdata = "testdata";
+        S64 bytes = LLFile::write(testfile1, testdata, 0, sizeof(testdata));
+        ensure("LLFile::write() did not write correctly", bytes == sizeof(testdata));
+
+        rc = LLFile::remove(testfile1);
+        ensure("LLFile::remove() for file test_file.dat", rc == 0);
+        ensure("llfile_test.dat should not exist anymore", !LLFile::exists(testfile1));
+        ensure("llfile_test.dat should not be a file", !LLFile::isfile(testfile1));
+        ensure("llfile_test.dat should not be a directory", !LLFile::isdir(testfile1));
+        ensure("llfile_test.dat should not be a symlink", !LLFile::islink(testfile1));
+
+        rc = LLFile::remove(testdir);
+        ensure("LLFile::remove() for directory llfile_test failed", rc == 0);
+        ensure("llfile_test should not exist anymore", !LLFile::exists(testdir));
+    }
+
+    template<> template<>
+    void llfile_test_object_t::test<2>()
+    {
+        // High level static file IO functions to read and write data files
+        LLFile::mkdir(testdir);
+        ensure("llfile_test should exist", LLFile::isdir(testdir));
+
+        std::filesystem::path testfile1 = testdir;
+        testfile1.append("llfile_test.dat");
+
+        std::string testdata1("testdata");
+        std::string testdata2("datateststuff");
+        std::time_t current = time(nullptr);
+        S64 bytes = LLFile::write(testfile1, testdata1.c_str(), 0, testdata1.length());
+        ensure("LLFile::write() did not write correctly", bytes == testdata1.length());
+        ensure("llfile_test.dat should exist", LLFile::exists(testfile1));
+        ensure("llfile_test.dat should be a file", LLFile::isfile(testfile1));
+        ensure("llfile_test.dat should not be a directory", !LLFile::isdir(testfile1));
+
+        bytes = LLFile::size(testfile1);
+        ensure("LLFile::size() did not return the correct size", bytes == testdata1.length());
+
+        std::string data = LLFile::getContents(testfile1);
+        ensure("LLFile::getContents() did not return the correct size data", data.length() == testdata1.length());
+        ensure_memory_matches("LLFile::getContents() did not read correct data", testdata1.c_str(), (U32)testdata1.length(), data.c_str(), (U32)data.length());
+
+        char buffer[1024];
+        bytes = LLFile::read(testfile1, buffer, 0, testdata1.length());
+        ensure("LLFile:read() did not return the correct size", bytes == testdata1.length());
+        ensure_memory_matches("LLFile::read() did not read correct data", testdata1.c_str(), (U32)bytes, buffer, (U32)bytes);
+
+        // What if we try to read more data than there is in the file?
+        bytes = LLFile::read(testfile1, buffer, 0, bytes + 10);
+        ensure("LLFile:read() did not correctly stop on eof", bytes == testdata1.length());
+        ensure_memory_matches("LLFile::read() did not read correct data", testdata1.c_str(), (U32)bytes, buffer, (U32)bytes);
+
+        // Let's append more data
+        bytes = LLFile::write(testfile1, testdata2.c_str(), -1, testdata2.length());
+        ensure("LLFile::write() did not write correctly", bytes == testdata2.length());
+
+        bytes = LLFile::size(testfile1);
+        ensure("LLFile::size() did not return the correct size", bytes == testdata1.length() + testdata2.length());
+        bytes = LLFile::read(testfile1, buffer, 0, bytes);
+        ensure("LLFile:read() did not read correct number of bytes", bytes == testdata1.length() + testdata2.length());
+        ensure_memory_matches("LLFile:read() did not read correct testdata1", testdata1.c_str(), (U32)testdata1.length(), buffer, (U32)testdata1.length());
+        ensure_memory_matches("LLFile:read() did not read correct testdata2", testdata2.c_str(), (U32)testdata2.length(), buffer + testdata1.length(), (U32)testdata2.length());
+    }
+
+    template<> template<>
+    void llfile_test_object_t::test<3>()
+    {
+        const size_t numints = 1024;
+
+        // Testing the LLFile class implementation
+        std::filesystem::path testfile = testdir;
+        testfile.append("llfile_test.bin");
+
+        int data[numints];
+        for (int &t : data)
+        {
+            t = rand();
+        }
+
+        std::error_code ec;
+        LLFile fileout(testfile, LLFile::out, ec);
+        ensure("LLFile constructor did not open correctly", (bool)fileout);
+        ensure("error_code from LLFile constructor should not indicate an error", !ec);
+        if (fileout)
+        {
+            S64 length = fileout.size(ec);
+            ensure("freshly created file should be empty", length == 0);
+            ensure("error_code from LLFile::size() should not indicate an error", !ec);
+            S64 bytes = fileout.write(data, sizeof(data), ec);
+            ensure("LLFile::write() did not write correctly", bytes == sizeof(data));
+            ensure("error_code from LLFile::write() should not indicate an error", !ec);
+            bytes = fileout.write(data, sizeof(data), ec);
+            ensure("LLFile::write() did not write correctly", bytes == sizeof(data));
+            ensure("error_code from LLFile::write() should not indicate an error", !ec);
+            bytes = fileout.size(ec);
+            ensure("LLFile::size() returned wrong size", bytes == 2 * sizeof(data));
+            ensure("error_code from LLFile::size() should not indicate an error", !ec);
+            fileout.close();
+        }
+
+        LLFile filein(testfile, LLFile::in, ec);
+        ensure("LLFile constructor did not open correctly", (bool)filein);
+        ensure("error_code from LLFile constructor should not indicate an error", !ec);
+        if (filein)
+        {
+            S64 length = filein.size(ec);
+            ensure("LLFile::size() returned wrong size", length == 2 * sizeof(data));
+            ensure("error_code from LLFile::size() should not indicate an error", !ec);
+            char* buffer = (char*)malloc(length);
+            S64 bytes  = filein.read(buffer, length, ec);
+            ensure("LLFile::read() did not read correctly", bytes == length);
+            ensure("error_code from LLFile::read() should not indicate an error", !ec);
+            ensure_memory_matches("LLFile:read() did not read correct data1", data, (U32)sizeof(data), buffer, (U32)sizeof(data));
+            ensure_memory_matches("LLFile:read() did not read correct data2", data, (U32)sizeof(data), buffer + sizeof(data), (U32)sizeof(data));
+            S64 offset = filein.tell(ec);
+            ensure("LLFile::tell() returned a bad offset", offset == length);
+            ensure("error_code from LLFile::read() should not indicate an error", !ec);
+            offset = sizeof(data) / 2;
+            int rc = filein.seek(offset, ec);
+            ensure("LLFile::seek() indicated an error", rc == 0);
+            ensure("error_code from LLFile::seek() should not indicate an error", !ec);
+            bytes = filein.read(buffer, 2 * sizeof(data), ec);
+            ensure("LLFile::read() did not read correctly", bytes == sizeof(data) + offset);
+            ensure("error_code from LLFile::read() should not indicate an error", !ec);
+            ensure_memory_matches("LLFile:read() did not read correct data3", (char*)data + offset, (U32)offset, buffer, (U32)offset);
+            ensure_memory_matches("LLFile:read() did not read correct data4", (char*)data, (U32)sizeof(data), buffer + offset, (U32)sizeof(data));
+            filein.close();
+
+            free(buffer);
+        }
+    }
+
+    template<> template<>
+    void llfile_test_object_t::test<4>()
+    {
+        // Testing the LLFile class implementation with wrong paths and parameters
+        std::filesystem::path testfile = testdir;
+        testfile.append("llfile_test.bin");
+
+        std::error_code ec;
+        LLFile file(testfile, LLFile::out | LLFile::noreplace, ec);
+        ensure("LLFile constructor should not have opened the already existing file", !file);
+        ensure("error_code from LLFile constructor should indicate an error", (bool)ec);
+
+        LLFile::remove(testfile);
+        file = LLFile(testfile, LLFile::out | LLFile::app | LLFile::trunc, ec);
+        ensure("LLFile constructor should not have opened the file with conflicting flags", !file);
+        ensure("error_code from LLFile constructor should indicate an error", (bool)ec);
+
+        file = LLFile(testfile, LLFile::out | LLFile::app | LLFile::noreplace, ec);
+        ensure("LLFile constructor should not have opened the file with conflicting flags", !file);
+        ensure("error_code from LLFile constructor should indicate an error", (bool)ec);
+
+        testfile = testdir;
+        testfile.append("llfile_test");
+        testfile.append("llfile_test.bin");
+
+        file = LLFile(testfile, LLFile::in, ec);
+        ensure("LLFile constructor should not have been able to open the file in the non-existing directory", !file);
+        ensure("error_code from LLFile constructor should indicate an error", (bool)ec);
+    }
+
+    template<> template<>
+    void llfile_test_object_t::test<5>()
+    {
+        // Test file and directory operations with Unicode paths and filenames
+        std::filesystem::path testdir_unicode = get_testdir_unicode(tempdir);
+
+        // Unicode filename: "ファイル_テスト.bin" (means "file_test.bin" in Japanese)
+        std::string unicode_filename = "\xE3\x83\x95\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB_\xE3\x83\x86\xE3\x82\xB9\xE3\x83\x88.bin";
+        std::filesystem::path testfile_unicode = testdir_unicode;
+        testfile_unicode.append(unicode_filename);
+
+        // Clean up any previous test artifacts
+        clear_entire_dir(testdir_unicode);
+        ensure("Unicode test directory should not exist", !LLFile::exists(testdir_unicode));
+
+        // Create the Unicode directory
+        int rc = LLFile::mkdir(testdir_unicode);
+        ensure("LLFile::mkdir() failed for Unicode directory", rc == 0);
+        ensure("Unicode test directory should exist", LLFile::isdir(testdir_unicode));
+
+
+        ensure("Unicode test file should not exist", !LLFile::exists(testfile_unicode));
+
+        // Write to the Unicode file
+        const char* testdata = "unicode_testdata";
+        S64 bytes = LLFile::write(testfile_unicode, testdata, 0, strlen(testdata));
+        ensure("Unicode test file should exist", LLFile::exists(testfile_unicode));
+        ensure("Unicode test file should be a file", LLFile::isfile(testfile_unicode));
+        ensure("LLFile::write() did not write correctly to Unicode file", bytes == (S64)strlen(testdata));
+
+        // Read back the data
+        char buffer[64] = {};
+        bytes = LLFile::read(testfile_unicode, buffer, 0, sizeof(buffer));
+        ensure("LLFile::read() did not read correctly from Unicode file", bytes == (S64)strlen(testdata));
+        ensure_memory_matches("LLFile::read() did not read correct Unicode data", testdata, (U32)bytes, buffer, (U32)bytes);
+
+        // Remove the file and directory
+        rc = LLFile::remove(testfile_unicode);
+        ensure("LLFile::remove() failed for Unicode file", rc == 0);
+        ensure("Unicode test file should not exist after removal", !LLFile::exists(testfile_unicode));
+
+        rc = LLFile::remove(testdir_unicode);
+        ensure("LLFile::remove() failed for Unicode directory", rc == 0);
+        ensure("Unicode test directory should not exist after removal", !LLFile::exists(testdir_unicode));
+    }
+} // namespace tut
diff --git a/indra/llcommon/tests/llleap_test.cpp b/indra/llcommon/tests/llleap_test.cpp
index fa48bcdefd..ae20e7ed27 100644
--- a/indra/llcommon/tests/llleap_test.cpp
+++ b/indra/llcommon/tests/llleap_test.cpp
@@ -190,7 +190,7 @@ namespace tut
             // computation, so I don't mind calling it twice.) Then take the
             // basename.
             reader_module(LLProcess::basename(
-                              reader.getName().substr(0, reader.getName().length()-3))),
+                              reader.getPath().string().substr(0, reader.getPath().string().length()-3))),
             PYTHON(LLStringUtil::getenv("PYTHON"))
         {
             ensure("Set PYTHON to interpreter pathname", !PYTHON.empty());
@@ -212,9 +212,9 @@ namespace tut
                                 "time.sleep(1)\n");
         LLLeapVector instances;
         instances.push_back(LLLeap::create(get_test_name(),
-                                           StringVec{PYTHON, script.getName()})->getWeak());
+                                           StringVec{PYTHON, script.getPath().string()})->getWeak());
         instances.push_back(LLLeap::create(get_test_name(),
-                                           StringVec{PYTHON, script.getName()})->getWeak());
+                                           StringVec{PYTHON, script.getPath().string()})->getWeak());
         // In this case we're simply establishing that two LLLeap instances
         // can coexist without throwing exceptions or bombing in any other
         // way. Wait for them to terminate.
@@ -229,7 +229,7 @@ namespace tut
                                 "import sys\n"
                                 "sys.stderr.write('''Hello from Python!\n"
                                 "note partial line''')\n");
-        StringVec vcommand{ PYTHON, script.getName() };
+        StringVec vcommand{ PYTHON, script.getPath().string() };
         CaptureLog log(LLError::LEVEL_INFO);
         waitfor(LLLeap::create(get_test_name(), vcommand));
         log.messageWith("Hello from Python!");
@@ -244,7 +244,7 @@ namespace tut
                                 "print('Hello from Python!')\n");
         CaptureLog log(LLError::LEVEL_WARN);
         waitfor(LLLeap::create(get_test_name(),
-                               StringVec{PYTHON, script.getName()}));
+                               StringVec{PYTHON, script.getPath().string()}));
         ensure_contains("error log line",
                         log.messageWith("invalid protocol"), "Hello from Python!");
     }
@@ -259,7 +259,7 @@ namespace tut
                                 "sys.stdout.write('Hello from Python!')\n");
         CaptureLog log(LLError::LEVEL_WARN);
         waitfor(LLLeap::create(get_test_name(),
-                               StringVec{PYTHON, script.getName()}));
+                               StringVec{PYTHON, script.getPath().string()}));
         ensure_contains("error log line",
                         log.messageWith("Discarding"), "Hello from Python!");
     }
@@ -273,7 +273,7 @@ namespace tut
                                 "sys.stdout.write('5a2:something')\n");
         CaptureLog log(LLError::LEVEL_WARN);
         waitfor(LLLeap::create(get_test_name(),
-                               StringVec{PYTHON, script.getName()}));
+                               StringVec{PYTHON, script.getPath().string()}));
         ensure_contains("error log line",
                         log.messageWith("invalid protocol"), "5a2:");
     }
@@ -386,7 +386,7 @@ namespace tut
                                 "            else 'bad: ' + str(resp)\n"
                                 "send(pump='" << result.getName() << "', data=result)\n";});
         waitfor(LLLeap::create(get_test_name(),
-                               StringVec{PYTHON, script.getName()}));
+                               StringVec{PYTHON, script.getPath().string()}));
         result.ensure();
     }
 
@@ -445,7 +445,7 @@ namespace tut
                                 "        result = 'expected reqid=%s in %s' % (i, resp)\n"
                                 "        break\n"
                                 "send(pump='" << result.getName() << "', data=result)\n";});
-        waitfor(LLLeap::create(get_test_name(), StringVec{PYTHON, script.getName()}),
+        waitfor(LLLeap::create(get_test_name(), StringVec{PYTHON, script.getPath().string()}),
                 300);               // needs more realtime than most tests
         result.ensure();
     }
@@ -512,7 +512,7 @@ namespace tut
                                 "             (start, large[start:end], echoed[start:end]))\n"
                                 "sys.exit(1)\n";});
         waitfor(LLLeap::create(test_name,
-                               StringVec{PYTHON, script.getName(), stringize(size)}),
+                               StringVec{PYTHON, script.getPath().string(), stringize(size)}),
                 180);               // try a longer timeout
         result.ensure();
     }
diff --git a/indra/llcommon/tests/llprocess_test.cpp b/indra/llcommon/tests/llprocess_test.cpp
index cdf9f70b6e..5e653d0ba0 100644
--- a/indra/llcommon/tests/llprocess_test.cpp
+++ b/indra/llcommon/tests/llprocess_test.cpp
@@ -87,12 +87,12 @@ static void aprchk_(const char* call, apr_status_t rv, apr_status_t expected=APR
  * @param desc Optional description of the file for error message;
  * defaults to "in <pathname>"
  */
-static std::string readfile(const std::string& pathname, const std::string& desc="")
+static std::string readfile(const std::filesystem::path& pathname, const std::string& desc="")
 {
     std::string use_desc(desc);
     if (use_desc.empty())
     {
-        use_desc = "in " + pathname;
+        use_desc = "in " + pathname.string();
     }
     llifstream  inf(pathname.c_str());
     std::string output;
@@ -165,7 +165,7 @@ struct PythonProcessLauncher
 
         mParams.desc = desc + " script";
         mParams.executable = PYTHON;
-        mParams.args.add(mScript.getName());
+        mParams.args.add(mScript.getPath().string());
     }
 
     /// Launch Python script; verify that it launched
@@ -233,11 +233,11 @@ struct PythonProcessLauncher
     {
         NamedTempFile out("out", ""); // placeholder
         // pass name of this temporary file to the script
-        mParams.args.add(out.getName());
+        mParams.args.add(out.getPath().string());
         run();
         // assuming the script wrote to that file, read it
         std::string desc = "from " + mDesc + " script";
-        return readfile(out.getName(), desc);
+        return readfile(out.getPath(), desc);
     }
 
     LLProcess::Params mParams;
@@ -271,23 +271,23 @@ public:
 
     NamedTempDir():
         mPath(NamedTempFile::temp_path()),
-        mCreated(boost::filesystem::create_directories(mPath))
+        mCreated(std::filesystem::create_directories(mPath))
     {
-        mPath = boost::filesystem::canonical(mPath);
+        mPath = std::filesystem::canonical(mPath);
     }
 
     ~NamedTempDir()
     {
         if (mCreated)
         {
-            boost::filesystem::remove_all(mPath);
+            std::filesystem::remove_all(mPath);
         }
     }
 
     std::string getName() const { return mPath.string(); }
 
 private:
-    boost::filesystem::path mPath;
+    std::filesystem::path mPath;
     bool mCreated;
 };
 
@@ -440,7 +440,7 @@ namespace tut
 #endif
         // Have to have a named copy of this std::string so its c_str() value
         // will persist.
-        std::string scriptname(script.getName());
+        std::string scriptname(script.getPath().string());
         argv.push_back(scriptname.c_str());
         argv.push_back(NULL);
 
@@ -719,14 +719,14 @@ namespace tut
                                  "with open(sys.argv[1], 'w') as f:\n"
                                  "    f.write('bad')\n");
         NamedTempFile out("out", "not started");
-        py.mParams.args.add(out.getName());
+        py.mParams.args.add(out.getPath().string());
         py.launch();
         // Wait for the script to wake up and do its first write
         int i = 0, timeout = 60;
         for ( ; i < timeout; ++i)
         {
             yield();
-            if (readfile(out.getName(), "from kill() script") == "ok")
+            if (readfile(out.getPath(), "from kill() script") == "ok")
                 break;
         }
         // If we broke this loop because of the counter, something's wrong
@@ -745,7 +745,7 @@ namespace tut
         // If kill() failed, the script would have woken up on its own and
         // overwritten the file with 'bad'. But if kill() succeeded, it should
         // not have had that chance.
-        ensure_equals(get_test_name() + " script output", readfile(out.getName()), "ok");
+        ensure_equals(get_test_name() + " script output", readfile(out.getPath()), "ok");
     }
 
     template<> template<>
@@ -765,7 +765,7 @@ namespace tut
                                      "# if caller hasn't managed to kill by now, bad\n"
                                      "with open(sys.argv[1], 'w') as f:\n"
                                      "    f.write('bad')\n");
-            py.mParams.args.add(out.getName());
+            py.mParams.args.add(out.getPath().string());
             py.launch();
             // Capture handle for later
             phandle = py.mPy->getProcessHandle();
@@ -774,7 +774,7 @@ namespace tut
             for ( ; i < timeout; ++i)
             {
                 yield();
-                if (readfile(out.getName(), "from kill() script") == "ok")
+                if (readfile(out.getPath(), "from kill() script") == "ok")
                     break;
             }
             // If we broke this loop because of the counter, something's wrong
@@ -787,7 +787,7 @@ namespace tut
         // If kill() failed, the script would have woken up on its own and
         // overwritten the file with 'bad'. But if kill() succeeded, it should
         // not have had that chance.
-        ensure_equals(get_test_name() + " script output", readfile(out.getName()), "ok");
+        ensure_equals(get_test_name() + " script output", readfile(out.getPath()), "ok");
     }
 
     template<> template<>
@@ -817,8 +817,8 @@ namespace tut
                                      "# okay, saw 'go', write 'ack'\n"
                                      "with open(sys.argv[1], 'w') as f:\n"
                                      "    f.write('ack')\n");
-            py.mParams.args.add(from.getName());
-            py.mParams.args.add(to.getName());
+            py.mParams.args.add(from.getPath().string());
+            py.mParams.args.add(to.getPath().string());
             py.mParams.autokill = false;
             py.launch();
             // Capture handle for later
@@ -828,7 +828,7 @@ namespace tut
             for ( ; i < timeout; ++i)
             {
                 yield();
-                if (readfile(from.getName(), "from autokill script") == "ok")
+                if (readfile(from.getPath(), "from autokill script") == "ok")
                     break;
             }
             // If we broke this loop because of the counter, something's wrong
@@ -840,14 +840,14 @@ namespace tut
         // How do we know it's not terminated? By making it respond to
         // a specific stimulus in a specific way.
         {
-            llofstream outf(to.getName().c_str());
+            llofstream outf(to.getPath());
             outf << "go";
         } // flush and close.
         // now wait for the script to terminate... one way or another.
         waitfor(phandle, "autokill script");
         // If the LLProcess destructor implicitly called kill(), the
         // script could not have written 'ack' as we expect.
-        ensure_equals(get_test_name() + " script output", readfile(from.getName()), "ack");
+        ensure_equals(get_test_name() + " script output", readfile(from.getPath()), "ack");
     }
 
     template<> template<>
@@ -879,8 +879,8 @@ namespace tut
                                      "# okay, saw 'go', write 'ack'\n"
                                      "with open(sys.argv[1], 'w') as f:\n"
                                      "    f.write('ack')\n");
-            py.mParams.args.add(from.getName());
-            py.mParams.args.add(to.getName());
+            py.mParams.args.add(from.getPath().string());
+            py.mParams.args.add(to.getPath().string());
             py.mParams.autokill = true;
             py.mParams.attached = false;
             py.launch();
@@ -891,7 +891,7 @@ namespace tut
             for ( ; i < timeout; ++i)
             {
                 yield();
-                if (readfile(from.getName(), "from autokill script") == "ok")
+                if (readfile(from.getPath(), "from autokill script") == "ok")
                     break;
             }
             // If we broke this loop because of the counter, something's wrong
@@ -903,14 +903,14 @@ namespace tut
         // How do we know it's not terminated? By making it respond to
         // a specific stimulus in a specific way.
         {
-            llofstream outf(to.getName().c_str());
+            llofstream outf(to.getPath());
             outf << "go";
         } // flush and close.
         // now wait for the script to terminate... one way or another.
         waitfor(phandle, "autokill script");
         // If the LLProcess destructor implicitly called kill(), the
         // script could not have written 'ack' as we expect.
-        ensure_equals(get_test_name() + " script output", readfile(from.getName()), "ack");
+        ensure_equals(get_test_name() + " script output", readfile(from.getPath()), "ack");
     }
 
     template<> template<>
diff --git a/indra/llcommon/tests/llsdserialize_test.cpp b/indra/llcommon/tests/llsdserialize_test.cpp
index 272eb55521..a7abfda099 100644
--- a/indra/llcommon/tests/llsdserialize_test.cpp
+++ b/indra/llcommon/tests/llsdserialize_test.cpp
@@ -1808,7 +1808,7 @@ namespace tut
 #if LL_WINDOWS
         std::string q("\"");
         std::string qPYTHON(q + PYTHON + q);
-        std::string qscript(q + scriptfile.getName() + q);
+        std::string qscript(q + scriptfile.getPath().string() + q);
         int rc = (int)_spawnl(_P_WAIT, PYTHON.c_str(), qPYTHON.c_str(), qscript.c_str(),
                          std::forward<ARGS>(args)..., NULL);
         if (rc == -1)
@@ -1825,7 +1825,7 @@ namespace tut
 #else  // LL_DARWIN, LL_LINUX
         LLProcess::Params params;
         params.executable = PYTHON;
-        params.args.add(scriptfile.getName());
+        params.args.add(scriptfile.getPath().string());
         for (const std::string& arg : StringVec{ std::forward<ARGS>(args)... })
         {
             params.args.add(arg);
@@ -2002,8 +2002,8 @@ namespace tut
                    "        yield frombytes\n"
                    << pydata <<
                    // Don't forget raw-string syntax for Windows pathnames.
-                   "debug = open(r'" << debug.getName() << "', 'w')\n"
-                   "verify(parse_each(open(r'" << file.getName() << "', 'rb')))\n";});
+                   "debug = open(r'" << debug.getPath().string() << "', 'w')\n"
+                   "verify(parse_each(open(r'" << file.getPath().string() << "', 'rb')))\n";});
         }
         catch (const failure&)
         {
@@ -2111,13 +2111,13 @@ namespace tut
                "]\n"
                // Don't forget raw-string syntax for Windows pathnames.
                // N.B. Using 'print' implicitly adds newlines.
-               "with open(r'" << file.getName() << "', 'wb') as f:\n"
+               "with open(r'" << (const char*)file.getPath().u8string().c_str() << "', 'wb') as f:\n"
                "    for item in DATA:\n"
                "        serialized = llsd." << pyformatter << "(item)\n"
                "        f.write(lenformat.pack(len(serialized)))\n"
                "        f.write(serialized)\n";});
 
-        llifstream inf(file.getName().c_str());
+        llifstream inf(file.getPath());
         LLSD item;
         try
         {