reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

tools/clang/tools/extra/clangd/unittests/BackgroundIndexTests.cpp
  104   ASSERT_TRUE(Idx.blockUntilIdleForTest());
  144   ASSERT_TRUE(Idx.blockUntilIdleForTest());
  156   ASSERT_TRUE(Idx.blockUntilIdleForTest());
  205     ASSERT_TRUE(Idx.blockUntilIdleForTest());
  215     ASSERT_TRUE(Idx.blockUntilIdleForTest());
  273     ASSERT_TRUE(Idx.blockUntilIdleForTest());
  323     ASSERT_TRUE(Idx.blockUntilIdleForTest());
  338     ASSERT_TRUE(Idx.blockUntilIdleForTest());
  356     ASSERT_TRUE(Idx.blockUntilIdleForTest());
  397     ASSERT_TRUE(Idx.blockUntilIdleForTest());
  413     ASSERT_TRUE(Idx.blockUntilIdleForTest());
  429     ASSERT_TRUE(Idx.blockUntilIdleForTest());
  460   ASSERT_TRUE(Idx.blockUntilIdleForTest());
  491   ASSERT_TRUE(Idx.blockUntilIdleForTest());
  547   ASSERT_TRUE(Idx.blockUntilIdleForTest());
  563   ASSERT_TRUE(Idx.blockUntilIdleForTest());
tools/clang/tools/extra/clangd/unittests/ClangdTests.cpp
  213   ASSERT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
  218   ASSERT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
  223   ASSERT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
  249   ASSERT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
  255   ASSERT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
  261   ASSERT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
  292   ASSERT_TRUE(Server.blockUntilIdleForTest());
  409   ASSERT_TRUE(Server.blockUntilIdleForTest());
  455   ASSERT_TRUE(Server.blockUntilIdleForTest());
  471   ASSERT_TRUE(Server.blockUntilIdleForTest());
  502   ASSERT_TRUE(Server.blockUntilIdleForTest());
  508   ASSERT_TRUE(Server.blockUntilIdleForTest());
  512   ASSERT_TRUE(Server.blockUntilIdleForTest());
  543   ASSERT_TRUE(bool(SigHelp)) << "signatureHelp returned an error";
  599       ASSERT_TRUE(FileIndexStr.consume_front("Foo"));
  728       ASSERT_TRUE(!!runLocateSymbolAt(Server, FilePaths[FileIndex], Pos));
  752     ASSERT_TRUE(Server.blockUntilIdleForTest());
  779       ASSERT_TRUE(Lock.owns_lock())
  825   ASSERT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
 1005   ASSERT_TRUE(Server.blockUntilIdleForTest());
 1016   ASSERT_TRUE(Server.blockUntilIdleForTest());
 1080   ASSERT_TRUE(Server.blockUntilIdleForTest());
tools/clang/tools/extra/clangd/unittests/CodeCompleteTests.cpp
  808   ASSERT_TRUE(Server.blockUntilIdleForTest());
 1476   ASSERT_TRUE(Server.blockUntilIdleForTest());
 1984   ASSERT_TRUE(Server.blockUntilIdleForTest());
tools/clang/tools/extra/clangd/unittests/DraftStoreTests.cpp
   52     ASSERT_TRUE(!!Result);
   82   ASSERT_TRUE(!!Result) << llvm::toString(Result.takeError());
tools/clang/tools/extra/clangd/unittests/FileIndexTests.cpp
  298   ASSERT_TRUE(IndexUpdated);
tools/clang/tools/extra/clangd/unittests/IndexActionTests.cpp
   49   ASSERT_TRUE(IndexFile.Sources);
  248   ASSERT_TRUE(IndexFile.Sources);
tools/clang/tools/extra/clangd/unittests/RIFFTests.cpp
   31   ASSERT_TRUE(bool(Parsed)) << Parsed.takeError();
tools/clang/tools/extra/clangd/unittests/RenameTests.cpp
   84     ASSERT_TRUE(bool(RenameResult)) << RenameResult.takeError();
   87     ASSERT_TRUE(bool(ApplyResult)) << ApplyResult.takeError();
tools/clang/tools/extra/clangd/unittests/SemanticHighlightingTests.cpp
  637   ASSERT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for server";
tools/clang/tools/extra/clangd/unittests/SemanticSelectionTests.cpp
  175   ASSERT_TRUE(bool(Ranges))
tools/clang/tools/extra/clangd/unittests/SerializationTests.cpp
  111   ASSERT_TRUE(bool(ParsedYAML)) << ParsedYAML.takeError();
  112   ASSERT_TRUE(bool(ParsedYAML->Symbols));
  143   ASSERT_TRUE(bool(ParsedYAML->Refs));
  154   ASSERT_TRUE(bool(ParsedYAML->Relations));
  190   ASSERT_TRUE(bool(In2)) << In.takeError();
  191   ASSERT_TRUE(In2->Symbols);
  192   ASSERT_TRUE(In2->Refs);
  193   ASSERT_TRUE(In2->Relations);
  225     ASSERT_TRUE(bool(In)) << In.takeError();
  226     ASSERT_TRUE(In->Symbols);
  227     ASSERT_TRUE(In->Refs);
  228     ASSERT_TRUE(In->Sources);
  229     ASSERT_TRUE(In->Sources->count(IGN.URI));
  262     ASSERT_TRUE(bool(In)) << In.takeError();
  263     ASSERT_TRUE(In->Cmd);
tools/clang/tools/extra/clangd/unittests/SourceCodeTests.cpp
  488   ASSERT_TRUE(Result);
  594   ASSERT_TRUE(Range) << "Failed to get file range";
tools/clang/tools/extra/clangd/unittests/TUSchedulerTests.cpp
  205     ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  231     ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  274                         ASSERT_TRUE(bool(Pre));
  283                         ASSERT_TRUE(bool(Pre));
  352     ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  425                 ASSERT_TRUE((bool)AST);
  443                 ASSERT_TRUE((bool)Preamble);
  453     ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  489   ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  498   ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  507   ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  543   ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  548   ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  586   ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  624   ASSERT_TRUE(DoUpdate(SourceContents));
  629   ASSERT_TRUE(DoUpdate(SourceContents));
  637   ASSERT_TRUE(DoUpdate(OtherSourceContents));
  642   ASSERT_TRUE(DoUpdate(OtherSourceContents));
  663   ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  670   ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  671   ASSERT_TRUE(SeenDiags);
  678   ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  689   ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
  732                           ASSERT_TRUE((bool)Result);
  735   ASSERT_TRUE(Server.blockUntilIdleForTest());
tools/clang/tools/extra/clangd/unittests/TypeHierarchyTests.cpp
   72   ASSERT_TRUE(AST.getDiagnostics().empty());
   96   ASSERT_TRUE(AST.getDiagnostics().empty());
  119   ASSERT_TRUE(AST.getDiagnostics().empty());
  148   ASSERT_TRUE(AST.getDiagnostics().empty());
  184   ASSERT_TRUE(AST.getDiagnostics().empty());
  211   ASSERT_TRUE(AST.getDiagnostics().empty());
  261   ASSERT_TRUE(AST.getDiagnostics().empty());
  290   ASSERT_TRUE(AST.getDiagnostics().empty());
  321   ASSERT_TRUE(AST.getDiagnostics().empty());
  376     ASSERT_TRUE(bool(Result));
  407   ASSERT_TRUE(!AST.getDiagnostics().empty());
  415   ASSERT_TRUE(bool(Result));
  441   ASSERT_TRUE(AST.getDiagnostics().empty());
  447   ASSERT_TRUE(bool(Result));
  455   ASSERT_TRUE(bool(Result));
  630   ASSERT_TRUE(bool(Result));
tools/clang/tools/extra/clangd/unittests/XRefsTests.cpp
 1013     ASSERT_TRUE(AST.getDiagnostics().empty());
 1016     ASSERT_TRUE(H);
 1884   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
 1889   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
 1893   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
 1898   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
 1903   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
 1907   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
 1911   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
 1923   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
 2200     ASSERT_TRUE(AST.getDiagnostics().empty())
 2206       ASSERT_TRUE(!!Location) << llvm::toString(Location.takeError());
 2270     ASSERT_TRUE(AST.getDiagnostics().empty())
tools/clang/tools/extra/unittests/clang-query/QueryParserTest.cpp
   36   ASSERT_TRUE(isa<InvalidQuery>(Q));
   42   ASSERT_TRUE(isa<HelpQuery>(Q));
   45   ASSERT_TRUE(isa<InvalidQuery>(Q));
   51   ASSERT_TRUE(isa<QuitQuery>(Q));
   54   ASSERT_TRUE(isa<QuitQuery>(Q));
   57   ASSERT_TRUE(isa<InvalidQuery>(Q));
   63   ASSERT_TRUE(isa<InvalidQuery>(Q));
   67   ASSERT_TRUE(isa<InvalidQuery>(Q));
   71   ASSERT_TRUE(isa<InvalidQuery>(Q));
   76   ASSERT_TRUE(isa<InvalidQuery>(Q));
   80   ASSERT_TRUE(isa<InvalidQuery>(Q));
   85   ASSERT_TRUE(isa<SetExclusiveOutputQuery >(Q));
   89   ASSERT_TRUE(isa<SetExclusiveOutputQuery>(Q));
   93   ASSERT_TRUE(isa<EnableOutputQuery>(Q));
   97   ASSERT_TRUE(isa<InvalidQuery>(Q));
  101   ASSERT_TRUE(isa<DisableOutputQuery>(Q));
  105   ASSERT_TRUE(isa<InvalidQuery>(Q));
  110   ASSERT_TRUE(isa<SetQuery<bool> >(Q));
  117   ASSERT_TRUE(isa<MatchQuery>(Q));
  121   ASSERT_TRUE(isa<MatchQuery>(Q));
  127   ASSERT_TRUE(isa<LetQuery>(Q));
  133   ASSERT_TRUE(isa<LetQuery>(Q));
  139   ASSERT_TRUE(isa<LetQuery>(Q));
  145   ASSERT_TRUE(isa<InvalidQuery>(Q));
  149   ASSERT_TRUE(isa<LetQuery>(Q));
  154   ASSERT_TRUE(isa<InvalidQuery>(Q));
  158   ASSERT_TRUE(isa<InvalidQuery>(Q));
  165   ASSERT_TRUE(isa<NoOpQuery>(Q));
  168   ASSERT_TRUE(isa<LetQuery>(Q));
  171   ASSERT_TRUE(isa<SetQuery<bool>>(Q));
tools/clang/tools/extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp
   78   ASSERT_TRUE(!!Options1);
   87   ASSERT_TRUE(!!Options2);
   92   ASSERT_TRUE(Options.ExtraArgs.hasValue());
   95   ASSERT_TRUE(Options.ExtraArgsBefore.hasValue());
tools/clang/unittests/AST/ASTImporterGenericRedeclTest.cpp
  127       ASSERT_TRUE(PrevT->getTemplatedDecl());
  128       ASSERT_TRUE(CurrentT->getTemplatedDecl());
  178     ASSERT_TRUE(FromD->isThisDeclarationADefinition());
  218     ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
  239     ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
  285     ASSERT_TRUE(From0->isThisDeclarationADefinition());
  286     ASSERT_TRUE(From1->isThisDeclarationADefinition());
  308     ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
  333     ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
  356     ASSERT_TRUE(FromD->isThisDeclarationADefinition());
tools/clang/unittests/AST/ASTImporterODRStrategiesTest.cpp
  267     ASSERT_TRUE(isSuccess(Result));
  269     ASSERT_TRUE(ImportedD);
  292     ASSERT_TRUE(isSuccess(Result));
