jpeg/unittest/libmm_jpeg_unittest.cpp

   1 /*
   2  * Copyright (c) 2018 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 #include <tzplatform_config.h>
  18
  19 #include "libmm_jpeg_unittest.h"
  20 #include "FileInterface.h"
  21 #include "mm_util_jpeg.h"
  22
  23 #define DECODE_FILE_PATH        tzplatform_mkpath(TZ_SYS_BIN, "libmm-jpeg-unittest.jpg")
  24 #define ENCODE_FILE_PATH        tzplatform_mkpath(TZ_USER_CONTENT, "libmm-jpeg-result.jpg")
  25
  26 using ::testing::InitGoogleTest;
  27 using ::testing::Test;
  28 using ::testing::TestCase;
  29
  30 class libmm_jpeg_Test : public ::testing::Test {
  31         protected:
  32                 void SetUp() {
  33                         std::cout << "SetUp()" << std::endl;
  34                 }
  35
  36                 void TearDown() {
  37                         std::cout << "TearDown()" << std::endl;
  38                 }
  39 };
  40
  41 TEST(libmm_jpeg_Test, mm_util_decode_from_jpeg_file_p)
  42 {
  43         int ret = MM_UTIL_ERROR_NONE;
  44         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
  45
  46         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
  47         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
  48         EXPECT_EQ(decode_image.width, 640);
  49         EXPECT_EQ(decode_image.height, 480);
  50         EXPECT_TRUE(decode_image.data != NULL);
  51
  52         if (decode_image.data != NULL)
  53                 free(decode_image.data);
  54 }
  55
  56 TEST(libmm_jpeg_Test, mm_util_decode_from_jpeg_file_n)
  57 {
  58         int ret = MM_UTIL_ERROR_NONE;
  59         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
  60
  61         ret = mm_util_decode_from_jpeg_file(NULL, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
  62         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
  63
  64         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, NULL);
  65         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
  66 }
  67
  68 TEST(libmm_jpeg_Test, mm_util_decode_from_jpeg_memory_p)
  69 {
  70         int ret = MM_UTIL_ERROR_NONE;
  71         gboolean err = TRUE;
  72         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
  73
  74         FileInterface IFile = FileInterface(DECODE_FILE_PATH);
  75         err = IFile.ReadData();
  76         EXPECT_TRUE(err);
  77
  78         ret = mm_util_decode_from_jpeg_memory(IFile.readData, IFile.readDataSize, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
  79         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
  80         EXPECT_EQ(decode_image.width, 640);
  81         EXPECT_EQ(decode_image.height, 480);
  82         EXPECT_TRUE(decode_image.data != NULL);
  83
  84         if (decode_image.data != NULL)
  85                 free(decode_image.data);
  86 }
  87
  88 TEST(libmm_jpeg_Test, mm_util_decode_from_jpeg_memory_n)
  89 {
  90         int ret = MM_UTIL_ERROR_NONE;
  91         gboolean err = TRUE;
  92         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
  93
  94         FileInterface IFile = FileInterface(DECODE_FILE_PATH);
  95         err = IFile.ReadData();
  96         EXPECT_TRUE(err);
  97
  98         ret = mm_util_decode_from_jpeg_memory(NULL, IFile.readDataSize, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
  99         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 100
 101         ret = mm_util_decode_from_jpeg_memory(IFile.readData, IFile.readDataSize, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, NULL);
 102         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 103 }
 104
 105 TEST(libmm_jpeg_Test, mm_util_jpeg_encode_to_file_p)
 106 {
 107         int ret = MM_UTIL_ERROR_NONE;
 108         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
 109
 110         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
 111         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 112         EXPECT_TRUE(decode_image.data != NULL);
 113
 114         ret = mm_util_jpeg_encode_to_file(&decode_image, 100, ENCODE_FILE_PATH);
 115         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 116
 117         if (decode_image.data != NULL)
 118                 free(decode_image.data);
 119 }
 120
 121 TEST(libmm_jpeg_Test, mm_util_jpeg_encode_to_file_n)
 122 {
 123         int ret = MM_UTIL_ERROR_NONE;
 124         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
 125
 126         ret = mm_util_jpeg_encode_to_file(NULL, 100, ENCODE_FILE_PATH);
 127         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 128
 129         ret = mm_util_jpeg_encode_to_file(&decode_image, 0, ENCODE_FILE_PATH);
 130         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 131
 132         ret = mm_util_jpeg_encode_to_file(&decode_image, 100, NULL);
 133         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 134 }
 135
 136 TEST(libmm_jpeg_Test, mm_util_jpeg_encode_to_memory_p)
 137 {
 138         int ret = MM_UTIL_ERROR_NONE;
 139         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
 140         void *buffer = NULL;
 141         size_t size = 0;
 142
 143         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
 144         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 145         EXPECT_TRUE(decode_image.data != NULL);
 146
 147         ret = mm_util_jpeg_encode_to_memory(&buffer, &size, (unsigned char*)decode_image.data, (unsigned int)decode_image.width, (unsigned int)decode_image.height, decode_image.color, 100);
 148         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 149         EXPECT_TRUE(buffer != NULL);
 150         EXPECT_NE(size, 0);
 151
 152         if (decode_image.data != NULL)
 153                 free(decode_image.data);
 154 }
 155
 156 TEST(libmm_jpeg_Test, mm_util_jpeg_encode_to_memory_n)
 157 {
 158         int ret = MM_UTIL_ERROR_NONE;
 159         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
 160         void *buffer = NULL;
 161         unsigned int size = 0;
 162
 163         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
 164         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 165         EXPECT_TRUE(decode_image.data != NULL);
 166
 167         ret = mm_util_jpeg_encode_to_memory(NULL, &size, (unsigned char*)decode_image.data, (unsigned int)decode_image.width, (unsigned int)decode_image.height, decode_image.color, 100);
 168         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 169
 170         ret = mm_util_jpeg_encode_to_memory(&buffer, NULL, (unsigned char*)decode_image.data, (unsigned int)decode_image.width, (unsigned int)decode_image.height, decode_image.color, 100);
 171         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 172
 173         ret = mm_util_jpeg_encode_to_memory(&buffer, &size, (unsigned char*)decode_image.data, (unsigned int)decode_image.width, (unsigned int)decode_image.height, decode_image.color, 0);
 174         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 175
 176         if (decode_image.data != NULL)
 177                 free(decode_image.data);
 178 }
 179
 180 TEST(libmm_jpeg_Test, mm_util_encode_to_jpeg_memory_p)
 181 {
 182         int ret = MM_UTIL_ERROR_NONE;
 183         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
 184         void *buffer = NULL;
 185         size_t size = 0;
 186
 187         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
 188         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 189         EXPECT_TRUE(decode_image.data != NULL);
 190
 191         ret = mm_util_encode_to_jpeg_memory(&decode_image, 100, &buffer, &size);
 192         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 193         EXPECT_TRUE(buffer != NULL);
 194         EXPECT_NE(size, 0);
 195
 196         if (decode_image.data != NULL)
 197                 free(decode_image.data);
 198
 199         if (buffer != NULL)
 200                 free(buffer);
 201 }
 202
 203 TEST(libmm_jpeg_Test, mm_util_encode_to_jpeg_memory_n)
 204 {
 205         int ret = MM_UTIL_ERROR_NONE;
 206         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
 207         void *buffer = NULL;
 208         size_t size = 0;
 209
 210         ret = mm_util_encode_to_jpeg_memory(NULL, 100, &buffer, &size);
 211         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 212
 213         ret = mm_util_encode_to_jpeg_memory(&decode_image, 100, NULL, &size);
 214         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 215
 216         ret = mm_util_encode_to_jpeg_memory(&decode_image, 100, &buffer, NULL);
 217         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 218 }
 219
 220 int main(int argc, char **argv)
 221 {
 222         InitGoogleTest(&argc, argv);
 223
 224         return RUN_ALL_TESTS();
 225 }
 226