Keep the Process and Printer of an inherits_group of the Wrong Length

A project whose inherits_group did not have one entry per filament plus
the process and printer entries was loaded as if it had none. The CLI
then looked for system presets under the names of the user presets,
found none and refused to slice a project that slices on main.

The group is now read as before: the process first, the printer last
and the filaments in between, up to the filament count. A filament
without an entry counts as a system preset. A group with fewer than two
entries is still ignored. The warning stays.

src/OrcaSlicer.cpp

@@ -642,162 +642,6 @@ static void load_default_gcodes_to_config(DynamicPrintConfig& config, Preset::Ty
     }
 }
 
-static int load_assemble_plate_list(std::string config_file, std::vector<assemble_plate_info_t> &assemble_plate_info_list)
-{
-    int ret = 0;
-    boost::filesystem::path directory_path(config_file);
-
-    BOOST_LOG_TRIVIAL(info) << boost::format("%1% enter, file %2%")%__FUNCTION__ % config_file;
-    if (!fs::exists(directory_path)) {
-        BOOST_LOG_TRIVIAL(error) << boost::format("directory %1% not exist.")%config_file;
-        return CLI_FILE_NOTFOUND;
-    }
-
-    try {
-        json root_json;
-        boost::nowide::ifstream ifs(config_file);
-        ifs >> root_json;
-        ifs.close();
-
-        int plate_count = root_json[JSON_ASSEMPLE_PLATES].size();
-        if ((plate_count <= 0) || (plate_count > MAX_PLATE_COUNT)) {
-            BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": invalid plate count %1%")%plate_count;
-            return CLI_CONFIG_FILE_ERROR;
-        }
-        assemble_plate_info_list.resize(plate_count);
-
-        for (int plate_index = 0; plate_index < plate_count; plate_index++)
-        {
-            assemble_plate_info_t &assemble_plate = assemble_plate_info_list[plate_index];
-            const json& plate_json = root_json[JSON_ASSEMPLE_PLATES][plate_index];
-            assemble_plate.plate_name = plate_json[JSON_ASSEMPLE_PLATE_NAME];
-            assemble_plate.need_arrange = plate_json[JSON_ASSEMPLE_PLATE_NEED_ARRANGE];
-
-            if (plate_json.contains(JSON_ASSEMPLE_PLATE_PARAMS)) {
-                assemble_plate.plate_params = plate_json[JSON_ASSEMPLE_PLATE_PARAMS].get<std::map<std::string, std::string>>();
-                BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, has %2% plate params") % (plate_index + 1)  % assemble_plate.plate_params.size();
-            }
-
-            int object_count = plate_json[JSON_ASSEMPLE_OBJECTS].size();
-            if (object_count <= 0) {
-                BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": invalid object count %1% in plate %2%")%object_count %(plate_index+1);
-                return CLI_CONFIG_FILE_ERROR;
-            }
-
-            assemble_plate.assemble_obj_list.resize(object_count);
-            for (int object_index = 0; object_index < object_count; object_index++)
-            {
-                assemble_object_info_t& assemble_object = assemble_plate.assemble_obj_list[object_index];
-                const json& object_json = plate_json[JSON_ASSEMPLE_OBJECTS][object_index];
-
-                assemble_object.path = object_json[JSON_ASSEMPLE_OBJECT_PATH];
-                assemble_object.count = object_json[JSON_ASSEMPLE_OBJECT_COUNT];
-
-                if (assemble_object.count <= 0) {
-                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": invalid object clone count %1% in plate %2% Object %3%") % assemble_object.count % (plate_index + 1) % assemble_object.path;
-                    return CLI_CONFIG_FILE_ERROR;
-                }
-
-                assemble_object.filaments = object_json.at(JSON_ASSEMPLE_OBJECT_FILAMENTS).get<std::vector<int>>();
-                if ((assemble_object.filaments.size() > 0) && (assemble_object.filaments.size() != assemble_object.count) && (assemble_object.filaments.size() != 1))
-                {
-                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s filaments count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.filaments.size() % assemble_object.count;
-                    return CLI_CONFIG_FILE_ERROR;
-                }
-
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX)) {
-                    assemble_object.assemble_index = object_json[JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX].get<std::vector<int>>();
-                    if ((assemble_object.assemble_index.size() > 0) && (assemble_object.assemble_index.size() != assemble_object.count) && (assemble_object.assemble_index.size() != 1))
-                    {
-                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s assemble_index count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.assemble_index.size() % assemble_object.count;
-                        return CLI_CONFIG_FILE_ERROR;
-                    }
-                }
-
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_X)) {
-                    assemble_object.pos_x = object_json[JSON_ASSEMPLE_OBJECT_POS_X].get<std::vector<float>>();
-                    if ((assemble_object.pos_x.size() > 0) && (assemble_object.pos_x.size() != assemble_object.count) && (assemble_object.pos_x.size() != 1))
-                    {
-                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_x count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_x.size() % assemble_object.count;
-                        return CLI_CONFIG_FILE_ERROR;
-                    }
-                }
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_Y)) {
-                    assemble_object.pos_y = object_json[JSON_ASSEMPLE_OBJECT_POS_Y].get<std::vector<float>>();
-                    if ((assemble_object.pos_y.size() > 0) && (assemble_object.pos_y.size() != assemble_object.count) && (assemble_object.pos_y.size() != 1))
-                    {
-                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_y count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_y.size() % assemble_object.count;
-                        return CLI_CONFIG_FILE_ERROR;
-                    }
-                }
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_Z)) {
-                    assemble_object.pos_z = object_json[JSON_ASSEMPLE_OBJECT_POS_Z].get<std::vector<float>>();
-                    if ((assemble_object.pos_z.size() > 0) && (assemble_object.pos_z.size() != assemble_object.count) && (assemble_object.pos_z.size() != 1))
-                    {
-                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_z count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_z.size() % assemble_object.count;
-                        return CLI_CONFIG_FILE_ERROR;
-                    }
-                }
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_PRINT_PARAMS)) {
-                    assemble_object.print_params = object_json[JSON_ASSEMPLE_OBJECT_PRINT_PARAMS].get<std::map<std::string, std::string>>();
-                    BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, object %2% has %3% print params") % (plate_index + 1) %assemble_object.path % assemble_object.print_params.size();
-                }
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES)) {
-                    json height_range_json = object_json[JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES];
-                    int range_count = height_range_json.size();
-
-                    BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, object %2% has %3% height ranges") % (plate_index + 1) %assemble_object.path % range_count;
-
-                    assemble_object.height_ranges.resize(range_count);
-                    for (int range_index = 0; range_index < range_count; range_index++)
-                    {
-                        height_range_info_t& height_range = assemble_object.height_ranges[range_index];
-                        height_range.min_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MIN_Z];
-                        height_range.max_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MAX_Z];
-                        height_range.range_params = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_RANGE_PARAMS].get<std::map<std::string, std::string>>();
-                    }
-                }
-            }
-            if (plate_json.contains(JSON_ASSEMPLE_ASSEMBLE_PARAMS)) {
-                json assemble_params_json = plate_json[JSON_ASSEMPLE_ASSEMBLE_PARAMS];
-                int assemble_count = assemble_params_json.size();
-                for (int i = 0; i < assemble_count; i++)
-                {
-                    assembled_param_info_t assembled_param;
-                    int assemble_index = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX];
-                    if (assemble_params_json[i].contains(JSON_ASSEMPLE_OBJECT_PRINT_PARAMS)) {
-                        assembled_param.print_params = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_PRINT_PARAMS].get<std::map<std::string, std::string>>();
-                        BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, assemble object %2% has %3% print params") % (plate_index + 1) %i % assembled_param.print_params.size();
-                    }
-                    if (assemble_params_json[i].contains(JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES)) {
-                        json height_range_json = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES];
-                        int range_count = height_range_json.size();
-
-                        BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, assemble object %2% has %3% height ranges") % (plate_index + 1) %i % range_count;
-
-                        assembled_param.height_ranges.resize(range_count);
-                        for (int range_index = 0; range_index < range_count; range_index++)
-                        {
-                            height_range_info_t& height_range = assembled_param.height_ranges[range_index];
-                            height_range.min_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MIN_Z];
-                            height_range.max_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MAX_Z];
-                            height_range.range_params = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_RANGE_PARAMS].get<std::map<std::string, std::string>>();
-                        }
-                    }
-                    assemble_plate.assembled_param_list.emplace(assemble_index, std::move(assembled_param));
-                }
-                BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, has %2% plate params") % (plate_index + 1)  % assemble_plate.plate_params.size();
-            }
-        }
-    }
-    catch(std::exception &err) {
-        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse file "<<config_file<<" got a generic exception, reason = " << err.what();
-        ret = CLI_CONFIG_FILE_ERROR;
-    }
-
-    return ret;
-}
-
 void merge_or_add_object(assemble_plate_info_t& assemble_plate_info, Model &model, int assemble_index, std::map<int, ModelObject*> &merged_objects, ModelObject *ori_object)
 {
     if (assemble_index > 0) {
@@ -1863,6 +1707,14 @@ int CLI::run(int argc, char **argv)
 
                     BOOST_LOG_TRIVIAL(info) << boost::format("current_printer_name %1%, current_process_name %2%")%current_printer_name %current_process_name;
                     ConfigOptionStrings* option_strings = config.option<ConfigOptionStrings>("inherits_group");
+                    // One entry for the process, one per filament and one for the printer. A group of another
+                    // length still has the process first and the printer last; one too short for that is ignored.
+                    if (option_strings && option_strings->values.size() != current_filaments_name.size() + 2) {
+                        boost::nowide::cerr << "Warning: inherits_group has " << option_strings->values.size() << " entries, expected "
+                                            << current_filaments_name.size() + 2 << " for " << current_filaments_name.size() << " filaments" << std::endl;
+                        if (option_strings->values.size() < 2)
+                            option_strings = nullptr;
+                    }
                     if (option_strings) {
                         current_inherits_group = option_strings->values;
                         size_t size = current_inherits_group.size();
@@ -1884,16 +1736,13 @@ int CLI::run(int argc, char **argv)
                             BOOST_LOG_TRIVIAL(info) << boost::format("inherits of process valid, current_process_system_name is %1%") %current_process_system_name;
                         }
 
-                        current_filaments_system_name.resize(size - 2);
+                        // A filament without an entry of its own counts as a system preset.
-                        for (int index = 1; index < (size - 1); index++) {
+                        current_filaments_system_name = current_filaments_name;
-                            if (current_inherits_group[index].empty()) {
+                        for (size_t index = 1; index < size - 1 && index <= current_filaments_name.size(); index++) {
-                                current_filaments_system_name[index-1] = current_filaments_name[index-1];
+                            if (!current_inherits_group[index].empty())
-                            }
-                            else {
                                 current_filaments_system_name[index-1] = current_inherits_group[index];
                         }
                     }
-                    }
                     else {
                         current_printer_system_name = current_printer_name;
                         current_process_system_name = current_process_name;
@@ -2023,7 +1872,12 @@ int CLI::run(int argc, char **argv)
         //parse the json and assemble object here
         Model model;
 
-        int ret = load_assemble_plate_list(load_assemble_list, assemble_plate_info_list);
+        AssembleListResult list_result = load_assemble_plate_list(load_assemble_list, assemble_plate_info_list, MAX_PLATE_COUNT);
+        int ret = CLI_SUCCESS;
+        if (list_result == AssembleListResult::FileNotFound)
+            ret = CLI_FILE_NOTFOUND;
+        else if (list_result == AssembleListResult::ConfigError)
+            ret = CLI_CONFIG_FILE_ERROR;
         if (ret) {
             record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
             flush_and_exit(ret);
@@ -4733,6 +4587,11 @@ int CLI::run(int argc, char **argv)
                 record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                 flush_and_exit(CLI_INVALID_PARAMS);
             }
+            if (m_models.empty()) {
+                boost::nowide::cerr << "Invalid params: --assemble needs at least one input model." << std::endl;
+                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
+                flush_and_exit(CLI_INVALID_PARAMS);
+            }
             Model m;
             ModelObject* new_object = m.add_object();
             new_object->name = _u8L("Assembly");
@@ -5673,7 +5532,7 @@ int CLI::run(int argc, char **argv)
                         float w = dynamic_cast<const ConfigOptionFloat *>(m_print_config.option("prime_tower_width"))->value;
                         float a = dynamic_cast<const ConfigOptionFloat *>(m_print_config.option("wipe_tower_rotation_angle"))->value;
                         float v = dynamic_cast<const ConfigOptionFloat *>(m_print_config.option("prime_volume"))->value;
-                        unsigned int filaments_cnt = plate_data_src[plate_to_slice-1]->slice_filaments_info.size();
+                        unsigned int filaments_cnt = (plate_data_src.size() >= static_cast<size_t>(plate_to_slice)) ? plate_data_src[plate_to_slice-1]->slice_filaments_info.size() : 0;
                         if ((filaments_cnt == 0) || need_skip)
                         {
                             // slice filaments info invalid

src/OrcaSlicer.hpp

@@ -5,6 +5,7 @@
 
 #include "libslic3r/Config.hpp"
 #include "libslic3r/Model.hpp"
+#include "libslic3r/Format/AssembleList.hpp"
 
 namespace Slic3r {
 
@@ -19,64 +20,6 @@ namespace IO {
     };
 }
 
-#define JSON_ASSEMPLE_PLATES                   "plates"
-#define JSON_ASSEMPLE_PLATE_PARAMS             "plate_params"
-#define JSON_ASSEMPLE_PLATE_NAME               "plate_name"
-#define JSON_ASSEMPLE_PLATE_NEED_ARRANGE       "need_arrange"
-#define JSON_ASSEMPLE_OBJECTS                  "objects"
-#define JSON_ASSEMPLE_OBJECT_PATH              "path"
-#define JSON_ASSEMPLE_OBJECT_COUNT             "count"
-#define JSON_ASSEMPLE_OBJECT_FILAMENTS         "filaments"
-#define JSON_ASSEMPLE_OBJECT_POS_X             "pos_x"
-#define JSON_ASSEMPLE_OBJECT_POS_Y             "pos_y"
-#define JSON_ASSEMPLE_OBJECT_POS_Z             "pos_z"
-#define JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX    "assemble_index"
-#define JSON_ASSEMPLE_OBJECT_PRINT_PARAMS      "print_params"
-#define JSON_ASSEMPLE_ASSEMBLE_PARAMS         "assembled_params"
-
-
-#define JSON_ASSEMPLE_OBJECT_MIN_Z              "min_z"
-#define JSON_ASSEMPLE_OBJECT_MAX_Z              "max_z"
-#define JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES      "height_ranges"
-#define JSON_ASSEMPLE_OBJECT_RANGE_PARAMS       "range_params"
-
-typedef struct _height_range_info {
-    float         min_z;
-    float         max_z;
-
-    std::map<std::string, std::string> range_params;
-}height_range_info_t;
-
-typedef struct _assembled_param_info {
-    std::map<std::string, std::string> print_params;
-    std::vector<height_range_info_t> height_ranges;
-}assembled_param_info_t;
-
-typedef struct _assemble_object_info {
-    std::string         path;
-    int                 count;
-
-    std::vector<int>    filaments;
-    std::vector<int>    assemble_index;
-    std::vector<float>  pos_x;
-    std::vector<float>  pos_y;
-    std::vector<float>  pos_z;
-    std::map<std::string, std::string> print_params;
-    std::vector<height_range_info_t> height_ranges;
-}assemble_object_info_t;
-
-typedef struct _assemble_plate_info {
-    std::string         plate_name;
-    bool                need_arrange {false};
-    int                 filaments_count {0};
-
-    std::map<std::string, std::string> plate_params;
-    std::vector<assemble_object_info_t> assemble_obj_list;
-    std::vector<ModelObject *> loaded_obj_list;
-    std::map<int, assembled_param_info_t> assembled_param_list;
-}assemble_plate_info_t;
-
-
 typedef struct _printer_plate_info {
     std::string         printer_name;
     int                 printable_width{0};

src/libslic3r/CMakeLists.txt

@@ -205,6 +205,8 @@ set(lisbslic3r_sources
     Format/3mf.hpp
     Format/AMF.cpp
     Format/AMF.hpp
+    Format/AssembleList.cpp
+    Format/AssembleList.hpp
     Format/DRC.cpp
     Format/DRC.hpp
     Format/bbs_3mf.cpp

src/libslic3r/Fill/Fill.cpp

@@ -1692,9 +1692,9 @@ void Layer::make_ironing()
 				ironing_params.just_infill 	= false;
 				// ORCA: Get filament-specific overrides if configured, otherwise use process values
 				size_t extruder_idx = ironing_params.extruder - 1;
-				ironing_params.line_spacing = std::max(IRONING_SPACING_MIN, !config.filament_ironing_spacing.is_nil(extruder_idx)
+				ironing_params.line_spacing = (!config.filament_ironing_spacing.is_nil(extruder_idx)
 					? config.filament_ironing_spacing.get_at(extruder_idx)
-					: config.ironing_spacing.value);
+					: config.ironing_spacing);
                 ironing_params.inset = (!config.filament_ironing_inset.is_nil(extruder_idx)
 					? config.filament_ironing_inset.get_at(extruder_idx)
 					: config.ironing_inset);

src/libslic3r/Fill/FillConcentric.cpp

@@ -22,9 +22,6 @@ void FillConcentric::_fill_surface_single(
     
     coord_t min_spacing = scale_(this->spacing) * params.multiline;
     coord_t distance = coord_t(min_spacing / params.density);
-    // A non-positive step never shrinks the region, so the inset loop below would not end.
-    if (min_spacing <= 0 || distance <= 0)
-        return;
     
     if (params.density > 0.9999f && !params.dont_adjust) {
         distance = this->_adjust_solid_spacing(bounding_box.size()(0), distance);
@@ -111,8 +108,6 @@ void FillConcentric::_fill_surface_single(const FillParams& params,
     // no rotation is supported for this infill pattern
     Point   bbox_size = expolygon.contour.bounding_box().size();
     coord_t min_spacing = scaled<coord_t>(this->spacing);
-    if (min_spacing <= 0)
-        return;
 
     if (params.density > 0.9999f && !params.dont_adjust) {
         coord_t                loops_count = std::max(bbox_size.x(), bbox_size.y()) / min_spacing + 1;

src/libslic3r/Format/AssembleList.cpp

@@ -0,0 +1,204 @@
+#include "AssembleList.hpp"
+
+#include <algorithm>
+
+#include <boost/filesystem.hpp>
+#include <boost/format.hpp>
+#include <boost/log/trivial.hpp>
+#include <boost/nowide/fstream.hpp>
+
+#include "nlohmann/json.hpp"
+
+#define JSON_ASSEMPLE_PLATES                   "plates"
+#define JSON_ASSEMPLE_PLATE_PARAMS             "plate_params"
+#define JSON_ASSEMPLE_PLATE_NAME               "plate_name"
+#define JSON_ASSEMPLE_PLATE_NEED_ARRANGE       "need_arrange"
+#define JSON_ASSEMPLE_OBJECTS                  "objects"
+#define JSON_ASSEMPLE_OBJECT_PATH              "path"
+#define JSON_ASSEMPLE_OBJECT_COUNT             "count"
+#define JSON_ASSEMPLE_OBJECT_FILAMENTS         "filaments"
+#define JSON_ASSEMPLE_OBJECT_POS_X             "pos_x"
+#define JSON_ASSEMPLE_OBJECT_POS_Y             "pos_y"
+#define JSON_ASSEMPLE_OBJECT_POS_Z             "pos_z"
+#define JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX    "assemble_index"
+#define JSON_ASSEMPLE_OBJECT_PRINT_PARAMS      "print_params"
+#define JSON_ASSEMPLE_ASSEMBLE_PARAMS         "assembled_params"
+
+
+#define JSON_ASSEMPLE_OBJECT_MIN_Z              "min_z"
+#define JSON_ASSEMPLE_OBJECT_MAX_Z              "max_z"
+#define JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES      "height_ranges"
+#define JSON_ASSEMPLE_OBJECT_RANGE_PARAMS       "range_params"
+
+namespace Slic3r {
+
+using json = nlohmann::json;
+
+AssembleListResult load_assemble_plate_list(const std::string &config_file, std::vector<assemble_plate_info_t> &assemble_plate_info_list, int max_plate_count)
+{
+    AssembleListResult ret = AssembleListResult::Success;
+    boost::filesystem::path directory_path(config_file);
+
+    BOOST_LOG_TRIVIAL(info) << boost::format("%1% enter, file %2%")%__FUNCTION__ % config_file;
+    if (!boost::filesystem::exists(directory_path)) {
+        BOOST_LOG_TRIVIAL(error) << boost::format("directory %1% not exist.")%config_file;
+        return AssembleListResult::FileNotFound;
+    }
+
+    try {
+        json root_json;
+        boost::nowide::ifstream ifs(config_file);
+        ifs >> root_json;
+        ifs.close();
+
+        int plate_count = root_json[JSON_ASSEMPLE_PLATES].size();
+        if ((plate_count <= 0) || (plate_count > max_plate_count)) {
+            BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": invalid plate count %1%")%plate_count;
+            return AssembleListResult::ConfigError;
+        }
+        assemble_plate_info_list.resize(plate_count);
+
+        for (int plate_index = 0; plate_index < plate_count; plate_index++)
+        {
+            assemble_plate_info_t &assemble_plate = assemble_plate_info_list[plate_index];
+            const json& plate_json = root_json[JSON_ASSEMPLE_PLATES][plate_index];
+            assemble_plate.plate_name = plate_json[JSON_ASSEMPLE_PLATE_NAME];
+            assemble_plate.need_arrange = plate_json[JSON_ASSEMPLE_PLATE_NEED_ARRANGE];
+
+            if (plate_json.contains(JSON_ASSEMPLE_PLATE_PARAMS)) {
+                assemble_plate.plate_params = plate_json[JSON_ASSEMPLE_PLATE_PARAMS].get<std::map<std::string, std::string>>();
+                BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, has %2% plate params") % (plate_index + 1)  % assemble_plate.plate_params.size();
+            }
+
+            int object_count = plate_json[JSON_ASSEMPLE_OBJECTS].size();
+            if (object_count <= 0) {
+                BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": invalid object count %1% in plate %2%")%object_count %(plate_index+1);
+                return AssembleListResult::ConfigError;
+            }
+
+            assemble_plate.assemble_obj_list.resize(object_count);
+            for (int object_index = 0; object_index < object_count; object_index++)
+            {
+                assemble_object_info_t& assemble_object = assemble_plate.assemble_obj_list[object_index];
+                const json& object_json = plate_json[JSON_ASSEMPLE_OBJECTS][object_index];
+
+                assemble_object.path = object_json[JSON_ASSEMPLE_OBJECT_PATH];
+                assemble_object.count = object_json[JSON_ASSEMPLE_OBJECT_COUNT];
+
+                if (assemble_object.count <= 0) {
+                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": invalid object clone count %1% in plate %2% Object %3%") % assemble_object.count % (plate_index + 1) % assemble_object.path;
+                    return AssembleListResult::ConfigError;
+                }
+
+                assemble_object.filaments = object_json.at(JSON_ASSEMPLE_OBJECT_FILAMENTS).get<std::vector<int>>();
+                if (assemble_object.filaments.empty())
+                {
+                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s filaments list is empty") % assemble_object.path;
+                    return AssembleListResult::ConfigError;
+                }
+                if ((assemble_object.filaments.size() != assemble_object.count) && (assemble_object.filaments.size() != 1))
+                {
+                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s filaments count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.filaments.size() % assemble_object.count;
+                    return AssembleListResult::ConfigError;
+                }
+                // 0 keeps the default filament, as it does for --load-filament-ids.
+                if (std::any_of(assemble_object.filaments.begin(), assemble_object.filaments.end(), [](int id) { return id < 0; }))
+                {
+                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1% has a negative filament id") % assemble_object.path;
+                    return AssembleListResult::ConfigError;
+                }
+
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX)) {
+                    assemble_object.assemble_index = object_json[JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX].get<std::vector<int>>();
+                    if ((assemble_object.assemble_index.size() > 0) && (assemble_object.assemble_index.size() != assemble_object.count) && (assemble_object.assemble_index.size() != 1))
+                    {
+                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s assemble_index count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.assemble_index.size() % assemble_object.count;
+                        return AssembleListResult::ConfigError;
+                    }
+                }
+
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_X)) {
+                    assemble_object.pos_x = object_json[JSON_ASSEMPLE_OBJECT_POS_X].get<std::vector<float>>();
+                    if ((assemble_object.pos_x.size() > 0) && (assemble_object.pos_x.size() != assemble_object.count) && (assemble_object.pos_x.size() != 1))
+                    {
+                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_x count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_x.size() % assemble_object.count;
+                        return AssembleListResult::ConfigError;
+                    }
+                }
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_Y)) {
+                    assemble_object.pos_y = object_json[JSON_ASSEMPLE_OBJECT_POS_Y].get<std::vector<float>>();
+                    if ((assemble_object.pos_y.size() > 0) && (assemble_object.pos_y.size() != assemble_object.count) && (assemble_object.pos_y.size() != 1))
+                    {
+                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_y count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_y.size() % assemble_object.count;
+                        return AssembleListResult::ConfigError;
+                    }
+                }
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_Z)) {
+                    assemble_object.pos_z = object_json[JSON_ASSEMPLE_OBJECT_POS_Z].get<std::vector<float>>();
+                    if ((assemble_object.pos_z.size() > 0) && (assemble_object.pos_z.size() != assemble_object.count) && (assemble_object.pos_z.size() != 1))
+                    {
+                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_z count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_z.size() % assemble_object.count;
+                        return AssembleListResult::ConfigError;
+                    }
+                }
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_PRINT_PARAMS)) {
+                    assemble_object.print_params = object_json[JSON_ASSEMPLE_OBJECT_PRINT_PARAMS].get<std::map<std::string, std::string>>();
+                    BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, object %2% has %3% print params") % (plate_index + 1) %assemble_object.path % assemble_object.print_params.size();
+                }
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES)) {
+                    json height_range_json = object_json[JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES];
+                    int range_count = height_range_json.size();
+
+                    BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, object %2% has %3% height ranges") % (plate_index + 1) %assemble_object.path % range_count;
+
+                    assemble_object.height_ranges.resize(range_count);
+                    for (int range_index = 0; range_index < range_count; range_index++)
+                    {
+                        height_range_info_t& height_range = assemble_object.height_ranges[range_index];
+                        height_range.min_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MIN_Z];
+                        height_range.max_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MAX_Z];
+                        height_range.range_params = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_RANGE_PARAMS].get<std::map<std::string, std::string>>();
+                    }
+                }
+            }
+            if (plate_json.contains(JSON_ASSEMPLE_ASSEMBLE_PARAMS)) {
+                json assemble_params_json = plate_json[JSON_ASSEMPLE_ASSEMBLE_PARAMS];
+                int assemble_count = assemble_params_json.size();
+                for (int i = 0; i < assemble_count; i++)
+                {
+                    assembled_param_info_t assembled_param;
+                    int assemble_index = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX];
+                    if (assemble_params_json[i].contains(JSON_ASSEMPLE_OBJECT_PRINT_PARAMS)) {
+                        assembled_param.print_params = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_PRINT_PARAMS].get<std::map<std::string, std::string>>();
+                        BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, assemble object %2% has %3% print params") % (plate_index + 1) %i % assembled_param.print_params.size();
+                    }
+                    if (assemble_params_json[i].contains(JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES)) {
+                        json height_range_json = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES];
+                        int range_count = height_range_json.size();
+
+                        BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, assemble object %2% has %3% height ranges") % (plate_index + 1) %i % range_count;
+
+                        assembled_param.height_ranges.resize(range_count);
+                        for (int range_index = 0; range_index < range_count; range_index++)
+                        {
+                            height_range_info_t& height_range = assembled_param.height_ranges[range_index];
+                            height_range.min_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MIN_Z];
+                            height_range.max_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MAX_Z];
+                            height_range.range_params = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_RANGE_PARAMS].get<std::map<std::string, std::string>>();
+                        }
+                    }
+                    assemble_plate.assembled_param_list.emplace(assemble_index, std::move(assembled_param));
+                }
+                BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, has %2% plate params") % (plate_index + 1)  % assemble_plate.plate_params.size();
+            }
+        }
+    }
+    catch(std::exception &err) {
+        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse file "<<config_file<<" got a generic exception, reason = " << err.what();
+        ret = AssembleListResult::ConfigError;
+    }
+
+    return ret;
+}
+
+} // namespace Slic3r

