Migrate encoder module to use google test

src/architecture/utilities/simDefinitions.h

@@ -5,15 +5,11 @@
 #ifndef SIM_MACROS_H
 #define SIM_MACROS_H
 
-#define EPOCH_YEAR 2019
+#define EPOCH_YEAR 2'019
 #define EPOCH_MONTH 01
 #define EPOCH_DAY 01
 #define EPOCH_HOUR 00
 #define EPOCH_MIN 00
 #define EPOCH_SEC 0.00
 
-#define SIGNAL_NOMINAL 0
-#define SIGNAL_OFF 1
-#define SIGNAL_STUCK 2
-
 #endif  // SIM_MACROS_H

src/simulation/deviceInterface/encoder/CMakeLists.txt

@@ -8,3 +8,5 @@ xmera_add_swig_module("${module}")
 target_sources("${module}" PRIVATE
   encoder.cpp
 )
+
+add_subdirectory(_UnitTest)

src/simulation/deviceInterface/encoder/_UnitTest/CMakeLists.txt

@@ -0,0 +1,13 @@
+# The encoder .cpp is compiled only into the SWIG Python module (not a linkable
+# C++ library), so pull the source in directly here.
+add_executable(test_encoder
+  ../encoder.cpp
+  test_encoder.cpp
+)
+target_include_directories(test_encoder PRIVATE "${CMAKE_SOURCE_DIR}")
+target_link_libraries(test_encoder PRIVATE
+  GTest::gtest_main
+  Xmera::Core
+  ArchitectureUtilities
+)
+gtest_discover_tests(test_encoder)

src/simulation/deviceInterface/encoder/_UnitTest/encoderTestHelpers.hpp

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: ISC
+// Copyright (c) 2026, Laboratory for Atmospheric and Space Physics, University of Colorado at Boulder
+
+#ifndef ENCODER_TEST_HELPERS_HPP
+#define ENCODER_TEST_HELPERS_HPP
+
+#include <architecture/messaging/messaging.h>
+#include <architecture/msgPayloadDef/RWSpeedMsgPayload.h>
+
+#include <simulation/deviceInterface/encoder/encoder.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace encodertest {
+    //! One second in nanoseconds. The tests use this value as the time step.
+    constexpr uint64_t oneSecond = 1'000'000'000ULL;
+
+    //! This harness connects an encoder to an input speed message and an output reader.
+    class EncoderHarness {
+    public:
+        //! Make an encoder with the given wheel count and clicks per rotation, then connect its messages.
+        EncoderHarness(std::size_t numRW, std::uint32_t clicksPerRotation) {
+            this->encoder.setNumRW(numRW);
+            this->encoder.setClicksPerRotation(clicksPerRotation);
+            this->encoder.rwSpeedInMsg.subscribeTo(&this->speedInMsg);
+            this->speedOut = this->encoder.rwSpeedOutMsg.addSubscriber();
+        }
+
+        EncoderHarness(EncoderHarness const &) = delete;
+        EncoderHarness &operator=(EncoderHarness const &) = delete;
+
+        //! Write the wheel speeds to the input message, update the encoder at time t, and read the output.
+        RWSpeedMsgPayload step(std::vector<double> const &wheelSpeeds, uint64_t t) {
+            RWSpeedMsgPayload payload{};
+            for (std::size_t i = 0; i < wheelSpeeds.size(); ++i) { payload.wheelSpeeds[i] = wheelSpeeds[i]; }
+            this->speedInMsg.write(payload, 0, t);
+            this->encoder.updateState(t);
+            return this->speedOut();
+        }
+
+        Encoder encoder;                          //!< encoder under test
+        Message<RWSpeedMsgPayload> speedInMsg;    //!< input wheel speed message
+        ReadFunctor<RWSpeedMsgPayload> speedOut;  //!< reader of the encoder output message
+    };
+}  // namespace encodertest
+
+#endif  // ENCODER_TEST_HELPERS_HPP

