[llvm] r367427 - [LLVM] Fix Alignment death tests in Release Mode
Guillaume Chatelet via llvm-commits
llvm-commits at lists.llvm.org
Wed Jul 31 05:47:20 PDT 2019
Author: gchatelet
Date: Wed Jul 31 05:47:20 2019
New Revision: 367427
URL: http://llvm.org/viewvc/llvm-project?rev=367427&view=rev
Log:
[LLVM] Fix Alignment death tests in Release Mode
Modified:
llvm/trunk/unittests/Support/AlignmentTest.cpp
Modified: llvm/trunk/unittests/Support/AlignmentTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Support/AlignmentTest.cpp?rev=367427&r1=367426&r2=367427&view=diff
==============================================================================
--- llvm/trunk/unittests/Support/AlignmentTest.cpp (original)
+++ llvm/trunk/unittests/Support/AlignmentTest.cpp Wed Jul 31 05:47:20 2019
@@ -22,36 +22,20 @@ std::vector<uint64_t> getValidAlignments
return Out;
}
-// We use a subset of valid alignments for DEATH_TESTs as they are particularly
-// slow.
-std::vector<uint64_t> getValidAlignmentsForDeathTest() {
- return {1, 1ULL << 31, 1ULL << 63};
-}
-
-std::vector<uint64_t> getNonPowerOfTwo() { return {3, 10, 15}; }
+TEST(AlignmentTest, AlignDefaultCTor) { EXPECT_EQ(Align().value(), 1ULL); }
-TEST(Alignment, AlignDefaultCTor) { EXPECT_EQ(Align().value(), 1ULL); }
-
-TEST(Alignment, MaybeAlignDefaultCTor) {
+TEST(AlignmentTest, MaybeAlignDefaultCTor) {
EXPECT_FALSE(MaybeAlign().hasValue());
}
-TEST(Alignment, ValidCTors) {
+TEST(AlignmentTest, ValidCTors) {
for (size_t Value : getValidAlignments()) {
EXPECT_EQ(Align(Value).value(), Value);
EXPECT_EQ((*MaybeAlign(Value)).value(), Value);
}
}
-TEST(Alignment, InvalidCTors) {
- EXPECT_DEATH((Align(0)), "Value must not be 0");
- for (size_t Value : getNonPowerOfTwo()) {
- EXPECT_DEATH((Align(Value)), "Alignment is not a power of 2");
- EXPECT_DEATH((MaybeAlign(Value)), "Alignment is not 0 or a power of 2");
- }
-}
-
-TEST(Alignment, CheckMaybeAlignHasValue) {
+TEST(AlignmentTest, CheckMaybeAlignHasValue) {
EXPECT_TRUE(MaybeAlign(1));
EXPECT_TRUE(MaybeAlign(1).hasValue());
EXPECT_FALSE(MaybeAlign(0));
@@ -60,27 +44,17 @@ TEST(Alignment, CheckMaybeAlignHasValue)
EXPECT_FALSE(MaybeAlign().hasValue());
}
-TEST(Alignment, CantConvertUnsetMaybe) {
- EXPECT_DEATH((MaybeAlign(0).getValue()), ".*");
-}
-
-TEST(Alignment, Division) {
+TEST(AlignmentTest, Division) {
for (size_t Value : getValidAlignments()) {
- if (Value == 1) {
- EXPECT_DEATH(Align(Value) / 2, "Can't halve byte alignment");
- EXPECT_DEATH(MaybeAlign(Value) / 2, "Can't halve byte alignment");
- } else {
+ if (Value > 1) {
EXPECT_EQ(Align(Value) / 2, Value / 2);
EXPECT_EQ(MaybeAlign(Value) / 2, Value / 2);
}
}
EXPECT_EQ(MaybeAlign(0) / 2, MaybeAlign(0));
-
- EXPECT_DEATH(Align(8) / 0, "Divisor must be positive and a power of 2");
- EXPECT_DEATH(Align(8) / 3, "Divisor must be positive and a power of 2");
}
-TEST(Alignment, AlignTo) {
+TEST(AlignmentTest, AlignTo) {
struct {
uint64_t alignment;
uint64_t offset;
@@ -114,15 +88,14 @@ TEST(Alignment, AlignTo) {
}
}
-TEST(Alignment, Log2) {
+TEST(AlignmentTest, Log2) {
for (size_t Value : getValidAlignments()) {
EXPECT_EQ(Log2(Align(Value)), Log2_64(Value));
EXPECT_EQ(Log2(MaybeAlign(Value)), Log2_64(Value));
}
- EXPECT_DEATH(Log2(MaybeAlign(0)), ".* should be defined");
}
-TEST(Alignment, MinAlign) {
+TEST(AlignmentTest, MinAlign) {
struct {
uint64_t A;
uint64_t B;
@@ -148,7 +121,7 @@ TEST(Alignment, MinAlign) {
}
}
-TEST(Alignment, Encode_Decode) {
+TEST(AlignmentTest, Encode_Decode) {
for (size_t Value : getValidAlignments()) {
{
Align Actual(Value);
@@ -166,7 +139,7 @@ TEST(Alignment, Encode_Decode) {
EXPECT_EQ(Expected, Actual);
}
-TEST(Alignment, isAligned) {
+TEST(AlignmentTest, isAligned) {
struct {
uint64_t alignment;
uint64_t offset;
@@ -187,7 +160,7 @@ TEST(Alignment, isAligned) {
}
}
-TEST(Alignment, AlignComparisons) {
+TEST(AlignmentTest, AlignComparisons) {
std::vector<uint64_t> ValidAlignments = getValidAlignments();
std::sort(ValidAlignments.begin(), ValidAlignments.end());
for (size_t I = 1; I < ValidAlignments.size(); ++I) {
@@ -240,14 +213,49 @@ TEST(Alignment, AlignComparisons) {
}
}
-TEST(Alignment, AssumeAligned) {
+TEST(AlignmentTest, AssumeAligned) {
EXPECT_EQ(assumeAligned(0), Align(1));
EXPECT_EQ(assumeAligned(0), Align());
EXPECT_EQ(assumeAligned(1), Align(1));
EXPECT_EQ(assumeAligned(1), Align());
}
-TEST(Alignment, ComparisonsWithZero) {
+// Death tests reply on assert which is disabled in release mode.
+#ifndef NDEBUG
+
+// We use a subset of valid alignments for DEATH_TESTs as they are particularly
+// slow.
+std::vector<uint64_t> getValidAlignmentsForDeathTest() {
+ return {1, 1ULL << 31, 1ULL << 63};
+}
+
+std::vector<uint64_t> getNonPowerOfTwo() { return {3, 10, 15}; }
+
+TEST(AlignmentDeathTest, Log2) {
+ EXPECT_DEATH(Log2(MaybeAlign(0)), ".* should be defined");
+}
+
+TEST(AlignmentDeathTest, CantConvertUnsetMaybe) {
+ EXPECT_DEATH((MaybeAlign(0).getValue()), ".*");
+}
+
+TEST(AlignmentDeathTest, Division) {
+ EXPECT_DEATH(Align(1) / 2, "Can't halve byte alignment");
+ EXPECT_DEATH(MaybeAlign(1) / 2, "Can't halve byte alignment");
+
+ EXPECT_DEATH(Align(8) / 0, "Divisor must be positive and a power of 2");
+ EXPECT_DEATH(Align(8) / 3, "Divisor must be positive and a power of 2");
+}
+
+TEST(AlignmentDeathTest, InvalidCTors) {
+ EXPECT_DEATH((Align(0)), "Value must not be 0");
+ for (size_t Value : getNonPowerOfTwo()) {
+ EXPECT_DEATH((Align(Value)), "Alignment is not a power of 2");
+ EXPECT_DEATH((MaybeAlign(Value)), "Alignment is not 0 or a power of 2");
+ }
+}
+
+TEST(AlignmentDeathTest, ComparisonsWithZero) {
for (size_t Value : getValidAlignmentsForDeathTest()) {
EXPECT_DEATH((void)(Align(Value) == 0), ".* should be defined");
EXPECT_DEATH((void)(Align(Value) != 0), ".* should be defined");
@@ -258,7 +266,7 @@ TEST(Alignment, ComparisonsWithZero) {
}
}
-TEST(Alignment, CompareMaybeAlignToZero) {
+TEST(AlignmentDeathTest, CompareMaybeAlignToZero) {
for (size_t Value : getValidAlignmentsForDeathTest()) {
// MaybeAlign is allowed to be == or != 0
(void)(MaybeAlign(Value) == 0);
@@ -270,7 +278,7 @@ TEST(Alignment, CompareMaybeAlignToZero)
}
}
-TEST(Alignment, CompareAlignToUndefMaybeAlign) {
+TEST(AlignmentDeathTest, CompareAlignToUndefMaybeAlign) {
for (size_t Value : getValidAlignmentsForDeathTest()) {
EXPECT_DEATH((void)(Align(Value) == MaybeAlign(0)), ".* should be defined");
EXPECT_DEATH((void)(Align(Value) != MaybeAlign(0)), ".* should be defined");
@@ -281,4 +289,6 @@ TEST(Alignment, CompareAlignToUndefMaybe
}
}
+#endif // NDEBUG
+
} // end anonymous namespace
More information about the llvm-commits
mailing list