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

References

tools/clang/tools/extra/clangd/unittests/ASTTests.cpp
   17   ASSERT_EQ("TestClass", shortenNamespace("TestClass", ""));
   19   ASSERT_EQ("TestClass", shortenNamespace(
   22   ASSERT_EQ(
   26   ASSERT_EQ("TestClass",
   30   ASSERT_EQ(
   34   ASSERT_EQ("TestClass<testns1::OtherClass>",
tools/clang/tools/extra/clangd/unittests/CanonicalIncludesTests.cpp
   75   ASSERT_EQ("<path>", CI.mapHeader("some/path", ""));
   77   ASSERT_EQ("<vector>", CI.mapHeader("bits/stl_vector.h", ""));
   79   ASSERT_EQ("<map>", CI.mapHeader("some/header.h", "std::map"));
tools/clang/tools/extra/clangd/unittests/ClangdTests.cpp
  759       ASSERT_EQ(Stats[I].HadErrorsInLastDiags,
  826   ASSERT_EQ(DiagConsumer.Count, 2); // Sanity check - we actually ran both?
tools/clang/tools/extra/clangd/unittests/CodeCompleteTests.cpp
 2158   ASSERT_EQ(Reqs1.size(), 1u);
 2164   ASSERT_EQ(Reqs2.size(), 1u);
 2171   ASSERT_EQ(Reqs3.size(), 2u);
tools/clang/tools/extra/clangd/unittests/HeaderSourceSwitchTests.cpp
   34   ASSERT_EQ(PathResult.getValue(), FooH);
   38   ASSERT_EQ(PathResult.getValue(), FooCpp);
   49   ASSERT_EQ(PathResult.getValue(), FooHH);
   58   ASSERT_EQ(PathResult.getValue(), Foo2HH);
   68   ASSERT_EQ(PathResult.getValue(), Foo3HXX);
tools/clang/tools/extra/clangd/unittests/SelectionTests.cpp
  331   ASSERT_EQ("CXXRecordDecl", nodeKind(T.commonAncestor())) << T;
tools/clang/tools/extra/clangd/unittests/SemanticHighlightingTests.cpp
  638   ASSERT_EQ(DiagConsumer.Count, 1);
tools/clang/tools/extra/clangd/unittests/TUSchedulerTests.cpp
  490   ASSERT_EQ(BuiltASTCounter.load(), 1);
  499   ASSERT_EQ(BuiltASTCounter.load(), 3);
  508   ASSERT_EQ(BuiltASTCounter.load(), 4);
tools/clang/tools/extra/clangd/unittests/ThreadingTests.cpp
   50       ASSERT_EQ(Counter, TasksCnt * IncrementsPerTask);
   61   ASSERT_EQ(Counter, TasksCnt * IncrementsPerTask);
tools/clang/tools/extra/clangd/unittests/TraceTests.cpp
  121   ASSERT_EQ(++Event, Events->end());
  122   ASSERT_EQ(++Prop, Root->end());
tools/clang/tools/extra/unittests/clang-doc/ClangDocTest.cpp
   47   ASSERT_EQ(Expected.AttrKeys.size(), Actual.AttrKeys.size());
   51   ASSERT_EQ(Expected.AttrValues.size(), Actual.AttrValues.size());
   55   ASSERT_EQ(Expected.Args.size(), Actual.Args.size());
   59   ASSERT_EQ(Expected.Children.size(), Actual.Children.size());
   88   ASSERT_EQ(Expected->Namespace.size(), Actual->Namespace.size());
   91   ASSERT_EQ(Expected->Description.size(), Actual->Description.size());
  103   ASSERT_EQ(Expected->Loc.size(), Actual->Loc.size());
  115   ASSERT_EQ(Expected->Params.size(), Actual->Params.size());
  126   ASSERT_EQ(Expected->Members.size(), Actual->Members.size());
  134   ASSERT_EQ(Expected->ChildNamespaces.size(), Actual->ChildNamespaces.size());
  139   ASSERT_EQ(Expected->ChildRecords.size(), Actual->ChildRecords.size());
  143   ASSERT_EQ(Expected->ChildFunctions.size(), Actual->ChildFunctions.size());
  148   ASSERT_EQ(Expected->ChildEnums.size(), Actual->ChildEnums.size());
  160   ASSERT_EQ(Expected->Members.size(), Actual->Members.size());
  164   ASSERT_EQ(Expected->Parents.size(), Actual->Parents.size());
  168   ASSERT_EQ(Expected->VirtualParents.size(), Actual->VirtualParents.size());
  172   ASSERT_EQ(Expected->Bases.size(), Actual->Bases.size());
  176   ASSERT_EQ(Expected->ChildRecords.size(), Actual->ChildRecords.size());
  180   ASSERT_EQ(Expected->ChildFunctions.size(), Actual->ChildFunctions.size());
  185   ASSERT_EQ(Expected->ChildEnums.size(), Actual->ChildEnums.size());
  200   ASSERT_EQ(Expected.Children.size(), Actual.Children.size());
tools/clang/tools/extra/unittests/clang-doc/SerializeTest.cpp
   70   ASSERT_EQ(NumExpectedInfos, EmittedInfos.size());
   80   ASSERT_EQ(NumExpectedInfos, EmittedInfos.size());
tools/clang/tools/extra/unittests/clang-query/QueryParserTest.cpp
  177   ASSERT_EQ(8u, Comps.size());
  196   ASSERT_EQ(1u, Comps.size());
  201   ASSERT_EQ(1u, Comps.size());
  206   ASSERT_EQ(4u, Comps.size());
  218   ASSERT_EQ(1u, Comps.size());
  224   ASSERT_EQ(1u, Comps.size());
  229   ASSERT_EQ(1u, Comps.size());
tools/clang/unittests/AST/ASTImporterGenericRedeclTest.cpp
  120     ASSERT_EQ(&Prev->getASTContext(), &Current->getASTContext());
  381     ASSERT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 3u);
tools/clang/unittests/AST/ASTImporterTest.cpp
  260   ASSERT_EQ(Redecls.size(), 1u);
  272   ASSERT_EQ(Redecls.size(), 3u);
  401   ASSERT_EQ(i, 2);
  418   ASSERT_EQ(i, 4);
  439   ASSERT_EQ(i, 4);
  453   ASSERT_EQ(i, 3);
 1258   ASSERT_EQ(ToTemplated1, ToTemplated);
 1670   ASSERT_EQ(1u, DeclCounterWithPredicate<ClassTemplateDecl>(
 1708   ASSERT_EQ(2u, DeclCounter<CXXRecordDecl>().match(
 1803   ASSERT_EQ(1u, DeclCounterWithPredicate<ClassTemplateSpecializationDecl>(
 2057   ASSERT_EQ(Proto->size_overridden_methods(), 1u);
 2089   ASSERT_EQ(1u,
 2346   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, functionDecl(hasName("f"))),
 2532   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
 2550   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
 2568   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
 2586   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
 2609   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
 2638   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
 2668   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
 2687     ASSERT_EQ(LookupRes.size(), 0u);
 2689     ASSERT_EQ(LookupRes.size(), 1u);
 2734   ASSERT_EQ(LookupRes.size(), 0u);
 2736   ASSERT_EQ(LookupRes.size(), 1u);
 2749   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, FunctionPattern), 2u);
 2779   ASSERT_EQ(LookupRes.size(), 0u);
 2781   ASSERT_EQ(LookupRes.size(), 1u);
 2821   ASSERT_EQ(LookupRes.size(), 1u);
 2823   ASSERT_EQ(LookupRes.size(), 1u);
 2860     ASSERT_EQ(Fr, FromFriend);
 2863   ASSERT_EQ(FrN, 1u);
 3023     ASSERT_EQ(DeclCounter<CXXMethodDecl>().match(ToClass, MethodMatcher), 1u);
 3032     ASSERT_EQ(DeclCounter<CXXMethodDecl>().match(ToClass, MethodMatcher), 0u);
 3590   ASSERT_EQ(FromDWithDef->getPreviousDecl(), FromDWithInit);
 3615   ASSERT_EQ(FromDWithInit, FromDWithDef->getPreviousDecl());
 3646   ASSERT_EQ(FromDDeclarationOnly, FromDWithDef->getPreviousDecl());
 3745   ASSERT_EQ(FromFriendClass->getDefinition(), FromClass);
 3746   ASSERT_EQ(FromFriendClass->getPreviousDecl(), FromClass);
 3747   ASSERT_EQ(FromFriendClass->getDescribedClassTemplate()->getPreviousDecl(),
 4029   ASSERT_EQ(L.getAsDecl(), A1);
 4037   ASSERT_EQ(1u, L.getAsVector()->size());
 4138     ASSERT_EQ(SpecD, FirstSpecD);
 4265   ASSERT_EQ(FromD->getNumTemplateParameterLists(), 1u);
 4279   ASSERT_EQ(Res.size(), 1u);
 4307   ASSERT_EQ(cast<Decl>(FooLexicalDC), X->getTemplatedDecl());
 4308   ASSERT_EQ(cast<Decl>(FooDC), ToTU);
 4329   ASSERT_EQ(Res.size(), 1u);
 4343   ASSERT_EQ(cast<Decl>(FooLexicalDC), A);
 4344   ASSERT_EQ(cast<Decl>(FooDC), ToTU);
 4365   ASSERT_EQ(Res.size(), 1u);
 4383   ASSERT_EQ(Res.size(), 1u);
 4388   ASSERT_EQ(Res.size(), 1u);
 4393   ASSERT_EQ(Res.size(), 1u);
 4470   ASSERT_EQ(Res.size(), 1u);
 4475   ASSERT_EQ(Res.size(), 0u);
 4611   ASSERT_EQ(Res.size(), 3u);
 4669   ASSERT_EQ(Res.size(), 1u);
 4678   ASSERT_EQ(Res.size(), 1u);
 4719   ASSERT_EQ(RD0, RD1);
 4720   ASSERT_EQ(RD1, X);
 4745   ASSERT_EQ(E->getRedeclContext(), ToTU);
 4758   ASSERT_EQ(Res.size(), 1u);
 4763   ASSERT_EQ(Res.size(), 1u);
 4784   ASSERT_EQ(Res.size(), 1u);
 4814   ASSERT_EQ(FromFwd->getCanonicalDecl(), FromDef->getCanonicalDecl());
 5334   ASSERT_EQ(ToClassDef->getMostRecentDecl(), ToClassDef);
 5335   ASSERT_EQ(ToClassProto->getMostRecentDecl(), ToClassProto);
 5344   ASSERT_EQ(FromClassDef->getMostRecentDecl(), FromClassDef);
 5345   ASSERT_EQ(FromClassProto->getMostRecentDecl(), FromClassProto);
 5566   ASSERT_EQ(
 5590   ASSERT_EQ(
tools/clang/unittests/AST/ASTVectorTest.cpp
   55   ASSERT_EQ(V.begin(), I);
   59   ASSERT_EQ(V.begin() + 1, I);
   63   ASSERT_EQ(V.end() - 5, I);
   73   ASSERT_EQ(V.begin(), I);
   78   ASSERT_EQ(V.begin(), I);
   82   ASSERT_EQ(V.begin() + IntVec.size(), I);
   86   ASSERT_EQ(V.begin() + IntVec.size(), I);
tools/clang/unittests/AST/CommentLexer.cpp
   86   ASSERT_EQ(0U, Toks.size());
   99     ASSERT_EQ(1U, Toks.size());
  101     ASSERT_EQ(tok::newline, Toks[0].getKind());
  115     ASSERT_EQ(2U, Toks.size());
  117     ASSERT_EQ(tok::newline, Toks[0].getKind());
  118     ASSERT_EQ(tok::newline, Toks[1].getKind());
  134     ASSERT_EQ(2U, Toks.size());
  136     ASSERT_EQ(tok::text,          Toks[0].getKind());
  137     ASSERT_EQ(StringRef(" Meow"), Toks[0].getText());
  139     ASSERT_EQ(tok::newline,       Toks[1].getKind());
  154     ASSERT_EQ(3U, Toks.size());
  156     ASSERT_EQ(tok::text,          Toks[0].getKind());
  157     ASSERT_EQ(StringRef(" Meow"), Toks[0].getText());
  159     ASSERT_EQ(tok::newline,       Toks[1].getKind());
  160     ASSERT_EQ(tok::newline,       Toks[2].getKind());
  177     ASSERT_EQ(10U, Toks.size());
  179     ASSERT_EQ(tok::text,         Toks[0].getKind());
  180     ASSERT_EQ(StringRef(" Aaa"), Toks[0].getText());
  181     ASSERT_EQ(tok::text,         Toks[1].getKind());
  182     ASSERT_EQ(StringRef("\\"),   Toks[1].getText());
  183     ASSERT_EQ(tok::newline,      Toks[2].getKind());
  185     ASSERT_EQ(tok::text,         Toks[3].getKind());
  186     ASSERT_EQ(StringRef(" Bbb"), Toks[3].getText());
  187     ASSERT_EQ(tok::text,         Toks[4].getKind());
  188     ASSERT_EQ(StringRef("\\"),   Toks[4].getText());
  189     ASSERT_EQ(tok::text,         Toks[5].getKind());
  190     ASSERT_EQ(StringRef(" "),    Toks[5].getText());
  191     ASSERT_EQ(tok::newline,      Toks[6].getKind());
  193     ASSERT_EQ(tok::text,         Toks[7].getKind());
  194     ASSERT_EQ(StringRef(" Ccc?" "?/"), Toks[7].getText());
  195     ASSERT_EQ(tok::newline,      Toks[8].getKind());
  197     ASSERT_EQ(tok::newline,      Toks[9].getKind());
  215   ASSERT_EQ(15U, Toks.size());
  217   ASSERT_EQ(tok::text,         Toks[0].getKind());
  218   ASSERT_EQ(StringRef(" Aaa"), Toks[0].getText());
  219   ASSERT_EQ(tok::newline,      Toks[1].getKind());
  221   ASSERT_EQ(tok::text,         Toks[2].getKind());
  222   ASSERT_EQ(StringRef(" Bbb"), Toks[2].getText());
  223   ASSERT_EQ(tok::newline,      Toks[3].getKind());
  225   ASSERT_EQ(tok::text,         Toks[4].getKind());
  226   ASSERT_EQ(StringRef(" Ccc"), Toks[4].getText());
  227   ASSERT_EQ(tok::newline,      Toks[5].getKind());
  229   ASSERT_EQ(tok::text,            Toks[6].getKind());
  230   ASSERT_EQ(StringRef("  ! Ddd"), Toks[6].getText());
  231   ASSERT_EQ(tok::newline,         Toks[7].getKind());
  233   ASSERT_EQ(tok::text,         Toks[8].getKind());
  234   ASSERT_EQ(StringRef(" Eee"), Toks[8].getText());
  235   ASSERT_EQ(tok::newline,      Toks[9].getKind());
  237   ASSERT_EQ(tok::text,          Toks[10].getKind());
  238   ASSERT_EQ(StringRef("* Fff"), Toks[10].getText());
  239   ASSERT_EQ(tok::newline,       Toks[11].getKind());
  241   ASSERT_EQ(tok::text,         Toks[12].getKind());
  242   ASSERT_EQ(StringRef(" "),    Toks[12].getText());
  244   ASSERT_EQ(tok::newline,      Toks[13].getKind());
  245   ASSERT_EQ(tok::newline,      Toks[14].getKind());
  256     ASSERT_EQ(2U, Toks.size());
  258     ASSERT_EQ(tok::text,          Toks[0].getKind());
  259     ASSERT_EQ(StringRef("@"),     Toks[0].getText());
  261     ASSERT_EQ(tok::newline,       Toks[1].getKind());
  273     ASSERT_EQ(3U, Toks.size());
  275     ASSERT_EQ(tok::text,          Toks[0].getKind());
  276     ASSERT_EQ(StringRef("@"),     Toks[0].getText());
  278     ASSERT_EQ(tok::newline,       Toks[1].getKind());
  279     ASSERT_EQ(tok::newline,       Toks[2].getKind());
  291     ASSERT_EQ(3U, Toks.size());
  293     ASSERT_EQ(tok::text,           Toks[0].getKind());
  294     ASSERT_EQ(StringRef("\\"),     Toks[0].getText());
  296     ASSERT_EQ(tok::newline,        Toks[1].getKind());
  297     ASSERT_EQ(tok::newline,        Toks[2].getKind());
  319     ASSERT_EQ(array_lengthof(Text), Toks.size());
  323         ASSERT_EQ(StringRef(Text[j]), Toks[j].getText())
  338   ASSERT_EQ(6U, Toks.size());
  340   ASSERT_EQ(tok::text,       Toks[0].getKind());
  341   ASSERT_EQ(StringRef(" "),  Toks[0].getText());
  343   ASSERT_EQ(tok::text,       Toks[1].getKind());
  344   ASSERT_EQ(StringRef("\\"), Toks[1].getText());
  346   ASSERT_EQ(tok::text,       Toks[2].getKind());
  347   ASSERT_EQ(StringRef("^ "), Toks[2].getText());
  349   ASSERT_EQ(tok::text,       Toks[3].getKind());
  350   ASSERT_EQ(StringRef("\\"), Toks[3].getText());
  352   ASSERT_EQ(tok::text,       Toks[4].getKind());
  353   ASSERT_EQ(StringRef("0"),  Toks[4].getText());
  355   ASSERT_EQ(tok::newline,    Toks[5].getKind());
  364   ASSERT_EQ(4U, Toks.size());
  366   ASSERT_EQ(tok::text,          Toks[0].getKind());
  367   ASSERT_EQ(StringRef(" "),     Toks[0].getText());
  369   ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
  370   ASSERT_EQ(StringRef("brief"), getCommandName(Toks[1]));
  372   ASSERT_EQ(tok::text,          Toks[2].getKind());
  373   ASSERT_EQ(StringRef(" Aaa."), Toks[2].getText());
  375   ASSERT_EQ(tok::newline,       Toks[3].getKind());
  384   ASSERT_EQ(8U, Toks.size());
  386   ASSERT_EQ(tok::text,       Toks[0].getKind());
  387   ASSERT_EQ(StringRef(" "),  Toks[0].getText());
  389   ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
  390   ASSERT_EQ(StringRef("em"), getCommandName(Toks[1]));
  392   ASSERT_EQ(tok::backslash_command, Toks[2].getKind());
  393   ASSERT_EQ(StringRef("em"), getCommandName(Toks[2]));
  395   ASSERT_EQ(tok::text,       Toks[3].getKind());
  396   ASSERT_EQ(StringRef(" "),  Toks[3].getText());
  398   ASSERT_EQ(tok::backslash_command, Toks[4].getKind());
  399   ASSERT_EQ(StringRef("em"), getCommandName(Toks[4]));
  401   ASSERT_EQ(tok::text,       Toks[5].getKind());
  402   ASSERT_EQ(StringRef("\t"), Toks[5].getText());
  404   ASSERT_EQ(tok::backslash_command, Toks[6].getKind());
  405   ASSERT_EQ(StringRef("em"), getCommandName(Toks[6]));
  407   ASSERT_EQ(tok::newline,    Toks[7].getKind());
  416   ASSERT_EQ(8U, Toks.size());
  418   ASSERT_EQ(tok::text,       Toks[0].getKind());
  419   ASSERT_EQ(StringRef(" "),  Toks[0].getText());
  421   ASSERT_EQ(tok::at_command, Toks[1].getKind());
  422   ASSERT_EQ(StringRef("em"), getCommandName(Toks[1]));
  424   ASSERT_EQ(tok::at_command, Toks[2].getKind());
  425   ASSERT_EQ(StringRef("em"), getCommandName(Toks[2]));
  427   ASSERT_EQ(tok::text,       Toks[3].getKind());
  428   ASSERT_EQ(StringRef(" "),  Toks[3].getText());
  430   ASSERT_EQ(tok::at_command, Toks[4].getKind());
  431   ASSERT_EQ(StringRef("em"), getCommandName(Toks[4]));
  433   ASSERT_EQ(tok::text,       Toks[5].getKind());
  434   ASSERT_EQ(StringRef("\t"), Toks[5].getText());
  436   ASSERT_EQ(tok::at_command, Toks[6].getKind());
  437   ASSERT_EQ(StringRef("em"), getCommandName(Toks[6]));
  439   ASSERT_EQ(tok::newline,    Toks[7].getKind());
  448   ASSERT_EQ(8U, Toks.size());
  450   ASSERT_EQ(tok::text,        Toks[0].getKind());
  451   ASSERT_EQ(StringRef(" "),   Toks[0].getText());
  453   ASSERT_EQ(tok::unknown_command, Toks[1].getKind());
  454   ASSERT_EQ(StringRef("aaa"), Toks[1].getUnknownCommandName());
  456   ASSERT_EQ(tok::unknown_command, Toks[2].getKind());
  457   ASSERT_EQ(StringRef("bbb"), Toks[2].getUnknownCommandName());
  459   ASSERT_EQ(tok::text,        Toks[3].getKind());
  460   ASSERT_EQ(StringRef(" "),   Toks[3].getText());
  462   ASSERT_EQ(tok::unknown_command, Toks[4].getKind());
  463   ASSERT_EQ(StringRef("ccc"), Toks[4].getUnknownCommandName());
  465   ASSERT_EQ(tok::text,        Toks[5].getKind());
  466   ASSERT_EQ(StringRef("\t"),  Toks[5].getText());
  468   ASSERT_EQ(tok::unknown_command, Toks[6].getKind());
  469   ASSERT_EQ(StringRef("ddd"), Toks[6].getUnknownCommandName());
  471   ASSERT_EQ(tok::newline,     Toks[7].getKind());
  480   ASSERT_EQ(3U, Toks.size());
  482   ASSERT_EQ(tok::text,      Toks[0].getKind());
  483   ASSERT_EQ(StringRef(" "), Toks[0].getText());
  485   ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
  486   ASSERT_EQ(StringRef("c"), getCommandName(Toks[1]));
  488   ASSERT_EQ(tok::newline,   Toks[2].getKind());
  502   ASSERT_EQ(8U, Toks.size());
  504   ASSERT_EQ(tok::text,          Toks[0].getKind());
  505   ASSERT_EQ(StringRef(" "),     Toks[0].getText());
  507   ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
  508   ASSERT_EQ(StringRef("NewBlockCommand"), getCommandName(Toks[1]));
  510   ASSERT_EQ(tok::text,          Toks[2].getKind());
  511   ASSERT_EQ(StringRef(" Aaa."), Toks[2].getText());
  513   ASSERT_EQ(tok::newline,       Toks[3].getKind());
  515   ASSERT_EQ(tok::text,          Toks[4].getKind());
  516   ASSERT_EQ(StringRef(" "),     Toks[4].getText());
  518   ASSERT_EQ(tok::at_command,    Toks[5].getKind());
  519   ASSERT_EQ(StringRef("NewBlockCommand"), getCommandName(Toks[5]));
  521   ASSERT_EQ(tok::text,          Toks[6].getKind());
  522   ASSERT_EQ(StringRef(" Aaa."), Toks[6].getText());
  524   ASSERT_EQ(tok::newline,       Toks[7].getKind());
  541   ASSERT_EQ(11U, Toks.size());
  543   ASSERT_EQ(tok::text,      Toks[0].getKind());
  544   ASSERT_EQ(StringRef(" "), Toks[0].getText());
  546   ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
  547   ASSERT_EQ(StringRef("Foo"), getCommandName(Toks[1]));
  549   ASSERT_EQ(tok::newline,     Toks[2].getKind());
  551   ASSERT_EQ(tok::text,      Toks[3].getKind());
  552   ASSERT_EQ(StringRef(" "), Toks[3].getText());
  554   ASSERT_EQ(tok::backslash_command, Toks[4].getKind());
  555   ASSERT_EQ(StringRef("Bar"), getCommandName(Toks[4]));
  557   ASSERT_EQ(tok::text,         Toks[5].getKind());
  558   ASSERT_EQ(StringRef(" Baz"), Toks[5].getText());
  560   ASSERT_EQ(tok::newline,     Toks[6].getKind());
  562   ASSERT_EQ(tok::text,      Toks[7].getKind());
  563   ASSERT_EQ(StringRef(" "), Toks[7].getText());
  565   ASSERT_EQ(tok::backslash_command, Toks[8].getKind());
  566   ASSERT_EQ(StringRef("Blech"), getCommandName(Toks[8]));
  568   ASSERT_EQ(tok::text,                Toks[9].getKind());
  569   ASSERT_EQ(StringRef(" quux=corge"), Toks[9].getText());
  571   ASSERT_EQ(tok::newline,     Toks[10].getKind());
  586     ASSERT_EQ(5U, Toks.size());
  588     ASSERT_EQ(tok::text,                 Toks[0].getKind());
  589     ASSERT_EQ(StringRef(" "),            Toks[0].getText());
  591     ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
  592     ASSERT_EQ(StringRef("verbatim"),     getVerbatimBlockName(Toks[1]));
  594     ASSERT_EQ(tok::verbatim_block_end,   Toks[2].getKind());
  595     ASSERT_EQ(StringRef("endverbatim"),  getVerbatimBlockName(Toks[2]));
  597     ASSERT_EQ(tok::newline,              Toks[3].getKind());
  598     ASSERT_EQ(tok::newline,              Toks[4].getKind());
  610   ASSERT_EQ(3U, Toks.size());
  612   ASSERT_EQ(tok::text,                 Toks[0].getKind());
  613   ASSERT_EQ(StringRef(" "),            Toks[0].getText());
  615   ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
  616   ASSERT_EQ(StringRef("verbatim"),     getVerbatimBlockName(Toks[1]));
  618   ASSERT_EQ(tok::newline,              Toks[2].getKind());
  629   ASSERT_EQ(4U, Toks.size());
  631   ASSERT_EQ(tok::text,                 Toks[0].getKind());
  632   ASSERT_EQ(StringRef(" "),            Toks[0].getText());
  634   ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
  635   ASSERT_EQ(StringRef("verbatim"),     getVerbatimBlockName(Toks[1]));
  637   ASSERT_EQ(tok::newline,              Toks[2].getKind());
  638   ASSERT_EQ(tok::newline,              Toks[3].getKind());
  653     ASSERT_EQ(6U, Toks.size());
  655     ASSERT_EQ(tok::text,                 Toks[0].getKind());
  656     ASSERT_EQ(StringRef(" Meow "),       Toks[0].getText());
  658     ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
  659     ASSERT_EQ(StringRef("verbatim"),     getVerbatimBlockName(Toks[1]));
  661     ASSERT_EQ(tok::verbatim_block_line,  Toks[2].getKind());
  662     ASSERT_EQ(StringRef(" aaa "),        Toks[2].getVerbatimBlockText());
  664     ASSERT_EQ(tok::verbatim_block_end,   Toks[3].getKind());
  665     ASSERT_EQ(StringRef("endverbatim"),  getVerbatimBlockName(Toks[3]));
  667     ASSERT_EQ(tok::newline,              Toks[4].getKind());
  668     ASSERT_EQ(tok::newline,              Toks[5].getKind());
  684     ASSERT_EQ(5U, Toks.size());
  686     ASSERT_EQ(tok::text,                 Toks[0].getKind());
  687     ASSERT_EQ(StringRef(" Meow "),       Toks[0].getText());
  689     ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
  690     ASSERT_EQ(StringRef("verbatim"),     getVerbatimBlockName(Toks[1]));
  692     ASSERT_EQ(tok::verbatim_block_line,  Toks[2].getKind());
  693     ASSERT_EQ(StringRef(" aaa "),        Toks[2].getVerbatimBlockText());
  695     ASSERT_EQ(tok::newline,              Toks[3].getKind());
  696     ASSERT_EQ(tok::newline,              Toks[4].getKind());
  712   ASSERT_EQ(10U, Toks.size());
  714   ASSERT_EQ(tok::text,                 Toks[0].getKind());
  715   ASSERT_EQ(StringRef(" "),            Toks[0].getText());
  717   ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
  718   ASSERT_EQ(StringRef("verbatim"),     getVerbatimBlockName(Toks[1]));
  720   ASSERT_EQ(tok::newline,              Toks[2].getKind());
  722   ASSERT_EQ(tok::verbatim_block_line,  Toks[3].getKind());
  723   ASSERT_EQ(StringRef(" Aaa"),         Toks[3].getVerbatimBlockText());
  725   ASSERT_EQ(tok::newline,              Toks[4].getKind());
  727   ASSERT_EQ(tok::newline,              Toks[5].getKind());
  729   ASSERT_EQ(tok::verbatim_block_line,  Toks[6].getKind());
  730   ASSERT_EQ(StringRef(" Bbb"),         Toks[6].getVerbatimBlockText());
  732   ASSERT_EQ(tok::newline,              Toks[7].getKind());
  734   ASSERT_EQ(tok::verbatim_block_end,   Toks[8].getKind());
  735   ASSERT_EQ(StringRef("endverbatim"),  getVerbatimBlockName(Toks[8]));
  737   ASSERT_EQ(tok::newline,              Toks[9].getKind());
  753   ASSERT_EQ(10U, Toks.size());
  755   ASSERT_EQ(tok::text,                 Toks[0].getKind());
  756   ASSERT_EQ(StringRef(" "),            Toks[0].getText());
  758   ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
  759   ASSERT_EQ(StringRef("verbatim"),     getVerbatimBlockName(Toks[1]));
  761   ASSERT_EQ(tok::verbatim_block_line,  Toks[2].getKind());
  762   ASSERT_EQ(StringRef(" Aaa"),         Toks[2].getVerbatimBlockText());
  764   ASSERT_EQ(tok::verbatim_block_line,  Toks[3].getKind());
  765   ASSERT_EQ(StringRef(""),             Toks[3].getVerbatimBlockText());
  767   ASSERT_EQ(tok::verbatim_block_line,  Toks[4].getKind());
  768   ASSERT_EQ(StringRef(" Bbb"),         Toks[4].getVerbatimBlockText());
  770   ASSERT_EQ(tok::verbatim_block_end,   Toks[5].getKind());
  771   ASSERT_EQ(StringRef("endverbatim"),  getVerbatimBlockName(Toks[5]));
  773   ASSERT_EQ(tok::newline,              Toks[6].getKind());
  775   ASSERT_EQ(tok::text,                 Toks[7].getKind());
  776   ASSERT_EQ(StringRef(" "),            Toks[7].getText());
  778   ASSERT_EQ(tok::newline,              Toks[8].getKind());
  779   ASSERT_EQ(tok::newline,              Toks[9].getKind());
  794   ASSERT_EQ(14U, Toks.size());
  796   ASSERT_EQ(tok::text,                 Toks[0].getKind());
  797   ASSERT_EQ(StringRef(" Meow "),       Toks[0].getText());
  799   ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
  800   ASSERT_EQ(StringRef("verbatim"),     getVerbatimBlockName(Toks[1]));
  802   ASSERT_EQ(tok::verbatim_block_line,  Toks[2].getKind());
  803   ASSERT_EQ(StringRef(" aaa\\$\\@"),   Toks[2].getVerbatimBlockText());
  805   ASSERT_EQ(tok::verbatim_block_line,  Toks[3].getKind());
  806   ASSERT_EQ(StringRef("bbb \\endverbati"), Toks[3].getVerbatimBlockText());
  808   ASSERT_EQ(tok::verbatim_block_line,  Toks[4].getKind());
  809   ASSERT_EQ(StringRef("ccc"),          Toks[4].getVerbatimBlockText());
  811   ASSERT_EQ(tok::verbatim_block_line,  Toks[5].getKind());
  812   ASSERT_EQ(StringRef("ddd "),         Toks[5].getVerbatimBlockText());
  814   ASSERT_EQ(tok::verbatim_block_end,   Toks[6].getKind());
  815   ASSERT_EQ(StringRef("endverbatim"),  getVerbatimBlockName(Toks[6]));
  817   ASSERT_EQ(tok::text,                 Toks[7].getKind());
  818   ASSERT_EQ(StringRef(" Blah "),       Toks[7].getText());
  820   ASSERT_EQ(tok::verbatim_block_begin, Toks[8].getKind());
  821   ASSERT_EQ(StringRef("verbatim"),     getVerbatimBlockName(Toks[8]));
  823   ASSERT_EQ(tok::verbatim_block_line,  Toks[9].getKind());
  824   ASSERT_EQ(StringRef(" eee"),         Toks[9].getVerbatimBlockText());
  826   ASSERT_EQ(tok::verbatim_block_end,   Toks[10].getKind());
  827   ASSERT_EQ(StringRef("endverbatim"),  getVerbatimBlockName(Toks[10]));
  829   ASSERT_EQ(tok::text,                 Toks[11].getKind());
  830   ASSERT_EQ(StringRef(" BlahBlah"),    Toks[11].getText());
  832   ASSERT_EQ(tok::newline,              Toks[12].getKind());
  833   ASSERT_EQ(tok::newline,              Toks[13].getKind());
  844   ASSERT_EQ(13U, Toks.size());
  846   ASSERT_EQ(tok::text,                 Toks[0].getKind());
  847   ASSERT_EQ(StringRef(" "),            Toks[0].getText());
  849   ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
  850   ASSERT_EQ(StringRef("f$"),           getVerbatimBlockName(Toks[1]));
  852   ASSERT_EQ(tok::verbatim_block_line,  Toks[2].getKind());
  853   ASSERT_EQ(StringRef(" Aaa "),        Toks[2].getVerbatimBlockText());
  855   ASSERT_EQ(tok::verbatim_block_end,   Toks[3].getKind());
  856   ASSERT_EQ(StringRef("f$"),           getVerbatimBlockName(Toks[3]));
  858   ASSERT_EQ(tok::text,                 Toks[4].getKind());
  859   ASSERT_EQ(StringRef(" "),            Toks[4].getText());
  861   ASSERT_EQ(tok::verbatim_block_begin, Toks[5].getKind());
  862   ASSERT_EQ(StringRef("f["),           getVerbatimBlockName(Toks[5]));
  864   ASSERT_EQ(tok::verbatim_block_line,  Toks[6].getKind());
  865   ASSERT_EQ(StringRef(" Bbb "),        Toks[6].getVerbatimBlockText());
  867   ASSERT_EQ(tok::verbatim_block_end,   Toks[7].getKind());
  868   ASSERT_EQ(StringRef("f]"),           getVerbatimBlockName(Toks[7]));
  870   ASSERT_EQ(tok::text,                 Toks[8].getKind());
  871   ASSERT_EQ(StringRef(" "),            Toks[8].getText());
  873   ASSERT_EQ(tok::verbatim_block_begin, Toks[9].getKind());
  874   ASSERT_EQ(StringRef("f{"),           getVerbatimBlockName(Toks[9]));
  876   ASSERT_EQ(tok::verbatim_block_line,  Toks[10].getKind());
  877   ASSERT_EQ(StringRef(" Ccc "),        Toks[10].getVerbatimBlockText());
  879   ASSERT_EQ(tok::verbatim_block_end,   Toks[11].getKind());
  880   ASSERT_EQ(StringRef("f}"),           getVerbatimBlockName(Toks[11]));
  882   ASSERT_EQ(tok::newline,              Toks[12].getKind());
  897     ASSERT_EQ(4U, Toks.size());
  899     ASSERT_EQ(tok::text,               Toks[0].getKind());
  900     ASSERT_EQ(StringRef(" "),          Toks[0].getText());
  902     ASSERT_EQ(tok::verbatim_line_name, Toks[1].getKind());
  903     ASSERT_EQ(StringRef("fn"),         getVerbatimLineName(Toks[1]));
  905     ASSERT_EQ(tok::newline,            Toks[2].getKind());
  906     ASSERT_EQ(tok::newline,            Toks[3].getKind());
  922     ASSERT_EQ(5U, Toks.size());
  924     ASSERT_EQ(tok::text,               Toks[0].getKind());
  925     ASSERT_EQ(StringRef(" "),          Toks[0].getText());
  927     ASSERT_EQ(tok::verbatim_line_name, Toks[1].getKind());
  928     ASSERT_EQ(StringRef("fn"),         getVerbatimLineName(Toks[1]));
  930     ASSERT_EQ(tok::verbatim_line_text, Toks[2].getKind());
  931     ASSERT_EQ(StringRef(" void *foo(const char *zzz = \"\\$\");"),
  934     ASSERT_EQ(tok::newline,            Toks[3].getKind());
  935     ASSERT_EQ(tok::newline,            Toks[4].getKind());
  950   ASSERT_EQ(9U, Toks.size());
  952   ASSERT_EQ(tok::text,               Toks[0].getKind());
  953   ASSERT_EQ(StringRef(" "),          Toks[0].getText());
  955   ASSERT_EQ(tok::verbatim_line_name, Toks[1].getKind());
  956   ASSERT_EQ(StringRef("fn"),         getVerbatimLineName(Toks[1]));
  958   ASSERT_EQ(tok::verbatim_line_text, Toks[2].getKind());
  959   ASSERT_EQ(StringRef(" void *foo(const char *zzz = \"\\$\");"),
  961   ASSERT_EQ(tok::newline,            Toks[3].getKind());
  963   ASSERT_EQ(tok::text,               Toks[4].getKind());
  964   ASSERT_EQ(StringRef(" Meow"),      Toks[4].getText());
  965   ASSERT_EQ(tok::newline,            Toks[5].getKind());
  967   ASSERT_EQ(tok::text,               Toks[6].getKind());
  968   ASSERT_EQ(StringRef(" "),          Toks[6].getText());
  970   ASSERT_EQ(tok::newline,            Toks[7].getKind());
  971   ASSERT_EQ(tok::newline,            Toks[8].getKind());
  982   ASSERT_EQ(3U, Toks.size());
  984   ASSERT_EQ(tok::text,      Toks[0].getKind());
  985   ASSERT_EQ(StringRef(" "), Toks[0].getText());
  987   ASSERT_EQ(tok::text,      Toks[1].getKind());
  988   ASSERT_EQ(StringRef("<"), Toks[1].getText());
  990   ASSERT_EQ(tok::newline,   Toks[2].getKind());
 1001   ASSERT_EQ(4U, Toks.size());
 1003   ASSERT_EQ(tok::text,       Toks[0].getKind());
 1004   ASSERT_EQ(StringRef(" a"), Toks[0].getText());
 1006   ASSERT_EQ(tok::text,       Toks[1].getKind());
 1007   ASSERT_EQ(StringRef("<"),  Toks[1].getText());
 1009   ASSERT_EQ(tok::text,       Toks[2].getKind());
 1010   ASSERT_EQ(StringRef("2"),  Toks[2].getText());
 1012   ASSERT_EQ(tok::newline,    Toks[3].getKind());
 1023   ASSERT_EQ(4U, Toks.size());
 1025   ASSERT_EQ(tok::text,         Toks[0].getKind());
 1026   ASSERT_EQ(StringRef(" "),    Toks[0].getText());
 1028   ASSERT_EQ(tok::text,         Toks[1].getKind());
 1029   ASSERT_EQ(StringRef("<"),    Toks[1].getText());
 1031   ASSERT_EQ(tok::text,         Toks[2].getKind());
 1032   ASSERT_EQ(StringRef(" img"), Toks[2].getText());
 1034   ASSERT_EQ(tok::newline,      Toks[3].getKind());
 1048     ASSERT_EQ(3U, Toks.size());
 1050     ASSERT_EQ(tok::text,           Toks[0].getKind());
 1051     ASSERT_EQ(StringRef(" "),      Toks[0].getText());
 1053     ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
 1054     ASSERT_EQ(StringRef("img"),    Toks[1].getHTMLTagStartName());
 1056     ASSERT_EQ(tok::newline,        Toks[2].getKind());
 1068   ASSERT_EQ(4U, Toks.size());
 1070   ASSERT_EQ(tok::text,           Toks[0].getKind());
 1071   ASSERT_EQ(StringRef(" "),      Toks[0].getText());
 1073   ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
 1074   ASSERT_EQ(StringRef("img"),    Toks[1].getHTMLTagStartName());
 1076   ASSERT_EQ(tok::text,           Toks[2].getKind());
 1077   ASSERT_EQ(StringRef("42"),     Toks[2].getText());
 1079   ASSERT_EQ(tok::newline,        Toks[3].getKind());
 1089   ASSERT_EQ(5U, Toks.size());
 1091   ASSERT_EQ(tok::text,           Toks[0].getKind());
 1092   ASSERT_EQ(StringRef(" "),      Toks[0].getText());
 1094   ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
 1095   ASSERT_EQ(StringRef("img"),    Toks[1].getHTMLTagStartName());
 1097   ASSERT_EQ(tok::html_greater,   Toks[2].getKind());
 1099   ASSERT_EQ(tok::text,           Toks[3].getKind());
 1100   ASSERT_EQ(StringRef(" Meow"),  Toks[3].getText());
 1102   ASSERT_EQ(tok::newline,        Toks[4].getKind());
 1112   ASSERT_EQ(4U, Toks.size());
 1114   ASSERT_EQ(tok::text,           Toks[0].getKind());
 1115   ASSERT_EQ(StringRef(" "),      Toks[0].getText());
 1117   ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
 1118   ASSERT_EQ(StringRef("img"),    Toks[1].getHTMLTagStartName());
 1120   ASSERT_EQ(tok::text,           Toks[2].getKind());
 1121   ASSERT_EQ(StringRef("="),      Toks[2].getText());
 1123   ASSERT_EQ(tok::newline,        Toks[3].getKind());
 1133   ASSERT_EQ(7U, Toks.size());
 1135   ASSERT_EQ(tok::text,           Toks[0].getKind());
 1136   ASSERT_EQ(StringRef(" "),      Toks[0].getText());
 1138   ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
 1139   ASSERT_EQ(StringRef("img"),    Toks[1].getHTMLTagStartName());
 1141   ASSERT_EQ(tok::html_ident,     Toks[2].getKind());
 1142   ASSERT_EQ(StringRef("src"),   Toks[2].getHTMLIdent());
 1144   ASSERT_EQ(tok::html_equals,    Toks[3].getKind());
 1146   ASSERT_EQ(tok::html_greater,   Toks[4].getKind());
 1148   ASSERT_EQ(tok::text,           Toks[5].getKind());
 1149   ASSERT_EQ(StringRef(" Meow"),  Toks[5].getText());
 1151   ASSERT_EQ(tok::newline,        Toks[6].getKind());
 1165     ASSERT_EQ(4U, Toks.size());
 1167     ASSERT_EQ(tok::text,           Toks[0].getKind());
 1168     ASSERT_EQ(StringRef(" "),      Toks[0].getText());
 1170     ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
 1171     ASSERT_EQ(StringRef("img"),    Toks[1].getHTMLTagStartName());
 1173     ASSERT_EQ(tok::html_ident,     Toks[2].getKind());
 1174     ASSERT_EQ(StringRef("src"),    Toks[2].getHTMLIdent());
 1176     ASSERT_EQ(tok::newline,        Toks[3].getKind());
 1191     ASSERT_EQ(5U, Toks.size());
 1193     ASSERT_EQ(tok::text,           Toks[0].getKind());
 1194     ASSERT_EQ(StringRef(" "),      Toks[0].getText());
 1196     ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
 1197     ASSERT_EQ(StringRef("img"),    Toks[1].getHTMLTagStartName());
 1199     ASSERT_EQ(tok::html_ident,     Toks[2].getKind());
 1200     ASSERT_EQ(StringRef("src"),    Toks[2].getHTMLIdent());
 1202     ASSERT_EQ(tok::html_equals,    Toks[3].getKind());
 1204     ASSERT_EQ(tok::newline,        Toks[4].getKind());
 1221     ASSERT_EQ(6U, Toks.size());
 1223     ASSERT_EQ(tok::text,               Toks[0].getKind());
 1224     ASSERT_EQ(StringRef(" "),          Toks[0].getText());
 1226     ASSERT_EQ(tok::html_start_tag,     Toks[1].getKind());
 1227     ASSERT_EQ(StringRef("img"),        Toks[1].getHTMLTagStartName());
 1229     ASSERT_EQ(tok::html_ident,         Toks[2].getKind());
 1230     ASSERT_EQ(StringRef("src"),        Toks[2].getHTMLIdent());
 1232     ASSERT_EQ(tok::html_equals,        Toks[3].getKind());
 1234     ASSERT_EQ(tok::html_quoted_string, Toks[4].getKind());
 1235     ASSERT_EQ(StringRef(""),           Toks[4].getHTMLQuotedString());
 1237     ASSERT_EQ(tok::newline,            Toks[5].getKind());
 1248   ASSERT_EQ(6U, Toks.size());
 1250   ASSERT_EQ(tok::text,           Toks[0].getKind());
 1251   ASSERT_EQ(StringRef(" "),      Toks[0].getText());
 1253   ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
 1254   ASSERT_EQ(StringRef("img"),    Toks[1].getHTMLTagStartName());
 1256   ASSERT_EQ(tok::html_ident,     Toks[2].getKind());
 1257   ASSERT_EQ(StringRef("src"),    Toks[2].getHTMLIdent());
 1259   ASSERT_EQ(tok::html_equals,    Toks[3].getKind());
 1261   ASSERT_EQ(tok::text,           Toks[4].getKind());
 1262   ASSERT_EQ(StringRef("@"),      Toks[4].getText());
 1264   ASSERT_EQ(tok::newline,        Toks[5].getKind());
 1280     ASSERT_EQ(6U, Toks.size());
 1282     ASSERT_EQ(tok::text,                  Toks[0].getKind());
 1283     ASSERT_EQ(StringRef(" "),             Toks[0].getText());
 1285     ASSERT_EQ(tok::html_start_tag,        Toks[1].getKind());
 1286     ASSERT_EQ(StringRef("img"),           Toks[1].getHTMLTagStartName());
 1288     ASSERT_EQ(tok::html_ident,            Toks[2].getKind());
 1289     ASSERT_EQ(StringRef("src"),           Toks[2].getHTMLIdent());
 1291     ASSERT_EQ(tok::html_equals,           Toks[3].getKind());
 1293     ASSERT_EQ(tok::html_quoted_string,    Toks[4].getKind());
 1294     ASSERT_EQ(StringRef("val\\\"\\'val"), Toks[4].getHTMLQuotedString());
 1296     ASSERT_EQ(tok::newline,               Toks[5].getKind());
 1311     ASSERT_EQ(7U, Toks.size());
 1313     ASSERT_EQ(tok::text,                  Toks[0].getKind());
 1314     ASSERT_EQ(StringRef(" "),             Toks[0].getText());
 1316     ASSERT_EQ(tok::html_start_tag,        Toks[1].getKind());
 1317     ASSERT_EQ(StringRef("img"),           Toks[1].getHTMLTagStartName());
 1319     ASSERT_EQ(tok::html_ident,            Toks[2].getKind());
 1320     ASSERT_EQ(StringRef("src"),           Toks[2].getHTMLIdent());
 1322     ASSERT_EQ(tok::html_equals,           Toks[3].getKind());
 1324     ASSERT_EQ(tok::html_quoted_string,    Toks[4].getKind());
 1325     ASSERT_EQ(StringRef("val\\\"\\'val"), Toks[4].getHTMLQuotedString());
 1327     ASSERT_EQ(tok::html_greater,          Toks[5].getKind());
 1329     ASSERT_EQ(tok::newline,               Toks[6].getKind());
 1344     ASSERT_EQ(4U, Toks.size());
 1346     ASSERT_EQ(tok::text,               Toks[0].getKind());
 1347     ASSERT_EQ(StringRef(" "),          Toks[0].getText());
 1349     ASSERT_EQ(tok::html_start_tag,     Toks[1].getKind());
 1350     ASSERT_EQ(StringRef("img"),        Toks[1].getHTMLTagStartName());
 1352     ASSERT_EQ(tok::html_slash_greater, Toks[2].getKind());
 1354     ASSERT_EQ(tok::newline,            Toks[3].getKind());
 1369     ASSERT_EQ(5U, Toks.size());
 1371     ASSERT_EQ(tok::text,               Toks[0].getKind());
 1372     ASSERT_EQ(StringRef(" "),          Toks[0].getText());
 1374     ASSERT_EQ(tok::html_start_tag,     Toks[1].getKind());
 1375     ASSERT_EQ(StringRef("img"),        Toks[1].getHTMLTagStartName());
 1377     ASSERT_EQ(tok::text,               Toks[2].getKind());
 1378     ASSERT_EQ(StringRef("/"),          Toks[2].getText());
 1380     ASSERT_EQ(tok::text,               Toks[3].getKind());
 1381     ASSERT_EQ(StringRef(" Aaa"),       Toks[3].getText());
 1383     ASSERT_EQ(tok::newline,            Toks[4].getKind());
 1394   ASSERT_EQ(3U, Toks.size());
 1396   ASSERT_EQ(tok::text,       Toks[0].getKind());
 1397   ASSERT_EQ(StringRef(" "),  Toks[0].getText());
 1399   ASSERT_EQ(tok::text,       Toks[1].getKind());
 1400   ASSERT_EQ(StringRef("</"), Toks[1].getText());
 1402   ASSERT_EQ(tok::newline,    Toks[2].getKind());
 1412   ASSERT_EQ(4U, Toks.size());
 1414   ASSERT_EQ(tok::text,       Toks[0].getKind());
 1415   ASSERT_EQ(StringRef(" "),  Toks[0].getText());
 1417   ASSERT_EQ(tok::text,       Toks[1].getKind());
 1418   ASSERT_EQ(StringRef("</"), Toks[1].getText());
 1420   ASSERT_EQ(tok::text,       Toks[2].getKind());
 1421   ASSERT_EQ(StringRef("@"),  Toks[2].getText());
 1423   ASSERT_EQ(tok::newline,    Toks[3].getKind());
 1433   ASSERT_EQ(3U, Toks.size());
 1435   ASSERT_EQ(tok::text,         Toks[0].getKind());
 1436   ASSERT_EQ(StringRef(" "),    Toks[0].getText());
 1438   ASSERT_EQ(tok::html_end_tag, Toks[1].getKind());
 1439   ASSERT_EQ(StringRef("img"),  Toks[1].getHTMLTagEndName());
 1441   ASSERT_EQ(tok::newline,      Toks[2].getKind());
 1451   ASSERT_EQ(4U, Toks.size());
 1453   ASSERT_EQ(tok::text,         Toks[0].getKind());
 1454   ASSERT_EQ(StringRef(" "),    Toks[0].getText());
 1456   ASSERT_EQ(tok::text,         Toks[1].getKind());
 1457   ASSERT_EQ(StringRef("<tag"), Toks[1].getText());
 1459   ASSERT_EQ(tok::text,         Toks[2].getKind());
 1460   ASSERT_EQ(StringRef(">"),    Toks[2].getText());
 1462   ASSERT_EQ(tok::newline,      Toks[3].getKind());
 1472   ASSERT_EQ(4U, Toks.size());
 1474   ASSERT_EQ(tok::text,          Toks[0].getKind());
 1475   ASSERT_EQ(StringRef(" "),     Toks[0].getText());
 1477   ASSERT_EQ(tok::text,          Toks[1].getKind());
 1478   ASSERT_EQ(StringRef("</tag"), Toks[1].getText());
 1480   ASSERT_EQ(tok::text,          Toks[2].getKind());
 1481   ASSERT_EQ(StringRef(">"),     Toks[2].getText());
 1483   ASSERT_EQ(tok::newline,       Toks[3].getKind());
 1493   ASSERT_EQ(3U, Toks.size());
 1495   ASSERT_EQ(tok::text,         Toks[0].getKind());
 1496   ASSERT_EQ(StringRef(" "),    Toks[0].getText());
 1498   ASSERT_EQ(tok::text,         Toks[1].getKind());
 1499   ASSERT_EQ(StringRef("&"),    Toks[1].getText());
 1501   ASSERT_EQ(tok::newline,      Toks[2].getKind());
 1511   ASSERT_EQ(4U, Toks.size());
 1513   ASSERT_EQ(tok::text,         Toks[0].getKind());
 1514   ASSERT_EQ(StringRef(" "),    Toks[0].getText());
 1516   ASSERT_EQ(tok::text,         Toks[1].getKind());
 1517   ASSERT_EQ(StringRef("&"),    Toks[1].getText());
 1519   ASSERT_EQ(tok::text,         Toks[2].getKind());
 1520   ASSERT_EQ(StringRef("!"),    Toks[2].getText());
 1522   ASSERT_EQ(tok::newline,      Toks[3].getKind());
 1532   ASSERT_EQ(3U, Toks.size());
 1534   ASSERT_EQ(tok::text,         Toks[0].getKind());
 1535   ASSERT_EQ(StringRef(" "),    Toks[0].getText());
 1537   ASSERT_EQ(tok::text,         Toks[1].getKind());
 1538   ASSERT_EQ(StringRef("&amp"), Toks[1].getText());
 1540   ASSERT_EQ(tok::newline,      Toks[2].getKind());
 1550   ASSERT_EQ(4U, Toks.size());
 1552   ASSERT_EQ(tok::text,         Toks[0].getKind());
 1553   ASSERT_EQ(StringRef(" "),    Toks[0].getText());
 1555   ASSERT_EQ(tok::text,         Toks[1].getKind());
 1556   ASSERT_EQ(StringRef("&amp"), Toks[1].getText());
 1558   ASSERT_EQ(tok::text,         Toks[2].getKind());
 1559   ASSERT_EQ(StringRef("!"),    Toks[2].getText());
 1561   ASSERT_EQ(tok::newline,      Toks[3].getKind());
 1571   ASSERT_EQ(3U, Toks.size());
 1573   ASSERT_EQ(tok::text,         Toks[0].getKind());
 1574   ASSERT_EQ(StringRef(" "),    Toks[0].getText());
 1576   ASSERT_EQ(tok::text,         Toks[1].getKind());
 1577   ASSERT_EQ(StringRef("&#"),   Toks[1].getText());
 1579   ASSERT_EQ(tok::newline,      Toks[2].getKind());
 1589   ASSERT_EQ(4U, Toks.size());
 1591   ASSERT_EQ(tok::text,         Toks[0].getKind());
 1592   ASSERT_EQ(StringRef(" "),    Toks[0].getText());
 1594   ASSERT_EQ(tok::text,         Toks[1].getKind());
 1595   ASSERT_EQ(StringRef("&#"),   Toks[1].getText());
 1597   ASSERT_EQ(tok::text,         Toks[2].getKind());
 1598   ASSERT_EQ(StringRef("a"),    Toks[2].getText());
 1600   ASSERT_EQ(tok::newline,      Toks[3].getKind());
 1610   ASSERT_EQ(3U, Toks.size());
 1612   ASSERT_EQ(tok::text,         Toks[0].getKind());
 1613   ASSERT_EQ(StringRef(" "),    Toks[0].getText());
 1615   ASSERT_EQ(tok::text,         Toks[1].getKind());
 1616   ASSERT_EQ(StringRef("&#42"), Toks[1].getText());
 1618   ASSERT_EQ(tok::newline,      Toks[2].getKind());
 1628   ASSERT_EQ(4U, Toks.size());
 1630   ASSERT_EQ(tok::text,         Toks[0].getKind());
 1631   ASSERT_EQ(StringRef(" "),    Toks[0].getText());
 1633   ASSERT_EQ(tok::text,         Toks[1].getKind());
 1634   ASSERT_EQ(StringRef("&#42"), Toks[1].getText());
 1636   ASSERT_EQ(tok::text,         Toks[2].getKind());
 1637   ASSERT_EQ(StringRef("a"),    Toks[2].getText());
 1639   ASSERT_EQ(tok::newline,      Toks[3].getKind());
 1649   ASSERT_EQ(3U, Toks.size());
 1651   ASSERT_EQ(tok::text,         Toks[0].getKind());
 1652   ASSERT_EQ(StringRef(" "),    Toks[0].getText());
 1654   ASSERT_EQ(tok::text,         Toks[1].getKind());
 1655   ASSERT_EQ(StringRef("&#x"),  Toks[1].getText());
 1657   ASSERT_EQ(tok::newline,      Toks[2].getKind());
 1667   ASSERT_EQ(4U, Toks.size());
 1669   ASSERT_EQ(tok::text,         Toks[0].getKind());
 1670   ASSERT_EQ(StringRef(" "),    Toks[0].getText());
 1672   ASSERT_EQ(tok::text,         Toks[1].getKind());
 1673   ASSERT_EQ(StringRef("&#x"),  Toks[1].getText());
 1675   ASSERT_EQ(tok::text,         Toks[2].getKind());
 1676   ASSERT_EQ(StringRef("z"),    Toks[2].getText());
 1678   ASSERT_EQ(tok::newline,      Toks[3].getKind());
 1688   ASSERT_EQ(3U, Toks.size());
 1690   ASSERT_EQ(tok::text,          Toks[0].getKind());
 1691   ASSERT_EQ(StringRef(" "),     Toks[0].getText());
 1693   ASSERT_EQ(tok::text,          Toks[1].getKind());
 1694   ASSERT_EQ(StringRef("&#xab"), Toks[1].getText());
 1696   ASSERT_EQ(tok::newline,       Toks[2].getKind());
 1706   ASSERT_EQ(4U, Toks.size());
 1708   ASSERT_EQ(tok::text,          Toks[0].getKind());
 1709   ASSERT_EQ(StringRef(" "),     Toks[0].getText());
 1711   ASSERT_EQ(tok::text,          Toks[1].getKind());
 1712   ASSERT_EQ(StringRef("&#xaB"), Toks[1].getText());
 1714   ASSERT_EQ(tok::text,          Toks[2].getKind());
 1715   ASSERT_EQ(StringRef("z"),     Toks[2].getText());
 1717   ASSERT_EQ(tok::newline,       Toks[3].getKind());
 1727   ASSERT_EQ(3U, Toks.size());
 1729   ASSERT_EQ(tok::text,          Toks[0].getKind());
 1730   ASSERT_EQ(StringRef(" "),     Toks[0].getText());
 1732   ASSERT_EQ(tok::text,          Toks[1].getKind());
 1733   ASSERT_EQ(StringRef("&"),     Toks[1].getText());
 1735   ASSERT_EQ(tok::newline,       Toks[2].getKind());
 1745   ASSERT_EQ(4U, Toks.size());
 1747   ASSERT_EQ(tok::text,          Toks[0].getKind());
 1748   ASSERT_EQ(StringRef(" "),     Toks[0].getText());
 1750   ASSERT_EQ(tok::text,          Toks[1].getKind());
 1751   ASSERT_EQ(StringRef("&"),     Toks[1].getText());
 1753   ASSERT_EQ(tok::text,          Toks[2].getKind());
 1754   ASSERT_EQ(StringRef("<"),     Toks[2].getText());
 1756   ASSERT_EQ(tok::newline,       Toks[3].getKind());
 1766   ASSERT_EQ(4U, Toks.size());
 1768   ASSERT_EQ(tok::text,          Toks[0].getKind());
 1769   ASSERT_EQ(StringRef(" "),     Toks[0].getText());
 1771   ASSERT_EQ(tok::text,          Toks[1].getKind());
 1772   ASSERT_EQ(StringRef("&"),     Toks[1].getText());
 1774   ASSERT_EQ(tok::text,          Toks[2].getKind());
 1775   ASSERT_EQ(StringRef(" meow"), Toks[2].getText());
 1777   ASSERT_EQ(tok::newline,       Toks[3].getKind());
 1793     ASSERT_EQ(3U, Toks.size());
 1795     ASSERT_EQ(tok::text,          Toks[0].getKind());
 1796     ASSERT_EQ(StringRef(" "),     Toks[0].getText());
 1798     ASSERT_EQ(tok::text,          Toks[1].getKind());
 1799     ASSERT_EQ(StringRef("="),     Toks[1].getText());
 1801     ASSERT_EQ(tok::newline,       Toks[2].getKind());
 1817   ASSERT_EQ(12U, Toks.size());
 1819   ASSERT_EQ(tok::text,           Toks[0].getKind());
 1820   ASSERT_EQ(StringRef(" Aaa"),   Toks[0].getText());
 1821   ASSERT_EQ(tok::newline,        Toks[1].getKind());
 1823   ASSERT_EQ(tok::text,           Toks[2].getKind());
 1824   ASSERT_EQ(StringRef(" Bbb"),   Toks[2].getText());
 1825   ASSERT_EQ(tok::newline,        Toks[3].getKind());
 1827   ASSERT_EQ(tok::text,           Toks[4].getKind());
 1828   ASSERT_EQ(StringRef(" Ccc"),   Toks[4].getText());
 1829   ASSERT_EQ(tok::newline,        Toks[5].getKind());
 1831   ASSERT_EQ(tok::text,           Toks[6].getKind());
 1832   ASSERT_EQ(StringRef(" Ddd"),   Toks[6].getText());
 1833   ASSERT_EQ(tok::newline,        Toks[7].getKind());
 1834   ASSERT_EQ(tok::newline,        Toks[8].getKind());
 1836   ASSERT_EQ(tok::text,           Toks[9].getKind());
 1837   ASSERT_EQ(StringRef(" Eee"),   Toks[9].getText());
 1839   ASSERT_EQ(tok::newline,        Toks[10].getKind());
 1840   ASSERT_EQ(tok::newline,        Toks[11].getKind());
tools/clang/unittests/AST/CommentParser.cpp
 1376       ASSERT_EQ(3U, VBC->getNumLines());
 1377       ASSERT_EQ(" Aaa", VBC->getText(0));
 1378       ASSERT_EQ("",     VBC->getText(1));
 1379       ASSERT_EQ(" Bbb", VBC->getText(2));
tools/clang/unittests/ASTMatchers/Dynamic/ParserTest.cpp
  330   ASSERT_EQ(1u, Comps.size());
  336   ASSERT_EQ(1u, Comps.size());
  347   ASSERT_EQ(1u, Comps.size());
  359   ASSERT_EQ(3u, Comps.size());
tools/clang/unittests/ASTMatchers/Dynamic/RegistryTest.cpp
  479   ASSERT_EQ(AllOfWhileComps.size(), WhileComps.size());
tools/clang/unittests/Analysis/CloneDetectionTest.cpp
   76   ASSERT_EQ(CloneGroups.size(), 1u);
   77   ASSERT_EQ(CloneGroups.front().size(), 2u);
   93   ASSERT_EQ(CloneGroups.size(), 1u);
   94   ASSERT_EQ(CloneGroups.front().size(), 4u);
  107   ASSERT_EQ(FoundFunctionsWithBarPrefix, 2);
tools/clang/unittests/Basic/FileManagerTest.cpp
  223   ASSERT_EQ(file.getError(), std::errc::no_such_file_or_directory);
  227   ASSERT_EQ(readingDirAsFile.getError(), std::errc::is_a_directory);
  231   ASSERT_EQ(readingFileAsDir.getError(), std::errc::not_a_directory);
tools/clang/unittests/Basic/FixedPointTest.cpp
  134   ASSERT_EQ(APFixedPoint::getMax(Sema).getValue(),
  139   ASSERT_EQ(APFixedPoint::getMax(Sema).getValue(),
  144   ASSERT_EQ(APFixedPoint::getMin(Sema).getValue(),
  200   ASSERT_EQ(ValWithFract.getIntPart(), IntPart);
  205   ASSERT_EQ(JustFract.getIntPart(), 0);
  210   ASSERT_EQ(WholeNum.getIntPart(), IntPart);
  216     ASSERT_EQ(Negative.getIntPart(), IntPart);
  221   ASSERT_EQ(APFixedPoint::getMin(Sema).getIntPart(), Expected);
  225   ASSERT_EQ(APFixedPoint::getMax(Sema).getIntPart(), Expected);
  305   ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
  307   ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
  309   ASSERT_EQ(APFixedPoint(0, getSAccumSema()), APFixedPoint(0, getLAccumSema()));
  312   ASSERT_EQ(APFixedPoint(64, getSAccumSema()),
  314   ASSERT_EQ(APFixedPoint(16384, getAccumSema()),
  316   ASSERT_EQ(APFixedPoint(1073741824, getLAccumSema()),
  320   ASSERT_EQ(APFixedPoint(64, getSAccumSema()),
  322   ASSERT_EQ(APFixedPoint(64, getSAccumSema()),
  326   ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
  330   ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
  332   ASSERT_EQ(APFixedPoint(-320, getSAccumSema()),
  336   ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
  338   ASSERT_EQ(APFixedPoint(640, getUSAccumSema()),
  381   ASSERT_EQ(Fixed.convert(Dst), Expected);
  389   ASSERT_EQ(Fixed.convert(Dst), APFixedPoint::getMin(Dst));
  397   ASSERT_EQ(Fixed.convert(Dst), APFixedPoint::getMax(Dst));
  608   ASSERT_EQ(UFixed.getValue(), APSInt::getUnsigned(255 << 8).extOrTrunc(16));
  614   ASSERT_EQ(Val.convert(getLFractSema()).getValue(), -(1ULL << 31));
  617   ASSERT_EQ(Val.convert(getSAccumSema()).getValue(), -(1ULL << 15));
  620   ASSERT_EQ(Val.convert(getAccumSema()).getValue(), -(1ULL << 31));
  624   ASSERT_EQ(Val.convert(getLFractSema()).getValue(), 1ULL << 30);
  627   ASSERT_EQ(Val.convert(getSAccumSema()).getValue(), 255 << 7);
  630   ASSERT_EQ(Val.convert(getAccumSema()).getValue(), 65535 << 15);
  634   ASSERT_EQ(Val.convert(getUSAccumSema()).getValue(), 255 << 8);
  637   ASSERT_EQ(Val.convert(getUAccumSema()).getValue(), 65535ULL << 16);
  640   ASSERT_EQ(Val.convert(getULAccumSema()).getValue().getZExtValue(),
tools/clang/unittests/Basic/SourceManagerTest.cpp
   81   ASSERT_EQ(3U, toks.size());
   82   ASSERT_EQ(tok::l_square, toks[0].getKind());
   83   ASSERT_EQ(tok::identifier, toks[1].getKind());
   84   ASSERT_EQ(tok::r_square, toks[2].getKind());
   96   ASSERT_EQ("M", PP.getSpelling(macroExpStartLoc, str));
   97   ASSERT_EQ(")", PP.getSpelling(macroExpEndLoc, str));
  204   ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM(""), nullptr);
  205   ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM("\x00\x00\x00"), nullptr);
  206   ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM("\xFF\xFF\xFF"), nullptr);
  207   ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM("#include <iostream>"),
  210   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
  213   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
  216   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
  219   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
  222   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
  225   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
  228   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
  231   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
  234   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
  238   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
  290   ASSERT_EQ(4U, toks.size());
  291   ASSERT_EQ(tok::numeric_constant, toks[0].getKind());
  292   ASSERT_EQ(tok::numeric_constant, toks[1].getKind());
  293   ASSERT_EQ(tok::numeric_constant, toks[2].getKind());
  294   ASSERT_EQ(tok::numeric_constant, toks[3].getKind());
  412   ASSERT_EQ(0U, toks.size());
  414   ASSERT_EQ(15U, Macros.size());
  417   ASSERT_EQ("M", Macros[0].Name);
  420   ASSERT_EQ("INC", Macros[1].Name);
  423   ASSERT_EQ("M", Macros[2].Name);
  426   ASSERT_EQ("INC", Macros[3].Name);
  429   ASSERT_EQ("MACRO_IN_INCLUDE", Macros[4].Name);
  433   ASSERT_EQ("MACRO_DEFINED", Macros[5].Name);
  437   ASSERT_EQ("MACRO_DEFINED", Macros[6].Name);
  441   ASSERT_EQ("MACRO_UNDEFINED", Macros[7].Name);
  444   ASSERT_EQ("INC2", Macros[8].Name);
  447   ASSERT_EQ("M", Macros[9].Name);
  450   ASSERT_EQ("INC2", Macros[10].Name);
  453   ASSERT_EQ("MACRO_IN_INCLUDE", Macros[11].Name);
tools/clang/unittests/Driver/DistroTest.cpp
   48   ASSERT_EQ(Distro(Distro::UbuntuTrusty), UbuntuTrusty);
   78   ASSERT_EQ(Distro(Distro::UbuntuYakkety), UbuntuYakkety);
  113   ASSERT_EQ(Distro(Distro::Fedora), Fedora25);
  150   ASSERT_EQ(Distro(Distro::RHEL7), CentOS7);
  178   ASSERT_EQ(Distro(Distro::OpenSUSE), OpenSUSELeap421);
  204   ASSERT_EQ(Distro(Distro::OpenSUSE), OpenSUSE132);
  221   ASSERT_EQ(Distro(Distro::UnknownDistro), SLES10);
  244   ASSERT_EQ(Distro(Distro::DebianJessie), DebianJessie);
  263   ASSERT_EQ(Distro(Distro::DebianStretch), DebianStretchSid);
  285   ASSERT_EQ(Distro(Distro::Exherbo), Exherbo);
  307   ASSERT_EQ(Distro(Distro::ArchLinux), ArchLinux);
  332   ASSERT_EQ(Distro(Distro::Gentoo), Gentoo);
tools/clang/unittests/Driver/MultilibTest.cpp
  244   ASSERT_EQ(MS.size(), (unsigned)2 * 2 * 2)
  247   ASSERT_EQ(MS.size(), (unsigned)2 * 2 * 2 - 1)
  260   ASSERT_EQ((int)MS.size(), 1 /* Default */ +
  272   ASSERT_EQ((int)MS.size(), 1 /* Default */ +
  335     ASSERT_EQ(Selection.gccSuffix(), Suffix) << "Selection picked " << Selection
  346   ASSERT_EQ(Latte.size(), (unsigned)0);
  348   ASSERT_EQ(Latte.size(), (unsigned)1);
  350   ASSERT_EQ(Latte.size(), (unsigned)2);
tools/clang/unittests/Format/FormatTest.cpp
14273   ASSERT_EQ(*Style1, getGoogleStyle());
14286   ASSERT_EQ(*Style1, getLLVMStyle());
14293   ASSERT_EQ(*Style2, getMozillaStyle());
14298   ASSERT_EQ(*Style2, getNoStyle());
14306   ASSERT_EQ(*Style2, getLLVMStyle());
14311   ASSERT_EQ(*Style2, getLLVMStyle());
14321   ASSERT_EQ(*Style3, getGoogleStyle());
14352   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
tools/clang/unittests/Frontend/CompilerInstanceTest.cpp
   91   ASSERT_EQ(DiagnosticsOS.str(), "error: expected no crash\n");
tools/clang/unittests/Frontend/FrontendActionTest.cpp
   97   ASSERT_EQ(2U, test_action.decl_names.size());
  117   ASSERT_EQ(2U, test_action.decl_names.size());
  145   ASSERT_EQ(13U, test_action.decl_names.size());
tools/clang/unittests/Frontend/PCHPreambleTest.cpp
  143   ASSERT_EQ(AST->getPreambleCounterForTests(), 1U);
  164   ASSERT_EQ(AST->getPreambleCounterForTests(), 1U);
  183   ASSERT_EQ(AST->getPreambleCounterForTests(), 1U);
  189   ASSERT_EQ(AST->getPreambleCounterForTests(), 1U);
  217   ASSERT_EQ(initialCounts[1], GetFileReadCount(Header1));
  218   ASSERT_EQ(initialCounts[2], GetFileReadCount(Header2));
  240   ASSERT_EQ(HeaderReadCount, GetFileReadCount(Header));
tools/clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp
   35   ASSERT_EQ(1u, Tokens.size());
   36   ASSERT_EQ(pp_eof, Tokens.back().K);
   41   ASSERT_EQ(1u, Tokens.size());
   42   ASSERT_EQ(pp_eof, Tokens.back().K);
   94   ASSERT_EQ(2u, Tokens.size());
   95   ASSERT_EQ(pp_define, Tokens.front().K);
  584   ASSERT_EQ(Tokens.size(), 3u);
  678   ASSERT_EQ(Tokens.size(), 12u);
tools/clang/unittests/Lex/HeaderMapTest.cpp
  138   ASSERT_EQ(3 * sizeof(HMapBucket), sizeof(File.Buckets));
  179   ASSERT_EQ("bc", Map.lookupFilename("a", DestPath));
  204   ASSERT_EQ('c', File.Bytes[5]);
  206     ASSERT_EQ(0, File.Bytes[I]);
  219   ASSERT_EQ("", Map.lookupFilename("a", DestPath));
  239   ASSERT_EQ('b', File.Bytes[5]);
  241     ASSERT_EQ(0, File.Bytes[I]);
  254   ASSERT_EQ("", Map.lookupFilename("a", DestPath));
tools/clang/unittests/Lex/PPCallbacksTest.cpp
  314   ASSERT_EQ(SrcMgr::CharacteristicKind::C_User, Kind);
  324   ASSERT_EQ("\"quoted.h\"", GetSourceString(Range));
  334   ASSERT_EQ("<angled.h>", GetSourceString(Range));
  345   ASSERT_EQ("\"quoted.h\"", GetSourceString(Range));
  356   ASSERT_EQ("<angled.h>", GetSourceString(Range));
  367   ASSERT_EQ("\"quoted.h\"", GetSourceString(Range));
  379   ASSERT_EQ("<angled.h>", GetSourceString(Range));
  389   ASSERT_EQ("\"tri\?\?-graph.h\"", GetSourceString(Range));
  400   ASSERT_EQ("\"tri\?\?-graph.h\"", GetSourceString(Range));
  410   ASSERT_EQ("cl_khr_fp64", Parameters.Name);
  412   ASSERT_EQ(ExpectedState, Parameters.State);
  422   ASSERT_EQ("cl_khr_fp16", Parameters.Name);
  424   ASSERT_EQ(ExpectedState, Parameters.State);
tools/clang/unittests/Lex/PPConditionalDirectiveRecordTest.cpp
   99   ASSERT_EQ(10U, toks.size());
tools/clang/unittests/Sema/ExternalSemaSourceTest.cpp
  229   ASSERT_EQ(0, Watcher.SeenCount);
  244   ASSERT_EQ(1, Watcher.SeenCount);
  264   ASSERT_EQ(0, Third.CallCount);
  265   ASSERT_EQ(1, Watcher.SeenCount);
  279   ASSERT_EQ(1, Watcher.SeenCount);
  295   ASSERT_EQ(0, Diagnoser.CallCount);
  312   ASSERT_EQ(1, First.CallCount);
  313   ASSERT_EQ(1, Second.CallCount);
  314   ASSERT_EQ(0, Third.CallCount);
tools/clang/unittests/StaticAnalyzer/StoreTest.cpp
   51     ASSERT_EQ(Zero, StMgr.getBinding(StX0, LX0, ACtx.IntTy));
   56     ASSERT_EQ(Zero, StMgr.getBinding(StY0, LY0, ACtx.IntTy));
   57     ASSERT_EQ(Zero, *StMgr.getDefaultBinding(StY0, LY0.getAsRegion()));
   65     ASSERT_EQ(Zero, StMgr.getBinding(StZ0, LZ0, ACtx.IntTy));
   66     ASSERT_EQ(NarrowZero, *StMgr.getDefaultBinding(StZ0, LZ0.getAsRegion()));
   71     ASSERT_EQ(One, StMgr.getBinding(StX1, LX1, ACtx.IntTy));
   76     ASSERT_EQ(One, StMgr.getBinding(StY1, LY1, ACtx.IntTy));
   77     ASSERT_EQ(One, *StMgr.getDefaultBinding(StY1, LY1.getAsRegion()));
tools/clang/unittests/Tooling/ASTSelectionTest.cpp
   94   ASSERT_EQ(Node.SelectionKind, SelectionKind);
  100   ASSERT_EQ(ND->getName(), Name);
  133       ASSERT_EQ(Node.SelectionKind, SelectionKind);
  170         ASSERT_EQ(OS.str(), "FunctionDecl \"f\" contains-selection\n");
tools/clang/unittests/Tooling/CompilationDatabaseTest.cpp
  142   ASSERT_EQ(1u, Commands[0].CommandLine.size());
  147   ASSERT_EQ(1u, Commands[1].CommandLine.size());
  166   ASSERT_EQ(1u, Commands[0].CommandLine.size());
  170   ASSERT_EQ(1u, Commands[1].CommandLine.size());
  304   ASSERT_EQ(4u, FoundCommand.CommandLine.size()) << ErrorMessage;
  332   ASSERT_EQ(2u, FoundCommand.CommandLine.size());
  369   ASSERT_EQ(1u, FoundCommand.CommandLine.size()) << ErrorMessage;
  416   ASSERT_EQ(3ul, Result.size());
  424   ASSERT_EQ(2ul, Result.size());
  431   ASSERT_EQ(1ul, Backslash.size());
  434   ASSERT_EQ(1ul, Quote.size());
  440   ASSERT_EQ(1ul, Result.size());
  447   ASSERT_EQ(2ul, Result.size());
  455   ASSERT_EQ(1ul, Result.size());
  462   ASSERT_EQ(1ul, Result.size());
  469   ASSERT_EQ(4ul, Result.size());
  479   ASSERT_EQ(1ul, QuotedNoSpaces.size());
  484   ASSERT_EQ(1ul, MixedNoSpaces.size());
  490   ASSERT_EQ(1ul, Unclosed.size());
  494   ASSERT_EQ(1ul, Empty.size());
  500   ASSERT_EQ(1ul, Args.size());
  509   ASSERT_EQ(1ul, Result.size());
  567   ASSERT_EQ(1ul, Result.size());
  568   ASSERT_EQ(".", Result[0].Directory);
  584   ASSERT_EQ(1ul, Result.size());
  585   ASSERT_EQ(".", Result[0].Directory);
  601   ASSERT_EQ(1ul, Result.size());
  602   ASSERT_EQ(".", Result[0].Directory);
  619   ASSERT_EQ(1ul, Result.size());
  620   ASSERT_EQ(".", Result[0].Directory);
  636   ASSERT_EQ(1ul, Result.size());
  637   ASSERT_EQ(".", Result[0].Directory);
tools/clang/unittests/Tooling/DependencyScannerTest.cpp
  104   ASSERT_EQ(Deps.size(), 3u);
  117   ASSERT_EQ(Deps.size(), 3u);
  155   ASSERT_EQ(Deps.size(), 6u);
  190   ASSERT_EQ(Deps.size(), 6u);
tools/clang/unittests/Tooling/DiagnosticsYamlTest.cpp
  121   ASSERT_EQ(3u, TUDActual.Diagnostics.size());
  140   ASSERT_EQ(1u, Fixes1.size());
  152   ASSERT_EQ(1u, Fixes2.size());
tools/clang/unittests/Tooling/ExecutionTest.cpp
  205   ASSERT_EQ(KVs.size(), 0u);
  218   ASSERT_EQ(KVs.size(), 1u);
tools/clang/unittests/Tooling/RecursiveASTVisitorTestPostOrderVisitor.cpp
   92   ASSERT_EQ(expected.size(), Visitor.VisitedNodes.size());
   94     ASSERT_EQ(expected[I], Visitor.VisitedNodes[I]);
  111   ASSERT_EQ(expected.size(), Visitor.VisitedNodes.size());
  113     ASSERT_EQ(expected[I], Visitor.VisitedNodes[I]);
tools/clang/unittests/Tooling/RefactoringActionRulesTest.cpp
  111     ASSERT_EQ(Result.size(), 1u);
tools/clang/unittests/Tooling/ReplacementsYamlTest.cpp
   90   ASSERT_EQ(2u, DocActual.Replacements.size());
   91   ASSERT_EQ("/path/to/source.cpp", DocActual.MainSourceFile);
   92   ASSERT_EQ("/path/to/file1.h", DocActual.Replacements[0].getFilePath());
   93   ASSERT_EQ(232u, DocActual.Replacements[0].getOffset());
   94   ASSERT_EQ(56u, DocActual.Replacements[0].getLength());
   95   ASSERT_EQ("replacement #1", DocActual.Replacements[0].getReplacementText());
   96   ASSERT_EQ("/path/to/file2.h", DocActual.Replacements[1].getFilePath());
   97   ASSERT_EQ(301u, DocActual.Replacements[1].getOffset());
   98   ASSERT_EQ(2u, DocActual.Replacements[1].getLength());
   99   ASSERT_EQ("replacement #2", DocActual.Replacements[1].getReplacementText());
  116   ASSERT_EQ("/path/to/source.cpp", DocActual.MainSourceFile);
  117   ASSERT_EQ(1u, DocActual.Replacements.size());
  118   ASSERT_EQ("target_file.h", DocActual.Replacements[0].getFilePath());
  119   ASSERT_EQ(1u, DocActual.Replacements[0].getOffset());
  120   ASSERT_EQ(10u, DocActual.Replacements[0].getLength());
  121   ASSERT_EQ("replacement", DocActual.Replacements[0].getReplacementText());
tools/clang/unittests/libclang/LibclangTest.cpp
  719     ASSERT_EQ(6u, NumTokens);
tools/lldb/unittests/Host/HostTest.cpp
   25   ASSERT_EQ("Host::GetEnvironment",
tools/lldb/unittests/Host/MainLoopTest.cpp
   84   ASSERT_EQ(1u, callback_count);
  101   ASSERT_EQ(1u, callback_count);
  124   ASSERT_EQ(1u, callback_count);
  136   ASSERT_EQ(1u, callback_count);
  148   ASSERT_EQ(0, sigaction(SIGUSR2, &sa, nullptr));
  160   ASSERT_EQ(1u, callback_count);
tools/lldb/unittests/Host/SocketAddressTest.cpp
   31   ASSERT_EQ(1138, sa.GetPort());
   35   ASSERT_EQ(0, sa.GetPort());
   41   ASSERT_EQ(1139, sa.GetPort());
   47   ASSERT_EQ(1u, addr.size());
tools/lldb/unittests/Host/TaskPoolTest.cpp
   15   ASSERT_EQ(10, f3.get());
   16   ASSERT_EQ(2, f1.get());
   17   ASSERT_EQ(17, f4.get());
   18   ASSERT_EQ(5, f2.get());
   29   ASSERT_EQ(2, r[0]);
   30   ASSERT_EQ(5, r[1]);
   31   ASSERT_EQ(10, r[2]);
   32   ASSERT_EQ(17, r[3]);
   41   ASSERT_EQ(data[0], 0);
   42   ASSERT_EQ(data[1], 1);
   43   ASSERT_EQ(data[2], 4);
   44   ASSERT_EQ(data[3], 9);
tools/lldb/unittests/Interpreter/TestCompletion.cpp
  120     ASSERT_EQ(4u, Results.GetSize());
  128     ASSERT_EQ(2u, Results.GetSize());
  161   ASSERT_EQ(1u, Results.GetSize());
  165   ASSERT_EQ(0u, Results.GetSize());
  169   ASSERT_EQ(7u, Results.GetSize());
  193   ASSERT_EQ(1u, Results.GetSize());
  199   ASSERT_EQ(1u, Results.GetSize());
  204   ASSERT_EQ(13u, Results.GetSize());
  222   ASSERT_EQ(5u, Results.GetSize());
tools/lldb/unittests/ObjectFile/ELF/TestObjectFileELF.cpp
  168   ASSERT_EQ(1u, ObjectFile::GetModuleSpecifications(FileSpec(SO), 0, 0, Specs));
  238   ASSERT_EQ(entry_point_addr.GetAddressClass(),
  299   ASSERT_EQ(entry_point_addr.GetAddressClass(), AddressClass::eCode);
tools/lldb/unittests/Process/Linux/ProcessorTraceTest.cpp
   40   ASSERT_EQ(0u, bytes_read);
   45   ASSERT_EQ(0u, bytes_read);
   51   ASSERT_EQ(0u, bytes_read);
   57   ASSERT_EQ(0u, bytes_read);
   63   ASSERT_EQ(0u, bytes_read);
   78     ASSERT_EQ((sizeof(cyclic) - i - 1), bytes_read);
   93   ASSERT_EQ(3u, bytes_read);
   99   ASSERT_EQ(3u, bytes_read);
  105   ASSERT_EQ(3u, bytes_read);
  111   ASSERT_EQ(3u, bytes_read);
  119     ASSERT_EQ(2u, bytes_read);
  127     ASSERT_EQ(1u, bytes_read);
  144     ASSERT_EQ((sizeof(cyclic) - i - 1), bytes_read);
tools/lldb/unittests/Process/POSIX/NativeProcessELFTest.cpp
   61   ASSERT_EQ(phdr_addr, process.GetAuxValue(AuxVector::AUXV_AT_PHDR));
  112   ASSERT_EQ(mem_extractor.GetAddress(&info_addr_offset), info_addr);
  154   ASSERT_EQ(elf_info_addr, LLDB_INVALID_ADDRESS);
tools/lldb/unittests/Process/gdb-remote/GDBRemoteClientBaseTest.cpp
   52     ASSERT_EQ(TestClient::eBroadcastBitRunPacketSent,
   81   ASSERT_EQ(PacketResult::Success, server.SendPacket("T01"));
   82   ASSERT_EQ(eStateStopped, SendCPacket(response));
   83   ASSERT_EQ("T01", response.GetStringRef());
   84   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
   85   ASSERT_EQ("c", response.GetStringRef());
   88   ASSERT_EQ(PacketResult::Success, server.SendPacket("W01"));
   89   ASSERT_EQ(eStateExited, SendCPacket(response));
   90   ASSERT_EQ("W01", response.GetStringRef());
   91   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
   92   ASSERT_EQ("c", response.GetStringRef());
   95   ASSERT_EQ(PacketResult::Success, server.SendPacket("X01"));
   96   ASSERT_EQ(eStateExited, SendCPacket(response));
   97   ASSERT_EQ("X01", response.GetStringRef());
   98   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
   99   ASSERT_EQ("c", response.GetStringRef());
  111   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  112   ASSERT_EQ("c", response.GetStringRef());
  119   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  120   ASSERT_EQ("\x03", response.GetStringRef());
  121   ASSERT_EQ(PacketResult::Success, server.SendPacket("T13"));
  124   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  125   ASSERT_EQ("C47", response.GetStringRef());
  129   ASSERT_EQ(PacketResult::Success, server.SendPacket("T47"));
  130   ASSERT_EQ(eStateStopped, continue_state.get());
  131   ASSERT_EQ("T47", continue_response.GetStringRef());
  141   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  142   ASSERT_EQ("c", response.GetStringRef());
  146   ASSERT_EQ(
  156   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  157   ASSERT_EQ("\x03", response.GetStringRef());
  158   ASSERT_EQ(PacketResult::Success, server.SendPacket("T13"));
  161   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  162   ASSERT_EQ("qTest2", response.GetStringRef());
  165   ASSERT_EQ(PacketResult::Success, server.SendPacket("QTest2"));
  166   ASSERT_EQ(PacketResult::Success, async_result.get());
  167   ASSERT_EQ("QTest2", async_response.GetStringRef());
  170   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  171   ASSERT_EQ("c", response.GetStringRef());
  172   ASSERT_EQ(PacketResult::Success, server.SendPacket("T01"));
  173   ASSERT_EQ(eStateStopped, continue_state.get());
  174   ASSERT_EQ("T01", continue_response.GetStringRef());
  186   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  187   ASSERT_EQ("c", response.GetStringRef());
  194   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  195   ASSERT_EQ("\x03", response.GetStringRef());
  196   ASSERT_EQ(PacketResult::Success, server.SendPacket("T13"));
  199   ASSERT_EQ(eStateStopped, continue_state.get());
  200   ASSERT_EQ("T13", continue_response.GetStringRef());
  210   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  211   ASSERT_EQ("c", response.GetStringRef());
  219   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  220   ASSERT_EQ("\x03", response.GetStringRef());
  221   ASSERT_EQ(PacketResult::Success, server.SendPacket("T01"));
  222   ASSERT_EQ(eStateStopped, continue_state.get());
  223   ASSERT_EQ("T01", continue_response.GetStringRef());
  227   ASSERT_EQ(PacketResult::Success, server.SendPacket("T01"));
  228   ASSERT_EQ(eStateStopped, SendCPacket(response));
  229   ASSERT_EQ("T01", response.GetStringRef());
  230   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  231   ASSERT_EQ("c", response.GetStringRef());
  244   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  245   ASSERT_EQ("c", response.GetStringRef());
  252   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  253   ASSERT_EQ("\x03", response.GetStringRef());
  254   ASSERT_EQ(PacketResult::Success, server.SendPacket("T13"));
  255   ASSERT_EQ(PacketResult::Success, server.SendPacket("T13"));
  258   ASSERT_EQ(eStateStopped, continue_state.get());
  259   ASSERT_EQ("T13", continue_response.GetStringRef());
  267   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  268   ASSERT_EQ("qTest", response.GetStringRef());
  269   ASSERT_EQ(PacketResult::Success, server.SendPacket("QTest"));
  270   ASSERT_EQ(PacketResult::Success, send_result.get());
  271   ASSERT_EQ("QTest", async_response.GetStringRef());
  279   ASSERT_EQ(PacketResult::Success, server.SendPacket("O4142"));
  280   ASSERT_EQ(PacketResult::Success, server.SendPacket("Apro"));
  281   ASSERT_EQ(PacketResult::Success, server.SendPacket("O4344"));
  282   ASSERT_EQ(PacketResult::Success, server.SendPacket("Afile"));
  283   ASSERT_EQ(PacketResult::Success, server.SendPacket("T01"));
  284   ASSERT_EQ(eStateStopped, SendCPacket(response));
  285   ASSERT_EQ("T01", response.GetStringRef());
  286   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  287   ASSERT_EQ("c", response.GetStringRef());
  310   ASSERT_EQ(PacketResult::Success, server.SendPacket(stream.GetData()));
  311   ASSERT_EQ(PacketResult::Success, server.SendPacket("T01"));
  312   ASSERT_EQ(eStateStopped, SendCPacket(response));
  313   ASSERT_EQ("T01", response.GetStringRef());
  314   ASSERT_EQ(1ul, delegate.structured_data_packets.size());
  318   ASSERT_EQ(json_packet, delegate.structured_data_packets[0]);
  327   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  328   ASSERT_EQ("c", response.GetStringRef());
  335   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  336   ASSERT_EQ("\x03", response.GetStringRef());
  340   ASSERT_EQ(eStateInvalid, continue_state.get());
  347   ASSERT_EQ(PacketResult::Success, server.SendPacket("O"));
  348   ASSERT_EQ(PacketResult::Success, server.SendPacket("O48656c6c6f2c"));
  349   ASSERT_EQ(PacketResult::Success, server.SendPacket("O20"));
  350   ASSERT_EQ(PacketResult::Success, server.SendPacket("O"));
  351   ASSERT_EQ(PacketResult::Success, server.SendPacket("O776f726c64"));
  352   ASSERT_EQ(PacketResult::Success, server.SendPacket("OK"));
  358   ASSERT_EQ(PacketResult::Success, result);
  359   ASSERT_EQ("OK", response.GetStringRef());
  360   ASSERT_EQ("Hello, world", command_output.GetString().str());
tools/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
   37   ASSERT_EQ(PacketResult::Success, server.GetPacket(request));
   38   ASSERT_EQ("QThreadSuffixSupported", request.GetStringRef());
   40     ASSERT_EQ(PacketResult::Success, server.SendOKResponse());
   42     ASSERT_EQ(PacketResult::Success, server.SendUnimplementedResponse(nullptr));
   49   ASSERT_EQ(PacketResult::Success, server.GetPacket(request));
   51   ASSERT_EQ(PacketResult::Success, server.SendPacket(response));
  128   ASSERT_EQ(0,
  136   ASSERT_EQ(0,
  194   ASSERT_EQ(1u, result->size());
  219   ASSERT_EQ(1u, result->size());
  264     ASSERT_EQ(0u, result->size()) << "response was: " << response;
  275       ASSERT_EQ(PacketResult::Success, result);
  281       ASSERT_EQ(PacketResult::Success, server.SendPacket(response));
  304   ASSERT_EQ(10, num_packets);
  392   ASSERT_EQ(result.get(), 1u);
  400   ASSERT_EQ(result.get(), LLDB_INVALID_UID);
  441   ASSERT_EQ(buffer.size(), 3u);
  442   ASSERT_EQ(buf[0], 0x12);
  443   ASSERT_EQ(buf[1], 0x34);
  444   ASSERT_EQ(buf[2], 0x56);
  453   ASSERT_EQ(buffer2.size(), 0u);
  473   ASSERT_EQ(buffer.size(), 3u);
  474   ASSERT_EQ(buf[0], 0x12);
  475   ASSERT_EQ(buf[1], 0x34);
  476   ASSERT_EQ(buf[2], 0x56);
  485   ASSERT_EQ(buffer2.size(), 0u);
  505   ASSERT_EQ(options.getTraceBufferSize(), 8192u);
  506   ASSERT_EQ(options.getMetaDataBufferSize(), 8192u);
  507   ASSERT_EQ(options.getType(), 1);
  515   ASSERT_EQ(custom_params->GetType(), eStructuredDataTypeDictionary);
  517   ASSERT_EQ(psb_value, 1u);
tools/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationTest.cpp
   63     ASSERT_EQ(PacketResult::Success, client.ReadPacket(response));
   64     ASSERT_EQ(Test.Payload, response.GetStringRef());
   65     ASSERT_EQ(PacketResult::Success, server.GetAck());
tools/lldb/unittests/Process/minidump/MinidumpParserTest.cpp
  112   ASSERT_EQ(1UL, thread_list.size());
  139   ASSERT_EQ(llvm::Triple::ArchType::x86_64,
  141   ASSERT_EQ(llvm::Triple::OSType::Linux,
  189   ASSERT_EQ(16001UL, pid);
  223   ASSERT_EQ(16001UL, pid.getValue());
  247   ASSERT_EQ(1u, filtered_modules.size());
  258   ASSERT_EQ(11UL, exception_stream->ExceptionRecord.ExceptionCode);
  500   ASSERT_EQ(llvm::Triple::ArchType::x86,
  502   ASSERT_EQ(llvm::Triple::OSType::Win32,
  524   ASSERT_EQ(4440UL, pid.getValue());
  531   ASSERT_EQ(4440UL, pid.getValue());
  539   ASSERT_EQ(7836UL, pid.getValue());
  689   ASSERT_EQ(1u, filtered_modules.size());
  715   ASSERT_EQ(2u, filtered_modules.size());
tools/lldb/unittests/Process/minidump/RegisterContextMinidumpTest.cpp
   59   ASSERT_EQ(RegInterface->GetGPRSize(), Buf->GetByteSize());
  120   ASSERT_EQ(RegInterface->GetGPRSize(), Buf->GetByteSize());
tools/lldb/unittests/Signals/UnixSignalsTest.cpp
   34   ASSERT_EQ(expected.size(), observed.size()) << location;
   37     ASSERT_EQ(expected[i], observed[i])
tools/lldb/unittests/Symbol/TestDWARFCallFrameInfo.cpp
  253   ASSERT_EQ(3, plan.GetRowCount());
tools/lldb/unittests/Symbol/TestLineEntry.cpp
   90   ASSERT_EQ(range.GetByteSize(), (uint64_t)0x24);
   99   ASSERT_EQ(range.GetByteSize(), (uint64_t)0x49);
  108   ASSERT_EQ(range.GetByteSize(), (uint64_t)0x33);
tools/lldb/unittests/Utility/ArchSpecTest.cpp
  237   ASSERT_EQ(A.GetCore(), ArchSpec::eCore_uknownMach64);
tools/lldb/unittests/Utility/ArgsTest.cpp
  105   ASSERT_EQ(5u, args.GetArgumentCount());
  154   ASSERT_EQ(3u, args.GetArgumentCount());
  192   ASSERT_EQ(2u, args.GetArgumentCount());
  200   ASSERT_EQ(4u, args.GetArgumentCount());
  215   ASSERT_EQ(2u, ref.size());
tools/lldb/unittests/Utility/DataExtractorTest.cpp
   24   ASSERT_EQ(buffer[1], LE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8));
   26   ASSERT_EQ(buffer[1], BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8));
   29   ASSERT_EQ(int8_t(buffer[1]),
   32   ASSERT_EQ(int8_t(buffer[1]),
tools/lldb/unittests/Utility/EnvironmentTest.cpp
   27   ASSERT_EQ(2u, Env4.size());
tools/lldb/unittests/Utility/ListenerTest.cpp
   26   ASSERT_EQ(event_mask,
   63   ASSERT_EQ(event_mask,
tools/lldb/unittests/Utility/LogTest.cpp
  249   ASSERT_EQ("", takeOutput());
  255   ASSERT_EQ("Foo failed: My Error\n", takeOutput());
tools/lldb/unittests/Utility/OptionsWithRawTest.cpp
   62   ASSERT_EQ(args.GetArgString(), "-foo ");
   63   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo --");
   66   ASSERT_EQ(1u, ref.size());
   77   ASSERT_EQ(args.GetArgString(), "-foo ");
   78   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo -- ");
   81   ASSERT_EQ(1u, ref.size());
   91   ASSERT_EQ(args.GetArgString(), "-foo ");
   92   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo -- ");
   95   ASSERT_EQ(1u, ref.size());
  105   ASSERT_EQ(args.GetArgString(), " -foo ");
  106   ASSERT_EQ(args.GetArgStringWithDelimiter(), " -foo -- ");
  109   ASSERT_EQ(1u, ref.size());
  119   ASSERT_EQ(args.GetArgString(), "-foo ");
  120   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo -- ");
  123   ASSERT_EQ(1u, ref.size());
  133   ASSERT_EQ(args.GetArgString(), "-foo ");
  134   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo -- ");
  137   ASSERT_EQ(1u, ref.size());
  147   ASSERT_EQ(args.GetArgString(), "-foo ");
  148   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo -- ");
  151   ASSERT_EQ(1u, ref.size());
  161   ASSERT_EQ(args.GetArgString(), "-foo ");
  162   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo -- ");
  165   ASSERT_EQ(1u, ref.size());
  175   ASSERT_EQ(args.GetArgString(), "");
  176   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-- ");
  179   ASSERT_EQ(0u, ref.size());
tools/lldb/unittests/Utility/ScalarTest.cpp
   76   ASSERT_EQ(a >> c, a_scalar >> c_scalar);
   77   ASSERT_EQ(b >> c, b_scalar >> c_scalar);
  102   ASSERT_EQ(0, memcmp(&a, a_scalar.GetBytes(), sizeof(a)));
  103   ASSERT_EQ(0, memcmp(&b, b_scalar.GetBytes(), sizeof(b)));
  104   ASSERT_EQ(0, memcmp(&c, c_scalar.GetBytes(), sizeof(c)));
  105   ASSERT_EQ(0, memcmp(&d, d_scalar.GetBytes(), sizeof(d)));
  106   ASSERT_EQ(0, e_error.Fail());
  107   ASSERT_EQ(0, memcmp(e, e_scalar.GetBytes(), sizeof(e)));
  108   ASSERT_EQ(0, f_error.Fail());
  109   ASSERT_EQ(0, memcmp(f, f_scalar.GetBytes(), sizeof(f)));
  115   ASSERT_EQ((signed char)a, a_scalar.SChar());
  116   ASSERT_EQ((unsigned char)a, a_scalar.UChar());
  117   ASSERT_EQ((signed short)a, a_scalar.SShort());
  118   ASSERT_EQ((unsigned short)a, a_scalar.UShort());
  119   ASSERT_EQ((signed int)a, a_scalar.SInt());
  120   ASSERT_EQ((unsigned int)a, a_scalar.UInt());
  121   ASSERT_EQ((signed long)a, a_scalar.SLong());
  122   ASSERT_EQ((unsigned long)a, a_scalar.ULong());
  123   ASSERT_EQ((signed long long)a, a_scalar.SLongLong());
  124   ASSERT_EQ((unsigned long long)a, a_scalar.ULongLong());
  128   ASSERT_EQ((float)a2, a2_scalar.Float());
  129   ASSERT_EQ((double)a2, a2_scalar.Double());
  130   ASSERT_EQ((long double)a2, a2_scalar.LongDouble());
  140   ASSERT_EQ(0, memcmp(&a1, s_scalar.GetBytes(), sizeof(a1)));
  142   ASSERT_EQ(0, memcmp(&a1, s_scalar.GetBytes(), sizeof(a1)));
  144   ASSERT_EQ(0, memcmp(&b1, s_scalar.GetBytes(), sizeof(b1)));
  150   ASSERT_EQ(0, memcmp(&a2, u_scalar.GetBytes(), sizeof(a2)));
  152   ASSERT_EQ(0, memcmp(&a2, u_scalar.GetBytes(), sizeof(a2)));
  154   ASSERT_EQ(0, memcmp(&b2, u_scalar.GetBytes(), sizeof(b2)));
tools/lldb/unittests/Utility/StreamTeeTest.cpp
   18   ASSERT_EQ(0U, tee.GetNumStreams());
   26   ASSERT_EQ(1U, tee.GetNumStreams());
   36   ASSERT_EQ(2U, tee.GetNumStreams());
   48   ASSERT_EQ(2U, tee2.GetNumStreams());
   60   ASSERT_EQ(2U, tee2.GetNumStreams());
   76   ASSERT_EQ(2U, tee.GetNumStreams());
  109   ASSERT_EQ(2U, tee.GetNumStreams());
  128   ASSERT_EQ(0U, tee.GetNumStreams());
  131   ASSERT_EQ(1U, tee.GetNumStreams());
  135   ASSERT_EQ(2U, tee.GetNumStreams());
  145   ASSERT_EQ(1U, tee.GetNumStreams());
  152   ASSERT_EQ(0U, tee.GetNumStreams());
  162   ASSERT_EQ(1U, tee.GetNumStreams());
  178   ASSERT_EQ(1U, tee.GetNumStreams());
tools/lldb/unittests/Utility/StringExtractorTest.cpp
   14   ASSERT_EQ(true, ex.IsGood());
   15   ASSERT_EQ(0u, ex.GetFilePos());
   16   ASSERT_EQ(kEmptyString, ex.GetStringRef());
   17   ASSERT_EQ(true, ex.Empty());
   18   ASSERT_EQ(0u, ex.GetBytesLeft());
   19   ASSERT_EQ(nullptr, ex.Peek());
   26   ASSERT_EQ(true, ex.IsGood());
   27   ASSERT_EQ(0u, ex.GetFilePos());
   28   ASSERT_EQ(kInitMiscString, ex.GetStringRef());
   29   ASSERT_EQ(false, ex.Empty());
   30   ASSERT_EQ(kInitMiscString.size(), ex.GetBytesLeft());
   31   ASSERT_EQ(kInitMiscString[0], *ex.Peek());
   38   ASSERT_EQ(-1, ex.DecodeHexU8());
   39   ASSERT_EQ(true, ex.IsGood());
   40   ASSERT_EQ(0u, ex.GetFilePos());
   41   ASSERT_EQ(true, ex.Empty());
   42   ASSERT_EQ(0u, ex.GetBytesLeft());
   43   ASSERT_EQ(nullptr, ex.Peek());
   49   ASSERT_EQ(-1, ex.DecodeHexU8());
   50   ASSERT_EQ(true, ex.IsGood());
   51   ASSERT_EQ(0u, ex.GetFilePos());
   52   ASSERT_EQ(1u, ex.GetBytesLeft());
   53   ASSERT_EQ('1', *ex.Peek());
   60   ASSERT_EQ(-1, ex.DecodeHexU8());
   61   ASSERT_EQ(true, ex.IsGood());
   62   ASSERT_EQ(0u, ex.GetFilePos());
   63   ASSERT_EQ(2u, ex.GetBytesLeft());
   64   ASSERT_EQ('x', *ex.Peek());
   71   ASSERT_EQ(-1, ex.DecodeHexU8());
   72   ASSERT_EQ(true, ex.IsGood());
   73   ASSERT_EQ(0u, ex.GetFilePos());
   74   ASSERT_EQ(2u, ex.GetBytesLeft());
   75   ASSERT_EQ('a', *ex.Peek());
   82   ASSERT_EQ(0x12, ex.DecodeHexU8());
   83   ASSERT_EQ(true, ex.IsGood());
   84   ASSERT_EQ(2u, ex.GetFilePos());
   85   ASSERT_EQ(0u, ex.GetBytesLeft());
   86   ASSERT_EQ(nullptr, ex.Peek());
   93   ASSERT_EQ(0x12, ex.DecodeHexU8());
   94   ASSERT_EQ(true, ex.IsGood());
   95   ASSERT_EQ(2u, ex.GetFilePos());
   96   ASSERT_EQ(2u, ex.GetBytesLeft());
   97   ASSERT_EQ('3', *ex.Peek());
  104   ASSERT_EQ(0xab, ex.GetHexU8(0xab));
  105   ASSERT_EQ(false, ex.IsGood());
  106   ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
  107   ASSERT_EQ(true, ex.Empty());
  108   ASSERT_EQ(0u, ex.GetBytesLeft());
  109   ASSERT_EQ(nullptr, ex.Peek());
  116   ASSERT_EQ(0xbc, ex.GetHexU8(0xbc));
  117   ASSERT_EQ(false, ex.IsGood());
  118   ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
  119   ASSERT_EQ(0u, ex.GetBytesLeft());
  120   ASSERT_EQ(nullptr, ex.Peek());
  127   ASSERT_EQ(0xcd, ex.GetHexU8(0xcd));
  128   ASSERT_EQ(false, ex.IsGood());
  129   ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
  130   ASSERT_EQ(0u, ex.GetBytesLeft());
  131   ASSERT_EQ(nullptr, ex.Peek());
  138   ASSERT_EQ(0x12, ex.GetHexU8(0x12));
  139   ASSERT_EQ(true, ex.IsGood());
  140   ASSERT_EQ(2u, ex.GetFilePos());
  141   ASSERT_EQ(0u, ex.GetBytesLeft());
  142   ASSERT_EQ(nullptr, ex.Peek());
  149   ASSERT_EQ(0x12, ex.GetHexU8(0x12));
  150   ASSERT_EQ(true, ex.IsGood());
  151   ASSERT_EQ(2u, ex.GetFilePos());
  152   ASSERT_EQ(2u, ex.GetBytesLeft());
  153   ASSERT_EQ('3', *ex.Peek());
  161   ASSERT_EQ(0xab, ex.GetHexU8(0xab, kSetEofOnFail));
  162   ASSERT_EQ(false, ex.IsGood()); // this result seems inconsistent with
  164   ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
  165   ASSERT_EQ(true, ex.Empty());
  166   ASSERT_EQ(0u, ex.GetBytesLeft());
  167   ASSERT_EQ(nullptr, ex.Peek());
  175   ASSERT_EQ(0xbc, ex.GetHexU8(0xbc, kSetEofOnFail));
  176   ASSERT_EQ(true, ex.IsGood());
  177   ASSERT_EQ(0u, ex.GetFilePos());
  178   ASSERT_EQ(1u, ex.GetBytesLeft());
  179   ASSERT_EQ('1', *ex.Peek());
  187   ASSERT_EQ(0xcd, ex.GetHexU8(0xcd, kSetEofOnFail));
  188   ASSERT_EQ(true, ex.IsGood());
  189   ASSERT_EQ(0u, ex.GetFilePos());
  190   ASSERT_EQ(2u, ex.GetBytesLeft());
  191   ASSERT_EQ('x', *ex.Peek());
  199   ASSERT_EQ(0x12, ex.GetHexU8(0x12, kSetEofOnFail));
  200   ASSERT_EQ(true, ex.IsGood());
  201   ASSERT_EQ(2u, ex.GetFilePos());
  202   ASSERT_EQ(0u, ex.GetBytesLeft());
  203   ASSERT_EQ(nullptr, ex.Peek());
  211   ASSERT_EQ(0x12, ex.GetHexU8(0x12, kSetEofOnFail));
  212   ASSERT_EQ(true, ex.IsGood());
  213   ASSERT_EQ(2u, ex.GetFilePos());
  214   ASSERT_EQ(2u, ex.GetBytesLeft());
  215   ASSERT_EQ('3', *ex.Peek());
  224   ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
  234   ASSERT_EQ(true, ex.IsGood());
  235   ASSERT_EQ(2 * kValidHexPairs, ex.GetFilePos());
  236   ASSERT_EQ(false, ex.Empty());
  237   ASSERT_EQ(4u, ex.GetBytesLeft());
  238   ASSERT_EQ('x', *ex.Peek());
  247   ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
  264   ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
  283   ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
  301   ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
  316   ASSERT_EQ(false, ex.IsGood());
  317   ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
  318   ASSERT_EQ(false, ex.Empty());
  319   ASSERT_EQ(0u, ex.GetBytesLeft());
  320   ASSERT_EQ(nullptr, ex.Peek());
  330   ASSERT_EQ(
  347   ASSERT_EQ(true, ex.IsGood());
  348   ASSERT_EQ(kReadBytes * 2, ex.GetFilePos());
  349   ASSERT_EQ(false, ex.Empty());
  350   ASSERT_EQ(12u, ex.GetBytesLeft());
  351   ASSERT_EQ('2', *ex.Peek());
  360   ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
  370   ASSERT_EQ(true, ex.IsGood());
  371   ASSERT_EQ(2 * kValidHexPairs, ex.GetFilePos());
  372   ASSERT_EQ(false, ex.Empty());
  373   ASSERT_EQ(4u, ex.GetBytesLeft());
  374   ASSERT_EQ('x', *ex.Peek());
  383   ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
  400   ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
  416   ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
  433   ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
  448   ASSERT_EQ(true, ex.IsGood());
  449   ASSERT_EQ(kValidHexPairs * 2, ex.GetFilePos());
  450   ASSERT_EQ(false, ex.Empty());
  451   ASSERT_EQ(4u, ex.GetBytesLeft());
  452   ASSERT_EQ('x', *ex.Peek());
  462   ASSERT_EQ(kReadBytes, ex.GetHexBytesAvail(
  478   ASSERT_EQ(true, ex.IsGood());
  479   ASSERT_EQ(kReadBytes * 2, ex.GetFilePos());
  480   ASSERT_EQ(false, ex.Empty());
  481   ASSERT_EQ(12u, ex.GetBytesLeft());
  482   ASSERT_EQ('2', *ex.Peek());
tools/lldb/unittests/Utility/StringListTest.cpp
   28   ASSERT_EQ(2U, s.GetSize());
   32   ASSERT_EQ(2U, orig.GetSize());
   40   ASSERT_EQ(1U, s.GetSize());
   44   ASSERT_EQ(2U, s.GetSize());
   52   ASSERT_EQ(1U, s.GetSize());
   56   ASSERT_EQ(2U, s.GetSize());
   67   ASSERT_EQ(1U, s.GetSize());
   71   ASSERT_EQ(2U, s.GetSize());
   82   ASSERT_EQ(1U, s.GetSize());
   86   ASSERT_EQ(2U, s.GetSize());
   94   ASSERT_EQ(1U, s.GetSize());
   98   ASSERT_EQ(2U, s.GetSize());
  109   ASSERT_EQ(1U, s.GetSize());
  113   ASSERT_EQ(2U, s.GetSize());
tools/lldb/unittests/Utility/TimerTest.cpp
   26   ASSERT_EQ(1, sscanf(ss.GetData(), "%lf sec for CAT1", &seconds));
   45   ASSERT_EQ(ss.GetString().count("CAT1"), 1U);
   46   ASSERT_EQ(1, sscanf(ss.GetData(), "%lf sec for CAT1", &seconds));
   64   ASSERT_EQ(2, sscanf(ss.GetData(),
   98   ASSERT_EQ(
tools/lldb/unittests/tools/lldb-server/tests/ThreadIdsInJstopinfoTest.cpp
   43   ASSERT_EQ(stop_reply_pcs.size(), thread_infos.size())
tools/polly/unittests/Support/ISLTools.cpp
   22   ASSERT_EQ(S.n_basic_set(), 2);
unittests/ADT/APFloatTest.cpp
 1013   ASSERT_EQ("10", convertToString(10.0, 6, 3));
 1014   ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
 1015   ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
 1016   ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
 1017   ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
 1018   ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
 1019   ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
 1020   ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
 1021   ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3));
 1022   ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3));
 1023   ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1));
 1024   ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0));
 1025   ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0));
 1026   ASSERT_EQ("10", convertToString(10.0, 6, 3, false));
 1027   ASSERT_EQ("1.000000e+01", convertToString(10.0, 6, 0, false));
 1028   ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2, false));
 1029   ASSERT_EQ("1.0100e+04", convertToString(1.01E+4, 4, 2, false));
 1030   ASSERT_EQ("1.01000e+04", convertToString(1.01E+4, 5, 1, false));
 1031   ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2, false));
 1032   ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2, false));
 1033   ASSERT_EQ("1.01000e-02", convertToString(1.01E-2, 5, 1, false));
 1034   ASSERT_EQ("0.78539816339744828",
 1036   ASSERT_EQ("4.94065645841246540e-324",
 1038   ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1, false));
 1039   ASSERT_EQ("8.73183400000000010e+02", convertToString(873.1834, 0, 0, false));
 1040   ASSERT_EQ("1.79769313486231570e+308",
 1047     ASSERT_EQ("NaN", Str);
 1140     ASSERT_EQ(t.expected, nanbitsFromAPInt(t.semantics, t.SNaN, t.Negative, t.payload));
unittests/ADT/IListTest.cpp
  145   ASSERT_EQ(1u, List.size());
  150   ASSERT_EQ(1, N->Value);
  156   ASSERT_EQ(2u, List.size());
  240   ASSERT_EQ(1u, L1.size());
  241   ASSERT_EQ(&N, &L1.front());
  246   ASSERT_EQ(&N, &L2.front());
  251   ASSERT_EQ(0u, L1.size());
  265   ASSERT_EQ(2u, L1.size());
  266   ASSERT_EQ(&N1, &L1.front());
  273   ASSERT_EQ(2u, L1.size());
  274   ASSERT_EQ(&N1, &L1.back());
  275   ASSERT_EQ(&N2, &L1.front());
unittests/ADT/ImmutableListTest.cpp
  248     ASSERT_EQ(i, *I);
  251   ASSERT_EQ(0, i);
  256     ASSERT_EQ(i, *I);
  259   ASSERT_EQ(6, i);
  264     ASSERT_EQ(i, *I);
  267   ASSERT_EQ(6, i);
unittests/ADT/ImmutableSetTest.cpp
  161   ASSERT_EQ(6, obj.counter);
  166   ASSERT_EQ(3, obj2.counter);
  171   ASSERT_EQ(0, obj3.counter);
  183     ASSERT_EQ(i, *I);
  186   ASSERT_EQ(0, i);
  190     ASSERT_EQ(i, *I);
  193   ASSERT_EQ(3, i);
  197     ASSERT_EQ(i, *I);
  200   ASSERT_EQ(6, i);
unittests/ADT/MapVectorTest.cpp
   21   ASSERT_EQ(R.first, MV1.begin());
   33   ASSERT_EQ(MV1.end(), I);
   36   ASSERT_EQ(I, MV2.begin());
   46   ASSERT_EQ(R.first, MV.begin());
   52   ASSERT_EQ(R.first, MV.begin());
   88   ASSERT_EQ(MV.size(), 3u);
   91   ASSERT_EQ(MV.size(), 2u);
   92   ASSERT_EQ(MV.find(1), MV.end());
   93   ASSERT_EQ(MV[3], 4);
   94   ASSERT_EQ(MV[5], 6);
   96   ASSERT_EQ(MV.erase(3), 1u);
   97   ASSERT_EQ(MV.size(), 1u);
   98   ASSERT_EQ(MV.find(3), MV.end());
   99   ASSERT_EQ(MV[5], 6);
  101   ASSERT_EQ(MV.erase(79), 0u);
  102   ASSERT_EQ(MV.size(), 1u);
  114   ASSERT_EQ(MV.size(), 6u);
  117   ASSERT_EQ(MV.size(), 3u);
  118   ASSERT_EQ(MV.find(1), MV.end());
  119   ASSERT_EQ(MV.find(3), MV.end());
  120   ASSERT_EQ(MV.find(5), MV.end());
  121   ASSERT_EQ(MV[2], 12);
  122   ASSERT_EQ(MV[4], 14);
  123   ASSERT_EQ(MV[6], 16);
  135   ASSERT_EQ(MV.size(), 6u);
  139     ASSERT_EQ(P.first, count);
  145     ASSERT_EQ(P.first, count);
  155   ASSERT_EQ(MV.count(1), 1u);
  156   ASSERT_EQ(*MV.find(2)->second, 2);
  177   ASSERT_EQ(R.first, MV.begin());
  184   ASSERT_EQ(R.first, MV.begin());
  203   ASSERT_EQ(R.first, MV.begin());
  209   ASSERT_EQ(R.first, MV.begin());
  245   ASSERT_EQ(MV.size(), 3u);
  248   ASSERT_EQ(MV.size(), 2u);
  249   ASSERT_EQ(MV.find(1), MV.end());
  250   ASSERT_EQ(MV[3], 4);
  251   ASSERT_EQ(MV[5], 6);
  253   ASSERT_EQ(MV.erase(3), 1u);
  254   ASSERT_EQ(MV.size(), 1u);
  255   ASSERT_EQ(MV.find(3), MV.end());
  256   ASSERT_EQ(MV[5], 6);
  258   ASSERT_EQ(MV.erase(79), 0u);
  259   ASSERT_EQ(MV.size(), 1u);
  271   ASSERT_EQ(MV.size(), 6u);
  274   ASSERT_EQ(MV.size(), 3u);
  275   ASSERT_EQ(MV.find(1), MV.end());
  276   ASSERT_EQ(MV.find(3), MV.end());
  277   ASSERT_EQ(MV.find(5), MV.end());
  278   ASSERT_EQ(MV[2], 12);
  279   ASSERT_EQ(MV[4], 14);
  280   ASSERT_EQ(MV[6], 16);
  292   ASSERT_EQ(MV.size(), 6u);
  296     ASSERT_EQ(P.first, count);
  302     ASSERT_EQ(P.first, count);
  312   ASSERT_EQ(MV.count(1), 1u);
  313   ASSERT_EQ(*MV.find(2)->second, 2);
  321   ASSERT_EQ(R.first, MV.begin());
  327   ASSERT_EQ(R.first, MV.begin());
  363   ASSERT_EQ(MV.size(), 3u);
  366   ASSERT_EQ(MV.size(), 2u);
  367   ASSERT_EQ(MV.find(1), MV.end());
  368   ASSERT_EQ(MV[3], 4);
  369   ASSERT_EQ(MV[5], 6);
  371   ASSERT_EQ(MV.erase(3), 1u);
  372   ASSERT_EQ(MV.size(), 1u);
  373   ASSERT_EQ(MV.find(3), MV.end());
  374   ASSERT_EQ(MV[5], 6);
  376   ASSERT_EQ(MV.erase(79), 0u);
  377   ASSERT_EQ(MV.size(), 1u);
  389   ASSERT_EQ(MV.size(), 6u);
  392   ASSERT_EQ(MV.size(), 3u);
  393   ASSERT_EQ(MV.find(1), MV.end());
  394   ASSERT_EQ(MV.find(3), MV.end());
  395   ASSERT_EQ(MV.find(5), MV.end());
  396   ASSERT_EQ(MV[2], 12);
  397   ASSERT_EQ(MV[4], 14);
  398   ASSERT_EQ(MV[6], 16);
  410   ASSERT_EQ(MV.size(), 6u);
  414     ASSERT_EQ(P.first, count);
  420     ASSERT_EQ(P.first, count);
unittests/ADT/STLExtrasTest.cpp
   52   ASSERT_EQ(3u, CharResults.size());
   64   ASSERT_EQ(3u, IntResults.size());
  102   ASSERT_EQ(3u, Results.size());
  120   ASSERT_EQ(3u, Results.size());
  268   ASSERT_EQ(3u, Enumerated.size());
  301   ASSERT_EQ(V.begin() + 4, I);
unittests/ADT/StringMapTest.cpp
  329   ASSERT_EQ(iter->second.i, 123);
  370   ASSERT_EQ(A.size(), 0u);
  371   ASSERT_EQ(B.size(), 1u);
  372   ASSERT_EQ(B["x"], 42);
  373   ASSERT_EQ(B.count("y"), 0u);
  382   ASSERT_EQ(A.size(), 1u);
  383   ASSERT_EQ(B.size(), 0u);
  384   ASSERT_EQ(A["y"], 117);
  385   ASSERT_EQ(B.count("x"), 0u);
  414   ASSERT_EQ(InstanceCount, 1);
  417   ASSERT_EQ(I->second.Number, 42);
  421   ASSERT_EQ(InstanceCount, 1);
  425   ASSERT_EQ(I->second.Number, 42);
  428   ASSERT_EQ(InstanceCount, 0);
unittests/Analysis/AliasSetTrackerTest.cpp
   73   ASSERT_EQ((int)AST.getAliasSets().size(), 2);
unittests/Analysis/BasicAliasAnalysisTest.cpp
   91   ASSERT_EQ(
   96   ASSERT_EQ(
  120   ASSERT_EQ(BasicAA.alias(
  126   ASSERT_EQ(BasicAA.alias(
unittests/Analysis/DomTreeUpdaterTest.cpp
  118   ASSERT_EQ(BB3->getParent(), F);
  384   ASSERT_EQ(BasicBlocks.size(), static_cast<size_t>(2));
  426   ASSERT_EQ(BasicBlocks.size(), static_cast<size_t>(2));
  428   ASSERT_EQ(BasicBlocks.size(), static_cast<size_t>(0));
  521   ASSERT_EQ(CallbackFlag, true);
  676   ASSERT_EQ(BB3->getParent(), F);
unittests/Analysis/LazyCallGraphTest.cpp
  324   ASSERT_EQ(1, D.size());
  340   ASSERT_EQ(1, C.size());
  356   ASSERT_EQ(1, B.size());
  374   ASSERT_EQ(1, A.size());
  572   ASSERT_EQ(1, RC.size());
  773   ASSERT_EQ(&ARC, CG.lookupRefSCC(A2));
  774   ASSERT_EQ(&ARC, CG.lookupRefSCC(A3));
  775   ASSERT_EQ(&BRC, CG.lookupRefSCC(B2));
  776   ASSERT_EQ(&BRC, CG.lookupRefSCC(B3));
  777   ASSERT_EQ(&CRC, CG.lookupRefSCC(C2));
  778   ASSERT_EQ(&CRC, CG.lookupRefSCC(C3));
  779   ASSERT_EQ(&DRC, CG.lookupRefSCC(D2));
  780   ASSERT_EQ(&DRC, CG.lookupRefSCC(D3));
  781   ASSERT_EQ(1, std::distance(D2->begin(), D2->end()));
  865   ASSERT_EQ(&ARC, CG.lookupRefSCC(A2));
  866   ASSERT_EQ(&ARC, CG.lookupRefSCC(A3));
  867   ASSERT_EQ(&BRC, CG.lookupRefSCC(B2));
  868   ASSERT_EQ(&BRC, CG.lookupRefSCC(B3));
  869   ASSERT_EQ(&CRC, CG.lookupRefSCC(C2));
  870   ASSERT_EQ(&CRC, CG.lookupRefSCC(C3));
  871   ASSERT_EQ(&DRC, CG.lookupRefSCC(D2));
  872   ASSERT_EQ(&DRC, CG.lookupRefSCC(D3));
  873   ASSERT_EQ(1, std::distance(D2->begin(), D2->end()));
 1111   ASSERT_EQ(&ARC, CG.lookupRefSCC(A2));
 1112   ASSERT_EQ(&ARC, CG.lookupRefSCC(A3));
 1113   ASSERT_EQ(&BRC, CG.lookupRefSCC(B2));
 1114   ASSERT_EQ(&BRC, CG.lookupRefSCC(B3));
 1115   ASSERT_EQ(&CRC, CG.lookupRefSCC(C2));
 1116   ASSERT_EQ(&CRC, CG.lookupRefSCC(C3));
 1117   ASSERT_EQ(&DRC, CG.lookupRefSCC(D2));
 1118   ASSERT_EQ(&DRC, CG.lookupRefSCC(D3));
 1119   ASSERT_EQ(1, std::distance(D2->begin(), D2->end()));
 1141       ASSERT_EQ(nullptr, C1Call) << "Found too many C1 calls: " << *CI;
 1144       ASSERT_EQ(nullptr, D1Call) << "Found too many D1 calls: " << *CI;
 1152   ASSERT_EQ(&D2F, C1Call->getCalledFunction());
 1153   ASSERT_EQ(&D2F, D1Call->getCalledFunction());
 1156   ASSERT_EQ(0u, D2F.getNumUses());
 1171   ASSERT_EQ(2u, NewRCs.size());
 1290     ASSERT_EQ(1u, MergedCs.size());
 1362   ASSERT_EQ(2u, NewRCs.size());
 1428   ASSERT_EQ(2u, NewRCs.size());
 1661   ASSERT_EQ(4, RC.size());
 1670   ASSERT_EQ(4, RC.size());
 1679   ASSERT_EQ(4, RC.size());
 1687     ASSERT_EQ(1u, MergedCs.size());
 1690   ASSERT_EQ(3, RC.size());
 1789   ASSERT_EQ(8, RC.size());
 1803   ASSERT_EQ(8, RC.size());
 1913   ASSERT_EQ(7, RC.size());
 1935         ASSERT_EQ(2u, MergedCs.size());
 1942   ASSERT_EQ(5, RC.size());
 2053   ASSERT_EQ(2, RC1.size());
 2148   ASSERT_EQ(2, RC1.size());
unittests/Analysis/LoopInfoTest.cpp
  191   ASSERT_EQ("entry", I->getName());
  194   ASSERT_EQ("loop.0", L_0.getHeader()->getName());
  196   ASSERT_EQ("loop.0.0", L_0_0.getHeader()->getName());
  198   ASSERT_EQ("loop.0.1", L_0_1.getHeader()->getName());
  200   ASSERT_EQ("loop.0.2", L_0_2.getHeader()->getName());
  202   ASSERT_EQ("loop.1", L_1.getHeader()->getName());
  204   ASSERT_EQ("loop.1.0", L_1_0.getHeader()->getName());
  206   ASSERT_EQ("loop.1.1", L_1_1.getHeader()->getName());
  208   ASSERT_EQ("loop.1.2", L_1_2.getHeader()->getName());
  211   ASSERT_EQ(8u, Preorder.size());
  222   ASSERT_EQ(8u, ReverseSiblingPreorder.size());
unittests/Analysis/MemorySSATest.cpp
  942   ASSERT_EQ(DefA, BClobber);
  991   ASSERT_EQ(DefX1, X2Clobber);
 1311   ASSERT_EQ(MSSA.getWalker()->getClobberingMemoryAccess(StoreAEntry),
 1315   ASSERT_EQ(MSSA.getWalker()->getClobberingMemoryAccess(StoreBEntry),
 1328   ASSERT_EQ(MSSA.getWalker()->getClobberingMemoryAccess(StoreAEntry),
 1351   ASSERT_EQ(Walker->getClobberingMemoryAccess(StoreA),
 1353   ASSERT_EQ(Walker->getClobberingMemoryAccess(StoreB),
 1357   ASSERT_EQ(Walker->getClobberingMemoryAccess(StoreA2), StoreAAccess);
 1358   ASSERT_EQ(StoreA2Access->getOptimized(), StoreAAccess);
unittests/AsmParser/AsmParserTest.cpp
   58   ASSERT_EQ(Mapping.GlobalValues.size(), 1u);
unittests/BinaryFormat/MachOTest.cpp
   34   ASSERT_EQ(Header->magic, MH_MAGIC);
   43     ASSERT_EQ(LC->load_command_data.cmd, LC_SEGMENT);
unittests/BinaryFormat/MsgPackDocumentTest.cpp
   20   ASSERT_EQ(Doc.getRoot().getKind(), Type::Int);
   21   ASSERT_EQ(Doc.getRoot().getInt(), 0);
   28   ASSERT_EQ(Doc.getRoot().getKind(), Type::Array);
   30   ASSERT_EQ(A.size(), 2u);
   32   ASSERT_EQ(SI.getKind(), Type::Int);
   33   ASSERT_EQ(SI.getInt(), 1);
   35   ASSERT_EQ(SN.getKind(), Type::Nil);
   47   ASSERT_EQ(Doc.getRoot().getKind(), Type::Map);
   49   ASSERT_EQ(M.size(), 2u);
   51   ASSERT_EQ(FooS.getKind(), Type::Int);
   52   ASSERT_EQ(FooS.getInt(), 1);
   54   ASSERT_EQ(BarS.getKind(), Type::Int);
   55   ASSERT_EQ(BarS.getInt(), 2);
   63   ASSERT_EQ(Buffer, "\x01");
   73   ASSERT_EQ(Buffer, "\x92\x01\xc0");
   83   ASSERT_EQ(Buffer, "\x82\xa3"
   98   ASSERT_EQ(OStream.str(), "---\n- 1\n- 2\n...\n");
  105   ASSERT_EQ(Doc.getRoot().getKind(), Type::Array);
  107   ASSERT_EQ(A.size(), 2u);
  109   ASSERT_EQ(SI.getKind(), Type::UInt);
  110   ASSERT_EQ(SI.getUInt(), 1u);
  112   ASSERT_EQ(SS.getKind(), Type::String);
  113   ASSERT_EQ(SS.getString(), "2");
  127   ASSERT_EQ(OStream.str(), "---\n"
  147   ASSERT_EQ(OStream.str(), "---\n"
  159   ASSERT_EQ(Doc.getRoot().getKind(), Type::Map);
  161   ASSERT_EQ(M.size(), 2u);
  163   ASSERT_EQ(SI.getKind(), Type::UInt);
  164   ASSERT_EQ(SI.getUInt(), 1u);
  166   ASSERT_EQ(SS.getKind(), Type::String);
  167   ASSERT_EQ(SS.getString(), "2");
unittests/Bitstream/BitstreamReaderTest.cpp
  124     ASSERT_EQ(Magic, MaybeRead.get());
  131     ASSERT_EQ(BitstreamEntry::SubBlock, Entry.Kind);
  132     ASSERT_EQ(BlockID, Entry.ID);
  139     ASSERT_EQ(BitstreamEntry::Record, Entry.Kind);
  140     ASSERT_EQ(AbbrevID, Entry.ID);
  148     ASSERT_EQ(RecordID, MaybeRecord.get());
unittests/CodeGen/DIEHashTest.cpp
   44   ASSERT_EQ(0x1AFE116E83701108ULL, MD5Res);
   59   ASSERT_EQ(0x715305ce6cfd9ad1ULL, MD5Res);
   73   ASSERT_EQ(0xd566dbd2ca5265ffULL, MD5Res);
  101   ASSERT_EQ(0x7b80381fd17f1e33ULL, MD5Res);
  131   ASSERT_EQ(0x5646aa436b7e07c6ULL, MD5Res);
  171   ASSERT_EQ(0x3a7dc3ed7b76b2f8ULL, MD5Res);
  193   ASSERT_EQ(0x73d8b25aef227b06ULL, MD5Res);
  223   ASSERT_EQ(0x74ea73862e8708d2ULL, MD5Res);
  258   ASSERT_EQ(0xa0b15f467ad4525bULL, MD5Res);
  293   ASSERT_EQ(0xad211c8c3b31e57ULL, MD5Res);
  324   ASSERT_EQ(0x852e0c9ff7c04ebULL, MD5Res);
  402   ASSERT_EQ(MD5ResDef, MD5ResDecl);
  521   ASSERT_EQ(0x954e026f01c02529ULL, MD5Res);
  540   ASSERT_EQ(0xde8a3b7b43807f4aULL, MD5Res);
  558   ASSERT_EQ(0xd36a1b6dfb604ba0ULL, MD5Res);
  592   ASSERT_EQ(0x8f78211ddce3df10ULL, MD5Res);
  638   ASSERT_EQ(0x9a216000dd3788a7ULL, MD5Res);
  696   ASSERT_EQ(0x493af53ad3d3f651ULL, MD5Res);
unittests/CodeGen/MachineInstrTest.cpp
  228   ASSERT_EQ(IsEqual1, IsEqual2);
  233   ASSERT_EQ(IsEqual1, Hash1 == Hash2);
unittests/CodeGen/MachineOperandTest.cpp
  407   ASSERT_EQ(hash_value(MO1), hash_value(MO2));
unittests/CodeGen/ScalableVectorMVTsTest.cpp
   98   ASSERT_EQ(ScV8Int64Ty->getElementCount(), Mnxv8i64.getVectorElementCount());
   99   ASSERT_EQ(MVT::getVT(ScV8Int64Ty->getElementType()),
  105   ASSERT_EQ(ScV8Int64Ty->getElementCount(), Enxv8i64.getVectorElementCount());
  106   ASSERT_EQ(EVT::getEVT(ScV8Int64Ty->getElementType()),
  118   ASSERT_EQ(Enxv4f64.getVectorElementCount(), ScV4Float64Ty->getElementCount());
  119   ASSERT_EQ(Enxv4f64.getScalarType().getTypeForEVT(Ctx),
unittests/DebugInfo/CodeView/TypeHashingTest.cpp
  106   ASSERT_EQ(0x1000U, CharPP[0].getIndex());
  107   ASSERT_EQ(0x1001U, IntPP[0].getIndex());
  108   ASSERT_EQ(0x1002U, IntPPP[0].getIndex());
  109   ASSERT_EQ(0x1003U, Args[0].getIndex());
  110   ASSERT_EQ(0x1004U, Proc[0].getIndex());
  138   ASSERT_EQ(0x1000U, IntPP[1].getIndex());
  139   ASSERT_EQ(0x1001U, IntPPP[1].getIndex());
  140   ASSERT_EQ(0x1002U, CharPP[1].getIndex());
  141   ASSERT_EQ(0x1003U, DoublePP[1].getIndex());
  142   ASSERT_EQ(0x1004U, Args[1].getIndex());
  143   ASSERT_EQ(0x1005U, Proc[1].getIndex());
unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp
   61     ASSERT_EQ(1u, Records.size());
   68     ASSERT_EQ(sizeof...(T), TTB->records().size());
   74     ASSERT_EQ(sizeof...(T), Symbols.size());
unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
 1046   ASSERT_EQ(NumCUs, 1u);
 3185     ASSERT_EQ(DwarfFormat::DWARF64, Header.getFormat());
 3186     ASSERT_EQ(0x1122334455667788ULL, Header.getLength());
 3187     ASSERT_EQ(5, Header.getVersion());
 3188     ASSERT_EQ(DW_UT_compile, Header.getUnitType());
 3189     ASSERT_EQ(4, Header.getAddressByteSize());
 3199     ASSERT_EQ(0x1122334455667788ULL, CU.getLength());
unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp
  197   ASSERT_EQ(Prologue.IncludeDirectories.size(), 1u);
  198   ASSERT_EQ(Prologue.IncludeDirectories[0].getForm(), DW_FORM_string);
  200   ASSERT_EQ(Prologue.FileNames.size(), 1u);
  201   ASSERT_EQ(Prologue.FileNames[0].Name.getForm(), DW_FORM_string);
unittests/DebugInfo/GSYM/GSYMTest.cpp
  248   ASSERT_EQ(ExpectedOffset.get(), 0ULL);
  419   ASSERT_EQ(InlineInfos->size(), 1u);
  420   ASSERT_EQ(*InlineInfos->at(0), Inline1);
  423   ASSERT_EQ(InlineInfos->size(), 1u);
  424   ASSERT_EQ(*InlineInfos->at(0), Inline1);
  430   ASSERT_EQ(InlineInfos->size(), 2u);
  431   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub1);
  432   ASSERT_EQ(*InlineInfos->at(1), Inline1);
  435   ASSERT_EQ(InlineInfos->size(), 2u);
  436   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub1);
  437   ASSERT_EQ(*InlineInfos->at(1), Inline1);
  443   ASSERT_EQ(InlineInfos->size(), 2u);
  444   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub2);
  445   ASSERT_EQ(*InlineInfos->at(1), Inline1);
  448   ASSERT_EQ(InlineInfos->size(), 2u);
  449   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub2);
  450   ASSERT_EQ(*InlineInfos->at(1), Inline1);
  824   ASSERT_EQ(LT.size(), (size_t)0);
  826   ASSERT_EQ(LT.size(), (size_t)1);
  835   ASSERT_EQ(LT.size(), (size_t)8);
  837   ASSERT_EQ(LT[0], Line0);
  838   ASSERT_EQ(LT[1], Line1);
  839   ASSERT_EQ(LT[2], Line2);
  848   ASSERT_EQ(LT.size(), (size_t)0);
  855   ASSERT_EQ(LT1, LT2);
  867   ASSERT_EQ(LT1, LT2);
 1254   ASSERT_EQ(FI, ExpFI.get());
unittests/DebugInfo/PDB/NativeSymbolReuseTest.cpp
   69     ASSERT_EQ(2U, Compilands->getChildCount());
   86     ASSERT_EQ(2U, Compilands->getChildCount());
  113     ASSERT_EQ(2U, Compilands->getChildCount());
unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp
  281     ASSERT_EQ(
unittests/FuzzMutate/ReservoirSamplerTest.cpp
   19   ASSERT_EQ(7, Sampler.getSelection());
unittests/IR/ConstantsTest.cpp
  343   ASSERT_EQ(A0G, RefArray->getInitializer());
  346   ASSERT_EQ(A01, RefArray->getInitializer());
  366   ASSERT_EQ(Int1, Ref->getInitializer());
  369   ASSERT_EQ(Int2, Ref->getInitializer());
  382   ASSERT_EQ(GEP->getOperand(0), Placeholder);
  386   ASSERT_EQ(GEP, Ref->getInitializer());
  393   ASSERT_EQ(GEP, Ref->getInitializer());
  394   ASSERT_EQ(GEP->getOperand(0), Alias);
  408   ASSERT_EQ(unwrap<GlobalAlias>(AliasRef)->getAliasee(), Aliasee);
  475   ASSERT_EQ(cast<ConstantExpr>(C)->getOpcode(), Instruction::BitCast);
unittests/IR/InstructionsTest.cpp
  674   ASSERT_EQ(GEPI->idx_end(), std::next(GEPI->idx_begin(), 3));
  683   ASSERT_EQ(CGEPI->idx_end(), std::next(CGEPI->idx_begin(), 3));
unittests/IR/MetadataTest.cpp
  231     ASSERT_EQ(Self, Self->getOperand(0));
  249     ASSERT_EQ(Self, Self->getOperand(0));
  433   ASSERT_EQ(Empty, N->getOperand(0));
  437   ASSERT_EQ(nullptr, N->getOperand(0));
  442   ASSERT_EQ(nullptr, NullOp->getOperand(0));
  455   ASSERT_EQ(Empty, Wrapped1->getOperand(0));
  462   ASSERT_EQ(Wrapped1, Wrapped2->getOperand(0));
  468   ASSERT_EQ(Empty, Wrapped2->getOperand(0));
  485   ASSERT_EQ(N, MDTuple::get(Context, NullOps));
  502   ASSERT_EQ(nullptr, N->getOperand(0));
  512   ASSERT_EQ(Empty, MDNode::get(Context, None));
  524   ASSERT_EQ(Empty, MDNode::get(Context, None));
  718   ASSERT_EQ(N, MDNode::replaceWithUniqued(TempMDTuple(N)));
  722   ASSERT_EQ(Op, MDNode::replaceWithUniqued(TempMDTuple(Op)));
  739   ASSERT_EQ(N, MDNode::replaceWithUniqued(TempMDTuple(N)));
  745   ASSERT_EQ(nullptr, N->getOperand(0));
  762   ASSERT_EQ(N, MDNode::replaceWithUniqued(TempMDTuple(N)));
  771   ASSERT_EQ(N, MDTuple::get(Context, NullOps));
 2713   ASSERT_EQ(4u, MDs.size());
 2789   ASSERT_EQ(&PH0, D->getOperand(0));
 2790   ASSERT_EQ(&PH1, D->getOperand(1));
 2791   ASSERT_EQ(&PH2, D->getOperand(2));
unittests/IR/UseTest.cpp
   44   ASSERT_EQ("x", X.getName());
   54   ASSERT_EQ(8u, I);
   64   ASSERT_EQ(8u, I);
   89   ASSERT_EQ("x", X.getName());
   99   ASSERT_EQ(8u, I);
  107   ASSERT_EQ(8u, I);
unittests/IR/ValueTest.cpp
  133   ASSERT_EQ(3u, BB.size());
  208   ASSERT_EQ(3u, EntryBB.size());
unittests/IR/WaymarkTest.cpp
   33   ASSERT_EQ(1U + 22, A->getNumOperands());
unittests/LineEditor/LineEditor.cpp
   69   ASSERT_EQ(2u, CA.Completions.size());
   70   ASSERT_EQ("int foo()", CA.Completions[0]);
   71   ASSERT_EQ("int bar()", CA.Completions[1]);
unittests/Linker/LinkModulesTest.cpp
  258   ASSERT_EQ("foo", F->getName());
  359   ASSERT_EQ(F->getNumUses(), (unsigned)2);
unittests/Object/MinidumpTest.cpp
   49   ASSERT_EQ(1u, File.streams().size());
  200   ASSERT_EQ(2u, File.streams().size());
  352     ASSERT_EQ(1u, ExpectedModule->size());
  452     ASSERT_EQ(1u, ExpectedThread->size());
  507     ASSERT_EQ(1u, ExpectedRanges->size());
  592     ASSERT_EQ(1u, std::distance(ExpectedInfo->begin(), ExpectedInfo->end()));
unittests/ObjectYAML/MinidumpYAMLTest.cpp
   50   ASSERT_EQ(3u, File.streams().size());
  104   ASSERT_EQ(1u, File.streams().size());
  131   ASSERT_EQ(1u, File.streams().size());
  163   ASSERT_EQ(1u, File.streams().size());
  206   ASSERT_EQ(1u, File.streams().size());
  262   ASSERT_EQ(1u, File.streams().size());
  313   ASSERT_EQ(1u, File.streams().size());
unittests/Option/OptionParsingTest.cpp
  109   ASSERT_EQ(2u, ASL.size());
unittests/Passes/PluginsTest.cpp
   52   ASSERT_EQ(TEST_PLUGIN_NAME, Plugin->getPluginName());
   53   ASSERT_EQ(TEST_PLUGIN_VERSION, Plugin->getPluginVersion());
unittests/ProfileData/CoverageMappingTest.cpp
  267   ASSERT_EQ(1u, InputFunctions.size());
  268   ASSERT_EQ(1u, OutputFunctions.size());
  273   ASSERT_EQ(N, Output.Regions.size());
  275     ASSERT_EQ(Input.Regions[I].Count, Output.Regions[I].Count);
  276     ASSERT_EQ(Input.Regions[I].FileID, Output.Regions[I].FileID);
  277     ASSERT_EQ(Input.Regions[I].startLoc(), Output.Regions[I].startLoc());
  278     ASSERT_EQ(Input.Regions[I].endLoc(), Output.Regions[I].endLoc());
  279     ASSERT_EQ(Input.Regions[I].Kind, Output.Regions[I].Kind);
  294   ASSERT_EQ(1u, OutputFunctions.size());
  297   ASSERT_EQ(N, Output.Regions.size());
  298   ASSERT_EQ(N, Output.Filenames.size());
  355     ASSERT_EQ(2U, Segments.size());
  360       ASSERT_EQ("func2", FunctionRecord.Name);
  383   ASSERT_EQ(2U, Segments.size());
  401   ASSERT_EQ(3U, Segments.size());
  457   ASSERT_EQ(8U, Segments.size());
  485   ASSERT_EQ(7U, Segments.size());
  510   ASSERT_EQ(5U, Segments.size());
  535   ASSERT_EQ(5U, Segments.size());
  562   ASSERT_EQ(1U, Segments.size());
  585   ASSERT_EQ(10U, Segments.size());
  616   ASSERT_EQ(8U, Segments.size());
  635   ASSERT_EQ(1u, OutputFunctions.size());
  638   ASSERT_EQ(CounterMappingRegion::ExpansionRegion, Output.Regions[2].Kind);
  639   ASSERT_EQ(Counter::getCounter(2), Output.Regions[2].Count);
  640   ASSERT_EQ(3U, Output.Regions[2].LineStart);
  655   ASSERT_EQ(7U, Segments.size());
  656   ASSERT_EQ(CoverageSegment(1, 1, 20, true),  Segments[0]);
  657   ASSERT_EQ(CoverageSegment(4, 7, 30, false), Segments[1]);
  658   ASSERT_EQ(CoverageSegment(5, 8, 10, true),  Segments[2]);
  659   ASSERT_EQ(CoverageSegment(9, 1, 30, false), Segments[3]);
  660   ASSERT_EQ(CoverageSegment(9, 9, false),     Segments[4]);
  661   ASSERT_EQ(CoverageSegment(10, 10, 0, true), Segments[5]);
  662   ASSERT_EQ(CoverageSegment(11, 11, false),   Segments[6]);
  680     ASSERT_EQ(Line + 1, LCS.getLine());
  682     ASSERT_EQ(LineCounts[Line], LCS.getExecutionCount());
  685   ASSERT_EQ(11U, Line);
  695   ASSERT_EQ(2U, Segments.size());
  696   ASSERT_EQ(CoverageSegment(1, 2, 0, true), Segments[0]);
  697   ASSERT_EQ(CoverageSegment(3, 4, false),   Segments[1]);
  708   ASSERT_EQ(3U, Segments.size());
  709   ASSERT_EQ(CoverageSegment(1, 1, 0, true),  Segments[0]);
  710   ASSERT_EQ(CoverageSegment(4, 7, 0, false), Segments[1]);
  711   ASSERT_EQ(CoverageSegment(9, 9, false),    Segments[2]);
  725   ASSERT_EQ(4U, Segments.size());
  726   ASSERT_EQ(CoverageSegment(1, 1, 10, true), Segments[0]);
  727   ASSERT_EQ(CoverageSegment(3, 3, 50, true), Segments[1]);
  728   ASSERT_EQ(CoverageSegment(4, 4, 10, false), Segments[2]);
  729   ASSERT_EQ(CoverageSegment(9, 9, false), Segments[3]);
  743   ASSERT_EQ(4U, Segments.size());
  765   ASSERT_EQ(4U, Segments.size());
  766   ASSERT_EQ(CoverageSegment(1, 1, 10, true), Segments[0]);
  767   ASSERT_EQ(CoverageSegment(3, 3, 20, true), Segments[1]);
  768   ASSERT_EQ(CoverageSegment(4, 4, 10, false), Segments[2]);
  769   ASSERT_EQ(CoverageSegment(9, 9, false), Segments[3]);
  787   ASSERT_EQ(4U, Segments.size());
  804   ASSERT_EQ(1U, Names.size());
  805   ASSERT_EQ("func", Names[0]);
  818   ASSERT_EQ(1U, Names.size());
  819   ASSERT_EQ("func", Names[0]);
  839     ASSERT_EQ(Group.size(), 1U);
  853   ASSERT_EQ(2U, Segments.size());
  888   ASSERT_EQ(3U, NumFuncs);
unittests/ProfileData/InstrProfTest.cpp
   80   ASSERT_EQ(StringRef("foo"), I->Name);
   81   ASSERT_EQ(0x1234U, I->Hash);
   82   ASSERT_EQ(4U, I->Counts.size());
   83   ASSERT_EQ(1U, I->Counts[0]);
   84   ASSERT_EQ(2U, I->Counts[1]);
   85   ASSERT_EQ(3U, I->Counts[2]);
   86   ASSERT_EQ(4U, I->Counts[3]);
   98   ASSERT_EQ(2U, R->Counts.size());
   99   ASSERT_EQ(1U, R->Counts[0]);
  100   ASSERT_EQ(2U, R->Counts[1]);
  104   ASSERT_EQ(2U, R->Counts.size());
  105   ASSERT_EQ(3U, R->Counts[0]);
  106   ASSERT_EQ(4U, R->Counts[1]);
  124   ASSERT_EQ(2U, Counts.size());
  125   ASSERT_EQ(1U, Counts[0]);
  126   ASSERT_EQ(2U, Counts[1]);
  130   ASSERT_EQ(2U, Counts.size());
  131   ASSERT_EQ(3U, Counts[0]);
  132   ASSERT_EQ(4U, Counts[1]);
  156     ASSERT_EQ(ProfileSummary::PSK_Instr, IPS.getKind());
  157     ASSERT_EQ(2305843009213693952U, IPS.getMaxFunctionCount());
  158     ASSERT_EQ(2305843009213693952U, IPS.getMaxCount());
  159     ASSERT_EQ(10U, IPS.getNumCounts());
  160     ASSERT_EQ(4539628424389557499U, IPS.getTotalCount());
  173     ASSERT_EQ(576460752303423488U, EightyPerc->MinCount);
  174     ASSERT_EQ(288230376151711744U, NinetyPerc->MinCount);
  175     ASSERT_EQ(288230376151711744U, NinetyFivePerc->MinCount);
  176     ASSERT_EQ(72057594037927936U, NinetyNinePerc->MinCount);
  214   ASSERT_EQ(1U, R->Counts.size());
  215   ASSERT_EQ(42U, R->Counts[0]);
  219   ASSERT_EQ(2U, R->Counts.size());
  220   ASSERT_EQ(0U, R->Counts[0]);
  221   ASSERT_EQ(0U, R->Counts[1]);
  255   ASSERT_EQ(4U, R->getNumValueSites(IPVK_IndirectCallTarget));
  256   ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
  257   ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
  258   ASSERT_EQ(2U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 2));
  259   ASSERT_EQ(1U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 3));
  265   ASSERT_EQ(3U, VD[0].Count);
  266   ASSERT_EQ(2U, VD[1].Count);
  267   ASSERT_EQ(1U, VD[2].Count);
  268   ASSERT_EQ(6U, TotalC);
  270   ASSERT_EQ(StringRef((const char *)VD[0].Value, 7), StringRef("callee3"));
  271   ASSERT_EQ(StringRef((const char *)VD[1].Value, 7), StringRef("callee2"));
  272   ASSERT_EQ(StringRef((const char *)VD[2].Value, 7), StringRef("callee1"));
  310   ASSERT_EQ(3U, N);
  311   ASSERT_EQ(21U, T);
  313   ASSERT_EQ(6000U, ValueData[0].Value);
  314   ASSERT_EQ(6U, ValueData[0].Count);
  315   ASSERT_EQ(5000U, ValueData[1].Value);
  316   ASSERT_EQ(5U, ValueData[1].Count);
  317   ASSERT_EQ(4000U, ValueData[2].Value);
  318   ASSERT_EQ(4U, ValueData[2].Count);
  322   ASSERT_EQ(1U, N);
  323   ASSERT_EQ(21U, T);
  336   ASSERT_EQ(5U, N);
  337   ASSERT_EQ(21U, T);
  338   ASSERT_EQ(6000U, ValueData[0].Value);
  339   ASSERT_EQ(6U, ValueData[0].Count);
  340   ASSERT_EQ(5000U, ValueData[1].Value);
  341   ASSERT_EQ(5U, ValueData[1].Count);
  342   ASSERT_EQ(4000U, ValueData[2].Value);
  343   ASSERT_EQ(4U, ValueData[2].Count);
  344   ASSERT_EQ(3000U, ValueData[3].Value);
  345   ASSERT_EQ(3U, ValueData[3].Count);
  346   ASSERT_EQ(2000U, ValueData[4].Value);
  347   ASSERT_EQ(2U, ValueData[4].Count);
  359   ASSERT_EQ(4U, N);
  360   ASSERT_EQ(10U, T);
  361   ASSERT_EQ(3000U, ValueData[0].Value);
  362   ASSERT_EQ(4U, ValueData[0].Count);
  363   ASSERT_EQ(4000U, ValueData[1].Value);
  364   ASSERT_EQ(3U, ValueData[1].Count);
  365   ASSERT_EQ(5000U, ValueData[2].Value);
  366   ASSERT_EQ(2U, ValueData[2].Count);
  367   ASSERT_EQ(6000U, ValueData[3].Value);
  368   ASSERT_EQ(1U, ValueData[3].Count);
  395   ASSERT_EQ(4U, R->getNumValueSites(IPVK_IndirectCallTarget));
  396   ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
  397   ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
  398   ASSERT_EQ(2U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 2));
  399   ASSERT_EQ(1U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 3));
  404   ASSERT_EQ(30U, VD[0].Count);
  405   ASSERT_EQ(20U, VD[1].Count);
  406   ASSERT_EQ(10U, VD[2].Count);
  407   ASSERT_EQ(60U, TotalC);
  409   ASSERT_EQ(StringRef((const char *)VD[0].Value, 7), StringRef("callee3"));
  410   ASSERT_EQ(StringRef((const char *)VD[1].Value, 7), StringRef("callee2"));
  411   ASSERT_EQ(StringRef((const char *)VD[2].Value, 7), StringRef("callee1"));
  445   ASSERT_EQ(4U, R->getNumValueSites(IPVK_IndirectCallTarget));
  446   ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
  447   ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
  448   ASSERT_EQ(2U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 2));
  449   ASSERT_EQ(1U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 3));
  453   ASSERT_EQ(StringRef((const char *)VD[0].Value, 7), StringRef("callee3"));
  454   ASSERT_EQ(StringRef((const char *)VD[1].Value, 7), StringRef("callee2"));
  455   ASSERT_EQ(StringRef((const char *)VD[2].Value, 7), StringRef("callee1"));
  522   ASSERT_EQ(5U, R->getNumValueSites(IPVK_IndirectCallTarget));
  523   ASSERT_EQ(4U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
  524   ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
  525   ASSERT_EQ(4U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 2));
  526   ASSERT_EQ(1U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 3));
  527   ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 4));
  531   ASSERT_EQ(StringRef((const char *)VD[0].Value, 7), StringRef("callee2"));
  532   ASSERT_EQ(7U, VD[0].Count);
  533   ASSERT_EQ(StringRef((const char *)VD[1].Value, 7), StringRef("callee3"));
  534   ASSERT_EQ(6U, VD[1].Count);
  535   ASSERT_EQ(StringRef((const char *)VD[2].Value, 7), StringRef("callee4"));
  536   ASSERT_EQ(4U, VD[2].Count);
  537   ASSERT_EQ(StringRef((const char *)VD[3].Value, 7), StringRef("callee1"));
  538   ASSERT_EQ(1U, VD[3].Count);
  542   ASSERT_EQ(StringRef((const char *)VD_2[0].Value, 7), StringRef("callee3"));
  543   ASSERT_EQ(6U, VD_2[0].Count);
  544   ASSERT_EQ(StringRef((const char *)VD_2[1].Value, 7), StringRef("callee4"));
  545   ASSERT_EQ(4U, VD_2[1].Count);
  546   ASSERT_EQ(StringRef((const char *)VD_2[2].Value, 7), StringRef("callee2"));
  547   ASSERT_EQ(3U, VD_2[2].Count);
  548   ASSERT_EQ(StringRef((const char *)VD_2[3].Value, 7), StringRef("callee1"));
  549   ASSERT_EQ(1U, VD_2[3].Count);
  553   ASSERT_EQ(StringRef((const char *)VD_3[0].Value, 7), StringRef("callee1"));
  554   ASSERT_EQ(1U, VD_3[0].Count);
  558   ASSERT_EQ(StringRef((const char *)VD_4[0].Value, 7), StringRef("callee3"));
  559   ASSERT_EQ(6U, VD_4[0].Count);
  560   ASSERT_EQ(StringRef((const char *)VD_4[1].Value, 7), StringRef("callee2"));
  561   ASSERT_EQ(4U, VD_4[1].Count);
  562   ASSERT_EQ(StringRef((const char *)VD_4[2].Value, 7), StringRef("callee1"));
  563   ASSERT_EQ(2U, VD_4[2].Count);
  575   ASSERT_EQ(Result, instrprof_error::success);
  580   ASSERT_EQ(Result, instrprof_error::counter_overflow);
  584   ASSERT_EQ(Result, instrprof_error::success);
  592   ASSERT_EQ(Result, instrprof_error::success);
  601   ASSERT_EQ(Result, instrprof_error::counter_overflow);
  610   ASSERT_EQ(Max, ReadRecord1->Counts[0]);
  615   ASSERT_EQ(1U, ReadRecord2->getNumValueSites(IPVK_IndirectCallTarget));
  618   ASSERT_EQ(StringRef("bar"), StringRef((const char *)VD[0].Value, 3));
  619   ASSERT_EQ(Max, VD[0].Count);
  663   ASSERT_EQ(2U, R->getNumValueSites(IPVK_IndirectCallTarget));
  664   ASSERT_EQ(255U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
  666     ASSERT_EQ(VD[I].Value, 509 - I);
  667     ASSERT_EQ(VD[I].Count, 1509 - I);
  704   ASSERT_EQ(5U, Record.getNumValueSites(IPVK_IndirectCallTarget));
  705   ASSERT_EQ(5U, Record.getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
  706   ASSERT_EQ(4U, Record.getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
  707   ASSERT_EQ(3U, Record.getNumValueDataForSite(IPVK_IndirectCallTarget, 2));
  708   ASSERT_EQ(2U, Record.getNumValueDataForSite(IPVK_IndirectCallTarget, 3));
  709   ASSERT_EQ(0U, Record.getNumValueDataForSite(IPVK_IndirectCallTarget, 4));
  717   ASSERT_EQ(StringRef((const char *)VD_0[0].Value, 7), StringRef("callee2"));
  718   ASSERT_EQ(1000U, VD_0[0].Count);
  719   ASSERT_EQ(StringRef((const char *)VD_0[1].Value, 7), StringRef("callee3"));
  720   ASSERT_EQ(500U, VD_0[1].Count);
  721   ASSERT_EQ(StringRef((const char *)VD_0[2].Value, 7), StringRef("callee1"));
  722   ASSERT_EQ(400U, VD_0[2].Count);
  723   ASSERT_EQ(StringRef((const char *)VD_0[3].Value, 7), StringRef("callee4"));
  724   ASSERT_EQ(300U, VD_0[3].Count);
  725   ASSERT_EQ(StringRef((const char *)VD_0[4].Value, 7), StringRef("callee5"));
  726   ASSERT_EQ(100U, VD_0[4].Count);
  731   ASSERT_EQ(StringRef((const char *)VD_1[0].Value, 7), StringRef("callee2"));
  732   ASSERT_EQ(2500U, VD_1[0].Count);
  733   ASSERT_EQ(StringRef((const char *)VD_1[1].Value, 7), StringRef("callee1"));
  734   ASSERT_EQ(1300U, VD_1[1].Count);
  735   ASSERT_EQ(StringRef((const char *)VD_1[2].Value, 7), StringRef("callee3"));
  736   ASSERT_EQ(1000U, VD_1[2].Count);
  737   ASSERT_EQ(StringRef((const char *)VD_1[3].Value, 7), StringRef("callee5"));
  738   ASSERT_EQ(800U, VD_1[3].Count);
  743   ASSERT_EQ(StringRef((const char *)VD_2[0].Value, 7), StringRef("callee4"));
  744   ASSERT_EQ(5500U, VD_2[0].Count);
  745   ASSERT_EQ(StringRef((const char *)VD_2[1].Value, 7), StringRef("callee3"));
  746   ASSERT_EQ(1000U, VD_2[1].Count);
  747   ASSERT_EQ(StringRef((const char *)VD_2[2].Value, 7), StringRef("callee6"));
  748   ASSERT_EQ(800U, VD_2[2].Count);
  753   ASSERT_EQ(StringRef((const char *)VD_3[0].Value, 7), StringRef("callee3"));
  754   ASSERT_EQ(2000U, VD_3[0].Count);
  755   ASSERT_EQ(StringRef((const char *)VD_3[1].Value, 7), StringRef("callee2"));
  756   ASSERT_EQ(1800U, VD_3[1].Count);
  777   ASSERT_EQ(5U, Record.getNumValueSites(IPVK_IndirectCallTarget));
  778   ASSERT_EQ(5U, Record.getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
  786   ASSERT_EQ(VD_0[0].Value, 0x2000ULL);
  787   ASSERT_EQ(1000U, VD_0[0].Count);
  788   ASSERT_EQ(VD_0[1].Value, 0x3000ULL);
  789   ASSERT_EQ(500U, VD_0[1].Count);
  790   ASSERT_EQ(VD_0[2].Value, 0x1000ULL);
  791   ASSERT_EQ(400U, VD_0[2].Count);
  794   ASSERT_EQ(VD_0[4].Value, 0ULL);
  804   ASSERT_EQ(1ULL << 63, Reader->getMaximumFunctionCount(/* IsCS */ false));
  816   ASSERT_EQ(2U, Counts.size());
  817   ASSERT_EQ(3U, Counts[0]);
  818   ASSERT_EQ(6U, Counts[1]);
  822   ASSERT_EQ(2U, Counts.size());
  823   ASSERT_EQ(15U, Counts[0]);
  824   ASSERT_EQ(20U, Counts[1]);
  839   ASSERT_EQ(StringRef("func1"), R);
  841   ASSERT_EQ(StringRef("func2"), R);
  843   ASSERT_EQ(StringRef("func3"), R);
  845   ASSERT_EQ(StringRef("bar1"), R);
  847   ASSERT_EQ(StringRef("bar2"), R);
  849   ASSERT_EQ(StringRef("bar3"), R);
  853   ASSERT_EQ(StringRef(), R);
  855   ASSERT_EQ(StringRef(), R);
  864   ASSERT_EQ(StringRef("blah_1"), R);
  866   ASSERT_EQ(StringRef("blah_2"), R);
  868   ASSERT_EQ(StringRef("blah_3"), R);
  870   ASSERT_EQ(StringRef("func1"), R);
  872   ASSERT_EQ(StringRef("func2"), R);
  874   ASSERT_EQ(StringRef("func3"), R);
  876   ASSERT_EQ(StringRef("bar1"), R);
  878   ASSERT_EQ(StringRef("bar2"), R);
  880   ASSERT_EQ(StringRef("bar3"), R);
  919     ASSERT_EQ(StringRef(PGOName),
  921     ASSERT_EQ(StringRef(Funcs[I]), ProfSymtab.getOrigFuncName(Key));
  976       ASSERT_EQ(StringRef("func_0"), R);
  978       ASSERT_EQ(StringRef("f oooooooooooooo_0"), R);
  987           ASSERT_EQ(StringRef(N[J]), R);
 1007     ASSERT_EQ(4u, Counts.size());
 1017     ASSERT_EQ(3u, Counts.size());
unittests/ProfileData/SampleProfTest.cpp
  170       ASSERT_EQ("_Z3fooi", ReadFooSamples->getName());
  172     ASSERT_EQ(7711u, ReadFooSamples->getTotalSamples());
  173     ASSERT_EQ(610u, ReadFooSamples->getHeadSamples());
  178       ASSERT_EQ("_Z3bari", ReadBarSamples->getName());
  180     ASSERT_EQ(20301u, ReadBarSamples->getTotalSamples());
  181     ASSERT_EQ(1437u, ReadBarSamples->getHeadSamples());
  193       ASSERT_EQ(3u, Reader->getProfiles().size());
  196       ASSERT_EQ(12557u, ReadBazSamples->getTotalSamples());
  197       ASSERT_EQ(4u, Reader->getProfiles().size());
  202     ASSERT_EQ(1232u, ReadBooSamples->getTotalSamples());
  210     ASSERT_EQ(1000u, CTMap.get()[MconstructRep]);
  211     ASSERT_EQ(437u, CTMap.get()[StringviewRep]);
  214       ASSERT_EQ(ProfileSummary::PSK_Sample, Summary.getKind());
  215       ASSERT_EQ(137392u, Summary.getTotalCount());
  216       ASSERT_EQ(8u, Summary.getNumCounts());
  217       ASSERT_EQ(4u, Summary.getNumFunctions());
  218       ASSERT_EQ(1437u, Summary.getMaxFunctionCount());
  219       ASSERT_EQ(60351u, Summary.getMaxCount());
  233       ASSERT_EQ(60000u, EightyPerc->MinCount);
  234       ASSERT_EQ(12557u, NinetyPerc->MinCount);
  235       ASSERT_EQ(12557u, NinetyFivePerc->MinCount);
  236       ASSERT_EQ(610u, NinetyNinePerc->MinCount);
  328       ASSERT_EQ(I->getValue(), Esamples);
  367   ASSERT_EQ(Result, sampleprof_error::success);
  370   ASSERT_EQ(Result, sampleprof_error::success);
  373   ASSERT_EQ(Result, sampleprof_error::success);
  376   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
  377   ASSERT_EQ(FooSamples.getTotalSamples(), Max);
  380   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
  381   ASSERT_EQ(FooSamples.getHeadSamples(), Max);
  384   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
  387   ASSERT_EQ(BodySamples.get(), Max);
unittests/Support/BinaryStreamTest.cpp
  204     ASSERT_EQ(InputData.size(), Stream.Input->getLength());
  224     ASSERT_EQ(InputData.size(), Ref.getLength());
  324   ASSERT_EQ(InputData.size(), Original.getLength());
  364     ASSERT_EQ(InputData.size(), Stream.Input->getLength());
  376       ASSERT_EQ(ExpectedSize, Data.size());
  423     ASSERT_EQ(InputData.size(), Stream.Input->getLength());
  427     ASSERT_EQ(Ints[0], *Iter++);
  428     ASSERT_EQ(Ints[1], *Iter++);
  429     ASSERT_EQ(Ints[2], *Iter++);
  430     ASSERT_EQ(Ints[3], *Iter++);
  431     ASSERT_EQ(Array.end(), Iter);
  445     ASSERT_EQ(InputData.size(), Stream.Input->getLength());
  449     ASSERT_EQ(Pairs[0].first, Iter->first);
  450     ASSERT_EQ(Pairs[0].second, Iter->second);
  452     ASSERT_EQ(Pairs[1].first, Iter->first);
  453     ASSERT_EQ(Pairs[1].second, Iter->second);
  455     ASSERT_EQ(Array.end(), Iter);
  493     ASSERT_EQ("1. Test", *Iter++);
  494     ASSERT_EQ("2. Longer Test", *Iter++);
  495     ASSERT_EQ("3. Really Long Test", *Iter++);
  496     ASSERT_EQ("4. Super Extra Longest Test Of All", *Iter++);
  497     ASSERT_EQ(Array.end(), Iter);
  556     ASSERT_EQ(0U, Reader.bytesRemaining());
  577     ASSERT_EQ(0U, Reader.bytesRemaining());
  583     ASSERT_EQ(0U, Reader.bytesRemaining());
  584     ASSERT_EQ(Ints, std::vector<int>(FixedIntsRef.begin(), FixedIntsRef.end()));
  609     ASSERT_EQ(0U, Reader.bytesRemaining());
  737     ASSERT_EQ(0U, Reader.bytesRemaining());
  754     ASSERT_EQ(0U, Reader.bytesRemaining());
unittests/Support/Casting.cpp
  207   ASSERT_EQ(OrigD, NewD.get());
  208   ASSERT_EQ(nullptr, D);
  213   ASSERT_EQ(OrigD, B.get());
  214   ASSERT_EQ(nullptr, NewD);
  219   ASSERT_EQ(OrigD, NewB.get());
  220   ASSERT_EQ(nullptr, B);
  225   ASSERT_EQ(OrigD, D.get());
  226   ASSERT_EQ(nullptr, NewB);
  231   ASSERT_EQ(nullptr, F);
  232   ASSERT_EQ(OrigD, D.get());
unittests/Support/CommandLineTest.cpp
   96   ASSERT_EQ(&TestOption, Retrieved) << "Retrieved wrong option.";
  126   ASSERT_EQ(cl::Hidden, TestOption.getOptionHiddenFlag()) <<
  177   ASSERT_EQ(TestOption2.Categories.size(), 2U);
  195   ASSERT_EQ(TestOption.Categories.end(),
  387   ASSERT_EQ(cl::ReallyHidden, TestOption1.getOptionHiddenFlag())
  389   ASSERT_EQ(cl::NotHidden, TestOption2.getOptionHiddenFlag())
  394   ASSERT_EQ(cl::NotHidden, Map["help"]->getOptionHiddenFlag())
  410   ASSERT_EQ(cl::ReallyHidden, TestOption1.getOptionHiddenFlag())
  412   ASSERT_EQ(cl::NotHidden, TestOption2.getOptionHiddenFlag())
  414   ASSERT_EQ(cl::NotHidden, TestOption3.getOptionHiddenFlag())
  419   ASSERT_EQ(cl::NotHidden, Map["help"]->getOptionHiddenFlag())
  951   ASSERT_EQ(Argv.size(), 1 + NON_RSP_AT_ARGS + 2);
unittests/Support/ConvertUTFTest.cpp
   47   ASSERT_EQ(3u, Result.size());
unittests/Support/FileOutputBufferTest.cpp
   60   ASSERT_EQ(File1Size, 8192ULL);
   76   ASSERT_EQ(fs::access(Twine(File2), fs::AccessMode::Exist),
   98   ASSERT_EQ(File3Size, 8192000ULL);
unittests/Support/FileUtilitiesTest.cpp
   50   ASSERT_EQ(FinalFileContent, TestfileContent);
unittests/Support/FormatVariadicTest.cpp
   46   ASSERT_EQ(1U, Replacements.size());
   54   ASSERT_EQ(1u, Replacements.size());
   60   ASSERT_EQ(1u, Replacements.size());
   68   ASSERT_EQ(1u, Replacements.size());
   75   ASSERT_EQ(1u, Replacements.size());
   84   ASSERT_EQ(1u, Replacements.size());
   93   ASSERT_EQ(1u, Replacements.size());
  102   ASSERT_EQ(1u, Replacements.size());
  111   ASSERT_EQ(1u, Replacements.size());
  120   ASSERT_EQ(1u, Replacements.size());
  129   ASSERT_EQ(1u, Replacements.size());
  139   ASSERT_EQ(1u, Replacements.size());
  149   ASSERT_EQ(1u, Replacements.size());
  160   ASSERT_EQ(1u, Replacements.size());
  170   ASSERT_EQ(1u, Replacements.size());
  180   ASSERT_EQ(1u, Replacements.size());
  190   ASSERT_EQ(1u, Replacements.size());
  203   ASSERT_EQ(1u, Replacements.size());
  211   ASSERT_EQ(1u, Replacements.size());
  219   ASSERT_EQ(1u, Replacements.size());
  231   ASSERT_EQ(5u, Replacements.size());
unittests/Support/Host.cpp
   53     ASSERT_EQ(Num, -1);
unittests/Support/LockFileManagerTest.cpp
   66   ASSERT_EQ(Ret, 0);
unittests/Support/MemoryBufferTest.cpp
  100   ASSERT_EQ(sys::fs::createTemporaryFile("MemoryBufferTest_getOpenFile", "temp",
  168   ASSERT_EQ(::pipe(pipes), 0) << strerror(errno);
  179       ASSERT_EQ(::write(pipes[1], "foo", 3), 3) << strerror(errno);
  341     ASSERT_EQ(0x6000u, MB.getBufferSize());
  343     ASSERT_EQ(MB.getBufferEnd(), MB.getBufferStart() + MB.getBufferSize());
  350   ASSERT_EQ(0x10000u, MB.getBufferSize());
  371     ASSERT_EQ(16u, MB.getBufferSize());
  373     ASSERT_EQ(MB.getBufferEnd(), MB.getBufferStart() + MB.getBufferSize());
  380   ASSERT_EQ(16u, MB.getBufferSize());
unittests/Support/ParallelTest.cpp
   49   ASSERT_EQ(range[2049], 1u);
unittests/Support/Path.cpp
  194     ASSERT_EQ("/root/foo.cpp", Relative);
  201     ASSERT_EQ("//root/foo.cpp", Relative);
  464   ASSERT_EQ(F1, F2);
  484   ASSERT_EQ(D2, F1);
  493   ASSERT_EQ(F1, F2);
  592   ASSERT_EQ(-1, TempFileOrError->FD);
  604   ASSERT_EQ(-1, TempFileOrError->FD);
  637   ASSERT_EQ(fs::remove(Twine(TempPath2), false),
  645   ASSERT_EQ(fs::access(Twine(TempPath2), sys::fs::AccessMode::Exist),
  670   ASSERT_EQ(fs::access(Twine(TempPath), sys::fs::AccessMode::Exist),
  736   ASSERT_EQ(fs::create_directory(Twine(TestDirectory) + "foo", false),
  749   ASSERT_EQ(Status.permissions() & fs::perms::all_all,
  754   ASSERT_EQ(Status.permissions() & fs::perms::all_all, fs::perms::all_all);
  869   ASSERT_EQ(da1, visited.end()); // Not visited.
  873   ASSERT_EQ(p1, visited.end()); // Not visited.
 1066   ASSERT_EQ(Status.getSize(), 123U);
 1076   ASSERT_EQ(write(FD, Data.data(), Data.size()), static_cast<ssize_t>(Data.size()));
 1106   ASSERT_EQ(close(FileDescriptor), 0);
 1124     ASSERT_EQ(close(FD), 0);
 1279     ASSERT_EQ(D1, D2);
 1318   ASSERT_EQ(ShouldExistBefore, fs::exists(Path));
 1323   ASSERT_EQ(Data.size(), (size_t)write(FD, Data.data(), Data.size()));
 1330   ASSERT_EQ(Data, Contents);
 1375   ASSERT_EQ(0ULL, FileSize);
 1379   ASSERT_EQ(4, write(FD, "Test", 4));
 1384   ASSERT_EQ(4ULL, FileSize);
 1390   ASSERT_EQ(0ULL, FileSize);
 1406   ASSERT_EQ(4ULL, FileSize);
 1420   ASSERT_EQ(4ULL, FileSize);
 1445     ASSERT_EQ(4ULL, FileSize);
 1450     ASSERT_EQ(4ULL, FileSize);
 1452     ASSERT_EQ(4, write(FD, "Buzz", 4));
 1464     ASSERT_EQ((size_t)Result, Data.size());
 1465     ASSERT_EQ(Data, StringRef(Buffer.data(), Buffer.size()));
 1467     ASSERT_EQ(-1, Result);
 1468     ASSERT_EQ(EBADF, errno);
 1475     ASSERT_EQ((size_t)Result, Data.size());
 1477     ASSERT_EQ(-1, Result);
 1478     ASSERT_EQ(EBADF, errno);
 1659   ASSERT_EQ(D1, D2) << "D1: " << TestDirectory << "\nD2: " << path;
unittests/Support/ProgramTest.cpp
  268   ASSERT_EQ(-2, RetCode);
  291     ASSERT_EQ(PI.Pid, ProcessInfo::InvalidPid)
  331   ASSERT_EQ(::read(fd, buf, 10), 10);
  332   ASSERT_EQ(strncmp(buf, utf8_text, 10), 0);
unittests/Support/ReverseIterationTest.cpp
   49     ASSERT_EQ(std::get<0>(Tuple).first, std::get<1>(Tuple));
   54     ASSERT_EQ(iter->first, IterKeys[i]);
  103     ASSERT_EQ(std::get<0>(Tuple).second, std::get<1>(Tuple)->value);
  108     ASSERT_EQ(iter->second, Keys[i]->value);
unittests/Support/TaskQueueTest.cpp
   51   ASSERT_EQ(1, X);
   52   ASSERT_EQ(0, Y);
   53   ASSERT_EQ(0, Z);
   57   ASSERT_EQ(1, X);
   58   ASSERT_EQ(1, Y);
   59   ASSERT_EQ(0, Z);
   63   ASSERT_EQ(1, X);
   64   ASSERT_EQ(1, Y);
   65   ASSERT_EQ(1, Z);
   86   ASSERT_EQ(1, X);
   87   ASSERT_EQ(1, Y);
   88   ASSERT_EQ(0, Z);
   93   ASSERT_EQ(1, X);
   94   ASSERT_EQ(1, Y);
   95   ASSERT_EQ(1, Z);
  104   ASSERT_EQ(42, F2.get());
  105   ASSERT_EQ("Hello", F1.get());
unittests/Support/ThreadPool.cpp
   97   ASSERT_EQ(0, checked_in);
  100   ASSERT_EQ(5, checked_in);
  115   ASSERT_EQ(10, checked_in);
  130   ASSERT_EQ(2, i.load());
  146   ASSERT_EQ(2, i.load());
  161     ASSERT_EQ(0, checked_in);
  164   ASSERT_EQ(5, checked_in);
unittests/Support/Threading.cpp
   74   ASSERT_EQ(Executed, true);
unittests/Support/VirtualFileSystemTest.cpp
  557   ASSERT_EQ(BIt, vfs::directory_iterator());
  565   ASSERT_EQ(CIt, vfs::directory_iterator());
  916   ASSERT_EQ("/a", I->path());
  919   ASSERT_EQ(vfs::directory_iterator(), I);
  925   ASSERT_EQ("/", *PWD);
  929   ASSERT_EQ("/a", Path);
  958   ASSERT_EQ(Stat.getError(), errc::no_such_file_or_directory) << FS.toString();
  960   ASSERT_EQ(Stat.getError(), errc::no_such_file_or_directory) << FS.toString();
  987   ASSERT_EQ("/a", Stat->getName());
  995   ASSERT_EQ("/a", Stat->getName());
 1006   ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer());
 1008   ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer());
 1010   ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer());
 1012   ASSERT_EQ(File.getError(), errc::invalid_argument) << FS.toString();
 1014   ASSERT_EQ(File.getError(), errc::no_such_file_or_directory) << FS.toString();
 1020   ASSERT_EQ("c", (*(*File)->getBuffer("ignored"))->getBuffer());
 1022   ASSERT_EQ("d", (*(*File)->getBuffer("ignored"))->getBuffer());
 1039   ASSERT_EQ("/a", I->path());
 1042   ASSERT_EQ("/b", I->path());
 1045   ASSERT_EQ(vfs::directory_iterator(), I);
 1051   ASSERT_EQ("/b/c", getPosixPath(I->path()));
 1054   ASSERT_EQ(vfs::directory_iterator(), I);
 1063   ASSERT_EQ("/b/c", Stat->getName());
 1064   ASSERT_EQ("/b", *FS.getCurrentWorkingDirectory());
 1071   ASSERT_EQ("/b/c",
 1074   ASSERT_EQ("/b",
 1118   ASSERT_EQ(0xFEEDFACE, Stat->getUser());
 1122   ASSERT_EQ(0xFEEDFACE, Stat->getUser());
 1126   ASSERT_EQ(sys::fs::perms::all_all, Stat->getPermissions());
 1127   ASSERT_EQ(0xFEEDFACE, Stat->getUser());
 1135   ASSERT_EQ(0xDABBAD00, Stat->getGroup());
 1139   ASSERT_EQ(0xDABBAD00, Stat->getGroup());
 1143   ASSERT_EQ(sys::fs::perms::all_all, Stat->getPermissions());
 1144   ASSERT_EQ(0xDABBAD00, Stat->getGroup());
 1158   ASSERT_EQ(sys::fs::file_type::socket_file, Stat->getType());
 1159   ASSERT_EQ(sys::fs::perms::all_all, Stat->getPermissions());
 1168   ASSERT_EQ(sys::fs::perms::owner_read | sys::fs::perms::owner_write |
 1174   ASSERT_EQ(sys::fs::perms::owner_read | sys::fs::perms::owner_write |
 1180   ASSERT_EQ(sys::fs::perms::owner_read | sys::fs::perms::owner_write,
 1210   ASSERT_EQ("../b/c", Stat->getName());
 1220   ASSERT_EQ("../b/c", Stat->getName());
 1227   ASSERT_EQ("../b/c", getPosixPath(It->path()));
unittests/Support/YAMLIOTest.cpp
  293   ASSERT_EQ(Serialized, Expected);
 2966     ASSERT_EQ(seq->size(), 2u);
unittests/Support/raw_sha1_ostream_test.cpp
   36   ASSERT_EQ("2EF7BDE608CE5404E97D5F042F95F89F1C232871", Hash);
   43   ASSERT_EQ("2EF7BDE608CE5404E97D5F042F95F89F1C232871", Hash);
   53   ASSERT_EQ("F7FF9E8B7BB2E09B70935A5D785E0CC5D9D0ABF0", Hash);
   62   ASSERT_EQ(NonSplitHash, Hash);
   70   ASSERT_EQ("F7FF9E8B7BB2E09B70935A5D785E0CC5D9D0ABF0", Hash);
   76   ASSERT_EQ("7447F2A5A42185C8CF91E632789C431830B59067", Hash);
unittests/Target/ARM/MachineInstrTest.cpp
  501       ASSERT_EQ(IsValidTPOpcode(i), Valid)
unittests/TextAPI/TextStubV1Tests.cpp
  450   ASSERT_EQ("malformed file\nTest.tbd:2:1: error: missing required key "
  467   ASSERT_EQ(
unittests/TextAPI/TextStubV2Tests.cpp
  487   ASSERT_EQ("malformed file\nTest.tbd:2:1: error: missing required key "
  504   ASSERT_EQ(
unittests/TextAPI/TextStubV3Tests.cpp
  464   ASSERT_EQ("malformed file\nTest.tbd:2:1: error: missing required key "
  481   ASSERT_EQ(
unittests/TextAPI/TextStubV4Tests.cpp
  525   ASSERT_EQ("malformed file\nTest.tbd:2:1: error: missing required key "
  541   ASSERT_EQ(
unittests/Transforms/Utils/ValueMapperTest.cpp
  135   ASSERT_EQ(Old, D->getOperand(0));
unittests/tools/llvm-exegesis/X86/BenchmarkResultTest.cpp
  112     ASSERT_EQ(FromDiskVector.size(), size_t{1});
unittests/tools/llvm-exegesis/X86/SnippetRepetitorTest.cpp
   72   ASSERT_EQ(MF->getNumBlockIDs(), 1u);
   81   ASSERT_EQ(MF->getNumBlockIDs(), 3u);