/*
 * Copyright (c) Advanced Micro Devices, Inc., or its affiliates.
 *
 * SPDX-License-Identifier: MIT
 */

#include <hip_test_common.hh>
#include <hip_test_checkers.hh>
#include <fstream>
#include <vector>

#ifdef __linux__
#include <unistd.h>
#include <sys/mman.h>
#include <sys/wait.h>

// Common Definitions and Macros
#if HT_AMD
static const char* visibility_env_var = "HIP_VISIBLE_DEVICES";
#else
static const char* visibility_env_var = "CUDA_VISIBLE_DEVICES";
#endif

#define UNUSED(expr)                                                                               \
  do {                                                                                             \
    (void)(expr);                                                                                  \
  } while (0)

void Callback(hipStream_t stream, hipError_t status, void* userData) {
  UNUSED(stream);
  HIP_CHECK(status);
  REQUIRE(userData == NULL);
}

// Dummy RTC function
static constexpr auto rtcfn{
    R"(
extern "C"
__global__ void fn()
{
}
)"};

// Dummy Kernel Function
static __global__ void fn() {}

// No GPU test case for hipGetDeviceCount
static bool NoGpuTst_hipGetDeviceCount() {
  bool passed = false;
  hipError_t err;
  int nGpus = 0;
  err = hipGetDeviceCount(&nGpus);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipGetDeviceCount: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipSetDevice
static bool NoGpuTst_hipSetDevice() {
  bool passed = false;
  hipError_t err;
  err = hipSetDevice(0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipSetDevice: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipDeviceGetAttribute
static bool NoGpuTst_hipDeviceGetAttribute() {
  bool passed = false;
  hipError_t err;
  int pi = 0;
  hipDeviceAttribute_t attr = hipDeviceAttributeCudaCompatibleBegin;
  err = hipDeviceGetAttribute(&pi, attr, 0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceGetAttribute: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipDeviceGetP2PAttribute
static bool NoGpuTst_hipDeviceGetP2PAttribute() {
  bool passed = false;
  hipError_t err;
  int srcDevice = 0, dstDevice = 1;
  int value{-1};
  err = hipDeviceGetP2PAttribute(&value, hipDevP2PAttrPerformanceRank, srcDevice, dstDevice);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceGetP2PAttribute: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipDeviceGetPCIBusId
static bool NoGpuTst_hipDeviceGetPCIBusId() {
  bool passed = false;
  hipError_t err;
  int device = 0;
  char pciBusId[128];
  err = hipDeviceGetPCIBusId(pciBusId, 128, device);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceGetPCIBusId: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipDeviceGetByPCIBusId
static bool NoGpuTst_hipDeviceGetByPCIBusId() {
  bool passed = false;
  hipError_t err;
  int device = 0;
  char pciBusId[128];
  err = hipDeviceGetByPCIBusId(&device, pciBusId);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceGetByPCIBusId: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipDeviceTotalMem
static bool NoGpuTst_hipDeviceTotalMem() {
  bool passed = false;
  hipError_t err, err_exp;
#if HT_AMD
  err_exp = hipErrorNoDevice;
#else
  err_exp = hipErrorNotInitialized;
#endif
  int device = 0;
  size_t bytes = 0;
  err = hipDeviceTotalMem(&bytes, device);
  if (err == err_exp) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceTotalMem: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipFuncSetSharedMemConfig
static bool NoGpuTst_hipFuncSetSharedMemConfig() {
  bool passed = false;
  hipError_t err;
  err = hipFuncSetSharedMemConfig(reinterpret_cast<const void*>(&fn), hipSharedMemBankSizeDefault);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipFuncSetSharedMemConfig: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipStreamCreate
static bool NoGpuTst_hipStreamCreate() {
  bool passed = false;
  hipError_t err;
  hipStream_t stream = nullptr;
  err = hipStreamCreate(&stream);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipStreamCreate: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipStreamCreateWithPriority
static bool NoGpuTst_hipStreamCreateWithPriority() {
  bool passed = false;
  hipError_t err;
  hipStream_t mystream = nullptr;
  err = hipStreamCreateWithPriority(&mystream, 0, 0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipStreamCreateWithPriority: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipStreamSynchronize
static bool NoGpuTst_hipStreamSynchronize() {
  bool passed = false;
  hipError_t err;
  err = hipStreamSynchronize(0);  // sync with null stream
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipStreamSynchronize: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipStreamGetFlags
static bool NoGpuTst_hipStreamGetFlags() {
  bool passed = false;
  hipError_t err;
  unsigned int flags = 0;
  err = hipStreamGetFlags(0, &flags);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipStreamGetFlags: " << hipGetErrorName(err));
  }
  return passed;
}
#if HT_AMD
// No GPU test case for hipExtStreamCreateWithCUMask
static bool NoGpuTst_hipExtStreamCreateWithCUMask() {
  bool passed = false;
  hipError_t err;
  hipStream_t mystream = nullptr;
  uint32_t cuMaskSize = 0;
  const uint32_t cuMask = 0;
  err = hipExtStreamCreateWithCUMask(&mystream, cuMaskSize, &cuMask);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipExtStreamCreateWithCUMask: " << hipGetErrorName(err));
  }
  return passed;
}
#endif
// No GPU test case for hipStreamAddCallback
static bool NoGpuTst_hipStreamAddCallback() {
  bool passed = false;
  hipError_t err;
  void* userData = NULL;
  unsigned int flags = 0;
  err = hipStreamAddCallback(0, Callback, userData, flags);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipStreamAddCallback: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipEventCreateWithFlags
static bool NoGpuTst_hipEventCreateWithFlags() {
  bool passed = false;
  hipError_t err;
  hipEvent_t event = 0;
  err = hipEventCreateWithFlags(&event, hipEventDefault);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipEventCreateWithFlags: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipDeviceSynchronize
static bool NoGpuTst_hipDeviceSynchronize() {
  bool passed = false;
  hipError_t err;
  err = hipDeviceSynchronize();
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceSynchronize: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipGetDevice
static bool NoGpuTst_hipGetDevice() {
  bool passed = false;
  hipError_t err;
  int deviceId = 0;
  err = hipGetDevice(&deviceId);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipGetDevice: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipDeviceGetCacheConfig
static bool NoGpuTst_hipDeviceGetCacheConfig() {
  bool passed = false;
  hipError_t err;
  hipFuncCache_t cacheConfig = hipFuncCachePreferNone;
  err = hipDeviceGetCacheConfig(&cacheConfig);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceGetCacheConfig: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipDeviceGetSharedMemConfig
static bool NoGpuTst_hipDeviceGetSharedMemConfig() {
  bool passed = false;
  hipError_t err;
  hipSharedMemConfig pConfig = hipSharedMemBankSizeDefault;
  err = hipDeviceGetSharedMemConfig(&pConfig);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceGetSharedMemConfig: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipDeviceSetSharedMemConfig
static bool NoGpuTst_hipDeviceSetSharedMemConfig() {
  bool passed = false;
  hipError_t err;
  hipSharedMemConfig pConfig = hipSharedMemBankSizeDefault;
  err = hipDeviceSetSharedMemConfig(pConfig);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceSetSharedMemConfig: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipPointerGetAttributes
static bool NoGpuTst_hipPointerGetAttributes() {
  bool passed = false;
  hipError_t err;
  hipPointerAttribute_t attributes = {};
  char* A_d = nullptr;
  err = hipPointerGetAttributes(&attributes, A_d);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipPointerGetAttributes: " << hipGetErrorName(err));
  }
  return passed;
}
#if HT_AMD
// No GPU test case for hipExtMallocWithFlags
static bool NoGpuTst_hipExtMallocWithFlags() {
  bool passed = false;
  hipError_t err;
  int* Ptr = nullptr;
  unsigned int flags = 0;
  err = hipExtMallocWithFlags(reinterpret_cast<void**>(Ptr), 128, flags);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipExtMallocWithFlags: " << hipGetErrorName(err));
  }
  return passed;
}
#endif
// No GPU test case for hipMallocManaged
static bool NoGpuTst_hipMallocManaged() {
  bool passed = false;
  hipError_t err;
  float* dev_ptr;
  err = hipMallocManaged(&dev_ptr, 128, hipMemAttachGlobal);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipMallocManaged: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipHostFree
static bool NoGpuTst_hipHostFree() {
  bool passed = false;
  hipError_t err;
  void* ptr1 = nullptr;
  err = hipHostFree(ptr1);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipHostFree: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test case for hipMemcpyWithStream
static bool NoGpuTst_hipMemcpyWithStream() {
  bool passed = false;
  hipError_t err;
  int *A_h, *B_h;
  A_h = reinterpret_cast<int*>(malloc(sizeof(int)));
  REQUIRE(A_h != nullptr);
  B_h = reinterpret_cast<int*>(malloc(sizeof(int)));
  REQUIRE(B_h != nullptr);
  err = hipMemcpyWithStream(A_h, B_h, 128, hipMemcpyHostToHost, 0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipMemcpyWithStream: " << hipGetErrorName(err));
  }
  free(A_h);
  free(B_h);
  return passed;
}

#if HT_AMD
// No GPU test case for hipMallocMipmappedArray
static bool NoGpuTst_hipMallocMipmappedArray() {
  bool passed = false;
  hipError_t err;
  hipMipmappedArray_t mipmappedArray{};
  hipExtent extent;
  hipChannelFormatDesc desc = hipCreateChannelDesc<int>();
  err = hipMallocMipmappedArray(&mipmappedArray, &desc, extent, 0, 0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipMallocMipmappedArray: " << hipGetErrorName(err));
  }
  return passed;
}
#endif
// No GPU test case for hipDeviceEnablePeerAccess
static bool NoGpuTst_hipDeviceEnablePeerAccess() {
  bool passed = false;
  hipError_t err;
  int peerDeviceId = 0;
  err = hipDeviceEnablePeerAccess(peerDeviceId, 0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceEnablePeerAccess: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipHostMalloc() API
static bool NoGpuTst_hipHostMalloc() {
  bool passed = false;
  hipError_t err;
  int* ptr;
  size_t size = 1024;
  unsigned int flag = hipHostMallocDefault;
  err = hipHostMalloc(&ptr, size, flag);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipHostMalloc: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipMalloc() API
static bool NoGpuTst_hipMalloc() {
  bool passed = false;
  hipError_t err;
  int* ptr;
  size_t size = 1024;
  err = hipMalloc(&ptr, size);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipMalloc: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipHostRegister() API
static bool NoGpuTst_hipHostRegister() {
  bool passed = false;
  hipError_t err;
  size_t size = 1024;
  unsigned int reg_flag = hipHostRegisterDefault;
  void* hostPtr = reinterpret_cast<void*>(malloc(size));
  err = hipHostRegister(hostPtr, size, reg_flag);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipHostRegister: " << hipGetErrorName(err));
  }
  free(hostPtr);
  return passed;
}

// No GPU test for hipMemcpy() API
static bool NoGpuTst_hipMemcpy() {
  bool passed = false;
  hipError_t err;
  size_t size = 1024;
  int* dst = reinterpret_cast<int*>(malloc(size));
  int* src = reinterpret_cast<int*>(malloc(size));
  err = hipMemcpy(dst, src, size, hipMemcpyHostToHost);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipMemcpy: " << hipGetErrorName(err));
  }
  free(dst);
  free(src);
  return passed;
}

// No GPU test for hipMemAllocPitch() API
static bool NoGpuTst_hipMemAllocPitch() {
  bool passed = false;
  hipError_t err, err_exp;
#if HT_AMD
  err_exp = hipErrorNoDevice;
#else
  err_exp = hipErrorNotInitialized;
#endif
  size_t pitch;
  hipDeviceptr_t dptr;
  size_t widthInBytes = 128;
  size_t height = 128;
  unsigned int elementSizeBytes = 4;
  err = hipMemAllocPitch(&dptr, &pitch, widthInBytes, height, elementSizeBytes);
  if (err == err_exp) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipMemAllocPitch: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipMemGetInfo() API
static bool NoGpuTst_hipMemGetInfo() {
  bool passed = false;
  hipError_t err;
  size_t free, total;
  err = hipMemGetInfo(&free, &total);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipMemGetInfo: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipMalloc3DArray() API
static bool NoGpuTst_hipMalloc3DArray() {
  bool passed = false;
  hipError_t err;
  hipArray_t array;
  hipChannelFormatDesc desc = hipCreateChannelDesc<int>();
  hipExtent extent = make_hipExtent(64, 64, 64);
  err = hipMalloc3DArray(&array, &desc, extent, hipArrayDefault);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipMalloc3DArray: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipDeviceCanAccessPeer() API
static bool NoGpuTst_hipDeviceCanAccessPeer() {
  bool passed = false;
  hipError_t err;
  int canAccessPeer;
  int deviceId1 = 0;
  int peerDeviceId = 1;
  err = hipDeviceCanAccessPeer(&canAccessPeer, deviceId1, peerDeviceId);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceCanAccessPeer: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipDeviceDisablePeerAccess() API
static bool NoGpuTst_hipDeviceDisablePeerAccess() {
  bool passed = false;
  hipError_t err;
  err = hipDeviceDisablePeerAccess(1);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceDisablePeerAccess: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipDeviceGet() API
static bool NoGpuTst_hipDeviceGet() {
  bool passed = false;
  hipError_t err, err_exp;
#if HT_AMD
  err_exp = hipErrorNoDevice;
#else
  err_exp = hipErrorNotInitialized;
#endif
  hipDevice_t device;
  int ordinal = 0;
  err = hipDeviceGet(&device, ordinal);
  if (err == err_exp) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceGet: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipDeviceComputeCapability() API
static bool NoGpuTst_hipDeviceComputeCapability() {
  bool passed = false;
  hipError_t err, err_exp;
#if HT_AMD
  err_exp = hipErrorNoDevice;
#else
  err_exp = hipErrorNotInitialized;
#endif
  int major;
  int minor;
  err = hipDeviceComputeCapability(&major, &minor, 0);
  if (err == err_exp) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceComputeCapability: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipDeviceGetName() API
static bool NoGpuTst_hipDeviceGetName() {
  bool passed = false;
  hipError_t err, err_exp;
#if HT_AMD
  err_exp = hipErrorNoDevice;
#else
  err_exp = hipErrorNotInitialized;
#endif
  char name[256];
  int len = 256;
  err = hipDeviceGetName(name, len, 0);
  if (err == err_exp) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceGetName: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipGetDeviceProperties() API
static bool NoGpuTst_hipGetDeviceProperties() {
  bool passed = false;
  hipError_t err;
  int deviceId = 0;
  hipDeviceProp_t prop;
  err = hipGetDeviceProperties(&prop, deviceId);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipGetDeviceProperties: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipChooseDevice() API
static bool NoGpuTst_hipChooseDevice() {
  bool passed = false;
  hipError_t err;
  int device;
  hipDeviceProp_t prop;
  prop.major = 0;
  prop.minor = 0;
  err = hipChooseDevice(&device, &prop);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipChooseDevice: " << hipGetErrorName(err));
  }
  return passed;
}
#if HT_AMD
// No GPU test for hipExtGetLinkTypeAndHopCount() API
static bool NoGpuTst_hipExtGetLinkTypeAndHopCount() {
  bool passed = false;
  hipError_t err;
  uint32_t linktype;
  uint32_t hopcount;
  err = hipExtGetLinkTypeAndHopCount(0, 1, &linktype, &hopcount);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipExtGetLinkTypeAndHopCount: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipExtStreamGetCUMask() API
static bool NoGpuTst_hipExtStreamGetCUMask() {
  bool passed = false;
  hipError_t err;
  uint32_t cuMaskSize = 1024;
  uint32_t cuMask;
  err = hipExtStreamGetCUMask(0, cuMaskSize, &cuMask);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipExtStreamGetCUMask: " << hipGetErrorName(err));
  }
  return passed;
}
#endif

// No GPU test for hipFuncSetAttribute() API
static bool NoGpuTst_hipFuncSetAttribute() {
  bool passed = false;
  hipError_t err;
  hipFuncAttribute attr = hipFuncAttributeMaxDynamicSharedMemorySize;
  err = hipFuncSetAttribute(reinterpret_cast<const void*>(&fn), attr, 0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipFuncSetAttribute: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipFuncSetCacheConfig() API
static bool NoGpuTst_hipFuncSetCacheConfig() {
  bool passed = false;
  hipError_t err;
  hipFuncCache_t config = hipFuncCachePreferShared;
  err = hipFuncSetCacheConfig(reinterpret_cast<const void*>(&fn), config);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipFuncSetCacheConfig: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipStreamCreateWithFlags() API
static bool NoGpuTst_hipStreamCreateWithFlags() {
  bool passed = false;
  hipError_t err;
  hipStream_t stream;
  unsigned int flags = 0;
  err = hipStreamCreateWithFlags(&stream, flags);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipStreamCreateWithFlags: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipDeviceGetStreamPriorityRange() API
static bool NoGpuTst_hipDeviceGetStreamPriorityRange() {
  bool passed = false;
  hipError_t err;
  int leastPriority;
  int greatestPriority;
  err = hipDeviceGetStreamPriorityRange(&leastPriority, &greatestPriority);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceGetStreamPriorityRange: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipEventCreate() API
static bool NoGpuTst_hipEventCreate() {
  bool passed = false;
  hipError_t err;
  hipEvent_t event;
  err = hipEventCreate(&event);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipEventCreate: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipStreamGetPriority() API
static bool NoGpuTst_hipStreamGetPriority() {
  bool passed = false;
  hipError_t err;
  int priority;
  err = hipStreamGetPriority(0, &priority);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipStreamGetPriority: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipDeviceReset() API
static bool NoGpuTst_hipDeviceReset() {
  bool passed = false;
  hipError_t err;
  err = hipDeviceReset();
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceReset: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipDeviceSetCacheConfig() API
static bool NoGpuTst_hipDeviceSetCacheConfig() {
  bool passed = false;
  hipError_t err;
  hipFuncCache_t cacheConfig = hipFuncCachePreferShared;
  err = hipDeviceSetCacheConfig(cacheConfig);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceSetCacheConfig: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipDeviceGetLimit() API
static bool NoGpuTst_hipDeviceGetLimit() {
  bool passed = false;
  hipError_t err;
  size_t pValue;
  hipLimit_t limit = hipLimitStackSize;
  err = hipDeviceGetLimit(&pValue, limit);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipDeviceGetLimit: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipGetDeviceFlags() API
static bool NoGpuTst_hipGetDeviceFlags() {
  bool passed = false;
  hipError_t err;
  unsigned int flags;
  err = hipGetDeviceFlags(&flags);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipGetDeviceFlags: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipSetDeviceFlags() API
static bool NoGpuTst_hipSetDeviceFlags() {
  bool passed = false;
  hipError_t err;
  err = hipSetDeviceFlags(0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipSetDeviceFlags: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipModuleLoad() API
static bool NoGpuTst_hipModuleLoad() {
  bool passed = false;
  hipError_t err;
  hipModule_t module;
  err = hipModuleLoad(&module, "dummy_kernel.code");
#if HT_AMD
  if (err == hipErrorNoDevice) {
    passed = true;
  }
#else
  if (err == hipErrorNotInitialized) {
    passed = true;
  }
#endif
  if (passed == false) {
    WARN("Error Code Returned by hipModuleLoad: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipFuncGetAttributes() API
static bool NoGpuTst_hipFuncGetAttributes() {
  bool passed = false;
  hipError_t err;
  hipFuncAttributes attr{};
  err = hipFuncGetAttributes(&attr, reinterpret_cast<const void*>(&fn));
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipFuncGetAttributes: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipModuleLoadData() API
static bool NoGpuTst_hipModuleLoadData() {
  bool passed = false;
  hipError_t err;
  hipModule_t module;
  std::ifstream file("dummy_kernel.code", std::ios::binary | std::ios::ate);
  std::streamsize fsize = file.tellg();
  file.seekg(0, std::ios::beg);
  std::vector<char> buffer(fsize);
  if (file.read(buffer.data(), fsize)) {
    err = hipModuleLoadData(&module, &buffer[0]);
#if HT_AMD
    if (err == hipErrorNoDevice) {
      passed = true;
    }
#else
    if (err == hipErrorNotInitialized) {
      passed = true;
    }
#endif
    if (passed == false) {
      WARN("Error Code Returned by hipModuleLoadData: " << hipGetErrorName(err));
    }
  } else {
    WARN("File Read Failed");
  }
  return passed;
}

// No GPU test for hipModuleLoadDataEx() API
static bool NoGpuTst_hipModuleLoadDataEx() {
  bool passed = false;
  hipError_t err;
  hipModule_t module;
  std::ifstream file("dummy_kernel.code", std::ios::binary | std::ios::ate);
  std::streamsize fsize = file.tellg();
  file.seekg(0, std::ios::beg);
  std::vector<char> buffer(fsize);
  if (file.read(buffer.data(), fsize)) {
    err = hipModuleLoadDataEx(&module, &buffer[0], 0, nullptr, nullptr);
#if HT_AMD
    if (err == hipErrorNoDevice) {
      passed = true;
    }
#else
    if (err == hipErrorNotInitialized) {
      passed = true;
    }
#endif
    if (passed == false) {
      WARN("Error Code Returned by hipModuleLoadDataEx: " << hipGetErrorName(err));
    }
  } else {
    WARN("File Read Failed");
  }
  return true;
}

// No GPU test for hipLaunchCooperativeKernel() API
static bool NoGpuTst_hipLaunchCooperativeKernel() {
  bool passed = false;
  hipError_t err;
  dim3 dimBlock = dim3(1);
  dim3 dimGrid = dim3(1);
  err = hipLaunchCooperativeKernel(reinterpret_cast<void*>(fn), dimGrid, dimBlock, nullptr, 0, 0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipLaunchCooperativeKernel: " << hipGetErrorName(err));
  }
  return passed;
}

#if HT_AMD
// No GPU test for hipLaunchCooperativeKernelMultiDevice() API
static bool NoGpuTst_hipLaunchCooperativeKernelMultiDevice() {
  bool passed = false;
  hipError_t err;
  dim3 dimBlock;
  dim3 dimGrid;
  dimGrid.x = 1;
  dimGrid.y = 1;
  dimGrid.z = 1;
  dimBlock.x = 64;
  dimBlock.y = 1;
  dimBlock.z = 1;
  hipLaunchParams md_params[1];
  void* dev_params[1][1];
  dev_params[0][0] = nullptr;
  md_params[0].func = reinterpret_cast<void*>(fn);
  md_params[0].gridDim = dimGrid;
  md_params[0].blockDim = dimBlock;
  md_params[0].sharedMem = 0;
  md_params[0].stream = hipStreamPerThread;
  md_params[0].args = dev_params[0];

  err = hipLaunchCooperativeKernelMultiDevice(md_params, 1, 0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipLaunchCooperativeKernelMultiDevice: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipExtLaunchMultiKernelMultiDevice() API
static bool NoGpuTst_hipExtLaunchMultiKernelMultiDevice() {
  bool passed = false;
  hipError_t err;
  dim3 dimBlock;
  dim3 dimGrid;
  dimGrid.x = 1;
  dimGrid.y = 1;
  dimGrid.z = 1;
  dimBlock.x = 64;
  dimBlock.y = 1;
  dimBlock.z = 1;
  hipLaunchParams md_params[1];
  md_params[0].func = reinterpret_cast<void*>(fn);
  md_params[0].gridDim = dimGrid;
  md_params[0].blockDim = dimBlock;
  md_params[0].sharedMem = 0;
  md_params[0].stream = hipStreamPerThread;
  md_params[0].args = nullptr;

  err = hipExtLaunchMultiKernelMultiDevice(md_params, 1, 0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipExtLaunchMultiKernelMultiDevice: " << hipGetErrorName(err));
  }
  return passed;
}
#endif

// No GPU test for hipExtLaunchMultiKernelMultiDevice() API
static bool NoGpuTst_hipOccupancyMaxActiveBlocksPerMultiprocessor() {
  bool passed = false;
  hipError_t err;
  int numBlock = 0, blockSize = 256;
  err = hipOccupancyMaxActiveBlocksPerMultiprocessor(&numBlock, fn, blockSize, 0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code hipOccupancyMaxActiveBlocksPerMultiprocessor: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags()
static bool NoGpuTst_hipOccupancyMaxActiveBlocksPerMultiprocessorFlags() {
  bool passed = false;
  hipError_t err;
  int numBlock = 0, blockSize = 256;
  err = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(&numBlock, fn, blockSize, 0, 0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags: "
         << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipOccupancyMaxPotentialBlockSize()
static bool NoGpuTst_hipOccupancyMaxPotentialBlockSize() {
  bool passed = false;
  hipError_t err;
  int blocksizelimit = 256, blockSize = 0, gridsize = 0;
  err = hipOccupancyMaxPotentialBlockSize(&gridsize, &blockSize, fn, 0, blocksizelimit);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipOccupancyMaxPotentialBlockSize: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hiprtcVersion()
static bool NoGpuTst_hiprtcVersion() {
  bool passed = false;
  int major = 0, minor = 0;
  hiprtcResult err = hiprtcVersion(&major, &minor);
  if (err == HIPRTC_SUCCESS) {
    passed = true;
  } else {
    WARN("Error Code Returned by hiprtcVersion: " << hiprtcGetErrorString(err));
  }
  return passed;
}

// No GPU test for hiprtcCreateProgram() and hiprtcDestroyProgram()
static bool NoGpuTst_hiprtcCreateProgram_DestroyProg() {
  bool passed = false;
  hiprtcProgram prog;
  hiprtcResult err = hiprtcCreateProgram(&prog, rtcfn, "rtcfn.cu", 0, nullptr, nullptr);
  if (err == HIPRTC_SUCCESS) {
    passed = true;
    err = hiprtcDestroyProgram(&prog);
    if (err == HIPRTC_SUCCESS) {
      passed = true;
    } else {
      passed = false;
      WARN("Error Code Returned by hiprtcDestroyProgram: " << hiprtcGetErrorString(err));
    }
  } else {
    WARN("Error Code Returned by hiprtcCreateProgram: " << hiprtcGetErrorString(err));
  }
  return passed;
}

// No GPU test for hiprtcAddNameExpression()
static bool NoGpuTst_hiprtcAddNameExpression() {
  bool passed = false;
  hiprtcProgram prog;
  hiprtcResult err = hiprtcCreateProgram(&prog, rtcfn, "rtcfn.cu", 0, nullptr, nullptr);
  if (err == HIPRTC_SUCCESS) {
    err = hiprtcAddNameExpression(prog, "dummy_func");
    if (err == HIPRTC_SUCCESS) {
      passed = true;
    } else {
      passed = false;
      WARN("Error Code Returned by hiprtcAddNameExpression: " << hiprtcGetErrorString(err));
    }
  }
  if (err == HIPRTC_SUCCESS) {
    err = hiprtcDestroyProgram(&prog);
  }
  return passed;
}

// No GPU test for hipMallocPitch()
#define SIZE_H 20
#define SIZE_W 179
static bool NoGpuTst_hipMallocPitch() {
  bool passed = false;
  hipError_t err;
  int* devPtr;
  size_t devPitch;
  err = hipMallocPitch(reinterpret_cast<void**>(&devPtr), &devPitch, SIZE_W * sizeof(int), SIZE_H);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipMallocPitch: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipMallocArray()
static bool NoGpuTst_hipMallocArray() {
  bool passed = false;
  hipError_t err;
  hipChannelFormatDesc channelDesc = hipCreateChannelDesc(32, 0, 0, 0, hipChannelFormatKindFloat);
  hipArray_t hipArray;
  err = hipMallocArray(&hipArray, &channelDesc, 256, 256);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipMallocArray: " << hipGetErrorName(err));
  }
  return passed;
}
#if HT_AMD
// No GPU test for hipMipmappedArrayCreate()
static bool NoGpuTst_hipMipmappedArrayCreate() {
  bool passed = false;
  hipError_t err;
  unsigned int width = 256, height = 256, mipmap_level = 2;
  unsigned int orig_width = width;
  unsigned int orig_height = height;
  width /= pow(2, mipmap_level);
  height /= pow(2, mipmap_level);

  hipChannelFormatDesc channelDesc = hipCreateChannelDesc(32, 0, 0, 0, hipChannelFormatKindFloat);
  HIP_ARRAY3D_DESCRIPTOR mipmapped_array_desc;
  memset(&mipmapped_array_desc, 0x00, sizeof(HIP_ARRAY3D_DESCRIPTOR));
  mipmapped_array_desc.Width = orig_width;
  mipmapped_array_desc.Height = orig_height;
  mipmapped_array_desc.Depth = 0;
  mipmapped_array_desc.Format = HIP_AD_FORMAT_FLOAT;
  mipmapped_array_desc.NumChannels =
      ((channelDesc.x != 0) + (channelDesc.y != 0) + (channelDesc.z != 0) + (channelDesc.w != 0));
  mipmapped_array_desc.Flags = 0;

  hipMipmappedArray* mip_array_ptr;
  err = hipMipmappedArrayCreate(&mip_array_ptr, &mipmapped_array_desc, 2 * mipmap_level);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipMipmappedArrayCreate: " << hipGetErrorName(err));
  }
  return passed;
}
#endif
#define SMALL_SIZE 4
static bool NoGpuTst_hipMalloc3D() {
  bool passed = false;
  hipError_t err;
  size_t width = SMALL_SIZE * sizeof(char);
  size_t height{SMALL_SIZE}, depth{SMALL_SIZE};
  hipPitchedPtr devPitchedPtr;
  hipExtent extent = make_hipExtent(width, height, depth);
  err = hipMalloc3D(&devPitchedPtr, extent);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipMalloc3D: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipGraphCreate() API
static bool NoGpuTst_hipGraphCreate() {
  bool passed = false;
  hipError_t err;
  hipGraph_t graph;

  err = hipGraphCreate(&graph, 0);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipGraphCreate: " << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipStreamBeginCapture() API
static bool NoGpuTst_hipStreamBeginCapture() {
  bool passed = false;
  hipError_t err;

  err = hipStreamBeginCapture(0, hipStreamCaptureModeGlobal);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipStreamBeginCapture with null stream: " << hipGetErrorName(err));
  }

  err = hipStreamBeginCapture(hipStreamPerThread, hipStreamCaptureModeGlobal);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN(
        "Error Code Returned by hipStreamBeginCapture with "
        "hipStreamPerThread stream: "
        << hipGetErrorName(err));
  }
  return passed;
}

// No GPU test for hipStreamIsCapturing() API
static bool NoGpuTst_hipStreamIsCapturing() {
  bool passed = false;
  hipError_t err;
  hipStreamCaptureStatus cStatus;

  err = hipStreamIsCapturing(0, &cStatus);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN("Error Code Returned by hipStreamIsCapturing: " << hipGetErrorName(err));
  }
  err = hipStreamIsCapturing(hipStreamPerThread, &cStatus);
  if (err == hipErrorNoDevice) {
    passed = true;
  } else {
    WARN(
        "Error Code Returned by hipStreamIsCapturing with "
        "hipStreamPerThread stream: "
        << hipGetErrorName(err));
  }
  return passed;
}
// Common function invoking individual tests
static bool NoGpuTst_Common(bool (*test_fn)()) {
  bool passed = false;
  int* Ptr = reinterpret_cast<int*>(
      mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0));
  if (Ptr == MAP_FAILED) {
    WARN("Mapping Failed\n");
    return false;
  }
  // forking to get number of gpus on this system
  if (fork() == 0) {  //  child process
    int TotlGpus = 0;
    static_cast<void>(hipGetDeviceCount(&TotlGpus));
    Ptr[0] = TotlGpus;
    exit(0);
  } else {  // parent process
    wait(NULL);
    if (Ptr[0] > 0) {  // If there are gpus active on the system
      if ((setenv(visibility_env_var, "-1", 1)) != 0) {
        WARN("Unable to turn on HIP_VISIBLE_DEVICES, hence exiting!");
        return false;
      }
      passed = test_fn();
    } else if (Ptr[0] == 0) {
      WARN("GPUs not available!");
      passed = test_fn();
    }
  }
  return passed;
}

// Tests
HIP_TEST_CASE(Unit_NoGpuTst_hipGetDeviceCount) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipGetDeviceCount));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipSetDevice) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipSetDevice)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceGetAttribute) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceGetAttribute));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceGetP2PAttribute) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceGetP2PAttribute));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceGetPCIBusId) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceGetPCIBusId));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceGetByPCIBusId) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceGetByPCIBusId));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceTotalMem) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceTotalMem));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipFuncSetSharedMemConfig) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipFuncSetSharedMemConfig));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipStreamCreate) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipStreamCreate)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipStreamCreateWithPriority) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipStreamCreateWithPriority));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipStreamSynchronize) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipStreamSynchronize));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipStreamGetFlags) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipStreamGetFlags));
}
#if HT_AMD
HIP_TEST_CASE(Unit_NoGpuTst_hipExtStreamCreateWithCUMask) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipExtStreamCreateWithCUMask));
}
#endif
HIP_TEST_CASE(Unit_NoGpuTst_hipStreamAddCallback) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipStreamAddCallback));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipEventCreateWithFlags) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipEventCreateWithFlags));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceSynchronize) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceSynchronize));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipGetDevice) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipGetDevice)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceGetCacheConfig) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceGetCacheConfig));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceGetSharedMemConfig) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceGetSharedMemConfig));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceSetSharedMemConfig) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceSetSharedMemConfig));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipPointerGetAttributes) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipPointerGetAttributes));
}
#if HT_AMD
HIP_TEST_CASE(Unit_NoGpuTst_hipExtMallocWithFlags) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipExtMallocWithFlags));
}
#endif
HIP_TEST_CASE(Unit_NoGpuTst_hipMallocManaged) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipMallocManaged)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipHostFree) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipHostFree)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipMemcpyWithStream) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipMemcpyWithStream));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipMallocArray) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipMallocArray)); }
#if HT_AMD
HIP_TEST_CASE(Unit_NoGpuTst_hipMallocMipmappedArray) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipMallocMipmappedArray));
}
#endif
HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceEnablePeerAccess) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceEnablePeerAccess));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipHostMalloc) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipHostMalloc)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipMalloc) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipMalloc)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipHostRegister) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipHostRegister)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipMemcpy) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipMemcpy)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipMemAllocPitch) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipMemAllocPitch)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipMemGetInfo) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipMemGetInfo)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipMalloc3DArray) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipMalloc3DArray)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceCanAccessPeer) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceCanAccessPeer));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceDisablePeerAccess) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceDisablePeerAccess));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceGet) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceGet)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceComputeCapability) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceComputeCapability));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceGetName) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceGetName)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipGetDeviceProperties) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipGetDeviceProperties));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipChooseDevice) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipChooseDevice)); }

