/* Modifications Copyright(C) 2022 Advanced Micro Devices, Inc.
 * All rights reserved.
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#ifndef CL_USE_DEPRECATED_OPENCL_1_0_APIS
#define CL_USE_DEPRECATED_OPENCL_1_0_APIS
#endif

#ifndef CL_USE_DEPRECATED_OPENCL_1_1_APIS
#define CL_USE_DEPRECATED_OPENCL_1_1_APIS
#endif

// Need to rename all CL API functions to prevent ICD loader functions calling
// themselves via the dispatch table. Include this before cl headers.
#include "rename_api.h"

#include <CL/cl.h>
#include <platform/icd_test_log.h>
#include "icd_structs.h"

#define CL_PLATFORM_ICD_SUFFIX_KHR                  0x0920
CL_API_ENTRY cl_int CL_API_CALL
clIcdGetPlatformIDsKHR(cl_uint, cl_platform_id *, cl_uint *);

struct _cl_platform_id
{
    CLIicdDispatchTable* dispatch;
    const char *profile;
    const char *version;
    const char *name;
    const char *vendor;
    const char *extensions;
    const char *suffix;
};

struct _cl_device_id
{
    CLIicdDispatchTable* dispatch;
};

struct _cl_context
{
    CLIicdDispatchTable* dispatch;
};

struct _cl_command_queue
{
    CLIicdDispatchTable* dispatch;
};

struct _cl_mem
{
    CLIicdDispatchTable* dispatch;
};

struct _cl_program
{
    CLIicdDispatchTable* dispatch;
};

struct _cl_kernel
{
    CLIicdDispatchTable* dispatch;
};

struct _cl_event
{
    CLIicdDispatchTable* dispatch;
};

struct _cl_sampler
{
    CLIicdDispatchTable* dispatch;
};

static CLIicdDispatchTable* dispatchTable = NULL;
static cl_platform_id platform = NULL;
static cl_bool initialized = CL_FALSE;

CL_API_ENTRY cl_int CL_API_CALL
clGetPlatformIDs(cl_uint           num_entries ,
                 cl_platform_id *  platforms ,
                 cl_uint *         num_platforms) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetPlatformIDs(%u, %p, %p)\n",
                      num_entries,
                      platforms,
                      num_platforms);
    return_value = clIcdGetPlatformIDsKHR(num_entries, platforms, num_platforms);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetPlatformInfo(cl_platform_id    platform,
                  cl_platform_info  param_name,
                  size_t            param_value_size,
                  void *            param_value,
                  size_t *          param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int ret = CL_SUCCESS;
    const char *returnString = NULL;
    size_t returnStringLength = 0;
    /*test_icd_stub_log("clGetPlatformInfo(%p, %u, %u, %p, %p)\n",
                      platform,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);*/

    // validate the arguments
    if (param_value_size == 0 && param_value != NULL) {
        ret = CL_INVALID_VALUE;
        goto done;
    }
    // select the string to return
    switch(param_name) {
        case CL_PLATFORM_PROFILE:
            returnString = platform->profile;
            break;
        case CL_PLATFORM_VERSION:
            returnString = platform->version;
            break;
        case CL_PLATFORM_NAME:
            returnString = platform->name;
            break;
        case CL_PLATFORM_VENDOR:
            returnString = platform->vendor;
            break;
        case CL_PLATFORM_EXTENSIONS:
            returnString = platform->extensions;
            break;
        case CL_PLATFORM_ICD_SUFFIX_KHR:
            returnString = platform->suffix;
            break;
        default:
            ret = CL_INVALID_VALUE;
            goto done;
    }

    // make sure the buffer passed in is big enough for the result
    returnStringLength = strlen(returnString)+1;
    if (param_value_size && param_value_size < returnStringLength) {
        ret = CL_INVALID_VALUE;
        goto done;
    }

    // pass the data back to the user
    if (param_value) {
        memcpy(param_value, returnString, returnStringLength);
    }
    if (param_value_size_ret) {
        *param_value_size_ret = returnStringLength;
    }

done:
    /*test_icd_stub_log("Value returned: %d\n",
                      return_value);*/
    return ret;
}


/* Device APIs */
CL_API_ENTRY cl_int CL_API_CALL
clGetDeviceIDs(cl_platform_id   platform,
               cl_device_type   device_type,
               cl_uint          num_entries,
               cl_device_id *   devices,
               cl_uint *        num_devices) CL_API_SUFFIX__VERSION_1_0
{
    cl_int ret = CL_SUCCESS;

    if ((num_entries > 1 || num_entries < 0) && devices != NULL) {
        ret = CL_INVALID_VALUE;
        goto done;
    }

    if (devices != NULL) {
        cl_device_id obj = (cl_device_id) malloc(sizeof(*obj));
        obj->dispatch = dispatchTable;
        devices[0] = obj;
    }
    if (num_devices) {
        *num_devices = 1;
    }

done:
    test_icd_stub_log("clGetDeviceIDs(%p, %x, %u, %p, %p)\n",
                      platform,
                      device_type,
                      num_entries,
                      devices,
                      num_devices);
    test_icd_stub_log("Value returned: %d\n", ret);
    return ret;
}



