TC/testcase/utc_media_recorder_lifecycle.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 #include <tet_api.h>
  20 #include <media/recorder.h>
  21
  22 static void startup(void);
  23 static void cleanup(void);
  24
  25 void (*tet_startup)(void) = startup;
  26 void (*tet_cleanup)(void) = cleanup;
  27
  28 static void utc_media_recorder_create_audiorecorder_p(void);
  29 static void utc_media_recorder_create_audiorecorder_n(void);
  30 static void utc_media_recorder_cancel_p(void);
  31 static void utc_media_recorder_cancel_n(void);
  32 static void utc_media_recorder_commit_p(void);
  33 static void utc_media_recorder_commit_n(void);
  34 static void utc_media_recorder_create_videorecorder_p(void);
  35 static void utc_media_recorder_create_videorecorder_n(void);
  36 static void utc_media_recorder_destroy_p(void);
  37 static void utc_media_recorder_destroy_n(void);
  38 static void utc_media_recorder_pause_p(void);
  39 static void utc_media_recorder_pause_n(void);
  40 static void utc_media_recorder_ready_p(void);
  41 static void utc_media_recorder_ready_n(void);
  42 static void utc_media_recorder_start_p(void);
  43 static void utc_media_recorder_start_n(void);
  44 static void utc_media_recorder_unready_p(void);
  45 static void utc_media_recorder_unready_n(void);
  46
  47
  48 struct tet_testlist tet_testlist[] = {
  49         { utc_media_recorder_create_audiorecorder_p, 1 },
  50         { utc_media_recorder_create_audiorecorder_n, 2 },
  51         { utc_media_recorder_cancel_p , 1 },
  52         { utc_media_recorder_cancel_n , 2 },
  53         { utc_media_recorder_commit_p , 1 },
  54         { utc_media_recorder_commit_n , 2 },
  55         { utc_media_recorder_create_videorecorder_p , 1 },
  56         { utc_media_recorder_create_videorecorder_n , 2 },
  57         { utc_media_recorder_destroy_p , 1 },
  58         { utc_media_recorder_destroy_n , 2 },
  59         { utc_media_recorder_pause_p , 1 },
  60         { utc_media_recorder_pause_n , 2 },
  61         { utc_media_recorder_ready_p , 1 },
  62         { utc_media_recorder_ready_n , 2 },
  63         { utc_media_recorder_start_p , 1 },
  64         { utc_media_recorder_start_n , 2 },
  65         { utc_media_recorder_unready_p , 1 },
  66         { utc_media_recorder_unready_n , 2 },
  67         { NULL, 0 },
  68 };
  69
  70 static void startup(void)
  71 {
  72         /* start of TC */
  73 }
  74
  75 static void cleanup(void)
  76 {
  77         /* end of TC */
  78 }
  79
  80 /**
  81  * @brief Negative test case of recorder_create_audiorecorder()
  82  */
  83 static void utc_media_recorder_create_audiorecorder_n(void)
  84 {
  85         int ret;
  86         ret = recorder_create_audiorecorder(NULL);
  87         dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "not allow NULL");
  88
  89 }
  90
  91 static void utc_media_recorder_create_audiorecorder_p(void)
  92 {
  93         int ret;
  94         recorder_h recorder;
  95         ret = recorder_create_audiorecorder(&recorder);
  96         dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "create_audiorecorder is faild");
  97         recorder_destroy(recorder);
  98 }
  99
 100
 101 static void utc_media_recorder_cancel_p(void)
 102 {
 103         int ret;
 104         recorder_h recorder;
 105         ret = recorder_create_audiorecorder(&recorder);
 106         ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 107         ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
 108         ret |= recorder_prepare(recorder);
 109         ret |= recorder_start(recorder);
 110         dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
 111         sleep(2);
 112         ret = recorder_cancel(recorder);
 113         dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "record commit is fail");
 114         recorder_unprepare(recorder);
 115         recorder_destroy(recorder);
 116 }
 117
 118 static void utc_media_recorder_cancel_n(void)
 119 {
 120         int ret;
 121         recorder_h recorder;
 122         ret = recorder_create_audiorecorder(&recorder);
 123         ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 124         ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
 125         ret |= recorder_prepare(recorder);
 126         dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
 127         ret = recorder_cancel(recorder);
 128         dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "invalid state");
 129         recorder_unprepare(recorder);
 130         recorder_destroy(recorder);
 131 }
 132
 133
 134 static void utc_media_recorder_commit_p(void)
 135 {
 136         int ret;
 137         recorder_h recorder;
 138         ret = recorder_create_audiorecorder(&recorder);
 139         ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 140         ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
 141         ret |= recorder_prepare(recorder);
 142         ret |= recorder_start(recorder);
 143         dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
 144         sleep(2);
 145         ret = recorder_commit(recorder);
 146         dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "record commit is fail");
 147         recorder_unprepare(recorder);
 148         recorder_destroy(recorder);
 149 }
 150
 151 static void utc_media_recorder_commit_n(void)
 152 {
 153         int ret;
 154         recorder_h recorder;
 155         ret =recorder_create_audiorecorder(&recorder);
 156         ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 157         ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
 158         ret |= recorder_prepare(recorder);
 159         dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
 160         ret = recorder_commit(recorder);
 161         dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "invalid state");
 162         recorder_unprepare(recorder);
 163         recorder_destroy(recorder);
 164 }
 165
 166 static void utc_media_recorder_create_videorecorder_p(void)
 167 {
 168         recorder_h recorder;
 169         camera_h camera;
 170         int ret;
 171         ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
 172         dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "create camera is faild");
 173
 174         ret = recorder_create_videorecorder(camera, &recorder);
 175         dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "create recorder is faild");
 176         recorder_destroy(recorder);
 177         camera_destroy(camera);
 178 }
 179
 180 static void utc_media_recorder_create_videorecorder_n(void)
 181 {
 182         recorder_h recorder;
 183         int ret;
 184         ret = recorder_create_videorecorder(NULL, &recorder);
 185         dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "not allow NULL");
 186 }
 187
 188 static void utc_media_recorder_destroy_p(void)
 189 {
 190         recorder_h recorder;
 191         int ret;
 192         ret = recorder_create_audiorecorder(&recorder);
 193         dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "create recorder is faild");
 194         ret = recorder_destroy(recorder);
 195         dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "recorder_destroy is faild");
 196 }
 197
 198 static void utc_media_recorder_destroy_n(void)
 199 {
 200         int ret;
 201         ret = recorder_destroy(NULL);
 202         dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "not allow NULL");
 203 }
 204
 205 static void utc_media_recorder_pause_p(void)
 206 {
 207         int ret;
 208         recorder_h recorder;
 209         ret = recorder_create_audiorecorder(&recorder);
 210         ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 211         ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
 212         ret |= recorder_prepare(recorder);
 213         ret |= recorder_start(recorder);
 214         dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
 215         sleep(2);
 216         ret = recorder_pause(recorder);
 217         dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "record commit is fail");
 218         recorder_cancel(recorder);
 219         recorder_unprepare(recorder);
 220         recorder_destroy(recorder);
 221
 222 }
 223
 224 static void utc_media_recorder_pause_n(void)
 225 {
 226         int ret;
 227         recorder_h recorder;
 228         ret = recorder_create_audiorecorder(&recorder);
 229         ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 230         ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
 231         ret |= recorder_prepare(recorder);
 232         dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
 233         ret = recorder_pause(recorder);
 234         dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "invalid state");
 235         recorder_unprepare(recorder);
 236         recorder_destroy(recorder);
 237 }
 238
 239 static void utc_media_recorder_ready_p(void)
 240 {
 241         int ret;
 242         recorder_h recorder;
 243         ret = recorder_create_audiorecorder(&recorder);
 244         ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 245         ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
 246         dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
 247         ret = recorder_prepare(recorder);
 248         dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "invalid state");
 249         recorder_unprepare(recorder);
 250         recorder_destroy(recorder);
 251 }
 252
 253 static void utc_media_recorder_ready_n(void)
 254 {
 255         int ret;
 256         recorder_h recorder;
 257         ret = recorder_create_audiorecorder(&recorder);
 258         ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 259         ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
 260         ret |= recorder_prepare(recorder);
 261         dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
 262         ret = recorder_prepare(recorder);
 263         dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "invalid state");
 264         recorder_unprepare(recorder);
 265         recorder_destroy(recorder);
 266 }
 267
 268 static void utc_media_recorder_start_p(void)
 269 {
 270         int ret;
 271         recorder_h recorder;
 272         ret = recorder_create_audiorecorder(&recorder);
 273         ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 274         ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
 275         ret |= recorder_prepare(recorder);
 276         dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "recorder create fail");
 277         ret = recorder_start(recorder);
 278         dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "recorder start record fail");
 279         recorder_cancel(recorder);
 280         recorder_unprepare(recorder);
 281         recorder_destroy(recorder);
 282 }
 283
 284 static void utc_media_recorder_start_n(void)
 285 {
 286         int ret;
 287         recorder_h recorder;
 288         ret = recorder_create_audiorecorder(&recorder);
 289         dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "recorder create fail");
 290
 291         ret = recorder_start(recorder);
 292         dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "expect invalid state");
 293         recorder_destroy(recorder);
 294 }
 295
 296 static void utc_media_recorder_unready_p(void)
 297 {
 298         int ret;
 299         recorder_h recorder;
 300         ret = recorder_create_audiorecorder(&recorder);
 301         ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
 302         ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
 303         ret |= recorder_prepare(recorder);
 304         dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "recorder create fail");
 305         ret = recorder_unprepare(recorder);
 306         dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "recorder unready fail");
 307         recorder_destroy(recorder);
 308 }
 309
 310 static void utc_media_recorder_unready_n(void)
 311 {
 312         int ret;
 313         recorder_h recorder;
 314         ret = recorder_create_audiorecorder(&recorder);
 315         dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "recorder create fail");
 316
 317         ret = recorder_unprepare(recorder);
 318         dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "expect invalid state");
 319         recorder_destroy(recorder);
 320 }
 321
 322
 323