Keep the Plugin Tests' Python Packages Out of the Working Directory

The plugin test fixtures start the interpreter before the test points
data_dir at its temporary directory, so PythonInterpreter creates
{data_dir}/python/packages and {data_dir}/log with an empty data_dir: a
python/ and log/ folder in whatever directory the tests run from. When that
is the test binary's folder, the next run's embedded-interpreter tests took
the stray python/ as their home and failed to start Python.

Give each fixture that initializes the plugin manager its own temporary
data directory, set up before initialize(), and only use the python/ folder
next to the test binary as the interpreter's home when it holds a standard
library.

src/libslic3r/Utils.hpp

@@ -256,13 +256,10 @@ extern bool is_gallery_file(const std::string& path, char const* type);
 extern bool is_shapes_dir(const std::string& dir);
 //BBS: add json support
 extern bool is_json_file(const std::string& path);
-// True if rel_path is relative, has no ".." component or embedded NUL and, joined to root, still resolves inside it.
+// True if rel_path is relative, has no ".." component and, joined to root, still resolves inside it.
 // Both '/' and '\\' are treated as separators on every platform, so an archive rejected on one OS
 // is rejected on all of them.
 extern bool is_path_within_root(const std::string &rel_path, const boost::filesystem::path &root);
-// True if a symlink stored at link_rel_path (relative to root) with this target stays inside root: the target
-// must be relative, and joined to the link's directory it must pass is_path_within_root.
-extern bool is_symlink_target_within_root(const std::string &link_rel_path, const std::string &target, const boost::filesystem::path &root);
 
 // Orca: custom protocal support utils
 inline bool is_orca_open(const std::string& url) { return boost::starts_with(url, "orcaslicer://open"); }

src/libslic3r/miniz_extension.cpp

@@ -4,9 +4,6 @@
 #include "miniz_extension.hpp"
 #include "Utils.hpp"
 
-#include <boost/filesystem.hpp>
-#include <boost/log/trivial.hpp>
-
 #if defined(_MSC_VER) || defined(__MINGW64__)
 #include "boost/nowide/cstdio.hpp"
 #endif
@@ -118,66 +115,6 @@ std::string decode_archive_entry_path(mz_zip_archive *zip, const mz_zip_archive_
     return decode_zip_unicode_path_extra_field(extra.substr(0, extra_size > 0 ? extra_size - 1 : 0), stat.m_filename);
 }
 