CL_API_ENTRY cl_int CL_API_CALL
clGetDeviceInfo(cl_device_id    device,
                cl_device_info  param_name,
                size_t          param_value_size,
                void *          param_value,
                size_t *        param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetDeviceInfo(%p, %u, %u, %p, %p)\n",
                      device,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clCreateSubDevices(cl_device_id in_device,
                   const cl_device_partition_property *properties,
                   cl_uint num_entries,
                   cl_device_id *out_devices,
                   cl_uint *num_devices) CL_API_SUFFIX__VERSION_1_2
{

    cl_int return_value = CL_OUT_OF_RESOURCES;

    test_icd_stub_log("clCreateSubDevices(%p, %p, %u, %p, %p)\n",
                      in_device,
                      properties,
                      num_entries,
                      out_devices,
                      num_devices);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}


CL_API_ENTRY cl_int CL_API_CALL
clRetainDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clRetainDevice(%p)\n", device);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}


CL_API_ENTRY cl_int CL_API_CALL
clReleaseDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2

{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clReleaseDevice(%p)\n", device);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}


/* Context APIs  */
CL_API_ENTRY cl_context CL_API_CALL
clCreateContext(const cl_context_properties * properties,
                cl_uint                       num_devices ,
                const cl_device_id *          devices,
                void (CL_CALLBACK * pfn_notify)(const char *, const void *, size_t, void *),
                void *                        user_data,
                cl_int *                      errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_context obj = (cl_context) malloc(sizeof(struct _cl_context));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateContext(%p, %u, %p, %p, %p, %p)\n",
                      properties,
                      num_devices,
                      devices,
                      pfn_notify,
                      user_data,
                      errcode_ret);
    pfn_notify(NULL, NULL, 0, NULL);
    test_icd_stub_log("createcontext_callback(%p, %p, %u, %p)\n",
                      NULL,
                      NULL,
                      0,
                      NULL);

    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}


CL_API_ENTRY cl_context CL_API_CALL
clCreateContextFromType(const cl_context_properties * properties,
                        cl_device_type                device_type,
                        void (CL_CALLBACK *     pfn_notify)(const char *, const void *, size_t, void *),
                        void *                        user_data,
                        cl_int *                      errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_context obj = (cl_context) malloc(sizeof(struct _cl_context));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateContextFromType(%p, %x, %p, %p, %p)\n",
                      properties,
                      device_type,
                      pfn_notify,
                      user_data,
                      errcode_ret);
    pfn_notify(NULL, NULL, 0, NULL);

    test_icd_stub_log ("createcontext_callback(%p, %p, %u, %p)\n",
                       NULL,
                       NULL,
                       0,
                       NULL);

    test_icd_stub_log("Value returned: %p\n",
		              obj);
    return obj;
}

CL_API_ENTRY cl_int CL_API_CALL
clRetainContext(cl_context context) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clRetainContext(%p)\n", context);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clReleaseContext(cl_context context) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clReleaseContext(%p)\n", context);
    free(context);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetContextInfo(cl_context         context,
                 cl_context_info    param_name,
                 size_t             param_value_size,
                 void *             param_value,
                 size_t *           param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetContextInfo(%p, %u, %u, %p, %p)\n",
                      context,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

/* Command Queue APIs */
CL_API_ENTRY cl_command_queue CL_API_CALL
clCreateCommandQueue(cl_context                     context,
                     cl_device_id                   device,
                     cl_command_queue_properties    properties,
                     cl_int *                       errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_command_queue obj = (cl_command_queue) malloc(sizeof(struct _cl_command_queue));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateCommandQueue(%p, %p, %x, %p)\n",
                      context,
                      device,
                      properties,
                      errcode_ret);

    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}

CL_API_ENTRY cl_int CL_API_CALL
clSetCommandQueueProperty(cl_command_queue               command_queue ,
                            cl_command_queue_properties    properties ,
                            cl_bool                        enable ,
                            cl_command_queue_properties *  old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clSetCommandQueueProperty(%p, %p, %u, %p)\n",
                      command_queue,
                      properties,
                      enable,
                      old_properties);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clRetainCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clRetainCommandQueue(%p)\n", command_queue);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clReleaseCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clReleaseCommandQueue(%p)\n", command_queue);
    free(command_queue);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetCommandQueueInfo(cl_command_queue       command_queue ,
                      cl_command_queue_info  param_name ,
                      size_t                 param_value_size ,
                      void *                 param_value ,
                      size_t *               param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetCommandQueueInfo(%p, %u, %u, %p, %p)\n",
                      command_queue,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}



/* Memory Object APIs */
CL_API_ENTRY cl_mem CL_API_CALL
clCreateBuffer(cl_context    context ,
               cl_mem_flags  flags ,
               size_t        size ,
               void *        host_ptr ,
               cl_int *      errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_mem obj = (cl_mem) malloc(sizeof(struct _cl_mem));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateBuffer(%p, %x, %u, %p, %p)\n",
                      context,
                      flags,
                      size,
                      host_ptr,
                      errcode_ret);

    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}

CL_API_ENTRY cl_mem CL_API_CALL
clCreateSubBuffer(cl_mem                    buffer ,
                  cl_mem_flags              flags ,
                  cl_buffer_create_type     buffer_create_type ,
                  const void *              buffer_create_info ,
                  cl_int *                  errcode_ret) CL_API_SUFFIX__VERSION_1_1
{
    cl_mem obj = (cl_mem) malloc(sizeof(struct _cl_mem));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateSubBuffer(%p, %x, %u, %p, %p)\n",
                      buffer,
                      flags,
                      buffer_create_type,
                      buffer_create_info,
                      errcode_ret);

    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}

