1 /* 2 * Copyright (C) 2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 #define private public 16 #include <gtest/gtest.h> 17 #include <fstream> 18 #include "image_creator.h" 19 #include "image_packer.h" 20 #include "image_source.h" 21 #include "image_utils.h" 22 #include "directory_ex.h" 23 #include "image_creator_manager.h" 24 25 using namespace testing::ext; 26 using namespace OHOS::Media; 27 namespace OHOS { 28 namespace Multimedia { 29 class ImageCreatorTest : public testing::Test { 30 public: ImageCreatorTest()31 ImageCreatorTest() {} ~ImageCreatorTest()32 ~ImageCreatorTest() {} 33 }; 34 35 /** 36 * @tc.name: CreateImageCreator001 37 * @tc.desc: test CreateImageCreator 38 * @tc.type: FUNC 39 */ 40 HWTEST_F(ImageCreatorTest, CreateImageCreator001, TestSize.Level3) 41 { 42 GTEST_LOG_(INFO) << "ImageCreatorTest: CreateImageCreator001 start"; 43 ImageCreator creat; 44 int32_t width = 1; 45 int32_t height = 2; 46 int32_t format = 3; 47 int32_t capicity = 4; 48 std::shared_ptr<ImageCreator> createimagec = creat.CreateImageCreator(width, height, format, capicity); 49 ASSERT_NE(createimagec, nullptr); 50 GTEST_LOG_(INFO) << "ImageCreatorTest: CreateImageCreator001 end"; 51 } 52 53 /** 54 * @tc.name: SaveSTP001 55 * @tc.desc: test SaveSTP 56 * @tc.type: FUNC 57 */ 58 HWTEST_F(ImageCreatorTest, SaveSTP001, TestSize.Level3) 59 { 60 GTEST_LOG_(INFO) << "ImageCreatorTest: SaveSTP001 start"; 61 ImageCreator creat; 62 uint32_t *buffer = nullptr; 63 uint8_t *tempBuffer = nullptr; 64 uint32_t bufferSize = 1; 65 InitializationOptions initializationOpts; 66 int32_t savesp = creat.SaveSTP(buffer, tempBuffer, bufferSize, initializationOpts); 67 ASSERT_EQ(savesp, -1); 68 GTEST_LOG_(INFO) << "ImageCreatorTest: SaveSTP001 end"; 69 } 70 71 /** 72 * @tc.name: SaveSTP002 73 * @tc.desc: test SaveSTP 74 * @tc.type: FUNC 75 */ 76 HWTEST_F(ImageCreatorTest, SaveSTP002, TestSize.Level3) 77 { 78 GTEST_LOG_(INFO) << "ImageCreatorTest: SaveSTP002 start"; 79 ImageCreator creat; 80 uint32_t *buffer = nullptr; 81 uint8_t *tempBuffer = nullptr; 82 uint32_t bufferSize = 0; 83 InitializationOptions initializationOpts; 84 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(buffer, bufferSize, initializationOpts); 85 ASSERT_EQ(pixelMap, nullptr); 86 int32_t savesp = creat.SaveSTP(buffer, tempBuffer, bufferSize, initializationOpts); 87 ASSERT_EQ(savesp, ERR_MEDIA_INVALID_VALUE); 88 GTEST_LOG_(INFO) << "ImageCreatorTest: SaveSTP002 end"; 89 } 90 91 /** 92 * @tc.name: SaveSenderBufferAsImage001 93 * @tc.desc: test SaveSenderBufferAsImage 94 * @tc.type: FUNC 95 */ 96 HWTEST_F(ImageCreatorTest, SaveSenderBufferAsImage001, TestSize.Level3) 97 { 98 GTEST_LOG_(INFO) << "ImageCreatorTest: SaveSenderBufferAsImage001 start"; 99 ImageCreator creat; 100 OHOS::sptr<OHOS::SurfaceBuffer> buffer = nullptr; 101 InitializationOptions initializationOpts; 102 int32_t savesend = creat.SaveSenderBufferAsImage(buffer, initializationOpts); 103 ASSERT_EQ(savesend, 0); 104 GTEST_LOG_(INFO) << "ImageCreatorTest: SaveSenderBufferAsImage001 end"; 105 } 106 107 /** 108 * @tc.name: SaveSenderBufferAsImage002 109 * @tc.desc: test SaveSenderBufferAsImage 110 * @tc.type: FUNC 111 */ 112 HWTEST_F(ImageCreatorTest, SaveSenderBufferAsImage002, TestSize.Level3) 113 { 114 GTEST_LOG_(INFO) << "ImageCreatorTest: SaveSenderBufferAsImage002start"; 115 ImageCreator creat; 116 OHOS::sptr<OHOS::SurfaceBuffer> buffer; 117 InitializationOptions initializationOpts; 118 int32_t savesend = creat.SaveSenderBufferAsImage(buffer, initializationOpts); 119 ASSERT_EQ(savesend, 0); 120 GTEST_LOG_(INFO) << "ImageCreatorTest: SaveSenderBufferAsImage002 end"; 121 } 122 123 /** 124 * @tc.name: getSurfaceById001 125 * @tc.desc: test getSurfaceById 126 * @tc.type: FUNC 127 */ 128 HWTEST_F(ImageCreatorTest, getSurfaceById001, TestSize.Level3) 129 { 130 GTEST_LOG_(INFO) << "ImageCreatorTest: getSurfaceById001 start"; 131 ImageCreator creat; 132 std::string id = ""; 133 sptr<IConsumerSurface> getsrfid = creat.getSurfaceById(id); 134 ASSERT_EQ(getsrfid, nullptr); 135 GTEST_LOG_(INFO) << "ImageCreatorTest: getSurfaceById001 end"; 136 } 137 138 /** 139 * @tc.name: ReleaseCreator001 140 * @tc.desc: test ReleaseCreator 141 * @tc.type: FUNC 142 */ 143 HWTEST_F(ImageCreatorTest, ReleaseCreator001, TestSize.Level3) 144 { 145 GTEST_LOG_(INFO) << "ImageCreatorTest: ReleaseCreator001 start"; 146 ImageCreator creat; 147 creat.ReleaseCreator(); 148 ASSERT_NE(&creat, nullptr); 149 GTEST_LOG_(INFO) << "ImageCreatorTest: ReleaseCreator001 end"; 150 } 151 152 /** 153 * @tc.name: OnBufferAvailable001 154 * @tc.desc: test OnBufferAvailable 155 * @tc.type: FUNC 156 */ 157 HWTEST_F(ImageCreatorTest, OnBufferAvailable001, TestSize.Level3) 158 { 159 GTEST_LOG_(INFO) << "ImageCreatorTest: OnBufferAvailable001 start"; 160 std::shared_ptr<ImageCreator> creator = ImageCreator::CreateImageCreator(1, 1, 1, 1); 161 ASSERT_NE(creator, nullptr); 162 sptr<ImageCreatorSurfaceListener> listener = new ImageCreatorSurfaceListener(); 163 listener->ic_ = creator; 164 listener->OnBufferAvailable(); 165 GTEST_LOG_(INFO) << "ImageCreatorTest: OnBufferAvailable001 end"; 166 } 167 168 /** 169 * @tc.name: OnBufferAvailable002 170 * @tc.desc: test OnBufferAvailable 171 * @tc.type: FUNC 172 */ 173 HWTEST_F(ImageCreatorTest, OnBufferAvailable002, TestSize.Level3) 174 { 175 GTEST_LOG_(INFO) << "ImageCreatorTest: OnBufferAvailable002 start"; 176 std::shared_ptr<ImageCreator> creator = ImageCreator::CreateImageCreator(1, 1, 1, 1); 177 ASSERT_NE(creator, nullptr); 178 sptr<ImageCreatorSurfaceListener> listener = new ImageCreatorSurfaceListener(); 179 listener->ic_ = creator; 180 listener->ic_->RegisterBufferAvaliableListener(listener->ic_->surfaceBufferAvaliableListener_); 181 listener->OnBufferAvailable(); 182 GTEST_LOG_(INFO) << "ImageCreatorTest: OnBufferAvailable002 end"; 183 } 184 185 /** 186 * @tc.name: DequeueImage001 187 * @tc.desc: test DequeueImage 188 * @tc.type: FUNC 189 */ 190 HWTEST_F(ImageCreatorTest, DequeueImage001, TestSize.Level3) 191 { 192 GTEST_LOG_(INFO) << "ImageCreatorTest: DequeueImage001 start"; 193 std::shared_ptr<ImageCreator> creator = ImageCreator::CreateImageCreator(1, 1, 1, 1); 194 ASSERT_NE(creator, nullptr); 195 OHOS::sptr<OHOS::SurfaceBuffer> buffer = creator->DequeueImage(); 196 ASSERT_NE(buffer, nullptr); 197 GTEST_LOG_(INFO) << "ImageCreatorTest: DequeueImage001 end"; 198 } 199 200 /** 201 * @tc.name: OnBufferRelease001 202 * @tc.desc: test OnBufferRelease 203 * @tc.type: FUNC 204 */ 205 HWTEST_F(ImageCreatorTest, OnBufferRelease001, TestSize.Level3) 206 { 207 GTEST_LOG_(INFO) << "ImageCreatorTest: OnBufferRelease001 start"; 208 std::shared_ptr<ImageCreator> creator = ImageCreator::CreateImageCreator(1, 1, 1, 1); 209 ASSERT_NE(creator, nullptr); 210 OHOS::sptr<OHOS::SurfaceBuffer> buffer = creator->DequeueImage(); 211 ASSERT_NE(buffer, nullptr); 212 (void)ImageCreator::OnBufferRelease(buffer); 213 GTEST_LOG_(INFO) << "ImageCreatorTest: OnBufferRelease001 end"; 214 } 215 216 /** 217 * @tc.name: QueueImage001 218 * @tc.desc: test QueueImage 219 * @tc.type: FUNC 220 */ 221 HWTEST_F(ImageCreatorTest, QueueImage001, TestSize.Level3) 222 { 223 GTEST_LOG_(INFO) << "ImageCreatorTest: QueueImage001 start"; 224 std::shared_ptr<ImageCreator> creator = ImageCreator::CreateImageCreator(1, 1, 1, 1); 225 ASSERT_NE(creator, nullptr); 226 OHOS::sptr<OHOS::SurfaceBuffer> buffer; 227 creator->QueueImage(buffer); 228 GTEST_LOG_(INFO) << "ImageCreatorTest: QueueImage001 end"; 229 } 230 231 /** 232 * @tc.name: SaveSTP002 233 * @tc.desc: test SaveSTP 234 * @tc.type: FUNC 235 */ 236 HWTEST_F(ImageCreatorTest, SaveSTP003, TestSize.Level3) 237 { 238 GTEST_LOG_(INFO) << "ImageCreatorTest: SaveSTP003 start"; 239 240 uint32_t color[64] = {}; 241 uint32_t colorlength = 64; 242 InitializationOptions opts; 243 opts.pixelFormat = OHOS::Media::PixelFormat::ARGB_8888; 244 opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE; 245 opts.size.height = 8; 246 opts.size.width = 8; 247 248 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, colorlength, opts); 249 ASSERT_NE(pixelMap.get(), nullptr); 250 251 int64_t bufferSize = 2 * 1024 * 1024; 252 uint8_t *buffer = static_cast<uint8_t *>(malloc(bufferSize)); 253 254 ImagePacker imagePacker; 255 PackOption option; 256 option.format = ImageReceiver::OPTION_FORMAT; 257 option.numberHint = ImageReceiver::OPTION_NUMBERHINT; 258 option.quality = ImageReceiver::OPTION_QUALITY; 259 std::set<std::string> formats; 260 261 uint32_t ret = imagePacker.GetSupportedFormats(formats); 262 ASSERT_EQ(ret, SUCCESS); 263 264 imagePacker.StartPacking(buffer, bufferSize, option); 265 imagePacker.AddImage(*pixelMap); 266 int64_t packedSize = 0; 267 imagePacker.FinalizePacking(packedSize); 268 ASSERT_NE(packedSize, 0); 269 270 std::shared_ptr<ImageCreator> creator = ImageCreator::CreateImageCreator(8, 8, 3, 1); 271 ASSERT_NE(creator, nullptr); 272 273 int32_t status = creator->SaveSTP(color, buffer, colorlength, opts); 274 ASSERT_EQ(status, ERR_MEDIA_INVALID_VALUE); 275 276 free(buffer); 277 GTEST_LOG_(INFO) << "ImageCreatorTest: SaveSTP003 end"; 278 } 279 280 /** 281 * @tc.name: GetBufferProcessor001 282 * @tc.desc: test GetBufferProcessor 283 * @tc.type: FUNC 284 */ 285 HWTEST_F(ImageCreatorTest, GetBufferProcessor001, TestSize.Level3) 286 { 287 GTEST_LOG_(INFO) << "ImageCreatorTest: GetBufferProcessor001 start"; 288 std::shared_ptr<ImageCreator> creator = ImageCreator::CreateImageCreator(1, 1, 1, 1); 289 creator->bufferProcessor_ = nullptr; 290 creator->GetBufferProcessor(); 291 ASSERT_NE(creator->bufferProcessor_, nullptr); 292 GTEST_LOG_(INFO) << "ImageCreatorTest: GetBufferProcessor001 end"; 293 } 294 295 /** 296 * @tc.name: QueueNativeImage001 297 * @tc.desc: test QueueNativeImage 298 * @tc.type: FUNC 299 */ 300 HWTEST_F(ImageCreatorTest, QueueNativeImage001, TestSize.Level3) 301 { 302 GTEST_LOG_(INFO) << "ImageCreatorTest: QueueNativeImage001 start"; 303 std::shared_ptr<ImageCreator> creator = ImageCreator::CreateImageCreator(1, 1, 1, 1); 304 std::shared_ptr<NativeImage> image = nullptr; 305 creator->QueueNativeImage(image); 306 ASSERT_EQ(image, nullptr); 307 GTEST_LOG_(INFO) << "ImageCreatorTest: QueueNativeImage001 end"; 308 } 309 } // namespace Multimedia 310 } // namespace OHOS 311