src/libslic3r/Format/AssembleList.hpp

@@ -0,0 +1,60 @@
+#ifndef slic3r_Format_AssembleList_hpp_
+#define slic3r_Format_AssembleList_hpp_
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Slic3r {
+
+class ModelObject;
+
+typedef struct _height_range_info {
+    float         min_z;
+    float         max_z;
+
+    std::map<std::string, std::string> range_params;
+}height_range_info_t;
+
+typedef struct _assembled_param_info {
+    std::map<std::string, std::string> print_params;
+    std::vector<height_range_info_t> height_ranges;
+}assembled_param_info_t;
+
+typedef struct _assemble_object_info {
+    std::string         path;
+    int                 count;
+
+    std::vector<int>    filaments;
+    std::vector<int>    assemble_index;
+    std::vector<float>  pos_x;
+    std::vector<float>  pos_y;
+    std::vector<float>  pos_z;
+    std::map<std::string, std::string> print_params;
+    std::vector<height_range_info_t> height_ranges;
+}assemble_object_info_t;
+
+typedef struct _assemble_plate_info {
+    std::string         plate_name;
+    bool                need_arrange {false};
+    int                 filaments_count {0};
+
+    std::map<std::string, std::string> plate_params;
+    std::vector<assemble_object_info_t> assemble_obj_list;
+    std::vector<ModelObject *> loaded_obj_list;
+    std::map<int, assembled_param_info_t> assembled_param_list;
+}assemble_plate_info_t;
+
+enum class AssembleListResult {
+    Success,
+    FileNotFound,
+    // Malformed JSON, a missing required field, or a value that fails validation.
+    ConfigError
+};
+
+// Read the JSON assemble list used by the CLI's --load-assemble-list into one entry per plate.
+AssembleListResult load_assemble_plate_list(const std::string &config_file, std::vector<assemble_plate_info_t> &assemble_plate_info_list, int max_plate_count);
+
+} // namespace Slic3r
+
+#endif /* slic3r_Format_AssembleList_hpp_ */

