From 000f8bdd65e989f10bad0631ce5adaa89d83d8e4 Mon Sep 17 00:00:00 2001
From: Adam Cetnerowski <adam.cetnerowski@intel.com>
Date: Thu, 26 Mar 2020 17:54:39 +0100
Subject: [PATCH] ULT renaming: Memory alignment tests

Related-To: NEO-2236

Change-Id: I47ef07092ed5c37dbb355e0d5b3b6c3bf1862160
Signed-off-by: Adam Cetnerowski <adam.cetnerowski@intel.com>
---
 .../helpers/aligned_memory_tests.cpp          | 50 +++++++++----------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/shared/test/unit_test/helpers/aligned_memory_tests.cpp b/shared/test/unit_test/helpers/aligned_memory_tests.cpp
index 2e3fde8eb5..b82ecc0789 100644
--- a/shared/test/unit_test/helpers/aligned_memory_tests.cpp
+++ b/shared/test/unit_test/helpers/aligned_memory_tests.cpp
@@ -11,7 +11,7 @@
 
 #include <cstdint>
 
-TEST(AlignedFree, nullptrShouldntCrash) {
+TEST(AlignedFree, GivenNullPtrWhenFreeingAlignedThenNoCrash) {
     alignedFree(nullptr);
 }
 void *ptrAlignedToPage = (void *)0x1000;
@@ -32,21 +32,21 @@ struct AlignedMalloc : public ::testing::TestWithParam<size_t> {
     size_t alignAlloc;
 };
 
-TEST_P(AlignedMalloc, size0) {
+TEST_P(AlignedMalloc, GivenSizeZeroWhenAllocatingAlignedThenAlignedPointerIsReturned) {
     size_t sizeAlloc = 0;
     ptr = alignedMalloc(sizeAlloc, alignAlloc);
     EXPECT_NE(nullptr, ptr);
     EXPECT_EQ(0u, (uintptr_t)ptr % alignAlloc);
 }
 
-TEST_P(AlignedMalloc, size4096) {
+TEST_P(AlignedMalloc, GivenSize4096WhenAllocatingAlignedThenAlignedPointerIsReturned) {
     size_t sizeAlloc = 4096;
     ptr = alignedMalloc(sizeAlloc, alignAlloc);
     EXPECT_NE(nullptr, ptr);
     EXPECT_EQ(0u, (uintptr_t)ptr % alignAlloc);
 }
 
-TEST(AlignedMallocTests, size0align4096) {
+TEST(AlignedMallocTests, GivenSizeZeroAndAlign4096WhenAllocatingAlignedThenAlignedPointerIsReturned) {
     size_t sizeAlloc = 0;
     auto ptr = alignedMalloc(sizeAlloc, 4096);
     EXPECT_NE(nullptr, ptr);
@@ -67,7 +67,7 @@ INSTANTIATE_TEST_CASE_P(
 struct AlignUp : public ::testing::TestWithParam<size_t> {
 };
 
-TEST_P(AlignUp, belowAlignmentBefore) {
+TEST_P(AlignUp, GivenPointerBelowAlignmentWhenAligningUpThenReturnAlignedPointer) {
     uintptr_t addrBefore = 0x1fffffff;
     auto ptrBefore = (uint32_t *)addrBefore;
 
@@ -78,7 +78,7 @@ TEST_P(AlignUp, belowAlignmentBefore) {
     EXPECT_EQ(0u, addrAfter % alignment);
 }
 
-TEST_P(AlignUp, AtAlignmentBefore) {
+TEST_P(AlignUp, GivenPointerAtAlignmentWhenAligningUpThenReturnAlignedPointer) {
     uintptr_t addrBefore = 0x20000000;
     auto ptrBefore = (uint32_t *)addrBefore;
 
@@ -89,7 +89,7 @@ TEST_P(AlignUp, AtAlignmentBefore) {
     EXPECT_EQ(0u, addrAfter % alignment);
 }
 
-TEST_P(AlignUp, AboveAlignmentBefore) {
+TEST_P(AlignUp, GivenPointerAboveAlignmentWhenAligningUpThenReturnAlignedPointer) {
     uintptr_t addrBefore = 0x20000001;
     auto ptrBefore = (uint32_t *)addrBefore;
 
@@ -100,7 +100,7 @@ TEST_P(AlignUp, AboveAlignmentBefore) {
     EXPECT_EQ(0u, addrAfter % alignment);
 }
 
-TEST_P(AlignUp, preserve64Bit) {
+TEST_P(AlignUp, WhenAligningUpThen64BitIsPreserved) {
     uint64_t aligned = 1ULL << 48;
     auto alignment = GetParam();
     auto result = alignUp(aligned, alignment);
@@ -119,36 +119,36 @@ INSTANTIATE_TEST_CASE_P(
         256,
         4096));
 
-TEST(AlignWholeSize, alignWholeSizeToPage) {
+TEST(AlignWholeSize, GivenSizeLessThanPageSizeWhenAligningWholeSizeToPageThenAlignedSizeIsPageSize) {
     int size = 1;
     auto retSize = alignSizeWholePage(ptrAlignedToPage, size);
     EXPECT_EQ(retSize, 4096u);
 }
-TEST(AlignWholeSize, sizeGreaterThenPageResultsIn2Pages) {
+TEST(AlignWholeSize, GivenSizeGreaterThanPageSizeWhenAligningWholeSizeToPageThenAlignedSizeIsMultipleOfPageSize) {
 
     int size = 4097;
     auto retSize = alignSizeWholePage(ptrAlignedToPage, size);
     EXPECT_EQ(retSize, 4096u * 2);
 }
-TEST(AlignWholeSize, allocationNotPageAligned) {
+TEST(AlignWholeSize, GivenSizeGreaterThanPageSizeAndUnalignedPointerWhenAligningWholeSizeToPageThenAlignedSizeIsMultipleOfPageSize) {
 
     int size = 4097;
     auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size);
     EXPECT_EQ(retSize, 4096u * 2);
 }
-TEST(AlignWholeSize, ptrNotAligned) {
+TEST(AlignWholeSize, GivenSizeOneAndUnalignedPointerWhenAligningWholeSizeToPageThenAlignedSizeIsPageSize) {
 
     int size = 1;
     auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size);
     EXPECT_EQ(retSize, 4096u);
 }
-TEST(AlignWholeSize, allocationFitsToOnePage) {
+TEST(AlignWholeSize, GivenSizeOneLessThanPageSizeAndUnalignedPointerWhenAligningWholeSizeToPageThenAlignedSizeIsPageSize) {
 
     int size = 4095;
     auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size);
     EXPECT_EQ(retSize, 4096u);
 }
-TEST(AlignWholeSize, allocationFitsTo2Pages) {
+TEST(AlignWholeSize, GivenSizeOneLessThanTwoPageSizeAndUnalignedPointerWhenAligningWholeSizeToPageThenAlignedSizeIsTwoPageSize) {
 
     int size = 4095 + 4096;
     auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size);
@@ -160,54 +160,54 @@ TEST(AlignWholeSize, allocationOverlapsToAnotherPage) {
     auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size);
     EXPECT_EQ(retSize, 4096u * 2);
 }
-TEST(AlignWholeSize, allocationOverlapsTo2AnotherPage) {
+TEST(AlignWholeSize, GivenSizeofTwoPagesAndUnalignedPointerWhenAligningWholeSizeToPageThenAlignedSizeIsThreePageSize) {
 
     int size = 4096 * 2;
     auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size);
     EXPECT_EQ(retSize, 4096u * 3);
 }
-TEST(AlignWholeSize, ptrProperlyAlignedTo2Pages) {
+TEST(AlignWholeSize, GivenSizeofTwoPagesAndAlignedPointerWhenAligningWholeSizeToPageThenAlignedSizeIsTwoPageSize) {
 
     int size = 4096 * 2;
     auto retSize = alignSizeWholePage(ptrAlignedToPage, size);
     EXPECT_EQ(retSize, 4096u * 2);
 }
 
-TEST(AlignDown, ptrAlignedToPageWhenAlignedDownReturnsTheSamePointer) {
+TEST(AlignDown, GivenPtrAlignedToPageWhenAligningDownToPageSizeThenReturnTheSamePointer) {
     void *ptr = (void *)0x1000;
 
     auto alignedDownPtr = alignDown(ptr, MemoryConstants::pageSize);
     EXPECT_EQ(ptr, alignedDownPtr);
 }
-TEST(AlignDown, ptrNotAlignedToPageWhenAlignedDownReturnsPageAlignedPointer) {
+TEST(AlignDown, GivenPtrNotAlignedToPageWhenAligningDownToPageSizeThenPageAlignedPointerIsReturned) {
     void *ptr = (void *)0x1001;
     void *expected_ptr = (void *)0x1000;
     auto alignedDownPtr = alignDown(ptr, MemoryConstants::pageSize);
     EXPECT_EQ(expected_ptr, alignedDownPtr);
 }
 
-TEST(AlignDown, ptrNotAlignedToPage2WhenAlignedDownReturnsPageAlignedPointer) {
+TEST(AlignDown, GivenPtrNotAlignedToTwoPageWhenAligningDownToPageSizeThenReturnAlignedPointerToPreviousPage) {
     void *ptr = (void *)0x1241;
     void *expected_ptr = (void *)0x1000;
     auto alignedDownPtr = alignDown(ptr, MemoryConstants::pageSize);
     EXPECT_EQ(expected_ptr, alignedDownPtr);
 }
 
-TEST(AlignDown, ptrNotAlignedToPage3WhenAlignedDownReturnsPageAlignedPointer) {
+TEST(AlignDown, GivenPtrNotAlignedToThreePageWhenAligningDownToPageSizeThenReturnAlignedPointerToPreviousPage) {
     void *ptr = (void *)0x3241;
     void *expected_ptr = (void *)0x3000;
     auto alignedDownPtr = alignDown(ptr, MemoryConstants::pageSize);
     EXPECT_EQ(expected_ptr, alignedDownPtr);
 }
 
-TEST(AlignDown, ptrNotAlignedToDwordWhenAlignedDownReturnsDwordAlignedPointer) {
+TEST(AlignDown, GivenPtrNotAlignedToDwordWhenAligningDownToDwordThenDwordAlignedPointerIsReturned) {
     void *ptr = (void *)0x3241;
     void *expected_ptr = (void *)0x3240;
     auto alignedDownPtr = alignDown(ptr, 4);
     EXPECT_EQ(expected_ptr, alignedDownPtr);
 }
 
-TEST(AlignDown, preserve64Bit) {
+TEST(AlignDown, WhenAligningDownThen64BitIsPreserved) {
     uint64_t aligned = 1ULL << 48;
     auto result = alignDown(aligned, MemoryConstants::pageSize);
     EXPECT_EQ(aligned, result);
@@ -243,7 +243,7 @@ class IsAlignedTests : public ::testing::Test {
 typedef ::testing::Types<int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double> IsAlignedTypes;
 
 TYPED_TEST_CASE(IsAlignedTests, IsAlignedTypes);
-TYPED_TEST(IsAlignedTests, aligned) {
+TYPED_TEST(IsAlignedTests, WhenCheckingForAlignmentThenReturnCorrectValue) {
     TypeParam *ptr = reinterpret_cast<TypeParam *>(static_cast<uintptr_t>(0xdeadbeefu));
     // one byte alignment should always return true
     if (alignof(TypeParam) == 1)
@@ -265,7 +265,7 @@ TYPED_TEST(IsAlignedTests, aligned) {
     EXPECT_FALSE(isAligned(ptr3));
 }
 
-TEST(IsAligned, nonPointerType) {
+TEST(IsAligned, GivenNonPointerTypeWhenCheckingForAlignmentThenReturnIsCorrect) {
     EXPECT_TRUE(isAligned<3>(0));
     EXPECT_FALSE(isAligned<3>(1));
     EXPECT_FALSE(isAligned<3>(2));
@@ -275,7 +275,7 @@ TEST(IsAligned, nonPointerType) {
     EXPECT_TRUE(isAligned<3>(6));
 }
 
-TEST(IsAligned, supportsConstexprEvaluation) {
+TEST(IsAligned, WhenUsingConstexprEvaluationThenResultIsCorrect) {
     static_assert(false == isAligned<3>(2), "");
     static_assert(true == isAligned<3>(3), "");
 }