test: add unit tests for scheduling and affinity helpers.

Author: srvald

tests/test_helpers.cpp

@@ -145,3 +145,220 @@ TEST(TestHelpers, robotSeriesString)
   EXPECT_EQ(robotSeriesString(RobotSeries::UR_SERIES), "UR_SERIES");
   EXPECT_EQ(robotSeriesString(RobotSeries::UNDEFINED), "UNDEFINED");
 }
+
+// Thread Affinity Tests
+
+TEST(TestHelpers, setThreadAffinity_basic)
+{
+  pthread_t thread = pthread_self();
+#ifdef _WIN32
+  DWORD_PTR mask = (1ULL << 0);
+  EXPECT_TRUE(setThreadAffinity(thread, mask));
+#else
+  cpu_set_t cpuset;
+  CPU_ZERO(&cpuset);
+  CPU_SET(0, &cpuset);
+  EXPECT_TRUE(setThreadAffinity(thread, cpuset));
+#endif
+}
+
+TEST(TestHelpers, setThreadAffinity_mult)
+{
+  pthread_t thread = pthread_self();
+#ifdef _WIN32
+  DWORD_PTR mask = (1ULL << 6) | (1ULL << 7);
+  EXPECT_TRUE(setThreadAffinity(thread, mask));
+#else
+  cpu_set_t cpuset;
+  CPU_ZERO(&cpuset);
+  CPU_SET(6, &cpuset);
+  CPU_SET(7, &cpuset);
+  EXPECT_TRUE(setThreadAffinity(thread, cpuset));
+#endif
+}
+
+TEST(TestHelpers, setThreadAffinity_invalid)
+{
+#ifdef _WIN32
+  pthread_t thread = pthread_self();
+  uint64_t invalid_mask = 1ULL << 63; 
+  EXPECT_FALSE(setThreadAffinity(thread, invalid_mask));
+#else
+  cpu_set_t cpuset;
+  CPU_ZERO(&cpuset);
+  CPU_SET(63, &cpuset);
+  EXPECT_TRUE(setThreadAffinity(thread, cpuset));
+#endif
+}
+
+TEST(TestHelpers, setThreadAffinity_invalidHandle)
+{
+#ifdef _WIN32
+  pthread_t thread = nullptr;
+  EXPECT_FALSE(setThreadAffinity(thread, (1ULL << 0)));
+#else
+  pthread_t thread{};
+  cpu_set_t cpuset;
+  CPU_ZERO(&cpuset);
+  CPU_SET(0, &cpuset);
+  EXPECT_FALSE(setThreadAffinity(thread, cpuset));
+#endif
+}
+
+TEST(TestHelpers, setThreadAffinity_empty)
+{
+#ifdef _WIN32
+  pthread_t thread = pthread_self();
+  EXPECT_FALSE(setThreadAffinity(thread, 0));
+#else
+  pthread_t thread = pthread_self();
+  cpu_set_t cpuset;
+  CPU_ZERO(&cpuset);
+  EXPECT_FALSE(setThreadAffinity(thread, cpuset));
+#endif
+
+}
+
+// Thread Priority Tests
+
+TEST(TestHelpers, setThreadPriority_allValidPriorities)
+{
+#ifdef _WIN32
+  pthread_t thread = pthread_self();
+
+  EXPECT_TRUE(setThreadPriority(thread, THREAD_PRIORITY_LOWEST));
+  EXPECT_TRUE(setThreadPriority(thread, THREAD_PRIORITY_BELOW_NORMAL));
+  EXPECT_TRUE(setThreadPriority(thread, THREAD_PRIORITY_NORMAL));
+  EXPECT_TRUE(setThreadPriority(thread, THREAD_PRIORITY_ABOVE_NORMAL));
+  EXPECT_TRUE(setThreadPriority(thread, THREAD_PRIORITY_HIGHEST));
+  EXPECT_TRUE(setThreadPriority(thread, THREAD_PRIORITY_TIME_CRITICAL));
+#endif
+}
+
+TEST(TestHelpers, setThreadPriority_invalid)
+{
+#ifdef _WIN32
+  pthread_t thread = pthread_self();
+  EXPECT_FALSE(setThreadPriority(thread, 999999));
+#endif
+}
+
+TEST(TestHelpers, setThreadPriority_invalidHandle)
+{
+#ifdef _WIN32
+  pthread_t thread = nullptr;
+  EXPECT_FALSE(setThreadPriority(thread, THREAD_PRIORITY_HIGHEST));
+#endif
+}
+
+// Process Priority tests
+
+TEST(TestHelpers, setProcessPriority_allValidPriorities)
+{
+#ifdef _WIN32
+  pprocess_t process = pprocess_self();
+
+  EXPECT_TRUE(setProcessPriority(process, IDLE_PRIORITY_CLASS));
+  EXPECT_TRUE(setProcessPriority(process, BELOW_NORMAL_PRIORITY_CLASS));
+  EXPECT_TRUE(setProcessPriority(process, NORMAL_PRIORITY_CLASS));
+  EXPECT_TRUE(setProcessPriority(process, ABOVE_NORMAL_PRIORITY_CLASS));
+  EXPECT_TRUE(setProcessPriority(process, HIGH_PRIORITY_CLASS));
+#endif
+}
+
+TEST(TestHelpers, setProcessPriority_invalid)
+{
+#ifdef _WIN32
+  pprocess_t process = pprocess_self();
+  EXPECT_FALSE(setProcessPriority(process, 999999));
+#endif
+}
+
+TEST(TestHelpers, setProcessPriority_invalidHandle)
+{
+#ifdef _WIN32
+  pprocess_t process = nullptr;
+  EXPECT_FALSE(setProcessPriority(process, NORMAL_PRIORITY_CLASS));
+#endif
+}
+
+// Process Affinity Tests
+
+TEST(TestHelpers, setProcessAffinity_basic)
+{
+#ifdef _WIN32
+  pprocess_t process = pprocess_self();
+  DWORD_PTR mask = (1ULL << 0);
+  EXPECT_TRUE(setProcessAffinity(process, mask));
+#endif
+}
+
+TEST(TestHelpers, setProcessAffinity_multi)
+{
+#ifdef _WIN32
+  pprocess_t process = pprocess_self();
+  DWORD_PTR mask = (1ULL << 0) | (1ULL << 1);
+  EXPECT_TRUE(setProcessAffinity(process, mask));
+#endif
+}
+
+TEST(TestHelpers, setProcessAffinity_invalidHandle)
+{
+#ifdef _WIN32
+  pprocess_t process = nullptr;
+  EXPECT_FALSE(setProcessAffinity(process, (1ULL << 0)));
+#endif
+}
+
+TEST(TestHelpers, setProcessAffinity_zeroMask)
+{
+#ifdef _WIN32
+  pprocess_t process = pprocess_self();
+  EXPECT_FALSE(setProcessAffinity(process,0));
+#endif
+}
+
+TEST(TestHelpers, setProcessAffinity_invalidMask)
+{
+#ifdef _WIN32
+  pprocess_t process = pprocess_self();
+  DWORD_PTR mask = 0xFFFFFFFFFFFFFFFFULL;
+  EXPECT_FALSE(setProcessAffinity(process, mask));
+#endif
+}
+
+// FIFO Scheduling Tests
+
+TEST(TestHelpers, setFiFoScheduling_normal)
+{
+  pthread_t thread = pthread_self();
+#ifdef _WIN32
+  EXPECT_TRUE(setFiFoScheduling(thread, THREAD_PRIORITY_NORMAL));
+#else
+  EXPECT_TRUE(setFiFoScheduling(thread, 50));
+#endif
+}
+
+TEST(TestHelpers, setFiFoScheduling_invalidPriority)
+{
+  pthread_t thread = pthread_self();
+  EXPECT_FALSE(setFiFoScheduling(thread, 999));
+}
+
+TEST(TestHelpers, setFiFoScheduling_invalidHandle)
+{
+#ifdef _WIN32
+  pthread_t thread = nullptr;
+  EXPECT_FALSE(setFiFoScheduling(thread, THREAD_PRIORITY_NORMAL));
+#else
+  pthread_t thread{};
+  EXPECT_FALSE(setFiFoScheduling(thread, 50));
+#endif
+}
+
+TEST(TestHelpers, setFiFoScheduling_maxPriority)
+{
+  pthread_t thread = pthread_self();
+  int max_prio = sched_get_priority_max(SCHED_FIFO);
+  EXPECT_TRUE(setFiFoScheduling(thread, max_prio));
+}