utests/ut_tbm_surface.cpp

   1 #include <gtest/gtest.h>
   2 #include <stdlib.h>
   3
   4 #include <tbm_bufmgr.h>
   5 #include <tbm_surface.h>
   6 #include "ut.h"
   7
   8 TEST_F(UtInit, SurfaceQueryFormatsFailNull)
   9 {
  10         uint32_t num = 0;
  11         tbm_format *formats = NULL;
  12         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
  13
  14         ut_set_default_tbm_env();
  15
  16         result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, NULL);
  17         ASSERT_NE(TBM_SURFACE_ERROR_NONE, result);
  18
  19         result = (tbm_surface_error_e)tbm_surface_query_formats(NULL, &num);
  20         ASSERT_NE(TBM_SURFACE_ERROR_NONE, result);
  21 }
  22
  23 TEST_F(UtInit, SurfaceQueryFormatSuccess)
  24 {
  25         uint32_t num = 0;
  26         tbm_format *formats = NULL;
  27         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
  28
  29         ut_set_default_tbm_env();
  30
  31         result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, &num);
  32         ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
  33         ASSERT_NE(0, num);
  34         ASSERT_NE((tbm_format *)NULL, formats);
  35         for (uint32_t i = 0; i < num; i++)
  36                 ASSERT_NE(0, formats[i]);
  37         free(formats);
  38 }
  39
  40 TEST_F(UtInit, SurfaceCeateFailInvalidGeometry)
  41 {
  42         tbm_surface_h surface = NULL;
  43
  44         ut_set_default_tbm_env();
  45
  46         surface = tbm_surface_create(-1, 1024, TBM_FORMAT_ARGB8888);
  47         ASSERT_EQ(nullptr, surface); // Expected Value: NULL
  48
  49         surface = tbm_surface_create(720, -1, TBM_FORMAT_ARGB8888);
  50         ASSERT_EQ(nullptr, surface);
  51
  52         surface = tbm_surface_create(720, 1024, 0);
  53         ASSERT_EQ(nullptr, surface);
  54 }
  55
  56 TEST_F(UtInit, SurfaceCeateSuccess)
  57 {
  58         tbm_surface_h surface = NULL;
  59         uint32_t num = 0;
  60         tbm_format *formats = NULL;
  61         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
  62
  63         ut_set_default_tbm_env();
  64
  65         result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, &num);
  66         ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
  67
  68         for (uint32_t i = 0; i < num; i++) {
  69                 surface = tbm_surface_create(720, 1024, formats[i]);
  70                 ASSERT_NE((tbm_surface_h)NULL, surface);
  71                 result = (tbm_surface_error_e)tbm_surface_destroy(surface);
  72                 ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
  73         }
  74 }
  75
  76 TEST_F(SurfaceTest, SurfaceGetFormatFailInvalidInput)
  77 {
  78         tbm_surface_h invalid_surface = (tbm_surface_h)1;
  79         tbm_format fmt = tbm_surface_get_format(invalid_surface);
  80         ASSERT_EQ(0, fmt);
  81 }
  82
  83 TEST_F(SurfaceTest, SurfaceGetFormatFailNull)
  84 {
  85         tbm_format fmt = tbm_surface_get_format(NULL);
  86         ASSERT_EQ(0, fmt);
  87 }
  88
  89 TEST_F(SurfaceTest, SurfaceGetFormatSuccess)
  90 {
  91         tbm_format fmt = tbm_surface_get_format(surface);
  92         ASSERT_EQ(this->format, fmt);
  93 }
  94
  95 TEST_F(SurfaceTest, SurfaceGetWidthFailInvalidInput)
  96 {
  97         tbm_surface_h invalid_surface = (tbm_surface_h)1;
  98         int width = tbm_surface_get_width(invalid_surface);
  99         ASSERT_EQ(0, width);
 100 }
 101
 102 TEST_F(SurfaceTest, SurfaceGetWidthFailNull)
 103 {
 104         int width = tbm_surface_get_width(NULL);
 105         ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_PARAMETER, width);
 106 }
 107
 108 TEST_F(SurfaceTest, SurfaceGetWidthSuccess)
 109 {
 110         int width = tbm_surface_get_width(surface);
 111         ASSERT_EQ(this->width, width);
 112 }
 113
 114 TEST_F(SurfaceTest, SurfaceGetHeightFailInvalidInput)
 115 {
 116         tbm_surface_h invalid_surface = (tbm_surface_h)1;
 117         int height = tbm_surface_get_height(invalid_surface);
 118         ASSERT_EQ(0, height);
 119 }
 120
 121 TEST_F(SurfaceTest, SurfaceGetHeightFailNull)
 122 {
 123         int height = tbm_surface_get_height(NULL);
 124         ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_PARAMETER, height);
 125 }
 126
 127 TEST_F(SurfaceTest, SurfaceGetHeightSuccess)
 128 {
 129         int height = tbm_surface_get_height(surface);
 130         ASSERT_EQ(this->height, height);
 131 }
 132
 133 TEST_F(SurfaceTest, SurfaceGetInfoInvalidInput)
 134 {
 135         tbm_surface_h invalid_surface = (tbm_surface_h)1;
 136         tbm_surface_info_s info;
 137         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 138
 139         result = (tbm_surface_error_e)tbm_surface_get_info(invalid_surface, &info);
 140         ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_OPERATION, result);
 141 }
 142
 143 TEST_F(SurfaceTest, SurfaceGetInfoFailNull)
 144 {
 145         tbm_surface_info_s info;
 146         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 147
 148         result = (tbm_surface_error_e)tbm_surface_get_info(surface, NULL);
 149         ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_PARAMETER, result);
 150
 151         result = (tbm_surface_error_e)tbm_surface_get_info(NULL, &info);
 152         ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_PARAMETER, result);
 153
 154         result = (tbm_surface_error_e)tbm_surface_get_info(NULL, NULL);
 155         ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_PARAMETER, result);
 156 }
 157
 158 TEST_F(SurfaceTest, SurfaceGetInfoSuccess)
 159 {
 160         tbm_surface_info_s info;
 161         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 162
 163         result = (tbm_surface_error_e)tbm_surface_get_info(surface, &info);
 164         ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
 165         ASSERT_EQ(this->format, info.format);
 166         ASSERT_EQ(this->height, info.height);
 167         ASSERT_EQ(this->width, info.width);
 168         ASSERT_GT(info.num_planes, 0);
 169         ASSERT_GT(info.bpp, 0);
 170         ASSERT_GT(info.size, 0);
 171 }
 172
 173 TEST_F(SurfaceTest, SurfaceMapFailInvalidInput)
 174 {
 175         tbm_surface_info_s info;
 176         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 177         tbm_surface_h invalid_surface = (tbm_surface_h)1;
 178
 179         result = (tbm_surface_error_e)tbm_surface_map(invalid_surface, 0, &info);
 180         ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_OPERATION, result);
 181 }
 182
 183 TEST_F(SurfaceTest, SurfaceMapFailNull)
 184 {
 185         tbm_surface_info_s info;
 186         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 187
 188         result = (tbm_surface_error_e)tbm_surface_map(surface, 0, NULL);
 189         ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_PARAMETER, result);
 190
 191         result = (tbm_surface_error_e)tbm_surface_map(NULL, 0, &info);
 192         ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_PARAMETER, result);
 193 }
 194
 195 TEST_F(SurfaceTest, SurfaceMapSuccess)
 196 {
 197         tbm_surface_info_s info;
 198         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 199
 200         result = (tbm_surface_error_e)tbm_surface_map(surface, 0, &info);
 201         ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
 202         ASSERT_EQ(this->format, info.format);
 203         ASSERT_EQ(this->height, info.height);
 204         ASSERT_EQ(this->width, info.width);
 205         ASSERT_GT(info.num_planes, 0);
 206         ASSERT_GT(info.bpp, 0);
 207         ASSERT_GT(info.size, 0);
 208
 209         result = (tbm_surface_error_e)tbm_surface_unmap(surface);
 210         ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
 211 }
 212
 213 TEST_F(SurfaceTest, SurfaceUnmapFailInvalidInput)
 214 {
 215         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 216         tbm_surface_h invalid_surface = (tbm_surface_h)1;
 217         result = (tbm_surface_error_e)tbm_surface_unmap(invalid_surface);
 218         ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
 219 }
 220
 221 TEST_F(SurfaceTest, SurfaceUnmapFailNull)
 222 {
 223         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 224
 225         result = (tbm_surface_error_e)tbm_surface_unmap(NULL);
 226         ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_PARAMETER, result);
 227 }
 228