utest: rework output init func

Change-Id: Ib1f07e1235ed654cf73d346730f94692dabf7438
Signed-off-by: Andrii Sokolenko <a.sokolenko@samsung.com>

diff --git a/utests/src/ut_tdm_output.cpp b/utests/src/ut_tdm_output.cpp
index e3178c1..9c050ba 100644 (file)
--- a/utests/src/ut_tdm_output.cpp
+++ b/utests/src/ut_tdm_output.cpp
@@ -40,7 +40,7 @@ extern "C" {
 class TDMOutput : public ::testing::Test {
 protected:
        tdm_display *dpy = NULL;
-       int output_count = -42, master_fd = -42, tbm_fd = -42;
+       int output_count = 0, master_fd = -42, tbm_fd = -42;
        bool has_output = false;
        tbm_bufmgr tbm_bufmgr = NULL;
        static unsigned int handle_call;
@@ -59,12 +59,14 @@ protected:
                setenv("XDG_RUNTIME_DIR", ".", 1);
                setenv("TBM_DLOG", "1", 1);
                setenv("TBM_DISPLAY_SERVER", "1", 1);
-               tbm_bufmgr = tbm_bufmgr_init(-1);
-               ASSERT_FALSE(tbm_bufmgr == NULL);
+               setenv("TDM_COMMIT_PER_VBLANK", "0", 1);
+
                tdm_error error = TDM_ERROR_NONE;
                dpy = tdm_display_init(&error);
                ASSERT_TRUE(error == TDM_ERROR_NONE);
                ASSERT_FALSE(dpy == NULL);
+               tbm_bufmgr = tbm_bufmgr_init(-1);
+               ASSERT_FALSE(tbm_bufmgr == NULL);
                master_fd = tbm_drm_helper_get_master_fd();
                tbm_fd = tbm_drm_helper_get_fd();
                error = tdm_display_get_output_count(dpy, &output_count);
@@ -99,9 +101,76 @@ protected:
                unsetenv("XDG_RUNTIME_DIR");
                unsetenv("TBM_DLOG");
                unsetenv("TBM_DISPLAY_SERVER");
+               unsetenv("TDM_COMMIT_PER_VBLANK");
+       }
+};
+
+class TDMOutputCommit : public TDMOutput {
+protected:
+       int conn_output_count = 0;
+       tdm_output ** connected_output_array = NULL;
+       tdm_output_mode** preferred_mode = NULL;
+       bool has_output = false;
+       void SetUp(void)
+       {
+               ASSERT_NO_FATAL_FAILURE(TDMOutput::SetUp());
+               if (TDMOutput::output_count > 0) {
+                       connected_output_array = (tdm_output **) calloc(TDMOutput::output_count, sizeof(tdm_output *));
+                       ASSERT_FALSE(NULL == connected_output_array);
+                       preferred_mode = (tdm_output_mode **) calloc(TDMOutput::output_count, sizeof(tdm_output_mode*));
+                       ASSERT_FALSE(NULL == preferred_mode);
+               }
+               conn_output_count = 0;
+               for (int i = 0; i < TDMOutput::output_count; i++) {
+                       tdm_error error = TDM_ERROR_NONE;
+                       int output_modes_cnt = 0;
+                       const tdm_output_mode* output_modes = NULL;
+                       tdm_output * output = tdm_display_get_output(TDMOutput::dpy, i, &error);
+                       if (TDM_ERROR_NONE != error || NULL == output)
+                               continue;
+                       tdm_output_conn_status status = TDM_OUTPUT_CONN_STATUS_DISCONNECTED;
+                       if (TDM_ERROR_NONE != tdm_output_get_conn_status(output, &status))
+                               continue;
+                       if (TDM_OUTPUT_CONN_STATUS_DISCONNECTED == status)
+                               continue;
+                       if (TDM_ERROR_NONE != tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON))
+                               continue;
+                       if(TDM_ERROR_NONE != tdm_output_get_available_modes(output,
+                                                                                                                               &output_modes,
+                                                                                                                               &output_modes_cnt))
+                               continue;
+                       for(int k = 0; k < output_modes_cnt; k++) {
+                               if(output_modes[k].type & TDM_OUTPUT_MODE_TYPE_PREFERRED) {
+                                       preferred_mode[conn_output_count] = &output_modes[k];
+                                       break;
+                               }
+                       }
+                       if (NULL == preferred_mode[conn_output_count])
+                               continue;
+                       connected_output_array[conn_output_count++] = output;
+               }
+#ifdef FAIL_ON_UNSUPPORTED
+               ASSERT_GT(conn_output_count, 0);
+#endif
+
+               if (conn_output_count > 0)
+                       has_output = true;
+       }
+       void TearDown(void)
+       {
+               for (int i = 0; i < conn_output_count; i++) {
+                       EXPECT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(connected_output_array[i],
+                                                                                                                         TDM_OUTPUT_DPMS_OFF));
+               }
+               if (connected_output_array)
+                       free(connected_output_array);
+               if (preferred_mode)
+                       free(preferred_mode);
+               ASSERT_NO_FATAL_FAILURE(TDMOutput::TearDown());
        }
 };
 
+
 unsigned int TDMOutput::handle_call = 0;
 
 TEST_F(TDMOutput, DisplayGetOutputSuccessful)
@@ -861,3 +930,44 @@ TEST_F(TDMOutput, OutputSetPropertyFailNullAll)
                                        error == TDM_ERROR_OPERATION_FAILED) exit(1);
                                 exit(0);}, ::testing::ExitedWithCode(0), "");
 }
+
+TEST_F(TDMOutput, OutputGetPropertySuccessful)
+{
+       SKIP_FLAG(has_output);
+       for (int i = 0; i < output_count; i++) {
+               tdm_error error = TDM_ERROR_NONE;
+               tdm_value value = {.u32 = 0};
+               tdm_output * output = tdm_display_get_output(dpy, i, &error);
+               ASSERT_FALSE(NULL == output);
+               ASSERT_TRUE(TDM_ERROR_NONE == error);
+               error = tdm_output_get_property(output, UINT_MAX, &value);
+               ASSERT_TRUE(error == TDM_ERROR_NOT_IMPLEMENTED || error == TDM_ERROR_OPERATION_FAILED);
+       }
+}
+
+TEST_F(TDMOutput, OutputGetPropertyFailNullAll)
+{
+       SKIP_FLAG(has_output);
+       ASSERT_EXIT({tdm_error error = TDM_ERROR_NONE;
+                                error = tdm_output_get_property(NULL, 0, NULL);
+                                if (error == TDM_ERROR_NONE || error == TDM_ERROR_NOT_IMPLEMENTED ||
+                                        error == TDM_ERROR_OPERATION_FAILED) exit(1);
+                                exit(0);}, ::testing::ExitedWithCode(0), "");
+}
+
+TEST_F(TDMOutputCommit, OutputCommit)
+{
+       SKIP_FLAG(has_output);
+       for (int i = 0; i < conn_output_count; i++) {
+               ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_mode(connected_output_array[i], preferred_mode[i]));
+               ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_commit(connected_output_array[i], 0, NULL, NULL));
+               /* TODO: use a commit handler instead of an usleep to wait when
+               * commit will be applied */
+               usleep(20000);
+       }
+}
+
+TEST_F(TDMOutputCommit, DISABLED_OutputWaitVBlank)
+{
+       SKIP_FLAG(has_output);
+}