From: Jiyong Min Date: Mon, 5 Mar 2018 06:33:22 +0000 (+0900) Subject: Code Refactoring for testsuite X-Git-Tag: submit/tizen/20180305.053300~1 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=897e4552ba554b7c3ece5af6411b91613100b09e;p=platform%2Fcore%2Fmultimedia%2Flibmm-utility.git Code Refactoring for testsuite - mm_util_bmp_testsuite - mm_util_jpeg_testsuite - mm_util_png_testsuite Change-Id: I21b4f457152d9a5b1f20b8aa23c7cfbbaf0d9723 Signed-off-by: Jiyong Min --- diff --git a/bmp/test/mm_util_bmp_testsuite.c b/bmp/test/mm_util_bmp_testsuite.c index ff31718..9f2a3bb 100755 --- a/bmp/test/mm_util_bmp_testsuite.c +++ b/bmp/test/mm_util_bmp_testsuite.c @@ -22,57 +22,352 @@ #include #include #include -#include +#include +#include +#include #include #include -#define DECODE_RESULT_PATH tzplatform_mkpath(TZ_USER_CONTENT, "decode_test.") -#define BUFFER_SIZE 128 +#define SAFE_FREE(x) { if (x != NULL) { free(x); x = NULL; } } +#define SAFE_G_FREE(x) { if (x != NULL) { g_free(x); x = NULL; } } -static inline void flush_stdin() +#define DECODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "bmp_test_dec_file.raw") +#define DECODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "bmp_test_dec_mem.raw") +#define ENCODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "bmp_test_enc_file.jpg") +#define ENCODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "bmp_test_enc_mem.jpg") + +typedef enum { + TEST_AUTO, + TEST_DECODE_FILE, + TEST_DECODE_MEMORY, + TEST_ENCODE_FILE, + TEST_ENCODE_MEMORY, + TEST_NUM, +} bmp_test_mode_e; + +static char *MODE_TO_STR[] = { + "AUTO", + "DECODE_FILE", + "DECODE_MEMORY", + "ENCODE_FILE", + "ENCODE_MEMORY", + "", +}; + +/* for arguments */ +static int g_test_mode = 0; +static char *g_path = NULL; + +/* for reading file */ +static void *g_readed_data = NULL; +static size_t g_readed_size = 0; + +static mm_util_bmp_data g_decoded_data = {0,}; + +static gboolean _read_file(char *path, void **data, size_t *length) { - int ch; - while ((ch = getchar()) != EOF && ch != '\n') ; + FILE *fp = NULL; + long len = 0; + + if (!path || !data || length == 0) { + fprintf(stderr, "\t[BMP_testsuite] invalid data %s %p %p\n", path, data, length); + return FALSE; + } + + fprintf(stderr, "\t[BMP_testsuite] %s read\n", path); + + fp = fopen(path, "r"); + if (fp == NULL) { + fprintf(stderr, "\t[BMP_testsuite] fopen failed (%d) \n", errno); + return FALSE; + } + + fseek(fp, 0, SEEK_END); + len = ftell(fp); + if (len < 0) { + fprintf(stderr, "\t[BMP_testsuite] ftell failed \n"); + fclose(fp); + return FALSE; + } + + rewind(fp); + *data = (void *)calloc(1, len); + if (*data == NULL) { + fprintf(stderr, "\tmemory allocation failed \n"); + fclose(fp); + return FALSE; + } + + *length = fread(*data, 1, (size_t)len, fp); + if (*length != len) { + fprintf(stderr, "\t[BMP_testsuite] fread failed \n"); + } + + fclose(fp); + + if (*data == NULL) { + *length = 0; + return FALSE; + } + + *length = (size_t)len; + + fprintf(stderr, "\t[BMP_testsuite] %s %zu read DONE\n", path, *length); + + return TRUE; } -int main(int argc, char *argv[]) +static gboolean _write_file(const char *path, void *data, size_t length) +{ + FILE *fp = NULL; + size_t len = 0; + + if (!path || !data || length == 0) { + fprintf(stderr, "\t[BMP_testsuite] invalid data %s %p %zu\n", path, data, length); + return FALSE; + } + + fprintf(stderr, "\t[BMP_testsuite] %s %p %zu write\n", path, data, length); + + fp = fopen(path, "w"); + if (fp == NULL) { + fprintf(stderr, "\t[BMP_testsuite] fopen failed (%d) \n", errno); + return FALSE; + } + + len = fwrite(data, 1, length, fp); + if (len != length) { + fprintf(stderr, "\t[BMP_testsuite] fwrite failed \n"); + } + + fclose(fp); + fp = NULL; + + fprintf(stderr, "\t[BMP_testsuite] %s write DONE\n", path); + + return TRUE; +} + +gboolean _get_input_data(const char *argv, const long min, const long max, int *data) +{ + if (argv == NULL || strlen(argv) == 0) + return FALSE; + + long temp = g_ascii_strtoll(argv, NULL, 10); + if (temp < min || temp > max) + return FALSE; + + *data = (int)temp; + + return TRUE; +} + +void _print_help(const char *argv0) +{ + fprintf(stderr, "\t[usage]\n"); + fprintf(stderr, "\t\t1. decode & encode : %s mode path\n", argv0); + fprintf(stderr, "\t\t2. decode : %s mode path\n", argv0); + fprintf(stderr, "\t\t3. encode : %s mode path width height\n", argv0); + fprintf(stderr, "\t\t4. mode : 0 - auto, 1 - decode from file, 2 - decode from memory, 3 - encode to file, 4 - encode to memeory\n"); +} + +gboolean _get_arguments(int argc, char *argv[]) +{ + int width = 0, height = 0; + + if (FALSE == _get_input_data(argv[1], TEST_AUTO, TEST_NUM - 1, &g_test_mode)) { + fprintf(stderr, "\t[BMP_testsuite] wrong mode(%s) for test\n", argv[1]); + _print_help(argv[0]); + return FALSE; + } + + g_path = g_strdup(argv[2]); + if (g_path == NULL) { + fprintf(stderr, "\t[BMP_testsuite] Not enough memory\n"); + return FALSE; + } + + if ((g_test_mode == TEST_AUTO) || (g_test_mode == TEST_DECODE_FILE) || (g_test_mode == TEST_DECODE_MEMORY)) { + /* do nothing */ + } else if (g_test_mode == TEST_ENCODE_FILE || g_test_mode == TEST_ENCODE_MEMORY) { + if (argc < 4) { + fprintf(stderr, "\t[BMP_testsuite] not enough args\n"); + _print_help(argv[0]); + return FALSE; + } + if (FALSE == _get_input_data(argv[3], 0, INT_MAX, &width)) { + fprintf(stderr, "\t[BMP_testsuite] wrong width %s\n", argv[3]); + return FALSE; + } + g_decoded_data.width = (unsigned long)width; + if (FALSE == _get_input_data(argv[4], 0, INT_MAX, &height)) { + fprintf(stderr, "\t[BMP_testsuite] wrong height %s\n", argv[4]); + return FALSE; + } + g_decoded_data.height = (unsigned long)height; + } else { + fprintf(stderr, "\t[BMP_testsuite] wrong mode for test %s\n", argv[1]); + return FALSE; + } + + return TRUE; +} + +gboolean _test_decode(const bmp_test_mode_e mode) +{ + int ret = 0; + + /* test decoding jpeg */ + if (mode == TEST_DECODE_FILE) { + ret = mm_util_decode_from_bmp_file(&g_decoded_data, g_path); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[BMP_testsuite] mm_util_decode_from_bmp_file failed %d\n", ret); + return FALSE; + } + if (FALSE == _write_file(DECODE_FILE_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) { + fprintf(stderr, "\t[BMP_testsuite] writing decoded data failed : %s\n", DECODE_FILE_PATH); + return FALSE; + } + } else if (mode == TEST_DECODE_MEMORY) { + if (FALSE == _read_file(g_path, &g_readed_data, &g_readed_size)) { + fprintf(stderr, "\t[BMP_testsuite] reading file error\n"); + return FALSE; + } + + ret = mm_util_decode_from_bmp_memory(&g_decoded_data, g_readed_data, (unsigned int)g_readed_size); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[BMP_testsuite] mm_util_decode_from_bmp_memory failed %d\n", ret); + return FALSE; + } + if (FALSE == _write_file(DECODE_MEM_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) { + fprintf(stderr, "\t[BMP_testsuite] writing decoded data failed : %s\n", DECODE_MEM_PATH); + return FALSE; + } + } + + return TRUE; +} + +gboolean _test_encode(const bmp_test_mode_e mode) { int ret = 0; - mm_util_bmp_data decoded; + /* for encoding jpeg to memory */ + void *encoded_data = NULL; + unsigned int encoded_size = 0; + + if ((mode != TEST_ENCODE_FILE) && (mode != TEST_ENCODE_MEMORY)) + return TRUE; + + if (FALSE == _read_file(g_path, &g_decoded_data.data, &g_readed_size)) { + fprintf(stderr, "\t[BMP_testsuite] reading file error\n"); + return FALSE; + } + g_decoded_data.size = (unsigned int)g_readed_size; + + /* test encoding jpeg */ + if (mode == TEST_ENCODE_FILE) { + ret = mm_util_encode_bmp_to_file(&g_decoded_data, ENCODE_FILE_PATH); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[BMP_testsuite] mm_util_jpeg_encode_to_file failed : %d\n", ret); + return FALSE; + } + } else if (mode == TEST_ENCODE_MEMORY) { + ret = mm_util_encode_bmp_to_memory(&g_decoded_data, &encoded_data, &encoded_size); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[BMP_testsuite] mm_util_jpeg_encode_to_file failed : %d\n", ret); + SAFE_FREE(encoded_data); + return FALSE; + } + if (FALSE == _write_file(ENCODE_MEM_PATH, encoded_data, (size_t)encoded_size)) { + fprintf(stderr, "\t[BMP_testsuite] writing decoded data failed : %s\n", ENCODE_MEM_PATH); + SAFE_FREE(encoded_data); + return FALSE; + } + } + SAFE_FREE(encoded_data); + return TRUE; +} + +gboolean _test_auto() +{ + bmp_test_mode_e test_mode = TEST_DECODE_FILE; + + while (test_mode < TEST_NUM) { + fprintf(stderr, "\t[BMP_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST START\n", MODE_TO_STR[test_mode]); + if (TEST_ENCODE_FILE == test_mode) { + SAFE_G_FREE(g_path); + g_path = g_strdup(DECODE_FILE_PATH); + if (g_path == NULL) { + fprintf(stderr, "\t[BMP_testsuite] Not enough memory\n"); + return FALSE; + } + } + /* test decoding jpeg */ + if ((test_mode == TEST_DECODE_FILE) || (test_mode == TEST_DECODE_MEMORY)) { + if (FALSE == _test_decode(test_mode)) { + fprintf(stderr, "\t[BMP_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]); + return FALSE; + } + } + + /* test encoding jpeg */ + if ((test_mode == TEST_ENCODE_FILE) || (test_mode == TEST_ENCODE_MEMORY)) { + if (FALSE == _test_encode(test_mode)) { + fprintf(stderr, "\t[BMP_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]); + return FALSE; + } + } + + fprintf(stderr, "\t[BMP_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST SUCCESS\n", MODE_TO_STR[test_mode]); + + SAFE_FREE(g_readed_data); + SAFE_FREE(g_decoded_data.data); + test_mode++; + } + + return TRUE; +} + +int main(int argc, char *argv[]) +{ if (argc < 2) { - fprintf(stderr, "\t[usage]\n"); - fprintf(stderr, "\t\t1. decode : mm_util_bmp_testsuite decode filepath.bmp\n"); + _print_help(argv[0]); return 0; } - if (!strcmp("decode", argv[1])) { - ret = mm_util_decode_from_bmp_file(&decoded, argv[2]); - } else { - fprintf(stderr, "\tunknown command [%s]\n", argv[1]); - return 0; + if (FALSE == _get_arguments(argc, argv)) { + fprintf(stderr, "\t[BMP_testsuite] _get_arguments failed\n"); + goto out; } - if (ret != MM_UTIL_ERROR_NONE) { - fprintf(stderr, "\tERROR is occurred %x\n", ret); - } else { - fprintf(stderr, "\tBMP OPERATION SUCCESS\n"); - { - if (decoded.data) { - fprintf(stderr, "\t##Decoded data##: %p\t width: %lu\t height:%lu\t size: %llu\n", decoded.data, decoded.width, decoded.height, decoded.size); - char filename[BUFFER_SIZE] = { 0, }; - memset(filename, 0, BUFFER_SIZE); - { - snprintf(filename, BUFFER_SIZE, "%s%s", DECODE_RESULT_PATH, "bmp"); - } - - ret = mm_util_encode_bmp_to_file(&decoded, filename); - - free(decoded.data); - } else { - fprintf(stderr, "\tDECODED data is NULL\n"); - } + /* test full functions automatically */ + if (g_test_mode == TEST_AUTO) { + if (FALSE == _test_auto()) + fprintf(stderr, "\t[BMP_testsuite] _test_auto failed\n"); + goto out; + } + + /* test decoding jpeg */ + if ((g_test_mode == TEST_DECODE_FILE) || (g_test_mode == TEST_DECODE_MEMORY)) { + if (FALSE == _test_decode(g_test_mode)) { + fprintf(stderr, "\t[BMP_testsuite] _test_decode(%s) failed\n", MODE_TO_STR[g_test_mode]); + goto out; + } + } + + /* test encoding jpeg */ + if ((g_test_mode == TEST_ENCODE_FILE) || (g_test_mode == TEST_ENCODE_MEMORY)) { + if (FALSE == _test_encode(g_test_mode)) { + fprintf(stderr, "\t[BMP_testsuite] _test_encode(%s) failed\n", MODE_TO_STR[g_test_mode]); + goto out; } } + +out: + SAFE_G_FREE(g_path); + SAFE_FREE(g_readed_data); + SAFE_FREE(g_decoded_data.data); + return 0; } diff --git a/jpeg/test/mm_util_jpeg_testsuite.c b/jpeg/test/mm_util_jpeg_testsuite.c index 092bdbf..03dff99 100755 --- a/jpeg/test/mm_util_jpeg_testsuite.c +++ b/jpeg/test/mm_util_jpeg_testsuite.c @@ -18,226 +18,376 @@ * limitations under the License. * */ + #include #include #include #include +#include +#include #include #include -#define ENCODE_RESULT_PATH tzplatform_mkpath(TZ_USER_CONTENT, "encode_test.jpg") -#define DECODE_RESULT_PATH tzplatform_mkpath(TZ_USER_CONTENT, "decode_test.") - -#define TRUE 1 -#define FALSE 0 -#define BUFFER_SIZE 128 -static inline void flush_stdin() -{ - int ch; - while ((ch = getchar()) != EOF && ch != '\n'); -} - - -static int _read_file(char *file_name, void **data, unsigned int *data_size) +#define SAFE_FREE(x) { if (x != NULL) { free(x); x = NULL; } } +#define SAFE_G_FREE(x) { if (x != NULL) { g_free(x); x = NULL; } } + +#define DECODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "jpeg_test_dec_file.raw") +#define DECODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "jpeg_test_dec_mem.raw") +#define ENCODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "jpeg_test_enc_file.jpg") +#define ENCODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "jpeg_test_enc_mem.jpg") + +typedef enum { + TEST_AUTO, + TEST_DECODE_FILE, + TEST_DECODE_MEMORY, + TEST_ENCODE_FILE, + TEST_ENCODE_MEMORY, + TEST_NUM, +} jpeg_test_mode_e; + +static char *MODE_TO_STR[] = { + "AUTO", + "DECODE_FILE", + "DECODE_MEMORY", + "ENCODE_FILE", + "ENCODE_MEMORY", + "", +}; + +/* for arguments */ +static int g_test_mode = 0; +static char *g_path = NULL; +static int g_color = MM_UTIL_COLOR_RGB24; +static int g_quality = 75; +static int g_downscale = MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1; + +/* for reading file */ +static void *g_readed_data = NULL; +static size_t g_readed_size = 0; + +static mm_util_jpeg_yuv_data g_decoded_data = {0,}; + +static gboolean _read_file(char *path, void **data, size_t *length) { FILE *fp = NULL; - long file_size = 0; + long len = 0; - if (!file_name || !data || !data_size) { - fprintf(stderr, "\tNULL pointer\n"); + if (!path || !data || length == 0) { + fprintf(stderr, "\t[JPEG_testsuite] invalid data %s %p %p\n", path, data, length); return FALSE; } - fprintf(stderr, "\tTry to open %s to read\n", file_name); + fprintf(stderr, "\t[JPEG_testsuite] %s read\n", path); - fp = fopen(file_name, "r"); + fp = fopen(path, "r"); if (fp == NULL) { - fprintf(stderr, "\tfile open failed %d\n", errno); + fprintf(stderr, "\t[JPEG_testsuite] fopen failed (%d) \n", errno); return FALSE; } fseek(fp, 0, SEEK_END); - file_size = ftell(fp); - if (file_size > -1L) { - rewind(fp); - *data = (void *)calloc(1, file_size); - if (*data == NULL) { - fprintf(stderr, "\tmemory allocation failed %d\n", errno); - fclose(fp); - fp = NULL; - return FALSE; - } else { - if (fread(*data, 1, file_size, fp) == (size_t)file_size) { - fprintf(stderr, "#Success# fread\n"); - } else { - fprintf(stderr, "#Error# fread\n"); - fclose(fp); - fp = NULL; - return FALSE; - } - } + len = ftell(fp); + if (len < 0) { + fprintf(stderr, "\t[JPEG_testsuite] ftell failed \n"); fclose(fp); - fp = NULL; + return FALSE; + } - if (*data) { - *data_size = (unsigned int)file_size; - return TRUE; - } else { - *data_size = 0; - return FALSE; - } - } else { - fprintf(stderr, "#Error# ftell\n"); + rewind(fp); + *data = (void *)calloc(1, len); + if (*data == NULL) { + fprintf(stderr, "\tmemory allocation failed \n"); fclose(fp); - fp = NULL; return FALSE; } -} + *length = fread(*data, 1, (size_t)len, fp); + if (*length != len) { + fprintf(stderr, "\t[JPEG_testsuite] fread failed \n"); + } + + fclose(fp); + + if (*data == NULL) { + *length = 0; + return FALSE; + } + + *length = (size_t)len; + + fprintf(stderr, "\t[JPEG_testsuite] %s %zu read DONE\n", path, *length); -static int _write_file(const char *file_name, void *data, unsigned int data_size) + return TRUE; +} + +static gboolean _write_file(const char *path, void *data, size_t length) { FILE *fp = NULL; + size_t len = 0; - if (!file_name || !data || data_size == 0) { - fprintf(stderr, "\tinvalid data %s %p size:%u\n", file_name, data, data_size); + if (!path || !data || length == 0) { + fprintf(stderr, "\t[JPEG_testsuite] invalid data %s %p %zu\n", path, data, length); return FALSE; } - fprintf(stderr, "\tTry to open %s to write\n", file_name); + fprintf(stderr, "\t[JPEG_testsuite] %s %p %zu write\n", path, data, length); - fp = fopen(file_name, "w"); + fp = fopen(path, "w"); if (fp == NULL) { - fprintf(stderr, "\tfile open failed %d\n", errno); + fprintf(stderr, "\t[JPEG_testsuite] fopen failed (%d) \n", errno); return FALSE; } - fwrite(data, 1, data_size, fp); + len = fwrite(data, 1, length, fp); + if (len != length) { + fprintf(stderr, "\t[JPEG_testsuite] fwrite failed \n"); + } + fclose(fp); fp = NULL; - fprintf(stderr, "\tfile [%s] write DONE\n", file_name); + fprintf(stderr, "\t[JPEG_testsuite] %s write DONE\n", path); return TRUE; } +gboolean _get_input_data(const char *argv, const long min, const long max, int *data) +{ + if (argv == NULL || strlen(argv) == 0) + return FALSE; -int main(int argc, char *argv[]) + long temp = g_ascii_strtoll(argv, NULL, 10); + if (temp < min || temp > max) + return FALSE; + + *data = (int)temp; + + return TRUE; +} + +void _print_help(const char *argv0) { - int ret = 0; - unsigned int src_size = 0; - unsigned int dst_size = 0; - int width = 0; - int height = 0; - int quality = 0; - void *src = NULL; - void *dst = NULL; - - mm_util_jpeg_yuv_data decoded_data = {0,}; - mm_util_color_format_e fmt; /* = MM_UTIL_COLOR_RGB24; */ - mm_util_jpeg_decode_downscale downscale; + fprintf(stderr, "\t[usage]\n"); + fprintf(stderr, "\t\t1. decode & encode : %s mode path color_format(opt.) quality(opt.) downscale(opt.)\n", argv0); + fprintf(stderr, "\t\t2. decode : %s mode path color_format(opt.)\n", argv0); + fprintf(stderr, "\t\t3. encode : %s mode path width(mand.) height(mand.) color_format(mand.) quality(opt.) downscale(opt.)\n", argv0); + fprintf(stderr, "\t\t4. mode : 0 - auto, 1 - decode from file, 2 - decode from memory, 3 - encode to file, 4 - encode to memeory\n"); +} - if (argc < 2) { - fprintf(stderr, "\t[usage]\n"); - fprintf(stderr, "\t\t1. encode : mm_util_jpeg_testsuite encode filepath.yuv width height quality\n"); - fprintf(stderr, "\t\t2. decode : mm_util_jpeg_testsuite decode filepath.jpg\n"); - fprintf(stderr, "\t\t3. decode_ds : mm_util_jpeg_testsuite decode_ds filepath.jpg format downscale\n"); - return 0; +gboolean _get_arguments(int argc, char *argv[]) +{ + if (FALSE == _get_input_data(argv[1], TEST_AUTO, TEST_NUM - 1, &g_test_mode)) { + fprintf(stderr, "\t[JPEG_testsuite] wrong mode(%s) for test\n", argv[1]); + _print_help(argv[0]); + return FALSE; } - /*g_type_init(); //when you include WINK */ + g_path = g_strdup(argv[2]); + if (g_path == NULL) { + fprintf(stderr, "\t[JPEG_testsuite] Not enough memory\n"); + return FALSE; + } + if (g_test_mode == TEST_AUTO) { + if (FALSE == _get_input_data(argv[3], MM_UTIL_COLOR_YUV420, MM_UTIL_COLOR_NUM - 1, &g_color)) + fprintf(stderr, "\t[JPEG_testsuite] color is default(%d)\n", g_color); + if (FALSE == _get_input_data(argv[4], 1, 100, &g_quality)) + fprintf(stderr, "\t[JPEG_testsuite] quality is default(%d)\n", g_quality); + if (FALSE == _get_input_data(argv[5], MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_8, &g_downscale)) + fprintf(stderr, "\t[JPEG_testsuite] downscale is default(%d)\n", g_downscale); + } else if (g_test_mode == TEST_DECODE_FILE) { + if (FALSE == _get_input_data(argv[3], MM_UTIL_COLOR_YUV420, MM_UTIL_COLOR_NUM - 1, &g_color)) + fprintf(stderr, "\t[JPEG_testsuite] color is default(%d)\n", g_color); + } else if (g_test_mode == TEST_DECODE_MEMORY) { + if (FALSE == _get_input_data(argv[3], MM_UTIL_COLOR_YUV420, MM_UTIL_COLOR_NUM - 1, &g_color)) + fprintf(stderr, "\t[JPEG_testsuite] color is default(%d)\n", g_color); + } else if (g_test_mode == TEST_ENCODE_FILE || g_test_mode == TEST_ENCODE_MEMORY) { + if (argc < 5) { + fprintf(stderr, "\t[JPEG_testsuite] not enough args\n"); + _print_help(argv[0]); + return FALSE; + } + if (FALSE == _get_input_data(argv[3], 0, INT_MAX, &g_decoded_data.width)) { + fprintf(stderr, "\t[JPEG_testsuite] wrong width %s\n", argv[3]); + return FALSE; + } + if (FALSE == _get_input_data(argv[4], 0, INT_MAX, &g_decoded_data.height)) { + fprintf(stderr, "\t[JPEG_testsuite] wrong height %s\n", argv[4]); + return FALSE; + } + if (FALSE == _get_input_data(argv[5], MM_UTIL_COLOR_YUV420, MM_UTIL_COLOR_NUM - 1, &g_color)) { + fprintf(stderr, "\t[JPEG_testsuite] wrong color %s\n", argv[5]); + return FALSE; + } + if (FALSE == _get_input_data(argv[6], 1, 100, &g_quality)) + fprintf(stderr, "\t[JPEG_testsuite] quality is default(%d)\n", g_quality); - if (!strcmp("encode", argv[1])) { - if (_read_file(argv[2], &src, &src_size)) { - width = atoi(argv[3]); - height = atoi(argv[4]); - quality = atoi(argv[5]); - fmt = atoi(argv[6]); + if (FALSE == _get_input_data(argv[7], MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_8, &g_downscale)) + fprintf(stderr, "\t[JPEG_testsuite] downscale is default(%d)\n", g_downscale); + } else { + fprintf(stderr, "\t[JPEG_testsuite] wrong mode for test %s\n", argv[1]); + return FALSE; + } - ret = mm_util_jpeg_encode_to_memory(&dst, &dst_size, src, width, height, fmt, quality); - } else { - ret = MM_UTIL_ERROR_INVALID_OPERATION; - } - } else if (!strcmp("enc2file", argv[1])) { - if (_read_file(argv[2], &src, &src_size)) { - width = atoi(argv[3]); - height = atoi(argv[4]); - quality = atoi(argv[5]); - fmt = atoi(argv[6]); + return TRUE; +} - ret = mm_util_jpeg_encode_to_file(ENCODE_RESULT_PATH, src, width, height, fmt, quality); - } else { - ret = MM_UTIL_ERROR_INVALID_OPERATION; +gboolean _test_decode(const jpeg_test_mode_e mode) +{ + int ret = 0; + + /* test decoding jpeg */ + if (mode == TEST_DECODE_FILE) { + ret = mm_util_decode_from_jpeg_file_with_downscale(&g_decoded_data, g_path, g_color, g_downscale); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[JPEG_testsuite] mm_util_decode_from_jpeg_file_with_downscale failed %d\n", ret); + return FALSE; + } + if (FALSE == _write_file(DECODE_FILE_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) { + fprintf(stderr, "\t[JPEG_testsuite] writing decoded data failed : %s\n", DECODE_FILE_PATH); + return FALSE; + } + } else if (mode == TEST_DECODE_MEMORY) { + if (FALSE == _read_file(g_path, &g_readed_data, &g_readed_size)) { + fprintf(stderr, "\t[JPEG_testsuite] reading file error\n"); + return FALSE; } - } else if (!strcmp("decode", argv[1])) { - if (_read_file(argv[2], &src, &src_size)) { - fmt = atoi(argv[3]); - ret = mm_util_decode_from_jpeg_memory_with_downscale(&decoded_data, src, src_size, fmt, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1); - free(src); - src = NULL; - } else { - ret = MM_UTIL_ERROR_INVALID_OPERATION; + ret = mm_util_decode_from_jpeg_memory_with_downscale(&g_decoded_data, g_readed_data, (unsigned int)g_readed_size, g_color, g_downscale); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[JPEG_testsuite] mm_util_decode_from_jpeg_memory_with_downscale failed %d\n", ret); + return FALSE; } - } else if (!strcmp("decode_ds", argv[1])) { - if (_read_file(argv[2], &src, &src_size)) { - fmt = atoi(argv[3]); - downscale = atoi(argv[4]); - ret = mm_util_decode_from_jpeg_memory_with_downscale(&decoded_data, src, src_size, fmt, downscale); + if (FALSE == _write_file(DECODE_MEM_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) { + fprintf(stderr, "\t[JPEG_testsuite] writing decoded data failed : %s\n", DECODE_MEM_PATH); + return FALSE; + } + } + + return TRUE; +} + +gboolean _test_encode(const jpeg_test_mode_e mode) +{ + int ret = 0; + /* for encoding jpeg to memory */ + void *encoded_data = NULL; + unsigned int encoded_size = 0; - free(src); - src = NULL; - } else { - ret = MM_UTIL_ERROR_INVALID_OPERATION; + if ((mode != TEST_ENCODE_FILE) && (mode != TEST_ENCODE_MEMORY)) + return TRUE; + + if (FALSE == _read_file(g_path, &g_decoded_data.data, &g_readed_size)) { + fprintf(stderr, "\t[JPEG_testsuite] reading file error\n"); + return FALSE; + } + g_decoded_data.size = (unsigned int)g_readed_size; + g_decoded_data.format = (mm_util_color_format_e)g_color; + + /* test encoding jpeg */ + if (mode == TEST_ENCODE_FILE) { + ret = mm_util_jpeg_encode_to_file(ENCODE_FILE_PATH, g_decoded_data.data, g_decoded_data.width, g_decoded_data.height, g_decoded_data.format, g_quality); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[JPEG_testsuite] mm_util_jpeg_encode_to_file failed : %d\n", ret); + return FALSE; + } + } else if (mode == TEST_ENCODE_MEMORY) { + ret = mm_util_jpeg_encode_to_memory(&encoded_data, &encoded_size, g_decoded_data.data, g_decoded_data.width, g_decoded_data.height, g_decoded_data.format, g_quality); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[JPEG_testsuite] mm_util_jpeg_encode_to_file failed : %d\n", ret); + SAFE_FREE(encoded_data); + return FALSE; + } + if (FALSE == _write_file(ENCODE_MEM_PATH, encoded_data, (size_t)encoded_size)) { + fprintf(stderr, "\t[JPEG_testsuite] writing decoded data failed : %s\n", ENCODE_MEM_PATH); + SAFE_FREE(encoded_data); + return FALSE; } - } else { - fprintf(stderr, "\tunknown command [%s]\n", argv[1]); - return 0; } - if (ret != MM_UTIL_ERROR_NONE) { - fprintf(stderr, "\tERROR is occurred %x\n", ret); - } else { - fprintf(stderr, "\tJPEG OPERATION SUCCESS\n"); - if (!strcmp("encode", argv[1])) { - if (dst) { - fprintf(stderr, "\t##Encoded data##: %p\tsize: %u\n", dst, dst_size); - - _write_file(ENCODE_RESULT_PATH, dst, dst_size); - - free(dst); - dst = NULL; - dst_size = 0; - } else { - fprintf(stderr, "\tENCODED data is NULL\n"); + SAFE_FREE(encoded_data); + return TRUE; +} + +gboolean _test_auto() +{ + jpeg_test_mode_e test_mode = TEST_DECODE_FILE; + + while (test_mode < TEST_NUM) { + fprintf(stderr, "\t[JPEG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST START\n", MODE_TO_STR[test_mode]); + if (TEST_ENCODE_FILE == test_mode) { + SAFE_G_FREE(g_path); + g_path = g_strdup(DECODE_FILE_PATH); + if (g_path == NULL) { + fprintf(stderr, "\t[JPEG_testsuite] Not enough memory\n"); + return FALSE; } - } else { - if (decoded_data.data) { - fprintf(stderr, "\t##Decoded data##: %p\t width: %d\t height:%d\t size: %d\n", decoded_data.data, decoded_data.width, decoded_data.height, decoded_data.size); - char filename[BUFFER_SIZE] = {0, }; - memset(filename, 0, BUFFER_SIZE); - if (fmt == MM_UTIL_COLOR_RGB24 || fmt == MM_UTIL_COLOR_RGBA || fmt == MM_UTIL_COLOR_BGRA || fmt == MM_UTIL_COLOR_ARGB) { - snprintf(filename, BUFFER_SIZE, "%s%s", DECODE_RESULT_PATH, "rgb"); - } else if ((fmt == MM_UTIL_COLOR_YUV420) || - (fmt == MM_UTIL_COLOR_YUV422) || - (fmt == MM_UTIL_COLOR_NV12) || - (fmt == MM_UTIL_COLOR_NV21) || - (fmt == MM_UTIL_COLOR_NV16) || - (fmt == MM_UTIL_COLOR_NV61)) { - snprintf(filename, BUFFER_SIZE, "%s%s", DECODE_RESULT_PATH, "yuv"); - } - _write_file(filename, decoded_data.data, decoded_data.size); - - free(decoded_data.data); - decoded_data.data = NULL; - decoded_data.size = 0; - } else { - fprintf(stderr, "\tDECODED data is NULL\n"); + } + /* test decoding jpeg */ + if ((test_mode == TEST_DECODE_FILE) || (test_mode == TEST_DECODE_MEMORY)) { + if (FALSE == _test_decode(test_mode)) { + fprintf(stderr, "\t[JPEG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]); + return FALSE; } } + + /* test encoding jpeg */ + if ((test_mode == TEST_ENCODE_FILE) || (test_mode == TEST_ENCODE_MEMORY)) { + if (FALSE == _test_encode(test_mode)) { + fprintf(stderr, "\t[JPEG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]); + return FALSE; + } + } + + fprintf(stderr, "\t[JPEG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST SUCCESS\n", MODE_TO_STR[test_mode]); + + SAFE_FREE(g_readed_data); + SAFE_FREE(g_decoded_data.data); + test_mode++; + } + + return TRUE; +} + +int main(int argc, char *argv[]) +{ + if (argc < 2) { + _print_help(argv[0]); + return 0; + } + + if (FALSE == _get_arguments(argc, argv)) { + fprintf(stderr, "\t[JPEG_testsuite] _get_arguments failed\n"); + goto out; + } + + /* test full functions automatically */ + if (g_test_mode == TEST_AUTO) { + if (FALSE == _test_auto()) + fprintf(stderr, "\t[JPEG_testsuite] _test_auto failed\n"); + goto out; + } + + /* test decoding jpeg */ + if ((g_test_mode == TEST_DECODE_FILE) || (g_test_mode == TEST_DECODE_MEMORY)) { + if (FALSE == _test_decode(g_test_mode)) { + fprintf(stderr, "\t[JPEG_testsuite] _test_decode(%s) failed\n", MODE_TO_STR[g_test_mode]); + goto out; + } + } + + /* test encoding jpeg */ + if ((g_test_mode == TEST_ENCODE_FILE) || (g_test_mode == TEST_ENCODE_MEMORY)) { + if (FALSE == _test_encode(g_test_mode)) { + fprintf(stderr, "\t[JPEG_testsuite] _test_encode(%s) failed\n", MODE_TO_STR[g_test_mode]); + goto out; + } } +out: + SAFE_G_FREE(g_path); + SAFE_FREE(g_readed_data); + SAFE_FREE(g_decoded_data.data); return 0; } diff --git a/png/test/mm_util_png_testsuite.c b/png/test/mm_util_png_testsuite.c index 22411d3..b12c8f9 100755 --- a/png/test/mm_util_png_testsuite.c +++ b/png/test/mm_util_png_testsuite.c @@ -23,164 +23,355 @@ #include #include #include +#include +#include #include #include -#define DECODE_RESULT_PATH tzplatform_mkpath(TZ_USER_CONTENT, "decode_test.") +#define SAFE_FREE(x) { if (x != NULL) { free(x); x = NULL; } } +#define SAFE_G_FREE(x) { if (x != NULL) { g_free(x); x = NULL; } } -#define TRUE 1 -#define FALSE 0 -#define BUFFER_SIZE 128 +#define DECODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "png_test_dec_file.raw") +#define DECODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "png_test_dec_mem.raw") +#define ENCODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "png_test_enc_file.jpg") +#define ENCODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "png_test_enc_mem.jpg") -static inline void flush_stdin() -{ - int ch; - while ((ch = getchar()) != EOF && ch != '\n') ; -} +typedef enum { + TEST_AUTO, + TEST_DECODE_FILE, + TEST_DECODE_MEMORY, + TEST_ENCODE_FILE, + TEST_ENCODE_MEMORY, + TEST_NUM, +} png_test_mode_e; + +static char *MODE_TO_STR[] = { + "AUTO", + "DECODE_FILE", + "DECODE_MEMORY", + "ENCODE_FILE", + "ENCODE_MEMORY", + "", +}; + +/* for arguments */ +static int g_test_mode = 0; +static char *g_path = NULL; +static int g_compression = MM_UTIL_COMPRESSION_6; -static int _read_file(char *file_name, void **data, int *data_size) +/* for reading file */ +static void *g_readed_data = NULL; +static size_t g_readed_size = 0; + +static mm_util_png_data g_decoded_data = {0,}; + +static gboolean _read_file(char *path, void **data, size_t *length) { FILE *fp = NULL; - long file_size = 0; + long len = 0; - if (!file_name || !data || !data_size) { - fprintf(stderr, "\tNULL pointer\n"); + if (!path || !data || length == 0) { + fprintf(stderr, "\t[PNG_testsuite] invalid data %s %p %p\n", path, data, length); return FALSE; } - fprintf(stderr, "\tTry to open %s to read\n", file_name); + fprintf(stderr, "\t[PNG_testsuite] %s read\n", path); - fp = fopen(file_name, "r"); + fp = fopen(path, "r"); if (fp == NULL) { - fprintf(stderr, "\tfile open failed %d\n", errno); + fprintf(stderr, "\t[PNG_testsuite] fopen failed (%d) \n", errno); return FALSE; } fseek(fp, 0, SEEK_END); - file_size = ftell(fp); - if (file_size > -1L) { - rewind(fp); - *data = (void *)calloc(1, file_size); - if (*data == NULL) { - fprintf(stderr, "\tmemory allocation failed %d\n", errno); - fclose(fp); - fp = NULL; - return FALSE; - } else { - if (fread(*data, 1, file_size, fp) == (size_t)file_size) { - fprintf(stderr, "\t#Success# fread\n"); - } else { - fprintf(stderr, "\t#Error# fread\n"); - fclose(fp); - fp = NULL; - return FALSE; - } - } + len = ftell(fp); + if (len < 0) { + fprintf(stderr, "\t[PNG_testsuite] ftell failed \n"); fclose(fp); - fp = NULL; + return FALSE; + } - if (*data) { - *data_size = file_size; - return TRUE; - } else { - *data_size = 0; - return FALSE; - } - } else { - fprintf(stderr, "\t#Success# ftell\n"); + rewind(fp); + *data = (void *)calloc(1, len); + if (*data == NULL) { + fprintf(stderr, "\tmemory allocation failed \n"); fclose(fp); - fp = NULL; return FALSE; } + + *length = fread(*data, 1, (size_t)len, fp); + if (*length != len) { + fprintf(stderr, "\t[PNG_testsuite] fread failed \n"); + } + + fclose(fp); + + if (*data == NULL) { + *length = 0; + return FALSE; + } + + *length = (size_t)len; + + fprintf(stderr, "\t[PNG_testsuite] %s %zu read DONE\n", path, *length); + + return TRUE; } -static int _write_file(const char *file_name, void *data, int data_size) +static gboolean _write_file(const char *path, void *data, size_t length) { FILE *fp = NULL; + size_t len = 0; - if (!file_name || !data || data_size <= 0) { - fprintf(stderr, "\tinvalid data %s %p size:%d\n", file_name, data, data_size); + if (!path || !data || length == 0) { + fprintf(stderr, "\t[PNG_testsuite] invalid data %s %p %zu\n", path, data, length); return FALSE; } - fprintf(stderr, "\tTry to open %s to write\n", file_name); + fprintf(stderr, "\t[PNG_testsuite] %s %p %zu write\n", path, data, length); - fp = fopen(file_name, "w"); + fp = fopen(path, "w"); if (fp == NULL) { - fprintf(stderr, "\tfile open failed %d\n", errno); + fprintf(stderr, "\t[PNG_testsuite] fopen failed (%d) \n", errno); return FALSE; } - fwrite(data, 1, data_size, fp); + len = fwrite(data, 1, length, fp); + if (len != length) { + fprintf(stderr, "\t[PNG_testsuite] fwrite failed \n"); + } + fclose(fp); fp = NULL; - fprintf(stderr, "\tfile [%s] write DONE\n", file_name); + fprintf(stderr, "\t[PNG_testsuite] %s write DONE\n", path); return TRUE; } -int main(int argc, char *argv[]) +gboolean _get_input_data(const char *argv, const long min, const long max, int *data) +{ + if (argv == NULL || strlen(argv) == 0) + return FALSE; + + long temp = g_ascii_strtoll(argv, NULL, 10); + if (temp < min || temp > max) + return FALSE; + + *data = (int)temp; + + return TRUE; +} + +void _print_help(const char *argv0) +{ + fprintf(stderr, "\t[usage]\n"); + fprintf(stderr, "\t\t1. decode & encode : %s mode path compression_level(opt.)\n", argv0); + fprintf(stderr, "\t\t2. decode : %s mode path\n", argv0); + fprintf(stderr, "\t\t3. encode : %s mode path width(mand.) height(mand.) compression_level(opt.)\n", argv0); + fprintf(stderr, "\t\t4. mode : 0 - auto, 1 - decode from file, 2 - decode from memory, 3 - encode to file, 4 - encode to memeory\n"); +} + +gboolean _get_arguments(int argc, char *argv[]) +{ + if (FALSE == _get_input_data(argv[1], TEST_AUTO, TEST_NUM - 1, &g_test_mode)) { + fprintf(stderr, "\t[PNG_testsuite] wrong mode(%s) for test\n", argv[1]); + _print_help(argv[0]); + return FALSE; + } + + g_path = g_strdup(argv[2]); + if (g_path == NULL) { + fprintf(stderr, "\t[PNG_testsuite] Not enough memory\n"); + return FALSE; + } + + if (g_test_mode == TEST_AUTO) { + if (FALSE == _get_input_data(argv[3], MM_UTIL_COMPRESSION_1, MM_UTIL_COMPRESSION_9, &g_compression)) + fprintf(stderr, "\t[PNG_testsuite] compression_level is default(%d)\n", g_compression); + } else if ((g_test_mode == TEST_DECODE_FILE) || (g_test_mode == TEST_DECODE_MEMORY)) { + /* do nothing */ + } else if (g_test_mode == TEST_ENCODE_FILE || g_test_mode == TEST_ENCODE_MEMORY) { + int width = 0, height = 0; + if (argc < 4) { + fprintf(stderr, "\t[PNG_testsuite] not enough args\n"); + _print_help(argv[0]); + return FALSE; + } + if (FALSE == _get_input_data(argv[3], 0, INT_MAX, &width)) { + fprintf(stderr, "\t[PNG_testsuite] wrong width %s\n", argv[3]); + return FALSE; + } + g_decoded_data.width = (unsigned long)width; + if (FALSE == _get_input_data(argv[4], 0, INT_MAX, &height)) { + fprintf(stderr, "\t[PNG_testsuite] wrong height %s\n", argv[4]); + return FALSE; + } + g_decoded_data.height = (unsigned long)height; + if (FALSE == _get_input_data(argv[5], MM_UTIL_COMPRESSION_1, MM_UTIL_COMPRESSION_9, &g_compression)) + fprintf(stderr, "\t[PNG_testsuite] wrong compression_level %s\n", argv[5]); + } else { + fprintf(stderr, "\t[PNG_testsuite] wrong mode for test %s\n", argv[1]); + return FALSE; + } + + return TRUE; +} + +gboolean _test_decode(const png_test_mode_e mode) { int ret = 0; - mm_util_png_data decoded_data; - void *src = NULL; - int src_size = 0; - mm_util_png_compression compression = MM_UTIL_COMPRESSION_6; /* default */ + /* test decoding jpeg */ + if (mode == TEST_DECODE_FILE) { + ret = mm_util_decode_from_png_file(&g_decoded_data, g_path); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[PNG_testsuite] mm_util_decode_from_jpeg_file_with_downscale failed %d\n", ret); + return FALSE; + } + if (FALSE == _write_file(DECODE_FILE_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) { + fprintf(stderr, "\t[PNG_testsuite] writing decoded data failed : %s\n", DECODE_FILE_PATH); + return FALSE; + } + } else if (mode == TEST_DECODE_MEMORY) { + if (FALSE == _read_file(g_path, &g_readed_data, &g_readed_size)) { + fprintf(stderr, "\t[PNG_testsuite] reading file error\n"); + return FALSE; + } + + ret = mm_util_decode_from_png_memory(&g_decoded_data, g_readed_data, (unsigned long long)g_readed_size); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[PNG_testsuite] mm_util_decode_from_jpeg_memory_with_downscale failed %d\n", ret); + return FALSE; + } + if (FALSE == _write_file(DECODE_MEM_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) { + fprintf(stderr, "\t[PNG_testsuite] writing decoded data failed : %s\n", DECODE_MEM_PATH); + return FALSE; + } + } + + return TRUE; +} + +gboolean _test_encode(const png_test_mode_e mode) +{ + int ret = 0; + /* for encoding jpeg to memory */ + void *encoded_data = NULL; + size_t encoded_size = 0; + + if ((mode != TEST_ENCODE_FILE) && (mode != TEST_ENCODE_MEMORY)) + return TRUE; + + if (FALSE == _read_file(g_path, &g_decoded_data.data, &g_decoded_data.size)) { + fprintf(stderr, "\t[PNG_testsuite] reading file error\n"); + return FALSE; + } + + /* test encoding jpeg */ + if (mode == TEST_ENCODE_FILE) { + ret = mm_util_encode_to_png_file(&g_decoded_data, g_compression, ENCODE_FILE_PATH); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[PNG_testsuite] mm_util_jpeg_encode_to_file failed : %d\n", ret); + return FALSE; + } + } else if (mode == TEST_ENCODE_MEMORY) { + ret = mm_util_encode_to_png_memory(&g_decoded_data, g_compression, &encoded_data, &encoded_size); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[PNG_testsuite] mm_util_jpeg_encode_to_file failed : %d\n", ret); + SAFE_FREE(encoded_data); + return FALSE; + } + if (FALSE == _write_file(ENCODE_MEM_PATH, encoded_data, (size_t)encoded_size)) { + fprintf(stderr, "\t[PNG_testsuite] writing decoded data failed : %s\n", ENCODE_MEM_PATH); + SAFE_FREE(encoded_data); + return FALSE; + } + } + + SAFE_FREE(encoded_data); + return TRUE; +} + +gboolean _test_auto() +{ + png_test_mode_e test_mode = TEST_DECODE_FILE; + + while (test_mode < TEST_NUM) { + fprintf(stderr, "\t[PNG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST START\n", MODE_TO_STR[test_mode]); + if (TEST_ENCODE_FILE == test_mode) { + SAFE_G_FREE(g_path); + g_path = g_strdup(DECODE_FILE_PATH); + if (g_path == NULL) { + fprintf(stderr, "\t[PNG_testsuite] Not enough memory\n"); + return FALSE; + } + } + /* test decoding jpeg */ + if ((test_mode == TEST_DECODE_FILE) || (test_mode == TEST_DECODE_MEMORY)) { + if (FALSE == _test_decode(test_mode)) { + fprintf(stderr, "\t[PNG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]); + return FALSE; + } + } + + /* test encoding jpeg */ + if ((test_mode == TEST_ENCODE_FILE) || (test_mode == TEST_ENCODE_MEMORY)) { + if (FALSE == _test_encode(test_mode)) { + fprintf(stderr, "\t[PNG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]); + return FALSE; + } + } + + fprintf(stderr, "\t[PNG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST SUCCESS\n", MODE_TO_STR[test_mode]); + + SAFE_FREE(g_readed_data); + SAFE_FREE(g_decoded_data.data); + test_mode++; + } + + return TRUE; +} + +int main(int argc, char *argv[]) +{ if (argc < 2) { - fprintf(stderr, "\t[usage]\n"); - fprintf(stderr, "\t\t1. decode : mm_util_png_testsuite decode filepath.png compression_level\n"); + _print_help(argv[0]); return 0; } - if (!strcmp("decode", argv[1])) { - ret = mm_util_decode_from_png_file(&decoded_data, argv[2]); - } else if (!strcmp("decode-mem", argv[1])) { - if (_read_file(argv[2], &src, &src_size)) { - ret = mm_util_decode_from_png_memory(&decoded_data, &src, src_size); + if (FALSE == _get_arguments(argc, argv)) { + fprintf(stderr, "\t[PNG_testsuite] _get_arguments failed\n"); + goto out; + } - free(src); - src = NULL; - } else { - ret = MM_UTIL_ERROR_INVALID_OPERATION; + /* test full functions automatically */ + if (g_test_mode == TEST_AUTO) { + if (FALSE == _test_auto()) + fprintf(stderr, "\t[PNG_testsuite] _test_auto failed\n"); + goto out; + } + + /* test decoding jpeg */ + if ((g_test_mode == TEST_DECODE_FILE) || (g_test_mode == TEST_DECODE_MEMORY)) { + if (FALSE == _test_decode(g_test_mode)) { + fprintf(stderr, "\t[PNG_testsuite] _test_decode(%s) failed\n", MODE_TO_STR[g_test_mode]); + goto out; } - } else { - fprintf(stderr, "\tunknown command [%s]\n", argv[1]); - return 0; } - if (ret != MM_UTIL_ERROR_NONE) { - fprintf(stderr, "\tERROR is occurred %x\n", ret); - } else { - fprintf(stderr, "\tPNG OPERATION SUCCESS\n"); - { - if (decoded_data.data) { - fprintf(stderr, "\t##Decoded data##: %p\t width: %lu\t height:%lu\t size: %lu\n", decoded_data.data, (long unsigned int)decoded_data.width, (long unsigned int)decoded_data.height, (long unsigned int)decoded_data.size); - char filename[BUFFER_SIZE] = { 0, }; - memset(filename, 0, BUFFER_SIZE); - { - snprintf(filename, BUFFER_SIZE, "%s%s", DECODE_RESULT_PATH, "png"); - } - - if (argv[3]) - compression = atoi(argv[3]); - - if (!strcmp("decode", argv[1])) { - void *encoded_data; - size_t size; - ret = mm_util_encode_to_png_memory(&decoded_data, compression, &encoded_data, &size); - fprintf(stderr, "Finished encoding encoded_data.size %zu\n", size); - _write_file(filename, encoded_data, size); - free(encoded_data); - } else if (!strcmp("decode-mem", argv[1])) { - ret = mm_util_encode_to_png_file(&decoded_data, compression, filename); - } - free(decoded_data.data); - } else { - fprintf(stderr, "\tDECODED data is NULL\n"); - } + /* test encoding jpeg */ + if ((g_test_mode == TEST_ENCODE_FILE) || (g_test_mode == TEST_ENCODE_MEMORY)) { + if (FALSE == _test_encode(g_test_mode)) { + fprintf(stderr, "\t[PNG_testsuite] _test_encode(%s) failed\n", MODE_TO_STR[g_test_mode]); + goto out; } } + +out: + SAFE_G_FREE(g_path); + SAFE_FREE(g_readed_data); + SAFE_FREE(g_decoded_data.data); + return 0; }