utests/src/ut_tdm_buffer.cpp

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