[examples] DigitalCommunication, I2CCommunication: Add tests (#4865)

wpilibcExamples/src/test/cpp/examples/DigitalCommunication/cpp/DigitalCommunicationTest.cpp

@@ -0,0 +1,153 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include <gtest/gtest.h>
+
+#include <string>
+#include <thread>
+
+#include <frc/simulation/DIOSim.h>
+#include <frc/simulation/DriverStationSim.h>
+#include <frc/simulation/SimHooks.h>
+#include <units/time.h>
+
+#include "Robot.h"
+
+template <typename T>
+class DigitalCommunicationTest : public testing::TestWithParam<T> {
+ public:
+  frc::sim::DIOSim m_allianceOutput{Robot::kAlliancePort};
+  frc::sim::DIOSim m_enabledOutput{Robot::kEnabledPort};
+  frc::sim::DIOSim m_autonomousOutput{Robot::kAutonomousPort};
+  frc::sim::DIOSim m_alertOutput{Robot::kAlertPort};
+  Robot m_robot;
+  std::optional<std::thread> m_thread;
+
+  void SetUp() override {
+    frc::sim::PauseTiming();
+    frc::sim::DriverStationSim::ResetData();
+
+    m_thread = std::thread([&] { m_robot.StartCompetition(); });
+    frc::sim::StepTiming(0.0_ms);
+    // SimHooks.stepTiming(0.0); // Wait for Notifiers
+  }
+
+  void TearDown() override {
+    m_robot.EndCompetition();
+    m_thread->join();
+    m_allianceOutput.ResetData();
+    m_enabledOutput.ResetData();
+    m_autonomousOutput.ResetData();
+    m_alertOutput.ResetData();
+  }
+};
+
+class AllianceTest : public DigitalCommunicationTest<HAL_AllianceStationID> {};
+
+TEST_P(AllianceTest, Alliance) {
+  auto alliance = GetParam();
+  frc::sim::DriverStationSim::SetAllianceStationId(alliance);
+  frc::sim::DriverStationSim::NotifyNewData();
+
+  EXPECT_TRUE(m_allianceOutput.GetInitialized());
+  EXPECT_FALSE(m_allianceOutput.GetIsInput());
+
+  frc::sim::StepTiming(20_ms);
+
+  bool isRed;
+  switch (alliance) {
+    case HAL_AllianceStationID_kBlue1:
+    case HAL_AllianceStationID_kBlue2:
+    case HAL_AllianceStationID_kBlue3:
+      isRed = false;
+      break;
+    case HAL_AllianceStationID_kRed1:
+    case HAL_AllianceStationID_kRed2:
+    case HAL_AllianceStationID_kRed3:
+      isRed = true;
+      break;
+  }
+  EXPECT_EQ(isRed, m_allianceOutput.GetValue());
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    DigitalCommunicationTests, AllianceTest,
+    testing::Values<HAL_AllianceStationID>(
+        HAL_AllianceStationID_kRed1, HAL_AllianceStationID_kRed2,
+        HAL_AllianceStationID_kRed3, HAL_AllianceStationID_kBlue1,
+        HAL_AllianceStationID_kBlue2, HAL_AllianceStationID_kBlue3),
+    [](const testing::TestParamInfo<AllianceTest::ParamType>& info) {
+      switch (info.param) {
+        case HAL_AllianceStationID_kBlue1:
+          return std::string{"Blue1"};
+        case HAL_AllianceStationID_kBlue2:
+          return std::string{"Blue2"};
+        case HAL_AllianceStationID_kBlue3:
+          return std::string{"Blue3"};
+        case HAL_AllianceStationID_kRed1:
+          return std::string{"Red1"};
+        case HAL_AllianceStationID_kRed2:
+          return std::string{"Red2"};
+        case HAL_AllianceStationID_kRed3:
+          return std::string{"Red3"};
+      }
+      return std::string{"Error"};
+    });
+
+class EnabledTest : public DigitalCommunicationTest<bool> {};
+
+TEST_P(EnabledTest, Enabled) {
+  auto enabled = GetParam();
+  frc::sim::DriverStationSim::SetEnabled(enabled);
+  frc::sim::DriverStationSim::NotifyNewData();
+
+  EXPECT_TRUE(m_enabledOutput.GetInitialized());
+  EXPECT_FALSE(m_enabledOutput.GetIsInput());
+
+  frc::sim::StepTiming(20_ms);
+
+  EXPECT_EQ(enabled, m_enabledOutput.GetValue());
+}
+
+INSTANTIATE_TEST_SUITE_P(DigitalCommunicationTests, EnabledTest,
+                         testing::Bool(), testing::PrintToStringParamName());
+
+class AutonomousTest : public DigitalCommunicationTest<bool> {};
+
+TEST_P(AutonomousTest, Autonomous) {
+  auto autonomous = GetParam();
+  frc::sim::DriverStationSim::SetAutonomous(autonomous);
+  frc::sim::DriverStationSim::NotifyNewData();
+
+  EXPECT_TRUE(m_autonomousOutput.GetInitialized());
+  EXPECT_FALSE(m_autonomousOutput.GetIsInput());
+
+  frc::sim::StepTiming(20_ms);
+
+  EXPECT_EQ(autonomous, m_autonomousOutput.GetValue());
+}
+
+INSTANTIATE_TEST_SUITE_P(DigitalCommunicationTests, AutonomousTest,
+                         testing::Bool(), testing::PrintToStringParamName());
+
+class AlertTest : public DigitalCommunicationTest<double> {};
+
+TEST_P(AlertTest, Alert) {
+  auto matchTime = GetParam();
+  frc::sim::DriverStationSim::SetMatchTime(matchTime);
+  frc::sim::DriverStationSim::NotifyNewData();
+
+  EXPECT_TRUE(m_alertOutput.GetInitialized());
+  EXPECT_FALSE(m_alertOutput.GetIsInput());
+
+  frc::sim::StepTiming(20_ms);
+
+  EXPECT_EQ(matchTime <= 30 && matchTime >= 25, m_alertOutput.GetValue());
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    DigitalCommunicationTests, AlertTest, testing::Values(45.0, 27.0, 23.0),
+    [](const testing::TestParamInfo<double>& info) {
+      return testing::PrintToString(info.param).append("_s");
+    });

wpilibcExamples/src/test/cpp/examples/DigitalCommunication/cpp/main.cpp

@@ -0,0 +1,17 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include <hal/HALBase.h>
+
+#include "gtest/gtest.h"
+
+/**
+ * Runs all unit tests.
+ */
+int main(int argc, char** argv) {
+  HAL_Initialize(500, 0);
+  ::testing::InitGoogleTest(&argc, argv);
+  int ret = RUN_ALL_TESTS();
+  return ret;
+}

wpilibcExamples/src/test/cpp/examples/I2CCommunication/cpp/I2CCommunicationTest.cpp

@@ -0,0 +1,160 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include <gtest/gtest.h>
+
+#include <string>
+#include <thread>
+
+#include <frc/simulation/DriverStationSim.h>
+#include <frc/simulation/SimHooks.h>
+#include <hal/simulation/I2CData.h>
+#include <units/time.h>
+
+#include "Robot.h"
+
+static std::string gString;
+
+void callback(const char* name, void* param, const unsigned char* buffer,
+              unsigned int count) {
+  gString.assign(reinterpret_cast<const char*>(buffer),
+                 static_cast<int>(count));
+}
+
+template <typename T>
+class I2CCommunicationTest : public testing::TestWithParam<T> {
+ public:
+  Robot m_robot;
+  std::optional<std::thread> m_thread;
+  int32_t m_callback;
+  int32_t m_port;
+
+  void SetUp() override {
+    gString = std::string();
+    frc::sim::PauseTiming();
+    frc::sim::DriverStationSim::ResetData();
+    m_port = static_cast<int32_t>(Robot::kPort);
+
+    m_callback = HALSIM_RegisterI2CWriteCallback(m_port, &callback, nullptr);
+
+    m_thread = std::thread([&] { m_robot.StartCompetition(); });
+    frc::sim::StepTiming(0.0_ms);  // Wait for Notifiers
+  }
+
+  void TearDown() override {
+    m_robot.EndCompetition();
+    m_thread->join();
+
+    HALSIM_CancelI2CWriteCallback(m_port, m_callback);
+    HALSIM_ResetI2CData(m_port);
+  }
+};
+
+class AllianceTest : public I2CCommunicationTest<HAL_AllianceStationID> {};
+
+TEST_P(AllianceTest, Alliance) {
+  auto alliance = GetParam();
+  frc::sim::DriverStationSim::SetAllianceStationId(alliance);
+  frc::sim::DriverStationSim::NotifyNewData();
+
+  EXPECT_TRUE(HALSIM_GetI2CInitialized(m_port));
+
+  frc::sim::StepTiming(20_ms);
+
+  char expected;
+  switch (alliance) {
+    case HAL_AllianceStationID_kBlue1:
+    case HAL_AllianceStationID_kBlue2:
+    case HAL_AllianceStationID_kBlue3:
+      expected = 'B';
+      break;
+    case HAL_AllianceStationID_kRed1:
+    case HAL_AllianceStationID_kRed2:
+    case HAL_AllianceStationID_kRed3:
+      expected = 'R';
+      break;
+  }
+  EXPECT_EQ(expected, gString.at(0));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    I2CCommunicationTests, AllianceTest,
+    testing::Values<HAL_AllianceStationID>(
+        HAL_AllianceStationID_kRed1, HAL_AllianceStationID_kRed2,
+        HAL_AllianceStationID_kRed3, HAL_AllianceStationID_kBlue1,
+        HAL_AllianceStationID_kBlue2, HAL_AllianceStationID_kBlue3),
+    [](const testing::TestParamInfo<AllianceTest::ParamType>& info) {
+      switch (info.param) {
+        case HAL_AllianceStationID_kBlue1:
+          return std::string{"Blue1"};
+        case HAL_AllianceStationID_kBlue2:
+          return std::string{"Blue2"};
+        case HAL_AllianceStationID_kBlue3:
+          return std::string{"Blue3"};
+        case HAL_AllianceStationID_kRed1:
+          return std::string{"Red1"};
+        case HAL_AllianceStationID_kRed2:
+          return std::string{"Red2"};
+        case HAL_AllianceStationID_kRed3:
+          return std::string{"Red3"};
+      }
+      return std::string{"Error"};
+    });
+
+class EnabledTest : public I2CCommunicationTest<bool> {};
+
+TEST_P(EnabledTest, Enabled) {
+  auto enabled = GetParam();
+  frc::sim::DriverStationSim::SetEnabled(enabled);
+  frc::sim::DriverStationSim::NotifyNewData();
+
+  EXPECT_TRUE(HALSIM_GetI2CInitialized(m_port));
+
+  frc::sim::StepTiming(20_ms);
+
+  char expected = enabled ? 'E' : 'D';
+  EXPECT_EQ(expected, gString.at(1));
+}
+
+INSTANTIATE_TEST_SUITE_P(I2CCommunicationTests, EnabledTest, testing::Bool(),
+                         testing::PrintToStringParamName());
+
+class AutonomousTest : public I2CCommunicationTest<bool> {};
+
+TEST_P(AutonomousTest, Autonomous) {
+  auto autonomous = GetParam();
+  frc::sim::DriverStationSim::SetAutonomous(autonomous);
+  frc::sim::DriverStationSim::NotifyNewData();
+
+  EXPECT_TRUE(HALSIM_GetI2CInitialized(m_port));
+
+  frc::sim::StepTiming(20_ms);
+
+  char expected = autonomous ? 'A' : 'T';
+  EXPECT_EQ(expected, gString.at(2));
+}
+
+INSTANTIATE_TEST_SUITE_P(I2CCommunicationTests, AutonomousTest, testing::Bool(),
+                         testing::PrintToStringParamName());
+
+class MatchTimeTest : public I2CCommunicationTest<int> {};
+
+TEST_P(MatchTimeTest, Alert) {
+  auto matchTime = GetParam();
+  frc::sim::DriverStationSim::SetMatchTime(matchTime);
+  frc::sim::DriverStationSim::NotifyNewData();
+
+  EXPECT_TRUE(HALSIM_GetI2CInitialized(m_port));
+
+  frc::sim::StepTiming(20_ms);
+
+  std::string expected = fmt::format("{:03}", matchTime);
+  EXPECT_EQ(expected, gString.substr(3));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    I2CCommunicationTests, MatchTimeTest, testing::Values(112, 45, 27, 23, 3),
+    [](const testing::TestParamInfo<int>& info) {
+      return testing::PrintToString(info.param).append("_s");
+    });

wpilibcExamples/src/test/cpp/examples/I2CCommunication/cpp/main.cpp

@@ -0,0 +1,17 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include <hal/HALBase.h>
+
+#include "gtest/gtest.h"
+
+/**
+ * Runs all unit tests.
+ */
+int main(int argc, char** argv) {
+  HAL_Initialize(500, 0);
+  ::testing::InitGoogleTest(&argc, argv);
+  int ret = RUN_ALL_TESTS();
+  return ret;
+}