diff --git a/crossConnIntegrationTests/src/main/native/cpp/AnalogTest.cpp b/crossConnIntegrationTests/src/main/native/cpp/AnalogTest.cpp
new file mode 100644
index 0000000..3423ffe
--- /dev/null
+++ b/crossConnIntegrationTests/src/main/native/cpp/AnalogTest.cpp
@@ -0,0 +1,112 @@
+// 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/AnalogInput.h>
+#include <hal/AnalogOutput.h>
+#include <wpi/SmallVector.h>
+
+#include "CrossConnects.h"
+#include "LifetimeWrappers.h"
+#include "gtest/gtest.h"
+
+using namespace hlt;
+
+class AnalogCrossTest : public ::testing::TestWithParam<std::pair<int, int>> {};
+
+TEST_P(AnalogCrossTest, AnalogCross) {
+  auto param = GetParam();
+
+  int32_t status = 0;
+  AnalogInputHandle input{param.first, &status};
+  ASSERT_EQ(0, status);
+  AnalogOutputHandle output{param.second, &status};
+  ASSERT_EQ(0, status);
+
+  for (double i = 0; i < 5; i += 0.1) {
+    HAL_SetAnalogOutput(output, i, &status);
+    ASSERT_EQ(0, status);
+    usleep(1000);
+    ASSERT_NEAR(i, HAL_GetAnalogVoltage(input, &status), 0.01);
+    ASSERT_EQ(0, status);
+  }
+
+  for (double i = 5; i > 0; i -= 0.1) {
+    HAL_SetAnalogOutput(output, i, &status);
+    ASSERT_EQ(0, status);
+    usleep(1000);
+    ASSERT_NEAR(i, HAL_GetAnalogVoltage(input, &status), 0.01);
+    ASSERT_EQ(0, status);
+  }
+}
+
+TEST(AnalogInputTest, AllocateAll) {
+  wpi::SmallVector<AnalogInputHandle, 21> analogHandles;
+  for (int i = 0; i < HAL_GetNumAnalogInputs(); i++) {
+    int32_t status = 0;
+    analogHandles.emplace_back(AnalogInputHandle(i, &status));
+    ASSERT_EQ(status, 0);
+  }
+}
+
+TEST(AnalogInputTest, MultipleAllocateFails) {
+  int32_t status = 0;
+  AnalogInputHandle handle(0, &status);
+  ASSERT_NE(handle, HAL_kInvalidHandle);
+  ASSERT_EQ(status, 0);
+
+  AnalogInputHandle handle2(0, &status);
+  ASSERT_EQ(handle2, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_IS_ALLOCATED);
+}
+
+TEST(AnalogInputTest, OverAllocateFails) {
+  int32_t status = 0;
+  AnalogInputHandle handle(HAL_GetNumAnalogInputs(), &status);
+  ASSERT_EQ(handle, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_OUT_OF_RANGE);
+}
+
+TEST(AnalogInputTest, UnderAllocateFails) {
+  int32_t status = 0;
+  AnalogInputHandle handle(-1, &status);
+  ASSERT_EQ(handle, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_OUT_OF_RANGE);
+}
+
+TEST(AnalogOutputTest, AllocateAll) {
+  wpi::SmallVector<AnalogOutputHandle, 21> analogHandles;
+  for (int i = 0; i < HAL_GetNumAnalogOutputs(); i++) {
+    int32_t status = 0;
+    analogHandles.emplace_back(AnalogOutputHandle(i, &status));
+    ASSERT_EQ(status, 0);
+  }
+}
+
+TEST(AnalogOutputTest, MultipleAllocateFails) {
+  int32_t status = 0;
+  AnalogOutputHandle handle(0, &status);
+  ASSERT_NE(handle, HAL_kInvalidHandle);
+  ASSERT_EQ(status, 0);
+
+  AnalogOutputHandle handle2(0, &status);
+  ASSERT_EQ(handle2, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_IS_ALLOCATED);
+}
+
+TEST(AnalogOutputTest, OverAllocateFails) {
+  int32_t status = 0;
+  AnalogOutputHandle handle(HAL_GetNumAnalogOutputs(), &status);
+  ASSERT_EQ(handle, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_OUT_OF_RANGE);
+}
+
+TEST(AnalogOutputTest, UnderAllocateFails) {
+  int32_t status = 0;
+  AnalogOutputHandle handle(-1, &status);
+  ASSERT_EQ(handle, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_OUT_OF_RANGE);
+}
+
+INSTANTIATE_TEST_SUITE_P(AnalogCrossConnectsTests, AnalogCrossTest,
+                         ::testing::ValuesIn(AnalogCrossConnects));
diff --git a/crossConnIntegrationTests/src/main/native/cpp/DIOTest.cpp b/crossConnIntegrationTests/src/main/native/cpp/DIOTest.cpp
new file mode 100644
index 0000000..84d2b9d
--- /dev/null
+++ b/crossConnIntegrationTests/src/main/native/cpp/DIOTest.cpp
@@ -0,0 +1,101 @@
+// 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/DIO.h>
+#include <wpi/SmallVector.h>
+
+#include "CrossConnects.h"
+#include "LifetimeWrappers.h"
+#include "gtest/gtest.h"
+
+using namespace hlt;
+
+class DIOTest : public ::testing::TestWithParam<std::pair<int, int>> {};
+
+TEST_P(DIOTest, DIOCross) {
+  auto param = GetParam();
+  int32_t status = 0;
+  DIOHandle first{param.first, false, &status};
+  ASSERT_EQ(0, status);
+  DIOHandle second{param.second, true, &status};
+  ASSERT_EQ(0, status);
+
+  HAL_SetDIO(first, false, &status);
+  ASSERT_EQ(0, status);
+  usleep(1000);
+  ASSERT_FALSE(HAL_GetDIO(first, &status));
+  ASSERT_EQ(0, status);
+  ASSERT_FALSE(HAL_GetDIO(second, &status));
+  ASSERT_EQ(0, status);
+
+  HAL_SetDIO(first, true, &status);
+  ASSERT_EQ(0, status);
+  usleep(1000);
+  ASSERT_TRUE(HAL_GetDIO(second, &status));
+  ASSERT_EQ(0, status);
+
+  HAL_SetDIODirection(first, true, &status);
+  ASSERT_EQ(0, status);
+  HAL_SetDIODirection(second, false, &status);
+  ASSERT_EQ(0, status);
+
+  HAL_SetDIO(second, false, &status);
+  ASSERT_EQ(0, status);
+  usleep(1000);
+  ASSERT_FALSE(HAL_GetDIO(first, &status));
+  ASSERT_EQ(0, status);
+
+  HAL_SetDIO(second, true, &status);
+  ASSERT_EQ(0, status);
+  usleep(1000);
+  ASSERT_TRUE(HAL_GetDIO(first, &status));
+  ASSERT_EQ(0, status);
+}
+
+TEST(DIOTest, AllocateAll) {
+  wpi::SmallVector<DIOHandle, 32> dioHandles;
+  for (int i = 0; i < HAL_GetNumDigitalChannels(); i++) {
+    int32_t status = 0;
+    dioHandles.emplace_back(i, true, &status);
+    ASSERT_EQ(status, 0);
+  }
+}
+
+TEST(DIOTest, MultipleAllocateFails) {
+  int32_t status = 0;
+  DIOHandle handle(0, true, &status);
+  ASSERT_NE(handle, HAL_kInvalidHandle);
+  ASSERT_EQ(status, 0);
+
+  DIOHandle handle2(0, true, &status);
+  ASSERT_EQ(handle2, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_IS_ALLOCATED);
+}
+
+TEST(DIOTest, OverAllocateFails) {
+  int32_t status = 0;
+  DIOHandle handle(HAL_GetNumDigitalChannels(), true, &status);
+  ASSERT_EQ(handle, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_OUT_OF_RANGE);
+}
+
+TEST(DIOTest, UnderAllocateFails) {
+  int32_t status = 0;
+  DIOHandle handle(-1, true, &status);
+  ASSERT_EQ(handle, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_OUT_OF_RANGE);
+}
+
+TEST(DIOTest, CrossAllocationFails) {
+  int32_t status = 0;
+  PWMHandle pwmHandle(10, &status);
+  ASSERT_NE(pwmHandle, HAL_kInvalidHandle);
+  ASSERT_EQ(status, 0);
+  DIOHandle handle(10, true, &status);
+  ASSERT_EQ(handle, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_IS_ALLOCATED);
+}
+
+INSTANTIATE_TEST_SUITE_P(DIOCrossConnectsTests, DIOTest,
+                         ::testing::ValuesIn(DIOCrossConnects));
diff --git a/crossConnIntegrationTests/src/main/native/cpp/DutyCycleTest.cpp b/crossConnIntegrationTests/src/main/native/cpp/DutyCycleTest.cpp
new file mode 100644
index 0000000..830ddc4
--- /dev/null
+++ b/crossConnIntegrationTests/src/main/native/cpp/DutyCycleTest.cpp
@@ -0,0 +1,51 @@
+// 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/HAL.h>
+
+#include "CrossConnects.h"
+#include "LifetimeWrappers.h"
+#include "gtest/gtest.h"
+
+using namespace hlt;
+
+class DutyCycleTest : public ::testing::TestWithParam<std::pair<int, int>> {};
+
+TEST_P(DutyCycleTest, DutyCycle) {
+  auto param = GetParam();
+
+  int32_t status = 0;
+  PWMHandle pwmHandle(param.first, &status);
+  ASSERT_NE(pwmHandle, HAL_kInvalidHandle);
+  ASSERT_EQ(0, status);
+
+  // Ensure our PWM is disabled, and set up properly
+  HAL_SetPWMRaw(pwmHandle, 0, &status);
+  ASSERT_EQ(0, status);
+  HAL_SetPWMConfig(pwmHandle, 2.0, 1.0, 1.0, 0, 0, &status);
+  HAL_SetPWMConfig(pwmHandle, 5.05, 2.525, 2.525, 2.525, 0, &status);
+  ASSERT_EQ(0, status);
+  HAL_SetPWMPeriodScale(pwmHandle, 0, &status);
+  ASSERT_EQ(0, status);
+
+  DIOHandle dioHandle{param.second, true, &status};
+  ASSERT_EQ(0, status);
+
+  DutyCycleHandle dutyCycle{dioHandle, &status};
+  ASSERT_EQ(0, status);
+
+  HAL_SetPWMSpeed(pwmHandle, 0.5, &status);
+  ASSERT_EQ(0, status);
+
+  // Sleep enough time for the frequency to converge
+  usleep(3500000);
+
+  ASSERT_NEAR(1000 / 5.05,
+              (double)HAL_GetDutyCycleFrequency(dutyCycle, &status), 1);
+
+  // TODO measure output
+}
+
+INSTANTIATE_TEST_SUITE_P(DutyCycleCrossConnTests, DutyCycleTest,
+                         ::testing::ValuesIn(PWMCrossConnects));
diff --git a/crossConnIntegrationTests/src/main/native/cpp/Main.cpp b/crossConnIntegrationTests/src/main/native/cpp/Main.cpp
new file mode 100644
index 0000000..95bc5b5
--- /dev/null
+++ b/crossConnIntegrationTests/src/main/native/cpp/Main.cpp
@@ -0,0 +1,10 @@
+// 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"
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/crossConnIntegrationTests/src/main/native/cpp/PWMTest.cpp b/crossConnIntegrationTests/src/main/native/cpp/PWMTest.cpp
new file mode 100644
index 0000000..27fcce7
--- /dev/null
+++ b/crossConnIntegrationTests/src/main/native/cpp/PWMTest.cpp
@@ -0,0 +1,357 @@
+// 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 <atomic>
+#include <thread>
+
+#include <hal/DMA.h>
+#include <hal/HAL.h>
+#include <wpi/SmallVector.h>
+#include <wpi/condition_variable.h>
+#include <wpi/priority_mutex.h>
+
+#include "CrossConnects.h"
+#include "LifetimeWrappers.h"
+#include "gtest/gtest.h"
+
+using namespace hlt;
+
+class PWMTest : public ::testing::TestWithParam<std::pair<int, int>> {};
+
+void TestTimingDMA(int squelch, std::pair<int, int> param) {
+  // Initialize DMA
+  int32_t status = 0;
+  DMAHandle dmaHandle(&status);
+  ASSERT_NE(dmaHandle, HAL_kInvalidHandle);
+  ASSERT_EQ(0, status);
+
+  status = 0;
+  PWMHandle pwmHandle(param.first, &status);
+  ASSERT_NE(pwmHandle, HAL_kInvalidHandle);
+  ASSERT_EQ(0, status);
+
+  // Ensure our PWM is disabled, and set up properly
+  HAL_SetPWMRaw(pwmHandle, 0, &status);
+  HAL_SetPWMConfig(pwmHandle, 2.0, 1.0, 1.0, 0, 0, &status);
+  HAL_SetPWMPeriodScale(pwmHandle, squelch, &status);
+
+  unsigned int checkPeriod = 0;
+  switch (squelch) {
+    case (0):
+      checkPeriod = 5050;
+      break;
+    case (1):
+      checkPeriod = 10100;
+      break;
+    case (3):
+      checkPeriod = 20200;
+      break;
+  }
+
+  status = 0;
+  DIOHandle dioHandle(param.second, true, &status);
+  ASSERT_NE(dioHandle, HAL_kInvalidHandle);
+
+  HAL_AddDMADigitalSource(dmaHandle, dioHandle, &status);
+  ASSERT_EQ(0, status);
+
+  HAL_SetDMAExternalTrigger(dmaHandle, dioHandle,
+                            HAL_AnalogTriggerType::HAL_Trigger_kInWindow, true,
+                            true, &status);
+  ASSERT_EQ(0, status);
+
+  // Loop to test 5 speeds
+  for (unsigned int testWidth = 1000; testWidth < 2100; testWidth += 250) {
+    HAL_StartDMA(dmaHandle, 1024, &status);
+    ASSERT_EQ(0, status);
+
+    while (true) {
+      int32_t remaining = 0;
+      HAL_DMASample testSample;
+      HAL_ReadDMA(dmaHandle, &testSample, 0.01, &remaining, &status);
+      if (remaining == 0) {
+        break;
+      }
+    }
+
+    HAL_SetPWMSpeed(pwmHandle, (testWidth - 1000) / 1000.0, &status);
+
+    constexpr const int kSampleCount = 15;
+    HAL_DMASample dmaSamples[kSampleCount];
+    int readCount = 0;
+    while (readCount < kSampleCount) {
+      status = 0;
+      int32_t remaining = 0;
+      HAL_DMAReadStatus readStatus = HAL_ReadDMA(
+          dmaHandle, &dmaSamples[readCount], 1.0, &remaining, &status);
+      ASSERT_EQ(0, status);
+      ASSERT_EQ(HAL_DMAReadStatus::HAL_DMA_OK, readStatus);
+      readCount++;
+    }
+
+    HAL_SetPWMSpeed(pwmHandle, 0, &status);
+    HAL_StopDMA(dmaHandle, &status);
+
+    // Find first rising edge
+    int startIndex = 4;
+    while (startIndex < 6) {
+      status = 0;
+      auto value = HAL_GetDMASampleDigitalSource(&dmaSamples[startIndex],
+                                                 dioHandle, &status);
+      ASSERT_EQ(0, status);
+      if (value)
+        break;
+      startIndex++;
+    }
+    ASSERT_LT(startIndex, 6);
+
+    // Check that samples alternate
+    bool previous = false;
+    int iterationCount = 0;
+    for (int i = startIndex; i < startIndex + 8; i++) {
+      auto value =
+          HAL_GetDMASampleDigitalSource(&dmaSamples[i], dioHandle, &status);
+      ASSERT_EQ(0, status);
+      ASSERT_NE(previous, value);
+      previous = !previous;
+      iterationCount++;
+    }
+    ASSERT_EQ(iterationCount, 8);
+    iterationCount = 0;
+
+    // Check width between samples
+    for (int i = startIndex; i < startIndex + 8; i += 2) {
+      auto width = HAL_GetDMASampleTime(&dmaSamples[i + 1], &status) -
+                   HAL_GetDMASampleTime(&dmaSamples[i], &status);
+      ASSERT_NEAR(testWidth, width, 10);
+      iterationCount++;
+    }
+    ASSERT_EQ(iterationCount, 4);
+    iterationCount = 0;
+
+    // Check period between samples
+    for (int i = startIndex; i < startIndex + 6; i += 2) {
+      auto period = HAL_GetDMASampleTime(&dmaSamples[i + 2], &status) -
+                    HAL_GetDMASampleTime(&dmaSamples[i], &status);
+      ASSERT_NEAR(checkPeriod, period, 10);
+      iterationCount++;
+    }
+    ASSERT_EQ(iterationCount, 3);
+  }
+}
+
+struct InterruptCheckData {
+  wpi::SmallVector<uint64_t, 8> risingStamps;
+  wpi::SmallVector<uint64_t, 8> fallingStamps;
+  wpi::priority_mutex mutex;
+  wpi::condition_variable cond;
+  HAL_InterruptHandle handle;
+};
+
+// TODO switch this to DMA
+void TestTiming(int squelch, std::pair<int, int> param) {
+  // Initialize interrupt
+  int32_t status = 0;
+  InterruptHandle interruptHandle(&status);
+  // Ensure we have a valid interrupt handle
+  ASSERT_NE(interruptHandle, HAL_kInvalidHandle);
+
+  status = 0;
+  PWMHandle pwmHandle(param.first, &status);
+  ASSERT_NE(pwmHandle, HAL_kInvalidHandle);
+
+  // Ensure our PWM is disabled, and set up properly
+  HAL_SetPWMRaw(pwmHandle, 0, &status);
+  HAL_SetPWMConfig(pwmHandle, 2.0, 1.0, 1.0, 0, 0, &status);
+  HAL_SetPWMPeriodScale(pwmHandle, squelch, &status);
+
+  unsigned int checkPeriod = 0;
+  switch (squelch) {
+    case (0):
+      checkPeriod = 5050;
+      break;
+    case (1):
+      checkPeriod = 10100;
+      break;
+    case (3):
+      checkPeriod = 20200;
+      break;
+  }
+
+  status = 0;
+  DIOHandle dioHandle(param.second, true, &status);
+  ASSERT_NE(dioHandle, HAL_kInvalidHandle);
+
+  InterruptCheckData interruptData;
+  interruptData.handle = interruptHandle;
+
+  // Can use any type for the interrupt handle
+  HAL_RequestInterrupts(interruptHandle, dioHandle,
+                        HAL_AnalogTriggerType::HAL_Trigger_kInWindow, &status);
+
+  HAL_SetInterruptUpSourceEdge(interruptHandle, true, true, &status);
+
+  // Loop to test 5 speeds
+  for (unsigned int i = 1000; i < 2100; i += 250) {
+    interruptData.risingStamps.clear();
+    interruptData.fallingStamps.clear();
+
+    std::atomic_bool runThread{true};
+
+    status = 0;
+    std::thread interruptThread([&]() {
+      while (runThread) {
+        int32_t threadStatus = 0;
+        auto mask =
+            HAL_WaitForInterrupt(interruptHandle, 5, true, &threadStatus);
+
+        if ((mask & 0x100) == 0x100 && interruptData.risingStamps.size() == 0 &&
+            interruptData.fallingStamps.size() == 0) {
+          // Falling edge at start of tracking. Skip
+          continue;
+        }
+
+        int32_t status = 0;
+        if ((mask & 0x1) == 0x1) {
+          auto ts = HAL_ReadInterruptRisingTimestamp(interruptHandle, &status);
+          // Rising Edge
+          interruptData.risingStamps.push_back(ts);
+        } else if ((mask & 0x100) == 0x100) {
+          auto ts = HAL_ReadInterruptFallingTimestamp(interruptHandle, &status);
+          // Falling Edge
+          interruptData.fallingStamps.push_back(ts);
+        }
+
+        if (interruptData.risingStamps.size() >= 4 &&
+            interruptData.fallingStamps.size() >= 4) {
+          interruptData.cond.notify_all();
+          runThread = false;
+          break;
+        }
+      }
+    });
+
+    // Ensure our interrupt actually got created correctly.
+    ASSERT_EQ(status, 0);
+    HAL_SetPWMSpeed(pwmHandle, (i - 1000) / 1000.0, &status);
+    ASSERT_EQ(status, 0);
+    {
+      std::unique_lock<wpi::priority_mutex> lock(interruptData.mutex);
+      // Wait for lock
+      // TODO: Add Timeout
+      auto timeout = interruptData.cond.wait_for(lock, std::chrono::seconds(2));
+      if (timeout == std::cv_status::timeout) {
+        runThread = false;
+        if (interruptThread.joinable()) {
+          interruptThread.join();
+        }
+        ASSERT_TRUE(false);  // Exit test as failure on timeout
+      }
+    }
+
+    HAL_SetPWMRaw(pwmHandle, 0, &status);
+
+    // Ensure our interrupts have the proper counts
+    ASSERT_EQ(interruptData.risingStamps.size(),
+              interruptData.fallingStamps.size());
+
+    ASSERT_GT(interruptData.risingStamps.size(), 0u);
+
+    ASSERT_EQ(interruptData.risingStamps.size() % 2, 0u);
+    ASSERT_EQ(interruptData.fallingStamps.size() % 2, 0u);
+
+    for (size_t j = 0; j < interruptData.risingStamps.size(); j++) {
+      uint64_t width =
+          interruptData.fallingStamps[j] - interruptData.risingStamps[j];
+      ASSERT_NEAR(width, i, 10);
+    }
+
+    for (unsigned int j = 0; j < interruptData.risingStamps.size() - 1; j++) {
+      uint64_t period =
+          interruptData.risingStamps[j + 1] - interruptData.risingStamps[j];
+      ASSERT_NEAR(period, checkPeriod, 10);
+    }
+    runThread = false;
+    if (interruptThread.joinable()) {
+      interruptThread.join();
+    }
+  }
+}
+
+TEST_P(PWMTest, Timing4x) {
+  auto param = GetParam();
+  TestTiming(3, param);
+}
+
+TEST_P(PWMTest, Timing2x) {
+  auto param = GetParam();
+  TestTiming(1, param);
+}
+
+TEST_P(PWMTest, Timing1x) {
+  auto param = GetParam();
+  TestTiming(0, param);
+}
+
+TEST_P(PWMTest, TimingDMA4x) {
+  auto param = GetParam();
+  TestTimingDMA(3, param);
+}
+
+TEST_P(PWMTest, TimingDMA2x) {
+  auto param = GetParam();
+  TestTimingDMA(1, param);
+}
+
+TEST_P(PWMTest, TimingDMA1x) {
+  auto param = GetParam();
+  TestTimingDMA(0, param);
+}
+
+TEST(PWMTest, AllocateAll) {
+  wpi::SmallVector<PWMHandle, 21> pwmHandles;
+  for (int i = 0; i < HAL_GetNumPWMChannels(); i++) {
+    int32_t status = 0;
+    pwmHandles.emplace_back(PWMHandle(i, &status));
+    ASSERT_EQ(status, 0);
+  }
+}
+
+TEST(PWMTest, MultipleAllocateFails) {
+  int32_t status = 0;
+  PWMHandle handle(0, &status);
+  ASSERT_NE(handle, HAL_kInvalidHandle);
+  ASSERT_EQ(status, 0);
+
+  PWMHandle handle2(0, &status);
+  ASSERT_EQ(handle2, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_IS_ALLOCATED);
+}
+
+TEST(PWMTest, OverAllocateFails) {
+  int32_t status = 0;
+  PWMHandle handle(HAL_GetNumPWMChannels(), &status);
+  ASSERT_EQ(handle, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_OUT_OF_RANGE);
+}
+
+TEST(PWMTest, UnderAllocateFails) {
+  int32_t status = 0;
+  PWMHandle handle(-1, &status);
+  ASSERT_EQ(handle, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_OUT_OF_RANGE);
+}
+
+TEST(PWMTest, CrossAllocationFails) {
+  int32_t status = 0;
+  DIOHandle dioHandle(10, true, &status);
+  ASSERT_NE(dioHandle, HAL_kInvalidHandle);
+  ASSERT_EQ(status, 0);
+  PWMHandle handle(10, &status);
+  ASSERT_EQ(handle, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_IS_ALLOCATED);
+}
+
+INSTANTIATE_TEST_SUITE_P(PWMCrossConnectTests, PWMTest,
+                         ::testing::ValuesIn(PWMCrossConnects));
diff --git a/crossConnIntegrationTests/src/main/native/cpp/RelayAnalogTest.cpp b/crossConnIntegrationTests/src/main/native/cpp/RelayAnalogTest.cpp
new file mode 100644
index 0000000..fc7da0c
--- /dev/null
+++ b/crossConnIntegrationTests/src/main/native/cpp/RelayAnalogTest.cpp
@@ -0,0 +1,50 @@
+// 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/AnalogInput.h>
+#include <hal/Relay.h>
+#include <wpi/SmallVector.h>
+
+#include "CrossConnects.h"
+#include "LifetimeWrappers.h"
+#include "gtest/gtest.h"
+
+using namespace hlt;
+
+class RelayAnalogTest : public ::testing::TestWithParam<std::pair<int, int>> {};
+
+TEST_P(RelayAnalogTest, RelayAnalogCross) {
+  auto param = GetParam();
+
+  int32_t status = 0;
+  RelayHandle relay{param.first, true, &status};
+  ASSERT_EQ(0, status);
+  AnalogInputHandle analog{param.second, &status};
+  ASSERT_EQ(0, status);
+  AnalogTriggerHandle trigger{analog, &status};
+  ASSERT_EQ(0, status);
+  HAL_SetAnalogTriggerLimitsVoltage(trigger, 1.5, 3.0, &status);
+  ASSERT_EQ(0, status);
+
+  HAL_SetRelay(relay, false, &status);
+  ASSERT_EQ(0, status);
+  usleep(1000);
+  ASSERT_FALSE(HAL_GetAnalogTriggerTriggerState(trigger, &status));
+  ASSERT_EQ(0, status);
+
+  HAL_SetRelay(relay, true, &status);
+  ASSERT_EQ(0, status);
+  usleep(1000);
+  ASSERT_TRUE(HAL_GetAnalogTriggerTriggerState(trigger, &status));
+  ASSERT_EQ(0, status);
+
+  HAL_SetRelay(relay, false, &status);
+  ASSERT_EQ(0, status);
+  usleep(1000);
+  ASSERT_FALSE(HAL_GetAnalogTriggerTriggerState(trigger, &status));
+  ASSERT_EQ(0, status);
+}
+
+INSTANTIATE_TEST_SUITE_P(RelayAnalogCrossConnectsTests, RelayAnalogTest,
+                         ::testing::ValuesIn(RelayAnalogCrossConnects));
diff --git a/crossConnIntegrationTests/src/main/native/cpp/RelayDigitalTest.cpp b/crossConnIntegrationTests/src/main/native/cpp/RelayDigitalTest.cpp
new file mode 100644
index 0000000..c7923bc
--- /dev/null
+++ b/crossConnIntegrationTests/src/main/native/cpp/RelayDigitalTest.cpp
@@ -0,0 +1,104 @@
+// 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/Relay.h>
+#include <wpi/SmallVector.h>
+
+#include "CrossConnects.h"
+#include "LifetimeWrappers.h"
+#include "gtest/gtest.h"
+
+using namespace hlt;
+
+class RelayDigitalTest : public ::testing::TestWithParam<RelayCross> {};
+
+TEST_P(RelayDigitalTest, RelayCross) {
+  auto param = GetParam();
+  int32_t status = 0;
+  RelayHandle fwd{param.Relay, true, &status};
+  ASSERT_EQ(0, status);
+  RelayHandle rev{param.Relay, false, &status};
+  ASSERT_EQ(0, status);
+  DIOHandle fwdInput{param.FwdDio, true, &status};
+  ASSERT_EQ(0, status);
+  DIOHandle revInput{param.RevDio, true, &status};
+  ASSERT_EQ(0, status);
+
+  HAL_SetRelay(fwd, false, &status);
+  ASSERT_EQ(0, status);
+  HAL_SetRelay(rev, false, &status);
+  ASSERT_EQ(0, status);
+  usleep(1000);
+  ASSERT_FALSE(HAL_GetDIO(fwdInput, &status));
+  ASSERT_EQ(0, status);
+  ASSERT_FALSE(HAL_GetDIO(revInput, &status));
+  ASSERT_EQ(0, status);
+
+  HAL_SetRelay(fwd, false, &status);
+  ASSERT_EQ(0, status);
+  HAL_SetRelay(rev, true, &status);
+  ASSERT_EQ(0, status);
+  usleep(1000);
+  ASSERT_FALSE(HAL_GetDIO(fwdInput, &status));
+  ASSERT_EQ(0, status);
+  ASSERT_TRUE(HAL_GetDIO(revInput, &status));
+  ASSERT_EQ(0, status);
+
+  HAL_SetRelay(fwd, true, &status);
+  ASSERT_EQ(0, status);
+  HAL_SetRelay(rev, false, &status);
+  ASSERT_EQ(0, status);
+  usleep(1000);
+  ASSERT_TRUE(HAL_GetDIO(fwdInput, &status));
+  ASSERT_EQ(0, status);
+  ASSERT_FALSE(HAL_GetDIO(revInput, &status));
+  ASSERT_EQ(0, status);
+
+  HAL_SetRelay(fwd, true, &status);
+  ASSERT_EQ(0, status);
+  HAL_SetRelay(rev, true, &status);
+  ASSERT_EQ(0, status);
+  usleep(1000);
+  ASSERT_TRUE(HAL_GetDIO(fwdInput, &status));
+  ASSERT_EQ(0, status);
+  ASSERT_TRUE(HAL_GetDIO(revInput, &status));
+  ASSERT_EQ(0, status);
+}
+
+TEST(RelayDigitalTest, AllocateAll) {
+  wpi::SmallVector<RelayHandle, 32> relayHandles;
+  for (int i = 0; i < HAL_GetNumRelayChannels(); i++) {
+    int32_t status = 0;
+    relayHandles.emplace_back(i / 2, i % 2, &status);
+    ASSERT_EQ(status, 0);
+  }
+}
+
+TEST(RelayDigitalTest, MultipleAllocateFails) {
+  int32_t status = 0;
+  RelayHandle handle(0, true, &status);
+  ASSERT_NE(handle, HAL_kInvalidHandle);
+  ASSERT_EQ(status, 0);
+
+  RelayHandle handle2(0, true, &status);
+  ASSERT_EQ(handle2, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_IS_ALLOCATED);
+}
+
+TEST(RelayDigitalTest, OverAllocateFails) {
+  int32_t status = 0;
+  RelayHandle handle(HAL_GetNumRelayChannels(), true, &status);
+  ASSERT_EQ(handle, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_OUT_OF_RANGE);
+}
+
+TEST(RelayDigitalTest, UnderAllocateFails) {
+  int32_t status = 0;
+  RelayHandle handle(-1, true, &status);
+  ASSERT_EQ(handle, HAL_kInvalidHandle);
+  ASSERT_LAST_ERROR_STATUS(status, RESOURCE_OUT_OF_RANGE);
+}
+
+INSTANTIATE_TEST_SUITE_P(RelayDigitalCrossConnectsTests, RelayDigitalTest,
+                         ::testing::ValuesIn(RelayCrossConnects));
diff --git a/crossConnIntegrationTests/src/main/native/cpp/TestEnvironment.cpp b/crossConnIntegrationTests/src/main/native/cpp/TestEnvironment.cpp
new file mode 100644
index 0000000..ee8c2b1
--- /dev/null
+++ b/crossConnIntegrationTests/src/main/native/cpp/TestEnvironment.cpp
@@ -0,0 +1,71 @@
+// 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 <cstdlib>
+#include <thread>
+
+#include <fmt/core.h>
+#include <hal/HAL.h>
+
+#include "gtest/gtest.h"
+#include "mockds/MockDS.h"
+
+using namespace std::chrono_literals;
+
+class TestEnvironment : public testing::Environment {
+  bool m_alreadySetUp = false;
+  MockDS m_mockDS;
+
+ public:
+  TestEnvironment() {
+    // Only set up once. This allows gtest_repeat to be used to automatically
+    // repeat tests.
+    if (m_alreadySetUp) {
+      return;
+    }
+    m_alreadySetUp = true;
+
+    if (!HAL_Initialize(500, 0)) {
+      fmt::print(stderr, "FATAL ERROR: HAL could not be initialized\n");
+      std::exit(-1);
+    }
+
+    m_mockDS.Start();
+
+    // This sets up the network communications library to enable the driver
+    // station. After starting network coms, it will loop until the driver
+    // station returns that the robot is enabled, to ensure that tests will be
+    // able to run on the hardware.
+    HAL_ObserveUserProgramStarting();
+
+    fmt::print("Started coms\n");
+
+    int enableCounter = 0;
+
+    auto checkEnabled = []() {
+      HAL_ControlWord controlWord;
+      std::memset(&controlWord, 0, sizeof(controlWord));
+      HAL_GetControlWord(&controlWord);
+      return controlWord.enabled && controlWord.dsAttached;
+    };
+    while (!checkEnabled()) {
+      if (enableCounter > 50) {
+        // Robot did not enable properly after 5 seconds.
+        // Force exit
+        fmt::print(stderr, " Failed to enable. Aborting\n");
+        std::terminate();
+      }
+
+      std::this_thread::sleep_for(100ms);
+
+      fmt::print("Waiting for enable: {}\n", enableCounter++);
+    }
+    std::this_thread::sleep_for(500ms);
+  }
+
+  ~TestEnvironment() override { m_mockDS.Stop(); }
+};
+
+testing::Environment* const environment =
+    testing::AddGlobalTestEnvironment(new TestEnvironment);
diff --git a/crossConnIntegrationTests/src/main/native/cpp/mockds/MockDS.cpp b/crossConnIntegrationTests/src/main/native/cpp/mockds/MockDS.cpp
new file mode 100644
index 0000000..b2e5c2d
--- /dev/null
+++ b/crossConnIntegrationTests/src/main/native/cpp/mockds/MockDS.cpp
@@ -0,0 +1,86 @@
+// 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 "MockDS.h"
+
+#include <stdint.h>
+
+#include <string_view>
+
+#include <fmt/core.h>
+#include <hal/cpp/fpga_clock.h>
+#include <wpi/Logger.h>
+#include <wpi/SmallVector.h>
+#include <wpi/UDPClient.h>
+
+static void LoggerFunc(unsigned int level, const char* file, unsigned int line,
+                       const char* msg) {
+  if (level == 20) {
+    fmt::print(stderr, "DS: {}\n", msg);
+    return;
+  }
+
+  std::string_view levelmsg;
+  if (level >= 50) {
+    levelmsg = "CRITICAL";
+  } else if (level >= 40) {
+    levelmsg = "ERROR";
+  } else if (level >= 30) {
+    levelmsg = "WARNING";
+  } else {
+    return;
+  }
+  fmt::print(stderr, "DS: {}: {} ({}:{})\n", levelmsg, msg, file, line);
+}
+
+static void generateEnabledDsPacket(wpi::SmallVectorImpl<uint8_t>& data,
+                                    uint16_t sendCount) {
+  data.clear();
+  data.push_back(sendCount >> 8);
+  data.push_back(sendCount);
+  data.push_back(0x01);  // general data tag
+  data.push_back(0x04);  // teleop enabled
+  data.push_back(0x10);  // normal data request
+  data.push_back(0x00);  // red 1 station
+}
+
+void MockDS::Start() {
+  if (m_active) {
+    return;
+  }
+  m_active = true;
+  m_thread = std::thread([&]() {
+    wpi::Logger logger(LoggerFunc);
+    wpi::UDPClient client(logger);
+    client.start();
+    auto timeout_time = hal::fpga_clock::now();
+    int initCount = 0;
+    uint16_t sendCount = 0;
+    wpi::SmallVector<uint8_t, 8> data;
+    while (m_active) {
+      // Keep 20ms intervals, and increase time to next interval
+      auto current = hal::fpga_clock::now();
+      while (timeout_time <= current) {
+        timeout_time += std::chrono::milliseconds(20);
+      }
+      std::this_thread::sleep_until(timeout_time);
+      generateEnabledDsPacket(data, sendCount++);
+      // ~10 disabled packets are required to make the robot actually enable
+      // 1 is definitely not enough.
+      if (initCount < 10) {
+        initCount++;
+        data[3] = 0;
+      }
+      client.send(data, "127.0.0.1", 1110);
+    }
+    client.shutdown();
+  });
+}
+
+void MockDS::Stop() {
+  m_active = false;
+  if (m_thread.joinable()) {
+    m_thread.join();
+  }
+}
diff --git a/crossConnIntegrationTests/src/main/native/cpp/mockds/MockDS.h b/crossConnIntegrationTests/src/main/native/cpp/mockds/MockDS.h
new file mode 100644
index 0000000..da5fcd9
--- /dev/null
+++ b/crossConnIntegrationTests/src/main/native/cpp/mockds/MockDS.h
@@ -0,0 +1,23 @@
+// 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.
+
+#pragma once
+
+#include <atomic>
+#include <thread>
+
+class MockDS {
+ public:
+  MockDS() = default;
+  ~MockDS() { Stop(); }
+  MockDS(const MockDS& other) = delete;
+  MockDS& operator=(const MockDS& other) = delete;
+
+  void Start();
+  void Stop();
+
+ private:
+  std::thread m_thread;
+  std::atomic_bool m_active{false};
+};
diff --git a/crossConnIntegrationTests/src/main/native/dt/Main.cpp b/crossConnIntegrationTests/src/main/native/dt/Main.cpp
new file mode 100644
index 0000000..a3e363e
--- /dev/null
+++ b/crossConnIntegrationTests/src/main/native/dt/Main.cpp
@@ -0,0 +1,5 @@
+// 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.
+
+int main() {}
diff --git a/crossConnIntegrationTests/src/main/native/include/CrossConnects.h b/crossConnIntegrationTests/src/main/native/include/CrossConnects.h
new file mode 100644
index 0000000..f77a8f2
--- /dev/null
+++ b/crossConnIntegrationTests/src/main/native/include/CrossConnects.h
@@ -0,0 +1,62 @@
+// 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.
+
+#pragma once
+
+#include <array>
+#include <utility>
+
+namespace hlt {
+
+constexpr static std::array<std::pair<int, int>, 22> DIOCrossConnects{
+    std::pair{20, 25},
+    std::pair{19, 24},
+    std::pair{17, 13},
+    std::pair{16, 12},
+    std::pair{15, 11},
+    std::pair{14, 10},
+    std::pair{26, 2},
+    std::pair{27, 1},
+    std::pair{28, 0},
+    std::pair{29, 3},
+    std::pair{30, 4},
+
+    // Opposite direction
+    std::pair{25, 20},
+    std::pair{24, 19},
+    std::pair{13, 17},
+    std::pair{12, 16},
+    std::pair{11, 15},
+    std::pair{10, 14},
+    std::pair{2, 26},
+    std::pair{1, 27},
+    std::pair{0, 28},
+    std::pair{3, 29},
+    std::pair{4, 30},
+};
+
+// PWM on left, DIO on right
+constexpr static std::array<std::pair<int, int>, 2> PWMCrossConnects{
+    std::pair{0, 18},
+    std::pair{16, 25},
+};
+
+// FWD only, relay on left
+constexpr static std::array<std::pair<int, int>, 2> RelayAnalogCrossConnects{
+    std::pair{2, 0}, std::pair{3, 1}};
+
+struct RelayCross {
+  int Relay;
+  int FwdDio;
+  int RevDio;
+};
+
+constexpr static std::array<RelayCross, 1> RelayCrossConnects{
+    RelayCross{0, 23, 22}};
+
+// input on left
+constexpr static std::array<std::pair<int, int>, 2> AnalogCrossConnects{
+    std::pair{2, 0}, std::pair{4, 1}};
+
+}  // namespace hlt
diff --git a/crossConnIntegrationTests/src/main/native/include/LifetimeWrappers.h b/crossConnIntegrationTests/src/main/native/include/LifetimeWrappers.h
new file mode 100644
index 0000000..9f0eb15
--- /dev/null
+++ b/crossConnIntegrationTests/src/main/native/include/LifetimeWrappers.h
@@ -0,0 +1,200 @@
+// 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.
+
+#pragma once
+
+#include <hal/DMA.h>
+#include <hal/DutyCycle.h>
+#include <hal/HAL.h>
+
+namespace hlt {
+
+struct InterruptHandle {
+ public:
+  explicit InterruptHandle(int32_t* status) {
+    handle = HAL_InitializeInterrupts(status);
+  }
+  InterruptHandle(const InterruptHandle&) = delete;
+  InterruptHandle operator=(const InterruptHandle&) = delete;
+
+  InterruptHandle(InterruptHandle&&) = default;
+  InterruptHandle& operator=(InterruptHandle&&) = default;
+
+  ~InterruptHandle() { HAL_CleanInterrupts(handle); }
+
+  operator HAL_InterruptHandle() const { return handle; }
+
+ private:
+  HAL_InterruptHandle handle = 0;
+};
+
+struct DMAHandle {
+ public:
+  explicit DMAHandle(int32_t* status) { handle = HAL_InitializeDMA(status); }
+  DMAHandle(const DMAHandle&) = delete;
+  DMAHandle operator=(const DMAHandle&) = delete;
+
+  DMAHandle(DMAHandle&&) = default;
+  DMAHandle& operator=(DMAHandle&&) = default;
+
+  ~DMAHandle() { HAL_FreeDMA(handle); }
+
+  operator HAL_DMAHandle() const { return handle; }
+
+ private:
+  HAL_DMAHandle handle = 0;
+};
+
+struct AnalogInputHandle {
+ public:
+  AnalogInputHandle(int32_t port, int32_t* status) {
+    handle = HAL_InitializeAnalogInputPort(HAL_GetPort(port), nullptr, status);
+  }
+  AnalogInputHandle(const AnalogInputHandle&) = delete;
+  AnalogInputHandle operator=(const AnalogInputHandle&) = delete;
+
+  AnalogInputHandle(AnalogInputHandle&&) = default;
+  AnalogInputHandle& operator=(AnalogInputHandle&&) = default;
+
+  ~AnalogInputHandle() { HAL_FreeAnalogInputPort(handle); }
+
+  operator HAL_AnalogInputHandle() const { return handle; }
+
+ private:
+  HAL_AnalogInputHandle handle = 0;
+};
+
+struct AnalogOutputHandle {
+ public:
+  AnalogOutputHandle(int32_t port, int32_t* status) {
+    handle = HAL_InitializeAnalogOutputPort(HAL_GetPort(port), nullptr, status);
+  }
+  AnalogOutputHandle(const AnalogOutputHandle&) = delete;
+  AnalogOutputHandle operator=(const AnalogOutputHandle&) = delete;
+
+  AnalogOutputHandle(AnalogOutputHandle&&) = default;
+  AnalogOutputHandle& operator=(AnalogOutputHandle&&) = default;
+
+  ~AnalogOutputHandle() { HAL_FreeAnalogOutputPort(handle); }
+
+  operator HAL_AnalogOutputHandle() const { return handle; }
+
+ private:
+  HAL_AnalogOutputHandle handle = 0;
+};
+
+struct AnalogTriggerHandle {
+ public:
+  explicit AnalogTriggerHandle(HAL_AnalogInputHandle port, int32_t* status) {
+    handle = HAL_InitializeAnalogTrigger(port, status);
+  }
+  AnalogTriggerHandle(const AnalogTriggerHandle&) = delete;
+  AnalogTriggerHandle operator=(const AnalogTriggerHandle&) = delete;
+
+  AnalogTriggerHandle(AnalogTriggerHandle&&) = default;
+  AnalogTriggerHandle& operator=(AnalogTriggerHandle&&) = default;
+
+  ~AnalogTriggerHandle() {
+    int32_t status = 0;
+    HAL_CleanAnalogTrigger(handle, &status);
+  }
+
+  operator HAL_AnalogTriggerHandle() const { return handle; }
+
+ private:
+  HAL_AnalogTriggerHandle handle = 0;
+};
+
+struct DutyCycleHandle {
+ public:
+  DutyCycleHandle(HAL_DigitalHandle port, int32_t* status) {
+    handle = HAL_InitializeDutyCycle(
+        port, HAL_AnalogTriggerType::HAL_Trigger_kInWindow, status);
+  }
+  DutyCycleHandle(const DutyCycleHandle&) = delete;
+  DutyCycleHandle operator=(const DutyCycleHandle&) = delete;
+
+  DutyCycleHandle(DutyCycleHandle&&) = default;
+  DutyCycleHandle& operator=(DutyCycleHandle&&) = default;
+
+  ~DutyCycleHandle() { HAL_FreeDutyCycle(handle); }
+
+  operator HAL_DutyCycleHandle() const { return handle; }
+
+ private:
+  HAL_DutyCycleHandle handle = 0;
+};
+
+struct DIOHandle {
+ public:
+  DIOHandle() {}
+  DIOHandle(const DIOHandle&) = delete;
+  DIOHandle operator=(const DIOHandle&) = delete;
+
+  DIOHandle(DIOHandle&&) = default;
+  DIOHandle& operator=(DIOHandle&&) = default;
+
+  DIOHandle(int32_t port, HAL_Bool input, int32_t* status) {
+    handle = HAL_InitializeDIOPort(HAL_GetPort(port), input, nullptr, status);
+  }
+
+  ~DIOHandle() { HAL_FreeDIOPort(handle); }
+
+  operator HAL_DigitalHandle() const { return handle; }
+
+ private:
+  HAL_DigitalHandle handle = 0;
+};
+
+struct PWMHandle {
+ public:
+  PWMHandle() {}
+  PWMHandle(const PWMHandle&) = delete;
+  PWMHandle operator=(const PWMHandle&) = delete;
+
+  PWMHandle(PWMHandle&&) = default;
+  PWMHandle& operator=(PWMHandle&&) = default;
+
+  PWMHandle(int32_t port, int32_t* status) {
+    handle = HAL_InitializePWMPort(HAL_GetPort(port), nullptr, status);
+  }
+
+  ~PWMHandle() {
+    int32_t status = 0;
+    HAL_FreePWMPort(handle, &status);
+  }
+
+  operator HAL_DigitalHandle() const { return handle; }
+
+ private:
+  HAL_DigitalHandle handle = 0;
+};
+
+struct RelayHandle {
+ public:
+  RelayHandle(int32_t port, HAL_Bool fwd, int32_t* status) {
+    handle = HAL_InitializeRelayPort(HAL_GetPort(port), fwd, nullptr, status);
+  }
+  RelayHandle(const RelayHandle&) = delete;
+  RelayHandle operator=(const RelayHandle&) = delete;
+
+  RelayHandle(RelayHandle&&) = default;
+  RelayHandle& operator=(RelayHandle&&) = default;
+
+  ~RelayHandle() { HAL_FreeRelayPort(handle); }
+
+  operator HAL_RelayHandle() const { return handle; }
+
+ private:
+  HAL_RelayHandle handle = 0;
+};
+
+#define ASSERT_LAST_ERROR_STATUS(status, x)                          \
+  do {                                                               \
+    ASSERT_EQ(status, HAL_USE_LAST_ERROR);                           \
+    const char* lastErrorMessageInMacro = HAL_GetLastError(&status); \
+    ASSERT_EQ(status, x);                                            \
+  } while (0)
+
+}  // namespace hlt