CL_API_ENTRY cl_mem CL_API_CALL
clCreateImage(cl_context              context,
                            cl_mem_flags            flags,
                            const cl_image_format * image_format,
                            const cl_image_desc *   image_desc,
                            void *                  host_ptr,
                            cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_2
{
    cl_mem obj = (cl_mem) malloc(sizeof(struct _cl_mem));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateImage(%p, %x, %p, %p, %p, %p)\n",
                      context,
                      flags,
                      image_format,
                      image_desc,
                      host_ptr,
                      errcode_ret);

    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}


CL_API_ENTRY cl_mem CL_API_CALL
clCreateImage2D(cl_context              context ,
                cl_mem_flags            flags ,
                const cl_image_format * image_format ,
                size_t                  image_width ,
                size_t                  image_height ,
                size_t                  image_row_pitch ,
                void *                  host_ptr ,
                cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_mem obj = (cl_mem) malloc(sizeof(struct _cl_mem));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateImage2D(%p, %x, %p, %u, %u, %u, %p, %p)\n",
                      context,
                      flags,
                      image_format,
                      image_width,
                      image_height,
                      image_row_pitch,
                      host_ptr,
		      errcode_ret);

    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}

CL_API_ENTRY cl_mem CL_API_CALL
clCreateImage3D(cl_context              context,
                cl_mem_flags            flags,
                const cl_image_format * image_format,
                size_t                  image_width,
                size_t                  image_height ,
                size_t                  image_depth ,
                size_t                  image_row_pitch ,
                size_t                  image_slice_pitch ,
                void *                  host_ptr ,
                cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_mem obj = (cl_mem) malloc(sizeof(struct _cl_mem));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateImage3D(%p, %x, %p, %u, %u, %u, %u, %u, %p, %p)\n",
                      context,
                      flags,
                      image_format,
                      image_width,
                      image_height,
                      image_depth,
                      image_row_pitch,
                      image_slice_pitch,
                      host_ptr,
                      errcode_ret);

    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}

CL_API_ENTRY cl_int CL_API_CALL
clRetainMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clRetainMemObject(%p)\n", memobj);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clReleaseMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clReleaseMemObject(%p)\n", memobj);
    free(memobj);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetSupportedImageFormats(cl_context           context,
                           cl_mem_flags         flags,
                           cl_mem_object_type   image_type ,
                           cl_uint              num_entries ,
                           cl_image_format *    image_formats ,
                           cl_uint *            num_image_formats) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetSupportedImageFormats(%p, %x, %u, %u, %p, %p)\n",
                      context,
                      flags,
                      image_type,
                      num_entries,
                      image_formats,
                      num_image_formats);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetMemObjectInfo(cl_mem            memobj ,
                   cl_mem_info       param_name ,
                   size_t            param_value_size ,
                   void *            param_value ,
                   size_t *          param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetMemObjectInfo(%p, %u, %u, %p, %p)\n",
                      memobj,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetImageInfo(cl_mem            image ,
               cl_image_info     param_name ,
               size_t            param_value_size ,
               void *            param_value ,
               size_t *          param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetImageInfo(%p, %u, %u, %p, %p)\n",
                      image,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clSetMemObjectDestructorCallback(cl_mem  memobj ,
                                    void (CL_CALLBACK * pfn_notify)(cl_mem  memobj , void* user_data),
                                    void * user_data)             CL_API_SUFFIX__VERSION_1_1
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clSetMemObjectDestructorCallback(%p, %p, %p)\n",
                      memobj,
                      pfn_notify,
                      user_data);
    pfn_notify(memobj, NULL);
    test_icd_stub_log("setmemobjectdestructor_callback(%p, %p)\n",
               memobj,
               NULL);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

/* Sampler APIs  */
CL_API_ENTRY cl_sampler CL_API_CALL
clCreateSampler(cl_context           context ,
                cl_bool              normalized_coords ,
                cl_addressing_mode   addressing_mode ,
                cl_filter_mode       filter_mode ,
                cl_int *             errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_sampler obj = (cl_sampler) malloc(sizeof(struct _cl_sampler));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateSampler(%p, %u, %u, %u, %p)\n",
                      context,
                      normalized_coords,
                      addressing_mode,
                      filter_mode,
                      errcode_ret);

    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}

CL_API_ENTRY cl_int CL_API_CALL
clRetainSampler(cl_sampler  sampler) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clRetainSampler(%p)\n", sampler);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clReleaseSampler(cl_sampler  sampler) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clReleaseSampler(%p)\n", sampler);
    free(sampler);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetSamplerInfo(cl_sampler          sampler ,
                 cl_sampler_info     param_name ,
                 size_t              param_value_size ,
                 void *              param_value ,
                 size_t *            param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetSamplerInfo(%p, %u, %u, %p, %p)\n",
                      sampler,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

/* Program Object APIs  */
CL_API_ENTRY cl_program CL_API_CALL
clCreateProgramWithSource(cl_context         context ,
                          cl_uint            count ,
                          const char **      strings ,
                          const size_t *     lengths ,
                          cl_int *           errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_program obj = (cl_program) malloc(sizeof(struct _cl_program));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateProgramWithSource(%p, %u, %p, %p, %p)\n",
                      context,
                      count,
                      strings,
                      lengths,
                      errcode_ret);

    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}

CL_API_ENTRY cl_program CL_API_CALL
clCreateProgramWithBinary(cl_context                      context ,
                          cl_uint                         num_devices ,
                          const cl_device_id *            device_list ,
                          const size_t *                  lengths ,
                          const unsigned char **          binaries ,
                          cl_int *                        binary_status ,
                          cl_int *                        errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_program obj = (cl_program) malloc(sizeof(struct _cl_program));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateProgramWithBinary(%p, %u, %p, %p, %p, %p, %p)\n",
                      context,
                      num_devices,
                      device_list,
                      lengths,
                      binaries,
                      binary_status,
                      errcode_ret);

    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}

