utests/src/ut_tdm_buffer.cpp

   1 #include "gtest/gtest.h"
   2 #include "ut_common.h"
   3 #include "stdint.h"
   4
   5 extern "C" {
   6 #include "tdm.h"
   7 #include "tdm_backend.h"
   8 #include "tbm_bufmgr.h"
   9 #include "tbm_surface.h"
  10 #include "tbm_surface_internal.h"
  11 #include "tbm_drm_helper.h"
  12 }
  13
  14 class TDMBuffer: public ::testing::Test
  15 {
  16 protected:
  17         static tbm_bufmgr tbm_bufmgr_s;
  18         static int master_fd;
  19
  20         tbm_surface_h surface;
  21
  22         tdm_error error;
  23
  24         static void SetEnv(void)
  25         {
  26                 setenv("TDM_DEBUG_MODULE", "all", 1);
  27                 setenv("TDM_DEBUG", "1", 1);
  28                 setenv("TDM_THREAD", "0", 1);
  29                 setenv("XDG_RUNTIME_DIR", "/run", 1);
  30                 setenv("TBM_DISPLAY_SERVER", "1", 1);
  31         }
  32
  33         static void UnsetEnv(void)
  34         {
  35                 unsetenv("TDM_DEBUG_MODULE");
  36                 unsetenv("TDM_DEBUG");
  37                 unsetenv("TDM_THREAD");
  38                 unsetenv("XDG_RUNTIME_DIR");
  39                 unsetenv("TBM_DISPLAY_SERVER");
  40         }
  41
  42         static void SetUpTestCase()
  43         {
  44                 SetEnv();
  45                 tbm_bufmgr_s = tbm_bufmgr_init(-1);
  46                 ASSERT_FALSE(tbm_bufmgr_s == NULL);
  47                 master_fd = tbm_drm_helper_get_master_fd();
  48         }
  49
  50         static void TearDownTestCase()
  51         {
  52                 tbm_bufmgr_deinit(tbm_bufmgr_s);
  53                 tbm_bufmgr_s = NULL;
  54
  55                 if (master_fd > -1) {
  56                         int temp_master_fd = tbm_drm_helper_get_master_fd();
  57                         EXPECT_EQ(temp_master_fd, -1) << "Fatal Error. Can't deinit tdm/tbm" << std::endl;
  58                         if (temp_master_fd > -1)
  59                                 exit(1);
  60                         close(master_fd);
  61                 }
  62
  63                 UnsetEnv();
  64         }
  65         void SetUp()
  66         {
  67                 surface = tbm_surface_create(256, 256, TBM_FORMAT_ARGB8888);
  68                 ASSERT_TRUE(surface != NULL);
  69         }
  70         void TearDown()
  71         {
  72                 if (surface) {
  73                         while (tbm_surface_internal_is_valid(surface))
  74                                 tbm_surface_destroy(surface);
  75                 }
  76         }
  77 };
  78
  79 tbm_bufmgr TDMBuffer::tbm_bufmgr_s = NULL;
  80 int TDMBuffer::master_fd = -42;
  81
  82
  83 static int handler_is_called = 0;
  84 static void release_handler(tbm_surface_h buffer, void *user_data)
  85 {
  86         if (user_data == &handler_is_called)
  87                 handler_is_called = 1;
  88 }
  89 static void destroy_handler(tbm_surface_h buffer, void *user_data)
  90 {
  91         if (user_data == &handler_is_called)
  92                 handler_is_called = 1;
  93 }
  94
  95 /* tbm_surface_h tdm_buffer_ref_backend(tbm_surface_h buffer) */
  96 TEST_F(TDMBuffer, RefFailNULL)
  97 {
  98         tbm_surface_h buffer = NULL;
  99
 100         buffer = tdm_buffer_ref_backend(NULL);
 101         ASSERT_EQ(NULL, buffer);
 102 }
 103
 104 TEST_F(TDMBuffer, RefSuccessful)
 105 {
 106         tbm_surface_h buffer = NULL;
 107
 108         buffer = tdm_buffer_ref_backend(surface);
 109         ASSERT_EQ(buffer, surface);
 110
 111         buffer = tdm_buffer_ref_backend(surface);
 112         ASSERT_EQ(buffer, surface);
 113
 114 }
 115
 116 /* void tdm_buffer_unref_backend(tbm_surface_h buffer) */
 117 TEST_F(TDMBuffer, UnrefFailNULL)
 118 {
 119         tdm_buffer_unref_backend(NULL);
 120 }
 121
 122 TEST_F(TDMBuffer, UnrefSuccessfulTwoRefUnref)
 123 {
 124         tbm_surface_h buffer = NULL;
 125
 126         buffer = tdm_buffer_ref_backend(surface);
 127         ASSERT_EQ(buffer, surface);
 128         buffer = tdm_buffer_ref_backend(surface);
 129         ASSERT_EQ(buffer, surface);
 130
 131         // first unref
 132         tdm_buffer_unref_backend(surface);
 133         ASSERT_TRUE(tbm_surface_internal_is_valid(surface));
 134
 135         // second unref
 136         tdm_buffer_unref_backend(surface);
 137         ASSERT_TRUE(tbm_surface_internal_is_valid(surface));
 138 }
 139
 140 TEST_F(TDMBuffer, UnrefSuccessfulWithoutRef)
 141 {
 142         tdm_buffer_unref_backend(surface);
 143         ASSERT_FALSE(tbm_surface_internal_is_valid(surface));
 144 }
 145
 146 TEST_F(TDMBuffer, UnrefSuccessfulOneRefTwoUnref)
 147 {
 148         tbm_surface_h buffer = NULL;
 149
 150         buffer = tdm_buffer_ref_backend(surface);
 151         ASSERT_EQ(buffer, surface);
 152
 153         tdm_buffer_unref_backend(surface);
 154         ASSERT_TRUE(tbm_surface_internal_is_valid(surface));
 155
 156         tdm_buffer_unref_backend(surface);
 157         ASSERT_FALSE(tbm_surface_internal_is_valid(surface));
 158 }
 159
 160 /* tdm_error tdm_buffer_add_release_handler(tbm_surface_h buffer, tdm_buffer_release_handler func, void *user_data) */
 161 TEST_F(TDMBuffer, AddReleaseHandlerFailNULL)
 162 {
 163         error = tdm_buffer_add_release_handler(NULL, release_handler, &handler_is_called);
 164         ASSERT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
 165
 166         error = tdm_buffer_add_release_handler(surface, NULL, &handler_is_called);
 167         ASSERT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
 168 }
 169
 170 TEST_F(TDMBuffer, AddReleaseHandlerSuccessful)
 171 {
 172         error = tdm_buffer_add_release_handler(surface, release_handler, &handler_is_called);
 173         ASSERT_EQ(TDM_ERROR_NONE, error);
 174
 175         handler_is_called = 0;
 176         tdm_buffer_unref_backend(surface);
 177         ASSERT_TRUE(handler_is_called);
 178 }
 179
 180
 181 /* void tdm_buffer_remove_release_handler(tbm_surface_h buffer, tdm_buffer_release_handler func, void *user_data) */
 182 TEST_F(TDMBuffer, RemoveReleaseHandlerFailNULL)
 183 {
 184         tdm_buffer_remove_release_handler(NULL, release_handler, &handler_is_called);
 185
 186         tdm_buffer_remove_release_handler(surface, NULL, &handler_is_called);
 187 }
 188
 189 TEST_F(TDMBuffer, RemoveReleaseHandlerFailWithoutAdd)
 190 {
 191         tdm_buffer_remove_release_handler(surface, release_handler, &handler_is_called);
 192 }
 193
 194 TEST_F(TDMBuffer, RemoveReleaseHandlerSuccessful)
 195 {
 196         error = tdm_buffer_add_release_handler(surface, release_handler, &handler_is_called);
 197         ASSERT_EQ(TDM_ERROR_NONE, error);
 198
 199         tdm_buffer_remove_release_handler(surface, release_handler, &handler_is_called);
 200
 201         handler_is_called = 0;
 202         tdm_buffer_unref_backend(surface);
 203         ASSERT_FALSE(handler_is_called);
 204 }
 205
 206 /* tdm_error tdm_buffer_add_destroy_handler(tbm_surface_h buffer, tdm_buffer_destroy_handler func, void *user_data) */
 207 TEST_F(TDMBuffer, AddDestroyHandlerFailNULL)
 208 {
 209         error = tdm_buffer_add_destroy_handler(NULL, destroy_handler, &handler_is_called);
 210         ASSERT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
 211
 212         error = tdm_buffer_add_destroy_handler(surface, NULL, &handler_is_called);
 213         ASSERT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
 214 }
 215
 216 TEST_F(TDMBuffer, AddDestroyHandlerSuccessful)
 217 {
 218         error = tdm_buffer_add_destroy_handler(surface, destroy_handler, &handler_is_called);
 219         ASSERT_EQ(TDM_ERROR_NONE, error);
 220
 221         handler_is_called = 0;
 222         tbm_surface_internal_unref(surface);
 223         ASSERT_TRUE(handler_is_called);
 224         surface = NULL;
 225 }
 226
 227 /* void tdm_buffer_remove_destroy_handler() */
 228 TEST_F(TDMBuffer, RemoveDestroyHandlerFailNULL)
 229 {
 230         tdm_buffer_remove_destroy_handler(NULL, release_handler, &handler_is_called);
 231
 232         tdm_buffer_remove_destroy_handler(surface, NULL, &handler_is_called);
 233 }
 234
 235 TEST_F(TDMBuffer, RemoveDestroyHandlerFailWithoutAdd)
 236 {
 237         tdm_buffer_remove_destroy_handler(surface, release_handler, &handler_is_called);
 238 }
 239
 240 TEST_F(TDMBuffer, RemoveDestroyHandlerSuccessful)
 241 {
 242         error = tdm_buffer_add_destroy_handler(surface, release_handler, &handler_is_called);
 243         ASSERT_EQ(TDM_ERROR_NONE, error);
 244
 245         tdm_buffer_remove_destroy_handler(surface, release_handler, &handler_is_called);
 246
 247         handler_is_called = 0;
 248         tbm_surface_internal_unref(surface);
 249         ASSERT_FALSE(handler_is_called);
 250 }
 251