Initial import of libdpf.

Co-authored-by: Cursor <cursoragent@cursor.com>

thirdparty/portable-snippets/tests/clock.c

@@ -0,0 +1,175 @@
+#define _POSIX_C_SOURCE 199309L
+
+#include "../exact-int/exact-int.h"
+#include "../clock/clock.h"
+#include "munit/munit.h"
+
+/* These tests can yield false positives in some situations, but I'm
+ * having trouble thinking of better ways to test.  Ideas welcome. */
+
+#if !defined(_WIN32)
+#  include <unistd.h>
+#  define sleep_seconds(n) sleep(n)
+#else
+#  include <Windows.h>
+#  define sleep_seconds(n) Sleep((n) * 1000)
+#endif
+
+static MunitResult
+test_clock_wall_time(const MunitParameter params[], void* data) {
+#if defined(PSNIP_CLOCK_WALL_METHOD)
+  struct PsnipClockTimespec res;
+  psnip_uint32_t precision = psnip_clock_get_precision(PSNIP_CLOCK_TYPE_WALL);
+  time_t t;
+  int r;
+
+  (void) params;
+  (void) data;
+
+  munit_logf(MUNIT_LOG_DEBUG, "Wall clock method: %d", PSNIP_CLOCK_WALL_METHOD);
+
+  munit_assert_uint32(precision, !=, 0);
+
+  t = time(NULL);
+  /* This test may fail if more than 1 second passes here, but this
+   * thread could conceivably be preempted for longer. */
+  r = psnip_clock_get_time(PSNIP_CLOCK_TYPE_WALL, &res);
+  munit_assert_int(r, ==, 0);
+
+  munit_assert_uint64(t, <=, res.seconds);
+  munit_assert_uint64(t, >=, res.seconds - 1);
+
+  return MUNIT_OK;
+#else
+  (void) params;
+  (void) data;
+
+  return MUNIT_SKIP;
+#endif
+}
+
+static int ts_difference(struct PsnipClockTimespec* earlier, struct PsnipClockTimespec* later) {
+  return
+    (int) ((later->seconds - earlier->seconds) * 1000) +
+    (int) ((((psnip_int64_t) later->nanoseconds) - ((psnip_int64_t) earlier->nanoseconds)) / 1000000);
+}
+
+static MunitResult
+test_clock_wall_veracity(const MunitParameter params[], void* data) {
+#if defined(PSNIP_CLOCK_WALL_METHOD)
+  struct PsnipClockTimespec res1, res2;
+  int elapsed_ms;
+  int r;
+
+  r = psnip_clock_get_time(PSNIP_CLOCK_TYPE_WALL, &res1);
+  munit_assert_int(r, ==, 0);
+
+  /* Assuming we aren't interrupted by a signal, aren't suspended for
+   * much more than 1 seconds, etc. */
+  sleep_seconds(1);
+
+  r = psnip_clock_get_time(PSNIP_CLOCK_TYPE_WALL, &res2);
+  munit_assert_int(r, ==, 0);
+
+  elapsed_ms = ts_difference(&res1, &res2);
+
+  munit_assert_int(elapsed_ms, >,  900);
+  munit_assert_int(elapsed_ms, <, 1100);
+
+  (void) params;
+  (void) data;
+
+  return MUNIT_OK;
+#else
+  (void) params;
+  (void) data;
+
+  return MUNIT_SKIP;
+#endif
+}
+
+static MunitResult
+test_clock_cpu(const MunitParameter params[], void* data) {
+#if defined(PSNIP_CLOCK_CPU_METHOD)
+  struct PsnipClockTimespec res1, res2;
+  psnip_uint32_t precision = psnip_clock_get_precision(PSNIP_CLOCK_TYPE_WALL);
+  int r;
+  int elapsed_ms;
+
+  munit_logf(MUNIT_LOG_DEBUG, "CPU clock method: %d", PSNIP_CLOCK_CPU_METHOD);
+
+  munit_assert_uint32(precision, !=, 0);
+
+  r = psnip_clock_get_time(PSNIP_CLOCK_TYPE_WALL, &res1);
+  munit_assert_int(r, ==, 0);
+
+  sleep_seconds(1);
+
+  r = psnip_clock_get_time(PSNIP_CLOCK_TYPE_WALL, &res2);
+  munit_assert_int(r, ==, 0);
+
+  elapsed_ms = ts_difference(&res1, &res2);
+
+  munit_assert_int(elapsed_ms, >=, 1000);
+  if (precision >= 1000)
+    munit_assert_int(elapsed_ms, <=, 1100);
+
+  (void) params;
+  (void) data;
+
+  return MUNIT_OK;
+#else
+  (void) params;
+  (void) data;
+
+  return MUNIT_SKIP;
+#endif
+}
+
+static MunitResult
+test_clock_monotonic(const MunitParameter params[], void* data) {
+
+#if defined(PSNIP_CLOCK_MONOTONIC_METHOD)
+  struct PsnipClockTimespec res1, res2;
+  int r;
+  int elapsed_ms;
+
+  r = psnip_clock_get_time(PSNIP_CLOCK_TYPE_MONOTONIC, &res1);
+  munit_assert_int(r, ==, 0);
+
+  /* Assuming we aren't interrupted by a signal, aren't suspended for
+   * much more than 2 seconds, etc. */
+  sleep_seconds(1);
+
+  r = psnip_clock_get_time(PSNIP_CLOCK_TYPE_MONOTONIC, &res2);
+  munit_assert_int(r, ==, 0);
+
+  elapsed_ms = ts_difference(&res1, &res2);
+
+  munit_assert_int(elapsed_ms, >,  900);
+  munit_assert_int(elapsed_ms, <, 1100);
+
+  (void) params;
+  (void) data;
+
+  return MUNIT_OK;
+#else
+  return MUNIT_SKIP;
+#endif
+}
+
+static MunitTest test_suite_tests[] = {
+  { (char*) "/clock/wall/time",     test_clock_wall_time,     NULL, NULL, MUNIT_TEST_OPTION_SINGLE_ITERATION, NULL },
+  { (char*) "/clock/wall/veracity", test_clock_wall_veracity, NULL, NULL, MUNIT_TEST_OPTION_SINGLE_ITERATION, NULL },
+  { (char*) "/clock/cpu",           test_clock_cpu,           NULL, NULL, MUNIT_TEST_OPTION_SINGLE_ITERATION, NULL },
+  { (char*) "/clock/monotonic",     test_clock_monotonic,     NULL, NULL, MUNIT_TEST_OPTION_SINGLE_ITERATION, NULL },
+  { NULL, NULL, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL }
+};
+
+static const MunitSuite test_suite = {
+  (char*) "", test_suite_tests, NULL, 16384, MUNIT_SUITE_OPTION_NONE
+};
+
+int main(int argc, char* argv[MUNIT_ARRAY_PARAM(argc + 1)]) {
+  return munit_suite_main(&test_suite, NULL, argc, argv);
+}