Ported test_support_material from upstream Slic3r.

Reworked the FFF testing framework & ConfigBase::set_deserialize()
for more compact tests: set_deserialize() now accepts list
of key / value pairs.

Fixed an incorrect assert in LayerRegion.

src/libslic3r/Config.cpp

@@ -438,6 +438,14 @@ bool ConfigBase::set_deserialize(const t_config_option_key &opt_key_src, const s
     return this->set_deserialize_raw(opt_key, value, append);
 }
 
+bool ConfigBase::set_deserialize(std::initializer_list<SetDeserializeItem> items)
+{
+	bool deserialized = true;
+	for (const SetDeserializeItem &item : items)
+		deserialized &= this->set_deserialize(item.opt_key, item.opt_value, item.append);
+	return deserialized;
+}
+
 bool ConfigBase::set_deserialize_raw(const t_config_option_key &opt_key_src, const std::string &value, bool append)
 {
     t_config_option_key opt_key = opt_key_src;

src/libslic3r/Config.hpp

@@ -1554,6 +1554,8 @@ public:
     // Set a configuration value from a string, it will call an overridable handle_legacy() 
     // to resolve renamed and removed configuration keys.
     bool set_deserialize(const t_config_option_key &opt_key, const std::string &str, bool append = false);
+    struct SetDeserializeItem { std::string opt_key; std::string opt_value; bool append = false; };
+    bool set_deserialize(std::initializer_list<SetDeserializeItem> items);
 
     double get_abs_value(const t_config_option_key &opt_key) const;
     double get_abs_value(const t_config_option_key &opt_key, double ratio_over) const;

src/libslic3r/LayerRegion.cpp

@@ -70,7 +70,7 @@ void LayerRegion::make_perimeters(const SurfaceCollection &slices, SurfaceCollec
         fill_surfaces
     );
     
-    if (this->layer()->lower_layer != NULL)
+    if (this->layer()->lower_layer != nullptr)
         // Cummulative sum of polygons over all the regions.
         g.lower_slices = &this->layer()->lower_layer->slices;
     
@@ -130,7 +130,7 @@ void LayerRegion::process_external_surfaces(const Layer *lower_layer, const Poly
                     bridges.emplace_back(surface);
             }
             if (surface.is_internal()) {
-            	assert(surface.surface_type == stInternal);
+            	assert(surface.surface_type == stInternal || surface.surface_type == stInternalSolid);
             	if (! has_infill && lower_layer != nullptr)
             		polygons_append(voids, surface.expolygon);
             	internal.emplace_back(std::move(surface));

tests/fff_print/CMakeLists.txt

@@ -11,6 +11,7 @@ add_executable(${_TEST_NAME}_tests
 	test_printgcode.cpp
 	test_printobject.cpp
 	test_skirt_brim.cpp
+	test_support_material.cpp
 	test_trianglemesh.cpp
 	)
 target_link_libraries(${_TEST_NAME}_tests test_common libslic3r)

tests/fff_print/test_data.hpp

@@ -1,12 +1,12 @@
 #ifndef SLIC3R_TEST_DATA_HPP
 #define SLIC3R_TEST_DATA_HPP
 
-#include "libslic3r/Point.hpp"
-#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/Config.hpp"
 #include "libslic3r/Geometry.hpp"
 #include "libslic3r/Model.hpp"
+#include "libslic3r/Point.hpp"
 #include "libslic3r/Print.hpp"
-#include "libslic3r/Config.hpp"
+#include "libslic3r/TriangleMesh.hpp"
 
 #include <unordered_map>
 
@@ -61,15 +61,24 @@ bool _equiv(const T& a, const T& b) { return std::abs(a - b) < EPSILON; }
 template <typename T>
 bool _equiv(const T& a, const T& b, double epsilon) { return abs(a - b) < epsilon; }
 
-//Slic3r::Model model(const std::string& model_name, TestMesh m, Vec3d translate = Vec3d(0,0,0), Vec3d scale = Vec3d(1.0,1.0,1.0));
-//Slic3r::Model model(const std::string& model_name, TestMesh m, Vec3d translate = Vec3d(0,0,0), double scale = 1.0);
-
 Slic3r::Model model(const std::string& model_name, TriangleMesh&& _mesh);
-
-std::shared_ptr<Print> init_print(std::initializer_list<TestMesh> meshes, Slic3r::Model& model, const Slic3r::DynamicPrintConfig &config_in = Slic3r::DynamicPrintConfig::full_print_config(), bool comments = false);
-std::shared_ptr<Print> init_print(std::initializer_list<TriangleMesh> meshes, Slic3r::Model& model, const Slic3r::DynamicPrintConfig &config_in = Slic3r::DynamicPrintConfig::full_print_config(), bool comments = false);
-
-std::string gcode(std::shared_ptr<Print> print);
+void init_print(std::vector<TriangleMesh> 		  &&meshes, Slic3r::Print &print, Slic3r::Model& model, const DynamicPrintConfig &config_in, bool comments = false);
+void init_print(std::initializer_list<TestMesh> 	meshes, Slic3r::Print &print, Slic3r::Model& model, const Slic3r::DynamicPrintConfig &config_in = Slic3r::DynamicPrintConfig::full_print_config(), bool comments = false);
+void init_print(std::initializer_list<TriangleMesh> meshes, Slic3r::Print &print, Slic3r::Model& model, const Slic3r::DynamicPrintConfig &config_in = Slic3r::DynamicPrintConfig::full_print_config(), bool comments = false);
+void init_print(std::initializer_list<TestMesh> 	meshes, Slic3r::Print &print, Slic3r::Model& model, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments = false);
+void init_print(std::initializer_list<TriangleMesh> meshes, Slic3r::Print &print, Slic3r::Model& model, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments = false);
+
+void init_and_process_print(std::initializer_list<TestMesh> 	meshes, Slic3r::Print &print, const DynamicPrintConfig& config, bool comments = false);
+void init_and_process_print(std::initializer_list<TriangleMesh> meshes, Slic3r::Print &print, const DynamicPrintConfig& config, bool comments = false);
+void init_and_process_print(std::initializer_list<TestMesh> 	meshes, Slic3r::Print &print, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments = false);
+void init_and_process_print(std::initializer_list<TriangleMesh> meshes, Slic3r::Print &print, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments = false);
+
+std::string gcode(Print& print);
+
+std::string slice(std::initializer_list<TestMesh> meshes, const DynamicPrintConfig &config, bool comments = false);
+std::string slice(std::initializer_list<TriangleMesh> meshes, const DynamicPrintConfig &config, bool comments = false);
+std::string slice(std::initializer_list<TestMesh> meshes, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments = false);
+std::string slice(std::initializer_list<TriangleMesh> meshes, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments = false);
 
 } } // namespace Slic3r::Test
 

