TC/unit/utc_drmtrustedclient_drm_trusted_open_decrypt_session_func.c

   1 /*\r
   2  * drm-trusted-client TCs\r
   3  *\r
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
   5  *\r
   6  * Contact: Hakjoo Ko <hakjoo.ko@samsung.com>\r
   7  *                      Mahendra Kumar Prajapat <mahendra.p@samsung.com>\r
   8  *                      Harsha Shekar <h.shekar@samsung.com>\r
   9  *\r
  10  *\r
  11  * Licensed under the Apache License, Version 2.0 (the "License");\r
  12  * you may not use this file except in compliance with the License.\r
  13  * You may obtain a copy of the License at\r
  14  *\r
  15  * http://www.apache.org/licenses/LICENSE-2.0\r
  16  *\r
  17  * Unless required by applicable law or agreed to in writing, software\r
  18  * distributed under the License is distributed on an "AS IS" BASIS,\r
  19  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  20  * See the License for the specific language governing permissions and\r
  21  * limitations under the License.\r
  22  *\r
  23  */\r
  24 \r
  25 /**\r
  26  * @file                utc_drmtrustedclient_drm_trusted_open_decrypt_session_func.c\r
  27  * @brief       TETware unit testing functions for drm_trusted_open_decrypt_session.\r
  28  * @author      Harsha Shekar (h.shekar@samsung.com)\r
  29  * @version     0.1\r
  30  * @history     0.1: Initial draft\r
  31  */\r
  32 \r
  33 #include <tet_api.h>\r
  34 #include "drm_test_contents_def.h"\r
  35 #include <time.h>\r
  36 #include <sys/types.h>\r
  37 #include <sys/stat.h>\r
  38 \r
  39 //#define MAX_OUT_BUFFER_LEN (1024 * 1024)\r
  40 #define MAX_OUT_BUFFER_LEN (10 * 1024)\r
  41 \r
  42 static void startup(void);\r
  43 static void cleanup(void);\r
  44 \r
  45 void (*tet_startup)(void) = startup;\r
  46 void (*tet_cleanup)(void) = cleanup;\r
  47 \r
  48 static void utc_drmtrustedclient_drm_trusted_open_decrypt_session_func_01(void);\r
  49 static void utc_drmtrustedclient_drm_trusted_open_decrypt_session_func_02(void);\r
  50 static void utc_drmtrustedclient_drm_trusted_open_decrypt_session_func_03(void);\r
  51 static void utc_drmtrustedclient_drm_trusted_open_decrypt_session_func_04(void);\r
  52 \r
  53 enum {\r
  54         POSITIVE_TC_IDX = 0x01,\r
  55         NEGATIVE_TC_IDX,\r
  56 };\r
  57 \r
  58 \r
  59 struct tet_testlist tet_testlist[] = {\r
  60                 { utc_drmtrustedclient_drm_trusted_open_decrypt_session_func_01, POSITIVE_TC_IDX },\r
  61                 { utc_drmtrustedclient_drm_trusted_open_decrypt_session_func_02, NEGATIVE_TC_IDX },\r
  62                 { utc_drmtrustedclient_drm_trusted_open_decrypt_session_func_03, NEGATIVE_TC_IDX },\r
  63                 { utc_drmtrustedclient_drm_trusted_open_decrypt_session_func_04, NEGATIVE_TC_IDX },\r
  64                 { NULL, 0 }\r
  65 };\r
  66 \r
  67 \r
  68 static void startup(void) {\r
  69         tet_infoline("drm_trusted_open_decrypt_session:Test started");\r
  70 }\r
  71 \r
  72 static void cleanup(void) {\r
  73         tet_infoline("drm_trusted_open_decrypt_session:Test completed");\r
  74 }\r
  75 \r
  76 void test_drm_trusted_operation_cb(\r
  77                 drm_trusted_user_operation_info_s *operation_info, void *output_data)\r
  78 {\r
  79         tet_printf("Callback Hit:test_drm_trusted_operation_cb");\r
  80         tet_printf("operation_status=%d", operation_info->operation_status);\r
  81         tet_printf("operation_type=%d", operation_info->operation_type);\r
  82 }\r
  83 \r
  84 /**\r
  85  * @brief Positive test case of drm_trusted_open_decrypt_session()\r
  86  */\r
  87 static void utc_drmtrustedclient_drm_trusted_open_decrypt_session_func_01(void)\r
  88 {\r
  89         /* Initialize variables & structures */\r
  90         drm_trusted_open_decrypt_info_s open_input_data;\r
  91         drm_trusted_open_decrypt_resp_data_s open_output_data;\r
  92         drm_trusted_seek_decrypt_info_s seek_input_data;\r
  93         drm_trusted_tell_decrypt_resp_data_s tell_output_data;\r
  94         drm_trusted_set_consumption_state_info_s state_input_data;\r
  95         drm_trusted_payload_info_s read_input_data;\r
  96         drm_trusted_read_decrypt_resp_data_s read_output_data;\r
  97         unsigned char *out_buffer = NULL;\r
  98 \r
  99         DRM_DECRYPT_HANDLE pHandle = NULL;\r
 100         int ret = -1;\r
 101 \r
 102         /* memset the structures */\r
 103         memset(&open_input_data, 0x0, sizeof(drm_trusted_open_decrypt_info_s));\r
 104         memset(&open_output_data, 0x0, sizeof(drm_trusted_open_decrypt_resp_data_s));\r
 105         memset(&seek_input_data, 0x0, sizeof(drm_trusted_seek_decrypt_info_s));\r
 106         memset(&tell_output_data, 0x0, sizeof(drm_trusted_tell_decrypt_resp_data_s));\r
 107         memset(&state_input_data, 0x0, sizeof(drm_trusted_set_consumption_state_info_s));\r
 108         memset(&read_input_data, 0x0, sizeof(drm_trusted_payload_info_s));\r
 109         memset(&read_output_data, 0x0, sizeof(drm_trusted_read_decrypt_resp_data_s));\r
 110 \r
 111         /* Enter Appropriate Inputs */\r
 112         memcpy(open_input_data.filePath, FILE_PATH_VALID_FILE_OMA_2,\r
 113                         strlen(FILE_PATH_VALID_FILE_OMA_2));\r
 114         open_input_data.file_type = DRM_TRUSTED_TYPE_OMA_V1;\r
 115         open_input_data.permission = DRM_TRUSTED_PERMISSION_TYPE_PLAY;\r
 116 \r
 117         /* Open Decrypt Session */\r
 118         ret = drm_trusted_open_decrypt_session(&open_input_data, &open_output_data,\r
 119                         &pHandle);\r
 120 \r
 121         tet_printf("drm_trusted_open_decrypt_session ret = 0x%x", ret);\r
 122 \r
 123         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 124                 tet_printf("open_decrypt_session success");\r
 125         } else {\r
 126                 tet_printf("open_decrypt_session FAILED: ret=0x%x", ret);\r
 127                 tet_result(TET_FAIL);\r
 128         }\r
 129 \r
 130         seek_input_data.offset = 0;\r
 131         seek_input_data.seek_mode = DRM_SEEK_END; /* Set cursor to end */\r
 132 \r
 133         ret = drm_trusted_seek_decrypt_session(pHandle, &seek_input_data);\r
 134 \r
 135         tet_printf("drm_trusted_seek_decrypt_session ret = 0x%x", ret);\r
 136 \r
 137         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 138                 tet_printf("seek_decrypt_session success");\r
 139         } else {\r
 140                 tet_printf("seek_decrypt_session FAILED: ret=0x%x", ret);\r
 141                 tet_result(TET_FAIL);\r
 142         }\r
 143 \r
 144         ret = drm_trusted_tell_decrypt_session(pHandle, &tell_output_data);\r
 145         tet_printf("ret = 0x%x", ret);\r
 146 \r
 147         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 148                 tet_printf("tell_decrypt_session success");\r
 149         } else {\r
 150                 tet_printf("tell_decrypt_session FAILED: ret=0x%x", ret);\r
 151                 tet_result(TET_FAIL);\r
 152         }\r
 153         tet_printf("file-size = %u",tell_output_data.offset);\r
 154 \r
 155         seek_input_data.offset = 0;\r
 156         seek_input_data.seek_mode = DRM_SEEK_SET; /* Set cursor to START */\r
 157 \r
 158         ret = drm_trusted_seek_decrypt_session(pHandle, &seek_input_data);\r
 159         tet_printf("drm_trusted_seek_decrypt_session ret = 0x%x", ret);\r
 160 \r
 161         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 162                 tet_printf("seek_decrypt_session success");\r
 163         } else {\r
 164                 tet_printf("seek_decrypt_session FAILED: ret=0x%x", ret);\r
 165                 tet_result(TET_FAIL);\r
 166         }\r
 167 \r
 168         state_input_data.state = DRM_CONSUMPTION_STARTED;\r
 169         ret = drm_trusted_set_decrypt_state(pHandle, &state_input_data);\r
 170         tet_printf("drm_trusted_set_decrypt_state START ret = 0x%x", ret);\r
 171         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 172                 tet_printf("set_decrypt_state success");\r
 173         } else {\r
 174                 tet_printf("set_decrypt_state FAILED: ret=0x%x", ret);\r
 175                 tet_result(TET_FAIL);\r
 176         }\r
 177 \r
 178         /* Allocate memory for Out Buffer */\r
 179         out_buffer = (unsigned char*) malloc(MAX_OUT_BUFFER_LEN);\r
 180         if (!out_buffer) {\r
 181                 tet_printf("Memory Allocation Error!!!");\r
 182                 tet_result(TET_FAIL);\r
 183         }\r
 184 \r
 185         read_input_data.payload_data = out_buffer;\r
 186         read_input_data.payload_data_len = (unsigned int) MAX_OUT_BUFFER_LEN;\r
 187 \r
 188         /* Handle READ / DECRYPT operation */\r
 189         ret = drm_trusted_read_decrypt_session(pHandle, &read_input_data,\r
 190                         &read_output_data);\r
 191         tet_printf("drm_trusted_read_decrypt_session ret = 0x%x", ret);\r
 192         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 193                 tet_printf("read_decrypt_session success");\r
 194         } else {\r
 195                 tet_printf("read_decrypt_session FAILED: ret=0x%x", ret);\r
 196                 tet_result(TET_FAIL);\r
 197         }\r
 198 \r
 199         state_input_data.state = DRM_CONSUMPTION_STOPPED;\r
 200         ret = drm_trusted_set_decrypt_state(pHandle, &state_input_data);\r
 201         tet_printf("drm_trusted_set_decrypt_state STOPT ret = 0x%x", ret);\r
 202         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 203                 tet_printf("set_decrypt_state success");\r
 204         } else {\r
 205                 tet_printf("set_decrypt_state FAILED: ret=0x%x", ret);\r
 206                 tet_result(TET_FAIL);\r
 207         }\r
 208 \r
 209         if (out_buffer)\r
 210                 free (out_buffer);\r
 211 \r
 212         ret = drm_trusted_close_decrypt_session(&pHandle);\r
 213         tet_printf("drm_trusted_close_decrypt_session ret = 0x%x", ret);\r
 214         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 215                 tet_printf("close_decrypt_session success");\r
 216                 tet_result(TET_PASS);\r
 217         } else {\r
 218                 tet_printf("close_decrypt_session FAILED: ret=0x%x", ret);\r
 219                 tet_result(TET_FAIL);\r
 220         }\r
 221 }\r
 222 \r
 223 /**\r
 224  * @brief negative test case of drm_trusted_open_decrypt_session()\r
 225  * here open_input_data is NULL\r
 226  */\r
 227 static void utc_drmtrustedclient_drm_trusted_open_decrypt_session_func_02(void)\r
 228 {\r
 229         /* Initialize variables & structures */\r
 230         drm_trusted_open_decrypt_info_s open_input_data;\r
 231         drm_trusted_open_decrypt_resp_data_s open_output_data;\r
 232 \r
 233         DRM_DECRYPT_HANDLE pHandle = NULL;\r
 234         int ret = -1;\r
 235         //drm_trusted_permission_type_e perm_type;\r
 236 \r
 237         /* memset the structures */\r
 238         memset(&open_input_data, 0x0, sizeof(drm_trusted_open_decrypt_info_s));\r
 239         memset(&open_output_data, 0x0, sizeof(drm_trusted_open_decrypt_resp_data_s));\r
 240         memcpy(open_input_data.filePath, FILE_PATH_VALID_FILE_OMA_2,\r
 241                                 strlen(FILE_PATH_VALID_FILE_OMA_2));\r
 242         open_input_data.file_type = DRM_TRUSTED_TYPE_OMA_V1;\r
 243         open_input_data.permission = DRM_TRUSTED_PERMISSION_TYPE_ANY;\r
 244         //open_input_data.operation_callback.callback = test_drm_trusted_operation_cb;\r
 245         /* Open Decrypt Session*/\r
 246         ret = drm_trusted_open_decrypt_session(NULL, &open_output_data, &pHandle);\r
 247         tet_printf("ret = 0x%x", ret);\r
 248         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 249                 tet_printf("open_decrypt_session Success");\r
 250                 tet_result(TET_FAIL);\r
 251         } else {\r
 252                 tet_printf("open_decrypt_session FAILED: ret=0x%x", ret);\r
 253                 tet_result(TET_PASS);\r
 254         }\r
 255 }\r
 256 \r
 257 /**\r
 258  * @brief negative test case of drm_trusted_open_decrypt_session()\r
 259  * here open_output_data is NULL\r
 260  */\r
 261 static void utc_drmtrustedclient_drm_trusted_open_decrypt_session_func_03(void)\r
 262 {\r
 263         /* Initialize variables & structures */\r
 264         drm_trusted_open_decrypt_info_s open_input_data;\r
 265         drm_trusted_open_decrypt_resp_data_s open_output_data;\r
 266 \r
 267         DRM_DECRYPT_HANDLE pHandle = NULL;\r
 268         int ret = -1;\r
 269         //drm_trusted_permission_type_e perm_type;\r
 270 \r
 271         /* memset the structures */\r
 272         memset(&open_input_data, 0x0, sizeof(drm_trusted_open_decrypt_info_s));\r
 273         memset(&open_output_data, 0x0, sizeof(drm_trusted_open_decrypt_resp_data_s));\r
 274         memcpy(open_input_data.filePath, FILE_PATH_VALID_FILE_OMA_2,\r
 275                                 strlen(FILE_PATH_VALID_FILE_OMA_2));\r
 276         open_input_data.file_type = DRM_TRUSTED_TYPE_OMA_V1;\r
 277         open_input_data.permission = DRM_TRUSTED_PERMISSION_TYPE_ANY;\r
 278         //open_input_data.operation_callback.callback = test_drm_trusted_operation_cb;\r
 279         /* Open Decrypt Session*/\r
 280         ret = drm_trusted_open_decrypt_session(&open_input_data, NULL, &pHandle);\r
 281         tet_printf("ret = 0x%x", ret);\r
 282         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 283                 tet_printf("open_decrypt_session Success");\r
 284                 tet_result(TET_FAIL);\r
 285         } else {\r
 286                 tet_printf("open_decrypt_session FAILED: ret=0x%x", ret);\r
 287                 tet_result(TET_PASS);\r
 288         }\r
 289 }\r
 290 \r
 291 /**\r
 292  * @brief negative test case of drm_trusted_open_decrypt_session()\r
 293  * here Phandle is NULL\r
 294  */\r
 295 static void utc_drmtrustedclient_drm_trusted_open_decrypt_session_func_04(void)\r
 296 {\r
 297         /* Initialize variables & structures */\r
 298         drm_trusted_open_decrypt_info_s open_input_data;\r
 299         drm_trusted_open_decrypt_resp_data_s open_output_data;\r
 300 \r
 301         //DRM_DECRYPT_HANDLE pHandle = NULL;\r
 302         int ret = -1;\r
 303         //drm_trusted_permission_type_e perm_type;\r
 304 \r
 305         /* memset the structures */\r
 306         memset(&open_input_data, 0x0, sizeof(drm_trusted_open_decrypt_info_s));\r
 307         memset(&open_output_data, 0x0, sizeof(drm_trusted_open_decrypt_resp_data_s));\r
 308         memcpy(open_input_data.filePath, FILE_PATH_VALID_FILE_OMA_2,\r
 309                                 strlen(FILE_PATH_VALID_FILE_OMA_2));\r
 310         open_input_data.file_type = DRM_TRUSTED_TYPE_OMA_V1;\r
 311         open_input_data.permission = DRM_TRUSTED_PERMISSION_TYPE_ANY;\r
 312         //open_input_data.operation_callback.callback = test_drm_trusted_operation_cb;\r
 313         /* Open Decrypt Session*/\r
 314         ret = drm_trusted_open_decrypt_session(&open_input_data, &open_output_data,\r
 315                         NULL);\r
 316         tet_printf("ret = 0x%x", ret);\r
 317         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 318                 tet_printf("open_decrypt_session Success");\r
 319                 tet_result(TET_FAIL);\r
 320         } else {\r
 321                 tet_printf("open_decrypt_session FAILED: ret=0x%x", ret);\r
 322                 tet_result(TET_PASS);\r
 323         }\r
 324 }\r