diff --git a/core/helpers/get_info.h b/core/helpers/get_info.h
index d9099df31c..edc5de5893 100644
--- a/core/helpers/get_info.h
+++ b/core/helpers/get_info.h
@@ -6,28 +6,28 @@
  */
 
 #pragma once
-#include "CL/cl.h"
+#include "get_info_status.h"
 
 #include <cstring>
 
 // Need for linux compatibility with memcpy_s
 #include "core/helpers/string.h"
 
-inline cl_int getInfo(void *destParamValue, size_t destParamValueSize,
-                      const void *srcParamValue, size_t srcParamValueSize) {
-    auto retVal = CL_INVALID_VALUE;
+inline GetInfoStatus getInfo(void *destParamValue, size_t destParamValueSize,
+                             const void *srcParamValue, size_t srcParamValueSize) {
+    auto retVal = GetInfoStatus::INVALID_VALUE;
     if (srcParamValue && srcParamValueSize) {
         if (!destParamValue && !destParamValueSize) {
             // Report ok if they're looking for size.
-            retVal = CL_SUCCESS;
+            retVal = GetInfoStatus::SUCCESS;
         } else if (destParamValue && destParamValueSize >= srcParamValueSize) {
             // Report ok if we can copy safely
-            retVal = CL_SUCCESS;
+            retVal = GetInfoStatus::SUCCESS;
 
             memcpy_s(destParamValue, destParamValueSize, srcParamValue, srcParamValueSize);
         } else if (!destParamValue) {
             // Report ok if destParamValue == nullptr and destParamValueSize > 0
-            retVal = CL_SUCCESS;
+            retVal = GetInfoStatus::SUCCESS;
         }
     }
 
@@ -35,13 +35,13 @@ inline cl_int getInfo(void *destParamValue, size_t destParamValueSize,
 }
 
 struct GetInfoHelper {
-    GetInfoHelper(void *dst, size_t dstSize, size_t *retSize, cl_int *retVal = nullptr)
+    GetInfoHelper(void *dst, size_t dstSize, size_t *retSize, GetInfoStatus *retVal = nullptr)
         : dst(dst), dstSize(dstSize), retSize(retSize), retVal(retVal) {
     }
 
     template <typename DataType>
-    cl_int set(const DataType &val) {
-        cl_int errCode = CL_SUCCESS;
+    GetInfoStatus set(const DataType &val) {
+        auto errCode = GetInfoStatus::SUCCESS;
         if (retSize != nullptr) {
             *retSize = sizeof(val);
         }
@@ -49,7 +49,7 @@ struct GetInfoHelper {
             if (dstSize >= sizeof(val)) {
                 *reinterpret_cast<DataType *>(dst) = val;
             } else {
-                errCode = CL_INVALID_VALUE;
+                errCode = GetInfoStatus::INVALID_VALUE;
             }
         }
         if (retVal)
@@ -67,24 +67,24 @@ struct GetInfoHelper {
     void *dst;
     size_t dstSize;
     size_t *retSize;
-    cl_int *retVal;
+    GetInfoStatus *retVal;
 };
 
 struct ErrorCodeHelper {
-    ErrorCodeHelper(cl_int *errcodeRet, cl_int defaultCode)
+    ErrorCodeHelper(int *errcodeRet, int defaultCode)
         : errcodeRet(errcodeRet) {
         set(defaultCode);
     }
 
-    void set(cl_int code) {
+    void set(int code) {
         if (errcodeRet != nullptr) {
             *errcodeRet = code;
         }
         localErrcode = code;
     }
 
-    cl_int *errcodeRet;
-    cl_int localErrcode;
+    int *errcodeRet;
+    int localErrcode;
 };
 
 template <typename T>
diff --git a/core/helpers/get_info_status.h b/core/helpers/get_info_status.h
new file mode 100644
index 0000000000..186de309f1
--- /dev/null
+++ b/core/helpers/get_info_status.h
@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+enum class GetInfoStatus {
+    INVALID_CONTEXT = -2,
+    INVALID_VALUE = -1,
+    SUCCESS = 0
+};
diff --git a/runtime/accelerators/intel_accelerator.cpp b/runtime/accelerators/intel_accelerator.cpp
index 349ed599d5..69c1e2ad74 100644
--- a/runtime/accelerators/intel_accelerator.cpp
+++ b/runtime/accelerators/intel_accelerator.cpp
@@ -10,6 +10,7 @@
 #include "core/helpers/get_info.h"
 #include "core/helpers/string.h"
 #include "runtime/context/context.h"
+#include "runtime/helpers/get_info_status_mapper.h"
 
 namespace NEO {
 
@@ -23,7 +24,7 @@ cl_int IntelAccelerator::getInfo(cl_accelerator_info_intel paramName,
     switch (paramName) {
     case CL_ACCELERATOR_DESCRIPTOR_INTEL: {
         ret = getDescriptorSize();
-        result = ::getInfo(paramValue, paramValueSize, getDescriptor(), ret);
+        result = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, getDescriptor(), ret));
     }
 
     break;
@@ -32,7 +33,7 @@ cl_int IntelAccelerator::getInfo(cl_accelerator_info_intel paramName,
         auto v = getReference();
 
         ret = sizeof(cl_uint);
-        result = ::getInfo(paramValue, paramValueSize, &v, ret);
+        result = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, &v, ret));
     }
 
     break;
@@ -40,7 +41,7 @@ cl_int IntelAccelerator::getInfo(cl_accelerator_info_intel paramName,
     case CL_ACCELERATOR_CONTEXT_INTEL: {
         ret = sizeof(cl_context);
         cl_context ctx = static_cast<cl_context>(pContext);
-        result = ::getInfo(paramValue, paramValueSize, &ctx, ret);
+        result = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, &ctx, ret));
     }
 
     break;
@@ -48,7 +49,7 @@ cl_int IntelAccelerator::getInfo(cl_accelerator_info_intel paramName,
     case CL_ACCELERATOR_TYPE_INTEL: {
         auto v = getTypeId();
         ret = sizeof(cl_accelerator_type_intel);
-        result = ::getInfo(paramValue, paramValueSize, &v, ret);
+        result = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, &v, ret));
     }
 
     break;
diff --git a/runtime/api/api.cpp b/runtime/api/api.cpp
index 77628f637f..972151f630 100644
--- a/runtime/api/api.cpp
+++ b/runtime/api/api.cpp
@@ -30,6 +30,7 @@
 #include "runtime/device_queue/device_queue.h"
 #include "runtime/event/user_event.h"
 #include "runtime/gtpin/gtpin_notify.h"
+#include "runtime/helpers/get_info_status_mapper.h"
 #include "runtime/helpers/mem_properties_parser_helper.h"
 #include "runtime/helpers/memory_properties_flags_helpers.h"
 #include "runtime/helpers/queue_helpers.h"
@@ -1868,20 +1869,20 @@ cl_int CL_API_CALL clGetEventInfo(cl_event event,
     //  a nullptr value is returned."
     case CL_EVENT_COMMAND_QUEUE: {
         if (neoEvent->isUserEvent()) {
-            retVal = info.set<cl_command_queue>(nullptr);
+            retVal = changeGetInfoStatusToCLResultType(info.set<cl_command_queue>(nullptr));
             TRACING_EXIT(clGetEventInfo, &retVal);
             return retVal;
         }
-        retVal = info.set<cl_command_queue>(neoEvent->getCommandQueue());
+        retVal = changeGetInfoStatusToCLResultType(info.set<cl_command_queue>(neoEvent->getCommandQueue()));
         TRACING_EXIT(clGetEventInfo, &retVal);
         return retVal;
     }
     case CL_EVENT_CONTEXT:
-        retVal = info.set<cl_context>(neoEvent->getContext());
+        retVal = changeGetInfoStatusToCLResultType(info.set<cl_context>(neoEvent->getContext()));
         TRACING_EXIT(clGetEventInfo, &retVal);
         return retVal;
     case CL_EVENT_COMMAND_TYPE:
-        retVal = info.set<cl_command_type>(neoEvent->getCommandType());
+        retVal = changeGetInfoStatusToCLResultType(info.set<cl_command_type>(neoEvent->getCommandType()));
         TRACING_EXIT(clGetEventInfo, &retVal);
         return retVal;
     case CL_EVENT_COMMAND_EXECUTION_STATUS:
@@ -1895,16 +1896,16 @@ cl_int CL_API_CALL clGetEventInfo(cl_event event,
             if (executionStatus == CL_QUEUED) {
                 executionStatus = CL_SUBMITTED;
             }
-            retVal = info.set<cl_int>(executionStatus);
+            retVal = changeGetInfoStatusToCLResultType(info.set<cl_int>(executionStatus));
             TRACING_EXIT(clGetEventInfo, &retVal);
             return retVal;
         }
 
-        retVal = info.set<cl_int>(neoEvent->updateEventAndReturnCurrentStatus());
+        retVal = changeGetInfoStatusToCLResultType(info.set<cl_int>(neoEvent->updateEventAndReturnCurrentStatus()));
         TRACING_EXIT(clGetEventInfo, &retVal);
         return retVal;
     case CL_EVENT_REFERENCE_COUNT:
-        retVal = info.set<cl_uint>(neoEvent->getReference());
+        retVal = changeGetInfoStatusToCLResultType(info.set<cl_uint>(neoEvent->getReference()));
         TRACING_EXIT(clGetEventInfo, &retVal);
         return retVal;
     }
@@ -3617,34 +3618,34 @@ cl_int clGetMemAllocInfoINTEL(
     switch (paramName) {
     case CL_MEM_ALLOC_TYPE_INTEL: {
         if (!unifiedMemoryAllocation) {
-            retVal = info.set<cl_int>(CL_MEM_TYPE_UNKNOWN_INTEL);
+            retVal = changeGetInfoStatusToCLResultType(info.set<cl_int>(CL_MEM_TYPE_UNKNOWN_INTEL));
             return retVal;
         } else if (unifiedMemoryAllocation->memoryType == InternalMemoryType::HOST_UNIFIED_MEMORY) {
-            retVal = info.set<cl_int>(CL_MEM_TYPE_HOST_INTEL);
+            retVal = changeGetInfoStatusToCLResultType(info.set<cl_int>(CL_MEM_TYPE_HOST_INTEL));
             return retVal;
         } else if (unifiedMemoryAllocation->memoryType == InternalMemoryType::DEVICE_UNIFIED_MEMORY) {
-            retVal = info.set<cl_int>(CL_MEM_TYPE_DEVICE_INTEL);
+            retVal = changeGetInfoStatusToCLResultType(info.set<cl_int>(CL_MEM_TYPE_DEVICE_INTEL));
             return retVal;
         } else {
-            retVal = info.set<cl_int>(CL_MEM_TYPE_SHARED_INTEL);
+            retVal = changeGetInfoStatusToCLResultType(info.set<cl_int>(CL_MEM_TYPE_SHARED_INTEL));
             return retVal;
         }
         break;
     }
     case CL_MEM_ALLOC_BASE_PTR_INTEL: {
-        retVal = info.set<uint64_t>(unifiedMemoryAllocation->gpuAllocation->getGpuAddress());
+        retVal = changeGetInfoStatusToCLResultType(info.set<uint64_t>(unifiedMemoryAllocation->gpuAllocation->getGpuAddress()));
         return retVal;
     }
     case CL_MEM_ALLOC_SIZE_INTEL: {
-        retVal = info.set<size_t>(unifiedMemoryAllocation->size);
+        retVal = changeGetInfoStatusToCLResultType(info.set<size_t>(unifiedMemoryAllocation->size));
         return retVal;
     }
     case CL_MEM_ALLOC_FLAGS_INTEL: {
-        retVal = info.set<cl_mem_alloc_flags_intel>(unifiedMemoryAllocation->allocationFlagsProperty.allAllocFlags);
+        retVal = changeGetInfoStatusToCLResultType(info.set<cl_mem_alloc_flags_intel>(unifiedMemoryAllocation->allocationFlagsProperty.allAllocFlags));
         return retVal;
     }
     case CL_MEM_ALLOC_DEVICE_INTEL: {
-        retVal = info.set<cl_device_id>(static_cast<cl_device_id>(unifiedMemoryAllocation->device));
+        retVal = changeGetInfoStatusToCLResultType(info.set<cl_device_id>(static_cast<cl_device_id>(unifiedMemoryAllocation->device)));
         return retVal;
     }
 
diff --git a/runtime/context/context.cpp b/runtime/context/context.cpp
index d7406034a0..85cd445e03 100644
--- a/runtime/context/context.cpp
+++ b/runtime/context/context.cpp
@@ -21,6 +21,7 @@
 #include "runtime/device/cl_device.h"
 #include "runtime/device_queue/device_queue.h"
 #include "runtime/gtpin/gtpin_notify.h"
+#include "runtime/helpers/get_info_status_mapper.h"
 #include "runtime/helpers/surface_formats.h"
 #include "runtime/mem_obj/image.h"
 #include "runtime/platform/platform.h"
@@ -241,7 +242,7 @@ cl_int Context::getInfo(cl_context_info paramName, size_t paramValueSize,
     }
 
     if (callGetinfo) {
-        retVal = ::getInfo(paramValue, paramValueSize, pValue, valueSize);
+        retVal = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, pValue, valueSize));
     } else {
         retVal = CL_SUCCESS;
     }
diff --git a/runtime/device/device_info.cpp b/runtime/device/device_info.cpp
index b91e8f3565..eca1ff7dfb 100644
--- a/runtime/device/device_info.cpp
+++ b/runtime/device/device_info.cpp
@@ -14,6 +14,7 @@
 #include "runtime/device/cl_device_vector.h"
 #include "runtime/device/device_info_map.h"
 #include "runtime/helpers/cl_device_helpers.h"
+#include "runtime/helpers/get_info_status_mapper.h"
 #include "runtime/platform/platform.h"
 
 using DeviceInfoTable::Map;
@@ -189,7 +190,7 @@ cl_int ClDevice::getDeviceInfo(cl_device_info paramName,
         ClDeviceHelper::getExtraDeviceInfo(*this, paramName, param, src, srcSize, retSize);
     }
 
-    retVal = ::getInfo(paramValue, paramValueSize, src, srcSize);
+    retVal = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, src, srcSize));
 
     if (paramValueSizeRet) {
         *paramValueSizeRet = retSize;
diff --git a/runtime/event/event.cpp b/runtime/event/event.cpp
index 7ecc6c4876..0cd761a252 100644
--- a/runtime/event/event.cpp
+++ b/runtime/event/event.cpp
@@ -22,6 +22,7 @@
 #include "runtime/event/async_events_handler.h"
 #include "runtime/event/event_tracker.h"
 #include "runtime/extensions/public/cl_ext_private.h"
+#include "runtime/helpers/get_info_status_mapper.h"
 #include "runtime/helpers/hardware_commands_helper.h"
 #include "runtime/mem_obj/mem_obj.h"
 #include "runtime/platform/platform.h"
@@ -209,7 +210,7 @@ cl_int Event::getEventProfilingInfo(cl_profiling_info paramName,
         return CL_INVALID_VALUE;
     }
 
-    retVal = ::getInfo(paramValue, paramValueSize, src, srcSize);
+    retVal = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, src, srcSize));
 
     if (paramValueSizeRet) {
         *paramValueSizeRet = srcSize;
diff --git a/runtime/helpers/CMakeLists.txt b/runtime/helpers/CMakeLists.txt
index 64173f16e4..02a1ef195b 100644
--- a/runtime/helpers/CMakeLists.txt
+++ b/runtime/helpers/CMakeLists.txt
@@ -20,6 +20,7 @@ set(RUNTIME_SRCS_HELPERS_BASE
   ${CMAKE_CURRENT_SOURCE_DIR}/enable_product.inl
   ${CMAKE_CURRENT_SOURCE_DIR}/enqueue_properties.h
   ${CMAKE_CURRENT_SOURCE_DIR}/error_mappers.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/get_info_status_mapper.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hardware_commands_helper.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hardware_commands_helper.inl
   ${CMAKE_CURRENT_SOURCE_DIR}/hardware_commands_helper_base.inl
diff --git a/runtime/helpers/get_info_status_mapper.h b/runtime/helpers/get_info_status_mapper.h
new file mode 100644
index 0000000000..293d65032c
--- /dev/null
+++ b/runtime/helpers/get_info_status_mapper.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "core/helpers/get_info_status.h"
+
+#include <CL/cl.h>
+
+#include <cassert>
+
+static inline cl_int changeGetInfoStatusToCLResultType(GetInfoStatus status) {
+    switch (status) {
+    case GetInfoStatus::SUCCESS:
+        return CL_SUCCESS;
+
+    case GetInfoStatus::INVALID_CONTEXT:
+        return CL_INVALID_CONTEXT;
+
+    case GetInfoStatus::INVALID_VALUE:
+        return CL_INVALID_VALUE;
+    }
+
+    return CL_INVALID_VALUE;
+}
diff --git a/runtime/helpers/queue_helpers.h b/runtime/helpers/queue_helpers.h
index 973617480a..ffa0750c05 100644
--- a/runtime/helpers/queue_helpers.h
+++ b/runtime/helpers/queue_helpers.h
@@ -11,6 +11,7 @@
 #include "runtime/command_queue/command_queue.h"
 #include "runtime/device/cl_device.h"
 #include "runtime/device_queue/device_queue.h"
+#include "runtime/helpers/get_info_status_mapper.h"
 
 namespace NEO {
 
@@ -54,32 +55,32 @@ cl_int getQueueInfo(QueueType *queue,
                     size_t paramValueSize,
                     void *paramValue,
                     size_t *paramValueSizeRet) {
-    cl_int retVal = CL_SUCCESS;
 
-    GetInfoHelper getInfoHelper(paramValue, paramValueSize, paramValueSizeRet, &retVal);
+    cl_int retVal = CL_SUCCESS;
+    GetInfoHelper getInfoHelper(paramValue, paramValueSize, paramValueSizeRet);
 
     switch (paramName) {
     case CL_QUEUE_CONTEXT:
-        getInfoHelper.set<cl_context>(&queue->getContext());
+        retVal = changeGetInfoStatusToCLResultType(getInfoHelper.set<cl_context>(&queue->getContext()));
         break;
     case CL_QUEUE_DEVICE: {
         Device &device = queue->getDevice();
-        getInfoHelper.set<cl_device_id>(device.getSpecializedDevice<ClDevice>());
+        retVal = changeGetInfoStatusToCLResultType(getInfoHelper.set<cl_device_id>(device.getSpecializedDevice<ClDevice>()));
         break;
     }
     case CL_QUEUE_REFERENCE_COUNT:
-        getInfoHelper.set<cl_int>(queue->getReference());
+        retVal = changeGetInfoStatusToCLResultType(getInfoHelper.set<cl_int>(queue->getReference()));
         break;
     case CL_QUEUE_PROPERTIES:
-        getInfoHelper.set<cl_command_queue_properties>(queue->getCommandQueueProperties());
+        retVal = changeGetInfoStatusToCLResultType(getInfoHelper.set<cl_command_queue_properties>(queue->getCommandQueueProperties()));
         break;
     case CL_QUEUE_DEVICE_DEFAULT:
-        getInfoHelper.set<cl_command_queue>(queue->getContext().getDefaultDeviceQueue());
+        retVal = changeGetInfoStatusToCLResultType(getInfoHelper.set<cl_command_queue>(queue->getContext().getDefaultDeviceQueue()));
         break;
     case CL_QUEUE_SIZE:
         if (std::is_same<QueueType, class DeviceQueue>::value) {
             auto devQ = reinterpret_cast<DeviceQueue *>(queue);
-            getInfoHelper.set<cl_uint>(devQ->getQueueSize());
+            retVal = changeGetInfoStatusToCLResultType(getInfoHelper.set<cl_uint>(devQ->getQueueSize()));
             break;
         }
         retVal = CL_INVALID_VALUE;
diff --git a/runtime/kernel/kernel.cpp b/runtime/kernel/kernel.cpp
index 655416e499..3a4e6c2415 100644
--- a/runtime/kernel/kernel.cpp
+++ b/runtime/kernel/kernel.cpp
@@ -31,6 +31,7 @@
 #include "runtime/execution_model/device_enqueue.h"
 #include "runtime/gtpin/gtpin_notify.h"
 #include "runtime/helpers/dispatch_info.h"
+#include "runtime/helpers/get_info_status_mapper.h"
 #include "runtime/helpers/per_thread_data.h"
 #include "runtime/helpers/sampler_helpers.h"
 #include "runtime/helpers/surface_formats.h"
@@ -498,7 +499,7 @@ cl_int Kernel::getInfo(cl_kernel_info paramName, size_t paramValueSize,
         break;
     }
 
-    retVal = ::getInfo(paramValue, paramValueSize, pSrc, srcSize);
+    retVal = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, pSrc, srcSize));
 
     if (paramValueSizeRet) {
         *paramValueSizeRet = srcSize;
@@ -557,7 +558,7 @@ cl_int Kernel::getArgInfo(cl_uint argIndx, cl_kernel_arg_info paramName, size_t
         break;
     }
 
-    retVal = ::getInfo(paramValue, paramValueSize, pSrc, srcSize);
+    retVal = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, pSrc, srcSize));
 
     if (paramValueSizeRet) {
         *paramValueSizeRet = srcSize;
@@ -589,7 +590,7 @@ cl_int Kernel::getWorkGroupInfo(cl_device_id device, cl_kernel_work_group_info p
             auto divisionSize = 32 / patchInfo.executionEnvironment->LargestCompiledSIMDSize;
             maxWorkgroupSize /= divisionSize;
         }
-        retVal = info.set<size_t>(maxWorkgroupSize);
+        retVal = changeGetInfoStatusToCLResultType(info.set<size_t>(maxWorkgroupSize));
         break;
 
     case CL_KERNEL_COMPILE_WORK_GROUP_SIZE:
@@ -597,29 +598,29 @@ cl_int Kernel::getWorkGroupInfo(cl_device_id device, cl_kernel_work_group_info p
         requiredWorkGroupSize.val[0] = patchInfo.executionEnvironment->RequiredWorkGroupSizeX;
         requiredWorkGroupSize.val[1] = patchInfo.executionEnvironment->RequiredWorkGroupSizeY;
         requiredWorkGroupSize.val[2] = patchInfo.executionEnvironment->RequiredWorkGroupSizeZ;
-        retVal = info.set<size_t3>(requiredWorkGroupSize);
+        retVal = changeGetInfoStatusToCLResultType(info.set<size_t3>(requiredWorkGroupSize));
         break;
 
     case CL_KERNEL_LOCAL_MEM_SIZE:
         localMemorySize = patchInfo.localsurface
                               ? patchInfo.localsurface->TotalInlineLocalMemorySize
                               : 0;
-        retVal = info.set<cl_ulong>(localMemorySize);
+        retVal = changeGetInfoStatusToCLResultType(info.set<cl_ulong>(localMemorySize));
         break;
 
     case CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE:
         DEBUG_BREAK_IF(!patchInfo.executionEnvironment);
         preferredWorkGroupSizeMultiple = patchInfo.executionEnvironment->LargestCompiledSIMDSize;
-        retVal = info.set<size_t>(preferredWorkGroupSizeMultiple);
+        retVal = changeGetInfoStatusToCLResultType((info.set<size_t>(preferredWorkGroupSizeMultiple)));
         break;
 
     case CL_KERNEL_SPILL_MEM_SIZE_INTEL:
         scratchSize = kernelInfo.patchInfo.mediavfestate ? kernelInfo.patchInfo.mediavfestate->PerThreadScratchSpace : 0;
-        retVal = info.set<cl_ulong>(scratchSize);
+        retVal = changeGetInfoStatusToCLResultType(info.set<cl_ulong>(scratchSize));
         break;
     case CL_KERNEL_PRIVATE_MEM_SIZE:
         privateMemSize = kernelInfo.patchInfo.pAllocateStatelessPrivateSurface ? kernelInfo.patchInfo.pAllocateStatelessPrivateSurface->PerThreadPrivateMemorySize : 0;
-        retVal = info.set<cl_ulong>(privateMemSize);
+        retVal = changeGetInfoStatusToCLResultType(info.set<cl_ulong>(privateMemSize));
         break;
     default:
         retVal = CL_INVALID_VALUE;
@@ -683,14 +684,14 @@ cl_int Kernel::getSubGroupInfo(cl_kernel_sub_group_info paramName,
         for (size_t i = 0; i < numDimensions; i++) {
             WGS *= ((size_t *)inputValue)[i];
         }
-        return info.set<size_t>(std::min(WGS, maxSimdSize));
+        return changeGetInfoStatusToCLResultType(info.set<size_t>(std::min(WGS, maxSimdSize)));
     }
     case CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR: {
         for (size_t i = 0; i < numDimensions; i++) {
             WGS *= ((size_t *)inputValue)[i];
         }
-        return info.set<size_t>((WGS / maxSimdSize) +
-                                std::min(static_cast<size_t>(1), WGS % maxSimdSize)); // add 1 if WGS % maxSimdSize != 0
+        return changeGetInfoStatusToCLResultType(
+            info.set<size_t>((WGS / maxSimdSize) + std::min(static_cast<size_t>(1), WGS % maxSimdSize))); // add 1 if WGS % maxSimdSize != 0
     }
     case CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT: {
         auto subGroupsNum = *(size_t *)inputValue;
@@ -702,14 +703,14 @@ cl_int Kernel::getSubGroupInfo(cl_kernel_sub_group_info paramName,
         // If no work group size can accommodate the requested number of subgroups, return 0 in each element of the returned array.
         switch (numDimensions) {
         case 1:
-            return info.set<size_t>(workGroupSize);
+            return changeGetInfoStatusToCLResultType(info.set<size_t>(workGroupSize));
         case 2:
             struct size_t2 {
                 size_t val[2];
             } workGroupSize2;
             workGroupSize2.val[0] = workGroupSize;
             workGroupSize2.val[1] = (workGroupSize > 0) ? 1 : 0;
-            return info.set<size_t2>(workGroupSize2);
+            return changeGetInfoStatusToCLResultType(info.set<size_t2>(workGroupSize2));
         case 3:
         default:
             struct size_t3 {
@@ -718,18 +719,18 @@ cl_int Kernel::getSubGroupInfo(cl_kernel_sub_group_info paramName,
             workGroupSize3.val[0] = workGroupSize;
             workGroupSize3.val[1] = (workGroupSize > 0) ? 1 : 0;
             workGroupSize3.val[2] = (workGroupSize > 0) ? 1 : 0;
-            return info.set<size_t3>(workGroupSize3);
+            return changeGetInfoStatusToCLResultType(info.set<size_t3>(workGroupSize3));
         }
     }
     case CL_KERNEL_MAX_NUM_SUB_GROUPS: {
         // round-up maximum number of subgroups
-        return info.set<size_t>(Math::divideAndRoundUp(maxRequiredWorkGroupSize, largestCompiledSIMDSize));
+        return changeGetInfoStatusToCLResultType(info.set<size_t>(Math::divideAndRoundUp(maxRequiredWorkGroupSize, largestCompiledSIMDSize)));
     }
     case CL_KERNEL_COMPILE_NUM_SUB_GROUPS: {
-        return info.set<size_t>(static_cast<size_t>(getKernelInfo().patchInfo.executionEnvironment->CompiledSubGroupsNumber));
+        return changeGetInfoStatusToCLResultType(info.set<size_t>(static_cast<size_t>(getKernelInfo().patchInfo.executionEnvironment->CompiledSubGroupsNumber)));
     }
     case CL_KERNEL_COMPILE_SUB_GROUP_SIZE_INTEL: {
-        return info.set<size_t>(getKernelInfo().requiredSubGroupSize);
+        return changeGetInfoStatusToCLResultType(info.set<size_t>(getKernelInfo().requiredSubGroupSize));
     }
     default:
         return CL_INVALID_VALUE;
diff --git a/runtime/mem_obj/image.cpp b/runtime/mem_obj/image.cpp
index ea6310daac..5c46f4e322 100644
--- a/runtime/mem_obj/image.cpp
+++ b/runtime/mem_obj/image.cpp
@@ -23,6 +23,7 @@
 #include "runtime/command_queue/command_queue.h"
 #include "runtime/context/context.h"
 #include "runtime/device/cl_device.h"
+#include "runtime/helpers/get_info_status_mapper.h"
 #include "runtime/helpers/memory_properties_flags_helpers.h"
 #include "runtime/helpers/mipmap.h"
 #include "runtime/helpers/surface_formats.h"
@@ -864,7 +865,7 @@ cl_int Image::getImageInfo(cl_image_info paramName,
         break;
     }
 
-    retVal = ::getInfo(paramValue, paramValueSize, srcParam, srcParamSize);
+    retVal = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, srcParam, srcParamSize));
 
     if (paramValueSizeRet) {
         *paramValueSizeRet = srcParamSize;
diff --git a/runtime/mem_obj/mem_obj.cpp b/runtime/mem_obj/mem_obj.cpp
index 5522533f90..dc0022ce0e 100644
--- a/runtime/mem_obj/mem_obj.cpp
+++ b/runtime/mem_obj/mem_obj.cpp
@@ -20,6 +20,7 @@
 #include "runtime/command_stream/command_stream_receiver.h"
 #include "runtime/context/context.h"
 #include "runtime/device/cl_device.h"
+#include "runtime/helpers/get_info_status_mapper.h"
 
 #include <algorithm>
 
@@ -188,7 +189,7 @@ cl_int MemObj::getMemObjectInfo(cl_mem_info paramName,
         break;
     }
 
-    retVal = ::getInfo(paramValue, paramValueSize, srcParam, srcParamSize);
+    retVal = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, srcParam, srcParamSize));
 
     if (paramValueSizeRet) {
         *paramValueSizeRet = srcParamSize;
diff --git a/runtime/mem_obj/pipe.cpp b/runtime/mem_obj/pipe.cpp
index b546530cc1..db35b38633 100644
--- a/runtime/mem_obj/pipe.cpp
+++ b/runtime/mem_obj/pipe.cpp
@@ -11,6 +11,7 @@
 #include "core/memory_manager/memory_manager.h"
 #include "runtime/context/context.h"
 #include "runtime/device/cl_device.h"
+#include "runtime/helpers/get_info_status_mapper.h"
 #include "runtime/helpers/memory_properties_flags_helpers.h"
 #include "runtime/mem_obj/mem_obj_helper.h"
 
@@ -104,7 +105,7 @@ cl_int Pipe::getPipeInfo(cl_image_info paramName,
         break;
     }
 
-    retVal = ::getInfo(paramValue, paramValueSize, srcParam, srcParamSize);
+    retVal = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, srcParam, srcParamSize));
 
     if (paramValueSizeRet) {
         *paramValueSizeRet = srcParamSize;
diff --git a/runtime/platform/platform.cpp b/runtime/platform/platform.cpp
index 0bf186f03d..17b27400d6 100644
--- a/runtime/platform/platform.cpp
+++ b/runtime/platform/platform.cpp
@@ -25,6 +25,7 @@
 #include "runtime/event/async_events_handler.h"
 #include "runtime/gtpin/gtpin_notify.h"
 #include "runtime/helpers/built_ins_helper.h"
+#include "runtime/helpers/get_info_status_mapper.h"
 #include "runtime/platform/extensions.h"
 #include "runtime/sharings/sharing_factory.h"
 #include "runtime/source_level_debugger/source_level_debugger.h"
@@ -85,7 +86,7 @@ cl_int Platform::getInfo(cl_platform_info paramName,
     case CL_PLATFORM_HOST_TIMER_RESOLUTION:
         pVal = static_cast<uint64_t>(this->clDevices[0]->getPlatformHostTimerResolution());
         paramSize = sizeof(uint64_t);
-        retVal = ::getInfo(paramValue, paramValueSize, &pVal, paramSize);
+        retVal = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, &pVal, paramSize));
         break;
     case CL_PLATFORM_PROFILE:
         param = &platformInfo->profile;
@@ -112,7 +113,7 @@ cl_int Platform::getInfo(cl_platform_info paramName,
     // Case for string parameters
     if (param) {
         paramSize = param->length() + 1;
-        retVal = ::getInfo(paramValue, paramValueSize, param->c_str(), paramSize);
+        retVal = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, param->c_str(), paramSize));
     }
 
     if (paramValueSizeRet) {
diff --git a/runtime/program/get_info.cpp b/runtime/program/get_info.cpp
index c1e6270215..2b51abe74d 100644
--- a/runtime/program/get_info.cpp
+++ b/runtime/program/get_info.cpp
@@ -11,6 +11,7 @@
 #include "runtime/context/context.h"
 #include "runtime/device/cl_device.h"
 #include "runtime/helpers/base_object.h"
+#include "runtime/helpers/get_info_status_mapper.h"
 #include "runtime/helpers/validators.h"
 #include "runtime/program/kernel_info.h"
 
@@ -141,7 +142,7 @@ cl_int Program::getInfo(cl_program_info paramName, size_t paramValueSize,
     }
 
     retVal = (retVal == CL_SUCCESS)
-                 ? ::getInfo(paramValue, paramValueSize, pSrc, srcSize)
+                 ? changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, pSrc, srcSize))
                  : retVal;
     if (paramValueSizeRet) {
         *paramValueSizeRet = retSize;
@@ -202,7 +203,7 @@ cl_int Program::getBuildInfo(cl_device_id device, cl_program_build_info paramNam
     }
 
     retVal = (retVal == CL_SUCCESS)
-                 ? ::getInfo(paramValue, paramValueSize, pSrc, srcSize)
+                 ? changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, pSrc, srcSize))
                  : retVal;
 
     if (paramValueSizeRet) {
diff --git a/runtime/sampler/sampler.cpp b/runtime/sampler/sampler.cpp
index 18543a17bd..831c3a20ad 100644
--- a/runtime/sampler/sampler.cpp
+++ b/runtime/sampler/sampler.cpp
@@ -11,6 +11,7 @@
 #include "core/helpers/hw_info.h"
 #include "runtime/context/context.h"
 #include "runtime/device/cl_device.h"
+#include "runtime/helpers/get_info_status_mapper.h"
 
 #include "patch_list.h"
 
@@ -211,7 +212,7 @@ cl_int Sampler::getInfo(cl_sampler_info paramName, size_t paramValueSize,
         break;
     }
 
-    retVal = ::getInfo(paramValue, paramValueSize, pValue, valueSize);
+    retVal = changeGetInfoStatusToCLResultType(::getInfo(paramValue, paramValueSize, pValue, valueSize));
 
     if (paramValueSizeRet) {
         *paramValueSizeRet = valueSize;
diff --git a/unit_tests/helpers/CMakeLists.txt b/unit_tests/helpers/CMakeLists.txt
index bfa442918e..dfd8c8fe38 100644
--- a/unit_tests/helpers/CMakeLists.txt
+++ b/unit_tests/helpers/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2017-2019 Intel Corporation
+# Copyright (C) 2017-2020 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -24,6 +24,7 @@ set(IGDRCL_SRCS_tests_helpers
   ${CMAKE_CURRENT_SOURCE_DIR}/flush_stamp_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/get_gpgpu_engines_tests.inl
   ${CMAKE_CURRENT_SOURCE_DIR}/get_info_tests.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/get_info_status_mapper_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/gtest_helpers.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hardware_commands_helper_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/hardware_commands_helper_tests.h
diff --git a/unit_tests/helpers/get_info_status_mapper_tests.cpp b/unit_tests/helpers/get_info_status_mapper_tests.cpp
new file mode 100644
index 0000000000..73fac6eb65
--- /dev/null
+++ b/unit_tests/helpers/get_info_status_mapper_tests.cpp
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "runtime/helpers/get_info_status_mapper.h"
+
+#include "gtest/gtest.h"
+
+TEST(getInfoStatusMapper, GivenValidGetInfoStatusReturnExpectedCLCode) {
+    auto getInfoStatus = changeGetInfoStatusToCLResultType(GetInfoStatus::SUCCESS);
+    EXPECT_EQ(CL_SUCCESS, getInfoStatus);
+
+    getInfoStatus = changeGetInfoStatusToCLResultType(GetInfoStatus::INVALID_CONTEXT);
+    EXPECT_EQ(CL_INVALID_CONTEXT, getInfoStatus);
+
+    getInfoStatus = changeGetInfoStatusToCLResultType(GetInfoStatus::INVALID_VALUE);
+    EXPECT_EQ(CL_INVALID_VALUE, getInfoStatus);
+}
+
+TEST(getInfoStatusMapper, GivenInvalidGetStatusReturnCLInvalidValue) {
+    auto getInfoStatus = changeGetInfoStatusToCLResultType(static_cast<GetInfoStatus>(1));
+    EXPECT_EQ(CL_INVALID_VALUE, getInfoStatus);
+}
diff --git a/unit_tests/helpers/get_info_tests.cpp b/unit_tests/helpers/get_info_tests.cpp
index 90c1bbb133..cb07d0ec12 100644
--- a/unit_tests/helpers/get_info_tests.cpp
+++ b/unit_tests/helpers/get_info_tests.cpp
@@ -14,7 +14,7 @@ TEST(getInfo, valid_params_returnsSuccess) {
     float src = 1.0f;
 
     auto retVal = getInfo(&dest, sizeof(dest), &src, sizeof(src));
-    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_EQ(GetInfoStatus::SUCCESS, retVal);
     EXPECT_EQ(src, dest);
 }
 
@@ -23,7 +23,7 @@ TEST(getInfo, null_param_and_param_size_too_small_returnsSuccess) {
     float src = 1.0f;
 
     auto retVal = getInfo(nullptr, 0, &src, sizeof(src));
-    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_EQ(GetInfoStatus::SUCCESS, retVal);
     EXPECT_NE(src, dest);
 }
 
@@ -32,7 +32,7 @@ TEST(getInfo, GivenNullPtrAsValueAndNonZeroSizeWhenAskedForGetInfoThenSuccessIsR
     float src = 1.0f;
 
     auto retVal = getInfo(nullptr, sizeof(dest), &src, sizeof(src));
-    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_EQ(GetInfoStatus::SUCCESS, retVal);
     EXPECT_NE(src, dest);
 }
 
@@ -41,7 +41,7 @@ TEST(getInfo, param_size_too_small_returnsError) {
     float src = 1.0f;
 
     auto retVal = getInfo(&dest, 0, &src, sizeof(src));
-    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+    EXPECT_EQ(GetInfoStatus::INVALID_VALUE, retVal);
     EXPECT_NE(src, dest);
 }
 
@@ -50,7 +50,7 @@ TEST(getInfo, null_src_param_returnsError) {
     float src = 1.0f;
 
     auto retVal = getInfo(&dest, sizeof(dest), nullptr, sizeof(src));
-    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+    EXPECT_EQ(GetInfoStatus::INVALID_VALUE, retVal);
     EXPECT_NE(src, dest);
 }
 
@@ -59,10 +59,18 @@ TEST(getInfo, zero_src_param_size_returnsError) {
     float src = 1.0f;
 
     auto retVal = getInfo(&dest, sizeof(dest), &src, 0);
-    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+    EXPECT_EQ(GetInfoStatus::INVALID_VALUE, retVal);
     EXPECT_NE(src, dest);
 }
 
+TEST(getInfoHelper, GivenInstanceOfGetInfoHelperAndNullPtrParamsSuccessIsReturned) {
+    GetInfoStatus retVal;
+    GetInfoHelper info(nullptr, 0, nullptr, &retVal);
+
+    info.set(1);
+    EXPECT_EQ(GetInfoStatus::SUCCESS, retVal);
+}
+
 TEST(getInfoHelper, staticSetter) {
     uint32_t *getValue = nullptr;
     uint32_t expectedValue = 1;
@@ -79,12 +87,12 @@ TEST(getInfoHelper, staticSetter) {
 }
 
 TEST(errorCodeHelper, localVariable) {
-    cl_int errCode = CL_SUCCESS;
-    ErrorCodeHelper err(&errCode, CL_INVALID_VALUE);
-    EXPECT_EQ(CL_INVALID_VALUE, errCode);
-    EXPECT_EQ(CL_INVALID_VALUE, err.localErrcode);
+    int errCode = 0;
+    ErrorCodeHelper err(&errCode, 1);
+    EXPECT_EQ(1, errCode);
+    EXPECT_EQ(1, err.localErrcode);
 
-    err.set(CL_INVALID_CONTEXT);
-    EXPECT_EQ(CL_INVALID_CONTEXT, errCode);
-    EXPECT_EQ(CL_INVALID_CONTEXT, err.localErrcode);
+    err.set(2);
+    EXPECT_EQ(2, errCode);
+    EXPECT_EQ(2, err.localErrcode);
 }