haltests/tc_tbm_surface.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
   4  *
   5  * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
   6  * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
   7  * Contact: Roman Marchenko <r.marchenko@samsung.com>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sub license, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice (including the
  18  * next paragraph) shall be included in all copies or substantial portions
  19  * of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  24  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  25  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  26  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  27  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28  *
  29 **************************************************************************/
  30
  31 #include "tc_tbm.h"
  32
  33 /* The tbm_surface.h contains the public APIs. Therefore, the error values has TBM_SURFACE_ prefix,
  34  * but the values of the TBM_SURFACE_ prefix error types has the same vaules as TBM_ERROR_ prefix types.
  35  * We check the two error types in this TBMSurface testcase.
  36  */
  37
  38 class TBMSurface : public TBMBufmgr
  39 {
  40 protected:
  41         void SetUp();
  42         void TearDown();
  43 public:
  44         uint32_t num_formats;
  45         tbm_format *formats;
  46         tbm_format format;
  47
  48         int width, height;
  49         tbm_surface_h surface;
  50 };
  51
  52 void TBMSurface::SetUp()
  53 {
  54         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
  55
  56         TBMBufmgr::SetUp();
  57
  58         result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, &num_formats);
  59         ASSERT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_NONE));
  60         ASSERT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
  61
  62         for (uint32_t i = 0; i < num_formats; i++)
  63                 if (formats[i] == TBM_FORMAT_ARGB8888)
  64                         format = TBM_FORMAT_ARGB8888;
  65
  66         /* fail if there is no TBM_FORMAT_ARGB8888 format */
  67         ASSERT_TRUE(format == TBM_FORMAT_ARGB8888);
  68
  69         width = 720;
  70         height = 1024;
  71         surface = tbm_surface_internal_create_with_flags(width, height, format, TBM_BO_DEFAULT);
  72         ASSERT_TRUE(surface != NULL);
  73         ASSERT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
  74         ASSERT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
  75 }
  76
  77 void TBMSurface::TearDown()
  78 {
  79         if (surface)
  80                 tbm_surface_internal_destroy(surface);
  81         ASSERT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
  82         ASSERT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
  83
  84         if (formats)
  85                 free(formats);
  86
  87         TBMBufmgr::TearDown();
  88 }
  89
  90 static int memory_for_invalid_param;
  91 static tbm_surface_h invalid_surface = (tbm_surface_h)&memory_for_invalid_param;
  92
  93 TEST_F(TBMSurface, SurfaceCeateFailInvalidGeometry)
  94 {
  95         tbm_surface_h surf1 = NULL;
  96
  97         surf1 = tbm_surface_create(-1, 1024, TBM_FORMAT_ARGB8888);
  98         EXPECT_EQ(nullptr, surf1); // Expected Value: NULL
  99         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 100         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 101
 102         surf1 = tbm_surface_create(720, -1, TBM_FORMAT_ARGB8888);
 103         EXPECT_EQ(nullptr, surf1);
 104         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 105         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 106
 107         surf1 = tbm_surface_create(720, 1024, 0);
 108         EXPECT_EQ(nullptr, surf1);
 109         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 110         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 111 }
 112
 113 TEST_F(TBMSurface, SurfaceCeateSuccess)
 114 {
 115         tbm_surface_h surf1 = NULL;
 116         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 117
 118         for (uint32_t i = 0; i < num_formats; i++) {
 119                 surf1 = tbm_surface_create(720, 1024, formats[i]);
 120                 EXPECT_NE((tbm_surface_h)NULL, surf1);
 121                 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
 122                 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 123                 result = (tbm_surface_error_e)tbm_surface_destroy(surf1);
 124                 EXPECT_EQ(TBM_SURFACE_ERROR_NONE, result);
 125                 EXPECT_EQ(TBM_ERROR_NONE, result);
 126         }
 127 }
 128
 129 TEST_F(TBMSurface, SurfaceGetFormatFailInvalidInput)
 130 {
 131         tbm_format fmt = tbm_surface_get_format(invalid_surface);
 132         EXPECT_EQ(0, fmt);
 133         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 134         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 135 }
 136
 137 TEST_F(TBMSurface, SurfaceGetFormatFailNull)
 138 {
 139         tbm_format fmt = tbm_surface_get_format(NULL);
 140         EXPECT_EQ(0, fmt);
 141         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 142         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 143 }
 144
 145 TEST_F(TBMSurface, SurfaceGetFormatSuccess)
 146 {
 147         tbm_format fmt = tbm_surface_get_format(surface);
 148         EXPECT_EQ(this->format, fmt);
 149         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
 150         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 151 }
 152
 153 TEST_F(TBMSurface, SurfaceGetWidthFailInvalidInput)
 154 {
 155         int width = tbm_surface_get_width(invalid_surface);
 156         EXPECT_EQ(width, TBM_SURFACE_ERROR_INVALID_PARAMETER);
 157         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 158         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 159 }
 160
 161 TEST_F(TBMSurface, SurfaceGetWidthFailNull)
 162 {
 163         int width = tbm_surface_get_width(NULL);
 164         EXPECT_EQ(width, TBM_SURFACE_ERROR_INVALID_PARAMETER);
 165         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 166         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 167 }
 168
 169 TEST_F(TBMSurface, SurfaceGetWidthSuccess)
 170 {
 171         int width = tbm_surface_get_width(surface);
 172         EXPECT_EQ(this->width, width);
 173         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
 174         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 175 }
 176
 177 TEST_F(TBMSurface, SurfaceGetHeightFailInvalidInput)
 178 {
 179         int height = tbm_surface_get_height(invalid_surface);
 180         EXPECT_EQ(height, TBM_SURFACE_ERROR_INVALID_PARAMETER);
 181         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 182         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 183 }
 184
 185 TEST_F(TBMSurface, SurfaceGetHeightFailNull)
 186 {
 187         int height = tbm_surface_get_height(NULL);
 188         EXPECT_EQ(height, TBM_SURFACE_ERROR_INVALID_PARAMETER);
 189         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 190         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 191 }
 192
 193 TEST_F(TBMSurface, SurfaceGetHeightSuccess)
 194 {
 195         int height = tbm_surface_get_height(surface);
 196         EXPECT_EQ(this->height, height);
 197         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
 198         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 199 }
 200
 201 TEST_F(TBMSurface, SurfaceGetInfoInvalidInput)
 202 {
 203         tbm_surface_info_s info;
 204         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 205
 206         result = (tbm_surface_error_e)tbm_surface_get_info(invalid_surface, &info);
 207         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 208         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 209 }
 210
 211 TEST_F(TBMSurface, SurfaceGetInfoFailNull)
 212 {
 213         tbm_surface_info_s info;
 214         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 215
 216         result = (tbm_surface_error_e)tbm_surface_get_info(surface, NULL);
 217         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 218         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 219
 220         result = (tbm_surface_error_e)tbm_surface_get_info(NULL, &info);
 221         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 222         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 223
 224         result = (tbm_surface_error_e)tbm_surface_get_info(NULL, NULL);
 225         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 226         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 227 }
 228
 229 TEST_F(TBMSurface, SurfaceGetInfoSuccess)
 230 {
 231         tbm_surface_info_s info;
 232         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 233
 234         result = (tbm_surface_error_e)tbm_surface_get_info(surface, &info);
 235         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_NONE));
 236         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
 237         EXPECT_EQ(this->format, info.format);
 238         EXPECT_EQ(this->height, info.height);
 239         EXPECT_EQ(this->width, info.width);
 240         EXPECT_GT(info.num_planes, 0);
 241         EXPECT_GT(info.bpp, 0);
 242         EXPECT_GT(info.size, 0);
 243 }
 244
 245 TEST_F(TBMSurface, SurfaceMapFailInvalidInput)
 246 {
 247         tbm_surface_info_s info;
 248         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 249
 250         result = (tbm_surface_error_e)tbm_surface_map(invalid_surface, 0, &info);
 251         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 252         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 253 }
 254
 255 TEST_F(TBMSurface, SurfaceMapFailNull)
 256 {
 257         tbm_surface_info_s info;
 258         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 259
 260         result = (tbm_surface_error_e)tbm_surface_map(surface, 0, NULL);
 261         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 262         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 263
 264         result = (tbm_surface_error_e)tbm_surface_map(NULL, 0, &info);
 265         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 266         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 267 }
 268
 269 TEST_F(TBMSurface, SurfaceMapSuccess)
 270 {
 271         tbm_surface_info_s info;
 272         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 273
 274         result = (tbm_surface_error_e)tbm_surface_map(surface, 0, &info);
 275         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_NONE));
 276         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
 277         EXPECT_EQ(this->format, info.format);
 278         EXPECT_EQ(this->height, info.height);
 279         EXPECT_EQ(this->width, info.width);
 280         EXPECT_GT(info.num_planes, 0);
 281         EXPECT_GT(info.bpp, 0);
 282         EXPECT_GT(info.size, 0);
 283
 284         result = (tbm_surface_error_e)tbm_surface_unmap(surface);
 285         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_NONE));
 286         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
 287 }
 288
 289 TEST_F(TBMSurface, SurfaceUnmapFailInvalidInput)
 290 {
 291         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 292         result = (tbm_surface_error_e)tbm_surface_unmap(invalid_surface);
 293         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 294         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 295 }
 296
 297 TEST_F(TBMSurface, SurfaceUnmapFailNull)
 298 {
 299         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 300
 301         result = (tbm_surface_error_e)tbm_surface_unmap(NULL);
 302         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
 303         EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 304 }
 305