bmp/unittest/libmm_bmp_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_bmp_unittest.h"
  20 #include "FileInterface.h"
  21 #include "mm_util_bmp.h"
  22
  23 #define DECODE_FILE_PATH        tzplatform_mkpath(TZ_SYS_BIN, "libmm-bmp-unittest.bmp")
  24 #define ENCODE_FILE_PATH        tzplatform_mkpath(TZ_USER_CONTENT, "libmm-bmp-result.bmp")
  25
  26 using ::testing::InitGoogleTest;
  27 using ::testing::Test;
  28 using ::testing::TestCase;
  29
  30 class libmm_bmp_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_bmp_Test, mm_util_decode_from_bmp_file_p)
  42 {
  43         int ret = MM_UTIL_ERROR_NONE;
  44         mm_image_info_s decode_image;
  45
  46         ret = mm_util_decode_from_bmp_file(DECODE_FILE_PATH, &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_bmp_Test, mm_util_decode_from_bmp_file_n)
  57 {
  58         int ret = MM_UTIL_ERROR_NONE;
  59         mm_image_info_s decode_image;
  60
  61         ret = mm_util_decode_from_bmp_file(NULL, &decode_image);
  62         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
  63
  64         ret = mm_util_decode_from_bmp_file(DECODE_FILE_PATH, NULL);
  65         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
  66 }
  67
  68 TEST(libmm_bmp_Test, mm_util_decode_from_bmp_memory_p)
  69 {
  70         int ret = MM_UTIL_ERROR_NONE;
  71         gboolean err = TRUE;
  72         mm_image_info_s decode_image;
  73
  74         FileInterface IFile = FileInterface(DECODE_FILE_PATH);
  75         err = IFile.ReadData();
  76         EXPECT_TRUE(err);
  77
  78         ret = mm_util_decode_from_bmp_memory(IFile.readData, IFile.readDataSize, &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_bmp_Test, mm_util_decode_from_bmp_memory_n)
  89 {
  90         int ret = MM_UTIL_ERROR_NONE;
  91         gboolean err = TRUE;
  92         mm_image_info_s decode_image;
  93
  94         FileInterface IFile = FileInterface(DECODE_FILE_PATH);
  95         err = IFile.ReadData();
  96         EXPECT_TRUE(err);
  97
  98         ret = mm_util_decode_from_bmp_memory(NULL, IFile.readDataSize, &decode_image);
  99         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 100
 101         ret = mm_util_decode_from_bmp_memory(IFile.readData, IFile.readDataSize, NULL);
 102         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 103 }
 104
 105 TEST(libmm_bmp_Test, mm_util_encode_bmp_to_file_p)
 106 {
 107         int ret = MM_UTIL_ERROR_NONE;
 108         mm_image_info_s decode_image;
 109
 110         ret = mm_util_decode_from_bmp_file(DECODE_FILE_PATH, &decode_image);
 111         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 112         EXPECT_TRUE(decode_image.data != NULL);
 113
 114         ret = mm_util_encode_bmp_to_file(&decode_image, 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_bmp_Test, mm_util_encode_bmp_to_file_n)
 122 {
 123         int ret = MM_UTIL_ERROR_NONE;
 124         mm_image_info_s decode_image;
 125
 126         ret = mm_util_encode_bmp_to_file(NULL, ENCODE_FILE_PATH);
 127         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 128
 129         ret = mm_util_encode_bmp_to_file(&decode_image, NULL);
 130         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 131 }
 132
 133 TEST(libmm_bmp_Test, mm_util_encode_bmp_to_memory_p)
 134 {
 135         int ret = MM_UTIL_ERROR_NONE;
 136         mm_image_info_s decode_image;
 137         void *buffer = NULL;
 138         size_t size = 0;
 139
 140         ret = mm_util_decode_from_bmp_file(DECODE_FILE_PATH, &decode_image);
 141         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 142         EXPECT_TRUE(decode_image.data != NULL);
 143
 144         ret = mm_util_encode_bmp_to_memory(&decode_image, &buffer, &size);
 145         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 146         EXPECT_TRUE(buffer != NULL);
 147         EXPECT_NE(size, 0);
 148
 149         if (decode_image.data != NULL)
 150                 free(decode_image.data);
 151
 152         if (buffer != NULL)
 153                 free(buffer);
 154 }
 155
 156 TEST(libmm_bmp_Test, mm_util_encode_bmp_to_memory_n)
 157 {
 158         int ret = MM_UTIL_ERROR_NONE;
 159         mm_image_info_s decode_image;
 160         void *buffer = NULL;
 161         size_t size = 0;
 162
 163         ret = mm_util_encode_bmp_to_memory(NULL, &buffer, &size);
 164         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 165
 166         ret = mm_util_encode_bmp_to_memory(&decode_image, NULL, &size);
 167         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 168
 169         ret = mm_util_encode_bmp_to_memory(&decode_image, &buffer, NULL);
 170         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 171 }
 172
 173 int main(int argc, char **argv)
 174 {
 175         InitGoogleTest(&argc, argv);
 176
 177         return RUN_ALL_TESTS();
 178 }
 179