Convert into parametrized tests

Author: bmagyar

transmission_interface/test/transmission_interface_variable_test.cpp

@@ -3,14 +3,20 @@
 #include <transmission_interface/simple_transmission.h>
 #include <transmission_interface/transmission_interface.h>
 #include <vector>
+#include <sstream>
 
-using std::vector;
 using namespace testing;
 
 namespace transmission_interface
 {
-// Floating-point value comparison threshold
-const double EPS = 1e-6;
+template <typename T>
+std::vector<T> operator+(const std::vector<T>& v1, const std::vector<T>& v2)
+{
+    std::vector<T> result;
+    result.insert(result.end(), v1.begin(), v1.end());
+    result.insert(result.end(), v2.begin(), v2.end());
+    return result;
+}
 
 class PositionOnlyActuatorData : public ActuatorDataContainer<PositionActuatorData>
 {
@@ -29,6 +35,11 @@ class PositionOnlyActuatorData : public ActuatorDataContainer<PositionActuatorDa
     {
         return hasValidPointers(position);
     }
+
+    size_t size() const
+    {
+        return position.size();
+    }
 };
 
 class DummyHandle : public TransmissionHandle<PositionOnlyActuatorData>
@@ -41,56 +52,95 @@ class DummyHandle : public TransmissionHandle<PositionOnlyActuatorData>
     }
 };
 
-TEST(HandlePreconditionsTest, ValidHandle)
+struct TransmissionTestParams
+{
+    PositionOnlyActuatorData actuator_data;
+    JointData joint_data;
+    bool should_throw;
+};
+
+std::string PrintToString(const TransmissionTestParams& param)
+{
+    std::stringstream ss;
+    ss << "ActuatorDataSize: " << param.actuator_data.size()
+       << " JointDataPositionSize: " << param.joint_data.position.size()
+       << " VelocitySize: " << param.joint_data.velocity.size() << " EffortSize: " << param.joint_data.effort.size()
+       << " ShouldThrow: " << (param.should_throw ? "Yes" : "No");
+    return ss.str();
+}
+
+class VariableTransmissionInterfaceTest : public TestWithParam<TransmissionTestParams>
+{
+  public:
+    VariableTransmissionInterfaceTest() : trans(1.0)
+    {
+    }
+
+    SimpleTransmission trans;
+};
+
+TEST_P(VariableTransmissionInterfaceTest, transmissionHandleInitialization)
+{
+    if (GetParam().should_throw)
+    {
+        EXPECT_THROW(DummyHandle("trans", &trans, GetParam().actuator_data, GetParam().joint_data),
+                     TransmissionInterfaceException);
+    }
+    else
+    {
+        EXPECT_NO_THROW(DummyHandle("trans", &trans, GetParam().actuator_data, GetParam().joint_data));
+    }
+}
+
+std::vector<TransmissionTestParams> makeTransmissionHandleTestParams(const int num_dof)
 {
+    std::vector<TransmissionTestParams> result;
+    constexpr bool SHOULD_THROW = true;
+    constexpr bool SHOULD_NOT_THROW = false;
+
     double val = 0.0;
-    vector<double*> good_vec(1, &val);
-    SimpleTransmission trans(1.0);
+    std::vector<double*> good_vec(num_dof, &val);
 
     {
         PositionOnlyActuatorData a_data;
-        JointData j_data;
         a_data.position = good_vec;
-        EXPECT_NO_THROW(DummyHandle("trans", &trans, a_data, j_data));
+        result.push_back({ a_data, JointData(), SHOULD_NOT_THROW });
     }
     {
         PositionOnlyActuatorData a_data;
         a_data.position = good_vec;
         JointData j_data;
         j_data.position = good_vec;
-        EXPECT_NO_THROW(DummyHandle("trans", &trans, a_data, j_data));
+        result.push_back({ a_data, j_data, SHOULD_NOT_THROW });
     }
     {
         PositionOnlyActuatorData a_data;
         a_data.position = good_vec;
         JointData j_data;
         j_data.velocity = good_vec;
-        EXPECT_NO_THROW(DummyHandle("trans", &trans, a_data, j_data));
+        result.push_back({ a_data, j_data, SHOULD_NOT_THROW });
     }
     {
         PositionOnlyActuatorData a_data;
         a_data.position = good_vec;
         JointData j_data;
         j_data.effort = good_vec;
-        EXPECT_NO_THROW(DummyHandle("trans", &trans, a_data, j_data));
+        result.push_back({ a_data, j_data, SHOULD_NOT_THROW });
     }
     {
-        PositionOnlyActuatorData a_data;
         JointData j_data;
         j_data.position = good_vec;
-        EXPECT_THROW(DummyHandle("trans", &trans, a_data, j_data), TransmissionInterfaceException);
+        result.push_back({ PositionOnlyActuatorData(), j_data, SHOULD_THROW });
     }
     {
-        PositionOnlyActuatorData a_data;
         JointData j_data;
         j_data.velocity = good_vec;
-        EXPECT_THROW(DummyHandle("trans", &trans, a_data, j_data), TransmissionInterfaceException);
+        result.push_back({ PositionOnlyActuatorData(), j_data, SHOULD_THROW });
     }
     {
-        PositionOnlyActuatorData a_data;
         JointData j_data;
         j_data.effort = good_vec;
-        EXPECT_THROW(DummyHandle("trans", &trans, a_data, j_data), TransmissionInterfaceException);
+        result.push_back({ PositionOnlyActuatorData(), j_data, SHOULD_THROW });
     }
     {
         PositionOnlyActuatorData a_data;
@@ -99,10 +149,16 @@ TEST(HandlePreconditionsTest, ValidHandle)
         j_data.position = good_vec;
         j_data.velocity = good_vec;
         j_data.effort = good_vec;
-        EXPECT_NO_THROW(DummyHandle("trans", &trans, a_data, j_data));
+        result.push_back({ a_data, j_data, SHOULD_NOT_THROW });
     }
+
+    return result;
 }
 
+// SimpleTransmission only handles one joint
+INSTANTIATE_TEST_CASE_P(TransmissionHandleInitialization, VariableTransmissionInterfaceTest,
+                        ValuesIn(makeTransmissionHandleTestParams(1)));
+
 }  // namespace transmission_interface
 
 int main(int argc, char** argv)