TC/unit/utc_drmclient_drm_process_request_func.c

   1 /*\r
   2  * drm-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_drmclient_drm_process_request_func.c\r
  27  * @brief       TETware unit testing functions for drm_process_request.\r
  28  * @author      Mahendra Kumar Prajapat (mahendra.p@samsung.com)\r
  29  * @version     0.1\r
  30  * @history     0.1: Initial draft\r
  31  */\r
  32 \r
  33 #include <sys/types.h>\r
  34 #include <sys/stat.h>\r
  35 \r
  36 #include <tet_api.h>\r
  37 \r
  38 #include "drmcontentsdef.h"\r
  39 \r
  40 static void startup(void);\r
  41 static void cleanup(void);\r
  42 \r
  43 void (*tet_startup)(void) = startup;\r
  44 void (*tet_cleanup)(void) = cleanup;\r
  45 \r
  46 static void utc_drmclient_drm_process_request_func_01(void);\r
  47 static void utc_drmclient_drm_process_request_func_02(void);\r
  48 static void utc_drmclient_drm_process_request_func_03(void);\r
  49 static void utc_drmclient_drm_process_request_func_04(void);\r
  50 static void utc_drmclient_drm_process_request_func_05(void);\r
  51 static void utc_drmclient_drm_process_request_func_06(void);\r
  52 static void utc_drmclient_drm_process_request_func_07(void);\r
  53 static void utc_drmclient_drm_process_request_func_08(void);\r
  54 static void utc_drmclient_drm_process_request_func_09(void);\r
  55 static void utc_drmclient_drm_process_request_func_10(void);\r
  56 static void utc_drmclient_drm_process_request_func_11(void);\r
  57 static void utc_drmclient_drm_process_request_func_12(void);\r
  58 static void utc_drmclient_drm_process_request_func_13(void);\r
  59 static void utc_drmclient_drm_process_request_func_14(void);\r
  60 static void utc_drmclient_drm_process_request_func_15(void);\r
  61 static void utc_drmclient_drm_process_request_func_16(void);\r
  62 static void utc_drmclient_drm_process_request_func_17(void);\r
  63 static void utc_drmclient_drm_process_request_func_18(void);\r
  64 static void utc_drmclient_drm_process_request_func_19(void);\r
  65 static void utc_drmclient_drm_process_request_func_20(void);\r
  66 static void utc_drmclient_drm_process_request_func_21(void);\r
  67 static void utc_drmclient_drm_process_request_func_22(void);\r
  68 static void utc_drmclient_drm_process_request_func_23(void);\r
  69 static void utc_drmclient_drm_process_request_func_24(void);\r
  70 static void utc_drmclient_drm_process_request_func_25(void);\r
  71 static void utc_drmclient_drm_process_request_func_26(void);\r
  72 static void utc_drmclient_drm_process_request_func_27(void);\r
  73 static void utc_drmclient_drm_process_request_func_28(void);\r
  74 static void utc_drmclient_drm_process_request_func_29(void);\r
  75 static void utc_drmclient_drm_process_request_func_30(void);\r
  76 static void utc_drmclient_drm_process_request_func_31(void);\r
  77 static void utc_drmclient_drm_process_request_func_32(void);\r
  78 static void utc_drmclient_drm_process_request_func_33(void);\r
  79 static void utc_drmclient_drm_process_request_func_34(void);\r
  80 static void utc_drmclient_drm_process_request_func_35(void);\r
  81 static void utc_drmclient_drm_process_request_func_36(void);\r
  82 static void utc_drmclient_drm_process_request_func_37(void);\r
  83 static void utc_drmclient_drm_process_request_func_38(void);\r
  84 static void utc_drmclient_drm_process_request_func_39(void);\r
  85 \r
  86 enum {\r
  87         POSITIVE_TC_IDX = 0x01,\r
  88         NEGATIVE_TC_IDX,\r
  89 };\r
  90 \r
  91 struct tet_testlist tet_testlist[] = {\r
  92         { utc_drmclient_drm_process_request_func_01, POSITIVE_TC_IDX },\r
  93         { utc_drmclient_drm_process_request_func_02, POSITIVE_TC_IDX },\r
  94         { utc_drmclient_drm_process_request_func_03, NEGATIVE_TC_IDX },\r
  95         { utc_drmclient_drm_process_request_func_04, NEGATIVE_TC_IDX },\r
  96         { utc_drmclient_drm_process_request_func_05, NEGATIVE_TC_IDX },\r
  97         { utc_drmclient_drm_process_request_func_06, POSITIVE_TC_IDX },\r
  98         { utc_drmclient_drm_process_request_func_07, POSITIVE_TC_IDX },\r
  99         { utc_drmclient_drm_process_request_func_08, NEGATIVE_TC_IDX },\r
 100         { utc_drmclient_drm_process_request_func_09, NEGATIVE_TC_IDX },\r
 101         { utc_drmclient_drm_process_request_func_10, POSITIVE_TC_IDX },\r
 102         { utc_drmclient_drm_process_request_func_11, POSITIVE_TC_IDX },\r
 103         { utc_drmclient_drm_process_request_func_12, NEGATIVE_TC_IDX },\r
 104         { utc_drmclient_drm_process_request_func_13, POSITIVE_TC_IDX },\r
 105         { utc_drmclient_drm_process_request_func_14, POSITIVE_TC_IDX },\r
 106         { utc_drmclient_drm_process_request_func_15, POSITIVE_TC_IDX },\r
 107         { utc_drmclient_drm_process_request_func_16, POSITIVE_TC_IDX },\r
 108         { utc_drmclient_drm_process_request_func_17, POSITIVE_TC_IDX },\r
 109         { utc_drmclient_drm_process_request_func_18, POSITIVE_TC_IDX },\r
 110         { utc_drmclient_drm_process_request_func_19, NEGATIVE_TC_IDX },\r
 111         { utc_drmclient_drm_process_request_func_20, NEGATIVE_TC_IDX },\r
 112         { utc_drmclient_drm_process_request_func_21, POSITIVE_TC_IDX },\r
 113         { utc_drmclient_drm_process_request_func_22, POSITIVE_TC_IDX },\r
 114         { utc_drmclient_drm_process_request_func_23, POSITIVE_TC_IDX },\r
 115         { utc_drmclient_drm_process_request_func_24, POSITIVE_TC_IDX },\r
 116         { utc_drmclient_drm_process_request_func_25, NEGATIVE_TC_IDX },\r
 117         { utc_drmclient_drm_process_request_func_26, POSITIVE_TC_IDX },\r
 118         { utc_drmclient_drm_process_request_func_27, NEGATIVE_TC_IDX },\r
 119         { utc_drmclient_drm_process_request_func_28, POSITIVE_TC_IDX },\r
 120         { utc_drmclient_drm_process_request_func_29, NEGATIVE_TC_IDX },\r
 121         { utc_drmclient_drm_process_request_func_30, POSITIVE_TC_IDX },\r
 122         { utc_drmclient_drm_process_request_func_31, NEGATIVE_TC_IDX },\r
 123         { utc_drmclient_drm_process_request_func_32, POSITIVE_TC_IDX },\r
 124         { utc_drmclient_drm_process_request_func_33, NEGATIVE_TC_IDX },\r
 125         { utc_drmclient_drm_process_request_func_34, POSITIVE_TC_IDX },\r
 126         { utc_drmclient_drm_process_request_func_35, POSITIVE_TC_IDX },\r
 127         { utc_drmclient_drm_process_request_func_36, POSITIVE_TC_IDX },\r
 128         { utc_drmclient_drm_process_request_func_37, NEGATIVE_TC_IDX },\r
 129         { utc_drmclient_drm_process_request_func_38, POSITIVE_TC_IDX },\r
 130         { utc_drmclient_drm_process_request_func_39, NEGATIVE_TC_IDX },\r
 131         { NULL, 0 }\r
 132 };\r
 133 \r
 134 static void startup(void)\r
 135 {\r
 136         tet_infoline("drm_process_request:Test started");\r
 137 }\r
 138 \r
 139 static void cleanup(void)\r
 140 {\r
 141         tet_infoline("drm_process_request:Test completed");\r
 142 }\r
 143 \r
 144 /**\r
 145  * @brief Positive test case of drm_process_request()\r
 146  */\r
 147 static void utc_drmclient_drm_process_request_func_01(void)\r
 148 {\r
 149         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 150         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_FILE;\r
 151         char file_path[FILE_PATH_MAX_SIZE] = {0,};\r
 152 \r
 153         snprintf(file_path,FILE_PATH_MAX_SIZE, "%s",FILE_PATH_VALID_FILE_OMA_1);\r
 154         tet_printf ("Testing:DRM_REQUEST_TYPE_REGISTER_FILE");\r
 155 \r
 156         ret = drm_process_request(request_type,(void*)file_path,NULL);\r
 157         tet_printf("ret=0x%x",ret);\r
 158         if(DRM_RETURN_SUCCESS == ret){\r
 159                 tet_printf("Register success:file_path=%s",\r
 160                                 file_path);\r
 161                 tet_result(TET_PASS);\r
 162         }else{\r
 163                 tet_printf("Register FAILED:ret=0x%x file_path=%s",\r
 164                                 ret,file_path);\r
 165                 tet_result(TET_FAIL);\r
 166         }\r
 167 }\r
 168 \r
 169 /**\r
 170  * @brief Positive test case of drm_process_request()\r
 171  */\r
 172 static void utc_drmclient_drm_process_request_func_02(void)\r
 173 {\r
 174         /** This is duplication of\r
 175          * test-case utc_drmclient_drm_process_request_func_01\r
 176          * This test-case is added to ensure proper behavior if same content is\r
 177          * registered 2 times.\r
 178          */\r
 179         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 180         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_FILE;\r
 181         char file_path[FILE_PATH_MAX_SIZE] = {0,};\r
 182 \r
 183         snprintf(file_path,FILE_PATH_MAX_SIZE, "%s",FILE_PATH_VALID_FILE_OMA_1);\r
 184         tet_printf ("Testing:DRM_REQUEST_TYPE_REGISTER_FILE");\r
 185 \r
 186         ret = drm_process_request(request_type,(void*)file_path,NULL);\r
 187         tet_printf("ret=0x%x",ret);\r
 188         if(DRM_RETURN_SUCCESS == ret){\r
 189                 tet_printf("Register success:file_path=%s",\r
 190                                 file_path);\r
 191                 tet_result(TET_PASS);\r
 192         }else{\r
 193                 tet_printf("Register FAILED:ret=0x%x file_path=%s",\r
 194                                 ret,file_path);\r
 195                 tet_result(TET_FAIL);\r
 196         }\r
 197 }\r
 198 \r
 199 /**\r
 200  * @brief Negative test case of drm_process_request()\r
 201  */\r
 202 static void utc_drmclient_drm_process_request_func_03(void)\r
 203 {\r
 204         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 205         drm_request_type_e request_type = DRM_REQUEST_TYPE_NONE;\r
 206         char file_path[FILE_PATH_MAX_SIZE] = {0,};\r
 207 \r
 208         snprintf(file_path,FILE_PATH_MAX_SIZE, "%s",FILE_PATH_VALID_FILE_OMA_1);\r
 209         tet_printf("Testing:DRM_REQUEST_TYPE_NONE");\r
 210 \r
 211         ret = drm_process_request(request_type,(void*)file_path,NULL);\r
 212         tet_printf("ret=0x%x",ret);\r
 213         if(DRM_RETURN_SUCCESS == ret){\r
 214                 tet_printf("Register success:file_path=%s",\r
 215                                 file_path);\r
 216                 tet_result(TET_FAIL);\r
 217         }else{\r
 218                 tet_printf("Invalid request_type=%d ret=0x%x file_path=%s",\r
 219                                 request_type,ret,file_path);\r
 220                 tet_result(TET_PASS);\r
 221         }\r
 222 }\r
 223 \r
 224 /**\r
 225  * @brief Negative test case of drm_process_request()\r
 226  */\r
 227 static void utc_drmclient_drm_process_request_func_04(void)\r
 228 {\r
 229         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 230         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_FILE;\r
 231         char file_path[FILE_PATH_MAX_SIZE] = {0,};\r
 232 \r
 233         tet_printf("Testing:DRM_REQUEST_TYPE_REGISTER_FILE");\r
 234 \r
 235         ret = drm_process_request(request_type,(void*)file_path,NULL);\r
 236         tet_printf("ret=0x%x",ret);\r
 237         if(DRM_RETURN_SUCCESS == ret){\r
 238                 tet_printf("Register success:file_path=%s",\r
 239                                 file_path);\r
 240                 tet_result(TET_FAIL);\r
 241         }else{\r
 242                 tet_printf("Invalid file_path: ret=0x%x file_path=%s",\r
 243                                 ret,file_path);\r
 244                 tet_result(TET_PASS);\r
 245         }\r
 246 }\r
 247 \r
 248 /**\r
 249  * @brief Negative test case of drm_process_request()\r
 250  */\r
 251 static void utc_drmclient_drm_process_request_func_05(void)\r
 252 {\r
 253         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 254         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_FILE;\r
 255         char *file_path = NULL;\r
 256 \r
 257         tet_printf("Testing:DRM_REQUEST_TYPE_REGISTER_FILE");\r
 258 \r
 259         ret = drm_process_request(request_type,(void*)file_path,NULL);\r
 260         tet_printf("ret=0x%x",ret);\r
 261         if(DRM_RETURN_SUCCESS == ret){\r
 262                 tet_printf("Register success:file_path=%p",\r
 263                                 file_path);\r
 264                 tet_result(TET_FAIL);\r
 265         }else{\r
 266                 tet_printf("Invalid file_path: ret=0x%x file_path=%p",\r
 267                                 ret,file_path);\r
 268                 tet_result(TET_PASS);\r
 269         }\r
 270 }\r
 271 \r
 272 /**\r
 273  * @brief Positive test case of drm_process_request()\r
 274  */\r
 275 static void utc_drmclient_drm_process_request_func_06(void)\r
 276 {\r
 277         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 278         drm_request_type_e request_type = DRM_REQUEST_TYPE_UNREGISTER_FILE;\r
 279         drm_unregister_info_s unregister_info;\r
 280         memset(&unregister_info,0x0,sizeof(drm_unregister_info_s));\r
 281 \r
 282         tet_printf("Testing:DRM_REQUEST_TYPE_UNREGISTER_FILE");\r
 283         snprintf(unregister_info.file_path,FILE_PATH_MAX_SIZE, "%s",FILE_PATH_VALID_FILE_OMA_1);\r
 284         unregister_info.remove_license = 1;\r
 285 \r
 286         ret = drm_process_request(request_type,(void*)&unregister_info,NULL);\r
 287         tet_printf("ret=0x%x",ret);\r
 288         if(DRM_RETURN_SUCCESS == ret){\r
 289                 tet_printf("Un-register success:file_path=%s",\r
 290                                 unregister_info.file_path);\r
 291                 tet_result(TET_PASS);\r
 292         }else{\r
 293                 tet_printf("Un-register FAILED:ret=0x%x "\r
 294                                 "file_path=%s",ret,unregister_info.file_path);\r
 295                 tet_result(TET_FAIL);\r
 296         }\r
 297 }\r
 298 \r
 299 /**\r
 300  * @brief Positive test case of drm_process_request()\r
 301  */\r
 302 static void utc_drmclient_drm_process_request_func_07(void)\r
 303 {\r
 304         /** This is duplication of\r
 305          * test-case utc_drmclient_drm_process_request_func_06\r
 306          * This test-case is added to ensure proper behavior if same content is\r
 307          * unregistered 2 times.\r
 308          */\r
 309         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 310         drm_request_type_e request_type = DRM_REQUEST_TYPE_UNREGISTER_FILE;\r
 311         drm_unregister_info_s unregister_info;\r
 312         memset(&unregister_info,0x0,sizeof(drm_unregister_info_s));\r
 313 \r
 314         tet_printf("Testing:DRM_REQUEST_TYPE_UNREGISTER_FILE");\r
 315         snprintf(unregister_info.file_path,FILE_PATH_MAX_SIZE, "%s",FILE_PATH_VALID_FILE_OMA_1);\r
 316         unregister_info.remove_license = 0;\r
 317 \r
 318         ret = drm_process_request(request_type,(void*)&unregister_info,NULL);\r
 319         tet_printf("ret=0x%x",ret);\r
 320         if(DRM_RETURN_SUCCESS == ret){\r
 321                 tet_printf("Un-register success:file_path=%s",\r
 322                                 unregister_info.file_path);\r
 323                 tet_result(TET_PASS);\r
 324         }else{\r
 325                 tet_printf("Un-register FAILED:ret=0x%x "\r
 326                                 "file_path=%s",ret,unregister_info.file_path);\r
 327                 tet_result(TET_FAIL);\r
 328         }\r
 329 }\r
 330 \r
 331 /**\r
 332  * @brief Negative test case of drm_process_request()\r
 333  */\r
 334 static void utc_drmclient_drm_process_request_func_08(void)\r
 335 {\r
 336         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 337         drm_request_type_e request_type = DRM_REQUEST_TYPE_UNREGISTER_FILE;\r
 338         drm_unregister_info_s unregister_info;\r
 339         memset(&unregister_info,0x0,sizeof(drm_unregister_info_s));\r
 340 \r
 341         tet_printf("Testing:DRM_REQUEST_TYPE_UNREGISTER_FILE");\r
 342         snprintf(unregister_info.file_path,FILE_PATH_MAX_SIZE, "%s",FILE_PATH_INVALID_FILE_EMPTY);\r
 343         unregister_info.remove_license = 0;\r
 344 \r
 345         ret = drm_process_request(request_type,(void*)&unregister_info,NULL);\r
 346         tet_printf("ret=0x%x",ret);\r
 347         if(DRM_RETURN_SUCCESS == ret){\r
 348                 tet_printf("Un-register success:file_path=%s",\r
 349                                 unregister_info.file_path);\r
 350                 tet_result(TET_FAIL);\r
 351         }else{\r
 352                 tet_printf("Invalid file path:ret=0x%x "\r
 353                                 "file_path=%s",ret,unregister_info.file_path);\r
 354                 tet_result(TET_PASS);\r
 355         }\r
 356 }\r
 357 \r
 358 /**\r
 359  * @brief Negative test case of drm_process_request()\r
 360  */\r
 361 static void utc_drmclient_drm_process_request_func_09(void)\r
 362 {\r
 363         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 364         drm_request_type_e request_type = DRM_REQUEST_TYPE_UNREGISTER_FILE;\r
 365 \r
 366         tet_printf("Testing:DRM_REQUEST_TYPE_UNREGISTER_FILE");\r
 367 \r
 368         ret = drm_process_request(request_type,NULL,NULL);\r
 369         tet_printf("ret=0x%x",ret);\r
 370         if(DRM_RETURN_SUCCESS == ret){\r
 371                 tet_printf("Un-register success");\r
 372                 tet_result(TET_FAIL);\r
 373         }else{\r
 374                 tet_printf("Invalid input:ret=0x%x",ret);\r
 375                 tet_result(TET_PASS);\r
 376         }\r
 377 }\r
 378 \r
 379 /**\r
 380  * @brief Positive test case of drm_process_request()\r
 381  */\r
 382 static void utc_drmclient_drm_process_request_func_10(void)\r
 383 {\r
 384         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 385         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_LICENSE;\r
 386         tet_printf("Testing:DRM_REQUEST_TYPE_REGISTER_LICENSE");\r
 387 \r
 388         drm_register_lic_info_s lic_req_info;\r
 389         drm_register_lic_resp_s lic_resp_info;\r
 390 \r
 391         memset(&lic_req_info,0x0,sizeof(drm_register_lic_info_s));\r
 392         memset(&lic_resp_info,0x0,sizeof(drm_register_lic_resp_s));\r
 393 \r
 394         struct stat stat_buf = { 0 };\r
 395         FILE *fp = NULL;\r
 396         unsigned int read_len=0;\r
 397         char *tempPath = NULL;\r
 398 \r
 399         char file_path[FILE_PATH_MAX_SIZE] = {0,};\r
 400         snprintf(file_path,FILE_PATH_MAX_SIZE, "%s",FILE_PATH_VALID_RO_FILE_OMA_1);\r
 401 \r
 402         if (0 == stat(file_path, &stat_buf)) {\r
 403                 lic_req_info.lic_data_len = stat_buf.st_size;\r
 404                 tet_printf("file_path=%s file_size=%u",file_path,\r
 405                                 lic_req_info.lic_data_len);\r
 406         } else {\r
 407                 tet_printf("stat failed:error=%s file_path=%s",\r
 408                                 strerror(errno),file_path);\r
 409                 tet_result(TET_FAIL);\r
 410                 return;\r
 411         }\r
 412 \r
 413         fp = fopen(file_path,"r");\r
 414         if(NULL == fp){\r
 415                 tet_printf("fopen failed:error=%s file_path=%s",\r
 416                                 strerror(errno),file_path);\r
 417                 tet_result(TET_FAIL);\r
 418                 return;\r
 419         }\r
 420 \r
 421         memset(lic_req_info.lic_data,0x0,sizeof(lic_req_info.lic_data));\r
 422         read_len = fread(lic_req_info.lic_data,1,lic_req_info.lic_data_len,fp);\r
 423         tet_printf("read_len=%u lic_req_info.lic_data_len=%u",\r
 424                         read_len,lic_req_info.lic_data_len);\r
 425 \r
 426         fclose(fp);\r
 427 \r
 428         tempPath = strrchr((char *)file_path, '.');\r
 429         if(strncmp(tempPath, ".dr", 2) == 0\r
 430                 || strncmp(tempPath, ".drc", 3) == 0){\r
 431                 tet_printf("DRM v1 License file");\r
 432 \r
 433                 lic_req_info.lic_version = DRM_OMA_DRMV1_RIGHTS;\r
 434                 lic_req_info.roap_init_src = DRM_ROAP_INIT_FROM_UNKNOWN;\r
 435                 lic_req_info.operation_callback.callback = NULL;\r
 436 \r
 437                 ret = drm_process_request(request_type,(void*)&lic_req_info,\r
 438                                 (void*)&lic_resp_info);\r
 439                 tet_printf("ret=0x%x",ret);\r
 440                 if(DRM_RETURN_SUCCESS == ret){\r
 441                         tet_printf("Register License success");\r
 442                         tet_printf("CID=%s",lic_resp_info.cid);\r
 443                         tet_result(TET_PASS);\r
 444                 }else{\r
 445                         tet_printf("Register License FAILED:"\r
 446                                         "ret=0x%x",ret);\r
 447                         tet_result(TET_FAIL);\r
 448                 }\r
 449         }else{\r
 450                 tet_printf("Not a License file:ret=0x%x",ret);\r
 451                 tet_result(TET_FAIL);\r
 452         }\r
 453 }\r
 454 \r
 455 /**\r
 456  * @brief Positive test case of drm_process_request()\r
 457  */\r
 458 static void utc_drmclient_drm_process_request_func_11(void)\r
 459 {\r
 460         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 461         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_LICENSE;\r
 462         tet_printf("Testing:DRM_REQUEST_TYPE_REGISTER_LICENSE");\r
 463 \r
 464         drm_register_lic_info_s lic_req_info;\r
 465         drm_register_lic_resp_s lic_resp_info;\r
 466 \r
 467         memset(&lic_req_info,0x0,sizeof(drm_register_lic_info_s));\r
 468         memset(&lic_resp_info,0x0,sizeof(drm_register_lic_resp_s));\r
 469 \r
 470         struct stat stat_buf = { 0 };\r
 471         FILE *fp = NULL;\r
 472         unsigned int read_len=0;\r
 473         char *tempPath = NULL;\r
 474 \r
 475         char file_path[FILE_PATH_MAX_SIZE] = {0,};\r
 476         snprintf(file_path,FILE_PATH_MAX_SIZE, "%s",FILE_PATH_VALID_RO_FILE_OMA_2);\r
 477 \r
 478         if (0 == stat(file_path, &stat_buf)) {\r
 479                 lic_req_info.lic_data_len = stat_buf.st_size;\r
 480                 tet_printf("file_path=%s file_size=%u",file_path,\r
 481                                 lic_req_info.lic_data_len);\r
 482         } else {\r
 483                 tet_printf("stat failed:error=%s file_path=%s",\r
 484                                 strerror(errno),file_path);\r
 485                 tet_result(TET_FAIL);\r
 486                 return;\r
 487         }\r
 488 \r
 489         fp = fopen(file_path,"r");\r
 490         if(NULL == fp){\r
 491                 tet_printf("fopen failed:error=%s file_path=%s",\r
 492                                 strerror(errno),file_path);\r
 493                 tet_result(TET_FAIL);\r
 494                 return;\r
 495         }\r
 496 \r
 497         memset(lic_req_info.lic_data,0x0,sizeof(lic_req_info.lic_data));\r
 498         read_len = fread(lic_req_info.lic_data,1,lic_req_info.lic_data_len,fp);\r
 499         tet_printf("read_len=%u lic_req_info.lic_data_len=%u",\r
 500                         read_len,lic_req_info.lic_data_len);\r
 501 \r
 502         fclose(fp);\r
 503 \r
 504         tempPath = strrchr((char *)file_path, '.');\r
 505         if(strncmp(tempPath, ".dr", 2) == 0\r
 506                 || strncmp(tempPath, ".drc", 3) == 0){\r
 507                 tet_printf("DRM v1 License file");\r
 508 \r
 509                 lic_req_info.lic_version = DRM_OMA_DRMV1_RIGHTS;\r
 510                 lic_req_info.roap_init_src = DRM_ROAP_INIT_FROM_UNKNOWN;\r
 511                 lic_req_info.operation_callback.callback = NULL;\r
 512 \r
 513                 ret = drm_process_request(request_type,(void*)&lic_req_info,\r
 514                                 (void*)&lic_resp_info);\r
 515                 tet_printf("ret=0x%x",ret);\r
 516                 if(DRM_RETURN_SUCCESS == ret){\r
 517                         tet_printf("Register License success");\r
 518                         tet_printf("CID=%s",lic_resp_info.cid);\r
 519                         tet_result(TET_PASS);\r
 520                 }else{\r
 521                         tet_printf("Register License FAILED:"\r
 522                                         "ret=0x%x",ret);\r
 523                         tet_result(TET_FAIL);\r
 524                 }\r
 525         }else{\r
 526                 tet_printf("Not a License file:ret=0x%x",ret);\r
 527                 tet_result(TET_FAIL);\r
 528         }\r
 529 }\r
 530 \r
 531 /**\r
 532  * @brief Negative test case of drm_process_request()\r
 533  */\r
 534 static void utc_drmclient_drm_process_request_func_12(void)\r
 535 {\r
 536         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 537         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_LICENSE;\r
 538         tet_printf("Testing:DRM_REQUEST_TYPE_REGISTER_LICENSE");\r
 539 \r
 540         ret = drm_process_request(request_type,NULL,NULL);\r
 541         tet_printf("ret=0x%x",ret);\r
 542         if(DRM_RETURN_SUCCESS == ret){\r
 543                 tet_printf("Register License success");\r
 544                 tet_result(TET_FAIL);\r
 545         }else{\r
 546                 tet_printf("Invalid input and output ret=0x%x",ret);\r
 547                 tet_result(TET_PASS);\r
 548         }\r
 549 }\r
 550 \r
 551 /**\r
 552  * @brief       Positive test case of drm_process_request()\r
 553  * @remark      Content is un-registered as a part of\r
 554  *                      utc_drmclient_drm_process_request_func_06\r
 555  *                      and utc_drmclient_drm_process_request_func_07.\r
 556  *                      Thus re-registering the content.\r
 557  */\r
 558 static void utc_drmclient_drm_process_request_func_13(void)\r
 559 {\r
 560         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 561         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_FILE;\r
 562         char file_path[FILE_PATH_MAX_SIZE] = {0,};\r
 563 \r
 564         snprintf(file_path,FILE_PATH_MAX_SIZE, "%s",FILE_PATH_VALID_FILE_OMA_1);\r
 565         tet_printf ("Testing:DRM_REQUEST_TYPE_REGISTER_FILE");\r
 566 \r
 567         ret = drm_process_request(request_type,(void*)file_path,NULL);\r
 568         tet_printf("ret=0x%x",ret);\r
 569         if(DRM_RETURN_SUCCESS == ret){\r
 570                 tet_printf("Register success:file_path=%s",\r
 571                                 file_path);\r
 572                 tet_result(TET_PASS);\r
 573         }else{\r
 574                 tet_printf("Register FAILED:ret=0x%x file_path=%s",\r
 575                                 ret,file_path);\r
 576                 tet_result(TET_FAIL);\r
 577         }\r
 578 }\r
 579 \r
 580 /**\r
 581  * @brief       Positive test case of drm_process_request()\r
 582  */\r
 583 static void utc_drmclient_drm_process_request_func_14(void)\r
 584 {\r
 585         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 586         drm_request_type_e request_type = DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL;\r
 587         tet_printf ("Testing:DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL");\r
 588 \r
 589         drm_initiator_info_s initiator_info;\r
 590         drm_web_server_resp_data_s ws_resp_data;\r
 591 \r
 592         memset(&initiator_info,0x0,sizeof(drm_initiator_info_s));\r
 593         memset(&ws_resp_data,0x0,sizeof(drm_web_server_resp_data_s));\r
 594 \r
 595         snprintf(initiator_info.initiator_url,DRM_MAX_LEN_INITIATOR_URL, "%s",\r
 596                         LICENSE_INITIATOR_VALID_PR_FILE);\r
 597 \r
 598         tet_printf ("Source Initiator URL=%s",LICENSE_INITIATOR_VALID_PR_FILE);\r
 599         tet_printf ("Destination Initiator URL=%s",initiator_info.initiator_url);\r
 600 \r
 601         initiator_info.initiator_url_len = strlen(initiator_info.initiator_url);\r
 602         initiator_info.operation_callback.callback = NULL;\r
 603 \r
 604         tet_printf ("Source Initiator URL Length=%u",strlen(LICENSE_INITIATOR_VALID_PR_FILE));\r
 605         tet_printf ("Destination Initiator URL Length=%u",strlen(initiator_info.initiator_url));\r
 606 \r
 607         ret = drm_process_request(request_type, (void*)&initiator_info,\r
 608                         (void*)&ws_resp_data);\r
 609         if (DRM_RETURN_SUCCESS == ret) {\r
 610                 tet_printf("Server Error Code = %d",\r
 611                                 ws_resp_data.result_code);\r
 612                 tet_printf("Content URL = %s",\r
 613                                 ws_resp_data.content_url);\r
 614                 tet_result(TET_PASS);\r
 615         } else {\r
 616                 tet_printf("ret = 0x%x", ret);\r
 617                 /**\r
 618                  * As this TC depends on network connectivity,\r
 619                  * Thus making it TET_PASS\r
 620                  */\r
 621                 tet_result(TET_PASS);\r
 622         }\r
 623 }\r
 624 \r
 625 /**\r
 626  * @brief       Positive test case of drm_process_request()\r
 627  */\r
 628 static void utc_drmclient_drm_process_request_func_15(void)\r
 629 {\r
 630         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 631         drm_request_type_e request_type = DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL;\r
 632         tet_printf ("Testing:DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL");\r
 633 \r
 634         drm_initiator_info_s initiator_info;\r
 635         drm_web_server_resp_data_s ws_resp_data;\r
 636 \r
 637         memset(&initiator_info,0x0,sizeof(drm_initiator_info_s));\r
 638         memset(&ws_resp_data,0x0,sizeof(drm_web_server_resp_data_s));\r
 639 \r
 640         snprintf(initiator_info.initiator_url,DRM_MAX_LEN_INITIATOR_URL, "%s",\r
 641                         LICENSE_INITIATOR_VALID_PR_FILE_1);\r
 642 \r
 643         tet_printf ("Source Initiator URL=%s",LICENSE_INITIATOR_VALID_PR_FILE_1);\r
 644         tet_printf ("Destination Initiator URL=%s",initiator_info.initiator_url);\r
 645 \r
 646         initiator_info.initiator_url_len = strlen(initiator_info.initiator_url);\r
 647         initiator_info.operation_callback.callback = NULL;\r
 648 \r
 649         tet_printf ("Source Initiator URL Length=%u",strlen(LICENSE_INITIATOR_VALID_PR_FILE_1));\r
 650         tet_printf ("Destination Initiator URL Length=%u",strlen(initiator_info.initiator_url));\r
 651 \r
 652         ret = drm_process_request(request_type, (void*)&initiator_info,\r
 653                         (void*)&ws_resp_data);\r
 654         if (DRM_RETURN_SUCCESS == ret) {\r
 655                 tet_printf("Server Error Code = %d",\r
 656                                 ws_resp_data.result_code);\r
 657                 tet_printf("Content URL = %s",\r
 658                                 ws_resp_data.content_url);\r
 659                 tet_result(TET_PASS);\r
 660         } else {\r
 661                 tet_printf("ret = 0x%x", ret);\r
 662                 /**\r
 663                  * As this TC depends on network connectivity,\r
 664                  * Thus making it TET_PASS\r
 665                  */\r
 666                 tet_result(TET_PASS);\r
 667         }\r
 668 }\r
 669 \r
 670 /**\r
 671  * @brief       Positive test case of drm_process_request()\r
 672  */\r
 673 static void utc_drmclient_drm_process_request_func_16(void)\r
 674 {\r
 675         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 676         drm_request_type_e request_type = DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL;\r
 677         tet_printf ("Testing:DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL");\r
 678 \r
 679         drm_initiator_info_s initiator_info;\r
 680         drm_web_server_resp_data_s ws_resp_data;\r
 681 \r
 682         memset(&initiator_info,0x0,sizeof(drm_initiator_info_s));\r
 683         memset(&ws_resp_data,0x0,sizeof(drm_web_server_resp_data_s));\r
 684 \r
 685         snprintf(initiator_info.initiator_url,DRM_MAX_LEN_INITIATOR_URL, "%s",\r
 686                         JOIN_DOMAIN_INITIATOR_VALID_PR_FILE_1);\r
 687 \r
 688         tet_printf ("Source Initiator URL=%s",JOIN_DOMAIN_INITIATOR_VALID_PR_FILE_1);\r
 689         tet_printf ("Destination Initiator URL=%s",initiator_info.initiator_url);\r
 690 \r
 691         initiator_info.initiator_url_len = strlen(initiator_info.initiator_url);\r
 692         initiator_info.operation_callback.callback = NULL;\r
 693 \r
 694         tet_printf ("Source Initiator URL Length=%u",strlen(JOIN_DOMAIN_INITIATOR_VALID_PR_FILE_1));\r
 695         tet_printf ("Destination Initiator URL Length=%u",strlen(initiator_info.initiator_url));\r
 696 \r
 697         ret = drm_process_request(request_type, (void*)&initiator_info,\r
 698                         (void*)&ws_resp_data);\r
 699         if (DRM_RETURN_SUCCESS == ret) {\r
 700                 tet_printf("Server Error Code = %d",\r
 701                                 ws_resp_data.result_code);\r
 702                 tet_printf("Content URL = %s",\r
 703                                 ws_resp_data.content_url);\r
 704                 tet_result(TET_PASS);\r
 705         } else {\r
 706                 tet_printf("ret = 0x%x", ret);\r
 707                 /**\r
 708                  * As this TC depends on network connectivity,\r
 709                  * Thus making it TET_PASS\r
 710                  */\r
 711                 tet_result(TET_PASS);\r
 712         }\r
 713 }\r
 714 \r
 715 /**\r
 716  * @brief       Positive test case of drm_process_request()\r
 717  */\r
 718 static void utc_drmclient_drm_process_request_func_17(void)\r
 719 {\r
 720         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 721         drm_request_type_e request_type = DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL;\r
 722         tet_printf ("Testing:DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL");\r
 723 \r
 724         drm_initiator_info_s initiator_info;\r
 725         drm_web_server_resp_data_s ws_resp_data;\r
 726 \r
 727         memset(&initiator_info,0x0,sizeof(drm_initiator_info_s));\r
 728         memset(&ws_resp_data,0x0,sizeof(drm_web_server_resp_data_s));\r
 729 \r
 730         snprintf(initiator_info.initiator_url,DRM_MAX_LEN_INITIATOR_URL, "%s",\r
 731                         LEAVE_DOMAIN_INITIATOR_VALID_PR_FILE_1);\r
 732 \r
 733         tet_printf ("Source Initiator URL=%s",LEAVE_DOMAIN_INITIATOR_VALID_PR_FILE_1);\r
 734         tet_printf ("Destination Initiator URL=%s",initiator_info.initiator_url);\r
 735 \r
 736         initiator_info.initiator_url_len = strlen(initiator_info.initiator_url);\r
 737         initiator_info.operation_callback.callback = NULL;\r
 738 \r
 739         tet_printf ("Source Initiator URL Length=%u",strlen(LEAVE_DOMAIN_INITIATOR_VALID_PR_FILE_1));\r
 740         tet_printf ("Destination Initiator URL Length=%u",strlen(initiator_info.initiator_url));\r
 741 \r
 742         ret = drm_process_request(request_type, (void*)&initiator_info,\r
 743                         (void*)&ws_resp_data);\r
 744         if (DRM_RETURN_SUCCESS == ret) {\r
 745                 tet_printf("Server Error Code = %d",\r
 746                                 ws_resp_data.result_code);\r
 747                 tet_printf("Content URL = %s",\r
 748                                 ws_resp_data.content_url);\r
 749                 tet_result(TET_PASS);\r
 750         } else {\r
 751                 tet_printf("ret = 0x%x", ret);\r
 752                 /**\r
 753                  * As this TC depends on network connectivity,\r
 754                  * Thus making it TET_PASS\r
 755                  */\r
 756                 tet_result(TET_PASS);\r
 757         }\r
 758 }\r
 759 \r
 760 /**\r
 761  * @brief       Positive test case of drm_process_request()\r
 762  */\r
 763 static void utc_drmclient_drm_process_request_func_18(void)\r
 764 {\r
 765         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 766         drm_request_type_e request_type = DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL;\r
 767         tet_printf ("Testing:DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL");\r
 768 \r
 769         drm_initiator_info_s initiator_info;\r
 770         drm_web_server_resp_data_s ws_resp_data;\r
 771 \r
 772         memset(&initiator_info,0x0,sizeof(drm_initiator_info_s));\r
 773         memset(&ws_resp_data,0x0,sizeof(drm_web_server_resp_data_s));\r
 774 \r
 775         snprintf(initiator_info.initiator_url,DRM_MAX_LEN_INITIATOR_URL, "%s",\r
 776                         METERING_INITIATOR_VALID_PR_FILE_1);\r
 777 \r
 778         tet_printf ("Source Initiator URL=%s",METERING_INITIATOR_VALID_PR_FILE_1);\r
 779         tet_printf ("Destination Initiator URL=%s",initiator_info.initiator_url);\r
 780 \r
 781         initiator_info.initiator_url_len = strlen(initiator_info.initiator_url);\r
 782         initiator_info.operation_callback.callback = NULL;\r
 783 \r
 784         tet_printf ("Source Initiator URL Length=%u",strlen(METERING_INITIATOR_VALID_PR_FILE_1));\r
 785         tet_printf ("Destination Initiator URL Length=%u",strlen(initiator_info.initiator_url));\r
 786 \r
 787         ret = drm_process_request(request_type, (void*)&initiator_info,\r
 788                         (void*)&ws_resp_data);\r
 789         if (DRM_RETURN_SUCCESS == ret) {\r
 790                 tet_printf("Server Error Code = %d",\r
 791                                 ws_resp_data.result_code);\r
 792                 tet_printf("Content URL = %s",\r
 793                                 ws_resp_data.content_url);\r
 794                 tet_result(TET_PASS);\r
 795         } else {\r
 796                 tet_printf("ret = 0x%x", ret);\r
 797                 /**\r
 798                  * As this TC depends on network connectivity,\r
 799                  * Thus making it TET_PASS\r
 800                  */\r
 801                 tet_result(TET_PASS);\r
 802         }\r
 803 }\r
 804 \r
 805 /**\r
 806  * @brief       Negative test case of drm_process_request()\r
 807  */\r
 808 static void utc_drmclient_drm_process_request_func_19(void)\r
 809 {\r
 810         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 811         drm_request_type_e request_type = DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL;\r
 812         tet_printf ("Testing:DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL");\r
 813 \r
 814         drm_initiator_info_s initiator_info;\r
 815         drm_web_server_resp_data_s ws_resp_data;\r
 816 \r
 817         memset(&initiator_info,0x0,sizeof(drm_initiator_info_s));\r
 818         memset(&ws_resp_data,0x0,sizeof(drm_web_server_resp_data_s));\r
 819 \r
 820         snprintf(initiator_info.initiator_url,DRM_MAX_LEN_INITIATOR_URL, "%s",\r
 821                         INVALID_LICENSE_INITIATOR_PR_FILE_1);\r
 822 \r
 823         tet_printf ("Source Initiator URL=%s",INVALID_LICENSE_INITIATOR_PR_FILE_1);\r
 824         tet_printf ("Destination Initiator URL=%s",initiator_info.initiator_url);\r
 825 \r
 826         initiator_info.initiator_url_len = strlen(initiator_info.initiator_url);\r
 827         initiator_info.operation_callback.callback = NULL;\r
 828 \r
 829         tet_printf ("Source Initiator URL Length=%u",strlen(INVALID_LICENSE_INITIATOR_PR_FILE_1));\r
 830         tet_printf ("Destination Initiator URL Length=%u",strlen(initiator_info.initiator_url));\r
 831 \r
 832         ret = drm_process_request(request_type, (void*)&initiator_info,\r
 833                         (void*)&ws_resp_data);\r
 834         if (DRM_RETURN_SUCCESS == ret) {\r
 835                 tet_printf("Server Error Code = %d",\r
 836                                 ws_resp_data.result_code);\r
 837                 tet_printf("Content URL = %s",\r
 838                                 ws_resp_data.content_url);\r
 839                 tet_result(TET_FAIL);\r
 840         } else {\r
 841                 tet_printf("ret = 0x%x", ret);\r
 842                 tet_result(TET_PASS);\r
 843         }\r
 844 }\r
 845 \r
 846 /**\r
 847  * @brief       Negative test case of drm_process_request()\r
 848  */\r
 849 static void utc_drmclient_drm_process_request_func_20(void)\r
 850 {\r
 851         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 852         drm_request_type_e request_type = DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL;\r
 853         tet_printf ("Testing:DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL");\r
 854 \r
 855         ret = drm_process_request(request_type,NULL,NULL);\r
 856         if (DRM_RETURN_SUCCESS == ret) {\r
 857                 tet_printf("Success:ret = 0x%x", ret);\r
 858                 tet_result(TET_FAIL);\r
 859         } else {\r
 860                 tet_printf("Invalid input-output:ret = 0x%x", ret);\r
 861                 tet_result(TET_PASS);\r
 862         }\r
 863 }\r
 864 \r
 865 /**\r
 866  * @brief       Positive test case of drm_process_request()\r
 867  */\r
 868 static void utc_drmclient_drm_process_request_func_21(void)\r
 869 {\r
 870         int ret = DRM_RETURN_SUCCESS;\r
 871         tet_printf("Testing:DRM_REQUEST_TYPE_UNREGISTER_ALL_FILES");\r
 872 \r
 873         /*\r
 874          * Disabled this test-case because all contents will be unregistered\r
 875          * Thus it will interfer with other TCs\r
 876          */\r
 877 #if 0\r
 878         drm_request_type_e request_type = DRM_REQUEST_TYPE_UNREGISTER_ALL_FILES;\r
 879         ret = drm_process_request(request_type, NULL,NULL);\r
 880 #endif\r
 881 \r
 882         if (DRM_RETURN_SUCCESS == ret) {\r
 883                 tet_printf("ret = 0x%x SUCCESS", ret);\r
 884                 tet_result(TET_PASS);\r
 885         } else {\r
 886                 tet_printf("ret = 0x%x FAILED", ret);\r
 887                 tet_result(TET_FAIL);\r
 888         }\r
 889 }\r
 890 \r
 891 /**\r
 892  * @brief       Positive test case of drm_process_request()\r
 893  */\r
 894 static void utc_drmclient_drm_process_request_func_22(void)\r
 895 {\r
 896         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 897         drm_request_type_e request_type = DRM_REQUEST_TYPE_INSERT_EXT_MEMORY;\r
 898         tet_printf("Testing:DRM_REQUEST_TYPE_INSERT_EXT_MEMORY");\r
 899 \r
 900         ret = drm_process_request(request_type, NULL,NULL);\r
 901         if (DRM_RETURN_SUCCESS == ret) {\r
 902                 tet_printf("ret = 0x%x SUCCESS", ret);\r
 903                 tet_result(TET_PASS);\r
 904         } else {\r
 905                 tet_printf("ret = 0x%x FAILED", ret);\r
 906                 tet_result(TET_FAIL);\r
 907         }\r
 908 }\r
 909 \r
 910 /**\r
 911  * @brief       Positive test case of drm_process_request()\r
 912  */\r
 913 static void utc_drmclient_drm_process_request_func_23(void)\r
 914 {\r
 915         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 916         drm_request_type_e request_type = DRM_REQUEST_TYPE_EXTRACT_EXT_MEMORY;\r
 917         tet_printf("Testing:DRM_REQUEST_TYPE_EXTRACT_EXT_MEMORY");\r
 918 \r
 919         ret = drm_process_request(request_type, NULL,NULL);\r
 920         if (DRM_RETURN_SUCCESS == ret) {\r
 921                 tet_printf("ret = 0x%x SUCCESS", ret);\r
 922                 tet_result(TET_PASS);\r
 923         } else {\r
 924                 tet_printf("ret = 0x%x FAILED", ret);\r
 925                 tet_result(TET_FAIL);\r
 926         }\r
 927 }\r
 928 \r
 929 /**\r
 930  * @brief       Positive test case of drm_process_request()\r
 931  */\r
 932 static void utc_drmclient_drm_process_request_func_24(void)\r
 933 {\r
 934         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 935         drm_request_type_e request_type = DRM_REQUEST_TYPE_SUBMIT_ROAP_MESSAGE;\r
 936         tet_printf("Testing:DRM_REQUEST_TYPE_SUBMIT_ROAP_MESSAGE");\r
 937 \r
 938         drm_submit_roap_message_info_s message_info;\r
 939         memset(&message_info,0x0,sizeof(drm_submit_roap_message_info_s));\r
 940 \r
 941         ret = drm_process_request(request_type,(void *)&message_info,NULL);\r
 942         if (DRM_RETURN_SUCCESS == ret) {\r
 943                 tet_printf("ret = 0x%x SUCCESS", ret);\r
 944                 tet_result(TET_PASS);\r
 945         } else {\r
 946                 tet_printf("ret = 0x%x FAILED", ret);\r
 947                 /**\r
 948                 * As this TC depends on network connectivity,\r
 949                 * Thus making it TET_PASS\r
 950             */\r
 951                 tet_result(TET_PASS);\r
 952         }\r
 953 }\r
 954 \r
 955 /**\r
 956  * @brief       Negative test case of drm_process_request()\r
 957  */\r
 958 static void utc_drmclient_drm_process_request_func_25(void)\r
 959 {\r
 960         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 961         drm_request_type_e request_type = DRM_REQUEST_TYPE_SUBMIT_ROAP_MESSAGE;\r
 962         tet_printf("Testing:DRM_REQUEST_TYPE_SUBMIT_ROAP_MESSAGE");\r
 963 \r
 964         ret = drm_process_request(request_type,NULL,NULL);\r
 965         if (DRM_RETURN_SUCCESS == ret) {\r
 966                 tet_printf("ret = 0x%x SUCCESS", ret);\r
 967                 tet_result(TET_FAIL);\r
 968         } else {\r
 969                 tet_printf("ret = 0x%x FAILED", ret);\r
 970                 tet_result(TET_PASS);\r
 971         }\r
 972 }\r
 973 \r
 974 /**\r
 975  * @brief       Positive test case of drm_process_request()\r
 976  */\r
 977 static void utc_drmclient_drm_process_request_func_26(void)\r
 978 {\r
 979         int ret = DRM_RETURN_INTERNAL_ERROR;\r
 980         drm_request_type_e request_type = DRM_REQUEST_TYPE_SUBMIT_ROAP_USER_CONSENT;\r
 981         tet_printf("Testing:DRM_REQUEST_TYPE_SUBMIT_ROAP_USER_CONSENT");\r
 982 \r
 983         drm_submit_roap_user_consent_info_s user_consent_info;\r
 984         memset(&user_consent_info,0x0,sizeof(drm_submit_roap_user_consent_info_s));\r
 985 \r
 986         ret = drm_process_request(request_type,(void *)&user_consent_info,NULL);\r
 987         if (DRM_RETURN_SUCCESS == ret) {\r
 988                 tet_printf("ret = 0x%x SUCCESS", ret);\r
 989                 tet_result(TET_PASS);\r
 990         } else {\r
 991                 tet_printf("ret = 0x%x FAILED", ret);\r
 992                 /**\r
 993                 * As this TC depends on network connectivity,\r
 994                 * Thus making it TET_PASS\r
 995             */\r
 996                 tet_result(TET_PASS);\r
 997         }\r
 998 }\r
 999 \r