#if HT_AMD
HIP_TEST_CASE(Unit_NoGpuTst_hipExtGetLinkTypeAndHopCount) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipExtGetLinkTypeAndHopCount));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipExtStreamGetCUMask) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipExtStreamGetCUMask));
}
#endif

HIP_TEST_CASE(Unit_NoGpuTst_hipFuncSetAttribute) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipFuncSetAttribute));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipFuncSetCacheConfig) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipFuncSetCacheConfig));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipStreamCreateWithFlags) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipStreamCreateWithFlags));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceGetStreamPriorityRange) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceGetStreamPriorityRange));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipEventCreate) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipEventCreate)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipStreamGetPriority) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipStreamGetPriority));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceReset) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceReset)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceSetCacheConfig) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceSetCacheConfig));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipDeviceGetLimit) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipDeviceGetLimit));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipGetDeviceFlags) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipGetDeviceFlags));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipSetDeviceFlags) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipSetDeviceFlags));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipModuleLoad) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipModuleLoad)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipFuncGetAttributes) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipFuncGetAttributes));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipModuleLoadData) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipModuleLoadData));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipModuleLoadDataEx) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipModuleLoadDataEx));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipLaunchCooperativeKernel) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipLaunchCooperativeKernel));
}

