On Sat, 2016-10-15 at 14:43 +0200, Niels Ole Salscheider wrote:
> v6: Fix OpenCL C version test if test is compiled against OpenCL 1.0
> v5: Use sscanf, fix CL_DEVICE_OPENCL_C_VERSION include guard, fix logic
> v4: Test against env->version instead of opencl_version and never
>     report PIGLIT_SKIP for the values of IMAGE_SUPPORT and ENDIAN_LITTLE
> v3: Fix alignment and typos
> v2: Check the values of the defines and add more checks
> 
> Signed-off-by: Niels Ole Salscheider <niels_...@salscheider-online.de>
> Reviewed-by: Jan Vesely <jan.ves...@rutgers.edu>
> ---
>  tests/cl.py                          |   1 +
>  tests/cl/program/CMakeLists.cl.txt   |   1 +
>  tests/cl/program/predefined-macros.c | 463 
> +++++++++++++++++++++++++++++++++++
>  3 files changed, 465 insertions(+)
>  create mode 100644 tests/cl/program/predefined-macros.c
> 
> diff --git a/tests/cl.py b/tests/cl.py
> index 353ab05..73fba0d 100644
> --- a/tests/cl.py
> +++ b/tests/cl.py
> @@ -96,6 +96,7 @@ with profile.group_manager(PiglitCLTest, 'program') as g:
>      g(['cl-program-max-work-item-sizes'],
>        'Run kernel with max work item sizes')
>      g(['cl-program-bitcoin-phatk'], 'Bitcoin: phatk kernel')
> +    g(['cl-program-predefined-macros'], 'Check predefined preprocessor 
> macros')
>  
>  with profile.group_manager(PiglitCLTest, 'interop') as g:
>      g(['cl-interop-egl_khr_cl_event2'], 'EGL_KHR_cl_event2')
> diff --git a/tests/cl/program/CMakeLists.cl.txt 
> b/tests/cl/program/CMakeLists.cl.txt
> index 82dc675..c8d7307 100644
> --- a/tests/cl/program/CMakeLists.cl.txt
> +++ b/tests/cl/program/CMakeLists.cl.txt
> @@ -1,3 +1,4 @@
>  piglit_cl_add_program_test (tester program-tester.c)
>  piglit_cl_add_program_test (max-work-item-sizes max-work-item-sizes.c)
>  piglit_cl_add_program_test (bitcoin-phatk bitcoin-phatk.c)
> +piglit_cl_add_program_test (predefined-macros predefined-macros.c)
> diff --git a/tests/cl/program/predefined-macros.c 
> b/tests/cl/program/predefined-macros.c
> new file mode 100644
> index 0000000..f94812c
> --- /dev/null
> +++ b/tests/cl/program/predefined-macros.c
> @@ -0,0 +1,463 @@
> +/*
> + * Copyright © 2016 Niels Ole Salscheider <niels_...@salscheider-online.de>
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice (including the next
> + * paragraph) shall be included in all copies or substantial portions of the
> + * Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
> + * DEALINGS IN THE SOFTWARE.
> + */
> +
> +#include "piglit-framework-cl-program.h"
> +
> +char *program_source =
> +"kernel void test(global int* file_defined, global int* line_defined, \n"
> +"                 global int* opencl_version_defined, global int* 
> opencl_version, \n"
> +"                 global int* opencl_c_version_defined, global int* 
> opencl_c_version, \n"
> +"                 global int* cl_version_defined, global int* cl_version, \n"
> +"                 global int* endian_little_defined, global int* 
> endian_little, \n"
> +"                 global int* image_support_defined, global int* 
> image_support) \n"
> +"{ \n"
> +"#ifdef __FILE__ \n"
> +"    *file_defined = 1; \n"
> +"#else \n"
> +"    *file_defined = 0; \n"
> +"#endif \n"
> +"\n"
> +"#ifdef __LINE__ \n"
> +"    *line_defined = 1; \n"
> +"#else \n"
> +"    *line_defined = 0; \n"
> +"#endif \n"
> +"\n"
> +"#ifdef __OPENCL_VERSION__ \n"
> +"    *opencl_version_defined = 1; \n"
> +"    *opencl_version = __OPENCL_VERSION__; \n"
> +"#else \n"
> +"    *opencl_version_defined = 0; \n"
> +"#endif \n"
> +"\n"
> +"#ifdef __OPENCL_C_VERSION__ \n"
> +"    *opencl_c_version_defined = 1; \n"
> +"    *opencl_c_version = __OPENCL_C_VERSION__; \n"
> +"#else \n"
> +"    *opencl_c_version_defined = 0; \n"
> +"#endif \n"
> +"\n"
> +"#ifdef CL_VERSION_1_0 \n"
> +"    cl_version_defined[0] = 1; \n"
> +"    cl_version[0] = CL_VERSION_1_0; \n"
> +"#else \n"
> +"    cl_version_defined[0] = 0; \n"
> +"#endif \n"
> +"\n"
> +"#ifdef CL_VERSION_1_1 \n"
> +"    cl_version_defined[1] = 1; \n"
> +"    cl_version[1] = CL_VERSION_1_1; \n"
> +"#else \n"
> +"    cl_version_defined[1] = 0; \n"
> +"#endif \n"
> +"\n"
> +"#ifdef CL_VERSION_1_2 \n"
> +"    cl_version_defined[2] = 1; \n"
> +"    cl_version[2] = CL_VERSION_1_2; \n"
> +"#else \n"
> +"    cl_version_defined[2] = 0; \n"
> +"#endif \n"
> +"\n"
> +"#ifdef CL_VERSION_2_0 \n"
> +"    cl_version_defined[3] = 1; \n"
> +"    cl_version[3] = CL_VERSION_2_0; \n"
> +"#else \n"
> +"    cl_version_defined[3] = 0; \n"
> +"#endif \n"
> +"\n"
> +"#ifdef __ENDIAN_LITTLE__ \n"
> +"    *endian_little_defined = 1; \n"
> +"    *endian_little = __ENDIAN_LITTLE__; \n"
> +"#else \n"
> +"    *endian_little_defined = 0; \n"
> +"#endif \n"
> +"#ifdef __IMAGE_SUPPORT__ \n"
> +"    *image_support_defined = 1; \n"
> +"    *image_support = __IMAGE_SUPPORT__; \n"
> +"#else \n"
> +"    *image_support_defined = 0; \n"
> +"#endif \n"
> +"}";
> +
> +PIGLIT_CL_PROGRAM_TEST_CONFIG_BEGIN
> +
> +     config.name = "Preprocessor Macros";
> +     config.clc_version_min = 10;
> +     config.run_per_device = true;
> +
> +     config.program_source = program_source;
> +     config.kernel_name = "test";
> +
> +PIGLIT_CL_PROGRAM_TEST_CONFIG_END
> +
> +int
> +version_from_string(char* string, int *version)
> +{
> +     int major, minor;
> +     if (!string || sscanf(string, "%*s %d.%d %*s", &major, &minor) != 2) {
> +             return 0;
> +     }
> +     *version = 100 * major + 10 * minor;
> +     return 1;
> +}
> +
> +#define NUM_CL_VERSION 4
> +
> +enum piglit_result
> +piglit_cl_test(const int argc,
> +               const char** argv,
> +               const struct piglit_cl_program_test_config* config,
> +               const struct piglit_cl_program_test_env* env)
> +{
> +     enum piglit_result result = PIGLIT_SKIP;
> +     enum piglit_result result_file_defined = PIGLIT_SKIP;
> +     enum piglit_result result_line_defined = PIGLIT_SKIP;
> +     enum piglit_result result_opencl_version_defined = PIGLIT_SKIP;
> +     enum piglit_result result_opencl_version = PIGLIT_SKIP;
> +     enum piglit_result result_opencl_c_version_defined = PIGLIT_SKIP;
> +     enum piglit_result result_opencl_c_version = PIGLIT_SKIP;
> +     enum piglit_result result_cl_version_defined[NUM_CL_VERSION];
> +     enum piglit_result result_cl_version[NUM_CL_VERSION];
> +     enum piglit_result result_endian_little_defined = PIGLIT_SKIP;
> +     enum piglit_result result_endian_little = PIGLIT_SKIP;
> +     enum piglit_result result_image_support_defined = PIGLIT_SKIP;
> +     enum piglit_result result_image_support = PIGLIT_SKIP;
> +
> +     size_t work_size = 1;
> +
> +     cl_int file_defined;
> +     cl_mem file_defined_mem = NULL;
> +     cl_int line_defined;
> +     cl_mem line_defined_mem = NULL;
> +     cl_int opencl_version_defined;
> +     cl_mem opencl_version_defined_mem = NULL;
> +     cl_int opencl_version;
> +     cl_mem opencl_version_mem = NULL;
> +     cl_int opencl_c_version_defined;
> +     cl_mem opencl_c_version_defined_mem = NULL;
> +     cl_int opencl_c_version;
> +     cl_mem opencl_c_version_mem = NULL;
> +     cl_int cl_version_defined[NUM_CL_VERSION];
> +     cl_mem cl_version_defined_mem = NULL;
> +     cl_int cl_version[NUM_CL_VERSION];
> +     cl_mem cl_version_mem = NULL;
> +     cl_int endian_little_defined;
> +     cl_mem endian_little_defined_mem = NULL;
> +     cl_int endian_little;
> +     cl_mem endian_little_mem = NULL;
> +     cl_int image_support_defined;
> +     cl_mem image_support_defined_mem = NULL;
> +     cl_int image_support;
> +     cl_mem image_support_mem = NULL;
> +
> +     char* opencl_version_str_host = NULL;
> +     char* opencl_c_version_str_host = NULL;
> +     cl_bool* endian_little_host = NULL;
> +     cl_bool* image_support_host = NULL;
> +
> +     int i;
> +     for (i = 0; i < NUM_CL_VERSION; ++i) {
> +             result_cl_version_defined[i] = PIGLIT_SKIP;
> +             result_cl_version[i] = PIGLIT_SKIP;
> +     }
> +
> +     opencl_version_str_host = piglit_cl_get_device_info(env->device_id,
> +                                                         CL_DEVICE_VERSION);
> +#ifdef CL_VERSION_1_1
> +     opencl_c_version_str_host = piglit_cl_get_device_info(env->device_id,
> +                                                           
> CL_DEVICE_OPENCL_C_VERSION);
> +#endif
> +     endian_little_host = piglit_cl_get_device_info(env->device_id,
> +                                                    CL_DEVICE_ENDIAN_LITTLE);
> +     image_support_host = piglit_cl_get_device_info(env->device_id,
> +                                                    CL_DEVICE_IMAGE_SUPPORT);
> +
> +     /* create buffers for the results */
> +     file_defined_mem = piglit_cl_create_buffer(env->context,
> +                                                CL_MEM_WRITE_ONLY,
> +                                                sizeof(cl_int));
> +     line_defined_mem = piglit_cl_create_buffer(env->context,
> +                                                CL_MEM_WRITE_ONLY,
> +                                                sizeof(cl_int));
> +     opencl_version_defined_mem = piglit_cl_create_buffer(env->context,
> +                                                          CL_MEM_WRITE_ONLY,
> +                                                          sizeof(cl_int));
> +     opencl_version_mem = piglit_cl_create_buffer(env->context,
> +                                                  CL_MEM_WRITE_ONLY,
> +                                                  sizeof(cl_int));
> +     opencl_c_version_defined_mem = piglit_cl_create_buffer(env->context,
> +                                                            
> CL_MEM_WRITE_ONLY,
> +                                                            sizeof(cl_int));
> +     opencl_c_version_mem = piglit_cl_create_buffer(env->context,
> +                                                    CL_MEM_WRITE_ONLY,
> +                                                    sizeof(cl_int));
> +     cl_version_defined_mem = piglit_cl_create_buffer(env->context,
> +                                                      CL_MEM_WRITE_ONLY,
> +                                                      NUM_CL_VERSION * 
> sizeof(cl_int));
> +     cl_version_mem = piglit_cl_create_buffer(env->context,
> +                                              CL_MEM_WRITE_ONLY,
> +                                              NUM_CL_VERSION * 
> sizeof(cl_int));
> +     endian_little_defined_mem = piglit_cl_create_buffer(env->context,
> +                                                         CL_MEM_WRITE_ONLY,
> +                                                         sizeof(cl_int));
> +     endian_little_mem = piglit_cl_create_buffer(env->context,
> +                                                 CL_MEM_WRITE_ONLY,
> +                                                 sizeof(cl_int));
> +     image_support_defined_mem = piglit_cl_create_buffer(env->context,
> +                                                         CL_MEM_WRITE_ONLY,
> +                                                         sizeof(cl_int));
> +     image_support_mem = piglit_cl_create_buffer(env->context,
> +                                                 CL_MEM_WRITE_ONLY,
> +                                                 sizeof(cl_int));
> +
> +     /* set kernel args and run the kernel */
> +     piglit_cl_set_kernel_buffer_arg(env->kernel, 0, &file_defined_mem);
> +     piglit_cl_set_kernel_buffer_arg(env->kernel, 1, &line_defined_mem);
> +     piglit_cl_set_kernel_buffer_arg(env->kernel, 2,
> +                                     &opencl_version_defined_mem);
> +     piglit_cl_set_kernel_buffer_arg(env->kernel, 3, &opencl_version_mem);
> +     piglit_cl_set_kernel_buffer_arg(env->kernel, 4,
> +                                     &opencl_c_version_defined_mem);
> +     piglit_cl_set_kernel_buffer_arg(env->kernel, 5, &opencl_c_version_mem);
> +     piglit_cl_set_kernel_buffer_arg(env->kernel, 6,
> +                                     &cl_version_defined_mem);
> +     piglit_cl_set_kernel_buffer_arg(env->kernel, 7, &cl_version_mem);
> +     piglit_cl_set_kernel_buffer_arg(env->kernel, 8,
> +                                     &endian_little_defined_mem);
> +     piglit_cl_set_kernel_buffer_arg(env->kernel, 9, &endian_little_mem);
> +     piglit_cl_set_kernel_buffer_arg(env->kernel, 10,
> +                                     &image_support_defined_mem);
> +     piglit_cl_set_kernel_buffer_arg(env->kernel, 11, &image_support_mem);
> +     piglit_cl_execute_ND_range_kernel(env->context->command_queues[0],
> +                                       env->kernel,
> +                                       1,
> +                                       NULL,
> +                                       &work_size,
> +                                       &work_size);
> +
> +     /* read the buffers */
> +     piglit_cl_read_buffer(env->context->command_queues[0], file_defined_mem,
> +                           0, sizeof(cl_int), &file_defined);
> +     piglit_cl_read_buffer(env->context->command_queues[0], line_defined_mem,
> +                           0, sizeof(cl_int), &line_defined);
> +     piglit_cl_read_buffer(env->context->command_queues[0],
> +                           opencl_version_defined_mem, 0, sizeof(cl_int),
> +                           &opencl_version_defined);
> +     piglit_cl_read_buffer(env->context->command_queues[0],
> +                           opencl_version_mem, 0, sizeof(cl_int),
> +                           &opencl_version);
> +     piglit_cl_read_buffer(env->context->command_queues[0],
> +                           opencl_c_version_defined_mem, 0, sizeof(cl_int),
> +                           &opencl_c_version_defined);
> +     piglit_cl_read_buffer(env->context->command_queues[0],
> +                           opencl_c_version_mem, 0, sizeof(cl_int),
> +                           &opencl_c_version);
> +     piglit_cl_read_buffer(env->context->command_queues[0],
> +                           cl_version_defined_mem, 0,
> +                           NUM_CL_VERSION * sizeof(cl_int),
> +                           cl_version_defined);
> +     piglit_cl_read_buffer(env->context->command_queues[0],
> +                           cl_version_mem, 0,
> +                           NUM_CL_VERSION * sizeof(cl_int),
> +                           cl_version);
> +     piglit_cl_read_buffer(env->context->command_queues[0],
> +                           endian_little_defined_mem, 0, sizeof(cl_int),
> +                           &endian_little_defined);
> +     piglit_cl_read_buffer(env->context->command_queues[0],
> +                           endian_little_mem, 0, sizeof(cl_int),
> +                           &endian_little);
> +     piglit_cl_read_buffer(env->context->command_queues[0],
> +                           image_support_defined_mem, 0, sizeof(cl_int),
> +                           &image_support_defined);
> +     piglit_cl_read_buffer(env->context->command_queues[0],
> +                           image_support_mem, 0, sizeof(cl_int),
> +                           &image_support);
> +
> +     /* check the values */
> +     result_file_defined = (file_defined == 1) ? PIGLIT_PASS : PIGLIT_FAIL;
> +     result_line_defined = (line_defined == 1) ? PIGLIT_PASS : PIGLIT_FAIL;
> +
> +     if (!opencl_version_defined) {
> +             result_opencl_version_defined = PIGLIT_FAIL;
> +     } else {
> +             int opencl_version_host;
> +             result_opencl_version_defined = PIGLIT_PASS;
> +             if (!version_from_string(opencl_version_str_host,
> +                                      &opencl_version_host)) {
> +                     printf("Could not determine host OpenCL version.\n");
> +                     piglit_merge_result(&result, PIGLIT_FAIL);
> +             } else {
> +                     result_opencl_version = (opencl_version == 
> opencl_version_host) ?
> +                                             PIGLIT_PASS : PIGLIT_FAIL;
> +             }
> +     }
> +
> +     if (env->version >= 11) {
> +             result_cl_version_defined[0] = cl_version_defined[0] ?
> +                                            PIGLIT_PASS : PIGLIT_FAIL;
> +             result_cl_version_defined[1] = cl_version_defined[1] ?
> +                                            PIGLIT_PASS : PIGLIT_FAIL;
> +     }
> +     if (env->version >= 12) {
> +             result_cl_version_defined[2] = cl_version_defined[2] ?
> +                                            PIGLIT_PASS : PIGLIT_FAIL;
> +     }
> +     if (env->version >= 20) {
> +             result_cl_version_defined[3] = cl_version_defined[3] ?
> +                                            PIGLIT_PASS : PIGLIT_FAIL;
> +     }
> +
> +     if (env->version >= 12) {
> +             if (!opencl_c_version_defined) {
> +                     result_opencl_c_version_defined = PIGLIT_FAIL;
> +             } else {
> +#ifdef CL_VERSION_1_1
> +                     int opencl_c_version_host;
> +#endif
> +                     result_opencl_c_version_defined = PIGLIT_PASS;

I think it'd be better to let this be the default PIGLIT_SKIP. I can
fix that locally before pushing if you concur.

thanks for your patience,
Jan

> +#ifdef CL_VERSION_1_1
> +                     if (!version_from_string(opencl_c_version_str_host,
> +                                              &opencl_c_version_host)) {
> +                             printf("Could not determine host OpenCL C 
> version.\n");
> +                             piglit_merge_result(&result, PIGLIT_FAIL);
> +                     } else {
> +                             result_opencl_c_version = (opencl_c_version == 
> opencl_c_version_host) ?
> +                                                       PIGLIT_PASS : 
> PIGLIT_FAIL;
> +                     }
> +#endif
> +             }
> +     }
> +
> +     if (cl_version_defined[0]) {
> +             result_cl_version[0] = (cl_version[0] == 100) ?
> +                                    PIGLIT_PASS : PIGLIT_FAIL;
> +     }
> +     if (cl_version_defined[1]) {
> +             result_cl_version[1] = (cl_version[1] == 110) ?
> +                                    PIGLIT_PASS : PIGLIT_FAIL;
> +     }
> +     if (cl_version_defined[2]) {
> +             result_cl_version[2] = (cl_version[2] == 120) ?
> +                                    PIGLIT_PASS : PIGLIT_FAIL;
> +     }
> +     if (cl_version_defined[3]) {
> +             result_cl_version[3] = (cl_version[3] == 200) ?
> +                                    PIGLIT_PASS : PIGLIT_FAIL;
> +     }
> +
> +     result_endian_little_defined = (*endian_little_host == 
> endian_little_defined) ?
> +                                    PIGLIT_PASS : PIGLIT_FAIL;
> +     if (endian_little_defined) {
> +             result_endian_little = (endian_little == 1) ?
> +                                    PIGLIT_PASS : PIGLIT_FAIL;
> +     } else if (!*endian_little_host) {
> +             result_endian_little = PIGLIT_PASS;
> +     }
> +
> +     result_image_support_defined = (*image_support_host == 
> image_support_defined) ?
> +                                    PIGLIT_PASS : PIGLIT_FAIL;
> +     if (image_support_defined) {
> +             result_image_support = (image_support == 1) ?
> +                                    PIGLIT_PASS : PIGLIT_FAIL;
> +     } else if (!*image_support_host) {
> +             result_image_support = PIGLIT_PASS;
> +     }
> +
> +     /* report the results */
> +     piglit_report_subtest_result(result_file_defined,
> +                                  "__FILE__ must be defined");
> +     piglit_merge_result(&result, result_file_defined);
> +     piglit_report_subtest_result(result_line_defined,
> +                                  "__LINE__ must be defined");
> +     piglit_merge_result(&result, result_line_defined);
> +     piglit_report_subtest_result(result_opencl_version_defined,
> +                                  "__OPENCL_VERSION__ must be defined");
> +     piglit_merge_result(&result, result_opencl_version_defined);
> +     piglit_report_subtest_result(result_opencl_version,
> +                                  "__OPENCL_VERSION__ must be consistent 
> with host");
> +     piglit_merge_result(&result, result_opencl_version);
> +     piglit_report_subtest_result(result_opencl_c_version_defined,
> +                                  "__OPENCL_C_VERSION__ must be defined for 
> OpenCL 1.2 and later");
> +     piglit_merge_result(&result, result_opencl_c_version_defined);
> +     piglit_report_subtest_result(result_opencl_c_version,
> +                                  "__OPENCL_C_VERSION__ must be consistent 
> with host (if defined)");
> +     piglit_merge_result(&result, result_opencl_c_version);
> +     piglit_report_subtest_result(result_cl_version_defined[0],
> +                                  "CL_VERSION_1_0 must be defined for OpenCL 
> 1.1 and later");
> +     piglit_merge_result(&result, result_cl_version_defined[0]);
> +     piglit_report_subtest_result(result_cl_version_defined[1],
> +                                  "CL_VERSION_1_1 must be defined for OpenCL 
> 1.1 and later");
> +     piglit_merge_result(&result, result_cl_version_defined[1]);
> +     piglit_report_subtest_result(result_cl_version_defined[2],
> +                                  "CL_VERSION_1_2 must be defined for OpenCL 
> 1.2 and later");
> +     piglit_merge_result(&result, result_cl_version_defined[2]);
> +     piglit_report_subtest_result(result_cl_version_defined[3],
> +                                  "CL_VERSION_2_0 must be defined for OpenCL 
> 2.0 and later");
> +     piglit_merge_result(&result, result_cl_version_defined[3]);
> +     piglit_report_subtest_result(result_cl_version[0],
> +                                  "CL_VERSION_1_0 must be 100 if defined");
> +     piglit_merge_result(&result, result_cl_version[0]);
> +     piglit_report_subtest_result(result_cl_version[1],
> +                                  "CL_VERSION_1_1 must be 110 if defined");
> +     piglit_merge_result(&result, result_cl_version[1]);
> +     piglit_report_subtest_result(result_cl_version[2],
> +                                  "CL_VERSION_1_2 must be 120 if defined");
> +     piglit_merge_result(&result, result_cl_version[2]);
> +     piglit_report_subtest_result(result_cl_version[3],
> +                                  "CL_VERSION_2_0 must be 200 if defined");
> +     piglit_merge_result(&result, result_cl_version[3]);
> +     piglit_report_subtest_result(result_endian_little_defined,
> +                                  "__ENDIAN_LITTLE__ must be consistent with 
> host");
> +     piglit_merge_result(&result, result_endian_little_defined);
> +     piglit_report_subtest_result(result_endian_little,
> +                                  "__ENDIAN_LITTLE__ must be 1 if defined");
> +     piglit_merge_result(&result, result_endian_little);
> +     piglit_report_subtest_result(result_image_support_defined,
> +                                  "__IMAGE_SUPPORT__ must be consistent with 
> host");
> +     piglit_merge_result(&result, result_image_support_defined);
> +     piglit_report_subtest_result(result_image_support,
> +                                  "__IMAGE_SUPPORT__ must be 1 if defined");
> +     piglit_merge_result(&result, result_image_support);
> +
> +     /* free cl resources */
> +     clReleaseMemObject(file_defined_mem);
> +     clReleaseMemObject(line_defined_mem);
> +     clReleaseMemObject(opencl_version_defined_mem);
> +     clReleaseMemObject(opencl_version_mem);
> +     clReleaseMemObject(opencl_c_version_defined_mem);
> +     clReleaseMemObject(opencl_c_version_mem);
> +     clReleaseMemObject(cl_version_defined_mem);
> +     clReleaseMemObject(cl_version_mem);
> +     clReleaseMemObject(endian_little_defined_mem);
> +     clReleaseMemObject(endian_little_mem);
> +     clReleaseMemObject(image_support_defined_mem);
> +     clReleaseMemObject(image_support_mem);
> +
> +     /* free host resources */
> +     free(opencl_version_str_host);
> +     free(opencl_c_version_str_host);
> +     free(endian_little_host);
> +     free(image_support_host);
> +
> +     return result;
> +}

Attachment: signature.asc
Description: This is a digitally signed message part

_______________________________________________
Piglit mailing list
Piglit@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/piglit

Reply via email to