1 //
2 // Copyright (c) 2022 The Khronos Group Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //    http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 #include "../testBase.h"
17 #include "../common.h"
18 #include "test_cl_ext_image_buffer.hpp"
19 
20 /**
21  * Negative tests for {CL_IMAGE_REQUIREMENTS_SIZE_EXT}
22  * Check that attempting to perform the {CL_IMAGE_REQUIREMENTS_SIZE_EXT} query
23  *  without specifying the _image_format_ results in {CL_INVALID_VALUE} being
24  * returned. Check that attempting to perform the
25  * {CL_IMAGE_REQUIREMENTS_SIZE_EXT} query without specifying the _image_desc_
26  * results in {CL_INVALID_VALUE} being returned.
27  */
cl_image_requirements_size_ext_negative(cl_device_id device,cl_context context,cl_command_queue queue)28 int cl_image_requirements_size_ext_negative(cl_device_id device,
29                                             cl_context context,
30                                             cl_command_queue queue)
31 {
32     if (!is_extension_available(device, "cl_ext_image_requirements_info"))
33     {
34         log_info("Extension cl_ext_image_requirements_info not available\n");
35         return TEST_SKIPPED_ITSELF;
36     }
37 
38     cl_platform_id platform = getPlatformFromDevice(device);
39     GET_EXTENSION_FUNC(platform, clGetImageRequirementsInfoEXT);
40 
41     size_t max_size = 0;
42     size_t param_val_size = 0;
43 
44     cl_image_desc image_desc = { 0 };
45     image_desc_init(&image_desc, CL_MEM_OBJECT_IMAGE2D);
46 
47     cl_image_format format = { CL_RGBA, CL_UNSIGNED_INT16 };
48 
49     /* Check image_format null results in CL_INVALID_VALUE */
50     cl_int err = clGetImageRequirementsInfoEXT(
51         context, nullptr, CL_MEM_READ_WRITE, nullptr, &image_desc,
52         CL_IMAGE_REQUIREMENTS_SIZE_EXT, sizeof(max_size), &max_size,
53         &param_val_size);
54     test_failure_error(err, CL_INVALID_VALUE,
55                        "Unexpected clGetImageRequirementsInfoEXT return");
56 
57     /* Check image_desc null results in CL_INVALID_VALUE */
58     err = clGetImageRequirementsInfoEXT(
59         context, nullptr, CL_MEM_READ_WRITE, &format, nullptr,
60         CL_IMAGE_REQUIREMENTS_SIZE_EXT, sizeof(max_size), &max_size,
61         &param_val_size);
62     test_failure_error(err, CL_INVALID_VALUE,
63                        "Unexpected clGetImageRequirementsInfoEXT return");
64 
65     return TEST_PASS;
66 }
67 
68 /**
69  * Consistency checks for CL_IMAGE_REQUIREMENTS_SIZE_EXT
70  * When creating 2D images from a buffer is supported
71  * Check that the CL_IMAGE_REQUIREMENTS_SIZE_EXT query can be performed
72  * successfully. Create a buffer with the size returned and check that an image
73  * can successfully be created from the buffer. Check that the value returned
74  * for CL_MEM_SIZE for the image is the same as the value returned for
75  * CL_IMAGE_REQUIREMENTS_SIZE_EXT.
76  */
cl_image_requirements_size_ext_consistency(cl_device_id device,cl_context context,cl_command_queue queue)77 int cl_image_requirements_size_ext_consistency(cl_device_id device,
78                                                cl_context context,
79                                                cl_command_queue queue)
80 {
81     if (!is_extension_available(device, "cl_ext_image_requirements_info"))
82     {
83         log_info("Extension cl_ext_image_requirements_info not available\n");
84         return TEST_SKIPPED_ITSELF;
85     }
86 
87     if (!is_extension_available(device, "cl_ext_image_from_buffer"))
88     {
89         log_info("Extension cl_ext_image_from_buffer not available\n");
90         return TEST_SKIPPED_ITSELF;
91     }
92 
93     cl_platform_id platform = getPlatformFromDevice(device);
94     GET_EXTENSION_FUNC(platform, clGetImageRequirementsInfoEXT);
95 
96     size_t max_size = 0;
97     size_t param_val_size = 0;
98 
99     std::vector<cl_mem_object_type> imageTypes{
100         CL_MEM_OBJECT_IMAGE1D,       CL_MEM_OBJECT_IMAGE2D,
101         CL_MEM_OBJECT_IMAGE3D,       CL_MEM_OBJECT_IMAGE1D_BUFFER,
102         CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY
103     };
104 
105     std::vector<cl_mem_flags> flagTypes{ CL_MEM_READ_ONLY, CL_MEM_WRITE_ONLY,
106                                          CL_MEM_READ_WRITE,
107                                          CL_MEM_KERNEL_READ_AND_WRITE };
108 
109     for (auto flag : flagTypes)
110     {
111         for (auto imageType : imageTypes)
112         {
113             /* Get the list of supported image formats */
114             std::vector<cl_image_format> formatList;
115             if (TEST_PASS
116                     != get_format_list(context, imageType, formatList, flag)
117                 || formatList.size() == 0)
118             {
119                 test_fail("Failure to get supported formats list\n");
120             }
121 
122             for (auto format : formatList)
123             {
124                 cl_image_desc image_desc = { 0 };
125                 image_desc_init(&image_desc, imageType);
126 
127                 flag = (flag == CL_MEM_KERNEL_READ_AND_WRITE)
128                     ? CL_MEM_READ_WRITE
129                     : flag;
130 
131                 cl_int err = clGetImageRequirementsInfoEXT(
132                     context, nullptr, flag, &format, &image_desc,
133                     CL_IMAGE_REQUIREMENTS_SIZE_EXT, sizeof(max_size), &max_size,
134                     &param_val_size);
135                 test_error(err, "Error clGetImageRequirementsInfoEXT");
136 
137                 /* Create buffer */
138                 cl_mem buffer =
139                     clCreateBuffer(context, flag, max_size, nullptr, &err);
140                 test_error(err, "Unable to create buffer");
141 
142                 image_desc.buffer = buffer;
143 
144                 /* 2D Image from buffer */
145                 cl_mem image_buffer = clCreateImage(context, flag, &format,
146                                                     &image_desc, nullptr, &err);
147                 test_error(err, "Unable to create image");
148 
149                 size_t size = 0;
150                 err = clGetMemObjectInfo(image_buffer, CL_MEM_SIZE,
151                                          sizeof(size_t), &size, NULL);
152                 test_error(err, "Error clGetMemObjectInfo");
153 
154                 if (max_size != size)
155                 {
156                     test_fail("CL_IMAGE_REQUIREMENTS_SIZE_EXT different from "
157                               "CL_MEM_SIZE\n");
158                 }
159 
160                 err = clReleaseMemObject(image_buffer);
161                 test_error(err, "Error clReleaseMemObject");
162 
163                 err = clReleaseMemObject(buffer);
164                 test_error(err, "Error clReleaseMemObject");
165             }
166         }
167     }
168 
169     return TEST_PASS;
170 }
171 
172 /**
173  * Negative testing for all testable error codes returned by
174  * clGetImageFormatInfoKHR
175  */
clGetImageRequirementsInfoEXT_negative(cl_device_id device,cl_context context,cl_command_queue queue)176 int clGetImageRequirementsInfoEXT_negative(cl_device_id device,
177                                            cl_context context,
178                                            cl_command_queue queue)
179 {
180     if (!is_extension_available(device, "cl_ext_image_requirements_info"))
181     {
182         log_info("Extension cl_ext_image_requirements_info not available\n");
183         return TEST_SKIPPED_ITSELF;
184     }
185 
186     cl_platform_id platform = getPlatformFromDevice(device);
187     GET_EXTENSION_FUNC(platform, clGetImageRequirementsInfoEXT);
188 
189     cl_image_desc image_desc = { 0 };
190     image_desc_init(&image_desc, CL_MEM_OBJECT_IMAGE3D);
191 
192     cl_image_format format = { CL_RGBA, CL_UNSIGNED_INT16 };
193 
194     /* Check that CL_INVALID_CONTEXT is returned when passing nullptr as context
195      */
196     size_t row_pitch_alignment = 0;
197     cl_int err = clGetImageRequirementsInfoEXT(
198         nullptr, nullptr, CL_MEM_READ_WRITE, &format, &image_desc,
199         CL_IMAGE_REQUIREMENTS_ROW_PITCH_ALIGNMENT_EXT,
200         sizeof(row_pitch_alignment), &row_pitch_alignment, nullptr);
201     test_failure_error(err, CL_INVALID_CONTEXT,
202                        "Unexpected clGetImageRequirementsInfoEXT return");
203 
204     /* Check that CL_INVALID_VALUE is returned when passing an invalid
205      * image_type */
206     cl_image_desc invalid_desc = { CL_MEM_OBJECT_BUFFER, TEST_IMAGE_SIZE };
207     err = clGetImageRequirementsInfoEXT(
208         context, nullptr, CL_MEM_READ_WRITE, &format, &invalid_desc,
209         CL_IMAGE_REQUIREMENTS_ROW_PITCH_ALIGNMENT_EXT,
210         sizeof(row_pitch_alignment), &row_pitch_alignment, nullptr);
211     test_failure_error(err, CL_INVALID_IMAGE_DESCRIPTOR,
212                        "Unexpected clGetImageRequirementsInfoEXT return");
213 
214     /* Check that CL_INVALID_VALUE is returned when passing invalid flags */
215     err = clGetImageRequirementsInfoEXT(
216         context, nullptr, -1, &format, &image_desc,
217         CL_IMAGE_REQUIREMENTS_ROW_PITCH_ALIGNMENT_EXT,
218         sizeof(row_pitch_alignment), &row_pitch_alignment, nullptr);
219     test_failure_error(err, CL_INVALID_VALUE,
220                        "Unexpected clGetImageRequirementsInfoEXT return");
221 
222     /* Check that CL_INVALID_IMAGE_FORMAT_DESCRIPTOR is returned when passing a
223      * nullptr image_format */
224     cl_image_format invalid_format = { CL_INTENSITY, CL_UNORM_SHORT_555 };
225     err = clGetImageRequirementsInfoEXT(
226         context, nullptr, CL_MEM_READ_WRITE, &invalid_format, &image_desc,
227         CL_IMAGE_REQUIREMENTS_ROW_PITCH_ALIGNMENT_EXT,
228         sizeof(row_pitch_alignment), &row_pitch_alignment, nullptr);
229     test_failure_error(err, CL_INVALID_IMAGE_FORMAT_DESCRIPTOR,
230                        "Unexpected clGetImageRequirementsInfoEXT return");
231 
232     /* Check that CL_INVALID_IMAGE_DESCRIPTOR is returned when passing an
233      * image_desc with invalid values */
234     cl_image_desc invalid_desc_size = { CL_MEM_OBJECT_IMAGE1D, 0 };
235     err = clGetImageRequirementsInfoEXT(
236         context, nullptr, CL_MEM_READ_WRITE, &format, &invalid_desc_size,
237         CL_IMAGE_REQUIREMENTS_ROW_PITCH_ALIGNMENT_EXT,
238         sizeof(row_pitch_alignment), &row_pitch_alignment, nullptr);
239     test_failure_error(err, CL_INVALID_IMAGE_DESCRIPTOR,
240                        "Unexpected clGetImageRequirementsInfoEXT return");
241 
242     /* Check that CL_INVALID_VALUE is returned when passing an invalid
243      * param_name */
244     cl_image_requirements_info_ext invalid_info = CL_IMAGE_FORMAT;
245     err = clGetImageRequirementsInfoEXT(
246         context, nullptr, CL_MEM_READ_WRITE, &format, &image_desc, invalid_info,
247         sizeof(row_pitch_alignment), &row_pitch_alignment, nullptr);
248     test_failure_error(err, CL_INVALID_VALUE,
249                        "Unexpected clGetImageRequirementsInfoEXT return");
250 
251     /* Check that CL_INVALID_VALUE is returned when passing a param_value_size
252      * value smaller than the size of the return type */
253     err = clGetImageRequirementsInfoEXT(
254         context, nullptr, CL_MEM_READ_WRITE, &format, &image_desc,
255         CL_IMAGE_REQUIREMENTS_ROW_PITCH_ALIGNMENT_EXT,
256         sizeof(row_pitch_alignment) - 1, &row_pitch_alignment, nullptr);
257     test_failure_error(err, CL_INVALID_VALUE,
258                        "Unexpected clGetImageRequirementsInfoEXT return");
259 
260     /* Check that CL_INVALID_VALUE is returned when passing a param_value_size
261      * value smaller than the size of the return type */
262     uint32_t max_height = 0;
263     err = clGetImageRequirementsInfoEXT(
264         context, nullptr, CL_MEM_READ_WRITE, &format, &image_desc,
265         CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT, sizeof(max_height) - 1,
266         &max_height, nullptr);
267     test_failure_error(err, CL_INVALID_VALUE,
268                        "Unexpected clGetImageRequirementsInfoEXT return");
269 
270     return TEST_PASS;
271 }
272 
273 /**
274  * Negative tests for {CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT}
275  * Attempt to perform the {CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT} query on all
276  * image types for which it is not valid Check that
277  * {CL_INVALID_IMAGE_DESCRIPTOR} is returned in all cases.
278  *
279  * Negative testing for {CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT}
280  * Attempt to perform the {CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT} query on all
281  * image types for which it is not valid Check that
282  * {CL_INVALID_IMAGE_DESCRIPTOR} is returned in all cases.
283  *
284  * Negative testing for {CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT}
285  * Attempt to perform the {CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT} query on
286  * all image types for which it is not valid Check that
287  * {CL_INVALID_IMAGE_DESCRIPTOR} is returned in all cases.
288  */
cl_image_requirements_max_val_ext_negative(cl_device_id device,cl_context context,cl_command_queue queue)289 int cl_image_requirements_max_val_ext_negative(cl_device_id device,
290                                                cl_context context,
291                                                cl_command_queue queue)
292 {
293     if (!is_extension_available(device, "cl_ext_image_requirements_info"))
294     {
295         log_info("Extension cl_ext_image_requirements_info not available\n");
296         return TEST_SKIPPED_ITSELF;
297     }
298 
299     cl_platform_id platform = getPlatformFromDevice(device);
300     GET_EXTENSION_FUNC(platform, clGetImageRequirementsInfoEXT);
301 
302     size_t value = 0;
303 
304     std::vector<cl_mem_object_type> imageTypes_height{
305         CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE1D_BUFFER,
306         CL_MEM_OBJECT_IMAGE1D
307     };
308 
309     cl_image_format format = { CL_RGBA, CL_UNSIGNED_INT16 };
310 
311     for (auto imageType : imageTypes_height)
312     {
313         cl_image_desc image_desc = { 0 };
314         image_desc_init(&image_desc, imageType);
315 
316         /* Check image_format null results in CL_INVALID_VALUE */
317         cl_int err = clGetImageRequirementsInfoEXT(
318             context, nullptr, CL_MEM_READ_WRITE, &format, &image_desc,
319             CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT, sizeof(value), &value,
320             nullptr);
321         test_failure_error(err, CL_INVALID_IMAGE_DESCRIPTOR,
322                            "Unexpected clGetImageRequirementsInfoEXT return");
323     }
324 
325     std::vector<cl_mem_object_type> imageTypes_depth{
326         CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE2D_ARRAY,
327         CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE1D_BUFFER,
328         CL_MEM_OBJECT_IMAGE1D
329     };
330 
331     for (auto imageType : imageTypes_depth)
332     {
333         cl_image_desc image_desc = { 0 };
334         image_desc_init(&image_desc, imageType);
335 
336         /* Check image_format null results in CL_INVALID_VALUE */
337         cl_int err = clGetImageRequirementsInfoEXT(
338             context, nullptr, CL_MEM_READ_WRITE, &format, &image_desc,
339             CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT, sizeof(value), &value,
340             nullptr);
341         test_failure_error(err, CL_INVALID_IMAGE_DESCRIPTOR,
342                            "Unexpected clGetImageRequirementsInfoEXT return");
343     }
344 
345     std::vector<cl_mem_object_type> imageTypes_array_size{
346         CL_MEM_OBJECT_IMAGE3D, CL_MEM_OBJECT_IMAGE2D,
347         CL_MEM_OBJECT_IMAGE1D_BUFFER, CL_MEM_OBJECT_IMAGE1D
348     };
349 
350     for (auto imageType : imageTypes_array_size)
351     {
352         cl_image_desc image_desc = { 0 };
353         image_desc_init(&image_desc, imageType);
354 
355         /* Check image_format null results in CL_INVALID_VALUE */
356         cl_int err = clGetImageRequirementsInfoEXT(
357             context, nullptr, CL_MEM_READ_WRITE, &format, &image_desc,
358             CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT, sizeof(value), &value,
359             nullptr);
360         test_failure_error(err, CL_INVALID_IMAGE_DESCRIPTOR,
361                            "Unexpected clGetImageRequirementsInfoEXT return");
362     }
363 
364     return TEST_PASS;
365 }
366 
367 /**
368  * Consistency checks for {CL_IMAGE_REQUIREMENTS_MAX_WIDTH_EXT}
369  ** Check that the {CL_IMAGE_REQUIREMENTS_MAX_WIDTH_EXT} query can be performed
370  *successfully
371  *
372  * Consistency checks for {CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT}
373  ** Check that the {CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT} query can be performed
374  *successfully
375  *
376  * Consistency checks for {CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT}
377  ** Check that the {CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT} query can be performed
378  *successfully
379  *
380  * Consistency checks for {CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT}
381  ** Check that the {CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT} query can be
382  *performed successfully
383  */
cl_image_requirements_max_val_ext_positive(cl_device_id device,cl_context context,cl_command_queue queue)384 int cl_image_requirements_max_val_ext_positive(cl_device_id device,
385                                                cl_context context,
386                                                cl_command_queue queue)
387 {
388     if (!is_extension_available(device, "cl_ext_image_requirements_info"))
389     {
390         log_info("Extension cl_ext_image_requirements_info not available\n");
391         return TEST_SKIPPED_ITSELF;
392     }
393 
394     cl_platform_id platform = getPlatformFromDevice(device);
395     GET_EXTENSION_FUNC(platform, clGetImageRequirementsInfoEXT);
396 
397     /* CL_IMAGE_REQUIREMENTS_MAX_WIDTH_EXT */
398     cl_image_desc image_desc_1d = { 0 };
399     image_desc_init(&image_desc_1d, CL_MEM_OBJECT_IMAGE1D);
400 
401     uint32_t max_width = 0;
402     cl_int err = clGetImageRequirementsInfoEXT(
403         context, nullptr, CL_MEM_READ_WRITE, nullptr, &image_desc_1d,
404         CL_IMAGE_REQUIREMENTS_MAX_WIDTH_EXT, sizeof(max_width), &max_width,
405         nullptr);
406     test_error(err, "Error clGetImageRequirementsInfoEXT");
407 
408     size_t width_1d = 0;
409     err = clGetDeviceInfo(device, CL_DEVICE_IMAGE_MAX_BUFFER_SIZE,
410                           sizeof(width_1d), &width_1d, NULL);
411     test_error(err, "Error clGetDeviceInfo");
412 
413     if (!(max_width <= width_1d && max_width > 0))
414     {
415         test_fail("Unexpected CL_IMAGE_REQUIREMENTS_MAX_WIDTH_EXT value\n");
416     }
417 
418     /* CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT */
419     cl_image_desc image_desc_2d = { 0 };
420     image_desc_init(&image_desc_2d, CL_MEM_OBJECT_IMAGE2D);
421 
422     uint32_t max_height = 0;
423     err = clGetImageRequirementsInfoEXT(
424         context, nullptr, CL_MEM_READ_WRITE, nullptr, &image_desc_2d,
425         CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT, sizeof(max_height), &max_height,
426         nullptr);
427     test_error(err, "Error clGetImageRequirementsInfoEXT");
428 
429     size_t height_2d = 0;
430     err = clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_HEIGHT,
431                           sizeof(height_2d), &height_2d, NULL);
432     test_error(err, "Error clGetDeviceInfo");
433 
434     if (!(max_height <= height_2d && max_height > 0))
435     {
436         test_fail("Unexpected CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT value\n");
437     }
438 
439     /* CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT */
440     cl_image_desc image_desc_3d = { 0 };
441     image_desc_init(&image_desc_3d, CL_MEM_OBJECT_IMAGE3D);
442 
443     uint32_t max_depth = 0;
444     err = clGetImageRequirementsInfoEXT(context, nullptr, CL_MEM_READ_WRITE,
445                                         nullptr, &image_desc_3d,
446                                         CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT,
447                                         sizeof(max_depth), &max_depth, nullptr);
448     test_error(err, "Error clGetImageRequirementsInfoEXT");
449 
450     size_t depth_3d = 0;
451     err = clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof(depth_3d),
452                           &depth_3d, NULL);
453     test_error(err, "Error clGetDeviceInfo");
454 
455     if (!(max_depth <= depth_3d && max_depth > 0))
456     {
457         test_fail("Unexpected CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT value\n");
458     }
459 
460     /* CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT */
461     cl_image_desc image_desc_array = { 0 };
462     image_desc_init(&image_desc_array, CL_MEM_OBJECT_IMAGE2D_ARRAY);
463 
464     uint32_t max_array_size = 0;
465     err = clGetImageRequirementsInfoEXT(
466         context, nullptr, CL_MEM_READ_WRITE, nullptr, &image_desc_array,
467         CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT, sizeof(max_array_size),
468         &max_array_size, nullptr);
469     test_error(err, "Error clGetImageRequirementsInfoEXT");
470 
471     size_t array_size = 0;
472     err = clGetDeviceInfo(device, CL_DEVICE_IMAGE_MAX_ARRAY_SIZE,
473                           sizeof(array_size), &array_size, NULL);
474     test_error(err, "Error clGetDeviceInfo");
475 
476     if (!(max_array_size <= array_size && max_array_size > 0))
477     {
478         test_fail(
479             "Unexpected CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT value\n");
480     }
481 
482     return TEST_PASS;
483 }
484