mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-22 04:55:50 -04:00
56f6308b2d
Summary: This patch changes expression support to use one instance of FileCheckNumericVariable per numeric variable rather than one per variable and per definition. The current system was only necessary for the last patch of the numeric expression support patch series in order to handle a line using a variable defined earlier on the same line from the input text. However this can be dealt more efficiently. 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/D64229 llvm-svn: 365220
513 lines
19 KiB
C++
513 lines
19 KiB
C++
//===- 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)));
|
|
Context.createLineVariable();
|
|
// 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);
|
|
return errorToBool(FileCheckPattern::parseNumericVariableDefinition(
|
|
ExprBufferRef, &Context, LineNumber, SM)
|
|
.takeError());
|
|
}
|
|
|
|
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
|