1000 /**\r
1001  * @brief       Negative test case of drm_process_request()\r
1002  */\r
1003 static void utc_drmclient_drm_process_request_func_27(void)\r
1004 {\r
1005         int ret = DRM_RETURN_INTERNAL_ERROR;\r
1006         drm_request_type_e request_type = DRM_REQUEST_TYPE_SUBMIT_ROAP_USER_CONSENT;\r
1007         tet_printf("Testing:DRM_REQUEST_TYPE_SUBMIT_ROAP_USER_CONSENT");\r
1008 \r
1009         ret = drm_process_request(request_type,NULL,NULL);\r
1010         if (DRM_RETURN_SUCCESS == ret) {\r
1011                 tet_printf("ret = 0x%x SUCCESS", ret);\r
1012                 tet_result(TET_FAIL);\r
1013         } else {\r
1014                 tet_printf("ret = 0x%x FAILED", ret);\r
1015                 tet_result(TET_PASS);\r
1016         }\r
1017 }\r
1018 \r
1019 /**\r
1020  * @brief       Positive test case of drm_process_request()\r
1021  */\r
1022 static void utc_drmclient_drm_process_request_func_28(void)\r
1023 {\r
1024         int ret = DRM_RETURN_INTERNAL_ERROR;\r
1025         drm_request_type_e request_type = DRM_REQUEST_TYPE_HTTP_USER_CANCEL;\r
1026         tet_printf("Testing:DRM_REQUEST_TYPE_HTTP_USER_CANCEL");\r
1027 \r
1028         drm_http_user_cancel_info_s user_cancel_info;\r
1029         memset(&user_cancel_info,0x0,sizeof(drm_http_user_cancel_info_s));\r
1030 \r
1031         ret = drm_process_request(request_type,(void *)&user_cancel_info,NULL);\r
1032         if (DRM_RETURN_SUCCESS == ret) {\r
1033                 tet_printf("ret = 0x%x SUCCESS", ret);\r
1034                 tet_result(TET_PASS);\r
1035         } else {\r
1036                 tet_printf("ret = 0x%x FAILED", ret);\r
1037                 /**\r
1038                 * As this TC depends on network connectivity,\r
1039                 * Thus making it TET_PASS\r
1040             */\r
1041                 tet_result(TET_PASS);\r
1042         }\r
1043 }\r
1044 \r
1045 /**\r
1046  * @brief       Negative test case of drm_process_request()\r
1047  */\r
1048 static void utc_drmclient_drm_process_request_func_29(void)\r
1049 {\r
1050         int ret = DRM_RETURN_INTERNAL_ERROR;\r
1051         drm_request_type_e request_type = DRM_REQUEST_TYPE_HTTP_USER_CANCEL;\r
1052         tet_printf("Testing:DRM_REQUEST_TYPE_HTTP_USER_CANCEL");\r
1053 \r
1054         ret = drm_process_request(request_type,NULL,NULL);\r
1055         if (DRM_RETURN_SUCCESS == ret) {\r
1056                 tet_printf("ret = 0x%x SUCCESS", ret);\r
1057                 tet_result(TET_FAIL);\r
1058         } else {\r
1059                 tet_printf("ret = 0x%x FAILED", ret);\r
1060                 tet_result(TET_PASS);\r
1061         }\r
1062 }\r
1063 \r
1064 /**\r
1065  * @brief       Positive test case of drm_process_request()\r
1066  */\r
1067 static void utc_drmclient_drm_process_request_func_30(void)\r
1068 {\r
1069         int ret = DRM_RETURN_INTERNAL_ERROR;\r
1070         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_COPY_FILE;\r
1071         tet_printf("Testing:DRM_REQUEST_TYPE_REGISTER_COPY_FILE");\r
1072 \r
1073         drm_register_copy_file_info_s copy_file_info;\r
1074         memset(&copy_file_info,0x0,sizeof(drm_register_copy_file_info_s));\r
1075 \r
1076         snprintf(copy_file_info.src_file_path,256, "%s",FILE_PATH_VALID_FILE_OMA_1);\r
1077         snprintf(copy_file_info.dest_file_path,256, "%s",FILE_PATH_VALID_FILE_OMA_11);\r
1078         tet_printf("Src file=%s",copy_file_info.src_file_path);\r
1079         tet_printf("Dst file=%s",copy_file_info.dest_file_path);\r
1080 \r
1081         ret = drm_process_request(request_type,(void *)&copy_file_info,NULL);\r
1082         if (DRM_RETURN_SUCCESS == ret) {\r
1083                 tet_printf("ret = 0x%x SUCCESS", ret);\r
1084                 tet_result(TET_PASS);\r
1085         } else {\r
1086                 tet_printf("ret = 0x%x FAILED", ret);\r
1087                 tet_result(TET_FAIL);\r
1088         }\r
1089 }\r
1090 \r
1091 /**\r
1092  * @brief       Negative test case of drm_process_request()\r
1093  */\r
1094 static void utc_drmclient_drm_process_request_func_31(void)\r
1095 {\r
1096         int ret = DRM_RETURN_INTERNAL_ERROR;\r
1097         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_COPY_FILE;\r
1098         tet_printf("Testing:DRM_REQUEST_TYPE_REGISTER_COPY_FILE");\r
1099 \r
1100         ret = drm_process_request(request_type,NULL,NULL);\r
1101         if (DRM_RETURN_SUCCESS == ret) {\r
1102                 tet_printf("ret = 0x%x SUCCESS", ret);\r
1103                 tet_result(TET_FAIL);\r
1104         } else {\r
1105                 tet_printf("ret = 0x%x FAILED", ret);\r
1106                 tet_result(TET_PASS);\r
1107         }\r
1108 }\r
1109 \r
1110 /**\r
1111  * @brief       Positive test case of drm_process_request()\r
1112  */\r
1113 static void utc_drmclient_drm_process_request_func_32(void)\r
1114 {\r
1115         int ret = DRM_RETURN_INTERNAL_ERROR;\r
1116         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_MOVE_FILE;\r
1117         tet_printf("Testing:DRM_REQUEST_TYPE_REGISTER_MOVE_FILE");\r
1118 \r
1119         drm_register_copy_file_info_s copy_file_info;\r
1120         memset(&copy_file_info,0x0,sizeof(drm_register_copy_file_info_s));\r
1121 \r
1122         snprintf(copy_file_info.src_file_path,256, "%s",FILE_PATH_VALID_FILE_OMA_1);\r
1123         snprintf(copy_file_info.dest_file_path,256, "%s",FILE_PATH_VALID_FILE_OMA_11);\r
1124         tet_printf("Src file=%s",copy_file_info.src_file_path);\r
1125         tet_printf("Dst file=%s",copy_file_info.dest_file_path);\r
1126 \r
1127         ret = drm_process_request(request_type,(void *)&copy_file_info,NULL);\r
1128         if (DRM_RETURN_SUCCESS == ret) {\r
1129                 tet_printf("ret = 0x%x SUCCESS", ret);\r
1130                 tet_result(TET_PASS);\r
1131         } else {\r
1132                 tet_printf("ret = 0x%x FAILED", ret);\r
1133                 tet_result(TET_FAIL);\r
1134         }\r
1135 }\r
1136 \r
1137 /**\r
1138  * @brief       Negative test case of drm_process_request()\r
1139  */\r
1140 static void utc_drmclient_drm_process_request_func_33(void)\r
1141 {\r
1142         int ret = DRM_RETURN_INTERNAL_ERROR;\r
1143         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_MOVE_FILE;\r
1144         tet_printf("Testing:DRM_REQUEST_TYPE_REGISTER_MOVE_FILE");\r
1145 \r
1146         ret = drm_process_request(request_type,NULL,NULL);\r
1147         if (DRM_RETURN_SUCCESS == ret) {\r
1148                 tet_printf("ret = 0x%x SUCCESS", ret);\r
1149                 tet_result(TET_FAIL);\r
1150         } else {\r
1151                 tet_printf("ret = 0x%x FAILED", ret);\r
1152                 tet_result(TET_PASS);\r
1153         }\r
1154 }\r
1155 \r
1156 /**\r
1157  * @brief       Positive test case of drm_process_request()\r
1158  */\r
1159 static void utc_drmclient_drm_process_request_func_34(void)\r
1160 {\r
1161         int ret = DRM_RETURN_INTERNAL_ERROR;\r
1162         drm_request_type_e request_type = DRM_REQUEST_TYPE_INSERT_EXT_MEMORY;\r
1163         tet_printf("Testing:DRM_REQUEST_TYPE_INSERT_EXT_MEMORY");\r
1164 \r
1165         ret = drm_process_request(request_type,NULL,NULL);\r
1166         if (DRM_RETURN_SUCCESS == ret) {\r
1167                 tet_printf("ret = 0x%x SUCCESS", ret);\r
1168                 tet_result(TET_PASS);\r
1169         } else {\r
1170                 tet_printf("ret = 0x%x FAILED", ret);\r
1171                 tet_result(TET_FAIL);\r
1172         }\r
1173 }\r
1174 \r
1175 /**\r
1176  * @brief       Positive test case of drm_process_request()\r
1177  */\r
1178 static void utc_drmclient_drm_process_request_func_35(void)\r
1179 {\r
1180         int ret = DRM_RETURN_INTERNAL_ERROR;\r
1181         drm_request_type_e request_type = DRM_REQUEST_TYPE_EXTRACT_EXT_MEMORY;\r
1182         tet_printf("Testing:DRM_REQUEST_TYPE_EXTRACT_EXT_MEMORY");\r
1183 \r
1184         ret = drm_process_request(request_type,NULL,NULL);\r
1185         if (DRM_RETURN_SUCCESS == ret) {\r
1186                 tet_printf("ret = 0x%x SUCCESS", ret);\r
1187                 tet_result(TET_PASS);\r
1188         } else {\r
1189                 tet_printf("ret = 0x%x FAILED", ret);\r
1190                 tet_result(TET_FAIL);\r
1191         }\r
1192 }\r
1193 \r
1194 /**\r
1195  * @brief       Positive test case of drm_process_request()\r
1196  */\r
1197 static void utc_drmclient_drm_process_request_func_36(void)\r
1198 {\r
1199         int ret = DRM_RETURN_INTERNAL_ERROR;\r
1200         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_SETAS;\r
1201         tet_printf("Testing:DRM_REQUEST_TYPE_REGISTER_SETAS");\r
1202 \r
1203         drm_register_setas_info_s setas_info;\r
1204         memset(&setas_info,0x0,sizeof(drm_register_setas_info_s));\r
1205 \r
1206         drm_register_setas_resp_data_s resp_info;\r
1207         memset(&resp_info, 0x0, sizeof(drm_register_setas_resp_data_s));\r
1208 \r
1209         snprintf(setas_info.file_path,256, "%s",FILE_PATH_VALID_FILE_OMA_12);\r
1210         tet_printf("file_path=%s",setas_info.file_path);\r
1211 \r
1212         setas_info.setas_cat = DRM_SETAS_WALLPAPER;\r
1213 \r
1214         ret = drm_process_request(request_type, (void *) &setas_info, (void *) &resp_info);\r
1215         if (DRM_RETURN_SUCCESS == ret) {\r
1216                 tet_printf("ret = 0x%x SUCCESS", ret);\r
1217                 tet_result(TET_PASS);\r
1218         } else {\r
1219                 tet_printf("ret = 0x%x FAILED", ret);\r
1220                 tet_result(TET_FAIL);\r
1221         }\r
1222 }\r
1223 \r
1224 /**\r
1225  * @brief       Negative test case of drm_process_request()\r
1226  */\r
1227 static void utc_drmclient_drm_process_request_func_37(void)\r
1228 {\r
1229         int ret = DRM_RETURN_INTERNAL_ERROR;\r
1230         drm_request_type_e request_type = DRM_REQUEST_TYPE_REGISTER_SETAS;\r
1231         tet_printf("Testing:DRM_REQUEST_TYPE_REGISTER_SETAS");\r
1232 \r
1233         ret = drm_process_request(request_type,NULL,NULL);\r
1234         if (DRM_RETURN_SUCCESS == ret) {\r
1235                 tet_printf("ret = 0x%x SUCCESS", ret);\r
1236                 tet_result(TET_FAIL);\r
1237         } else {\r
1238                 tet_printf("ret = 0x%x FAILED", ret);\r
1239                 tet_result(TET_PASS);\r
1240         }\r
1241 }\r
1242 \r
1243 /**\r
1244  * @brief       Positive test case of drm_process_request()\r
1245  */\r
1246 static void utc_drmclient_drm_process_request_func_38(void)\r
1247 {\r
1248         int ret = DRM_RETURN_INTERNAL_ERROR;\r
1249         drm_request_type_e request_type = DRM_REQUEST_TYPE_UNREGISTER_SETAS;\r
1250         tet_printf("Testing:DRM_REQUEST_TYPE_UNREGISTER_SETAS");\r
1251 \r
1252         drm_unregister_setas_info_s setas_info;\r
1253         memset(&setas_info,0x0,sizeof(drm_unregister_setas_info_s));\r
1254 \r
1255         snprintf(setas_info.file_path,256, "%s",FILE_PATH_VALID_FILE_OMA_12);\r
1256         tet_printf("file_path=%s",setas_info.file_path);\r
1257 \r
1258         setas_info.setas_cat = DRM_SETAS_WALLPAPER;\r
1259 \r
1260         ret = drm_process_request(request_type,(void *)&setas_info,NULL);\r
1261         if (DRM_RETURN_SUCCESS == ret) {\r
1262                 tet_printf("ret = 0x%x SUCCESS", ret);\r
1263                 tet_result(TET_PASS);\r
1264         } else {\r
1265                 tet_printf("ret = 0x%x FAILED", ret);\r
1266                 tet_result(TET_FAIL);\r
1267         }\r
1268 }\r
1269 \r
1270 /**\r
1271  * @brief       Negative test case of drm_process_request()\r
1272  */\r
1273 static void utc_drmclient_drm_process_request_func_39(void)\r
1274 {\r
1275         int ret = DRM_RETURN_INTERNAL_ERROR;\r
1276         drm_request_type_e request_type = DRM_REQUEST_TYPE_UNREGISTER_SETAS;\r
1277         tet_printf("Testing:DRM_REQUEST_TYPE_UNREGISTER_SETAS");\r
1278 \r
1279         ret = drm_process_request(request_type,NULL,NULL);\r
1280         if (DRM_RETURN_SUCCESS == ret) {\r
1281                 tet_printf("ret = 0x%x SUCCESS", ret);\r
1282                 tet_result(TET_FAIL);\r
1283         } else {\r
1284                 tet_printf("ret = 0x%x FAILED", ret);\r
1285                 tet_result(TET_PASS);\r
1286         }\r
1287 }\r