diff options
Diffstat (limited to 'TC/testcase/utc_media_camera_attr.c')
| -rwxr-xr-x | TC/testcase/utc_media_camera_attr.c | 731 |
1 files changed, 731 insertions, 0 deletions
diff --git a/TC/testcase/utc_media_camera_attr.c b/TC/testcase/utc_media_camera_attr.c new file mode 100755 index 0000000..6d3fb33 --- /dev/null +++ b/TC/testcase/utc_media_camera_attr.c @@ -0,0 +1,731 @@ +/* +* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + + + +#include <tet_api.h> +#include <media/camera.h> +#include <stdio.h> + +#define MY_ASSERT( fun , test , msg ) \ +{\ + if( !test ) \ + dts_fail(fun , msg ); \ +} + +static void startup(void); +static void cleanup(void); +static bool _cb_af_mode(camera_attr_af_mode_e mode, void *user_data); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_media_camera_attr_set_preview_fps_negative(void); +static void utc_media_camera_attr_set_preview_fps_positive(void); + +static void utc_media_camera_attr_set_image_quality_negative(void); +static void utc_media_camera_attr_set_image_quality_positive(void); + +static void utc_media_camera_attr_get_preview_fps_negative(void); +static void utc_media_camera_attr_get_preview_fps_positive(void); + +static void utc_media_camera_attr_get_image_quality_negative(void); +static void utc_media_camera_attr_get_image_quality_positive(void); + +static void utc_media_camera_attr_set_zoom_negative(void); +static void utc_media_camera_attr_set_zoom_positive(void); + +static void utc_media_camera_attr_set_af_mode_negative(void); +static void utc_media_camera_attr_set_af_mode_positive(void); + +static void utc_media_camera_attr_set_exposure_mode_negative(void); +static void utc_media_camera_attr_set_exposure_mode_positive(void); + +static void utc_media_camera_attr_set_exposure_negative(void); +static void utc_media_camera_attr_set_exposure_positive(void); + +static void utc_media_camera_attr_set_iso_negative(void); +static void utc_media_camera_attr_set_iso_positive(void); + +static void utc_media_camera_attr_set_brightness_negative(void); +static void utc_media_camera_attr_set_brightness_positive(void); + +static void utc_media_camera_attr_set_contrast_negative(void); +static void utc_media_camera_attr_set_contrast_positive(void); + +static void utc_media_camera_attr_set_whitebalance_negative(void); +static void utc_media_camera_attr_set_whitebalance_positive(void); + +static void utc_media_camera_attr_get_effect_negative(void); +static void utc_media_camera_attr_get_effect_positive(void); + +static void utc_media_camera_attr_get_scene_mode_negative(void); +static void utc_media_camera_attr_get_scene_mode_positive(void); + +static void utc_media_camera_attr_is_enable_tag_negative(void); +static void utc_media_camera_attr_is_enable_tag_positive(void); + +static void utc_media_camera_attr_get_tag_image_description_negative(void); +static void utc_media_camera_attr_get_tag_image_description_positive(void); + +static void utc_media_camera_attr_get_tag_orientation_negative(void); +static void utc_media_camera_attr_get_tag_orientation_positive(void); + +static void utc_media_camera_attr_get_tag_software_negative(void); +static void utc_media_camera_attr_get_tag_software_positive(void); + +static void utc_media_camera_attr_get_geotag_negative(void); +static void utc_media_camera_attr_get_geotag_positive(void); + +static void utc_media_camera_attr_get_flash_mode_negative(void); +static void utc_media_camera_attr_get_flash_mode_positive(void); + +static void utc_media_camera_attr_foreach_supported_af_mode_negative(void); +static void utc_media_camera_attr_foreach_supported_af_mode_positive(void); + +static void utc_media_camera_attr_foreach_supported_exposure_mode_negative(void); +static void utc_media_camera_attr_foreach_supported_exposure_mode_positive(void); + +static void utc_media_camera_attr_foreach_supported_iso_negative(void); +static void utc_media_camera_attr_foreach_supported_iso_positive(void); + +static void utc_media_camera_attr_foreach_supported_whitebalance_negative(void); +static void utc_media_camera_attr_foreach_supported_whitebalance_positive(void); + +static void utc_media_camera_attr_foreach_supported_effect_negative(void); +static void utc_media_camera_attr_foreach_supported_effect_positive(void); + +static void utc_media_camera_attr_foreach_supported_scene_mode_negative(void); +static void utc_media_camera_attr_foreach_supported_scene_mode_positive(void); + +static void utc_media_camera_attr_foreach_supported_flash_mode_negative(void); +static void utc_media_camera_attr_foreach_supported_flash_mode_positive(void); + +static void utc_media_camera_attr_foreach_supported_fps_negative(void); +static void utc_media_camera_attr_foreach_supported_fps_positive(void); + +static void utc_media_camera_attr_get_lens_orientation_negative(void); +static void utc_media_camera_attr_get_lens_orientation_positive(void); + + +struct tet_testlist tet_testlist[] = { + {utc_media_camera_attr_set_preview_fps_negative , 1}, + {utc_media_camera_attr_set_preview_fps_positive , 2 }, + {utc_media_camera_attr_set_image_quality_negative, 3 }, + {utc_media_camera_attr_set_image_quality_positive, 4}, + {utc_media_camera_attr_get_preview_fps_negative, 5}, + {utc_media_camera_attr_get_preview_fps_positive, 6}, + {utc_media_camera_attr_get_image_quality_negative, 7}, + {utc_media_camera_attr_get_image_quality_positive, 8}, + {utc_media_camera_attr_set_zoom_negative, 9}, + {utc_media_camera_attr_set_zoom_positive, 10}, + {utc_media_camera_attr_set_af_mode_negative, 11}, + {utc_media_camera_attr_set_af_mode_positive, 12}, + {utc_media_camera_attr_set_exposure_mode_negative, 13}, + {utc_media_camera_attr_set_exposure_mode_positive, 14}, + {utc_media_camera_attr_set_exposure_negative, 15}, + {utc_media_camera_attr_set_exposure_positive, 16}, + {utc_media_camera_attr_set_iso_negative, 17}, + {utc_media_camera_attr_set_iso_positive, 18}, + {utc_media_camera_attr_set_brightness_negative, 19}, + {utc_media_camera_attr_set_brightness_positive, 20}, + {utc_media_camera_attr_set_contrast_negative, 21}, + {utc_media_camera_attr_set_contrast_positive, 22}, + {utc_media_camera_attr_set_whitebalance_negative, 23}, + {utc_media_camera_attr_set_whitebalance_positive, 24}, + {utc_media_camera_attr_get_effect_negative, 25}, + {utc_media_camera_attr_get_effect_positive, 26}, + {utc_media_camera_attr_get_scene_mode_negative, 27}, + {utc_media_camera_attr_get_scene_mode_positive, 28}, + {utc_media_camera_attr_is_enable_tag_negative, 29}, + {utc_media_camera_attr_is_enable_tag_positive, 30}, + {utc_media_camera_attr_get_tag_image_description_negative, 31}, + {utc_media_camera_attr_get_tag_image_description_positive, 32}, + {utc_media_camera_attr_get_tag_orientation_negative, 33}, + {utc_media_camera_attr_get_tag_orientation_positive, 34}, + {utc_media_camera_attr_get_tag_software_negative, 35}, + {utc_media_camera_attr_get_tag_software_positive, 36}, + {utc_media_camera_attr_get_geotag_negative, 37}, + {utc_media_camera_attr_get_geotag_positive, 38}, + {utc_media_camera_attr_get_flash_mode_negative, 43}, + {utc_media_camera_attr_get_flash_mode_positive, 44}, + {utc_media_camera_attr_foreach_supported_af_mode_negative, 45}, + {utc_media_camera_attr_foreach_supported_af_mode_positive, 46}, + {utc_media_camera_attr_foreach_supported_exposure_mode_negative, 47}, + {utc_media_camera_attr_foreach_supported_exposure_mode_positive, 48}, + {utc_media_camera_attr_foreach_supported_iso_negative, 49}, + {utc_media_camera_attr_foreach_supported_iso_positive, 50}, + {utc_media_camera_attr_foreach_supported_whitebalance_negative, 51}, + {utc_media_camera_attr_foreach_supported_whitebalance_positive, 52}, + {utc_media_camera_attr_foreach_supported_effect_negative, 53}, + {utc_media_camera_attr_foreach_supported_effect_positive, 54}, + {utc_media_camera_attr_foreach_supported_scene_mode_negative, 55}, + {utc_media_camera_attr_foreach_supported_scene_mode_positive, 56}, + {utc_media_camera_attr_foreach_supported_flash_mode_negative, 57}, + {utc_media_camera_attr_foreach_supported_flash_mode_positive, 58}, + {utc_media_camera_attr_foreach_supported_fps_negative, 59}, + {utc_media_camera_attr_foreach_supported_fps_positive, 60}, + {utc_media_camera_attr_get_lens_orientation_negative, 61}, + {utc_media_camera_attr_get_lens_orientation_positive, 62}, + { NULL, 0 }, +}; + +camera_h camera; + +static void startup(void) +{ + fprintf(stderr, "%s test\n", __func__); + /* start of TC */ + int ret; + ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera); + if( ret != 0 ) + dts_fail("camera_create", "Could not create camera"); +} + +static void cleanup(void) +{ + /* end of TC */ + camera_destroy(camera); +} + +static void utc_media_camera_attr_set_preview_fps_negative(void) +{ + fprintf(stderr, "%s test\n", __func__); + int ret; + ret = camera_attr_set_preview_fps(camera, -1); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); +} +static void utc_media_camera_attr_set_preview_fps_positive(void) +{ + int ret; + ret = camera_attr_set_preview_fps(camera, CAMERA_ATTR_FPS_AUTO); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "CAMERA_ATTR_FPS_AUTO set is faild"); +} + +static void utc_media_camera_attr_set_image_quality_negative(void) +{ + int ret; + ret = camera_attr_set_image_quality(camera, -1); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed"); + +} + +static void utc_media_camera_attr_set_image_quality_positive(void) +{ + int ret; + ret = camera_attr_set_image_quality(camera, 100); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set 100 is faild"); + +} + +static void utc_media_camera_attr_get_preview_fps_negative(void) +{ + int ret; + ret = camera_attr_get_preview_fps(camera, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} + +static void utc_media_camera_attr_get_preview_fps_positive(void) +{ + int ret; + camera_attr_fps_e value; + ret = camera_attr_get_preview_fps(camera, &value); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "fail get preview fps"); +} + +static void utc_media_camera_attr_get_image_quality_negative(void) +{ + int ret; + ret = camera_attr_get_image_quality(camera, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} +static void utc_media_camera_attr_get_image_quality_positive(void) +{ + int ret; + int value; + ret = camera_attr_get_image_quality(camera, &value); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "fail get image quality"); +} + +static void utc_media_camera_attr_set_zoom_negative(void) +{ + int ret; + ret = camera_attr_set_zoom(camera, -1); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed"); + +} +static void utc_media_camera_attr_set_zoom_positive(void) +{ + int ret; + int min,max; + ret = camera_attr_get_zoom_range(camera, &min, &max); + + if( ret != 0 ) + dts_fail(__func__ , "Failed getting zoom range" ); + + if( max == -1 ) + dts_pass(__func__, "this target is not supported zoom"); + + ret = camera_attr_set_zoom(camera,min); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set 10 is failed"); +} + +static void utc_media_camera_attr_set_af_mode_negative(void) +{ + int ret; + ret = camera_attr_set_af_mode(camera, -1); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed"); + +} + +static void utc_media_camera_attr_set_af_mode_positive(void) +{ + int ret; + int af_mode = CAMERA_ATTR_AF_NONE; + + camera_attr_foreach_supported_af_mode(camera, _cb_af_mode, &af_mode); + ret = camera_attr_set_af_mode(camera, af_mode); + printf("camera_attr_set_af_mode %d ret=%x\n", af_mode, ret); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set af mode is faild"); + +} + +static void utc_media_camera_attr_set_exposure_mode_negative(void) +{ + int ret; + ret = camera_attr_set_exposure_mode(camera, -1); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed"); +} +static void utc_media_camera_attr_set_exposure_mode_positive(void) +{ + int ret; + ret = camera_attr_set_exposure_mode(camera, CAMERA_ATTR_EXPOSURE_MODE_ALL); + printf("camera_attr_set_exposure_mode %x\n", ret); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set CAMERA_ATTR_EXPOSURE_MODE_ALL is faild"); +} + +static void utc_media_camera_attr_set_exposure_negative(void) +{ + int ret; + ret = camera_attr_set_exposure(camera, -1); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed"); + +} +static void utc_media_camera_attr_set_exposure_positive(void) +{ + int ret; + int min,max; + ret = camera_attr_get_exposure_range(camera, &min, &max); + + if( ret != 0 ) + dts_fail(__func__ , "Failed getting exposure range" ); + + if( max == -1 ) + dts_pass(__func__, "this target is not supproted exposure "); + + + ret = camera_attr_set_exposure(camera, min); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set 1 is faild"); + +} + +static void utc_media_camera_attr_set_iso_negative(void) +{ + int ret; + ret = camera_attr_set_iso(camera, -1); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed"); +} +static void utc_media_camera_attr_set_iso_positive(void) +{ + int ret; + ret = camera_attr_set_iso(camera, CAMERA_ATTR_ISO_AUTO); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "CAMERA_ATTR_ISO_AUTO set is faild"); + +} + +static void utc_media_camera_attr_set_brightness_negative(void) +{ + int ret; + ret = camera_attr_set_brightness(camera, -1); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed"); + +} +static void utc_media_camera_attr_set_brightness_positive(void) +{ + int ret; + int min, max; + ret = camera_attr_get_brightness_range(camera, &min, &max); + if( ret != 0 ) + dts_fail(__func__ , "Failed getting brightness range" ); + + if( max == -1 ) + dts_pass(__func__, "this target is not supported brightness "); + ret = camera_attr_set_brightness(camera, min+1); + printf("camera_attr_set_brightness ret = %d, min = %d\n", ret, min); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set 1 is faild"); + +} + +static void utc_media_camera_attr_set_contrast_negative(void) +{ + int ret; + ret = camera_attr_set_contrast(camera, -1); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed"); +} +static void utc_media_camera_attr_set_contrast_positive(void) +{ + int ret; + int min, max; + ret = camera_attr_get_contrast_range(camera, &min, &max); + if( ret != 0 ) + dts_fail(__func__ , "Failed getting contrast range" ); + + if( max == -1 ) + dts_pass(__func__, "this target is not supported contrast "); + ret = camera_attr_set_contrast(camera, min); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set 1 is faild"); +} + +static void utc_media_camera_attr_set_whitebalance_negative(void) +{ + int ret; + ret = camera_attr_set_whitebalance(camera, -1); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "-1 is not allowed"); +} +static void utc_media_camera_attr_set_whitebalance_positive(void) +{ + int ret; + ret = camera_attr_set_whitebalance(camera, CAMERA_ATTR_WHITE_BALANCE_AUTOMATIC); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "set CAMERA_ATTR_WHITE_BALANCE_AUTOMATIC is faild"); + +} + +static void utc_media_camera_attr_get_effect_negative(void) +{ + int ret; + ret = camera_attr_get_effect(camera, 0); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} +static void utc_media_camera_attr_get_effect_positive(void) +{ + int ret; + camera_attr_effect_mode_e value; + ret = camera_attr_get_effect(camera, &value); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild"); + +} + +static void utc_media_camera_attr_get_scene_mode_negative(void) +{ + int ret; + ret = camera_attr_get_scene_mode(camera, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} +static void utc_media_camera_attr_get_scene_mode_positive(void) +{ + int ret; + camera_attr_scene_mode_e value; + ret = camera_attr_get_scene_mode(camera, &value); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild"); + +} + +static void utc_media_camera_attr_is_enable_tag_negative(void) +{ + int ret; + ret = camera_attr_is_enabled_tag(camera, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); +} +static void utc_media_camera_attr_is_enable_tag_positive(void) +{ + int ret; + bool enable; + ret = camera_attr_is_enabled_tag(camera, &enable); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get enable tag is faild"); +} + +static void utc_media_camera_attr_get_tag_image_description_negative(void) +{ + int ret; + ret = camera_attr_get_tag_image_description(camera, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); +} +static void utc_media_camera_attr_get_tag_image_description_positive(void) +{ + int ret; + char *buffer; + ret = camera_attr_get_tag_image_description(camera, &buffer); + if( ret == 0) + free(buffer); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild"); +} + +static void utc_media_camera_attr_get_tag_orientation_negative(void) +{ + int ret; + ret = camera_attr_get_tag_orientation(camera, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} +static void utc_media_camera_attr_get_tag_orientation_positive(void) +{ + int ret; + camera_attr_tag_orientation_e value; + ret = camera_attr_get_tag_orientation(camera, &value); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild"); +} + +static void utc_media_camera_attr_get_tag_software_negative(void) +{ + int ret; + ret = camera_attr_get_tag_software(camera, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); +} +static void utc_media_camera_attr_get_tag_software_positive(void) +{ + int ret; + char *buffer; + ret = camera_attr_get_tag_software(camera, &buffer); + if(ret == 0 ) + free(buffer); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild"); +} + +static void utc_media_camera_attr_get_geotag_negative(void) +{ + int ret; + ret = camera_attr_get_geotag(camera, NULL, NULL, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} +static void utc_media_camera_attr_get_geotag_positive(void) +{ + int ret; + double value1,value2, value3; + ret = camera_attr_get_geotag(camera, &value1, &value2, &value3); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild"); + +} + + +static void utc_media_camera_attr_get_flash_mode_negative(void) +{ + int ret; + ret = camera_attr_get_flash_mode(camera, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} +static void utc_media_camera_attr_get_flash_mode_positive(void) +{ + int ret; + camera_attr_flash_mode_e value; + ret = camera_attr_get_flash_mode(camera, &value); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "get is faild"); + +} + +static void utc_media_camera_attr_foreach_supported_af_mode_negative(void) +{ + int ret; + ret = camera_attr_foreach_supported_af_mode(camera, NULL, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} + +static bool _cb_af_mode(camera_attr_af_mode_e mode, void *user_data) +{ + int *af_mode = NULL; + + af_mode = (int *)user_data; + if (af_mode) { + *af_mode = mode; + return false; + } + + return true; +} + +static void utc_media_camera_attr_foreach_supported_af_mode_positive(void) +{ + int ret; + ret = camera_attr_foreach_supported_af_mode(camera, _cb_af_mode, NULL); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "faild"); +} + +static void utc_media_camera_attr_foreach_supported_exposure_mode_negative(void) +{ + int ret; + ret = camera_attr_foreach_supported_exposure_mode(camera, NULL, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} + +bool _cb_exposure_mode(camera_attr_exposure_mode_e mode , void *user_data) +{ + return false; +} + +static void utc_media_camera_attr_foreach_supported_exposure_mode_positive(void) +{ + int ret; + ret = camera_attr_foreach_supported_exposure_mode(camera, _cb_exposure_mode, NULL); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_exposure_mode is failed"); + +} + +static void utc_media_camera_attr_foreach_supported_iso_negative(void) +{ + int ret; + ret = camera_attr_foreach_supported_iso(camera, NULL, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); +} + +bool _cb_iso(camera_attr_iso_e iso , void *user_data) +{ + return false; +} + +static void utc_media_camera_attr_foreach_supported_iso_positive(void) +{ + int ret; + ret = camera_attr_foreach_supported_iso(camera, _cb_iso, NULL); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_exposure_mode is faild"); +} + +static void utc_media_camera_attr_foreach_supported_whitebalance_negative(void) +{ + int ret; + ret = camera_attr_foreach_supported_whitebalance(camera, NULL, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); +} + +bool _cb_whitebalance_cb(camera_attr_whitebalance_e wb , void *user_data) +{ + return false; +} + +static void utc_media_camera_attr_foreach_supported_whitebalance_positive(void) +{ + int ret; + ret = camera_attr_foreach_supported_whitebalance(camera, _cb_whitebalance_cb, NULL); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_whitebalance is faild"); + +} + +static void utc_media_camera_attr_foreach_supported_effect_negative(void) +{ + int ret; + ret = camera_attr_foreach_supported_effect(camera, NULL, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} + +bool _cb_effect_cb(camera_attr_effect_mode_e effect , void *user_data) +{ + return false; +} + +static void utc_media_camera_attr_foreach_supported_effect_positive(void) +{ + int ret; + ret = camera_attr_foreach_supported_effect(camera, _cb_effect_cb, NULL); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_effect is faild"); + +} + +static void utc_media_camera_attr_foreach_supported_scene_mode_negative(void) +{ + int ret; + ret = camera_attr_foreach_supported_scene_mode(camera, NULL, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} + +bool _cb_scene_mode_cb(camera_attr_scene_mode_e mode , void *user_data) +{ + return false; +} + +static void utc_media_camera_attr_foreach_supported_scene_mode_positive(void) +{ + int ret; + ret = camera_attr_foreach_supported_scene_mode(camera, _cb_scene_mode_cb, NULL); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_scene_mode is faild"); + +} + +static void utc_media_camera_attr_foreach_supported_flash_mode_negative(void) +{ + int ret; + ret = camera_attr_foreach_supported_flash_mode(camera, NULL, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} + +bool _cb_flash_mode_cb(camera_attr_flash_mode_e mode, void *user_data) +{ + return false; +} + +static void utc_media_camera_attr_foreach_supported_flash_mode_positive(void) +{ + int ret; + ret = camera_attr_foreach_supported_flash_mode(camera, _cb_flash_mode_cb, NULL); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_flash_mode is faild"); + +} + +static void utc_media_camera_attr_foreach_supported_fps_negative(void) +{ + int ret; + ret = camera_attr_foreach_supported_fps(camera, NULL, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} + +bool _cb_fps_cb(camera_attr_fps_e fps, void *user_data) +{ + return false; +} + +static void utc_media_camera_attr_foreach_supported_fps_positive(void) +{ + int ret; + ret = camera_attr_foreach_supported_fps(camera, _cb_fps_cb, NULL); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_foreach_supported_fps is faild"); + +} + + +static void utc_media_camera_attr_get_lens_orientation_negative(void) +{ + int ret; + ret = camera_attr_get_lens_orientation(camera, NULL); + dts_check_ne(__func__, ret, CAMERA_ERROR_NONE, "NULL is not allowed"); + +} +static void utc_media_camera_attr_get_lens_orientation_positive(void) +{ + int ret; + int rotate; + ret = camera_attr_get_lens_orientation(camera, &rotate); + dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "camera_attr_get_lens_orientation is faild"); +} + |