From e650828b52db4cc854371aeb915c0d74bf9a2158 Mon Sep 17 00:00:00 2001 From: Guillaume Chatelet Date: Wed, 31 Jul 2019 12:47:20 +0000 Subject: [PATCH] [LLVM] Fix Alignment death tests in Release Mode git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@367427 91177308-0d34-0410-b5e6-96231b3b80d8 --- unittests/Support/AlignmentTest.cpp | 96 ++++++++++++++++------------- 1 file changed, 53 insertions(+), 43 deletions(-) diff --git a/unittests/Support/AlignmentTest.cpp b/unittests/Support/AlignmentTest.cpp index 9ae999200ef..57cc08c2d71 100644 --- a/unittests/Support/AlignmentTest.cpp +++ b/unittests/Support/AlignmentTest.cpp @@ -22,36 +22,20 @@ std::vector getValidAlignments() { return Out; } -// We use a subset of valid alignments for DEATH_TESTs as they are particularly -// slow. -std::vector getValidAlignmentsForDeathTest() { - return {1, 1ULL << 31, 1ULL << 63}; -} - -std::vector 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 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 getValidAlignmentsForDeathTest() { + return {1, 1ULL << 31, 1ULL << 63}; +} + +std::vector 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, CompareAlignToUndefMaybeAlign) { } } +#endif // NDEBUG + } // end anonymous namespace -- 2.40.0