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