unittests/Support/FileCheckTest.cpp

   1 //===- llvm/unittest/Support/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/Support/FileCheck.h"
  10 #include "gtest/gtest.h"
  11 #include <unordered_set>
  12
  13 using namespace llvm;
  14 namespace {
  15
  16 class FileCheckTest : public ::testing::Test {};
  17
  18 TEST_F(FileCheckTest, Literal) {
  19   // Eval returns the literal's value.
  20   FileCheckExpressionLiteral Ten(10);
  21   Expected<uint64_t> Value = Ten.eval();
  22   ASSERT_TRUE(bool(Value));
  23   EXPECT_EQ(10U, *Value);
  24
  25   // Max value can be correctly represented.
  26   FileCheckExpressionLiteral Max(std::numeric_limits<uint64_t>::max());
  27   Value = Max.eval();
  28   ASSERT_TRUE(bool(Value));
  29   EXPECT_EQ(std::numeric_limits<uint64_t>::max(), *Value);
  30 }
  31
  32 static std::string toString(const std::unordered_set<std::string> &Set) {
  33   bool First = true;
  34   std::string Str;
  35   for (StringRef S : Set) {
  36     Str += Twine(First ? "{" + S : ", " + S).str();
  37     First = false;
  38   }
  39   Str += '}';
  40   return Str;
  41 }
  42
  43 static void
  44 expectUndefErrors(std::unordered_set<std::string> ExpectedUndefVarNames,
  45                   Error Err) {
  46   handleAllErrors(std::move(Err), [&](const FileCheckUndefVarError &E) {
  47     ExpectedUndefVarNames.erase(E.getVarName());
  48   });
  49   EXPECT_TRUE(ExpectedUndefVarNames.empty()) << toString(ExpectedUndefVarNames);
  50 }
  51
  52 // Return whether Err contains any FileCheckUndefVarError whose associated name
  53 // is not ExpectedUndefVarName.
  54 static void expectUndefError(const Twine &ExpectedUndefVarName, Error Err) {
  55   expectUndefErrors({ExpectedUndefVarName.str()}, std::move(Err));
  56 }
  57
  58 uint64_t doAdd(uint64_t OpL, uint64_t OpR) { return OpL + OpR; }
  59
  60 TEST_F(FileCheckTest, NumericVariable) {
  61   // Undefined variable: isValueKnownAtMatchTime returns false, getValue and
  62   // eval fail, error returned by eval holds the name of the undefined
  63   // variable.
  64   FileCheckNumericVariable FooVar = FileCheckNumericVariable("FOO", 1);
  65   EXPECT_EQ("FOO", FooVar.getName());
  66   EXPECT_FALSE(FooVar.isValueKnownAtMatchTime());
  67   FileCheckNumericVariableUse FooVarUse =
  68       FileCheckNumericVariableUse("FOO", &FooVar);
  69   EXPECT_FALSE(FooVar.getValue());
  70   Expected<uint64_t> EvalResult = FooVarUse.eval();
  71   ASSERT_FALSE(EvalResult);
  72   expectUndefError("FOO", EvalResult.takeError());
  73
  74   FooVar.setValue(42);
  75
  76   // Defined variable: isValueKnownAtMatchTime returns true, getValue and eval
  77   // return value set.
  78   EXPECT_TRUE(FooVar.isValueKnownAtMatchTime());
  79   Optional<uint64_t> Value = FooVar.getValue();
  80   ASSERT_TRUE(bool(Value));
  81   EXPECT_EQ(42U, *Value);
  82   EvalResult = FooVarUse.eval();
  83   ASSERT_TRUE(bool(EvalResult));
  84   EXPECT_EQ(42U, *EvalResult);
  85
  86   // Variable defined by numeric expression: isValueKnownAtMatchTime
  87   // returns true, getValue and eval return value of expression, setValue
  88   // clears expression.
  89   std::unique_ptr<FileCheckNumericVariableUse> FooVarUsePtr =
  90       std::make_unique<FileCheckNumericVariableUse>("FOO", &FooVar);
  91   std::unique_ptr<FileCheckExpressionLiteral> One =
  92       std::make_unique<FileCheckExpressionLiteral>(1);
  93   FileCheckASTBinop Binop =
  94       FileCheckASTBinop(doAdd, std::move(FooVarUsePtr), std::move(One));
  95   FileCheckNumericVariable FoobarExprVar =
  96       FileCheckNumericVariable("FOOBAR", 2, &Binop);
  97   EXPECT_TRUE(FoobarExprVar.isValueKnownAtMatchTime());
  98   ASSERT_FALSE(FoobarExprVar.getValue());
  99   FileCheckNumericVariableUse FoobarExprVarUse =
 100       FileCheckNumericVariableUse("FOOBAR", &FoobarExprVar);
 101   EvalResult = FoobarExprVarUse.eval();
 102   ASSERT_TRUE(bool(EvalResult));
 103   EXPECT_EQ(43U, *EvalResult);
 104   EXPECT_TRUE(FoobarExprVar.getExpressionAST());
 105   FoobarExprVar.setValue(43);
 106   EXPECT_FALSE(FoobarExprVar.getExpressionAST());
 107   FoobarExprVar = FileCheckNumericVariable("FOOBAR", 2, &Binop);
 108   EXPECT_TRUE(FoobarExprVar.getExpressionAST());
 109
 110   // Clearing variable: getValue and eval fail. Error returned by eval holds
 111   // the name of the cleared variable.
 112   FooVar.clearValue();
 113   FoobarExprVar.clearValue();
 114   EXPECT_FALSE(FoobarExprVar.getExpressionAST());
 115   EXPECT_FALSE(FooVar.getValue());
 116   EXPECT_FALSE(FoobarExprVar.getValue());
 117   EvalResult = FooVarUse.eval();
 118   ASSERT_FALSE(EvalResult);
 119   expectUndefError("FOO", EvalResult.takeError());
 120   EvalResult = FoobarExprVarUse.eval();
 121   ASSERT_FALSE(EvalResult);
 122   expectUndefError("FOOBAR", EvalResult.takeError());
 123 }
 124
 125 TEST_F(FileCheckTest, Binop) {
 126   FileCheckNumericVariable FooVar = FileCheckNumericVariable("FOO", 1);
 127   FooVar.setValue(42);
 128   std::unique_ptr<FileCheckNumericVariableUse> FooVarUse =
 129       std::make_unique<FileCheckNumericVariableUse>("FOO", &FooVar);
 130   FileCheckNumericVariable BarVar = FileCheckNumericVariable("BAR", 2);
 131   BarVar.setValue(18);
 132   std::unique_ptr<FileCheckNumericVariableUse> BarVarUse =
 133       std::make_unique<FileCheckNumericVariableUse>("BAR", &BarVar);
 134   FileCheckASTBinop Binop =
 135       FileCheckASTBinop(doAdd, std::move(FooVarUse), std::move(BarVarUse));
 136
 137   // Defined variable: eval returns right value.
 138   Expected<uint64_t> Value = Binop.eval();
 139   ASSERT_TRUE(bool(Value));
 140   EXPECT_EQ(60U, *Value);
 141
 142   // 1 undefined variable: eval fails, error contains name of undefined
 143   // variable.
 144   FooVar.clearValue();
 145   Value = Binop.eval();
 146   ASSERT_FALSE(Value);
 147   expectUndefError("FOO", Value.takeError());
 148
 149   // 2 undefined variables: eval fails, error contains names of all undefined
 150   // variables.
 151   BarVar.clearValue();
 152   Value = Binop.eval();
 153   ASSERT_FALSE(Value);
 154   expectUndefErrors({"FOO", "BAR"}, Value.takeError());
 155 }
 156
 157 TEST_F(FileCheckTest, ValidVarNameStart) {
 158   EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('a'));
 159   EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('G'));
 160   EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('_'));
 161   EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('2'));
 162   EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('$'));
 163   EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('@'));
 164   EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('+'));
 165   EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('-'));
 166   EXPECT_FALSE(FileCheckPattern::isValidVarNameStart(':'));
 167 }
 168
 169 static StringRef bufferize(SourceMgr &SM, StringRef Str) {
 170   std::unique_ptr<MemoryBuffer> Buffer =
 171       MemoryBuffer::getMemBufferCopy(Str, "TestBuffer");
 172   StringRef StrBufferRef = Buffer->getBuffer();
 173   SM.AddNewSourceBuffer(std::move(Buffer), SMLoc());
 174   return StrBufferRef;
 175 }
 176
 177 TEST_F(FileCheckTest, ParseVar) {
 178   SourceMgr SM;
 179   StringRef OrigVarName = bufferize(SM, "GoodVar42");
 180   StringRef VarName = OrigVarName;
 181   Expected<FileCheckPattern::VariableProperties> ParsedVarResult =
 182       FileCheckPattern::parseVariable(VarName, SM);
 183   ASSERT_TRUE(bool(ParsedVarResult));
 184   EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
 185   EXPECT_TRUE(VarName.empty());
 186   EXPECT_FALSE(ParsedVarResult->IsPseudo);
 187
 188   VarName = OrigVarName = bufferize(SM, "$GoodGlobalVar");
 189   ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
 190   ASSERT_TRUE(bool(ParsedVarResult));
 191   EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
 192   EXPECT_TRUE(VarName.empty());
 193   EXPECT_FALSE(ParsedVarResult->IsPseudo);
 194
 195   VarName = OrigVarName = bufferize(SM, "@GoodPseudoVar");
 196   ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
 197   ASSERT_TRUE(bool(ParsedVarResult));
 198   EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
 199   EXPECT_TRUE(VarName.empty());
 200   EXPECT_TRUE(ParsedVarResult->IsPseudo);
 201
 202   VarName = bufferize(SM, "42BadVar");
 203   ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
 204   EXPECT_TRUE(errorToBool(ParsedVarResult.takeError()));
 205
 206   VarName = bufferize(SM, "$@");
 207   ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
 208   EXPECT_TRUE(errorToBool(ParsedVarResult.takeError()));
 209
 210   VarName = OrigVarName = bufferize(SM, "B@dVar");
 211   ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
 212   ASSERT_TRUE(bool(ParsedVarResult));
 213   EXPECT_EQ(VarName, OrigVarName.substr(1));
 214   EXPECT_EQ(ParsedVarResult->Name, "B");
 215   EXPECT_FALSE(ParsedVarResult->IsPseudo);
 216
 217   VarName = OrigVarName = bufferize(SM, "B$dVar");
 218   ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
 219   ASSERT_TRUE(bool(ParsedVarResult));
 220   EXPECT_EQ(VarName, OrigVarName.substr(1));
 221   EXPECT_EQ(ParsedVarResult->Name, "B");
 222   EXPECT_FALSE(ParsedVarResult->IsPseudo);
 223
 224   VarName = bufferize(SM, "BadVar+");
 225   ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
 226   ASSERT_TRUE(bool(ParsedVarResult));
 227   EXPECT_EQ(VarName, "+");
 228   EXPECT_EQ(ParsedVarResult->Name, "BadVar");
 229   EXPECT_FALSE(ParsedVarResult->IsPseudo);
 230
 231   VarName = bufferize(SM, "BadVar-");
 232   ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
 233   ASSERT_TRUE(bool(ParsedVarResult));
 234   EXPECT_EQ(VarName, "-");
 235   EXPECT_EQ(ParsedVarResult->Name, "BadVar");
 236   EXPECT_FALSE(ParsedVarResult->IsPseudo);
 237
 238   VarName = bufferize(SM, "BadVar:");
 239   ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
 240   ASSERT_TRUE(bool(ParsedVarResult));
 241   EXPECT_EQ(VarName, ":");
 242   EXPECT_EQ(ParsedVarResult->Name, "BadVar");
 243   EXPECT_FALSE(ParsedVarResult->IsPseudo);
 244 }
 245
 246 class PatternTester {
 247 private:
 248   size_t LineNumber = 1;
 249   SourceMgr SM;
 250   FileCheckRequest Req;
 251   FileCheckPatternContext Context;
 252   FileCheckPattern P =
 253       FileCheckPattern(Check::CheckPlain, &Context, LineNumber++);
 254
 255 public:
 256   PatternTester() {
 257     std::vector<std::string> GlobalDefines;
 258     GlobalDefines.emplace_back(std::string("#FOO=42"));
 259     GlobalDefines.emplace_back(std::string("BAR=BAZ"));
 260     // An ASSERT_FALSE would make more sense but cannot be used in a
 261     // constructor.
 262     EXPECT_FALSE(
 263         errorToBool(Context.defineCmdlineVariables(GlobalDefines, SM)));
 264     Context.createLineVariable();
 265     // Call parsePattern to have @LINE defined.
 266     P.parsePattern("N/A", "CHECK", SM, Req);
 267     // parsePattern does not expect to be called twice for the same line and
 268     // will set FixedStr and RegExStr incorrectly if it is. Therefore prepare
 269     // a pattern for a different line.
 270     initNextPattern();
 271   }
 272
 273   void initNextPattern() {
 274     P = FileCheckPattern(Check::CheckPlain, &Context, LineNumber++);
 275   }
 276
 277   bool parseSubstExpect(StringRef Expr) {
 278     StringRef ExprBufferRef = bufferize(SM, Expr);
 279     Optional<FileCheckNumericVariable *> DefinedNumericVariable;
 280     return errorToBool(
 281         P.parseNumericSubstitutionBlock(ExprBufferRef, DefinedNumericVariable,
 282                                         false, LineNumber - 1, &Context, SM)
 283             .takeError());
 284   }
 285
 286   bool parsePatternExpect(StringRef Pattern) {
 287     StringRef PatBufferRef = bufferize(SM, Pattern);
 288     return P.parsePattern(PatBufferRef, "CHECK", SM, Req);
 289   }
 290
 291   bool matchExpect(StringRef Buffer) {
 292     StringRef BufferRef = bufferize(SM, Buffer);
 293     size_t MatchLen;
 294     return errorToBool(P.match(BufferRef, MatchLen, SM).takeError());
 295   }
 296 };
 297
 298 TEST_F(FileCheckTest, ParseExpr) {
 299   PatternTester Tester;
 300
 301   // Variable definition.
 302
 303   // Definition of invalid variable.
 304   EXPECT_TRUE(Tester.parseSubstExpect("10VAR:"));
 305   EXPECT_TRUE(Tester.parseSubstExpect("@FOO:"));
 306   EXPECT_TRUE(Tester.parseSubstExpect("@LINE:"));
 307
 308   // Conflict with pattern variable.
 309   EXPECT_TRUE(Tester.parseSubstExpect("BAR:"));
 310
 311   // Garbage after name of variable being defined.
 312   EXPECT_TRUE(Tester.parseSubstExpect("VAR GARBAGE:"));
 313
 314   // Acceptable variable definition.
 315   EXPECT_FALSE(Tester.parseSubstExpect("VAR1:"));
 316   EXPECT_FALSE(Tester.parseSubstExpect("  VAR2:"));
 317   EXPECT_FALSE(Tester.parseSubstExpect("VAR3  :"));
 318   EXPECT_FALSE(Tester.parseSubstExpect("VAR3:  "));
 319   EXPECT_FALSE(Tester.parsePatternExpect("[[#FOOBAR: FOO+1]]"));
 320
 321   // Numeric expression.
 322
 323   // Unacceptable variable.
 324   EXPECT_TRUE(Tester.parseSubstExpect("10VAR"));
 325   EXPECT_TRUE(Tester.parseSubstExpect("@FOO"));
 326
 327   // Only valid variable.
 328   EXPECT_FALSE(Tester.parseSubstExpect("@LINE"));
 329   EXPECT_FALSE(Tester.parseSubstExpect("FOO"));
 330   EXPECT_FALSE(Tester.parseSubstExpect("UNDEF"));
 331
 332   // Valid empty expression.
 333   EXPECT_FALSE(Tester.parseSubstExpect(""));
 334
 335   // Valid use of variable defined on the same line from expression. Note that
 336   // the same pattern object is used for the parsePatternExpect and
 337   // parseSubstExpect since no initNextPattern is called, thus appearing as
 338   // being on the same line from the pattern's point of view.
 339   ASSERT_FALSE(Tester.parsePatternExpect("[[#LINE1VAR:FOO+1]]"));
 340   EXPECT_FALSE(Tester.parseSubstExpect("LINE1VAR"));
 341
 342   // Invalid use of variable defined on same line from input. As above, the
 343   // absence of a call to initNextPattern makes it appear to be on the same
 344   // line from the pattern's point of view.
 345   ASSERT_FALSE(Tester.parsePatternExpect("[[#LINE2VAR:]]"));
 346   EXPECT_TRUE(Tester.parseSubstExpect("LINE2VAR"));
 347
 348   // Unsupported operator.
 349   EXPECT_TRUE(Tester.parseSubstExpect("@LINE/2"));
 350
 351   // Missing offset operand.
 352   EXPECT_TRUE(Tester.parseSubstExpect("@LINE+"));
 353
 354   // Valid expression.
 355   EXPECT_FALSE(Tester.parseSubstExpect("@LINE+5"));
 356   EXPECT_FALSE(Tester.parseSubstExpect("FOO+4"));
 357   EXPECT_FALSE(Tester.parseSubstExpect("FOOBAR"));
 358   Tester.initNextPattern();
 359   EXPECT_FALSE(Tester.parsePatternExpect("[[#FOO+FOO]]"));
 360   EXPECT_FALSE(Tester.parsePatternExpect("[[#FOO+3-FOO]]"));
 361 }
 362
 363 TEST_F(FileCheckTest, ParsePattern) {
 364   PatternTester Tester;
 365
 366   // Space in pattern variable expression.
 367   EXPECT_TRUE(Tester.parsePatternExpect("[[ BAR]]"));
 368
 369   // Invalid variable name.
 370   EXPECT_TRUE(Tester.parsePatternExpect("[[42INVALID]]"));
 371
 372   // Invalid pattern variable definition.
 373   EXPECT_TRUE(Tester.parsePatternExpect("[[@PAT:]]"));
 374   EXPECT_TRUE(Tester.parsePatternExpect("[[PAT+2:]]"));
 375
 376   // Collision with numeric variable.
 377   EXPECT_TRUE(Tester.parsePatternExpect("[[FOO:]]"));
 378
 379   // Valid use of pattern variable.
 380   EXPECT_FALSE(Tester.parsePatternExpect("[[BAR]]"));
 381
 382   // Valid pattern variable definition.
 383   EXPECT_FALSE(Tester.parsePatternExpect("[[PAT:[0-9]+]]"));
 384
 385   // Invalid numeric expressions.
 386   EXPECT_TRUE(Tester.parsePatternExpect("[[#42INVALID]]"));
 387   EXPECT_TRUE(Tester.parsePatternExpect("[[#@FOO]]"));
 388   EXPECT_TRUE(Tester.parsePatternExpect("[[#@LINE/2]]"));
 389
 390   // Valid numeric expressions and numeric variable definition.
 391   EXPECT_FALSE(Tester.parsePatternExpect("[[#FOO]]"));
 392   EXPECT_FALSE(Tester.parsePatternExpect("[[#@LINE+2]]"));
 393   EXPECT_FALSE(Tester.parsePatternExpect("[[#NUMVAR:]]"));
 394 }
 395
 396 TEST_F(FileCheckTest, Match) {
 397   PatternTester Tester;
 398
 399   // Check matching an empty expression only matches a number.
 400   Tester.parsePatternExpect("[[#]]");
 401   EXPECT_TRUE(Tester.matchExpect("FAIL"));
 402   EXPECT_FALSE(Tester.matchExpect("18"));
 403
 404   // Check matching a definition only matches a number.
 405   Tester.initNextPattern();
 406   Tester.parsePatternExpect("[[#NUMVAR:]]");
 407   EXPECT_TRUE(Tester.matchExpect("FAIL"));
 408   EXPECT_TRUE(Tester.matchExpect(""));
 409   EXPECT_FALSE(Tester.matchExpect("18"));
 410
 411   // Check matching the variable defined matches the correct number only
 412   Tester.initNextPattern();
 413   Tester.parsePatternExpect("[[#NUMVAR]] [[#NUMVAR+2]]");
 414   EXPECT_TRUE(Tester.matchExpect("19 21"));
 415   EXPECT_TRUE(Tester.matchExpect("18 21"));
 416   EXPECT_FALSE(Tester.matchExpect("18 20"));
 417
 418   // Check matching a numeric expression using @LINE after match failure uses
 419   // the correct value for @LINE.
 420   Tester.initNextPattern();
 421   EXPECT_FALSE(Tester.parsePatternExpect("[[#@LINE]]"));
 422   // Ok, @LINE is 5 now.
 423   EXPECT_FALSE(Tester.matchExpect("5"));
 424   Tester.initNextPattern();
 425   // @LINE is now 6, match with substitution failure.
 426   EXPECT_FALSE(Tester.parsePatternExpect("[[#UNKNOWN]]"));
 427   EXPECT_TRUE(Tester.matchExpect("FOO"));
 428   Tester.initNextPattern();
 429   // Check that @LINE is 7 as expected.
 430   EXPECT_FALSE(Tester.parsePatternExpect("[[#@LINE]]"));
 431   EXPECT_FALSE(Tester.matchExpect("7"));
 432 }
 433
 434 TEST_F(FileCheckTest, Substitution) {
 435   SourceMgr SM;
 436   FileCheckPatternContext Context;
 437   std::vector<std::string> GlobalDefines;
 438   GlobalDefines.emplace_back(std::string("FOO=BAR"));
 439   EXPECT_FALSE(errorToBool(Context.defineCmdlineVariables(GlobalDefines, SM)));
 440
 441   // Substitution of an undefined string variable fails and error holds that
 442   // variable's name.
 443   FileCheckStringSubstitution StringSubstitution =
 444       FileCheckStringSubstitution(&Context, "VAR404", 42);
 445   Expected<std::string> SubstValue = StringSubstitution.getResult();
 446   ASSERT_FALSE(bool(SubstValue));
 447   expectUndefError("VAR404", SubstValue.takeError());
 448
 449   // Substitutions of defined pseudo and non-pseudo numeric variables return
 450   // the right value.
 451   FileCheckNumericVariable LineVar = FileCheckNumericVariable("@LINE", 1);
 452   FileCheckNumericVariable NVar = FileCheckNumericVariable("N", 1);
 453   LineVar.setValue(42);
 454   NVar.setValue(10);
 455   auto LineVarUse =
 456       std::make_unique<FileCheckNumericVariableUse>("@LINE", &LineVar);
 457   auto NVarUse = std::make_unique<FileCheckNumericVariableUse>("N", &NVar);
 458   FileCheckNumericSubstitution SubstitutionLine = FileCheckNumericSubstitution(
 459       &Context, "@LINE", std::move(LineVarUse), 12);
 460   FileCheckNumericSubstitution SubstitutionN =
 461       FileCheckNumericSubstitution(&Context, "N", std::move(NVarUse), 30);
 462   SubstValue = SubstitutionLine.getResult();
 463   ASSERT_TRUE(bool(SubstValue));
 464   EXPECT_EQ("42", *SubstValue);
 465   SubstValue = SubstitutionN.getResult();
 466   ASSERT_TRUE(bool(SubstValue));
 467   EXPECT_EQ("10", *SubstValue);
 468
 469   // Substitution of an undefined numeric variable fails, error holds name of
 470   // undefined variable.
 471   LineVar.clearValue();
 472   SubstValue = SubstitutionLine.getResult();
 473   ASSERT_FALSE(bool(SubstValue));
 474   expectUndefError("@LINE", SubstValue.takeError());
 475   NVar.clearValue();
 476   SubstValue = SubstitutionN.getResult();
 477   ASSERT_FALSE(bool(SubstValue));
 478   expectUndefError("N", SubstValue.takeError());
 479
 480   // Substitution of a defined string variable returns the right value.
 481   FileCheckPattern P = FileCheckPattern(Check::CheckPlain, &Context, 1);
 482   StringSubstitution = FileCheckStringSubstitution(&Context, "FOO", 42);
 483   SubstValue = StringSubstitution.getResult();
 484   ASSERT_TRUE(bool(SubstValue));
 485   EXPECT_EQ("BAR", *SubstValue);
 486 }
 487
 488 TEST_F(FileCheckTest, FileCheckContext) {
 489   FileCheckPatternContext Cxt = FileCheckPatternContext();
 490   std::vector<std::string> GlobalDefines;
 491   SourceMgr SM;
 492
 493   // Missing equal sign.
 494   GlobalDefines.emplace_back(std::string("LocalVar"));
 495   EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
 496   GlobalDefines.clear();
 497   GlobalDefines.emplace_back(std::string("#LocalNumVar"));
 498   EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
 499
 500   // Empty variable name.
 501   GlobalDefines.clear();
 502   GlobalDefines.emplace_back(std::string("=18"));
 503   EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
 504   GlobalDefines.clear();
 505   GlobalDefines.emplace_back(std::string("#=18"));
 506   EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
 507
 508   // Invalid variable name.
 509   GlobalDefines.clear();
 510   GlobalDefines.emplace_back(std::string("18LocalVar=18"));
 511   EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
 512   GlobalDefines.clear();
 513   GlobalDefines.emplace_back(std::string("#18LocalNumVar=18"));
 514   EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
 515
 516   // Name conflict between pattern and numeric variable.
 517   GlobalDefines.clear();
 518   GlobalDefines.emplace_back(std::string("LocalVar=18"));
 519   GlobalDefines.emplace_back(std::string("#LocalVar=36"));
 520   EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
 521   Cxt = FileCheckPatternContext();
 522   GlobalDefines.clear();
 523   GlobalDefines.emplace_back(std::string("#LocalNumVar=18"));
 524   GlobalDefines.emplace_back(std::string("LocalNumVar=36"));
 525   EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
 526   Cxt = FileCheckPatternContext();
 527
 528   // Invalid numeric value for numeric variable.
 529   GlobalDefines.clear();
 530   GlobalDefines.emplace_back(std::string("#LocalNumVar=x"));
 531   EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
 532
 533   // Define local variables from command-line.
 534   GlobalDefines.clear();
 535   // Clear local variables to remove dummy numeric variable x that
 536   // parseNumericSubstitutionBlock would have created and stored in
 537   // GlobalNumericVariableTable.
 538   Cxt.clearLocalVars();
 539   GlobalDefines.emplace_back(std::string("LocalVar=FOO"));
 540   GlobalDefines.emplace_back(std::string("EmptyVar="));
 541   GlobalDefines.emplace_back(std::string("#LocalNumVar1=18"));
 542   GlobalDefines.emplace_back(std::string("#LocalNumVar2=LocalNumVar1+2"));
 543   ASSERT_FALSE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
 544
 545   // Check defined variables are present and undefined is absent.
 546   StringRef LocalVarStr = "LocalVar";
 547   StringRef LocalNumVar1Ref = bufferize(SM, "LocalNumVar1");
 548   StringRef LocalNumVar2Ref = bufferize(SM, "LocalNumVar2");
 549   StringRef EmptyVarStr = "EmptyVar";
 550   StringRef UnknownVarStr = "UnknownVar";
 551   Expected<StringRef> LocalVar = Cxt.getPatternVarValue(LocalVarStr);
 552   FileCheckPattern P = FileCheckPattern(Check::CheckPlain, &Cxt, 1);
 553   Optional<FileCheckNumericVariable *> DefinedNumericVariable;
 554   Expected<std::unique_ptr<FileCheckExpressionAST>> ExpressionAST =
 555       P.parseNumericSubstitutionBlock(LocalNumVar1Ref, DefinedNumericVariable,
 556                                       /*IsLegacyLineExpr=*/false,
 557                                       /*LineNumber=*/1, &Cxt, SM);
 558   ASSERT_TRUE(bool(LocalVar));
 559   EXPECT_EQ(*LocalVar, "FOO");
 560   Expected<StringRef> EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
 561   Expected<StringRef> UnknownVar = Cxt.getPatternVarValue(UnknownVarStr);
 562   ASSERT_TRUE(bool(ExpressionAST));
 563   Expected<uint64_t> ExpressionVal = (*ExpressionAST)->eval();
 564   ASSERT_TRUE(bool(ExpressionVal));
 565   EXPECT_EQ(*ExpressionVal, 18U);
 566   ExpressionAST =
 567       P.parseNumericSubstitutionBlock(LocalNumVar2Ref, DefinedNumericVariable,
 568                                       /*IsLegacyLineExpr=*/false,
 569                                       /*LineNumber=*/1, &Cxt, SM);
 570   ASSERT_TRUE(bool(ExpressionAST));
 571   ExpressionVal = (*ExpressionAST)->eval();
 572   ASSERT_TRUE(bool(ExpressionVal));
 573   EXPECT_EQ(*ExpressionVal, 20U);
 574   ASSERT_TRUE(bool(EmptyVar));
 575   EXPECT_EQ(*EmptyVar, "");
 576   EXPECT_TRUE(errorToBool(UnknownVar.takeError()));
 577
 578   // Clear local variables and check they become absent.
 579   Cxt.clearLocalVars();
 580   LocalVar = Cxt.getPatternVarValue(LocalVarStr);
 581   EXPECT_TRUE(errorToBool(LocalVar.takeError()));
 582   // Check a numeric expression's evaluation fails if called after clearing of
 583   // local variables, if it was created before. This is important because local
 584   // variable clearing due to --enable-var-scope happens after numeric
 585   // expressions are linked to the numeric variables they use.
 586   EXPECT_TRUE(errorToBool((*ExpressionAST)->eval().takeError()));
 587   P = FileCheckPattern(Check::CheckPlain, &Cxt, 2);
 588   ExpressionAST = P.parseNumericSubstitutionBlock(
 589       LocalNumVar1Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
 590       /*LineNumber=*/2, &Cxt, SM);
 591   ASSERT_TRUE(bool(ExpressionAST));
 592   ExpressionVal = (*ExpressionAST)->eval();
 593   EXPECT_TRUE(errorToBool(ExpressionVal.takeError()));
 594   ExpressionAST = P.parseNumericSubstitutionBlock(
 595       LocalNumVar2Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
 596       /*LineNumber=*/2, &Cxt, SM);
 597   ASSERT_TRUE(bool(ExpressionAST));
 598   ExpressionVal = (*ExpressionAST)->eval();
 599   EXPECT_TRUE(errorToBool(ExpressionVal.takeError()));
 600   EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
 601   EXPECT_TRUE(errorToBool(EmptyVar.takeError()));
 602   // Clear again because parseNumericSubstitutionBlock would have created a
 603   // dummy variable and stored it in GlobalNumericVariableTable.
 604   Cxt.clearLocalVars();
 605
 606   // Redefine global variables and check variables are defined again.
 607   GlobalDefines.emplace_back(std::string("$GlobalVar=BAR"));
 608   GlobalDefines.emplace_back(std::string("#$GlobalNumVar=36"));
 609   ASSERT_FALSE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
 610   StringRef GlobalVarStr = "$GlobalVar";
 611   StringRef GlobalNumVarRef = bufferize(SM, "$GlobalNumVar");
 612   Expected<StringRef> GlobalVar = Cxt.getPatternVarValue(GlobalVarStr);
 613   ASSERT_TRUE(bool(GlobalVar));
 614   EXPECT_EQ(*GlobalVar, "BAR");
 615   P = FileCheckPattern(Check::CheckPlain, &Cxt, 3);
 616   ExpressionAST = P.parseNumericSubstitutionBlock(
 617       GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
 618       /*LineNumber=*/3, &Cxt, SM);
 619   ASSERT_TRUE(bool(ExpressionAST));
 620   ExpressionVal = (*ExpressionAST)->eval();
 621   ASSERT_TRUE(bool(ExpressionVal));
 622   EXPECT_EQ(*ExpressionVal, 36U);
 623
 624   // Clear local variables and check global variables remain defined.
 625   Cxt.clearLocalVars();
 626   EXPECT_FALSE(errorToBool(Cxt.getPatternVarValue(GlobalVarStr).takeError()));
 627   P = FileCheckPattern(Check::CheckPlain, &Cxt, 4);
 628   ExpressionAST = P.parseNumericSubstitutionBlock(
 629       GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
 630       /*LineNumber=*/4, &Cxt, SM);
 631   ASSERT_TRUE(bool(ExpressionAST));
 632   ExpressionVal = (*ExpressionAST)->eval();
 633   ASSERT_TRUE(bool(ExpressionVal));
 634   EXPECT_EQ(*ExpressionVal, 36U);
 635 }
 636 } // namespace