text: /*
   * Copyright (c) 2017, Intel Corporation
   *
   * 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 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 "cl_api_tests.h"
  #include "runtime/context/context.h"
  #include "runtime/compiler_interface/compiler_interface.h"
  #include "runtime/device/device.h"
  #include "runtime/helpers/file_io.h"
  #include "runtime/helpers/options.h"
  #include "unit_tests/helpers/kernel_binary_helper.h"
  #include "unit_tests/helpers/test_files.h"
  
  using namespace OCLRT;
  
  typedef api_tests clGetKernelArgInfoTests;
  
  namespace ULT {
  
  TEST_F(clGetKernelArgInfoTests, success) {
      cl_program pProgram = nullptr;
      void *pSource = nullptr;
      size_t sourceSize = 0;
      std::string testFile;
  
      KernelBinaryHelper kbHelper("CopyBuffer_simd8", false);
  
      testFile.append(clFiles);
      testFile.append("CopyBuffer_simd8.cl");
  
      sourceSize = loadDataFromFile(
          testFile.c_str(),
          pSource);
  
      ASSERT_NE(0u, sourceSize);
      ASSERT_NE(nullptr, pSource);
  
      pProgram = clCreateProgramWithSource(
          pContext,
          1,
          (const char **)&pSource,
          &sourceSize,
          &retVal);
  
      EXPECT_NE(nullptr, pProgram);
      ASSERT_EQ(CL_SUCCESS, retVal);
  
      retVal = clBuildProgram(
          pProgram,
          num_devices,
          devices,
          "-cl-kernel-arg-info",
          nullptr,
          nullptr);
  
      ASSERT_EQ(CL_SUCCESS, retVal);
  
      cl_kernel kernel = clCreateKernel(pProgram, "CopyBuffer", &retVal);
      ASSERT_EQ(CL_SUCCESS, retVal);
  
      size_t ret_sz;
      cl_kernel_arg_type_qualifier type_qual;
      retVal = clGetKernelArgInfo(kernel, 0, CL_KERNEL_ARG_TYPE_QUALIFIER,
                                  sizeof(type_qual), &type_qual, &ret_sz);
      EXPECT_EQ(CL_SUCCESS, retVal);
      EXPECT_EQ(ret_sz, sizeof(cl_kernel_arg_type_qualifier));
  
      retVal = clReleaseKernel(kernel);
      EXPECT_EQ(CL_SUCCESS, retVal);
  
      retVal = clReleaseProgram(pProgram);
      EXPECT_EQ(CL_SUCCESS, retVal);
  
      deleteDataReadFromFile(pSource);
      CompilerInterface::shutdown();
  }
  } // namespace ULT
  