1 /**************************************************************************
3 * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
5 * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
6 * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
7 * Contact: Roman Marchenko <r.marchenko@samsung.com>
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:
17 * The above copyright notice and this permission notice (including the
18 * next paragraph) shall be included in all copies or substantial portions
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.
29 **************************************************************************/
31 #include "gtest/gtest.h"
32 #include "ut_common.h"
35 #include "tbm_bufmgr.h"
36 #include "tbm_drm_helper.h"
39 #include <sys/epoll.h>
40 #include <sys/timerfd.h>
43 class TDMCaptureWithoutCreation : public testing::Test {
45 tdm_display *dpy = nullptr;
46 tbm_bufmgr bufmgr = nullptr;
47 tdm_display_capability display_capability = (tdm_display_capability)0;
48 bool has_capture = false;
49 std::vector<tdm_output *> output_array;
51 virtual void SetEnvs()
53 setenv("TDM_DLOG", "1", 1);
54 setenv("XDG_RUNTIME_DIR", ".", 1);
55 setenv("TBM_DLOG", "1", 1);
56 setenv("TDM_DEBUG_MODULE", "all", 1);
57 setenv("TDM_DEBUG", "1", 1);
58 setenv("TBM_DISPLAY_SERVER", "1", 1);
61 virtual void UnsetEnvs()
64 unsetenv("XDG_RUNTIME_DIR");
66 unsetenv("TDM_DEBUG_MODULE");
67 unsetenv("TDM_DEBUG");
68 unsetenv("TBM_DISPLAY_SERVER");
73 tdm_error error = TDM_ERROR_NONE;
78 /* FIXME: fix the error. If we initialize TBM before TDM we get fail
79 * in the tdm_output_set_dpms */
81 tbm_bufmgr = tbm_bufmgr_init(-1);
82 ASSERT_FALSE(tbm_bufmgr == NULL);
85 dpy = tdm_display_init(&error);
86 ASSERT_TRUE(error == TDM_ERROR_NONE);
87 ASSERT_FALSE(dpy == nullptr);
89 error = tdm_display_get_capabilities(dpy, &display_capability);
90 #ifdef FAIL_ON_UNSUPPORTED
91 ASSERT_TRUE(display_capability & TDM_DISPLAY_CAPABILITY_CAPTURE);
93 ASSERT_TRUE(error == TDM_ERROR_NONE);
95 if (display_capability & TDM_DISPLAY_CAPABILITY_CAPTURE)
98 ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE);
100 for (int i = 0; i < output_count; i++) {
101 tdm_output *output = tdm_display_get_output(dpy, i, &error);
103 if (TDM_ERROR_NONE != error || nullptr == output)
106 tdm_output_conn_status status = TDM_OUTPUT_CONN_STATUS_DISCONNECTED;
107 if (TDM_ERROR_NONE != tdm_output_get_conn_status(output, &status))
110 if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
113 output_array.push_back(output);
120 tdm_display_deinit(dpy);
122 tbm_bufmgr_deinit(bufmgr);
131 const tdm_output_mode *output_mode;
132 tdm_capture *capture;
133 std::vector<tdm_layer *> layers;
134 UtCapture(tdm_output *, const tdm_output_mode *, tdm_capture *, std::vector<tdm_layer *>);
137 UtCapture::UtCapture(tdm_output *_output, const tdm_output_mode *_output_mode,
138 tdm_capture *_capture, std::vector<tdm_layer *> _layers)
141 output_mode = _output_mode;
146 class TDMCapture : public TDMCaptureWithoutCreation {
148 const tbm_format *formats = nullptr;
149 int format_count = 0;
150 std::vector<UtCapture> captures;
151 std::vector<tbm_surface_h> buffers;
152 static int utCaptureDoneHandlerSuccessCounter;
153 friend void UtCaptureDoneHandler(tdm_capture *capture,
154 tbm_surface_h buffer, void *user_data);
157 void UtCaptureGetInfo(UtCapture *capture, double scale, tdm_transform transform, tdm_info_capture *info);
158 void UtCaptureGetInfo(UtCapture *capture, tdm_info_capture *info);
159 tbm_surface_h UtCaptureCreateBuffer(UtCapture *capture);
160 tbm_surface_h UtCaptureCreateBuffer(int width, int height, tbm_format format, int scanout);
161 tbm_surface_h UtCaptureCreateBuffer(int width, int height, tbm_format format);
164 int TDMCapture::utCaptureDoneHandlerSuccessCounter = 0;
166 void UtCaptureDoneHandler(tdm_capture *capture,
167 tbm_surface_h buffer, void *user_data)
169 TDMCapture *fcapture = (TDMCapture *)user_data;
174 for (tbm_surface_h buf : fcapture->buffers) {
176 fcapture->utCaptureDoneHandlerSuccessCounter++;
182 void TDMCapture::SetUp(void)
186 utCaptureDoneHandlerSuccessCounter = 0;
188 ASSERT_NO_FATAL_FAILURE(TDMCaptureWithoutCreation::SetUp());
193 for (tdm_output *output : output_array) {
194 const tdm_output_mode *output_mode = nullptr;
195 int output_modes_cnt = 0;
196 const tdm_output_mode *output_modes;
197 int temp_layer_count = 0;
198 std::vector<tdm_layer *> layers;
200 error = tdm_output_get_available_modes(output, &output_modes, &output_modes_cnt);
201 ASSERT_EQ(TDM_ERROR_NONE, error);
203 for(int j = 0; j < output_modes_cnt; j++)
204 if(output_modes[j].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
205 output_mode = &output_modes[j];
207 ASSERT_NE(nullptr, output_mode);
209 if (TDM_ERROR_NONE != tdm_output_get_layer_count(output, &temp_layer_count))
211 if (0 == temp_layer_count)
214 for (int i = 0; i < temp_layer_count; ++i) {
216 layer = tdm_output_get_layer(output, i, &error);
217 ASSERT_TRUE(TDM_ERROR_NONE == error);
218 ASSERT_FALSE(NULL == layer);
219 layers.push_back(layer);
222 tdm_capture *capture = tdm_output_create_capture(output, &error);
223 ASSERT_NE(nullptr, capture);
224 ASSERT_EQ(TDM_ERROR_NONE, error);
226 captures.emplace_back(output, output_mode, capture, layers);
230 tdm_display_get_catpure_available_formats(dpy, &formats, &format_count);
231 ASSERT_EQ(TDM_ERROR_NONE, error);
232 ASSERT_NE(nullptr, formats);
233 ASSERT_GE(format_count, 0);
236 void TDMCapture::TearDown(void)
238 for (UtCapture & utCapture : captures)
239 tdm_capture_destroy(utCapture.capture);
241 for (tbm_surface_h buffer : buffers) {
242 tbm_surface_destroy(buffer);
245 TDMCaptureWithoutCreation::TearDown();
248 void TDMCapture::UtCaptureGetInfo(UtCapture *capture, double scale,
249 tdm_transform transform, tdm_info_capture *info)
251 memset((void *)info, 0, sizeof(tdm_info_capture));
253 const tdm_output_mode *output_mode = capture->output_mode;
255 int w = output_mode->hdisplay * scale;
256 int h = output_mode->vdisplay * scale;
258 info->dst_config.size.h = w;
259 info->dst_config.size.v = h;
260 info->dst_config.pos.x = 0;
261 info->dst_config.pos.y = 0;
262 info->dst_config.pos.w = w;
263 info->dst_config.pos.h = h;
264 info->dst_config.format = formats[0];
265 info->transform = transform;
266 info->type = TDM_CAPTURE_TYPE_ONESHOT;
269 void TDMCapture::UtCaptureGetInfo(UtCapture *capture, tdm_info_capture *info)
271 UtCaptureGetInfo(capture, 1.0, TDM_TRANSFORM_NORMAL, info);
275 TDMCapture::UtCaptureCreateBuffer(UtCapture *capture)
277 tbm_surface_h buffer;
279 buffer = tbm_surface_create(capture->output_mode->hdisplay,
280 capture->output_mode->vdisplay, formats[0]);
282 buffers.push_back(buffer);
288 TDMCapture::UtCaptureCreateBuffer(int width, int height, tbm_format format, int scanout)
290 tbm_surface_h buffer;
293 buffer = tbm_surface_internal_create_with_flags(width, height, format, TBM_BO_SCANOUT);
295 buffer = tbm_surface_internal_create_with_flags(width, height, format, TBM_BO_DEFAULT);
298 buffers.push_back(buffer);
304 TDMCapture::UtCaptureCreateBuffer(int width, int height, tbm_format format)
306 return UtCaptureCreateBuffer(width, height, format, 0);
309 class TDMCaptureCommit : public TDMCapture {
315 static const int timeLimitSec = 3;
316 static const int timeLimitNsec = 0;
320 void UtHandleCaptureEvent();
321 int UtPrepareToCapture(double scale, tdm_transform transform);
322 int UtPrepareToCapture();
325 void TDMCaptureCommit::SetUp(void)
327 struct epoll_event ep;
330 ASSERT_NO_FATAL_FAILURE(TDMCapture::SetUp());
332 for (UtCapture & utCapture : captures) {
333 error = tdm_output_set_mode(utCapture.output, utCapture.output_mode);
334 ASSERT_TRUE(error == TDM_ERROR_NONE);
336 error = tdm_output_set_dpms(utCapture.output, TDM_OUTPUT_DPMS_ON);
337 ASSERT_TRUE(error == TDM_ERROR_NONE);
339 for (tdm_layer *layer : utCapture.layers) {
341 tdm_layer_capability lcapabilities;
342 tbm_surface_h buffer;
343 tdm_info_layer layer_info = {0};
345 w = utCapture.output_mode->hdisplay;
346 h = utCapture.output_mode->vdisplay;
348 error = tdm_layer_get_capabilities(layer, &lcapabilities);
349 ASSERT_EQ(TDM_ERROR_NONE, error);
350 if (!(lcapabilities & TDM_LAYER_CAPABILITY_PRIMARY)) {
355 buffer = UtCaptureCreateBuffer(w, h, TBM_FORMAT_ARGB8888, 1);
356 ASSERT_NE(nullptr, buffer);
358 layer_info.src_config.size.h = w;
359 layer_info.src_config.size.v = h;
360 layer_info.src_config.pos.x = 0;
361 layer_info.src_config.pos.y = 0;
362 layer_info.src_config.pos.w = w;
363 layer_info.src_config.pos.h = h;
364 layer_info.src_config.format = TBM_FORMAT_ARGB8888;
365 layer_info.dst_pos.x = 0;
366 layer_info.dst_pos.y = 0;
367 layer_info.dst_pos.w = w;
368 layer_info.dst_pos.h = h;
369 layer_info.transform = TDM_TRANSFORM_NORMAL;
371 error = tdm_layer_set_info(layer, &layer_info);
372 ASSERT_EQ(TDM_ERROR_NONE, error);
374 error = tdm_layer_set_buffer(layer, buffer);
375 ASSERT_EQ(TDM_ERROR_NONE, error);
378 error = tdm_output_commit(utCapture.output, 0, nullptr, nullptr);
379 ASSERT_EQ(TDM_ERROR_NONE, error);
382 /* TODO: use output_commit_handle */
385 epFd = epoll_create1(0);
386 ASSERT_TRUE(epFd != -1);
388 timerFd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
389 ASSERT_TRUE(timerFd != -1);
391 memset(&ep, 0, sizeof ep);
392 ep.events |= EPOLLIN;
393 ep.data.fd = timerFd;
394 ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, timerFd, &ep) == 0);
396 ASSERT_TRUE(tdm_display_get_fd(dpy, &tdmFd) == TDM_ERROR_NONE);
398 memset(&ep, 0, sizeof ep);
399 ep.events |= EPOLLIN;
401 ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, tdmFd, &ep) == 0);
404 void TDMCaptureCommit::TearDown(void)
411 for (UtCapture & utCapture : captures) {
412 for (tdm_layer *layer : utCapture.layers)
413 tdm_layer_unset_buffer(layer);
415 tdm_output_set_dpms(utCapture.output, TDM_OUTPUT_DPMS_OFF);
418 TDMCapture::TearDown();
421 void TDMCaptureCommit::UtHandleCaptureEvent()
423 struct itimerspec its;
425 struct epoll_event ep_event[2];
427 if (utCaptureDoneHandlerSuccessCounter == (int)captures.size())
430 its.it_interval.tv_sec = 0;
431 its.it_interval.tv_nsec = 0;
432 its.it_value.tv_sec = timeLimitSec;
433 its.it_value.tv_nsec = timeLimitNsec;
435 ASSERT_TRUE(timerfd_settime(timerFd, 0, &its, NULL) == 0);
438 count = epoll_wait(epFd, ep_event, sizeof(ep_event), -1);
439 ASSERT_TRUE(count >= 0);
441 for (int i = 0; i < count; i++) {
442 if (ep_event[i].data.fd == timerFd) {
445 ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
446 if (utCaptureDoneHandlerSuccessCounter == (int)captures.size())
453 int TDMCaptureCommit::UtPrepareToCapture(double scale, tdm_transform transform)
456 tbm_surface_h buffer;
458 for (UtCapture & utCapture : captures) {
459 tdm_info_capture info = {0};
461 UtCaptureGetInfo(&utCapture, scale, transform, &info);
463 error = tdm_capture_set_done_handler(utCapture.capture, UtCaptureDoneHandler, this);
464 EXPECT_EQ(TDM_ERROR_NONE, error);
465 if (error != TDM_ERROR_NONE)
468 error = tdm_capture_set_info(utCapture.capture, &info);
469 EXPECT_EQ(TDM_ERROR_NONE, error);
470 if (error != TDM_ERROR_NONE)
473 buffer = UtCaptureCreateBuffer(info.dst_config.size.h,
474 info.dst_config.size.v,
475 info.dst_config.format);
476 EXPECT_NE(NULL, buffer);
480 error = tdm_capture_attach(utCapture.capture, buffer);
481 EXPECT_EQ(TDM_ERROR_NONE, error);
482 if (error != TDM_ERROR_NONE)
489 int TDMCaptureCommit::UtPrepareToCapture()
491 return UtPrepareToCapture(1.0, TDM_TRANSFORM_NORMAL);
494 class TDMCaptureCommitThread : public TDMCaptureCommit {
498 TDMCaptureCommit::SetEnvs();
499 setenv("TDM_THREAD", "1", 1);
503 TDMCaptureCommit::UnsetEnvs();
504 unsetenv("TDM_THREAD");
508 TEST_F(TDMCaptureWithoutCreation, DisplayGetCaptureAvailableFormatsSuccessful)
510 SKIP_FLAG(has_capture);
511 const tbm_format * formats = nullptr;
513 ASSERT_TRUE(TDM_ERROR_NONE == tdm_display_get_catpure_available_formats(dpy, &formats, &count));
514 ASSERT_FALSE(-42 == count);
515 ASSERT_FALSE(nullptr == formats);
518 /* tdm_display_create_pp() */
520 TEST_F(TDMCaptureWithoutCreation, DisplayCreateCaptureNullAll)
522 SKIP_FLAG(has_capture);
523 tdm_capture *capture;
525 capture = tdm_output_create_capture(nullptr, nullptr);
526 ASSERT_EQ(nullptr, capture);
529 TEST_F(TDMCaptureWithoutCreation, DisplayCreateCaptureNullOutput)
531 SKIP_FLAG(has_capture);
532 tdm_capture *capture;
535 capture = tdm_output_create_capture(nullptr, &error);
536 ASSERT_EQ(nullptr, capture);
537 ASSERT_NE(TDM_ERROR_NONE, error);
540 TEST_F(TDMCaptureWithoutCreation, DisplayCreateCaptureSuccessNullError)
542 SKIP_FLAG(has_capture);
543 tdm_capture *capture;
545 for (tdm_output *output : output_array) {
546 capture = tdm_output_create_capture(output, nullptr);
547 ASSERT_NE(nullptr, capture);
551 TEST_F(TDMCaptureWithoutCreation, DisplayCreateCaptureSuccess)
553 SKIP_FLAG(has_capture);
554 tdm_capture *capture;
557 for (tdm_output *output : output_array) {
558 capture = tdm_output_create_capture(output, &error);
559 ASSERT_NE(nullptr, capture);
560 ASSERT_EQ(TDM_ERROR_NONE, error);
564 /* tdm_display_get_capture_available_size */
566 TEST_F(TDMCapture, DisplayGetCaptureAvailableSizeFailNullAll)
568 SKIP_FLAG(has_capture);
571 error = tdm_display_get_capture_available_size(nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
572 ASSERT_NE(TDM_ERROR_NONE, error);
575 TEST_F(TDMCapture, DisplayGetCaptureAvailableSizeSuccess)
577 SKIP_FLAG(has_capture);
585 error = tdm_display_get_capture_available_size(dpy, &min_w, &min_h,
586 &max_w, &max_h, &preferred_align);
587 ASSERT_EQ(TDM_ERROR_NONE, error);
591 /* tdm_capture_set_info() */
593 TEST_F(TDMCapture, CaptureSetInfoFailNullAll)
595 SKIP_FLAG(has_capture);
598 error = tdm_capture_set_info(nullptr, nullptr);
599 ASSERT_NE(TDM_ERROR_NONE, error);
602 TEST_F(TDMCapture, CaptureSetInfoFailNullCapture)
604 SKIP_FLAG(has_capture);
606 tdm_info_capture info;
608 error = tdm_capture_set_info(nullptr, &info);
609 ASSERT_NE(TDM_ERROR_NONE, error);
612 TEST_F(TDMCapture, CaptureSetInfoNullInfo)
614 SKIP_FLAG(has_capture);
617 for (UtCapture & utCapture : captures) {
618 error = tdm_capture_set_info(utCapture.capture, nullptr);
619 ASSERT_NE(TDM_ERROR_NONE, error);
623 TEST_F(TDMCapture, CaptureSetInfoSuccessStream)
625 SKIP_FLAG(has_capture);
627 tdm_info_capture info;
629 for (UtCapture & utCapture : captures) {
630 error = tdm_output_set_mode(utCapture.output, utCapture.output_mode);
631 ASSERT_EQ(TDM_ERROR_NONE, error);
633 UtCaptureGetInfo(&utCapture, &info);
635 info.type = TDM_CAPTURE_TYPE_STREAM;
637 error = tdm_capture_set_info(utCapture.capture, &info);
638 ASSERT_EQ(TDM_ERROR_NONE, error);
642 TEST_F(TDMCapture, CaptureSetInfoSuccess)
644 SKIP_FLAG(has_capture);
646 tdm_info_capture info;
648 for (UtCapture & utCapture : captures) {
649 UtCaptureGetInfo(&utCapture, &info);
651 error = tdm_capture_set_info(utCapture.capture, &info);
652 ASSERT_EQ(TDM_ERROR_NONE, error);
656 /* tdm_capture_set_done_handler() */
658 TEST_F(TDMCapture, CaptureSetDoneHandlerFailNullAll)
660 SKIP_FLAG(has_capture);
663 error = tdm_capture_set_done_handler(nullptr, nullptr, nullptr);
664 ASSERT_NE(TDM_ERROR_NONE, error);
667 TEST_F(TDMCapture, CaptureSetDoneHandlerFailNullCapture)
669 SKIP_FLAG(has_capture);
672 error = tdm_capture_set_done_handler(nullptr, UtCaptureDoneHandler, this);
673 ASSERT_NE(TDM_ERROR_NONE, error);
676 TEST_F(TDMCapture, CaptureSetDoneHandlerSuccessNullFailNullFunc)
678 SKIP_FLAG(has_capture);
681 for (UtCapture & utCapture : captures) {
682 error = tdm_pp_set_done_handler(utCapture.capture, nullptr, this);
683 ASSERT_NE(TDM_ERROR_NONE, error);
687 TEST_F(TDMCapture, CaptureSetDoneHandlerSuccessNullData)
689 SKIP_FLAG(has_capture);
692 for (UtCapture & utCapture : captures) {
693 error = tdm_capture_set_done_handler(utCapture.capture, UtCaptureDoneHandler, this);
694 ASSERT_EQ(TDM_ERROR_NONE, error);
698 TEST_F(TDMCapture, CaptureSetDoneHandlerSuccess)
700 SKIP_FLAG(has_capture);
703 for (UtCapture & utCapture : captures) {
704 error = tdm_capture_set_done_handler(utCapture.capture, UtCaptureDoneHandler, this);
705 ASSERT_EQ(TDM_ERROR_NONE, error);
709 /* tdm_capture_attach() */
711 TEST_F(TDMCapture, CaptureAttachFailNullAll)
713 SKIP_FLAG(has_capture);
716 error = tdm_capture_attach(nullptr, nullptr);
717 ASSERT_NE(TDM_ERROR_NONE, error);
720 TEST_F(TDMCapture, CaptureAttachFailNullCapture)
722 SKIP_FLAG(has_capture);
724 tbm_surface_h buffer;
726 buffer = UtCaptureCreateBuffer(&captures[0]);
727 ASSERT_NE(nullptr, buffer);
729 error = tdm_capture_attach(nullptr, buffer);
730 ASSERT_NE(TDM_ERROR_NONE, error);
733 TEST_F(TDMCapture, CaptureAttachFailNullBuffer)
735 SKIP_FLAG(has_capture);
738 for (UtCapture & utCapture : captures) {
739 error = tdm_capture_attach(utCapture.capture, nullptr);
740 ASSERT_NE(TDM_ERROR_NONE, error);
744 TEST_F(TDMCapture, CaptureAttachSuccess)
746 SKIP_FLAG(has_capture);
748 tbm_surface_h buffer;
750 for (UtCapture & utCapture : captures) {
751 buffer = UtCaptureCreateBuffer(&utCapture);
752 ASSERT_NE(nullptr, buffer);
754 error = tdm_capture_attach(utCapture.capture, buffer);
755 ASSERT_EQ(TDM_ERROR_NONE, error);
759 /* tdm_pp_commit() */
761 TEST_F(TDMCapture, CaptureCommitFailNullCapture)
763 SKIP_FLAG(has_capture);
766 error = tdm_capture_commit(nullptr);
767 ASSERT_NE(TDM_ERROR_NONE, error);
770 TEST_F(TDMCapture, CaptureCommitFailDpmsOff)
772 SKIP_FLAG(has_capture);
775 for (UtCapture & utCapture : captures) {
776 error = tdm_capture_commit(utCapture.capture);
777 ASSERT_NE(TDM_ERROR_NONE, error);
781 TEST_F(TDMCaptureCommit, CaptureCommitSuccess)
783 SKIP_FLAG(has_capture);
786 ASSERT_NE(-1, UtPrepareToCapture());
788 for (UtCapture & utCapture : captures) {
789 error = tdm_capture_commit(utCapture.capture);
790 ASSERT_EQ(TDM_ERROR_NONE, error);
793 UtHandleCaptureEvent();
795 ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
798 TEST_F(TDMCaptureCommitThread, CaptureCommitSuccess)
800 SKIP_FLAG(has_capture);
803 ASSERT_NE(-1, UtPrepareToCapture());
805 for (UtCapture & utCapture : captures) {
806 error = tdm_capture_commit(utCapture.capture);
807 ASSERT_EQ(TDM_ERROR_NONE, error);
810 UtHandleCaptureEvent();
812 ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
815 TEST_F(TDMCaptureCommit, CaptureCommitSuccessScale)
817 SKIP_FLAG(has_capture);
820 ASSERT_NE(-1, UtPrepareToCapture(2.0, TDM_TRANSFORM_NORMAL));
822 for (UtCapture & utCapture : captures) {
823 error = tdm_capture_commit(utCapture.capture);
824 ASSERT_EQ(TDM_ERROR_NONE, error);
827 UtHandleCaptureEvent();
829 ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
832 TEST_F(TDMCaptureCommit, CaptureCommitSuccessScaleAndTransform)
834 SKIP_FLAG(has_capture);
837 ASSERT_NE(-1, UtPrepareToCapture(2.0, TDM_TRANSFORM_180));
839 for (UtCapture & utCapture : captures) {
840 error = tdm_capture_commit(utCapture.capture);
841 ASSERT_EQ(TDM_ERROR_NONE, error);
844 UtHandleCaptureEvent();
846 ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);