-bool extract_archive_confined(const std::string &zip_path_utf8, const std::string &dest_dir)
-{
-    mz_zip_archive archive;
-    mz_zip_zero_struct(&archive);
-
-    if (!open_zip_reader(&archive, zip_path_utf8)) {
-        BOOST_LOG_TRIVIAL(error) << "Unable to open zip reader for " << zip_path_utf8;
-        return false;
-    }
-
-    const mz_uint num_entries = mz_zip_reader_get_num_files(&archive);
-    mz_zip_archive_file_stat stat;
-
-    // Validate every entry first so an archive with a single escaping entry leaves no partial output behind.
-    const boost::filesystem::path root(dest_dir);
-    for (mz_uint i = 0; i < num_entries; ++i) {
-        if (mz_zip_reader_file_stat(&archive, i, &stat) && !is_path_within_root(stat.m_filename, root)) {
-            BOOST_LOG_TRIVIAL(error) << "Unzip: rejecting " << zip_path_utf8 << ", entry " << stat.m_filename << " resolves outside " << dest_dir;
-            close_zip_reader(&archive);
-            return false;
-        }
-    }
-
-    for (mz_uint i = 0; i < num_entries; ++i) {
-        if (!mz_zip_reader_file_stat(&archive, i, &stat)) {
-            BOOST_LOG_TRIVIAL(warning) << "Unzip: read file stat failed";
-            continue;
-        }
-        const std::string dest_file = dest_dir + "/" + stat.m_filename;
-        try {
-            if (stat.m_is_directory) {
-                const boost::filesystem::path dest_path(dest_file);
-                if (!boost::filesystem::exists(dest_path))
-                    boost::filesystem::create_directories(dest_path);
-                continue;
-            }
-            if (stat.m_uncomp_size == 0) {
-                BOOST_LOG_TRIVIAL(warning) << "Unzip: invalid size for file " << stat.m_filename;
-                continue;
-            }
-            // Replace a symlink at the destination rather than writing through it.
-            const boost::filesystem::path dest_path(dest_file);
-            if (boost::filesystem::is_symlink(boost::filesystem::symlink_status(dest_path)))
-                boost::filesystem::remove(dest_path);
-            if (!mz_zip_reader_extract_to_file(&archive, stat.m_file_index, dest_file.c_str(), 0)) {
-                BOOST_LOG_TRIVIAL(error) << "Unzip: extract file " << stat.m_filename << " to dest " << dest_file << " failed";
-                close_zip_reader(&archive);
-                return false;
-            }
-            BOOST_LOG_TRIVIAL(info) << "Unzip: successfully extract file " << stat.m_file_index << " to " << dest_file;
-        } catch (const std::exception &e) {
-            close_zip_reader(&archive);
-            BOOST_LOG_TRIVIAL(error) << "Unzip: archive read exception: " << e.what();
-            return false;
-        }
-    }
-    close_zip_reader(&archive);
-    return true;
-}
-
 MZ_Archive::MZ_Archive()
 {
     mz_zip_zero_struct(&arch);

src/libslic3r/miniz_extension.hpp

@@ -11,8 +11,6 @@ bool open_zip_writer(mz_zip_archive *zip, const std::string &fname_utf8);
 bool close_zip_reader(mz_zip_archive *zip);
 bool close_zip_writer(mz_zip_archive *zip);
 std::string decode_archive_entry_path(mz_zip_archive *zip, const mz_zip_archive_file_stat &stat);
-// Extracts every entry of the archive under dest_dir. Nothing is written if any entry would resolve outside dest_dir.
-bool extract_archive_confined(const std::string &zip_path_utf8, const std::string &dest_dir);
 
 class MZ_Archive {
 public:

src/libslic3r/utils.cpp

@@ -1093,9 +1093,6 @@ bool is_path_within_root(const std::string &rel_path, const boost::filesystem::p
     auto is_separator = [](char c) { return c == '/' || c == '\\'; };
     if (rel_path.empty() || is_separator(rel_path.front()) || (rel_path.size() > 1 && rel_path[1] == ':'))
         return false;
-    // The filesystem calls stop at a NUL, so they would act on a shorter path than the one checked here.
-    if (rel_path.find('\0') != std::string::npos)
-        return false;
     for (size_t start = 0; start <= rel_path.size();) {
         size_t end = start;
         while (end < rel_path.size() && !is_separator(rel_path[end]))
@@ -1106,10 +1103,7 @@ bool is_path_within_root(const std::string &rel_path, const boost::filesystem::p
     }
     // Resolve against the canonical root so a symlink inside it cannot lead back out.
     try {
-        std::string root_str = boost::filesystem::weakly_canonical(root).string();
-        // A trailing separator on root would otherwise fail the prefix match below for every path.
-        while (!root_str.empty() && (root_str.back() == '/' || root_str.back() == boost::filesystem::path::preferred_separator))
-            root_str.pop_back();
+        const std::string root_str = boost::filesystem::weakly_canonical(root).string();
         const std::string full_str = boost::filesystem::weakly_canonical(root / rel_path).string();
         return full_str.compare(0, root_str.size(), root_str) == 0 &&
                (full_str.size() == root_str.size() || full_str[root_str.size()] == boost::filesystem::path::preferred_separator);
@@ -1118,15 +1112,6 @@ bool is_path_within_root(const std::string &rel_path, const boost::filesystem::p
     }
 }
 
-bool is_symlink_target_within_root(const std::string &link_rel_path, const std::string &target, const boost::filesystem::path &root)
-{
-    if (target.empty() || target.front() == '/' || target.front() == '\\' || (target.size() > 1 && target[1] == ':'))
-        return false;
-    // A relative target without ".." only descends from the link's directory, so no chain of such links can leave root.
-    const size_t sep = link_rel_path.find_last_of("/\\");
-    return is_path_within_root((sep == std::string::npos ? std::string() : link_rel_path.substr(0, sep + 1)) + target, root);
-}
-
 bool is_img_file(const std::string &path)
 {
 	return boost::iends_with(path, ".png") || boost::iends_with(path, ".svg");

src/slic3r/CMakeLists.txt

@@ -1019,9 +1019,14 @@ if (UNIX AND NOT APPLE)
     find_package(GTK${SLIC3R_GTK} REQUIRED)
     pkg_check_modules(LIBSECRET REQUIRED libsecret-1)
     pkg_check_modules(webkit2gtk REQUIRED webkit2gtk-4.1)
-    find_package(X11 REQUIRED)
+    if (FLATPAK)
+        # I don't know why this is needed, but for whatever reason slic3r isn't
+        # linking to X11 and webkit2gtk. force it.
+        find_package(X11 REQUIRED)
+        target_link_libraries(libslic3r_gui ${X11_LIBRARIES} ${webkit2gtk_LIBRARIES})
+    endif()
     target_include_directories(libslic3r_gui SYSTEM PRIVATE ${GTK${SLIC3R_GTK}_INCLUDE_DIRS} ${LIBSECRET_INCLUDE_DIRS} ${webkit2gtk_INCLUDE_DIRS})
-    target_link_libraries(libslic3r_gui ${GTK${SLIC3R_GTK}_LIBRARIES} fontconfig ${LIBSECRET_LIBRARIES} ${webkit2gtk_LIBRARIES} ${X11_LIBRARIES})
+    target_link_libraries(libslic3r_gui ${GTK${SLIC3R_GTK}_LIBRARIES} fontconfig ${LIBSECRET_LIBRARIES})
 
     # Propagate GDK backend detection results as compile definitions so that
     # LinuxDisplayBackend.cpp can include the right GDK headers.

src/slic3r/GUI/GUI.cpp

@@ -14,9 +14,6 @@
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/any.hpp>
 
-#include <wx/filename.h>
-#include <wx/filesys.h>
-
 #if __APPLE__
 #import <IOKit/pwr_mgt/IOPMLib.h>
 #elif _WIN32
@@ -534,11 +531,6 @@ boost::filesystem::path into_path(const wxString &str)
 	return boost::filesystem::path(str.wx_str());
 }
 
-wxString file_url_from_path(const boost::filesystem::path &path)
-{
-	return wxFileSystem::FileNameToURL(wxFileName(from_path(path)));
-}
-
 void about()
 {
     AboutDialog dlg;

src/slic3r/GUI/GUI.hpp

@@ -76,9 +76,6 @@ std::string	into_u8(const wxString &str);
 wxString	from_path(const boost::filesystem::path &path);
 // boost path from wxString
 boost::filesystem::path	into_path(const wxString &str);
-// file:// URL of a local path, percent-encoded so characters such as '#', '%' and '?' stay part of the path.
-// Append any query or fragment to the result.
-wxString	file_url_from_path(const boost::filesystem::path &path);
 
 // Display an About dialog
 extern void about();

src/slic3r/GUI/GUI_App.cpp

@@ -1512,33 +1512,11 @@ int GUI_App::install_plugin(std::string name, std::string package_name, InstallP
                     size_t n = mz_zip_reader_get_extra(&archive, stat.m_file_index, extra.data(), extra.size());
                     dest_file = decode(extra.substr(0, n), stat.m_filename);
                 }
-                if (!is_path_within_root(dest_file, plugin_folder)) {
-                    BOOST_LOG_TRIVIAL(error) << "[install_plugin] entry " << dest_file << " resolves outside " << plugin_folder.string();
-                    close_zip_reader(&archive);
-                    if (pro_fn) { pro_fn(InstallStatusUnzipFailed, 0, cancel); }
-                    return InstallStatusUnzipFailed;
-                }
                 auto dest_path = plugin_folder / dest_file;
+                boost::filesystem::create_directories(dest_path.parent_path());
                 std::string dest_zip_file = encode_path(dest_path.string().c_str());
-#ifndef WIN32
-                // Validate a symlink's target before anything at the destination is replaced.
-                const bool is_link = S_ISLNK(stat.m_external_attr >> 16);
-                std::string link;
-                if (is_link) {
-                    link.assign(stat.m_uncomp_size, 0);
-                    if (!mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, link.data(), stat.m_uncomp_size, 0) ||
-                        !is_symlink_target_within_root(dest_file, link, plugin_folder)) {
-                        BOOST_LOG_TRIVIAL(error) << "[install_plugin] link " << dest_file << " -> " << link << " is unreadable or resolves outside " << plugin_folder.string();
-                        close_zip_reader(&archive);
-                        if (pro_fn) { pro_fn(InstallStatusUnzipFailed, 0, cancel); }
-                        return InstallStatusUnzipFailed;
-                    }
-                }
-#endif
                 try {
-                    boost::filesystem::create_directories(dest_path.parent_path());
-                    // symlink_status so that an existing symlink, dangling or not, is replaced rather than written through.
-                    if (fs::exists(fs::symlink_status(dest_path))) {
+                    if (fs::exists(dest_path)) {
                         boost::system::error_code ec;
                         fs::remove(dest_path, ec);
                         if (ec) {
@@ -1566,8 +1544,9 @@ int GUI_App::install_plugin(std::string name, std::string package_name, InstallP
                     }
                     mz_bool res = 0;
 #ifndef WIN32
-                    if (is_link) {
-                        res = 1;
+                    if (S_ISLNK(stat.m_external_attr >> 16)) {
+                        std::string link(stat.m_uncomp_size + 1, 0);
+                        res = mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, link.data(), stat.m_uncomp_size, 0);
                         try {
                             boost::filesystem::create_symlink(link, dest_path);
                         } catch (const std::exception &e) {

src/slic3r/GUI/MarkdownTip.cpp

@@ -98,7 +98,10 @@ void MarkdownTip::LoadStyle()
         ph /= "tooltip/styled.html";
         _data_dir = false;
     }
-    _tipView->LoadURL(file_url_from_path(ph));
+    auto url = ph.string();
+    std::replace(url.begin(), url.end(), '\\', '/');
+    url = "file:///" + url;
+    _tipView->LoadURL(from_u8(url));
     _lastTip.clear();
 }
 

src/slic3r/GUI/Plater.cpp

@@ -3672,7 +3672,7 @@ void Sidebar::update_all_preset_comboboxes()
         wxString url = from_u8(PrintHost::get_print_host_webui(&cfg));
         wxString apikey;
         if(url.empty())
-            url = file_url_from_path(boost::filesystem::path(resources_dir()) / "web/orca/missing_connection.html");
+            url = wxString::Format("file://%s/web/orca/missing_connection.html", from_u8(resources_dir()));
         else {
             const auto host_type = cfg.option<ConfigOptionEnum<PrintHostType>>("host_type")->value;
             if (cfg.has("printhost_apikey") && (host_type != htSimplyPrint))

src/slic3r/GUI/PrivacyUpdateDialog.cpp

@@ -57,7 +57,9 @@ PrivacyUpdateDialog::PrivacyUpdateDialog(wxWindow* parent, wxWindowID id, const
 
     fs::path ph(resources_dir());
     ph /= "tooltip/privacyupdate.html";
-    m_host_url = into_u8(file_url_from_path(ph));
+    m_host_url = ph.string();
+    std::replace(m_host_url.begin(), m_host_url.end(), '\\', '/');
+    m_host_url = "file:///" + m_host_url;
     m_vebview_release_note->LoadURL(from_u8(m_host_url));
     m_sizer_right->Add(m_vebview_release_note, 0, wxEXPAND | wxRIGHT | wxLEFT, FromDIP(15));
 

src/slic3r/GUI/Project.cpp

@@ -45,10 +45,10 @@ const std::vector<std::string> license_list = {
 ProjectPanel::ProjectPanel(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, long style) : wxPanel(parent, id, pos, size, style)
 {
     SetBackgroundColour(*wxWHITE);
-    m_project_home_url = file_url_from_path(boost::filesystem::path(resources_dir()) / "web/model/index.html");
+    m_project_home_url = wxString::Format("file://%s/web/model/index.html", from_u8(resources_dir()));
     wxString strlang = wxGetApp().current_language_code_safe();
     if (strlang != "")
-        m_project_home_url += "?lang=" + strlang;
+        m_project_home_url = wxString::Format("file://%s/web/model/index.html?lang=%s", from_u8(resources_dir()), strlang);
 
     wxBoxSizer* main_sizer = new wxBoxSizer(wxVERTICAL);
 

src/slic3r/GUI/ReleaseNote.cpp

@@ -510,7 +510,7 @@ void UpdateVersionDialog::update_version_info(wxString release_note, wxString ve
         out_buf->append(text, size);
     }, (void*) &html_source, MD_DIALECT_GITHUB | MD_FLAG_STRIKETHROUGH | MD_FLAG_WIKILINKS, 0);
     html_source.append("</body></html>");
-    m_vebview_release_note->LoadURL(file_url_from_path(boost::filesystem::path(resources_dir()) / "web/guide/0/index.html"));
+    m_vebview_release_note->LoadURL("file://" + (boost::filesystem::path (resources_dir()) / "web/guide/0/index.html").string());
 
     SetMinSize(GetSize());
     SetMaxSize(GetSize());

src/slic3r/GUI/WebDownPluginDlg.cpp

@@ -38,7 +38,9 @@ DownPluginFrame::DownPluginFrame(GUI_App *pGUI) : wxDialog((wxWindow *) (pGUI->m
 
     // set the frame icon
     wxBoxSizer *topsizer = new wxBoxSizer(wxVERTICAL);
-    wxString TargetUrl    = file_url_from_path(boost::filesystem::path(resources_dir()) / "web/guide/6/index.html");
+    wxString TargetUrl    = from_u8((boost::filesystem::path(resources_dir()) / "web/guide/6/index.html").make_preferred().string());
+
+    TargetUrl = "file://" + TargetUrl;
 
     // Create the webview
     m_browser = WebView::CreateWebView(this, TargetUrl);

src/slic3r/GUI/WebGuideDialog.cpp

@@ -218,38 +218,37 @@ wxString GuideFrame::SetStartPage(GuidePage startpage, bool load)
     m_page = startpage;
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(" enter, load=%1%, start_page=%2%")%load%int(startpage);
     //wxLogMessage("GUIDE: webpage_1  %s", (boost::filesystem::path(resources_dir()) / "web\\guide\\1\\index.html").make_preferred().string().c_str() );
-    const wxString guide_url = file_url_from_path(boost::filesystem::path(resources_dir()) / "web/guide/0/index.html");
-    wxString TargetUrl = guide_url + "?target=1";
+    wxString TargetUrl = from_u8( (boost::filesystem::path(resources_dir()) / "web/guide/0/index.html?target=1").make_preferred().string() );
     //wxLogMessage("GUIDE: webpage_2  %s", TargetUrl.mb_str());
 
     if (startpage == BBL_WELCOME){
         SetTitle(_L("Setup Wizard"));
-        TargetUrl = guide_url + "?target=1";
+        TargetUrl = from_u8((boost::filesystem::path(resources_dir()) / "web/guide/0/index.html?target=1").make_preferred().string());
     } else if (startpage == BBL_REGION) {
         SetTitle(_L("Setup Wizard"));
-        TargetUrl = guide_url + "?target=11";
+        TargetUrl = from_u8((boost::filesystem::path(resources_dir()) / "web/guide/0/index.html?target=11").make_preferred().string());
     } else if (startpage == BBL_MODELS) {
         SetTitle(_L("Setup Wizard"));
-        TargetUrl = guide_url + "?target=21";
+        TargetUrl = from_u8((boost::filesystem::path(resources_dir()) / "web/guide/0/index.html?target=21").make_preferred().string());
     } else if (startpage == BBL_FILAMENTS) {
         SetTitle(_L("Setup Wizard"));
 
         int nSize = m_ProfileJson["model"].size();
 
         if (nSize>0)
-            TargetUrl = guide_url + "?target=22";
+            TargetUrl = from_u8((boost::filesystem::path(resources_dir()) / "web/guide/0/index.html?target=22").make_preferred().string());
         else
-            TargetUrl = guide_url + "?target=21";
+            TargetUrl = from_u8((boost::filesystem::path(resources_dir()) / "web/guide/0/index.html?target=21").make_preferred().string());
     } else if (startpage == BBL_FILAMENT_ONLY) {
         SetTitle("");
-        TargetUrl = guide_url + "?target=23";
+        TargetUrl = from_u8((boost::filesystem::path(resources_dir()) / "web/guide/0/index.html?target=23").make_preferred().string());
     } else if (startpage == BBL_MODELS_ONLY) {
         SetTitle("");
-        TargetUrl = guide_url + "?target=24";
+        TargetUrl = from_u8((boost::filesystem::path(resources_dir()) / "web/guide/0/index.html?target=24").make_preferred().string());
     }
     else {
         SetTitle(_L("Setup Wizard"));
-        TargetUrl = guide_url + "?target=21";
+        TargetUrl = from_u8((boost::filesystem::path(resources_dir()) / "web/guide/0/index.html?target=21").make_preferred().string());
     }
 
     wxString strlang = wxGetApp().current_language_code_safe();
@@ -257,6 +256,7 @@ wxString GuideFrame::SetStartPage(GuidePage startpage, bool load)
     if (strlang != "")
         TargetUrl = wxString::Format("%s&lang=%s", w2s(TargetUrl), strlang);
 
+    TargetUrl = "file://" + TargetUrl;
     if (load)
         load_url(TargetUrl);
 
@@ -1284,7 +1284,7 @@ bool GuideFrame::BuildProfileJson(const PresetBundle& bundle, bool require_all_r
                 entry["vendor"]          = vp.id;
                 entry["nozzle_diameter"] = nozzle_str;
                 entry["materials"]       = materials_str;
-                entry["cover"]           = into_u8(file_url_from_path(cover_path));
+                entry["cover"]           = cover_path.string();
                 entry["nozzle_selected"] = "";
                 entry["sub_path"]        = "";
                 m_ProfileJson["model"].push_back(entry);
@@ -1732,7 +1732,7 @@ int GuideFrame::LoadProfileFamily(std::string strVendor, std::string strFilePath
                     cover_path = (boost::filesystem::absolute(boost::filesystem::path(resources_dir()) / "/web/image/printer/") / cover_file)
                                      .make_preferred();
             }
-            OneModel["cover"]                  = into_u8(file_url_from_path(cover_path));
+            OneModel["cover"]                  = cover_path.string();
 
             OneModel["nozzle_selected"] = "";
 

src/slic3r/GUI/WebUserLoginDialog.cpp

@@ -599,7 +599,7 @@ void ZUserLogin::OnScriptResponseMessage(wxCommandEvent &WXUNUSED(evt))
 
 bool  ZUserLogin::ShowErrorPage()
 {
-    wxString ErrortUrl = file_url_from_path(boost::filesystem::path(resources_dir()) / "web/login/error.html");
+    wxString ErrortUrl = from_u8((boost::filesystem::path(resources_dir()) / "web\\login\\error.html").make_preferred().string());
     load_url(ErrortUrl);
 
     return true;

src/slic3r/GUI/WebViewDialog.cpp

@@ -36,10 +36,10 @@ namespace GUI {
 WebViewPanel::WebViewPanel(wxWindow *parent)
         : wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize)
  {
-    wxString url = file_url_from_path(boost::filesystem::path(resources_dir()) / "web/homepage/index.html");
+    wxString url = wxString::Format("file://%s/web/homepage/index.html", from_u8(resources_dir()));
     wxString strlang = wxGetApp().current_language_code_safe();
     if (strlang != "")
-        url += "?lang=" + strlang;
+        url = wxString::Format("file://%s/web/homepage/index.html?lang=%s", from_u8(resources_dir()), strlang);
 
     wxBoxSizer* topsizer = new wxBoxSizer(wxVERTICAL);
     

src/slic3r/GUI/Widgets/MultiNozzleSync.cpp

@@ -1,6 +1,5 @@
 #include "MultiNozzleSync.hpp"
 
-#include "../GUI.hpp"
 #include "../GUI_App.hpp"
 #include "../I18N.hpp"
 #include "../Plater.hpp"
@@ -22,6 +21,8 @@
 #include <set>
 
 #include <wx/choice.h>
+#include <wx/filename.h>
+#include <wx/filesys.h>
 #include <wx/sizer.h>
 #include <wx/stattext.h>
 
@@ -640,7 +641,8 @@ NozzleListTable::NozzleListTable(wxWindow* parent) : wxPanel(parent,wxID_ANY,wxD
     m_web_view->AddScriptMessageHandler("nozzleListTable");
     m_web_view->EnableContextMenu(false);
     fs::path filepath = fs::path(resources_dir()) / "web/flush/NozzleListTable.html";
-    wxString url = file_url_from_path(filepath);
+    wxFileName fn(wxString::FromUTF8(filepath.string()));
+    wxString url = wxFileSystem::FileNameToURL(fn);
     m_web_view->LoadURL(url);
 
     auto sizer = new wxBoxSizer(wxVERTICAL);

src/slic3r/GUI/Widgets/WebHosting.cpp

@@ -48,19 +48,20 @@ constexpr char ORCA_BRIDGE_JS[] = R"JS(
 
 wxString bootstrap_url()
 {
-    return file_url_from_path(boost::filesystem::path(resources_dir()) / BOOTSTRAP_PAGE);
+    return wxString("file://") + from_u8((boost::filesystem::path(resources_dir()) / BOOTSTRAP_PAGE).make_preferred().string());
 }
 
 wxString content_base_url()
 {
-    return file_url_from_path(boost::filesystem::path(resources_dir()) / "web") + "/";
+    const std::string dir = (boost::filesystem::path(resources_dir()) / "web").make_preferred().string();
+    return wxString("file://") + from_u8(dir) + "/";
 }
 
 bool is_content_url(const wxString& url)
 {
-    // The web view reports the URL it parsed, which may escape the resources path differently
-    // from content_base_url().
-    return wxURI::Unescape(url.BeforeFirst('#')) == wxURI::Unescape(content_base_url());
+    // The web view reports the URL it parsed, which escapes anything the resources path holds
+    // (a space, a non-ASCII character), while content_base_url() is the raw path.
+    return wxURI::Unescape(url.BeforeFirst('#')) == content_base_url();
 }
 
 const char* orca_bridge_script() { return ORCA_BRIDGE_JS; }

src/slic3r/GUI/Widgets/WebViewHostDialog.cpp

@@ -192,7 +192,7 @@ bool WebViewHostDialog::create_webview(const std::string& resource_path,
 
 wxString WebViewHostDialog::build_resource_url(const std::string& resource_path) const
 {
-    wxString target_url = file_url_from_path(boost::filesystem::path(resources_dir()) / resource_path);
+    wxString target_url = from_u8((boost::filesystem::path(resources_dir()) / resource_path).make_preferred().string());
 
     if (append_language_to_url()) {
         const wxString lang = wxGetApp().current_language_code_safe();
@@ -202,7 +202,7 @@ wxString WebViewHostDialog::build_resource_url(const std::string& resource_path)
         }
     }
 
-    return target_url;
+    return wxString("file://") + target_url;
 }
 
 void WebViewHostDialog::load_url(const wxString& url)

src/slic3r/GUI/WipeTowerDialog.cpp

@@ -464,7 +464,7 @@ WipingDialog::WipingDialog(wxWindow* parent, const int max_flush_volume) :
     wxString filepath_str = from_path(filepath);
     wxFileName fn(filepath_str);
     if(fn.FileExists()) {
-        wxString url = file_url_from_path(filepath);
+        wxString url = wxFileSystem::FileNameToURL(fn);
         BOOST_LOG_TRIVIAL(debug) << __FUNCTION__<< "File exists and load url " << url.ToStdString();
         m_webview->LoadURL(url);
         BOOST_LOG_TRIVIAL(debug) << __FUNCTION__<< "Successfully loaded url: " << url.ToStdString();

src/slic3r/Utils/ElegooLink.cpp

@@ -340,7 +340,9 @@ namespace Slic3r {
         if (classify_printer_model(config->opt_string("printer_model")) != ElegooPrinterType::CC2)
             return fallback_webui;
 
-        std::string web_path = GUI::into_u8(GUI::file_url_from_path(boost::filesystem::path(resources_dir()) / "web/elegoolink/lan_service_web/index.html"));
+        std::string web_path = resources_dir() + "/web/elegoolink/lan_service_web/index.html";
+        std::replace(web_path.begin(), web_path.end(), '\\', '/');
+        web_path = "file://" + web_path;
         const std::string token   = get_cc2_token(config->opt_string("printhost_apikey"));
         const std::string host_ip = Http::get_host_header_value(host);
 

src/slic3r/Utils/PresetUpdater.cpp

@@ -339,8 +339,62 @@ bool PresetUpdater::priv::get_file(const std::string &url, const fs::path &targe
 //BBS: refine preset update logic
 bool PresetUpdater::priv::extract_file(const fs::path &source_path, const fs::path &dest_path)
 {
-    const std::string parent_path = (!dest_path.empty() ? dest_path : source_path.parent_path()).string();
-    return extract_archive_confined(source_path.string(), parent_path);
+    bool res = true;
+    std::string file_path = source_path.string();
+    std::string parent_path = (!dest_path.empty() ? dest_path : source_path.parent_path()).string();
+    mz_zip_archive archive;
+    mz_zip_zero_struct(&archive);
+
+    if (!open_zip_reader(&archive, file_path))
+    {
+        BOOST_LOG_TRIVIAL(error) << "Unable to open zip reader for "<<file_path;
+        return false;
+    }
+
+    mz_uint num_entries = mz_zip_reader_get_num_files(&archive);
+
+    mz_zip_archive_file_stat stat;
+    // we first loop the entries to read from the archive the .amf file only, in order to extract the version from it
+    for (mz_uint i = 0; i < num_entries; ++i)
+    {
+        if (mz_zip_reader_file_stat(&archive, i, &stat))
+        {
+            std::string dest_file = parent_path+"/"+stat.m_filename;
+            if (stat.m_is_directory) {
+                fs::path dest_path(dest_file);
+                if (!fs::exists(dest_path))
+                    fs::create_directories(dest_path);
+				continue;
+            }
+            else if (stat.m_uncomp_size == 0) {
+                BOOST_LOG_TRIVIAL(warning) << "[Orca Updater]Unzip: invalid size for file "<<stat.m_filename;
+                continue;
+            }
+            try
+            {
+                res = mz_zip_reader_extract_to_file(&archive, stat.m_file_index, dest_file.c_str(), 0);
+                if (!res) {
+                    BOOST_LOG_TRIVIAL(error) << "[Orca Updater]extract file "<<stat.m_filename<<" to dest "<<dest_file<<" failed";
+                    close_zip_reader(&archive);
+                    return res;
+                }
+                BOOST_LOG_TRIVIAL(info) << "[Orca Updater]successfully extract file " << stat.m_file_index << " to "<<dest_file;
+            }
+            catch (const std::exception& e)
+            {
+                // ensure the zip archive is closed and rethrow the exception
+                close_zip_reader(&archive);
+                BOOST_LOG_TRIVIAL(error) << "[Orca Updater]Archive read exception:"<<e.what();
+                return false;
+            }
+        }
+        else {
+            BOOST_LOG_TRIVIAL(warning) << "[Orca Updater]Unzip: read file stat failed";
+        }
+    }
+    close_zip_reader(&archive);
+
+	return true;
 }
 
 // Remove a leftover partial archive for the vendor about to be synchronized.

tests/libslic3r/CMakeLists.txt

@@ -44,7 +44,6 @@ add_executable(${_TEST_NAME}_tests
     test_lay_on_face.cpp
     test_model.cpp
     test_utils.cpp
-    test_miniz_extension.cpp
     test_timeutils.cpp
     test_voronoi.cpp
     test_wipe_tower_estimate.cpp

tests/libslic3r/test_miniz_extension.cpp

@@ -1,194 +0,0 @@
-#include <catch2/catch_all.hpp>
-
-#include "libslic3r/miniz_extension.hpp"
-
-#include "test_utils.hpp"
-
-#include <boost/filesystem.hpp>
-
-#include <algorithm>
-#include <fstream>
-#include <iterator>
-#include <string>
-#include <utility>
-#include <vector>
-
-using namespace Slic3r;
-namespace fs = boost::filesystem;
-
-namespace {
-
-void write_zip(const fs::path &zip_file, const std::vector<std::pair<std::string, std::string>> &entries)
-{
-    mz_zip_archive zip;
-    mz_zip_zero_struct(&zip);
-    REQUIRE(open_zip_writer(&zip, zip_file.string()));
-    for (const auto &[name, content] : entries)
-        REQUIRE(mz_zip_writer_add_mem(&zip, name.c_str(), content.data(), content.size(), MZ_DEFAULT_COMPRESSION));
-    REQUIRE(mz_zip_writer_finalize_archive(&zip));
-    REQUIRE(close_zip_writer(&zip));
-}
-
-// miniz refuses to write a name starting with '/', so write a placeholder of the same length and patch it in place.
-void rename_entry(const fs::path &zip_file, const std::string &from, const std::string &to)
-{
-    REQUIRE(from.size() == to.size());
-    std::string bytes;
-    {
-        std::ifstream in(zip_file.string(), std::ios::binary);
-        bytes.assign(std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>());
-    }
-    size_t count = 0;
-    for (size_t pos = bytes.find(from); pos != std::string::npos; pos = bytes.find(from, pos + to.size()), ++count)
-        bytes.replace(pos, from.size(), to);
-    // Once in the local header and once in the central directory.
-    REQUIRE(count == 2);
-    std::ofstream out(zip_file.string(), std::ios::binary | std::ios::trunc);
-    out << bytes;
-}
-
-std::vector<std::string> list_dir(const fs::path &dir)
-{
-    std::vector<std::string> names;
-    for (const fs::directory_entry &entry : fs::directory_iterator(dir))
-        names.push_back(entry.path().filename().string());
-    std::sort(names.begin(), names.end());
-    return names;
-}
-
-std::string read_file(const fs::path &file)
-{
-    std::ifstream in(file.string(), std::ios::binary);
-    return std::string(std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>());
-}
-
-} // namespace
-
-TEST_CASE("Confined extraction writes a well-formed archive under the target directory", "[MinizExtension]")
-{
-    ScopedTemporaryDir tmp;
-    const fs::path     zip_file = tmp.path() / "bundle.zip";
-    const fs::path     target   = tmp.path() / "cache";
-    fs::create_directories(target);
-    write_zip(zip_file, {{"vendor/", ""}, {"vendor/machine/", ""}, {"vendor.json", "{\"a\":1}"}, {"vendor/machine/printer.json", "{\"b\":2}"}});
-
-    REQUIRE(extract_archive_confined(zip_file.string(), target.string()));
-    CHECK(fs::is_directory(target / "vendor"));
-    CHECK(read_file(target / "vendor.json") == "{\"a\":1}");
-    CHECK(read_file(target / "vendor" / "machine" / "printer.json") == "{\"b\":2}");
-}
-
-TEST_CASE("Confined extraction rejects an archive with an entry outside the target directory", "[MinizExtension]")
-{
-    ScopedTemporaryDir tmp;
-    const fs::path     zip_file = tmp.path() / "bundle.zip";
-    const fs::path     target   = tmp.path() / "cache";
-    fs::create_directories(target);
-
-    const std::string escaping_entry = GENERATE(std::string("../escape.txt"), std::string("..\\escape.txt"),
-                                                std::string("sub/../../escape.txt"), std::string("C:/escape.txt"),
-                                                std::string("C:escape.txt"), std::string("\\escape.txt"));
-    // The normal entry comes first so a per-entry check would already have written it.
-    write_zip(zip_file, {{"normal.json", "{}"}, {escaping_entry, "escaped"}});
-
-    CAPTURE(escaping_entry);
-    CHECK_FALSE(extract_archive_confined(zip_file.string(), target.string()));
-    CHECK_FALSE(fs::exists(tmp.path() / "escape.txt"));
-    CHECK(fs::is_empty(target));
-}
-
-TEST_CASE("Confined extraction rejects an archive with an absolute entry name", "[MinizExtension]")
-{
-    ScopedTemporaryDir tmp;
-    const fs::path     zip_file = tmp.path() / "bundle.zip";
-    const fs::path     target   = tmp.path() / "cache";
-    fs::create_directories(target);
-
-    const std::string absolute    = (tmp.path() / "escape.txt").generic_string();
-    const std::string placeholder = "#" + absolute.substr(1);
-    write_zip(zip_file, {{"normal.json", "{}"}, {placeholder, "escaped"}});
-    rename_entry(zip_file, placeholder, absolute);
-
-    CHECK_FALSE(extract_archive_confined(zip_file.string(), target.string()));
-    CHECK_FALSE(fs::exists(tmp.path() / "escape.txt"));
-    CHECK(fs::is_empty(target));
-}
-
-TEST_CASE("Confined extraction rejects a directory entry outside the target directory", "[MinizExtension]")
-{
-    ScopedTemporaryDir tmp;
-    const fs::path     zip_file = tmp.path() / "bundle.zip";
-    const fs::path     target   = tmp.path() / "cache";
-    fs::create_directories(target);
-    write_zip(zip_file, {{"vendor/", ""}, {"../outside/", ""}});
-
-    CHECK_FALSE(extract_archive_confined(zip_file.string(), target.string()));
-    CHECK_FALSE(fs::exists(tmp.path() / "outside"));
-    CHECK(fs::is_empty(target));
-}
-
-TEST_CASE("Confined extraction validates zero-size entries like any other", "[MinizExtension]")
-{
-    ScopedTemporaryDir tmp;
-    const fs::path     zip_file = tmp.path() / "bundle.zip";
-    const fs::path     target   = tmp.path() / "cache";
-    fs::create_directories(target);
-
-    SECTION("an empty file inside the target does not fail the archive") {
-        write_zip(zip_file, {{"empty.json", ""}, {"vendor.json", "{}"}});
-        CHECK(extract_archive_confined(zip_file.string(), target.string()));
-        CHECK(read_file(target / "vendor.json") == "{}");
-    }
-    SECTION("an empty file outside the target rejects the archive") {
-        write_zip(zip_file, {{"vendor.json", "{}"}, {"../escape.txt", ""}});
-        CHECK_FALSE(extract_archive_confined(zip_file.string(), target.string()));
-        CHECK_FALSE(fs::exists(tmp.path() / "escape.txt"));
-        CHECK(fs::is_empty(target));
-    }
-}
-
-TEST_CASE("Confined extraction writes nothing outside the target for Windows-specific name forms", "[MinizExtension]")
-{
-    ScopedTemporaryDir tmp;
-    const fs::path     zip_file = tmp.path() / "bundle.zip";
-    const fs::path     target   = tmp.path() / "cache";
-    fs::create_directories(target);
-
-    // Windows strips trailing dots and spaces and maps device names; whether these extract depends on the
-    // platform, but none of them may land beside the target.
-    const std::string name = GENERATE(std::string("name."), std::string("name "), std::string("..."), std::string(".. "),
-                                      std::string(".. /escape.txt"), std::string(".../escape.txt"), std::string("CON"),
-                                      std::string("sub/NUL.txt"), std::string("C:escape.txt"));
-    write_zip(zip_file, {{name, "payload"}});
-
-    CAPTURE(name);
-    extract_archive_confined(zip_file.string(), target.string());
-    CHECK(list_dir(tmp.path()) == std::vector<std::string>{"bundle.zip", "cache"});
-}
-
-#ifndef _WIN32
-TEST_CASE("Confined extraction replaces a symlink at the destination instead of writing through it", "[MinizExtension]")
-{
-    ScopedTemporaryDir tmp;
-    const fs::path     zip_file = tmp.path() / "bundle.zip";
-    const fs::path     target   = tmp.path() / "cache";
-    const fs::path     outside  = tmp.path() / "outside";
-    fs::create_directories(target);
-    fs::create_directories(outside);
-    write_zip(zip_file, {{"vendor.json", "{\"a\":1}"}});
-
-    SECTION("a dangling symlink") {
-        fs::create_symlink(outside / "vendor.json", target / "vendor.json");
-        CHECK(extract_archive_confined(zip_file.string(), target.string()));
-        CHECK_FALSE(fs::exists(outside / "vendor.json"));
-        CHECK_FALSE(fs::is_symlink(fs::symlink_status(target / "vendor.json")));
-        CHECK(read_file(target / "vendor.json") == "{\"a\":1}");
-    }
-    SECTION("a symlink to an existing file") {
-        { std::ofstream((outside / "vendor.json").string()) << "original"; }
-        fs::create_symlink(outside / "vendor.json", target / "vendor.json");
-        extract_archive_confined(zip_file.string(), target.string());
-        CHECK(read_file(outside / "vendor.json") == "original");
-    }
-}
-#endif

tests/libslic3r/test_utils.cpp

@@ -243,82 +243,3 @@ TEST_CASE("find_unused_filename gives up after 999 versions", "[Utils]") {
     REQUIRE_FALSE(find_unused_filename(dir.path(), "model.3mf", {}, name));
     CHECK(name == "model(999).3mf");
 }
-
-TEST_CASE("is_path_within_root accepts a root given with a trailing separator", "[utils]") {
-    ScopedTemporaryDir tmp;
-    const std::string root = tmp.path().string();
-    const std::string with_separator = GENERATE_COPY(root + "/", root + std::string(1, static_cast<char>(boost::filesystem::path::preferred_separator)));
-
-    CAPTURE(with_separator);
-    CHECK(is_path_within_root("vendor.json", with_separator));
-    CHECK(is_path_within_root("vendor/machine/printer.json", with_separator));
-    CHECK_FALSE(is_path_within_root("../vendor.json", with_separator));
-}
-
-TEST_CASE("is_path_within_root treats Windows-specific name forms the same on every platform", "[utils]") {
-    ScopedTemporaryDir tmp;
-
-    SECTION("names ending in dots or spaces stay inside the root") {
-        const std::string name = GENERATE(std::string("name."), std::string("name "), std::string("dir./file.json"), std::string("dir /file.json"));
-        CAPTURE(name);
-        CHECK(is_path_within_root(name, tmp.path()));
-    }
-    SECTION("drive-relative names are rejected") {
-        const std::string name = GENERATE(std::string("C:x"), std::string("c:x/y.json"), std::string("C:"));
-        CAPTURE(name);
-        CHECK_FALSE(is_path_within_root(name, tmp.path()));
-    }
-}
-
-TEST_CASE("is_path_within_root rejects a name with an embedded NUL", "[utils]") {
-    ScopedTemporaryDir tmp;
-    // The filesystem calls stop at the NUL, so they would act on a different path than the one checked.
-    const std::string name = GENERATE(std::string("..\0", 3), std::string("..\0x/file.json", 14), std::string("sub/..\0x", 8),
-                                      std::string("file.json\0", 10), std::string("\0file.json", 10));
-    CAPTURE(name.size());
-    CHECK_FALSE(is_path_within_root(name, tmp.path()));
-}
-
-TEST_CASE("is_symlink_target_within_root accepts relative targets that stay inside the root", "[utils]") {
-    ScopedTemporaryDir tmp;
-    const auto [link, target] = GENERATE(std::make_pair(std::string("Versions/Current"), std::string("A")),
-                                         std::make_pair(std::string("Foo.framework/Foo"), std::string("Versions/Current/Foo")),
-                                         std::make_pair(std::string("libfoo.so"), std::string("libfoo.so.1")),
-                                         std::make_pair(std::string("a/b/link"), std::string("c/d")));
-    CAPTURE(link, target);
-    CHECK(is_symlink_target_within_root(link, target, tmp.path()));
-}
-
-TEST_CASE("is_symlink_target_within_root rejects absolute targets and targets that climb out", "[utils]") {
-    ScopedTemporaryDir tmp;
-    const std::string outside = (tmp.path().parent_path() / "outside").generic_string();
-    const auto [link, target] = GENERATE_COPY(std::make_pair(std::string("sub/link"), outside),
-                                              std::make_pair(std::string("sub/link"), std::string("/etc/passwd")),
-                                              std::make_pair(std::string("sub/link"), std::string("\\outside")),
-                                              std::make_pair(std::string("sub/link"), std::string("C:/outside")),
-                                              std::make_pair(std::string("sub/link"), std::string("C:outside")),
-                                              std::make_pair(std::string("sub/link"), std::string("")),
-                                              std::make_pair(std::string("link"), std::string("..")),
-                                              std::make_pair(std::string("link"), std::string("../outside")),
-                                              std::make_pair(std::string("sub/link"), std::string("../../outside")),
-                                              std::make_pair(std::string("sub/link"), std::string("x/../../../outside")),
-                                              std::make_pair(std::string("sub/link"), std::string("..\\..\\outside")),
-                                              // symlink() stops at the NUL, so this target would be created as "..".
-                                              std::make_pair(std::string("link"), std::string("..\0", 3)));
-    CAPTURE(link, target);
-    CHECK_FALSE(is_symlink_target_within_root(link, target, tmp.path()));
-}
-
-#ifndef _WIN32
-TEST_CASE("is_symlink_target_within_root rejects a target that passes through a symlink leading out", "[utils]") {
-    ScopedTemporaryDir tmp;
-    const boost::filesystem::path root    = tmp.path() / "root";
-    const boost::filesystem::path outside = tmp.path() / "outside";
-    boost::filesystem::create_directories(root);
-    boost::filesystem::create_directories(outside);
-    boost::filesystem::create_symlink(outside, root / "out");
-
-    CHECK_FALSE(is_symlink_target_within_root("link", "out/lib.so", root));
-    CHECK(is_symlink_target_within_root("link", "in/lib.so", root));
-}
-#endif

tests/slic3rutils/CMakeLists.txt

@@ -27,7 +27,6 @@ add_executable(${_TEST_NAME}_tests
     test_plugin_cloud_metadata.cpp
     test_plugin_audit.cpp
     test_shortcuts.cpp
-    test_file_url.cpp
     ../fff_print/test_helpers.cpp
     )
 

tests/slic3rutils/python_test_support.hpp

@@ -6,6 +6,7 @@
 #include <boost/filesystem.hpp>
 #include <memory.h>
 #include <stdexcept>
+#include <string>
 #include <pybind11/embed.h>
 #include <pybind11/pybind11.h>
 
@@ -25,8 +26,15 @@ void ensure_python_initialized()
     config.parse_argv = 0;
 
     const auto python_home = boost::dll::program_location().parent_path() / "python";
+#ifdef _WIN32
+    const auto stdlib = python_home / "Lib";
+#else
+    const auto stdlib = python_home / "lib" /
+                        ("python" + std::to_string(PY_MAJOR_VERSION) + "." + std::to_string(PY_MINOR_VERSION));
+#endif
 
-    if (boost::filesystem::exists(python_home)) {
+    // Only a real runtime: a stray python/ folder (packages a test left behind) is not a home.
+    if (boost::filesystem::exists(stdlib / "encodings")) {
         const std::string home = python_home.string();
         const PyStatus status  = PyConfig_SetBytesString(&config, &config.home, home.c_str());
 

tests/slic3rutils/test_file_url.cpp

@@ -1,74 +0,0 @@
-#include <catch2/catch_test_macros.hpp>
-#include <catch2/generators/catch_generators.hpp>
-
-#include "slic3r/GUI/GUI.hpp"
-
-#include <boost/filesystem/path.hpp>
-
-#include <wx/uri.h>
-
-using namespace Slic3r::GUI;
-
-#ifndef _WIN32
-TEST_CASE("A file URL keeps characters special to URLs in its path", "[FileUrl]")
-{
-    const std::string path = GENERATE(as<std::string>{},
-        "/opt/test#dir/resources/web/homepage/index.html",
-        "/opt/test%20x/resources/web/homepage/index.html",
-        "/opt/Orca Slicer/resources/web/homepage/index.html",
-        "/opt/what?/resources/web/homepage/index.html",
-        "/home/Jos\xC3\xA9/\xE8\xB5\x84\xE6\xBA\x90/resources/web/homepage/index.html");
-
-    const wxString url = file_url_from_path(boost::filesystem::path(path));
-    CAPTURE(path, url.utf8_string());
-
-    // WebView::CreateWebView() and WebView::LoadUrl() re-parse the URL before loading it.
-    const wxURI uri(wxURI(url).BuildURI());
-    CHECK(uri.GetScheme() == "file");
-    CHECK(!uri.HasQuery());
-    CHECK(!uri.HasFragment());
-    CHECK(wxURI::Unescape(uri.GetPath()).utf8_string() == path);
-}
-
-TEST_CASE("A file URL of a plain path is the path behind file://", "[FileUrl]")
-{
-    const std::string path = "/opt/OrcaSlicer/resources/web/homepage/index.html";
-    CHECK(file_url_from_path(boost::filesystem::path(path)) == "file://" + path);
-}
-
-TEST_CASE("A query appended to a file URL stays separate from its path", "[FileUrl]")
-{
-    const std::string path = "/opt/test#dir%20x/resources/web/guide/0/index.html";
-    const wxURI uri(file_url_from_path(boost::filesystem::path(path)) + "?target=21&lang=de");
-    CHECK(wxURI::Unescape(uri.GetPath()).utf8_string() == path);
-    CHECK(uri.GetQuery() == "target=21&lang=de");
-    CHECK(!uri.HasFragment());
-}
-#else
-TEST_CASE("A file URL of a Windows path has a drive letter and forward slashes", "[FileUrl]")
-{
-    const auto [path, url] = GENERATE(table<std::wstring, std::string>({
-        { L"C:\\Program Files\\OrcaSlicer\\resources\\web\\homepage\\index.html",
-          "file:///C:/Program%20Files/OrcaSlicer/resources/web/homepage/index.html" },
-        { L"D:\\#OneDrive\\OrcaSlicer\\resources\\web\\guide\\0\\index.html",
-          "file:///D:/%23OneDrive/OrcaSlicer/resources/web/guide/0/index.html" },
-        { L"D:\\100%\\OrcaSlicer\\resources\\web\\homepage\\index.html",
-          "file:///D:/100%25/OrcaSlicer/resources/web/homepage/index.html" },
-        // Callers join the resources directory with a forward-slash relative path.
-        { L"D:\\#OneDrive\\OrcaSlicer\\resources/web/homepage/index.html",
-          "file:///D:/%23OneDrive/OrcaSlicer/resources/web/homepage/index.html" },
-        { L"\\\\server\\share\\OrcaSlicer\\resources\\web\\homepage\\index.html",
-          "file://server/share/OrcaSlicer/resources/web/homepage/index.html" },
-    }));
-    CHECK(file_url_from_path(boost::filesystem::path(path)).utf8_string() == url);
-}
-
-TEST_CASE("A query appended to a Windows file URL stays separate from its path", "[FileUrl]")
-{
-    const wxURI uri(file_url_from_path(boost::filesystem::path(L"D:\\#OneDrive\\OrcaSlicer\\resources\\web\\guide\\0\\index.html")) +
-                    "?target=21&lang=de");
-    CHECK(wxURI::Unescape(uri.GetPath()) == "/D:/#OneDrive/OrcaSlicer/resources/web/guide/0/index.html");
-    CHECK(uri.GetQuery() == "target=21&lang=de");
-    CHECK(!uri.HasFragment());
-}
-#endif

tests/slic3rutils/test_plugin_capability_config.cpp

@@ -38,6 +38,9 @@ namespace {
 // before this destructor's shutdown() runs.
 struct ScopedPluginManager
 {
+    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
+    // which would otherwise land in the working directory.
+    ScopedDataDir python_data_dir{"plugin-python"};
     bool initialized = PluginManager::instance().initialize();
 
     ~ScopedPluginManager()

tests/slic3rutils/test_plugin_cloud_metadata.cpp

@@ -31,6 +31,9 @@ namespace {
 // same as any other plugin.
 struct ScopedManagerShutdown
 {
+    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
+    // which would otherwise land in the working directory.
+    ScopedDataDir python_data_dir{"plugin-python"};
     bool initialized = PluginManager::instance().initialize();
 
     ~ScopedManagerShutdown()

tests/slic3rutils/test_plugin_host_api.cpp

@@ -16,8 +16,6 @@
 
 #include <string>
 
-#include <wx/uri.h>
-
 namespace py = pybind11;
 
 namespace {
@@ -212,33 +210,23 @@ TEST_CASE("A reloaded plugin page is recognised by its base URL, fragment aside"
 {
     using namespace Slic3r::GUI::web_hosting;
 
-    // A resources path holding a space, which the web view may report escaped differently.
+    // A resources path holding a space, which the web view reports escaped.
     const Slic3r::ScopedResourcesDir resources("web content check");
 
     // The swapped-in page, then after an in-page anchor and a reload.
     CHECK(is_content_url(content_base_url()));
     CHECK(is_content_url(content_base_url() + "#tab2"));
-    const wxString unescaped = wxURI::Unescape(content_base_url());
-    REQUIRE(unescaped != content_base_url());
-    CHECK(is_content_url(unescaped));
-    CHECK(is_content_url(unescaped + "#tab2"));
+    wxString escaped = content_base_url();
+    escaped.Replace(" ", "%20");
+    REQUIRE(escaped != content_base_url());
+    CHECK(is_content_url(escaped));
+    CHECK(is_content_url(escaped + "#tab2"));
     // A page the plugin linked to keeps its own URL and must be left alone.
     CHECK_FALSE(is_content_url(content_base_url() + "guide.html"));
     CHECK_FALSE(is_content_url("https://example.com/"));
     CHECK_FALSE(is_content_url(""));
 }
 
-TEST_CASE("A reloaded plugin page is recognised when the resources path holds a '#'", "[PluginHost]")
-{
-    using namespace Slic3r::GUI::web_hosting;
-
-    const Slic3r::ScopedResourcesDir resources("web#content check");
-
-    CHECK(is_content_url(content_base_url()));
-    CHECK(is_content_url(content_base_url() + "#tab2"));
-    CHECK_FALSE(is_content_url(content_base_url() + "guide.html"));
-}
-
 TEST_CASE("Plugin host API exposes model geometry and structure to Python", "[PluginHost][Python]")
 {
     using Catch::Matchers::WithinAbs;

tests/slic3rutils/test_plugin_lifecycle.cpp

@@ -41,6 +41,9 @@ namespace {
 // Declare this FIRST in a test so it is destroyed last.
 struct ScopedPluginManager
 {
+    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
+    // which would otherwise land in the working directory.
+    ScopedDataDir python_data_dir{"plugin-python"};
     bool initialized = false;
 
     ScopedPluginManager() { initialized = PluginManager::instance().initialize(); }

tests/slic3rutils/test_plugin_printer_agent.cpp

@@ -12,6 +12,8 @@
 #include <memory>
 #include <string>
 
+#include "plugin_test_utils.hpp"
+
 namespace py = pybind11;
 using namespace Slic3r;
 
@@ -21,6 +23,9 @@ namespace {
 // into Python unless PythonInterpreter::instance() reports initialized.
 struct ScopedPluginManager
 {
+    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
+    // which would otherwise land in the working directory.
+    ScopedDataDir python_data_dir{"plugin-python"};
     bool initialized = PluginManager::instance().initialize();
 
     ~ScopedPluginManager()

tests/slic3rutils/test_slicing_pipeline_config.cpp

@@ -35,6 +35,9 @@ namespace {
 
 struct ScopedPluginManager
 {
+    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
+    // which would otherwise land in the working directory.
+    ScopedDataDir python_data_dir{"plugin-python"};
     bool initialized = false;
 
     ScopedPluginManager() { initialized = PluginManager::instance().initialize(); }