#if HT_AMD
HIP_TEST_CASE(Unit_NoGpuTst_hipLaunchCooperativeKernelMultiDevice) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipLaunchCooperativeKernelMultiDevice));
}
HIP_TEST_CASE(Unit_NoGpuTst_hipExtLaunchMultiKernelMultiDevice) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipExtLaunchMultiKernelMultiDevice));
}
#endif
HIP_TEST_CASE(Unit_NoGpuTst_hipOccupancyMaxActiveBlocksPerMultiprocessor) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipOccupancyMaxActiveBlocksPerMultiprocessor));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipOccupancyMaxActiveBlocksPerMultiprocessorFlags) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipOccupancyMaxActiveBlocksPerMultiprocessorFlags));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipOccupancyMaxPotentialBlockSize) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipOccupancyMaxPotentialBlockSize));
}

HIP_TEST_CASE(Unit_NoGpuTst_hiprtcVersion) { REQUIRE(NoGpuTst_Common(NoGpuTst_hiprtcVersion)); }

HIP_TEST_CASE(Unit_NoGpuTst_hiprtcCreateProgram_DestroyProg) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hiprtcCreateProgram_DestroyProg));
}

HIP_TEST_CASE(Unit_NoGpuTst_hiprtcAddNameExpression) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hiprtcAddNameExpression));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipMallocPitch) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipMallocPitch)); }

#if HT_AMD
HIP_TEST_CASE(Unit_NoGpuTst_hipMipmappedArrayCreate) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipMipmappedArrayCreate));
}
#endif
HIP_TEST_CASE(Unit_NoGpuTst_hipMalloc3D) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipMalloc3D)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipGraphCreate) { REQUIRE(NoGpuTst_Common(NoGpuTst_hipGraphCreate)); }

HIP_TEST_CASE(Unit_NoGpuTst_hipStreamBeginCapture) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipStreamBeginCapture));
}

HIP_TEST_CASE(Unit_NoGpuTst_hipStreamIsCapturing) {
  REQUIRE(NoGpuTst_Common(NoGpuTst_hipStreamIsCapturing));
}
#endif  // #ifdef __linux__