gif/unittest/libmm_gif_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_gif_unittest.h"
  20 #include "FileInterface.h"
  21 #include "mm_util_gif.h"
  22 #include "mm_util_image.h"
  23
  24 #define DECODE_FILE_PATH        tzplatform_mkpath(TZ_SYS_BIN, "libmm-gif-unittest.gif")
  25 #define ENCODE_FILE_PATH        tzplatform_mkpath(TZ_USER_CONTENT, "libmm-gif-result.gif")
  26
  27 using ::testing::InitGoogleTest;
  28 using ::testing::Test;
  29 using ::testing::TestCase;
  30
  31 class libmm_gif_Test : public ::testing::Test {
  32         protected:
  33                 void SetUp() {
  34                         std::cout << "SetUp()" << std::endl;
  35                 }
  36
  37                 void TearDown() {
  38                         std::cout << "TearDown()" << std::endl;
  39                 }
  40 };
  41
  42 TEST(libmm_gif_Test, mm_util_decode_from_gif_file_p)
  43 {
  44         int ret = MM_UTIL_ERROR_NONE;
  45         mm_util_image_h decode_image = NULL;
  46
  47         ret = mm_util_decode_from_gif_file(DECODE_FILE_PATH, &decode_image);
  48         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
  49         EXPECT_TRUE(mm_image_is_valid_image(decode_image));
  50
  51         mm_image_destroy_image(decode_image);
  52 }
  53
  54 TEST(libmm_gif_Test, mm_util_decode_from_gif_file_n)
  55 {
  56         int ret = MM_UTIL_ERROR_NONE;
  57         mm_util_image_h decode_image = NULL;
  58
  59         ret = mm_util_decode_from_gif_file(NULL, &decode_image);
  60         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
  61
  62         ret = mm_util_decode_from_gif_file(DECODE_FILE_PATH, NULL);
  63         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
  64 }
  65
  66 TEST(libmm_gif_Test, mm_util_decode_from_gif_memory_p)
  67 {
  68         int ret = MM_UTIL_ERROR_NONE;
  69         gboolean err = TRUE;
  70         mm_util_image_h decode_image = NULL;
  71
  72         FileInterface IFile = FileInterface(DECODE_FILE_PATH);
  73         err = IFile.ReadData();
  74         EXPECT_TRUE(err);
  75
  76         ret = mm_util_decode_from_gif_memory(IFile.readData, IFile.readDataSize, &decode_image);
  77         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
  78         EXPECT_TRUE(mm_image_is_valid_image(decode_image));
  79
  80         mm_image_destroy_image(decode_image);
  81 }
  82
  83 TEST(libmm_gif_Test, mm_util_decode_from_gif_memory_n)
  84 {
  85         int ret = MM_UTIL_ERROR_NONE;
  86         gboolean err = TRUE;
  87         mm_util_image_h decode_image = NULL;
  88
  89         FileInterface IFile = FileInterface(DECODE_FILE_PATH);
  90         err = IFile.ReadData();
  91         EXPECT_TRUE(err);
  92
  93         ret = mm_util_decode_from_gif_memory(NULL, IFile.readDataSize, &decode_image);
  94         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
  95
  96         ret = mm_util_decode_from_gif_memory(IFile.readData, IFile.readDataSize, NULL);
  97         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
  98 }
  99
 100 TEST(libmm_gif_Test, mm_util_encode_to_gif_file_p)
 101 {
 102         int ret = MM_UTIL_ERROR_NONE;
 103         mm_util_image_h decode_image = NULL;
 104
 105         ret = mm_util_decode_from_gif_file(DECODE_FILE_PATH, &decode_image);
 106         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 107         EXPECT_TRUE(mm_image_is_valid_image(decode_image));
 108
 109         ret = mm_util_encode_to_gif_file(&decode_image, 1, ENCODE_FILE_PATH);
 110         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 111
 112         mm_image_destroy_image(decode_image);
 113 }
 114
 115 TEST(libmm_gif_Test, mm_util_encode_to_gif_file_n)
 116 {
 117         int ret = MM_UTIL_ERROR_NONE;
 118         mm_util_image_h decode_image = NULL;
 119
 120         ret = mm_util_decode_from_gif_file(DECODE_FILE_PATH, &decode_image);
 121         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 122         EXPECT_TRUE(mm_image_is_valid_image(decode_image));
 123
 124         ret = mm_util_encode_to_gif_file(NULL, 1, ENCODE_FILE_PATH);
 125         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 126
 127         ret = mm_util_encode_to_gif_file(&decode_image, 1, NULL);
 128         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 129
 130         mm_image_destroy_image(decode_image);
 131 }
 132
 133 TEST(libmm_gif_Test, mm_util_encode_to_gif_memory_p)
 134 {
 135         int ret = MM_UTIL_ERROR_NONE;
 136         mm_util_image_h decode_image = NULL;
 137         void *buffer = NULL;
 138         size_t size = 0;
 139
 140         ret = mm_util_decode_from_gif_file(DECODE_FILE_PATH, &decode_image);
 141         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 142         EXPECT_TRUE(mm_image_is_valid_image(decode_image));
 143
 144         ret = mm_util_encode_to_gif_memory(&decode_image, 1, &buffer, &size);
 145         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 146         EXPECT_TRUE(buffer != NULL);
 147         EXPECT_NE(size, 0);
 148
 149         mm_image_destroy_image(decode_image);
 150
 151         if (buffer != NULL)
 152                 free(buffer);
 153 }
 154
 155 TEST(libmm_gif_Test, mm_util_encode_to_gif_memory_n)
 156 {
 157         int ret = MM_UTIL_ERROR_NONE;
 158         mm_util_image_h decode_image = NULL;
 159         void *buffer = NULL;
 160         size_t size = 0;
 161
 162         ret = mm_util_decode_from_gif_file(DECODE_FILE_PATH, &decode_image);
 163         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 164         EXPECT_TRUE(mm_image_is_valid_image(decode_image));
 165
 166         ret = mm_util_encode_to_gif_memory(NULL, 1, &buffer, &size);
 167         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 168
 169         ret = mm_util_encode_to_gif_memory(&decode_image, 1, NULL, &size);
 170         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 171
 172         ret = mm_util_encode_to_gif_memory(&decode_image, 1, &buffer, NULL);
 173         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 174
 175         mm_image_destroy_image(decode_image);
 176 }
 177
 178 int main(int argc, char **argv)
 179 {
 180         InitGoogleTest(&argc, argv);
 181
 182         return RUN_ALL_TESTS();
 183 }
 184