Keep the Segment-Based Voronoi Reproducers

The gapfill, weirdness and NaN reproducers go through Orca's repairing VoronoiDiagram once they use it instead of raw boost, so they are converted rather than deleted. Only the two point-input reproducers, which the wrapper neither checks nor repairs, are removed.

sandboxes/orca_network_permission_probe_plugin.py

@@ -1,39 +0,0 @@
-# /// script
-# requires-python = ">=3.12"
-#
-# [tool.orcaslicer.plugin]
-# name = "Network Permission Probe"
-# description = "Tests host-based network permission prompts and matching"
-# author = "OrcaSlicer"
-# version = "0.1.0"
-# ///
-"""Local probe for the orca.request_permissions(network=...) API.
-
-Install this file as a local plugin, approve https://example.com, then run the
-script capability more than once. Each run changes the query string; the saved
-scheme/host grant should prevent another prompt for that same host.
-"""
-
-import time
-import urllib.request
-
-import orca
-
-
-class NetworkPermissionProbe(orca.script.ScriptPluginCapabilityBase):
-    def get_name(self):
-        return "Network Permission Probe"
-
-    def execute(self):
-        # User-triggered GET to a reserved example domain; varying the query tests
-        # that permission matching is not tied to the complete URL.
-        url = f"https://example.com/?permission_probe={time.time_ns()}"
-        with urllib.request.urlopen(url, timeout=10) as response:
-            return orca.ExecutionResult.success(f"Network permission probe: HTTP {response.status}")
-
-
-@orca.plugin
-class NetworkPermissionProbePackage(orca.base):
-    def register_capabilities(self):
-        orca.request_permissions(network=["https://example.com"])
-        orca.register_capability(NetworkPermissionProbe)

src/libslic3r/Format/bbs_3mf.cpp

@@ -988,7 +988,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
 
             MetadataList metadata;
             VolumeMetadataList volumes;
-            std::optional<bool> auto_drop;
+            bool auto_drop { true };
         };
 
         struct CutObjectInfo
@@ -1208,7 +1208,6 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         //IdToGeometryMap m_orig_geometries; // backup & restore
         CurrentConfig m_curr_config;
         IdToMetadataMap m_objects_metadata;
-        std::set<int>   m_items_auto_drop_off; // object ids with a build item auto_drop="0" (2.4.x layout)
         IdToCutObjectInfoMap       m_cut_object_infos;
         IdToLayerHeightsProfileMap m_layer_heights_profiles;
         IdToLayerConfigRangesMap m_layer_config_ranges;
@@ -1464,7 +1463,6 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         m_objects.clear();
         m_instances.clear();
         m_objects_metadata.clear();
-        m_items_auto_drop_off.clear();
         m_curr_metadata_name.clear();
         m_curr_characters.clear();
 
@@ -1504,7 +1502,6 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         m_curr_config.object_id = -1;
         m_curr_config.volume_id = -1;
         m_objects_metadata.clear();
-        m_items_auto_drop_off.clear();
         m_layer_heights_profiles.clear();
         m_layer_config_ranges.clear();
         m_brim_ear_points.clear();
@@ -2260,14 +2257,11 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             ObjectMetadata::VolumeMetadataList volumes;
             ObjectMetadata::VolumeMetadataList* volumes_ptr = nullptr;
 
-            // 2.4.x stored auto_drop on build items, shared by all instances of an object; any "off" wins
-            const bool legacy_auto_drop = !m_items_auto_drop_off.count(object.first.second);
-
             IdToMetadataMap::iterator obj_metadata = m_objects_metadata.find(object.first.second);
             if (obj_metadata != m_objects_metadata.end()) {
                 // config data has been found, this model was saved using slic3r pe
 
-                model_object->auto_drop = obj_metadata->second.auto_drop.value_or(legacy_auto_drop);
+                model_object->auto_drop = obj_metadata->second.auto_drop;
 
                 // apply object's name and config data
                 for (const Metadata& metadata : obj_metadata->second.metadata) {
@@ -2285,7 +2279,6 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             }
             else {
                 // config data not found, this model was not saved using slic3r pe
-                model_object->auto_drop = legacy_auto_drop;
 
                 // add the entire geometry as the single volume to generate
                 //volumes.emplace_back(0, (int)obj_geometry->second.triangles.size() - 1);
@@ -4128,8 +4121,6 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         std::string path = bbs_get_attribute_value_string(attributes, num_attributes, PPATH_ATTR);
         Transform3d transform = bbs_get_transform_from_3mf_specs_string(bbs_get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR));
         int printable = bbs_get_attribute_value_bool(attributes, num_attributes, PRINTABLE_ATTR);
-        if (const char* auto_drop = bbs_get_attribute_value_charptr(attributes, num_attributes, AUTO_DROP_ATTR); auto_drop != nullptr && !::atoi(auto_drop))
-            m_items_auto_drop_off.insert(object_id);
         return !m_load_model || _create_object_instance(path, object_id, transform, printable, 1);
     }
 
@@ -4498,8 +4489,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         // int instances_count_id = bbs_get_attribute_value_int(attributes, num_attributes, INSTANCESCOUNT_ATTR);
 
         ObjectMetadata metadata;
-        if (bbs_get_attribute_value_charptr(attributes, num_attributes, AUTO_DROP_ATTR) != nullptr)
+        metadata.auto_drop = bbs_get_attribute_value_bool(attributes, num_attributes, AUTO_DROP_ATTR);
-            metadata.auto_drop = bbs_get_attribute_value_bool(attributes, num_attributes, AUTO_DROP_ATTR);
         m_objects_metadata.insert({ object_id, std::move(metadata) });
         m_curr_config.object_id = object_id;
         return true;

src/slic3r/plugin/PluginAuditManager.cpp

@@ -5,14 +5,10 @@
 #include "libslic3r/libslic3r.h" // GCODEVIEWER_APP_KEY, and SLIC3R_APP_KEY via libslic3r_version.h
 #include "libslic3r_version.h"
 
-#include <boost/algorithm/string/case_conv.hpp>
 #include <boost/algorithm/string/predicate.hpp>
-#include <boost/algorithm/string/trim.hpp>
-#include <boost/asio/ip/address.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/filesystem/operations.hpp>
 #include <boost/log/trivial.hpp>
-#include <boost/system/error_code.hpp>
 
 #include <algorithm>
 #include <cctype>
@@ -150,205 +146,6 @@ static bool is_fs_category(AuditEventCategory category)
     }
 }
 
-// HTTP and raw-socket events are governed by the same network permission: a declared host may be
-// reached through either layer, and the layers nest for one plugin action (urllib -> http.client
-// -> socket).
-static bool is_network_category(AuditEventCategory category)
-{
-    return category == AuditEventCategory::Http || category == AuditEventCategory::Socket;
-}
-
-// The only network events whose target can be a resolved address instead of the host the plugin
-// asked for. They may fall back to a network-approved call site; every other network event must
-// name a host or URL the hook can match directly.
-static bool is_resolved_address_event(const std::string& event_name)
-{
-    return event_name == "socket.connect" || event_name == "socket.sendto";
-}
-
-// ---------------------------------------------------------------------------
-// Network permission identity
-// ---------------------------------------------------------------------------
-
-static std::string ascii_lower(std::string value)
-{
-    boost::algorithm::to_lower(value);
-    return value;
-}
-
-static std::string trim_ascii_space(std::string value)
-{
-    boost::algorithm::trim(value);
-    return value;
-}
-
-// Canonical storage keeps IPv6 literals bracketed (https://[::1]), while a socket address
-// exposes the bare literal (::1). Compare them without the brackets.
-static std::string without_ipv6_brackets(std::string host)
-{
-    if (host.size() >= 2 && host.front() == '[' && host.back() == ']')
-        host = host.substr(1, host.size() - 2);
-    return host;
-}
-
-// Returns the host part of a URL authority, dropping userinfo and port. IPv6 literals keep their
-// brackets so that a URL and a bare address compare consistently.
-static std::string host_from_authority(std::string authority)
-{
-    const size_t at = authority.rfind('@');
-    if (at != std::string::npos)
-        authority.erase(0, at + 1);
-
-    if (authority.empty())
-        return {};
-
-    if (authority.front() == '[') {
-        const size_t close = authority.find(']');
-        if (close == std::string::npos)
-            return {};
-        authority.erase(close + 1);
-        return ascii_lower(authority);
-    }
-
-    const size_t colon = authority.find(':');
-    if (colon != std::string::npos)
-        authority.erase(colon);
-
-    if (authority.find_first_of(" \t\r\n/?#@") != std::string::npos)
-        return {};
-
-    return ascii_lower(authority);
-}
-
-// Extracts a host from a target that is not a URL: "host", "host:443", "[::1]:443", "('host',
-// 443)" (the form older releases persisted for socket address events), or "'host'".
-static std::string network_host_from_target(const std::string& target)
-{
-    std::string value = trim_ascii_space(target);
-    if (value.empty())
-        return {};
-
-    if (value.front() == '(') {
-        // Legacy persisted address tuple: ("host", 443) or ("host", 443, 0, 0).
-        const size_t quote = value.find_first_of("'\"");
-        if (quote != std::string::npos) {
-            const char   delimiter = value[quote];
-            const size_t end       = value.find(delimiter, quote + 1);
-            if (end == std::string::npos)
-                return {};
-            value = value.substr(quote + 1, end - quote - 1);
-        } else {
-            value = value.substr(1);
-            const size_t comma = value.find(',');
-            if (comma != std::string::npos)
-                value.erase(comma);
-        }
-    } else if (value.front() == '[') {
-        const size_t close = value.find(']');
-        if (close == std::string::npos)
-            return {};
-        value.erase(close + 1);
-    } else {
-        // Strip a ":port" suffix, but leave a bare IPv6 literal ("::1") intact.
-        const size_t colon = value.find(':');
-        if (colon != std::string::npos && value.find(':', colon + 1) == std::string::npos)
-            value.erase(colon);
-    }
-
-    value = trim_ascii_space(value);
-    if (value.empty() || value.find_first_of(" \t\r\n/?#@") != std::string::npos)
-        return {};
-
-    return ascii_lower(value);
-}
-
-std::string PluginAuditManager::normalize_network_url(const std::string& url)
-{
-    const size_t scheme_end = url.find("://");
-    if (scheme_end == std::string::npos || scheme_end == 0)
-        return {};
-
-    const std::string scheme = ascii_lower(url.substr(0, scheme_end));
-    if (scheme != "http" && scheme != "https")
-        return {};
-
-    const size_t authority_start = scheme_end + 3;
-    const size_t authority_end   = url.find_first_of("/?#", authority_start);
-    const std::string authority  = url.substr(authority_start, authority_end == std::string::npos
-                                                                    ? std::string::npos
-                                                                    : authority_end - authority_start);
-
-    const std::string host = host_from_authority(authority);
-    if (host.empty())
-        return {};
-
-    return scheme + "://" + host;
-}
-
-bool PluginAuditManager::network_permission_matches(const std::vector<std::string>& granted,
-                                                    const std::string&              target)
-{
-    if (target.empty())
-        return false;
-
-    const bool        target_is_url = target.find("://") != std::string::npos;
-    const std::string target_url    = normalize_network_url(target);
-    if (target_is_url && target_url.empty()) {
-        // A non-http(s) URL has no network identity we can generalize; only an exact grant
-        // recorded by an earlier approval stays valid, so an unrelated scheme never matches.
-        return std::find(granted.begin(), granted.end(), target) != granted.end();
-    }
-
-    const std::string target_host =
-        target_is_url ? std::string{} : without_ipv6_brackets(network_host_from_target(target));
-    if (!target_is_url && target_host.empty())
-        return false;
-
-    for (const std::string& entry : granted) {
-        // Preserve an exact grant recorded by an older release, e.g. a full URL with a query.
-        if (entry == target)
-            return true;
-
-        const std::string entry_url = normalize_network_url(entry);
-        if (target_is_url) {
-            if (entry_url == target_url)
-                return true;
-            continue;
-        }
-
-        if (!entry_url.empty()) {
-            // Bare hosts carry no scheme: match the host part of a scheme://host grant.
-            const std::string entry_host = entry_url.substr(entry_url.find("://") + 3);
-            if (without_ipv6_brackets(entry_host) == target_host)
-                return true;
-        } else if (without_ipv6_brackets(network_host_from_target(entry)) == target_host) {
-            // Legacy persisted address tuples, e.g. "('host', 443)".
-            return true;
-        }
-    }
-
-    return false;
-}
-
-bool PluginAuditManager::is_ip_address_target(const std::string& target)
-{
-    if (target.empty() || target.find("://") != std::string::npos)
-        return false;
-
-    std::string host = target;
-    if (host.size() >= 2 && host.front() == '[' && host.back() == ']')
-        host = host.substr(1, host.size() - 2);
-
-    // Drop an IPv6 zone identifier before parsing; it is not part of the address literal.
-    const size_t zone = host.find('%');
-    if (zone != std::string::npos)
-        host.erase(zone);
-
-    boost::system::error_code ec;
-    boost::asio::ip::make_address(host, ec);
-    return !ec;
-}
-
 // ---------------------------------------------------------------------------
 // Path safety
 // ---------------------------------------------------------------------------
@@ -674,39 +471,6 @@ AuditDecision PluginAuditManager::check_open(const std::string& path_str, const
     return check_path_access(boost::filesystem::path(path_str), is_write);
 }
 
