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