Gericom/teak-llvm
1
Fork 0
mirror of https://github.com/Gericom/teak-llvm.git synced 2025-06-22 04:55:50 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity
fe7ac170a7
teak-llvm/llvm/unittests/Support/FileCheckTest.cpp
Thomas Preud'homme fe7ac170a7 [FileCheck] Don't diagnose undef vars at parse time 
Summary:
Diagnosing use of undefined variables takes place in
parseNumericVariableUse() and printSubstitutions() for numeric variables
but only takes place in printSubstitutions() for string variables. The
reason for the split location of diagnostics is that parsing is not
aware of the clearing of variables due to --enable-var-scope and thus
use of variables cleared in this way can only be catched by
printSubstitutions().

Beyond the code level inconsistency, there is also a user facing
inconsistency since diagnostics look different between the two
functions. While the diagnostic in printSubstitutions is more verbose,
doing the diagnostic there allows to diagnose all undefined variables
rather than just the first one and error out.

This patch create dummy variable definition when encountering a use of
undefined variable so that parsing can proceed and be diagnosed by
printSubstitutions() later. Tests that were testing whether parsing
fails in such case are thus modified accordingly.

Reviewers: jhenderson, chandlerc, jdenny, probinson, grimar, arichardson, rnk

Subscribers: JonChesterfield, rogfer01, hfinkel, kristina, rnk, tra, arichardson, grimar, dblaikie, probinson, llvm-commits, hiraditya

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D64228

llvm-svn: 365219
2019-07-05 16:25:33 +00:00

512 lines
19 KiB
C++
Raw Blame History