-namespace {
-
-// Builds and shows the modal confirmation. Must run on the GUI thread.
-bool show_permission_dialog(const wxString& message, const wxString& title)
-{
-    wxMessageDialog dialog(nullptr, message, title, wxYES_NO | wxICON_WARNING);
-    return dialog.ShowModal() == wxID_YES;
-}
-
-// Shows a permission prompt on the GUI thread and waits for the answer. The caller may be the
-// plugin-load worker, so off the main thread the dialog is marshaled with CallAfter.
-bool ask_permission(const wxString& message)
-{
-    if (wxTheApp == nullptr || GUI::wxGetApp().is_closing())
-        return false;
-
-    if (wxIsMainThread())
-        return show_permission_dialog(message, _L("Plugin permissions"));
-
-    auto result = std::make_shared<std::promise<bool>>();
-    auto future = result->get_future();
-    GUI::wxGetApp().CallAfter([result, message]() {
-        if (wxTheApp == nullptr || GUI::wxGetApp().is_closing()) {
-            result->set_value(false);
-            return;
-        }
-        result->set_value(show_permission_dialog(message, _L("Plugin permissions")));
-    });
-    return future.get();
-}
-
-} // namespace
-
 bool PluginAuditManager::request_filesystem_read_permissions(const std::string&              plugin_key,
                                                               const std::vector<std::string>& paths)
 {
@@ -728,80 +492,60 @@ bool PluginAuditManager::request_filesystem_read_permissions(const std::string&
     if (missing.empty())
         return true;
 
-    wxString requested_paths;
+    if (wxTheApp == nullptr || GUI::wxGetApp().is_closing())
-    for (const std::string& path : missing)
-        requested_paths += wxString::FromUTF8(path.c_str()) + "\n";
-
-    if (!ask_permission(wxString::Format(_L("Plugin \"%s\" requests filesystem read access to:\n%s"),
-                                        wxString::FromUTF8(descriptor.name.c_str()), requested_paths)))
         return false;
 
-    seed_install_metadata(state, descriptor);
+    auto show_dialog = [&descriptor, &missing]() {
+        wxString requested_paths;
+        for (const std::string& path : missing)
+            requested_paths += wxString::FromUTF8(path.c_str()) + "\n";
+
+        wxMessageDialog dialog(
+            nullptr,
+            wxString::Format(_L("Plugin \"%s\" requests filesystem read access to:\n%s"),
+                             wxString::FromUTF8(descriptor.name.c_str()), requested_paths),
+            _L("Plugin permissions"),
+            wxYES_NO | wxICON_WARNING);
+        return dialog.ShowModal() == wxID_YES;
+    };
+
+    bool granted = false;
+    if (wxIsMainThread()) {
+        granted = show_dialog();
+    } else {
+        auto result = std::make_shared<std::promise<bool>>();
+        auto future = result->get_future();
+        GUI::wxGetApp().CallAfter([result, descriptor_name = descriptor.name, missing]() {
+            wxString requested_paths;
+            for (const std::string& path : missing)
+                requested_paths += wxString::FromUTF8(path.c_str()) + "\n";
+
+            wxMessageDialog dialog(
+                nullptr,
+                wxString::Format(_L("Plugin \"%s\" requests filesystem read access to:\n%s"),
+                                 wxString::FromUTF8(descriptor_name.c_str()), requested_paths),
+                _L("Plugin permissions"),
+                wxYES_NO | wxICON_WARNING);
+            result->set_value(dialog.ShowModal() == wxID_YES);
+        });
+        granted = future.get();
+    }
+
+    if (!granted)
+        return false;
+
+    if (state.plugin_name.empty()) {
+        state.installed_from    = descriptor.is_cloud_plugin() ? "cloud" : "local";
+        state.installed_version = !descriptor.installed_version.empty() ? descriptor.installed_version : descriptor.version;
+        state.plugin_name       = descriptor.name;
+        state.cloud_uuid        = descriptor.cloud_uuid();
+        state.enabled            = true;
+    }
 
     state.permissions.fs_read.insert(state.permissions.fs_read.end(), missing.begin(), missing.end());
     return write_install_state(boost::filesystem::path(descriptor.plugin_root), state);
 }
 
-bool PluginAuditManager::request_network_permissions(const std::string&              plugin_key,
-                                                      const std::vector<std::string>& urls)
-{
-    if (plugin_key.empty() || urls.empty())
-        return true;
-
-    PluginDescriptor descriptor;
-    if (!PluginManager::instance().try_get_plugin_descriptor(plugin_key, descriptor) || descriptor.plugin_root.empty())
-        return false;
-
-    // Reduce every request to scheme://host before comparing or persisting it, so a URL with a
-    // path or query cannot create a second grant for the same host.
-    std::vector<std::string> requested;
-    for (const std::string& url : urls) {
-        const std::string normalized = normalize_network_url(url);
-        if (normalized.empty()) {
-            BOOST_LOG_TRIVIAL(warning) << "[AUDIT] Invalid network permission request for plugin " << plugin_key << ": " << url;
-            return false;
-        }
-        if (std::find(requested.begin(), requested.end(), normalized) == requested.end())
-            requested.push_back(normalized);
-    }
-
-    PluginInstallState state;
-    read_install_state(boost::filesystem::path(descriptor.plugin_root), state);
-
-    std::vector<std::string> missing;
-    for (const std::string& entry : requested) {
-        if (!network_permission_matches(state.permissions.network_http, entry) &&
-            !network_permission_matches(state.permissions.network_socket, entry))
-            missing.push_back(entry);
-    }
-    if (missing.empty())
-        return true;
-
-    wxString requested_hosts;
-    for (const std::string& entry : missing)
-        requested_hosts += wxString::FromUTF8(entry.c_str()) + "\n";
-
-    if (!ask_permission(wxString::Format(_L("Plugin \"%s\" requests network access to:\n%s"),
-                                        wxString::FromUTF8(descriptor.name.c_str()), requested_hosts)))
-        return false;
-
-    seed_install_metadata(state, descriptor);
-
-    // A declared host is reachable through both HTTP and raw socket events. Recording the grant in
-    // both existing lists keeps the sidecar self-describing and means either event layer matches
-    // it without relying on the other list.
-    for (const std::string& entry : missing) {
-        if (std::find(state.permissions.network_http.begin(), state.permissions.network_http.end(), entry) ==
-            state.permissions.network_http.end())
-            state.permissions.network_http.push_back(entry);
-        if (std::find(state.permissions.network_socket.begin(), state.permissions.network_socket.end(), entry) ==
-            state.permissions.network_socket.end())
-            state.permissions.network_socket.push_back(entry);
-    }
-
-    return write_install_state(boost::filesystem::path(descriptor.plugin_root), state);
-}
-
 void PluginAuditManager::report_violation(const AuditViolation& violation)
 {
     m_last_violation     = violation;
@@ -833,38 +577,13 @@ bool PluginAuditManager::last_violation(AuditViolation& violation) const
 
 bool PluginAuditManager::has_approved_ancestor(const std::string&              plugin_key,
                                                const std::vector<std::string>& call_site_ids) const
-{
-    return has_call_site(m_approved_call_sites, plugin_key, call_site_ids);
-}
-
-void PluginAuditManager::record_approved_call_sites(const std::string&              plugin_key,
-                                                     const std::vector<std::string>& call_site_ids)
-{
-    record_call_sites(m_approved_call_sites, plugin_key, call_site_ids);
-}
-
-bool PluginAuditManager::has_approved_network_ancestor(const std::string&              plugin_key,
-                                                        const std::vector<std::string>& call_site_ids) const
-{
-    return has_call_site(m_approved_network_call_sites, plugin_key, call_site_ids);
-}
-
-void PluginAuditManager::record_approved_network_call_sites(const std::string&              plugin_key,
-                                                             const std::vector<std::string>& call_site_ids)
-{
-    record_call_sites(m_approved_network_call_sites, plugin_key, call_site_ids);
-}
-
-bool PluginAuditManager::has_call_site(const CallSiteRegistry&         registry,
-                                       const std::string&              plugin_key,
-                                       const std::vector<std::string>& call_site_ids) const
 {
     if (plugin_key.empty() || call_site_ids.empty())
         return false;
 
     std::lock_guard<std::mutex> lock(m_mutex);
-    auto it = registry.find(plugin_key);
+    auto it = m_approved_call_sites.find(plugin_key);
-    if (it == registry.end())
+    if (it == m_approved_call_sites.end())
         return false;
 
     for (const auto& id : call_site_ids)
@@ -873,15 +592,14 @@ bool PluginAuditManager::has_call_site(const CallSiteRegistry&         registry,
     return false;
 }
 
-void PluginAuditManager::record_call_sites(CallSiteRegistry&               registry,
+void PluginAuditManager::record_approved_call_sites(const std::string&              plugin_key,
-                                           const std::string&              plugin_key,
+                                                     const std::vector<std::string>& call_site_ids)
-                                           const std::vector<std::string>& call_site_ids)
 {
     if (plugin_key.empty() || call_site_ids.empty())
         return;
 
     std::lock_guard<std::mutex> lock(m_mutex);
-    auto& approved = registry[plugin_key];
+    auto& approved = m_approved_call_sites[plugin_key];
     approved.insert(call_site_ids.begin(), call_site_ids.end());
 }
 
@@ -898,39 +616,6 @@ PyObject* tuple_item(PyObject* args, Py_ssize_t index)
     return PyTuple_GET_ITEM(args, index);
 }
 
-std::string python_unicode(PyObject* object)
-{
-    if (!object || !PyUnicode_Check(object))
-        return {};
-    const char* text = PyUnicode_AsUTF8(object);
-    if (!text) {
-        PyErr_Clear();
-        return {};
-    }
-    return text;
-}
-
-// Converts a str/bytes leaf to text, clearing a failed conversion. Returns false when `object` is
-// neither str nor bytes, so callers can apply their own fallback.
-bool python_text(PyObject* object, std::string& out)
-{
-    if (PyUnicode_Check(object)) {
-        out = python_unicode(object);
-        return true;
-    }
-    if (PyBytes_Check(object)) {
-        const char* value = PyBytes_AsString(object);
-        if (!value) {
-            PyErr_Clear();
-            out.clear();
-            return true;
-        }
-        out = value;
-        return true;
-    }
-    return false;
-}
-
 std::string python_path(PyObject* object)
 {
     if (!object)
@@ -942,12 +627,26 @@ std::string python_path(PyObject* object)
         return {};
     }
 
-    std::string result;
+    const char* path = PyUnicode_Check(path_object) ? PyUnicode_AsUTF8(path_object) : PyBytes_AsString(path_object);
-    python_text(path_object, result);
+    std::string result = path ? path : "";
     Py_DECREF(path_object);
+    if (!path)
+        PyErr_Clear();
     return result;
 }
 
+std::string python_unicode(PyObject* object)
+{
+    if (!object || !PyUnicode_Check(object))
+        return {};
+    const char* text = PyUnicode_AsUTF8(object);
+    if (!text) {
+        PyErr_Clear();
+        return {};
+    }
+    return text;
+}
+
 std::string python_str(PyObject* object)
 {
     if (!object)
@@ -964,27 +663,6 @@ std::string python_str(PyObject* object)
     return result;
 }
 
-// Network audit events expose different shapes for the same thing: a URL, a bare host, or an
-// address tuple such as ("host", 443). Reduce the argument to the host it names, leaving the
-// scheme and port to be judged by the permission matcher. None / an empty tuple has no target.
-std::string python_network_host(PyObject* object)
-{
-    if (!object || object == Py_None)
-        return {};
-
-    if (PyTuple_Check(object)) {
-        if (PyTuple_GET_SIZE(object) == 0)
-            return {};
-        return python_network_host(PyTuple_GET_ITEM(object, 0));
-    }
-
-    std::string text;
-    if (python_text(object, text))
-        return text;
-
-    return python_str(object);
-}
-
 std::vector<std::string> call_site_identities(const std::string& plugin_root)
 {
     std::vector<std::string> ids;
@@ -1088,10 +766,8 @@ std::vector<std::string> audit_targets(const std::string& event_name, AuditEvent
 
     const auto it = audit_target_arg_indices.find(event_name);
     if (it != audit_target_arg_indices.end()) {
-        const bool network_event = is_network_category(category);
         for (const Py_ssize_t index : it->second) {
-            std::string value = network_event ? python_network_host(tuple_item(args, index))
+            std::string value = python_str(tuple_item(args, index));
-                                              : python_str(tuple_item(args, index));
             if (!value.empty()) {
                 targets.push_back(std::move(value));
                 break;
@@ -1121,20 +797,6 @@ bool has_permission(const std::vector<std::string>& granted, const std::string&
     return std::find(granted.begin(), granted.end(), target) != granted.end();
 }
 
-// A declared or previously approved network grant may live in either network list: an HTTP grant
-// covers the sockets the same request opens, and a raw socket grant covers a later HTTP call to
-// the same host.
-bool has_network_permission(const PluginPermissions& permissions, const std::string& target)
-{
-    return PluginAuditManager::network_permission_matches(permissions.network_http, target) ||
-           PluginAuditManager::network_permission_matches(permissions.network_socket, target);
-}
-
-bool has_any_network_permission(const PluginPermissions& permissions)
-{
-    return !permissions.network_http.empty() || !permissions.network_socket.empty();
-}
-
 bool persist_permission(const std::string&        plugin_key,
                         PluginInstallState&       state,
                         std::vector<std::string>& permission_list,
@@ -1144,7 +806,15 @@ bool persist_permission(const std::string&        plugin_key,
     if (!PluginManager::instance().try_get_plugin_descriptor(plugin_key, descriptor) || descriptor.plugin_root.empty())
         return false;
 
-    seed_install_metadata(state, descriptor);
+    // A sandbox plugin may not have a sidecar yet.  Seed the small amount of install metadata
+    // needed by the writer so clicking Yes still creates the JSON file.
+    if (state.plugin_name.empty()) {
+        state.installed_from    = descriptor.is_cloud_plugin() ? "cloud" : "local";
+        state.installed_version = !descriptor.installed_version.empty() ? descriptor.installed_version : descriptor.version;
+        state.plugin_name       = descriptor.name;
+        state.cloud_uuid        = descriptor.cloud_uuid();
+        state.enabled            = true;
+    }
 
     if (!has_permission(permission_list, target))
         permission_list.push_back(target);
@@ -1223,10 +893,11 @@ bool prompt_for_targets(AuditEventCategory category, const std::string& plugin_n
     for (const auto& target : unresolved)
         target_list += wxString::FromUTF8(target.c_str()) + "\n";
 
-    return show_permission_dialog(
+    wxMessageDialog dialog(nullptr,
-        audit_message(category, wxString::FromUTF8(plugin_name.c_str()), wxString::FromUTF8(event_name.c_str()),
+                           audit_message(category, wxString::FromUTF8(plugin_name.c_str()),
-                      target_list, unresolved.size()),
+                                        wxString::FromUTF8(event_name.c_str()), target_list, unresolved.size()),
-        _L("Plugin permission request"));
+                           _L("Plugin permission request"), wxYES_NO | wxICON_WARNING);
+    return dialog.ShowModal() == wxID_YES;
 }
 
 // Records a grant in the plugin's sidecar so it is not asked again. Reads the install state
@@ -1286,30 +957,7 @@ int decide_audited_event(PluginAuditManager&             mgr,
                          const std::vector<std::string>&   call_site_ids)
 {
     std::vector<std::string> unresolved = targets;
-    if (is_network_category(category)) {
+    if (permission_list) {
-        if (targets.empty()) {
-            // socket.__new__ and http.client.send carry no host. Any network grant already lets
-            // the plugin open a connection, and every host-bearing event still matches its own
-            // grant, so the targetless events are covered by an existing grant instead of
-            // prompting every run. Deliberately do not record a call site here: a targetless
-            // approval must not become an ancestor that later network events could use to skip
-            // their own host check.
-            if (has_any_network_permission(state.permissions))
-                return 0;
-        } else {
-            unresolved.clear();
-            for (const auto& target : targets)
-                if (!has_network_permission(state.permissions, target))
-                    unresolved.push_back(target);
-            if (unresolved.empty()) {
-                // Remember the stdlib frames for this approved host. The network ancestor cache
-                // is only consulted for a resolved-IP socket.connect/sendto, so this cannot
-                // suppress a later hostname or URL event.
-                mgr.record_approved_network_call_sites(plugin_key, call_site_ids);
-                return 0;
-            }
-        }
-    } else if (permission_list) {
         unresolved.clear();
         for (const auto& target : targets)
             if (!has_permission(*permission_list, target))
@@ -1325,12 +973,6 @@ int decide_audited_event(PluginAuditManager&             mgr,
         for (const auto& target : unresolved)
             persist_permission(plugin_key, state, *permission_list, target);
 
-    // A target-bearing network approval may cover the resolved address of the same connection.
-    // A targetless approval does not: it carries no host, so it must not create an ancestor that
-    // a later hostname/URL check could be skipped by (and the network cache is IP-only anyway).
-    if (is_network_category(category) && !targets.empty())
-        mgr.record_approved_network_call_sites(plugin_key, call_site_ids);
-
     mgr.record_approved_call_sites(plugin_key, call_site_ids);
     return 0;
 }
@@ -1382,28 +1024,12 @@ int PluginAuditManager::audit_hook(const char* event, PyObject* args, void* user
     PluginDescriptor plugin_descriptor;
     PluginManager::instance().try_get_plugin_descriptor(mgr->current_plugin(), plugin_descriptor);
 
-    // Some plugins call other audited events, e.g. urllib.request will call socket.connect.
+    // Some plugins call other audited events, e.g. urlib.request will call socket.connect. So this is so that if urlib.request
-    // Collect the stdlib frames now so an approved network host can cover the resolved address
+    // was already approved, socket.connect won't trigger another permission dialog.
-    // of the same connection without covering another host.
     const std::vector<std::string> call_site_ids =
         PluginAuditDetail::call_site_identities(plugin_descriptor.plugin_root);
-
+    if (mgr->has_approved_ancestor(mgr->current_plugin(), call_site_ids))
-    // A general call-site approval may cover nested events for the same logical action. Network
-    // events use a separate rule: a hostname/URL target must match its own grant even when a
-    // parent event was approved, and targetless events are handled by the any-grant rule. Only a
-    // resolved-address connect/sendto (target is an IP literal) may use an approval recorded for
-    // an earlier network host event, because its own target carries no hostname to match.
-    if (is_network_category(event_type)) {
-        const bool all_resolved_addresses =
-            !targets.empty() && std::all_of(targets.begin(), targets.end(), [](const std::string& target) {
-                return PluginAuditManager::is_ip_address_target(target);
-            });
-        if (is_resolved_address_event(event_name) && all_resolved_addresses &&
-            mgr->has_approved_network_ancestor(mgr->current_plugin(), call_site_ids))
-            return 0;
-    } else if (mgr->has_approved_ancestor(mgr->current_plugin(), call_site_ids)) {
         return 0;
-    }
 
     // A filesystem target that resolves entirely inside a pre-determined allowed root -- the
     // plugin system's own data_dir() tree (which holds each plugin's storage folder and the

src/slic3r/plugin/PluginAuditManager.hpp

@@ -138,33 +138,6 @@ public:
     bool request_filesystem_read_permissions(const std::string& plugin_key,
                                              const std::vector<std::string>& paths);
 
-    // Ask the user to grant network access to the given http(s) URLs. Each URL is reduced to its
-    // scheme and host before prompting and persisting, so one approval covers every path, query
-    // and port on that host. The grant is written to both network_http and network_socket: the
-    // same declared host can surface through HTTP events (urllib/http.client) and raw socket
-    // events. Like request_filesystem_read_permissions, the request may originate on a plugin
-    // load worker; denial aborts the plugin load without adding a permission.
-    bool request_network_permissions(const std::string& plugin_key,
-                                     const std::vector<std::string>& urls);
-
-    // Canonical scheme://host form used to store and match network permissions. Returns an empty
-    // string unless `url` is an absolute http(s) URL with a host. The path, query, fragment,
-    // userinfo and port are discarded; scheme and host are lowercased.
-    static std::string normalize_network_url(const std::string& url);
-
-    // True when a granted scheme://host entry covers `target`. `target` is a URL (urllib.Request),
-    // a bare host (http.client.connect, socket.getaddrinfo) or an address as exposed by the audit
-    // event (a hostname, a host:port pair, or a legacy persisted tuple such as "('host', 443)").
-    // URL targets must match both scheme and host. A bare host carries no scheme, so it matches
-    // the host part of any grant; it never matches a different host.
-    static bool network_permission_matches(const std::vector<std::string>& granted,
-                                           const std::string& target);
-
-    // True when `target` is a bare IPv4/IPv6 literal (optionally bracketed). A network event
-    // carrying an IP literal has no hostname the audit hook can match, so it is the only kind of
-    // network event allowed to use an approved network call-site ancestor.
-    static bool is_ip_address_target(const std::string& target);
-
     void report_violation(const AuditViolation& violation);
     bool audit_denial_pending() const;
     void clear_audit_denial();
@@ -178,20 +151,9 @@ public:
     // is recorded here by (filename, function, first line) identity. A later event whose own
     // ancestor chain still contains one of those frames is the same logical action seen from
     // a deeper layer, so it is auto-approved instead of prompting again.
-    //
-    // Network events do not use this general cache: see the network call-site cache below.
     bool has_approved_ancestor(const std::string& plugin_key, const std::vector<std::string>& call_site_ids) const;
     void record_approved_call_sites(const std::string& plugin_key, const std::vector<std::string>& call_site_ids);
 
-    // --- network call-site cache ---
-    // Separate from the general cascade above so a network approval can only suppress a later
-    // network event with no hostname to check: a resolved address (socket.connect/sendto with an
-    // IP literal). Hostname and URL events are never auto-approved by an ancestor; they must
-    // match their own grant. Targetless events are handled by the "any network grant" rule and
-    // never record an entry here.
-    bool has_approved_network_ancestor(const std::string& plugin_key, const std::vector<std::string>& call_site_ids) const;
-    void record_approved_network_call_sites(const std::string& plugin_key, const std::vector<std::string>& call_site_ids);
-
     bool verbose_events = true;
 
 private:
@@ -208,23 +170,12 @@ private:
     static thread_local bool                           m_has_last_violation;
     static thread_local AuditViolation                 m_last_violation;
 
-    // mutable: the deny and ancestor queries are const but must lock.
+    // mutable: is_denied_filename() and has_approved_ancestor() are const queries that must lock.
     mutable std::mutex m_mutex;
-
-    using CallSiteRegistry = std::unordered_map<std::string, std::unordered_set<std::string>>;
-
-    // Shared lookup/insert mechanics for the two registries below. The caller selects the
-    // registry, so the general and network approvals remain independent.
-    bool has_call_site(const CallSiteRegistry& registry, const std::string& plugin_key,
-                       const std::vector<std::string>& call_site_ids) const;
-    void record_call_sites(CallSiteRegistry& registry, const std::string& plugin_key,
-                           const std::vector<std::string>& call_site_ids);
-
     std::vector<AllowedRoot>             m_global_allowed_roots;
     std::vector<std::string>             m_denied_filenames;
     std::vector<std::string>             m_denied_path_keywords;
-    CallSiteRegistry                     m_approved_call_sites;
+    std::unordered_map<std::string, std::unordered_set<std::string>> m_approved_call_sites; // plugin_key -> call-site ids
-    CallSiteRegistry                     m_approved_network_call_sites;
 };
 
 // RAII guard that sets the current plugin key and capability name, restoring the previous

src/slic3r/plugin/PluginFsUtils.cpp

@@ -832,29 +832,6 @@ bool read_install_state(const boost::filesystem::path& plugin_dir, PluginInstall
     }
 }
 
-namespace {
-
-// The single descriptor -> sidecar metadata mapping. Prefer installed_version (fetched at install
-// time and preserved across rewrites) over a possibly stale manifest version.
-void apply_install_metadata(PluginInstallState& state, const PluginDescriptor& entry)
-{
-    state.installed_from    = entry.is_cloud_plugin() ? "cloud" : "local";
-    state.installed_version = !entry.installed_version.empty() ? entry.installed_version : entry.version;
-    state.plugin_name       = entry.name;
-    state.cloud_uuid        = entry.cloud_uuid();
-}
-
-} // namespace
-
-void seed_install_metadata(PluginInstallState& state, const PluginDescriptor& entry)
-{
-    if (!state.plugin_name.empty())
-        return;
-
-    apply_install_metadata(state, entry);
-    state.enabled = true;
-}
-
 bool write_install_state(const boost::filesystem::path& plugin_dir, const PluginInstallState& state)
 {
     namespace fs                = boost::filesystem;
@@ -897,9 +874,16 @@ bool write_install_state(const boost::filesystem::path& plugin_dir, const Plugin
     // Loading a plugin updates its lifecycle/capability state, but must retain permissions granted
     // during register_capabilities() or by a previous runtime audit prompt.
     read_install_state(plugin_dir, state);
-    apply_install_metadata(state, entry);
+    state.installed_from    = entry.is_cloud_plugin() ? "cloud" : "local";
-    state.enabled      = enabled;
+    // Prefer the descriptor's recorded installed_version (the version fetched from the cloud
-    state.capabilities = capabilities;
+    // at install time, preserved across sidecar re-writes) so a stale manifest/PEP723 header
+    // never overwrites the source-of-truth version. Fall back to the manifest version for
+    // first-time/local installs where installed_version is not yet populated.
+    state.installed_version = !entry.installed_version.empty() ? entry.installed_version : entry.version;
+    state.plugin_name       = entry.name;
+    state.cloud_uuid        = entry.cloud_uuid();
+    state.enabled           = enabled;
+    state.capabilities      = capabilities;
     return write_install_state(plugin_dir, state);
 }
 
@@ -910,7 +894,11 @@ bool write_install_state(const boost::filesystem::path& plugin_dir, const Plugin
     // permissions on a fresh install/reinstall. PluginManager writes the real per-capability flags
     // while preserving permissions once the package is loaded, via the overload above.
     PluginInstallState state;
-    seed_install_metadata(state, entry);
+    state.installed_from    = entry.is_cloud_plugin() ? "cloud" : "local";
+    state.installed_version = !entry.installed_version.empty() ? entry.installed_version : entry.version;
+    state.plugin_name       = entry.name;
+    state.cloud_uuid        = entry.cloud_uuid();
+    state.enabled           = true;
     return write_install_state(plugin_dir, state);
 }
 

src/slic3r/plugin/PluginFsUtils.hpp

@@ -184,19 +184,12 @@ std::vector<std::string> collect_resource_texture_files(const std::string& dir,
 
 // Canonical writer: emits the .install_state.json schema for the given state.
 bool write_install_state(const boost::filesystem::path& plugin_dir, const PluginInstallState& state);
-
 // Builds a PluginInstallState from the descriptor and delegates to the canonical writer.
 bool write_install_state(const boost::filesystem::path& plugin_dir, const PluginDescriptor& entry, bool enabled,
                          const std::vector<std::pair<std::string, bool>>& capabilities);
 // Convenience overload: write(dir, entry, /*enabled=*/true, /*capabilities=*/{}).
 bool write_install_state(const boost::filesystem::path& plugin_dir, const PluginDescriptor& entry);
 
-// Fill the descriptor-derived install metadata into a sidecar state that does not describe an
-// installed plugin yet, and mark it enabled. Leaves permissions and capabilities untouched.
-// Single source for the metadata mapping used by the install writer and by the audit prompt path
-// that creates a sidecar on demand.
-void seed_install_metadata(PluginInstallState& state, const PluginDescriptor& entry);
-
 // Reads install state back into the descriptor; plugin_key is always derived. Returns whether the
 // sidecar was present and valid.
 bool read_install_state(const boost::filesystem::path& plugin_dir, PluginDescriptor& entry);

src/slic3r/plugin/PluginManager.cpp

@@ -1180,8 +1180,12 @@ void PluginManager::mark_plugin_install_state_disabled(const std::string& plugin
 
     const boost::filesystem::path root(descriptor.plugin_root);
     PluginInstallState state;
-    if (!read_install_state(root, state))
+    if (!read_install_state(root, state)) {
-        seed_install_metadata(state, descriptor);
+        state.installed_from    = descriptor.is_cloud_plugin() ? "cloud" : "local";
+        state.installed_version = !descriptor.installed_version.empty() ? descriptor.installed_version : descriptor.version;
+        state.plugin_name       = descriptor.name;
+        state.cloud_uuid        = descriptor.cloud_uuid();
+    }
     state.enabled = false;
     if (!write_install_state(root, state))
         return;

src/slic3r/plugin/PythonPluginBridge.cpp

@@ -50,7 +50,6 @@ std::mutex g_registry_mutex;
 std::unordered_map<std::string, std::vector<py::object>> g_pending_capabilities;
 std::unordered_map<std::string, py::object> g_pending_package;
 std::unordered_map<std::string, std::vector<std::string>> g_pending_fs_read_permissions;
-std::unordered_map<std::string, std::vector<std::string>> g_pending_network_permissions;
 struct PluginInstanceHandle
 {
     // The C++ plugin interface points into a Python object. Keep both alive through one
@@ -90,7 +89,6 @@ void discard_pending_capture_without_python(const std::string& plugin_key)
     }
 
     g_pending_fs_read_permissions.erase(plugin_key);
-    g_pending_network_permissions.erase(plugin_key);
 }
 
 } // namespace
@@ -116,7 +114,6 @@ void PythonPluginBridge::begin_plugin_capture(const std::string& plugin_key)
         g_pending_capabilities.erase(plugin_key);
         g_pending_package.erase(plugin_key);
         g_pending_fs_read_permissions.erase(plugin_key);
-        g_pending_network_permissions.erase(plugin_key);
     }
     // From now until finalize/cancel, @orca.plugin and register_capability() calls made by
     // Python code on this thread are attributed to this plugin.
@@ -148,7 +145,6 @@ std::vector<CapturedCapability> PythonPluginBridge::finalize_plugin_capture(cons
             g_pending_capabilities.erase(capture_key);
             g_pending_package.erase(capture_key);
             g_pending_fs_read_permissions.erase(capture_key);
-            g_pending_network_permissions.erase(capture_key);
         };
 
         try {
@@ -204,30 +200,6 @@ std::vector<CapturedCapability> PythonPluginBridge::finalize_plugin_capture(cons
                     return {};
                 }
             }
-
-            std::vector<std::string> network_permissions;
-            {
-                std::lock_guard<std::mutex> lock(g_registry_mutex);
-                auto it = g_pending_network_permissions.find(capture_key);
-                if (it != g_pending_network_permissions.end()) {
-                    network_permissions = std::move(it->second);
-                    g_pending_network_permissions.erase(it);
-                }
-            }
-            if (!network_permissions.empty()) {
-                bool granted = false;
-                {
-                    py::gil_scoped_release release;
-                    granted = PluginAuditManager::instance().request_network_permissions(plugin_key, network_permissions);
-                }
-                if (!granted) {
-                    error = _u8L("Plugin network permission request denied");
-                    BOOST_LOG_TRIVIAL(warning) << error << " for key " << plugin_key;
-                    discard_pending_for_key();
-                    clear_active_key();
-                    return {};
-                }
-            }
         } catch (py::error_already_set& err) {
             log_python_exception_keep(err);
             error = err.what();
@@ -351,7 +323,6 @@ void PythonPluginBridge::cancel_plugin_capture(const std::string& plugin_key)
         g_pending_capabilities.erase(plugin_key);
         g_pending_package.erase(plugin_key);
         g_pending_fs_read_permissions.erase(plugin_key);
-        g_pending_network_permissions.erase(plugin_key);
     }
 
     if (g_active_plugin_key == plugin_key)
@@ -379,7 +350,6 @@ void PythonPluginBridge::clear_pending_captures()
         }
         g_pending_package.clear();
         g_pending_fs_read_permissions.clear();
-        g_pending_network_permissions.clear();
         g_active_plugin_key.clear();
         return;
     }
@@ -389,7 +359,6 @@ void PythonPluginBridge::clear_pending_captures()
     g_pending_capabilities.clear();
     g_pending_package.clear();
     g_pending_fs_read_permissions.clear();
-    g_pending_network_permissions.clear();
     g_active_plugin_key.clear();
 }
 
@@ -589,50 +558,24 @@ void bind_python_api(pybind11::module_& m)
 
     m.def(
         "request_permissions",
-        [](const std::vector<std::string>& fs_read, const std::vector<std::string>& network) {
+        [](const std::vector<std::string>& fs_read) {
             if (g_active_plugin_key.empty())
                 throw py::value_error("request_permissions() called outside plugin discovery context");
 
-            // Validate and canonicalize everything before touching the pending registry, so a
+            std::lock_guard<std::mutex> lock(g_registry_mutex);
-            // partially invalid call cannot leave a half-recorded request behind.
+            auto& requested = g_pending_fs_read_permissions[g_active_plugin_key];
-            std::vector<std::string> normalized_network;
-            normalized_network.reserve(network.size());
-            for (const std::string& url : network) {
-                const std::string normalized = PluginAuditManager::normalize_network_url(url);
-                if (normalized.empty())
-                    throw py::value_error(
-                        "request_permissions(network=...) requires an http:// or https:// URL with a host");
-                if (std::find(normalized_network.begin(), normalized_network.end(), normalized) == normalized_network.end())
-                    normalized_network.push_back(normalized);
-            }
-
             for (const std::string& path : fs_read) {
                 if (path.empty())
                     throw py::value_error("request_permissions(fs_read=...) does not accept empty paths");
-            }
+                if (std::find(requested.begin(), requested.end(), path) == requested.end())
-
+                    requested.push_back(path);
-            std::lock_guard<std::mutex> lock(g_registry_mutex);
-            auto& requested_fs = g_pending_fs_read_permissions[g_active_plugin_key];
-            for (const std::string& path : fs_read) {
-                if (std::find(requested_fs.begin(), requested_fs.end(), path) == requested_fs.end())
-                    requested_fs.push_back(path);
-            }
-
-            if (!normalized_network.empty()) {
-                auto& requested_network = g_pending_network_permissions[g_active_plugin_key];
-                for (const std::string& entry : normalized_network) {
-                    if (std::find(requested_network.begin(), requested_network.end(), entry) == requested_network.end())
-                        requested_network.push_back(entry);
-                }
             }
         },
-        py::arg("fs_read") = std::vector<std::string>{}, py::arg("network") = std::vector<std::string>{},
+        py::arg("fs_read") = std::vector<std::string>{},
-        R"pbdoc(Request permissions while OrcaSlicer loads your module.
+        R"pbdoc(Request filesystem read permissions while OrcaSlicer loads your module.
 
-`fs_read` lists filesystem paths to read. `network` lists http(s) URLs; each is reduced to its
+The host presents the request to the user after register_capabilities() returns. Denying the
-scheme and host, so one grant covers every path, query and port on that host. The host presents
+request aborts the plugin load.)pbdoc");
-the requests to the user after register_capabilities() returns. Denying a request aborts the
-plugin load.)pbdoc");
 
     m.def("plugin", [](py::object cls) {
         if (g_active_plugin_key.empty())

tests/data/test_stl/ASCII/20mmbox-CR.stl

@@ -1 +0,0 @@
-solid STL generated by MeshLab␍  facet normal  0.000000e+00 -0.000000e+00 -1.000000e+00␍    outer loop␍      vertex   2.000000e+01  2.000000e+01  0.000000e+00␍      vertex   2.000000e+01  0.000000e+00  0.000000e+00␍      vertex   0.000000e+00  0.000000e+00  0.000000e+00␍    endloop␍  endfacet␍  facet normal -0.000000e+00  0.000000e+00 -1.000000e+00␍    outer loop␍      vertex   2.000000e+01  2.000000e+01  0.000000e+00␍      vertex   0.000000e+00  0.000000e+00  0.000000e+00␍      vertex   0.000000e+00  2.000000e+01  0.000000e+00␍    endloop␍  endfacet␍  facet normal  0.000000e+00  0.000000e+00  1.000000e+00␍    outer loop␍      vertex   2.000000e+01  2.000000e+01  2.000000e+01␍      vertex   0.000000e+00  2.000000e+01  2.000000e+01␍      vertex   0.000000e+00  0.000000e+00  2.000000e+01␍    endloop␍  endfacet␍  facet normal  0.000000e+00  0.000000e+00  1.000000e+00␍    outer loop␍      vertex   2.000000e+01  2.000000e+01  2.000000e+01␍      vertex   0.000000e+00  0.000000e+00  2.000000e+01␍      vertex   2.000000e+01  0.000000e+00  2.000000e+01␍    endloop␍  endfacet␍  facet normal  1.000000e+00  0.000000e+00 -0.000000e+00␍    outer loop␍      vertex   2.000000e+01  2.000000e+01  0.000000e+00␍      vertex   2.000000e+01  2.000000e+01  2.000000e+01␍      vertex   2.000000e+01  0.000000e+00  2.000000e+01␍    endloop␍  endfacet␍  facet normal  1.000000e+00  0.000000e+00  0.000000e+00␍    outer loop␍      vertex   2.000000e+01  2.000000e+01  0.000000e+00␍      vertex   2.000000e+01  0.000000e+00  2.000000e+01␍      vertex   2.000000e+01  0.000000e+00  0.000000e+00␍    endloop␍  endfacet␍  facet normal  0.000000e+00 -1.000000e+00  0.000000e+00␍    outer loop␍      vertex   2.000000e+01  0.000000e+00  0.000000e+00␍      vertex   2.000000e+01  0.000000e+00  2.000000e+01␍      vertex   0.000000e+00  0.000000e+00  2.000000e+01␍    endloop␍  endfacet␍  facet normal  0.000000e+00 -1.000000e+00  0.000000e+00␍    outer loop␍      vertex   2.000000e+01  0.000000e+00  0.000000e+00␍      vertex   0.000000e+00  0.000000e+00  2.000000e+01␍      vertex   0.000000e+00  0.000000e+00  0.000000e+00␍    endloop␍  endfacet␍  facet normal -1.000000e+00  0.000000e+00  0.000000e+00␍    outer loop␍      vertex   0.000000e+00  0.000000e+00  0.000000e+00␍      vertex   0.000000e+00  0.000000e+00  2.000000e+01␍      vertex   0.000000e+00  2.000000e+01  2.000000e+01␍    endloop␍  endfacet␍  facet normal -1.000000e+00  0.000000e+00  0.000000e+00␍    outer loop␍      vertex   0.000000e+00  0.000000e+00  0.000000e+00␍      vertex   0.000000e+00  2.000000e+01  2.000000e+01␍      vertex   0.000000e+00  2.000000e+01  0.000000e+00␍    endloop␍  endfacet␍  facet normal  0.000000e+00  1.000000e+00  0.000000e+00␍    outer loop␍      vertex   2.000000e+01  2.000000e+01  2.000000e+01␍      vertex   2.000000e+01  2.000000e+01  0.000000e+00␍      vertex   0.000000e+00  2.000000e+01  0.000000e+00␍    endloop␍  endfacet␍  facet normal  0.000000e+00  1.000000e+00  0.000000e+00␍    outer loop␍      vertex   2.000000e+01  2.000000e+01  2.000000e+01␍      vertex   0.000000e+00  2.000000e+01  0.000000e+00␍      vertex   0.000000e+00  2.000000e+01  2.000000e+01␍    endloop␍  endfacet␍endsolid vcg␍

tests/fff_print/test_fill.cpp

@@ -44,7 +44,6 @@
 #include "libslic3r/Layer.hpp"
 #include "libslic3r/Print.hpp"
 #include "libslic3r/PrintConfig.hpp"
-#include "libslic3r/SVG.hpp"
 #include "libslic3r/libslic3r.h"
 
 #include "test_helpers.hpp"
@@ -53,15 +52,6 @@ using namespace Slic3r;
 
 bool test_if_solid_surface_filled(const ExPolygon& expolygon, double flow_spacing, double angle = 0, double density = 1.0);
 
-#if 0
-TEST_CASE("Adjusted solid distance", "[Fill]") {
-    int surface_width = 250;
-    int distance = Slic3r::Flow::solid_spacing(surface_width, 47);
-    REQUIRE(distance == Catch::Approx(50));
-    REQUIRE(surface_width % distance == 0);
-}
-#endif
-
 TEST_CASE("Pattern path length", "[Fill]") {
     std::unique_ptr<Slic3r::Fill> filler(Slic3r::Fill::new_from_type("rectilinear"));
     filler->angle = float(-(PI)/2.0);
@@ -120,15 +110,6 @@ TEST_CASE("Pattern path length", "[Fill]") {
                 filler->angle = float(angle);
                 ExPolygon e(test_square, test_hole);
                 Slic3r::Polylines paths = test(e);
-#if 0
-				{
-					BoundingBox bbox = get_extents(e);
-					SVG svg("c:\\data\\temp\\square_with_holes.svg", bbox);
-					svg.draw(e);
-					svg.draw(paths);
-					svg.Close();
-				}
-#endif
                 REQUIRE((paths.size() >= 1 && paths.size() <= 3));
                 // paths don't cross hole
                 REQUIRE(diff_pl(paths, offset(e, float(SCALED_EPSILON*10))).size() == 0);
@@ -175,25 +156,6 @@ TEST_CASE("Pattern path length", "[Fill]") {
         }
     }
 
-    #if 0   // Disabled temporarily due to precision issues on the Mac VM
-    SECTION("Solid surface fill") {
-        Slic3r::Points points {
-            Point::new_scale(6883102, 9598327.01296997),
-            Point::new_scale(6883102, 20327272.01297),
-            Point::new_scale(3116896, 20327272.01297),
-            Point::new_scale(3116896, 9598327.01296997) 
-        };
-        Slic3r::ExPolygon expolygon(points);
-         
-        REQUIRE(test_if_solid_surface_filled(expolygon, 0.55) == true);
-        for (size_t i = 0; i <= 20; ++i)
-        {
-            expolygon.scale(1.05);
-            REQUIRE(test_if_solid_surface_filled(expolygon, 0.55) == true);
-        }
-    }
-    #endif
-
     SECTION("Solid surface fill") {
         Slic3r::Points points {
                 Slic3r::Point(59515297,5422499),Slic3r::Point(59531249,5578697),Slic3r::Point(59695801,6123186),
@@ -226,245 +188,6 @@ TEST_CASE("Pattern path length", "[Fill]") {
     }
 }
 
-/*
-{
-    my $collection = Slic3r::Polyline::Collection->new(
-            Slic3r::Polyline->new([0,15], [0,18], [0,20]),
-            Slic3r::Polyline->new([0,10], [0,8], [0,5]),
-            );
-    is_deeply
-        [ map $_->[Y], map @$_, @{$collection->chained_path_from(Slic3r::Point->new(0,30), 0)} ],
-        [20, 18, 15, 10, 8, 5],
-        'chained path';
-}
-
-{
-    my $collection = Slic3r::Polyline::Collection->new(
-            Slic3r::Polyline->new([4,0], [10,0], [15,0]),
-            Slic3r::Polyline->new([10,5], [15,5], [20,5]),
-            );
-    is_deeply
-        [ map $_->[X], map @$_, @{$collection->chained_path_from(Slic3r::Point->new(30,0), 0)} ],
-        [reverse 4, 10, 15, 10, 15, 20],
-        'chained path';
-}
-
-{
-    my $collection = Slic3r::ExtrusionPath::Collection->new(
-            map Slic3r::ExtrusionPath->new(polyline => $_, role => 0, mm3_per_mm => 1),
-            Slic3r::Polyline->new([0,15], [0,18], [0,20]),
-            Slic3r::Polyline->new([0,10], [0,8], [0,5]),
-            );
-    is_deeply
-        [ map $_->[Y], map @{$_->polyline}, @{$collection->chained_path_from(Slic3r::Point->new(0,30), 0)} ],
-        [20, 18, 15, 10, 8, 5],
-        'chained path';
-}
-
-{
-    my $collection = Slic3r::ExtrusionPath::Collection->new(
-            map Slic3r::ExtrusionPath->new(polyline => $_, role => 0, mm3_per_mm => 1),
-            Slic3r::Polyline->new([15,0], [10,0], [4,0]),
-            Slic3r::Polyline->new([10,5], [15,5], [20,5]),
-            );
-    is_deeply
-        [ map $_->[X], map @{$_->polyline}, @{$collection->chained_path_from(Slic3r::Point->new(30,0), 0)} ],
-        [reverse 4, 10, 15, 10, 15, 20],
-        'chained path';
-}
-
-for my $pattern (qw(rectilinear honeycomb hilbertcurve concentric)) {
-    my $config = Slic3r::Config->new_from_defaults;
-    $config->set('fill_pattern', $pattern);
-    $config->set('external_fill_pattern', $pattern);
-    $config->set('perimeters', 1);
-    $config->set('skirts', 0);
-    $config->set('fill_density', 20);
-    $config->set('layer_height', 0.05);
-    $config->set('perimeter_extruder', 1);
-    $config->set('infill_extruder', 2);
-    my $print = Slic3r::Test::init_print('20mm_cube', config => $config, scale => 2);
-    ok my $gcode = Slic3r::Test::gcode($print), "successful $pattern infill generation";
-    my $tool = undef;
-    my @perimeter_points = my @infill_points = ();
-    Slic3r::GCode::Reader->new->parse($gcode, sub {
-            my ($self, $cmd, $args, $info) = @_;
-
-            if ($cmd =~ /^T(\d+)/) {
-            $tool = $1;
-            } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) {
-            if ($tool == $config->perimeter_extruder-1) {
-            push @perimeter_points, Slic3r::Point->new_scale($args->{X}, $args->{Y});
-            } elsif ($tool == $config->infill_extruder-1) {
-            push @infill_points, Slic3r::Point->new_scale($args->{X}, $args->{Y});
-            }
-            }
-            });
-    my $convex_hull = convex_hull(\@perimeter_points);
-    ok !(defined first { !$convex_hull->contains_point($_) } @infill_points), "infill does not exceed perimeters ($pattern)";
-}
-
-{
-    my $config = Slic3r::Config->new_from_defaults;
-    $config->set('infill_only_where_needed', 1);
-    $config->set('bottom_solid_layers', 0);
-    $config->set('infill_extruder', 2);
-    $config->set('infill_extrusion_width', 0.5);
-    $config->set('fill_density', 40);
-    $config->set('cooling', 0);                 # for preventing speeds from being altered
-        $config->set('first_layer_speed', '100%');  # for preventing speeds from being altered
-
-        my $test = sub {
-            my $print = Slic3r::Test::init_print('pyramid', config => $config);
-
-            my $tool = undef;
-            my @infill_extrusions = ();  # array of polylines
-                Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
-                        my ($self, $cmd, $args, $info) = @_;
-
-                        if ($cmd =~ /^T(\d+)/) {
-                        $tool = $1;
-                        } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) {
-                        if ($tool == $config->infill_extruder-1) {
-                        push @infill_extrusions, Slic3r::Line->new_scale(
-                                [ $self->X, $self->Y ],
-                                [ $info->{new_X}, $info->{new_Y} ],
-                                );
-                        }
-                        }
-                        });
-            return 0 if !@infill_extrusions;  # prevent calling convex_hull() with no points
-
-                my $convex_hull = convex_hull([ map $_->pp, map @$_, @infill_extrusions ]);
-            return unscale unscale sum(map $_->area, @{offset([$convex_hull], scale(+$config->infill_extrusion_width/2))});
-        };
-
-    my $tolerance = 5;  # mm^2
-
-        $config->set('solid_infill_below_area', 0);
-    ok $test->() < $tolerance,
-       'no infill is generated when using infill_only_where_needed on a pyramid';
-
-    $config->set('solid_infill_below_area', 70);
-    ok abs($test->() - $config->solid_infill_below_area) < $tolerance,
-       'infill is only generated under the forced solid shells';
-}
-
-{
-    my $config = Slic3r::Config->new_from_defaults;
-    $config->set('skirts', 0);
-    $config->set('perimeters', 1);
-    $config->set('fill_density', 0);
-    $config->set('top_solid_layers', 0);
-    $config->set('bottom_solid_layers', 0);
-    $config->set('solid_infill_below_area', 20000000);
-    $config->set('solid_infill_every_layers', 2);
-    $config->set('perimeter_speed', 99);
-    $config->set('external_perimeter_speed', 99);
-    $config->set('cooling', 0);
-    $config->set('first_layer_speed', '100%');
-
-    my $print = Slic3r::Test::init_print('20mm_cube', config => $config);
-    my %layers_with_extrusion = ();
-    Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
-            my ($self, $cmd, $args, $info) = @_;
-
-            if ($cmd eq 'G1' && $info->{dist_XY} > 0 && $info->{extruding}) {
-            if (($args->{F} // $self->F) != $config->perimeter_speed*60) {
-            $layers_with_extrusion{$self->Z} = ($args->{F} // $self->F);
-            }
-            }
-            });
-
-    ok !%layers_with_extrusion,
-       "solid_infill_below_area and solid_infill_every_layers are ignored when fill_density is 0";
-}
-
-{
-    my $config = Slic3r::Config->new_from_defaults;
-    $config->set('skirts', 0);
-    $config->set('perimeters', 3);
-    $config->set('fill_density', 0);
-    $config->set('layer_height', 0.2);
-    $config->set('first_layer_height', 0.2);
-    $config->set('nozzle_diameter', [0.35]);
-    $config->set('infill_extruder', 2);
-    $config->set('solid_infill_extruder', 2);
-    $config->set('infill_extrusion_width', 0.52);
-    $config->set('solid_infill_extrusion_width', 0.52);
-    $config->set('first_layer_extrusion_width', 0);
-
-    my $print = Slic3r::Test::init_print('A', config => $config);
-    my %infill = ();  # Z => [ Line, Line ... ]
-        my $tool = undef;
-    Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
-            my ($self, $cmd, $args, $info) = @_;
-
-            if ($cmd =~ /^T(\d+)/) {
-            $tool = $1;
-            } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) {
-            if ($tool == $config->infill_extruder-1) {
-            my $z = 1 * $self->Z;
-            $infill{$z} ||= [];
-            push @{$infill{$z}}, Slic3r::Line->new_scale(
-                    [ $self->X, $self->Y ],
-                    [ $info->{new_X}, $info->{new_Y} ],
-                    );
-            }
-            }
-            });
-    my $grow_d = scale($config->infill_extrusion_width)/2;
-    my $layer0_infill = union([ map @{$_->grow($grow_d)}, @{ $infill{0.2} } ]);
-    my $layer1_infill = union([ map @{$_->grow($grow_d)}, @{ $infill{0.4} } ]);
-    my $diff = diff($layer0_infill, $layer1_infill);
-    $diff = offset2_ex($diff, -$grow_d, +$grow_d);
-    $diff = [ grep { $_->area > 2*(($grow_d*2)**2) } @$diff ];
-    is scalar(@$diff), 0, 'no missing parts in solid shell when fill_density is 0';
-}
-
-{
-    # GH: #2697
-    my $config = Slic3r::Config->new_from_defaults;
-    $config->set('perimeter_extrusion_width', 0.72);
-    $config->set('top_infill_extrusion_width', 0.1);
-    $config->set('infill_extruder', 2);         # in order to distinguish infill
-        $config->set('solid_infill_extruder', 2);   # in order to distinguish infill
-
-        my $print = Slic3r::Test::init_print('20mm_cube', config => $config);
-    my %infill = ();  # Z => [ Line, Line ... ]
-        my %other  = ();  # Z => [ Line, Line ... ]
-        my $tool = undef;
-    Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
-            my ($self, $cmd, $args, $info) = @_;
-
-            if ($cmd =~ /^T(\d+)/) {
-            $tool = $1;
-            } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) {
-            my $z = 1 * $self->Z;
-            my $line = Slic3r::Line->new_scale(
-                    [ $self->X, $self->Y ],
-                    [ $info->{new_X}, $info->{new_Y} ],
-                    );
-            if ($tool == $config->infill_extruder-1) {
-            $infill{$z} //= [];
-            push @{$infill{$z}}, $line;
-            } else {
-            $other{$z} //= [];
-            push @{$other{$z}}, $line;
-            }
-            }
-            });
-    my $top_z = max(keys %infill);
-    my $top_infill_grow_d = scale($config->top_infill_extrusion_width)/2;
-    my $top_infill = union([ map @{$_->grow($top_infill_grow_d)}, @{ $infill{$top_z} } ]);
-    my $perimeters_grow_d = scale($config->perimeter_extrusion_width)/2;
-    my $perimeters = union([ map @{$_->grow($perimeters_grow_d)}, @{ $other{$top_z} } ]);
-    my $covered = union_ex([ @$top_infill, @$perimeters ]);
-    my @holes = map @{$_->holes}, @$covered;
-    ok sum(map unscale unscale $_->area*-1, @holes) < 1, 'no gaps between top solid infill and perimeters';
-}
-*/
-
 bool test_if_solid_surface_filled(const ExPolygon& expolygon, double flow_spacing, double angle, double density)
 {
     std::unique_ptr<Slic3r::Fill> filler(Slic3r::Fill::new_from_type("rectilinear"));
@@ -498,18 +221,6 @@ bool test_if_solid_surface_filled(const ExPolygon& expolygon, double flow_spacin
     const double scaled_flow_spacing = std::pow(scale_(flow_spacing), 2);
     uncovered.erase(std::remove_if(uncovered.begin(), uncovered.end(), [scaled_flow_spacing](const ExPolygon& poly) { return poly.area() < scaled_flow_spacing; }), uncovered.end());
 
-#if 0
-	if (! uncovered.empty()) {
-		BoundingBox bbox = get_extents(expolygon.contour);
-		bbox.merge(get_extents(uncovered));
-		bbox.merge(get_extents(grown_paths));
-		SVG svg("c:\\data\\temp\\test_if_solid_surface_filled.svg", bbox);
-		svg.draw(expolygon);
-		svg.draw(uncovered, "red");
-		svg.Close();
-	}
-#endif
-
     return uncovered.empty(); // solid surface is fully filled
 }
 

tests/fff_print/test_flow.cpp

@@ -58,23 +58,6 @@ SCENARIO("Flow math for non-bridges", "[Flow]") {
             }
         }
     }
-
-#if 0
-    /// Check for an edge case in the maths where the spacing could be 0; original
-    /// math is 0.99. Slic3r issue #4654
-    GIVEN("Input spacing of 0.414159 and a total width of 2") {
-        double in_spacing = 0.414159;
-        double total_width = 2.0;
-        auto flow = Flow::new_from_spacing(1.0, 0.4, 0.3);
-        WHEN("solid_spacing() is called") {
-            double result = flow.solid_spacing(total_width, in_spacing);
-            THEN("Yielded spacing is greater than 0") {
-                REQUIRE(result > 0);
-            }
-        }
-    }
-#endif    
-
 }
 
 /// Spacing, width calculation for bridge extrusions

tests/fff_print/test_gcodewriter.cpp

@@ -142,21 +142,6 @@ SCENARIO("z_hop lifts the nozzle when a lift is requested", "[GCodeWriter]") {
     }
 }
 
-SCENARIO("Origin manipulation", "[GCodeWriter]") {
-	Slic3r::GCode gcodegen;
-	WHEN("set_origin to (10,0)") {
-    	gcodegen.set_origin(Vec2d(10,0));
-    	REQUIRE(gcodegen.origin() == Vec2d(10, 0));
-    }
-	WHEN("set_origin to (10,0) and translate by (5, 5)") {
-		gcodegen.set_origin(Vec2d(10,0));
-		gcodegen.set_origin(gcodegen.origin() + Vec2d(5, 5));
-		THEN("origin returns reference to point") {
-    		REQUIRE(gcodegen.origin() == Vec2d(15,5));
-    	}
-    }
-}
-
 TEST_CASE("A cached config slot is looked up again whenever its key changes", "[GCodeWriter]")
 {
     GCode::ConfigIndexCache cache;

tests/fff_print/test_helpers.cpp

@@ -5,6 +5,7 @@
 #include "libslic3r/GCodeReader.hpp"
 #include "libslic3r/Config.hpp"
 #include "libslic3r/Print.hpp"
+#include "libslic3r/Model.hpp"
 
 #include <algorithm>
 #include <cstdlib>
@@ -502,27 +503,3 @@ std::vector<std::string> role_sequence(const std::string &gcode, const std::vect
 }
 
 } } // namespace Slic3r::Test
-
-#include <catch2/catch_all.hpp>
-#include "libslic3r/Arrange.hpp"
-#include "libslic3r/Model.hpp"
-
-SCENARIO("init_print functionality", "[test_helpers]") {
-	GIVEN("A default config") {
-		Slic3r::DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
-		WHEN("init_print is called with a single mesh.") {
-			Slic3r::Model model;
-			Slic3r::Print print;
-			Slic3r::Test::init_print({ Slic3r::Test::cube(20) }, print, model, config);
-			THEN("One mesh/printobject is in the resulting Print object.") {
-				REQUIRE(print.objects().size() == 1);
-			}
-			THEN("print.process() doesn't crash.") {
-				REQUIRE_NOTHROW(print.process());
-			}
-			THEN("Export gcode functions outputs text.") {
-				REQUIRE(! Slic3r::Test::gcode(print).empty());
-			}
-		}
-	}
-}

tests/fff_print/test_imex_mode_gcode.cpp

@@ -327,24 +327,6 @@ TEST_CASE("A printer with IMEX disabled resolves the mode placeholders to nothin
     CHECK_FALSE(has_line(gcode, kQuadScript));
 }
 
-// The placeholders are set unconditionally, ahead of the is_imex check, so they are defined for
-// every printer. A single-extruder preset that mentions {imex_mode} must expand it to an empty
-// string rather than fail the export on an unknown variable.
-TEST_CASE("IMEX mode placeholders are defined on an ordinary single-extruder printer",
-          "[ImexModeGcode][IMEX]")
-{
-    const std::string gcode = slice({ cube(20) }, {
-        { "skirt_loops",         "0" },
-        { "brim_type",           "no_brim" },
-        { "gcode_flavor",        "klipper" },
-        { "machine_start_gcode", kReportStartGcode },
-    });
-
-    CHECK(has_line(gcode, ";IMEX_MODE:"));
-    CHECK(has_line(gcode, ";IMEX_MODE_INDEX:0"));
-    CHECK(has_line(gcode, ";IMEX_MODE_GCODE:"));
-}
-
 // In a parallel mode no tool changes occur, so every active carriage has to be addressed
 // explicitly: once before the print for pressure advance, and again at the second layer for the
 // drop from the initial-layer temperature. Nothing else in the suite covers either emission, and

tests/fff_print/test_mixed_filament.cpp

@@ -66,21 +66,6 @@ void count_mixed(ToolOrdering &to, size_t &groups, size_t &resolutions)
 
 } // namespace
 
-TEST_CASE("enable_mixed_color_sublayer reaches the Print config", "[MixedFilament]")
-{
-    Print print;
-    Model model;
-    init_print({cube(20)}, print, model, mixed_config(true));
-
-    // The option lives in PrintConfig; if it did not survive Print::apply the slicer would
-    // silently fall back to the whole-layer path.
-    CHECK(print.config().enable_mixed_color_sublayer.value == true);
-    REQUIRE(print.config().filament_is_mixed.values.size() == 3);
-    CHECK(print.config().filament_is_mixed.values[2] == true);
-    REQUIRE(print.config().filament_mixed_components.values.size() == 3);
-    CHECK(print.config().filament_mixed_components.values[2] == "1,2");
-}
-
 TEST_CASE("Mixed filament splits layers into sub-layers when the option is on", "[MixedFilament]")
 {
     Print print;

tests/fff_print/test_multifilament.cpp

@@ -840,32 +840,6 @@ static void all_regions_on_filament(DynamicPrintConfig &config, int filament_1ba
         config.set_deserialize_strict({ { key, std::to_string(filament_1based) } });
 }
 
-// IMEX parallel modes emit per-carriage temperatures from a branch that is mutually
-// exclusive with the standard per-extruder path, and that branch skipped the head the
-// print's own toolpaths run on. That head therefore never received its 1st->2nd layer
-// transition and held nozzle_temperature_initial_layer for the whole job.
-TEST_CASE("Parallel-mode IMEX prints transition the printing head to its second-layer temperature",
-          "[MultiFilament][IMEX]")
-{
-    DynamicPrintConfig config = multifilament_config(7);
-    imex_7x4_printer(config);
-    all_regions_on_filament(config, 1); // filament 1 => logical slot 0 => physical head 0
-    // The multi-extruder normalization collapses per-filament temperature vectors to a
-    // single value, so heads are told apart by their tool qualifier, not by temperature.
-    config.set_deserialize_strict({
-        { "imex_parallel_mode",                "copy" },
-        { "nozzle_temperature_initial_layer",  "200" },
-        { "nozzle_temperature",                "240" },
-    });
-
-    const std::string gcode = slice({ cube(20) }, config);
-
-    // Head 0 runs the print's own toolpaths and must step 200 -> 240 at the second layer.
-    CHECK(gcode.find("M104 S240 T0") != std::string::npos);
-    // Head 1 is the copy carriage; it already worked and must keep working.
-    CHECK(gcode.find("M104 S240 T1") != std::string::npos);
-}
-
 // IMEX supplements is_extruder_used for the secondary carriages a parallel mode drives.
 // `primary` drives exactly one tool, so the supplement must not run: routing every region
 // to filament 6 puts the initial tool on physical head 2, while the mode's only declared

tests/fff_print/test_print.cpp

@@ -54,8 +54,6 @@
 #include <cstdlib>
 #include <sstream>
 #include <limits>
-#include <fstream>
-#include <iterator>
 #include <memory>
 #include <string_view>
 #include <utility>
@@ -794,25 +792,6 @@ TEST_CASE("Print statistics in custom G-code match the final print statistics",
     }
 }
 
-TEST_CASE("export_gcode writes G-code without a result pointer", "[Print][export_gcode]")
-{
-    Print print;
-    Model model;
-    Slic3r::Test::init_print({cube(20)}, print, model);
-    print.process();
-
-    SECTION("non-BBL printer") {}
-    SECTION("BBL printer") { print.is_BBL_printer() = true; }
-
-    ScopedTemporaryFile temp(".gcode");
-    REQUIRE_NOTHROW(print.export_gcode(temp.string(), nullptr, nullptr));
-
-    std::ifstream in(temp.string());
-    const std::string gcode((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
-
-    REQUIRE_FALSE(gcode.empty());
-}
-
 TEST_CASE("Exporting a sliced print again gives the same G-code", "[Print][export_gcode][Regression]")
 {
     const int instances = GENERATE(1, 3);
@@ -1062,34 +1041,6 @@ TEST_CASE("Belt printers keep the part fan off within the band above the belt",
     CHECK(clear_fan_off == 0);
 }
 
-// Organic supports under an overhang on a belt printer reach below the object's first layer,
-// where the virtual belt raft layers sit at negative Z. The lowest of them used to get a
-// negative height and abort slicing with a negative flow error.
-TEST_CASE("Belt printers slice organic tree supports that reach the belt", "[Print][belt][Support]")
-{
-    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
-    config.set_deserialize_strict({
-        { "belt_printer",               1 },
-        { "belt_slice_rotation",        "x" },
-        { "belt_slice_rotation_angle",  45 },
-        { "gcode_remap_x",              "rev_x" },
-        { "gcode_remap_y",              "pos_z" },
-        { "gcode_remap_z",              "pos_y" },
-        { "layer_height",               0.2 },
-        { "initial_layer_print_height", 0.2 },
-        { "skirt_loops",                0 },
-        { "z_hop",                      0 },
-        { "enable_support",             1 },
-        { "support_type",               "tree(auto)" },
-        { "support_style",              "organic" },
-        { "machine_start_gcode",        "T[initial_tool]\n" },
-        { "layer_change_gcode",         "G92 E0\n" },
-    });
-    std::string gcode;
-    REQUIRE_NOTHROW(gcode = slice({ TestMesh::overhang }, config));
-    CHECK(! gcode.empty());
-}
-
 TEST_CASE("Slicing errors are reported per object with the object's name", "[Print]")
 {
     Print print;

tests/fff_print/test_skirt_brim.cpp

@@ -837,30 +837,6 @@ TEST_CASE("Belt brim on an object layer precedes its perimeters, once", "[SkirtB
     CHECK(role_passes(gc, "brim") <= bands);
 }
 
-// B - single extruder (filament id 1).  Every band must survive the 1-based -> 0-based
-// filament-id conversion the apron path performs: a wrong conversion drops all single-extruder
-// bands, so the pass count would collapse.  The expected count is derived from the sliced
-// layers, not a ratio.
-TEST_CASE("Belt brim on a single extruder emits every band once", "[SkirtBrim][belt]")
-{
-    DynamicPrintConfig config = belt_brim_config();
-    config.set_deserialize_strict({
-        { "brim_type",       "outer_only" },
-        { "brim_width",      4 },
-        { "brim_object_gap", 0 },
-    });
-    Print print;
-    Model model;
-    init_print({ cube(20) }, print, model, config);
-    const std::string gc = gcode(print);
-
-    const PrintObject &object = *print.objects().front();
-    const int expected = nonempty_belt_brim_layers(object) + belt_brim_apron_bands(object);
-    REQUIRE(expected > 0);
-    CHECK(role_layers(gc, "brim") == expected);
-    CHECK(belt_tools_for_role(gc, "brim") == std::set<int>{ 0 });   // filament 1 -> tool 0
-}
-
 // Number of brim segments the belt brim generator produced for `object`: the lattice
 // lines of every per-layer band plus the apron prologue.  Each segment is written as one
 // extruding move, so this is what a G-code count has to match.  A pass count cannot see a

tests/fff_print/test_slicing_pipeline_hook.cpp

@@ -27,14 +27,6 @@ TEST_CASE("slicing_pipeline_plugin option exists and defaults empty", "[slicing_
 
 #include "libslic3r/Print.hpp"
 
-TEST_CASE("slicing pipeline hook setter is a no-op-safe injection", "[slicing_pipeline]") {
-    int calls = 0;
-    Slic3r::Print::set_slicing_pipeline_hook_fn(
-        [&](Slic3r::Print&, const Slic3r::PrintObject*, Slic3r::SlicingPipelineStepPlugin){ ++calls; });
-    Slic3r::Print::set_slicing_pipeline_hook_fn(nullptr); // reset — must be legal
-    CHECK(calls == 0);
-}
-
 #include <vector>
 #include <algorithm>
 using namespace Slic3r::Test;

tests/fff_print/test_trianglemesh.cpp

@@ -10,8 +10,6 @@
 #include <cstdlib>
 #include <cstddef>
 #include <cmath>
-#include <future>
-#include <chrono>
 #include <vector>
 #include <math.h>
 #include "libslic3r/ExPolygon.hpp"
@@ -59,12 +57,6 @@ SCENARIO("Basic mesh statistics", "[TriangleMesh]") {
             REQUIRE(cube.facets_count() == facets.size());
         }
 
-#if 0
-        THEN( "Number of normals is equal to the number of facets.") {
-            REQUIRE(cube.normals().size() == facets.size());
-        }
-#endif
-
         THEN( "center() returns the center of the object.") {
             REQUIRE(cube.center() == Vec3d(10.0,10.0,10.0));
         }
@@ -265,20 +257,6 @@ SCENARIO("Split functionality", "[TriangleMesh]") {
     }
 }
 
-SCENARIO("Mesh merge functions", "[TriangleMesh]") {
-    GIVEN( "Two 20mm cubes, each with one corner on the origin") {
-		auto cube = make_cube();
-		TriangleMesh cube2(cube);
-
-        WHEN( "The two meshes are merged") {
-            cube.merge(cube2);
-            THEN( "There are twice as many facets in the merged mesh as the original.") {
-                REQUIRE(cube.facets_count() == 2 * cube2.facets_count());
-            }
-        }
-    }
-}
-
 SCENARIO("Cut behavior", "[TriangleMesh]") {
     GIVEN( "A 20mm cube with one corner on the origin") {
 		auto cube = make_cube();
@@ -306,53 +284,3 @@ SCENARIO("Cut behavior", "[TriangleMesh]") {
         }
     }
 }
-#ifdef TEST_PERFORMANCE
-TEST_CASE("Large mesh slices within the time budget (#4486)", "[TriangleMesh][Regression]") {
-    TriangleMesh mesh;
-    DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
-    mesh.ReadSTLFile(std::string(testfile_dir) + "test_trianglemesh/4486/100_000.stl");
-
-    config.set("layer_height", 500);
-    config.set("first_layer_height", 250);
-    config.set("nozzle_diameter", 500);
-
-    Slic3r::Print print;
-    Slic3r::Model model;
-    Slic3r::Test::init_print({mesh}, print, model, config);
-
-    print.status_cb = [] (int ln, const std::string& msg) { Slic3r::Log::info("Print") << ln << " " << msg << "\n";};
-
-    std::future<void> fut = std::async([&print] () { print.process(); });
-    std::chrono::milliseconds span {120000};
-    bool timedout {false};
-    if(fut.wait_for(span) == std::future_status::timeout) {
-        timedout = true;
-    }
-    REQUIRE(timedout == false);
-
-}
-#endif // TEST_PERFORMANCE
-
-#ifdef BUILD_PROFILE
-TEST_CASE("Large mesh slicing profile (#4486)", "[TriangleMesh][Profile]") {
-    TriangleMesh mesh;
-    DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
-    mesh.ReadSTLFile(std::string(testfile_dir) + "test_trianglemesh/4486/10_000.stl");
-
-    config.set("layer_height", 500);
-    config.set("first_layer_height", 250);
-    config.set("nozzle_diameter", 500);
-    config.set("fill_density", "5%");
-
-    Slic3r::Print print;
-    Slic3r::Model model;
-    Slic3r::Test::init_print({mesh}, print, model, config);
-
-    print.status_cb = [] (int ln, const std::string& msg) { Slic3r::Log::info("Print") << ln << " " << msg << "\n";};
-
-    print.process();
-
-    REQUIRE(true);
-
-}
-#endif //BUILD_PROFILE

tests/fff_print/test_wipe.cpp

@@ -348,21 +348,6 @@ TEST_CASE("Inactive inward wipe settings preserve the exported trajectory", "[Wi
     CHECK_FALSE(trajectories_differ(regular_paths, inward_paths));
 }
 
-TEST_CASE("Inward wipe changes the exported trajectory when outer wall width is Auto", "[Wipe][Regression]")
-{
-    const char *wall_generator = GENERATE("classic", "arachne");
-    INFO("wall generator: " << wall_generator);
-
-    const std::vector<Vec2d> regular = wipe_destinations(
-        slice({make_cube(10., 10., 1.)}, wipe_config(wall_generator, false)));
-    const std::vector<Vec2d> inward = wipe_destinations(
-        slice({make_cube(10., 10., 1.)}, wipe_config(wall_generator, true)));
-
-    REQUIRE_FALSE(regular.empty());
-    REQUIRE_FALSE(inward.empty());
-    REQUIRE(trajectories_differ(regular, inward));
-}
-
 TEST_CASE("Inward wipe recognizes an external wall starting on an overhang", "[Wipe][Regression]")
 {
     const char *wall_generator = GENERATE("classic", "arachne");

tests/libslic3r/test_3mf.cpp

@@ -505,28 +505,6 @@ TEST_CASE("A project whose components reference themselves fails to load", "[3mf
     REQUIRE_FALSE(loaded);
 }
 
-TEST_CASE("A project in the 2.4.x layout keeps auto drop off from its build item", "[3mf][Regression]")
-{
-    // 2.4.x wrote auto_drop on the build item and left it off the object, so the object is re-laid out here.
-    ScopedTemporaryFile temp(".3mf");
-    {
-        Model        model;
-        ModelObject* object = model.add_object();
-        object->add_volume(make_cube(10., 10., 10.));
-        object->add_instance();
-        object->auto_drop = false;
-        store_project(model, temp.string(), SaveStrategy::Zip64 | SaveStrategy::Silence);
-    }
-    REQUIRE(replace_in_3mf_entry(temp.string(), "model_settings.config", " auto_drop=\"0\"", ""));
-    REQUIRE(replace_in_3mf_entry(temp.string(), "3dmodel.model", "printable=\"1\"/>", "printable=\"1\" auto_drop=\"0\"/>"));
-
-    ScopedTemporaryDir backup_dir("orca_auto_drop_dst");
-    Model              model;
-    REQUIRE(load_project(temp.string(), model, backup_dir));
-    REQUIRE(model.objects.size() == 1);
-    CHECK_FALSE(model.objects.front()->auto_drop);
-}
-
 TEST_CASE("An object loads up to the component reference budget and fails past it", "[3mf][Regression]")
 {
     // The importer queues at most 100000 component references per object. Every reference besides the
@@ -1669,69 +1647,6 @@ SCENARIO("Legacy 3MF without published metadata loads unchanged", "[3mf]") {
     }
 }
 
-// Locks the serialization contract of the orca_published_material_keys metadata: the per-entry JSON
-// must survive a store_bbs_3mf -> load_bbs_3mf round-trip verbatim, exactly like orca_published_keys.
-SCENARIO("Published 3MF round-trips the published_material_keys metadata", "[3mf]") {
-    GIVEN("a model carrying published material keys metadata") {
-        Model model;
-        std::string src_file = std::string(TEST_DATA_DIR) + "/test_3mf/Prusa.stl";
-        REQUIRE(load_stl(src_file.c_str(), &model));
-        model.add_default_instances();
-
-        const std::string material_keys_json =
-            R"([{"material":{"filament_type":"PLA","filament_vendor":"Generic","filament_id":"GFL99"},"slot":0,"keys":["filament_retraction_length","filament_z_hop"]}])";
-
-        model.model_info = std::make_shared<ModelInfo>();
-        model.model_info->metadata_items[ORCA_PUBLISHED_MATERIAL_TAG] = material_keys_json;
-
-        ScopedTemporaryDir backup_dir("orca_pub_mat");
-        model.set_backup_path(backup_dir.string());
-
-        WHEN("stored to and reloaded from a .3mf") {
-            ScopedTemporaryFile temp(".3mf");
-            const std::string test_file = temp.string();
-
-            DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
-            StoreParams store_params;
-            store_params.path    = test_file.c_str();
-            store_params.model   = &model;
-            store_params.config  = &config;
-            store_params.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence;
-            REQUIRE(store_bbs_3mf(store_params));
-
-            Model dst_model;
-            DynamicPrintConfig dst_config;
-            ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Enable };
-            PlateDataPtrs        dst_plates;
-            std::vector<Preset*> project_presets;
-            bool   is_bbl_3mf = false, is_orca_3mf = false;
-            Semver file_version;
-            bool loaded = load_bbs_3mf(test_file.c_str(), &dst_config, &ctxt, &dst_model, &dst_plates,
-                                       &project_presets, &is_bbl_3mf, &is_orca_3mf, &file_version, nullptr,
-                                       LoadStrategy::LoadModel | LoadStrategy::LoadConfig);
-            THEN("the published material keys metadata round-trips unchanged") {
-                REQUIRE(loaded);
-                REQUIRE(dst_model.model_info != nullptr);
-                REQUIRE(dst_model.model_info->metadata_items[ORCA_PUBLISHED_MATERIAL_TAG] == material_keys_json);
-
-                // The value must parse back to one material entry carrying the nested identity
-                // object, the author slot ordinal and the key list.
-                nlohmann::json entries = nlohmann::json::parse(material_keys_json);
-                REQUIRE(entries.is_array());
-                REQUIRE(entries.size() == 1);
-                REQUIRE(entries[0]["material"]["filament_type"] == "PLA");
-                REQUIRE(entries[0]["material"]["filament_vendor"] == "Generic");
-                REQUIRE(entries[0]["material"]["filament_id"] == "GFL99");
-                REQUIRE(entries[0]["slot"] == 0);
-                REQUIRE(entries[0]["keys"].is_array());
-                REQUIRE(entries[0]["keys"].size() == 2);
-                REQUIRE(entries[0]["keys"][0] == "filament_retraction_length");
-            }
-            release_PlateData_list(dst_plates);
-        }
-    }
-}
-
 SCENARIO("Minimal published 3MF omits project config, preset dumps and slicer tags", "[3mf]") {
     GIVEN("a multi-instance model carrying published metadata and a published_config payload") {
         Model model;

tests/libslic3r/test_arrange.cpp

@@ -159,15 +159,6 @@ TEST_CASE("overlap_area detects overlap and ignores touching edges", "[Arrange]"
     }
 }
 
-TEST_CASE("Arrange places every item on the physical bed", "[Arrange]")
-{
-    ArrangePolygons items = squares(5, 20.);
-    arrange(items, bed(200, 200), quiet_params(scaled(1.)));
-
-    for (const ArrangePolygon &ap : items)
-        REQUIRE(ap.bed_idx == 0);
-}
-
 TEST_CASE("Arranged items stay within the bed", "[Arrange]")
 {
     ArrangePolygons items = squares(6, 30.);

tests/libslic3r/test_caddocument.cpp

@@ -2061,49 +2061,6 @@ TEST_CASE("mass properties: invalid body index", "[CadDocument]")
     REQUIRE_FALSE(mp3.valid);
 }
 
-TEST_CASE("serialize_recipe roundtrip with two bodies", "[CadDocument]")
-{
-    using Catch::Matchers::WithinRel;
-    CadDocument doc;
-
-    // Body 1: rectangle sketch + extrude + fillet
-    int sk1 = doc.add_sketch(SketchShape::Rectangle, SketchPlane::XY(),
-                             20, 20, 10, "Rect1");
-    REQUIRE(sk1 >= 0);
-    doc.add_extrude(sk1, 10.0, false, BooleanMode::New, "Extrude1");
-    doc.add_fillet(2.0, FaceGroup::All, "Fillet1");
-    REQUIRE(doc.recompute());
-    REQUIRE(doc.error.empty());
-
-    // Body 2: circle sketch + extrude (separate New body)
-    SketchEntity circ;
-    circ.type   = SketchEntity::Type::Circle;
-    circ.center = Vec2d(0, 0);
-    circ.radius = 8.0;
-    int sk2 = doc.add_sketch_entities({circ}, SketchPlane::XZ(), "Circle2");
-    doc.add_extrude(sk2, 6.0, false, BooleanMode::New, "Extrude2");
-    REQUIRE(doc.recompute());
-    REQUIRE(doc.error.empty());
-
-    REQUIRE(doc.bodies.size() >= 2);
-    std::vector<double> orig_vols;
-    for (const auto& b : doc.bodies)
-        orig_vols.push_back(double(SketchEngine::tessellate(b.shape).volume()));
-
-    auto blob = doc.serialize_recipe();
-    REQUIRE_FALSE(blob.empty());
-
-    CadDocument doc2;
-    REQUIRE(doc2.deserialize_recipe(blob));
-    REQUIRE(doc2.error.empty());
-    REQUIRE(doc2.bodies.size() == doc.bodies.size());
-
-    for (size_t i = 0; i < doc.bodies.size(); ++i) {
-        double v2 = double(SketchEngine::tessellate(doc2.bodies[i].shape).volume());
-        REQUIRE_THAT(v2, WithinRel(orig_vols[i], 1e-6));
-    }
-}
-
 TEST_CASE("deserialize_recipe rejects future version with error", "[CadDocument]")
 {
     CadDocument doc;
@@ -2147,41 +2104,6 @@ TEST_CASE("deserialize_recipe handles empty blob without throwing", "[CadDocumen
     REQUIRE_FALSE(doc.error.empty());
 }
 
-TEST_CASE("deserialize_recipe error is non-empty on every failure path", "[CadDocument]")
-{
-    CadDocument doc;
-    auto reset = [&]() { doc = CadDocument{}; };
-
-    // too new
-    {
-        std::ostringstream oss;
-        { cereal::BinaryOutputArchive ar(oss); uint32_t v = 999; ar(v); }
-        reset();
-        REQUIRE_FALSE(doc.deserialize_recipe(oss.str()));
-        REQUIRE_FALSE(doc.error.empty());
-    }
-    // too old
-    {
-        std::ostringstream oss;
-        { cereal::BinaryOutputArchive ar(oss); uint32_t v = 1; ar(v); }
-        reset();
-        REQUIRE_FALSE(doc.deserialize_recipe(oss.str()));
-        REQUIRE_FALSE(doc.error.empty());
-    }
-    // truncated / garbage
-    {
-        reset();
-        REQUIRE_FALSE(doc.deserialize_recipe("not a valid blob \x00\x01\x02"));
-        REQUIRE_FALSE(doc.error.empty());
-    }
-    // empty
-    {
-        reset();
-        REQUIRE_FALSE(doc.deserialize_recipe(""));
-        REQUIRE_FALSE(doc.error.empty());
-    }
-}
-
 TEST_CASE("a v4 project still opens", "[CadDocument][recipe]")
 {
     // The regression guard for everyone who already has projects: a pre-framing v4
@@ -4209,25 +4131,6 @@ static CadDocument make_golden_doc_v1()
     return doc;
 }
 
-TEST_CASE("regenerate golden recipe fixture", "[.regen]")
-{
-    CadDocument doc = make_golden_doc_v1();
-    // ponytail: serialize_recipe() only needs features, recompute is unnecessary
-    // for a fixture that exercises the serialization format.
-    auto blob = doc.serialize_recipe();
-    REQUIRE_FALSE(blob.empty());
-
-    // Version-free on purpose: this writes whatever today's format is, so a version bump does
-    // not have to remember to edit it. The version-stamped fixtures beside it are frozen
-    // evidence from older builds and are never regenerated.
-    std::string path = std::string(TEST_DATA_DIR) + "/cad_recipe_current.bin";
-    std::ofstream ofs(path, std::ios::binary);
-    REQUIRE(ofs.is_open());
-    ofs.write(blob.data(), static_cast<std::streamsize>(blob.size()));
-    ofs.close();
-    SUCCEED("Fixture written to " << path);
-}
-
 // The previous format's real blob, kept on disk deliberately. It is the only thing that can
 // prove the version gate does its job: a v3 recipe carries FEWER fields per feature than this
 // build reads, so without the bump to v4 it would have passed the gate and had two ints read
@@ -5692,45 +5595,6 @@ TEST_CASE("surface-loft round-trip serialize/deserialize", "[CadDocument][surfac
 
 // --- Mate tests (M8a) ---
 
-TEST_CASE("fastened mate with zero offset/angle", "[CadDocument][mate]")
-{
-    using Catch::Matchers::WithinAbs;
-
-    CadDocument doc;
-    int sk_box = doc.add_sketch(SketchShape::Rectangle, SketchPlane::XY(), 10, 10, 0, "Box");
-    doc.add_extrude(sk_box, 5.0, false, BooleanMode::New, "BoxExt");
-    REQUIRE(doc.recompute());
-    REQUIRE(doc.error.empty());
-
-    int cs_fixed = doc.add_coordsys(CoordSysType::PointWorld, Vec3d(5, 5, 5), "CS_Fixed");
-    doc.features[cs_fixed].coordsys_body = 0;
-    REQUIRE(doc.recompute());
-    REQUIRE(doc.error.empty());
-
-    int sk_cyl = doc.add_sketch(SketchShape::Circle, SketchPlane::XY(), 0, 0, 3, "Cyl");
-    doc.add_extrude(sk_cyl, 10.0, false, BooleanMode::New, "CylExt");
-    REQUIRE(doc.recompute());
-    REQUIRE(doc.error.empty());
-    REQUIRE(doc.bodies.size() == 2);
-
-    int cs_moving = doc.add_coordsys(CoordSysType::PointWorld, Vec3d(0, 0, 5), "CS_Moving");
-    doc.features[cs_moving].coordsys_body = 1;
-    REQUIRE(doc.recompute());
-    REQUIRE(doc.error.empty());
-
-    int mi = doc.add_mate(0, cs_fixed, cs_moving, 0.0, 0.0, false, "Mate");
-    REQUIRE(mi >= 0);
-    REQUIRE(doc.recompute());
-    REQUIRE(doc.error.empty());
-
-    GProp_GProps props;
-    BRepGProp::VolumeProperties(doc.bodies[1].shape, props);
-    gp_Pnt com = props.CentreOfMass();
-    REQUIRE_THAT(double(com.X()), WithinAbs(5.0, 1e-4));
-    REQUIRE_THAT(double(com.Y()), WithinAbs(5.0, 1e-4));
-    REQUIRE_THAT(double(com.Z()), WithinAbs(5.0, 1e-4));
-}
-
 TEST_CASE("fastened mate with offset", "[CadDocument][mate]")
 {
     using Catch::Matchers::WithinAbs;
@@ -5927,30 +5791,6 @@ TEST_CASE("mate round-trip serialization", "[CadDocument][mate]")
     REQUIRE(mf->mate_flip   == true);
 }
 
-TEST_CASE("version 2 blob is rejected", "[CadDocument][mate]")
-{
-
-    CadDocument doc;
-    int sk = doc.add_sketch(SketchShape::Rectangle, SketchPlane::XY(), 10, 10, 0, "Box");
-    doc.add_extrude(sk, 5.0, false, BooleanMode::New, "E");
-    REQUIRE(doc.recompute());
-    REQUIRE(doc.error.empty());
-
-    std::ostringstream oss;
-    {
-        cereal::BinaryOutputArchive ar(oss);
-        uint32_t fake_v = 2;
-        ar(fake_v);
-        ar(doc.features);
-        ar(doc.variables);
-    }
-    std::string blob = oss.str();
-
-    CadDocument fresh;
-    REQUIRE_FALSE(fresh.deserialize_recipe(blob));
-    REQUIRE_CONTAINS(fresh.error, "older version");
-}
-
 TEST_CASE("mate error: out of range connectors", "[CadDocument][mate]")
 {
 
@@ -7693,17 +7533,6 @@ TEST_CASE("two holes are both subtracted", "[CadDocument][sketchwire]")
     REQUIRE_THAT(double(doc.display_mesh.volume()), Catch::Matchers::WithinRel(expected, 0.01));
 }
 
-TEST_CASE("a lone circle still extrudes exactly as before", "[CadDocument][sketchwire]")
-{
-    std::vector<SketchEntity> ents = { circle_entity({0, 0}, 8.0) };
-    CadDocument doc = plate_doc(ents, 5.0);
-
-    REQUIRE(doc.recompute());
-    REQUIRE(doc.error.empty());
-    const double expected = M_PI * 64.0 * 5.0;
-    REQUIRE_THAT(double(doc.display_mesh.volume()), Catch::Matchers::WithinRel(expected, 0.01));
-}
-
 TEST_CASE("a closed polygon still extrudes exactly as before", "[CadDocument][sketchwire]")
 {
     std::vector<SketchEntity> ents = rect_entities(20, 20);

tests/libslic3r/test_clipper_utils.cpp

@@ -155,51 +155,6 @@ SCENARIO("Various Clipper operations - xs/t/11_clipper.t", "[ClipperUtils]") {
             REQUIRE(result.front().length() == Catch::Approx(subject.length()));
         }
     }
-
-#if 0
-    {
-        # Clipper does not preserve polyline orientation
-        my $polyline = Slic3r::Polyline->new([50, 150], [300, 150]);
-        my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]);
-        is scalar(@$result), 1, 'intersection_pl - correct number of result lines';
-        is_deeply $result->[0]->pp, [[100, 150], [200, 150]], 'clipped line orientation is preserved';
-    }
-    {
-        # Clipper does not preserve polyline orientation
-        my $polyline = Slic3r::Polyline->new([300, 150], [50, 150]);
-        my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]);
-        is scalar(@$result), 1, 'intersection_pl - correct number of result lines';
-        is_deeply $result->[0]->pp, [[200, 150], [100, 150]], 'clipped line orientation is preserved';
-    }
-    {
-        # Disabled until Clipper bug #127 is fixed
-        my $subject = [
-            Slic3r::Polyline->new([-90000000, -100000000], [-90000000, 100000000]), # vertical
-                Slic3r::Polyline->new([-100000000, -10000000], [100000000, -10000000]), # horizontal
-                Slic3r::Polyline->new([-100000000, 0], [100000000, 0]), # horizontal
-                Slic3r::Polyline->new([-100000000, 10000000], [100000000, 10000000]), # horizontal
-        ];
-        my $clip = Slic3r::Polygon->new(# a circular, convex, polygon
-            [99452190, 10452846], [97814760, 20791169], [95105652, 30901699], [91354546, 40673664], [86602540, 50000000],
-            [80901699, 58778525], [74314483, 66913061], [66913061, 74314483], [58778525, 80901699], [50000000, 86602540],
-            [40673664, 91354546], [30901699, 95105652], [20791169, 97814760], [10452846, 99452190], [0, 100000000],
-            [-10452846, 99452190], [-20791169, 97814760], [-30901699, 95105652], [-40673664, 91354546],
-            [-50000000, 86602540], [-58778525, 80901699], [-66913061, 74314483], [-74314483, 66913061],
-            [-80901699, 58778525], [-86602540, 50000000], [-91354546, 40673664], [-95105652, 30901699],
-            [-97814760, 20791169], [-99452190, 10452846], [-100000000, 0], [-99452190, -10452846],
-            [-97814760, -20791169], [-95105652, -30901699], [-91354546, -40673664], [-86602540, -50000000],
-            [-80901699, -58778525], [-74314483, -66913061], [-66913061, -74314483], [-58778525, -80901699],
-            [-50000000, -86602540], [-40673664, -91354546], [-30901699, -95105652], [-20791169, -97814760],
-            [-10452846, -99452190], [0, -100000000], [10452846, -99452190], [20791169, -97814760],
-            [30901699, -95105652], [40673664, -91354546], [50000000, -86602540], [58778525, -80901699],
-            [66913061, -74314483], [74314483, -66913061], [80901699, -58778525], [86602540, -50000000],
-            [91354546, -40673664], [95105652, -30901699], [97814760, -20791169], [99452190, -10452846], [100000000, 0]
-            );
-        my $result = Slic3r::Geometry::Clipper::intersection_pl($subject, [$clip]);
-        is scalar(@$result), scalar(@$subject), 'intersection_pl - expected number of polylines';
-        is sum(map scalar(@$_), @$result), scalar(@$subject) * 2, 'intersection_pl - expected number of points in polylines';
-    }
-#endif
 }
 
 SCENARIO("Various Clipper operations - t/clipper.t", "[ClipperUtils]") {

tests/libslic3r/test_config.cpp

@@ -643,45 +643,6 @@ SCENARIO("update_non_diff_values_to_base_config keeps a project's changed values
     }
 }
 
-// SCENARIO("DynamicPrintConfig JSON serialization", "[Config]") {
-//     WHEN("DynamicPrintConfig is serialized and deserialized") {
-// 	auto now = std::chrono::high_resolution_clock::now();
-// 	auto timestamp = now.time_since_epoch().count();
-// 	std::stringstream ss;
-// 	ss << "catch_test_serialization_" << timestamp << ".json";
-// 	std::string filename = (fs::temp_directory_path() / ss.str()).string();
-
-// TODO: Finish making a unit test for JSON serialization
-//         FullPrintConfig full_print_config;
-//         DynamicPrintConfig cfg;
-//         cfg.apply(full_print_config, false);
-
-//         std::string serialized;
-//         try {
-//             std::ostringstream ss;
-//             cereal::BinaryOutputArchive oarchive(ss);
-//             oarchive(cfg);
-//             serialized = ss.str();
-//         } catch (const std::runtime_error & /* e */) {
-//             // e.what();
-//         }
-// 	CAPTURE(serialized.length());
-
-//         THEN("Config object contains ini file options.") {
-//             DynamicPrintConfig cfg2;
-//             try {
-//                 std::stringstream ss(serialized);
-//                 cereal::BinaryInputArchive iarchive(ss);
-//                 iarchive(cfg2);
-//             } catch (const std::runtime_error & /* e */) {
-//                 // e.what();
-//             }
-// 	    CAPTURE(cfg.diff_report(cfg2));
-//             REQUIRE(cfg == cfg2);
-//         }
-//     }
-// }
-
 TEST_CASE("save_to_json round-trips plugin capability references as strings", "[Config][plugins]") {
     ScopedTemporaryFile tmp(".json");
     const std::vector<std::string> refs = {

tests/libslic3r/test_elephant_foot_compensation.cpp

@@ -17,10 +17,6 @@ using namespace Slic3r;
 
 // #define TESTS_EXPORT_SVGS
 
-namespace Slic3r {
-	Points mittered_offset_path_scaled(const Points& contour, const std::vector<float>& deltas, double miter_limit);
-}
-
 static ExPolygon spirograph_gear_1mm()
 {
 	ExPolygon out;
@@ -479,33 +475,6 @@ SCENARIO("Elephant foot compensation", "[ElephantFoot]") {
         }
 	}
 
-#if 0
-	GIVEN("Varying inner offset") {
-		ExPolygon input = spirograph_gear_1mm().simplify(SCALED_EPSILON).front();
-		ExPolygon output;
-		std::vector<float> deltas(input.contour.points.size(), scale_(1.));
-                // mittered_offset_path_scaled_points is commented out somewhere above
-		output.contour.points = Slic3r::mittered_offset_path_scaled_points(input.contour.points, deltas, 2.);
-#ifdef TESTS_EXPORT_SVGS
-		{
-			SVG svg(debug_out_path("elephant_foot_compensation_0.svg").c_str(), get_extents(output));
-			svg.draw(input, "blue");
-			svg.draw_outline(output, "black", coord_t(scale_(0.01)));
-		}
-#endif /* TESTS_EXPORT_SVGS */
-		for (size_t i = 0; i <= deltas.size() / 2; ++ i)
-			deltas[i] = deltas[deltas.size() - i - 1] = scale_(1.) * double(i) / (0.5 * double(deltas.size()));
-		output.contour.points = Slic3r::mittered_offset_path_scaled_points(input.contour.points, deltas, 2.);
-#ifdef TESTS_EXPORT_SVGS
-		{
-			SVG svg(debug_out_path("elephant_foot_compensation_varying.svg").c_str(), get_extents(output));
-			svg.draw(input, "blue");
-			svg.draw_outline(output, "black", coord_t(scale_(0.01)));
-		}
-#endif /* TESTS_EXPORT_SVGS */
-	}
-#endif
-
     GIVEN("Rectangle with a narrow part sticking out") {				
 		// Rectangle
 		ExPolygon expoly;

tests/libslic3r/test_fill_plane_path.cpp

@@ -208,20 +208,3 @@ TEST_CASE("Octagram spiral smooth factor controls corner curvature", "[FillPlane
     REQUIRE(path_length(half_smooth) < path_length(sharp));
     REQUIRE(invalid_factor == sharp);
 }
-
-TEST_CASE("Hilbert curve smooth factor controls corner curvature", "[FillPlanePath]")
-{
-    const Points sharp       = TestableHilbertCurve().generate_points(0.005);
-    const Points half_smooth = TestableHilbertCurve().generate_points(0.005, 0.5);
-    const Points full_smooth = TestableHilbertCurve().generate_points(0.005, 1.);
-    const Points invalid_factor = TestableHilbertCurve().generate_points(
-        0.005, std::numeric_limits<double>::quiet_NaN());
-
-    REQUIRE(full_smooth.front() == half_smooth.front());
-    REQUIRE(full_smooth.back() == half_smooth.back());
-    REQUIRE(path_length(full_smooth) < path_length(half_smooth));
-    REQUIRE(invalid_factor == sharp);
-
-    for (size_t i = 1; i < full_smooth.size(); ++i)
-        REQUIRE((full_smooth[i] - full_smooth[i - 1]).squaredNorm() > 0);
-}

tests/libslic3r/test_geometry.cpp

@@ -18,8 +18,6 @@
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/ShortestPath.hpp"
 
-//#include <random>
-//#include "libnest2d/tools/benchmark.h"
 #include "libslic3r/SVG.hpp"
 
 #include "../libnest2d/printer_parts.hpp"
@@ -605,73 +603,6 @@ TEST_CASE("Convex polygon intersection on two overlapping squares", "[Geometry][
     REQUIRE(is_inters == true);
 }
 
-//// Only for benchmarking
-//static Polygon gen_convex_poly(std::mt19937_64 &rg, size_t point_cnt)
-//{
-//    std::uniform_int_distribution<coord_t> dist(0, 100);
-
-//    Polygon out;
-//    out.points.reserve(point_cnt);
-
-//    coord_t tr = dist(rg) * 2 / SCALING_FACTOR;
-
-//    for (size_t i = 0; i < point_cnt; ++i)
-//        out.points.emplace_back(tr + dist(rg) / SCALING_FACTOR,
-//                                tr + dist(rg) / SCALING_FACTOR);
-
-//    return Geometry::convex_hull(out.points);
-//}
-//TEST_CASE("Convex polygon intersection test on random polygons", "[Geometry]") {
-//    constexpr size_t TEST_CNT = 1000;
-//    constexpr size_t POINT_CNT = 1000;
-
-//    auto seed = std::random_device{}();
-////    unsigned long seed = 2525634386;
-//    std::mt19937_64 rg{seed};
-//    Benchmark bench;
-
-//    auto tests = reserve_vector<std::pair<Polygon, Polygon>>(TEST_CNT);
-//    auto results = reserve_vector<bool>(TEST_CNT);
-//    auto expects = reserve_vector<bool>(TEST_CNT);
-
-//    for (size_t i = 0; i < TEST_CNT; ++i) {
-//        tests.emplace_back(gen_convex_poly(rg, POINT_CNT), gen_convex_poly(rg, POINT_CNT));
-//    }
-
-//    bench.start();
-//    for (const auto &test : tests)
-//        results.emplace_back(Geometry::convex_polygons_intersect(test.first, test.second));
-//    bench.stop();
-
-//    std::cout << "Test time: " << bench.getElapsedSec() << std::endl;
-
-//    bench.start();
-//    for (const auto &test : tests)
-//        expects.emplace_back(!intersection(test.first, test.second).empty());
-//    bench.stop();
-
-//    std::cout << "Clipper time: " << bench.getElapsedSec() << std::endl;
-
-//    REQUIRE(results.size() == expects.size());
-
-//    auto seedstr = std::to_string(seed);
-//    for (size_t i = 0; i < results.size(); ++i) {
-//        // std::cout << expects[i] << " ";
-
-//        if (results[i] != expects[i]) {
-//            SVG svg{std::string("fail_seed") + seedstr + "_" + std::to_string(i) + ".svg"};
-//            svg.draw(tests[i].first, "blue");
-//            svg.draw(tests[i].second, "green");
-//            svg.Close();
-
-//            // std::cout << std::endl;
-//        }
-//        REQUIRE(results[i] == expects[i]);
-//    }
-//    std::cout << std::endl;
-
-//}
-
 struct Pair
 {
     size_t first, second;

tests/libslic3r/test_imex_helpers.cpp

@@ -71,15 +71,6 @@ TEST_CASE("effective_physical_extruder_map - degenerate nozzle count still yield
     REQUIRE(effective_physical_extruder_map(nullptr, 0).values == std::vector<int>{0});
 }
 
-TEST_CASE("effective_physical_extruder_map - IDEX ghost-color regression guard", "[IMEX]") {
-    // Dual extruder, no authored map. Before the GUI fix this produced a black ghost on T1
-    // because first_filament_for_physical_head({0}, 1) == -1.
-    auto default_pem = make_pem({0});
-    auto pem         = effective_physical_extruder_map(&default_pem, 2);
-    REQUIRE(first_filament_for_physical_head(pem, 0) == 0);
-    REQUIRE(first_filament_for_physical_head(pem, 1) == 1); // no longer -1
-}
-
 TEST_CASE("imex_pem_tool_for - non-parallel mode returns -1", "[IMEX]") {
     // Empty mode string (not in IMEX) and "primary" (IMEX present but not parallel) both
     // short-circuit to bare-firmware PA/temp emission.
@@ -1058,12 +1049,6 @@ TEST_CASE("compute_imex_slice_offset - flag on + copy mode returns primary zone
     REQUIRE_THAT(z.y(), WithinAbs(40.0, 1e-9));
 }
 
-TEST_CASE("compute_imex_slice_offset - flag on + mirror mode returns primary zone center", "[IMEX]") {
-    auto z = compute_imex_slice_offset(true, "mirror", kPrimaryZoneCenteredAt60_40);
-    REQUIRE_THAT(z.x(), WithinAbs(60.0, 1e-9));
-    REQUIRE_THAT(z.y(), WithinAbs(40.0, 1e-9));
-}
-
 TEST_CASE("compute_imex_slice_offset - user-defined non-primary mode names trigger shift", "[IMEX]") {
     // Mode names are user-defined; anything not "primary" or "" should activate.
     auto z = compute_imex_slice_offset(true, "iq-copy", kPrimaryZoneCenteredAt60_40);

tests/libslic3r/test_indexed_triangle_set.cpp

@@ -6,7 +6,6 @@
 #include "libslic3r/Point.hpp"
 #include "libslic3r/libslic3r.h"
 #include <limits>
-#include <random>
 #include <catch2/catch_all.hpp>
 #include <vector>
 #include <string>
@@ -117,68 +116,6 @@ TEST_CASE("Split two watertight meshes", "[its_split][its]") {
 }
 
 #include <libslic3r/QuadricEdgeCollapse.hpp>
-static float triangle_area(const Vec3f &v0, const Vec3f &v1, const Vec3f &v2)
-{
-    Vec3f ab = v1 - v0;
-    Vec3f ac = v2 - v0;
-    return ab.cross(ac).norm() / 2.f;
-}
-
-static float triangle_area(const stl_triangle_vertex_indices &triangle_indices, const std::vector<Vec3f> &vertices)
-{
-    return triangle_area(vertices[triangle_indices[0]],
-                         vertices[triangle_indices[1]],
-                         vertices[triangle_indices[2]]);
-}
-
-#if 0
-// clang complains about unused functions
-static std::mt19937 create_random_generator() {
-    std::random_device rd;
-    std::mt19937 gen(rd());
-    return gen;
-}
-#endif
-
-std::vector<Vec3f> its_sample_surface(const indexed_triangle_set &its,
-                                      double        sample_per_mm2,
-                                      std::mt19937 random_generator) // = create_random_generator())
-{
-    std::vector<Vec3f> samples;
-    std::uniform_real_distribution<float> rand01(0.f, 1.f);
-    for (const auto &triangle_indices : its.indices) {
-        float area = triangle_area(triangle_indices, its.vertices);
-        float countf;
-        float fractional = std::modf(area * sample_per_mm2, &countf);
-        int count = static_cast<int>(countf);
-
-        float generate = rand01(random_generator);
-        if (generate < fractional) ++count;
-        if (count == 0) continue;
-
-        const Vec3f &v0 = its.vertices[triangle_indices[0]];
-        const Vec3f &v1 = its.vertices[triangle_indices[1]];
-        const Vec3f &v2 = its.vertices[triangle_indices[2]];
-        for (int c = 0; c < count; c++) {
-            // barycentric coordinate
-            Vec3f b;
-            b[0] = rand01(random_generator);
-            b[1] = rand01(random_generator);
-            if ((b[0] + b[1]) > 1.f) {
-                b[0] = 1.f - b[0];
-                b[1] = 1.f - b[1];
-            }
-            b[2] = 1.f - b[0] - b[1];
-            Vec3f pos;
-            for (int i = 0; i < 3; i++) {
-                pos[i] = b[0] * v0[i] + b[1] * v1[i] + b[2] * v2[i];
-            }
-            samples.push_back(pos);
-        }        
-    }
-    return samples;
-}
-
 
 #include "libslic3r/AABBTreeIndirect.hpp"
 

tests/libslic3r/test_ordering_strategies.cpp

@@ -261,16 +261,6 @@ TEST_CASE("snake_core produces valid paths on ring", "[Snake]") {
     REQUIRE(is_permutation(p2, centers.size()));
 }
 
-// --- Core Strategy Tests: Random Layout ---
-
-TEST_CASE("snake_core produces valid paths on random input", "[Snake]") {
-    Points centers = make_random_16();
-
-    auto p2 = snake_core(centers);
-
-    REQUIRE(is_permutation(p2, centers.size()));
-}
-
 // --- Quality Comparison Tests ---
 
 TEST_CASE("snake has no crossings on random input", "[Snake]") {

tests/libslic3r/test_precise_seam.cpp

@@ -730,25 +730,6 @@ TEST_CASE("Neighboring vertices distinguish repeated anchors on different lobes"
     CHECK(edges == std::vector<size_t>{0, 2, 3, 4, 6, 7});
 }
 
-TEST_CASE("Modifier holes subtract coverage while separate components add intervals", "[PreciseSeam][SegmentExtraction]")
-{
-    const Polygon perimeter = rectangle(0, 0, 20, 20);
-    ExPolygon area(rectangle(1, -3, 10, 3));
-    area.holes.push_back(rectangle(4, -1, 7, 1));
-    area.holes.back().reverse();
-    const auto result = PreciseSeam::extract_perimeter_segments(PreciseSeam::PreparedPerimeter(perimeter),
-        PreciseSeam::prepare_modifier_regions({area, ExPolygon(rectangle(14, -3, 18, 3))}), ModelVolumeType::PRECISE_SEAM_CENTER);
-    check_provenance(perimeter, result);
-    REQUIRE(result.segments.size() == 3);
-    const std::vector<Point> starts{mm(1, 0), mm(7, 0), mm(14, 0)};
-    const std::vector<Point> ends{mm(4, 0), mm(10, 0), mm(18, 0)};
-    for (size_t i = 0; i < 3; ++i) {
-        CHECK(result.segments[i].polyline.points.front() == starts[i]);
-        CHECK(result.segments[i].polyline.points.back() == ends[i]);
-    }
-    CHECK_FALSE(result.full_containment);
-}
-
 TEST_CASE("Full coverage is distinct from an empty or point-only intersection", "[PreciseSeam][SegmentExtraction]")
 {
     const bool reverse = GENERATE(false, true);

tests/libslic3r/test_sketchconstraints.cpp

@@ -239,30 +239,6 @@ TEST_CASE("DistanceX on two Points binds real roles with non-negative prefill",
     REQUIRE(p.defs[0].eb == 0);
 }
 
-TEST_CASE("Horizontal on a Point rejects with NeedALine", "[SketchConstraints]")
-{
-    std::vector<SketchEntity> ents = { mk_point(1, 2) };
-    ConstraintPlan p = plan_entity_constraint(ents, 0, -1, -1, SketchConstraintType::Horizontal);
-    REQUIRE(p.kind == ConstraintPlan::Kind::Reject);
-    REQUIRE(p.reason == ConstraintReject::NeedALine);
-}
-
-TEST_CASE("Angle on two Circles rejects with NeedTwoLines", "[SketchConstraints]")
-{
-    std::vector<SketchEntity> ents = { mk_circle(0, 0, 1), mk_circle(5, 0, 1) };
-    ConstraintPlan p = plan_entity_constraint(ents, 0, 1, -1, SketchConstraintType::Angle);
-    REQUIRE(p.kind == ConstraintPlan::Kind::Reject);
-    REQUIRE(p.reason == ConstraintReject::NeedTwoLines);
-}
-
-TEST_CASE("Parallel on a Line + Circle rejects with NeedTwoLines (new guard)", "[SketchConstraints]")
-{
-    std::vector<SketchEntity> ents = { mk_line(0, 0, 1, 0), mk_circle(5, 0, 1) };
-    ConstraintPlan p = plan_entity_constraint(ents, 0, 1, -1, SketchConstraintType::Parallel);
-    REQUIRE(p.kind == ConstraintPlan::Kind::Reject);
-    REQUIRE(p.reason == ConstraintReject::NeedTwoLines);
-}
-
 TEST_CASE("Equal on two Circles promotes to EqualRadius", "[SketchConstraints]")
 {
     std::vector<SketchEntity> ents = { mk_circle(0, 0, 1), mk_circle(5, 0, 2) };

tests/libslic3r/test_stl.cpp

@@ -44,17 +44,6 @@ SCENARIO("Reading an STL file", "[stl]") {
 				REQUIRE(is_approx(model.objects.front()->volumes.front()->mesh().size(), Vec3d(20, 20, 20)));
 			}
 		}
-#if 0
-		// ASCII STLs ending with just carriage returns are not supported. These were used by the old Macs, while the Unix based MacOS uses LFs as any other Unix.
-		WHEN("line endings CR") {
-			Slic3r::Model model;
-			THEN("load should succeed") {
-				REQUIRE(Slic3r::load_stl(stl_path("ASCII/20mmbox-CR.stl").c_str(), &model));
-				REQUIRE(is_approx(model.objects.front()->volumes.front()->mesh().size(), Vec3d(20, 20, 20)));
-			}
-		}
-
-#endif
 		WHEN("nonstandard STL file (text after ending tags, invalid normals, for example infinities)") {
 			Slic3r::Model model;
 			THEN("load should succeed") {

tests/libslic3r/test_texture_displacement.cpp

@@ -3285,33 +3285,6 @@ TEST_CASE("a ModelUV layer falls back to Triplanar when the volume carries no UV
         CHECK_THAT((no_channel.vertices[i] - as_triplanar.vertices[i]).norm(), WithinAbs(0.f, 1e-5f));
 }
 
-TEST_CASE("a bake with colour off on every layer reports no colour at all", "[TextureDisplacement]")
-{
-    const indexed_triangle_set cube = its_make_cube(10., 10., 10.);
-
-    TextureDisplacementLayer layer;
-    layer.slot          = 0;
-    layer.depth_mm      = 1.0f;
-    layer.tiling_scale  = 5.0f;
-    layer.image_data    = make_flat_rgb_png(200, 40, 10); // has colour to give...
-    layer.color_enabled = false;                          // ...but is not asked for it
-
-    TextureDisplacementFacetsData facets{};
-    facets[0] = paint_whole_mesh(cube);
-
-    std::vector<uint8_t> triangle_color;
-    TextureColorRequest  request;
-    request.quantize     = [](const Vec3f &) { return 0; }; // would colour everything, if asked
-    request.out_triangle = &triangle_color;
-
-    const indexed_triangle_set out = build_texture_displacement(cube, {layer}, facets, classic_options(), {}, &request);
-    REQUIRE_FALSE(out.vertices.empty());
-    // Every entry 0 ("this triangle takes no colour from the texture"), so the commit leaves whatever
-    // the model was already painted with exactly as it was.
-    for (const uint8_t entry : triangle_color)
-        CHECK(entry == 0);
-}
-
 TEST_CASE("transfer_uv_channel resamples a UV channel onto a subdivided copy of the same surface",
           "[TextureDisplacement]")
 {

tests/libslic3r/test_vendor_cache.cpp

@@ -1110,28 +1110,6 @@ TEST_CASE("a cache with the wrong cache version is rejected", "[VendorCache]")
     REQUIRE(!out.load_vendor_cache(cache.string(), vid, Semver("1.0.0")));
 }
 
-TEST_CASE("a cache truncated mid-blob is rejected", "[VendorCache]")
-{
-    TempDir           tmp;
-    const std::string vid   = "Acme";
-    const fs::path     cache = tmp.path / "vendor.opc";
-
-    REQUIRE(save_one_vendor(cache.string(), one_vendor(vid), vid, "1.0.0",
-                            {filament_entry(vid + " PLA")}));
-
-    {
-        std::ifstream in(cache.string(), std::ios::binary);
-        std::vector<char> buf(30); // 20-byte header + 10 bytes of blob
-        in.read(buf.data(), 30);
-        in.close();
-        std::ofstream out(cache.string(), std::ios::binary | std::ios::trunc);
-        out.write(buf.data(), 30);
-    }
-
-    PresetBundle out;
-    REQUIRE(!out.load_vendor_cache(cache.string(), vid, Semver("1.0.0")));
-}
-
 TEST_CASE("printer model bed texture fields survive a cache round-trip", "[VendorCache]")
 {
     TempDir           tmp;

tests/libslic3r/test_voronoi.cpp

@@ -34,53 +34,6 @@ using namespace Slic3r;
 using VD = Geometry::VoronoiDiagram;
 using BoostVD = boost::polygon::voronoi_diagram<double>;
 
-// https://svn.boost.org/trac10/ticket/12067
-// This bug seems to be confirmed.
-// Vojtech supposes that there may be no Voronoi edges produced for
-// the 1st and last sweep line positions.
-TEST_CASE("Voronoi missing edges - points 12067", "[Voronoi]")
-{
-    Points pts {
-        { -10, -20 },
-        {  10, -20 },
-        {   5,   0 },
-        {  10,  20 },
-        { -10,  20 },
-        {  -5,   0 }
-    };
-
-#if 0
-    for (Point &p : pts) {
-        Vec2d q = p.cast<double>();
-        p.x() = scale_(p.x());
-        p.y() = scale_(p.y());
-    }
-#endif
-
-#if 0
-    // Try to rotate, maybe the issue is caused by incorrect handling of vertical or horizontal edges?
-    double a = 0.18764587962597876897475f;
-    double c = cos(a);
-    double s = sin(a);
-    for (Point &p : poly.points) {
-        Vec2d q = p.cast<double>();
-        p.x() = coord_t(q.x() * c + q.y() * s + 0.5);
-        p.y() = coord_t(- q.x() * s + q.y() * c + 0.5);
-    }
-#endif
-
-    // Construction of the Voronoi Diagram.
-    BoostVD vd;
-    construct_voronoi(pts.begin(), pts.end(), &vd);
-
-#ifdef VORONOI_DEBUG_OUT
-    dump_voronoi_to_svg(debug_out_path("voronoi-pts.svg").c_str(),
-        vd, pts, Lines());
-#endif
-
-//    REQUIRE(closest_point.z() == Catch::Approx(1.));
-}
-
 // https://svn.boost.org/trac10/ticket/12707
 // This issue is confirmed, there are no self intersections in the polygon.
 // A minimal test case is created at the end of this test,
@@ -315,36 +268,6 @@ TEST_CASE("Voronoi weirdness", "[Voronoi]")
 #endif
 }
 
-// https://svn.boost.org/trac10/ticket/12903
-// division by zero reported, but this issue is most likely a non-issue, as it produces an infinity for the interval of validity
-// of the floating point calculation, therefore forcing a recalculation with extended accuracy.
-TEST_CASE("Voronoi division by zero 12903", "[Voronoi]")
-{
-    Points pts { { 1, 1 }, { 3, 1 }, { 1, 3 }, { 3, 3 },
-                 { -1, 1 }, { 1, -1 }, { 5, 1 }, { 3, -1 },
-                 { -1, 3 }, { 1, 5 }, { 5, 3 }, { 3, 5 } };
-    {
-        auto pts2 { pts };
-        std::sort(pts2.begin(), pts2.end(), [](auto &l, auto &r) { return (l.x() == r.x()) ? l.y() < r.y() : l.x() < r.x(); });
-        // No point removed -> no duplicate.
-        REQUIRE(std::unique(pts2.begin(), pts2.end()) == pts2.end());
-    }
-
-    BoostVD vd;
-    construct_voronoi(pts.begin(), pts.end(), &vd);
-
-#ifdef VORONOI_DEBUG_OUT
-    // Scale the voronoi vertices and input points, so that the dump_voronoi_to_svg will display them correctly.
-    for (auto &pt : vd.vertices()) {
-        const_cast<double&>(pt.x()) = scale_(pt.x());
-        const_cast<double&>(pt.y()) = scale_(pt.y());
-    }
-    for (auto &pt : pts)
-        pt = Point::new_scale(pt.x(), pt.y());
-    dump_voronoi_to_svg(debug_out_path("voronoi-div-by-zero.svg").c_str(), vd, pts, Lines());
-#endif
-}
-
 // https://svn.boost.org/trac10/ticket/12139
 // Funny sample from a dental industry?
 // Vojtech confirms this test fails and rightly so, because the input data contain self intersections.
@@ -1383,15 +1306,6 @@ TEST_CASE("Voronoi offset", "[VoronoiOffset]")
             OffsetTest { scale_(0.55), 1, 0 }
       }) {
 
-#if 0
-      Polygons offsetted_polygons_out = Slic3r::Voronoi::offset(vd, lines, ot.distance, scale_(0.005));
-#ifdef VORONOI_DEBUG_OUT
-      dump_voronoi_to_svg(debug_out_path("voronoi-offset-out-%lf.svg", ot.distance).c_str(),
-          vd, Points(), lines, offsetted_polygons_out);
-#endif
-      REQUIRE(offsetted_polygons_out.size() == ot.num_outer);
-#endif
-
       Polygons offsetted_polygons_in = Slic3r::Voronoi::offset(vd, lines, - ot.distance, scale_(0.005));
 #ifdef VORONOI_DEBUG_OUT
       dump_voronoi_to_svg(debug_out_path("voronoi-offset-in-%lf.svg", ot.distance).c_str(),

tests/slic3rutils/slic3rutils_tests_main.cpp

@@ -1,61 +1 @@
 #include <catch2/catch_all.hpp>
-
-#include <catch2/catch_test_macros.hpp>
-#include "slic3r/Utils/Http.hpp"
-
-TEST_CASE("Check SSL certificates paths", "[Http][NotWorking]") {
-    
-    Slic3r::Http g = Slic3r::Http::get("https://github.com/");
-    
-    unsigned status = 0;
-    g.on_error([&status](std::string, std::string, unsigned http_status) {
-        status = http_status;
-    });
-    
-    g.on_complete([&status](std::string /* body */, unsigned http_status){
-        status = http_status;
-    });
-    
-    g.perform_sync();
-    
-    REQUIRE(status == 200);
-}
-
-TEST_CASE("Http digest authentication", "[Http][NotWorking]") {
-    Slic3r::Http g = Slic3r::Http::get("https://httpbingo.org/digest-auth/auth/guest/guest");
-
-    g.auth_digest("guest", "guest");
-
-    unsigned status = 0;
-    g.on_error([&status](std::string, std::string, unsigned http_status) {
-        status = http_status;
-    });
-
-    g.on_complete([&status](std::string /* body */, unsigned http_status){
-        status = http_status;
-    });
-
-    g.perform_sync();
-
-    REQUIRE(status == 200);
-}
-
-TEST_CASE("Http basic authentication", "[Http][NotWorking]") {
-    Slic3r::Http g = Slic3r::Http::get("https://httpbingo.org/basic-auth/guest/guest");
-
-    g.auth_basic("guest", "guest");
-
-    unsigned status = 0;
-    g.on_error([&status](std::string, std::string, unsigned http_status) {
-        status = http_status;
-    });
-
-    g.on_complete([&status](std::string /* body */, unsigned http_status){
-        status = http_status;
-    });
-
-    g.perform_sync();
-
-    REQUIRE(status == 200);
-}
-

tests/slic3rutils/test_action_source.cpp

@@ -73,34 +73,6 @@ TEST_CASE("ActionRegistry takes exclusive ownership of published actions", "[Act
     STATIC_CHECK(std::is_same_v<decltype(&ActionRegistry::upsert), ExpectedUpsert>);
 }
 
-// A dynamic "Go to Plate N" action is keyed by plate index (not the display title), so renaming
-// a plate never re-keys it - the same contract as a setting action.
-TEST_CASE("Go-to-plate actions are keyed by index, not title", "[ActionSource][SpeedDial]")
-{
-    CHECK(AppAction::compose_id("orca_plate_goto", "0", "orca") == "orca_plate_goto:0:orca");
-    CHECK(AppAction::compose_id("orca_plate_goto", "2", "orca") == "orca_plate_goto:2:orca");
-}
-
-// A dynamic "Open recent project" action is keyed by file path (not the display name), so renaming
-// a project or reordering the recents list never re-keys it - the same contract as a setting action.
-TEST_CASE("Recent-project actions are keyed by path, not title", "[ActionSource][SpeedDial]")
-{
-    CHECK(AppAction::compose_id("orca_recent_project", "/a/b/project.3mf", "orca") ==
-          "orca_recent_project:/a/b/project.3mf:orca");
-    CHECK(AppAction::compose_id("orca_recent_project", "C:/Data/cube.3mf", "orca") ==
-          "orca_recent_project:C:/Data/cube.3mf:orca");
-}
-
-// A built-in command is keyed by its stable catalog key (not the localized display title), so a
-// rename or a UI-language switch never re-keys the action and its persisted favourite/stats survive.
-TEST_CASE("Command actions are keyed by catalog key, not display title", "[ActionSource][SpeedDial]")
-{
-    CHECK(AppAction::compose_id("orca_command", "save_project", "orca") == "orca_command:save_project:orca");
-    // The second field is the stable key, so distinct commands never collide.
-    CHECK(AppAction::compose_id("orca_command", "save_project", "orca") !=
-          AppAction::compose_id("orca_command", "load_project", "orca"));
-}
-
 // The real catalog -> action mapping keys by the stable catalog key and copies presentation from the
 // catalog, so a rename or a UI-language switch never re-keys the action. The catalog's English title
 // and group become the action's English search aliases; no translation catalog is loaded in the tests,

tests/slic3rutils/test_moonraker_printer_agent.cpp

@@ -150,13 +150,6 @@ public:
         return m_close_frames;
     }
 
-    // The printer answers a close frame before its own read completes, so the agent's stop can return first.
-    bool wait_for_close_frames(int count)
-    {
-        std::unique_lock<std::mutex> lock(m_mutex);
-        return m_changed.wait_for(lock, 10s, [&] { return m_close_frames >= count; });
-    }
-
     // Hangs up every connection that is waiting.
     void release()
     {
@@ -284,7 +277,6 @@ private:
                 if (ec == websocket::error::closed) {
                     std::lock_guard<std::mutex> lock(m_mutex);
                     ++m_close_frames;
-                    m_changed.notify_all();
                 }
                 if (ec)
                     reading = false;
@@ -457,7 +449,6 @@ TEST_CASE("Stopping the status stream sends the printer a close frame", "[Moonra
     REQUIRE(f.printer.wait_for_ready_connections(1));
 
     CHECK(f.stops_within(3s));
-    CHECK(f.printer.wait_for_close_frames(1));
     CHECK(f.printer.close_frames() == 1);
 }
 

tests/slic3rutils/test_plugin_audit.cpp

@@ -14,7 +14,6 @@
 #include <boost/filesystem.hpp>
 
 #include <string>
-#include <vector>
 
 using namespace Slic3r;
 namespace fs = boost::filesystem;
@@ -326,117 +325,6 @@ TEST_CASE("Plugin audit a read-only allowed root blocks writes but not reads", "
     }
 }
 
-TEST_CASE("Plugin audit network permissions match by scheme and host", "[audit]")
-{
-    SECTION("a URL is reduced to its scheme and host")
-    {
-        CHECK(PluginAuditManager::normalize_network_url("https://API.Example.com:8443/v1/items?page=2#top") ==
-              "https://api.example.com");
-        CHECK(PluginAuditManager::normalize_network_url("http://example.com") == "http://example.com");
-        CHECK(PluginAuditManager::normalize_network_url("https://[2001:db8::1]:443/path") == "https://[2001:db8::1]");
-    }
-
-    SECTION("non-http schemes and targets without a scheme are not network URLs")
-    {
-        CHECK(PluginAuditManager::normalize_network_url("ftp://example.com").empty());
-        CHECK(PluginAuditManager::normalize_network_url("api.example.com").empty());
-        CHECK(PluginAuditManager::normalize_network_url("https://").empty());
-    }
-
-    SECTION("a URL target matches the same scheme and host regardless of path and port")
-    {
-        const std::vector<std::string> granted{"https://api.example.com"};
-        CHECK(PluginAuditManager::network_permission_matches(granted, "https://api.example.com/v1/items?page=2"));
-        CHECK(PluginAuditManager::network_permission_matches(granted, "https://api.example.com:8443/upload"));
-    }
-
-    SECTION("a URL target does not match a different host or a different scheme")
-    {
-        const std::vector<std::string> granted{"https://api.example.com"};
-        CHECK_FALSE(PluginAuditManager::network_permission_matches(granted, "https://evil.example.com/v1"));
-        CHECK_FALSE(PluginAuditManager::network_permission_matches(granted, "http://api.example.com/v1"));
-    }
-
-    SECTION("a bare host target matches the host of a grant")
-    {
-        const std::vector<std::string> granted{"https://api.example.com"};
-        CHECK(PluginAuditManager::network_permission_matches(granted, "api.example.com"));
-        CHECK(PluginAuditManager::network_permission_matches(granted, "api.example.com:443"));
-        CHECK_FALSE(PluginAuditManager::network_permission_matches(granted, "other.example.com"));
-    }
-
-    SECTION("legacy persisted address tuples keep matching their host")
-    {
-        const std::vector<std::string> legacy_granted{"('api.example.com', 443)"};
-        CHECK(PluginAuditManager::network_permission_matches(legacy_granted, "api.example.com"));
-
-        const std::vector<std::string> granted{"https://api.example.com"};
-        CHECK(PluginAuditManager::network_permission_matches(granted, "('api.example.com', 443)"));
-        CHECK_FALSE(PluginAuditManager::network_permission_matches(granted, "('93.184.216.34', 443)"));
-    }
-
-    SECTION("an IPv6 literal matches across bracketed and bare forms")
-    {
-        const std::vector<std::string> granted{"https://[2001:db8::1]"};
-        CHECK(PluginAuditManager::network_permission_matches(granted, "2001:db8::1"));
-        CHECK(PluginAuditManager::network_permission_matches(granted, "[2001:db8::1]:443"));
-        CHECK_FALSE(PluginAuditManager::network_permission_matches(granted, "2001:db8::2"));
-    }
-
-    SECTION("a non-http URL only matches an exact grant")
-    {
-        const std::vector<std::string> granted{"ftp://example.com/file"};
-        CHECK(PluginAuditManager::network_permission_matches(granted, "ftp://example.com/file"));
-        CHECK_FALSE(PluginAuditManager::network_permission_matches(granted, "ftp://example.com/other"));
-
-        const std::vector<std::string> https{"https://api.example.com"};
-        CHECK_FALSE(PluginAuditManager::network_permission_matches(https, "ftp://api.example.com/file"));
-    }
-
-    SECTION("an empty grant list or an empty target never matches")
-    {
-        const std::vector<std::string> granted{};
-        CHECK_FALSE(PluginAuditManager::network_permission_matches(granted, "https://api.example.com"));
-
-        const std::vector<std::string> any{"https://api.example.com"};
-        CHECK_FALSE(PluginAuditManager::network_permission_matches(any, ""));
-    }
-}
-
-TEST_CASE("Plugin audit limits network ancestor approvals to resolved addresses", "[audit]")
-{
-    SECTION("IP literals are distinguished from hostnames and URLs")
-    {
-        CHECK(PluginAuditManager::is_ip_address_target("127.0.0.1"));
-        CHECK(PluginAuditManager::is_ip_address_target("93.184.216.34"));
-        CHECK(PluginAuditManager::is_ip_address_target("::1"));
-        CHECK(PluginAuditManager::is_ip_address_target("2001:db8::1"));
-        CHECK(PluginAuditManager::is_ip_address_target("[2001:db8::1]"));
-
-        CHECK_FALSE(PluginAuditManager::is_ip_address_target("api.example.com"));
-        CHECK_FALSE(PluginAuditManager::is_ip_address_target("localhost"));
-        CHECK_FALSE(PluginAuditManager::is_ip_address_target("https://api.example.com"));
-        CHECK_FALSE(PluginAuditManager::is_ip_address_target(""));
-    }
-
-    SECTION("a network approval is kept apart from the general call-site cascade")
-    {
-        PluginAuditManager& mgr = PluginAuditManager::instance();
-        const std::string   plugin_key = "plugin-audit-network-ancestor";
-        const std::string   other_key  = "plugin-audit-network-ancestor-other";
-
-        mgr.record_approved_network_call_sites(plugin_key, {"frame:network"});
-        mgr.record_approved_call_sites(plugin_key, {"frame:general"});
-
-        CHECK(mgr.has_approved_network_ancestor(plugin_key, {"frame:network"}));
-        CHECK_FALSE(mgr.has_approved_network_ancestor(plugin_key, {"frame:general"}));
-        CHECK_FALSE(mgr.has_approved_network_ancestor(other_key, {"frame:network"}));
-
-        // The network approval must not leak into the general cascade used by other categories.
-        CHECK_FALSE(mgr.has_approved_ancestor(plugin_key, {"frame:network"}));
-    }
-}
-
 TEST_CASE("Plugin audit a scoped root can also be registered read-only", "[audit]")
 {
     ScopedDataDir data_dir_guard("plugin-audit-scoped-readonly");

tests/slic3rutils/test_plugin_config.cpp

@@ -138,22 +138,6 @@ TEST_CASE("PluginConfig serializes the documented on-disk schema", "[PluginConfi
     CHECK(entry.size() == 5);
 }
 
-TEST_CASE("PluginConfig keeps a capability's config after its plugin goes away", "[PluginConfig]")
-{
-    ScopedDataDir data_dir_guard("plugin-config-retention");
-
-    {
-        PluginConfig config;
-        REQUIRE(config.store_capability_config(capability_id(PluginCapabilityType::Script, "cap_a", "plugin_a"), json{{"token", "keep me"}}));
-    }
-
-    // config.json is deliberately not keyed to installed plugins: a record outlives its plugin and is
-    // still there on reinstall. Asserts no cleanup path silently drops it.
-    PluginConfig after_removal;
-    after_removal.load();
-    CHECK(after_removal.get_config(capability_id(PluginCapabilityType::Script, "cap_a", "plugin_a"))->config == json{{"token", "keep me"}});
-}
-
 TEST_CASE("PluginConfig treats a missing config file as an empty store", "[PluginConfig]")
 {
     ScopedDataDir data_dir_guard("plugin-config-missing");