utests/src/ut_tdm_event_loop.cpp

   1 #include "gtest/gtest.h"
   2 #include "ut_common.h"
   3 #include "stdint.h"
   4 #include "fcntl.h"
   5
   6 extern "C" {
   7 #include "tdm.h"
   8 #include "tdm_backend.h"
   9 #include "tbm_bufmgr.h"
  10 #include "tbm_surface.h"
  11 #include "tbm_surface_internal.h"
  12 #include "tbm_drm_helper.h"
  13 }
  14
  15 class TDMEventLoop: public ::testing::Test
  16 {
  17 protected:
  18         static tdm_display *dpy;
  19         tdm_error error;
  20         tdm_event_loop_source *loop_src;
  21         int fd;
  22
  23         static void SetEnv(void)
  24         {
  25                 setenv("TDM_DEBUG_MODULE", "all", 1);
  26                 setenv("TDM_DEBUG", "1", 1);
  27                 setenv("TDM_THREAD", "0", 1);
  28                 setenv("XDG_RUNTIME_DIR", "/run", 1);
  29                 setenv("TBM_DISPLAY_SERVER", "1", 1);
  30         }
  31
  32         static void UnsetEnv(void)
  33         {
  34                 unsetenv("TDM_DEBUG_MODULE");
  35                 unsetenv("TDM_DEBUG");
  36                 unsetenv("TDM_THREAD");
  37                 unsetenv("XDG_RUNTIME_DIR");
  38                 unsetenv("TBM_DISPLAY_SERVER");
  39         }
  40
  41         static void SetUpTestCase()
  42         {
  43                 tdm_error error;
  44                 SetEnv();
  45                 dpy = tdm_display_init(&error);
  46                 ASSERT_NE(NULL, dpy);
  47                 ASSERT_EQ(TDM_ERROR_NONE, error);
  48         }
  49
  50         static void TearDownTestCase()
  51         {
  52                 tdm_display_deinit(dpy);
  53                 UnsetEnv();
  54         }
  55
  56         int GetFd()
  57         {
  58                 if (fd == -1)
  59                         fd = tbm_drm_helper_get_master_fd();
  60                 return fd;
  61         }
  62
  63         void SetUp()
  64         {
  65                 loop_src = NULL;
  66                 fd = -1;
  67         }
  68
  69         void TearDown()
  70         {
  71                 if (loop_src)
  72                         tdm_event_loop_source_remove(loop_src);
  73                 if (fd >= 0)
  74                         close(fd);
  75         }
  76 };
  77
  78 tdm_display *TDMEventLoop::dpy = NULL;
  79
  80 static int handler_is_called = 0;
  81 static tdm_error timer_handler(void *user_data)
  82 {
  83         if (user_data == &handler_is_called)
  84                 handler_is_called = 1;
  85         return TDM_ERROR_NONE;
  86 }
  87
  88 static tdm_error fd_handler(int fd, tdm_event_loop_mask mask, void *user_data)
  89 {
  90         if (user_data == &handler_is_called)
  91                 handler_is_called = 1;
  92         return TDM_ERROR_NONE;
  93 }
  94
  95 /*void tdm_event_loop_source_remove(tdm_event_loop_source *source); */
  96 TEST_F(TDMEventLoop, SourceRemoveFailNULL)
  97 {
  98         tdm_event_loop_source_remove(NULL);
  99 }
 100
 101 /* tdm_event_loop_source* tdm_event_loop_add_timer_handler(tdm_display *dpy,
 102                                                                         tdm_event_loop_timer_handler func,
 103                                                                         void *user_data, tdm_error *error); */
 104 TEST_F(TDMEventLoop, AddTimerHandlerFailNULL)
 105 {
 106         loop_src = tdm_event_loop_add_timer_handler(NULL, timer_handler, &handler_is_called, &error);
 107         ASSERT_NE(TDM_ERROR_NONE, error);
 108         ASSERT_EQ(NULL, loop_src);
 109
 110         loop_src = tdm_event_loop_add_timer_handler(dpy, NULL, &handler_is_called, &error);
 111         ASSERT_NE(TDM_ERROR_NONE, error);
 112         ASSERT_EQ(NULL, loop_src);
 113
 114         loop_src = tdm_event_loop_add_timer_handler(dpy, NULL, &handler_is_called, NULL);
 115         ASSERT_EQ(NULL, loop_src);
 116 }
 117
 118 TEST_F(TDMEventLoop, AddTimerHandlerSuccessful)
 119 {
 120         loop_src = tdm_event_loop_add_timer_handler(dpy, timer_handler, &handler_is_called, &error);
 121         ASSERT_EQ(TDM_ERROR_NONE, error);
 122         ASSERT_NE(NULL, loop_src);
 123 }
 124
 125 /* tdm_error tdm_event_loop_source_timer_update(tdm_event_loop_source *source, unsigned int ms_delay); */
 126 TEST_F(TDMEventLoop, SourceTimerUpdateFailNULL)
 127 {
 128         error = tdm_event_loop_source_timer_update(NULL, 0);
 129         ASSERT_NE(TDM_ERROR_NONE, error);
 130 }
 131 TEST_F(TDMEventLoop, SourceTimerUpdateSuccessful)
 132 {
 133         loop_src = tdm_event_loop_add_timer_handler(dpy, timer_handler, &handler_is_called, &error);
 134         ASSERT_EQ(TDM_ERROR_NONE, error);
 135         ASSERT_NE(NULL, loop_src);
 136
 137         error = tdm_event_loop_source_timer_update(loop_src, 10);
 138         ASSERT_EQ(TDM_ERROR_NONE, error);
 139 }
 140
 141 /* tdm_event_loop_source* tdm_event_loop_add_fd_handler(tdm_display *dpy, int fd, tdm_event_loop_mask mask,
 142                                                           tdm_event_loop_fd_handler func, void *user_data,
 143                                                           tdm_error *error); */
 144 TEST_F(TDMEventLoop, AddFdHandlerFailNULL)
 145 {
 146         loop_src = tdm_event_loop_add_fd_handler(NULL, 0, TDM_EVENT_LOOP_READABLE,
 147                                                                                         fd_handler, &handler_is_called, &error);
 148         ASSERT_EQ(NULL, loop_src);
 149         ASSERT_NE(TDM_ERROR_NONE, error);
 150
 151         loop_src = tdm_event_loop_add_fd_handler(dpy, 0, TDM_EVENT_LOOP_READABLE,
 152                                                                                         NULL, &handler_is_called, &error);
 153         ASSERT_NE(TDM_ERROR_NONE, error);
 154         ASSERT_EQ(NULL, loop_src);
 155 }
 156
 157 TEST_F(TDMEventLoop, AddFdHandlerFailInvalidFd)
 158 {
 159         loop_src = tdm_event_loop_add_fd_handler(dpy, -1, TDM_EVENT_LOOP_READABLE,
 160                                                                                         fd_handler, &handler_is_called, &error);
 161         ASSERT_NE(TDM_ERROR_NONE, error);
 162         ASSERT_EQ(NULL, loop_src);
 163 }
 164
 165 TEST_F(TDMEventLoop, AddFdHandlerSuccessful)
 166 {
 167         int fd = GetFd();
 168         ASSERT_NE(-1, fd);
 169
 170         loop_src = tdm_event_loop_add_fd_handler(dpy, fd, TDM_EVENT_LOOP_READABLE,
 171                                                                                         fd_handler, &handler_is_called, &error);
 172         ASSERT_EQ(TDM_ERROR_NONE, error);
 173         ASSERT_NE(NULL, loop_src);
 174 }
 175
 176 /* tdm_error tdm_event_loop_source_fd_update(tdm_event_loop_source *source, tdm_event_loop_mask mask); */
 177 TEST_F(TDMEventLoop, SourceFdUpdateFailNULL)
 178 {
 179         error = tdm_event_loop_source_fd_update(NULL, TDM_EVENT_LOOP_READABLE);
 180 }
 181
 182 TEST_F(TDMEventLoop, SourceFdUpdateSuccessful)
 183 {
 184         int fd;
 185         tdm_event_loop_mask flag = TDM_EVENT_LOOP_WRITABLE;
 186
 187         fd = GetFd();
 188         ASSERT_NE(-1, fd);
 189
 190         loop_src = tdm_event_loop_add_fd_handler(dpy, fd, flag,
 191                                                                                         fd_handler, &handler_is_called, &error);
 192         ASSERT_EQ(TDM_ERROR_NONE, error);
 193         ASSERT_NE(NULL, loop_src);
 194
 195         error = tdm_event_loop_source_fd_update(loop_src, TDM_EVENT_LOOP_READABLE);
 196         ASSERT_EQ(TDM_ERROR_NONE, error);
 197 }
 198