From e35f161cfdf0f0e594dd0e99685db15bcee6720b Mon Sep 17 00:00:00 2001 From: Thomas Preud'homme Date: Tue, 23 Jul 2019 22:41:51 +0000 Subject: [PATCH] [FileCheck] Use ASSERT for fatal unit tests Summary: A number of EXPECT statements in FileCheck's unit tests are dependent from results of other values being tested. This commit changes those earlier test to use ASSERT instead of EXPECT to avoid cascade errors when they are all related to the same issue. 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/D64921 llvm-svn: 366862 --- unittests/Support/FileCheckTest.cpp | 88 +++++++++++++++-------------- 1 file changed, 45 insertions(+), 43 deletions(-) diff --git a/unittests/Support/FileCheckTest.cpp b/unittests/Support/FileCheckTest.cpp index 147ed68e223..d85690d633b 100644 --- a/unittests/Support/FileCheckTest.cpp +++ b/unittests/Support/FileCheckTest.cpp @@ -19,13 +19,13 @@ TEST_F(FileCheckTest, Literal) { // Eval returns the literal's value. FileCheckExpressionLiteral Ten(10); Expected Value = Ten.eval(); - EXPECT_TRUE(bool(Value)); + ASSERT_TRUE(bool(Value)); EXPECT_EQ(10U, *Value); // Max value can be correctly represented. FileCheckExpressionLiteral Max(std::numeric_limits::max()); Value = Max.eval(); - EXPECT_TRUE(bool(Value)); + ASSERT_TRUE(bool(Value)); EXPECT_EQ(std::numeric_limits::max(), *Value); } @@ -68,7 +68,7 @@ TEST_F(FileCheckTest, NumericVariable) { FileCheckNumericVariableUse("FOO", &FooVar); EXPECT_FALSE(FooVar.getValue()); Expected EvalResult = FooVarUse.eval(); - EXPECT_FALSE(EvalResult); + ASSERT_FALSE(EvalResult); expectUndefError("FOO", EvalResult.takeError()); FooVar.setValue(42); @@ -77,10 +77,10 @@ TEST_F(FileCheckTest, NumericVariable) { // return value set. EXPECT_TRUE(FooVar.isValueKnownAtMatchTime()); Optional Value = FooVar.getValue(); - EXPECT_TRUE(bool(Value)); + ASSERT_TRUE(bool(Value)); EXPECT_EQ(42U, *Value); EvalResult = FooVarUse.eval(); - EXPECT_TRUE(bool(EvalResult)); + ASSERT_TRUE(bool(EvalResult)); EXPECT_EQ(42U, *EvalResult); // Variable defined by numeric expression: isValueKnownAtMatchTime @@ -95,11 +95,11 @@ TEST_F(FileCheckTest, NumericVariable) { FileCheckNumericVariable FoobarExprVar = FileCheckNumericVariable("FOOBAR", 2, &Binop); EXPECT_TRUE(FoobarExprVar.isValueKnownAtMatchTime()); - EXPECT_FALSE(FoobarExprVar.getValue()); + ASSERT_FALSE(FoobarExprVar.getValue()); FileCheckNumericVariableUse FoobarExprVarUse = FileCheckNumericVariableUse("FOOBAR", &FoobarExprVar); EvalResult = FoobarExprVarUse.eval(); - EXPECT_TRUE(bool(EvalResult)); + ASSERT_TRUE(bool(EvalResult)); EXPECT_EQ(43U, *EvalResult); EXPECT_TRUE(FoobarExprVar.getExpressionAST()); FoobarExprVar.setValue(43); @@ -115,10 +115,10 @@ TEST_F(FileCheckTest, NumericVariable) { EXPECT_FALSE(FooVar.getValue()); EXPECT_FALSE(FoobarExprVar.getValue()); EvalResult = FooVarUse.eval(); - EXPECT_FALSE(EvalResult); + ASSERT_FALSE(EvalResult); expectUndefError("FOO", EvalResult.takeError()); EvalResult = FoobarExprVarUse.eval(); - EXPECT_FALSE(EvalResult); + ASSERT_FALSE(EvalResult); expectUndefError("FOOBAR", EvalResult.takeError()); } @@ -136,21 +136,21 @@ TEST_F(FileCheckTest, Binop) { // Defined variable: eval returns right value. Expected Value = Binop.eval(); - EXPECT_TRUE(bool(Value)); + ASSERT_TRUE(bool(Value)); EXPECT_EQ(60U, *Value); // 1 undefined variable: eval fails, error contains name of undefined // variable. FooVar.clearValue(); Value = Binop.eval(); - EXPECT_FALSE(Value); + ASSERT_FALSE(Value); expectUndefError("FOO", Value.takeError()); // 2 undefined variables: eval fails, error contains names of all undefined // variables. BarVar.clearValue(); Value = Binop.eval(); - EXPECT_FALSE(Value); + ASSERT_FALSE(Value); expectUndefErrors({"FOO", "BAR"}, Value.takeError()); } @@ -180,21 +180,21 @@ TEST_F(FileCheckTest, ParseVar) { StringRef VarName = OrigVarName; Expected ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM); - EXPECT_TRUE(bool(ParsedVarResult)); + 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); - EXPECT_TRUE(bool(ParsedVarResult)); + 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); - EXPECT_TRUE(bool(ParsedVarResult)); + ASSERT_TRUE(bool(ParsedVarResult)); EXPECT_EQ(ParsedVarResult->Name, OrigVarName); EXPECT_TRUE(VarName.empty()); EXPECT_TRUE(ParsedVarResult->IsPseudo); @@ -209,35 +209,35 @@ TEST_F(FileCheckTest, ParseVar) { VarName = OrigVarName = bufferize(SM, "B@dVar"); ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM); - EXPECT_TRUE(bool(ParsedVarResult)); + 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); - EXPECT_TRUE(bool(ParsedVarResult)); + 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); - EXPECT_TRUE(bool(ParsedVarResult)); + 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); - EXPECT_TRUE(bool(ParsedVarResult)); + 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); - EXPECT_TRUE(bool(ParsedVarResult)); + ASSERT_TRUE(bool(ParsedVarResult)); EXPECT_EQ(VarName, ":"); EXPECT_EQ(ParsedVarResult->Name, "BadVar"); EXPECT_FALSE(ParsedVarResult->IsPseudo); @@ -257,6 +257,8 @@ public: std::vector GlobalDefines; GlobalDefines.emplace_back(std::string("#FOO=42")); GlobalDefines.emplace_back(std::string("BAR=BAZ")); + // An ASSERT_FALSE would make more sense but cannot be used in a + // constructor. EXPECT_FALSE( errorToBool(Context.defineCmdlineVariables(GlobalDefines, SM))); Context.createLineVariable(); @@ -334,13 +336,13 @@ TEST_F(FileCheckTest, ParseExpr) { // the same pattern object is used for the parsePatternExpect and // parseSubstExpect since no initNextPattern is called, thus appearing as // being on the same line from the pattern's point of view. - EXPECT_FALSE(Tester.parsePatternExpect("[[#LINE1VAR:FOO+1]]")); + ASSERT_FALSE(Tester.parsePatternExpect("[[#LINE1VAR:FOO+1]]")); EXPECT_FALSE(Tester.parseSubstExpect("LINE1VAR")); // Invalid use of variable defined on same line from input. As above, the // absence of a call to initNextPattern makes it appear to be on the same // line from the pattern's point of view. - EXPECT_FALSE(Tester.parsePatternExpect("[[#LINE2VAR:]]")); + ASSERT_FALSE(Tester.parsePatternExpect("[[#LINE2VAR:]]")); EXPECT_TRUE(Tester.parseSubstExpect("LINE2VAR")); // Unsupported operator. @@ -441,7 +443,7 @@ TEST_F(FileCheckTest, Substitution) { FileCheckStringSubstitution StringSubstitution = FileCheckStringSubstitution(&Context, "VAR404", 42); Expected SubstValue = StringSubstitution.getResult(); - EXPECT_FALSE(bool(SubstValue)); + ASSERT_FALSE(bool(SubstValue)); expectUndefError("VAR404", SubstValue.takeError()); // Substitutions of defined pseudo and non-pseudo numeric variables return @@ -458,28 +460,28 @@ TEST_F(FileCheckTest, Substitution) { FileCheckNumericSubstitution SubstitutionN = FileCheckNumericSubstitution(&Context, "N", std::move(NVarUse), 30); SubstValue = SubstitutionLine.getResult(); - EXPECT_TRUE(bool(SubstValue)); + ASSERT_TRUE(bool(SubstValue)); EXPECT_EQ("42", *SubstValue); SubstValue = SubstitutionN.getResult(); - EXPECT_TRUE(bool(SubstValue)); + ASSERT_TRUE(bool(SubstValue)); EXPECT_EQ("10", *SubstValue); // Substitution of an undefined numeric variable fails, error holds name of // undefined variable. LineVar.clearValue(); SubstValue = SubstitutionLine.getResult(); - EXPECT_FALSE(bool(SubstValue)); + ASSERT_FALSE(bool(SubstValue)); expectUndefError("@LINE", SubstValue.takeError()); NVar.clearValue(); SubstValue = SubstitutionN.getResult(); - EXPECT_FALSE(bool(SubstValue)); + ASSERT_FALSE(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); SubstValue = StringSubstitution.getResult(); - EXPECT_TRUE(bool(SubstValue)); + ASSERT_TRUE(bool(SubstValue)); EXPECT_EQ("BAR", *SubstValue); } @@ -538,7 +540,7 @@ TEST_F(FileCheckTest, FileCheckContext) { GlobalDefines.emplace_back(std::string("EmptyVar=")); GlobalDefines.emplace_back(std::string("#LocalNumVar1=18")); GlobalDefines.emplace_back(std::string("#LocalNumVar2=LocalNumVar1+2")); - EXPECT_FALSE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM))); + ASSERT_FALSE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM))); // Check defined variables are present and undefined is absent. StringRef LocalVarStr = "LocalVar"; @@ -553,23 +555,23 @@ TEST_F(FileCheckTest, FileCheckContext) { P.parseNumericSubstitutionBlock(LocalNumVar1Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false, /*LineNumber=*/1, &Cxt, SM); - EXPECT_TRUE(bool(LocalVar)); + ASSERT_TRUE(bool(LocalVar)); EXPECT_EQ(*LocalVar, "FOO"); Expected EmptyVar = Cxt.getPatternVarValue(EmptyVarStr); Expected UnknownVar = Cxt.getPatternVarValue(UnknownVarStr); - EXPECT_TRUE(bool(ExpressionAST)); + ASSERT_TRUE(bool(ExpressionAST)); Expected ExpressionVal = (*ExpressionAST)->eval(); - EXPECT_TRUE(bool(ExpressionVal)); + ASSERT_TRUE(bool(ExpressionVal)); EXPECT_EQ(*ExpressionVal, 18U); ExpressionAST = P.parseNumericSubstitutionBlock(LocalNumVar2Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false, /*LineNumber=*/1, &Cxt, SM); - EXPECT_TRUE(bool(ExpressionAST)); + ASSERT_TRUE(bool(ExpressionAST)); ExpressionVal = (*ExpressionAST)->eval(); - EXPECT_TRUE(bool(ExpressionVal)); + ASSERT_TRUE(bool(ExpressionVal)); EXPECT_EQ(*ExpressionVal, 20U); - EXPECT_TRUE(bool(EmptyVar)); + ASSERT_TRUE(bool(EmptyVar)); EXPECT_EQ(*EmptyVar, ""); EXPECT_TRUE(errorToBool(UnknownVar.takeError())); @@ -586,13 +588,13 @@ TEST_F(FileCheckTest, FileCheckContext) { ExpressionAST = P.parseNumericSubstitutionBlock( LocalNumVar1Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false, /*LineNumber=*/2, &Cxt, SM); - EXPECT_TRUE(bool(ExpressionAST)); + ASSERT_TRUE(bool(ExpressionAST)); ExpressionVal = (*ExpressionAST)->eval(); EXPECT_TRUE(errorToBool(ExpressionVal.takeError())); ExpressionAST = P.parseNumericSubstitutionBlock( LocalNumVar2Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false, /*LineNumber=*/2, &Cxt, SM); - EXPECT_TRUE(bool(ExpressionAST)); + ASSERT_TRUE(bool(ExpressionAST)); ExpressionVal = (*ExpressionAST)->eval(); EXPECT_TRUE(errorToBool(ExpressionVal.takeError())); EmptyVar = Cxt.getPatternVarValue(EmptyVarStr); @@ -604,19 +606,19 @@ TEST_F(FileCheckTest, FileCheckContext) { // 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))); + ASSERT_FALSE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM))); StringRef GlobalVarStr = "$GlobalVar"; StringRef GlobalNumVarRef = bufferize(SM, "$GlobalNumVar"); Expected GlobalVar = Cxt.getPatternVarValue(GlobalVarStr); - EXPECT_TRUE(bool(GlobalVar)); + ASSERT_TRUE(bool(GlobalVar)); EXPECT_EQ(*GlobalVar, "BAR"); P = FileCheckPattern(Check::CheckPlain, &Cxt, 3); ExpressionAST = P.parseNumericSubstitutionBlock( GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false, /*LineNumber=*/3, &Cxt, SM); - EXPECT_TRUE(bool(ExpressionAST)); + ASSERT_TRUE(bool(ExpressionAST)); ExpressionVal = (*ExpressionAST)->eval(); - EXPECT_TRUE(bool(ExpressionVal)); + ASSERT_TRUE(bool(ExpressionVal)); EXPECT_EQ(*ExpressionVal, 36U); // Clear local variables and check global variables remain defined. @@ -626,9 +628,9 @@ TEST_F(FileCheckTest, FileCheckContext) { ExpressionAST = P.parseNumericSubstitutionBlock( GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false, /*LineNumber=*/4, &Cxt, SM); - EXPECT_TRUE(bool(ExpressionAST)); + ASSERT_TRUE(bool(ExpressionAST)); ExpressionVal = (*ExpressionAST)->eval(); - EXPECT_TRUE(bool(ExpressionVal)); + ASSERT_TRUE(bool(ExpressionVal)); EXPECT_EQ(*ExpressionVal, 36U); } } // namespace