CL_API_ENTRY cl_program CL_API_CALL
clCreateProgramWithBuiltInKernels(cl_context             context ,
                                  cl_uint                num_devices ,
                                  const cl_device_id *   device_list ,
                                  const char *           kernel_names ,
                                  cl_int *               errcode_ret) CL_API_SUFFIX__VERSION_1_2
{
    cl_program obj = (cl_program) malloc(sizeof(struct _cl_program));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateProgramWithBuiltInKernels(%p, %u, %p, %p, %p)\n",
                      context,
                      num_devices,
                      device_list,
                      kernel_names,
                      errcode_ret);

    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}


CL_API_ENTRY cl_int CL_API_CALL
clRetainProgram(cl_program  program) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clRetainProgram(%p)\n",
                      program);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clReleaseProgram(cl_program  program) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clReleaseProgram(%p)\n", program);
    free(program);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clBuildProgram(cl_program            program ,
               cl_uint               num_devices ,
               const cl_device_id *  device_list ,
               const char *          options ,
               void (CL_CALLBACK *   pfn_notify)(cl_program  program , void *  user_data),
               void *                user_data) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clBuildProgram(%p, %u, %p, %p, %p, %p)\n",
                      program,
                      num_devices,
                      device_list,
                      options,
                      pfn_notify,
                      user_data);
    pfn_notify(program, NULL);
    test_icd_stub_log("program_callback(%p, %p)\n", program, NULL);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clUnloadCompiler(void) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clUnloadCompiler()\n");
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clCompileProgram(cl_program            program ,
                 cl_uint               num_devices ,
                 const cl_device_id *  device_list ,
                 const char *          options ,
                 cl_uint               num_input_headers ,
                 const cl_program *    input_headers,
                 const char **         header_include_names ,
                 void (CL_CALLBACK *   pfn_notify)(cl_program  program , void *  user_data),
                 void *                user_data) CL_API_SUFFIX__VERSION_1_2
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clCompileProgram(%p, %u, %p, %p, %u, %p, %p, %p)\n",
                      program,
                      num_devices,
                      device_list,
                      options,
                      num_input_headers,
                      header_include_names,
                      pfn_notify,
                      user_data);
    pfn_notify(program, NULL);
    test_icd_stub_log("program_callback(%p, %p)\n", program, NULL);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_program CL_API_CALL
clLinkProgram(cl_context            context ,
              cl_uint               num_devices ,
              const cl_device_id *  device_list ,
              const char *          options ,
              cl_uint               num_input_programs ,
              const cl_program *    input_programs ,
              void (CL_CALLBACK *   pfn_notify)(cl_program  program , void *  user_data),
              void *                user_data ,
              cl_int *              errcode_ret) CL_API_SUFFIX__VERSION_1_2
{
    cl_program obj = (cl_program) malloc(sizeof(cl_program));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clLinkProgram(%p, %u, %p, %p, %u, %p, %p, %p, %p)\n",
                      context,
                      num_devices,
                      device_list,
                      options,
                      num_input_programs,
                      input_programs,
                      pfn_notify,
                      user_data,
                      errcode_ret);
    pfn_notify(obj, NULL);
    test_icd_stub_log("program_callback(%p, %p)\n", obj, NULL);
    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}


CL_API_ENTRY cl_int CL_API_CALL
clUnloadPlatformCompiler(cl_platform_id  platform) CL_API_SUFFIX__VERSION_1_2
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clUnloadPlatformCompiler(%p)\n", platform);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetProgramInfo(cl_program          program ,
                 cl_program_info     param_name ,
                 size_t              param_value_size ,
                 void *              param_value ,
                 size_t *            param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetProgramInfo(%p, %u, %u, %p, %p)\n",
                      program,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetProgramBuildInfo(cl_program             program ,
                      cl_device_id           device ,
                      cl_program_build_info  param_name ,
                      size_t                 param_value_size ,
                      void *                 param_value ,
                      size_t *               param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetProgramBuildInfo(%p, %p, %u, %u, %p, %p)\n",
                      program,
                      device,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

/* Kernel Object APIs */
CL_API_ENTRY cl_kernel CL_API_CALL
clCreateKernel(cl_program       program ,
               const char *     kernel_name ,
               cl_int *         errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_kernel obj = (cl_kernel) malloc(sizeof(struct _cl_kernel));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateKernel(%p, %p, %p)\n",
                      program,
                      kernel_name,
                      errcode_ret);

    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}

