43 static void test_alignments() { |
43 static void test_alignments() { |
44 log("### Test: %c" SIZE_FORMAT " " UINT64_FORMAT " : %c" SIZE_FORMAT " " UINT64_FORMAT " ###\n", |
44 log("### Test: %c" SIZE_FORMAT " " UINT64_FORMAT " : %c" SIZE_FORMAT " " UINT64_FORMAT " ###\n", |
45 std::numeric_limits<T>::is_signed ? 's' : 'u', sizeof(T), (uint64_t)std::numeric_limits<T>::max(), |
45 std::numeric_limits<T>::is_signed ? 's' : 'u', sizeof(T), (uint64_t)std::numeric_limits<T>::max(), |
46 std::numeric_limits<A>::is_signed ? 's' : 'u', sizeof(A), (uint64_t)std::numeric_limits<A>::max()); |
46 std::numeric_limits<A>::is_signed ? 's' : 'u', sizeof(A), (uint64_t)std::numeric_limits<A>::max()); |
47 |
47 |
48 ASSERT_LE((uint64_t)std::numeric_limits<T>::max(), (uint64_t)std::numeric_limits<intptr_t>::max()) << "The test assumes that casting to intptr_t will not truncate bits"; |
|
49 |
|
50 // Test all possible alignment values that fit in type A. |
48 // Test all possible alignment values that fit in type A. |
51 for (A alignment = max_alignment<A>(); alignment > 0; alignment >>= 1) { |
49 for (A alignment = max_alignment<A>(); alignment > 0; alignment >>= 1) { |
52 log("=== Alignment: " UINT64_FORMAT " ===\n", (uint64_t)alignment); |
50 log("=== Alignment: " UINT64_FORMAT " ===\n", (uint64_t)alignment); |
53 |
51 |
54 for (size_t i = 0; i < ARRAY_SIZE(values); i++) { |
52 for (size_t i = 0; i < ARRAY_SIZE(values); i++) { |
60 log("Testing align_up: alignment: 0x" UINT64_FORMAT_X " value: 0x" UINT64_FORMAT_X " expected: 0x" UINT64_FORMAT_X "\n", (uint64_t)alignment, values[i], up); |
58 log("Testing align_up: alignment: 0x" UINT64_FORMAT_X " value: 0x" UINT64_FORMAT_X " expected: 0x" UINT64_FORMAT_X "\n", (uint64_t)alignment, values[i], up); |
61 |
59 |
62 T value = T(values[i]); |
60 T value = T(values[i]); |
63 |
61 |
64 // Check against uint64_t version |
62 // Check against uint64_t version |
65 ASSERT_EQ(align_size_up(value, alignment), (intptr_t)up); |
63 ASSERT_EQ(align_size_up((uint64_t)value, alignment), up); |
66 // Check inline function vs macro |
64 // Check inline function vs macro |
67 ASSERT_EQ(align_size_up(value, alignment), (intptr_t)align_size_up_(value, alignment)); |
65 ASSERT_EQ(align_size_up(value, alignment), align_size_up_(value, alignment)); |
68 // Sanity check |
66 // Sanity check |
69 ASSERT_GE(align_size_up(value, alignment), (intptr_t)value); |
67 ASSERT_GE(align_size_up(value, alignment), value); |
70 } |
68 } |
71 |
69 |
72 // Test align down |
70 // Test align down |
73 const uint64_t down = align_size_down_(values[i], (uint64_t)alignment); |
71 const uint64_t down = align_size_down_(values[i], (uint64_t)alignment); |
74 if (down <= (uint64_t)std::numeric_limits<T>::max()) { |
72 if (down <= (uint64_t)std::numeric_limits<T>::max()) { |
75 log("Testing align_size_down: alignment: 0x" UINT64_FORMAT_X " value: 0x" UINT64_FORMAT_X " expected: 0x" UINT64_FORMAT_X "\n", (uint64_t)alignment, values[i], down); |
73 log("Testing align_size_down: alignment: 0x" UINT64_FORMAT_X " value: 0x" UINT64_FORMAT_X " expected: 0x" UINT64_FORMAT_X "\n", (uint64_t)alignment, values[i], down); |
76 |
74 |
77 T value = T(values[i]); |
75 T value = T(values[i]); |
78 |
76 |
79 // Check against uint64_t version |
77 // Check against uint64_t version |
80 ASSERT_EQ(align_size_down(value, alignment), (intptr_t)down); |
78 ASSERT_EQ((uint64_t)align_size_down(value, alignment), down); |
81 // Check inline function vs macro |
79 // Check inline function vs macro |
82 ASSERT_EQ(align_size_down(value, alignment), (intptr_t)align_size_down_(value, alignment)); |
80 ASSERT_EQ(align_size_down(value, alignment), align_size_down_(value, alignment)); |
83 // Sanity check |
81 // Sanity check |
84 ASSERT_LE(align_size_down(value, alignment), (intptr_t)value); |
82 ASSERT_LE(align_size_down(value, alignment), value); |
85 } |
83 } |
86 |
84 |
87 // Test is aligned |
85 // Test is aligned |
88 const bool is = is_size_aligned_(values[i], (uint64_t)alignment); |
86 const bool is = is_size_aligned_(values[i], (uint64_t)alignment); |
89 if (values[i] <= (uint64_t)std::numeric_limits<T>::max()) { |
87 if (values[i] <= (uint64_t)std::numeric_limits<T>::max()) { |
101 } |
99 } |
102 |
100 |
103 TEST(Align, functions_and_macros) { |
101 TEST(Align, functions_and_macros) { |
104 // Test the alignment functions with different type combinations. |
102 // Test the alignment functions with different type combinations. |
105 |
103 |
106 // The current implementation of the alignment functions use intptr_t |
|
107 // as return and input parameter type. Therefore, we restrict the tested |
|
108 // types on 32-bit platforms. |
|
109 #ifdef _LP64 |
|
110 test_alignments<int64_t, uint8_t>(); |
104 test_alignments<int64_t, uint8_t>(); |
111 test_alignments<int64_t, uint16_t>(); |
105 test_alignments<int64_t, uint16_t>(); |
112 test_alignments<int64_t, uint32_t>(); |
106 test_alignments<int64_t, uint32_t>(); |
113 test_alignments<int64_t, int8_t>(); |
107 test_alignments<int64_t, int8_t>(); |
114 test_alignments<int64_t, int16_t>(); |
108 test_alignments<int64_t, int16_t>(); |
119 test_alignments<uint32_t, uint16_t>(); |
113 test_alignments<uint32_t, uint16_t>(); |
120 test_alignments<uint32_t, uint32_t>(); |
114 test_alignments<uint32_t, uint32_t>(); |
121 test_alignments<uint32_t, int8_t>(); |
115 test_alignments<uint32_t, int8_t>(); |
122 test_alignments<uint32_t, int16_t>(); |
116 test_alignments<uint32_t, int16_t>(); |
123 test_alignments<uint32_t, int32_t>(); |
117 test_alignments<uint32_t, int32_t>(); |
124 #endif |
|
125 |
118 |
126 test_alignments<int32_t, uint8_t>(); |
119 test_alignments<int32_t, uint8_t>(); |
127 test_alignments<int32_t, uint16_t>(); |
120 test_alignments<int32_t, uint16_t>(); |
128 test_alignments<int32_t, int8_t>(); |
121 test_alignments<int32_t, int8_t>(); |
129 test_alignments<int32_t, int16_t>(); |
122 test_alignments<int32_t, int16_t>(); |