tests/fff_print/test_flow.cpp

@@ -19,16 +19,19 @@ SCENARIO("Extrusion width specifics", "[!mayfail]") {
     GIVEN("A config with a skirt, brim, some fill density, 3 perimeters, and 1 bottom solid layer and a 20mm cube mesh") {
         // this is a sharedptr
         DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
-        config.opt_int("skirts") = 1;
-        config.opt_float("brim_width") = 2.;
-        config.opt_int("perimeters") = 3;
-        config.set_deserialize("fill_density", "40%");
-        config.set_deserialize("first_layer_height", "100%");
+		config.set_deserialize({
+			{ "brim_width",			"2" },
+			{ "skirts",				"1" },
+			{ "perimeters",			"3" },
+			{ "fill_density",		"40%" },
+			{ "first_layer_height", "100%" }
+			});
 
         WHEN("first layer width set to 2mm") {
             Slic3r::Model model;
             config.set_deserialize("first_layer_extrusion_width", "2");
-            std::shared_ptr<Print> print = Slic3r::Test::init_print({TestMesh::cube_20x20x20}, model, config);
+            Slic3r::Print print;
+            Slic3r::Test::init_print({TestMesh::cube_20x20x20}, print, model, config);
 
             std::vector<double> E_per_mm_bottom;
             std::string gcode = Test::gcode(print);

tests/fff_print/test_print.cpp

@@ -10,31 +10,20 @@ using namespace Slic3r::Test;
 
 SCENARIO("PrintObject: Perimeter generation", "[PrintObject]") {
     GIVEN("20mm cube and default config") {
-        Slic3r::DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
-        TestMesh m = TestMesh::cube_20x20x20;
-        Slic3r::Model model;
-        size_t event_counter = 0;
-        std::string stage;
-        int value = 0;
-        auto callback = [&event_counter, &stage, &value] (int a, const char* b) { stage = std::string(b); ++ event_counter; value = a; };
-        config.set_deserialize("fill_density", "0");
-
         WHEN("make_perimeters() is called")  {
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({m}, model, config);
-			print->process();
-			const PrintObject& object = *(print->objects().at(0));
+            Slic3r::Print print;
+            Slic3r::Test::init_and_process_print({TestMesh::cube_20x20x20}, print, { { "fill_density", "0" } });
+			const PrintObject &object = *print.objects().front();
 			THEN("67 layers exist in the model") {
                 REQUIRE(object.layers().size() == 66);
             }
             THEN("Every layer in region 0 has 1 island of perimeters") {
-                for (const Layer *layer : object.layers()) {
+                for (const Layer *layer : object.layers())
                     REQUIRE(layer->regions().front()->perimeters.entities.size() == 1);
-                }
             }
             THEN("Every layer in region 0 has 3 paths in its perimeters list.") {
-                for (const Layer *layer : object.layers()) {
+                for (const Layer *layer : object.layers())
                     REQUIRE(layer->regions().front()->perimeters.items_count() == 3);
-                }
             }
         }
     }
@@ -42,66 +31,59 @@ SCENARIO("PrintObject: Perimeter generation", "[PrintObject]") {
 
 SCENARIO("Print: Skirt generation", "[Print]") {
     GIVEN("20mm cube and default config") {
-        Slic3r::DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
-        TestMesh m = TestMesh::cube_20x20x20;
-        Slic3r::Model model;
-        std::string stage;
-        int value = 0;
-        config.opt_int("skirt_height") = 1;
-        config.opt_float("skirt_distance") = 1.f;
         WHEN("Skirts is set to 2 loops")  {
-            config.opt_int("skirts") = 2;
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({m}, model, config);
-			print->process();
+            Slic3r::Print print;
+            Slic3r::Test::init_and_process_print({TestMesh::cube_20x20x20}, print, {
+            	{ "skirt_height", 	"1" },
+        		{ "skirt_distance", "1" },
+        		{ "skirts", 		"2"}
+            });
             THEN("Skirt Extrusion collection has 2 loops in it") {
-                REQUIRE(print->skirt().items_count() == 2);
-                REQUIRE(print->skirt().flatten().entities.size() == 2);
+                REQUIRE(print.skirt().items_count() == 2);
+                REQUIRE(print.skirt().flatten().entities.size() == 2);
             }
         }
     }
 }
 
-void test_is_solid_infill(std::shared_ptr<Slic3r::Print> p, size_t obj_id, size_t layer_id ) {
-    const PrintObject &obj = *(p->objects().at(obj_id));
-    const Layer       &layer = *(obj.get_layer((int)layer_id));
-
-    // iterate over all of the regions in the layer
-    for (const LayerRegion *reg : layer.regions()) {
-        // for each region, iterate over the fill surfaces
-        for (const Surface& s : reg->fill_surfaces.surfaces) {
-            CHECK(s.is_solid());
-        }
-    }
-}
-
 SCENARIO("Print: Changing number of solid surfaces does not cause all surfaces to become internal.", "[Print]") {
     GIVEN("sliced 20mm cube and config with top_solid_surfaces = 2 and bottom_solid_surfaces = 1") {
         Slic3r::DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
-        TestMesh m = TestMesh::cube_20x20x20;
-        config.opt_int("top_solid_layers") = 2;
-        config.opt_int("bottom_solid_layers") = 1;
-        config.opt_float("layer_height") = 0.5; // get a known number of layers
-        config.set_deserialize("first_layer_height", "0.5");
+		config.set_deserialize({
+			{ "top_solid_layers",		"2" },
+			{ "bottom_solid_layers",	"1" },
+			{ "layer_height",			"0.5" }, // get a known number of layers
+			{ "first_layer_height",		"0.5" }
+			});
+        Slic3r::Print print;
         Slic3r::Model model;
-        std::string stage;
-        std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({m}, model, config);
-        print->process();
+        Slic3r::Test::init_print({TestMesh::cube_20x20x20}, print, model, config);
         // Precondition: Ensure that the model has 2 solid top layers (39, 38)
         // and one solid bottom layer (0).
-        test_is_solid_infill(print, 0, 0); // should be solid
-        test_is_solid_infill(print, 0, 39); // should be solid
-        test_is_solid_infill(print, 0, 38); // should be solid
+		auto test_is_solid_infill = [&print](size_t obj_id, size_t layer_id) {
+		    const Layer &layer = *(print.objects().at(obj_id)->get_layer((int)layer_id));
+		    // iterate over all of the regions in the layer
+		    for (const LayerRegion *region : layer.regions()) {
+		        // for each region, iterate over the fill surfaces
+		        for (const Surface &surface : region->fill_surfaces.surfaces)
+		            CHECK(surface.is_solid());
+		    }
+		};
+        print.process();
+        test_is_solid_infill(0,  0); // should be solid
+        test_is_solid_infill(0, 39); // should be solid
+        test_is_solid_infill(0, 38); // should be solid
         WHEN("Model is re-sliced with top_solid_layers == 3") {
 			config.opt_int("top_solid_layers") = 3;
-			print->apply(model, config);
-            print->process();
+			print.apply(model, config);
+            print.process();
             THEN("Print object does not have 0 solid bottom layers.") {
-                test_is_solid_infill(print, 0, 0);
+                test_is_solid_infill(0, 0);
             }
             AND_THEN("Print object has 3 top solid layers") {
-                test_is_solid_infill(print, 0, 39);
-                test_is_solid_infill(print, 0, 38);
-                test_is_solid_infill(print, 0, 37);
+                test_is_solid_infill(0, 39);
+                test_is_solid_infill(0, 38);
+                test_is_solid_infill(0, 37);
             }
         }
     }
@@ -109,35 +91,36 @@ SCENARIO("Print: Changing number of solid surfaces does not cause all surfaces t
 
 SCENARIO("Print: Brim generation", "[Print]") {
     GIVEN("20mm cube and default config, 1mm first layer width") {
-        Slic3r::DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
-        TestMesh m = TestMesh::cube_20x20x20;
-        Slic3r::Model model;
-        std::string stage;
-        int value = 0;
-        config.set_deserialize("first_layer_extrusion_width", "1");
         WHEN("Brim is set to 3mm")  {
-            config.opt_float("brim_width") = 3;
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({m}, model, config);
-            print->process();
+	        Slic3r::Print print;
+	        Slic3r::Test::init_and_process_print({TestMesh::cube_20x20x20}, print, {
+	        	{ "first_layer_extrusion_width", 	"1" },
+	        	{ "brim_width", 					"3" }
+	        });
             THEN("Brim Extrusion collection has 3 loops in it") {
-                REQUIRE(print->brim().items_count() == 3);
+                REQUIRE(print.brim().items_count() == 3);
             }
         }
         WHEN("Brim is set to 6mm")  {
-            config.opt_float("brim_width") = 6;
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({m}, model, config);
-			print->process();
+	        Slic3r::Print print;
+	        Slic3r::Test::init_and_process_print({TestMesh::cube_20x20x20}, print, {
+	        	{ "first_layer_extrusion_width", 	"1" },
+	        	{ "brim_width", 					"6" }
+	        });
             THEN("Brim Extrusion collection has 6 loops in it") {
-                REQUIRE(print->brim().items_count() == 6);
+                REQUIRE(print.brim().items_count() == 6);
             }
         }
         WHEN("Brim is set to 6mm, extrusion width 0.5mm")  {
-            config.opt_float("brim_width") = 6;
-            config.set_deserialize("first_layer_extrusion_width", "0.5");
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({m}, model, config);
-			print->process();
+	        Slic3r::Print print;
+	        Slic3r::Test::init_and_process_print({TestMesh::cube_20x20x20}, print, {
+	        	{ "first_layer_extrusion_width", 	"1" },
+	        	{ "brim_width", 					"6" },
+	        	{ "first_layer_extrusion_width", 	"0.5" }
+	        });
+			print.process();
             THEN("Brim Extrusion collection has 12 loops in it") {
-                REQUIRE(print->brim().items_count() == 14);
+                REQUIRE(print.brim().items_count() == 14);
             }
         }
     }

tests/fff_print/test_printgcode.cpp

@@ -17,16 +17,16 @@ std::regex skirt_regex("G1 X[-0-9.]* Y[-0-9.]* E[-0-9.]* ; skirt");
 
 SCENARIO( "PrintGCode basic functionality", "[PrintGCode]") {
     GIVEN("A default configuration and a print test object") {
-        Slic3r::DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
-
         WHEN("the output is executed with no support material") {
-			config.set_deserialize("layer_height", "0.2");
-			config.set_deserialize("first_layer_height", "0.2");
-            config.set_deserialize("first_layer_extrusion_width", "0");
-            config.set_deserialize("gcode_comments", "1");
-            config.set_deserialize("start_gcode", "");
+            Slic3r::Print print;
             Slic3r::Model model;
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({TestMesh::cube_20x20x20}, model, config);
+            Slic3r::Test::init_print({TestMesh::cube_20x20x20}, print, model, {
+                { "layer_height",					"0.2" },
+                { "first_layer_height",				"0.2" },
+                { "first_layer_extrusion_width",	"0" },
+                { "gcode_comments",					"1" },
+                { "start_gcode",					"" }
+                });
             std::string gcode = Slic3r::Test::gcode(print);
             THEN("Some text output is generated.") {
                 REQUIRE(gcode.size() > 0);
@@ -75,7 +75,7 @@ SCENARIO( "PrintGCode basic functionality", "[PrintGCode]") {
             THEN("final Z height is 20mm") {
                 double final_z = 0.0;
                 GCodeReader reader;
-                reader.apply_config(print->config());
+                reader.apply_config(print.config());
                 reader.parse_buffer(gcode, [&final_z] (GCodeReader& self, const GCodeReader::GCodeLine& line) {
                     final_z = std::max<double>(final_z, static_cast<double>(self.z())); // record the highest Z point we reach
                 });
@@ -83,16 +83,18 @@ SCENARIO( "PrintGCode basic functionality", "[PrintGCode]") {
             }
         }
         WHEN("output is executed with complete objects and two differently-sized meshes") {
+            Slic3r::Print print;
             Slic3r::Model model;
-            config.set_deserialize("first_layer_extrusion_width", "0");
-            config.set_deserialize("first_layer_height", "0.3");
-			config.set_deserialize("layer_height", "0.2");
-			config.set_deserialize("support_material", "0");
-            config.set_deserialize("raft_layers", "0");
-            config.set_deserialize("complete_objects", "1");
-            config.set_deserialize("gcode_comments", "1");
-            config.set_deserialize("between_objects_gcode", "; between-object-gcode");
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({TestMesh::cube_20x20x20,TestMesh::cube_20x20x20}, model, config);
+            Slic3r::Test::init_print({TestMesh::cube_20x20x20,TestMesh::cube_20x20x20}, print, model, {
+                { "first_layer_extrusion_width",    "0" },
+                { "first_layer_height",             "0.3" },
+                { "layer_height",                   "0.2" },
+                { "support_material",               "0" },
+                { "raft_layers",                    "0" },
+                { "complete_objects",               "1" },
+                { "gcode_comments",                 "1" },
+                { "between_objects_gcode",          "; between-object-gcode" }
+                });
             std::string gcode = Slic3r::Test::gcode(print);
             THEN("Some text output is generated.") {
                 REQUIRE(gcode.size() > 0);
@@ -115,7 +117,7 @@ SCENARIO( "PrintGCode basic functionality", "[PrintGCode]") {
             THEN("final Z height is 20.1mm") {
                 double final_z = 0.0;
                 GCodeReader reader;
-                reader.apply_config(print->config());
+                reader.apply_config(print.config());
                 reader.parse_buffer(gcode, [&final_z] (GCodeReader& self, const GCodeReader::GCodeLine& line) {
                     final_z = std::max(final_z, static_cast<double>(self.z())); // record the highest Z point we reach
                 });
@@ -125,7 +127,7 @@ SCENARIO( "PrintGCode basic functionality", "[PrintGCode]") {
                 double final_z = 0.0;
                 bool reset = false;
                 GCodeReader reader;
-                reader.apply_config(print->config());
+                reader.apply_config(print.config());
                 reader.parse_buffer(gcode, [&final_z, &reset] (GCodeReader& self, const GCodeReader::GCodeLine& line) {
                     if (final_z > 0 && std::abs(self.z() - 0.3) < 0.01 ) { // saw higher Z before this, now it's lower
                         reset = true;
@@ -139,7 +141,7 @@ SCENARIO( "PrintGCode basic functionality", "[PrintGCode]") {
                 double final_z = 0.0;
                 bool reset = false;
                 GCodeReader reader;
-                reader.apply_config(print->config());
+                reader.apply_config(print.config());
                 reader.parse_buffer(gcode, [&final_z, &reset] (GCodeReader& self, const GCodeReader::GCodeLine& line) {
                     if (final_z > 0 && std::abs(self.z() - 0.3) < 0.01 ) { 
                         reset = (final_z > 20.0);
@@ -151,13 +153,12 @@ SCENARIO( "PrintGCode basic functionality", "[PrintGCode]") {
             }
         }
         WHEN("the output is executed with support material") {
-            Slic3r::Model model;
-            config.set_deserialize("first_layer_extrusion_width", "0");
-            config.set_deserialize("support_material", "1");
-            config.set_deserialize("raft_layers", "3");
-            config.set_deserialize("gcode_comments", "1");
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({TestMesh::cube_20x20x20}, model, config);
-            std::string gcode = Slic3r::Test::gcode(print);
+            std::string gcode = ::Test::slice({TestMesh::cube_20x20x20}, {
+                { "first_layer_extrusion_width",    "0" },
+                { "support_material",               "1" },
+                { "raft_layers",                    "3" },
+                { "gcode_comments",                 "1" }
+                });
             THEN("Some text output is generated.") {
                 REQUIRE(gcode.size() > 0);
             }
@@ -175,10 +176,9 @@ SCENARIO( "PrintGCode basic functionality", "[PrintGCode]") {
             }
         }
         WHEN("the output is executed with a separate first layer extrusion width") {
-            Slic3r::Model model;
-            config.set_deserialize("first_layer_extrusion_width", "0.5");
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({TestMesh::cube_20x20x20}, model, config);
-            std::string gcode = Slic3r::Test::gcode(print);
+			std::string gcode = ::Test::slice({ TestMesh::cube_20x20x20 }, {
+                { "first_layer_extrusion_width", "0.5" }
+                });
             THEN("Some text output is generated.") {
                 REQUIRE(gcode.size() > 0);
             }
@@ -193,48 +193,46 @@ SCENARIO( "PrintGCode basic functionality", "[PrintGCode]") {
             }
         }
         WHEN("Cooling is enabled and the fan is disabled.") {
-            config.set_deserialize("cooling", "1");
-            config.set_deserialize("disable_fan_first_layers", "5");
-            Slic3r::Model model;
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({TestMesh::cube_20x20x20}, model, config);
-            std::string gcode = Slic3r::Test::gcode(print);
+			std::string gcode = ::Test::slice({ TestMesh::cube_20x20x20 }, {
+				{ "cooling",                    "1" },
+                { "disable_fan_first_layers",   "5" }
+                });
             THEN("GCode to disable fan is emitted."){
                 REQUIRE(gcode.find("M107") != std::string::npos);
             }
         }
         WHEN("end_gcode exists with layer_num and layer_z") {
-            config.set_deserialize("end_gcode", "; Layer_num [layer_num]\n; Layer_z [layer_z]");
-            config.set_deserialize("layer_height", "0.1");
-            config.set_deserialize("first_layer_height", "0.1");
-
-            Slic3r::Model model;
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({TestMesh::cube_20x20x20}, model, config);
-            std::string gcode = Slic3r::Test::gcode(print);
+			std::string gcode = ::Test::slice({ TestMesh::cube_20x20x20 }, {
+				{ "end_gcode",              "; Layer_num [layer_num]\n; Layer_z [layer_z]" },
+                { "layer_height",           "0.1" },
+                { "first_layer_height",     "0.1" }
+                });
             THEN("layer_num and layer_z are processed in the end gcode") {
                 REQUIRE(gcode.find("; Layer_num 199") != std::string::npos);
                 REQUIRE(gcode.find("; Layer_z 20") != std::string::npos);
             }
         }
         WHEN("current_extruder exists in start_gcode") {
-            config.set_deserialize("start_gcode", "; Extruder [current_extruder]");
             {
-                Slic3r::Model model;
-                std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({TestMesh::cube_20x20x20}, model, config);
-                std::string gcode = Slic3r::Test::gcode(print);
+				std::string gcode = ::Test::slice({ TestMesh::cube_20x20x20 }, {
+					{ "start_gcode", "; Extruder [current_extruder]" }
+                });
                 THEN("current_extruder is processed in the start gcode and set for first extruder") {
                     REQUIRE(gcode.find("; Extruder 0") != std::string::npos);
                 }
             }
-			config.set_num_extruders(4);
-			config.set_deserialize("infill_extruder", "2");
-			config.set_deserialize("solid_infill_extruder", "2");
-			config.set_deserialize("perimeter_extruder", "2");
-			config.set_deserialize("support_material_extruder", "2");
-			config.set_deserialize("support_material_interface_extruder", "2");
 			{
-                Slic3r::Model model;
-                std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({TestMesh::cube_20x20x20}, model, config);
-                std::string gcode = Slic3r::Test::gcode(print);
+                DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+                config.set_num_extruders(4);
+                config.set_deserialize({ 
+                    { "start_gcode",                    "; Extruder [current_extruder]" },
+                    { "infill_extruder",                "2" },
+                    { "solid_infill_extruder",          "2" },
+                    { "perimeter_extruder",             "2" },
+                    { "support_material_extruder",      "2" },
+                    { "support_material_interface_extruder", "2" }
+                });
+                std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, config);
                 THEN("current_extruder is processed in the start gcode and set for second extruder") {
                     REQUIRE(gcode.find("; Extruder 1") != std::string::npos);
                 }
@@ -242,15 +240,13 @@ SCENARIO( "PrintGCode basic functionality", "[PrintGCode]") {
         }
 
         WHEN("layer_num represents the layer's index from z=0") {
-			config.set_deserialize("complete_objects", "1");
-			config.set_deserialize("gcode_comments", "1");
-			config.set_deserialize("layer_gcode", ";Layer:[layer_num] ([layer_z] mm)");
-            config.set_deserialize("layer_height", "1.0");
-            config.set_deserialize("first_layer_height", "1.0");
-
-            Slic3r::Model model;
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({TestMesh::cube_20x20x20,TestMesh::cube_20x20x20}, model, config);
-            std::string gcode = Slic3r::Test::gcode(print);
+			std::string gcode = ::Test::slice({ TestMesh::cube_20x20x20, TestMesh::cube_20x20x20 }, {
+				{ "complete_objects",               "1" },
+                { "gcode_comments",                 "1" },
+                { "layer_gcode",                    ";Layer:[layer_num] ([layer_z] mm)" },
+                { "layer_height",                   "1.0" },
+                { "first_layer_height",             "1.0" }
+                });
 			// End of the 1st object.
 			size_t pos = gcode.find(";Layer:19 ");
 			THEN("First and second object last layer is emitted") {

tests/fff_print/test_printobject.cpp

@@ -19,9 +19,10 @@ SCENARIO("PrintObject: object layer heights", "[PrintObject]") {
         WHEN("generate_object_layers() is called for 2mm layer heights and nozzle diameter of 3mm") {
             config.opt_float("nozzle_diameter", 0) = 3;
 			config.opt_float("layer_height") = 2.0;
-			std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({m}, model, config);
-			print->process();
-			const std::vector<Slic3r::Layer*> &layers = print->objects().front()->layers();
+            Slic3r::Print print;
+            Slic3r::Test::init_print({m}, print, model, config);
+			print.process();
+			const std::vector<Slic3r::Layer*> &layers = print.objects().front()->layers();
             THEN("The output vector has 10 entries") {
                 REQUIRE(layers.size() == 10);
             }
@@ -36,9 +37,10 @@ SCENARIO("PrintObject: object layer heights", "[PrintObject]") {
         WHEN("generate_object_layers() is called for 10mm layer heights and nozzle diameter of 11mm") {
             config.opt_float("nozzle_diameter", 0) = 11;
 			config.opt_float("layer_height") = 10;
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({m}, model, config);
-			print->process();
-			const std::vector<Slic3r::Layer*> &layers = print->objects().front()->layers();
+            Slic3r::Print print;
+            Slic3r::Test::init_print({m}, print, model, config);
+			print.process();
+			const std::vector<Slic3r::Layer*> &layers = print.objects().front()->layers();
 			THEN("The output vector has 3 entries") {
                 REQUIRE(layers.size() == 3);
             }
@@ -52,9 +54,10 @@ SCENARIO("PrintObject: object layer heights", "[PrintObject]") {
         WHEN("generate_object_layers() is called for 15mm layer heights and nozzle diameter of 16mm") {
             config.opt_float("nozzle_diameter", 0) = 16;
             config.opt_float("layer_height") = 15.0;
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({m}, model, config);
-			print->process();
-			const std::vector<Slic3r::Layer*> &layers = print->objects().front()->layers();
+            Slic3r::Print print;
+            Slic3r::Test::init_print({m}, print, model, config);
+			print.process();
+			const std::vector<Slic3r::Layer*> &layers = print.objects().front()->layers();
 			THEN("The output vector has 2 entries") {
                 REQUIRE(layers.size() == 2);
             }
@@ -69,9 +72,10 @@ SCENARIO("PrintObject: object layer heights", "[PrintObject]") {
         WHEN("generate_object_layers() is called for 15mm layer heights and nozzle diameter of 5mm") {
             config.opt_float("nozzle_diameter", 0) = 5;
             config.opt_float("layer_height") = 15.0;
-            std::shared_ptr<Slic3r::Print> print = Slic3r::Test::init_print({m}, model, config);
-			print->process();
-			const std::vector<Slic3r::Layer*> &layers = print->objects().front()->layers();
+            Slic3r::Print print;
+            Slic3r::Test::init_print({m}, print, model, config);
+			print.process();
+			const std::vector<Slic3r::Layer*> &layers = print.objects().front()->layers();
 			THEN("The layer height is limited to 5mm.") {
                 CHECK(layers.size() == 5);
                 coordf_t last = 2.0;