GitHub-Proxy/Slic3r
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/slic3r/Slic3r.git synced 2025-08-02 02:00:42 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Wrote accessor tests and accompanying implementation.

Browse Source
This commit is contained in:
Joseph Lenox 2018-07-12 21:54:10 -05:00
parent 40cedc350c
commit 7861037556
3 changed files with 184 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
src/test/libslic3r/test_config.cpp
View File

@ -12,7 +12,7 @@ SCENARIO("Generic config validation performs as expected.") {
GIVEN("A config generated from default options") { GIVEN("A config generated from default options") {
auto config {Slic3r::Config::new_from_defaults()}; auto config {Slic3r::Config::new_from_defaults()};
WHEN( "perimeter_extrusion_width is set to 250%, a valid value") { WHEN( "perimeter_extrusion_width is set to 250%, a valid value") {
config->set("perimeter_extrusion_width", "250\%"); config->set("perimeter_extrusion_width", "250%");
THEN( "The config is read as valid.") { THEN( "The config is read as valid.") {
REQUIRE(config->validate() == true); REQUIRE(config->validate() == true);
} }
@ -29,59 +29,99 @@ SCENARIO("Generic config validation performs as expected.") {
REQUIRE(except_thrown == true); REQUIRE(except_thrown == true);
} }
} }
WHEN( "perimeters is set to -10, an invalid value") {
config->set("perimeters", -10);
THEN( "An InvalidOptionValue exception is thrown.") {
auto except_thrown {false};
try {
config->validate();
} catch (const InvalidOptionValue& e) {
except_thrown = true;
}
REQUIRE(except_thrown == true);
}
}
} }
} }
SCENARIO("Config accessor functions perform as expected.", "[!mayfail]") { SCENARIO("Config accessor functions perform as expected.") {
GIVEN("A config generated from default options") { GIVEN("A config generated from default options") {
auto config {Slic3r::Config::new_from_defaults()}; auto config {Slic3r::Config::new_from_defaults()};
WHEN("A numeric option is set through the string interface") { WHEN("A numeric option is set through the string interface") {
config->set("bed_temperature", "100");
THEN("The underlying value is set correctly.") { THEN("The underlying value is set correctly.") {
REQUIRE(false); REQUIRE(config->get<ConfigOptionInt>("bed_temperature").getInt() == 100);
} }
} }
WHEN("An integer-based option is set through the integer interface") { WHEN("An integer-based option is set through the integer interface") {
config->set("bed_temperature", 100);
THEN("The underlying value is set correctly.") { THEN("The underlying value is set correctly.") {
REQUIRE(false); REQUIRE(config->get<ConfigOptionInt>("bed_temperature").getInt() == 100);
} }
} }
WHEN("An floating-point option is set through the integer interface") { WHEN("An floating-point option is set through the integer interface") {
config->set("perimeter_speed", 10);
THEN("The underlying value is set correctly.") { THEN("The underlying value is set correctly.") {
REQUIRE(false); REQUIRE(config->get<ConfigOptionFloat>("perimeter_speed").getFloat() == 10.0);
} }
} }
WHEN("A floating-point option is set through the double interface") { WHEN("A floating-point option is set through the double interface") {
config->set("perimeter_speed", 5.5);
THEN("The underlying value is set correctly.") { THEN("The underlying value is set correctly.") {
REQUIRE(false); REQUIRE(config->get<ConfigOptionFloat>("perimeter_speed").getFloat() == 5.5);
} }
} }
WHEN("An integer-based option is set through the double interface") { WHEN("An integer-based option is set through the double interface") {
config->set("bed_temperature", 5.5);
THEN("The underlying value is set, rounded to the nearest integer.") { THEN("The underlying value is set, rounded to the nearest integer.") {
REQUIRE(false); REQUIRE(config->get<ConfigOptionInt>("bed_temperature").getInt() == 6);
} }
} }
WHEN("A numeric option is set to a non-numeric value.") { WHEN("A numeric option is set to a non-numeric value.") {
auto except_thrown {false}; auto except_thrown {false};
try { try {
config->set("perimeter_extrusion_width", "zzzz"); config->set("perimeter_speed", "zzzz");
} catch (const InvalidOptionType& e) { } catch (const InvalidOptionValue& e) {
except_thrown = true; except_thrown = true;
} }
THEN("An exception is thown.") { THEN("An InvalidOptionValue exception is thown.") {
REQUIRE(except_thrown == true); REQUIRE(except_thrown == true);
} }
THEN("The value does not change.") { THEN("The value does not change.") {
REQUIRE(false); REQUIRE(config->get<ConfigOptionFloat>("perimeter_speed").getFloat() == 60.0);
} }
} }
WHEN("An invalid option is requested during set.") { WHEN("An invalid option is requested during set (string).") {
auto except_thrown {false}; auto except_thrown {false};
try { try {
config->set("deadbeef_invalid_option", "1"); config->set("deadbeef_invalid_option", "1");
} catch (const InvalidOptionType& e) { } catch (const InvalidOptionType& e) {
except_thrown = true; except_thrown = true;
} }
THEN("An exception is thrown.") { THEN("An InvalidOptionType exception is thrown.") {
REQUIRE(except_thrown == true);
}
}
WHEN("An invalid option is requested during set (double).") {
auto except_thrown {false};
try {
config->set("deadbeef_invalid_option", 1.0);
} catch (const InvalidOptionType& e) {
except_thrown = true;
}
THEN("An InvalidOptionType exception is thrown.") {
REQUIRE(except_thrown == true);
}
}
WHEN("An invalid option is requested during set (int).") {
auto except_thrown {false};
try {
config->set("deadbeef_invalid_option", 1);
} catch (const InvalidOptionType& e) {
except_thrown = true;
}
THEN("An InvalidOptionType exception is thrown.") {
REQUIRE(except_thrown == true); REQUIRE(except_thrown == true);
} }
} }
@ -92,7 +132,18 @@ SCENARIO("Config accessor functions perform as expected.", "[!mayfail]") {
} catch (const InvalidOptionType& e) { } catch (const InvalidOptionType& e) {
except_thrown = true; except_thrown = true;
} }
THEN("An exception is thrown.") { THEN("An InvalidOptionType exception is thrown.") {
REQUIRE(except_thrown == true);
}
}
WHEN("An invalid option is requested during get_ptr.") {
auto except_thrown {false};
try {
config->get_ptr<std::string>("deadbeef_invalid_option", false);
} catch (const InvalidOptionType& e) {
except_thrown = true;
}
THEN("An InvalidOptionType exception is thrown.") {
REQUIRE(except_thrown == true); REQUIRE(except_thrown == true);
} }
} }

147
xs/src/libslic3r/Config.cpp
View File

@ -64,7 +64,7 @@ Config::validate()
try { try {
tmp_opt = get_ptr<ConfigOptionVectorBase>(k); tmp_opt = get_ptr<ConfigOptionVectorBase>(k);
} catch (std::bad_cast) { } catch (std::bad_cast) {
throw InvalidOptionValue((std::string("Invalid value for ") + std::string(k)).c_str()); throw InvalidOptionType((std::string("(cast failure) Invalid value for ") + std::string(k)).c_str());
} }
auto tmp_str {tmp_opt->vserialize()}; auto tmp_str {tmp_opt->vserialize()};
values.insert(values.end(), tmp_str.begin(), tmp_str.end()); values.insert(values.end(), tmp_str.begin(), tmp_str.end());
@ -75,11 +75,10 @@ Config::validate()
} }
// Verify each value // Verify each value
for (auto v : values) { for (auto v : values) {
Slic3r::Log::debug("Config::validate", v);
if (type == "i" || type == "f" || opt.type == coPercent || opt.type == coFloatOrPercent) { if (type == "i" || type == "f" || opt.type == coPercent || opt.type == coFloatOrPercent) {
if (opt.type == coPercent || opt.type == coFloatOrPercent) if (opt.type == coPercent || opt.type == coFloatOrPercent)
v = std::regex_replace(v, std::regex("%$"), std::string("")); v = std::regex_replace(v, std::regex("%$"), std::string(""));
if (!is_valid_int(type, opt, v) || !is_valid_float(type, opt, v)) { if ((type == "i" && !is_valid_int(type, opt, v)) || !is_valid_float(type, opt, v)) {
throw InvalidOptionValue((std::string("Invalid value for ") + std::string(k)).c_str()); throw InvalidOptionValue((std::string("Invalid value for ") + std::string(k)).c_str());
} }
} }
@ -91,46 +90,130 @@ Config::validate()
void void
Config::set(const t_config_option_key& opt_key, const std::string& value) Config::set(const t_config_option_key& opt_key, const std::string& value)
{ {
try {
const auto& def {print_config_def.options.at(opt_key)};
switch (def.type) {
case coInt:
{
auto* ptr {dynamic_cast<ConfigOptionInt*>(this->optptr(opt_key, true))};
ptr->setInt(std::stoi(value));
} break;
case coInts:
{
auto* ptr {dynamic_cast<ConfigOptionInts*>(this->optptr(opt_key, true))};
if (!ptr->deserialize(value, true) ) {
throw InvalidOptionValue(std::string(opt_key) + std::string(" set with invalid value."));
}
} break;
case coFloat:
{
auto* ptr {dynamic_cast<ConfigOptionFloat*>(this->optptr(opt_key, true))};
ptr->setFloat(std::stod(value));
} break;
case coFloatOrPercent:
{
auto* ptr {dynamic_cast<ConfigOptionFloatOrPercent*>(this->optptr(opt_key, true))};
const size_t perc = value.find("%");
ptr->percent = (perc != std::string::npos);
if (ptr->percent)
ptr->setFloat(std::stod(std::string(value).replace(value.find("%"), std::string("%").length(), "")));
else
ptr->setFloat(std::stod(value));
} break;
case coFloats:
{
auto* ptr {dynamic_cast<ConfigOptionFloats*>(this->optptr(opt_key, true))};
if (!ptr->deserialize(value, true) ) {
throw InvalidOptionValue(std::string(opt_key) + std::string(" set with invalid value."));
}
} break;
default:
Slic3r::Log::warn("Config::set", "Unknown set type.");
}
} catch (std::invalid_argument &e) {
throw InvalidOptionValue(std::string(opt_key) + std::string(" set with invalid value."));
} catch (std::out_of_range &e) {
throw InvalidOptionType(std::string(opt_key) + std::string(" is an invalid Slic3r option."));
}
} }
void void
Config::set(const t_config_option_key& opt_key, const int value) Config::set(const t_config_option_key& opt_key, const int value)
{ {
const auto& def {print_config_def.options.at(opt_key)}; try {
switch (def.type) { const auto& def {print_config_def.options.at(opt_key)};
case coInt: switch (def.type) {
{ case coInt:
auto* ptr {dynamic_cast<ConfigOptionInt*>(this->optptr(opt_key, true))}; {
ptr->setInt(value); auto* ptr {dynamic_cast<ConfigOptionInt*>(this->optptr(opt_key, true))};
} break; ptr->setInt(value);
case coInts: } break;
{ case coInts:
auto* ptr {dynamic_cast<ConfigOptionInts*>(this->optptr(opt_key, true))}; {
ptr->deserialize(std::to_string(value), true); auto* ptr {dynamic_cast<ConfigOptionInts*>(this->optptr(opt_key, true))};
} break; ptr->deserialize(std::to_string(value), true);
case coFloat: } break;
{ case coFloat:
auto* ptr {dynamic_cast<ConfigOptionFloat*>(this->optptr(opt_key, true))}; {
ptr->setFloat(value); auto* ptr {dynamic_cast<ConfigOptionFloat*>(this->optptr(opt_key, true))};
} break; ptr->setFloat(value);
case coFloatOrPercent: } break;
{ case coFloatOrPercent:
auto* ptr {dynamic_cast<ConfigOptionFloatOrPercent*>(this->optptr(opt_key, true))}; {
ptr->setFloat(value); auto* ptr {dynamic_cast<ConfigOptionFloatOrPercent*>(this->optptr(opt_key, true))};
} break; ptr->setFloat(value);
case coFloats: } break;
{ case coFloats:
auto* ptr {dynamic_cast<ConfigOptionFloats*>(this->optptr(opt_key, true))}; {
ptr->deserialize(std::to_string(value), true); auto* ptr {dynamic_cast<ConfigOptionFloats*>(this->optptr(opt_key, true))};
} break; ptr->deserialize(std::to_string(value), true);
default: } break;
Slic3r::Log::warn("Config::set", "Unknown set type."); default:
Slic3r::Log::warn("Config::set", "Unknown set type.");
}
} catch (std::out_of_range &e) {
throw InvalidOptionType(std::string(opt_key) + std::string(" is an invalid Slic3r option."));
} }
} }
void void
Config::set(const t_config_option_key& opt_key, const double value) Config::set(const t_config_option_key& opt_key, const double value)
{ {
try {
const auto& def {print_config_def.options.at(opt_key)};
switch (def.type) {
case coInt:
{
auto* ptr {dynamic_cast<ConfigOptionInt*>(this->optptr(opt_key, true))};
ptr->setInt(std::round(value));
} break;
case coInts:
{
auto* ptr {dynamic_cast<ConfigOptionInts*>(this->optptr(opt_key, true))};
ptr->deserialize(std::to_string(std::round(value)), true);
} break;
case coFloat:
{
auto* ptr {dynamic_cast<ConfigOptionFloat*>(this->optptr(opt_key, true))};
ptr->setFloat(value);
} break;
case coFloatOrPercent:
{
auto* ptr {dynamic_cast<ConfigOptionFloatOrPercent*>(this->optptr(opt_key, true))};
ptr->setFloat(value);
} break;
case coFloats:
{
auto* ptr {dynamic_cast<ConfigOptionFloats*>(this->optptr(opt_key, true))};
ptr->deserialize(std::to_string(value), true);
} break;
default:
Slic3r::Log::warn("Config::set", "Unknown set type.");
}
} catch (std::out_of_range &e) {
throw InvalidOptionType(std::string(opt_key) + std::string(" is an invalid Slic3r option."));
}
} }
void void

4
xs/src/libslic3r/Config.hpp
View File

@ -18,6 +18,7 @@ namespace Slic3r {
class InvalidOptionValue : public std::runtime_error { class InvalidOptionValue : public std::runtime_error {
public: public:
InvalidOptionValue(const char* v) : runtime_error(v) {} InvalidOptionValue(const char* v) : runtime_error(v) {}
InvalidOptionValue(const std::string v) : runtime_error(v.c_str()) {}
}; };
/// Exception class to handle config options that don't exist. /// Exception class to handle config options that don't exist.
@ -27,6 +28,7 @@ class InvalidConfigOption : public std::runtime_error {};
class InvalidOptionType : public std::runtime_error { class InvalidOptionType : public std::runtime_error {
public: public:
InvalidOptionType(const char* v) : runtime_error(v) {} InvalidOptionType(const char* v) : runtime_error(v) {}
InvalidOptionType(const std::string v) : runtime_error(v.c_str()) {}
}; };
class Config; class Config;
@ -60,12 +62,14 @@ public:
/// format than longwinded dynamic_cast<> /// format than longwinded dynamic_cast<>
template <class T> template <class T>
T& get(const t_config_option_key& opt_key, bool create=false) { T& get(const t_config_option_key& opt_key, bool create=false) {
if (print_config_def.options.count(opt_key) == 0) throw InvalidOptionType(opt_key + std::string(" is an invalid option."));
return *(dynamic_cast<T*>(this->optptr(opt_key, create))); return *(dynamic_cast<T*>(this->optptr(opt_key, create)));
} }
/// Template function to dynamic cast and leave it in pointer form. /// Template function to dynamic cast and leave it in pointer form.
template <class T> template <class T>
T* get_ptr(const t_config_option_key& opt_key, bool create=false) { T* get_ptr(const t_config_option_key& opt_key, bool create=false) {
if (print_config_def.options.count(opt_key) == 0) throw InvalidOptionType(opt_key + std::string(" is an invalid option."));
return dynamic_cast<T*>(this->optptr(opt_key, create)); return dynamic_cast<T*>(this->optptr(opt_key, create));
} }