CL_API_ENTRY cl_int CL_API_CALL
clCreateKernelsInProgram(cl_program      program ,
                         cl_uint         num_kernels ,
                         cl_kernel *     kernels ,
                         cl_uint *       num_kernels_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clCreateKernelsInProgram(%p, %u, %p, %p)\n",
                      program,
                      num_kernels,
                      kernels,
                      num_kernels_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clRetainKernel(cl_kernel     kernel) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clRetainKernel(%p)\n", kernel);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clReleaseKernel(cl_kernel    kernel) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clReleaseKernel(%p)\n", kernel);
    free(kernel);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clSetKernelArg(cl_kernel     kernel ,
               cl_uint       arg_index ,
               size_t        arg_size ,
               const void *  arg_value) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clSetKernelArg(%p, %u, %u, %p)\n",
                      kernel,
                      arg_index,
                      arg_size,
                      arg_value);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetKernelInfo(cl_kernel        kernel ,
                cl_kernel_info   param_name ,
                size_t           param_value_size ,
                void *           param_value ,
                size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetKernelInfo(%p, %u, %u, %p, %p)\n",
                      kernel,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetKernelArgInfo(cl_kernel        kernel ,
                   cl_uint          arg_indx ,
                   cl_kernel_arg_info   param_name ,
                   size_t           param_value_size ,
                   void *           param_value ,
                   size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_2
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetKernelArgInfo(%p, %u, %u, %u, %p, %p)\n",
                      kernel,
                      arg_indx,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetKernelWorkGroupInfo(cl_kernel                   kernel ,
                         cl_device_id                device ,
                         cl_kernel_work_group_info   param_name ,
                         size_t                      param_value_size ,
                         void *                      param_value ,
                         size_t *                    param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetKernelWorkGroupInfo(%p, %p, %u, %u, %p, %p)\n",
                      kernel,
                      device,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

/* Event Object APIs  */
CL_API_ENTRY cl_int CL_API_CALL
clWaitForEvents(cl_uint              num_events ,
                const cl_event *     event_list) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clWaitForEvents(%u, %p)\n",
                      num_events,
                      event_list);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetEventInfo(cl_event          event ,
               cl_event_info     param_name ,
               size_t            param_value_size ,
               void *            param_value ,
               size_t *          param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetEventInfo(%p, %u, %u, %p, %p)\n",
                      event,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_event CL_API_CALL
clCreateUserEvent(cl_context     context ,
                  cl_int *       errcode_ret) CL_API_SUFFIX__VERSION_1_1
{
    cl_event obj = (cl_event) malloc(sizeof(struct _cl_event));
    obj->dispatch = dispatchTable;
    test_icd_stub_log("clCreateUserEvent(%p, %p)\n", context, errcode_ret);
    test_icd_stub_log("Value returned: %p\n", obj);
    return obj;
}

CL_API_ENTRY cl_int CL_API_CALL
clRetainEvent(cl_event  event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clRetainEvent(%p)\n", event);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clReleaseEvent(cl_event  event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clReleaseEvent(%p)\n", event);
    free(event);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clSetUserEventStatus(cl_event    event ,
                     cl_int      execution_status) CL_API_SUFFIX__VERSION_1_1
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clSetUserEventStatus(%p, %d)\n",
                      event,
                      execution_status);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clSetEventCallback(cl_event     event ,
                    cl_int       command_exec_callback_type ,
                    void (CL_CALLBACK *  pfn_notify)(cl_event, cl_int, void *),
                    void *       user_data) CL_API_SUFFIX__VERSION_1_1
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clSetEventCallback(%p, %d, %p, %p)\n",
                      event,
                      command_exec_callback_type,
                      pfn_notify,
                      user_data);
    pfn_notify(event, command_exec_callback_type, NULL);
    test_icd_stub_log("setevent_callback(%p, %d, %p)\n",
                      event,
                      command_exec_callback_type,
                      NULL);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

/* Profiling APIs  */
CL_API_ENTRY cl_int CL_API_CALL
clGetEventProfilingInfo(cl_event             event ,
                        cl_profiling_info    param_name ,
                        size_t               param_value_size ,
                        void *               param_value ,
                        size_t *             param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clGetEventProfilingInfo(%p, %u, %u, %p, %p)\n",
                      event,
                      param_name,
                      param_value_size,
                      param_value,
                      param_value_size_ret);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

/* Flush and Finish APIs */
CL_API_ENTRY cl_int CL_API_CALL
clFlush(cl_command_queue  command_queue) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clFlush(%p)\n", command_queue);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clFinish(cl_command_queue  command_queue) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clFinish(%p)\n", command_queue);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

