PrintConfig: add sdf::Errors output to API methods (#1098)

Signed-off-by: Marco A. Gutierrez <marco@openrobotics.org>
Co-authored-by: Steve Peters <scpeters@openrobotics.org>

Author: Marco A. Gutiérrez

include/sdf/PrintConfig.hh

@@ -22,6 +22,7 @@
 
 #include "sdf/sdf_config.h"
 #include "sdf/system_util.hh"
+#include "sdf/Types.hh"
 
 namespace sdf
 {
@@ -54,6 +55,19 @@ namespace sdf
     public: bool SetRotationSnapToDegrees(unsigned int _interval,
                                           double _tolerance);
 
+    /// \brief Sets the option for printing pose rotation in degrees as well as
+    /// snapping the rotation to the desired interval, with the provided
+    /// tolerance.
+    /// \param[in] _interval Degrees interval to snap to, this value must be
+    /// larger than 0, and less than or equal to 360.
+    /// \param[in] _tolerance Tolerance which snapping occurs, this value must
+    /// be larger than 0, less than 360, and less than the provided interval.
+    /// \param[out] _errors Vector of Errors.
+    /// \return True, unless any of the provided values are not valid.
+    public: bool SetRotationSnapToDegrees(unsigned int _interval,
+                                          double _tolerance,
+                                          sdf::Errors &_errors);
+
     /// \brief Returns the current degree value that pose rotations will snap to
     /// when printed.
     /// \return The assigned degrees interval value to snap to. If it has not

src/PrintConfig.cc

@@ -18,6 +18,7 @@
 
 #include "sdf/PrintConfig.hh"
 #include "sdf/Console.hh"
+#include "Utils.hh"
 
 using namespace sdf;
 
@@ -75,19 +76,36 @@ bool PrintConfig::PreserveIncludes() const
 /////////////////////////////////////////////////
 bool PrintConfig::SetRotationSnapToDegrees(unsigned int _interval,
                                            double _tolerance)
+{
+  sdf::Errors errors;
+  bool result = this->SetRotationSnapToDegrees(_interval,
+                                               _tolerance,
+                                               errors);
+  throwOrPrintErrors(errors);
+  return result;
+}
+
+/////////////////////////////////////////////////
+bool PrintConfig::SetRotationSnapToDegrees(unsigned int _interval,
+                                           double _tolerance,
+                                           sdf::Errors &_errors)
 {
   if (_interval == 0 || _interval > 360)
   {
-    sdferr << "Interval value to snap to must be larger than 0, and less than "
-           << "or equal to 360.\n";
+    std::stringstream ss;
+    ss << "Interval value to snap to must be larger than 0, and less than "
+       << "or equal to 360.";
+    _errors.push_back({ErrorCode::ROTATION_SNAP_CONFIG_ERROR, ss.str()});
     return false;
   }
 
   if (_tolerance <= 0 || _tolerance > 360 ||
       _tolerance >= static_cast<double>(_interval))
   {
-    sdferr << "Tolerance must be larger than 0, less than or equal to "
-           << "360, and less than the provided interval.\n";
+    std::stringstream ss;
+    ss << "Tolerance must be larger than 0, less than or equal to "
+       << "360, and less than the provided interval.";
+    _errors.push_back({ErrorCode::ROTATION_SNAP_CONFIG_ERROR, ss.str()});
     return false;
   }
 

test/integration/error_output.cc

@@ -32,16 +32,16 @@ TEST(ErrorOutput, ParamErrorOutput)
 {
   std::stringstream buffer;
   sdf::testing::RedirectConsoleStream redir(
-    sdf::Console::Instance()->GetMsgStream(), &buffer);
+      sdf::Console::Instance()->GetMsgStream(), &buffer);
 
   sdf::Errors errors;
   ASSERT_NO_THROW(sdf::Param param1("key", "not_valid_type", "true", false,
-        errors, "description"));
+      errors, "description"));
   ASSERT_GE(2u, errors.size());
   EXPECT_EQ(errors[0].Code(), sdf::ErrorCode::UNKNOWN_PARAMETER_TYPE);
   EXPECT_NE(std::string::npos,
       errors[0].Message().find(
-        "Unknown parameter type[not_valid_type]"));
+      "Unknown parameter type[not_valid_type]"));
   EXPECT_EQ(errors[1].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos,
       errors[1].Message().find("Invalid parameter"));
@@ -52,10 +52,10 @@ TEST(ErrorOutput, ParamErrorOutput)
   ASSERT_GE(2u, errors.size());
   EXPECT_EQ(errors[0].Code(), sdf::ErrorCode::UNKNOWN_PARAMETER_TYPE);
   EXPECT_NE(std::string::npos,
-   errors[0].Message().find("Unknown parameter type[not_valid_type]"));
+      errors[0].Message().find("Unknown parameter type[not_valid_type]"));
   EXPECT_EQ(errors[1].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos,
-   errors[1].Message().find("Invalid parameter"));
+      errors[1].Message().find("Invalid parameter"));
 
   errors.clear();
   sdf::Param param3("key", "bool", "true", false, errors, "description");
