Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-25 01:41:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Peter Johnson
2026-06-21 19:26:10 -07:00
committed by GitHub
parent 912938b434
commit c3fe63b2f7
15 changed files with 170 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
hal/src/test/native/cpp/mockdata/AnalogInDataTest.cpp
View File

@@ -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

34
hal/src/test/native/cpp/mockdata/DIODataTest.cpp
View File

@@ -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);
}

77
hal/src/test/native/cpp/mockdata/DriverStationDataTest.cpp
View File

@@ -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

8
hal/src/test/native/cpp/mockdata/I2CDataTest.cpp
View File

@@ -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

36
hal/src/test/native/cpp/mockdata/PCMDataTest.cpp
View File

@@ -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

10
hal/src/test/native/cpp/mockdata/PDPDataTest.cpp
View File

@@ -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

34
hal/src/test/native/cpp/mockdata/PWMDataTest.cpp
View File

@@ -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

14
hal/src/test/native/cpp/mockdata/SimDeviceDataTest.cpp
View File

@@ -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