1 /*
2 * Copyright (c) 2023 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 "napi/native_api.h"
17 #include <cstdint>
18 #include <hilog/log.h>
19 #include <multimedia/player_framework/native_avcodec_base.h>
20 #include <native_image/native_image.h>
21 #include <native_window/external_window.h>
22 #include <native_buffer/native_buffer.h>
23 #include "nativewindow.h"
24 #include "ace/xcomponent/native_interface_xcomponent.h"
25 #include <string>
26
27 #define SUCCESS 0
28 #define FAIL (-1)
29
30 #define CONSTANT_2147483647 2147483647
31 #define CONSTANT_2147483648 2147483648
32 #define CONSTANT_NEG_2147483647 (-2147483647)
33 #define CONSTANT_NEG_2147483648 (-2147483648)
34 #define CONSTANT_NEG_9223372036854775807 (9223372036854775807)
35 #define CONSTANT_NEG_9223372036854775808 (-9223372036854775808)
36
37
38 #define CONSTANT_0 0
39 #define CONSTANT_1 1
40 #define CONSTANT_2 2
41 #define CONSTANT_3 3
42 #define CONSTANT_4 4
43 #define CONSTANT_5 5
44 #define CONSTANT_6 6
45 #define CONSTANT_7 7
46 #define CONSTANT_8 8
47 #define CONSTANT_60 60
48 #define CONSTANT_2999 2999
49 #define CONSTANT_3000 3000
50 #define CONSTANT_3001 3001
51 #define CONSTANT_998899 998899
52 #define CONSTANT_100 100
53 #define CONSTANT_1000 1000
54 #define CONSTANT_10000 10000
55 #define CONSTANT_100000 100000
56 #define CONSTANT_1000000 1000000
57 #define CONSTANT_10000000 10000000
58 #define CONSTANT_100000000 100000000
59 #define CONSTANT_1000000000 1000000000
60 #define CONSTANT_1999999 1999999
61 #define CONSTANT_99999999 99999999
62 #define CONSTANT_99999999999999999 99999999999999999
63 #define CONSTANT_999999999999999999 999999999999999999
64 #define CONSTANT_40001000 40001000
65 #define CONSTANT_50002000 50002000
66 #define CONSTANT_50102000 50102000
67
68 OH_NativeBuffer_Format bufferFormatType[] = {
69 NATIVEBUFFER_PIXEL_FMT_CLUT8, NATIVEBUFFER_PIXEL_FMT_CLUT1, NATIVEBUFFER_PIXEL_FMT_CLUT4,
70 NATIVEBUFFER_PIXEL_FMT_RGB_565, NATIVEBUFFER_PIXEL_FMT_RGBA_5658, NATIVEBUFFER_PIXEL_FMT_RGBX_4444,
71 NATIVEBUFFER_PIXEL_FMT_RGBA_4444, NATIVEBUFFER_PIXEL_FMT_RGB_444, NATIVEBUFFER_PIXEL_FMT_RGBX_5551,
72 NATIVEBUFFER_PIXEL_FMT_RGBA_5551, NATIVEBUFFER_PIXEL_FMT_RGB_555, NATIVEBUFFER_PIXEL_FMT_RGBX_8888,
73 NATIVEBUFFER_PIXEL_FMT_RGBA_8888, NATIVEBUFFER_PIXEL_FMT_RGB_888, NATIVEBUFFER_PIXEL_FMT_BGR_565,
74 NATIVEBUFFER_PIXEL_FMT_BGRX_4444, NATIVEBUFFER_PIXEL_FMT_BGRA_4444, NATIVEBUFFER_PIXEL_FMT_BGRX_5551,
75 NATIVEBUFFER_PIXEL_FMT_BGRA_5551, NATIVEBUFFER_PIXEL_FMT_BGRX_8888, NATIVEBUFFER_PIXEL_FMT_BGRA_8888,
76 NATIVEBUFFER_PIXEL_FMT_YUV_422_I, NATIVEBUFFER_PIXEL_FMT_YCBCR_422_SP, NATIVEBUFFER_PIXEL_FMT_YCRCB_422_SP,
77 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, NATIVEBUFFER_PIXEL_FMT_YCBCR_422_P,
78 NATIVEBUFFER_PIXEL_FMT_YCRCB_422_P, NATIVEBUFFER_PIXEL_FMT_YCBCR_420_P, NATIVEBUFFER_PIXEL_FMT_YCRCB_420_P,
79 NATIVEBUFFER_PIXEL_FMT_YUYV_422_PKG, NATIVEBUFFER_PIXEL_FMT_UYVY_422_PKG, NATIVEBUFFER_PIXEL_FMT_YVYU_422_PKG,
80 NATIVEBUFFER_PIXEL_FMT_VYUY_422_PKG, NATIVEBUFFER_PIXEL_FMT_RGBA_1010102, NATIVEBUFFER_PIXEL_FMT_YCBCR_P010,
81 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010, NATIVEBUFFER_PIXEL_FMT_RAW10, NATIVEBUFFER_PIXEL_FMT_VENDER_MASK,
82 NATIVEBUFFER_PIXEL_FMT_BUTT, NATIVEBUFFER_PIXEL_FMT_BLOB, NATIVEBUFFER_PIXEL_FMT_RGBA16_FLOAT,
83 NATIVEBUFFER_PIXEL_FMT_Y8, NATIVEBUFFER_PIXEL_FMT_Y16,
84 };
85
86 int32_t TransformType[] = {
87 NATIVEBUFFER_ROTATE_NONE, NATIVEBUFFER_ROTATE_90, NATIVEBUFFER_ROTATE_180, NATIVEBUFFER_ROTATE_270,
88 NATIVEBUFFER_FLIP_H, NATIVEBUFFER_FLIP_V, NATIVEBUFFER_FLIP_H_ROT90, NATIVEBUFFER_FLIP_V_ROT90,
89 NATIVEBUFFER_FLIP_H_ROT180, NATIVEBUFFER_FLIP_V_ROT180, NATIVEBUFFER_FLIP_H_ROT270, NATIVEBUFFER_FLIP_V_ROT270,
90 };
91
92 int32_t ColorGamut[] = {
93 NATIVEBUFFER_COLOR_GAMUT_NATIVE, NATIVEBUFFER_COLOR_GAMUT_STANDARD_BT601,
94 NATIVEBUFFER_COLOR_GAMUT_STANDARD_BT709, NATIVEBUFFER_COLOR_GAMUT_DCI_P3,
95 NATIVEBUFFER_COLOR_GAMUT_SRGB, NATIVEBUFFER_COLOR_GAMUT_ADOBE_RGB,
96 NATIVEBUFFER_COLOR_GAMUT_DISPLAY_P3, NATIVEBUFFER_COLOR_GAMUT_BT2020,
97 NATIVEBUFFER_COLOR_GAMUT_BT2100_PQ, NATIVEBUFFER_COLOR_GAMUT_BT2100_HLG,
98 NATIVEBUFFER_COLOR_GAMUT_DISPLAY_BT2020,
99 };
100
101 uint64_t usageType[] = {
102 NATIVEBUFFER_USAGE_CPU_READ, NATIVEBUFFER_USAGE_CPU_WRITE, NATIVEBUFFER_USAGE_MEM_DMA,
103 NATIVEBUFFER_USAGE_HW_RENDER, NATIVEBUFFER_USAGE_HW_TEXTURE, NATIVEBUFFER_USAGE_CPU_READ_OFTEN,
104 NATIVEBUFFER_USAGE_ALIGNMENT_512, NATIVEBUFFER_USAGE_MEM_MMZ_CACHE, NATIVEBUFFER_USAGE_CPU_READ
105 | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA | NATIVEBUFFER_USAGE_HW_RENDER
106 | NATIVEBUFFER_USAGE_HW_TEXTURE | NATIVEBUFFER_USAGE_CPU_READ_OFTEN
107 | NATIVEBUFFER_USAGE_ALIGNMENT_512 | NATIVEBUFFER_USAGE_MEM_MMZ_CACHE,
108 };
109
DestroyNativeWindowImage(OH_NativeImage * image,OHNativeWindow * window)110 static void DestroyNativeWindowImage(OH_NativeImage *image, OHNativeWindow *window)
111 {
112 OH_NativeWindow_DestroyNativeWindow(window);
113 OH_NativeImage_Destroy(&image);
114 }
115
testNativeWindowNativeWindowHandleOptSetGetFormatNormal(napi_env env,napi_callback_info info)116 napi_value testNativeWindowNativeWindowHandleOptSetGetFormatNormal(napi_env env, napi_callback_info info)
117 {
118 napi_value result = nullptr;
119 InitNativeWindow* initNative = new InitNativeWindow();
120 OHNativeWindow *nativeWindow = nullptr;
121 nativeWindow = initNative->returnNativeWindow();
122 if (nativeWindow == nullptr) {
123 napi_create_int32(env, CONSTANT_998899, &result);
124 return result;
125 }
126 OH_NativeImage *iamge = initNative->returnNativeImage();
127 // OHNativeWindow* nativeWindow;
128 for (int i = 0; i < sizeof(bufferFormatType)/sizeof(bufferFormatType[0]); ++i) {
129 int32_t flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_FORMAT, bufferFormatType[i]);
130 if (flag != 0) {
131 napi_create_int32(env, CONSTANT_1, &result);
132 return result;
133 }
134 int32_t getFormat;
135 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_FORMAT, &getFormat);
136 if (flag != 0) {
137 napi_create_int32(env, CONSTANT_2, &result);
138 return result;
139 }
140 if (getFormat != bufferFormatType[i]) {
141 napi_create_int32(env, CONSTANT_3, &result);
142 return result;
143 }
144 }
145 delete initNative;
146 napi_create_int32(env, SUCCESS, &result);
147 return result;
148 }
149
testNativeWindowNativeWindowHandleOptSetGetFormatAbnormal(napi_env env,napi_callback_info info)150 napi_value testNativeWindowNativeWindowHandleOptSetGetFormatAbnormal(napi_env env, napi_callback_info info)
151 {
152 napi_value result = nullptr;
153 InitNativeWindow* initNative = new InitNativeWindow();
154 OHNativeWindow *nativeWindow = nullptr;
155 nativeWindow = initNative->returnNativeWindow();
156 if (nativeWindow == nullptr) {
157 napi_create_int32(env, CONSTANT_998899, &result);
158 return result;
159 }
160 OH_NativeImage *iamge = initNative->returnNativeImage();
161 int32_t flag;
162 int32_t arr[] = {-CONSTANT_2147483648, -CONSTANT_2147483647, -CONSTANT_1000000, -CONSTANT_100, -CONSTANT_1,
163 CONSTANT_0, CONSTANT_1, CONSTANT_100000, CONSTANT_2147483647};
164
165 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
166 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_FORMAT, arr[i]);
167 if (flag != 0) {
168 napi_create_int32(env, (i + 1) * CONSTANT_1000 + CONSTANT_1, &result);
169 return result;
170 }
171 int32_t format;
172 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_FORMAT, &format);
173 if (flag != 0) {
174 napi_create_int32(env, (i + 1) * CONSTANT_1000 + CONSTANT_2, &result);
175 return result;
176 }
177 if (format != arr[i]) {
178 napi_create_int32(env, (i + 1) * CONSTANT_1000 + CONSTANT_3, &result);
179 return result;
180 }
181 }
182
183 int32_t flag1 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_FORMAT, "ab%^！#8c");
184 int32_t flag2 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_FORMAT, CONSTANT_999999999999999999);
185 int32_t flag3 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_FORMAT, NULL);
186 int32_t flag4 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_FORMAT);
187 if (flag1 != 0 || flag2 != 0 || flag3 != 0 || flag4 != 0) {
188 napi_create_int32(env, CONSTANT_10000 + CONSTANT_4, &result);
189 return result;
190 }
191 delete initNative;
192 napi_create_int32(env, SUCCESS, &result);
193 return result;
194 }
195
testNativeWindowNativeWindowHandleOptSetGetUsageNormal(napi_env env,napi_callback_info info)196 napi_value testNativeWindowNativeWindowHandleOptSetGetUsageNormal(napi_env env, napi_callback_info info)
197 {
198 napi_value result = nullptr;
199 InitNativeWindow* initNative = new InitNativeWindow();
200 OHNativeWindow *_nativeWindow = nullptr;
201 _nativeWindow = initNative->returnNativeWindow();
202 if (_nativeWindow == nullptr) {
203 napi_create_int32(env, CONSTANT_998899, &result);
204 return result;
205 }
206 OH_NativeImage *iamge = initNative->returnNativeImage();
207 int code = SET_BUFFER_GEOMETRY;
208 int32_t width_ = 0x100;
209 int32_t height_ = 0x100;
210 OH_NativeWindow_NativeWindowHandleOpt(_nativeWindow, code, width_, height_);
211 for (int i = 0; i < sizeof(usageType)/sizeof(usageType[0]); ++i) {
212 uint64_t getUsage;
213 int32_t flag1 = OH_NativeWindow_NativeWindowHandleOpt(_nativeWindow, SET_USAGE, usageType[i]);
214 int32_t flag2 = OH_NativeWindow_NativeWindowHandleOpt(_nativeWindow, GET_USAGE, &getUsage);
215 if (flag1 != 0 || flag2 != 0) {
216 napi_create_int32(env, (i + 1) * CONSTANT_1000 + CONSTANT_2, &result);
217 return result;
218 }
219 if (getUsage != usageType[i]) {
220 napi_create_int32(env, (i + 1) * CONSTANT_1000 + CONSTANT_3, &result);
221 return result;
222 }
223 }
224 uint64_t arr2[] = {0, 1, 1000, 100000000, 2147483647, 18446744073709551615};
225 for (int i = 0; i < sizeof(arr2) / sizeof(arr2[0]); ++i) {
226 int32_t flag1 = OH_NativeWindow_NativeWindowHandleOpt(_nativeWindow, SET_USAGE, arr2[i]);
227 uint64_t usage;
228 int32_t flag2 = OH_NativeWindow_NativeWindowHandleOpt(_nativeWindow, GET_USAGE, &usage);
229 if (flag1 != 0 || flag2 != 0) {
230 napi_create_int32(env, (i + 1) * CONSTANT_1000 + CONSTANT_5, &result);
231 return result;
232 }
233 if (usage != arr2[i]) {
234 napi_create_int32(env, (i + 1) * CONSTANT_1000 + CONSTANT_6, &result);
235 return result;
236 }
237 }
238 delete initNative;
239 napi_create_int32(env, SUCCESS, &result);
240 return result;
241 }
242
testNativeWindowNativeWindowHandleOptSetGetUsageAbnormal(napi_env env,napi_callback_info info)243 napi_value testNativeWindowNativeWindowHandleOptSetGetUsageAbnormal(napi_env env, napi_callback_info info)
244 {
245 napi_value result = nullptr;
246 InitNativeWindow* initNative = new InitNativeWindow();
247 OHNativeWindow *nativeWindow = nullptr;
248 nativeWindow = initNative->returnNativeWindow();
249 if (nativeWindow == nullptr) {
250 napi_create_int32(env, CONSTANT_998899, &result);
251 return result;
252 }
253 OH_NativeImage *iamge = initNative->returnNativeImage();
254 int32_t flag;
255 unsigned arr[] = {static_cast<unsigned int>(-999999999999999999), static_cast<unsigned int>(-2147483648),
256 static_cast<unsigned int>(-1000), static_cast<unsigned int>(-1),
257 static_cast<unsigned int>(999999999999999999)};
258
259 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
260 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_USAGE, arr[i]);
261 if (flag != 0) {
262 napi_create_int32(env, (i + 1) * CONSTANT_1000 + CONSTANT_1, &result);
263 return result;
264 }
265 uint64_t usage;
266 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_USAGE, &usage);
267 if (flag != 0) {
268 napi_create_int32(env, (i + 1) * CONSTANT_1000 + CONSTANT_2, &result);
269 return result;
270 }
271 }
272
273 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_USAGE, "");
274 if (flag != 0) {
275 napi_create_int32(env, CONSTANT_100000 + CONSTANT_1, &result);
276 return result;
277 }
278 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_USAGE, NULL);
279 if (flag != 0) {
280 napi_create_int32(env, CONSTANT_2 * CONSTANT_100000 + CONSTANT_1, &result);
281 return result;
282 }
283 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_USAGE);
284 if (flag != 0) {
285 napi_create_int32(env, CONSTANT_3 * CONSTANT_100000 + CONSTANT_1, &result);
286 return result;
287 }
288 delete initNative;
289 napi_create_int32(env, SUCCESS, &result);
290 return result;
291 }
292
293
testNativeWindowNativeWindowHandleOptSetGetStrideNormal(napi_env env,napi_callback_info info)294 napi_value testNativeWindowNativeWindowHandleOptSetGetStrideNormal(napi_env env, napi_callback_info info)
295 {
296 napi_value result = nullptr;
297 int32_t flag;
298 InitNativeWindow* initNative = new InitNativeWindow();
299 OHNativeWindow *nativeWindow = nullptr;
300 nativeWindow = initNative->returnNativeWindow();
301 if (nativeWindow == nullptr) {
302 napi_create_int32(env, CONSTANT_998899, &result);
303 return result;
304 }
305 OH_NativeImage *iamge = initNative->returnNativeImage();
306 int32_t arr[] = {-CONSTANT_2147483647, -CONSTANT_1000, -CONSTANT_1, CONSTANT_0,
307 CONSTANT_1, CONSTANT_1000, CONSTANT_2147483647};
308 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
309 int32_t stride;
310 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_STRIDE, arr[i]);
311 if (flag != 0) {
312 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
313 return result;
314 }
315 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_STRIDE, &stride);
316 if (flag != 0) {
317 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_2, &result);
318 return result;
319 }
320 if (arr[i] != stride) {
321 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_3, &result);
322 return result;
323 }
324 }
325 delete initNative;
326 napi_create_int32(env, SUCCESS, &result);
327 return result;
328 }
329
testNativeWindowNativeWindowHandleOptSetGetStrideAbnormal(napi_env env,napi_callback_info info)330 napi_value testNativeWindowNativeWindowHandleOptSetGetStrideAbnormal(napi_env env, napi_callback_info info)
331 {
332 napi_value result = nullptr;
333 int32_t flag;
334 int32_t stride;
335 InitNativeWindow* initNative = new InitNativeWindow();
336 OHNativeWindow *nativeWindow = nullptr;
337 nativeWindow = initNative->returnNativeWindow();
338 if (nativeWindow == nullptr) {
339 napi_create_int32(env, CONSTANT_998899, &result);
340 return result;
341 }
342 OH_NativeImage *iamge = initNative->returnNativeImage();
343
344 long long arr[] = {-CONSTANT_999999999999999999, static_cast<long long>(CONSTANT_999999999999999999), 1LL << 63};
345 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
346 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_STRIDE, arr[i]);
347 if (flag != 0) {
348 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
349 return result;
350 }
351 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_STRIDE, &stride);
352 if (flag != 0) {
353 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_2, &result);
354 return result;
355 }
356 }
357 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_STRIDE, NULL);
358 if (flag != 0) {
359 napi_create_int32(env, CONSTANT_100000 + CONSTANT_1, &result);
360 return result;
361 }
362 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_STRIDE, "sdasda213!");
363 if (flag != 0) {
364 napi_create_int32(env, CONSTANT_2 * CONSTANT_100000 + CONSTANT_1, &result);
365 return result;
366 }
367 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_STRIDE);
368 if (flag != 0) {
369 napi_create_int32(env, CONSTANT_3 * CONSTANT_100000 + CONSTANT_1, &result);
370 return result;
371 }
372
373 delete initNative;
374 napi_create_int32(env, SUCCESS, &result);
375 return result;
376 }
377
378
testNativeWindowNativeWindowHandleOptSetGetSwapIntervalNormal(napi_env env,napi_callback_info info)379 napi_value testNativeWindowNativeWindowHandleOptSetGetSwapIntervalNormal(napi_env env, napi_callback_info info)
380 {
381 napi_value result = nullptr;
382 int32_t flag;
383 InitNativeWindow* initNative = new InitNativeWindow();
384 OHNativeWindow *nativeWindow = nullptr;
385 nativeWindow = initNative->returnNativeWindow();
386 if (nativeWindow == nullptr) {
387 napi_create_int32(env, CONSTANT_998899, &result);
388 return result;
389 }
390 OH_NativeImage *iamge = initNative->returnNativeImage();
391
392 int32_t arr[] = {CONSTANT_0, CONSTANT_100, CONSTANT_1000, CONSTANT_10000, CONSTANT_1000000,
393 CONSTANT_1000000000, CONSTANT_2147483647, -CONSTANT_1999999, -CONSTANT_99999999};
394 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
395 int32_t interval;
396 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_SWAP_INTERVAL, arr[i]);
397 if (flag != 0) {
398 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
399 return result;
400 }
401 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_SWAP_INTERVAL, &interval);
402 if (flag != 0) {
403 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_2, &result);
404 return result;
405 }
406 }
407
408 delete initNative;
409 napi_create_int32(env, SUCCESS, &result);
410 return result;
411 }
412
testNativeWindowNativeWindowHandleOptSetGetSwapIntervalAbnormal(napi_env env,napi_callback_info info)413 napi_value testNativeWindowNativeWindowHandleOptSetGetSwapIntervalAbnormal(napi_env env, napi_callback_info info)
414 {
415 napi_value result = nullptr;
416 int32_t flag;
417 int32_t stride;
418 InitNativeWindow* initNative = new InitNativeWindow();
419 OHNativeWindow *nativeWindow = nullptr;
420 nativeWindow = initNative->returnNativeWindow();
421 if (nativeWindow == nullptr) {
422 napi_create_int32(env, CONSTANT_998899, &result);
423 return result;
424 }
425 OH_NativeImage *iamge = initNative->returnNativeImage();
426
427 long long arr[] = {-CONSTANT_99999999999999999, static_cast<long long>(CONSTANT_99999999999999999), 1LL << 63};
428 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
429 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_STRIDE, arr[i]);
430 if (flag != 0) {
431 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
432 return result;
433 }
434 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_STRIDE, &stride);
435 if (flag != 0) {
436 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_2, &result);
437 return result;
438 }
439 }
440 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_STRIDE, NULL);
441 if (flag != 0) {
442 napi_create_int32(env, CONSTANT_100000 + CONSTANT_1, &result);
443 return result;
444 }
445 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_STRIDE, "sdasda213!");
446 if (flag != 0) {
447 napi_create_int32(env, CONSTANT_2 * CONSTANT_100000 + CONSTANT_1, &result);
448 return result;
449 }
450 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_STRIDE);
451 if (flag != 0) {
452 napi_create_int32(env, CONSTANT_3 * CONSTANT_100000 + CONSTANT_1, &result);
453 return result;
454 }
455
456 delete initNative;
457 napi_create_int32(env, SUCCESS, &result);
458 return result;
459 }
460
461
testNativeWindowNativeWindowHandleOptSetGetColorGamutNormal(napi_env env,napi_callback_info info)462 napi_value testNativeWindowNativeWindowHandleOptSetGetColorGamutNormal(napi_env env, napi_callback_info info)
463 {
464 napi_value result = nullptr;
465 InitNativeWindow* initNative = new InitNativeWindow();
466 OHNativeWindow *nativeWindow = nullptr;
467 nativeWindow = initNative->returnNativeWindow();
468 if (nativeWindow == nullptr) {
469 napi_create_int32(env, CONSTANT_998899, &result);
470 return result;
471 }
472 OH_NativeImage *iamge = initNative->returnNativeImage();
473
474 for (int i = 0; i < sizeof(ColorGamut) / sizeof(ColorGamut[0]); ++i) {
475 int32_t getColorGamut;
476 int32_t flag1 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_COLOR_GAMUT, ColorGamut[i]);
477 int32_t flag2 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_COLOR_GAMUT, &getColorGamut);
478 if (flag1 != 0 || flag2 != 0) {
479 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
480 return result;
481 }
482 if (getColorGamut != ColorGamut[i]) {
483 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_2, &result);
484 return result;
485 }
486 }
487 int32_t arr[] = {-CONSTANT_2147483647, -CONSTANT_1000, -CONSTANT_1, CONSTANT_0,
488 CONSTANT_1, CONSTANT_1000, CONSTANT_2147483647};
489 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
490 int32_t gamut;
491 int32_t flag1 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_COLOR_GAMUT, arr[i]);
492 int32_t flag2 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_COLOR_GAMUT, &gamut);
493 if (flag1 != 0 || flag2 != 0) {
494 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_3, &result);
495 return result;
496 }
497 if (arr[i] != gamut) {
498 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_4, &result);
499 return result;
500 }
501 }
502 delete initNative;
503 napi_create_int32(env, SUCCESS, &result);
504 return result;
505 }
506
testNativeWindowNativeWindowHandleOptSetGetColorGamutAbnormal(napi_env env,napi_callback_info info)507 napi_value testNativeWindowNativeWindowHandleOptSetGetColorGamutAbnormal(napi_env env, napi_callback_info info)
508 {
509 napi_value result = nullptr;
510 int32_t flag;
511 int32_t gamut;
512 InitNativeWindow* initNative = new InitNativeWindow();
513 OHNativeWindow *nativeWindow = nullptr;
514 nativeWindow = initNative->returnNativeWindow();
515 if (nativeWindow == nullptr) {
516 napi_create_int32(env, CONSTANT_998899, &result);
517 return result;
518 }
519 OH_NativeImage *iamge = initNative->returnNativeImage();
520
521 long long arr[] = {-CONSTANT_99999999999999999, static_cast<long long>(CONSTANT_99999999999999999), 1LL << 63};
522 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
523 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_COLOR_GAMUT, arr[i]);
524 if (flag != 0) {
525 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
526 return result;
527 }
528 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_COLOR_GAMUT, &gamut);
529 if (flag != 0) {
530 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_2, &result);
531 return result;
532 }
533 }
534 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_COLOR_GAMUT, NULL);
535 if (flag != 0) {
536 napi_create_int32(env, CONSTANT_100000 + CONSTANT_1, &result);
537 return result;
538 }
539 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_COLOR_GAMUT, "sdasda213!");
540 if (flag != 0) {
541 napi_create_int32(env, CONSTANT_2 * CONSTANT_100000 + CONSTANT_1, &result);
542 return result;
543 }
544 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_COLOR_GAMUT);
545 if (flag != 0) {
546 napi_create_int32(env, CONSTANT_3 * CONSTANT_100000 + CONSTANT_1, &result);
547 return result;
548 }
549
550 delete initNative;
551 napi_create_int32(env, SUCCESS, &result);
552 return result;
553 }
554
555
testNativeWindowNativeWindowHandleOptSetGetTransformNormal(napi_env env,napi_callback_info info)556 napi_value testNativeWindowNativeWindowHandleOptSetGetTransformNormal(napi_env env, napi_callback_info info)
557 {
558 napi_value result = nullptr;
559 InitNativeWindow* initNative = new InitNativeWindow();
560 OHNativeWindow *nativeWindow = nullptr;
561 nativeWindow = initNative->returnNativeWindow();
562 if (nativeWindow == nullptr) {
563 napi_create_int32(env, CONSTANT_998899, &result);
564 return result;
565 }
566 OH_NativeImage *iamge = initNative->returnNativeImage();
567 for (int i = 0; i < sizeof(TransformType)/sizeof(TransformType[0]); ++i) {
568 int32_t getTransformType;
569 int32_t flag1 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_TRANSFORM, TransformType[i]);
570 int32_t flag2 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_TRANSFORM, &getTransformType);
571 if (flag1 != 0 || flag2 != 0) {
572 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_2, &result);
573 return result;
574 }
575 if (TransformType[i] != getTransformType) {
576 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_3, &result);
577 return result;
578 }
579 }
580 int32_t arr[] = {-CONSTANT_2147483647, -CONSTANT_1000, -CONSTANT_1, CONSTANT_0,
581 CONSTANT_1, CONSTANT_1000, CONSTANT_2147483647};
582 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
583 int32_t transform;
584 int32_t flag1 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_TRANSFORM, arr[i]);
585 int32_t flag2 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_TRANSFORM, &transform);
586 if (flag1 != 0 || flag2 != 0) {
587 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_4, &result);
588 return result;
589 }
590 if (arr[i] != transform) {
591 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_5, &result);
592 return result;
593 }
594 }
595
596 delete initNative;
597 napi_create_int32(env, SUCCESS, &result);
598 return result;
599 }
600
testNativeWindowNativeWindowHandleOptSetGetTransformAbnormal(napi_env env,napi_callback_info info)601 napi_value testNativeWindowNativeWindowHandleOptSetGetTransformAbnormal(napi_env env, napi_callback_info info)
602 {
603 napi_value result = nullptr;
604 int32_t flag;
605 int32_t gamut;
606 InitNativeWindow* initNative = new InitNativeWindow();
607 OHNativeWindow *nativeWindow = nullptr;
608 nativeWindow = initNative->returnNativeWindow();
609 if (nativeWindow == nullptr) {
610 napi_create_int32(env, CONSTANT_998899, &result);
611 return result;
612 }
613 OH_NativeImage *iamge = initNative->returnNativeImage();
614
615 long long arr[] = {-CONSTANT_99999999999999999, static_cast<long long>(CONSTANT_99999999999999999), 1LL << 63};
616 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
617 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_TRANSFORM, arr[i]);
618 if (flag != 0) {
619 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
620 return result;
621 }
622 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_TRANSFORM, &gamut);
623 if (flag != 0) {
624 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_2, &result);
625 return result;
626 }
627 }
628 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_TRANSFORM, NULL);
629 if (flag != 0) {
630 napi_create_int32(env, CONSTANT_100000 + CONSTANT_1, &result);
631 return result;
632 }
633 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_TRANSFORM, "sdasda213!");
634 if (flag != 0) {
635 napi_create_int32(env, CONSTANT_2 * CONSTANT_100000 + CONSTANT_1, &result);
636 return result;
637 }
638 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_TRANSFORM);
639 if (flag != 0) {
640 napi_create_int32(env, CONSTANT_3 * CONSTANT_100000 + CONSTANT_1, &result);
641 return result;
642 }
643
644 delete initNative;
645 napi_create_int32(env, SUCCESS, &result);
646 return result;
647 }
648
649
testNativeWindowNativeWindowHandleOptSetUiTimeStampNormal(napi_env env,napi_callback_info info)650 napi_value testNativeWindowNativeWindowHandleOptSetUiTimeStampNormal(napi_env env, napi_callback_info info)
651 {
652 napi_value result = nullptr;
653
654 int32_t flag;
655 InitNativeWindow* initNative = new InitNativeWindow();
656 OHNativeWindow *nativeWindow = nullptr;
657 nativeWindow = initNative->returnNativeWindow();
658 if (nativeWindow == nullptr) {
659 napi_create_int32(env, CONSTANT_998899, &result);
660 return result;
661 }
662 OH_NativeImage *iamge = initNative->returnNativeImage();
663 uint64_t arr[] = {CONSTANT_0, CONSTANT_1, CONSTANT_1000, 1ULL << 63, CONSTANT_999999999999999999,
664 18446744073709551615};
665 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
666 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_UI_TIMESTAMP, arr[i]);
667 if (flag != 0) {
668 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
669 return result;
670 }
671 }
672
673 delete initNative;
674 napi_create_int32(env, SUCCESS, &result);
675 return result;
676 }
677
testNativeWindowNativeWindowHandleOptSetUiTimeStampAbnormal(napi_env env,napi_callback_info info)678 napi_value testNativeWindowNativeWindowHandleOptSetUiTimeStampAbnormal(napi_env env, napi_callback_info info)
679 {
680 napi_value result = nullptr;
681
682 int32_t flag;
683 InitNativeWindow* initNative = new InitNativeWindow();
684 OHNativeWindow *nativeWindow = nullptr;
685 nativeWindow = initNative->returnNativeWindow();
686 if (nativeWindow == nullptr) {
687 napi_create_int32(env, CONSTANT_998899, &result);
688 return result;
689 }
690 OH_NativeImage *iamge = initNative->returnNativeImage();
691 int64_t arr[] = {-CONSTANT_1, -CONSTANT_1000, -CONSTANT_1000000, -922337203685477580};
692 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
693 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_UI_TIMESTAMP, arr[i]);
694 if (flag != 0) {
695 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
696 return result;
697 }
698 }
699 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_UI_TIMESTAMP, "sdasda213!");
700 if (flag != 0) {
701 napi_create_int32(env, CONSTANT_100000 + CONSTANT_1, &result);
702 return result;
703 }
704 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_UI_TIMESTAMP, NULL);
705 if (flag != 0) {
706 napi_create_int32(env, CONSTANT_2 * CONSTANT_100000 + CONSTANT_1, &result);
707 return result;
708 }
709 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_UI_TIMESTAMP);
710 if (flag != 0) {
711 napi_create_int32(env, CONSTANT_3 * CONSTANT_100000 + CONSTANT_1, &result);
712 return result;
713 }
714
715 delete initNative;
716 napi_create_int32(env, SUCCESS, &result);
717 return result;
718 }
719
720
testNativeWindowNativeWindowHandleOptGetBufferQueueSize(napi_env env,napi_callback_info info)721 napi_value testNativeWindowNativeWindowHandleOptGetBufferQueueSize(napi_env env, napi_callback_info info)
722 {
723 napi_value result = nullptr;
724 InitNativeWindow* initNative = new InitNativeWindow();
725 OHNativeWindow *nativeWindow = nullptr;
726 nativeWindow = initNative->returnNativeWindow();
727 if (nativeWindow == nullptr) {
728 napi_create_int32(env, CONSTANT_998899, &result);
729 return result;
730 }
731 OH_NativeImage *iamge = initNative->returnNativeImage();
732 int32_t size;
733
734 int32_t flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_BUFFERQUEUE_SIZE, &size);
735 if (flag != 0) {
736 napi_create_int32(env, CONSTANT_1, &result);
737 return result;
738 }
739 if (size != CONSTANT_3) {
740 napi_create_int32(env, CONSTANT_2, &result);
741 return result;
742 }
743
744 delete initNative;
745 napi_create_int32(env, SUCCESS, &result);
746 return result;
747 }
748
749
testNativeWindowNativeWindowHandleOptSetHdrWhitePointBrightnessNormal(napi_env env,napi_callback_info info)750 napi_value testNativeWindowNativeWindowHandleOptSetHdrWhitePointBrightnessNormal(napi_env env,
751 napi_callback_info info)
752 {
753 napi_value result = nullptr;
754 InitNativeWindow* initNative = new InitNativeWindow();
755 OHNativeWindow *nativeWindow = nullptr;
756 nativeWindow = initNative->returnNativeWindow();
757 if (nativeWindow == nullptr) {
758 napi_create_int32(env, CONSTANT_998899, &result);
759 return result;
760 }
761 OH_NativeImage *iamge = initNative->returnNativeImage();
762 int32_t brightness;
763
764 float arr[] = {0.0f, 0.00001f, 0.5f, 0.123456f, 0.99999f, 1.0f};
765 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
766 int32_t flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_HDR_WHITE_POINT_BRIGHTNESS, brightness);
767 if (flag != 0) {
768 napi_create_int32(env, i + CONSTANT_1, &result);
769 return result;
770 }
771 }
772
773 delete initNative;
774 napi_create_int32(env, SUCCESS, &result);
775 return result;
776 }
777
778
testNativeWindowNativeWindowHandleOptSetHdrWhitePointBrightnessAbnormal(napi_env env,napi_callback_info info)779 napi_value testNativeWindowNativeWindowHandleOptSetHdrWhitePointBrightnessAbnormal(napi_env env,
780 napi_callback_info info)
781 {
782 napi_value result = nullptr;
783 InitNativeWindow* initNative = new InitNativeWindow();
784 OHNativeWindow *nativeWindow = nullptr;
785 nativeWindow = initNative->returnNativeWindow();
786 if (nativeWindow == nullptr) {
787 napi_create_int32(env, CONSTANT_998899, &result);
788 return result;
789 }
790 OH_NativeImage *iamge = initNative->returnNativeImage();
791 int32_t brightness;
792
793 float arr[] = {-0.1f, 1.1f, -CONSTANT_100, 0, CONSTANT_100};
794 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
795 int32_t flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_HDR_WHITE_POINT_BRIGHTNESS, brightness);
796 if (flag != 0) {
797 napi_create_int32(env, i +CONSTANT_1, &result);
798 return result;
799 }
800 }
801 int32_t flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_HDR_WHITE_POINT_BRIGHTNESS, "test123@@#");
802 if (flag != 0) {
803 napi_create_int32(env, CONSTANT_1000 + CONSTANT_1, &result);
804 return result;
805 }
806 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_HDR_WHITE_POINT_BRIGHTNESS);
807 if (flag != 0) {
808 napi_create_int32(env, CONSTANT_1000 + CONSTANT_2, &result);
809 return result;
810 }
811
812 delete initNative;
813 napi_create_int32(env, SUCCESS, &result);
814 return result;
815 }
816
817
testNativeWindowNativeWindowHandleOptSetSdrWhitePointBrightnessNormal(napi_env env,napi_callback_info info)818 napi_value testNativeWindowNativeWindowHandleOptSetSdrWhitePointBrightnessNormal(napi_env env,
819 napi_callback_info info)
820 {
821 napi_value result = nullptr;
822 InitNativeWindow* initNative = new InitNativeWindow();
823 OHNativeWindow *nativeWindow = nullptr;
824 nativeWindow = initNative->returnNativeWindow();
825 if (nativeWindow == nullptr) {
826 napi_create_int32(env, CONSTANT_998899, &result);
827 return result;
828 }
829 OH_NativeImage *iamge = initNative->returnNativeImage();
830 int32_t brightness;
831
832 float arr[] = {0.0f, 0.00001f, 0.5f, 0.123456f, 0.99999f, 1.0f};
833 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
834 int32_t flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_SDR_WHITE_POINT_BRIGHTNESS, brightness);
835 if (flag != 0) {
836 napi_create_int32(env, i + CONSTANT_1, &result);
837 return result;
838 }
839 }
840
841 delete initNative;
842 napi_create_int32(env, SUCCESS, &result);
843 return result;
844 }
845
846
testNativeWindowNativeWindowHandleOptSetSdrWhitePointBrightnessAbnormal(napi_env env,napi_callback_info info)847 napi_value testNativeWindowNativeWindowHandleOptSetSdrWhitePointBrightnessAbnormal(napi_env env,
848 napi_callback_info info)
849 {
850 napi_value result = nullptr;
851 InitNativeWindow* initNative = new InitNativeWindow();
852 OHNativeWindow *nativeWindow = nullptr;
853 nativeWindow = initNative->returnNativeWindow();
854 if (nativeWindow == nullptr) {
855 napi_create_int32(env, CONSTANT_998899, &result);
856 return result;
857 }
858 OH_NativeImage *iamge = initNative->returnNativeImage();
859 int32_t brightness;
860
861 float arr[] = {-0.1f, 1.1f, -CONSTANT_100, 0, CONSTANT_100};
862 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
863 int32_t flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_SDR_WHITE_POINT_BRIGHTNESS, brightness);
864 if (flag != 0) {
865 napi_create_int32(env, i + CONSTANT_1, &result);
866 return result;
867 }
868 }
869 int32_t flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_SDR_WHITE_POINT_BRIGHTNESS, "test123@@#");
870 if (flag != 0) {
871 napi_create_int32(env, CONSTANT_1000 + CONSTANT_1, &result);
872 return result;
873 }
874 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_SDR_WHITE_POINT_BRIGHTNESS);
875 if (flag != 0) {
876 napi_create_int32(env, CONSTANT_1000 + CONSTANT_2, &result);
877 return result;
878 }
879
880 delete initNative;
881 napi_create_int32(env, SUCCESS, &result);
882 return result;
883 }
884
885
testNativeWindowNativeWindowHandleOptSetGetSourceTypeNormal(napi_env env,napi_callback_info info)886 napi_value testNativeWindowNativeWindowHandleOptSetGetSourceTypeNormal(napi_env env, napi_callback_info info)
887 {
888 napi_value result = nullptr;
889 InitNativeWindow* initNative = new InitNativeWindow();
890 OHNativeWindow *nativeWindow = nullptr;
891 nativeWindow = initNative->returnNativeWindow();
892 if (nativeWindow == nullptr) {
893 napi_create_int32(env, CONSTANT_998899, &result);
894 return result;
895 }
896 OH_NativeImage *iamge = initNative->returnNativeImage();
897 int32_t SourceType[] = {
898 OH_SURFACE_SOURCE_DEFAULT, OH_SURFACE_SOURCE_UI, OH_SURFACE_SOURCE_GAME,
899 OH_SURFACE_SOURCE_CAMERA, OH_SURFACE_SOURCE_VIDEO,
900 };
901 for (int i = 0; i < sizeof(SourceType)/sizeof(SourceType[i]); ++i) {
902 int32_t getSourceType;
903 int32_t flag1 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_SOURCE_TYPE, SourceType[i]);
904 int32_t flag2 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_SOURCE_TYPE, &getSourceType);
905 if (flag1 != 0 || flag2 != 0) {
906 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
907 return result;
908 }
909 if (getSourceType != SourceType[i]) {
910 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_2, &result);
911 return result;
912 }
913 }
914 int32_t arr[] = {-2147483647, -1000, -1, 0, 1, 1000, 2147483647};
915 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
916 int32_t flag1 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_SOURCE_TYPE, arr[i]);
917 int32_t sourceType;
918 int32_t flag2 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_SOURCE_TYPE, &sourceType);
919 if (flag1 != 0 || flag2 != 0) {
920 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_3, &result);
921 return result;
922 }
923 if (sourceType != arr[i]) {
924 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_4, &result);
925 return result;
926 }
927 }
928
929 delete initNative;
930 napi_create_int32(env, SUCCESS, &result);
931 return result;
932 }
933
934
testNativeWindowNativeWindowHandleOptSetGetSourceTypeAbnormal(napi_env env,napi_callback_info info)935 napi_value testNativeWindowNativeWindowHandleOptSetGetSourceTypeAbnormal(napi_env env, napi_callback_info info)
936 {
937 napi_value result = nullptr;
938
939 int32_t flag;
940 InitNativeWindow* initNative = new InitNativeWindow();
941 OHNativeWindow *nativeWindow = nullptr;
942 nativeWindow = initNative->returnNativeWindow();
943 if (nativeWindow == nullptr) {
944 napi_create_int32(env, CONSTANT_998899, &result);
945 return result;
946 }
947 OH_NativeImage *iamge = initNative->returnNativeImage();
948 unsigned arr[] = {static_cast<unsigned int>(-999999999999999999), static_cast<unsigned int>(-2147483648),
949 static_cast<unsigned int>(-1000), static_cast<unsigned int>(-1),
950 static_cast<unsigned int>(999999999999999999)};
951 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
952 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_SOURCE_TYPE, arr[i]);
953 if (flag != 0) {
954 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
955 return result;
956 }
957 int32_t sourceType;
958 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_SOURCE_TYPE, &sourceType);
959 if (flag != 0) {
960 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_2, &result);
961 return result;
962 }
963 }
964 int32_t flag1 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_SOURCE_TYPE, CONSTANT_999999999999999999);
965 int32_t flag2 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_SOURCE_TYPE, "sdasda213!");
966 int32_t flag3 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_SOURCE_TYPE, NULL);
967 int32_t flag4 = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_SOURCE_TYPE);
968 if (flag1 != 0 || flag2 != 0 || flag3 != 0 || flag4 != 0) {
969 napi_create_int32(env, CONSTANT_100000 + CONSTANT_3, &result);
970 return result;
971 }
972
973 delete initNative;
974 napi_create_int32(env, SUCCESS, &result);
975 return result;
976 }
977
978
testNativeWindowNativeWindowHandleOptSetGetAppFrameworkTypeNormal(napi_env env,napi_callback_info info)979 napi_value testNativeWindowNativeWindowHandleOptSetGetAppFrameworkTypeNormal(napi_env env, napi_callback_info info)
980 {
981 napi_value result = nullptr;
982 int32_t flag;
983 char *frameworkType;
984 InitNativeWindow* initNative = new InitNativeWindow();
985 OHNativeWindow *nativeWindow = nullptr;
986 nativeWindow = initNative->returnNativeWindow();
987 if (nativeWindow == nullptr) {
988 napi_create_int32(env, CONSTANT_998899, &result);
989 return result;
990 }
991 OH_NativeImage *iamge = initNative->returnNativeImage();
992
993 const char *arr[] = {
994 "", "0123", "natp ", "应用框架", "Test", "!@#$%&*(", "这里一共是二十一个汉字这里一共是二十一个汉"};
995
996 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
997 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_APP_FRAMEWORK_TYPE, arr[i]);
998 if (flag != 0) {
999 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
1000 return result;
1001 }
1002 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_APP_FRAMEWORK_TYPE, &frameworkType);
1003 if (flag != 0) {
1004 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_2, &result);
1005 return result;
1006 }
1007 int com = strcmp(arr[i], frameworkType);
1008 if (com != 0) {
1009 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_3, &result);
1010 return result;
1011 }
1012 }
1013
1014 delete initNative;
1015 napi_create_int32(env, SUCCESS, &result);
1016 return result;
1017 }
1018
1019
testNativeWindowNativeWindowHandleOptSetGetAppFrameworkTypeAbnormal(napi_env env,napi_callback_info info)1020 napi_value testNativeWindowNativeWindowHandleOptSetGetAppFrameworkTypeAbnormal(napi_env env, napi_callback_info info)
1021 {
1022 napi_value result = nullptr;
1023 int32_t flag;
1024 char *frameworkType;
1025 InitNativeWindow* initNative = new InitNativeWindow();
1026 OHNativeWindow *nativeWindow = nullptr;
1027 nativeWindow = initNative->returnNativeWindow();
1028 if (nativeWindow == nullptr) {
1029 napi_create_int32(env, CONSTANT_998899, &result);
1030 return result;
1031 }
1032 OH_NativeImage *iamge = initNative->returnNativeImage();
1033
1034 const char *arr[] = {"这里一共是二十二个汉字这里一共是二十二个汉字",
1035 "abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde"};
1036 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
1037 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_APP_FRAMEWORK_TYPE, arr[i]);
1038 if (flag != 0) {
1039 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
1040 return result;
1041 }
1042 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_APP_FRAMEWORK_TYPE, &frameworkType);
1043 if (flag != 0) {
1044 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_2, &result);
1045 return result;
1046 }
1047 }
1048
1049 delete initNative;
1050 napi_create_int32(env, SUCCESS, &result);
1051 return result;
1052 }
1053
1054
testNativeWindowNativeWindowSetSetScalingModeV2Nullptr(napi_env env,napi_callback_info info)1055 napi_value testNativeWindowNativeWindowSetSetScalingModeV2Nullptr(napi_env env, napi_callback_info info)
1056 {
1057 napi_value result = nullptr;
1058 InitNativeWindow* initNative = new InitNativeWindow();
1059 OHNativeWindow *nativeWindow = nullptr;
1060 nativeWindow = initNative->returnNativeWindow();
1061 if (nativeWindow == nullptr) {
1062 napi_create_int32(env, CONSTANT_998899, &result);
1063 return result;
1064 }
1065 OH_NativeImage *iamge = initNative->returnNativeImage();
1066
1067 int32_t flag = OH_NativeWindow_NativeWindowSetScalingModeV2(nullptr, OH_SCALING_MODE_FREEZE_V2);
1068 if (flag == 0) {
1069 napi_create_int32(env, CONSTANT_1, &result);
1070 return result;
1071 }
1072 flag = OH_NativeWindow_NativeWindowSetScalingModeV2(nativeWindow, static_cast<OHScalingModeV2>(CONSTANT_100));
1073 if (flag == 0) {
1074 napi_create_int32(env, CONSTANT_2, &result);
1075 return result;
1076 }
1077
1078 delete initNative;
1079 napi_create_int32(env, SUCCESS, &result);
1080 return result;
1081 }
1082
1083
testNativeWindowNativeWindowSetScalingModeV2ScalingMode(napi_env env,napi_callback_info info)1084 napi_value testNativeWindowNativeWindowSetScalingModeV2ScalingMode(napi_env env, napi_callback_info info)
1085 {
1086 napi_value result = nullptr;
1087 InitNativeWindow* initNative = new InitNativeWindow();
1088 OHNativeWindow *nativeWindow = nullptr;
1089 nativeWindow = initNative->returnNativeWindow();
1090 if (nativeWindow == nullptr) {
1091 napi_create_int32(env, CONSTANT_998899, &result);
1092 return result;
1093 }
1094 OH_NativeImage *iamge = initNative->returnNativeImage();
1095
1096 int32_t flag;
1097 OHScalingModeV2 arr[] = {OH_SCALING_MODE_FREEZE_V2, OH_SCALING_MODE_SCALE_TO_WINDOW_V2,
1098 OH_SCALING_MODE_SCALE_CROP_V2, OH_SCALING_MODE_NO_SCALE_CROP_V2,
1099 OH_SCALING_MODE_SCALE_FIT_V2};
1100 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
1101 flag = OH_NativeWindow_NativeWindowSetScalingModeV2(nativeWindow, arr[i]);
1102 if (flag != 0) {
1103 napi_create_int32(env, i + CONSTANT_1, &result);
1104 return result;
1105 }
1106 }
1107
1108 delete initNative;
1109 napi_create_int32(env, SUCCESS, &result);
1110 return result;
1111 }
1112
testNativeWindowGetColorSpaceFirst(napi_env env,napi_callback_info info)1113 napi_value testNativeWindowGetColorSpaceFirst(napi_env env, napi_callback_info info)
1114 {
1115 napi_value result = nullptr;
1116 InitNativeWindow* initNative = new InitNativeWindow();
1117 OHNativeWindow *nativeWindow = nullptr;
1118 nativeWindow = initNative->returnNativeWindow();
1119 if (nativeWindow == nullptr) {
1120 napi_create_int32(env, CONSTANT_998899, &result);
1121 return result;
1122 }
1123 OH_NativeImage *iamge = initNative->returnNativeImage();
1124 OHNativeWindowBuffer *windowBuffer = nullptr;
1125 int fenceFd;
1126 int32_t flag = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &windowBuffer, &fenceFd);
1127 if (flag != 0) {
1128 napi_create_int32(env, CONSTANT_1000 + CONSTANT_1, &result);
1129 return result;
1130 }
1131 OH_NativeBuffer_ColorSpace colorSpace;
1132 flag = OH_NativeWindow_GetColorSpace(nativeWindow, &colorSpace);
1133 if (flag != CONSTANT_50002000 && flag != CONSTANT_50102000) {
1134 napi_create_int32(env, flag, &result);
1135 return result;
1136 }
1137
1138 delete initNative;
1139 napi_create_int32(env, SUCCESS, &result);
1140 return result;
1141 }
1142
testNativeWindowSetColorSpaceNormal(napi_env env,napi_callback_info info)1143 napi_value testNativeWindowSetColorSpaceNormal(napi_env env, napi_callback_info info)
1144 {
1145 napi_value result = nullptr;
1146
1147 int32_t flag;
1148 for (int i = 0; i < sizeof(OH_NativeBuffer_ColorSpace); ++i) {
1149 OH_NativeBuffer_ColorSpace colorspace1 = static_cast<OH_NativeBuffer_ColorSpace>(i);
1150 InitNativeWindow *initNative = new InitNativeWindow();
1151 OHNativeWindow *nativeWindow = nullptr;
1152 nativeWindow = initNative->returnNativeWindow();
1153 if (nativeWindow == nullptr) {
1154 napi_create_int32(env, CONSTANT_998899, &result);
1155 return result;
1156 }
1157 OH_NativeImage *iamge = initNative->returnNativeImage();
1158 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
1159 int fenceFd;
1160 int32_t res = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd);
1161 Region::Rect rect{
1162 .x = 0x100,
1163 .y = 0x100,
1164 .w = 0x100,
1165 .h = 0x100,
1166 };
1167 Region region{.rects = &rect};
1168 res = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, fenceFd, region);
1169 flag = OH_NativeWindow_SetColorSpace(nativeWindow, colorspace1);
1170 if (flag != 0) {
1171 napi_create_int32(env, CONSTANT_1000 * i + CONSTANT_1, &result);
1172 return result;
1173 }
1174 OH_NativeBuffer_ColorSpace colorSpace;
1175 flag = OH_NativeWindow_GetColorSpace(nativeWindow, &colorSpace);
1176 if (flag != 0) {
1177 napi_create_int32(env, CONSTANT_1000 * i + CONSTANT_2, &result);
1178 return result;
1179 }
1180 if (colorSpace != colorspace1) {
1181 napi_create_int32(env, CONSTANT_1000 * i + CONSTANT_3, &result);
1182 return result;
1183 }
1184
1185 delete initNative;
1186 }
1187
1188 napi_create_int32(env, SUCCESS, &result);
1189 return result;
1190 }
1191
1192
testNativeWindowSetColorSpaceNullptr(napi_env env,napi_callback_info info)1193 napi_value testNativeWindowSetColorSpaceNullptr(napi_env env, napi_callback_info info)
1194 {
1195 napi_value result = nullptr;
1196
1197 int32_t flag = OH_NativeWindow_SetColorSpace(nullptr, OH_COLORSPACE_NONE);
1198 if (flag != CONSTANT_40001000) {
1199 napi_create_int32(env, FAIL, &result);
1200 return result;
1201 }
1202
1203 napi_create_int32(env, SUCCESS, &result);
1204 return result;
1205 }
1206
testNativeWindowSetColorSpaceAbnormal(napi_env env,napi_callback_info info)1207 napi_value testNativeWindowSetColorSpaceAbnormal(napi_env env, napi_callback_info info)
1208 {
1209 napi_value result = nullptr;
1210 InitNativeWindow* initNative = new InitNativeWindow();
1211 OHNativeWindow *nativeWindow = nullptr;
1212 nativeWindow = initNative->returnNativeWindow();
1213 if (nativeWindow == nullptr) {
1214 napi_create_int32(env, CONSTANT_998899, &result);
1215 return result;
1216 }
1217 OH_NativeImage *iamge = initNative->returnNativeImage();
1218
1219 int32_t flag =
1220 OH_NativeWindow_SetColorSpace(nativeWindow, static_cast<OH_NativeBuffer_ColorSpace>(CONSTANT_100000));
1221 if (flag != CONSTANT_40001000) {
1222 napi_create_int32(env, FAIL, &result);
1223 return result;
1224 }
1225
1226 delete initNative;
1227 napi_create_int32(env, SUCCESS, &result);
1228 return result;
1229 }
1230
1231
testNativeWindowGetColorSpaceNullptr(napi_env env,napi_callback_info info)1232 napi_value testNativeWindowGetColorSpaceNullptr(napi_env env, napi_callback_info info)
1233 {
1234 napi_value result = nullptr;
1235
1236 int32_t flag;
1237 OH_NativeBuffer_ColorSpace ret;
1238 flag = OH_NativeWindow_GetColorSpace(nullptr, &ret);
1239 if (flag != CONSTANT_40001000) {
1240 napi_create_int32(env, FAIL, &result);
1241 return result;
1242 }
1243
1244 napi_create_int32(env, SUCCESS, &result);
1245 return result;
1246 }
1247
1248
testNativeWindowGetMetadataValueFirst(napi_env env,napi_callback_info info)1249 napi_value testNativeWindowGetMetadataValueFirst(napi_env env, napi_callback_info info)
1250 {
1251 napi_value result = nullptr;
1252
1253 int32_t flag;
1254 InitNativeWindow* initNative = new InitNativeWindow();
1255 OHNativeWindow *nativeWindow = nullptr;
1256 nativeWindow = initNative->returnNativeWindow();
1257 if (nativeWindow == nullptr) {
1258 napi_create_int32(env, CONSTANT_998899, &result);
1259 return result;
1260 }
1261 OH_NativeImage *iamge = initNative->returnNativeImage();
1262 int32_t ret1;
1263 uint8_t *ret2;
1264 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, &ret1, &ret2);
1265 if (flag != CONSTANT_50002000 && flag != CONSTANT_50102000) {
1266 napi_create_int32(env, FAIL, &result);
1267 return result;
1268 }
1269
1270 delete initNative;
1271 napi_create_int32(env, SUCCESS, &result);
1272 return result;
1273 }
1274
testNativeWindowSetDynamicMetadataValue1(napi_env env,napi_callback_info info,OHNativeWindow * nativeWindow)1275 napi_value testNativeWindowSetDynamicMetadataValue1(napi_env env, napi_callback_info info,
1276 OHNativeWindow *nativeWindow)
1277 {
1278 napi_value result = nullptr;
1279 int32_t bufferSize;
1280 uint8_t *buffer;
1281 int32_t X = -1;
1282 uint8_t metaData[CONSTANT_60];
1283 int32_t flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, X, metaData);
1284 if (flag != CONSTANT_40001000) {
1285 napi_create_int32(env, CONSTANT_1000 + CONSTANT_1, &result);
1286 return result;
1287 }
1288 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
1289 if (flag != CONSTANT_50002000 && flag != CONSTANT_50102000) {
1290 napi_create_int32(env, CONSTANT_1000 + CONSTANT_2, &result);
1291 return result;
1292 }
1293 // 2. X=0 set调用失败 get调用失败
1294 X = 0;
1295 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, X, metaData);
1296 if (flag != CONSTANT_40001000) {
1297 napi_create_int32(env, CONSTANT_2 * CONSTANT_1000 + CONSTANT_1, &result);
1298 return result;
1299 }
1300 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
1301 if (flag != CONSTANT_50002000 && flag != CONSTANT_50102000) {
1302 napi_create_int32(env, CONSTANT_2 * CONSTANT_1000 + CONSTANT_2, &result);
1303 return result;
1304 }
1305 return result;
1306 }
1307
testNativeWindowSetDynamicMetadataValue2(napi_env env,napi_callback_info info,OHNativeWindow * nativeWindow)1308 napi_value testNativeWindowSetDynamicMetadataValue2(napi_env env, napi_callback_info info,
1309 OHNativeWindow *nativeWindow)
1310 {
1311 napi_value result = nullptr;
1312 int32_t bufferSize;
1313 uint8_t *buffer;
1314 uint8_t metaData[CONSTANT_60];
1315 int32_t X = 1; // 3. X=1 set调用成功 get调用成功 两者一致
1316 metaData[0] = static_cast<uint8_t>(0);
1317 int32_t flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, X, metaData);
1318 if (flag != 0) {
1319 napi_create_int32(env, CONSTANT_3 * CONSTANT_1000 + CONSTANT_1, &result);
1320 return result;
1321 }
1322 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
1323 if (flag != 0) {
1324 napi_create_int32(env, CONSTANT_3 * CONSTANT_1000 + CONSTANT_2, &result);
1325 return result;
1326 }
1327 if (bufferSize != X) {
1328 napi_create_int32(env, CONSTANT_3 * CONSTANT_1000 + CONSTANT_3, &result);
1329 return result;
1330 }
1331 X = CONSTANT_60; // 4. X=60 set调用成功 get调用成功 两者一致
1332 for (int i = 0; i < X; ++i) {
1333 metaData[i] = static_cast<uint8_t>(i);
1334 }
1335 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, CONSTANT_60, metaData);
1336 if (flag != 0) {
1337 napi_create_int32(env, CONSTANT_4 * CONSTANT_1000 + CONSTANT_1, &result);
1338 return result;
1339 }
1340 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
1341 if (flag != 0) {
1342 napi_create_int32(env, CONSTANT_4 * CONSTANT_1000 + CONSTANT_2, &result);
1343 return result;
1344 }
1345 if (bufferSize != X) {
1346 napi_create_int32(env, CONSTANT_4 * CONSTANT_1000 + CONSTANT_3, &result);
1347 return result;
1348 }
1349 return result;
1350 }
1351
testNativeWindowSetDynamicMetadataValue3(napi_env env,napi_callback_info info,OHNativeWindow * nativeWindow)1352 napi_value testNativeWindowSetDynamicMetadataValue3(napi_env env, napi_callback_info info,
1353 OHNativeWindow *nativeWindow)
1354 {
1355 napi_value result = nullptr;
1356 int32_t bufferSize;
1357 uint8_t *buffer;
1358 uint8_t metaData[CONSTANT_60];
1359 int32_t X = CONSTANT_2999;
1360 int32_t flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, X, metaData);
1361 if (flag != 0) {
1362 napi_create_int32(env, CONSTANT_5 * CONSTANT_1000 + CONSTANT_1, &result);
1363 return result;
1364 }
1365 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
1366 if (flag != 0) {
1367 napi_create_int32(env, CONSTANT_5 * CONSTANT_1000 + CONSTANT_2, &result);
1368 return result;
1369 }
1370 if (bufferSize != X) {
1371 napi_create_int32(env, CONSTANT_5 * CONSTANT_1000 + CONSTANT_3, &result);
1372 return result;
1373 }
1374 X = CONSTANT_3000;
1375 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, X, metaData);
1376 if (flag != 0) {
1377 napi_create_int32(env, CONSTANT_6 * CONSTANT_1000 + CONSTANT_1, &result);
1378 return result;
1379 }
1380 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
1381 if (flag != 0) {
1382 napi_create_int32(env, CONSTANT_6 * CONSTANT_1000 + CONSTANT_2, &result);
1383 return result;
1384 }
1385 if (bufferSize != X) {
1386 napi_create_int32(env, CONSTANT_6 * CONSTANT_1000 + CONSTANT_3, &result);
1387 return result;
1388 }
1389 return result;
1390 }
1391
testNativeWindowSetDynamicMetadataValue4(napi_env env,napi_callback_info info,OHNativeWindow * nativeWindow)1392 napi_value testNativeWindowSetDynamicMetadataValue4(napi_env env, napi_callback_info info,
1393 OHNativeWindow *nativeWindow)
1394 {
1395 napi_value result = nullptr;
1396 int32_t bufferSize;
1397 uint8_t *buffer;
1398 uint8_t metaData[CONSTANT_60];
1399 int32_t X = CONSTANT_3001;
1400 int32_t flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, X, metaData);
1401 if (flag != CONSTANT_40001000) {
1402 napi_create_int32(env, CONSTANT_7 * CONSTANT_1000 + CONSTANT_1, &result);
1403 return result;
1404 }
1405 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
1406 if (flag != 0) {
1407 napi_create_int32(env, CONSTANT_7 * CONSTANT_1000 + CONSTANT_2, &result);
1408 return result;
1409 }
1410 X = CONSTANT_100000000;
1411 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, X, metaData);
1412 if (flag != CONSTANT_40001000) {
1413 napi_create_int32(env, CONSTANT_8 * CONSTANT_1000 + CONSTANT_1, &result);
1414 return result;
1415 }
1416 return result;
1417 }
1418
testNativeWindowSetDynamicMetadataValue(napi_env env,napi_callback_info info)1419 napi_value testNativeWindowSetDynamicMetadataValue(napi_env env, napi_callback_info info)
1420 {
1421 napi_value result = nullptr;
1422 InitNativeWindow* initNative = new InitNativeWindow();
1423 OHNativeWindow *nativeWindow = nullptr;
1424 nativeWindow = initNative->returnNativeWindow();
1425 if (nativeWindow == nullptr) {
1426 napi_create_int32(env, CONSTANT_998899, &result);
1427 return result;
1428 }
1429 OH_NativeImage *iamge = initNative->returnNativeImage();
1430 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
1431 int fenceFd;
1432 int32_t res = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd);
1433 Region::Rect rect{.x = 0x100, .y = 0x100, .w = 0x100, .h = 0x100};
1434 Region region{.rects = &rect};
1435 res = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, fenceFd, region);
1436
1437 result = testNativeWindowSetDynamicMetadataValue1(env, info, nativeWindow);
1438 if (result != nullptr) {
1439 return result;
1440 }
1441 result = testNativeWindowSetDynamicMetadataValue2(env, info, nativeWindow);
1442 if (result != nullptr) {
1443 return result;
1444 }
1445 result = testNativeWindowSetDynamicMetadataValue3(env, info, nativeWindow);
1446 if (result != nullptr) {
1447 return result;
1448 }
1449 result = testNativeWindowSetDynamicMetadataValue4(env, info, nativeWindow);
1450 if (result != nullptr) {
1451 return result;
1452 }
1453
1454 delete initNative;
1455 napi_create_int32(env, SUCCESS, &result);
1456 return result;
1457 }
1458
1459
testNativeWindowSetMetadataValueTimes(napi_env env,napi_callback_info info)1460 napi_value testNativeWindowSetMetadataValueTimes(napi_env env, napi_callback_info info)
1461 {
1462 napi_value result = nullptr;
1463
1464 int32_t flag;
1465 InitNativeWindow* initNative = new InitNativeWindow();
1466 OHNativeWindow *nativeWindow = nullptr;
1467 nativeWindow = initNative->returnNativeWindow();
1468 if (nativeWindow == nullptr) {
1469 napi_create_int32(env, CONSTANT_998899, &result);
1470 return result;
1471 }
1472 OH_NativeImage *iamge = initNative->returnNativeImage();
1473 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
1474 int fenceFd;
1475 int32_t res = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd);
1476 Region::Rect rect{
1477 .x = 0x100,
1478 .y = 0x100,
1479 .w = 0x100,
1480 .h = 0x100,
1481 };
1482 Region region{.rects = &rect};
1483 res = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, fenceFd, region);
1484 int32_t bufferSize;
1485 uint8_t *buffer;
1486 int32_t X = CONSTANT_60;
1487 uint8_t metaData[X];
1488 for (int j = 0; j < X; ++j) {
1489 metaData[j] = static_cast<uint8_t>(j);
1490 }
1491
1492 for (int i = 0; i < CONSTANT_60; ++i) {
1493 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, X, metaData);
1494 if (flag != 0) {
1495 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
1496 return result;
1497 }
1498 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
1499 if (flag != 0) {
1500 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_2, &result);
1501 return result;
1502 }
1503 if (bufferSize != X) {
1504 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_3, &result);
1505 return result;
1506 }
1507 }
1508
1509 delete initNative;
1510 napi_create_int32(env, SUCCESS, &result);
1511 return result;
1512 }
1513
1514
testNativeWindowSetStaticMetadataValue1(napi_env env,napi_callback_info info,OHNativeWindow * nativeWindow)1515 napi_value testNativeWindowSetStaticMetadataValue1(napi_env env, napi_callback_info info,
1516 OHNativeWindow *nativeWindow)
1517 {
1518 napi_value result = nullptr;
1519 int32_t bufferSize;
1520 uint8_t *buffer;
1521 uint8_t metaData[CONSTANT_60];
1522 // 1.
1523 int32_t X = -1;
1524 int32_t flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, X, metaData);
1525 if (flag != CONSTANT_40001000) {
1526 napi_create_int32(env, CONSTANT_1000 + CONSTANT_1, &result);
1527 return result;
1528 }
1529 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1530 if (flag != CONSTANT_50002000 && flag != CONSTANT_50102000) {
1531 napi_create_int32(env, CONSTANT_1000 + CONSTANT_2, &result);
1532 return result;
1533 }
1534 // 2. X=0 set调用失败 get调用失败
1535 X = 0;
1536 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, X, metaData);
1537 if (flag != CONSTANT_40001000) {
1538 napi_create_int32(env, CONSTANT_2 * CONSTANT_1000 + CONSTANT_1, &result);
1539 return result;
1540 }
1541 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1542 if (flag != CONSTANT_50002000 && flag != CONSTANT_50102000) {
1543 napi_create_int32(env, CONSTANT_2 * CONSTANT_1000 + CONSTANT_2, &result);
1544 return result;
1545 }
1546 return result;
1547 }
1548
1549
testNativeWindowSetStaticMetadataValue2(napi_env env,napi_callback_info info,OHNativeWindow * nativeWindow)1550 napi_value testNativeWindowSetStaticMetadataValue2(napi_env env, napi_callback_info info,
1551 OHNativeWindow *nativeWindow)
1552 {
1553 napi_value result = nullptr;
1554 int32_t bufferSize;
1555 uint8_t *buffer;
1556 uint8_t metaData[CONSTANT_60];
1557 int32_t X = 1; // 3. X=1 set调用成功 get调用成功 两者一致
1558 metaData[0] = static_cast<uint8_t>(0);
1559 int32_t flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, X, metaData);
1560 if (flag != 0) {
1561 napi_create_int32(env, CONSTANT_3 * CONSTANT_1000 + CONSTANT_1, &result);
1562 return result;
1563 }
1564 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1565 if (flag != 0) {
1566 napi_create_int32(env, CONSTANT_3 * CONSTANT_1000 + CONSTANT_2, &result);
1567 return result;
1568 }
1569 if (bufferSize != X) {
1570 napi_create_int32(env, CONSTANT_3 * CONSTANT_1000 + CONSTANT_3, &result);
1571 return result;
1572 }
1573 X = CONSTANT_60; // 4.
1574 for (int i = 0; i < X; ++i) {
1575 metaData[i] = static_cast<uint8_t>(i);
1576 }
1577 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, CONSTANT_60, metaData);
1578 if (flag != 0) {
1579 napi_create_int32(env, CONSTANT_4 * CONSTANT_1000 + CONSTANT_1, &result);
1580 return result;
1581 }
1582 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1583 if (flag != 0) {
1584 napi_create_int32(env, CONSTANT_4 * CONSTANT_1000 + CONSTANT_2, &result);
1585 return result;
1586 }
1587 if (bufferSize != X) {
1588 napi_create_int32(env, CONSTANT_4 * CONSTANT_1000 + CONSTANT_3, &result);
1589 return result;
1590 }
1591 return result;
1592 }
1593
testNativeWindowSetStaticMetadataValue3(napi_env env,napi_callback_info info,OHNativeWindow * nativeWindow)1594 napi_value testNativeWindowSetStaticMetadataValue3(napi_env env, napi_callback_info info,
1595 OHNativeWindow *nativeWindow)
1596 {
1597 napi_value result = nullptr;
1598 int32_t bufferSize;
1599 uint8_t *buffer;
1600 uint8_t metaData[CONSTANT_60];
1601
1602 int32_t X = CONSTANT_2999;
1603 int32_t flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, X, metaData);
1604 if (flag != 0) {
1605 napi_create_int32(env, CONSTANT_5 * CONSTANT_1000 + CONSTANT_1, &result);
1606 return result;
1607 }
1608 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1609 if (flag != 0) {
1610 napi_create_int32(env, CONSTANT_5 * CONSTANT_1000 + CONSTANT_2, &result);
1611 return result;
1612 }
1613 if (bufferSize != X) {
1614 napi_create_int32(env, CONSTANT_5 * CONSTANT_1000 + CONSTANT_3, &result);
1615 return result;
1616 }
1617 X = CONSTANT_3000;
1618 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, X, metaData);
1619 if (flag != 0) {
1620 napi_create_int32(env, CONSTANT_6 * CONSTANT_1000 + CONSTANT_1, &result);
1621 return result;
1622 }
1623 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1624 if (flag != 0) {
1625 napi_create_int32(env, CONSTANT_6 * CONSTANT_1000 + CONSTANT_2, &result);
1626 return result;
1627 }
1628 if (bufferSize != X) {
1629 napi_create_int32(env, CONSTANT_6 * CONSTANT_1000 + CONSTANT_3, &result);
1630 return result;
1631 }
1632 return result;
1633 }
1634
testNativeWindowSetStaticMetadataValue4(napi_env env,napi_callback_info info,OHNativeWindow * nativeWindow)1635 napi_value testNativeWindowSetStaticMetadataValue4(napi_env env, napi_callback_info info,
1636 OHNativeWindow *nativeWindow)
1637 {
1638 napi_value result = nullptr;
1639 int32_t bufferSize;
1640 uint8_t *buffer;
1641 uint8_t metaData[CONSTANT_60];
1642 int32_t X = CONSTANT_3001;
1643 int32_t flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, X, buffer);
1644 if (flag != CONSTANT_40001000) {
1645 napi_create_int32(env, CONSTANT_7 * CONSTANT_1000 + CONSTANT_1, &result);
1646 return result;
1647 }
1648 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1649 if (flag != 0) {
1650 napi_create_int32(env, CONSTANT_7 * CONSTANT_1000 + CONSTANT_2, &result);
1651 return result;
1652 }
1653 X = CONSTANT_100000000;
1654 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_STATIC_METADATA, X, metaData);
1655 if (flag != CONSTANT_40001000) {
1656 napi_create_int32(env, CONSTANT_8 * CONSTANT_1000 + CONSTANT_1, &result);
1657 return result;
1658 }
1659 return result;
1660 }
1661
testNativeWindowSetStaticMetadataValue(napi_env env,napi_callback_info info)1662 napi_value testNativeWindowSetStaticMetadataValue(napi_env env, napi_callback_info info)
1663 {
1664 napi_value result = nullptr;
1665 InitNativeWindow* initNative = new InitNativeWindow();
1666 OHNativeWindow *nativeWindow = nullptr;
1667 nativeWindow = initNative->returnNativeWindow();
1668 if (nativeWindow == nullptr) {
1669 napi_create_int32(env, CONSTANT_998899, &result);
1670 return result;
1671 }
1672 OH_NativeImage *iamge = initNative->returnNativeImage();
1673 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
1674 int fenceFd;
1675 int32_t res = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd);
1676 Region::Rect rect{.x = 0x100, .y = 0x100, .w = 0x100, .h = 0x100};
1677 Region region{.rects = &rect};
1678 res = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, fenceFd, region);
1679
1680 result = testNativeWindowSetStaticMetadataValue1(env, info, nativeWindow);
1681 if (result != nullptr) {
1682 return result;
1683 }
1684 result = testNativeWindowSetStaticMetadataValue2(env, info, nativeWindow);
1685 if (result != nullptr) {
1686 return result;
1687 }
1688 result = testNativeWindowSetStaticMetadataValue3(env, info, nativeWindow);
1689 if (result != nullptr) {
1690 return result;
1691 }
1692 result = testNativeWindowSetStaticMetadataValue4(env, info, nativeWindow);
1693 if (result != nullptr) {
1694 return result;
1695 }
1696
1697 delete initNative;
1698 napi_create_int32(env, SUCCESS, &result);
1699 return result;
1700 }
1701
testNativeWindowSetMetadataValue1(napi_env env,napi_callback_info info,OHNativeWindow * nativeWindow)1702 napi_value testNativeWindowSetMetadataValue1(napi_env env, napi_callback_info info, OHNativeWindow *nativeWindow)
1703 {
1704 napi_value result = nullptr;
1705 int32_t flag;
1706 int32_t bufferSize;
1707 uint8_t *buffer;
1708 int32_t X = -1;
1709 uint8_t metaData[CONSTANT_60];
1710 // 1.
1711 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, X, metaData);
1712 if (flag != CONSTANT_40001000) {
1713 napi_create_int32(env, CONSTANT_1000 + CONSTANT_1, &result);
1714 return result;
1715 }
1716 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1717 if (flag != CONSTANT_50002000 && flag != CONSTANT_50102000) {
1718 napi_create_int32(env, CONSTANT_1000 + CONSTANT_2, &result);
1719 return result;
1720 }
1721 // 2. X=0 set调用失败 get调用失败
1722 X = 0;
1723 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, X, metaData);
1724 if (flag != CONSTANT_40001000) {
1725 napi_create_int32(env, CONSTANT_2 * CONSTANT_1000 + CONSTANT_1, &result);
1726 return result;
1727 }
1728 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1729 if (flag != CONSTANT_50002000 && flag != CONSTANT_50102000) {
1730 napi_create_int32(env, CONSTANT_2 * CONSTANT_1000 + CONSTANT_2, &result);
1731 return result;
1732 }
1733 return result;
1734 }
1735
testNativeWindowSetMetadataValue2(napi_env env,napi_callback_info info,OHNativeWindow * nativeWindow)1736 napi_value testNativeWindowSetMetadataValue2(napi_env env, napi_callback_info info, OHNativeWindow *nativeWindow)
1737 {
1738 napi_value result = nullptr;
1739 int32_t bufferSize;
1740 uint8_t *buffer;
1741 int32_t X = 1; // 3. X=1 set调用成功 get调用成功 两者一致
1742 uint8_t metaData[CONSTANT_60];
1743 metaData[0] = static_cast<uint8_t>(X);
1744 int32_t flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, X, metaData);
1745 if (flag != 0) {
1746 napi_create_int32(env, CONSTANT_3 * CONSTANT_1000 + CONSTANT_1, &result);
1747 return result;
1748 }
1749 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1750 if (flag != 0) {
1751 napi_create_int32(env, CONSTANT_3 * CONSTANT_1000 + CONSTANT_2, &result);
1752 return result;
1753 }
1754 if (bufferSize != CONSTANT_4) {
1755 napi_create_int32(env, CONSTANT_3 * CONSTANT_1000 + CONSTANT_3, &result);
1756 return result;
1757 }
1758 X = CONSTANT_4; // 4. X=60 set调用成功 get调用成功 两者一致
1759 for (int i = 0; i < X; ++i) {
1760 metaData[i] = static_cast<uint8_t>(i);
1761 }
1762 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, X, metaData);
1763 if (flag != 0) {
1764 napi_create_int32(env, CONSTANT_4 * CONSTANT_1000 + CONSTANT_1, &result);
1765 return result;
1766 }
1767 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1768 if (flag != 0) {
1769 napi_create_int32(env, CONSTANT_4 * CONSTANT_1000 + CONSTANT_2, &result);
1770 return result;
1771 }
1772 if (bufferSize != CONSTANT_4) {
1773 napi_create_int32(env, CONSTANT_4 * CONSTANT_1000 + CONSTANT_3, &result);
1774 return result;
1775 }
1776 return result;
1777 }
1778
testNativeWindowSetMetadataValue3(napi_env env,napi_callback_info info,OHNativeWindow * nativeWindow)1779 napi_value testNativeWindowSetMetadataValue3(napi_env env, napi_callback_info info, OHNativeWindow *nativeWindow)
1780 {
1781 napi_value result = nullptr;
1782 int32_t flag;
1783 int32_t bufferSize;
1784 uint8_t *buffer;
1785 int32_t X = -1;
1786 uint8_t metaData[CONSTANT_60];
1787 // 5. X=2999 set调用成功 get调用成功 两者一致
1788 X = CONSTANT_2999;
1789 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, X, metaData);
1790 if (flag != 0) {
1791 napi_create_int32(env, CONSTANT_5 * CONSTANT_1000 + CONSTANT_1, &result);
1792 return result;
1793 }
1794 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1795 if (flag != 0) {
1796 napi_create_int32(env, CONSTANT_5 * CONSTANT_1000 + CONSTANT_2, &result);
1797 return result;
1798 }
1799 if (bufferSize != CONSTANT_4) {
1800 napi_create_int32(env, CONSTANT_5 * CONSTANT_1000 + CONSTANT_3, &result);
1801 return result;
1802 }
1803 // 6. X=3000 set调用成功 get调用成功 两者一致
1804 X = CONSTANT_3000;
1805 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, X, metaData);
1806 if (flag != 0) {
1807 napi_create_int32(env, CONSTANT_6 * CONSTANT_1000 + CONSTANT_1, &result);
1808 return result;
1809 }
1810 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1811 if (flag != 0) {
1812 napi_create_int32(env, CONSTANT_6 * CONSTANT_1000 + CONSTANT_2, &result);
1813 return result;
1814 }
1815 if (bufferSize != CONSTANT_4) {
1816 napi_create_int32(env, CONSTANT_6 * CONSTANT_1000 + CONSTANT_3, &result);
1817 return result;
1818 }
1819 return result;
1820 }
1821
testNativeWindowSetMetadataValue4(napi_env env,napi_callback_info info,OHNativeWindow * nativeWindow)1822 napi_value testNativeWindowSetMetadataValue4(napi_env env, napi_callback_info info, OHNativeWindow *nativeWindow)
1823 {
1824 napi_value result = nullptr;
1825 int32_t flag;
1826 int32_t bufferSize;
1827 uint8_t *buffer;
1828 int32_t X = -1;
1829 uint8_t metaData[CONSTANT_60];
1830 // 7.
1831 X = CONSTANT_3001;
1832 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, X, metaData);
1833 if (flag != CONSTANT_40001000) {
1834 napi_create_int32(env, CONSTANT_7 * CONSTANT_1000 + CONSTANT_1, &result);
1835 return result;
1836 }
1837 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1838 if (flag != 0) {
1839 napi_create_int32(env, CONSTANT_7 * CONSTANT_1000 + CONSTANT_2, &result);
1840 return result;
1841 }
1842 // 8. X=100000000 set调用失败 get调用失败
1843 X = CONSTANT_100000000;
1844 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, X, metaData);
1845 if (flag != CONSTANT_40001000) {
1846 napi_create_int32(env, CONSTANT_8 * CONSTANT_1000 + CONSTANT_1, &result);
1847 return result;
1848 }
1849 return result;
1850 }
1851
testNativeWindowSetMetadataValue(napi_env env,napi_callback_info info)1852 napi_value testNativeWindowSetMetadataValue(napi_env env, napi_callback_info info)
1853 {
1854 napi_value result = nullptr;
1855 InitNativeWindow* initNative = new InitNativeWindow();
1856 OHNativeWindow *nativeWindow = nullptr;
1857 nativeWindow = initNative->returnNativeWindow();
1858 if (nativeWindow == nullptr) {
1859 napi_create_int32(env, CONSTANT_998899, &result);
1860 return result;
1861 }
1862 OH_NativeImage *iamge = initNative->returnNativeImage();
1863 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
1864 int fenceFd;
1865 int32_t flag = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd);
1866 Region::Rect rect{.x = 0x100, .y = 0x100, .w = 0x100, .h = 0x100};
1867 Region region{.rects = &rect};
1868 flag = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, fenceFd, region);
1869
1870 result = testNativeWindowSetMetadataValue1(env, info, nativeWindow);
1871 if (result != nullptr) {
1872 return result;
1873 }
1874 result = testNativeWindowSetMetadataValue2(env, info, nativeWindow);
1875 if (result != nullptr) {
1876 return result;
1877 }
1878 result = testNativeWindowSetMetadataValue3(env, info, nativeWindow);
1879 if (result != nullptr) {
1880 return result;
1881 }
1882 result = testNativeWindowSetMetadataValue4(env, info, nativeWindow);
1883 if (result != nullptr) {
1884 return result;
1885 }
1886
1887 delete initNative;
1888 napi_create_int32(env, SUCCESS, &result);
1889 return result;
1890 }
1891
testNativeWindowSetNullMetadataValue(napi_env env,napi_callback_info info)1892 napi_value testNativeWindowSetNullMetadataValue(napi_env env, napi_callback_info info)
1893 {
1894 napi_value result = nullptr;
1895
1896 int32_t flag;
1897 InitNativeWindow* initNative = new InitNativeWindow();
1898 OHNativeWindow *nativeWindow = nullptr;
1899 nativeWindow = initNative->returnNativeWindow();
1900 if (nativeWindow == nullptr) {
1901 napi_create_int32(env, CONSTANT_998899, &result);
1902 return result;
1903 }
1904 OH_NativeImage *iamge = initNative->returnNativeImage();
1905 uint8_t *buffer = new uint8_t[CONSTANT_60];
1906 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, static_cast<OH_NativeBuffer_MetadataKey>(CONSTANT_1000000),
1907 CONSTANT_60, buffer);
1908 if (flag != CONSTANT_50002000 && flag != CONSTANT_50102000) {
1909 napi_create_int32(env, FAIL, &result);
1910 return result;
1911 }
1912
1913 delete initNative;
1914 napi_create_int32(env, SUCCESS, &result);
1915 return result;
1916 }
1917
1918
testNativeWindowSetMetadataValueNullptr(napi_env env,napi_callback_info info)1919 napi_value testNativeWindowSetMetadataValueNullptr(napi_env env, napi_callback_info info)
1920 {
1921 napi_value result = nullptr;
1922
1923 int32_t flag;
1924 InitNativeWindow* initNative = new InitNativeWindow();
1925 OHNativeWindow *nativeWindow = nullptr;
1926 nativeWindow = initNative->returnNativeWindow();
1927 if (nativeWindow == nullptr) {
1928 napi_create_int32(env, CONSTANT_998899, &result);
1929 return result;
1930 }
1931 OH_NativeImage *iamge = initNative->returnNativeImage();
1932 uint8_t *buffer = new uint8_t[CONSTANT_60];
1933 flag = OH_NativeWindow_SetMetadataValue(nullptr, OH_HDR_DYNAMIC_METADATA, CONSTANT_60, buffer);
1934 if (flag != CONSTANT_40001000) {
1935 napi_create_int32(env, 1, &result);
1936 return result;
1937 }
1938 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, CONSTANT_60, nullptr);
1939 if (flag != CONSTANT_40001000) {
1940 napi_create_int32(env, 1, &result);
1941 return result;
1942 }
1943
1944 delete initNative;
1945 napi_create_int32(env, SUCCESS, &result);
1946 return result;
1947 }
1948
1949
testNativeWindowGetMetadataValueAbnormal(napi_env env,napi_callback_info info)1950 napi_value testNativeWindowGetMetadataValueAbnormal(napi_env env, napi_callback_info info)
1951 {
1952 napi_value result = nullptr;
1953
1954 int32_t flag;
1955 InitNativeWindow* initNative = new InitNativeWindow();
1956 OHNativeWindow *nativeWindow = nullptr;
1957 nativeWindow = initNative->returnNativeWindow();
1958 if (nativeWindow == nullptr) {
1959 napi_create_int32(env, CONSTANT_998899, &result);
1960 return result;
1961 }
1962 OH_NativeImage *iamge = initNative->returnNativeImage();
1963 uint8_t *buffer = new uint8_t[CONSTANT_60];
1964 flag = OH_NativeWindow_SetMetadataValue(nullptr, OH_HDR_DYNAMIC_METADATA, CONSTANT_60, buffer);
1965 if (flag != CONSTANT_40001000) {
1966 napi_create_int32(env, 1, &result);
1967 return result;
1968 }
1969 flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_DYNAMIC_METADATA, CONSTANT_60, nullptr);
1970 if (flag != CONSTANT_40001000) {
1971 napi_create_int32(env, 1, &result);
1972 return result;
1973 }
1974
1975 delete initNative;
1976 napi_create_int32(env, SUCCESS, &result);
1977 return result;
1978 }
1979
testNativeWindowGetMetadataValueNullptr(napi_env env,napi_callback_info info)1980 napi_value testNativeWindowGetMetadataValueNullptr(napi_env env, napi_callback_info info)
1981 {
1982 napi_value result = nullptr;
1983
1984 int32_t flag;
1985 InitNativeWindow* initNative = new InitNativeWindow();
1986 OHNativeWindow *nativeWindow = nullptr;
1987 nativeWindow = initNative->returnNativeWindow();
1988 if (nativeWindow == nullptr) {
1989 napi_create_int32(env, CONSTANT_998899, &result);
1990 return result;
1991 }
1992 OH_NativeImage *iamge = initNative->returnNativeImage();
1993 uint8_t *buffer = new uint8_t[CONSTANT_60];
1994 int32_t ret1;
1995 uint8_t *ret2;
1996 // 1.
1997 flag = OH_NativeWindow_SetMetadataValue(nullptr, OH_HDR_DYNAMIC_METADATA, CONSTANT_60, buffer);
1998 if (flag != CONSTANT_40001000) {
1999 napi_create_int32(env, CONSTANT_1, &result);
2000 return result;
2001 }
2002 // 2.
2003 flag = OH_NativeWindow_GetMetadataValue(nullptr, OH_HDR_DYNAMIC_METADATA, &ret1, nullptr);
2004 if (flag != CONSTANT_40001000) {
2005 napi_create_int32(env, CONSTANT_2, &result);
2006 return result;
2007 }
2008 // 3.
2009 flag = OH_NativeWindow_GetMetadataValue(nullptr, OH_HDR_DYNAMIC_METADATA, nullptr, &ret2);
2010 if (flag != CONSTANT_40001000) {
2011 napi_create_int32(env, CONSTANT_3, &result);
2012 return result;
2013 }
2014 // 4.
2015 flag = OH_NativeWindow_GetMetadataValue(nullptr, OH_HDR_DYNAMIC_METADATA, &ret1, &ret2);
2016 if (flag != CONSTANT_40001000) {
2017 napi_create_int32(env, CONSTANT_4, &result);
2018 return result;
2019 }
2020 delete[] buffer;
2021
2022 delete initNative;
2023 napi_create_int32(env, SUCCESS, &result);
2024 return result;
2025 }
2026
testNativeWindowNativeWindowHandleOptSetDesiredPresentTimeStampNormal(napi_env env,napi_callback_info info)2027 napi_value testNativeWindowNativeWindowHandleOptSetDesiredPresentTimeStampNormal(napi_env env,
2028 napi_callback_info info)
2029 {
2030 napi_value result = nullptr;
2031 int32_t flag;
2032 InitNativeWindow* initNative = new InitNativeWindow();
2033 OHNativeWindow *nativeWindow = nullptr;
2034 nativeWindow = initNative->returnNativeWindow();
2035 if (nativeWindow == nullptr) {
2036 napi_create_int32(env, CONSTANT_998899, &result);
2037 return result;
2038 }
2039 OH_NativeImage *iamge = initNative->returnNativeImage();
2040 uint64_t arr[] = {CONSTANT_1, CONSTANT_1000, CONSTANT_1000000000, 1ULL << 63, CONSTANT_999999999999999999};
2041 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
2042 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_DESIRED_PRESENT_TIMESTAMP, arr[i]);
2043 if (flag != 0) {
2044 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
2045 return result;
2046 }
2047 }
2048
2049 delete initNative;
2050 napi_create_int32(env, SUCCESS, &result);
2051 return result;
2052 }
2053
testNativeWindowNativeWindowHandleOptSetDesiredPresentTimeStampAbNormal(napi_env env,napi_callback_info info)2054 napi_value testNativeWindowNativeWindowHandleOptSetDesiredPresentTimeStampAbNormal(napi_env env,
2055 napi_callback_info info)
2056 {
2057 napi_value result = nullptr;
2058 int32_t flag;
2059 InitNativeWindow* initNative = new InitNativeWindow();
2060 OHNativeWindow *nativeWindow = nullptr;
2061 nativeWindow = initNative->returnNativeWindow();
2062 if (nativeWindow == nullptr) {
2063 napi_create_int32(env, CONSTANT_998899, &result);
2064 return result;
2065 }
2066 OH_NativeImage *iamge = initNative->returnNativeImage();
2067 int64_t arr[] = {CONSTANT_0, -CONSTANT_1, -CONSTANT_1000, -CONSTANT_1000000, CONSTANT_NEG_9223372036854775807};
2068 for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
2069 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_DESIRED_PRESENT_TIMESTAMP, arr[i]);
2070 if (flag != 0) {
2071 napi_create_int32(env, CONSTANT_1000 * (i + 1) + CONSTANT_1, &result);
2072 return result;
2073 }
2074 }
2075 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_DESIRED_PRESENT_TIMESTAMP, "sdasda213!");
2076 if (flag != 0) {
2077 napi_create_int32(env, CONSTANT_100000 + CONSTANT_1, &result);
2078 return result;
2079 }
2080 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_DESIRED_PRESENT_TIMESTAMP, NULL);
2081 if (flag != 0) {
2082 napi_create_int32(env, CONSTANT_2 * CONSTANT_100000 + CONSTANT_1, &result);
2083 return result;
2084 }
2085 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_DESIRED_PRESENT_TIMESTAMP);
2086 if (flag != 0) {
2087 napi_create_int32(env, CONSTANT_3 * CONSTANT_100000 + CONSTANT_1, &result);
2088 return result;
2089 }
2090
2091 delete initNative;
2092 napi_create_int32(env, SUCCESS, &result);
2093 return result;
2094 }
2095
testNativeWindowSetMetadataValue_metadata_type(napi_env env,napi_callback_info info)2096 napi_value testNativeWindowSetMetadataValue_metadata_type(napi_env env, napi_callback_info info)
2097 {
2098 napi_value result = nullptr;
2099 InitNativeWindow* initNative = new InitNativeWindow();
2100 OHNativeWindow *nativeWindow = nullptr;
2101 nativeWindow = initNative->returnNativeWindow();
2102 if (nativeWindow == nullptr) {
2103 napi_create_int32(env, CONSTANT_998899, &result);
2104 return result;
2105 }
2106 OH_NativeImage *iamge = initNative->returnNativeImage();
2107 OH_NativeBuffer_MetadataType hdr_type[] = {OH_VIDEO_HDR_HLG, OH_VIDEO_HDR_HDR10, OH_VIDEO_HDR_VIVID, OH_VIDEO_NONE};
2108 for (int i = 0; i <= sizeof(hdr_type) / sizeof(hdr_type[0]); i++) {
2109 int32_t bufferSize;
2110 uint8_t *buffer;
2111 uint8_t val = hdr_type[i];
2112 int32_t flag = OH_NativeWindow_SetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, sizeof(uint8_t), &val);
2113 if (flag != SUCCESS) {
2114 napi_create_int32(env, CONSTANT_1000 * i + CONSTANT_1, &result);
2115 return result;
2116 }
2117 flag = OH_NativeWindow_GetMetadataValue(nativeWindow, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
2118 if (*buffer != val) {
2119 napi_create_int32(env, CONSTANT_1000 * i + CONSTANT_2, &result);
2120 return result;
2121 }
2122 }
2123
2124 delete initNative;
2125 napi_create_int32(env, SUCCESS, &result);
2126 return result;
2127 }