@@ -73,15 +73,15 @@ TEST(ErrorOutput, ParamErrorOutput)
   ASSERT_GE(errors.size(), 1u);
   EXPECT_EQ(errors[0].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos, errors[0].Message().find(
-    "The value for //pose[@rotation_format='euler_rpy'] must have 6 "
-    "values, but 1 were found instead in '1'."));
+      "The value for //pose[@rotation_format='euler_rpy'] must have 6 "
+      "values, but 1 were found instead in '1'."));
 
   errors.clear();
   param3.Update(errors);
   ASSERT_GE(errors.size(), 1u);
   EXPECT_EQ(errors[0].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos, errors[0].Message().find(
-    "[updateFunc] is not set."));
+      "[updateFunc] is not set."));
 
   errors.clear();
   sdf::Param requiredParam("key", "int", "1", true, "2", "4", errors,
@@ -92,14 +92,13 @@ TEST(ErrorOutput, ParamErrorOutput)
   ASSERT_GE(errors.size(), 1u);
   EXPECT_EQ(errors[0].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos, errors[0].Message().find(
-    "Empty string used when setting a required parameter. Key[key]"));
+      "Empty string used when setting a required parameter. Key[key]"));
   EXPECT_FALSE(requiredParam.ValidateValue(errors));
   ASSERT_GE(errors.size(), 2u);
   EXPECT_EQ(errors[1].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos, errors[1].Message().find(
-    "The value [1] is less than the minimum allowed value of [2] for "
-    "key [key]"));
-
+      "The value [1] is less than the minimum allowed value of [2] for "
+      "key [key]"));
 
   errors.clear();
   // Adding a parent with @rotation_format to something invalid
@@ -111,37 +110,37 @@ TEST(ErrorOutput, ParamErrorOutput)
   ASSERT_EQ(errors.size(), 2u);
   EXPECT_EQ(errors[0].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos, errors[0].Message().find(
-    "Undefined attribute //pose[@rotation_format='invalid_format'], "
-    "only 'euler_rpy' and 'quat_xyzw' is supported."));
+      "Undefined attribute //pose[@rotation_format='invalid_format'], "
+      "only 'euler_rpy' and 'quat_xyzw' is supported."));
   EXPECT_EQ(errors[1].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos, errors[1].Message().find(
-    "Failed to set value '1 2 3 0.40000000000000002 0.5 "
-    "0.59999999999999987' to key [] for new parent element of name '',"
-    " reverting to previous value '1 2 3 0.40000000000000002 0.5 "
-    "0.59999999999999987'."));
+      "Failed to set value '1 2 3 0.40000000000000002 0.5 "
+      "0.59999999999999987' to key [] for new parent element of name '',"
+      " reverting to previous value '1 2 3 0.40000000000000002 0.5 "
+      "0.59999999999999987'."));
 
   errors.clear();
   sdf::Param param4("key", "bool", "15", false, "a", "b", errors,
                     "description");
   ASSERT_EQ(errors.size(), 6u);
   EXPECT_EQ(errors[0].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos, errors[0].Message().find(
-    "Invalid boolean value"));
+      "Invalid boolean value"));
   EXPECT_EQ(errors[1].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos, errors[1].Message().find(
-    "Invalid parameter"));
+      "Invalid parameter"));
   EXPECT_EQ(errors[2].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos, errors[2].Message().find(
-    "Invalid boolean value"));
+      "Invalid boolean value"));
   EXPECT_EQ(errors[3].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos, errors[3].Message().find(
-    "Invalid [min] parameter in SDFormat description of [key]"));
+      "Invalid [min] parameter in SDFormat description of [key]"));
   EXPECT_EQ(errors[4].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos, errors[4].Message().find(
-    "Invalid boolean value"));
+      "Invalid boolean value"));
   EXPECT_EQ(errors[5].Code(), sdf::ErrorCode::PARAMETER_ERROR);
   EXPECT_NE(std::string::npos, errors[5].Message().find(
-    "Invalid [max] parameter in SDFormat description of [key]"));
+      "Invalid [max] parameter in SDFormat description of [key]"));
 
   // Check nothing has been printed
   EXPECT_TRUE(buffer.str().empty()) << buffer.str();
@@ -153,7 +152,7 @@ TEST(ErrorOutput, ElementErrorOutput)
 {
   std::stringstream buffer;
   sdf::testing::RedirectConsoleStream redir(
-    sdf::Console::Instance()->GetMsgStream(), &buffer);
+      sdf::Console::Instance()->GetMsgStream(), &buffer);
 
   sdf::Errors errors;
   sdf::ElementPtr elem = std::make_shared<sdf::Element>();
