ut : add testcases

1. add exceptions for checking valid enum values
2. add UTs to check the state and invalid values

Change-Id: I0f7eb1d9f25f2dbdb29cab9b0882487d63a3dba4

diff --git a/include/esplusplayer_capi/display.h b/include/esplusplayer_capi/display.h
index 28693d0..a509f82 100644 (file)
--- a/include/esplusplayer_capi/display.h
+++ b/include/esplusplayer_capi/display.h
@@ -43,7 +43,8 @@ typedef enum {
   ESPLUSPLAYER_DISPLAY_MODE_FULL_SCREEN,
   ESPLUSPLAYER_DISPLAY_MODE_CROPPED_FULL,
   ESPLUSPLAYER_DISPLAY_MODE_ORIGIN_OR_LETTER,
-  ESPLUSPLAYER_DISPLAY_MODE_DST_ROI
+  ESPLUSPLAYER_DISPLAY_MODE_DST_ROI,
+  ESPLUSPLAYER_DISPLAY_MODE_MAX
 } esplusplayer_display_mode;
 
 /**
@@ -53,7 +54,8 @@ typedef enum {
   ESPLUSPLAYER_DISPLAY_TYPE_NONE,
   ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
   ESPLUSPLAYER_DISPLAY_TYPE_EVAS,
-  ESPLUSPLAYER_DISPLAY_TYPE_MIXER
+  ESPLUSPLAYER_DISPLAY_TYPE_MIXER,
+  ESPLUSPLAYER_DISPLAY_TYPE_MAX
 } esplusplayer_display_type;
 
 /**

diff --git a/include/esplusplayer_capi/esplusplayer_capi.h b/include/esplusplayer_capi/esplusplayer_capi.h
index a9584d4..32ba9ad 100644 (file)
--- a/include/esplusplayer_capi/esplusplayer_capi.h
+++ b/include/esplusplayer_capi/esplusplayer_capi.h
@@ -143,7 +143,8 @@ typedef enum {
   /**
    * @description   sorfware codec can only be selected
    */
-  ESPLUSPLAYER_AUDIO_CODEC_TYPE_SW
+  ESPLUSPLAYER_AUDIO_CODEC_TYPE_SW,
+  ESPLUSPLAYER_AUDIO_CODEC_TYPE_MAX
 } esplusplayer_audio_codec_type;
 
 /**
@@ -164,7 +165,8 @@ typedef enum {
   api.
                    esplusplayer_set_display()
   */
