1 /*
2  * Copyright (C) 2024 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 
16 #include <gtest/gtest.h>
17 #include "image_ffi.h"
18 
19 namespace OHOS {
20 namespace Multimedia {
21 using namespace testing::ext;
22 using namespace OHOS::Media;
23 static const std::string IMAGE_JPEG_PATH = "/data/local/tmp/image/test_exif.jpg";
24 static const char* KEY = "key";
25 static const char* VALUE = "value";
26 
27 class ImageFfiTest : public testing::Test {
28 public:
ImageFfiTest()29     ImageFfiTest() {}
~ImageFfiTest()30     ~ImageFfiTest() {}
31 };
32 
33 /**
34  * @tc.name: ImageFfiTest001
35  * @tc.desc: test ImageSourceImpl
36  * @tc.type: FUNC
37  */
38 HWTEST_F(ImageFfiTest, ImageFfiTest001, TestSize.Level3)
39 {
40     GTEST_LOG_(INFO) << "ImageFfiTest: ImageFfiTest001 start";
41     std::string invalidPath = "";
42     uint32_t errCode;
43     int64_t imageSourceId = FfiOHOSCreateImageSourceByPath(const_cast<char*>(invalidPath.c_str()), &errCode);
44     FfiOHOSImageSourceGetImageInfo(imageSourceId, 0, &errCode);
45     FfiOHOSGetSupportedFormats(imageSourceId, &errCode);
46     FfiOHOSGetImageProperty(imageSourceId, const_cast<char*>(KEY), 0, const_cast<char*>(VALUE), &errCode);
47     FfiOHOSModifyImageProperty(imageSourceId, const_cast<char*>(KEY), const_cast<char*>(VALUE));
48     FfiOHOSGetFrameCount(imageSourceId);
49     CSourceOptions opts;
50     imageSourceId = FfiOHOSCreateImageSourceByPathWithOption(const_cast<char*>(invalidPath.c_str()), opts, &errCode);
51     int fd = 0;
52     imageSourceId = FfiOHOSCreateImageSourceByFd(fd, &errCode);
53     imageSourceId = FfiOHOSCreateImageSourceByFdWithOption(fd, opts, &errCode);
54     const uint32_t size = 10;
55     uint8_t data[size] = {0};
56     imageSourceId = FfiOHOSCreateImageSourceByBuffer(&data[0], size, &errCode);
57     imageSourceId = FfiOHOSCreateImageSourceByRawFile(fd, 0, 0, opts, &errCode);
58     imageSourceId = FfiOHOSCreateImageSourceByBufferWithOption(&data[0], size, opts, &errCode);
59     imageSourceId = FfiOHOSCreateIncrementalSource(&data[0], size, opts, &errCode);
60     UpdateDataInfo info;
61     FfiOHOSUpdateData(imageSourceId, info);
62     CDecodingOptions decodeOpts;
63     FfiOHOSImageSourceCreatePixelMap(imageSourceId, 0, decodeOpts);
64     FfiOHOSImageSourceGetDelayTime(imageSourceId, &errCode);
65     FfiOHOSRelease(imageSourceId);
66     GTEST_LOG_(INFO) << "ImageFfiTest: ImageFfiTest001 end";
67 }
68 
69 /**
70  * @tc.name: ImageFfiTest002
71  * @tc.desc: test ImageSourceImpl
72  * @tc.type: FUNC
73  */
74 HWTEST_F(ImageFfiTest, ImageFfiTest002, TestSize.Level3)
75 {
76     GTEST_LOG_(INFO) << "ImageFfiTest: ImageFfiTest002 start";
77     uint32_t errCode;
78     char* jpgPath = const_cast<char*>(IMAGE_JPEG_PATH.c_str());
79     int64_t imageSourceId = FfiOHOSCreateImageSourceByPath(jpgPath, &errCode);
80     FfiOHOSImageSourceGetImageInfo(imageSourceId, 0, &errCode);
81     FfiOHOSGetSupportedFormats(imageSourceId, &errCode);
82     FfiOHOSGetImageProperty(imageSourceId, const_cast<char*>(KEY), 0, const_cast<char*>(VALUE), &errCode);
83     FfiOHOSModifyImageProperty(imageSourceId, const_cast<char*>(KEY), const_cast<char*>(VALUE));
84     FfiOHOSGetFrameCount(imageSourceId);
85     CDecodingOptions decodeOpts;
86     FfiOHOSImageSourceCreatePixelMap(imageSourceId, 0, decodeOpts);
87     FfiOHOSImageSourceGetDelayTime(imageSourceId, &errCode);
88     CSourceOptions opts;
89     imageSourceId = FfiOHOSCreateImageSourceByPathWithOption(jpgPath, opts, &errCode);
90     UpdateDataInfo info;
91     FfiOHOSUpdateData(imageSourceId, info);
92     FfiOHOSRelease(imageSourceId);
93     GTEST_LOG_(INFO) << "ImageFfiTest: ImageFfiTest002 end";
94 }
95 
96 /**
97  * @tc.name: ImageFfiTest003
98  * @tc.desc: test ImageReceiverImpl
99  * @tc.type: FUNC
100  */
101 HWTEST_F(ImageFfiTest, ImageFfiTest003, TestSize.Level3)
102 {
103     GTEST_LOG_(INFO) << "ImageFfiTest: ImageFfiTest003 start";
104     int64_t imageReceiverId = FfiOHOSCreateImageReceiver(0, 0, 0, 0);
105     CSize size;
106     FfiOHOSReceiverGetSize(imageReceiverId, &size);
107     int32_t capacity;
108     FfiOHOSReceiverGetCapacity(imageReceiverId, &capacity);
109     int32_t format;
110     FfiOHOSReceiverGetFormat(imageReceiverId, &format);
111     FfiOHOSGetReceivingSurfaceId(imageReceiverId);
112     int64_t imageId = FfiOHOSReadNextImage(imageReceiverId);
113     imageId = FfiOHOSReadLatestImage(imageReceiverId);
114     CRegion region;
115     FfiOHOSImageGetClipRect(imageId, &region);
116     FfiOHOSImageGetSize(imageId, &size);
117     FfiOHOSImageGetFormat(imageId, &format);
118     CRetComponent component;
119     FfiOHOSGetComponent(imageId, 0, &component);
120     FfiOHOSImageRelease(imageId);
121     FfiOHOSReceiverRelease(imageReceiverId);
122     GTEST_LOG_(INFO) << "ImageFfiTest: ImageFfiTest003 end";
123 }
124 
125 /**
126  * @tc.name: ImageFfiTest004
127  * @tc.desc: test ImageReceiverImpl
128  * @tc.type: FUNC
129  */
130 HWTEST_F(ImageFfiTest, ImageFfiTest004, TestSize.Level3)
131 {
132     GTEST_LOG_(INFO) << "ImageFfiTest: ImageFfiTest004 start";
133     int64_t imageReceiverId = FfiOHOSCreateImageReceiver(100, 100, 2000, 8);
134     CSize size;
135     FfiOHOSReceiverGetSize(imageReceiverId, &size);
136     int32_t capacity;
137     FfiOHOSReceiverGetCapacity(imageReceiverId, &capacity);
138     int32_t format;
139     FfiOHOSReceiverGetFormat(imageReceiverId, &format);
140     FfiOHOSGetReceivingSurfaceId(imageReceiverId);
141     int64_t imageId = FfiOHOSReadNextImage(imageReceiverId);
142     imageId = FfiOHOSReadLatestImage(imageReceiverId);
143     CRegion region;
144     FfiOHOSImageGetClipRect(imageId, &region);
145     FfiOHOSImageGetSize(imageId, &size);
146     FfiOHOSImageGetFormat(imageId, &format);
147     CRetComponent component;
148     FfiOHOSGetComponent(imageId, 0, &component);
149     FfiOHOSImageRelease(imageId);
150     FfiOHOSReceiverRelease(imageReceiverId);
151     GTEST_LOG_(INFO) << "ImageFfiTest: ImageFfiTest004 end";
152 }
153 
154 /**
155  * @tc.name: ImageFfiTest005
156  * @tc.desc: test ImageReceiverImpl
157  * @tc.type: FUNC
158  */
159 HWTEST_F(ImageFfiTest, ImageFfiTest005, TestSize.Level3)
160 {
161     GTEST_LOG_(INFO) << "ImageFfiTest: ImageFfiTest005 start";
162     int64_t imageCreatorId = FFiOHOSImageCreatorConstructor(0, 0, 0, 0);
163     FFiOHOSImageCreatorGetCapacity(imageCreatorId);
164     FFiOHOSImageCreatorGetformat(imageCreatorId);
165     uint32_t errCode;
166     FFiOHOSImageCreatorDequeueImage(imageCreatorId, &errCode);
167     FFiOHOSImageCreatorQueueImage(imageCreatorId, 0);
168     FFiOHOSImageCreatorRelease(imageCreatorId);
169     imageCreatorId = FFiOHOSImageCreatorConstructor(100, 100, 2000, 8);
170     FFiOHOSImageCreatorGetCapacity(imageCreatorId);
171     FFiOHOSImageCreatorGetformat(imageCreatorId);
172     FFiOHOSImageCreatorDequeueImage(imageCreatorId, &errCode);
173     FFiOHOSImageCreatorQueueImage(imageCreatorId, 0);
174     FFiOHOSImageCreatorRelease(imageCreatorId);
175     GTEST_LOG_(INFO) << "ImageFfiTest: ImageFfiTest005 end";
176 }
177 }
178 }