/* Enqueued Commands APIs */
CL_API_ENTRY cl_int CL_API_CALL
clEnqueueReadBuffer(cl_command_queue     command_queue ,
                    cl_mem               buffer ,
                    cl_bool              blocking_read ,
                    size_t               offset ,
                    size_t               cb ,
                    void *               ptr ,
                    cl_uint              num_events_in_wait_list ,
                    const cl_event *     event_wait_list ,
                    cl_event *           event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueReadBuffer(%p, %p, %u, %u, %u, %p, %u, %p, %p)\n",
                      command_queue,
                      buffer,
                      blocking_read,
                      offset,
                      cb,
                      ptr,
                      num_events_in_wait_list,
                      event_wait_list, event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueReadBufferRect(cl_command_queue     command_queue ,
                        cl_mem               buffer ,
                        cl_bool              blocking_read ,
                        const size_t *       buffer_origin ,
                        const size_t *       host_origin ,
                        const size_t *       region ,
                        size_t               buffer_row_pitch ,
                        size_t               buffer_slice_pitch ,
                        size_t               host_row_pitch ,
                        size_t               host_slice_pitch ,
                        void *               ptr ,
                        cl_uint              num_events_in_wait_list ,
                        const cl_event *     event_wait_list ,
                        cl_event *           event) CL_API_SUFFIX__VERSION_1_1
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueReadBufferRect(%p, %p, %u, %p, %p, %p, %u, %u, %u, %u, %p, %u, %p, %p)\n",
                      command_queue,
                      buffer,
                      blocking_read,
                      buffer_origin,
                      host_origin,
                      region,
                      buffer_row_pitch,
                      buffer_slice_pitch,
                      host_row_pitch,
                      host_slice_pitch,
                      ptr,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueWriteBuffer(cl_command_queue    command_queue ,
                     cl_mem              buffer ,
                     cl_bool             blocking_write ,
                     size_t              offset ,
                     size_t              cb ,
                     const void *        ptr ,
                     cl_uint             num_events_in_wait_list ,
                     const cl_event *    event_wait_list ,
                     cl_event *          event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueWriteBuffer(%p, %p, %u, %u, %u, %p, %u, %p, %p)\n",
                      command_queue,
                      buffer,
                      blocking_write,
                      offset,
                      cb,
                      ptr,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueWriteBufferRect(cl_command_queue     command_queue ,
                         cl_mem               buffer ,
                         cl_bool              blocking_write ,
                         const size_t *       buffer_origin ,
                         const size_t *       host_origin ,
                         const size_t *       region ,
                         size_t               buffer_row_pitch ,
                         size_t               buffer_slice_pitch ,
                         size_t               host_row_pitch ,
                         size_t               host_slice_pitch ,
                         const void *         ptr ,
                         cl_uint              num_events_in_wait_list ,
                         const cl_event *     event_wait_list ,
                         cl_event *           event) CL_API_SUFFIX__VERSION_1_1
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueWriteBufferRect(%p, %p, %u, %p, %p, %p, %u, %u, %u, %u, %p, %u, %p, %p)\n",
                      command_queue,
                      buffer,
                      blocking_write,
                      buffer_origin,
                      host_origin,
                      region,
                      buffer_row_pitch,
                      buffer_slice_pitch,
                      host_row_pitch,
                      host_slice_pitch,
                      ptr,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueCopyBuffer(cl_command_queue     command_queue ,
                    cl_mem               src_buffer ,
                    cl_mem               dst_buffer ,
                    size_t               src_offset ,
                    size_t               dst_offset ,
                    size_t               cb ,
                    cl_uint              num_events_in_wait_list ,
                    const cl_event *     event_wait_list ,
                    cl_event *           event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueCopyBuffer(%p, %p, %p, %u, %u, %u, %u, %p, %p)\n",
                      command_queue,
                      src_buffer,
                      dst_buffer,
                      src_offset,
                      dst_offset,
                      cb,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueCopyBufferRect(cl_command_queue     command_queue ,
                        cl_mem               src_buffer ,
                        cl_mem               dst_buffer ,
                        const size_t *       src_origin ,
                        const size_t *       dst_origin ,
                        const size_t *       region ,
                        size_t               src_row_pitch ,
                        size_t               src_slice_pitch ,
                        size_t               dst_row_pitch ,
                        size_t               dst_slice_pitch ,
                        cl_uint              num_events_in_wait_list ,
                        const cl_event *     event_wait_list ,
                        cl_event *           event) CL_API_SUFFIX__VERSION_1_1
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueCopyBufferRect(%p, %p, %p, %p, %p, %p, %u, %u, %u, %u, %u, %p, %p)\n",
                      command_queue,
                      src_buffer,
                      dst_buffer,
                      src_origin,
                      dst_origin,
                      region,
                      src_row_pitch,
                      src_slice_pitch,
                      dst_row_pitch,
                      dst_slice_pitch,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}


CL_API_ENTRY cl_int CL_API_CALL
clEnqueueFillBuffer(cl_command_queue    command_queue ,
                    cl_mem              buffer ,
                    const void *        pattern ,
                    size_t              pattern_size ,
                    size_t              offset ,
                    size_t              cb ,
                    cl_uint             num_events_in_wait_list ,
                    const cl_event *    event_wait_list ,
                    cl_event *          event) CL_API_SUFFIX__VERSION_1_2
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueFillBuffer(%p, %p, %p, %u, %u, %u, %u, %p, %p)\n",
                      command_queue,
                      buffer,
                      pattern,
                      pattern_size,
                      offset,
                      cb,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}


CL_API_ENTRY cl_int CL_API_CALL
clEnqueueFillImage(cl_command_queue    command_queue ,
                   cl_mem              image ,
                   const void *        fill_color ,
                   const size_t *      origin ,
                   const size_t *      region ,
                   cl_uint             num_events_in_wait_list ,
                   const cl_event *    event_wait_list ,
                   cl_event *          event) CL_API_SUFFIX__VERSION_1_2
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueFillImage(%p, %p, %p, %p, %p, %u, %p, %p)\n",
                      command_queue,
                      image,
                      fill_color,
                      origin,
                      region,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}


