[hal] Translate unit tests to catch2 (#9003)

hal/BUILD.bazel

@@ -200,7 +200,7 @@ cc_test(
     srcs = glob(["src/test/native/**/*.cpp"]),
     deps = [
         ":wpiHal",
-        "//thirdparty/googletest",
+        "//thirdparty/catch2",
     ],
 )
 

hal/CMakeLists.txt

@@ -34,6 +34,6 @@ install(FILES ${WPILIB_BINARY_DIR}/hal-config.cmake DESTINATION share/hal)
 install(EXPORT hal DESTINATION share/hal)
 
 if(WITH_TESTS)
-    wpilib_add_test(hal src/test/native/cpp)
-    target_link_libraries(hal_test hal googletest)
+    wpilib_add_test_catch2(hal src/test/native/cpp)
+    target_link_libraries(hal_test hal)
 endif()

hal/build.gradle

@@ -2,6 +2,7 @@ ext {
     nativeName = 'hal'
     setBaseName = 'wpiHal'
     devMain = 'org.wpilib.hardware.hal.DevMain'
+    nativeTestSuiteName = "${nativeName}Catch2Test"
     generatedHeaders = "src/generated/main/native/include"
     splitSetup = {
         if (it.targetPlatform.name == nativeUtils.wpi.platforms.systemcore) {

hal/src/test/native/cpp/HALTest.cpp

@@ -4,10 +4,10 @@
 
 #include "wpi/hal/HAL.h"
 
-#include <gtest/gtest.h>
+#include <catch2/catch_test_macros.hpp>
 
 namespace wpi::hal {
-TEST(HALTest, RuntimeType) {
-  EXPECT_EQ(HAL_RuntimeType::HAL_RUNTIME_SIMULATION, HAL_GetRuntimeType());
+TEST_CASE("HALTest RuntimeType", "[hal]") {
+  CHECK(HAL_RuntimeType::HAL_RUNTIME_SIMULATION == HAL_GetRuntimeType());
 }
 }  // namespace wpi::hal

hal/src/test/native/cpp/can/CANTest.cpp

@@ -5,7 +5,7 @@
 #include <cstring>
 #include <utility>
 
-#include <gtest/gtest.h>
+#include <catch2/catch_test_macros.hpp>
 
 #include "wpi/hal/CANAPI.h"
 #include "wpi/hal/simulation/CanData.h"
@@ -43,11 +43,11 @@ struct CANSendCallbackStore {
   int32_t handle;
 };
 
-TEST(CANTest, CanIdPacking) {
+TEST_CASE("CANTest CanIdPacking", "[hal][can]") {
   int32_t status = 0;
   int32_t deviceId = 12;
   CANTestStore testStore(kCANBusS0, deviceId, &status);
-  ASSERT_EQ(0, status);
+  REQUIRE(0 == status);
 
   std::pair<int32_t, bool> storePair;
   storePair.second = false;
@@ -72,17 +72,17 @@ TEST(CANTest, CanIdPacking) {
 
   HAL_WriteCANPacket(testStore.handle, apiId, &message, &status);
 
-  ASSERT_EQ(0, status);
+  REQUIRE(0 == status);
 
-  ASSERT_TRUE(storePair.second);
+  REQUIRE(storePair.second);
 
-  ASSERT_NE(0, storePair.first);
+  REQUIRE(0 != storePair.first);
 
-  ASSERT_EQ(deviceId, storePair.first & 0x3F);
-  ASSERT_EQ(apiId, (storePair.first & 0x0000FFC0) >> 6);
-  ASSERT_EQ(static_cast<int32_t>(HAL_CANManufacturer::HAL_CAN_MAN_TEAM_USE),
-            (storePair.first & 0x00FF0000) >> 16);
-  ASSERT_EQ(static_cast<int32_t>(HAL_CANDeviceType::HAL_CAN_DEV_MISCELLANEOUS),
-            (storePair.first & 0x1F000000) >> 24);
+  REQUIRE(deviceId == (storePair.first & 0x3F));
+  REQUIRE(apiId == ((storePair.first & 0x0000FFC0) >> 6));
+  REQUIRE(static_cast<int32_t>(HAL_CANManufacturer::HAL_CAN_MAN_TEAM_USE) ==
+          (storePair.first & 0x00FF0000) >> 16);
+  REQUIRE(static_cast<int32_t>(HAL_CANDeviceType::HAL_CAN_DEV_MISCELLANEOUS) ==
+          (storePair.first & 0x1F000000) >> 24);
 }
 }  // namespace wpi::hal

hal/src/test/native/cpp/handles/HandleTest.cpp

@@ -4,7 +4,7 @@
 
 #include <memory>
 
-#include <gtest/gtest.h>
+#include <catch2/catch_test_macros.hpp>
 
 #include "wpi/hal/handles/IndexedClassedHandleResource.hpp"
 
@@ -15,13 +15,13 @@ class MyTestClass {};
 }  // namespace
 
 namespace wpi::hal {
-TEST(HandleTest, ClassedHandle) {
+TEST_CASE("HandleTest ClassedHandle", "[hal][handles]") {
   wpi::hal::IndexedClassedHandleResource<HAL_TestHandle, MyTestClass, 8,
                                          HAL_HandleEnum::VENDOR>
       testClass;
   auto resource =
       testClass.Allocate(0, std::make_shared<MyTestClass>(), "TestResource");
-  EXPECT_TRUE(resource.has_value());
+  CHECK(resource.has_value());
 }
 
 }  // namespace wpi::hal

hal/src/test/native/cpp/main.cpp

@@ -2,13 +2,30 @@
 // 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_view>
+
+#include <catch2/catch_session.hpp>
 
 #include "wpi/hal/HAL.h"
 
-int main(int argc, char** argv) {
-  HAL_Initialize(500, 0);
-  ::testing::InitGoogleTest(&argc, argv);
-  int ret = RUN_ALL_TESTS();
-  return ret;
+namespace {
+
+bool IsCatchListCommand(int argc, char** argv) {
+  for (int i = 1; i < argc; ++i) {
+    std::string_view arg{argv[i]};
+    if (arg == "--list-tests" || arg == "--list-tags" ||
+        arg == "--list-reporters" || arg == "--list-listeners") {
+      return true;
+    }
+  }
+  return false;
+}
+
+}  // namespace
+
+int main(int argc, char** argv) {
+  if (!IsCatchListCommand(argc, argv)) {
+    HAL_Initialize(500, 0);
+  }
+  return Catch::Session().run(argc, argv);
 }

hal/src/test/native/cpp/mockdata/AnalogInDataTest.cpp

@@ -6,7 +6,7 @@
 
 #include <string>
 
-#include <gtest/gtest.h>
+#include <catch2/catch_test_macros.hpp>
 
 #include "wpi/hal/AnalogInput.h"
 #include "wpi/hal/Errors.h"
@@ -24,14 +24,14 @@ void TestAnalogInInitializationCallback(const char* name, void* param,
   gTestAnalogInCallbackValue = *value;
 }
 
-TEST(AnalogInSimTest, AnalogInInitialization) {
+TEST_CASE("AnalogInSimTest AnalogInInitialization", "[hal][mockdata]") {
   const int INDEX_TO_TEST = 1;
 
   int callbackParam = 0;
   int callbackId = HALSIM_RegisterAnalogInInitializedCallback(
       INDEX_TO_TEST, &TestAnalogInInitializationCallback, &callbackParam,
       false);
-  ASSERT_TRUE(0 != callbackId);
+  REQUIRE(0 != callbackId);
 
   int32_t status = 0;
   int32_t channel = 0;
@@ -41,31 +41,31 @@ TEST(AnalogInSimTest, AnalogInInitialization) {
   channel = 8000;
   gTestAnalogInCallbackName = "Unset";
   analogInHandle = HAL_InitializeAnalogInputPort(channel, nullptr, &status);
-  EXPECT_EQ(HAL_INVALID_HANDLE, analogInHandle);
-  EXPECT_EQ(HAL_USE_LAST_ERROR, status);
+  CHECK(HAL_INVALID_HANDLE == analogInHandle);
+  CHECK(HAL_USE_LAST_ERROR == status);
   HAL_GetLastError(&status);
-  EXPECT_EQ(HAL_RESOURCE_OUT_OF_RANGE, status);
-  EXPECT_STREQ("Unset", gTestAnalogInCallbackName.c_str());
+  CHECK(HAL_RESOURCE_OUT_OF_RANGE == status);
+  CHECK("Unset" == gTestAnalogInCallbackName);
 
   // Successful setup
   status = 0;
   channel = INDEX_TO_TEST;
   gTestAnalogInCallbackName = "Unset";
   analogInHandle = HAL_InitializeAnalogInputPort(channel, nullptr, &status);
-  EXPECT_TRUE(HAL_INVALID_HANDLE != analogInHandle);
-  EXPECT_EQ(0, status);
-  EXPECT_STREQ("Initialized", gTestAnalogInCallbackName.c_str());
+  CHECK(HAL_INVALID_HANDLE != analogInHandle);
+  CHECK(0 == status);
+  CHECK("Initialized" == gTestAnalogInCallbackName);
 
   // Double initialize... should fail
   status = 0;
   channel = INDEX_TO_TEST;
   gTestAnalogInCallbackName = "Unset";
   analogInHandle = HAL_InitializeAnalogInputPort(channel, nullptr, &status);
-  EXPECT_EQ(HAL_INVALID_HANDLE, analogInHandle);
-  EXPECT_EQ(HAL_USE_LAST_ERROR, status);
+  CHECK(HAL_INVALID_HANDLE == analogInHandle);
+  CHECK(HAL_USE_LAST_ERROR == status);
   HAL_GetLastError(&status);
-  EXPECT_EQ(HAL_RESOURCE_IS_ALLOCATED, status);
-  EXPECT_STREQ("Unset", gTestAnalogInCallbackName.c_str());
+  CHECK(HAL_RESOURCE_IS_ALLOCATED == status);
+  CHECK("Unset" == gTestAnalogInCallbackName);
 
   // Reset, should allow you to re-register
   wpi::hal::HandleBase::ResetGlobalHandles();
@@ -78,9 +78,9 @@ TEST(AnalogInSimTest, AnalogInInitialization) {
   channel = INDEX_TO_TEST;
   gTestAnalogInCallbackName = "Unset";
   analogInHandle = HAL_InitializeAnalogInputPort(channel, nullptr, &status);
-  EXPECT_TRUE(HAL_INVALID_HANDLE != analogInHandle);
-  EXPECT_EQ(0, status);
-  EXPECT_STREQ("Initialized", gTestAnalogInCallbackName.c_str());
+  CHECK(HAL_INVALID_HANDLE != analogInHandle);
+  CHECK(0 == status);
+  CHECK("Initialized" == gTestAnalogInCallbackName);
   HALSIM_CancelAnalogInInitializedCallback(INDEX_TO_TEST, callbackId);
 }
 }  // namespace wpi::hal

hal/src/test/native/cpp/mockdata/DIODataTest.cpp

@@ -6,7 +6,7 @@
 
 #include <string>
 
-#include <gtest/gtest.h>
+#include <catch2/catch_test_macros.hpp>
 
 #include "wpi/hal/DIO.h"
 #include "wpi/hal/Errors.h"
@@ -24,14 +24,14 @@ void TestDigitalIoInitializationCallback(const char* name, void* param,
   gTestDigitalIoCallbackValue = *value;
 }
 
-TEST(DigitalIoSimTest, DigitalIoInitialization) {
+TEST_CASE("DigitalIoSimTest DigitalIoInitialization", "[hal][mockdata]") {
   const int INDEX_TO_TEST = 3;
 
   int callbackParam = 0;
   int callbackId = HALSIM_RegisterDIOInitializedCallback(
       INDEX_TO_TEST, &TestDigitalIoInitializationCallback, &callbackParam,
       false);
-  ASSERT_TRUE(0 != callbackId);
+  REQUIRE(0 != callbackId);
 
   int32_t status = 0;
   int32_t channel = 0;
@@ -41,31 +41,31 @@ TEST(DigitalIoSimTest, DigitalIoInitialization) {
   channel = 8000;
   gTestDigitalIoCallbackName = "Unset";
   digitalIoHandle = HAL_InitializeDIOPort(channel, true, nullptr, &status);
-  EXPECT_EQ(HAL_INVALID_HANDLE, digitalIoHandle);
-  EXPECT_EQ(HAL_USE_LAST_ERROR, status);
+  CHECK(HAL_INVALID_HANDLE == digitalIoHandle);
+  CHECK(HAL_USE_LAST_ERROR == status);
   HAL_GetLastError(&status);
-  EXPECT_EQ(HAL_RESOURCE_OUT_OF_RANGE, status);
-  EXPECT_STREQ("Unset", gTestDigitalIoCallbackName.c_str());
+  CHECK(HAL_RESOURCE_OUT_OF_RANGE == status);
+  CHECK("Unset" == gTestDigitalIoCallbackName);
 
   // Successful setup
   status = 0;
   channel = INDEX_TO_TEST;
   gTestDigitalIoCallbackName = "Unset";
   digitalIoHandle = HAL_InitializeDIOPort(channel, true, nullptr, &status);
-  EXPECT_TRUE(HAL_INVALID_HANDLE != digitalIoHandle);
-  EXPECT_EQ(0, status);
-  EXPECT_STREQ("Initialized", gTestDigitalIoCallbackName.c_str());
+  CHECK(HAL_INVALID_HANDLE != digitalIoHandle);
+  CHECK(0 == status);
+  CHECK("Initialized" == gTestDigitalIoCallbackName);
 
   // Double initialize... should fail
   status = 0;
   channel = INDEX_TO_TEST;
   gTestDigitalIoCallbackName = "Unset";
   digitalIoHandle = HAL_InitializeDIOPort(channel, true, nullptr, &status);
-  EXPECT_EQ(HAL_INVALID_HANDLE, digitalIoHandle);
-  EXPECT_EQ(HAL_USE_LAST_ERROR, status);
+  CHECK(HAL_INVALID_HANDLE == digitalIoHandle);
+  CHECK(HAL_USE_LAST_ERROR == status);
   HAL_GetLastError(&status);
-  EXPECT_EQ(HAL_RESOURCE_IS_ALLOCATED, status);
-  EXPECT_STREQ("Unset", gTestDigitalIoCallbackName.c_str());
+  CHECK(HAL_RESOURCE_IS_ALLOCATED == status);
+  CHECK("Unset" == gTestDigitalIoCallbackName);
 
   // Reset, should allow you to re-register
   wpi::hal::HandleBase::ResetGlobalHandles();
@@ -78,9 +78,9 @@ TEST(DigitalIoSimTest, DigitalIoInitialization) {
   channel = INDEX_TO_TEST;
   gTestDigitalIoCallbackName = "Unset";
   digitalIoHandle = HAL_InitializeDIOPort(channel, true, nullptr, &status);
-  EXPECT_TRUE(HAL_INVALID_HANDLE != digitalIoHandle);
-  EXPECT_EQ(0, status);
-  EXPECT_STREQ("Initialized", gTestDigitalIoCallbackName.c_str());
+  CHECK(HAL_INVALID_HANDLE != digitalIoHandle);
+  CHECK(0 == status);
+  CHECK("Initialized" == gTestDigitalIoCallbackName);
   HALSIM_CancelDIOInitializedCallback(INDEX_TO_TEST, callbackId);
 }
 

hal/src/test/native/cpp/mockdata/DriverStationDataTest.cpp

@@ -6,14 +6,15 @@
 
 #include <cstring>
 
-#include <gtest/gtest.h>
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 #include "wpi/hal/DriverStation.h"
 #include "wpi/util/StringExtras.hpp"
 
 namespace wpi::hal {
 
-TEST(DriverStationTest, Joystick) {
+TEST_CASE("DriverStationTest Joystick", "[hal][mockdata]") {
   HAL_JoystickAxes axes;
   HAL_JoystickPOVs povs;
   HAL_JoystickButtons buttons;
@@ -24,18 +25,18 @@ TEST(DriverStationTest, Joystick) {
     HAL_GetJoystickPOVs(joystickNum, &povs);
     HAL_GetJoystickButtons(joystickNum, &buttons);
 
-    EXPECT_EQ(0, axes.available);
+    CHECK(0 == axes.available);
     for (int i = 0; i < HAL_MAX_JOYSTICK_AXES; ++i) {
-      EXPECT_EQ(0, axes.axes[i]);
+      CHECK(0 == axes.axes[i]);
     }
 
-    EXPECT_EQ(0, povs.available);
+    CHECK(0 == povs.available);
     for (int i = 0; i < HAL_MAX_JOYSTICK_POVS; ++i) {
-      EXPECT_EQ(0, povs.povs[i]);
+      CHECK(0 == povs.povs[i]);
     }
 
-    EXPECT_EQ(0llu, buttons.available);
-    EXPECT_EQ(0llu, buttons.buttons);
+    CHECK(0llu == buttons.available);
+    CHECK(0llu == buttons.buttons);
   }
 
   HAL_JoystickAxes set_axes;
@@ -72,26 +73,28 @@ TEST(DriverStationTest, Joystick) {
   HAL_GetJoystickPOVs(joystickUnderTest, &povs);
   HAL_GetJoystickButtons(joystickUnderTest, &buttons);
 
-  EXPECT_EQ(0x1F, axes.available);
-  EXPECT_NEAR(0.000, axes.axes[0], 0.000001);
-  EXPECT_NEAR(0.125, axes.axes[1], 0.000001);
-  EXPECT_NEAR(0.250, axes.axes[2], 0.000001);
-  EXPECT_NEAR(0.375, axes.axes[3], 0.000001);
-  EXPECT_NEAR(0.500, axes.axes[4], 0.000001);
-  EXPECT_NEAR(0, axes.axes[5], 0.000001);  // Should not have been set, still 0
-  EXPECT_NEAR(0, axes.axes[6], 0.000001);  // Should not have been set, still 0
+  CHECK(0x1F == axes.available);
+  CHECK(axes.axes[0] == Catch::Approx(0.000).margin(0.000001));
+  CHECK(axes.axes[1] == Catch::Approx(0.125).margin(0.000001));
+  CHECK(axes.axes[2] == Catch::Approx(0.250).margin(0.000001));
+  CHECK(axes.axes[3] == Catch::Approx(0.375).margin(0.000001));
+  CHECK(axes.axes[4] == Catch::Approx(0.500).margin(0.000001));
+  CHECK(axes.axes[5] == Catch::Approx(0).margin(
+                            0.000001));  // Should not have been set, still 0
+  CHECK(axes.axes[6] == Catch::Approx(0).margin(
+                            0.000001));  // Should not have been set, still 0
 
-  EXPECT_EQ(0x7, povs.available);
-  EXPECT_EQ(HAL_JOYSTICK_POV_UP, povs.povs[0]);
-  EXPECT_EQ(HAL_JOYSTICK_POV_RIGHT, povs.povs[1]);
-  EXPECT_EQ(HAL_JOYSTICK_POV_DOWN, povs.povs[2]);
-  EXPECT_EQ(0, povs.povs[3]);  // Should not have been set, still 0
-  EXPECT_EQ(0, povs.povs[4]);  // Should not have been set, still 0
-  EXPECT_EQ(0, povs.povs[5]);  // Should not have been set, still 0
-  EXPECT_EQ(0, povs.povs[6]);  // Should not have been set, still 0
+  CHECK(0x7 == povs.available);
+  CHECK(HAL_JOYSTICK_POV_UP == povs.povs[0]);
+  CHECK(HAL_JOYSTICK_POV_RIGHT == povs.povs[1]);
+  CHECK(HAL_JOYSTICK_POV_DOWN == povs.povs[2]);
+  CHECK(0 == povs.povs[3]);  // Should not have been set, still 0
+  CHECK(0 == povs.povs[4]);  // Should not have been set, still 0
+  CHECK(0 == povs.povs[5]);  // Should not have been set, still 0
+  CHECK(0 == povs.povs[6]);  // Should not have been set, still 0
 
-  EXPECT_EQ(0xFFllu, buttons.available);
-  EXPECT_EQ(0xDEADBEEFllu, buttons.buttons);
+  CHECK(0xFFllu == buttons.available);
+  CHECK(0xDEADBEEFllu == buttons.buttons);
 
   // Reset
   HALSIM_ResetDriverStationData();
@@ -103,22 +106,22 @@ TEST(DriverStationTest, Joystick) {
     HAL_GetJoystickPOVs(joystickNum, &povs);
     HAL_GetJoystickButtons(joystickNum, &buttons);
 
-    EXPECT_EQ(0, axes.available);
+    CHECK(0 == axes.available);
     for (int i = 0; i < HAL_MAX_JOYSTICK_AXES; ++i) {
-      EXPECT_EQ(0, axes.axes[i]);
+      CHECK(0 == axes.axes[i]);
     }
 
-    EXPECT_EQ(0, povs.available);
+    CHECK(0 == povs.available);
     for (int i = 0; i < HAL_MAX_JOYSTICK_POVS; ++i) {
-      EXPECT_EQ(0, povs.povs[i]);
+      CHECK(0 == povs.povs[i]);
     }
 
-    EXPECT_EQ(0llu, buttons.available);
-    EXPECT_EQ(0llu, buttons.buttons);
+    CHECK(0llu == buttons.available);
+    CHECK(0llu == buttons.buttons);
   }
 }
 
-TEST(DriverStationTest, EventInfo) {
+TEST_CASE("DriverStationTest EventInfo", "[hal][mockdata]") {
   constexpr std::string_view eventName = "UnitTest";
   HAL_MatchInfo info;
   wpi::util::format_to_n_c_str(info.eventName, sizeof(info.eventName),
@@ -133,10 +136,10 @@ TEST(DriverStationTest, EventInfo) {
   HAL_MatchInfo dataBack;
   HAL_GetMatchInfo(&dataBack);
 
-  EXPECT_EQ(eventName, dataBack.eventName);
-  EXPECT_EQ(5, dataBack.matchNumber);
-  EXPECT_EQ(HAL_MatchType::HAL_MATCH_TYPE_QUALIFICATION, dataBack.matchType);
-  EXPECT_EQ(42, dataBack.replayNumber);
+  CHECK(eventName == dataBack.eventName);
+  CHECK(5 == dataBack.matchNumber);
+  CHECK(HAL_MatchType::HAL_MATCH_TYPE_QUALIFICATION == dataBack.matchType);
+  CHECK(42 == dataBack.replayNumber);
 }
 
 }  // namespace wpi::hal

hal/src/test/native/cpp/mockdata/I2CDataTest.cpp

@@ -6,7 +6,7 @@
 
 #include <string>
 
-#include <gtest/gtest.h>
+#include <catch2/catch_test_macros.hpp>
 
 #include "wpi/hal/I2C.h"
 
@@ -21,7 +21,7 @@ void TestI2CInitializationCallback(const char* name, void* param,
   gTestI2CCallbackValue = *value;
 }
 
-TEST(I2CSimTest, I2CInitialization) {
+TEST_CASE("I2CSimTest I2CInitialization", "[hal][mockdata]") {
   const int INDEX_TO_TEST = 1;
 
   int32_t status = 0;
@@ -30,12 +30,12 @@ TEST(I2CSimTest, I2CInitialization) {
   int callbackParam = 0;
   int callbackId = HALSIM_RegisterI2CInitializedCallback(
       INDEX_TO_TEST, &TestI2CInitializationCallback, &callbackParam, false);
-  ASSERT_TRUE(0 != callbackId);
+  REQUIRE(0 != callbackId);
 
   port = HAL_I2C_PORT_1;
   gTestI2CCallbackName = "Unset";
   HAL_InitializeI2C(port, &status);
-  EXPECT_STREQ("Initialized", gTestI2CCallbackName.c_str());
+  CHECK("Initialized" == gTestI2CCallbackName);
 }
 
 }  // namespace wpi::hal

hal/src/test/native/cpp/mockdata/PCMDataTest.cpp

@@ -4,7 +4,7 @@
 
 #include <string>
 
-#include <gtest/gtest.h>
+#include <catch2/catch_test_macros.hpp>
 
 #include "wpi/hal/CTREPCM.h"
 #include "wpi/hal/Errors.h"
@@ -23,14 +23,14 @@ void TestSolenoidInitializationCallback(const char* name, void* param,
   gTestSolenoidCallbackValue = *value;
 }
 
-TEST(PCMDataTest, PCMInitialization) {
+TEST_CASE("PCMDataTest PCMInitialization", "[hal][mockdata]") {
   const int MODULE_TO_TEST = 2;
 
   int callbackParam = 0;
   int callbackId = HALSIM_RegisterCTREPCMInitializedCallback(
       MODULE_TO_TEST, &TestSolenoidInitializationCallback, &callbackParam,
       false);
-  ASSERT_TRUE(0 != callbackId);
+  REQUIRE(0 != callbackId);
 
   int32_t status = 0;
   int32_t module;
@@ -40,31 +40,31 @@ TEST(PCMDataTest, PCMInitialization) {
   module = 8000;
   gTestSolenoidCallbackName = "Unset";
   pcmHandle = HAL_InitializeCTREPCM(0, module, nullptr, &status);
-  EXPECT_EQ(HAL_INVALID_HANDLE, pcmHandle);
-  EXPECT_EQ(HAL_USE_LAST_ERROR, status);
+  CHECK(HAL_INVALID_HANDLE == pcmHandle);
+  CHECK(HAL_USE_LAST_ERROR == status);
   HAL_GetLastError(&status);
-  EXPECT_EQ(HAL_RESOURCE_OUT_OF_RANGE, status);
-  EXPECT_STREQ("Unset", gTestSolenoidCallbackName.c_str());
+  CHECK(HAL_RESOURCE_OUT_OF_RANGE == status);
+  CHECK("Unset" == gTestSolenoidCallbackName);
 
   // Successful setup
   status = 0;
   module = MODULE_TO_TEST;
   gTestSolenoidCallbackName = "Unset";
   pcmHandle = HAL_InitializeCTREPCM(0, module, nullptr, &status);
-  EXPECT_TRUE(HAL_INVALID_HANDLE != pcmHandle);
-  EXPECT_EQ(0, status);
-  EXPECT_STREQ("Initialized", gTestSolenoidCallbackName.c_str());
+  CHECK(HAL_INVALID_HANDLE != pcmHandle);
+  CHECK(0 == status);
+  CHECK("Initialized" == gTestSolenoidCallbackName);
 
   // Double initialize... should fail
   status = 0;
   module = MODULE_TO_TEST;
   gTestSolenoidCallbackName = "Unset";
   pcmHandle = HAL_InitializeCTREPCM(0, module, nullptr, &status);
-  EXPECT_EQ(HAL_INVALID_HANDLE, pcmHandle);
-  EXPECT_EQ(HAL_USE_LAST_ERROR, status);
+  CHECK(HAL_INVALID_HANDLE == pcmHandle);
+  CHECK(HAL_USE_LAST_ERROR == status);
   HAL_GetLastError(&status);
-  EXPECT_EQ(HAL_RESOURCE_IS_ALLOCATED, status);
-  EXPECT_STREQ("Unset", gTestSolenoidCallbackName.c_str());
+  CHECK(HAL_RESOURCE_IS_ALLOCATED == status);
+  CHECK("Unset" == gTestSolenoidCallbackName);
 
   // Reset, should allow you to re-register
   wpi::hal::HandleBase::ResetGlobalHandles();
@@ -72,15 +72,15 @@ TEST(PCMDataTest, PCMInitialization) {
   callbackId = HALSIM_RegisterCTREPCMInitializedCallback(
       MODULE_TO_TEST, &TestSolenoidInitializationCallback, &callbackParam,
       false);
-  ASSERT_TRUE(0 != callbackId);
+  REQUIRE(0 != callbackId);
 
   status = 0;
   module = MODULE_TO_TEST;
   gTestSolenoidCallbackName = "Unset";
   pcmHandle = HAL_InitializeCTREPCM(0, module, nullptr, &status);
-  EXPECT_TRUE(HAL_INVALID_HANDLE != pcmHandle);
-  EXPECT_EQ(0, status);
-  EXPECT_STREQ("Initialized", gTestSolenoidCallbackName.c_str());
+  CHECK(HAL_INVALID_HANDLE != pcmHandle);
+  CHECK(0 == status);
+  CHECK("Initialized" == gTestSolenoidCallbackName);
 }
 
 }  // namespace wpi::hal

hal/src/test/native/cpp/mockdata/PDPDataTest.cpp

@@ -4,7 +4,7 @@
 
 #include <string>
 
-#include <gtest/gtest.h>
+#include <catch2/catch_test_macros.hpp>
 
 #include "wpi/hal/PowerDistribution.h"
 #include "wpi/hal/simulation/PowerDistributionData.h"
@@ -20,13 +20,13 @@ void TestPdpInitializationCallback(const char* name, void* param,
   gTestPdpCallbackValue = *value;
 }
 
-TEST(PdpSimTest, PdpInitialization) {
+TEST_CASE("PdpSimTest PdpInitialization", "[hal][mockdata]") {
   const int INDEX_TO_TEST = 1;
 
   int callbackParam = 0;
   int callbackId = HALSIM_RegisterPowerDistributionInitializedCallback(
       INDEX_TO_TEST, &TestPdpInitializationCallback, &callbackParam, false);
-  ASSERT_TRUE(0 != callbackId);
+  REQUIRE(0 != callbackId);
 
   int32_t status = 0;
 
@@ -34,8 +34,8 @@ TEST(PdpSimTest, PdpInitialization) {
   gTestPdpCallbackName = "Unset";
   HAL_InitializePowerDistribution(0, INDEX_TO_TEST, HAL_POWER_DISTRIBUTION_CTRE,
                                   nullptr, &status);
-  EXPECT_EQ(0, status);
-  EXPECT_STREQ("Initialized", gTestPdpCallbackName.c_str());
+  CHECK(0 == status);
+  CHECK("Initialized" == gTestPdpCallbackName);
 }
 
 }  // namespace wpi::hal

hal/src/test/native/cpp/mockdata/PWMDataTest.cpp

@@ -6,7 +6,7 @@
 
 #include <string>
 
-#include <gtest/gtest.h>
+#include <catch2/catch_test_macros.hpp>
 
 #include "wpi/hal/Errors.h"
 #include "wpi/hal/HAL.h"
@@ -24,13 +24,13 @@ void TestPwmInitializationCallback(const char* name, void* param,
   gTestPwmCallbackValue = *value;
 }
 
-TEST(PWMSimTest, PwmInitialization) {
+TEST_CASE("PWMSimTest PwmInitialization", "[hal][mockdata]") {
   const int INDEX_TO_TEST = 7;
 
   int callbackParam = 0;
   int callbackId = HALSIM_RegisterPWMInitializedCallback(
       INDEX_TO_TEST, &TestPwmInitializationCallback, &callbackParam, false);
-  ASSERT_TRUE(0 != callbackId);
+  REQUIRE(0 != callbackId);
 
   int32_t status = 0;
   int32_t channel = 0;
@@ -40,31 +40,31 @@ TEST(PWMSimTest, PwmInitialization) {
   channel = 8000;
   gTestPwmCallbackName = "Unset";
   pwmHandle = HAL_InitializePWMPort(channel, nullptr, &status);
-  EXPECT_EQ(HAL_INVALID_HANDLE, pwmHandle);
-  EXPECT_EQ(HAL_USE_LAST_ERROR, status);
+  CHECK(HAL_INVALID_HANDLE == pwmHandle);
+  CHECK(HAL_USE_LAST_ERROR == status);
   HAL_GetLastError(&status);
-  EXPECT_EQ(HAL_RESOURCE_OUT_OF_RANGE, status);
-  EXPECT_STREQ("Unset", gTestPwmCallbackName.c_str());
+  CHECK(HAL_RESOURCE_OUT_OF_RANGE == status);
+  CHECK("Unset" == gTestPwmCallbackName);
 
   // Successful setup
   status = 0;
   channel = INDEX_TO_TEST;
   gTestPwmCallbackName = "Unset";
   pwmHandle = HAL_InitializePWMPort(channel, nullptr, &status);
-  EXPECT_TRUE(HAL_INVALID_HANDLE != pwmHandle);
-  EXPECT_EQ(0, status);
-  EXPECT_STREQ("Initialized", gTestPwmCallbackName.c_str());
+  CHECK(HAL_INVALID_HANDLE != pwmHandle);
+  CHECK(0 == status);
+  CHECK("Initialized" == gTestPwmCallbackName);
 
   // Double initialize... should fail
   status = 0;
   channel = INDEX_TO_TEST;
   gTestPwmCallbackName = "Unset";
   pwmHandle = HAL_InitializePWMPort(channel, nullptr, &status);
-  EXPECT_EQ(HAL_INVALID_HANDLE, pwmHandle);
-  EXPECT_EQ(HAL_USE_LAST_ERROR, status);
+  CHECK(HAL_INVALID_HANDLE == pwmHandle);
+  CHECK(HAL_USE_LAST_ERROR == status);
   HAL_GetLastError(&status);
-  EXPECT_EQ(HAL_RESOURCE_IS_ALLOCATED, status);
-  EXPECT_STREQ("Unset", gTestPwmCallbackName.c_str());
+  CHECK(HAL_RESOURCE_IS_ALLOCATED == status);
+  CHECK("Unset" == gTestPwmCallbackName);
 
   // Reset, should allow you to re-register
   wpi::hal::HandleBase::ResetGlobalHandles();
@@ -76,9 +76,9 @@ TEST(PWMSimTest, PwmInitialization) {
   channel = INDEX_TO_TEST;
   gTestPwmCallbackName = "Unset";
   pwmHandle = HAL_InitializePWMPort(channel, nullptr, &status);
-  EXPECT_TRUE(HAL_INVALID_HANDLE != pwmHandle);
-  EXPECT_EQ(0, status);
-  EXPECT_STREQ("Initialized", gTestPwmCallbackName.c_str());
+  CHECK(HAL_INVALID_HANDLE != pwmHandle);
+  CHECK(0 == status);
+  CHECK("Initialized" == gTestPwmCallbackName);
   HALSIM_CancelPWMInitializedCallback(INDEX_TO_TEST, callbackId);
 }
 }  // namespace wpi::hal

hal/src/test/native/cpp/mockdata/SimDeviceDataTest.cpp

@@ -4,21 +4,21 @@
 
 #include "wpi/hal/simulation/SimDeviceData.h"
 
-#include <gtest/gtest.h>
+#include <catch2/catch_test_macros.hpp>
 
 #include "wpi/hal/SimDevice.h"
 
 namespace wpi::hal {
 
-TEST(SimDeviceSimTest, Enabled) {
-  ASSERT_TRUE(HALSIM_IsSimDeviceEnabled("foo"));
+TEST_CASE("SimDeviceSimTest Enabled", "[hal][mockdata]") {
+  REQUIRE(HALSIM_IsSimDeviceEnabled("foo"));
   HALSIM_SetSimDeviceEnabled("f", false);
   HALSIM_SetSimDeviceEnabled("foob", true);
-  ASSERT_FALSE(HALSIM_IsSimDeviceEnabled("foo"));
-  ASSERT_TRUE(HALSIM_IsSimDeviceEnabled("foobar"));
-  ASSERT_TRUE(HALSIM_IsSimDeviceEnabled("bar"));
+  REQUIRE_FALSE(HALSIM_IsSimDeviceEnabled("foo"));
+  REQUIRE(HALSIM_IsSimDeviceEnabled("foobar"));
+  REQUIRE(HALSIM_IsSimDeviceEnabled("bar"));
 
-  ASSERT_EQ(HAL_CreateSimDevice("foo"), 0);
+  REQUIRE(HAL_CreateSimDevice("foo") == 0);
 }
 
 }  // namespace wpi::hal