From 6e871a874a4c1e5973ceb323993f940ac78d21eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20=C5=A0ach?= Date: Fri, 15 Dec 2023 11:05:45 +0100 Subject: [PATCH] Rewrite gcode.t to c++ --- t/gcode.t | 243 ---------------------- tests/fff_print/test_data.cpp | 31 ++- tests/fff_print/test_data.hpp | 10 +- tests/fff_print/test_gcode.cpp | 302 ++++++++++++++++++++++++++++ tests/fff_print/test_retraction.cpp | 28 ++- 5 files changed, 344 insertions(+), 270 deletions(-) delete mode 100644 t/gcode.t diff --git a/t/gcode.t b/t/gcode.t deleted file mode 100644 index 7bf6b06535..0000000000 --- a/t/gcode.t +++ /dev/null @@ -1,243 +0,0 @@ -use Test::More tests => 22; -use strict; -use warnings; - -BEGIN { - use FindBin; - use lib "$FindBin::Bin/../lib"; - use local::lib "$FindBin::Bin/../local-lib"; -} - -use List::Util qw(first); -use Slic3r; -use Slic3r::Geometry qw(scale convex_hull); -use Slic3r::Test; - -{ - my $config = Slic3r::Config::new_from_defaults; - $config->set('wipe', [1]); - $config->set('retract_layer_change', [0]); - - my $print = Slic3r::Test::init_print('20mm_cube', config => $config); - my $have_wipe = 0; - my @retract_speeds = (); - my $extruded_on_this_layer = 0; - my $wiping_on_new_layer = 0; - Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { - my ($self, $cmd, $args, $info) = @_; - - if ($info->{travel} && $info->{dist_Z}) { - # changing layer - $extruded_on_this_layer = 0; - } elsif ($info->{extruding} && $info->{dist_XY}) { - $extruded_on_this_layer = 1; - } elsif ($info->{retracting} && $info->{dist_XY} > 0) { - $have_wipe = 1; - $wiping_on_new_layer = 1 if !$extruded_on_this_layer; - my $move_time = $info->{dist_XY} / ($args->{F} // $self->F); - push @retract_speeds, abs($info->{dist_E}) / $move_time; - } - }); - - ok $have_wipe, "wipe"; - ok !defined (first { abs($_ - $config->retract_speed->[0]*60) < 5 } @retract_speeds), 'wipe moves don\'t retract faster than configured speed'; - ok !$wiping_on_new_layer, 'no wiping after layer change'; -} - -{ - my $config = Slic3r::Config::new_from_defaults; - $config->set('z_offset', 5); - $config->set('start_gcode', ''); - - my $test = sub { - my ($comment) = @_; - my $print = Slic3r::Test::init_print('20mm_cube', config => $config); - my $moves_below_z_offset = 0; - Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { - my ($self, $cmd, $args, $info) = @_; - - if ($info->{travel} && exists $args->{Z}) { - $moves_below_z_offset++ if $args->{Z} < $config->z_offset; - } - }); - is $moves_below_z_offset, 0, "no Z moves below Z offset ($comment)"; - }; - - $test->("no lift"); - - $config->set('retract_lift', [3]); - $test->("lift < z_offset"); - - $config->set('retract_lift', [6]); - $test->("lift > z_offset"); -} - -{ - # This tests the following behavior: - # - complete objects does not crash - # - no hard-coded "E" are generated - # - Z moves are correctly generated for both objects - # - no travel moves go outside skirt - # - temperatures are set correctly - my $config = Slic3r::Config::new_from_defaults; - $config->set('gcode_comments', 1); - $config->set('complete_objects', 1); - $config->set('extrusion_axis', 'A'); - $config->set('start_gcode', ''); # prevent any default extra Z move - $config->set('layer_height', 0.4); - $config->set('first_layer_height', 0.4); - $config->set('temperature', [200]); - $config->set('first_layer_temperature', [210]); - my $print = Slic3r::Test::init_print('20mm_cube', config => $config, duplicate => 2); - ok my $gcode = Slic3r::Test::gcode($print), "complete_objects"; - my @z_moves = (); - my @travel_moves = (); # array of scaled points - my @extrusions = (); # array of scaled points - my @temps = (); - Slic3r::GCode::Reader->new->parse($gcode, sub { - my ($self, $cmd, $args, $info) = @_; - fail 'unexpected E argument' if defined $args->{E}; - if (defined $args->{Z}) { - push @z_moves, $args->{Z}; - } - - if ($info->{dist_XY}) { - if ($info->{extruding} || $args->{A}) { - push @extrusions, Slic3r::Point->new_scale($info->{new_X}, $info->{new_Y}); - } else { - push @travel_moves, Slic3r::Point->new_scale($info->{new_X}, $info->{new_Y}) - if @extrusions; # skip initial travel move to first skirt point - } - } elsif ($cmd eq 'M104' || $cmd eq 'M109') { - push @temps, $args->{S} if !@temps || $args->{S} != $temps[-1]; - } - }); - my $layer_count = 20/0.4; # cube is 20mm tall - is scalar(@z_moves), 2*$layer_count, 'complete_objects generates the correct number of Z moves'; - is_deeply [ @z_moves[0..($layer_count-1)] ], [ @z_moves[$layer_count..$#z_moves] ], 'complete_objects generates the correct Z moves'; - - my $convex_hull = convex_hull(\@extrusions); - ok !(defined first { !$convex_hull->contains_point($_) } @travel_moves), 'all travel moves happen within skirt'; - - is_deeply \@temps, [210, 200, 210, 200, 0], 'expected temperature changes'; -} - -{ - my $config = Slic3r::Config::new_from_defaults; - $config->set('retract_length', [1000000]); - $config->set('use_relative_e_distances', 1); - $config->set('layer_gcode', "G92 E0\n"); - my $print = Slic3r::Test::init_print('20mm_cube', config => $config); - Slic3r::Test::gcode($print); - ok $print->print->total_used_filament > 0, 'final retraction is not considered in total used filament'; -} - -{ - my $test = sub { - my ($print, $comment) = @_; - - my @percent = (); - my $got_100 = 0; - my $extruding_after_100 = 0; - Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { - my ($self, $cmd, $args, $info) = @_; - - if ($cmd eq 'M73') { - push @percent, $args->{P}; - $got_100 = 1 if $args->{P} eq '100'; - } - if ($info->{extruding} && $got_100) { - $extruding_after_100 = 1; - } - }); - # the extruder heater is turned off when M73 P100 is reached - ok !(defined first { $_ > 100 } @percent), "M73 is never given more than 100% ($comment)"; - ok !$extruding_after_100, "no extrusions after M73 P100 ($comment)"; - }; - - { - my $config = Slic3r::Config::new_from_defaults; - $config->set('gcode_flavor', 'sailfish'); - $config->set('raft_layers', 3); - my $print = Slic3r::Test::init_print('20mm_cube', config => $config); - $test->($print, 'single object'); - } - - { - my $config = Slic3r::Config::new_from_defaults; - $config->set('gcode_flavor', 'sailfish'); - my $print = Slic3r::Test::init_print('20mm_cube', config => $config, duplicate => 2); - $test->($print, 'two copies of single object'); - } - - { - my $config = Slic3r::Config::new_from_defaults; - $config->set('gcode_flavor', 'sailfish'); - my $print = Slic3r::Test::init_print(['20mm_cube','20mm_cube'], config => $config); - $test->($print, 'two objects'); - } - - { - my $config = Slic3r::Config::new_from_defaults; - $config->set('gcode_flavor', 'sailfish'); - my $print = Slic3r::Test::init_print('20mm_cube', config => $config, scale_xyz => [1,1, 1/(20/$config->layer_height) ]); - $test->($print, 'one layer object'); - } -} - -#{ -# [input_filename] placeholder was removed in 0cbbe96. -# my $config = Slic3r::Config::new_from_defaults; -# $config->set('start_gcode', 'START:[input_filename]'); -# my $print = Slic3r::Test::init_print('20mm_cube', config => $config); -# my $gcode = Slic3r::Test::gcode($print); -# like $gcode, qr/START:20mm_cube/, '[input_filename] is also available in custom G-code'; -#} - -# The current Spiral Vase slicing code removes the holes and all but the largest contours from each slice, -# therefore the following test is no more valid. -#{ -# my $config = Slic3r::Config::new_from_defaults; -# $config->set('spiral_vase', 1); -# my $print = Slic3r::Test::init_print('cube_with_hole', config => $config); -# -# my $spiral = 0; -# Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { -# my ($self, $cmd, $args, $info) = @_; -# -# if ($cmd eq 'G1' && exists $args->{E} && exists $args->{Z}) { -# $spiral = 1; -# } -# }); -# -# ok !$spiral, 'spiral vase is correctly disabled on layers with multiple loops'; -#} - - -{ - # Tests that the Repetier flavor produces M201 Xnnn Ynnn for resetting - # acceleration, also that M204 Snnn syntax is not generated. - my $config = Slic3r::Config::new_from_defaults; - $config->set('gcode_flavor', 'repetier'); - $config->set('default_acceleration', 1337); - my $print = Slic3r::Test::init_print('cube_with_hole', config => $config); - - my $has_accel = 0; - my $has_m204 = 0; - Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { - my ($self, $cmd, $args, $info) = @_; - - if ($cmd eq 'M201' && exists $args->{X} && exists $args->{Y}) { - if ($args->{X} == 1337 && $args->{Y} == 1337) { - $has_accel = 1; - } - } - if ($cmd eq 'M204' && exists $args->{S}) { - $has_m204 = 1; - } - }); - ok $has_accel, 'M201 is generated for repetier firmware.'; - ok !$has_m204, 'M204 is not generated for repetier firmware'; -} - -__END__ diff --git a/tests/fff_print/test_data.cpp b/tests/fff_print/test_data.cpp index 79064e2c72..b28196b2bd 100644 --- a/tests/fff_print/test_data.cpp +++ b/tests/fff_print/test_data.cpp @@ -236,7 +236,7 @@ static bool verbose_gcode() return s == "1" || s == "on" || s == "yes"; } -void init_print(std::vector &&meshes, Slic3r::Print &print, Slic3r::Model &model, const DynamicPrintConfig &config_in, bool comments) +void init_print(std::vector &&meshes, Slic3r::Print &print, Slic3r::Model &model, const DynamicPrintConfig &config_in, bool comments, unsigned duplicate_count) { DynamicPrintConfig config = DynamicPrintConfig::full_print_config(); config.apply(config_in); @@ -247,10 +247,19 @@ void init_print(std::vector &&meshes, Slic3r::Print &print, Slic3r for (const TriangleMesh &t : meshes) { ModelObject *object = model.add_object(); object->name += "object.stl"; - object->add_volume(std::move(t)); + object->add_volume(t); object->add_instance(); } - arrange_objects(model, arr2::to_arrange_bed(get_bed_shape(config)), arr2::ArrangeSettings{}.set_distance_from_objects(min_object_distance(config))); + + double distance = min_object_distance(config); + arr2::ArrangeSettings arrange_settings{}; + arrange_settings.set_distance_from_objects(distance); + arr2::ArrangeBed bed{arr2::to_arrange_bed(get_bed_shape(config))}; + if (duplicate_count > 1) { + duplicate(model, duplicate_count, bed, arrange_settings); + } + + arrange_objects(model, bed, arrange_settings); model.center_instances_around_point({100, 100}); for (ModelObject *mo : model.objects) { mo->ensure_on_bed(); @@ -262,36 +271,36 @@ void init_print(std::vector &&meshes, Slic3r::Print &print, Slic3r print.set_status_silent(); } -void init_print(std::initializer_list test_meshes, Slic3r::Print &print, Slic3r::Model &model, const Slic3r::DynamicPrintConfig &config_in, bool comments) +void init_print(std::initializer_list test_meshes, Slic3r::Print &print, Slic3r::Model &model, const Slic3r::DynamicPrintConfig &config_in, bool comments, unsigned duplicate_count) { std::vector triangle_meshes; triangle_meshes.reserve(test_meshes.size()); for (const TestMesh test_mesh : test_meshes) triangle_meshes.emplace_back(mesh(test_mesh)); - init_print(std::move(triangle_meshes), print, model, config_in, comments); + init_print(std::move(triangle_meshes), print, model, config_in, comments, duplicate_count); } -void init_print(std::initializer_list input_meshes, Slic3r::Print &print, Slic3r::Model &model, const DynamicPrintConfig &config_in, bool comments) +void init_print(std::initializer_list input_meshes, Slic3r::Print &print, Slic3r::Model &model, const DynamicPrintConfig &config_in, bool comments, unsigned duplicate_count) { std::vector triangle_meshes; triangle_meshes.reserve(input_meshes.size()); for (const TriangleMesh &input_mesh : input_meshes) triangle_meshes.emplace_back(input_mesh); - init_print(std::move(triangle_meshes), print, model, config_in, comments); + init_print(std::move(triangle_meshes), print, model, config_in, comments, duplicate_count); } -void init_print(std::initializer_list meshes, Slic3r::Print &print, Slic3r::Model &model, std::initializer_list config_items, bool comments) +void init_print(std::initializer_list meshes, Slic3r::Print &print, Slic3r::Model &model, std::initializer_list config_items, bool comments, unsigned duplicate_count) { Slic3r::DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config(); config.set_deserialize_strict(config_items); - init_print(meshes, print, model, config, comments); + init_print(meshes, print, model, config, comments, duplicate_count); } -void init_print(std::initializer_list meshes, Slic3r::Print &print, Slic3r::Model &model, std::initializer_list config_items, bool comments) +void init_print(std::initializer_list meshes, Slic3r::Print &print, Slic3r::Model &model, std::initializer_list config_items, bool comments, unsigned duplicate_count) { Slic3r::DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config(); config.set_deserialize_strict(config_items); - init_print(meshes, print, model, config, comments); + init_print(meshes, print, model, config, comments, duplicate_count); } void init_and_process_print(std::initializer_list meshes, Slic3r::Print &print, const DynamicPrintConfig &config, bool comments) diff --git a/tests/fff_print/test_data.hpp b/tests/fff_print/test_data.hpp index fd110caf1b..12ff0f551d 100644 --- a/tests/fff_print/test_data.hpp +++ b/tests/fff_print/test_data.hpp @@ -63,11 +63,11 @@ template bool _equiv(const T& a, const T& b, double epsilon) { return abs(a - b) < epsilon; } Slic3r::Model model(const std::string& model_name, TriangleMesh&& _mesh); -void init_print(std::vector &&meshes, Slic3r::Print &print, Slic3r::Model& model, const DynamicPrintConfig &config_in, bool comments = false); -void init_print(std::initializer_list 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 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 meshes, Slic3r::Print &print, Slic3r::Model& model, std::initializer_list config_items, bool comments = false); -void init_print(std::initializer_list meshes, Slic3r::Print &print, Slic3r::Model& model, std::initializer_list config_items, bool comments = false); +void init_print(std::vector &&meshes, Slic3r::Print &print, Slic3r::Model& model, const DynamicPrintConfig &config_in, bool comments = false, unsigned duplicate_count = 1); +void init_print(std::initializer_list meshes, Slic3r::Print &print, Slic3r::Model& model, const Slic3r::DynamicPrintConfig &config_in = Slic3r::DynamicPrintConfig::full_print_config(), bool comments = false, unsigned duplicate_count = 1); +void init_print(std::initializer_list meshes, Slic3r::Print &print, Slic3r::Model& model, const Slic3r::DynamicPrintConfig &config_in = Slic3r::DynamicPrintConfig::full_print_config(), bool comments = false, unsigned duplicate = 1); +void init_print(std::initializer_list meshes, Slic3r::Print &print, Slic3r::Model& model, std::initializer_list config_items, bool comments = false, unsigned duplicate = 1); +void init_print(std::initializer_list meshes, Slic3r::Print &print, Slic3r::Model& model, std::initializer_list config_items, bool comments = false, unsigned duplicate = 1); void init_and_process_print(std::initializer_list meshes, Slic3r::Print &print, const DynamicPrintConfig& config, bool comments = false); void init_and_process_print(std::initializer_list meshes, Slic3r::Print &print, const DynamicPrintConfig& config, bool comments = false); diff --git a/tests/fff_print/test_gcode.cpp b/tests/fff_print/test_gcode.cpp index 3ec1758b4e..a61ca2dd8a 100644 --- a/tests/fff_print/test_gcode.cpp +++ b/tests/fff_print/test_gcode.cpp @@ -1,10 +1,22 @@ +/** + * Mostly ported from t/gcode.t + */ + #include #include +#include +#include #include "libslic3r/GCode.hpp" +#include "libslic3r/Geometry/ConvexHull.hpp" +#include "libslic3r/ModelArrange.hpp" +#include "test_data.hpp" using namespace Slic3r; +using namespace Test; + +constexpr bool debug_files = false; SCENARIO("Origin manipulation", "[GCode]") { Slic3r::GCodeGenerator gcodegen; @@ -20,3 +32,293 @@ SCENARIO("Origin manipulation", "[GCode]") { } } } + + +TEST_CASE("Wiping speeds", "[GCode]") { + DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config(); + config.set_deserialize_strict({ + { "wipe", "1" }, + { "retract_layer_change", "0" }, + }); + bool have_wipe = false; + std::vector retract_speeds; + bool extruded_on_this_layer = false; + bool wiping_on_new_layer = false; + + GCodeReader parser; + std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, config); + parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) { + if (line.travel() && line.dist_Z(self) != 0) { + extruded_on_this_layer = false; + } else if (line.extruding(self) && line.dist_XY(self) > 0) { + extruded_on_this_layer = true; + } else if (line.retracting(self) && line.dist_XY(self) > 0) { + have_wipe = true; + wiping_on_new_layer = !extruded_on_this_layer; + const double f = line.has_f() ? line.f() : self.f(); + double move_time = line.dist_XY(self) / f; + retract_speeds.emplace_back(std::abs(line.dist_E(self)) / move_time); + } + }); + CHECK(have_wipe); + double expected_retract_speed = config.option("retract_speed")->get_at(0) * 60; + for (const double retract_speed : retract_speeds) { + INFO("Wipe moves don\'t retract faster than configured speed"); + CHECK(retract_speed < expected_retract_speed); + } + INFO("No wiping after layer change") + CHECK(!wiping_on_new_layer); +} + +bool has_moves_below_z_offset(const DynamicPrintConfig& config) { + GCodeReader parser; + std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, config); + + unsigned moves_below_z_offset{}; + double configured_offset = config.opt_float("z_offset"); + parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) { + if (line.travel() && line.has_z() && line.z() < configured_offset) { + moves_below_z_offset++; + } + }); + return moves_below_z_offset > 0; +} + +TEST_CASE("Z moves with offset", "[GCode]") { + DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config(); + config.set_deserialize_strict({ + { "z_offset", 5 }, + { "start_gcode", "" }, + }); + + INFO("No lift"); + CHECK(!has_moves_below_z_offset(config)); + + config.set_deserialize_strict({{ "retract_lift", "3" }}); + INFO("Lift < z offset"); + CHECK(!has_moves_below_z_offset(config)); + + config.set_deserialize_strict({{ "retract_lift", "6" }}); + INFO("Lift > z offset"); + CHECK(!has_moves_below_z_offset(config)); +} + +std::optional parse_axis(const std::string& line, const std::string& axis) { + std::smatch matches; + if (std::regex_search(line, matches, std::regex{axis + "(\\d+)"})) { + std::string matchedValue = matches[1].str(); + return std::stod(matchedValue); + } + return std::nullopt; +} + +/** +* This tests the following behavior: +* - complete objects does not crash +* - no hard-coded "E" are generated +* - Z moves are correctly generated for both objects +* - no travel moves go outside skirt +* - temperatures are set correctly +*/ +TEST_CASE("Extrusion, travels, temeperatures", "[GCode]") { + DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config(); + config.set_deserialize_strict({ + { "gcode_comments", 1 }, + { "complete_objects", 1 }, + { "extrusion_axis", 'A' }, + { "start_gcode", "" }, // prevent any default extra Z move + { "layer_height", 0.4 }, + { "first_layer_height", 0.4 }, + { "temperature", "200" }, + { "first_layer_temperature", "210" } + }); + + std::vector z_moves; + Points travel_moves; + Points extrusions; + std::vector temps; + + GCodeReader parser; + + Print print; + Model model; + Test::init_print({TestMesh::cube_20x20x20}, print, model, config, false, 2); + std::string gcode = Test::gcode(print); + parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) { + INFO("Unexpected E argument"); + CHECK(!line.has_e()); + + if (line.has_z()) { + z_moves.emplace_back(line.z()); + } + if (line.has_x() || line.has_y()) { + if (line.extruding(self) || line.has_unknown_axis()) { + extrusions.emplace_back(scaled(line.x()), scaled(line.y())); + } else if (!extrusions.empty()){ // skip initial travel move to first skirt point + travel_moves.emplace_back(scaled(line.x()), scaled(line.y())); + } + } else if (line.cmd_is("M104") || line.cmd_is("M109")) { + const std::optional parsed_temperature = parse_axis(line.raw(), "S"); + if (!parsed_temperature) { + FAIL("Failed to parse temperature!"); + } + if (temps.empty() || temps.back() != parsed_temperature) { + temps.emplace_back(*parsed_temperature); + } + } + }); + + const unsigned layer_count = 20 / 0.4; + INFO("Complete_objects generates the correct number of Z moves."); + CHECK(z_moves.size() == layer_count * 2); + auto first_moves = tcb::span{z_moves}.subspan(0, layer_count); + auto second_moves = tcb::span{z_moves}.subspan(layer_count); + + CHECK( std::vector(first_moves.begin(), first_moves.end()) == std::vector(second_moves.begin(), second_moves.end())); + const Polygon convex_hull{Geometry::convex_hull(extrusions)}; + INFO("All travel moves happen within skirt."); + for (const Point& travel_move : travel_moves) { + CHECK(convex_hull.contains(travel_move)); + } + INFO("Expected temperature changes"); + CHECK(temps == std::vector{210, 200, 210, 200, 0}); +} + + +TEST_CASE("Used filament", "[GCode]") { + DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config(); + config.set_deserialize_strict({ + { "retract_length", "1000000" }, + { "use_relative_e_distances", 1 }, + { "layer_gcode", "G92 E0\n" }, + }); + GCodeReader parser; + Print print; + Model model; + Test::init_print({TestMesh::cube_20x20x20}, print, model, config); + Test::gcode(print); + + INFO("Final retraction is not considered in total used filament"); + CHECK(print.print_statistics().total_used_filament > 0); +} + +void check_m73s(Print& print){ + std::vector percent{}; + bool got_100 = false; + bool extruding_after_100 = 0; + + GCodeReader parser; + std::string gcode = Slic3r::Test::gcode(print); + parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) { + + if (line.cmd_is("M73")) { + std::optional p = parse_axis(line.raw(), "P"); + if (!p) { + FAIL("Failed to parse percent"); + } + percent.emplace_back(*p); + got_100 = p == Approx(100); + } + if (line.extruding(self) && got_100) { + extruding_after_100 = true; + } + }); + INFO("M73 is never given more than 100%"); + for (const double value : percent) { + CHECK(value <= 100); + } + INFO("No extrusions after M73 P100."); + CHECK(!extruding_after_100); +} + + +TEST_CASE("M73s have correct percent values", "[GCode]") { + DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config(); + + SECTION("Single object") { + config.set_deserialize_strict({ + {" gcode_flavor", "sailfish" }, + {" raft_layers", 3 }, + }); + + Print print; + Model model; + Test::init_print({TestMesh::cube_20x20x20}, print, model, config); + check_m73s(print); + } + + SECTION("Two copies of single object") { + config.set_deserialize_strict({ + {" gcode_flavor", "sailfish" }, + }); + Print print; + Model model; + + Test::init_print({TestMesh::cube_20x20x20}, print, model, config, false, 2); + check_m73s(print); + + if constexpr (debug_files) { + std::ofstream gcode_file{"M73_2_copies.gcode"}; + gcode_file << Test::gcode(print); + } + } + + SECTION("Two objects") { + config.set_deserialize_strict({ + {" gcode_flavor", "sailfish" }, + }); + Print print; + Model model; + Test::init_print({TestMesh::cube_20x20x20, TestMesh::cube_20x20x20}, print, model, config); + check_m73s(print); + } + + SECTION("One layer object") { + config.set_deserialize_strict({ + {" gcode_flavor", "sailfish" }, + }); + Print print; + Model model; + TriangleMesh test_mesh{mesh(TestMesh::cube_20x20x20)}; + const double layer_height = config.opt_float("layer_height"); + test_mesh.scale(Vec3f{1, 1, layer_height/20}); + Test::init_print({test_mesh}, print, model, config); + check_m73s(print); + + if constexpr (debug_files) { + std::ofstream gcode_file{"M73_one_layer.gcode"}; + gcode_file << Test::gcode(print); + } + } +} + + +TEST_CASE("M201 for acceleation reset", "[GCode]") { + DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config(); + config.set_deserialize_strict({ + { "gcode_flavor", "repetier" }, + { "default_acceleration", 1337 }, + }); + + GCodeReader parser; + std::string gcode = Slic3r::Test::slice({TestMesh::cube_with_hole}, config); + + bool has_accel = false; + bool has_m204 = false; + + parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) { + if (line.cmd_is("M201") && line.has_x() && line.has_y()) { + if (line.x() == 1337 && line.y() == 1337) { + has_accel = true; + } + } + if (line.cmd_is("M204") && line.raw().find('S') != std::string::npos) { + has_m204 = true; + } + }); + + INFO("M201 is generated for repetier firmware."); + CHECK(has_accel); + INFO("M204 is not generated for repetier firmware"); + CHECK(!has_m204); +} diff --git a/tests/fff_print/test_retraction.cpp b/tests/fff_print/test_retraction.cpp index d75a92368b..0c7d42a766 100644 --- a/tests/fff_print/test_retraction.cpp +++ b/tests/fff_print/test_retraction.cpp @@ -13,9 +13,7 @@ using namespace Slic3r; using namespace Test; -void check_gcode(std::initializer_list meshes, const DynamicPrintConfig& config) { - std::string gcode = Slic3r::Test::slice(meshes, config); - +void check_gcode(std::initializer_list meshes, const DynamicPrintConfig& config, const unsigned duplicate) { constexpr std::size_t tools_count = 4; std::size_t tool = 0; std::array toolchange_count{0}; // Track first usages so that we don't expect retract_length_toolchange when extruders are used for the first time @@ -26,6 +24,10 @@ void check_gcode(std::initializer_list meshes, const DynamicPrintConfi bool changed_tool = false; bool wait_for_toolchange = false; + Print print; + Model model; + Test::init_print({TestMesh::cube_20x20x20}, print, model, config, false, duplicate); + std::string gcode = Test::gcode(print); GCodeReader parser; parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) { @@ -114,24 +116,24 @@ void check_gcode(std::initializer_list meshes, const DynamicPrintConfi }); } -void test_slicing(std::initializer_list meshes, DynamicPrintConfig& config) { +void test_slicing(std::initializer_list meshes, DynamicPrintConfig& config, const unsigned duplicate = 1) { SECTION("Retraction") { - check_gcode(meshes, config); + check_gcode(meshes, config, duplicate); } SECTION("Restart extra length") { config.set_deserialize_strict({{ "retract_restart_extra", "1" }}); - check_gcode(meshes, config); + check_gcode(meshes, config, duplicate); } SECTION("Negative restart extra length") { config.set_deserialize_strict({{ "retract_restart_extra", "-1" }}); - check_gcode(meshes, config); + check_gcode(meshes, config, duplicate); } SECTION("Retract_lift") { config.set_deserialize_strict({{ "retract_lift", "1,2" }}); - check_gcode(meshes, config); + check_gcode(meshes, config, duplicate); } } @@ -149,10 +151,10 @@ TEST_CASE("Slicing with retraction and lifing", "[retraction]") { }); SECTION("Standard run") { - //test_slicing({TestMesh::cube_20x20x20}, config); + test_slicing({TestMesh::cube_20x20x20}, config); } SECTION("With duplicate cube") { - //test_slicing({TestMesh::cube_20x20x20, TestMesh::cube_20x20x20}, config); + test_slicing({TestMesh::cube_20x20x20}, config, 2); } SECTION("Dual extruder with multiple skirt layers") { config.set_deserialize_strict({ @@ -258,8 +260,12 @@ TEST_CASE("Firmware retraction when length is 0", "[retraction]") { } std::vector get_lift_layers(const DynamicPrintConfig& config) { + Print print; + Model model; + Test::init_print({TestMesh::cube_20x20x20}, print, model, config, false, 2); + std::string gcode = Test::gcode(print); + std::vector result; - const std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, config); GCodeReader parser; parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) { if (line.cmd_is("G1") && line.dist_Z(self) < 0) {