|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
lib/Testing/Support/SupportHelpers.cpp 41 EXPECT_TRUE(Found) << "Unit test source directory file does not exist.";
45 EXPECT_TRUE(static_cast<bool>(File))
tools/clang/tools/extra/clangd/unittests/BackgroundIndexTests.cpp 277 EXPECT_TRUE(ShardSource->Sources);
288 EXPECT_TRUE(ShardHeader->Sources);
404 EXPECT_TRUE(ShardHeader->Symbols->empty());
615 EXPECT_TRUE(checkRebuild([&] { Rebuilder.indexedTU(); }));
618 EXPECT_TRUE(checkRebuild([&] { Rebuilder.indexedTU(); }));
625 EXPECT_TRUE(checkRebuild([&] { Rebuilder.doneLoading(); }));
638 EXPECT_TRUE(checkRebuild([&] { Rebuilder.doneLoading(); }));
645 EXPECT_TRUE(checkRebuild([&] { Rebuilder.doneLoading(); }));
tools/clang/tools/extra/clangd/unittests/CancellationTests.cpp 20 EXPECT_TRUE(isCancelled());
30 EXPECT_TRUE(isCancelled());
32 EXPECT_TRUE(isCancelled());
41 EXPECT_TRUE(isCancelled());
61 EXPECT_TRUE(HasCancelled);
tools/clang/tools/extra/clangd/unittests/ClangdTests.cpp 154 EXPECT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
256 EXPECT_TRUE(DiagConsumer.hadErrorInLastDiags());
345 EXPECT_TRUE(DiagConsumer.hadErrorInLastDiags());
370 EXPECT_TRUE(DiagConsumer.hadErrorInLastDiags());
372 EXPECT_TRUE(DiagConsumer.hadErrorInLastDiags());
404 EXPECT_TRUE(DiagConsumer.hadErrorInLastDiags());
462 EXPECT_TRUE(bool(Locations));
477 EXPECT_TRUE(bool(Locations));
852 EXPECT_TRUE(static_cast<bool>(Replaces));
854 EXPECT_TRUE(static_cast<bool>(Changed));
980 EXPECT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
tools/clang/tools/extra/clangd/unittests/CodeCompleteTests.cpp 188 EXPECT_TRUE(Results.HasMore);
244 EXPECT_TRUE(Results.RanParser);
294 EXPECT_TRUE(Results.RanParser);
659 EXPECT_TRUE(Results.HasMore);
896 EXPECT_TRUE(Results.Completions.empty());
985 EXPECT_TRUE(Results.Completions.empty());
1182 EXPECT_TRUE(wait(Lock, ReceivedRequestCV, timeoutSeconds(30),
1643 EXPECT_TRUE(R.deprecated);
1718 EXPECT_TRUE(C.FixIts.size() == 1u || C.Name == "AuxFunction");
1758 EXPECT_TRUE(C.FixIts.empty() || C.Name == "AuxFunction");
1780 EXPECT_TRUE(R.textEdit);
1782 EXPECT_TRUE(R.additionalTextEdits.empty());
1800 EXPECT_TRUE(R.textEdit);
2362 EXPECT_TRUE(Results.Completions.empty());
tools/clang/tools/extra/clangd/unittests/DexTests.cpp 68 EXPECT_TRUE(DocIterator->reachedEnd());
108 EXPECT_TRUE(And->reachedEnd());
120 EXPECT_TRUE(And->reachedEnd());
149 EXPECT_TRUE(Or->reachedEnd());
180 EXPECT_TRUE(Or->reachedEnd());
241 EXPECT_TRUE(Root->reachedEnd());
286 EXPECT_TRUE(Corpus{0}.all()->reachedEnd());
502 EXPECT_TRUE(Req.Limit);
504 EXPECT_TRUE(Incomplete);
531 EXPECT_TRUE(Incomplete) << "Short queries have different semantics";
535 EXPECT_TRUE(Incomplete) << "Short queries have different semantics";
tools/clang/tools/extra/clangd/unittests/DraftStoreTests.cpp 199 EXPECT_TRUE(!Result);
220 EXPECT_TRUE(!Result);
241 EXPECT_TRUE(!Result);
262 EXPECT_TRUE(!Result);
283 EXPECT_TRUE(!Result);
303 EXPECT_TRUE(!Result);
336 EXPECT_TRUE(!Result);
341 EXPECT_TRUE(Contents);
tools/clang/tools/extra/clangd/unittests/FSTests.cpp 28 EXPECT_TRUE(ProduceFS->openFileForRead("x"));
29 EXPECT_TRUE(ProduceFS->status("y"));
30 EXPECT_TRUE(ProduceFS->status("main"));
32 EXPECT_TRUE(StatCache.lookup(testPath("x")).hasValue());
33 EXPECT_TRUE(StatCache.lookup(testPath("y")).hasValue());
44 EXPECT_TRUE(Cached);
51 EXPECT_TRUE(CachedDotDot);
tools/clang/tools/extra/clangd/unittests/FindSymbolsTests.cpp 74 EXPECT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for preamble";
76 EXPECT_TRUE(bool(SymbolInfos)) << "workspaceSymbols returned an error";
332 EXPECT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for preamble";
334 EXPECT_TRUE(bool(SymbolInfos)) << "documentSymbols returned an error";
tools/clang/tools/extra/clangd/unittests/FormatTests.cpp 35 EXPECT_TRUE(bool(NewCode))
tools/clang/tools/extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp 305 EXPECT_TRUE(DB.getCompileCommand(File));
306 EXPECT_TRUE(DB.getProjectInfo(File));
tools/clang/tools/extra/clangd/unittests/HeaderSourceSwitchTests.cpp 33 EXPECT_TRUE(PathResult.hasValue());
37 EXPECT_TRUE(PathResult.hasValue());
48 EXPECT_TRUE(PathResult.hasValue());
57 EXPECT_TRUE(PathResult.hasValue());
67 EXPECT_TRUE(PathResult.hasValue());
tools/clang/tools/extra/clangd/unittests/HeadersTests.cpp 50 EXPECT_TRUE(static_cast<bool>(CI));
66 EXPECT_TRUE(
82 EXPECT_TRUE(
108 EXPECT_TRUE(
263 EXPECT_TRUE(Edit.hasValue());
264 EXPECT_TRUE(StringRef(Edit->newText).contains("<y>"));
tools/clang/tools/extra/clangd/unittests/IndexTests.cpp 54 EXPECT_TRUE(Pos.hasOverflow());
59 EXPECT_TRUE(Pos.hasOverflow());
121 EXPECT_TRUE(WeakToken.expired()); // So the token is too.
143 EXPECT_TRUE(Req.Limit);
145 EXPECT_TRUE(Incomplete);
tools/clang/tools/extra/clangd/unittests/JSONTransportTests.cpp 196 EXPECT_TRUE(bool(Err)); // Ran into EOF with no handler signalling done.
tools/clang/tools/extra/clangd/unittests/QualityTests.cpp 60 EXPECT_TRUE(Quality.ReservedName);
65 EXPECT_TRUE(Quality.ImplementationDetail);
71 EXPECT_TRUE(Quality.Deprecated);
78 EXPECT_TRUE(Quality.Deprecated);
124 EXPECT_TRUE(Relevance.Forbidden);
180 EXPECT_TRUE(Relevance.InBaseClass);
193 EXPECT_TRUE(Matched);
393 EXPECT_TRUE(Rel.IsInstanceMember);
398 EXPECT_TRUE(Rel.IsInstanceMember);
409 EXPECT_TRUE(Rel.IsInstanceMember);
412 EXPECT_TRUE(Rel.IsInstanceMember);
481 EXPECT_TRUE(RelevanceWithFixIt.NeedsFixIts);
tools/clang/tools/extra/clangd/unittests/RenameTests.cpp 192 EXPECT_TRUE(bool(Results)) << "renameWithinFile returned an error: "
tools/clang/tools/extra/clangd/unittests/SelectionTests.cpp 320 EXPECT_TRUE(verifyCommonAncestor(T.root(), T.commonAncestor(), C.Code))
tools/clang/tools/extra/clangd/unittests/SerializationTests.cpp 103 EXPECT_TRUE(bool(readIndexFile("")));
108 EXPECT_TRUE(bool(In)) << In.takeError();
129 EXPECT_TRUE(Sym1.Flags & Symbol::IndexedForCodeCompletion);
141 EXPECT_TRUE(Sym2.Flags & Symbol::Deprecated);
182 EXPECT_TRUE(bool(In)) << In.takeError();
206 EXPECT_TRUE(bool(In)) << In.takeError();
245 EXPECT_TRUE(bool(In)) << In.takeError();
tools/clang/tools/extra/clangd/unittests/SourceCodeTests.cpp 277 EXPECT_TRUE(isRangeConsecutive(range({2, 2}, {2, 3}), range({2, 3}, {2, 4})));
519 EXPECT_TRUE(isInsideMainFile(DeclLoc(MainDecl), SM));
tools/clang/tools/extra/clangd/unittests/SymbolCollectorTests.cpp 154 EXPECT_TRUE(shouldCollect("nx"));
155 EXPECT_TRUE(shouldCollect("nx::X"));
156 EXPECT_TRUE(shouldCollect("nx::f"));
157 EXPECT_TRUE(shouldCollect("InMain"));
158 EXPECT_TRUE(shouldCollect("InAnonymous", /*Qualified=*/false));
159 EXPECT_TRUE(shouldCollect("g"));
176 EXPECT_TRUE(shouldCollect("nx::TopLevel"));
177 EXPECT_TRUE(shouldCollect("nx::Kind::KIND_OK"));
178 EXPECT_TRUE(shouldCollect("nx::Kind"));
194 EXPECT_TRUE(shouldCollect("nx::Top_Level"));
195 EXPECT_TRUE(shouldCollect("nx::Kind_Fine"));
tools/clang/tools/extra/clangd/unittests/TUSchedulerTests.cpp 155 [&](Expected<InputsAndAST> AST) { EXPECT_TRUE(bool(AST)); });
158 EXPECT_TRUE(bool(Preamble));
tools/clang/tools/extra/clangd/unittests/TraceTests.cpp 112 EXPECT_TRUE(VerifyObject(*Event, {{"ph", "M"}, {"name", "process_name"}}));
115 EXPECT_TRUE(VerifyObject(*Event, {{"ph", "M"}, {"name", "thread_name"}}));
118 EXPECT_TRUE(VerifyObject(*Event, {{"ph", "i"}, {"name", "Log"}}));
120 EXPECT_TRUE(VerifyObject(*Event, {{"ph", "X"}, {"name", "A"}}));
tools/clang/tools/extra/clangd/unittests/TypeHierarchyTests.cpp 477 EXPECT_TRUE(GotResult);
tools/clang/tools/extra/clangd/unittests/URITests.cpp 165 EXPECT_TRUE(static_cast<bool>(U));
180 EXPECT_TRUE(FailedResolve("no:/a/b/c"));
182 EXPECT_TRUE(FailedResolve("file:a/b/c"));
tools/clang/tools/extra/clangd/unittests/XRefsTests.cpp 582 EXPECT_TRUE(bool(Locations)) << "findDefinitions returned an error";
587 EXPECT_TRUE(bool(Locations)) << "findDefinitions returned an error";
594 EXPECT_TRUE(bool(Locations)) << "findDefinitions returned an error";
tools/clang/tools/extra/unittests/clang-apply-replacements/ApplyReplacementsTest.cpp 48 EXPECT_TRUE(mergeAndDeduplicate(TURs, TUs, ReplacementsMap, SM));
49 EXPECT_TRUE(ReplacementsMap.empty());
tools/clang/tools/extra/unittests/clang-change-namespace/ChangeNamespaceTests.cpp 57 EXPECT_TRUE(static_cast<bool>(ChangedCode));
tools/clang/tools/extra/unittests/clang-doc/BitcodeTest.cpp 67 EXPECT_TRUE(WriteResult.size() > 0);
96 EXPECT_TRUE(WriteResult.size() > 0);
116 EXPECT_TRUE(WriteResult.size() > 0);
138 EXPECT_TRUE(WriteResult.size() > 0);
156 EXPECT_TRUE(WriteResult.size() > 0);
272 EXPECT_TRUE(WriteResult.size() > 0);
tools/clang/tools/extra/unittests/clang-include-fixer/IncludeFixerTest.cpp 107 EXPECT_TRUE(static_cast<bool>(Replaces))
tools/clang/tools/extra/unittests/clang-query/QueryEngineTest.cpp 56 EXPECT_TRUE(NoOpQuery().run(OS, S));
68 EXPECT_TRUE(HelpQuery().run(OS, S));
70 EXPECT_TRUE(OS.str().find("Available commands:") != std::string::npos);
74 EXPECT_TRUE(MatchQuery("functionDecl()", FnMatcher).run(OS, S));
76 EXPECT_TRUE(OS.str().find("foo.cc:1:1: note: \"root\" binds here") !=
78 EXPECT_TRUE(OS.str().find("foo.cc:2:1: note: \"root\" binds here") !=
80 EXPECT_TRUE(OS.str().find("bar.cc:1:1: note: \"root\" binds here") !=
82 EXPECT_TRUE(OS.str().find("bar.cc:2:1: note: \"root\" binds here") !=
84 EXPECT_TRUE(OS.str().find("4 matches.") != std::string::npos);
88 EXPECT_TRUE(MatchQuery(FooMatcherString, FooMatcher).run(OS, S));
90 EXPECT_TRUE(OS.str().find("foo.cc:1:1: note: \"root\" binds here") !=
92 EXPECT_TRUE(OS.str().find("1 match.") != std::string::npos);
96 EXPECT_TRUE(
98 EXPECT_TRUE(MatchQuery(FooMatcherString, FooMatcher).run(OS, S));
100 EXPECT_TRUE(OS.str().find("Binding for \"root\":\nvoid foo1()") !=
105 EXPECT_TRUE(
107 EXPECT_TRUE(MatchQuery(FooMatcherString, FooMatcher).run(OS, S));
109 EXPECT_TRUE(OS.str().find("FunctionDecl") != std::string::npos);
113 EXPECT_TRUE(EnableOutputQuery(&QuerySession::DiagOutput).run(OS, S));
114 EXPECT_TRUE(EnableOutputQuery(&QuerySession::DetailedASTOutput).run(OS, S));
115 EXPECT_TRUE(MatchQuery(FooMatcherString, FooMatcher).run(OS, S));
119 EXPECT_TRUE(Output.find("FunctionDecl") != std::string::npos);
120 EXPECT_TRUE(Output.find("foo.cc:1:1: note: \"root\" binds here") !=
126 EXPECT_TRUE(SetQuery<bool>(&QuerySession::BindRoot, false).run(OS, S));
127 EXPECT_TRUE(MatchQuery(FooMatcherString, FooMatcher).run(OS, S));
129 EXPECT_TRUE(OS.str().find("No bindings.") != std::string::npos);
139 EXPECT_TRUE(QueryParser::parse("let x \"foo1\"", S)->run(OS, S));
143 EXPECT_TRUE(QueryParser::parse("let y hasName(x)", S)->run(OS, S));
147 EXPECT_TRUE(QueryParser::parse("match functionDecl(y)", S)->run(OS, S));
148 EXPECT_TRUE(OS.str().find("foo.cc:1:1: note: \"root\" binds here") !=
150 EXPECT_TRUE(OS.str().find("1 match.") != std::string::npos);
153 EXPECT_TRUE(QueryParser::parse("unlet x", S)->run(OS, S));
tools/clang/tools/extra/unittests/clang-query/QueryParserTest.cpp 28 EXPECT_TRUE(isa<NoOpQuery>(Q));
31 EXPECT_TRUE(isa<NoOpQuery>(Q));
118 EXPECT_TRUE(cast<MatchQuery>(Q)->Matcher.canConvertTo<Decl>());
122 EXPECT_TRUE(cast<MatchQuery>(Q)->Matcher.canConvertTo<Stmt>());
129 EXPECT_TRUE(cast<LetQuery>(Q)->Value.isMatcher());
130 EXPECT_TRUE(cast<LetQuery>(Q)->Value.getMatcher().hasTypedMatcher<Decl>());
135 EXPECT_TRUE(cast<LetQuery>(Q)->Value.isMatcher());
136 EXPECT_TRUE(cast<LetQuery>(Q)->Value.getMatcher().hasTypedMatcher<Decl>());
141 EXPECT_TRUE(cast<LetQuery>(Q)->Value.isString());
tools/clang/tools/extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp 12 EXPECT_TRUE(Options.LineFilter.empty());
14 EXPECT_TRUE(Options.LineFilter.empty());
19 EXPECT_TRUE(!!parseLineFilter("asdf", Options));
20 EXPECT_TRUE(Options.LineFilter.empty());
22 EXPECT_TRUE(!!parseLineFilter("[{}]", Options));
23 EXPECT_TRUE(!!parseLineFilter("[{\"name\":\"\"}]", Options));
24 EXPECT_TRUE(
26 EXPECT_TRUE(
28 EXPECT_TRUE(
63 EXPECT_TRUE(!!Options);
tools/clang/tools/extra/unittests/clang-tidy/GlobListTest.cpp 10 EXPECT_TRUE(Filter.contains(""));
27 EXPECT_TRUE(Filter.contains(""));
28 EXPECT_TRUE(Filter.contains("aaaa"));
29 EXPECT_TRUE(Filter.contains("-*"));
30 EXPECT_TRUE(Filter.contains("-"));
31 EXPECT_TRUE(Filter.contains("*"));
37 EXPECT_TRUE(Filter.contains("aaa"));
47 EXPECT_TRUE(Filter.contains("aaa"));
48 EXPECT_TRUE(Filter.contains("bbb"));
62 EXPECT_TRUE(Filter.contains("a"));
63 EXPECT_TRUE(Filter.contains("aa"));
65 EXPECT_TRUE(Filter.contains("aaaa"));
71 EXPECT_TRUE(Filter.contains("a"));
72 EXPECT_TRUE(Filter.contains("aa"));
73 EXPECT_TRUE(Filter.contains("aaa"));
74 EXPECT_TRUE(Filter.contains("aaaa"));
81 EXPECT_TRUE(Filter.contains("a.b.c"));
88 EXPECT_TRUE(Filter.contains("aaa"));
89 EXPECT_TRUE(Filter.contains("qqq"));
94 EXPECT_TRUE(Filter.contains("a.1.b"));
98 EXPECT_TRUE(Filter.contains("asdfqwEasdf"));
tools/clang/tools/extra/unittests/clang-tidy/GoogleModuleTest.cpp 85 EXPECT_TRUE(runCheckOnCode("using std::string;", "foo.h"));
95 EXPECT_TRUE(runCheckOnCode("using namespace std;", "foo.h"));
tools/clang/unittests/AST/ASTContextParentMapTest.cpp 28 EXPECT_TRUE(
35 EXPECT_TRUE(Verifier.match("class C { void f() { if (true) {} } };",
41 EXPECT_TRUE(
48 EXPECT_TRUE(Verifier.match("namespace a { class b {}; } void f(a::b) {}",
54 EXPECT_TRUE(DeclVerifier.match(
59 EXPECT_TRUE(DeclVerifier.match(
75 EXPECT_TRUE(TemplateVerifier.match(
110 EXPECT_TRUE(LambdaVerifier.match(
tools/clang/unittests/AST/ASTImporterGenericRedeclTest.cpp 168 EXPECT_TRUE(ImportedD == ToD);
171 EXPECT_TRUE(ToT->getTemplatedDecl());
185 EXPECT_TRUE(ToD->isThisDeclarationADefinition());
187 EXPECT_TRUE(ToT->getTemplatedDecl());
205 EXPECT_TRUE(Imported0 == To0);
206 EXPECT_TRUE(Imported1 == To1);
227 EXPECT_TRUE(ImportedProto == ToProto);
228 EXPECT_TRUE(ImportedDef == ToDef);
230 EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
249 EXPECT_TRUE(ImportedDef == ToDef);
250 EXPECT_TRUE(ImportedProto == ToProto);
251 EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
272 EXPECT_TRUE(Imported0 == To0);
273 EXPECT_TRUE(Imported1 == To1);
295 EXPECT_TRUE(Imported0 == To0);
296 EXPECT_TRUE(To0->isThisDeclarationADefinition());
298 EXPECT_TRUE(ToT0->getTemplatedDecl());
319 EXPECT_TRUE(ImportedDef == ToDef);
320 EXPECT_TRUE(ImportedProto == ToProto);
321 EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
344 EXPECT_TRUE(ImportedDef == ToDef);
345 EXPECT_TRUE(ImportedProto == ToProto);
346 EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
363 EXPECT_TRUE(cast<DeclTy>(ImportedD)->isThisDeclarationADefinition());
386 EXPECT_TRUE(DefinitionD->isThisDeclarationADefinition());
388 EXPECT_TRUE(DefinitionD->getPreviousDecl());
tools/clang/unittests/AST/ASTImporterODRStrategiesTest.cpp 285 EXPECT_TRUE(isImportError(Result, ImportError::NameConflict));
tools/clang/unittests/AST/ASTImporterTest.cpp 93 EXPECT_TRUE(Verifier.match(ToImport, WrapperMatcher));
136 EXPECT_TRUE(
171 EXPECT_TRUE(AST.get());
224 EXPECT_TRUE(FoundDecl.size() == 1);
227 EXPECT_TRUE(static_cast<bool>(Imported));
235 EXPECT_TRUE(FoundDecl.size() == 1);
238 EXPECT_TRUE(
384 EXPECT_TRUE(path.hasCycleAtBack());
388 EXPECT_TRUE(path.hasCycleAtBack());
395 EXPECT_TRUE(path.hasCycleAtBack());
412 EXPECT_TRUE(path.hasCycleAtBack());
433 EXPECT_TRUE(path.hasCycleAtBack());
448 EXPECT_TRUE(path.hasCycleAtBack());
992 EXPECT_TRUE(MatchVerifier<FunctionDecl>().match(
1180 EXPECT_TRUE(ToTemplated1);
1194 EXPECT_TRUE(ToTemplated1);
1207 EXPECT_TRUE(ToTemplated);
1211 EXPECT_TRUE(ToFT);
1223 EXPECT_TRUE(ToTemplated);
1227 EXPECT_TRUE(ToFT);
1257 EXPECT_TRUE(ToTemplated1);
1309 EXPECT_TRUE(Verifier.match(To, Matcher));
1335 EXPECT_TRUE(Check(To));
1361 EXPECT_TRUE(Check(To));
1389 EXPECT_TRUE(Check(To));
1409 EXPECT_TRUE(
1418 EXPECT_TRUE(
1455 EXPECT_TRUE(MatchVerifier<Decl>{}.match(To, Pattern));
1461 EXPECT_TRUE(MatchVerifier<Decl>{}.match(To, Pattern));
1474 EXPECT_TRUE(Verifier.match(To, cxxRecordDecl(hasFieldOrder({"a", "b"}))));
1495 EXPECT_TRUE(
1520 EXPECT_TRUE(Verifier.match(
1537 EXPECT_TRUE(Verifier.match(To, Matcher));
1555 EXPECT_TRUE(Verifier.match(To, Matcher));
1575 EXPECT_TRUE(
1587 EXPECT_TRUE(Verifier.match(To, Matcher));
1619 EXPECT_TRUE(
1653 EXPECT_TRUE(ToCTD->isThisDeclarationADefinition());
1849 EXPECT_TRUE(To0);
1850 EXPECT_TRUE(To1);
1937 EXPECT_TRUE(Imported2->isUsed(false));
1955 EXPECT_TRUE(ExistingD->isUsed(false));
1986 EXPECT_TRUE(ExistingD->isUsed(false));
2003 EXPECT_TRUE(Imported2->isUsed(false));
2020 EXPECT_TRUE(ImportedD == To0);
2022 EXPECT_TRUE(To1->doesThisDeclarationHaveABody());
2038 EXPECT_TRUE(ImportedD == To1);
2040 EXPECT_TRUE(To1->doesThisDeclarationHaveABody());
2078 EXPECT_TRUE(To->isVirtual());
2302 EXPECT_TRUE(To0);
2321 EXPECT_TRUE(ToF0);
2361 EXPECT_TRUE(ToD);
2367 EXPECT_TRUE(LambdaRec->getDestructor());
2387 EXPECT_TRUE(ToD);
2388 EXPECT_TRUE(MatchVerifier<FunctionDecl>().match(
2413 EXPECT_TRUE(ToD);
2415 EXPECT_TRUE(MatchVerifier<TranslationUnitDecl>().match(
2476 EXPECT_TRUE(ImportedD);
2494 EXPECT_TRUE(ImportedD);
2516 EXPECT_TRUE(ImportedD);
2569 EXPECT_TRUE(ImportedD->doesThisDeclarationHaveABody());
2589 EXPECT_TRUE(ToFD->doesThisDeclarationHaveABody());
2610 EXPECT_TRUE(ImportedD->doesThisDeclarationHaveABody());
2643 EXPECT_TRUE(OutOfClassFD->doesThisDeclarationHaveABody());
2669 EXPECT_TRUE(ImportedD->doesThisDeclarationHaveABody());
2704 EXPECT_TRUE(To0->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
2752 EXPECT_TRUE(ToFriend->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
2755 EXPECT_TRUE(ToNormal->isInIdentifierNamespace(Decl::IDNS_Ordinary));
2797 EXPECT_TRUE(ToNormal->isInIdentifierNamespace(Decl::IDNS_Ordinary));
2798 EXPECT_TRUE(ToFriend->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
2799 EXPECT_TRUE(ToFriend->isInIdentifierNamespace(Decl::IDNS_Ordinary));
2828 EXPECT_TRUE(ToNormalF->isInIdentifierNamespace(Decl::IDNS_Ordinary));
2839 EXPECT_TRUE(ToNormalF->isInIdentifierNamespace(Decl::IDNS_Ordinary));
2842 EXPECT_TRUE(ToFriendF->isInIdentifierNamespace(Decl::IDNS_Ordinary));
2843 EXPECT_TRUE(ToFriendF->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
3253 EXPECT_TRUE(MatchVerifier<RecordDecl>().match(
3255 EXPECT_TRUE(MatchVerifier<RecordDecl>().match(
3270 EXPECT_TRUE(ToF);
3277 EXPECT_TRUE(ToLambda);
3284 EXPECT_TRUE(ToField);
3286 EXPECT_TRUE(ToIndex);
3337 EXPECT_TRUE(ToField->getInClassInitializer());
3379 EXPECT_TRUE(ToFun->hasBody());
3466 EXPECT_TRUE(ToCtor->hasBody());
3544 EXPECT_TRUE(ImportedSpec);
3568 EXPECT_TRUE(ToD);
3570 EXPECT_TRUE(ToInitExpr);
3571 EXPECT_TRUE(ToInitExpr->isGLValue());
3627 EXPECT_TRUE(ImportedD->getAnyInitializer());
3628 EXPECT_TRUE(ImportedD->getDefinition());
3658 EXPECT_TRUE(ImportedD->getAnyInitializer());
3659 EXPECT_TRUE(ImportedD->getDefinition());
3676 EXPECT_TRUE(ImportedDef == ToDef);
3677 EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
3694 EXPECT_TRUE(ImportedDef == ToDef);
3695 EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
3715 EXPECT_TRUE(ImportedDef == ToDef);
3716 EXPECT_TRUE(ImportedProto == ToProto);
3717 EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
3753 EXPECT_TRUE(ToClass);
3754 EXPECT_TRUE(ToFriendClass);
3776 EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToD, Pattern));
3795 EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToD, Pattern));
3871 EXPECT_TRUE(Imported->getPreviousDecl());
3898 EXPECT_TRUE(ImportedDef->getPreviousDecl());
3929 EXPECT_TRUE(ImportedDef->getPreviousDecl());
3959 EXPECT_TRUE(ImportedDef->getPreviousDecl());
4068 EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToTU, Pattern));
4091 EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToTU, Pattern));
4115 EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToTU, Pattern));
4213 EXPECT_TRUE(ToCTD->isThisDeclarationADefinition());
4820 EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
4959 EXPECT_TRUE(ToProto);
5007 EXPECT_TRUE(OptErr);
5050 EXPECT_TRUE(Import(FromB, Lang_CXX));
5052 EXPECT_TRUE(Import(FromNS, Lang_CXX));
5057 EXPECT_TRUE(OptErr);
5061 EXPECT_TRUE(OptErr);
5080 EXPECT_TRUE(OptErr);
5085 EXPECT_TRUE(OptErr);
5090 EXPECT_TRUE(OptErr);
5095 EXPECT_TRUE(OptErr);
5113 EXPECT_TRUE(ImportedX);
5135 EXPECT_TRUE(ImportedOK);
5307 EXPECT_TRUE(ToF);
5475 EXPECT_TRUE(Constr1->isDefaulted());
5476 EXPECT_TRUE(Constr1->isExplicitlyDefaulted());
5477 EXPECT_TRUE(Constr2->isDeletedAsWritten());
5571 EXPECT_TRUE(ToF);
5595 EXPECT_TRUE(ToF);
tools/clang/unittests/AST/ASTImporterVisibilityTest.cpp 110 EXPECT_TRUE(ToD0);
tools/clang/unittests/AST/ASTTypeTraitsTest.cpp 29 EXPECT_TRUE(ASTNodeKind().isNone());
35 EXPECT_TRUE(DNT<Decl>().isBaseOf(DNT<VarDecl>()));
39 EXPECT_TRUE(DNT<Decl>().isSame(DNT<Decl>()));
44 EXPECT_TRUE(DNT<Expr>().isBaseOf(DNT<Expr>(), &Distance));
47 EXPECT_TRUE(DNT<Stmt>().isBaseOf(DNT<IfStmt>(), &Distance));
51 EXPECT_TRUE(DNT<DeclaratorDecl>().isBaseOf(DNT<ParmVarDecl>(), &Distance));
56 EXPECT_TRUE(DNT<Expr>().isBaseOf(DNT<CallExpr>()));
57 EXPECT_TRUE(DNT<Expr>().isBaseOf(DNT<BinaryOperator>()));
69 EXPECT_TRUE(DNT<BinaryOperator>().isSame(
71 EXPECT_TRUE(DNT<BinaryOperator>().isSame(
73 EXPECT_TRUE(DNT<VarDecl>().isSame(
77 EXPECT_TRUE(
79 EXPECT_TRUE(ASTNodeKind::getMostDerivedType(DNT<IfStmt>(),
84 EXPECT_TRUE(DNT<Expr>().isSame(ASTNodeKind::getMostDerivedCommonAncestor(
86 EXPECT_TRUE(DNT<Expr>().isSame(ASTNodeKind::getMostDerivedCommonAncestor(
88 EXPECT_TRUE(DNT<VarDecl>().isSame(ASTNodeKind::getMostDerivedCommonAncestor(
92 EXPECT_TRUE(
97 EXPECT_TRUE(ASTNodeKind::getMostDerivedCommonAncestor(
129 EXPECT_TRUE(Verifier.match("void f() {}", decl()));
135 EXPECT_TRUE(Verifier.match("void f() {}", stmt()));
141 EXPECT_TRUE(Verifier.match("void f() {}", typeLoc(loc(functionType()))));
147 EXPECT_TRUE(Verifier.match("namespace N { typedef void T; } N::T f() {}",
154 EXPECT_TRUE(Verifier.match("void f() {}", functionDecl()));
160 EXPECT_TRUE(Verifier.match("void f() {}", stmt()));
166 EXPECT_TRUE(Verifier.match("void f() {}", functionDecl()));
172 EXPECT_TRUE(Verifier.match("void f() {}", stmt()));
178 EXPECT_TRUE(Node == Node);
tools/clang/unittests/AST/EvaluateAsRValueTest.cpp 76 EXPECT_TRUE(VarInfo["Constant"]);
tools/clang/unittests/AST/SourceLocationTest.cpp 70 EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
76 EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
82 EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
88 EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
94 EXPECT_TRUE(Verifier.match("void f() { new int[10]; }", cxxNewExpr()));
100 EXPECT_TRUE(Verifier.match("void f() { new int(); }", cxxNewExpr()));
106 EXPECT_TRUE(Verifier.match("struct S { operator int() const; };\n"
121 EXPECT_TRUE(Verifier.match("struct S { int x; };\n"
129 EXPECT_TRUE(Verifier.match("#define MEMBER(a, b) (a->b)\n"
138 EXPECT_TRUE(Verifier.match("struct S { int x; void Test(); };\n"
146 EXPECT_TRUE(Verifier.match("int a[(int)(void*)1234];",
153 EXPECT_TRUE(Verifier.match("int a;", typeLoc()));
159 EXPECT_TRUE(Verifier.match("long a;", typeLoc()));
165 EXPECT_TRUE(Verifier.match("long double a;", typeLoc()));
171 EXPECT_TRUE(Verifier.match("double long a;", typeLoc()));
177 EXPECT_TRUE(Verifier.match("long int a;", typeLoc()));
183 EXPECT_TRUE(Verifier.match("int long a;", typeLoc()));
189 EXPECT_TRUE(Verifier.match("unsigned int a;", typeLoc()));
195 EXPECT_TRUE(Verifier.match("int unsigned a;", typeLoc()));
201 EXPECT_TRUE(Verifier.match("long long a;", typeLoc()));
207 EXPECT_TRUE(Verifier.match("unsigned long long a;", typeLoc()));
213 EXPECT_TRUE(Verifier.match("long unsigned long a;", typeLoc()));
219 EXPECT_TRUE(Verifier.match("long long unsigned a;", typeLoc()));
225 EXPECT_TRUE(Verifier.match("const long long a = 0;", typeLoc()));
231 EXPECT_TRUE(Verifier.match("long const long a = 0;", typeLoc()));
237 EXPECT_TRUE(Verifier.match("long long const a = 0;", typeLoc()));
243 EXPECT_TRUE(Verifier.match("class C { C(); };", functionDecl()));
249 EXPECT_TRUE(Verifier.match("class C { C() = default; };", functionDecl()));
255 EXPECT_TRUE(Verifier.match("class C { C() = delete; };", functionDecl()));
261 EXPECT_TRUE(Verifier.match(
269 EXPECT_TRUE(Verifier.match(
278 EXPECT_TRUE(Verifier.match(
286 EXPECT_TRUE(Verifier.match(
304 EXPECT_TRUE(Verifier.match(
313 EXPECT_TRUE(Verifier.match("int* a = new (int);", cxxNewExpr()));
329 EXPECT_TRUE(Verifier.match(
340 EXPECT_TRUE(Verifier.match(
350 EXPECT_TRUE(Verifier.match(
360 EXPECT_TRUE(Verifier.match(
371 EXPECT_TRUE(Verifier.match(
382 EXPECT_TRUE(Verifier.match(
391 EXPECT_TRUE(Verifier.match(
402 EXPECT_TRUE(Verifier.match("struct A {\n"
411 EXPECT_TRUE(Verifier.match("struct A {\n"
420 EXPECT_TRUE(Verifier.match("struct A {\n"
429 EXPECT_TRUE(Verifier.match("struct A {\n"
438 EXPECT_TRUE(Verifier.match("struct A {\n"
447 EXPECT_TRUE(Verifier.match("struct A {\n"
456 EXPECT_TRUE(Verifier.match("class B;\n"
466 EXPECT_TRUE(Verifier.match("class B;\n"
476 EXPECT_TRUE(Verifier.match("template <typename T>\n"
486 EXPECT_TRUE(Verifier.match("template <typename T>\n"
496 EXPECT_TRUE(Verifier.match("struct A;\n"
507 EXPECT_TRUE(Verifier.match("struct A;\n"
525 EXPECT_TRUE(ConstructorVerifier.match(
529 EXPECT_TRUE(DestructorVerifier.match(
543 EXPECT_TRUE(ConstructorVerifier.match(
547 EXPECT_TRUE(DestructorVerifier.match(
554 EXPECT_TRUE(Verifier.match("struct A {\n"
564 EXPECT_TRUE(Verifier.match("struct A {\n"
574 EXPECT_TRUE(Verifier.match("struct A {\n"
584 EXPECT_TRUE(Verifier.match("struct A {\n"
594 EXPECT_TRUE(Verifier.match("struct A {\n"
603 EXPECT_TRUE(Verifier.match("struct A {\n"
612 EXPECT_TRUE(Verifier.match(
625 EXPECT_TRUE(Verifier.match(
637 EXPECT_TRUE(Verifier.match(
645 EXPECT_TRUE(Verifier.match(
654 EXPECT_TRUE(Verifier.match(
664 EXPECT_TRUE(Verifier.match(
702 EXPECT_TRUE(Verifier.match("void f() throw();\n", loc(functionType())));
705 EXPECT_TRUE(Verifier.match("void f() throw(void(void) throw());\n",
711 EXPECT_TRUE(Verifier.match("void f() throw(...);\n", loc(functionType()),
715 EXPECT_TRUE(Verifier.match("void f() noexcept;\n", loc(functionType()),
719 EXPECT_TRUE(Verifier.match("void f() noexcept(false);\n", loc(functionType()),
723 EXPECT_TRUE(Verifier.match("void f() noexcept(noexcept(1+1));\n",
728 EXPECT_TRUE(Verifier2.match("void g(void (*fp)(void) throw());\n",
733 EXPECT_TRUE(Verifier2.match("void g(void (*fp)(void) noexcept(true));\n",
tools/clang/unittests/AST/StructuralEquivalenceTest.cpp 102 EXPECT_TRUE(testStructuralMatch(Decls));
107 EXPECT_TRUE(testStructuralMatch(Decls));
112 EXPECT_TRUE(testStructuralMatch(Decls));
124 EXPECT_TRUE(testStructuralMatch(Decls));
130 EXPECT_TRUE(testStructuralMatch(Decls));
147 EXPECT_TRUE(testStructuralMatch(Spec0, Spec1));
248 EXPECT_TRUE(testStructuralMatch(t));
269 EXPECT_TRUE(testStructuralMatch(t));
312 EXPECT_TRUE(testStructuralMatch(t));
360 EXPECT_TRUE(testStructuralMatch(t));
380 EXPECT_TRUE(testStructuralMatch(t));
404 EXPECT_TRUE(testStructuralMatch(t));
546 EXPECT_TRUE(testStructuralMatch(t));
628 EXPECT_TRUE(testStructuralMatch(t));
653 EXPECT_TRUE(testStructuralMatch(R0, R0));
654 EXPECT_TRUE(testStructuralMatch(R1, R1));
682 EXPECT_TRUE(testStructuralMatch(RA, RA));
683 EXPECT_TRUE(testStructuralMatch(RB, RB));
724 EXPECT_TRUE(testStructuralMatch(RA, RA));
725 EXPECT_TRUE(testStructuralMatch(RA1, RA1));
760 EXPECT_TRUE(testStructuralMatch(R0, R0));
761 EXPECT_TRUE(testStructuralMatch(R1, R1));
777 EXPECT_TRUE(testStructuralMatch(t));
784 EXPECT_TRUE(testStructuralMatch(t));
791 EXPECT_TRUE(testStructuralMatch(t));
825 EXPECT_TRUE(testStructuralMatch(L0, L1));
849 EXPECT_TRUE(testStructuralMatch(L0, L1));
877 EXPECT_TRUE(testStructuralMatch(First, Second));
884 EXPECT_TRUE(testStructuralMatch(t));
891 EXPECT_TRUE(testStructuralMatch(t));
898 EXPECT_TRUE(testStructuralMatch(t));
912 EXPECT_TRUE(testStructuralMatch(t));
918 EXPECT_TRUE(testStructuralMatch(t));
934 EXPECT_TRUE(testStructuralMatch(First, Second));
974 EXPECT_TRUE(testStructuralMatch(t));
1029 EXPECT_TRUE(testStructuralMatch(t));
1082 EXPECT_TRUE(testStructuralMatch(t));
1169 EXPECT_TRUE(testStructuralMatch(t));
1222 EXPECT_TRUE(testStructuralMatch(t));
1390 EXPECT_TRUE(Ctx.IsEquivalent(C.first, C.second));
tools/clang/unittests/ASTMatchers/ASTMatchersInternalTest.cpp 25 EXPECT_TRUE(notMatches("class X {};", HasEmptyName));
32 EXPECT_TRUE(notMatches("class X {};", HasEmptyName));
38 EXPECT_TRUE(
57 EXPECT_TRUE(matchAndVerifyResultTrue("class A { class B {}; };",
60 EXPECT_TRUE(matchAndVerifyResultFalse("class A { class B {}; };",
63 EXPECT_TRUE(matchAndVerifyResultFalse("class A { class C {}; };",
80 EXPECT_TRUE(matchAndVerifyResultTrue("class A { class B {}; };",
83 EXPECT_TRUE(matchAndVerifyResultFalse("class A { class B {}; };",
86 EXPECT_TRUE(matchAndVerifyResultFalse("class A { class C {}; };",
92 EXPECT_TRUE(matches("void x() { class B {}; }", StatementHasClassB));
118 EXPECT_TRUE(Called);
131 EXPECT_TRUE(VerifyCallback.Called);
137 EXPECT_TRUE(VerifyCallback.Called);
157 EXPECT_TRUE(VerifyCallback.Called);
163 EXPECT_TRUE(VerifyCallback.Called);
176 EXPECT_TRUE(matches("void g(); inline void f();",
178 EXPECT_TRUE(matches("namespace n { inline namespace m {} }",
187 EXPECT_TRUE(matches("class X {};",
189 EXPECT_TRUE(notMatches("", recordDecl(isExpansionInMainFile())));
192 EXPECT_TRUE(matchesConditionally("#include <other>\n",
200 EXPECT_TRUE(matchesConditionally(
203 EXPECT_TRUE(matchesConditionally("#include \"other\"\n",
206 EXPECT_TRUE(notMatches("class X {};",
208 EXPECT_TRUE(notMatches("", recordDecl(isExpansionInSystemHeader())));
215 EXPECT_TRUE(matchesConditionally(
221 EXPECT_TRUE(matchesConditionally(
tools/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp 27 EXPECT_TRUE(matches(Program,
30 EXPECT_TRUE(matches(Program,
35 EXPECT_TRUE(matches(Program,
41 EXPECT_TRUE(matches(Program,
52 EXPECT_TRUE(matches("class Y { class X {}; };", HasClassX));
53 EXPECT_TRUE(matches("class X {};", HasClassX));
57 EXPECT_TRUE(matches("class Y { class X {}; };", YHasClassX));
58 EXPECT_TRUE(notMatches("class X {};", YHasClassX));
59 EXPECT_TRUE(
76 EXPECT_TRUE(matches(
88 EXPECT_TRUE(matches(
102 EXPECT_TRUE(matches(
141 EXPECT_TRUE(matches("class F {};", Recursive));
142 EXPECT_TRUE(matches("class Z {};", Recursive));
143 EXPECT_TRUE(matches("class C {};", Recursive));
144 EXPECT_TRUE(matches("class M { class N { class X {}; }; };", Recursive));
145 EXPECT_TRUE(matches("class M { class N { class B {}; }; };", Recursive));
146 EXPECT_TRUE(
157 EXPECT_TRUE(notMatches("", NotClassX));
158 EXPECT_TRUE(notMatches("class Y {};", NotClassX));
159 EXPECT_TRUE(matches("class Y {}; class Z : public Y {};", NotClassX));
160 EXPECT_TRUE(notMatches("class Y {}; class X : public Y {};", NotClassX));
161 EXPECT_TRUE(
171 EXPECT_TRUE(matches("class X { class Z {}; };", ClassXHasNotClassY));
172 EXPECT_TRUE(notMatches("class X { class Y {}; class Z {}; };",
177 EXPECT_TRUE(matches("void Foo(){}", NamedNotRecord));
178 EXPECT_TRUE(notMatches("struct Foo {};", NamedNotRecord));
182 EXPECT_TRUE(matches("char *p = 0;",
184 EXPECT_TRUE(notMatches("char *p = 0;",
186 EXPECT_TRUE(matches("char *p = 0;",
195 EXPECT_TRUE(matches("class Z { class X {}; };", ZDescendantClassX));
196 EXPECT_TRUE(
198 EXPECT_TRUE(
201 EXPECT_TRUE(
204 EXPECT_TRUE(notMatches("class Z {};", ZDescendantClassX));
211 EXPECT_TRUE(matches("class Z { class X { class Y {}; }; };",
213 EXPECT_TRUE(
216 EXPECT_TRUE(notMatches(
234 EXPECT_TRUE(
237 EXPECT_TRUE(matches(
253 EXPECT_TRUE(matches("void f() { int i; }", CannotMemoize));
261 EXPECT_TRUE(notMatches("void f() { int i; }",
263 EXPECT_TRUE(notMatches("void f() { int i; }",
266 EXPECT_TRUE(matches("void f() { int i; }",
278 EXPECT_TRUE(notMatches("template <typename T> struct S;"
284 EXPECT_TRUE(matches("struct __attribute__((warn_unused)) X {};",
294 EXPECT_TRUE(matches("class X {}; class Z : public X {};", YOrZDerivedFromX));
295 EXPECT_TRUE(matches("class Y {};", YOrZDerivedFromX));
296 EXPECT_TRUE(
298 EXPECT_TRUE(notMatches("class Z {};", YOrZDerivedFromX));
302 EXPECT_TRUE(matches("class X {};", XOrYOrZOrU));
303 EXPECT_TRUE(notMatches("class V {};", XOrYOrZOrU));
308 EXPECT_TRUE(matches("class X {};", XOrYOrZOrUOrV));
309 EXPECT_TRUE(matches("class Y {};", XOrYOrZOrUOrV));
310 EXPECT_TRUE(matches("class Z {};", XOrYOrZOrUOrV));
311 EXPECT_TRUE(matches("class U {};", XOrYOrZOrUOrV));
312 EXPECT_TRUE(matches("class V {};", XOrYOrZOrUOrV));
313 EXPECT_TRUE(notMatches("class A {};", XOrYOrZOrUOrV));
316 EXPECT_TRUE(matches("int F() { return 1 + 2; }", MixedTypes));
317 EXPECT_TRUE(matches("int F() { if (true) return 1; }", MixedTypes));
318 EXPECT_TRUE(notMatches("int F() { return 1; }", MixedTypes));
320 EXPECT_TRUE(
328 EXPECT_TRUE(matches("class X {}; class Y : public X {};", IsDerivedFromX));
329 EXPECT_TRUE(notMatches("class X {};", IsDerivedFromX));
330 EXPECT_TRUE(notMatches("class X;", IsDerivedFromX));
331 EXPECT_TRUE(notMatches("class Y;", IsDerivedFromX));
332 EXPECT_TRUE(notMatches("", IsDerivedFromX));
337 EXPECT_TRUE(
339 EXPECT_TRUE(notMatches("class X {};", IsDirectlyDerivedFromX));
340 EXPECT_TRUE(notMatches("class X;", IsDirectlyDerivedFromX));
341 EXPECT_TRUE(notMatches("class Y;", IsDirectlyDerivedFromX));
342 EXPECT_TRUE(notMatches("", IsDirectlyDerivedFromX));
346 EXPECT_TRUE(matches("class X {}; class Y : public X {};", IsAX));
347 EXPECT_TRUE(matches("class X {};", IsAX));
348 EXPECT_TRUE(matches("class X;", IsAX));
349 EXPECT_TRUE(notMatches("class Y;", IsAX));
350 EXPECT_TRUE(notMatches("", IsAX));
356 EXPECT_TRUE(
359 EXPECT_TRUE(
362 EXPECT_TRUE(
366 EXPECT_TRUE(notMatches("class X {};"
370 EXPECT_TRUE(matches("class X {}; template<class T> class Z : public X {};",
372 EXPECT_TRUE(
376 EXPECT_TRUE(
380 EXPECT_TRUE(
383 EXPECT_TRUE(
386 EXPECT_TRUE(
390 EXPECT_TRUE(
393 EXPECT_TRUE(
398 EXPECT_TRUE(
401 EXPECT_TRUE(
406 EXPECT_TRUE(
409 EXPECT_TRUE(
412 EXPECT_TRUE(matches("class X {}; class Z : public ::X {};",
414 EXPECT_TRUE(
418 EXPECT_TRUE(
423 EXPECT_TRUE(
426 EXPECT_TRUE(
429 EXPECT_TRUE(
433 EXPECT_TRUE(notMatches("class X {}; class Y : public X {}; "
436 EXPECT_TRUE(
440 EXPECT_TRUE(
444 EXPECT_TRUE(
447 EXPECT_TRUE(
450 EXPECT_TRUE(
453 EXPECT_TRUE(
456 EXPECT_TRUE(
459 EXPECT_TRUE(
462 EXPECT_TRUE(
465 EXPECT_TRUE(
470 EXPECT_TRUE(
475 EXPECT_TRUE(matches(
481 EXPECT_TRUE(
485 EXPECT_TRUE(matches(
492 EXPECT_TRUE(notMatches(
513 EXPECT_TRUE(matches(
517 EXPECT_TRUE(notMatches(
521 EXPECT_TRUE(matches(
538 EXPECT_TRUE(matches(
542 EXPECT_TRUE(notMatches(
546 EXPECT_TRUE(matches(
551 EXPECT_TRUE(matches(
554 EXPECT_TRUE(notMatches(
558 EXPECT_TRUE(matches(
562 EXPECT_TRUE(matches(
571 EXPECT_TRUE(notMatches(Code, cxxRecordDecl(isDerivedFrom(""))));
572 EXPECT_TRUE(notMatches(Code, cxxRecordDecl(isDirectlyDerivedFrom(""))));
573 EXPECT_TRUE(notMatches(Code, cxxRecordDecl(isSameOrDerivedFrom(""))));
578 EXPECT_TRUE(
580 EXPECT_TRUE(matchesObjC(
583 EXPECT_TRUE(matchesObjC(
586 EXPECT_TRUE(matchesObjC(
588 EXPECT_TRUE(notMatchesObjC("@interface X @end", IsDerivedFromX));
589 EXPECT_TRUE(notMatchesObjC("@class X;", IsDerivedFromX));
590 EXPECT_TRUE(notMatchesObjC("@class Y;", IsDerivedFromX));
591 EXPECT_TRUE(notMatchesObjC("@interface X @end @compatibility_alias Y X;",
593 EXPECT_TRUE(notMatchesObjC("@interface X @end typedef X Y;", IsDerivedFromX));
597 EXPECT_TRUE(
599 EXPECT_TRUE(matchesObjC(
602 EXPECT_TRUE(matchesObjC(
605 EXPECT_TRUE(matchesObjC(
608 EXPECT_TRUE(notMatchesObjC("@interface X @end", IsDirectlyDerivedFromX));
609 EXPECT_TRUE(notMatchesObjC("@class X;", IsDirectlyDerivedFromX));
610 EXPECT_TRUE(notMatchesObjC("@class Y;", IsDirectlyDerivedFromX));
611 EXPECT_TRUE(notMatchesObjC("@interface X @end @compatibility_alias Y X;",
613 EXPECT_TRUE(notMatchesObjC("@interface X @end typedef X Y;",
617 EXPECT_TRUE(matchesObjC("@interface X @end @interface Y : X @end", IsAX));
618 EXPECT_TRUE(matchesObjC("@interface X @end", IsAX));
619 EXPECT_TRUE(matchesObjC("@class X;", IsAX));
620 EXPECT_TRUE(notMatchesObjC("@interface Y @end", IsAX));
621 EXPECT_TRUE(notMatchesObjC("@class Y;", IsAX));
627 EXPECT_TRUE(matchesObjC(
630 EXPECT_TRUE(matchesObjC("@interface X @end @interface Y : X @end typedef Y "
633 EXPECT_TRUE(matchesObjC(
635 EXPECT_TRUE(matchesObjC(
638 EXPECT_TRUE(matchesObjC(
641 EXPECT_TRUE(matchesObjC(
644 EXPECT_TRUE(matchesObjC(
647 EXPECT_TRUE(matchesObjC(
650 EXPECT_TRUE(matchesObjC(
653 EXPECT_TRUE(matchesObjC(
656 EXPECT_TRUE(matchesObjC(
659 EXPECT_TRUE(matchesObjC(
662 EXPECT_TRUE(matchesObjC(
664 EXPECT_TRUE(matchesObjC(
667 EXPECT_TRUE(matchesObjC(
670 EXPECT_TRUE(matchesObjC(
673 EXPECT_TRUE(matchesObjC(
676 EXPECT_TRUE(matchesObjC(
683 EXPECT_TRUE(matches("auto x = []{};", IsLambda));
684 EXPECT_TRUE(notMatches("struct S { void operator()() const; };", IsLambda));
690 EXPECT_TRUE(matchAndVerifyResultTrue("class X {};",
693 EXPECT_TRUE(matchAndVerifyResultFalse("class X {};",
699 EXPECT_TRUE(matchAndVerifyResultTrue("class A { public: A *a; class B {}; };",
706 EXPECT_TRUE(matchAndVerifyResultTrue("class A { void x() { x(); } };",
720 EXPECT_TRUE(matchAndVerifyResultTrue(
732 EXPECT_TRUE(matchAndVerifyResultTrue(
741 EXPECT_TRUE(
744 EXPECT_TRUE(
747 EXPECT_TRUE(matches("namespace ns { struct A {}; } struct B { ns::A a; };",
749 EXPECT_TRUE(matches("namespace { struct A {}; } struct B { A a; };",
756 EXPECT_TRUE(matches("class Y { }; "
761 EXPECT_TRUE(notMatches("class Y { }; "
767 EXPECT_TRUE(matches("class Y; int operator*(Y &); void f(Y &y) { *y; }",
771 EXPECT_TRUE(matches("class Y { int operator*(); };",
773 EXPECT_TRUE(notMatches("class Y { void myOperator(); };",
776 EXPECT_TRUE(matches("class Y; int operator*(Y &);", AnyOpStar));
777 EXPECT_TRUE(matches("class Y { int operator*(); };", AnyOpStar));
782 EXPECT_TRUE(matchAndVerifyResultTrue(
788 EXPECT_TRUE(matches("class Y { }; "
792 EXPECT_TRUE(
801 EXPECT_TRUE(matches("void f() { int X; }", M));
802 EXPECT_TRUE(notMatches("int X;", M));
803 EXPECT_TRUE(notMatches("void f() { static int X; }", M));
806 EXPECT_TRUE(notMatches("void f() { int X; }", M));
807 EXPECT_TRUE(matches("int X;", M));
808 EXPECT_TRUE(matches("void f() { static int X; }", M));
813 EXPECT_TRUE(matches("void f() { static int X; }", M));
814 EXPECT_TRUE(notMatches("static int X;", M));
815 EXPECT_TRUE(notMatches("void f() { int X; }", M));
816 EXPECT_TRUE(notMatches("int X;", M));
823 EXPECT_TRUE(matches(T, varDecl(hasName("x"), hasAutomaticStorageDuration())));
824 EXPECT_TRUE(
826 EXPECT_TRUE(
829 EXPECT_TRUE(matches(T, varDecl(hasName("y"), hasStaticStorageDuration())));
830 EXPECT_TRUE(matches(T, varDecl(hasName("a"), hasStaticStorageDuration())));
831 EXPECT_TRUE(matches(T, varDecl(hasName("b"), hasStaticStorageDuration())));
832 EXPECT_TRUE(matches(T, varDecl(hasName("c"), hasStaticStorageDuration())));
833 EXPECT_TRUE(notMatches(T, varDecl(hasName("x"), hasStaticStorageDuration())));
839 EXPECT_TRUE(notMatches(T, varDecl(hasName("x"), hasThreadStorageDuration())));
840 EXPECT_TRUE(notMatches(T, varDecl(hasName("y"), hasThreadStorageDuration())));
841 EXPECT_TRUE(notMatches(T, varDecl(hasName("a"), hasThreadStorageDuration())));
845 EXPECT_TRUE(matches(
851 EXPECT_TRUE(matches("void x() { int a = sizeof(a); }", sizeOfExpr(
853 EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }", sizeOfExpr(
855 EXPECT_TRUE(matches(
858 EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }", sizeOfExpr(
863 EXPECT_TRUE(matches("int i = 0;", varDecl(hasType(isInteger()))));
864 EXPECT_TRUE(matches(
871 EXPECT_TRUE(notMatches("int *i;", varDecl(hasType(isInteger()))));
872 EXPECT_TRUE(notMatches("struct T {}; T t; void f(T *) { }; void g() {f(&t);}",
878 EXPECT_TRUE(matches("int i = 0;", varDecl(hasType(isSignedInteger()))));
879 EXPECT_TRUE(notMatches("unsigned i = 0;",
884 EXPECT_TRUE(notMatches("int i = 0;", varDecl(hasType(isUnsignedInteger()))));
885 EXPECT_TRUE(matches("unsigned i = 0;",
890 EXPECT_TRUE(matches("int* i = nullptr;", varDecl(hasType(isAnyPointer()))));
894 EXPECT_TRUE(matchesObjC("@interface Foo @end Foo *f;",
899 EXPECT_TRUE(notMatches("int i = 0;", varDecl(hasType(isAnyPointer()))));
903 EXPECT_TRUE(matches("char i = 0;", varDecl(hasType(isAnyCharacter()))));
907 EXPECT_TRUE(notMatches("int i;", varDecl(hasType(isAnyCharacter()))));
911 EXPECT_TRUE(matches("class Y { void x() { this->y; } int y; };",
913 EXPECT_TRUE(matches("class Y { void x() { y; } int y; };",
915 EXPECT_TRUE(notMatches("class Y { void x() { (*this).y; } int y; };",
917 EXPECT_TRUE(matches("template <class T> class Y { void x() { this->m; } };",
919 EXPECT_TRUE(
925 EXPECT_TRUE(matches("class Y { void x() { this->y; } static int y; };",
927 EXPECT_TRUE(notMatches("class Y { void x() { y; } static int y; };",
929 EXPECT_TRUE(notMatches("class Y { void x() { (*this).y; } static int y; };",
934 EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
936 EXPECT_TRUE(matches("class Y { void x() { x(); } };",
938 EXPECT_TRUE(notMatches("class Y { void x() { Y y; y.x(); } };",
940 EXPECT_TRUE(
943 EXPECT_TRUE(matches("class Y { template <class T> void x() { x<T>(); } };",
945 EXPECT_TRUE(
951 EXPECT_TRUE(matches("struct S { explicit operator int(); };",
953 EXPECT_TRUE(notMatches("struct S { operator int(); };",
955 EXPECT_TRUE(matchesConditionally(
958 EXPECT_TRUE(matchesConditionally(
961 EXPECT_TRUE(matchesConditionally(
969 EXPECT_TRUE(matches("void x(int) { x(0); }", Call1Arg));
970 EXPECT_TRUE(matches("class X { void x(int) { x(0); } };", Call1Arg));
971 EXPECT_TRUE(notMatches("void x(int, int) { x(0, 0); }", Call1Arg));
976 EXPECT_TRUE(matches("void f(int i) {}", Function1Arg));
977 EXPECT_TRUE(matches("class X { void f(int i) {} };", Function1Arg));
978 EXPECT_TRUE(notMatches("void f() {}", Function1Arg));
979 EXPECT_TRUE(notMatches("void f(int i, int j, int k) {}", Function1Arg));
980 EXPECT_TRUE(matches("void f(int i, ...) {};", Function1Arg));
986 EXPECT_TRUE(matches("class X {}; void y(X y) { X &x = y; }",
988 EXPECT_TRUE(
992 EXPECT_TRUE(
994 EXPECT_TRUE(
996 EXPECT_TRUE(
1001 EXPECT_TRUE(notMatches("typedef const int const_int; const_int i = 1;",
1003 EXPECT_TRUE(matches("int *const j = nullptr;",
1005 EXPECT_TRUE(matches("int *volatile k;",
1007 EXPECT_TRUE(notMatches("int m;",
1012 EXPECT_TRUE(matches("extern \"C\" void f() {}", functionDecl(isExternC())));
1013 EXPECT_TRUE(matches("extern \"C\" { void f() {} }",
1015 EXPECT_TRUE(notMatches("void f() {}", functionDecl(isExternC())));
1019 EXPECT_TRUE(matches("extern \"C\" int i;", varDecl(isExternC())));
1020 EXPECT_TRUE(matches("extern \"C\" { int i; }", varDecl(isExternC())));
1021 EXPECT_TRUE(notMatches("int i;", varDecl(isExternC())));
1025 EXPECT_TRUE(
1027 EXPECT_TRUE(matches("static int i = 1;", varDecl(isStaticStorageClass())));
1028 EXPECT_TRUE(notMatches("int i = 1;", varDecl(isStaticStorageClass())));
1029 EXPECT_TRUE(notMatches("extern int i;", varDecl(isStaticStorageClass())));
1030 EXPECT_TRUE(notMatches("void f() {}", functionDecl(isStaticStorageClass())));
1034 EXPECT_TRUE(notMatches("class A { ~A(); };",
1036 EXPECT_TRUE(matches("class B { ~B() = default; };",
1041 EXPECT_TRUE(
1043 EXPECT_TRUE(matches("void Func() = delete;",
1048 EXPECT_TRUE(notMatches("void f();", functionDecl(isNoThrow())));
1049 EXPECT_TRUE(notMatches("void f() throw(int);", functionDecl(isNoThrow())));
1050 EXPECT_TRUE(
1052 EXPECT_TRUE(matches("void f() throw();", functionDecl(isNoThrow())));
1053 EXPECT_TRUE(matches("void f() noexcept;", functionDecl(isNoThrow())));
1055 EXPECT_TRUE(notMatches("void f();", functionProtoType(isNoThrow())));
1056 EXPECT_TRUE(notMatches("void f() throw(int);", functionProtoType(isNoThrow())));
1057 EXPECT_TRUE(
1059 EXPECT_TRUE(matches("void f() throw();", functionProtoType(isNoThrow())));
1060 EXPECT_TRUE(matches("void f() noexcept;", functionProtoType(isNoThrow())));
1064 EXPECT_TRUE(matches("constexpr int foo = 42;",
1066 EXPECT_TRUE(matches("constexpr int bar();",
1068 EXPECT_TRUE(matches("void baz() { if constexpr(1 > 0) {} }",
1070 EXPECT_TRUE(notMatches("void baz() { if (1 > 0) {} }", ifStmt(isConstexpr()),
1075 EXPECT_TRUE(
1078 EXPECT_TRUE(
1082 EXPECT_TRUE(matches("template<typename T> struct C {}; C<int> c;",
1084 EXPECT_TRUE(
1090 EXPECT_TRUE(matches("template<int T> struct C {}; C<42> c;",
1093 EXPECT_TRUE(notMatches("template<typename T> struct C {}; C<int> c;",
1099 EXPECT_TRUE(matches("template<int T> struct C {}; C<42> c;",
1102 EXPECT_TRUE(matches("template<int T> struct C {}; C<-42> c;",
1105 EXPECT_TRUE(matches("template<int T> struct C {}; C<-0042> c;",
1108 EXPECT_TRUE(notMatches("template<int T> struct C {}; C<42> c;",
1114 EXPECT_TRUE(matches("class C { public: int i; };", accessSpecDecl()));
1115 EXPECT_TRUE(
1117 EXPECT_TRUE(
1119 EXPECT_TRUE(
1122 EXPECT_TRUE(notMatches("class C { int i; };", accessSpecDecl()));
1126 EXPECT_TRUE(matches("class X final {};", cxxRecordDecl(isFinal())));
1127 EXPECT_TRUE(matches("class X { virtual void f() final; };",
1129 EXPECT_TRUE(notMatches("class X {};", cxxRecordDecl(isFinal())));
1130 EXPECT_TRUE(
1135 EXPECT_TRUE(matches("class X { virtual int f(); };",
1137 EXPECT_TRUE(notMatches("class X { int f(); };", cxxMethodDecl(isVirtual())));
1141 EXPECT_TRUE(matches("class A { virtual int f(); };"
1144 EXPECT_TRUE(
1151 EXPECT_TRUE(matches("class X { virtual int f() = 0; };",
1153 EXPECT_TRUE(notMatches("class X { int f(); };", cxxMethodDecl(isPure())));
1157 EXPECT_TRUE(matches("class X { X &operator=(X); };",
1159 EXPECT_TRUE(matches("class X { X &operator=(X &); };",
1161 EXPECT_TRUE(matches("class X { X &operator=(const X &); };",
1163 EXPECT_TRUE(matches("class X { X &operator=(volatile X &); };",
1165 EXPECT_TRUE(matches("class X { X &operator=(const volatile X &); };",
1167 EXPECT_TRUE(notMatches("class X { X &operator=(X &&); };",
1172 EXPECT_TRUE(notMatches("class X { X &operator=(X); };",
1174 EXPECT_TRUE(matches("class X { X &operator=(X &&); };",
1176 EXPECT_TRUE(matches("class X { X &operator=(const X &&); };",
1178 EXPECT_TRUE(matches("class X { X &operator=(volatile X &&); };",
1180 EXPECT_TRUE(matches("class X { X &operator=(const volatile X &&); };",
1182 EXPECT_TRUE(notMatches("class X { X &operator=(X &); };",
1187 EXPECT_TRUE(
1189 EXPECT_TRUE(
1194 EXPECT_TRUE(matches("class X { virtual int f(); }; "
1197 EXPECT_TRUE(notMatches("class X { virtual int f(); }; "
1200 EXPECT_TRUE(notMatches("class X { int f(); }; "
1203 EXPECT_TRUE(notMatches("class X { int f(); int f(int); }; ",
1205 EXPECT_TRUE(
1214 EXPECT_TRUE(
1217 EXPECT_TRUE(
1220 EXPECT_TRUE(
1223 EXPECT_TRUE(
1229 EXPECT_TRUE(
1237 EXPECT_TRUE(
1240 EXPECT_TRUE(
1243 EXPECT_TRUE(
1246 EXPECT_TRUE(
1255 EXPECT_TRUE(
1266 EXPECT_TRUE(notMatches("class Foo { };",
1269 EXPECT_TRUE(matches("class Foo { }; Foo* f = new Foo();",
1271 EXPECT_TRUE(matches("class Foo { Foo(){} };",
1274 EXPECT_TRUE(matches("struct A { int x; } a = {0}, b = a; void f() { a = b; }",
1279 EXPECT_TRUE(matches("struct S { explicit S(int); };",
1281 EXPECT_TRUE(notMatches("struct S { S(int); };",
1283 EXPECT_TRUE(matchesConditionally(
1286 EXPECT_TRUE(matchesConditionally("struct S { explicit(true) S(int);};",
1289 EXPECT_TRUE(matchesConditionally("struct S { explicit(false) S(int);};",
1295 EXPECT_TRUE(matchesConditionally("template<typename T> struct S { S(int);};"
1299 EXPECT_TRUE(matchesConditionally("template<typename T> struct S { S(int);};"
1303 EXPECT_TRUE(matchesConditionally("template<typename T> struct S { S(int);};"
1307 EXPECT_TRUE(matchesConditionally("template<typename T> struct S { S(int);};"
1311 EXPECT_TRUE(matchesConditionally(
1318 EXPECT_TRUE(matches(
1321 EXPECT_TRUE(notMatches(
1324 EXPECT_TRUE(notMatches(
1328 EXPECT_TRUE(notMatches(
1331 EXPECT_TRUE(matches(
1334 EXPECT_TRUE(notMatches(
1338 EXPECT_TRUE(notMatches(
1341 EXPECT_TRUE(notMatches(
1344 EXPECT_TRUE(matches(
1350 EXPECT_TRUE(notMatches("struct S { int X = 0; };",
1352 EXPECT_TRUE(notMatches("struct S { S() = default; };",
1354 EXPECT_TRUE(notMatches("struct S { S() = delete; };",
1356 EXPECT_TRUE(
1358 EXPECT_TRUE(matches("struct S { S(); }; S::S(){}",
1363 EXPECT_TRUE(notMatches("struct S { S(); S(int); int X; };",
1365 EXPECT_TRUE(notMatches("struct S { S(){} S(int X) : X(X) {} int X; };",
1367 EXPECT_TRUE(matches(
1370 EXPECT_TRUE(matches(
1377 EXPECT_TRUE(matches("const char *s = \"abcd\";", Literal));
1379 EXPECT_TRUE(matches("const wchar_t *s = L\"abcd\";", Literal));
1381 EXPECT_TRUE(matches("const char *s = \"\x05\x06\x07\x08\";", Literal));
1383 EXPECT_TRUE(notMatches("const char *s = \"ab\";", Literal));
1387 EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
1389 EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
1391 EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
1393 EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
1395 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1397 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1399 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1401 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1403 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1405 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1407 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1409 EXPECT_TRUE(notMatches("namespace a { namespace b { class AC; } }",
1414 EXPECT_TRUE(
1417 EXPECT_TRUE(
1420 EXPECT_TRUE(
1423 EXPECT_TRUE(
1426 EXPECT_TRUE(
1429 EXPECT_TRUE(
1432 EXPECT_TRUE(
1435 EXPECT_TRUE(
1438 EXPECT_TRUE(
1441 EXPECT_TRUE(notMatches("class A { class B { class C; }; };",
1443 EXPECT_TRUE(
1450 EXPECT_TRUE(matches(code, recordDecl(hasName("a::b::C"))));
1451 EXPECT_TRUE(matches(code, recordDecl(hasName("a::C"))));
1452 EXPECT_TRUE(matches(code, recordDecl(hasName("::a::b::C"))));
1453 EXPECT_TRUE(matches(code, recordDecl(hasName("::a::C"))));
1458 EXPECT_TRUE(
1460 EXPECT_TRUE(matches(code, recordDecl(hasName("a::C"))));
1461 EXPECT_TRUE(
1463 EXPECT_TRUE(matches(code, recordDecl(hasName("::a::C"))));
1467 EXPECT_TRUE(matches("class A { class { class C; } x; };",
1469 EXPECT_TRUE(matches("class A { class { class C; } x; };",
1473 EXPECT_TRUE(matches("class A { struct { class C; } x; };",
1475 EXPECT_TRUE(matches("class A { struct { class C; } x; };",
1484 EXPECT_TRUE(matches(code, varDecl(hasName("i"))));
1487 EXPECT_TRUE(matches(code, fieldDecl(hasName("m"))));
1488 EXPECT_TRUE(matches(code, fieldDecl(hasName("S::m"))));
1489 EXPECT_TRUE(matches(code, fieldDecl(hasName("F(int)::S::m"))));
1490 EXPECT_TRUE(matches(code, fieldDecl(hasName("a::F(int)::S::m"))));
1491 EXPECT_TRUE(matches(code, fieldDecl(hasName("::a::F(int)::S::m"))));
1497 EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX", "a::b::C"))));
1498 EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("a::b::C", "XX"))));
1499 EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX::C", "a::b::C"))));
1500 EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX", "C"))));
1502 EXPECT_TRUE(notMatches(Code, recordDecl(hasAnyName("::C", "::b::C"))));
1503 EXPECT_TRUE(
1507 EXPECT_TRUE(matches(Code, recordDecl(hasAnyName(Names))));
1513 EXPECT_TRUE(matches("class A {};", DefinitionOfClassA));
1514 EXPECT_TRUE(notMatches("class A;", DefinitionOfClassA));
1518 EXPECT_TRUE(matches("int a;", DefinitionOfVariableA));
1519 EXPECT_TRUE(notMatches("extern int a;", DefinitionOfVariableA));
1523 EXPECT_TRUE(matches("class A { void a() {} };", DefinitionOfMethodA));
1524 EXPECT_TRUE(notMatches("class A { void a(); };", DefinitionOfMethodA));
1528 EXPECT_TRUE(matchesObjC("@interface A @end "
1531 EXPECT_TRUE(notMatchesObjC("@interface A; - (void)a; @end",
1542 EXPECT_TRUE(matches(
1564 EXPECT_TRUE(matchesObjC(ObjCString, objcIvarRefExpr()));
1565 EXPECT_TRUE(matchesObjC(ObjCString, objcIvarRefExpr(
1572 EXPECT_TRUE(matchesObjC("void f() { ^{}(); }", blockExpr()));
1576 EXPECT_TRUE(matches("void f() { }",
1578 EXPECT_TRUE(notMatches("void f() {}",
1583 EXPECT_TRUE(matches("void f() { 1; }",
1585 EXPECT_TRUE(notMatches("void f() { 1; }",
1587 EXPECT_TRUE(notMatches("void f() { 1; }",
1592 EXPECT_TRUE(matches("void f() { 1; 2; 3; }",
1597 EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
1599 EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
1601 EXPECT_TRUE(notMatches("void f() { { 1; } { 1; 2; 3; 4; } }",
1603 EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
1608 EXPECT_TRUE(matches("struct { int first; } s; int i(s.first);",
1615 EXPECT_TRUE(notMatches("struct { int i; } first; int i(first.i);",
1620 EXPECT_TRUE(matches("void f() {"
1628 EXPECT_TRUE(matches(
1631 EXPECT_TRUE(notMatches(
1637 EXPECT_TRUE(matches("class C { int a : 2; int b; };",
1639 EXPECT_TRUE(notMatches("class C { int a : 2; int b; };",
1641 EXPECT_TRUE(matches("class C { int a : 2; int b : 4; };",
1646 EXPECT_TRUE(
1650 EXPECT_TRUE(
1656 EXPECT_TRUE(matches(
1658 EXPECT_TRUE(notMatches(
1660 EXPECT_TRUE(notMatches(
1663 EXPECT_TRUE(notMatches(
1665 EXPECT_TRUE(notMatches(
1667 EXPECT_TRUE(matches(
1670 EXPECT_TRUE(notMatches(
1672 EXPECT_TRUE(matches("class A { protected: int i; };",
1674 EXPECT_TRUE(notMatches(
1678 EXPECT_TRUE(notMatches("int i;", varDecl(isPublic(), hasName("i"))));
1679 EXPECT_TRUE(notMatches("int i;", varDecl(isProtected(), hasName("i"))));
1680 EXPECT_TRUE(notMatches("int i;", varDecl(isPrivate(), hasName("i"))));
1684 EXPECT_TRUE(notMatches("void f();", functionDecl(hasDynamicExceptionSpec())));
1685 EXPECT_TRUE(notMatches("void g() noexcept;",
1687 EXPECT_TRUE(notMatches("void h() noexcept(true);",
1689 EXPECT_TRUE(notMatches("void i() noexcept(false);",
1691 EXPECT_TRUE(
1693 EXPECT_TRUE(
1695 EXPECT_TRUE(
1698 EXPECT_TRUE(notMatches("void f();", functionProtoType(hasDynamicExceptionSpec())));
1699 EXPECT_TRUE(notMatches("void g() noexcept;",
1701 EXPECT_TRUE(notMatches("void h() noexcept(true);",
1703 EXPECT_TRUE(notMatches("void i() noexcept(false);",
1705 EXPECT_TRUE(
1707 EXPECT_TRUE(
1709 EXPECT_TRUE(
1714 EXPECT_TRUE(notMatches(
1720 EXPECT_TRUE(matches(
1723 EXPECT_TRUE(matches(
1727 EXPECT_TRUE(matches("template <class T> struct X { void f() { T t; t.m; } };",
1730 EXPECT_TRUE(
1737 EXPECT_TRUE(matches(
1740 EXPECT_TRUE(matches("struct X { template <class T> void f(); };"
1744 EXPECT_TRUE(matches("template <class T> void f(T t) { t.g(); }",
1751 EXPECT_TRUE(matches(
1755 EXPECT_TRUE(matches(
1762 EXPECT_TRUE(notMatches("class X { void m(); };", fieldDecl(hasName("m"))));
1763 EXPECT_TRUE(notMatches("class X { class m {}; };", fieldDecl(hasName("m"))));
1764 EXPECT_TRUE(notMatches("class X { enum { m }; };", fieldDecl(hasName("m"))));
1765 EXPECT_TRUE(notMatches("class X { enum m {}; };", fieldDecl(hasName("m"))));
1769 EXPECT_TRUE(matches("class X { int m; };", fieldDecl(hasName("m"))));
1773 EXPECT_TRUE(matches("volatile int i = 42;",
1775 EXPECT_TRUE(notMatches("volatile int *i;",
1777 EXPECT_TRUE(matches("typedef volatile int v_int; v_int i = 42;",
1782 EXPECT_TRUE(matches("const int i = 42;",
1787 EXPECT_TRUE(matches("int i = 42; int* const p(&i);",
1792 EXPECT_TRUE(matches("typedef const int const_int; const_int i = 42;",
1794 EXPECT_TRUE(matches("typedef int* int_ptr; const int_ptr p(0);",
1799 EXPECT_TRUE(notMatches("typedef int nonconst_int; nonconst_int i = 42;",
1801 EXPECT_TRUE(notMatches("int const* p;",
1806 EXPECT_TRUE(matches("void f() {int i,j;}",
1808 EXPECT_TRUE(notMatches("void f() {int i,j; int k;}",
1810 EXPECT_TRUE(notMatches("void f() {int i,j, k, l;}",
1816 EXPECT_TRUE(matchAndVerifyResultTrue(
1824 EXPECT_TRUE(matchAndVerifyResultTrue(
1829 EXPECT_TRUE(matchAndVerifyResultTrue(
1834 EXPECT_TRUE(notMatches(
1844 EXPECT_TRUE(matches(
1848 EXPECT_TRUE(matches(
1855 EXPECT_TRUE(matches(
1862 EXPECT_TRUE(matches(
1870 EXPECT_TRUE(
1879 EXPECT_TRUE(matches(
1887 EXPECT_TRUE(matches(
1900 EXPECT_TRUE(matches(
1910 EXPECT_TRUE(notMatches(
1917 EXPECT_TRUE(notMatches(
1923 EXPECT_TRUE(
1929 EXPECT_TRUE(notMatches("template<typename T> class A { T i; };",
1934 EXPECT_TRUE(matches("template<typename T> struct A { A() { T i; } };"
1940 EXPECT_TRUE(notMatches("template<typename T> struct A { void x() { T i; } };",
1945 EXPECT_TRUE(
1951 EXPECT_TRUE(notMatches("template<typename T> void A(T t) { T i; }",
1956 EXPECT_TRUE(
1962 EXPECT_TRUE(notMatches("template<typename T> void A(T t) { T i; }",
1970 EXPECT_TRUE(notMatches(
1973 EXPECT_TRUE(matches(
1979 EXPECT_TRUE(matches(
1985 EXPECT_TRUE(matches("template<int T> int f() { return T; }",
1990 EXPECT_TRUE(matches("template<typename T> T f() { return T(); }",
1995 EXPECT_TRUE(matches("template<typename T> T f() { return T(); }",
2000 EXPECT_TRUE(notMatches("template<int T> int f() { return T; }",
2005 EXPECT_TRUE(matches("template<int T> int f() { return T; }",
2010 EXPECT_TRUE(matches("template<typename T> T f() { return T(); }",
2015 EXPECT_TRUE(matches(
2022 EXPECT_TRUE(notMatches(
2025 EXPECT_TRUE(notMatches(
2032 EXPECT_TRUE(notMatches(
2036 EXPECT_TRUE(notMatches(
2044 EXPECT_TRUE(notMatches(
2047 EXPECT_TRUE(notMatches(
2054 EXPECT_TRUE(matches(
2058 EXPECT_TRUE(matches(
2065 EXPECT_TRUE(notMatches("void func();", functionDecl(isNoReturn())));
2066 EXPECT_TRUE(notMatches("void func() {}", functionDecl(isNoReturn())));
2068 EXPECT_TRUE(notMatchesC("void func();", functionDecl(isNoReturn())));
2069 EXPECT_TRUE(notMatchesC("void func() {}", functionDecl(isNoReturn())));
2071 EXPECT_TRUE(
2073 EXPECT_TRUE(
2076 EXPECT_TRUE(notMatches("struct S { static void func(); };",
2078 EXPECT_TRUE(notMatches("struct S { static void func() {} };",
2081 EXPECT_TRUE(notMatches("struct S { S(); };", functionDecl(isNoReturn())));
2082 EXPECT_TRUE(notMatches("struct S { S() {} };", functionDecl(isNoReturn())));
2086 EXPECT_TRUE(matches("[[noreturn]] void func();", functionDecl(isNoReturn())));
2087 EXPECT_TRUE(
2090 EXPECT_TRUE(matches("struct S { [[noreturn]] void func(); };",
2092 EXPECT_TRUE(matches("struct S { [[noreturn]] void func() {} };",
2095 EXPECT_TRUE(matches("struct S { [[noreturn]] static void func(); };",
2097 EXPECT_TRUE(matches("struct S { [[noreturn]] static void func() {} };",
2100 EXPECT_TRUE(
2102 EXPECT_TRUE(matches("struct S { [[noreturn]] S() {} };",
2107 EXPECT_TRUE(matches("__attribute__((noreturn)) void func();",
2109 EXPECT_TRUE(matches("__attribute__((noreturn)) void func() {}",
2112 EXPECT_TRUE(matches("struct S { __attribute__((noreturn)) void func(); };",
2114 EXPECT_TRUE(matches("struct S { __attribute__((noreturn)) void func() {} };",
2117 EXPECT_TRUE(
2120 EXPECT_TRUE(
2124 EXPECT_TRUE(matches("struct S { __attribute__((noreturn)) S(); };",
2126 EXPECT_TRUE(matches("struct S { __attribute__((noreturn)) S() {} };",
2131 EXPECT_TRUE(matchesC("__attribute__((noreturn)) void func();",
2133 EXPECT_TRUE(matchesC("__attribute__((noreturn)) void func() {}",
2136 EXPECT_TRUE(matchesC("_Noreturn void func();",
2138 EXPECT_TRUE(matchesC("_Noreturn void func() {}",
2143 EXPECT_TRUE(matches("struct S { bool func(); };",
2145 EXPECT_TRUE(notMatches("struct S { void func(); };",
2150 EXPECT_TRUE(matches("struct S { void func(); };",
2155 EXPECT_TRUE(matches("struct S { float func(); };",
2157 EXPECT_TRUE(notMatches("struct S { int func(); };",
2159 EXPECT_TRUE(matches("struct S { long double func(); };",
2164 EXPECT_TRUE(matches("int a[] = {2,3};", arrayType()));
2165 EXPECT_TRUE(matches("int a[42];", arrayType()));
2166 EXPECT_TRUE(matches("void f(int b) { int a[b]; }", arrayType()));
2168 EXPECT_TRUE(notMatches("struct A {}; A a[7];",
2171 EXPECT_TRUE(matches(
2174 EXPECT_TRUE(matches(
2177 EXPECT_TRUE(matches(
2181 EXPECT_TRUE(notMatches(
2184 EXPECT_TRUE(notMatches(
2187 EXPECT_TRUE(notMatches(
2192 EXPECT_TRUE(matches("int a[2];",
2194 EXPECT_TRUE(matches("const int a = 0;", qualType(isInteger())));
2198 EXPECT_TRUE(matches("void f(int i[]);", valueDecl(hasType(decayedType(hasDecayedType(pointerType()))))));
2199 EXPECT_TRUE(notMatches("int i[7];", decayedType()));
2203 EXPECT_TRUE(matches("_Complex float f;", complexType()));
2204 EXPECT_TRUE(matches(
2207 EXPECT_TRUE(notMatches(
2213 EXPECT_TRUE(notMatches("namespace N {}", namespaceDecl(isAnonymous())));
2214 EXPECT_TRUE(matches("namespace {}", namespaceDecl(isAnonymous())));
2218 EXPECT_TRUE(notMatches("class vector {};"
2229 EXPECT_TRUE(matches("namespace std {"
2233 EXPECT_TRUE(matches("namespace std {"
2239 EXPECT_TRUE(notMatches("namespace std {"
2251 EXPECT_TRUE(
2269 EXPECT_TRUE(matches(
2273 EXPECT_TRUE(notMatches("int i = 1.f;",
2280 EXPECT_TRUE(notMatches(
2287 EXPECT_TRUE(
2292 EXPECT_TRUE(notMatches(
2298 EXPECT_TRUE(matches(
2303 EXPECT_TRUE(notMatches("class X { class Y {}; };",
2309 EXPECT_TRUE(matches(
2315 EXPECT_TRUE(notMatches(
2323 EXPECT_TRUE(matchAndVerifyResultTrue(
2344 EXPECT_TRUE(matchAndVerifyResultTrue(
2357 EXPECT_TRUE(matchAndVerifyResultTrue(
2389 EXPECT_TRUE(matches("#define NULL ((void *)0)\n"
2391 EXPECT_TRUE(matches("void *v2 = nullptr;", expr(nullPointerConstant())));
2392 EXPECT_TRUE(matches("void *v3 = __null;", expr(nullPointerConstant())));
2393 EXPECT_TRUE(matches("char *cp = (char *)0;", expr(nullPointerConstant())));
2394 EXPECT_TRUE(matches("int *ip = 0;", expr(nullPointerConstant())));
2395 EXPECT_TRUE(matches("int i = 0;", expr(nullPointerConstant())));
2399 EXPECT_TRUE(matches("int a = 0;", namedDecl(hasExternalFormalLinkage())));
2400 EXPECT_TRUE(
2402 EXPECT_TRUE(notMatches("static void f(void) { int a = 0; }",
2404 EXPECT_TRUE(matches("void f(void) { int a = 0; }",
2410 EXPECT_TRUE(matches("namespace { int a = 0; }",
2415 EXPECT_TRUE(matches("void x(int val = 0) {}",
2417 EXPECT_TRUE(notMatches("void x(int val) {}",
2422 EXPECT_TRUE(matches("struct MyClass {}; MyClass *p1 = new MyClass[10];",
2427 EXPECT_TRUE(matches("struct MyClass {}; MyClass *p1 = new MyClass[10];",
2432 EXPECT_TRUE(matches("struct x {};",
2434 EXPECT_TRUE(notMatches("struct x;",
2439 EXPECT_TRUE(matches("class x {};",
2441 EXPECT_TRUE(notMatches("class x;",
2446 EXPECT_TRUE(matches("union x {};",
2448 EXPECT_TRUE(notMatches("union x;",
2453 EXPECT_TRUE(matches("enum class X {};", enumDecl(isScoped())));
2454 EXPECT_TRUE(notMatches("enum X {};", enumDecl(isScoped())));
2458 EXPECT_TRUE(matches("auto Y() -> int { return 0; }",
2460 EXPECT_TRUE(matches("auto X() -> int;", functionDecl(hasTrailingReturn())));
2461 EXPECT_TRUE(notMatches("int X() { return 0; }",
2463 EXPECT_TRUE(notMatches("int X();", functionDecl(hasTrailingReturn())));
2464 EXPECT_TRUE(notMatchesC("void X();", functionDecl(hasTrailingReturn())));
2468 EXPECT_TRUE(matches(
2471 EXPECT_TRUE(notMatches(
2481 EXPECT_TRUE(matches("void x() { int a; a += 1; }", BinAsgmtOperator));
2482 EXPECT_TRUE(matches("void x() { int a; a = 2; }", BinAsgmtOperator));
2483 EXPECT_TRUE(matches("void x() { int a; a &= 3; }", BinAsgmtOperator));
2484 EXPECT_TRUE(matches("struct S { S& operator=(const S&); };"
2487 EXPECT_TRUE(
2492 EXPECT_TRUE(
2504 EXPECT_TRUE(
2507 EXPECT_TRUE(
2519 EXPECT_TRUE(notMatchesWithOpenMP(Source0, Matcher));
2525 EXPECT_TRUE(matchesWithOpenMP(Source1, Matcher));
2534 EXPECT_TRUE(
2542 EXPECT_TRUE(
2544 EXPECT_TRUE(
2554 EXPECT_TRUE(matchesWithOpenMP(
2562 EXPECT_TRUE(notMatchesWithOpenMP(
2564 EXPECT_TRUE(matchesWithOpenMP(
2572 EXPECT_TRUE(notMatchesWithOpenMP(
2583 EXPECT_TRUE(notMatchesWithOpenMP(Source0, Matcher));
2590 EXPECT_TRUE(notMatchesWithOpenMP(Source1, Matcher));
2597 EXPECT_TRUE(matchesWithOpenMP(Source2, Matcher));
2604 EXPECT_TRUE(matchesWithOpenMP(Source3, Matcher));
2611 EXPECT_TRUE(matchesWithOpenMP(Source4, Matcher));
2622 EXPECT_TRUE(notMatchesWithOpenMP(Source0, Matcher));
2629 EXPECT_TRUE(notMatchesWithOpenMP(Source1, Matcher));
2636 EXPECT_TRUE(matchesWithOpenMP(Source2, Matcher));
2643 EXPECT_TRUE(notMatchesWithOpenMP(Source3, Matcher));
2650 EXPECT_TRUE(notMatchesWithOpenMP(Source4, Matcher));
2661 EXPECT_TRUE(notMatchesWithOpenMP(Source0, Matcher));
2668 EXPECT_TRUE(notMatchesWithOpenMP(Source1, Matcher));
2675 EXPECT_TRUE(matchesWithOpenMP(Source2, Matcher));
2682 EXPECT_TRUE(notMatchesWithOpenMP(Source3, Matcher));
2689 EXPECT_TRUE(notMatchesWithOpenMP(Source4, Matcher));
2700 EXPECT_TRUE(notMatchesWithOpenMP(Source0, Matcher));
2707 EXPECT_TRUE(matchesWithOpenMP(Source1, Matcher));
2714 EXPECT_TRUE(matchesWithOpenMP(Source2, Matcher));
2721 EXPECT_TRUE(matchesWithOpenMP(Source3, Matcher));
2728 EXPECT_TRUE(matchesWithOpenMP(Source4, Matcher));
2734 EXPECT_TRUE(notMatchesWithOpenMP(Source5, Matcher));
2741 EXPECT_TRUE(matchesWithOpenMP(Source6, Matcher));
tools/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp 23 EXPECT_TRUE(Finder.addDynamicMatcher(decl(), nullptr));
24 EXPECT_TRUE(Finder.addDynamicMatcher(callExpr(), nullptr));
25 EXPECT_TRUE(Finder.addDynamicMatcher(constantArrayType(hasSize(42)),
34 EXPECT_TRUE(notMatches("", decl(usingDecl())));
35 EXPECT_TRUE(matches("namespace x { class X {}; } using x::X;",
41 EXPECT_TRUE(matches("typedef int X;", NamedX));
42 EXPECT_TRUE(matches("int X;", NamedX));
43 EXPECT_TRUE(matches("class foo { virtual void X(); };", NamedX));
44 EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", NamedX));
45 EXPECT_TRUE(matches("void foo() { int X; }", NamedX));
46 EXPECT_TRUE(matches("namespace X { }", NamedX));
47 EXPECT_TRUE(matches("enum X { A, B, C };", NamedX));
49 EXPECT_TRUE(notMatches("#define X 1", NamedX));
54 EXPECT_TRUE(matches("typedef int Xa;", NamedX));
55 EXPECT_TRUE(matches("int Xb;", NamedX));
56 EXPECT_TRUE(matches("class foo { virtual void Xc(); };", NamedX));
57 EXPECT_TRUE(matches("void foo() try { } catch(int Xdef) { }", NamedX));
58 EXPECT_TRUE(matches("void foo() { int Xgh; }", NamedX));
59 EXPECT_TRUE(matches("namespace Xij { }", NamedX));
60 EXPECT_TRUE(matches("enum X { A, B, C };", NamedX));
62 EXPECT_TRUE(notMatches("#define Xkl 1", NamedX));
65 EXPECT_TRUE(matches("int no_foo;", StartsWithNo));
66 EXPECT_TRUE(matches("class foo { virtual void nobody(); };", StartsWithNo));
69 EXPECT_TRUE(matches("int abc;", Abc));
70 EXPECT_TRUE(matches("int aFOObBARc;", Abc));
71 EXPECT_TRUE(notMatches("int cab;", Abc));
72 EXPECT_TRUE(matches("int cabc;", Abc));
75 EXPECT_TRUE(matches("int k;", StartsWithK));
76 EXPECT_TRUE(matches("int kAbc;", StartsWithK));
77 EXPECT_TRUE(matches("namespace x { int kTest; }", StartsWithK));
78 EXPECT_TRUE(matches("class C { int k; };", StartsWithK));
79 EXPECT_TRUE(notMatches("class C { int ckc; };", StartsWithK));
91 EXPECT_TRUE(matches("class X;", ClassX));
92 EXPECT_TRUE(matches("class X {};", ClassX));
93 EXPECT_TRUE(matches("template<class T> class X {};", ClassX));
94 EXPECT_TRUE(notMatches("", ClassX));
102 EXPECT_TRUE(matches(
106 EXPECT_TRUE(matches(
113 EXPECT_TRUE(matches("extern \"C\" { void foo() {}; }", linkageSpecDecl()));
114 EXPECT_TRUE(notMatches("void foo() {};", linkageSpecDecl()));
119 EXPECT_TRUE(notMatches("class X;", ClassX));
120 EXPECT_TRUE(notMatches("class X {};", ClassX));
125 EXPECT_TRUE(matches("template<typename T> class X {};", ClassX));
126 EXPECT_TRUE(matches("class Z { template<class T> class X {}; };", ClassX));
130 EXPECT_TRUE(notMatches("template<typename T> class X { };"
137 EXPECT_TRUE(notMatches("template<typename T, typename U> class X { };"
144 EXPECT_TRUE(matchesWithCuda("__global__ void f() { }"
147 EXPECT_TRUE(matchesWithCuda("__attribute__((device)) void f() {}",
149 EXPECT_TRUE(notMatchesWithCuda("void f() {}",
156 EXPECT_TRUE(matches("enum EnumType { EnumValue };",
158 EXPECT_TRUE(matches("void FunctionDecl();",
163 EXPECT_TRUE(matches("class Y { friend class X; };",
165 EXPECT_TRUE(matches("class Y { friend class X; };",
168 EXPECT_TRUE(matches("class Y { friend void f(); };",
173 EXPECT_TRUE(notMatches("class X {};", enumDecl(hasName("X"))));
177 EXPECT_TRUE(matches("enum X {};", enumDecl(hasName("X"))));
182 EXPECT_TRUE(matches("enum X{ A };", Matcher));
183 EXPECT_TRUE(notMatches("enum X{ B };", Matcher));
184 EXPECT_TRUE(notMatches("enum X {};", Matcher));
190 EXPECT_TRUE(matchesConditionally("template<typename T>"
221 EXPECT_TRUE(matches(MkStr("NS::X x; f(x);"), ADLMatch));
222 EXPECT_TRUE(notMatches(MkStr("NS::X x; NS::f(x);"), ADLMatch));
223 EXPECT_TRUE(notMatches(MkStr("MyX x; f(x);"), ADLMatch));
224 EXPECT_TRUE(notMatches(MkStr("NS::X x; using NS::f; f(x);"), ADLMatch));
227 EXPECT_TRUE(matches(MkStr("NS::X x; x + x;"), ADLMatch));
228 EXPECT_TRUE(matches(MkStr("NS::X x; x + x;"), ADLMatchOper));
229 EXPECT_TRUE(notMatches(MkStr("MyX x; x + x;"), ADLMatch));
230 EXPECT_TRUE(notMatches(MkStr("MyX x; x + x;"), ADLMatchOper));
231 EXPECT_TRUE(matches(MkStr("NS::X x; operator+(x, x);"), ADLMatch));
232 EXPECT_TRUE(notMatches(MkStr("NS::X x; NS::operator+(x, x);"), ADLMatch));
241 EXPECT_TRUE(matches("class Y { void x() { x(); } };", MethodX));
242 EXPECT_TRUE(notMatches("class Y { void x() {} };", MethodX));
247 EXPECT_TRUE(
250 EXPECT_TRUE(
253 EXPECT_TRUE(
256 EXPECT_TRUE(
259 EXPECT_TRUE(
266 EXPECT_TRUE(
269 EXPECT_TRUE(
272 EXPECT_TRUE(
275 EXPECT_TRUE(
278 EXPECT_TRUE(
283 EXPECT_TRUE(matches("auto f = [] (int i) { return i; };",
288 EXPECT_TRUE(matches("int as[] = { 1, 2, 3 };"
291 EXPECT_TRUE(notMatches("void f() { for (int i; i<5; ++i); }",
300 EXPECT_TRUE(matches("template<int N>\n"
307 EXPECT_TRUE(matches("template <int N> void f();",
309 EXPECT_TRUE(
314 EXPECT_TRUE(matches("template <typename T> void f();",
316 EXPECT_TRUE(
321 EXPECT_TRUE(matches("constexpr char operator \"\" _inc (const char i) {"
329 EXPECT_TRUE(matches("void f() { while(true) { break; } }", breakStmt()));
330 EXPECT_TRUE(matches("void f() { while(true) { continue; } }",
332 EXPECT_TRUE(matches("void f() { goto FOO; FOO: ;}", gotoStmt()));
333 EXPECT_TRUE(matches("void f() { goto FOO; FOO: ;}",
337 EXPECT_TRUE(matches("void f() { FOO: ; void *ptr = &&FOO; goto *ptr; }",
339 EXPECT_TRUE(matches("void f() { return; }", returnStmt()));
345 EXPECT_TRUE(matches("class Y { }; "
355 EXPECT_TRUE(notMatches("class Y { }; "
359 EXPECT_TRUE(matches("class Y { }; "
364 EXPECT_TRUE(notMatches("bool x = true, y = true; bool t = x && y;", OpCall));
365 EXPECT_TRUE(notMatches("int t = 5 << 2;", OpCall));
372 EXPECT_TRUE(
375 EXPECT_TRUE(
378 EXPECT_TRUE(
381 EXPECT_TRUE(
384 EXPECT_TRUE(
388 EXPECT_TRUE(matches(
404 EXPECT_TRUE(matches(
414 EXPECT_TRUE(notMatches(
428 EXPECT_TRUE(matches(
430 EXPECT_TRUE(matches(
432 EXPECT_TRUE(matches(
435 EXPECT_TRUE(matches(
438 EXPECT_TRUE(notMatches(
445 EXPECT_TRUE(matches("void x() { int a = sizeof(a); }",
447 EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }",
457 EXPECT_TRUE(notMatches("class Y { void x() {} };", memberExpr()));
458 EXPECT_TRUE(notMatches("class Y { void x() {} };", unresolvedMemberExpr()));
459 EXPECT_TRUE(
464 EXPECT_TRUE(matches("class Y { void x() { x(); } };", memberExpr()));
465 EXPECT_TRUE(matches("class Y { template <class T> void x() { x<T>(); } };",
467 EXPECT_TRUE(matches("template <class T> void x() { T t; t.f(); }",
472 EXPECT_TRUE(
474 EXPECT_TRUE(
476 EXPECT_TRUE(
478 EXPECT_TRUE(matches("template <class T>"
481 EXPECT_TRUE(matches("template <class T> class X : T { void f() { T::v; } };",
483 EXPECT_TRUE(matches("template <class T> void x() { T t; t.v; }",
488 EXPECT_TRUE(matches("class Y { void x() { this->y; } static int y; };",
490 EXPECT_TRUE(notMatches("class Y { void x() { y; } static int y; };",
492 EXPECT_TRUE(notMatches("class Y { void x() { Y::y; } static int y; };",
499 EXPECT_TRUE(matches("void f() { f(); }", CallFunctionF));
500 EXPECT_TRUE(notMatches("void f() { }", CallFunctionF));
506 EXPECT_TRUE(matches("void f(); template <int N> void g() { f(); }",
508 EXPECT_TRUE(
514 EXPECT_TRUE(
517 EXPECT_TRUE(
522 EXPECT_TRUE(matches("void f(...);", functionDecl(isVariadic())));
523 EXPECT_TRUE(notMatches("void f(int);", functionDecl(isVariadic())));
524 EXPECT_TRUE(notMatches("template <typename... Ts> void f(Ts...);",
526 EXPECT_TRUE(notMatches("void f();", functionDecl(isVariadic())));
527 EXPECT_TRUE(notMatchesC("void f();", functionDecl(isVariadic())));
528 EXPECT_TRUE(matches("void f(...);", functionDecl(parameterCountIs(0))));
529 EXPECT_TRUE(matchesC("void f();", functionDecl(parameterCountIs(0))));
530 EXPECT_TRUE(matches("void f(int, ...);", functionDecl(parameterCountIs(1))));
534 EXPECT_TRUE(
540 EXPECT_TRUE(
546 EXPECT_TRUE(
555 EXPECT_TRUE(matches("template<typename T> struct A {};"
558 EXPECT_TRUE(matches("template<typename T> struct A {}; A<int> a;",
560 EXPECT_TRUE(notMatches("template<typename T> struct A {};",
565 EXPECT_TRUE(matches("int x;", declaratorDecl()));
566 EXPECT_TRUE(notMatches("class A {};", declaratorDecl()));
570 EXPECT_TRUE(matches("void f(int x);", parmVarDecl()));
571 EXPECT_TRUE(notMatches("void f();", parmVarDecl()));
577 EXPECT_TRUE(
579 EXPECT_TRUE(
582 EXPECT_TRUE(
585 EXPECT_TRUE(matches("class X {}; void x(int) { X x; }", Constructor));
589 EXPECT_TRUE(matches("class C { int i; public: C(int ii) : i(ii) {} };",
594 EXPECT_TRUE(
596 EXPECT_TRUE(
605 EXPECT_TRUE(
612 EXPECT_TRUE(
623 EXPECT_TRUE(
635 EXPECT_TRUE(
642 EXPECT_TRUE(
653 EXPECT_TRUE(
659 EXPECT_TRUE(
669 EXPECT_TRUE(matches("class X { public: X(); }; void x() { new X; }", New));
670 EXPECT_TRUE(
672 EXPECT_TRUE(
674 EXPECT_TRUE(matches("class X {}; void x(int) { new X; }", New));
678 EXPECT_TRUE(matches("struct A {}; void f(A* a) { delete a; }",
685 EXPECT_TRUE(matches("void x(int, int = 0) { int y; x(y); }", Arg));
686 EXPECT_TRUE(
688 EXPECT_TRUE(notMatches("void x(int, int = 0) { int y; x(y, 0); }", Arg));
693 EXPECT_TRUE(matches("const char *s = \"string\";", Literal));
695 EXPECT_TRUE(matches("const wchar_t *s = L\"string\";", Literal));
697 EXPECT_TRUE(matches("const char *s = \"\x05five\";", Literal));
699 EXPECT_TRUE(notMatches("const char s[1] = {'a'};", Literal));
704 EXPECT_TRUE(matches("const char c = 'c';", CharLiteral));
706 EXPECT_TRUE(matches("const char c = L'c';", CharLiteral));
708 EXPECT_TRUE(notMatches("const wchar_t c = 0x2126;", CharLiteral));
709 EXPECT_TRUE(notMatches("const char c = 0x1;", CharLiteral));
714 EXPECT_TRUE(matches("int i = 10;", HasIntLiteral));
715 EXPECT_TRUE(matches("int i = 0x1AB;", HasIntLiteral));
716 EXPECT_TRUE(matches("int i = 10L;", HasIntLiteral));
717 EXPECT_TRUE(matches("int i = 10U;", HasIntLiteral));
720 EXPECT_TRUE(notMatches("int i = L'a';",
723 EXPECT_TRUE(notMatches("int i = 'a';", HasIntLiteral));
724 EXPECT_TRUE(notMatches("int i = 1e10;", HasIntLiteral));
725 EXPECT_TRUE(notMatches("int i = 10.0;", HasIntLiteral));
728 EXPECT_TRUE(
736 EXPECT_TRUE(matches("float i = 10.0;", HasFloatLiteral));
737 EXPECT_TRUE(matches("float i = 10.0f;", HasFloatLiteral));
738 EXPECT_TRUE(matches("double i = 10.0;", HasFloatLiteral));
739 EXPECT_TRUE(matches("double i = 10.0L;", HasFloatLiteral));
740 EXPECT_TRUE(matches("double i = 1e10;", HasFloatLiteral));
741 EXPECT_TRUE(matches("double i = 5.0;", floatLiteral(equals(5.0))));
742 EXPECT_TRUE(matches("double i = 5.0;", floatLiteral(equals(5.0f))));
743 EXPECT_TRUE(
746 EXPECT_TRUE(notMatches("float i = 10;", HasFloatLiteral));
747 EXPECT_TRUE(notMatches("double i = 5.0;", floatLiteral(equals(6.0))));
748 EXPECT_TRUE(notMatches("double i = 5.0;", floatLiteral(equals(6.0f))));
749 EXPECT_TRUE(
754 EXPECT_TRUE(matches("int* i = nullptr;", cxxNullPtrLiteralExpr()));
758 EXPECT_TRUE(matchesC("void f() { (void)__builtin_choose_expr(1, 2, 3); }",
763 EXPECT_TRUE(matches("int* i = __null;", gnuNullExpr()));
767 EXPECT_TRUE(matches("void foo() { int *ptr; __atomic_load_n(ptr, 1); }",
775 EXPECT_TRUE(matchesConditionally(
794 EXPECT_TRUE(matchesC99(ToMatch,
823 EXPECT_TRUE(
830 EXPECT_TRUE(matches("void declToImport() { int C = ({int X=4; X;}); }",
836 EXPECT_TRUE(matches("void foo() { __func__; }",
843 EXPECT_TRUE(matches("void foo() { __asm(\"mov al, 2\"); }", asmStmt()));
850 EXPECT_TRUE(matches("void x() { if (true) {} }", Condition));
851 EXPECT_TRUE(notMatches("void x() { if (false) {} }", Condition));
852 EXPECT_TRUE(notMatches("void x() { bool a = true; if (a) {} }", Condition));
853 EXPECT_TRUE(notMatches("void x() { if (true || false) {} }", Condition));
854 EXPECT_TRUE(notMatches("void x() { if (1) {} }", Condition));
862 EXPECT_TRUE(matches("void x() { true ? false : true; }", Conditional));
863 EXPECT_TRUE(notMatches("void x() { false ? false : true; }", Conditional));
864 EXPECT_TRUE(notMatches("void x() { true ? true : false; }", Conditional));
869 EXPECT_TRUE(matches("void x() { true ? true : false; }", ConditionalFalse));
870 EXPECT_TRUE(
873 EXPECT_TRUE(matches("void x() { true ? true : false; }", ConditionalFalse));
874 EXPECT_TRUE(
886 EXPECT_TRUE(matches("void x() { 1 ?: 0; }", AlwaysOne));
893 EXPECT_TRUE(matches("void x() { 4 ?: 5; }", FourNotFive));
897 EXPECT_TRUE(matches("int i[2]; void f() { i[1] = 1; }",
899 EXPECT_TRUE(notMatches("int i; void f() { i = 1; }",
904 EXPECT_TRUE(matches("void f() { for(;;); }", forStmt()));
905 EXPECT_TRUE(matches("void f() { if(true) for(;;); }", forStmt()));
906 EXPECT_TRUE(notMatches("int as[] = { 1, 2, 3 };"
912 EXPECT_TRUE(notMatches("void f() { ; }", forStmt()));
913 EXPECT_TRUE(notMatches("void f() { if(true); }", forStmt()));
917 EXPECT_TRUE(notMatches("void f();", compoundStmt()));
918 EXPECT_TRUE(matches("void f() {}", compoundStmt()));
919 EXPECT_TRUE(matches("void f() {{}}", compoundStmt()));
925 EXPECT_TRUE(notMatches("namespace n { struct S {}; }",
927 EXPECT_TRUE(matches("namespace n { struct S { void f() {{}} }; }",
932 EXPECT_TRUE(matches("char *p = reinterpret_cast<char *>(&p);",castExpr()));
933 EXPECT_TRUE(matches("void *p = (void *)(&p);", castExpr()));
934 EXPECT_TRUE(matches("char q, *p = const_cast<char *>(&q);", castExpr()));
935 EXPECT_TRUE(matches("char c = char(0);", castExpr()));
939 EXPECT_TRUE(matches("char c = 0;", castExpr()));
941 EXPECT_TRUE(matches("char c = 0, d = c;", castExpr()));
945 EXPECT_TRUE(notMatches("char c = '0';", castExpr()));
946 EXPECT_TRUE(notMatches("char c, &q = c;", castExpr()));
947 EXPECT_TRUE(notMatches("int i = (0);", castExpr()));
948 EXPECT_TRUE(notMatches("int i = 0;", castExpr()));
952 EXPECT_TRUE(matches("char* p = reinterpret_cast<char*>(&p);",
957 EXPECT_TRUE(notMatches("char* p = (char*)(&p);", cxxReinterpretCastExpr()));
958 EXPECT_TRUE(notMatches("char q, *p = const_cast<char*>(&q);",
960 EXPECT_TRUE(notMatches("void* p = static_cast<void*>(&p);",
962 EXPECT_TRUE(notMatches("struct B { virtual ~B() {} }; struct D : B {};"
970 EXPECT_TRUE(matches(foo_class + "void r() { Foo f = Foo(\"hello world\"); }",
976 EXPECT_TRUE(
979 EXPECT_TRUE(
985 EXPECT_TRUE(matches("struct B { virtual ~B() {} }; struct D : B {};"
992 EXPECT_TRUE(matches("void* p(static_cast<void*>(&p));",
997 EXPECT_TRUE(notMatches("char* p = (char*)(&p);", cxxStaticCastExpr()));
998 EXPECT_TRUE(notMatches("char q, *p = const_cast<char*>(&q);",
1000 EXPECT_TRUE(notMatches("void* p = reinterpret_cast<char*>(&p);",
1002 EXPECT_TRUE(notMatches("struct B { virtual ~B() {} }; struct D : B {};"
1009 EXPECT_TRUE(matches("int i = (int) 2.2f;", cStyleCastExpr()));
1013 EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);"
1024 EXPECT_TRUE(matches("int x = 0; const int y = x;",
1027 EXPECT_TRUE(matches("char c = 0;",
1030 EXPECT_TRUE(matches("int arr[6]; int *p = arr;",
1039 EXPECT_TRUE(notMatches("int x = 0;",
1041 EXPECT_TRUE(notMatches("int x = 0, &y = x;",
1044 EXPECT_TRUE(notMatches("int x = 0; double d = (double) x;",
1046 EXPECT_TRUE(notMatches("const int *p; int *q = const_cast<int *>(p);",
1049 EXPECT_TRUE(notMatches("int x = (0);",
1054 EXPECT_TRUE(notMatches("class X {};", stmt()));
1058 EXPECT_TRUE(matches("void x() {}", stmt()));
1062 EXPECT_TRUE(notMatches("void x() {}", declStmt()));
1066 EXPECT_TRUE(matches("void x() { int a; }", declStmt()));
1070 EXPECT_TRUE(matches("struct Foo { ~Foo(); };"
1079 EXPECT_TRUE(matches("int a[] = { 1, 2 };",
1081 EXPECT_TRUE(matches("struct B { int x, y; }; B b = { 5, 6 };",
1083 EXPECT_TRUE(matches("struct S { S(void (*a)()); };"
1087 EXPECT_TRUE(
1100 EXPECT_TRUE(matches(code + "A a{0};",
1104 EXPECT_TRUE(matches(code + "A a = {0};",
1109 EXPECT_TRUE(notMatches("int a[] = { 1, 2 };", cxxStdInitializerListExpr()));
1110 EXPECT_TRUE(notMatches("struct B { int x, y; }; B b = { 5, 6 };",
1115 EXPECT_TRUE(matches("namespace X { int x; } using X::x;",
1120 EXPECT_TRUE(matches("namespace f { int a; } using f::a;",
1125 EXPECT_TRUE(matches("namespace X { int x; } using namespace X;",
1133 EXPECT_TRUE(notMatches("void x() {}", whileStmt()));
1134 EXPECT_TRUE(matches("void x() { while(true); }", whileStmt()));
1135 EXPECT_TRUE(notMatches("void x() { do {} while(true); }", whileStmt()));
1139 EXPECT_TRUE(matches("void x() { do {} while(true); }", doStmt()));
1140 EXPECT_TRUE(matches("void x() { do ; while(false); }", doStmt()));
1144 EXPECT_TRUE(notMatches("void x() { while(true) {} }", doStmt()));
1148 EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }", switchCase()));
1149 EXPECT_TRUE(matches("void x() { switch(42) { default:; } }", switchCase()));
1150 EXPECT_TRUE(matches("void x() { switch(42) default:; }", switchCase()));
1151 EXPECT_TRUE(notMatches("void x() { switch(42) {} }", switchCase()));
1155 EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }", switchStmt()));
1156 EXPECT_TRUE(matches("void x() { switch(42) { default:; } }", switchStmt()));
1157 EXPECT_TRUE(matches("void x() { switch(42) default:; }", switchStmt()));
1158 EXPECT_TRUE(notMatches("void x() {}", switchStmt()));
1162 EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", cxxCatchStmt()));
1163 EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", cxxTryStmt()));
1164 EXPECT_TRUE(
1166 EXPECT_TRUE(matches("void foo() try { throw; } catch(int X) { }",
1168 EXPECT_TRUE(matches("void foo() try { throw 5;} catch(int X) { }",
1170 EXPECT_TRUE(matches("void foo() try { throw; } catch(...) { }",
1172 EXPECT_TRUE(notMatches("void foo() try { throw; } catch(int) { }",
1174 EXPECT_TRUE(matches("void foo() try {} catch(int X) { }",
1176 EXPECT_TRUE(notMatches("void foo() try { int X; } catch (...) { }",
1181 EXPECT_TRUE(matches("int i = (3);", parenExpr()));
1182 EXPECT_TRUE(matches("int i = (3 + 7);", parenExpr()));
1183 EXPECT_TRUE(notMatches("int i = 3;", parenExpr()));
1184 EXPECT_TRUE(notMatches("int foo() { return 1; }; int a = foo();",
1191 EXPECT_TRUE(matches(
1197 EXPECT_TRUE(matches("struct S {};", qualType().bind("loc")));
1201 EXPECT_TRUE(matches("int a[2];", constantArrayType()));
1202 EXPECT_TRUE(notMatches(
1206 EXPECT_TRUE(matches("int a[42];", constantArrayType(hasSize(42))));
1207 EXPECT_TRUE(matches("int b[2*21];", constantArrayType(hasSize(42))));
1208 EXPECT_TRUE(notMatches("int c[41], d[43];", constantArrayType(hasSize(42))));
1212 EXPECT_TRUE(matches(
1215 EXPECT_TRUE(notMatches(
1221 EXPECT_TRUE(matches("int a[] = { 2, 3 };", incompleteArrayType()));
1222 EXPECT_TRUE(matches("void f(int a[]) {}", incompleteArrayType()));
1224 EXPECT_TRUE(notMatches("int a[42]; void f() { int b[a[0]]; }",
1229 EXPECT_TRUE(matches("void f(int b) { int a[b]; }", variableArrayType()));
1230 EXPECT_TRUE(notMatches("int a[] = {2, 3}; int b[42];", variableArrayType()));
1232 EXPECT_TRUE(matches(
1243 EXPECT_TRUE(matches("_Atomic(int) i;", atomicType()));
1245 EXPECT_TRUE(matches("_Atomic(int) i;",
1247 EXPECT_TRUE(notMatches("_Atomic(float) f;",
1253 EXPECT_TRUE(matches("auto i = 2;", autoType()));
1254 EXPECT_TRUE(matches("int v[] = { 2, 3 }; void f() { for (int i : v) {} }",
1257 EXPECT_TRUE(matches("auto i = 2;", varDecl(hasType(isInteger()))));
1258 EXPECT_TRUE(matches("struct X{}; auto x = X{};",
1270 EXPECT_TRUE(matches("decltype(1 + 1) sum = 1 + 1;", decltypeType()));
1271 EXPECT_TRUE(matches("decltype(1 + 1) sum = 1 + 1;",
1276 EXPECT_TRUE(matches("int (*f)(int);", functionType()));
1277 EXPECT_TRUE(matches("void f(int i) {}", functionType()));
1281 EXPECT_TRUE(
1283 EXPECT_TRUE(matches("void (*fp)(void);",
1288 EXPECT_TRUE(matches("int (*f)(int);", functionProtoType()));
1289 EXPECT_TRUE(matches("void f(int i);", functionProtoType()));
1290 EXPECT_TRUE(matches("void f();", functionProtoType(parameterCountIs(0))));
1291 EXPECT_TRUE(notMatchesC("void f();", functionProtoType()));
1292 EXPECT_TRUE(
1297 EXPECT_TRUE(
1299 EXPECT_TRUE(notMatches("int *array[4];", varDecl(hasType(parenType()))));
1301 EXPECT_TRUE(matches(
1304 EXPECT_TRUE(notMatches(
1321 EXPECT_TRUE(matches(
1324 EXPECT_TRUE(matches(
1327 EXPECT_TRUE(matches(
1332 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1334 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ptr"),
1336 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1338 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1340 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1342 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1346 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1348 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1350 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ptr"),
1352 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1356 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1358 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1360 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1362 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
1364 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
1366 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1370 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1372 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1374 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1376 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
1378 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1380 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
1390 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("a"),
1392 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("b"),
1394 EXPECT_TRUE(matches(Fragment, varDecl(hasName("c"),
1396 EXPECT_TRUE(matches(Fragment, varDecl(hasName("c"),
1398 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("c"),
1400 EXPECT_TRUE(matches(Fragment, varDecl(hasName("d"),
1402 EXPECT_TRUE(matches(Fragment, varDecl(hasName("d"),
1404 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("d"),
1406 EXPECT_TRUE(matches(Fragment, varDecl(hasName("e"),
1408 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("e"),
1410 EXPECT_TRUE(matches(Fragment, varDecl(hasName("e"),
1415 EXPECT_TRUE(matches("enum Color { Green }; Color color;",
1417 EXPECT_TRUE(matches("enum class Color { Green }; Color color;",
1422 EXPECT_TRUE(matches("int b; int * const a = &b;",
1424 EXPECT_TRUE(matches("int b; int * const a = &b;",
1426 EXPECT_TRUE(matches(
1429 EXPECT_TRUE(matches(
1435 EXPECT_TRUE(matches("typedef int X; X a;", varDecl(hasName("a"),
1440 EXPECT_TRUE(matches("template <typename T> class A{}; A<int> a;",
1445 EXPECT_TRUE(matches("class C{}; C c;", recordType()));
1446 EXPECT_TRUE(matches("struct S{}; S s;",
1448 EXPECT_TRUE(notMatches("int i;",
1453 EXPECT_TRUE(matches(
1460 EXPECT_TRUE(matches("class C {} c;", elaboratedType()));
1461 EXPECT_TRUE(notMatches("class C {}; C c;", elaboratedType()));
1472 EXPECT_TRUE(matches(code, binaryOperator(hasRHS(
1477 EXPECT_TRUE(matches("namespace ns { struct A {}; } ns::A a;",
1479 EXPECT_TRUE(matches("template <typename T> class A { typename T::B b; };",
1481 EXPECT_TRUE(matches("struct A { void f(); }; void A::f() {}",
1483 EXPECT_TRUE(matches("namespace a { namespace b {} } namespace ab = a::b;",
1486 EXPECT_TRUE(matches(
1489 EXPECT_TRUE(notMatches(
1495 EXPECT_TRUE(matches("void f() {int i;;}", nullStmt()));
1496 EXPECT_TRUE(notMatches("void f() {int i;}", nullStmt()));
1500 EXPECT_TRUE(matches("namespace test {} namespace alias = ::test;",
1507 EXPECT_TRUE(matches("struct A { struct B {}; }; A::B b;", Matcher));
1508 EXPECT_TRUE(matches("struct A { struct B { struct C {}; }; }; A::B::C c;",
1510 EXPECT_TRUE(notMatches("namespace A { struct B {}; } A::B b;", Matcher));
1516 EXPECT_TRUE(matches("namespace ns { struct A {}; } ns::A a;", Matcher));
1517 EXPECT_TRUE(notMatches("namespace xx { struct A {}; } xx::A a;", Matcher));
1518 EXPECT_TRUE(notMatches("struct ns { struct A {}; }; ns::A a;", Matcher));
1522 EXPECT_TRUE(matches(
1525 EXPECT_TRUE(matches(
1529 EXPECT_TRUE(matches(
1577 EXPECT_TRUE(matchAndVerifyResultTrue(
1580 EXPECT_TRUE(matchAndVerifyResultTrue(
1583 EXPECT_TRUE(matchAndVerifyResultTrue(
1590 EXPECT_TRUE(matches("typedef int typedefDeclTest;",
1592 EXPECT_TRUE(notMatches("using typedefDeclTest2 = int;",
1597 EXPECT_TRUE(matches("using typeAliasTest2 = int;",
1599 EXPECT_TRUE(notMatches("typedef int typeAliasTest;",
1604 EXPECT_TRUE(matches("typedef int typedefNameDeclTest1;",
1606 EXPECT_TRUE(matches("using typedefNameDeclTest2 = int;",
1620 EXPECT_TRUE(
1622 EXPECT_TRUE(
1628 EXPECT_TRUE(notMatchesObjC("", objcMessageExpr(anything())));
1645 EXPECT_TRUE(matchesObjC(
1648 EXPECT_TRUE(matchesObjC(Objc1String,
1653 EXPECT_TRUE(matchesObjC(
1656 EXPECT_TRUE(matchesObjC(
1662 EXPECT_TRUE(matchesObjC(
1668 EXPECT_TRUE(notMatchesObjC(
1671 EXPECT_TRUE(matchesObjC(
1674 EXPECT_TRUE(matchesObjC(
1677 EXPECT_TRUE(matchesObjC(
1704 EXPECT_TRUE(matchesObjC(
1707 EXPECT_TRUE(matchesObjC(
1710 EXPECT_TRUE(matchesObjC(
1713 EXPECT_TRUE(matchesObjC(
1716 EXPECT_TRUE(matchesObjC(
1719 EXPECT_TRUE(matchesObjC(
1722 EXPECT_TRUE(matchesObjC(
1725 EXPECT_TRUE(matchesObjC(
1728 EXPECT_TRUE(matchesObjC(
1742 EXPECT_TRUE(matchesObjC(
1745 EXPECT_TRUE(matchesObjC(
1748 EXPECT_TRUE(matchesObjC(
1751 EXPECT_TRUE(matchesObjC(
1763 EXPECT_TRUE(matchesObjC(ObjCString, autoreleasePoolStmt()));
1776 EXPECT_TRUE(matchesWithOpenMP(Source0, Matcher));
1783 EXPECT_TRUE(matchesWithOpenMP(Source1, Matcher));
1789 EXPECT_TRUE(notMatchesWithOpenMP(Source2, Matcher));
1799 EXPECT_TRUE(notMatchesWithOpenMP(Source0, Matcher));
1806 EXPECT_TRUE(notMatchesWithOpenMP(Source1, Matcher));
1813 EXPECT_TRUE(matchesWithOpenMP(Source2, Matcher));
1820 EXPECT_TRUE(matchesWithOpenMP(Source3, Matcher));
1827 EXPECT_TRUE(notMatchesWithOpenMP(Source4, Matcher));
tools/clang/unittests/ASTMatchers/ASTMatchersTest.h 437 EXPECT_TRUE(M.count(Id) == 0 ||
tools/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp 22 EXPECT_TRUE(matches("class A { void func(); };",
24 EXPECT_TRUE(notMatches("class A { void func(); };",
29 EXPECT_TRUE(matches(
39 EXPECT_TRUE(matches(
46 EXPECT_TRUE(notMatches(
54 EXPECT_TRUE(matches("namespace {"
62 EXPECT_TRUE(matches("class D{};", decl(hasDeclContext(decl()))));
66 EXPECT_TRUE(matches("void f() { int i = 3; }",
68 EXPECT_TRUE(matches("void f() { int i = 3; }",
71 EXPECT_TRUE(matches("void f() { int i = 3; }",
73 EXPECT_TRUE(matches("void f() { int i = 3; }",
76 EXPECT_TRUE(notMatches("void f() { float f = 2.0f; }",
79 EXPECT_TRUE(matchAndVerifyResultTrue(
87 EXPECT_TRUE(matches("void f() { int*** i; }",
89 EXPECT_TRUE(matches("void f() { int*** i; }",
92 EXPECT_TRUE(matches("void f() { int*** i; }",
95 EXPECT_TRUE(matchAndVerifyResultTrue(
103 EXPECT_TRUE(matches("int i;",
105 EXPECT_TRUE(notMatches("int** i;",
107 EXPECT_TRUE(matchAndVerifyResultTrue(
114 EXPECT_TRUE(matches(
117 EXPECT_TRUE(notMatches(
127 EXPECT_TRUE(matches(
129 EXPECT_TRUE(notMatches(
138 EXPECT_TRUE(matches(
141 EXPECT_TRUE(notMatches(
149 EXPECT_TRUE(matches("class A { public: A *a; };", TypeA));
150 EXPECT_TRUE(notMatches("class A {};", TypeA));
155 EXPECT_TRUE(matches("class A {}; class B : public A { public: B *b; };",
157 EXPECT_TRUE(notMatches("class A {};", TypeA));
162 EXPECT_TRUE(
165 EXPECT_TRUE(matchesC("struct S {}; void f(void) { struct S s; }",
171 EXPECT_TRUE(matches("typedef int I; void f(I i);",
174 EXPECT_TRUE(matchesObjC("@interface Foo @end void f(Foo *f);",
177 EXPECT_TRUE(matchesObjC(
181 EXPECT_TRUE(matches("template <typename T> void f(T t);",
184 EXPECT_TRUE(matches("template <typename T> void f(T t);",
187 EXPECT_TRUE(matches("template <typename T> struct S {"
191 EXPECT_TRUE(notMatches("template <typename T> struct S {"
196 EXPECT_TRUE(matches("template <typename T> struct S {"
212 EXPECT_TRUE(matches(Using, unresolvedUsingTypenameDecl(hasName("Foo"))));
214 EXPECT_TRUE(matches(Using, parmVarDecl(hasType(namedDecl(hasName("Foo"))))));
218 EXPECT_TRUE(matches("enum X {}; void y(X *x) { x; }",
233 EXPECT_TRUE(matches(
237 EXPECT_TRUE(matches(
244 EXPECT_TRUE(matches("typedef int X; X a;",
252 EXPECT_TRUE(matches("template <typename T> class A {}; A<int> a;",
255 EXPECT_TRUE(matches("template <typename T> class A {};"
259 EXPECT_TRUE(matches("template <typename T> class A {}; A<int> a;",
265 EXPECT_TRUE(
271 EXPECT_TRUE(matches("template <typename T> using C = T; C<int> c;",
277 EXPECT_TRUE(
280 EXPECT_TRUE(
286 EXPECT_TRUE(matches("namespace N { template <class T> void f(T t); }"
290 EXPECT_TRUE(matches(
294 EXPECT_TRUE(notMatches(
302 EXPECT_TRUE(
304 EXPECT_TRUE(
307 EXPECT_TRUE(
314 EXPECT_TRUE(
316 EXPECT_TRUE(
318 EXPECT_TRUE(
325 EXPECT_TRUE(
327 EXPECT_TRUE(
334 EXPECT_TRUE(
336 EXPECT_TRUE(
341 EXPECT_TRUE(matches("typedef int X;", typedefDecl(hasType(asString("int")))));
342 EXPECT_TRUE(matches("typedef const int T;",
344 EXPECT_TRUE(notMatches("typedef const int T;",
346 EXPECT_TRUE(matches("typedef int foo; typedef foo bar;",
351 EXPECT_TRUE(matches("using X = int;", typedefNameDecl(hasType(asString("int")))));
352 EXPECT_TRUE(matches("using T = const int;",
354 EXPECT_TRUE(notMatches("using T = const int;",
356 EXPECT_TRUE(matches("using foo = int; using bar = foo;",
361 EXPECT_TRUE(matches("int x;",
365 EXPECT_TRUE(notMatches("class X {}; X x;",
373 EXPECT_TRUE(matches("class Y { void x() { x(); } };", CallMethodX));
374 EXPECT_TRUE(notMatches("class Y { void x() {} };", CallMethodX));
377 EXPECT_TRUE(
379 EXPECT_TRUE(notMatches("struct Y { operator int() const; }; Y y = Y();",
384 EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
386 EXPECT_TRUE(
394 EXPECT_TRUE(matches("void x(int) { int y; x(y); }", CallArgumentY));
395 EXPECT_TRUE(
397 EXPECT_TRUE(notMatches("void x(int) { int z; x(z); }", CallArgumentY));
401 EXPECT_TRUE(notMatches("void x(int) { int y; x(y); }", WrongIndex));
412 EXPECT_TRUE(matches("void x(int, int) { int y; x(1, y); }", CallArgumentY));
413 EXPECT_TRUE(matches("void x(int, int) { int y; x(y, 42); }", CallArgumentY));
414 EXPECT_TRUE(matches("struct Y { Y(int, int); };"
417 EXPECT_TRUE(matches("struct Y { Y(int, int); };"
420 EXPECT_TRUE(matches("template <class Y> void x() { int y; (void)Y(1, y); }",
422 EXPECT_TRUE(matches("template <class Y> void x() { int y; (void)Y(y, 42); }",
424 EXPECT_TRUE(matchesObjC("@interface I -(void)f:(int) y; @end "
430 EXPECT_TRUE(notMatches("void x(int, int) { x(1, 2); }", CallArgumentY));
431 EXPECT_TRUE(notMatches("struct Y { Y(int, int); };"
434 EXPECT_TRUE(notMatches("template <class Y>"
440 EXPECT_TRUE(matches("void x(long) { int y; x(y); }", ImplicitCastedArgument));
444 EXPECT_TRUE(matchesObjC(
458 EXPECT_TRUE(matchesObjC(
472 EXPECT_TRUE(matchesObjC(
487 EXPECT_TRUE(matchesObjC(
491 EXPECT_TRUE(matchesObjC(
507 EXPECT_TRUE(matchesObjC(
511 EXPECT_TRUE(matchesObjC(
541 EXPECT_TRUE(matches(Snippet1, MatchesY));
542 EXPECT_TRUE(notMatches(Snippet2, MatchesY));
545 EXPECT_TRUE(matches(Snippet2, MatchesX));
556 EXPECT_TRUE(matches(Snippet3, MatchesCall));
575 EXPECT_TRUE(matches(Snippet1, MatchesY));
576 EXPECT_TRUE(matches(Snippet2, MatchesY));
580 EXPECT_TRUE(notMatches(Snippet2, MatchesX));
591 EXPECT_TRUE(notMatches(Snippet3, MatchesCall));
609 EXPECT_TRUE(matches(Snippet1, MatchesX));
610 EXPECT_TRUE(notMatches(Snippet2, MatchesX));
614 EXPECT_TRUE(notMatches(Snippet1, MatchesXPointer));
615 EXPECT_TRUE(matches(Snippet2, MatchesXPointer));
626 EXPECT_TRUE(notMatches("void f(int* i) { int* y; f(y); }", CallExpr));
628 EXPECT_TRUE(notMatches("void f(int i) { int x; f(x); }", CallExpr));
637 EXPECT_TRUE(matchAndVerifyResultTrue(
649 EXPECT_TRUE(matchAndVerifyResultTrue(
667 EXPECT_TRUE(
671 EXPECT_TRUE(
676 EXPECT_TRUE(matchAndVerifyResultTrue(
679 EXPECT_TRUE(matchAndVerifyResultTrue(
691 EXPECT_TRUE(matchAndVerifyResultTrue(
702 EXPECT_TRUE(matchAndVerifyResultTrue(
719 EXPECT_TRUE(notMatches("typedef int &int_ref;"
723 EXPECT_TRUE(
731 EXPECT_TRUE(matches("class X { void x(int) {} };",
733 EXPECT_TRUE(notMatches("class X { void x(int) {} };",
735 EXPECT_TRUE(matchesObjC("@interface I -(void)f:(int) x; @end",
737 EXPECT_TRUE(matchesObjC("int main() { void (^b)(int) = ^(int p) {}; }",
742 EXPECT_TRUE(notMatches("class X { void x(int) {} };",
747 EXPECT_TRUE(matches(
750 EXPECT_TRUE(notMatches(
753 EXPECT_TRUE(matches("class X { void x(const X *x) {} };",
756 EXPECT_TRUE(matches("class X { void x(const X &x) {} };",
762 EXPECT_TRUE(matches(
765 EXPECT_TRUE(matches(
768 EXPECT_TRUE(matchesObjC("@interface I -(void)f:(int) x; @end",
770 EXPECT_TRUE(matchesObjC("int main() { void (^b)(int) = ^(int p) {}; }",
775 EXPECT_TRUE(matches("class Y { int f() { return 1; } };",
777 EXPECT_TRUE(notMatches("class Y { int f() { return 1; } };",
779 EXPECT_TRUE(matches("class Y { Y getMe() { return *this; } };",
785 EXPECT_TRUE(notMatches(
791 EXPECT_TRUE(notMatches("class Y {}; class X { void x() {} };",
797 EXPECT_TRUE(matches("class Y {}; class X { void x(int x) {} };",
799 EXPECT_TRUE(notMatches("class Y {}; class X { void x(int) {} };",
804 EXPECT_TRUE(matches(
812 EXPECT_TRUE(matches("template<template <typename> class S> class X {};"
820 EXPECT_TRUE(matches(
827 EXPECT_TRUE(notMatches(
833 EXPECT_TRUE(matches(
840 EXPECT_TRUE(notMatches(
849 EXPECT_TRUE(matches(
854 EXPECT_TRUE(notMatches(
860 EXPECT_TRUE(matches(
865 EXPECT_TRUE(notMatches(
871 EXPECT_TRUE(matches(
875 EXPECT_TRUE(notMatches(
881 EXPECT_TRUE(matches("template<typename T> struct C {}; C<int> c;",
884 EXPECT_TRUE(matches(
888 EXPECT_TRUE(matches(
902 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T"))));
903 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U"))));
914 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T"))));
915 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U"))));
927 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T"))));
928 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T2"))));
929 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U"))));
930 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U2"))));
942 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T"))));
943 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T2"))));
944 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U"))));
945 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U2"))));
959 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T"))));
960 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U"))));
973 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T"))));
974 EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U"))));
978 EXPECT_TRUE(matches("template<int T> struct C {}; C<42> c;",
982 EXPECT_TRUE(notMatches("template<unsigned T> struct C {}; C<42> c;",
988 EXPECT_TRUE(matches("class Foo { Foo(int i); };",
990 EXPECT_TRUE(notMatches("class Foo { Foo(int i); };",
995 EXPECT_TRUE(matches("class Foo { virtual ~Foo(); };",
1000 EXPECT_TRUE(notMatches("class Foo {};",
1005 EXPECT_TRUE(
1008 EXPECT_TRUE(
1026 EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
1028 EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
1030 EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
1032 EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
1042 EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
1044 EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
1056 EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
1058 EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
1060 EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
1074 EXPECT_TRUE(matches(Code, cxxConstructorDecl(allOf(
1077 EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(allOf(
1080 EXPECT_TRUE(matches(Code, cxxConstructorDecl(allOf(
1083 EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(allOf(
1089 EXPECT_TRUE(matches("void f() { if (false) true; else false; }",
1091 EXPECT_TRUE(notMatches("void f() { if (false) false; else true; }",
1093 EXPECT_TRUE(matches("void f() { if (false) false; else true; }",
1095 EXPECT_TRUE(notMatches("void f() { if (false) true; else false; }",
1102 EXPECT_TRUE(matches("void x() { true || false; }", OperatorOr));
1103 EXPECT_TRUE(notMatches("void x() { true && false; }", OperatorOr));
1111 EXPECT_TRUE(matches("void x() { true || false; }", OperatorTrueFalse));
1112 EXPECT_TRUE(matches("void x() { true && false; }", OperatorTrueFalse));
1113 EXPECT_TRUE(notMatches("void x() { false || true; }", OperatorTrueFalse));
1117 EXPECT_TRUE(matches("void x() { 1[\"abc\"]; }", OperatorIntPointer));
1118 EXPECT_TRUE(notMatches("void x() { \"abc\"[1]; }", OperatorIntPointer));
1125 EXPECT_TRUE(matches("void x() { true || false; }", HasOperand));
1126 EXPECT_TRUE(matches("void x() { false && true; }", HasOperand));
1127 EXPECT_TRUE(notMatches("void x() { true || true; }", HasOperand));
1134 EXPECT_TRUE(
1136 EXPECT_TRUE(
1139 EXPECT_TRUE(
1141 EXPECT_TRUE(
1143 EXPECT_TRUE(matches("bool b = 1 < 2;", binaryOperator(hasOperatorName("<"))));
1144 EXPECT_TRUE(
1146 EXPECT_TRUE(
1148 EXPECT_TRUE(
1151 EXPECT_TRUE(matches("bool b = 1 > 2;", binaryOperator(hasOperatorName(">"))));
1152 EXPECT_TRUE(
1154 EXPECT_TRUE(
1156 EXPECT_TRUE(
1159 EXPECT_TRUE(
1161 EXPECT_TRUE(
1164 EXPECT_TRUE(
1166 EXPECT_TRUE(
1169 EXPECT_TRUE(
1171 EXPECT_TRUE(
1174 EXPECT_TRUE(
1177 EXPECT_TRUE(
1179 EXPECT_TRUE(
1182 EXPECT_TRUE(
1185 EXPECT_TRUE(
1187 EXPECT_TRUE(
1190 EXPECT_TRUE(
1192 EXPECT_TRUE(
1195 EXPECT_TRUE(
1197 EXPECT_TRUE(
1200 EXPECT_TRUE(
1202 EXPECT_TRUE(
1205 EXPECT_TRUE(
1208 EXPECT_TRUE(
1213 EXPECT_TRUE(
1218 EXPECT_TRUE(
1222 EXPECT_TRUE(notMatches("int a[42]; void x() { a[23]; }", unaryOperator()));
1225 EXPECT_TRUE(notMatches(
1234 EXPECT_TRUE(matches("void x() { !true; } ", OperatorNot));
1235 EXPECT_TRUE(notMatches("void x() { true; } ", OperatorNot));
1242 EXPECT_TRUE(matches("void x() { !false; }", OperatorOnFalse));
1243 EXPECT_TRUE(notMatches("void x() { !true; }", OperatorOnFalse));
1249 EXPECT_TRUE(matches("bool b = !true;", unaryOperator(hasOperatorName("!"))));
1250 EXPECT_TRUE(
1252 EXPECT_TRUE(matches("int i = ~ 1;", unaryOperator(hasOperatorName("~"))));
1253 EXPECT_TRUE(
1255 EXPECT_TRUE(
1257 EXPECT_TRUE(
1259 EXPECT_TRUE(
1261 EXPECT_TRUE(
1263 EXPECT_TRUE(
1265 EXPECT_TRUE(
1269 EXPECT_TRUE(notMatches("int i; double d = (double)i;", unaryOperator()));
1272 EXPECT_TRUE(notMatches("void f(); void x() { f(); }", unaryOperator()));
1276 EXPECT_TRUE(notMatches(
1282 EXPECT_TRUE(matches(
1285 EXPECT_TRUE(matches(
1288 EXPECT_TRUE(notMatches(
1294 EXPECT_TRUE(matches(
1304 EXPECT_TRUE(
1306 EXPECT_TRUE(
1309 EXPECT_TRUE(
1315 EXPECT_TRUE(matches(
1321 EXPECT_TRUE(matches(
1337 EXPECT_TRUE(matches("void x() { if (true) {} }", IfStmt));
1338 EXPECT_TRUE(notMatches("void x() { if (false) {} }", IfStmt));
1342 EXPECT_TRUE(matches("void x() { for (;true;) {} }", ForStmt));
1343 EXPECT_TRUE(notMatches("void x() { for (;false;) {} }", ForStmt));
1347 EXPECT_TRUE(matches("void x() { while (true) {} }", WhileStmt));
1348 EXPECT_TRUE(notMatches("void x() { while (false) {} }", WhileStmt));
1352 EXPECT_TRUE(matches("void x() { switch (42) {case 42:;} }", SwitchStmt));
1353 EXPECT_TRUE(notMatches("void x() { switch (43) {case 43:;} }", SwitchStmt));
1357 EXPECT_TRUE(matches("void f(){ int i; for (; i < 3 ; ); }",
1359 EXPECT_TRUE(matches("void f() { for (int i = 0; ;); }",
1364 EXPECT_TRUE(matches("void f(){ int a[] {1, 2}; for (int i : a); }",
1366 EXPECT_TRUE(matches(
1372 EXPECT_TRUE(notMatches("void f(){ for (int i = 0; ; ++i); }",
1374 EXPECT_TRUE(notMatches("void f() {int i; for (; i < 4; ++i) {} }",
1379 EXPECT_TRUE(matches("void f() { for(;;) {} }",
1381 EXPECT_TRUE(notMatches("void f() { for(;;); }",
1383 EXPECT_TRUE(matches("void f() { while(true) {} }",
1385 EXPECT_TRUE(matches("void f() { do {} while(true); }",
1387 EXPECT_TRUE(matches("void f() { int p[2]; for (auto x : p) {} }",
1389 EXPECT_TRUE(matches("void f() {}", functionDecl(hasBody(compoundStmt()))));
1390 EXPECT_TRUE(notMatches("void f();", functionDecl(hasBody(compoundStmt()))));
1391 EXPECT_TRUE(matches("void f(); void f() {}",
1399 EXPECT_TRUE(matches("void f() { for (;;); }",
1405 EXPECT_TRUE(notMatches("void f() { if (true) for (;;); }",
1410 EXPECT_TRUE(matches("void f() { if (true) { for (;;); } }",
1415 EXPECT_TRUE(matches("void f() { 1; 2; 3; for (;;); 4; 5; 6; }",
1421 EXPECT_TRUE(matchesConditionally(
1426 EXPECT_TRUE(matches("class X { void operator delete(void*); };",
1430 EXPECT_TRUE(matchesConditionally(
1437 EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
1444 EXPECT_TRUE(matches("int x; const int i = x;",
1448 EXPECT_TRUE(matches("int arr[3]; int *p = arr;",
1455 EXPECT_TRUE(notMatches("char c = 0;",
1459 EXPECT_TRUE(notMatches("int arr[3]; int *p = arr;",
1465 EXPECT_TRUE(
1476 EXPECT_TRUE(
1487 EXPECT_TRUE(matches(
1501 EXPECT_TRUE(matches("struct H {};"
1507 EXPECT_TRUE(notMatches("struct H {};"
1515 EXPECT_TRUE(matches("struct H {};"
1525 EXPECT_TRUE(matches("void f() {"
1535 EXPECT_TRUE(matches("struct H {};"
1541 EXPECT_TRUE(matches("struct H {};"
1550 EXPECT_TRUE(matches("class C {}; C a = C();",
1582 EXPECT_TRUE(matches(Code, varDecl(
1594 EXPECT_TRUE(
1602 EXPECT_TRUE(matches("int x = 0; const int y = x;",
1606 EXPECT_TRUE(matches("char x = 0;",
1615 EXPECT_TRUE(notMatches("int x; const int y = x;",
1618 EXPECT_TRUE(notMatches("int x; int y = x;",
1624 EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
1627 EXPECT_TRUE(notMatches("int i = (0);",
1630 EXPECT_TRUE(notMatches("float i = (float)0;",
1633 EXPECT_TRUE(notMatches("float i = float(0);",
1641 EXPECT_TRUE(matches("int x = 0; int &y = x;",
1649 EXPECT_TRUE(matches("int x = (0);",
1652 EXPECT_TRUE(matches("int x = (((((0)))));",
1658 EXPECT_TRUE(matches("char x = (0);",
1662 EXPECT_TRUE(matches("char x = (char)0;",
1665 EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
1672 EXPECT_TRUE(matches("int x = 0;",
1680 EXPECT_TRUE(notMatches("int x = ((0));",
1686 EXPECT_TRUE(notMatches("char x = ((0));",
1690 EXPECT_TRUE(notMatches("char *x = static_cast<char *>((0));",
1700 EXPECT_TRUE(matches("int x = 0; const int y = x;",
1704 EXPECT_TRUE(matches("const char x = (0);",
1712 EXPECT_TRUE(matches("int x = 0; int &y = x;",
1715 EXPECT_TRUE(matches("int x = 0;",
1724 EXPECT_TRUE(notMatches("char c = ((3));",
1729 EXPECT_TRUE(notMatches("float y = (float(0));",
1732 EXPECT_TRUE(notMatches("float y = (float)0;",
1735 EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
1741 EXPECT_TRUE(matches("class string {}; class URL { public: URL(string s); };"
1748 EXPECT_TRUE(matches("float x = static_cast<float>(42);",
1755 EXPECT_TRUE(matches("namespace f { int a; void b(); } using f::b;",
1758 EXPECT_TRUE(notMatches("namespace f { int a; void b(); } using f::a;",
1764 EXPECT_TRUE(matches(
1767 EXPECT_TRUE(notMatches(
1775 EXPECT_TRUE(matches("void f() {int a = 4;}", SingleDeclStmt));
1776 EXPECT_TRUE(notMatches("void f() {int a;}", SingleDeclStmt));
1777 EXPECT_TRUE(notMatches("void f() {int a = 4, b = 3;}",
1784 EXPECT_TRUE(matches("void f() {int a = 4;}",
1786 EXPECT_TRUE(matches("void f() {int a = 4, b = 3;}",
1790 EXPECT_TRUE(notMatches("void f() {int a = 4, b = 3;}",
1796 EXPECT_TRUE(notMatches("void x() { switch(42); }",
1798 EXPECT_TRUE(matches("void x() { switch(42) case 42:; }",
1800 EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }",
1802 EXPECT_TRUE(notMatches(
1805 EXPECT_TRUE(matches("void x() { switch(42) { case 1+1: case 4:; } }",
1809 EXPECT_TRUE(notMatches("void x() { switch(42) { case 1+1: case 2+2:; } }",
1813 EXPECT_TRUE(notMatches("void x() { switch(42) { case 1 ... 2:; } }",
1817 EXPECT_TRUE(matchAndVerifyResultTrue(
1824 EXPECT_TRUE(matchesConditionally(
1827 EXPECT_TRUE(matchesConditionally(
1831 EXPECT_TRUE(matchesConditionally(
1835 EXPECT_TRUE(matchesConditionally(
1839 EXPECT_TRUE(matchesConditionally(
1843 EXPECT_TRUE(matchesConditionally(
1847 EXPECT_TRUE(matchesConditionally(
1851 EXPECT_TRUE(matchesConditionally(
1855 EXPECT_TRUE(matchesConditionally(
1861 EXPECT_TRUE(matchesConditionally("template<typename T> struct S { S(int); };"
1866 EXPECT_TRUE(matchesConditionally("template<typename T> struct S { S(int); };"
1874 EXPECT_TRUE(matches(
1880 EXPECT_TRUE(notMatches(
1883 EXPECT_TRUE(notMatches(
1889 EXPECT_TRUE(matches(
1895 EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; };",
1901 EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; int y; int z; };",
1907 EXPECT_TRUE(matchAndVerifyResultTrue(
1915 EXPECT_TRUE(matchAndVerifyResultTrue("class C { class D { int x; }; };",
1924 EXPECT_TRUE(matchAndVerifyResultTrue(
1932 EXPECT_TRUE(matchAndVerifyResultTrue(
1939 EXPECT_TRUE(matchAndVerifyResultTrue(
1947 EXPECT_TRUE(matchAndVerifyResultTrue(
1956 EXPECT_TRUE(matchAndVerifyResultTrue(
1965 EXPECT_TRUE(matchAndVerifyResultTrue(
1990 EXPECT_TRUE(matchAndVerifyResultTrue(
1996 EXPECT_TRUE(matchAndVerifyResultTrue(
2000 EXPECT_TRUE(matchAndVerifyResultTrue(
2006 EXPECT_TRUE(matchAndVerifyResultTrue(
2010 EXPECT_TRUE(matchAndVerifyResultTrue(
2016 EXPECT_TRUE(matchAndVerifyResultTrue(
2020 EXPECT_TRUE(matchAndVerifyResultTrue(
2024 EXPECT_TRUE(matchAndVerifyResultTrue(
2029 EXPECT_TRUE(matchAndVerifyResultTrue(
2035 EXPECT_TRUE(matchAndVerifyResultTrue(
2039 EXPECT_TRUE(matchAndVerifyResultTrue(
2044 EXPECT_TRUE(matchAndVerifyResultTrue(
2048 EXPECT_TRUE(matchAndVerifyResultTrue(
2055 EXPECT_TRUE(matchAndVerifyResultTrue(
2059 EXPECT_TRUE(matchAndVerifyResultTrue(
2067 EXPECT_TRUE(matchAndVerifyResultTrue(
2071 EXPECT_TRUE(matchAndVerifyResultTrue(
2078 EXPECT_TRUE(matchAndVerifyResultTrue(
2085 EXPECT_TRUE(matchAndVerifyResultTrue(
2092 EXPECT_TRUE(matchAndVerifyResultTrue(
2099 EXPECT_TRUE(matchAndVerifyResultTrue(
2106 EXPECT_TRUE(matches(
2112 EXPECT_TRUE(notMatches(
2118 EXPECT_TRUE(matches(
2125 EXPECT_TRUE(matches(
2131 EXPECT_TRUE(matches(
2137 EXPECT_TRUE(matchAndVerifyResultTrue(
2144 EXPECT_TRUE(matchAndVerifyResultTrue(
2156 EXPECT_TRUE(matchAndVerifyResultTrue(
2170 EXPECT_TRUE(matches(
2178 EXPECT_TRUE(matches(
2186 EXPECT_TRUE(matches(
2189 EXPECT_TRUE(notMatches(
2192 EXPECT_TRUE(notMatches(
2198 EXPECT_TRUE(matches(
2209 EXPECT_TRUE(matches("struct MyClass {\n"
2217 EXPECT_TRUE(matches("int F() {\n"
2222 EXPECT_TRUE(matches("void f() {\n"
2229 EXPECT_TRUE(matches("void f() {\n"
2238 EXPECT_TRUE(matches("struct PartitionAllocator {\n"
2249 EXPECT_TRUE(matches("template <class T> void f();\n"
2256 EXPECT_TRUE(matches(
2263 EXPECT_TRUE(
2270 EXPECT_TRUE(matches(
2279 EXPECT_TRUE(
2307 EXPECT_TRUE(matches("int b; int &a = b;",
2309 EXPECT_TRUE(matches("int *a;", pointerType(pointee(builtinType()))));
2311 EXPECT_TRUE(matches("int *a;",
2314 EXPECT_TRUE(matches(
2317 EXPECT_TRUE(notMatches(
2323 EXPECT_TRUE(matches(
2331 EXPECT_TRUE(notMatches(
2337 EXPECT_TRUE(notMatches(
2344 EXPECT_TRUE(matches(
2353 EXPECT_TRUE(notMatches(
2362 EXPECT_TRUE(matchAndVerifyResultTrue(
2370 EXPECT_TRUE(matchAndVerifyResultTrue(
2380 EXPECT_TRUE(matches(
2385 EXPECT_TRUE(notMatches(
2390 EXPECT_TRUE(matches(
2398 EXPECT_TRUE(matchAndVerifyResultTrue(
2409 EXPECT_TRUE(matches(
2413 EXPECT_TRUE(matchAndVerifyResultTrue(
2425 EXPECT_TRUE(matches(
2430 EXPECT_TRUE(notMatches(
2435 EXPECT_TRUE(matches(
2441 EXPECT_TRUE(matchAndVerifyResultTrue(
2452 EXPECT_TRUE(matches(
2456 EXPECT_TRUE(matchAndVerifyResultTrue(
2484 EXPECT_TRUE(matchAndVerifyResultTrue(
2489 EXPECT_TRUE(matchAndVerifyResultFalse(
2497 EXPECT_TRUE(matchAndVerifyResultTrue(
2501 EXPECT_TRUE(matchAndVerifyResultFalse(
2508 EXPECT_TRUE(matchAndVerifyResultTrue(
2512 EXPECT_TRUE(matchAndVerifyResultFalse(
2520 EXPECT_TRUE(matches("int F() { int a, b; return a + b; }", RetVal));
2541 EXPECT_TRUE(
2546 EXPECT_TRUE(
2551 EXPECT_TRUE(
2556 EXPECT_TRUE(matches(CppString2, returnStmt(forFunction(hasName("F2")))));
2557 EXPECT_TRUE(notMatches(CppString2, returnStmt(forFunction(hasName("F")))));
2570 EXPECT_TRUE(matchAndVerifyResultTrue(
2573 EXPECT_TRUE(matchAndVerifyResultTrue(
2578 EXPECT_TRUE(matchAndVerifyResultTrue(
2581 EXPECT_TRUE(matchAndVerifyResultTrue(
2586 EXPECT_TRUE(notMatches(Code1, ForEachOverriddenInClass("A")));
2593 EXPECT_TRUE(matchAndVerifyResultTrue(
2596 EXPECT_TRUE(matchAndVerifyResultTrue(
2601 EXPECT_TRUE(notMatches(Code2, ForEachOverriddenInClass("A1")));
2610 EXPECT_TRUE(
2613 EXPECT_TRUE(
2616 EXPECT_TRUE(
2619 EXPECT_TRUE(notMatches(Fragment, unresolvedLookupExpr(hasAnyDeclaration(
2628 EXPECT_TRUE(matches(Fragment, substTemplateTypeParmType(hasReplacementType(
2630 EXPECT_TRUE(notMatches(Fragment, substTemplateTypeParmType(hasReplacementType(
2632 EXPECT_TRUE(
2642 EXPECT_TRUE(
2644 EXPECT_TRUE(notMatches("template<typename T> class A {};", Matcher));
tools/clang/unittests/ASTMatchers/Dynamic/ParserTest.cpp 82 EXPECT_TRUE(Sema.Values[0].getBoolean());
140 EXPECT_TRUE(Result.hasValue());
164 EXPECT_TRUE(matchesRange(Bar.NameRange, 1, 1, 8, 17));
170 EXPECT_TRUE(matchesRange(Baz.NameRange, 1, 2, 19, 10));
176 EXPECT_TRUE(matchesRange(Foo.NameRange, 1, 2, 2, 12));
216 EXPECT_TRUE(matches("int x = 1 + false;", M));
226 EXPECT_TRUE(matches("void f(int a, int x);", M));
238 EXPECT_TRUE(matches("void f(int a, int x);", M));
242 EXPECT_TRUE(!Parser::parseMatcherExpression(
260 EXPECT_TRUE(matchesObjC("@interface I @end "
389 EXPECT_TRUE(matchAndVerifyResultTrue(
392 EXPECT_TRUE(matchAndVerifyResultFalse(
405 EXPECT_TRUE(matchAndVerifyResultTrue(
408 EXPECT_TRUE(matchAndVerifyResultFalse(
tools/clang/unittests/ASTMatchers/Dynamic/RegistryTest.cpp 138 EXPECT_TRUE(matches(ClassSnippet, IsArrowValue));
139 EXPECT_TRUE(matches(BoolSnippet, BoolValue));
148 EXPECT_TRUE(matches("class X {};", Value));
153 EXPECT_TRUE(matches("void foo(int,int);", Value));
171 EXPECT_TRUE(matches(code, HasInitializerSimple));
175 EXPECT_TRUE(matches(code, HasInitializerSimple));
176 EXPECT_TRUE(matches(code, HasInitializerComplex));
182 EXPECT_TRUE(matches("void f(int a, int x);", HasParameter));
203 EXPECT_TRUE(matches(Code, CallExpr1));
206 EXPECT_TRUE(matches(Code, CallExpr0));
221 EXPECT_TRUE(matches(Code, DeclDecl));
226 EXPECT_TRUE(matches(Code, NNSL));
237 EXPECT_TRUE(matches("int a;", Var));
239 EXPECT_TRUE(matches("class A {};", Class));
241 EXPECT_TRUE(matches("void f(){};", Func));
249 EXPECT_TRUE(matches("int Foo;", Anything));
250 EXPECT_TRUE(matches("class Foo {};", Anything));
251 EXPECT_TRUE(matches("void Foo(){};", Anything));
253 EXPECT_TRUE(matches("class Foo {};", RecordDecl));
266 EXPECT_TRUE(
278 EXPECT_TRUE(matches("template<typename T> class A {}; A<int> a;",
290 EXPECT_TRUE(matches("int const *b;", M));
297 EXPECT_TRUE(matches("int b[7];", M));
308 EXPECT_TRUE(matches("struct Foo { Foo() : foo(1) {} int foo; };", CtorDecl));
321 EXPECT_TRUE(matches("class X {};", D));
322 EXPECT_TRUE(matches("class Y { class X {}; };", D));
332 EXPECT_TRUE(matches("void foo() { for(int X;;); }", S));
333 EXPECT_TRUE(matches("void foo() { for(;;) { int X; } }", S));
340 EXPECT_TRUE(matches("void foo() { if (true) { int x = 42; } }", S));
353 EXPECT_TRUE(matches("void foo(){}", D));
354 EXPECT_TRUE(matches("struct Foo{};", D));
367 EXPECT_TRUE(matches("struct Foo{};", D));
369 EXPECT_TRUE(matches("class Bar{};", D));
381 EXPECT_TRUE(matches("class OtherBar{ int Foo; };", D));
387 EXPECT_TRUE(matches("void Foo(){}", D));
388 EXPECT_TRUE(notMatches("struct Foo {};", D));
394 EXPECT_TRUE(constructMatcher("hasInitializer", Error.get()).isNull());
398 EXPECT_TRUE(constructMatcher("isArrow", StringRef(), Error.get()).isNull());
402 EXPECT_TRUE(constructMatcher("anyOf", Error.get()).isNull());
406 EXPECT_TRUE(constructMatcher("unless", StringRef(), StringRef(),
413 EXPECT_TRUE(constructMatcher("ofClass", StringRef(), Error.get()).isNull());
418 EXPECT_TRUE(
428 EXPECT_TRUE(constructMatcher("anyOf", StringRef(), StringRef(),
434 EXPECT_TRUE(constructMatcher(
450 EXPECT_TRUE(hasCompletion(
455 EXPECT_TRUE(hasCompletion(Comps, "whileStmt(",
458 EXPECT_TRUE(hasCompletion(
465 EXPECT_TRUE(hasCompletion(WhileComps, "hasBody(",
467 EXPECT_TRUE(hasCompletion(
471 EXPECT_TRUE(
480 EXPECT_TRUE(std::equal(WhileComps.begin(), WhileComps.end(),
488 EXPECT_TRUE(
490 EXPECT_TRUE(hasCompletion(NamedDeclComps, "hasName(\"",
495 EXPECT_TRUE(hasCompletion(
504 EXPECT_TRUE(matches("struct __attribute__((warn_unused)) X {};", Value));
510 EXPECT_TRUE(matches("int i = (1);", Value));
518 EXPECT_TRUE(matches("bool x = true;", BooleanStmt));
525 EXPECT_TRUE(matches("bool x = false;", BooleanStmt));
532 EXPECT_TRUE(matches("double x = 1.2;", DoubleStmt));
538 EXPECT_TRUE(matches("double x = 12e-1;", DoubleStmt));
544 EXPECT_TRUE(matches("int x = 42;", IntegerStmt));
550 EXPECT_TRUE(matches("int x = 'x';", CharStmt));
551 EXPECT_TRUE(matches("int x = L'x';", CharStmt));
552 EXPECT_TRUE(matches("int x = u'x';", CharStmt));
553 EXPECT_TRUE(matches("int x = U'x';", CharStmt));
tools/clang/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp 22 EXPECT_TRUE(Value.isUnsigned());
25 EXPECT_TRUE(Value.hasValue());
34 EXPECT_TRUE(Value.isString());
38 EXPECT_TRUE(Value.hasValue());
46 EXPECT_TRUE(Value.hasValue());
50 EXPECT_TRUE(Value.isMatcher());
52 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<UnaryOperator>());
57 EXPECT_TRUE(Value.isMatcher());
58 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Decl>());
63 EXPECT_TRUE(Value.isMatcher());
66 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Expr>());
67 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<IntegerLiteral>());
74 EXPECT_TRUE(Value.isString());
76 EXPECT_TRUE(Value.hasValue());
84 EXPECT_TRUE(Value.hasValue());
89 EXPECT_TRUE(Value.isMatcher());
90 EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Decl>());
95 EXPECT_TRUE(Value.isBoolean());
97 EXPECT_TRUE(Value.hasValue());
103 EXPECT_TRUE(Value.isDouble());
105 EXPECT_TRUE(Value.hasValue());
112 EXPECT_TRUE(Value.isUnsigned());
116 EXPECT_TRUE(Value.hasValue());
137 EXPECT_TRUE(!Value);
144 EXPECT_TRUE(IfTrue);
149 EXPECT_TRUE(matches("class X {};", VariantValue(VariantMatcher::SingleMatcher(
153 EXPECT_TRUE(
157 EXPECT_TRUE(
tools/clang/unittests/Analysis/CFGDominatorTree.cpp 53 EXPECT_TRUE(Dom.dominates(ExitBlock, ExitBlock));
55 EXPECT_TRUE(Dom.dominates(CaseABlock, ExitBlock));
56 EXPECT_TRUE(Dom.dominates(SwitchBlock, ExitBlock));
57 EXPECT_TRUE(Dom.dominates(EntryBlock, ExitBlock));
59 EXPECT_TRUE(Dom.dominates(CaseABlock, CaseABlock));
61 EXPECT_TRUE(Dom.dominates(SwitchBlock, CaseABlock));
62 EXPECT_TRUE(Dom.dominates(EntryBlock, CaseABlock));
64 EXPECT_TRUE(Dom.dominates(SwitchBlock, SwitchBlock));
66 EXPECT_TRUE(Dom.dominates(EntryBlock, SwitchBlock));
68 EXPECT_TRUE(Dom.dominates(EntryBlock, EntryBlock));
76 EXPECT_TRUE(PostDom.dominates(ExitBlock, EntryBlock));
77 EXPECT_TRUE(PostDom.dominates(CaseABlock, EntryBlock));
78 EXPECT_TRUE(PostDom.dominates(SwitchBlock, EntryBlock));
79 EXPECT_TRUE(PostDom.dominates(EntryBlock, EntryBlock));
82 EXPECT_TRUE(PostDom.dominates(ExitBlock, SwitchBlock));
83 EXPECT_TRUE(PostDom.dominates(CaseABlock, SwitchBlock));
84 EXPECT_TRUE(PostDom.dominates(SwitchBlock, SwitchBlock));
87 EXPECT_TRUE(PostDom.dominates(ExitBlock, CaseABlock));
88 EXPECT_TRUE(PostDom.dominates(CaseABlock, CaseABlock));
91 EXPECT_TRUE(PostDom.dominates(ExitBlock, ExitBlock));
95 EXPECT_TRUE(PostDom.dominates(nullptr, EntryBlock));
96 EXPECT_TRUE(PostDom.dominates(nullptr, SwitchBlock));
97 EXPECT_TRUE(PostDom.dominates(nullptr, CaseABlock));
98 EXPECT_TRUE(PostDom.dominates(nullptr, ExitBlock));
144 EXPECT_TRUE(Control.isControlDependent(SecondThenBlock, SecondIfBlock));
145 EXPECT_TRUE(Control.isControlDependent(SecondIfBlock, FirstIfBlock));
tools/clang/unittests/Analysis/CFGTest.cpp 110 EXPECT_TRUE(ElementRef->getAs<CFGStmt>());
111 EXPECT_TRUE((*ElementRef).getAs<CFGStmt>());
115 EXPECT_TRUE(*MainBlock->ref_begin() < *(MainBlock->ref_begin() + 1));
116 EXPECT_TRUE(*MainBlock->ref_begin() == *MainBlock->ref_begin());
119 EXPECT_TRUE(MainBlock->ref_begin() < MainBlock->ref_begin() + 1);
120 EXPECT_TRUE(MainBlock->ref_begin() == MainBlock->ref_begin());
134 EXPECT_TRUE(ElementRef->getAs<CFGStmt>());
135 EXPECT_TRUE((*ElementRef).getAs<CFGStmt>());
139 EXPECT_TRUE(*CMainBlock->ref_begin() < *(CMainBlock->ref_begin() + 1));
140 EXPECT_TRUE(*CMainBlock->ref_begin() == *CMainBlock->ref_begin());
143 EXPECT_TRUE(CMainBlock->ref_begin() < CMainBlock->ref_begin() + 1);
144 EXPECT_TRUE(CMainBlock->ref_begin() == CMainBlock->ref_begin());
158 EXPECT_TRUE(ElementRef->getAs<CFGStmt>());
159 EXPECT_TRUE((*ElementRef).getAs<CFGStmt>());
164 EXPECT_TRUE(*MainBlock->rref_begin() == *MainBlock->rref_begin());
167 EXPECT_TRUE(MainBlock->rref_begin() < MainBlock->rref_begin() + 1);
168 EXPECT_TRUE(MainBlock->rref_begin() == MainBlock->rref_begin());
181 EXPECT_TRUE(ElementRef->getAs<CFGStmt>());
182 EXPECT_TRUE((*ElementRef).getAs<CFGStmt>());
187 EXPECT_TRUE(*CMainBlock->rref_begin() == *CMainBlock->rref_begin());
190 EXPECT_TRUE(CMainBlock->rref_begin() < CMainBlock->rref_begin() + 1);
191 EXPECT_TRUE(CMainBlock->rref_begin() == CMainBlock->rref_begin());
tools/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp 890 EXPECT_TRUE(isMutated(Results, AST.get()));
899 EXPECT_TRUE(isMutated(Results, AST.get()));
909 EXPECT_TRUE(isMutated(Results, AST.get()));
929 EXPECT_TRUE(isMutated(Results, AST.get()));
939 EXPECT_TRUE(isMutated(Results, AST.get()));
945 EXPECT_TRUE(isMutated(Results, AST.get()));
956 EXPECT_TRUE(isMutated(Results, AST.get()));
967 EXPECT_TRUE(isMutated(Results, AST.get()));
984 EXPECT_TRUE(isMutated(Results, AST.get()));
994 EXPECT_TRUE(isMutated(Results, AST.get()));
1012 EXPECT_TRUE(isMutated(Results, AST.get()));
tools/clang/unittests/Basic/CharInfoTest.cpp 43 EXPECT_TRUE(isASCII('\0'));
44 EXPECT_TRUE(isASCII('\n'));
45 EXPECT_TRUE(isASCII(' '));
46 EXPECT_TRUE(isASCII('a'));
47 EXPECT_TRUE(isASCII('\x7f'));
54 EXPECT_TRUE(isIdentifierHead('a'));
55 EXPECT_TRUE(isIdentifierHead('A'));
56 EXPECT_TRUE(isIdentifierHead('z'));
57 EXPECT_TRUE(isIdentifierHead('Z'));
58 EXPECT_TRUE(isIdentifierHead('_'));
66 EXPECT_TRUE(isIdentifierHead('$', /*AllowDollar=*/true));
74 EXPECT_TRUE(isIdentifierBody('a'));
75 EXPECT_TRUE(isIdentifierBody('A'));
76 EXPECT_TRUE(isIdentifierBody('z'));
77 EXPECT_TRUE(isIdentifierBody('Z'));
78 EXPECT_TRUE(isIdentifierBody('_'));
80 EXPECT_TRUE(isIdentifierBody('0'));
86 EXPECT_TRUE(isIdentifierBody('$', /*AllowDollar=*/true));
102 EXPECT_TRUE(isHorizontalWhitespace(' '));
103 EXPECT_TRUE(isHorizontalWhitespace('\t'));
104 EXPECT_TRUE(isHorizontalWhitespace('\f')); // ??
105 EXPECT_TRUE(isHorizontalWhitespace('\v')); // ??
129 EXPECT_TRUE(isVerticalWhitespace('\n'));
130 EXPECT_TRUE(isVerticalWhitespace('\r'));
146 EXPECT_TRUE(isWhitespace(' '));
147 EXPECT_TRUE(isWhitespace('\t'));
148 EXPECT_TRUE(isWhitespace('\f'));
149 EXPECT_TRUE(isWhitespace('\v'));
151 EXPECT_TRUE(isWhitespace('\n'));
152 EXPECT_TRUE(isWhitespace('\r'));
160 EXPECT_TRUE(isDigit('0'));
161 EXPECT_TRUE(isDigit('9'));
181 EXPECT_TRUE(isHexDigit('0'));
182 EXPECT_TRUE(isHexDigit('9'));
184 EXPECT_TRUE(isHexDigit('a'));
185 EXPECT_TRUE(isHexDigit('A'));
205 EXPECT_TRUE(isLetter('a'));
206 EXPECT_TRUE(isLetter('A'));
208 EXPECT_TRUE(isLetter('z'));
209 EXPECT_TRUE(isLetter('Z'));
227 EXPECT_TRUE(isLowercase('a'));
230 EXPECT_TRUE(isLowercase('z'));
250 EXPECT_TRUE(isUppercase('A'));
253 EXPECT_TRUE(isUppercase('Z'));
268 EXPECT_TRUE(isAlphanumeric('0'));
269 EXPECT_TRUE(isAlphanumeric('9'));
271 EXPECT_TRUE(isAlphanumeric('a'));
272 EXPECT_TRUE(isAlphanumeric('A'));
274 EXPECT_TRUE(isAlphanumeric('z'));
275 EXPECT_TRUE(isAlphanumeric('Z'));
299 EXPECT_TRUE(isPunctuation('.'));
300 EXPECT_TRUE(isPunctuation('_'));
302 EXPECT_TRUE(isPunctuation('/'));
303 EXPECT_TRUE(isPunctuation('('));
315 EXPECT_TRUE(isPrintable('0'));
316 EXPECT_TRUE(isPrintable('9'));
318 EXPECT_TRUE(isPrintable('a'));
319 EXPECT_TRUE(isPrintable('A'));
321 EXPECT_TRUE(isPrintable('z'));
322 EXPECT_TRUE(isPrintable('Z'));
324 EXPECT_TRUE(isPrintable('.'));
325 EXPECT_TRUE(isPrintable('_'));
327 EXPECT_TRUE(isPrintable('/'));
328 EXPECT_TRUE(isPrintable('('));
330 EXPECT_TRUE(isPrintable(' '));
341 EXPECT_TRUE(isPreprocessingNumberBody('0'));
342 EXPECT_TRUE(isPreprocessingNumberBody('9'));
344 EXPECT_TRUE(isPreprocessingNumberBody('a'));
345 EXPECT_TRUE(isPreprocessingNumberBody('A'));
347 EXPECT_TRUE(isPreprocessingNumberBody('z'));
348 EXPECT_TRUE(isPreprocessingNumberBody('Z'));
349 EXPECT_TRUE(isPreprocessingNumberBody('.'));
350 EXPECT_TRUE(isPreprocessingNumberBody('_'));
362 EXPECT_TRUE(isRawStringDelimBody('0'));
363 EXPECT_TRUE(isRawStringDelimBody('9'));
365 EXPECT_TRUE(isRawStringDelimBody('a'));
366 EXPECT_TRUE(isRawStringDelimBody('A'));
368 EXPECT_TRUE(isRawStringDelimBody('z'));
369 EXPECT_TRUE(isRawStringDelimBody('Z'));
370 EXPECT_TRUE(isRawStringDelimBody('.'));
371 EXPECT_TRUE(isRawStringDelimBody('_'));
373 EXPECT_TRUE(isRawStringDelimBody('/'));
429 EXPECT_TRUE(isValidIdentifier("_"));
430 EXPECT_TRUE(isValidIdentifier("a"));
431 EXPECT_TRUE(isValidIdentifier("z"));
432 EXPECT_TRUE(isValidIdentifier("A"));
433 EXPECT_TRUE(isValidIdentifier("Z"));
434 EXPECT_TRUE(isValidIdentifier("$", /*AllowDollar=*/true));
446 EXPECT_TRUE(isValidIdentifier("__"));
447 EXPECT_TRUE(isValidIdentifier("a_"));
448 EXPECT_TRUE(isValidIdentifier("z_"));
449 EXPECT_TRUE(isValidIdentifier("A_"));
450 EXPECT_TRUE(isValidIdentifier("Z_"));
451 EXPECT_TRUE(isValidIdentifier("$_", /*AllowDollar=*/true));
461 EXPECT_TRUE(isValidIdentifier("_1"));
463 EXPECT_TRUE(isValidIdentifier("__"));
464 EXPECT_TRUE(isValidIdentifier("_a"));
465 EXPECT_TRUE(isValidIdentifier("_z"));
466 EXPECT_TRUE(isValidIdentifier("_A"));
467 EXPECT_TRUE(isValidIdentifier("_Z"));
468 EXPECT_TRUE(isValidIdentifier("_$", /*AllowDollar=*/true));
478 EXPECT_TRUE(isValidIdentifier("__1"));
480 EXPECT_TRUE(isValidIdentifier("___"));
481 EXPECT_TRUE(isValidIdentifier("__a"));
482 EXPECT_TRUE(isValidIdentifier("__z"));
483 EXPECT_TRUE(isValidIdentifier("__A"));
484 EXPECT_TRUE(isValidIdentifier("__Z"));
485 EXPECT_TRUE(isValidIdentifier("__$", /*AllowDollar=*/true));
495 EXPECT_TRUE(isValidIdentifier("_1_"));
497 EXPECT_TRUE(isValidIdentifier("___"));
498 EXPECT_TRUE(isValidIdentifier("_a_"));
499 EXPECT_TRUE(isValidIdentifier("_z_"));
500 EXPECT_TRUE(isValidIdentifier("_A_"));
501 EXPECT_TRUE(isValidIdentifier("_Z_"));
502 EXPECT_TRUE(isValidIdentifier("_$_", /*AllowDollar=*/true));
tools/clang/unittests/Basic/DiagnosticTest.cpp 39 EXPECT_TRUE(trap.hasErrorOccurred());
40 EXPECT_TRUE(trap.hasUnrecoverableErrorOccurred());
64 EXPECT_TRUE(Diags.hasErrorOccurred());
66 EXPECT_TRUE(Diags.hasUncompilableErrorOccurred());
67 EXPECT_TRUE(Diags.hasUnrecoverableErrorOccurred());
tools/clang/unittests/Basic/FileManagerTest.cpp 426 EXPECT_TRUE(Ref.isValid());
438 EXPECT_TRUE(BypassRef->isValid());
tools/clang/unittests/Basic/SourceManagerTest.cpp 99 EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(lsqrLoc, idLoc));
100 EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(idLoc, rsqrLoc));
101 EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(macroExpStartLoc, idLoc));
102 EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(idLoc, macroExpEndLoc));
119 EXPECT_TRUE(!Invalid);
123 EXPECT_TRUE(!Invalid);
127 EXPECT_TRUE(!Invalid);
131 EXPECT_TRUE(!Invalid);
136 EXPECT_TRUE(!Invalid);
140 EXPECT_TRUE(Invalid);
145 EXPECT_TRUE(Invalid);
149 EXPECT_TRUE(Invalid);
307 EXPECT_TRUE(defLoc.isFileID());
308 EXPECT_TRUE(loc1.isFileID());
309 EXPECT_TRUE(SourceMgr.isMacroArgExpansion(loc2));
310 EXPECT_TRUE(SourceMgr.isMacroArgExpansion(loc3));
313 EXPECT_TRUE(defLoc2.isFileID());
457 EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Macros[3].Loc, Macros[4].Loc));
461 EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Macros[10].Loc, Macros[11].Loc));
tools/clang/unittests/CrossTU/CrossTranslationUnitTest.cpp 60 EXPECT_TRUE(llvm::sys::fs::exists(IndexFileName));
71 EXPECT_TRUE(llvm::sys::fs::exists(SourceFileName));
76 EXPECT_TRUE(llvm::sys::fs::exists(ASTFileName));
91 EXPECT_TRUE(SLocResult);
100 EXPECT_TRUE(FDWithDefinition);
103 EXPECT_TRUE(FDWithDefinition->isThisDeclarationADefinition());
137 EXPECT_TRUE(tooling::runToolOnCode(std::make_unique<CTUAction>(&Success, 1u),
139 EXPECT_TRUE(Success);
144 EXPECT_TRUE(tooling::runToolOnCode(std::make_unique<CTUAction>(&Success, 0u),
163 EXPECT_TRUE(llvm::sys::fs::exists(IndexFileName));
166 EXPECT_TRUE((bool)IndexOrErr);
169 EXPECT_TRUE(ParsedIndex.count(E.getKey()));
173 EXPECT_TRUE(Index.count(E.getKey()));
188 EXPECT_TRUE(llvm::sys::fs::exists(IndexFileName));
191 EXPECT_TRUE((bool)IndexOrErr);
tools/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp 246 EXPECT_TRUE(WaitForExpectedStateResult.wait_for(std::chrono::seconds(3)) ==
250 EXPECT_TRUE(TestConsumer.result().hasValue());
252 EXPECT_TRUE(*TestConsumer.result());
tools/clang/unittests/Driver/ModuleCacheTest.cpp 24 EXPECT_TRUE(Path.find("org.llvm.clang") != Path.npos);
25 EXPECT_TRUE(Path.endswith("ModuleCache"));
tools/clang/unittests/Driver/ToolChainTest.cpp 64 EXPECT_TRUE(C);
104 EXPECT_TRUE(C);
149 EXPECT_TRUE(CC);
150 EXPECT_TRUE(CXX);
151 EXPECT_TRUE(CL);
152 EXPECT_TRUE(CCDriver.CCCIsCC());
153 EXPECT_TRUE(CXXDriver.CCCIsCXX());
154 EXPECT_TRUE(CLDriver.IsCLMode());
164 EXPECT_TRUE(C);
165 EXPECT_TRUE(C->containsError());
170 EXPECT_TRUE(Empty.TargetPrefix.empty());
171 EXPECT_TRUE(Empty.ModeSuffix.empty());
172 EXPECT_TRUE(Empty.DriverMode == nullptr);
176 EXPECT_TRUE(DriverOnly.TargetPrefix.empty());
177 EXPECT_TRUE(DriverOnly.ModeSuffix == "clang");
178 EXPECT_TRUE(DriverOnly.DriverMode == nullptr);
182 EXPECT_TRUE(DriverOnly2.TargetPrefix.empty());
183 EXPECT_TRUE(DriverOnly2.ModeSuffix == "clang++");
188 EXPECT_TRUE(TargetAndMode.TargetPrefix == "i386");
189 EXPECT_TRUE(TargetAndMode.ModeSuffix == "clang-g++");
191 EXPECT_TRUE(TargetAndMode.TargetIsValid);
201 EXPECT_TRUE(Res.TargetPrefix.empty());
202 EXPECT_TRUE(Res.ModeSuffix == "clang");
203 EXPECT_TRUE(Res.DriverMode == nullptr);
207 EXPECT_TRUE(Res.TargetPrefix.empty());
208 EXPECT_TRUE(Res.ModeSuffix == "clang++");
213 EXPECT_TRUE(Res.TargetPrefix.empty());
214 EXPECT_TRUE(Res.ModeSuffix == "clang++");
219 EXPECT_TRUE(Res.TargetPrefix.empty());
220 EXPECT_TRUE(Res.ModeSuffix == "clang++");
225 EXPECT_TRUE(Res.TargetPrefix == "x86_64");
226 EXPECT_TRUE(Res.ModeSuffix == "clang++");
228 EXPECT_TRUE(Res.TargetIsValid);
232 EXPECT_TRUE(Res.TargetPrefix == "x86_64-linux-gnu");
233 EXPECT_TRUE(Res.ModeSuffix == "clang-c++");
235 EXPECT_TRUE(Res.TargetIsValid);
239 EXPECT_TRUE(Res.TargetPrefix == "x86_64-linux-gnu");
240 EXPECT_TRUE(Res.ModeSuffix == "clang-c++");
242 EXPECT_TRUE(Res.TargetIsValid);
245 EXPECT_TRUE(Res.TargetPrefix.empty());
246 EXPECT_TRUE(Res.ModeSuffix.empty());
247 EXPECT_TRUE(Res.DriverMode == nullptr);
251 EXPECT_TRUE(Res.TargetPrefix.empty());
252 EXPECT_TRUE(Res.ModeSuffix.empty());
253 EXPECT_TRUE(Res.DriverMode == nullptr);
257 EXPECT_TRUE(Res.TargetPrefix == "qqq");
258 EXPECT_TRUE(Res.ModeSuffix == "clang-cl");
tools/clang/unittests/Format/CleanupTest.cpp 32 EXPECT_TRUE(static_cast<bool>(Result));
310 EXPECT_TRUE(static_cast<bool>(CleanReplaces))
313 EXPECT_TRUE(static_cast<bool>(Result));
320 EXPECT_TRUE(static_cast<bool>(CleanReplaces))
323 EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
326 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Format/FormatTest.cpp 50 EXPECT_TRUE(static_cast<bool>(Result));
12305 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
12306 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
12310 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
12311 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
12315 EXPECT_TRUE(
12317 EXPECT_TRUE(
12322 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
12323 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
12327 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
12328 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
12332 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
12333 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
12337 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
12338 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
14382 EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
14385 EXPECT_TRUE(static_cast<bool>(Result));
14411 EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
14414 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Format/FormatTestCSharp.cpp 28 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Format/FormatTestComments.cpp 53 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Format/FormatTestJS.cpp 29 EXPECT_TRUE(Status.FormatComplete);
31 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Format/FormatTestJava.cpp 28 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Format/FormatTestObjC.cpp 54 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Format/FormatTestProto.cpp 28 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Format/FormatTestRawStrings.cpp 48 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Format/FormatTestSelective.cpp 29 EXPECT_TRUE(Status.FormatComplete) << Code << "\n\n";
31 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Format/FormatTestTableGen.cpp 28 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Format/FormatTestTextProto.cpp 28 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Format/NamespaceEndCommentsFixerTest.cpp 32 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Format/SortImportsTestJS.cpp 29 EXPECT_TRUE(static_cast<bool>(Sorted));
32 EXPECT_TRUE(static_cast<bool>(Formatted));
tools/clang/unittests/Format/SortImportsTestJava.cpp 20 EXPECT_TRUE(static_cast<bool>(Sorted));
23 EXPECT_TRUE(static_cast<bool>(Result));
284 EXPECT_TRUE(
291 EXPECT_TRUE(
tools/clang/unittests/Format/SortIncludesTest.cpp 34 EXPECT_TRUE(static_cast<bool>(Sorted));
37 EXPECT_TRUE(static_cast<bool>(Result));
152 EXPECT_TRUE(sortIncludes(FmtStyle, Code, GetCodeRange(Code), "a.cc").empty());
tools/clang/unittests/Format/UsingDeclarationsSorterTest.cpp 30 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Frontend/ASTUnitTest.cpp 71 EXPECT_TRUE(PolicyWithDefaultLangOpt.UseVoidForZeroParams);
87 EXPECT_TRUE(llvm::sys::fs::exists(ASTFileName));
tools/clang/unittests/Frontend/CodeGenActionTest.cpp 55 EXPECT_TRUE(Compiler.hasDiagnostics());
59 EXPECT_TRUE(Success);
tools/clang/unittests/Frontend/OutputStreamTest.cpp 43 EXPECT_TRUE(Success);
44 EXPECT_TRUE(!IRBuffer.empty());
45 EXPECT_TRUE(StringRef(IRBuffer.data()).startswith("BC"));
70 EXPECT_TRUE(!VerboseStream.str().empty());
71 EXPECT_TRUE(StringRef(VerboseBuffer.data()).contains("errors generated"));
100 EXPECT_TRUE(!VerboseBuffer.empty());
101 EXPECT_TRUE(StringRef(VerboseBuffer.data()).contains("errors generated"));
tools/clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp 34 EXPECT_TRUE(Out.empty());
40 EXPECT_TRUE(Out.empty());
tools/clang/unittests/Lex/LexerTest.cpp 293 EXPECT_TRUE(Lexer::isAtStartOfMacroExpansion(lsqrLoc, SourceMgr, LangOpts, &Loc));
297 EXPECT_TRUE(Lexer::isAtEndOfMacroExpansion(rsqrLoc, SourceMgr, LangOpts, &Loc));
299 EXPECT_TRUE(macroRange.isTokenRange());
303 EXPECT_TRUE(range.isInvalid());
306 EXPECT_TRUE(range.isInvalid());
309 EXPECT_TRUE(!range.isTokenRange());
387 EXPECT_TRUE(MI->isFunctionLike());
431 EXPECT_TRUE(hasNewLineEscaped("\\\r"));
432 EXPECT_TRUE(hasNewLineEscaped("\\\n"));
433 EXPECT_TRUE(hasNewLineEscaped("\\\r\n"));
434 EXPECT_TRUE(hasNewLineEscaped("\\\n\r"));
435 EXPECT_TRUE(hasNewLineEscaped("\\ \t\v\f\r"));
436 EXPECT_TRUE(hasNewLineEscaped("\\ \t\v\f\r\n"));
480 EXPECT_TRUE(Lex(" // \\\n").empty());
481 EXPECT_TRUE(Lex("#include <\\\\").empty());
482 EXPECT_TRUE(Lex("#include <\\\\\n").empty());
532 EXPECT_TRUE(
534 EXPECT_TRUE(
tools/clang/unittests/Lex/PPConditionalDirectiveRecordTest.cpp 103 EXPECT_TRUE(PPRec->rangeIntersectsConditionalDirective(
107 EXPECT_TRUE(PPRec->rangeIntersectsConditionalDirective(
109 EXPECT_TRUE(PPRec->rangeIntersectsConditionalDirective(
115 EXPECT_TRUE(PPRec->rangeIntersectsConditionalDirective(
120 EXPECT_TRUE(PPRec->areInDifferentConditionalDirectiveRegion(
124 EXPECT_TRUE(PPRec->areInDifferentConditionalDirectiveRegion(
126 EXPECT_TRUE(PPRec->areInDifferentConditionalDirectiveRegion(
130 EXPECT_TRUE(PPRec->areInDifferentConditionalDirectiveRegion(
tools/clang/unittests/Rename/ClangRenameTest.h 99 EXPECT_TRUE(static_cast<bool>(ChangedCode));
tools/clang/unittests/Sema/GslOwnerPointerInference.cpp 17 EXPECT_TRUE(matches("template<class T>"
29 EXPECT_TRUE(matches("template<class T>"
41 EXPECT_TRUE(matches("template<class T>"
tools/clang/unittests/Serialization/InMemoryModuleCacheTest.cpp 63 EXPECT_TRUE(Cache.isPCMFinal("B"));
87 EXPECT_TRUE(Cache.shouldBuildPCM("B"));
98 EXPECT_TRUE(Cache.isPCMFinal("B"));
101 EXPECT_TRUE(Cache.tryToDropPCM("B"));
116 EXPECT_TRUE(Cache.isPCMFinal("B"));
tools/clang/unittests/StaticAnalyzer/AnalyzerOptionsTest.cpp 26 EXPECT_TRUE(llvm::any_of(AllCheckers, IsAlphaChecker));
54 EXPECT_TRUE(Opts.getCheckerBooleanOption(&CheckerOne, "Option"));
56 EXPECT_TRUE(Opts.getCheckerBooleanOption(&CheckerOne, "Option", true));
59 EXPECT_TRUE(Opts.getCheckerBooleanOption(&CheckerOne, "Option2", true));
85 EXPECT_TRUE("StringValue" ==
92 EXPECT_TRUE("StringValue" == Opts.getCheckerStringOption(
tools/clang/unittests/StaticAnalyzer/CallDescriptionTest.cpp 69 EXPECT_TRUE(LookupResult && *LookupResult);
102 EXPECT_TRUE(tooling::runToolOnCode(
109 EXPECT_TRUE(tooling::runToolOnCode(
116 EXPECT_TRUE(tooling::runToolOnCode(
123 EXPECT_TRUE(tooling::runToolOnCode(
140 EXPECT_TRUE(tooling::runToolOnCode(
148 EXPECT_TRUE(tooling::runToolOnCode(
tools/clang/unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp 83 EXPECT_TRUE(runCheckerOnCode<CustomChecker>("void f() {;}", Diags));
99 EXPECT_TRUE(
tools/clang/unittests/StaticAnalyzer/StoreTest.cpp 99 EXPECT_TRUE(tooling::runToolOnCode(std::make_unique<VariableBindAction>(),
tools/clang/unittests/StaticAnalyzer/SymbolReaperTest.cpp 39 EXPECT_TRUE(SymReaper.isLiveRegion(VR));
64 EXPECT_TRUE(
tools/clang/unittests/Tooling/ASTSelectionTest.cpp 74 EXPECT_TRUE(Visitor.runOver(Source, Language));
99 EXPECT_TRUE(!!ND);
159 EXPECT_TRUE(Node);
186 EXPECT_TRUE(Node);
201 EXPECT_TRUE(Node);
225 EXPECT_TRUE(Node);
241 EXPECT_TRUE(Node);
257 EXPECT_TRUE(Node);
281 EXPECT_TRUE(Node);
311 EXPECT_TRUE(Node);
332 EXPECT_TRUE(Node);
354 EXPECT_TRUE(Node);
402 EXPECT_TRUE(Node);
418 EXPECT_TRUE(Node);
434 EXPECT_TRUE(Node);
457 EXPECT_TRUE(Node);
484 EXPECT_TRUE(Node);
510 EXPECT_TRUE(Node);
530 EXPECT_TRUE(Node);
541 EXPECT_TRUE(Node);
693 EXPECT_TRUE(Node);
701 EXPECT_TRUE(Node);
710 EXPECT_TRUE(Node);
719 EXPECT_TRUE(Node);
722 EXPECT_TRUE(SelectedCode);
724 EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
728 EXPECT_TRUE(
731 EXPECT_TRUE(isa<FunctionDecl>(Parents[1].get().Node.get<Decl>()));
733 EXPECT_TRUE(isa<CompoundStmt>(Parents[2].get().Node.get<Stmt>()));
739 EXPECT_TRUE(Node);
742 EXPECT_TRUE(SelectedCode);
744 EXPECT_TRUE(isa<CallExpr>((*SelectedCode)[0]));
745 EXPECT_TRUE(isa<IfStmt>((*SelectedCode)[1]));
749 EXPECT_TRUE(
752 EXPECT_TRUE(isa<FunctionDecl>(Parents[1].get().Node.get<Decl>()));
754 EXPECT_TRUE(isa<CompoundStmt>(Parents[2].get().Node.get<Stmt>()));
760 EXPECT_TRUE(Node);
763 EXPECT_TRUE(SelectedCode);
765 EXPECT_TRUE(isa<CallExpr>((*SelectedCode)[0]));
766 EXPECT_TRUE(isa<IfStmt>((*SelectedCode)[1]));
767 EXPECT_TRUE(isa<BinaryOperator>((*SelectedCode)[2]));
773 EXPECT_TRUE(Node);
774 EXPECT_TRUE(Node);
777 EXPECT_TRUE(SelectedCode);
779 EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
780 EXPECT_TRUE(isa<CallExpr>((*SelectedCode)[1]));
781 EXPECT_TRUE(isa<IfStmt>((*SelectedCode)[2]));
782 EXPECT_TRUE(isa<BinaryOperator>((*SelectedCode)[3]));
794 EXPECT_TRUE(Node);
797 EXPECT_TRUE(SelectedCode);
799 EXPECT_TRUE(isa<BinaryOperator>((*SelectedCode)[0]));
803 EXPECT_TRUE(
806 EXPECT_TRUE(isa<VarDecl>(Parents[1].get().Node.get<Decl>()));
822 EXPECT_TRUE(Node);
825 EXPECT_TRUE(SelectedCode);
827 EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
831 EXPECT_TRUE(
834 EXPECT_TRUE(isa<FunctionDecl>(Parents[1].get().Node.get<Decl>()));
836 EXPECT_TRUE(isa<CompoundStmt>(Parents[2].get().Node.get<Stmt>()));
838 EXPECT_TRUE(isa<CompoundStmt>(Parents[3].get().Node.get<Stmt>()));
852 EXPECT_TRUE(Node);
855 EXPECT_TRUE(SelectedCode);
857 EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
861 EXPECT_TRUE(
864 EXPECT_TRUE(isa<FunctionDecl>(Parents[1].get().Node.get<Decl>()));
866 EXPECT_TRUE(isa<CompoundStmt>(Parents[2].get().Node.get<Stmt>()));
880 EXPECT_TRUE(Node);
883 EXPECT_TRUE(SelectedCode);
885 EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
889 EXPECT_TRUE(
892 EXPECT_TRUE(isa<FunctionDecl>(Parents[1].get().Node.get<Decl>()));
894 EXPECT_TRUE(isa<CompoundStmt>(Parents[2].get().Node.get<Stmt>()));
919 EXPECT_TRUE(Node);
929 EXPECT_TRUE(Node);
932 EXPECT_TRUE(SelectedCode);
934 EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
938 EXPECT_TRUE(
941 EXPECT_TRUE(isa<ObjCImplDecl>(Parents[1].get().Node.get<Decl>()));
943 EXPECT_TRUE(isa<ObjCMethodDecl>(Parents[2].get().Node.get<Decl>()));
945 EXPECT_TRUE(isa<CompoundStmt>(Parents[3].get().Node.get<Stmt>()));
952 EXPECT_TRUE(Node);
955 EXPECT_TRUE(SelectedCode);
957 EXPECT_TRUE(isa<ObjCMessageExpr>((*SelectedCode)[0]));
958 EXPECT_TRUE(isa<IfStmt>((*SelectedCode)[1]));
962 EXPECT_TRUE(
965 EXPECT_TRUE(isa<ObjCImplDecl>(Parents[1].get().Node.get<Decl>()));
967 EXPECT_TRUE(isa<ObjCMethodDecl>(Parents[2].get().Node.get<Decl>()));
969 EXPECT_TRUE(isa<CompoundStmt>(Parents[3].get().Node.get<Stmt>()));
984 EXPECT_TRUE(Node);
987 EXPECT_TRUE(SelectedCode);
989 EXPECT_TRUE(isa<ObjCStringLiteral>((*SelectedCode)[0]));
996 EXPECT_TRUE(Node);
999 EXPECT_TRUE(SelectedCode);
1001 EXPECT_TRUE(isa<ObjCStringLiteral>((*SelectedCode)[0]));
1027 EXPECT_TRUE(Node);
1030 EXPECT_TRUE(SelectedCode);
1032 EXPECT_TRUE(isa<CXXMemberCallExpr>((*SelectedCode)[0]));
1038 EXPECT_TRUE(Node);
1041 EXPECT_TRUE(SelectedCode);
1043 EXPECT_TRUE(isa<CXXMemberCallExpr>((*SelectedCode)[0]));
1049 EXPECT_TRUE(Node);
1052 EXPECT_TRUE(SelectedCode);
1070 EXPECT_TRUE(Node);
1074 EXPECT_TRUE(SelectedCode);
1076 EXPECT_TRUE(isa<CallExpr>((*SelectedCode)[0]));
1077 EXPECT_TRUE(isa<CompoundStmt>(
tools/clang/unittests/Tooling/CastExprTest.cpp 29 EXPECT_TRUE(isa<DeclRefExpr>(Sub))
tools/clang/unittests/Tooling/CommentHandlerTest.cpp 33 EXPECT_TRUE(Verified) << "CommentVerifier not accessed";
46 EXPECT_TRUE(!Invalid) << "Invalid line number on comment " << C;
49 EXPECT_TRUE(!Invalid) << "Invalid column number on comment " << C;
104 EXPECT_TRUE(Current == End) << "Unexpected comment \""
111 EXPECT_TRUE(Current != End) << "Comment " << Message << " not found";
115 EXPECT_TRUE(C.Message == Message && C.Line == Line && C.Col == Col)
133 EXPECT_TRUE(Visitor.runOver("class X {}; int main() { return 0; }"));
139 EXPECT_TRUE(Visitor.runOver(
147 EXPECT_TRUE(Visitor.runOver(
160 EXPECT_TRUE(Visitor.runOver(
171 EXPECT_TRUE(Visitor.runOver(
206 EXPECT_TRUE(Visitor.runOver(Source));
213 EXPECT_TRUE(Visitor.runOver(
tools/clang/unittests/Tooling/CompilationDatabaseTest.cpp 252 EXPECT_TRUE(find("//net/aa/file.cc").empty());
264 EXPECT_TRUE(find("//net/some/path").empty());
288 EXPECT_TRUE(NotFound.CommandLine.empty()) << ErrorMessage;
289 EXPECT_TRUE(NotFound.Directory.empty()) << ErrorMessage;
317 EXPECT_TRUE(NotFound.Directory.empty()) << ErrorMessage;
318 EXPECT_TRUE(NotFound.CommandLine.empty()) << ErrorMessage;
405 EXPECT_TRUE(ErrorMessage.empty()) << ErrorMessage;
411 EXPECT_TRUE(Result.empty());
456 EXPECT_TRUE(Result[0].empty()) << Result[0];
540 EXPECT_TRUE(ErrorMsg.empty());
551 EXPECT_TRUE(ErrorMsg.empty());
813 EXPECT_TRUE(CCRef == CCTest);
819 EXPECT_TRUE(CCRef != CCTest);
824 EXPECT_TRUE(CCRef != CCTest);
829 EXPECT_TRUE(CCRef != CCTest);
834 EXPECT_TRUE(CCRef != CCTest);
tools/clang/unittests/Tooling/DiagnosticsYamlTest.cpp 171 EXPECT_TRUE(Fixes3.empty());
tools/clang/unittests/Tooling/FixItTest.cpp 86 EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
87 EXPECT_TRUE(Hint.CodeToInsert.empty());
92 EXPECT_TRUE(Hint0.InsertFromRange.isInvalid());
93 EXPECT_TRUE(Hint0.CodeToInsert.empty());
98 EXPECT_TRUE(Hint1.InsertFromRange.isInvalid());
99 EXPECT_TRUE(Hint1.CodeToInsert.empty());
121 EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
122 EXPECT_TRUE(Hint.CodeToInsert.empty());
130 EXPECT_TRUE(Hint0.InsertFromRange.isInvalid());
131 EXPECT_TRUE(Hint0.CodeToInsert.empty());
139 EXPECT_TRUE(Hint1.InsertFromRange.isInvalid());
140 EXPECT_TRUE(Hint1.CodeToInsert.empty());
151 EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
152 EXPECT_TRUE(Hint.CodeToInsert.empty());
169 EXPECT_TRUE(Hint0.InsertFromRange.isInvalid());
174 EXPECT_TRUE(Hint1.InsertFromRange.isInvalid());
199 EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
200 EXPECT_TRUE(Hint.CodeToInsert.empty());
214 EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
225 EXPECT_TRUE(Hint.InsertFromRange.isInvalid());
tools/clang/unittests/Tooling/HeaderIncludesTest.cpp 30 EXPECT_TRUE(static_cast<bool>(Result));
39 EXPECT_TRUE(static_cast<bool>(Result));
tools/clang/unittests/Tooling/LexicallyOrderedRecursiveASTVisitorTest.cpp 143 EXPECT_TRUE(Visitor.runOver(Source, DummyMatchVisitor::Lang_OBJC));
167 EXPECT_TRUE(Visitor.runOver(Source, DummyMatchVisitor::Lang_OBJC));
181 EXPECT_TRUE(Visitor.runOver(Source));
223 EXPECT_TRUE(Visitor.runOver(Source));
tools/clang/unittests/Tooling/QualTypeNamesTest.cpp 38 EXPECT_TRUE(false) << "Typename::getFullyQualifiedName failed for "
tools/clang/unittests/Tooling/RecursiveASTVisitorTestDeclVisitor.cpp 26 EXPECT_TRUE(Visitor.runOver(
54 EXPECT_TRUE(Visitor.runOver(
84 EXPECT_TRUE(Visitor.runOver(
94 EXPECT_TRUE(Visitor.runOver(
102 EXPECT_TRUE(Visitor.runOver(
112 EXPECT_TRUE(Visitor.runOver(
120 EXPECT_TRUE(Visitor.runOver(
131 EXPECT_TRUE(Visitor.runOver(
tools/clang/unittests/Tooling/RecursiveASTVisitorTestTypeLocVisitor.cpp 26 EXPECT_TRUE(Visitor.runOver("class X {}; class Y : public X {};"));
32 EXPECT_TRUE(Visitor.runOver(
41 EXPECT_TRUE(Visitor.runOver(
49 EXPECT_TRUE(Visitor.runOver(
57 EXPECT_TRUE(Visitor.runOver(
66 EXPECT_TRUE(Visitor.runOver(
74 EXPECT_TRUE(Visitor.runOver(
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/Attr.cpp 42 EXPECT_TRUE(Visitor.runOver(
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/CXXBoolLiteralExpr.cpp 30 EXPECT_TRUE(Visitor.runOver(
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/CXXMemberCall.cpp 28 EXPECT_TRUE(Visitor.runOver(
39 EXPECT_TRUE(Visitor.runOver(
52 EXPECT_TRUE(Visitor.runOver(
70 EXPECT_TRUE(Visitor.runOver(
87 EXPECT_TRUE(Visitor.runOver(
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/CXXMethodDecl.cpp 55 EXPECT_TRUE(Visitor.runOver(Code, CXXMethodDeclVisitor::Lang_CXX11));
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/CXXOperatorCallExprTraverser.cpp 30 EXPECT_TRUE(Visitor.runOver(
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/Class.cpp 36 EXPECT_TRUE(Visitor.runOver("auto lambda = []{};", ClassVisitor::Lang_CXX11));
37 EXPECT_TRUE(Visitor.sawOnlyImplicitLambdaClasses());
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/ConstructExpr.cpp 53 EXPECT_TRUE(Visitor.runOver(
69 EXPECT_TRUE(Visitor.runOver(
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/DeclRefExpr.cpp 37 EXPECT_TRUE(Visitor.runOver(
45 EXPECT_TRUE(Visitor.runOver(
54 EXPECT_TRUE(Visitor.runOver(
61 EXPECT_TRUE(Visitor.runOver(
69 EXPECT_TRUE(Visitor.runOver(
82 EXPECT_TRUE(Visitor.runOver(
90 EXPECT_TRUE(Visitor.runOver(
110 EXPECT_TRUE(Visitor.runOver(
117 EXPECT_TRUE(Visitor.runOver("void f(int(^)(int)); \n"
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/ImplicitCtor.cpp 36 EXPECT_TRUE(Visitor.runOver(
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/ImplicitCtorInitializer.cpp 53 EXPECT_TRUE(Visitor.runOver(Code, CXXCtorInitializerVisitor::Lang_CXX));
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/InitListExprPostOrder.cpp 30 EXPECT_TRUE(Visitor.runOver("struct S { int x; };\n"
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/InitListExprPostOrderNoQueue.cpp 34 EXPECT_TRUE(Visitor.runOver("struct S { int x; };\n"
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/InitListExprPreOrder.cpp 38 EXPECT_TRUE(Visitor.runOver("struct S { int x; };\n"
47 EXPECT_TRUE(Visitor.runOver("struct S { int x; };\n"
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/InitListExprPreOrderNoQueue.cpp 32 EXPECT_TRUE(Visitor.runOver("struct S { int x; };\n"
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/IntegerLiteral.cpp 28 EXPECT_TRUE(Visitor.runOver("int f(int i = 1);\n"
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/LambdaDefaultCapture.cpp 30 EXPECT_TRUE(Visitor.runOver("void f() { int a; [=]{a;}; }",
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/LambdaExpr.cpp 51 EXPECT_TRUE(Visitor.runOver("void f() { []{ return; }(); }",
53 EXPECT_TRUE(Visitor.allBodiesHaveBeenTraversed());
61 EXPECT_TRUE(Visitor.runOver("void f() { []{ []{ return; }; }(); }",
63 EXPECT_TRUE(Visitor.allBodiesHaveBeenTraversed());
72 EXPECT_TRUE(Visitor.runOver("auto x = []{ [] {}; };",
74 EXPECT_TRUE(Visitor.allBodiesHaveBeenTraversed());
75 EXPECT_TRUE(Visitor.allClassesHaveBeenTraversed());
82 EXPECT_TRUE(Visitor.runOver("void f() { []{ return; }(); }",
84 EXPECT_TRUE(Visitor.allBodiesHaveBeenTraversed());
85 EXPECT_TRUE(Visitor.allClassesHaveBeenTraversed());
93 EXPECT_TRUE(Visitor.runOver(
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/LambdaTemplateParams.cpp 46 EXPECT_TRUE(Visitor.runOver(
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/NestedNameSpecifiers.cpp 70 EXPECT_TRUE(Visitor.runOver(Source, NestedNameSpecifiersVisitor::Lang_CXX14));
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/ParenExpr.cpp 26 EXPECT_TRUE(Visitor.runOver("int k = (4) + 9;\n"));
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/TemplateArgumentLocTraverser.cpp 33 EXPECT_TRUE(Visitor.runOver(
tools/clang/unittests/Tooling/RefactoringCallbacksTest.cpp 32 EXPECT_TRUE(tooling::applyAllReplacements(FileToReplace["input.cc"],
tools/clang/unittests/Tooling/RefactoringTest.cpp 40 EXPECT_TRUE(Replace.apply(Context.Rewrite));
48 EXPECT_TRUE(Replace.apply(Context.Rewrite));
56 EXPECT_TRUE(Replace.apply(Context.Rewrite));
65 EXPECT_TRUE(Replace.apply(Context.Rewrite));
74 EXPECT_TRUE(Replace1.apply(Context.Rewrite));
81 EXPECT_TRUE(Replace2.apply(Context.Rewrite));
97 EXPECT_TRUE(Replace1.getFilePath().empty());
100 EXPECT_TRUE(Replace2.getFilePath().empty());
147 EXPECT_TRUE(!Err);
152 EXPECT_TRUE(checkReplacementError(std::move(Err),
158 EXPECT_TRUE(checkReplacementError(std::move(Err),
164 EXPECT_TRUE(checkReplacementError(std::move(Err),
176 EXPECT_TRUE(!Err);
179 EXPECT_TRUE(!Err);
182 EXPECT_TRUE(!Err);
191 EXPECT_TRUE(!Err);
194 EXPECT_TRUE(!Err);
201 EXPECT_TRUE(!Err);
211 EXPECT_TRUE(!Err);
214 EXPECT_TRUE(!Err);
221 EXPECT_TRUE(!Err);
224 EXPECT_TRUE(!Err);
233 EXPECT_TRUE(!Err);
237 EXPECT_TRUE(!Err);
241 EXPECT_TRUE(!Err);
245 EXPECT_TRUE(!Err);
255 EXPECT_TRUE(!Err);
259 EXPECT_TRUE(!Err);
264 EXPECT_TRUE(!Err);
269 EXPECT_TRUE(!Err);
282 EXPECT_TRUE(!Err);
286 EXPECT_TRUE(!Err);
291 EXPECT_TRUE(!Err);
302 EXPECT_TRUE(!Err);
306 EXPECT_TRUE(!Err);
313 EXPECT_TRUE(!Err);
323 EXPECT_TRUE(!Err);
328 EXPECT_TRUE(!Err);
332 EXPECT_TRUE(!Err);
344 EXPECT_TRUE(!Err);
347 EXPECT_TRUE(!Err);
354 EXPECT_TRUE(checkReplacementError(std::move(Err),
359 EXPECT_TRUE(!Err);
366 EXPECT_TRUE(!Err);
369 EXPECT_TRUE(!Err);
375 EXPECT_TRUE(!Err);
378 EXPECT_TRUE(!Err);
386 EXPECT_TRUE(!Err);
390 EXPECT_TRUE(checkReplacementError(std::move(Err),
396 EXPECT_TRUE(!Err);
399 EXPECT_TRUE(!Err);
406 EXPECT_TRUE(!Err);
409 EXPECT_TRUE(!Err);
412 EXPECT_TRUE(!Err);
422 EXPECT_TRUE(!Err);
425 EXPECT_TRUE(!Err);
428 EXPECT_TRUE(!Err);
440 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
453 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
463 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
475 EXPECT_TRUE(!Err);
480 EXPECT_TRUE(!Err);
483 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
496 EXPECT_TRUE(checkReplacementError(std::move(Err),
500 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
541 EXPECT_TRUE(
642 EXPECT_TRUE(applyAllReplacements(Replaces, Context.Rewrite));
713 EXPECT_TRUE(ClassDeclX.runOver(" class X;"));
719 EXPECT_TRUE(ClassDeclX.runOver("#define A(Y) Y\nA(class X);"));
736 EXPECT_TRUE(CallToF.runOver("void F(); void G() { F(); }"));
742 EXPECT_TRUE(CallToF.runOver(
766 EXPECT_TRUE(VisitNNSA.runOver("namespace a { void f() { ::a::f(); } }"));
771 EXPECT_TRUE(Range(10, 10).overlapsWith(Range(0, 11)));
772 EXPECT_TRUE(Range(0, 11).overlapsWith(Range(10, 10)));
775 EXPECT_TRUE(Range(0, 10).overlapsWith(Range(2, 6)));
776 EXPECT_TRUE(Range(2, 6).overlapsWith(Range(0, 10)));
780 EXPECT_TRUE(Range(0, 10).contains(Range(0, 10)));
781 EXPECT_TRUE(Range(0, 10).contains(Range(2, 6)));
796 EXPECT_TRUE(Ranges[0].getOffset() == 0);
797 EXPECT_TRUE(Ranges[0].getLength() == 0);
798 EXPECT_TRUE(Ranges[1].getOffset() == 6);
799 EXPECT_TRUE(Ranges[1].getLength() == 22);
922 EXPECT_TRUE(static_cast<bool>(AfterFirst));
924 EXPECT_TRUE(static_cast<bool>(InSequenceRewrite));
930 EXPECT_TRUE(static_cast<bool>(MergedRewrite));
940 EXPECT_TRUE(static_cast<bool>(AfterFirst));
944 EXPECT_TRUE(static_cast<bool>(MergedRewrite));
1045 EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
1046 EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
1066 EXPECT_TRUE(VFS->addFile(Path1, 0, llvm::MemoryBuffer::getMemBuffer("")));
1067 EXPECT_TRUE(VFS->addFile(Path2, 0, llvm::MemoryBuffer::getMemBuffer("")));
1090 EXPECT_TRUE(FileToReplaces.empty());
1207 EXPECT_TRUE((bool)Err);
1261 EXPECT_TRUE(checkReplacementError(
1278 EXPECT_TRUE(
1292 EXPECT_TRUE(checkReplacementError(
tools/clang/unittests/Tooling/ReplacementTest.h 31 EXPECT_TRUE(!Err);
tools/clang/unittests/Tooling/RewriterTest.cpp 34 EXPECT_TRUE(Context.Rewrite.overwriteChangedFiles());
42 EXPECT_TRUE(!Err);
47 EXPECT_TRUE(static_cast<bool>(Rewritten));
tools/clang/unittests/Tooling/StencilTest.cpp 169 EXPECT_TRUE(llvm::errorToBool(ResultOrErr.takeError()))
tools/clang/unittests/Tooling/ToolingTest.cpp 65 EXPECT_TRUE(runToolOnCode(
105 EXPECT_TRUE(runToolOnCode(
109 EXPECT_TRUE(FoundClassDeclX);
112 EXPECT_TRUE(runToolOnCode(
122 EXPECT_TRUE(FindClassDeclX(AST.get()));
133 EXPECT_TRUE(Action.get() != nullptr);
147 EXPECT_TRUE(Action.get() != nullptr);
169 EXPECT_TRUE(Invocation.run());
199 EXPECT_TRUE(Invocation.run());
234 EXPECT_TRUE(EndCallback.Matched);
260 EXPECT_TRUE(runToolOnCode(std::make_unique<SkipBodyAction>(),
266 EXPECT_TRUE(runToolOnCodeWithArgs(
269 EXPECT_TRUE(runToolOnCodeWithArgs(
273 EXPECT_TRUE(runToolOnCodeWithArgs(
277 EXPECT_TRUE(runToolOnCodeWithArgs(
282 EXPECT_TRUE(runToolOnCodeWithArgs(
295 EXPECT_TRUE(runToolOnCode(
298 EXPECT_TRUE(runToolOnCode(
301 EXPECT_TRUE(
310 EXPECT_TRUE(runToolOnCode(
328 EXPECT_TRUE(runToolOnCodeWithArgs(std::make_unique<SkipBodyAction>(), "", Args));
351 EXPECT_TRUE(runToolOnCodeWithArgs(
354 EXPECT_TRUE(runToolOnCodeWithArgs(
357 EXPECT_TRUE(runToolOnCodeWithArgs(
360 EXPECT_TRUE(runToolOnCodeWithArgs(
363 EXPECT_TRUE(runToolOnCodeWithArgs(
393 EXPECT_TRUE(Ran);
394 EXPECT_TRUE(Found);
401 EXPECT_TRUE(Ran);
476 EXPECT_TRUE(HasFlag("-c"));
477 EXPECT_TRUE(HasFlag("-w"));
tools/lld/unittests/DriverTests/DarwinLdDriverTest.cpp 51 EXPECT_TRUE(parse({"foo.o", "bar.o", "-arch", "i386"}));
60 EXPECT_TRUE(parse({"-o", "my.out", "foo.o", "-arch", "i386"}));
65 EXPECT_TRUE(parse({"-dylib", "foo.o", "-arch", "i386"}));
70 EXPECT_TRUE(parse({"-r", "foo.o", "-arch", "i386"}));
75 EXPECT_TRUE(parse({"-bundle", "foo.o", "-arch", "i386"}));
80 EXPECT_TRUE(parse({"-preload", "foo.o", "-arch", "i386"}));
85 EXPECT_TRUE(parse({"-static", "foo.o", "-arch", "i386"}));
90 EXPECT_TRUE(parse({"-e", "entryFunc", "foo.o", "-arch", "i386"}));
95 EXPECT_TRUE(parse({"-arch", "x86_64", "-dead_strip", "foo.o"}));
96 EXPECT_TRUE(_ctx.deadStrip());
100 EXPECT_TRUE(parse({"-arch", "x86_64", "-dead_strip", "foo.o"}));
105 EXPECT_TRUE(parse({"-arch", "x86_64", "-dylib", "-dead_strip", "foo.o"}));
110 EXPECT_TRUE(parse({"-arch", "x86_64", "-r", "-dead_strip", "foo.o"}));
115 EXPECT_TRUE(
117 EXPECT_TRUE(_ctx.globalsAreDeadStripRoots());
121 EXPECT_TRUE(parse({"-arch", "x86_64", "-dylib", "-dead_strip",
123 EXPECT_TRUE(_ctx.globalsAreDeadStripRoots());
127 EXPECT_TRUE(parse(
133 EXPECT_TRUE(parse({"-arch", "x86_64", "foo.o"}));
140 EXPECT_TRUE(parse({"-arch", "i386", "foo.o"}));
147 EXPECT_TRUE(parse({"-arch", "armv6", "foo.o"}));
154 EXPECT_TRUE(parse({"-arch", "armv7", "foo.o"}));
161 EXPECT_TRUE(parse({"-arch", "armv7s", "foo.o"}));
168 EXPECT_TRUE(
171 EXPECT_TRUE(_ctx.minOS("10.7", ""));
176 EXPECT_TRUE(
179 EXPECT_TRUE(_ctx.minOS("10.7", ""));
180 EXPECT_TRUE(_ctx.minOS("10.8", ""));
184 EXPECT_TRUE(parse({"-ios_version_min", "5.0", "foo.o", "-arch", "armv7"}));
186 EXPECT_TRUE(_ctx.minOS("", "5.0"));
191 EXPECT_TRUE(parse({"-ios_version_min", "6.0", "foo.o", "-arch", "armv7"}));
193 EXPECT_TRUE(_ctx.minOS("", "5.0"));
194 EXPECT_TRUE(_ctx.minOS("", "6.0"));
198 EXPECT_TRUE(
201 EXPECT_TRUE(_ctx.minOS("", "5.0"));
206 EXPECT_TRUE(
209 EXPECT_TRUE(_ctx.minOS("", "5.0"));
210 EXPECT_TRUE(_ctx.minOS("", "6.0"));
214 EXPECT_TRUE(parse(
230 EXPECT_TRUE(
246 EXPECT_TRUE(
256 EXPECT_TRUE(
tools/lld/unittests/MachOTests/MachONormalizedFileBinaryReaderTests.cpp 79 EXPECT_TRUE(f->localSymbols.empty());
80 EXPECT_TRUE(f->globalSymbols.empty());
81 EXPECT_TRUE(f->undefinedSymbols.empty());
110 EXPECT_TRUE(f->localSymbols.empty());
111 EXPECT_TRUE(f->globalSymbols.empty());
112 EXPECT_TRUE(f->undefinedSymbols.empty());
141 EXPECT_TRUE(f->localSymbols.empty());
142 EXPECT_TRUE(f->globalSymbols.empty());
143 EXPECT_TRUE(f->undefinedSymbols.empty());
172 EXPECT_TRUE(f->localSymbols.empty());
173 EXPECT_TRUE(f->globalSymbols.empty());
174 EXPECT_TRUE(f->undefinedSymbols.empty());
186 EXPECT_TRUE(f->localSymbols.empty());
187 EXPECT_TRUE(f->globalSymbols.empty());
188 EXPECT_TRUE(f->undefinedSymbols.empty());
195 EXPECT_TRUE(f2->localSymbols.empty());
196 EXPECT_TRUE(f2->globalSymbols.empty());
197 EXPECT_TRUE(f2->undefinedSymbols.empty());
274 EXPECT_TRUE(text.segmentName.equals("__TEXT"));
275 EXPECT_TRUE(text.sectionName.equals("__text"));
284 EXPECT_TRUE(text.indirectSymbols.empty());
300 EXPECT_TRUE(cstring.segmentName.equals("__TEXT"));
301 EXPECT_TRUE(cstring.sectionName.equals("__cstring"));
310 EXPECT_TRUE(cstring.indirectSymbols.empty());
311 EXPECT_TRUE(cstring.relocations.empty());
320 EXPECT_TRUE(mainLabel.name.equals("_main"));
327 EXPECT_TRUE(printfLabel.name.equals("_printf"));
399 EXPECT_TRUE(text.segmentName.equals("__TEXT"));
400 EXPECT_TRUE(text.sectionName.equals("__text"));
409 EXPECT_TRUE(text.indirectSymbols.empty());
435 EXPECT_TRUE(cstring.segmentName.equals("__TEXT"));
436 EXPECT_TRUE(cstring.sectionName.equals("__cstring"));
445 EXPECT_TRUE(cstring.indirectSymbols.empty());
446 EXPECT_TRUE(cstring.relocations.empty());
451 EXPECT_TRUE(mainLabel.name.equals("_main"));
458 EXPECT_TRUE(printfLabel.name.equals("_printf"));
531 EXPECT_TRUE(text.segmentName.equals("__TEXT"));
532 EXPECT_TRUE(text.sectionName.equals("__text"));
541 EXPECT_TRUE(text.indirectSymbols.empty());
576 EXPECT_TRUE(cstring.segmentName.equals("__TEXT"));
577 EXPECT_TRUE(cstring.sectionName.equals("__cstring"));
586 EXPECT_TRUE(cstring.indirectSymbols.empty());
587 EXPECT_TRUE(cstring.relocations.empty());
592 EXPECT_TRUE(mainLabel.name.equals("_main"));
599 EXPECT_TRUE(printfLabel.name.equals("_printf"));
675 EXPECT_TRUE(text.segmentName.equals("__TEXT"));
676 EXPECT_TRUE(text.sectionName.equals("__text"));
685 EXPECT_TRUE(text.indirectSymbols.empty());
719 EXPECT_TRUE(cstring.segmentName.equals("__TEXT"));
720 EXPECT_TRUE(cstring.sectionName.equals("__cstring"));
729 EXPECT_TRUE(cstring.indirectSymbols.empty());
730 EXPECT_TRUE(cstring.relocations.empty());
735 EXPECT_TRUE(mainLabel.name.equals("_main"));
742 EXPECT_TRUE(printfLabel.name.equals("_printf"));
tools/lld/unittests/MachOTests/MachONormalizedFileBinaryWriterTests.cpp 162 EXPECT_TRUE(f2->localSymbols.empty());
163 EXPECT_TRUE(f2->globalSymbols.empty());
166 EXPECT_TRUE(barUndef.name.equals("_bar"));
170 EXPECT_TRUE(tbarUndef.name.equals("_tbar"));
176 EXPECT_TRUE(text.segmentName.equals("__TEXT"));
177 EXPECT_TRUE(text.sectionName.equals("__text"));
274 EXPECT_TRUE(f2->localSymbols.empty());
275 EXPECT_TRUE(f2->globalSymbols.empty());
278 EXPECT_TRUE(barUndef.name.equals("_bar"));
282 EXPECT_TRUE(tbarUndef.name.equals("_tbar"));
288 EXPECT_TRUE(text.segmentName.equals("__TEXT"));
289 EXPECT_TRUE(text.sectionName.equals("__text"));
393 EXPECT_TRUE(f2->localSymbols.empty());
396 EXPECT_TRUE(fooDef.name.equals("_foo"));
401 EXPECT_TRUE(foo2Def.name.equals("_foo2"));
408 EXPECT_TRUE(barUndef.name.equals("_bar"));
414 EXPECT_TRUE(text.segmentName.equals("__TEXT"));
415 EXPECT_TRUE(text.sectionName.equals("__text"));
550 EXPECT_TRUE(f2->localSymbols.empty());
553 EXPECT_TRUE(fooDef.name.equals("_foo"));
558 EXPECT_TRUE(foo2Def.name.equals("_foo2"));
565 EXPECT_TRUE(barUndef.name.equals("_bar"));
571 EXPECT_TRUE(text.segmentName.equals("__TEXT"));
572 EXPECT_TRUE(text.sectionName.equals("__text"));
tools/lld/unittests/MachOTests/MachONormalizedFileToAtomsTests.cpp 81 EXPECT_TRUE(atom1->name().equals("_foo"));
87 EXPECT_TRUE(atom2->name().equals("_bar"));
92 EXPECT_TRUE(atom3->name().equals("_baz"));
97 EXPECT_TRUE(atom4->name().equals("_undef"));
tools/lld/unittests/MachOTests/MachONormalizedFileYAMLTests.cpp 40 EXPECT_TRUE(!ec);
54 EXPECT_TRUE(f->sections.empty());
55 EXPECT_TRUE(f->localSymbols.empty());
56 EXPECT_TRUE(f->globalSymbols.empty());
57 EXPECT_TRUE(f->undefinedSymbols.empty());
70 EXPECT_TRUE(f->sections.empty());
71 EXPECT_TRUE(f->localSymbols.empty());
72 EXPECT_TRUE(f->globalSymbols.empty());
73 EXPECT_TRUE(f->undefinedSymbols.empty());
86 EXPECT_TRUE(f->sections.empty());
87 EXPECT_TRUE(f->localSymbols.empty());
88 EXPECT_TRUE(f->globalSymbols.empty());
89 EXPECT_TRUE(f->undefinedSymbols.empty());
102 EXPECT_TRUE(f->sections.empty());
103 EXPECT_TRUE(f->localSymbols.empty());
104 EXPECT_TRUE(f->globalSymbols.empty());
105 EXPECT_TRUE(f->undefinedSymbols.empty());
118 EXPECT_TRUE(f->sections.empty());
119 EXPECT_TRUE(f->localSymbols.empty());
120 EXPECT_TRUE(f->globalSymbols.empty());
121 EXPECT_TRUE(f->undefinedSymbols.empty());
134 EXPECT_TRUE(f->sections.empty());
135 EXPECT_TRUE(f->localSymbols.empty());
136 EXPECT_TRUE(f->globalSymbols.empty());
137 EXPECT_TRUE(f->undefinedSymbols.empty());
155 EXPECT_TRUE(f2->sections.empty());
156 EXPECT_TRUE(f2->localSymbols.empty());
157 EXPECT_TRUE(f2->globalSymbols.empty());
158 EXPECT_TRUE(f2->undefinedSymbols.empty());
177 EXPECT_TRUE(f->sections.empty());
178 EXPECT_TRUE(f->localSymbols.empty());
179 EXPECT_TRUE(f->undefinedSymbols.empty());
182 EXPECT_TRUE(sym.name.equals("_main"));
206 EXPECT_TRUE(f->localSymbols.empty());
207 EXPECT_TRUE(f->globalSymbols.empty());
208 EXPECT_TRUE(f->undefinedSymbols.empty());
211 EXPECT_TRUE(sect.segmentName.equals("__TEXT"));
212 EXPECT_TRUE(sect.sectionName.equals("__text"));
282 EXPECT_TRUE(sect1.segmentName.equals("__TEXT"));
283 EXPECT_TRUE(sect1.sectionName.equals("__text"));
299 EXPECT_TRUE(reloc1.pcRel);
300 EXPECT_TRUE(reloc1.isExtern);
308 EXPECT_TRUE(reloc2.pcRel);
309 EXPECT_TRUE(reloc2.isExtern);
314 EXPECT_TRUE(sect2.segmentName.equals("__TEXT"));
315 EXPECT_TRUE(sect2.sectionName.equals("__cstring"));
327 EXPECT_TRUE(sym1.name.equals("_main"));
335 EXPECT_TRUE(sym2.name.equals("L_.str"));
343 EXPECT_TRUE(sym3.name.equals("_printf"));
412 EXPECT_TRUE(sect1.segmentName.equals("__TEXT"));
413 EXPECT_TRUE(sect1.sectionName.equals("__text"));
429 EXPECT_TRUE(reloc1.pcRel);
430 EXPECT_TRUE(reloc1.isExtern);
435 EXPECT_TRUE(reloc2.scattered);
443 EXPECT_TRUE(reloc3.scattered);
451 EXPECT_TRUE(sect2.segmentName.equals("__TEXT"));
452 EXPECT_TRUE(sect2.sectionName.equals("__cstring"));
464 EXPECT_TRUE(sym1.name.equals("_main"));
472 EXPECT_TRUE(sym2.name.equals("_printf"));
540 EXPECT_TRUE(sect1.segmentName.equals("__TEXT"));
541 EXPECT_TRUE(sect1.sectionName.equals("__text"));
554 EXPECT_TRUE(reloc1.scattered);
562 EXPECT_TRUE(reloc2.scattered);
573 EXPECT_TRUE(reloc3.pcRel);
574 EXPECT_TRUE(reloc3.isExtern);
579 EXPECT_TRUE(sect2.segmentName.equals("__TEXT"));
580 EXPECT_TRUE(sect2.sectionName.equals("__cstring"));
592 EXPECT_TRUE(sym1.name.equals("_main"));
600 EXPECT_TRUE(sym2.name.equals("_printf"));
680 EXPECT_TRUE(sect1.segmentName.equals("__TEXT"));
681 EXPECT_TRUE(sect1.sectionName.equals("__text"));
697 EXPECT_TRUE(reloc1.pcRel);
698 EXPECT_TRUE(reloc1.isExtern);
703 EXPECT_TRUE(reloc2.scattered);
711 EXPECT_TRUE(reloc3.scattered);
719 EXPECT_TRUE(reloc4.scattered);
727 EXPECT_TRUE(reloc5.scattered);
735 EXPECT_TRUE(sect2.segmentName.equals("__TEXT"));
736 EXPECT_TRUE(sect2.sectionName.equals("__cstring"));
748 EXPECT_TRUE(sym1.name.equals("_main"));
756 EXPECT_TRUE(sym2.name.equals("_printf"));
tools/lldb/unittests/Breakpoint/BreakpointIDTest.cpp 26 EXPECT_TRUE(BreakpointID::StringIsBreakpointName("_", E));
27 EXPECT_TRUE(BreakpointID::StringIsBreakpointName("a123", E));
28 EXPECT_TRUE(BreakpointID::StringIsBreakpointName("test", E));
tools/lldb/unittests/Core/RichManglingContextTest.cpp 21 EXPECT_TRUE(RMC.FromItaniumName(mangled));
23 EXPECT_TRUE(RMC.IsFunction());
39 EXPECT_TRUE(ItaniumRMC.FromItaniumName(mangled));
43 EXPECT_TRUE(CxxMethodRMC.FromCxxMethodName(demangled));
45 EXPECT_TRUE(ItaniumRMC.IsFunction() == CxxMethodRMC.IsFunction());
46 EXPECT_TRUE(ItaniumRMC.IsCtorOrDtor() == CxxMethodRMC.IsCtorOrDtor());
50 EXPECT_TRUE(ItaniumRMC.GetBufferRef() == CxxMethodRMC.GetBufferRef());
54 EXPECT_TRUE(ItaniumRMC.GetBufferRef() == CxxMethodRMC.GetBufferRef());
58 EXPECT_TRUE(ItaniumRMC.GetBufferRef() == CxxMethodRMC.GetBufferRef());
63 EXPECT_TRUE(CxxMethodRMC.FromCxxMethodName(ConstString("X")));
72 EXPECT_TRUE(CxxMethodRMC.FromCxxMethodName(
76 EXPECT_TRUE(CxxMethodRMC.IsFunction());
80 EXPECT_TRUE(CxxMethodRMC.GetBufferRef().empty());
89 EXPECT_TRUE(RMC.FromItaniumName(ConstString(mangled)));
93 EXPECT_TRUE(RMC.FromCxxMethodName(ConstString(demangled)));
97 EXPECT_TRUE(RMC.FromItaniumName(ConstString(mangled)));
126 EXPECT_TRUE(RMC.FromItaniumName(ConstString(ShortMangled)));
131 EXPECT_TRUE(RMC.FromItaniumName(ConstString(LongMangled)));
138 EXPECT_TRUE(AllocatedNewBuffer || ExtendedExistingBuffer);
tools/lldb/unittests/Editline/EditlineTest.cpp 257 EXPECT_TRUE(_el_adapter.IsValid());
280 EXPECT_TRUE(GetEditlineAdapter().SendLine(input_text));
288 EXPECT_TRUE(received_line);
302 EXPECT_TRUE(GetEditlineAdapter().SendLines(input_lines));
308 EXPECT_TRUE(GetEditlineAdapter().GetLines(el_reported_lines,
tools/lldb/unittests/Expression/DiagnosticManagerTest.cpp 66 EXPECT_TRUE(mgr.HasFixIts());
69 EXPECT_TRUE(mgr.HasFixIts());
72 EXPECT_TRUE(mgr.HasFixIts());
tools/lldb/unittests/Host/ConnectionFileDescriptorTest.cpp 42 EXPECT_TRUE(UriParser::Parse(uri, scheme, hostname, port, path));
tools/lldb/unittests/Host/FileSystemTest.cpp 189 EXPECT_TRUE(fs.Exists("/foo"));
190 EXPECT_TRUE(fs.Exists(FileSpec("/foo", FileSpec::Style::posix)));
196 EXPECT_TRUE(fs.Readable("/foo"));
197 EXPECT_TRUE(fs.Readable(FileSpec("/foo", FileSpec::Style::posix)));
227 EXPECT_TRUE(foo.equals("/foo"));
245 EXPECT_TRUE(foo.equals("/foo"));
258 EXPECT_TRUE(foo.equals("bogus"));
tools/lldb/unittests/Host/HostInfoTest.cpp 57 EXPECT_TRUE(HostInfo::GetHostname(s));
tools/lldb/unittests/Host/SocketTest.cpp 29 EXPECT_TRUE(Socket::DecodeHostAndPort("localhost:1138", host_str, port_str,
34 EXPECT_TRUE(error.Success());
38 EXPECT_TRUE(error.Fail());
44 EXPECT_TRUE(error.Fail());
50 EXPECT_TRUE(error.Fail());
54 EXPECT_TRUE(
59 EXPECT_TRUE(error.Success());
61 EXPECT_TRUE(
66 EXPECT_TRUE(error.Success());
68 EXPECT_TRUE(
73 EXPECT_TRUE(error.Success());
75 EXPECT_TRUE(
80 EXPECT_TRUE(error.Success());
82 EXPECT_TRUE(
87 EXPECT_TRUE(error.Success());
141 EXPECT_TRUE(error.Success());
142 EXPECT_TRUE(socket_up->IsValid());
152 EXPECT_TRUE(socket_up->IsValid());
170 EXPECT_TRUE(UriParser::Parse(uri, scheme, hostname, port, path));
190 EXPECT_TRUE(UriParser::Parse(uri, scheme, hostname, port, path));
215 EXPECT_TRUE(UriParser::Parse(uri, scheme, hostname, port, path));
tools/lldb/unittests/Host/SocketTestUtilities.cpp 38 EXPECT_TRUE(listen_socket_up->IsValid());
52 EXPECT_TRUE(connect_socket_up->IsValid());
55 EXPECT_TRUE(error.Success());
57 EXPECT_TRUE((*a_up)->IsValid());
61 EXPECT_TRUE(accept_error.Success());
63 EXPECT_TRUE((*b_up)->IsValid());
tools/lldb/unittests/Host/linux/HostTest.cpp 55 EXPECT_TRUE(Info.GetArchitecture().IsValid());
tools/lldb/unittests/Interpreter/TestCompletion.cpp 121 EXPECT_TRUE(HasEquivalentFile(DirFoo, Results));
122 EXPECT_TRUE(HasEquivalentFile(DirFooA, Results));
123 EXPECT_TRUE(HasEquivalentFile(DirFooB, Results));
124 EXPECT_TRUE(HasEquivalentFile(DirFooC, Results));
129 EXPECT_TRUE(HasEquivalentFile(DirBar, Results));
130 EXPECT_TRUE(HasEquivalentFile(DirBaz, Results));
162 EXPECT_TRUE(HasEquivalentFile(DirFooA, Results));
170 EXPECT_TRUE(HasEquivalentFile(DirFoo, Results));
171 EXPECT_TRUE(HasEquivalentFile(DirFooA, Results));
172 EXPECT_TRUE(HasEquivalentFile(DirFooB, Results));
173 EXPECT_TRUE(HasEquivalentFile(DirFooC, Results));
174 EXPECT_TRUE(HasEquivalentFile(DirBar, Results));
175 EXPECT_TRUE(HasEquivalentFile(DirBaz, Results));
176 EXPECT_TRUE(HasEquivalentFile(DirTestFolder, Results));
194 EXPECT_TRUE(HasEquivalentFile(DirFooA, Results));
200 EXPECT_TRUE(HasEquivalentFile(FileAA, Results));
205 EXPECT_TRUE(HasEquivalentFile(DirFoo, Results));
206 EXPECT_TRUE(HasEquivalentFile(DirFooA, Results));
207 EXPECT_TRUE(HasEquivalentFile(DirFooB, Results));
208 EXPECT_TRUE(HasEquivalentFile(DirFooC, Results));
209 EXPECT_TRUE(HasEquivalentFile(DirBar, Results));
210 EXPECT_TRUE(HasEquivalentFile(DirBaz, Results));
211 EXPECT_TRUE(HasEquivalentFile(DirTestFolder, Results));
213 EXPECT_TRUE(HasEquivalentFile(FileAA, Results));
214 EXPECT_TRUE(HasEquivalentFile(FileAB, Results));
215 EXPECT_TRUE(HasEquivalentFile(FileAC, Results));
216 EXPECT_TRUE(HasEquivalentFile(FileFoo, Results));
217 EXPECT_TRUE(HasEquivalentFile(FileBar, Results));
218 EXPECT_TRUE(HasEquivalentFile(FileBaz, Results));
223 EXPECT_TRUE(HasEquivalentFile(DirFoo, Results));
224 EXPECT_TRUE(HasEquivalentFile(DirFooA, Results));
225 EXPECT_TRUE(HasEquivalentFile(DirFooB, Results));
226 EXPECT_TRUE(HasEquivalentFile(DirFooC, Results));
227 EXPECT_TRUE(HasEquivalentFile(FileFoo, Results));
tools/lldb/unittests/Interpreter/TestOptionArgParser.cpp 16 EXPECT_TRUE(
18 EXPECT_TRUE(
20 EXPECT_TRUE(
22 EXPECT_TRUE(OptionArgParser::ToBoolean(llvm::StringRef("1"), false, nullptr));
24 EXPECT_TRUE(
26 EXPECT_TRUE(success);
27 EXPECT_TRUE(
29 EXPECT_TRUE(success);
30 EXPECT_TRUE(
32 EXPECT_TRUE(success);
33 EXPECT_TRUE(
35 EXPECT_TRUE(success);
47 EXPECT_TRUE(success);
50 EXPECT_TRUE(success);
53 EXPECT_TRUE(success);
56 EXPECT_TRUE(success);
61 EXPECT_TRUE(
64 EXPECT_TRUE(OptionArgParser::ToBoolean(llvm::StringRef(""), true, &success));
75 EXPECT_TRUE(success);
77 EXPECT_TRUE(success);
103 EXPECT_TRUE(success);
108 EXPECT_TRUE(success);
113 EXPECT_TRUE(success);
tools/lldb/unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp 113 EXPECT_TRUE(method.IsValid()) << test.input;
152 EXPECT_TRUE(CPlusPlusLanguage::ExtractContextAndIdentifier(
tools/lldb/unittests/ObjectFile/PECOFF/TestPECallFrameInfo.cpp 213 EXPECT_TRUE(cfi->GetUnwindPlan(Address(file_addr, sect_list), plan));
tools/lldb/unittests/Platform/PlatformDarwinTest.cpp 55 EXPECT_TRUE(PlatformDarwinTester::SDKSupportsModules(
65 EXPECT_TRUE(PlatformDarwinTester::SDKSupportsModules(
tools/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp 313 EXPECT_TRUE(result.get().Success());
320 EXPECT_TRUE(result.get().Success());
339 EXPECT_TRUE(result.get().Success());
tools/lldb/unittests/Process/minidump/MinidumpParserTest.cpp 564 EXPECT_TRUE(consumeObject(registers, context).Success());
607 EXPECT_TRUE(consumeObject(registers, context).Success());
642 EXPECT_TRUE(consumeObject(registers, context).Success());
tools/lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp 95 EXPECT_TRUE(sys_module.IsAllocated());
96 EXPECT_TRUE(PythonModule::Check(sys_module.get()));
102 EXPECT_TRUE(sys_path.IsAllocated());
103 EXPECT_TRUE(sys_version_info.IsAllocated());
105 EXPECT_TRUE(PythonList::Check(sys_path.get()));
113 EXPECT_TRUE(version_info_type.IsAllocated());
115 EXPECT_TRUE(major_version_field.IsAllocated());
123 EXPECT_TRUE(major_version_field.IsAllocated());
124 EXPECT_TRUE(minor_version_field.IsAllocated());
137 EXPECT_TRUE(sys_path.IsAllocated());
138 EXPECT_TRUE(PythonList::Check(sys_path.get()));
146 EXPECT_TRUE(version_major.IsAllocated());
147 EXPECT_TRUE(version_minor.IsAllocated());
175 EXPECT_TRUE(PythonInteger::Check(py_int));
184 EXPECT_TRUE(PythonInteger::Check(py_long));
200 EXPECT_TRUE(PythonBoolean::Check(Py_True));
205 EXPECT_TRUE(PythonBoolean::Check(Py_False));
211 EXPECT_TRUE(PythonBoolean::Check(py_bool));
226 EXPECT_TRUE(PythonBytes::Check(py_bytes));
230 EXPECT_TRUE(PythonString::Check(py_bytes));
247 EXPECT_TRUE(PythonByteArray::Check(py_bytes));
266 EXPECT_TRUE(PythonString::Check(py_string));
320 EXPECT_TRUE(PythonList::Check(py_list));
336 EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
337 EXPECT_TRUE(PythonString::Check(chk_value2.get()));
364 EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
365 EXPECT_TRUE(PythonString::Check(chk_value2.get()));
476 EXPECT_TRUE(PythonDictionary::Check(py_dict));
487 EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
488 EXPECT_TRUE(PythonString::Check(chk_value2.get()));
524 EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
525 EXPECT_TRUE(PythonString::Check(chk_value2.get()));
548 EXPECT_TRUE(dict_sp->HasKey(string_key0));
549 EXPECT_TRUE(dict_sp->HasKey(string_key1));
562 EXPECT_TRUE(PythonCallable::Check(sys_exc_info.get()));
575 EXPECT_TRUE(PythonList::Check(result.get()));
589 EXPECT_TRUE(PythonFile::Check(py_file.get().get()));
594 EXPECT_TRUE(py_int.HasAttribute("numerator"));
599 EXPECT_TRUE(numerator_attr.IsAllocated());
613 EXPECT_TRUE((bool)structured_data_sp);
617 EXPECT_TRUE(structured_dict_ptr != nullptr);
621 EXPECT_TRUE((bool)structured_addr_value_sp);
624 EXPECT_TRUE(extracted_value == value);
tools/lldb/unittests/Symbol/LocateSymbolFileTest.cpp 40 EXPECT_TRUE(symbol_file_spec.GetFilename().IsEmpty());
52 EXPECT_TRUE(symbol_file_spec.GetFilename().IsEmpty());
tools/lldb/unittests/Symbol/TestClangASTContext.cpp 60 EXPECT_TRUE(
62 EXPECT_TRUE(
64 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeChar16),
66 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeChar32),
68 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeDouble),
70 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeDoubleComplex),
72 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeFloat),
74 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeFloatComplex),
76 EXPECT_TRUE(
78 EXPECT_TRUE(
80 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeInt128),
82 EXPECT_TRUE(
84 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeLongDouble),
86 EXPECT_TRUE(
89 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeLongLong),
91 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeNullPtr),
93 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeObjCClass),
95 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeObjCID),
97 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeObjCSel),
99 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeShort),
101 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeSignedChar),
103 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedChar),
105 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedInt),
107 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedInt128),
109 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedLong),
111 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedLongLong),
113 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedShort),
115 EXPECT_TRUE(
117 EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeWChar),
176 EXPECT_TRUE(type.IsValid());
191 EXPECT_TRUE(type_ptr->isBuiltinType());
194 EXPECT_TRUE(type_ptr->isSignedIntegerType());
197 EXPECT_TRUE(type_ptr->isUnsignedIntegerType());
200 EXPECT_TRUE(type_ptr->isFloatingType());
243 EXPECT_TRUE(ClangUtil::IsClangType(bool_type));
244 EXPECT_TRUE(ClangUtil::IsClangType(record_type));
346 EXPECT_TRUE(ClangASTContext::RecordHasFields(non_empty_base_decl));
362 EXPECT_TRUE(result);
369 EXPECT_TRUE(
385 EXPECT_TRUE(result);
392 EXPECT_TRUE(
tools/lldb/unittests/Symbol/TestType.cpp 57 EXPECT_TRUE(contextMatches(mms, mms));
70 EXPECT_TRUE(contextMatches(mms, mas));
71 EXPECT_TRUE(contextMatches(ms, mas));
78 EXPECT_TRUE(contextMatches(mmms, mas));
87 EXPECT_TRUE(contextMatches(mme, mma));
88 EXPECT_TRUE(contextMatches(mms, mma));
tools/lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp 122 EXPECT_TRUE(abbrev1->HasChildren());
167 EXPECT_TRUE(abbrev1->HasChildren());
212 EXPECT_TRUE(abbrev1->HasChildren());
241 EXPECT_TRUE(bool(error));
270 EXPECT_TRUE(bool(error));
299 EXPECT_TRUE(bool(error));
325 EXPECT_TRUE(bool(error));
tools/lldb/unittests/Target/ModuleCacheTest.cpp 88 EXPECT_TRUE(FileSystem::Instance().Exists(uuid_view))
93 EXPECT_TRUE(FileSystem::Instance().Exists(sysroot_view))
127 EXPECT_TRUE(error.Success()) << "Error was: " << error.AsCString();
128 EXPECT_TRUE(did_create);
tools/lldb/unittests/Target/PathMappingListTest.cpp 37 EXPECT_TRUE(
41 EXPECT_TRUE(map.ReverseRemapPath(match.remapped, unmapped_spec));
tools/lldb/unittests/UnwindAssembly/ARM64/TestArm64InstEmulation.cpp 89 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
95 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
96 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
102 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
103 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
106 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_fp_arm64, regloc));
107 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
110 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_arm64, regloc));
111 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
117 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_fp_arm64);
118 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
121 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_fp_arm64, regloc));
122 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
125 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_arm64, regloc));
126 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
132 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
133 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
136 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_fp_arm64, regloc));
137 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
140 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_arm64, regloc));
141 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
147 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
148 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
206 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
212 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
213 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
219 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
222 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x21_arm64, regloc));
223 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
226 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x22_arm64, regloc));
227 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
233 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
236 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x19_arm64, regloc));
237 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
240 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x20_arm64, regloc));
241 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
248 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
251 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_fp_arm64, regloc));
252 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
255 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_arm64, regloc));
256 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
263 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_fp_arm64);
264 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
271 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
272 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
282 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_fp_arm64, regloc));
283 EXPECT_TRUE(regloc.IsSame());
285 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_arm64, regloc));
286 EXPECT_TRUE(regloc.IsSame());
293 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x19_arm64, regloc));
294 EXPECT_TRUE(regloc.IsSame());
296 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x20_arm64, regloc));
297 EXPECT_TRUE(regloc.IsSame());
303 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
304 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
307 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x21_arm64, regloc));
308 EXPECT_TRUE(regloc.IsSame());
310 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x22_arm64, regloc));
311 EXPECT_TRUE(regloc.IsSame());
360 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
366 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
367 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
371 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
372 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
389 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
390 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
394 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
395 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
399 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
400 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
404 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
405 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
487 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
492 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_fp_arm64);
493 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
496 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x20_arm64, regloc));
497 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
502 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_fp_arm64);
503 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
506 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x20_arm64, regloc));
507 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
600 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
608 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_fp_arm64);
609 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
612 EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d15_arm64, regloc));
613 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
616 EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d14_arm64, regloc));
617 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
620 EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d13_arm64, regloc));
621 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
624 EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d12_arm64, regloc));
625 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
628 EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d11_arm64, regloc));
629 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
632 EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d10_arm64, regloc));
633 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
636 EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d9_arm64, regloc));
637 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
640 EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d8_arm64, regloc));
641 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
647 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
648 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
652 EXPECT_TRUE(regloc.IsSame());
655 EXPECT_TRUE(regloc.IsSame());
658 EXPECT_TRUE(regloc.IsSame());
661 EXPECT_TRUE(regloc.IsSame());
664 EXPECT_TRUE(regloc.IsSame());
667 EXPECT_TRUE(regloc.IsSame());
670 EXPECT_TRUE(regloc.IsSame());
673 EXPECT_TRUE(regloc.IsSame());
676 EXPECT_TRUE(regloc.IsSame());
679 EXPECT_TRUE(regloc.IsSame());
tools/lldb/unittests/UnwindAssembly/PPC64/TestPPC64InstEmulation.cpp 95 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
101 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
102 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
108 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
109 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
112 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_r31_ppc64le, regloc));
113 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
119 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
120 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
123 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_ppc64le, regloc));
124 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
130 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
131 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
134 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_r31_ppc64le, regloc));
135 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
138 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_ppc64le, regloc));
139 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
145 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r31_ppc64le);
146 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
149 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_r31_ppc64le, regloc));
150 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
153 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_ppc64le, regloc));
154 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
160 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
161 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
164 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_r31_ppc64le, regloc));
165 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
168 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_ppc64le, regloc));
169 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
207 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
213 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
214 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
220 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
221 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
224 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_r31_ppc64le, regloc));
225 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
231 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
232 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
235 EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_ppc64le, regloc));
236 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
242 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r30_ppc64le);
243 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
248 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r30_ppc64le);
249 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
255 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
256 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
tools/lldb/unittests/UnwindAssembly/x86/Testx86AssemblyInspectionEngine.cpp 158 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
167 EXPECT_TRUE(unwind_plan.GetInitialCFARegister() == k_rsp);
168 EXPECT_TRUE(unwind_plan.GetUnwindPlanValidAtAllInstructions() ==
170 EXPECT_TRUE(unwind_plan.GetSourcedFromCompiler() == eLazyBoolNo);
177 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
178 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
181 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
182 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
188 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
189 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
192 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
193 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
199 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
200 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
203 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
204 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
210 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
211 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
214 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
215 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
234 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
243 EXPECT_TRUE(unwind_plan.GetInitialCFARegister() == k_esp);
244 EXPECT_TRUE(unwind_plan.GetUnwindPlanValidAtAllInstructions() ==
246 EXPECT_TRUE(unwind_plan.GetSourcedFromCompiler() == eLazyBoolNo);
253 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
254 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
257 EXPECT_TRUE(row_sp->GetRegisterInfo(k_eip, regloc));
258 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
259 EXPECT_TRUE(regloc.GetOffset() == -4);
264 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
265 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
268 EXPECT_TRUE(row_sp->GetRegisterInfo(k_eip, regloc));
269 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
275 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_ebp);
276 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
279 EXPECT_TRUE(row_sp->GetRegisterInfo(k_eip, regloc));
280 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
286 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
287 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
290 EXPECT_TRUE(row_sp->GetRegisterInfo(k_eip, regloc));
291 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
355 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
394 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
395 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
398 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
399 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
402 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbp, regloc));
403 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
406 EXPECT_TRUE(row_sp->GetRegisterInfo(k_r15, regloc));
407 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
410 EXPECT_TRUE(row_sp->GetRegisterInfo(k_r14, regloc));
411 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
414 EXPECT_TRUE(row_sp->GetRegisterInfo(k_r13, regloc));
415 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
418 EXPECT_TRUE(row_sp->GetRegisterInfo(k_r12, regloc));
419 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
422 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbx, regloc));
423 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
432 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
433 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
436 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
437 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
610 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
663 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
664 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
681 EXPECT_TRUE(row_sp->GetRegisterInfo(k_eip, regloc));
682 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
685 EXPECT_TRUE(row_sp->GetRegisterInfo(k_ebp, regloc));
686 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
689 EXPECT_TRUE(row_sp->GetRegisterInfo(k_ebx, regloc));
690 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
693 EXPECT_TRUE(row_sp->GetRegisterInfo(k_edi, regloc));
694 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
697 EXPECT_TRUE(row_sp->GetRegisterInfo(k_esi, regloc));
698 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
708 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
709 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
735 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
736 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
739 EXPECT_TRUE(row_sp->GetRegisterInfo(k_eip, regloc));
740 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
743 EXPECT_TRUE(row_sp->GetRegisterInfo(k_esp, regloc));
744 EXPECT_TRUE(regloc.IsCFAPlusOffset());
798 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
814 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
815 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
818 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
819 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
846 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
847 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
850 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
851 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
905 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
923 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
924 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
932 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
933 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
941 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
942 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
960 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
961 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
978 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
984 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
985 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
988 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbp, regloc));
989 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
993 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
999 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1000 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1003 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbp, regloc));
1004 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
1022 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1027 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1028 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1033 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1034 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1038 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1043 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1044 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1049 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1050 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1070 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1079 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1103 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1109 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1110 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1114 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1119 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1120 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1125 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1126 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1131 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1132 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1149 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1155 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1156 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1159 EXPECT_TRUE(row_sp->GetRegisterInfo(k_r15, regloc));
1160 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
1177 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1183 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1184 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1187 EXPECT_TRUE(row_sp->GetRegisterInfo(k_r14, regloc));
1188 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
1205 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1211 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1212 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1215 EXPECT_TRUE(row_sp->GetRegisterInfo(k_r13, regloc));
1216 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
1233 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1239 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1240 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1243 EXPECT_TRUE(row_sp->GetRegisterInfo(k_r12, regloc));
1244 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
1261 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1267 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1268 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1271 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbx, regloc));
1272 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
1293 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1298 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
1299 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1322 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1327 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
1328 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1351 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1356 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
1357 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1377 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1382 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
1383 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1386 EXPECT_TRUE(row_sp->GetRegisterInfo(k_ebx, regloc));
1387 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
1405 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1410 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
1411 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1414 EXPECT_TRUE(row_sp->GetRegisterInfo(k_ebp, regloc));
1415 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
1432 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1438 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1439 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1442 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbp, regloc));
1443 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
1461 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1466 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
1467 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1470 EXPECT_TRUE(row_sp->GetRegisterInfo(k_esi, regloc));
1471 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
1489 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1494 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
1495 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1498 EXPECT_TRUE(row_sp->GetRegisterInfo(k_edi, regloc));
1499 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
1516 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1522 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
1523 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1533 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1538 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
1539 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1549 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1554 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_ebp);
1555 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1565 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1570 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_ebp);
1571 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1589 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1594 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1595 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1605 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1610 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1611 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1629 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1634 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1635 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1645 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1650 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1651 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1669 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1674 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1675 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1685 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
1690 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1691 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1709 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1714 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1715 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1725 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
1730 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1731 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1752 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
1757 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1758 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1778 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
1783 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1784 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1804 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
1809 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1810 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1830 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
1835 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1836 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1856 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
1861 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1862 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1882 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
1887 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1888 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1908 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
1913 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1914 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1934 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
1939 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1940 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1960 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
1965 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1966 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
1986 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
1991 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
1992 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2012 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
2017 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2018 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2047 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
2052 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2053 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2058 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2059 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2079 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
2084 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2085 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2089 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
2094 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2095 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2118 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
2123 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2124 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2147 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
2152 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
2155 EXPECT_TRUE(row_sp->GetRegisterInfo(k_r14, regloc));
2156 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2159 EXPECT_TRUE(row_sp->GetRegisterInfo(k_r15, regloc));
2160 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2163 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbx, regloc));
2164 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2185 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
2190 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
2193 EXPECT_TRUE(row_sp->GetRegisterInfo(k_ebx, regloc));
2194 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2197 EXPECT_TRUE(row_sp->GetRegisterInfo(k_esi, regloc));
2198 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2267 EXPECT_TRUE(engine64->AugmentUnwindPlanFromCallSite(
2278 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2289 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2354 EXPECT_TRUE(engine64->AugmentUnwindPlanFromCallSite(
2359 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2432 EXPECT_TRUE(engine32->AugmentUnwindPlanFromCallSite(
2437 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
2469 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
2474 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
2475 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2478 EXPECT_TRUE(row_sp->GetRegisterInfo(k_ebp, regloc));
2479 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2484 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
2489 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2490 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2617 EXPECT_TRUE(
2619 EXPECT_TRUE(reg_loc.IsAtAFAPlusOffset());
2637 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
2642 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
2673 EXPECT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(
2689 EXPECT_TRUE(unwind_plan.GetInitialCFARegister() == k_rsp);
2690 EXPECT_TRUE(unwind_plan.GetUnwindPlanValidAtAllInstructions() ==
2692 EXPECT_TRUE(unwind_plan.GetSourcedFromCompiler() == eLazyBoolNo);
2699 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2700 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2703 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
2704 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2710 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2711 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2714 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
2715 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2721 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
2722 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2725 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
2726 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2732 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2733 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2736 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
2737 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2743 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
2744 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2747 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
2748 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2754 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2755 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2758 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
2759 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2765 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
2766 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2769 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
2770 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2776 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2777 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2780 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
2781 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2787 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
2788 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2791 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
2792 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2798 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2799 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2802 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
2803 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2809 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
2810 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2813 EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
2814 EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
2857 EXPECT_TRUE(engine32->GetNonCallSiteUnwindPlanFromAssembly(
2864 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
2865 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2873 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_ebp);
2874 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2882 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_ebp);
2883 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2891 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
2892 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2899 EXPECT_TRUE(engine64->GetNonCallSiteUnwindPlanFromAssembly(
2906 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2907 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2915 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
2916 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2924 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
2925 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
2933 EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
2934 EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
tools/lldb/unittests/Utility/ArchSpecTest.cpp 22 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-10", AS));
27 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-15", AS));
32 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12.15", AS));
40 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("13.11", AS));
61 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-15-vendor-os", AS));
68 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-10-vendor-os-name", AS));
75 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-15-vendor.os-name", AS));
84 EXPECT_TRUE(ParseMachCPUDashSubtypeTriple("12-10-vendor", AS));
101 EXPECT_TRUE(AS.SetTriple("12-10-apple-darwin"));
104 EXPECT_TRUE(llvm::StringRef(AS.GetTriple().str())
109 EXPECT_TRUE(AS.SetTriple("18.100-apple-darwin"));
112 EXPECT_TRUE(llvm::StringRef(AS.GetTriple().str())
117 EXPECT_TRUE(AS.SetTriple("i686-pc-windows"));
121 EXPECT_TRUE(
163 EXPECT_TRUE(A.IsValid());
164 EXPECT_TRUE(B.IsValid());
165 EXPECT_TRUE(C.IsValid());
166 EXPECT_TRUE(D.IsValid());
201 EXPECT_TRUE(A.IsValid());
202 EXPECT_TRUE(B.IsValid());
299 EXPECT_TRUE(ArchSpec("x86_64-pc-linux"));
tools/lldb/unittests/Utility/BroadcasterTest.cpp 32 EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
42 EXPECT_TRUE(listener2_sp->GetEvent(event_sp, timeout));
47 EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
49 EXPECT_TRUE(listener2_sp->GetEvent(event_sp, timeout));
55 EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
70 EXPECT_TRUE(broadcaster.EventTypeHasListeners(event_mask));
tools/lldb/unittests/Utility/ConstStringTest.cpp 29 EXPECT_TRUE(xyz.GetMangledCounterpart(counterpart));
32 EXPECT_TRUE(uvw.GetMangledCounterpart(counterpart));
51 EXPECT_TRUE(ConstString("some").GetMangledCounterpart(counterpart));
69 EXPECT_TRUE(bar.GetMangledCounterpart(counterpart));
72 EXPECT_TRUE(foo.GetMangledCounterpart(counterpart));
83 EXPECT_TRUE(!empty);
84 EXPECT_TRUE(empty.IsEmpty());
88 EXPECT_TRUE(!null);
89 EXPECT_TRUE(null.IsEmpty());
90 EXPECT_TRUE(null.IsNull());
98 EXPECT_TRUE(foo == foo2);
99 EXPECT_TRUE(foo2 == foo);
100 EXPECT_TRUE(foo == ConstString("foo"));
112 EXPECT_TRUE(empty == ConstString(""));
116 EXPECT_TRUE(null == ConstString());
123 EXPECT_TRUE(foo == "foo");
124 EXPECT_TRUE(foo != "");
126 EXPECT_TRUE(foo != "bar");
132 EXPECT_TRUE(empty != "bar");
136 EXPECT_TRUE(null != "");
137 EXPECT_TRUE(null == static_cast<const char *>(nullptr));
138 EXPECT_TRUE(null != "bar");
tools/lldb/unittests/Utility/EnvironmentTest.cpp 45 EXPECT_TRUE(FOO_EQ_BAR == Envp_[0] || FOO_EQ_BAR == Envp_[1]);
46 EXPECT_TRUE(BAR_EQ_BAZ == Envp_[0] || BAR_EQ_BAZ == Envp_[1]);
tools/lldb/unittests/Utility/FileSpecTest.cpp 337 EXPECT_TRUE(spec.IsRelative());
344 EXPECT_TRUE(fs_posix.RemoveLastPathComponent());
346 EXPECT_TRUE(fs_posix.RemoveLastPathComponent());
348 EXPECT_TRUE(fs_posix.RemoveLastPathComponent());
355 EXPECT_TRUE(fs_posix_relative.RemoveLastPathComponent());
357 EXPECT_TRUE(fs_posix_relative.RemoveLastPathComponent());
371 EXPECT_TRUE(fs_windows.RemoveLastPathComponent());
373 EXPECT_TRUE(fs_windows.RemoveLastPathComponent());
375 EXPECT_TRUE(fs_windows.RemoveLastPathComponent());
377 EXPECT_TRUE(fs_windows.RemoveLastPathComponent());
tools/lldb/unittests/Utility/FlagsTest.cpp 56 EXPECT_TRUE(f.AllSet(eFlag0 | eFlag1));
71 EXPECT_TRUE(f.AnySet(eFlag0 | eFlag1));
74 EXPECT_TRUE(f.AnySet(eFlag0 | eFlag1));
77 EXPECT_TRUE(f.AnySet(eFlag0 | eFlag1));
91 EXPECT_TRUE(f.Test(eFlag0));
96 EXPECT_TRUE(f.Test(eFlag0));
97 EXPECT_TRUE(f.Test(eFlag1));
102 EXPECT_TRUE(f.Test(eFlag1));
111 EXPECT_TRUE(f.AllClear(eFlag0 | eFlag1));
121 EXPECT_TRUE(f.AnyClear(eFlag0 | eFlag1));
126 EXPECT_TRUE(f.AnyClear(eFlag0 | eFlag1));
129 EXPECT_TRUE(f.AnyClear(eFlag0 | eFlag1));
136 EXPECT_TRUE(f.AnyClear(eFlag0 | eFlag1));
139 EXPECT_TRUE(f.AnyClear(eFlag0 | eFlag1));
145 EXPECT_TRUE(f.IsClear(eFlag0));
146 EXPECT_TRUE(f.IsClear(eFlag1));
150 EXPECT_TRUE(f.IsClear(eFlag1));
157 EXPECT_TRUE(f.IsClear(eFlag0));
161 EXPECT_TRUE(f.IsClear(eFlag0));
162 EXPECT_TRUE(f.IsClear(eFlag1));
tools/lldb/unittests/Utility/ListenerTest.cpp 40 EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
43 EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
46 EXPECT_TRUE(
52 EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
77 EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
80 EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
83 EXPECT_TRUE(
89 EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
101 EXPECT_TRUE(listener_sp->GetEvent(event_sp, llvm::None));
105 EXPECT_TRUE(
110 EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
tools/lldb/unittests/Utility/LogTest.cpp 131 EXPECT_TRUE(Log::EnableLogChannel(stream_sp, 0, "chan", {"foo"}, llvm::nulls()));
146 EXPECT_TRUE(EnableChannel(stream_sp, 0, "chan", {}, error));
150 EXPECT_TRUE(EnableChannel(stream_sp, 0, "chan", {"bar"}, error));
153 EXPECT_TRUE(EnableChannel(stream_sp, 0, "chan", {"baz"}, error));
165 EXPECT_TRUE(
170 EXPECT_TRUE(log->GetVerbose());
179 EXPECT_TRUE(EnableChannel(stream_sp, 0, "chan", {"foo", "bar"}, error));
182 EXPECT_TRUE(DisableChannel("chan", {"bar"}, error));
186 EXPECT_TRUE(DisableChannel("chan", {"baz"}, error));
192 EXPECT_TRUE(DisableChannel("chan", {}, error));
198 EXPECT_TRUE(ListCategories("chan", list));
215 EXPECT_TRUE(EnableChannel(getStream(), LLDB_LOG_OPTION_THREADSAFE, "chan", {},
220 EXPECT_TRUE(EnableChannel(getStream(), LLDB_LOG_OPTION_PREPEND_SEQUENCE,
228 EXPECT_TRUE(EnableChannel(getStream(), LLDB_LOG_OPTION_PREPEND_FILE_FUNCTION,
239 EXPECT_TRUE(EnableChannel(
271 EXPECT_TRUE(DisableChannel("chan", {}, err));
288 EXPECT_TRUE(
307 EXPECT_TRUE(DisableChannel("chan", {}, err));
tools/lldb/unittests/Utility/NameMatchesTest.cpp 15 EXPECT_TRUE(NameMatches("foo", NameMatch::Ignore, "bar"));
19 EXPECT_TRUE(NameMatches("foo", NameMatch::Equals, "foo"));
24 EXPECT_TRUE(NameMatches("foobar", NameMatch::Contains, "foo"));
25 EXPECT_TRUE(NameMatches("foobar", NameMatch::Contains, "oob"));
26 EXPECT_TRUE(NameMatches("foobar", NameMatch::Contains, "bar"));
27 EXPECT_TRUE(NameMatches("foobar", NameMatch::Contains, "foobar"));
28 EXPECT_TRUE(NameMatches("", NameMatch::Contains, ""));
34 EXPECT_TRUE(NameMatches("foo", NameMatch::StartsWith, "f"));
35 EXPECT_TRUE(NameMatches("foo", NameMatch::StartsWith, ""));
36 EXPECT_TRUE(NameMatches("", NameMatch::StartsWith, ""));
42 EXPECT_TRUE(NameMatches("foo", NameMatch::EndsWith, "o"));
43 EXPECT_TRUE(NameMatches("foo", NameMatch::EndsWith, ""));
44 EXPECT_TRUE(NameMatches("", NameMatch::EndsWith, ""));
50 EXPECT_TRUE(NameMatches("foobar", NameMatch::RegularExpression, "foo"));
51 EXPECT_TRUE(NameMatches("foobar", NameMatch::RegularExpression, "f[oa]o"));
tools/lldb/unittests/Utility/PredicateTest.cpp 17 EXPECT_TRUE(P.WaitForValueEqualTo(0));
24 EXPECT_TRUE(P.WaitForValueEqualTo(1));
tools/lldb/unittests/Utility/ProcessInstanceInfoTest.cpp 104 EXPECT_TRUE(match.Matches(info_bar));
108 EXPECT_TRUE(match.Matches(info_bar));
109 EXPECT_TRUE(match.Matches(info_empty));
tools/lldb/unittests/Utility/RangeTest.cpp 40 EXPECT_TRUE(r.IsValid());
49 EXPECT_TRUE(r.IsValid());
58 EXPECT_TRUE(r == RangeT());
64 EXPECT_TRUE(r == RangeT(4, 0));
101 EXPECT_TRUE(r.Contains(3));
102 EXPECT_TRUE(r.Contains(4));
103 EXPECT_TRUE(r.Contains(5));
104 EXPECT_TRUE(r.Contains(6));
105 EXPECT_TRUE(r.Contains(7));
125 EXPECT_TRUE(r.ContainsEndInclusive(3));
126 EXPECT_TRUE(r.ContainsEndInclusive(4));
127 EXPECT_TRUE(r.ContainsEndInclusive(5));
128 EXPECT_TRUE(r.ContainsEndInclusive(6));
129 EXPECT_TRUE(r.ContainsEndInclusive(7));
130 EXPECT_TRUE(r.ContainsEndInclusive(8));
138 EXPECT_TRUE(r.ContainsEndInclusive(0));
148 EXPECT_TRUE(r.Contains(r));
160 EXPECT_TRUE(r.Contains(RangeT(4, 3)));
162 EXPECT_TRUE(r.Contains(RangeT(3, 4)));
164 EXPECT_TRUE(r.Contains(RangeT(4, 4)));
174 EXPECT_TRUE(r.Contains(RangeT(3, 0)));
175 EXPECT_TRUE(r.Contains(RangeT(4, 0)));
181 EXPECT_TRUE(r.Contains(r));
184 EXPECT_TRUE(r.Contains(RangeT()));
200 EXPECT_TRUE(r.Union(RangeT(8, 2)));
204 EXPECT_TRUE(r.Union(RangeT(1, 2)));
208 EXPECT_TRUE(r.Union(RangeT(8, 3)));
212 EXPECT_TRUE(r.Union(RangeT(0, 1)));
216 EXPECT_TRUE(r.Union(RangeT(0, 3)));
218 EXPECT_TRUE(r.Union(RangeT(5, 1)));
220 EXPECT_TRUE(r.Union(RangeT(9, 2)));
228 EXPECT_TRUE(r.DoesAdjoinOrIntersect(RangeT(1, 2)));
229 EXPECT_TRUE(r.DoesAdjoinOrIntersect(RangeT(2, 2)));
230 EXPECT_TRUE(r.DoesAdjoinOrIntersect(RangeT(4, 2)));
231 EXPECT_TRUE(r.DoesAdjoinOrIntersect(RangeT(6, 2)));
232 EXPECT_TRUE(r.DoesAdjoinOrIntersect(RangeT(7, 2)));
241 EXPECT_TRUE(r.DoesIntersect(RangeT(2, 2)));
242 EXPECT_TRUE(r.DoesIntersect(RangeT(4, 2)));
243 EXPECT_TRUE(r.DoesIntersect(RangeT(6, 2)));
256 EXPECT_TRUE(r1 < r2);
286 EXPECT_TRUE(r == RangeT(10, 20));
304 EXPECT_TRUE(r != RangeT(10, 21));
305 EXPECT_TRUE(r != RangeT(9, 20));
306 EXPECT_TRUE(r != RangeT(9, 21));
312 EXPECT_TRUE(RangeT() < RangeT(1, 0));
313 EXPECT_TRUE(RangeT() < RangeT(2, 0));
314 EXPECT_TRUE(RangeT(1, 0) < RangeT(2, 0));
319 EXPECT_TRUE(r == RangeT());
tools/lldb/unittests/Utility/RegularExpressionTest.cpp 19 EXPECT_TRUE(r1.IsValid());
21 EXPECT_TRUE(r1.Execute("916"));
28 EXPECT_TRUE(r2.IsValid());
30 EXPECT_TRUE(r2.Execute("916"));
36 EXPECT_TRUE(static_cast<bool>(err));
46 EXPECT_TRUE(static_cast<bool>(err));
56 EXPECT_TRUE(r1.IsValid());
60 EXPECT_TRUE(r1.Execute("9a:513b", &matches));
tools/lldb/unittests/Utility/ReproducerInstrumentationTest.cpp 239 EXPECT_TRUE(m_get_instrumend_foo_called);
298 EXPECT_TRUE(deserializer.HasData(1));
tools/lldb/unittests/Utility/ScalarTest.cpp 195 EXPECT_TRUE(r.IsValid());
216 EXPECT_TRUE(lhs.Promote(int_types[i])) << "int promotion #" << i;
218 EXPECT_TRUE(rhs.Promote(float_types[j])) << "float promotion #" << j;
220 EXPECT_TRUE(x.Promote(float_types[j]));
228 EXPECT_TRUE(lhs.Promote(float_types[i])) << "float promotion #" << i;
230 EXPECT_TRUE(rhs.Promote(float_types[j])) << "float promotion #" << j;
232 EXPECT_TRUE(x.Promote(float_types[j]));
tools/lldb/unittests/Utility/StatusTest.cpp 26 EXPECT_TRUE(Status(llvm::Error::success()).Success());
30 EXPECT_TRUE(eagain.Fail());
36 EXPECT_TRUE(foo.Fail());
41 EXPECT_TRUE(foo.Success());
48 EXPECT_TRUE(bool(eagain));
54 EXPECT_TRUE(bool(foo));
tools/lldb/unittests/Utility/StreamTest.cpp 329 EXPECT_TRUE(!TakeValue().empty());
339 EXPECT_TRUE(!TakeValue().empty());
tools/lldb/unittests/Utility/StringExtractorTest.cpp 491 EXPECT_TRUE(ex.GetNameColonValue(name, value));
494 EXPECT_TRUE(ex.GetNameColonValue(name, value));
506 EXPECT_TRUE(ex.GetNameColonValue(name, value));
509 EXPECT_TRUE(ex.GetNameColonValue(name, value));
tools/lldb/unittests/Utility/StringLexerTest.cpp 28 EXPECT_TRUE(l.HasAtLeast(3));
29 EXPECT_TRUE(l.HasAtLeast(2));
30 EXPECT_TRUE(l.HasAtLeast(1));
36 EXPECT_TRUE(l.HasAtLeast(2));
37 EXPECT_TRUE(l.HasAtLeast(1));
53 EXPECT_TRUE(l.AdvanceIf("fo"));
56 EXPECT_TRUE(l.AdvanceIf("obar"));
105 EXPECT_TRUE(l.NextIf('f'));
111 EXPECT_TRUE(l.NextIf('o'));
117 EXPECT_TRUE(l.NextIf('o'));
126 EXPECT_TRUE(r.first);
132 EXPECT_TRUE(r.first);
138 EXPECT_TRUE(r.first);
tools/lldb/unittests/Utility/TimeoutTest.cpp 18 EXPECT_TRUE(bool(Timeout<std::micro>(seconds(0))));
21 EXPECT_TRUE(bool(Timeout<std::micro>(Timeout<std::milli>(seconds(0)))));
tools/lldb/unittests/Utility/UUIDTest.cpp 50 EXPECT_TRUE(a16);
51 EXPECT_TRUE(a20);
52 EXPECT_TRUE(from_str);
tools/lldb/unittests/Utility/VMRangeTest.cpp 28 EXPECT_TRUE(range.IsValid());
59 EXPECT_TRUE(VMRange(0x200, 0x200) == range);
71 EXPECT_TRUE(range.IsValid());
79 EXPECT_TRUE(range.Contains(0x100));
80 EXPECT_TRUE(range.Contains(0x101));
81 EXPECT_TRUE(range.Contains(0x1FF));
95 EXPECT_TRUE(range.Contains(VMRange(0x100, 0x105)));
96 EXPECT_TRUE(range.Contains(VMRange(0x101, 0x105)));
97 EXPECT_TRUE(range.Contains(VMRange(0x100, 0x1FF)));
98 EXPECT_TRUE(range.Contains(VMRange(0x105, 0x200)));
101 EXPECT_TRUE(range.Contains(VMRange(0x100, 0x200)));
106 EXPECT_TRUE(range.Contains(VMRange(0x100, 0x100)));
141 EXPECT_TRUE(VMRange::ContainsValue(collection, 0x100));
143 EXPECT_TRUE(VMRange::ContainsValue(collection, 0x109));
145 EXPECT_TRUE(VMRange::ContainsRange(collection, VMRange(0x100, 0x104)));
146 EXPECT_TRUE(VMRange::ContainsRange(collection, VMRange(0x108, 0x100)));
tools/polly/unittests/DeLICM/DeLICMTest.cpp 223 EXPECT_TRUE(
225 EXPECT_TRUE(checkIsConflicting({"{ Dom[i] }", nullptr, "{}"},
235 EXPECT_TRUE(checkIsConflictingKnown({"{ Dom[i] -> ValA[] }", nullptr, "{}"},
237 EXPECT_TRUE(checkIsConflictingKnown({"{ Dom[i] -> Val[] }", nullptr, "{}"},
247 EXPECT_TRUE(checkIsConflictingKnown(
259 EXPECT_TRUE(
264 EXPECT_TRUE(checkIsConflicting({"{ Dom[i] }", nullptr, "{}"},
272 EXPECT_TRUE(checkIsConflicting({"{ Dom[1] }", nullptr, "{}"},
280 EXPECT_TRUE(checkIsConflictingKnown({"{ Dom[i] -> ValA[] }", nullptr, "{}"},
282 EXPECT_TRUE(checkIsConflictingKnown({"{ Dom[i] -> Val[] }", nullptr, "{}"},
284 EXPECT_TRUE(checkIsConflictingKnown({"{ Dom[i] -> [] }", nullptr, "{}"},
298 EXPECT_TRUE(checkIsConflicting({"{}", nullptr, "{ Dom[0] }"},
308 EXPECT_TRUE(checkIsConflictingKnown({"{}", nullptr, "{ Dom[0] -> ValA[] }"},
310 EXPECT_TRUE(checkIsConflictingKnown({"{}", nullptr, "{ Dom[0] -> Val[] }"},
tools/polly/unittests/Flatten/FlattenTest.cpp 42 EXPECT_TRUE(checkFlatten("{ A[] -> [0] }", "{ A[] -> [0] }"));
43 EXPECT_TRUE(checkFlatten("{ A[i] -> [i, 0] : 0 <= i < 10 }",
45 EXPECT_TRUE(checkFlatten("{ A[i] -> [0, i] : 0 <= i < 10 }",
50 EXPECT_TRUE(checkFlatten(
54 EXPECT_TRUE(checkFlatten(
60 EXPECT_TRUE(checkFlatten(
64 EXPECT_TRUE(checkFlatten(
tools/polly/unittests/Isl/IslTest.cpp 92 EXPECT_TRUE(IslZero.is_zero());
98 EXPECT_TRUE(IslNOne.is_negone());
104 EXPECT_TRUE(IslZero.is_zero());
110 EXPECT_TRUE(IslOne.is_one());
123 EXPECT_TRUE(IslNOne.is_negone());
129 EXPECT_TRUE(IslZero.is_zero());
135 EXPECT_TRUE(IslOne.is_one());
253 EXPECT_TRUE(APLargePow2.isPowerOf2());
271 EXPECT_TRUE(APLargePow2.isPowerOf2());
412 EXPECT_TRUE(Stat.is_ok());
424 EXPECT_TRUE(Stat.is_ok());
435 EXPECT_TRUE(Stat.is_ok());
446 EXPECT_TRUE(Stat.is_ok());
454 EXPECT_TRUE(PwAff.is_cst());
458 EXPECT_TRUE(Stat.is_ok());
464 EXPECT_TRUE(TestMap
476 EXPECT_TRUE(TestUMap
492 EXPECT_TRUE(Aff.is_cst());
496 EXPECT_TRUE(Stat.is_error());
tools/polly/unittests/ScheduleOptimizer/ScheduleOptimizerTest.cpp 30 EXPECT_TRUE(Result.is_equal(isl::set(ctx, "{[0]}")));
42 EXPECT_TRUE(Result.is_equal(isl::set(ctx, "{[1]}")));
54 EXPECT_TRUE(Result.is_equal(isl::set(ctx, "{[1]; [2]}")));
unittests/ADT/APFloatTest.cpp 48 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isSignaling());
49 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isSignaling());
50 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false, &payload).isSignaling());
51 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true, &payload).isSignaling());
78 EXPECT_TRUE(test.isInfinity());
79 EXPECT_TRUE(!test.isNegative());
80 EXPECT_TRUE(test.bitwiseIsEqual(expected));
86 EXPECT_TRUE(!test.isNegative());
87 EXPECT_TRUE(test.bitwiseIsEqual(expected));
93 EXPECT_TRUE(test.isNegative());
94 EXPECT_TRUE(test.bitwiseIsEqual(expected));
100 EXPECT_TRUE(test.isInfinity() && test.isNegative());
101 EXPECT_TRUE(test.bitwiseIsEqual(expected));
107 EXPECT_TRUE(test.isInfinity() && !test.isNegative());
108 EXPECT_TRUE(test.bitwiseIsEqual(expected));
117 EXPECT_TRUE(!test.isInfinity() && !test.isNegative());
118 EXPECT_TRUE(test.bitwiseIsEqual(expected));
125 EXPECT_TRUE(test.bitwiseIsEqual(expected));
131 EXPECT_TRUE(test.isInfinity() && test.isNegative());
132 EXPECT_TRUE(test.bitwiseIsEqual(expected));
139 EXPECT_TRUE(test.bitwiseIsEqual(expected));
145 EXPECT_TRUE(test.isPosZero());
146 EXPECT_TRUE(test.bitwiseIsEqual(expected));
152 EXPECT_TRUE(test.isNegZero());
153 EXPECT_TRUE(test.bitwiseIsEqual(expected));
160 EXPECT_TRUE(test.bitwiseIsEqual(expected));
166 EXPECT_TRUE(test.bitwiseIsEqual(expected));
172 EXPECT_TRUE(test.bitwiseIsEqual(expected));
178 EXPECT_TRUE(test.bitwiseIsEqual(expected));
184 EXPECT_TRUE(test.bitwiseIsEqual(expected));
190 EXPECT_TRUE(test.bitwiseIsEqual(expected));
196 EXPECT_TRUE(test.bitwiseIsEqual(expected));
202 EXPECT_TRUE(test.bitwiseIsEqual(expected));
208 EXPECT_TRUE(test.bitwiseIsEqual(expected));
224 EXPECT_TRUE(test.bitwiseIsEqual(expected));
233 EXPECT_TRUE(test.bitwiseIsEqual(expected));
241 EXPECT_TRUE(test.isDenormal());
242 EXPECT_TRUE(test.bitwiseIsEqual(expected));
250 EXPECT_TRUE(test.isDenormal());
251 EXPECT_TRUE(test.bitwiseIsEqual(expected));
264 EXPECT_TRUE(test.bitwiseIsEqual(expected));
270 EXPECT_TRUE(test.bitwiseIsEqual(expected));
276 EXPECT_TRUE(test.bitwiseIsEqual(expected));
282 EXPECT_TRUE(test.bitwiseIsEqual(expected));
300 EXPECT_TRUE(test.isDenormal());
301 EXPECT_TRUE(test.isNegative());
302 EXPECT_TRUE(test.bitwiseIsEqual(expected));
309 EXPECT_TRUE(test.isDenormal());
310 EXPECT_TRUE(!test.isNegative());
311 EXPECT_TRUE(test.bitwiseIsEqual(expected));
318 EXPECT_TRUE(!test.isDenormal());
319 EXPECT_TRUE(!test.isNegative());
320 EXPECT_TRUE(test.bitwiseIsEqual(expected));
327 EXPECT_TRUE(!test.isDenormal());
328 EXPECT_TRUE(test.isNegative());
329 EXPECT_TRUE(test.bitwiseIsEqual(expected));
345 EXPECT_TRUE(test.bitwiseIsEqual(expected));
352 EXPECT_TRUE(test.bitwiseIsEqual(expected));
358 EXPECT_TRUE(test.bitwiseIsEqual(expected));
365 EXPECT_TRUE(test.bitwiseIsEqual(expected));
384 EXPECT_TRUE(test.isDenormal());
385 EXPECT_TRUE(!test.isNegative());
386 EXPECT_TRUE(test.bitwiseIsEqual(expected));
394 EXPECT_TRUE(test.isDenormal());
395 EXPECT_TRUE(!test.isNegative());
396 EXPECT_TRUE(test.bitwiseIsEqual(expected));
404 EXPECT_TRUE(test.isDenormal());
405 EXPECT_TRUE(test.isNegative());
406 EXPECT_TRUE(test.bitwiseIsEqual(expected));
414 EXPECT_TRUE(test.isDenormal());
415 EXPECT_TRUE(test.isNegative());
416 EXPECT_TRUE(test.bitwiseIsEqual(expected));
424 EXPECT_TRUE(!test.isDenormal());
425 EXPECT_TRUE(!test.isNegative());
426 EXPECT_TRUE(test.bitwiseIsEqual(expected));
434 EXPECT_TRUE(!test.isDenormal());
435 EXPECT_TRUE(!test.isNegative());
436 EXPECT_TRUE(test.bitwiseIsEqual(expected));
444 EXPECT_TRUE(!test.isDenormal());
445 EXPECT_TRUE(test.isNegative());
446 EXPECT_TRUE(test.bitwiseIsEqual(expected));
454 EXPECT_TRUE(!test.isDenormal());
455 EXPECT_TRUE(test.isNegative());
456 EXPECT_TRUE(test.bitwiseIsEqual(expected));
488 EXPECT_TRUE(!f1.isNegative() && f1.isZero());
499 EXPECT_TRUE(f1.isNegative() && f1.isZero());
509 EXPECT_TRUE(f1.isNegative() && f1.isZero());
518 EXPECT_TRUE(f1.isNegative() && f1.isZero());
568 EXPECT_TRUE(std::isnan(minimum(f1, nan).convertToDouble()));
569 EXPECT_TRUE(std::isnan(minimum(nan, f1).convertToDouble()));
583 EXPECT_TRUE(std::isnan(maximum(f1, nan).convertToDouble()));
584 EXPECT_TRUE(std::isnan(maximum(nan, f1).convertToDouble()));
599 EXPECT_TRUE(T.isDenormal());
611 EXPECT_TRUE(T.isDenormal());
623 EXPECT_TRUE(T.isDenormal());
635 EXPECT_TRUE(T.isDenormal());
642 EXPECT_TRUE(APFloat(-0.0f).isNegative());
646 EXPECT_TRUE(APFloat(-0.0).isNegative());
900 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "99e99999").isInfinity());
901 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-99e99999").isInfinity());
902 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "1e-99999").isPosZero());
903 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-1e-99999").isNegZero());
1058 EXPECT_TRUE(isExact);
1083 EXPECT_TRUE(isExact);
1321 EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
1322 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
1323 EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
1324 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
1325 EXPECT_TRUE(APFloat(APFloat::IEEEquad(), "2.0").getExactInverse(&inv));
1326 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad(), "0.5")));
1327 EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble(), "2.0").getExactInverse(&inv));
1328 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble(), "0.5")));
1329 EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended(), "2.0").getExactInverse(&inv));
1330 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended(), "0.5")));
1333 EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
1334 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));
1394 EXPECT_TRUE(std::isnan(P.convertToDouble()));
1397 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() > 0.0);
1400 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() < 0.0);
1405 EXPECT_TRUE(T.isInteger());
1415 EXPECT_TRUE(T.isInteger());
1423 EXPECT_TRUE(T.isInteger());
1445 EXPECT_TRUE(test.isFiniteNonZero());
1446 EXPECT_TRUE(test.isDenormal());
1447 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1451 EXPECT_TRUE(test.isNegative());
1452 EXPECT_TRUE(test.isFiniteNonZero());
1453 EXPECT_TRUE(test.isDenormal());
1454 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1459 EXPECT_TRUE(test.isFiniteNonZero());
1460 EXPECT_TRUE(test.isDenormal());
1461 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1465 EXPECT_TRUE(test.isNegative());
1466 EXPECT_TRUE(test.isFiniteNonZero());
1467 EXPECT_TRUE(test.isDenormal());
1468 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1475 EXPECT_TRUE(test.isFiniteNonZero());
1477 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1481 EXPECT_TRUE(test.isNegative());
1482 EXPECT_TRUE(test.isFiniteNonZero());
1484 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1489 EXPECT_TRUE(test.isFiniteNonZero());
1491 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1495 EXPECT_TRUE(test.isNegative());
1496 EXPECT_TRUE(test.isFiniteNonZero());
1498 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1528 EXPECT_TRUE(test.isZero());
1529 EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative());
1530 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1539 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1541 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1543 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1545 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1560 EXPECT_TRUE(losesInfo);
1566 EXPECT_TRUE(losesInfo);
1577 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1584 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1590 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1596 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1648 EXPECT_TRUE(t.isNegative());
1651 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), true).isNegative());
1654 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), true).isNegative());
1657 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), true).isNegative());
1660 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isNegative());
1665 EXPECT_TRUE(t.isNormal());
1676 EXPECT_TRUE(t.isFinite());
1678 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), false).isFinite());
1681 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFinite());
1687 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), false).isInfinity());
1699 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNaN());
1700 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNaN());
1706 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p+0").isFiniteNonZero());
1707 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p+0").isFiniteNonZero());
1710 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFiniteNonZero());
1711 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").isFiniteNonZero());
2014 EXPECT_TRUE(result.bitwiseIsEqual(x));
2015 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2016 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2302 EXPECT_TRUE(result.bitwiseIsEqual(x));
2303 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2304 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2591 EXPECT_TRUE(result.bitwiseIsEqual(x));
2592 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2593 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2880 EXPECT_TRUE(result.bitwiseIsEqual(x));
2881 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2882 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2890 EXPECT_TRUE(Two.bitwiseIsEqual(One + One));
2891 EXPECT_TRUE(One.bitwiseIsEqual(Two - One));
2892 EXPECT_TRUE(Two.bitwiseIsEqual(One * Two));
2893 EXPECT_TRUE(One.bitwiseIsEqual(Two / Two));
2916 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf)));
2917 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf)));
2918 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero)));
2919 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero)));
2920 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN)));
2921 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN)));
2922 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN)));
2923 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN)));
2924 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue)));
2925 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue)));
2926 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue)));
2927 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue)));
2928 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue)));
2929 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue)));
2930 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized)));
2931 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
2944 EXPECT_TRUE(NegOne.bitwiseIsEqual(neg(One)));
2945 EXPECT_TRUE(One.bitwiseIsEqual(neg(NegOne)));
2946 EXPECT_TRUE(NegZero.bitwiseIsEqual(neg(Zero)));
2947 EXPECT_TRUE(Zero.bitwiseIsEqual(neg(NegZero)));
2948 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
2949 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
2950 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
2951 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
2952 EXPECT_TRUE(NegQNaN.bitwiseIsEqual(neg(QNaN)));
2953 EXPECT_TRUE(QNaN.bitwiseIsEqual(neg(NegQNaN)));
3002 EXPECT_TRUE(
3005 EXPECT_TRUE(
3008 EXPECT_TRUE(
3020 EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0, RM)));
3021 EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0, RM)));
3022 EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0, RM)));
3023 EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0, RM)));
3024 EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0, RM)));
3025 EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0, RM)));
3029 EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling());
3040 EXPECT_TRUE(QuietPayload.isNaN() && !QuietPayload.isSignaling());
3043 EXPECT_TRUE(PInf.bitwiseIsEqual(
3045 EXPECT_TRUE(MInf.bitwiseIsEqual(
3047 EXPECT_TRUE(PInf.bitwiseIsEqual(
3049 EXPECT_TRUE(PZero.bitwiseIsEqual(
3051 EXPECT_TRUE(MZero.bitwiseIsEqual(
3053 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").bitwiseIsEqual(
3055 EXPECT_TRUE(PZero.bitwiseIsEqual(
3074 EXPECT_TRUE(SmallestF64.bitwiseIsEqual(
3076 EXPECT_TRUE(NegSmallestF64.bitwiseIsEqual(
3079 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
3082 EXPECT_TRUE(scalbn(SmallestF64, -2097, RM).isPosZero());
3083 EXPECT_TRUE(scalbn(SmallestF64, -2098, RM).isPosZero());
3084 EXPECT_TRUE(scalbn(SmallestF64, -2099, RM).isPosZero());
3085 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1022")
3087 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
3089 EXPECT_TRUE(scalbn(SmallestF64, 2098, RM).isInfinity());
3090 EXPECT_TRUE(scalbn(SmallestF64, 2099, RM).isInfinity());
3093 EXPECT_TRUE(scalbn(SmallestF64, -INT_MAX, RM).isPosZero());
3094 EXPECT_TRUE(scalbn(LargestF64, INT_MAX, RM).isInfinity());
3096 EXPECT_TRUE(LargestDenormalF64
3098 EXPECT_TRUE(NegLargestDenormalF64
3101 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1022")
3103 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1021")
3106 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1")
3108 EXPECT_TRUE(scalbn(LargestDenormalF64, -1023, RM).isPosZero());
3109 EXPECT_TRUE(scalbn(LargestDenormalF64, -1024, RM).isPosZero());
3110 EXPECT_TRUE(scalbn(LargestDenormalF64, -2048, RM).isPosZero());
3111 EXPECT_TRUE(scalbn(LargestDenormalF64, 2047, RM).isInfinity());
3112 EXPECT_TRUE(scalbn(LargestDenormalF64, 2098, RM).isInfinity());
3113 EXPECT_TRUE(scalbn(LargestDenormalF64, 2099, RM).isInfinity());
3115 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-2")
3117 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1")
3119 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+0")
3121 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1023")
3123 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+974")
3127 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-972")
3129 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1")
3131 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-2")
3133 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+0")
3136 EXPECT_TRUE(scalbn(RandomDenormalF64, -2097, RM).isPosZero());
3137 EXPECT_TRUE(scalbn(RandomDenormalF64, -2090, RM).isPosZero());
3140 EXPECT_TRUE(
3144 EXPECT_TRUE(
3148 EXPECT_TRUE(
3152 EXPECT_TRUE(
3155 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1074")
3157 EXPECT_TRUE(scalbn(NegLargestF64, -2099, RM).isNegZero());
3158 EXPECT_TRUE(scalbn(LargestF64, 1, RM).isInfinity());
3161 EXPECT_TRUE(
3165 EXPECT_TRUE(
3216 EXPECT_TRUE(Frac.isPosZero());
3220 EXPECT_TRUE(Frac.isNegZero());
3225 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3229 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3233 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3237 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3242 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3246 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3251 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3255 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3260 EXPECT_TRUE(Frac.isInfinity() && !Frac.isNegative());
3264 EXPECT_TRUE(Frac.isInfinity() && Frac.isNegative());
3268 EXPECT_TRUE(Frac.isNaN());
3272 EXPECT_TRUE(Frac.isNaN());
3276 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3280 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3285 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1").bitwiseIsEqual(Frac));
3289 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3293 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac));
3302 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3309 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3317 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3324 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3331 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3338 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3344 EXPECT_TRUE(f1.isNaN());
3350 EXPECT_TRUE(f1.isNaN());
3356 EXPECT_TRUE(f1.isNaN());
3363 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3370 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3967 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isSmallest());
3968 EXPECT_TRUE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isLargest());
3972 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isDenormal());
3981 EXPECT_TRUE(
unittests/ADT/APIntTest.cpp 22 EXPECT_TRUE(!Zero);
23 EXPECT_TRUE(!Zero.zext(64));
24 EXPECT_TRUE(!Zero.sext(64));
31 EXPECT_TRUE(Shl[0]);
240 EXPECT_TRUE(zero.isMaxSignedValue());
243 EXPECT_TRUE(one.isMinSignedValue());
389 EXPECT_TRUE(!APInt(8, 1).uge(256));
390 EXPECT_TRUE(!APInt(8, 1).ugt(256));
391 EXPECT_TRUE( APInt(8, 1).ule(256));
392 EXPECT_TRUE( APInt(8, 1).ult(256));
393 EXPECT_TRUE(!APInt(8, 1).sge(256));
394 EXPECT_TRUE(!APInt(8, 1).sgt(256));
395 EXPECT_TRUE( APInt(8, 1).sle(256));
396 EXPECT_TRUE( APInt(8, 1).slt(256));
397 EXPECT_TRUE(!(APInt(8, 0) == 256));
398 EXPECT_TRUE( APInt(8, 0) != 256);
399 EXPECT_TRUE(!(APInt(8, 1) == 256));
400 EXPECT_TRUE( APInt(8, 1) != 256);
410 EXPECT_TRUE( u64.uge(uint64max));
411 EXPECT_TRUE(!u64.ugt(uint64max));
412 EXPECT_TRUE( u64.ule(uint64max));
413 EXPECT_TRUE(!u64.ult(uint64max));
414 EXPECT_TRUE( u64.sge(int64max));
415 EXPECT_TRUE( u64.sgt(int64max));
416 EXPECT_TRUE(!u64.sle(int64max));
417 EXPECT_TRUE(!u64.slt(int64max));
418 EXPECT_TRUE( u64.sge(int64min));
419 EXPECT_TRUE( u64.sgt(int64min));
420 EXPECT_TRUE(!u64.sle(int64min));
421 EXPECT_TRUE(!u64.slt(int64min));
423 EXPECT_TRUE(u64 == uint64max);
424 EXPECT_TRUE(u64 != int64max);
425 EXPECT_TRUE(u64 != int64min);
427 EXPECT_TRUE(!s64.uge(uint64max));
428 EXPECT_TRUE(!s64.ugt(uint64max));
429 EXPECT_TRUE( s64.ule(uint64max));
430 EXPECT_TRUE( s64.ult(uint64max));
431 EXPECT_TRUE( s64.sge(int64max));
432 EXPECT_TRUE(!s64.sgt(int64max));
433 EXPECT_TRUE( s64.sle(int64max));
434 EXPECT_TRUE(!s64.slt(int64max));
435 EXPECT_TRUE( s64.sge(int64min));
436 EXPECT_TRUE( s64.sgt(int64min));
437 EXPECT_TRUE(!s64.sle(int64min));
438 EXPECT_TRUE(!s64.slt(int64min));
440 EXPECT_TRUE(s64 != uint64max);
441 EXPECT_TRUE(s64 == int64max);
442 EXPECT_TRUE(s64 != int64min);
444 EXPECT_TRUE( big.uge(uint64max));
445 EXPECT_TRUE( big.ugt(uint64max));
446 EXPECT_TRUE(!big.ule(uint64max));
447 EXPECT_TRUE(!big.ult(uint64max));
448 EXPECT_TRUE( big.sge(int64max));
449 EXPECT_TRUE( big.sgt(int64max));
450 EXPECT_TRUE(!big.sle(int64max));
451 EXPECT_TRUE(!big.slt(int64max));
452 EXPECT_TRUE( big.sge(int64min));
453 EXPECT_TRUE( big.sgt(int64min));
454 EXPECT_TRUE(!big.sle(int64min));
455 EXPECT_TRUE(!big.slt(int64min));
457 EXPECT_TRUE(big != uint64max);
458 EXPECT_TRUE(big != int64max);
459 EXPECT_TRUE(big != int64min);
468 EXPECT_TRUE(!a.slt(edge));
469 EXPECT_TRUE( a.sle(edge));
470 EXPECT_TRUE(!a.sgt(edge));
471 EXPECT_TRUE( a.sge(edge));
472 EXPECT_TRUE( a.slt(edgeP1));
473 EXPECT_TRUE( a.sle(edgeP1));
474 EXPECT_TRUE(!a.sgt(edgeP1));
475 EXPECT_TRUE(!a.sge(edgeP1));
476 EXPECT_TRUE( a.slt(edgeM1));
477 EXPECT_TRUE( a.sle(edgeM1));
478 EXPECT_TRUE(!a.sgt(edgeM1));
479 EXPECT_TRUE(!a.sge(edgeM1));
488 EXPECT_TRUE(!a.ult(edge));
489 EXPECT_TRUE( a.ule(edge));
490 EXPECT_TRUE(!a.ugt(edge));
491 EXPECT_TRUE( a.uge(edge));
492 EXPECT_TRUE( a.ult(edgeP1));
493 EXPECT_TRUE( a.ule(edgeP1));
494 EXPECT_TRUE(!a.ugt(edgeP1));
495 EXPECT_TRUE(!a.uge(edgeP1));
496 EXPECT_TRUE(!a.ult(edgeM1));
497 EXPECT_TRUE(!a.ule(edgeM1));
498 EXPECT_TRUE( a.ugt(edgeM1));
499 EXPECT_TRUE( a.uge(edgeM1));
501 EXPECT_TRUE(!a.slt(edge));
502 EXPECT_TRUE( a.sle(edge));
503 EXPECT_TRUE(!a.sgt(edge));
504 EXPECT_TRUE( a.sge(edge));
505 EXPECT_TRUE( a.slt(edgeP1));
506 EXPECT_TRUE( a.sle(edgeP1));
507 EXPECT_TRUE(!a.sgt(edgeP1));
508 EXPECT_TRUE(!a.sge(edgeP1));
509 EXPECT_TRUE(!a.slt(edgeM1));
510 EXPECT_TRUE(!a.sle(edgeM1));
511 EXPECT_TRUE( a.sgt(edgeM1));
512 EXPECT_TRUE( a.sge(edgeM1));
522 EXPECT_TRUE(!One.slt(One));
523 EXPECT_TRUE(!Two.slt(One));
524 EXPECT_TRUE(MinusOne.slt(One));
525 EXPECT_TRUE(MinusTwo.slt(One));
527 EXPECT_TRUE(One.slt(Two));
528 EXPECT_TRUE(!Two.slt(Two));
529 EXPECT_TRUE(MinusOne.slt(Two));
530 EXPECT_TRUE(MinusTwo.slt(Two));
532 EXPECT_TRUE(!One.slt(MinusOne));
533 EXPECT_TRUE(!Two.slt(MinusOne));
534 EXPECT_TRUE(!MinusOne.slt(MinusOne));
535 EXPECT_TRUE(MinusTwo.slt(MinusOne));
537 EXPECT_TRUE(!One.slt(MinusTwo));
538 EXPECT_TRUE(!Two.slt(MinusTwo));
539 EXPECT_TRUE(!MinusOne.slt(MinusTwo));
540 EXPECT_TRUE(!MinusTwo.slt(MinusTwo));
1691 EXPECT_TRUE(A.isSplat(8));
1692 EXPECT_TRUE(A.isSplat(16));
1693 EXPECT_TRUE(A.isSplat(32));
1697 EXPECT_TRUE(B.isSplat(2));
1698 EXPECT_TRUE(B.isSplat(4));
1699 EXPECT_TRUE(B.isSplat(8));
1700 EXPECT_TRUE(B.isSplat(24));
1707 EXPECT_TRUE(C.isSplat(24));
1714 EXPECT_TRUE(D.isSplat(16));
1715 EXPECT_TRUE(D.isSplat(32));
1718 EXPECT_TRUE(E.isSplat(1));
1719 EXPECT_TRUE(E.isSplat(2));
1720 EXPECT_TRUE(E.isSplat(4));
1721 EXPECT_TRUE(E.isSplat(8));
1722 EXPECT_TRUE(E.isSplat(16));
1723 EXPECT_TRUE(E.isSplat(32));
1738 EXPECT_TRUE(MaskVal.isMask());
1739 EXPECT_TRUE(MaskVal.isMask(I));
1746 EXPECT_TRUE(APInt(32, 0xf0000000).isShiftedMask());
1747 EXPECT_TRUE(APInt(32, 0xffff0000).isShiftedMask());
1748 EXPECT_TRUE(APInt(32, 0xff << 1).isShiftedMask());
1756 EXPECT_TRUE(MaskVal.isShiftedMask());
1760 EXPECT_TRUE(MaskVal.isShiftedMask());
1764 EXPECT_TRUE(MaskVal.isShiftedMask());
2402 EXPECT_TRUE(signmin32.ashr(32).isAllOnesValue());
2410 EXPECT_TRUE(signmin128.ashr(128).isAllOnesValue());
2455 EXPECT_TRUE(i32_1.isSubsetOf(i32_3));
2458 EXPECT_TRUE(i32_3.isSubsetOf(i32_3));
2464 EXPECT_TRUE(i128_1.isSubsetOf(i128_3));
2467 EXPECT_TRUE(i128_3.isSubsetOf(i128_3));
2473 EXPECT_TRUE(i128_1.isSubsetOf(i128_3));
2476 EXPECT_TRUE(i128_3.isSubsetOf(i128_3));
2531 EXPECT_TRUE(Prod.uge(Ai));
2533 EXPECT_TRUE(((Quo - 1).zext(16) * B.zext(16)).ult(Ai));
2564 EXPECT_TRUE(Prod.uge(A));
2566 EXPECT_TRUE(((Quo - 1).sext(16) * B.sext(16)).ult(A));
2572 EXPECT_TRUE(Prod.ule(A));
2574 EXPECT_TRUE(((Quo + 1).sext(16) * B.sext(16)).ugt(A));
2603 EXPECT_TRUE(Overflow);
2617 EXPECT_TRUE(D.getHiBits(Bits).isNullValue() != Overflow);
2717 EXPECT_TRUE(One.isOneValue());
2720 EXPECT_TRUE(MulInv.isNullValue());
unittests/ADT/APSIntTest.cpp 18 EXPECT_TRUE(A.isUnsigned());
30 EXPECT_TRUE(D.isUnsigned());
34 EXPECT_TRUE(A.isUnsigned());
39 EXPECT_TRUE(A.isUnsigned());
44 EXPECT_TRUE(APSInt::get(7).isSigned());
48 EXPECT_TRUE(APSInt::get(-7).isSigned());
55 EXPECT_TRUE(APSInt::getUnsigned(7).isUnsigned());
59 EXPECT_TRUE(APSInt::getUnsigned(-7).isUnsigned());
66 EXPECT_TRUE(APSInt(APInt(3, 7), true).isUnsigned());
67 EXPECT_TRUE(APSInt(APInt(3, 7), false).isSigned());
68 EXPECT_TRUE(APSInt(APInt(4, 7), true).isUnsigned());
69 EXPECT_TRUE(APSInt(APInt(4, 7), false).isSigned());
70 EXPECT_TRUE(APSInt(APInt(4, -7), true).isUnsigned());
71 EXPECT_TRUE(APSInt(APInt(4, -7), false).isSigned());
85 EXPECT_TRUE(APSInt::compareValues(S(7), S(8)) < 0);
86 EXPECT_TRUE(APSInt::compareValues(S(8), S(7)) > 0);
87 EXPECT_TRUE(APSInt::compareValues(S(7), S(7)) == 0);
88 EXPECT_TRUE(APSInt::compareValues(S(-7), S(8)) < 0);
89 EXPECT_TRUE(APSInt::compareValues(S(8), S(-7)) > 0);
90 EXPECT_TRUE(APSInt::compareValues(S(-7), S(-7)) == 0);
91 EXPECT_TRUE(APSInt::compareValues(S(-7), S(-8)) > 0);
92 EXPECT_TRUE(APSInt::compareValues(S(-8), S(-7)) < 0);
93 EXPECT_TRUE(APSInt::compareValues(S(-7), S(-7)) == 0);
96 EXPECT_TRUE(APSInt::compareValues(U(7), U(8)) < 0);
97 EXPECT_TRUE(APSInt::compareValues(U(8), U(7)) > 0);
98 EXPECT_TRUE(APSInt::compareValues(U(7), U(7)) == 0);
101 EXPECT_TRUE(APSInt::compareValues(U(7), S(8)) < 0);
102 EXPECT_TRUE(APSInt::compareValues(U(8), S(7)) > 0);
103 EXPECT_TRUE(APSInt::compareValues(U(7), S(7)) == 0);
104 EXPECT_TRUE(APSInt::compareValues(U(8), S(-7)) > 0);
107 EXPECT_TRUE(APSInt::compareValues(S(7).trunc(32), S(8)) < 0);
108 EXPECT_TRUE(APSInt::compareValues(S(8).trunc(32), S(7)) > 0);
109 EXPECT_TRUE(APSInt::compareValues(S(7).trunc(32), S(7)) == 0);
110 EXPECT_TRUE(APSInt::compareValues(S(-7).trunc(32), S(8)) < 0);
111 EXPECT_TRUE(APSInt::compareValues(S(8).trunc(32), S(-7)) > 0);
112 EXPECT_TRUE(APSInt::compareValues(S(-7).trunc(32), S(-7)) == 0);
113 EXPECT_TRUE(APSInt::compareValues(S(-7).trunc(32), S(-8)) > 0);
114 EXPECT_TRUE(APSInt::compareValues(S(-8).trunc(32), S(-7)) < 0);
115 EXPECT_TRUE(APSInt::compareValues(S(-7).trunc(32), S(-7)) == 0);
116 EXPECT_TRUE(APSInt::compareValues(S(7), S(8).trunc(32)) < 0);
117 EXPECT_TRUE(APSInt::compareValues(S(8), S(7).trunc(32)) > 0);
118 EXPECT_TRUE(APSInt::compareValues(S(7), S(7).trunc(32)) == 0);
119 EXPECT_TRUE(APSInt::compareValues(S(-7), S(8).trunc(32)) < 0);
120 EXPECT_TRUE(APSInt::compareValues(S(8), S(-7).trunc(32)) > 0);
121 EXPECT_TRUE(APSInt::compareValues(S(-7), S(-7).trunc(32)) == 0);
122 EXPECT_TRUE(APSInt::compareValues(S(-7), S(-8).trunc(32)) > 0);
123 EXPECT_TRUE(APSInt::compareValues(S(-8), S(-7).trunc(32)) < 0);
124 EXPECT_TRUE(APSInt::compareValues(S(-7), S(-7).trunc(32)) == 0);
127 EXPECT_TRUE(APSInt::compareValues(U(7), U(8).trunc(32)) < 0);
128 EXPECT_TRUE(APSInt::compareValues(U(8), U(7).trunc(32)) > 0);
129 EXPECT_TRUE(APSInt::compareValues(U(7), U(7).trunc(32)) == 0);
130 EXPECT_TRUE(APSInt::compareValues(U(7).trunc(32), U(8)) < 0);
131 EXPECT_TRUE(APSInt::compareValues(U(8).trunc(32), U(7)) > 0);
132 EXPECT_TRUE(APSInt::compareValues(U(7).trunc(32), U(7)) == 0);
135 EXPECT_TRUE(APSInt::compareValues(U(7).trunc(32), S(8)) < 0);
136 EXPECT_TRUE(APSInt::compareValues(U(8).trunc(32), S(7)) > 0);
137 EXPECT_TRUE(APSInt::compareValues(U(7).trunc(32), S(7)) == 0);
138 EXPECT_TRUE(APSInt::compareValues(U(8).trunc(32), S(-7)) > 0);
139 EXPECT_TRUE(APSInt::compareValues(U(7), S(8).trunc(32)) < 0);
140 EXPECT_TRUE(APSInt::compareValues(U(8), S(7).trunc(32)) > 0);
141 EXPECT_TRUE(APSInt::compareValues(U(7), S(7).trunc(32)) == 0);
142 EXPECT_TRUE(APSInt::compareValues(U(8), S(-7).trunc(32)) > 0);
173 EXPECT_TRUE(False.isNonNegative());
176 EXPECT_TRUE(True.isNegative());
181 EXPECT_TRUE(CharMin.isNonNegative());
185 EXPECT_TRUE(CharSmall.isNonNegative());
186 EXPECT_TRUE(CharSmall.isStrictlyPositive());
189 EXPECT_TRUE(CharBoundaryUnder.isNonNegative());
190 EXPECT_TRUE(CharBoundaryUnder.isStrictlyPositive());
192 EXPECT_TRUE(CharBoundaryOver.isNegative());
196 EXPECT_TRUE(CharLarge.isNegative());
200 EXPECT_TRUE(CharMax.isNegative());
216 EXPECT_TRUE(False.isNonNegative());
220 EXPECT_TRUE(True.isNonNegative());
221 EXPECT_TRUE(True.isStrictlyPositive());
224 EXPECT_TRUE(CharMin.isNonNegative());
228 EXPECT_TRUE(CharSmall.isNonNegative());
229 EXPECT_TRUE(CharSmall.isStrictlyPositive());
232 EXPECT_TRUE(CharBoundaryUnder.isNonNegative());
233 EXPECT_TRUE(CharBoundaryUnder.isStrictlyPositive());
236 EXPECT_TRUE(CharBoundaryOver.isNonNegative());
237 EXPECT_TRUE(CharBoundaryOver.isStrictlyPositive());
240 EXPECT_TRUE(CharLarge.isNonNegative());
241 EXPECT_TRUE(CharLarge.isStrictlyPositive());
244 EXPECT_TRUE(CharMax.isNonNegative());
245 EXPECT_TRUE(CharMax.isStrictlyPositive());
unittests/ADT/AnyTest.cpp 30 EXPECT_TRUE(B.hasValue());
31 EXPECT_TRUE(any_isa<int>(B));
34 EXPECT_TRUE(C.hasValue());
35 EXPECT_TRUE(any_isa<int>(C));
38 EXPECT_TRUE(D.hasValue());
39 EXPECT_TRUE(any_isa<const char *>(D));
43 EXPECT_TRUE(E.hasValue());
44 EXPECT_TRUE(any_isa<double>(E));
50 EXPECT_TRUE(B.hasValue());
51 EXPECT_TRUE(F.hasValue());
52 EXPECT_TRUE(any_isa<int>(F));
53 EXPECT_TRUE(any_isa<int>(B));
59 EXPECT_TRUE(G.hasValue());
60 EXPECT_TRUE(any_isa<int>(G));
65 EXPECT_TRUE(A.hasValue());
66 EXPECT_TRUE(F.hasValue());
67 EXPECT_TRUE(any_isa<int>(A));
68 EXPECT_TRUE(any_isa<int>(F));
72 EXPECT_TRUE(B.hasValue());
74 EXPECT_TRUE(any_isa<int>(B));
114 EXPECT_TRUE(E.hasValue());
unittests/ADT/ArrayRefTest.cpp 59 EXPECT_TRUE(Array1.equals(Array1c));
61 EXPECT_TRUE(Array2.equals(Array2c));
98 EXPECT_TRUE(AR1.drop_back().equals(AR2));
105 EXPECT_TRUE(AR1.drop_front(2).equals(AR2));
134 EXPECT_TRUE(AR1.take_back().equals(AR2));
141 EXPECT_TRUE(AR1.take_front(2).equals(AR2));
169 EXPECT_TRUE(AR1.equals({1, 2, 3, 4, 5, 6, 7, 8}));
180 EXPECT_TRUE(AR1a.equals({1, 2, 3, 4, 5, 6, 7}));
184 EXPECT_TRUE(AR1b.equals({3, 4, 5, 6}));
190 EXPECT_TRUE(ArrayRef<unsigned>() == ArrayRef<unsigned>());
226 EXPECT_TRUE(A.empty());
229 EXPECT_TRUE(A.empty());
245 EXPECT_TRUE(AR2.equals(AR2Ref));
unittests/ADT/BitVectorTest.cpp 30 EXPECT_TRUE(Vec.all());
31 EXPECT_TRUE(Vec.none());
32 EXPECT_TRUE(Vec.empty());
37 EXPECT_TRUE(Vec.any());
38 EXPECT_TRUE(Vec.all());
45 EXPECT_TRUE(Vec.any());
54 EXPECT_TRUE(Inv.any());
60 EXPECT_TRUE(Inv != Vec);
62 EXPECT_TRUE(Inv == Vec);
75 EXPECT_TRUE(Vec[i]);
76 EXPECT_TRUE(Vec.test(i));
81 EXPECT_TRUE(Vec[32]);
89 EXPECT_TRUE(Copy == Alt);
90 EXPECT_TRUE(Vec.size() == 6);
91 EXPECT_TRUE(Vec.count() == 3);
92 EXPECT_TRUE(Vec.find_first() == 3);
105 EXPECT_TRUE(Vec[i]);
106 EXPECT_TRUE(Vec.test(i));
111 EXPECT_TRUE(Vec[32]);
116 EXPECT_TRUE(Vec[60]);
126 EXPECT_TRUE(Vec[32]);
137 EXPECT_TRUE(Vec.none());
143 EXPECT_TRUE(Vec.any());
144 EXPECT_TRUE(Vec.all());
151 EXPECT_TRUE(Vec.any());
152 EXPECT_TRUE(Vec.all());
161 EXPECT_TRUE(Vec.none());
168 EXPECT_TRUE(Inv.all());
169 EXPECT_TRUE(Inv.none());
170 EXPECT_TRUE(Inv.empty());
176 EXPECT_TRUE(Vec.all());
177 EXPECT_TRUE(Vec.none());
178 EXPECT_TRUE(Vec.empty());
464 EXPECT_TRUE(A.test(4));
465 EXPECT_TRUE(A.test(5));
466 EXPECT_TRUE(A.test(7));
467 EXPECT_TRUE(A.test(18));
478 EXPECT_TRUE(A.test(4));
479 EXPECT_TRUE(A.test(5));
487 EXPECT_TRUE(A.test(2));
488 EXPECT_TRUE(A.test(7));
510 EXPECT_TRUE(Small.test(0));
533 EXPECT_TRUE(Big.test(0));
556 EXPECT_TRUE(Small.test(0));
557 EXPECT_TRUE(Small.test(1));
558 EXPECT_TRUE(Small.test(2));
559 EXPECT_TRUE(Small.test(16));
579 EXPECT_TRUE(Big.test(0));
580 EXPECT_TRUE(Big.test(1));
581 EXPECT_TRUE(Big.test(2));
582 EXPECT_TRUE(Big.test(16));
602 EXPECT_TRUE(Small.test(1));
603 EXPECT_TRUE(Small.test(2));
604 EXPECT_TRUE(Small.test(16));
624 EXPECT_TRUE(Big.test(1));
625 EXPECT_TRUE(Big.test(2));
626 EXPECT_TRUE(Big.test(16));
646 EXPECT_TRUE(Small.test(1));
666 EXPECT_TRUE(Big.test(2));
667 EXPECT_TRUE(Big.test(16));
687 EXPECT_TRUE(Big == Small);
688 EXPECT_TRUE(Small == Big);
705 EXPECT_TRUE(Small.anyCommon(Big));
706 EXPECT_TRUE(Big.anyCommon(Small));
721 EXPECT_TRUE(Small.test(Big));
731 EXPECT_TRUE(Vec.none());
735 EXPECT_TRUE(Vec.none());
750 EXPECT_TRUE(A.test(31));
803 EXPECT_TRUE(A.anyCommon(B));
804 EXPECT_TRUE(B.anyCommon(A));
836 EXPECT_TRUE(A.test(2));
837 EXPECT_TRUE(A.test(3));
838 EXPECT_TRUE(A.test(8));
839 EXPECT_TRUE(A.test(9));
943 EXPECT_TRUE( A.test(1));
944 EXPECT_TRUE( A.test(23));
945 EXPECT_TRUE( A.test(254));
953 EXPECT_TRUE( B.test(0));
957 EXPECT_TRUE( B.test(255));
964 EXPECT_TRUE(C.test(0));
974 EXPECT_TRUE( D.test(1));
975 EXPECT_TRUE( D.test(2));
983 EXPECT_TRUE( E.test(1));
984 EXPECT_TRUE( E.test(32));
1002 EXPECT_TRUE(A.test(B));
1004 EXPECT_TRUE(A.test(D));
1009 EXPECT_TRUE(C.test(A));
1010 EXPECT_TRUE(C.test(B));
1012 EXPECT_TRUE(C.test(D));
1016 EXPECT_TRUE(A.all());
1018 EXPECT_TRUE(A.none());
1021 EXPECT_TRUE(A.none());
1027 EXPECT_TRUE(C.none());
1057 EXPECT_TRUE(A.empty());
1061 EXPECT_TRUE(A.all());
1062 EXPECT_TRUE(A.none());
1103 EXPECT_TRUE(false);
unittests/ADT/BumpPtrListTest.cpp 45 EXPECT_TRUE(L.empty());
66 EXPECT_TRUE(L.empty());
87 EXPECT_TRUE(L.empty());
unittests/ADT/DenseMapTest.cpp 40 EXPECT_TRUE(Constructed.insert(this).second);
43 EXPECT_TRUE(Constructed.insert(this).second);
46 EXPECT_TRUE(Constructed.insert(this).second);
114 EXPECT_TRUE(this->Map.empty());
117 EXPECT_TRUE(this->Map.begin() == this->Map.end());
121 EXPECT_TRUE(this->Map.find(this->getKey()) == this->Map.end());
130 EXPECT_TRUE(ConstMap.empty());
131 EXPECT_TRUE(ConstMap.begin() == ConstMap.end());
148 EXPECT_TRUE(it == this->Map.end());
151 EXPECT_TRUE(this->Map.count(this->getKey()));
152 EXPECT_TRUE(this->Map.find(this->getKey()) == this->Map.begin());
163 EXPECT_TRUE(this->Map.empty());
164 EXPECT_TRUE(this->Map.begin() == this->Map.end());
173 EXPECT_TRUE(this->Map.empty());
174 EXPECT_TRUE(this->Map.begin() == this->Map.end());
183 EXPECT_TRUE(this->Map.empty());
184 EXPECT_TRUE(this->Map.begin() == this->Map.end());
218 EXPECT_TRUE(copyMap.empty());
228 EXPECT_TRUE(copyMap.empty());
268 EXPECT_TRUE(this->Map.empty());
274 EXPECT_TRUE(otherMap.empty());
284 EXPECT_TRUE(this->Map.empty());
291 EXPECT_TRUE(otherMap.empty());
325 EXPECT_TRUE(it == cit);
329 EXPECT_TRUE(cit == cit2);
541 EXPECT_TRUE(map.find(3) == map.end());
547 EXPECT_TRUE(map.find_as("d") == map.end());
580 EXPECT_TRUE(map.find(32) == map.end());
587 EXPECT_TRUE(Try1.second);
unittests/ADT/DenseSetTest.cpp 122 EXPECT_TRUE(set.find(3) == set.end());
128 EXPECT_TRUE(set.find_as("d") == set.end());
unittests/ADT/DirectedGraphTest.cpp 100 EXPECT_TRUE(DG.addNode(N1));
101 EXPECT_TRUE(DG.addNode(N2));
102 EXPECT_TRUE(DG.addNode(N3));
108 EXPECT_TRUE(DG.connect(N1, N2, E2));
109 EXPECT_TRUE(DG.connect(N2, N3, E3));
110 EXPECT_TRUE(DG.connect(N3, N1, E1));
123 EXPECT_TRUE(DG.size() == 3);
134 EXPECT_TRUE(DG.findIncomingEdgesToNode(N1, EL));
135 EXPECT_TRUE(EL.size() == 1);
157 EXPECT_TRUE(DG.size() == 3);
174 EXPECT_TRUE(EL.empty());
181 EXPECT_TRUE(DG.findIncomingEdgesToNode(N2, EL));
205 EXPECT_TRUE(N2.hasEdgeTo(N1));
206 EXPECT_TRUE(N3.hasEdgeTo(N1));
227 EXPECT_TRUE(DG.size() == 3);
230 EXPECT_TRUE(DG.removeNode(N1));
239 EXPECT_TRUE(DG.size() == 2);
240 EXPECT_TRUE(N3.getEdges().empty());
243 EXPECT_TRUE(EL.empty());
276 EXPECT_TRUE(ListOfSCCs.size() == 2);
281 EXPECT_TRUE(SCC.size() == 1);
282 EXPECT_TRUE(SCC.count(&N4) == 1);
287 EXPECT_TRUE(SCC.size() == 3);
288 EXPECT_TRUE(SCC.count(&N1) == 1);
289 EXPECT_TRUE(SCC.count(&N2) == 1);
290 EXPECT_TRUE(SCC.count(&N3) == 1);
291 EXPECT_TRUE(SCC.count(&N4) == 0);
unittests/ADT/EquivalenceClassesTest.cpp 23 EXPECT_TRUE(EqClasses.isEquivalent(i, j));
37 EXPECT_TRUE(EqClasses.isEquivalent(i, j));
49 EXPECT_TRUE(EqClasses.isEquivalent(i, j));
64 EXPECT_TRUE(EqClasses.isEquivalent(i, j));
79 EXPECT_TRUE(EqClasses.isEquivalent(i, j));
unittests/ADT/FallibleIteratorTest.cpp 123 EXPECT_TRUE(Elem.isValid());
140 EXPECT_TRUE(Elem.isValid());
248 EXPECT_TRUE(I->isValid());
255 EXPECT_TRUE(I->isValid());
unittests/ADT/FoldingSet.cpp 106 EXPECT_TRUE(WasThere);
153 EXPECT_TRUE(Trivial.empty());
166 EXPECT_TRUE(Trivial.empty());
174 EXPECT_TRUE(Trivial.empty());
unittests/ADT/FunctionRefTest.cpp 24 EXPECT_TRUE(F);
unittests/ADT/IListNodeBaseTest.cpp 93 EXPECT_TRUE(TA.isKnownSentinel());
94 EXPECT_TRUE(TA.isSentinel());
unittests/ADT/IListSentinelTest.cpp 40 EXPECT_TRUE(S.isKnownSentinel());
47 EXPECT_TRUE(TS.isSentinel());
48 EXPECT_TRUE(TS.isKnownSentinel());
unittests/ADT/IListTest.cpp 85 EXPECT_TRUE(std::next(List.begin()) == List.end());
141 EXPECT_TRUE(E == List.end());
unittests/ADT/ImmutableListTest.cpp 40 EXPECT_TRUE(f.getEmptyList() == f.getEmptyList());
41 EXPECT_TRUE(f.getEmptyList().isEqual(f.getEmptyList()));
42 EXPECT_TRUE(f.getEmptyList().isEmpty());
46 EXPECT_TRUE(L.getTail().isEmpty());
47 EXPECT_TRUE(L.begin() == L.end());
55 EXPECT_TRUE(L.isEmpty());
57 EXPECT_TRUE(L2.getTail().isEmpty());
60 EXPECT_TRUE(L == L2.getTail());
62 EXPECT_TRUE(L.isEqual(L2.getTail()));
64 EXPECT_TRUE(L2.begin() != L2.end());
68 EXPECT_TRUE(L2.contains(3));
71 EXPECT_TRUE(L.isEmpty());
75 EXPECT_TRUE(L3.contains(2));
119 EXPECT_TRUE(L2.getTail().isEmpty());
121 EXPECT_TRUE(L.isEqual(L2.getTail()));
122 EXPECT_TRUE(L2.getTail().isEqual(L));
134 EXPECT_TRUE(L.isEmpty());
142 EXPECT_TRUE(L2.contains(3));
143 EXPECT_TRUE(L2.contains(4));
144 EXPECT_TRUE(L2.contains(5));
152 EXPECT_TRUE(L3.contains(43));
153 EXPECT_TRUE(L3.contains(20));
154 EXPECT_TRUE(L3.contains(9));
155 EXPECT_TRUE(L3.contains(3));
156 EXPECT_TRUE(L3.contains(4));
157 EXPECT_TRUE(L3.contains(5));
164 EXPECT_TRUE(L3.getTail().getTail().getTail() == L2);
165 EXPECT_TRUE(L2 == L3.getTail().getTail().getTail());
166 EXPECT_TRUE(L3.getTail().getTail().getTail().isEqual(L2));
167 EXPECT_TRUE(L2.isEqual(L3.getTail().getTail().getTail()));
169 EXPECT_TRUE(L4.contains(9));
170 EXPECT_TRUE(L4.contains(3));
171 EXPECT_TRUE(L4.contains(4));
172 EXPECT_TRUE(L4.contains(5));
175 EXPECT_TRUE(L4.isEqual(L4));
176 EXPECT_TRUE(L4.isEqual(L5));
178 EXPECT_TRUE(L5.isEqual(L4));
179 EXPECT_TRUE(L5.isEqual(L5));
207 EXPECT_TRUE(L2.getTail().isEmpty());
209 EXPECT_TRUE(L.isEqual(L2.getTail()));
210 EXPECT_TRUE(L2.getTail().isEqual(L));
215 EXPECT_TRUE(L2 == L3.getTail());
219 EXPECT_TRUE(L3 == L4.getTail());
221 EXPECT_TRUE(L4 == L5);
222 EXPECT_TRUE(L3 == L5.getTail());
unittests/ADT/ImmutableMapTest.cpp 19 EXPECT_TRUE(f.getEmptyMap() == f.getEmptyMap());
21 EXPECT_TRUE(f.getEmptyMap().isEmpty());
25 EXPECT_TRUE(S.begin() == S.end());
35 EXPECT_TRUE(S.isEmpty());
unittests/ADT/ImmutableSetTest.cpp 39 EXPECT_TRUE(f.getEmptySet() == f.getEmptySet());
41 EXPECT_TRUE(f.getEmptySet().isEmpty());
45 EXPECT_TRUE(S.begin() == S.end());
55 EXPECT_TRUE(S.isEmpty());
58 EXPECT_TRUE(S != S2);
60 EXPECT_TRUE(S2.contains(3));
62 EXPECT_TRUE(S2.begin() != S2.end());
65 EXPECT_TRUE(S.isEmpty());
68 EXPECT_TRUE(S != S3);
70 EXPECT_TRUE(S3.contains(2));
73 EXPECT_TRUE(S2 != S3);
86 EXPECT_TRUE(S.isEmpty());
94 EXPECT_TRUE(S2.contains(3));
95 EXPECT_TRUE(S2.contains(4));
96 EXPECT_TRUE(S2.contains(5));
100 EXPECT_TRUE(S3.contains(43));
101 EXPECT_TRUE(S3.contains(20));
102 EXPECT_TRUE(S3.contains(9));
103 EXPECT_TRUE(S3.contains(3));
104 EXPECT_TRUE(S3.contains(4));
105 EXPECT_TRUE(S3.contains(5));
108 EXPECT_TRUE(S4.contains(9));
109 EXPECT_TRUE(S4.contains(3));
110 EXPECT_TRUE(S4.contains(4));
111 EXPECT_TRUE(S4.contains(5));
124 EXPECT_TRUE(S3.contains(3));
128 EXPECT_TRUE(S2 == S4);
129 EXPECT_TRUE(S3 != S2);
130 EXPECT_TRUE(S3 != S4);
132 EXPECT_TRUE(S3.contains(4));
133 EXPECT_TRUE(S3.contains(5));
135 EXPECT_TRUE(S4.contains(4));
136 EXPECT_TRUE(S4.contains(5));
unittests/ADT/IntervalMapTest.cpp 24 EXPECT_TRUE(map.empty());
33 EXPECT_TRUE(map.begin() == map.begin());
34 EXPECT_TRUE(map.begin() == map.end());
35 EXPECT_TRUE(map.end() == map.end());
43 EXPECT_TRUE(I == map.end());
48 EXPECT_TRUE(CI == I);
51 EXPECT_TRUE(I2 == CI);
74 EXPECT_TRUE(map.begin() == map.begin());
76 EXPECT_TRUE(map.end() == map.end());
77 EXPECT_TRUE(map.begin().valid());
91 EXPECT_TRUE(I == map.end());
99 EXPECT_TRUE(I == map.begin());
151 EXPECT_TRUE(map.empty());
366 EXPECT_TRUE(map.empty());
367 EXPECT_TRUE(map.begin() == map.end());
406 EXPECT_TRUE(I == map.end());
416 EXPECT_TRUE(I == map.begin());
501 EXPECT_TRUE(I == map.begin());
509 EXPECT_TRUE(map.empty());
510 EXPECT_TRUE(map.begin() == map.end());
545 EXPECT_TRUE(I == map.end());
555 EXPECT_TRUE(I == map.begin());
585 EXPECT_TRUE(map.empty());
586 EXPECT_TRUE(map.begin() == map.end());
621 EXPECT_TRUE(map.overlaps(0, 10));
622 EXPECT_TRUE(map.overlaps(0, 15));
623 EXPECT_TRUE(map.overlaps(0, 25));
624 EXPECT_TRUE(map.overlaps(0, 45));
625 EXPECT_TRUE(map.overlaps(10, 45));
626 EXPECT_TRUE(map.overlaps(30, 45));
627 EXPECT_TRUE(map.overlaps(35, 36));
628 EXPECT_TRUE(map.overlaps(40, 45));
630 EXPECT_TRUE(map.overlaps(60, 60));
631 EXPECT_TRUE(map.overlaps(60, 66));
644 EXPECT_TRUE(map.overlaps(0, 15));
645 EXPECT_TRUE(map.overlaps(0, 25));
646 EXPECT_TRUE(map.overlaps(0, 45));
647 EXPECT_TRUE(map.overlaps(10, 45));
648 EXPECT_TRUE(map.overlaps(30, 45));
649 EXPECT_TRUE(map.overlaps(35, 36));
unittests/ADT/IntrusiveRefCntPtrTest.cpp 62 EXPECT_TRUE(Released);
63 EXPECT_TRUE(Retained);
unittests/ADT/IteratorTest.cpp 415 EXPECT_TRUE(all_of(pi, [](unsigned n) { return (n & 0x01) == 0; }));
436 EXPECT_TRUE(get<0>(tup) & 0x01);
441 EXPECT_TRUE(all_of(ascending, [](unsigned n) { return (n & 0x01) == 0; }));
unittests/ADT/MakeUniqueTest.cpp 18 EXPECT_TRUE((bool)p0);
22 EXPECT_TRUE((bool)p1);
26 EXPECT_TRUE((bool)p2);
30 EXPECT_TRUE((bool)p3);
34 EXPECT_TRUE((bool)p4);
38 EXPECT_TRUE((bool)p5);
43 EXPECT_TRUE((bool)p6);
48 EXPECT_TRUE((bool)p7);
53 EXPECT_TRUE((bool)p8);
59 EXPECT_TRUE((bool)p9);
65 EXPECT_TRUE((bool)p10);
71 EXPECT_TRUE((bool)p1);
unittests/ADT/MapVectorTest.cpp 24 EXPECT_TRUE(R.second);
27 EXPECT_TRUE(MV2.empty());
29 EXPECT_TRUE(MV1.empty());
49 EXPECT_TRUE(R.second);
61 EXPECT_TRUE(R.second);
75 EXPECT_TRUE(R.second);
180 EXPECT_TRUE(R.second);
206 EXPECT_TRUE(R.second);
218 EXPECT_TRUE(R.second);
232 EXPECT_TRUE(R.second);
324 EXPECT_TRUE(R.second);
336 EXPECT_TRUE(R.second);
350 EXPECT_TRUE(R.second);
unittests/ADT/OptionalTest.cpp 226 EXPECT_TRUE(A.hasValue());
232 EXPECT_TRUE(A.hasValue());
282 EXPECT_TRUE((bool)O);
293 EXPECT_TRUE((bool)A);
294 EXPECT_TRUE((bool)B);
305 EXPECT_TRUE((bool)O);
317 EXPECT_TRUE((bool)A);
318 EXPECT_TRUE((bool)B);
342 EXPECT_TRUE((bool)A);
343 EXPECT_TRUE((bool)B);
379 EXPECT_TRUE((bool)A);
unittests/ADT/PackedVectorTest.cpp 23 EXPECT_TRUE(Vec.empty());
39 EXPECT_TRUE(Vec.empty());
52 EXPECT_TRUE(Vec != Vec2);
55 EXPECT_TRUE(Vec == Vec2);
unittests/ADT/PointerEmbeddedIntTest.cpp 24 EXPECT_TRUE(I != J);
25 EXPECT_TRUE(I < J);
27 EXPECT_TRUE(I <= J);
31 EXPECT_TRUE(I != 43);
32 EXPECT_TRUE(I < 43);
34 EXPECT_TRUE(I <= 43);
38 EXPECT_TRUE(42 != J);
39 EXPECT_TRUE(42 < J);
41 EXPECT_TRUE(42 <= J);
unittests/ADT/PointerIntPairTest.cpp 98 EXPECT_TRUE(pair.getInt());
unittests/ADT/PointerSumTypeTest.cpp 32 EXPECT_TRUE(a);
33 EXPECT_TRUE(b);
34 EXPECT_TRUE(c);
46 EXPECT_TRUE(a.is<Float>());
50 EXPECT_TRUE(b.is<Int1>());
54 EXPECT_TRUE(c.is<Int2>());
99 EXPECT_TRUE(n);
unittests/ADT/PointerUnionTest.cpp 38 EXPECT_TRUE(a == a);
40 EXPECT_TRUE(a != b);
42 EXPECT_TRUE(b == c);
44 EXPECT_TRUE(b != n);
46 EXPECT_TRUE(i3 == i3);
48 EXPECT_TRUE(i3 != f3);
49 EXPECT_TRUE(f3 != l3);
50 EXPECT_TRUE(i4 == i4);
52 EXPECT_TRUE(i4 != f4);
53 EXPECT_TRUE(i4 != l4);
54 EXPECT_TRUE(f4 != l4);
55 EXPECT_TRUE(l4 != d4);
56 EXPECT_TRUE(i4null != f4null);
57 EXPECT_TRUE(i4null != l4null);
58 EXPECT_TRUE(i4null != d4null);
64 EXPECT_TRUE(n.isNull());
67 EXPECT_TRUE(!n);
69 EXPECT_TRUE((bool)a);
70 EXPECT_TRUE((bool)b);
85 EXPECT_TRUE(i4null.isNull());
86 EXPECT_TRUE(f4null.isNull());
87 EXPECT_TRUE(l4null.isNull());
88 EXPECT_TRUE(d4null.isNull());
93 EXPECT_TRUE(a.is<float *>());
94 EXPECT_TRUE(b.is<int *>());
96 EXPECT_TRUE(n.is<int *>());
98 EXPECT_TRUE(i3.is<int *>());
99 EXPECT_TRUE(f3.is<float *>());
100 EXPECT_TRUE(l3.is<long long *>());
101 EXPECT_TRUE(i4.is<int *>());
102 EXPECT_TRUE(f4.is<float *>());
103 EXPECT_TRUE(l4.is<long long *>());
104 EXPECT_TRUE(d4.is<double *>());
105 EXPECT_TRUE(i4null.is<int *>());
106 EXPECT_TRUE(f4null.is<float *>());
107 EXPECT_TRUE(l4null.is<long long *>());
108 EXPECT_TRUE(d4null.is<double *>());
128 EXPECT_TRUE(a.is<Aligned<0>*>());
147 EXPECT_TRUE(a.is<Aligned<7>*>());
150 EXPECT_TRUE(a == PU8(&a7));
151 EXPECT_TRUE(a != PU8(&a0));
155 EXPECT_TRUE((void *)b.getAddrOfPtr1() == (void *)&b);
156 EXPECT_TRUE((void *)n.getAddrOfPtr1() == (void *)&n);
unittests/ADT/PriorityWorklistTest.cpp 29 EXPECT_TRUE(W.empty());
33 EXPECT_TRUE(W.insert(21));
34 EXPECT_TRUE(W.insert(42));
35 EXPECT_TRUE(W.insert(17));
39 EXPECT_TRUE(W.count(42));
45 EXPECT_TRUE(W.erase(17));
51 EXPECT_TRUE(W.empty());
54 EXPECT_TRUE(W.insert(21));
55 EXPECT_TRUE(W.insert(42));
56 EXPECT_TRUE(W.insert(12));
57 EXPECT_TRUE(W.insert(17));
58 EXPECT_TRUE(W.count(12));
59 EXPECT_TRUE(W.count(17));
62 EXPECT_TRUE(W.erase(12));
64 EXPECT_TRUE(W.count(17));
73 EXPECT_TRUE(W.empty());
137 EXPECT_TRUE(W.erase_if([](int i) {
unittests/ADT/SCCIteratorTest.cpp 66 EXPECT_TRUE(NodesInThisSCC.isSubsetOf(G.NodesReachableFrom(i)));
82 EXPECT_TRUE(G.NodesReachableFrom(j).Meet(NodesInThisSCC).isEmpty());
94 EXPECT_TRUE(NodesInSomeSCC.Meet(NodesInThisSCC).isEmpty());
107 EXPECT_TRUE(NodesReachableFromSCC.isSubsetOf(NodesInSomeSCC));
unittests/ADT/STLExtrasTest.cpp 75 EXPECT_TRUE(IntResults.empty());
368 EXPECT_TRUE(llvm::empty(V));
374 EXPECT_TRUE(llvm::empty(E));
378 EXPECT_TRUE(llvm::empty(R0));
439 EXPECT_TRUE(is_splat(V));
443 EXPECT_TRUE(is_splat(V));
unittests/ADT/ScopeExitTest.cpp 28 EXPECT_TRUE(Called);
unittests/ADT/SequenceTest.cpp 31 EXPECT_TRUE(my_seq.begin() < my_seq.end());
35 EXPECT_TRUE(adjusted_begin == adjusted_end);
unittests/ADT/SimpleIListTest.cpp 26 EXPECT_TRUE(L.empty());
46 EXPECT_TRUE(L.empty());
65 EXPECT_TRUE(L.empty());
74 EXPECT_TRUE(L1.empty());
125 EXPECT_TRUE(L.empty());
312 EXPECT_TRUE(L.empty());
323 EXPECT_TRUE(L.empty());
333 EXPECT_TRUE(L.empty());
351 EXPECT_TRUE(L2.empty());
439 EXPECT_TRUE(std::is_sorted(L1.begin(), L1.end()));
440 EXPECT_TRUE(std::is_sorted(L2.begin(), L2.end()));
446 EXPECT_TRUE(RHS.empty());
448 EXPECT_TRUE(std::is_sorted(LHS.begin(), LHS.end()));
461 EXPECT_TRUE(L1.empty());
462 EXPECT_TRUE(L2.empty());
476 EXPECT_TRUE(std::is_sorted(L1.begin(), L1.end(), makeFalse));
477 EXPECT_TRUE(std::is_sorted(L2.begin(), L2.end(), makeFalse));
483 EXPECT_TRUE(L2.empty());
485 EXPECT_TRUE(std::is_sorted(L1.begin(), L1.end(), makeFalse));
498 EXPECT_TRUE(L1.empty());
500 EXPECT_TRUE(std::is_sorted(L2.begin(), L2.end(), makeFalse));
523 EXPECT_TRUE(L2.empty());
524 EXPECT_TRUE(std::is_sorted(L1.begin(), L1.end()));
530 EXPECT_TRUE(RHS.empty());
532 EXPECT_TRUE(std::is_sorted(LHS.begin(), LHS.end()));
543 EXPECT_TRUE(L1.empty());
544 EXPECT_TRUE(L2.empty());
561 EXPECT_TRUE(std::is_sorted(L.begin(), L.end()));
588 EXPECT_TRUE(std::is_sorted(L.begin(), L.end(), compare));
unittests/ADT/SmallPtrSetTest.cpp 36 EXPECT_TRUE(s1.count(&buf[i]));
47 EXPECT_TRUE(s2.count(&buf[i]));
117 EXPECT_TRUE(s1.count(&buf[i]));
125 EXPECT_TRUE(s2.count(&buf[i]));
134 EXPECT_TRUE(s1.count(&buf[i]));
140 EXPECT_TRUE(s1.empty());
143 EXPECT_TRUE(s3.count(&buf[i]));
155 EXPECT_TRUE(s3.empty());
157 EXPECT_TRUE(s1.count(&buf[i]));
164 EXPECT_TRUE(s3.count(&buf[i]));
179 EXPECT_TRUE(a.count(&buf[0]));
180 EXPECT_TRUE(a.count(&buf[1]));
185 EXPECT_TRUE(b.count(&buf[2]));
194 EXPECT_TRUE(a.count(&buf[2]));
196 EXPECT_TRUE(b.count(&buf[0]));
197 EXPECT_TRUE(b.count(&buf[1]));
206 EXPECT_TRUE(a.count(&buf[0]));
207 EXPECT_TRUE(a.count(&buf[1]));
209 EXPECT_TRUE(a.count(&buf[3]));
212 EXPECT_TRUE(b.count(&buf[2]));
221 EXPECT_TRUE(a.count(&buf[2]));
223 EXPECT_TRUE(b.count(&buf[0]));
224 EXPECT_TRUE(b.count(&buf[1]));
226 EXPECT_TRUE(b.count(&buf[3]));
236 EXPECT_TRUE(b.count(&buf[2]));
237 EXPECT_TRUE(b.count(&buf[4]));
238 EXPECT_TRUE(b.count(&buf[5]));
239 EXPECT_TRUE(b.count(&buf[6]));
240 EXPECT_TRUE(a.count(&buf[0]));
241 EXPECT_TRUE(a.count(&buf[1]));
242 EXPECT_TRUE(a.count(&buf[3]));
256 EXPECT_TRUE(*B == &buf[0] || *B == &buf[1] || *B == &buf[2]);
257 EXPECT_TRUE(*M == &buf[0] || *M == &buf[1] || *M == &buf[2]);
258 EXPECT_TRUE(*B != *M);
261 EXPECT_TRUE(Removable == &buf[0] || Removable == &buf[1] ||
263 EXPECT_TRUE(Removable != *B && Removable != *M);
unittests/ADT/SmallSetTest.cpp 62 EXPECT_TRUE(s1.erase(i));
unittests/ADT/SmallStringTest.cpp 33 EXPECT_TRUE(v.empty());
35 EXPECT_TRUE(v.begin() == v.end());
43 EXPECT_TRUE(theString.rbegin() == theString.rend());
unittests/ADT/SmallVectorTest.cpp 61 EXPECT_TRUE(constructed);
67 EXPECT_TRUE(constructed);
75 EXPECT_TRUE(constructed);
164 EXPECT_TRUE(v.empty());
167 EXPECT_TRUE(v.begin() == v.end());
231 EXPECT_TRUE(this->theVector.rbegin() == this->theVector.rend());
328 EXPECT_TRUE(Ctors == 2 || Ctors == 4);
330 EXPECT_TRUE(MoveCtors == 0 || MoveCtors == 2);
332 EXPECT_TRUE(Dtors == 0 || Dtors == 2);
368 EXPECT_TRUE(*it == this->theVector.front());
369 EXPECT_TRUE(*it == this->theVector[0]);
372 EXPECT_TRUE(*it == this->theVector[1]);
373 EXPECT_TRUE(*it == this->theVector.back());
376 EXPECT_TRUE(it == this->theVector.end());
378 EXPECT_TRUE(*it == this->theVector[1]);
381 EXPECT_TRUE(*it == this->theVector[0]);
386 EXPECT_TRUE(*rit == this->theVector[1]);
389 EXPECT_TRUE(*rit == this->theVector[0]);
392 EXPECT_TRUE(rit == this->theVector.rend());
394 EXPECT_TRUE(*rit == this->theVector[0]);
397 EXPECT_TRUE(*rit == this->theVector[1]);
574 EXPECT_TRUE(Constructable::getNumMoveConstructorCalls() == 2 ||
605 EXPECT_TRUE(Constructable::getNumMoveConstructorCalls() == 0 ||
644 EXPECT_TRUE(Constructable::getNumMoveConstructorCalls() == 2 ||
672 EXPECT_TRUE(Constructable::getNumMoveConstructorCalls() == 0 ||
703 EXPECT_TRUE(this->theVector == this->otherVector);
710 EXPECT_TRUE(this->theVector != this->otherVector);
718 EXPECT_TRUE(constVector.empty());
719 EXPECT_TRUE(constVector.begin() == constVector.end());
794 EXPECT_TRUE(this->NumBuiltinElts(this->otherVector) == 4 ||
838 EXPECT_TRUE(m.hasValue);
912 EXPECT_TRUE(&back == &V.back());
913 EXPECT_TRUE(V.size() == 1);
914 EXPECT_TRUE(back.State == ES_Emplaced);
915 EXPECT_TRUE(back.A0.State == EAS_Defaulted);
916 EXPECT_TRUE(back.A1.State == EAS_Defaulted);
917 EXPECT_TRUE(back.A2.State == EAS_Defaulted);
918 EXPECT_TRUE(back.A3.State == EAS_Defaulted);
923 EXPECT_TRUE(&back == &V.back());
924 EXPECT_TRUE(V.size() == 1);
925 EXPECT_TRUE(back.State == ES_Emplaced);
926 EXPECT_TRUE(back.A0.State == EAS_RValue);
927 EXPECT_TRUE(back.A1.State == EAS_Defaulted);
928 EXPECT_TRUE(back.A2.State == EAS_Defaulted);
929 EXPECT_TRUE(back.A3.State == EAS_Defaulted);
934 EXPECT_TRUE(&back == &V.back());
935 EXPECT_TRUE(V.size() == 1);
936 EXPECT_TRUE(back.State == ES_Emplaced);
937 EXPECT_TRUE(back.A0.State == EAS_LValue);
938 EXPECT_TRUE(back.A1.State == EAS_Defaulted);
939 EXPECT_TRUE(back.A2.State == EAS_Defaulted);
940 EXPECT_TRUE(back.A3.State == EAS_Defaulted);
945 EXPECT_TRUE(&back == &V.back());
946 EXPECT_TRUE(V.size() == 1);
947 EXPECT_TRUE(back.State == ES_Emplaced);
948 EXPECT_TRUE(back.A0.State == EAS_LValue);
949 EXPECT_TRUE(back.A1.State == EAS_LValue);
950 EXPECT_TRUE(back.A2.State == EAS_Defaulted);
951 EXPECT_TRUE(back.A3.State == EAS_Defaulted);
956 EXPECT_TRUE(&back == &V.back());
957 EXPECT_TRUE(V.size() == 1);
958 EXPECT_TRUE(back.State == ES_Emplaced);
959 EXPECT_TRUE(back.A0.State == EAS_RValue);
960 EXPECT_TRUE(back.A1.State == EAS_RValue);
961 EXPECT_TRUE(back.A2.State == EAS_Defaulted);
962 EXPECT_TRUE(back.A3.State == EAS_Defaulted);
967 EXPECT_TRUE(&back == &V.back());
968 EXPECT_TRUE(V.size() == 1);
969 EXPECT_TRUE(back.State == ES_Emplaced);
970 EXPECT_TRUE(back.A0.State == EAS_RValue);
971 EXPECT_TRUE(back.A1.State == EAS_LValue);
972 EXPECT_TRUE(back.A2.State == EAS_RValue);
973 EXPECT_TRUE(back.A3.State == EAS_LValue);
987 EXPECT_TRUE(V1.empty());
989 EXPECT_TRUE(makeArrayRef(V1).equals({0, 0}));
991 EXPECT_TRUE(makeArrayRef(V1).equals({-1, -1}));
994 EXPECT_TRUE(makeArrayRef(V2).equals({1, 2, 3, 4}));
996 EXPECT_TRUE(makeArrayRef(V2).equals({4}));
998 EXPECT_TRUE(makeArrayRef(V2).equals({4, 3, 2}));
1000 EXPECT_TRUE(makeArrayRef(V2).equals({4, 5, 3, 2}));
unittests/ADT/SparseBitVectorTest.cpp 21 EXPECT_TRUE(Vec.test(5));
24 EXPECT_TRUE(Vec.test(5));
28 EXPECT_TRUE(Vec.test_and_set(17));
30 EXPECT_TRUE(Vec.test(17));
36 EXPECT_TRUE(ConstVec.test(5));
40 EXPECT_TRUE(Vec.test(1337));
47 EXPECT_TRUE(Vec.empty());
48 EXPECT_TRUE(MovedVec.test(5));
49 EXPECT_TRUE(MovedVec.test(1337));
52 EXPECT_TRUE(MovedVec.empty());
62 EXPECT_TRUE(Vec.test(1));
68 EXPECT_TRUE(Vec &= Other);
69 EXPECT_TRUE(Vec.empty());
75 EXPECT_TRUE(Vec &= Other);
76 EXPECT_TRUE(Vec.empty());
82 EXPECT_TRUE(Vec &= Other);
83 EXPECT_TRUE(Vec.empty());
92 EXPECT_TRUE(Vec.test(23));
93 EXPECT_TRUE(Vec.test(234));
99 EXPECT_TRUE(Vec.test(17));
100 EXPECT_TRUE(Vec.test(256));
106 EXPECT_TRUE(Vec.test(56));
107 EXPECT_TRUE(Vec.test(517));
112 EXPECT_TRUE(Vec.intersectWithComplement(Vec));
113 EXPECT_TRUE(Vec.empty());
120 EXPECT_TRUE(Vec.empty());
128 EXPECT_TRUE(Vec.test(42));
139 EXPECT_TRUE(Vec.test(31));
147 EXPECT_TRUE(Vec.empty());
unittests/ADT/SparseMultiSetTest.cpp 21 EXPECT_TRUE(Set.empty());
27 EXPECT_TRUE(Set.find(0) == Set.end());
28 EXPECT_TRUE(Set.find(9) == Set.end());
32 EXPECT_TRUE(CSet.empty());
34 EXPECT_TRUE(CSet.find(0) == CSet.end());
36 EXPECT_TRUE(I == CSet.end());
44 EXPECT_TRUE(I != Set.end());
45 EXPECT_TRUE(*I == 5);
50 EXPECT_TRUE(Set.find(0) == Set.end());
51 EXPECT_TRUE(Set.find(9) == Set.end());
54 EXPECT_TRUE(Set.contains(5));
58 EXPECT_TRUE(I != Set.end());
59 EXPECT_TRUE(I == ++Set.find(5));
61 EXPECT_TRUE(I == Set.find(5));
65 EXPECT_TRUE(I == Set.end());
71 EXPECT_TRUE(I != Set.end());
73 EXPECT_TRUE(I != Set.end());
75 EXPECT_TRUE(I == Set.end());
76 EXPECT_TRUE(Set.empty());
94 EXPECT_TRUE(Set.erase(Set.find(4)) == Set.end());
97 EXPECT_TRUE(Set.find(4) == Set.end());
101 EXPECT_TRUE(Set.find(5) != Set.end());
102 EXPECT_TRUE(Set.erase(Set.find(5)) != Set.end());
111 EXPECT_TRUE(Set.getTail(6) == Set.getHead(6));
113 EXPECT_TRUE(I == Set.end());
120 EXPECT_TRUE(I == Set.end());
125 EXPECT_TRUE(I == Set.end());
198 EXPECT_TRUE(!Set2.contains(0));
199 EXPECT_TRUE(!Set.contains(3));
231 EXPECT_TRUE(Set.contains(5));
unittests/ADT/SparseSetTest.cpp 21 EXPECT_TRUE(Set.empty());
22 EXPECT_TRUE(Set.begin() == Set.end());
28 EXPECT_TRUE(Set.find(0) == Set.end());
29 EXPECT_TRUE(Set.find(9) == Set.end());
33 EXPECT_TRUE(CSet.empty());
34 EXPECT_TRUE(CSet.begin() == CSet.end());
36 EXPECT_TRUE(CSet.find(0) == CSet.end());
38 EXPECT_TRUE(I == CSet.end());
46 EXPECT_TRUE(IP.second);
47 EXPECT_TRUE(IP.first == Set.begin());
51 EXPECT_TRUE(Set.begin() + 1 == Set.end());
54 EXPECT_TRUE(Set.find(0) == Set.end());
55 EXPECT_TRUE(Set.find(9) == Set.end());
58 EXPECT_TRUE(Set.count(5));
63 EXPECT_TRUE(IP.first == Set.begin());
72 EXPECT_TRUE(I == Set.begin());
74 EXPECT_TRUE(I == Set.end());
75 EXPECT_TRUE(Set.empty());
102 EXPECT_TRUE(I == Set.end());
107 EXPECT_TRUE(IP.first == Set.begin() + 1);
110 EXPECT_TRUE(Set.erase(4));
118 EXPECT_TRUE(Set.count(5));
119 EXPECT_TRUE(Set.find(5) == Set.begin());
120 EXPECT_TRUE(Set.erase(5));
133 EXPECT_TRUE(I == Set.end());
138 EXPECT_TRUE(I == Set.begin() + 1);
153 EXPECT_TRUE(Set.count(i));
183 EXPECT_TRUE(Set.erase(6));
unittests/ADT/StringExtrasTest.cpp 18 EXPECT_TRUE(isPrint('0'));
19 EXPECT_TRUE(isPrint('a'));
20 EXPECT_TRUE(isPrint('A'));
21 EXPECT_TRUE(isPrint(' '));
22 EXPECT_TRUE(isPrint('~'));
23 EXPECT_TRUE(isPrint('?'));
85 EXPECT_TRUE(to_float("4.7", F));
89 EXPECT_TRUE(to_float("4.7", D));
93 EXPECT_TRUE(to_float("4.7", LD));
unittests/ADT/StringMapTest.cpp 33 EXPECT_TRUE(testMap.empty());
36 EXPECT_TRUE(testMap.begin() == testMap.end());
42 EXPECT_TRUE(testMap.find(testKey) == testMap.end());
43 EXPECT_TRUE(testMap.find(StringRef(testKeyFirst, testKeyLength)) ==
45 EXPECT_TRUE(testMap.find(testKeyStr) == testMap.end());
59 EXPECT_TRUE(it == testMap.end());
65 EXPECT_TRUE(testMap.find(testKey) == testMap.begin());
66 EXPECT_TRUE(testMap.find(StringRef(testKeyFirst, testKeyLength)) ==
68 EXPECT_TRUE(testMap.find(testKeyStr) == testMap.begin());
99 EXPECT_TRUE(constTestMap.empty());
102 EXPECT_TRUE(constTestMap.begin() == constTestMap.end());
108 EXPECT_TRUE(constTestMap.find(testKey) == constTestMap.end());
109 EXPECT_TRUE(constTestMap.find(StringRef(testKeyFirst, testKeyLength)) ==
111 EXPECT_TRUE(constTestMap.find(testKeyStr) == constTestMap.end());
255 EXPECT_TRUE(Inserted);
290 EXPECT_TRUE(try1.second);
unittests/ADT/StringRefTest.cpp 66 EXPECT_TRUE(S.empty());
69 EXPECT_TRUE(S.empty());
82 EXPECT_TRUE(StringRef().empty());
122 EXPECT_TRUE(StringRef("aab") < StringRef("aad"));
124 EXPECT_TRUE(StringRef("aab") <= StringRef("aab"));
126 EXPECT_TRUE(StringRef("aad") > StringRef("aab"));
128 EXPECT_TRUE(StringRef("aab") >= StringRef("aab"));
133 EXPECT_TRUE(StringRef("aab") != StringRef("aac"));
196 EXPECT_TRUE(parts == expected);
202 EXPECT_TRUE(parts == expected);
207 EXPECT_TRUE(parts == expected);
211 EXPECT_TRUE(parts == expected);
215 EXPECT_TRUE(parts == expected);
220 EXPECT_TRUE(parts == expected);
225 EXPECT_TRUE(parts == expected);
231 EXPECT_TRUE(parts == expected);
236 EXPECT_TRUE(parts == expected);
241 EXPECT_TRUE(parts == expected);
246 EXPECT_TRUE(parts == expected);
251 EXPECT_TRUE(parts == expected);
256 EXPECT_TRUE(parts == expected);
262 EXPECT_TRUE(parts == expected);
267 EXPECT_TRUE(parts == expected);
272 EXPECT_TRUE(parts == expected);
277 EXPECT_TRUE(parts == expected);
282 EXPECT_TRUE(parts == expected);
286 EXPECT_TRUE(parts == expected);
288 EXPECT_TRUE(parts == expected);
296 EXPECT_TRUE(parts == expected);
301 EXPECT_TRUE(parts == expected);
306 EXPECT_TRUE(parts == expected);
310 EXPECT_TRUE(parts == expected);
312 EXPECT_TRUE(parts == expected);
320 EXPECT_TRUE(parts == expected);
349 EXPECT_TRUE(Str.startswith(""));
350 EXPECT_TRUE(Str.startswith("he"));
357 EXPECT_TRUE(Str.startswith_lower(""));
358 EXPECT_TRUE(Str.startswith_lower("he"));
359 EXPECT_TRUE(Str.startswith_lower("hell"));
360 EXPECT_TRUE(Str.startswith_lower("HELlo"));
367 EXPECT_TRUE(Str.consume_front(""));
369 EXPECT_TRUE(Str.consume_front("he"));
375 EXPECT_TRUE(Str.consume_front("llo"));
378 EXPECT_TRUE(Str.consume_front(""));
383 EXPECT_TRUE(Str.endswith(""));
384 EXPECT_TRUE(Str.endswith("lo"));
392 EXPECT_TRUE(Str.endswith_lower(""));
393 EXPECT_TRUE(Str.endswith_lower("lo"));
394 EXPECT_TRUE(Str.endswith_lower("LO"));
395 EXPECT_TRUE(Str.endswith_lower("ELlo"));
402 EXPECT_TRUE(Str.consume_back(""));
404 EXPECT_TRUE(Str.consume_back("lo"));
410 EXPECT_TRUE(Str.consume_back("hel"));
413 EXPECT_TRUE(Str.consume_back(""));
914 EXPECT_TRUE(v1_join1);
916 EXPECT_TRUE(v1_join2);
918 EXPECT_TRUE(v1_join3);
921 EXPECT_TRUE(v2_join1);
923 EXPECT_TRUE(v2_join2);
925 EXPECT_TRUE(v2_join3);
927 EXPECT_TRUE(v2_join3);
937 EXPECT_TRUE(StrEmpty.equals(StrEmptyc));
946 EXPECT_TRUE(Str1.equals(Str1c));
948 EXPECT_TRUE(Str2.equals(Str2c));
968 EXPECT_TRUE(Dropped.empty());
971 EXPECT_TRUE(Dropped.empty());
990 EXPECT_TRUE(Taken.empty());
993 EXPECT_TRUE(Taken.empty());
unittests/ADT/TinyPtrVectorTest.cpp 428 EXPECT_TRUE(V.size() == 1);
430 EXPECT_TRUE(V.front() == &v);
443 EXPECT_TRUE(V.size() == 128);
446 EXPECT_TRUE(V[i] == data[i]);
460 EXPECT_TRUE(V.size() == 128);
465 EXPECT_TRUE(mut_array[i] == data[i]);
467 EXPECT_TRUE(mut_array[i] == (324 + data[i]));
unittests/ADT/TripleTest.cpp 561 EXPECT_TRUE(T.isArch64Bit());
567 EXPECT_TRUE(T.isArch32Bit());
773 EXPECT_TRUE(T.isArch32Bit());
778 EXPECT_TRUE(T.isArch32Bit());
783 EXPECT_TRUE(T.isArch32Bit());
789 EXPECT_TRUE(T.isArch64Bit());
792 EXPECT_TRUE(T.isArch16Bit());
798 EXPECT_TRUE(T.isArch32Bit());
804 EXPECT_TRUE(T.isArch64Bit());
808 EXPECT_TRUE(T.isArch32Bit());
814 EXPECT_TRUE(T.isArch64Bit());
818 EXPECT_TRUE(T.isArch32Bit());
824 EXPECT_TRUE(T.isArch64Bit());
828 EXPECT_TRUE(T.isArch32Bit());
834 EXPECT_TRUE(T.isArch64Bit());
838 EXPECT_TRUE(T.isArch32Bit());
844 EXPECT_TRUE(T.isArch64Bit());
848 EXPECT_TRUE(T.isArch32Bit());
853 EXPECT_TRUE(T.isArch32Bit());
859 EXPECT_TRUE(T.isArch64Bit());
863 EXPECT_TRUE(T.isArch32Bit());
869 EXPECT_TRUE(T.isArch64Bit());
872 EXPECT_TRUE(T.isArch16Bit());
878 EXPECT_TRUE(T.isArch32Bit());
883 EXPECT_TRUE(T.isArch32Bit());
885 EXPECT_TRUE(T.isRISCV());
890 EXPECT_TRUE(T.isArch64Bit());
891 EXPECT_TRUE(T.isRISCV());
1065 EXPECT_TRUE(T.isLittleEndian());
1067 EXPECT_TRUE(T.isLittleEndian());
1151 EXPECT_TRUE(T.isMacOSX());
1154 EXPECT_TRUE(T.isArch32Bit());
1166 EXPECT_TRUE(T.isMacOSX());
1170 EXPECT_TRUE(T.isArch64Bit());
1181 EXPECT_TRUE(T.isMacOSX());
1185 EXPECT_TRUE(T.isArch64Bit());
1196 EXPECT_TRUE(T.isMacOSX());
1200 EXPECT_TRUE(T.isArch64Bit());
1212 EXPECT_TRUE(T.isiOS());
1214 EXPECT_TRUE(T.isArch32Bit());
1227 EXPECT_TRUE(T.isiOS());
1229 EXPECT_TRUE(T.isArch32Bit());
1242 EXPECT_TRUE(T.isiOS());
1247 EXPECT_TRUE(T.isSimulatorEnvironment());
1251 EXPECT_TRUE(T.isiOS());
1256 EXPECT_TRUE(T.getEnvironment() == Triple::MacABI);
1257 EXPECT_TRUE(T.isMacCatalystEnvironment());
1368 EXPECT_TRUE(Triple("x86_64-pc-win32").isWindowsMSVCEnvironment());
unittests/Analysis/AliasAnalysisTest.cpp 250 EXPECT_TRUE(IsCustomAAQueried);
unittests/Analysis/BranchProbabilityInfoTest.cpp 83 EXPECT_TRUE(BPI.isEdgeHot(EntryBB, ExitBB));
unittests/Analysis/CGSCCPassManagerTest.cpp 498 EXPECT_TRUE(FoundModuleAnalysis1);
499 EXPECT_TRUE(FoundModuleAnalysis2);
unittests/Analysis/DivergenceAnalysisTest.cpp 101 EXPECT_TRUE(DA.hasDetectedDivergence());
102 EXPECT_TRUE(DA.isDivergent(arg));
105 EXPECT_TRUE(DA.hasDetectedDivergence());
106 EXPECT_TRUE(DA.isDivergent(arg));
149 EXPECT_TRUE(DA.hasDetectedDivergence());
156 EXPECT_TRUE(DA.isDivergent(RetInst));
203 EXPECT_TRUE(DA.hasDetectedDivergence());
210 EXPECT_TRUE(DA.isDivergent(RetInst));
305 EXPECT_TRUE(DA.isDivergent(*Phi));
421 EXPECT_TRUE(DA.hasDetectedDivergence());
426 EXPECT_TRUE(DA.isDivergent(DivDblPhi));
unittests/Analysis/DomTreeUpdaterTest.cpp 128 EXPECT_TRUE(DT.verify());
129 EXPECT_TRUE(PDT.verify());
184 EXPECT_TRUE(&F->getEntryBlock() == NewEntry);
296 EXPECT_TRUE(DTU.isBBPendingDeletion(BB3));
297 EXPECT_TRUE(DTU.hasPendingDeletedBB());
391 EXPECT_TRUE(DTU.isBBPendingDeletion(BB2));
414 EXPECT_TRUE(DTU.isBBPendingDeletion(BB1));
504 EXPECT_TRUE(DTU.isBBPendingDeletion(BB3));
559 EXPECT_TRUE(&F->getEntryBlock() == NewEntry);
589 EXPECT_TRUE(DTU.isBBPendingDeletion(BB0));
unittests/Analysis/IVDescriptorsTest.cpp 87 EXPECT_TRUE(IsInductionPHI);
unittests/Analysis/LazyCallGraphTest.cpp 349 EXPECT_TRUE(C.isParentOf(D));
351 EXPECT_TRUE(C.isAncestorOf(D));
365 EXPECT_TRUE(B.isParentOf(D));
367 EXPECT_TRUE(B.isAncestorOf(D));
383 EXPECT_TRUE(A.isParentOf(B));
384 EXPECT_TRUE(A.isParentOf(C));
386 EXPECT_TRUE(A.isAncestorOf(B));
387 EXPECT_TRUE(A.isAncestorOf(C));
388 EXPECT_TRUE(A.isAncestorOf(D));
623 EXPECT_TRUE(ARC.isParentOf(BRC));
624 EXPECT_TRUE(AC.isParentOf(BC));
625 EXPECT_TRUE(ARC.isParentOf(CRC));
626 EXPECT_TRUE(AC.isParentOf(CC));
629 EXPECT_TRUE(ARC.isAncestorOf(DRC));
630 EXPECT_TRUE(AC.isAncestorOf(DC));
633 EXPECT_TRUE(DRC.isDescendantOf(ARC));
634 EXPECT_TRUE(DC.isDescendantOf(AC));
635 EXPECT_TRUE(DRC.isChildOf(BRC));
636 EXPECT_TRUE(DC.isChildOf(BC));
637 EXPECT_TRUE(DRC.isChildOf(CRC));
638 EXPECT_TRUE(DC.isChildOf(CC));
644 EXPECT_TRUE(NewE);
645 EXPECT_TRUE(NewE.isCall());
650 EXPECT_TRUE(ARC.isParentOf(DRC));
651 EXPECT_TRUE(AC.isParentOf(DC));
652 EXPECT_TRUE(ARC.isAncestorOf(DRC));
653 EXPECT_TRUE(AC.isAncestorOf(DC));
654 EXPECT_TRUE(DRC.isChildOf(ARC));
655 EXPECT_TRUE(DC.isChildOf(AC));
656 EXPECT_TRUE(DRC.isDescendantOf(ARC));
657 EXPECT_TRUE(DC.isDescendantOf(AC));
671 EXPECT_TRUE(ARC.isParentOf(DRC));
673 EXPECT_TRUE(ARC.isAncestorOf(DRC));
674 EXPECT_TRUE(AC.isAncestorOf(DC));
675 EXPECT_TRUE(DRC.isChildOf(ARC));
677 EXPECT_TRUE(DRC.isDescendantOf(ARC));
678 EXPECT_TRUE(DC.isDescendantOf(AC));
689 EXPECT_TRUE(NewE.isCall());
692 EXPECT_TRUE(ARC.isParentOf(DRC));
693 EXPECT_TRUE(AC.isParentOf(DC));
694 EXPECT_TRUE(ARC.isAncestorOf(DRC));
695 EXPECT_TRUE(AC.isAncestorOf(DC));
696 EXPECT_TRUE(DRC.isChildOf(ARC));
697 EXPECT_TRUE(DC.isChildOf(AC));
698 EXPECT_TRUE(DRC.isDescendantOf(ARC));
699 EXPECT_TRUE(DC.isDescendantOf(AC));
715 EXPECT_TRUE(ARC.isAncestorOf(DRC));
716 EXPECT_TRUE(AC.isAncestorOf(DC));
719 EXPECT_TRUE(DRC.isDescendantOf(ARC));
720 EXPECT_TRUE(DC.isDescendantOf(AC));
822 EXPECT_TRUE(ARC.isParentOf(CRC));
823 EXPECT_TRUE(BRC.isParentOf(CRC));
914 EXPECT_TRUE(ARC.isParentOf(CRC));
915 EXPECT_TRUE(BRC.isParentOf(CRC));
1178 EXPECT_TRUE(CRC.isParentOf(D2RC));
1179 EXPECT_TRUE(CRC.isParentOf(NewDRC));
1180 EXPECT_TRUE(D2RC.isParentOf(NewDRC));
1183 EXPECT_TRUE(CRC.isParentOf(NewDRC));
1184 EXPECT_TRUE(D2RC.isParentOf(NewDRC));
1201 EXPECT_TRUE(CRC.isParentOf(NewDRC));
1289 EXPECT_TRUE(RC.switchInternalEdgeToCall(A, C, [&](ArrayRef<LazyCallGraph::SCC *> MergedCs) {
1686 EXPECT_TRUE(RC.switchInternalEdgeToCall(C, B, [&](ArrayRef<LazyCallGraph::SCC *> MergedCs) {
1933 EXPECT_TRUE(RC.switchInternalEdgeToCall(
1979 EXPECT_TRUE(GRC.isParentOf(FRC));
unittests/Analysis/LoopInfoTest.cpp 99 EXPECT_TRUE(loopIDFoundAndSet);
276 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
280 EXPECT_TRUE(StepValue && StepValue->isOne());
287 EXPECT_TRUE(L->isGuarded());
334 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
338 EXPECT_TRUE(StepValue && StepValue->isOne());
345 EXPECT_TRUE(L->isGuarded());
392 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
396 EXPECT_TRUE(StepValue && StepValue->isOne());
403 EXPECT_TRUE(L->isGuarded());
450 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
454 EXPECT_TRUE(StepValue && StepValue->isOne());
461 EXPECT_TRUE(L->isGuarded());
508 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
512 EXPECT_TRUE(StepValue && StepValue->isOne());
519 EXPECT_TRUE(L->isGuarded());
567 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
571 EXPECT_TRUE(StepValue && StepValue->isOne());
578 EXPECT_TRUE(L->isGuarded());
625 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
633 EXPECT_TRUE(L->isGuarded());
680 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
684 EXPECT_TRUE(StepValue && StepValue->isOne());
691 EXPECT_TRUE(L->isGuarded());
743 EXPECT_TRUE(FinalIVValue && FinalIVValue->isZero());
749 EXPECT_TRUE(L->isGuarded());
797 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
806 EXPECT_TRUE(L->isGuarded());
856 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
860 EXPECT_TRUE(StepValue && StepValue->isOne());
867 EXPECT_TRUE(L->isGuarded());
916 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
920 EXPECT_TRUE(StepValue && StepValue->isOne());
927 EXPECT_TRUE(L->isGuarded());
976 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
980 EXPECT_TRUE(StepValue && StepValue->isOne());
1028 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
1032 EXPECT_TRUE(StepValue && StepValue->isOne());
1085 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
1089 EXPECT_TRUE(StepValue && StepValue->isOne());
1096 EXPECT_TRUE(L->isGuarded());
1155 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
1159 EXPECT_TRUE(StepValue && StepValue->isOne());
1166 EXPECT_TRUE(L->isGuarded());
1180 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
1183 EXPECT_TRUE(StepValue && StepValue->isOne());
1190 EXPECT_TRUE(L->isGuarded());
1246 EXPECT_TRUE(InitialIVValue && InitialIVValue->isZero());
1250 EXPECT_TRUE(StepValue && StepValue->isOne());
1258 EXPECT_TRUE(L->isAuxiliaryInductionVariable(Instruction_i, SE));
1260 EXPECT_TRUE(L->isAuxiliaryInductionVariable(Instruction_aux, SE));
1271 EXPECT_TRUE(L->isGuarded());
1351 EXPECT_TRUE(L->isLoopSimplifyForm());
1398 EXPECT_TRUE(Exits.size() == 2);
1402 EXPECT_TRUE(Exits.size() == 1);
1441 EXPECT_TRUE(Exits.size() == 1);
1445 EXPECT_TRUE(Exits.size() == 1);
unittests/Analysis/MemorySSATest.cpp 105 EXPECT_TRUE(isa<MemoryPhi>(DefiningAccess));
242 EXPECT_TRUE(isa<MemoryPhi>(DefiningAccess));
362 EXPECT_TRUE(isa<MemoryPhi>(LoadAccess->getDefiningAccess()));
405 EXPECT_TRUE(isa<MemoryPhi>(LoadAccess->getDefiningAccess()));
449 EXPECT_TRUE(isa<MemoryPhi>(LoadAccess->getDefiningAccess()));
503 EXPECT_TRUE(isa<MemoryPhi>(DefiningAccess));
509 EXPECT_TRUE(MSSA.isLiveOnEntryDef(cast<MemoryAccess>(Op.get())));
513 EXPECT_TRUE(MSSA.isLiveOnEntryDef(LoadAccess->getDefiningAccess()));
550 EXPECT_TRUE(isa<MemoryPhi>(DefiningAccess));
569 EXPECT_TRUE(
574 EXPECT_TRUE(MSSA.isLiveOnEntryDef(Operand));
581 EXPECT_TRUE(MSSA.isLiveOnEntryDef(LoadAccess->getDefiningAccess()));
642 EXPECT_TRUE(MSSA.isLiveOnEntryDef(Walker->getClobberingMemoryAccess(SI)));
676 EXPECT_TRUE(MSSA.isLiveOnEntryDef(LiveOnEntry));
682 EXPECT_TRUE(MSSA.isLiveOnEntryDef(LiveOnEntry));
813 EXPECT_TRUE(MSSA.isLiveOnEntryDef(Walker->getClobberingMemoryAccess(SIA)));
866 EXPECT_TRUE(MSSA.locallyDominates(MSSA.getMemoryAccess(StoreC),
868 EXPECT_TRUE(MSSA.locallyDominates(MSSA.getMemoryAccess(StoreA1),
unittests/Analysis/OrderedBasicBlockTest.cpp 48 EXPECT_TRUE(OBB.dominates(Add, Ret));
49 EXPECT_TRUE(OBB.dominates(Add, Ret));
unittests/Analysis/OrderedInstructionsTest.cpp 59 EXPECT_TRUE(OI.dominates(LoadInstX, LoadInstY));
63 EXPECT_TRUE(OI.dominates(LoadInstY, LoadInstZ));
unittests/Analysis/PhiValuesTest.cpp 58 EXPECT_TRUE(Vals.count(Val1));
59 EXPECT_TRUE(Vals.count(Val2));
62 EXPECT_TRUE(Vals.count(Val1));
63 EXPECT_TRUE(Vals.count(Val3));
70 EXPECT_TRUE(Vals.count(Val4));
71 EXPECT_TRUE(Vals.count(Val2));
74 EXPECT_TRUE(Vals.count(Val4));
75 EXPECT_TRUE(Vals.count(Val3));
82 EXPECT_TRUE(Vals.count(Val1));
83 EXPECT_TRUE(Vals.count(Val2));
134 EXPECT_TRUE(Vals.count(Val1));
135 EXPECT_TRUE(Vals.count(Val2));
138 EXPECT_TRUE(Vals.count(Val2));
139 EXPECT_TRUE(Vals.count(Val3));
142 EXPECT_TRUE(Vals.count(Val1));
143 EXPECT_TRUE(Vals.count(Val2));
144 EXPECT_TRUE(Vals.count(Val3));
151 EXPECT_TRUE(Vals.count(Val4));
152 EXPECT_TRUE(Vals.count(Val2));
155 EXPECT_TRUE(Vals.count(Val2));
156 EXPECT_TRUE(Vals.count(Val3));
159 EXPECT_TRUE(Vals.count(Val4));
160 EXPECT_TRUE(Vals.count(Val2));
161 EXPECT_TRUE(Vals.count(Val3));
168 EXPECT_TRUE(Vals.count(Val4));
169 EXPECT_TRUE(Vals.count(Val2));
172 EXPECT_TRUE(Vals.count(Val2));
173 EXPECT_TRUE(Vals.count(Val3));
176 EXPECT_TRUE(Vals.count(Val1));
177 EXPECT_TRUE(Vals.count(Val3));
184 EXPECT_TRUE(Vals.count(Val4));
185 EXPECT_TRUE(Vals.count(Val2));
188 EXPECT_TRUE(Vals.count(Val2));
189 EXPECT_TRUE(Vals.count(Val3));
192 EXPECT_TRUE(Vals.count(Val1));
193 EXPECT_TRUE(Vals.count(Val2));
194 EXPECT_TRUE(Vals.count(Val3));
203 EXPECT_TRUE(Vals.count(Val4));
204 EXPECT_TRUE(Vals.count(Val2));
207 EXPECT_TRUE(Vals.count(Val1));
208 EXPECT_TRUE(Vals.count(Val2));
unittests/Analysis/ProfileSummaryInfoTest.cpp 134 EXPECT_TRUE(PSI.hasProfileSummary());
135 EXPECT_TRUE(PSI.isHotCount(400));
136 EXPECT_TRUE(PSI.isColdCount(2));
140 EXPECT_TRUE(PSI.isHotCountNthPercentile(990000, 400));
144 EXPECT_TRUE(PSI.isHotCountNthPercentile(999999, 400));
145 EXPECT_TRUE(PSI.isHotCountNthPercentile(999999, 100));
152 EXPECT_TRUE(PSI.isFunctionEntryHot(F));
161 EXPECT_TRUE(PSI.hasProfileSummary());
162 EXPECT_TRUE(PSI.hasInstrumentationProfile());
170 EXPECT_TRUE(PSI.isHotBlock(&BB0, &BFI));
171 EXPECT_TRUE(PSI.isHotBlock(BB1, &BFI));
173 EXPECT_TRUE(PSI.isHotBlock(BB3, &BFI));
175 EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, &BB0, &BFI));
176 EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, BB1, &BFI));
178 EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, BB3, &BFI));
180 EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, &BB0, &BFI));
181 EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB1, &BFI));
182 EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB2, &BFI));
183 EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB3, &BFI));
194 EXPECT_TRUE(PSI.isHotCallSite(CS1, &BFI));
208 EXPECT_TRUE(PSI.hasProfileSummary());
209 EXPECT_TRUE(PSI.hasSampleProfile());
217 EXPECT_TRUE(PSI.isHotBlock(&BB0, &BFI));
218 EXPECT_TRUE(PSI.isHotBlock(BB1, &BFI));
220 EXPECT_TRUE(PSI.isHotBlock(BB3, &BFI));
222 EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, &BB0, &BFI));
223 EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, BB1, &BFI));
225 EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, BB3, &BFI));
227 EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, &BB0, &BFI));
228 EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB1, &BFI));
229 EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB2, &BFI));
230 EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB3, &BFI));
247 EXPECT_TRUE(PSI.isHotCallSite(CS2, &BFI));
252 EXPECT_TRUE(PSI.isHotCallSite(CS2, &BFI));
unittests/Analysis/ScalarEvolutionTest.cpp 202 EXPECT_TRUE(isa<BitCastInst>(V));
204 EXPECT_TRUE(isa<GetElementPtrInst>(Gep));
205 EXPECT_TRUE(isa<ConstantInt>(Gep->getOperand(1)));
207 EXPECT_TRUE(isa<BitCastInst>(Gep->getPrevNode()));
293 EXPECT_TRUE(isa<SCEVAddRecExpr>(FirstExprForIV0));
294 EXPECT_TRUE(isa<SCEVAddRecExpr>(FirstExprForIV0Inc));
295 EXPECT_TRUE(isa<SCEVAddRecExpr>(SecondExprForIV0));
863 EXPECT_TRUE(isa<SCEVConstant>(EC));
873 EXPECT_TRUE(isa<SCEVConstant>(ARAtLoopExit));
887 EXPECT_TRUE(isa<SCEVConstant>(NewEC));
891 EXPECT_TRUE(isa<SCEVConstant>(NewARAtLoopExit));
976 EXPECT_TRUE(isa<SCEVConstant>(NewEC));
1032 EXPECT_TRUE(isa<SCEVUnknown>(Expr));
1090 EXPECT_TRUE(isa<SCEVUnknown>(Expr));
1187 EXPECT_TRUE(isa<SCEVAddRecExpr>(S));
1189 EXPECT_TRUE(AR->isAffine());
1192 EXPECT_TRUE(isSafeToExpandAt(AR, L->getTerminator(), SE));
1193 EXPECT_TRUE(isSafeToExpandAt(AR, Post->getTerminator(), SE));
1242 EXPECT_TRUE(isa<SCEVAddExpr>(S));
1294 EXPECT_TRUE(isa<SCEVAddExpr>(S));
1340 EXPECT_TRUE(isa<SCEVAddExpr>(SC2));
1343 EXPECT_TRUE(isa<SCEVAddExpr>(SC1));
1391 EXPECT_TRUE(isa<SCEVAddExpr>(SC2));
1394 EXPECT_TRUE(isa<SCEVAddExpr>(SC1));
1553 EXPECT_TRUE(Loop->getIncomingAndBackEdge(Incoming, Backedge));
1555 EXPECT_TRUE(isa<ConstantInt>(Start));
1556 EXPECT_TRUE(dyn_cast<ConstantInt>(Start)->isZero());
1558 EXPECT_TRUE(isa<BinaryOperator>(Next));
1563 EXPECT_TRUE(isa<ConstantInt>(Step));
1564 EXPECT_TRUE(dyn_cast<ConstantInt>(Step)->isOne());
1664 EXPECT_TRUE(isa<SCEVMulExpr>(AndSCEV));
1665 EXPECT_TRUE(cast<SCEVMulExpr>(AndSCEV)->hasNoSignedWrap());
unittests/Analysis/SparsePropagation.cpp 273 EXPECT_TRUE(Solver.isBlockExecutable(GEntry));
314 EXPECT_TRUE(Solver.getExistingValueState(MemGV).isConstant());
355 EXPECT_TRUE(Solver.getExistingValueState(MemGV).isOverdefined());
395 EXPECT_TRUE(Solver.getExistingValueState(RetF).isConstant());
435 EXPECT_TRUE(Solver.getExistingValueState(RetF).isOverdefined());
483 EXPECT_TRUE(Solver.getExistingValueState(RegA).isOverdefined());
484 EXPECT_TRUE(Solver.getExistingValueState(RegB).isConstant());
540 EXPECT_TRUE(Solver.isBlockExecutable(Pad));
541 EXPECT_TRUE(Solver.isBlockExecutable(Body));
542 EXPECT_TRUE(Solver.isBlockExecutable(Exit));
unittests/Analysis/TBAATest.cpp 63 EXPECT_TRUE(verifyFunction(*F, &Outs));
64 EXPECT_TRUE(StringRef(ErrorMsg.begin(), ErrorMsg.size())
86 EXPECT_TRUE(!verifyFunction(*F));
unittests/Analysis/TargetLibraryInfoTest.cpp 574 EXPECT_TRUE(isLibFunc(F, LF));
unittests/Analysis/UnrollAnalyzerTest.cpp 107 EXPECT_TRUE(I1 != SimplifiedValuesVector[0].end());
112 EXPECT_TRUE(I2 != SimplifiedValuesVector[0].end());
118 EXPECT_TRUE(I1 != SimplifiedValuesVector[TripCount - 1].end());
123 EXPECT_TRUE(I2 != SimplifiedValuesVector[TripCount - 1].end());
124 EXPECT_TRUE(cast<ConstantInt>((*I2).second)->getZExtValue());
174 EXPECT_TRUE(I1 != SimplifiedValuesVector[0].end());
176 EXPECT_TRUE(I2 == SimplifiedValuesVector[0].end());
216 EXPECT_TRUE(I1 != SimplifiedValuesVector[5].end());
219 EXPECT_TRUE(I2 != SimplifiedValuesVector[5].end());
261 EXPECT_TRUE(I1 != SimplifiedValuesVector[5].end());
311 EXPECT_TRUE(I1 != SimplifiedValuesVector[5].end());
314 EXPECT_TRUE(I2 != SimplifiedValuesVector[5].end());
317 EXPECT_TRUE(I3 != SimplifiedValuesVector[5].end());
unittests/Analysis/ValueLatticeTest.cpp 35 EXPECT_TRUE(ValueLatticeElement::get(C1).isConstantRange());
36 EXPECT_TRUE(
38 EXPECT_TRUE(ValueLatticeElement::getOverdefined().isOverdefined());
42 EXPECT_TRUE(ValueLatticeElement::get(C2).isConstant());
43 EXPECT_TRUE(ValueLatticeElement::getNot(C2).isNotConstant());
53 EXPECT_TRUE(LV1.isConstantRange());
57 EXPECT_TRUE(LV1.mergeIn(ValueLatticeElement::get(ConstantInt::get(I32Ty, 99)),
59 EXPECT_TRUE(LV1.isConstantRange());
65 EXPECT_TRUE(LV1.isConstantRange());
71 EXPECT_TRUE(LV2.mergeIn(LV1, M.getDataLayout()));
72 EXPECT_TRUE(LV1.isConstantRange());
75 EXPECT_TRUE(LV2.isConstantRange());
80 EXPECT_TRUE(
82 EXPECT_TRUE(LV1.isOverdefined());
87 EXPECT_TRUE(LV1.isOverdefined());
97 EXPECT_TRUE(LV1.getCompare(CmpInst::ICMP_EQ, I1Ty, LV1)->isOneValue());
98 EXPECT_TRUE(LV1.getCompare(CmpInst::ICMP_SGE, I1Ty, LV1)->isOneValue());
99 EXPECT_TRUE(LV1.getCompare(CmpInst::ICMP_SLE, I1Ty, LV1)->isOneValue());
100 EXPECT_TRUE(LV1.getCompare(CmpInst::ICMP_NE, I1Ty, LV1)->isZeroValue());
101 EXPECT_TRUE(LV1.getCompare(CmpInst::ICMP_SLT, I1Ty, LV1)->isZeroValue());
102 EXPECT_TRUE(LV1.getCompare(CmpInst::ICMP_SGT, I1Ty, LV1)->isZeroValue());
107 EXPECT_TRUE(LV1.getCompare(CmpInst::ICMP_SLT, I1Ty, LV2)->isOneValue());
108 EXPECT_TRUE(LV1.getCompare(CmpInst::ICMP_SLE, I1Ty, LV2)->isOneValue());
109 EXPECT_TRUE(LV1.getCompare(CmpInst::ICMP_NE, I1Ty, LV2)->isOneValue());
110 EXPECT_TRUE(LV1.getCompare(CmpInst::ICMP_EQ, I1Ty, LV2)->isZeroValue());
111 EXPECT_TRUE(LV1.getCompare(CmpInst::ICMP_SGE, I1Ty, LV2)->isZeroValue());
112 EXPECT_TRUE(LV1.getCompare(CmpInst::ICMP_SGT, I1Ty, LV2)->isZeroValue());
143 EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OEQ, I1Ty, LV2)->isOneValue());
144 EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OGE, I1Ty, LV2)->isOneValue());
145 EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OLE, I1Ty, LV2)->isOneValue());
146 EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_ONE, I1Ty, LV2)->isZeroValue());
147 EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OLT, I1Ty, LV2)->isZeroValue());
148 EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OGT, I1Ty, LV2)->isZeroValue());
150 EXPECT_TRUE(
168 EXPECT_TRUE(isa<UndefValue>(LV1.getCompare(CmpInst::ICMP_SLT, I1Ty, LV2)));
169 EXPECT_TRUE(isa<UndefValue>(LV1.getCompare(CmpInst::ICMP_SLE, I1Ty, LV2)));
170 EXPECT_TRUE(isa<UndefValue>(LV1.getCompare(CmpInst::ICMP_NE, I1Ty, LV2)));
171 EXPECT_TRUE(isa<UndefValue>(LV1.getCompare(CmpInst::ICMP_EQ, I1Ty, LV2)));
172 EXPECT_TRUE(isa<UndefValue>(LV1.getCompare(CmpInst::ICMP_SGE, I1Ty, LV2)));
173 EXPECT_TRUE(isa<UndefValue>(LV1.getCompare(CmpInst::ICMP_SGT, I1Ty, LV2)));
177 EXPECT_TRUE(isa<UndefValue>(LV1.getCompare(CmpInst::FCMP_OEQ, I1Ty, LV3)));
178 EXPECT_TRUE(isa<UndefValue>(LV1.getCompare(CmpInst::FCMP_OGE, I1Ty, LV3)));
179 EXPECT_TRUE(isa<UndefValue>(LV1.getCompare(CmpInst::FCMP_OLE, I1Ty, LV3)));
180 EXPECT_TRUE(isa<UndefValue>(LV1.getCompare(CmpInst::FCMP_ONE, I1Ty, LV3)));
181 EXPECT_TRUE(isa<UndefValue>(LV1.getCompare(CmpInst::FCMP_OLT, I1Ty, LV3)));
182 EXPECT_TRUE(isa<UndefValue>(LV1.getCompare(CmpInst::FCMP_OGT, I1Ty, LV3)));
unittests/Analysis/ValueTrackingTest.cpp 33 EXPECT_TRUE(M) << os.str();
unittests/Analysis/VectorFunctionABITest.cpp 48 EXPECT_TRUE(OptVFS.hasValue());
67 EXPECT_TRUE(A.hasValue());
68 EXPECT_TRUE(B.hasValue());
69 EXPECT_TRUE(C.hasValue());
122 EXPECT_TRUE(invokeParser("_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000_sin"));
142 EXPECT_TRUE(invokeParser("_ZGVnN2v_sin(my_v_sin)"));
154 EXPECT_TRUE(invokeParser("_ZGVnN2ln1Ln10Un100Rn1000_sin"));
169 EXPECT_TRUE(invokeParser("_ZGVsMxv_sin"));
171 EXPECT_TRUE(IsMasked());
172 EXPECT_TRUE(IsScalable);
179 EXPECT_TRUE(invokeParser("_ZGVsM2v_sin"));
181 EXPECT_TRUE(IsMasked());
196 EXPECT_TRUE(invokeParser("_ZGVnN2ls2_sin"));
199 EXPECT_TRUE(invokeParser("_ZGVnN2Rs4_sin"));
202 EXPECT_TRUE(invokeParser("_ZGVnN2Ls6_sin"));
205 EXPECT_TRUE(invokeParser("_ZGVnN2Us8_sin"));
209 EXPECT_TRUE(invokeParser("_ZGVnN3lLRUlnLnRnUn_sin"));
222 EXPECT_TRUE(invokeParser("_ZGVqN2v_sin"));
225 EXPECT_TRUE(invokeParser("_ZGVnN2v_sin"));
228 EXPECT_TRUE(invokeParser("_ZGVsN2v_sin"));
231 EXPECT_TRUE(invokeParser("_ZGVbN2v_sin"));
234 EXPECT_TRUE(invokeParser("_ZGVcN2v_sin"));
237 EXPECT_TRUE(invokeParser("_ZGVdN2v_sin"));
240 EXPECT_TRUE(invokeParser("_ZGVeN2v_sin"));
253 EXPECT_TRUE(invokeParser("_ZGVsN2l2a2_sin"));
265 EXPECT_TRUE(invokeParser("_ZGVsN2l2a1_sin"));
271 EXPECT_TRUE(invokeParser("_ZGVnN2u0_sin"));
312 EXPECT_TRUE(invokeParser("_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
318 EXPECT_TRUE(invokeParser("_ZGVsN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
324 EXPECT_TRUE(invokeParser("_ZGVbN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
330 EXPECT_TRUE(invokeParser("_ZGVcN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
336 EXPECT_TRUE(invokeParser("_ZGVdN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
342 EXPECT_TRUE(invokeParser("_ZGVeN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
349 EXPECT_TRUE(invokeParser("_ZGVqN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
370 EXPECT_TRUE(invokeParser("_ZGVnM2v_sin"));
372 EXPECT_TRUE(IsMasked());
382 EXPECT_TRUE(invokeParser("_ZGVsM2v_sin"));
384 EXPECT_TRUE(IsMasked());
394 EXPECT_TRUE(invokeParser("_ZGVbM2v_sin"));
396 EXPECT_TRUE(IsMasked());
406 EXPECT_TRUE(invokeParser("_ZGVcM2v_sin"));
408 EXPECT_TRUE(IsMasked());
418 EXPECT_TRUE(invokeParser("_ZGVdM2v_sin"));
420 EXPECT_TRUE(IsMasked());
430 EXPECT_TRUE(invokeParser("_ZGVeM2v_sin"));
432 EXPECT_TRUE(IsMasked());
unittests/Analysis/VectorUtilsTest.cpp 81 EXPECT_TRUE(isSplatValue(UndefVec));
94 EXPECT_TRUE(isSplatValue(SplatC));
107 EXPECT_TRUE(isSplatValue(A));
116 EXPECT_TRUE(isSplatValue(A));
147 EXPECT_TRUE(isSplatValue(A));
157 EXPECT_TRUE(isSplatValue(A));
191 EXPECT_TRUE(isSplatValue(A));
202 EXPECT_TRUE(isSplatValue(A));
248 EXPECT_TRUE(isSplatValue(A));
unittests/AsmParser/AsmParserTest.cpp 28 EXPECT_TRUE(Mod != nullptr);
29 EXPECT_TRUE(Error.getMessage().empty());
55 EXPECT_TRUE(Mod != nullptr);
56 EXPECT_TRUE(Error.getMessage().empty());
59 EXPECT_TRUE(isa<GlobalVariable>(Mapping.GlobalValues[0]));
78 EXPECT_TRUE(V->getType()->isDoubleTy());
80 EXPECT_TRUE(cast<ConstantFP>(V)->isExactlyValue(3.5));
84 EXPECT_TRUE(V->getType()->isIntegerTy());
86 EXPECT_TRUE(cast<ConstantInt>(V)->equalsInt(42));
90 EXPECT_TRUE(V->getType()->isVectorTy());
unittests/BinaryFormat/DwarfTest.cpp 150 EXPECT_TRUE(RefSize.hasValue());
151 EXPECT_TRUE(AddrSize.hasValue());
158 EXPECT_TRUE(RefSize.hasValue());
159 EXPECT_TRUE(AddrSize.hasValue());
165 EXPECT_TRUE(RefSize.hasValue());
170 EXPECT_TRUE(RefSize.hasValue());
175 EXPECT_TRUE(RefSize.hasValue());
181 EXPECT_TRUE(RefSize.hasValue());
186 EXPECT_TRUE(RefSize.hasValue());
191 EXPECT_TRUE(RefSize.hasValue());
unittests/BinaryFormat/MsgPackReaderTest.cpp 26 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
27 EXPECT_TRUE(*ContinueOrErr);
32 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
33 EXPECT_TRUE(*ContinueOrErr);
39 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
48 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
49 EXPECT_TRUE(*ContinueOrErr);
57 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
58 EXPECT_TRUE(*ContinueOrErr);
67 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
68 EXPECT_TRUE(*ContinueOrErr);
82 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
83 EXPECT_TRUE(*ContinueOrErr);
93 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
94 EXPECT_TRUE(*ContinueOrErr);
103 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
104 EXPECT_TRUE(*ContinueOrErr);
113 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
114 EXPECT_TRUE(*ContinueOrErr);
123 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
124 EXPECT_TRUE(*ContinueOrErr);
133 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
134 EXPECT_TRUE(*ContinueOrErr);
143 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
144 EXPECT_TRUE(*ContinueOrErr);
153 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
154 EXPECT_TRUE(*ContinueOrErr);
163 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
164 EXPECT_TRUE(*ContinueOrErr);
173 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
174 EXPECT_TRUE(*ContinueOrErr);
183 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
184 EXPECT_TRUE(*ContinueOrErr);
193 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
194 EXPECT_TRUE(*ContinueOrErr);
203 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
204 EXPECT_TRUE(*ContinueOrErr);
216 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
217 EXPECT_TRUE(*ContinueOrErr);
227 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
228 EXPECT_TRUE(*ContinueOrErr);
237 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
238 EXPECT_TRUE(*ContinueOrErr);
247 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
248 EXPECT_TRUE(*ContinueOrErr);
257 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
258 EXPECT_TRUE(*ContinueOrErr);
267 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
268 EXPECT_TRUE(*ContinueOrErr);
277 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
278 EXPECT_TRUE(*ContinueOrErr);
287 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
288 EXPECT_TRUE(*ContinueOrErr);
297 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
298 EXPECT_TRUE(*ContinueOrErr);
307 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
308 EXPECT_TRUE(*ContinueOrErr);
317 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
318 EXPECT_TRUE(*ContinueOrErr);
327 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
328 EXPECT_TRUE(*ContinueOrErr);
337 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
338 EXPECT_TRUE(*ContinueOrErr);
347 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
348 EXPECT_TRUE(*ContinueOrErr);
357 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
358 EXPECT_TRUE(*ContinueOrErr);
367 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
368 EXPECT_TRUE(*ContinueOrErr);
378 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
379 EXPECT_TRUE(*ContinueOrErr);
390 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
391 EXPECT_TRUE(*ContinueOrErr);
400 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
401 EXPECT_TRUE(*ContinueOrErr);
411 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
412 EXPECT_TRUE(*ContinueOrErr);
422 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
423 EXPECT_TRUE(*ContinueOrErr);
432 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
433 EXPECT_TRUE(*ContinueOrErr);
443 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
444 EXPECT_TRUE(*ContinueOrErr);
454 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
455 EXPECT_TRUE(*ContinueOrErr);
464 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
465 EXPECT_TRUE(*ContinueOrErr);
475 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
476 EXPECT_TRUE(*ContinueOrErr);
486 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
487 EXPECT_TRUE(*ContinueOrErr);
496 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
497 EXPECT_TRUE(*ContinueOrErr);
507 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
508 EXPECT_TRUE(*ContinueOrErr);
518 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
519 EXPECT_TRUE(*ContinueOrErr);
528 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
529 EXPECT_TRUE(*ContinueOrErr);
539 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
540 EXPECT_TRUE(*ContinueOrErr);
550 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
551 EXPECT_TRUE(*ContinueOrErr);
560 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
561 EXPECT_TRUE(*ContinueOrErr);
571 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
572 EXPECT_TRUE(*ContinueOrErr);
582 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
583 EXPECT_TRUE(*ContinueOrErr);
592 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
593 EXPECT_TRUE(*ContinueOrErr);
602 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
603 EXPECT_TRUE(*ContinueOrErr);
612 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
613 EXPECT_TRUE(*ContinueOrErr);
623 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
624 EXPECT_TRUE(*ContinueOrErr);
633 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
634 EXPECT_TRUE(*ContinueOrErr);
643 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
644 EXPECT_TRUE(*ContinueOrErr);
653 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
654 EXPECT_TRUE(*ContinueOrErr);
663 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
664 EXPECT_TRUE(*ContinueOrErr);
673 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
674 EXPECT_TRUE(*ContinueOrErr);
683 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
684 EXPECT_TRUE(*ContinueOrErr);
693 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
694 EXPECT_TRUE(*ContinueOrErr);
703 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
704 EXPECT_TRUE(*ContinueOrErr);
714 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
715 EXPECT_TRUE(*ContinueOrErr);
724 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
725 EXPECT_TRUE(*ContinueOrErr);
734 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
735 EXPECT_TRUE(*ContinueOrErr);
744 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
745 EXPECT_TRUE(*ContinueOrErr);
754 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
755 EXPECT_TRUE(*ContinueOrErr);
764 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
765 EXPECT_TRUE(*ContinueOrErr);
777 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
778 EXPECT_TRUE(*ContinueOrErr);
789 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
790 EXPECT_TRUE(*ContinueOrErr);
801 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
802 EXPECT_TRUE(*ContinueOrErr);
813 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
814 EXPECT_TRUE(*ContinueOrErr);
825 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
826 EXPECT_TRUE(*ContinueOrErr);
837 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
838 EXPECT_TRUE(*ContinueOrErr);
849 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
850 EXPECT_TRUE(*ContinueOrErr);
861 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
862 EXPECT_TRUE(*ContinueOrErr);
873 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
874 EXPECT_TRUE(*ContinueOrErr);
885 EXPECT_TRUE(static_cast<bool>(ContinueOrErr));
886 EXPECT_TRUE(*ContinueOrErr);
unittests/Bitcode/BitReaderTest.cpp 85 EXPECT_TRUE(F->empty());
86 EXPECT_TRUE(G->empty());
87 EXPECT_TRUE(H->empty());
88 EXPECT_TRUE(J->empty());
93 EXPECT_TRUE(F->empty());
94 EXPECT_TRUE(G->empty());
96 EXPECT_TRUE(J->empty());
101 EXPECT_TRUE(F->empty());
104 EXPECT_TRUE(J->empty());
109 EXPECT_TRUE(F->empty());
155 EXPECT_TRUE(M->getFunction("before")->empty());
156 EXPECT_TRUE(M->getFunction("func")->empty());
162 EXPECT_TRUE(M->getFunction("other")->empty());
182 EXPECT_TRUE(M->getFunction("after")->empty());
183 EXPECT_TRUE(M->getFunction("func")->empty());
189 EXPECT_TRUE(M->getFunction("other")->empty());
unittests/Bitstream/BitstreamReaderTest.cpp 26 EXPECT_TRUE((bool)MaybeRead);
29 EXPECT_TRUE((bool)MaybeRead);
30 EXPECT_TRUE(Cursor.AtEndOfStream());
36 EXPECT_TRUE(Cursor.AtEndOfStream());
46 EXPECT_TRUE(Cursor.AtEndOfStream());
52 EXPECT_TRUE(Cursor.AtEndOfStream());
62 EXPECT_TRUE((bool)MaybeRead);
149 EXPECT_TRUE(Record.empty());
unittests/CodeGen/AArch64SelectionDAGTest.cpp 92 EXPECT_TRUE(Known.isZero());
107 EXPECT_TRUE(Known.isZero());
unittests/CodeGen/GlobalISel/CSETest.cpp 37 EXPECT_TRUE(&*MIBAdd == &*MIBAdd2);
40 EXPECT_TRUE(&*MIBAdd == &*MIBAdd4);
43 EXPECT_TRUE(&*MIBAdd != &*MIBAdd5);
48 EXPECT_TRUE(&*MIBCst == &*MIBCst1);
51 EXPECT_TRUE(&*MIBCF1 == &*MIBCst);
56 EXPECT_TRUE(&*MIBFP0 == &*MIBFP0_1);
74 EXPECT_TRUE(&*MIBUnmerge == &*MIBUnmerge2);
95 EXPECT_TRUE(MIBAdd1->getOpcode() != TargetOpcode::COPY);
96 EXPECT_TRUE(&*MIBAdd1 != &*MIBAdd);
99 EXPECT_TRUE(&*MIBZero == &*MIBZeroTmp);
unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp 32 EXPECT_TRUE(match);
39 EXPECT_TRUE(match);
51 EXPECT_TRUE(match);
59 EXPECT_TRUE(match);
67 EXPECT_TRUE(match);
86 EXPECT_TRUE(FoldGAddInt.hasValue());
91 EXPECT_TRUE(FoldGAddMix.hasValue());
98 EXPECT_TRUE(FoldGAndInt.hasValue());
103 EXPECT_TRUE(FoldGAndMix.hasValue());
110 EXPECT_TRUE(FoldGAShrInt.hasValue());
115 EXPECT_TRUE(FoldGAShrMix.hasValue());
122 EXPECT_TRUE(FoldGLShrInt.hasValue());
127 EXPECT_TRUE(FoldGLShrMix.hasValue());
134 EXPECT_TRUE(FoldGMulInt.hasValue());
139 EXPECT_TRUE(FoldGMulMix.hasValue());
146 EXPECT_TRUE(FoldGOrInt.hasValue());
151 EXPECT_TRUE(FoldGOrMix.hasValue());
158 EXPECT_TRUE(FoldGShlInt.hasValue());
163 EXPECT_TRUE(FoldGShlMix.hasValue());
170 EXPECT_TRUE(FoldGSubInt.hasValue());
175 EXPECT_TRUE(FoldGSubMix.hasValue());
182 EXPECT_TRUE(FoldGXorInt.hasValue());
187 EXPECT_TRUE(FoldGXorMix.hasValue());
194 EXPECT_TRUE(FoldGUdivInt.hasValue());
199 EXPECT_TRUE(FoldGUdivMix.hasValue());
206 EXPECT_TRUE(FoldGSdivInt.hasValue());
211 EXPECT_TRUE(FoldGSdivMix.hasValue());
218 EXPECT_TRUE(FoldGUremInt.hasValue());
223 EXPECT_TRUE(FoldGUremMix.hasValue());
230 EXPECT_TRUE(FoldGSremInt.hasValue());
235 EXPECT_TRUE(FoldGSremMix.hasValue());
unittests/CodeGen/GlobalISel/KnownBitsTest.cpp 133 EXPECT_TRUE(KnownBits.signBitIsZero(Zero.getReg(0)));
unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp 44 EXPECT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
56 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
76 EXPECT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
90 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
109 EXPECT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
121 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
153 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
186 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
205 EXPECT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
213 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
232 EXPECT_TRUE(Helper.lower(*MIBCTLZ, 0, LLT::scalar(64)) ==
244 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
263 EXPECT_TRUE(Helper.lower(*MIBCTLZ, 0, LLT::scalar(64)) ==
275 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
296 EXPECT_TRUE(Helper.lower(*MIBCTLZ, 0, s8) ==
316 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
338 EXPECT_TRUE(Helper.widenScalar(*MIBCTLZ, 1, s16) ==
351 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
374 EXPECT_TRUE(Helper.widenScalar(*MIBCTLZ_ZU, 1, s16) ==
387 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
409 EXPECT_TRUE(Helper.widenScalar(*MIBCTPOP, 1, s16) ==
420 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
443 EXPECT_TRUE(Helper.widenScalar(*MIBCTTZ_ZERO_UNDEF, 1, s16) ==
454 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
476 EXPECT_TRUE(Helper.widenScalar(*MIBCTTZ, 1, s16) ==
489 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
512 EXPECT_TRUE(Helper.widenScalar(*MIBUAddO, 0, s16) ==
527 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
551 EXPECT_TRUE(Helper.widenScalar(*MIBUSUBO, 0, s16) ==
566 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
589 EXPECT_TRUE(Helper.fewerElementsVector(*And, 0, V2S32) ==
613 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
654 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
748 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
794 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
872 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
918 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
1019 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
1056 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
unittests/CodeGen/GlobalISel/MachineIRBuilderTest.cpp 37 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
99 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
120 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
156 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
185 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
214 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
242 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
267 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
293 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
324 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
363 EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
unittests/CodeGen/GlobalISel/PatternMatchTest.cpp 40 EXPECT_TRUE(match);
53 EXPECT_TRUE(match);
57 EXPECT_TRUE(match);
67 EXPECT_TRUE(match);
74 EXPECT_TRUE(match);
86 EXPECT_TRUE(match);
101 EXPECT_TRUE(match);
110 EXPECT_TRUE(match);
118 EXPECT_TRUE(match);
127 EXPECT_TRUE(match);
145 EXPECT_TRUE(match);
150 EXPECT_TRUE(match);
154 EXPECT_TRUE(match);
161 EXPECT_TRUE(match);
162 EXPECT_TRUE(TmpFP);
172 EXPECT_TRUE(match);
173 EXPECT_TRUE(TmpFP64);
184 EXPECT_TRUE(match);
185 EXPECT_TRUE(TmpFP16);
209 EXPECT_TRUE(match);
213 EXPECT_TRUE(match);
217 EXPECT_TRUE(match);
221 EXPECT_TRUE(match);
227 EXPECT_TRUE(match);
232 EXPECT_TRUE(match);
237 EXPECT_TRUE(match);
252 EXPECT_TRUE(mi_match(MIBAdd->getOperand(0).getReg(), *MRI,
258 EXPECT_TRUE(
260 EXPECT_TRUE(
262 EXPECT_TRUE(
274 EXPECT_TRUE(match);
290 EXPECT_TRUE(match);
301 EXPECT_TRUE(match);
323 EXPECT_TRUE(match);
unittests/CodeGen/LowLevelTypeTest.cpp 39 EXPECT_TRUE(Ty == Ty);
79 EXPECT_TRUE(VTy == VTy);
194 EXPECT_TRUE(Ty == Ty);
196 EXPECT_TRUE(VTy == VTy);
unittests/CodeGen/MachineInstrBundleIteratorTest.cpp 37 EXPECT_TRUE(MBI.isBundledWithPred());
38 EXPECT_TRUE(MBI.isBundledWithSucc());
76 EXPECT_TRUE(MBI.isBundledWithPred());
77 EXPECT_TRUE(MBI.isBundledWithSucc());
unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp 222 EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
227 EXPECT_TRUE(ValidateVisitedRecord(I.index(), I.value()));
251 EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
256 EXPECT_TRUE(ValidateVisitedRecord(I.index(), I.value()));
280 EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
285 EXPECT_TRUE(ValidateVisitedRecord(I.index(), I.value()));
311 EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
316 EXPECT_TRUE(ValidateVisitedRecord(I.index(), I.value()));
341 EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
346 EXPECT_TRUE(ValidateVisitedRecord(I.index(), I.value()));
unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp 118 EXPECT_TRUE(Success);
unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp 229 EXPECT_TRUE((bool)Obj);
236 EXPECT_TRUE(DieDG.isValid());
251 EXPECT_TRUE((bool)FormValue);
253 EXPECT_TRUE(BlockDataOpt.hasValue());
256 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
259 EXPECT_TRUE((bool)FormValue);
261 EXPECT_TRUE(BlockDataOpt.hasValue());
264 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
267 EXPECT_TRUE((bool)FormValue);
269 EXPECT_TRUE(BlockDataOpt.hasValue());
272 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
275 EXPECT_TRUE((bool)FormValue);
277 EXPECT_TRUE(BlockDataOpt.hasValue());
280 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
285 EXPECT_TRUE((bool)FormValue);
287 EXPECT_TRUE(BlockDataOpt.hasValue());
290 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), Data16, 16) == 0);
305 EXPECT_TRUE((bool)ExtractedStringValue);
310 EXPECT_TRUE((bool)ExtractedStrxValue);
314 EXPECT_TRUE((bool)ExtractedStrx1Value);
318 EXPECT_TRUE((bool)ExtractedStrx2Value);
322 EXPECT_TRUE((bool)ExtractedStrx3Value);
326 EXPECT_TRUE((bool)ExtractedStrx4Value);
331 EXPECT_TRUE((bool)ExtractedStrpValue);
493 EXPECT_TRUE((bool)Obj);
504 EXPECT_TRUE(DieDG.isValid());
508 EXPECT_TRUE(SubprogramDieDG.isValid());
513 EXPECT_TRUE(ArgcDieDG.isValid());
518 EXPECT_TRUE(NullDieDG.isValid());
521 EXPECT_TRUE(!NullDieDG.getSibling().isValid());
522 EXPECT_TRUE(!NullDieDG.getFirstChild().isValid());
527 EXPECT_TRUE(IntDieDG.isValid());
532 EXPECT_TRUE(NullDieDG.isValid());
535 EXPECT_TRUE(!NullDieDG.getSibling().isValid());
536 EXPECT_TRUE(!NullDieDG.getFirstChild().isValid());
541 EXPECT_TRUE(IntDieDG.isValid());
670 EXPECT_TRUE((bool)Obj);
683 EXPECT_TRUE(Unit1DieDG.isValid());
686 EXPECT_TRUE(Unit2DieDG.isValid());
690 EXPECT_TRUE(CU1TypeDieDG.isValid());
696 EXPECT_TRUE(CU2TypeDieDG.isValid());
703 EXPECT_TRUE(CU1Ref1DieDG.isValid());
710 EXPECT_TRUE(CU1Ref2DieDG.isValid());
718 EXPECT_TRUE(CU1Ref4DieDG.isValid());
726 EXPECT_TRUE(CU1Ref8DieDG.isValid());
734 EXPECT_TRUE(CU1RefAddrDieDG.isValid());
742 EXPECT_TRUE(CU1ToCU2RefAddrDieDG.isValid());
750 EXPECT_TRUE(CU2Ref1DieDG.isValid());
757 EXPECT_TRUE(CU2Ref2DieDG.isValid());
765 EXPECT_TRUE(CU2Ref4DieDG.isValid());
773 EXPECT_TRUE(CU2Ref8DieDG.isValid());
781 EXPECT_TRUE(CU2RefAddrDieDG.isValid());
789 EXPECT_TRUE(CU2ToCU1RefAddrDieDG.isValid());
880 EXPECT_TRUE((bool)Obj);
891 EXPECT_TRUE(DieDG.isValid());
898 EXPECT_TRUE(SubprogramDieNoPC.isValid());
917 EXPECT_TRUE(SubprogramDieLowPC.isValid());
920 EXPECT_TRUE((bool)OptU64);
934 EXPECT_TRUE(SubprogramDieLowHighPC.isValid());
937 EXPECT_TRUE((bool)OptU64);
945 EXPECT_TRUE((bool)OptU64);
952 EXPECT_TRUE((bool)OptU64);
959 EXPECT_TRUE((bool)OptU64);
962 EXPECT_TRUE(SubprogramDieLowHighPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
1098 EXPECT_TRUE(
1149 EXPECT_TRUE((bool)Obj);
1160 EXPECT_TRUE(CUDie.isValid());
1176 EXPECT_TRUE(Null.isNULL());
1187 EXPECT_TRUE(A.hasChildren());
1189 EXPECT_TRUE(C.hasChildren());
1190 EXPECT_TRUE(D.hasChildren());
1213 EXPECT_TRUE(C2.getSibling().isNULL());
1321 EXPECT_TRUE((bool)Obj);
1332 EXPECT_TRUE(CUDie.isValid());
1395 EXPECT_TRUE(CUDie.isValid());
1432 EXPECT_TRUE((bool)Obj);
1443 EXPECT_TRUE(CUDie.isValid());
1501 EXPECT_TRUE((bool)Obj);
1512 EXPECT_TRUE(CUDie.isValid());
1529 EXPECT_TRUE(NameOpt);
1532 EXPECT_TRUE(StringOpt);
1548 EXPECT_TRUE(NameOpt);
1551 EXPECT_TRUE(StringOpt);
1587 EXPECT_TRUE(toAddress(FormValOpt2).hasValue());
1603 EXPECT_TRUE(toUnsigned(FormValOpt3).hasValue());
1605 EXPECT_TRUE(toSigned(FormValOpt3).hasValue());
1623 EXPECT_TRUE(toReference(FormValOpt4).hasValue());
1641 EXPECT_TRUE(toUnsigned(FormValOpt5).hasValue());
1643 EXPECT_TRUE(toSigned(FormValOpt5).hasValue());
1667 EXPECT_TRUE(BlockOpt.hasValue());
1704 EXPECT_TRUE((bool)Obj);
1715 EXPECT_TRUE(CUDie.isValid());
1738 EXPECT_TRUE(NameOpt.hasValue());
1768 EXPECT_TRUE((bool)Obj);
1772 EXPECT_TRUE((bool)U);
1775 EXPECT_TRUE((bool)Abbrevs);
1791 EXPECT_TRUE((bool)FormValue);
1795 EXPECT_TRUE((bool)V);
1834 EXPECT_TRUE((bool)AbbrevPtr);
1836 EXPECT_TRUE((bool)FormValue);
1838 EXPECT_TRUE((bool)V);
1862 EXPECT_TRUE(DwarfContext.verify(Strm));
1863 EXPECT_TRUE(Str.str().contains(Error));
1870 EXPECT_TRUE(Str.str().contains(Error));
1876 EXPECT_TRUE(DwarfContext.verify(Strm));
2530 EXPECT_TRUE((bool)Obj);
2541 EXPECT_TRUE(Errors == 2);
2551 EXPECT_TRUE(Errors == 1);
unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp 505 EXPECT_TRUE(Parser.done());
526 EXPECT_TRUE(Parser.done());
538 EXPECT_TRUE(Parser.done());
554 EXPECT_TRUE(Parser.done());
575 EXPECT_TRUE(Parser.done());
597 EXPECT_TRUE(Parser.done());
632 EXPECT_TRUE(Parser.done());
654 EXPECT_TRUE(Parser.done());
674 EXPECT_TRUE(Parser.done());
unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp 27 EXPECT_TRUE(isFormClass(DW_FORM_addr, DWARFFormValue::FC_Address));
29 EXPECT_TRUE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_Constant));
30 EXPECT_TRUE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_SectionOffset));
31 EXPECT_TRUE(
33 EXPECT_TRUE(isFormClass(DW_FORM_GNU_str_index, DWARFFormValue::FC_String));
34 EXPECT_TRUE(isFormClass(DW_FORM_GNU_addr_index, DWARFFormValue::FC_Address));
36 EXPECT_TRUE(isFormClass(DW_FORM_ref_addr, DWARFFormValue::FC_Reference));
37 EXPECT_TRUE(isFormClass(DW_FORM_ref_sig8, DWARFFormValue::FC_Reference));
unittests/DebugInfo/GSYM/GSYMTest.cpp 67 EXPECT_TRUE(R.second);
73 EXPECT_TRUE(R.second);
90 EXPECT_TRUE(FI.isValid());
99 EXPECT_TRUE(FI.hasRichInfo());
367 EXPECT_TRUE(II.isValid());
422 EXPECT_TRUE(InlineInfos);
429 EXPECT_TRUE(InlineInfos);
434 EXPECT_TRUE(InlineInfos);
442 EXPECT_TRUE(InlineInfos);
447 EXPECT_TRUE(InlineInfos);
534 EXPECT_TRUE(E1.isValid());
553 EXPECT_TRUE(Range.contains(StartAddr));
554 EXPECT_TRUE(Range.contains(EndAddr - 1));
596 EXPECT_TRUE(Range.intersects(OverlapsRangeStart));
597 EXPECT_TRUE(Range.intersects(InsideRange));
598 EXPECT_TRUE(Range.intersects(OverlapsRangeEnd));
612 EXPECT_TRUE(Ranges.contains(0x1000));
613 EXPECT_TRUE(Ranges.contains(0x2000));
614 EXPECT_TRUE(Ranges.contains(0x4000));
615 EXPECT_TRUE(Ranges.contains(0x2000 - 1));
616 EXPECT_TRUE(Ranges.contains(0x3000 - 1));
618 EXPECT_TRUE(Ranges.contains(0x5000 - 1));
625 EXPECT_TRUE(Ranges.contains(AddressRange(0x1000, 0x1000+1)));
626 EXPECT_TRUE(Ranges.contains(AddressRange(0x1000, 0x2000)));
628 EXPECT_TRUE(Ranges.contains(AddressRange(0x2000, 0x3000)));
1119 EXPECT_TRUE(bool(DecodedFI));
unittests/DebugInfo/MSF/MSFBuilderTest.cpp 102 EXPECT_TRUE(Msf.isBlockFree(I));
unittests/DebugInfo/PDB/HashTableTest.cpp 185 EXPECT_TRUE(NSM.get("One", N));
188 EXPECT_TRUE(NSM.get("Two", N));
191 EXPECT_TRUE(NSM.get("Three", N));
194 EXPECT_TRUE(NSM.get("Four", N));
197 EXPECT_TRUE(NSM.get("Five", N));
200 EXPECT_TRUE(NSM.get("Six", N));
203 EXPECT_TRUE(NSM.get("Seven", N));
unittests/Demangle/PartialDemangleTest.cpp 68 EXPECT_TRUE(D.isFunction());
92 EXPECT_TRUE(Demangler.isFunction());
93 EXPECT_TRUE(Demangler.hasFunctionQualifiers());
101 EXPECT_TRUE(Demangler.isSpecialName());
108 EXPECT_TRUE(Demangler.isData());
129 EXPECT_TRUE(D.isCtorOrDtor());
144 EXPECT_TRUE(D2.isFunction());
146 EXPECT_TRUE(D1.partialDemangle("Not a mangled name!"));
unittests/ExecutionEngine/JITLink/MachO_x86_64_Tests.cpp 66 EXPECT_TRUE(E.getTarget().isDefined())
93 EXPECT_TRUE(E.getTarget().isDefined()) << "Target is not a defined symbol";
unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp 392 EXPECT_TRUE(didCallAllocateCodeSection);
412 EXPECT_TRUE(didCallAllocateCodeSection);
422 EXPECT_TRUE(
450 EXPECT_TRUE(MM->UsedCodeSize > 0);
451 EXPECT_TRUE(MM->UsedDataSizeRW > 0);
468 EXPECT_TRUE(didCallYield);
unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp 232 EXPECT_TRUE(0 != FBPtr);
238 EXPECT_TRUE(0 != FAPtr);
unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp 99 EXPECT_TRUE(nullptr != vPtr)
139 EXPECT_TRUE(Cache->wasModuleLookedUp(SavedModulePointer));
143 EXPECT_TRUE(nullptr != ObjBuffer);
177 EXPECT_TRUE(Cache->wasModuleLookedUp(SecondModulePointer));
218 EXPECT_TRUE(Cache->wasModuleLookedUp(SecondModulePointer));
222 EXPECT_TRUE(nullptr != ObjBuffer);
unittests/ExecutionEngine/MCJIT/MCJITTest.cpp 53 EXPECT_TRUE(nullptr != globalPtr)
66 EXPECT_TRUE(0 != addPtr)
87 EXPECT_TRUE(0 != ptr)
109 EXPECT_TRUE(0 != rgvPtr);
186 EXPECT_TRUE(0 != ptr)
205 EXPECT_TRUE(A != nullptr) << "Failed lookup - test not correctly configured.";
unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp 29 EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
57 EXPECT_TRUE(OnCompletionRun) << "Should have been marked ready";
76 EXPECT_TRUE(OnCompletionRun) << "OnCompletionCallback was not run";
90 EXPECT_TRUE(OnCompletionRun) << "OnCompletion was not run for empty query";
144 EXPECT_TRUE(!!Err) << "Expected failure";
145 EXPECT_TRUE(Err.isA<SymbolsNotFound>())
153 EXPECT_TRUE(!!Err) << "Expected failure";
154 EXPECT_TRUE(Err.isA<SymbolsCouldNotBeRemoved>())
168 EXPECT_TRUE(BarDiscarded) << "\"Bar\" should have been discarded";
169 EXPECT_TRUE(BarMaterializerDestructed)
171 EXPECT_TRUE(OnCompletionRun) << "OnCompletion should have been run";
190 EXPECT_TRUE(OnCompletionRun) << "OnCompletion was not run for empty query";
273 EXPECT_TRUE(!!Result) << "Unexpected lookup failure";
288 EXPECT_TRUE(!!Result) << "Unexpected lookup failure";
382 EXPECT_TRUE(FooReady)
501 EXPECT_TRUE(FooResolved) << "\"Foo\" should be resolved now";
502 EXPECT_TRUE(BarResolved) << "\"Bar\" should be resolved now";
503 EXPECT_TRUE(BazResolved) << "\"Baz\" should be resolved now";
525 EXPECT_TRUE(FooReady) << "\"Foo\" should be ready now";
526 EXPECT_TRUE(BarReady) << "\"Bar\" should be ready now";
527 EXPECT_TRUE(BazReady) << "\"Baz\" should be ready now";
573 EXPECT_TRUE(OnBarReadyRun) << "Query for \"Bar\" was not run";
583 EXPECT_TRUE(OnFooReadyRun) << "Query for \"Foo\" was not run";
637 EXPECT_TRUE(OnBarReadyRun) << "Query for \"Bar\" was not run";
647 EXPECT_TRUE(OnFooReadyRun) << "Query for \"Foo\" was not run";
698 EXPECT_TRUE(OnBarReadyRun) << "Query for \"Bar\" was not run";
711 EXPECT_TRUE(OnFooReadyRun) << "Query for \"Foo\" was not run";
771 EXPECT_TRUE(OnFooReadyRun) << "Query for Foo did not run";
772 EXPECT_TRUE(OnBarReadyRun) << "Query for Bar did not run";
795 EXPECT_TRUE(MaterializerRun) << "Expected materializer to have run by now";
816 EXPECT_TRUE(Name == Foo || Name == Bar)
830 EXPECT_TRUE(DestructorRun)
862 EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
873 EXPECT_TRUE(FooMaterialized) << "Foo was not materialized";
874 EXPECT_TRUE(BarDiscarded) << "Bar was not discarded";
875 EXPECT_TRUE(OnCompletionRun) << "OnResolutionCallback was not run";
916 EXPECT_TRUE(OnCompletionRun) << "OnCompletion not run";
917 EXPECT_TRUE(BarMaterialized) << "Bar was not materialized at all";
918 EXPECT_TRUE(DuplicateBarDiscarded)
1005 EXPECT_TRUE(F.getSymbols().count(&JD))
1077 EXPECT_TRUE(QueryHandlerRun) << "Query handler never ran";
1165 EXPECT_TRUE(FooMaterialized) << "Foo should be materialized now";
1172 EXPECT_TRUE(BarMaterialized) << "Bar should be materialized now";
1191 EXPECT_TRUE(!!Result) << "Result should be a success value";
1229 EXPECT_TRUE(!!Err) << "Expected failure value";
1230 EXPECT_TRUE(Err.isA<DuplicateDefinition>())
unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp 39 EXPECT_TRUE(isa<LoadInst>(*II)) << "First instruction of stub should be a load.";
41 EXPECT_TRUE(Call != nullptr) << "Second instruction of stub should be a call.";
42 EXPECT_TRUE(Call->isTailCall()) << "Indirect call from stub should be tail call.";
43 EXPECT_TRUE(Call->hasStructRetAttr())
45 EXPECT_TRUE(Call->paramHasAttr(1U, Attribute::ByVal))
unittests/ExecutionEngine/Orc/LazyCallThroughAndReexportsTest.cpp 71 EXPECT_TRUE(DummyTargetMaterialized)
unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp 49 EXPECT_TRUE(!!Result) << "Unexpected error";
66 EXPECT_TRUE(OnCompletionRun) << "OnCompletion was never run";
92 EXPECT_TRUE(!!RS) << "Expected getResponsibilitySetWithLegacyFn to succeed";
101 EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";
118 EXPECT_TRUE(OnCompletionRun) << "OnCompletion was not run";
unittests/ExecutionEngine/Orc/LegacyCompileOnDemandLayerTest.cpp 85 EXPECT_TRUE(!!Sym) << "CompileOnDemand::findSymbol should call findSymbol in "
unittests/ExecutionEngine/Orc/OrcCAPITest.cpp 203 EXPECT_TRUE(C.Compiled)
unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp 259 EXPECT_TRUE(!!Result) << "Async int(int) response handler failed";
350 EXPECT_TRUE(!!Result) << "Async int(int) response handler failed";
401 EXPECT_TRUE(!!Result) << "Async int(int) response handler failed";
556 EXPECT_TRUE(!!FOrErr)
599 EXPECT_TRUE(!!FOrErr)
665 EXPECT_TRUE(Err.isA<DummyError>())
700 EXPECT_TRUE(!!ValOrErr)
735 EXPECT_TRUE(Err.isA<DummyError>())
776 EXPECT_TRUE(!!Result) << "Async int(int) response handler failed";
787 EXPECT_TRUE(!!Result) << "Async int(int) response handler failed";
798 EXPECT_TRUE(!!Result) << "Async int(int) response handler failed";
861 EXPECT_TRUE(Err.isA<CouldNotNegotiate>())
unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp 96 EXPECT_TRUE(testSetProcessAllSections(std::move(Obj), true))
unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp 142 EXPECT_TRUE(std::equal(RPCObjContents.begin(), RPCObjContents.end(),
316 EXPECT_TRUE(!!Err) << "Expected error from removeObject";
381 EXPECT_TRUE(!!Sym1) << "Symbol 'foobar' should be findable";
390 EXPECT_TRUE(!!Err) << "Sym2 should contain an error value";
470 EXPECT_TRUE(!!Sym1) << "Symbol 'foobar' should be findable";
477 EXPECT_TRUE(!!Err) << "Sym2 should contain an error value";
578 EXPECT_TRUE(!!Err) << "emitAndFinalize should work";
unittests/ExecutionEngine/Orc/SymbolStringPoolTest.cpp 50 EXPECT_TRUE(SP.empty()) << "pool should be empty";
unittests/FuzzMutate/OperationsTest.cpp 101 EXPECT_TRUE(OnlyI32.matches({}, i32));
110 EXPECT_TRUE(AnyType.matches({}, i1));
111 EXPECT_TRUE(AnyType.matches({}, f64));
112 EXPECT_TRUE(AnyType.matches({}, s));
113 EXPECT_TRUE(AnyType.matches({}, v8i8));
114 EXPECT_TRUE(AnyType.matches({}, p0i32));
121 EXPECT_TRUE(AnyInt.matches({}, i1));
122 EXPECT_TRUE(AnyInt.matches({}, i64));
131 EXPECT_TRUE(AnyFP.matches({}, f16));
132 EXPECT_TRUE(AnyFP.matches({}, f32));
142 EXPECT_TRUE(AnyPtr.matches({}, p0i32));
153 EXPECT_TRUE(AnyVec.matches({}, v8i8));
154 EXPECT_TRUE(AnyVec.matches({}, v4f16));
163 EXPECT_TRUE(First.matches({i8}, i8));
164 EXPECT_TRUE(First.matches({s, a}, s));
293 EXPECT_TRUE(GEPOp.SourcePreds[0].matches({}, UndefValue::get(Int8PtrTy)));
294 EXPECT_TRUE(GEPOp.SourcePreds[1].matches({UndefValue::get(Int8PtrTy)},
352 EXPECT_TRUE(EVOp.SourcePreds[0].matches({}, SVal));
354 EXPECT_TRUE(EVOp.SourcePreds[0].matches({}, AVal));
356 EXPECT_TRUE(IVOp.SourcePreds[0].matches({}, SVal));
358 EXPECT_TRUE(IVOp.SourcePreds[0].matches({}, AVal));
366 EXPECT_TRUE(
368 EXPECT_TRUE(
376 EXPECT_TRUE(
378 EXPECT_TRUE(
389 EXPECT_TRUE(IVOp.SourcePreds[1].matches({SVal}, UndefValue::get(Int8PtrTy)));
390 EXPECT_TRUE(IVOp.SourcePreds[1].matches({SVal}, UndefValue::get(Int32Ty)));
394 EXPECT_TRUE(IVOp.SourcePreds[2].matches({SVal, UndefValue::get(Int32Ty)},
unittests/FuzzMutate/StrategiesTest.cpp 74 EXPECT_TRUE(!verifyModule(*M, &errs()));
89 EXPECT_TRUE(!verifyModule(*M, &errs()));
unittests/IR/AsmWriterTest.cpp 35 EXPECT_TRUE(r != std::string::npos);
unittests/IR/AttributesTest.cpp 39 EXPECT_TRUE(Align4 < Align5);
40 EXPECT_TRUE(Align4 < Deref4);
41 EXPECT_TRUE(Align4 < Deref5);
42 EXPECT_TRUE(Align5 < Deref4);
46 EXPECT_TRUE(ByVal < Align4);
62 EXPECT_TRUE(AL.hasFnAttribute(Attribute::NoReturn));
66 EXPECT_TRUE(AL.hasAttribute(AttributeList::ReturnIndex, Attribute::SExt));
67 EXPECT_TRUE(AL.hasFnAttribute(Attribute::NoReturn));
87 EXPECT_TRUE(AS.getAlignment() == 8);
88 EXPECT_TRUE(AS.hasAttribute(Attribute::ReadOnly));
91 EXPECT_TRUE(AS.hasAttribute(Attribute::ReadOnly));
94 EXPECT_TRUE(AS.getAlignment() == 0);
95 EXPECT_TRUE(AS.hasAttribute(Attribute::ReadOnly));
100 EXPECT_TRUE(AL.hasAttributes(0));
101 EXPECT_TRUE(AL.hasAttribute(0, Attribute::StackAlignment));
102 EXPECT_TRUE(AL.hasAttribute(0, Attribute::OptimizeNone));
103 EXPECT_TRUE(AL.getStackAlignment(0) == 32);
104 EXPECT_TRUE(AL.hasParamAttrs(0));
105 EXPECT_TRUE(AL.hasParamAttr(0, Attribute::Alignment));
106 EXPECT_TRUE(AL.hasParamAttr(0, Attribute::ReadOnly));
107 EXPECT_TRUE(AL.getParamAlignment(0) == 8);
111 EXPECT_TRUE(AL.hasParamAttr(0, Attribute::ReadOnly));
112 EXPECT_TRUE(AL.hasAttribute(0, Attribute::StackAlignment));
113 EXPECT_TRUE(AL.hasAttribute(0, Attribute::OptimizeNone));
114 EXPECT_TRUE(AL.getStackAlignment(0) == 32);
118 EXPECT_TRUE(AL.hasParamAttr(0, Attribute::ReadOnly));
120 EXPECT_TRUE(AL.hasAttribute(0, Attribute::OptimizeNone));
128 EXPECT_TRUE(AL2.hasParamAttr(0, Attribute::ReadOnly));
129 EXPECT_TRUE(AL2.hasAttribute(0, Attribute::StackAlignment));
130 EXPECT_TRUE(AL2.hasAttribute(0, Attribute::OptimizeNone));
131 EXPECT_TRUE(AL2.getStackAlignment(0) == 32);
135 EXPECT_TRUE(AL2.hasParamAttr(0, Attribute::ReadOnly));
137 EXPECT_TRUE(AL2.hasAttribute(0, Attribute::OptimizeNone));
156 EXPECT_TRUE(AL.hasParamAttribute(0, Attribute::NonNull));
163 EXPECT_TRUE(AL.isEmpty());
unittests/IR/BasicBlockTest.cpp 38 EXPECT_TRUE(false) << "empty block should have no phis";
unittests/IR/CFGBuilder.cpp 172 EXPECT_TRUE(B.getOrAddBlock("entry") == &Holder.F->getEntryBlock());
173 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("entry")->getTerminator()));
174 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("a")->getTerminator()));
175 EXPECT_TRUE(isa<UnreachableInst>(B.getOrAddBlock("b")->getTerminator()));
176 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("d")->getTerminator()));
200 EXPECT_TRUE(B.getOrAddBlock("entry") == &Holder.F->getEntryBlock());
201 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("entry")->getTerminator()));
202 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("a")->getTerminator()));
203 EXPECT_TRUE(isa<UnreachableInst>(B.getOrAddBlock("b")->getTerminator()));
204 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("d")->getTerminator()));
224 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("entry")->getTerminator()));
225 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("a")->getTerminator()));
226 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("c")->getTerminator()));
227 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("d")->getTerminator()));
231 EXPECT_TRUE(UpdateC);
235 EXPECT_TRUE(isa<UnreachableInst>(B.getOrAddBlock("c")->getTerminator()));
242 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("a")->getTerminator()));
243 EXPECT_TRUE(isa<UnreachableInst>(B.getOrAddBlock("entry")->getTerminator()));
264 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("entry")->getTerminator()));
265 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("a")->getTerminator()));
266 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("c")->getTerminator()));
267 EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("d")->getTerminator()));
unittests/IR/ConstantRangeTest.cpp 86 EXPECT_TRUE(CR.isEmptySet());
92 EXPECT_TRUE(CR.contains(Exact));
123 EXPECT_TRUE(CR.isEmptySet());
129 EXPECT_TRUE(CR.contains(Exact));
143 EXPECT_TRUE(Full.isFullSet());
145 EXPECT_TRUE(Full.inverse().isEmptySet());
147 EXPECT_TRUE(Full.contains(APInt(16, 0x0)));
148 EXPECT_TRUE(Full.contains(APInt(16, 0x9)));
149 EXPECT_TRUE(Full.contains(APInt(16, 0xa)));
150 EXPECT_TRUE(Full.contains(APInt(16, 0xaa9)));
151 EXPECT_TRUE(Full.contains(APInt(16, 0xaaa)));
154 EXPECT_TRUE(Empty.isEmptySet());
155 EXPECT_TRUE(Empty.inverse().isFullSet());
168 EXPECT_TRUE(One.contains(APInt(16, 0xa)));
178 EXPECT_TRUE(Some.contains(APInt(16, 0xa)));
179 EXPECT_TRUE(Some.contains(APInt(16, 0xaa9)));
184 EXPECT_TRUE(Wrap.isWrappedSet());
185 EXPECT_TRUE(Wrap.contains(APInt(16, 0x0)));
186 EXPECT_TRUE(Wrap.contains(APInt(16, 0x9)));
189 EXPECT_TRUE(Wrap.contains(APInt(16, 0xaaa)));
228 EXPECT_TRUE(One.isSingleElement());
264 EXPECT_TRUE(Wrap.isSignWrappedSet());
267 EXPECT_TRUE(ConstantRange(APInt(8, 127), APInt(8, 129)).isSignWrappedSet());
269 EXPECT_TRUE(ConstantRange(APInt(8, 10), APInt(8, 9)).isSignWrappedSet());
270 EXPECT_TRUE(ConstantRange(APInt(8, 10), APInt(8, 250)).isSignWrappedSet());
281 EXPECT_TRUE(Wrap.isUpperWrapped());
286 EXPECT_TRUE(Wrap.isUpperSignWrapped());
291 EXPECT_TRUE(CR1.isUpperWrapped());
295 EXPECT_TRUE(CR2.isUpperSignWrapped());
304 EXPECT_TRUE(TFull.isFullSet());
305 EXPECT_TRUE(TEmpty.isEmptySet());
308 EXPECT_TRUE(TSome.isFullSet());
309 EXPECT_TRUE(TWrap.isFullSet());
317 EXPECT_TRUE(TwoSix.truncate(2).isFullSet());
335 EXPECT_TRUE(ZEmpty.isEmptySet());
355 EXPECT_TRUE(SEmpty.isEmptySet());
390 EXPECT_TRUE(LHS.intersectWith(RHS) == LHS);
481 EXPECT_TRUE(SmallestCR.isEmptySet());
482 EXPECT_TRUE(UnsignedCR.isEmptySet());
483 EXPECT_TRUE(SignedCR.isEmptySet());
489 EXPECT_TRUE(SmallestCR.isFullSet());
490 EXPECT_TRUE(UnsignedCR.isFullSet());
491 EXPECT_TRUE(SignedCR.isFullSet());
524 EXPECT_TRUE(Variant1 == SmallestCR || Variant2 == SmallestCR);
538 EXPECT_TRUE(Variant1 == UnsignedCR || Variant2 == UnsignedCR);
552 EXPECT_TRUE(Variant1 == SignedCR || Variant2 == SignedCR);
663 EXPECT_TRUE(CR.contains(N));
669 EXPECT_TRUE(CR.isEmptySet());
696 EXPECT_TRUE(CR.contains(N));
703 EXPECT_TRUE(CR.isEmptySet());
739 EXPECT_TRUE(CR.contains(N));
747 EXPECT_TRUE(CR.isEmptySet());
1103 EXPECT_TRUE(CR.isEmptySet());
1320 EXPECT_TRUE(ConstantRange::makeAllowedICmpRegion(ICmpInst::ICMP_SGT, SMax)
1336 EXPECT_TRUE(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_EQ,
1440 EXPECT_TRUE(NSWForAllValues.isSingleElement() &&
1446 EXPECT_TRUE(NSWForAllValues.isSingleElement() &&
1452 EXPECT_TRUE(NUWForAllValues.isSingleElement() &&
1458 EXPECT_TRUE(NUWForAllValues.isSingleElement() &&
1461 EXPECT_TRUE(ConstantRange::makeGuaranteedNoWrapRegion(
1463 EXPECT_TRUE(ConstantRange::makeGuaranteedNoWrapRegion(
1465 EXPECT_TRUE(ConstantRange::makeGuaranteedNoWrapRegion(
1467 EXPECT_TRUE(ConstantRange::makeGuaranteedNoWrapRegion(
1696 EXPECT_TRUE(ConstantRange(APInt::getMinValue(32), APInt(32, 100))
1701 EXPECT_TRUE(ConstantRange(APInt::getSignedMinValue(32), APInt(32, 100))
1706 EXPECT_TRUE(ConstantRange(APInt(32, 100), APInt::getMinValue(32))
1711 EXPECT_TRUE(ConstantRange(APInt(32, 100), APInt::getSignedMinValue(32))
1716 EXPECT_TRUE(
1721 EXPECT_TRUE(
1737 EXPECT_TRUE(ConstantRange(APInt(32, 100)).getEquivalentICmp(Pred, RHS));
1741 EXPECT_TRUE(
1746 EXPECT_TRUE(
1755 EXPECT_TRUE(ConstantRange(APInt(32, 0)).getEquivalentICmp(Pred, RHS));
1759 EXPECT_TRUE(
1764 EXPECT_TRUE(ConstantRange(APInt(32, -1)).getEquivalentICmp(Pred, RHS));
1768 EXPECT_TRUE(
1975 EXPECT_TRUE(RangeHasOverflowLow);
1980 EXPECT_TRUE(RangeHasOverflowHigh);
1987 EXPECT_TRUE(RangeHasNoOverflow);
1996 EXPECT_TRUE(RangeHasOverflowLow || RangeHasOverflowHigh);
1997 EXPECT_TRUE(RangeHasNoOverflow);
2136 EXPECT_TRUE(Empty.isAllNegative());
2137 EXPECT_TRUE(Empty.isAllNonNegative());
2216 EXPECT_TRUE(AbsCR.isEmptySet());
unittests/IR/ConstantsTest.cpp 126 EXPECT_TRUE(isa<ConstantFP>(X));
unittests/IR/DebugTypeODRUniquingTest.cpp 20 EXPECT_TRUE(Context.isODRUniquingDebugTypes());
unittests/IR/DominatorTreeBatchUpdatesTest.cpp 98 EXPECT_TRUE(DT.verify());
100 EXPECT_TRUE(PDT.verify());
109 EXPECT_TRUE(DT.verify());
111 EXPECT_TRUE(PDT.verify());
120 EXPECT_TRUE(DT.verify());
122 EXPECT_TRUE(PDT.verify());
131 EXPECT_TRUE(DT.verify());
133 EXPECT_TRUE(PDT.verify());
146 EXPECT_TRUE(DT.verify());
148 EXPECT_TRUE(PDT.verify());
162 EXPECT_TRUE(DT.verify());
164 EXPECT_TRUE(PDT.verify());
179 EXPECT_TRUE(DT.verify());
181 EXPECT_TRUE(PDT.verify());
189 EXPECT_TRUE(DT.verify());
191 EXPECT_TRUE(PDT.verify());
210 EXPECT_TRUE(DT.verify());
212 EXPECT_TRUE(PDT.verify());
219 EXPECT_TRUE(DT.verify());
221 EXPECT_TRUE(PDT.verify());
243 EXPECT_TRUE(DT.verify());
245 EXPECT_TRUE(PDT.verify());
252 EXPECT_TRUE(DT.verify());
254 EXPECT_TRUE(PDT.verify());
276 EXPECT_TRUE(DT.verify());
278 EXPECT_TRUE(PDT.verify());
285 EXPECT_TRUE(DT.verify());
287 EXPECT_TRUE(PDT.verify());
309 EXPECT_TRUE(DT.verify());
311 EXPECT_TRUE(PDT.verify());
318 EXPECT_TRUE(DT.verify());
320 EXPECT_TRUE(PDT.verify());
339 EXPECT_TRUE(DT.verify());
341 EXPECT_TRUE(PDT.verify());
348 EXPECT_TRUE(DT.verify());
350 EXPECT_TRUE(PDT.verify());
unittests/IR/DominatorTreeTest.cpp 104 EXPECT_TRUE(DT->isReachableFromEntry(BB0));
105 EXPECT_TRUE(DT->isReachableFromEntry(BB1));
106 EXPECT_TRUE(DT->isReachableFromEntry(BB2));
108 EXPECT_TRUE(DT->isReachableFromEntry(BB4));
111 EXPECT_TRUE(DT->dominates(BB0, BB0));
112 EXPECT_TRUE(DT->dominates(BB0, BB1));
113 EXPECT_TRUE(DT->dominates(BB0, BB2));
114 EXPECT_TRUE(DT->dominates(BB0, BB3));
115 EXPECT_TRUE(DT->dominates(BB0, BB4));
118 EXPECT_TRUE(DT->dominates(BB1, BB1));
120 EXPECT_TRUE(DT->dominates(BB1, BB3));
125 EXPECT_TRUE(DT->dominates(BB2, BB2));
126 EXPECT_TRUE(DT->dominates(BB2, BB3));
132 EXPECT_TRUE(DT->dominates(BB3, BB3));
137 EXPECT_TRUE(DT->properlyDominates(BB0, BB1));
138 EXPECT_TRUE(DT->properlyDominates(BB0, BB2));
139 EXPECT_TRUE(DT->properlyDominates(BB0, BB3));
144 EXPECT_TRUE(DT->properlyDominates(BB1, BB3));
149 EXPECT_TRUE(DT->properlyDominates(BB2, BB3));
158 EXPECT_TRUE(DT->dominates(Y1, Y2));
163 EXPECT_TRUE(DT->dominates(Y6, Y6));
164 EXPECT_TRUE(DT->dominates(Y6, Y7));
165 EXPECT_TRUE(DT->dominates(Y7, Y6));
166 EXPECT_TRUE(DT->dominates(Y7, Y7));
169 EXPECT_TRUE(DT->dominates(Y3, Y4));
173 EXPECT_TRUE(DT->dominates(Y2, Y9));
178 EXPECT_TRUE(DT->dominates(Y1, Y6));
179 EXPECT_TRUE(DT->dominates(Y3, Y6));
186 EXPECT_TRUE(DT->dominates(Y1, BB1));
187 EXPECT_TRUE(DT->dominates(Y1, BB2));
188 EXPECT_TRUE(DT->dominates(Y1, BB3));
189 EXPECT_TRUE(DT->dominates(Y1, BB4));
192 EXPECT_TRUE(DT->dominates(Y3, BB1));
194 EXPECT_TRUE(DT->dominates(Y3, BB3));
197 EXPECT_TRUE(DT->dominates(Y6, BB3));
200 EXPECT_TRUE(PDT->dominates(BB0, BB0));
204 EXPECT_TRUE(PDT->dominates(BB4, BB1));
265 EXPECT_TRUE(DT->verify());
270 EXPECT_TRUE(&F.getEntryBlock() == NewEntry);
272 EXPECT_TRUE(DT->verify());
316 EXPECT_TRUE(DT->dominates(Edge_BB0_BB2, BB2));
389 EXPECT_TRUE(DT->verify());
390 EXPECT_TRUE(PDT->verify());
398 EXPECT_TRUE(DT->verify());
399 EXPECT_TRUE(PDT->verify());
483 EXPECT_TRUE(DT->verify());
484 EXPECT_TRUE(PDT->verify());
489 EXPECT_TRUE(DT->verify());
491 EXPECT_TRUE(PDT->verify());
572 EXPECT_TRUE(DT->verify());
573 EXPECT_TRUE(PDT->verify());
585 EXPECT_TRUE(DT->verify());
586 EXPECT_TRUE(PDT->verify());
663 EXPECT_TRUE(DT->getNode(IDFBlocks[0])->getDFSNumIn() <
690 EXPECT_TRUE(DT.verify());
692 EXPECT_TRUE(PDT.verify());
700 EXPECT_TRUE(DT.verify());
702 EXPECT_TRUE(PDT.verify());
716 EXPECT_TRUE(DT.verify());
718 EXPECT_TRUE(PDT.verify());
721 EXPECT_TRUE(LastUpdate);
727 EXPECT_TRUE(DT.verify());
729 EXPECT_TRUE(PDT.verify());
744 EXPECT_TRUE(DT.verify());
746 EXPECT_TRUE(PDT.verify());
754 EXPECT_TRUE(DT.verify());
756 EXPECT_TRUE(PDT.verify());
767 EXPECT_TRUE(PDT.verify());
770 EXPECT_TRUE(LastUpdate);
776 EXPECT_TRUE(PDT.verify());
777 EXPECT_TRUE(PDT.getRoots().size() == 2);
795 EXPECT_TRUE(DT.verify());
797 EXPECT_TRUE(PDT.verify());
805 EXPECT_TRUE(DT.verify());
807 EXPECT_TRUE(PDT.verify());
825 EXPECT_TRUE(DT.verify());
827 EXPECT_TRUE(PDT.verify());
835 EXPECT_TRUE(DT.verify());
837 EXPECT_TRUE(PDT.verify());
852 EXPECT_TRUE(DT.verify());
854 EXPECT_TRUE(PDT.verify());
862 EXPECT_TRUE(DT.verify());
864 EXPECT_TRUE(PDT.verify());
878 EXPECT_TRUE(DT.verify());
880 EXPECT_TRUE(PDT.verify());
888 EXPECT_TRUE(DT.verify());
890 EXPECT_TRUE(PDT.verify());
908 EXPECT_TRUE(DT.verify());
910 EXPECT_TRUE(PDT.verify());
924 EXPECT_TRUE(DT.verify());
925 EXPECT_TRUE(PDT.verify());
946 EXPECT_TRUE(DT.verify());
948 EXPECT_TRUE(PDT.verify());
962 EXPECT_TRUE(DT.verify());
963 EXPECT_TRUE(PDT.verify());
982 EXPECT_TRUE(DT.verify());
989 EXPECT_TRUE(DT.verify());
unittests/IR/FunctionTest.cpp 25 EXPECT_TRUE(F->hasLazyArguments());
29 EXPECT_TRUE(F->hasLazyArguments());
31 EXPECT_TRUE(F->hasLazyArguments());
55 EXPECT_TRUE(F1->hasLazyArguments());
56 EXPECT_TRUE(F2->hasLazyArguments());
63 EXPECT_TRUE(F1->hasLazyArguments());
64 EXPECT_TRUE(F2->hasLazyArguments());
78 EXPECT_TRUE(F1->hasLazyArguments());
103 EXPECT_TRUE(F2->hasLazyArguments());
116 EXPECT_TRUE(F1->hasLazyArguments());
117 EXPECT_TRUE(F2->hasLazyArguments());
130 EXPECT_TRUE(F->getSection() == ".text.test");
131 EXPECT_TRUE(F->hasSection());
136 EXPECT_TRUE(F->getSection() == ".text.test2");
137 EXPECT_TRUE(F->hasSection());
unittests/IR/IRBuilderTest.cpp 91 EXPECT_TRUE(II->hasNoInfs());
103 EXPECT_TRUE(II->hasNoInfs());
115 EXPECT_TRUE(II->hasNoInfs());
121 EXPECT_TRUE(II->hasNoInfs());
359 EXPECT_TRUE(M->getDataLayout().isLegalInteger(32));
393 EXPECT_TRUE(IFMF->hasNoSignedZeros());
394 EXPECT_TRUE(IFMF->hasNoNaNs());
429 EXPECT_TRUE(FAdd->hasNoNaNs());
430 EXPECT_TRUE(FAdd->hasNoInfs());
431 EXPECT_TRUE(FAdd->hasNoSignedZeros());
432 EXPECT_TRUE(FAdd->hasAllowReciprocal());
433 EXPECT_TRUE(FAdd->hasAllowContract());
434 EXPECT_TRUE(FAdd->hasAllowReassoc());
435 EXPECT_TRUE(FAdd->hasApproxFunc());
442 EXPECT_TRUE(Builder.getFastMathFlags().any());
443 EXPECT_TRUE(Builder.getFastMathFlags().all());
446 EXPECT_TRUE(FAdd->hasNoNaNs());
447 EXPECT_TRUE(FAdd->isFast());
451 EXPECT_TRUE(Builder.getFastMathFlags().any());
454 EXPECT_TRUE(FAdd->hasNoNaNs());
455 EXPECT_TRUE(FAdd->isFast());
458 EXPECT_TRUE(Builder.getFastMathFlags().all());
461 EXPECT_TRUE(FDiv->hasAllowReciprocal());
477 EXPECT_TRUE(Builder.getFastMathFlags().any());
478 EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
481 EXPECT_TRUE(FDiv->hasAllowReciprocal());
495 EXPECT_TRUE(Builder.getFastMathFlags().any());
496 EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
499 EXPECT_TRUE(FCmp->hasAllowReciprocal());
514 EXPECT_TRUE(Builder.getFastMathFlags().any());
515 EXPECT_TRUE(Builder.getFastMathFlags().AllowContract);
518 EXPECT_TRUE(FAdd->hasAllowContract());
526 EXPECT_TRUE(FAdd->hasApproxFunc());
527 EXPECT_TRUE(FAdd->hasAllowContract());
536 EXPECT_TRUE(FAdd->hasApproxFunc());
537 EXPECT_TRUE(FAdd->hasAllowContract());
538 EXPECT_TRUE(FAdd->hasAllowReassoc());
559 EXPECT_TRUE(Builder.getFastMathFlags().any());
560 EXPECT_TRUE(Builder.getFastMathFlags().NoNaNs);
561 EXPECT_TRUE(FCall->hasNoNaNs());
564 EXPECT_TRUE(Builder.getFastMathFlags().any());
565 EXPECT_TRUE(Builder.getFastMathFlags().NoNaNs);
566 EXPECT_TRUE(FCall->hasNoNaNs());
579 EXPECT_TRUE(FDiv->hasNoNaNs());
591 EXPECT_TRUE(
593 EXPECT_TRUE(
595 EXPECT_TRUE(
597 EXPECT_TRUE(cast<BinaryOperator>(
601 EXPECT_TRUE(
603 EXPECT_TRUE(
605 EXPECT_TRUE(
607 EXPECT_TRUE(cast<BinaryOperator>(
613 EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWAdd(C, C))
615 EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWSub(C, C))
617 EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWMul(C, C))
619 EXPECT_TRUE(cast<OverflowingBinaryOperator>(
623 EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWAdd(C, C))
625 EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWSub(C, C))
627 EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWMul(C, C))
629 EXPECT_TRUE(cast<OverflowingBinaryOperator>(
650 EXPECT_TRUE(Builder.getFastMathFlags().allowReciprocal());
679 EXPECT_TRUE(!NoErr->getThrownTypes());
686 EXPECT_TRUE(Err->getThrownTypes().get() == Error.get());
709 EXPECT_TRUE(verifyModule(*M));
724 EXPECT_TRUE(SP->isDistinct());
748 EXPECT_TRUE(GSP->isDistinct());
751 EXPECT_TRUE(verifyModule(*M));
765 EXPECT_TRUE(GSP->isArtificial());
791 EXPECT_TRUE(String1a->getType()->getPointerAddressSpace() == 0);
792 EXPECT_TRUE(String1b->getType()->getPointerAddressSpace() == 0);
793 EXPECT_TRUE(String2->getType()->getPointerAddressSpace() == 1);
794 EXPECT_TRUE(String3->getType()->getPointerAddressSpace() == 2);
846 EXPECT_TRUE(verifyModule(*M));
847 EXPECT_TRUE(CU->getImportedEntities().size() == 2);
916 EXPECT_TRUE(verifyModule(*M));
unittests/IR/InstructionsTest.cpp 126 EXPECT_TRUE(b0->isUnconditional());
145 EXPECT_TRUE(b1->isConditional());
221 EXPECT_TRUE(CastInst::isCastable(V8x8Ty, X86MMXTy));
222 EXPECT_TRUE(CastInst::isCastable(X86MMXTy, V8x8Ty));
224 EXPECT_TRUE(CastInst::isCastable(V8x64Ty, V8x8Ty));
225 EXPECT_TRUE(CastInst::isCastable(V8x8Ty, V8x64Ty));
240 EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V2Int64PtrAS1Ty));
241 EXPECT_TRUE(CastInst::isCastable(V2Int32PtrAS1Ty, V2Int32PtrTy));
253 EXPECT_TRUE(CastInst::isBitCastable(Int32PtrTy, Int64PtrTy));
256 EXPECT_TRUE(CastInst::isBitCastable(FloatTy, FloatTy));
257 EXPECT_TRUE(CastInst::isBitCastable(FloatTy, FloatTy));
258 EXPECT_TRUE(CastInst::isBitCastable(FloatTy, Int32Ty));
259 EXPECT_TRUE(CastInst::isBitCastable(Int16Ty, HalfTy));
260 EXPECT_TRUE(CastInst::isBitCastable(Int32Ty, FloatTy));
261 EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty, Int64Ty));
263 EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty, V4Int16Ty));
269 EXPECT_TRUE(CastInst::isBitCastable(V2Int64PtrTy, V2Int32PtrTy));
270 EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrTy, V2Int64PtrTy));
415 EXPECT_TRUE(isa<FPMathOperator>(V1));
534 EXPECT_TRUE(Clone->onlyReadsMemory());
559 EXPECT_TRUE(Clone->hasFnAttr(Attribute::AttrKind::Cold));
562 EXPECT_TRUE(Clone->getOperandBundle("after").hasValue());
591 EXPECT_TRUE(Clone->hasFnAttr(Attribute::AttrKind::Cold));
594 EXPECT_TRUE(Clone->getOperandBundle("after").hasValue());
818 EXPECT_TRUE(ShuffleVectorInst::isIdentityMask(Identity));
821 EXPECT_TRUE(ShuffleVectorInst::isSingleSourceMask(Identity)); // identity is always single source
827 EXPECT_TRUE(ShuffleVectorInst::isSelectMask(Select));
836 EXPECT_TRUE(ShuffleVectorInst::isReverseMask(Reverse));
837 EXPECT_TRUE(ShuffleVectorInst::isSingleSourceMask(Reverse)); // reverse is always single source
845 EXPECT_TRUE(ShuffleVectorInst::isSingleSourceMask(SingleSource));
853 EXPECT_TRUE(ShuffleVectorInst::isSingleSourceMask(ZeroEltSplat)); // 0-splat is always single source
854 EXPECT_TRUE(ShuffleVectorInst::isZeroEltSplatMask(ZeroEltSplat));
863 EXPECT_TRUE(ShuffleVectorInst::isTransposeMask(Transpose));
866 EXPECT_TRUE(ShuffleVectorInst::isIdentityMask(ConstantVector::get({CU, C1, CU, C3})));
867 EXPECT_TRUE(ShuffleVectorInst::isIdentityMask(ConstantVector::get({C4, CU, C6, CU})));
869 EXPECT_TRUE(ShuffleVectorInst::isSelectMask(ConstantVector::get({C4, C1, C6, CU})));
870 EXPECT_TRUE(ShuffleVectorInst::isSelectMask(ConstantVector::get({CU, C1, C6, C3})));
872 EXPECT_TRUE(ShuffleVectorInst::isReverseMask(ConstantVector::get({C7, C6, CU, C4})));
873 EXPECT_TRUE(ShuffleVectorInst::isReverseMask(ConstantVector::get({C3, CU, C1, CU})));
875 EXPECT_TRUE(ShuffleVectorInst::isSingleSourceMask(ConstantVector::get({C7, C5, CU, C7})));
876 EXPECT_TRUE(ShuffleVectorInst::isSingleSourceMask(ConstantVector::get({C3, C0, CU, C3})));
878 EXPECT_TRUE(ShuffleVectorInst::isZeroEltSplatMask(ConstantVector::get({C4, CU, CU, C4})));
879 EXPECT_TRUE(ShuffleVectorInst::isZeroEltSplatMask(ConstantVector::get({CU, C0, CU, C0})));
881 EXPECT_TRUE(ShuffleVectorInst::isTransposeMask(ConstantVector::get({C1, C5, C3, C7})));
882 EXPECT_TRUE(ShuffleVectorInst::isTransposeMask(ConstantVector::get({C1, C3})));
891 EXPECT_TRUE(Id1->isIdentity());
902 EXPECT_TRUE(Id2->isIdentityWithExtract());
911 EXPECT_TRUE(Id3->isIdentityWithExtract());
928 EXPECT_TRUE(Id5->isIdentityWithPadding());
937 EXPECT_TRUE(Id6->isIdentityWithPadding());
966 EXPECT_TRUE(Id9->isConcat());
1045 EXPECT_TRUE(isa<FPMathOperator>(FP));
1056 EXPECT_TRUE(FNeg->hasNoNaNs());
1124 EXPECT_TRUE(isa<Value>(F));
1125 EXPECT_TRUE(isa<Instruction>(F));
1126 EXPECT_TRUE(isa<UnaryInstruction>(F));
1127 EXPECT_TRUE(isa<UnaryOperator>(F));
unittests/IR/LegacyPassManagerTest.cpp 115 EXPECT_TRUE(initialized);
125 EXPECT_TRUE(initialized);
126 EXPECT_TRUE(finalized);
unittests/IR/MDBuilderTest.cpp 39 EXPECT_TRUE(mdconst::hasa<ConstantFP>(Op));
41 EXPECT_TRUE(Val->getType()->isFloatingPointTy());
42 EXPECT_TRUE(Val->isExactlyValue(1.0));
52 EXPECT_TRUE(mdconst::hasa<ConstantInt>(R1->getOperand(0)));
53 EXPECT_TRUE(mdconst::hasa<ConstantInt>(R1->getOperand(1)));
68 EXPECT_TRUE(R0->getNumOperands() == 1 || R0->getOperand(1) == nullptr);
69 EXPECT_TRUE(R1->getNumOperands() == 1 || R1->getOperand(1) == nullptr);
77 EXPECT_TRUE(isa<MDString>(R0->getOperand(0)));
79 EXPECT_TRUE(R0->getNumOperands() == 1 || R0->getOperand(1) == nullptr);
94 EXPECT_TRUE(isa<MDString>(N0->getOperand(0)));
95 EXPECT_TRUE(isa<MDString>(N1->getOperand(0)));
96 EXPECT_TRUE(isa<MDString>(N2->getOperand(0)));
103 EXPECT_TRUE(mdconst::hasa<ConstantInt>(N2->getOperand(2)));
unittests/IR/MetadataTest.cpp 39 EXPECT_TRUE(CRU.hasReplaceableUses());
40 EXPECT_TRUE(CRU.getReplaceableUses());
48 EXPECT_TRUE(CRU.hasReplaceableUses());
49 EXPECT_TRUE(CRU.getReplaceableUses());
469 EXPECT_TRUE(Wrapped2->isDistinct());
517 EXPECT_TRUE(Distinct1->isResolved());
518 EXPECT_TRUE(Distinct2->isDistinct());
531 EXPECT_TRUE(U->isUniqued());
541 EXPECT_TRUE(D->isDistinct());
551 EXPECT_TRUE(T->isTemporary());
562 EXPECT_TRUE(Distinct->isResolved());
594 EXPECT_TRUE(N0->isResolved());
666 EXPECT_TRUE(Temp->isTemporary());
671 EXPECT_TRUE(FirstUniqued->isUniqued());
672 EXPECT_TRUE(FirstUniqued->isResolved());
678 EXPECT_TRUE(Temp->isTemporary());
682 EXPECT_TRUE(Uniqued->isUniqued());
683 EXPECT_TRUE(Uniqued->isResolved());
690 EXPECT_TRUE(Temp->isTemporary());
694 EXPECT_TRUE(Uniqued->isUniqued());
703 EXPECT_TRUE(Uniqued->isResolved());
723 EXPECT_TRUE(Op->isResolved());
724 EXPECT_TRUE(N->isResolved());
779 EXPECT_TRUE(Temp->isTemporary());
784 EXPECT_TRUE(Distinct->isDistinct());
785 EXPECT_TRUE(Distinct->isResolved());
792 EXPECT_TRUE(Temp->isTemporary());
797 EXPECT_TRUE(Distinct->isDistinct());
798 EXPECT_TRUE(Distinct->isResolved());
813 EXPECT_TRUE(U->isUniqued());
825 EXPECT_TRUE(N->isDistinct());
829 EXPECT_TRUE(U->isUniqued());
834 EXPECT_TRUE(U->isUniqued());
840 EXPECT_TRUE(V->isUniqued());
942 EXPECT_TRUE(isa<DILocalScope>(M->getScope()));
954 EXPECT_TRUE(isa<DILocalScope>(M->getScope()));
963 EXPECT_TRUE(L0->isDistinct());
972 EXPECT_TRUE(L->isTemporary());
979 EXPECT_TRUE(L->isTemporary());
981 EXPECT_TRUE(L2->isTemporary());
1752 EXPECT_TRUE(Clone->isDistinct());
2267 EXPECT_TRUE(N->isParameter());
2371 EXPECT_TRUE(DIExpression::get(Context, None));
2487 EXPECT_TRUE(V->getType()->isMetadataTy());
2499 EXPECT_TRUE(V->getType()->isMetadataTy());
2506 EXPECT_TRUE(V3->getType()->isMetadataTy());
2518 EXPECT_TRUE(V->getType()->isMetadataTy());
2533 EXPECT_TRUE(MD->getValue() == GV0.get());
2539 EXPECT_TRUE(MD->getValue() == GV1.get());
2594 EXPECT_TRUE(MD->getValue() == GV0.get());
2600 EXPECT_TRUE(MD->getValue() == GV1.get());
2611 EXPECT_TRUE(MD->getValue() == GV.get());
2615 EXPECT_TRUE(!MD);
2656 EXPECT_TRUE(F->hasMetadata());
2662 EXPECT_TRUE(F->hasMetadata());
2679 EXPECT_TRUE(F->hasMetadata());
2733 EXPECT_TRUE(verifyFunction(*F));
2751 EXPECT_TRUE(Count.hasValue());
2760 EXPECT_TRUE(Count.hasValue());
unittests/IR/ModuleTest.cpp 47 EXPECT_TRUE(std::is_sorted(M.global_begin(), M.global_end(), compare));
71 EXPECT_TRUE(std::equal(RandomStreams[0].begin(), RandomStreams[0].end(),
unittests/IR/PassManagerTest.cpp 191 EXPECT_TRUE(PAC.preserved());
192 EXPECT_TRUE(PAC.preservedSet<AllAnalysesOn<Function>>());
203 EXPECT_TRUE(PAC.preserved());
204 EXPECT_TRUE(PAC.preservedSet<AllAnalysesOn<Function>>());
216 EXPECT_TRUE(PAC.preservedSet<AllAnalysesOn<Function>>());
224 EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>().preserved());
227 EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>().preserved());
228 EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>().preserved());
232 EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>().preserved());
233 EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>().preserved());
239 EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>()
244 EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>()
246 EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>()
251 EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>()
253 EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>()
258 EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>()
260 EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>()
281 EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
285 EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
290 EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
294 EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
299 EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
303 EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
309 EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
313 EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
339 EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
343 EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
349 EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
353 EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
358 EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
362 EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
393 EXPECT_TRUE(PA.getChecker(FakeID).preservedSet<AllAnalysesOn<Function>>());
394 EXPECT_TRUE(PA.getChecker(FakeID).preservedSet<AllAnalysesOn<Module>>());
unittests/IR/PatternMatch.cpp 61 EXPECT_TRUE(m_OneUse(m_Value(V)).match(One));
76 EXPECT_TRUE(
89 EXPECT_TRUE(
102 EXPECT_TRUE(
118 EXPECT_TRUE(
121 EXPECT_TRUE(
125 EXPECT_TRUE(
131 EXPECT_TRUE(
135 EXPECT_TRUE(
138 EXPECT_TRUE(
157 EXPECT_TRUE(
160 EXPECT_TRUE(
170 EXPECT_TRUE(
193 EXPECT_TRUE(
196 EXPECT_TRUE(
199 EXPECT_TRUE(
206 EXPECT_TRUE(
209 EXPECT_TRUE(
219 EXPECT_TRUE(
242 EXPECT_TRUE(
252 EXPECT_TRUE(
255 EXPECT_TRUE(
271 EXPECT_TRUE(
281 EXPECT_TRUE(
284 EXPECT_TRUE(
291 EXPECT_TRUE(
294 EXPECT_TRUE(
297 EXPECT_TRUE(
313 EXPECT_TRUE(
330 EXPECT_TRUE(
333 EXPECT_TRUE(
349 EXPECT_TRUE(
352 EXPECT_TRUE(
362 EXPECT_TRUE(
369 EXPECT_TRUE(
372 EXPECT_TRUE(
375 EXPECT_TRUE(
394 EXPECT_TRUE(
398 EXPECT_TRUE(
404 EXPECT_TRUE(
427 EXPECT_TRUE(
433 EXPECT_TRUE(
437 EXPECT_TRUE(
440 EXPECT_TRUE(
443 EXPECT_TRUE(
453 EXPECT_TRUE(
461 EXPECT_TRUE(m_Add(m_One(), m_Zero()).match(X));
465 EXPECT_TRUE(m_Unless(m_Add(m_Zero(), m_One())).match(X));
467 EXPECT_TRUE(m_c_Add(m_One(), m_Zero()).match(X));
468 EXPECT_TRUE(m_c_Add(m_Zero(), m_One()).match(X));
481 EXPECT_TRUE(m_One().match(One32));
486 EXPECT_TRUE(m_ZExt(m_One()).match(One64Z));
491 EXPECT_TRUE(m_SExt(m_One()).match(One64S));
493 EXPECT_TRUE(m_ZExtOrSelf(m_One()).match(One32));
494 EXPECT_TRUE(m_ZExtOrSelf(m_One()).match(One64Z));
497 EXPECT_TRUE(m_SExtOrSelf(m_One()).match(One32));
499 EXPECT_TRUE(m_SExtOrSelf(m_One()).match(One64S));
502 EXPECT_TRUE(m_ZExtOrSExt(m_One()).match(One64Z));
503 EXPECT_TRUE(m_ZExtOrSExt(m_One()).match(One64S));
505 EXPECT_TRUE(m_ZExtOrSExtOrSelf(m_One()).match(One32));
506 EXPECT_TRUE(m_ZExtOrSExtOrSelf(m_One()).match(One64Z));
507 EXPECT_TRUE(m_ZExtOrSExtOrSelf(m_One()).match(One64S));
514 EXPECT_TRUE(m_Power2().match(C128));
518 EXPECT_TRUE(m_NegatedPower2().match(CNeg128));
523 EXPECT_TRUE(m_Power2().match(CIntMin));
524 EXPECT_TRUE(m_Power2().match(CNegIntMin));
526 EXPECT_TRUE(m_NegatedPower2().match(CIntMin));
527 EXPECT_TRUE(m_NegatedPower2().match(CNegIntMin));
536 EXPECT_TRUE(match(X, m_Deferred(tX)));
541 EXPECT_TRUE(match(X, m_Deferred(tX)));
546 EXPECT_TRUE(match(X, m_Deferred(tX)));
551 EXPECT_TRUE(match(X, m_Deferred(tX)));
557 EXPECT_TRUE(match(IRB.CreateAnd(X, X), m_And(m_Value(tX), m_Deferred(tX))));
568 EXPECT_TRUE(match(
587 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
593 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
616 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
624 EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR))
637 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
643 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
667 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
675 EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR))
688 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
694 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
717 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
725 EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR))
738 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
744 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
767 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
775 EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR))
786 EXPECT_TRUE(
791 EXPECT_TRUE(
796 EXPECT_TRUE(
801 EXPECT_TRUE(m_NSWShl(m_Value(MatchL), m_Value(MatchR)).match(
806 EXPECT_TRUE(
811 EXPECT_TRUE(
816 EXPECT_TRUE(
821 EXPECT_TRUE(m_NUWShl(m_Value(MatchL), m_Value(MatchR)).match(
868 EXPECT_TRUE(m_Load(m_Value(MatchLoad)).match(LoadInst));
871 EXPECT_TRUE(m_Load(m_Specific(Alloca)).match(LoadInst));
875 EXPECT_TRUE(m_Store(m_Value(MatchStoreVal), m_Value(MatchStorePointer))
883 EXPECT_TRUE(m_Store(m_SpecificInt(42), m_Specific(Alloca))
942 EXPECT_TRUE(match(VI1, m_InsertElement(m_Value(), m_Value(), m_Value())));
943 EXPECT_TRUE(
945 EXPECT_TRUE(
947 EXPECT_TRUE(
949 EXPECT_TRUE(match(VI2, m_InsertElement(m_Value(), m_Value(), m_Value())));
955 EXPECT_TRUE(match(VI3, m_InsertElement(m_Value(A), m_Value(B), m_Value(C))));
956 EXPECT_TRUE(A == VI1);
957 EXPECT_TRUE(B == Val2);
958 EXPECT_TRUE(isa<ConstantInt>(C));
962 EXPECT_TRUE(match(EX1, m_ExtractElement(m_Value(A), m_Value(B))));
963 EXPECT_TRUE(A == VI4);
964 EXPECT_TRUE(B == Val);
967 EXPECT_TRUE(match(EX2, m_ExtractElement(m_Value(), m_ConstantInt())));
968 EXPECT_TRUE(match(EX3, m_ExtractElement(m_Constant(), m_ConstantInt())));
971 EXPECT_TRUE(match(SI1, m_ShuffleVector(m_Value(), m_Undef(), m_Zero())));
972 EXPECT_TRUE(match(SI2, m_ShuffleVector(m_Value(A), m_Value(B), m_Value(C))));
973 EXPECT_TRUE(A == VI3);
974 EXPECT_TRUE(B == VI4);
975 EXPECT_TRUE(C == IdxVec);
979 EXPECT_TRUE(match(
989 EXPECT_TRUE(match(
993 EXPECT_TRUE(match(
996 EXPECT_TRUE(A == Val);
1014 EXPECT_TRUE(match(ScalarUndef, m_Undef()));
1015 EXPECT_TRUE(match(VectorUndef, m_Undef()));
1022 EXPECT_TRUE(match(ScalarZero, m_Zero()));
1023 EXPECT_TRUE(match(VectorZero, m_Zero()));
1024 EXPECT_TRUE(match(VectorZeroUndef, m_Zero()));
1042 EXPECT_TRUE(match(ScalarUndef, m_Undef()));
1043 EXPECT_TRUE(match(VectorUndef, m_Undef()));
1050 EXPECT_TRUE(match(ScalarZero, m_AnyZeroFP()));
1051 EXPECT_TRUE(match(VectorZero, m_AnyZeroFP()));
1052 EXPECT_TRUE(match(VectorZeroUndef, m_AnyZeroFP()));
1067 EXPECT_TRUE(match(V, m_FNeg(m_Value(Match))));
1071 EXPECT_TRUE(match(V1, m_FNeg(m_Value(Match))));
1077 EXPECT_TRUE(match(V2, m_FNeg(m_Value(Match))));
1089 EXPECT_TRUE(match(Br1, m_Br(m_Value(), m_BasicBlock(), m_BasicBlock())));
1092 EXPECT_TRUE(match(Br1, m_Br(m_Value(), m_BasicBlock(A), m_BasicBlock(B))));
1102 EXPECT_TRUE(
1109 EXPECT_TRUE(match(Br2, m_Br(m_Value(), m_BasicBlock(A), m_Deferred(A))));
1133 EXPECT_TRUE(m_ICmp(MatchPred, m_Value(MatchL), m_Value(MatchR))
unittests/IR/TimePassesTest.cpp 87 EXPECT_TRUE(TimePassesStr.str().contains("report"));
88 EXPECT_TRUE(TimePassesStr.str().contains("Pass1"));
89 EXPECT_TRUE(TimePassesStr.str().contains("Pass2"));
96 EXPECT_TRUE(TimePassesStr.empty());
108 EXPECT_TRUE(TimePassesStr.str().contains("report"));
110 EXPECT_TRUE(TimePassesStr.str().contains("Pass2"));
145 EXPECT_TRUE(TimePassesStr.str().contains("report"));
146 EXPECT_TRUE(TimePassesStr.str().contains("Pass1"));
147 EXPECT_TRUE(TimePassesStr.str().contains("Pass2"));
153 EXPECT_TRUE(TimePassesStr.empty());
164 EXPECT_TRUE(TimePassesStr.str().contains("report"));
166 EXPECT_TRUE(TimePassesStr.str().contains("Pass2"));
unittests/IR/TypesTest.cpp 25 EXPECT_TRUE(Struct->getName().empty());
34 EXPECT_TRUE(Foo->isLayoutIdentical(Bar));
unittests/IR/UserTest.cpp 72 EXPECT_TRUE(P.value_op_begin() == P.value_op_begin());
74 EXPECT_TRUE(P.value_op_begin() != P.value_op_end());
76 EXPECT_TRUE(P.value_op_begin() < P.value_op_end());
78 EXPECT_TRUE(P.value_op_end() > P.value_op_begin());
80 EXPECT_TRUE(P.value_op_begin() <= P.value_op_begin());
82 EXPECT_TRUE(P.value_op_begin() >= P.value_op_begin());
88 EXPECT_TRUE(IP->value_op_begin() == IP->value_op_begin());
90 EXPECT_TRUE(IP->value_op_begin() != IP->value_op_end());
92 EXPECT_TRUE(IP->value_op_begin() < IP->value_op_end());
94 EXPECT_TRUE(IP->value_op_end() > IP->value_op_begin());
96 EXPECT_TRUE(IP->value_op_begin() <= IP->value_op_begin());
98 EXPECT_TRUE(IP->value_op_begin() >= IP->value_op_begin());
141 EXPECT_TRUE(TestF->user_empty());
unittests/IR/ValueHandleTest.cpp 70 EXPECT_TRUE(BitcastWVH == BitcastWVH);
71 EXPECT_TRUE(BitcastV.get() == BitcastWVH);
72 EXPECT_TRUE(BitcastWVH == BitcastV.get());
75 EXPECT_TRUE(BitcastWVH != ConstantWVH);
76 EXPECT_TRUE(BitcastV.get() != ConstantWVH);
77 EXPECT_TRUE(BitcastWVH != ConstantV);
148 EXPECT_TRUE(BitcastAVH == BitcastAVH);
149 EXPECT_TRUE(BitcastV.get() == BitcastAVH);
150 EXPECT_TRUE(BitcastAVH == BitcastV.get());
153 EXPECT_TRUE(BitcastAVH != ConstantAVH);
154 EXPECT_TRUE(BitcastV.get() != ConstantAVH);
155 EXPECT_TRUE(BitcastAVH != ConstantV);
225 EXPECT_TRUE(BitcastCVH == BitcastCVH);
226 EXPECT_TRUE(BitcastV.get() == BitcastCVH);
227 EXPECT_TRUE(BitcastCVH == BitcastV.get());
230 EXPECT_TRUE(BitcastCVH != ConstantCVH);
231 EXPECT_TRUE(BitcastV.get() != ConstantCVH);
232 EXPECT_TRUE(BitcastCVH != ConstantV);
459 EXPECT_TRUE(BitcastVH == BitcastVH);
460 EXPECT_TRUE(BitcastV.get() == BitcastVH);
461 EXPECT_TRUE(BitcastVH == BitcastV.get());
464 EXPECT_TRUE(BitcastVH != ConstantVH);
465 EXPECT_TRUE(BitcastV.get() != ConstantVH);
466 EXPECT_TRUE(BitcastVH != ConstantV);
491 EXPECT_TRUE(DenseMapInfo<PoisoningVH<Value>>::isEqual(VH, BitcastV.get()));
unittests/IR/ValueMapTest.cpp 65 EXPECT_TRUE(VM.empty());
75 EXPECT_TRUE(VM.find(this->AddV.get()) == VM.end());
84 EXPECT_TRUE(CVM.find(this->AddV.get()) == CVM.end());
91 EXPECT_TRUE(InsertResult1.second);
207 EXPECT_TRUE(CalledRAUW);
208 EXPECT_TRUE(CalledDeleted);
unittests/IR/ValueTest.cpp 42 EXPECT_TRUE(std::next(F->arg_begin())->isUsedInBasicBlock(&F->front()));
43 EXPECT_TRUE(F->arg_begin()->isUsedInBasicBlock(&F->front()));
63 EXPECT_TRUE(Value::MaximumAlignment == 536870912U);
unittests/IR/VectorTypesTest.cpp 228 EXPECT_TRUE(ScV2I32Len.isScalable());
unittests/IR/VerifierTest.cpp 45 EXPECT_TRUE(verifyFunction(*F));
59 EXPECT_TRUE(verifyModule(M, &ErrorOS));
60 EXPECT_TRUE(StringRef(ErrorOS.str()).startswith(
90 EXPECT_TRUE(verifyModule(M2, &ErrorOS));
91 EXPECT_TRUE(StringRef(ErrorOS.str())
105 EXPECT_TRUE(verifyModule(M1, &ErrorOS));
106 EXPECT_TRUE(StringRef(ErrorOS.str()).equals(
114 EXPECT_TRUE(verifyModule(M3, &ErrorOS));
115 EXPECT_TRUE(StringRef(ErrorOS.str()).startswith(
130 EXPECT_TRUE(verifyModule(M, &ErrorOS));
131 EXPECT_TRUE(
144 EXPECT_TRUE(verifyModule(M, &ErrorOS));
145 EXPECT_TRUE(
164 EXPECT_TRUE(verifyModule(M));
189 EXPECT_TRUE(verifyModule(M));
unittests/LineEditor/LineEditor.cpp 50 EXPECT_TRUE(Buffer.empty());
unittests/Linker/LinkModulesTest.cpp 75 EXPECT_TRUE(false);
272 EXPECT_TRUE(M0->isDistinct());
273 EXPECT_TRUE(M1->isDistinct());
274 EXPECT_TRUE(M2->isDistinct());
275 EXPECT_TRUE(M3->isDistinct());
276 EXPECT_TRUE(M4->isUniqued());
300 EXPECT_TRUE(M0->isDistinct());
301 EXPECT_TRUE(M1->isDistinct());
302 EXPECT_TRUE(M2->isDistinct());
303 EXPECT_TRUE(M3->isDistinct());
304 EXPECT_TRUE(M4->isUniqued());
unittests/MI/LiveIntervalTest.cpp 89 EXPECT_TRUE(MF.verify(this));
unittests/Option/OptionParsingTest.cpp 73 EXPECT_TRUE(AL.hasArg(OPT_A));
74 EXPECT_TRUE(AL.hasArg(OPT_B));
75 EXPECT_TRUE(AL.hasArg(OPT_C));
76 EXPECT_TRUE(AL.hasArg(OPT_D));
77 EXPECT_TRUE(AL.hasArg(OPT_E));
78 EXPECT_TRUE(AL.hasArg(OPT_F));
79 EXPECT_TRUE(AL.hasArg(OPT_G));
122 EXPECT_TRUE(AL.hasArg(OPT_A));
123 EXPECT_TRUE(AL.hasArg(OPT_C));
130 EXPECT_TRUE(AL.hasArg(OPT_B));
132 EXPECT_TRUE(AL.hasArg(OPT_SLASH_C));
136 EXPECT_TRUE(AL.hasArg(OPT_SLASH_C));
137 EXPECT_TRUE(AL.hasArg(OPT_C));
148 EXPECT_TRUE(AL.hasArg(OPT_H));
157 EXPECT_TRUE(AL.hasArg(OPT_B));
168 EXPECT_TRUE(AL.hasArg(OPT_A));
169 EXPECT_TRUE(AL.hasArg(OPT_B));
188 EXPECT_TRUE(AL.hasArg(OPT_A));
189 EXPECT_TRUE(AL.hasArg(OPT_Slurp));
200 EXPECT_TRUE(AL.hasArg(OPT_A));
202 EXPECT_TRUE(AL.hasArg(OPT_Slurp));
215 EXPECT_TRUE(AL.hasArg(OPT_A));
216 EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
226 EXPECT_TRUE(AL.hasArg(OPT_A));
227 EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
238 EXPECT_TRUE(AL.hasArg(OPT_A));
239 EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
252 EXPECT_TRUE(AL.hasArg(OPT_A));
253 EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
268 EXPECT_TRUE(AL.hasArg(OPT_B));
unittests/ProfileData/CoverageMappingTest.cpp 335 EXPECT_TRUE(ErrorEquals(coveragemap_error::malformed, loadCoverageMapping()));
unittests/ProfileData/InstrProfTest.cpp 886 EXPECT_TRUE(ErrorEquals(instrprof_error::malformed, Symtab.addFuncName("")));
unittests/Remarks/BitstreamRemarksParsingTest.cpp 31 EXPECT_TRUE(*MaybeParser != nullptr);
37 EXPECT_TRUE(*Remark != nullptr); // At least one remark.
42 EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
43 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
61 EXPECT_TRUE(*MaybeBSParser != nullptr);
67 EXPECT_TRUE(*BSRemark != nullptr); // At least one remark.
72 EXPECT_TRUE(BSE.isA<remarks::EndOfFileError>());
73 EXPECT_TRUE(errorToBool(std::move(BSE))); // Check for parsing errors.
162 EXPECT_TRUE(*MaybeParser != nullptr);
168 EXPECT_TRUE(*MaybeRemark != nullptr); // At least one remark.
175 EXPECT_TRUE(Remark.Loc);
180 EXPECT_TRUE(Remark.Hotness);
200 EXPECT_TRUE(Arg.Loc);
221 EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
222 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
329 EXPECT_TRUE(*MaybeBSParser != nullptr);
unittests/Remarks/RemarksStrTabParsingTest.cpp 28 EXPECT_TRUE(static_cast<bool>(Result));
31 EXPECT_TRUE(static_cast<bool>(Result));
34 EXPECT_TRUE(static_cast<bool>(Result));
37 EXPECT_TRUE(static_cast<bool>(Result));
unittests/Remarks/YAMLRemarksParsingTest.cpp 20 EXPECT_TRUE(*MaybeParser != nullptr);
25 EXPECT_TRUE(*Remark != nullptr); // At least one remark.
28 EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
29 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
36 EXPECT_TRUE(*MaybeParser != nullptr);
41 EXPECT_TRUE(*Remark != nullptr); // At least one remark.
44 EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
45 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
53 EXPECT_TRUE(*MaybeParser != nullptr);
90 EXPECT_TRUE(StringRef(Stream.str()).contains(StringRef(Error)));
95 EXPECT_TRUE(parseExpectError("\n\n", "document root is not of mapping type."));
99 EXPECT_TRUE(
178 EXPECT_TRUE(parseExpectError("\n"
186 EXPECT_TRUE(parseExpectError("\n"
193 EXPECT_TRUE(parseExpectError("\n"
200 EXPECT_TRUE(parseExpectError("\n"
207 EXPECT_TRUE(parseExpectError("\n"
216 EXPECT_TRUE(parseExpectError("\n"
225 EXPECT_TRUE(parseExpectError("\n"
237 EXPECT_TRUE(parseExpectError("\n"
246 EXPECT_TRUE(parseExpectError("\n"
255 EXPECT_TRUE(parseExpectError("\n"
264 EXPECT_TRUE(parseExpectError("\n"
273 EXPECT_TRUE(parseExpectError("\n"
281 EXPECT_TRUE(parseExpectError("\n"
290 EXPECT_TRUE(parseExpectError("\n"
296 EXPECT_TRUE(parseExpectError("\n"
304 EXPECT_TRUE(parseExpectError("\n"
313 EXPECT_TRUE(parseExpectError("\n"
322 EXPECT_TRUE(parseExpectError("\n"
331 EXPECT_TRUE(parseExpectError("\n"
343 EXPECT_TRUE(parseExpectError("\n"
355 EXPECT_TRUE(parseExpectError("\n"
367 EXPECT_TRUE(parseExpectError("\n"
404 EXPECT_TRUE(*MaybeParser != nullptr);
410 EXPECT_TRUE(*MaybeRemark != nullptr); // At least one remark.
417 EXPECT_TRUE(Remark.Loc);
422 EXPECT_TRUE(Remark.Hotness);
442 EXPECT_TRUE(Arg.Loc);
463 EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
464 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
576 EXPECT_TRUE(*MaybeParser != nullptr);
582 EXPECT_TRUE(*MaybeRemark != nullptr); // At least one remark.
589 EXPECT_TRUE(Remark.Loc);
594 EXPECT_TRUE(Remark.Hotness);
614 EXPECT_TRUE(Arg.Loc);
635 EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
636 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
652 EXPECT_TRUE(*MaybeParser != nullptr);
662 EXPECT_TRUE(
unittests/Support/ARMAttributeParser.cpp 48 EXPECT_TRUE(testTagString(6, "Tag_CPU_arch"));
50 EXPECT_TRUE(testBuildAttr(6, 0, ARMBuildAttrs::CPU_arch,
52 EXPECT_TRUE(testBuildAttr(6, 1, ARMBuildAttrs::CPU_arch,
54 EXPECT_TRUE(testBuildAttr(6, 2, ARMBuildAttrs::CPU_arch,
56 EXPECT_TRUE(testBuildAttr(6, 3, ARMBuildAttrs::CPU_arch,
58 EXPECT_TRUE(testBuildAttr(6, 4, ARMBuildAttrs::CPU_arch,
60 EXPECT_TRUE(testBuildAttr(6, 5, ARMBuildAttrs::CPU_arch,
62 EXPECT_TRUE(testBuildAttr(6, 6, ARMBuildAttrs::CPU_arch,
64 EXPECT_TRUE(testBuildAttr(6, 7, ARMBuildAttrs::CPU_arch,
66 EXPECT_TRUE(testBuildAttr(6, 8, ARMBuildAttrs::CPU_arch,
68 EXPECT_TRUE(testBuildAttr(6, 9, ARMBuildAttrs::CPU_arch,
70 EXPECT_TRUE(testBuildAttr(6, 10, ARMBuildAttrs::CPU_arch,
72 EXPECT_TRUE(testBuildAttr(6, 11, ARMBuildAttrs::CPU_arch,
74 EXPECT_TRUE(testBuildAttr(6, 12, ARMBuildAttrs::CPU_arch,
76 EXPECT_TRUE(testBuildAttr(6, 13, ARMBuildAttrs::CPU_arch,
78 EXPECT_TRUE(testBuildAttr(6, 14, ARMBuildAttrs::CPU_arch,
80 EXPECT_TRUE(testBuildAttr(6, 15, ARMBuildAttrs::CPU_arch,
82 EXPECT_TRUE(testBuildAttr(6, 16, ARMBuildAttrs::CPU_arch,
84 EXPECT_TRUE(testBuildAttr(6, 17, ARMBuildAttrs::CPU_arch,
86 EXPECT_TRUE(testBuildAttr(6, 21, ARMBuildAttrs::CPU_arch,
91 EXPECT_TRUE(testTagString(7, "Tag_CPU_arch_profile"));
92 EXPECT_TRUE(testBuildAttr(7, 'A', ARMBuildAttrs::CPU_arch_profile,
94 EXPECT_TRUE(testBuildAttr(7, 'R', ARMBuildAttrs::CPU_arch_profile,
96 EXPECT_TRUE(testBuildAttr(7, 'M', ARMBuildAttrs::CPU_arch_profile,
98 EXPECT_TRUE(testBuildAttr(7, 'S', ARMBuildAttrs::CPU_arch_profile,
103 EXPECT_TRUE(testTagString(8, "Tag_ARM_ISA_use"));
104 EXPECT_TRUE(testBuildAttr(8, 0, ARMBuildAttrs::ARM_ISA_use,
106 EXPECT_TRUE(testBuildAttr(8, 1, ARMBuildAttrs::ARM_ISA_use,
111 EXPECT_TRUE(testTagString(9, "Tag_THUMB_ISA_use"));
112 EXPECT_TRUE(testBuildAttr(9, 0, ARMBuildAttrs::THUMB_ISA_use,
114 EXPECT_TRUE(testBuildAttr(9, 1, ARMBuildAttrs::THUMB_ISA_use,
119 EXPECT_TRUE(testTagString(10, "Tag_FP_arch"));
120 EXPECT_TRUE(testBuildAttr(10, 0, ARMBuildAttrs::FP_arch,
122 EXPECT_TRUE(testBuildAttr(10, 1, ARMBuildAttrs::FP_arch,
124 EXPECT_TRUE(testBuildAttr(10, 2, ARMBuildAttrs::FP_arch,
126 EXPECT_TRUE(testBuildAttr(10, 3, ARMBuildAttrs::FP_arch,
128 EXPECT_TRUE(testBuildAttr(10, 4, ARMBuildAttrs::FP_arch,
130 EXPECT_TRUE(testBuildAttr(10, 5, ARMBuildAttrs::FP_arch,
132 EXPECT_TRUE(testBuildAttr(10, 6, ARMBuildAttrs::FP_arch,
134 EXPECT_TRUE(testBuildAttr(10, 7, ARMBuildAttrs::FP_arch,
136 EXPECT_TRUE(testBuildAttr(10, 8, ARMBuildAttrs::FP_arch,
141 EXPECT_TRUE(testTagString(11, "Tag_WMMX_arch"));
142 EXPECT_TRUE(testBuildAttr(11, 0, ARMBuildAttrs::WMMX_arch,
144 EXPECT_TRUE(testBuildAttr(11, 1, ARMBuildAttrs::WMMX_arch,
146 EXPECT_TRUE(testBuildAttr(11, 2, ARMBuildAttrs::WMMX_arch,
151 EXPECT_TRUE(testTagString(12, "Tag_Advanced_SIMD_arch"));
152 EXPECT_TRUE(testBuildAttr(12, 0, ARMBuildAttrs::Advanced_SIMD_arch,
154 EXPECT_TRUE(testBuildAttr(12, 1, ARMBuildAttrs::Advanced_SIMD_arch,
156 EXPECT_TRUE(testBuildAttr(12, 2, ARMBuildAttrs::Advanced_SIMD_arch,
158 EXPECT_TRUE(testBuildAttr(12, 3, ARMBuildAttrs::Advanced_SIMD_arch,
160 EXPECT_TRUE(testBuildAttr(12, 4, ARMBuildAttrs::Advanced_SIMD_arch,
165 EXPECT_TRUE(testTagString(36, "Tag_FP_HP_extension"));
166 EXPECT_TRUE(testBuildAttr(36, 0, ARMBuildAttrs::FP_HP_extension,
168 EXPECT_TRUE(testBuildAttr(36, 1, ARMBuildAttrs::FP_HP_extension,
173 EXPECT_TRUE(testTagString(48, "Tag_MVE_arch"));
174 EXPECT_TRUE(testBuildAttr(48, 0, ARMBuildAttrs::MVE_arch,
176 EXPECT_TRUE(testBuildAttr(48, 1, ARMBuildAttrs::MVE_arch,
178 EXPECT_TRUE(testBuildAttr(48, 2, ARMBuildAttrs::MVE_arch,
183 EXPECT_TRUE(testTagString(34, "Tag_CPU_unaligned_access"));
184 EXPECT_TRUE(testBuildAttr(34, 0, ARMBuildAttrs::CPU_unaligned_access,
186 EXPECT_TRUE(testBuildAttr(34, 1, ARMBuildAttrs::CPU_unaligned_access,
191 EXPECT_TRUE(testTagString(66, "Tag_T2EE_use"));
192 EXPECT_TRUE(testBuildAttr(66, 0, ARMBuildAttrs::T2EE_use,
194 EXPECT_TRUE(testBuildAttr(66, 1, ARMBuildAttrs::T2EE_use,
199 EXPECT_TRUE(testTagString(68, "Tag_Virtualization_use"));
200 EXPECT_TRUE(testBuildAttr(68, 0, ARMBuildAttrs::Virtualization_use,
202 EXPECT_TRUE(testBuildAttr(68, 1, ARMBuildAttrs::Virtualization_use,
204 EXPECT_TRUE(testBuildAttr(68, 2, ARMBuildAttrs::Virtualization_use,
206 EXPECT_TRUE(testBuildAttr(68, 3, ARMBuildAttrs::Virtualization_use,
211 EXPECT_TRUE(testTagString(42, "Tag_MPextension_use"));
212 EXPECT_TRUE(testBuildAttr(42, 0, ARMBuildAttrs::MPextension_use,
214 EXPECT_TRUE(testBuildAttr(42, 1, ARMBuildAttrs::MPextension_use,
219 EXPECT_TRUE(testTagString(44, "Tag_DIV_use"));
220 EXPECT_TRUE(testBuildAttr(44, 0, ARMBuildAttrs::DIV_use,
222 EXPECT_TRUE(testBuildAttr(44, 1, ARMBuildAttrs::DIV_use,
224 EXPECT_TRUE(testBuildAttr(44, 2, ARMBuildAttrs::DIV_use,
229 EXPECT_TRUE(testTagString(13, "Tag_PCS_config"));
230 EXPECT_TRUE(testBuildAttr(13, 0, ARMBuildAttrs::PCS_config, 0));
231 EXPECT_TRUE(testBuildAttr(13, 1, ARMBuildAttrs::PCS_config, 1));
232 EXPECT_TRUE(testBuildAttr(13, 2, ARMBuildAttrs::PCS_config, 2));
233 EXPECT_TRUE(testBuildAttr(13, 3, ARMBuildAttrs::PCS_config, 3));
234 EXPECT_TRUE(testBuildAttr(13, 4, ARMBuildAttrs::PCS_config, 4));
235 EXPECT_TRUE(testBuildAttr(13, 5, ARMBuildAttrs::PCS_config, 5));
236 EXPECT_TRUE(testBuildAttr(13, 6, ARMBuildAttrs::PCS_config, 6));
237 EXPECT_TRUE(testBuildAttr(13, 7, ARMBuildAttrs::PCS_config, 7));
241 EXPECT_TRUE(testTagString(14, "Tag_ABI_PCS_R9_use"));
242 EXPECT_TRUE(testBuildAttr(14, 0, ARMBuildAttrs::ABI_PCS_R9_use,
244 EXPECT_TRUE(testBuildAttr(14, 1, ARMBuildAttrs::ABI_PCS_R9_use,
246 EXPECT_TRUE(testBuildAttr(14, 2, ARMBuildAttrs::ABI_PCS_R9_use,
248 EXPECT_TRUE(testBuildAttr(14, 3, ARMBuildAttrs::ABI_PCS_R9_use,
253 EXPECT_TRUE(testTagString(15, "Tag_ABI_PCS_RW_data"));
254 EXPECT_TRUE(testBuildAttr(15, 0, ARMBuildAttrs::ABI_PCS_RW_data,
256 EXPECT_TRUE(testBuildAttr(15, 1, ARMBuildAttrs::ABI_PCS_RW_data,
258 EXPECT_TRUE(testBuildAttr(15, 2, ARMBuildAttrs::ABI_PCS_RW_data,
260 EXPECT_TRUE(testBuildAttr(15, 3, ARMBuildAttrs::ABI_PCS_RW_data,
265 EXPECT_TRUE(testTagString(16, "Tag_ABI_PCS_RO_data"));
266 EXPECT_TRUE(testBuildAttr(16, 0, ARMBuildAttrs::ABI_PCS_RO_data,
268 EXPECT_TRUE(testBuildAttr(16, 1, ARMBuildAttrs::ABI_PCS_RO_data,
270 EXPECT_TRUE(testBuildAttr(16, 2, ARMBuildAttrs::ABI_PCS_RO_data,
275 EXPECT_TRUE(testTagString(17, "Tag_ABI_PCS_GOT_use"));
276 EXPECT_TRUE(testBuildAttr(17, 0, ARMBuildAttrs::ABI_PCS_GOT_use,
278 EXPECT_TRUE(testBuildAttr(17, 1, ARMBuildAttrs::ABI_PCS_GOT_use,
280 EXPECT_TRUE(testBuildAttr(17, 2, ARMBuildAttrs::ABI_PCS_GOT_use,
285 EXPECT_TRUE(testTagString(18, "Tag_ABI_PCS_wchar_t"));
286 EXPECT_TRUE(testBuildAttr(18, 0, ARMBuildAttrs::ABI_PCS_wchar_t,
288 EXPECT_TRUE(testBuildAttr(18, 2, ARMBuildAttrs::ABI_PCS_wchar_t,
290 EXPECT_TRUE(testBuildAttr(18, 4, ARMBuildAttrs::ABI_PCS_wchar_t,
295 EXPECT_TRUE(testTagString(26, "Tag_ABI_enum_size"));
296 EXPECT_TRUE(testBuildAttr(26, 0, ARMBuildAttrs::ABI_enum_size,
298 EXPECT_TRUE(testBuildAttr(26, 1, ARMBuildAttrs::ABI_enum_size,
300 EXPECT_TRUE(testBuildAttr(26, 2, ARMBuildAttrs::ABI_enum_size,
302 EXPECT_TRUE(testBuildAttr(26, 3, ARMBuildAttrs::ABI_enum_size,
307 EXPECT_TRUE(testTagString(24, "Tag_ABI_align_needed"));
308 EXPECT_TRUE(testBuildAttr(24, 0, ARMBuildAttrs::ABI_align_needed,
310 EXPECT_TRUE(testBuildAttr(24, 1, ARMBuildAttrs::ABI_align_needed,
312 EXPECT_TRUE(testBuildAttr(24, 2, ARMBuildAttrs::ABI_align_needed,
314 EXPECT_TRUE(testBuildAttr(24, 3, ARMBuildAttrs::ABI_align_needed,
319 EXPECT_TRUE(testTagString(25, "Tag_ABI_align_preserved"));
320 EXPECT_TRUE(testBuildAttr(25, 0, ARMBuildAttrs::ABI_align_preserved,
322 EXPECT_TRUE(testBuildAttr(25, 1, ARMBuildAttrs::ABI_align_preserved,
324 EXPECT_TRUE(testBuildAttr(25, 2, ARMBuildAttrs::ABI_align_preserved,
326 EXPECT_TRUE(testBuildAttr(25, 3, ARMBuildAttrs::ABI_align_preserved,
331 EXPECT_TRUE(testTagString(19, "Tag_ABI_FP_rounding"));
332 EXPECT_TRUE(testBuildAttr(19, 0, ARMBuildAttrs::ABI_FP_rounding, 0));
333 EXPECT_TRUE(testBuildAttr(19, 1, ARMBuildAttrs::ABI_FP_rounding, 1));
337 EXPECT_TRUE(testTagString(20, "Tag_ABI_FP_denormal"));
338 EXPECT_TRUE(testBuildAttr(20, 0, ARMBuildAttrs::ABI_FP_denormal,
340 EXPECT_TRUE(testBuildAttr(20, 1, ARMBuildAttrs::ABI_FP_denormal,
342 EXPECT_TRUE(testBuildAttr(20, 2, ARMBuildAttrs::ABI_FP_denormal,
347 EXPECT_TRUE(testTagString(21, "Tag_ABI_FP_exceptions"));
348 EXPECT_TRUE(testBuildAttr(21, 0, ARMBuildAttrs::ABI_FP_exceptions, 0));
349 EXPECT_TRUE(testBuildAttr(21, 1, ARMBuildAttrs::ABI_FP_exceptions, 1));
353 EXPECT_TRUE(testTagString(22, "Tag_ABI_FP_user_exceptions"));
354 EXPECT_TRUE(testBuildAttr(22, 0, ARMBuildAttrs::ABI_FP_user_exceptions, 0));
355 EXPECT_TRUE(testBuildAttr(22, 1, ARMBuildAttrs::ABI_FP_user_exceptions, 1));
359 EXPECT_TRUE(testTagString(23, "Tag_ABI_FP_number_model"));
360 EXPECT_TRUE(testBuildAttr(23, 0, ARMBuildAttrs::ABI_FP_number_model,
362 EXPECT_TRUE(testBuildAttr(23, 1, ARMBuildAttrs::ABI_FP_number_model,
364 EXPECT_TRUE(testBuildAttr(23, 2, ARMBuildAttrs::ABI_FP_number_model,
366 EXPECT_TRUE(testBuildAttr(23, 3, ARMBuildAttrs::ABI_FP_number_model,
371 EXPECT_TRUE(testTagString(38, "Tag_ABI_FP_16bit_format"));
372 EXPECT_TRUE(testBuildAttr(38, 0, ARMBuildAttrs::ABI_FP_16bit_format,
374 EXPECT_TRUE(testBuildAttr(38, 1, ARMBuildAttrs::ABI_FP_16bit_format,
376 EXPECT_TRUE(testBuildAttr(38, 2, ARMBuildAttrs::ABI_FP_16bit_format,
381 EXPECT_TRUE(testTagString(27, "Tag_ABI_HardFP_use"));
382 EXPECT_TRUE(testBuildAttr(27, 0, ARMBuildAttrs::ABI_HardFP_use,
384 EXPECT_TRUE(testBuildAttr(27, 1, ARMBuildAttrs::ABI_HardFP_use,
386 EXPECT_TRUE(testBuildAttr(27, 2, ARMBuildAttrs::ABI_HardFP_use, 2));
390 EXPECT_TRUE(testTagString(28, "Tag_ABI_VFP_args"));
391 EXPECT_TRUE(testBuildAttr(28, 0, ARMBuildAttrs::ABI_VFP_args,
393 EXPECT_TRUE(testBuildAttr(28, 1, ARMBuildAttrs::ABI_VFP_args,
395 EXPECT_TRUE(testBuildAttr(28, 2, ARMBuildAttrs::ABI_VFP_args, 2));
396 EXPECT_TRUE(testBuildAttr(28, 3, ARMBuildAttrs::ABI_VFP_args, 3));
400 EXPECT_TRUE(testTagString(29, "Tag_ABI_WMMX_args"));
401 EXPECT_TRUE(testBuildAttr(29, 0, ARMBuildAttrs::ABI_WMMX_args, 0));
402 EXPECT_TRUE(testBuildAttr(29, 1, ARMBuildAttrs::ABI_WMMX_args, 1));
403 EXPECT_TRUE(testBuildAttr(29, 2, ARMBuildAttrs::ABI_WMMX_args, 2));
unittests/Support/AlignmentTest.cpp 70 EXPECT_TRUE(MaybeAlign(1));
71 EXPECT_TRUE(MaybeAlign(1).hasValue());
unittests/Support/BranchProbabilityTest.cpp 33 EXPECT_TRUE(BP(1, 7) < BP(2, 7));
34 EXPECT_TRUE(BP(1, 7) < BP(1, 4));
35 EXPECT_TRUE(BP(5, 7) < BP(3, 4));
46 EXPECT_TRUE(BP(4, 7) > BP(1, 2));
47 EXPECT_TRUE(BP(4, 7) > BP(3, 7));
49 EXPECT_TRUE(BP(1, 7) <= BP(2, 7));
50 EXPECT_TRUE(BP(1, 7) <= BP(1, 4));
51 EXPECT_TRUE(BP(5, 7) <= BP(3, 4));
52 EXPECT_TRUE(BP(1, 7) <= BP(1, 7));
53 EXPECT_TRUE(BP(1, 7) <= BP(2, 14));
60 EXPECT_TRUE(BP(1, 7) >= BP(1, 7));
61 EXPECT_TRUE(BP(1, 7) >= BP(2, 14));
62 EXPECT_TRUE(BP(4, 7) >= BP(1, 2));
63 EXPECT_TRUE(BP(4, 7) >= BP(3, 7));
68 EXPECT_TRUE(BP(1, 7) == BP(1, 7));
69 EXPECT_TRUE(BP(1, 7) == BP(2, 14));
73 EXPECT_TRUE(BP(1, 7) != BP(2, 7));
74 EXPECT_TRUE(BP(1, 7) != BP(1, 4));
75 EXPECT_TRUE(BP(5, 7) != BP(3, 4));
78 EXPECT_TRUE(BP(4, 7) != BP(1, 2));
79 EXPECT_TRUE(BP(4, 7) != BP(3, 7));
81 EXPECT_TRUE(BP(1, 7) == BP(2, 14));
82 EXPECT_TRUE(BP(1, 7) == BP(3, 21));
83 EXPECT_TRUE(BP(5, 7) == BP(25, 35));
84 EXPECT_TRUE(BP(99999998, 100000000) < BP(99999999, 100000000));
85 EXPECT_TRUE(BP(4, 8) == BP(400000000, 800000000));
93 EXPECT_TRUE(A == B);
97 EXPECT_TRUE(A <= B);
98 EXPECT_TRUE(A >= B);
101 EXPECT_TRUE(B != C);
103 EXPECT_TRUE(B > C);
105 EXPECT_TRUE(B >= C);
110 EXPECT_TRUE(BigZero != BigOne);
111 EXPECT_TRUE(BigZero < BigOne);
113 EXPECT_TRUE(BigZero <= BigOne);
unittests/Support/Casting.cpp 115 EXPECT_TRUE(isa<foo>(B1));
116 EXPECT_TRUE(isa<foo>(B2));
117 EXPECT_TRUE(isa<foo>(B3));
118 EXPECT_TRUE(isa<foo>(B4));
122 EXPECT_TRUE(isa_and_nonnull<foo>(B2));
123 EXPECT_TRUE(isa_and_nonnull<foo>(B4));
284 EXPECT_TRUE(isa<Base>(D));
286 EXPECT_TRUE(BP != nullptr);
305 EXPECT_TRUE(isa<UseInferredUpcast>(&UIU));
375 EXPECT_TRUE(!isa<pointer_wrappers::Derived>(MB));
376 EXPECT_TRUE(!isa<pointer_wrappers::Derived>(CB));
377 EXPECT_TRUE(isa<pointer_wrappers::Derived>(MD));
378 EXPECT_TRUE(isa<pointer_wrappers::Derived>(CD));
382 EXPECT_TRUE(cast<pointer_wrappers::Derived>(MD) == &D);
383 EXPECT_TRUE(cast<pointer_wrappers::Derived>(CD) == &D);
387 EXPECT_TRUE(cast_or_null<pointer_wrappers::Derived>(MN) == nullptr);
388 EXPECT_TRUE(cast_or_null<pointer_wrappers::Derived>(CN) == nullptr);
389 EXPECT_TRUE(cast_or_null<pointer_wrappers::Derived>(MD) == &D);
390 EXPECT_TRUE(cast_or_null<pointer_wrappers::Derived>(CD) == &D);
394 EXPECT_TRUE(dyn_cast<pointer_wrappers::Derived>(MB) == nullptr);
395 EXPECT_TRUE(dyn_cast<pointer_wrappers::Derived>(CB) == nullptr);
396 EXPECT_TRUE(dyn_cast<pointer_wrappers::Derived>(MD) == &D);
397 EXPECT_TRUE(dyn_cast<pointer_wrappers::Derived>(CD) == &D);
401 EXPECT_TRUE(dyn_cast_or_null<pointer_wrappers::Derived>(MN) == nullptr);
402 EXPECT_TRUE(dyn_cast_or_null<pointer_wrappers::Derived>(CN) == nullptr);
403 EXPECT_TRUE(dyn_cast_or_null<pointer_wrappers::Derived>(MB) == nullptr);
404 EXPECT_TRUE(dyn_cast_or_null<pointer_wrappers::Derived>(CB) == nullptr);
405 EXPECT_TRUE(dyn_cast_or_null<pointer_wrappers::Derived>(MD) == &D);
406 EXPECT_TRUE(dyn_cast_or_null<pointer_wrappers::Derived>(CD) == &D);
unittests/Support/CommandLineTest.cpp 314 EXPECT_TRUE(Actual.empty());
322 EXPECT_TRUE(Actual.empty());
437 EXPECT_TRUE(
439 EXPECT_TRUE(TopLevelOpt);
450 EXPECT_TRUE(
453 EXPECT_TRUE(SC1Opt);
463 EXPECT_TRUE(
467 EXPECT_TRUE(SC2Opt);
504 EXPECT_TRUE(cl::ParseCommandLineOptions(2, args, StringRef(), &OS));
505 EXPECT_TRUE(AllOpt);
511 EXPECT_TRUE(cl::ParseCommandLineOptions(3, args2, StringRef(), &OS));
512 EXPECT_TRUE(AllOpt);
518 EXPECT_TRUE(cl::ParseCommandLineOptions(3, args3, StringRef(), &OS));
519 EXPECT_TRUE(AllOpt);
523 EXPECT_TRUE(Errs.empty());
535 EXPECT_TRUE(
537 EXPECT_TRUE(TopLevelOpt);
543 EXPECT_TRUE(
545 EXPECT_TRUE(TopLevelOpt);
561 EXPECT_TRUE(cl::ParseCommandLineOptions(3, args, StringRef(), &OS));
562 EXPECT_TRUE(RemoveOption);
564 EXPECT_TRUE(Errs.empty());
585 EXPECT_TRUE(
587 EXPECT_TRUE(TopLevelRemove);
612 EXPECT_TRUE(
614 EXPECT_TRUE(RemoveOption);
620 EXPECT_TRUE(
622 EXPECT_TRUE(RemoveOption);
628 EXPECT_TRUE(
630 EXPECT_TRUE(RemoveOption);
657 EXPECT_TRUE(
668 EXPECT_TRUE(
701 EXPECT_TRUE(cl::ParseCommandLineOptions(sizeof(args0) / sizeof(char *), args0,
703 EXPECT_TRUE(Bar == "args0 bar string");
704 EXPECT_TRUE(Foo);
706 EXPECT_TRUE(SC2_Foo.empty());
711 EXPECT_TRUE(cl::ParseCommandLineOptions(sizeof(args1) / sizeof(char *), args1,
713 EXPECT_TRUE(Bar == "args1 bar string");
714 EXPECT_TRUE(Foo);
715 EXPECT_TRUE(SC1_B);
716 EXPECT_TRUE(SC2_Foo.empty());
727 EXPECT_TRUE(cl::ParseCommandLineOptions(sizeof(args2) / sizeof(char *), args2,
729 EXPECT_TRUE(Bar == "args2 bar string");
730 EXPECT_TRUE(Foo);
732 EXPECT_TRUE(SC2_Foo == "foo string");
759 EXPECT_TRUE(!EC);
762 EXPECT_TRUE(RspFile.is_open());
771 EXPECT_TRUE(
773 EXPECT_TRUE(TopLevelOpt);
774 EXPECT_TRUE(InputFilenames[0] == "path\\dir\\file1");
775 EXPECT_TRUE(InputFilenames[1] == "path/dir/file2");
784 EXPECT_TRUE(!EC);
790 EXPECT_TRUE(IncludedFile.is_open());
802 EXPECT_TRUE(!EC);
808 EXPECT_TRUE(IncludedFile2.is_open());
817 EXPECT_TRUE(IncludedFile3.is_open());
834 EXPECT_TRUE(Res);
860 EXPECT_TRUE(!EC);
875 EXPECT_TRUE(SelfFile.is_open());
883 EXPECT_TRUE(NestedFile.is_open());
891 EXPECT_TRUE(FlagFile.is_open());
926 EXPECT_TRUE(!EC);
932 EXPECT_TRUE(ResponseFile.is_open());
970 EXPECT_TRUE(
973 EXPECT_TRUE(Opt1 == "false");
974 EXPECT_TRUE(Opt2);
975 EXPECT_TRUE(Opt3 == 3);
990 EXPECT_TRUE(Opt1 == "true");
991 EXPECT_TRUE(Opt2);
992 EXPECT_TRUE(Opt3 == 3);
1002 EXPECT_TRUE(!EC);
1007 EXPECT_TRUE(ConfigFile.is_open());
1019 EXPECT_TRUE(ConfigFile2.is_open());
1031 EXPECT_TRUE(!EC);
1032 EXPECT_TRUE(StringRef(CurrDir) != StringRef(TestDir));
1038 EXPECT_TRUE(Result);
1073 EXPECT_TRUE(cl::ParseCommandLineOptions(3, args3, StringRef(), &OS)); OS.flush();
1074 EXPECT_TRUE(Errs.empty()); Errs.clear();
1077 EXPECT_TRUE(cl::ParseCommandLineOptions(6, args4, StringRef(), &OS)); OS.flush();
1078 EXPECT_TRUE(PosEatArgs.size() == 1);
1079 EXPECT_TRUE(PosEatArgs2.size() == 2);
1080 EXPECT_TRUE(Errs.empty());
1323 EXPECT_TRUE(IncludeDirs.empty());
1325 EXPECT_TRUE(
1327 EXPECT_TRUE(IncludeDirs.size() == 1);
1328 EXPECT_TRUE(IncludeDirs.front().compare("/usr/include") == 0);
1335 EXPECT_TRUE(IncludeDirs.empty());
1337 EXPECT_TRUE(
1339 EXPECT_TRUE(IncludeDirs.size() == 1);
1340 EXPECT_TRUE(IncludeDirs.front().compare("/usr/include") == 0);
1346 EXPECT_TRUE(IncludeDirs.empty());
1348 EXPECT_TRUE(
1350 EXPECT_TRUE(IncludeDirs.size() == 1);
1351 EXPECT_TRUE(IncludeDirs.front().compare("/usr/include") == 0);
1361 EXPECT_TRUE(MacroDefs.empty());
1363 EXPECT_TRUE(
1365 EXPECT_TRUE(MacroDefs.size() == 1);
1366 EXPECT_TRUE(MacroDefs.front().compare("=HAVE_FOO") == 0);
1373 EXPECT_TRUE(MacroDefs.empty());
1377 EXPECT_TRUE(MacroDefs.empty());
1382 EXPECT_TRUE(MacroDefs.empty());
1384 EXPECT_TRUE(
1386 EXPECT_TRUE(MacroDefs.size() == 1);
1387 EXPECT_TRUE(MacroDefs.front().compare("HAVE_FOO") == 0);
1405 EXPECT_TRUE(
1407 EXPECT_TRUE(OptF);
1421 EXPECT_TRUE(
1423 EXPECT_TRUE(OptF);
1431 EXPECT_TRUE(
1433 EXPECT_TRUE(OptF);
1441 EXPECT_TRUE(
1443 EXPECT_TRUE(OptF);
1446 EXPECT_TRUE(OptO.empty());
1467 EXPECT_TRUE(
1475 EXPECT_TRUE(
1483 EXPECT_TRUE(
1492 EXPECT_TRUE(
1494 EXPECT_TRUE(OptF);
1500 EXPECT_TRUE(
1502 EXPECT_TRUE(OptF);
1508 EXPECT_TRUE(
1510 EXPECT_TRUE(OptF);
1518 EXPECT_TRUE(
1520 EXPECT_TRUE(OptF);
1528 EXPECT_TRUE(
1542 EXPECT_TRUE(
1551 EXPECT_TRUE(
1553 EXPECT_TRUE(OptF);
1564 EXPECT_TRUE(
1566 EXPECT_TRUE(OptF);
1574 EXPECT_TRUE(
1576 EXPECT_TRUE(OptF);
1604 EXPECT_TRUE(
1606 EXPECT_TRUE(OptA);
1609 EXPECT_TRUE(Errs.empty()); Errs.clear();
1612 EXPECT_TRUE(
1614 EXPECT_TRUE(OptA);
1617 EXPECT_TRUE(Errs.empty()); Errs.clear();
1641 EXPECT_TRUE(cl::ParseCommandLineOptions(4, args2, StringRef(),
1643 EXPECT_TRUE(Errs.empty()); Errs.clear();
1647 EXPECT_TRUE(cl::ParseCommandLineOptions(4, args3, StringRef(),
1649 EXPECT_TRUE(OptA);
1650 EXPECT_TRUE(OptBLong);
1653 EXPECT_TRUE(Errs.empty()); Errs.clear();
unittests/Support/ConvertUTFTest.cpp 23 EXPECT_TRUE(Success);
34 EXPECT_TRUE(Success);
45 EXPECT_TRUE(Success);
61 EXPECT_TRUE(Success);
62 EXPECT_TRUE(Result.empty());
67 EXPECT_TRUE(HasBOM);
69 EXPECT_TRUE(HasBOM);
71 EXPECT_TRUE(HasBOM); // Don't care about odd lengths.
73 EXPECT_TRUE(HasBOM);
87 EXPECT_TRUE(Success);
97 EXPECT_TRUE(Success);
102 EXPECT_TRUE(Success);
111 EXPECT_TRUE(Success);
214 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
222 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
231 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
242 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
248 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
258 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
269 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
278 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
283 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
288 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
293 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
298 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
304 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
314 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
318 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
323 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
328 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
334 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
340 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
350 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
355 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
360 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
365 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
370 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
382 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
384 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
386 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
389 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
392 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
395 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
399 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
403 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
407 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
411 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
417 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
445 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
458 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
482 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
490 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
504 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
510 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
519 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
524 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
531 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
535 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
544 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
546 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
548 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
550 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
553 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
558 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
563 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
568 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
573 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
583 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
585 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
587 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
590 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
593 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
596 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
599 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
602 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
605 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
608 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
611 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
614 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
617 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
620 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
623 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
626 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
631 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
634 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
637 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
640 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
643 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
647 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
651 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
655 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
662 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
665 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
668 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
672 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
675 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
678 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
685 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
690 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
694 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
698 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
702 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
707 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
715 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
719 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
723 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
727 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
731 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
736 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
744 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
748 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
752 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
757 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
766 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
769 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
772 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
775 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
778 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
781 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
786 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
788 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
791 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
794 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
798 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
804 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
810 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
814 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
817 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
820 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
823 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
827 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
834 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
837 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
840 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
843 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
846 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
850 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
857 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
860 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
863 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
867 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
875 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
877 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
879 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
881 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
883 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
887 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
889 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
892 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
899 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
901 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
904 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
910 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
913 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
916 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
919 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
922 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
926 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
933 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
936 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
939 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
943 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
954 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
956 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
958 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
960 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
963 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
967 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
969 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
976 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
979 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
982 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
986 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
997 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1000 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1007 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1027 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1031 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1034 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1038 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1042 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1046 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1052 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1057 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1060 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1064 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1068 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1072 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1078 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1081 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1084 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1087 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1091 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1095 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1099 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1103 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1107 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1111 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1133 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1139 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1145 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1153 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1159 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1165 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1173 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1179 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1185 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1191 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1197 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1203 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1209 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1215 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1221 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1238 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1243 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1248 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1253 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1258 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1263 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1268 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1273 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1278 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1283 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1288 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1293 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1298 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1303 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1308 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1313 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1318 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1323 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1328 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1333 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1338 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1343 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1348 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1353 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1358 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1363 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1368 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1373 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1378 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1383 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1388 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1393 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1398 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1403 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1408 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1413 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1418 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1423 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1428 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1433 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1438 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1443 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1448 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1453 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1458 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1463 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1468 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1473 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1478 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1483 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1488 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1493 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1498 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1503 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1508 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1513 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1518 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1523 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1528 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1533 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1538 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1543 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1548 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1553 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1558 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1563 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1568 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1573 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1578 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1583 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1588 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1593 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1598 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1603 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1608 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1613 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1618 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1623 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1628 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1633 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1638 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1643 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1650 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1658 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1661 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1664 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1667 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1670 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1673 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1676 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1679 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1682 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1685 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1688 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1691 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1694 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1697 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1700 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1703 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1707 EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
unittests/Support/CrashRecoveryTest.cpp 30 EXPECT_TRUE(CrashRecoveryContext().RunSafely(incrementGlobal));
50 EXPECT_TRUE(CRC.RunSafely(noop));
unittests/Support/DataExtractorTest.cpp 269 EXPECT_TRUE(DE.eof(C));
unittests/Support/DebugCounterTest.cpp 25 EXPECT_TRUE(DebugCounter::isCounterSet(TestCounter));
31 EXPECT_TRUE(DebugCounter::shouldExecute(TestCounter));
34 EXPECT_TRUE(DebugCounter::shouldExecute(TestCounter));
unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp 66 EXPECT_TRUE(DL.isValid());
67 EXPECT_TRUE(Err.empty());
70 EXPECT_TRUE(GS != nullptr && GS != &TestA);
74 EXPECT_TRUE(GS != nullptr && GS != &TestA);
78 EXPECT_TRUE(DL.isValid());
79 EXPECT_TRUE(Err.empty());
83 EXPECT_TRUE(GS != nullptr && GS == &TestA);
87 EXPECT_TRUE(GS != nullptr && GS == &TestA);
93 EXPECT_TRUE(GS != nullptr && GS != &TestA);
98 EXPECT_TRUE(GS != nullptr && GS != &OverloadTestA);
101 EXPECT_TRUE(GS != nullptr && GS == &OverloadTestA);
104 EXPECT_TRUE(FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol(
108 EXPECT_TRUE(DynamicLibrary::SearchOrder == DynamicLibrary::SO_Linker);
119 EXPECT_TRUE(DL.isValid());
120 EXPECT_TRUE(Err.empty());
124 EXPECT_TRUE(SS_0 != nullptr);
131 EXPECT_TRUE(TO_0 != nullptr);
135 EXPECT_TRUE(DL2.isValid());
136 EXPECT_TRUE(Err.empty());
141 EXPECT_TRUE(SS_1 != nullptr);
142 EXPECT_TRUE(SS_0 != SS_1);
146 EXPECT_TRUE(TO_1 != nullptr);
147 EXPECT_TRUE(TO_0 != TO_1);
158 EXPECT_TRUE(FuncPtr<SetStrings>(DynamicLibrary::SearchForAddressOfSymbol(
unittests/Support/ErrorOrTest.cpp 25 EXPECT_TRUE(!!a);
75 EXPECT_TRUE(!!x);
86 EXPECT_TRUE(!!x);
103 EXPECT_TRUE(!!x1);
104 EXPECT_TRUE(!!x2);
105 EXPECT_TRUE(!!x3);
106 EXPECT_TRUE(!!x4);
unittests/Support/ErrorTest.cpp 164 EXPECT_TRUE(E.isA<CustomError>());
166 EXPECT_TRUE(F.isA<CustomError>());
167 EXPECT_TRUE(F.isA<CustomSubError>());
182 EXPECT_TRUE(CaughtErrorInfo == 42) << "Wrong result from CustomError handler";
256 EXPECT_TRUE(CaughtErrorInfo == 42 && CaughtErrorExtraInfo == 7)
273 EXPECT_TRUE(CaughtErrorInfo == 42 && CaughtErrorExtraInfo == 7 &&
292 EXPECT_TRUE(CaughtErrorInfo == 42 && DummyInfo == 0 && DummyExtraInfo == 0)
320 EXPECT_TRUE(CustomErrorInfo1 == 7 && CustomErrorInfo2 == 42 &&
537 EXPECT_TRUE(!!A) << "Expected with non-error value doesn't convert to 'true'";
590 EXPECT_TRUE(E.isA<CustomError>()) << "Incorrect Expected error value";
642 EXPECT_TRUE(!!ValOrErr)
668 EXPECT_TRUE(Err.isA<CustomError>())
684 EXPECT_TRUE(!!ValOrErr)
865 EXPECT_TRUE(GotCSE) << "Failed to round-trip ErrorList via C API";
866 EXPECT_TRUE(GotCE) << "Failed to round-trip ErrorList via C API";
unittests/Support/FileCheckTest.cpp 51 EXPECT_TRUE(ExpectedUndefVarNames.empty()) << toString(ExpectedUndefVarNames);
124 EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('a'));
125 EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('G'));
126 EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('_'));
151 EXPECT_TRUE(VarName.empty());
158 EXPECT_TRUE(VarName.empty());
165 EXPECT_TRUE(VarName.empty());
166 EXPECT_TRUE(ParsedVarResult->IsPseudo);
170 EXPECT_TRUE(errorToBool(ParsedVarResult.takeError()));
174 EXPECT_TRUE(errorToBool(ParsedVarResult.takeError()));
269 EXPECT_TRUE(Tester.parseSubstExpect("10VAR:"));
270 EXPECT_TRUE(Tester.parseSubstExpect("@FOO:"));
271 EXPECT_TRUE(Tester.parseSubstExpect("@LINE:"));
274 EXPECT_TRUE(Tester.parseSubstExpect("BAR:"));
277 EXPECT_TRUE(Tester.parseSubstExpect("VAR GARBAGE:"));
289 EXPECT_TRUE(Tester.parseSubstExpect("10VAR"));
290 EXPECT_TRUE(Tester.parseSubstExpect("@FOO"));
305 EXPECT_TRUE(Tester.parseSubstExpect("LINE1VAR"));
311 EXPECT_TRUE(Tester.parseSubstExpect("LINE2VAR"));
314 EXPECT_TRUE(Tester.parseSubstExpect("@LINE/2"));
317 EXPECT_TRUE(Tester.parseSubstExpect("@LINE+"));
333 EXPECT_TRUE(Tester.parsePatternExpect("[[ BAR]]"));
336 EXPECT_TRUE(Tester.parsePatternExpect("[[42INVALID]]"));
339 EXPECT_TRUE(Tester.parsePatternExpect("[[@PAT:]]"));
340 EXPECT_TRUE(Tester.parsePatternExpect("[[PAT+2:]]"));
343 EXPECT_TRUE(Tester.parsePatternExpect("[[FOO:]]"));
352 EXPECT_TRUE(Tester.parsePatternExpect("[[#42INVALID]]"));
353 EXPECT_TRUE(Tester.parsePatternExpect("[[#@FOO]]"));
354 EXPECT_TRUE(Tester.parsePatternExpect("[[#@LINE/2]]"));
367 EXPECT_TRUE(Tester.matchExpect("FAIL"));
373 EXPECT_TRUE(Tester.matchExpect("FAIL"));
374 EXPECT_TRUE(Tester.matchExpect(""));
380 EXPECT_TRUE(Tester.matchExpect("19 21"));
381 EXPECT_TRUE(Tester.matchExpect("18 21"));
393 EXPECT_TRUE(Tester.matchExpect("FOO"));
460 EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
463 EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
468 EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
471 EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
476 EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
479 EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
485 EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
490 EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
496 EXPECT_TRUE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
541 EXPECT_TRUE(errorToBool(UnknownVar.takeError()));
546 EXPECT_TRUE(errorToBool(LocalVar.takeError()));
551 EXPECT_TRUE(errorToBool((*ExpressionAST)->eval().takeError()));
558 EXPECT_TRUE(errorToBool(ExpressionVal.takeError()));
564 EXPECT_TRUE(errorToBool(ExpressionVal.takeError()));
566 EXPECT_TRUE(errorToBool(EmptyVar.takeError()));
unittests/Support/FileCollectorTest.cpp 115 EXPECT_TRUE(FileCollector.hasSeen("/path/to/a"));
116 EXPECT_TRUE(FileCollector.hasSeen("/path/to/b"));
117 EXPECT_TRUE(FileCollector.hasSeen("/path/to/c"));
144 EXPECT_TRUE(ec);
164 EXPECT_TRUE(FileCollector.hasSeen(a.Path));
168 EXPECT_TRUE(FileCollector.hasSeen(subdir.Path));
202 EXPECT_TRUE(Collector->hasSeen(a.Path));
205 EXPECT_TRUE(Collector->hasSeen(b.Path));
208 EXPECT_TRUE(Collector->hasSeen(subdir.Path));
214 EXPECT_TRUE(Collector->hasSeen(subdir3.Path));
215 EXPECT_TRUE(Collector->hasSeen(subdir3a.Path));
216 EXPECT_TRUE(Collector->hasSeen(subdir3b.Path));
296 EXPECT_TRUE(Collector->hasSeen(a.Path));
297 EXPECT_TRUE(Collector->hasSeen(symlink.Path));
unittests/Support/FileOutputBufferTest.cpp 118 EXPECT_TRUE(IsExecutable);
unittests/Support/FormatVariadicTest.cpp 687 EXPECT_TRUE(E1.isA<StringError>()); // not consumed
unittests/Support/GlobPatternTest.cpp 19 EXPECT_TRUE((bool)Pat1);
20 EXPECT_TRUE(Pat1->match(""));
26 EXPECT_TRUE((bool)Pat1);
27 EXPECT_TRUE(Pat1->match("abcdef"));
28 EXPECT_TRUE(Pat1->match("abxcxdef"));
36 EXPECT_TRUE((bool)Pat1);
37 EXPECT_TRUE(Pat1->match("axxc"));
44 EXPECT_TRUE((bool)Pat1);
45 EXPECT_TRUE(Pat1->match("*"));
50 EXPECT_TRUE((bool)Pat2);
51 EXPECT_TRUE(Pat2->match("ax?c"));
58 EXPECT_TRUE((bool)Pat1);
59 EXPECT_TRUE(Pat1->match("a"));
60 EXPECT_TRUE(Pat1->match("b"));
61 EXPECT_TRUE(Pat1->match("c"));
62 EXPECT_TRUE(Pat1->match("d"));
63 EXPECT_TRUE(Pat1->match("e"));
64 EXPECT_TRUE(Pat1->match("f"));
65 EXPECT_TRUE(Pat1->match("y"));
66 EXPECT_TRUE(Pat1->match("z"));
73 EXPECT_TRUE((bool)Pat1);
74 EXPECT_TRUE(Pat1->match("g"));
86 EXPECT_TRUE((bool)Pat2);
87 EXPECT_TRUE(Pat2->match("g"));
101 EXPECT_TRUE((bool)Pat1);
102 EXPECT_TRUE(Pat1->match("]x"));
103 EXPECT_TRUE(Pat1->match("ax"));
110 EXPECT_TRUE((bool)Pat1);
111 EXPECT_TRUE(Pat1->match("*"));
112 EXPECT_TRUE(Pat1->match("?"));
113 EXPECT_TRUE(Pat1->match("^"));
130 EXPECT_TRUE((bool)Pat1);
131 EXPECT_TRUE(Pat1->match("axxx\xFF"));
133 EXPECT_TRUE((bool)Pat2);
134 EXPECT_TRUE(Pat2->match("\xFF"));
unittests/Support/ItaniumManglingCanonicalizerTest.cpp 317 EXPECT_TRUE(Found.insert({ClassKey, *Class.begin()}).second)
unittests/Support/JSONTest.cpp 204 EXPECT_TRUE(isUTF8(Valid)) << Valid;
232 EXPECT_TRUE(!!Doc);
239 EXPECT_TRUE(O->getNull("null"));
319 EXPECT_TRUE(!!Doc) << T.Desc;
unittests/Support/KnownBitsTest.cpp 119 EXPECT_TRUE(KnownNSWComputed.Zero.isSubsetOf(KnownNSW.Zero));
120 EXPECT_TRUE(KnownNSWComputed.One.isSubsetOf(KnownNSW.One));
unittests/Support/LineIteratorTest.cpp 38 EXPECT_TRUE(I.is_at_eof());
67 EXPECT_TRUE(I.is_at_eof());
103 EXPECT_TRUE(I.is_at_eof());
127 EXPECT_TRUE(I.is_at_eof());
164 EXPECT_TRUE(I.is_at_eof());
170 EXPECT_TRUE(line_iterator(*Buffer).is_at_eof());
172 EXPECT_TRUE(line_iterator(*Buffer, false).is_at_eof());
176 EXPECT_TRUE(line_iterator(*Buffer).is_at_eof());
182 EXPECT_TRUE(line_iterator(*Buffer, true, '#').is_at_eof());
188 EXPECT_TRUE(line_iterator(*Buffer, true, '#').is_at_eof());
unittests/Support/LockFileManagerTest.cpp 110 EXPECT_TRUE(sys::fs::exists(FileLock.str()));
unittests/Support/ManagedStatic.cpp 79 EXPECT_TRUE(Ms1.isConstructed());
80 EXPECT_TRUE(Ms2.isConstructed());
unittests/Support/MathExtrasTest.cpp 134 EXPECT_TRUE(isIntN(16, 32767));
139 EXPECT_TRUE(isUIntN(16, 65535));
141 EXPECT_TRUE(isUIntN(1, 0));
142 EXPECT_TRUE(isUIntN(6, 63));
180 EXPECT_TRUE(isPowerOf2_32(1 << 6));
181 EXPECT_TRUE(isPowerOf2_32(1 << 12));
188 EXPECT_TRUE(isPowerOf2_64(1LL << 46));
189 EXPECT_TRUE(isPowerOf2_64(1LL << 12));
296 EXPECT_TRUE(ResultOverflowed);
304 EXPECT_TRUE(ResultOverflowed);
308 EXPECT_TRUE(ResultOverflowed);
357 EXPECT_TRUE(ResultOverflowed);
361 EXPECT_TRUE(ResultOverflowed);
365 EXPECT_TRUE(ResultOverflowed);
381 EXPECT_TRUE(ResultOverflowed);
411 EXPECT_TRUE(ResultOverflowed);
415 EXPECT_TRUE(ResultOverflowed);
419 EXPECT_TRUE(ResultOverflowed);
422 EXPECT_TRUE(ResultOverflowed);
425 EXPECT_TRUE(ResultOverflowed);
428 EXPECT_TRUE(ResultOverflowed);
453 EXPECT_TRUE((isShiftedUInt<1, 0>(0)));
454 EXPECT_TRUE((isShiftedUInt<1, 0>(1)));
458 EXPECT_TRUE((isShiftedUInt<1, 63>(0x8000000000000000)));
459 EXPECT_TRUE((isShiftedUInt<2, 62>(0xC000000000000000)));
463 EXPECT_TRUE((isShiftedUInt<10, 5>(uint64_t(0x201) << 5)));
469 EXPECT_TRUE((isShiftedInt<1, 0>(0)));
470 EXPECT_TRUE((isShiftedInt<1, 0>(-1)));
474 EXPECT_TRUE((isShiftedInt<1, 63>(0x8000000000000000)));
475 EXPECT_TRUE((isShiftedInt<2, 62>(0xC000000000000000)));
479 EXPECT_TRUE((isShiftedInt<11, 5>(int64_t(0x201) << 5)));
482 EXPECT_TRUE((isShiftedInt<11, 5>(-(int64_t(0x201) << 5))));
486 EXPECT_TRUE((isShiftedInt<6, 10>(-(int64_t(1) << 15))));
507 EXPECT_TRUE(AddOverflow<TypeParam>(MaxValue, MaxValue, Result));
514 EXPECT_TRUE(AddOverflow<TypeParam>(MaxValue, TypeParam(1), Result));
521 EXPECT_TRUE(AddOverflow<TypeParam>(MinValue, MinValue, Result));
528 EXPECT_TRUE(AddOverflow<TypeParam>(MinValue, TypeParam(-1), Result));
541 EXPECT_TRUE(SubOverflow<TypeParam>(0, MinValue, Result));
548 EXPECT_TRUE(SubOverflow<TypeParam>(0, MinValue, Result));
556 EXPECT_TRUE(SubOverflow<TypeParam>(MaxValue, MinValue, Result));
564 EXPECT_TRUE(SubOverflow<TypeParam>(MinValue, MaxValue, Result));
591 EXPECT_TRUE(MulOverflow<TypeParam>(MinValue, -1, Result));
599 EXPECT_TRUE(MulOverflow<TypeParam>(MinValue, MinValue, Result));
601 EXPECT_TRUE(MulOverflow<TypeParam>(MaxValue, MaxValue, Result));
unittests/Support/MemoryBufferTest.cpp 76 EXPECT_TRUE(nullptr != MB1.get());
80 EXPECT_TRUE(nullptr != MB2.get());
84 EXPECT_TRUE(nullptr != MB3.get());
154 EXPECT_TRUE(nullptr != MBC1.get());
158 EXPECT_TRUE(nullptr != MBC2.get());
199 EXPECT_TRUE(nullptr != Zero.get());
203 EXPECT_TRUE(nullptr != One.get());
207 EXPECT_TRUE(nullptr != Two.get());
211 EXPECT_TRUE(nullptr != Three.get());
217 EXPECT_TRUE(nullptr != Four.get());
301 EXPECT_TRUE(BufData.substr(0x0000,8).equals("12345678"));
302 EXPECT_TRUE(BufData.substr(0x0FF8,8).equals("12345678"));
303 EXPECT_TRUE(BufData.substr(0x1000,8).equals("abcdefgh"));
304 EXPECT_TRUE(BufData.substr(0x2FF8,8).equals("abcdefgh"));
305 EXPECT_TRUE(BufData.substr(0x3000,8).equals("ABCDEFGH"));
306 EXPECT_TRUE(BufData.substr(0x3FF8,8).equals("ABCDEFGH"));
316 EXPECT_TRUE(BufData2.substr(0x0000,8).equals("12345678"));
317 EXPECT_TRUE(BufData2.substr(0x17F8,8).equals("12345678"));
318 EXPECT_TRUE(BufData2.substr(0x1800,8).equals("abcdefgh"));
319 EXPECT_TRUE(BufData2.substr(0x2FF8,8).equals("abcdefgh"));
unittests/Support/Path.cpp 71 EXPECT_TRUE(path::is_separator('/'));
76 EXPECT_TRUE(path::is_separator('\\', path::Style::windows));
303 EXPECT_TRUE(path::is_separator(LastComponent[0], Path.second));
325 EXPECT_TRUE(status);
351 EXPECT_TRUE(status);
363 EXPECT_TRUE(!TempDir.empty());
366 EXPECT_TRUE(!TempDir.empty());
657 EXPECT_TRUE(equal);
660 EXPECT_TRUE(fs::equivalent(A, B));
1015 EXPECT_TRUE(fs::exists(Twine(BaseDir) + "/foo/bar/baz"));
1016 EXPECT_TRUE(fs::exists(Twine(BaseDir) + "/foo/bar/buzz"));
1017 EXPECT_TRUE(fs::exists(Paths[0]));
1018 EXPECT_TRUE(fs::exists(Paths[1]));
1019 EXPECT_TRUE(fs::exists(Paths[2]));
1020 EXPECT_TRUE(fs::exists(Paths[3]));
1208 EXPECT_TRUE(path::remove_dots(Path1, true, path::Style::windows));
1226 EXPECT_TRUE(path::remove_dots(Path2, true, path::Style::posix));
1678 EXPECT_TRUE(CheckPermissions(fs::all_all));
1681 EXPECT_TRUE(CheckPermissions(fs::all_read | fs::all_exe));
1758 EXPECT_TRUE(CheckPermissions(fs::no_perms));
1761 EXPECT_TRUE(CheckPermissions(fs::owner_read));
1764 EXPECT_TRUE(CheckPermissions(fs::owner_write));
1767 EXPECT_TRUE(CheckPermissions(fs::owner_exe));
1770 EXPECT_TRUE(CheckPermissions(fs::owner_all));
1773 EXPECT_TRUE(CheckPermissions(fs::group_read));
1776 EXPECT_TRUE(CheckPermissions(fs::group_write));
1779 EXPECT_TRUE(CheckPermissions(fs::group_exe));
1782 EXPECT_TRUE(CheckPermissions(fs::group_all));
1785 EXPECT_TRUE(CheckPermissions(fs::others_read));
1788 EXPECT_TRUE(CheckPermissions(fs::others_write));
1791 EXPECT_TRUE(CheckPermissions(fs::others_exe));
1794 EXPECT_TRUE(CheckPermissions(fs::others_all));
1797 EXPECT_TRUE(CheckPermissions(fs::all_read));
1800 EXPECT_TRUE(CheckPermissions(fs::all_write));
1803 EXPECT_TRUE(CheckPermissions(fs::all_exe));
1806 EXPECT_TRUE(CheckPermissions(fs::set_uid_on_exe));
1809 EXPECT_TRUE(CheckPermissions(fs::set_gid_on_exe));
1817 EXPECT_TRUE(CheckPermissions(fs::sticky_bit));
1823 EXPECT_TRUE(CheckPermissions(fs::set_uid_on_exe | fs::set_gid_on_exe |
1830 EXPECT_TRUE(CheckPermissions(fs::all_read | fs::set_uid_on_exe |
1834 EXPECT_TRUE(CheckPermissions(fs::all_perms));
1839 EXPECT_TRUE(CheckPermissions(fs::all_perms & ~fs::sticky_bit));
unittests/Support/RegexTest.cpp 22 EXPECT_TRUE(r1.match("916"));
23 EXPECT_TRUE(r1.match("9"));
28 EXPECT_TRUE(r2.match("aa216b", &Matches));
33 EXPECT_TRUE(r3.match("9a:513b", &Matches));
39 EXPECT_TRUE(r3.match("9:513b", &Matches));
49 EXPECT_TRUE(r4.match(String, &Matches));
60 EXPECT_TRUE(r5.match(String));
66 EXPECT_TRUE(r1.match("abc_abc", &Matches));
71 EXPECT_TRUE(r2.match("a4b4c4", &Matches));
77 EXPECT_TRUE(r3.match("a6zb6z", &Matches));
115 EXPECT_TRUE(Regex::isLiteralERE("abc"));
145 EXPECT_TRUE(r2.match("916"));
152 EXPECT_TRUE(r2.match("916"));
163 EXPECT_TRUE(r1.isValid(Error));
unittests/Support/ReplaceFileTest.cpp 93 EXPECT_TRUE(!fs::rename(SourceFileName, TargetFileName));
97 EXPECT_TRUE(FDHasContent(ReadFD, "!!target!!"));
105 EXPECT_TRUE(FileHasContent(TargetFileName, "!!source!!"));
109 EXPECT_TRUE(!fs::rename(TargetFileName, SourceFileName));
167 EXPECT_TRUE(FileHasContent(TargetTmp0FileName, "!!target.tmp0!!"));
unittests/Support/SpecialCaseListTest.cpp 53 EXPECT_TRUE(SCL->inSection("", "src", "hello"));
54 EXPECT_TRUE(SCL->inSection("", "src", "bye"));
55 EXPECT_TRUE(SCL->inSection("", "src", "hi", "category"));
56 EXPECT_TRUE(SCL->inSection("", "src", "zzzz", "category"));
76 EXPECT_TRUE(
82 EXPECT_TRUE(
89 EXPECT_TRUE(((StringRef)Error).startswith("malformed section header "));
92 EXPECT_TRUE(((StringRef)Error).startswith("malformed regex for section [: "));
95 EXPECT_TRUE(((StringRef)Error).endswith("Supplied regexp was blank"));
104 EXPECT_TRUE(SCL->inSection("arbitrary", "src", "global"));
105 EXPECT_TRUE(SCL->inSection("", "src", "global"));
106 EXPECT_TRUE(SCL->inSection("sect1", "src", "test1"));
110 EXPECT_TRUE(SCL->inSection("sect2", "src", "test1"));
111 EXPECT_TRUE(SCL->inSection("sect3", "src", "test2"));
112 EXPECT_TRUE(SCL->inSection("sect3-arbitrary", "src", "test2"));
122 EXPECT_TRUE(SCL->inSection("", "global", "foo", "init"));
129 EXPECT_TRUE(SCL->inSection("", "type", "t2", "init"));
134 EXPECT_TRUE(SCL->inSection("", "src", "hello", "init"));
147 EXPECT_TRUE(SCL->inSection("", "fun", "tomfoolery"));
148 EXPECT_TRUE(SCL->inSection("", "fun", "foobar"));
181 EXPECT_TRUE(SCL->inSection("", "src", "bar"));
182 EXPECT_TRUE(SCL->inSection("", "src", "baz"));
184 EXPECT_TRUE(SCL->inSection("", "src", "ban", "init"));
185 EXPECT_TRUE(SCL->inSection("", "src", "tomfoolery"));
186 EXPECT_TRUE(SCL->inSection("", "src", "tomfoglery"));
194 EXPECT_TRUE(SCL->inSection("", "fun", "bar"));
196 EXPECT_TRUE(SCL->inSection("", "fun", "zakaz"));
203 EXPECT_TRUE(SCL->inSection("", "fun", "abara"));
205 EXPECT_TRUE(SCL->inSection("", "fun", "zakaz"));
212 EXPECT_TRUE(SCL->inSection("", "fun", "bara"));
214 EXPECT_TRUE(SCL->inSection("", "fun", "barbarbarbar"));
215 EXPECT_TRUE(SCL->inSection("", "fun", "abarbarbarbar"));
221 EXPECT_TRUE(SCL->inSection("", "src", "c++abi"));
230 EXPECT_TRUE(SCL->inSection("", "fun", "aaa"));
231 EXPECT_TRUE(SCL->inSection("", "fun", "aaaa"));
232 EXPECT_TRUE(SCL->inSection("", "fun", "aaaabbbaaa"));
238 EXPECT_TRUE(SCL->inSection("", "src", "dir/c++abi"));
241 EXPECT_TRUE(SCL->inSection("", "src", "C:\\hello\\world"));
242 EXPECT_TRUE(SCL->inSection("", "src", "hello\\world"));
unittests/Support/StringPool.cpp 27 EXPECT_TRUE(a != b);
unittests/Support/SymbolRemappingReaderTest.cpp 24 EXPECT_TRUE((bool)E);
unittests/Support/TarWriterTest.cpp 49 EXPECT_TRUE((bool)TarOrErr);
56 EXPECT_TRUE((bool)MBOrErr);
71 EXPECT_TRUE(Buf.size() >= sizeof(UstarHeader));
113 EXPECT_TRUE(Buf.size() >= 1024);
120 EXPECT_TRUE(Pax.startswith("211 path=/" + std::string(200, 'x')));
130 EXPECT_TRUE((bool)TarOrErr);
148 EXPECT_TRUE((bool)TarOrErr);
167 EXPECT_TRUE((bool)TarOrErr);
unittests/Support/TargetParserTest.cpp 53 EXPECT_TRUE(testARMCPU("invalid", "invalid", "invalid",
55 EXPECT_TRUE(testARMCPU("generic", "invalid", "none",
58 EXPECT_TRUE(testARMCPU("arm2", "armv2", "none",
60 EXPECT_TRUE(testARMCPU("arm3", "armv2a", "none",
62 EXPECT_TRUE(testARMCPU("arm6", "armv3", "none",
64 EXPECT_TRUE(testARMCPU("arm7m", "armv3m", "none",
66 EXPECT_TRUE(testARMCPU("arm8", "armv4", "none",
68 EXPECT_TRUE(testARMCPU("arm810", "armv4", "none",
70 EXPECT_TRUE(testARMCPU("strongarm", "armv4", "none",
72 EXPECT_TRUE(testARMCPU("strongarm110", "armv4", "none",
74 EXPECT_TRUE(testARMCPU("strongarm1100", "armv4", "none",
76 EXPECT_TRUE(testARMCPU("strongarm1110", "armv4", "none",
78 EXPECT_TRUE(testARMCPU("arm7tdmi", "armv4t", "none",
80 EXPECT_TRUE(testARMCPU("arm7tdmi-s", "armv4t", "none",
82 EXPECT_TRUE(testARMCPU("arm710t", "armv4t", "none",
84 EXPECT_TRUE(testARMCPU("arm720t", "armv4t", "none",
86 EXPECT_TRUE(testARMCPU("arm9", "armv4t", "none",
88 EXPECT_TRUE(testARMCPU("arm9tdmi", "armv4t", "none",
90 EXPECT_TRUE(testARMCPU("arm920", "armv4t", "none",
92 EXPECT_TRUE(testARMCPU("arm920t", "armv4t", "none",
94 EXPECT_TRUE(testARMCPU("arm922t", "armv4t", "none",
96 EXPECT_TRUE(testARMCPU("arm9312", "armv4t", "none",
98 EXPECT_TRUE(testARMCPU("arm940t", "armv4t", "none",
100 EXPECT_TRUE(testARMCPU("ep9312", "armv4t", "none",
102 EXPECT_TRUE(testARMCPU("arm10tdmi", "armv5t", "none",
104 EXPECT_TRUE(testARMCPU("arm1020t", "armv5t", "none",
106 EXPECT_TRUE(testARMCPU("arm9e", "armv5te", "none",
108 EXPECT_TRUE(testARMCPU("arm946e-s", "armv5te", "none",
110 EXPECT_TRUE(testARMCPU("arm966e-s", "armv5te", "none",
112 EXPECT_TRUE(testARMCPU("arm968e-s", "armv5te", "none",
114 EXPECT_TRUE(testARMCPU("arm10e", "armv5te", "none",
116 EXPECT_TRUE(testARMCPU("arm1020e", "armv5te", "none",
118 EXPECT_TRUE(testARMCPU("arm1022e", "armv5te", "none",
120 EXPECT_TRUE(testARMCPU("arm926ej-s", "armv5tej", "none",
122 EXPECT_TRUE(testARMCPU("arm1136j-s", "armv6", "none",
124 EXPECT_TRUE(testARMCPU("arm1136jf-s", "armv6", "vfpv2",
126 EXPECT_TRUE(testARMCPU("arm1136jz-s", "armv6", "none",
128 EXPECT_TRUE(testARMCPU("arm1176jz-s", "armv6kz", "none",
130 EXPECT_TRUE(testARMCPU("mpcore", "armv6k", "vfpv2",
132 EXPECT_TRUE(testARMCPU("mpcorenovfp", "armv6k", "none",
134 EXPECT_TRUE(testARMCPU("arm1176jzf-s", "armv6kz", "vfpv2",
136 EXPECT_TRUE(testARMCPU("arm1156t2-s", "armv6t2", "none",
138 EXPECT_TRUE(testARMCPU("arm1156t2f-s", "armv6t2", "vfpv2",
140 EXPECT_TRUE(testARMCPU("cortex-m0", "armv6-m", "none",
142 EXPECT_TRUE(testARMCPU("cortex-m0plus", "armv6-m", "none",
144 EXPECT_TRUE(testARMCPU("cortex-m1", "armv6-m", "none",
146 EXPECT_TRUE(testARMCPU("sc000", "armv6-m", "none",
148 EXPECT_TRUE(testARMCPU("cortex-a5", "armv7-a", "neon-vfpv4",
150 EXPECT_TRUE(testARMCPU("cortex-a7", "armv7-a", "neon-vfpv4",
154 EXPECT_TRUE(testARMCPU("cortex-a8", "armv7-a", "neon",
156 EXPECT_TRUE(testARMCPU("cortex-a9", "armv7-a", "neon-fp16",
158 EXPECT_TRUE(testARMCPU("cortex-a12", "armv7-a", "neon-vfpv4",
163 EXPECT_TRUE(testARMCPU("cortex-a15", "armv7-a", "neon-vfpv4",
168 EXPECT_TRUE(testARMCPU("cortex-a17", "armv7-a", "neon-vfpv4",
173 EXPECT_TRUE(testARMCPU("krait", "armv7-a", "neon-vfpv4",
176 EXPECT_TRUE(testARMCPU("cortex-r4", "armv7-r", "none",
178 EXPECT_TRUE(testARMCPU("cortex-r4f", "armv7-r", "vfpv3-d16",
180 EXPECT_TRUE(testARMCPU("cortex-r5", "armv7-r", "vfpv3-d16",
184 EXPECT_TRUE(testARMCPU("cortex-r7", "armv7-r", "vfpv3-d16-fp16",
188 EXPECT_TRUE(testARMCPU("cortex-r8", "armv7-r", "vfpv3-d16-fp16",
192 EXPECT_TRUE(testARMCPU("cortex-r52", "armv8-r", "neon-fp-armv8",
197 EXPECT_TRUE(
199 EXPECT_TRUE(
201 EXPECT_TRUE(testARMCPU("cortex-m4", "armv7e-m", "fpv4-sp-d16",
203 EXPECT_TRUE(testARMCPU("cortex-m7", "armv7e-m", "fpv5-d16",
205 EXPECT_TRUE(testARMCPU("cortex-a32", "armv8-a", "crypto-neon-fp-armv8",
210 EXPECT_TRUE(testARMCPU("cortex-a35", "armv8-a", "crypto-neon-fp-armv8",
215 EXPECT_TRUE(testARMCPU("cortex-a53", "armv8-a", "crypto-neon-fp-armv8",
220 EXPECT_TRUE(testARMCPU("cortex-a55", "armv8.2-a", "crypto-neon-fp-armv8",
226 EXPECT_TRUE(testARMCPU("cortex-a57", "armv8-a", "crypto-neon-fp-armv8",
231 EXPECT_TRUE(testARMCPU("cortex-a72", "armv8-a", "crypto-neon-fp-armv8",
236 EXPECT_TRUE(testARMCPU("cortex-a73", "armv8-a", "crypto-neon-fp-armv8",
241 EXPECT_TRUE(testARMCPU("cortex-a75", "armv8.2-a", "crypto-neon-fp-armv8",
247 EXPECT_TRUE(testARMCPU("cortex-a76", "armv8.2-a", "crypto-neon-fp-armv8",
253 EXPECT_TRUE(testARMCPU("cortex-a76ae", "armv8.2-a", "crypto-neon-fp-armv8",
259 EXPECT_TRUE(testARMCPU("neoverse-n1", "armv8.2-a", "crypto-neon-fp-armv8",
265 EXPECT_TRUE(testARMCPU("cyclone", "armv8-a", "crypto-neon-fp-armv8",
270 EXPECT_TRUE(testARMCPU("exynos-m1", "armv8-a", "crypto-neon-fp-armv8",
275 EXPECT_TRUE(testARMCPU("exynos-m2", "armv8-a", "crypto-neon-fp-armv8",
280 EXPECT_TRUE(testARMCPU("exynos-m3", "armv8-a", "crypto-neon-fp-armv8",
285 EXPECT_TRUE(testARMCPU("exynos-m4", "armv8.2-a", "crypto-neon-fp-armv8",
291 EXPECT_TRUE(testARMCPU("exynos-m5", "armv8.2-a", "crypto-neon-fp-armv8",
297 EXPECT_TRUE(testARMCPU("cortex-m23", "armv8-m.base", "none",
299 EXPECT_TRUE(testARMCPU("cortex-m33", "armv8-m.main", "fpv5-sp-d16",
301 EXPECT_TRUE(testARMCPU("cortex-m35p", "armv8-m.main", "fpv5-sp-d16",
303 EXPECT_TRUE(testARMCPU("iwmmxt", "iwmmxt", "none",
305 EXPECT_TRUE(testARMCPU("xscale", "xscale", "none",
307 EXPECT_TRUE(testARMCPU("swift", "armv7s", "neon-vfpv4",
342 EXPECT_TRUE(
345 EXPECT_TRUE(
348 EXPECT_TRUE(
351 EXPECT_TRUE(
354 EXPECT_TRUE(
357 EXPECT_TRUE(
360 EXPECT_TRUE(
363 EXPECT_TRUE(
366 EXPECT_TRUE(
369 EXPECT_TRUE(
372 EXPECT_TRUE(
375 EXPECT_TRUE(
378 EXPECT_TRUE(
381 EXPECT_TRUE(
384 EXPECT_TRUE(
387 EXPECT_TRUE(
390 EXPECT_TRUE(
393 EXPECT_TRUE(
396 EXPECT_TRUE(
399 EXPECT_TRUE(
402 EXPECT_TRUE(
405 EXPECT_TRUE(
408 EXPECT_TRUE(
411 EXPECT_TRUE(
414 EXPECT_TRUE(
417 EXPECT_TRUE(
420 EXPECT_TRUE(
423 EXPECT_TRUE(
426 EXPECT_TRUE(
429 EXPECT_TRUE(
432 EXPECT_TRUE(
435 EXPECT_TRUE(
438 EXPECT_TRUE(
441 EXPECT_TRUE(
483 EXPECT_TRUE(testARMExtension("cortex-a55",
487 EXPECT_TRUE(testARMExtension("cortex-a75",
598 EXPECT_TRUE(Found != std::end(Features));
599 EXPECT_TRUE(Extensions.size() == Features.size());
605 EXPECT_TRUE(Found != std::end(Features));
606 EXPECT_TRUE(Extensions.size() == Features.size());
615 EXPECT_TRUE((FK == ARM::FK_INVALID || FK >= ARM::FK_LAST)
764 EXPECT_TRUE(testAArch64CPU(
767 EXPECT_TRUE(testAArch64CPU(
771 EXPECT_TRUE(testAArch64CPU(
775 EXPECT_TRUE(testAArch64CPU(
779 EXPECT_TRUE(testAArch64CPU(
785 EXPECT_TRUE(testAArch64CPU(
789 EXPECT_TRUE(testAArch64CPU(
796 EXPECT_TRUE(testAArch64CPU(
803 EXPECT_TRUE(testAArch64CPU(
807 EXPECT_TRUE(testAArch64CPU(
811 EXPECT_TRUE(testAArch64CPU(
817 EXPECT_TRUE(testAArch64CPU(
823 EXPECT_TRUE(testAArch64CPU(
829 EXPECT_TRUE(testAArch64CPU(
832 EXPECT_TRUE(testAArch64CPU(
836 EXPECT_TRUE(testAArch64CPU(
840 EXPECT_TRUE(testAArch64CPU(
844 EXPECT_TRUE(testAArch64CPU(
850 EXPECT_TRUE(testAArch64CPU(
856 EXPECT_TRUE(testAArch64CPU(
860 EXPECT_TRUE(testAArch64CPU(
864 EXPECT_TRUE(testAArch64CPU(
871 EXPECT_TRUE(testAArch64CPU(
878 EXPECT_TRUE(testAArch64CPU(
882 EXPECT_TRUE(testAArch64CPU(
887 EXPECT_TRUE(testAArch64CPU(
892 EXPECT_TRUE(testAArch64CPU(
897 EXPECT_TRUE(testAArch64CPU(
902 EXPECT_TRUE(testAArch64CPU(
935 EXPECT_TRUE(testAArch64Arch("armv8-a", "cortex-a53", "v8",
937 EXPECT_TRUE(testAArch64Arch("armv8.1-a", "generic", "v8.1a",
939 EXPECT_TRUE(testAArch64Arch("armv8.2-a", "generic", "v8.2a",
941 EXPECT_TRUE(testAArch64Arch("armv8.3-a", "generic", "v8.3a",
943 EXPECT_TRUE(testAArch64Arch("armv8.4-a", "generic", "v8.4a",
945 EXPECT_TRUE(testAArch64Arch("armv8.5-a", "generic", "v8.5a",
960 EXPECT_TRUE(testAArch64Extension("cortex-a55",
968 EXPECT_TRUE(testAArch64Extension("cortex-a75",
978 EXPECT_TRUE(testAArch64Extension("exynos-m4",
980 EXPECT_TRUE(testAArch64Extension("exynos-m4",
982 EXPECT_TRUE(testAArch64Extension("exynos-m4",
984 EXPECT_TRUE(testAArch64Extension("exynos-m4",
986 EXPECT_TRUE(testAArch64Extension("exynos-m4",
988 EXPECT_TRUE(testAArch64Extension("exynos-m5",
990 EXPECT_TRUE(testAArch64Extension("exynos-m5",
992 EXPECT_TRUE(testAArch64Extension("exynos-m5",
994 EXPECT_TRUE(testAArch64Extension("exynos-m5",
996 EXPECT_TRUE(testAArch64Extension("exynos-m5",
998 EXPECT_TRUE(testAArch64Extension("falkor",
1002 EXPECT_TRUE(testAArch64Extension("saphira",
1004 EXPECT_TRUE(testAArch64Extension("saphira",
1006 EXPECT_TRUE(testAArch64Extension("saphira",
1008 EXPECT_TRUE(testAArch64Extension("saphira",
1010 EXPECT_TRUE(testAArch64Extension("saphira",
1012 EXPECT_TRUE(testAArch64Extension("saphira",
1016 EXPECT_TRUE(testAArch64Extension("cortex-a55",
1020 EXPECT_TRUE(testAArch64Extension("cortex-a55",
1022 EXPECT_TRUE(testAArch64Extension("cortex-a75",
1026 EXPECT_TRUE(testAArch64Extension("cortex-a75",
1038 EXPECT_TRUE(testAArch64Extension("tsv110",
1044 EXPECT_TRUE(testAArch64Extension("tsv110",
1046 EXPECT_TRUE(testAArch64Extension("tsv110",
1048 EXPECT_TRUE(testAArch64Extension("tsv110",
1050 EXPECT_TRUE(testAArch64Extension("tsv110",
1052 EXPECT_TRUE(testAArch64Extension("tsv110",
1094 EXPECT_TRUE(!Features.size());
1097 EXPECT_TRUE(Extensions.size() == Features.size());
1102 EXPECT_TRUE(std::find(B, E, "+crc") != E);
1103 EXPECT_TRUE(std::find(B, E, "+crypto") != E);
1104 EXPECT_TRUE(std::find(B, E, "+fp-armv8") != E);
1105 EXPECT_TRUE(std::find(B, E, "+neon") != E);
1106 EXPECT_TRUE(std::find(B, E, "+fullfp16") != E);
1107 EXPECT_TRUE(std::find(B, E, "+spe") != E);
1108 EXPECT_TRUE(std::find(B, E, "+ras") != E);
1109 EXPECT_TRUE(std::find(B, E, "+lse") != E);
1110 EXPECT_TRUE(std::find(B, E, "+rdm") != E);
1111 EXPECT_TRUE(std::find(B, E, "+dotprod") != E);
1112 EXPECT_TRUE(std::find(B, E, "+rcpc") != E);
1113 EXPECT_TRUE(std::find(B, E, "+fp16fml") != E);
1114 EXPECT_TRUE(std::find(B, E, "+sve") != E);
1115 EXPECT_TRUE(std::find(B, E, "+sve2") != E);
1116 EXPECT_TRUE(std::find(B, E, "+sve2-aes") != E);
1117 EXPECT_TRUE(std::find(B, E, "+sve2-sm4") != E);
1118 EXPECT_TRUE(std::find(B, E, "+sve2-sha3") != E);
1119 EXPECT_TRUE(std::find(B, E, "+sve2-bitperm") != E);
1126 EXPECT_TRUE((AK == AArch64::ArchKind::INVALID)
unittests/Support/TimerTest.cpp 37 EXPECT_TRUE(T1.isInitialized());
48 EXPECT_TRUE(TR1 < TR2);
56 EXPECT_TRUE(T1.hasTriggered());
58 EXPECT_TRUE(T1.hasTriggered());
unittests/Support/TrigramIndexTest.cpp 36 EXPECT_TRUE(TI->isDefinitelyOut("foo"));
43 EXPECT_TRUE(TI->isDefinitelyOut("foo"));
49 EXPECT_TRUE(TI->isDefeated());
58 EXPECT_TRUE(TI->isDefeated());
66 EXPECT_TRUE(TI->isDefinitelyOut("foo"));
67 EXPECT_TRUE(TI->isDefinitelyOut("bar"));
75 EXPECT_TRUE(TI->isDefeated());
81 EXPECT_TRUE(TI->isDefeated());
87 EXPECT_TRUE(TI->isDefeated());
93 EXPECT_TRUE(TI->isDefeated());
101 EXPECT_TRUE(TI->isDefinitelyOut("c\\+\\+"));
103 EXPECT_TRUE(TI->isDefinitelyOut("hello\\\\world"));
105 EXPECT_TRUE(TI->isDefinitelyOut("a\\tb"));
106 EXPECT_TRUE(TI->isDefinitelyOut("a\tb"));
113 EXPECT_TRUE(TI->isDefeated());
119 EXPECT_TRUE(TI->isDefeated());
127 EXPECT_TRUE(TI->isDefinitelyOut("class.h"));
128 EXPECT_TRUE(TI->isDefinitelyOut("class"));
unittests/Support/TypeNameTest.cpp 32 EXPECT_TRUE(S1Name.endswith("::N1::S1")) << S1Name.str();
33 EXPECT_TRUE(C1Name.endswith("::N1::C1")) << C1Name.str();
34 EXPECT_TRUE(U1Name.endswith("::N1::U1")) << U1Name.str();
36 EXPECT_TRUE(S2Name.endswith("S2")) << S2Name.str();
unittests/Support/UnicodeTest.cpp 66 EXPECT_TRUE(isPrintable(' '));
67 EXPECT_TRUE(isPrintable('A'));
68 EXPECT_TRUE(isPrintable('~'));
73 EXPECT_TRUE(isPrintable(0xAC));
74 EXPECT_TRUE(isPrintable(0xAD)); // SOFT HYPHEN is displayed on most terminals
76 EXPECT_TRUE(isPrintable(0xAE));
78 EXPECT_TRUE(isPrintable(0x0377)); // GREEK SMALL LETTER PAMPHYLIAN DIGAMMA
84 EXPECT_TRUE(isPrintable(0x20000)); // CJK UNIFIED IDEOGRAPH-20000
unittests/Support/VersionTupleTest.cpp 37 EXPECT_TRUE(VT.tryParse(""));
38 EXPECT_TRUE(VT.tryParse("1."));
39 EXPECT_TRUE(VT.tryParse("1.2."));
40 EXPECT_TRUE(VT.tryParse("1.2.3."));
41 EXPECT_TRUE(VT.tryParse("1.2.3.4."));
42 EXPECT_TRUE(VT.tryParse("1.2.3.4.5"));
43 EXPECT_TRUE(VT.tryParse("1-2"));
44 EXPECT_TRUE(VT.tryParse("1+2"));
45 EXPECT_TRUE(VT.tryParse(".1"));
46 EXPECT_TRUE(VT.tryParse(" 1"));
47 EXPECT_TRUE(VT.tryParse("1 "));
48 EXPECT_TRUE(VT.tryParse("."));
unittests/Support/VirtualFileSystemTest.cpp 193 EXPECT_TRUE(Status->isStatusKnown());
195 EXPECT_TRUE(Status->isRegularFile());
198 EXPECT_TRUE(Status->exists());
203 EXPECT_TRUE(Status->isStatusKnown());
204 EXPECT_TRUE(Status->isDirectory());
208 EXPECT_TRUE(Status->exists());
213 EXPECT_TRUE(Status->isStatusKnown());
216 EXPECT_TRUE(Status->isSymlink());
218 EXPECT_TRUE(Status->exists());
220 EXPECT_TRUE(Status->equivalent(*Status));
241 EXPECT_TRUE(Status->equivalent(*Status2));
303 EXPECT_TRUE(Status1->equivalent(*StatusB));
304 EXPECT_TRUE(Status2->equivalent(*StatusM));
305 EXPECT_TRUE(Status3->equivalent(*StatusT));
327 EXPECT_TRUE(Status1->equivalent(*Status2));
333 EXPECT_TRUE(Status1->equivalent(*Status2));
386 EXPECT_TRUE(Status->exists());
400 EXPECT_TRUE(Status->exists());
497 EXPECT_TRUE(I->path().endswith("a") || I->path().endswith("c"));
501 EXPECT_TRUE(I->path().endswith("a") || I->path().endswith("c"));
1234 EXPECT_TRUE(FS.addHardLink(FromLink, Target));
1236 EXPECT_TRUE(FS.status(FromLink)->getSize() == FS.status(Target)->getSize());
1237 EXPECT_TRUE(FS.getBufferForFile(FromLink)->get()->getBuffer() ==
1247 EXPECT_TRUE(FS.addHardLink(Link2, Target));
1248 EXPECT_TRUE(FS.addHardLink(Link1, Link2));
1249 EXPECT_TRUE(FS.addHardLink(Link0, Link1));
1271 EXPECT_TRUE(FS.addHardLink(Link, Target));
1279 EXPECT_TRUE(FS.addFile(Target, 0, MemoryBuffer::getMemBuffer(Content)));
1280 EXPECT_TRUE(FS.addHardLink(Link, Target));
1281 EXPECT_TRUE(FS.addFile(Link, 0, MemoryBuffer::getMemBuffer(Content)));
1289 EXPECT_TRUE(FS.addFile(Target, 0, MemoryBuffer::getMemBuffer(Content)));
1290 EXPECT_TRUE(FS.addHardLink(Link, Target));
1299 EXPECT_TRUE(FS.addFile(File, 0, MemoryBuffer::getMemBuffer(Content)));
1307 EXPECT_TRUE(FS.addFile(Target, 0, MemoryBuffer::getMemBuffer(Content)));
1321 EXPECT_TRUE(FS.addHardLink("/c/d", "/a/b"));
1412 EXPECT_TRUE(S->IsVFSMapped);
1416 EXPECT_TRUE(S->equivalent(*SLower));
1425 EXPECT_TRUE(OpenedS->IsVFSMapped);
1430 EXPECT_TRUE(S->isDirectory());
1431 EXPECT_TRUE(S->equivalent(*O->status("//root/"))); // non-volatile UniqueID
1467 EXPECT_TRUE(S->equivalent(*SS));
1469 EXPECT_TRUE(S->equivalent(*SS));
1471 EXPECT_TRUE(S->equivalent(*SS));
2047 EXPECT_TRUE(Status->isStatusKnown());
2049 EXPECT_TRUE(Status->isRegularFile());
2052 EXPECT_TRUE(Status->exists());
2103 EXPECT_TRUE(Status->exists());
2107 EXPECT_TRUE(Status->exists());
2114 EXPECT_TRUE(Status->exists());
2127 EXPECT_TRUE(Status->exists());
2160 EXPECT_TRUE(Status->exists());
unittests/Support/YAMLIOTest.cpp 104 EXPECT_TRUE(!!yin.error());
189 EXPECT_TRUE(!!yin.error());
198 EXPECT_TRUE(!!yin.error());
253 EXPECT_TRUE(!!yin.error());
402 EXPECT_TRUE(map.str.equals("hello there"));
403 EXPECT_TRUE(map.stdstr == "hello where?");
458 EXPECT_TRUE(map.str.equals("one two"));
459 EXPECT_TRUE(map.stdstr == "three four");
789 EXPECT_TRUE(map.str1.equals("'aaa"));
790 EXPECT_TRUE(map.str2.equals("\"bbb"));
791 EXPECT_TRUE(map.str3.equals("`ccc"));
792 EXPECT_TRUE(map.str4.equals("@ddd"));
793 EXPECT_TRUE(map.str5.equals(""));
794 EXPECT_TRUE(map.str6.equals("0000000004000000"));
795 EXPECT_TRUE(map.stdstr1 == "'eee");
796 EXPECT_TRUE(map.stdstr2 == "\"fff");
797 EXPECT_TRUE(map.stdstr3 == "`ggg");
798 EXPECT_TRUE(map.stdstr4 == "@hhh");
799 EXPECT_TRUE(map.stdstr5 == "");
800 EXPECT_TRUE(map.stdstr6 == "0000000004000000");
1150 EXPECT_TRUE(map2.warningLabels.str.empty());
1151 EXPECT_TRUE(map2.documentation.str.empty());
1323 EXPECT_TRUE(map2.name.equals("hello"));
1325 EXPECT_TRUE(map2.strings[0].value.equals("one"));
1326 EXPECT_TRUE(map2.strings[1].value.equals("two"));
1370 EXPECT_TRUE(map2.name.equals("hello"));
1378 EXPECT_TRUE(map2.sequenceOfNumbers[2].empty());
1805 EXPECT_TRUE(!!yin.error());
1911 EXPECT_TRUE(!!yin.error());
1929 EXPECT_TRUE(!!yin.error());
1947 EXPECT_TRUE(!!yin.error());
1965 EXPECT_TRUE(!!yin.error());
1983 EXPECT_TRUE(!!yin.error());
2001 EXPECT_TRUE(!!yin.error());
2020 EXPECT_TRUE(!!yin.error());
2038 EXPECT_TRUE(!!yin.error());
2057 EXPECT_TRUE(!!yin.error());
2076 EXPECT_TRUE(!!yin.error());
2095 EXPECT_TRUE(!!yin.error());
2113 EXPECT_TRUE(!!yin.error());
2132 EXPECT_TRUE(!!yin.error());
2150 EXPECT_TRUE(!!yin.error());
2168 EXPECT_TRUE(!!yin.error());
2186 EXPECT_TRUE(!!yin.error());
2204 EXPECT_TRUE(!!yin.error());
2223 EXPECT_TRUE(!!yin.error());
2241 EXPECT_TRUE(!!yin.error());
2259 EXPECT_TRUE(!!yin.error());
2269 EXPECT_TRUE(!!yin.error());
2275 EXPECT_TRUE(!!yin.error());
2333 EXPECT_TRUE(Seq2.Tests[0].Numbers.empty());
2334 EXPECT_TRUE(Seq2.Tests[1].Numbers.empty());
2340 EXPECT_TRUE(Seq2.Tests[3].Numbers.empty());
2347 EXPECT_TRUE(!!yin.error());
2363 EXPECT_TRUE(seq.empty());
2708 EXPECT_TRUE(isNumeric(".inf"));
2709 EXPECT_TRUE(isNumeric(".INF"));
2710 EXPECT_TRUE(isNumeric(".Inf"));
2711 EXPECT_TRUE(isNumeric("-.inf"));
2712 EXPECT_TRUE(isNumeric("+.inf"));
2714 EXPECT_TRUE(isNumeric(".nan"));
2715 EXPECT_TRUE(isNumeric(".NaN"));
2716 EXPECT_TRUE(isNumeric(".NAN"));
2718 EXPECT_TRUE(isNumeric("0"));
2719 EXPECT_TRUE(isNumeric("0."));
2720 EXPECT_TRUE(isNumeric("0.0"));
2721 EXPECT_TRUE(isNumeric("-0.0"));
2722 EXPECT_TRUE(isNumeric("+0.0"));
2724 EXPECT_TRUE(isNumeric("12345"));
2725 EXPECT_TRUE(isNumeric("012345"));
2726 EXPECT_TRUE(isNumeric("+12.0"));
2727 EXPECT_TRUE(isNumeric(".5"));
2728 EXPECT_TRUE(isNumeric("+.5"));
2729 EXPECT_TRUE(isNumeric("-1.0"));
2731 EXPECT_TRUE(isNumeric("2.3e4"));
2732 EXPECT_TRUE(isNumeric("-2E+05"));
2733 EXPECT_TRUE(isNumeric("+12e03"));
2734 EXPECT_TRUE(isNumeric("6.8523015e+5"));
2736 EXPECT_TRUE(isNumeric("1.e+1"));
2737 EXPECT_TRUE(isNumeric(".0e+1"));
2739 EXPECT_TRUE(isNumeric("0x2aF3"));
2740 EXPECT_TRUE(isNumeric("0o01234567"));
2970 EXPECT_TRUE(first->BoolValue);
unittests/Support/YAMLParserTest.cpp 36 EXPECT_TRUE(Stream.failed()) << Message << ": " << Input;
43 EXPECT_TRUE(Stream.validate()) << Message << ": " << Input;
272 EXPECT_TRUE(Begin != End);
288 EXPECT_TRUE(Begin == Begin);
289 EXPECT_TRUE(End == End);
308 EXPECT_TRUE(Begin != AnotherBegin);
309 EXPECT_TRUE(Begin != AnotherEnd);
331 EXPECT_TRUE(End == AnotherEnd);
unittests/TableGen/AutomataTest.cpp 34 EXPECT_TRUE(A.add(SK_a));
36 EXPECT_TRUE(A.add(SK_b));
38 EXPECT_TRUE(A.add(SK_c));
47 EXPECT_TRUE(A.add(SK_a));
48 EXPECT_TRUE(A.add(SK_b));
52 EXPECT_TRUE(A.add(SK_a));
57 EXPECT_TRUE(A.add(SK_c));
64 EXPECT_TRUE(
73 EXPECT_TRUE(
82 EXPECT_TRUE(A.add(SK_a));
83 EXPECT_TRUE(A.add(SK_a));
85 EXPECT_TRUE(A.add(SK_a));
86 EXPECT_TRUE(A.add(SK_b));
88 EXPECT_TRUE(A.add(SK_b));
89 EXPECT_TRUE(A.add(SK_a));
91 EXPECT_TRUE(A.add(SK_b));
92 EXPECT_TRUE(A.add(SK_b));
96 EXPECT_TRUE(A.add(SK_b));
97 EXPECT_TRUE(A.add(SK_b));
106 EXPECT_TRUE(A.add(BRK_0_to_4_dbl));
107 EXPECT_TRUE(A.add(BRK_0_to_4_dbl));
113 EXPECT_TRUE(A.add(BRK_0_to_4_dbl));
114 EXPECT_TRUE(A.add(BRK_0_to_4_dbl));
115 EXPECT_TRUE(A.add(BRK_0_to_6));
116 EXPECT_TRUE(A.add(BRK_0_to_6));
123 EXPECT_TRUE(A.add(BRK_0_to_6));
135 EXPECT_TRUE(A.add(BRK_0_to_4_dbl));
136 EXPECT_TRUE(A.add(BRK_0_to_4_dbl));
137 EXPECT_TRUE(A.add(BRK_0_to_6));
unittests/Target/AArch64/TestStackOffset.cpp 70 EXPECT_TRUE(!A);
71 EXPECT_TRUE(!(A + B));
74 EXPECT_TRUE(!(A + C));
82 EXPECT_TRUE(StackOffset(2, MVT::nxv8i1).isValid());
unittests/Target/X86/MachineSizeOptsTest.cpp 117 EXPECT_TRUE(shouldOptimizeForSize(G, &PSI, MBFI_G));
121 EXPECT_TRUE(shouldOptimizeForSize(BB2, &PSI, MBFI_F));
unittests/TextAPI/ELFYAMLTest.cpp 73 EXPECT_TRUE(Stub->SoName.hasValue());
100 EXPECT_TRUE(SymFoo.Warning.hasValue());
107 EXPECT_TRUE(SymNor.Undefined);
115 EXPECT_TRUE(SymNot.Undefined);
116 EXPECT_TRUE(SymNot.Weak);
117 EXPECT_TRUE(SymNot.Warning.hasValue());
unittests/TextAPI/TextStubV1Tests.cpp 86 EXPECT_TRUE(!!Result);
102 EXPECT_TRUE(File->isTwoLevelNamespace());
103 EXPECT_TRUE(File->isApplicationExtensionSafe());
123 EXPECT_TRUE(
139 EXPECT_TRUE(!!Result);
155 EXPECT_TRUE(File->isTwoLevelNamespace());
156 EXPECT_TRUE(File->isApplicationExtensionSafe());
224 EXPECT_TRUE(!!Result);
241 EXPECT_TRUE(!!Result);
258 EXPECT_TRUE(!!Result);
275 EXPECT_TRUE(!!Result);
292 EXPECT_TRUE(!!Result);
310 EXPECT_TRUE(!!Result);
326 EXPECT_TRUE(!!Result);
342 EXPECT_TRUE(!!Result);
358 EXPECT_TRUE(!!Result);
390 EXPECT_TRUE(!!Result);
406 EXPECT_TRUE(!!Result);
422 EXPECT_TRUE(!!Result);
unittests/TextAPI/TextStubV2Tests.cpp 88 EXPECT_TRUE(!!Result);
104 EXPECT_TRUE(File->isTwoLevelNamespace());
105 EXPECT_TRUE(File->isApplicationExtensionSafe());
106 EXPECT_TRUE(File->isInstallAPI());
125 EXPECT_TRUE(
159 EXPECT_TRUE(!!Result);
245 EXPECT_TRUE(!!Result);
262 EXPECT_TRUE(!!Result);
279 EXPECT_TRUE(!!Result);
296 EXPECT_TRUE(!!Result);
313 EXPECT_TRUE(!!Result);
331 EXPECT_TRUE(!!Result);
347 EXPECT_TRUE(!!Result);
363 EXPECT_TRUE(!!Result);
379 EXPECT_TRUE(!!Result);
411 EXPECT_TRUE(!!Result);
427 EXPECT_TRUE(!!Result);
442 EXPECT_TRUE(!!Result);
unittests/TextAPI/TextStubV3Tests.cpp 92 EXPECT_TRUE(!!Result);
113 EXPECT_TRUE(File->isTwoLevelNamespace());
114 EXPECT_TRUE(File->isApplicationExtensionSafe());
115 EXPECT_TRUE(File->isInstallAPI());
134 EXPECT_TRUE(
201 EXPECT_TRUE(!!Result);
218 EXPECT_TRUE(!!Result);
235 EXPECT_TRUE(!!Result);
252 EXPECT_TRUE(!!Result);
269 EXPECT_TRUE(!!Result);
286 EXPECT_TRUE(!!Result);
302 EXPECT_TRUE(!!Result);
324 EXPECT_TRUE(!!Result);
340 EXPECT_TRUE(!!Result);
356 EXPECT_TRUE(!!Result);
372 EXPECT_TRUE(!!Result);
404 EXPECT_TRUE(!!Result);
420 EXPECT_TRUE(!!Result);
436 EXPECT_TRUE(!!Result);
unittests/TextAPI/TextStubV4Tests.cpp 109 EXPECT_TRUE(!!Result);
134 EXPECT_TRUE(File->isApplicationExtensionSafe());
135 EXPECT_TRUE(File->isInstallAPI());
166 EXPECT_TRUE(std::equal(Exports.begin(), Exports.end(),
168 EXPECT_TRUE(std::equal(Reexports.begin(), Reexports.end(),
170 EXPECT_TRUE(std::equal(Undefineds.begin(), Undefineds.end(),
247 EXPECT_TRUE(!!Result);
270 EXPECT_TRUE(!!Result);
292 EXPECT_TRUE(!!Result);
310 EXPECT_TRUE(!!Result);
327 EXPECT_TRUE(!!Result);
344 EXPECT_TRUE(!!Result);
360 EXPECT_TRUE(!!Result);
377 EXPECT_TRUE(!!Result);
395 EXPECT_TRUE(!!Result);
413 EXPECT_TRUE(!!Result);
430 EXPECT_TRUE(!!Result);
445 EXPECT_TRUE(!!Result);
460 EXPECT_TRUE(!!Result);
475 EXPECT_TRUE(!!Result);
unittests/Transforms/IPO/LowerTypeTests.cpp 68 EXPECT_TRUE(BSI.containsGlobalOffset(Offset));
unittests/Transforms/Scalar/LoopPassManagerTest.cpp 968 EXPECT_TRUE(AR.DT.verify());
1010 EXPECT_TRUE(AR.DT.verify());
1156 EXPECT_TRUE(AR.DT.verify());
1223 EXPECT_TRUE(AR.DT.verify());
1278 EXPECT_TRUE(AR.DT.verify());
1516 EXPECT_TRUE(AR.DT.verify());
unittests/Transforms/Utils/BasicBlockUtilsTest.cpp 53 EXPECT_TRUE(Result);
55 EXPECT_TRUE(DT.verify());
83 EXPECT_TRUE(DT.verify());
109 EXPECT_TRUE(DT.verify());
136 EXPECT_TRUE(DT.verify());
137 EXPECT_TRUE(PDT.verify());
unittests/Transforms/Utils/CloningTest.cpp 95 EXPECT_TRUE(AddClone->hasNoUnsignedWrap());
97 EXPECT_TRUE(SubClone->hasNoUnsignedWrap());
99 EXPECT_TRUE(MulClone->hasNoUnsignedWrap());
112 EXPECT_TRUE(AddClone->hasNoUnsignedWrap());
113 EXPECT_TRUE(AddClone->hasNoSignedWrap());
114 EXPECT_TRUE(SubClone->hasNoUnsignedWrap());
115 EXPECT_TRUE(SubClone->hasNoSignedWrap());
116 EXPECT_TRUE(MulClone->hasNoUnsignedWrap());
117 EXPECT_TRUE(MulClone->hasNoSignedWrap());
130 EXPECT_TRUE(AddClone->hasNoSignedWrap());
132 EXPECT_TRUE(SubClone->hasNoSignedWrap());
134 EXPECT_TRUE(MulClone->hasNoSignedWrap());
148 EXPECT_TRUE(this->clone(GEP)->isInBounds());
158 EXPECT_TRUE(this->clone(SDiv)->isExact());
235 EXPECT_TRUE(Split);
237 EXPECT_TRUE(Mapping.find(AddInst) != Mapping.end());
238 EXPECT_TRUE(Mapping.find(MulInst) != Mapping.end());
241 EXPECT_TRUE(AddSplit);
247 EXPECT_TRUE(MulSplit);
284 EXPECT_TRUE(Split);
286 EXPECT_TRUE(Mapping.find(AddInst) != Mapping.end());
287 EXPECT_TRUE(Mapping.find(MulInst) != Mapping.end());
288 EXPECT_TRUE(Mapping.find(SubInst) != Mapping.end());
291 EXPECT_TRUE(AddSplit);
297 EXPECT_TRUE(MulSplit);
337 EXPECT_TRUE(Split);
339 EXPECT_TRUE(Mapping.find(AddInst) != Mapping.end());
340 EXPECT_TRUE(Mapping.find(MulInst) != Mapping.end());
343 EXPECT_TRUE(AddSplit);
349 EXPECT_TRUE(MulSplit);
437 EXPECT_TRUE((*BI)->getName().startswith("for.outer"));
438 EXPECT_TRUE((*(++BI))->getName().startswith("for.inner.preheader"));
439 EXPECT_TRUE((*(++BI))->getName().startswith("for.inner"));
440 EXPECT_TRUE((*(++BI))->getName().startswith("for.inner.exit"));
441 EXPECT_TRUE((*(++BI))->getName().startswith("for.outer.latch"));
615 EXPECT_TRUE(NewIntrin);
638 EXPECT_TRUE(NewIntrin);
686 EXPECT_TRUE(ImplModule != nullptr);
688 EXPECT_TRUE(GetDICompileUnitCount(*ImplModule) == 2);
690 EXPECT_TRUE(ImplFunction != nullptr);
693 EXPECT_TRUE(DeclModule != nullptr);
695 EXPECT_TRUE(GetDICompileUnitCount(*DeclModule) == 0);
697 EXPECT_TRUE(DeclFunction != nullptr);
708 EXPECT_TRUE(GetDICompileUnitCount(*DeclModule) == 1);
797 EXPECT_TRUE(SP != nullptr);
810 EXPECT_TRUE(NewGV != nullptr);
819 EXPECT_TRUE(GV != nullptr);
827 EXPECT_TRUE(SP != nullptr);
834 EXPECT_TRUE(NMD != nullptr);
838 EXPECT_TRUE(CU != nullptr);
842 EXPECT_TRUE(SP != nullptr);
unittests/Transforms/Utils/CodeExtractorTest.cpp 63 EXPECT_TRUE(CE.isEligible());
67 EXPECT_TRUE(Outlined);
72 EXPECT_TRUE(Exit && cast<PHINode>(Exit->front()).getNumIncomingValues() == 1);
74 EXPECT_TRUE(ExitSplit &&
114 EXPECT_TRUE(CE.isEligible());
118 EXPECT_TRUE(Outlined);
123 EXPECT_TRUE(Exit1 &&
125 EXPECT_TRUE(Exit2 &&
189 EXPECT_TRUE(CE.isEligible());
193 EXPECT_TRUE(Outlined);
224 EXPECT_TRUE(CE.isEligible());
228 EXPECT_TRUE(Outlined);
276 EXPECT_TRUE(CE.isEligible());
280 EXPECT_TRUE(Outlined);
unittests/Transforms/Utils/FunctionComparatorTest.cpp 117 EXPECT_TRUE(Cmp.testFunctionAccess(F1.F, F2.F));
126 EXPECT_TRUE(needToCmpOperands);
unittests/Transforms/Utils/IntegerDivisionTest.cpp 41 EXPECT_TRUE(BB->front().getOpcode() == Instruction::SDiv);
46 EXPECT_TRUE(BB->front().getOpcode() == Instruction::AShr);
49 EXPECT_TRUE(Quotient && Quotient->getOpcode() == Instruction::Sub);
71 EXPECT_TRUE(BB->front().getOpcode() == Instruction::UDiv);
76 EXPECT_TRUE(BB->front().getOpcode() == Instruction::ICmp);
79 EXPECT_TRUE(Quotient && Quotient->getOpcode() == Instruction::PHI);
101 EXPECT_TRUE(BB->front().getOpcode() == Instruction::SRem);
106 EXPECT_TRUE(BB->front().getOpcode() == Instruction::AShr);
109 EXPECT_TRUE(Remainder && Remainder->getOpcode() == Instruction::Sub);
131 EXPECT_TRUE(BB->front().getOpcode() == Instruction::URem);
136 EXPECT_TRUE(BB->front().getOpcode() == Instruction::ICmp);
139 EXPECT_TRUE(Remainder && Remainder->getOpcode() == Instruction::Sub);
162 EXPECT_TRUE(BB->front().getOpcode() == Instruction::SDiv);
167 EXPECT_TRUE(BB->front().getOpcode() == Instruction::AShr);
170 EXPECT_TRUE(Quotient && Quotient->getOpcode() == Instruction::Sub);
192 EXPECT_TRUE(BB->front().getOpcode() == Instruction::UDiv);
197 EXPECT_TRUE(BB->front().getOpcode() == Instruction::ICmp);
200 EXPECT_TRUE(Quotient && Quotient->getOpcode() == Instruction::PHI);
222 EXPECT_TRUE(BB->front().getOpcode() == Instruction::SRem);
227 EXPECT_TRUE(BB->front().getOpcode() == Instruction::AShr);
230 EXPECT_TRUE(Remainder && Remainder->getOpcode() == Instruction::Sub);
252 EXPECT_TRUE(BB->front().getOpcode() == Instruction::URem);
257 EXPECT_TRUE(BB->front().getOpcode() == Instruction::ICmp);
260 EXPECT_TRUE(Remainder && Remainder->getOpcode() == Instruction::Sub);
unittests/Transforms/Utils/LocalTest.cpp 45 EXPECT_TRUE(RecursivelyDeleteDeadPHINode(phi));
54 EXPECT_TRUE(RecursivelyDeleteDeadPHINode(phi));
60 EXPECT_TRUE(RecursivelyDeleteDeadPHINode(phi));
101 EXPECT_TRUE(EliminateDuplicatePHINodes(BB));
224 EXPECT_TRUE(DTU.getDomTree().verify());
227 EXPECT_TRUE(DTU.getPostDomTree().verify());
443 EXPECT_TRUE(DTU.getDomTree().verify());
444 EXPECT_TRUE(DTU.getPostDomTree().verify());
455 EXPECT_TRUE(DTU.getDomTree().verify());
456 EXPECT_TRUE(DTU.getPostDomTree().verify());
732 EXPECT_TRUE(replaceAllDbgUsesWith(D, C, C, DT));
737 EXPECT_TRUE(any_of(CDbgVals, [](DbgVariableIntrinsic *DII) {
740 EXPECT_TRUE(any_of(CDbgVals, [](DbgVariableIntrinsic *DII) {
744 EXPECT_TRUE(replaceAllDbgUsesWith(C, D, D, DT));
749 EXPECT_TRUE(any_of(DDbgVals, [](DbgVariableIntrinsic *DII) {
752 EXPECT_TRUE(any_of(DDbgVals, [](DbgVariableIntrinsic *DII) {
757 EXPECT_TRUE(replaceAllDbgUsesWith(A, F_, F_, DT));
763 EXPECT_TRUE(replaceAllDbgUsesWith(F_, G, G, DT));
775 EXPECT_TRUE(replaceAllDbgUsesWith(B, A, A, DT));
790 EXPECT_TRUE(hasADbgVal({DW_OP_LLVM_convert, 32, DW_ATE_signed,
796 EXPECT_TRUE(hasADbgVal({DW_OP_lit0, DW_OP_mul, DW_OP_deref,
802 EXPECT_TRUE(hasADbgVal({DW_OP_lit0, DW_OP_mul, DW_OP_LLVM_convert, 32,
807 EXPECT_TRUE(hasADbgVal({DW_OP_LLVM_convert, 32, DW_ATE_signed,
811 EXPECT_TRUE(hasADbgVal({DW_OP_lit0, DW_OP_mul, DW_OP_deref,
816 EXPECT_TRUE(hasADbgVal({DW_OP_lit0, DW_OP_mul, DW_OP_LLVM_convert, 32,
906 EXPECT_TRUE(DTU.getDomTree().verify());
907 EXPECT_TRUE(DTU.getPostDomTree().verify());
914 EXPECT_TRUE(DTU.getDomTree().verify());
915 EXPECT_TRUE(DTU.getPostDomTree().verify());
944 EXPECT_TRUE(removeUnreachableBlocks(F, &DTU));
946 EXPECT_TRUE(DTU.getDomTree().verify());
unittests/Transforms/Utils/SizeOptsTest.cpp 70 EXPECT_TRUE(PSI.hasProfileSummary());
72 EXPECT_TRUE(shouldOptimizeForSize(G, &PSI, BFI_G));
76 EXPECT_TRUE(shouldOptimizeForSize(BB2, &PSI, BFI_F));
unittests/Transforms/Utils/ValueMapperTest.cpp 44 EXPECT_TRUE(U0->isResolved());
45 EXPECT_TRUE(U0->isUniqued());
46 EXPECT_TRUE(U1->isResolved());
47 EXPECT_TRUE(U1->isUniqued());
103 EXPECT_TRUE(MappedN0->isResolved());
104 EXPECT_TRUE(MappedN1->isResolved());
209 EXPECT_TRUE(VM.hasMD());
260 EXPECT_TRUE(F2MD);
317 EXPECT_TRUE(VM.count(MAV));
323 EXPECT_TRUE(VM.count(MAV));
343 EXPECT_TRUE(isa<LocalAsMetadata>(MDA->getMetadata()));
344 EXPECT_TRUE(isa<ConstantAsMetadata>(MDC->getMetadata()));
unittests/Transforms/Vectorize/VPlanDominatorTreeTest.cpp 58 EXPECT_TRUE(VPDT.isReachableFromEntry(PH));
59 EXPECT_TRUE(VPDT.isReachableFromEntry(H));
60 EXPECT_TRUE(VPDT.isReachableFromEntry(IfThen));
61 EXPECT_TRUE(VPDT.isReachableFromEntry(IfElse));
62 EXPECT_TRUE(VPDT.isReachableFromEntry(Latch));
63 EXPECT_TRUE(VPDT.isReachableFromEntry(Exit));
66 EXPECT_TRUE(VPDT.dominates(PH, PH));
67 EXPECT_TRUE(VPDT.dominates(PH, H));
68 EXPECT_TRUE(VPDT.dominates(PH, IfThen));
69 EXPECT_TRUE(VPDT.dominates(PH, IfElse));
70 EXPECT_TRUE(VPDT.dominates(PH, Latch));
71 EXPECT_TRUE(VPDT.dominates(PH, Exit));
74 EXPECT_TRUE(VPDT.dominates(H, H));
75 EXPECT_TRUE(VPDT.dominates(H, IfThen));
76 EXPECT_TRUE(VPDT.dominates(H, IfElse));
77 EXPECT_TRUE(VPDT.dominates(H, Latch));
78 EXPECT_TRUE(VPDT.dominates(H, Exit));
82 EXPECT_TRUE(VPDT.dominates(IfThen, IfThen));
90 EXPECT_TRUE(VPDT.dominates(IfElse, IfElse));
98 EXPECT_TRUE(VPDT.dominates(Latch, Latch));
99 EXPECT_TRUE(VPDT.dominates(Latch, Exit));
106 EXPECT_TRUE(VPDT.dominates(Exit, Exit));
110 EXPECT_TRUE(VPDT.properlyDominates(PH, H));
111 EXPECT_TRUE(VPDT.properlyDominates(PH, IfThen));
112 EXPECT_TRUE(VPDT.properlyDominates(PH, IfElse));
113 EXPECT_TRUE(VPDT.properlyDominates(PH, Latch));
114 EXPECT_TRUE(VPDT.properlyDominates(PH, Exit));
118 EXPECT_TRUE(VPDT.properlyDominates(H, IfThen));
119 EXPECT_TRUE(VPDT.properlyDominates(H, IfElse));
120 EXPECT_TRUE(VPDT.properlyDominates(H, Latch));
121 EXPECT_TRUE(VPDT.properlyDominates(H, Exit));
142 EXPECT_TRUE(VPDT.properlyDominates(Latch, Exit));
unittests/Transforms/Vectorize/VPlanLoopInfoTest.cpp 67 EXPECT_TRUE(VPLp->contains(H));
69 EXPECT_TRUE(VPLp->contains(IfThen));
71 EXPECT_TRUE(VPLp->contains(IfElse));
73 EXPECT_TRUE(VPLp->contains(Latch));
unittests/Transforms/Vectorize/VPlanPredicatorTest.cpp 225 EXPECT_TRUE(ValidOrOperands);
unittests/Transforms/Vectorize/VPlanSlpTest.cpp 313 EXPECT_TRUE(Slp.isCompletelySLP());
unittests/Transforms/Vectorize/VPlanTest.cpp 59 EXPECT_TRUE(VPBB1.empty());
unittests/Transforms/Vectorize/VPlanTestBase.h 39 EXPECT_TRUE(M);
unittests/XRay/GraphTest.cpp 192 EXPECT_TRUE(G.vertices().empty());
193 EXPECT_TRUE(G.edges().empty());
208 EXPECT_TRUE(!!T);
214 EXPECT_TRUE(G.edges().empty());
220 EXPECT_TRUE(G.outEdges(0u).empty());
223 EXPECT_TRUE(G.inEdges(0u).empty());
239 EXPECT_TRUE(T && T->EA == 2u);
unittests/XRay/ProfileTest.cpp 49 EXPECT_TRUE(errorToBool(P.addBlock({})));
52 EXPECT_TRUE(errorToBool(P.addBlock({1, {}})));
unittests/tools/llvm-cfi-verify/FileAnalysis.cpp 119 EXPECT_TRUE(InstrMeta->Valid);
131 EXPECT_TRUE(InstrMeta->Valid);
143 EXPECT_TRUE(InstrMeta->Valid);
155 EXPECT_TRUE(InstrMeta->Valid);
167 EXPECT_TRUE(InstrMeta->Valid);
258 EXPECT_TRUE(
280 EXPECT_TRUE(
282 EXPECT_TRUE(
296 EXPECT_TRUE(
419 EXPECT_TRUE(XRefs.empty());
440 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty());
444 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty());
453 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty());
463 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty());
467 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty());
471 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty());
486 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty());
490 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty());
494 EXPECT_TRUE(Analysis.getDirectControlFlowXRefs(*InstrMetaPtr).empty());
unittests/tools/llvm-exegesis/Common/AssemblerUtils.h 66 EXPECT_TRUE(TheTarget) << Error << " " << TT;
70 EXPECT_TRUE(TM) << TT << " " << CpuName;
unittests/tools/llvm-exegesis/X86/SnippetFileTest.cpp 94 EXPECT_TRUE((bool)Error);
104 EXPECT_TRUE((bool)Error);
114 EXPECT_TRUE((bool)Error);
unittests/tools/llvm-exegesis/X86/SnippetGeneratorTest.cpp 157 EXPECT_TRUE((bool)Error);
382 EXPECT_TRUE((bool)Error);
unittests/tools/llvm-exegesis/X86/TargetTest.cpp 141 EXPECT_TRUE(State.getRATC().reservedRegisters().test(X86::AH));
utils/unittest/googletest/src/gtest-port.cc 616 EXPECT_TRUE(is_valid_)