src/libslic3r/GCode.cpp

@@ -2504,8 +2504,7 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
 
     {
         LifecycleEventContext ctx;
-        ctx.id = std::to_string(print->model().id().id);
+        ctx.name = std::to_string(print->model().id().id);
-        ctx.name = print->get_model_name();
         ctx.code = LifecycleEvtCode::Ok;
         ctx.msg  = path;
         ctx.cancellation_check = [print]() { return print->canceled(); };
@@ -2557,8 +2556,7 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
         }
         {
             LifecycleEventContext ctx;
-            ctx.id = std::to_string(print->model().id().id);
+            ctx.name = std::to_string(print->model().id().id);
-            ctx.name = print->get_model_name();
             ctx.code = LifecycleEvtCode::Error;
             ctx.msg  = std::string(path) + "\n" + err_msg;
             ctx.cancellation_check = [print]() { return print->canceled(); };
@@ -2582,8 +2580,7 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
         boost::nowide::remove(path_tmp.c_str());
         {
             LifecycleEventContext ctx;
-            ctx.id = std::to_string(print->model().id().id);
+            ctx.name = std::to_string(print->model().id().id);
-            ctx.name = print->get_model_name();
             ctx.code = LifecycleEvtCode::Error;
             ctx.msg  = std::string(path) + "\n" + ex.what();
             ctx.cancellation_check = [print]() { return print->canceled(); };
@@ -2696,8 +2693,7 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
     if (ret) {
         {
             LifecycleEventContext ctx;
-            ctx.id = std::to_string(print->model().id().id);
+            ctx.name = std::to_string(print->model().id().id);
-            ctx.name = print->get_model_name();
             ctx.code = LifecycleEvtCode::Error;
             ctx.msg  = std::string(path) + "\nFailed to rename the output G-code file: " + ret.message();
             ctx.cancellation_check = [print]() { return print->canceled(); };
@@ -2716,8 +2712,7 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
 
     {
         LifecycleEventContext ctx;
-        ctx.id = std::to_string(print->model().id().id);
+        ctx.name = std::to_string(print->model().id().id);
-        ctx.name = print->get_model_name();
         ctx.code = LifecycleEvtCode::Ok;
         ctx.msg  = path;
         ctx.cancellation_check = [print]() { return print->canceled(); };

src/libslic3r/Print.cpp

@@ -2717,8 +2717,7 @@ void Print::process(long long *time_cost_with_cache, bool use_cache)
 
     {
         LifecycleEventContext ctx;
-        ctx.id = std::to_string(m_model.id().id);
+        ctx.name = std::to_string(m_model.id().id);
-        ctx.name = get_model_name();
         ctx.code = LifecycleEvtCode::Ok;
         ctx.cancellation_check = [this]() { return canceled(); };
         fire_lifecycle_event(LifecycleEvent::SliceStarted, ctx);
@@ -3345,8 +3344,7 @@ void Print::process(long long *time_cost_with_cache, bool use_cache)
 
     {
         LifecycleEventContext ctx;
-        ctx.id = std::to_string(m_model.id().id);
+        ctx.name = std::to_string(m_model.id().id);
-        ctx.name = get_model_name();
         ctx.code = LifecycleEvtCode::Ok;
         ctx.cancellation_check = [this]() { return canceled(); };
         fire_lifecycle_event(LifecycleEvent::SliceGeometryFinished, ctx);
@@ -4952,8 +4950,7 @@ void Print::export_gcode_from_previous_file(const std::string& file, GCodeProces
 {
     {
         LifecycleEventContext ctx;
-        ctx.id = std::to_string(m_model.id().id);
+        ctx.name = std::to_string(m_model.id().id);
-        ctx.name = get_model_name();
         ctx.code = LifecycleEvtCode::Ok;
         ctx.msg  = file;
         ctx.cancellation_check = [this]() { return canceled(); };
@@ -4983,8 +4980,7 @@ void Print::export_gcode_from_previous_file(const std::string& file, GCodeProces
         BOOST_LOG_TRIVIAL(error) << __FUNCTION__ <<  boost::format(": found errors when process gcode file %1%") %file.c_str();
         {
             LifecycleEventContext ctx;
-            ctx.id = std::to_string(m_model.id().id);
+            ctx.name = std::to_string(m_model.id().id);
-            ctx.name = get_model_name();
             ctx.code = LifecycleEvtCode::Error;
             ctx.msg  = file + "\n" + ex.what();
             ctx.cancellation_check = [this]() { return canceled(); };
@@ -4998,8 +4994,7 @@ void Print::export_gcode_from_previous_file(const std::string& file, GCodeProces
 
     {
         LifecycleEventContext ctx;
-        ctx.id = std::to_string(m_model.id().id);
+        ctx.name = std::to_string(m_model.id().id);
-        ctx.name = get_model_name();
         ctx.code = LifecycleEvtCode::Ok;
         ctx.msg  = file;
         ctx.cancellation_check = [this]() { return canceled(); };

src/libslic3r/PrintConfig.hpp

@@ -178,10 +178,6 @@ enum class IroningType {
     Count,
 };
 
-// Smallest usable ironing line spacing. Anything tighter yields an unprintable number of lines,
-// and zero stops the fillers from making progress.
-constexpr double IRONING_SPACING_MIN = 0.05;
-
 //BBS
 enum class WallInfillOrder {
     InnerOuterInfill,

src/libslic3r/Support/SupportParameters.hpp

@@ -64,7 +64,7 @@ struct SupportParameters {
 
         this->ironing = object_config.support_ironing;
         this->ironing_flow = support_material_interface_flow.with_height(support_material_interface_flow.height() * 0.01 * object_config.support_ironing_flow.value);
-        this->ironing_spacing = std::max(IRONING_SPACING_MIN, object_config.support_ironing_spacing.value);
+        this->ironing_spacing = object_config.support_ironing_spacing;
         this->ironing_pattern = object_config.support_ironing_pattern;
 
         // Calculate a minimum support layer height as a minimum over all extruders, but not smaller than 10um.

src/slic3r/GUI/ConfigManipulation.cpp

@@ -210,30 +210,6 @@ void ConfigManipulation::check_filament_max_volumetric_speed(DynamicPrintConfig
 
 }
 
-void ConfigManipulation::check_filament_ironing_spacing(DynamicPrintConfig *config)
-{
-    const auto *opt = config->option<ConfigOptionFloatsNullable>("filament_ironing_spacing");
-    if (opt == nullptr)
-        return;
-    std::vector<double> values = opt->values;
-    bool                reset  = false;
-    for (size_t i = 0; i < values.size(); ++i)
-        if (!opt->is_nil(i) && values[i] < IRONING_SPACING_MIN) {
-            values[i] = 0.1;
-            reset     = true;
-        }
-    if (!reset)
-        return;
-    const wxString     msg_text = _(L("Ironing spacing too small\nIt has been reset to 0.1"));
-    MessageDialog      dialog(nullptr, msg_text, "", wxICON_WARNING | wxOK);
-    DynamicPrintConfig new_conf = *config;
-    is_msg_dlg_already_exist    = true;
-    dialog.ShowModal();
-    new_conf.set_key_value("filament_ironing_spacing", new ConfigOptionFloatsNullable(values));
-    apply(config, &new_conf);
-    is_msg_dlg_already_exist = false;
-}
-
 void ConfigManipulation::check_chamber_temperature(DynamicPrintConfig* config)
 {
    bool support_chamber_temp_control=GUI::wxGetApp().preset_bundle->printers.get_selected_preset().config.opt_bool("support_chamber_temp_control");
@@ -356,7 +332,7 @@ void ConfigManipulation::update_print_fff_config(DynamicPrintConfig* config, con
     }
 
     //BBS: ironing_spacing shouldn't be too small or equal to zero
-    if (config->opt_float("ironing_spacing") < IRONING_SPACING_MIN)
+    if (config->opt_float("ironing_spacing") < 0.05)
     {
         const wxString msg_text = _(L("Ironing spacing too small\nIt has been reset to 0.1"));
         MessageDialog dialog(nullptr, msg_text, "", wxICON_WARNING | wxOK);
@@ -367,7 +343,7 @@ void ConfigManipulation::update_print_fff_config(DynamicPrintConfig* config, con
         apply(config, &new_conf);
         is_msg_dlg_already_exist = false;
     }
-    if (config->opt_float("support_ironing_spacing") < IRONING_SPACING_MIN)
+    if (config->opt_float("support_ironing_spacing") < 0.05)
     {
         const wxString msg_text = _(L("Ironing spacing too small\nIt has been reset to 0.1"));
         MessageDialog dialog(nullptr, msg_text, "", wxICON_WARNING | wxOK);

src/slic3r/GUI/ConfigManipulation.hpp

@@ -84,7 +84,6 @@ public:
     void    check_nozzle_temperature_initial_layer_range(DynamicPrintConfig* config);
     void    check_adaptive_pressure_advance_model(DynamicPrintConfig* config);
     void    check_filament_max_volumetric_speed(DynamicPrintConfig *config);
-    void    check_filament_ironing_spacing(DynamicPrintConfig *config);
     void    check_chamber_temperature(DynamicPrintConfig* config);
     void    check_chamber_minimal_temperature(DynamicPrintConfig* config);
     bool    check_layer_height(DynamicPrintConfig* config);

src/slic3r/GUI/Plater.cpp

@@ -12800,6 +12800,8 @@ void Plater::priv::on_process_completed(SlicingProcessCompletedEvent &evt)
     notification_manager->set_slicing_progress_export_possible();
 
     // Reset the "export G-code path" name, so that the automatic background processing will be enabled again.
+    const std::string lifecycle_job_name = this->background_process.fff_print() ?
+        this->background_process.fff_print()->output_filename() : std::string();
     this->background_process.reset_export();
     // This bool stops showing export finished notification even when process_completed_with_error is false
     bool has_error = false;
@@ -12846,18 +12848,8 @@ void Plater::priv::on_process_completed(SlicingProcessCompletedEvent &evt)
 
     {
         Slic3r::LifecycleEventContext ctx;
-        if (const PrintBase* print = this->background_process.current_print()) {
+        ctx.name = lifecycle_job_name;
-            const Model& model = print->model();
+        ctx.code = evt.cancelled() ? Slic3r::LifecycleEvtCode::Warn : (has_error ? Slic3r::LifecycleEvtCode::Error : Slic3r::LifecycleEvtCode::Ok);
-            ctx.id             = std::to_string(model.id().id);
-            if (model.model_info)
-                ctx.name = model.model_info->model_name;
-        } else {
-            // Realistically Printbase* print will never be null because select_technology already asserts an active print
-            // and the worker thread asserts it before processing.
-            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": slicing completed without an active print; lifecycle event has no model ID";
-        }
-        ctx.code = evt.cancelled() ? Slic3r::LifecycleEvtCode::Warn :
-                                     (has_error ? Slic3r::LifecycleEvtCode::Error : Slic3r::LifecycleEvtCode::Ok);
         ctx.msg  = evt.cancelled() ? "cancelled" : (has_error ? lifecycle_error_msg : std::string());
         Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::SlicingJobComplete, ctx);
     }

src/slic3r/GUI/Tab.cpp

@@ -4905,7 +4905,6 @@ void TabFilament::update()
         return; // ys_FIXME
 
     m_config_manipulation.check_filament_max_volumetric_speed(m_config);
-    m_config_manipulation.check_filament_ironing_spacing(m_config);
 
     m_update_cnt++;
 

src/slic3r/Utils/PrintHost.cpp

@@ -6,7 +6,6 @@
 #include <boost/optional.hpp>
 #include <boost/log/trivial.hpp>
 #include <boost/filesystem.hpp>
-#include <nlohmann/json.hpp>
 
 #include <wx/string.h>
 #include <wx/app.h>
@@ -116,67 +115,10 @@ std::string PrintHost::get_print_host_webui(DynamicPrintConfig* config)
     return webui_url;
 }
 
-namespace {
-
-// Moonraker (Klipper's API server) reports a raised exception as { "error": { "code", "message", "traceback" } }
-// under every host type that connects to it, often with the cause only in the traceback. Returns the reason to show,
-// or empty for any other body.
-std::string moonraker_error_reason(const std::string &body)
-{
-    const auto root = nlohmann::json::parse(body, nullptr, false);
-    const auto err  = root.find("error");
-    if (err == root.end())
-        return {};
-    const auto message   = err->find("message");
-    const auto traceback = err->find("traceback");
-    if (message == err->end() || traceback == err->end() || !message->is_string() || !traceback->is_string())
-        return {};
-
-    const auto &msg = message->get_ref<const std::string &>();
-    const auto &tb  = traceback->get_ref<const std::string &>();
-    if (msg.empty())
-        return {};
-    const auto end = tb.find_last_not_of(" \t\r\n");
-    if (end == std::string::npos)
-        return msg;
-
-    // Chained exceptions each start a new traceback; the one that failed the request is the last.
-    const auto header = tb.rfind("Traceback (most recent call last):", end);
-
-    // Tornado renders a raised HTTPError as "HTTP <code>: <reason>[ (<detail>)]", and the detail may span lines.
-    const auto code = err->find("code");
-    if (code != err->end() && code->is_number_integer()) {
-        const std::string marker = "HTTP " + std::to_string(code->get<int>()) + ": ";
-        const auto        pos    = tb.rfind(marker, end);
-        if (pos != std::string::npos && (header == std::string::npos || pos > header) && pos + marker.size() <= end) {
-            const std::string reason = tb.substr(pos + marker.size(), end + 1 - pos - marker.size());
-            // An HTTPError whose detail equals its reason, like HTTPError(401, "Unauthorized"), renders the phrase twice.
-            return reason == msg + " (" + msg + ")" ? msg : reason;
-        }
-    }
-
-    // Any other exception's type and message are everything from the first unindented line after its frames.
-    auto begin = (header == std::string::npos) ? std::string::npos : tb.find('\n', header);
-    while (begin != std::string::npos && begin < end) {
-        ++begin;
-        if (tb[begin] != ' ' && tb[begin] != '\r' && tb[begin] != '\n')
-            break;
-        begin = tb.find('\n', begin);
-    }
-    if (begin == std::string::npos || begin > end) {
-        const auto nl = tb.rfind('\n', end);
-        begin         = (nl == std::string::npos) ? 0 : nl + 1;
-    }
-    return msg + " (" + tb.substr(begin, end + 1 - begin) + ")";
-}
-
-} // namespace
-
 wxString PrintHost::format_error(const std::string &body, const std::string &error, unsigned status) const
 {
     if (status != 0) {
-        const std::string reason = moonraker_error_reason(body);
+        auto wxbody = wxString::FromUTF8(body.data());
-        auto wxbody = wxString::FromUTF8(reason.empty() ? body : reason);
         return wxString::Format("HTTP %u: %s", status, wxbody);
     } else {
         if (error.find("curl:Timeout was reached") != std::string::npos) {

tests/cli/CMakeLists.txt

@@ -15,3 +15,10 @@ set_tests_properties(cli_strict_mode PROPERTIES
     LABELS "CLI;RequiresApp"
     SKIP_RETURN_CODE 77
     TIMEOUT 900)
+
+add_test(NAME cli_malformed_input
+    COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cli_malformed_input.sh $<TARGET_FILE:OrcaSlicer> ${ORCA_CLI_TEST_PYTHON})
+set_tests_properties(cli_malformed_input PROPERTIES
+    LABELS "CLI;RequiresApp"
+    SKIP_RETURN_CODE 77
+    TIMEOUT 900)

tests/cli/test_cli_malformed_input.sh

@@ -0,0 +1,207 @@
+#!/usr/bin/env bash
+# End-to-end checks that malformed CLI input fails cleanly, or loads, instead of crashing the
+# orca-slicer binary. Each case lives inline in CLI::run(), so only the binary can reach it.
+#
+# - A project whose inherits_group does not have one entry per filament plus the process and
+#   printer entries still loads.
+# - --slice N --arrange 1 on a project without plate metadata slices plate N.
+# - An assemble list object with an empty filament list, or a negative filament id, is rejected
+#   as a config error.
+# - --assemble with no input model is rejected as invalid parameters.
+#
+# usage: test_cli_malformed_input.sh <orca-slicer binary> <python3>
+set -u
+
+BIN="${1:-}"
+PY="${2:-python3}"
+# 77 is the test's SKIP_RETURN_CODE.
+[ -x "$BIN" ] || { echo "SKIP: orca-slicer binary not found: $BIN"; exit 77; }
+
+# From src/libslic3r/Utils.hpp. main() returns them, so the shell sees them modulo 256.
+CLI_SUCCESS=0
+CLI_INVALID_PARAMS=-2
+CLI_CONFIG_FILE_ERROR=-5
+
+WORK="$(mktemp -d "${TMPDIR:-/tmp}/orca-cli-malformed.XXXXXX")"
+trap 'rm -rf "$WORK"' EXIT
+mkdir -p "$WORK/datadir"
+
+# Standalone presets: without "inherits" the CLI loads them as-is, with no preset bundle.
+cat > "$WORK/machine.json" <<'EOF'
+{
+    "type": "machine",
+    "from": "User",
+    "name": "CLI malformed input test printer",
+    "printable_area": ["0x0", "200x0", "200x200", "0x200"],
+    "printable_height": "100",
+    "layer_change_gcode": "G92 E0"
+}
+EOF
+cat > "$WORK/process.json" <<'EOF'
+{
+    "type": "process",
+    "from": "User",
+    "name": "CLI malformed input test process"
+}
+EOF
+cat > "$WORK/filament.json" <<'EOF'
+{
+    "type": "filament",
+    "from": "User",
+    "name": "CLI malformed input test filament"
+}
+EOF
+
+"$PY" - "$WORK/cube.stl" <<'EOF'
+import sys
+
+v = [(x, y, z) for z in (0, 10) for y in (0, 10) for x in (0, 10)]
+with open(sys.argv[1], "w") as f:
+    f.write("solid cube\n")
+    # Faces wound counter-clockwise seen from outside: -z, +z, -y, +y, -x, +x.
+    for a, b, c, d in ((0, 2, 3, 1), (4, 5, 7, 6), (0, 1, 5, 4), (2, 6, 7, 3), (0, 4, 6, 2), (1, 3, 7, 5)):
+        for tri in ((a, b, c), (a, c, d)):
+            f.write("facet normal 0 0 0\nouter loop\n")
+            for i in tri:
+                f.write("vertex %g %g %g\n" % v[i])
+            f.write("endloop\nendfacet\n")
+    f.write("endsolid cube\n")
+EOF
+
+fails=0
+fail() { echo "FAIL: $*"; fails=$((fails + 1)); }
+
+# run <tag> [option...]: run into $WORK/<tag>, keeping the log and the shell status there.
+run() {
+    local out="$WORK/$1"; shift
+    mkdir -p "$out"
+    timeout 300 "$BIN" --datadir "$WORK/datadir" --outputdir "$out" "$@" > "$out/log" 2>&1
+    echo $? > "$out/status"
+}
+
+# run_presets <tag> [option...]: run with the standalone presets loaded.
+run_presets() {
+    local tag="$1"; shift
+    run "$tag" --load-settings "$WORK/machine.json;$WORK/process.json" --load-filaments "$WORK/filament.json" "$@"
+}
+
+# expect_status <tag> <cli code>
+expect_status() {
+    local got; got="$(cat "$WORK/$1/status")"
+    [ "$got" -eq $(( $2 & 255 )) ] || fail "$1: shell status $got, want $(( $2 & 255 )) (code $2)"
+}
+
+# expect_result <tag> <return_code>: a failing run must also carry an error_string.
+expect_result() {
+    "$PY" - "$WORK/$1/result.json" "$2" <<'EOF' || fail "$1: result.json"
+import json, sys
+
+try:
+    with open(sys.argv[1]) as f:
+        result = json.load(f)
+except (OSError, ValueError) as e:
+    sys.exit("cannot read %s: %s" % (sys.argv[1], e))
+want_rc = int(sys.argv[2])
+if result.get("return_code") != want_rc:
+    sys.exit("return_code %r, want %d" % (result.get("return_code"), want_rc))
+if want_rc != 0 and not result.get("error_string"):
+    sys.exit("no error_string")
+EOF
+}
+
+# expect_log <tag> <text>
+expect_log() {
+    grep -qF -- "$2" "$WORK/$1/log" || fail "$1: log does not mention \"$2\""
+}
+
+# expect_gcode <tag>
+expect_gcode() {
+    compgen -G "$WORK/$1/*.gcode" > /dev/null || fail "$1: no G-code was exported"
+}
+
+# rewrite_3mf <in> <out> inherits <json list> | no-plates
+rewrite_3mf() {
+    "$PY" - "$@" <<'EOF'
+import json, re, sys, zipfile
+
+src, dst, mode = sys.argv[1:4]
+with zipfile.ZipFile(src) as zin, zipfile.ZipFile(dst, "w", zipfile.ZIP_DEFLATED) as zout:
+    for info in zin.infolist():
+        data = zin.read(info.filename)
+        if mode == "inherits" and info.filename == "Metadata/project_settings.config":
+            config = json.loads(data)
+            config["inherits_group"] = json.loads(sys.argv[4])
+            data = json.dumps(config, indent=4).encode()
+        elif mode == "no-plates":
+            if re.match(r"Metadata/plate_\d+\.", info.filename):
+                continue
+            if info.filename == "Metadata/model_settings.config":
+                data = re.sub(rb"\s*<plate>.*?</plate>", b"", data, flags=re.S)
+        zout.writestr(info, data)
+EOF
+}
+
+# assemble_list <file> <filaments json>
+assemble_list() {
+    cat > "$1" <<EOF
+{"plates": [{"plate_name": "p", "need_arrange": false,
+             "objects": [{"path": "$WORK/cube.stl", "count": 1, "filaments": $2,
+                          "pos_x": [100], "pos_y": [100]}]}]}
+EOF
+}
+
+echo "== a one-filament project exported by the CLI is the base for the project cases"
+run_presets export --slice 0 --export-3mf project.3mf "$WORK/cube.stl"
+expect_status export $CLI_SUCCESS
+[ -f "$WORK/export/project.3mf" ] || { echo "FAIL: project export failed"; tail -n 40 "$WORK/export/log"; exit 1; }
+
+echo "== an inherits_group of the wrong length still loads"
+for group in '[]' '[""]' '["", "", "", "", ""]'; do
+    tag="inherits_$("$PY" -c 'import json, sys; print(len(json.loads(sys.argv[1])))' "$group")"
+    rewrite_3mf "$WORK/export/project.3mf" "$WORK/$tag.3mf" inherits "$group"
+    run "$tag" --info "$WORK/$tag.3mf"
+    expect_status "$tag" $CLI_SUCCESS
+    expect_log "$tag" "inherits_group"
+done
+
+echo "== --slice 1 --arrange 1 slices a project without plate metadata"
+rewrite_3mf "$WORK/export/project.3mf" "$WORK/no_plates.3mf" no-plates
+run_presets no_plates --slice 1 --arrange 1 "$WORK/no_plates.3mf"
+expect_status no_plates $CLI_SUCCESS
+expect_result no_plates $CLI_SUCCESS
+expect_gcode no_plates
+
+echo "== an assemble list with a valid filament id slices"
+assemble_list "$WORK/assemble_valid.json" '[1]'
+run_presets assemble_valid --slice 0 --load-assemble-list "$WORK/assemble_valid.json"
+expect_status assemble_valid $CLI_SUCCESS
+expect_gcode assemble_valid
+
+echo "== an assemble list with an empty filament list or a negative filament id is rejected"
+for filaments in '[]' '[-1]'; do
+    if [ "$filaments" = '[]' ]; then tag=assemble_empty; else tag=assemble_negative; fi
+    assemble_list "$WORK/$tag.json" "$filaments"
+    run_presets "$tag" --slice 0 --load-assemble-list "$WORK/$tag.json"
+    expect_status "$tag" $CLI_CONFIG_FILE_ERROR
+    expect_result "$tag" $CLI_CONFIG_FILE_ERROR
+done
+
+echo "== --assemble with no input model is rejected"
+for action in "--slice 0" "--export-3mf out.3mf"; do
+    tag="assemble_no_input_${action%% *}"
+    tag="${tag//-/}"
+    # shellcheck disable=SC2086
+    run_presets "$tag" --assemble $action
+    expect_status "$tag" $CLI_INVALID_PARAMS
+    expect_result "$tag" $CLI_INVALID_PARAMS
+    expect_log "$tag" "--assemble"
+done
+
+if [ "$fails" -ne 0 ]; then
+    for log in "$WORK"/*/log; do
+        echo "--- $log"
+        tail -n 40 "$log"
+    done
+    exit 1
+fi
+echo "PASS"

tests/fff_print/test_fill.cpp

@@ -747,61 +747,6 @@ TEST_CASE("A region with ironing turned off is never ironed", "[Fill]")
     REQUIRE(Layer::choose_ironing_extruder(cfg, spiral_mode, /*is_topmost_layer=*/true) == -1);
 }
 
-// Ironing path count and total length in mm, over the whole object.
-static std::pair<size_t, double> ironing_extent(const Print &print)
-{
-    size_t paths  = 0;
-    double length = 0.;
-    for (const Layer *layer : print.objects().front()->layers())
-        for (const LayerRegion *region : layer->regions())
-            for (const ExtrusionEntity *entity : region->fills.flatten().entities)
-                if (ironing_role(entity->role())) {
-                    ++paths;
-                    length += unscale<double>(entity->length());
-                }
-    return {paths, length};
-}
-
-TEST_CASE("Ironing spacing below the minimum irons at the minimum spacing", "[Fill]")
-{
-    const std::string pattern      = GENERATE("rectilinear", "concentric");
-    const bool        via_filament = GENERATE(false, true);
-    const double      spacing      = GENERATE(0., 0.001);
-    CAPTURE(pattern, via_filament, spacing);
-
-    auto ironing_for = [&pattern, via_filament](double spacing) {
-        DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
-        config.set_deserialize_strict({{"ironing_type", "top"},
-                                       {"ironing_pattern", pattern},
-                                       {"layer_height", 0.2}});
-        // The filament override replaces the process spacing, which stays at a usable value.
-        if (via_filament)
-            config.set_deserialize_strict({{"ironing_spacing", 0.1}, {"filament_ironing_spacing", spacing}});
-        else
-            config.set_deserialize_strict({{"ironing_spacing", spacing}});
-        Print print;
-        Slic3r::Test::init_and_process_print({Slic3r::Test::cube(20)}, print, config);
-        return ironing_extent(print);
-    };
-
-    const std::pair<size_t, double> clamped = ironing_for(spacing);
-    const std::pair<size_t, double> minimum = ironing_for(IRONING_SPACING_MIN);
-    REQUIRE(minimum.first > 0);
-    CHECK(clamped.first == minimum.first);
-    CHECK_THAT(clamped.second, Catch::Matchers::WithinRel(minimum.second, 1e-9));
-}
-
-TEST_CASE("Concentric fill at zero spacing returns without paths", "[Fill]")
-{
-    std::unique_ptr<Fill> filler(Fill::new_from_type(ipConcentric));
-    filler->spacing      = 0.;
-    filler->bounding_box = BoundingBox(Point(0, 0), Point::new_scale(10, 10));
-    FillParams params;
-    params.density = 1.f;
-    Surface surface(stTop, ExPolygon({Point(0, 0), Point::new_scale(10, 0), Point::new_scale(10, 10), Point::new_scale(0, 10)}));
-    CHECK(filler->fill_surface(&surface, params).empty());
-}
-
 TEST_CASE("Solid infill direction offsets every layer when no template is set", "[Fill]")
 {
     auto angles_for = [](int direction) {

tests/fff_print/test_print.cpp

@@ -15,9 +15,6 @@
 #include "libslic3r/Layer.hpp"
 #include "libslic3r/Model.hpp"
 #include "libslic3r/GCodeReader.hpp"
-#include "libslic3r/GCode/GCodeProcessor.hpp"
-#include "libslic3r/Exception.hpp"
-#include "libslic3r/LifecycleEvents.hpp"
 
 #include "test_helpers.hpp"
 #include "test_utils.hpp"
@@ -25,10 +22,7 @@
 #include <algorithm>
 #include <fstream>
 #include <iterator>
-#include <memory>
 #include <string_view>
-#include <utility>
-#include <vector>
 
 using namespace Slic3r;
 using namespace Slic3r::Test;
@@ -230,88 +224,8 @@ std::string resolved_output_name(Model& model, const std::string& format, const
     return print.output_filename(filename_base);
 }
 
-struct ScopedLifecycleHook
-{
-    explicit ScopedLifecycleHook(LifecycleHookFn hook) { set_lifecycle_hook_fn(std::move(hook)); }
-    ~ScopedLifecycleHook() { set_lifecycle_hook_fn(nullptr); }
-};
-
 } // namespace
 
-TEST_CASE("Slicing lifecycle events identify the model", "[Print][LifecycleEvents]")
-{
-    struct ObservedEvent {
-        LifecycleEvent event;
-        std::string id;
-        std::string name;
-    };
-    std::vector<ObservedEvent> events;
-    ScopedLifecycleHook hook([&](LifecycleEvent event, const LifecycleEventContext& ctx) {
-        events.push_back({ event, ctx.id, ctx.name });
-    });
-
-    Print print;
-    Model model;
-    ModelInfo info;
-    info.model_name = "Lifecycle test model";
-    model.model_info = std::make_shared<ModelInfo>(std::move(info));
-    init_print({cube(20)}, print, model);
-
-    print.process();
-    ScopedTemporaryFile temp(".gcode");
-    print.export_gcode(temp.string(), nullptr, nullptr);
-    GCodeProcessorResult result;
-    print.export_gcode_from_previous_file(temp.string(), &result);
-
-    const std::string expected_id = std::to_string(print.model().id().id);
-    const std::vector<LifecycleEvent> expected_events = {
-        LifecycleEvent::SliceStarted,
-        LifecycleEvent::SliceGeometryFinished,
-        LifecycleEvent::GCodeExportStarted,
-        LifecycleEvent::GCodeExportFinished,
-        LifecycleEvent::GCodeExportStarted,
-        LifecycleEvent::GCodeExportFinished,
-    };
-    REQUIRE(events.size() == expected_events.size());
-    for (size_t i = 0; i < expected_events.size(); ++i) {
-        CHECK(events[i].event == expected_events[i]);
-        CHECK(events[i].id == expected_id);
-        CHECK(events[i].name == "Lifecycle test model");
-    }
-}
-
-TEST_CASE("Slicing lifecycle event name is empty without model metadata", "[Print][LifecycleEvents]")
-{
-    std::string event_id;
-    std::string event_name = "unset";
-    ScopedLifecycleHook hook([&](LifecycleEvent event, const LifecycleEventContext& ctx) {
-        if (event == LifecycleEvent::SliceStarted) {
-            event_id = ctx.id;
-            event_name = ctx.name;
-        }
-    });
-
-    Print print;
-    Model model;
-    init_print({cube(20)}, print, model);
-    print.process();
-
-    CHECK(event_id == std::to_string(print.model().id().id));
-    CHECK(event_name.empty());
-}
-
-TEST_CASE("Output filenames with numeric statistics fail before slicing finishes", "[Print][Regression]")
-{
-    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
-    config.set_key_value("filename_format", new ConfigOptionString("{int(total_weight*10) / 10.0}"));
-
-    Print print;
-    Model model;
-    init_print({cube(20)}, print, model, config);
-
-    CHECK_THROWS_AS(print.output_filename(), PlaceholderParserError);
-}
-
 TEST_CASE("Print: {first_object_name} names the first printable object on the plate", "[Print]")
 {
     Model model;

tests/libslic3r/CMakeLists.txt

@@ -7,6 +7,7 @@ add_executable(${_TEST_NAME}_tests
     test_appconfig.cpp
     test_arachne_walls.cpp
     test_arrange.cpp
+    test_assemble_list.cpp
     test_bambu_networking.cpp
     test_buildvolume.cpp
     test_calib.cpp

tests/libslic3r/test_assemble_list.cpp

@@ -0,0 +1,266 @@
+#include <catch2/catch_all.hpp>
+
+#include "libslic3r/Format/AssembleList.hpp"
+
+#include "test_utils.hpp"
+
+#include <boost/nowide/fstream.hpp>
+#include <nlohmann/json.hpp>
+
+#include <string>
+#include <vector>
+
+using namespace Slic3r;
+using Catch::Matchers::WithinAbs;
+using nlohmann::json;
+
+static constexpr int max_plates = 36;
+
+static AssembleListResult load_text(const std::string &text, std::vector<assemble_plate_info_t> &plates)
+{
+    ScopedTemporaryFile file(".json");
+    {
+        boost::nowide::ofstream out(file.string());
+        out << text;
+    }
+    return load_assemble_plate_list(file.string(), plates, max_plates);
+}
+
+static AssembleListResult load_json(const json &root)
+{
+    std::vector<assemble_plate_info_t> plates;
+    return load_text(root.dump(), plates);
+}
+
+// One plate with one object of three clones, which every optional field accepts.
+static json valid_list()
+{
+    return json::parse(R"({
+        "plates": [{
+            "plate_name": "plate",
+            "need_arrange": false,
+            "objects": [{
+                "path": "cube.stl",
+                "count": 3,
+                "filaments": [1],
+                "height_ranges": [{ "min_z": 0, "max_z": 5, "range_params": { "layer_height": "0.1" } }]
+            }],
+            "assembled_params": [{
+                "assemble_index": 1,
+                "height_ranges": [{ "min_z": 0, "max_z": 5, "range_params": { "layer_height": "0.1" } }]
+            }]
+        }]
+    })");
+}
+
+TEST_CASE("A valid assemble list parses into its plates and objects", "[AssembleList]")
+{
+    const std::string text = R"({
+        "plates": [
+            {
+                "plate_name": "first",
+                "need_arrange": true,
+                "plate_params": { "curr_bed_type": "Textured PEI Plate" },
+                "objects": [
+                    {
+                        "path": "a.stl",
+                        "count": 2,
+                        "filaments": [1, 3],
+                        "assemble_index": [1],
+                        "pos_x": [10.5, 20.5],
+                        "pos_y": [30],
+                        "pos_z": [0, 1],
+                        "print_params": { "sparse_infill_density": "30%" },
+                        "height_ranges": [{ "min_z": 1.5, "max_z": 4, "range_params": { "layer_height": "0.12" } }]
+                    },
+                    { "path": "b.stl", "count": 1, "filaments": [0] }
+                ],
+                "assembled_params": [{ "assemble_index": 1, "print_params": { "wall_loops": "4" } }]
+            },
+            {
+                "plate_name": "second",
+                "need_arrange": false,
+                "objects": [{ "path": "c.stl", "count": 1, "filaments": [2] }]
+            }
+        ]
+    })";
+    std::vector<assemble_plate_info_t> plates;
+    REQUIRE(load_text(text, plates) == AssembleListResult::Success);
+    REQUIRE(plates.size() == 2);
+
+    const assemble_plate_info_t &first = plates[0];
+    CHECK(first.plate_name == "first");
+    CHECK(first.need_arrange);
+    CHECK(first.plate_params.at("curr_bed_type") == "Textured PEI Plate");
+    REQUIRE(first.assemble_obj_list.size() == 2);
+
+    const assemble_object_info_t &a = first.assemble_obj_list[0];
+    CHECK(a.path == "a.stl");
+    CHECK(a.count == 2);
+    CHECK(a.filaments == std::vector<int>{1, 3});
+    CHECK(a.assemble_index == std::vector<int>{1});
+    REQUIRE(a.pos_x.size() == 2);
+    CHECK_THAT(a.pos_x[0], WithinAbs(10.5, 1e-6));
+    CHECK_THAT(a.pos_x[1], WithinAbs(20.5, 1e-6));
+    REQUIRE(a.pos_y.size() == 1);
+    CHECK_THAT(a.pos_y[0], WithinAbs(30., 1e-6));
+    REQUIRE(a.pos_z.size() == 2);
+    CHECK_THAT(a.pos_z[1], WithinAbs(1., 1e-6));
+    CHECK(a.print_params.at("sparse_infill_density") == "30%");
+    REQUIRE(a.height_ranges.size() == 1);
+    CHECK_THAT(a.height_ranges[0].min_z, WithinAbs(1.5, 1e-6));
+    CHECK_THAT(a.height_ranges[0].max_z, WithinAbs(4., 1e-6));
+    CHECK(a.height_ranges[0].range_params.at("layer_height") == "0.12");
+
+    const assemble_object_info_t &b = first.assemble_obj_list[1];
+    CHECK(b.path == "b.stl");
+    CHECK(b.count == 1);
+    CHECK(b.filaments == std::vector<int>{0});
+    CHECK(b.pos_x.empty());
+    CHECK(b.assemble_index.empty());
+
+    REQUIRE(first.assembled_param_list.count(1) == 1);
+    CHECK(first.assembled_param_list.at(1).print_params.at("wall_loops") == "4");
+
+    const assemble_plate_info_t &second = plates[1];
+    CHECK(second.plate_name == "second");
+    CHECK_FALSE(second.need_arrange);
+    REQUIRE(second.assemble_obj_list.size() == 1);
+    CHECK(second.assemble_obj_list[0].path == "c.stl");
+    CHECK(second.assemble_obj_list[0].filaments == std::vector<int>{2});
+}
+
+TEST_CASE("The unmodified fixture used by the rule tests is accepted", "[AssembleList]")
+{
+    CHECK(load_json(valid_list()) == AssembleListResult::Success);
+}
+
+TEST_CASE("An object with an empty filament list is rejected", "[AssembleList]")
+{
+    json root = valid_list();
+    root["plates"][0]["objects"][0]["filaments"] = json::array();
+    CHECK(load_json(root) == AssembleListResult::ConfigError);
+}
+
+TEST_CASE("An object with a negative filament id is rejected", "[AssembleList]")
+{
+    json root = valid_list();
+    root["plates"][0]["objects"][0]["filaments"] = GENERATE(json::array({-1}), json::array({1, -2, 1}));
+    CAPTURE(root["plates"][0]["objects"][0]["filaments"].dump());
+    CHECK(load_json(root) == AssembleListResult::ConfigError);
+}
+
+TEST_CASE("Filament id 0 is accepted", "[AssembleList]")
+{
+    json root = valid_list();
+    root["plates"][0]["objects"][0]["filaments"] = GENERATE(json::array({0}), json::array({0, 1, 0}));
+    CAPTURE(root["plates"][0]["objects"][0]["filaments"].dump());
+    CHECK(load_json(root) == AssembleListResult::Success);
+}
+
+TEST_CASE("Per-clone lists need one entry or one per clone", "[AssembleList]")
+{
+    // The fixture object has 3 clones.
+    const std::string key  = GENERATE("filaments", "assemble_index", "pos_x", "pos_y", "pos_z");
+    const size_t      size = GENERATE(1, 2, 3, 4);
+    CAPTURE(key, size);
+
+    json root = valid_list();
+    root["plates"][0]["objects"][0][key] = json(std::vector<int>(size, 1));
+    const AssembleListResult expected = (size == 1 || size == 3) ? AssembleListResult::Success : AssembleListResult::ConfigError;
+    CHECK(load_json(root) == expected);
+}
+
+TEST_CASE("An empty optional per-clone list is accepted", "[AssembleList]")
+{
+    const std::string key = GENERATE("assemble_index", "pos_x", "pos_y", "pos_z");
+    CAPTURE(key);
+
+    json root = valid_list();
+    root["plates"][0]["objects"][0][key] = json::array();
+    CHECK(load_json(root) == AssembleListResult::Success);
+}
+
+// Fields read through a const reference (plate_name, need_arrange, objects, path, count) are
+// looked up without a presence check, so only their wrong-type case is covered here.
+TEST_CASE("A missing required field is rejected", "[AssembleList]")
+{
+    const std::string pointer = GENERATE("/plates",
+                                         "/plates/0/objects/0/filaments",
+                                         "/plates/0/objects/0/height_ranges/0/min_z",
+                                         "/plates/0/objects/0/height_ranges/0/max_z",
+                                         "/plates/0/objects/0/height_ranges/0/range_params",
+                                         "/plates/0/assembled_params/0/assemble_index",
+                                         "/plates/0/assembled_params/0/height_ranges/0/min_z",
+                                         "/plates/0/assembled_params/0/height_ranges/0/max_z",
+                                         "/plates/0/assembled_params/0/height_ranges/0/range_params");
+    CAPTURE(pointer);
+
+    json root = valid_list();
+    const json::json_pointer ptr(pointer);
+    root[ptr.parent_pointer()].erase(ptr.back());
+    CHECK(load_json(root) == AssembleListResult::ConfigError);
+}
+
+TEST_CASE("A field of the wrong type is rejected", "[AssembleList]")
+{
+    const std::string pointer = GENERATE("/plates/0/plate_name",
+                                         "/plates/0/need_arrange",
+                                         "/plates/0/objects/0/path",
+                                         "/plates/0/objects/0/count",
+                                         "/plates/0/objects/0/filaments",
+                                         "/plates/0/objects/0/pos_x");
+    CAPTURE(pointer);
+
+    json root = valid_list();
+    root[json::json_pointer(pointer)] = json::object();
+    CHECK(load_json(root) == AssembleListResult::ConfigError);
+}
+
+TEST_CASE("A plate or clone count out of range is rejected", "[AssembleList]")
+{
+    SECTION("no plates")
+    {
+        json root = valid_list();
+        root["plates"] = json::array();
+        CHECK(load_json(root) == AssembleListResult::ConfigError);
+    }
+    SECTION("more plates than the limit")
+    {
+        json root = valid_list();
+        const json plate = root["plates"][0];
+        for (int i = 1; i < max_plates; ++i)
+            root["plates"].push_back(plate);
+        CHECK(load_json(root) == AssembleListResult::Success);
+        root["plates"].push_back(plate);
+        CHECK(load_json(root) == AssembleListResult::ConfigError);
+    }
+    SECTION("a plate with no objects")
+    {
+        json root = valid_list();
+        root["plates"][0]["objects"] = json::array();
+        CHECK(load_json(root) == AssembleListResult::ConfigError);
+    }
+    SECTION("a clone count below 1")
+    {
+        json root = valid_list();
+        root["plates"][0]["objects"][0]["count"] = GENERATE(0, -1);
+        CAPTURE(root["plates"][0]["objects"][0]["count"].dump());
+        CHECK(load_json(root) == AssembleListResult::ConfigError);
+    }
+}
+
+TEST_CASE("Malformed JSON is rejected", "[AssembleList]")
+{
+    const std::string text = GENERATE(std::string(), std::string("{\"plates\": ["), std::string("not json"));
+    CAPTURE(text);
+    std::vector<assemble_plate_info_t> plates;
+    CHECK(load_text(text, plates) == AssembleListResult::ConfigError);
+}
+
+TEST_CASE("A missing file is reported as not found", "[AssembleList]")
+{
+    ScopedTemporaryFile        file(".json");
+    std::vector<assemble_plate_info_t> plates;
+    CHECK(load_assemble_plate_list(file.string(), plates, max_plates) == AssembleListResult::FileNotFound);
+}

tests/slic3rutils/CMakeLists.txt

@@ -18,7 +18,6 @@ add_executable(${_TEST_NAME}_tests
     test_plugin_install.cpp
     test_plugin_lifecycle.cpp
     test_plugin_printer_agent.cpp
-    test_printhost.cpp
     test_slicing_pipeline_bindings.cpp
     test_slicing_pipeline_config.cpp
     test_plugin_sort.cpp

tests/slic3rutils/test_printhost.cpp

@@ -1,213 +0,0 @@
-#include <catch2/catch_all.hpp>
-
-#include <nlohmann/json.hpp>
-
-#include "slic3r/Utils/PrintHost.hpp"
-
-using namespace Slic3r;
-
-namespace {
-
-class TestPrintHost : public PrintHost
-{
-public:
-    using PrintHost::format_error;
-
-    const char* get_name() const override { return "Test"; }
-    bool test(wxString&) const override { return true; }
-    wxString get_test_ok_msg() const override { return {}; }
-    wxString get_test_failed_msg(wxString&) const override { return {}; }
-    bool upload(PrintHostUpload, ProgressFn, ErrorFn, InfoFn) const override { return true; }
-    bool has_auto_discovery() const override { return false; }
-    bool can_test() const override { return false; }
-    PrintHostPostUploadActions get_post_upload_actions() const override { return {}; }
-    std::string get_host() const override { return {}; }
-};
-
-std::string format_error(const std::string& body, const std::string& error, unsigned status)
-{
-    return TestPrintHost().format_error(body, error, status).ToStdString();
-}
-
-std::string envelope(int code, const std::string& message, const std::string& traceback)
-{
-    return nlohmann::json{{"error", {{"code", code}, {"message", message}, {"traceback", traceback}}}}.dump();
-}
-
-std::string moonraker_error(int code, const std::string& message, const std::string& detail = {})
-{
-    std::string line = "tornado.web.HTTPError: HTTP " + std::to_string(code) + ": " + message;
-    if (!detail.empty())
-        line += " (" + detail + ")";
-    return envelope(code, message, "Traceback (most recent call last):\n  ...\n" + line + "\n");
-}
-
-// A real Moonraker body for uploading a file that is being printed.
-constexpr const char* k_busy_file_403 =
-    R"JSON({"error": {"code": 403, "message": "Forbidden", "traceback": "Traceback (most recent call last):\n\n  File \"/home/lava/moonraker/moonraker/components/file_manager/file_manager.py\", line 1017, in _finish_gcode_upload\n    can_start = self._handle_operation_check(check_path)\n                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nmoonraker.utils.exceptions.ServerError: File currently in use\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n\n  File \"/home/lava/moonraker/moonraker/components/application.py\", line 1069, in post\n    raise tornado.web.HTTPError(\ntornado.web.HTTPError: HTTP 403: Forbidden (File is loaded, upload not permitted)\n"}})JSON";
-
-} // namespace
-
-TEST_CASE("A Klipper upload error shows its reason instead of a Python traceback", "[PrintHost][Regression]")
-{
-    const std::string msg = format_error(k_busy_file_403, "", 403);
-    INFO("actual: " << msg);
-
-    CHECK(msg == "HTTP 403: Forbidden (File is loaded, upload not permitted)");
-    CHECK_THAT(msg, !Catch::Matchers::ContainsSubstring("Traceback"));
-    CHECK_THAT(msg, !Catch::Matchers::ContainsSubstring("file_manager.py"));
-}
-
-TEST_CASE("The specific cause is recovered from a file endpoint's traceback", "[PrintHost]")
-{
-    SECTION("a plain detail")
-    {
-        const std::string body = moonraker_error(403, "Forbidden", "File is loaded, upload not permitted");
-        CHECK(format_error(body, "", 403) == "HTTP 403: Forbidden (File is loaded, upload not permitted)");
-    }
-
-    SECTION("a detail whose own parentheses nest (a filename)")
-    {
-        const std::string detail = "Directory does not exist (/home/pi/gcodes/plate (1).gcode)";
-        const std::string body   = moonraker_error(400, "Bad Request", detail);
-        CHECK(format_error(body, "", 400) == "HTTP 400: Bad Request (" + detail + ")");
-    }
-
-    SECTION("a detail that contains the reason phrase")
-    {
-        const std::string body = moonraker_error(403, "Forbidden", "Forbidden zone: access denied");
-        CHECK(format_error(body, "", 403) == "HTTP 403: Forbidden (Forbidden zone: access denied)");
-    }
-
-    SECTION("a detail that spans lines")
-    {
-        const std::string detail = "Move out of range\nX=250.000 Y=10.000";
-        const std::string body   = moonraker_error(400, "Bad Request", detail);
-        CHECK(format_error(body, "", 400) == "HTTP 400: Bad Request (" + detail + ")");
-    }
-
-    SECTION("a detail that only repeats the reason phrase is dropped")
-    {
-        const std::string body = moonraker_error(401, "Unauthorized", "Unauthorized");
-        CHECK(format_error(body, "", 401) == "HTTP 401: Unauthorized");
-    }
-}
-
-TEST_CASE("An unhandled exception shows its type and message", "[PrintHost]")
-{
-    const std::string frame = "Traceback (most recent call last):\n"
-                              "  File \"/home/pi/moonraker/moonraker/components/file_manager/file_manager.py\", line 1, in write\n"
-                              "    self._write(data)\n";
-
-    SECTION("a one-line message")
-    {
-        const std::string body = envelope(500, "Internal Server Error", frame + "OSError: [Errno 28] No space left on device\n");
-        CHECK(format_error(body, "", 500) == "HTTP 500: Internal Server Error (OSError: [Errno 28] No space left on device)");
-    }
-
-    SECTION("a message that spans lines")
-    {
-        const std::string body = envelope(500, "Internal Server Error", frame + "ServerError: Klippy request failed\n  see klippy.log\n");
-        CHECK(format_error(body, "", 500) == "HTTP 500: Internal Server Error (ServerError: Klippy request failed\n  see klippy.log)");
-    }
-
-    SECTION("raised while handling an HTTPError with the same code")
-    {
-        const std::string traceback = frame + "tornado.web.HTTPError: HTTP 500: Internal Server Error (Database locked)\n\n"
-                                              "During handling of the above exception, another exception occurred:\n\n" +
-                                      frame + "OSError: [Errno 5] Input/output error\n";
-        const std::string body      = envelope(500, "Internal Server Error", traceback);
-        CHECK(format_error(body, "", 500) == "HTTP 500: Internal Server Error (OSError: [Errno 5] Input/output error)");
-    }
-
-    SECTION("a traceback with no header")
-    {
-        const std::string body = envelope(500, "Internal Server Error", "OSError: [Errno 5] Input/output error");
-        CHECK(format_error(body, "", 500) == "HTTP 500: Internal Server Error (OSError: [Errno 5] Input/output error)");
-    }
-}
-
-TEST_CASE("A reason already complete in message is shown unchanged", "[PrintHost]")
-{
-    SECTION("message is the whole reason, no trailing detail")
-    {
-        const std::string body = moonraker_error(503, "Klippy is not ready");
-        CHECK(format_error(body, "", 503) == "HTTP 503: Klippy is not ready");
-    }
-
-    SECTION("a message that itself contains parentheses is not duplicated")
-    {
-        const std::string reason = "Requested blocks (0-5) are unavailable";
-        const std::string body   = moonraker_error(400, reason);
-        CHECK(format_error(body, "", 400) == "HTTP 400: " + reason);
-    }
-}
-
-TEST_CASE("A Moonraker error with no usable detail shows just the reason phrase", "[PrintHost]")
-{
-    struct Case
-    {
-        const char* name;
-        const char* body;
-        unsigned status;
-        const char* expected;
-    };
-
-    const auto c = GENERATE(
-        Case{"an empty traceback", R"JSON({"error": {"code": 500, "message": "Internal Server Error", "traceback": ""}})JSON", 500,
-             "HTTP 500: Internal Server Error"},
-        Case{"a traceback of only whitespace", R"JSON({"error": {"code": 500, "message": "Internal Server Error", "traceback": "\n \n"}})JSON",
-             500, "HTTP 500: Internal Server Error"});
-
-    DYNAMIC_SECTION(c.name) { CHECK(format_error(c.body, "", c.status) == c.expected); }
-}
-
-TEST_CASE("A percent sign in the reason is not a format specifier", "[PrintHost]")
-{
-    const std::string body = moonraker_error(507, "Insufficient Storage", "disk 100% full");
-    CHECK(format_error(body, "", 507) == "HTTP 507: Insufficient Storage (disk 100% full)");
-}
-
-TEST_CASE("Error bodies that are not a Moonraker envelope are left unchanged", "[PrintHost]")
-{
-    SECTION("OctoPrint's string-valued error member")
-    {
-        const std::string body = R"JSON({"error": "File not found"})JSON";
-        CHECK(format_error(body, "", 404) == "HTTP 404: " + body);
-    }
-
-    SECTION("PrusaLink's top-level message, not under error")
-    {
-        const std::string body = R"JSON({"title": "Conflict", "message": "Printer is printing"})JSON";
-        CHECK(format_error(body, "", 409) == "HTTP 409: " + body);
-    }
-
-    SECTION("a body that is not JSON")
-    {
-        const std::string html = "<html><head><title>502 Bad Gateway</title></head></html>";
-        CHECK(format_error(html, "", 502) == "HTTP 502: " + html);
-    }
-
-    SECTION("an error object with no traceback")
-    {
-        const std::string body = R"JSON({"error": {"code": 500, "message": "Internal Server Error"}})JSON";
-        CHECK(format_error(body, "", 500) == "HTTP 500: " + body);
-    }
-
-    SECTION("an error object whose traceback is null")
-    {
-        const std::string body = R"JSON({"error": {"code": 500, "message": "Internal Server Error", "traceback": null}})JSON";
-        CHECK(format_error(body, "", 500) == "HTTP 500: " + body);
-    }
-
-    SECTION("an envelope whose reason phrase is empty")
-    {
-        const std::string body = envelope(403, "", "Traceback (most recent call last):\nOSError: denied\n");
-        CHECK(format_error(body, "", 403) == "HTTP 403: " + body);
-    }
-
-    SECTION("a transport error with no HTTP status")
-    {
-        CHECK(format_error("", "curl:Could not connect", 0) == "curl:Could not connect");
-    }
-}