@@ -163,59 +162,84 @@ TEST(ErrorOutput, ElementErrorOutput)
   ASSERT_EQ(errors.size(), 1u);
   EXPECT_EQ(errors[0].Code(), sdf::ErrorCode::ELEMENT_ERROR);
   EXPECT_NE(std::string::npos, errors[0].Message().find(
-    "Unable to find value for key [test]"));
+      "Unable to find value for key [test]"));
 
   errors.clear();
   elem->GetElement("missingElement", errors);
   ASSERT_EQ(errors.size(), 1u);
   EXPECT_NE(std::string::npos, errors[0].Message().find(
-    "Missing element description for [missingElement]"));
+      "Missing element description for [missingElement]"));
 
   errors.clear();
   elem->AddAttribute(
-    "invalidAttribute", "int", "invalidFormat", false, errors);
+      "invalidAttribute", "int", "invalidFormat", false, errors);
   ASSERT_EQ(errors.size(), 2u);
   EXPECT_NE(std::string::npos, errors[0].Message().find(
-    "Invalid argument. Unable to set value [invalidFormat]"
-    " for key[invalidAttribute]"));
+      "Invalid argument. Unable to set value [invalidFormat]"
+      " for key[invalidAttribute]"));
   EXPECT_NE(std::string::npos, errors[1].Message().find(
-    "Invalid parameter"));
+      "Invalid parameter"));
 
   errors.clear();
   elem->AddValue("type", "value", true, "a", "b", errors);
   ASSERT_EQ(errors.size(), 9u);
   EXPECT_NE(std::string::npos, errors[0].Message().find(
-    "Unknown parameter type[type]"));
+      "Unknown parameter type[type]"));
   EXPECT_NE(std::string::npos, errors[1].Message().find(
-    "Invalid parameter"));
+      "Invalid parameter"));
   EXPECT_NE(std::string::npos, errors[2].Message().find(
-    "Unknown parameter type[type]"));
+      "Unknown parameter type[type]"));
   EXPECT_NE(std::string::npos, errors[3].Message().find(
-    "Invalid [min] parameter in SDFormat description of [testElement]"));
+      "Invalid [min] parameter in SDFormat description of [testElement]"));
   EXPECT_NE(std::string::npos, errors[4].Message().find(
-    "Unknown parameter type[type]"));
+      "Unknown parameter type[type]"));
   EXPECT_NE(std::string::npos, errors[5].Message().find(
-    "Invalid [max] parameter in SDFormat description of [testElement]"));
+      "Invalid [max] parameter in SDFormat description of [testElement]"));
   EXPECT_NE(std::string::npos, errors[6].Message().find(
-    "Unknown parameter type[type]"));
+      "Unknown parameter type[type]"));
   EXPECT_NE(std::string::npos, errors[7].Message().find(
-    "Failed to set value '0' to key [testElement] for new parent element"
-    " of name 'testElement', reverting to previous value '0'."));
+      "Failed to set value '0' to key [testElement] for new parent element"
+      " of name 'testElement', reverting to previous value '0'."));
   EXPECT_NE(std::string::npos, errors[8].Message().find(
-    "Cannot set parent Element of value to itself."));
+      "Cannot set parent Element of value to itself."));
   errors.clear();
 
   elem->GetElement("nonExistentElement", errors);
   ASSERT_EQ(errors.size(), 1u);
   EXPECT_NE(std::string::npos, errors[0].Message().find(
-    "Missing element description for [nonExistentElement]"));
+      "Missing element description for [nonExistentElement]"));
   errors.clear();
 
   elem->RemoveChild(sdf::ElementPtr(), errors);
   ASSERT_EQ(errors.size(), 1u);
   EXPECT_NE(std::string::npos, errors[0].Message().find(
-    "Cannot remove a nullptr child pointer"));
+      "Cannot remove a nullptr child pointer"));
+  // Check nothing has been printed
+  EXPECT_TRUE(buffer.str().empty()) << buffer.str();
+}
 
+////////////////////////////////////////
+// Test PrintConfig class for sdf::Errors outputs
+TEST(ErrorOutput, PrintConfigErrorOutput)
+{
+  std::stringstream buffer;
+  sdf::testing::RedirectConsoleStream redir(
+      sdf::Console::Instance()->GetMsgStream(), &buffer);
+
+  sdf::Errors errors;
+  sdf::PrintConfig printConfig;
+  ASSERT_FALSE(printConfig.SetRotationSnapToDegrees(361, 300, errors));
+  ASSERT_EQ(errors.size(), 1u);
+  EXPECT_NE(std::string::npos, errors[0].Message().find(
+      "Interval value to snap to must be larger than 0,"
+      " and less than or equal to 360."));
+  errors.clear();
+
+  ASSERT_FALSE(printConfig.SetRotationSnapToDegrees(300, 300, errors));
+  ASSERT_EQ(errors.size(), 1u);
+  EXPECT_NE(std::string::npos, errors[0].Message().find(
+      "Tolerance must be larger than 0, less than or equal to 360, "
+      "and less than the provided interval."));
   // Check nothing has been printed
   EXPECT_TRUE(buffer.str().empty()) << buffer.str();
 }