TC/testcase/utc_media_recorder_working.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17
  18
  19
  20 #include <tet_api.h>
  21 #include <media/camera.h>
  22 #include <stdio.h>
  23 #include <glib.h>
  24 #include <media/recorder.h>
  25
  26 #define MY_ASSERT( fun , test , msg ) \
  27 {\
  28         if( !test ) \
  29                 dts_fail(fun , msg ); \
  30 }
  31
  32 static GMainLoop *g_mainloop = NULL;
  33 static GThread *event_thread;
  34 int preview_win = 0;
  35
  36
  37 static void utc_media_recorder_attribute_test(void);
  38 static void utc_media_recorder_state_change_test(void);
  39 static void utc_media_recorder_recoding_status_cb_test(void);
  40 static void utc_media_recorder_limit_cb_test(void);
  41
  42
  43 static void startup(void);
  44 static void cleanup(void);
  45
  46 void (*tet_startup)(void) = startup;
  47 void (*tet_cleanup)(void) = cleanup;
  48
  49
  50 struct tet_testlist tet_testlist[] = {
  51         { utc_media_recorder_attribute_test, 1 },
  52         { utc_media_recorder_state_change_test , 2 },
  53         { utc_media_recorder_recoding_status_cb_test , 3 },
  54         { utc_media_recorder_limit_cb_test , 4 },
  55         { NULL, 0 },
  56 };
  57
  58
  59 gpointer GmainThread(gpointer data){
  60         g_mainloop = g_main_loop_new (NULL, 0);
  61         g_main_loop_run (g_mainloop);
  62
  63         return NULL;
  64 }
  65
  66
  67 static void startup(void)
  68 {
  69         if( !g_thread_supported() )
  70         {
  71                 g_thread_init(NULL);
  72         }
  73
  74         GError *gerr = NULL;
  75         event_thread = g_thread_create(GmainThread, NULL, 1, &gerr);
  76 }
  77
  78 static void cleanup(void)
  79 {
  80         g_main_loop_quit (g_mainloop);
  81         g_thread_join(event_thread);
  82 }
  83
  84
  85
  86
  87 void record_state_cb(recorder_state_e previous , recorder_state_e current , int by_asm, void *user_data){
  88         char * state_table[] = {
  89                 "MEDIARECORDER_STATE_NONE",                             /**< recorder is not created yet */
  90                 "MEDIARECORDER_STATE_CREATED",                          /**< recorder is created, but not initialized yet */
  91                 "MEDIARECORDER_STATE_READY",                    /**< ready to record if video recorder is playing preview */
  92                 "MEDIARECORDER_STATE_RECORDING",        /**< While recording */
  93                 "MEDIARECORDER_STATE_PAUSED",                   /**< Pause recording */
  94                 "MEDIARECORDER_STATE_NUM"                               /**< Number of recorder states */
  95                 };
  96         printf("%s\n", state_table[current]);
  97 }
  98
  99 int recording_limit_size_test(recorder_h recorder){
 100         int ret;
 101         int fail=0;
 102         int int_value;
 103         // negative test
 104         printf("-------------limit size test----------------------\n");
 105         printf("-nagative test\n");
 106         ret = recorder_attr_set_size_limit(recorder, -1);
 107         if( ret == 0 ){
 108                 printf("FAIL\n");
 109                 fail++;
 110         }else
 111                 printf("PASS\n");
 112
 113         printf("-0 test\n");
 114         ret = recorder_attr_set_size_limit(recorder, 0);
 115         if( ret != 0 ){
 116                 printf("FAIL\n");
 117                 fail++;
 118         }else
 119                 printf("PASS\n");
 120
 121         ret = recorder_attr_get_size_limit(recorder,&int_value);
 122         if( int_value != 0){
 123                 printf("FAIL\n");
 124                 fail++;
 125         }else
 126                 printf("PASS\n");
 127
 128
 129         printf("-1212 set test\n");
 130         ret = recorder_attr_set_size_limit(recorder, 1212);
 131         if( ret != 0 ){
 132                 printf("FAIL\n");
 133                 fail++;
 134         }else
 135                 printf("PASS\n");
 136
 137         ret = recorder_attr_get_size_limit(recorder,&int_value);
 138         if( int_value != 1212){
 139                 printf("FAIL\n");
 140                 fail++;
 141         }else
 142                 printf("PASS\n");
 143
 144         return -fail;
 145 }
 146
 147 int recording_time_limit_test(recorder_h recorder){
 148         int ret;
 149         int fail=0;
 150         int int_value;
 151         // negative test
 152         printf("-------------limit time test----------------------\n");
 153
 154         ret = recorder_attr_set_time_limit(recorder, -1);
 155         if( ret == 0 ){
 156                 printf("FAIL\n");
 157                 fail++;
 158         }else
 159                 printf("PASS\n");
 160
 161         printf("-0 test\n");
 162         ret = recorder_attr_set_time_limit(recorder, 0);
 163         if( ret != 0 ){
 164                 printf("FAIL\n");
 165                 fail++;
 166         }else
 167                 printf("PASS\n");
 168
 169         ret = recorder_attr_get_time_limit(recorder,&int_value);
 170         if( int_value != 0){
 171                 printf("FAIL\n");
 172                 fail++;
 173         }else
 174                 printf("PASS\n");
 175
 176
 177         printf("-1212 set test\n");
 178         ret = recorder_attr_set_time_limit(recorder, 1212);
 179         if( ret != 0 ){
 180                 printf("FAIL\n");
 181                 fail++;
 182         }else
 183                 printf("PASS\n");
 184
 185         ret = recorder_attr_get_time_limit(recorder,&int_value);
 186         if( int_value != 1212){
 187                 printf("FAIL\n");
 188                 fail++;
 189         }else
 190                 printf("PASS\n");
 191
 192
 193         return -fail;
 194 }
 195
 196 int fileformat_test_fail = 0;
 197 bool _file_format_test_cb(recorder_file_format_e format, void *user_data){
 198         int ret;
 199         recorder_h recorder = (recorder_h)user_data;
 200         recorder_file_format_e get_format;
 201         ret = recorder_set_file_format(recorder, format);
 202         recorder_get_file_format(recorder, &get_format);
 203
 204         if( get_format != format){
 205                 printf("FAIL\n");
 206                 fileformat_test_fail++;
 207         }else
 208                 printf("PASS\n");
 209         return true;
 210 }
 211
 212
 213 int fileformat_test(recorder_h recorder){
 214         fileformat_test_fail = 0;
 215         printf("----------------file format test ------------------\n");
 216         recorder_foreach_supported_file_format(recorder, _file_format_test_cb, recorder);
 217         return -fileformat_test_fail;
 218 }
 219
 220 int videoencoder_test_fail = 0;
 221 bool _video_encoder_test_cb(recorder_video_codec_e codec, void *user_data){
 222         int ret;
 223         recorder_h recorder = (recorder_h)user_data;
 224         recorder_video_codec_e get_codec;
 225         ret = recorder_set_video_encoder(recorder, codec);
 226         recorder_get_video_encoder(recorder, &get_codec);
 227
 228
 229         if( get_codec != codec){
 230                 printf("FAIL\n");
 231                 videoencoder_test_fail++;
 232         }else
 233                 printf("PASS\n");
 234         return true;
 235 }
 236
 237
 238 int video_encoder_test(recorder_h recorder){
 239         videoencoder_test_fail = 0;
 240         printf("----------------video encorder test ------------------\n");
 241         recorder_foreach_supported_video_encoder(recorder, _video_encoder_test_cb, recorder);
 242         return -videoencoder_test_fail;
 243 }
 244
 245 int audioencoder_test_fail = 0;
 246 bool _audio_encoder_test_cb(recorder_audio_codec_e codec, void *user_data){
 247         int ret;
 248         recorder_h recorder = (recorder_h)user_data;
 249         recorder_audio_codec_e get_codec;
 250         ret = recorder_set_audio_encoder(recorder, codec);
 251         recorder_get_audio_encoder(recorder, &get_codec);
 252
 253
 254         if( get_codec != codec){
 255                 printf("FAIL\n");
 256                 audioencoder_test_fail++;
 257         }else
 258                 printf("PASS\n");
 259         return true;
 260 }
 261
 262
 263 int audio_encoder_test(recorder_h recorder){
 264         audioencoder_test_fail = 0;
 265         printf("----------------audio encorder test ------------------\n");
 266         recorder_foreach_supported_audio_encoder(recorder, _audio_encoder_test_cb, recorder);
 267         return -audioencoder_test_fail;
 268 }
 269
 270 int recording_audio_device_test(recorder_h recorder)
 271 {
 272         int ret;
 273         int fail=0;
 274         recorder_audio_device_e  int_value;
 275         // negative test
 276         printf("-------------audio device test----------------------\n");
 277         printf("-nagative test\n");
 278         ret = recorder_attr_set_audio_device (recorder, -1);
 279         if( ret == 0 ){
 280                 printf("FAIL\n");
 281                 fail++;
 282         }else
 283                 printf("PASS\n");
 284
 285         printf("-RECORDER_AUDIO_DEVICE_MIC test\n");
 286         ret = recorder_attr_set_audio_device(recorder, RECORDER_AUDIO_DEVICE_MIC);
 287         if( ret != 0 ){
 288                 printf("FAIL\n");
 289                 fail++;
 290         }else
 291                 printf("PASS\n");
 292
 293         ret = recorder_attr_get_audio_device(recorder,&int_value);
 294         if( int_value != RECORDER_AUDIO_DEVICE_MIC){
 295                 printf("FAIL\n");
 296                 fail++;
 297         }else
 298                 printf("PASS\n");
 299
 300
 301         printf("-RECORDER_AUDIO_DEVICE_MODEM  set test\n");
 302         ret = recorder_attr_set_audio_device(recorder, RECORDER_AUDIO_DEVICE_MODEM );
 303         if( ret != 0 ){
 304                 printf("FAIL\n");
 305                 fail++;
 306         }else
 307                 printf("PASS\n");
 308
 309         ret = recorder_attr_get_audio_device(recorder,&int_value);
 310         if( int_value != RECORDER_AUDIO_DEVICE_MODEM){
 311                 printf("FAIL\n");
 312                 fail++;
 313         }else
 314                 printf("PASS\n");
 315
 316         return -fail;
 317 }
 318
 319 int recording_samplerate_test(recorder_h recorder){
 320         int ret;
 321         int fail=0;
 322         int int_value;
 323         // negative test
 324         printf("-------------samplerate test----------------------\n");
 325
 326         ret = recorder_attr_set_audio_samplerate(recorder, -1);
 327         if( ret == 0 ){
 328                 printf("FAIL\n");
 329                 fail++;
 330         }else
 331                 printf("PASS\n");
 332
 333         printf("-44100 test\n");
 334         ret = recorder_attr_set_audio_samplerate(recorder, 44100);
 335         if( ret != 0 ){
 336                 printf("FAIL\n");
 337                 fail++;
 338         }else
 339                 printf("PASS\n");
 340
 341         ret = recorder_attr_get_audio_samplerate(recorder,&int_value);
 342         if( int_value != 44100){
 343                 printf("FAIL\n");
 344                 fail++;
 345         }else
 346                 printf("PASS\n");
 347
 348
 349         printf("-1212 set test\n");
 350         ret = recorder_attr_set_audio_samplerate(recorder, 1212);
 351         if( ret != 0 ){
 352                 printf("FAIL\n");
 353                 fail++;
 354         }else
 355                 printf("PASS\n");
 356
 357         ret = recorder_attr_get_audio_samplerate(recorder,&int_value);
 358         if( int_value != 1212){
 359                 printf("FAIL\n");
 360                 fail++;
 361         }else
 362                 printf("PASS\n");
 363
 364
 365         return -fail;
 366 }
 367
 368
 369 int recording_audio_encoder_bitrate_test(recorder_h recorder){
 370         int ret;
 371         int fail=0;
 372         int int_value;
 373         // negative test
 374         printf("-------------audio encoder bitrate test----------------------\n");
 375         printf("-negative test\n");
 376         ret = recorder_attr_set_audio_encoder_bitrate (recorder, -2);
 377         if( ret == 0 ){
 378                 printf("FAIL\n");
 379                 fail++;
 380         }else
 381                 printf("PASS\n");
 382
 383         printf("-12200 test\n");
 384         ret = recorder_attr_set_audio_encoder_bitrate (recorder, 12200);
 385         if( ret != 0 ){
 386                 printf("FAIL\n");
 387                 fail++;
 388         }else
 389                 printf("PASS\n");
 390
 391         ret = recorder_attr_get_audio_encoder_bitrate (recorder,&int_value);
 392         if( int_value != 12200){
 393                 printf("FAIL\n");
 394                 fail++;
 395         }else
 396                 printf("PASS\n");
 397
 398
 399         printf("-288000  set test\n");
 400         ret = recorder_attr_set_audio_encoder_bitrate (recorder, 288000 );
 401         if( ret != 0 ){
 402                 printf("FAIL\n");
 403                 fail++;
 404         }else
 405                 printf("PASS\n");
 406
 407         ret = recorder_attr_get_audio_encoder_bitrate (recorder,&int_value);
 408         if( int_value != 288000 ){
 409                 printf("FAIL\n");
 410                 fail++;
 411         }else
 412                 printf("PASS\n");
 413
 414         printf("-1212  set test\n");
 415         ret = recorder_attr_set_audio_encoder_bitrate (recorder, 1212 );
 416         if( ret != 0 ){
 417                 printf("FAIL\n");
 418                 fail++;
 419         }else
 420                 printf("PASS\n");
 421
 422         ret = recorder_attr_get_audio_encoder_bitrate (recorder,&int_value);
 423         if( int_value != 1212 ){
 424                 printf("FAIL\n");
 425                 fail++;
 426         }else
 427                 printf("PASS\n");
 428
 429         return -fail;
 430 }
 431
 432 int recording_video_encoder_bitrate_test(recorder_h recorder){
 433         int ret;
 434         int fail=0;
 435         int int_value;
 436         // negative test
 437         printf("-------------video encoder bitrate test----------------------\n");
 438         printf("-negative test\n");
 439         ret = recorder_attr_set_video_encoder_bitrate (recorder, -2);
 440         if( ret == 0 ){
 441                 printf("FAIL\n");
 442                 fail++;
 443         }else
 444                 printf("PASS\n");
 445
 446         printf("-12200 test\n");
 447         ret = recorder_attr_set_video_encoder_bitrate (recorder, 12200);
 448         if( ret != 0 ){
 449                 printf("FAIL\n");
 450                 fail++;
 451         }else
 452                 printf("PASS\n");
 453
 454         ret = recorder_attr_get_video_encoder_bitrate (recorder,&int_value);
 455         if( int_value != 12200){
 456                 printf("FAIL\n");
 457                 fail++;
 458         }else
 459                 printf("PASS\n");
 460
 461
 462         printf("-288000  set test\n");
 463         ret = recorder_attr_set_video_encoder_bitrate (recorder, 288000 );
 464         if( ret != 0 ){
 465                 printf("FAIL\n");
 466                 fail++;
 467         }else
 468                 printf("PASS\n");
 469
 470         ret = recorder_attr_get_video_encoder_bitrate (recorder,&int_value);
 471         if( int_value != 288000 ){
 472                 printf("FAIL\n");
 473                 fail++;
 474         }else
 475                 printf("PASS\n");
 476
 477         printf("-1212  set test\n");
 478         ret = recorder_attr_set_video_encoder_bitrate (recorder, 1212 );
 479         if( ret != 0 ){
 480                 printf("FAIL\n");
 481                 fail++;
 482         }else
 483                 printf("PASS\n");
 484
 485         ret = recorder_attr_get_video_encoder_bitrate (recorder,&int_value);
 486         if( int_value != 1212 ){
 487                 printf("FAIL\n");
 488                 fail++;
 489         }else
 490                 printf("PASS\n");
 491
 492         return -fail;
 493 }
 494
 495
 496 typedef struct{
 497         bool iscalled;
 498         bool isready;
 499         bool isrecording;
 500         bool ispaused;
 501         recorder_state_e state;
 502 } state_change_data;
 503
 504 void _state_change_test_cb(recorder_state_e previous, recorder_state_e current, bool by_asm, void *user_data){
 505         state_change_data * data = (state_change_data*)user_data;
 506         if( current == RECORDER_STATE_READY )
 507                 data->isready = true;
 508         if( current == RECORDER_STATE_RECORDING )
 509                 data->isrecording = true;
 510         if( current == RECORDER_STATE_PAUSED )
 511                 data->ispaused = true;
 512
 513         data->state = current;
 514
 515         //printf("state %d\n",current);
 516
 517 }
 518
 519 void utc_media_recorder_state_change_test(void){
 520         recorder_h recorder;
 521         state_change_data data;
 522         int ret;
 523         recorder_create_audiorecorder(&recorder);
 524         data.iscalled = false;
 525         data.isready = false;
 526         data.isrecording = false;
 527         data.ispaused = false;
 528         data.state = 0;
 529         printf("-------------------------recorder state change test -------------------\n");
 530         recorder_set_state_changed_cb(recorder, _state_change_test_cb, &data);
 531         recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
 532         recorder_prepare(recorder);
 533         ret = recorder_start(recorder);
 534         sleep(1);
 535         ret = recorder_pause(recorder);
 536         ret =recorder_commit(recorder);
 537         sleep(2);
 538
 539         if( data.isready && data.isrecording && data.ispaused && data.state == RECORDER_STATE_READY ){
 540                 printf("PASS\n");
 541                 ret = 0;
 542         }else{
 543                 printf("FAIL data.isready %d, data.isrecording %d,  data.ispaused %d,  data.state %d \n", data.isready , data.isrecording , data.ispaused , data.state );
 544                 ret = -1;
 545         }
 546
 547         recorder_unprepare(recorder);
 548         recorder_destroy(recorder);
 549
 550
 551         MY_ASSERT(__func__, ret == 0 , "Fail state change test");
 552         dts_pass(__func__, "PASS");
 553
 554 }
 555
 556
 557 typedef struct {
 558         int elapsed_time;
 559         int file_size;
 560 } recording_result;
 561 void _recording_status_test_cb(int elapsed_time, int file_size, void *user_data){
 562         recording_result *result = (recording_result*)user_data;
 563         result->elapsed_time = elapsed_time;
 564         result->file_size = file_size;
 565
 566 }
 567
 568 void utc_media_recorder_recoding_status_cb_test(void){
 569         recorder_h recorder;
 570         recording_result result;
 571         int ret;
 572
 573         printf("--------------recording status cb test-------------------\n");
 574         recorder_create_audiorecorder(&recorder);
 575         recorder_set_recording_status_cb(recorder,_recording_status_test_cb, &result);
 576         recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
 577         recorder_prepare(recorder);
 578         ret = recorder_start(recorder);
 579         result.elapsed_time = 0;
 580         result.file_size = 0;
 581         sleep(3);
 582         ret = recorder_cancel(recorder);
 583         ret =recorder_unprepare(recorder);
 584         ret =recorder_destroy(recorder);
 585         if( result.elapsed_time > 0  && result.file_size > 0){
 586                 printf("PASS\n");
 587                 dts_pass(__func__, "PASS");
 588         }else{
 589                 printf("FAIL\n");
 590                 dts_fail(__func__, "status cb Fail");
 591         }
 592 }
 593
 594
 595 void utc_media_recorder_attribute_test(void){
 596         int fail =0;
 597         int ret;
 598         recorder_h recorder;
 599         ret = recorder_create_audiorecorder(&recorder);
 600         fail = recording_limit_size_test(recorder);
 601         fail +=recording_time_limit_test(recorder);
 602         fail +=fileformat_test(recorder);
 603         fail +=video_encoder_test(recorder);
 604         fail +=audio_encoder_test(recorder);
 605         fail +=recording_audio_device_test(recorder);
 606         fail +=recording_samplerate_test(recorder);
 607         fail +=recording_audio_encoder_bitrate_test(recorder);
 608         fail +=recording_video_encoder_bitrate_test(recorder);
 609         MY_ASSERT(__func__, fail == 0 , "Fail recorder attribute");
 610         dts_pass(__func__, "PASS");
 611 }
 612
 613
 614
 615 void _recording_status_cb2(int elapsed_time, int file_size, void *user_data){
 616         //printf("elapsed time :%d , file_size :%d\n", elapsed_time , file_size);
 617
 618 }
 619
 620 void _recording_limited_reached_cb(recorder_recording_limit_type_e type, void *user_data){
 621         printf("limited!! %d\n", type);
 622         int *ischeck = (int*)user_data;
 623         *ischeck = 1;
 624 }
 625
 626
 627 void utc_media_recorder_limit_cb_test(void){
 628         recorder_h recorder;
 629         int ischeck = 0;
 630         int ret =0;
 631         recorder_state_e state;
 632         recorder_create_audiorecorder(&recorder);
 633         printf("------------------------limit cb test -------------------------\n");
 634         //recorder_set_state_change_cb(recorder, record_state_cb, NULL);
 635         recorder_set_recording_status_cb(recorder, _recording_status_cb2, NULL);
 636         recorder_set_recording_limit_reached_cb(recorder, _recording_limited_reached_cb, &ischeck);
 637         recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
 638         recorder_prepare(recorder);
 639
 640         recorder_get_state(recorder, &state);
 641
 642
 643         printf("-time limit test\n");
 644         recorder_attr_set_time_limit(recorder, 2);
 645         recorder_start(recorder);
 646         sleep(5);
 647         recorder_cancel(recorder);
 648         if( ischeck ){
 649                 printf("PASS\n");
 650         }else{
 651                 printf("FAIL\n");
 652                 ret--;
 653         }
 654
 655
 656         printf("-time unlimit test\n");
 657         //recorder_unready(recorder);
 658         recorder_attr_set_time_limit(recorder, 0);
 659         //recorder_ready(recorder);
 660
 661         recorder_start(recorder);
 662         ischeck = 0;
 663         sleep(5);
 664         recorder_cancel(recorder);
 665         if( ischeck ){
 666                 printf("FAIL\n");
 667                 ret--;
 668         }else{
 669                 printf("PASS\n");
 670         }
 671
 672
 673         printf("-size limit test\n");
 674         ischeck = 0;
 675         recorder_attr_set_size_limit(recorder, 2);
 676         recorder_start(recorder);
 677         sleep(5);
 678         recorder_cancel(recorder);
 679
 680         if( ischeck ){
 681                 printf("PASS\n");
 682         }else{
 683                 printf("FAIL\n");
 684                 ret--;
 685         }
 686
 687         printf("-size unlimit test\n");
 688         ischeck = 0;
 689         recorder_attr_set_size_limit(recorder, 0);
 690         recorder_start(recorder);
 691         sleep(5);
 692         recorder_cancel(recorder);
 693
 694         if( ischeck ){
 695                 printf("FAIL\n");
 696                 ret--;
 697         }else{
 698                 printf("PASS\n");
 699         }
 700
 701
 702         recorder_unprepare(recorder);
 703         recorder_destroy(recorder);
 704
 705         MY_ASSERT(__func__,  ret == 0 , "fail limit cb");
 706         dts_pass(__func__, "PASS");
 707 }
 708