src/simulation/deviceInterface/encoder/_UnitTest/test_encoder.cpp

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: ISC
+// Copyright (c) 2026, Laboratory for Atmospheric and Space Physics, University of Colorado at Boulder
+
+#include "encoderTestHelpers.hpp"
+
+#include <gtest/gtest.h>
+
+#include <numbers>
+#include <stdexcept>
+
+using encodertest::EncoderHarness;
+using encodertest::oneSecond;
+
+namespace {
+    constexpr double pi = std::numbers::pi;
+    constexpr double tolerance = 1e-9;
+}  // namespace
+
+//! On the first step the time step is zero, so the encoder sends the true wheel speeds.
+TEST(Encoder, firstStepSendsTrueSpeeds) {
+    EncoderHarness harness(3, 2);
+    harness.encoder.reset(0);
+
+    RWSpeedMsgPayload const out = harness.step({100.0, 200.0, 300.0}, 0);
+
+    EXPECT_DOUBLE_EQ(out.wheelSpeeds[0], 100.0);
+    EXPECT_DOUBLE_EQ(out.wheelSpeeds[1], 200.0);
+    EXPECT_DOUBLE_EQ(out.wheelSpeeds[2], 300.0);
+}
+
+//! With two clicks per rotation, each output speed is a whole number of clicks times pi rad/s.
+//! The encoder keeps the fraction of a click that remains and adds it to the next step.
+TEST(Encoder, quantizesSpeedOverConsecutiveSteps) {
+    EncoderHarness harness(3, 2);
+    harness.encoder.reset(0);
+    std::vector<double> const speeds{100.0, 200.0, 300.0};
+
+    harness.step(speeds, 0);
+    RWSpeedMsgPayload const first = harness.step(speeds, oneSecond);
+    RWSpeedMsgPayload const second = harness.step(speeds, 2 * oneSecond);
+
+    EXPECT_NEAR(first.wheelSpeeds[0], 31.0 * pi, tolerance);
+    EXPECT_NEAR(first.wheelSpeeds[1], 63.0 * pi, tolerance);
+    EXPECT_NEAR(first.wheelSpeeds[2], 95.0 * pi, tolerance);
+    EXPECT_NEAR(second.wheelSpeeds[0], 32.0 * pi, tolerance);
+    EXPECT_NEAR(second.wheelSpeeds[1], 64.0 * pi, tolerance);
+    EXPECT_NEAR(second.wheelSpeeds[2], 95.0 * pi, tolerance);
+}
+
+//! When the signal is off, the encoder sends zero speed.
+TEST(Encoder, offSignalSendsZeroSpeed) {
+    EncoderHarness harness(3, 2);
+    harness.encoder.reset(0);
+    std::vector<double> const speeds{100.0, 200.0, 300.0};
+    harness.step(speeds, 0);
+    harness.step(speeds, oneSecond);
+
+    for (int i = 0; i < 3; ++i) { harness.encoder.rwSignalState[i] = EncoderSignal::Off; }
+    RWSpeedMsgPayload const out = harness.step(speeds, 2 * oneSecond);
+
+    EXPECT_DOUBLE_EQ(out.wheelSpeeds[0], 0.0);
+    EXPECT_DOUBLE_EQ(out.wheelSpeeds[1], 0.0);
+    EXPECT_DOUBLE_EQ(out.wheelSpeeds[2], 0.0);
+}
+
+//! An off signal erases the remaining clicks. After the signal is nominal again, the count starts from zero.
+TEST(Encoder, nominalSignalAfterOffStartsFromZeroClicks) {
+    EncoderHarness harness(3, 2);
+    harness.encoder.reset(0);
+    std::vector<double> const speeds{100.0, 200.0, 300.0};
+    harness.step(speeds, 0);
+    harness.step(speeds, oneSecond);
+    harness.step(speeds, 2 * oneSecond);
+
+    for (int i = 0; i < 3; ++i) { harness.encoder.rwSignalState[i] = EncoderSignal::Off; }
+    harness.step(speeds, 3 * oneSecond);
+    for (int i = 0; i < 3; ++i) { harness.encoder.rwSignalState[i] = EncoderSignal::Nominal; }
+    RWSpeedMsgPayload const out = harness.step({500.0, 400.0, 300.0}, 4 * oneSecond);
+
+    EXPECT_NEAR(out.wheelSpeeds[0], 159.0 * pi, tolerance);
+    EXPECT_NEAR(out.wheelSpeeds[1], 127.0 * pi, tolerance);
+    EXPECT_NEAR(out.wheelSpeeds[2], 95.0 * pi, tolerance);
+}
+
+//! When the signal is stuck, the encoder sends the speeds of the previous step and ignores the new input.
+TEST(Encoder, stuckSignalHoldsPreviousSpeed) {
+    EncoderHarness harness(3, 2);
+    harness.encoder.reset(0);
+    harness.step({500.0, 400.0, 300.0}, 0);
+    RWSpeedMsgPayload const before = harness.step({500.0, 400.0, 300.0}, oneSecond);
+
+    for (int i = 0; i < 3; ++i) { harness.encoder.rwSignalState[i] = EncoderSignal::Stuck; }
+    RWSpeedMsgPayload const out = harness.step({100.0, 200.0, 300.0}, 2 * oneSecond);
+
+    EXPECT_DOUBLE_EQ(out.wheelSpeeds[0], before.wheelSpeeds[0]);
+    EXPECT_DOUBLE_EQ(out.wheelSpeeds[1], before.wheelSpeeds[1]);
+    EXPECT_DOUBLE_EQ(out.wheelSpeeds[2], before.wheelSpeeds[2]);
+}
+
+//! The encoder cannot operate without an input message. Reset rejects an encoder with no connected input message.
+TEST(Encoder, resetRejectsUnlinkedInputMessage) {
+    Encoder encoder;
+    encoder.setNumRW(3);
+    encoder.setClicksPerRotation(2);
+
+    EXPECT_THROW(encoder.reset(0), std::invalid_argument);
+}
+
+//! The setters reject zero for the wheel count and for the clicks per rotation.
+TEST(Encoder, settersRejectZero) {
+    Encoder encoder;
+
+    EXPECT_THROW(encoder.setNumRW(0), std::invalid_argument);
+    EXPECT_THROW(encoder.setClicksPerRotation(0), std::invalid_argument);
+}