-#include "gtest/gtest.h"
-#include "ut_tdm.h"
-#include "stdint.h"
-#include <stdio.h>
-#include <ftw.h>
-#include <unistd.h>
-
-extern "C" {
-#include "tdm.h"
-#include "tdm_helper.h"
-#include "tdm_backend.h"
-#include "tbm_bufmgr.h"
-#include "tbm_surface.h"
-#include "tbm_surface_internal.h"
-#include "tbm_drm_helper.h"
-}
-
-#define TMP_PATH_FOR_UTEST "/tmp/tmp_utest_helper"
-#define STR_LEN 8192
-
-class TDMHelper : public ::testing::Test {
-protected:
- tdm_display *dpy = NULL;
- tbm_bufmgr bufmgr = NULL;
- int master_fd = -42;
- /*list of connected outputs*/
- int output_count = 0;
- const tdm_output_mode **preferred_mode_array = NULL;
- tdm_output **outputs;
- tdm_error error ;
- tbm_surface_h surface;
- virtual void SetEnv()
- {
- setenv("TDM_THREAD", "0", 1);
- setenv("TDM_COMMIT_PER_VBLANK", "1", 1);
- setenv("XDG_RUNTIME_DIR", "/run", 1);
- setenv("TBM_DISPLAY_SERVER", "1", 1);
- }
-
- void UnsetEnv()
- {
- unsetenv("TDM_THREAD");
- unsetenv("TDM_COMMIT_PER_VBLANK");
- unsetenv("XDG_RUNTIME_DIR");
- unsetenv("TBM_DISPLAY_SERVER");
- }
+/**************************************************************************
+ *
+ * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
+ *
+ * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
+ * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
+ * Contact: Roman Marchenko <r.marchenko@samsung.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+**************************************************************************/
- void SetUp(void)
- {
- const tdm_output_mode *preferred_mode = NULL;
- tdm_error error = TDM_ERROR_NONE;
- int all_output_count = 0;
-
- SetEnv();
+#include "ut_tdm.h"
- bufmgr = tbm_bufmgr_init(-1);
- ASSERT_FALSE(bufmgr == NULL);
+/* LCOV_EXCL_START */
- dpy = tdm_display_init(&error);
- ASSERT_TRUE(error == TDM_ERROR_NONE);
- ASSERT_FALSE(dpy == NULL);
+class TDMHelper : public TDMOutput
+{
+public:
+ TDMHelper();
+ void SetUp(void);
+ void TearDown(void);
+};
- master_fd = tbm_drm_helper_get_master_fd();
- ASSERT_TRUE(tdm_display_get_output_count(dpy, &all_output_count) == TDM_ERROR_NONE);
+TDMHelper::TDMHelper()
+{
+}
- outputs = (tdm_output **)calloc(all_output_count, sizeof(tdm_output *));
- ASSERT_FALSE(NULL == outputs);
+void TDMHelper::SetUp(void)
+{
+ TDMOutput::SetUp();
+}
- preferred_mode_array = (const tdm_output_mode **)calloc(all_output_count, sizeof(tdm_output_mode *));
- ASSERT_FALSE(NULL == preferred_mode_array);
+void TDMHelper::TearDown(void)
+{
+ TDMOutput::TearDown();
+}
- output_count = 0;
+TEST_P(TDMHelper, HelperGetTime)
+{
+ ASSERT_GT(tdm_helper_get_time(), 0.0);
+}
- for (int i = 0; i < all_output_count; i++) {
- tdm_output *output = tdm_display_get_output(dpy, i, &error);
- int output_modes_cnt = 0;
- const tdm_output_mode *output_modes;
+TEST_P(TDMHelper, HelperDumpBufferXR24)
+{
+ tbm_surface_h buffer;
- if (TDM_ERROR_NONE != error || NULL == output)
- continue;
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_XRGB8888);
+ ASSERT_NE(buffer, NULL);
- tdm_output_conn_status status = TDM_OUTPUT_CONN_STATUS_DISCONNECTED;
- if (TDM_ERROR_NONE != tdm_output_get_conn_status(output, &status))
- continue;
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
- if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
- continue;
+ char filename[256];
+ snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
+ tdm_helper_dump_buffer(buffer, (const char*)filename);
- error = tdm_output_get_available_modes(output, &output_modes, &output_modes_cnt);
- if (TDM_ERROR_NONE != error)
- continue;
- if (output_modes_cnt <= 0) {
- continue;
- }
+ tbm_surface_destroy(buffer);
+}
- for(int j = 0; j < output_modes_cnt; j++)
- if(output_modes[j].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
- preferred_mode = &output_modes[j];
+TEST_P(TDMHelper, HelperDumpBufferAR24)
+{
+ tbm_surface_h buffer;
- if (!preferred_mode)
- continue;
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(buffer, NULL);
- if (preferred_mode_array)
- preferred_mode_array[output_count] = preferred_mode;
- if (outputs)
- outputs[output_count] = output;
- output_count++;
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
- error = tdm_output_set_mode(output, preferred_mode);
- ASSERT_EQ(TDM_ERROR_NONE, error);
- }
- surface = tbm_surface_create(256, 256, TBM_FORMAT_ARGB8888);
- ASSERT_TRUE(surface != NULL);
- }
+ char filename[256];
+ snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
+ tdm_helper_dump_buffer(buffer, (const char*)filename);
- void TearDown(void)
- {
- if (surface) {
- while (tbm_surface_internal_is_valid(surface))
- tbm_surface_destroy(surface);
- }
- tdm_display_deinit(dpy);
- dpy = NULL;
- tbm_bufmgr_deinit(bufmgr);
- bufmgr = NULL;
- if (outputs)
- free(outputs);
- if (preferred_mode_array)
- free(preferred_mode_array);
- if (master_fd > -1) {
- int temp_master_fd = tbm_drm_helper_get_master_fd();
- EXPECT_EQ(temp_master_fd, -1) << "Fatal Error. Can't deinit tdm/tbm" << std::endl;
- if (temp_master_fd > -1)
- exit(1);
- close(master_fd);
- }
-
- UnsetEnv();
- }
-};
+ tbm_surface_destroy(buffer);
+}
-int remove_cb(const char *fpath, const struct stat *sb, int typeflag, struct FTW *ftwbuf)
+TEST_P(TDMHelper, HelperDumpBufferNullObject)
{
- int rv = remove(fpath);
- if (rv)
- perror(fpath);
- return rv;
+ char filename[256];
+ tdm_helper_dump_buffer(NULL, (const char*)filename);
}
-int rmrf(const char *path)
+TEST_P(TDMHelper, HelperDumpBufferNullOther)
{
- return nftw(path, remove_cb, 64, FTW_DEPTH | FTW_PHYS);
+ tbm_surface_h buffer = (tbm_surface_h)TDM_UT_INVALID_VALUE;
+ tdm_helper_dump_buffer(buffer, NULL);
}
-class TDMHelperSurface: public TDMHelper
+TEST_P(TDMHelper, HelperClearBufferPos)
{
-protected:
-
- void SetUp()
- {
- TDMHelper::SetUp();
- ASSERT_EQ(0, mkdir(TMP_PATH_FOR_UTEST, 0755)) << "error: " << strerror(errno);
- }
- void TearDown()
- {
+ tbm_surface_h buffer;
+ tdm_pos pos = {.x = 40, .y = 40, .w = TDM_UT_BUFFER_SIZE - 80, .h = TDM_UT_BUFFER_SIZE - 80};
- rmrf(TMP_PATH_FOR_UTEST);
- TDMHelper::TearDown();
- }
-};
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(buffer, NULL);
-class TDMHelperDisplay: public TDMHelper {
-};
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
-class TDMHelperOutput: public TDMHelper {
-};
+ tdm_helper_clear_buffer_pos(buffer, &pos);
+ tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
-/* double tdm_helper_get_time(void); */
-TEST(TDMHelper, GetTime)
-{
- double time;
- time = tdm_helper_get_time();
- EXPECT_GT(time, 0);
+ tbm_surface_destroy(buffer);
}
-/* void tdm_helper_dump_start(char *dumppath, int *count); */
-TEST(TDMHelper, DumpStartFailNull)
+TEST_P(TDMHelper, HelperClearBufferColor)
{
- int count = 100;
- tdm_helper_dump_start(NULL, &count);
+ tbm_surface_h buffer;
+ tdm_pos pos = {.x = 40, .y = 40, .w = TDM_UT_BUFFER_SIZE - 80, .h = TDM_UT_BUFFER_SIZE - 80};
+ unsigned int color = 0xffffff00;
- tdm_helper_dump_start((char *)TMP_PATH_FOR_UTEST, NULL);
-}
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(buffer, NULL);
-TEST(TDMHelper, DumpStartSuccessful)
-{
- int count = 100;
- tdm_helper_dump_start((char *)TMP_PATH_FOR_UTEST, &count);
-}
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
-/* void tdm_helper_dump_stop(void); */
-TEST(TDMHelper, DumpStopSuccessful)
-{
- tdm_helper_dump_stop();
-}
+ tdm_helper_clear_buffer_color(buffer, &pos, color);
-/* void tdm_helper_dump_buffer(tbm_surface_h buffer, const char *file); */
-TEST_F(TDMHelperSurface, DumpBufferFailNull)
-{
- tdm_helper_dump_buffer(NULL, TMP_PATH_FOR_UTEST "/tmp");
+ tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
+
+ tbm_surface_destroy(buffer);
}
-TEST_F(TDMHelperSurface, DumpBufferFailInvalidOutput)
+TEST_P(TDMHelper, HelperClearBufferARGB)
{
- int invalid_surface;
- tdm_helper_dump_buffer((tbm_surface_h)&invalid_surface, TMP_PATH_FOR_UTEST "/xyz.png");
+ tbm_surface_h buffer;
- /* file name mast have an extension ".png" */
- tdm_helper_dump_buffer(surface, TMP_PATH_FOR_UTEST "/tmp.xyz");
-}
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(buffer, NULL);
-TEST_F(TDMHelperSurface, DumpBufferFailUnknownFormat)
-{
- tbm_surface_h surf;
- surf = tbm_surface_create(256, 256, TBM_FORMAT_YUV444);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_dump_buffer(surface, TMP_PATH_FOR_UTEST "/xyz.png");
- tbm_surface_destroy(surf);
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
+
+ tdm_helper_clear_buffer(buffer);
+
+ tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
+
+ tbm_surface_destroy(buffer);
}
-TEST_F(TDMHelperSurface, DumpBufferSuccessful)
+TEST_P(TDMHelper, HelperClearBufferXRGB)
{
- tbm_surface_h surf;
+ tbm_surface_h buffer;
- tdm_helper_dump_buffer(surface, TMP_PATH_FOR_UTEST "/rgb.png");
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_XRGB8888);
+ ASSERT_NE(buffer, NULL);
- surf = tbm_surface_create(256, 256, TBM_FORMAT_YUV420);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_dump_buffer(surf, TMP_PATH_FOR_UTEST "/YUV.yuv");
- tbm_surface_destroy(surf);
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
- surf = tbm_surface_create(256, 256, TBM_FORMAT_NV12);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_dump_buffer(surf, TMP_PATH_FOR_UTEST "/NV.yuv");
- tbm_surface_destroy(surf);
+ tdm_helper_clear_buffer(buffer);
- surf = tbm_surface_create(256, 256, TBM_FORMAT_YUYV);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_dump_buffer(surf, TMP_PATH_FOR_UTEST "/YUYV.yuv");
- tbm_surface_destroy(surf);
-}
+ tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
-/* void tdm_helper_clear_buffer_color(tbm_surface_h buffer, tdm_pos *pos, unsigned int color); */
-TEST_F(TDMHelperSurface, ClearBufferColorFailNull)
-{
- tdm_pos pos;
- tdm_helper_clear_buffer_color(NULL, &pos, 0x0F0F0F);
+ tbm_surface_destroy(buffer);
}
-TEST_F(TDMHelperSurface, ClearBufferColorInvalidOutput)
+TEST_P(TDMHelper, HelperClearBufferYUV420)
{
- int invalid_surface;
- tdm_pos pos;
- tdm_helper_clear_buffer_color((tbm_surface_h)&invalid_surface, &pos, 0x0F0F0F);
-}
+ tbm_surface_h buffer;
-TEST_F(TDMHelperSurface, ClearBufferColorUnknownFormat)
-{
- tdm_pos pos = { .x = 0, .y = 0, .w = 10, .h = 10 };
- tbm_surface_h surf;
- surf = tbm_surface_create(256, 256, TBM_FORMAT_YUV444);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer_color(surf, &pos, 0x0F0F0F);
- tbm_surface_destroy(surf);
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_YUV420);
+ ASSERT_NE(buffer, NULL);
+
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
+
+ tdm_helper_clear_buffer(buffer);
+
+ tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
+
+ tbm_surface_destroy(buffer);
}
-TEST_F(TDMHelperSurface, ClearBufferColorSuccessful)
+TEST_P(TDMHelper, HelperClearBufferNV12)
{
- tdm_pos pos = { .x = 0, .y = 0, .w = 10, .h = 10 };
- tbm_surface_h surf;
+ tbm_surface_h buffer;
- tdm_helper_clear_buffer_color(surface, &pos, 0x0F0F0F);
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_NV12);
+ ASSERT_NE(buffer, NULL);
- surf = tbm_surface_create(256, 256, TBM_FORMAT_YVU420);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer_color(surf, &pos, 0x0F0F0F);
- tbm_surface_destroy(surf);
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
- surf = tbm_surface_create(256, 256, TBM_FORMAT_NV12);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer_color(surf, &pos, 0x0F0F0F);
- tbm_surface_destroy(surf);
+ tdm_helper_clear_buffer(buffer);
- surf = tbm_surface_create(256, 256, TBM_FORMAT_YUYV);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer_color(surf, &pos, 0x0F0F0F);
- tbm_surface_destroy(surf);
+ tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
- surf = tbm_surface_create(256, 256, TBM_FORMAT_UYVY);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer_color(surf, &pos, 0x0F0F0F);
- tbm_surface_destroy(surf);
+ tbm_surface_destroy(buffer);
}
-/* void tdm_helper_clear_buffer_pos(tbm_surface_h buffer, tdm_pos *pos); */
-TEST_F(TDMHelperSurface, ClearBufferPosFailNull)
+TEST_P(TDMHelper, HelperClearBufferNV21)
{
- tdm_pos pos;
- tdm_helper_clear_buffer_pos(NULL, &pos);
+ tbm_surface_h buffer;
+
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_NV21);
+ ASSERT_NE(buffer, NULL);
+
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
+
+ tdm_helper_clear_buffer(buffer);
+
+ tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
+
+ tbm_surface_destroy(buffer);
}
-TEST_F(TDMHelperSurface, ClearBufferPosInvalidOutput)
+TEST_P(TDMHelper, HelperGetBufferFullSize)
{
- int invalid_surface;
- tdm_pos pos;
- tdm_helper_clear_buffer_pos((tbm_surface_h)&invalid_surface, &pos);
+ tbm_surface_h buffer;
+ int w = TDM_UT_INVALID_VALUE, h = TDM_UT_INVALID_VALUE;
+
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(buffer, NULL);
+
+ tdm_helper_get_buffer_full_size(buffer, &w, &h);
+ ASSERT_NE(w, TDM_UT_INVALID_VALUE);
+ ASSERT_GE(w, tbm_surface_get_width(buffer));
+ ASSERT_NE(h, TDM_UT_INVALID_VALUE);
+ ASSERT_GE(h, tbm_surface_get_height(buffer));
+
+ tbm_surface_destroy(buffer);
}
-TEST_F(TDMHelperSurface, ClearBufferPosUnknownFormat)
+TEST_P(TDMHelper, HelperConvertBufferRotate0)
{
- tdm_pos pos = { .x = 0, .y = 0, .w = 10, .h = 10 };
- tbm_surface_h surf;
- surf = tbm_surface_create(256, 256, TBM_FORMAT_YUV444);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer_pos(surf, &pos);
- tbm_surface_destroy(surf);
+ tbm_surface_h buffer, temp;
+ tdm_pos sp, dp;
+
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(buffer, NULL);
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
+
+ temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(temp, NULL);
+
+ sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
+ dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
+
+ ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_NONE);
+
+ tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
+
+ tbm_surface_destroy(buffer);
+ tbm_surface_destroy(temp);
}
-TEST_F(TDMHelperSurface, ClearBufferPosSuccessful)
+TEST_P(TDMHelper, HelperConvertBufferRotate0Flip)
{
- tdm_pos pos = { .x = 0, .y = 0, .w = 10, .h = 10 };
- tbm_surface_h surf;
+ tbm_surface_h buffer, temp;
+ tdm_pos sp, dp;
- tdm_helper_clear_buffer_pos(surface, &pos);
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(buffer, NULL);
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
- surf = tbm_surface_create(256, 256, TBM_FORMAT_YVU420);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer_pos(surf, &pos);
- tbm_surface_destroy(surf);
+ temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(temp, NULL);
- surf = tbm_surface_create(256, 256, TBM_FORMAT_NV12);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer_pos(surf, &pos);
- tbm_surface_destroy(surf);
+ sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
+ dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
- surf = tbm_surface_create(256, 256, TBM_FORMAT_YUYV);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer_pos(surf, &pos);
- tbm_surface_destroy(surf);
+ ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_FLIPPED, 0), TDM_ERROR_NONE);
- surf = tbm_surface_create(256, 256, TBM_FORMAT_UYVY);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer_pos(surf, &pos);
- tbm_surface_destroy(surf);
+ tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
+
+ tbm_surface_destroy(buffer);
+ tbm_surface_destroy(temp);
}
-/* void tdm_helper_clear_buffer(tbm_surface_h buffer); */
-TEST_F(TDMHelperSurface, ClearBufferFailNull)
+TEST_P(TDMHelper, HelperConvertBufferRotate90)
{
- tdm_helper_clear_buffer(NULL);
+ tbm_surface_h buffer, temp;
+ tdm_pos sp, dp;
+
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(buffer, NULL);
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
+
+ temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(temp, NULL);
+
+ sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
+ dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
+
+ ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_90, 0), TDM_ERROR_NONE);
+
+ tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
+
+ tbm_surface_destroy(buffer);
+ tbm_surface_destroy(temp);
}
-TEST_F(TDMHelperSurface, ClearBufferInvalidOutput)
+TEST_P(TDMHelper, HelperConvertBufferRotate180)
{
- int invalid_surface;
- tdm_helper_clear_buffer((tbm_surface_h)&invalid_surface);
+ tbm_surface_h buffer, temp;
+ tdm_pos sp, dp;
+
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(buffer, NULL);
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
+
+ temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(temp, NULL);
+
+ sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
+ dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
+
+ ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_180, 0), TDM_ERROR_NONE);
+
+ tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
+
+ tbm_surface_destroy(buffer);
+ tbm_surface_destroy(temp);
}
-TEST_F(TDMHelperSurface, ClearBufferUnknownFormat)
+TEST_P(TDMHelper, HelperConvertBufferRotate270)
{
- tbm_surface_h surf;
+ tbm_surface_h buffer, temp;
+ tdm_pos sp, dp;
+
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(buffer, NULL);
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
+
+ temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(temp, NULL);
+
+ sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
+ dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
- surf = tbm_surface_create(256, 256, TBM_FORMAT_YUV444);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer(surf);
- tbm_surface_destroy(surf);
+ ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_270, 0), TDM_ERROR_NONE);
+
+ tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
+
+ tbm_surface_destroy(buffer);
+ tbm_surface_destroy(temp);
}
-TEST_F(TDMHelperSurface, ClearBufferSuccessful)
+TEST_P(TDMHelper, HelperConvertBufferYUV420)
{
- tbm_surface_h surf;
+ tbm_surface_h buffer, temp;
+ tdm_pos sp, dp;
- tdm_helper_clear_buffer(surface);
+ buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_YUV420);
+ ASSERT_NE(buffer, NULL);
+ tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
- surf = tbm_surface_create(256, 256, TBM_FORMAT_YVU420);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer(surf);
- tbm_surface_destroy(surf);
+ temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_YUV420);
+ ASSERT_NE(temp, NULL);
- surf = tbm_surface_create(256, 256, TBM_FORMAT_NV12);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer(surf);
- tbm_surface_destroy(surf);
+ sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
+ dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
- surf = tbm_surface_create(256, 256, TBM_FORMAT_YUYV);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer(surf);
- tbm_surface_destroy(surf);
+ ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_OPERATION_FAILED);
- surf = tbm_surface_create(256, 256, TBM_FORMAT_UYVY);
- ASSERT_TRUE(surf != NULL);
- tdm_helper_clear_buffer(surf);
- tbm_surface_destroy(surf);
+ tbm_surface_destroy(buffer);
+ tbm_surface_destroy(temp);
}
-/* void tdm_helper_get_buffer_full_size(tbm_surface_h buffer, int *buffer_w, int *buffer_h); */
-TEST_F(TDMHelperSurface, GetBufferFullSizeFailNull)
+TEST_P(TDMHelper, HelperGetFD)
{
- int buffer_w;
- int buffer_h;
- tdm_helper_get_buffer_full_size(NULL, &buffer_w, &buffer_h);
+ int fd = tdm_helper_get_fd("TDM_DRM_MASTER_FD");
+ ASSERT_GE(fd, 0);
+ close(fd);
+ fd = tdm_helper_get_fd("BLURBLUR");
+ ASSERT_EQ(fd, -1);
}
-TEST_F(TDMHelperSurface, GetBufferFullSizeFailinvalidBuffer)
+TEST_P(TDMHelper, HelperSetFD)
{
- int invalid_surface;
- int buffer_w;
- int buffer_h;
- tdm_helper_get_buffer_full_size((tbm_surface_h)&invalid_surface, &buffer_w, &buffer_h);
+ tdm_helper_set_fd("TDM_DRM_MASTER_FD", -1);
+ tdm_helper_set_fd("BLURBLUR", -1);
}
-TEST_F(TDMHelperSurface, GetBufferFullSizeSuccessful)
+TEST_P(TDMHelper, HelperDumpStart)
{
- int buffer_w = 0;
- int buffer_h = 0;
- tdm_helper_get_buffer_full_size(surface, &buffer_w, &buffer_h);
- ASSERT_GE(buffer_w, 0);
- ASSERT_GE(buffer_h, 0);
+ char path[256];
+ int count = 0;
+ snprintf(path, sizeof path, "blurblur");
+ tdm_helper_dump_start(path, &count);
+ tdm_helper_dump_stop();
}
-/* tdm_error tdm_helper_convert_buffer(tbm_surface_h srcbuf, tbm_surface_h dstbuf,
- tdm_pos *srcpos, tdm_pos *dstpos,
- tdm_transform transform, int over); */
-TEST_F(TDMHelperSurface, ConvertBufferFailNull)
+static void
+_ut_tdm_helper_capture_cb(tbm_surface_h buffer, void *user_data)
{
- tdm_pos srcpos = { 0, 0, 256, 256 };
- tdm_pos dstpos = { 0, 0, 256, 256 };
- tbm_surface_h dstbuf;
- tdm_error error;
+}
- dstbuf = tbm_surface_create(256, 256, TBM_FORMAT_ARGB8888);
- ASSERT_TRUE(dstbuf != NULL);
+TEST_P(TDMHelper, HelperCaptureOutput)
+{
+ tdm_error ret;
+ tdm_output *output;
- error = tdm_helper_convert_buffer(NULL, dstbuf, &srcpos, &dstpos, TDM_TRANSFORM_NORMAL, 0);
- tbm_surface_destroy(dstbuf);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ for (int o = 0; o < output_count; o++) {
+ tbm_surface_h dump;
- error = tdm_helper_convert_buffer(surface, NULL, &srcpos, &dstpos, TDM_TRANSFORM_NORMAL, 0);
- ASSERT_NE(TDM_ERROR_NONE, error);
-}
+ output = tdm_display_get_output(dpy, o, &ret);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
+ ASSERT_NE(output, NULL);
-TEST_F(TDMHelperSurface, ConvertBufferFailinvalidBuffer)
-{
- int invalid_surface;
- tdm_pos srcpos = { 0, 0, 256, 256 };
- tdm_pos dstpos = { 0, 0, 256, 256 };
- tbm_surface_h dstbuf;
- tdm_error error;
+ if (!ut_tdm_output_is_connected(output))
+ continue;
- dstbuf = tbm_surface_create(256, 256, TBM_FORMAT_ARGB8888);
- ASSERT_TRUE(dstbuf != NULL);
+ ASSERT_EQ(ut_tdm_output_prepare(dpy, output, true), true);
- error = tdm_helper_convert_buffer((tbm_surface_h)&invalid_surface, dstbuf, &srcpos, &dstpos, TDM_TRANSFORM_NORMAL, 0);
- tbm_surface_destroy(dstbuf);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ dump = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
+ ASSERT_NE(dump, NULL);
- error = tdm_helper_convert_buffer(surface, (tbm_surface_h)&invalid_surface, &srcpos, &dstpos, TDM_TRANSFORM_NORMAL, 0);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ ASSERT_EQ(tdm_helper_capture_output(output, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
+ _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_NONE);
+
+ tdm_helper_dump_buffer_str(dump, NULL, (char*)typeid(*this).name());
+
+ tbm_surface_destroy(dump);
+ }
}
-TEST_F(TDMHelperSurface, ConvertBufferSuccessful)
-{
- tdm_pos srcpos = { 0, 0, 256, 256 };
- tdm_pos dstpos = { 0, 0, 256, 256 };
- tbm_surface_h dstbuf;
- tdm_error error;
- dstbuf = tbm_surface_create(256, 256, TBM_FORMAT_ARGB8888);
- ASSERT_TRUE(dstbuf != NULL);
+TEST_P(TDMHelper, HelperCaptureOutputNullObject)
+{
+ tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE;
- error = tdm_helper_convert_buffer(surface, dstbuf, &srcpos, &dstpos, TDM_TRANSFORM_NORMAL, 0);
- tbm_surface_destroy(dstbuf);
- ASSERT_EQ(TDM_ERROR_NONE, error);
+ ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
+ _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
-
-/* void tdm_helper_get_display_information(tdm_display *dpy, char *reply, int *len); */
-TEST_F(TDMHelperDisplay, GetDisplayInformationFailNull)
+TEST_P(TDMHelper, HelperCaptureOutputNullOther)
{
- char reply[STR_LEN] = {0};
- int len = STR_LEN;
- tdm_helper_get_display_information(NULL, reply, &len);
- ASSERT_LT(len, STR_LEN);
- ASSERT_EQ((STR_LEN - len), strlen(reply));
+ for (int o = 0; o < output_count; o++) {
+ tdm_error ret;
+ tdm_output *output = tdm_display_get_output(dpy, o, &ret);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
+ ASSERT_NE(output, NULL);
+ tdm_helper_output_commit_per_vblank_enabled(output);
+ }
- len = STR_LEN;
- tdm_helper_get_display_information(dpy, NULL, &len);
- ASSERT_EQ(STR_LEN, len);
+ tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE;
- reply[0] = '\0';
- tdm_helper_get_display_information(dpy, reply, NULL);
- ASSERT_EQ(0, reply[0]);
+ ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
+ _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
}
-TEST_F(TDMHelperDisplay, GetDisplayInformationSuccessful)
+TEST_P(TDMHelper, HelperGetDisplayInformation)
{
- char reply[STR_LEN] = {0};
- int len = STR_LEN;
- tdm_helper_get_display_information(dpy, reply, &len);
- ASSERT_LT(len, STR_LEN);
- ASSERT_EQ((STR_LEN - len), strlen(reply));
-}
-int capture_handler_is_called = 0;
-void capture_handler(tbm_surface_h buffer, void *user_data)
-{
- if (&capture_handler_is_called == user_data)
- capture_handler_is_called = 1;
-}
-/* tdm_error tdm_helper_capture_output(...); */
-TEST_F(TDMHelperOutput, CaptureOutputFailNull)
-{
- int output_count = 0;
- tdm_output *output = NULL;
- tdm_error error;
- tbm_surface_h buffer = NULL;
-
- error = tdm_display_get_output_count(dpy, &output_count);
- ASSERT_EQ(TDM_ERROR_NONE, error);
- for (int i = 0; i < output_count; i++) {
-
- output = tdm_display_get_output(dpy, i, &error);
- ASSERT_NE(NULL, output);
-
- error = tdm_helper_capture_output(NULL, buffer, 0, 0, 0, 0, capture_handler, &capture_handler_is_called);
- ASSERT_NE(TDM_ERROR_NONE, error);
- error = tdm_helper_capture_output(output, NULL, 0, 0, 0, 0, capture_handler, &capture_handler_is_called);
- ASSERT_NE(TDM_ERROR_NONE, error);
- error = tdm_helper_capture_output(output, buffer, 0, 0, 0, 0, NULL, &capture_handler_is_called);
- ASSERT_NE(TDM_ERROR_NONE, error);
- error = tdm_helper_capture_output(output, buffer, 0, 0, 0, 0, capture_handler, NULL);
- ASSERT_NE(TDM_ERROR_NONE, error);
+ char reply[8192];
+ int len = sizeof reply;
+
+ for (int o = 0; o < output_count; o++) {
+ tdm_error ret;
+ tdm_output *output = tdm_display_get_output(dpy, o, &ret);
+ ASSERT_EQ(ret, TDM_ERROR_NONE);
+ ASSERT_NE(output, NULL);
+ if (!ut_tdm_output_is_connected(output))
+ continue;
+ ASSERT_EQ(ut_tdm_output_prepare(dpy, output, true), true);
}
+
+ tdm_helper_get_display_information(dpy, reply, &len);
+ TDM_INFO("%s", reply);
}
-TEST_F(TDMHelperOutput, CaptureOutputFailInvalidInputs)
+TEST_P(TDMHelper, HelperGetDisplayInformationNullObject)
{
- for (int i = 0; i < output_count; i++) {
- error = tdm_helper_capture_output(outputs[i], surface, -1, 0, 0, 0, capture_handler, &capture_handler_is_called);
- ASSERT_NE(TDM_ERROR_NONE, error);
- error = tdm_helper_capture_output(outputs[i], surface, 0, -1, 0, 0, capture_handler, &capture_handler_is_called);
- ASSERT_NE(TDM_ERROR_NONE, error);
- error = tdm_helper_capture_output(outputs[i], surface, 0, 0, -1, 0, capture_handler, &capture_handler_is_called);
- ASSERT_NE(TDM_ERROR_NONE, error);
- error = tdm_helper_capture_output(outputs[i], surface, 0, 0, 0, -1, capture_handler, &capture_handler_is_called);
- ASSERT_NE(TDM_ERROR_NONE, error);
- }
+ char reply[8192];
+ int len = sizeof reply;
+
+ tdm_helper_get_display_information(NULL, reply, &len);
}
-TEST_F(TDMHelperOutput, CaptureOutputSuccessful)
+TEST_P(TDMHelper, HelperGetDisplayInformationNullOther)
{
- for (int i = 0; i < output_count; i++) {
- error = tdm_helper_capture_output(outputs[i], surface, 0, 0, 255, 255, capture_handler, &capture_handler_is_called);
- ASSERT_EQ(TDM_ERROR_NONE, error);
- }
+ tdm_helper_get_display_information(dpy, NULL, NULL);
}
-/* int tdm_helper_output_commit_per_vblank_enabled(tdm_output *output); */
-TEST_F(TDMHelperOutput, CommitPerVblankEnabledFailNull)
+TEST_P(TDMHelper, HelperCommitPerVblankEnabled)
{
- int state;
- state = tdm_helper_output_commit_per_vblank_enabled(NULL);
- ASSERT_EQ(-1, state);
+ ASSERT_EQ(tdm_helper_commit_per_vblank_enabled(dpy), 0);
}
-TEST_F(TDMHelperOutput, CommitPerVblankEnabledSuccessful)
+TEST_P(TDMHelper, HelperCommitPerVblankEnabledNullOBject)
{
- int state;
+ ASSERT_EQ(tdm_helper_commit_per_vblank_enabled(NULL), 0);
+}
- for (int i = 0; i < output_count; i++) {
- state = tdm_helper_output_commit_per_vblank_enabled(outputs[i]);
- ASSERT_EQ(1, state);
- }
+TEST_P(TDMHelper, HelperOutputCommitPerVblankEnabledNullObject)
+{
+ ASSERT_EQ(tdm_helper_output_commit_per_vblank_enabled(NULL), -1);
}
+#ifdef TDM_UT_TEST_WITH_PARAMS
+INSTANTIATE_TEST_CASE_P(TDMHelperParams,
+ TDMHelper,
+ Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
+#else
+INSTANTIATE_TEST_CASE_P(TDMHelperParams,
+ TDMHelper,
+ Values(TDM_DEFAULT_MODULE));
+#endif
+
+/* LCOV_EXCL_END */
\ No newline at end of file
projects / platform / core / uifw / libtdm.git / blobdiff