-  ESPLUSPLAYER_VIDEO_CODEC_TYPE_HW_N_DECODING
+  ESPLUSPLAYER_VIDEO_CODEC_TYPE_HW_N_DECODING,
+  ESPLUSPLAYER_VIDEO_CODEC_TYPE_MAX
 
 } esplusplayer_video_codec_type;
 /**

diff --git a/include/esplusplayer_capi/submitdatatype.h b/include/esplusplayer_capi/submitdatatype.h
index 0cf9d42..acb80ca 100755 (executable)
--- a/include/esplusplayer_capi/submitdatatype.h
+++ b/include/esplusplayer_capi/submitdatatype.h
@@ -38,6 +38,7 @@ typedef enum {
   ESPLUSPLAYER_SUBMIT_DATA_TYPE_CLEAN_DATA,
   ESPLUSPLAYER_SUBMIT_DATA_TYPE_ENCRYPTED_DATA,
 //  ESPLUSPLAYER_SUBMIT_DATA_TYPE_TRUSTZONE_DATA,
+  ESPLUSPLAYER_SUBMIT_DATA_TYPE_MAX,
 } esplusplayer_submit_data_type;
 
 #ifdef __cplusplus

diff --git a/packaging/esplusplayer.spec b/packaging/esplusplayer.spec
index d4ebb30..35ca39d 100644 (file)
--- a/packaging/esplusplayer.spec
+++ b/packaging/esplusplayer.spec
@@ -2,7 +2,7 @@
 %bcond_without ESPLUSPLAYER_UT
 Name:       esplusplayer
 Summary:    new multimedia streaming player
-Version:    0.0.4
+Version:    0.0.5
 Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0

diff --git a/src/esplusplayer/src/esplusplayer_capi.cpp b/src/esplusplayer/src/esplusplayer_capi.cpp
index 948f2fb..dc5152b 100644 (file)
--- a/src/esplusplayer/src/esplusplayer_capi.cpp
+++ b/src/esplusplayer/src/esplusplayer_capi.cpp
@@ -798,6 +798,8 @@ int esplusplayer_set_display(esplusplayer_handle handle,
                              esplusplayer_display_type type, void* window) {
   LOG_ENTER_P(cast_(handle))
   if (is_null_(handle)) return ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER;
+  if (type < ESPLUSPLAYER_DISPLAY_TYPE_NONE ||
+    type >= ESPLUSPLAYER_DISPLAY_TYPE_MAX) return ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION;
   LOG_INFO_P(cast_(handle), "display type : %d, object : %p",
              static_cast<int>(type), window);
 
@@ -810,6 +812,8 @@ int esplusplayer_set_ecore_display(esplusplayer_handle handle,
                                    int x, int y, int width, int height) {
   LOG_ENTER_P(cast_(handle))
   if (is_null_(handle)) return ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER;
+  if (type < ESPLUSPLAYER_DISPLAY_TYPE_NONE ||
+    type >= ESPLUSPLAYER_DISPLAY_TYPE_MAX) return ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION;
   LOG_INFO_P(cast_(handle), "display type : %d, object : %p",
              static_cast<int>(type), window);
 
@@ -823,6 +827,9 @@ int esplusplayer_set_surface_display(esplusplayer_handle handle,
                                      int width, int height) {
   LOG_ENTER_P(cast_(handle))
   if (is_null_(handle)) return ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER;
+  if (type < ESPLUSPLAYER_DISPLAY_TYPE_NONE ||
+    type >= ESPLUSPLAYER_DISPLAY_TYPE_MAX) return ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION;
+  if (width <= 0 || height <= 0) return ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER;
   LOG_INFO_P(cast_(handle), "display type : %d, object : %u",
              static_cast<int>(type), surface_id);
 
@@ -834,6 +841,8 @@ int esplusplayer_set_display_mode(esplusplayer_handle handle,
                                   esplusplayer_display_mode mode) {
   LOG_ENTER_P(cast_(handle))
   if (is_null_(handle)) return ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER;
+  if (mode < ESPLUSPLAYER_DISPLAY_MODE_LETTER_BOX ||
+    mode >= ESPLUSPLAYER_DISPLAY_MODE_MAX) return ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION;
   LOG_INFO_P(cast_(handle), "display mode : %d", static_cast<int>(mode));
 
   return convert_return_type_(
@@ -844,6 +853,7 @@ int esplusplayer_set_display_roi(esplusplayer_handle handle, int x, int y,
                                  int width, int height) {
   LOG_ENTER_P(cast_(handle))
   if (is_null_(handle)) return ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER;
+  if (width <= 0 || height <= 0) return ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER;
   LOG_INFO_P(cast_(handle), "x : %d, y: %d, width : %d, height : %d", x, y,
              width, height);
 
@@ -903,6 +913,8 @@ int esplusplayer_set_submit_data_type(esplusplayer_handle handle,
                                       esplusplayer_submit_data_type type) {
   LOG_ENTER_P(cast_(handle))
   if (is_null_(handle)) return ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER;
+  if (type < ESPLUSPLAYER_SUBMIT_DATA_TYPE_CLEAN_DATA ||
+    type >= ESPLUSPLAYER_SUBMIT_DATA_TYPE_MAX) return ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION;
   LOG_INFO_P(cast_(handle), "type : %d", type);
   return convert_return_type_(
       cast_(handle)->SetSubmitDataType(static_cast<SubmitDataType>(type)));
@@ -1336,6 +1348,8 @@ int esplusplayer_set_audio_codec_type(esplusplayer_handle handle,
                                       esplusplayer_audio_codec_type type) {
   LOG_ENTER_P(cast_(handle))
   if (is_null_(handle)) return ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER;
+  if (type < ESPLUSPLAYER_AUDIO_CODEC_TYPE_HW ||
+    type >= ESPLUSPLAYER_AUDIO_CODEC_TYPE_MAX) return ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION;
   auto ret =
       cast_(handle)->SetAudioCodecType(static_cast<PlayerAudioCodecType>(type));
   return convert_return_type_(ret);
@@ -1345,6 +1359,8 @@ int esplusplayer_set_video_codec_type(esplusplayer_handle handle,
                                       esplusplayer_video_codec_type type) {
   LOG_ENTER_P(cast_(handle))
   if (is_null_(handle)) return ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER;
+  if (type < ESPLUSPLAYER_VIDEO_CODEC_TYPE_HW ||
+    type >= ESPLUSPLAYER_VIDEO_CODEC_TYPE_MAX) return ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION;
   auto ret =
       cast_(handle)->SetVideoCodecType(static_cast<PlayerVideoCodecType>(type));
   return convert_return_type_(ret);

diff --git a/ut/include/esplusplayer/eseventlistener.hpp b/ut/include/esplusplayer/eseventlistener.hpp
index 36d8d64..1acad46 100644 (file)
--- a/ut/include/esplusplayer/eseventlistener.hpp
+++ b/ut/include/esplusplayer/eseventlistener.hpp
@@ -54,7 +54,7 @@ class EsPlayerEventCallback {
     }
   }
   static void OnError(const esplusplayer_error_type err_code, void* userdata) {
-    std::cout << "OnError" << std::endl;
+    std::cout << "OnError : " << esplusplayer_get_error_string(err_code) << std::endl;
   }
   static void OnResourceConflicted(void* userdata) {
     std::cout << "OnResourceConflicted" << std::endl;

diff --git a/ut/src/esplusplayer/ut_basic.cpp b/ut/src/esplusplayer/ut_basic.cpp
index 36caa4b..b95c333 100644 (file)
--- a/ut/src/esplusplayer/ut_basic.cpp
+++ b/ut/src/esplusplayer/ut_basic.cpp
@@ -103,39 +103,102 @@ class EsBasicTest : public ::testing::TestWithParam<std::string> {
 
 TEST_F(EsTest, vdapi_basic_esplusplayer_create_p_1) {
   esplusplayer_handle esplayer = esplusplayer_create();
-  ASSERT_NE(nullptr, esplayer);
+  ASSERT_TRUE(esplayer);
   ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
 }
 
 TEST_F(EsTest, vdapi_basic_esplusplayer_open_p_1) {
   esplusplayer_handle esplayer = esplusplayer_create();
-  ASSERT_NE(nullptr, esplayer);
+  ASSERT_TRUE(esplayer);
   ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
 }
 
+TEST_F(EsTest, vdapi_basic_esplusplayer_open_n_1) {
+  ASSERT_EQ(esplusplayer_open(nullptr), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 TEST_F(EsTest, vdapi_basic_esplusplayer_close_p_1) {
   esplusplayer_handle esplayer = esplusplayer_create();
-  ASSERT_NE(nullptr, esplayer);
+  ASSERT_TRUE(esplayer);
   ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
 }
 
+TEST_F(EsTest, vdapi_basic_esplusplayer_close_p_2) {
+  esplusplayer_handle esplayer = esplusplayer_create();
+  ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+}
+
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_close_p_3) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+
+  ASSERT_EQ(
+      esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+                               util_.GetWindow()),
+      ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_TRUE(video_reader_->SetStreamInfo(esplayer_));
+  ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
+  ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
+            ESPLUSPLAYER_ERROR_TYPE_NONE);
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  std::cout << "BasicTest, Play, END" << std::endl;
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_close_n_1) {
+  ASSERT_EQ(esplusplayer_close(nullptr), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 TEST_F(EsTest, vdapi_basic_esplusplayer_stop_p_1) {
   esplusplayer_handle esplayer = esplusplayer_create();
-  ASSERT_NE(nullptr, esplayer);
+  ASSERT_TRUE(esplayer);
   ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_stop(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
 }
 
+TEST_F(EsTest, vdapi_basic_esplusplayer_stop_n_1) {
+  ASSERT_EQ(esplusplayer_stop(nullptr), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_stop_n_2) {
+  esplusplayer_handle esplayer = esplusplayer_create();
+  ASSERT_TRUE(esplayer);
+  ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_stop(esplayer), ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION);
+  ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_destroy_p_1) {
+  esplusplayer_handle esplayer = esplusplayer_create();
+  ASSERT_TRUE(esplayer);
+  ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_destroy_n_1) {
+  ASSERT_EQ(esplusplayer_close(nullptr), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_destroy_n_2) {
+  esplusplayer_handle esplayer = esplusplayer_create();
+  ASSERT_TRUE(esplayer);
+  ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_INVALID_STATE);
+}
+
 TEST_F(EsTest, vdapi_basic_esplusplayer_get_error_string_p_1) {
   esplusplayer_handle esplayer = esplusplayer_create();
-  ASSERT_NE(nullptr, esplayer);
+  ASSERT_TRUE(esplayer);
   ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::string error =
       esplusplayer_get_error_string(ESPLUSPLAYER_ERROR_TYPE_NOT_SUPPORTED_FILE);
@@ -146,7 +209,7 @@ TEST_F(EsTest, vdapi_basic_esplusplayer_get_error_string_p_1) {
 
 TEST_F(EsTest, vdapi_basic_esplusplayer_set_video_frame_buffer_type_p_1) {
   esplusplayer_handle esplayer = esplusplayer_create();
-  ASSERT_NE(nullptr, esplayer);
+  ASSERT_TRUE(esplayer);
   ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_set_video_frame_buffer_type(
                 esplayer, ESPLUSPLAYER_DECODED_VIDEO_FRAME_BUFFER_TYPE_NONE),
@@ -166,16 +229,37 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_video_frame_buffer_type_p_2) {
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
 
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(10));
 
   std::cout << "BasicTest, set video frame buffer type, END" << std::endl;
 }
 
+TEST_F(EsTest, vdapi_basic_esplusplayer_set_video_frame_buffer_type_n_1) {
+  esplusplayer_handle esplayer = esplusplayer_create();
+  ASSERT_TRUE(esplayer);
+  ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_video_frame_buffer_type(
+                esplayer, ESPLUSPLAYER_DECODED_VIDEO_FRAME_BUFFER_TYPE_NONE),
+                ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION);
+  ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_set_video_frame_buffer_type_n_2) {
+  esplusplayer_handle esplayer = esplusplayer_create();
+  ASSERT_TRUE(esplayer);
+  ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_video_frame_buffer_type(
+                esplayer, (esplusplayer_decoded_video_frame_buffer_type)10),
+                ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION);
+}
+
 TEST_F(EsTest, vdapi_basic_esplusplayer_set_buffer_size_p_1) {
   esplusplayer_handle esplayer = esplusplayer_create();
-  ASSERT_NE(nullptr, esplayer);
+  ASSERT_TRUE(esplayer);
   ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
   esplusplayer_set_buffer_size(esplayer,
                                ESPLUSPLAYER_BUFFER_AUDIO_MAX_BYTE_SIZE, 10240);
@@ -183,6 +267,42 @@ TEST_F(EsTest, vdapi_basic_esplusplayer_set_buffer_size_p_1) {
   ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
 }
 
+TEST_F(EsTest, vdapi_basic_esplusplayer_set_buffer_size_p_2) {
+  esplusplayer_handle esplayer = esplusplayer_create();
+  ASSERT_TRUE(esplayer);
+  ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  esplusplayer_set_buffer_size(esplayer,
+                               ESPLUSPLAYER_BUFFER_VIDEO_MAX_BYTE_SIZE, 10240);
+  ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_set_buffer_size_p_3) {
+  esplusplayer_handle esplayer = esplusplayer_create();
+  ASSERT_TRUE(esplayer);
+  ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  esplusplayer_set_buffer_size(esplayer,
+                               ESPLUSPLAYER_BUFFER_AUDIO_MAX_TIME_SIZE, 12345);
+  ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_set_buffer_size_p_4) {
+  esplusplayer_handle esplayer = esplusplayer_create();
+  ASSERT_TRUE(esplayer);
+  ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  esplusplayer_set_buffer_size(esplayer,
+                               ESPLUSPLAYER_BUFFER_VIDEO_MIN_TIME_THRESHOLD, 0);
+  ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_set_buffer_size_n_1) {
+  ASSERT_EQ(esplusplayer_set_buffer_size(nullptr,
+                               ESPLUSPLAYER_BUFFER_VIDEO_MIN_BYTE_THRESHOLD, 1),
+                               ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 #ifdef TIZEN_FEATURE_TV
 TEST_F(EsTest, vdapi_basic_esplusplayer_submit_encrypted_packet_p_1) {
   esplusplayer_handle esplayer = NULL;
@@ -191,20 +311,47 @@ TEST_F(EsTest, vdapi_basic_esplusplayer_submit_encrypted_packet_p_1) {
 }
 #endif
 
-TEST_F(EsTest, vdapi_basic_esplusplayer_submit_eos_packet_p_1) {
+TEST_F(EsTest, vdapi_basic_esplusplayer_submit_eos_packet_n_1) {
   esplusplayer_handle esplayer = NULL;
   ASSERT_EQ(
       esplusplayer_submit_eos_packet(esplayer, ESPLUSPLAYER_STREAM_TYPE_VIDEO),
       ESPLUSPLAYER_SUBMIT_STATUS_NOT_PREPARED);
+  ASSERT_EQ(
+      esplusplayer_submit_eos_packet(esplayer, ESPLUSPLAYER_STREAM_TYPE_AUDIO),
+      ESPLUSPLAYER_SUBMIT_STATUS_NOT_PREPARED);
 }
 
-TEST_F(EsTest, vdapi_basic_esplusplayer_decoded_buffer_destroy_p_1) {
+TEST_F(EsTest, vdapi_basic_esplusplayer_submit_eos_packet_n_2) {
+  esplusplayer_handle esplayer = esplusplayer_create();
+  ASSERT_TRUE(esplayer);
+  ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(
+      esplusplayer_submit_eos_packet(esplayer, ESPLUSPLAYER_STREAM_TYPE_VIDEO),
+      ESPLUSPLAYER_SUBMIT_STATUS_INVALID_PACKET);
+  ASSERT_EQ(
+      esplusplayer_submit_eos_packet(esplayer, ESPLUSPLAYER_STREAM_TYPE_AUDIO),
+      ESPLUSPLAYER_SUBMIT_STATUS_INVALID_PACKET);
+  ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_decoded_buffer_destroy_n_1) {
   esplusplayer_handle esplayer = NULL;
   ASSERT_EQ(esplusplayer_decoded_buffer_destroy(esplayer, NULL),
             ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
 }
 
 TEST_F(EsTest, vdapi_basic_esplusplayer_set_unlimited_max_buffer_mode_p_1) {
+  esplusplayer_handle esplayer = esplusplayer_create();
+  ASSERT_TRUE(esplayer);
+  ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_unlimited_max_buffer_mode(esplayer),
+            ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_set_unlimited_max_buffer_mode_n_1) {
   esplusplayer_handle esplayer = NULL;
   ASSERT_EQ(esplusplayer_set_unlimited_max_buffer_mode(esplayer),
             ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
@@ -212,7 +359,7 @@ TEST_F(EsTest, vdapi_basic_esplusplayer_set_unlimited_max_buffer_mode_p_1) {
 
 TEST_F(EsTest, vdapi_basic_esplusplayer_get_state_p_1) {
   esplusplayer_handle esplayer = esplusplayer_create();
-  ASSERT_NE(nullptr, esplayer);
+  ASSERT_TRUE(esplayer);
   ASSERT_EQ(esplusplayer_open(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::cout << "get state" << std::endl;
   esplusplayer_state ret = ESPLUSPLAYER_STATE_NONE;
@@ -220,9 +367,32 @@ TEST_F(EsTest, vdapi_basic_esplusplayer_get_state_p_1) {
   ASSERT_EQ(ret, ESPLUSPLAYER_STATE_IDLE);
   std::cout << "get state" << ret << std::endl;
   ASSERT_EQ(esplusplayer_close(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ret = esplusplayer_get_state(esplayer);
+  ASSERT_EQ(ret, ESPLUSPLAYER_STATE_NONE);
+  std::cout << "get state" << ret << std::endl;
   ASSERT_EQ(esplusplayer_destroy(esplayer), ESPLUSPLAYER_ERROR_TYPE_NONE);
 }
 
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_get_state_p_2) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+
+  ASSERT_EQ(
+      esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+                               util_.GetWindow()),
+      ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_TRUE(video_reader_->SetStreamInfo(esplayer_));
+  ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
+  ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
+            ESPLUSPLAYER_ERROR_TYPE_NONE);
+
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
+
+  esplusplayer_state ret = ESPLUSPLAYER_STATE_NONE;
+  ret = esplusplayer_get_state(esplayer_);
+
+  ASSERT_EQ(ret, ESPLUSPLAYER_STATE_READY);
+}
+
 TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_audio_mute_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(
@@ -233,14 +403,14 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_audio_mute_p_1) {
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_set_audio_mute(esplayer_, true),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(10));
 }
 
-TEST_P(EsBasicTest, vdapi_basic_esplusplayer_close_p_2) {
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_prepare_async_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
 
   ASSERT_EQ(
@@ -252,11 +422,14 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_close_p_2) {
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
 
-  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
+  ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  std::this_thread::sleep_for(std::chrono::seconds(10));
+
   std::cout << "BasicTest, Play, END" << std::endl;
 }
 
-TEST_P(EsBasicTest, vdapi_basic_esplusplayer_prepare_async_p_1) {
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_prepare_async_p_2) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
 
   ASSERT_EQ(
@@ -267,15 +440,41 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_prepare_async_p_1) {
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
 
-  callback_->WaitForPrepareDone();
+  ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
+            ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_prepare_async_n_1) {
+  ASSERT_EQ(esplusplayer_prepare_async(nullptr), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_start_p_1) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+
+  ASSERT_EQ(
+      esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+                               util_.GetWindow()),
+      ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_TRUE(video_reader_->SetStreamInfo(esplayer_));
+  ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
+  ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
+            ESPLUSPLAYER_ERROR_TYPE_NONE);
+
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(10));
 
   std::cout << "BasicTest, Play, END" << std::endl;
 }
 
-TEST_P(EsBasicTest, vdapi_basic_esplusplayer_start_p_1) {
+TEST_F(EsTest, vdapi_basic_esplusplayer_start_n_1) {
+  ASSERT_EQ(esplusplayer_start(nullptr), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_start_n_2) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
 
   ASSERT_EQ(
@@ -287,11 +486,11 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_start_p_1) {
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
 
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(10));
 
-  std::cout << "BasicTest, Play, END" << std::endl;
+  ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION);
 }
 
 TEST_P(EsBasicTest, vdapi_basic_esplusplayer_pause_p_1) {
@@ -305,7 +504,7 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_pause_p_1) {
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(1));
   std::cout << "Pause player" << std::endl;
@@ -314,6 +513,33 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_pause_p_1) {
   std::cout << "BasicTest, Play, END" << std::endl;
 }
 
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_pause_p_3) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+
+  ASSERT_EQ(
+      esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+                               util_.GetWindow()),
+      ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_TRUE(video_reader_->SetStreamInfo(esplayer_));
+  ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
+  ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
+            ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
+  ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+  std::cout << "Pause player" << std::endl;
+  ASSERT_EQ(esplusplayer_pause(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  std::this_thread::sleep_for(std::chrono::seconds(3));
+
+  std::cout << "Pause player" << std::endl;
+  ASSERT_EQ(esplusplayer_pause(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  std::this_thread::sleep_for(std::chrono::seconds(3));
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_pause_n_1) {
+  ASSERT_EQ(esplusplayer_pause(nullptr), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 TEST_P(EsBasicTest, vdapi_basic_esplusplayer_resume_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
 
@@ -325,7 +551,7 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_resume_p_1) {
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(1));
   std::cout << "Pause player" << std::endl;
@@ -337,7 +563,11 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_resume_p_1) {
   std::cout << "BasicTest, Play, END" << std::endl;
 }
 
-TEST_P(EsBasicTest, vdapi_basic_esplusplayer_deactive_p_1) {
+TEST_F(EsTest, vdapi_basic_esplusplayer_resume_n_1) {
+  ASSERT_EQ(esplusplayer_resume(nullptr), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_deactivate_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
 
   ASSERT_EQ(
@@ -348,7 +578,7 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_deactive_p_1) {
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(1));
   ASSERT_EQ(esplusplayer_deactivate(esplayer_, ESPLUSPLAYER_STREAM_TYPE_AUDIO),
@@ -356,9 +586,35 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_deactive_p_1) {
   ASSERT_EQ(esplusplayer_deactivate(esplayer_, ESPLUSPLAYER_STREAM_TYPE_VIDEO),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
 }
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_deactivate_n_1) {
+  ASSERT_EQ(esplusplayer_deactivate(nullptr, ESPLUSPLAYER_STREAM_TYPE_AUDIO),
+    ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+  ASSERT_EQ(esplusplayer_deactivate(nullptr, ESPLUSPLAYER_STREAM_TYPE_VIDEO),
+    ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_deactivate_n_2) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+
+  ASSERT_EQ(
+      esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+                               util_.GetWindow()),
+      ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_TRUE(video_reader_->SetStreamInfo(esplayer_));
+  ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
+  ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
+            ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
+  ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+  ASSERT_EQ(esplusplayer_deactivate(esplayer_,
+    (esplusplayer_stream_type)((int)ESPLUSPLAYER_STREAM_TYPE_MAX + 1)),
+    ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION);
+}
 #if 0
 
-TEST_P(EsBasicTest, vdapi_basic_esplusplayer_active_p_1) {
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_activate_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
 
   ASSERT_EQ(
@@ -399,21 +655,27 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_get_playing_time_p_1) {
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(1));
   uint64_t cur_time1 = 0;
   uint64_t cur_time2 = 0;
   ASSERT_EQ(esplusplayer_get_playing_time(esplayer_, &cur_time1),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  std::cout << "current time is" << cur_time1 << std::endl;
+  std::cout << "current time is " << cur_time1 << std::endl;
   ASSERT_EQ(esplusplayer_get_playing_time(esplayer_, &cur_time2),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  std::cout << "current time is" << cur_time2 << std::endl;
+  std::cout << "current time is " << cur_time2 << std::endl;
   ASSERT_LE(cur_time1, cur_time2);
   std::this_thread::sleep_for(std::chrono::seconds(5));
 }
 
+TEST_F(EsTest, vdapi_basic_esplusplayer_get_playing_time_n_1) {
+  uint64_t cur_time = 0;
+  ASSERT_EQ(esplusplayer_get_playing_time(nullptr, &cur_time),
+    ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 TEST_P(EsBasicTest, vdapi_basic_esplusplayer_seek_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
 
@@ -425,7 +687,7 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_seek_p_1) {
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(1));
   ASSERT_EQ(esplusplayer_seek(esplayer_, 0), ESPLUSPLAYER_ERROR_TYPE_NONE);
@@ -433,6 +695,43 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_seek_p_1) {
   std::cout << "BasicTest, Play, END" << std::endl;
 }
 
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_seek_p_2) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+
+  ASSERT_EQ(
+      esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+                               util_.GetWindow()),
+      ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_TRUE(video_reader_->SetStreamInfo(esplayer_));
+  ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
+  ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
+            ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
+  ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+  ASSERT_EQ(esplusplayer_pause(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+
+  ASSERT_EQ(esplusplayer_seek(esplayer_, 1000), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  std::this_thread::sleep_for(std::chrono::seconds(5));
+  uint64_t cur_time = 0;
+  ASSERT_EQ(esplusplayer_get_playing_time(esplayer_, &cur_time),
+            ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(cur_time, 1000);
+  std::cout << "current time is " << cur_time << std::endl;
+
+  ASSERT_EQ(esplusplayer_seek(esplayer_, 5000), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  std::this_thread::sleep_for(std::chrono::seconds(5));
+  ASSERT_EQ(esplusplayer_get_playing_time(esplayer_, &cur_time),
+            ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(cur_time, 5000);
+  std::cout << "current time is " << cur_time << std::endl;
+}
+
+TEST_F(EsTest, vdapi_basic_esplusplayer_seek_n_1) {
+  ASSERT_EQ(esplusplayer_seek(nullptr, 0), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_playback_rate_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
 
@@ -444,7 +743,7 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_playback_rate_p_1) {
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(1));
   ASSERT_EQ(esplusplayer_set_playback_rate(esplayer_, 2.0, true),
@@ -453,6 +752,11 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_playback_rate_p_1) {
   std::cout << "BasicTest, Play, END" << std::endl;
 }
 
+TEST_F(EsTest, vdapi_basic_esplusplayer_set_playback_rate_n_1) {
+  ASSERT_EQ(esplusplayer_set_playback_rate(nullptr, 1.0, true),
+    ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 TEST_P(EsBasicTest, vdapi_basic_esplusplayer_flush_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(
@@ -463,7 +767,7 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_flush_p_1) {
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(1));
   ASSERT_EQ(esplusplayer_flush(esplayer_, ESPLUSPLAYER_STREAM_TYPE_AUDIO),
@@ -475,6 +779,13 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_flush_p_1) {
   std::cout << "BasicTest, Play, END" << std::endl;
 }
 
+TEST_F(EsTest, vdapi_basic_esplusplayer_flush_n_1) {
+  ASSERT_EQ(esplusplayer_flush(nullptr, ESPLUSPLAYER_STREAM_TYPE_AUDIO),
+    ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+  ASSERT_EQ(esplusplayer_flush(nullptr, ESPLUSPLAYER_STREAM_TYPE_VIDEO),
+    ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_volume_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
 
@@ -486,7 +797,7 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_volume_p_1) {
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   int vol = 80;
   int vol1 = 0;
   ASSERT_EQ(esplusplayer_set_volume(esplayer_, vol),
@@ -499,6 +810,10 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_volume_p_1) {
   std::cout << "BasicTest, Play, END" << std::endl;
 }
 
+TEST_F(EsTest, vdapi_basic_esplusplayer_set_volume_n_1) {
+  ASSERT_EQ(esplusplayer_set_volume(nullptr, 0), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 TEST_P(EsBasicTest, vdapi_basic_esplusplayer_get_volume_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
 
@@ -510,7 +825,7 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_get_volume_p_1) {
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   int vol = 80;
   int vol1 = 0;
   ASSERT_EQ(esplusplayer_set_volume(esplayer_, vol),
@@ -523,6 +838,11 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_get_volume_p_1) {
   std::cout << "BasicTest, Play, END" << std::endl;
 }
 
+TEST_F(EsTest, vdapi_basic_esplusplayer_get_volume_n_1) {
+  int vol = 0;
+  ASSERT_EQ(esplusplayer_get_volume(nullptr, &vol), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_submit_data_type_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
 
@@ -537,50 +857,88 @@ TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_submit_data_type_p_1) {
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(3));
 }
 
+TEST_F(EsTest, vdapi_basic_esplusplayer_set_submit_data_type_n_1) {
+  ASSERT_EQ(esplusplayer_set_submit_data_type(
+    nullptr, ESPLUSPLAYER_SUBMIT_DATA_TYPE_CLEAN_DATA),
+    ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_submit_data_type_n_2) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_submit_data_type(
+    esplayer_, (esplusplayer_submit_data_type)10),
+    ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION);
+}
+
 TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_video_codec_type_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
 
-  ASSERT_EQ(
-      esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
-                               util_.GetWindow()),
-      ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+    util_.GetWindow()), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_set_video_codec_type(esplayer_,
-                                              ESPLUSPLAYER_VIDEO_CODEC_TYPE_HW),
-            ESPLUSPLAYER_ERROR_TYPE_NONE);
+    ESPLUSPLAYER_VIDEO_CODEC_TYPE_HW),
+    ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_TRUE(video_reader_->SetStreamInfo(esplayer_));
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  callback_->WaitForPrepareDone();
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(3));
   std::cout << "BasicTest, Play, END" << std::endl;
 }
 
+TEST_F(EsTest, vdapi_basic_esplusplayer_set_video_codec_type_n_1) {
+  ASSERT_EQ(esplusplayer_set_video_codec_type(nullptr,
+    ESPLUSPLAYER_VIDEO_CODEC_TYPE_HW),
+    ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_video_codec_type_n_2) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+    util_.GetWindow()), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_video_codec_type(esplayer_,
+    (esplusplayer_video_codec_type)10), ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION);
+}
+
 TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_audio_codec_type_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
 
-  ASSERT_EQ(
-      esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
-                               util_.GetWindow()),
-      ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+    util_.GetWindow()), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_set_audio_codec_type(esplayer_,
-                                              ESPLUSPLAYER_AUDIO_CODEC_TYPE_HW),
-            ESPLUSPLAYER_ERROR_TYPE_NONE);
+    ESPLUSPLAYER_AUDIO_CODEC_TYPE_HW),
+    ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_TRUE(video_reader_->SetStreamInfo(esplayer_));
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_),
-            ESPLUSPLAYER_ERROR_TYPE_NONE);
-  callback_->WaitForPrepareDone();
+    ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_TRUE(callback_->WaitForPrepareDone());
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(3));
   std::cout << "BasicTest, Play, END" << std::endl;
 }
 
+TEST_F(EsTest, vdapi_basic_esplusplayer_set_audio_codec_type_n_1) {
+  ASSERT_EQ(esplusplayer_set_audio_codec_type(nullptr,
+    ESPLUSPLAYER_AUDIO_CODEC_TYPE_HW),
+    ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+#if 0
+// there is no exception handling in API
+TEST_P(EsBasicTest, vdapi_basic_esplusplayer_set_audio_codec_type_n_2) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+    util_.GetWindow()), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_audio_codec_type(esplayer_,
+    (esplusplayer_audio_codec_type)10), ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION);
+}
+#endif
 INSTANTIATE_TEST_CASE_P(ESPP_Basic, EsBasicTest,
                         ::testing::ValuesIn(es_tc::tc_list));

diff --git a/ut/src/esplusplayer/ut_display.cpp b/ut/src/esplusplayer/ut_display.cpp
index 79132b3..46dacdb 100755 (executable)
--- a/ut/src/esplusplayer/ut_display.cpp
+++ b/ut/src/esplusplayer/ut_display.cpp
@@ -80,7 +80,10 @@ class EsDisplayTest : public ::testing::TestWithParam<std::string> {
 
   virtual void TearDown() override {
     if (nullptr != esplayer_) {
-      ASSERT_EQ(esplusplayer_stop(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+      esplusplayer_state state = esplusplayer_get_state(esplayer_);
+      if (state != ESPLUSPLAYER_STATE_NONE) {
+        ASSERT_EQ(esplusplayer_stop(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+      }
       ASSERT_EQ(esplusplayer_close(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
     }
     delete callback_;
@@ -112,6 +115,21 @@ TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_p_1) {
       ESPLUSPLAYER_ERROR_TYPE_NONE);
 }
 
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_n_1) {
+  ASSERT_EQ(
+      esplusplayer_set_display(nullptr, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+                               util_.GetWindow()),
+      ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_n_2) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(
+      esplusplayer_set_display(esplayer_, (esplusplayer_display_type)ESPLUSPLAYER_DISPLAY_TYPE_MAX,
+                               util_.GetWindow()),
+      ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION);
+}
+
 TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_ecore_display_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_set_ecore_display(
@@ -120,6 +138,21 @@ TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_ecore_display_p_1) {
             ESPLUSPLAYER_ERROR_TYPE_NONE);
 }
 
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_ecore_display_n_1) {
+  ASSERT_EQ(esplusplayer_set_ecore_display(
+                nullptr, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+                util_.EcoreWindow(), 0, 0, 1920, 1080),
+            ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_ecore_display_n_2) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_ecore_display(
+                esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_MAX,
+                util_.EcoreWindow(), 0, 0, 1920, 1080),
+      ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION);
+}
+
 TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_surface_display_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   unsigned int surfaceid = 1;
@@ -129,6 +162,31 @@ TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_surface_display_p_1) {
             ESPLUSPLAYER_ERROR_TYPE_NONE);
 }
 
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_surface_display_n_1) {
+  ASSERT_EQ(esplusplayer_set_surface_display(nullptr,
+                                             ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+                                             0, 0, 0, 1080, 720),
+            ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_surface_display_n_2) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  unsigned int surfaceid = 1;
+  ASSERT_EQ(esplusplayer_set_surface_display(esplayer_,
+                                             ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+                                             surfaceid, 0, 0, -1, -1),
+            ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_surface_display_n_3) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  unsigned int surfaceid = 1;
+  ASSERT_EQ(esplusplayer_set_surface_display(esplayer_,
+                                             (esplusplayer_display_type)-1,
+                                             surfaceid, 0, 0, 1920, 1080),
+            ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION);
+}
+
 TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_mode_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(esplusplayer_set_display_mode(esplayer_,
@@ -136,6 +194,19 @@ TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_mode_p_1) {
             ESPLUSPLAYER_ERROR_TYPE_NONE);
 }
 
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_mode_n_1) {
+  ASSERT_EQ(esplusplayer_set_display_mode(nullptr,
+                                             ESPLUSPLAYER_DISPLAY_MODE_CROPPED_FULL),
+            ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_mode_n_2) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_display_mode(esplayer_,
+                                             (esplusplayer_display_mode)100),
+            ESPLUSPLAYER_ERROR_TYPE_INVALID_OPERATION);
+}
+
 TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_roi_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(
@@ -145,7 +216,7 @@ TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_roi_p_1) {
   ASSERT_EQ(esplusplayer_set_display_mode(esplayer_,
                                              ESPLUSPLAYER_DISPLAY_MODE_DST_ROI),
             ESPLUSPLAYER_ERROR_TYPE_NONE);
-  ASSERT_EQ(esplusplayer_set_display_roi(esplayer_,0,0,600,500),ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_display_roi(esplayer_, 0, 0, 600, 500), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_TRUE(video_reader_->SetStreamInfo(esplayer_));
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
@@ -155,13 +226,31 @@ TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_roi_p_1) {
   std::this_thread::sleep_for(std::chrono::seconds(5));
 }
 
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_roi_n_1) {
+  ASSERT_EQ(esplusplayer_set_display_roi(nullptr, 0, 0, 600, 500),
+    ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_roi_n_2) {
+  ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(
+      esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
+                               util_.GetWindow()),
+      ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_display_mode(esplayer_,
+                                             ESPLUSPLAYER_DISPLAY_MODE_DST_ROI),
+            ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_display_roi(esplayer_, 0, 0, 1, -10),
+    ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_visible_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(
       esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
                                util_.GetWindow()),
       ESPLUSPLAYER_ERROR_TYPE_NONE);
-  ASSERT_EQ(esplusplayer_set_display_visible(esplayer_,false),ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_display_visible(esplayer_, false), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_TRUE(video_reader_->SetStreamInfo(esplayer_));
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
@@ -171,13 +260,17 @@ TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_visible_p_1) {
   std::this_thread::sleep_for(std::chrono::seconds(5));
 }
 
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_visible_n_1) {
+  ASSERT_EQ(esplusplayer_set_display_visible(nullptr, false), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_video_roi_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(
       esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
                                util_.GetWindow()),
       ESPLUSPLAYER_ERROR_TYPE_NONE);
-  ASSERT_EQ(esplusplayer_set_video_roi(esplayer_,0,0,0.5,0.5),ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_video_roi(esplayer_, 0, 0, 0.5, 0.5), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_TRUE(video_reader_->SetStreamInfo(esplayer_));
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
@@ -187,13 +280,18 @@ TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_video_roi_p_1) {
   std::this_thread::sleep_for(std::chrono::seconds(5));
 }
 
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_video_roi_n_1) {
+  ASSERT_EQ(esplusplayer_set_video_roi(nullptr, 0, 0, 0.5, 0.5), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_rotation_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(
       esplusplayer_set_display(esplayer_, ESPLUSPLAYER_DISPLAY_TYPE_OVERLAY,
                                util_.GetWindow()),
       ESPLUSPLAYER_ERROR_TYPE_NONE);
-  ASSERT_EQ(esplusplayer_set_display_rotation(esplayer_,ESPLUSPLAYER_DISPLAY_ROTATION_TYPE_90),ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_display_rotation(esplayer_,
+    ESPLUSPLAYER_DISPLAY_ROTATION_TYPE_90), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_TRUE(video_reader_->SetStreamInfo(esplayer_));
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
@@ -203,6 +301,11 @@ TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_rotation_p_1) {
   std::this_thread::sleep_for(std::chrono::seconds(5));
 }
 
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_set_display_rotation_n_1) {
+  ASSERT_EQ(esplusplayer_set_display_rotation(nullptr,
+    ESPLUSPLAYER_DISPLAY_ROTATION_TYPE_270), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 TEST_P(EsDisplayTest, vdapi_display_esplusplayer_get_display_rotation_p_1) {
   ASSERT_EQ(esplusplayer_open(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(
@@ -211,16 +314,22 @@ TEST_P(EsDisplayTest, vdapi_display_esplusplayer_get_display_rotation_p_1) {
       ESPLUSPLAYER_ERROR_TYPE_NONE);
   esplusplayer_display_rotation_type rotation_set = ESPLUSPLAYER_DISPLAY_ROTATION_TYPE_90;
   esplusplayer_display_rotation_type rotation_get = ESPLUSPLAYER_DISPLAY_ROTATION_TYPE_NONE;
-  ASSERT_EQ(esplusplayer_set_display_rotation(esplayer_,rotation_set),ESPLUSPLAYER_ERROR_TYPE_NONE);
+  ASSERT_EQ(esplusplayer_set_display_rotation(esplayer_, rotation_set), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_TRUE(video_reader_->SetStreamInfo(esplayer_));
   ASSERT_TRUE(audio_reader_->SetStreamInfo(esplayer_));
   ASSERT_EQ(esplusplayer_prepare_async(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
-  esplusplayer_get_display_rotation(esplayer_,&rotation_get);
+  ASSERT_EQ(esplusplayer_get_display_rotation(esplayer_, &rotation_get), ESPLUSPLAYER_ERROR_TYPE_NONE);
   ASSERT_EQ(rotation_set,rotation_get);
   callback_->WaitForPrepareDone();
   ASSERT_EQ(esplusplayer_start(esplayer_), ESPLUSPLAYER_ERROR_TYPE_NONE);
   std::this_thread::sleep_for(std::chrono::seconds(5));
 }
 
+TEST_P(EsDisplayTest, vdapi_display_esplusplayer_get_display_rotation_n_1) {
+  esplusplayer_display_rotation_type rotation_get = ESPLUSPLAYER_DISPLAY_ROTATION_TYPE_NONE;
+  ASSERT_EQ(esplusplayer_get_display_rotation(nullptr,
+    &rotation_get), ESPLUSPLAYER_ERROR_TYPE_INVALID_PARAMETER);
+}
+
 INSTANTIATE_TEST_CASE_P(ESPP_Display, EsDisplayTest,
                         ::testing::ValuesIn(es_tc_diaplay::tc_list));