tools/clang/unittests/AST/ASTImporterTest.cpp
  964   ASSERT_TRUE(FromVar);
  977   ASSERT_TRUE(From);
  989   ASSERT_TRUE(From);
  991   ASSERT_TRUE(To);
 1006   ASSERT_TRUE(From);
 1155   ASSERT_TRUE(From);
 1156   ASSERT_TRUE(
 1162   ASSERT_TRUE(To);
 1163   ASSERT_TRUE(
 1175   ASSERT_TRUE(From);
 1177   ASSERT_TRUE(To);
 1189   ASSERT_TRUE(From);
 1191   ASSERT_TRUE(To);
 1203   ASSERT_TRUE(FromFT);
 1219   ASSERT_TRUE(FromFT);
 1243   ASSERT_TRUE(ToNs);
 1252   ASSERT_TRUE(From);
 1253   ASSERT_TRUE(To);
 1274   ASSERT_TRUE(FromChooseExpr);
 1277   ASSERT_TRUE(ToChooseExpr);
 1308   ASSERT_TRUE(Verifier.match(From, Matcher));
 1334   ASSERT_TRUE(Check(From));
 1360   ASSERT_TRUE(Check(From));
 1388   ASSERT_TRUE(Check(From));
 1407   ASSERT_TRUE(
 1416   ASSERT_TRUE(
 1454   ASSERT_TRUE(MatchVerifier<Decl>{}.match(From, Pattern));
 1460   ASSERT_TRUE(MatchVerifier<Decl>{}.match(From, Pattern));
 1473   ASSERT_TRUE(Verifier.match(From, cxxRecordDecl(hasFieldOrder({"a", "b"}))));
 1493   ASSERT_TRUE(
 1518   ASSERT_TRUE(Verifier.match(
 1536   ASSERT_TRUE(Verifier.match(From, Matcher));
 1554   ASSERT_TRUE(Verifier.match(From, Matcher));
 1573   ASSERT_TRUE(
 1586   ASSERT_TRUE(Verifier.match(From, Matcher));
 1617   ASSERT_TRUE(
 1983     ASSERT_TRUE(FromD->isUsed(false));
 2075   ASSERT_TRUE(Proto->isVirtual());
 2076   ASSERT_TRUE(Def->isVirtual());
 2303     ASSERT_TRUE(To1);
 2322   ASSERT_TRUE(ToF1);
 2681   ASSERT_TRUE(FromD->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
 2725   ASSERT_TRUE(FromFriend->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
 2728   ASSERT_TRUE(FromNormal->isInIdentifierNamespace(Decl::IDNS_Ordinary));
 2771   ASSERT_TRUE(FromNormal->isInIdentifierNamespace(Decl::IDNS_Ordinary));
 2772   ASSERT_TRUE(FromFriend->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
 2773   ASSERT_TRUE(FromFriend->isInIdentifierNamespace(Decl::IDNS_Ordinary));
 2816   ASSERT_TRUE(FromNormalF->isInIdentifierNamespace(Decl::IDNS_Ordinary));
 2819   ASSERT_TRUE(FromFriendF->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
 3316   ASSERT_TRUE(ToField);
 3329   ASSERT_TRUE(FromField);
 3330   ASSERT_TRUE(FromField->getInClassInitializer());
 3333   ASSERT_TRUE(ImportedSpec);
 3372   ASSERT_TRUE(FromFun->hasBody());
 3375   ASSERT_TRUE(ImportedSpec);
 3459   ASSERT_TRUE(FromCtor->hasBody());
 3462   ASSERT_TRUE(ImportedSpec);
 3562   ASSERT_TRUE(FromD->getAnyInitializer());
 3564   ASSERT_TRUE(InitExpr);
 3565   ASSERT_TRUE(InitExpr->isGLValue());
 3594   ASSERT_TRUE(ToD0);
 3595   ASSERT_TRUE(ToD1);
 3616   ASSERT_TRUE(FromDWithInit->getInit());
 3618   ASSERT_TRUE(FromDWithDef->isThisDeclarationADefinition());
 3623   ASSERT_TRUE(ToD->getInit());
 3649   ASSERT_TRUE(FromDWithDef->isThisDeclarationADefinition());
 3650   ASSERT_TRUE(FromDWithDef->getInit());
 3742   ASSERT_TRUE(FromClass);
 3743   ASSERT_TRUE(FromFriendClass);
 3775   ASSERT_TRUE(MatchVerifier<Decl>{}.match(FromD, Pattern));
 3794   ASSERT_TRUE(MatchVerifier<Decl>{}.match(FromD, Pattern));
 3832   ASSERT_TRUE(Imported2->getPreviousDecl());
 4004   ASSERT_TRUE(NS->containsDecl(Spec));
 4018   ASSERT_TRUE(DC->containsDecl(A0));
 4019   ASSERT_TRUE(DC->containsDecl(A1));
 4023   ASSERT_TRUE(Map);
 4031   ASSERT_TRUE(L.getAsDecl());
 4036   ASSERT_TRUE(L.getAsVector());
 4061   ASSERT_TRUE(MatchVerifier<Decl>{}.match(FromTU, Pattern));
 4065   ASSERT_TRUE(Import(Foo, Lang_CXX));
 4085   ASSERT_TRUE(MatchVerifier<Decl>{}.match(FromTU, Pattern));
 4087   ASSERT_TRUE(
 4109   ASSERT_TRUE(MatchVerifier<Decl>{}.match(FromTU, Pattern));
 4111   ASSERT_TRUE(
 4139     ASSERT_TRUE(SpecD->getPreviousDecl());
 4144   ASSERT_TRUE(Import(FromSpecD, Lang_CXX));
 4153     ASSERT_TRUE(SpecD->getPreviousDecl());
 4235   ASSERT_TRUE(ToD->getUnderlyingType()->isIncompleteType());
 4658   ASSERT_TRUE(FieldInSpec);
 4813   ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
 4905   ASSERT_TRUE(OptErr);
 4930   ASSERT_TRUE(OptErr);
 4964   ASSERT_TRUE(OptErr);
 4967   ASSERT_TRUE(OptErr);
 4990   ASSERT_TRUE(OptErr);
 4997   ASSERT_TRUE(OptErr);
 5122   ASSERT_TRUE(OptErr);
 5162     ASSERT_TRUE(OptErr);
 5171   ASSERT_TRUE(OptErr);
 5206     ASSERT_TRUE(OptErr);
 5245     ASSERT_TRUE(OptErr);
 5331   ASSERT_TRUE(ToClassDef->isThisDeclarationADefinition());
 5342   ASSERT_TRUE(FromClassDef->isThisDeclarationADefinition());
 5451   ASSERT_TRUE(ToD1);
 5454   ASSERT_TRUE(ToD2);
 5474   ASSERT_TRUE(ImportedX);
tools/clang/unittests/AST/ASTImporterVisibilityTest.cpp
  111     ASSERT_TRUE(ToD1);
  200     ASSERT_TRUE(ToD0);
  201     ASSERT_TRUE(ToD1);
  219     ASSERT_TRUE(ToD0);
  220     ASSERT_TRUE(ToD1);
  238     ASSERT_TRUE(ToF0);
  239     ASSERT_TRUE(ToF1);
  259     ASSERT_TRUE(ToF0);
  260     ASSERT_TRUE(ToF1);
tools/clang/unittests/AST/ASTTraverserTest.cpp
  230   ASSERT_TRUE(TL.getType()->isPointerType());
tools/clang/unittests/AST/ASTVectorTest.cpp
   74   ASSERT_TRUE(V.empty());
tools/clang/unittests/AST/CommentParser.cpp
  599   ASSERT_TRUE(HasChildCount(FC, 0));
  606   ASSERT_TRUE(HasChildCount(FC, 1));
  608   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " Meow"));
  617   ASSERT_TRUE(HasChildCount(FC, 1));
  621     ASSERT_TRUE(GetChildAt(FC, 0, PC));
  623     ASSERT_TRUE(HasChildCount(PC, 2));
  624       ASSERT_TRUE(HasTextWithNewlineAt(PC, 0, " Aaa"));
  625       ASSERT_TRUE(HasTextAt(PC, 1, " Bbb"));
  669     ASSERT_TRUE(HasChildCount(FC, 2));
  671     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " Aaa"));
  672     ASSERT_TRUE(HasParagraphCommentAt(FC, 1, " Bbb"));
  683   ASSERT_TRUE(HasChildCount(FC, 3));
  685   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
  689     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 1, BCC, "brief", PC));
  691     ASSERT_TRUE(HasParagraphCommentAt(BCC, 0, " Aaa"));
  693   ASSERT_TRUE(HasParagraphCommentAt(FC, 2, " Bbb"));
  700   ASSERT_TRUE(HasChildCount(FC, 3));
  702   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
  706     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 1, BCC, "brief", PC));
  708     ASSERT_TRUE(HasParagraphCommentAt(BCC, 0, " "));
  713     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 2, BCC, "author", PC));
  715     ASSERT_TRUE(GetChildAt(BCC, 0, PC));
  716       ASSERT_TRUE(HasChildCount(PC, 0));
  727   ASSERT_TRUE(HasChildCount(FC, 3));
  729   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
  733     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 1, BCC, "brief", PC));
  735     ASSERT_TRUE(GetChildAt(BCC, 0, PC));
  736       ASSERT_TRUE(HasChildCount(PC, 2));
  737       ASSERT_TRUE(HasTextWithNewlineAt(PC, 0, " Aaa"));
  738       ASSERT_TRUE(HasTextAt(PC, 1, " Bbb "));
  743     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 2, BCC, "author", PC));
  745     ASSERT_TRUE(HasParagraphCommentAt(BCC, 0, " Ccc"));
  753   ASSERT_TRUE(HasChildCount(FC, 2));
  755   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
  759     ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
  763     ASSERT_TRUE(HasChildCount(PCC, 1));
  764     ASSERT_TRUE(HasChildCount(PC, 0));
  772   ASSERT_TRUE(HasChildCount(FC, 3));
  774   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
  778     ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
  782     ASSERT_TRUE(HasChildCount(PCC, 1));
  783     ASSERT_TRUE(HasChildCount(PC, 0));
  788     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 2, BCC, "brief", PC));
  789     ASSERT_TRUE(HasChildCount(PC, 0));
  806     ASSERT_TRUE(HasChildCount(FC, 2));
  808     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
  812       ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
  816       ASSERT_TRUE(HasChildCount(PCC, 1));
  817       ASSERT_TRUE(HasParagraphCommentAt(PCC, 0, " Bbb"));
  836     ASSERT_TRUE(HasChildCount(FC, 2));
  838     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
  842       ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
  846       ASSERT_TRUE(HasChildCount(PCC, 1));
  847       ASSERT_TRUE(HasParagraphCommentAt(PCC, 0, " Bbb"));
  866     ASSERT_TRUE(HasChildCount(FC, 2));
  868     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
  872       ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
  876       ASSERT_TRUE(HasChildCount(PCC, 1));
  877       ASSERT_TRUE(HasParagraphCommentAt(PCC, 0, " Bbb"));
  897     ASSERT_TRUE(HasChildCount(FC, 2));
  899     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
  903       ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
  907       ASSERT_TRUE(HasChildCount(PCC, 1));
  908       ASSERT_TRUE(HasParagraphCommentAt(PCC, 0, " Bbb"));
  918   ASSERT_TRUE(HasChildCount(FC, 2));
  920   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
  924     ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
  928     ASSERT_TRUE(HasChildCount(PCC, 1));
  930     ASSERT_TRUE(HasChildCount(PC, 5));
  931       ASSERT_TRUE(HasTextAt(PC, 0, " "));
  932       ASSERT_TRUE(HasTextAt(PC, 1, "%"));
  933       ASSERT_TRUE(HasTextAt(PC, 2, " Bbb "));
  934       ASSERT_TRUE(HasTextAt(PC, 3, "$"));
  935       ASSERT_TRUE(HasTextAt(PC, 4, " ccc"));
  952     ASSERT_TRUE(HasChildCount(FC, 2));
  954     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
  958       ASSERT_TRUE(HasTParamCommandAt(FC, Traits, 1, TPCC, "tparam",
  960       ASSERT_TRUE(HasChildCount(TPCC, 1));
  961       ASSERT_TRUE(HasParagraphCommentAt(TPCC, 0, " Bbb"));
  970   ASSERT_TRUE(HasChildCount(FC, 3));
  972   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
  976     ASSERT_TRUE(HasTParamCommandAt(FC, Traits, 1, TPCC, "tparam", "", PC));
  977     ASSERT_TRUE(HasChildCount(TPCC, 1));
  978     ASSERT_TRUE(HasChildCount(PC, 0));
  983     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 2, BCC, "brief", PC));
  984     ASSERT_TRUE(HasChildCount(PC, 0));
  993   ASSERT_TRUE(HasChildCount(FC, 1));
  998     ASSERT_TRUE(GetChildAt(FC, 0, PC));
 1000     ASSERT_TRUE(HasChildCount(PC, 2));
 1001       ASSERT_TRUE(HasTextAt(PC, 0, " "));
 1002       ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "c", NoArgs()));
 1010   ASSERT_TRUE(HasChildCount(FC, 1));
 1015     ASSERT_TRUE(GetChildAt(FC, 0, PC));
 1017     ASSERT_TRUE(HasChildCount(PC, 3));
 1018       ASSERT_TRUE(HasTextAt(PC, 0, " "));
 1019       ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "c", NoArgs()));
 1020       ASSERT_TRUE(HasTextAt(PC, 2, " "));
 1028   ASSERT_TRUE(HasChildCount(FC, 1));
 1033     ASSERT_TRUE(GetChildAt(FC, 0, PC));
 1035     ASSERT_TRUE(HasChildCount(PC, 2));
 1036       ASSERT_TRUE(HasTextAt(PC, 0, " "));
 1037       ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "c", "aaa"));
 1045   ASSERT_TRUE(HasChildCount(FC, 1));
 1050     ASSERT_TRUE(GetChildAt(FC, 0, PC));
 1052     ASSERT_TRUE(HasChildCount(PC, 3));
 1053       ASSERT_TRUE(HasTextAt(PC, 0, " "));
 1054       ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "c", "aaa"));
 1055       ASSERT_TRUE(HasTextAt(PC, 2, " bbb"));
 1063   ASSERT_TRUE(HasChildCount(FC, 1));
 1068     ASSERT_TRUE(GetChildAt(FC, 0, PC));
 1070     ASSERT_TRUE(HasChildCount(PC, 3));
 1071       ASSERT_TRUE(HasTextAt(PC, 0, " "));
 1072       ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "unknown", NoArgs()));
 1073       ASSERT_TRUE(HasTextAt(PC, 2, " aaa"));
 1086     ASSERT_TRUE(HasChildCount(FC, 1));
 1091       ASSERT_TRUE(GetChildAt(FC, 0, PC));
 1093       ASSERT_TRUE(HasChildCount(PC, 2));
 1094         ASSERT_TRUE(HasTextAt(PC, 0, " "));
 1095         ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "a", NoAttrs()));
 1108     ASSERT_TRUE(HasChildCount(FC, 1));
 1113       ASSERT_TRUE(GetChildAt(FC, 0, PC));
 1115       ASSERT_TRUE(HasChildCount(PC, 2));
 1116         ASSERT_TRUE(HasTextAt(PC, 0, " "));
 1117         ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "br", SelfClosing()));
 1132     ASSERT_TRUE(HasChildCount(FC, 1));
 1137       ASSERT_TRUE(GetChildAt(FC, 0, PC));
 1139       ASSERT_TRUE(HasChildCount(PC, 2));
 1140         ASSERT_TRUE(HasTextAt(PC, 0, " "));
 1141         ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "a", "href", ""));
 1154     ASSERT_TRUE(HasChildCount(FC, 1));
 1159       ASSERT_TRUE(GetChildAt(FC, 0, PC));
 1161       ASSERT_TRUE(HasChildCount(PC, 2));
 1162         ASSERT_TRUE(HasTextAt(PC, 0, " "));
 1163         ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "a", "href", "bbb"));
 1177     ASSERT_TRUE(HasChildCount(FC, 1));
 1182       ASSERT_TRUE(GetChildAt(FC, 0, PC));
 1184       ASSERT_TRUE(HasChildCount(PC, 2));
 1185         ASSERT_TRUE(HasTextAt(PC, 0, " "));
 1186         ASSERT_TRUE(HasHTMLEndTagAt(PC, 1, HET, "a"));
 1199   ASSERT_TRUE(HasChildCount(FC, 1));
 1205     ASSERT_TRUE(GetChildAt(FC, 0, PC));
 1207     ASSERT_TRUE(HasChildCount(PC, 6));
 1208       ASSERT_TRUE(HasTextAt(PC, 0, " "));
 1209       ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "pre", NoAttrs()));
 1210       ASSERT_TRUE(HasTextWithNewlineAt(PC, 2, " Aaa"));
 1211       ASSERT_TRUE(HasTextWithNewlineAt(PC, 3, " Bbb"));
 1212       ASSERT_TRUE(HasTextAt(PC, 4, " "));
 1213       ASSERT_TRUE(HasHTMLEndTagAt(PC, 5, HET, "pre"));
 1221   ASSERT_TRUE(HasChildCount(FC, 2));
 1223   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
 1226     ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VCC,
 1236   ASSERT_TRUE(HasChildCount(FC, 2));
 1238   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
 1241     ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC,
 1251   ASSERT_TRUE(HasChildCount(FC, 2));
 1253   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
 1256     ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC, "verbatim", "",
 1267   ASSERT_TRUE(HasChildCount(FC, 1));
 1271     ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 0, VBC,
 1290     ASSERT_TRUE(HasChildCount(FC, 1));
 1294       ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 0, VBC,
 1314     ASSERT_TRUE(HasChildCount(FC, 2));
 1316     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
 1319       ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC,
 1341     ASSERT_TRUE(HasChildCount(FC, 2));
 1343     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
 1346       ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC,
 1369     ASSERT_TRUE(HasChildCount(FC, 2));
 1371     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
 1374       ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC,
 1392     ASSERT_TRUE(HasChildCount(FC, 2));
 1394     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
 1397       ASSERT_TRUE(HasVerbatimLineAt(FC, Traits, 1, VLC, "fn", ""));
 1410     ASSERT_TRUE(HasChildCount(FC, 2));
 1412     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
 1415       ASSERT_TRUE(HasVerbatimLineAt(FC, Traits, 1, VLC, "fn",
 1429     ASSERT_TRUE(HasChildCount(FC, 2));
 1431     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
 1435       ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 1, BCC, "deprecated", PC));
 1436       ASSERT_TRUE(HasChildCount(PC, 0));
