1 //===- llvm/unittest/FileCheck/FileCheckTest.cpp - FileCheck tests --------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "llvm/FileCheck/FileCheck.h" 10 #include "../lib/FileCheck/FileCheckImpl.h" 11 #include "llvm/Support/Regex.h" 12 #include "llvm/Testing/Support/Error.h" 13 #include "gtest/gtest.h" 14 #include <tuple> 15 #include <unordered_set> 16 17 using namespace llvm; 18 19 namespace { 20 21 class FileCheckTest : public ::testing::Test {}; 22 23 static StringRef bufferize(SourceMgr &SM, StringRef Str) { 24 std::unique_ptr<MemoryBuffer> Buffer = 25 MemoryBuffer::getMemBufferCopy(Str, "TestBuffer"); 26 StringRef StrBufferRef = Buffer->getBuffer(); 27 SM.AddNewSourceBuffer(std::move(Buffer), SMLoc()); 28 return StrBufferRef; 29 } 30 31 static std::string toString(const std::unordered_set<std::string> &Set) { 32 bool First = true; 33 std::string Str; 34 for (StringRef S : Set) { 35 Str += Twine(First ? "{" + S : ", " + S).str(); 36 First = false; 37 } 38 Str += '}'; 39 return Str; 40 } 41 42 template <typename ErrorT> 43 static void expectSameErrors(std::unordered_set<std::string> ExpectedMsgs, 44 Error Err) { 45 auto AnyErrorMsgMatch = [&ExpectedMsgs](std::string &&ErrorMsg) -> bool { 46 for (auto ExpectedMsgItr = ExpectedMsgs.begin(), 47 ExpectedMsgEnd = ExpectedMsgs.end(); 48 ExpectedMsgItr != ExpectedMsgEnd; ++ExpectedMsgItr) { 49 if (ErrorMsg.find(*ExpectedMsgItr) != std::string::npos) { 50 ExpectedMsgs.erase(ExpectedMsgItr); 51 return true; 52 } 53 } 54 return false; 55 }; 56 57 Error RemainingErrors = std::move(Err); 58 do { 59 RemainingErrors = 60 handleErrors(std::move(RemainingErrors), [&](const ErrorT &E) { 61 EXPECT_TRUE(AnyErrorMsgMatch(E.message())) 62 << "Unexpected error message:" << std::endl 63 << E.message(); 64 }); 65 } while (RemainingErrors && !ExpectedMsgs.empty()); 66 EXPECT_THAT_ERROR(std::move(RemainingErrors), Succeeded()); 67 EXPECT_TRUE(ExpectedMsgs.empty()) 68 << "Error message(s) not found:" << std::endl 69 << toString(ExpectedMsgs); 70 } 71 72 template <typename ErrorT> 73 static void expectError(StringRef ExpectedMsg, Error Err) { 74 expectSameErrors<ErrorT>({ExpectedMsg.str()}, std::move(Err)); 75 } 76 77 static void expectDiagnosticError(StringRef ExpectedMsg, Error Err) { 78 expectError<ErrorDiagnostic>(ExpectedMsg, std::move(Err)); 79 } 80 81 constexpr uint64_t MaxUint64 = std::numeric_limits<uint64_t>::max(); 82 constexpr int64_t MaxInt64 = std::numeric_limits<int64_t>::max(); 83 constexpr int64_t MinInt64 = std::numeric_limits<int64_t>::min(); 84 constexpr uint64_t AbsoluteMinInt64 = 85 static_cast<uint64_t>(-(MinInt64 + 1)) + 1; 86 constexpr uint64_t AbsoluteMaxInt64 = static_cast<uint64_t>(MaxInt64); 87 // Use 128 bitwidth for literals to keep one bit for sign for uint64_t 88 // literals. 89 constexpr unsigned LiteralsBitWidth = 128; 90 91 struct ExpressionFormatParameterisedFixture 92 : public ::testing::TestWithParam< 93 std::tuple<ExpressionFormat::Kind, unsigned, bool>> { 94 bool AlternateForm; 95 unsigned Precision; 96 bool Signed; 97 bool AllowHex; 98 bool AllowUpperHex; 99 ExpressionFormat Format; 100 Regex WildcardRegex; 101 102 StringRef TenStr; 103 StringRef FifteenStr; 104 std::string MaxUint64Str; 105 std::string MaxInt64Str; 106 std::string MinInt64Str; 107 StringRef FirstInvalidCharDigits; 108 StringRef AcceptedHexOnlyDigits; 109 StringRef RefusedHexOnlyDigits; 110 111 SourceMgr SM; 112 113 void SetUp() override { 114 ExpressionFormat::Kind Kind; 115 std::tie(Kind, Precision, AlternateForm) = GetParam(); 116 AllowHex = Kind == ExpressionFormat::Kind::HexLower || 117 Kind == ExpressionFormat::Kind::HexUpper; 118 AllowUpperHex = Kind == ExpressionFormat::Kind::HexUpper; 119 Signed = Kind == ExpressionFormat::Kind::Signed; 120 Format = ExpressionFormat(Kind, Precision, AlternateForm); 121 122 if (!AllowHex) { 123 MaxUint64Str = std::to_string(MaxUint64); 124 MaxInt64Str = std::to_string(MaxInt64); 125 MinInt64Str = std::to_string(MinInt64); 126 TenStr = "10"; 127 FifteenStr = "15"; 128 FirstInvalidCharDigits = "aA"; 129 AcceptedHexOnlyDigits = RefusedHexOnlyDigits = "N/A"; 130 return; 131 } 132 133 MaxUint64Str = AllowUpperHex ? "FFFFFFFFFFFFFFFF" : "ffffffffffffffff"; 134 MaxInt64Str = AllowUpperHex ? "7FFFFFFFFFFFFFFF" : "7fffffffffffffff"; 135 TenStr = AllowUpperHex ? "A" : "a"; 136 FifteenStr = AllowUpperHex ? "F" : "f"; 137 AcceptedHexOnlyDigits = AllowUpperHex ? "ABCDEF" : "abcdef"; 138 RefusedHexOnlyDigits = AllowUpperHex ? "abcdef" : "ABCDEF"; 139 MinInt64Str = "N/A"; 140 FirstInvalidCharDigits = "gG"; 141 } 142 143 void checkWildcardRegexMatch(StringRef Input, 144 unsigned TrailExtendTo = 0) const { 145 ASSERT_TRUE(TrailExtendTo == 0 || AllowHex); 146 SmallVector<StringRef, 4> Matches; 147 std::string ExtendedInput = Input.str(); 148 size_t PrefixSize = AlternateForm ? 2 : 0; 149 if (TrailExtendTo > Input.size() - PrefixSize) { 150 size_t ExtensionSize = PrefixSize + TrailExtendTo - Input.size(); 151 ExtendedInput.append(ExtensionSize, Input[PrefixSize]); 152 } 153 ASSERT_TRUE(WildcardRegex.match(ExtendedInput, &Matches)) 154 << "Wildcard regex does not match " << ExtendedInput; 155 EXPECT_EQ(Matches[0], ExtendedInput); 156 } 157 158 void checkWildcardRegexMatchFailure(StringRef Input) const { 159 EXPECT_FALSE(WildcardRegex.match(Input)); 160 } 161 162 std::string addBasePrefix(StringRef Num) const { 163 StringRef Prefix = AlternateForm ? "0x" : ""; 164 return (Twine(Prefix) + Twine(Num)).str(); 165 } 166 167 void checkPerCharWildcardRegexMatchFailure(StringRef Chars) const { 168 for (auto C : Chars) { 169 std::string Str = addBasePrefix(StringRef(&C, 1)); 170 EXPECT_FALSE(WildcardRegex.match(Str)); 171 } 172 } 173 174 std::string padWithLeadingZeros(StringRef NumStr) const { 175 bool Negative = NumStr.startswith("-"); 176 if (NumStr.size() - unsigned(Negative) >= Precision) 177 return NumStr.str(); 178 179 std::string PaddedStr; 180 if (Negative) { 181 PaddedStr = "-"; 182 NumStr = NumStr.drop_front(); 183 } 184 PaddedStr.append(Precision - NumStr.size(), '0'); 185 PaddedStr.append(NumStr.str()); 186 return PaddedStr; 187 } 188 189 template <class T> void checkMatchingString(T Val, StringRef ExpectedStr) { 190 APInt Value(LiteralsBitWidth, Val, std::is_signed_v<T>); 191 Expected<std::string> MatchingString = Format.getMatchingString(Value); 192 ASSERT_THAT_EXPECTED(MatchingString, Succeeded()) 193 << "No matching string for " << Val; 194 EXPECT_EQ(*MatchingString, ExpectedStr); 195 } 196 197 template <class T> void checkMatchingStringFailure(T Val) { 198 APInt Value(LiteralsBitWidth, Val, std::is_signed_v<T>); 199 Expected<std::string> MatchingString = Format.getMatchingString(Value); 200 // Error message tested in ExpressionFormat unit tests. 201 EXPECT_THAT_EXPECTED(MatchingString, Failed()); 202 } 203 204 template <class T> 205 void checkValueFromStringRepr(StringRef Str, T ExpectedVal) { 206 StringRef BufferizedStr = bufferize(SM, Str); 207 APInt ResultValue = Format.valueFromStringRepr(BufferizedStr, SM); 208 ASSERT_EQ(ResultValue.isNegative(), ExpectedVal < 0) 209 << "Value for " << Str << " is not " << ExpectedVal; 210 if (ResultValue.isNegative()) 211 EXPECT_EQ(ResultValue.getSExtValue(), static_cast<int64_t>(ExpectedVal)); 212 else 213 EXPECT_EQ(ResultValue.getZExtValue(), static_cast<uint64_t>(ExpectedVal)); 214 } 215 }; 216 217 TEST_P(ExpressionFormatParameterisedFixture, FormatGetWildcardRegex) { 218 // Wildcard regex is valid. 219 Expected<std::string> WildcardPattern = Format.getWildcardRegex(); 220 ASSERT_THAT_EXPECTED(WildcardPattern, Succeeded()); 221 WildcardRegex = Regex((Twine("^") + *WildcardPattern + "$").str()); 222 ASSERT_TRUE(WildcardRegex.isValid()); 223 224 // Does not match empty string. 225 checkWildcardRegexMatchFailure(""); 226 227 // Matches all decimal digits, matches several of them and match 0x prefix 228 // if and only if AlternateForm is true. 229 StringRef LongNumber = "12345678901234567890"; 230 StringRef PrefixedLongNumber = "0x12345678901234567890"; 231 if (AlternateForm) { 232 checkWildcardRegexMatch(PrefixedLongNumber); 233 checkWildcardRegexMatchFailure(LongNumber); 234 } else { 235 checkWildcardRegexMatch(LongNumber); 236 checkWildcardRegexMatchFailure(PrefixedLongNumber); 237 } 238 239 // Matches negative digits. 240 LongNumber = "-12345678901234567890"; 241 if (Signed) 242 checkWildcardRegexMatch(LongNumber); 243 else 244 checkWildcardRegexMatchFailure(LongNumber); 245 246 // Check non digits or digits with wrong casing are not matched. 247 std::string LongNumberStr; 248 if (AllowHex) { 249 LongNumberStr = addBasePrefix(AcceptedHexOnlyDigits); 250 checkWildcardRegexMatch(LongNumberStr, 16); 251 checkPerCharWildcardRegexMatchFailure(RefusedHexOnlyDigits); 252 } 253 checkPerCharWildcardRegexMatchFailure(FirstInvalidCharDigits); 254 255 // Check leading zeros are only accepted if number of digits is less than the 256 // precision. 257 LongNumber = "01234567890123456789"; 258 if (Precision) { 259 LongNumberStr = addBasePrefix(LongNumber.take_front(Precision)); 260 checkWildcardRegexMatch(LongNumberStr); 261 LongNumberStr = addBasePrefix(LongNumber.take_front(Precision - 1)); 262 checkWildcardRegexMatchFailure(LongNumberStr); 263 if (Precision < LongNumber.size()) { 264 LongNumberStr = addBasePrefix(LongNumber.take_front(Precision + 1)); 265 checkWildcardRegexMatchFailure(LongNumberStr); 266 } 267 } else { 268 LongNumberStr = addBasePrefix(LongNumber); 269 checkWildcardRegexMatch(LongNumberStr); 270 } 271 } 272 273 TEST_P(ExpressionFormatParameterisedFixture, FormatGetMatchingString) { 274 checkMatchingString(0, addBasePrefix(padWithLeadingZeros("0"))); 275 checkMatchingString(9, addBasePrefix(padWithLeadingZeros("9"))); 276 277 if (Signed) { 278 checkMatchingString(-5, padWithLeadingZeros("-5")); 279 checkMatchingString(MaxUint64, padWithLeadingZeros(MaxUint64Str)); 280 checkMatchingString(MaxInt64, padWithLeadingZeros(MaxInt64Str)); 281 checkMatchingString(MinInt64, padWithLeadingZeros(MinInt64Str)); 282 } else { 283 checkMatchingStringFailure(-5); 284 checkMatchingString(MaxUint64, 285 addBasePrefix(padWithLeadingZeros(MaxUint64Str))); 286 checkMatchingString(MaxInt64, 287 addBasePrefix(padWithLeadingZeros(MaxInt64Str))); 288 checkMatchingStringFailure(MinInt64); 289 } 290 291 checkMatchingString(10, addBasePrefix(padWithLeadingZeros(TenStr))); 292 checkMatchingString(15, addBasePrefix(padWithLeadingZeros(FifteenStr))); 293 } 294 295 TEST_P(ExpressionFormatParameterisedFixture, FormatValueFromStringRepr) { 296 checkValueFromStringRepr(addBasePrefix("0"), 0); 297 checkValueFromStringRepr(addBasePrefix("9"), 9); 298 299 if (Signed) { 300 checkValueFromStringRepr("-5", -5); 301 checkValueFromStringRepr(MaxUint64Str, MaxUint64); 302 } else { 303 checkValueFromStringRepr(addBasePrefix(MaxUint64Str), MaxUint64); 304 } 305 306 checkValueFromStringRepr(addBasePrefix(TenStr), 10); 307 checkValueFromStringRepr(addBasePrefix(FifteenStr), 15); 308 309 // Wrong casing is not tested because valueFromStringRepr() relies on 310 // StringRef's getAsInteger() which does not allow to restrict casing. 311 312 // Likewise, wrong letter digit for hex value is not tested because it is 313 // only caught by an assert in FileCheck due to getWildcardRegex() 314 // guaranteeing only valid letter digits are used. 315 } 316 317 TEST_P(ExpressionFormatParameterisedFixture, FormatBoolOperator) { 318 EXPECT_TRUE(bool(Format)); 319 } 320 321 INSTANTIATE_TEST_SUITE_P( 322 AllowedExplicitExpressionFormat, ExpressionFormatParameterisedFixture, 323 ::testing::Values( 324 std::make_tuple(ExpressionFormat::Kind::Unsigned, 0, false), 325 std::make_tuple(ExpressionFormat::Kind::Signed, 0, false), 326 std::make_tuple(ExpressionFormat::Kind::HexLower, 0, false), 327 std::make_tuple(ExpressionFormat::Kind::HexLower, 0, true), 328 std::make_tuple(ExpressionFormat::Kind::HexUpper, 0, false), 329 std::make_tuple(ExpressionFormat::Kind::HexUpper, 0, true), 330 331 std::make_tuple(ExpressionFormat::Kind::Unsigned, 1, false), 332 std::make_tuple(ExpressionFormat::Kind::Signed, 1, false), 333 std::make_tuple(ExpressionFormat::Kind::HexLower, 1, false), 334 std::make_tuple(ExpressionFormat::Kind::HexLower, 1, true), 335 std::make_tuple(ExpressionFormat::Kind::HexUpper, 1, false), 336 std::make_tuple(ExpressionFormat::Kind::HexUpper, 1, true), 337 338 std::make_tuple(ExpressionFormat::Kind::Unsigned, 16, false), 339 std::make_tuple(ExpressionFormat::Kind::Signed, 16, false), 340 std::make_tuple(ExpressionFormat::Kind::HexLower, 16, false), 341 std::make_tuple(ExpressionFormat::Kind::HexLower, 16, true), 342 std::make_tuple(ExpressionFormat::Kind::HexUpper, 16, false), 343 std::make_tuple(ExpressionFormat::Kind::HexUpper, 16, true), 344 345 std::make_tuple(ExpressionFormat::Kind::Unsigned, 20, false), 346 std::make_tuple(ExpressionFormat::Kind::Signed, 20, false))); 347 348 TEST_F(FileCheckTest, NoFormatProperties) { 349 ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat); 350 expectError<StringError>("trying to match value with invalid format", 351 NoFormat.getWildcardRegex().takeError()); 352 expectError<StringError>( 353 "trying to match value with invalid format", 354 NoFormat.getMatchingString(APInt(64, 18u)).takeError()); 355 EXPECT_FALSE(bool(NoFormat)); 356 } 357 358 TEST_F(FileCheckTest, FormatEqualityOperators) { 359 ExpressionFormat UnsignedFormat(ExpressionFormat::Kind::Unsigned); 360 ExpressionFormat UnsignedFormat2(ExpressionFormat::Kind::Unsigned); 361 EXPECT_TRUE(UnsignedFormat == UnsignedFormat2); 362 EXPECT_FALSE(UnsignedFormat != UnsignedFormat2); 363 364 ExpressionFormat HexLowerFormat(ExpressionFormat::Kind::HexLower); 365 EXPECT_FALSE(UnsignedFormat == HexLowerFormat); 366 EXPECT_TRUE(UnsignedFormat != HexLowerFormat); 367 368 ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat); 369 ExpressionFormat NoFormat2(ExpressionFormat::Kind::NoFormat); 370 EXPECT_FALSE(NoFormat == NoFormat2); 371 EXPECT_TRUE(NoFormat != NoFormat2); 372 } 373 374 TEST_F(FileCheckTest, FormatKindEqualityOperators) { 375 ExpressionFormat UnsignedFormat(ExpressionFormat::Kind::Unsigned); 376 EXPECT_TRUE(UnsignedFormat == ExpressionFormat::Kind::Unsigned); 377 EXPECT_FALSE(UnsignedFormat != ExpressionFormat::Kind::Unsigned); 378 EXPECT_FALSE(UnsignedFormat == ExpressionFormat::Kind::HexLower); 379 EXPECT_TRUE(UnsignedFormat != ExpressionFormat::Kind::HexLower); 380 ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat); 381 EXPECT_TRUE(NoFormat == ExpressionFormat::Kind::NoFormat); 382 EXPECT_FALSE(NoFormat != ExpressionFormat::Kind::NoFormat); 383 } 384 385 static void expectOperationValueResult(binop_eval_t Operation, APInt LeftValue, 386 APInt RightValue, APInt ExpectedValue) { 387 bool Overflow; 388 Expected<APInt> OperationResult = Operation(LeftValue, RightValue, Overflow); 389 ASSERT_THAT_EXPECTED(OperationResult, Succeeded()); 390 EXPECT_EQ(*OperationResult, ExpectedValue); 391 } 392 393 template <class T1, class T2, class TR> 394 static void expectOperationValueResult(binop_eval_t Operation, T1 LeftValue, 395 T2 RightValue, TR ResultValue) { 396 APInt LeftVal(LiteralsBitWidth, LeftValue, std::is_signed_v<T1>); 397 APInt RightVal(LiteralsBitWidth, RightValue, std::is_signed_v<T2>); 398 APInt ResultVal; 399 if constexpr (std::is_integral_v<TR>) 400 ResultVal = APInt(LiteralsBitWidth, ResultValue, std::is_signed_v<TR>); 401 else 402 ResultVal = APInt(LiteralsBitWidth, ResultValue, /*Radix=*/10); 403 expectOperationValueResult(Operation, LeftVal, RightVal, ResultVal); 404 } 405 406 template <class T1, class T2> 407 static void expectOperationValueResult(binop_eval_t Operation, T1 LeftValue, 408 T2 RightValue) { 409 bool Overflow; 410 APInt LeftVal(LiteralsBitWidth, LeftValue, std::is_signed_v<T1>); 411 APInt RightVal(LiteralsBitWidth, RightValue, std::is_signed_v<T2>); 412 expectError<OverflowError>( 413 "overflow error", Operation(LeftVal, RightVal, Overflow).takeError()); 414 } 415 416 TEST_F(FileCheckTest, ExpressionValueAddition) { 417 // Test both negative values. 418 expectOperationValueResult(exprAdd, -10, -10, -20); 419 420 // Test both negative values with underflow. 421 expectOperationValueResult(exprAdd, MinInt64, -1, "-9223372036854775809"); 422 expectOperationValueResult(exprAdd, MinInt64, MinInt64, 423 "-18446744073709551616"); 424 425 // Test negative and positive value. 426 expectOperationValueResult(exprAdd, -10, 10, 0); 427 expectOperationValueResult(exprAdd, -10, 11, 1); 428 expectOperationValueResult(exprAdd, -11, 10, -1); 429 430 // Test positive and negative value. 431 expectOperationValueResult(exprAdd, 10, -10, 0); 432 expectOperationValueResult(exprAdd, 10, -11, -1); 433 expectOperationValueResult(exprAdd, 11, -10, 1); 434 435 // Test both positive values. 436 expectOperationValueResult(exprAdd, 10, 10, 20); 437 438 // Test both positive values with result not representable as uint64_t. 439 expectOperationValueResult(exprAdd, MaxUint64, 1, "18446744073709551616"); 440 expectOperationValueResult(exprAdd, MaxUint64, MaxUint64, 441 "36893488147419103230"); 442 } 443 444 TEST_F(FileCheckTest, ExpressionValueSubtraction) { 445 // Test negative value and value bigger than int64_t max. 446 expectOperationValueResult(exprSub, -10, MaxUint64, "-18446744073709551625"); 447 448 // Test negative and positive value with result not representable as int64_t. 449 expectOperationValueResult(exprSub, MinInt64, 1, "-9223372036854775809"); 450 451 // Test negative and positive value. 452 expectOperationValueResult(exprSub, -10, 10, -20); 453 454 // Test both negative values. 455 expectOperationValueResult(exprSub, -10, -10, 0); 456 expectOperationValueResult(exprSub, -11, -10, -1); 457 expectOperationValueResult(exprSub, -10, -11, 1); 458 459 // Test positive and negative values. 460 expectOperationValueResult(exprSub, 10, -10, 20); 461 462 // Test both positive values with result positive. 463 expectOperationValueResult(exprSub, 10, 5, 5); 464 465 // Test both positive values with result not representable as int64_t. 466 expectOperationValueResult(exprSub, 0, MaxUint64, "-18446744073709551615"); 467 expectOperationValueResult(exprSub, 0, 468 static_cast<uint64_t>(-(MinInt64 + 10)) + 11, 469 "-9223372036854775809"); 470 471 // Test both positive values with result < -(max int64_t) 472 expectOperationValueResult(exprSub, 10, static_cast<uint64_t>(MaxInt64) + 11, 473 -MaxInt64 - 1); 474 475 // Test both positive values with 0 > result > -(max int64_t) 476 expectOperationValueResult(exprSub, 10, 11, -1); 477 } 478 479 TEST_F(FileCheckTest, ExpressionValueMultiplication) { 480 // Test mixed signed values. 481 expectOperationValueResult(exprMul, -3, 10, -30); 482 expectOperationValueResult(exprMul, 2, -17, -34); 483 expectOperationValueResult(exprMul, 0, MinInt64, 0); 484 expectOperationValueResult(exprMul, MinInt64, 1, MinInt64); 485 expectOperationValueResult(exprMul, 1, MinInt64, MinInt64); 486 expectOperationValueResult(exprMul, MaxInt64, -1, -MaxInt64); 487 expectOperationValueResult(exprMul, -1, MaxInt64, -MaxInt64); 488 489 // Test both negative values. 490 expectOperationValueResult(exprMul, -3, -10, 30); 491 expectOperationValueResult(exprMul, -2, -17, 34); 492 expectOperationValueResult(exprMul, MinInt64, -1, AbsoluteMinInt64); 493 494 // Test both positive values. 495 expectOperationValueResult(exprMul, 3, 10, 30); 496 expectOperationValueResult(exprMul, 2, 17, 34); 497 expectOperationValueResult(exprMul, 0, MaxUint64, 0); 498 499 // Test negative results not representable as int64_t. 500 expectOperationValueResult(exprMul, -10, MaxInt64, "-92233720368547758070"); 501 expectOperationValueResult(exprMul, MaxInt64, -10, "-92233720368547758070"); 502 expectOperationValueResult(exprMul, 10, MinInt64, "-92233720368547758080"); 503 expectOperationValueResult(exprMul, MinInt64, 10, "-92233720368547758080"); 504 expectOperationValueResult(exprMul, -1, MaxUint64, "-18446744073709551615"); 505 expectOperationValueResult(exprMul, MaxUint64, -1, "-18446744073709551615"); 506 expectOperationValueResult(exprMul, -1, AbsoluteMaxInt64 + 2, 507 "-9223372036854775809"); 508 expectOperationValueResult(exprMul, AbsoluteMaxInt64 + 2, -1, 509 "-9223372036854775809"); 510 511 // Test positive results not representable as uint64_t. 512 expectOperationValueResult(exprMul, 10, MaxUint64, "184467440737095516150"); 513 expectOperationValueResult(exprMul, MaxUint64, 10, "184467440737095516150"); 514 expectOperationValueResult(exprMul, MinInt64, -10, "92233720368547758080"); 515 expectOperationValueResult(exprMul, -10, MinInt64, "92233720368547758080"); 516 } 517 518 TEST_F(FileCheckTest, ExpressionValueDivision) { 519 // Test mixed signed values. 520 expectOperationValueResult(exprDiv, -30, 10, -3); 521 expectOperationValueResult(exprDiv, 34, -17, -2); 522 expectOperationValueResult(exprDiv, 0, -10, 0); 523 expectOperationValueResult(exprDiv, MinInt64, 1, MinInt64); 524 expectOperationValueResult(exprDiv, MaxInt64, -1, -MaxInt64); 525 expectOperationValueResult(exprDiv, -MaxInt64, 1, -MaxInt64); 526 527 // Test both negative values. 528 expectOperationValueResult(exprDiv, -30, -10, 3); 529 expectOperationValueResult(exprDiv, -34, -17, 2); 530 531 // Test both positive values. 532 expectOperationValueResult(exprDiv, 30, 10, 3); 533 expectOperationValueResult(exprDiv, 34, 17, 2); 534 expectOperationValueResult(exprDiv, 0, 10, 0); 535 536 // Test divide by zero. 537 expectOperationValueResult(exprDiv, -10, 0); 538 expectOperationValueResult(exprDiv, 10, 0); 539 expectOperationValueResult(exprDiv, 0, 0); 540 541 // Test negative result not representable as int64_t. 542 expectOperationValueResult(exprDiv, MaxUint64, -1, "-18446744073709551615"); 543 expectOperationValueResult(exprDiv, AbsoluteMaxInt64 + 2, -1, 544 "-9223372036854775809"); 545 } 546 547 TEST_F(FileCheckTest, Literal) { 548 SourceMgr SM; 549 550 // Eval returns the literal's value. 551 ExpressionLiteral Ten(bufferize(SM, "10"), APInt(64, 10u)); 552 Expected<APInt> Value = Ten.eval(); 553 ASSERT_THAT_EXPECTED(Value, Succeeded()); 554 EXPECT_EQ(10, Value->getSExtValue()); 555 Expected<ExpressionFormat> ImplicitFormat = Ten.getImplicitFormat(SM); 556 ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded()); 557 EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::NoFormat); 558 559 // Min value can be correctly represented. 560 ExpressionLiteral Min(bufferize(SM, std::to_string(MinInt64)), 561 APInt(64, MinInt64, /*IsSigned=*/true)); 562 Value = Min.eval(); 563 ASSERT_TRUE(bool(Value)); 564 EXPECT_EQ(MinInt64, Value->getSExtValue()); 565 566 // Max value can be correctly represented. 567 ExpressionLiteral Max(bufferize(SM, std::to_string(MaxUint64)), 568 APInt(64, MaxUint64)); 569 Value = Max.eval(); 570 ASSERT_THAT_EXPECTED(Value, Succeeded()); 571 EXPECT_EQ(MaxUint64, Value->getZExtValue()); 572 } 573 574 TEST_F(FileCheckTest, Expression) { 575 SourceMgr SM; 576 577 std::unique_ptr<ExpressionLiteral> Ten = 578 std::make_unique<ExpressionLiteral>(bufferize(SM, "10"), APInt(64, 10u)); 579 ExpressionLiteral *TenPtr = Ten.get(); 580 Expression Expr(std::move(Ten), 581 ExpressionFormat(ExpressionFormat::Kind::HexLower)); 582 EXPECT_EQ(Expr.getAST(), TenPtr); 583 EXPECT_EQ(Expr.getFormat(), ExpressionFormat::Kind::HexLower); 584 } 585 586 static void 587 expectUndefErrors(std::unordered_set<std::string> ExpectedUndefVarNames, 588 Error Err) { 589 EXPECT_THAT_ERROR(handleErrors(std::move(Err), 590 [&](const UndefVarError &E) { 591 EXPECT_EQ(ExpectedUndefVarNames.erase( 592 std::string(E.getVarName())), 593 1U); 594 }), 595 Succeeded()); 596 EXPECT_TRUE(ExpectedUndefVarNames.empty()) << toString(ExpectedUndefVarNames); 597 } 598 599 TEST_F(FileCheckTest, NumericVariable) { 600 SourceMgr SM; 601 602 // Undefined variable: getValue and eval fail, error returned by eval holds 603 // the name of the undefined variable. 604 NumericVariable FooVar("FOO", 605 ExpressionFormat(ExpressionFormat::Kind::Unsigned), 1); 606 EXPECT_EQ("FOO", FooVar.getName()); 607 EXPECT_EQ(FooVar.getImplicitFormat(), ExpressionFormat::Kind::Unsigned); 608 NumericVariableUse FooVarUse("FOO", &FooVar); 609 Expected<ExpressionFormat> ImplicitFormat = FooVarUse.getImplicitFormat(SM); 610 ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded()); 611 EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned); 612 EXPECT_FALSE(FooVar.getValue()); 613 Expected<APInt> EvalResult = FooVarUse.eval(); 614 expectUndefErrors({"FOO"}, EvalResult.takeError()); 615 616 // Defined variable without string: only getValue and eval return value set. 617 FooVar.setValue(APInt(64, 42u)); 618 std::optional<APInt> Value = FooVar.getValue(); 619 ASSERT_TRUE(Value); 620 EXPECT_EQ(42, Value->getSExtValue()); 621 EXPECT_FALSE(FooVar.getStringValue()); 622 EvalResult = FooVarUse.eval(); 623 ASSERT_THAT_EXPECTED(EvalResult, Succeeded()); 624 EXPECT_EQ(42, EvalResult->getSExtValue()); 625 626 // Defined variable with string: getValue, eval, and getStringValue return 627 // value set. 628 StringRef StringValue = "925"; 629 FooVar.setValue(APInt(64, 925u), StringValue); 630 Value = FooVar.getValue(); 631 ASSERT_TRUE(Value); 632 EXPECT_EQ(925, Value->getSExtValue()); 633 // getStringValue should return the same memory not just the same characters. 634 EXPECT_EQ(StringValue.begin(), FooVar.getStringValue()->begin()); 635 EXPECT_EQ(StringValue.end(), FooVar.getStringValue()->end()); 636 EvalResult = FooVarUse.eval(); 637 ASSERT_THAT_EXPECTED(EvalResult, Succeeded()); 638 EXPECT_EQ(925, EvalResult->getSExtValue()); 639 EXPECT_EQ(925, EvalResult->getSExtValue()); 640 641 // Clearing variable: getValue and eval fail. Error returned by eval holds 642 // the name of the cleared variable. 643 FooVar.clearValue(); 644 EXPECT_FALSE(FooVar.getValue()); 645 EXPECT_FALSE(FooVar.getStringValue()); 646 EvalResult = FooVarUse.eval(); 647 expectUndefErrors({"FOO"}, EvalResult.takeError()); 648 } 649 650 TEST_F(FileCheckTest, Binop) { 651 SourceMgr SM; 652 653 StringRef ExprStr = bufferize(SM, "FOO+BAR"); 654 StringRef FooStr = ExprStr.take_front(3); 655 NumericVariable FooVar(FooStr, 656 ExpressionFormat(ExpressionFormat::Kind::Unsigned), 1); 657 FooVar.setValue(APInt(64, 42u)); 658 std::unique_ptr<NumericVariableUse> FooVarUse = 659 std::make_unique<NumericVariableUse>(FooStr, &FooVar); 660 StringRef BarStr = ExprStr.take_back(3); 661 NumericVariable BarVar(BarStr, 662 ExpressionFormat(ExpressionFormat::Kind::Unsigned), 2); 663 BarVar.setValue(APInt(64, 18u)); 664 std::unique_ptr<NumericVariableUse> BarVarUse = 665 std::make_unique<NumericVariableUse>(BarStr, &BarVar); 666 BinaryOperation Binop(ExprStr, exprAdd, std::move(FooVarUse), 667 std::move(BarVarUse)); 668 669 // Defined variables with same bitwidth and no overflow: eval returns right 670 // value; implicit formas is as expected. 671 Expected<APInt> Value = Binop.eval(); 672 ASSERT_THAT_EXPECTED(Value, Succeeded()); 673 EXPECT_EQ(60, Value->getSExtValue()); 674 Expected<ExpressionFormat> ImplicitFormat = Binop.getImplicitFormat(SM); 675 ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded()); 676 EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned); 677 678 // Defined variables with different bitwidth and no overflow: eval succeeds 679 // and return the right value. 680 BarVar.setValue(APInt(32, 18u)); 681 Value = Binop.eval(); 682 ASSERT_THAT_EXPECTED(Value, Succeeded()); 683 EXPECT_EQ(60, Value->getSExtValue()); 684 685 // Defined variables with same bitwidth and wider result (i.e. overflow): 686 // eval succeeds and return the right value in a wider APInt. 687 BarVar.setValue(APInt(64, AbsoluteMaxInt64)); 688 Value = Binop.eval(); 689 ASSERT_THAT_EXPECTED(Value, Succeeded()); 690 EXPECT_EQ(128u, Value->getBitWidth()); 691 EXPECT_EQ(APInt(128, AbsoluteMaxInt64 + FooVar.getValue()->getZExtValue()), 692 *Value); 693 694 // 1 undefined variable: eval fails, error contains name of undefined 695 // variable. 696 FooVar.clearValue(); 697 Value = Binop.eval(); 698 expectUndefErrors({"FOO"}, Value.takeError()); 699 700 // 2 undefined variables: eval fails, error contains names of all undefined 701 // variables. 702 BarVar.clearValue(); 703 Value = Binop.eval(); 704 expectUndefErrors({"FOO", "BAR"}, Value.takeError()); 705 706 // Literal + Variable has format of variable. 707 ExprStr = bufferize(SM, "FOO+18"); 708 FooStr = ExprStr.take_front(3); 709 StringRef EighteenStr = ExprStr.take_back(2); 710 FooVarUse = std::make_unique<NumericVariableUse>(FooStr, &FooVar); 711 std::unique_ptr<ExpressionLiteral> Eighteen = 712 std::make_unique<ExpressionLiteral>(EighteenStr, APInt(64, 18u)); 713 Binop = BinaryOperation(ExprStr, exprAdd, std::move(FooVarUse), 714 std::move(Eighteen)); 715 ImplicitFormat = Binop.getImplicitFormat(SM); 716 ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded()); 717 EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned); 718 ExprStr = bufferize(SM, "18+FOO"); 719 FooStr = ExprStr.take_back(3); 720 EighteenStr = ExprStr.take_front(2); 721 FooVarUse = std::make_unique<NumericVariableUse>(FooStr, &FooVar); 722 Eighteen = std::make_unique<ExpressionLiteral>(EighteenStr, APInt(64, 18u)); 723 Binop = BinaryOperation(ExprStr, exprAdd, std::move(Eighteen), 724 std::move(FooVarUse)); 725 ImplicitFormat = Binop.getImplicitFormat(SM); 726 ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded()); 727 EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned); 728 729 // Variables with different implicit format conflict. 730 ExprStr = bufferize(SM, "FOO+BAZ"); 731 FooStr = ExprStr.take_front(3); 732 StringRef BazStr = ExprStr.take_back(3); 733 NumericVariable BazVar(BazStr, 734 ExpressionFormat(ExpressionFormat::Kind::HexLower), 3); 735 FooVarUse = std::make_unique<NumericVariableUse>(FooStr, &FooVar); 736 std::unique_ptr<NumericVariableUse> BazVarUse = 737 std::make_unique<NumericVariableUse>(BazStr, &BazVar); 738 Binop = BinaryOperation(ExprStr, exprAdd, std::move(FooVarUse), 739 std::move(BazVarUse)); 740 ImplicitFormat = Binop.getImplicitFormat(SM); 741 expectDiagnosticError( 742 "implicit format conflict between 'FOO' (%u) and 'BAZ' (%x), " 743 "need an explicit format specifier", 744 ImplicitFormat.takeError()); 745 746 // All variable conflicts are reported. 747 ExprStr = bufferize(SM, "(FOO+BAZ)+(FOO+QUUX)"); 748 StringRef Paren1ExprStr = ExprStr.substr(1, 7); 749 FooStr = Paren1ExprStr.take_front(3); 750 BazStr = Paren1ExprStr.take_back(3); 751 StringRef Paren2ExprStr = ExprStr.substr(ExprStr.rfind('(') + 1, 8); 752 StringRef FooStr2 = Paren2ExprStr.take_front(3); 753 StringRef QuuxStr = Paren2ExprStr.take_back(4); 754 FooVarUse = std::make_unique<NumericVariableUse>(FooStr, &FooVar); 755 BazVarUse = std::make_unique<NumericVariableUse>(BazStr, &BazVar); 756 std::unique_ptr<NumericVariableUse> FooVarUse2 = 757 std::make_unique<NumericVariableUse>(FooStr2, &FooVar); 758 NumericVariable QuuxVar( 759 QuuxStr, ExpressionFormat(ExpressionFormat::Kind::HexLower), 4); 760 std::unique_ptr<NumericVariableUse> QuuxVarUse = 761 std::make_unique<NumericVariableUse>(QuuxStr, &QuuxVar); 762 std::unique_ptr<BinaryOperation> Binop1 = std::make_unique<BinaryOperation>( 763 ExprStr.take_front(9), exprAdd, std::move(FooVarUse), 764 std::move(BazVarUse)); 765 std::unique_ptr<BinaryOperation> Binop2 = std::make_unique<BinaryOperation>( 766 ExprStr.take_back(10), exprAdd, std::move(FooVarUse2), 767 std::move(QuuxVarUse)); 768 std::unique_ptr<BinaryOperation> OuterBinop = 769 std::make_unique<BinaryOperation>(ExprStr, exprAdd, std::move(Binop1), 770 std::move(Binop2)); 771 ImplicitFormat = OuterBinop->getImplicitFormat(SM); 772 expectSameErrors<ErrorDiagnostic>( 773 {("implicit format conflict between 'FOO' (%u) and 'BAZ' (%x), need an " 774 "explicit format specifier"), 775 ("implicit format conflict between 'FOO' (%u) and 'QUUX' (%x), need an " 776 "explicit format specifier")}, 777 ImplicitFormat.takeError()); 778 } 779 780 TEST_F(FileCheckTest, ValidVarNameStart) { 781 EXPECT_TRUE(Pattern::isValidVarNameStart('a')); 782 EXPECT_TRUE(Pattern::isValidVarNameStart('G')); 783 EXPECT_TRUE(Pattern::isValidVarNameStart('_')); 784 EXPECT_FALSE(Pattern::isValidVarNameStart('2')); 785 EXPECT_FALSE(Pattern::isValidVarNameStart('$')); 786 EXPECT_FALSE(Pattern::isValidVarNameStart('@')); 787 EXPECT_FALSE(Pattern::isValidVarNameStart('+')); 788 EXPECT_FALSE(Pattern::isValidVarNameStart('-')); 789 EXPECT_FALSE(Pattern::isValidVarNameStart(':')); 790 } 791 792 TEST_F(FileCheckTest, ParseVar) { 793 SourceMgr SM; 794 StringRef OrigVarName = bufferize(SM, "GoodVar42"); 795 StringRef VarName = OrigVarName; 796 Expected<Pattern::VariableProperties> ParsedVarResult = 797 Pattern::parseVariable(VarName, SM); 798 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded()); 799 EXPECT_EQ(ParsedVarResult->Name, OrigVarName); 800 EXPECT_TRUE(VarName.empty()); 801 EXPECT_FALSE(ParsedVarResult->IsPseudo); 802 803 VarName = OrigVarName = bufferize(SM, "$GoodGlobalVar"); 804 ParsedVarResult = Pattern::parseVariable(VarName, SM); 805 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded()); 806 EXPECT_EQ(ParsedVarResult->Name, OrigVarName); 807 EXPECT_TRUE(VarName.empty()); 808 EXPECT_FALSE(ParsedVarResult->IsPseudo); 809 810 VarName = OrigVarName = bufferize(SM, "@GoodPseudoVar"); 811 ParsedVarResult = Pattern::parseVariable(VarName, SM); 812 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded()); 813 EXPECT_EQ(ParsedVarResult->Name, OrigVarName); 814 EXPECT_TRUE(VarName.empty()); 815 EXPECT_TRUE(ParsedVarResult->IsPseudo); 816 817 VarName = bufferize(SM, "42BadVar"); 818 ParsedVarResult = Pattern::parseVariable(VarName, SM); 819 expectDiagnosticError("invalid variable name", ParsedVarResult.takeError()); 820 821 VarName = bufferize(SM, "$@"); 822 ParsedVarResult = Pattern::parseVariable(VarName, SM); 823 expectDiagnosticError("invalid variable name", ParsedVarResult.takeError()); 824 825 VarName = OrigVarName = bufferize(SM, "B@dVar"); 826 ParsedVarResult = Pattern::parseVariable(VarName, SM); 827 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded()); 828 EXPECT_EQ(VarName, OrigVarName.substr(1)); 829 EXPECT_EQ(ParsedVarResult->Name, "B"); 830 EXPECT_FALSE(ParsedVarResult->IsPseudo); 831 832 VarName = OrigVarName = bufferize(SM, "B$dVar"); 833 ParsedVarResult = Pattern::parseVariable(VarName, SM); 834 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded()); 835 EXPECT_EQ(VarName, OrigVarName.substr(1)); 836 EXPECT_EQ(ParsedVarResult->Name, "B"); 837 EXPECT_FALSE(ParsedVarResult->IsPseudo); 838 839 VarName = bufferize(SM, "BadVar+"); 840 ParsedVarResult = Pattern::parseVariable(VarName, SM); 841 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded()); 842 EXPECT_EQ(VarName, "+"); 843 EXPECT_EQ(ParsedVarResult->Name, "BadVar"); 844 EXPECT_FALSE(ParsedVarResult->IsPseudo); 845 846 VarName = bufferize(SM, "BadVar-"); 847 ParsedVarResult = Pattern::parseVariable(VarName, SM); 848 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded()); 849 EXPECT_EQ(VarName, "-"); 850 EXPECT_EQ(ParsedVarResult->Name, "BadVar"); 851 EXPECT_FALSE(ParsedVarResult->IsPseudo); 852 853 VarName = bufferize(SM, "BadVar:"); 854 ParsedVarResult = Pattern::parseVariable(VarName, SM); 855 ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded()); 856 EXPECT_EQ(VarName, ":"); 857 EXPECT_EQ(ParsedVarResult->Name, "BadVar"); 858 EXPECT_FALSE(ParsedVarResult->IsPseudo); 859 } 860 861 static void expectNotFoundError(Error Err) { 862 expectError<NotFoundError>("String not found in input", std::move(Err)); 863 } 864 865 class PatternTester { 866 private: 867 size_t LineNumber = 1; 868 SourceMgr SM; 869 FileCheckRequest Req; 870 FileCheckPatternContext Context; 871 Pattern P{Check::CheckPlain, &Context, LineNumber}; 872 873 public: 874 PatternTester() { 875 std::vector<StringRef> GlobalDefines = {"#FOO=42", "BAR=BAZ", "#add=7"}; 876 // An ASSERT_FALSE would make more sense but cannot be used in a 877 // constructor. 878 EXPECT_THAT_ERROR(Context.defineCmdlineVariables(GlobalDefines, SM), 879 Succeeded()); 880 Context.createLineVariable(); 881 // Call parsePattern to have @LINE defined. 882 P.parsePattern("N/A", "CHECK", SM, Req); 883 // parsePattern does not expect to be called twice for the same line and 884 // will set FixedStr and RegExStr incorrectly if it is. Therefore prepare 885 // a pattern for a different line. 886 initNextPattern(); 887 } 888 889 void initNextPattern() { 890 P = Pattern(Check::CheckPlain, &Context, ++LineNumber); 891 } 892 893 size_t getLineNumber() const { return LineNumber; } 894 895 Expected<std::unique_ptr<Expression>> 896 parseSubst(StringRef Expr, bool IsLegacyLineExpr = false) { 897 StringRef ExprBufferRef = bufferize(SM, Expr); 898 std::optional<NumericVariable *> DefinedNumericVariable; 899 return P.parseNumericSubstitutionBlock( 900 ExprBufferRef, DefinedNumericVariable, IsLegacyLineExpr, LineNumber, 901 &Context, SM); 902 } 903 904 bool parsePattern(StringRef Pattern) { 905 StringRef PatBufferRef = bufferize(SM, Pattern); 906 return P.parsePattern(PatBufferRef, "CHECK", SM, Req); 907 } 908 909 Expected<size_t> match(StringRef Buffer) { 910 StringRef BufferRef = bufferize(SM, Buffer); 911 Pattern::MatchResult Res = P.match(BufferRef, SM); 912 if (Res.TheError) 913 return std::move(Res.TheError); 914 return Res.TheMatch->Pos; 915 } 916 917 void printVariableDefs(FileCheckDiag::MatchType MatchTy, 918 std::vector<FileCheckDiag> &Diags) { 919 P.printVariableDefs(SM, MatchTy, &Diags); 920 } 921 }; 922 923 TEST_F(FileCheckTest, ParseNumericSubstitutionBlock) { 924 PatternTester Tester; 925 926 // Variable definition. 927 928 expectDiagnosticError("invalid variable name", 929 Tester.parseSubst("%VAR:").takeError()); 930 931 expectDiagnosticError("definition of pseudo numeric variable unsupported", 932 Tester.parseSubst("@LINE:").takeError()); 933 934 expectDiagnosticError("string variable with name 'BAR' already exists", 935 Tester.parseSubst("BAR:").takeError()); 936 937 expectDiagnosticError("unexpected characters after numeric variable name", 938 Tester.parseSubst("VAR GARBAGE:").takeError()); 939 940 // Change of format. 941 expectDiagnosticError("format different from previous variable definition", 942 Tester.parseSubst("%X,FOO:").takeError()); 943 944 // Invalid format. 945 expectDiagnosticError("invalid matching format specification in expression", 946 Tester.parseSubst("X,VAR1:").takeError()); 947 expectDiagnosticError("invalid format specifier in expression", 948 Tester.parseSubst("%F,VAR1:").takeError()); 949 expectDiagnosticError("invalid matching format specification in expression", 950 Tester.parseSubst("%X a,VAR1:").takeError()); 951 952 // Acceptable variable definition. 953 EXPECT_THAT_EXPECTED(Tester.parseSubst("VAR1:"), Succeeded()); 954 EXPECT_THAT_EXPECTED(Tester.parseSubst(" VAR2:"), Succeeded()); 955 EXPECT_THAT_EXPECTED(Tester.parseSubst("VAR3 :"), Succeeded()); 956 EXPECT_THAT_EXPECTED(Tester.parseSubst("VAR3: "), Succeeded()); 957 958 // Acceptable variable definition with format specifier. Use parsePattern for 959 // variables whose definition needs to be visible for later checks. 960 EXPECT_FALSE(Tester.parsePattern("[[#%u, VAR_UNSIGNED:]]")); 961 EXPECT_FALSE(Tester.parsePattern("[[#%x, VAR_LOWER_HEX:]]")); 962 EXPECT_THAT_EXPECTED(Tester.parseSubst("%X, VAR_UPPER_HEX:"), Succeeded()); 963 964 // Acceptable variable definition with precision specifier. 965 EXPECT_FALSE(Tester.parsePattern("[[#%.8X, PADDED_ADDR:]]")); 966 EXPECT_FALSE(Tester.parsePattern("[[#%.8, PADDED_NUM:]]")); 967 968 // Acceptable variable definition in alternate form. 969 EXPECT_THAT_EXPECTED(Tester.parseSubst("%#x, PREFIXED_ADDR:"), Succeeded()); 970 EXPECT_THAT_EXPECTED(Tester.parseSubst("%#X, PREFIXED_ADDR:"), Succeeded()); 971 972 // Acceptable variable definition in alternate form. 973 expectDiagnosticError("alternate form only supported for hex values", 974 Tester.parseSubst("%#u, PREFIXED_UNSI:").takeError()); 975 expectDiagnosticError("alternate form only supported for hex values", 976 Tester.parseSubst("%#d, PREFIXED_UNSI:").takeError()); 977 978 // Acceptable variable definition from a numeric expression. 979 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOOBAR: FOO+1"), Succeeded()); 980 981 // Numeric expression. Switch to next line to make above valid definition 982 // available in expressions. 983 Tester.initNextPattern(); 984 985 // Invalid variable name. 986 expectDiagnosticError("invalid matching constraint or operand format", 987 Tester.parseSubst("%VAR").takeError()); 988 989 expectDiagnosticError("invalid pseudo numeric variable '@FOO'", 990 Tester.parseSubst("@FOO").takeError()); 991 992 // parsePattern() is used here instead of parseSubst() for the variable to be 993 // recorded in GlobalNumericVariableTable and thus appear defined to 994 // parseNumericVariableUse(). Note that the same pattern object is used for 995 // the parsePattern() and parseSubst() since no initNextPattern() is called, 996 // thus appearing as being on the same line from the pattern's point of view. 997 ASSERT_FALSE(Tester.parsePattern("[[#SAME_LINE_VAR:]]")); 998 expectDiagnosticError("numeric variable 'SAME_LINE_VAR' defined earlier in " 999 "the same CHECK directive", 1000 Tester.parseSubst("SAME_LINE_VAR").takeError()); 1001 1002 // Invalid use of variable defined on the same line from an expression not 1003 // using any variable defined on the same line. 1004 ASSERT_FALSE(Tester.parsePattern("[[#SAME_LINE_EXPR_VAR:@LINE+1]]")); 1005 expectDiagnosticError("numeric variable 'SAME_LINE_EXPR_VAR' defined earlier " 1006 "in the same CHECK directive", 1007 Tester.parseSubst("SAME_LINE_EXPR_VAR").takeError()); 1008 1009 // Valid use of undefined variable which creates the variable and record it 1010 // in GlobalNumericVariableTable. 1011 ASSERT_THAT_EXPECTED(Tester.parseSubst("UNDEF"), Succeeded()); 1012 EXPECT_TRUE(Tester.parsePattern("[[UNDEF:.*]]")); 1013 1014 // Invalid literal. 1015 expectDiagnosticError("unsupported operation 'U'", 1016 Tester.parseSubst("42U").takeError()); 1017 1018 // Valid empty expression. 1019 EXPECT_THAT_EXPECTED(Tester.parseSubst(""), Succeeded()); 1020 1021 // Invalid equality matching constraint with empty expression. 1022 expectDiagnosticError("empty numeric expression should not have a constraint", 1023 Tester.parseSubst("==").takeError()); 1024 1025 // Valid single operand expression. 1026 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO"), Succeeded()); 1027 EXPECT_THAT_EXPECTED(Tester.parseSubst("18"), Succeeded()); 1028 EXPECT_THAT_EXPECTED(Tester.parseSubst(std::to_string(MaxUint64)), 1029 Succeeded()); 1030 EXPECT_THAT_EXPECTED(Tester.parseSubst("0x12"), Succeeded()); 1031 EXPECT_THAT_EXPECTED(Tester.parseSubst("-30"), Succeeded()); 1032 EXPECT_THAT_EXPECTED(Tester.parseSubst(std::to_string(MinInt64)), 1033 Succeeded()); 1034 1035 // Valid optional matching constraint. 1036 EXPECT_THAT_EXPECTED(Tester.parseSubst("==FOO"), Succeeded()); 1037 1038 // Invalid matching constraint. 1039 expectDiagnosticError("invalid matching constraint or operand format", 1040 Tester.parseSubst("+=FOO").takeError()); 1041 1042 // Invalid format. 1043 expectDiagnosticError("invalid matching format specification in expression", 1044 Tester.parseSubst("X,FOO:").takeError()); 1045 expectDiagnosticError("invalid format specifier in expression", 1046 Tester.parseSubst("%F,FOO").takeError()); 1047 expectDiagnosticError("invalid matching format specification in expression", 1048 Tester.parseSubst("%X a,FOO").takeError()); 1049 1050 // Valid expression with 2 or more operands. 1051 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO+3"), Succeeded()); 1052 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO+0xC"), Succeeded()); 1053 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO-3+FOO"), Succeeded()); 1054 1055 expectDiagnosticError("unsupported operation '/'", 1056 Tester.parseSubst("@LINE/2").takeError()); 1057 1058 expectDiagnosticError("missing operand in expression", 1059 Tester.parseSubst("@LINE+").takeError()); 1060 1061 // Errors in RHS operand are bubbled up by parseBinop() to 1062 // parseNumericSubstitutionBlock(). 1063 expectDiagnosticError("invalid operand format", 1064 Tester.parseSubst("@LINE+%VAR").takeError()); 1065 1066 // Invalid legacy @LINE expression with non literal rhs. 1067 expectDiagnosticError( 1068 "invalid operand format", 1069 Tester.parseSubst("@LINE+@LINE", /*IsLegacyNumExpr=*/true).takeError()); 1070 1071 // Invalid legacy @LINE expression made of a single literal. 1072 expectDiagnosticError( 1073 "invalid variable name", 1074 Tester.parseSubst("2", /*IsLegacyNumExpr=*/true).takeError()); 1075 1076 // Invalid hex literal in legacy @LINE expression. 1077 expectDiagnosticError( 1078 "unexpected characters at end of expression 'xC'", 1079 Tester.parseSubst("@LINE+0xC", /*LegacyLineExpr=*/true).takeError()); 1080 1081 // Valid expression with format specifier. 1082 EXPECT_THAT_EXPECTED(Tester.parseSubst("%u, FOO"), Succeeded()); 1083 EXPECT_THAT_EXPECTED(Tester.parseSubst("%d, FOO"), Succeeded()); 1084 EXPECT_THAT_EXPECTED(Tester.parseSubst("%x, FOO"), Succeeded()); 1085 EXPECT_THAT_EXPECTED(Tester.parseSubst("%X, FOO"), Succeeded()); 1086 1087 // Valid expression with precision specifier. 1088 EXPECT_THAT_EXPECTED(Tester.parseSubst("%.8u, FOO"), Succeeded()); 1089 EXPECT_THAT_EXPECTED(Tester.parseSubst("%.8, FOO"), Succeeded()); 1090 1091 // Valid legacy @LINE expression. 1092 EXPECT_THAT_EXPECTED(Tester.parseSubst("@LINE+2", /*IsLegacyNumExpr=*/true), 1093 Succeeded()); 1094 1095 // Invalid legacy @LINE expression with more than 2 operands. 1096 expectDiagnosticError( 1097 "unexpected characters at end of expression '+@LINE'", 1098 Tester.parseSubst("@LINE+2+@LINE", /*IsLegacyNumExpr=*/true).takeError()); 1099 expectDiagnosticError( 1100 "unexpected characters at end of expression '+2'", 1101 Tester.parseSubst("@LINE+2+2", /*IsLegacyNumExpr=*/true).takeError()); 1102 1103 // Valid expression with several variables when their implicit formats do not 1104 // conflict. 1105 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO+VAR_UNSIGNED"), Succeeded()); 1106 1107 // Valid implicit format conflict in presence of explicit formats. 1108 EXPECT_THAT_EXPECTED(Tester.parseSubst("%X,FOO+VAR_LOWER_HEX"), Succeeded()); 1109 1110 // Implicit format conflict. 1111 expectDiagnosticError( 1112 "implicit format conflict between 'FOO' (%u) and " 1113 "'VAR_LOWER_HEX' (%x), need an explicit format specifier", 1114 Tester.parseSubst("FOO+VAR_LOWER_HEX").takeError()); 1115 1116 // Simple parenthesized expressions: 1117 EXPECT_THAT_EXPECTED(Tester.parseSubst("(1)"), Succeeded()); 1118 EXPECT_THAT_EXPECTED(Tester.parseSubst("(1+1)"), Succeeded()); 1119 EXPECT_THAT_EXPECTED(Tester.parseSubst("(1)+1"), Succeeded()); 1120 EXPECT_THAT_EXPECTED(Tester.parseSubst("((1)+1)"), Succeeded()); 1121 EXPECT_THAT_EXPECTED(Tester.parseSubst("((1)+X)"), Succeeded()); 1122 EXPECT_THAT_EXPECTED(Tester.parseSubst("((X)+Y)"), Succeeded()); 1123 1124 expectDiagnosticError("missing operand in expression", 1125 Tester.parseSubst("(").takeError()); 1126 expectDiagnosticError("missing ')' at end of nested expression", 1127 Tester.parseSubst("(1").takeError()); 1128 expectDiagnosticError("missing operand in expression", 1129 Tester.parseSubst("(1+").takeError()); 1130 expectDiagnosticError("missing ')' at end of nested expression", 1131 Tester.parseSubst("(1+1").takeError()); 1132 expectDiagnosticError("missing ')' at end of nested expression", 1133 Tester.parseSubst("((1+2+3").takeError()); 1134 expectDiagnosticError("missing ')' at end of nested expression", 1135 Tester.parseSubst("((1+2)+3").takeError()); 1136 1137 // Test missing operation between operands: 1138 expectDiagnosticError("unsupported operation '('", 1139 Tester.parseSubst("(1)(2)").takeError()); 1140 expectDiagnosticError("unsupported operation '('", 1141 Tester.parseSubst("2(X)").takeError()); 1142 1143 // Test more closing than opening parentheses. The diagnostic messages are 1144 // not ideal, but for now simply check that we reject invalid input. 1145 expectDiagnosticError("invalid matching constraint or operand format", 1146 Tester.parseSubst(")").takeError()); 1147 expectDiagnosticError("unsupported operation ')'", 1148 Tester.parseSubst("1)").takeError()); 1149 expectDiagnosticError("unsupported operation ')'", 1150 Tester.parseSubst("(1+2))").takeError()); 1151 expectDiagnosticError("unsupported operation ')'", 1152 Tester.parseSubst("(2))").takeError()); 1153 expectDiagnosticError("unsupported operation ')'", 1154 Tester.parseSubst("(1))(").takeError()); 1155 1156 // Valid expression with function call. 1157 EXPECT_THAT_EXPECTED(Tester.parseSubst("add(FOO,3)"), Succeeded()); 1158 EXPECT_THAT_EXPECTED(Tester.parseSubst("add (FOO,3)"), Succeeded()); 1159 // Valid expression with nested function call. 1160 EXPECT_THAT_EXPECTED(Tester.parseSubst("add(FOO, min(BAR,10))"), Succeeded()); 1161 // Valid expression with function call taking expression as argument. 1162 EXPECT_THAT_EXPECTED(Tester.parseSubst("add(FOO, (BAR+10) + 3)"), 1163 Succeeded()); 1164 EXPECT_THAT_EXPECTED(Tester.parseSubst("add(FOO, min (BAR,10) + 3)"), 1165 Succeeded()); 1166 // Valid expression with variable named the same as a function. 1167 EXPECT_THAT_EXPECTED(Tester.parseSubst("add"), Succeeded()); 1168 EXPECT_THAT_EXPECTED(Tester.parseSubst("add+FOO"), Succeeded()); 1169 EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO+add"), Succeeded()); 1170 EXPECT_THAT_EXPECTED(Tester.parseSubst("add(add,add)+add"), Succeeded()); 1171 1172 // Malformed call syntax. 1173 expectDiagnosticError("missing ')' at end of call expression", 1174 Tester.parseSubst("add(FOO,(BAR+7)").takeError()); 1175 expectDiagnosticError("missing ')' at end of call expression", 1176 Tester.parseSubst("add(FOO,min(BAR,7)").takeError()); 1177 expectDiagnosticError("missing argument", 1178 Tester.parseSubst("add(FOO,)").takeError()); 1179 expectDiagnosticError("missing argument", 1180 Tester.parseSubst("add(,FOO)").takeError()); 1181 expectDiagnosticError("missing argument", 1182 Tester.parseSubst("add(FOO,,3)").takeError()); 1183 1184 // Valid call, but to an unknown function. 1185 expectDiagnosticError("call to undefined function 'bogus_function'", 1186 Tester.parseSubst("bogus_function(FOO,3)").takeError()); 1187 expectDiagnosticError("call to undefined function '@add'", 1188 Tester.parseSubst("@add(2,3)").takeError()); 1189 expectDiagnosticError("call to undefined function '$add'", 1190 Tester.parseSubst("$add(2,3)").takeError()); 1191 expectDiagnosticError("call to undefined function 'FOO'", 1192 Tester.parseSubst("FOO(2,3)").takeError()); 1193 expectDiagnosticError("call to undefined function 'FOO'", 1194 Tester.parseSubst("FOO (2,3)").takeError()); 1195 1196 // Valid call, but with incorrect argument count. 1197 expectDiagnosticError("function 'add' takes 2 arguments but 1 given", 1198 Tester.parseSubst("add(FOO)").takeError()); 1199 expectDiagnosticError("function 'add' takes 2 arguments but 3 given", 1200 Tester.parseSubst("add(FOO,3,4)").takeError()); 1201 1202 // Valid call, but not part of a valid expression. 1203 expectDiagnosticError("unsupported operation 'a'", 1204 Tester.parseSubst("2add(FOO,2)").takeError()); 1205 expectDiagnosticError("unsupported operation 'a'", 1206 Tester.parseSubst("FOO add(FOO,2)").takeError()); 1207 expectDiagnosticError("unsupported operation 'a'", 1208 Tester.parseSubst("add(FOO,2)add(FOO,2)").takeError()); 1209 } 1210 1211 TEST_F(FileCheckTest, ParsePattern) { 1212 PatternTester Tester; 1213 1214 // Invalid space in string substitution. 1215 EXPECT_TRUE(Tester.parsePattern("[[ BAR]]")); 1216 1217 // Invalid variable name in string substitution. 1218 EXPECT_TRUE(Tester.parsePattern("[[42INVALID]]")); 1219 1220 // Invalid string variable definition. 1221 EXPECT_TRUE(Tester.parsePattern("[[@PAT:]]")); 1222 EXPECT_TRUE(Tester.parsePattern("[[PAT+2:]]")); 1223 1224 // Collision with numeric variable. 1225 EXPECT_TRUE(Tester.parsePattern("[[FOO:]]")); 1226 1227 // Invalid use of string variable. 1228 EXPECT_TRUE(Tester.parsePattern("[[FOO-BAR]]")); 1229 1230 // Valid use of string variable. 1231 EXPECT_FALSE(Tester.parsePattern("[[BAR]]")); 1232 1233 // Valid string variable definition. 1234 EXPECT_FALSE(Tester.parsePattern("[[PAT:[0-9]+]]")); 1235 1236 // Invalid numeric substitution. 1237 EXPECT_TRUE(Tester.parsePattern("[[#42INVALID]]")); 1238 1239 // Valid numeric substitution. 1240 EXPECT_FALSE(Tester.parsePattern("[[#FOO]]")); 1241 1242 // Valid legacy @LINE expression. 1243 EXPECT_FALSE(Tester.parsePattern("[[@LINE+2]]")); 1244 1245 // Invalid legacy @LINE expression with non decimal literal. 1246 EXPECT_TRUE(Tester.parsePattern("[[@LINE+0x3]]")); 1247 } 1248 1249 TEST_F(FileCheckTest, Match) { 1250 PatternTester Tester; 1251 1252 // Check a substitution error is diagnosed. 1253 ASSERT_FALSE(Tester.parsePattern("[[#%u, -1]]")); 1254 expectDiagnosticError( 1255 "unable to substitute variable or numeric expression: overflow error", 1256 Tester.match("").takeError()); 1257 1258 // Check matching an empty expression only matches a number. 1259 Tester.initNextPattern(); 1260 ASSERT_FALSE(Tester.parsePattern("[[#]]")); 1261 expectNotFoundError(Tester.match("FAIL").takeError()); 1262 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded()); 1263 1264 // Check matching a definition only matches a number with the right format. 1265 Tester.initNextPattern(); 1266 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR:]]")); 1267 expectNotFoundError(Tester.match("FAIL").takeError()); 1268 expectNotFoundError(Tester.match("").takeError()); 1269 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded()); 1270 Tester.initNextPattern(); 1271 Tester.parsePattern("[[#%u,NUMVAR_UNSIGNED:]]"); 1272 expectNotFoundError(Tester.match("C").takeError()); 1273 EXPECT_THAT_EXPECTED(Tester.match("20"), Succeeded()); 1274 Tester.initNextPattern(); 1275 Tester.parsePattern("[[#%x,NUMVAR_LOWER_HEX:]]"); 1276 expectNotFoundError(Tester.match("g").takeError()); 1277 expectNotFoundError(Tester.match("C").takeError()); 1278 EXPECT_THAT_EXPECTED(Tester.match("c"), Succeeded()); 1279 Tester.initNextPattern(); 1280 Tester.parsePattern("[[#%X,NUMVAR_UPPER_HEX:]]"); 1281 expectNotFoundError(Tester.match("H").takeError()); 1282 expectNotFoundError(Tester.match("b").takeError()); 1283 EXPECT_THAT_EXPECTED(Tester.match("B"), Succeeded()); 1284 1285 // Check matching expressions with no explicit format matches the values in 1286 // the right format. 1287 Tester.initNextPattern(); 1288 Tester.parsePattern("[[#NUMVAR_UNSIGNED-5]]"); 1289 expectNotFoundError(Tester.match("f").takeError()); 1290 expectNotFoundError(Tester.match("F").takeError()); 1291 EXPECT_THAT_EXPECTED(Tester.match("15"), Succeeded()); 1292 Tester.initNextPattern(); 1293 Tester.parsePattern("[[#NUMVAR_LOWER_HEX+1]]"); 1294 expectNotFoundError(Tester.match("13").takeError()); 1295 expectNotFoundError(Tester.match("D").takeError()); 1296 EXPECT_THAT_EXPECTED(Tester.match("d"), Succeeded()); 1297 Tester.initNextPattern(); 1298 Tester.parsePattern("[[#NUMVAR_UPPER_HEX+1]]"); 1299 expectNotFoundError(Tester.match("12").takeError()); 1300 expectNotFoundError(Tester.match("c").takeError()); 1301 EXPECT_THAT_EXPECTED(Tester.match("C"), Succeeded()); 1302 1303 // Check matching an undefined variable returns a NotFound error. 1304 Tester.initNextPattern(); 1305 ASSERT_FALSE(Tester.parsePattern("100")); 1306 expectNotFoundError(Tester.match("101").takeError()); 1307 1308 // Check matching the defined variable matches the correct number only. 1309 Tester.initNextPattern(); 1310 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR]]")); 1311 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded()); 1312 1313 // Check matching several substitutions does not match them independently. 1314 Tester.initNextPattern(); 1315 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR]] [[#NUMVAR+2]]")); 1316 expectNotFoundError(Tester.match("19 21").takeError()); 1317 expectNotFoundError(Tester.match("18 21").takeError()); 1318 EXPECT_THAT_EXPECTED(Tester.match("18 20"), Succeeded()); 1319 1320 // Check matching a numeric expression using @LINE after a match failure uses 1321 // the correct value for @LINE. 1322 Tester.initNextPattern(); 1323 ASSERT_FALSE(Tester.parsePattern("[[#@LINE]]")); 1324 // Ok, @LINE matches the current line number. 1325 EXPECT_THAT_EXPECTED(Tester.match(std::to_string(Tester.getLineNumber())), 1326 Succeeded()); 1327 Tester.initNextPattern(); 1328 // Match with substitution failure. 1329 ASSERT_FALSE(Tester.parsePattern("[[#UNKNOWN1+UNKNOWN2]]")); 1330 expectSameErrors<ErrorDiagnostic>( 1331 {"undefined variable: UNKNOWN1", "undefined variable: UNKNOWN2"}, 1332 Tester.match("FOO").takeError()); 1333 Tester.initNextPattern(); 1334 // Check that @LINE matches the later (given the calls to initNextPattern()) 1335 // line number. 1336 EXPECT_FALSE(Tester.parsePattern("[[#@LINE]]")); 1337 EXPECT_THAT_EXPECTED(Tester.match(std::to_string(Tester.getLineNumber())), 1338 Succeeded()); 1339 } 1340 1341 TEST_F(FileCheckTest, MatchParen) { 1342 PatternTester Tester; 1343 // Check simple parenthesized expressions 1344 Tester.initNextPattern(); 1345 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR:]]")); 1346 expectNotFoundError(Tester.match("FAIL").takeError()); 1347 expectNotFoundError(Tester.match("").takeError()); 1348 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded()); 1349 1350 Tester.initNextPattern(); 1351 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR + (2 + 2)]]")); 1352 expectNotFoundError(Tester.match("21").takeError()); 1353 EXPECT_THAT_EXPECTED(Tester.match("22"), Succeeded()); 1354 Tester.initNextPattern(); 1355 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR + (2)]]")); 1356 EXPECT_THAT_EXPECTED(Tester.match("20"), Succeeded()); 1357 Tester.initNextPattern(); 1358 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR+(2)]]")); 1359 EXPECT_THAT_EXPECTED(Tester.match("20"), Succeeded()); 1360 Tester.initNextPattern(); 1361 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR+(NUMVAR)]]")); 1362 EXPECT_THAT_EXPECTED(Tester.match("36"), Succeeded()); 1363 1364 // Check nested parenthesized expressions: 1365 Tester.initNextPattern(); 1366 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR+(2+(2))]]")); 1367 EXPECT_THAT_EXPECTED(Tester.match("22"), Succeeded()); 1368 Tester.initNextPattern(); 1369 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR+(2+(NUMVAR))]]")); 1370 EXPECT_THAT_EXPECTED(Tester.match("38"), Succeeded()); 1371 Tester.initNextPattern(); 1372 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR+((((NUMVAR))))]]")); 1373 EXPECT_THAT_EXPECTED(Tester.match("36"), Succeeded()); 1374 Tester.initNextPattern(); 1375 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR+((((NUMVAR)))-1)-1]]")); 1376 EXPECT_THAT_EXPECTED(Tester.match("34"), Succeeded()); 1377 1378 // Parentheses can also be the first character after the '#': 1379 Tester.initNextPattern(); 1380 ASSERT_FALSE(Tester.parsePattern("[[#(NUMVAR)]]")); 1381 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded()); 1382 Tester.initNextPattern(); 1383 ASSERT_FALSE(Tester.parsePattern("[[#(NUMVAR+2)]]")); 1384 EXPECT_THAT_EXPECTED(Tester.match("20"), Succeeded()); 1385 } 1386 1387 TEST_F(FileCheckTest, MatchBuiltinFunctions) { 1388 PatternTester Tester; 1389 // Esnure #NUMVAR has the expected value. 1390 Tester.initNextPattern(); 1391 ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR:]]")); 1392 expectNotFoundError(Tester.match("FAIL").takeError()); 1393 expectNotFoundError(Tester.match("").takeError()); 1394 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded()); 1395 1396 // Check each builtin function generates the expected result. 1397 Tester.initNextPattern(); 1398 ASSERT_FALSE(Tester.parsePattern("[[#add(NUMVAR,13)]]")); 1399 EXPECT_THAT_EXPECTED(Tester.match("31"), Succeeded()); 1400 Tester.initNextPattern(); 1401 ASSERT_FALSE(Tester.parsePattern("[[#div(NUMVAR,3)]]")); 1402 EXPECT_THAT_EXPECTED(Tester.match("6"), Succeeded()); 1403 Tester.initNextPattern(); 1404 ASSERT_FALSE(Tester.parsePattern("[[#max(NUMVAR,5)]]")); 1405 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded()); 1406 Tester.initNextPattern(); 1407 ASSERT_FALSE(Tester.parsePattern("[[#max(NUMVAR,99)]]")); 1408 EXPECT_THAT_EXPECTED(Tester.match("99"), Succeeded()); 1409 Tester.initNextPattern(); 1410 ASSERT_FALSE(Tester.parsePattern("[[#min(NUMVAR,5)]]")); 1411 EXPECT_THAT_EXPECTED(Tester.match("5"), Succeeded()); 1412 Tester.initNextPattern(); 1413 ASSERT_FALSE(Tester.parsePattern("[[#min(NUMVAR,99)]]")); 1414 EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded()); 1415 Tester.initNextPattern(); 1416 ASSERT_FALSE(Tester.parsePattern("[[#mul(NUMVAR,3)]]")); 1417 EXPECT_THAT_EXPECTED(Tester.match("54"), Succeeded()); 1418 Tester.initNextPattern(); 1419 ASSERT_FALSE(Tester.parsePattern("[[#sub(NUMVAR,7)]]")); 1420 EXPECT_THAT_EXPECTED(Tester.match("11"), Succeeded()); 1421 1422 // Check nested function calls. 1423 Tester.initNextPattern(); 1424 ASSERT_FALSE(Tester.parsePattern("[[#add(min(7,2),max(4,10))]]")); 1425 EXPECT_THAT_EXPECTED(Tester.match("12"), Succeeded()); 1426 1427 // Check function call that uses a variable of the same name. 1428 Tester.initNextPattern(); 1429 ASSERT_FALSE(Tester.parsePattern("[[#add(add,add)+min (add,3)+add]]")); 1430 EXPECT_THAT_EXPECTED(Tester.match("24"), Succeeded()); 1431 } 1432 1433 TEST_F(FileCheckTest, Substitution) { 1434 SourceMgr SM; 1435 FileCheckPatternContext Context; 1436 EXPECT_THAT_ERROR(Context.defineCmdlineVariables({"FOO=BAR"}, SM), 1437 Succeeded()); 1438 1439 // Substitution of an undefined string variable fails and error holds that 1440 // variable's name. 1441 StringSubstitution StringSubstitution(&Context, "VAR404", 42); 1442 Expected<std::string> SubstValue = StringSubstitution.getResult(); 1443 expectUndefErrors({"VAR404"}, SubstValue.takeError()); 1444 1445 // Numeric substitution blocks constituted of defined numeric variables are 1446 // substituted for the variable's value. 1447 NumericVariable NVar("N", ExpressionFormat(ExpressionFormat::Kind::Unsigned), 1448 1); 1449 NVar.setValue(APInt(64, 10u)); 1450 auto NVarUse = std::make_unique<NumericVariableUse>("N", &NVar); 1451 auto ExpressionN = std::make_unique<Expression>( 1452 std::move(NVarUse), ExpressionFormat(ExpressionFormat::Kind::HexUpper)); 1453 NumericSubstitution SubstitutionN(&Context, "N", std::move(ExpressionN), 1454 /*InsertIdx=*/30); 1455 SubstValue = SubstitutionN.getResult(); 1456 ASSERT_THAT_EXPECTED(SubstValue, Succeeded()); 1457 EXPECT_EQ("A", *SubstValue); 1458 1459 // Substitution of an undefined numeric variable fails, error holds name of 1460 // undefined variable. 1461 NVar.clearValue(); 1462 SubstValue = SubstitutionN.getResult(); 1463 expectUndefErrors({"N"}, SubstValue.takeError()); 1464 1465 // Substitution of a defined string variable returns the right value. 1466 Pattern P(Check::CheckPlain, &Context, 1); 1467 StringSubstitution = llvm::StringSubstitution(&Context, "FOO", 42); 1468 SubstValue = StringSubstitution.getResult(); 1469 ASSERT_THAT_EXPECTED(SubstValue, Succeeded()); 1470 EXPECT_EQ("BAR", *SubstValue); 1471 } 1472 1473 TEST_F(FileCheckTest, FileCheckContext) { 1474 FileCheckPatternContext Cxt; 1475 SourceMgr SM; 1476 1477 // No definition. 1478 EXPECT_THAT_ERROR(Cxt.defineCmdlineVariables({}, SM), Succeeded()); 1479 1480 // Missing equal sign. 1481 expectDiagnosticError("missing equal sign in global definition", 1482 Cxt.defineCmdlineVariables({"LocalVar"}, SM)); 1483 expectDiagnosticError("missing equal sign in global definition", 1484 Cxt.defineCmdlineVariables({"#LocalNumVar"}, SM)); 1485 1486 // Empty variable name. 1487 expectDiagnosticError("empty variable name", 1488 Cxt.defineCmdlineVariables({"=18"}, SM)); 1489 expectDiagnosticError("empty variable name", 1490 Cxt.defineCmdlineVariables({"#=18"}, SM)); 1491 1492 // Invalid variable name. 1493 expectDiagnosticError("invalid variable name", 1494 Cxt.defineCmdlineVariables({"18LocalVar=18"}, SM)); 1495 expectDiagnosticError("invalid variable name", 1496 Cxt.defineCmdlineVariables({"#18LocalNumVar=18"}, SM)); 1497 1498 // Name conflict between pattern and numeric variable. 1499 expectDiagnosticError( 1500 "string variable with name 'LocalVar' already exists", 1501 Cxt.defineCmdlineVariables({"LocalVar=18", "#LocalVar=36"}, SM)); 1502 Cxt = FileCheckPatternContext(); 1503 expectDiagnosticError( 1504 "numeric variable with name 'LocalNumVar' already exists", 1505 Cxt.defineCmdlineVariables({"#LocalNumVar=18", "LocalNumVar=36"}, SM)); 1506 Cxt = FileCheckPatternContext(); 1507 1508 // Invalid numeric value for numeric variable. 1509 expectUndefErrors({"x"}, Cxt.defineCmdlineVariables({"#LocalNumVar=x"}, SM)); 1510 1511 // Define local variables from command-line. 1512 std::vector<StringRef> GlobalDefines; 1513 // Clear local variables to remove dummy numeric variable x that 1514 // parseNumericSubstitutionBlock would have created and stored in 1515 // GlobalNumericVariableTable. 1516 Cxt.clearLocalVars(); 1517 GlobalDefines.emplace_back("LocalVar=FOO"); 1518 GlobalDefines.emplace_back("EmptyVar="); 1519 GlobalDefines.emplace_back("#LocalNumVar1=18"); 1520 GlobalDefines.emplace_back("#%x,LocalNumVar2=LocalNumVar1+2"); 1521 GlobalDefines.emplace_back("#LocalNumVar3=0xc"); 1522 ASSERT_THAT_ERROR(Cxt.defineCmdlineVariables(GlobalDefines, SM), Succeeded()); 1523 1524 // Create @LINE pseudo numeric variable and check it is present by matching 1525 // it. 1526 size_t LineNumber = 1; 1527 Pattern P(Check::CheckPlain, &Cxt, LineNumber); 1528 FileCheckRequest Req; 1529 Cxt.createLineVariable(); 1530 ASSERT_FALSE(P.parsePattern("[[@LINE]]", "CHECK", SM, Req)); 1531 Pattern::MatchResult Res = P.match("1", SM); 1532 ASSERT_THAT_ERROR(std::move(Res.TheError), Succeeded()); 1533 1534 #ifndef NDEBUG 1535 // Recreating @LINE pseudo numeric variable fails. 1536 EXPECT_DEATH(Cxt.createLineVariable(), 1537 "@LINE pseudo numeric variable already created"); 1538 #endif 1539 1540 // Check defined variables are present and undefined ones are absent. 1541 StringRef LocalVarStr = "LocalVar"; 1542 StringRef LocalNumVar1Ref = bufferize(SM, "LocalNumVar1"); 1543 StringRef LocalNumVar2Ref = bufferize(SM, "LocalNumVar2"); 1544 StringRef LocalNumVar3Ref = bufferize(SM, "LocalNumVar3"); 1545 StringRef EmptyVarStr = "EmptyVar"; 1546 StringRef UnknownVarStr = "UnknownVar"; 1547 Expected<StringRef> LocalVar = Cxt.getPatternVarValue(LocalVarStr); 1548 P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber); 1549 std::optional<NumericVariable *> DefinedNumericVariable; 1550 Expected<std::unique_ptr<Expression>> ExpressionPointer = 1551 P.parseNumericSubstitutionBlock(LocalNumVar1Ref, DefinedNumericVariable, 1552 /*IsLegacyLineExpr=*/false, LineNumber, 1553 &Cxt, SM); 1554 ASSERT_THAT_EXPECTED(LocalVar, Succeeded()); 1555 EXPECT_EQ(*LocalVar, "FOO"); 1556 Expected<StringRef> EmptyVar = Cxt.getPatternVarValue(EmptyVarStr); 1557 Expected<StringRef> UnknownVar = Cxt.getPatternVarValue(UnknownVarStr); 1558 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded()); 1559 Expected<APInt> ExpressionVal = (*ExpressionPointer)->getAST()->eval(); 1560 ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded()); 1561 EXPECT_EQ(ExpressionVal->getSExtValue(), 18); 1562 ExpressionPointer = P.parseNumericSubstitutionBlock( 1563 LocalNumVar2Ref, DefinedNumericVariable, 1564 /*IsLegacyLineExpr=*/false, LineNumber, &Cxt, SM); 1565 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded()); 1566 ExpressionVal = (*ExpressionPointer)->getAST()->eval(); 1567 ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded()); 1568 EXPECT_EQ(ExpressionVal->getSExtValue(), 20); 1569 ExpressionPointer = P.parseNumericSubstitutionBlock( 1570 LocalNumVar3Ref, DefinedNumericVariable, 1571 /*IsLegacyLineExpr=*/false, LineNumber, &Cxt, SM); 1572 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded()); 1573 ExpressionVal = (*ExpressionPointer)->getAST()->eval(); 1574 ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded()); 1575 EXPECT_EQ(ExpressionVal->getSExtValue(), 12); 1576 ASSERT_THAT_EXPECTED(EmptyVar, Succeeded()); 1577 EXPECT_EQ(*EmptyVar, ""); 1578 expectUndefErrors({std::string(UnknownVarStr)}, UnknownVar.takeError()); 1579 1580 // Clear local variables and check they become absent. 1581 Cxt.clearLocalVars(); 1582 LocalVar = Cxt.getPatternVarValue(LocalVarStr); 1583 expectUndefErrors({std::string(LocalVarStr)}, LocalVar.takeError()); 1584 // Check a numeric expression's evaluation fails if called after clearing of 1585 // local variables, if it was created before. This is important because local 1586 // variable clearing due to --enable-var-scope happens after numeric 1587 // expressions are linked to the numeric variables they use. 1588 expectUndefErrors({"LocalNumVar3"}, 1589 (*ExpressionPointer)->getAST()->eval().takeError()); 1590 P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber); 1591 ExpressionPointer = P.parseNumericSubstitutionBlock( 1592 LocalNumVar1Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false, 1593 LineNumber, &Cxt, SM); 1594 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded()); 1595 ExpressionVal = (*ExpressionPointer)->getAST()->eval(); 1596 expectUndefErrors({"LocalNumVar1"}, ExpressionVal.takeError()); 1597 ExpressionPointer = P.parseNumericSubstitutionBlock( 1598 LocalNumVar2Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false, 1599 LineNumber, &Cxt, SM); 1600 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded()); 1601 ExpressionVal = (*ExpressionPointer)->getAST()->eval(); 1602 expectUndefErrors({"LocalNumVar2"}, ExpressionVal.takeError()); 1603 EmptyVar = Cxt.getPatternVarValue(EmptyVarStr); 1604 expectUndefErrors({"EmptyVar"}, EmptyVar.takeError()); 1605 // Clear again because parseNumericSubstitutionBlock would have created a 1606 // dummy variable and stored it in GlobalNumericVariableTable. 1607 Cxt.clearLocalVars(); 1608 1609 // Redefine global variables and check variables are defined again. 1610 GlobalDefines.emplace_back("$GlobalVar=BAR"); 1611 GlobalDefines.emplace_back("#$GlobalNumVar=36"); 1612 ASSERT_THAT_ERROR(Cxt.defineCmdlineVariables(GlobalDefines, SM), Succeeded()); 1613 StringRef GlobalVarStr = "$GlobalVar"; 1614 StringRef GlobalNumVarRef = bufferize(SM, "$GlobalNumVar"); 1615 Expected<StringRef> GlobalVar = Cxt.getPatternVarValue(GlobalVarStr); 1616 ASSERT_THAT_EXPECTED(GlobalVar, Succeeded()); 1617 EXPECT_EQ(*GlobalVar, "BAR"); 1618 P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber); 1619 ExpressionPointer = P.parseNumericSubstitutionBlock( 1620 GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false, 1621 LineNumber, &Cxt, SM); 1622 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded()); 1623 ExpressionVal = (*ExpressionPointer)->getAST()->eval(); 1624 ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded()); 1625 EXPECT_EQ(ExpressionVal->getSExtValue(), 36); 1626 1627 // Clear local variables and check global variables remain defined. 1628 Cxt.clearLocalVars(); 1629 EXPECT_THAT_EXPECTED(Cxt.getPatternVarValue(GlobalVarStr), Succeeded()); 1630 P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber); 1631 ExpressionPointer = P.parseNumericSubstitutionBlock( 1632 GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false, 1633 LineNumber, &Cxt, SM); 1634 ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded()); 1635 ExpressionVal = (*ExpressionPointer)->getAST()->eval(); 1636 ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded()); 1637 EXPECT_EQ(ExpressionVal->getSExtValue(), 36); 1638 } 1639 1640 TEST_F(FileCheckTest, CapturedVarDiags) { 1641 PatternTester Tester; 1642 ASSERT_FALSE(Tester.parsePattern("[[STRVAR:[a-z]+]] [[#NUMVAR:@LINE]]")); 1643 EXPECT_THAT_EXPECTED(Tester.match("foobar 2"), Succeeded()); 1644 std::vector<FileCheckDiag> Diags; 1645 Tester.printVariableDefs(FileCheckDiag::MatchFoundAndExpected, Diags); 1646 EXPECT_EQ(Diags.size(), 2ul); 1647 for (const FileCheckDiag &Diag : Diags) { 1648 EXPECT_EQ(Diag.CheckTy, Check::CheckPlain); 1649 EXPECT_EQ(Diag.MatchTy, FileCheckDiag::MatchFoundAndExpected); 1650 EXPECT_EQ(Diag.InputStartLine, 1u); 1651 EXPECT_EQ(Diag.InputEndLine, 1u); 1652 } 1653 EXPECT_EQ(Diags[0].InputStartCol, 1u); 1654 EXPECT_EQ(Diags[0].InputEndCol, 7u); 1655 EXPECT_EQ(Diags[1].InputStartCol, 8u); 1656 EXPECT_EQ(Diags[1].InputEndCol, 9u); 1657 EXPECT_EQ(Diags[0].Note, "captured var \"STRVAR\""); 1658 EXPECT_EQ(Diags[1].Note, "captured var \"NUMVAR\""); 1659 } 1660 } // namespace 1661