diff options
Diffstat (limited to 'llvm/unittests/FileCheck/FileCheckTest.cpp')
| -rw-r--r-- | llvm/unittests/FileCheck/FileCheckTest.cpp | 147 |
1 files changed, 98 insertions, 49 deletions
diff --git a/llvm/unittests/FileCheck/FileCheckTest.cpp b/llvm/unittests/FileCheck/FileCheckTest.cpp index c5eaa5f..3ed5143 100644 --- a/llvm/unittests/FileCheck/FileCheckTest.cpp +++ b/llvm/unittests/FileCheck/FileCheckTest.cpp @@ -87,7 +87,8 @@ constexpr uint64_t AbsoluteMaxInt64 = static_cast<uint64_t>(MaxInt64); struct ExpressionFormatParameterisedFixture : public ::testing::TestWithParam< - std::pair<ExpressionFormat::Kind, unsigned>> { + std::tuple<ExpressionFormat::Kind, unsigned, bool>> { + bool AlternateForm; unsigned Precision; bool Signed; bool AllowHex; @@ -108,12 +109,12 @@ struct ExpressionFormatParameterisedFixture void SetUp() override { ExpressionFormat::Kind Kind; - std::tie(Kind, Precision) = GetParam(); + std::tie(Kind, Precision, AlternateForm) = GetParam(); AllowHex = Kind == ExpressionFormat::Kind::HexLower || Kind == ExpressionFormat::Kind::HexUpper; AllowUpperHex = Kind == ExpressionFormat::Kind::HexUpper; Signed = Kind == ExpressionFormat::Kind::Signed; - Format = ExpressionFormat(Kind, Precision); + Format = ExpressionFormat(Kind, Precision, AlternateForm); if (!AllowHex) { MaxUint64Str = std::to_string(MaxUint64); @@ -138,10 +139,13 @@ struct ExpressionFormatParameterisedFixture void checkWildcardRegexMatch(StringRef Input, unsigned TrailExtendTo = 0) const { + ASSERT_TRUE(TrailExtendTo == 0 || AllowHex); SmallVector<StringRef, 4> Matches; std::string ExtendedInput = Input.str(); - if (TrailExtendTo > Input.size()) { - ExtendedInput.append(TrailExtendTo - Input.size(), Input[0]); + size_t PrefixSize = AlternateForm ? 2 : 0; + if (TrailExtendTo > Input.size() - PrefixSize) { + size_t ExtensionSize = PrefixSize + TrailExtendTo - Input.size(); + ExtendedInput.append(ExtensionSize, Input[PrefixSize]); } ASSERT_TRUE(WildcardRegex.match(ExtendedInput, &Matches)) << "Wildcard regex does not match " << ExtendedInput; @@ -152,9 +156,16 @@ struct ExpressionFormatParameterisedFixture EXPECT_FALSE(WildcardRegex.match(Input)); } + std::string addBasePrefix(StringRef Num) const { + StringRef Prefix = AlternateForm ? "0x" : ""; + return (Twine(Prefix) + Twine(Num)).str(); + } + void checkWildcardRegexCharMatchFailure(StringRef Chars) const { - for (auto C : Chars) - EXPECT_FALSE(WildcardRegex.match(StringRef(&C, 1))); + for (auto C : Chars) { + std::string Str = addBasePrefix(StringRef(&C, 1)); + EXPECT_FALSE(WildcardRegex.match(Str)); + } } std::string padWithLeadingZeros(StringRef NumStr) const { @@ -207,10 +218,10 @@ struct ExpressionFormatParameterisedFixture static_cast<uint64_t>(ExpectedVal)); } - void checkValueFromStringReprFailure(StringRef Str) { - StringRef OverflowErrorStr = "unable to represent numeric value"; + void checkValueFromStringReprFailure( + StringRef Str, StringRef ErrorStr = "unable to represent numeric value") { Expected<ExpressionValue> ResultValue = getValueFromStringReprFailure(Str); - expectDiagnosticError(OverflowErrorStr, ResultValue.takeError()); + expectDiagnosticError(ErrorStr, ResultValue.takeError()); } }; @@ -224,9 +235,17 @@ TEST_P(ExpressionFormatParameterisedFixture, FormatGetWildcardRegex) { // Does not match empty string. checkWildcardRegexMatchFailure(""); - // Matches all decimal digits and matches several of them. + // Matches all decimal digits, matches several of them and match 0x prefix + // if and only if AlternateForm is true. StringRef LongNumber = "12345678901234567890"; - checkWildcardRegexMatch(LongNumber); + StringRef PrefixedLongNumber = "0x12345678901234567890"; + if (AlternateForm) { + checkWildcardRegexMatch(PrefixedLongNumber); + checkWildcardRegexMatchFailure(LongNumber); + } else { + checkWildcardRegexMatch(LongNumber); + checkWildcardRegexMatchFailure(PrefixedLongNumber); + } // Matches negative digits. LongNumber = "-12345678901234567890"; @@ -236,8 +255,10 @@ TEST_P(ExpressionFormatParameterisedFixture, FormatGetWildcardRegex) { checkWildcardRegexMatchFailure(LongNumber); // Check non digits or digits with wrong casing are not matched. + std::string LongNumberStr; if (AllowHex) { - checkWildcardRegexMatch(AcceptedHexOnlyDigits, 16); + LongNumberStr = addBasePrefix(AcceptedHexOnlyDigits); + checkWildcardRegexMatch(LongNumberStr, 16); checkWildcardRegexCharMatchFailure(RefusedHexOnlyDigits); } checkWildcardRegexCharMatchFailure(FirstInvalidCharDigits); @@ -246,17 +267,23 @@ TEST_P(ExpressionFormatParameterisedFixture, FormatGetWildcardRegex) { // precision. LongNumber = "01234567890123456789"; if (Precision) { - checkWildcardRegexMatch(LongNumber.take_front(Precision)); - checkWildcardRegexMatchFailure(LongNumber.take_front(Precision - 1)); - if (Precision < LongNumber.size()) - checkWildcardRegexMatchFailure(LongNumber.take_front(Precision + 1)); - } else - checkWildcardRegexMatch(LongNumber); + LongNumberStr = addBasePrefix(LongNumber.take_front(Precision)); + checkWildcardRegexMatch(LongNumberStr); + LongNumberStr = addBasePrefix(LongNumber.take_front(Precision - 1)); + checkWildcardRegexMatchFailure(LongNumberStr); + if (Precision < LongNumber.size()) { + LongNumberStr = addBasePrefix(LongNumber.take_front(Precision + 1)); + checkWildcardRegexMatchFailure(LongNumberStr); + } + } else { + LongNumberStr = addBasePrefix(LongNumber); + checkWildcardRegexMatch(LongNumberStr); + } } TEST_P(ExpressionFormatParameterisedFixture, FormatGetMatchingString) { - checkMatchingString(0, padWithLeadingZeros("0")); - checkMatchingString(9, padWithLeadingZeros("9")); + checkMatchingString(0, addBasePrefix(padWithLeadingZeros("0"))); + checkMatchingString(9, addBasePrefix(padWithLeadingZeros("9"))); if (Signed) { checkMatchingString(-5, padWithLeadingZeros("-5")); @@ -265,33 +292,38 @@ TEST_P(ExpressionFormatParameterisedFixture, FormatGetMatchingString) { checkMatchingString(MinInt64, padWithLeadingZeros(MinInt64Str)); } else { checkMatchingStringFailure(-5); - checkMatchingString(MaxUint64, padWithLeadingZeros(MaxUint64Str)); - checkMatchingString(MaxInt64, padWithLeadingZeros(MaxInt64Str)); + checkMatchingString(MaxUint64, + addBasePrefix(padWithLeadingZeros(MaxUint64Str))); + checkMatchingString(MaxInt64, + addBasePrefix(padWithLeadingZeros(MaxInt64Str))); checkMatchingStringFailure(MinInt64); } - checkMatchingString(10, padWithLeadingZeros(TenStr)); - checkMatchingString(15, padWithLeadingZeros(FifteenStr)); + checkMatchingString(10, addBasePrefix(padWithLeadingZeros(TenStr))); + checkMatchingString(15, addBasePrefix(padWithLeadingZeros(FifteenStr))); } TEST_P(ExpressionFormatParameterisedFixture, FormatValueFromStringRepr) { - checkValueFromStringRepr("0", 0); - checkValueFromStringRepr("9", 9); + checkValueFromStringRepr(addBasePrefix("0"), 0); + checkValueFromStringRepr(addBasePrefix("9"), 9); if (Signed) { checkValueFromStringRepr("-5", -5); checkValueFromStringReprFailure(MaxUint64Str); } else { - checkValueFromStringReprFailure("-5"); - checkValueFromStringRepr(MaxUint64Str, MaxUint64); + checkValueFromStringReprFailure("-" + addBasePrefix("5")); + checkValueFromStringRepr(addBasePrefix(MaxUint64Str), MaxUint64); } - checkValueFromStringRepr(TenStr, 10); - checkValueFromStringRepr(FifteenStr, 15); + checkValueFromStringRepr(addBasePrefix(TenStr), 10); + checkValueFromStringRepr(addBasePrefix(FifteenStr), 15); // Wrong casing is not tested because valueFromStringRepr() relies on // StringRef's getAsInteger() which does not allow to restrict casing. - checkValueFromStringReprFailure("G"); + checkValueFromStringReprFailure(addBasePrefix("G")); + + if (AlternateForm) + checkValueFromStringReprFailure("9", "missing alternate form prefix"); } TEST_P(ExpressionFormatParameterisedFixture, FormatBoolOperator) { @@ -300,23 +332,30 @@ TEST_P(ExpressionFormatParameterisedFixture, FormatBoolOperator) { INSTANTIATE_TEST_CASE_P( AllowedExplicitExpressionFormat, ExpressionFormatParameterisedFixture, - ::testing::Values(std::make_pair(ExpressionFormat::Kind::Unsigned, 0), - std::make_pair(ExpressionFormat::Kind::Signed, 0), - std::make_pair(ExpressionFormat::Kind::HexLower, 0), - std::make_pair(ExpressionFormat::Kind::HexUpper, 0), - - std::make_pair(ExpressionFormat::Kind::Unsigned, 1), - std::make_pair(ExpressionFormat::Kind::Signed, 1), - std::make_pair(ExpressionFormat::Kind::HexLower, 1), - std::make_pair(ExpressionFormat::Kind::HexUpper, 1), - - std::make_pair(ExpressionFormat::Kind::Unsigned, 16), - std::make_pair(ExpressionFormat::Kind::Signed, 16), - std::make_pair(ExpressionFormat::Kind::HexLower, 16), - std::make_pair(ExpressionFormat::Kind::HexUpper, 16), - - std::make_pair(ExpressionFormat::Kind::Unsigned, 20), - std::make_pair(ExpressionFormat::Kind::Signed, 20)), ); + ::testing::Values( + std::make_tuple(ExpressionFormat::Kind::Unsigned, 0, false), + std::make_tuple(ExpressionFormat::Kind::Signed, 0, false), + std::make_tuple(ExpressionFormat::Kind::HexLower, 0, false), + std::make_tuple(ExpressionFormat::Kind::HexLower, 0, true), + std::make_tuple(ExpressionFormat::Kind::HexUpper, 0, false), + std::make_tuple(ExpressionFormat::Kind::HexUpper, 0, true), + + std::make_tuple(ExpressionFormat::Kind::Unsigned, 1, false), + std::make_tuple(ExpressionFormat::Kind::Signed, 1, false), + std::make_tuple(ExpressionFormat::Kind::HexLower, 1, false), + std::make_tuple(ExpressionFormat::Kind::HexLower, 1, true), + std::make_tuple(ExpressionFormat::Kind::HexUpper, 1, false), + std::make_tuple(ExpressionFormat::Kind::HexUpper, 1, true), + + std::make_tuple(ExpressionFormat::Kind::Unsigned, 16, false), + std::make_tuple(ExpressionFormat::Kind::Signed, 16, false), + std::make_tuple(ExpressionFormat::Kind::HexLower, 16, false), + std::make_tuple(ExpressionFormat::Kind::HexLower, 16, true), + std::make_tuple(ExpressionFormat::Kind::HexUpper, 16, false), + std::make_tuple(ExpressionFormat::Kind::HexUpper, 16, true), + + std::make_tuple(ExpressionFormat::Kind::Unsigned, 20, false), + std::make_tuple(ExpressionFormat::Kind::Signed, 20, false)), ); TEST_F(FileCheckTest, NoFormatProperties) { ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat); @@ -1043,6 +1082,16 @@ TEST_F(FileCheckTest, ParseNumericSubstitutionBlock) { EXPECT_FALSE(Tester.parsePattern("[[#%.8X, PADDED_ADDR:]]")); EXPECT_FALSE(Tester.parsePattern("[[#%.8, PADDED_NUM:]]")); + // Acceptable variable definition in alternate form. + EXPECT_THAT_EXPECTED(Tester.parseSubst("%#x, PREFIXED_ADDR:"), Succeeded()); + EXPECT_THAT_EXPECTED(Tester.parseSubst("%#X, PREFIXED_ADDR:"), Succeeded()); + + // Acceptable variable definition in alternate form. + expectDiagnosticError("alternate form only supported for hex values", + Tester.parseSubst("%#u, PREFIXED_UNSI:").takeError()); + expectDiagnosticError("alternate form only supported for hex values", + Tester.parseSubst("%#d, PREFIXED_UNSI:").takeError()); + // Acceptable variable definition from a numeric expression. EXPECT_THAT_EXPECTED(Tester.parseSubst("FOOBAR: FOO+1"), Succeeded()); |