tests/work_interval_test.c

   1 /* test that the header doesn't implicitly depend on others */
   2 #include <sys/work_interval.h>
   3
   4 #include <stdlib.h>
   5 #include <stdio.h>
   6 #include <unistd.h>
   7 #include <errno.h>
   8 #include <err.h>
   9 #include <string.h>
  10 #include <pthread.h>
  11
  12 #include <mach/mach.h>
  13
  14 #include <darwintest.h>
  15
  16 T_GLOBAL_META(T_META_NAMESPACE("xnu.scheduler"));
  17
  18 static mach_port_t port = MACH_PORT_NULL;
  19
  20 static void *
  21 joining_thread_fn(__unused void *arg)
  22 {
  23         int ret = 0;
  24         kern_return_t kr = KERN_SUCCESS;
  25
  26         ret = work_interval_join_port(port);
  27         T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, another thread");
  28
  29         kr = mach_port_deallocate(mach_task_self(), port);
  30         T_ASSERT_MACH_SUCCESS(kr, "mach_port_deallocate of port, another thread");
  31
  32         /* deliberately exit with joined work interval */
  33         return NULL;
  34 }
  35
  36 T_DECL(work_interval, "work interval interface")
  37 {
  38         int ret = 0;
  39         work_interval_t handle = NULL;
  40         uint64_t now = mach_absolute_time();
  41         kern_return_t kr = KERN_SUCCESS;
  42
  43         ret = work_interval_create(NULL, 0);
  44         T_ASSERT_EQ(errno, EINVAL, "create with null errno EINVAL");
  45         T_ASSERT_EQ(ret, -1, "create with null returns -1");
  46
  47         /* Binary must be entitled for this to succeed */
  48         ret = work_interval_create(&handle, 0);
  49         T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, no flags");
  50
  51         ret = work_interval_copy_port(handle, &port);
  52         T_ASSERT_EQ(errno, EINVAL, "work_interval_copy_port on non-joinable interval errno EINVAL");
  53         T_ASSERT_EQ(ret, -1, "work_interval_copy_port on non-joinable interval returns -1");
  54
  55         ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
  56         T_ASSERT_POSIX_SUCCESS(ret, "work_interval_notify, no flags");
  57
  58         ret = work_interval_destroy(handle);
  59         T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy, no flags");
  60
  61         uint32_t flags[] = {
  62                 WORK_INTERVAL_FLAG_JOINABLE,
  63                 WORK_INTERVAL_FLAG_JOINABLE | WORK_INTERVAL_FLAG_GROUP,
  64         };
  65
  66         for (uint32_t i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
  67                 ret = work_interval_create(&handle, flags[i]);
  68                 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, joinable");
  69
  70                 ret = work_interval_copy_port(handle, &port);
  71                 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port, joinable");
  72
  73                 ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
  74                 T_ASSERT_EQ(ret, -1, "work_interval_notify on non-joined thread returns -1");
  75                 T_ASSERT_EQ(errno, EINVAL, "work_interval_copy_port on non-joined thread errno EINVAL");
  76
  77                 ret = work_interval_join_port(port);
  78                 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, joinable");
  79
  80                 ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
  81                 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_notify, on joined thread");
  82
  83                 ret = work_interval_join_port(port);
  84                 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, join the same interval after destroy");
  85
  86                 kr = mach_port_deallocate(mach_task_self(), port);
  87                 T_ASSERT_MACH_SUCCESS(kr, "mach_port_deallocate of port");
  88
  89                 ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
  90                 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_notify, on joined thread after destroy");
  91
  92                 ret = work_interval_destroy(handle);
  93                 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy, joinable, on joined thread");
  94
  95                 ret = work_interval_leave();
  96                 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_leave, on destroyed work interval");
  97         }
  98
  99         ret = work_interval_create(&handle, WORK_INTERVAL_FLAG_JOINABLE | WORK_INTERVAL_FLAG_GROUP);
 100         T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, joinable");
 101
 102         ret = work_interval_copy_port(handle, &port);
 103         T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port, joinable");
 104
 105         ret = work_interval_join_port(port);
 106         T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, join before handing to another thread");
 107
 108         pthread_t joining_thread;
 109
 110         T_ASSERT_POSIX_ZERO(pthread_create(&joining_thread, NULL, joining_thread_fn, NULL), "pthread_create");
 111
 112         T_ASSERT_POSIX_ZERO(pthread_join(joining_thread, NULL), "pthread_join");
 113
 114         ret = work_interval_leave();
 115         T_ASSERT_POSIX_SUCCESS(ret, "work_interval_leave");
 116
 117         ret = work_interval_destroy(handle);
 118         T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy");
 119 }