//===- llvm/unittest/Support/FileCheckTest.cpp - FileCheck tests --===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/FileCheck.h"
#include "gtest/gtest.h"
using namespace llvm;
namespace {
class FileCheckTest : public ::testing::Test {};
TEST_F(FileCheckTest, NumericVariable) {
// Undefined variable: getValue and clearValue fails, setValue works.
FileCheckNumericVariable FooVar = FileCheckNumericVariable(1, "FOO");
EXPECT_EQ("FOO", FooVar.getName());
llvm::Optional<uint64_t> Value = FooVar.getValue();
EXPECT_FALSE(Value);
EXPECT_TRUE(FooVar.clearValue());
EXPECT_FALSE(FooVar.setValue(42));
// Defined variable: getValue returns value set, setValue fails.
Value = FooVar.getValue();
EXPECT_TRUE(Value);
EXPECT_EQ(42U, *Value);
EXPECT_TRUE(FooVar.setValue(43));
Value = FooVar.getValue();
EXPECT_TRUE(Value);
EXPECT_EQ(42U, *Value);
// Clearing variable: getValue fails, clearValue again fails.
EXPECT_FALSE(FooVar.clearValue());
Value = FooVar.getValue();
EXPECT_FALSE(Value);
EXPECT_TRUE(FooVar.clearValue());
}
uint64_t doAdd(uint64_t OpL, uint64_t OpR) { return OpL + OpR; }
static void expectUndefError(const Twine &ExpectedStr, Error Err) {
handleAllErrors(std::move(Err), [&](const FileCheckUndefVarError &E) {
EXPECT_EQ(ExpectedStr.str(), E.getVarName());
});
}
TEST_F(FileCheckTest, Expression) {
FileCheckNumericVariable FooVar = FileCheckNumericVariable("FOO", 42);
FileCheckExpression Expression = FileCheckExpression(doAdd, &FooVar, 18);
// Defined variable: eval returns right value.
Expected<uint64_t> Value = Expression.eval();
EXPECT_TRUE(static_cast<bool>(Value));
EXPECT_EQ(60U, *Value);
// Undefined variable: eval fails, undefined variable returned. We call
// getUndefVarName first to check that it can be called without calling
// eval() first.
FooVar.clearValue();
Error EvalError = Expression.eval().takeError();
EXPECT_TRUE(errorToBool(std::move(EvalError)));
expectUndefError("FOO", std::move(EvalError));
}
TEST_F(FileCheckTest, ValidVarNameStart) {
EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('a'));
EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('G'));
EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('_'));
EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('2'));
EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('$'));
EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('@'));
EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('+'));
EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('-'));
EXPECT_FALSE(FileCheckPattern::isValidVarNameStart(':'));
}
static StringRef bufferize(SourceMgr &SM, StringRef Str) {
std::unique_ptr<MemoryBuffer> Buffer =
MemoryBuffer::getMemBufferCopy(Str, "TestBuffer");
StringRef StrBufferRef = Buffer->getBuffer();
SM.AddNewSourceBuffer(std::move(Buffer), SMLoc());
return StrBufferRef;
}
TEST_F(FileCheckTest, ParseVar) {
SourceMgr SM;
StringRef OrigVarName = bufferize(SM, "GoodVar42");
StringRef VarName = OrigVarName;
bool IsPseudo = true;
Expected<StringRef> ParsedName =
FileCheckPattern::parseVariable(VarName, IsPseudo, SM);
EXPECT_TRUE(static_cast<bool>(ParsedName));
EXPECT_EQ(*ParsedName, OrigVarName);
EXPECT_TRUE(VarName.empty());
EXPECT_FALSE(IsPseudo);
VarName = OrigVarName = bufferize(SM, "$GoodGlobalVar");
IsPseudo = true;
ParsedName = FileCheckPattern::parseVariable(VarName, IsPseudo, SM);
EXPECT_TRUE(static_cast<bool>(ParsedName));
EXPECT_EQ(*ParsedName, OrigVarName);
EXPECT_TRUE(VarName.empty());
EXPECT_FALSE(IsPseudo);
VarName = OrigVarName = bufferize(SM, "@GoodPseudoVar");
IsPseudo = true;
ParsedName = FileCheckPattern::parseVariable(VarName, IsPseudo, SM);
EXPECT_TRUE(static_cast<bool>(ParsedName));
EXPECT_EQ(*ParsedName, OrigVarName);
EXPECT_TRUE(VarName.empty());
EXPECT_TRUE(IsPseudo);
VarName = bufferize(SM, "42BadVar");
ParsedName = FileCheckPattern::parseVariable(VarName, IsPseudo, SM);
EXPECT_TRUE(errorToBool(ParsedName.takeError()));
VarName = bufferize(SM, "$@");
ParsedName = FileCheckPattern::parseVariable(VarName, IsPseudo, SM);
EXPECT_TRUE(errorToBool(ParsedName.takeError()));
VarName = OrigVarName = bufferize(SM, "B@dVar");
IsPseudo = true;
ParsedName = FileCheckPattern::parseVariable(VarName, IsPseudo, SM);
EXPECT_TRUE(static_cast<bool>(ParsedName));
EXPECT_EQ(VarName, OrigVarName.substr(1));
EXPECT_EQ(*ParsedName, "B");
EXPECT_FALSE(IsPseudo);
VarName = OrigVarName = bufferize(SM, "B$dVar");
IsPseudo = true;
ParsedName = FileCheckPattern::parseVariable(VarName, IsPseudo, SM);
EXPECT_TRUE(static_cast<bool>(ParsedName));
EXPECT_EQ(VarName, OrigVarName.substr(1));
EXPECT_EQ(*ParsedName, "B");
EXPECT_FALSE(IsPseudo);
VarName = bufferize(SM, "BadVar+");
IsPseudo = true;
ParsedName = FileCheckPattern::parseVariable(VarName, IsPseudo, SM);
EXPECT_TRUE(static_cast<bool>(ParsedName));
EXPECT_EQ(VarName, "+");
EXPECT_EQ(*ParsedName, "BadVar");
EXPECT_FALSE(IsPseudo);
VarName = bufferize(SM, "BadVar-");
IsPseudo = true;
ParsedName = FileCheckPattern::parseVariable(VarName, IsPseudo, SM);
EXPECT_TRUE(static_cast<bool>(ParsedName));
EXPECT_EQ(VarName, "-");
EXPECT_EQ(*ParsedName, "BadVar");
EXPECT_FALSE(IsPseudo);
VarName = bufferize(SM, "BadVar:");
IsPseudo = true;
ParsedName = FileCheckPattern::parseVariable(VarName, IsPseudo, SM);
EXPECT_TRUE(static_cast<bool>(ParsedName));
EXPECT_EQ(VarName, ":");
EXPECT_EQ(*ParsedName, "BadVar");
EXPECT_FALSE(IsPseudo);
}
class PatternTester {
private:
size_t LineNumber = 1;
SourceMgr SM;
FileCheckRequest Req;
FileCheckPatternContext Context;
FileCheckPattern P =
FileCheckPattern(Check::CheckPlain, &Context, LineNumber++);
public:
PatternTester() {
std::vector<std::string> GlobalDefines;
GlobalDefines.emplace_back(std::string("#FOO=42"));
GlobalDefines.emplace_back(std::string("BAR=BAZ"));
EXPECT_FALSE(
errorToBool(Context.defineCmdlineVariables(GlobalDefines, SM)));
// Call parsePattern to have @LINE defined.
P.parsePattern("N/A", "CHECK", SM, Req);
// parsePattern does not expect to be called twice for the same line and
// will set FixedStr and RegExStr incorrectly if it is. Therefore prepare
// a pattern for a different line.
initNextPattern();
}
void initNextPattern() {
P = FileCheckPattern(Check::CheckPlain, &Context, LineNumber++);
}
bool parseNumVarDefExpect(StringRef Expr) {
StringRef ExprBufferRef = bufferize(SM, Expr);
StringRef Name;
return errorToBool(FileCheckPattern::parseNumericVariableDefinition(
ExprBufferRef, Name, &Context, SM));
}
bool parseSubstExpect(StringRef Expr) {
StringRef ExprBufferRef = bufferize(SM, Expr);
Optional<FileCheckNumericVariable *> DefinedNumericVariable;
return errorToBool(P.parseNumericSubstitutionBlock(
ExprBufferRef, DefinedNumericVariable, SM)
.takeError());
}
bool parsePatternExpect(StringRef Pattern) {
StringRef PatBufferRef = bufferize(SM, Pattern);
return P.parsePattern(PatBufferRef, "CHECK", SM, Req);
}
bool matchExpect(StringRef Buffer) {
StringRef BufferRef = bufferize(SM, Buffer);
size_t MatchLen;
return errorToBool(P.match(BufferRef, MatchLen, SM).takeError());
}
};
TEST_F(FileCheckTest, ParseNumericVariableDefinition) {
PatternTester Tester;
// Invalid definition of pseudo.
EXPECT_TRUE(Tester.parseNumVarDefExpect("@LINE"));
// Conflict with pattern variable.
EXPECT_TRUE(Tester.parseNumVarDefExpect("BAR"));
// Defined variable.
EXPECT_FALSE(Tester.parseNumVarDefExpect("FOO"));
}
TEST_F(FileCheckTest, ParseExpr) {
PatternTester Tester;
// Variable definition.
// Definition of invalid variable.
EXPECT_TRUE(Tester.parseSubstExpect("10VAR:"));
EXPECT_TRUE(Tester.parseSubstExpect("@FOO:"));
EXPECT_TRUE(Tester.parseSubstExpect("@LINE:"));
// Garbage after name of variable being defined.
EXPECT_TRUE(Tester.parseSubstExpect("VAR GARBAGE:"));
// Variable defined to numeric expression.
EXPECT_TRUE(Tester.parseSubstExpect("VAR1: FOO"));
// Acceptable variable definition.
EXPECT_FALSE(Tester.parseSubstExpect("VAR1:"));
EXPECT_FALSE(Tester.parseSubstExpect(" VAR2:"));
EXPECT_FALSE(Tester.parseSubstExpect("VAR3 :"));
EXPECT_FALSE(Tester.parseSubstExpect("VAR3: "));
// Numeric expression.
// Unacceptable variable.
EXPECT_TRUE(Tester.parseSubstExpect("10VAR"));
EXPECT_TRUE(Tester.parseSubstExpect("@FOO"));
// Only valid variable.
EXPECT_FALSE(Tester.parseSubstExpect("@LINE"));
EXPECT_FALSE(Tester.parseSubstExpect("FOO"));
EXPECT_FALSE(Tester.parseSubstExpect("UNDEF"));
// Use variable defined on same line.
EXPECT_FALSE(Tester.parsePatternExpect("[[#LINE1VAR:]]"));
EXPECT_TRUE(Tester.parseSubstExpect("LINE1VAR"));
// Unsupported operator.
EXPECT_TRUE(Tester.parseSubstExpect("@LINE/2"));
// Missing offset operand.
EXPECT_TRUE(Tester.parseSubstExpect("@LINE+"));
// Cannot parse offset operand.
EXPECT_TRUE(Tester.parseSubstExpect("@LINE+x"));
// Unexpected string at end of numeric expression.
EXPECT_TRUE(Tester.parseSubstExpect("@LINE+5x"));
// Valid expression.
EXPECT_FALSE(Tester.parseSubstExpect("@LINE+5"));
EXPECT_FALSE(Tester.parseSubstExpect("FOO+4"));
}
TEST_F(FileCheckTest, ParsePattern) {
PatternTester Tester;
// Space in pattern variable expression.
EXPECT_TRUE(Tester.parsePatternExpect("[[ BAR]]"));
// Invalid variable name.
EXPECT_TRUE(Tester.parsePatternExpect("[[42INVALID]]"));
// Invalid pattern variable definition.
EXPECT_TRUE(Tester.parsePatternExpect("[[@PAT:]]"));
EXPECT_TRUE(Tester.parsePatternExpect("[[PAT+2:]]"));
// Collision with numeric variable.
EXPECT_TRUE(Tester.parsePatternExpect("[[FOO:]]"));
// Valid use of pattern variable.
EXPECT_FALSE(Tester.parsePatternExpect("[[BAR]]"));
// Valid pattern variable definition.
EXPECT_FALSE(Tester.parsePatternExpect("[[PAT:[0-9]+]]"));
// Invalid numeric expressions.
EXPECT_TRUE(Tester.parsePatternExpect("[[#42INVALID]]"));
EXPECT_TRUE(Tester.parsePatternExpect("[[#@FOO]]"));
EXPECT_TRUE(Tester.parsePatternExpect("[[#@LINE/2]]"));
EXPECT_TRUE(Tester.parsePatternExpect("[[#2+@LINE]]"));
EXPECT_TRUE(Tester.parsePatternExpect("[[#YUP:@LINE]]"));
// Valid numeric expressions and numeric variable definition.
EXPECT_FALSE(Tester.parsePatternExpect("[[#FOO]]"));
EXPECT_FALSE(Tester.parsePatternExpect("[[#@LINE+2]]"));
EXPECT_FALSE(Tester.parsePatternExpect("[[#NUMVAR:]]"));
}
TEST_F(FileCheckTest, Match) {
PatternTester Tester;
// Check matching a definition only matches a number.
Tester.parsePatternExpect("[[#NUMVAR:]]");
EXPECT_TRUE(Tester.matchExpect("FAIL"));
EXPECT_FALSE(Tester.matchExpect("18"));
// Check matching the variable defined matches the correct number only
Tester.initNextPattern();
Tester.parsePatternExpect("[[#NUMVAR]] [[#NUMVAR+2]]");
EXPECT_TRUE(Tester.matchExpect("19 21"));
EXPECT_TRUE(Tester.matchExpect("18 21"));
EXPECT_FALSE(Tester.matchExpect("18 20"));
}
TEST_F(FileCheckTest, Substitution) {
SourceMgr SM;
FileCheckPatternContext Context;
std::vector<std::string> GlobalDefines;
GlobalDefines.emplace_back(std::string("FOO=BAR"));
EXPECT_FALSE(errorToBool(Context.defineCmdlineVariables(GlobalDefines, SM)));
// Substitution of an undefined string variable fails and error holds that
// variable's name.
FileCheckStringSubstitution StringSubstitution =
FileCheckStringSubstitution(&Context, "VAR404", 42);
Expected<std::string> SubstValue = StringSubstitution.getResult();
EXPECT_FALSE(static_cast<bool>(SubstValue));
expectUndefError("VAR404", SubstValue.takeError());
// Substitutions of defined pseudo and non-pseudo numeric variables return
// the right value.
FileCheckNumericVariable LineVar = FileCheckNumericVariable("@LINE", 42);
FileCheckNumericVariable NVar = FileCheckNumericVariable("N", 10);
FileCheckExpression LineExpression = FileCheckExpression(doAdd, &LineVar, 0);
FileCheckExpression NExpression = FileCheckExpression(doAdd, &NVar, 3);
FileCheckNumericSubstitution SubstitutionLine =
FileCheckNumericSubstitution(&Context, "@LINE", &LineExpression, 12);
FileCheckNumericSubstitution SubstitutionN =
FileCheckNumericSubstitution(&Context, "N", &NExpression, 30);
Expected<std::string> Value = SubstitutionLine.getResult();
EXPECT_TRUE(static_cast<bool>(Value));
EXPECT_EQ("42", *Value);
Value = SubstitutionN.getResult();
EXPECT_TRUE(static_cast<bool>(Value));
EXPECT_EQ("13", *Value);
// Substitution of an undefined numeric variable fails.
LineVar.clearValue();
SubstValue = SubstitutionLine.getResult().takeError();
EXPECT_FALSE(static_cast<bool>(SubstValue));
expectUndefError("@LINE", SubstValue.takeError());
NVar.clearValue();
SubstValue = SubstitutionN.getResult().takeError();
EXPECT_FALSE(static_cast<bool>(SubstValue));
expectUndefError("N", SubstValue.takeError());
// Substitution of a defined string variable returns the right value.
FileCheckPattern P = FileCheckPattern(Check::CheckPlain, &Context, 1);
StringSubstitution = FileCheckStringSubstitution(&Context, "FOO", 42);
Value = StringSubstitution.getResult();
EXPECT_TRUE(static_cast<bool>(Value));
EXPECT_EQ("BAR", *Value);
}
TEST_F(FileCheckTest, FileCheckContext) {
FileCheckPatternContext Cxt = FileCheckPatternContext();
std::vector<std::string> GlobalDefines;
SourceMgr SM;
// Missing equal sign.
GlobalDefines.emplace_back(std::string("LocalVar"));
EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
GlobalDefines.clear();
GlobalDefines.emplace_back(std::string("#LocalNumVar"));
EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
// Empty variable name.
GlobalDefines.clear();
GlobalDefines.emplace_back(std::string("=18"));
EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
GlobalDefines.clear();
GlobalDefines.emplace_back(std::string("#=18"));
EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
// Invalid variable name.
GlobalDefines.clear();
GlobalDefines.emplace_back(std::string("18LocalVar=18"));
EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
GlobalDefines.clear();
GlobalDefines.emplace_back(std::string("#18LocalNumVar=18"));
EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
// Name conflict between pattern and numeric variable.
GlobalDefines.clear();
GlobalDefines.emplace_back(std::string("LocalVar=18"));
GlobalDefines.emplace_back(std::string("#LocalVar=36"));
EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
Cxt = FileCheckPatternContext();
GlobalDefines.clear();
GlobalDefines.emplace_back(std::string("#LocalNumVar=18"));
GlobalDefines.emplace_back(std::string("LocalNumVar=36"));
EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
Cxt = FileCheckPatternContext();
// Invalid numeric value for numeric variable.
GlobalDefines.clear();
GlobalDefines.emplace_back(std::string("#LocalNumVar=x"));
EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
// Define local variables from command-line.
GlobalDefines.clear();
GlobalDefines.emplace_back(std::string("LocalVar=FOO"));
GlobalDefines.emplace_back(std::string("EmptyVar="));
GlobalDefines.emplace_back(std::string("#LocalNumVar=18"));
EXPECT_FALSE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
// Check defined variables are present and undefined is absent.
StringRef LocalVarStr = "LocalVar";
StringRef LocalNumVarRef = bufferize(SM, "LocalNumVar");
StringRef EmptyVarStr = "EmptyVar";
StringRef UnknownVarStr = "UnknownVar";
Expected<StringRef> LocalVar = Cxt.getPatternVarValue(LocalVarStr);
FileCheckPattern P = FileCheckPattern(Check::CheckPlain, &Cxt, 1);
Optional<FileCheckNumericVariable *> DefinedNumericVariable;
Expected<FileCheckExpression *> Expression = P.parseNumericSubstitutionBlock(
LocalNumVarRef, DefinedNumericVariable, SM);
Expected<StringRef> EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
Expected<StringRef> UnknownVar = Cxt.getPatternVarValue(UnknownVarStr);
EXPECT_TRUE(static_cast<bool>(LocalVar));
EXPECT_EQ(*LocalVar, "FOO");
EXPECT_TRUE(static_cast<bool>(Expression));
Expected<uint64_t> ExpressionVal = (*Expression)->eval();
EXPECT_TRUE(static_cast<bool>(ExpressionVal));
EXPECT_EQ(*ExpressionVal, 18U);
EXPECT_TRUE(static_cast<bool>(EmptyVar));
EXPECT_EQ(*EmptyVar, "");
EXPECT_TRUE(errorToBool(UnknownVar.takeError()));
// Clear local variables and check they become absent.
Cxt.clearLocalVars();
LocalVar = Cxt.getPatternVarValue(LocalVarStr);
EXPECT_TRUE(errorToBool(LocalVar.takeError()));
// Check a numeric expression's evaluation fails if called after clearing of
// local variables, if it was created before. This is important because local
// variable clearing due to --enable-var-scope happens after numeric
// expressions are linked to the numeric variables they use.
EXPECT_TRUE(errorToBool((*Expression)->eval().takeError()));
P = FileCheckPattern(Check::CheckPlain, &Cxt, 2);
Expression = P.parseNumericSubstitutionBlock(LocalNumVarRef,
DefinedNumericVariable, SM);
EXPECT_TRUE(bool(Expression));
ExpressionVal = (*Expression)->eval();
EXPECT_TRUE(errorToBool(ExpressionVal.takeError()));
EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
EXPECT_TRUE(errorToBool(EmptyVar.takeError()));
// Clear again because parseNumericSubstitutionBlock would have created a
// dummy variable and stored it in GlobalNumericVariableTable.
Cxt.clearLocalVars();
// Redefine global variables and check variables are defined again.
GlobalDefines.emplace_back(std::string("$GlobalVar=BAR"));
GlobalDefines.emplace_back(std::string("#$GlobalNumVar=36"));
EXPECT_FALSE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
StringRef GlobalVarStr = "$GlobalVar";
StringRef GlobalNumVarRef = bufferize(SM, "$GlobalNumVar");
Expected<StringRef> GlobalVar = Cxt.getPatternVarValue(GlobalVarStr);
EXPECT_TRUE(static_cast<bool>(GlobalVar));
EXPECT_EQ(*GlobalVar, "BAR");
P = FileCheckPattern(Check::CheckPlain, &Cxt, 3);
Expression = P.parseNumericSubstitutionBlock(GlobalNumVarRef,
DefinedNumericVariable, SM);
EXPECT_TRUE(static_cast<bool>(Expression));
ExpressionVal = (*Expression)->eval();
EXPECT_TRUE(static_cast<bool>(ExpressionVal));
EXPECT_EQ(*ExpressionVal, 36U);
// Clear local variables and check global variables remain defined.
Cxt.clearLocalVars();
EXPECT_FALSE(errorToBool(Cxt.getPatternVarValue(GlobalVarStr).takeError()));
P = FileCheckPattern(Check::CheckPlain, &Cxt, 4);
Expression = P.parseNumericSubstitutionBlock(GlobalNumVarRef,
DefinedNumericVariable, SM);
EXPECT_TRUE(static_cast<bool>(Expression));
ExpressionVal = (*Expression)->eval();
EXPECT_TRUE(static_cast<bool>(ExpressionVal));
EXPECT_EQ(*ExpressionVal, 36U);
}
} // namespace
Reference in New Issue View Git Blame Copy Permalink