aboutsummaryrefslogtreecommitdiff
path: root/llvm/unittests/Support/FileCheckTest.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/unittests/Support/FileCheckTest.cpp')
-rw-r--r--llvm/unittests/Support/FileCheckTest.cpp144
1 files changed, 71 insertions, 73 deletions
diff --git a/llvm/unittests/Support/FileCheckTest.cpp b/llvm/unittests/Support/FileCheckTest.cpp
index 66465f1..8ca0af7 100644
--- a/llvm/unittests/Support/FileCheckTest.cpp
+++ b/llvm/unittests/Support/FileCheckTest.cpp
@@ -19,13 +19,13 @@ class FileCheckTest : public ::testing::Test {};
TEST_F(FileCheckTest, Literal) {
// Eval returns the literal's value.
- FileCheckExpressionLiteral Ten(10);
+ ExpressionLiteral Ten(10);
Expected<uint64_t> Value = Ten.eval();
ASSERT_TRUE(bool(Value));
EXPECT_EQ(10U, *Value);
// Max value can be correctly represented.
- FileCheckExpressionLiteral Max(std::numeric_limits<uint64_t>::max());
+ ExpressionLiteral Max(std::numeric_limits<uint64_t>::max());
Value = Max.eval();
ASSERT_TRUE(bool(Value));
EXPECT_EQ(std::numeric_limits<uint64_t>::max(), *Value);
@@ -45,14 +45,14 @@ static std::string toString(const std::unordered_set<std::string> &Set) {
static void
expectUndefErrors(std::unordered_set<std::string> ExpectedUndefVarNames,
Error Err) {
- handleAllErrors(std::move(Err), [&](const FileCheckUndefVarError &E) {
+ handleAllErrors(std::move(Err), [&](const UndefVarError &E) {
ExpectedUndefVarNames.erase(E.getVarName());
});
EXPECT_TRUE(ExpectedUndefVarNames.empty()) << toString(ExpectedUndefVarNames);
}
-// Return whether Err contains any FileCheckUndefVarError whose associated name
-// is not ExpectedUndefVarName.
+// Return whether Err contains any UndefVarError whose associated name is not
+// ExpectedUndefVarName.
static void expectUndefError(const Twine &ExpectedUndefVarName, Error Err) {
expectUndefErrors({ExpectedUndefVarName.str()}, std::move(Err));
}
@@ -62,9 +62,9 @@ uint64_t doAdd(uint64_t OpL, uint64_t OpR) { return OpL + OpR; }
TEST_F(FileCheckTest, NumericVariable) {
// Undefined variable: getValue and eval fail, error returned by eval holds
// the name of the undefined variable.
- FileCheckNumericVariable FooVar("FOO", 1);
+ NumericVariable FooVar("FOO", 1);
EXPECT_EQ("FOO", FooVar.getName());
- FileCheckNumericVariableUse FooVarUse("FOO", &FooVar);
+ NumericVariableUse FooVarUse("FOO", &FooVar);
EXPECT_FALSE(FooVar.getValue());
Expected<uint64_t> EvalResult = FooVarUse.eval();
ASSERT_FALSE(EvalResult);
@@ -90,15 +90,15 @@ TEST_F(FileCheckTest, NumericVariable) {
}
TEST_F(FileCheckTest, Binop) {
- FileCheckNumericVariable FooVar("FOO", 1);
+ NumericVariable FooVar("FOO", 1);
FooVar.setValue(42);
- std::unique_ptr<FileCheckNumericVariableUse> FooVarUse =
- std::make_unique<FileCheckNumericVariableUse>("FOO", &FooVar);
- FileCheckNumericVariable BarVar("BAR", 2);
+ std::unique_ptr<NumericVariableUse> FooVarUse =
+ std::make_unique<NumericVariableUse>("FOO", &FooVar);
+ NumericVariable BarVar("BAR", 2);
BarVar.setValue(18);
- std::unique_ptr<FileCheckNumericVariableUse> BarVarUse =
- std::make_unique<FileCheckNumericVariableUse>("BAR", &BarVar);
- FileCheckASTBinop Binop(doAdd, std::move(FooVarUse), std::move(BarVarUse));
+ std::unique_ptr<NumericVariableUse> BarVarUse =
+ std::make_unique<NumericVariableUse>("BAR", &BarVar);
+ BinaryOperation Binop(doAdd, std::move(FooVarUse), std::move(BarVarUse));
// Defined variable: eval returns right value.
Expected<uint64_t> Value = Binop.eval();
@@ -121,15 +121,15 @@ TEST_F(FileCheckTest, Binop) {
}
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(':'));
+ EXPECT_TRUE(Pattern::isValidVarNameStart('a'));
+ EXPECT_TRUE(Pattern::isValidVarNameStart('G'));
+ EXPECT_TRUE(Pattern::isValidVarNameStart('_'));
+ EXPECT_FALSE(Pattern::isValidVarNameStart('2'));
+ EXPECT_FALSE(Pattern::isValidVarNameStart('$'));
+ EXPECT_FALSE(Pattern::isValidVarNameStart('@'));
+ EXPECT_FALSE(Pattern::isValidVarNameStart('+'));
+ EXPECT_FALSE(Pattern::isValidVarNameStart('-'));
+ EXPECT_FALSE(Pattern::isValidVarNameStart(':'));
}
static StringRef bufferize(SourceMgr &SM, StringRef Str) {
@@ -144,65 +144,65 @@ TEST_F(FileCheckTest, ParseVar) {
SourceMgr SM;
StringRef OrigVarName = bufferize(SM, "GoodVar42");
StringRef VarName = OrigVarName;
- Expected<FileCheckPattern::VariableProperties> ParsedVarResult =
- FileCheckPattern::parseVariable(VarName, SM);
+ Expected<Pattern::VariableProperties> ParsedVarResult =
+ Pattern::parseVariable(VarName, SM);
ASSERT_TRUE(bool(ParsedVarResult));
EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
EXPECT_TRUE(VarName.empty());
EXPECT_FALSE(ParsedVarResult->IsPseudo);
VarName = OrigVarName = bufferize(SM, "$GoodGlobalVar");
- ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+ ParsedVarResult = Pattern::parseVariable(VarName, SM);
ASSERT_TRUE(bool(ParsedVarResult));
EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
EXPECT_TRUE(VarName.empty());
EXPECT_FALSE(ParsedVarResult->IsPseudo);
VarName = OrigVarName = bufferize(SM, "@GoodPseudoVar");
- ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+ ParsedVarResult = Pattern::parseVariable(VarName, SM);
ASSERT_TRUE(bool(ParsedVarResult));
EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
EXPECT_TRUE(VarName.empty());
EXPECT_TRUE(ParsedVarResult->IsPseudo);
VarName = bufferize(SM, "42BadVar");
- ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+ ParsedVarResult = Pattern::parseVariable(VarName, SM);
EXPECT_TRUE(errorToBool(ParsedVarResult.takeError()));
VarName = bufferize(SM, "$@");
- ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+ ParsedVarResult = Pattern::parseVariable(VarName, SM);
EXPECT_TRUE(errorToBool(ParsedVarResult.takeError()));
VarName = OrigVarName = bufferize(SM, "B@dVar");
- ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+ ParsedVarResult = Pattern::parseVariable(VarName, SM);
ASSERT_TRUE(bool(ParsedVarResult));
EXPECT_EQ(VarName, OrigVarName.substr(1));
EXPECT_EQ(ParsedVarResult->Name, "B");
EXPECT_FALSE(ParsedVarResult->IsPseudo);
VarName = OrigVarName = bufferize(SM, "B$dVar");
- ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+ ParsedVarResult = Pattern::parseVariable(VarName, SM);
ASSERT_TRUE(bool(ParsedVarResult));
EXPECT_EQ(VarName, OrigVarName.substr(1));
EXPECT_EQ(ParsedVarResult->Name, "B");
EXPECT_FALSE(ParsedVarResult->IsPseudo);
VarName = bufferize(SM, "BadVar+");
- ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+ ParsedVarResult = Pattern::parseVariable(VarName, SM);
ASSERT_TRUE(bool(ParsedVarResult));
EXPECT_EQ(VarName, "+");
EXPECT_EQ(ParsedVarResult->Name, "BadVar");
EXPECT_FALSE(ParsedVarResult->IsPseudo);
VarName = bufferize(SM, "BadVar-");
- ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+ ParsedVarResult = Pattern::parseVariable(VarName, SM);
ASSERT_TRUE(bool(ParsedVarResult));
EXPECT_EQ(VarName, "-");
EXPECT_EQ(ParsedVarResult->Name, "BadVar");
EXPECT_FALSE(ParsedVarResult->IsPseudo);
VarName = bufferize(SM, "BadVar:");
- ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+ ParsedVarResult = Pattern::parseVariable(VarName, SM);
ASSERT_TRUE(bool(ParsedVarResult));
EXPECT_EQ(VarName, ":");
EXPECT_EQ(ParsedVarResult->Name, "BadVar");
@@ -215,7 +215,7 @@ private:
SourceMgr SM;
FileCheckRequest Req;
FileCheckPatternContext Context;
- FileCheckPattern P{Check::CheckPlain, &Context, LineNumber++};
+ Pattern P{Check::CheckPlain, &Context, LineNumber++};
public:
PatternTester() {
@@ -236,12 +236,12 @@ public:
}
void initNextPattern() {
- P = FileCheckPattern(Check::CheckPlain, &Context, LineNumber++);
+ P = Pattern(Check::CheckPlain, &Context, LineNumber++);
}
bool parseSubstExpect(StringRef Expr) {
StringRef ExprBufferRef = bufferize(SM, Expr);
- Optional<FileCheckNumericVariable *> DefinedNumericVariable;
+ Optional<NumericVariable *> DefinedNumericVariable;
return errorToBool(
P.parseNumericSubstitutionBlock(ExprBufferRef, DefinedNumericVariable,
false, LineNumber - 1, &Context, SM)
@@ -406,24 +406,22 @@ TEST_F(FileCheckTest, Substitution) {
// Substitution of an undefined string variable fails and error holds that
// variable's name.
- FileCheckStringSubstitution StringSubstitution(&Context, "VAR404", 42);
+ StringSubstitution StringSubstitution(&Context, "VAR404", 42);
Expected<std::string> SubstValue = StringSubstitution.getResult();
ASSERT_FALSE(bool(SubstValue));
expectUndefError("VAR404", SubstValue.takeError());
// Substitutions of defined pseudo and non-pseudo numeric variables return
// the right value.
- FileCheckNumericVariable LineVar("@LINE", 1);
- FileCheckNumericVariable NVar("N", 1);
+ NumericVariable LineVar("@LINE", 1);
+ NumericVariable NVar("N", 1);
LineVar.setValue(42);
NVar.setValue(10);
- auto LineVarUse =
- std::make_unique<FileCheckNumericVariableUse>("@LINE", &LineVar);
- auto NVarUse = std::make_unique<FileCheckNumericVariableUse>("N", &NVar);
- FileCheckNumericSubstitution SubstitutionLine(&Context, "@LINE",
- std::move(LineVarUse), 12);
- FileCheckNumericSubstitution SubstitutionN(&Context, "N", std::move(NVarUse),
- 30);
+ auto LineVarUse = std::make_unique<NumericVariableUse>("@LINE", &LineVar);
+ auto NVarUse = std::make_unique<NumericVariableUse>("N", &NVar);
+ NumericSubstitution SubstitutionLine(&Context, "@LINE", std::move(LineVarUse),
+ 12);
+ NumericSubstitution SubstitutionN(&Context, "N", std::move(NVarUse), 30);
SubstValue = SubstitutionLine.getResult();
ASSERT_TRUE(bool(SubstValue));
EXPECT_EQ("42", *SubstValue);
@@ -443,8 +441,8 @@ TEST_F(FileCheckTest, Substitution) {
expectUndefError("N", SubstValue.takeError());
// Substitution of a defined string variable returns the right value.
- FileCheckPattern P(Check::CheckPlain, &Context, 1);
- StringSubstitution = FileCheckStringSubstitution(&Context, "FOO", 42);
+ Pattern P(Check::CheckPlain, &Context, 1);
+ StringSubstitution = llvm::StringSubstitution(&Context, "FOO", 42);
SubstValue = StringSubstitution.getResult();
ASSERT_TRUE(bool(SubstValue));
EXPECT_EQ("BAR", *SubstValue);
@@ -514,9 +512,9 @@ TEST_F(FileCheckTest, FileCheckContext) {
StringRef EmptyVarStr = "EmptyVar";
StringRef UnknownVarStr = "UnknownVar";
Expected<StringRef> LocalVar = Cxt.getPatternVarValue(LocalVarStr);
- FileCheckPattern P(Check::CheckPlain, &Cxt, 1);
- Optional<FileCheckNumericVariable *> DefinedNumericVariable;
- Expected<std::unique_ptr<FileCheckExpressionAST>> ExpressionAST =
+ Pattern P(Check::CheckPlain, &Cxt, 1);
+ Optional<NumericVariable *> DefinedNumericVariable;
+ Expected<std::unique_ptr<ExpressionAST>> ExpressionASTPointer =
P.parseNumericSubstitutionBlock(LocalNumVar1Ref, DefinedNumericVariable,
/*IsLegacyLineExpr=*/false,
/*LineNumber=*/1, &Cxt, SM);
@@ -524,16 +522,16 @@ TEST_F(FileCheckTest, FileCheckContext) {
EXPECT_EQ(*LocalVar, "FOO");
Expected<StringRef> EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
Expected<StringRef> UnknownVar = Cxt.getPatternVarValue(UnknownVarStr);
- ASSERT_TRUE(bool(ExpressionAST));
- Expected<uint64_t> ExpressionVal = (*ExpressionAST)->eval();
+ ASSERT_TRUE(bool(ExpressionASTPointer));
+ Expected<uint64_t> ExpressionVal = (*ExpressionASTPointer)->eval();
ASSERT_TRUE(bool(ExpressionVal));
EXPECT_EQ(*ExpressionVal, 18U);
- ExpressionAST =
+ ExpressionASTPointer =
P.parseNumericSubstitutionBlock(LocalNumVar2Ref, DefinedNumericVariable,
/*IsLegacyLineExpr=*/false,
/*LineNumber=*/1, &Cxt, SM);
- ASSERT_TRUE(bool(ExpressionAST));
- ExpressionVal = (*ExpressionAST)->eval();
+ ASSERT_TRUE(bool(ExpressionASTPointer));
+ ExpressionVal = (*ExpressionASTPointer)->eval();
ASSERT_TRUE(bool(ExpressionVal));
EXPECT_EQ(*ExpressionVal, 20U);
ASSERT_TRUE(bool(EmptyVar));
@@ -548,19 +546,19 @@ TEST_F(FileCheckTest, FileCheckContext) {
// 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((*ExpressionAST)->eval().takeError()));
- P = FileCheckPattern(Check::CheckPlain, &Cxt, 2);
- ExpressionAST = P.parseNumericSubstitutionBlock(
+ EXPECT_TRUE(errorToBool((*ExpressionASTPointer)->eval().takeError()));
+ P = Pattern(Check::CheckPlain, &Cxt, 2);
+ ExpressionASTPointer = P.parseNumericSubstitutionBlock(
LocalNumVar1Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
/*LineNumber=*/2, &Cxt, SM);
- ASSERT_TRUE(bool(ExpressionAST));
- ExpressionVal = (*ExpressionAST)->eval();
+ ASSERT_TRUE(bool(ExpressionASTPointer));
+ ExpressionVal = (*ExpressionASTPointer)->eval();
EXPECT_TRUE(errorToBool(ExpressionVal.takeError()));
- ExpressionAST = P.parseNumericSubstitutionBlock(
+ ExpressionASTPointer = P.parseNumericSubstitutionBlock(
LocalNumVar2Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
/*LineNumber=*/2, &Cxt, SM);
- ASSERT_TRUE(bool(ExpressionAST));
- ExpressionVal = (*ExpressionAST)->eval();
+ ASSERT_TRUE(bool(ExpressionASTPointer));
+ ExpressionVal = (*ExpressionASTPointer)->eval();
EXPECT_TRUE(errorToBool(ExpressionVal.takeError()));
EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
EXPECT_TRUE(errorToBool(EmptyVar.takeError()));
@@ -577,24 +575,24 @@ TEST_F(FileCheckTest, FileCheckContext) {
Expected<StringRef> GlobalVar = Cxt.getPatternVarValue(GlobalVarStr);
ASSERT_TRUE(bool(GlobalVar));
EXPECT_EQ(*GlobalVar, "BAR");
- P = FileCheckPattern(Check::CheckPlain, &Cxt, 3);
- ExpressionAST = P.parseNumericSubstitutionBlock(
+ P = Pattern(Check::CheckPlain, &Cxt, 3);
+ ExpressionASTPointer = P.parseNumericSubstitutionBlock(
GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
/*LineNumber=*/3, &Cxt, SM);
- ASSERT_TRUE(bool(ExpressionAST));
- ExpressionVal = (*ExpressionAST)->eval();
+ ASSERT_TRUE(bool(ExpressionASTPointer));
+ ExpressionVal = (*ExpressionASTPointer)->eval();
ASSERT_TRUE(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);
- ExpressionAST = P.parseNumericSubstitutionBlock(
+ P = Pattern(Check::CheckPlain, &Cxt, 4);
+ ExpressionASTPointer = P.parseNumericSubstitutionBlock(
GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
/*LineNumber=*/4, &Cxt, SM);
- ASSERT_TRUE(bool(ExpressionAST));
- ExpressionVal = (*ExpressionAST)->eval();
+ ASSERT_TRUE(bool(ExpressionASTPointer));
+ ExpressionVal = (*ExpressionASTPointer)->eval();
ASSERT_TRUE(bool(ExpressionVal));
EXPECT_EQ(*ExpressionVal, 36U);
}
generated by cgit v1.1 at 2025-08-04 13:07:40 +0000