Adjust clang format to the new versions, revert broken macro layout (#714)

projects/hip-tests/catch/unit/memory/hipDrvMemcpy3DAsync_old.cc

@@ -69,9 +69,8 @@ template <typename T> class DrvMemcpy3DAsync {
 };
 
 /* Intializes class variables */
-template <typename T>
-DrvMemcpy3DAsync<T>::DrvMemcpy3DAsync(int l_width, int l_height, int l_depth,
-                                      hipArray_Format l_format) {
+template <typename T> DrvMemcpy3DAsync<T>::DrvMemcpy3DAsync(int l_width, int l_height, int l_depth,
+                                                            hipArray_Format l_format) {
   width = l_width;
   height = l_height;
   depth = l_depth;

projects/hip-tests/catch/unit/memory/hipGetProcAddressMemoryApis.cc

@@ -6041,7 +6041,7 @@ TEST_CASE("Unit_hipGetProcAddress_MemoryApisPeerToPeer") {
   HIP_CHECK(hipDeviceCanAccessPeer(&canAccessPeer, deviceId, peerDeviceId));
   if (!canAccessPeer) {
     std::string msg = "Skipped as peer access cannot be enabled between devices " +
-        std::to_string(deviceId) + " " + std::to_string(peerDeviceId);
+                      std::to_string(deviceId) + " " + std::to_string(peerDeviceId);
     HipTest::HIP_SKIP_TEST(msg.c_str());
     return;
   }

projects/hip-tests/catch/unit/memory/hipHostUnregister.cc

@@ -23,12 +23,12 @@ THE SOFTWARE.
 #include <hip_test_common.hh>
 
 namespace hipHostUnregisterTests {
-constexpr unsigned int allFlags = hipHostRegisterDefault &  // 0
-    hipHostRegisterPortable &                               // 1
-    hipHostRegisterMapped &                                 // 2
-    hipHostRegisterIoMemory                                 // 4
+constexpr unsigned int allFlags = hipHostRegisterDefault &   // 0
+                                  hipHostRegisterPortable &  // 1
+                                  hipHostRegisterMapped &    // 2
+                                  hipHostRegisterIoMemory    // 4
 #if HT_NVIDIA
-    & cudaHostRegisterReadOnly;  // 8
+                                  & cudaHostRegisterReadOnly;  // 8
 #else
     ;
 #endif

projects/hip-tests/catch/unit/memory/hipMemPoolSetGetAttribute.cc

@@ -27,9 +27,8 @@
  * - Sets attributes of a memory pool
  */
 
-template <typename T>
-static void MemPoolSetGetAttribute(const hipMemPool_t mempool, const hipMemPoolAttr attr,
-                                   T& set_value) {
+template <typename T> static void MemPoolSetGetAttribute(const hipMemPool_t mempool,
+                                                         const hipMemPoolAttr attr, T& set_value) {
   T get_value = 100;
   HIP_CHECK(hipMemPoolSetAttribute(mempool, attr, &set_value));
   HIP_CHECK(hipMemPoolGetAttribute(mempool, attr, &get_value));

projects/hip-tests/catch/unit/memory/hipMemcpy3DAsync_old.cc

@@ -77,9 +77,8 @@ template <typename T> void Memcpy3DAsync<T>::SetDefaultData() {
 /*
  * Constructor initalized width,depth and height
  */
-template <typename T>
-Memcpy3DAsync<T>::Memcpy3DAsync(int l_width, int l_height, int l_depth,
-                                hipChannelFormatKind l_format) {
+template <typename T> Memcpy3DAsync<T>::Memcpy3DAsync(int l_width, int l_height, int l_depth,
+                                                      hipChannelFormatKind l_format) {
   width = l_width;
   height = l_height;
   depth = l_depth;

projects/hip-tests/catch/unit/memory/hipMemcpy3D_old.cc

@@ -76,9 +76,8 @@ template <typename T> void Memcpy3D<T>::SetDefaultData() {
 /*
  * Constructor initalized width,depth and height
  */
-template <typename T>
-Memcpy3D<T>::Memcpy3D(size_t l_width, size_t l_height, size_t l_depth,
-                      hipChannelFormatKind l_format) {
+template <typename T> Memcpy3D<T>::Memcpy3D(size_t l_width, size_t l_height, size_t l_depth,
+                                            hipChannelFormatKind l_format) {
   width = l_width;
   height = l_height;
   depth = l_depth;

projects/hip-tests/catch/unit/memory/hipMemcpyWithStream_old.cc

@@ -68,8 +68,8 @@ enum class ops {
 };
 
 struct joinable_thread : std::thread {
-  template <class... Xs>
-  explicit joinable_thread(Xs&&... xs) : std::thread(std::forward<Xs>(xs)...) {}  // NOLINT
+  template <class... Xs> explicit joinable_thread(Xs&&... xs)
+      : std::thread(std::forward<Xs>(xs)...) {}  // NOLINT
 
   joinable_thread& operator=(joinable_thread&& other) = default;
   joinable_thread(joinable_thread&& other) = default;

projects/hip-tests/catch/unit/memory/hipMemcpy_EdgeCases.cc

@@ -65,8 +65,8 @@ template <typename T> class DeviceMemory {
   int _offset;
 };
 
-template <typename T>
-DeviceMemory<T>::DeviceMemory(size_t numElements) : _maxNumElements(numElements), _offset(0) {
+template <typename T> DeviceMemory<T>::DeviceMemory(size_t numElements)
+    : _maxNumElements(numElements), _offset(0) {
   T** np = nullptr;
   HipTest::initArrays(&_A_d, &_B_d, &_C_d, np, np, np, numElements, 0);
   size_t sizeElements = numElements * sizeof(T);
@@ -110,8 +110,7 @@ template <typename T> class HostMemory {
   T* _C_h;
 };
 
-template <typename T>
-HostMemory<T>::HostMemory(size_t numElements, bool usePinnedHost)
+template <typename T> HostMemory<T>::HostMemory(size_t numElements, bool usePinnedHost)
     : _usePinnedHost(usePinnedHost), _maxNumElements(numElements), _offset(0) {
   T** np = nullptr;
   HipTest::initArrays(np, np, np, &_A_h, &_B_h, &_C_h, numElements, usePinnedHost);
@@ -199,9 +198,9 @@ void memcpytest2_get_host_memory(size_t* free, size_t* total) {
 // (runtime figures out direction).  if false, use
 // explicit memcpy direction.
 //
-template <typename T>
-void memcpytest2(DeviceMemory<T>* dmem, HostMemory<T>* hmem, size_t numElements, bool useHostToHost,
-                 bool useDeviceToDevice, bool useMemkindDefault) {
+template <typename T> void memcpytest2(DeviceMemory<T>* dmem, HostMemory<T>* hmem,
+                                       size_t numElements, bool useHostToHost,
+                                       bool useDeviceToDevice, bool useMemkindDefault) {
   size_t sizeElements = numElements * sizeof(T);
 
   hmem->reset(numElements);

projects/hip-tests/catch/unit/memory/hipMemset.cc

@@ -82,9 +82,8 @@ static bool testhipMemset(T* A_h, T* A_d, T memsetval, enum MemsetType type, siz
 }
 
 
-template <typename T>
-static bool testhipMemsetAsync(T* A_h, T* A_d, T memsetval, enum MemsetType type,
-                               size_t numElements) {
+template <typename T> static bool testhipMemsetAsync(T* A_h, T* A_d, T memsetval,
+                                                     enum MemsetType type, size_t numElements) {
   size_t Nbytes = numElements * sizeof(T);
   bool testResult = true;
   constexpr auto MAX_OFFSET = 3;  // To memset on unaligned ptr.

projects/hip-tests/catch/unit/memory/hipMemsetAsync.cc

@@ -34,9 +34,8 @@ constexpr int testValue2 = 98;
 using namespace mem_utils;
 
 // Helper function to run tests for hipMemset allocation types
-template <typename T>
-void runAsyncTests(hipStream_t stream, allocType type, memType memType, MultiDData data1,
-                   MultiDData data2) {
+template <typename T> void runAsyncTests(hipStream_t stream, allocType type, memType memType,
+                                         MultiDData data1, MultiDData data2) {
   std::pair<T*, T*> aPtr{};
   MultiDData totalRange;
   totalRange.width = data1.width + data2.width;
@@ -61,9 +60,8 @@ void runAsyncTests(hipStream_t stream, allocType type, memType memType, MultiDDa
   }
 }
 
-template <typename T>
-static void doMemsetTest(allocType mallocType, memType memset_type, MultiDData data1,
-                         MultiDData data2) {
+template <typename T> static void doMemsetTest(allocType mallocType, memType memset_type,
+                                               MultiDData data1, MultiDData data2) {
   enum StreamType { NULLSTR, CREATEDSTR };
   auto streamType = GENERATE(NULLSTR, CREATEDSTR);
   hipStream_t stream{nullptr};

projects/hip-tests/catch/unit/memory/hipMemsetFunctional.cc

@@ -182,9 +182,8 @@ DEFINE_1D_BASIC_TEST_CASE("ZeroSize_hipMemsetD8", hipMemsetTypeD8, int8_t, 0x1,
 
 // Helper function that sets a full region of memory with an initial value, sets a smaller subregion
 // with another value and check that the memset API do not write outside of the subregion of data.
-template <typename T>
-void partialMemsetTest(T valA, T valB, size_t count, size_t offset, MemsetType memsetType,
-                       bool async) {
+template <typename T> void partialMemsetTest(T valA, T valB, size_t count, size_t offset,
+                                             MemsetType memsetType, bool async) {
   T* devPtr;
   size_t subSize{count - offset};
   HIP_CHECK(hipMalloc(&devPtr, count * sizeof(T)));
@@ -250,9 +249,8 @@ void check_device_data_2D(T* devPtr, T value, size_t pitch, size_t width, size_t
 
 // Helper function for allocating memory, setting data with the specified 2D memset API and then
 // checking result of operation.
-template <typename T>
-void checkMemset2D(T value, size_t width, size_t height, bool async = false, size_t pitch = 0,
-                   T* devPtr = nullptr) {
+template <typename T> void checkMemset2D(T value, size_t width, size_t height, bool async = false,
+                                         size_t pitch = 0, T* devPtr = nullptr) {
   hipStream_t stream{nullptr};
   HIP_CHECK(hipStreamCreate(&stream));
   constexpr size_t elementSize = sizeof(T);
@@ -342,9 +340,9 @@ TEST_CASE("Unit_hipMemsetFunctional_ZeroSize_2D") {
 
 // Helper function that sets a full region of memory with an initial value, sets a smaller subregion
 // with another value and check that the memset API do not write outside of the subregion of data.
-template <typename T>
-void partialMemsetTest2D(T valA, T valB, size_t width, size_t height, size_t widthOffset,
-                         size_t heightOffset, bool async) {
+template <typename T> void partialMemsetTest2D(T valA, T valB, size_t width, size_t height,
+                                               size_t widthOffset, size_t heightOffset,
+                                               bool async) {
   T* devPtr{nullptr};
   size_t pitch{0};
   size_t subWidth{width - widthOffset};

projects/hip-tests/catch/unit/memory/hipMemsetNegative.cc

@@ -218,7 +218,7 @@ TEST_CASE("Unit_hipMemset3D_Negative_OutOfBounds") {
   HIP_CHECK(hipMalloc3D(&pitchedDevPtr, validExtent));
   hipPitchedPtr outOfBoundsPtr{pitchedDevPtr};
   outOfBoundsPtr.ptr = reinterpret_cast<char*>(pitchedDevPtr.ptr) +
-      pitchedDevPtr.pitch * validExtent.height * validExtent.depth + 1;
+                       pitchedDevPtr.pitch * validExtent.height * validExtent.depth + 1;
 
   SECTION("Extent Equal to 0") {
     hipExtent zeroExtent{0, 0, 0};

projects/hip-tests/catch/unit/memory/hipMemsetSync.cc

@@ -51,9 +51,9 @@ struct MultiDData {
 };
 
 // set of helper functions to tidy the nested switch statements
-template <typename T>
-static std::pair<T*, T*> deviceMallocHelper(memSetType memType, size_t dataW, size_t dataH,
-                                            size_t dataD, size_t& dataPitch) {
+template <typename T> static std::pair<T*, T*> deviceMallocHelper(memSetType memType, size_t dataW,
+                                                                  size_t dataH, size_t dataD,
+                                                                  size_t& dataPitch) {
   size_t elementSize = sizeof(T);
   size_t sizeInBytes = elementSize * dataW * dataH * dataD;
   T* aPtr{};
@@ -88,9 +88,8 @@ static std::pair<T*, T*> deviceMallocHelper(memSetType memType, size_t dataW, si
   return std::make_pair(aPtr, nullptr);
 }
 
-template <typename T>
-static std::pair<T*, T*> hostMallocHelper(size_t dataW, size_t dataH, size_t dataD,
-                                          size_t& dataPitch) {
+template <typename T> static std::pair<T*, T*> hostMallocHelper(size_t dataW, size_t dataH,
+                                                                size_t dataD, size_t& dataPitch) {
   size_t elementSize = sizeof(T);
   size_t sizeInBytes = elementSize * dataW * dataH * dataD;
   T* aPtr;
@@ -101,9 +100,9 @@ static std::pair<T*, T*> hostMallocHelper(size_t dataW, size_t dataH, size_t dat
   return std::make_pair(aPtr, nullptr);
 }
 
-template <typename T>
-static std::pair<T*, T*> hostRegisteredHelper(size_t dataW, size_t dataH, size_t dataD,
-                                              size_t& dataPitch) {
+template <typename T> static std::pair<T*, T*> hostRegisteredHelper(size_t dataW, size_t dataH,
+                                                                    size_t dataD,
+                                                                    size_t& dataPitch) {
   size_t elementSize = sizeof(T);
   size_t sizeInBytes = elementSize * dataW * dataH * dataD;
   T* aPtr = new T[dataW * dataH * dataD];
@@ -114,9 +113,9 @@ static std::pair<T*, T*> hostRegisteredHelper(size_t dataW, size_t dataH, size_t
   return std::make_pair(aPtr, nullptr);
 }
 
-template <typename T>
-static std::pair<T*, T*> devRegisteredHelper(size_t dataW, size_t dataH, size_t dataD,
-                                             size_t& dataPitch) {
+template <typename T> static std::pair<T*, T*> devRegisteredHelper(size_t dataW, size_t dataH,
+                                                                   size_t dataD,
+                                                                   size_t& dataPitch) {
   size_t elementSize = sizeof(T);
   size_t sizeInBytes = elementSize * dataW * dataH * dataD;
   T* aPtr = new T[dataW * dataH * dataD];
@@ -164,9 +163,9 @@ static std::pair<T*, T*> initMemory(allocType type, memSetType memType, MultiDDa
 }
 
 // set of helper functions to tidy the nested switch statements
-template <typename T>
-static void deviceMallocCopy(memSetType memType, T* aPtr, T* hostMem, size_t dataW, size_t dataH,
-                             size_t dataD, size_t& dataPitch) {
+template <typename T> static void deviceMallocCopy(memSetType memType, T* aPtr, T* hostMem,
+                                                   size_t dataW, size_t dataH, size_t dataD,
+                                                   size_t& dataPitch) {
   size_t elementSize = sizeof(T);
   size_t sizeInBytes = elementSize * dataW * dataH * dataD;
   switch (memType) {
@@ -200,9 +199,8 @@ static void deviceMallocCopy(memSetType memType, T* aPtr, T* hostMem, size_t dat
   }
 }
 
-template <typename T>
-static void hostCopy(memSetType memType, T* aPtr, T* hostMem, size_t dataW, size_t dataH,
-                     size_t dataD, size_t& dataPitch) {
+template <typename T> static void hostCopy(memSetType memType, T* aPtr, T* hostMem, size_t dataW,
+                                           size_t dataH, size_t dataD, size_t& dataPitch) {
   size_t elementSize = sizeof(T);
   size_t sizeInBytes = elementSize * dataW * dataH * dataD;
   hipMemcpy3DParms params{};
@@ -236,9 +234,9 @@ static void hostCopy(memSetType memType, T* aPtr, T* hostMem, size_t dataW, size
   }
 }
 
-template <typename T>
-static void devRegisteredCopy(memSetType memType, T* aPtr, T* hostMem, size_t dataW, size_t dataH,
-                              size_t dataD, size_t& dataPitch) {
+template <typename T> static void devRegisteredCopy(memSetType memType, T* aPtr, T* hostMem,
+                                                    size_t dataW, size_t dataH, size_t dataD,
+                                                    size_t& dataPitch) {
   size_t elementSize = sizeof(T);
 
   switch (memType) {
@@ -309,9 +307,9 @@ void verifyData(T* aPtr, size_t value, MultiDData& data, allocType type, memSetT
 }
 
 // macro to allow reuse of functions for testing versions of hipMemset
-template <typename T>
-void memsetCheck(T* aPtr, size_t value, memSetType memsetType, MultiDData& data, bool async = false,
-                 hipStream_t stream = nullptr) {
+template <typename T> void memsetCheck(T* aPtr, size_t value, memSetType memsetType,
+                                       MultiDData& data, bool async = false,
+                                       hipStream_t stream = nullptr) {
   size_t dataW = data.width;
   size_t dataH = data.height == 0 ? 1 : data.height;
   size_t dataD = data.depth == 0 ? 1 : data.depth;