tools/clang/unittests/AST/DataCollectionTest.cpp
  107   ASSERT_TRUE(isStmtHashEqual(declRefExpr().bind("id"), "int x, r = x;",
  116   ASSERT_TRUE(isStmtHashEqual(memberExpr().bind("id"),
  119   ASSERT_TRUE(isStmtHashEqual(memberExpr().bind("id"),
  122   ASSERT_TRUE(isStmtHashEqual(memberExpr().bind("id"),
  131   ASSERT_TRUE(
  133   ASSERT_TRUE(
  140   ASSERT_TRUE(isStmtHashEqual(floatLiteral().bind("id"), "double x = .0;",
  142   ASSERT_TRUE(isStmtHashEqual(floatLiteral().bind("id"), "double x = .10;",
  144   ASSERT_TRUE(isStmtHashEqual(floatLiteral().bind("id"), "double x = .1;",
  151   ASSERT_TRUE(isStmtHashEqual(stringLiteral().bind("id"), R"(char x[] = "0";)",
  158   ASSERT_TRUE(isStmtHashEqual(cxxBoolLiteral().bind("id"), "bool x = false;",
  165   ASSERT_TRUE(isStmtHashEqual(characterLiteral().bind("id"), "char x = '0';",
  167   ASSERT_TRUE(isStmtHashEqual(characterLiteral().bind("id"),
tools/clang/unittests/AST/DeclPrinterTest.cpp
  194   ASSERT_TRUE(PrintedDeclCXX98Matches(
  202   ASSERT_TRUE(PrintedDeclCXX98Matches(
  210   ASSERT_TRUE(PrintedDeclCXX98Matches(
  219   ASSERT_TRUE(PrintedDeclCXX98Matches(
  228   ASSERT_TRUE(PrintedDeclCXX98Matches(
  236   ASSERT_TRUE(PrintedDeclCXX11Matches(
  244   ASSERT_TRUE(PrintedDeclCXX98Matches(
  253   ASSERT_TRUE(PrintedDeclCXX98Matches(
  262   ASSERT_TRUE(PrintedDeclCXX98Matches(
  269   ASSERT_TRUE(PrintedDeclCXX98Matches(
  276   ASSERT_TRUE(PrintedDeclCXX98Matches(
  283   ASSERT_TRUE(PrintedDeclCXX98Matches(
  291   ASSERT_TRUE(PrintedDeclCXX98Matches(
  299   ASSERT_TRUE(PrintedDeclCXX98Matches(
  307   ASSERT_TRUE(PrintedDeclCXX98Matches(
  315   ASSERT_TRUE(PrintedDeclCXX98Matches(
  323   ASSERT_TRUE(PrintedDeclCXX98Matches(
  331   ASSERT_TRUE(PrintedDeclCXX98Matches(
  339   ASSERT_TRUE(PrintedDeclCXX98Matches(
  348   ASSERT_TRUE(PrintedDeclCXX98Matches(
  355     ASSERT_TRUE(PrintedDeclCXX98Matches(
  363     ASSERT_TRUE(PrintedDeclCXX98Matches(
  371     ASSERT_TRUE(PrintedDeclCXX98Matches(
  379     ASSERT_TRUE(PrintedDeclCXX98Matches(
  387     ASSERT_TRUE(PrintedDeclCXX98Matches(
  396   ASSERT_TRUE(PrintedDeclCXX98Matches(
  403   ASSERT_TRUE(PrintedDeclCXX98Matches(
  411   ASSERT_TRUE(PrintedDeclCXX98Matches(
  418   ASSERT_TRUE(PrintedDeclCXX98Matches(
  425   ASSERT_TRUE(PrintedDeclCXX98Matches(
  432   ASSERT_TRUE(PrintedDeclCXX11Matches(
  439   ASSERT_TRUE(PrintedDeclCXX98Matches(
  446   ASSERT_TRUE(PrintedDeclCXX98Matches(
  453   ASSERT_TRUE(PrintedDeclCXX98Matches(
  460   ASSERT_TRUE(PrintedDeclCXX98Matches(
  469   ASSERT_TRUE(PrintedDeclCXX98Matches(
  476   ASSERT_TRUE(PrintedDeclCXX98Matches(
  484   ASSERT_TRUE(PrintedDeclCXX98Matches(
  495   ASSERT_TRUE(PrintedDeclCXX98Matches(
  504   ASSERT_TRUE(PrintedDeclCXX98Matches(
  513   ASSERT_TRUE(PrintedDeclCXX98Matches(
  522   ASSERT_TRUE(PrintedDeclCXX98Matches(
  531   ASSERT_TRUE(PrintedDeclCXX98Matches(
  541   ASSERT_TRUE(PrintedDeclCXX98Matches(
  552   ASSERT_TRUE(PrintedDeclCXX11Matches(
  561   ASSERT_TRUE(PrintedDeclCXX98Matches(
  570   ASSERT_TRUE(PrintedDeclCXX11Matches(
  579   ASSERT_TRUE(PrintedDeclCXX11Matches(
  588   ASSERT_TRUE(PrintedDeclCXX11Matches(
  597   ASSERT_TRUE(PrintedDeclCXX11Matches(
  607   ASSERT_TRUE(PrintedDeclCXX11nonMSCMatches(
  617   ASSERT_TRUE(PrintedDeclCXX98Matches(
  626   ASSERT_TRUE(PrintedDeclCXX98Matches(
  635   ASSERT_TRUE(PrintedDeclCXX98Matches(
  644   ASSERT_TRUE(PrintedDeclCXX98Matches(
  653   ASSERT_TRUE(PrintedDeclCXX98Matches(
  663   ASSERT_TRUE(PrintedDeclCXX11Matches(
  673   ASSERT_TRUE(PrintedDeclCXX11Matches(
  683   ASSERT_TRUE(PrintedDeclCXX11Matches(
  693   ASSERT_TRUE(PrintedDeclCXX98Matches(
  702   ASSERT_TRUE(PrintedDeclCXX11Matches(
  731     ASSERT_TRUE(PrintedDeclCXX98Matches(
  754     ASSERT_TRUE(PrintedDeclCXX98Matches(
  762   ASSERT_TRUE(PrintedDeclCXX98Matches(
  771   ASSERT_TRUE(PrintedDeclCXX98Matches(
  780   ASSERT_TRUE(PrintedDeclCXX98Matches(
  793   ASSERT_TRUE(PrintedDeclCXX98Matches(
  802   ASSERT_TRUE(PrintedDeclCXX98Matches(
  811   ASSERT_TRUE(PrintedDeclCXX98Matches(
  820   ASSERT_TRUE(PrintedDeclCXX98Matches(
  829   ASSERT_TRUE(PrintedDeclCXX98Matches(
  838   ASSERT_TRUE(PrintedDeclCXX11Matches(
  847   ASSERT_TRUE(PrintedDeclCXX11Matches(
  856   ASSERT_TRUE(PrintedDeclCXX98Matches(
  865   ASSERT_TRUE(PrintedDeclCXX98Matches(
  874   ASSERT_TRUE(PrintedDeclCXX98Matches(
  884   ASSERT_TRUE(PrintedDeclCXX11Matches(
  893   ASSERT_TRUE(PrintedDeclCXX11Matches(
  903   ASSERT_TRUE(PrintedDeclCXX11Matches(
  913   ASSERT_TRUE(PrintedDeclCXX11Matches(
  924   ASSERT_TRUE(PrintedDeclCXX98Matches(
  932   ASSERT_TRUE(PrintedDeclCXX98Matches(
  940   ASSERT_TRUE(PrintedDeclCXX11Matches(
  948   ASSERT_TRUE(PrintedDeclCXX98Matches(
  957   ASSERT_TRUE(PrintedDeclCXX98Matches(
  966   ASSERT_TRUE(PrintedDeclCXX98Matches(
  974   ASSERT_TRUE(PrintedDeclCXX98Matches(
  982   ASSERT_TRUE(PrintedDeclCXX98Matches(
  990   ASSERT_TRUE(PrintedDeclCXX98Matches(
  998   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1006   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1014   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1023   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1030   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1038   ASSERT_TRUE(PrintedDeclCXX11Matches(
 1046   ASSERT_TRUE(PrintedDeclCXX11Matches(
 1054   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1064   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1075   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1085   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1093   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1101   ASSERT_TRUE(PrintedDeclCXX11Matches(
 1109   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1116   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1123   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1132   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1142   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1153   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1163   ASSERT_TRUE(PrintedDeclCXX11Matches(
 1173   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1182   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1192   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1203   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1214   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1223   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1232   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1241   ASSERT_TRUE(PrintedDeclCXX98Matches(
 1251   ASSERT_TRUE(PrintedDeclCXX11Matches(
 1262   ASSERT_TRUE(PrintedDeclCXX11Matches(
 1274   ASSERT_TRUE(PrintedDeclCXX11Matches(
 1285   ASSERT_TRUE(PrintedDeclCXX1ZMatches(
 1292   ASSERT_TRUE(PrintedDeclObjCMatches(
 1305   ASSERT_TRUE(PrintedDeclObjCMatches(
 1309   ASSERT_TRUE(PrintedDeclObjCMatches(
 1316   ASSERT_TRUE(PrintedDeclObjCMatches(
tools/clang/unittests/AST/DeclTest.cpp
   35   ASSERT_TRUE(runToolOnCodeWithArgs(
   85   ASSERT_TRUE(Decls.size() == 1);
  107   ASSERT_TRUE(0 == MangleF.compare("\x01" "foo"));
  108   ASSERT_TRUE(0 == MangleG.compare("goo"));
tools/clang/unittests/AST/EvaluateAsRValueTest.cpp
   91     ASSERT_TRUE(runToolOnCodeWithArgs(
tools/clang/unittests/AST/ExternalASTSourceTest.cpp
   80   ASSERT_TRUE(testExternalASTSource(new TestSource(Calls), "int j, k = j;"));
tools/clang/unittests/AST/NamedDeclPrinterTest.cpp
  161   ASSERT_TRUE(PrintedNamedDeclCXX98Matches(
  168   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
  175   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
  182   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
  189   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
  196   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
  203   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
  210   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
  217   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
  233   ASSERT_TRUE(PrintedWrittenPropertyDeclObjCMatches(
  249   ASSERT_TRUE(PrintedWrittenPropertyDeclObjCMatches(
  260   ASSERT_TRUE(PrintedNestedNameSpecifierMatches(Code, "func", "foo::bar::"));
  269   ASSERT_TRUE(
tools/clang/unittests/AST/OMPStructuredBlockTest.cpp
   81   ASSERT_TRUE(PrintedOMPStmtMatches(
   91   ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
   93   ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
  109   ASSERT_TRUE(PrintedOMPStmtMatches(
  111   ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
  128   ASSERT_TRUE(PrintedOMPStmtMatches(
  130   ASSERT_TRUE(
  142   ASSERT_TRUE(PrintedOMPStmtMatches(
  161   ASSERT_TRUE(PrintedOMPStmtMatches(
  175   ASSERT_TRUE(PrintedOMPStmtMatches(Source,
  190   ASSERT_TRUE(PrintedOMPStmtMatches(Source,
  205   ASSERT_TRUE(PrintedOMPStmtMatches(
  220   ASSERT_TRUE(PrintedOMPStmtMatches(Source,
  251   ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
  253   ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
  263   ASSERT_TRUE(PrintedOMPStmtMatches(
  274   ASSERT_TRUE(PrintedOMPStmtMatches(
  286   ASSERT_TRUE(PrintedOMPStmtMatches(
  299   ASSERT_TRUE(
  302   ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
  313   ASSERT_TRUE(PrintedOMPStmtMatches(
  324   ASSERT_TRUE(PrintedOMPStmtMatches(
  335   ASSERT_TRUE(PrintedOMPStmtMatches(
  346   ASSERT_TRUE(PrintedOMPStmtMatches(
  376   ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPSectionsDirectiveMatcher(),
  381   ASSERT_TRUE(PrintedOMPStmtMatches(
  392   ASSERT_TRUE(PrintedOMPStmtMatches(
  403   ASSERT_TRUE(PrintedOMPStmtMatches(
  414   ASSERT_TRUE(PrintedOMPStmtMatches(
  424   ASSERT_TRUE(
  427   ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
  436   ASSERT_TRUE(
  439   ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
  449   ASSERT_TRUE(PrintedOMPStmtMatches(
  460   ASSERT_TRUE(PrintedOMPStmtMatches(
  470   ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
  472   ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
  482   ASSERT_TRUE(PrintedOMPStmtMatches(
  493   ASSERT_TRUE(PrintedOMPStmtMatches(
  504   ASSERT_TRUE(PrintedOMPStmtMatches(
  514   ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
  516   ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
  525   ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
  527   ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
  538   ASSERT_TRUE(PrintedOMPStmtMatches(
tools/clang/unittests/AST/StmtPrinterTest.cpp
   94   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX98,
  108   ASSERT_TRUE(PrintedStmtMSMatches(
  124   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX98,
  132   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX98,
  146   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX11,
  161   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX11,
  169   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX11,
  178   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX14,
  186   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX2a,
  205   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX11,
  210   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX11,
  225   ASSERT_TRUE(PrintedStmtObjCMatches(ObjCSource, returnStmt().bind("id"),
  231   ASSERT_TRUE(PrintedStmtObjCMatches(ObjCSource, returnStmt().bind("id"),
  239   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX11, CPPSource,
  244   ASSERT_TRUE(PrintedStmtCXXMatches(
tools/clang/unittests/ASTMatchers/ASTMatchersInternalTest.cpp
  108   ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), "int x;"));
  130   ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), "int x;"));
  135   ASSERT_TRUE(AST.get());
  156   ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), "int x;"));
  161   ASSERT_TRUE(AST.get());
  169   ASSERT_TRUE(AST.get());
tools/clang/unittests/Analysis/CloneDetectionTest.cpp
   81     ASSERT_TRUE(ND != nullptr);
   83     ASSERT_TRUE(ND->getNameAsString().find("bar") != 0);
  100     ASSERT_TRUE(ND != nullptr);
tools/clang/unittests/Basic/DiagnosticTest.cpp
   82   ASSERT_TRUE(!Value);
tools/clang/unittests/Basic/FileManagerTest.cpp
   93   ASSERT_TRUE(file != nullptr);
   96   ASSERT_TRUE(dir != nullptr);
  100   ASSERT_TRUE(file != nullptr);
  103   ASSERT_TRUE(dir != nullptr);
  129   ASSERT_TRUE(dir);
  133   ASSERT_TRUE(dir);
  154   ASSERT_TRUE(file);
  155   ASSERT_TRUE((*file)->isValid());
  159   ASSERT_TRUE(dir != nullptr);
  179   ASSERT_TRUE(file);
  180   ASSERT_TRUE((*file)->isValid());
  184   ASSERT_TRUE(dir != nullptr);
  201   ASSERT_TRUE(fileFoo);
  202   ASSERT_TRUE((*fileFoo)->isValid());
  203   ASSERT_TRUE(fileBar);
  204   ASSERT_TRUE((*fileBar)->isValid());
  264   ASSERT_TRUE(manager.getVirtualFile("abc/foo.cpp", 100, 0)->isValid());
  265   ASSERT_TRUE(manager.getVirtualFile("abc/bar.cpp", 200, 0)->isValid());
  288   ASSERT_TRUE(file1 != nullptr);
  289   ASSERT_TRUE(file1->isValid());
  295   ASSERT_TRUE(file2);
  296   ASSERT_TRUE((*file2)->isValid());
  319   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
  329   ASSERT_TRUE(Manager.makeAbsolutePath(Path));
  345   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
  359   ASSERT_TRUE(file != nullptr);
  360   ASSERT_TRUE(file->isValid());
  378   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
  392   ASSERT_TRUE(file);
  393   ASSERT_TRUE((*file)->isValid());
  411   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
  424   ASSERT_TRUE(File);
  437   ASSERT_TRUE(BypassRef);
tools/clang/unittests/Basic/FixedPointTest.cpp
  605   ASSERT_TRUE(Fixed.getValue().isSigned());
  607   ASSERT_TRUE(UFixed.getValue().isUnsigned());
tools/clang/unittests/Basic/SourceManagerTest.cpp
   92   ASSERT_TRUE(macroExpStartLoc.isFileID());
   93   ASSERT_TRUE(macroExpEndLoc.isFileID());
  416   ASSERT_TRUE(Macros[0].isDefinition());
  419   ASSERT_TRUE(Macros[1].isDefinition());
  425   ASSERT_TRUE(Macros[3].isExpansion());
  428   ASSERT_TRUE(Macros[4].isDefinition());
  431   ASSERT_TRUE(Macros[5].isDefinition());
  435   ASSERT_TRUE(Macros[6].isDefinition());
  436   ASSERT_TRUE(Macros[6].isUnDefinition());
  440   ASSERT_TRUE(Macros[7].isUnDefinition());
  443   ASSERT_TRUE(Macros[8].isDefinition());
  449   ASSERT_TRUE(Macros[10].isExpansion());
  452   ASSERT_TRUE(Macros[11].isDefinition());
tools/clang/unittests/CodeGen/CodeGenExternalTest.cpp
  179         ASSERT_TRUE(c != NULL);
  189         ASSERT_TRUE(def != NULL);
  191         ASSERT_TRUE(clangTy != NULL);
  196         ASSERT_TRUE(llvmTy != NULL);
  203         ASSERT_TRUE(structTy != NULL);
  216         ASSERT_TRUE(xField != NULL);
  217         ASSERT_TRUE(yField != NULL);
  218         ASSERT_TRUE(zField != NULL);
  231         ASSERT_TRUE(xTy != NULL);
  232         ASSERT_TRUE(yTy != NULL);
  233         ASSERT_TRUE(zTy != NULL);
  253   ASSERT_TRUE(mytest_fn_ok);
  254   ASSERT_TRUE(mytest_struct_ok);
  298     ASSERT_TRUE(test_codegen_fns_ran);
tools/clang/unittests/CodeGen/IncrementalProcessingTest.cpp
  150     ASSERT_TRUE(M[0]);
  153     ASSERT_TRUE(M[1]);
  154     ASSERT_TRUE(M[1]->getFunction("funcForProg1"));
  157     ASSERT_TRUE(M[2]);
  158     ASSERT_TRUE(M[2]->getFunction("funcForProg2"));
  164     ASSERT_TRUE(GlobalInit1);
  167     ASSERT_TRUE(GlobalInit2);
tools/clang/unittests/CodeGen/TBAAMetadataTest.cpp
  144   ASSERT_TRUE(I);
  156   ASSERT_TRUE(I);
  168   ASSERT_TRUE(I);
  180   ASSERT_TRUE(I);
  192   ASSERT_TRUE(I);
  204   ASSERT_TRUE(I);
  267   ASSERT_TRUE(I);
  279   ASSERT_TRUE(I);
  291   ASSERT_TRUE(I);
  303   ASSERT_TRUE(I);
  315   ASSERT_TRUE(I);
  327   ASSERT_TRUE(I);
  378   ASSERT_TRUE(I);
  390   ASSERT_TRUE(I);
  403   ASSERT_TRUE(I);
  415   ASSERT_TRUE(I);
  470   ASSERT_TRUE(I);
  482   ASSERT_TRUE(I);
  495   ASSERT_TRUE(I);
  507   ASSERT_TRUE(I);
  575   ASSERT_TRUE(I);
  587   ASSERT_TRUE(I);
  599   ASSERT_TRUE(I);
  611   ASSERT_TRUE(I);
  675   ASSERT_TRUE(I);
  687   ASSERT_TRUE(I);
  699   ASSERT_TRUE(I);
  711   ASSERT_TRUE(I);
  723   ASSERT_TRUE(I);
  735   ASSERT_TRUE(I);
  799   ASSERT_TRUE(I);
  811   ASSERT_TRUE(I);
  823   ASSERT_TRUE(I);
  835   ASSERT_TRUE(I);
  893   ASSERT_TRUE(I);
  905   ASSERT_TRUE(I);
  917   ASSERT_TRUE(I);
  972   ASSERT_TRUE(I);
  984   ASSERT_TRUE(I);
  996   ASSERT_TRUE(I);
 1048   ASSERT_TRUE(I);
 1060   ASSERT_TRUE(I);
 1072   ASSERT_TRUE(I);
 1126   ASSERT_TRUE(I);
 1138   ASSERT_TRUE(I);
 1150   ASSERT_TRUE(I);
 1202   ASSERT_TRUE(I);
 1214   ASSERT_TRUE(I);
 1226   ASSERT_TRUE(I);
 1238   ASSERT_TRUE(I);
 1284   ASSERT_TRUE(I);
 1296   ASSERT_TRUE(I);
tools/clang/unittests/Driver/DistroTest.cpp
   49   ASSERT_TRUE(UbuntuTrusty.IsUbuntu());
   79   ASSERT_TRUE(UbuntuYakkety.IsUbuntu());
  115   ASSERT_TRUE(Fedora25.IsRedhat());
  152   ASSERT_TRUE(CentOS7.IsRedhat());
  181   ASSERT_TRUE(OpenSUSELeap421.IsOpenSUSE());
  207   ASSERT_TRUE(OpenSUSE132.IsOpenSUSE());
  248   ASSERT_TRUE(DebianJessie.IsDebian());
  267   ASSERT_TRUE(DebianStretchSid.IsDebian());
  337   ASSERT_TRUE(Gentoo.IsGentoo());
tools/clang/unittests/Driver/MultilibTest.cpp
   24   ASSERT_TRUE(Multilib().isValid()) << "Empty multilib is not valid";
   26   ASSERT_TRUE(Multilib().flag("+foo").isValid())
   29   ASSERT_TRUE(Multilib().flag("-foo").isValid())
   35   ASSERT_TRUE(Multilib().flag("+foo").flag("+foo").isValid())
   38   ASSERT_TRUE(Multilib().flag("+foo").flag("-foobar").isValid())
   44   ASSERT_TRUE(M == M) << "Multilib::operator==() is not reflexive";
   48   ASSERT_TRUE(Multilib() == Multilib())
   56   ASSERT_TRUE(M1 == M2) << "Multilibs with the same flag should be the same";
   78   ASSERT_TRUE(M1 == M2) << "Flag duplication shouldn't affect equivalence";
   79   ASSERT_TRUE(M2 == M1)
   87   ASSERT_TRUE(M1 == M2)
   89   ASSERT_TRUE(M2 == M1)
   97   ASSERT_TRUE(M1 == M2)
   99   ASSERT_TRUE(M2 == M1)
  107   ASSERT_TRUE(M1 == M2)
  109   ASSERT_TRUE(M2 == M1)
  139   ASSERT_TRUE(M.gccSuffix() == "/gcc64");
  140   ASSERT_TRUE(M.osSuffix() == "/os64");
  141   ASSERT_TRUE(M.includeSuffix() == "/inc64");
  149   ASSERT_TRUE(M1 == M2)
  151   ASSERT_TRUE(M1 == M3)
  153   ASSERT_TRUE(M1 == M4)
  162     ASSERT_TRUE(llvm::StringSwitch<bool>(*I)
  183   ASSERT_TRUE(MS.size() == 0);
  185   ASSERT_TRUE(MS.size() == 2);
  188       ASSERT_TRUE(I->flags()[0] == "+m64");
  190       ASSERT_TRUE(I->flags()[0] == "-m64");
  201   ASSERT_TRUE(MS.size() == 4);
  203     ASSERT_TRUE(I->isValid()) << "Multilb " << *I << " should be valid";
  204     ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
  208     ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
  215     ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
  229   ASSERT_TRUE(MS.size() == 2);
  231     ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
  236   ASSERT_TRUE(MS.size() == 0);
  250     ASSERT_TRUE(I->gccSuffix() != "/one/two/three")
  291   ASSERT_TRUE(MS1.select(FlagM64, SelectionM64))
  293   ASSERT_TRUE(SelectionM64.gccSuffix() == "/64")
  299   ASSERT_TRUE(MS1.select(FlagNoM64, SelectionNoM64))
  301   ASSERT_TRUE(SelectionNoM64.gccSuffix() == "")
  325     ASSERT_TRUE(MS2.select(Flags, Selection)) << "Selection failed for "
  362   ASSERT_TRUE(MS.select(Flags1, Selection1))
  364   ASSERT_TRUE(Selection1.gccSuffix() == "/foo")
  371   ASSERT_TRUE(MS.select(Flags2, Selection2))
  373   ASSERT_TRUE(Selection2.gccSuffix() == "/bar")
tools/clang/unittests/Format/FormatTest.cpp
14272   ASSERT_TRUE((bool)Style1);
14279   ASSERT_TRUE(
14282   ASSERT_TRUE(
14285   ASSERT_TRUE((bool)Style1);
14289   ASSERT_TRUE(
14292   ASSERT_TRUE((bool)Style2);
14297   ASSERT_TRUE((bool)Style2);
14302   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
14305   ASSERT_TRUE((bool)Style2);
14310   ASSERT_TRUE((bool)Style2);
14314   ASSERT_TRUE(
14317   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
14320   ASSERT_TRUE((bool)Style3);
14339   ASSERT_TRUE(
14343   ASSERT_TRUE(
14351   ASSERT_TRUE((bool)StyleTd);
tools/clang/unittests/Format/FormatTestObjC.cpp
   74   ASSERT_TRUE((bool)Style);
   79   ASSERT_TRUE((bool)Style);
   85   ASSERT_TRUE((bool)Style);
   90   ASSERT_TRUE((bool)Style);
   95   ASSERT_TRUE((bool)Style);
   99   ASSERT_TRUE((bool)Style);
  104   ASSERT_TRUE((bool)Style);
  108   ASSERT_TRUE((bool)Style);
  113   ASSERT_TRUE((bool)Style);
  118   ASSERT_TRUE((bool)Style);
  123   ASSERT_TRUE((bool)Style);
  127   ASSERT_TRUE((bool)Style);
  132   ASSERT_TRUE((bool)Style);
  137   ASSERT_TRUE((bool)Style);
  142   ASSERT_TRUE((bool)Style);
  147   ASSERT_TRUE((bool)Style);
  152   ASSERT_TRUE((bool)Style);
  157   ASSERT_TRUE((bool)Style);
  161   ASSERT_TRUE((bool)Style);
  165   ASSERT_TRUE((bool)Style);
  169   ASSERT_TRUE((bool)Style);
  177   ASSERT_TRUE((bool)Style);
  183   ASSERT_TRUE((bool)Style);
tools/clang/unittests/Frontend/CompilerInstanceTest.cpp
   71   ASSERT_TRUE(Instance.getFileManager().getFile("vfs-virtual.file"));
tools/clang/unittests/Frontend/FrontendActionTest.cpp
   96   ASSERT_TRUE(compiler.ExecuteAction(test_action));
  116   ASSERT_TRUE(compiler.ExecuteAction(test_action));
  144   ASSERT_TRUE(compiler.ExecuteAction(test_action));
  192   ASSERT_TRUE(Compiler.ExecuteAction(TestAction));
  194   ASSERT_TRUE(TestAction.SeenEnd);
  252   ASSERT_TRUE(Compiler.ExecuteAction(TestAction));
  283     ASSERT_TRUE(Compiler.ExecuteAction(TestAction));
tools/clang/unittests/Frontend/PCHPreambleTest.cpp
  138   ASSERT_TRUE(AST.get());
  142   ASSERT_TRUE(ReparseAST(AST));
  158   ASSERT_TRUE(AST.get());
  163   ASSERT_TRUE(ReparseAST(AST));
  181   ASSERT_TRUE(AST.get());
  188   ASSERT_TRUE(ReparseAST(AST));
  205   ASSERT_TRUE(AST.get());
  214   ASSERT_TRUE(ReparseAST(AST));
  231   ASSERT_TRUE(AST.get());
  236   ASSERT_TRUE(ReparseAST(AST));
  247   ASSERT_TRUE(ReparseAST(AST));
  259   ASSERT_TRUE(ReparseAST(AST));
tools/clang/unittests/Frontend/ParsedSourceLocationTest.cpp
   21     ASSERT_TRUE(PSR);
tools/clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp
  245   ASSERT_TRUE(minimizeSourceToDependencyDirectives("#define 0\n", Out));
  251   ASSERT_TRUE(minimizeSourceToDependencyDirectives("#define &\n", Out));
  405   ASSERT_TRUE(minimizeSourceToDependencyDirectives("@import A\n", Out));
  406   ASSERT_TRUE(minimizeSourceToDependencyDirectives("@import MACRO(A);\n", Out));
  407   ASSERT_TRUE(minimizeSourceToDependencyDirectives("@import \" \";\n", Out));
tools/clang/unittests/Lex/HeaderMapTest.cpp
  128   ASSERT_TRUE(HeaderMapImpl::checkHeader(*File.getBuffer(), NeedsSwap));
  132   ASSERT_TRUE(HeaderMapImpl::checkHeader(*File.getBuffer(), NeedsSwap));
  133   ASSERT_TRUE(NeedsSwap);
  174   ASSERT_TRUE(HeaderMapImpl::checkHeader(*File.getBuffer(), NeedsSwap));
  212   ASSERT_TRUE(HeaderMapImpl::checkHeader(*File.getBuffer(), NeedsSwap));
  247   ASSERT_TRUE(HeaderMapImpl::checkHeader(*File.getBuffer(), NeedsSwap));
tools/clang/unittests/Lex/LexerTest.cpp
  550     ASSERT_TRUE(T.hasValue());
tools/clang/unittests/Sema/ExternalSemaSourceTest.cpp
  197     ASSERT_TRUE(CI.hasDiagnostics());
  227   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
  241   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
  260   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
  275   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
  291   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
tools/clang/unittests/Tooling/ASTSelectionTest.cpp
   92   ASSERT_TRUE(IsTypeMatched);
tools/clang/unittests/Tooling/CompilationDatabaseTest.cpp
  563   ASSERT_TRUE((bool)Database);
  564   ASSERT_TRUE(ErrorMsg.empty());
  580   ASSERT_TRUE((bool)Database);
  581   ASSERT_TRUE(ErrorMsg.empty());
  597   ASSERT_TRUE((bool)Database);
  598   ASSERT_TRUE(ErrorMsg.empty());
  616   ASSERT_TRUE((bool)Database);
  617   ASSERT_TRUE(ErrorMessage.empty());
  632   ASSERT_TRUE((bool)Database);
  633   ASSERT_TRUE(ErrorMsg.empty());
tools/clang/unittests/Tooling/ExecutionTest.cpp
  159   ASSERT_TRUE((bool)Executor);
  169   ASSERT_TRUE((bool)Executor);
  180   ASSERT_TRUE((bool)Executor);
  192   ASSERT_TRUE(!Err);
  203   ASSERT_TRUE(!Err);
  216   ASSERT_TRUE(!Err);
  261   ASSERT_TRUE(!Err);
  289   ASSERT_TRUE(!Err);
tools/clang/unittests/Tooling/RefactoringActionRulesTest.cpp
  137     ASSERT_TRUE(!ErrorOrResult);
  170   ASSERT_TRUE(!Result);
tools/clang/unittests/Tooling/RefactoringCallbacksTest.cpp
   28   ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), Code))
tools/clang/unittests/Tooling/RefactoringTest.cpp
  694   ASSERT_TRUE(Replace.isApplicable());
 1113   ASSERT_TRUE(!Err);
 1116   ASSERT_TRUE(!Err);
 1165   ASSERT_TRUE(!Err);
 1168   ASSERT_TRUE(!Err);
 1200   ASSERT_TRUE(!Err);
 1217   ASSERT_TRUE(!Err);
 1226   ASSERT_TRUE(!Err);
 1231   ASSERT_TRUE(!Err);
 1240   ASSERT_TRUE(!Err);
 1245   ASSERT_TRUE(!Err);
 1255   ASSERT_TRUE(!Err);
 1260   ASSERT_TRUE((bool)Err);
 1271   ASSERT_TRUE(!Err);
 1277   ASSERT_TRUE((bool)Err);
 1287   ASSERT_TRUE(!Err);
 1291   ASSERT_TRUE((bool)Err);
 1376   ASSERT_TRUE(!Err);
 1629   ASSERT_TRUE(!Err);
 1631   ASSERT_TRUE(!Err);
 1633   ASSERT_TRUE(!Err);
 1635   ASSERT_TRUE(!Err);
 1637   ASSERT_TRUE(!Err);
 1639   ASSERT_TRUE(!Err);
 1641   ASSERT_TRUE(!Err);
 1656   ASSERT_TRUE(!Err);
 1658   ASSERT_TRUE(!Err);
 1660   ASSERT_TRUE(!Err);
 1662   ASSERT_TRUE(!Err);
 1664   ASSERT_TRUE(!Err);
 1666   ASSERT_TRUE(!Err);
 1680   ASSERT_TRUE(!Err);
 1682   ASSERT_TRUE(!Err);
 1684   ASSERT_TRUE(!Err);
 1686   ASSERT_TRUE(!Err);
 1688   ASSERT_TRUE(!Err);
 1690   ASSERT_TRUE(!Err);
 1708   ASSERT_TRUE(!Err);
 1710   ASSERT_TRUE(!Err);
 1712   ASSERT_TRUE(!Err);
 1714   ASSERT_TRUE(!Err);
tools/clang/unittests/Tooling/SourceCodeBuildersTest.cpp
   72   ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
   84   ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
  133   ASSERT_TRUE(StmtMatch);
tools/clang/unittests/Tooling/StencilTest.cpp
   98     ASSERT_TRUE(StmtMatch);
  130   ASSERT_TRUE(StmtMatch);
  149   ASSERT_TRUE(StmtMatch);
  166   ASSERT_TRUE(StmtMatch);
  178   ASSERT_TRUE(StmtMatch);
  185   ASSERT_TRUE(StmtMatch);
  316   ASSERT_TRUE(StmtMatch);
  337   ASSERT_TRUE(StmtMatch);
tools/clang/unittests/Tooling/Syntax/TokensTest.cpp
  137     ASSERT_TRUE(Compiler.ExecuteAction(Recorder))
tools/clang/unittests/Tooling/ToolingTest.cpp
  121   ASSERT_TRUE(AST.get());
  125   ASSERT_TRUE(AST.get());
tools/clang/unittests/Tooling/TransformerTest.cpp
   66   ASSERT_TRUE(MaybeActual) << "Rewrite failed. Expecting: " << Expected;
tools/clang/unittests/libclang/LibclangTest.cpp
  471   ASSERT_TRUE(llvm::StringRef(clang_getCString(cxname)).endswith("main.cpp"));
  491   ASSERT_TRUE(ReparseTU(0, nullptr /* No unsaved files. */));
  499   ASSERT_TRUE(ReparseTU(0, nullptr /* No unsaved files. */));
  526   ASSERT_TRUE(ReparseTU(0, nullptr /* No unsaved files. */));
  534   ASSERT_TRUE(ReparseTU(0, nullptr /* No unsaved files. */));
  622       ASSERT_TRUE(ReparseTU(0, nullptr /* No unsaved files. */));
  735   ASSERT_TRUE(SaveAndLoadTU(ASTName));
tools/lldb/unittests/Expression/DWARFExpressionTest.cpp
  276   ASSERT_TRUE((bool)t.GetDwarfUnit());
tools/lldb/unittests/Host/FileTest.cpp
   32   ASSERT_TRUE(stream);
   50   ASSERT_TRUE(file.IsValid());
   53   ASSERT_TRUE(stream != NULL);
tools/lldb/unittests/Host/MainLoopTest.cpp
   33     ASSERT_TRUE(error.Success());
   35     ASSERT_TRUE(error.Success());
   47     ASSERT_TRUE(error.Success());
   48     ASSERT_TRUE(accept_error.get().Success());
   75   ASSERT_TRUE(socketpair[0]->Write(&X, len).Success());
   81   ASSERT_TRUE(error.Success());
   82   ASSERT_TRUE(handle);
   83   ASSERT_TRUE(loop.Run().Success());
   90   ASSERT_TRUE(socketpair[0]->Write(&X, len).Success());
   91   ASSERT_TRUE(socketpair[1]->Write(&X, len).Success());
   96   ASSERT_TRUE(error.Success());
   98   ASSERT_TRUE(error.Success());
  100   ASSERT_TRUE(loop.Run().Success());
  111   ASSERT_TRUE(term.OpenFirstAvailableMaster(O_RDWR, nullptr, 0));
  112   ASSERT_TRUE(term.OpenSlave(O_RDWR | O_NOCTTY, nullptr, 0));
  120   ASSERT_TRUE(error.Success());
  123   ASSERT_TRUE(loop.Run().Success());
  133   ASSERT_TRUE(error.Success());
  135   ASSERT_TRUE(loop.Run().Success());
  151   ASSERT_TRUE(error.Success());
  158   ASSERT_TRUE(loop.Run().Success());
tools/lldb/unittests/Host/SocketAddressTest.cpp
   29   ASSERT_TRUE(sa.SetToLocalhost(AF_INET, 1138));
   33   ASSERT_TRUE(sa.SetToAnyAddress(AF_INET, 0));
   37   ASSERT_TRUE(sa.SetToLocalhost(AF_INET6, 1139));
   38   ASSERT_TRUE(sa.GetIPAddress() == "::1" ||
tools/lldb/unittests/Host/linux/HostTest.cpp
   35   ASSERT_TRUE(Host::GetProcessInfo(getpid(), Info));
   37   ASSERT_TRUE(Info.ProcessIDIsValid());
   40   ASSERT_TRUE(Info.ParentProcessIDIsValid());
   43   ASSERT_TRUE(Info.EffectiveUserIDIsValid());
   46   ASSERT_TRUE(Info.EffectiveGroupIDIsValid());
   49   ASSERT_TRUE(Info.UserIDIsValid());
   52   ASSERT_TRUE(Info.GroupIDIsValid());
tools/lldb/unittests/Host/linux/SupportTest.cpp
   17   ASSERT_TRUE(BufferOrError);
   18   ASSERT_TRUE(*BufferOrError);
   23   ASSERT_TRUE(BufferOrError);
   24   ASSERT_TRUE(*BufferOrError);
tools/lldb/unittests/Interpreter/TestCompletion.cpp
   68     ASSERT_TRUE(test_info != nullptr);
tools/lldb/unittests/ObjectFile/ELF/TestObjectFileELF.cpp
  170   ASSERT_TRUE(Specs.GetModuleSpecAtIndex(0, Spec)) ;
  234   ASSERT_TRUE(entry_point_addr.GetOffset() & 1);
tools/lldb/unittests/Process/gdb-remote/GDBRemoteClientBaseTest.cpp
  126   ASSERT_TRUE(async_result.get());
  201   ASSERT_TRUE(async_result.get());
  224   ASSERT_TRUE(async_result.get());
  260   ASSERT_TRUE(interrupt_result.get());
  339   ASSERT_TRUE(async_result.get());
tools/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
   84   ASSERT_TRUE(write_result.get());
   91   ASSERT_TRUE(write_result.get());
  104   ASSERT_TRUE(write_result.get());
  111   ASSERT_TRUE(write_result.get());
  121   ASSERT_TRUE(async_result.get());
  127   ASSERT_TRUE(bool(buffer_sp));
  135   ASSERT_TRUE(bool(buffer_sp));
  149   ASSERT_TRUE(async_result.get());
  156   ASSERT_TRUE(async_result.get());
  165   ASSERT_TRUE(async_result.get());
  193   ASSERT_TRUE(result.hasValue());
  218   ASSERT_TRUE(result.hasValue());
  263     ASSERT_TRUE(result);
  277       ASSERT_TRUE(ref.consume_front("qSpeedTest:response_size:"));
  292   ASSERT_TRUE(bool(object_sp));
  294   ASSERT_TRUE(bool(dict_sp));
  297   ASSERT_TRUE(bool(object_sp));
  299   ASSERT_TRUE(bool(dict_sp));
  302   ASSERT_TRUE(dict_sp->GetValueForKeyAsInteger("num_packets", num_packets))
  391   ASSERT_TRUE(error.Success());
  414   ASSERT_TRUE(result.get().Success());
  440   ASSERT_TRUE(result.get().Success());
  472   ASSERT_TRUE(result.get().Success());
  504   ASSERT_TRUE(result.get().Success());
  514   ASSERT_TRUE(custom_params);
  516   ASSERT_TRUE(custom_params->GetValueForKeyAsInteger("psb", psb_value));
  518   ASSERT_TRUE(
tools/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationTest.cpp
   62     ASSERT_TRUE(Write(Test.Packet));
tools/lldb/unittests/Process/minidump/MinidumpParserTest.cpp
   88   ASSERT_TRUE(llvm::yaml::convertYAML(YIn, os, [](const llvm::Twine &Msg){}));
  187   ASSERT_TRUE(proc_status.hasValue());
  222   ASSERT_TRUE(pid.hasValue());
  264   ASSERT_TRUE(range.hasValue()) << "There is no range containing this address";
  523   ASSERT_TRUE(pid.hasValue());
  530   ASSERT_TRUE(pid.hasValue());
  538   ASSERT_TRUE(pid.hasValue());
tools/lldb/unittests/Symbol/TestClangASTContext.cpp
  416   ASSERT_TRUE(type);
tools/lldb/unittests/Symbol/TestDWARFCallFrameInfo.cpp
  252   ASSERT_TRUE(cfi.GetUnwindPlan(sym->GetAddress(), plan));
tools/lldb/unittests/SymbolFile/NativePDB/PdbFPOProgramToDWARFExpressionTests.cpp
   39   ASSERT_TRUE(TranslateFPOProgramToDWARFExpression(
   48   ASSERT_TRUE(DWARFExpression::PrintDWARFExpression(
tools/lldb/unittests/Target/ExecutionContextTest.cpp
   82   ASSERT_TRUE(debugger_sp);
   88   ASSERT_TRUE(target_sp);
   89   ASSERT_TRUE(target_sp->GetArchitecture().IsValid());
   90   ASSERT_TRUE(platform_sp);
  104   ASSERT_TRUE(debugger_sp);
  110   ASSERT_TRUE(target_sp);
  111   ASSERT_TRUE(target_sp->GetArchitecture().IsValid());
  112   ASSERT_TRUE(platform_sp);
  116   ASSERT_TRUE(process_sp);
tools/lldb/unittests/Target/ModuleCacheTest.cpp
  129   ASSERT_TRUE(bool(module_sp));
tools/lldb/unittests/UnwindAssembly/x86/Testx86AssemblyInspectionEngine.cpp
 2513   ASSERT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(data, sizeof(data),
 2547   ASSERT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(data, sizeof(data),
 2586   ASSERT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(data, sizeof(data),
tools/lldb/unittests/Utility/ArchSpecTest.cpp
  143     ASSERT_TRUE(B.IsValid());
  150     ASSERT_TRUE(A.IsValid());
  233   ASSERT_TRUE(A.IsValid());
  235   ASSERT_TRUE(B.IsValid());
  244     ASSERT_TRUE(A.IsExactMatch(B));
  245     ASSERT_TRUE(A.IsCompatibleMatch(B));
  252     ASSERT_TRUE(A.IsExactMatch(B));
  253     ASSERT_TRUE(A.IsCompatibleMatch(B));
  259     ASSERT_TRUE(A.IsCompatibleMatch(B));
  292     ASSERT_TRUE(A.IsExactMatch(B));
  293     ASSERT_TRUE(A.IsCompatibleMatch(B));
  339     ASSERT_TRUE(B.TripleVendorWasSpecified());
  343     ASSERT_TRUE(C.TripleVendorWasSpecified());
  344     ASSERT_TRUE(C.TripleOSWasSpecified());
  347     ASSERT_TRUE(D.TripleVendorWasSpecified());
  348     ASSERT_TRUE(D.TripleOSWasSpecified());
  349     ASSERT_TRUE(D.TripleEnvironmentWasSpecified());
  357     ASSERT_TRUE(A.TripleVendorWasSpecified());
  361     ASSERT_TRUE(B.TripleVendorWasSpecified());
  362     ASSERT_TRUE(B.TripleOSWasSpecified());
  365     ASSERT_TRUE(C.TripleVendorWasSpecified());
  366     ASSERT_TRUE(C.TripleOSWasSpecified());
  367     ASSERT_TRUE(C.TripleEnvironmentWasSpecified());
  369     ASSERT_TRUE(D.TripleVendorWasSpecified());
  370     ASSERT_TRUE(D.TripleOSWasSpecified());
  371     ASSERT_TRUE(D.TripleEnvironmentWasSpecified());
tools/lldb/unittests/Utility/ArgsTest.cpp
  166   ASSERT_TRUE(args.GetQuotedCommandString(stdstr));
tools/lldb/unittests/Utility/LogTest.cpp
   94   ASSERT_TRUE(EnableChannel(m_stream_sp, 0, "chan", {}, error));
tools/lldb/unittests/Utility/OptionsWithRawTest.cpp
   61   ASSERT_TRUE(args.HasArgs());
   76   ASSERT_TRUE(args.HasArgs());
   90   ASSERT_TRUE(args.HasArgs());
  104   ASSERT_TRUE(args.HasArgs());
  118   ASSERT_TRUE(args.HasArgs());
  132   ASSERT_TRUE(args.HasArgs());
  146   ASSERT_TRUE(args.HasArgs());
  160   ASSERT_TRUE(args.HasArgs());
  174   ASSERT_TRUE(args.HasArgs());
tools/lldb/unittests/Utility/ScalarTest.cpp
   34   ASSERT_TRUE(checkInequality<int>(23, 24));
   35   ASSERT_TRUE(checkEquality<int>(96, 96));
   36   ASSERT_TRUE(checkInequality<float>(4.0f, 4.5f));
   37   ASSERT_TRUE(checkEquality<float>(4.0f, 4.0f));
   41   ASSERT_TRUE(checkInequality<APInt>(apint1, apint2));
   42   ASSERT_TRUE(checkEquality<APInt>(apint1, apint1));
   47   ASSERT_TRUE(void1 == void2);
   54   ASSERT_TRUE(s1 < s2);
   55   ASSERT_TRUE(s1 <= s2);
   56   ASSERT_TRUE(s2 > s1);
   57   ASSERT_TRUE(s2 >= s1);
   63   ASSERT_TRUE(s1 < s2);
   64   ASSERT_TRUE(s1 <= s2);
   65   ASSERT_TRUE(s2 > s1);
   66   ASSERT_TRUE(s2 >= s1);
  139   ASSERT_TRUE(s_scalar.ExtractBitfield(0, 0));
  141   ASSERT_TRUE(s_scalar.ExtractBitfield(len, 0));
  143   ASSERT_TRUE(s_scalar.ExtractBitfield(len - 4, 4));
  149   ASSERT_TRUE(u_scalar.ExtractBitfield(0, 0));
  151   ASSERT_TRUE(u_scalar.ExtractBitfield(len, 0));
  153   ASSERT_TRUE(u_scalar.ExtractBitfield(len - 4, 4));
  288   ASSERT_TRUE(Z.IsZero());
  290   ASSERT_TRUE(Z.IsZero());
  296   ASSERT_TRUE(S.MakeUnsigned());
  302   ASSERT_TRUE(S.MakeSigned());
tools/lldb/unittests/Utility/TildeExpressionResolverTest.cpp
   19   ASSERT_TRUE(Resolver.ResolveFullPath("~", Result));
   21   ASSERT_TRUE(Resolver.ResolveFullPath("~/", Result));
   24   ASSERT_TRUE(Resolver.ResolveFullPath("~James/bar/baz", Result));
   27   ASSERT_TRUE(Resolver.ResolveFullPath("~Jason/", Result));
   30   ASSERT_TRUE(Resolver.ResolveFullPath("~Lars", Result));
tools/lldb/unittests/Utility/VASprintfTest.cpp
   37   ASSERT_TRUE(Sprintf(BigBuffer, "%s", TestStr.c_str()));
   45   ASSERT_TRUE(Sprintf(SmallBuffer, "%s", TestStr.c_str()));
   55   ASSERT_TRUE(setlocale(LC_ALL, TEST_ENCODING));
   65   ASSERT_TRUE(setlocale(LC_ALL, Current.c_str()));
tools/lldb/unittests/tools/lldb-server/tests/ThreadIdsInJstopinfoTest.cpp
   48     ASSERT_TRUE(thread_infos.find(tid) != thread_infos.end())
unittests/ADT/APIntTest.cpp
  911   ASSERT_TRUE(a.uge(b)); // Must: a >= b
  912   ASSERT_TRUE(a.ugt(c)); // Must: a > c
unittests/ADT/BitVectorTest.cpp
  274   ASSERT_TRUE(SmallBitVectorIsSmallMode(A));
  284   ASSERT_TRUE(SmallBitVectorIsSmallMode(A));
unittests/ADT/DenseMapTest.cpp
  317     ASSERT_TRUE(visited[i]) << "Entry #" << i << " was never visited";
unittests/ADT/IListTest.cpp
  242   ASSERT_TRUE(N.IsInList);
  247   ASSERT_TRUE(N.IsInList);
  248   ASSERT_TRUE(N.WasTransferred);
  253   ASSERT_TRUE(N.WasTransferred);
  277   ASSERT_TRUE(N2.WasTransferred);
unittests/ADT/IntervalMapTest.cpp
   82   ASSERT_TRUE(I.valid());
   95   ASSERT_TRUE(I.valid());
  104   ASSERT_TRUE(I.valid());
  111   ASSERT_TRUE(I.valid());
  117   ASSERT_TRUE(I.valid());
  124   ASSERT_TRUE(I.valid());
  131   ASSERT_TRUE(I.valid());
  137   ASSERT_TRUE(I.valid());
  144   ASSERT_TRUE(I.valid());
  163   ASSERT_TRUE(I.valid());
  167   ASSERT_TRUE(I.valid());
  173   ASSERT_TRUE(I.valid());
  180   ASSERT_TRUE(I.valid());
  250   ASSERT_TRUE(I.valid());
  287   ASSERT_TRUE(I.valid());
  292   ASSERT_TRUE(I.valid());
  306   ASSERT_TRUE(I.valid());
  310   ASSERT_TRUE(I.valid());
  314   ASSERT_TRUE(I.valid());
  318   ASSERT_TRUE(I.valid());
  328   ASSERT_TRUE(I.valid());
  332   ASSERT_TRUE(I.valid());
  336   ASSERT_TRUE(I.valid());
  340   ASSERT_TRUE(I.valid());
  350   ASSERT_TRUE(I.valid());
  354   ASSERT_TRUE(I.valid());
  358   ASSERT_TRUE(I.valid());
  399     ASSERT_TRUE(I.valid());
  411     ASSERT_TRUE(I.valid());
  420   ASSERT_TRUE(I.valid());
  426   ASSERT_TRUE(I.valid());
  433   ASSERT_TRUE(I.valid());
  440   ASSERT_TRUE(I.valid());
  447   ASSERT_TRUE(I.valid());
  454   ASSERT_TRUE(I.valid());
  456   ASSERT_TRUE(I.valid());
  463   ASSERT_TRUE(I.valid());
  469   ASSERT_TRUE(I.valid());
  476   ASSERT_TRUE(I.valid());
  483   ASSERT_TRUE(I.valid());
  490   ASSERT_TRUE(I.valid());
  492   ASSERT_TRUE(I.valid());
  538     ASSERT_TRUE(I.valid());
  550     ASSERT_TRUE(I.valid());
  559   ASSERT_TRUE(I.valid());
  565   ASSERT_TRUE(I.valid());
  571   ASSERT_TRUE(I.valid());
  683   ASSERT_TRUE(AB.valid());
  690   ASSERT_TRUE(BA.valid());
  726   ASSERT_TRUE(AB.valid());
  730   ASSERT_TRUE(AB.valid());
  734   ASSERT_TRUE(AB.valid());
  738   ASSERT_TRUE(AB.valid());
  742   ASSERT_TRUE(AB.valid());
  746   ASSERT_TRUE(AB.valid());
  755   ASSERT_TRUE(AB2.valid());
  761   ASSERT_TRUE(AB2.valid());
  767   ASSERT_TRUE(BA.valid());
  771   ASSERT_TRUE(BA.valid());
  775   ASSERT_TRUE(BA.valid());
  779   ASSERT_TRUE(BA.valid());
  783   ASSERT_TRUE(BA.valid());
  787   ASSERT_TRUE(BA.valid());
  796   ASSERT_TRUE(BA2.valid());
  801   ASSERT_TRUE(BA2.valid());
unittests/ADT/PriorityWorklistTest.cpp
   78   ASSERT_TRUE(W.insert(2));
   79   ASSERT_TRUE(W.insert(4));
   80   ASSERT_TRUE(W.insert(7));
   90   ASSERT_TRUE(W.empty());
   93   ASSERT_TRUE(W.insert(2));
   94   ASSERT_TRUE(W.insert(7));
  100   ASSERT_TRUE(W.empty());
  102   ASSERT_TRUE(W.insert(2));
  103   ASSERT_TRUE(W.insert(7));
  110   ASSERT_TRUE(W.empty());
  112   ASSERT_TRUE(W.insert(2));
  113   ASSERT_TRUE(W.insert(7));
  118   ASSERT_TRUE(W.empty());
unittests/ADT/SparseMultiSetTest.cpp
  220   ASSERT_TRUE(I != Set.end());
  226   ASSERT_TRUE(I != Set.end());
  229   ASSERT_TRUE(I == Set.end());
unittests/ADT/SparseSetTest.cpp
  173   ASSERT_TRUE(I == Set.begin());
  179   ASSERT_TRUE(I == Set.begin());
  197     ASSERT_TRUE(--Expected == Set.pop_back_val());
  203     ASSERT_TRUE(Set.insert(i).second);
unittests/ADT/StringMapTest.cpp
  221     ASSERT_TRUE(visited[i]) << "Entry #" << i << " was never visited";
  422   ASSERT_TRUE(A.empty());
  429   ASSERT_TRUE(B.empty());
unittests/ADT/StringRefTest.cpp
  610       ASSERT_TRUE(U8Success);
  617       ASSERT_TRUE(U16Success);
  624       ASSERT_TRUE(U32Success);
  631       ASSERT_TRUE(U64Success);
  646       ASSERT_TRUE(S8Success);
  653       ASSERT_TRUE(S16Success);
  660       ASSERT_TRUE(S32Success);
  667       ASSERT_TRUE(S64Success);
  692     ASSERT_TRUE(IsBadNumber);
  782       ASSERT_TRUE(U8Success);
  793       ASSERT_TRUE(U16Success);
  804       ASSERT_TRUE(U32Success);
  815       ASSERT_TRUE(U64Success);
  835       ASSERT_TRUE(S8Success);
  846       ASSERT_TRUE(S16Success);
  857       ASSERT_TRUE(S32Success);
  868       ASSERT_TRUE(S64Success);
unittests/Analysis/AliasSetTrackerTest.cpp
   56   ASSERT_TRUE(M) << "Bad assembly?";
unittests/Analysis/CaptureTrackingTest.cpp
   52   ASSERT_TRUE(M) << "Bad assembly?";
   61     ASSERT_TRUE(PointerMayBeCaptured(Arg, true, true, TrueMaxUsesLimit));
   68     ASSERT_TRUE(isa<ReturnInst>(Ret));
   71     ASSERT_TRUE(PointerMayBeCapturedBefore(Arg, true, true, Ret, &DT, false,
unittests/Analysis/DomTreeUpdaterTest.cpp
   58   ASSERT_TRUE(DTU.hasDomTree());
   59   ASSERT_TRUE(DTU.hasPostDomTree());
   60   ASSERT_TRUE(DTU.isEager());
   62   ASSERT_TRUE(DTU.getDomTree().verify());
   63   ASSERT_TRUE(DTU.getPostDomTree().verify());
  114   ASSERT_TRUE(DT.verify());
  115   ASSERT_TRUE(PDT.verify());
  122   ASSERT_TRUE(DT.verify());
  123   ASSERT_TRUE(PDT.verify());
  145   ASSERT_TRUE(DT.verify());
  146   ASSERT_TRUE(PDT.verify());
  168   ASSERT_TRUE(DTU.hasDomTree());
  169   ASSERT_TRUE(DTU.hasPostDomTree());
  170   ASSERT_TRUE(DTU.isEager());
  172   ASSERT_TRUE(DT.verify());
  173   ASSERT_TRUE(PDT.verify());
  190   ASSERT_TRUE(DT.verify());
  191   ASSERT_TRUE(PDT.verify());
  203   ASSERT_TRUE(DT.verify());
  204   ASSERT_TRUE(PDT.verify());
  210   ASSERT_TRUE(DT.verify());
  211   ASSERT_TRUE(PDT.verify());
  242   ASSERT_TRUE(DTU.hasDomTree());
  245   ASSERT_TRUE(DTU.isLazy());
  246   ASSERT_TRUE(DTU.getDomTree().verify());
  279   ASSERT_TRUE(DTU.getDomTree().verify());
  298   ASSERT_TRUE(isa<UnreachableInst>(BB3->getTerminator()));
  331   ASSERT_TRUE(DTU.hasDomTree());
  334   ASSERT_TRUE(DTU.isLazy());
  335   ASSERT_TRUE(DTU.getDomTree().verify());
  392   ASSERT_TRUE(isa<UnreachableInst>(BB2->getTerminator()));
  415   ASSERT_TRUE(isa<UnreachableInst>(BB1->getTerminator()));
  429   ASSERT_TRUE(DT.verify());
  460   ASSERT_TRUE(DTU.hasDomTree());
  461   ASSERT_TRUE(DTU.hasPostDomTree());
  463   ASSERT_TRUE(DTU.isLazy());
  464   ASSERT_TRUE(DTU.getDomTree().verify());
  465   ASSERT_TRUE(DTU.getPostDomTree().verify());
  505   ASSERT_TRUE(isa<UnreachableInst>(BB3->getTerminator()));
  511   ASSERT_TRUE(DTU.getDomTree().verify());
  512   ASSERT_TRUE(DTU.hasPendingUpdates());
  513   ASSERT_TRUE(DTU.hasPendingPostDomTreeUpdates());
  515   ASSERT_TRUE(DTU.hasPendingDeletedBB());
  516   ASSERT_TRUE(DTU.getPostDomTree().verify());
  543   ASSERT_TRUE(DTU.hasDomTree());
  544   ASSERT_TRUE(DTU.hasPostDomTree());
  546   ASSERT_TRUE(DTU.isLazy());
  547   ASSERT_TRUE(DTU.getDomTree().verify());
  548   ASSERT_TRUE(DTU.getPostDomTree().verify());
  568   ASSERT_TRUE(DTU.getDomTree().verify());
  569   ASSERT_TRUE(DTU.getPostDomTree().verify());
  582   ASSERT_TRUE(DT.verify());
  583   ASSERT_TRUE(PDT.verify());
  590   ASSERT_TRUE(isa<UnreachableInst>(BB0->getTerminator()));
  596   ASSERT_TRUE(DTU.hasPendingDeletedBB());
  633   ASSERT_TRUE(DTU.hasDomTree());
  634   ASSERT_TRUE(DTU.hasPostDomTree());
  636   ASSERT_TRUE(DTU.isLazy());
  637   ASSERT_TRUE(DTU.getDomTree().verify());
  638   ASSERT_TRUE(DTU.getPostDomTree().verify());
  672   ASSERT_TRUE(DTU.getDomTree().verify());
  673   ASSERT_TRUE(DTU.hasPendingPostDomTreeUpdates());
  696   ASSERT_TRUE(DTU.getPostDomTree().verify());
  698   ASSERT_TRUE(DTU.hasPendingDomTreeUpdates());
  701   ASSERT_TRUE(DT.verify());
  725   ASSERT_TRUE(DTU.hasPendingDeletedBB());
  750   ASSERT_TRUE(DTU.getDomTree().verify());
  787   ASSERT_TRUE(DTU.hasPendingUpdates());
  793   ASSERT_TRUE(DTU.getDomTree().verify());
unittests/Analysis/GlobalsModRefTest.cpp
   32   ASSERT_TRUE(M) << "Bad assembly?";
unittests/Analysis/LazyCallGraphTest.cpp
 1139     ASSERT_TRUE(CI) << "Expected a call: " << *U;
unittests/Analysis/MemorySSATest.cpp
 1313   ASSERT_TRUE(StoreAEntry->isOptimized());
 1317   ASSERT_TRUE(StoreBEntry->isOptimized());
unittests/Analysis/ScalarEvolutionTest.cpp
 1708   ASSERT_TRUE(M && "Could not parse module?");
 1709   ASSERT_TRUE(!verifyModule(*M) && "Must have been well formed!");
unittests/Analysis/ValueTrackingTest.cpp
   40     ASSERT_TRUE(M);
   43     ASSERT_TRUE(F) << "Test must have a function @test";
   54     ASSERT_TRUE(A) << "@test must have an instruction %A";
unittests/AsmParser/AsmParserTest.cpp
   72   ASSERT_TRUE(Mod != nullptr);
   77   ASSERT_TRUE(V);
   79   ASSERT_TRUE(isa<ConstantFP>(V));
   83   ASSERT_TRUE(V);
   85   ASSERT_TRUE(isa<ConstantInt>(V));
   89   ASSERT_TRUE(V);
   91   ASSERT_TRUE(isa<ConstantDataVector>(V));
   94   ASSERT_TRUE(V);
   95   ASSERT_TRUE(isa<ConstantInt>(V));
   98   ASSERT_TRUE(V);
   99   ASSERT_TRUE(isa<BlockAddress>(V));
  102   ASSERT_TRUE(V);
  103   ASSERT_TRUE(isa<UndefValue>(V));
  137   ASSERT_TRUE(Mod != nullptr);
  144   ASSERT_TRUE(V);
  145   ASSERT_TRUE(isa<ConstantExpr>(V));
  150   ASSERT_TRUE(V);
  151   ASSERT_TRUE(isa<ConstantExpr>(V));
  173   ASSERT_TRUE(Mod != nullptr);
  179   ASSERT_TRUE(Ty);
  180   ASSERT_TRUE(Ty->isIntegerTy());
  181   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
  185   ASSERT_TRUE(Ty);
  186   ASSERT_TRUE(Ty->isIntegerTy());
  187   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 13);
  191   ASSERT_TRUE(Ty);
  192   ASSERT_TRUE(Ty->isFloatTy());
  195   ASSERT_TRUE(Ty);
  196   ASSERT_TRUE(Ty->isDoubleTy());
  201   ASSERT_TRUE(Ty);
  202   ASSERT_TRUE(Ty->isStructTy());
  206   ASSERT_TRUE(ST->getNumElements() == 2);
  209     ASSERT_TRUE(Ty->isIntegerTy());
  210     ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
  215   ASSERT_TRUE(Ty);
  216   ASSERT_TRUE(Ty->isStructTy());
  220   ASSERT_TRUE(ST->getNumElements() == 4);
  223     ASSERT_TRUE(Ty->isIntegerTy());
  224     ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
  229   ASSERT_TRUE(Ty);
  230   ASSERT_TRUE(Ty->isVectorTy());
  234   ASSERT_TRUE(VT->getNumElements() == 5);
  235   ASSERT_TRUE(VT->getBitWidth() == 160);
  237   ASSERT_TRUE(Ty->isIntegerTy());
  238   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
  242   ASSERT_TRUE(Ty);
  243   ASSERT_TRUE(Ty->isStructTy());
  246   ASSERT_TRUE(ST->isOpaque());
  251   ASSERT_TRUE(Ty);
  252   ASSERT_TRUE(Ty->isPointerTy());
  256   ASSERT_TRUE(Ty->isIntegerTy());
  257   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
  261   ASSERT_TRUE(Ty);
  262   ASSERT_TRUE(Ty->isPointerTy());
  266   ASSERT_TRUE(Ty->isPointerTy());
  270   ASSERT_TRUE(Ty->isIntegerTy());
  271   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
  275   ASSERT_TRUE(!Ty);
  297   ASSERT_TRUE(Mod != nullptr);
  304   ASSERT_TRUE(Ty);
  305   ASSERT_TRUE(Ty->isIntegerTy());
  306   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
  307   ASSERT_TRUE(Read == 3);
  311   ASSERT_TRUE(Ty);
  312   ASSERT_TRUE(Ty->isIntegerTy());
  313   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 13);
  314   ASSERT_TRUE(Read == 3);
  318   ASSERT_TRUE(Ty);
  319   ASSERT_TRUE(Ty->isFloatTy());
  320   ASSERT_TRUE(Read == 5);
  323   ASSERT_TRUE(Ty);
  324   ASSERT_TRUE(Ty->isDoubleTy());
  325   ASSERT_TRUE(Read == 6);
  330   ASSERT_TRUE(Ty);
  331   ASSERT_TRUE(Ty->isStructTy());
  332   ASSERT_TRUE(Read == 3);
  336   ASSERT_TRUE(ST->getNumElements() == 2);
  339     ASSERT_TRUE(Ty->isIntegerTy());
  340     ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
  345   ASSERT_TRUE(Ty);
  346   ASSERT_TRUE(Ty->isStructTy());
  347   ASSERT_TRUE(Read == 2);
  351   ASSERT_TRUE(ST->getNumElements() == 4);
  354     ASSERT_TRUE(Ty->isIntegerTy());
  355     ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
  360   ASSERT_TRUE(Ty);
  361   ASSERT_TRUE(Ty->isVectorTy());
  362   ASSERT_TRUE(Read == 9);
  366   ASSERT_TRUE(VT->getNumElements() == 5);
  367   ASSERT_TRUE(VT->getBitWidth() == 160);
  369   ASSERT_TRUE(Ty->isIntegerTy());
  370   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
  374   ASSERT_TRUE(Ty);
  375   ASSERT_TRUE(Ty->isStructTy());
  376   ASSERT_TRUE(Read == 7);
  379   ASSERT_TRUE(ST->isOpaque());
  384   ASSERT_TRUE(Ty);
  385   ASSERT_TRUE(Ty->isPointerTy());
  386   ASSERT_TRUE(Read == 4);
  390   ASSERT_TRUE(Ty->isIntegerTy());
  391   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
  395   ASSERT_TRUE(Ty);
  396   ASSERT_TRUE(Ty->isPointerTy());
  397   ASSERT_TRUE(Read == 5);
  401   ASSERT_TRUE(Ty->isPointerTy());
  405   ASSERT_TRUE(Ty->isIntegerTy());
  406   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
  410   ASSERT_TRUE(Ty);
  411   ASSERT_TRUE(Ty->isIntegerTy());
  412   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
  414   ASSERT_TRUE(Read == 4);
unittests/BinaryFormat/MsgPackDocumentTest.cpp
   19   ASSERT_TRUE(Ok);
   27   ASSERT_TRUE(Ok);
   46   ASSERT_TRUE(Ok);
  104   ASSERT_TRUE(Ok);
  158   ASSERT_TRUE(Ok);
unittests/Bitstream/BitstreamReaderTest.cpp
  123     ASSERT_TRUE((bool)MaybeRead);
  129     ASSERT_TRUE((bool)MaybeEntry);
  137     ASSERT_TRUE((bool)MaybeEntry);
  147     ASSERT_TRUE((bool)MaybeRecord);
  159     ASSERT_TRUE((bool)MaybeRead);
unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp
 1076   ASSERT_TRUE(Helper.widenScalar(*MIB, 0, LLT::scalar(64)) ==
 1087   ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
 1107   ASSERT_TRUE(Helper.narrowScalar(*MIB, 0, LLT::scalar(10)) ==
 1118   ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
 1137   ASSERT_TRUE(Helper.narrowScalar(*MIB, 0, LLT::scalar(8)) ==
 1150   ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
 1169   ASSERT_TRUE(Helper.lower(*MIB, 0, LLT()) ==
 1180   ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
unittests/CodeGen/LowLevelTypeTest.cpp
   28     ASSERT_TRUE(Ty.isValid());
   29     ASSERT_TRUE(Ty.isScalar());
   67       ASSERT_TRUE(VTy.isValid());
   68       ASSERT_TRUE(VTy.isVector());
  176       ASSERT_TRUE(Ty.isValid());
  177       ASSERT_TRUE(Ty.isPointer());
  182       ASSERT_TRUE(VTy.isValid());
  183       ASSERT_TRUE(VTy.isVector());
  184       ASSERT_TRUE(VTy.getElementType().isPointer());
unittests/CodeGen/MachineInstrBundleIteratorTest.cpp
  106   ASSERT_TRUE(MBI != I);
  107   ASSERT_TRUE(&MBI != I);
  108   ASSERT_TRUE(CMBI != I);
  109   ASSERT_TRUE(&CMBI != I);
  110   ASSERT_TRUE(I != MBI);
  111   ASSERT_TRUE(I != &MBI);
  112   ASSERT_TRUE(I != CMBI);
  113   ASSERT_TRUE(I != &CMBI);
  114   ASSERT_TRUE(MBI != CI);
  115   ASSERT_TRUE(&MBI != CI);
  116   ASSERT_TRUE(CMBI != CI);
  117   ASSERT_TRUE(&CMBI != CI);
  118   ASSERT_TRUE(CI != MBI);
  119   ASSERT_TRUE(CI != &MBI);
  120   ASSERT_TRUE(CI != CMBI);
  121   ASSERT_TRUE(CI != &CMBI);
  122   ASSERT_TRUE(MBI.getIterator() != I);
  123   ASSERT_TRUE(CMBI.getIterator() != I);
  124   ASSERT_TRUE(I != MBI.getIterator());
  125   ASSERT_TRUE(I != CMBI.getIterator());
  126   ASSERT_TRUE(MBI.getIterator() != CI);
  127   ASSERT_TRUE(CMBI.getIterator() != CI);
  128   ASSERT_TRUE(CI != MBI.getIterator());
  129   ASSERT_TRUE(CI != CMBI.getIterator());
unittests/CodeGen/MachineInstrTest.cpp
  199   ASSERT_TRUE(MI1->isIdenticalTo(*MI2, MachineInstr::IgnoreVRegDefs));
  200   ASSERT_TRUE(MI2->isIdenticalTo(*MI1, MachineInstr::IgnoreVRegDefs));
  337   ASSERT_TRUE(
  339   ASSERT_TRUE(
  352   ASSERT_TRUE(MIS.empty());
  356   ASSERT_TRUE(std::distance(MIS.begin(), MII) == 1);
  368   ASSERT_TRUE(MIS.empty());
  372   ASSERT_TRUE(std::distance(MIS.begin(), MII) == 1);
  391   ASSERT_TRUE(MI->memoperands_empty());
  397   ASSERT_TRUE(MI->memoperands().size() == 1);
  403   ASSERT_TRUE(MI->memoperands().size() == 1);
  404   ASSERT_TRUE(MI->getPreInstrSymbol() == Sym1);
  409   ASSERT_TRUE(MI->memoperands().size() == 1);
  410   ASSERT_TRUE(MI->getPreInstrSymbol() == Sym1);
  411   ASSERT_TRUE(MI->getPostInstrSymbol() == Sym2);
  415   ASSERT_TRUE(MI->memoperands().size() == 1);
  416   ASSERT_TRUE(MI->getPreInstrSymbol() == Sym1);
  417   ASSERT_TRUE(MI->getPostInstrSymbol() == Sym2);
  418   ASSERT_TRUE(MI->getHeapAllocMarker() == MDN);
  445   ASSERT_TRUE(MI->memoperands().size() == 2);
  446   ASSERT_TRUE(MI->getPreInstrSymbol() == Sym1);
  447   ASSERT_TRUE(MI->getPostInstrSymbol() == Sym2);
  448   ASSERT_TRUE(MI->getHeapAllocMarker() == MDN);
  451   ASSERT_TRUE(MI->memoperands().size() == 2);
  452   ASSERT_TRUE(MI->getPreInstrSymbol() == Sym1);
  453   ASSERT_TRUE(MI->getPostInstrSymbol() == Sym1);
  454   ASSERT_TRUE(MI->getHeapAllocMarker() == MDN);
  480   ASSERT_TRUE(MI->memoperands().size() == 2);
  481   ASSERT_TRUE(MI->getPreInstrSymbol() == Sym1);
  483   ASSERT_TRUE(MI->getHeapAllocMarker() == MDN);
  486   ASSERT_TRUE(MI->memoperands().size() == 2);
  487   ASSERT_TRUE(MI->getPreInstrSymbol() == Sym1);
  492   ASSERT_TRUE(MI->memoperands().size() == 2);
  498   ASSERT_TRUE(MI->memoperands_empty());
unittests/CodeGen/MachineOperandTest.cpp
   31   ASSERT_TRUE(MO.isImm());
   32   ASSERT_TRUE(MO.getImm() == 50);
   41   ASSERT_TRUE(MO.isTargetIndex());
   42   ASSERT_TRUE(MO.getIndex() == 74);
   43   ASSERT_TRUE(MO.getOffset() == 57);
   44   ASSERT_TRUE(MO.getTargetFlags() == 12);
   53   ASSERT_TRUE(MO.isRegMask());
   54   ASSERT_TRUE(MO.getRegMask() == &Dummy);
   61   ASSERT_TRUE(OS.str() == "<regmask ...>");
   73   ASSERT_TRUE(MO.isReg());
   74   ASSERT_TRUE(MO.getReg() == 1);
   75   ASSERT_TRUE(MO.getSubReg() == 5);
   82   ASSERT_TRUE(OS.str() == "$physreg1.subreg5");
   95   ASSERT_TRUE(MO.isCImm());
   96   ASSERT_TRUE(MO.getCImm() == CImm);
   97   ASSERT_TRUE(MO.getCImm()->getValue() == Int);
  104   ASSERT_TRUE(OS.str() == "i128 18446744073709551616");
  113   ASSERT_TRUE(MO.isImm());
  114   ASSERT_TRUE(MO.getImm() == 3);
  121   ASSERT_TRUE(OS.str() == "%subreg.3");
  130   ASSERT_TRUE(MO.isCPI());
  131   ASSERT_TRUE(MO.getIndex() == 0);
  132   ASSERT_TRUE(MO.getOffset() == 8);
  140     ASSERT_TRUE(OS.str() == "%const.0 + 8");
  152     ASSERT_TRUE(OS.str() == "%const.0 - 12");
  162   ASSERT_TRUE(MO.isTargetIndex());
  163   ASSERT_TRUE(MO.getIndex() == 0);
  164   ASSERT_TRUE(MO.getOffset() == 8);
  171     ASSERT_TRUE(OS.str() == "target-index(<unknown>) + 8");
  182     ASSERT_TRUE(OS.str() == "target-index(<unknown>) - 12");
  192   ASSERT_TRUE(MO.isJTI());
  193   ASSERT_TRUE(MO.getIndex() == 3);
  199   ASSERT_TRUE(OS.str() == "%jump-table.3");
  208   ASSERT_TRUE(MO.isSymbol());
  209   ASSERT_TRUE(MO.getSymbolName() == StringRef("foo"));
  216     ASSERT_TRUE(OS.str() == "&foo");
  226     ASSERT_TRUE(OS.str() == "&foo + 12");
  236     ASSERT_TRUE(OS.str() == "&foo - 12");
  253   ASSERT_TRUE(MO.isGlobal());
  254   ASSERT_TRUE(MO.getGlobal() == GV);
  255   ASSERT_TRUE(MO.getOffset() == 12);
  262     ASSERT_TRUE(OS.str() == "@foo + 12");
  272     ASSERT_TRUE(OS.str() == "@foo - 12");
  283   ASSERT_TRUE(MO.isRegLiveOut());
  284   ASSERT_TRUE(MO.getRegLiveOut() == &Mask);
  290   ASSERT_TRUE(OS.str() == "liveout(<unknown>)");
  307   ASSERT_TRUE(MO.isMetadata());
  308   ASSERT_TRUE(MO.getMetadata() == Node);
  316   ASSERT_TRUE(OS.str() == "!0");
  329   ASSERT_TRUE(MO.isMCSymbol());
  330   ASSERT_TRUE(MO.getMCSymbol() == Sym);
  336   ASSERT_TRUE(OS.str() == "<mcsymbol foo>");
  345   ASSERT_TRUE(MO.isCFIIndex());
  346   ASSERT_TRUE(MO.getCFIIndex() == 8);
  353   ASSERT_TRUE(OS.str() == "<cfi directive>");
  362   ASSERT_TRUE(MO.isIntrinsicID());
  363   ASSERT_TRUE(MO.getIntrinsicID() == Intrinsic::bswap);
  370     ASSERT_TRUE(OS.str() == "intrinsic(@llvm.bswap)");
  381     ASSERT_TRUE(OS.str() == "intrinsic(4294967295)");
  391   ASSERT_TRUE(MO.isPredicate());
  392   ASSERT_TRUE(MO.getPredicate() == CmpInst::ICMP_EQ);
  398   ASSERT_TRUE(OS.str() == "intpred(eq)");
  408   ASSERT_TRUE(MO1.isIdenticalTo(MO2));
unittests/CodeGen/ScalableVectorMVTsTest.cpp
   22     ASSERT_TRUE(VecTy.isValid());
   23     ASSERT_TRUE(VecTy.isInteger());
   24     ASSERT_TRUE(VecTy.isVector());
   25     ASSERT_TRUE(VecTy.isScalableVector());
   26     ASSERT_TRUE(VecTy.getScalarType().isValid());
   34     ASSERT_TRUE(VecTy.isValid());
   35     ASSERT_TRUE(VecTy.isFloatingPoint());
   36     ASSERT_TRUE(VecTy.isVector());
   37     ASSERT_TRUE(VecTy.isScalableVector());
   38     ASSERT_TRUE(VecTy.getScalarType().isValid());
   49   ASSERT_TRUE(Vnx4i32.isScalableVector());
   54   ASSERT_TRUE(Vnx2i32.isScalableVector());
   58   ASSERT_TRUE(Vnx2i64.isScalableVector());
   75   ASSERT_TRUE(EltCnt.Scalable);
   97   ASSERT_TRUE(Mnxv8i64.isScalableVector());
  104   ASSERT_TRUE(Enxv8i64.isScalableVector());
  117   ASSERT_TRUE(ScV4Float64Ty->isScalable());
unittests/CodeGen/TargetOptionsTest.cpp
   57   ASSERT_TRUE(TM->Options.EnableIPRA == EnableIPRA);
unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
 1043   ASSERT_TRUE((bool)Obj);
 1049   ASSERT_TRUE(DieDG.isValid());
 1055   ASSERT_TRUE((bool)Extracted1);
 1059   ASSERT_TRUE((bool)Form2);
 1062   ASSERT_TRUE((bool)Extracted2);
 1066   ASSERT_TRUE((bool)Form3);
 1069   ASSERT_TRUE((bool)Extracted3);
 1096   ASSERT_TRUE((bool)Obj);
 1383   ASSERT_TRUE((bool)ErrOrSections);
 1922   ASSERT_TRUE((bool)ErrOrSections);
 1971   ASSERT_TRUE((bool)ErrOrSections);
 2008   ASSERT_TRUE((bool)ErrOrSections);
 2045   ASSERT_TRUE((bool)ErrOrSections);
 2078   ASSERT_TRUE((bool)ErrOrSections);
 2126   ASSERT_TRUE((bool)ErrOrSections);
 2197   ASSERT_TRUE((bool)ErrOrSections);
 2269   ASSERT_TRUE((bool)ErrOrSections);
 2341   ASSERT_TRUE((bool)ErrOrSections);
 2418   ASSERT_TRUE((bool)ErrOrSections);
 2500   ASSERT_TRUE((bool)ErrOrSections);
 2603   ASSERT_TRUE((bool)ErrOrSections);
 2668   ASSERT_TRUE((bool)ErrOrSections);
 2725   ASSERT_TRUE((bool)ErrOrSections);
 2799   ASSERT_TRUE((bool)ErrOrSections);
 2849   ASSERT_TRUE((bool)ErrOrSections);
 2913   ASSERT_TRUE((bool)ErrOrSections);
 2980   ASSERT_TRUE((bool)ErrOrSections);
 2988   ASSERT_TRUE(Empty.contains(Empty));
 2993   ASSERT_TRUE(Ranges.contains(Empty));
 2999   ASSERT_TRUE(Ranges.contains({{{0x10, 0x10}}}));
 3000   ASSERT_TRUE(Ranges.contains({{{0x10, 0x11}}}));
 3001   ASSERT_TRUE(Ranges.contains({{{0x10, 0x20}}}));
 3004   ASSERT_TRUE(Ranges.contains({{{0x11, 0x12}}}));
 3007   ASSERT_TRUE(Ranges.contains({{{0x1f, 0x20}}}));
 3011   ASSERT_TRUE(Ranges.contains({{{0x20, 0x20}}}));
 3014   ASSERT_TRUE(Ranges.contains({{{0x31, 0x32}}}));
 3015   ASSERT_TRUE(Ranges.contains({{{0x3f, 0x40}}}));
 3016   ASSERT_TRUE(Ranges.contains({{{0x10, 0x20}, {0x30, 0x40}}}));
 3017   ASSERT_TRUE(Ranges.contains({{{0x11, 0x12}, {0x31, 0x32}}}));
 3018   ASSERT_TRUE(Ranges.contains(
 3027   ASSERT_TRUE(Ranges.contains({{{0x11, 0x12}, {0x30, 0x50}}}));
 3036   ASSERT_TRUE(LHS.intersects(RHS));
 3037   ASSERT_TRUE(RHS.intersects(LHS));
 3048   ASSERT_TRUE(LHS.intersects(RHS));
 3049   ASSERT_TRUE(RHS.intersects(LHS));
unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp
   96     ASSERT_TRUE(Err.operator bool());
  260   ASSERT_TRUE(ExpectedLineTable.operator bool());
  271   ASSERT_TRUE(ExpectedLineTable2.operator bool());
  284   ASSERT_TRUE(ExpectedLineTable3.operator bool());
  291   ASSERT_TRUE(ExpectedLineTable4.operator bool());
  478   ASSERT_TRUE(ExpectedLineTable.operator bool());
unittests/DebugInfo/GSYM/GSYMTest.cpp
   31   ASSERT_TRUE(bool(Err));
  246   ASSERT_TRUE(bool(ExpectedOffset));
  255   ASSERT_TRUE((bool)Decoded);
  330   ASSERT_TRUE((bool)Decoded);
  418   ASSERT_TRUE(InlineInfos);
  811   ASSERT_TRUE((bool)Decoded);
  823   ASSERT_TRUE(LT.empty());
  847   ASSERT_TRUE(LT.empty());
 1041   ASSERT_TRUE((bool)Decoded);
 1059   ASSERT_TRUE(bool(Err));
 1087   ASSERT_TRUE(bool(finalizeErr));
 1135   ASSERT_TRUE(bool(GR));
 1253   ASSERT_TRUE(bool(ExpFI));
unittests/ExecutionEngine/ExecutionEngineTest.cpp
   36     ASSERT_TRUE(Engine.get() != nullptr) << "EngineBuilder returned error: '"
unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp
   45   ASSERT_TRUE(ptr != 0) << "Unable to get pointer to function.";
   57   ASSERT_TRUE(ptr != 0) << "Unable to get pointer to function.";
unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp
   92     ASSERT_TRUE(bool(TheJIT));
   93     ASSERT_TRUE(nullptr != Main);
unittests/ExecutionEngine/MCJIT/MCJITTest.cpp
   69   ASSERT_TRUE(addPtr != 0) << "Unable to get pointer to function .";
unittests/FuzzMutate/OperationsTest.cpp
  191   ASSERT_TRUE(UncondBr->isUnconditional());
  239   ASSERT_TRUE(!verifyModule(*M, &errs()));
  326   ASSERT_TRUE(Descr.SourcePreds[0].matches({}, &*std::next(BB.begin())));
unittests/FuzzMutate/RandomIRBuilderTest.cpp
   73   ASSERT_TRUE(Descr.SourcePreds[0].matches(Srcs, Insts[1]));
   75   ASSERT_TRUE(Descr.SourcePreds[1].matches(Srcs, Insts[1]));
   82     ASSERT_TRUE(Descr.SourcePreds[2].matches(Srcs, LastSrc));
  113   ASSERT_TRUE(IVDescr.SourcePreds[0].matches({}, Src));
  127       ASSERT_TRUE(IVDescr.SourcePreds[2].matches(Srcs, Src));
  162     ASSERT_TRUE(!verifyModule(*M, &errs()));
  190   ASSERT_TRUE(Descr.SourcePreds[0].matches({}, Source));
  234     ASSERT_TRUE(!verifyModule(*M, &errs()));
unittests/FuzzMutate/ReservoirSamplerTest.cpp
   25   ASSERT_TRUE(Sampler.isEmpty());
unittests/FuzzMutate/StrategiesTest.cpp
   71     ASSERT_TRUE(M && !verifyModule(*M, &errs()));
   83   ASSERT_TRUE(M && !verifyModule(*M, &errs()));
   86   ASSERT_TRUE(Mutator);
  107   ASSERT_TRUE(Mutator);
  133   ASSERT_TRUE(Mutator);
unittests/IR/ConstantsTest.cpp
  427     ASSERT_TRUE(dyn_cast<ConstantDataArray>(CDV) != nullptr)
  436     ASSERT_TRUE(dyn_cast<ConstantDataArray>(CDV) != nullptr)
  449     ASSERT_TRUE(dyn_cast<ConstantDataVector>(CDV) != nullptr)
  457     ASSERT_TRUE(dyn_cast<ConstantDataVector>(CDV) != nullptr)
  515   ASSERT_TRUE(foldFuncPtrAndConstToNull(Context, &TheModule, 2));
  532       ASSERT_TRUE(foldFuncPtrAndConstToNull(Context, &TheModule, AndValue));
  552   ASSERT_TRUE(foldFuncPtrAndConstToNull(Context, &TheModule, 2, Align(4)));
  584   ASSERT_TRUE(ConstantExpr::get( \
unittests/IR/DominatorTreeBatchUpdatesTest.cpp
  106   ASSERT_TRUE(Builder.applyUpdate());
  128   ASSERT_TRUE(Builder.applyUpdate());
unittests/IR/DominatorTreeTest.cpp
  388         ASSERT_TRUE(PDT->dominates(PDT->getNode(D), PDT->getNode(B)));
  482         ASSERT_TRUE(PDT->dominates(PDT->getNode(D), PDT->getNode(B)));
unittests/IR/IRBuilderTest.cpp
  188   ASSERT_TRUE(isa<IntrinsicInst>(V));
  193   ASSERT_TRUE(isa<IntrinsicInst>(V));
  198   ASSERT_TRUE(isa<IntrinsicInst>(V));
  203   ASSERT_TRUE(isa<IntrinsicInst>(V));
  208   ASSERT_TRUE(isa<IntrinsicInst>(V));
  213   ASSERT_TRUE(isa<IntrinsicInst>(VInt));
  218   ASSERT_TRUE(isa<IntrinsicInst>(VInt));
  223   ASSERT_TRUE(isa<IntrinsicInst>(V));
  228   ASSERT_TRUE(isa<IntrinsicInst>(VDouble));
  243   ASSERT_TRUE(isa<ConstrainedFPIntrinsic>(V));
  245   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebStrict);
  246   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDynamic);
  252   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebIgnore);
  253   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmUpward);
  259   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebIgnore);
  260   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmToNearest);
  266   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebMayTrap);
  267   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDownward);
  273   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebStrict);
  274   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmTowardZero);
  280   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebIgnore);
  281   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDynamic);
  289   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebMayTrap);
  290   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDownward);
  321   ASSERT_TRUE(II_Start1 != nullptr);
  323   ASSERT_TRUE(II_End1 != nullptr);
  382   ASSERT_TRUE(isa<Instruction>(U));
  383   ASSERT_TRUE(isa<FPMathOperator>(U));
  384   ASSERT_TRUE(isa<UnaryOperator>(U));
  407   ASSERT_TRUE(isa<Instruction>(F));
  417   ASSERT_TRUE(isa<Instruction>(F));
  444   ASSERT_TRUE(isa<Instruction>(F));
  452   ASSERT_TRUE(isa<Instruction>(F));
  459   ASSERT_TRUE(isa<Instruction>(F));
  467   ASSERT_TRUE(isa<Instruction>(F));
  479   ASSERT_TRUE(isa<Instruction>(F));
  486   ASSERT_TRUE(isa<Instruction>(FC));
  497   ASSERT_TRUE(isa<Instruction>(FC));
  505   ASSERT_TRUE(isa<Instruction>(FC));
  516   ASSERT_TRUE(isa<Instruction>(FC));
  572   ASSERT_TRUE(isa<Instruction>(F));
unittests/IR/InstructionsTest.cpp
  607     ASSERT_TRUE(UI->isExact());
  615     ASSERT_TRUE(ShrI->isExact());
  623     ASSERT_TRUE(AI->hasNoUnsignedWrap());
  632     ASSERT_TRUE(SI->hasNoSignedWrap());
  641     ASSERT_TRUE(ShlI->hasNoSignedWrap());
  642     ASSERT_TRUE(ShlI->hasNoUnsignedWrap());
  652     ASSERT_TRUE(GI->isInBounds());
  670   ASSERT_TRUE(isa<GetElementPtrInst>(V));
 1024   ASSERT_TRUE(M);
unittests/IR/MetadataTest.cpp
  449   ASSERT_TRUE(Empty->isResolved());
  456   ASSERT_TRUE(Wrapped1->isResolved());
  463   ASSERT_TRUE(Wrapped2->isResolved());
  483   ASSERT_TRUE(N->isUniqued());
  501   ASSERT_TRUE(N->isDistinct());
  510   ASSERT_TRUE(Empty->isResolved());
  740   ASSERT_TRUE(N->isUniqued());
  744   ASSERT_TRUE(N->isDistinct());
  763   ASSERT_TRUE(N->isUniqued());
  769   ASSERT_TRUE(N->isUniqued());
 1105   ASSERT_TRUE(N->isUniqued());
 1113   ASSERT_TRUE(N->isUniqued());
 1122   ASSERT_TRUE(N->isUniqued());
 1142   ASSERT_TRUE(Count);
 1143   ASSERT_TRUE(Count.is<ConstantInt*>());
 1157   ASSERT_TRUE(Count);
 1158   ASSERT_TRUE(Count.is<ConstantInt*>());
 1174   ASSERT_TRUE(Count);
 1175   ASSERT_TRUE(Count.is<DIVariable*>());
 1177   ASSERT_TRUE(isa<DIVariable>(N->getRawCountNode()));
 2534   ASSERT_TRUE(GV0->use_empty());
 2595   ASSERT_TRUE(GV0->use_empty());
 2612   ASSERT_TRUE(GV->use_empty());
 2730   ASSERT_TRUE(F->isMaterializable());
unittests/IR/UseTest.cpp
   41   ASSERT_TRUE(F);
   42   ASSERT_TRUE(F->arg_begin() != F->arg_end());
   86   ASSERT_TRUE(F);
   87   ASSERT_TRUE(F->arg_begin() != F->arg_end());
unittests/IR/ValueHandleTest.cpp
  331       ASSERT_TRUE(nullptr != getValPtr());
unittests/IR/ValueMapTest.cpp
   72   ASSERT_TRUE(I != VM.end());
   81   ASSERT_TRUE(CI != CVM.end());
unittests/IR/ValueTest.cpp
  130   ASSERT_TRUE(F);
  136   ASSERT_TRUE(I0);
  138   ASSERT_TRUE(I1);
  141   ASSERT_TRUE(G0);
  143   ASSERT_TRUE(G1);
  205   ASSERT_TRUE(F);
  210   ASSERT_TRUE(BB2);
  213   ASSERT_TRUE(I0);
  215   ASSERT_TRUE(I1);
  240   ASSERT_TRUE(F);
  243   ASSERT_TRUE(BB2);
unittests/IR/VectorTypesTest.cpp
  100   ASSERT_TRUE(ScV8Int32Ty->isScalable());
  105   ASSERT_TRUE(ScV8Int16Ty->isScalable());
  111   ASSERT_TRUE(ScV4Int64Ty->isScalable());
  116   ASSERT_TRUE(ScV2Int64Ty->isScalable());
  121   ASSERT_TRUE(ScV8Int64Ty->isScalable());
  126   ASSERT_TRUE(ScV4Float64Ty->isScalable());
  132   ASSERT_TRUE(ExtTy->isScalable());
  138   ASSERT_TRUE(TruncTy->isScalable());
  144   ASSERT_TRUE(HalvedTy->isScalable());
  150   ASSERT_TRUE(DoubledTy->isScalable());
  156   ASSERT_TRUE(ConvTy->isScalable());
  162   ASSERT_TRUE(EltCnt.Scalable);
  211   ASSERT_TRUE(DL.typeSizeEqualsStoreSize(V4Int32Ty));
  255   ASSERT_TRUE(DL.typeSizeEqualsStoreSize(ScV4Int32Ty));
unittests/IR/WaymarkTest.cpp
   45   ASSERT_TRUE(many);
unittests/Linker/LinkModulesTest.cpp
  116   ASSERT_TRUE(isa<BlockAddress>(Elem));
  123   ASSERT_TRUE(isa<BlockAddress>(Elem));
  254   ASSERT_TRUE(Src.get());
  281   ASSERT_TRUE(Dst.get());
  334   ASSERT_TRUE(Foo.get());
  337   ASSERT_TRUE(Foo->getFunction("llvm.memset.p0s_struct.rtx_defs.i32"));
  342   ASSERT_TRUE(Bar.get());
  346   ASSERT_TRUE(Bar->getFunction("llvm.memset.p0s_struct.rtx_def.0s.i32"));
  350   ASSERT_TRUE(Dst.get());
unittests/MI/LiveIntervalTest.cpp
  152   ASSERT_TRUE(M);
unittests/ObjectYAML/YAML2ObjTest.cpp
   35   ASSERT_TRUE(Obj);
   36   ASSERT_TRUE(Obj->isELF());
   37   ASSERT_TRUE(Obj->isRelocatableObject());
   65   ASSERT_TRUE(Errors.size() == 2);
   66   ASSERT_TRUE(Errors[0] == "ObjectYAML: repeated symbol name: 'foo'");
   67   ASSERT_TRUE(Errors[1] == Errors[0]);
   78   ASSERT_TRUE(Errors.size() == 2);
   79   ASSERT_TRUE(Errors[0] == "ObjectYAML: repeated symbol name: 'foo'");
   80   ASSERT_TRUE(Errors[1] == Errors[0]);
unittests/Passes/PluginsTest.cpp
   50   ASSERT_TRUE(!!Plugin) << "Plugin path: " << PluginPath;
unittests/ProfileData/CoverageMappingTest.cpp
  326     ASSERT_TRUE(!Data.empty());
unittests/ProfileData/InstrProfTest.cpp
   65   ASSERT_TRUE(Reader->begin() == Reader->end());
   79   ASSERT_TRUE(I != E);
   87   ASSERT_TRUE(++I == E);
  109   ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, R.takeError()));
  112   ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function, R.takeError()));
  135   ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, std::move(E1)));
  138   ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function, std::move(E2)));
  184   ASSERT_TRUE(MD);
  186   ASSERT_TRUE(PSFromMD);
  194   ASSERT_TRUE(MD);
  196   ASSERT_TRUE(PSFromMD);
  309   ASSERT_TRUE(Res);
  321   ASSERT_TRUE(Res);
  335   ASSERT_TRUE(Res);
  358   ASSERT_TRUE(Res);
  614   ASSERT_TRUE(bool(ReadRecord2));
  916     ASSERT_TRUE(F != nullptr);
 1041   ASSERT_TRUE(I == E);
unittests/ProfileData/SampleProfTest.cpp
   49     ASSERT_TRUE(NoError(WriterOrErr.getError()));
   56     ASSERT_TRUE(NoError(ReaderOrErr.getError()));
   64     ASSERT_TRUE(NoError(EC));
   80     ASSERT_TRUE(NoError(llvm::sys::fs::createTemporaryFile("profile", "", ProfilePath)));
  152     ASSERT_TRUE(NoError(EC));
  158     ASSERT_TRUE(NoError(EC));
  168     ASSERT_TRUE(ReadFooSamples != nullptr);
  176     ASSERT_TRUE(ReadBarSamples != nullptr);
  192       ASSERT_TRUE(ReadBazSamples == nullptr);
  195       ASSERT_TRUE(ReadBazSamples != nullptr);
  201     ASSERT_TRUE(ReadBooSamples != nullptr);
  244     ASSERT_TRUE(MD);
  246     ASSERT_TRUE(PS);
  253     ASSERT_TRUE(MD);
  255     ASSERT_TRUE(PS);
  305     ASSERT_TRUE(NoError(EC));
  315     ASSERT_TRUE(NoError(EC));
  321     ASSERT_TRUE(NoError(EC));
unittests/Support/CachePruningTest.cpp
   17   ASSERT_TRUE(bool(P));
   25   ASSERT_TRUE(bool(P));
   28   ASSERT_TRUE(bool(P));
   31   ASSERT_TRUE(bool(P));
   37   ASSERT_TRUE(bool(P));
   43   ASSERT_TRUE(bool(P));
   50   ASSERT_TRUE(bool(P));
   54   ASSERT_TRUE(bool(P));
   58   ASSERT_TRUE(bool(P));
   62   ASSERT_TRUE(bool(P));
   69   ASSERT_TRUE(bool(P));
unittests/Support/CommandLineTest.cpp
   92   ASSERT_TRUE(Map.count("test-option") == 1) <<
unittests/Support/FileCheckTest.cpp
   24   ASSERT_TRUE(bool(Value));
   30   ASSERT_TRUE(bool(Value));
   77   ASSERT_TRUE(bool(Value));
   80   ASSERT_TRUE(bool(EvalResult));
  105   ASSERT_TRUE(bool(Value));
  149   ASSERT_TRUE(bool(ParsedVarResult));
  156   ASSERT_TRUE(bool(ParsedVarResult));
  163   ASSERT_TRUE(bool(ParsedVarResult));
  178   ASSERT_TRUE(bool(ParsedVarResult));
  185   ASSERT_TRUE(bool(ParsedVarResult));
  192   ASSERT_TRUE(bool(ParsedVarResult));
  199   ASSERT_TRUE(bool(ParsedVarResult));
  206   ASSERT_TRUE(bool(ParsedVarResult));
  428   ASSERT_TRUE(bool(SubstValue));
  431   ASSERT_TRUE(bool(SubstValue));
  449   ASSERT_TRUE(bool(SubstValue));
  523   ASSERT_TRUE(bool(LocalVar));
  527   ASSERT_TRUE(bool(ExpressionAST));
  529   ASSERT_TRUE(bool(ExpressionVal));
  535   ASSERT_TRUE(bool(ExpressionAST));
  537   ASSERT_TRUE(bool(ExpressionVal));
  539   ASSERT_TRUE(bool(EmptyVar));
  556   ASSERT_TRUE(bool(ExpressionAST));
  562   ASSERT_TRUE(bool(ExpressionAST));
  578   ASSERT_TRUE(bool(GlobalVar));
  584   ASSERT_TRUE(bool(ExpressionAST));
  586   ASSERT_TRUE(bool(ExpressionVal));
  596   ASSERT_TRUE(bool(ExpressionAST));
  598   ASSERT_TRUE(bool(ExpressionVal));
unittests/Support/FileCollectorTest.cpp
  179   ASSERT_TRUE(IsDirectory);
unittests/Support/JSONTest.cpp
  235   ASSERT_TRUE(O);
  246   ASSERT_TRUE(O->getObject("object"));
  250   ASSERT_TRUE(A);
  252   ASSERT_TRUE((*A)[4].getAsArray());
  259       ASSERT_TRUE(E.getAsObject());
  375   ASSERT_TRUE(fromJSON(J, R));
unittests/Support/ParallelTest.cpp
   34   ASSERT_TRUE(std::is_sorted(std::begin(array), std::end(array)));
   47   ASSERT_TRUE(std::equal(range, range + 2049, expected));
unittests/Support/Path.cpp
  509   ASSERT_TRUE(fs::exists(Twine(TestDirectory) + "/test1/test2/test3"));
  574   ASSERT_TRUE(fs::exists(Twine(TestDirectory) + "/noreadperm"));
  590   ASSERT_TRUE((bool)TempFileOrError);
  595   ASSERT_TRUE(fs::exists(TestDirectory + "/keep"));
  602   ASSERT_TRUE((bool)TempFileOrError);
  618   ASSERT_TRUE(sys::fs::exists(Twine(TempPath)));
  624   ASSERT_TRUE(TempPath2.endswith(".temp"));
 1264   ASSERT_TRUE(sys::fs::exists(Twine(TempPath)));
 1321   ASSERT_TRUE(fs::exists(Path));
 1328   ASSERT_TRUE((bool)Buffer);
 1340   ASSERT_TRUE(fs::exists(NonExistantFile));
 1368   ASSERT_TRUE(fs::exists(NonExistantFile));
 1573   ASSERT_TRUE(sys::fs::exists(Twine(TempPath)));
 1610   ASSERT_TRUE(!!Perms);
 1616   ASSERT_TRUE(!!Perms);
 1622   ASSERT_TRUE(!!Perms);
 1631   ASSERT_TRUE(!!Perms);
 1669   ASSERT_TRUE(fs::exists(Twine(TempPath)));
unittests/Support/ProgramTest.cpp
   77     ASSERT_TRUE(EnvP);
  222     ASSERT_TRUE(Error.empty());
  239     ASSERT_TRUE(Error.empty());
  280     ASSERT_TRUE(RetCode < 0) << "On error ExecuteAndWait should return 0 or "
  282     ASSERT_TRUE(ExecutionFailed);
  293     ASSERT_TRUE(ExecutionFailed);
unittests/Support/ReplaceFileTest.cpp
  111   ASSERT_TRUE(fs::exists(SourceFileName));
unittests/Support/Threading.cpp
   59     ASSERT_TRUE(ThreadAdvanced.wait());
   64   ASSERT_TRUE(ThreadStarted.wait());
   66   ASSERT_TRUE(ThreadFinished.wait());
unittests/Support/VirtualFileSystemTest.cpp
  379     ASSERT_TRUE(Status.getError());
  406     ASSERT_TRUE(Status.getError());
  524   ASSERT_TRUE(BBuf);
  528   ASSERT_TRUE(ABuf);
  533   ASSERT_TRUE(BStat);
  537   ASSERT_TRUE(AStat);
  625     ASSERT_TRUE(Index >= 0 && Index < 4);
  700       ASSERT_TRUE(Index >= 0 && Index < 7);
 1026   ASSERT_TRUE(FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a")));
 1028   ASSERT_TRUE(FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a")));
 1117   ASSERT_TRUE(Stat->isDirectory());
 1121   ASSERT_TRUE(Stat->isDirectory());
 1125   ASSERT_TRUE(Stat->isRegularFile());
 1134   ASSERT_TRUE(Stat->isDirectory());
 1137   ASSERT_TRUE(Stat->isDirectory());
 1142   ASSERT_TRUE(Stat->isRegularFile());
 1152   ASSERT_TRUE(Stat->isDirectory());
 1155   ASSERT_TRUE(Stat->isDirectory());
 1167   ASSERT_TRUE(Stat->isDirectory());
 1173   ASSERT_TRUE(Stat->isDirectory());
 1179   ASSERT_TRUE(Stat->isRegularFile());
 1191   ASSERT_TRUE(Stat->isDirectory());
 1194   ASSERT_TRUE(Stat->isRegularFile());
 1209   ASSERT_TRUE(Stat->isRegularFile());
 1219   ASSERT_TRUE(Stat->isRegularFile());
 1402   ASSERT_TRUE(FS.get() != nullptr);
 1456   ASSERT_TRUE(FS.get() != nullptr);
 1492   ASSERT_TRUE(FS.get() != nullptr);
 1617   ASSERT_TRUE(nullptr != FS.get());
 1641   ASSERT_TRUE(nullptr != FS.get());
 1661   ASSERT_TRUE(nullptr != FS.get());
 1675   ASSERT_TRUE(nullptr != FS.get());
 1689   ASSERT_TRUE(nullptr != FS.get());
 1708   ASSERT_TRUE(nullptr != FS.get());
 1744   ASSERT_TRUE(FS.get() != nullptr);
 1794   ASSERT_TRUE(FS.get() != nullptr);
 1829   ASSERT_TRUE(FS.get() != nullptr);
 1905   ASSERT_TRUE(FS.get() != nullptr);
 1933   ASSERT_TRUE(FS.get() != nullptr);
 1962   ASSERT_TRUE(FS.get() != nullptr);
 1995   ASSERT_TRUE(FS.get() != nullptr);
 2037   ASSERT_TRUE(FS.get() != nullptr);
 2042   ASSERT_TRUE(WorkingDir);
 2055   ASSERT_TRUE(EC);
 2057   ASSERT_TRUE(WorkingDir);
 2063   ASSERT_TRUE(WorkingDir);
 2069   ASSERT_TRUE(WorkingDir);
 2096   ASSERT_TRUE(FS.get() != nullptr);
 2099   ASSERT_TRUE(FS.get() != nullptr);
 2117   ASSERT_TRUE(Status.getError());
 2120   ASSERT_TRUE(Status.getError());
 2153   ASSERT_TRUE(FS.get() != nullptr);
 2156   ASSERT_TRUE(FS.get() != nullptr);
 2163   ASSERT_TRUE(Status.getError());
unittests/Support/YAMLIOTest.cpp
 2965     ASSERT_TRUE(seq);
 2968     ASSERT_TRUE(first);
 2972     ASSERT_TRUE(second);
 2997     ASSERT_TRUE(map);
 2999     ASSERT_TRUE(foo);
 3003     ASSERT_TRUE(bar);
unittests/Target/AArch64/InstSizes.cpp
   60   ASSERT_TRUE(MParser);
   63   ASSERT_TRUE(M);
   73   ASSERT_TRUE(F != nullptr);
   83   ASSERT_TRUE(TM);
unittests/Target/WebAssembly/WebAssemblyExceptionInfoTest.cpp
   68   ASSERT_TRUE(TM);
  161   ASSERT_TRUE(M);
  165   ASSERT_TRUE(MF);
  182   ASSERT_TRUE(WE0);
  189   ASSERT_TRUE(WE0_0);
  196   ASSERT_TRUE(WE0_0);
  201   ASSERT_TRUE(WE0_0);
  206   ASSERT_TRUE(WE0_0);
  211   ASSERT_TRUE(WE0_0);
  216   ASSERT_TRUE(WE0_0_0);
  223   ASSERT_TRUE(WE0_1);
  231   ASSERT_TRUE(TM);
  336   ASSERT_TRUE(M);
  340   ASSERT_TRUE(MF);
  357   ASSERT_TRUE(WE0);
  364   ASSERT_TRUE(WE0);
  369   ASSERT_TRUE(WE0);
  374   ASSERT_TRUE(WE0);
  379   ASSERT_TRUE(WE0_0);
  386   ASSERT_TRUE(WE0_0);
  391   ASSERT_TRUE(WE0_0);
  396   ASSERT_TRUE(WE0_0);
  401   ASSERT_TRUE(WE0_0);
  406   ASSERT_TRUE(WE0_0_0);
  413   ASSERT_TRUE(WE0_1);
unittests/Target/X86/MachineSizeOptsTest.cpp
   94   ASSERT_TRUE(F != nullptr);
   96   ASSERT_TRUE(G != nullptr);
   98   ASSERT_TRUE(H != nullptr);
  100   ASSERT_TRUE(PSI.hasProfileSummary());
  113   ASSERT_TRUE(iter == BB0.succ_end());
  115   ASSERT_TRUE(BB3 == *BB2->succ_begin());
unittests/Transforms/Utils/LocalTest.cpp
  144   ASSERT_TRUE(GV);
  146   ASSERT_TRUE(F);
  149   ASSERT_TRUE(AI);
  151   ASSERT_TRUE(Inst);
  153   ASSERT_TRUE(DII);
  520     ASSERT_TRUE(GV);
  522     ASSERT_TRUE(F);
  555         ASSERT_TRUE(I.isTerminator());
  562     ASSERT_TRUE(FoundX);
  563     ASSERT_TRUE(FoundY);
  570   ASSERT_TRUE(Inst);
  572   ASSERT_TRUE(Deleted);
  578   ASSERT_TRUE(BB);
  580   ASSERT_TRUE(Deleted);
  619   ASSERT_TRUE(isa<ReturnInst>(&A));
  626   ASSERT_TRUE(isa<UnreachableInst>(&B));
unittests/Transforms/Utils/ValueMapperTest.cpp
   89   ASSERT_TRUE(N0->isResolved());
   90   ASSERT_TRUE(N1->isResolved());
unittests/XRay/GraphTest.cpp
   72     ASSERT_TRUE(!!EVV);
   98     ASSERT_TRUE(!!EEV);
unittests/tools/llvm-exegesis/ClusteringTest.cpp
   51   ASSERT_TRUE((bool)Clustering);
   80   ASSERT_TRUE((bool)Error);
   92   ASSERT_TRUE((bool)Error);
  122   ASSERT_TRUE((bool)Clustering);
  139   ASSERT_TRUE((bool)Clustering);
unittests/tools/llvm-exegesis/PerfHelperTest.cpp
   42   ASSERT_TRUE(pfmInitialize());