CL_API_ENTRY cl_int CL_API_CALL
clEnqueueReadImage(cl_command_queue      command_queue ,
                   cl_mem                image ,
                   cl_bool               blocking_read ,
                   const size_t *        origin ,
                   const size_t *        region ,
                   size_t                row_pitch ,
                   size_t                slice_pitch ,
                   void *                ptr ,
                   cl_uint               num_events_in_wait_list ,
                   const cl_event *      event_wait_list ,
                   cl_event *            event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueReadImage(%p, %p, %u, %p, %p, %u, %u, %p, %u, %p, %p)\n",
                      command_queue,
                      image,
                      blocking_read,
                      origin,
                      region,
                      row_pitch,
                      slice_pitch,
                      ptr,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueWriteImage(cl_command_queue     command_queue ,
                    cl_mem               image ,
                    cl_bool              blocking_write ,
                    const size_t *       origin ,
                    const size_t *       region ,
                    size_t               input_row_pitch ,
                    size_t               input_slice_pitch ,
                    const void *         ptr ,
                    cl_uint              num_events_in_wait_list ,
                    const cl_event *     event_wait_list ,
                    cl_event *           event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueWriteImage(%p, %p, %u, %p, %p, %u, %u, %p, %u, %p, %p)\n",
                      command_queue,
                      image,
                      blocking_write,
                      origin,
                      region,
                      input_row_pitch,
                      input_slice_pitch,
                      ptr,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueCopyImage(cl_command_queue      command_queue ,
                   cl_mem                src_image ,
                   cl_mem                dst_image ,
                   const size_t *        src_origin ,
                   const size_t *        dst_origin ,
                   const size_t *        region ,
                   cl_uint               num_events_in_wait_list ,
                   const cl_event *      event_wait_list ,
                   cl_event *            event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueCopyImage(%p, %p, %p, %p, %p, %p, %u, %p, %p)\n",
                      command_queue,
                      src_image,
                      dst_image,
                      src_origin,
                      dst_origin,
                      region,
                      num_events_in_wait_list,
                      event_wait_list ,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueCopyImageToBuffer(cl_command_queue  command_queue ,
                           cl_mem            src_image ,
                           cl_mem            dst_buffer ,
                           const size_t *    src_origin ,
                           const size_t *    region ,
                           size_t            dst_offset ,
                           cl_uint           num_events_in_wait_list ,
                           const cl_event *  event_wait_list ,
                           cl_event *        event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueCopyImageToBuffer(%p, %p, %p, %p, %p, %u, %u, %p, %p)\n",
                      command_queue,
                      src_image,
                      dst_buffer,
                      src_origin,
                      region,
                      dst_offset,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueCopyBufferToImage(cl_command_queue  command_queue ,
                           cl_mem            src_buffer ,
                           cl_mem            dst_image ,
                           size_t            src_offset ,
                           const size_t *    dst_origin ,
                           const size_t *    region ,
                           cl_uint           num_events_in_wait_list ,
                           const cl_event *  event_wait_list ,
                           cl_event *        event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueCopyBufferToImage(%p, %p, %p, %u, %p, %p, %u, %p, %p)\n",
                      command_queue,
                      src_buffer,
                      dst_image,
                      src_offset,
                      dst_origin,
                      region,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY void * CL_API_CALL
clEnqueueMapBuffer(cl_command_queue  command_queue ,
                   cl_mem            buffer ,
                   cl_bool           blocking_map ,
                   cl_map_flags      map_flags ,
                   size_t            offset ,
                   size_t            cb ,
                   cl_uint           num_events_in_wait_list ,
                   const cl_event *  event_wait_list ,
                   cl_event *        event ,
                   cl_int *          errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
    void *return_value = (void *) malloc(sizeof(void *));
    test_icd_stub_log("clEnqueueMapBuffer(%p, %p, %u, %x, %u, %u, %u, %p, %p, %p)\n",
                      command_queue,
                      buffer,
                      blocking_map,
                      map_flags,
                      offset,
                      cb,
                      num_events_in_wait_list,
                      event_wait_list,
                      event,
                      errcode_ret);

    test_icd_stub_log("Value returned: %p\n", return_value);
    return return_value;
}

CL_API_ENTRY void * CL_API_CALL
clEnqueueMapImage(cl_command_queue   command_queue ,
                  cl_mem             image ,
                  cl_bool            blocking_map ,
                  cl_map_flags       map_flags ,
                  const size_t *     origin ,
                  const size_t *     region ,
                  size_t *           image_row_pitch ,
                  size_t *           image_slice_pitch ,
                  cl_uint            num_events_in_wait_list ,
                  const cl_event *   event_wait_list ,
                  cl_event *         event ,
                  cl_int *           errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
    void *return_value = (void *) malloc(sizeof(void *));
    test_icd_stub_log("clEnqueueMapImage(%p, %p, %u, %x, %p, %p, %p, %p, %u, %p, %p, %p)\n",
                      command_queue,
                      image,
                      blocking_map,
                      map_flags,
                      origin,
                      region,
                      image_row_pitch,
                      image_slice_pitch,
                      num_events_in_wait_list,
                      event_wait_list,
                      event,
                      errcode_ret);

    test_icd_stub_log("Value returned: %p\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueUnmapMemObject(cl_command_queue  command_queue ,
                        cl_mem            memobj ,
                        void *            mapped_ptr ,
                        cl_uint           num_events_in_wait_list ,
                        const cl_event *   event_wait_list ,
                        cl_event *         event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueUnmapMemObject(%p, %p, %p, %u, %p, %p)\n",
                      command_queue,
                      memobj,
                      mapped_ptr,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueMigrateMemObjects(cl_command_queue        command_queue ,
                           cl_uint                 num_mem_objects ,
                           const cl_mem *          mem_objects ,
                           cl_mem_migration_flags  flags ,
                           cl_uint                 num_events_in_wait_list ,
                           const cl_event *        event_wait_list ,
                           cl_event *              event) CL_API_SUFFIX__VERSION_1_2
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueMigrateMemObjects(%p, %u, %p, %x, %u, %p, %p)\n",
                      command_queue,
                      num_mem_objects,
                      mem_objects,
                      flags,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}


CL_API_ENTRY cl_int CL_API_CALL
clEnqueueNDRangeKernel(cl_command_queue  command_queue ,
                       cl_kernel         kernel ,
                       cl_uint           work_dim ,
                       const size_t *    global_work_offset ,
                       const size_t *    global_work_size ,
                       const size_t *    local_work_size ,
                       cl_uint           num_events_in_wait_list ,
                       const cl_event *  event_wait_list ,
                       cl_event *        event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueNDRangeKernel(%p, %p, %u, %p, %p, %p, %u, %p, %p)\n",
                      command_queue,
                      kernel,
                      work_dim,
                      global_work_offset,
                      global_work_size,
                      local_work_size,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueTask(cl_command_queue   command_queue ,
              cl_kernel          kernel ,
              cl_uint            num_events_in_wait_list ,
              const cl_event *   event_wait_list ,
              cl_event *         event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueTask(%p, %p, %u, %p, %p)\n",
                      command_queue,
                      kernel,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueNativeKernel(cl_command_queue   command_queue ,
                      void (CL_CALLBACK *user_func)(void *),
                      void *             args ,
                      size_t             cb_args ,
                      cl_uint            num_mem_objects ,
                      const cl_mem *     mem_list ,
                      const void **      args_mem_loc ,
                      cl_uint            num_events_in_wait_list ,
                      const cl_event *   event_wait_list ,
                      cl_event *         event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueNativeKernel(%p, %p, %p, %u, %u, %p, %p, %u, %p, %p)\n",
                      command_queue,
                      user_func,
                      args,
                      cb_args,
                      num_mem_objects,
                      mem_list,
                      args_mem_loc,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY void * CL_API_CALL
clGetExtensionFunctionAddressForPlatform(cl_platform_id  platform ,
                                         const char *    func_name) CL_API_SUFFIX__VERSION_1_2
{
    void *return_value = (void *) malloc(sizeof(void *));
    test_icd_stub_log("clGetExtensionFunctionAddressForPlatform(%p, %p)\n",
                      platform,
                      func_name);

    test_icd_stub_log("Value returned: %p\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueMarkerWithWaitList(cl_command_queue  command_queue ,
                            cl_uint            num_events_in_wait_list ,
                            const cl_event *   event_wait_list ,
                            cl_event *         event) CL_API_SUFFIX__VERSION_1_2

{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueMarkerWithWaitList(%p, %u, %p, %p)\n",
                      command_queue,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueBarrierWithWaitList(cl_command_queue  command_queue ,
                             cl_uint            num_events_in_wait_list ,
                             const cl_event *   event_wait_list ,
                             cl_event *         event) CL_API_SUFFIX__VERSION_1_2
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueBarrierWithWaitList(%p, %u, %p, %p)\n",
                      command_queue,
                      num_events_in_wait_list,
                      event_wait_list,
                      event);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

extern CL_API_ENTRY cl_int CL_API_CALL
clSetPrintfCallback(cl_context           context ,
                    void (CL_CALLBACK *  pfn_notify)(cl_context  program ,
                                                          cl_uint printf_data_len ,
                                                          char *  printf_data_ptr ,
                                                          void *  user_data),
                    void *               user_data) CL_API_SUFFIX__VERSION_1_2
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clSetPrintfCallback(%p, %p, %p)\n",
                      context,
                      pfn_notify,
                      user_data);
    pfn_notify(context, 0, NULL, NULL);
    test_icd_stub_log("setprintf_callback(%p, %u, %p, %p)\n",
                      context,
                      0,
                      NULL,
                      NULL);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}


CL_API_ENTRY cl_int CL_API_CALL
clEnqueueMarker(cl_command_queue     command_queue ,
                cl_event *           event) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueMarker(%p, %p)\n", command_queue, event);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueWaitForEvents(cl_command_queue  command_queue ,
                       cl_uint           num_events ,
                       const cl_event *  event_list) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueWaitForEvents(%p, %u, %p)\n",
                      command_queue,
                      num_events,
                      event_list);

    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueBarrier(cl_command_queue  command_queue) CL_API_SUFFIX__VERSION_1_0
{
    cl_int return_value = CL_OUT_OF_RESOURCES;
    test_icd_stub_log("clEnqueueBarrier(%p)\n", command_queue);
    test_icd_stub_log("Value returned: %d\n", return_value);
    return return_value;
}

extern cl_int cliIcdDispatchTableCreate(CLIicdDispatchTable **outDispatchTable);

CL_API_ENTRY cl_int CL_API_CALL
clIcdGetPlatformIDsKHR(cl_uint           num_entries,
                       cl_platform_id * platforms,
                       cl_uint *        num_platforms)
{
    cl_int result = CL_SUCCESS;
    if (!initialized) {
        result = cliIcdDispatchTableCreate(&dispatchTable);
        platform = (cl_platform_id) malloc(sizeof(struct _cl_platform_id));
        memset(platform, 0, sizeof(struct _cl_platform_id));

        platform->dispatch = dispatchTable;
        platform->version = "OpenCL 1.2 Stub";
        platform->vendor = "stubvendorxxx";
        platform->profile = "stubprofilexxx";
        platform->name = "ICD_LOADER_TEST_OPENCL_STUB";
        platform->extensions = "cl_khr_icd cl_khr_gl cl_khr_d3d10";
        platform->suffix = "ilts";
        platform->dispatch = dispatchTable;
        initialized = CL_TRUE;
    }

    if ((platforms && num_entries >1) ||
        (platforms && num_entries <= 0) ||
        (!platforms && num_entries >= 1)) {
        result = CL_INVALID_VALUE;
        goto Done;
    }

    if (platforms && num_entries == 1) {
        platforms[0] = platform;
    }

Done:
    if (num_platforms) {
        *num_platforms = 1;
    }

    return result;
}

