Rename test .c sources to .cpp where necessary (#604)

Remove hacks to force language from CMake files.

Closes KhronosGroup/OpenCL-CTS#25

test_conformance/basic/test_simple_image_pitch.cpp

@@ -0,0 +1,153 @@
+//
+// Copyright (c) 2017 The Khronos Group Inc.
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "harness/compat.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+int test_simple_read_image_pitch(cl_device_id device, cl_context cl_context_, cl_command_queue q, int num_elements)
+{
+  cl_int err = CL_SUCCESS;
+
+  size_t imageW = 143;
+  size_t imageH = 151;
+  size_t bufferW = 151*4;
+  size_t bufferH = 151;
+
+  size_t pixel_bytes = 4;
+  size_t image_bytes = imageW * imageH * pixel_bytes;
+
+  size_t buffer_bytes = bufferW * bufferH;
+
+  PASSIVE_REQUIRE_IMAGE_SUPPORT( device );
+
+  char* host_image = (char*)malloc(image_bytes);
+  memset(host_image,0x1,image_bytes);
+
+  cl_image_format fmt = { 0 };
+  fmt.image_channel_order     = CL_RGBA;
+  fmt.image_channel_data_type = CL_UNORM_INT8;
+
+  cl_image_desc desc = { 0 };
+  desc.image_type         = CL_MEM_OBJECT_IMAGE2D;
+  desc.image_width        = imageW;
+  desc.image_height       = imageH;
+
+  cl_mem image = clCreateImage(cl_context_, CL_MEM_COPY_HOST_PTR|CL_MEM_READ_WRITE, &fmt, &desc, host_image, &err);
+  test_error(err,"clCreateImage");
+
+  char* host_buffer = (char*)malloc(buffer_bytes);
+  memset(host_buffer,0xa,buffer_bytes);
+
+  // Test reading from the image
+  size_t origin[] = { 0, 0, 0 };
+  size_t region[] = { imageW, imageH, 1 };
+
+  err = clEnqueueReadImage(q, image, CL_TRUE, origin, region, bufferW, 0, host_buffer, 0, NULL, NULL);
+  test_error(err,"clEnqueueReadImage");
+
+  size_t errors = 0;
+  for (size_t j=0;j<bufferH;++j) {
+    for (size_t i=0;i<bufferW;++i) {
+      char val = host_buffer[j*bufferW+i];
+      if ((i<imageW*pixel_bytes) && (val != 0x1)) {
+        log_error("Bad value %x in image at (byte: %lu, row: %lu)\n",val,i,j);
+        ++errors;
+      }
+      else if ((i>=imageW*pixel_bytes) && (val != 0xa)) {
+        log_error("Bad value %x outside image at (byte: %lu, row: %lu)\n",val,i,j);
+        ++errors;
+      }
+    }
+  }
+
+  test_error(clReleaseMemObject(image),"clReleaseMemObject");
+  free(host_image);
+  free(host_buffer);
+
+  return CL_SUCCESS;
+}
+
+int test_simple_write_image_pitch(cl_device_id device, cl_context cl_context_, cl_command_queue q, int num_elements)
+{
+  cl_int err = CL_SUCCESS;
+
+  size_t imageW = 143;
+  size_t imageH = 151;
+  size_t bufferW = 151*4;
+  size_t bufferH = 151;
+
+  size_t pixel_bytes = 4;
+  size_t image_bytes = imageW * imageH * pixel_bytes;
+
+  size_t buffer_bytes = bufferW * bufferH;
+
+  PASSIVE_REQUIRE_IMAGE_SUPPORT( device );
+
+  char* host_image = (char*)malloc(image_bytes);
+  memset(host_image,0x0,image_bytes);
+
+  cl_image_format fmt = { 0 };
+  fmt.image_channel_order     = CL_RGBA;
+  fmt.image_channel_data_type = CL_UNORM_INT8;
+
+  cl_image_desc desc = { 0 };
+  desc.image_type         = CL_MEM_OBJECT_IMAGE2D;
+  desc.image_width        = imageW;
+  desc.image_height       = imageH;
+
+  cl_mem image = clCreateImage(cl_context_, CL_MEM_COPY_HOST_PTR|CL_MEM_READ_WRITE, &fmt, &desc, host_image, &err);
+  test_error(err,"clCreateImage");
+
+  char* host_buffer = (char*)malloc(buffer_bytes);
+  memset(host_buffer,0xa,buffer_bytes);
+
+  // Test reading from the image
+  size_t origin[] = { 0, 0, 0 };
+  size_t region[] = { imageW, imageH, 1 };
+
+  err = clEnqueueWriteImage(q, image, CL_TRUE, origin, region, bufferW, 0, host_buffer, 0, NULL, NULL);
+  test_error(err,"clEnqueueWriteImage");
+
+  size_t mapped_pitch = 0;
+  char* mapped_image = (char*)clEnqueueMapImage(q, image, CL_TRUE, CL_MAP_READ, origin, region, &mapped_pitch, NULL, 0, NULL, NULL, &err);
+  test_error(err,"clEnqueueMapImage");
+
+  size_t errors = 0;
+  for (size_t j=0;j<imageH;++j) {
+    for (size_t i=0;i<mapped_pitch;++i) {
+      char val = mapped_image[j*mapped_pitch+i];
+      if ((i<imageW*pixel_bytes) && (val != 0xa)) {
+        log_error("Bad value %x in image at (byte: %lu, row: %lu)\n",val,i,j);
+        ++errors;
+      }
+    }
+  }
+
+  err = clEnqueueUnmapMemObject(q, image, (void *)mapped_image, 0, 0, 0);
+  test_error(err,"clEnqueueUnmapMemObject");
+
+  test_error(clReleaseMemObject(image),"clReleaseMemObject");
+  free(host_image);
+  free(host_buffer);
+
+  return CL_SUCCESS;
+}