Merge pull request #111 from Hyp-ed/tel-tests-namespaces

Removed using keywords from all tests and changing structs to classes

Author: mifrandir

test/state_machine/state.test.cpp

@@ -71,7 +71,8 @@ class StateTest : public hyped::testing::Test {
 /**
  * Testing Idle behaviour with respect to data
  */
-struct IdleTest : public StateTest {
+class IdleTest : public StateTest {
+ protected:
   state_machine::Idle *state = state_machine::Idle::getInstance();
 };
 
@@ -131,7 +132,8 @@ TEST_F(IdleTest, handlesAllInitialised)
 // Pre- Calibrating Tests
 //---------------------------------------------------------------------------
 
-struct PreCalibratingTest : public StateTest {
+class PreCalibratingTest : public StateTest {
+ protected:
   state_machine::PreCalibrating *state = state_machine::PreCalibrating::getInstance();
 };
 
@@ -195,7 +197,8 @@ TEST_F(PreCalibratingTest, handlesCalibrateCommand)
  * Testing Calibrating behaviour with respect to data
  */
 
-struct CalibratingTest : public StateTest {
+class CalibratingTest : public StateTest {
+ protected:
   state_machine::Calibrating *state = state_machine::Calibrating::getInstance();
 };
 
@@ -259,7 +262,8 @@ TEST_F(CalibratingTest, handlesAllReady)
 /**
  * Testing Ready behaviour with respect to data
  */
-struct ReadyTest : public StateTest {
+class ReadyTest : public StateTest {
+ protected:
   state_machine::Ready *state = state_machine::Ready::getInstance();
 };
 
@@ -325,7 +329,8 @@ TEST_F(ReadyTest, handlesLaunchCommand)
 /**
  * Testing Accelerating behaviour with respect to data
  */
-struct AcceleratingTest : public StateTest {
+class AcceleratingTest : public StateTest {
+ protected:
   state_machine::Accelerating *state = state_machine::Accelerating::getInstance();
 };
 
@@ -433,7 +438,8 @@ TEST_F(AcceleratingTest, handlesReachedMaxVelocity)
 /**
  * Testing Cruising behaviour with respect to data
  */
-struct CruisingTest : public StateTest {
+class CruisingTest : public StateTest {
+ protected:
   state_machine::Cruising *state = state_machine::Cruising::getInstance();
 };
 
@@ -498,7 +504,8 @@ TEST_F(CruisingTest, handlesInBrakingZone)
 /**
  * Testing PreBraking behaviour with respect to data
  */
-struct PreBrakingTest : public StateTest {
+class PreBrakingTest : public StateTest {
+ protected:
   state_machine::PreBraking *state = state_machine::PreBraking::getInstance();
 };
 
@@ -563,7 +570,8 @@ TEST_F(PreBrakingTest, handlesHighPowerOff)
 /**
  * Testing NominalBraking behaviour with respect to data
  */
-struct NominalBrakingTest : public StateTest {
+class NominalBrakingTest : public StateTest {
+ protected:
   state_machine::NominalBraking *state = state_machine::NominalBraking::getInstance();
 };
 
@@ -628,7 +636,8 @@ TEST_F(NominalBrakingTest, handlesStopped)
 /**
  * Testing Finished behaviour with respect to data
  */
-struct FinishedTest : public StateTest {
+class FinishedTest : public StateTest {
+ protected:
   state_machine::Finished *state = state_machine::Finished::getInstance();
 };
 
@@ -663,7 +672,8 @@ TEST_F(FinishedTest, handlesShutdownCommand)
 /**
  * Testing failure pre-braking behaviour with respect to data
  */
-struct FailurePreBrakingTest : public StateTest {
+class FailurePreBrakingTest : public StateTest {
+ protected:
   state_machine::FailurePreBraking *state = state_machine::FailurePreBraking::getInstance();
 };
 
@@ -698,7 +708,8 @@ TEST_F(FailurePreBrakingTest, handlesHighPowerOff)
 /**
  * Testing failure Braking behaviour with respect to data
  */
-struct FailureBrakingTest : public StateTest {
+class FailureBrakingTest : public StateTest {
+ protected:
   state_machine::FailureBraking *state = state_machine::FailureBraking::getInstance();
 };
 
@@ -733,7 +744,8 @@ TEST_F(FailureBrakingTest, handlesStopped)
 /**
  * Testing FailureStopped behaviour with respect to data
  */
-struct FailureStoppedTest : public StateTest {
+class FailureStoppedTest : public StateTest {
+ protected:
   state_machine::FailureStopped *state = state_machine::FailureStopped::getInstance();
 };
 

test/state_machine/transitions.test.cpp

@@ -14,7 +14,7 @@
 namespace hyped::testing {
 
 /**
- * Struct used for testing transition functions. Contains
+ * Class used for testing transition functions. Contains
  *
  * 1. Logger
  * 2. Error messages
@@ -967,4 +967,4 @@ TEST_F(TransitionFunctionality, handlesNonpositiveVelocity)
   }
 }
 
-}  // namespace hyped::testing
+}  // namespace hyped::testing

test/telemetry/writer_convert_module_status.test.cpp

@@ -5,38 +5,43 @@
 #include <data/data.hpp>
 #include <telemetry/writer.hpp>
 
-using namespace hyped::telemetry;
-using namespace hyped::data;
+namespace hyped::testing {
 
 /**
  * Tests the conversion of Module Status from Enum to String as required for GUI
  */
-struct WriterConvertModuleStatus : public ::testing::Test {
+class WriterConvertModuleStatus : public ::testing::Test {
  protected:
   void SetUp() {}
   void TearDown() {}
 };
 
 TEST_F(WriterConvertModuleStatus, convertsStartStatus)
 {
-  std::string convertedModuleStatus = Writer::convertModuleStatus(ModuleStatus::kStart);
+  std::string convertedModuleStatus
+    = telemetry::Writer::convertModuleStatus(data::ModuleStatus::kStart);
   ASSERT_EQ(convertedModuleStatus, "START") << "Should convert Start status.";
 }
 
 TEST_F(WriterConvertModuleStatus, convertsInitStatus)
 {
-  std::string convertedModuleStatus = Writer::convertModuleStatus(ModuleStatus::kInit);
+  std::string convertedModuleStatus
+    = telemetry::Writer::convertModuleStatus(data::ModuleStatus::kInit);
   ASSERT_EQ(convertedModuleStatus, "INIT") << "Should convert Init status.";
 }
 
 TEST_F(WriterConvertModuleStatus, convertsReadyStatus)
 {
-  std::string convertedModuleStatus = Writer::convertModuleStatus(ModuleStatus::kReady);
+  std::string convertedModuleStatus
+    = telemetry::Writer::convertModuleStatus(data::ModuleStatus::kReady);
   ASSERT_EQ(convertedModuleStatus, "READY") << "Should convert Ready status.";
 }
 
 TEST_F(WriterConvertModuleStatus, convertsCriticalFailureState)
 {
-  std::string convertedModuleStatus = Writer::convertModuleStatus(ModuleStatus::kCriticalFailure);
+  std::string convertedModuleStatus
+    = telemetry::Writer::convertModuleStatus(data::ModuleStatus::kCriticalFailure);
   ASSERT_EQ(convertedModuleStatus, "CRITICAL_FAILURE") << "Should convert Critical Failure status.";
 }
+
+}  // namespace hyped::testing

test/telemetry/writer_convert_state_machine_state.test.cpp

@@ -4,80 +4,87 @@
 #include "gtest/gtest.h"
 #include "telemetry/writer.hpp"
 
-using namespace hyped::telemetry;
-using namespace hyped::data;
+namespace hyped::testing {
 
 /**
  * Tests the conversion of State from Enum to String as required for GUI
  */
-struct WriterConvertStateMachineState : public ::testing::Test {
+class WriterConvertStateMachineState : public ::testing::Test {
  protected:
   void SetUp() {}
   void TearDown() {}
 };
 
 TEST_F(WriterConvertStateMachineState, convertsIdleState)
 {
-  std::string convertedState = Writer::convertStateMachineState(State::kIdle);
+  std::string convertedState = telemetry::Writer::convertStateMachineState(data::State::kIdle);
   ASSERT_EQ(convertedState, "IDLE") << "Should convert Idle state.";
 }
 
 TEST_F(WriterConvertStateMachineState, convertsCalibratingState)
 {
-  std::string convertedState = Writer::convertStateMachineState(State::kCalibrating);
+  std::string convertedState
+    = telemetry::Writer::convertStateMachineState(data::State::kCalibrating);
   ASSERT_EQ(convertedState, "CALIBRATING") << "Should convert Calibrating state.";
 }
 
 TEST_F(WriterConvertStateMachineState, convertsPreCalibratingState)
 {
-  std::string convertedState = Writer::convertStateMachineState(State::kPreCalibrating);
+  std::string convertedState
+    = telemetry::Writer::convertStateMachineState(data::State::kPreCalibrating);
   ASSERT_EQ(convertedState, "PRE_CALIBRATING") << "Should convert Pre-calibrating state.";
 }
 
 TEST_F(WriterConvertStateMachineState, convertsReadyState)
 {
-  std::string convertedState = Writer::convertStateMachineState(State::kReady);
+  std::string convertedState = telemetry::Writer::convertStateMachineState(data::State::kReady);
   ASSERT_EQ(convertedState, "READY") << "Should convert Ready state.";
 }
 
 TEST_F(WriterConvertStateMachineState, convertsAcceleratingState)
 {
-  std::string convertedState = Writer::convertStateMachineState(State::kAccelerating);
+  std::string convertedState
+    = telemetry::Writer::convertStateMachineState(data::State::kAccelerating);
   ASSERT_EQ(convertedState, "ACCELERATING") << "Should convert Accelerating state.";
 }
 
 TEST_F(WriterConvertStateMachineState, convertsCruisingState)
 {
-  std::string convertedState = Writer::convertStateMachineState(State::kCruising);
+  std::string convertedState = telemetry::Writer::convertStateMachineState(data::State::kCruising);
   ASSERT_EQ(convertedState, "CRUISING") << "Should convert Cruising state.";
 }
 
 TEST_F(WriterConvertStateMachineState, convertsNominalBrakingState)
 {
-  std::string convertedState = Writer::convertStateMachineState(State::kNominalBraking);
+  std::string convertedState
+    = telemetry::Writer::convertStateMachineState(data::State::kNominalBraking);
   ASSERT_EQ(convertedState, "NOMINAL_BRAKING") << "Should convert Nominal Braking state.";
 }
 
 TEST_F(WriterConvertStateMachineState, convertsEmergencyBrakingState)
 {
-  std::string convertedState = Writer::convertStateMachineState(State::kEmergencyBraking);
+  std::string convertedState
+    = telemetry::Writer::convertStateMachineState(data::State::kEmergencyBraking);
   ASSERT_EQ(convertedState, "EMERGENCY_BRAKING") << "Should convert Emergency Braking state.";
 }
 
 TEST_F(WriterConvertStateMachineState, convertsFailureStoppedState)
 {
-  std::string convertedState = Writer::convertStateMachineState(State::kFailureStopped);
+  std::string convertedState
+    = telemetry::Writer::convertStateMachineState(data::State::kFailureStopped);
   ASSERT_EQ(convertedState, "FAILURE_STOPPED") << "Should convert Failure Stopped state.";
 }
 
 TEST_F(WriterConvertStateMachineState, convertsFinishedState)
 {
-  std::string convertedState = Writer::convertStateMachineState(State::kFinished);
+  std::string convertedState = telemetry::Writer::convertStateMachineState(data::State::kFinished);
   ASSERT_EQ(convertedState, "FINISHED") << "Should convert Finished state.";
 }
 
 TEST_F(WriterConvertStateMachineState, convertsInvalidState)
 {
-  std::string convertedState = Writer::convertStateMachineState(State::kInvalid);
+  std::string convertedState = telemetry::Writer::convertStateMachineState(data::State::kInvalid);
   ASSERT_EQ(convertedState, "INVALID") << "Should convert Invalid state.";
 }
+
+}  // namespace hyped::testing

test/utils/differentiator.test.cpp

@@ -16,11 +16,11 @@ using hyped::utils::math::Differentiator;
 // -------------------------------------------------------------------------------------------------
 
 /**
- * Struct used for test fixtures testing functionality.
+ * Class used for test fixtures testing functionality.
  * Constructor sets the values of the DataPoint objects.
  * Helper functions defined to assist in testing
  */
-struct DifferentiatorFunctionality : public ::testing::Test {
+class DifferentiatorFunctionality : public ::testing::Test {
  protected:
   Differentiator<float> diff_test;
   DataPoint<float> test_point;
@@ -124,11 +124,11 @@ TEST_F(DifferentiatorFunctionality, derivativeOfSameValue)
 // -------------------------------------------------------------------------------------------------
 
 /**
- * Struct used in Testing the Differentiator special cases for linear and constants.
+ * Class used in Testing the Differentiator special cases for linear and constants.
  * Constructor populates an array of DataPoints with sample data for each of the functions.
  * These arrays are then accessed in the Test's for Test data.
  */
-struct SpecialCases : public ::testing::Test {
+class SpecialCases : public ::testing::Test {
  protected:
   Differentiator<float> diff_linear;
   DataPoint<float> linear_data[100];
@@ -180,11 +180,11 @@ TEST_F(SpecialCases, differentiatorConstantCase)
 // -------------------------------------------------------------------------------------------------
 
 /**
- * Struct used for checking the Sum of Derivatives property
+ * Class used for checking the Sum of Derivatives property
  * Creates an Array of DataPoints for the linear, quadratic, and function data.
  * These arrays are later accessed in the tests for Test Data.
  */
-struct DifferentiatorProperty : public ::testing::Test {
+class DifferentiatorProperty : public ::testing::Test {
  protected:
   Differentiator<float> diff_linear;
   Differentiator<float> diff_quadratic;

test/utils/integrator.test.cpp

@@ -63,10 +63,11 @@ TEST(IntegratorFunctionalityTest, handlesInitializationTest)
 // -------------------------------------------------------------------------------------------------
 
 /**
- * @brief struct used to setup all needed variables to make property tests of Integrator
+ * @brief class used to setup all needed variables to make property tests of Integrator
  *
  */
-struct IntegratorPropertyTest : public ::testing::Test {
+class IntegratorPropertyTest : public ::testing::Test {
+ protected:
   int number_of_points = 101;
   DataPoint<float> datafunction[101];
 
@@ -180,10 +181,11 @@ TEST_F(IntegratorPropertyTest, ConstantMultiplyTest)
 // Linear Tests
 // -------------------------------------------------------------------------------------------------
 /**
- * @brief struct used to set up all needed variables to make linear tests of Integrator
+ * @brief class used to set up all needed variables to make linear tests of Integrator
  *
  */
-struct IntegratorTestLinear : public ::testing::Test {
+class IntegratorTestLinear : public ::testing::Test {
+ protected:
   int max_time = 100;
   DataPoint<float> datatry[101];
   DataPoint<float> datatry2[101];