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 #include <securec.h>
16 #include <gtest/gtest.h>
17 #include <surface.h>
18 #include <consumer_surface.h>
19 #include <surface_utils.h>
20 #include "buffer_consumer_listener.h"
21 #include "surface_buffer_impl.h"
22 
23 using namespace testing;
24 using namespace testing::ext;
25 
26 namespace OHOS::Rosen {
27 class SurfaceUtilsTest : public testing::Test {
28 public:
29     static void SetUpTestCase();
30     static void TearDownTestCase();
31     static bool IsArrayEmpty(const float arr[16]);
32     static inline sptr<IConsumerSurface> csurface1 = nullptr;
33     static inline sptr<IBufferProducer> producer1 = nullptr;
34     static inline sptr<Surface> psurface1 = nullptr;
35 
36     static inline sptr<IConsumerSurface> csurface2 = nullptr;
37     static inline sptr<IBufferProducer> producer2 = nullptr;
38     static inline sptr<Surface> psurface2 = nullptr;
39 
40     static inline SurfaceUtils *utils = nullptr;
41     static constexpr const int32_t TRANSFORM_MATRIX_SIZE = 16;
42 };
43 
SetUpTestCase()44 void SurfaceUtilsTest::SetUpTestCase()
45 {
46     csurface1 = IConsumerSurface::Create();
47     sptr<IBufferConsumerListener> listener1 = new BufferConsumerListener();
48     csurface1->RegisterConsumerListener(listener1);
49     producer1 = csurface1->GetProducer();
50     psurface1 = Surface::CreateSurfaceAsProducer(producer1);
51 
52     csurface2 = IConsumerSurface::Create();
53     sptr<IBufferConsumerListener> listener2 = new BufferConsumerListener();
54     csurface2->RegisterConsumerListener(listener2);
55     producer2 = csurface2->GetProducer();
56     psurface2 = Surface::CreateSurfaceAsProducer(producer2);
57 }
58 
TearDownTestCase()59 void SurfaceUtilsTest::TearDownTestCase()
60 {
61     csurface1 = nullptr;
62     producer1 = nullptr;
63     psurface1 = nullptr;
64 
65     csurface2 = nullptr;
66     producer2 = nullptr;
67     psurface2 = nullptr;
68     utils = nullptr;
69 }
70 
71 /*
72 * Function: GetInstance
73 * Type: Function
74 * Rank: Important(2)
75 * EnvConditions: N/A
76 * CaseDescription: 1. call GetInstance
77 *                  2. check ret
78  */
79 HWTEST_F(SurfaceUtilsTest, GetInstance001, Function | MediumTest | Level2)
80 {
81     utils = SurfaceUtils::GetInstance();
82     ASSERT_NE(utils, nullptr);
83 }
84 
85 /*
86 * Function: GetInstance
87 * Type: Function
88 * Rank: Important(2)
89 * EnvConditions: N/A
90 * CaseDescription: 1. call Add
91 *                  2. check ret
92  */
93 HWTEST_F(SurfaceUtilsTest, Add001, Function | MediumTest | Level2)
94 {
95     GSError ret = utils->Add(psurface1->GetUniqueId(), nullptr);
96     ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
97 }
98 
99 /*
100 * Function: GetInstance
101 * Type: Function
102 * Rank: Important(2)
103 * EnvConditions: N/A
104 * CaseDescription: 1. call Add 2 times
105 *                  2. check ret
106  */
107 HWTEST_F(SurfaceUtilsTest, Add002, Function | MediumTest | Level2)
108 {
109     GSError ret = utils->Add(psurface1->GetUniqueId(), psurface1);
110     ASSERT_EQ(ret, OHOS::GSERROR_OK);
111 
112     ret = utils->Add(psurface1->GetUniqueId(), psurface1);
113     ASSERT_EQ(ret, OHOS::GSERROR_OK);
114 }
115 
116 /*
117 * Function: GetSurface
118 * Type: Function
119 * Rank: Important(2)
120 * EnvConditions: N/A
121 * CaseDescription: 1. call GetSurface by abnormal uniqueId
122 *                  2. check ret
123  */
124 HWTEST_F(SurfaceUtilsTest, GetSurface001, Function | MediumTest | Level2)
125 {
126     sptr<Surface> surface = utils->GetSurface(0);
127     ASSERT_EQ(surface, nullptr);
128 }
129 
130 /*
131 * Function: GetSurface
132 * Type: Function
133 * Rank: Important(2)
134 * EnvConditions: N/A
135 * CaseDescription: 1. call GetSurface
136 *                  2. check ret
137  */
138 HWTEST_F(SurfaceUtilsTest, GetSurface002, Function | MediumTest | Level2)
139 {
140     sptr<Surface> surface1 = utils->GetSurface(psurface1->GetUniqueId());
141     ASSERT_NE(surface1, nullptr);
142 }
143 
144 /*
145 * Function: GetSurface
146 * Type: Function
147 * Rank: Important(2)
148 * EnvConditions: N/A
149 * CaseDescription: 1. call GetSurface
150 *                  2. call Add
151 *                  3. call GetSurface again
152 *                  4. check ret
153  */
154 HWTEST_F(SurfaceUtilsTest, GetSurface003, Function | MediumTest | Level2)
155 {
156     sptr<Surface> surface2 = utils->GetSurface(psurface2->GetUniqueId());
157     ASSERT_NE(surface2, nullptr);
158 
159     GSError ret = utils->Add(psurface2->GetUniqueId(), psurface2);
160     ASSERT_EQ(ret, OHOS::GSERROR_OK);
161 
162     surface2 = utils->GetSurface(psurface2->GetUniqueId());
163     ASSERT_NE(surface2, nullptr);
164 }
165 
166 /*
167 * Function: Remove
168 * Type: Function
169 * Rank: Important(2)
170 * EnvConditions: N/A
171 * CaseDescription: 1. call Remove
172 *                  2. check ret
173  */
174 HWTEST_F(SurfaceUtilsTest, Remove001, Function | MediumTest | Level2)
175 {
176     GSError ret = utils->Remove(0);
177     ASSERT_EQ(ret, GSERROR_INVALID_OPERATING);
178 }
179 
180 /*
181 * Function: Remove
182 * Type: Function
183 * Rank: Important(2)
184 * EnvConditions: N/A
185 * CaseDescription: 1. call Remove 2 times
186 *                  2. check ret
187  */
188 HWTEST_F(SurfaceUtilsTest, Remove002, Function | MediumTest | Level2)
189 {
190     GSError ret = utils->Remove(psurface1->GetUniqueId());
191     ASSERT_EQ(ret, OHOS::GSERROR_OK);
192 
193     ret = utils->Remove(psurface1->GetUniqueId());
194     ASSERT_EQ(ret, SURFACE_ERROR_INVALID_OPERATING);
195 }
196 
197 /*
198 * Function: ComputeTransformMatrix
199 * Type: Function
200 * Rank: Important(2)
201 * EnvConditions: N/A
202 * CaseDescription: 1. call ComputeTransformMatrix
203 *                  2. call ComputeTransformMatrixV2
204  */
205 HWTEST_F(SurfaceUtilsTest, ComputeTransformMatrix001, Function | MediumTest | Level2)
206 {
207     // Prepare params
208     sptr<SurfaceBuffer> buffer = new SurfaceBufferImpl();
209     buffer->SetSurfaceBufferWidth(1920);
210     buffer->SetSurfaceBufferHeight(1920);
211     float matrix[TRANSFORM_MATRIX_SIZE];
212     Rect crop = {};
213     crop.w = buffer->GetWidth();
214     crop.h = buffer->GetHeight();
215     GraphicTransformType transform = GraphicTransformType::GRAPHIC_FLIP_H;
216     float emptyMatrix[TRANSFORM_MATRIX_SIZE];
217     //invalid parameter
218     sptr<SurfaceBuffer> tmpBuffer = nullptr;
219     utils->ComputeTransformMatrix(matrix, TRANSFORM_MATRIX_SIZE, tmpBuffer, transform, crop);
220     ASSERT_TRUE(IsArrayEmpty(matrix));
221     utils->ComputeTransformMatrixV2(matrix, TRANSFORM_MATRIX_SIZE, tmpBuffer, transform, crop);
222     ASSERT_TRUE(IsArrayEmpty(matrix));
223 
224     // Compute matrix with normal crop
225     utils->ComputeTransformMatrix(matrix, 16, buffer, transform, crop);
226     ASSERT_NE(matrix, emptyMatrix);
227     utils->ComputeTransformMatrixV2(matrix, 16, buffer, transform, crop);
228     ASSERT_NE(matrix, emptyMatrix);
229 }
230 
IsArrayEmpty(const float arr[TRANSFORM_MATRIX_SIZE])231 bool SurfaceUtilsTest::IsArrayEmpty(const float arr[TRANSFORM_MATRIX_SIZE])
232 {
233     return std::all_of(arr, arr + TRANSFORM_MATRIX_SIZE, [](float value) { return value == 0.0f; });
234 }
235 
236 /*
237 * Function: ComputeTransformMatrix
238 * Type: Function
239 * Rank: Important(2)
240 * EnvConditions: N/A
241 * CaseDescription: 1. call ComputeTransformMatrix with small crop
242 *                  2. call ComputeTransformMatrixV2 with small crop
243  */
244 HWTEST_F(SurfaceUtilsTest, ComputeTransformMatrix002, Function | MediumTest | Level2)
245 {
246     // Prepare params
247     sptr<SurfaceBuffer> buffer = new SurfaceBufferImpl();
248     buffer->SetSurfaceBufferWidth(1920);
249     buffer->SetSurfaceBufferHeight(1920);
250     float matrix[16];
251     Rect crop = {};
252     crop.w = 100;
253     crop.h = 100;
254     GraphicTransformType transform = GraphicTransformType::GRAPHIC_FLIP_H;
255 
256     // Compute matrix with normal crop
257     float emptyMatrix[16];
258     utils->ComputeTransformMatrix(matrix, 16, buffer, transform, crop);
259     ASSERT_NE(matrix, emptyMatrix);
260     utils->ComputeTransformMatrixV2(matrix, 16, buffer, transform, crop);
261     ASSERT_NE(matrix, emptyMatrix);
262 }
263 }