|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
tools/clang/tools/extra/clangd/unittests/BackgroundIndexTests.cpp 207 EXPECT_EQ(CacheHits, 0U);
208 EXPECT_EQ(Storage.size(), 2U);
217 EXPECT_EQ(CacheHits, 2U); // Check both A.cc and A.h loaded from cache.
218 EXPECT_EQ(Storage.size(), 2U);
245 EXPECT_EQ(ShardSource->Relations->size(), 0u);
278 EXPECT_EQ(ShardSource->Sources->size(), 2U); // A.cc, A.h
289 EXPECT_EQ(ShardHeader->Sources->size(), 2U); // A.h, B.h
340 EXPECT_EQ(CacheHits, 2U); // Check both A.cc and A.h loaded from cache.
358 EXPECT_EQ(CacheHits, 2U); // Check both A.cc and A.h loaded from cache.
415 EXPECT_EQ(CacheHits, 3U);
431 EXPECT_EQ(CacheHits, 3U);
555 EXPECT_EQ(CmdStored.CommandLine, Cmd.CommandLine);
556 EXPECT_EQ(CmdStored.Directory, Cmd.Directory);
569 EXPECT_EQ(CmdStored.CommandLine, Cmd.CommandLine);
570 EXPECT_EQ(CmdStored.Directory, Cmd.Directory);
677 EXPECT_EQ(LoRan, 0u);
695 EXPECT_EQ("BA", Sequence) << "priority order";
703 EXPECT_EQ("AB", Sequence) << "A was boosted before enqueueing";
711 EXPECT_EQ("AB", Sequence) << "A was boosted after enqueueing";
tools/clang/tools/extra/clangd/unittests/CanonicalIncludesTests.cpp 23 EXPECT_EQ("<stdio.h>", CI.mapHeader("path/stdio.h", "printf"));
33 EXPECT_EQ("<vector>", CI.mapHeader("path/vector.h", "std::vector"));
34 EXPECT_EQ("<cstdio>", CI.mapHeader("path/stdio.h", "std::printf"));
36 EXPECT_EQ("<utility>", CI.mapHeader("libstdc++/bits/move.h", "std::move"));
37 EXPECT_EQ("path/utility.h", CI.mapHeader("path/utility.h", "std::move"));
39 EXPECT_EQ("foo/bar.h", CI.mapHeader("foo/bar.h", "std::notathing"));
41 EXPECT_EQ("<ostream>", CI.mapHeader("iosfwd", "std::ostream"));
43 EXPECT_EQ("<iosfwd>", CI.mapHeader("iosfwd", "std::notwathing"));
51 EXPECT_EQ("<baz>", CI.mapHeader("foo/bar", "some::symbol"));
52 EXPECT_EQ("bar/bar", CI.mapHeader("bar/bar", "some::symbol"));
63 EXPECT_EQ("<vector>", CI.mapHeader("foo/bar", "std::vector"));
64 EXPECT_EQ("foo/bar", CI.mapHeader("foo/bar", "other::symbol"));
82 EXPECT_EQ("<map>", CI.mapHeader("bits/stl_vector.h", "std::map"));
83 EXPECT_EQ("<map>", CI.mapHeader("some/path", "std::map"));
tools/clang/tools/extra/clangd/unittests/ClangdTests.cpp 155 EXPECT_EQ(ExpectErrors, DiagConsumer.hadErrorInLastDiags());
174 EXPECT_EQ(Empty, Empty2);
175 EXPECT_EQ(OneDecl, OneDecl2);
176 EXPECT_EQ(SomeDecls, SomeDecls2);
226 EXPECT_EQ(DumpParse1, DumpParse2);
264 EXPECT_EQ(DumpParse1, DumpParse2);
293 EXPECT_EQ(FS.Got, 42);
294 EXPECT_EQ(DiagConsumer.Got, 42);
532 EXPECT_EQ(runDumpAST(Server, FooCpp), "<no-ast>");
855 EXPECT_EQ(Expected, *Changed);
956 EXPECT_EQ(CountStats["foo.h"], Before);
1007 EXPECT_EQ(Res.Context, CodeCompletionContext::CCC_Recovery);
1077 EXPECT_EQ(Res.Context, CodeCompletionContext::CCC_Recovery);
tools/clang/tools/extra/clangd/unittests/CodeCompleteTests.cpp 658 EXPECT_EQ(Results.Completions.size(), Opts.Limit);
1078 EXPECT_EQ(0, Results.activeSignature);
1079 EXPECT_EQ(0, Results.activeParameter);
1092 EXPECT_EQ(0, Results.activeSignature);
1093 EXPECT_EQ(0, Results.activeParameter);
1103 EXPECT_EQ(0, Results.activeSignature);
1104 EXPECT_EQ(1, Results.activeParameter);
1149 EXPECT_EQ(signatures(Code.code(), Code.point()).argListStart,
1204 EXPECT_EQ(Reqs.size(), Num);
1243 EXPECT_EQ(Requests[0].Scopes[0], "nx::ns::");
1442 EXPECT_EQ(A.Name, "a");
1443 EXPECT_EQ(A.Signature, "(…)");
1444 EXPECT_EQ(A.BundleSize, 2u);
1445 EXPECT_EQ(A.Kind, CompletionItemKind::Method);
1446 EXPECT_EQ(A.ReturnType, "int"); // All overloads return int.
1450 EXPECT_EQ(A.SnippetSuffix, "($0)");
1613 EXPECT_EQ(R.label, "Foo::x(bool) const");
1614 EXPECT_EQ(R.insertText, "Foo::x");
1615 EXPECT_EQ(R.insertTextFormat, InsertTextFormat::PlainText);
1616 EXPECT_EQ(R.filterText, "x");
1617 EXPECT_EQ(R.detail, "int\n\"foo.h\"");
1618 EXPECT_EQ(R.documentation, "This is x().");
1620 EXPECT_EQ(R.sortText, sortText(1.0, "x"));
1625 EXPECT_EQ(R.insertText, "Foo::x(${0:bool})");
1626 EXPECT_EQ(R.insertTextFormat, InsertTextFormat::Snippet);
1630 EXPECT_EQ(R.label, "^Foo::x(bool) const");
1635 EXPECT_EQ(R.label, "^[AS]Foo::x(bool) const");
1639 EXPECT_EQ(R.detail, "[2 overloads]\n\"foo.h\"");
1712 EXPECT_EQ(Results.Completions.size(), 3u);
1752 EXPECT_EQ(Results.Completions.size(), 3u);
1781 EXPECT_EQ(R.textEdit->newText, "->Foo::x");
1801 EXPECT_EQ(R.textEdit->newText, "Foo::x");
1836 EXPECT_EQ(Results.Completions.size(), 1u);
1858 EXPECT_EQ(0, Results.activeSignature);
1859 EXPECT_EQ(0, Results.activeParameter);
2125 EXPECT_EQ(WantQualifier, Prefix.Qualifier) << Case;
2126 EXPECT_EQ(WantQualifier.begin(), Prefix.Qualifier.begin()) << Case;
2127 EXPECT_EQ(WantName, Prefix.Name) << Case;
2128 EXPECT_EQ(WantName.begin(), Prefix.Name.begin()) << Case;
2165 EXPECT_EQ(Reqs2[0], Reqs1[0]);
2184 EXPECT_EQ(Results[0].Includes.size(), 2u);
2266 EXPECT_EQ(0, Results.activeParameter);
2277 EXPECT_EQ(0, Results.activeParameter);
2288 EXPECT_EQ(0, Results.activeParameter);
2299 EXPECT_EQ(1, Results.activeParameter);
tools/clang/tools/extra/clangd/unittests/CodeCompletionStringsTests.cpp 43 EXPECT_EQ(getReturnType(*Builder.TakeString()), "result");
48 EXPECT_EQ(formatDocumentation(*Builder.TakeString(), "Is this brief?"),
55 EXPECT_EQ(formatDocumentation(*Builder.TakeString(), "Is this brief?"),
64 EXPECT_EQ(formatDocumentation(*Builder.TakeString(), ""),
72 EXPECT_EQ(Signature, "");
73 EXPECT_EQ(Snippet, "");
88 EXPECT_EQ(Signature, "(p1, p2)");
89 EXPECT_EQ(Snippet, "(${1:p1}, ${2:p2})");
90 EXPECT_EQ(formatDocumentation(*CCS, "Foo's comment"), "Foo's comment");
113 EXPECT_EQ(Signature, "(p1, p2 = 0, p3 = 0)");
114 EXPECT_EQ(Snippet, "(${1:p1})");
124 EXPECT_EQ(Signature, "($p}1\\)");
125 EXPECT_EQ(Snippet, "(${1:\\$p\\}1\\\\})");
140 EXPECT_EQ(Snippet, " ${1:name} = ${2:target};");
144 EXPECT_EQ(Snippet, " ${1:name} = ${0:target};");
152 EXPECT_EQ(Signature, "info ok");
153 EXPECT_EQ(Snippet, "");
162 EXPECT_EQ(Signature, "");
163 EXPECT_EQ(Snippet, "");
173 EXPECT_EQ(Signature, "(type)");
174 EXPECT_EQ(Snippet, "${1:(type)}");
187 EXPECT_EQ(Signature, "(type) bar:(type2)");
188 EXPECT_EQ(Snippet, "${1:(type)} bar:${2:(type2)}");
199 EXPECT_EQ(Signature, "(type2)");
200 EXPECT_EQ(Snippet, "${1:(type2)}");
tools/clang/tools/extra/clangd/unittests/ContextTests.cpp 22 EXPECT_EQ(*Ctx.get(IntParam), 10);
23 EXPECT_EQ(*Ctx.get(ExtraIntParam), 20);
30 EXPECT_EQ(**Ctx.get(Param), 10);
33 EXPECT_EQ(**NewCtx.get(Param), 10);
46 EXPECT_EQ(*ParentCtx.get(ParentParam), 10);
47 EXPECT_EQ(*ParentCtx.get(ParentAndChildParam), 20);
48 EXPECT_EQ(ParentCtx.get(ChildParam), nullptr);
50 EXPECT_EQ(*ChildCtx.get(ParentParam), 10);
51 EXPECT_EQ(*ChildCtx.get(ParentAndChildParam), 30);
52 EXPECT_EQ(*ChildCtx.get(ChildParam), 40);
tools/clang/tools/extra/clangd/unittests/DexTests.cpp 52 EXPECT_EQ(DocIterator->peek(), 4U);
56 EXPECT_EQ(DocIterator->peek(), 7U);
60 EXPECT_EQ(DocIterator->peek(), 20U);
64 EXPECT_EQ(DocIterator->peek(), 100U);
84 EXPECT_EQ(And->peek(), 0U);
86 EXPECT_EQ(And->peek(), 7U);
88 EXPECT_EQ(And->peek(), 10U);
90 EXPECT_EQ(And->peek(), 320U);
92 EXPECT_EQ(And->peek(), 9000U);
103 EXPECT_EQ(And->peek(), 7U);
105 EXPECT_EQ(And->peek(), 320U);
131 EXPECT_EQ(Or->peek(), 0U);
133 EXPECT_EQ(Or->peek(), 4U);
135 EXPECT_EQ(Or->peek(), 5U);
137 EXPECT_EQ(Or->peek(), 7U);
139 EXPECT_EQ(Or->peek(), 10U);
141 EXPECT_EQ(Or->peek(), 30U);
143 EXPECT_EQ(Or->peek(), 42U);
145 EXPECT_EQ(Or->peek(), 320U);
147 EXPECT_EQ(Or->peek(), 9000U);
166 EXPECT_EQ(Or->peek(), 0U);
169 EXPECT_EQ(Or->peek(), 1U);
172 EXPECT_EQ(Or->peek(), 4U);
177 EXPECT_EQ(Or->peek(), 60U);
226 EXPECT_EQ(Root->peek(), 1U);
231 EXPECT_EQ(Root->peek(), 1U);
235 EXPECT_EQ(Root->peek(), 5U);
237 EXPECT_EQ(Root->peek(), 5U);
251 EXPECT_EQ(llvm::to_string(*I1), "[1 3 5]");
256 EXPECT_EQ(llvm::to_string(*I2), "T=L2");
326 EXPECT_EQ(llvm::to_string(*C.intersect()), "true");
327 EXPECT_EQ(llvm::to_string(*C.unionOf()), "false");
330 EXPECT_EQ(llvm::to_string(*C.intersect(L1.iterator(), C.all())), "[1]");
331 EXPECT_EQ(llvm::to_string(*C.intersect(L1.iterator(), C.none())), "false");
333 EXPECT_EQ(llvm::to_string(*C.unionOf(L1.iterator(), C.all())),
335 EXPECT_EQ(llvm::to_string(*C.unionOf(L1.iterator(), C.none())), "[1]");
338 EXPECT_EQ(llvm::to_string(*C.intersect(
341 EXPECT_EQ(llvm::to_string(*C.unionOf(
346 EXPECT_EQ(llvm::to_string(*C.intersect(
503 EXPECT_EQ(Matches.size(), *Req.Limit);
tools/clang/tools/extra/clangd/unittests/DiagnosticsTests.cpp 483 EXPECT_EQ(LSPDiags[0].first.code, "enum_class_reference");
484 EXPECT_EQ(LSPDiags[0].first.source, "clang");
485 EXPECT_EQ(LSPDiags[1].first.code, "");
486 EXPECT_EQ(LSPDiags[1].first.source, "");
712 EXPECT_EQ(D.Fixes.size(), 1u);
713 EXPECT_EQ(D.Fixes[0].Message,
tools/clang/tools/extra/clangd/unittests/DraftStoreTests.cpp 53 EXPECT_EQ(*Result, SrcAfter.code());
54 EXPECT_EQ(*DS.getDraft(Path), SrcAfter.code());
83 EXPECT_EQ(*Result, FinalSrc.code());
84 EXPECT_EQ(*DS.getDraft(Path), FinalSrc.code());
200 EXPECT_EQ(
221 EXPECT_EQ(toString(Result.takeError()),
242 EXPECT_EQ(toString(Result.takeError()),
263 EXPECT_EQ(toString(Result.takeError()),
284 EXPECT_EQ(toString(Result.takeError()), "Line value is out of range (100)");
304 EXPECT_EQ(toString(Result.takeError()), "Line value is out of range (100)");
337 EXPECT_EQ(toString(Result.takeError()),
342 EXPECT_EQ(*Contents, OriginalContents);
tools/clang/tools/extra/clangd/unittests/ExpectedTypeTest.cpp 144 EXPECT_EQ(fromCompletionResult(decl("returns_int")), IntTy);
147 EXPECT_EQ(fromCompletionResult(decl("returns_ptr")), IntPtrTy);
166 EXPECT_EQ(fromCompletionResult(decl("returns_not_dependent")), IntPtrTy);
167 EXPECT_EQ(fromCompletionResult(decl("returns_dependent")), llvm::None);
169 EXPECT_EQ(fromCompletionResult(decl("var_not_dependent")), IntPtrTy);
170 EXPECT_EQ(fromCompletionResult(decl("var_dependent")), llvm::None);
tools/clang/tools/extra/clangd/unittests/FSTests.cpp 45 EXPECT_EQ(Cached->getName(), testPath("fake"));
46 EXPECT_EQ(Cached->getUniqueID(), S.getUniqueID());
52 EXPECT_EQ(CachedDotDot->getName(), testPath("temp/../fake"));
53 EXPECT_EQ(CachedDotDot->getUniqueID(), S.getUniqueID());
tools/clang/tools/extra/clangd/unittests/FileDistanceTests.cpp 31 EXPECT_EQ(D.distance("tools/clang/lib/Format/FormatToken.cpp"), 0u);
32 EXPECT_EQ(D.distance("include/llvm/ADT/StringRef.h"), 2u);
34 EXPECT_EQ(D.distance("tools/clang/lib/Format/"), 5u);
36 EXPECT_EQ(D.distance("tools/clang/lib/Format/FormatToken.cpp/Oops"), 3u);
38 EXPECT_EQ(D.distance("/"), 22u);
40 EXPECT_EQ(D.distance("tools/clang/lib/Format/AnotherFile.cpp"), 8u);
42 EXPECT_EQ(D.distance("include/llvm/Support/Allocator.h"), 18u);
44 EXPECT_EQ(D.distance("include/llvm-c/Core.h"), 23u);
55 EXPECT_EQ(D.distance("b"), 8u); // a+up+down, not b+up+up
56 EXPECT_EQ(D.distance("b/b/b"), 14u); // a+up+down+down+down, not b
57 EXPECT_EQ(D.distance("b/b/b/c"), 17u); // a+up+down+down+down+down, not b+down
77 EXPECT_EQ(D.distance("file:///not/a/testpath/either"), 3u);
79 EXPECT_EQ(D.distance("unittest:///foo"), 1000u);
80 EXPECT_EQ(D.distance("unittest:///bar"), 1008u);
91 EXPECT_EQ(D.distance("/a"), 101u);
92 EXPECT_EQ(D.distance("/a/z"), 102u);
93 EXPECT_EQ(D.distance("/a/b"), 1u);
94 EXPECT_EQ(D.distance("/a/b/z"), 2u);
105 EXPECT_EQ(D.distance("/"), 0u);
106 EXPECT_EQ(D.distance("/a"), 102u);
107 EXPECT_EQ(D.distance("/a/b"), 101u);
108 EXPECT_EQ(D.distance("/x"), FileDistance::Unreachable);
113 EXPECT_EQ(D.distance("x::y::z::"), 0u);
tools/clang/tools/extra/clangd/unittests/FileIndexTests.cpp 251 EXPECT_EQ(Vector.Signature, "<class Ty>");
252 EXPECT_EQ(Vector.CompletionSnippetSuffix, "<${1:class Ty}>");
254 EXPECT_EQ(MakeVector.Signature, "<class Ty>(Arg A)");
255 EXPECT_EQ(MakeVector.CompletionSnippetSuffix, "<${1:class Ty}>(${2:Arg A})");
369 EXPECT_EQ(Results, 1u);
tools/clang/tools/extra/clangd/unittests/FindTargetTests.cpp 87 EXPECT_EQ(N->kind(), NodeType) << Selection;
893 EXPECT_EQ(ExpectedCode, Actual.AnnotatedCode);
894 EXPECT_EQ(ExpectedRefs, Actual.DumpedReferences) << ExpectedCode;
tools/clang/tools/extra/clangd/unittests/FormatTests.cpp 43 EXPECT_EQ(After, afterTyped(Before, "\n")) << Before;
46 EXPECT_EQ(After, afterTyped(Before, Typed)) << Before;
tools/clang/tools/extra/clangd/unittests/FormattedStringTests.cpp 21 EXPECT_EQ(S.renderAsPlainText(), "");
22 EXPECT_EQ(S.renderAsMarkdown(), "");
26 EXPECT_EQ(S.renderAsPlainText(), "foobar baz");
27 EXPECT_EQ(S.renderAsMarkdown(), "foobar baz");
31 EXPECT_EQ(S.renderAsPlainText(), "foobar");
32 EXPECT_EQ(S.renderAsMarkdown(), "`foobar`");
36 EXPECT_EQ(S.renderAsPlainText(), "foobar");
37 EXPECT_EQ(S.renderAsMarkdown(), "```cpp\n"
53 EXPECT_EQ(S.renderAsPlainText(), ExpectedText);
61 EXPECT_EQ(S.renderAsMarkdown(), ExpectedMarkdown);
66 EXPECT_EQ(S.renderAsPlainText(), "foobar bazqux");
67 EXPECT_EQ(S.renderAsMarkdown(), "`foobar` `bazqux`");
74 EXPECT_EQ(S.renderAsPlainText(), "foo bar baz");
75 EXPECT_EQ(S.renderAsMarkdown(), "foo `bar` baz");
82 EXPECT_EQ(S.renderAsMarkdown(), "\\*\\!\\`");
93 EXPECT_EQ(S.renderAsMarkdown(), EscapedPunctuation);
98 EXPECT_EQ(S.renderAsMarkdown(), "`* foo !+ bar * baz`");
101 EXPECT_EQ(S.renderAsMarkdown(), "```cpp\n"
108 EXPECT_EQ(S.renderAsMarkdown(), "`foo``bar``baz`");
112 EXPECT_EQ(S.renderAsMarkdown(), "```cpp\n"
119 EXPECT_EQ(S.renderAsMarkdown(), "` ``foo `");
122 EXPECT_EQ(S.renderAsMarkdown(), "` foo`` `");
125 EXPECT_EQ(S.renderAsMarkdown(), "` ``foo`` `");
130 EXPECT_EQ(S.renderAsMarkdown(), "` foo `");
133 EXPECT_EQ(S.renderAsMarkdown(), "`foo `");
136 EXPECT_EQ(S.renderAsMarkdown(), "` foo`");
141 EXPECT_EQ(S.renderAsMarkdown(), "```cpp\n"
146 EXPECT_EQ(S.renderAsMarkdown(), "```cpp\n"
151 EXPECT_EQ(S.renderAsMarkdown(), "````cpp\n"
156 EXPECT_EQ(S.renderAsMarkdown(), "`````cpp\n"
166 EXPECT_EQ(S.renderAsMarkdown(), "foo bar");
171 EXPECT_EQ(S.renderAsMarkdown(), "`foo` `bar`");
177 EXPECT_EQ(S.renderAsMarkdown(), "foo `bar`");
182 EXPECT_EQ(S.renderAsMarkdown(), "foo\n`bar`");
187 EXPECT_EQ(S.renderAsMarkdown(), "`foo` bar");
193 EXPECT_EQ(S.renderAsMarkdown(), "foo\n```cpp\nbar\n```\nbaz");
tools/clang/tools/extra/clangd/unittests/FunctionTests.cpp 24 EXPECT_EQ(0, N);
29 EXPECT_EQ(1, N);
33 EXPECT_EQ(1, N);
35 EXPECT_EQ(3, N);
39 EXPECT_EQ(3, N);
41 EXPECT_EQ(4, N);
44 EXPECT_EQ(4, N);
46 EXPECT_EQ(4, N);
tools/clang/tools/extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp 44 EXPECT_EQ(Cmd.Directory, testPath("foo"));
47 EXPECT_EQ(Cmd.Output, "");
93 EXPECT_EQ(CDB.getCompileCommand(testPath("missing.cc")), llvm::None);
99 EXPECT_EQ(CDB.getCompileCommand(testPath("missing.cc")), llvm::None);
114 EXPECT_EQ(CDB.getCompileCommand(testPath("bar.cc")), None);
tools/clang/tools/extra/clangd/unittests/HeaderSourceSwitchTests.cpp 179 EXPECT_EQ(Case.ExpectedSource,
245 EXPECT_EQ(Case.ExpectedResult,
273 EXPECT_EQ(HeaderPath,
tools/clang/tools/extra/clangd/unittests/HeadersTests.cpp 207 EXPECT_EQ(calculate(Path), "\"bar.h\"");
212 EXPECT_EQ(calculate(MainFile), "");
217 EXPECT_EQ(calculate(testPath("sub2/main.cpp")), "");
222 EXPECT_EQ(calculate(BarHeader), "\"bar.h\"");
227 EXPECT_EQ(calculate(BarHeader), "\"sub/bar.h\"");
233 EXPECT_EQ(calculate(BarHeader, ""), "\"sub-2/bar.h\"");
238 EXPECT_EQ(calculate(BarHeader, "<bar>"), "<bar>");
241 EXPECT_EQ(calculate(BarHeader, BazHeader), "\"baz.h\"");
248 EXPECT_EQ(calculate(testPath("sub/bar.h"), "\"bar.h\"", {Inc}), "");
249 EXPECT_EQ(calculate("\"x.h\"", "\"bar.h\"", {Inc}), "");
256 EXPECT_EQ(calculate(Inc.Resolved, "", {Inc}), "");
258 EXPECT_EQ(calculate(Inc.Resolved, "\"BAR.h\"", {Inc}), "");
276 EXPECT_EQ(Inserter.calculateIncludePath(Inserting, MainFile),
278 EXPECT_EQ(Inserter.shouldInsertInclude(HeaderPath, Inserting), false);
280 EXPECT_EQ(Inserter.calculateIncludePath(Verbatim, MainFile),
282 EXPECT_EQ(Inserter.shouldInsertInclude(HeaderPath, Verbatim), true);
284 EXPECT_EQ(Inserter.calculateIncludePath(Inserting, "sub2/main2.cpp"),
tools/clang/tools/extra/clangd/unittests/IndexActionTests.cpp 55 EXPECT_EQ(Node.URI.data(), IndexFile.Sources->find(URI)->getKeyData());
tools/clang/tools/extra/clangd/unittests/IndexTests.cpp 48 EXPECT_EQ(1u, Pos.line());
50 EXPECT_EQ(2u, Pos.column());
55 EXPECT_EQ(Pos.line(), Position::MaxLine);
60 EXPECT_EQ(Pos.column(), Position::MaxColumn);
68 EXPECT_EQ(nullptr, B.find(SymbolID("W")));
74 EXPECT_EQ(S.end(), S.find(SymbolID("W")));
144 EXPECT_EQ(Matches.size(), *Req.Limit);
306 EXPECT_EQ(M.Name, "Foo");
307 EXPECT_EQ(StringRef(M.CanonicalDeclaration.FileURI), "file:///left.h");
308 EXPECT_EQ(M.References, 3u);
309 EXPECT_EQ(M.Signature, "()");
310 EXPECT_EQ(M.CompletionSnippetSuffix, "{$1:0}");
311 EXPECT_EQ(M.Documentation, "--doc--");
312 EXPECT_EQ(M.Type, "expectedType");
313 EXPECT_EQ(M.Origin,
327 EXPECT_EQ(StringRef(M.CanonicalDeclaration.FileURI), "file:/left.h");
328 EXPECT_EQ(StringRef(M.Definition.FileURI), "");
329 EXPECT_EQ(M.Name, "left");
333 EXPECT_EQ(StringRef(M.CanonicalDeclaration.FileURI), "file:/right.h");
334 EXPECT_EQ(StringRef(M.Definition.FileURI), "file:/right.cpp");
335 EXPECT_EQ(M.Name, "right");
346 EXPECT_EQ(StringRef(M.CanonicalDeclaration.FileURI), "file:/x.proto");
351 EXPECT_EQ(StringRef(M.CanonicalDeclaration.FileURI), "file:/y.proto");
417 EXPECT_EQ(M.Documentation, "");
tools/clang/tools/extra/clangd/unittests/JSONTransportTests.cpp 119 EXPECT_EQ(trim(E.log()), trim(WantLog));
127 EXPECT_EQ(output(), WantOutput);
128 EXPECT_EQ(trim(input_mirror()), trim(input()));
160 EXPECT_EQ(trim(E.log()), trim(WantLog));
183 EXPECT_EQ(output(), WantOutput);
184 EXPECT_EQ(trim(input_mirror()), trim(input()));
195 EXPECT_EQ(trim(E.log()), "Notification call: 1234");
198 EXPECT_EQ(trim(input_mirror()), trim(input()));
tools/clang/tools/extra/clangd/unittests/ParsedASTTests.cpp 185 EXPECT_EQ(T.expandedTokens().front().text(SM), "first_token");
187 EXPECT_EQ(T.expandedTokens().back().kind(), tok::eof);
189 EXPECT_EQ(T.expandedTokens().drop_back().back().text(SM), "last_token");
194 EXPECT_EQ(Spelled.front().kind(), tok::hash);
195 EXPECT_EQ(Spelled.back().text(SM), "last_token");
211 EXPECT_EQ(T.expandedTokens().front().text(SM), "inline");
213 EXPECT_EQ(T.expandedTokens().back().kind(), tok::eof);
215 EXPECT_EQ(T.expandedTokens().drop_back().back().text(SM), "}");
tools/clang/tools/extra/clangd/unittests/QualityTests.cpp 61 EXPECT_EQ(Quality.References, SymbolQualitySignals().References);
62 EXPECT_EQ(Quality.Category, SymbolQualitySignals::Variable);
73 EXPECT_EQ(Quality.References, 24u);
74 EXPECT_EQ(Quality.Category, SymbolQualitySignals::Function);
80 EXPECT_EQ(Quality.References, SymbolQualitySignals().References);
81 EXPECT_EQ(Quality.Category, SymbolQualitySignals::Function);
85 EXPECT_EQ(Quality.Category, SymbolQualitySignals::Keyword);
123 EXPECT_EQ(Relevance.NameMatch, SymbolRelevanceSignals().NameMatch);
125 EXPECT_EQ(Relevance.Scope, SymbolRelevanceSignals::GlobalScope);
163 EXPECT_EQ(Relevance.Scope, SymbolRelevanceSignals::FileScope);
166 EXPECT_EQ(Relevance.Scope, SymbolRelevanceSignals::ClassScope);
169 EXPECT_EQ(Relevance.Scope, SymbolRelevanceSignals::FunctionScope);
173 EXPECT_EQ(Relevance.Scope, SymbolRelevanceSignals::GlobalScope);
191 EXPECT_EQ(Relevance.Scope, SymbolRelevanceSignals::FileScope);
199 EXPECT_EQ(Default.evaluate(), 1);
239 EXPECT_EQ(Default.evaluate(), 1);
286 EXPECT_EQ(Instance.evaluate(), Default.evaluate());
290 EXPECT_EQ(Instance.evaluate(), Default.evaluate());
300 EXPECT_EQ(WithoutMatchingWord.evaluate(), Default.evaluate());
370 EXPECT_EQ(Cls.Scope, SymbolRelevanceSignals::GlobalScope);
371 EXPECT_EQ(Ctor.Scope, SymbolRelevanceSignals::GlobalScope);
437 EXPECT_EQ(CtorQ.Category, SymbolQualitySignals::Constructor);
442 EXPECT_EQ(CtorQ.Category, SymbolQualitySignals::Constructor);
446 EXPECT_EQ(DtorQ.Category, SymbolQualitySignals::Destructor);
466 EXPECT_EQ(Q.Category, SymbolQualitySignals::Operator);
tools/clang/tools/extra/clangd/unittests/RIFFTests.cpp 29 EXPECT_EQ(llvm::to_string(File), Serialized);
32 EXPECT_EQ(*Parsed, File);
tools/clang/tools/extra/clangd/unittests/RenameTests.cpp 89 EXPECT_EQ(T.After, *ApplyResult) << T.Before;
tools/clang/tools/extra/clangd/unittests/SelectionTests.cpp 302 EXPECT_EQ("TranslationUnitDecl", nodeKind(&T.root())) << C.Code;
310 EXPECT_EQ(C.CommonAncestorKind, nodeKind(T.commonAncestor()))
314 EXPECT_EQ(nodeRange(T.commonAncestor(), AST), Test.range())
399 EXPECT_EQ("BreakStmt", T.commonAncestor()->kind());
400 EXPECT_EQ("WhileStmt", T.commonAncestor()->Parent->kind());
413 EXPECT_EQ("StringLiteral", nodeKind(Str)) << "Implicit selected?";
414 EXPECT_EQ("ImplicitCastExpr", nodeKind(Str->Parent));
415 EXPECT_EQ("CXXConstructExpr", nodeKind(Str->Parent->Parent));
416 EXPECT_EQ(Str, &Str->Parent->Parent->ignoreImplicit())
419 EXPECT_EQ("CXXConstructExpr", nodeKind(&Str->outerImplicit()));
tools/clang/tools/extra/clangd/unittests/SemanticHighlightingTests.cpp 116 EXPECT_EQ(Code, annotate(Test.code(), getSemanticHighlightings(AST)));
662 EXPECT_EQ(ActualResults, ExpectedResults);
tools/clang/tools/extra/clangd/unittests/SerializationTests.cpp 123 EXPECT_EQ(Sym1.Signature, "");
124 EXPECT_EQ(Sym1.Documentation, "Foo doc");
125 EXPECT_EQ(Sym1.ReturnType, "int");
126 EXPECT_EQ(StringRef(Sym1.CanonicalDeclaration.FileURI), "file:///path/foo.h");
127 EXPECT_EQ(Sym1.Origin, static_cast<SymbolOrigin>(1 << 7));
128 EXPECT_EQ(static_cast<uint8_t>(Sym1.Flags), 129);
136 EXPECT_EQ(Sym2.Signature, "-sig");
137 EXPECT_EQ(Sym2.ReturnType, "");
138 EXPECT_EQ(llvm::StringRef(Sym2.CanonicalDeclaration.FileURI),
149 EXPECT_EQ(Ref1.Kind, RefKind::Reference);
150 EXPECT_EQ(StringRef(Ref1.Location.FileURI), "file:///path/foo.cc");
236 EXPECT_EQ(IGNDeserialized.Digest, IGN.Digest);
237 EXPECT_EQ(IGNDeserialized.DirectIncludes, IGN.DirectIncludes);
238 EXPECT_EQ(IGNDeserialized.URI, IGN.URI);
239 EXPECT_EQ(IGNDeserialized.Flags, IGN.Flags);
266 EXPECT_EQ(SerializedCmd.CommandLine, Cmd.CommandLine);
267 EXPECT_EQ(SerializedCmd.Directory, Cmd.Directory);
tools/clang/tools/extra/clangd/unittests/SourceCodeTests.cpp 54 EXPECT_EQ(lspLength(""), 0UL);
55 EXPECT_EQ(lspLength("ascii"), 5UL);
57 EXPECT_EQ(lspLength("↓"), 1UL);
58 EXPECT_EQ(lspLength("¥"), 1UL);
60 EXPECT_EQ(lspLength("😂"), 2UL);
63 EXPECT_EQ(lspLength(""), 0UL);
64 EXPECT_EQ(lspLength("ascii"), 5UL);
66 EXPECT_EQ(lspLength("↓"), 3UL);
67 EXPECT_EQ(lspLength("¥"), 2UL);
69 EXPECT_EQ(lspLength("😂"), 4UL);
72 EXPECT_EQ(lspLength(""), 0UL);
73 EXPECT_EQ(lspLength("ascii"), 5UL);
75 EXPECT_EQ(lspLength("↓"), 1UL);
76 EXPECT_EQ(lspLength("¥"), 1UL);
78 EXPECT_EQ(lspLength("😂"), 1UL);
366 EXPECT_EQ(TestCase.points().front(), ActualPos) << Text;
377 EXPECT_EQ(IDs.size(), 7u);
378 EXPECT_EQ(IDs["include"], 1u);
379 EXPECT_EQ(IDs["void"], 1u);
380 EXPECT_EQ(IDs["int"], 2u);
381 EXPECT_EQ(IDs["xyz"], 2u);
382 EXPECT_EQ(IDs["abc"], 1u);
383 EXPECT_EQ(IDs["return"], 1u);
384 EXPECT_EQ(IDs["foo"], 2u);
397 EXPECT_EQ(ActualWords, ExpectedWords);
472 EXPECT_EQ(Case.second,
564 EXPECT_EQ(HalfOpenRange, Test.ranges(Name)[0]);
595 EXPECT_EQ(AST.getSourceManager().getFileOffset(Range->getBegin()),
597 EXPECT_EQ(AST.getSourceManager().getFileOffset(Range->getEnd()),
615 EXPECT_EQ(SM.getFileOffset(includeHashLoc(Foo, SM)),
618 EXPECT_EQ(SM.getFileOffset(includeHashLoc(Bar, SM)),
680 EXPECT_EQ(Res.EnclosingNamespace, Case.EnclosingNamespace) << Test.code();
tools/clang/tools/extra/clangd/unittests/TUSchedulerTests.cpp 139 EXPECT_EQ(S.getContents(Added), "");
141 EXPECT_EQ(S.getContents(Added), "x");
160 EXPECT_EQ(S.getContents(Added), "x");
162 EXPECT_EQ(S.getContents(Added), "");
207 EXPECT_EQ(2, CallbackCount);
233 EXPECT_EQ(2, CallbackCount);
289 EXPECT_EQ(2, CallbackCount);
414 EXPECT_EQ(File, *TUScheduler::getFileBeingProcessedInContext());
426 EXPECT_EQ(AST->Inputs.FS, Inputs.FS);
427 EXPECT_EQ(AST->Inputs.Contents, Inputs.Contents);
431 EXPECT_EQ(File, *TUScheduler::getFileBeingProcessedInContext());
444 EXPECT_EQ(Preamble->Contents, Inputs.Contents);
448 EXPECT_EQ(File, *TUScheduler::getFileBeingProcessedInContext());
457 EXPECT_EQ(TotalUpdates, FilesCount * UpdatesPerFile);
458 EXPECT_EQ(TotalASTReads, FilesCount * UpdatesPerFile);
459 EXPECT_EQ(TotalPreambleReads, FilesCount * UpdatesPerFile);
553 EXPECT_EQ(
690 EXPECT_EQ(Counter.load(), 3);
696 EXPECT_EQ(Context::current().getExisting(TestKey), 10);
tools/clang/tools/extra/clangd/unittests/TweakTests.cpp 72 EXPECT_EQ(Res->first, testPath(Path));
79 EXPECT_EQ(apply("^if (true) {return 100;} else {continue;}"),
81 EXPECT_EQ(apply("^if () {return 100;} else {continue;}"),
122 EXPECT_EQ(apply(Input), Output);
150 EXPECT_EQ(apply("int fcall(int); int x = fca[[ll(2 +]]2);"), Output);
437 EXPECT_EQ(IO.second, apply(IO.first)) << IO.first;
445 EXPECT_EQ("void /* entity.name.function.cpp */f() {}", apply("void ^f() {}"));
447 EXPECT_EQ(apply("[[void f1(); void f2();]]"),
451 EXPECT_EQ(apply("void f1(); void f2() {^}"),
473 EXPECT_EQ(apply("^FOO BAR FOO"), "1 2 3 BAR FOO");
474 EXPECT_EQ(apply("FOO BAR ^FOO"), "FOO BAR 1 2 3");
476 EXPECT_EQ(apply("F^UNC(2)"), "2 + 2 + 2");
479 EXPECT_EQ(apply("int a ^EMPTY;"), "int a ;");
480 EXPECT_EQ(apply("int a ^EMPTY_FN(1 2 3);"), "int a ;");
481 EXPECT_EQ(apply("int a = 123 ^EMPTY EMPTY_FN(1);"),
483 EXPECT_EQ(apply("int a = 123 ^EMPTY_FN(1) EMPTY;"), "int a = 123 EMPTY;");
484 EXPECT_EQ(apply("int a = 123 EMPTY_FN(1) ^EMPTY;"),
509 EXPECT_EQ(apply("[[auto]] i = 0;"), "int i = 0;");
510 EXPECT_EQ(apply("au^to i = 0;"), "int i = 0;");
512 EXPECT_EQ(apply("^auto C = ns::Class::Nested();"),
515 EXPECT_EQ(apply("namespace ns { void f() { ^auto C = Class(); } }"),
527 EXPECT_EQ(apply("au^to x = inl_ns::Visible();"),
530 EXPECT_EQ(apply("namespace x { void y() { struct S{}; ^auto z = S(); } }"),
533 EXPECT_EQ(apply(R"cpp(au^to x = "test")cpp"),
551 EXPECT_EQ(apply("for(;;) [[1+2; 1+2;]]"), "unavailable");
553 EXPECT_EQ(apply("int x = 0; [[x++;]]"), "unavailable");
555 EXPECT_EQ(apply("auto lam = [](){ [[int x;]] }; "), "unavailable");
598 EXPECT_EQ(apply(ParameterCheckInput), ParameterCheckOutput);
612 EXPECT_EQ(apply(ConstCheckInput), ConstCheckOutput);
626 EXPECT_EQ(apply(MethodFailInput), "unavailable");
636 EXPECT_EQ(apply(TemplateFailInput), "unavailable");
644 EXPECT_EQ(apply(MacroFailInput), "unavailable");
647 EXPECT_EQ(apply("void f([[int a]]);"), "unavailable");
654 EXPECT_EQ(apply(CompoundFailInput), "unavailable");
885 EXPECT_EQ(C.second, apply(C.first)) << C.first;
1112 EXPECT_EQ(apply(Test), Expected);
1138 EXPECT_EQ(apply(Test), Expected);
1176 EXPECT_EQ(apply(Test), Expected);
1214 EXPECT_EQ(apply(Test), Expected);
1234 EXPECT_EQ(apply(Test), Expected);
1250 EXPECT_EQ(apply(Test, &EditedFiles), Expected);
1294 EXPECT_EQ(apply(Test), Expected);
1381 EXPECT_EQ(apply(Case.first), Case.second) << Case.first;
1419 EXPECT_EQ(apply(Test), Expected);
1475 EXPECT_EQ(apply(Test), Expected);
1489 EXPECT_EQ(apply(Test), Expected);
1505 EXPECT_EQ(apply(Test), Expected);
1531 EXPECT_EQ(apply(Case.first), Case.second) << Case.first;
1589 EXPECT_EQ(apply(Case.first), Case.second) << Case.first;
tools/clang/tools/extra/clangd/unittests/TypeHierarchyTests.cpp 76 EXPECT_EQ(&findDecl(AST, "Child2"), static_cast<const NamedDecl *>(RD));
100 EXPECT_EQ(&findDecl(AST, "Child2"), static_cast<const NamedDecl *>(RD));
126 EXPECT_EQ(nullptr, RD);
tools/clang/tools/extra/clangd/unittests/URITests.cpp 46 EXPECT_EQ(URI("x", /*Authority=*/"", "a/b/c").toString(), "x:a/b/c");
47 EXPECT_EQ(URI("x", /*Authority=*/"", "a!b;c~").toString(), "x:a%21b%3Bc~");
48 EXPECT_EQ(URI("x", /*Authority=*/"", "a123b").toString(), "x:a123b");
49 EXPECT_EQ(URI("x", /*Authority=*/"", "a:b;c").toString(), "x:a:b%3Bc");
53 EXPECT_EQ(parseOrDie("x:a/b/c").body(), "a/b/c");
55 EXPECT_EQ(parseOrDie("s%2b://%3a/%3").scheme(), "s+");
56 EXPECT_EQ(parseOrDie("s%2b://%3a/%3").authority(), ":");
57 EXPECT_EQ(parseOrDie("s%2b://%3a/%3").body(), "/%3");
59 EXPECT_EQ(parseOrDie("x:a%21b%3ac~").body(), "a!b:c~");
60 EXPECT_EQ(parseOrDie("x:a:b%3bc").body(), "a:b;c");
129 EXPECT_EQ(resolveOrDie(parseOrDie("file:/a/b/c")), "/a/b/c");
130 EXPECT_EQ(resolveOrDie(parseOrDie("file://auth/a/b/c")), "/a/b/c");
135 EXPECT_EQ(resolveOrDie(parseOrDie("unittest:///a"), testPath("x")),
154 EXPECT_EQ(resolvePathOrDie(FilePath), FilePath);
155 EXPECT_EQ(resolvePathOrDie(testPath("x"), testPath("hint")), testPath("x"));
tools/clang/tools/extra/clangd/unittests/XRefsTests.cpp 479 EXPECT_EQ(Results[0].PreferredDeclaration.range, *WantDecl) << Test;
483 EXPECT_EQ(WantDef, GotDef) << Test;
1021 EXPECT_EQ(H->NamespaceScope, Expected.NamespaceScope);
1022 EXPECT_EQ(H->LocalScope, Expected.LocalScope);
1023 EXPECT_EQ(H->Name, Expected.Name);
1024 EXPECT_EQ(H->Kind, Expected.Kind);
1025 EXPECT_EQ(H->Documentation, Expected.Documentation);
1026 EXPECT_EQ(H->Definition, Expected.Definition);
1027 EXPECT_EQ(H->Type, Expected.Type);
1028 EXPECT_EQ(H->ReturnType, Expected.ReturnType);
1029 EXPECT_EQ(H->Parameters, Expected.Parameters);
1030 EXPECT_EQ(H->TemplateParameters, Expected.TemplateParameters);
1031 EXPECT_EQ(H->SymRange, Expected.SymRange);
1032 EXPECT_EQ(H->Value, Expected.Value);
1847 EXPECT_EQ(H->present().renderForTests(), Test.ExpectedHover.str())
1850 EXPECT_EQ("", Test.ExpectedHover.str()) << Test.Input;
2144 EXPECT_EQ(1u, findReferences(AST, Main.point(), /*Limit*/ 1,
2185 EXPECT_EQ(Rec.RefIDs, None) << T.AnnotatedCode;
2208 EXPECT_EQ(DeducedType->getAsString(), T.DeducedType);
tools/clang/tools/extra/unittests/clang-change-namespace/ChangeNamespaceTests.cpp 83 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
98 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
115 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
136 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
156 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
179 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
195 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
213 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
247 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
267 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
306 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
347 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
374 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
404 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
433 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
456 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
488 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
528 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
558 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
607 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
644 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
685 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
723 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
758 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
793 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
814 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
846 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
874 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
906 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
930 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
959 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
983 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1010 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1038 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1064 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1089 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1119 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1145 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1170 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1195 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1223 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1246 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1268 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1287 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1321 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1343 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1363 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1387 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1411 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1432 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1453 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1475 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1504 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1533 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1562 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1598 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1639 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1676 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1733 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1766 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1807 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1842 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1881 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1898 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1934 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1967 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2009 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2055 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2081 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2127 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2188 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2243 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2276 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
tools/clang/tools/extra/unittests/clang-doc/BitcodeTest.cpp 51 EXPECT_EQ(Infos.get().size(), NumInfos);
tools/clang/tools/extra/unittests/clang-doc/ClangDocTest.cpp 38 EXPECT_EQ(Expected.Kind, Actual.Kind);
39 EXPECT_EQ(Expected.Text, Actual.Text);
40 EXPECT_EQ(Expected.Name, Actual.Name);
41 EXPECT_EQ(Expected.Direction, Actual.Direction);
42 EXPECT_EQ(Expected.ParamName, Actual.ParamName);
43 EXPECT_EQ(Expected.CloseName, Actual.CloseName);
44 EXPECT_EQ(Expected.SelfClosing, Actual.SelfClosing);
45 EXPECT_EQ(Expected.Explicit, Actual.Explicit);
49 EXPECT_EQ(Expected.AttrKeys[Idx], Actual.AttrKeys[Idx]);
53 EXPECT_EQ(Expected.AttrValues[Idx], Actual.AttrValues[Idx]);
57 EXPECT_EQ(Expected.Args[Idx], Actual.Args[Idx]);
65 EXPECT_EQ(Expected.Name, Actual.Name);
66 EXPECT_EQ(Expected.RefType, Actual.RefType);
67 EXPECT_EQ(Expected.Path, Actual.Path);
76 EXPECT_EQ(Expected->Name, Actual->Name);
81 EXPECT_EQ(Expected->Access, Actual->Access);
85 EXPECT_EQ(size_t(20), Actual->USR.size());
86 EXPECT_EQ(Expected->Name, Actual->Name);
87 EXPECT_EQ(Expected->Path, Actual->Path);
98 EXPECT_EQ(Expected->DefLoc.hasValue(), Actual->DefLoc.hasValue());
100 EXPECT_EQ(Expected->DefLoc->LineNumber, Actual->DefLoc->LineNumber);
101 EXPECT_EQ(Expected->DefLoc->Filename, Actual->DefLoc->Filename);
105 EXPECT_EQ(Expected->Loc[Idx], Actual->Loc[Idx]);
111 EXPECT_EQ(Expected->IsMethod, Actual->IsMethod);
117 EXPECT_EQ(Expected->Params[Idx], Actual->Params[Idx]);
119 EXPECT_EQ(Expected->Access, Actual->Access);
125 EXPECT_EQ(Expected->Scoped, Actual->Scoped);
128 EXPECT_EQ(Expected->Members[Idx], Actual->Members[Idx]);
156 EXPECT_EQ(Expected->TagType, Actual->TagType);
158 EXPECT_EQ(Expected->IsTypeDef, Actual->IsTypeDef);
162 EXPECT_EQ(Expected->Members[Idx], Actual->Members[Idx]);
193 EXPECT_EQ(Expected->IsVirtual, Actual->IsVirtual);
194 EXPECT_EQ(Expected->Access, Actual->Access);
195 EXPECT_EQ(Expected->IsParent, Actual->IsParent);
tools/clang/tools/extra/unittests/clang-doc/HTMLGeneratorTest.cpp 141 EXPECT_EQ(Expected, Actual.str());
264 EXPECT_EQ(Expected, Actual.str());
317 EXPECT_EQ(Expected, Actual.str());
366 EXPECT_EQ(Expected, Actual.str());
451 EXPECT_EQ(Expected, Actual.str());
tools/clang/tools/extra/unittests/clang-doc/MDGeneratorTest.cpp 79 EXPECT_EQ(Expected, Actual.str());
146 EXPECT_EQ(Expected, Actual.str());
178 EXPECT_EQ(Expected, Actual.str());
209 EXPECT_EQ(Expected, Actual.str());
360 EXPECT_EQ(Expected, Actual.str());
tools/clang/tools/extra/unittests/clang-doc/YAMLGeneratorTest.cpp 72 EXPECT_EQ(Expected, Actual.str());
172 EXPECT_EQ(Expected, Actual.str());
225 EXPECT_EQ(Expected, Actual.str());
263 EXPECT_EQ(Expected, Actual.str());
469 EXPECT_EQ(Expected, Actual.str());
tools/clang/tools/extra/unittests/clang-include-fixer/IncludeFixerTest.cpp 118 EXPECT_EQ("#include <string>\nstd::string foo;\n",
121 EXPECT_EQ("// comment\n#include \"foo.h\"\n#include <string>\n"
126 EXPECT_EQ("#include \"foo.h\"\n#include <string>\nstd::string foo;\n",
129 EXPECT_EQ(
133 EXPECT_EQ("#include <string>\nstd::string foo;\n",
137 EXPECT_EQ("::string foo;\n", runIncludeFixer("::string foo;\n"));
141 EXPECT_EQ(
147 EXPECT_EQ("#include <string>\n"
154 EXPECT_EQ("#include \"otherdir/qux.h\"\na::b::foo bar;\n",
158 EXPECT_EQ("#include <otherdir/qux.h>\na::b::foo bar;\n",
162 EXPECT_EQ("#include \"otherdir/qux.h\"\na::b::foo bar;\n",
166 EXPECT_EQ("#include \"qux.h\"\na::b::foo bar;\n",
171 EXPECT_EQ("#include \"dir/otherdir/qux.h\"\n"
176 EXPECT_EQ("#define FOO a::b::foo\nint x = FOO;\n",
178 EXPECT_EQ("#define FOO(x) a::##x\nint x = FOO(b::foo);\n",
183 EXPECT_EQ("#include \"dir/otherdir/qux.h\"\n"
189 EXPECT_EQ("#include <string>\nstd::string bar;\nstd::sting foo;\n",
194 EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nb::bar b;\n}",
196 EXPECT_EQ("#include \"bar.h\"\nnamespace A {\na::b::bar b;\n}",
198 EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nvoid func() { b::bar b; }\n} "
201 EXPECT_EQ("namespace A { c::b::bar b; }\n",
205 EXPECT_EQ("#include \"bar.h\"\nnamespace A {\na::b::bar b;\n}",
209 EXPECT_EQ("#include \"strcat.h\"\nnamespace foo2 {\nstr::StrCat b;\n}",
213 EXPECT_EQ("#include \"str.h\"\nnamespace foo2 {\nstr::StrCat2 b;\n}",
215 EXPECT_EQ("#include \"str.h\"\nnamespace ns {\nstr::StrCat2 b;\n}",
220 EXPECT_EQ("#include \"color.h\"\nint test = a::b::Green;\n",
226 EXPECT_EQ(Code, runIncludeFixer(Code));
242 EXPECT_EQ(Expected, runIncludeFixer(Code));
246 EXPECT_EQ("#include \"Vector.h\"\na::Vector v;",
251 EXPECT_EQ("#include \"bar.h\"\na::b::bar b;\n",
253 EXPECT_EQ("#include \"bar.h\"\na::b::bar b;\n",
255 EXPECT_EQ("#include \"bar.h\"\na::b::bar b;\n",
257 EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nb::bar b;\n}\n",
259 EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nb::bar b;\n}\n",
261 EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nnamespace b{\nbar b;\n}\n} "
264 EXPECT_EQ("c::b::bar b;\n",
266 EXPECT_EQ("#include \"bar.h\"\nnamespace d {\na::b::bar b;\n}\n",
268 EXPECT_EQ("#include \"bar2.h\"\nnamespace c {\na::c::bar b;\n}\n",
272 EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nnamespace d {\nb::bar b;\n}\n} "
275 EXPECT_EQ("#include \"bar.h\"\nnamespace d {\nnamespace a {\na::b::bar "
280 EXPECT_EQ("#include \"bar.h\"\nnamespace d {\na::b::bar::t b;\n}\n",
282 EXPECT_EQ("#include \"bar.h\"\nnamespace c {\na::b::bar::t b;\n}\n",
284 EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nb::bar::t b;\n}\n",
287 EXPECT_EQ("#include \"color.h\"\nint test = a::b::Green;\n",
289 EXPECT_EQ("#include \"color.h\"\nnamespace d {\nint test = a::b::Green;\n}\n",
291 EXPECT_EQ("#include \"color.h\"\nnamespace a {\nint test = b::Green;\n}\n",
295 EXPECT_EQ("#include \"bar.h\"\n::a::b::bar b;\n",
297 EXPECT_EQ("#include \"bar.h\"\nnamespace a {\n::a::b::bar b;\n}\n",
361 EXPECT_EQ(ExpectedCode, runIncludeFixer(TestCode));
365 EXPECT_EQ("#include \"bar.h\"\nclass bar;\nvoid f() {\nbar* b;\nb->f();\n}",
tools/clang/tools/extra/unittests/clang-include-fixer/find-all-symbols/FindAllSymbolsTests.cpp 128 EXPECT_EQ(1, seen(InternalSymbol));
129 EXPECT_EQ(1, seen(IncSymbol));
131 EXPECT_EQ(1, seen(DirtySymbol));
132 EXPECT_EQ(1, seen(DirtyMacro));
156 EXPECT_EQ(1, seen(Symbol));
157 EXPECT_EQ(1, used(Symbol));
161 EXPECT_EQ(1, seen(Symbol));
162 EXPECT_EQ(1, used(Symbol));
167 EXPECT_EQ(1, seen(Symbol));
168 EXPECT_EQ(1, used(Symbol));
189 EXPECT_EQ(1, seen(Symbol));
190 EXPECT_EQ(1, used(Symbol));
194 EXPECT_EQ(1, seen(Symbol));
195 EXPECT_EQ(1, used(Symbol));
220 EXPECT_EQ(1, seen(Symbol));
221 EXPECT_EQ(1, used(Symbol));
225 EXPECT_EQ(1, seen(Symbol));
226 EXPECT_EQ(1, used(Symbol));
231 EXPECT_EQ(0, seen(Symbol));
232 EXPECT_EQ(0, used(Symbol));
258 EXPECT_EQ(1, seen(Symbol));
259 EXPECT_EQ(1, used(Symbol));
275 EXPECT_EQ(1, seen(Symbol));
277 EXPECT_EQ(1, seen(Symbol));
307 EXPECT_EQ(1, seen(Symbol));
308 EXPECT_EQ(1, used(Symbol));
312 EXPECT_EQ(1, seen(Symbol));
313 EXPECT_EQ(1, used(Symbol));
317 EXPECT_EQ(1, seen(Symbol));
318 EXPECT_EQ(1, used(Symbol));
323 EXPECT_EQ(1, seen(Symbol));
324 EXPECT_EQ(1, used(Symbol));
347 EXPECT_EQ(1, seen(Symbol));
348 EXPECT_EQ(1, used(Symbol));
352 EXPECT_EQ(1, seen(Symbol));
353 EXPECT_EQ(1, used(Symbol));
358 EXPECT_EQ(1, seen(Symbol));
359 EXPECT_EQ(1, used(Symbol));
364 EXPECT_EQ(1, seen(Symbol));
365 EXPECT_EQ(1, used(Symbol));
369 EXPECT_EQ(1, seen(Symbol));
370 EXPECT_EQ(1, used(Symbol));
379 EXPECT_EQ(1, seen(Symbol));
380 EXPECT_EQ(1, used(Symbol));
399 EXPECT_EQ(1, seen(Symbol));
400 EXPECT_EQ(1, used(Symbol));
403 EXPECT_EQ(1, seen(Symbol));
404 EXPECT_EQ(1, used(Symbol));
408 EXPECT_EQ(1, seen(Symbol));
409 EXPECT_EQ(1, used(Symbol));
434 EXPECT_EQ(1, seen(Symbol));
435 EXPECT_EQ(0, used(Symbol));
440 EXPECT_EQ(1, seen(Symbol));
441 EXPECT_EQ(1, used(Symbol));
446 EXPECT_EQ(1, seen(Symbol));
447 EXPECT_EQ(1, used(Symbol));
451 EXPECT_EQ(1, seen(Symbol));
452 EXPECT_EQ(1, used(Symbol));
456 EXPECT_EQ(0, seen(Symbol));
457 EXPECT_EQ(0, used(Symbol));
461 EXPECT_EQ(1, seen(Symbol));
462 EXPECT_EQ(1, used(Symbol));
465 EXPECT_EQ(1, seen(Symbol));
466 EXPECT_EQ(1, used(Symbol));
468 EXPECT_EQ(0, seen(Symbol));
469 EXPECT_EQ(0, used(Symbol));
473 EXPECT_EQ(0, seen(Symbol));
474 EXPECT_EQ(0, used(Symbol));
479 EXPECT_EQ(0, seen(Symbol));
482 EXPECT_EQ(0, seen(Symbol));
498 EXPECT_EQ(1, seen(Symbol));
499 EXPECT_EQ(1, used(Symbol));
516 EXPECT_EQ(1, seen(Symbol));
517 EXPECT_EQ(1, used(Symbol));
520 EXPECT_EQ(1, seen(Symbol));
521 EXPECT_EQ(1, used(Symbol));
524 EXPECT_EQ(1, seen(Symbol));
525 EXPECT_EQ(1, used(Symbol));
543 EXPECT_EQ(1, seen(Symbol));
544 EXPECT_EQ(1, used(Symbol));
547 EXPECT_EQ(1, seen(Symbol));
548 EXPECT_EQ(1, used(Symbol));
551 EXPECT_EQ(1, seen(Symbol));
552 EXPECT_EQ(1, used(Symbol));
565 EXPECT_EQ(1, seen(Symbol));
569 EXPECT_EQ(0, seen(Symbol));
573 EXPECT_EQ(0, seen(Symbol));
tools/clang/tools/extra/unittests/clang-move/ClangMoveTests.cpp 259 EXPECT_EQ(ExpectedTestHeader, Results[Spec.OldHeader]);
260 EXPECT_EQ(ExpectedTestCC, Results[Spec.OldCC]);
261 EXPECT_EQ(ExpectedNewHeader, Results[Spec.NewHeader]);
262 EXPECT_EQ(ExpectedHeader + ExpectedNewCC, Results[Spec.NewCC]);
271 EXPECT_EQ(2u, Results.size());
272 EXPECT_EQ(ExpectedTestHeader, Results[Spec.OldHeader]);
273 EXPECT_EQ(ExpectedNewHeader, Results[Spec.NewHeader]);
283 EXPECT_EQ(2u, Results.size());
284 EXPECT_EQ(ExpectedTestCC, Results[Spec.OldCC]);
285 EXPECT_EQ(ExpectedHeader + ExpectedNewCC, Results[Spec.NewCC]);
296 EXPECT_EQ(0u, Results.size());
320 EXPECT_EQ("", Results[Spec.OldHeader]);
321 EXPECT_EQ(ExpectedNewHeader, Results[Spec.NewHeader]);
322 EXPECT_EQ(ExpectedNewCC, Results[Spec.NewCC]);
344 EXPECT_EQ(Header, Results[Spec.NewHeader]);
345 EXPECT_EQ("", Results[Spec.OldHeader]);
346 EXPECT_EQ("", Results[Spec.OldCC]);
364 EXPECT_EQ(Header, Results[Spec.NewHeader]);
365 EXPECT_EQ("", Results[Spec.OldHeader]);
366 EXPECT_EQ("", Results[Spec.OldCC]);
390 EXPECT_EQ(ExpectedHeader, Results[Spec.NewHeader]);
393 EXPECT_EQ(ExpectedOldHeader, Results[Spec.OldHeader]);
412 EXPECT_EQ("", Results[Spec.OldHeader]);
413 EXPECT_EQ(Header, Results[Spec.NewHeader]);
432 EXPECT_EQ(ExpectedNewCode, Results[Spec.NewCC]);
454 EXPECT_EQ(ExpectedNewCode, Results[Spec.NewCC]);
508 EXPECT_EQ(ExpectedNewCC, Results[Spec.NewCC]);
509 EXPECT_EQ(ExpectedNewHeader, Results[Spec.NewHeader]);
531 EXPECT_EQ(ExpectedOldHeader, Results[Spec.OldHeader]);
532 EXPECT_EQ(ExpectedNewHeader, Results[Spec.NewHeader]);
556 EXPECT_EQ(ExpectedNewHeader, Results[Spec.NewHeader]);
557 EXPECT_EQ(ExpectedOldHeader, Results[Spec.OldHeader]);
tools/clang/tools/extra/unittests/clang-query/QueryEngineTest.cpp 58 EXPECT_EQ("", OS.str());
64 EXPECT_EQ("Parse error\n", OS.str());
135 EXPECT_EQ("Not a valid top-level matcher.\n", OS.str());
140 EXPECT_EQ("", OS.str());
144 EXPECT_EQ("", OS.str());
154 EXPECT_EQ("", OS.str());
158 EXPECT_EQ("1:2: Error parsing argument 1 for matcher hasName.\n"
tools/clang/tools/extra/unittests/clang-query/QueryParserTest.cpp 37 EXPECT_EQ("unknown command: foo", cast<InvalidQuery>(Q)->ErrStr);
46 EXPECT_EQ("unexpected extra input: ' me'", cast<InvalidQuery>(Q)->ErrStr);
58 EXPECT_EQ("unexpected extra input: ' me'", cast<InvalidQuery>(Q)->ErrStr);
64 EXPECT_EQ("expected variable name", cast<InvalidQuery>(Q)->ErrStr);
68 EXPECT_EQ("unknown variable: 'foo'", cast<InvalidQuery>(Q)->ErrStr);
72 EXPECT_EQ("expected 'diag', 'print', 'detailed-ast' or 'dump', got ''",
77 EXPECT_EQ("unexpected extra input: ' foo'", cast<InvalidQuery>(Q)->ErrStr);
81 EXPECT_EQ("expected 'diag', 'print', 'detailed-ast' or 'dump', got 'foo'",
86 EXPECT_EQ(&QuerySession::DetailedASTOutput, cast<SetExclusiveOutputQuery>(Q)->Var);
90 EXPECT_EQ(&QuerySession::DetailedASTOutput, cast<SetExclusiveOutputQuery>(Q)->Var);
94 EXPECT_EQ(&QuerySession::DetailedASTOutput, cast<EnableOutputQuery>(Q)->Var);
98 EXPECT_EQ("expected variable name", cast<InvalidQuery>(Q)->ErrStr);
102 EXPECT_EQ(&QuerySession::DetailedASTOutput, cast<DisableOutputQuery>(Q)->Var);
106 EXPECT_EQ("expected 'true' or 'false', got 'foo'",
111 EXPECT_EQ(&QuerySession::BindRoot, cast<SetQuery<bool> >(Q)->Var);
112 EXPECT_EQ(true, cast<SetQuery<bool> >(Q)->Value);
128 EXPECT_EQ("foo", cast<LetQuery>(Q)->Name);
134 EXPECT_EQ("foo", cast<LetQuery>(Q)->Name);
140 EXPECT_EQ("bar", cast<LetQuery>(Q)->Name);
142 EXPECT_EQ("str", cast<LetQuery>(Q)->Value.getString());
146 EXPECT_EQ("expected variable name", cast<InvalidQuery>(Q)->ErrStr);
150 EXPECT_EQ("x", cast<LetQuery>(Q)->Name);
155 EXPECT_EQ("expected variable name", cast<InvalidQuery>(Q)->ErrStr);
159 EXPECT_EQ("unexpected extra input: ' bad_data'",
178 EXPECT_EQ("help ", Comps[0].TypedText);
179 EXPECT_EQ("help", Comps[0].DisplayText);
180 EXPECT_EQ("let ", Comps[1].TypedText);
181 EXPECT_EQ("let", Comps[1].DisplayText);
182 EXPECT_EQ("match ", Comps[2].TypedText);
183 EXPECT_EQ("match", Comps[2].DisplayText);
184 EXPECT_EQ("quit ", Comps[3].TypedText);
185 EXPECT_EQ("quit", Comps[3].DisplayText);
186 EXPECT_EQ("set ", Comps[4].TypedText);
187 EXPECT_EQ("set", Comps[4].DisplayText);
188 EXPECT_EQ("enable ", Comps[5].TypedText);
189 EXPECT_EQ("enable", Comps[5].DisplayText);
190 EXPECT_EQ("disable ", Comps[6].TypedText);
191 EXPECT_EQ("disable", Comps[6].DisplayText);
192 EXPECT_EQ("unlet ", Comps[7].TypedText);
193 EXPECT_EQ("unlet", Comps[7].DisplayText);
197 EXPECT_EQ("utput ", Comps[0].TypedText);
198 EXPECT_EQ("output", Comps[0].DisplayText);
202 EXPECT_EQ("output ", Comps[0].TypedText);
203 EXPECT_EQ("output", Comps[0].DisplayText);
208 EXPECT_EQ("diag ", Comps[0].TypedText);
209 EXPECT_EQ("diag", Comps[0].DisplayText);
210 EXPECT_EQ("print ", Comps[1].TypedText);
211 EXPECT_EQ("print", Comps[1].DisplayText);
212 EXPECT_EQ("detailed-ast ", Comps[2].TypedText);
213 EXPECT_EQ("detailed-ast", Comps[2].DisplayText);
214 EXPECT_EQ("dump ", Comps[3].TypedText);
215 EXPECT_EQ("dump", Comps[3].DisplayText);
219 EXPECT_EQ("Stmt(", Comps[0].TypedText);
220 EXPECT_EQ("Matcher<Stmt> whileStmt(Matcher<WhileStmt>...)",
225 EXPECT_EQ("atch ", Comps[0].TypedText);
226 EXPECT_EQ("match", Comps[0].DisplayText);
230 EXPECT_EQ("et ", Comps[0].TypedText);
231 EXPECT_EQ("let", Comps[0].DisplayText);
tools/clang/tools/extra/unittests/clang-tidy/ClangTidyDiagnosticConsumerTest.cpp 27 EXPECT_EQ(2ul, Errors.size());
28 EXPECT_EQ("type specifier", Errors[0].Message.Message);
29 EXPECT_EQ("variable", Errors[1].Message.Message);
tools/clang/tools/extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp 40 EXPECT_EQ(3u, Options.LineFilter.size());
41 EXPECT_EQ("file1.cpp", Options.LineFilter[0].Name);
42 EXPECT_EQ(3u, Options.LineFilter[0].LineRanges.size());
43 EXPECT_EQ(3u, Options.LineFilter[0].LineRanges[0].first);
44 EXPECT_EQ(15u, Options.LineFilter[0].LineRanges[0].second);
45 EXPECT_EQ(20u, Options.LineFilter[0].LineRanges[1].first);
46 EXPECT_EQ(30u, Options.LineFilter[0].LineRanges[1].second);
47 EXPECT_EQ(42u, Options.LineFilter[0].LineRanges[2].first);
48 EXPECT_EQ(42u, Options.LineFilter[0].LineRanges[2].second);
49 EXPECT_EQ("file2.h", Options.LineFilter[1].Name);
50 EXPECT_EQ(0u, Options.LineFilter[1].LineRanges.size());
51 EXPECT_EQ("file3.cc", Options.LineFilter[2].Name);
52 EXPECT_EQ(1u, Options.LineFilter[2].LineRanges.size());
53 EXPECT_EQ(100u, Options.LineFilter[2].LineRanges[0].first);
54 EXPECT_EQ(1000u, Options.LineFilter[2].LineRanges[0].second);
64 EXPECT_EQ("-*,misc-*", *Options->Checks);
65 EXPECT_EQ(".*", *Options->HeaderFilterRegex);
66 EXPECT_EQ("some.user", *Options->User);
89 EXPECT_EQ("check1,check2,check3,check4", *Options.Checks);
90 EXPECT_EQ("filter2", *Options.HeaderFilterRegex);
91 EXPECT_EQ("user2", *Options.User);
93 EXPECT_EQ("arg1,arg2,arg3,arg4", llvm::join(Options.ExtraArgs->begin(),
96 EXPECT_EQ("arg-before1,arg-before2,arg-before3,arg-before4",
tools/clang/tools/extra/unittests/clang-tidy/GoogleModuleTest.cpp 24 EXPECT_EQ("class C { explicit C(int i); };",
29 EXPECT_EQ("class C { explicit C(int i, int j = 0); };",
35 EXPECT_EQ("class C { explicit C(int i); }; C::C(int i) {}",
41 EXPECT_EQ("class A { A(const A&); };\n"
51 EXPECT_EQ(
tools/clang/tools/extra/unittests/clang-tidy/IncludeInserterTest.cpp 165 EXPECT_EQ(PostCode, runCheckOnCode<NonSystemHeaderInserterCheck>(
196 EXPECT_EQ(PostCode, runCheckOnCode<MultipleHeaderInserterCheck>(
226 EXPECT_EQ(PostCode, runCheckOnCode<NonSystemHeaderInserterCheck>(
258 EXPECT_EQ(PostCode, runCheckOnCode<NonSystemHeaderInserterCheck>(
277 EXPECT_EQ(PreCode, runCheckOnCode<NonSystemHeaderInserterCheck>(
304 EXPECT_EQ(PostCode, runCheckOnCode<NonSystemHeaderInserterCheck>(
325 EXPECT_EQ(PostCode, runCheckOnCode<NonSystemHeaderInserterCheck>(
355 EXPECT_EQ(PostCode, runCheckOnCode<CXXSystemIncludeInserterCheck>(
383 EXPECT_EQ(PostCode, runCheckOnCode<CXXSystemIncludeInserterCheck>(
413 EXPECT_EQ(PostCode, runCheckOnCode<CXXSystemIncludeInserterCheck>(
438 EXPECT_EQ(PostCode, runCheckOnCode<CXXSystemIncludeInserterCheck>(
467 EXPECT_EQ(PostCode, runCheckOnCode<CXXSystemIncludeInserterCheck>(
488 EXPECT_EQ(PostCode, runCheckOnCode<CXXSystemIncludeInserterCheck>(
513 EXPECT_EQ(PostCode, runCheckOnCode<CSystemIncludeInserterCheck>(
530 EXPECT_EQ(PostCode, runCheckOnCode<CXXSystemIncludeInserterCheck>(
566 EXPECT_EQ(PostCode, runCheckOnCode<EarlyInAlphabetHeaderInserterCheck>(
601 EXPECT_EQ(PostCode, runCheckOnCode<EarlyInAlphabetHeaderInserterCheck>(
tools/clang/tools/extra/unittests/clang-tidy/LLVMModuleTest.cpp 50 EXPECT_EQ("#ifndef LLVM_ADT_FOO_H\n"
61 EXPECT_EQ("#ifndef LLVM_ADT_FOO_H_\n"
69 EXPECT_EQ("#ifndef LLVM_CLANG_C_BAR_H\n"
77 EXPECT_EQ("#ifndef LLVM_CLANG_LIB_CODEGEN_C_H\n"
85 EXPECT_EQ("#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_X_H\n"
93 EXPECT_EQ(
106 EXPECT_EQ(
119 EXPECT_EQ("#ifndef LLVM_CLANG_BAR_H\n"
136 EXPECT_EQ("#ifndef LLVM_ADT_FOO_H\n"
146 EXPECT_EQ("#ifndef LLVM_ADT_FOO_H\n"
156 EXPECT_EQ("#ifndef LLVM_ADT_FOO_H\n"
167 EXPECT_EQ("#ifndef LLVM_ADT_FOO_H\n"
175 EXPECT_EQ("#ifndef LLVM_ADT_FOO_H_\n"
183 EXPECT_EQ("#ifndef LLVM_ADT_FOO_H\n"
193 EXPECT_EQ("#ifndef LLVM_ADT_FOO_H\n"
205 EXPECT_EQ("#ifndef LLVM_ADT_FOO_H\n"
215 EXPECT_EQ("#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_FOO_H\n"
tools/clang/tools/extra/unittests/clang-tidy/NamespaceAliaserTest.cpp 63 EXPECT_EQ(ExpectedWarningCount, errors.size());
68 EXPECT_EQ("#include \"foo.h\"\n"
78 EXPECT_EQ(
87 EXPECT_EQ("#include \"foo.h\"\n"
97 EXPECT_EQ("#include \"foo.h\"\n"
107 EXPECT_EQ("#include \"foo.h\"\n"
tools/clang/tools/extra/unittests/clang-tidy/ObjCModuleTest.cpp 28 EXPECT_EQ(0ul, Errors.size());
40 EXPECT_EQ(1ul, Errors.size());
41 EXPECT_EQ(
tools/clang/tools/extra/unittests/clang-tidy/OverlappingReplacementsTest.cpp 153 EXPECT_EQ(CharFix, runCheckOnCode<UseCharCheck>(Code));
176 EXPECT_EQ(IfFix, runCheckOnCode<IfFalseCheck>(Code));
201 EXPECT_EQ(StartsFix, runCheckOnCode<StartsWithPotaCheck>(Code));
226 EXPECT_EQ(EndsFix, runCheckOnCode<EndsWithTatoCheck>(Code));
247 EXPECT_EQ(CharIfFix, Res);
257 EXPECT_EQ(StartsEndsFix, Res);
268 EXPECT_EQ(CharIfStartsEndsFix, Res);
297 EXPECT_EQ(CharIfFix, Res);
299 EXPECT_EQ(CharIfFix, Res);
323 EXPECT_EQ(IfStartsFix, Res);
325 EXPECT_EQ(IfStartsFix, Res);
352 EXPECT_EQ(Fix, Res);
354 EXPECT_EQ(Fix, Res);
384 EXPECT_EQ(IfFix, Res);
403 EXPECT_EQ(Code, Res);
tools/clang/tools/extra/unittests/clang-tidy/ReadabilityModuleTest.cpp 14 EXPECT_EQ("namespace i {\n} // namespace i",
16 EXPECT_EQ("namespace {\n} // namespace",
18 EXPECT_EQ("namespace i { namespace j {\n} // namespace j\n } // namespace i",
24 EXPECT_EQ(
30 EXPECT_EQ("namespace i { namespace j {\n"
36 EXPECT_EQ("namespace {\n"
40 EXPECT_EQ("namespace {\n"
44 EXPECT_EQ("namespace {\n"
48 EXPECT_EQ("namespace {\n"
52 EXPECT_EQ(
57 EXPECT_EQ(
62 EXPECT_EQ(
67 EXPECT_EQ("namespace My_NameSpace123 {\n"
73 EXPECT_EQ("namespace {\n"
82 EXPECT_EQ("namespace i { namespace jJ0_ {\n"
89 EXPECT_EQ("namespace {\n"
95 EXPECT_EQ("namespace {\n"
102 EXPECT_EQ("int main() {\n"
124 EXPECT_EQ("int main() {\n"
156 EXPECT_EQ("int main() {\n"
165 EXPECT_EQ("int main() {\n"
182 EXPECT_EQ("int main() {\n"
190 EXPECT_EQ("int main() {\n"
203 EXPECT_EQ("int main() {\n"
220 EXPECT_EQ("int main() {\n"
243 EXPECT_EQ("int main() {\n"
260 EXPECT_EQ("int main() {\n"
279 EXPECT_EQ("int main() {\n"
288 EXPECT_EQ("int main() {\n"
297 EXPECT_EQ("int main() {\n"
315 EXPECT_EQ("int main() {\n"
339 EXPECT_EQ("int main() {\n"
357 EXPECT_EQ("int main() {\n"
366 EXPECT_EQ("int main() {\n"
376 EXPECT_EQ("int main() {\n"
386 EXPECT_EQ("int main() {\n"
395 EXPECT_EQ("int main() {\n"
404 EXPECT_EQ("int main() {\n"
416 EXPECT_EQ("int main() {\n"
423 EXPECT_EQ("int main() {\n"
430 EXPECT_EQ(
461 EXPECT_EQ("#define DO_IT ++i\n"
495 EXPECT_EQ("const char *f() {\n"
tools/clang/tools/extra/unittests/clang-tidy/TransformerClangTidyCheckTest.cpp 67 EXPECT_EQ(Expected, test::runCheckOnCode<IfInverterCheck>(Input));
91 EXPECT_EQ(Expected, test::runCheckOnCode<IntLitCheck>(Input));
117 EXPECT_EQ(Expected, test::runCheckOnCode<BinOpCheck>(Input));
138 EXPECT_EQ(Input,
141 EXPECT_EQ("void changed() {}",
167 EXPECT_EQ(Input, test::runCheckOnCode<ConfigurableCheck>(
171 EXPECT_EQ(Expected, test::runCheckOnCode<ConfigurableCheck>(
204 EXPECT_EQ(Expected,
220 EXPECT_EQ(Expected,
tools/clang/tools/extra/unittests/clang-tidy/UsingInserterTest.cpp 67 EXPECT_EQ(ExpectedWarningCount, errors.size());
72 EXPECT_EQ("#include \"foo.h\"\n"
86 EXPECT_EQ("#include \"foo.h\"\n"
100 EXPECT_EQ("#include \"foo.h\"\n"
tools/clang/unittests/AST/ASTImporterGenericRedeclTest.cpp 121 EXPECT_EQ(Prev->getCanonicalDecl(), Current->getCanonicalDecl());
125 EXPECT_EQ(Current->getPreviousDecl(), Prev);
129 EXPECT_EQ(CurrentT->getTemplatedDecl()->getPreviousDecl(),
148 EXPECT_EQ(FirstSpecD->getCanonicalDecl(), PrevF->getCanonicalDecl());
154 EXPECT_EQ(Current->getPreviousDecl(), Prev);
166 EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
183 EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
202 EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
224 EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
246 EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
269 EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
292 EXPECT_EQ(Imported0, Imported1);
293 EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
316 EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
341 EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
362 EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
tools/clang/unittests/AST/ASTImporterODRStrategiesTest.cpp 271 EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
286 EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
293 EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
tools/clang/unittests/AST/ASTImporterTest.cpp 261 EXPECT_EQ(D0, Redecls[0]);
273 EXPECT_EQ(D0, Redecls[0]);
274 EXPECT_EQ(D1, Redecls[1]);
275 EXPECT_EQ(D2, Redecls[2]);
335 EXPECT_EQ(Imported->getQualifiedNameAsString(), "realDecl");
342 EXPECT_EQ(0U, count);
359 EXPECT_EQ(0U, count);
402 EXPECT_EQ(Res[0], D0);
403 EXPECT_EQ(Res[1], D0);
419 EXPECT_EQ(Res[0], D0);
420 EXPECT_EQ(Res[1], D2);
421 EXPECT_EQ(Res[2], D1);
422 EXPECT_EQ(Res[3], D0);
440 EXPECT_EQ(Res[0], D0);
441 EXPECT_EQ(Res[1], D2);
442 EXPECT_EQ(Res[2], D1);
443 EXPECT_EQ(Res[3], D0);
454 EXPECT_EQ(Res[0], D0);
455 EXPECT_EQ(Res[1], D1);
456 EXPECT_EQ(Res[2], D0);
979 EXPECT_EQ(To, nullptr);
1008 EXPECT_EQ(To, nullptr);
1181 EXPECT_EQ(ToTemplated1, ToTemplated);
1195 EXPECT_EQ(ToTemplated1, ToTemplated);
1279 EXPECT_EQ(FromChooseExpr->isConditionTrue(), ToChooseExpr->isConditionTrue());
1280 EXPECT_EQ(FromChooseExpr->isConditionDependent(),
1588 EXPECT_EQ(From->getIdentifierNamespace(), To->getIdentifierNamespace());
1600 EXPECT_EQ(From->getIdentifierNamespace(), To->getIdentifierNamespace());
1690 EXPECT_EQ(1u, DeclCounterWithPredicate<ClassTemplateDecl>(
1723 EXPECT_EQ(2u, DeclCounter<CXXRecordDecl>().match(
1728 EXPECT_EQ(Loc1.getExpansionLineNumber(), Loc2.getExpansionLineNumber());
1729 EXPECT_EQ(Loc1.getExpansionColumnNumber(), Loc2.getExpansionColumnNumber());
1730 EXPECT_EQ(Loc1.getSpellingLineNumber(), Loc2.getSpellingLineNumber());
1731 EXPECT_EQ(Loc1.getSpellingColumnNumber(), Loc2.getSpellingColumnNumber());
1824 EXPECT_EQ(1u, DeclCounterWithPredicate<ClassTemplateSpecializationDecl>(
1876 EXPECT_EQ(0u, ToTU->getASTContext().getDiagnostics().getNumWarnings());
1877 EXPECT_EQ(1u,
1909 EXPECT_EQ(1u, ToTU->getASTContext().getDiagnostics().getNumWarnings());
1910 EXPECT_EQ(1u,
1928 EXPECT_EQ(Imported1->getCanonicalDecl(), Imported2->getCanonicalDecl());
2002 EXPECT_EQ(Imported1, Imported2);
2017 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
2023 EXPECT_EQ(To1->getPreviousDecl(), To0);
2035 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
2041 EXPECT_EQ(To1->getPreviousDecl(), To0);
2059 EXPECT_EQ(To->size_overridden_methods(), 1u);
2099 EXPECT_EQ(1u,
2126 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFP), 1u);
2127 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, DFP), 1u);
2164 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFP), 1u);
2165 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, DFP), 1u);
2166 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFDefP), 1u);
2167 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, DFDefP), 1u);
2168 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, FDefAllP), 2u);
2196 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFP), 1u);
2197 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFDefP), 0u);
2209 EXPECT_EQ(ToBFOutOfClass->getDeclContext(), ToB);
2210 EXPECT_EQ(ToBFOutOfClass->getLexicalDeclContext(), ToTU);
2213 EXPECT_EQ(ToBFOutOfClass->getPreviousDecl(), ToBFInClass);
2256 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFP), 1u);
2257 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, DFP), 1u);
2258 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFDefP), 0u);
2259 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, DFDefP), 0u);
2276 EXPECT_EQ(ToBFOutOfClass->getDeclContext(), ToB);
2277 EXPECT_EQ(ToBFOutOfClass->getLexicalDeclContext(), ToTU);
2282 EXPECT_EQ(ToDFOutOfClass->getDeclContext(), ToD);
2283 EXPECT_EQ(ToDFOutOfClass->getLexicalDeclContext(), ToTU);
2286 EXPECT_EQ(ToBFOutOfClass->getPreviousDecl(), ToBFInClass);
2287 EXPECT_EQ(ToDFOutOfClass->getPreviousDecl(), ToDFInClass);
2305 EXPECT_EQ(To1->getPreviousDecl(), To0);
2438 EXPECT_EQ(ToD1, ToD2);
2460 EXPECT_EQ(ToD1, ToD2);
2536 EXPECT_EQ(ToFD->getPreviousDecl(), ImportedD);
2554 EXPECT_EQ(ToFD->getPreviousDecl(), ImportedD);
2572 EXPECT_EQ(ToFD->getPreviousDecl(), ImportedD);
2590 EXPECT_EQ(ToFD->getPreviousDecl(), ImportedD);
2615 EXPECT_EQ(InClassFD->getPreviousDecl(), ImportedD);
2617 EXPECT_EQ((*InClassFD->param_begin())->getOriginalType(),
2644 EXPECT_EQ(ImportedD->getPreviousDecl(), OutOfClassFD);
2646 EXPECT_EQ((*OutOfClassFD->param_begin())->getOriginalType(),
2671 EXPECT_EQ(ImportedD1->getPreviousDecl(), ImportedD);
2698 EXPECT_EQ(LookupRes.size(), 0u);
2700 EXPECT_EQ(LookupRes.size(), 1u);
2702 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, FunctionPattern), 1u);
2744 EXPECT_EQ(LookupRes.size(), 0u);
2747 EXPECT_EQ(LookupRes.size(), 1u);
2789 EXPECT_EQ(LookupRes.size(), 0u);
2791 EXPECT_EQ(LookupRes.size(), 1u);
2793 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, FunctionPattern), 2u);
2831 EXPECT_EQ(LookupRes.size(), 1u);
2832 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 1u);
2836 EXPECT_EQ(LookupRes.size(), 1u);
2837 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
2873 EXPECT_EQ(Fr, ToFriend);
2876 EXPECT_EQ(FrN, 1u);
3042 EXPECT_EQ(ToClass, ImportedClass);
3043 EXPECT_EQ(DeclCounter<CXXMethodDecl>().match(ToClass, MethodMatcher),
3121 EXPECT_EQ(ToR1, ToR2);
3161 EXPECT_EQ(ToF1, ToF2);
3201 EXPECT_EQ(ToM1, ToM2);
3287 EXPECT_EQ(*ToIndex, FromIndex);
3291 EXPECT_EQ(FromIndex, 3u);
3334 EXPECT_EQ(ImportedSpec, ToSpec);
3378 EXPECT_EQ(ImportedSpec, ToSpec);
3416 EXPECT_EQ(1u, ToTU->getASTContext().getDiagnostics().getNumWarnings());
3422 EXPECT_EQ(1u,
3465 EXPECT_EQ(ImportedSpec, ToSpec);
3491 EXPECT_EQ(ImportedSpec, ToSpec);
3492 EXPECT_EQ(1u, DeclCounter<ClassTemplatePartialSpecializationDecl>().match(
3516 EXPECT_EQ(ImportedSpec, ToSpec);
3517 EXPECT_EQ(1u, DeclCounter<ClassTemplateSpecializationDecl>().match(
3546 EXPECT_EQ(1u, DeclCounter<ClassTemplatePartialSpecializationDecl>().match(
3549 EXPECT_EQ(1u, DeclCounter<ClassTemplateSpecializationDecl>().match(
3597 EXPECT_EQ(ToD1->getPreviousDecl(), ToD0);
3674 EXPECT_EQ(DeclCounter<RecordDecl>().match(ToTU, Pattern), 2u);
3679 EXPECT_EQ(ToDef->getPreviousDecl(), ToProto);
3692 EXPECT_EQ(DeclCounter<RecordDecl>().match(ToTU, Pattern), 2u);
3697 EXPECT_EQ(ToDef->getPreviousDecl(), ToProto);
3712 EXPECT_EQ(DeclCounter<RecordDecl>().match(ToTU, Pattern), 2u);
3719 EXPECT_EQ(ToDef->getPreviousDecl(), ToProto);
3756 EXPECT_EQ(ToFriendClass->getDefinition(), ToClass);
3757 EXPECT_EQ(ToFriendClass->getPreviousDecl(), ToClass);
3758 EXPECT_EQ(ToFriendClass->getDescribedClassTemplate()->getPreviousDecl(),
3801 EXPECT_EQ(Friend->getFriendDecl()->getPreviousDecl(), Class);
3830 EXPECT_EQ(DeclCounter<ClassTemplateSpecializationDecl>().match(ToTU, Pattern),
3833 EXPECT_EQ(Imported2->getPreviousDecl(), Imported1);
3860 EXPECT_EQ(Imported0->getTemplatedDecl()->getTypeForDecl(),
3899 EXPECT_EQ(ToDecl, ImportedDef->getPreviousDecl());
3900 EXPECT_EQ(ToDecl->getTemplatedDecl(),
3930 EXPECT_EQ(ImportedFwd, ImportedDef->getPreviousDecl());
3931 EXPECT_EQ(ImportedFwd->getTemplatedDecl(),
3960 EXPECT_EQ(ImportedFwd, ImportedDef->getPreviousDecl());
3978 EXPECT_EQ(ImportedFoo, ToFoo);
4152 EXPECT_EQ(SpecD, FirstSpecD);
4177 EXPECT_EQ(
4217 EXPECT_EQ(0u, ToTU->getASTContext().getDiagnostics().getNumWarnings());
4269 EXPECT_EQ(ToD->getNumTemplateParameterLists(), 1u);
4280 EXPECT_EQ(*Res.begin(), D);
4314 EXPECT_EQ(FoundDecls.size(), 0u);
4318 EXPECT_EQ(FoundDecls.size(), 0u);
4321 EXPECT_EQ(findInDeclListOfDC(FooDC, FooName), nullptr);
4324 EXPECT_EQ(findInDeclListOfDC(FooLexicalDC, FooName), nullptr);
4330 EXPECT_EQ(*Res.begin(), Foo);
4350 EXPECT_EQ(FoundDecls.size(), 0u);
4354 EXPECT_EQ(FoundDecls.size(), 0u);
4357 EXPECT_EQ(findInDeclListOfDC(FooDC, FooName), nullptr);
4360 EXPECT_EQ(findInDeclListOfDC(FooLexicalDC, FooName), Foo);
4366 EXPECT_EQ(*Res.begin(), Foo);
4384 EXPECT_EQ(*Res.begin(), FirstDeclMatcher<FieldDecl>().match(
4389 EXPECT_EQ(*Res.begin(), FirstDeclMatcher<FieldDecl>().match(
4394 EXPECT_EQ(*Res.begin(), FirstDeclMatcher<VarDecl>().match(
4413 EXPECT_EQ(Res.size(), 3u);
4414 EXPECT_EQ(Res.count(F0), 1u);
4415 EXPECT_EQ(Res.count(F2), 1u);
4435 EXPECT_EQ(ResPlus.size(), 1u);
4436 EXPECT_EQ(ResPlus.count(FPlus), 1u);
4437 EXPECT_EQ(ResPlus.count(FMinus), 0u);
4440 EXPECT_EQ(ResMinus.size(), 1u);
4441 EXPECT_EQ(ResMinus.count(FMinus), 1u);
4442 EXPECT_EQ(ResMinus.count(FPlus), 0u);
4471 EXPECT_EQ(*Res.begin(), ToPlus);
4501 EXPECT_EQ(Res.size(), 1u);
4502 EXPECT_EQ(*Res.begin(), RD);
4505 EXPECT_EQ(Res.size(), 0u);
4526 EXPECT_EQ(Res.size(), 1u);
4527 EXPECT_EQ(*Res.begin(), RD);
4530 EXPECT_EQ(Res.size(), 0u);
4551 EXPECT_EQ(Res.count(Alias), 1u);
4566 EXPECT_EQ(Res.size(), 2u);
4567 EXPECT_EQ(Res.count(F), 1u);
4568 EXPECT_EQ(Res.count(F->getTemplatedDecl()), 1u);
4589 EXPECT_EQ(Res.size(), 2u);
4590 EXPECT_EQ(Res.count(F), 1u);
4591 EXPECT_EQ(Res.count(F->getTemplatedDecl()), 1u);
4612 EXPECT_EQ(Res.count(F), 1u);
4613 EXPECT_EQ(Res.count(F->getTemplatedDecl()), 1u);
4614 EXPECT_EQ(Res.count(*F->spec_begin()), 1u);
4629 EXPECT_EQ(Res.size(), 1u);
4630 EXPECT_EQ(*Res.begin(), F);
4665 EXPECT_EQ(FoundDecls.size(), 1u);
4666 EXPECT_EQ(FoundDecls[0], FieldInTemplate);
4670 EXPECT_EQ(*Res.begin(), FieldInTemplate);
4674 EXPECT_EQ(FoundDecls.size(), 1u);
4675 EXPECT_EQ(FoundDecls[0], FieldInSpec);
4679 EXPECT_EQ(*Res.begin(), FieldInSpec);
4694 EXPECT_EQ(Res.size(), 2u);
4695 EXPECT_EQ(Res.count(F), 1u);
4696 EXPECT_EQ(Res.count(F->getTemplatedDecl()), 1u);
4724 EXPECT_EQ(Res.size(), 1u);
4725 EXPECT_EQ(*Res.begin(), X);
4750 EXPECT_EQ(FoundDecls.size(), 1u);
4754 EXPECT_EQ(FoundDecls.size(), 1u);
4759 EXPECT_EQ(*Res.begin(), A);
4764 EXPECT_EQ(*Res.begin(), A);
4785 EXPECT_EQ(*Res.begin(), A);
4821 EXPECT_EQ(ToFwd->getCanonicalDecl(), ToDef->getCanonicalDecl());
4824 EXPECT_EQ(0u, ToTU->getASTContext().getDiagnostics().getNumWarnings());
4849 EXPECT_EQ(Imported->getPreviousDecl(), Friend);
4898 EXPECT_EQ(DeclCounter<ClassTemplateSpecializationDecl>().match(
4906 EXPECT_EQ(OptErr->Error, ImportError::NameConflict);
4924 EXPECT_EQ(
4931 EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
4954 EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, functionDecl(hasName("f"))),
4965 EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
4968 EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
4991 EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
4998 EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
5123 EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
5163 EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
5172 EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
5207 EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
5246 EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
5272 EXPECT_EQ(ToLSize, FromLSize);
5291 EXPECT_EQ(ToLSize, FromLSize);
5351 EXPECT_EQ(ImportedDef, ToClassDef);
5396 EXPECT_EQ(ImportedX->getCanonicalDecl(), ToX->getCanonicalDecl());
5429 EXPECT_EQ(ImportedType, ToType);
5456 EXPECT_EQ(ToD1->getCanonicalDecl(), ToD2->getCanonicalDecl());
5478 EXPECT_EQ(ImportedX->isAggregate(), FromX->isAggregate());
5574 EXPECT_EQ(DeclCounter<CXXRecordDecl>().match(ToTU, cxxRecordDecl(isLambda())),
5598 EXPECT_EQ(DeclCounter<CXXRecordDecl>().match(ToTU, cxxRecordDecl(isLambda())),
tools/clang/unittests/AST/ASTImporterVisibilityTest.cpp 113 EXPECT_EQ(ToD1->getPreviousDecl(), ToD0);
205 EXPECT_EQ(ToD1->getPreviousDecl(), ToD0);
223 EXPECT_EQ(ToD1->getPreviousDecl(), ToD0);
242 EXPECT_EQ(ToF0, ToF1);
247 EXPECT_EQ(0u, ToTu->getASTContext().getDiagnostics().getNumWarnings());
262 EXPECT_EQ(ToF0, ToF1);
267 EXPECT_EQ(0u, ToF0->getTranslationUnitDecl()
tools/clang/unittests/AST/ASTTraverserTest.cpp 92 EXPECT_EQ(Result.size(), 1u);
98 EXPECT_EQ(dumpASTString(ast_type_traits::DynTypedNode::create(Node)),
105 EXPECT_EQ(dumpASTString(ast_type_traits::DynTypedNode::create(*Node)),
112 EXPECT_EQ(dumpASTString(Node), DumpString);
190 EXPECT_EQ(dumpASTString(A), expectedString);
210 EXPECT_EQ(dumpASTString(Comment, Comment), expectedString);
216 EXPECT_EQ(Result.size(), 1u);
234 EXPECT_EQ(toTargetAddressSpace(static_cast<LangAS>(AS->getAddressSpace())),
tools/clang/unittests/AST/ASTTypeTraitsTest.cpp 45 EXPECT_EQ(0u, Distance);
48 EXPECT_EQ(1u, Distance);
52 EXPECT_EQ(2u, Distance);
109 EXPECT_EQ("<None>", ASTNodeKind().asStringRef());
tools/clang/unittests/AST/CommentTextTest.cpp 67 EXPECT_EQ(ExpectedOutput, Formatted);
77 EXPECT_EQ(ExpectedOutput, Formatted);
87 EXPECT_EQ(ExpectedOutput, Formatted);
97 EXPECT_EQ(ExpectedOutput, Formatted);
107 EXPECT_EQ(ExpectedOutput, Formatted);
123 EXPECT_EQ(ExpectedOutput, Formatted);
tools/clang/unittests/AST/EvaluateAsRValueTest.cpp 47 EXPECT_EQ(WasEvaluated, Init->isConstantInitializer(VD->getASTContext(),
74 EXPECT_EQ(2u, VarInfo.size());
77 EXPECT_EQ(2u, VarInfo.size());
tools/clang/unittests/AST/ExternalASTSourceTest.cpp 81 EXPECT_EQ(1u, Calls);
tools/clang/unittests/AST/StructuralEquivalenceTest.cpp 91 EXPECT_EQ(Eq01, Eq10);
tools/clang/unittests/ASTMatchers/ASTMatchersInternalTest.cpp 110 EXPECT_EQ(1u, Records.size());
111 EXPECT_EQ("MyID", Records.begin()->getKey());
tools/clang/unittests/ASTMatchers/ASTMatchersTest.h 405 EXPECT_EQ(ExpectedCount, Count);
408 EXPECT_EQ(ExpectedName, Name);
415 EXPECT_EQ(0, Count);
416 EXPECT_EQ("", Name);
433 EXPECT_EQ(Nodes->getNodeAs<T>(Id), I->second.get<T>());
tools/clang/unittests/ASTMatchers/Dynamic/ParserTest.cpp 81 EXPECT_EQ(2U, Sema.Values.size());
93 EXPECT_EQ(5U, Sema.Values.size());
94 EXPECT_EQ(1.0, Sema.Values[0].getDouble());
95 EXPECT_EQ("1:1: Error parsing numeric literal: <2.0f>", Sema.Errors[1]);
96 EXPECT_EQ(34.56e-78, Sema.Values[2].getDouble());
97 EXPECT_EQ(4e+6, Sema.Values[3].getDouble());
108 EXPECT_EQ(5U, Sema.Values.size());
109 EXPECT_EQ(0U, Sema.Values[0].getUnsigned());
110 EXPECT_EQ(123U, Sema.Values[1].getUnsigned());
111 EXPECT_EQ(31U, Sema.Values[2].getUnsigned());
112 EXPECT_EQ("1:1: Error parsing numeric literal: <12345678901>", Sema.Errors[3]);
113 EXPECT_EQ("1:1: Error parsing numeric literal: <1a1>", Sema.Errors[4]);
121 EXPECT_EQ(3ULL, Sema.Values.size());
122 EXPECT_EQ("Foo", Sema.Values[0].getString());
123 EXPECT_EQ("", Sema.Values[1].getString());
124 EXPECT_EQ("1:1: Error parsing string token: <\"Baz>", Sema.Errors[2]);
129 EXPECT_EQ(StartLine, Range.Start.Line);
130 EXPECT_EQ(EndLine, Range.End.Line);
131 EXPECT_EQ(StartColumn, Range.Start.Column);
132 EXPECT_EQ(EndColumn, Range.End.Column);
151 EXPECT_EQ("", E);
158 EXPECT_EQ(1ULL, Sema.Values.size());
159 EXPECT_EQ(ExpectedFoo, getSingleMatcher(Sema.Values[0])->getID().second);
161 EXPECT_EQ(3ULL, Sema.Matchers.size());
163 EXPECT_EQ("Bar", Bar.MatcherName);
165 EXPECT_EQ(1ULL, Bar.Args.size());
166 EXPECT_EQ(17U, Bar.Args[0].Value.getUnsigned());
169 EXPECT_EQ("Baz", Baz.MatcherName);
171 EXPECT_EQ(1ULL, Baz.Args.size());
172 EXPECT_EQ("B A,Z", Baz.Args[0].Value.getString());
175 EXPECT_EQ("Foo", Foo.MatcherName);
177 EXPECT_EQ(2ULL, Foo.Args.size());
178 EXPECT_EQ(ExpectedBar, getSingleMatcher(Foo.Args[0].Value)->getID().second);
179 EXPECT_EQ(ExpectedBaz, getSingleMatcher(Foo.Args[1].Value)->getID().second);
180 EXPECT_EQ("Yo!", Foo.BoundID);
188 EXPECT_EQ("", E);
191 EXPECT_EQ(1ULL, Sema.Matchers.size());
195 EXPECT_EQ("1:4: Error parsing matcher. Found end-of-code while looking for ')'.", Sema.Errors[1]);
214 EXPECT_EQ("", Error.toStringFull());
223 EXPECT_EQ("", Error.toStringFull());
235 EXPECT_EQ("", Error.toStringFull());
245 EXPECT_EQ("1:1: Error parsing argument 1 for matcher hasInitializer.\n"
258 EXPECT_EQ("", Error.toStringFull());
278 EXPECT_EQ(
281 EXPECT_EQ(
285 EXPECT_EQ(
289 EXPECT_EQ(
293 EXPECT_EQ("1:1: End of code found while looking for token.",
295 EXPECT_EQ("Input value is not a matcher expression.",
297 EXPECT_EQ("1:1: Matcher not found: Foo\n"
301 EXPECT_EQ("1:7: Expected end of code.", ParseWithError("expr()a"));
302 EXPECT_EQ("1:11: Malformed bind() expression.",
304 EXPECT_EQ("1:15: Malformed bind() expression.",
306 EXPECT_EQ("1:16: Malformed bind() expression.",
308 EXPECT_EQ("1:21: Malformed bind() expression.",
310 EXPECT_EQ("1:1: Error building matcher isArrow.\n"
313 EXPECT_EQ("Input value has unresolved overloaded type: "
319 EXPECT_EQ("1:1: Error building matcher callee.\n"
331 EXPECT_EQ("Stmt(", Comps[0].TypedText);
332 EXPECT_EQ("Matcher<Stmt> whileStmt(Matcher<WhileStmt>...)",
337 EXPECT_EQ("bind(\"", Comps[0].TypedText);
338 EXPECT_EQ("bind", Comps[0].MatcherDecl);
348 EXPECT_EQ("nameX", Comps[0].TypedText);
349 EXPECT_EQ("String nameX", Comps[0].MatcherDecl);
361 EXPECT_EQ("arameter(", Comps[0].TypedText);
362 EXPECT_EQ(
366 EXPECT_EQ("aramA", Comps[1].TypedText);
367 EXPECT_EQ("Matcher<Decl> hasParamA", Comps[1].MatcherDecl);
369 EXPECT_EQ("arent(", Comps[2].TypedText);
370 EXPECT_EQ(
386 EXPECT_EQ("", Error.toStringFull());
402 EXPECT_EQ("", Error.toStringFull());
tools/clang/unittests/ASTMatchers/Dynamic/RegistryTest.cpp 49 EXPECT_EQ("", DummyError.toStringFull());
62 EXPECT_EQ("", DummyError.toStringFull()) << MatcherName;
77 EXPECT_EQ("", DummyError.toStringFull());
395 EXPECT_EQ("Incorrect argument count. (Expected = 1) != (Actual = 0)",
399 EXPECT_EQ("Incorrect argument count. (Expected = 0) != (Actual = 1)",
403 EXPECT_EQ("Incorrect argument count. (Expected = (2, )) != (Actual = 0)",
408 EXPECT_EQ("Incorrect argument count. (Expected = (1, 1)) != (Actual = 2)",
414 EXPECT_EQ("Incorrect type for arg 1. (Expected = Matcher<CXXRecordDecl>) != "
422 EXPECT_EQ("Incorrect type for arg 2. (Expected = Matcher<CXXRecordDecl>) != "
430 EXPECT_EQ(
440 EXPECT_EQ("Incorrect type for arg 1. "
485 EXPECT_EQ(0u, DeclWhileComps.size());
tools/clang/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp 23 EXPECT_EQ(kUnsigned, Value.getUnsigned());
35 EXPECT_EQ(kString, Value.getString());
36 EXPECT_EQ("String", Value.getTypeAsString());
53 EXPECT_EQ("Matcher<Stmt>", Value.getTypeAsString());
60 EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString());
69 EXPECT_EQ("Matcher<Expr>", Value.getTypeAsString());
75 EXPECT_EQ("A", Value.getString());
81 EXPECT_EQ("String", Value.getTypeAsString());
92 EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString());
96 EXPECT_EQ(true, Value.getBoolean());
104 EXPECT_EQ(3.14, Value.getDouble());
113 EXPECT_EQ(17U, Value.getUnsigned());
127 EXPECT_EQ("Nothing", Value.getTypeAsString());
tools/clang/unittests/Analysis/CFGDominatorTree.cpp 29 EXPECT_EQ(BuildResult::BuiltCFG, Result.getStatus());
37 EXPECT_EQ(cfg->size(), 4u);
40 EXPECT_EQ(ExitBlock, &cfg->getExit());
47 EXPECT_EQ(EntryBlock, &cfg->getEntry());
115 EXPECT_EQ(BuildResult::BuiltCFG, Result.getStatus());
126 EXPECT_EQ(cfg->size(), 6u);
129 EXPECT_EQ(ExitBlock, &cfg->getExit());
140 EXPECT_EQ(EntryBlock, &cfg->getEntry());
167 EXPECT_EQ(BuildResult::BuiltCFG, Result.getStatus());
tools/clang/unittests/Analysis/CFGTest.cpp 30 EXPECT_EQ(BuildResult::SawFunctionBody, BuildCFG(Code).getStatus());
40 EXPECT_EQ(BuildResult::BuiltCFG, BuildCFG(Code).getStatus());
50 EXPECT_EQ(BuildResult::BuiltCFG, BuildCFG(Code).getStatus());
56 EXPECT_EQ(BuildResult::BuiltCFG, B.getStatus());
57 EXPECT_EQ(IsLinear, B.getCFG()->isLinear());
80 EXPECT_EQ(BuildResult::BuiltCFG, B.getStatus());
108 EXPECT_EQ(ElementRef.getParent(), MainBlock);
109 EXPECT_EQ(ElementRef.getIndexInBlock(), Index);
112 EXPECT_EQ(ElementRef.getParent(), MainBlock);
122 EXPECT_EQ(MainBlock->ref_end() - MainBlock->ref_begin(), MainBlockSize + 1);
123 EXPECT_EQ(MainBlock->ref_end() - MainBlockSize - 1, MainBlock->ref_begin());
124 EXPECT_EQ(MainBlock->ref_begin() + MainBlockSize + 1, MainBlock->ref_end());
125 EXPECT_EQ(MainBlock->ref_begin()++, MainBlock->ref_begin());
126 EXPECT_EQ(++(MainBlock->ref_begin()), MainBlock->ref_begin() + 1);
132 EXPECT_EQ(ElementRef.getParent(), CMainBlock);
133 EXPECT_EQ(ElementRef.getIndexInBlock(), Index);
136 EXPECT_EQ(ElementRef.getParent(), MainBlock);
146 EXPECT_EQ(CMainBlock->ref_end() - CMainBlock->ref_begin(), MainBlockSize + 1);
147 EXPECT_EQ(CMainBlock->ref_end() - MainBlockSize - 1, CMainBlock->ref_begin());
148 EXPECT_EQ(CMainBlock->ref_begin() + MainBlockSize + 1, CMainBlock->ref_end());
149 EXPECT_EQ(CMainBlock->ref_begin()++, CMainBlock->ref_begin());
150 EXPECT_EQ(++(CMainBlock->ref_begin()), CMainBlock->ref_begin() + 1);
156 EXPECT_EQ(ElementRef.getParent(), MainBlock);
157 EXPECT_EQ(ElementRef.getIndexInBlock(), Index);
160 EXPECT_EQ(ElementRef.getParent(), MainBlock);
170 EXPECT_EQ(MainBlock->rref_end() - MainBlock->rref_begin(), MainBlockSize + 1);
171 EXPECT_EQ(MainBlock->rref_end() - MainBlockSize - 1, MainBlock->rref_begin());
172 EXPECT_EQ(MainBlock->rref_begin() + MainBlockSize + 1, MainBlock->rref_end());
173 EXPECT_EQ(MainBlock->rref_begin()++, MainBlock->rref_begin());
174 EXPECT_EQ(++(MainBlock->rref_begin()), MainBlock->rref_begin() + 1);
179 EXPECT_EQ(ElementRef.getParent(), CMainBlock);
180 EXPECT_EQ(ElementRef.getIndexInBlock(), Index);
183 EXPECT_EQ(ElementRef.getParent(), MainBlock);
193 EXPECT_EQ(CMainBlock->rref_end() - CMainBlock->rref_begin(),
195 EXPECT_EQ(CMainBlock->rref_end() - MainBlockSize - 1,
197 EXPECT_EQ(CMainBlock->rref_begin() + MainBlockSize + 1,
199 EXPECT_EQ(CMainBlock->rref_begin()++, CMainBlock->rref_begin());
200 EXPECT_EQ(++(CMainBlock->rref_begin()), CMainBlock->rref_begin() + 1);
tools/clang/unittests/Basic/CharInfoTest.cpp 18 EXPECT_EQ((unsigned)CHAR_SPACE, InfoTable[(unsigned)' ']);
19 EXPECT_EQ((unsigned)CHAR_HORZ_WS, InfoTable[(unsigned)'\t']);
20 EXPECT_EQ((unsigned)CHAR_HORZ_WS, InfoTable[(unsigned)'\f']); // ??
21 EXPECT_EQ((unsigned)CHAR_HORZ_WS, InfoTable[(unsigned)'\v']); // ??
22 EXPECT_EQ((unsigned)CHAR_VERT_WS, InfoTable[(unsigned)'\n']);
23 EXPECT_EQ((unsigned)CHAR_VERT_WS, InfoTable[(unsigned)'\r']);
24 EXPECT_EQ((unsigned)CHAR_UNDER, InfoTable[(unsigned)'_']);
25 EXPECT_EQ((unsigned)CHAR_PERIOD, InfoTable[(unsigned)'.']);
28 EXPECT_EQ((unsigned)CHAR_XLOWER, InfoTable[i]);
29 EXPECT_EQ((unsigned)CHAR_XUPPER, InfoTable[i+'A'-'a']);
33 EXPECT_EQ((unsigned)CHAR_LOWER, InfoTable[i]);
34 EXPECT_EQ((unsigned)CHAR_UPPER, InfoTable[i+'A'-'a']);
38 EXPECT_EQ((unsigned)CHAR_DIGIT, InfoTable[i]);
383 EXPECT_EQ('0', toLowercase('0'));
384 EXPECT_EQ('9', toLowercase('9'));
386 EXPECT_EQ('a', toLowercase('a'));
387 EXPECT_EQ('a', toLowercase('A'));
389 EXPECT_EQ('z', toLowercase('z'));
390 EXPECT_EQ('z', toLowercase('Z'));
392 EXPECT_EQ('.', toLowercase('.'));
393 EXPECT_EQ('_', toLowercase('_'));
395 EXPECT_EQ('/', toLowercase('/'));
396 EXPECT_EQ('\0', toLowercase('\0'));
400 EXPECT_EQ('0', toUppercase('0'));
401 EXPECT_EQ('9', toUppercase('9'));
403 EXPECT_EQ('A', toUppercase('a'));
404 EXPECT_EQ('A', toUppercase('A'));
406 EXPECT_EQ('Z', toUppercase('z'));
407 EXPECT_EQ('Z', toUppercase('Z'));
409 EXPECT_EQ('.', toUppercase('.'));
410 EXPECT_EQ('_', toUppercase('_'));
412 EXPECT_EQ('/', toUppercase('/'));
413 EXPECT_EQ('\0', toUppercase('\0'));
tools/clang/unittests/Basic/DiagnosticTest.cpp 65 EXPECT_EQ(Diags.hasFatalErrorOccurred(), FatalsAsError ? 0u : 1u);
71 EXPECT_EQ(Diags.getNumWarnings(), FatalsAsError);
87 EXPECT_EQ(ErrDiag->first, SourceLocation());
88 EXPECT_EQ(ErrDiag->second.getDiagID(), diag::err_cannot_open_file);
92 EXPECT_EQ(*Value, std::make_pair(20, 1));
93 EXPECT_EQ(Value->first, 20);
tools/clang/unittests/Basic/FileManagerTest.cpp 97 EXPECT_EQ(".", dir->getName());
104 EXPECT_EQ("x/y", dir->getName());
130 EXPECT_EQ("virtual/dir", (*dir)->getName());
134 EXPECT_EQ("virtual", (*dir)->getName());
156 EXPECT_EQ("/tmp/test", (*file)->getName());
160 EXPECT_EQ("/tmp", dir->getName());
181 EXPECT_EQ("virtual/dir/bar.h", (*file)->getName());
185 EXPECT_EQ("virtual/dir", dir->getName());
250 EXPECT_EQ(f1 ? *f1 : nullptr,
270 EXPECT_EQ(f1 ? *f1 : nullptr,
290 EXPECT_EQ(43U, file1->getUniqueID().getFile());
291 EXPECT_EQ(123, file1->getSize());
298 EXPECT_EQ(file1, *file2);
299 EXPECT_EQ(43U, (*file2)->getUniqueID().getFile());
302 EXPECT_EQ(123, (*file2)->getSize());
330 EXPECT_EQ(Path, ExpectedResult);
364 EXPECT_EQ(file->tryGetRealPathName(), ExpectedResult);
397 EXPECT_EQ((*file)->tryGetRealPathName(), ExpectedResult);
427 EXPECT_EQ(Ref.getSize(), 10);
431 EXPECT_EQ(*expectedToOptional(Manager.getFileRef("/tmp/test")), Ref);
432 EXPECT_EQ(Ref.getUID(), VirtualUID);
433 EXPECT_EQ(Ref.getSize(), 10);
439 EXPECT_EQ(BypassRef->getName(), Ref.getName());
447 EXPECT_EQ(*expectedToOptional(Manager.getFileRef("/tmp/test")), Ref);
tools/clang/unittests/Basic/SourceManagerTest.cpp 118 EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 0, &Invalid));
122 EXPECT_EQ(5U, SourceMgr.getColumnNumber(MainFileID, 4, &Invalid));
126 EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 7, &Invalid));
130 EXPECT_EQ(5U, SourceMgr.getColumnNumber(MainFileID, 11, &Invalid));
134 EXPECT_EQ(7U, SourceMgr.getColumnNumber(MainFileID, strlen(Source),
152 EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 0, nullptr));
187 EXPECT_EQ(BeginLoc.printToString(SourceMgr), "/mainFile.cpp:1:1");
188 EXPECT_EQ(EndLoc.printToString(SourceMgr), "/mainFile.cpp:4:7");
190 EXPECT_EQ(BeginEOLLoc.printToString(SourceMgr), "/mainFile.cpp:1:7");
191 EXPECT_EQ(HeaderLoc.printToString(SourceMgr), "/test-header.h:1:1");
193 EXPECT_EQ(SourceRange(BeginLoc, BeginLoc).printToString(SourceMgr),
195 EXPECT_EQ(SourceRange(BeginLoc, BeginEOLLoc).printToString(SourceMgr),
197 EXPECT_EQ(SourceRange(BeginLoc, EndLoc).printToString(SourceMgr),
199 EXPECT_EQ(SourceRange(BeginLoc, HeaderLoc).printToString(SourceMgr),
311 EXPECT_EQ(loc2, toks[1].getLocation());
312 EXPECT_EQ(loc3, toks[2].getLocation());
tools/clang/unittests/CrossTU/CrossTranslationUnitTest.cpp 102 EXPECT_EQ(FDWithDefinition->getName(), "f");
104 EXPECT_EQ(OrigSLoc, FDWithDefinition->getLocation());
170 EXPECT_EQ(ParsedIndex[E.getKey()], E.getValue());
193 EXPECT_EQ(ParsedIndex["a"], "/ctudir/b/c/d");
tools/clang/unittests/Driver/ToolChainTest.cpp 74 EXPECT_EQ(
114 EXPECT_EQ("Found candidate GCC installation: "
tools/clang/unittests/Format/CleanupTest.cpp 59 EXPECT_EQ(Expected, cleanupAroundOffsets({28, 91, 132}, Code));
75 EXPECT_EQ(Expected, cleanup(Code, Ranges));
86 EXPECT_EQ(Expected, cleanupAroundOffsets({14}, Code));
100 EXPECT_EQ(Expected, Result);
119 EXPECT_EQ(Expected, Result);
137 EXPECT_EQ(Expected, Result);
143 EXPECT_EQ(Expected, cleanupAroundOffsets({17, 19}, Code));
147 EXPECT_EQ(Expected, cleanupAroundOffsets({23}, Code));
151 EXPECT_EQ(Expected, cleanupAroundOffsets({15}, Code));
157 EXPECT_EQ(Expected, cleanupAroundOffsets({15}, Code));
161 EXPECT_EQ(Expected, cleanupAroundOffsets({15}, Code));
167 EXPECT_EQ(Expected, cleanupAroundOffsets({40}, Code));
171 EXPECT_EQ(Expected, cleanupAroundOffsets({17, 22}, Code));
179 EXPECT_EQ(Expected, cleanupAroundOffsets({30}, Code, Style));
185 EXPECT_EQ(Expected, cleanupAroundOffsets({15, 18, 29, 33}, Code));
190 EXPECT_EQ(Expected, cleanupAroundOffsets({20, 23, 34, 38}, Code));
200 EXPECT_EQ(Expected, cleanupAroundOffsets({39}, Code));
209 EXPECT_EQ(Expected, cleanupAroundOffsets({39}, Code));
216 EXPECT_EQ(Expected, cleanupAroundOffsets({42, 44}, Code));
222 EXPECT_EQ(Expected, cleanupAroundOffsets({24, 26}, Code));
234 EXPECT_EQ(Expected, Result);
241 EXPECT_EQ(Expected, Result);
248 EXPECT_EQ(Expected, cleanupAroundOffsets({25, 40}, Code));
252 EXPECT_EQ(Expected, cleanupAroundOffsets({25}, Code));
256 EXPECT_EQ(Expected, cleanupAroundOffsets({38}, Code));
260 EXPECT_EQ(Expected, cleanupAroundOffsets({40}, Code));
264 EXPECT_EQ(Expected, cleanupAroundOffsets({17}, Code));
268 EXPECT_EQ(Expected, cleanupAroundOffsets({30}, Code));
272 EXPECT_EQ(Expected, cleanupAroundOffsets({30}, Code));
289 EXPECT_EQ(Expected, Result);
362 EXPECT_EQ(Expected, formatAndApply(Code, Replaces));
383 EXPECT_EQ(Expected, apply(Code, Replaces));
405 EXPECT_EQ(Expected, apply(Code, Replaces));
422 EXPECT_EQ(Expected, formatAndApply(Code, Replaces));
442 EXPECT_EQ(Expected, formatAndApply(Code, Replaces));
454 EXPECT_EQ(Expected, apply(Code, Replaces));
480 EXPECT_EQ(Expected, formatAndApply(Code, Replaces));
492 EXPECT_EQ(Expected, apply(Code, Replaces));
504 EXPECT_EQ(Expected, apply(Code, Replaces));
tools/clang/unittests/Format/FormatTest.cpp 45 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
70 EXPECT_EQ(Expected.str(), format(Expected, Style))
72 EXPECT_EQ(Expected.str(), format(Code, Style));
78 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle));
89 EXPECT_EQ(Code.str(),
112 EXPECT_EQ("1 2 3", test::messUp("1 2 3"));
113 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n"));
114 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc"));
115 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc"));
116 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne"));
120 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language);
124 EXPECT_EQ(FormatStyle::LK_Proto,
133 EXPECT_EQ(";", format(";"));
137 EXPECT_EQ("int i;", format(" int i;"));
138 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;"));
139 EXPECT_EQ("int i;\nint j;", format(" int i; int j;"));
140 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;"));
144 EXPECT_EQ("int i;", format("int\ni;"));
148 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}"));
167 EXPECT_EQ("if (a) {\n"
171 EXPECT_EQ(4, ReplacementCount);
172 EXPECT_EQ("if (a) {\n"
178 EXPECT_EQ(0, ReplacementCount);
179 EXPECT_EQ("/*\r\n"
185 EXPECT_EQ(0, ReplacementCount);
189 EXPECT_EQ("class C {\n"
198 EXPECT_EQ("namespace N {\n"
207 EXPECT_EQ("/* something */ namespace N {\n"
216 EXPECT_EQ("inline namespace N {\n"
225 EXPECT_EQ("/* something */ inline namespace N {\n"
234 EXPECT_EQ("export namespace N {\n"
243 EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
256 EXPECT_EQ("extern \"C\" int f() {\n"
268 EXPECT_EQ("void f() {\n"
285 EXPECT_EQ("void f() {\n"
302 EXPECT_EQ("void f() {\n"
324 EXPECT_EQ("namespace {\n"
333 EXPECT_EQ("namespace {\n"
340 EXPECT_EQ("namespace {\n"
349 EXPECT_EQ("namespace {\n"
356 EXPECT_EQ("namespace {\n"
364 EXPECT_EQ("namespace {\n"
381 EXPECT_EQ("class Foo\n"
722 EXPECT_EQ("#define A \\\n"
1114 EXPECT_EQ("DEBUG({\n"
1137 EXPECT_EQ("switch (n) {\n"
1173 EXPECT_EQ("switch (n)\n"
1194 EXPECT_EQ("switch (n)\n"
1268 EXPECT_EQ("switch (a) {\n"
1300 EXPECT_EQ("switch (a) {\n"
1311 EXPECT_EQ("switch (a) {\n"
1358 EXPECT_EQ("switch (n) {\n"
1375 EXPECT_EQ("switch (n)\n"
1451 EXPECT_EQ("if (foo) {\n"
1455 EXPECT_EQ("if (foo) {\n"
1461 EXPECT_EQ("if (foo && bar) {\n"
1465 EXPECT_EQ("if (foo) {\n"
1471 EXPECT_EQ(
1480 EXPECT_EQ("for (;;) {\n"
1484 EXPECT_EQ("while (1) {\n"
1488 EXPECT_EQ("switch (foo) {\n"
1493 EXPECT_EQ("try {\n"
1499 EXPECT_EQ("do {\n"
1505 EXPECT_EQ("if (foo && bar &&\n"
1511 EXPECT_EQ("if (foo && bar &&\n"
1521 EXPECT_EQ("if (foo) {\n"
1529 EXPECT_EQ(
1541 EXPECT_EQ("for (int i = 0;\n"
1547 EXPECT_EQ("while (foo || bar ||\n"
1553 EXPECT_EQ("switch (\n"
1560 EXPECT_EQ("try {\n"
1637 EXPECT_EQ("class A {\n"
1656 EXPECT_EQ("class A {\n"
1670 EXPECT_EQ("#define B \\\n"
1686 EXPECT_EQ("#define A private:\n"
1801 EXPECT_EQ("enum KeepEmptyLines {\n"
2054 EXPECT_EQ("#ifndef HEADER_GUARD\n"
2068 EXPECT_EQ("namespace A::B {\n"
2078 EXPECT_EQ("namespace out {\n"
2093 EXPECT_EQ("namespace out {\n"
2168 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2176 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2185 EXPECT_EQ("namespace out {\n"
2194 EXPECT_EQ("TESTSUITE(out) {\n"
2204 EXPECT_EQ("TESTSUITE(out) {\n"
2224 EXPECT_EQ("namespace out { namespace in {\n"
2233 EXPECT_EQ("namespace out {\n"
2247 EXPECT_EQ("namespace out {\n"
2259 EXPECT_EQ("namespace A { namespace B { namespace C {\n"
2268 EXPECT_EQ("namespace aaaaaaaaaa {\n"
2277 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
2290 EXPECT_EQ("namespace out { namespace in {\n"
2299 EXPECT_EQ("namespace out { namespace in {\n"
2308 EXPECT_EQ("namespace out { namespace in {\n"
2317 EXPECT_EQ("namespace out { namespace mid {\n"
2329 EXPECT_EQ("namespace out { namespace in {\n"
2338 EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
2397 EXPECT_EQ(
2412 EXPECT_EQ("_asm {\n"
2424 EXPECT_EQ("__asm {\n"
2577 EXPECT_EQ("S s = {a,\n"
2702 EXPECT_EQ("#define Q \\\n"
2710 EXPECT_EQ("# 123 \"A string literal\"",
2715 EXPECT_EQ("#;", format("#;"));
2720 EXPECT_EQ("#line 42 \"test\"\n",
2722 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n",
2727 EXPECT_EQ("#line 42 \"test\"",
2729 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B"));
2735 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20"));
2740 EXPECT_EQ("const char *c = STRINGIFY(\n"
2765 EXPECT_EQ("// somecomment\n"
2780 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
2783 EXPECT_EQ("#define A \\\n"
2792 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
2795 EXPECT_EQ("int x,\n"
2802 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
2822 EXPECT_EQ("#define A (x)", format("#define A (x)"));
2823 EXPECT_EQ("#define A(x)", format("#define A(x)"));
2833 EXPECT_EQ("#define A b;", format("#define A \\\n"
2837 EXPECT_EQ("#define A \\\n"
2846 EXPECT_EQ("#define A \\\n"
2898 EXPECT_EQ("class A : public QObject {\n"
2908 EXPECT_EQ("MACRO\n"
2912 EXPECT_EQ("SOME_MACRO\n"
2921 EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
2922 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
2924 EXPECT_EQ("class A : public QObject {\n"
2933 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
2942 EXPECT_EQ("/**/ FOO(a)\n"
2949 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2963 EXPECT_EQ("int q() {\n"
2975 EXPECT_EQ("#define LIST(L) \\\n"
2986 EXPECT_EQ("int q() {\n"
3028 EXPECT_EQ("int q() {\n"
3053 EXPECT_EQ("class A {\n"
3071 EXPECT_EQ("void f()\n"
3078 EXPECT_EQ("class SomeClass {\n"
3087 EXPECT_EQ("class SomeClass {\n"
3271 EXPECT_EQ("#ifndef NOT_GUARD\n"
3286 EXPECT_EQ("#ifdef WIN32\n"
3304 EXPECT_EQ("code();\n"
3341 EXPECT_EQ(Expected, format(ToFormat, Style));
3342 EXPECT_EQ(Expected, format(Expected, Style));
3368 EXPECT_EQ(Expected, format(ToFormat, Style));
3369 EXPECT_EQ(Expected, format(Expected, Style));
3391 EXPECT_EQ(Expected, format(ToFormat, Style));
3392 EXPECT_EQ(Expected, format(Expected, Style));
3478 EXPECT_EQ(Expected, format(ToFormat, Style));
3479 EXPECT_EQ(Expected, format(Expected, Style));
3508 EXPECT_EQ(Expected, format(ToFormat, Style));
3509 EXPECT_EQ(Expected, format(Expected, Style));
3525 EXPECT_EQ("#define A \\\n { \\\n {\nint i;",
3527 EXPECT_EQ("#define A \\\n } \\\n }\nint i;",
3533 EXPECT_EQ("#define A \\\n int i; \\\n int j;",
3535 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
3536 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3537 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */"));
3538 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
3542 EXPECT_EQ("#define MACRO(x) \\\n"
3551 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;",
3553 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
3554 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3555 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */"));
3556 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
3557 EXPECT_EQ("#define MACRO(x) \\\r\n"
3570 EXPECT_EQ("#define A \\\n"
3600 EXPECT_EQ(
3616 EXPECT_EQ("int\n"
3756 EXPECT_EQ("SOME_MACRO { int i; }\n"
3784 EXPECT_EQ("call(parameter, {\n"
3796 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });"));
3797 EXPECT_EQ("DEBUG({ // comment\n"
3803 EXPECT_EQ("DEBUG({\n"
3839 EXPECT_EQ("#define MACRO() \\\n"
3849 EXPECT_EQ("#define A \\\n"
3860 EXPECT_EQ("{}", format("{}"));
3865 EXPECT_EQ("void f() { }", format("void f() {}", Style));
3867 EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
4152 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
4370 EXPECT_EQ("Constructor()\n"
4681 EXPECT_EQ("Constructor() :\n"
4948 EXPECT_EQ("const aaaa::bbbbbbb &\n"
5171 EXPECT_EQ("f(g(h(a, // comment\n"
5285 EXPECT_EQ("aaa(aaaa,\n"
5296 EXPECT_EQ("aaa(aaaa, aaaa,\n"
5959 EXPECT_EQ("fun + \"1243\" /* comment */\n"
5964 EXPECT_EQ(
6248 EXPECT_EQ("x = \"a\\\n"
6255 EXPECT_EQ("xxxx =\n"
6264 EXPECT_EQ("NSString *const kString =\n"
6341 EXPECT_EQ("llvm::errs() << \"\n"
6591 EXPECT_EQ("static_cast<A< //\n"
6655 EXPECT_EQ("// Baseline - no comments.\n"
6665 EXPECT_EQ("template <\n"
6673 EXPECT_EQ(
6681 EXPECT_EQ(
6692 EXPECT_EQ(
6799 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
6800 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
6801 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
6802 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
6803 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
6850 EXPECT_EQ("int a = 1 << 2; /* foo\n"
6855 EXPECT_EQ("int b = 256 >> 1; /* foo\n"
7353 EXPECT_EQ("#define OP(x) \\\n"
7448 EXPECT_EQ("int *a;\n"
7455 EXPECT_EQ("int* a;\n"
7462 EXPECT_EQ("int *a;\n"
7469 EXPECT_EQ("auto x = [] {\n"
7831 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\""));
7832 EXPECT_EQ("#include <a>", format("#include<a>"));
7897 EXPECT_EQ("void f() { return }", format("void f ( ) { return }"));
7898 EXPECT_EQ("void f() {\n"
7903 EXPECT_EQ("namespace N {\n"
7907 EXPECT_EQ("namespace N {\n"
7986 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n"));
7987 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n"));
7988 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n"));
7989 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n"));
7991 EXPECT_EQ("{\n"
8137 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
8156 EXPECT_EQ("function({// First element:\n"
8165 EXPECT_EQ("std::vector<int> MyNumbers{\n"
8177 EXPECT_EQ("vector<int> SomeVector = {\n"
8272 EXPECT_EQ("vector< int > x{\n"
8276 EXPECT_EQ("vector< int > x{ 1, 2,\n"
8279 EXPECT_EQ("vector< int > x{\n"
8495 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
8496 EXPECT_EQ("class C {\n"
8500 EXPECT_EQ("A()\n"
8508 EXPECT_EQ("A()\n"
8512 EXPECT_EQ("A()\n"
8969 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n",
8971 EXPECT_EQ(
8974 EXPECT_EQ("#error 1", format(" # error 1"));
8975 EXPECT_EQ("#warning 1", format(" # warning 1"));
8999 EXPECT_EQ("if (true) return 42;",
9094 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
9105 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
9107 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
9108 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
9109 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
9111 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
9113 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
9115 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
9117 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9172 EXPECT_EQ("\"some text \"\n"
9175 EXPECT_EQ("\"some text \"\n"
9178 EXPECT_EQ(
9184 EXPECT_EQ(
9191 EXPECT_EQ("\"some text\"",
9193 EXPECT_EQ("\"some text\"",
9195 EXPECT_EQ("\"some \"\n"
9198 EXPECT_EQ("\"some \"\n"
9201 EXPECT_EQ("\"some\"\n"
9205 EXPECT_EQ("\"some\"\n"
9209 EXPECT_EQ("\"some\"\n"
9214 EXPECT_EQ("variable =\n"
9220 EXPECT_EQ("variable = f(\n"
9229 EXPECT_EQ(
9234 EXPECT_EQ("f(g(\"long string \"\n"
9240 EXPECT_EQ(
9244 EXPECT_EQ("f(\"one two three four five six \"\n"
9251 EXPECT_EQ("f(\"some \"\n"
9262 EXPECT_EQ("\"splitmea\"\n"
9267 EXPECT_EQ("\"split/\"\n"
9272 EXPECT_EQ("\"split/\"\n"
9276 EXPECT_EQ("\"split at \"\n"
9293 EXPECT_EQ("aaaaaaaaaaaa(\n"
9300 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
9306 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
9311 EXPECT_EQ("ffff(\n"
9320 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
9324 EXPECT_EQ("#define A \\\n"
9332 EXPECT_EQ("C a = \"some more \"\n"
9340 EXPECT_EQ("int i = a(b());",
9345 EXPECT_EQ(
9355 EXPECT_EQ(
9359 EXPECT_EQ(
9363 EXPECT_EQ(
9367 EXPECT_EQ("L\"wide string \"\n"
9370 EXPECT_EQ("@\"NSString \"\n"
9384 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
9385 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
9386 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
9387 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
9388 EXPECT_EQ("u8R\"x(raw literal)x\";",
9394 EXPECT_EQ(
9399 EXPECT_EQ("f(x,\n"
9412 EXPECT_EQ(
9415 EXPECT_EQ("f(\n"
9425 EXPECT_EQ("f(\n"
9436 EXPECT_EQ(
9442 EXPECT_EQ("func(a,\n"
9450 EXPECT_EQ("func(a, b,\n"
9457 EXPECT_EQ("func(a,\n"
9466 EXPECT_EQ("a << \"line line \"\n"
9471 EXPECT_EQ(
9478 EXPECT_EQ(
9485 EXPECT_EQ("abcd << \"line line \"\n"
9493 EXPECT_EQ(
9499 EXPECT_EQ("abcd +\n"
9509 EXPECT_EQ("someFunction(\n"
9517 EXPECT_EQ(
9527 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
9529 EXPECT_EQ("fffffffffff(g(R\"x(\n"
9538 EXPECT_EQ("fffffffffff(\n"
9549 EXPECT_EQ("fffffffffff(R\"x(\n"
9556 EXPECT_EQ("fffffffffff(R\"x(\n"
9563 EXPECT_EQ("fffffffffff(\n"
9573 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
9580 EXPECT_EQ("function(\"unterminated,\n"
9589 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
9609 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
9613 EXPECT_EQ("someFunction1234567890(\n"
9617 EXPECT_EQ("someFunction1234567890(\n"
9622 EXPECT_EQ("someFunction1234567890(\n"
9627 EXPECT_EQ("someFunction(\n"
9632 EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
9636 EXPECT_EQ("someFunction1234567890(\n"
9641 EXPECT_EQ("#define A \\\n"
9648 EXPECT_EQ("someFunction(\n"
9656 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
9657 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
9658 EXPECT_EQ("\"test\"\n"
9661 EXPECT_EQ("\"tes\\\\\"\n"
9664 EXPECT_EQ("\"\\\\\\\\\"\n"
9667 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
9668 EXPECT_EQ("\"\\uff01\"\n"
9671 EXPECT_EQ("\"\\Uff01ff02\"",
9673 EXPECT_EQ("\"\\x000000000001\"\n"
9676 EXPECT_EQ("\"\\x000000000001next\"",
9678 EXPECT_EQ("\"\\x000000000001\"",
9680 EXPECT_EQ("\"test\"\n"
9684 EXPECT_EQ("\"test\\000\"\n"
9746 EXPECT_EQ("if (aaaaaaaa && // q\n"
9753 EXPECT_EQ("if (aaa && bbb) // w\n"
9809 EXPECT_EQ("/*\n"
9835 EXPECT_EQ("if (aaaaaaaa && // q\n"
9859 EXPECT_EQ("{\n"
9868 EXPECT_EQ("{\n"
9880 EXPECT_EQ("{\n"
9888 EXPECT_EQ("{\n"
9900 EXPECT_EQ("{\n"
9911 EXPECT_EQ("{\n"
9924 EXPECT_EQ("/*\n"
9933 EXPECT_EQ("/* some\n"
9938 EXPECT_EQ("int a; /* some\n"
9944 EXPECT_EQ("int a; /* some\n"
9949 EXPECT_EQ("f(\"\t\t\"); /* some\n"
9954 EXPECT_EQ("{\n"
9970 EXPECT_EQ("if (aaaaaaaa && // q\n"
9977 EXPECT_EQ("if (aaa && bbb) // w\n"
10025 EXPECT_EQ("/*\n"
10049 EXPECT_EQ("if (aaaaaaaa && // q\n"
10073 EXPECT_EQ("{\n"
10082 EXPECT_EQ("{\n"
10094 EXPECT_EQ("{\n"
10102 EXPECT_EQ("{\n"
10114 EXPECT_EQ("{\n"
10125 EXPECT_EQ("{\n"
10136 EXPECT_EQ("/*\n"
10145 EXPECT_EQ("/* some\n"
10150 EXPECT_EQ("int a; /* some\n"
10155 EXPECT_EQ("int a; /* some\n"
10160 EXPECT_EQ("f(\"\t\t\"); /* some\n"
10165 EXPECT_EQ("{\n"
10197 EXPECT_EQ("void a(){\n"
10205 EXPECT_EQ("void a(){\n"
10214 EXPECT_EQ("void a(){\n"
10222 EXPECT_EQ("void a(){\n"
10231 EXPECT_EQ("void a(){\n"
10239 EXPECT_EQ("void a(){\n"
10248 EXPECT_EQ("void a(){\n"
10256 EXPECT_EQ("void a(){\n"
10266 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
10273 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
10280 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
10289 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
10868 EXPECT_EQ("int a = 5;\n"
10875 EXPECT_EQ("int a = 5;\n"
10884 EXPECT_EQ("int a = 5;\n"
11044 EXPECT_EQ("float const a = 5;\n"
11051 EXPECT_EQ("float a = 5;\n"
11060 EXPECT_EQ("float a = 5;\n"
11082 EXPECT_EQ("int a(int x,\n"
11094 EXPECT_EQ("double a(int x);\n"
11153 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
11345 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
11502 EXPECT_EQ("namespace a\n"
12157 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
12166 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A"));
12174 EXPECT_EQ("/*\n"
12182 EXPECT_EQ("/*\n"
12194 EXPECT_EQ("int a; /* first line\n"
12205 EXPECT_EQ("int a; // first line\n"
12216 EXPECT_EQ("int a; // the comment\n"
12219 EXPECT_EQ("int a; /* first line\n"
12228 EXPECT_EQ("int a; // first line\n"
12237 EXPECT_EQ("int a; /* first line\n"
12245 EXPECT_EQ("// foo bar baz bazfoo\n"
12250 EXPECT_EQ("// foo bar baz bazfoo\n"
12258 EXPECT_EQ("// foo bar baz bazfoo\n"
12264 EXPECT_EQ("// foo bar baz bazfoo\n"
12272 EXPECT_EQ("// foo bar baz bazfoo\n"
12283 EXPECT_EQ(
12289 EXPECT_EQ("int a = /* long block\n"
12350 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
12357 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
12361 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
12368 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
12375 EXPECT_EQ(0, parseConfiguration("---\n"
12826 EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
12830 EXPECT_EQ(12u, Style.IndentWidth);
12832 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
12839 EXPECT_EQ(parseConfiguration("Language: Cpp\n"
12843 EXPECT_EQ(23u, Style.IndentWidth);
12845 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
12894 EXPECT_EQ(123u, Style.ColumnLimit);
12895 EXPECT_EQ(456u, Style.IndentWidth);
12896 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
12897 EXPECT_EQ(789u, Style.TabWidth);
12899 EXPECT_EQ(parseConfiguration("---\n"
12907 EXPECT_EQ(parseConfiguration("---\n"
12917 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
12926 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
12930 EXPECT_EQ(0, parseConfiguration("---\n"
12939 EXPECT_EQ(76u, Style.IndentWidth);
12940 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
12948 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
12949 EXPECT_EQ(Style, ParsedStyle);
12953 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
12964 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
12965 EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
12967 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
12993 EXPECT_EQ("\"aaaaÄ\"\n"
12996 EXPECT_EQ("\"aaaaaaaÄ\"\n"
12999 EXPECT_EQ("\"Однажды, в \"\n"
13005 EXPECT_EQ(
13011 EXPECT_EQ("\"一\t\"\n"
13022 EXPECT_EQ("\"aaaaaa\"\n"
13028 EXPECT_EQ("const char *sssss =\n"
13037 EXPECT_EQ("// aaaaÄ\xc2\x8d",
13039 EXPECT_EQ("// Я из лесу\n"
13045 EXPECT_EQ("// 一二三\n"
13053 EXPECT_EQ("/* Гляжу,\n"
13064 EXPECT_EQ(
13070 EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
13228 EXPECT_EQ("void f()\n"
13247 EXPECT_EQ("void f() { }", format("void f() {}", Style));
13248 EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
13250 EXPECT_EQ("while (true) {\n"
13270 EXPECT_EQ("SomeClass::Constructor()\n"
13303 EXPECT_EQ("ASSERT(aaaa\n"
13308 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
13315 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
13323 EXPECT_EQ("#define aNumber \\\n"
13330 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
13335 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
13342 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
13353 EXPECT_EQ(
13361 EXPECT_EQ("[self.a b:c\n"
13405 EXPECT_EQ("SomeFunction([]() {\n"
13884 EXPECT_EQ("[[SessionService sharedService]\n"
13929 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
13932 EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
13939 EXPECT_EQ("int a;\r\n"
13946 EXPECT_EQ("int a;\r\n"
13953 EXPECT_EQ("int a;\n"
13960 EXPECT_EQ("\"aaaaaaa \"\r\n"
13963 EXPECT_EQ("#define A \\\r\n"
13972 EXPECT_EQ("/*\r\n"
13982 EXPECT_EQ("/*\r\n"
14001 EXPECT_EQ("int i =\n"
14009 EXPECT_EQ("int i =\n"
14069 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
14072 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
14081 EXPECT_EQ("< < <", format("\\\n<<<"));
14099 EXPECT_EQ(code, format(code));
14104 EXPECT_EQ("int a;\n"
14131 EXPECT_EQ("void f() {\n"
14152 EXPECT_EQ("<<<<<<<\n"
14161 EXPECT_EQ("<<<<<<<\n"
14173 EXPECT_EQ("#define Macro \\\n"
14195 EXPECT_EQ("int i;\n"
14205 EXPECT_EQ("int i;\n"
14217 EXPECT_EQ("// clang-format off\n"
14248 EXPECT_EQ("auto a = new unique_ptr<int>[10];",
14253 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
14258 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
14263 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
14386 EXPECT_EQ(Expected, *Result);
14415 EXPECT_EQ(Expected, *Result);
14419 EXPECT_EQ("using std::cin;\n"
14430 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
14436 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
14440 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
14441 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
14448 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
14449 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();"));
14450 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();"));
14451 EXPECT_EQ("auto const volatile [a, b] = f();",
14453 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();"));
14454 EXPECT_EQ("auto &[a, b, c] = f();",
14456 EXPECT_EQ("auto &&[a, b, c] = f();",
14458 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();"));
14459 EXPECT_EQ("auto const volatile &&[a, b] = f();",
14461 EXPECT_EQ("auto const &&[a, b] = f();",
14463 EXPECT_EQ("const auto &[a, b] = f();",
14465 EXPECT_EQ("const auto volatile &&[a, b] = f();",
14467 EXPECT_EQ("volatile const auto &&[a, b] = f();",
14469 EXPECT_EQ("const auto &&[a, b] = f();",
14488 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
14490 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
14492 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
14494 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);"));
14495 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);"));
14496 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);"));
14497 EXPECT_EQ("auto const &[x, y](expr);",
14499 EXPECT_EQ("auto const &&[x, y](expr);",
14501 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};"));
14502 EXPECT_EQ("auto const &[x, y]{expr};",
14504 EXPECT_EQ("auto const &&[x, y]{expr};",
14517 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
14518 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
14519 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
14520 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
14521 EXPECT_EQ(FormatStyle::LK_ObjC,
14523 EXPECT_EQ(
14526 EXPECT_EQ(FormatStyle::LK_ObjC,
14528 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
14529 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
14530 EXPECT_EQ(FormatStyle::LK_ObjC,
14532 EXPECT_EQ(FormatStyle::LK_ObjC,
14534 EXPECT_EQ(
14538 EXPECT_EQ(
14544 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
14545 EXPECT_EQ(FormatStyle::LK_ObjC,
14547 EXPECT_EQ(FormatStyle::LK_Cpp,
14549 EXPECT_EQ(
14552 EXPECT_EQ(FormatStyle::LK_ObjC,
14554 EXPECT_EQ(FormatStyle::LK_Cpp,
14556 EXPECT_EQ(FormatStyle::LK_ObjC,
14558 EXPECT_EQ(FormatStyle::LK_Cpp,
14560 EXPECT_EQ(FormatStyle::LK_Cpp,
14562 EXPECT_EQ(FormatStyle::LK_ObjC,
14564 EXPECT_EQ(FormatStyle::LK_Cpp,
14566 EXPECT_EQ(
14569 EXPECT_EQ(
14573 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
14577 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
14578 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
14579 EXPECT_EQ(FormatStyle::LK_ObjC,
14581 EXPECT_EQ(FormatStyle::LK_ObjC,
14583 EXPECT_EQ(FormatStyle::LK_ObjC,
14585 EXPECT_EQ(FormatStyle::LK_ObjC,
14587 EXPECT_EQ(
14593 EXPECT_EQ(FormatStyle::LK_Cpp,
14599 EXPECT_EQ(FormatStyle::LK_Cpp,
14605 EXPECT_EQ(FormatStyle::LK_Cpp,
14611 EXPECT_EQ(FormatStyle::LK_Cpp,
14617 EXPECT_EQ(FormatStyle::LK_Cpp,
14623 EXPECT_EQ(FormatStyle::LK_Cpp,
14632 EXPECT_EQ(FormatStyle::LK_Cpp,
14634 EXPECT_EQ(FormatStyle::LK_ObjC,
14636 EXPECT_EQ(
14639 EXPECT_EQ(
tools/clang/unittests/Format/FormatTestCSharp.cpp 48 EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable";
49 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
tools/clang/unittests/Format/FormatTestComments.cpp 48 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
72 EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable";
73 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
146 EXPECT_EQ("#include \"a\" // comment\n"
158 EXPECT_EQ("enum A {\n"
175 EXPECT_EQ("enum A {\n"
184 EXPECT_EQ("enum A {\n"
193 EXPECT_EQ("enum A {\n"
204 EXPECT_EQ("enum A {\n"
236 EXPECT_EQ("void f() { // This does something ..\n"
242 EXPECT_EQ("class C {\n"
254 EXPECT_EQ("int i; // single line trailing comment",
272 EXPECT_EQ("D(a, {\n"
281 EXPECT_EQ("lineWith(); // comment\n"
287 EXPECT_EQ("lineWith(); // comment\n"
295 EXPECT_EQ("lineWith(); // comment\n"
302 EXPECT_EQ("lineWith(); // comment\n"
308 EXPECT_EQ("lineWith();\n"
314 EXPECT_EQ("// first\n"
320 EXPECT_EQ("f();\n"
332 EXPECT_EQ("f(); // comment\n"
340 EXPECT_EQ("f(); // comment\n"
348 EXPECT_EQ("void f() {\n"
356 EXPECT_EQ("int xy; // a\n"
360 EXPECT_EQ("int xy; // a\n"
379 EXPECT_EQ("if ( // This is some comment\n"
395 EXPECT_EQ("SomeFunction(a,\n"
401 EXPECT_EQ("SomeFunction(a, b,\n"
408 EXPECT_EQ("SomeFunction(a, b, // comment (unclear relation)\n"
412 EXPECT_EQ("SomeFunction(a, // comment\n"
418 EXPECT_EQ("aaaaaaaaaa(aaaa(aaaa,\n"
427 EXPECT_EQ("// comment", format("// comment "));
428 EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment",
431 EXPECT_EQ("// comment\\\n", format("// comment\\\n \t \v \f "));
432 EXPECT_EQ("// comment \\\n", format("// comment \\\n \t \v \f "));
438 EXPECT_EQ("f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n"
443 EXPECT_EQ(
448 EXPECT_EQ(
475 EXPECT_EQ("/*\n"
485 EXPECT_EQ("class C {\n"
499 EXPECT_EQ("/*\n"
509 EXPECT_EQ("/*\n"
516 EXPECT_EQ("int i; /* Comment with empty...\n"
522 EXPECT_EQ("int foobar = 0; /* comment */\n"
536 EXPECT_EQ("int foobar = 0; /* comment */\n"
556 EXPECT_EQ("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
560 EXPECT_EQ(
580 EXPECT_EQ("void ffffffffff(\n"
587 EXPECT_EQ("// A comment that\n"
592 EXPECT_EQ("/// A comment that\n"
597 EXPECT_EQ("//! A comment that\n"
602 EXPECT_EQ("// a b c d\n"
606 EXPECT_EQ(
611 EXPECT_EQ("if (true) // A comment that\n"
616 EXPECT_EQ("// Don't_touch_leading_whitespace",
619 EXPECT_EQ("// Add leading\n"
622 EXPECT_EQ("/// Add leading\n"
625 EXPECT_EQ("//! Add leading\n"
628 EXPECT_EQ("// whitespace", format("//whitespace", getLLVMStyle()));
629 EXPECT_EQ("// Even if it makes the line exceed the column\n"
633 EXPECT_EQ("//--But not here", format("//--But not here", getLLVMStyle()));
634 EXPECT_EQ("/// line 1\n"
639 EXPECT_EQ("/// line 1\n"
654 EXPECT_EQ("// aa bb cc dd",
658 EXPECT_EQ("// A comment before\n"
665 EXPECT_EQ("void ffffff(\n"
675 EXPECT_EQ("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
678 EXPECT_EQ(
682 EXPECT_EQ(
686 EXPECT_EQ("{\n"
697 EXPECT_EQ("{\n"
712 EXPECT_EQ("// A comment\n"
718 EXPECT_EQ("/// A comment\n"
727 EXPECT_EQ("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
733 EXPECT_EQ("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n"
742 EXPECT_EQ("double\n"
755 EXPECT_EQ(
758 EXPECT_EQ(
764 EXPECT_EQ("if (xxx ==\n"
771 EXPECT_EQ("if (xxxxxxxxxx ==\n"
778 EXPECT_EQ("if (xxxxxxxxxx &&\n"
785 EXPECT_EQ("fffffffff(\n"
794 EXPECT_EQ("#define A(x) /* \\\n"
803 EXPECT_EQ("#define A( \\\n"
817 EXPECT_EQ("namespace {}\n// Test\n#define A",
819 EXPECT_EQ("namespace {}\n/* Test */\n#define A",
821 EXPECT_EQ("namespace {}\n/* Test */ #define A",
828 EXPECT_EQ("void f() {\n"
841 EXPECT_EQ("void f() {\n"
856 EXPECT_EQ("int f(int i) {\n"
875 EXPECT_EQ("int f(int i) {\n"
896 EXPECT_EQ("int f(int i) {\n"
919 EXPECT_EQ("void f() {\n"
934 EXPECT_EQ("void f() {\n"
953 EXPECT_EQ("int f(int i) {\n"
974 EXPECT_EQ("int f(int i) {\n"
997 EXPECT_EQ("int f(int i) {\n"
1023 EXPECT_EQ("void f() {\n"
1036 EXPECT_EQ("int f(int i) {\n"
1055 EXPECT_EQ("int f(int i) {\n"
1076 EXPECT_EQ("int f(int i) {\n"
1101 EXPECT_EQ("/* This is a long\n"
1111 EXPECT_EQ(
1117 EXPECT_EQ(
1123 EXPECT_EQ("/*\n"
1134 EXPECT_EQ("/*\n"
1147 EXPECT_EQ("/*\n"
1158 EXPECT_EQ("/*\n"
1165 EXPECT_EQ("{\n"
1182 EXPECT_EQ("{\n"
1201 EXPECT_EQ("/*\n"
1211 EXPECT_EQ("{\n"
1223 EXPECT_EQ("/* A comment before\n"
1231 EXPECT_EQ("/* some comment\n"
1245 EXPECT_EQ("/**\n"
1258 EXPECT_EQ("/** multilineblockcommentwithnowrapopportunity */",
1262 EXPECT_EQ("/*\n"
1271 EXPECT_EQ("/* a a */",
1273 EXPECT_EQ("/* a a bc */",
1275 EXPECT_EQ("/* aaa aaa\n"
1278 EXPECT_EQ("/* aaa aaa\n"
1284 EXPECT_EQ("#define X \\\n"
1299 EXPECT_EQ("#define X \\\n"
1309 EXPECT_EQ("#define X \\\n"
1330 EXPECT_EQ("#ifdef A // line 1 about A\n"
1363 EXPECT_EQ("#if A\n"
1377 EXPECT_EQ(
1410 EXPECT_EQ("S s = {\n"
1423 EXPECT_EQ("S s = {\n"
1443 EXPECT_EQ("if (true) { // comment about branch\n"
1452 EXPECT_EQ("if (1) { // if line 1\n"
1476 EXPECT_EQ("do { // line 1\n"
1487 EXPECT_EQ("while (a < b) { // line 1\n"
1502 EXPECT_EQ("// long long long\n"
1509 EXPECT_EQ("// long long long\n"
1516 EXPECT_EQ("// long long long\n"
1524 EXPECT_EQ("// long long long\n"
1539 EXPECT_EQ("/// long long long\n"
1544 EXPECT_EQ("//! long long long\n"
1549 EXPECT_EQ("/* long long long\n"
1554 EXPECT_EQ("///< long long long\n"
1559 EXPECT_EQ("//!< long long long\n"
1566 EXPECT_EQ("/* long long long\n"
1575 EXPECT_EQ("/* long long long\n"
1582 EXPECT_EQ("/* long long long\n"
1591 EXPECT_EQ("/* long long long\n"
1600 EXPECT_EQ("{\n"
1618 EXPECT_EQ("/* long long long\n"
1624 EXPECT_EQ("int i; /* long long\n"
1629 EXPECT_EQ("// long long long\n"
1637 EXPECT_EQ("// long long long\n"
1648 EXPECT_EQ("// long long long\n"
1657 EXPECT_EQ("// long long long\n"
1666 EXPECT_EQ("// long long long\n"
1675 EXPECT_EQ("// long long long", format("// long long\n"
1680 EXPECT_EQ("int i; /// a",
1684 EXPECT_EQ("// long long long\n"
1691 EXPECT_EQ("/* long long long */",
1695 EXPECT_EQ("/* long\n"
1700 EXPECT_EQ("{\n"
1716 EXPECT_EQ("// long long long\n"
1723 EXPECT_EQ("// long long long\n"
1732 EXPECT_EQ("int a; // Trailing\n"
1741 EXPECT_EQ("/// This long line\n"
1746 EXPECT_EQ("//! This long line\n"
1751 EXPECT_EQ("/* This long line\n"
1760 EXPECT_EQ("{\n"
1771 EXPECT_EQ("/*\n"
1785 EXPECT_EQ("/// First line gets\n"
1795 EXPECT_EQ("int i; // first long\n"
1801 EXPECT_EQ("{\n"
1814 EXPECT_EQ("int i; /* first line\n"
1827 EXPECT_EQ(
1837 EXPECT_EQ("/* Long long long\n"
1844 EXPECT_EQ("/* First comment\n"
1855 EXPECT_EQ("int i; // This long\n"
1864 EXPECT_EQ("{\n"
1877 EXPECT_EQ("//! long long long\n"
1885 EXPECT_EQ("/* long long long\n"
1893 EXPECT_EQ("/* long long long\n"
1903 EXPECT_EQ("// long long long\n"
1911 EXPECT_EQ("// long long long\n"
1920 EXPECT_EQ("// long long long\n"
1928 EXPECT_EQ("// long long long\n"
1936 EXPECT_EQ("// long long long\n"
1944 EXPECT_EQ("// long long long\n"
1952 EXPECT_EQ("// long long long\n"
1958 EXPECT_EQ("/* long long long\n"
1969 EXPECT_EQ("// long long long\n"
1977 EXPECT_EQ("/* First comment\n"
1988 EXPECT_EQ("// long long long\n"
1996 EXPECT_EQ("// - long long long\n"
2002 EXPECT_EQ("// * long long long\n"
2008 EXPECT_EQ("// + long long long\n"
2014 EXPECT_EQ("// 1. long long long\n"
2020 EXPECT_EQ("// -# long long long\n"
2027 EXPECT_EQ("// - long long long\n"
2034 EXPECT_EQ("// - long long long\n"
2044 EXPECT_EQ("// long long long\n"
2052 EXPECT_EQ("// long long\n"
2064 EXPECT_EQ("#include \"t\" /* l l l\n"
2071 EXPECT_EQ("int i; // long long\n"
2081 EXPECT_EQ("int i; // trigger\n"
2089 EXPECT_EQ("a = f(/* looooooooong\n"
2097 EXPECT_EQ("a = f(/* loooooong\n"
2105 EXPECT_EQ("/**/", format(" /**/", getLLVMStyleWithColumns(20)));
2106 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20)));
2107 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20)));
2108 EXPECT_EQ("//", format(" // ", getLLVMStyleWithColumns(20)));
2109 EXPECT_EQ("///", format(" /// ", getLLVMStyleWithColumns(20)));
2119 EXPECT_EQ("// some text that\n"
2126 EXPECT_EQ("// some text that\n"
2136 EXPECT_EQ("// some text that\n"
2144 EXPECT_EQ("// some text that\n"
2154 EXPECT_EQ("// some text\n"
2159 EXPECT_EQ("// some text\n"
2164 EXPECT_EQ("/* some text\n"
2174 EXPECT_EQ("// some text\n"
2183 EXPECT_EQ("// some text that\n"
2192 EXPECT_EQ("#if 0\n"
2200 EXPECT_EQ("#if false\n"
2208 EXPECT_EQ("enum E {\n"
2224 EXPECT_EQ("enum F {\n"
2246 EXPECT_EQ("enum G {\n"
2264 EXPECT_EQ("enum H {\n"
2286 EXPECT_EQ("enum I {\n"
2302 EXPECT_EQ("enum J {\n"
2328 EXPECT_EQ("#ifdef SWIG\n"
2336 EXPECT_EQ("#ifndef SWIG\n"
2345 EXPECT_EQ(
2376 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */",
2378 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;"));
2379 EXPECT_EQ("#define A /*123*/ \\\n"
2389 EXPECT_EQ("#define A\n"
2395 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/"));
2396 EXPECT_EQ("/*\n"
2406 EXPECT_EQ("/*\n"
2416 EXPECT_EQ("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
2427 EXPECT_EQ("someFunction(1, /* comment 1 */\n"
2440 EXPECT_EQ(
2448 EXPECT_EQ(
2458 EXPECT_EQ("/*\n"
2464 EXPECT_EQ("/*\n"
2470 EXPECT_EQ("/*\n"
2476 EXPECT_EQ("/*\n"
2480 EXPECT_EQ("/*\n"
2487 EXPECT_EQ("#define A \\\n"
2495 EXPECT_EQ("#define A \\\n"
2508 EXPECT_EQ("a = {\n"
2514 EXPECT_EQ("a = {\n"
2520 EXPECT_EQ("a = {\n"
2530 EXPECT_EQ("a = f(/* long\n"
2534 EXPECT_EQ("a = f(\n"
2540 EXPECT_EQ("a = f(/* long\n"
2549 EXPECT_EQ("a = f(/* long\n"
2558 EXPECT_EQ("a = f(/* long\n"
2567 EXPECT_EQ(
2574 EXPECT_EQ(
2582 EXPECT_EQ("a = f(a,\n"
2588 EXPECT_EQ("a = f(\n"
2604 EXPECT_EQ("#define MACRO(V) \\\n"
2613 EXPECT_EQ("int i = f(abc, // line 1\n"
2624 EXPECT_EQ("int ab; // line\n"
2630 EXPECT_EQ("int ab; // line\n"
2638 EXPECT_EQ("int ab; // line\n"
2646 EXPECT_EQ("int ab; // line\n"
2659 EXPECT_EQ("int i, j; // line 1\n"
2667 EXPECT_EQ("int i, j; // line 1\n"
2675 EXPECT_EQ("class A {\n"
2686 EXPECT_EQ("class A {\n"
2701 EXPECT_EQ("int f(int n) { // comment line 1 on f\n"
2718 EXPECT_EQ("int f(int n) {\n"
2767 EXPECT_EQ("int a; // line about a\n"
2772 EXPECT_EQ("int a; // line about a\n"
2779 EXPECT_EQ("int a; // line about a\n"
2791 EXPECT_EQ("/*\n"
2795 EXPECT_EQ("/*\n"
2799 EXPECT_EQ("/*\n"
2805 EXPECT_EQ("/*\n"
2810 EXPECT_EQ("/*\n"
2815 EXPECT_EQ("/*\n"
2820 EXPECT_EQ("/*\n"
2825 EXPECT_EQ("/**\n"
2830 EXPECT_EQ("/**\n"
2835 EXPECT_EQ("/**\n"
2840 EXPECT_EQ("/**\n"
2845 EXPECT_EQ("/**\n"
2852 EXPECT_EQ("/*\n"
2858 EXPECT_EQ("/*\n"
2864 EXPECT_EQ("/*\n"
2872 EXPECT_EQ("/* line 1\n"
2877 EXPECT_EQ("/* line 1\n"
2882 EXPECT_EQ("/* line 1\n"
2887 EXPECT_EQ("/* line 1\n"
2892 EXPECT_EQ("/* line 1\n"
2897 EXPECT_EQ("int i; /* line 1\n"
2902 EXPECT_EQ("int i; /* line 1\n"
2907 EXPECT_EQ("int i; /* line 1\n"
2914 EXPECT_EQ("/* line 1\n"
2921 EXPECT_EQ("/* line 1\n"
2928 EXPECT_EQ("/*\n"
2939 EXPECT_EQ("/*\n"
2953 EXPECT_EQ("/**\n"
2965 EXPECT_EQ("/*\n"
2983 EXPECT_EQ(
3003 EXPECT_EQ("const /** comment comment comment\n"
3013 EXPECT_EQ("# comment\n"
3018 EXPECT_EQ("# comment\n"
3024 EXPECT_EQ("# comment comment\n"
3031 EXPECT_EQ("data {\n"
3040 EXPECT_EQ("data {\n"
3049 EXPECT_EQ("# comment comment\n"
3057 EXPECT_EQ("k: val # comment\n"
3063 EXPECT_EQ("id {\n"
3074 EXPECT_EQ("k: val # commen1\n"
3100 EXPECT_EQ(
3118 EXPECT_EQ(
3127 EXPECT_EQ("/**\n"
3136 EXPECT_EQ("/**\n"
3146 EXPECT_EQ(
3159 EXPECT_EQ("/**\n"
3171 EXPECT_EQ("/**\n"
3182 EXPECT_EQ("/**\n"
3195 EXPECT_EQ("/**\n"
3203 EXPECT_EQ("/**\n"
tools/clang/unittests/Format/FormatTestJS.cpp 51 EXPECT_EQ(Code.str(), format(Code, Style))
54 EXPECT_EQ(Code.str(), Result) << "Formatted:\n" << Result;
61 EXPECT_EQ(Expected.str(), format(Expected, Style))
64 EXPECT_EQ(Expected.str(), Result) << "Formatted:\n" << Result;
72 EXPECT_EQ("aaaaa = bbbb.ccccccccccccccc(\n"
81 EXPECT_EQ(
96 EXPECT_EQ("/**\n"
105 EXPECT_EQ("/**\n"
114 EXPECT_EQ("/**\n"
120 EXPECT_EQ("/** jsdoc line 1 */",
124 EXPECT_EQ("/** jsdoc line 12 */",
128 EXPECT_EQ(
132 EXPECT_EQ(
138 EXPECT_EQ("/**\n"
143 EXPECT_EQ("/**\n"
148 EXPECT_EQ("/**\n"
153 EXPECT_EQ("/**\n"
162 EXPECT_EQ("/**\n"
173 EXPECT_EQ("function f() {\n"
187 EXPECT_EQ("/** @returns j */",
192 EXPECT_EQ("/**\n"
197 EXPECT_EQ("/**\n"
204 EXPECT_EQ("/**\n"
212 EXPECT_EQ("/**\n"
221 EXPECT_EQ("/**\n"
232 EXPECT_EQ("/**\n"
2116 EXPECT_EQ("{\n"
2308 EXPECT_EQ(
tools/clang/unittests/Format/FormatTestJava.cpp 48 EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable";
49 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
455 EXPECT_EQ(
543 EXPECT_EQ("\"some text other\";",
548 EXPECT_EQ("/*\n"
561 EXPECT_EQ("/**\n"
tools/clang/unittests/Format/FormatTestObjC.cpp 50 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
60 EXPECT_EQ(Code.str(), format(Code)) << "Expected code is not stable";
61 EXPECT_EQ(Code.str(), format(test::messUp(Code)));
65 EXPECT_EQ(Code.str(), format(test::messUp(Code), SC_ExpectIncomplete));
75 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
80 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
86 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
91 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
96 EXPECT_EQ(FormatStyle::LK_Cpp, Style->Language);
100 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
105 EXPECT_EQ(FormatStyle::LK_Cpp, Style->Language);
109 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
114 EXPECT_EQ(FormatStyle::LK_Cpp, Style->Language);
119 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
124 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
128 EXPECT_EQ(FormatStyle::LK_Cpp, Style->Language);
133 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
138 EXPECT_EQ(FormatStyle::LK_Cpp, Style->Language);
143 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
148 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
153 EXPECT_EQ(FormatStyle::LK_Cpp, Style->Language);
158 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
162 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
166 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
170 EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
178 EXPECT_EQ(FormatStyle::LK_Cpp, Style->Language);
184 EXPECT_EQ(FormatStyle::LK_Cpp, Style->Language);
452 EXPECT_EQ("@implementation Foo : Bar\n"
986 EXPECT_EQ("@interface", format("@ interface"));
tools/clang/unittests/Format/FormatTestProto.cpp 40 EXPECT_EQ(Code.str(), format(Code)) << "Expected code is not stable";
41 EXPECT_EQ(Code.str(), format(test::messUp(Code)));
189 EXPECT_EQ(
tools/clang/unittests/Format/FormatTestRawStrings.cpp 43 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
110 EXPECT_EQ(Expected, Actual);
141 EXPECT_EQ(0, parseConfiguration("---\n"
tools/clang/unittests/Format/FormatTestSelective.cpp 40 EXPECT_EQ("int a;\nint b;", format("int a; \nint b;", 0, 0));
41 EXPECT_EQ("int a;", format("int a; ", 0, 0));
42 EXPECT_EQ("int a;\n", format("int a; \n \n \n ", 0, 0));
43 EXPECT_EQ("int a;\nint b; ", format("int a; \nint b; ", 0, 0));
47 EXPECT_EQ("{int b;\n"
51 EXPECT_EQ("{\n"
57 EXPECT_EQ("#define A \\\n"
64 EXPECT_EQ("#define A \\\n"
74 EXPECT_EQ("int b;\n\nint a;", format("int b;\n\nint a;", 8, 0));
75 EXPECT_EQ("int b;\n\nint a;", format("int b;\n\nint a;", 7, 0));
79 EXPECT_EQ("int b;\nint a;", format("int b;int a;", 7, 0));
83 EXPECT_EQ("int a;\n\n int b;", format("int a;\n \n\n int b;", 8, 0));
84 EXPECT_EQ("int a;\n\n int b;", format("int a;\n \n\n int b;", 9, 0));
88 EXPECT_EQ(
102 EXPECT_EQ("if (a) return;", format("if(a)\nreturn;", 7, 1));
103 EXPECT_EQ("if (a) return; // comment",
108 EXPECT_EQ("int a; // comment\n"
113 EXPECT_EQ("int a; // comment\n"
120 EXPECT_EQ("int a; // comment\n"
126 EXPECT_EQ("int aaaaaa; // comment\n"
134 EXPECT_EQ("int a; // This\n"
141 EXPECT_EQ("int a; // This\n"
152 EXPECT_EQ("int a; // This\n"
163 EXPECT_EQ("int a;\n"
170 EXPECT_EQ("int x; // Format this line.\n"
182 EXPECT_EQ("int i;\n"
198 EXPECT_EQ("int i;\n"
211 EXPECT_EQ("void f() {\n"
228 EXPECT_EQ("int i = []() {\n"
246 EXPECT_EQ("DEBUG({\n"
255 EXPECT_EQ("DEBUG( {\n"
264 EXPECT_EQ("DEBUG( {\n"
273 EXPECT_EQ("DEBUG({\n"
283 EXPECT_EQ("Debug({\n"
294 EXPECT_EQ("DEBUG({\n"
307 EXPECT_EQ("DEBUG({\n"
314 EXPECT_EQ("someFunction(\n"
328 EXPECT_EQ("int longlongname; // comment\n"
339 EXPECT_EQ("int s = f({\n"
352 EXPECT_EQ("SomeFunction(\n"
372 EXPECT_EQ("namespace {\n"
381 EXPECT_EQ("namespace {\n"
394 EXPECT_EQ("int i;\n"
405 EXPECT_EQ("int i;\n"
419 EXPECT_EQ("{\n"
432 EXPECT_EQ("{\n"
449 EXPECT_EQ("{\n"
462 EXPECT_EQ("{\n"
479 EXPECT_EQ(" {\n"
486 EXPECT_EQ("void f() {}\n"
491 EXPECT_EQ("int a; // comment\n"
499 EXPECT_EQ(" void f() {\n"
506 EXPECT_EQ(" void f() {\n"
523 EXPECT_EQ(" int a;\n"
536 EXPECT_EQ("void f() {\n"
545 EXPECT_EQ("void f() {\n"
554 EXPECT_EQ("void f() {\n"
566 EXPECT_EQ(
588 EXPECT_EQ(
603 EXPECT_EQ(Code, format(Code, 47, 1));
tools/clang/unittests/Format/FormatTestTableGen.cpp 40 EXPECT_EQ(Code.str(), format(Code)) << "Expected code is not stable";
41 EXPECT_EQ(Code.str(), format(test::messUp(Code)));
tools/clang/unittests/Format/FormatTestTextProto.cpp 38 EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable";
39 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
386 EXPECT_EQ("aaa: 100\n"
tools/clang/unittests/Format/NamespaceEndCommentsFixerTest.cpp 47 EXPECT_EQ("namespace {\n"
56 EXPECT_EQ("namespace {\n"
64 EXPECT_EQ("namespace A {\n"
72 EXPECT_EQ("inline namespace A {\n"
81 EXPECT_EQ("namespace [[deprecated(\"foo\")]] A::B {\n"
90 EXPECT_EQ("namespace [[deprecated(\"foo\")]] A::inline B::inline C {\n"
100 EXPECT_EQ("namespace DEPRECATED A::B {\n"
109 EXPECT_EQ("inline namespace [[deprecated]] A {\n"
118 EXPECT_EQ("namespace ::A {\n"
126 EXPECT_EQ("namespace ::A::B {\n"
134 EXPECT_EQ("namespace /**/::/**/A/**/::/**/B/**/ {\n"
142 EXPECT_EQ("namespace A {\n"
152 EXPECT_EQ("namespace A {\n"
164 EXPECT_EQ("namespace A {\n"
180 EXPECT_EQ("namespace A {\n"
196 EXPECT_EQ("namespace A {\n"
209 EXPECT_EQ("namespace A {\n"
229 EXPECT_EQ("namespace out { namespace in {\n"
238 EXPECT_EQ("namespace out {\n"
251 EXPECT_EQ("namespace out { namespace in {\n"
262 EXPECT_EQ("namespace {\n"
270 EXPECT_EQ("namespace A {\n"
278 EXPECT_EQ("namespace A {\n"
294 EXPECT_EQ("TESTSUITE() {\n"
304 EXPECT_EQ("TESTSUITE(A) {\n"
313 EXPECT_EQ("inline TESTSUITE(A) {\n"
322 EXPECT_EQ("TESTSUITE(::A) {\n"
331 EXPECT_EQ("TESTSUITE(::A::B) {\n"
340 EXPECT_EQ("TESTSUITE(/**/::/**/A/**/::/**/B/**/) {\n"
349 EXPECT_EQ("TESTSUITE(A, B) {\n"
358 EXPECT_EQ("TESTSUITE(\"Test1\") {\n"
370 EXPECT_EQ("namespace A {\n"
379 EXPECT_EQ("namespace {\n"
388 EXPECT_EQ("namespace A {\n"
403 EXPECT_EQ("namespace {\n"
412 EXPECT_EQ("namespace {\n"
424 EXPECT_EQ("namespace {}", fixNamespaceEndComments("namespace {}"));
425 EXPECT_EQ("namespace A {}", fixNamespaceEndComments("namespace A {}"));
426 EXPECT_EQ("namespace A { a }",
428 EXPECT_EQ("namespace A { a };",
433 EXPECT_EQ("namespace A {\n"
441 EXPECT_EQ("namespace A {\n"
453 EXPECT_EQ("#define SAD \\\n"
464 EXPECT_EQ("namespace {\n"
470 EXPECT_EQ("namespace A {\n"
476 EXPECT_EQ("namespace A {\n"
482 EXPECT_EQ("namespace A::B {\n"
488 EXPECT_EQ("namespace A {\n"
494 EXPECT_EQ("namespace {\n"
506 EXPECT_EQ("TESTSUITE() {\n"
513 EXPECT_EQ("TESTSUITE(A) {\n"
520 EXPECT_EQ("TESTSUITE(A) {\n"
527 EXPECT_EQ("TESTSUITE(A::B) {\n"
534 EXPECT_EQ("TESTSUITE(A) {\n"
541 EXPECT_EQ("TESTSUITE() {\n"
551 EXPECT_EQ("namespace {\n"
557 EXPECT_EQ("namespace A {\n"
563 EXPECT_EQ("namespace A {\n"
569 EXPECT_EQ("namespace A {\n"
576 EXPECT_EQ("namespace A {\n"
582 EXPECT_EQ("namespace A {\n"
589 EXPECT_EQ("namespace A {} // namespace A",
591 EXPECT_EQ("namespace A {}; // namespace A",
597 EXPECT_EQ("namespace out { namespace in {\n"
602 EXPECT_EQ("namespace out { namespace in {\n"
607 EXPECT_EQ("namespace out { namespace in {\n"
620 EXPECT_EQ("TESTSUITE() {\n"
627 EXPECT_EQ("TESTSUITE(A) {\n"
634 EXPECT_EQ("TESTSUITE(A) {\n"
641 EXPECT_EQ("TESTSUITE(A) {\n"
648 EXPECT_EQ("TESTSUITE(A) {\n"
655 EXPECT_EQ("TESTSUITE() {\n"
662 EXPECT_EQ("TESTSUITE(A) {\n"
669 EXPECT_EQ("TESTSUITE(A) {\n"
677 EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
679 EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
687 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
692 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
697 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
707 EXPECT_EQ("namespace {\n"
713 EXPECT_EQ("namespace A {\n"
719 EXPECT_EQ("namespace A {\n"
725 EXPECT_EQ("namespace A {\n"
731 EXPECT_EQ("namespace A {\n"
737 EXPECT_EQ("namespace A {\n"
743 EXPECT_EQ("namespace A {} // namespace A",
745 EXPECT_EQ("namespace A {}; // namespace A",
753 EXPECT_EQ("TESTSUITE() {\n"
760 EXPECT_EQ("TESTSUITE(A) {\n"
767 EXPECT_EQ("TESTSUITE(A) {\n"
774 EXPECT_EQ("TESTSUITE(A) {\n"
781 EXPECT_EQ("TESTSUITE(A) {\n"
788 EXPECT_EQ("TESTSUITE(A) {\n"
795 EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
797 EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
803 EXPECT_EQ("#ifdef 1\n"
823 EXPECT_EQ("namespace A {\n"
833 EXPECT_EQ("#if 1\n"
845 EXPECT_EQ("namespace A {\n"
857 EXPECT_EQ("#if 1\n"
871 EXPECT_EQ("namespace A {\n"
879 EXPECT_EQ("#define FOO\n"
889 EXPECT_EQ("namespace A {\n"
901 EXPECT_EQ("#if 1\n"
917 EXPECT_EQ("#ifdef A\n"
935 EXPECT_EQ("#if 0\n"
951 EXPECT_EQ("#ifdef 1\n"
967 EXPECT_EQ("namespace {\n"
985 EXPECT_EQ("#if A\n"
1001 EXPECT_EQ("#if A\n"
1017 EXPECT_EQ("#if A\n"
1033 EXPECT_EQ("namespace A\n"
1049 EXPECT_EQ("namespace A\n"
1069 EXPECT_EQ("namespace {\n"
1080 EXPECT_EQ("template <int> struct a {};\n"
tools/clang/unittests/Format/SortImportsTestJS.cpp 39 EXPECT_EQ(Expected.str(), Result) << "Expected:\n"
tools/clang/unittests/Format/SortImportsTestJava.cpp 40 EXPECT_EQ("import static org.b;\n"
48 EXPECT_EQ("import org.Test;\n"
57 EXPECT_EQ("import static com.test.a;\n"
84 EXPECT_EQ("import static com.test.a;\n"
104 EXPECT_EQ("import com.test.a;\n"
121 EXPECT_EQ("import org.b;\n"
136 EXPECT_EQ("import org.a;\n"
153 EXPECT_EQ("import org.a.*;\n"
164 EXPECT_EQ("import org.a; // static\n"
173 EXPECT_EQ("import org.a;\n"
190 EXPECT_EQ("import org.a;\n"
199 EXPECT_EQ("import org.a;\n"
208 EXPECT_EQ("// comment\n"
217 EXPECT_EQ("// clang-format off\n"
228 EXPECT_EQ("// clang-format off\n"
239 EXPECT_EQ("// clang-format off\n"
254 EXPECT_EQ("import org.a;\n", sort("import org.a;\n"
259 EXPECT_EQ("import org.a;\n"
266 EXPECT_EQ("import X;\n"
tools/clang/unittests/Format/SortIncludesTest.cpp 32 EXPECT_EQ(ExpectedNumRanges, Replaces.size());
57 EXPECT_EQ("#include \"a.h\"\n"
64 EXPECT_EQ("// comment\n"
89 EXPECT_EQ("#include <sys/param.h>\n"
132 EXPECT_EQ("#include \"FormatTestUtils.h\"\n"
157 EXPECT_EQ("#include \"a.h\"\n"
167 EXPECT_EQ("#include \"a.h\"\n"
178 EXPECT_EQ("#include <a>\n"
197 EXPECT_EQ("#include <a>\n"
215 EXPECT_EQ("#include <a>\n"
235 EXPECT_EQ("#include \"a.h\"\n"
245 EXPECT_EQ("#include \"a.h\"\n"
254 EXPECT_EQ("#include \"a.h\" // comment\n"
263 EXPECT_EQ("#include \"a.h\"\n"
269 EXPECT_EQ("#include \"a.h\"\n"
278 EXPECT_EQ("#include \"a.h\"\n"
287 EXPECT_EQ("#include \"a.h\"\n"
299 EXPECT_EQ("#include \"a.h\"\n"
309 EXPECT_EQ("#include \"a.h\"\n"
319 EXPECT_EQ("#include \"a.h\"\n"
329 EXPECT_EQ("#include \"a.h\"\n"
340 EXPECT_EQ("#include \"a.h\"\n"
354 EXPECT_EQ("#include <b.h>\n"
372 EXPECT_EQ("#include \"a.h\"\n"
384 EXPECT_EQ("#include \"a.h\"\n"
395 EXPECT_EQ("#include \"llvm/a.h\"\n"
402 EXPECT_EQ("#include \"llvm/a.h\"\n"
409 EXPECT_EQ("#include \"llvm/input.h\"\n"
418 EXPECT_EQ("#include \"b.h\"\n"
427 EXPECT_EQ("#include \"b.h\"\n"
436 EXPECT_EQ("#include \"b.h\"\n"
445 EXPECT_EQ("#include <a>\n"
458 EXPECT_EQ("#include \"a.h\"\n"
473 EXPECT_EQ("#include \"c.h\"\n"
487 EXPECT_EQ("#include \"a.h\"\n"
504 EXPECT_EQ("#include \"llvm/A.h\"\n"
523 EXPECT_EQ("#include \"important_os_header.h\"\n"
532 EXPECT_EQ("#include \"important_os_header.h\"\n"
545 EXPECT_EQ("#include \"important_os_header.h\"\n"
556 EXPECT_EQ("#include \"important_os_header.h\"\n"
573 EXPECT_EQ(31u, newCursor(Code, 0));
574 EXPECT_EQ(13u, newCursor(Code, 15));
575 EXPECT_EQ(0u, newCursor(Code, 33));
577 EXPECT_EQ(41u, newCursor(Code, 10));
578 EXPECT_EQ(23u, newCursor(Code, 25));
579 EXPECT_EQ(10u, newCursor(Code, 43));
583 EXPECT_EQ("#include <a>\n"
594 EXPECT_EQ("#include <a>\n"
606 EXPECT_EQ("#include <a>\n"
619 EXPECT_EQ("#include <a>\n"
630 EXPECT_EQ("#include <a>\n"
642 EXPECT_EQ("#include <a>\n"
664 EXPECT_EQ(Expected, sort(Code));
666 EXPECT_EQ(1u, newCursor(Code, 14));
668 EXPECT_EQ(23u, newCursor(Code, 10));
669 EXPECT_EQ(23u, newCursor(Code, 36));
670 EXPECT_EQ(23u, newCursor(Code, 49));
671 EXPECT_EQ(23u, newCursor(Code, 36));
672 EXPECT_EQ(23u, newCursor(Code, 75));
674 EXPECT_EQ(26u, newCursor(Code, 52));
678 EXPECT_EQ("#include <a>\n"
701 EXPECT_EQ(1u, Ranges.size());
702 EXPECT_EQ(0u, Ranges[0].getOffset());
703 EXPECT_EQ(26u, Ranges[0].getLength());
707 EXPECT_EQ("<!--;\n"
724 EXPECT_EQ(Code, sort(Code, "input.h", 0));
733 EXPECT_EQ(Code, sort(Code, "input.h", 0));
739 EXPECT_EQ("#include <a.h>\n"
tools/clang/unittests/Format/UsingDeclarationsSorterTest.cpp 44 EXPECT_EQ("using a;\n"
48 EXPECT_EQ("using a;\n"
52 EXPECT_EQ("using a;\n"
57 EXPECT_EQ("using a::bcd;\n"
62 EXPECT_EQ("using a;\n"
67 EXPECT_EQ("using a::ba::aa;\n"
72 EXPECT_EQ("using a;\n"
77 EXPECT_EQ("using typename z;\n"
82 EXPECT_EQ("using a, b;\n"
89 EXPECT_EQ("using A;\n"
93 EXPECT_EQ("using a;\n"
97 EXPECT_EQ("using a;\n"
103 EXPECT_EQ("using ::a;\n"
108 EXPECT_EQ("using ::A;\n"
114 EXPECT_EQ("using _;\n"
118 EXPECT_EQ("using _;\n"
122 EXPECT_EQ("using a::_;\n"
128 EXPECT_EQ("using ::testing::_;\n"
143 EXPECT_EQ("using a;\n"
176 EXPECT_EQ("using a;\n"
187 EXPECT_EQ("#include <iostream>\n"
200 EXPECT_EQ("using b;\n"
213 EXPECT_EQ("using b;\n"
222 EXPECT_EQ("#define A \\\n"
234 EXPECT_EQ(Code, sortUsingDeclarations(Code));
238 EXPECT_EQ("using a; // line a1\n"
253 EXPECT_EQ("struct pt3 : pt2 {\n"
266 EXPECT_EQ("using a::operator();\n"
275 EXPECT_EQ("namespace A {\n"
294 EXPECT_EQ("// clang-format off\n"
310 EXPECT_EQ("using a;\n"
317 EXPECT_EQ("using a;\n"
327 EXPECT_EQ("using d;\n"
347 EXPECT_EQ("/* comment */ using a;\n"
354 EXPECT_EQ("using a;\n"
tools/clang/unittests/Frontend/FrontendActionTest.cpp 98 EXPECT_EQ("main", test_action.decl_names[0]);
99 EXPECT_EQ("x", test_action.decl_names[1]);
118 EXPECT_EQ("main", test_action.decl_names[0]);
119 EXPECT_EQ("x", test_action.decl_names[1]);
146 EXPECT_EQ("A", test_action.decl_names[0]);
147 EXPECT_EQ("c", test_action.decl_names[12]);
254 EXPECT_EQ("use of undeclared identifier 'foo'; did you mean 'moo'?",
256 EXPECT_EQ("This is a note", TDC->Note.str().str());
287 EXPECT_EQ(InMemoryModuleCache::Final,
290 EXPECT_EQ(InMemoryModuleCache::Unknown,
tools/clang/unittests/Frontend/ParsedSourceLocationTest.cpp 22 EXPECT_EQ(PSR->FileName, Filename);
23 EXPECT_EQ(PSR->Begin.first, BeginLine);
24 EXPECT_EQ(PSR->Begin.second, BeginColumn);
25 EXPECT_EQ(PSR->End.first, EndLine);
26 EXPECT_EQ(PSR->End.second, EndColumn);
tools/clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp 67 EXPECT_EQ(pp_define, Tokens[0].K);
68 EXPECT_EQ(pp_undef, Tokens[1].K);
69 EXPECT_EQ(pp_endif, Tokens[2].K);
70 EXPECT_EQ(pp_if, Tokens[3].K);
71 EXPECT_EQ(pp_ifdef, Tokens[4].K);
72 EXPECT_EQ(pp_ifndef, Tokens[5].K);
73 EXPECT_EQ(pp_elif, Tokens[6].K);
74 EXPECT_EQ(pp_else, Tokens[7].K);
75 EXPECT_EQ(pp_include, Tokens[8].K);
76 EXPECT_EQ(pp_include_next, Tokens[9].K);
77 EXPECT_EQ(pp___include_macros, Tokens[10].K);
78 EXPECT_EQ(pp_import, Tokens[11].K);
79 EXPECT_EQ(decl_at_import, Tokens[12].K);
80 EXPECT_EQ(pp_pragma_import, Tokens[13].K);
81 EXPECT_EQ(cxx_export_decl, Tokens[14].K);
82 EXPECT_EQ(cxx_module_decl, Tokens[15].K);
83 EXPECT_EQ(cxx_import_decl, Tokens[16].K);
84 EXPECT_EQ(pp_eof, Tokens[17].K);
585 EXPECT_EQ(Tokens[0].K,
679 EXPECT_EQ(Tokens[0].K,
681 EXPECT_EQ(Tokens[2].K,
695 EXPECT_EQ(Ranges.size(), 1u);
696 EXPECT_EQ(Ranges[0].Offset, 0);
697 EXPECT_EQ(Ranges[0].Length, (int)Out.find("#endif"));
716 EXPECT_EQ(Ranges.size(), 4u);
717 EXPECT_EQ(Ranges[0].Offset, (int)Out.find("#if FOO"));
718 EXPECT_EQ(Ranges[0].Offset + Ranges[0].Length, (int)Out.find("#elif"));
719 EXPECT_EQ(Ranges[1].Offset, (int)Out.find("#elif BAR"));
720 EXPECT_EQ(Ranges[1].Offset + Ranges[1].Length, (int)Out.find("#endif"));
721 EXPECT_EQ(Ranges[2].Offset, 0);
722 EXPECT_EQ(Ranges[2].Length, (int)Out.find("#else"));
723 EXPECT_EQ(Ranges[3].Offset, (int)Out.find("#else"));
724 EXPECT_EQ(Ranges[3].Offset + Ranges[3].Length, (int)Out.rfind("#endif"));
tools/clang/unittests/Lex/HeaderSearchTest.cpp 61 EXPECT_EQ(Search.search_dir_size(), 0u);
62 EXPECT_EQ(Search.suggestPathToFileForDiagnostics("/x/y/z", /*WorkingDir=*/"",
70 EXPECT_EQ(Search.suggestPathToFileForDiagnostics("/x/y/z", /*WorkingDir=*/"",
74 EXPECT_EQ(Search.suggestPathToFileForDiagnostics("/a/b/c", /*WorkingDir=*/"",
81 EXPECT_EQ(Search.suggestPathToFileForDiagnostics("/a/b/c/x/y/z",
89 EXPECT_EQ(Search.suggestPathToFileForDiagnostics("/x/y/./z",
94 EXPECT_EQ(Search.suggestPathToFileForDiagnostics("/m/n/./c/z",
120 EXPECT_EQ(Search.suggestPathToFileForDiagnostics("/y/z",
127 EXPECT_EQ(Search.suggestPathToFileForDiagnostics("/y/z/t.h",
133 EXPECT_EQ(Search.suggestPathToFileForDiagnostics("/y/z/t.h",
tools/clang/unittests/Lex/LexerTest.cpp 85 EXPECT_EQ(ExpectedTokens.size(), toks.size());
87 EXPECT_EQ(ExpectedTokens[i], toks[i].getKind());
125 EXPECT_EQ("M(i)", getSourceText(toks[2], toks[2]));
137 EXPECT_EQ("M(i)", getSourceText(toks[0], toks[0]));
150 EXPECT_EQ("c M(i)", getSourceText(toks[1], toks[2]));
163 EXPECT_EQ("M(i) c", getSourceText(toks[0], toks[1]));
177 EXPECT_EQ("<INVALID>", getSourceText(toks[1], toks[2]));
192 EXPECT_EQ("C(i)", getSourceText(toks[2], toks[2]));
205 EXPECT_EQ("M(M(i))", getSourceText(toks[2], toks[2]));
218 EXPECT_EQ("i", getSourceText(toks[2], toks[2]));
232 EXPECT_EQ("C(M(i))", getSourceText(toks[2], toks[2]));
247 EXPECT_EQ("M(i)", getSourceText(toks[3], toks[3]));
262 EXPECT_EQ("M(i)", getSourceText(toks[3], toks[3]));
294 EXPECT_EQ(Loc, macroRange.getBegin());
298 EXPECT_EQ(Loc, macroRange.getEnd());
310 EXPECT_EQ(range.getAsRange(),
317 EXPECT_EQ(text, "M(foo)");
329 EXPECT_EQ(SourceRange(fileLsqrLoc, fileIdLoc.getLocWithOffset(3)),
334 EXPECT_EQ(SourceRange(fileIdLoc, fileRsqrLoc.getLocWithOffset(1)),
341 EXPECT_EQ(SourceRange(macroRange.getBegin(), macroRange.getEnd().getLocWithOffset(1)),
347 EXPECT_EQ(text, "[bar");
354 EXPECT_EQ("INN", Lexer::getImmediateMacroName(idLoc1, SourceMgr, LangOpts));
355 EXPECT_EQ("INN", Lexer::getImmediateMacroName(idLoc2, SourceMgr, LangOpts));
356 EXPECT_EQ("NOF2", Lexer::getImmediateMacroName(idLoc3, SourceMgr, LangOpts));
357 EXPECT_EQ("N", Lexer::getImmediateMacroName(idLoc4, SourceMgr, LangOpts));
374 EXPECT_EQ(SourceMgr.getFileIDSize(SourceMgr.getFileID(helper1ArgLoc)), 8U);
386 EXPECT_EQ(3u, MI->getNumParams());
413 EXPECT_EQ(tok::string_literal, Result.getKind());
416 EXPECT_EQ(tok::string_literal, Result.getKind());
419 EXPECT_EQ(tok::string_literal, Result.getKind());
474 EXPECT_EQ(FoundLocation.second, OriginalLocation.second);
515 EXPECT_EQ(String1, R"(foo\n {\"bar\":[]}\n baz)");
516 EXPECT_EQ(String2, R"(foo\n {\"bar\":[]}\n baz)");
517 EXPECT_EQ(String3, R"(\\\n \\n\n \\\\n\n \\\\)");
518 EXPECT_EQ(String4, R"(\\\n \\n\n \\\\n\n \\\\)");
519 EXPECT_EQ(String5, R"(a\\\n\n\n \\\\b)");
520 EXPECT_EQ(String6, R"(a\\\n\n\n \\\\b)");
528 EXPECT_EQ(getSourceText(moo, moo), "MOO");
539 EXPECT_EQ(Lexer::getSourceText(CR, SourceMgr, LangOpts), "MOO"); // Was "MO".
tools/clang/unittests/Lex/PPCallbacksTest.cpp 429 EXPECT_EQ(Results1.size(), 1U);
430 EXPECT_EQ(
435 EXPECT_EQ(Results2.size(), 1U);
436 EXPECT_EQ(
441 EXPECT_EQ(Results3.size(), 1U);
442 EXPECT_EQ(
447 EXPECT_EQ(Results4.size(), 2U);
448 EXPECT_EQ(
451 EXPECT_EQ(
456 EXPECT_EQ(Results5.size(), 2U);
457 EXPECT_EQ(
460 EXPECT_EQ(
466 EXPECT_EQ(Results6.size(), 1U);
467 EXPECT_EQ(
473 EXPECT_EQ(Results7.size(), 2U);
474 EXPECT_EQ(
477 EXPECT_EQ(
483 EXPECT_EQ(Results8.size(), 1U);
484 EXPECT_EQ(
487 EXPECT_EQ(
tools/clang/unittests/Rename/ClangRenameTest.h 92 EXPECT_EQ(format(ExpectedCode), format(Actual));
tools/clang/unittests/Rewrite/RewriterTest.cpp 52 EXPECT_EQ(T.Rewrite.getRewrittenText(T.CRange), "ret");
53 EXPECT_EQ(T.Rewrite.getRewrittenText(T.TRange), "return");
54 EXPECT_EQ(T.Rewrite.getRewrittenText(T.SRange), "return");
56 EXPECT_EQ(T.Rewrite.getRewrittenText(T.CRange), "xret");
57 EXPECT_EQ(T.Rewrite.getRewrittenText(T.TRange), "xreturn");
58 EXPECT_EQ(T.Rewrite.getRewrittenText(T.SRange), "xreturn");
73 EXPECT_EQ(T.Rewrite.getRewrittenText(T.makeCharRange(42, 47)), "foogc;");
75 EXPECT_EQ(T.Rewrite.getRewrittenText(T.makeCharRange(42, 47)), "bar;");
77 EXPECT_EQ(T.Rewrite.getRewrittenText(T.makeCharRange(42, 47)), "0;");
tools/clang/unittests/Serialization/InMemoryModuleCacheTest.cpp 27 EXPECT_EQ(InMemoryModuleCache::Unknown, Cache.getPCMState("B"));
42 EXPECT_EQ(RawB, &Cache.addPCM("B", std::move(B)));
43 EXPECT_EQ(InMemoryModuleCache::Tentative, Cache.getPCMState("B"));
44 EXPECT_EQ(RawB, Cache.lookupPCM("B"));
60 EXPECT_EQ(RawB, &Cache.addBuiltPCM("B", std::move(B)));
61 EXPECT_EQ(InMemoryModuleCache::Final, Cache.getPCMState("B"));
62 EXPECT_EQ(RawB, Cache.lookupPCM("B"));
81 EXPECT_EQ(InMemoryModuleCache::Unknown, Cache.getPCMState("B"));
82 EXPECT_EQ(RawB1, &Cache.addPCM("B", std::move(B1)));
84 EXPECT_EQ(nullptr, Cache.lookupPCM("B"));
85 EXPECT_EQ(InMemoryModuleCache::ToBuild, Cache.getPCMState("B"));
97 EXPECT_EQ(RawB2, &Cache.addBuiltPCM("B", std::move(B2)));
102 EXPECT_EQ(RawB2, Cache.lookupPCM("B"));
110 EXPECT_EQ(InMemoryModuleCache::Unknown, Cache.getPCMState("B"));
111 EXPECT_EQ(RawB, &Cache.addPCM("B", std::move(B)));
115 EXPECT_EQ(InMemoryModuleCache::Final, Cache.getPCMState("B"));
tools/clang/unittests/StaticAnalyzer/CallDescriptionTest.cpp 44 ~ResultMap() { EXPECT_EQ(Found, Total); }
tools/clang/unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp 84 EXPECT_EQ(Diags, "custom.CustomChecker:Custom diagnostic description");
tools/clang/unittests/Tooling/ASTSelectionTest.cpp 93 EXPECT_EQ(Node.Children.size(), NumChildren);
202 EXPECT_EQ(Node->Children.size(), 1u);
226 EXPECT_EQ(Node->Children.size(), 1u);
242 EXPECT_EQ(Node->Children.size(), 1u);
258 EXPECT_EQ(Node->Children.size(), 1u);
282 EXPECT_EQ(Node->Children.size(), 2u);
312 EXPECT_EQ(Node->Children.size(), 1u);
333 EXPECT_EQ(Node->Children.size(), 1u);
355 EXPECT_EQ(Node->Children.size(), 1u);
403 EXPECT_EQ(Node->Children.size(), 1u);
419 EXPECT_EQ(Node->Children.size(), 1u);
435 EXPECT_EQ(Node->Children.size(), 2u);
458 EXPECT_EQ(Node->Children.size(), 1u);
485 EXPECT_EQ(Node->Children.size(), 1u);
511 EXPECT_EQ(Node->Children.size(), 1u);
531 EXPECT_EQ(Node->Children.size(), 1u);
542 EXPECT_EQ(Node->Children.size(), 1u);
723 EXPECT_EQ(SelectedCode->size(), 1u);
727 EXPECT_EQ(Parents.size(), 3u);
743 EXPECT_EQ(SelectedCode->size(), 2u);
748 EXPECT_EQ(Parents.size(), 3u);
764 EXPECT_EQ(SelectedCode->size(), 3u);
778 EXPECT_EQ(SelectedCode->size(), 4u);
798 EXPECT_EQ(SelectedCode->size(), 1u);
802 EXPECT_EQ(Parents.size(), 2u);
826 EXPECT_EQ(SelectedCode->size(), 1u);
830 EXPECT_EQ(Parents.size(), 4u);
856 EXPECT_EQ(SelectedCode->size(), 1u);
860 EXPECT_EQ(Parents.size(), 3u);
884 EXPECT_EQ(SelectedCode->size(), 1u);
888 EXPECT_EQ(Parents.size(), 3u);
933 EXPECT_EQ(SelectedCode->size(), 1u);
937 EXPECT_EQ(Parents.size(), 4u);
956 EXPECT_EQ(SelectedCode->size(), 2u);
961 EXPECT_EQ(Parents.size(), 4u);
988 EXPECT_EQ(SelectedCode->size(), 1u);
1000 EXPECT_EQ(SelectedCode->size(), 1u);
1031 EXPECT_EQ(SelectedCode->size(), 1u);
1042 EXPECT_EQ(SelectedCode->size(), 1u);
1053 EXPECT_EQ(SelectedCode->size(), 1u);
1075 EXPECT_EQ(SelectedCode->size(), 1u);
tools/clang/unittests/Tooling/CompilationDatabaseTest.cpp 29 EXPECT_EQ(nullptr,
83 EXPECT_EQ(std::vector<std::string>(),
95 EXPECT_EQ(expected_files,
111 EXPECT_EQ(
138 EXPECT_EQ(2U, Commands.size()) << ErrorMessage;
139 EXPECT_EQ(Directory1, Commands[0].Directory) << ErrorMessage;
140 EXPECT_EQ(FileName1, Commands[0].Filename) << ErrorMessage;
141 EXPECT_EQ(Output1, Commands[0].Output) << ErrorMessage;
143 EXPECT_EQ(Command1, Commands[0].CommandLine[0]) << ErrorMessage;
144 EXPECT_EQ(Directory2, Commands[1].Directory) << ErrorMessage;
145 EXPECT_EQ(FileName2, Commands[1].Filename) << ErrorMessage;
146 EXPECT_EQ(Output2, Commands[1].Output) << ErrorMessage;
148 EXPECT_EQ(Command2, Commands[1].CommandLine[0]) << ErrorMessage;
163 EXPECT_EQ(2U, Commands.size()) << ErrorMessage;
164 EXPECT_EQ(Directory2, Commands[0].Directory) << ErrorMessage;
165 EXPECT_EQ(FileName2, Commands[0].Filename) << ErrorMessage;
167 EXPECT_EQ(Command2, Commands[0].CommandLine[0]) << ErrorMessage;
168 EXPECT_EQ(Directory1, Commands[1].Directory) << ErrorMessage;
169 EXPECT_EQ(FileName1, Commands[1].Filename) << ErrorMessage;
171 EXPECT_EQ(Command1, Commands[1].CommandLine[0]) << ErrorMessage;
203 EXPECT_EQ(Directory, FoundCommand.Directory) << ErrorMessage;
204 EXPECT_EQ(1u, FoundCommand.CommandLine.size()) << ErrorMessage;
205 EXPECT_EQ(Arguments, FoundCommand.CommandLine[0]) << ErrorMessage;
231 EXPECT_EQ("//net/path/file.cc", find("//net/path/file.cc"));
235 EXPECT_EQ("", find("file.cc"));
241 EXPECT_EQ("//net/d/b/b.cc", find("//net/d/b/b.cc"));
246 EXPECT_EQ("//net/AA/file.cc", find("//net/aa/file.cc"));
253 EXPECT_EQ("Path is ambiguous", Error);
260 EXPECT_EQ("//net/SRC/aa/file.cc", find("//net/src/aa/file.cc"));
270 EXPECT_EQ("", find("//net/somepath/somefile.cc"));
276 EXPECT_EQ("//net/path/file.cc", find("//net/path/file.cc"));
280 EXPECT_EQ("", find("relative-path.cc"));
281 EXPECT_EQ("Cannot resolve relative paths", Error);
303 EXPECT_EQ(Directory, FoundCommand.Directory) << ErrorMessage;
305 EXPECT_EQ("//net/path/to/compiler",
307 EXPECT_EQ("and", FoundCommand.CommandLine[1]) << ErrorMessage;
308 EXPECT_EQ("some", FoundCommand.CommandLine[2]) << ErrorMessage;
309 EXPECT_EQ("arguments", FoundCommand.CommandLine[3]) << ErrorMessage;
333 EXPECT_EQ("//net/path to compiler",
335 EXPECT_EQ("and an argument", FoundCommand.CommandLine[1]) << ErrorMessage;
349 EXPECT_EQ(Directory, FoundCommand.Directory) << ErrorMessage;
368 EXPECT_EQ("//net/directory4", FoundCommand.Directory) << ErrorMessage;
370 EXPECT_EQ("command4", FoundCommand.CommandLine[0]) << ErrorMessage;
393 EXPECT_EQ(Case.second, llvm::join(FoundCommand.CommandLine, " "))
417 EXPECT_EQ("a", Result[0]);
418 EXPECT_EQ("b", Result[1]);
419 EXPECT_EQ("c", Result[2]);
425 EXPECT_EQ("a", Result[0]);
426 EXPECT_EQ("b", Result[1]);
432 EXPECT_EQ("a\\", Backslash[0]);
435 EXPECT_EQ("a\"", Quote[0]);
441 EXPECT_EQ(" a b ", Result[0]);
448 EXPECT_EQ(" a ", Result[0]);
449 EXPECT_EQ(" b ", Result[1]);
463 EXPECT_EQ("\"", Result[0]);
470 EXPECT_EQ("\"", Result[0]);
471 EXPECT_EQ("a \" b ", Result[1]);
472 EXPECT_EQ("and\\c", Result[2]);
473 EXPECT_EQ("\"", Result[3]);
480 EXPECT_EQ("ab", QuotedNoSpaces[0]);
485 EXPECT_EQ("abcdefg", MixedNoSpaces[0]);
491 EXPECT_EQ("abc", Unclosed[0]);
495 EXPECT_EQ("", Empty[0]);
501 EXPECT_EQ("a\\b \"c\"", Args[0]);
510 EXPECT_EQ(".", Result[0].Directory);
511 EXPECT_EQ(FileName, Result[0].Filename);
522 EXPECT_EQ(0ul, Database.getAllFiles().size());
531 EXPECT_EQ(0ul, Database.getAllCompileCommands().size());
541 EXPECT_EQ(0, Argc);
552 EXPECT_EQ(2, Argc);
571 EXPECT_EQ(2, Argc);
588 EXPECT_EQ(2, Argc);
605 EXPECT_EQ(2, Argc);
641 EXPECT_EQ(2, Argc);
702 EXPECT_EQ(Results[0].CommandLine.back(), path(F))
736 EXPECT_EQ(getProxy("dir/f.cpp"), "dir/foo.cpp");
737 EXPECT_EQ(getProxy("dir/FOO.cpp"), "dir/foo.cpp");
739 EXPECT_EQ(getProxy("dir/a.cpp"), "dir/bar.cpp");
741 EXPECT_EQ(getProxy("some/other/bar.h"), "dir/bar.cpp");
743 EXPECT_EQ(getProxy("an/other/b.cpp"), "an/other/foo.cpp");
745 EXPECT_EQ(getProxy("below/some/obscure/path.cpp"), "an/other/foo.cpp");
754 EXPECT_EQ(getCommand("foo.h"),
757 EXPECT_EQ(getCommand("foo"), "clang -D dir/foo.cpp -x c++-header -std=c++17");
759 EXPECT_EQ(getCommand("foo.cce"),
762 EXPECT_EQ(getCommand("foo.hpp"), "clang -D dir/foo.cpp -std=c++17");
764 EXPECT_EQ(getCommand("baz.h"), "clang -D dir/baz.cee -x c-header");
766 EXPECT_EQ(getCommand("foo.c"), "clang -D dir/bar.c");
769 EXPECT_EQ(getCommand("foo.c"), "clang -D dir/foo.cpp");
775 EXPECT_EQ(getCommand("dir/bar.cpp"), "clang -D dir/foo.cpp -Wall");
782 EXPECT_EQ(getProxy("foo/bar/baz/shout.C"), "FOO/BAR/BAZ/SHOUT.cc");
790 EXPECT_EQ(getCommand("foo.hpp"), "clang -D foo.cpp -faligned-new");
797 EXPECT_EQ(getCommand("foo.h"), "clang-cl -D foo.cpp /W4 /TP");
805 EXPECT_EQ(getCommand("foo.h"), "clang-cl -D foo.cpp --driver-mode=gcc -x c++-header");
806 EXPECT_EQ(getCommand("bar.h"), "clang -D bar.cpp --driver-mode=cl /TP");
856 EXPECT_EQ(getCommand("foo.cpp"),
858 EXPECT_EQ(getCommand("bar.cpp"),
tools/clang/unittests/Tooling/DependencyScannerTest.cpp 105 EXPECT_EQ(convert_to_slash(Deps[0]), "/root/test.cpp");
106 EXPECT_EQ(convert_to_slash(Deps[1]), "/root/symlink.h");
107 EXPECT_EQ(convert_to_slash(Deps[2]), "/root/header.h");
112 EXPECT_EQ(Files.getNumUniqueRealFiles(), 2u);
118 EXPECT_EQ(convert_to_slash(Deps[0]), "/root/test.cpp");
119 EXPECT_EQ(convert_to_slash(Deps[1]), "/root/symlink.h");
120 EXPECT_EQ(convert_to_slash(Deps[2]), "/root/header.h");
122 EXPECT_EQ(Files.getNumUniqueRealFiles(), 2u);
156 EXPECT_EQ(convert_to_slash(Deps[0]), "/root/test.cpp");
157 EXPECT_EQ(convert_to_slash(Deps[1]), "/root/header.h");
158 EXPECT_EQ(convert_to_slash(Deps[2]), "/root/symlink.h");
159 EXPECT_EQ(convert_to_slash(Deps[3]), "/root/test2.cpp");
160 EXPECT_EQ(convert_to_slash(Deps[4]), "/root/symlink.h");
161 EXPECT_EQ(convert_to_slash(Deps[5]), "/root/header.h");
191 EXPECT_EQ(convert_to_slash(Deps[0]), "/root/test.cpp");
192 EXPECT_EQ(convert_to_slash(Deps[1]), "/root/header.h");
193 EXPECT_EQ(convert_to_slash(Deps[2]), "/root/symlink.h");
194 EXPECT_EQ(convert_to_slash(Deps[3]), "/root/test.cpp");
195 EXPECT_EQ(convert_to_slash(Deps[4]), "/root/header.h");
196 EXPECT_EQ(convert_to_slash(Deps[5]), "/root/symlink.h");
tools/clang/unittests/Tooling/DiagnosticsYamlTest.cpp 112 EXPECT_EQ(YAMLContent, YamlContentStream.str());
122 EXPECT_EQ("path/to/source.cpp", TUDActual.MainSourceFile);
135 EXPECT_EQ("diagnostic#1", D1.DiagnosticName);
136 EXPECT_EQ("message #1", D1.Message.Message);
137 EXPECT_EQ(55u, D1.Message.FileOffset);
138 EXPECT_EQ("path/to/source.cpp", D1.Message.FilePath);
141 EXPECT_EQ("path/to/source.cpp", Fixes1[0].getFilePath());
142 EXPECT_EQ(100u, Fixes1[0].getOffset());
143 EXPECT_EQ(12u, Fixes1[0].getLength());
144 EXPECT_EQ("replacement #1", Fixes1[0].getReplacementText());
147 EXPECT_EQ("diagnostic#2", D2.DiagnosticName);
148 EXPECT_EQ("message #2", D2.Message.Message);
149 EXPECT_EQ(60u, D2.Message.FileOffset);
150 EXPECT_EQ("path/to/header.h", D2.Message.FilePath);
153 EXPECT_EQ("path/to/header.h", Fixes2[0].getFilePath());
154 EXPECT_EQ(62u, Fixes2[0].getOffset());
155 EXPECT_EQ(2u, Fixes2[0].getLength());
156 EXPECT_EQ("replacement #2", Fixes2[0].getReplacementText());
159 EXPECT_EQ("diagnostic#3", D3.DiagnosticName);
160 EXPECT_EQ("message #3", D3.Message.Message);
161 EXPECT_EQ(72u, D3.Message.FileOffset);
162 EXPECT_EQ("path/to/source2.cpp", D3.Message.FilePath);
163 EXPECT_EQ(2u, D3.Notes.size());
164 EXPECT_EQ("Note1", D3.Notes[0].Message);
165 EXPECT_EQ(88u, D3.Notes[0].FileOffset);
166 EXPECT_EQ("path/to/note1.cpp", D3.Notes[0].FilePath);
167 EXPECT_EQ("Note2", D3.Notes[1].Message);
168 EXPECT_EQ(99u, D3.Notes[1].FileOffset);
169 EXPECT_EQ("path/to/note2.cpp", D3.Notes[1].FilePath);
tools/clang/unittests/Tooling/ExecutionTest.cpp 160 EXPECT_EQ(BeforeReset, "set");
170 EXPECT_EQ(Executor->get()->getExecutorName(),
181 EXPECT_EQ(Executor->get()->getExecutorName(), TestToolExecutor::ExecutorName);
219 EXPECT_EQ("f", KVs[0].first);
222 EXPECT_EQ("::/1", KVs[0].second);
225 [](StringRef, StringRef Value) { EXPECT_EQ("::/1", Value); });
tools/clang/unittests/Tooling/FixItTest.cpp 38 EXPECT_EQ("foo(x, y)", getText(*CE, *Context));
39 EXPECT_EQ("foo(x, y)", getText(CE->getSourceRange(), *Context));
43 EXPECT_EQ("x", getText(*P0, *Context));
44 EXPECT_EQ("y", getText(*P1, *Context));
49 EXPECT_EQ("APPLY(foo, x, y)", getText(*CE, *Context));
59 EXPECT_EQ("F OO", getText(*CE, *Context));
62 EXPECT_EQ("", getText(*P0, *Context));
63 EXPECT_EQ("", getText(*P1, *Context));
70 EXPECT_EQ("", getText(*CE, *Context));
73 EXPECT_EQ("x", getText(*P0, *Context));
74 EXPECT_EQ("y", getText(*P1, *Context));
85 EXPECT_EQ("foo(x, y)", getText(Hint.RemoveRange.getAsRange(), *Context));
91 EXPECT_EQ("x", getText(Hint0.RemoveRange.getAsRange(), *Context));
97 EXPECT_EQ("y", getText(Hint1.RemoveRange.getAsRange(), *Context));
106 EXPECT_EQ("x + y", getText(Hint0.RemoveRange.getAsRange(), *Context));
110 EXPECT_EQ("y + x", getText(Hint1.RemoveRange.getAsRange(), *Context));
120 EXPECT_EQ("FOO", getText(Hint.RemoveRange.getAsRange(), *Context));
126 EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:17>",
128 EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:17>",
135 EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:20>",
137 EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:20>",
147 EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:37>",
149 EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:45>",
168 EXPECT_EQ("x", getText(Hint0.RemoveRange.getAsRange(), *Context));
170 EXPECT_EQ(Hint0.CodeToInsert, "y");
173 EXPECT_EQ("y", getText(Hint1.RemoveRange.getAsRange(), *Context));
175 EXPECT_EQ(Hint1.CodeToInsert, "x");
195 EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:17>",
197 EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:1:17>",
210 EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:2:30>",
212 EXPECT_EQ("input.cc:2:26 <Spelling=input.cc:2:30>",
215 EXPECT_EQ("y", Hint.CodeToInsert);
224 EXPECT_EQ("x + y", getText(Hint.RemoveRange.getAsRange(), *Context));
226 EXPECT_EQ("y + x", Hint.CodeToInsert);
tools/clang/unittests/Tooling/HeaderIncludesTest.cpp 51 EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
67 EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
91 EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
104 EXPECT_EQ(Expected, insert(Code, "<a>"));
115 EXPECT_EQ(Expected, insert(Code, "\"z.h\""));
128 EXPECT_EQ(Expected, insert(Code, "\"z.h\""));
143 EXPECT_EQ(Expected, insert(Code, "\"llvm/x/y.h\""));
156 EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
177 EXPECT_EQ(Expected, insert(Code, "\"d.h\""));
192 EXPECT_EQ(Expected, insert(Code, "<vector>"));
209 EXPECT_EQ(Expected, insert(Code, "<vector>"));
220 EXPECT_EQ(Expected, insert(Code, "<vector>"));
231 EXPECT_EQ(Expected, insert(Code, "<vector>"));
248 EXPECT_EQ(Expected, insert(Code, "<vector>"));
265 EXPECT_EQ(Expected, insert(Code, "<vector>"));
286 EXPECT_EQ(Expected, insert(Code, "<vector>"));
297 EXPECT_EQ(Expected, insert(Code, "<vector>"));
312 EXPECT_EQ(Expected, insert(Code, "<vector>"));
323 EXPECT_EQ(Expected, insert(Code, "<vector>"));
336 EXPECT_EQ(Expected, insert(Code, "<vector>"));
347 EXPECT_EQ(Expected, insert(Code, "<vector>"));
368 EXPECT_EQ(Expected, insert(Code, "<vector>"));
374 EXPECT_EQ(Expected, insert(Code, "<vector>"));
380 EXPECT_EQ(Expected, insert(Code, "<vector>"));
388 EXPECT_EQ(Expected, insert(Code, "<vector>"));
389 EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
397 EXPECT_EQ(Expected, insert(Code, "\"vector\""));
408 EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
421 EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
434 EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
445 EXPECT_EQ(Expected, insert(Code, "<x.h>"));
464 EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
487 EXPECT_EQ(Expected, insert(Code, "\"third.h\""));
496 EXPECT_EQ(Expected, remove(Code, "\"xyz.h\""));
505 EXPECT_EQ(Expected, remove(Code, "\"abc.h\""));
511 EXPECT_EQ(Expected, remove(Code, "\"xyz.h\""));
520 EXPECT_EQ(Expected, remove(Code, "<xyz.h>"));
529 EXPECT_EQ(Expected, remove(Code, "\"b.h\""));
tools/clang/unittests/Tooling/LookupTest.cpp 52 EXPECT_EQ("bar", replaceCallExpr(Expr, "::bar"));
58 EXPECT_EQ("bar", replaceCallExpr(Expr, "::a::bar"));
64 EXPECT_EQ("a::bar", replaceCallExpr(Expr, "::a::bar"));
70 EXPECT_EQ("::a::bar", replaceCallExpr(Expr, "::a::bar"));
77 EXPECT_EQ("c::bar", replaceCallExpr(Expr, "::a::c::bar"));
83 EXPECT_EQ("bar", replaceCallExpr(Expr, "::a::bar"));
89 EXPECT_EQ("bar", replaceCallExpr(Expr, "::bar"));
94 EXPECT_EQ("::bar", replaceCallExpr(Expr, "::bar"));
99 EXPECT_EQ("a::bar", replaceCallExpr(Expr, "::a::bar"));
104 EXPECT_EQ("a::bar", replaceCallExpr(Expr, "::a::bar"));
109 EXPECT_EQ("bar", replaceCallExpr(Expr, "::a::bar"));
115 EXPECT_EQ("c::bar", replaceCallExpr(Expr, "::a::c::bar"));
123 EXPECT_EQ("x::bar", replaceCallExpr(Expr, "::a::x::bar"));
132 EXPECT_EQ("a::y::bar", replaceCallExpr(Expr, "::a::y::bar"));
150 EXPECT_EQ("::y::bar", replaceCallExpr(Expr, "::y::bar"));
167 EXPECT_EQ("y::bar", replaceCallExpr(Expr, "::y::bar"));
196 EXPECT_EQ("x::Bar", replaceRecordTypeLoc(Type, "::a::x::Bar"));
209 EXPECT_EQ("Bar", replaceRecordTypeLoc(Type, "::a::x::Bar"));
221 EXPECT_EQ("Foo", replaceRecordTypeLoc(Type, "::x::Foo"));
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/ImplicitCtorInitializer.cpp 54 EXPECT_EQ(Visitor.VisitedImplicitInitializer, VisitImplCode);
tools/clang/unittests/Tooling/RefactoringActionRulesTest.cpp 143 EXPECT_EQ(DiagID, diag::err_refactor_no_selection);
175 EXPECT_EQ(Message, "Error");
231 EXPECT_EQ(Occurrences.size(), 1u);
232 EXPECT_EQ(Occurrences[0].getKind(), SymbolOccurrence::MatchingSymbol);
233 EXPECT_EQ(Occurrences[0].getNameRanges().size(), 1u);
234 EXPECT_EQ(Occurrences[0].getNameRanges()[0],
240 EXPECT_EQ(Descriptor.Name, "extract-function");
241 EXPECT_EQ(
244 EXPECT_EQ(Descriptor.Title, "Extract Function");
tools/clang/unittests/Tooling/RefactoringCallbacksTest.cpp 34 EXPECT_EQ(Expected, Context.getRewrittenText(ID));
133 EXPECT_EQ(Expected, Found);
tools/clang/unittests/Tooling/RefactoringTest.cpp 41 EXPECT_EQ("", Context.getRewrittenText(ID));
49 EXPECT_EQ("", Context.getRewrittenText(ID));
57 EXPECT_EQ("result", Context.getRewrittenText(ID));
66 EXPECT_EQ("line1\nlixne4", Context.getRewrittenText(ID));
75 EXPECT_EQ("line1\nlix\ny\nne4", Context.getRewrittenText(ID));
82 EXPECT_EQ("line1\nlix\ny\nnf4", Context.getRewrittenText(ID));
92 EXPECT_EQ("/path/to/file.cpp", Replace.getFilePath());
168 EXPECT_EQ(1u, Replaces.size());
169 EXPECT_EQ(Deletion, *Replaces.begin());
184 EXPECT_EQ(1u, Replaces.size());
185 EXPECT_EQ(R, *Replaces.begin());
197 EXPECT_EQ(1u, Replaces.size());
198 EXPECT_EQ(Replacement("x.cc", 0, 5, "34543"), *Replaces.begin());
203 EXPECT_EQ(1u, Replaces.size());
204 EXPECT_EQ(Replacement("x.cc", 0, 5, "34543"), *Replaces.begin());
216 EXPECT_EQ(Replaces.size(), 2u);
226 EXPECT_EQ(Replaces.size(), 2u);
248 EXPECT_EQ(1u, Replaces.size());
249 EXPECT_EQ(*Replaces.begin(), ContainingReplacement);
272 EXPECT_EQ(2u, Replaces.size());
273 EXPECT_EQ(*Replaces.begin(), ContainingReplacement);
274 EXPECT_EQ(*(++Replaces.begin()), After);
294 EXPECT_EQ(2u, Replaces.size());
295 EXPECT_EQ(*Replaces.begin(), Insertion);
296 EXPECT_EQ(*(++Replaces.begin()), Deletion);
309 EXPECT_EQ(1u, Replaces.size());
310 EXPECT_EQ(Replacement("x.cc", 0, 5, ""), *Replaces.begin());
315 EXPECT_EQ(1u, Replaces.size());
316 EXPECT_EQ(Replacement("x.cc", 0, 6, ""), *Replaces.begin());
335 EXPECT_EQ(1u, Replaces.size());
336 EXPECT_EQ(Replacement("x.cc", 0, 11, ""), *Replaces.begin());
371 EXPECT_EQ(Replaces.size(), 2u);
380 EXPECT_EQ(Replaces.size(), 2u);
401 EXPECT_EQ(1u, Replaces.size());
402 EXPECT_EQ(Replacement("x.cc", 10, 0, "aaa"), *Replaces.begin());
414 EXPECT_EQ(2u, Replaces.size());
415 EXPECT_EQ(Replacement("x.cc", 10, 0, ""), *Replaces.begin());
416 EXPECT_EQ(Replacement("x.cc", 10, 3, ""), *std::next(Replaces.begin()));
441 EXPECT_EQ("line1\nreplaced\nother\nline4", Context.getRewrittenText(ID));
454 EXPECT_EQ("line1\nother\nline3\nline4", Context.getRewrittenText(ID));
464 EXPECT_EQ("xy", Context.getRewrittenText(ID));
484 EXPECT_EQ("line1\nreplaced\nline3\nline4", Context.getRewrittenText(ID));
501 EXPECT_EQ("line1\nother\nline3\nline4", Context.getRewrittenText(ID));
544 EXPECT_EQ(Expected1, Context.getRewrittenText(ID1));
545 EXPECT_EQ(Expected2, Context.getRewrittenText(ID2));
552 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(0)); // |int i;
553 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(1)); // |nt i;
554 EXPECT_EQ(1u, Replaces.getShiftedCodePosition(2)); // i|t i;
555 EXPECT_EQ(2u, Replaces.getShiftedCodePosition(3)); // in| i;
556 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(4)); // int| i;
557 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(5)); // int | i;
558 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(6)); // int |i;
559 EXPECT_EQ(4u, Replaces.getShiftedCodePosition(7)); // int |;
560 EXPECT_EQ(5u, Replaces.getShiftedCodePosition(8)); // int i|
566 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(3)); // "123|5678"
567 EXPECT_EQ(7u, Replaces.getShiftedCodePosition(4)); // "1234|678"
568 EXPECT_EQ(8u, Replaces.getShiftedCodePosition(5)); // "12345|78"
575 EXPECT_EQ(i, Replaces.getShiftedCodePosition(i));
580 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(0));
581 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(39));
582 EXPECT_EQ(3u, Replaces.getShiftedCodePosition(45));
583 EXPECT_EQ(0u, Replaces.getShiftedCodePosition(42));
644 EXPECT_EQ("line1\nreplaced\nline3\nline4",
695 EXPECT_EQ(File, Replace.getFilePath());
696 EXPECT_EQ(Offset, Replace.getOffset());
697 EXPECT_EQ(Length, Replace.getLength());
795 EXPECT_EQ(2ul, Ranges.size());
808 EXPECT_EQ(1ul, Ranges.size());
809 EXPECT_EQ(0u, Ranges[0].getOffset());
810 EXPECT_EQ(2u, Ranges[0].getLength());
817 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
824 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
831 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
841 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
851 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
862 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
870 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
879 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
887 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
895 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
905 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
912 EXPECT_EQ(Expected, calculateRangesAfterReplacements(Replaces, Ranges));
925 EXPECT_EQ(Intermediate, *AfterFirst);
926 EXPECT_EQ(Result, *InSequenceRewrite);
931 EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
945 EXPECT_EQ(*InSequenceRewrite, *MergedRewrite);
974 EXPECT_EQ(toReplacements({{"", 0, 0, "ab"}}), First.merge(Second));
979 EXPECT_EQ(toReplacements({{"", 0, 0, "ba"}}), First.merge(Second));
1050 EXPECT_EQ(1u, FileToReplaces.size());
1051 EXPECT_EQ(Path1, FileToReplaces.begin()->first);
1071 EXPECT_EQ(1u, FileToReplaces.size());
1072 EXPECT_EQ(Path1, FileToReplaces.begin()->first);
1175 EXPECT_EQ(ExpectedChange.getKey(), ActualChange.getKey());
1176 EXPECT_EQ(ExpectedChange.getFilePath(), ActualChange.getFilePath());
1177 EXPECT_EQ(ExpectedChange.getError(), ActualChange.getError());
1178 EXPECT_EQ(ExpectedChange.getInsertedHeaders(),
1180 EXPECT_EQ(ExpectedChange.getRemovedHeaders(),
1182 EXPECT_EQ(ExpectedChange.getReplacements().size(),
1184 EXPECT_EQ(2u, ActualChange.getReplacements().size());
1185 EXPECT_EQ(*ExpectedChange.getReplacements().begin(),
1187 EXPECT_EQ(*(++ExpectedChange.getReplacements().begin()),
1193 EXPECT_EQ("input.cpp:20", Change.getKey());
1194 EXPECT_EQ("input.cpp", Change.getFilePath());
1201 EXPECT_EQ(Change.getReplacements().size(), 1u);
1202 EXPECT_EQ(*Change.getReplacements().begin(),
1209 EXPECT_EQ(Change.getReplacements().size(), 1u);
1218 EXPECT_EQ(Change.getReplacements().size(), 1u);
1219 EXPECT_EQ(*Change.getReplacements().begin(),
1227 EXPECT_EQ(Change.getReplacements().size(), 1u);
1228 EXPECT_EQ(*Change.getReplacements().begin(),
1232 EXPECT_EQ(Change.getReplacements().size(), 1u);
1233 EXPECT_EQ(*Change.getReplacements().begin(),
1241 EXPECT_EQ(Change.getReplacements().size(), 1u);
1242 EXPECT_EQ(*Change.getReplacements().begin(),
1246 EXPECT_EQ(Change.getReplacements().size(), 1u);
1247 EXPECT_EQ(*Change.getReplacements().begin(),
1330 EXPECT_EQ(FailureExpected, !ChangedCode);
1351 EXPECT_EQ("int b;", rewrite());
1361 EXPECT_EQ("float f;\n"
1377 EXPECT_EQ("int aa;\n"
1386 EXPECT_EQ("int abb;", rewrite());
1393 EXPECT_EQ("", rewrite(/*FailureExpected=*/true));
1399 EXPECT_EQ("int b;", rewrite());
1411 EXPECT_EQ("int x;\n"
1424 EXPECT_EQ("int a;\n"
1436 EXPECT_EQ("int a;\n"
1444 EXPECT_EQ("int bbb;", rewrite());
1450 EXPECT_EQ("int b;", rewrite());
1458 EXPECT_EQ("int aaa;\n"
1470 EXPECT_EQ("int aaa;\n"
1480 EXPECT_EQ("int *ccc;\n"
1491 EXPECT_EQ(" int aaa;\n"
1503 EXPECT_EQ("", rewrite(/*FailureExpected=*/true));
1513 EXPECT_EQ("#include \"a\"\n"
1528 EXPECT_EQ("#include \"a\"\n"
1545 EXPECT_EQ("#include <asys>\n"
1565 EXPECT_EQ("#include <b>\n"
1593 EXPECT_EQ("#ifndef __H__\n"
1613 EXPECT_EQ("\n"
1642 EXPECT_EQ("A::A() : b() {}\n"
1667 EXPECT_EQ("void f(float f);\n"
1691 EXPECT_EQ("void f(, float f, );\n"
1700 EXPECT_EQ("", rewrite());
1715 EXPECT_EQ("int b;\n"
tools/clang/unittests/Tooling/RewriterTest.cpp 22 EXPECT_EQ("line1\nreplaced\nline3\nline4",
35 EXPECT_EQ("line1\nreplaced\nline3\nline4",
48 EXPECT_EQ("line1\nreplaced\nline3\nline4", *Rewritten);
tools/clang/unittests/Tooling/SourceCodeBuildersTest.cpp 73 EXPECT_EQ(Expected, Pred(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr")))
85 EXPECT_EQ(Expected, Pred(*StmtMatch->Result.Nodes.getNodeAs<Expr>("arg")))
tools/clang/unittests/Tooling/SourceCodeTest.cpp 61 EXPECT_EQ("foo(x, y)", getText(*CE, *Context));
66 EXPECT_EQ("APPLY(foo, x, y)", getText(*CE, *Context));
76 EXPECT_EQ("F OO", getText(*CE, *Context));
79 EXPECT_EQ("", getText(*P0, *Context));
80 EXPECT_EQ("", getText(*P1, *Context));
87 EXPECT_EQ("", getText(*CE, *Context));
90 EXPECT_EQ("x", getText(*P0, *Context));
91 EXPECT_EQ("y", getText(*P1, *Context));
101 EXPECT_EQ("foo(x, y);",
106 EXPECT_EQ("x", getExtendedText(*P0, tok::TokenKind::semi, *Context));
107 EXPECT_EQ("x,", getExtendedText(*P0, tok::TokenKind::comma, *Context));
108 EXPECT_EQ("y", getExtendedText(*P1, tok::TokenKind::semi, *Context));
118 EXPECT_EQ("foo()", getExtendedText(*CE, tok::TokenKind::semi, *Context));
tools/clang/unittests/Tooling/StencilTest.cpp 354 EXPECT_EQ(S.toString(), Expected);
360 EXPECT_EQ(S.toString(), Expected);
366 EXPECT_EQ(S.toString(), Expected);
372 EXPECT_EQ(S.toString(), Expected);
378 EXPECT_EQ(S.toString(), Expected);
384 EXPECT_EQ(S.toString(), Expected);
389 EXPECT_EQ(S1.toString(), "selection(...)");
395 EXPECT_EQ(S.toString(), Expected);
401 EXPECT_EQ(S.toString(), Expected);
408 EXPECT_EQ(S.toString(), Expected);
414 EXPECT_EQ(S1.toString(), "run(...)");
422 EXPECT_EQ(S.toString(), Expected);
tools/clang/unittests/Tooling/Syntax/TokensTest.cpp 318 EXPECT_EQ(collectAndDump(Test.first), Test.second)
377 EXPECT_EQ(collectAndDump(Code), Expected);
475 EXPECT_EQ(Test.second, collectAndDump(Test.first))
573 EXPECT_EQ(Expected, collectAndDump(Code))
609 EXPECT_EQ(Buffer.spelledForExpanded(findExpanded("a1 a2")), llvm::None);
610 EXPECT_EQ(Buffer.spelledForExpanded(findExpanded("b2")), llvm::None);
611 EXPECT_EQ(Buffer.spelledForExpanded(findExpanded("a2 a3 split b1 b2")),
630 EXPECT_EQ(Buffer.spelledForExpanded(findExpanded("a1 a2 a3 split b1")),
632 EXPECT_EQ(Buffer.spelledForExpanded(findExpanded("a2 a3 split b1")),
636 EXPECT_EQ(Buffer.spelledForExpanded(findExpanded("a2")), llvm::None);
637 EXPECT_EQ(Buffer.spelledForExpanded(findExpanded("a1 a2")), llvm::None);
699 EXPECT_EQ(Buffer.expansionStartingAt(&T), llvm::None);
707 EXPECT_EQ(Buffer.expansionStartingAt(&T), llvm::None);
724 EXPECT_EQ(Buffer.expansionStartingAt(&T), llvm::None);
733 EXPECT_EQ(Buffer.expansionStartingAt(&T), llvm::None);
750 EXPECT_EQ(Int.range(SM), FileRange(SM.getMainFileID(), Code.range("i").Begin,
752 EXPECT_EQ(syntax::Token::range(SM, Int, Semi),
779 EXPECT_EQ(ExpectedMacroRanges, ActualMacroRanges);
tools/clang/unittests/Tooling/Syntax/TreeTest.cpp 156 EXPECT_EQ(Expected, Actual) << "the resulting dump is:\n" << Actual;
tools/clang/unittests/Tooling/TestVisitor.h 235 EXPECT_EQ(TimesExpected, TimesSeen)
tools/clang/unittests/Tooling/ToolingTest.cpp 235 EXPECT_EQ(2u, EndCallback.BeginCalled);
236 EXPECT_EQ(2u, EndCallback.EndCalled);
429 EXPECT_EQ(SyntaxOnlyCount, 1U);
447 EXPECT_EQ(0, Tool.run(Action.get()));
535 EXPECT_EQ((std::vector<std::string>{"clang", "-foo"}), Args);
537 EXPECT_EQ((std::vector<std::string>{"clang", "-target", Target,
551 EXPECT_EQ((std::vector<std::string>{"clang", "-target", Target,
562 EXPECT_EQ((std::vector<std::string>{"clang", "--driver-mode=g++", "-foo",
568 EXPECT_EQ((std::vector<std::string>{"clang", "--driver-mode=g++", "-foo",
579 EXPECT_EQ((std::vector<std::string>{"clang", "-target", Target, "-foo",
585 EXPECT_EQ((std::vector<std::string>{"clang", "-target", Target, "-foo",
603 EXPECT_EQ(0, Tool.buildASTs(ASTs));
604 EXPECT_EQ(2u, ASTs.size());
625 EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen);
636 EXPECT_EQ(1u, ASTs.size());
637 EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen);
tools/clang/unittests/Tooling/TransformerTest.cpp 72 EXPECT_EQ(format(Expected), format(Actual));
562 EXPECT_EQ(transformer::detail::buildMatchers(Rule).size(), 2UL);
584 EXPECT_EQ(ErrorCount, 1);
599 EXPECT_EQ(ErrorCount, 1);
613 EXPECT_EQ(Changes.size(), 2u);
614 EXPECT_EQ(ErrorCount, 0);
628 EXPECT_EQ(ErrorCount, 0);
tools/clang/unittests/libclang/LibclangTest.cpp 25 EXPECT_EQ(CXError_InvalidArguments,
31 EXPECT_EQ(nullptr, clang_createTranslationUnit(nullptr, nullptr));
35 EXPECT_EQ(CXError_InvalidArguments,
39 EXPECT_EQ(CXError_InvalidArguments,
41 EXPECT_EQ(nullptr, TU);
55 EXPECT_EQ(Err, CXError_Success);
60 EXPECT_EQ(Err, ExpErr);
372 EXPECT_EQ(2U, Ranges->count);
378 EXPECT_EQ(1U, line);
381 EXPECT_EQ(3U, line);
385 EXPECT_EQ(2U, line);
388 EXPECT_EQ(4U, line);
418 EXPECT_EQ(clang_EvalResult_getKind(RE),
428 EXPECT_EQ(numberedStmt, 1);
487 EXPECT_EQ(1U, clang_getNumDiagnostics(ClangTU));
492 EXPECT_EQ(1U, clang_getNumDiagnostics(ClangTU));
500 EXPECT_EQ(0U, clang_getNumDiagnostics(ClangTU));
522 EXPECT_EQ(1U, clang_getNumDiagnostics(ClangTU));
527 EXPECT_EQ(1U, clang_getNumDiagnostics(ClangTU));
535 EXPECT_EQ(0U, clang_getNumDiagnostics(ClangTU));
557 EXPECT_EQ(CXError_Success,
561 EXPECT_EQ(0U, clang_getNumDiagnostics(ClangTU));
590 EXPECT_EQ(Value, clang_PrintingPolicy_getProperty(Policy, Property));
627 EXPECT_EQ(3U, Ranges->count);
633 EXPECT_EQ(1U, line);
636 EXPECT_EQ(3U, line);
640 EXPECT_EQ(2U, line);
643 EXPECT_EQ(3U, line);
647 EXPECT_EQ(4U, line);
650 EXPECT_EQ(6U, line);
657 EXPECT_EQ(1U, Ranges->count);
660 EXPECT_EQ(1U, line);
665 EXPECT_EQ(2U, Ranges->count);
668 EXPECT_EQ(2U, line);
671 EXPECT_EQ(4U, line);
720 EXPECT_EQ(CXToken_Keyword, clang_getTokenKind(Tokens[0]));
721 EXPECT_EQ(CXToken_Keyword, clang_getTokenKind(Tokens[1]));
722 EXPECT_EQ(CXToken_Identifier, clang_getTokenKind(Tokens[2]));
723 EXPECT_EQ(CXToken_Punctuation, clang_getTokenKind(Tokens[3]));
724 EXPECT_EQ(CXToken_Punctuation, clang_getTokenKind(Tokens[4]));
725 EXPECT_EQ(CXToken_Punctuation, clang_getTokenKind(Tokens[5]));
tools/lld/unittests/DriverTests/DarwinLdDriverTest.cpp 54 EXPECT_EQ(2, inputFileCount());
55 EXPECT_EQ("foo.o", inputFile(0));
56 EXPECT_EQ("bar.o", inputFile(1));
61 EXPECT_EQ("my.out", _ctx.outputPath());
66 EXPECT_EQ(llvm::MachO::MH_DYLIB, _ctx.outputMachOType());
71 EXPECT_EQ(llvm::MachO::MH_OBJECT, _ctx.outputMachOType());
76 EXPECT_EQ(llvm::MachO::MH_BUNDLE, _ctx.outputMachOType());
81 EXPECT_EQ(llvm::MachO::MH_PRELOAD, _ctx.outputMachOType());
86 EXPECT_EQ(llvm::MachO::MH_EXECUTE, _ctx.outputMachOType());
91 EXPECT_EQ("entryFunc", _ctx.entrySymbolName());
134 EXPECT_EQ(MachOLinkingContext::arch_x86_64, _ctx.arch());
135 EXPECT_EQ((uint32_t)llvm::MachO::CPU_TYPE_X86_64, _ctx.getCPUType());
136 EXPECT_EQ(llvm::MachO::CPU_SUBTYPE_X86_64_ALL, _ctx.getCPUSubType());
141 EXPECT_EQ(MachOLinkingContext::arch_x86, _ctx.arch());
142 EXPECT_EQ((uint32_t)llvm::MachO::CPU_TYPE_I386, _ctx.getCPUType());
143 EXPECT_EQ(llvm::MachO::CPU_SUBTYPE_X86_ALL, _ctx.getCPUSubType());
148 EXPECT_EQ(MachOLinkingContext::arch_armv6, _ctx.arch());
149 EXPECT_EQ((uint32_t)llvm::MachO::CPU_TYPE_ARM, _ctx.getCPUType());
150 EXPECT_EQ(llvm::MachO::CPU_SUBTYPE_ARM_V6, _ctx.getCPUSubType());
155 EXPECT_EQ(MachOLinkingContext::arch_armv7, _ctx.arch());
156 EXPECT_EQ((uint32_t)llvm::MachO::CPU_TYPE_ARM, _ctx.getCPUType());
157 EXPECT_EQ(llvm::MachO::CPU_SUBTYPE_ARM_V7, _ctx.getCPUSubType());
162 EXPECT_EQ(MachOLinkingContext::arch_armv7s, _ctx.arch());
163 EXPECT_EQ((uint32_t)llvm::MachO::CPU_TYPE_ARM, _ctx.getCPUType());
164 EXPECT_EQ(llvm::MachO::CPU_SUBTYPE_ARM_V7S, _ctx.getCPUSubType());
170 EXPECT_EQ(MachOLinkingContext::OS::macOSX, _ctx.os());
178 EXPECT_EQ(MachOLinkingContext::OS::macOSX, _ctx.os());
185 EXPECT_EQ(MachOLinkingContext::OS::iOS, _ctx.os());
192 EXPECT_EQ(MachOLinkingContext::OS::iOS, _ctx.os());
200 EXPECT_EQ(MachOLinkingContext::OS::iOS_simulator, _ctx.os());
208 EXPECT_EQ(MachOLinkingContext::OS::iOS_simulator, _ctx.os());
216 EXPECT_EQ(_ctx.compatibilityVersion(), 0x10203U);
232 EXPECT_EQ(_ctx.currentVersion(), 0x10203U);
248 EXPECT_EQ(_ctx.bundleLoader(), "/bin/ls");
258 EXPECT_EQ(true, _ctx.deadStrippableDylib());
tools/lld/unittests/MachOTests/MachONormalizedFileBinaryReaderTests.cpp 76 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86_64);
77 EXPECT_EQ((int)(f->fileType), MH_OBJECT);
78 EXPECT_EQ((int)(f->flags), MH_SUBSECTIONS_VIA_SYMBOLS);
107 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86);
108 EXPECT_EQ((int)(f->fileType), MH_OBJECT);
109 EXPECT_EQ((int)(f->flags), MH_SUBSECTIONS_VIA_SYMBOLS);
138 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_ppc);
139 EXPECT_EQ((int)(f->fileType), MH_OBJECT);
140 EXPECT_EQ((int)(f->flags), MH_SUBSECTIONS_VIA_SYMBOLS);
169 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_armv7);
170 EXPECT_EQ((int)(f->fileType), MH_OBJECT);
171 EXPECT_EQ((int)(f->flags), MH_SUBSECTIONS_VIA_SYMBOLS);
183 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86_64);
184 EXPECT_EQ((int)(f->fileType), MH_OBJECT);
185 EXPECT_EQ((int)(f->flags), MH_SUBSECTIONS_VIA_SYMBOLS);
192 EXPECT_EQ(f2->arch, lld::MachOLinkingContext::arch_armv7);
193 EXPECT_EQ((int)(f2->fileType), MH_OBJECT);
194 EXPECT_EQ((int)(f2->flags), MH_SUBSECTIONS_VIA_SYMBOLS);
269 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86_64);
270 EXPECT_EQ((int)(f->fileType), MH_OBJECT);
271 EXPECT_EQ((int)(f->flags), MH_SUBSECTIONS_VIA_SYMBOLS);
272 EXPECT_EQ(f->sections.size(), 2UL);
276 EXPECT_EQ(text.type, S_REGULAR);
277 EXPECT_EQ(text.attributes,SectionAttr(S_ATTR_PURE_INSTRUCTIONS
279 EXPECT_EQ((uint16_t)text.alignment, 16U);
280 EXPECT_EQ(text.address, Hex64(0x0));
281 EXPECT_EQ(text.content.size(), 45UL);
282 EXPECT_EQ((int)(text.content[0]), 0x55);
283 EXPECT_EQ((int)(text.content[1]), 0x48);
285 EXPECT_EQ(text.relocations.size(), 2UL);
287 EXPECT_EQ(call.offset, Hex32(0x19));
288 EXPECT_EQ(call.type, X86_64_RELOC_BRANCH);
289 EXPECT_EQ(call.length, 2);
290 EXPECT_EQ(call.isExtern, true);
291 EXPECT_EQ(call.symbol, 2U);
293 EXPECT_EQ(str.offset, Hex32(0xB));
294 EXPECT_EQ(str.type, X86_64_RELOC_SIGNED);
295 EXPECT_EQ(str.length, 2);
296 EXPECT_EQ(str.isExtern, true);
297 EXPECT_EQ(str.symbol, 0U);
302 EXPECT_EQ(cstring.type, S_CSTRING_LITERALS);
303 EXPECT_EQ(cstring.attributes, SectionAttr(0));
304 EXPECT_EQ((uint16_t)cstring.alignment, 1U);
305 EXPECT_EQ(cstring.address, Hex64(0x02D));
306 EXPECT_EQ(cstring.content.size(), 7UL);
307 EXPECT_EQ((int)(cstring.content[0]), 0x68);
308 EXPECT_EQ((int)(cstring.content[1]), 0x65);
309 EXPECT_EQ((int)(cstring.content[2]), 0x6c);
313 EXPECT_EQ(f->localSymbols.size(), 1UL);
315 EXPECT_EQ(strLabel.type, N_SECT);
316 EXPECT_EQ(strLabel.sect, 2);
317 EXPECT_EQ(strLabel.value, Hex64(0x2D));
318 EXPECT_EQ(f->globalSymbols.size(), 1UL);
321 EXPECT_EQ(mainLabel.type, N_SECT);
322 EXPECT_EQ(mainLabel.sect, 1);
323 EXPECT_EQ(mainLabel.scope, SymbolScope(N_EXT));
324 EXPECT_EQ(mainLabel.value, Hex64(0x0));
325 EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
328 EXPECT_EQ(printfLabel.type, N_UNDF);
329 EXPECT_EQ(printfLabel.scope, SymbolScope(N_EXT));
394 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86);
395 EXPECT_EQ((int)(f->fileType), MH_OBJECT);
396 EXPECT_EQ((int)(f->flags), MH_SUBSECTIONS_VIA_SYMBOLS);
397 EXPECT_EQ(f->sections.size(), 2UL);
401 EXPECT_EQ(text.type, S_REGULAR);
402 EXPECT_EQ(text.attributes,SectionAttr(S_ATTR_PURE_INSTRUCTIONS
404 EXPECT_EQ((uint16_t)text.alignment, 16U);
405 EXPECT_EQ(text.address, Hex64(0x0));
406 EXPECT_EQ(text.content.size(), 48UL);
407 EXPECT_EQ((int)(text.content[0]), 0x55);
408 EXPECT_EQ((int)(text.content[1]), 0x89);
410 EXPECT_EQ(text.relocations.size(), 3UL);
412 EXPECT_EQ(call.offset, Hex32(0x1D));
413 EXPECT_EQ(call.scattered, false);
414 EXPECT_EQ(call.type, GENERIC_RELOC_VANILLA);
415 EXPECT_EQ(call.pcRel, true);
416 EXPECT_EQ(call.length, 2);
417 EXPECT_EQ(call.isExtern, true);
418 EXPECT_EQ(call.symbol, 1U);
420 EXPECT_EQ(sectDiff.offset, Hex32(0xE));
421 EXPECT_EQ(sectDiff.scattered, true);
422 EXPECT_EQ(sectDiff.type, GENERIC_RELOC_LOCAL_SECTDIFF);
423 EXPECT_EQ(sectDiff.pcRel, false);
424 EXPECT_EQ(sectDiff.length, 2);
425 EXPECT_EQ(sectDiff.value, 0x30U);
427 EXPECT_EQ(pair.offset, Hex32(0x0));
428 EXPECT_EQ(pair.scattered, true);
429 EXPECT_EQ(pair.type, GENERIC_RELOC_PAIR);
430 EXPECT_EQ(pair.pcRel, false);
431 EXPECT_EQ(pair.length, 2);
432 EXPECT_EQ(pair.value, 0x0BU);
437 EXPECT_EQ(cstring.type, S_CSTRING_LITERALS);
438 EXPECT_EQ(cstring.attributes, SectionAttr(0));
439 EXPECT_EQ((uint16_t)cstring.alignment, 1U);
440 EXPECT_EQ(cstring.address, Hex64(0x030));
441 EXPECT_EQ(cstring.content.size(), 7UL);
442 EXPECT_EQ((int)(cstring.content[0]), 0x68);
443 EXPECT_EQ((int)(cstring.content[1]), 0x65);
444 EXPECT_EQ((int)(cstring.content[2]), 0x6c);
448 EXPECT_EQ(f->localSymbols.size(), 0UL);
449 EXPECT_EQ(f->globalSymbols.size(), 1UL);
452 EXPECT_EQ(mainLabel.type, N_SECT);
453 EXPECT_EQ(mainLabel.sect, 1);
454 EXPECT_EQ(mainLabel.scope, SymbolScope(N_EXT));
455 EXPECT_EQ(mainLabel.value, Hex64(0x0));
456 EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
459 EXPECT_EQ(printfLabel.type, N_UNDF);
460 EXPECT_EQ(printfLabel.scope, SymbolScope(N_EXT));
526 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_armv7);
527 EXPECT_EQ((int)(f->fileType), MH_OBJECT);
528 EXPECT_EQ((int)(f->flags), MH_SUBSECTIONS_VIA_SYMBOLS);
529 EXPECT_EQ(f->sections.size(), 2UL);
533 EXPECT_EQ(text.type, S_REGULAR);
534 EXPECT_EQ(text.attributes,SectionAttr(S_ATTR_PURE_INSTRUCTIONS
536 EXPECT_EQ((uint16_t)text.alignment, 4U);
537 EXPECT_EQ(text.address, Hex64(0x0));
538 EXPECT_EQ(text.content.size(), 42UL);
539 EXPECT_EQ((int)(text.content[0]), 0x80);
540 EXPECT_EQ((int)(text.content[1]), 0xB5);
542 EXPECT_EQ(text.relocations.size(), 5UL);
544 EXPECT_EQ(call.offset, Hex32(0x18));
545 EXPECT_EQ(call.scattered, false);
546 EXPECT_EQ(call.type, ARM_THUMB_RELOC_BR22);
547 EXPECT_EQ(call.length, 2);
548 EXPECT_EQ(call.isExtern, true);
549 EXPECT_EQ(call.symbol, 1U);
551 EXPECT_EQ(movt.offset, Hex32(0xA));
552 EXPECT_EQ(movt.scattered, true);
553 EXPECT_EQ(movt.type, ARM_RELOC_HALF_SECTDIFF);
554 EXPECT_EQ(movt.length, 3);
555 EXPECT_EQ(movt.value, Hex32(0x2A));
557 EXPECT_EQ(movtPair.offset, Hex32(0x18));
558 EXPECT_EQ(movtPair.scattered, true);
559 EXPECT_EQ(movtPair.type, ARM_RELOC_PAIR);
560 EXPECT_EQ(movtPair.length, 3);
561 EXPECT_EQ(movtPair.value, Hex32(0xE));
563 EXPECT_EQ(movw.offset, Hex32(0x6));
564 EXPECT_EQ(movw.scattered, true);
565 EXPECT_EQ(movw.type, ARM_RELOC_HALF_SECTDIFF);
566 EXPECT_EQ(movw.length, 2);
567 EXPECT_EQ(movw.value, Hex32(0x2A));
569 EXPECT_EQ(movwPair.offset, Hex32(0x0));
570 EXPECT_EQ(movwPair.scattered, true);
571 EXPECT_EQ(movwPair.type, ARM_RELOC_PAIR);
572 EXPECT_EQ(movwPair.length, 2);
573 EXPECT_EQ(movwPair.value, Hex32(0xE));
578 EXPECT_EQ(cstring.type, S_CSTRING_LITERALS);
579 EXPECT_EQ(cstring.attributes, SectionAttr(0));
580 EXPECT_EQ((uint16_t)cstring.alignment, 1U);
581 EXPECT_EQ(cstring.address, Hex64(0x02A));
582 EXPECT_EQ(cstring.content.size(), 7UL);
583 EXPECT_EQ((int)(cstring.content[0]), 0x68);
584 EXPECT_EQ((int)(cstring.content[1]), 0x65);
585 EXPECT_EQ((int)(cstring.content[2]), 0x6c);
589 EXPECT_EQ(f->localSymbols.size(), 0UL);
590 EXPECT_EQ(f->globalSymbols.size(), 1UL);
593 EXPECT_EQ(mainLabel.type, N_SECT);
594 EXPECT_EQ(mainLabel.sect, 1);
595 EXPECT_EQ(mainLabel.scope, SymbolScope(N_EXT));
596 EXPECT_EQ(mainLabel.value, Hex64(0x0));
597 EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
600 EXPECT_EQ(printfLabel.type, N_UNDF);
601 EXPECT_EQ(printfLabel.scope, SymbolScope(N_EXT));
670 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_ppc);
671 EXPECT_EQ((int)(f->fileType), MH_OBJECT);
672 EXPECT_EQ((int)(f->flags), MH_SUBSECTIONS_VIA_SYMBOLS);
673 EXPECT_EQ(f->sections.size(), 2UL);
677 EXPECT_EQ(text.type, S_REGULAR);
678 EXPECT_EQ(text.attributes,SectionAttr(S_ATTR_PURE_INSTRUCTIONS
680 EXPECT_EQ((uint16_t)text.alignment, 4U);
681 EXPECT_EQ(text.address, Hex64(0x0));
682 EXPECT_EQ(text.content.size(), 68UL);
683 EXPECT_EQ((int)(text.content[0]), 0x7C);
684 EXPECT_EQ((int)(text.content[1]), 0x08);
686 EXPECT_EQ(text.relocations.size(), 5UL);
688 EXPECT_EQ(bl.offset, Hex32(0x24));
689 EXPECT_EQ(bl.type, PPC_RELOC_BR24);
690 EXPECT_EQ(bl.length, 2);
691 EXPECT_EQ(bl.isExtern, true);
692 EXPECT_EQ(bl.symbol, 1U);
694 EXPECT_EQ(lo.offset, Hex32(0x20));
695 EXPECT_EQ(lo.scattered, true);
696 EXPECT_EQ(lo.type, PPC_RELOC_LO16_SECTDIFF);
697 EXPECT_EQ(lo.length, 2);
698 EXPECT_EQ(lo.value, Hex32(0x44));
700 EXPECT_EQ(loPair.offset, Hex32(0x0));
701 EXPECT_EQ(loPair.scattered, true);
702 EXPECT_EQ(loPair.type, PPC_RELOC_PAIR);
703 EXPECT_EQ(loPair.length, 2);
704 EXPECT_EQ(loPair.value, Hex32(0x18));
706 EXPECT_EQ(ha.offset, Hex32(0x1C));
707 EXPECT_EQ(ha.scattered, true);
708 EXPECT_EQ(ha.type, PPC_RELOC_HA16_SECTDIFF);
709 EXPECT_EQ(ha.length, 2);
710 EXPECT_EQ(ha.value, Hex32(0x44));
712 EXPECT_EQ(haPair.offset, Hex32(0x2c));
713 EXPECT_EQ(haPair.scattered, true);
714 EXPECT_EQ(haPair.type, PPC_RELOC_PAIR);
715 EXPECT_EQ(haPair.length, 2);
716 EXPECT_EQ(haPair.value, Hex32(0x18));
721 EXPECT_EQ(cstring.type, S_CSTRING_LITERALS);
722 EXPECT_EQ(cstring.attributes, SectionAttr(0));
723 EXPECT_EQ((uint16_t)cstring.alignment, 4U);
724 EXPECT_EQ(cstring.address, Hex64(0x044));
725 EXPECT_EQ(cstring.content.size(), 7UL);
726 EXPECT_EQ((int)(cstring.content[0]), 0x68);
727 EXPECT_EQ((int)(cstring.content[1]), 0x65);
728 EXPECT_EQ((int)(cstring.content[2]), 0x6c);
732 EXPECT_EQ(f->localSymbols.size(), 0UL);
733 EXPECT_EQ(f->globalSymbols.size(), 1UL);
736 EXPECT_EQ(mainLabel.type, N_SECT);
737 EXPECT_EQ(mainLabel.sect, 1);
738 EXPECT_EQ(mainLabel.scope, SymbolScope(N_EXT));
739 EXPECT_EQ(mainLabel.value, Hex64(0x0));
740 EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
743 EXPECT_EQ(printfLabel.type, N_UNDF);
744 EXPECT_EQ(printfLabel.scope, SymbolScope(N_EXT));
tools/lld/unittests/MachOTests/MachONormalizedFileBinaryWriterTests.cpp 158 EXPECT_EQ(lld::MachOLinkingContext::arch_x86_64, f2->arch);
159 EXPECT_EQ(MH_OBJECT, f2->fileType);
160 EXPECT_EQ(FileFlags(MH_SUBSECTIONS_VIA_SYMBOLS), f2->flags);
164 EXPECT_EQ(2UL, f2->undefinedSymbols.size());
167 EXPECT_EQ(N_UNDF, barUndef.type);
168 EXPECT_EQ(SymbolScope(N_EXT), barUndef.scope);
171 EXPECT_EQ(N_UNDF, tbarUndef.type);
172 EXPECT_EQ(SymbolScope(N_EXT), tbarUndef.scope);
174 EXPECT_EQ(1UL, f2->sections.size());
178 EXPECT_EQ(S_REGULAR, text.type);
179 EXPECT_EQ(text.attributes,SectionAttr(S_ATTR_PURE_INSTRUCTIONS
181 EXPECT_EQ((uint16_t)text.alignment, 16U);
182 EXPECT_EQ(text.address, Hex64(0x0));
183 EXPECT_EQ(48UL, text.content.size());
185 EXPECT_EQ(call.offset, Hex32(0x1));
186 EXPECT_EQ(call.type, X86_64_RELOC_BRANCH);
187 EXPECT_EQ(call.length, 2);
188 EXPECT_EQ(call.isExtern, true);
189 EXPECT_EQ(call.symbol, 1U);
191 EXPECT_EQ(gotLoad.offset, Hex32(0x8));
192 EXPECT_EQ(gotLoad.type, X86_64_RELOC_GOT_LOAD);
193 EXPECT_EQ(gotLoad.length, 2);
194 EXPECT_EQ(gotLoad.isExtern, true);
195 EXPECT_EQ(gotLoad.symbol, 1U);
197 EXPECT_EQ(gotUse.offset, Hex32(0xE));
198 EXPECT_EQ(gotUse.type, X86_64_RELOC_GOT);
199 EXPECT_EQ(gotUse.length, 2);
200 EXPECT_EQ(gotUse.isExtern, true);
201 EXPECT_EQ(gotUse.symbol, 1U);
203 EXPECT_EQ(signed0.offset, Hex32(0x14));
204 EXPECT_EQ(signed0.type, X86_64_RELOC_SIGNED);
205 EXPECT_EQ(signed0.length, 2);
206 EXPECT_EQ(signed0.isExtern, true);
207 EXPECT_EQ(signed0.symbol, 1U);
209 EXPECT_EQ(signed1.offset, Hex32(0x1A));
210 EXPECT_EQ(signed1.type, X86_64_RELOC_SIGNED_1);
211 EXPECT_EQ(signed1.length, 2);
212 EXPECT_EQ(signed1.isExtern, true);
213 EXPECT_EQ(signed1.symbol, 1U);
215 EXPECT_EQ(signed4.offset, Hex32(0x21));
216 EXPECT_EQ(signed4.type, X86_64_RELOC_SIGNED_4);
217 EXPECT_EQ(signed4.length, 2);
218 EXPECT_EQ(signed4.isExtern, true);
219 EXPECT_EQ(signed4.symbol, 1U);
270 EXPECT_EQ(lld::MachOLinkingContext::arch_x86, f2->arch);
271 EXPECT_EQ(MH_OBJECT, f2->fileType);
272 EXPECT_EQ(FileFlags(MH_SUBSECTIONS_VIA_SYMBOLS), f2->flags);
276 EXPECT_EQ(2UL, f2->undefinedSymbols.size());
279 EXPECT_EQ(N_UNDF, barUndef.type);
280 EXPECT_EQ(SymbolScope(N_EXT), barUndef.scope);
283 EXPECT_EQ(N_UNDF, tbarUndef.type);
284 EXPECT_EQ(SymbolScope(N_EXT), tbarUndef.scope);
286 EXPECT_EQ(1UL, f2->sections.size());
290 EXPECT_EQ(S_REGULAR, text.type);
291 EXPECT_EQ(text.attributes,SectionAttr(S_ATTR_PURE_INSTRUCTIONS
293 EXPECT_EQ((uint16_t)text.alignment, 16U);
294 EXPECT_EQ(text.address, Hex64(0x0));
295 EXPECT_EQ(22UL, text.content.size());
297 EXPECT_EQ(call.offset, Hex32(0x1));
298 EXPECT_EQ(call.scattered, false);
299 EXPECT_EQ(call.type, GENERIC_RELOC_VANILLA);
300 EXPECT_EQ(call.pcRel, true);
301 EXPECT_EQ(call.length, 2);
302 EXPECT_EQ(call.isExtern, true);
303 EXPECT_EQ(call.symbol, 0U);
305 EXPECT_EQ(absLoad.offset, Hex32(0x6));
306 EXPECT_EQ(absLoad.scattered, false);
307 EXPECT_EQ(absLoad.type, GENERIC_RELOC_VANILLA);
308 EXPECT_EQ(absLoad.pcRel, false);
309 EXPECT_EQ(absLoad.length, 2);
310 EXPECT_EQ(absLoad.isExtern, true);
311 EXPECT_EQ(absLoad.symbol,0U);
313 EXPECT_EQ(pic1.offset, Hex32(0xc));
314 EXPECT_EQ(pic1.scattered, true);
315 EXPECT_EQ(pic1.type, GENERIC_RELOC_LOCAL_SECTDIFF);
316 EXPECT_EQ(pic1.length, 2);
317 EXPECT_EQ(pic1.value, 0U);
319 EXPECT_EQ(pic2.offset, Hex32(0x0));
320 EXPECT_EQ(pic1.scattered, true);
321 EXPECT_EQ(pic2.type, GENERIC_RELOC_PAIR);
322 EXPECT_EQ(pic2.length, 2);
323 EXPECT_EQ(pic2.value, 5U);
325 EXPECT_EQ(tlv.offset, Hex32(0x12));
326 EXPECT_EQ(tlv.type, GENERIC_RELOC_TLV);
327 EXPECT_EQ(tlv.length, 2);
328 EXPECT_EQ(tlv.isExtern, true);
329 EXPECT_EQ(tlv.symbol, 1U);
389 EXPECT_EQ(lld::MachOLinkingContext::arch_armv7, f2->arch);
390 EXPECT_EQ(MH_OBJECT, f2->fileType);
391 EXPECT_EQ(FileFlags(MH_SUBSECTIONS_VIA_SYMBOLS), f2->flags);
394 EXPECT_EQ(2UL, f2->globalSymbols.size());
397 EXPECT_EQ(N_SECT, fooDef.type);
398 EXPECT_EQ(1, fooDef.sect);
399 EXPECT_EQ(SymbolScope(N_EXT), fooDef.scope);
402 EXPECT_EQ(N_SECT, foo2Def.type);
403 EXPECT_EQ(1, foo2Def.sect);
404 EXPECT_EQ(SymbolScope(N_EXT), foo2Def.scope);
406 EXPECT_EQ(1UL, f2->undefinedSymbols.size());
409 EXPECT_EQ(N_UNDF, barUndef.type);
410 EXPECT_EQ(SymbolScope(N_EXT), barUndef.scope);
412 EXPECT_EQ(1UL, f2->sections.size());
416 EXPECT_EQ(S_REGULAR, text.type);
417 EXPECT_EQ(text.attributes,SectionAttr(S_ATTR_PURE_INSTRUCTIONS
419 EXPECT_EQ((uint16_t)text.alignment, 4U);
420 EXPECT_EQ(text.address, Hex64(0x0));
421 EXPECT_EQ(18UL, text.content.size());
423 EXPECT_EQ(blx.offset, Hex32(0x0));
424 EXPECT_EQ(blx.scattered, false);
425 EXPECT_EQ(blx.type, ARM_THUMB_RELOC_BR22);
426 EXPECT_EQ(blx.pcRel, true);
427 EXPECT_EQ(blx.length, 2);
428 EXPECT_EQ(blx.isExtern, true);
429 EXPECT_EQ(blx.symbol, 2U);
431 EXPECT_EQ(movw1.offset, Hex32(0x4));
432 EXPECT_EQ(movw1.scattered, true);
433 EXPECT_EQ(movw1.type, ARM_RELOC_HALF_SECTDIFF);
434 EXPECT_EQ(movw1.length, 2);
435 EXPECT_EQ(movw1.value, 0x10U);
437 EXPECT_EQ(movw2.offset, Hex32(0x0));
438 EXPECT_EQ(movw2.scattered, true);
439 EXPECT_EQ(movw2.type, ARM_RELOC_PAIR);
440 EXPECT_EQ(movw2.length, 2);
441 EXPECT_EQ(movw2.value, Hex32(0xC));
443 EXPECT_EQ(movt1.offset, Hex32(0x8));
444 EXPECT_EQ(movt1.scattered, true);
445 EXPECT_EQ(movt1.type, ARM_RELOC_HALF_SECTDIFF);
446 EXPECT_EQ(movt1.length, 2);
447 EXPECT_EQ(movt1.value, Hex32(0x10));
449 EXPECT_EQ(movt2.offset, Hex32(0x0));
450 EXPECT_EQ(movt2.scattered, true);
451 EXPECT_EQ(movt2.type, ARM_RELOC_PAIR);
452 EXPECT_EQ(movt2.length, 2);
453 EXPECT_EQ(movt2.value, Hex32(0xC));
455 EXPECT_EQ(absPointer.offset, Hex32(0xC));
456 EXPECT_EQ(absPointer.type, ARM_RELOC_VANILLA);
457 EXPECT_EQ(absPointer.length, 2);
458 EXPECT_EQ(absPointer.isExtern, true);
459 EXPECT_EQ(absPointer.symbol, 2U);
546 EXPECT_EQ(lld::MachOLinkingContext::arch_ppc, f2->arch);
547 EXPECT_EQ(MH_OBJECT, f2->fileType);
548 EXPECT_EQ(FileFlags(MH_SUBSECTIONS_VIA_SYMBOLS), f2->flags);
551 EXPECT_EQ(2UL, f2->globalSymbols.size());
554 EXPECT_EQ(N_SECT, fooDef.type);
555 EXPECT_EQ(1, fooDef.sect);
556 EXPECT_EQ(SymbolScope(N_EXT), fooDef.scope);
559 EXPECT_EQ(N_SECT, foo2Def.type);
560 EXPECT_EQ(1, foo2Def.sect);
561 EXPECT_EQ(SymbolScope(N_EXT), foo2Def.scope);
563 EXPECT_EQ(1UL, f2->undefinedSymbols.size());
566 EXPECT_EQ(N_UNDF, barUndef.type);
567 EXPECT_EQ(SymbolScope(N_EXT), barUndef.scope);
569 EXPECT_EQ(1UL, f2->sections.size());
573 EXPECT_EQ(S_REGULAR, text.type);
574 EXPECT_EQ(text.attributes,SectionAttr(S_ATTR_PURE_INSTRUCTIONS
576 EXPECT_EQ((uint16_t)text.alignment, 4U);
577 EXPECT_EQ(text.address, Hex64(0x0));
578 EXPECT_EQ(44UL, text.content.size());
580 EXPECT_EQ(br24.offset, Hex32(0x0));
581 EXPECT_EQ(br24.scattered, false);
582 EXPECT_EQ(br24.type, PPC_RELOC_BR24);
583 EXPECT_EQ(br24.pcRel, true);
584 EXPECT_EQ(br24.length, 2);
585 EXPECT_EQ(br24.isExtern, true);
586 EXPECT_EQ(br24.symbol, 2U);
588 EXPECT_EQ(br14.offset, Hex32(0x4));
589 EXPECT_EQ(br14.scattered, false);
590 EXPECT_EQ(br14.type, PPC_RELOC_BR14);
591 EXPECT_EQ(br14.pcRel, true);
592 EXPECT_EQ(br14.length, 2);
593 EXPECT_EQ(br14.isExtern, true);
594 EXPECT_EQ(br14.symbol, 2U);
596 EXPECT_EQ(pichi1.offset, Hex32(0x8));
597 EXPECT_EQ(pichi1.scattered, true);
598 EXPECT_EQ(pichi1.type, PPC_RELOC_HI16_SECTDIFF);
599 EXPECT_EQ(pichi1.length, 2);
600 EXPECT_EQ(pichi1.value, 0x28U);
602 EXPECT_EQ(pichi2.offset, Hex32(0x24));
603 EXPECT_EQ(pichi2.scattered, true);
604 EXPECT_EQ(pichi2.type, PPC_RELOC_PAIR);
605 EXPECT_EQ(pichi2.length, 2);
606 EXPECT_EQ(pichi2.value, 0x4U);
608 EXPECT_EQ(picha1.offset, Hex32(0xC));
609 EXPECT_EQ(picha1.scattered, true);
610 EXPECT_EQ(picha1.type, PPC_RELOC_HA16_SECTDIFF);
611 EXPECT_EQ(picha1.length, 2);
612 EXPECT_EQ(picha1.value, 0x28U);
614 EXPECT_EQ(picha2.offset, Hex32(0x24));
615 EXPECT_EQ(picha2.scattered, true);
616 EXPECT_EQ(picha2.type, PPC_RELOC_PAIR);
617 EXPECT_EQ(picha2.length, 2);
618 EXPECT_EQ(picha2.value, 0x4U);
620 EXPECT_EQ(piclo1.offset, Hex32(0x10));
621 EXPECT_EQ(piclo1.scattered, true);
622 EXPECT_EQ(piclo1.type, PPC_RELOC_LO16_SECTDIFF);
623 EXPECT_EQ(piclo1.length, 2);
624 EXPECT_EQ(piclo1.value, 0x28U);
626 EXPECT_EQ(piclo2.offset, Hex32(0x0));
627 EXPECT_EQ(piclo2.scattered, true);
628 EXPECT_EQ(piclo2.type, PPC_RELOC_PAIR);
629 EXPECT_EQ(piclo2.length, 2);
630 EXPECT_EQ(piclo2.value, 0x4U);
632 EXPECT_EQ(picloa1.offset, Hex32(0x14));
633 EXPECT_EQ(picloa1.scattered, true);
634 EXPECT_EQ(picloa1.type, PPC_RELOC_LO14_SECTDIFF);
635 EXPECT_EQ(picloa1.length, 2);
636 EXPECT_EQ(picloa1.value, 0x28U);
638 EXPECT_EQ(picloa2.offset, Hex32(0x0));
639 EXPECT_EQ(picloa2.scattered, true);
640 EXPECT_EQ(picloa2.type, PPC_RELOC_PAIR);
641 EXPECT_EQ(picloa2.length, 2);
642 EXPECT_EQ(picloa2.value, 0x4U);
644 EXPECT_EQ(abshi1.offset, Hex32(0x18));
645 EXPECT_EQ(abshi1.scattered, false);
646 EXPECT_EQ(abshi1.type, PPC_RELOC_HI16);
647 EXPECT_EQ(abshi1.length, 2);
648 EXPECT_EQ(abshi1.symbol, 1U);
650 EXPECT_EQ(abshi2.offset, Hex32(0x28));
651 EXPECT_EQ(abshi2.scattered, false);
652 EXPECT_EQ(abshi2.type, PPC_RELOC_PAIR);
653 EXPECT_EQ(abshi2.length, 2);
654 EXPECT_EQ(abshi2.symbol, 0U);
656 EXPECT_EQ(absha1.offset, Hex32(0x1C));
657 EXPECT_EQ(absha1.scattered, false);
658 EXPECT_EQ(absha1.type, PPC_RELOC_HA16);
659 EXPECT_EQ(absha1.length, 2);
660 EXPECT_EQ(absha1.symbol, 1U);
662 EXPECT_EQ(absha2.offset, Hex32(0x28));
663 EXPECT_EQ(absha2.scattered, false);
664 EXPECT_EQ(absha2.type, PPC_RELOC_PAIR);
665 EXPECT_EQ(absha2.length, 2);
666 EXPECT_EQ(absha2.symbol, 0U);
668 EXPECT_EQ(abslo1.offset, Hex32(0x20));
669 EXPECT_EQ(abslo1.scattered, false);
670 EXPECT_EQ(abslo1.type, PPC_RELOC_LO16);
671 EXPECT_EQ(abslo1.length, 2);
672 EXPECT_EQ(abslo1.symbol, 1U);
674 EXPECT_EQ(abslo2.offset, Hex32(0x00));
675 EXPECT_EQ(abslo2.scattered, false);
676 EXPECT_EQ(abslo2.type, PPC_RELOC_PAIR);
677 EXPECT_EQ(abslo2.length, 2);
678 EXPECT_EQ(abslo2.symbol, 0U);
680 EXPECT_EQ(absloa1.offset, Hex32(0x24));
681 EXPECT_EQ(absloa1.scattered, false);
682 EXPECT_EQ(absloa1.type, PPC_RELOC_LO14);
683 EXPECT_EQ(absloa1.length, 2);
684 EXPECT_EQ(absloa1.symbol, 1U);
686 EXPECT_EQ(absloa2.offset, Hex32(0x00));
687 EXPECT_EQ(absloa2.scattered, false);
688 EXPECT_EQ(absloa2.type, PPC_RELOC_PAIR);
689 EXPECT_EQ(absloa2.length, 2);
690 EXPECT_EQ(absloa2.symbol, 0U);
tools/lld/unittests/MachOTests/MachONormalizedFileToAtomsTests.cpp 32 EXPECT_EQ(0U, (*atom_f)->defined().size());
73 EXPECT_EQ(3U, file.defined().size());
82 EXPECT_EQ(2U, atom1->rawContent().size());
83 EXPECT_EQ(0x90, atom1->rawContent()[0]);
84 EXPECT_EQ(0xC3, atom1->rawContent()[1]);
85 EXPECT_EQ(lld::Atom::scopeGlobal, atom1->scope());
88 EXPECT_EQ(1U, atom2->rawContent().size());
89 EXPECT_EQ(0xC3, atom2->rawContent()[0]);
90 EXPECT_EQ(lld::Atom::scopeGlobal, atom2->scope());
93 EXPECT_EQ(1U, atom3->rawContent().size());
94 EXPECT_EQ(0xC4, atom3->rawContent()[0]);
95 EXPECT_EQ(lld::Atom::scopeLinkageUnit, atom3->scope());
98 EXPECT_EQ(lld::Atom::definitionUndefined, atom4->definition());
tools/lld/unittests/MachOTests/MachONormalizedFileYAMLTests.cpp 51 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_ppc);
52 EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
53 EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
67 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86_64);
68 EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
69 EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
83 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86);
84 EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
85 EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
99 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_armv6);
100 EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
101 EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
115 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_armv7);
116 EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
117 EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
131 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_armv7s);
132 EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
133 EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
152 EXPECT_EQ(f2->arch, lld::MachOLinkingContext::arch_x86_64);
153 EXPECT_EQ((int)(f2->fileType), llvm::MachO::MH_OBJECT);
154 EXPECT_EQ((int)(f2->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
175 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86_64);
176 EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
180 EXPECT_EQ(f->globalSymbols.size(), 1UL);
183 EXPECT_EQ((int)(sym.type), llvm::MachO::N_SECT);
184 EXPECT_EQ((int)(sym.scope), llvm::MachO::N_EXT);
185 EXPECT_EQ(sym.sect, 1);
186 EXPECT_EQ((int)(sym.desc), 0);
187 EXPECT_EQ((uint64_t)sym.value, 0x100ULL);
204 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86_64);
205 EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
209 EXPECT_EQ(f->sections.size(), 1UL);
213 EXPECT_EQ((uint32_t)(sect.type), (uint32_t)(llvm::MachO::S_REGULAR));
214 EXPECT_EQ((uint32_t)(sect.attributes),
216 EXPECT_EQ((uint16_t)sect.alignment, 2U);
217 EXPECT_EQ((uint64_t)sect.address, 0x12345678ULL);
218 EXPECT_EQ(sect.content.size(), 2UL);
219 EXPECT_EQ((int)(sect.content[0]), 0x90);
220 EXPECT_EQ((int)(sect.content[1]), 0x90);
276 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86_64);
277 EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
278 EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
279 EXPECT_EQ(f->sections.size(), 2UL);
284 EXPECT_EQ((uint32_t)(sect1.type), (uint32_t)(llvm::MachO::S_REGULAR));
285 EXPECT_EQ((uint32_t)(sect1.attributes),
288 EXPECT_EQ((uint16_t)sect1.alignment, 1U);
289 EXPECT_EQ((uint64_t)sect1.address, 0x0ULL);
290 EXPECT_EQ(sect1.content.size(), 22UL);
291 EXPECT_EQ((int)(sect1.content[0]), 0x55);
292 EXPECT_EQ((int)(sect1.content[1]), 0x48);
293 EXPECT_EQ(sect1.relocations.size(), 2UL);
295 EXPECT_EQ(reloc1.offset, 0x0eU);
297 EXPECT_EQ((int)reloc1.type, (int)llvm::MachO::X86_64_RELOC_BRANCH);
298 EXPECT_EQ(reloc1.length, 2);
301 EXPECT_EQ(reloc1.symbol, 2U);
302 EXPECT_EQ((int)(reloc1.value), 0);
304 EXPECT_EQ(reloc2.offset, 0x07U);
306 EXPECT_EQ((int)reloc2.type, (int)llvm::MachO::X86_64_RELOC_SIGNED);
307 EXPECT_EQ(reloc2.length, 2);
310 EXPECT_EQ(reloc2.symbol, 1U);
311 EXPECT_EQ((int)(reloc2.value), 0);
316 EXPECT_EQ((uint32_t)(sect2.type), (uint32_t)(llvm::MachO::S_CSTRING_LITERALS));
317 EXPECT_EQ((uint32_t)(sect2.attributes), 0U);
318 EXPECT_EQ((uint16_t)sect2.alignment, 1U);
319 EXPECT_EQ((uint64_t)sect2.address, 0x016ULL);
320 EXPECT_EQ(sect2.content.size(), 7UL);
321 EXPECT_EQ((int)(sect2.content[0]), 0x68);
322 EXPECT_EQ((int)(sect2.content[1]), 0x65);
323 EXPECT_EQ((int)(sect2.content[2]), 0x6c);
325 EXPECT_EQ(f->globalSymbols.size(), 1UL);
328 EXPECT_EQ((int)(sym1.type), llvm::MachO::N_SECT);
329 EXPECT_EQ((int)(sym1.scope), llvm::MachO::N_EXT);
330 EXPECT_EQ(sym1.sect, 1);
331 EXPECT_EQ((int)(sym1.desc), 0);
332 EXPECT_EQ((uint64_t)sym1.value, 0x0ULL);
333 EXPECT_EQ(f->localSymbols.size(), 1UL);
336 EXPECT_EQ((int)(sym2.type), llvm::MachO::N_SECT);
337 EXPECT_EQ((int)(sym2.scope), 0);
338 EXPECT_EQ(sym2.sect, 2);
339 EXPECT_EQ((int)(sym2.desc), 0);
340 EXPECT_EQ((uint64_t)sym2.value, 0x16ULL);
341 EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
344 EXPECT_EQ((int)(sym3.type), llvm::MachO::N_UNDF);
345 EXPECT_EQ((int)(sym3.scope), 0);
346 EXPECT_EQ(sym3.sect, 0);
347 EXPECT_EQ((int)(sym3.desc), 0);
348 EXPECT_EQ((uint64_t)sym3.value, 0x0ULL);
406 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86);
407 EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
408 EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
409 EXPECT_EQ(f->sections.size(), 2UL);
414 EXPECT_EQ((uint32_t)(sect1.type), (uint32_t)(llvm::MachO::S_REGULAR));
415 EXPECT_EQ((uint32_t)(sect1.attributes),
418 EXPECT_EQ((uint16_t)sect1.alignment, 1U);
419 EXPECT_EQ((uint64_t)sect1.address, 0x0ULL);
420 EXPECT_EQ(sect1.content.size(), 33UL);
421 EXPECT_EQ((int)(sect1.content[0]), 0x55);
422 EXPECT_EQ((int)(sect1.content[1]), 0x89);
423 EXPECT_EQ(sect1.relocations.size(), 3UL);
425 EXPECT_EQ(reloc1.offset, 0x16U);
427 EXPECT_EQ((int)reloc1.type, (int)llvm::MachO::GENERIC_RELOC_VANILLA);
428 EXPECT_EQ(reloc1.length, 2);
431 EXPECT_EQ(reloc1.symbol, 1U);
432 EXPECT_EQ((int)(reloc1.value), 0);
434 EXPECT_EQ(reloc2.offset, 0x0eU);
436 EXPECT_EQ((int)reloc2.type, (int)llvm::MachO::GENERIC_RELOC_LOCAL_SECTDIFF);
437 EXPECT_EQ(reloc2.length, 2);
439 EXPECT_EQ(reloc2.symbol, 0U);
440 EXPECT_EQ((int)(reloc2.value), 0x21);
442 EXPECT_EQ(reloc3.offset, 0U);
444 EXPECT_EQ((int)reloc3.type, (int)llvm::MachO::GENERIC_RELOC_PAIR);
445 EXPECT_EQ(reloc3.length, 2);
447 EXPECT_EQ(reloc3.symbol, 0U);
448 EXPECT_EQ((int)(reloc3.value), 0xb);
453 EXPECT_EQ((uint32_t)(sect2.type), (uint32_t)(llvm::MachO::S_CSTRING_LITERALS));
454 EXPECT_EQ((uint32_t)(sect2.attributes), 0U);
455 EXPECT_EQ((uint16_t)sect2.alignment, 1U);
456 EXPECT_EQ((uint64_t)sect2.address, 0x021ULL);
457 EXPECT_EQ(sect2.content.size(), 7UL);
458 EXPECT_EQ((int)(sect2.content[0]), 0x68);
459 EXPECT_EQ((int)(sect2.content[1]), 0x65);
460 EXPECT_EQ((int)(sect2.content[2]), 0x6c);
462 EXPECT_EQ(f->globalSymbols.size(), 1UL);
465 EXPECT_EQ((int)(sym1.type), llvm::MachO::N_SECT);
466 EXPECT_EQ((int)(sym1.scope), llvm::MachO::N_EXT);
467 EXPECT_EQ(sym1.sect, 1);
468 EXPECT_EQ((int)(sym1.desc), 0);
469 EXPECT_EQ((uint64_t)sym1.value, 0x0ULL);
470 EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
473 EXPECT_EQ((int)(sym2.type), llvm::MachO::N_UNDF);
474 EXPECT_EQ((int)(sym2.scope), 0);
475 EXPECT_EQ(sym2.sect, 0);
476 EXPECT_EQ((int)(sym2.desc), 0);
477 EXPECT_EQ((uint64_t)sym2.value, 0x0ULL);
534 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_armv6);
535 EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
536 EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
537 EXPECT_EQ(f->sections.size(), 2UL);
542 EXPECT_EQ((uint32_t)(sect1.type), (uint32_t)(llvm::MachO::S_REGULAR));
543 EXPECT_EQ((uint32_t)(sect1.attributes),
546 EXPECT_EQ((uint16_t)sect1.alignment, 4U);
547 EXPECT_EQ((uint64_t)sect1.address, 0x0ULL);
548 EXPECT_EQ(sect1.content.size(), 32UL);
549 EXPECT_EQ((int)(sect1.content[0]), 0x80);
550 EXPECT_EQ((int)(sect1.content[1]), 0x40);
551 EXPECT_EQ(sect1.relocations.size(), 3UL);
553 EXPECT_EQ(reloc1.offset, 0x1cU);
555 EXPECT_EQ((int)reloc1.type, (int)llvm::MachO::ARM_RELOC_SECTDIFF);
556 EXPECT_EQ(reloc1.length, 2);
558 EXPECT_EQ(reloc1.symbol, 0U);
559 EXPECT_EQ((int)(reloc1.value), 0x20);
561 EXPECT_EQ(reloc2.offset, 0x0U);
563 EXPECT_EQ((int)reloc2.type, (int)llvm::MachO::ARM_RELOC_PAIR);
564 EXPECT_EQ(reloc2.length, 2);
566 EXPECT_EQ(reloc2.symbol, 0U);
567 EXPECT_EQ((int)(reloc2.value), 0xc);
569 EXPECT_EQ(reloc3.offset, 0x10U);
571 EXPECT_EQ((int)reloc3.type, (int)llvm::MachO::ARM_RELOC_BR24);
572 EXPECT_EQ(reloc3.length, 2);
575 EXPECT_EQ(reloc3.symbol, 1U);
576 EXPECT_EQ((int)(reloc3.value), 0);
581 EXPECT_EQ((uint32_t)(sect2.type), (uint32_t)(llvm::MachO::S_CSTRING_LITERALS));
582 EXPECT_EQ((uint32_t)(sect2.attributes), 0U);
583 EXPECT_EQ((uint16_t)sect2.alignment, 1U);
584 EXPECT_EQ((uint64_t)sect2.address, 0x020ULL);
585 EXPECT_EQ(sect2.content.size(), 7UL);
586 EXPECT_EQ((int)(sect2.content[0]), 0x68);
587 EXPECT_EQ((int)(sect2.content[1]), 0x65);
588 EXPECT_EQ((int)(sect2.content[2]), 0x6c);
590 EXPECT_EQ(f->globalSymbols.size(), 1UL);
593 EXPECT_EQ((int)(sym1.type), llvm::MachO::N_SECT);
594 EXPECT_EQ((int)(sym1.scope), llvm::MachO::N_EXT);
595 EXPECT_EQ(sym1.sect, 1);
596 EXPECT_EQ((int)(sym1.desc), 0);
597 EXPECT_EQ((uint64_t)sym1.value, 0x0ULL);
598 EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
601 EXPECT_EQ((int)(sym2.type), llvm::MachO::N_UNDF);
602 EXPECT_EQ((int)(sym2.scope), 0);
603 EXPECT_EQ(sym2.sect, 0);
604 EXPECT_EQ((int)(sym2.desc), 0);
605 EXPECT_EQ((uint64_t)sym2.value, 0x0ULL);
674 EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_armv7);
675 EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
676 EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
677 EXPECT_EQ(f->sections.size(), 2UL);
682 EXPECT_EQ((uint32_t)(sect1.type), (uint32_t)(llvm::MachO::S_REGULAR));
683 EXPECT_EQ((uint32_t)(sect1.attributes),
686 EXPECT_EQ((uint16_t)sect1.alignment, 2U);
687 EXPECT_EQ((uint64_t)sect1.address, 0x0ULL);
688 EXPECT_EQ(sect1.content.size(), 22UL);
689 EXPECT_EQ((int)(sect1.content[0]), 0x80);
690 EXPECT_EQ((int)(sect1.content[1]), 0xb5);
691 EXPECT_EQ(sect1.relocations.size(), 5UL);
693 EXPECT_EQ(reloc1.offset, 0x0eU);
695 EXPECT_EQ((int)reloc1.type, (int)llvm::MachO::ARM_THUMB_RELOC_BR22);
696 EXPECT_EQ(reloc1.length, 2);
699 EXPECT_EQ(reloc1.symbol, 1U);
700 EXPECT_EQ((int)(reloc1.value), 0);
702 EXPECT_EQ(reloc2.offset, 0x8U);
704 EXPECT_EQ((int)reloc2.type, (int)llvm::MachO::ARM_RELOC_HALF_SECTDIFF);
705 EXPECT_EQ(reloc2.length, 3);
707 EXPECT_EQ(reloc2.symbol, 0U);
708 EXPECT_EQ((int)(reloc2.value), 0x16);
710 EXPECT_EQ(reloc3.offset, 0x6U);
712 EXPECT_EQ((int)reloc3.type, (int)llvm::MachO::ARM_RELOC_PAIR);
713 EXPECT_EQ(reloc3.length, 3);
715 EXPECT_EQ(reloc3.symbol, 0U);
716 EXPECT_EQ((int)(reloc3.value), 0xc);
718 EXPECT_EQ(reloc4.offset, 0x2U);
720 EXPECT_EQ((int)reloc4.type, (int)llvm::MachO::ARM_RELOC_HALF_SECTDIFF);
721 EXPECT_EQ(reloc4.length, 2);
723 EXPECT_EQ(reloc4.symbol, 0U);
724 EXPECT_EQ((int)(reloc4.value), 0x16);
726 EXPECT_EQ(reloc5.offset, 0x0U);
728 EXPECT_EQ((int)reloc5.type, (int)llvm::MachO::ARM_RELOC_PAIR);
729 EXPECT_EQ(reloc5.length, 2);
731 EXPECT_EQ(reloc5.symbol, 0U);
732 EXPECT_EQ((int)(reloc5.value), 0xc);
737 EXPECT_EQ((uint32_t)(sect2.type), (uint32_t)(llvm::MachO::S_CSTRING_LITERALS));
738 EXPECT_EQ((uint32_t)(sect2.attributes), 0U);
739 EXPECT_EQ((uint16_t)sect2.alignment, 1U);
740 EXPECT_EQ((uint64_t)sect2.address, 0x016ULL);
741 EXPECT_EQ(sect2.content.size(), 7UL);
742 EXPECT_EQ((int)(sect2.content[0]), 0x68);
743 EXPECT_EQ((int)(sect2.content[1]), 0x65);
744 EXPECT_EQ((int)(sect2.content[2]), 0x6c);
746 EXPECT_EQ(f->globalSymbols.size(), 1UL);
749 EXPECT_EQ((int)(sym1.type), llvm::MachO::N_SECT);
750 EXPECT_EQ((int)(sym1.scope), llvm::MachO::N_EXT);
751 EXPECT_EQ(sym1.sect, 1);
752 EXPECT_EQ((int)(sym1.desc), (int)(llvm::MachO::N_ARM_THUMB_DEF));
753 EXPECT_EQ((uint64_t)sym1.value, 0x0ULL);
754 EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
757 EXPECT_EQ((int)(sym2.type), llvm::MachO::N_UNDF);
758 EXPECT_EQ((int)(sym2.scope), 0);
759 EXPECT_EQ(sym2.sect, 0);
760 EXPECT_EQ((int)(sym2.desc), 0);
761 EXPECT_EQ((uint64_t)sym2.value, 0x0ULL);
tools/lldb/unittests/Core/MangledTest.cpp 171 EXPECT_EQ(1, Count("main", eFunctionNameTypeFull));
172 EXPECT_EQ(1, Count("main", eFunctionNameTypeBase));
173 EXPECT_EQ(0, Count("main", eFunctionNameTypeMethod));
176 EXPECT_EQ(1, Count("_Z3foov", eFunctionNameTypeFull));
177 EXPECT_EQ(1, Count("_Z3foov", eFunctionNameTypeBase));
178 EXPECT_EQ(1, Count("foo", eFunctionNameTypeBase));
179 EXPECT_EQ(0, Count("foo", eFunctionNameTypeMethod));
182 EXPECT_EQ(1, Count("puts@GLIBC_2.5", eFunctionNameTypeFull));
183 EXPECT_EQ(1, Count("puts@GLIBC_2.6", eFunctionNameTypeFull));
184 EXPECT_EQ(2, Count("puts", eFunctionNameTypeFull));
185 EXPECT_EQ(2, Count("puts", eFunctionNameTypeBase));
186 EXPECT_EQ(0, Count("puts", eFunctionNameTypeMethod));
189 EXPECT_EQ(1, Count("_Z5annotv@VERSION3", eFunctionNameTypeFull));
190 EXPECT_EQ(1, Count("_Z5annotv", eFunctionNameTypeFull));
191 EXPECT_EQ(1, Count("_Z5annotv", eFunctionNameTypeBase));
192 EXPECT_EQ(0, Count("annot", eFunctionNameTypeBase));
193 EXPECT_EQ(0, Count("annot", eFunctionNameTypeMethod));
196 EXPECT_EQ(1, Count("_ZN1AC2Ev", eFunctionNameTypeFull));
197 EXPECT_EQ(1, Count("_ZN1AC2Ev", eFunctionNameTypeBase));
198 EXPECT_EQ(1, Count("A", eFunctionNameTypeMethod));
199 EXPECT_EQ(0, Count("A", eFunctionNameTypeBase));
202 EXPECT_EQ(1, Count("_ZN1AD2Ev", eFunctionNameTypeFull));
203 EXPECT_EQ(1, Count("_ZN1AD2Ev", eFunctionNameTypeBase));
204 EXPECT_EQ(1, Count("~A", eFunctionNameTypeMethod));
205 EXPECT_EQ(0, Count("~A", eFunctionNameTypeBase));
208 EXPECT_EQ(1, Count("_ZN1A3barEv", eFunctionNameTypeFull));
209 EXPECT_EQ(1, Count("_ZN1A3barEv", eFunctionNameTypeBase));
210 EXPECT_EQ(1, Count("bar", eFunctionNameTypeMethod));
211 EXPECT_EQ(0, Count("bar", eFunctionNameTypeBase));
214 EXPECT_EQ(1, Count("_ZGVZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeFull));
215 EXPECT_EQ(1, Count("_ZGVZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeBase));
216 EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeMethod));
217 EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeBase));
218 EXPECT_EQ(1, Count("_ZZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeFull));
219 EXPECT_EQ(1, Count("_ZZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeBase));
220 EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeMethod));
221 EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeBase));
222 EXPECT_EQ(1, Count("_ZTVN5clang4DeclE", eFunctionNameTypeFull));
223 EXPECT_EQ(1, Count("_ZTVN5clang4DeclE", eFunctionNameTypeBase));
224 EXPECT_EQ(0, Count("Decl", eFunctionNameTypeMethod));
225 EXPECT_EQ(0, Count("Decl", eFunctionNameTypeBase));
228 EXPECT_EQ(1, Count("-[ObjCfoo]", eFunctionNameTypeFull));
229 EXPECT_EQ(1, Count("-[ObjCfoo]", eFunctionNameTypeBase));
230 EXPECT_EQ(0, Count("ObjCfoo", eFunctionNameTypeMethod));
233 EXPECT_EQ(1, Count("+[B ObjCbar(WithCategory)]", eFunctionNameTypeFull));
234 EXPECT_EQ(1, Count("+[B ObjCbar(WithCategory)]", eFunctionNameTypeBase));
235 EXPECT_EQ(0, Count("ObjCbar", eFunctionNameTypeMethod));
238 EXPECT_EQ(1, Count("_Z12undemangableEvx42", eFunctionNameTypeFull));
239 EXPECT_EQ(1, Count("_Z12undemangableEvx42", eFunctionNameTypeBase));
240 EXPECT_EQ(0, Count("_Z12undemangableEvx42", eFunctionNameTypeMethod));
241 EXPECT_EQ(0, Count("undemangable", eFunctionNameTypeBase));
242 EXPECT_EQ(0, Count("undemangable", eFunctionNameTypeMethod));
tools/lldb/unittests/Core/RichManglingContextTest.cpp 27 EXPECT_EQ("foo", RMC.GetBufferRef());
30 EXPECT_EQ("bar", RMC.GetBufferRef());
33 EXPECT_EQ("foo::bar()", RMC.GetBufferRef());
91 EXPECT_EQ("foo::bar()", RMC.GetBufferRef());
95 EXPECT_EQ("foo::bar()", RMC.GetBufferRef());
99 EXPECT_EQ("foo::bar()", RMC.GetBufferRef());
tools/lldb/unittests/Core/StreamCallbackTest.cpp 19 EXPECT_EQ(&test_baton, baton);
26 EXPECT_EQ(1u, callback_count);
tools/lldb/unittests/Disassembler/TestArm64Disassembly.cpp 67 EXPECT_EQ (num_of_instructions, inst_list.GetSize());
tools/lldb/unittests/Disassembler/TestArmv7Disassembly.cpp 75 EXPECT_EQ (num_of_instructions, inst_list.GetSize());
tools/lldb/unittests/Editline/EditlineTest.cpp 45 EXPECT_EQ(0, close_result);
156 EXPECT_EQ(eoln_length * sizeof(char), size_t(input_bytes_written));
290 EXPECT_EQ(input_text, el_reported_line);
tools/lldb/unittests/Expression/ClangParserTest.cpp 50 EXPECT_EQ(ComputeClangResourceDir(path_to_liblldb), path_to_clang_dir);
tools/lldb/unittests/Expression/DiagnosticManagerTest.cpp 40 EXPECT_EQ(0U, mgr.Diagnostics().size());
48 EXPECT_EQ(1U, mgr.Diagnostics().size());
50 EXPECT_EQ(DiagnosticOrigin::eDiagnosticOriginLLDB, got->getKind());
51 EXPECT_EQ(msg, got->GetMessage());
52 EXPECT_EQ(severity, got->GetSeverity());
53 EXPECT_EQ(custom_diag_id, got->GetCompilerID());
54 EXPECT_EQ(false, got->HasFixIts());
77 EXPECT_EQ("", mgr.GetString());
84 EXPECT_EQ("error: abc\n", mgr.GetString());
93 EXPECT_EQ("error: b\nc\n", mgr.GetString());
100 EXPECT_EQ("error: abc\n", mgr.GetString());
103 EXPECT_EQ("error: abc\nerror: def\n", mgr.GetString());
117 EXPECT_EQ("error: foo\nwarning: bar\nbaz\n", mgr.GetString());
130 EXPECT_EQ("baz\nwarning: bar\nerror: foo\n", mgr.GetString());
138 EXPECT_EQ(0U, mgr.Diagnostics().size());
151 EXPECT_EQ("error: foo\nerror: bar\nmessage text\n", mgr.GetString());
164 EXPECT_EQ("error: bar\nmessage text\nerror: foo\n", mgr.GetString());
171 EXPECT_EQ(1U, mgr.Diagnostics().size());
172 EXPECT_EQ(eDiagnosticOriginLLDB, mgr.Diagnostics().front()->getKind());
173 EXPECT_EQ("error: foo\n", mgr.GetString());
182 EXPECT_EQ(2U, mgr.Diagnostics().size());
183 EXPECT_EQ("error: foo\nerror: bar\n", mgr.GetString());
193 EXPECT_EQ(2U, mgr.Diagnostics().size());
194 EXPECT_EQ("error: foo\nwarning: bar\n", mgr.GetString());
201 EXPECT_EQ("", mgr.GetFixedExpression());
205 EXPECT_EQ("foo", mgr.GetFixedExpression());
209 EXPECT_EQ("bar", mgr.GetFixedExpression());
tools/lldb/unittests/Host/ConnectionFileDescriptorTest.cpp 43 EXPECT_EQ(ip, hostname);
44 EXPECT_EQ(socket->GetRemotePortNumber(), port);
tools/lldb/unittests/Host/FileActionTest.cpp 17 EXPECT_EQ(Action.GetAction(), FileAction::eFileActionOpen);
18 EXPECT_EQ(Action.GetFileSpec(), FileSpec("/tmp"));
tools/lldb/unittests/Host/FileSystemTest.cpp 171 EXPECT_EQ(system_clock::time_point(), fs.GetModificationTime(fs1));
206 EXPECT_EQ((uint64_t)1024, fs.GetByteSize("/foo"));
207 EXPECT_EQ((uint64_t)1024,
214 EXPECT_EQ(sys::fs::all_all, fs.GetPermissions("/foo"));
215 EXPECT_EQ(sys::fs::all_all,
234 EXPECT_EQ(FileSpec("/foo"), file_spec);
251 EXPECT_EQ(FileSpec("/foo"), file_spec);
264 EXPECT_EQ(FileSpec("bogus"), file_spec);
302 EXPECT_EQ(code.category(), std::system_category());
303 EXPECT_EQ(code.value(), ENOENT);
tools/lldb/unittests/Host/FileTest.cpp 35 EXPECT_EQ(file.GetWaitableHandle(), fd);
55 EXPECT_EQ(file.GetDescriptor(), fd);
56 EXPECT_EQ(file.GetWaitableHandle(), fd);
tools/lldb/unittests/Host/HostInfoTest.cpp 35 EXPECT_EQ(spec.GetTriple().getTriple(), "x86_64-pc-linux-gnu");
39 EXPECT_EQ(spec.GetTriple().getTriple(), "x86_64-pc");
44 EXPECT_EQ(spec.GetTriple().getArch(), Triple::x86_64);
45 EXPECT_EQ(spec.GetTriple().getOS(), triple.getOS());
46 EXPECT_EQ(spec.GetTriple().getVendor(), triple.getVendor());
47 EXPECT_EQ(spec.GetTriple().getEnvironment(), triple.getEnvironment());
50 EXPECT_EQ(HostInfo::GetAugmentedArchSpec(LLDB_ARCH_DEFAULT).GetTriple(),
tools/lldb/unittests/Host/HostTest.cpp 16 EXPECT_EQ("W01", formatv("{0:g}", WaitStatus{WaitStatus::Exit, 1}).str());
17 EXPECT_EQ("X02", formatv("{0:g}", WaitStatus{WaitStatus::Signal, 2}).str());
18 EXPECT_EQ("S03", formatv("{0:g}", WaitStatus{WaitStatus::Stop, 3}).str());
19 EXPECT_EQ("Exited with status 4",
tools/lldb/unittests/Host/NativeProcessProtocolTest.cpp 114 EXPECT_EQ(bytes_read, 6UL);
130 EXPECT_EQ(bytes_read, 3UL);
148 EXPECT_EQ(bytes_read, 6UL);
tools/lldb/unittests/Host/ProcessLaunchInfoTest.cpp 19 EXPECT_EQ(FileSpec("/stdin"),
21 EXPECT_EQ(FileSpec("/stdout"),
23 EXPECT_EQ(FileSpec("/stderr"),
25 EXPECT_EQ(FileSpec("/wd"), Info.GetWorkingDirectory());
26 EXPECT_EQ(eLaunchFlagStopAtEntry, Info.GetFlags().Get());
tools/lldb/unittests/Host/SocketAddressTest.cpp 48 EXPECT_EQ(AF_INET, addr[0].GetFamily());
49 EXPECT_EQ("127.0.0.1", addr[0].GetIPAddress());
tools/lldb/unittests/Host/SocketTest.cpp 33 EXPECT_EQ(1138, port);
58 EXPECT_EQ(12345, port);
65 EXPECT_EQ(0, port);
72 EXPECT_EQ(65535, port);
79 EXPECT_EQ(12345, port);
86 EXPECT_EQ(12345, port);
122 EXPECT_EQ(socket_a_up->GetLocalPortNumber(),
124 EXPECT_EQ(socket_b_up->GetLocalPortNumber(),
171 EXPECT_EQ(scheme, "connect");
172 EXPECT_EQ(port, socket_a_up->GetRemotePortNumber());
191 EXPECT_EQ(scheme, "udp");
216 EXPECT_EQ(scheme, "unix-connect");
217 EXPECT_EQ(path, domain_path);
tools/lldb/unittests/Host/linux/HostTest.cpp 38 EXPECT_EQ(lldb::pid_t(getpid()), Info.GetProcessID());
41 EXPECT_EQ(lldb::pid_t(getppid()), Info.GetParentProcessID());
44 EXPECT_EQ(geteuid(), Info.GetEffectiveUserID());
47 EXPECT_EQ(getegid(), Info.GetEffectiveGroupID());
50 EXPECT_EQ(geteuid(), Info.GetUserID());
53 EXPECT_EQ(getegid(), Info.GetGroupID());
56 EXPECT_EQ(HostInfo::GetArchitecture(HostInfo::eArchKindDefault),
tools/lldb/unittests/Interpreter/TestOptionArgParser.cpp 71 EXPECT_EQ('A', OptionArgParser::ToChar("A", 'B', nullptr));
72 EXPECT_EQ('B', OptionArgParser::ToChar("B", 'A', nullptr));
74 EXPECT_EQ('A', OptionArgParser::ToChar("A", 'B', &success));
76 EXPECT_EQ('B', OptionArgParser::ToChar("B", 'A', &success));
79 EXPECT_EQ('A', OptionArgParser::ToChar("", 'A', &success));
81 EXPECT_EQ('A', OptionArgParser::ToChar("ABC", 'A', &success));
88 EXPECT_EQ(lldb::eScriptLanguageDefault,
92 EXPECT_EQ(lldb::eScriptLanguagePython,
95 EXPECT_EQ(lldb::eScriptLanguageNone,
99 EXPECT_EQ(lldb::eScriptLanguageDefault,
104 EXPECT_EQ(lldb::eScriptLanguagePython,
109 EXPECT_EQ(lldb::eScriptLanguageNone,
115 EXPECT_EQ(lldb::eScriptLanguagePython,
tools/lldb/unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp 115 EXPECT_EQ(test.context, method.GetContext().str());
116 EXPECT_EQ(test.basename, method.GetBasename().str());
117 EXPECT_EQ(test.arguments, method.GetArguments().str());
118 EXPECT_EQ(test.qualifiers, method.GetQualifiers().str());
119 EXPECT_EQ(test.scope_qualified_name, method.GetScopeQualifiedName());
154 EXPECT_EQ(test.context, context.str());
155 EXPECT_EQ(test.basename, basename.str());
178 EXPECT_EQ(Count, Results.size());
tools/lldb/unittests/Language/Highlighting/HighlighterTest.cpp 55 EXPECT_EQ(getName(lldb::eLanguageTypeC_plus_plus), "clang");
56 EXPECT_EQ(getName(lldb::eLanguageTypeC_plus_plus_03), "clang");
57 EXPECT_EQ(getName(lldb::eLanguageTypeC_plus_plus_11), "clang");
58 EXPECT_EQ(getName(lldb::eLanguageTypeC_plus_plus_14), "clang");
59 EXPECT_EQ(getName(lldb::eLanguageTypeObjC), "clang");
60 EXPECT_EQ(getName(lldb::eLanguageTypeObjC_plus_plus), "clang");
62 EXPECT_EQ(getName(lldb::eLanguageTypeUnknown), "none");
63 EXPECT_EQ(getName(lldb::eLanguageTypeJulia), "none");
64 EXPECT_EQ(getName(lldb::eLanguageTypeHaskell), "none");
68 EXPECT_EQ(getName("myfile.cc"), "clang");
69 EXPECT_EQ(getName("moo.cpp"), "clang");
70 EXPECT_EQ(getName("mar.cxx"), "clang");
71 EXPECT_EQ(getName("foo.C"), "clang");
72 EXPECT_EQ(getName("bar.CC"), "clang");
73 EXPECT_EQ(getName("a/dir.CC"), "clang");
74 EXPECT_EQ(getName("/a/dir.hpp"), "clang");
75 EXPECT_EQ(getName("header.h"), "clang");
77 EXPECT_EQ(getName(""), "none");
78 EXPECT_EQ(getName("/dev/null"), "none");
79 EXPECT_EQ(getName("Factory.java"), "none");
80 EXPECT_EQ(getName("poll.py"), "none");
81 EXPECT_EQ(getName("reducer.hs"), "none");
110 EXPECT_EQ(code, highlightDefault(code, style));
116 EXPECT_EQ("<c>a</c> bc", highlightDefault("a bc", style, 0));
117 EXPECT_EQ("a<c> </c>bc", highlightDefault("a bc", style, 1));
118 EXPECT_EQ("a <c>b</c>c", highlightDefault("a bc", style, 2));
119 EXPECT_EQ("a b<c>c</c>", highlightDefault("a bc", style, 3));
125 EXPECT_EQ("a bc", highlightDefault("a bc", style, 4));
139 EXPECT_EQ("", highlightC("", s));
146 EXPECT_EQ(" int i = <scalar>22</scalar>;", highlightC(" int i = 22;", s));
153 EXPECT_EQ("const char *f = 22 + <str>\"foo\"</str>;",
161 EXPECT_EQ(" f = \"", highlightC(" f = \"", s));
168 EXPECT_EQ(" <k>return</k> 1; ", highlightC(" return 1; ", s));
175 EXPECT_EQ("foo<c>:</c><c>:</c>bar<c>:</c>", highlightC("foo::bar:", s));
182 EXPECT_EQ("a<b>{</b><b>}</b>", highlightC("a{}", s));
189 EXPECT_EQ("a<sb>[</sb><sb>]</sb>", highlightC("a[]", s));
196 EXPECT_EQ(" bool f = foo()<comma>,</comma> 1;",
204 EXPECT_EQ("<pp>#</pp><pp>include</pp><pp> </pp><pp>\"foo\"</pp><pp> </pp>//c",
212 EXPECT_EQ(" <cc>/*com */</cc> <cc>// com /*n*/</cc>",
220 EXPECT_EQ(" 1[+]2[/]a[*]f[&]x[|][~]l", highlightC(" 1+2/a*f&x|~l", s));
227 EXPECT_EQ(" <id>foo</id> <id>c</id> = <id>bar</id>(); return 1;",
235 EXPECT_EQ("<c> </c>foo c = bar(); return 1;",
237 EXPECT_EQ(" <c>foo</c> c = bar(); return 1;",
239 EXPECT_EQ(" <c>foo</c> c = bar(); return 1;",
241 EXPECT_EQ(" <c>foo</c> c = bar(); return 1;",
243 EXPECT_EQ(" foo<c> </c>c = bar(); return 1;",
245 EXPECT_EQ(" foo <c>c</c> = bar(); return 1;",
253 EXPECT_EQ("f", highlightC("f", s, 1));
259 EXPECT_EQ("f", highlightC("f", s, 2));
260 EXPECT_EQ("f", highlightC("f", s, 3));
261 EXPECT_EQ("f", highlightC("f", s, 4));
269 EXPECT_EQ("<c> </c><id>foo</id> <id>c</id> = <id>bar</id>(); return 1;",
278 EXPECT_EQ(" <id>foo</id><c> </c><id>c</id> = <id>bar</id>(); return 1;",
287 EXPECT_EQ(" <id><c>foo</c></id> <id>c</id> = <id>bar</id>(); return 1;",
289 EXPECT_EQ(" <id><c>foo</c></id> <id>c</id> = <id>bar</id>(); return 1;",
291 EXPECT_EQ(" <id><c>foo</c></id> <id>c</id> = <id>bar</id>(); return 1;",
tools/lldb/unittests/ObjectFile/Breakpad/BreakpadRecordsTest.cpp 17 EXPECT_EQ(Record::Module, Record::classify("MODULE"));
18 EXPECT_EQ(Record::Info, Record::classify("INFO"));
19 EXPECT_EQ(Record::File, Record::classify("FILE"));
20 EXPECT_EQ(Record::Func, Record::classify("FUNC"));
21 EXPECT_EQ(Record::Public, Record::classify("PUBLIC"));
22 EXPECT_EQ(Record::StackCFI, Record::classify("STACK CFI"));
23 EXPECT_EQ(Record::StackWin, Record::classify("STACK WIN"));
26 EXPECT_EQ(llvm::None, Record::classify("STACK"));
27 EXPECT_EQ(llvm::None, Record::classify("STACK CODE_ID"));
28 EXPECT_EQ(llvm::None, Record::classify("CODE_ID"));
32 EXPECT_EQ(Record::Line, Record::classify("deadbeef"));
33 EXPECT_EQ(Record::Line, Record::classify("12"));
37 EXPECT_EQ(ModuleRecord(llvm::Triple::Linux, llvm::Triple::x86_64,
42 EXPECT_EQ(llvm::None, ModuleRecord::parse("MODULE"));
43 EXPECT_EQ(llvm::None, ModuleRecord::parse("MODULE Linux"));
44 EXPECT_EQ(llvm::None, ModuleRecord::parse("MODULE Linux x86_64"));
45 EXPECT_EQ(llvm::None,
50 EXPECT_EQ(InfoRecord(UUID::fromData("@ABCDEFGHIJKLMNO", 16)),
52 EXPECT_EQ(InfoRecord(UUID()), InfoRecord::parse("INFO CODE_ID 47 a.exe"));
54 EXPECT_EQ(llvm::None, InfoRecord::parse("INFO"));
55 EXPECT_EQ(llvm::None, InfoRecord::parse("INFO CODE_ID"));
59 EXPECT_EQ(FileRecord(47, "foo"), FileRecord::parse("FILE 47 foo"));
60 EXPECT_EQ(llvm::None, FileRecord::parse("FILE 47"));
61 EXPECT_EQ(llvm::None, FileRecord::parse("FILE"));
62 EXPECT_EQ(llvm::None, FileRecord::parse(""));
66 EXPECT_EQ(FuncRecord(true, 0x47, 0x7, 0x8, "foo"),
68 EXPECT_EQ(FuncRecord(false, 0x47, 0x7, 0x8, "foo"),
71 EXPECT_EQ(llvm::None, FuncRecord::parse("PUBLIC 47 7 8 foo"));
72 EXPECT_EQ(llvm::None, FuncRecord::parse("FUNC 47 7 8"));
73 EXPECT_EQ(llvm::None, FuncRecord::parse("FUNC 47 7"));
74 EXPECT_EQ(llvm::None, FuncRecord::parse("FUNC 47"));
75 EXPECT_EQ(llvm::None, FuncRecord::parse("FUNC m"));
76 EXPECT_EQ(llvm::None, FuncRecord::parse("FUNC"));
80 EXPECT_EQ(LineRecord(0x47, 0x74, 47, 74), LineRecord::parse("47 74 47 74"));
81 EXPECT_EQ(llvm::None, LineRecord::parse("47 74 47"));
82 EXPECT_EQ(llvm::None, LineRecord::parse("47 74"));
83 EXPECT_EQ(llvm::None, LineRecord::parse("47"));
84 EXPECT_EQ(llvm::None, LineRecord::parse(""));
85 EXPECT_EQ(llvm::None, LineRecord::parse("FUNC"));
89 EXPECT_EQ(PublicRecord(true, 0x47, 0x8, "foo"),
91 EXPECT_EQ(PublicRecord(false, 0x47, 0x8, "foo"),
94 EXPECT_EQ(llvm::None, PublicRecord::parse("FUNC 47 8 foo"));
95 EXPECT_EQ(llvm::None, PublicRecord::parse("PUBLIC 47 8"));
96 EXPECT_EQ(llvm::None, PublicRecord::parse("PUBLIC 47"));
97 EXPECT_EQ(llvm::None, PublicRecord::parse("PUBLIC m"));
98 EXPECT_EQ(llvm::None, PublicRecord::parse("PUBLIC"));
102 EXPECT_EQ(StackCFIRecord(0x47, 0x8, ".cfa: $esp 4 + $eip: .cfa 4 - ^"),
106 EXPECT_EQ(StackCFIRecord(0x47, 0x8, ".cfa: $esp 4 +"),
109 EXPECT_EQ(StackCFIRecord(0x47, llvm::None, ".cfa: $esp 4 +"),
113 EXPECT_EQ(StackCFIRecord(0x47, 0x8, ".cfa: ^ ^ ^"),
116 EXPECT_EQ(llvm::None, StackCFIRecord::parse("STACK CFI INIT 47"));
117 EXPECT_EQ(llvm::None, StackCFIRecord::parse("STACK CFI INIT"));
118 EXPECT_EQ(llvm::None, StackCFIRecord::parse("STACK CFI"));
119 EXPECT_EQ(llvm::None, StackCFIRecord::parse("STACK"));
120 EXPECT_EQ(llvm::None, StackCFIRecord::parse("FILE 47 foo"));
121 EXPECT_EQ(llvm::None, StackCFIRecord::parse("42 47"));
125 EXPECT_EQ(
129 EXPECT_EQ(llvm::None, StackWinRecord::parse(
131 EXPECT_EQ(llvm::None,
133 EXPECT_EQ(llvm::None, StackWinRecord::parse(
135 EXPECT_EQ(llvm::None,
137 EXPECT_EQ(llvm::None, StackWinRecord::parse(
139 EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8 1 0 0 0 0 0"));
140 EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8 1 0 0 0 0"));
141 EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8 1 0 0 0"));
142 EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8 1 0 0"));
143 EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8 1 0"));
144 EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8 1"));
145 EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8"));
146 EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47"));
147 EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4"));
148 EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN"));
149 EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK"));
150 EXPECT_EQ(llvm::None, StackWinRecord::parse(""));
151 EXPECT_EQ(llvm::None, StackCFIRecord::parse("FILE 47 foo"));
152 EXPECT_EQ(llvm::None, StackCFIRecord::parse("42 47"));
tools/lldb/unittests/ObjectFile/ELF/TestObjectFileELF.cpp 124 EXPECT_EQ(bss_sp, X->GetAddress().GetSection());
129 EXPECT_EQ(data_sp, Y->GetAddress().GetSection());
134 EXPECT_EQ(text_sp, start->GetAddress().GetSection());
173 EXPECT_EQ(Spec.GetUUID(), Uuid);
tools/lldb/unittests/ObjectFile/PECOFF/TestPECallFrameInfo.cpp 219 EXPECT_EQ(plan.GetRowCount(), 7);
226 EXPECT_EQ(*plan.GetRowAtIndex(0), row);
231 EXPECT_EQ(*plan.GetRowAtIndex(1), row);
236 EXPECT_EQ(*plan.GetRowAtIndex(2), row);
241 EXPECT_EQ(*plan.GetRowAtIndex(3), row);
246 EXPECT_EQ(*plan.GetRowAtIndex(4), row);
251 EXPECT_EQ(*plan.GetRowAtIndex(5), row);
255 EXPECT_EQ(*plan.GetRowAtIndex(6), row);
261 EXPECT_EQ(plan.GetRowCount(), 2);
273 EXPECT_EQ(*plan.GetRowAtIndex(0), row);
277 EXPECT_EQ(*plan.GetRowAtIndex(1), row);
283 EXPECT_EQ(plan.GetRowCount(), 11);
290 EXPECT_EQ(*plan.GetRowAtIndex(0), row);
295 EXPECT_EQ(*plan.GetRowAtIndex(1), row);
300 EXPECT_EQ(*plan.GetRowAtIndex(2), row);
305 EXPECT_EQ(*plan.GetRowAtIndex(3), row);
310 EXPECT_EQ(*plan.GetRowAtIndex(4), row);
315 EXPECT_EQ(*plan.GetRowAtIndex(5), row);
319 EXPECT_EQ(*plan.GetRowAtIndex(6), row);
323 EXPECT_EQ(*plan.GetRowAtIndex(7), row);
327 EXPECT_EQ(*plan.GetRowAtIndex(8), row);
331 EXPECT_EQ(*plan.GetRowAtIndex(9), row);
335 EXPECT_EQ(*plan.GetRowAtIndex(10), row);
tools/lldb/unittests/Platform/PlatformDarwinTest.cpp 32 EXPECT_EQ(llvm::VersionTuple(1, 2, 3), V);
33 EXPECT_EQ("test1", D);
36 EXPECT_EQ(llvm::VersionTuple(2, 3), V);
37 EXPECT_EQ("test2", D);
40 EXPECT_EQ(llvm::VersionTuple(3), V);
41 EXPECT_EQ("test3", D);
44 EXPECT_EQ(llvm::VersionTuple(1, 2, 3), V);
45 EXPECT_EQ("test", D);
48 EXPECT_EQ(llvm::VersionTuple(2, 3, 4), V);
49 EXPECT_EQ("", D);
52 EXPECT_EQ(llvm::VersionTuple(3, 4, 5), V);
tools/lldb/unittests/Process/gdb-remote/GDBRemoteClientBaseTest.cpp 289 EXPECT_EQ("ABCD", delegate.output);
290 EXPECT_EQ("profile", delegate.misc_data);
291 EXPECT_EQ(1u, delegate.stop_reply_called);
tools/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp 150 EXPECT_EQ(1u, save_id);
195 EXPECT_EQ("/foo/bar.so", result.getValue()[0].GetFileSpec().GetPath());
196 EXPECT_EQ(triple, result.getValue()[0].GetArchitecture().GetTriple());
197 EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNO", 16),
199 EXPECT_EQ(0u, result.getValue()[0].GetObjectOffset());
200 EXPECT_EQ(1234u, result.getValue()[0].GetObjectSize());
220 EXPECT_EQ("/foo/bar.so", result.getValue()[0].GetFileSpec().GetPath());
221 EXPECT_EQ(triple, result.getValue()[0].GetArchitecture().GetTriple());
222 EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNOPQRS", 20),
224 EXPECT_EQ(0u, result.getValue()[0].GetObjectOffset());
225 EXPECT_EQ(1234u, result.getValue()[0].GetObjectSize());
340 EXPECT_EQ(addr, region_info.GetRange().GetRangeBase());
341 EXPECT_EQ(0x2000u, region_info.GetRange().GetByteSize());
342 EXPECT_EQ(MemoryRegionInfo::eYes, region_info.GetReadable());
343 EXPECT_EQ(MemoryRegionInfo::eNo, region_info.GetWritable());
344 EXPECT_EQ(MemoryRegionInfo::eYes, region_info.GetExecutable());
345 EXPECT_EQ("/foo/bar.so", region_info.GetName().GetStringRef());
tools/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationServerTest.cpp 69 EXPECT_EQ(server.GetPackets().size(), 1UL);
tools/lldb/unittests/Process/minidump/MinidumpParserTest.cpp 116 EXPECT_EQ(0x3e81u, thread.ThreadId);
119 EXPECT_EQ(7u, context.size());
154 EXPECT_EQ(nullptr, parser->GetMiscInfo());
246 EXPECT_EQ(2u, modules.size());
265 EXPECT_EQ(range_start, range->start);
266 EXPECT_EQ(range_start + range_size, range->start + range->range_ref.size());
282 EXPECT_EQ(llvm::None, parser->FindMemoryRange(0x00));
283 EXPECT_EQ(llvm::None, parser->FindMemoryRange(0x2a));
284 EXPECT_EQ((minidump::Range{0x401d46, llvm::ArrayRef<uint8_t>{0x54, 0x21}}),
286 EXPECT_EQ(llvm::None, parser->FindMemoryRange(0x401d46 + 2));
288 EXPECT_EQ(
292 EXPECT_EQ(llvm::None, parser->FindMemoryRange(0x7ffceb34a000 + 5));
309 EXPECT_EQ((llvm::ArrayRef<uint8_t>{0x54}), parser->GetMemory(0x401d46, 1));
310 EXPECT_EQ((llvm::ArrayRef<uint8_t>{0x54, 0x21}),
313 EXPECT_EQ((llvm::ArrayRef<uint8_t>{0xc8, 0x4d, 0x04, 0xbc, 0xe9}),
315 EXPECT_EQ((llvm::ArrayRef<uint8_t>{0xc8, 0x4d, 0x04}),
318 EXPECT_EQ(llvm::ArrayRef<uint8_t>(), parser->GetMemory(0x500000, 512));
515 EXPECT_EQ(llvm::None, parser->GetLinuxProcStatus());
566 EXPECT_EQ(MinidumpContext_x86_32_Flags(uint32_t(context->context_flags)),
571 EXPECT_EQ(0x00000000u, context->eax);
572 EXPECT_EQ(0xf7778000u, context->ebx);
573 EXPECT_EQ(0x00000001u, context->ecx);
574 EXPECT_EQ(0xff9dd4a3u, context->edx);
575 EXPECT_EQ(0x080482a8u, context->edi);
576 EXPECT_EQ(0xff9dd55cu, context->esi);
577 EXPECT_EQ(0xff9dd53cu, context->ebp);
578 EXPECT_EQ(0xff9dd52cu, context->esp);
579 EXPECT_EQ(0x080482a0u, context->eip);
580 EXPECT_EQ(0x00010282u, context->eflags);
581 EXPECT_EQ(0x0023u, context->cs);
582 EXPECT_EQ(0x0000u, context->fs);
583 EXPECT_EQ(0x0063u, context->gs);
584 EXPECT_EQ(0x002bu, context->ss);
585 EXPECT_EQ(0x002bu, context->ds);
586 EXPECT_EQ(0x002bu, context->es);
609 EXPECT_EQ(MinidumpContext_x86_64_Flags(uint32_t(context->context_flags)),
614 EXPECT_EQ(0x0000000000000000u, context->rax);
615 EXPECT_EQ(0x0000000000000000u, context->rbx);
616 EXPECT_EQ(0x0000000000000010u, context->rcx);
617 EXPECT_EQ(0x0000000000000000u, context->rdx);
618 EXPECT_EQ(0x00007ffceb349cf0u, context->rdi);
619 EXPECT_EQ(0x0000000000000000u, context->rsi);
620 EXPECT_EQ(0x00007ffceb34a210u, context->rbp);
621 EXPECT_EQ(0x00007ffceb34a210u, context->rsp);
622 EXPECT_EQ(0x00007fe9bc1aa9c0u, context->r8);
623 EXPECT_EQ(0x0000000000000000u, context->r9);
624 EXPECT_EQ(0x00007fe9bc3f16a0u, context->r10);
625 EXPECT_EQ(0x0000000000000246u, context->r11);
626 EXPECT_EQ(0x0000000000401c92u, context->r12);
627 EXPECT_EQ(0x00007ffceb34a430u, context->r13);
628 EXPECT_EQ(0x0000000000000000u, context->r14);
629 EXPECT_EQ(0x0000000000000000u, context->r15);
630 EXPECT_EQ(0x0000000000401dc6u, context->rip);
631 EXPECT_EQ(0x00010206u, context->eflags);
632 EXPECT_EQ(0x0033u, context->cs);
633 EXPECT_EQ(0x0000u, context->ss);
644 EXPECT_EQ(MinidumpContext_x86_32_Flags(uint32_t(context->context_flags)),
650 EXPECT_EQ(0x00000000u, context->eax);
651 EXPECT_EQ(0x0037f608u, context->ebx);
652 EXPECT_EQ(0x00e61578u, context->ecx);
653 EXPECT_EQ(0x00000008u, context->edx);
654 EXPECT_EQ(0x00000000u, context->edi);
655 EXPECT_EQ(0x00000002u, context->esi);
656 EXPECT_EQ(0x0037f654u, context->ebp);
657 EXPECT_EQ(0x0037f5b8u, context->esp);
658 EXPECT_EQ(0x77ce01fdu, context->eip);
659 EXPECT_EQ(0x00000246u, context->eflags);
660 EXPECT_EQ(0x0023u, context->cs);
661 EXPECT_EQ(0x0053u, context->fs);
662 EXPECT_EQ(0x002bu, context->gs);
663 EXPECT_EQ(0x002bu, context->ss);
664 EXPECT_EQ(0x002bu, context->ds);
665 EXPECT_EQ(0x002bu, context->es);
690 EXPECT_EQ(0x0000000000001000u, filtered_modules[0]->BaseOfImage);
716 EXPECT_EQ(0x0000000000002000u, filtered_modules[0]->BaseOfImage);
720 EXPECT_EQ(0x0000000000001000u, filtered_modules[1]->BaseOfImage);
tools/lldb/unittests/Process/minidump/RegisterContextMinidumpTest.cpp 64 EXPECT_EQ(Context.eax, reg32(*Buf, Info[lldb_eax_i386]));
65 EXPECT_EQ(Context.ebx, reg32(*Buf, Info[lldb_ebx_i386]));
66 EXPECT_EQ(Context.ecx, reg32(*Buf, Info[lldb_ecx_i386]));
67 EXPECT_EQ(Context.edx, reg32(*Buf, Info[lldb_edx_i386]));
68 EXPECT_EQ(Context.edi, reg32(*Buf, Info[lldb_edi_i386]));
69 EXPECT_EQ(Context.esi, reg32(*Buf, Info[lldb_esi_i386]));
70 EXPECT_EQ(Context.ebp, reg32(*Buf, Info[lldb_ebp_i386]));
71 EXPECT_EQ(Context.esp, reg32(*Buf, Info[lldb_esp_i386]));
72 EXPECT_EQ(Context.eip, reg32(*Buf, Info[lldb_eip_i386]));
73 EXPECT_EQ(Context.eflags, reg32(*Buf, Info[lldb_eflags_i386]));
74 EXPECT_EQ(Context.cs, reg32(*Buf, Info[lldb_cs_i386]));
75 EXPECT_EQ(Context.fs, reg32(*Buf, Info[lldb_fs_i386]));
76 EXPECT_EQ(Context.gs, reg32(*Buf, Info[lldb_gs_i386]));
77 EXPECT_EQ(Context.ss, reg32(*Buf, Info[lldb_ss_i386]));
78 EXPECT_EQ(Context.ds, reg32(*Buf, Info[lldb_ds_i386]));
79 EXPECT_EQ(Context.es, reg32(*Buf, Info[lldb_es_i386]));
123 EXPECT_EQ(Context.rax, reg64(*Buf, Info[lldb_rax_x86_64]));
124 EXPECT_EQ(Context.rbx, reg64(*Buf, Info[lldb_rbx_x86_64]));
125 EXPECT_EQ(Context.rcx, reg64(*Buf, Info[lldb_rcx_x86_64]));
126 EXPECT_EQ(Context.rdx, reg64(*Buf, Info[lldb_rdx_x86_64]));
127 EXPECT_EQ(Context.rdi, reg64(*Buf, Info[lldb_rdi_x86_64]));
128 EXPECT_EQ(Context.rsi, reg64(*Buf, Info[lldb_rsi_x86_64]));
129 EXPECT_EQ(Context.rbp, reg64(*Buf, Info[lldb_rbp_x86_64]));
130 EXPECT_EQ(Context.rsp, reg64(*Buf, Info[lldb_rsp_x86_64]));
131 EXPECT_EQ(Context.r8, reg64(*Buf, Info[lldb_r8_x86_64]));
132 EXPECT_EQ(Context.r9, reg64(*Buf, Info[lldb_r9_x86_64]));
133 EXPECT_EQ(Context.r10, reg64(*Buf, Info[lldb_r10_x86_64]));
134 EXPECT_EQ(Context.r11, reg64(*Buf, Info[lldb_r11_x86_64]));
135 EXPECT_EQ(Context.r12, reg64(*Buf, Info[lldb_r12_x86_64]));
136 EXPECT_EQ(Context.r13, reg64(*Buf, Info[lldb_r13_x86_64]));
137 EXPECT_EQ(Context.r14, reg64(*Buf, Info[lldb_r14_x86_64]));
138 EXPECT_EQ(Context.r15, reg64(*Buf, Info[lldb_r15_x86_64]));
139 EXPECT_EQ(Context.rip, reg64(*Buf, Info[lldb_rip_x86_64]));
140 EXPECT_EQ(Context.eflags, reg64(*Buf, Info[lldb_rflags_x86_64]));
141 EXPECT_EQ(Context.cs, reg64(*Buf, Info[lldb_cs_x86_64]));
142 EXPECT_EQ(Context.fs, reg64(*Buf, Info[lldb_fs_x86_64]));
143 EXPECT_EQ(Context.gs, reg64(*Buf, Info[lldb_gs_x86_64]));
144 EXPECT_EQ(Context.ss, reg64(*Buf, Info[lldb_ss_x86_64]));
145 EXPECT_EQ(Context.ds, reg64(*Buf, Info[lldb_ds_x86_64]));
146 EXPECT_EQ(Context.es, reg64(*Buf, Info[lldb_es_x86_64]));
161 EXPECT_EQ(info->kinds[lldb::eRegisterKindGeneric],
164 EXPECT_EQ(info->kinds[lldb::eRegisterKindGeneric],
167 EXPECT_EQ(info->kinds[lldb::eRegisterKindGeneric],
170 EXPECT_EQ(info->kinds[lldb::eRegisterKindGeneric],
173 EXPECT_EQ(info->kinds[lldb::eRegisterKindGeneric],
176 EXPECT_EQ(info->kinds[lldb::eRegisterKindGeneric],
179 EXPECT_EQ(info->kinds[lldb::eRegisterKindGeneric],
182 EXPECT_EQ(info->kinds[lldb::eRegisterKindGeneric],
185 EXPECT_EQ(info->kinds[lldb::eRegisterKindGeneric],
tools/lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp 59 EXPECT_EQ(original_refcnt, owned_long.get()->ob_refcnt);
63 EXPECT_EQ(original_refcnt + 1, strong_ref.get()->ob_refcnt);
67 EXPECT_EQ(original_refcnt, strong_ref.get()->ob_refcnt);
75 EXPECT_EQ(new_dict, dict.get());
80 EXPECT_EQ(nullptr, dict.get());
89 EXPECT_EQ(original_refcnt + 1, borrowed_long.get()->ob_refcnt);
94 EXPECT_EQ(m_sys_module.get(), sys_module.get());
131 EXPECT_EQ(PY_MAJOR_VERSION, major_version_value.GetInteger());
132 EXPECT_EQ(PY_MINOR_VERSION, minor_version_value.GetInteger());
148 EXPECT_EQ(PY_MAJOR_VERSION, version_major.GetInteger());
149 EXPECT_EQ(PY_MINOR_VERSION, version_minor.GetInteger());
164 EXPECT_EQ(PY_MAJOR_VERSION, version_major.GetInteger());
165 EXPECT_EQ(PY_MINOR_VERSION, version_minor.GetInteger());
178 EXPECT_EQ(PyObjectType::Integer, python_int.GetObjectType());
179 EXPECT_EQ(12, python_int.GetInteger());
186 EXPECT_EQ(PyObjectType::Integer, python_long.GetObjectType());
190 EXPECT_EQ(40, python_long.GetInteger());
195 EXPECT_EQ(7, constructed_int.GetInteger());
202 EXPECT_EQ(PyObjectType::Boolean, python_true.GetObjectType());
207 EXPECT_EQ(PyObjectType::Boolean, python_false.GetObjectType());
213 EXPECT_EQ(PyObjectType::Boolean, python_boolean.GetObjectType());
214 EXPECT_EQ(bool(value), python_boolean.GetValue());
231 EXPECT_EQ(PyObjectType::String, python_bytes.GetObjectType());
238 EXPECT_EQ(bytes.size(), strlen(test_bytes));
239 EXPECT_EQ(0, ::memcmp(bytes.data(), test_bytes, bytes.size()));
249 EXPECT_EQ(PyObjectType::ByteArray, python_bytes.GetObjectType());
252 EXPECT_EQ(after_bytes.size(), orig_bytes.size());
253 EXPECT_EQ(0, ::memcmp(orig_bytes.data(), test_bytes, orig_bytes.size()));
269 EXPECT_EQ(PyObjectType::String, python_string.GetObjectType());
283 EXPECT_EQ(test_string2, constructed_string.GetString());
290 EXPECT_EQ(GetString, str.GetString());
293 EXPECT_EQ(GetString, str_str.GetString());
301 EXPECT_EQ(7U, int_sp->GetValue());
309 EXPECT_EQ(test_string, string_sp->GetStringValue());
330 EXPECT_EQ(list_size, list.GetSize());
331 EXPECT_EQ(PyObjectType::List, list.GetObjectType());
342 EXPECT_EQ(long_value0, chk_int.GetInteger());
343 EXPECT_EQ(string_value1, chk_str.GetString());
359 EXPECT_EQ(2U, list.GetSize());
370 EXPECT_EQ(long_value0, chk_int.GetInteger());
371 EXPECT_EQ(string_value1, chk_str.GetString());
383 EXPECT_EQ(lldb::eStructuredDataTypeInteger,
385 EXPECT_EQ(lldb::eStructuredDataTypeString,
391 EXPECT_EQ(long_value0, long(int_sp->GetValue()));
392 EXPECT_EQ(string_value1, string_sp->GetValue());
397 EXPECT_EQ(0U, tuple.GetSize());
400 EXPECT_EQ(3U, tuple.GetSize());
414 EXPECT_EQ(tuple.GetItemAtIndex(0).get(), int_value.get());
415 EXPECT_EQ(tuple.GetItemAtIndex(1).get(), string_value.get());
416 EXPECT_EQ(tuple.GetItemAtIndex(2).get(), none_value.get());
424 EXPECT_EQ(3U, tuple.GetSize());
426 EXPECT_EQ(tuple.GetItemAtIndex(0).get(), int_value.get());
427 EXPECT_EQ(tuple.GetItemAtIndex(1).get(), string_value.get());
428 EXPECT_EQ(tuple.GetItemAtIndex(2).get(), none_value.get());
437 EXPECT_EQ(3U, tuple.GetSize());
439 EXPECT_EQ(tuple.GetItemAtIndex(0).get(), int_value.get());
440 EXPECT_EQ(tuple.GetItemAtIndex(1).get(), string_value.get());
441 EXPECT_EQ(tuple.GetItemAtIndex(2).get(), none_value.get());
451 EXPECT_EQ(tuple.GetSize(), array_sp->GetSize());
452 EXPECT_EQ(lldb::eStructuredDataTypeInteger,
454 EXPECT_EQ(lldb::eStructuredDataTypeString,
481 EXPECT_EQ(dict.GetSize(), dict_entries);
482 EXPECT_EQ(PyObjectType::Dictionary, dict.GetObjectType());
493 EXPECT_EQ(value_0, chk_int.GetInteger());
494 EXPECT_EQ(value_1, chk_str.GetString());
519 EXPECT_EQ(dict_entries, dict.GetSize());
530 EXPECT_EQ(value_0, chk_int.GetInteger());
531 EXPECT_EQ(value_1, chk_str.GetString());
546 EXPECT_EQ(2U, dict_sp->GetSize());
554 EXPECT_EQ(string_value0, string_sp->GetValue());
555 EXPECT_EQ(int_value1, long(int_sp->GetValue()));
577 EXPECT_EQ(3U, list_result.GetSize());
578 EXPECT_EQ(one.get(), list_result.GetItemAtIndex(0).get());
579 EXPECT_EQ(two.get(), list_result.GetItemAtIndex(1).get());
580 EXPECT_EQ(three.get(), list_result.GetItemAtIndex(2).get());
600 EXPECT_EQ(42, numerator_attr.GetInteger());
643 EXPECT_EQ(arginfo.get().count, 1);
644 EXPECT_EQ(arginfo.get().max_positional_args, 1u);
645 EXPECT_EQ(arginfo.get().has_varargs, false);
655 EXPECT_EQ(arginfo.get().count, 2);
656 EXPECT_EQ(arginfo.get().max_positional_args, 2u);
657 EXPECT_EQ(arginfo.get().has_varargs, false);
667 EXPECT_EQ(arginfo.get().count, 2);
668 EXPECT_EQ(arginfo.get().max_positional_args, 2u);
669 EXPECT_EQ(arginfo.get().has_varargs, false);
679 EXPECT_EQ(arginfo.get().count, 2);
680 EXPECT_EQ(arginfo.get().max_positional_args,
682 EXPECT_EQ(arginfo.get().has_varargs, true);
692 EXPECT_EQ(arginfo.get().count, 2);
693 EXPECT_EQ(arginfo.get().max_positional_args,
695 EXPECT_EQ(arginfo.get().has_varargs, true);
726 EXPECT_EQ(arginfo.get().count, 2); // FIXME, wrong
727 EXPECT_EQ(arginfo.get().max_positional_args, 1u);
728 EXPECT_EQ(arginfo.get().has_varargs, false);
734 EXPECT_EQ(arginfo.get().count, 2);
735 EXPECT_EQ(arginfo.get().max_positional_args, 2u);
736 EXPECT_EQ(arginfo.get().has_varargs, false);
742 EXPECT_EQ(arginfo.get().max_positional_args, 1u);
743 EXPECT_EQ(arginfo.get().has_varargs, false);
749 EXPECT_EQ(arginfo.get().max_positional_args, 1u);
750 EXPECT_EQ(arginfo.get().has_varargs, false);
756 EXPECT_EQ(arginfo.get().max_positional_args, 1u);
757 EXPECT_EQ(arginfo.get().has_varargs, false);
840 EXPECT_EQ(x.get(), 42l);
846 EXPECT_EQ(y.get(), 42l);
tools/lldb/unittests/Signals/UnixSignalsTest.cpp 48 EXPECT_EQ(4, signals.GetNumSignals());
49 EXPECT_EQ(2, signals.GetFirstSignalNumber());
50 EXPECT_EQ(4, signals.GetNextSignalNumber(2));
51 EXPECT_EQ(8, signals.GetNextSignalNumber(4));
52 EXPECT_EQ(16, signals.GetNextSignalNumber(8));
53 EXPECT_EQ(LLDB_INVALID_SIGNAL_NUMBER, signals.GetNextSignalNumber(16));
63 EXPECT_EQ("SIG4", name);
64 EXPECT_EQ(true, should_suppress);
65 EXPECT_EQ(false, should_stop);
66 EXPECT_EQ(true, should_notify);
68 EXPECT_EQ(true, signals.GetShouldSuppress(signo));
69 EXPECT_EQ(false, signals.GetShouldStop(signo));
70 EXPECT_EQ(true, signals.GetShouldNotify(signo));
71 EXPECT_EQ(name, signals.GetSignalAsCString(signo));
80 EXPECT_EQ(true, signals.GetShouldSuppress(signo));
81 EXPECT_EQ(true, signals.GetShouldStop(signo));
82 EXPECT_EQ(true, signals.GetShouldNotify(signo));
84 EXPECT_EQ(signals.GetVersion(), ver);
98 EXPECT_EQ(false, signals.GetShouldSuppress(signo));
99 EXPECT_EQ(true, signals.GetShouldStop(signo));
100 EXPECT_EQ(false, signals.GetShouldNotify(signo));
102 EXPECT_EQ(ver, signals.GetVersion());
tools/lldb/unittests/Symbol/PostfixExpressionTest.cpp 81 EXPECT_EQ("int(47)", ParseOneAndStringify("47"));
82 EXPECT_EQ("$foo", ParseOneAndStringify("$foo"));
83 EXPECT_EQ("+(int(1), int(2))", ParseOneAndStringify("1 2 +"));
84 EXPECT_EQ("-(int(1), int(2))", ParseOneAndStringify("1 2 -"));
85 EXPECT_EQ("@(int(1), int(2))", ParseOneAndStringify("1 2 @"));
86 EXPECT_EQ("+(int(1), +(int(2), int(3)))", ParseOneAndStringify("1 2 3 + +"));
87 EXPECT_EQ("+(+(int(1), int(2)), int(3))", ParseOneAndStringify("1 2 + 3 +"));
88 EXPECT_EQ("^(int(1))", ParseOneAndStringify("1 ^"));
89 EXPECT_EQ("^(^(int(1)))", ParseOneAndStringify("1 ^ ^"));
90 EXPECT_EQ("^(+(int(1), ^(int(2))))", ParseOneAndStringify("1 2 ^ + ^"));
91 EXPECT_EQ("-($foo, int(47))", ParseOneAndStringify("$foo 47 -"));
92 EXPECT_EQ("+(int(47), int(-42))", ParseOneAndStringify("47 -42 +"));
94 EXPECT_EQ("nullptr", ParseOneAndStringify("+"));
95 EXPECT_EQ("nullptr", ParseOneAndStringify("^"));
96 EXPECT_EQ("nullptr", ParseOneAndStringify("1 +"));
97 EXPECT_EQ("nullptr", ParseOneAndStringify("1 2 ^"));
98 EXPECT_EQ("nullptr", ParseOneAndStringify("1 2 3 +"));
99 EXPECT_EQ("nullptr", ParseOneAndStringify("^ 1"));
100 EXPECT_EQ("nullptr", ParseOneAndStringify("+ 1 2"));
101 EXPECT_EQ("nullptr", ParseOneAndStringify("1 + 2"));
102 EXPECT_EQ("nullptr", ParseOneAndStringify("1 2"));
103 EXPECT_EQ("nullptr", ParseOneAndStringify(""));
168 EXPECT_EQ("DW_OP_consts +0", ParseAndGenerateDWARF("0"));
170 EXPECT_EQ("DW_OP_breg1 +0", ParseAndGenerateDWARF("R1"));
172 EXPECT_EQ("DW_OP_bregx 65 0", ParseAndGenerateDWARF("R65"));
174 EXPECT_EQ("DW_OP_pick 0x00", ParseAndGenerateDWARF("INIT"));
176 EXPECT_EQ("DW_OP_pick 0x00, DW_OP_pick 0x01, DW_OP_plus ",
179 EXPECT_EQ("DW_OP_breg1 +0, DW_OP_pick 0x01, DW_OP_plus ",
182 EXPECT_EQ("DW_OP_consts +1, DW_OP_pick 0x01, DW_OP_deref , DW_OP_plus ",
185 EXPECT_EQ("DW_OP_consts +4, DW_OP_consts +5, DW_OP_plus ",
188 EXPECT_EQ("DW_OP_consts +4, DW_OP_consts +5, DW_OP_minus ",
191 EXPECT_EQ("DW_OP_consts +4, DW_OP_deref ", ParseAndGenerateDWARF("4 ^"));
193 EXPECT_EQ("DW_OP_breg6 +0, DW_OP_consts +128, DW_OP_lit1 "
tools/lldb/unittests/Symbol/TestClangASTContext.cpp 122 EXPECT_EQ(GetBasicQualType(eBasicTypeChar), GetBasicQualType("char"));
123 EXPECT_EQ(GetBasicQualType(eBasicTypeSignedChar),
125 EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedChar),
127 EXPECT_EQ(GetBasicQualType(eBasicTypeWChar), GetBasicQualType("wchar_t"));
128 EXPECT_EQ(GetBasicQualType(eBasicTypeSignedWChar),
130 EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedWChar),
132 EXPECT_EQ(GetBasicQualType(eBasicTypeShort), GetBasicQualType("short"));
133 EXPECT_EQ(GetBasicQualType(eBasicTypeShort), GetBasicQualType("short int"));
134 EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedShort),
136 EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedShort),
138 EXPECT_EQ(GetBasicQualType(eBasicTypeInt), GetBasicQualType("int"));
139 EXPECT_EQ(GetBasicQualType(eBasicTypeInt), GetBasicQualType("signed int"));
140 EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedInt),
142 EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedInt),
144 EXPECT_EQ(GetBasicQualType(eBasicTypeLong), GetBasicQualType("long"));
145 EXPECT_EQ(GetBasicQualType(eBasicTypeLong), GetBasicQualType("long int"));
146 EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedLong),
148 EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedLong),
150 EXPECT_EQ(GetBasicQualType(eBasicTypeLongLong),
152 EXPECT_EQ(GetBasicQualType(eBasicTypeLongLong),
154 EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedLongLong),
156 EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedLongLong),
158 EXPECT_EQ(GetBasicQualType(eBasicTypeInt128), GetBasicQualType("__int128_t"));
159 EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedInt128),
161 EXPECT_EQ(GetBasicQualType(eBasicTypeVoid), GetBasicQualType("void"));
162 EXPECT_EQ(GetBasicQualType(eBasicTypeBool), GetBasicQualType("bool"));
163 EXPECT_EQ(GetBasicQualType(eBasicTypeFloat), GetBasicQualType("float"));
164 EXPECT_EQ(GetBasicQualType(eBasicTypeDouble), GetBasicQualType("double"));
165 EXPECT_EQ(GetBasicQualType(eBasicTypeLongDouble),
167 EXPECT_EQ(GetBasicQualType(eBasicTypeObjCID), GetBasicQualType("id"));
168 EXPECT_EQ(GetBasicQualType(eBasicTypeObjCSel), GetBasicQualType("SEL"));
169 EXPECT_EQ(GetBasicQualType(eBasicTypeNullPtr), GetBasicQualType("nullptr"));
184 EXPECT_EQ(bit_size, actual_size);
257 EXPECT_EQ(0u, qt.getLocalFastQualifiers());
265 EXPECT_EQ(0u, qt.getLocalFastQualifiers());
269 EXPECT_EQ(AS_none,
271 EXPECT_EQ(AS_none, ClangASTContext::ConvertAccessTypeToAccessSpecifier(
273 EXPECT_EQ(AS_public,
275 EXPECT_EQ(AS_private, ClangASTContext::ConvertAccessTypeToAccessSpecifier(
277 EXPECT_EQ(AS_protected, ClangASTContext::ConvertAccessTypeToAccessSpecifier(
283 EXPECT_EQ(AS_public,
285 EXPECT_EQ(AS_private,
287 EXPECT_EQ(AS_protected,
291 EXPECT_EQ(AS_private,
293 EXPECT_EQ(AS_private,
295 EXPECT_EQ(AS_private,
297 EXPECT_EQ(AS_private,
299 EXPECT_EQ(AS_protected,
301 EXPECT_EQ(AS_protected,
305 EXPECT_EQ(AS_none,
307 EXPECT_EQ(AS_none,
309 EXPECT_EQ(AS_none,
311 EXPECT_EQ(AS_none,
313 EXPECT_EQ(AS_none,
315 EXPECT_EQ(AS_none,
367 EXPECT_EQ(1u, ClangASTContext::GetNumBaseClasses(
390 EXPECT_EQ(1u, ClangASTContext::GetNumBaseClasses(
436 EXPECT_EQ(m_ast->GetTemplateArgumentKind(t.GetOpaqueQualType(), 0),
438 EXPECT_EQ(m_ast->GetTypeTemplateArgument(t.GetOpaqueQualType(), 0),
440 EXPECT_EQ(llvm::None,
443 EXPECT_EQ(m_ast->GetTemplateArgumentKind(t.GetOpaqueQualType(), 1),
445 EXPECT_EQ(m_ast->GetTypeTemplateArgument(t.GetOpaqueQualType(), 1),
449 EXPECT_EQ(arg, result->value);
450 EXPECT_EQ(int_type, result->type);
tools/lldb/unittests/Symbol/TestDWARFCallFrameInfo.cpp 254 EXPECT_EQ(GetExpectedRow0(), *plan.GetRowAtIndex(0));
255 EXPECT_EQ(GetExpectedRow1(), *plan.GetRowAtIndex(1));
256 EXPECT_EQ(GetExpectedRow2(), *plan.GetRowAtIndex(2));
tools/lldb/unittests/Symbol/TestType.cpp 26 EXPECT_EQ(is_scoped, expected_is_scoped);
28 EXPECT_EQ(scope, expected_scope);
29 EXPECT_EQ(name, expected_name);
tools/lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp 79 EXPECT_EQ(symfile->GetPluginName(), SymbolFileDWARF::GetPluginNameStatic());
82 EXPECT_EQ(expected_abilities, symfile->CalculateAbilities());
118 EXPECT_EQ(abbrev_set.GetIndexOffset(), 1u);
121 EXPECT_EQ(abbrev1->Tag(), DW_TAG_compile_unit);
123 EXPECT_EQ(abbrev1->NumAttributes(), 1u);
125 EXPECT_EQ(abbrev2->Tag(), DW_TAG_subprogram);
127 EXPECT_EQ(abbrev2->NumAttributes(), 1u);
163 EXPECT_EQ(abbrev_set.GetIndexOffset(), 5u);
166 EXPECT_EQ(abbrev1->Tag(), DW_TAG_compile_unit);
168 EXPECT_EQ(abbrev1->NumAttributes(), 1u);
170 EXPECT_EQ(abbrev2->Tag(), DW_TAG_subprogram);
172 EXPECT_EQ(abbrev2->NumAttributes(), 1u);
208 EXPECT_EQ(abbrev_set.GetIndexOffset(), UINT32_MAX);
211 EXPECT_EQ(abbrev1->Tag(), DW_TAG_compile_unit);
213 EXPECT_EQ(abbrev1->NumAttributes(), 1u);
215 EXPECT_EQ(abbrev2->Tag(), DW_TAG_subprogram);
217 EXPECT_EQ(abbrev2->NumAttributes(), 1u);
242 EXPECT_EQ("abbrev decl requires non-null tag.",
271 EXPECT_EQ("malformed abbreviation declaration attribute",
300 EXPECT_EQ("malformed abbreviation declaration attribute",
326 EXPECT_EQ("abbreviation declaration attribute list not terminated with a "
tools/lldb/unittests/SymbolFile/NativePDB/PdbFPOProgramToDWARFExpressionTests.cpp 91 EXPECT_EQ((size_t)0, stream.GetSize());
tools/lldb/unittests/Target/ExecutionContextTest.cpp 72 EXPECT_EQ(endian::InlHostByteOrder(), exe_ctx.GetByteOrder());
93 EXPECT_EQ(target_sp->GetArchitecture().GetByteOrder(),
119 EXPECT_EQ(process_sp->GetByteOrder(), process_ctx.GetByteOrder());
tools/lldb/unittests/Target/MemoryRegionInfoTest.cpp 16 EXPECT_EQ("yes", llvm::formatv("{0}", MemoryRegionInfo::eYes).str());
17 EXPECT_EQ("no", llvm::formatv("{0}", MemoryRegionInfo::eNo).str());
18 EXPECT_EQ("don't know", llvm::formatv("{0}", MemoryRegionInfo::eDontKnow).str());
tools/lldb/unittests/Target/ModuleCacheTest.cpp 90 EXPECT_EQ(module_size, FileSystem::Instance().GetByteSize(uuid_view));
95 EXPECT_EQ(module_size, FileSystem::Instance().GetByteSize(sysroot_view));
125 EXPECT_EQ(expect_download, download_called);
134 EXPECT_EQ(1u, sc_list.GetSize());
tools/lldb/unittests/Target/PathMappingListTest.cpp 39 EXPECT_EQ(FileSpec(actual_remapped.GetStringRef()), match.remapped);
43 EXPECT_EQ(unmapped_path, orig_normalized);
tools/lldb/unittests/UnwindAssembly/ARM64/TestArm64InstEmulation.cpp 94 EXPECT_EQ(0ull, row_sp->GetOffset());
97 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
101 EXPECT_EQ(4ull, row_sp->GetOffset());
104 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
108 EXPECT_EQ(-16, regloc.GetOffset());
112 EXPECT_EQ(-8, regloc.GetOffset());
116 EXPECT_EQ(8ull, row_sp->GetOffset());
119 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
123 EXPECT_EQ(-16, regloc.GetOffset());
127 EXPECT_EQ(-8, regloc.GetOffset());
131 EXPECT_EQ(16ull, row_sp->GetOffset());
134 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
138 EXPECT_EQ(-16, regloc.GetOffset());
142 EXPECT_EQ(-8, regloc.GetOffset());
146 EXPECT_EQ(20ull, row_sp->GetOffset());
149 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
211 EXPECT_EQ(0ull, row_sp->GetOffset());
214 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
218 EXPECT_EQ(4ull, row_sp->GetOffset());
220 EXPECT_EQ(48, row_sp->GetCFAValue().GetOffset());
224 EXPECT_EQ(-40, regloc.GetOffset());
228 EXPECT_EQ(-48, regloc.GetOffset());
232 EXPECT_EQ(8ull, row_sp->GetOffset());
234 EXPECT_EQ(48, row_sp->GetCFAValue().GetOffset());
238 EXPECT_EQ(-24, regloc.GetOffset());
242 EXPECT_EQ(-32, regloc.GetOffset());
247 EXPECT_EQ(12ull, row_sp->GetOffset());
249 EXPECT_EQ(48, row_sp->GetCFAValue().GetOffset());
253 EXPECT_EQ(-16, regloc.GetOffset());
257 EXPECT_EQ(-8, regloc.GetOffset());
262 EXPECT_EQ(16ull, row_sp->GetOffset());
265 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
270 EXPECT_EQ(28ull, row_sp->GetOffset());
273 EXPECT_EQ(48, row_sp->GetCFAValue().GetOffset());
278 EXPECT_EQ(32ull, row_sp->GetOffset());
291 EXPECT_EQ(36ull, row_sp->GetOffset());
302 EXPECT_EQ(40ull, row_sp->GetOffset());
305 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
365 EXPECT_EQ(0ull, row_sp->GetOffset());
368 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
373 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
391 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
396 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
401 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
406 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
491 EXPECT_EQ(28ull, row_sp->GetOffset());
494 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
498 EXPECT_EQ(-32, regloc.GetOffset());
501 EXPECT_EQ(28ull, row_sp->GetOffset());
504 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
508 EXPECT_EQ(-32, regloc.GetOffset());
607 EXPECT_EQ(28ull, row_sp->GetOffset());
610 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
614 EXPECT_EQ(-96, regloc.GetOffset());
618 EXPECT_EQ(-88, regloc.GetOffset());
622 EXPECT_EQ(-80, regloc.GetOffset());
626 EXPECT_EQ(-72, regloc.GetOffset());
630 EXPECT_EQ(-64, regloc.GetOffset());
634 EXPECT_EQ(-56, regloc.GetOffset());
638 EXPECT_EQ(-48, regloc.GetOffset());
642 EXPECT_EQ(-40, regloc.GetOffset());
646 EXPECT_EQ(60ull, row_sp->GetOffset());
649 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
tools/lldb/unittests/UnwindAssembly/PPC64/TestPPC64InstEmulation.cpp 100 EXPECT_EQ(0ull, row_sp->GetOffset());
103 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
107 EXPECT_EQ(16ull, row_sp->GetOffset());
110 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
114 EXPECT_EQ(-8, regloc.GetOffset());
118 EXPECT_EQ(20ull, row_sp->GetOffset());
121 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
125 EXPECT_EQ(16, regloc.GetOffset());
129 EXPECT_EQ(24ull, row_sp->GetOffset());
132 EXPECT_EQ(112, row_sp->GetCFAValue().GetOffset());
136 EXPECT_EQ(-8, regloc.GetOffset());
140 EXPECT_EQ(16, regloc.GetOffset());
144 EXPECT_EQ(28ull, row_sp->GetOffset());
147 EXPECT_EQ(112, row_sp->GetCFAValue().GetOffset());
151 EXPECT_EQ(-8, regloc.GetOffset());
155 EXPECT_EQ(16, regloc.GetOffset());
159 EXPECT_EQ(40ull, row_sp->GetOffset());
162 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
166 EXPECT_EQ(-8, regloc.GetOffset());
170 EXPECT_EQ(16, regloc.GetOffset());
212 EXPECT_EQ(0ull, row_sp->GetOffset());
215 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
219 EXPECT_EQ(8ull, row_sp->GetOffset());
222 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
226 EXPECT_EQ(-8, regloc.GetOffset());
230 EXPECT_EQ(12ull, row_sp->GetOffset());
233 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
237 EXPECT_EQ(16, regloc.GetOffset());
241 EXPECT_EQ(16ull, row_sp->GetOffset());
244 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
247 EXPECT_EQ(16ull, row_sp->GetOffset());
250 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
254 EXPECT_EQ(36ull, row_sp->GetOffset());
257 EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
tools/lldb/unittests/UnwindAssembly/x86/Testx86AssemblyInspectionEngine.cpp 176 EXPECT_EQ(0ull, row_sp->GetOffset());
179 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
183 EXPECT_EQ(-8, regloc.GetOffset());
187 EXPECT_EQ(1ull, row_sp->GetOffset());
190 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
194 EXPECT_EQ(-8, regloc.GetOffset());
198 EXPECT_EQ(4ull, row_sp->GetOffset());
201 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
205 EXPECT_EQ(-8, regloc.GetOffset());
209 EXPECT_EQ(7ull, row_sp->GetOffset());
212 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
216 EXPECT_EQ(-8, regloc.GetOffset());
252 EXPECT_EQ(0ull, row_sp->GetOffset());
255 EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
263 EXPECT_EQ(1ull, row_sp->GetOffset());
266 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
270 EXPECT_EQ(-4, regloc.GetOffset());
274 EXPECT_EQ(3ull, row_sp->GetOffset());
277 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
281 EXPECT_EQ(-4, regloc.GetOffset());
285 EXPECT_EQ(6ull, row_sp->GetOffset());
288 EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
292 EXPECT_EQ(-4, regloc.GetOffset());
393 EXPECT_EQ(17ull, row_sp->GetOffset());
396 EXPECT_EQ(14496, row_sp->GetCFAValue().GetOffset());
400 EXPECT_EQ(-8, regloc.GetOffset());
404 EXPECT_EQ(-16, regloc.GetOffset());
408 EXPECT_EQ(-24, regloc.GetOffset());
412 EXPECT_EQ(-32, regloc.GetOffset());
416 EXPECT_EQ(-40, regloc.GetOffset());
420 EXPECT_EQ(-48, regloc.GetOffset());
424 EXPECT_EQ(-56, regloc.GetOffset());
431 EXPECT_EQ(34ull, row_sp->GetOffset());
434 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
438 EXPECT_EQ(-8, regloc.GetOffset());
662 EXPECT_EQ(10ull, row_sp->GetOffset());
665 EXPECT_EQ(14464, row_sp->GetCFAValue().GetOffset());
670 EXPECT_EQ(15ull, row_sp->GetOffset());
671 EXPECT_EQ(14468, row_sp->GetCFAValue().GetOffset());
676 EXPECT_EQ(16ull, row_sp->GetOffset());
677 EXPECT_EQ(14464, row_sp->GetCFAValue().GetOffset());
683 EXPECT_EQ(-4, regloc.GetOffset());
687 EXPECT_EQ(-8, regloc.GetOffset());
691 EXPECT_EQ(-12, regloc.GetOffset());
695 EXPECT_EQ(-16, regloc.GetOffset());
699 EXPECT_EQ(-20, regloc.GetOffset());
707 EXPECT_EQ(23ull, row_sp->GetOffset());
710 EXPECT_EQ(14472, row_sp->GetCFAValue().GetOffset());
715 EXPECT_EQ(24ull, row_sp->GetOffset());
716 EXPECT_EQ(14476, row_sp->GetCFAValue().GetOffset());
721 EXPECT_EQ(28ull, row_sp->GetOffset());
722 EXPECT_EQ(14480, row_sp->GetCFAValue().GetOffset());
727 EXPECT_EQ(36ull, row_sp->GetOffset());
728 EXPECT_EQ(14464, row_sp->GetCFAValue().GetOffset());
734 EXPECT_EQ(47ull, row_sp->GetOffset());
737 EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
741 EXPECT_EQ(-4, regloc.GetOffset());
745 EXPECT_EQ(0, regloc.GetOffset());
813 EXPECT_EQ(1ull, row_sp->GetOffset());
816 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
820 EXPECT_EQ(-8, regloc.GetOffset());
845 EXPECT_EQ(22ull, row_sp->GetOffset());
848 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
852 EXPECT_EQ(-8, regloc.GetOffset());
922 EXPECT_EQ(3ull, row_sp->GetOffset());
925 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
931 EXPECT_EQ(8ull, row_sp->GetOffset());
934 EXPECT_EQ(20, row_sp->GetCFAValue().GetOffset());
940 EXPECT_EQ(9ull, row_sp->GetOffset());
943 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
959 EXPECT_EQ(34ull, row_sp->GetOffset());
962 EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
983 EXPECT_EQ(1ull, row_sp->GetOffset());
986 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
990 EXPECT_EQ(-16, regloc.GetOffset());
998 EXPECT_EQ(1ull, row_sp->GetOffset());
1001 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1005 EXPECT_EQ(-8, regloc.GetOffset());
1026 EXPECT_EQ(5ull, row_sp->GetOffset());
1029 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
1032 EXPECT_EQ(7ull, row_sp->GetOffset());
1035 EXPECT_EQ(24, row_sp->GetCFAValue().GetOffset());
1042 EXPECT_EQ(5ull, row_sp->GetOffset());
1045 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1048 EXPECT_EQ(7ull, row_sp->GetOffset());
1051 EXPECT_EQ(12, row_sp->GetCFAValue().GetOffset());
1076 EXPECT_EQ(0ull, row_sp->GetOffset());
1085 EXPECT_EQ(0ull, row_sp->GetOffset());
1108 EXPECT_EQ(4ull, row_sp->GetOffset());
1111 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
1118 EXPECT_EQ(4ull, row_sp->GetOffset());
1121 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1124 EXPECT_EQ(10ull, row_sp->GetOffset());
1127 EXPECT_EQ(12, row_sp->GetCFAValue().GetOffset());
1130 EXPECT_EQ(12ull, row_sp->GetOffset());
1133 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
1154 EXPECT_EQ(2ull, row_sp->GetOffset());
1157 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
1161 EXPECT_EQ(-16, regloc.GetOffset());
1182 EXPECT_EQ(2ull, row_sp->GetOffset());
1185 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
1189 EXPECT_EQ(-16, regloc.GetOffset());
1210 EXPECT_EQ(2ull, row_sp->GetOffset());
1213 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
1217 EXPECT_EQ(-16, regloc.GetOffset());
1238 EXPECT_EQ(2ull, row_sp->GetOffset());
1241 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
1245 EXPECT_EQ(-16, regloc.GetOffset());
1266 EXPECT_EQ(1ull, row_sp->GetOffset());
1269 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
1273 EXPECT_EQ(-16, regloc.GetOffset());
1297 EXPECT_EQ(1ull, row_sp->GetOffset());
1300 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1326 EXPECT_EQ(1ull, row_sp->GetOffset());
1329 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1355 EXPECT_EQ(1ull, row_sp->GetOffset());
1358 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1381 EXPECT_EQ(1ull, row_sp->GetOffset());
1384 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1388 EXPECT_EQ(-8, regloc.GetOffset());
1409 EXPECT_EQ(1ull, row_sp->GetOffset());
1412 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1416 EXPECT_EQ(-8, regloc.GetOffset());
1437 EXPECT_EQ(2ull, row_sp->GetOffset());
1440 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
1444 EXPECT_EQ(-16, regloc.GetOffset());
1465 EXPECT_EQ(1ull, row_sp->GetOffset());
1468 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1472 EXPECT_EQ(-8, regloc.GetOffset());
1493 EXPECT_EQ(1ull, row_sp->GetOffset());
1496 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1500 EXPECT_EQ(-8, regloc.GetOffset());
1521 EXPECT_EQ(3ull, row_sp->GetOffset());
1524 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1537 EXPECT_EQ(3ull, row_sp->GetOffset());
1540 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1553 EXPECT_EQ(2ull, row_sp->GetOffset());
1556 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1569 EXPECT_EQ(2ull, row_sp->GetOffset());
1572 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1593 EXPECT_EQ(7ull, row_sp->GetOffset());
1596 EXPECT_EQ(264, row_sp->GetCFAValue().GetOffset());
1609 EXPECT_EQ(4ull, row_sp->GetOffset());
1612 EXPECT_EQ(24, row_sp->GetCFAValue().GetOffset());
1633 EXPECT_EQ(6ull, row_sp->GetOffset());
1636 EXPECT_EQ(260, row_sp->GetCFAValue().GetOffset());
1649 EXPECT_EQ(3ull, row_sp->GetOffset());
1652 EXPECT_EQ(20, row_sp->GetCFAValue().GetOffset());
1673 EXPECT_EQ(7ull, row_sp->GetOffset());
1676 EXPECT_EQ(8 - 256, row_sp->GetCFAValue().GetOffset());
1689 EXPECT_EQ(4ull, row_sp->GetOffset());
1692 EXPECT_EQ(8 - 16, row_sp->GetCFAValue().GetOffset());
1713 EXPECT_EQ(6ull, row_sp->GetOffset());
1716 EXPECT_EQ(4 - 256, row_sp->GetCFAValue().GetOffset());
1729 EXPECT_EQ(3ull, row_sp->GetOffset());
1732 EXPECT_EQ(4 - 16, row_sp->GetCFAValue().GetOffset());
1756 EXPECT_EQ(2ull, row_sp->GetOffset());
1759 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1782 EXPECT_EQ(2ull, row_sp->GetOffset());
1785 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1808 EXPECT_EQ(4ull, row_sp->GetOffset());
1811 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1834 EXPECT_EQ(4ull, row_sp->GetOffset());
1837 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1860 EXPECT_EQ(4ull, row_sp->GetOffset());
1863 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1886 EXPECT_EQ(4ull, row_sp->GetOffset());
1889 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1912 EXPECT_EQ(2ull, row_sp->GetOffset());
1915 EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
1938 EXPECT_EQ(2ull, row_sp->GetOffset());
1941 EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
1964 EXPECT_EQ(4ull, row_sp->GetOffset());
1967 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
1990 EXPECT_EQ(2ull, row_sp->GetOffset());
1993 EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
2016 EXPECT_EQ(2ull, row_sp->GetOffset());
2019 EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
2051 EXPECT_EQ(4ull, row_sp->GetOffset());
2054 EXPECT_EQ(20, row_sp->GetCFAValue().GetOffset());
2057 EXPECT_EQ(7ull, row_sp->GetOffset());
2060 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
2083 EXPECT_EQ(2ull, row_sp->GetOffset());
2086 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
2093 EXPECT_EQ(2ull, row_sp->GetOffset());
2096 EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
2122 EXPECT_EQ(5ull, row_sp->GetOffset());
2125 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
2151 EXPECT_EQ(19ull, row_sp->GetOffset());
2153 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
2157 EXPECT_EQ(-80, regloc.GetOffset());
2161 EXPECT_EQ(-1512, regloc.GetOffset());
2165 EXPECT_EQ(-88, regloc.GetOffset());
2189 EXPECT_EQ(12ull, row_sp->GetOffset());
2191 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
2195 EXPECT_EQ(-344, regloc.GetOffset());
2199 EXPECT_EQ(-40, regloc.GetOffset());
2273 EXPECT_EQ(4ull, row_sp->GetOffset());
2277 EXPECT_EQ(12ull, row_sp->GetOffset());
2279 EXPECT_EQ(152, row_sp->GetCFAValue().GetOffset());
2283 EXPECT_EQ(12ull, row_sp->GetOffset());
2288 EXPECT_EQ(20ull, row_sp->GetOffset());
2290 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
2358 EXPECT_EQ(6ull, row_sp->GetOffset());
2360 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
2436 EXPECT_EQ(5ull, row_sp->GetOffset());
2438 EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
2473 EXPECT_EQ(2ull, row_sp->GetOffset());
2476 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
2480 EXPECT_EQ(-8, regloc.GetOffset());
2488 EXPECT_EQ(0ull, row_sp->GetOffset());
2491 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
2521 EXPECT_EQ(esp_plus_4, plan.GetRowForFunctionOffset(0)->GetCFAValue());
2522 EXPECT_EQ(esp_plus_8, plan.GetRowForFunctionOffset(1)->GetCFAValue());
2524 EXPECT_EQ(ebp_plus_8, plan.GetRowForFunctionOffset(i)->GetCFAValue())
2526 EXPECT_EQ(esp_plus_4,
2555 EXPECT_EQ(rsp_plus_8, plan.GetRowForFunctionOffset(0)->GetCFAValue());
2556 EXPECT_EQ(rsp_plus_16, plan.GetRowForFunctionOffset(1)->GetCFAValue());
2558 EXPECT_EQ(rbp_plus_16, plan.GetRowForFunctionOffset(i)->GetCFAValue())
2560 EXPECT_EQ(rsp_plus_8,
2599 EXPECT_EQ(esp_plus_4, plan.GetRowForFunctionOffset(0)->GetCFAValue());
2600 EXPECT_EQ(esp_plus_8, plan.GetRowForFunctionOffset(1)->GetCFAValue());
2602 EXPECT_EQ(ebx_plus_8, plan.GetRowForFunctionOffset(i)->GetCFAValue())
2604 EXPECT_EQ(esp_plus_4, plan.GetRowForFunctionOffset(33)->GetCFAValue());
2607 EXPECT_EQ(esp_plus_0, plan.GetRowForFunctionOffset(12)->GetAFAValue());
2608 EXPECT_EQ(esp_minus_4, plan.GetRowForFunctionOffset(15)->GetAFAValue());
2609 EXPECT_EQ(esp_plus_0, plan.GetRowForFunctionOffset(16)->GetAFAValue());
2611 EXPECT_EQ(ebp_plus_0, plan.GetRowForFunctionOffset(i)->GetAFAValue())
2613 EXPECT_EQ(esp_minus_4, plan.GetRowForFunctionOffset(30)->GetAFAValue());
2620 EXPECT_EQ(-4, reg_loc.GetOffset());
2698 EXPECT_EQ(0ull, row_sp->GetOffset());
2701 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
2705 EXPECT_EQ(-8, regloc.GetOffset());
2709 EXPECT_EQ(1ull, row_sp->GetOffset());
2712 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
2716 EXPECT_EQ(-8, regloc.GetOffset());
2720 EXPECT_EQ(4ull, row_sp->GetOffset());
2723 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
2727 EXPECT_EQ(-8, regloc.GetOffset());
2731 EXPECT_EQ(7ull, row_sp->GetOffset());
2734 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
2738 EXPECT_EQ(-8, regloc.GetOffset());
2742 EXPECT_EQ(8ull, row_sp->GetOffset());
2745 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
2749 EXPECT_EQ(-8, regloc.GetOffset());
2753 EXPECT_EQ(11ull, row_sp->GetOffset());
2756 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
2760 EXPECT_EQ(-8, regloc.GetOffset());
2764 EXPECT_EQ(12ull, row_sp->GetOffset());
2767 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
2771 EXPECT_EQ(-8, regloc.GetOffset());
2775 EXPECT_EQ(15ull, row_sp->GetOffset());
2778 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
2782 EXPECT_EQ(-8, regloc.GetOffset());
2786 EXPECT_EQ(18ull, row_sp->GetOffset());
2789 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
2793 EXPECT_EQ(-8, regloc.GetOffset());
2797 EXPECT_EQ(21ull, row_sp->GetOffset());
2800 EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
2804 EXPECT_EQ(-8, regloc.GetOffset());
2808 EXPECT_EQ(24ull, row_sp->GetOffset());
2811 EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
2815 EXPECT_EQ(-8, regloc.GetOffset());
2863 EXPECT_EQ(16ull, row_sp->GetOffset());
2866 EXPECT_EQ(wordsize, row_sp->GetCFAValue().GetOffset());
2872 EXPECT_EQ(18ull, row_sp->GetOffset());
2875 EXPECT_EQ(wordsize * 2, row_sp->GetCFAValue().GetOffset());
2881 EXPECT_EQ(27ull, row_sp->GetOffset());
2884 EXPECT_EQ(wordsize * 2, row_sp->GetCFAValue().GetOffset());
2890 EXPECT_EQ(33ull, row_sp->GetOffset());
2893 EXPECT_EQ(wordsize, row_sp->GetCFAValue().GetOffset());
2905 EXPECT_EQ(16ull, row_sp->GetOffset());
2908 EXPECT_EQ(wordsize, row_sp->GetCFAValue().GetOffset());
2914 EXPECT_EQ(18ull, row_sp->GetOffset());
2917 EXPECT_EQ(wordsize * 2, row_sp->GetCFAValue().GetOffset());
2923 EXPECT_EQ(27ull, row_sp->GetOffset());
2926 EXPECT_EQ(wordsize * 2, row_sp->GetCFAValue().GetOffset());
2932 EXPECT_EQ(33ull, row_sp->GetOffset());
2935 EXPECT_EQ(wordsize, row_sp->GetCFAValue().GetOffset());
tools/lldb/unittests/Utility/AnsiTerminalTest.cpp 15 TEST(AnsiTerminal, Empty) { EXPECT_EQ("", ansi::FormatAnsiTerminalCodes("")); }
18 EXPECT_EQ(" ", ansi::FormatAnsiTerminalCodes(" "));
22 EXPECT_EQ("abc\x1B[30m",
27 EXPECT_EQ("\x1B[30mabc",
32 EXPECT_EQ("${ansi.fg.redish}abc",
37 EXPECT_EQ("${ansi.fg.foo}abc",
42 EXPECT_EQ("abc${ansi.", ansi::FormatAnsiTerminalCodes("abc${ansi."));
46 EXPECT_EQ("\x1B[30m\x1B[31mabc",
51 EXPECT_EQ(
tools/lldb/unittests/Utility/ArchSpecTest.cpp 23 EXPECT_EQ(12u, AS.GetMachOCPUType());
24 EXPECT_EQ(10u, AS.GetMachOCPUSubType());
28 EXPECT_EQ(12u, AS.GetMachOCPUType());
29 EXPECT_EQ(15u, AS.GetMachOCPUSubType());
33 EXPECT_EQ(12u, AS.GetMachOCPUType());
34 EXPECT_EQ(15u, AS.GetMachOCPUSubType());
41 EXPECT_EQ(0u, AS.GetMachOCPUType());
42 EXPECT_EQ(0u, AS.GetMachOCPUSubType());
62 EXPECT_EQ(12u, AS.GetMachOCPUType());
63 EXPECT_EQ(15u, AS.GetMachOCPUSubType());
64 EXPECT_EQ("vendor", AS.GetTriple().getVendorName());
65 EXPECT_EQ("os", AS.GetTriple().getOSName());
69 EXPECT_EQ(12u, AS.GetMachOCPUType());
70 EXPECT_EQ(10u, AS.GetMachOCPUSubType());
71 EXPECT_EQ("vendor", AS.GetTriple().getVendorName());
72 EXPECT_EQ("os", AS.GetTriple().getOSName());
76 EXPECT_EQ(12u, AS.GetMachOCPUType());
77 EXPECT_EQ(15u, AS.GetMachOCPUSubType());
78 EXPECT_EQ("vendor.os", AS.GetTriple().getVendorName());
79 EXPECT_EQ("name", AS.GetTriple().getOSName());
85 EXPECT_EQ(12u, AS.GetMachOCPUType());
86 EXPECT_EQ(10u, AS.GetMachOCPUSubType());
87 EXPECT_EQ("apple", AS.GetTriple().getVendorName());
88 EXPECT_EQ("", AS.GetTriple().getOSName());
102 EXPECT_EQ(uint32_t(llvm::MachO::CPU_TYPE_ARM), AS.GetMachOCPUType());
103 EXPECT_EQ(10u, AS.GetMachOCPUSubType());
106 EXPECT_EQ(ArchSpec::eCore_arm_armv7f, AS.GetCore());
110 EXPECT_EQ(uint32_t(llvm::MachO::CPU_TYPE_POWERPC), AS.GetMachOCPUType());
111 EXPECT_EQ(100u, AS.GetMachOCPUSubType());
114 EXPECT_EQ(ArchSpec::eCore_ppc_ppc970, AS.GetCore());
118 EXPECT_EQ(llvm::Triple::x86, AS.GetTriple().getArch());
119 EXPECT_EQ(llvm::Triple::PC, AS.GetTriple().getVendor());
120 EXPECT_EQ(llvm::Triple::Win32, AS.GetTriple().getOS());
124 EXPECT_EQ(ArchSpec::eCore_x86_32_i686, AS.GetCore());
144 EXPECT_EQ(llvm::Triple::ArchType::x86_64, B.GetTriple().getArch());
145 EXPECT_EQ(llvm::Triple::VendorType::PC, B.GetTriple().getVendor());
146 EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
147 EXPECT_EQ(ArchSpec::eCore_x86_64_x86_64, B.GetCore());
151 EXPECT_EQ(llvm::Triple::ArchType::x86_64, A.GetTriple().getArch());
152 EXPECT_EQ(llvm::Triple::VendorType::PC, A.GetTriple().getVendor());
153 EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
154 EXPECT_EQ(ArchSpec::eCore_x86_64_x86_64, A.GetCore());
168 EXPECT_EQ(llvm::Triple::ArchType::aarch64, B.GetTriple().getArch());
169 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
171 EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
172 EXPECT_EQ(llvm::Triple::EnvironmentType::Android,
176 EXPECT_EQ(llvm::Triple::ArchType::aarch64, A.GetTriple().getArch());
177 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
179 EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
180 EXPECT_EQ(llvm::Triple::EnvironmentType::Android,
183 EXPECT_EQ(llvm::Triple::ArchType::aarch64_32, D.GetTriple().getArch());
184 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
186 EXPECT_EQ(llvm::Triple::OSType::WatchOS, D.GetTriple().getOS());
189 EXPECT_EQ(llvm::Triple::ArchType::aarch64_32, C.GetTriple().getArch());
190 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
192 EXPECT_EQ(llvm::Triple::OSType::WatchOS, C.GetTriple().getOS());
204 EXPECT_EQ(llvm::Triple::ArchType::arm, B.GetTriple().getArch());
205 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
207 EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
208 EXPECT_EQ(llvm::Triple::EnvironmentType::UnknownEnvironment,
212 EXPECT_EQ(llvm::Triple::ArchType::arm, A.GetTriple().getArch());
213 EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
215 EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
216 EXPECT_EQ(llvm::Triple::EnvironmentType::UnknownEnvironment,
tools/lldb/unittests/Utility/ArgsTest.cpp 22 EXPECT_EQ(1u, args.GetArgumentCount());
29 EXPECT_EQ(1u, args.GetArgumentCount());
36 EXPECT_EQ(1u, args.GetArgumentCount());
43 EXPECT_EQ(1u, args.GetArgumentCount());
50 EXPECT_EQ(1u, args.GetArgumentCount());
57 EXPECT_EQ(1u, args.GetArgumentCount());
64 EXPECT_EQ(1u, args.GetArgumentCount());
71 EXPECT_EQ(4u, args.GetArgumentCount());
81 EXPECT_EQ(4u, args.GetArgumentCount());
83 EXPECT_EQ(1u, args.GetArgumentCount());
90 EXPECT_EQ(1u, args.GetArgumentCount());
92 EXPECT_EQ(2u, args.GetArgumentCount());
115 EXPECT_EQ(nullptr, args.GetArgumentVector());
119 EXPECT_EQ(nullptr, args.GetArgumentVector()[1]);
124 EXPECT_EQ(nullptr, args.GetArgumentVector()[2]);
130 EXPECT_EQ(nullptr, args.GetArgumentVector()[3]);
137 EXPECT_EQ(nullptr, args.GetArgumentVector()[4]);
145 EXPECT_EQ(nullptr, args.GetArgumentVector()[5]);
155 EXPECT_EQ("foo", args[0].ref());
156 EXPECT_EQ("bar", args[1].ref());
157 EXPECT_EQ("baz", args[2].ref());
167 EXPECT_EQ(str, stdstr);
173 EXPECT_EQ(1u, args.GetArgumentCount());
181 EXPECT_EQ(1u, args.GetArgumentCount());
195 EXPECT_EQ(nullptr, args.GetArgumentVector()[2]);
205 EXPECT_EQ(nullptr, args.GetArgumentVector()[4]);
222 EXPECT_EQ("foo\\'", Args::EscapeLLDBCommandArgument(foo, '\0'));
223 EXPECT_EQ("foo'", Args::EscapeLLDBCommandArgument(foo, '\''));
224 EXPECT_EQ("foo'", Args::EscapeLLDBCommandArgument(foo, '`'));
225 EXPECT_EQ("foo'", Args::EscapeLLDBCommandArgument(foo, '"'));
228 EXPECT_EQ("bar\\\"", Args::EscapeLLDBCommandArgument(bar, '\0'));
229 EXPECT_EQ("bar\"", Args::EscapeLLDBCommandArgument(bar, '\''));
230 EXPECT_EQ("bar\"", Args::EscapeLLDBCommandArgument(bar, '`'));
231 EXPECT_EQ("bar\\\"", Args::EscapeLLDBCommandArgument(bar, '"'));
234 EXPECT_EQ("baz\\`", Args::EscapeLLDBCommandArgument(baz, '\0'));
235 EXPECT_EQ("baz`", Args::EscapeLLDBCommandArgument(baz, '\''));
236 EXPECT_EQ("baz`", Args::EscapeLLDBCommandArgument(baz, '`'));
237 EXPECT_EQ("baz\\`", Args::EscapeLLDBCommandArgument(baz, '"'));
240 EXPECT_EQ("quux\\\t", Args::EscapeLLDBCommandArgument(quux, '\0'));
241 EXPECT_EQ("quux\t", Args::EscapeLLDBCommandArgument(quux, '\''));
242 EXPECT_EQ("quux\t", Args::EscapeLLDBCommandArgument(quux, '`'));
243 EXPECT_EQ("quux\t", Args::EscapeLLDBCommandArgument(quux, '"'));
250 EXPECT_EQ(3u, args.GetArgumentCount());
258 EXPECT_EQ(3u, args.GetArgumentCount());
266 EXPECT_EQ(3u, args.GetArgumentCount());
274 EXPECT_EQ(3u, args.GetArgumentCount());
282 EXPECT_EQ(3u, args.GetArgumentCount());
tools/lldb/unittests/Utility/BroadcasterTest.cpp 29 EXPECT_EQ(event_mask1,
33 EXPECT_EQ(event_mask1, event_sp->GetType());
39 EXPECT_EQ(event_mask2, listener2_sp->StartListeningForEvents(
43 EXPECT_EQ(event_mask2, event_sp->GetType());
48 EXPECT_EQ(event_mask1, event_sp->GetType());
50 EXPECT_EQ(event_mask2, event_sp->GetType());
56 EXPECT_EQ(event_mask1, event_sp->GetType());
68 EXPECT_EQ(event_mask,
tools/lldb/unittests/Utility/CompletionRequestTest.cpp 25 EXPECT_EQ(request.GetRawCursorPos(), cursor_pos);
26 EXPECT_EQ(request.GetCursorIndex(), arg_index);
28 EXPECT_EQ(request.GetParsedLine().GetArgumentCount(), 2u);
29 EXPECT_EQ(request.GetCursorArgumentPrefix().str(), "b");
42 EXPECT_EQ(request.GetRawCursorPos(), cursor_pos);
43 EXPECT_EQ(request.GetCursorIndex(), 3U);
45 EXPECT_EQ(request.GetParsedLine().GetArgumentCount(), 4U);
46 EXPECT_EQ(request.GetCursorArgumentPrefix().str(), "");
59 EXPECT_EQ(1U, result.GetResults().size());
61 EXPECT_EQ(1U, descriptions.GetSize());
72 EXPECT_EQ(0U, result.GetResults().size());
82 EXPECT_EQ(1U, result.GetResults().size());
83 EXPECT_EQ(CompletionMode::Partial, result.GetResults()[0].GetMode());
97 EXPECT_EQ(request.GetRawCursorPos(), cursor_pos);
98 EXPECT_EQ(request.GetCursorIndex(), arg_index);
100 EXPECT_EQ(request.GetParsedLine().GetArgumentCount(), 2u);
108 EXPECT_EQ(request.GetRawCursorPos(), cursor_pos);
111 EXPECT_EQ(request.GetCursorIndex(), arg_index - 1U);
112 EXPECT_EQ(request.GetParsedLine().GetArgumentCount(), 1u);
113 EXPECT_EQ(request.GetCursorArgumentPrefix().str(), "b");
125 EXPECT_EQ(0U, result.GetNumberOfResults());
131 EXPECT_EQ(1U, result.GetNumberOfResults());
132 EXPECT_EQ(1U, matches.GetSize());
138 EXPECT_EQ(1U, result.GetNumberOfResults());
139 EXPECT_EQ(1U, matches.GetSize());
146 EXPECT_EQ(2U, result.GetNumberOfResults());
147 EXPECT_EQ(2U, matches.GetSize());
154 EXPECT_EQ(2U, result.GetNumberOfResults());
155 EXPECT_EQ(2U, matches.GetSize());
163 EXPECT_EQ(2U, result.GetNumberOfResults());
164 EXPECT_EQ(2U, matches.GetSize());
172 EXPECT_EQ(3U, result.GetNumberOfResults());
173 EXPECT_EQ(3U, matches.GetSize());
189 EXPECT_EQ(0U, result.GetNumberOfResults());
196 EXPECT_EQ(1U, result.GetNumberOfResults());
197 EXPECT_EQ(1U, matches.GetSize());
198 EXPECT_EQ(1U, descriptions.GetSize());
206 EXPECT_EQ(1U, result.GetNumberOfResults());
207 EXPECT_EQ(1U, matches.GetSize());
208 EXPECT_EQ(1U, descriptions.GetSize());
217 EXPECT_EQ(2U, result.GetNumberOfResults());
218 EXPECT_EQ(2U, matches.GetSize());
219 EXPECT_EQ(2U, descriptions.GetSize());
227 EXPECT_EQ(3U, result.GetNumberOfResults());
228 EXPECT_EQ(3U, matches.GetSize());
229 EXPECT_EQ(3U, descriptions.GetSize());
242 EXPECT_EQ(4U, result.GetNumberOfResults());
243 EXPECT_EQ(4U, matches.GetSize());
244 EXPECT_EQ(4U, descriptions.GetSize());
270 EXPECT_EQ(1U, result.GetNumberOfResults());
tools/lldb/unittests/Utility/ConstStringTest.cpp 16 EXPECT_EQ("foo", llvm::formatv("{0}", ConstString("foo")).str());
23 EXPECT_EQ("", counterpart.GetStringRef());
27 EXPECT_EQ("xyz", xyz.GetStringRef());
30 EXPECT_EQ("uvw", counterpart.GetStringRef());
33 EXPECT_EQ("xyz", counterpart.GetStringRef());
52 EXPECT_EQ("one", counterpart.GetStringRef());
66 EXPECT_EQ("def", bar.GetStringRef());
70 EXPECT_EQ("abc", counterpart.GetStringRef());
73 EXPECT_EQ("def", counterpart.GetStringRef());
tools/lldb/unittests/Utility/DataExtractorTest.cpp 40 EXPECT_EQ(buffer + 0, E.PeekData(0, 0));
41 EXPECT_EQ(buffer + 0, E.PeekData(0, 4));
42 EXPECT_EQ(nullptr, E.PeekData(0, 5));
44 EXPECT_EQ(buffer + 2, E.PeekData(2, 0));
45 EXPECT_EQ(buffer + 2, E.PeekData(2, 2));
46 EXPECT_EQ(nullptr, E.PeekData(2, 3));
48 EXPECT_EQ(buffer + 4, E.PeekData(4, 0));
49 EXPECT_EQ(nullptr, E.PeekData(4, 1));
58 EXPECT_EQ(5U, offset);
67 EXPECT_EQ(2U, offset);
75 EXPECT_EQ(nullptr, E.GetCStr(&offset));
76 EXPECT_EQ(1U, offset);
84 EXPECT_EQ(nullptr, E.GetCStr(&offset));
85 EXPECT_EQ(1U, offset);
94 EXPECT_EQ(4U, offset);
107 EXPECT_EQ(0x01U, LE.GetMaxU64(&offset, 1));
108 EXPECT_EQ(1U, offset);
110 EXPECT_EQ(0x01U, BE.GetMaxU64(&offset, 1));
111 EXPECT_EQ(1U, offset);
115 EXPECT_EQ(0x0302U, LE.GetMaxU64(&offset, 2));
116 EXPECT_EQ(3U, offset);
118 EXPECT_EQ(0x0203U, BE.GetMaxU64(&offset, 2));
119 EXPECT_EQ(3U, offset);
123 EXPECT_EQ(0x07060504030201U, LE.GetMaxU64(&offset, 7));
124 EXPECT_EQ(7U, offset);
126 EXPECT_EQ(0x01020304050607U, BE.GetMaxU64(&offset, 7));
127 EXPECT_EQ(7U, offset);
131 EXPECT_EQ(0x0807060504030201U, LE.GetMaxU64(&offset, 8));
132 EXPECT_EQ(8U, offset);
134 EXPECT_EQ(0x0102030405060708U, BE.GetMaxU64(&offset, 8));
135 EXPECT_EQ(8U, offset);
148 EXPECT_EQ(0x01, LE.GetMaxS64(&offset, 1));
149 EXPECT_EQ(1U, offset);
151 EXPECT_EQ(0x01, BE.GetMaxS64(&offset, 1));
152 EXPECT_EQ(1U, offset);
157 EXPECT_EQ(0xffffffffff830201U, *reinterpret_cast<uint64_t *>(&value));
158 EXPECT_EQ(3U, offset);
161 EXPECT_EQ(0xffffffffff830405U, *reinterpret_cast<uint64_t *>(&value));
162 EXPECT_EQ(5U, offset);
166 EXPECT_EQ(0x0807060504830201, LE.GetMaxS64(&offset, 8));
167 EXPECT_EQ(8U, offset);
169 EXPECT_EQ(0x0102830405060708, BE.GetMaxS64(&offset, 8));
170 EXPECT_EQ(8U, offset);
183 EXPECT_EQ(0x01U, LE.GetMaxU64_unchecked(&offset, 1));
184 EXPECT_EQ(1U, offset);
186 EXPECT_EQ(0x01U, BE.GetMaxU64_unchecked(&offset, 1));
187 EXPECT_EQ(1U, offset);
191 EXPECT_EQ(0x0302U, LE.GetMaxU64_unchecked(&offset, 2));
192 EXPECT_EQ(3U, offset);
194 EXPECT_EQ(0x0203U, BE.GetMaxU64_unchecked(&offset, 2));
195 EXPECT_EQ(3U, offset);
199 EXPECT_EQ(0x07060504030201U, LE.GetMaxU64_unchecked(&offset, 7));
200 EXPECT_EQ(7U, offset);
202 EXPECT_EQ(0x01020304050607U, BE.GetMaxU64_unchecked(&offset, 7));
203 EXPECT_EQ(7U, offset);
207 EXPECT_EQ(0x0807060504030201U, LE.GetMaxU64_unchecked(&offset, 8));
208 EXPECT_EQ(8U, offset);
210 EXPECT_EQ(0x0102030405060708U, BE.GetMaxU64_unchecked(&offset, 8));
211 EXPECT_EQ(8U, offset);
tools/lldb/unittests/Utility/EnvironmentTest.cpp 17 EXPECT_EQ(0u, Environment(Envp1).size());
20 EXPECT_EQ("BAR", Environment(Envp2).lookup("FOO"));
23 EXPECT_EQ("BAR", Environment(Envp3).lookup("FOO"));
28 EXPECT_EQ("", Environment(Envp4).find("FOO")->second);
29 EXPECT_EQ("", Environment(Envp4).find("BAR")->second);
32 EXPECT_EQ("BAR=BAZ", Environment(Envp5).lookup("FOO"));
47 EXPECT_EQ(nullptr, Envp_[2]);
tools/lldb/unittests/Utility/EventTest.cpp 22 EXPECT_EQ(R"("foo")", to_string(EventDataBytes("foo")));
23 EXPECT_EQ("01 02 03", to_string(EventDataBytes("\x01\x02\x03")));
tools/lldb/unittests/Utility/FileSpecTest.cpp 29 EXPECT_EQ(nullptr, fs_posix_root.GetDirectory().GetCString());
34 EXPECT_EQ(nullptr, fs_net_drive.GetDirectory().GetCString());
44 EXPECT_EQ(nullptr, fs_windows_drive.GetDirectory().GetCString());
141 EXPECT_EQ(forward, backward);
158 EXPECT_EQ(one, two);
174 EXPECT_EQ(one, two);
188 EXPECT_EQ(one, two);
193 EXPECT_EQ(FileSpec::Style::posix, FileSpec::GuessPathStyle("/foo/bar.txt"));
194 EXPECT_EQ(FileSpec::Style::posix, FileSpec::GuessPathStyle("//net/bar.txt"));
195 EXPECT_EQ(FileSpec::Style::windows,
197 EXPECT_EQ(FileSpec::Style::windows,
199 EXPECT_EQ(llvm::None, FileSpec::GuessPathStyle("foo.txt"));
200 EXPECT_EQ(llvm::None, FileSpec::GuessPathStyle("foo/bar.txt"));
233 EXPECT_EQ(test.second,
265 EXPECT_EQ(test.second,
275 EXPECT_EQ("(empty)", llvm::formatv("{0}", F).str());
276 EXPECT_EQ("(empty)", llvm::formatv("{0:D}", F).str());
277 EXPECT_EQ("(empty)", llvm::formatv("{0:F}", F).str());
280 EXPECT_EQ("C:\\foo\\bar.txt", llvm::formatv("{0}", F).str());
281 EXPECT_EQ("C:\\foo\\", llvm::formatv("{0:D}", F).str());
282 EXPECT_EQ("bar.txt", llvm::formatv("{0:F}", F).str());
285 EXPECT_EQ("foo\\bar.txt", llvm::formatv("{0}", F).str());
286 EXPECT_EQ("foo\\", llvm::formatv("{0:D}", F).str());
287 EXPECT_EQ("bar.txt", llvm::formatv("{0:F}", F).str());
290 EXPECT_EQ("foo", llvm::formatv("{0}", F).str());
291 EXPECT_EQ("foo", llvm::formatv("{0:F}", F).str());
292 EXPECT_EQ("(empty)", llvm::formatv("{0:D}", F).str());
tools/lldb/unittests/Utility/FlagsTest.cpp 26 EXPECT_EQ(32U, f.GetBitSize());
32 EXPECT_EQ(0x3U, f.Get());
38 EXPECT_EQ(0x3U, f.Get());
41 EXPECT_EQ(0x2U, f.Get());
44 EXPECT_EQ(0x0U, f.Get());
tools/lldb/unittests/Utility/LogTest.cpp 127 EXPECT_EQ(nullptr, test_channel.GetLogIfAny(FOO));
134 EXPECT_EQ(nullptr, test_channel.GetLogIfAny(FOO));
138 EXPECT_EQ(nullptr, test_channel.GetLogIfAll(FOO));
144 EXPECT_EQ("Invalid log channel 'chanchan'.\n", error);
148 EXPECT_EQ(nullptr, test_channel.GetLogIfAll(BAR));
160 EXPECT_EQ(nullptr, test_channel.GetLogIfAll(FOO));
174 EXPECT_EQ(nullptr, test_channel.GetLogIfAll(FOO));
184 EXPECT_EQ(nullptr, test_channel.GetLogIfAll(BAR));
190 EXPECT_EQ(nullptr, test_channel.GetLogIfAll(BAR));
193 EXPECT_EQ(nullptr, test_channel.GetLogIfAny(FOO | BAR));
206 EXPECT_EQ(expected, list);
209 EXPECT_EQ("Invalid log channel 'chanchan'.\n", list);
214 EXPECT_EQ("Hello World\n", logAndTakeOutput("Hello World"));
217 EXPECT_EQ("Hello World\n", logAndTakeOutput("Hello World"));
224 EXPECT_EQ(1, sscanf(Msg.str().c_str(), "%d Hello World", &seq_no));
241 EXPECT_EQ(llvm::formatv("[{0,0+4}/{1,0+4}] Hello World\n", ::getpid(),
tools/lldb/unittests/Utility/PredicateTest.cpp 30 EXPECT_EQ(0, P.WaitForValueNotEqualTo(1));
31 EXPECT_EQ(llvm::None,
tools/lldb/unittests/Utility/ProcessInfoTest.cpp 17 EXPECT_EQ(ArchSpec("x86_64-pc-linux"), Info.GetArchitecture());
18 EXPECT_EQ(47u, Info.GetProcessID());
tools/lldb/unittests/Utility/RangeTest.cpp 33 EXPECT_EQ(0U, r.GetByteSize());
34 EXPECT_EQ(0U, r.GetRangeBase());
35 EXPECT_EQ(0U, r.GetRangeEnd());
41 EXPECT_EQ(5U, r.GetByteSize());
42 EXPECT_EQ(3U, r.GetRangeBase());
43 EXPECT_EQ(8U, r.GetRangeEnd());
50 EXPECT_EQ(5U, r.GetByteSize());
51 EXPECT_EQ(3U, r.GetRangeBase());
52 EXPECT_EQ(8U, r.GetRangeEnd());
70 EXPECT_EQ(6U, r.GetRangeBase());
71 EXPECT_EQ(11U, r.GetRangeEnd());
72 EXPECT_EQ(5U, r.GetByteSize());
78 EXPECT_EQ(4U, r.GetRangeBase());
79 EXPECT_EQ(9U, r.GetRangeEnd());
80 EXPECT_EQ(5U, r.GetByteSize());
83 EXPECT_EQ(6U, r.GetRangeBase());
84 EXPECT_EQ(11U, r.GetRangeEnd());
85 EXPECT_EQ(5U, r.GetByteSize());
91 EXPECT_EQ(3U, r.GetRangeBase());
92 EXPECT_EQ(8U, r.GetRangeEnd());
93 EXPECT_EQ(5U, r.GetByteSize());
193 EXPECT_EQ(r, RangeT(3, 5));
197 EXPECT_EQ(r, RangeT(3, 5));
201 EXPECT_EQ(r, RangeT(3, 7));
205 EXPECT_EQ(r, RangeT(1, 9));
209 EXPECT_EQ(r, RangeT(1, 10));
213 EXPECT_EQ(r, RangeT(0, 11));
217 EXPECT_EQ(r, RangeT(0, 11));
219 EXPECT_EQ(r, RangeT(0, 11));
221 EXPECT_EQ(r, RangeT(0, 11));
tools/lldb/unittests/Utility/RegisterValueTest.cpp 16 EXPECT_EQ(47u, R8.GetAsUInt8());
18 EXPECT_EQ(42u, R8.GetAsUInt8());
19 EXPECT_EQ(42u, R8.GetAsUInt16());
20 EXPECT_EQ(42u, R8.GetAsUInt32());
21 EXPECT_EQ(42u, R8.GetAsUInt64());
tools/lldb/unittests/Utility/RegularExpressionTest.cpp 20 EXPECT_EQ("^[0-9]+$", r1.GetText());
29 EXPECT_EQ("^[0-9]+$", r2.GetText());
39 EXPECT_EQ("", r1.GetText());
49 EXPECT_EQ("a[b-", r1.GetText());
57 EXPECT_EQ("[0-9]+([a-f])?:([0-9]+)", r1.GetText());
61 EXPECT_EQ(3u, matches.size());
62 EXPECT_EQ("9a:513", matches[0].str());
63 EXPECT_EQ("a", matches[1].str());
64 EXPECT_EQ("513", matches[2].str());
tools/lldb/unittests/Utility/ReproducerInstrumentationTest.cpp 119 EXPECT_EQ(expected_foos, g_foos.size());
120 EXPECT_EQ(expected_bars, g_bars.size());
187 EXPECT_EQ(m_a, 100);
188 EXPECT_EQ(m_b, 200);
190 EXPECT_EQ(m_d, "bar");
192 EXPECT_EQ(g_f, true);
193 EXPECT_EQ(2, m_called);
241 EXPECT_EQ(m_foo_set_by_ptr, m_foo_set_by_ref);
280 EXPECT_EQ(nullptr, index_to_object.GetObjectForIndex<Foo>(1));
281 EXPECT_EQ(nullptr, index_to_object.GetObjectForIndex<Bar>(2));
286 EXPECT_EQ(&foo, index_to_object.GetObjectForIndex<Foo>(1));
287 EXPECT_EQ(&bar, index_to_object.GetObjectForIndex<Bar>(2));
314 EXPECT_EQ(p.a, deserializer.Deserialize<bool>());
315 EXPECT_EQ(p.b, deserializer.Deserialize<bool>());
316 EXPECT_EQ(p.c, deserializer.Deserialize<char>());
317 EXPECT_EQ(p.d, deserializer.Deserialize<float>());
318 EXPECT_EQ(p.e, deserializer.Deserialize<int>());
319 EXPECT_EQ(p.f, deserializer.Deserialize<long long>());
320 EXPECT_EQ(p.g, deserializer.Deserialize<long>());
321 EXPECT_EQ(p.h, deserializer.Deserialize<short>());
322 EXPECT_EQ(p.i, deserializer.Deserialize<unsigned char>());
323 EXPECT_EQ(p.j, deserializer.Deserialize<unsigned int>());
324 EXPECT_EQ(p.k, deserializer.Deserialize<unsigned long long>());
325 EXPECT_EQ(p.l, deserializer.Deserialize<unsigned long>());
326 EXPECT_EQ(p.m, deserializer.Deserialize<unsigned short>());
340 EXPECT_EQ(p.a, *deserializer.Deserialize<bool *>());
341 EXPECT_EQ(p.b, *deserializer.Deserialize<bool *>());
342 EXPECT_EQ(p.c, *deserializer.Deserialize<char *>());
343 EXPECT_EQ(p.d, *deserializer.Deserialize<float *>());
344 EXPECT_EQ(p.e, *deserializer.Deserialize<int *>());
345 EXPECT_EQ(p.f, *deserializer.Deserialize<long long *>());
346 EXPECT_EQ(p.g, *deserializer.Deserialize<long *>());
347 EXPECT_EQ(p.h, *deserializer.Deserialize<short *>());
348 EXPECT_EQ(p.i, *deserializer.Deserialize<unsigned char *>());
349 EXPECT_EQ(p.j, *deserializer.Deserialize<unsigned int *>());
350 EXPECT_EQ(p.k, *deserializer.Deserialize<unsigned long long *>());
351 EXPECT_EQ(p.l, *deserializer.Deserialize<unsigned long *>());
352 EXPECT_EQ(p.m, *deserializer.Deserialize<unsigned short *>());
366 EXPECT_EQ(p.a, deserializer.Deserialize<bool &>());
367 EXPECT_EQ(p.b, deserializer.Deserialize<bool &>());
368 EXPECT_EQ(p.c, deserializer.Deserialize<char &>());
369 EXPECT_EQ(p.d, deserializer.Deserialize<float &>());
370 EXPECT_EQ(p.e, deserializer.Deserialize<int &>());
371 EXPECT_EQ(p.f, deserializer.Deserialize<long long &>());
372 EXPECT_EQ(p.g, deserializer.Deserialize<long &>());
373 EXPECT_EQ(p.h, deserializer.Deserialize<short &>());
374 EXPECT_EQ(p.i, deserializer.Deserialize<unsigned char &>());
375 EXPECT_EQ(p.j, deserializer.Deserialize<unsigned int &>());
376 EXPECT_EQ(p.k, deserializer.Deserialize<unsigned long long &>());
377 EXPECT_EQ(p.l, deserializer.Deserialize<unsigned long &>());
378 EXPECT_EQ(p.m, deserializer.Deserialize<unsigned short &>());
413 EXPECT_EQ(foo, *deserializer.Deserialize<Foo *>());
414 EXPECT_EQ(bar, *deserializer.Deserialize<Bar *>());
434 EXPECT_EQ(foo, deserializer.Deserialize<Foo &>());
435 EXPECT_EQ(bar, deserializer.Deserialize<Bar &>());
tools/lldb/unittests/Utility/ReproducerTest.cpp 51 EXPECT_EQ(nullptr, reproducer.GetGenerator());
52 EXPECT_EQ(nullptr, reproducer.GetLoader());
59 EXPECT_EQ(FileSpec("//bogus/path", FileSpec::Style::posix),
61 EXPECT_EQ(FileSpec("//bogus/path", FileSpec::Style::posix),
68 EXPECT_EQ(nullptr, reproducer.GetLoader());
72 EXPECT_EQ(nullptr, reproducer.GetGenerator());
73 EXPECT_EQ(nullptr, reproducer.GetLoader());
80 EXPECT_EQ(nullptr, reproducer.GetGenerator());
81 EXPECT_EQ(nullptr, reproducer.GetLoader());
91 EXPECT_EQ(FileSpec("//bogus/path", FileSpec::Style::posix),
93 EXPECT_EQ(FileSpec("//bogus/path", FileSpec::Style::posix),
100 EXPECT_EQ(nullptr, reproducer.GetGenerator());
113 EXPECT_EQ(FileSpec("//bogus/path", FileSpec::Style::posix),
129 EXPECT_EQ(provider, provider_alt);
141 EXPECT_EQ(FileSpec("//bogus/path", FileSpec::Style::posix),
145 EXPECT_EQ(&provider, &provider_alt);
tools/lldb/unittests/Utility/ScalarTest.cpp 164 EXPECT_EQ("12345", ScalarGetValue<signed short>(12345));
165 EXPECT_EQ("-12345", ScalarGetValue<signed short>(-12345));
166 EXPECT_EQ("12345", ScalarGetValue<unsigned short>(12345));
167 EXPECT_EQ(std::to_string(std::numeric_limits<unsigned short>::max()),
170 EXPECT_EQ("12345", ScalarGetValue<signed int>(12345));
171 EXPECT_EQ("-12345", ScalarGetValue<signed int>(-12345));
172 EXPECT_EQ("12345", ScalarGetValue<unsigned int>(12345));
173 EXPECT_EQ(std::to_string(std::numeric_limits<unsigned int>::max()),
176 EXPECT_EQ("12345678", ScalarGetValue<signed long>(12345678L));
177 EXPECT_EQ("-12345678", ScalarGetValue<signed long>(-12345678L));
178 EXPECT_EQ("12345678", ScalarGetValue<unsigned long>(12345678UL));
179 EXPECT_EQ(std::to_string(std::numeric_limits<unsigned long>::max()),
182 EXPECT_EQ("1234567890123", ScalarGetValue<signed long long>(1234567890123LL));
183 EXPECT_EQ("-1234567890123",
185 EXPECT_EQ("1234567890123",
187 EXPECT_EQ(std::to_string(std::numeric_limits<unsigned long long>::max()),
196 EXPECT_EQ(r, Scalar(2.5));
221 EXPECT_EQ(lhs + rhs, x);
233 EXPECT_EQ(lhs + rhs, x);
244 EXPECT_EQ(1234567890123ull, a);
249 EXPECT_EQ(-1234567890123ll, a);
273 EXPECT_EQ(A.GetType(), Scalar::e_sint);
277 EXPECT_EQ(B.GetType(), Scalar::GetBestTypeForBitSize(64, true));
279 EXPECT_EQ(C.GetType(), Scalar::e_sint128);
281 EXPECT_EQ(D.GetType(), Scalar::e_sint256);
283 EXPECT_EQ(E.GetType(), Scalar::e_sint512);
297 EXPECT_EQ(S.GetType(), Scalar::e_uint512);
300 EXPECT_EQ(S.GetByteSize(), 64U);
303 EXPECT_EQ(S.GetType(), Scalar::e_sint512);
304 EXPECT_EQ(S.GetByteSize(), 64U);
tools/lldb/unittests/Utility/StateTest.cpp 17 EXPECT_EQ("invalid", llvm::formatv("{0}", eStateInvalid).str());
18 EXPECT_EQ("unloaded", llvm::formatv("{0}", eStateUnloaded).str());
19 EXPECT_EQ("connected", llvm::formatv("{0}", eStateConnected).str());
20 EXPECT_EQ("attaching", llvm::formatv("{0}", eStateAttaching).str());
21 EXPECT_EQ("launching", llvm::formatv("{0}", eStateLaunching).str());
22 EXPECT_EQ("stopped", llvm::formatv("{0}", eStateStopped).str());
23 EXPECT_EQ("running", llvm::formatv("{0}", eStateRunning).str());
24 EXPECT_EQ("stepping", llvm::formatv("{0}", eStateStepping).str());
25 EXPECT_EQ("crashed", llvm::formatv("{0}", eStateCrashed).str());
26 EXPECT_EQ("detached", llvm::formatv("{0}", eStateDetached).str());
27 EXPECT_EQ("exited", llvm::formatv("{0}", eStateExited).str());
28 EXPECT_EQ("suspended", llvm::formatv("{0}", eStateSuspended).str());
tools/lldb/unittests/Utility/StatusTest.cpp 20 EXPECT_EQ("", llvm::formatv("{0}", Status()).str());
21 EXPECT_EQ("Hello Status", llvm::formatv("{0}", Status("Hello Status")).str());
22 EXPECT_EQ("Hello", llvm::formatv("{0:5}", Status("Hello Error")).str());
31 EXPECT_EQ(eErrorTypePOSIX, eagain.GetType());
32 EXPECT_EQ(Status::ValueType(EAGAIN), eagain.GetError());
37 EXPECT_EQ(eErrorTypeGeneric, foo.GetType());
50 EXPECT_EQ(EAGAIN, ec.value());
51 EXPECT_EQ(std::generic_category(), ec.category());
55 EXPECT_EQ("foo", llvm::toString(std::move(foo)));
tools/lldb/unittests/Utility/StreamTeeTest.cpp 27 EXPECT_EQ(s1, tee.GetStreamAtIndex(0U));
37 EXPECT_EQ(s1, tee.GetStreamAtIndex(0U));
38 EXPECT_EQ(s2, tee.GetStreamAtIndex(1U));
49 EXPECT_EQ(s1, tee2.GetStreamAtIndex(0U));
50 EXPECT_EQ(s2, tee2.GetStreamAtIndex(1U));
61 EXPECT_EQ(s1, tee2.GetStreamAtIndex(0U));
62 EXPECT_EQ(s2, tee2.GetStreamAtIndex(1U));
77 EXPECT_EQ("foo", ss1->GetString().str());
78 EXPECT_EQ("foo", ss2->GetString().str());
82 EXPECT_EQ("foobar", ss1->GetString().str());
83 EXPECT_EQ("foobar", ss2->GetString().str());
110 EXPECT_EQ(1U, fs1->m_flush_count);
111 EXPECT_EQ(1U, fs2->m_flush_count);
115 EXPECT_EQ(2U, fs1->m_flush_count);
116 EXPECT_EQ(2U, fs2->m_flush_count);
132 EXPECT_EQ(s1, tee.GetStreamAtIndex(0U));
136 EXPECT_EQ(s1, tee.GetStreamAtIndex(0U));
137 EXPECT_EQ(s2, tee.GetStreamAtIndex(1U));
146 EXPECT_EQ(lldb::StreamSP(), tee.GetStreamAtIndex(1));
153 EXPECT_EQ(lldb::StreamSP(), tee.GetStreamAtIndex(0U));
154 EXPECT_EQ(lldb::StreamSP(), tee.GetStreamAtIndex(1U));
163 EXPECT_EQ(s1, tee.GetStreamAtIndex(0U));
164 EXPECT_EQ(lldb::StreamSP(), tee.GetStreamAtIndex(1U));
168 EXPECT_EQ(1U, tee.GetNumStreams());
169 EXPECT_EQ(s2, tee.GetStreamAtIndex(0U));
170 EXPECT_EQ(lldb::StreamSP(), tee.GetStreamAtIndex(1));
179 EXPECT_EQ(s1, tee.GetStreamAtIndex(0U));
180 EXPECT_EQ(lldb::StreamSP(), tee.GetStreamAtIndex(1U));
187 EXPECT_EQ(5U, tee.GetNumStreams());
189 EXPECT_EQ(s2, tee.GetStreamAtIndex(4U));
192 EXPECT_EQ(s1, tee.GetStreamAtIndex(0U));
194 EXPECT_EQ(lldb::StreamSP(), tee.GetStreamAtIndex(1U));
195 EXPECT_EQ(lldb::StreamSP(), tee.GetStreamAtIndex(2U));
196 EXPECT_EQ(lldb::StreamSP(), tee.GetStreamAtIndex(3U));
197 EXPECT_EQ(lldb::StreamSP(), tee.GetStreamAtIndex(5U));
tools/lldb/unittests/Utility/StreamTest.cpp 41 EXPECT_EQ(lldb::eByteOrderPDP, s.GetByteOrder());
46 EXPECT_EQ(1U, s.GetWrittenBytes());
47 EXPECT_EQ("a", TakeValue());
50 EXPECT_EQ(1U, s.GetWrittenBytes());
51 EXPECT_EQ("1", TakeValue());
56 EXPECT_EQ(1U, s.GetWrittenBytes());
57 EXPECT_EQ(" ", TakeValue());
60 EXPECT_EQ(1U, s.GetWrittenBytes());
61 EXPECT_EQ("\n", TakeValue());
64 EXPECT_EQ(1U, s.GetWrittenBytes());
65 EXPECT_EQ("\r", TakeValue());
68 EXPECT_EQ(1U, s.GetWrittenBytes());
69 EXPECT_EQ("\t", TakeValue());
74 EXPECT_EQ(0U, s.GetWrittenBytes());
75 EXPECT_EQ("", TakeValue());
78 EXPECT_EQ(6U, s.GetWrittenBytes());
79 EXPECT_EQ("foobar", TakeValue());
82 EXPECT_EQ(1U, s.GetWrittenBytes());
83 EXPECT_EQ(" ", TakeValue());
88 EXPECT_EQ(0U, s.GetWrittenBytes());
89 EXPECT_EQ("", TakeValue());
92 EXPECT_EQ(6U, s.GetWrittenBytes());
93 EXPECT_EQ("foobar", TakeValue());
96 EXPECT_EQ(1U, s.GetWrittenBytes());
97 EXPECT_EQ(" ", TakeValue());
102 EXPECT_EQ(5U, s.GetWrittenBytes());
103 EXPECT_EQ(R"("foo")", TakeValue());
106 EXPECT_EQ(6U, s.GetWrittenBytes());
107 EXPECT_EQ(R"("ba r")", TakeValue());
110 EXPECT_EQ(3U, s.GetWrittenBytes());
111 EXPECT_EQ(R"(" ")", TakeValue());
116 EXPECT_EQ(1U, s.GetWrittenBytes());
117 EXPECT_EQ(std::string("\0", 1), TakeValue());
120 EXPECT_EQ(1U, s.GetWrittenBytes());
121 EXPECT_EQ(std::string("a", 1), TakeValue());
126 EXPECT_EQ(0U, s.GetWrittenBytes());
127 EXPECT_EQ("", TakeValue());
130 EXPECT_EQ(12U, s.GetWrittenBytes());
131 EXPECT_EQ("666f6f626172", TakeValue());
134 EXPECT_EQ(2U, s.GetWrittenBytes());
135 EXPECT_EQ("20", TakeValue());
140 EXPECT_EQ(2U, s.GetWrittenBytes());
141 EXPECT_EQ("37", TakeValue());
144 EXPECT_EQ(2U, s.GetWrittenBytes());
145 EXPECT_EQ("ff", TakeValue());
148 EXPECT_EQ(2U, s.GetWrittenBytes());
149 EXPECT_EQ("00", TakeValue());
154 EXPECT_EQ(0U, s.GetWrittenBytes());
155 EXPECT_EQ("", TakeValue());
158 EXPECT_EQ(2U, s.GetWrittenBytes());
159 EXPECT_EQ("37", TakeValue());
162 EXPECT_EQ(4U, s.GetWrittenBytes());
163 EXPECT_EQ("3737", TakeValue());
166 EXPECT_EQ(2U, s.GetWrittenBytes());
167 EXPECT_EQ("38", TakeValue());
172 EXPECT_EQ(4U, s.GetWrittenBytes());
173 EXPECT_EQ("3412", TakeValue());
176 EXPECT_EQ(4U, s.GetWrittenBytes());
177 EXPECT_EQ("ffff", TakeValue());
180 EXPECT_EQ(4U, s.GetWrittenBytes());
181 EXPECT_EQ("0000", TakeValue());
186 EXPECT_EQ(4U, s.GetWrittenBytes());
187 EXPECT_EQ("1234", TakeValue());
190 EXPECT_EQ(4U, s.GetWrittenBytes());
191 EXPECT_EQ("ffff", TakeValue());
194 EXPECT_EQ(4U, s.GetWrittenBytes());
195 EXPECT_EQ("0000", TakeValue());
200 EXPECT_EQ(8U, s.GetWrittenBytes());
201 EXPECT_EQ("78563412", TakeValue());
204 EXPECT_EQ(8U, s.GetWrittenBytes());
205 EXPECT_EQ("ffffffff", TakeValue());
208 EXPECT_EQ(8U, s.GetWrittenBytes());
209 EXPECT_EQ("00000000", TakeValue());
214 EXPECT_EQ(8U, s.GetWrittenBytes());
215 EXPECT_EQ("12345678", TakeValue());
218 EXPECT_EQ(8U, s.GetWrittenBytes());
219 EXPECT_EQ("ffffffff", TakeValue());
222 EXPECT_EQ(8U, s.GetWrittenBytes());
223 EXPECT_EQ("00000000", TakeValue());
228 EXPECT_EQ(16U, s.GetWrittenBytes());
229 EXPECT_EQ("efcdab9078563412", TakeValue());
232 EXPECT_EQ(16U, s.GetWrittenBytes());
233 EXPECT_EQ("ffffffffffffffff", TakeValue());
236 EXPECT_EQ(16U, s.GetWrittenBytes());
237 EXPECT_EQ("0000000000000000", TakeValue());
242 EXPECT_EQ(16U, s.GetWrittenBytes());
243 EXPECT_EQ("1234567890abcdef", TakeValue());
246 EXPECT_EQ(16U, s.GetWrittenBytes());
247 EXPECT_EQ("ffffffffffffffff", TakeValue());
250 EXPECT_EQ(16U, s.GetWrittenBytes());
251 EXPECT_EQ("0000000000000000", TakeValue());
257 EXPECT_EQ(2U, bytes);
259 EXPECT_EQ(4U, bytes);
261 EXPECT_EQ(8U, bytes);
263 EXPECT_EQ(16U, bytes);
264 EXPECT_EQ(30U, s.GetWrittenBytes());
265 EXPECT_EQ("121234123456781234567890abcdef", TakeValue());
271 EXPECT_EQ(2U, bytes);
273 EXPECT_EQ(4U, bytes);
275 EXPECT_EQ(8U, bytes);
277 EXPECT_EQ(16U, bytes);
278 EXPECT_EQ(30U, s.GetWrittenBytes());
279 EXPECT_EQ("12341278563412efcdab9078563412", TakeValue());
286 EXPECT_EQ(2U, s.GetWrittenBytes());
287 EXPECT_EQ("ab", TakeValue());
292 EXPECT_EQ(8U, s.GetWrittenBytes());
294 EXPECT_EQ(24U, s.GetWrittenBytes());
295 EXPECT_EQ("cstring\nllvm::StringRef\n", TakeValue());
303 EXPECT_EQ(40U, s.GetWrittenBytes());
304 EXPECT_EQ("127 32767 2147483647 9223372036854775807", TakeValue());
312 EXPECT_EQ(33U, s.GetWrittenBytes());
313 EXPECT_EQ("ff ffff ffffffff ffffffffffffffff", TakeValue());
352 EXPECT_EQ(8U, s.GetWrittenBytes());
353 EXPECT_EQ("78563412", TakeValue());
360 EXPECT_EQ(4U, s.GetWrittenBytes());
361 EXPECT_EQ("\x78\x56\x34\x12", TakeValue());
368 EXPECT_EQ(8U, s.GetWrittenBytes());
369 EXPECT_EQ("12345678", TakeValue());
376 EXPECT_EQ(4U, s.GetWrittenBytes());
377 EXPECT_EQ("\x12\x34\x56\x78", TakeValue());
408 EXPECT_EQ(1U, s.GetWrittenBytes());
409 EXPECT_EQ("\x74", TakeValue());
410 EXPECT_EQ(1U, bytes);
415 EXPECT_EQ(2U, s.GetWrittenBytes());
416 EXPECT_EQ("\x85\x33", TakeValue());
417 EXPECT_EQ(2U, bytes);
422 EXPECT_EQ(3U, s.GetWrittenBytes());
423 EXPECT_EQ("\xA3\xA0\x1", TakeValue());
424 EXPECT_EQ(3U, bytes);
429 EXPECT_EQ(4U, s.GetWrittenBytes());
430 EXPECT_EQ("\xB2\x80\x92\x5", TakeValue());
431 EXPECT_EQ(4U, bytes);
436 EXPECT_EQ(5U, s.GetWrittenBytes());
437 EXPECT_EQ("\xF8\xAC\xD1\x91\x1", TakeValue());
438 EXPECT_EQ(5U, bytes);
443 EXPECT_EQ(6U, s.GetWrittenBytes());
444 EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\x15", TakeValue());
445 EXPECT_EQ(6U, bytes);
450 EXPECT_EQ(7U, s.GetWrittenBytes());
451 EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\x3", TakeValue());
452 EXPECT_EQ(7U, bytes);
457 EXPECT_EQ(8U, s.GetWrittenBytes());
458 EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\xF3\x3", TakeValue());
459 EXPECT_EQ(8U, bytes);
464 EXPECT_EQ(9U, s.GetWrittenBytes());
465 EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\xF3\x93\x3", TakeValue());
466 EXPECT_EQ(9U, bytes);
471 EXPECT_EQ(10U, s.GetWrittenBytes());
472 EXPECT_EQ("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x1", TakeValue());
473 EXPECT_EQ(10U, bytes);
478 EXPECT_EQ(1U, s.GetWrittenBytes());
479 EXPECT_EQ(std::string("\0", 1), TakeValue());
480 EXPECT_EQ(1U, bytes);
485 EXPECT_EQ(1U, s.GetWrittenBytes());
486 EXPECT_EQ("\x1", TakeValue());
487 EXPECT_EQ(1U, bytes);
494 EXPECT_EQ(2U, s.GetWrittenBytes());
495 EXPECT_EQ(std::string("\xF4\0", 2), TakeValue());
496 EXPECT_EQ(2U, bytes);
501 EXPECT_EQ(2U, s.GetWrittenBytes());
502 EXPECT_EQ("\x85\x33", TakeValue());
503 EXPECT_EQ(2U, bytes);
508 EXPECT_EQ(3U, s.GetWrittenBytes());
509 EXPECT_EQ("\xA3\xA0\x1", TakeValue());
510 EXPECT_EQ(3U, bytes);
515 EXPECT_EQ(4U, s.GetWrittenBytes());
516 EXPECT_EQ("\xB2\x80\x92\x5", TakeValue());
517 EXPECT_EQ(4U, bytes);
522 EXPECT_EQ(5U, s.GetWrittenBytes());
523 EXPECT_EQ("\xF8\xAC\xD1\x91\x1", TakeValue());
524 EXPECT_EQ(5U, bytes);
529 EXPECT_EQ(6U, s.GetWrittenBytes());
530 EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\x15", TakeValue());
531 EXPECT_EQ(6U, bytes);
536 EXPECT_EQ(7U, s.GetWrittenBytes());
537 EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\x3", TakeValue());
538 EXPECT_EQ(7U, bytes);
543 EXPECT_EQ(8U, s.GetWrittenBytes());
544 EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\xF3\x3", TakeValue());
545 EXPECT_EQ(8U, bytes);
550 EXPECT_EQ(9U, s.GetWrittenBytes());
551 EXPECT_EQ("\xDF\xDF\xFE\xF1\xBF\xB5\xF3\x93\x3", TakeValue());
552 EXPECT_EQ(9U, bytes);
557 EXPECT_EQ(10U, s.GetWrittenBytes());
558 EXPECT_EQ(std::string("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0", 10), TakeValue());
559 EXPECT_EQ(10U, bytes);
564 EXPECT_EQ(1U, s.GetWrittenBytes());
565 EXPECT_EQ(std::string("\0", 1), TakeValue());
566 EXPECT_EQ(1U, bytes);
571 EXPECT_EQ(1U, s.GetWrittenBytes());
572 EXPECT_EQ(std::string("\x1", 1), TakeValue());
573 EXPECT_EQ(1U, bytes);
583 EXPECT_EQ(4U, s.GetWrittenBytes());
584 EXPECT_EQ("0x74", TakeValue());
585 EXPECT_EQ(4U, bytes);
590 EXPECT_EQ(6U, s.GetWrittenBytes());
591 EXPECT_EQ("0x6533", TakeValue());
592 EXPECT_EQ(6U, bytes);
tools/lldb/unittests/Utility/StringExtractorTest.cpp 225 EXPECT_EQ(0xab, dst[0]);
226 EXPECT_EQ(0xcd, dst[1]);
227 EXPECT_EQ(0xef, dst[2]);
228 EXPECT_EQ(0x01, dst[3]);
229 EXPECT_EQ(0x23, dst[4]);
230 EXPECT_EQ(0x45, dst[5]);
231 EXPECT_EQ(0x67, dst[6]);
232 EXPECT_EQ(0x89, dst[7]);
248 EXPECT_EQ(0xab, dst[0]);
249 EXPECT_EQ(0xcd, dst[1]);
250 EXPECT_EQ(0xef, dst[2]);
251 EXPECT_EQ(0x01, dst[3]);
252 EXPECT_EQ(0x23, dst[4]);
253 EXPECT_EQ(0x45, dst[5]);
254 EXPECT_EQ(0x67, dst[6]);
255 EXPECT_EQ(0x89, dst[7]);
265 EXPECT_EQ(0xab, dst[0]);
266 EXPECT_EQ(0xcd, dst[1]);
267 EXPECT_EQ(0xef, dst[2]);
268 EXPECT_EQ(0x01, dst[3]);
269 EXPECT_EQ(0x23, dst[4]);
270 EXPECT_EQ(0x45, dst[5]);
271 EXPECT_EQ(0x67, dst[6]);
274 EXPECT_EQ(0xde, dst[7]);
284 EXPECT_EQ(0xab, dst[0]);
285 EXPECT_EQ(0xcd, dst[1]);
286 EXPECT_EQ(0xef, dst[2]);
287 EXPECT_EQ(0x01, dst[3]);
288 EXPECT_EQ(0x23, dst[4]);
289 EXPECT_EQ(0x45, dst[5]);
290 EXPECT_EQ(0x67, dst[6]);
292 EXPECT_EQ(0xde, dst[7]);
302 EXPECT_EQ(0xab, dst[0]);
303 EXPECT_EQ(0xcd, dst[1]);
304 EXPECT_EQ(0xef, dst[2]);
305 EXPECT_EQ(0x01, dst[3]);
306 EXPECT_EQ(0x23, dst[4]);
307 EXPECT_EQ(0x45, dst[5]);
308 EXPECT_EQ(0x67, dst[6]);
309 EXPECT_EQ(0x89, dst[7]);
311 EXPECT_EQ(0xde, dst[8]);
312 EXPECT_EQ(0xde, dst[9]);
313 EXPECT_EQ(0xde, dst[10]);
314 EXPECT_EQ(0xde, dst[11]);
333 EXPECT_EQ(0xab, dst[0]);
334 EXPECT_EQ(0xcd, dst[1]);
335 EXPECT_EQ(0xef, dst[2]);
336 EXPECT_EQ(0x01, dst[3]);
338 EXPECT_EQ(0xab, dst[4]);
339 EXPECT_EQ(0xab, dst[5]);
340 EXPECT_EQ(0xab, dst[6]);
341 EXPECT_EQ(0xab, dst[7]);
342 EXPECT_EQ(0xab, dst[8]);
343 EXPECT_EQ(0xab, dst[9]);
344 EXPECT_EQ(0xab, dst[10]);
345 EXPECT_EQ(0xab, dst[11]);
361 EXPECT_EQ(0xab, dst[0]);
362 EXPECT_EQ(0xcd, dst[1]);
363 EXPECT_EQ(0xef, dst[2]);
364 EXPECT_EQ(0x01, dst[3]);
365 EXPECT_EQ(0x23, dst[4]);
366 EXPECT_EQ(0x45, dst[5]);
367 EXPECT_EQ(0x67, dst[6]);
368 EXPECT_EQ(0x89, dst[7]);
384 EXPECT_EQ(0xab, dst[0]);
385 EXPECT_EQ(0xcd, dst[1]);
386 EXPECT_EQ(0xef, dst[2]);
387 EXPECT_EQ(0x01, dst[3]);
388 EXPECT_EQ(0x23, dst[4]);
389 EXPECT_EQ(0x45, dst[5]);
390 EXPECT_EQ(0x67, dst[6]);
391 EXPECT_EQ(0x89, dst[7]);
401 EXPECT_EQ(0xab, dst[0]);
402 EXPECT_EQ(0xcd, dst[1]);
403 EXPECT_EQ(0xef, dst[2]);
404 EXPECT_EQ(0x01, dst[3]);
405 EXPECT_EQ(0x23, dst[4]);
406 EXPECT_EQ(0x45, dst[5]);
407 EXPECT_EQ(0x67, dst[6]);
417 EXPECT_EQ(0xab, dst[0]);
418 EXPECT_EQ(0xcd, dst[1]);
419 EXPECT_EQ(0xef, dst[2]);
420 EXPECT_EQ(0x01, dst[3]);
421 EXPECT_EQ(0x23, dst[4]);
422 EXPECT_EQ(0x45, dst[5]);
423 EXPECT_EQ(0x67, dst[6]);
434 EXPECT_EQ(0xab, dst[0]);
435 EXPECT_EQ(0xcd, dst[1]);
436 EXPECT_EQ(0xef, dst[2]);
437 EXPECT_EQ(0x01, dst[3]);
438 EXPECT_EQ(0x23, dst[4]);
439 EXPECT_EQ(0x45, dst[5]);
440 EXPECT_EQ(0x67, dst[6]);
441 EXPECT_EQ(0x89, dst[7]);
443 EXPECT_EQ(0xef, dst[8]);
444 EXPECT_EQ(0xef, dst[9]);
445 EXPECT_EQ(0xef, dst[10]);
446 EXPECT_EQ(0xef, dst[11]);
464 EXPECT_EQ(0xab, dst[0]);
465 EXPECT_EQ(0xcd, dst[1]);
466 EXPECT_EQ(0xef, dst[2]);
467 EXPECT_EQ(0x01, dst[3]);
469 EXPECT_EQ(0xab, dst[4]);
470 EXPECT_EQ(0xab, dst[5]);
471 EXPECT_EQ(0xab, dst[6]);
472 EXPECT_EQ(0xab, dst[7]);
473 EXPECT_EQ(0xab, dst[8]);
474 EXPECT_EQ(0xab, dst[9]);
475 EXPECT_EQ(0xab, dst[10]);
476 EXPECT_EQ(0xab, dst[11]);
492 EXPECT_EQ("key1", name);
493 EXPECT_EQ("value1", value);
495 EXPECT_EQ("key2", name);
496 EXPECT_EQ("value2", value);
497 EXPECT_EQ(0u, ex.GetBytesLeft());
507 EXPECT_EQ("key1", name);
508 EXPECT_EQ("value1:value2", value);
510 EXPECT_EQ("key2", name);
511 EXPECT_EQ("value3", value);
512 EXPECT_EQ(0u, ex.GetBytesLeft());
522 EXPECT_EQ(0u, ex.GetBytesLeft());
532 EXPECT_EQ(0u, ex.GetBytesLeft());
537 EXPECT_EQ(0x0ull, ex.GetHexMaxU32(true, 0));
540 EXPECT_EQ(0x0ull, ex.GetHexMaxU32(true, 1));
543 EXPECT_EQ(0x1ull, ex.GetHexMaxU32(true, 0));
546 EXPECT_EQ(0x1ull, ex.GetHexMaxU32(true, 0));
549 EXPECT_EQ(0x100ull, ex.GetHexMaxU32(true, 0));
552 EXPECT_EQ(0x12ull, ex.GetHexMaxU32(true, 0));
555 EXPECT_EQ(0x312ull, ex.GetHexMaxU32(true, 0));
558 EXPECT_EQ(0x312ull, ex.GetHexMaxU32(true, 0));
561 EXPECT_EQ(0x3412ull, ex.GetHexMaxU32(true, 0));
564 EXPECT_EQ(0x3412ull, ex.GetHexMaxU32(true, 0));
567 EXPECT_EQ(0x3412ull, ex.GetHexMaxU32(true, 0));
570 EXPECT_EQ(0x70563412ull, ex.GetHexMaxU32(true, 0));
573 EXPECT_EQ(0ull, ex.GetHexMaxU32(true, 0));
578 EXPECT_EQ(0x0ull, ex.GetHexMaxU32(false, 0));
581 EXPECT_EQ(0x0ull, ex.GetHexMaxU32(false, 1));
584 EXPECT_EQ(0x1ull, ex.GetHexMaxU32(false, 0));
587 EXPECT_EQ(0x1ull, ex.GetHexMaxU32(false, 0));
590 EXPECT_EQ(0x1ull, ex.GetHexMaxU32(false, 0));
593 EXPECT_EQ(0x12ull, ex.GetHexMaxU32(false, 0));
596 EXPECT_EQ(0x123ull, ex.GetHexMaxU32(false, 0));
599 EXPECT_EQ(0x1203ull, ex.GetHexMaxU32(false, 0));
602 EXPECT_EQ(0x1234ull, ex.GetHexMaxU32(false, 0));
605 EXPECT_EQ(0x12340ull, ex.GetHexMaxU32(false, 0));
608 EXPECT_EQ(0x123400ull, ex.GetHexMaxU32(false, 0));
611 EXPECT_EQ(0x12345670ull, ex.GetHexMaxU32(false, 0));
614 EXPECT_EQ(0ull, ex.GetHexMaxU32(false, 0));
619 EXPECT_EQ(0x0ull, ex.GetHexMaxU64(true, 0));
622 EXPECT_EQ(0x0ull, ex.GetHexMaxU64(true, 1));
625 EXPECT_EQ(0x1ull, ex.GetHexMaxU64(true, 0));
628 EXPECT_EQ(0x1ull, ex.GetHexMaxU64(true, 0));
631 EXPECT_EQ(0x100ull, ex.GetHexMaxU64(true, 0));
634 EXPECT_EQ(0x12ull, ex.GetHexMaxU64(true, 0));
637 EXPECT_EQ(0x312ull, ex.GetHexMaxU64(true, 0));
640 EXPECT_EQ(0x312ull, ex.GetHexMaxU64(true, 0));
643 EXPECT_EQ(0x3412ull, ex.GetHexMaxU64(true, 0));
646 EXPECT_EQ(0x3412ull, ex.GetHexMaxU64(true, 0));
649 EXPECT_EQ(0x3412ull, ex.GetHexMaxU64(true, 0));
652 EXPECT_EQ(0xF0DEBC9A78563412ULL, ex.GetHexMaxU64(true, 0));
655 EXPECT_EQ(0ull, ex.GetHexMaxU64(true, 0));
660 EXPECT_EQ(0x0ull, ex.GetHexMaxU64(false, 0));
663 EXPECT_EQ(0x0ull, ex.GetHexMaxU64(false, 1));
666 EXPECT_EQ(0x1ull, ex.GetHexMaxU64(false, 0));
669 EXPECT_EQ(0x1ull, ex.GetHexMaxU64(false, 0));
672 EXPECT_EQ(0x1ull, ex.GetHexMaxU64(false, 0));
675 EXPECT_EQ(0x12ull, ex.GetHexMaxU64(false, 0));
678 EXPECT_EQ(0x123ull, ex.GetHexMaxU64(false, 0));
681 EXPECT_EQ(0x1203ull, ex.GetHexMaxU64(false, 0));
684 EXPECT_EQ(0x1234ull, ex.GetHexMaxU64(false, 0));
687 EXPECT_EQ(0x12340ull, ex.GetHexMaxU64(false, 0));
690 EXPECT_EQ(0x123400ull, ex.GetHexMaxU64(false, 0));
693 EXPECT_EQ(0x123456789ABCDEF0ULL, ex.GetHexMaxU64(false, 0));
696 EXPECT_EQ(0ull, ex.GetHexMaxU64(false, 0));
tools/lldb/unittests/Utility/StringLexerTest.cpp 16 EXPECT_EQ("foo", l.GetUnlexed());
18 EXPECT_EQ("oo", l.GetUnlexed());
21 EXPECT_EQ("", l.GetUnlexed());
69 EXPECT_EQ("foo", l.GetUnlexed());
75 EXPECT_EQ("oo", l.GetUnlexed());
78 EXPECT_EQ("foo", l.GetUnlexed());
84 EXPECT_EQ('f', l.Peek());
86 EXPECT_EQ('o', l.Peek());
88 EXPECT_EQ('o', l.Peek());
93 EXPECT_EQ('f', l.Next());
94 EXPECT_EQ('o', l.Next());
95 EXPECT_EQ('o', l.Next());
127 EXPECT_EQ('f', r.second);
133 EXPECT_EQ('o', r.second);
139 EXPECT_EQ('o', r.second);
tools/lldb/unittests/Utility/StringListTest.cpp 18 EXPECT_EQ(0U, s.GetSize());
121 EXPECT_EQ(0U, s.GetSize());
129 EXPECT_EQ(3U, s.GetSize());
146 EXPECT_EQ(3U, s.GetSize());
151 EXPECT_EQ(3U, other.GetSize());
158 EXPECT_EQ(6U, s.GetSize());
166 EXPECT_EQ(3U, other.GetSize());
175 EXPECT_EQ(1U, s.GetSize());
178 EXPECT_EQ(2U, s.GetSize());
181 EXPECT_EQ(3U, s.GetSize());
187 EXPECT_EQ(3U, s.GetSize());
196 EXPECT_EQ(4U, s.GetSize());
206 EXPECT_EQ(1U, s.GetSize());
213 EXPECT_EQ(0U, s.GetSize());
219 EXPECT_EQ("", prefix);
230 EXPECT_EQ("foo", prefix);
238 EXPECT_EQ("foo", prefix);
247 EXPECT_EQ("foo", prefix);
258 EXPECT_EQ("", prefix);
264 EXPECT_EQ(0U, s.GetSize());
268 EXPECT_EQ(0U, s.GetSize());
273 EXPECT_EQ(0U, s.GetSize());
283 EXPECT_EQ(2U, s.GetSize());
288 EXPECT_EQ(1U, s.GetSize());
292 EXPECT_EQ(0U, s.GetSize());
300 EXPECT_EQ(0U, s.GetSize());
317 EXPECT_EQ(3U, s.GetSize());
327 EXPECT_EQ(1U, s.GetSize());
331 EXPECT_EQ(2U, s.GetSize());
340 EXPECT_EQ(1U, s.GetSize());
344 EXPECT_EQ(2U, s.GetSize());
353 EXPECT_EQ(1U, s.GetSize());
359 EXPECT_EQ(2U, s.GetSize());
369 EXPECT_EQ(1U, s.GetSize());
378 EXPECT_EQ(1U, s.GetSize());
385 EXPECT_EQ("", s.CopyList());
386 EXPECT_EQ("", s.CopyList("+"));
393 EXPECT_EQ("ab", s.CopyList());
394 EXPECT_EQ("-ab", s.CopyList("-"));
402 EXPECT_EQ("ab\ncd", s.CopyList());
403 EXPECT_EQ("-ab\n-cd", s.CopyList("-"));
414 EXPECT_EQ("ab cd", ss.GetString());
423 EXPECT_EQ("", ss.GetString());
433 EXPECT_EQ("foo", ss.GetString());
445 EXPECT_EQ("1 2 3", ss.GetString());
457 EXPECT_EQ("1.2.3", ss.GetString());
469 EXPECT_EQ("1--2--3", ss.GetString());
476 EXPECT_EQ(3U, s.GetMaxStringLength());
483 EXPECT_EQ(4U, s.GetMaxStringLength());
490 EXPECT_EQ(4U, s.GetMaxStringLength());
501 EXPECT_EQ(4U, s.GetMaxStringLength());
506 EXPECT_EQ(0U, s.GetMaxStringLength());
tools/lldb/unittests/Utility/StructuredDataTest.cpp 30 EXPECT_EQ(P.second, S.GetString());
38 EXPECT_EQ(nullptr, object_sp);
46 EXPECT_EQ("[1,2,3]", S.GetString());
tools/lldb/unittests/Utility/TildeExpressionResolverTest.cpp 20 EXPECT_EQ("/james", Result);
22 EXPECT_EQ("/james/", Result);
25 EXPECT_EQ("/james/bar/baz", Result);
28 EXPECT_EQ("/jason/", Result);
31 EXPECT_EQ("/lars", Result);
tools/lldb/unittests/Utility/TimeoutTest.cpp 19 EXPECT_EQ(seconds(0), *Timeout<std::micro>(seconds(0)));
20 EXPECT_EQ(seconds(3), *Timeout<std::micro>(seconds(3)));
25 EXPECT_EQ("<infinite>",
27 EXPECT_EQ("1000 ms",
tools/lldb/unittests/Utility/TimerTest.cpp 105 EXPECT_EQ(1, count1);
107 EXPECT_EQ(2, count2);
tools/lldb/unittests/Utility/UUIDTest.cpp 22 EXPECT_EQ(empty, empty);
23 EXPECT_EQ(a16, a16);
24 EXPECT_EQ(a20, a20);
60 EXPECT_EQ(32u, u.SetFromStringRef("404142434445464748494a4b4c4d4e4f"));
61 EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNO", 16), u);
63 EXPECT_EQ(36u, u.SetFromStringRef("40-41-42-43-4445464748494a4b4c4d4e4f"));
64 EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNO", 16), u);
66 EXPECT_EQ(45u, u.SetFromStringRef(
68 EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNOPQRS", 20), u);
70 EXPECT_EQ(0u, u.SetFromStringRef("40-41-42-43-4445464748494a4b4c4d4e4f", 20));
71 EXPECT_EQ(0u, u.SetFromStringRef("40xxxxx"));
72 EXPECT_EQ(0u, u.SetFromStringRef(""));
73 EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNOPQRS", 20), u)
76 EXPECT_EQ(
78 EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNO", 16), u);
82 EXPECT_EQ("40414243", UUID::fromData("@ABC", 4).GetAsString());
83 EXPECT_EQ("40414243-4445-4647", UUID::fromData("@ABCDEFG", 8).GetAsString());
84 EXPECT_EQ("40414243-4445-4647-4849-4A4B",
86 EXPECT_EQ("40414243-4445-4647-4849-4A4B4C4D4E4F",
88 EXPECT_EQ("40414243-4445-4647-4849-4A4B4C4D4E4F-50515253",
tools/lldb/unittests/Utility/UriParserTest.cpp 54 EXPECT_EQ(testCase.m_result, result);
58 EXPECT_EQ(testCase.m_port, port);
91 EXPECT_EQ(testCase.m_result, result);
95 EXPECT_EQ(testCase.m_port, port);
tools/lldb/unittests/Utility/UserIDResolverTest.cpp 30 EXPECT_EQ(user47, r.GetUserName(47));
31 EXPECT_EQ(user47, r.GetUserName(47));
32 EXPECT_EQ(llvm::None, r.GetUserName(42));
33 EXPECT_EQ(llvm::None, r.GetUserName(42));
43 EXPECT_EQ(group47, r.GetGroupName(47));
44 EXPECT_EQ(group47, r.GetGroupName(47));
45 EXPECT_EQ(llvm::None, r.GetGroupName(42));
46 EXPECT_EQ(llvm::None, r.GetGroupName(42));
tools/lldb/unittests/Utility/VASprintfTest.cpp 39 EXPECT_EQ(TestStr.size(), BigBuffer.size());
47 EXPECT_EQ(TestStr.size(), SmallBuffer.size());
62 EXPECT_EQ("<Encoding error>", Buffer);
tools/lldb/unittests/Utility/VMRangeTest.cpp 38 EXPECT_EQ(VMRange(), range);
44 EXPECT_EQ(range1, range2);
66 EXPECT_EQ(0U, range.GetByteSize());
70 EXPECT_EQ(1U, range.GetByteSize());
tools/polly/unittests/DeLICM/DeLICMTest.cpp 143 EXPECT_EQ(Result,
147 EXPECT_EQ(Result,
151 EXPECT_EQ(Result, isConflicting({}, ExistingUnused, ExistingKnown,
205 EXPECT_EQ(Forward, Backward);
215 EXPECT_EQ(Forward, Backward);
tools/polly/unittests/Isl/IslTest.cpp 117 EXPECT_EQ(IslNTwo, IslNTwoCmp);
141 EXPECT_EQ(0, IslTwo.cmp_si(2));
148 EXPECT_EQ(IslNOne, IslRef);
157 EXPECT_EQ(IslLarge, IslRef);
170 EXPECT_EQ(1, APNOne);
171 EXPECT_EQ(1u, APNOne.getBitWidth());
178 EXPECT_EQ(2, APNTwo);
179 EXPECT_EQ(2u, APNTwo.getBitWidth());
186 EXPECT_EQ(5, APNThree);
187 EXPECT_EQ(3u, APNThree.getBitWidth());
194 EXPECT_EQ(4, APNFour);
195 EXPECT_EQ(3u, APNFour.getBitWidth());
201 EXPECT_EQ(0, APZero);
202 EXPECT_EQ(1u, APZero.getBitWidth());
208 EXPECT_EQ(1, APOne);
209 EXPECT_EQ(2u, APOne.getBitWidth());
215 EXPECT_EQ(2, APTwo);
216 EXPECT_EQ(3u, APTwo.getBitWidth());
222 EXPECT_EQ(3, APThree);
223 EXPECT_EQ(3u, APThree.getBitWidth());
229 EXPECT_EQ(4, APFour);
230 EXPECT_EQ(4u, APFour.getBitWidth());
236 EXPECT_EQ((1ull << 32) - 1, APNOne);
237 EXPECT_EQ(33u, APNOne.getBitWidth());
245 EXPECT_EQ((1ull << 60) - 1, APLargeNum);
246 EXPECT_EQ(61u, APLargeNum.getBitWidth());
254 EXPECT_EQ(502u, APLargePow2.getBitWidth());
255 EXPECT_EQ(502u, APLargePow2.getMinSignedBits());
262 EXPECT_EQ(501u, APLargeNPow2.getBitWidth());
263 EXPECT_EQ(501u, APLargeNPow2.getMinSignedBits());
264 EXPECT_EQ(500, (-APLargeNPow2).exactLogBase2());
272 EXPECT_EQ(514u, APLargePow2.getBitWidth());
273 EXPECT_EQ(514u, APLargePow2.getMinSignedBits());
280 EXPECT_EQ(513u, APLargeNPow2.getBitWidth());
281 EXPECT_EQ(513u, APLargeNPow2.getMinSignedBits());
282 EXPECT_EQ(512, (-APLargeNPow2).exactLogBase2());
315 EXPECT_EQ(AffOne + AffOne, AffTwo);
316 EXPECT_EQ(AffOne + 1, AffTwo);
317 EXPECT_EQ(1 + AffOne, AffTwo);
318 EXPECT_EQ(AffOne + ValOne, AffTwo);
319 EXPECT_EQ(ValOne + AffOne, AffTwo);
324 EXPECT_EQ(AffTwo * AffTwo, AffFour);
325 EXPECT_EQ(AffTwo * 2, AffFour);
326 EXPECT_EQ(2 * AffTwo, AffFour);
327 EXPECT_EQ(AffTwo * ValTwo, AffFour);
328 EXPECT_EQ(ValTwo * AffTwo, AffFour);
333 EXPECT_EQ(AffTwo - AffOne, AffOne);
334 EXPECT_EQ(AffTwo - 1, AffOne);
335 EXPECT_EQ(2 - AffOne, AffOne);
336 EXPECT_EQ(AffTwo - ValOne, AffOne);
337 EXPECT_EQ(ValTwo - AffOne, AffOne);
342 EXPECT_EQ(AffFour / AffTwo, AffTwo);
343 EXPECT_EQ(AffFour / 2, AffTwo);
344 EXPECT_EQ(4 / AffTwo, AffTwo);
345 EXPECT_EQ(AffFour / ValTwo, AffTwo);
346 EXPECT_EQ(AffFour / 2, AffTwo);
349 EXPECT_EQ(AffNegFour / AffThree, AffNegOne);
350 EXPECT_EQ(AffNegFour / 3, AffNegOne);
351 EXPECT_EQ((-4) / AffThree, AffNegOne);
352 EXPECT_EQ(AffNegFour / ValThree, AffNegOne);
353 EXPECT_EQ(AffNegFour / 3, AffNegOne);
356 EXPECT_EQ(AffFour / AffNegThree, AffNegOne);
357 EXPECT_EQ(AffFour / -3, AffNegOne);
358 EXPECT_EQ(4 / AffNegThree, AffNegOne);
359 EXPECT_EQ(AffFour / ValNegThree, AffNegOne);
360 EXPECT_EQ(AffFour / -3, AffNegOne);
365 EXPECT_EQ(AffThree % AffTwo, AffOne);
366 EXPECT_EQ(AffThree % 2, AffOne);
367 EXPECT_EQ(3 % AffTwo, AffOne);
368 EXPECT_EQ(AffThree % ValTwo, AffOne);
369 EXPECT_EQ(ValThree % AffTwo, AffOne);
372 EXPECT_EQ(AffNegFour % AffThree, AffNegOne);
373 EXPECT_EQ(AffNegFour % 3, AffNegOne);
374 EXPECT_EQ((-4) % AffThree, AffNegOne);
375 EXPECT_EQ(AffNegFour % ValThree, AffNegOne);
376 EXPECT_EQ(AffNegFour % 3, AffNegOne);
379 EXPECT_EQ(AffFour % AffNegThree, AffOne);
380 EXPECT_EQ(AffFour % -3, AffOne);
381 EXPECT_EQ(4 % AffNegThree, AffOne);
382 EXPECT_EQ(AffFour % ValNegThree, AffOne);
383 EXPECT_EQ(AffFour % -3, AffOne);
407 EXPECT_EQ(BMap, TestBMap);
413 EXPECT_EQ(1, NumBMaps);
420 EXPECT_EQ(BSet, TestBSet);
425 EXPECT_EQ(1, NumBSets);
431 EXPECT_EQ(Map, TestMap);
436 EXPECT_EQ(1, NumMaps);
442 EXPECT_EQ(Set, TestSet);
447 EXPECT_EQ(1, NumSets);
459 EXPECT_EQ(1, NumPwAffs);
466 EXPECT_EQ(BMap, TestBMap);
471 EXPECT_EQ(1, NumBMaps);
478 EXPECT_EQ(Map, TestMap);
483 EXPECT_EQ(1, NumMaps);
491 EXPECT_EQ(Domain, TestSet);
497 EXPECT_EQ(1, NumPieces);
506 EXPECT_EQ(MAP("{ [] -> [i] : i <= 0 }"),
508 EXPECT_EQ(MAP("{ [] -> [i] : i < 0 }"),
512 EXPECT_EQ(UMAP("{ A[] -> [i] : i <= 0; B[] -> [i] : i <= 0 }"),
514 EXPECT_EQ(UMAP("{ A[] -> [i] : i < 0; B[] -> [i] : i < 0 }"),
518 EXPECT_EQ(UMAP("{ [] -> [i, j] : i < 0; [] -> [i, j] : i = 0 and j <= 0 }"),
520 EXPECT_EQ(UMAP("{ [] -> [i, j] : i < 0; [] -> [i, j] : i = 0 and j < 0 }"),
524 EXPECT_EQ(UMAP("{ [i] -> [j] : j <= i }"),
526 EXPECT_EQ(UMAP("{ [i] -> [j] : j < i }"),
530 EXPECT_EQ(UMAP("[i] -> { [] -> [j] : j <= i }"),
532 EXPECT_EQ(UMAP("[i] -> { [] -> [j] : j < i }"),
536 EXPECT_EQ(UMAP("{ [] -> [i] : i <= 10 }"),
538 EXPECT_EQ(UMAP("{ [] -> [i] : i < 10 }"),
542 EXPECT_EQ(UMAP("{ [] -> [i] : 1 = 0 }"),
544 EXPECT_EQ(UMAP("{ [] -> [i] : 1 = 0 }"),
553 EXPECT_EQ(MAP("{ [] -> [i] : i >= 0 }"),
555 EXPECT_EQ(MAP("{ [] -> [i] : i > 0 }"),
559 EXPECT_EQ(UMAP("{ A[] -> [i] : i >= 0; B[] -> [i] : i >= 0 }"),
561 EXPECT_EQ(UMAP("{ A[] -> [i] : i > 0; B[] -> [i] : i > 0 }"),
565 EXPECT_EQ(UMAP("{ [] -> [i, j] : i > 0; [] -> [i, j] : i = 0 and j >= 0 }"),
567 EXPECT_EQ(UMAP("{ [] -> [i, j] : i > 0; [] -> [i, j] : i = 0 and j > 0 }"),
571 EXPECT_EQ(UMAP("{ [i] -> [j] : j >= i }"),
573 EXPECT_EQ(UMAP("{ [i] -> [j] : j > i }"),
577 EXPECT_EQ(UMAP("[i] -> { [] -> [j] : j >= i }"),
579 EXPECT_EQ(UMAP("[i] -> { [] -> [j] : j > i }"),
583 EXPECT_EQ(UMAP("{ [] -> [i] : i >= 0 }"),
585 EXPECT_EQ(UMAP("{ [] -> [i] : i > 0 }"),
589 EXPECT_EQ(UMAP("{ }"), afterScatter(UMAP("{ }"), false));
590 EXPECT_EQ(UMAP("{ }"), afterScatter(UMAP("{ }"), true));
598 EXPECT_EQ(MAP("{ [] -> [i] : 0 < i < 10 }"),
601 EXPECT_EQ(
604 EXPECT_EQ(
607 EXPECT_EQ(
612 EXPECT_EQ(UMAP("{ A[] -> [i] : 0 < i < 10; B[] -> [i] : 0 < i < 10 }"),
615 EXPECT_EQ(UMAP("{ A[] -> [i] : 0 <= i < 10; B[] -> [i] : 0 <= i < 10 }"),
618 EXPECT_EQ(UMAP("{ A[] -> [i] : 0 < i <= 10; B[] -> [i] : 0 < i <= 10 }"),
621 EXPECT_EQ(UMAP("{ A[] -> [i] : 0 <= i <= 10; B[] -> [i] : 0 <= i <= 10 }"),
631 EXPECT_EQ(SET("{ [] : 1 = 0 }"), singleton(USET("{ }"), SPACE("{ [] }")));
632 EXPECT_EQ(MAP("{ [] -> [] : 1 = 0 }"),
636 EXPECT_EQ(SET("{ [] }"), singleton(USET("{ [] }"), SPACE("{ [] }")));
637 EXPECT_EQ(MAP("{ [] -> [] }"),
641 EXPECT_EQ(SET("{ [i] : 0 <= i < 10 }"),
643 EXPECT_EQ(
648 EXPECT_EQ(SET("[i] -> { [i] }"),
650 EXPECT_EQ(MAP("[i] -> { [i] -> [i] }"),
659 EXPECT_EQ(0u, getNumScatterDims(UMAP("{ [] -> [] }")));
660 EXPECT_EQ(1u, getNumScatterDims(UMAP("{ [] -> [i] }")));
661 EXPECT_EQ(2u, getNumScatterDims(UMAP("{ [] -> [i,j] }")));
662 EXPECT_EQ(3u, getNumScatterDims(UMAP("{ [] -> [i,j,k] }")));
665 EXPECT_EQ(0u, getNumScatterDims(UMAP("{ A[] -> []; [] -> []}")));
666 EXPECT_EQ(1u, getNumScatterDims(UMAP("{ A[] -> []; [] -> [i] }")));
667 EXPECT_EQ(2u, getNumScatterDims(UMAP("{ A[] -> [i]; [] -> [i,j] }")));
668 EXPECT_EQ(3u, getNumScatterDims(UMAP("{ A[] -> [i]; [] -> [i,j,k] }")));
676 EXPECT_EQ(SPACE("{ [] }"), getScatterSpace(UMAP("{ [] -> [] }")));
677 EXPECT_EQ(SPACE("{ [i] }"), getScatterSpace(UMAP("{ [] -> [i] }")));
678 EXPECT_EQ(SPACE("{ [i,j] }"), getScatterSpace(UMAP("{ [] -> [i,j] }")));
679 EXPECT_EQ(SPACE("{ [i,j,k] }"), getScatterSpace(UMAP("{ [] -> [i,j,k] }")));
682 EXPECT_EQ(SPACE("{ [] }"), getScatterSpace(UMAP("{ A[] -> []; [] -> [] }")));
683 EXPECT_EQ(SPACE("{ [i] }"),
685 EXPECT_EQ(SPACE("{ [i,j] }"),
687 EXPECT_EQ(SPACE("{ [i,j,k] }"),
696 EXPECT_EQ(UMAP("{ [i] -> [i] }"), makeIdentityMap(USET("{ [0] }"), false));
697 EXPECT_EQ(UMAP("{ [0] -> [0] }"), makeIdentityMap(USET("{ [0] }"), true));
700 EXPECT_EQ(UMAP("{ [] -> []; [i] -> [i] }"),
702 EXPECT_EQ(UMAP("{ [] -> []; [0] -> [0] }"),
706 EXPECT_EQ(UMAP("{ }"), makeIdentityMap(USET("{ }"), false));
707 EXPECT_EQ(UMAP("{ }"), makeIdentityMap(USET("{ }"), true));
715 EXPECT_EQ(MAP("{ [B[] -> A[]] -> [] }"),
717 EXPECT_EQ(UMAP("{ [B[] -> A[]] -> [] }"),
726 EXPECT_EQ(SET("{ [1] }"), shiftDim(SET("{ [0] }"), 0, 1));
727 EXPECT_EQ(USET("{ [1] }"), shiftDim(USET("{ [0] }"), 0, 1));
730 EXPECT_EQ(USET("{ [0,0,1] }"), shiftDim(USET("{ [0,0,0] }"), -1, 1));
731 EXPECT_EQ(USET("{ [0,1,0] }"), shiftDim(USET("{ [0,0,0] }"), -2, 1));
732 EXPECT_EQ(USET("{ [1,0,0] }"), shiftDim(USET("{ [0,0,0] }"), -3, 1));
735 EXPECT_EQ(USET("[n] -> { [n+1] }"), shiftDim(USET("[n] -> { [n] }"), 0, 1));
738 EXPECT_EQ(MAP("{ [1] -> [] }"),
740 EXPECT_EQ(UMAP("{ [1] -> [] }"),
742 EXPECT_EQ(MAP("{ [] -> [1] }"),
744 EXPECT_EQ(UMAP("{ [] -> [1] }"),
753 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : 0 < i }"),
757 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : 0 < i }"),
761 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : 0 <= i }"),
765 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : 0 <= i }"),
770 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : i < 0 }"),
774 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : i <= 0 }"),
778 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : i < 0 }"),
782 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[] : i <= 0 }"),
787 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom1[] : 0 < i < 10; [Elt[] -> [i]] -> "
792 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom1[] : 0 <= i < 10; [Elt[] -> [i]] -> "
797 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom1[] : 0 < i <= 10; [Elt[] -> [i]] -> "
802 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom1[] : 0 <= i <= 10; [Elt[] -> [i]] -> "
808 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom2[] : 0 < i < 10; [Elt[] -> [i]] -> "
813 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom2[] : 0 <= i < 10; [Elt[] -> [i]] -> "
818 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom2[] : 0 < i <= 10; [Elt[] -> [i]] -> "
823 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom2[] : 0 <= i <= 10; [Elt[] -> [i]] -> "
830 EXPECT_EQ(UMAP("{ [Elt[] -> [i]] -> Dom[1] : 0 < i <= 10; [Elt[] -> [i]] -> "
837 EXPECT_EQ(UMAP("[p] -> { [Elt[] -> [i]] -> Dom[] : p < i }"),
843 EXPECT_EQ(
862 EXPECT_EQ(UMAP("{ Elt[] -> [i] : 0 < i < 10 }"),
867 EXPECT_EQ(UMAP("{ Elt[] -> [i] : 0 < i <= 10 }"),
872 EXPECT_EQ(UMAP("{ Elt[] -> [i] : 0 <= i < 10 }"),
877 EXPECT_EQ(UMAP("{ Elt[] -> [i] : 0 <= i <= 10 }"),
884 EXPECT_EQ(UMAP("{ Elt[] -> [i] : 0 < i <= 10 }"),
891 EXPECT_EQ(UMAP("{}"),
897 EXPECT_EQ(UMAP("{ Elt[] -> [i] : i <= 0 }"),
903 EXPECT_EQ(
911 EXPECT_EQ(
920 EXPECT_EQ(
928 EXPECT_EQ(UMAP("{ Elt[] -> [i] : i <= 0 }"),
935 EXPECT_EQ(UMAP("{ Elt[] -> [i] : 0 < i <= 10 }"),
943 EXPECT_EQ(
951 EXPECT_EQ(
961 EXPECT_EQ(UMAP("{ Elt[] -> [i] : i < 0 }"),
965 EXPECT_EQ(UMAP("{ Elt[] -> [i] : i <= 0 }"),
969 EXPECT_EQ(UMAP("{ Elt[] -> [0] }"),
980 EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{}"), false, false));
981 EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{}"), true, false));
982 EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{}"), false, true));
983 EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{}"), true, true));
986 EXPECT_EQ(USET("{}"), convertZoneToTimepoints(USET("{ [1] }"), false, false));
987 EXPECT_EQ(USET("{ [0] }"),
989 EXPECT_EQ(USET("{ [1] }"),
991 EXPECT_EQ(USET("{ [0]; [1] }"),
995 EXPECT_EQ(USET("{}"),
997 EXPECT_EQ(USET("{ [0]; [10] }"),
999 EXPECT_EQ(USET("{ [1]; [11] }"),
1001 EXPECT_EQ(USET("{ [0]; [1]; [10]; [11] }"),
1005 EXPECT_EQ(
1008 EXPECT_EQ(
1011 EXPECT_EQ(
1014 EXPECT_EQ(USET("{ [i] : 0 <= i <= 10 }"),
1018 EXPECT_EQ(USET("{}"),
1020 EXPECT_EQ(USET("{ [0,0] }"),
1022 EXPECT_EQ(USET("{ [0,1] }"),
1024 EXPECT_EQ(USET("{ [0,0]; [0,1] }"),
1028 EXPECT_EQ(UMAP("{}"), convertZoneToTimepoints(UMAP("{ [1] -> [] }"),
1030 EXPECT_EQ(UMAP("{ [0] -> [] }"),
1033 EXPECT_EQ(UMAP("{ [1] -> [] }"),
1036 EXPECT_EQ(
1041 EXPECT_EQ(UMAP("{}"), convertZoneToTimepoints(UMAP("{ [] -> [1] }"),
1043 EXPECT_EQ(UMAP("{ [] -> [0] }"),
1046 EXPECT_EQ(UMAP("{ [] -> [1] }"),
1049 EXPECT_EQ(UMAP("{ [] -> [0]; [] -> [1] }"),
1059 EXPECT_EQ(MAP("{ [Domain[] -> Range1[]] -> [Domain[] -> Range2[]] }"),
1061 EXPECT_EQ(
1066 EXPECT_EQ(
1080 EXPECT_EQ(UMAP("{ [Factor[] -> Domain[]] -> [Factor[] -> Range[]] }"),
1082 EXPECT_EQ(UMAP("{ [Factor[l] -> Domain[i,k]] -> [Factor[l] -> Range[j,k]] }"),
1087 EXPECT_EQ(
1101 EXPECT_EQ(
1105 EXPECT_EQ(
1112 EXPECT_EQ(UMAP("{ [DomainDomainA[] -> NewDomainRangeA[]] -> RangeA[];"
unittests/ADT/APFloatTest.cpp 77 EXPECT_EQ(test.next(false), APFloat::opOK);
85 EXPECT_EQ(test.next(true), APFloat::opOK);
92 EXPECT_EQ(test.next(false), APFloat::opOK);
99 EXPECT_EQ(test.next(true), APFloat::opOK);
106 EXPECT_EQ(test.next(false), APFloat::opOK);
116 EXPECT_EQ(test.next(true), APFloat::opOK);
124 EXPECT_EQ(test.next(false), APFloat::opOK);
130 EXPECT_EQ(test.next(true), APFloat::opOK);
138 EXPECT_EQ(test.next(false), APFloat::opOK);
144 EXPECT_EQ(test.next(true), APFloat::opOK);
151 EXPECT_EQ(test.next(false), APFloat::opOK);
159 EXPECT_EQ(test.next(true), APFloat::opOK);
165 EXPECT_EQ(test.next(false), APFloat::opOK);
171 EXPECT_EQ(test.next(true), APFloat::opOK);
177 EXPECT_EQ(test.next(false), APFloat::opInvalidOp);
183 EXPECT_EQ(test.next(true), APFloat::opInvalidOp);
189 EXPECT_EQ(test.next(false), APFloat::opOK);
195 EXPECT_EQ(test.next(true), APFloat::opOK);
201 EXPECT_EQ(test.next(false), APFloat::opOK);
207 EXPECT_EQ(test.next(true), APFloat::opOK);
222 EXPECT_EQ(test.next(false), APFloat::opOK);
231 EXPECT_EQ(test.next(true), APFloat::opOK);
240 EXPECT_EQ(test.next(false), APFloat::opOK);
249 EXPECT_EQ(test.next(true), APFloat::opOK);
263 EXPECT_EQ(test.next(false), APFloat::opOK);
269 EXPECT_EQ(test.next(true), APFloat::opOK);
275 EXPECT_EQ(test.next(false), APFloat::opOK);
281 EXPECT_EQ(test.next(true), APFloat::opOK);
299 EXPECT_EQ(test.next(false), APFloat::opOK);
308 EXPECT_EQ(test.next(true), APFloat::opOK);
317 EXPECT_EQ(test.next(false), APFloat::opOK);
326 EXPECT_EQ(test.next(true), APFloat::opOK);
344 EXPECT_EQ(test.next(false), APFloat::opOK);
351 EXPECT_EQ(test.next(true), APFloat::opOK);
357 EXPECT_EQ(test.next(false), APFloat::opOK);
364 EXPECT_EQ(test.next(true), APFloat::opOK);
383 EXPECT_EQ(test.next(false), APFloat::opOK);
393 EXPECT_EQ(test.next(true), APFloat::opOK);
403 EXPECT_EQ(test.next(false), APFloat::opOK);
413 EXPECT_EQ(test.next(true), APFloat::opOK);
423 EXPECT_EQ(test.next(false), APFloat::opOK);
433 EXPECT_EQ(test.next(true), APFloat::opOK);
443 EXPECT_EQ(test.next(false), APFloat::opOK);
453 EXPECT_EQ(test.next(true), APFloat::opOK);
467 EXPECT_EQ(14.75f, f1.convertToFloat());
478 EXPECT_EQ(12.0f, f1.convertToFloat());
531 EXPECT_EQ(4.0f, M1.convertToFloat());
540 EXPECT_EQ(1.0, minnum(f1, f2).convertToDouble());
541 EXPECT_EQ(1.0, minnum(f2, f1).convertToDouble());
542 EXPECT_EQ(1.0, minnum(f1, nan).convertToDouble());
543 EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
551 EXPECT_EQ(2.0, maxnum(f1, f2).convertToDouble());
552 EXPECT_EQ(2.0, maxnum(f2, f1).convertToDouble());
553 EXPECT_EQ(1.0, maxnum(f1, nan).convertToDouble());
554 EXPECT_EQ(1.0, maxnum(nan, f1).convertToDouble());
564 EXPECT_EQ(1.0, minimum(f1, f2).convertToDouble());
565 EXPECT_EQ(1.0, minimum(f2, f1).convertToDouble());
566 EXPECT_EQ(-0.0, minimum(zp, zn).convertToDouble());
567 EXPECT_EQ(-0.0, minimum(zn, zp).convertToDouble());
579 EXPECT_EQ(2.0, maximum(f1, f2).convertToDouble());
580 EXPECT_EQ(2.0, maximum(f2, f1).convertToDouble());
581 EXPECT_EQ(0.0, maximum(zp, zn).convertToDouble());
582 EXPECT_EQ(0.0, maximum(zn, zp).convertToDouble());
640 EXPECT_EQ(0.0f, APFloat(0.0f).convertToFloat());
641 EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat());
644 EXPECT_EQ(0.0, APFloat(0.0).convertToDouble());
645 EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble());
655 EXPECT_EQ(Val.convertToDouble(), 0.0);
658 EXPECT_EQ(Val.convertToDouble(), 0.0);
661 EXPECT_EQ(Val.convertToDouble(), 0.0);
664 EXPECT_EQ(Val.convertToDouble(), 0.09);
667 EXPECT_EQ(Val.convertToDouble(), 0.00);
670 EXPECT_EQ(Val.convertToDouble(), 0.00);
675 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0").convertToDouble());
676 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0").convertToDouble());
677 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0").convertToDouble());
679 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.").convertToDouble());
680 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.").convertToDouble());
681 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.").convertToDouble());
683 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0").convertToDouble());
684 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0").convertToDouble());
685 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0").convertToDouble());
687 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0").convertToDouble());
688 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0").convertToDouble());
689 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0").convertToDouble());
691 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "00000.").convertToDouble());
692 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+00000.").convertToDouble());
693 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-00000.").convertToDouble());
695 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), ".00000").convertToDouble());
696 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.00000").convertToDouble());
697 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.00000").convertToDouble());
699 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0000.00000").convertToDouble());
700 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0000.00000").convertToDouble());
701 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0000.00000").convertToDouble());
705 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1").convertToDouble());
706 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1").convertToDouble());
707 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1").convertToDouble());
709 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e+1").convertToDouble());
710 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1").convertToDouble());
711 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1").convertToDouble());
713 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e-1").convertToDouble());
714 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1").convertToDouble());
715 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1").convertToDouble());
718 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e1").convertToDouble());
719 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e1").convertToDouble());
720 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e1").convertToDouble());
722 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e+1").convertToDouble());
723 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e+1").convertToDouble());
724 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e+1").convertToDouble());
726 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e-1").convertToDouble());
727 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e-1").convertToDouble());
728 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e-1").convertToDouble());
730 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e1").convertToDouble());
731 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e1").convertToDouble());
732 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e1").convertToDouble());
734 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e+1").convertToDouble());
735 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e+1").convertToDouble());
736 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e+1").convertToDouble());
738 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e-1").convertToDouble());
739 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e-1").convertToDouble());
740 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e-1").convertToDouble());
743 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e1").convertToDouble());
744 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e1").convertToDouble());
745 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e1").convertToDouble());
747 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e+1").convertToDouble());
748 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e+1").convertToDouble());
749 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e+1").convertToDouble());
751 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e-1").convertToDouble());
752 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e-1").convertToDouble());
753 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e-1").convertToDouble());
756 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1").convertToDouble());
757 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+000.0000e+1").convertToDouble());
758 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-000.0000e+1").convertToDouble());
762 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1234").convertToDouble());
763 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1234").convertToDouble());
764 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1234").convertToDouble());
766 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e+1234").convertToDouble());
767 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1234").convertToDouble());
768 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1234").convertToDouble());
770 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e-1234").convertToDouble());
771 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1234").convertToDouble());
772 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1234").convertToDouble());
774 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1234").convertToDouble());
775 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e-1234").convertToDouble());
777 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), StringRef("0e1234" "\0" "2", 6)).convertToDouble());
781 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1").convertToDouble());
782 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p1").convertToDouble());
783 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1").convertToDouble());
785 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p+1").convertToDouble());
786 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p+1").convertToDouble());
787 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p+1").convertToDouble());
789 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p-1").convertToDouble());
790 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p-1").convertToDouble());
791 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p-1").convertToDouble());
794 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
795 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p1").convertToDouble());
796 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p1").convertToDouble());
798 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p+1").convertToDouble());
799 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p+1").convertToDouble());
800 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p+1").convertToDouble());
802 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p-1").convertToDouble());
803 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p-1").convertToDouble());
804 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p-1").convertToDouble());
807 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p1").convertToDouble());
808 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p1").convertToDouble());
809 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p1").convertToDouble());
811 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p+1").convertToDouble());
812 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p+1").convertToDouble());
813 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p+1").convertToDouble());
815 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p-1").convertToDouble());
816 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p-1").convertToDouble());
817 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p-1").convertToDouble());
820 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p1").convertToDouble());
821 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p1").convertToDouble());
822 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p1").convertToDouble());
824 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p+1").convertToDouble());
825 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p+1").convertToDouble());
826 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p+1").convertToDouble());
828 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p-1").convertToDouble());
829 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p-1").convertToDouble());
830 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p-1").convertToDouble());
833 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1").convertToDouble());
834 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1").convertToDouble());
835 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1").convertToDouble());
836 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
837 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1234").convertToDouble());
838 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1234").convertToDouble());
839 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1234").convertToDouble());
840 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1234").convertToDouble());
841 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1234").convertToDouble());
842 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1234").convertToDouble());
846 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1").convertToDouble());
847 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
848 EXPECT_EQ(0.5, APFloat(APFloat::IEEEdouble(), ".5").convertToDouble());
849 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0").convertToDouble());
850 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-2").convertToDouble());
851 EXPECT_EQ(-4.0, APFloat(APFloat::IEEEdouble(), "-4.").convertToDouble());
852 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-.5").convertToDouble());
853 EXPECT_EQ(-1.5, APFloat(APFloat::IEEEdouble(), "-1.5").convertToDouble());
854 EXPECT_EQ(1.25e12, APFloat(APFloat::IEEEdouble(), "1.25e12").convertToDouble());
855 EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble(), "1.25e+12").convertToDouble());
856 EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble(), "1.25e-12").convertToDouble());
857 EXPECT_EQ(1024.0, APFloat(APFloat::IEEEdouble(), "1024.").convertToDouble());
858 EXPECT_EQ(1024.05, APFloat(APFloat::IEEEdouble(), "1024.05000").convertToDouble());
859 EXPECT_EQ(0.05, APFloat(APFloat::IEEEdouble(), ".05000").convertToDouble());
860 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
861 EXPECT_EQ(2.0e2, APFloat(APFloat::IEEEdouble(), "2.e2").convertToDouble());
862 EXPECT_EQ(2.0e+2, APFloat(APFloat::IEEEdouble(), "2.e+2").convertToDouble());
863 EXPECT_EQ(2.0e-2, APFloat(APFloat::IEEEdouble(), "2.e-2").convertToDouble());
864 EXPECT_EQ(2.05e2, APFloat(APFloat::IEEEdouble(), "002.05000e2").convertToDouble());
865 EXPECT_EQ(2.05e+2, APFloat(APFloat::IEEEdouble(), "002.05000e+2").convertToDouble());
866 EXPECT_EQ(2.05e-2, APFloat(APFloat::IEEEdouble(), "002.05000e-2").convertToDouble());
867 EXPECT_EQ(2.05e12, APFloat(APFloat::IEEEdouble(), "002.05000e12").convertToDouble());
868 EXPECT_EQ(2.05e+12, APFloat(APFloat::IEEEdouble(), "002.05000e+12").convertToDouble());
869 EXPECT_EQ(2.05e-12, APFloat(APFloat::IEEEdouble(), "002.05000e-12").convertToDouble());
871 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1e").convertToDouble());
872 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "+1e").convertToDouble());
873 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-1e").convertToDouble());
875 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.e").convertToDouble());
876 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "+1.e").convertToDouble());
877 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-1.e").convertToDouble());
879 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e").convertToDouble());
880 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), "+.1e").convertToDouble());
881 EXPECT_EQ(-0.1, APFloat(APFloat::IEEEdouble(), "-.1e").convertToDouble());
883 EXPECT_EQ(1.1, APFloat(APFloat::IEEEdouble(), "1.1e").convertToDouble());
884 EXPECT_EQ(1.1, APFloat(APFloat::IEEEdouble(), "+1.1e").convertToDouble());
885 EXPECT_EQ(-1.1, APFloat(APFloat::IEEEdouble(), "-1.1e").convertToDouble());
887 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1e+").convertToDouble());
888 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1e-").convertToDouble());
890 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e").convertToDouble());
891 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e+").convertToDouble());
892 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e-").convertToDouble());
894 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0e").convertToDouble());
895 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0e+").convertToDouble());
896 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0e-").convertToDouble());
905 EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828"));
926 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
927 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p0").convertToDouble());
928 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p0").convertToDouble());
930 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p+0").convertToDouble());
931 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p+0").convertToDouble());
932 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p+0").convertToDouble());
934 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p-0").convertToDouble());
935 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p-0").convertToDouble());
936 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p-0").convertToDouble());
939 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p1").convertToDouble());
940 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p1").convertToDouble());
941 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p1").convertToDouble());
943 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p+1").convertToDouble());
944 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p+1").convertToDouble());
945 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p+1").convertToDouble());
947 EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble(), "0x1p-1").convertToDouble());
948 EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble(), "+0x1p-1").convertToDouble());
949 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-0x1p-1").convertToDouble());
952 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p1").convertToDouble());
953 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p1").convertToDouble());
954 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p1").convertToDouble());
956 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p+1").convertToDouble());
957 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p+1").convertToDouble());
958 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p+1").convertToDouble());
960 EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble(), "0x1.8p-1").convertToDouble());
961 EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble(), "+0x1.8p-1").convertToDouble());
962 EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble(), "-0x1.8p-1").convertToDouble());
965 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p1").convertToDouble());
966 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p1").convertToDouble());
967 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p1").convertToDouble());
969 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p+1").convertToDouble());
970 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p+1").convertToDouble());
971 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p+1").convertToDouble());
973 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p-1").convertToDouble());
974 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p-1").convertToDouble());
975 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p-1").convertToDouble());
978 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p1").convertToDouble());
979 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p1").convertToDouble());
980 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p1").convertToDouble());
982 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p+1").convertToDouble());
983 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p+1").convertToDouble());
984 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p+1").convertToDouble());
986 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000p-1").convertToDouble());
987 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000p-1").convertToDouble());
988 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000p-1").convertToDouble());
991 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p10").convertToDouble());
992 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p10").convertToDouble());
993 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p10").convertToDouble());
995 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p+10").convertToDouble());
996 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p+10").convertToDouble());
997 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p+10").convertToDouble());
999 EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble(), "0x10p-10").convertToDouble());
1000 EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble(), "+0x10p-10").convertToDouble());
1001 EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble(), "-0x10p-10").convertToDouble());
1003 EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble(), "0x1.1p0").convertToDouble());
1004 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
1006 EXPECT_EQ(convertToDoubleFromString("0x1p-150"),
1008 EXPECT_EQ(2251799813685248.5,
1055 EXPECT_EQ(APFloat::opOK,
1059 EXPECT_EQ(APSInt(APInt(5, 10), true), result);
1061 EXPECT_EQ(APFloat::opInvalidOp,
1065 EXPECT_EQ(APSInt::getMinValue(5, true), result);
1067 EXPECT_EQ(APFloat::opInvalidOp,
1071 EXPECT_EQ(APSInt::getMaxValue(5, true), result);
1073 EXPECT_EQ(APFloat::opInexact,
1077 EXPECT_EQ(APSInt(APInt(5, 7), true), result);
1080 EXPECT_EQ(APFloat::opOK,
1084 EXPECT_EQ(APSInt(APInt(5, -10, true), false), result);
1086 EXPECT_EQ(APFloat::opInvalidOp,
1090 EXPECT_EQ(APSInt::getMinValue(5, false), result);
1092 EXPECT_EQ(APFloat::opInvalidOp,
1096 EXPECT_EQ(APSInt::getMaxValue(5, false), result);
1349 EXPECT_EQ(-0.0, P.convertToDouble());
1352 EXPECT_EQ(-1.0, P.convertToDouble());
1355 EXPECT_EQ(-0.0, P.convertToDouble());
1358 EXPECT_EQ(-0.0, P.convertToDouble());
1362 EXPECT_EQ(3.0, P.convertToDouble());
1365 EXPECT_EQ(3.0, P.convertToDouble());
1368 EXPECT_EQ(4.0, P.convertToDouble());
1371 EXPECT_EQ(3.0, P.convertToDouble());
1375 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1378 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1381 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1384 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1388 EXPECT_EQ(0.0, P.convertToDouble());
1391 EXPECT_EQ(-0.0, P.convertToDouble());
1437 EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle()).convertToFloat());
1438 EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble()).convertToDouble());
1532 EXPECT_EQ(GetZeroTest[i].bitPattern[j],
1553 EXPECT_EQ(1.0f, test.convertToFloat());
1559 EXPECT_EQ(1.0, test.convertToDouble());
1565 EXPECT_EQ(1.0, test.convertToDouble());
1570 EXPECT_EQ(4294967295.0, test.convertToDouble());
1602 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1603 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1607 EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
1608 EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
1612 EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1613 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1619 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1623 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1627 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1631 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1636 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1640 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
2957 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), false)));
2958 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), true)));
2959 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1024")));
2960 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023")));
2961 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023")));
2962 EXPECT_EQ(-51, ilogb(APFloat(APFloat::IEEEdouble(), "0x1p-51")));
2963 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1023")));
2964 EXPECT_EQ(-2, ilogb(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1")));
2965 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1023")));
2966 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), false)));
2967 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), true)));
2970 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+0")));
2971 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "-0x1p+0")));
2972 EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+42")));
2973 EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p-42")));
2975 EXPECT_EQ(APFloat::IEK_Inf,
2977 EXPECT_EQ(APFloat::IEK_Inf,
2979 EXPECT_EQ(APFloat::IEK_Zero,
2981 EXPECT_EQ(APFloat::IEK_Zero,
2983 EXPECT_EQ(APFloat::IEK_NaN,
2985 EXPECT_EQ(APFloat::IEK_NaN,
2988 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), false)));
2989 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), true)));
2991 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), false)));
2992 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), true)));
2993 EXPECT_EQ(-126,
2995 EXPECT_EQ(-126,
3041 EXPECT_EQ(Payload, QuietPayload.bitcastToAPInt().getLoBits(51));
3215 EXPECT_EQ(0, Exp);
3219 EXPECT_EQ(0, Exp);
3224 EXPECT_EQ(1, Exp);
3228 EXPECT_EQ(1, Exp);
3232 EXPECT_EQ(-1022, Exp);
3236 EXPECT_EQ(-1022, Exp);
3241 EXPECT_EQ(-1073, Exp);
3245 EXPECT_EQ(-1073, Exp);
3250 EXPECT_EQ(1024, Exp);
3254 EXPECT_EQ(1024, Exp);
3259 EXPECT_EQ(INT_MAX, Exp);
3263 EXPECT_EQ(INT_MAX, Exp);
3267 EXPECT_EQ(INT_MIN, Exp);
3271 EXPECT_EQ(INT_MIN, Exp);
3275 EXPECT_EQ(INT_MIN, Exp);
3279 EXPECT_EQ(INT_MIN, Exp);
3281 EXPECT_EQ(Payload, Frac.bitcastToAPInt().getLoBits(51));
3284 EXPECT_EQ(-1, Exp);
3288 EXPECT_EQ(-50, Exp);
3292 EXPECT_EQ(52, Exp);
3301 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3308 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3316 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3323 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3330 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3337 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3343 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3349 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3355 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3362 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3369 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3412 EXPECT_EQ(Expected, A1.getCategory())
3422 EXPECT_EQ(Expected, A2.getCategory())
3476 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3480 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3490 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
3494 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
3525 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3529 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3580 EXPECT_EQ(Expected, A1.getCategory())
3590 EXPECT_EQ(Expected, A2.getCategory())
3653 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3657 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3667 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
3671 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
3700 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3704 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3733 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3737 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3768 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3772 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3785 EXPECT_EQ(APFloat::cmpEqual,
3793 EXPECT_EQ(APFloat::cmpEqual,
3799 EXPECT_EQ(APFloat::cmpEqual,
3839 EXPECT_EQ(Expected, A1.compare(A2))
3871 EXPECT_EQ(Expected, A1.bitwiseIsEqual(A2))
3895 EXPECT_EQ(0x400f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
3896 EXPECT_EQ(0xbcb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
3901 EXPECT_EQ(0xc00f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
3902 EXPECT_EQ(0x3cb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
3911 EXPECT_EQ(APInt(128, 2, Data),
3918 EXPECT_EQ(APInt(128, 2, Data),
3925 EXPECT_EQ(
3931 EXPECT_EQ(APInt(128, 2, Data),
3939 EXPECT_EQ(
3947 EXPECT_EQ(
3955 EXPECT_EQ(APInt(128, 2, Data),
3963 EXPECT_EQ(APInt(128, 2, Data),
3995 EXPECT_EQ(0x4018000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
3996 EXPECT_EQ(0x3cc8000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
4009 EXPECT_EQ(2, Exp);
4010 EXPECT_EQ(0x3fe8000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
4011 EXPECT_EQ(0x3c98000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
unittests/ADT/APIntTest.cpp 37 EXPECT_EQ(neg_one, neg_one.ashr(7));
42 EXPECT_EQ(126u, Minus3.countLeadingOnes());
43 EXPECT_EQ(-3, Minus3.getSExtValue());
46 EXPECT_EQ(0u, Minus1.countLeadingZeros());
47 EXPECT_EQ(128u, Minus1.countLeadingOnes());
48 EXPECT_EQ(128u, Minus1.getActiveBits());
49 EXPECT_EQ(0u, Minus1.countTrailingZeros());
50 EXPECT_EQ(128u, Minus1.countTrailingOnes());
51 EXPECT_EQ(128u, Minus1.countPopulation());
52 EXPECT_EQ(-1, Minus1.getSExtValue());
57 EXPECT_EQ(0u, i33minus2.countLeadingZeros());
58 EXPECT_EQ(32u, i33minus2.countLeadingOnes());
59 EXPECT_EQ(33u, i33minus2.getActiveBits());
60 EXPECT_EQ(1u, i33minus2.countTrailingZeros());
61 EXPECT_EQ(32u, i33minus2.countPopulation());
62 EXPECT_EQ(-2, i33minus2.getSExtValue());
63 EXPECT_EQ(((uint64_t)-2)&((1ull<<33) -1), i33minus2.getZExtValue());
68 EXPECT_EQ(45u, i61.countLeadingZeros());
69 EXPECT_EQ(0u, i61.countLeadingOnes());
70 EXPECT_EQ(16u, i61.getActiveBits());
71 EXPECT_EQ(15u, i61.countTrailingZeros());
72 EXPECT_EQ(1u, i61.countPopulation());
73 EXPECT_EQ(static_cast<int64_t>(1 << 15), i61.getSExtValue());
74 EXPECT_EQ(static_cast<uint64_t>(1 << 15), i61.getZExtValue());
77 EXPECT_EQ(42u, i61.countLeadingZeros());
78 EXPECT_EQ(0u, i61.countLeadingOnes());
79 EXPECT_EQ(19u, i61.getActiveBits());
80 EXPECT_EQ(8u, i61.countTrailingZeros());
81 EXPECT_EQ(11u, i61.countPopulation());
82 EXPECT_EQ(static_cast<int64_t>((1 << 19) - (1 << 8)), i61.getSExtValue());
83 EXPECT_EQ(static_cast<uint64_t>((1 << 19) - (1 << 8)), i61.getZExtValue());
88 EXPECT_EQ(65u, i65.countLeadingZeros());
89 EXPECT_EQ(0u, i65.countLeadingOnes());
90 EXPECT_EQ(0u, i65.getActiveBits());
91 EXPECT_EQ(1u, i65.getActiveWords());
92 EXPECT_EQ(65u, i65.countTrailingZeros());
93 EXPECT_EQ(0u, i65.countPopulation());
97 EXPECT_EQ(0u, i65minus.countLeadingZeros());
98 EXPECT_EQ(1u, i65minus.countLeadingOnes());
99 EXPECT_EQ(65u, i65minus.getActiveBits());
100 EXPECT_EQ(64u, i65minus.countTrailingZeros());
101 EXPECT_EQ(1u, i65minus.countPopulation());
106 EXPECT_EQ(128u, u128max.countLeadingOnes());
107 EXPECT_EQ(0u, u128max.countLeadingZeros());
108 EXPECT_EQ(128u, u128max.getActiveBits());
109 EXPECT_EQ(0u, u128max.countTrailingZeros());
110 EXPECT_EQ(128u, u128max.countTrailingOnes());
111 EXPECT_EQ(128u, u128max.countPopulation());
114 EXPECT_EQ(64u, u64max.countLeadingZeros());
115 EXPECT_EQ(0u, u64max.countLeadingOnes());
116 EXPECT_EQ(64u, u64max.getActiveBits());
117 EXPECT_EQ(0u, u64max.countTrailingZeros());
118 EXPECT_EQ(64u, u64max.countTrailingOnes());
119 EXPECT_EQ(64u, u64max.countPopulation());
120 EXPECT_EQ((uint64_t)~0ull, u64max.getZExtValue());
123 EXPECT_EQ(128u, zero.countLeadingZeros());
124 EXPECT_EQ(0u, zero.countLeadingOnes());
125 EXPECT_EQ(0u, zero.getActiveBits());
126 EXPECT_EQ(128u, zero.countTrailingZeros());
127 EXPECT_EQ(0u, zero.countTrailingOnes());
128 EXPECT_EQ(0u, zero.countPopulation());
129 EXPECT_EQ(0u, zero.getSExtValue());
130 EXPECT_EQ(0u, zero.getZExtValue());
133 EXPECT_EQ(127u, one.countLeadingZeros());
134 EXPECT_EQ(0u, one.countLeadingOnes());
135 EXPECT_EQ(1u, one.getActiveBits());
136 EXPECT_EQ(0u, one.countTrailingZeros());
137 EXPECT_EQ(1u, one.countTrailingOnes());
138 EXPECT_EQ(1u, one.countPopulation());
139 EXPECT_EQ(1, one.getSExtValue());
140 EXPECT_EQ(1u, one.getZExtValue());
143 EXPECT_EQ(126u, s128.countLeadingZeros());
144 EXPECT_EQ(0u, s128.countLeadingOnes());
145 EXPECT_EQ(2u, s128.getActiveBits());
146 EXPECT_EQ(1u, s128.countTrailingZeros());
147 EXPECT_EQ(0u, s128.countTrailingOnes());
148 EXPECT_EQ(1u, s128.countPopulation());
149 EXPECT_EQ(2, s128.getSExtValue());
150 EXPECT_EQ(2u, s128.getZExtValue());
154 EXPECT_EQ(126u, s128.countLeadingZeros());
155 EXPECT_EQ(0u, s128.countLeadingOnes());
156 EXPECT_EQ(2u, s128.getActiveBits());
157 EXPECT_EQ(1u, s128.countTrailingZeros());
158 EXPECT_EQ(0u, s128.countTrailingOnes());
159 EXPECT_EQ(1u, s128.countPopulation());
160 EXPECT_EQ(2, s128.getSExtValue());
161 EXPECT_EQ(2u, s128.getZExtValue());
164 EXPECT_EQ(96u, s128.countLeadingZeros());
165 EXPECT_EQ(0u, s128.countLeadingOnes());
166 EXPECT_EQ(32u, s128.getActiveBits());
167 EXPECT_EQ(33u, s128.getMinSignedBits());
168 EXPECT_EQ(1u, s128.countTrailingZeros());
169 EXPECT_EQ(0u, s128.countTrailingOnes());
170 EXPECT_EQ(30u, s128.countPopulation());
171 EXPECT_EQ(static_cast<uint32_t>((~0u << 3) | 2), s128.getZExtValue());
174 EXPECT_EQ(0u, s128.countLeadingZeros());
175 EXPECT_EQ(66u, s128.countLeadingOnes());
176 EXPECT_EQ(128u, s128.getActiveBits());
177 EXPECT_EQ(63u, s128.getMinSignedBits());
178 EXPECT_EQ(1u, s128.countTrailingZeros());
179 EXPECT_EQ(0u, s128.countTrailingOnes());
180 EXPECT_EQ(96u, s128.countPopulation());
181 EXPECT_EQ(static_cast<int64_t>((3ull << 62) |
188 EXPECT_EQ(252u, s256.countLeadingZeros());
189 EXPECT_EQ(0u, s256.countLeadingOnes());
190 EXPECT_EQ(4u, s256.getActiveBits());
191 EXPECT_EQ(0u, s256.countTrailingZeros());
192 EXPECT_EQ(4u, s256.countTrailingOnes());
193 EXPECT_EQ(4u, s256.countPopulation());
194 EXPECT_EQ(15, s256.getSExtValue());
195 EXPECT_EQ(15u, s256.getZExtValue());
198 EXPECT_EQ(190u, s256.countLeadingZeros());
199 EXPECT_EQ(0u, s256.countLeadingOnes());
200 EXPECT_EQ(66u, s256.getActiveBits());
201 EXPECT_EQ(67u, s256.getMinSignedBits());
202 EXPECT_EQ(0u, s256.countTrailingZeros());
203 EXPECT_EQ(4u, s256.countTrailingOnes());
204 EXPECT_EQ(8u, s256.countPopulation());
207 EXPECT_EQ(0u, s256.countLeadingZeros());
208 EXPECT_EQ(196u, s256.countLeadingOnes());
209 EXPECT_EQ(256u, s256.getActiveBits());
210 EXPECT_EQ(61u, s256.getMinSignedBits());
211 EXPECT_EQ(0u, s256.countTrailingZeros());
212 EXPECT_EQ(4u, s256.countTrailingOnes());
213 EXPECT_EQ(200u, s256.countPopulation());
214 EXPECT_EQ(static_cast<int64_t>((~0ull << 60) | 15), s256.getSExtValue());
224 EXPECT_EQ(0, neg_two.getSExtValue());
225 EXPECT_EQ(-1, neg_one.getSExtValue());
226 EXPECT_EQ(1u, neg_one.getZExtValue());
227 EXPECT_EQ(0u, zero.getZExtValue());
228 EXPECT_EQ(-1, one.getSExtValue());
229 EXPECT_EQ(1u, one.getZExtValue());
230 EXPECT_EQ(0u, two.getZExtValue());
231 EXPECT_EQ(0, two.getSExtValue());
234 EXPECT_EQ(zero, two);
235 EXPECT_EQ(zero, neg_two);
236 EXPECT_EQ(one, neg_one);
237 EXPECT_EQ(two, neg_two);
246 EXPECT_EQ(two, one + one);
247 EXPECT_EQ(zero, neg_one + one);
248 EXPECT_EQ(neg_two, neg_one + neg_one);
251 EXPECT_EQ(neg_two, neg_one - one);
252 EXPECT_EQ(two, one - neg_one);
253 EXPECT_EQ(zero, one - one);
256 EXPECT_EQ(zero, zero & zero);
257 EXPECT_EQ(zero, one & zero);
258 EXPECT_EQ(zero, zero & one);
259 EXPECT_EQ(one, one & one);
260 EXPECT_EQ(zero, zero & zero);
261 EXPECT_EQ(zero, neg_one & zero);
262 EXPECT_EQ(zero, zero & neg_one);
263 EXPECT_EQ(neg_one, neg_one & neg_one);
266 EXPECT_EQ(zero, zero | zero);
267 EXPECT_EQ(one, one | zero);
268 EXPECT_EQ(one, zero | one);
269 EXPECT_EQ(one, one | one);
270 EXPECT_EQ(zero, zero | zero);
271 EXPECT_EQ(neg_one, neg_one | zero);
272 EXPECT_EQ(neg_one, zero | neg_one);
273 EXPECT_EQ(neg_one, neg_one | neg_one);
276 EXPECT_EQ(zero, zero ^ zero);
277 EXPECT_EQ(one, one ^ zero);
278 EXPECT_EQ(one, zero ^ one);
279 EXPECT_EQ(zero, one ^ one);
280 EXPECT_EQ(zero, zero ^ zero);
281 EXPECT_EQ(neg_one, neg_one ^ zero);
282 EXPECT_EQ(neg_one, zero ^ neg_one);
283 EXPECT_EQ(zero, neg_one ^ neg_one);
286 EXPECT_EQ(zero, one << one);
287 EXPECT_EQ(one, one << zero);
288 EXPECT_EQ(zero, one.shl(1));
289 EXPECT_EQ(one, one.shl(0));
290 EXPECT_EQ(zero, one.lshr(1));
291 EXPECT_EQ(one, one.ashr(1));
294 EXPECT_EQ(one, one.rotl(0));
295 EXPECT_EQ(one, one.rotl(1));
296 EXPECT_EQ(one, one.rotr(0));
297 EXPECT_EQ(one, one.rotr(1));
300 EXPECT_EQ(neg_one, neg_one * one);
301 EXPECT_EQ(neg_one, one * neg_one);
302 EXPECT_EQ(one, neg_one * neg_one);
303 EXPECT_EQ(one, one * one);
306 EXPECT_EQ(neg_one, one.sdiv(neg_one));
307 EXPECT_EQ(neg_one, neg_one.sdiv(one));
308 EXPECT_EQ(one, neg_one.sdiv(neg_one));
309 EXPECT_EQ(one, one.sdiv(one));
311 EXPECT_EQ(neg_one, one.udiv(neg_one));
312 EXPECT_EQ(neg_one, neg_one.udiv(one));
313 EXPECT_EQ(one, neg_one.udiv(neg_one));
314 EXPECT_EQ(one, one.udiv(one));
317 EXPECT_EQ(zero, neg_one.srem(one));
318 EXPECT_EQ(zero, neg_one.urem(one));
319 EXPECT_EQ(zero, one.srem(neg_one));
330 EXPECT_EQ(nine.srem(two), one);
331 EXPECT_EQ(nine.srem(-two), one);
332 EXPECT_EQ((-nine).srem(two), -one);
333 EXPECT_EQ((-nine).srem(-two), -one);
336 EXPECT_EQ(four, q);
337 EXPECT_EQ(one, r);
339 EXPECT_EQ(-four, q);
340 EXPECT_EQ(-one, r);
342 EXPECT_EQ(-four, q);
343 EXPECT_EQ(one, r);
345 EXPECT_EQ(four, q);
346 EXPECT_EQ(-one, r);
366 EXPECT_EQ(uv1 < uv2, arg1.ult(arg2));
367 EXPECT_EQ(uv1 <= uv2, arg1.ule(arg2));
368 EXPECT_EQ(uv1 > uv2, arg1.ugt(arg2));
369 EXPECT_EQ(uv1 >= uv2, arg1.uge(arg2));
371 EXPECT_EQ(sv1 < sv2, arg1.slt(arg2));
372 EXPECT_EQ(sv1 <= sv2, arg1.sle(arg2));
373 EXPECT_EQ(sv1 > sv2, arg1.sgt(arg2));
374 EXPECT_EQ(sv1 >= sv2, arg1.sge(arg2));
376 EXPECT_EQ(uv1 < uv2, arg1.ult(uv2));
377 EXPECT_EQ(uv1 <= uv2, arg1.ule(uv2));
378 EXPECT_EQ(uv1 > uv2, arg1.ugt(uv2));
379 EXPECT_EQ(uv1 >= uv2, arg1.uge(uv2));
381 EXPECT_EQ(sv1 < sv2, arg1.slt(sv2));
382 EXPECT_EQ(sv1 <= sv2, arg1.sle(sv2));
383 EXPECT_EQ(sv1 > sv2, arg1.sgt(sv2));
384 EXPECT_EQ(sv1 >= sv2, arg1.sge(sv2));
548 EXPECT_EQ(A1 & E1, E1);
549 EXPECT_EQ(A1 & 0, 0);
550 EXPECT_EQ(A1 & 1, 1);
551 EXPECT_EQ(A1 & 5, 5);
552 EXPECT_EQ(A1 & UINT64_MAX, E1);
554 EXPECT_EQ(A1 | E1, E1);
555 EXPECT_EQ(A1 | 0, E1);
556 EXPECT_EQ(A1 | 1, E1);
557 EXPECT_EQ(A1 | 2, E1 | 2);
558 EXPECT_EQ(A1 | UINT64_MAX, UINT64_MAX);
560 EXPECT_EQ(A1 ^ E1, 0);
561 EXPECT_EQ(A1 ^ 0, E1);
562 EXPECT_EQ(A1 ^ 1, E1 ^ 1);
563 EXPECT_EQ(A1 ^ 7, E1 ^ 7);
564 EXPECT_EQ(A1 ^ UINT64_MAX, ~E1);
576 EXPECT_EQ(A2 & N, N);
577 EXPECT_EQ(A2 & 0, 0);
578 EXPECT_EQ(A2 & 1, 1);
579 EXPECT_EQ(A2 & 5, 1);
580 EXPECT_EQ(A2 & UINT64_MAX, N);
582 EXPECT_EQ(A2 | N, A2);
583 EXPECT_EQ(A2 | 0, A2);
584 EXPECT_EQ(A2 | 1, A2);
585 EXPECT_EQ(A2 | 2, A2 + 2);
586 EXPECT_EQ(A2 | UINT64_MAX, A2 - N + UINT64_MAX);
588 EXPECT_EQ(A2 ^ N, A2 - N);
589 EXPECT_EQ(A2 ^ 0, A2);
590 EXPECT_EQ(A2 ^ 1, A2 - 1);
591 EXPECT_EQ(A2 ^ 7, A2 + 5);
592 EXPECT_EQ(A2 ^ UINT64_MAX, A2 - N + ~N);
617 EXPECT_EQ(AddLL, Two);
620 EXPECT_EQ(AddLR, Two);
621 EXPECT_EQ(AddLR.getRawData(), RawDataR);
624 EXPECT_EQ(AddRL, Two);
625 EXPECT_EQ(AddRL.getRawData(), RawDataL);
628 EXPECT_EQ(AddRR, Two);
629 EXPECT_EQ(AddRR.getRawData(), RawDataR);
633 EXPECT_EQ(AddLK, Two);
636 EXPECT_EQ(AddKL, Two);
640 EXPECT_EQ(AddRK, Two);
641 EXPECT_EQ(AddRK.getRawData(), RawDataL);
644 EXPECT_EQ(AddKR, Two);
645 EXPECT_EQ(AddKR.getRawData(), RawDataR);
654 EXPECT_EQ(AddLL, HighOneLowOne);
657 EXPECT_EQ(AddLR, HighOneLowOne);
658 EXPECT_EQ(AddLR.getRawData(), RawDataR);
661 EXPECT_EQ(AddRL, HighOneLowOne);
662 EXPECT_EQ(AddRL.getRawData(), RawDataL);
666 EXPECT_EQ(AddRR, HighOneLowOne);
667 EXPECT_EQ(AddRR.getRawData(), RawDataR);
671 EXPECT_EQ(AddLK, HighOneLowOne);
674 EXPECT_EQ(AddKL, HighOneLowOne);
678 EXPECT_EQ(AddRK, HighOneLowOne);
679 EXPECT_EQ(AddRK.getRawData(), RawDataL);
682 EXPECT_EQ(AddKR, HighOneLowOne);
683 EXPECT_EQ(AddKR.getRawData(), RawDataR);
689 EXPECT_EQ(SubLL, One);
692 EXPECT_EQ(SubLR, One);
693 EXPECT_EQ(SubLR.getRawData(), RawDataR);
696 EXPECT_EQ(SubRL, One);
697 EXPECT_EQ(SubRL.getRawData(), RawDataL);
700 EXPECT_EQ(SubRR, One);
701 EXPECT_EQ(SubRR.getRawData(), RawDataR);
705 EXPECT_EQ(SubLK, One);
708 EXPECT_EQ(SubKL, One);
712 EXPECT_EQ(SubRK, One);
713 EXPECT_EQ(SubRK.getRawData(), RawDataL);
716 EXPECT_EQ(SubKR, One);
717 EXPECT_EQ(SubKR.getRawData(), RawDataR);
726 EXPECT_EQ(SubLL, Two);
730 EXPECT_EQ(SubLR, Two);
731 EXPECT_EQ(SubLR.getRawData(), RawDataR);
735 EXPECT_EQ(SubRL, Two);
736 EXPECT_EQ(SubRL.getRawData(), RawDataL);
740 EXPECT_EQ(SubRR, Two);
741 EXPECT_EQ(SubRR.getRawData(), RawDataR);
746 EXPECT_EQ(SubLK, AllOnes);
750 EXPECT_EQ(SubKL, Three);
755 EXPECT_EQ(SubRK, AllOnes);
756 EXPECT_EQ(SubRK.getRawData(), RawDataL);
759 EXPECT_EQ(SubKR, Three);
760 EXPECT_EQ(SubKR.getRawData(), RawDataR);
784 EXPECT_EQ(AndLL, 0x8);
787 EXPECT_EQ(AndLR, 0x8);
788 EXPECT_EQ(AndLR.getRawData(), RawDataR);
791 EXPECT_EQ(AndRL, 0x8);
792 EXPECT_EQ(AndRL.getRawData(), RawDataL);
795 EXPECT_EQ(AndRR, 0x8);
796 EXPECT_EQ(AndRR.getRawData(), RawDataR);
800 EXPECT_EQ(AndLK, 0x8);
803 EXPECT_EQ(AndKL, 0x8);
807 EXPECT_EQ(AndRK, 0x8);
808 EXPECT_EQ(AndRK.getRawData(), RawDataL);
811 EXPECT_EQ(AndKR, 0x8);
812 EXPECT_EQ(AndKR.getRawData(), RawDataR);
818 EXPECT_EQ(OrLL, 0xe);
821 EXPECT_EQ(OrLR, 0xe);
822 EXPECT_EQ(OrLR.getRawData(), RawDataR);
825 EXPECT_EQ(OrRL, 0xe);
826 EXPECT_EQ(OrRL.getRawData(), RawDataL);
829 EXPECT_EQ(OrRR, 0xe);
830 EXPECT_EQ(OrRR.getRawData(), RawDataR);
834 EXPECT_EQ(OrLK, 0xe);
837 EXPECT_EQ(OrKL, 0xe);
841 EXPECT_EQ(OrRK, 0xe);
842 EXPECT_EQ(OrRK.getRawData(), RawDataL);
845 EXPECT_EQ(OrKR, 0xe);
846 EXPECT_EQ(OrKR.getRawData(), RawDataR);
852 EXPECT_EQ(XorLL, 0x6);
855 EXPECT_EQ(XorLR, 0x6);
856 EXPECT_EQ(XorLR.getRawData(), RawDataR);
859 EXPECT_EQ(XorRL, 0x6);
860 EXPECT_EQ(XorRL.getRawData(), RawDataL);
863 EXPECT_EQ(XorRR, 0x6);
864 EXPECT_EQ(XorRR.getRawData(), RawDataR);
868 EXPECT_EQ(XorLK, 0x6);
871 EXPECT_EQ(XorKL, 0x6);
875 EXPECT_EQ(XorRK, 0x6);
876 EXPECT_EQ(XorRK.getRawData(), RawDataL);
879 EXPECT_EQ(XorKR, 0x6);
880 EXPECT_EQ(XorKR.getRawData(), RawDataR);
901 EXPECT_EQ(NegL, NegativeTwo);
904 EXPECT_EQ(NegR, NegativeTwo);
905 EXPECT_EQ(NegR.getRawData(), RawData);
918 EXPECT_EQ(b, q);
919 EXPECT_EQ(c, r);
921 EXPECT_EQ(b, q);
922 EXPECT_EQ(c, r);
925 EXPECT_EQ(b, q);
926 EXPECT_EQ(c, r);
928 EXPECT_EQ(b, q);
929 EXPECT_EQ(c, r);
934 EXPECT_EQ(a, q);
935 EXPECT_EQ(c, r);
937 EXPECT_EQ(a, q);
938 EXPECT_EQ(c, r);
941 EXPECT_EQ(a, q);
942 EXPECT_EQ(c, r);
944 EXPECT_EQ(a, q);
945 EXPECT_EQ(c, r);
1014 EXPECT_EQ(a, q);
1015 EXPECT_EQ(c, r);
1017 EXPECT_EQ(a, q);
1018 EXPECT_EQ(c, r);
1022 EXPECT_EQ(a, q);
1024 EXPECT_EQ(-c, -r); // Need to negate so the uint64_t compare will work.
1026 EXPECT_EQ(c, r);
1029 EXPECT_EQ(a, q);
1031 EXPECT_EQ(-c, -sr); // Need to negate so the uint64_t compare will work.
1033 EXPECT_EQ(c, sr);
1070 EXPECT_EQ(Q, APInt(65, 1));
1071 EXPECT_EQ(R, APInt(65, 0));
1073 EXPECT_EQ(Q, APInt(65, 1));
1074 EXPECT_EQ(R, APInt(65, 0));
1079 EXPECT_EQ(Q, APInt(65, 0));
1080 EXPECT_EQ(R, APInt(65, 0));
1082 EXPECT_EQ(Q, APInt(65, 0));
1083 EXPECT_EQ(R, APInt(65, 0));
1088 EXPECT_EQ(Q, A);
1089 EXPECT_EQ(R, APInt(65, 0));
1091 EXPECT_EQ(Q, A);
1092 EXPECT_EQ(R, APInt(65, 0));
1096 EXPECT_EQ(APInt(32, 0), APInt(32, "0", 2));
1097 EXPECT_EQ(APInt(32, 1), APInt(32, "1", 2));
1098 EXPECT_EQ(APInt(32, 2), APInt(32, "10", 2));
1099 EXPECT_EQ(APInt(32, 3), APInt(32, "11", 2));
1100 EXPECT_EQ(APInt(32, 4), APInt(32, "100", 2));
1102 EXPECT_EQ(APInt(32, 0), APInt(32, "+0", 2));
1103 EXPECT_EQ(APInt(32, 1), APInt(32, "+1", 2));
1104 EXPECT_EQ(APInt(32, 2), APInt(32, "+10", 2));
1105 EXPECT_EQ(APInt(32, 3), APInt(32, "+11", 2));
1106 EXPECT_EQ(APInt(32, 4), APInt(32, "+100", 2));
1108 EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 2));
1109 EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 2));
1110 EXPECT_EQ(APInt(32, uint64_t(-2LL)), APInt(32, "-10", 2));
1111 EXPECT_EQ(APInt(32, uint64_t(-3LL)), APInt(32, "-11", 2));
1112 EXPECT_EQ(APInt(32, uint64_t(-4LL)), APInt(32, "-100", 2));
1114 EXPECT_EQ(APInt(32, 0), APInt(32, "0", 8));
1115 EXPECT_EQ(APInt(32, 1), APInt(32, "1", 8));
1116 EXPECT_EQ(APInt(32, 7), APInt(32, "7", 8));
1117 EXPECT_EQ(APInt(32, 8), APInt(32, "10", 8));
1118 EXPECT_EQ(APInt(32, 15), APInt(32, "17", 8));
1119 EXPECT_EQ(APInt(32, 16), APInt(32, "20", 8));
1121 EXPECT_EQ(APInt(32, +0), APInt(32, "+0", 8));
1122 EXPECT_EQ(APInt(32, +1), APInt(32, "+1", 8));
1123 EXPECT_EQ(APInt(32, +7), APInt(32, "+7", 8));
1124 EXPECT_EQ(APInt(32, +8), APInt(32, "+10", 8));
1125 EXPECT_EQ(APInt(32, +15), APInt(32, "+17", 8));
1126 EXPECT_EQ(APInt(32, +16), APInt(32, "+20", 8));
1128 EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 8));
1129 EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 8));
1130 EXPECT_EQ(APInt(32, uint64_t(-7LL)), APInt(32, "-7", 8));
1131 EXPECT_EQ(APInt(32, uint64_t(-8LL)), APInt(32, "-10", 8));
1132 EXPECT_EQ(APInt(32, uint64_t(-15LL)), APInt(32, "-17", 8));
1133 EXPECT_EQ(APInt(32, uint64_t(-16LL)), APInt(32, "-20", 8));
1135 EXPECT_EQ(APInt(32, 0), APInt(32, "0", 10));
1136 EXPECT_EQ(APInt(32, 1), APInt(32, "1", 10));
1137 EXPECT_EQ(APInt(32, 9), APInt(32, "9", 10));
1138 EXPECT_EQ(APInt(32, 10), APInt(32, "10", 10));
1139 EXPECT_EQ(APInt(32, 19), APInt(32, "19", 10));
1140 EXPECT_EQ(APInt(32, 20), APInt(32, "20", 10));
1142 EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 10));
1143 EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 10));
1144 EXPECT_EQ(APInt(32, uint64_t(-9LL)), APInt(32, "-9", 10));
1145 EXPECT_EQ(APInt(32, uint64_t(-10LL)), APInt(32, "-10", 10));
1146 EXPECT_EQ(APInt(32, uint64_t(-19LL)), APInt(32, "-19", 10));
1147 EXPECT_EQ(APInt(32, uint64_t(-20LL)), APInt(32, "-20", 10));
1149 EXPECT_EQ(APInt(32, 0), APInt(32, "0", 16));
1150 EXPECT_EQ(APInt(32, 1), APInt(32, "1", 16));
1151 EXPECT_EQ(APInt(32, 15), APInt(32, "F", 16));
1152 EXPECT_EQ(APInt(32, 16), APInt(32, "10", 16));
1153 EXPECT_EQ(APInt(32, 31), APInt(32, "1F", 16));
1154 EXPECT_EQ(APInt(32, 32), APInt(32, "20", 16));
1156 EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 16));
1157 EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 16));
1158 EXPECT_EQ(APInt(32, uint64_t(-15LL)), APInt(32, "-F", 16));
1159 EXPECT_EQ(APInt(32, uint64_t(-16LL)), APInt(32, "-10", 16));
1160 EXPECT_EQ(APInt(32, uint64_t(-31LL)), APInt(32, "-1F", 16));
1161 EXPECT_EQ(APInt(32, uint64_t(-32LL)), APInt(32, "-20", 16));
1163 EXPECT_EQ(APInt(32, 0), APInt(32, "0", 36));
1164 EXPECT_EQ(APInt(32, 1), APInt(32, "1", 36));
1165 EXPECT_EQ(APInt(32, 35), APInt(32, "Z", 36));
1166 EXPECT_EQ(APInt(32, 36), APInt(32, "10", 36));
1167 EXPECT_EQ(APInt(32, 71), APInt(32, "1Z", 36));
1168 EXPECT_EQ(APInt(32, 72), APInt(32, "20", 36));
1170 EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 36));
1171 EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 36));
1172 EXPECT_EQ(APInt(32, uint64_t(-35LL)), APInt(32, "-Z", 36));
1173 EXPECT_EQ(APInt(32, uint64_t(-36LL)), APInt(32, "-10", 36));
1174 EXPECT_EQ(APInt(32, uint64_t(-71LL)), APInt(32, "-1Z", 36));
1175 EXPECT_EQ(APInt(32, uint64_t(-72LL)), APInt(32, "-20", 36));
1183 EXPECT_EQ(APInt(8, 200), AP_100.uadd_sat(AP_100));
1184 EXPECT_EQ(APInt(8, 255), AP_100.uadd_sat(AP_200));
1185 EXPECT_EQ(APInt(8, 255), APInt(8, 255).uadd_sat(APInt(8, 255)));
1187 EXPECT_EQ(APInt(8, 110), AP_10.sadd_sat(AP_100));
1188 EXPECT_EQ(APInt(8, 127), AP_100.sadd_sat(AP_100));
1189 EXPECT_EQ(APInt(8, -128), (-AP_100).sadd_sat(-AP_100));
1190 EXPECT_EQ(APInt(8, -128), APInt(8, -128).sadd_sat(APInt(8, -128)));
1192 EXPECT_EQ(APInt(8, 90), AP_100.usub_sat(AP_10));
1193 EXPECT_EQ(APInt(8, 0), AP_100.usub_sat(AP_200));
1194 EXPECT_EQ(APInt(8, 0), APInt(8, 0).usub_sat(APInt(8, 255)));
1196 EXPECT_EQ(APInt(8, -90), AP_10.ssub_sat(AP_100));
1197 EXPECT_EQ(APInt(8, 127), AP_100.ssub_sat(-AP_100));
1198 EXPECT_EQ(APInt(8, -128), (-AP_100).ssub_sat(AP_100));
1199 EXPECT_EQ(APInt(8, -128), APInt(8, -128).ssub_sat(APInt(8, 127)));
1201 EXPECT_EQ(APInt(8, 250), APInt(8, 50).umul_sat(APInt(8, 5)));
1202 EXPECT_EQ(APInt(8, 255), APInt(8, 50).umul_sat(APInt(8, 6)));
1203 EXPECT_EQ(APInt(8, 255), APInt(8, -128).umul_sat(APInt(8, 3)));
1204 EXPECT_EQ(APInt(8, 255), APInt(8, 3).umul_sat(APInt(8, -128)));
1205 EXPECT_EQ(APInt(8, 255), APInt(8, -128).umul_sat(APInt(8, -128)));
1207 EXPECT_EQ(APInt(8, 125), APInt(8, 25).smul_sat(APInt(8, 5)));
1208 EXPECT_EQ(APInt(8, 127), APInt(8, 25).smul_sat(APInt(8, 6)));
1209 EXPECT_EQ(APInt(8, 127), APInt(8, 127).smul_sat(APInt(8, 127)));
1210 EXPECT_EQ(APInt(8, -125), APInt(8, -25).smul_sat(APInt(8, 5)));
1211 EXPECT_EQ(APInt(8, -125), APInt(8, 25).smul_sat(APInt(8, -5)));
1212 EXPECT_EQ(APInt(8, 125), APInt(8, -25).smul_sat(APInt(8, -5)));
1213 EXPECT_EQ(APInt(8, 125), APInt(8, 25).smul_sat(APInt(8, 5)));
1214 EXPECT_EQ(APInt(8, -128), APInt(8, -25).smul_sat(APInt(8, 6)));
1215 EXPECT_EQ(APInt(8, -128), APInt(8, 25).smul_sat(APInt(8, -6)));
1216 EXPECT_EQ(APInt(8, 127), APInt(8, -25).smul_sat(APInt(8, -6)));
1217 EXPECT_EQ(APInt(8, 127), APInt(8, 25).smul_sat(APInt(8, 6)));
1219 EXPECT_EQ(APInt(8, 128), APInt(8, 4).ushl_sat(APInt(8, 5)));
1220 EXPECT_EQ(APInt(8, 255), APInt(8, 4).ushl_sat(APInt(8, 6)));
1221 EXPECT_EQ(APInt(8, 128), APInt(8, 1).ushl_sat(APInt(8, 7)));
1222 EXPECT_EQ(APInt(8, 255), APInt(8, 1).ushl_sat(APInt(8, 8)));
1223 EXPECT_EQ(APInt(8, 255), APInt(8, -128).ushl_sat(APInt(8, 2)));
1224 EXPECT_EQ(APInt(8, 255), APInt(8, 64).ushl_sat(APInt(8, 2)));
1225 EXPECT_EQ(APInt(8, 255), APInt(8, 64).ushl_sat(APInt(8, -2)));
1227 EXPECT_EQ(APInt(8, 64), APInt(8, 4).sshl_sat(APInt(8, 4)));
1228 EXPECT_EQ(APInt(8, 127), APInt(8, 4).sshl_sat(APInt(8, 5)));
1229 EXPECT_EQ(APInt(8, 127), APInt(8, 1).sshl_sat(APInt(8, 8)));
1230 EXPECT_EQ(APInt(8, -64), APInt(8, -4).sshl_sat(APInt(8, 4)));
1231 EXPECT_EQ(APInt(8, -128), APInt(8, -4).sshl_sat(APInt(8, 5)));
1232 EXPECT_EQ(APInt(8, -128), APInt(8, -4).sshl_sat(APInt(8, 6)));
1233 EXPECT_EQ(APInt(8, -128), APInt(8, -1).sshl_sat(APInt(8, 7)));
1234 EXPECT_EQ(APInt(8, -128), APInt(8, -1).sshl_sat(APInt(8, 8)));
1238 EXPECT_EQ(APInt(32, uint64_t(1)), APInt(32, ArrayRef<uint64_t>(1)));
1242 EXPECT_EQ(1U, APInt::getBitsNeeded( "0", 2));
1243 EXPECT_EQ(1U, APInt::getBitsNeeded( "1", 2));
1244 EXPECT_EQ(2U, APInt::getBitsNeeded( "10", 2));
1245 EXPECT_EQ(2U, APInt::getBitsNeeded( "11", 2));
1246 EXPECT_EQ(3U, APInt::getBitsNeeded("100", 2));
1248 EXPECT_EQ(1U, APInt::getBitsNeeded( "+0", 2));
1249 EXPECT_EQ(1U, APInt::getBitsNeeded( "+1", 2));
1250 EXPECT_EQ(2U, APInt::getBitsNeeded( "+10", 2));
1251 EXPECT_EQ(2U, APInt::getBitsNeeded( "+11", 2));
1252 EXPECT_EQ(3U, APInt::getBitsNeeded("+100", 2));
1254 EXPECT_EQ(2U, APInt::getBitsNeeded( "-0", 2));
1255 EXPECT_EQ(2U, APInt::getBitsNeeded( "-1", 2));
1256 EXPECT_EQ(3U, APInt::getBitsNeeded( "-10", 2));
1257 EXPECT_EQ(3U, APInt::getBitsNeeded( "-11", 2));
1258 EXPECT_EQ(4U, APInt::getBitsNeeded("-100", 2));
1262 EXPECT_EQ(3U, APInt::getBitsNeeded( "0", 8));
1263 EXPECT_EQ(3U, APInt::getBitsNeeded( "7", 8));
1264 EXPECT_EQ(6U, APInt::getBitsNeeded("10", 8));
1265 EXPECT_EQ(6U, APInt::getBitsNeeded("17", 8));
1266 EXPECT_EQ(6U, APInt::getBitsNeeded("20", 8));
1268 EXPECT_EQ(3U, APInt::getBitsNeeded( "+0", 8));
1269 EXPECT_EQ(3U, APInt::getBitsNeeded( "+7", 8));
1270 EXPECT_EQ(6U, APInt::getBitsNeeded("+10", 8));
1271 EXPECT_EQ(6U, APInt::getBitsNeeded("+17", 8));
1272 EXPECT_EQ(6U, APInt::getBitsNeeded("+20", 8));
1274 EXPECT_EQ(4U, APInt::getBitsNeeded( "-0", 8));
1275 EXPECT_EQ(4U, APInt::getBitsNeeded( "-7", 8));
1276 EXPECT_EQ(7U, APInt::getBitsNeeded("-10", 8));
1277 EXPECT_EQ(7U, APInt::getBitsNeeded("-17", 8));
1278 EXPECT_EQ(7U, APInt::getBitsNeeded("-20", 8));
1282 EXPECT_EQ(1U, APInt::getBitsNeeded( "0", 10));
1283 EXPECT_EQ(2U, APInt::getBitsNeeded( "3", 10));
1284 EXPECT_EQ(4U, APInt::getBitsNeeded( "9", 10));
1285 EXPECT_EQ(4U, APInt::getBitsNeeded("10", 10));
1286 EXPECT_EQ(5U, APInt::getBitsNeeded("19", 10));
1287 EXPECT_EQ(5U, APInt::getBitsNeeded("20", 10));
1289 EXPECT_EQ(1U, APInt::getBitsNeeded( "+0", 10));
1290 EXPECT_EQ(4U, APInt::getBitsNeeded( "+9", 10));
1291 EXPECT_EQ(4U, APInt::getBitsNeeded("+10", 10));
1292 EXPECT_EQ(5U, APInt::getBitsNeeded("+19", 10));
1293 EXPECT_EQ(5U, APInt::getBitsNeeded("+20", 10));
1295 EXPECT_EQ(2U, APInt::getBitsNeeded( "-0", 10));
1296 EXPECT_EQ(5U, APInt::getBitsNeeded( "-9", 10));
1297 EXPECT_EQ(5U, APInt::getBitsNeeded("-10", 10));
1298 EXPECT_EQ(6U, APInt::getBitsNeeded("-19", 10));
1299 EXPECT_EQ(6U, APInt::getBitsNeeded("-20", 10));
1301 EXPECT_EQ(1U, APInt::getBitsNeeded("-1", 10));
1302 EXPECT_EQ(2U, APInt::getBitsNeeded("-2", 10));
1303 EXPECT_EQ(3U, APInt::getBitsNeeded("-4", 10));
1304 EXPECT_EQ(4U, APInt::getBitsNeeded("-8", 10));
1305 EXPECT_EQ(5U, APInt::getBitsNeeded("-16", 10));
1306 EXPECT_EQ(6U, APInt::getBitsNeeded("-23", 10));
1307 EXPECT_EQ(6U, APInt::getBitsNeeded("-32", 10));
1308 EXPECT_EQ(7U, APInt::getBitsNeeded("-64", 10));
1309 EXPECT_EQ(8U, APInt::getBitsNeeded("-127", 10));
1310 EXPECT_EQ(8U, APInt::getBitsNeeded("-128", 10));
1311 EXPECT_EQ(9U, APInt::getBitsNeeded("-255", 10));
1312 EXPECT_EQ(9U, APInt::getBitsNeeded("-256", 10));
1313 EXPECT_EQ(10U, APInt::getBitsNeeded("-512", 10));
1314 EXPECT_EQ(11U, APInt::getBitsNeeded("-1024", 10));
1315 EXPECT_EQ(12U, APInt::getBitsNeeded("-1025", 10));
1319 EXPECT_EQ(4U, APInt::getBitsNeeded( "0", 16));
1320 EXPECT_EQ(4U, APInt::getBitsNeeded( "F", 16));
1321 EXPECT_EQ(8U, APInt::getBitsNeeded("10", 16));
1322 EXPECT_EQ(8U, APInt::getBitsNeeded("1F", 16));
1323 EXPECT_EQ(8U, APInt::getBitsNeeded("20", 16));
1325 EXPECT_EQ(4U, APInt::getBitsNeeded( "+0", 16));
1326 EXPECT_EQ(4U, APInt::getBitsNeeded( "+F", 16));
1327 EXPECT_EQ(8U, APInt::getBitsNeeded("+10", 16));
1328 EXPECT_EQ(8U, APInt::getBitsNeeded("+1F", 16));
1329 EXPECT_EQ(8U, APInt::getBitsNeeded("+20", 16));
1331 EXPECT_EQ(5U, APInt::getBitsNeeded( "-0", 16));
1332 EXPECT_EQ(5U, APInt::getBitsNeeded( "-F", 16));
1333 EXPECT_EQ(9U, APInt::getBitsNeeded("-10", 16));
1334 EXPECT_EQ(9U, APInt::getBitsNeeded("-1F", 16));
1335 EXPECT_EQ(9U, APInt::getBitsNeeded("-20", 16));
1343 EXPECT_EQ(S.str().str(), "0b0");
1346 EXPECT_EQ(S.str().str(), "00");
1349 EXPECT_EQ(S.str().str(), "0");
1352 EXPECT_EQ(S.str().str(), "0x0");
1355 EXPECT_EQ(S.str().str(), "0");
1360 EXPECT_EQ(S.str().str(), "0b11111111");
1363 EXPECT_EQ(S.str().str(), "0377");
1366 EXPECT_EQ(S.str().str(), "255");
1369 EXPECT_EQ(S.str().str(), "0xFF");
1372 EXPECT_EQ(S.str().str(), "73");
1377 EXPECT_EQ(S.str().str(), "-0b1");
1380 EXPECT_EQ(S.str().str(), "-01");
1383 EXPECT_EQ(S.str().str(), "-1");
1386 EXPECT_EQ(S.str().str(), "-0x1");
1389 EXPECT_EQ(S.str().str(), "-1");
1394 EXPECT_EQ(APInt(15, 7).logBase2(), 2U);
1395 EXPECT_EQ(APInt(15, 7).ceilLogBase2(), 3U);
1396 EXPECT_EQ(APInt(15, 7).exactLogBase2(), -1);
1397 EXPECT_EQ(APInt(15, 8).logBase2(), 3U);
1398 EXPECT_EQ(APInt(15, 8).ceilLogBase2(), 3U);
1399 EXPECT_EQ(APInt(15, 8).exactLogBase2(), 3);
1400 EXPECT_EQ(APInt(15, 9).logBase2(), 3U);
1401 EXPECT_EQ(APInt(15, 9).ceilLogBase2(), 4U);
1402 EXPECT_EQ(APInt(15, 9).exactLogBase2(), -1);
1406 EXPECT_EQ(APInt(32, 3).magic().m, APInt(32, "55555556", 16));
1407 EXPECT_EQ(APInt(32, 3).magic().s, 0U);
1408 EXPECT_EQ(APInt(32, 5).magic().m, APInt(32, "66666667", 16));
1409 EXPECT_EQ(APInt(32, 5).magic().s, 1U);
1410 EXPECT_EQ(APInt(32, 7).magic().m, APInt(32, "92492493", 16));
1411 EXPECT_EQ(APInt(32, 7).magic().s, 2U);
1415 EXPECT_EQ(APInt(32, 3).magicu().m, APInt(32, "AAAAAAAB", 16));
1416 EXPECT_EQ(APInt(32, 3).magicu().s, 1U);
1417 EXPECT_EQ(APInt(32, 5).magicu().m, APInt(32, "CCCCCCCD", 16));
1418 EXPECT_EQ(APInt(32, 5).magicu().s, 2U);
1419 EXPECT_EQ(APInt(32, 7).magicu().m, APInt(32, "24924925", 16));
1420 EXPECT_EQ(APInt(32, 7).magicu().s, 3U);
1421 EXPECT_EQ(APInt(64, 25).magicu(1).m, APInt(64, "A3D70A3D70A3D70B", 16));
1422 EXPECT_EQ(APInt(64, 25).magicu(1).s, 4U);
1447 EXPECT_EQ(ValA.toString(10, false), ValC.toString(10, false));
1451 EXPECT_EQ(APInt(8, 1), APInt(8, 1).rotl(0));
1452 EXPECT_EQ(APInt(8, 2), APInt(8, 1).rotl(1));
1453 EXPECT_EQ(APInt(8, 4), APInt(8, 1).rotl(2));
1454 EXPECT_EQ(APInt(8, 16), APInt(8, 1).rotl(4));
1455 EXPECT_EQ(APInt(8, 1), APInt(8, 1).rotl(8));
1457 EXPECT_EQ(APInt(8, 16), APInt(8, 16).rotl(0));
1458 EXPECT_EQ(APInt(8, 32), APInt(8, 16).rotl(1));
1459 EXPECT_EQ(APInt(8, 64), APInt(8, 16).rotl(2));
1460 EXPECT_EQ(APInt(8, 1), APInt(8, 16).rotl(4));
1461 EXPECT_EQ(APInt(8, 16), APInt(8, 16).rotl(8));
1463 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(33));
1464 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(APInt(32, 33)));
1466 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(33));
1467 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(APInt(32, 33)));
1468 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(APInt(33, 33)));
1469 EXPECT_EQ(APInt(32, (1 << 8)), APInt(32, 1).rotl(APInt(32, 40)));
1470 EXPECT_EQ(APInt(32, (1 << 30)), APInt(32, 1).rotl(APInt(31, 30)));
1471 EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotl(APInt(31, 31)));
1473 EXPECT_EQ(APInt(32, 1), APInt(32, 1).rotl(APInt(1, 0)));
1474 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(APInt(1, 1)));
1476 EXPECT_EQ(APInt(32, 16), APInt(32, 1).rotl(APInt(3, 4)));
1478 EXPECT_EQ(APInt(32, 1), APInt(32, 1).rotl(APInt(64, 64)));
1479 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(APInt(64, 65)));
1481 EXPECT_EQ(APInt(7, 24), APInt(7, 3).rotl(APInt(7, 3)));
1482 EXPECT_EQ(APInt(7, 24), APInt(7, 3).rotl(APInt(7, 10)));
1483 EXPECT_EQ(APInt(7, 24), APInt(7, 3).rotl(APInt(5, 10)));
1484 EXPECT_EQ(APInt(7, 6), APInt(7, 3).rotl(APInt(12, 120)));
1486 EXPECT_EQ(APInt(8, 16), APInt(8, 16).rotr(0));
1487 EXPECT_EQ(APInt(8, 8), APInt(8, 16).rotr(1));
1488 EXPECT_EQ(APInt(8, 4), APInt(8, 16).rotr(2));
1489 EXPECT_EQ(APInt(8, 1), APInt(8, 16).rotr(4));
1490 EXPECT_EQ(APInt(8, 16), APInt(8, 16).rotr(8));
1492 EXPECT_EQ(APInt(8, 1), APInt(8, 1).rotr(0));
1493 EXPECT_EQ(APInt(8, 128), APInt(8, 1).rotr(1));
1494 EXPECT_EQ(APInt(8, 64), APInt(8, 1).rotr(2));
1495 EXPECT_EQ(APInt(8, 16), APInt(8, 1).rotr(4));
1496 EXPECT_EQ(APInt(8, 1), APInt(8, 1).rotr(8));
1498 EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(33));
1499 EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(APInt(32, 33)));
1501 EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(33));
1502 EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(APInt(32, 33)));
1503 EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(APInt(33, 33)));
1504 EXPECT_EQ(APInt(32, (1 << 24)), APInt(32, 1).rotr(APInt(32, 40)));
1506 EXPECT_EQ(APInt(32, (1 << 2)), APInt(32, 1).rotr(APInt(31, 30)));
1507 EXPECT_EQ(APInt(32, (1 << 1)), APInt(32, 1).rotr(APInt(31, 31)));
1509 EXPECT_EQ(APInt(32, 1), APInt(32, 1).rotr(APInt(1, 0)));
1510 EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(APInt(1, 1)));
1512 EXPECT_EQ(APInt(32, (1 << 28)), APInt(32, 1).rotr(APInt(3, 4)));
1514 EXPECT_EQ(APInt(32, 1), APInt(32, 1).rotr(APInt(64, 64)));
1515 EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(APInt(64, 65)));
1517 EXPECT_EQ(APInt(7, 48), APInt(7, 3).rotr(APInt(7, 3)));
1518 EXPECT_EQ(APInt(7, 48), APInt(7, 3).rotr(APInt(7, 10)));
1519 EXPECT_EQ(APInt(7, 48), APInt(7, 3).rotr(APInt(5, 10)));
1520 EXPECT_EQ(APInt(7, 65), APInt(7, 3).rotr(APInt(12, 120)));
1524 EXPECT_EQ(Rot, Big.rotr(144));
1526 EXPECT_EQ(APInt(32, 8), APInt(32, 1).rotl(Big));
1527 EXPECT_EQ(APInt(32, (1 << 29)), APInt(32, 1).rotr(Big));
1532 EXPECT_EQ(ValA, APInt::getSplat(8, ValA));
1533 EXPECT_EQ(APInt(64, 0x0101010101010101ULL), APInt::getSplat(64, ValA));
1536 EXPECT_EQ(APInt(4, 0xD), APInt::getSplat(4, ValB));
1537 EXPECT_EQ(APInt(15, 0xDB6D), APInt::getSplat(15, ValB));
1547 EXPECT_EQ(carry, APInt::WordType(0));
1548 EXPECT_EQ(singleWord, ~APInt::WordType(0) >> 1);
1555 EXPECT_EQ(carry, APInt::WordType(1));
1556 EXPECT_EQ(singleWord, ~APInt::WordType(0));
1566 EXPECT_EQ(APInt::tcCompare(test, expected, 4), 0);
1574 EXPECT_EQ(carry, APInt::WordType(0));
1575 EXPECT_EQ(APInt::tcCompare(test, expected, 4), 0);
1583 EXPECT_EQ(carry, APInt::WordType(0));
1584 EXPECT_EQ(APInt::tcCompare(test, expected, 4), 0);
1592 EXPECT_EQ(carry, APInt::WordType(0));
1593 EXPECT_EQ(APInt::tcCompare(test, expected, 4), 0);
1601 EXPECT_EQ(carry, APInt::WordType(1));
1602 EXPECT_EQ(APInt::tcCompare(test, expected, 4), 0);
1611 EXPECT_EQ(bool(E1 & (1ULL << i)),
1625 EXPECT_EQ(bool(E2[i] & (1ULL << j)),
1645 EXPECT_EQ(A1.nearestLogBase2(), A1.ceilLogBase2());
1650 EXPECT_EQ(A2.nearestLogBase2(), A2.logBase2());
1655 EXPECT_EQ(A3.nearestLogBase2(), A3.ceilLogBase2());
1662 EXPECT_EQ(A4.nearestLogBase2(), A4.ceilLogBase2());
1667 EXPECT_EQ(A5.nearestLogBase2(), A5.logBase2());
1672 EXPECT_EQ(A6.nearestLogBase2(), A6.ceilLogBase2());
1676 EXPECT_EQ(A7.nearestLogBase2(), 0ULL);
1678 EXPECT_EQ(A8.nearestLogBase2(), UINT32_MAX);
1683 EXPECT_EQ(A9.nearestLogBase2(), UINT32_MAX);
1802 EXPECT_EQ(1, APInt(1, 1).reverseBits());
1803 EXPECT_EQ(0, APInt(1, 0).reverseBits());
1805 EXPECT_EQ(3, APInt(2, 3).reverseBits());
1806 EXPECT_EQ(3, APInt(2, 3).reverseBits());
1808 EXPECT_EQ(0xb, APInt(4, 0xd).reverseBits());
1809 EXPECT_EQ(0xd, APInt(4, 0xb).reverseBits());
1810 EXPECT_EQ(0xf, APInt(4, 0xf).reverseBits());
1812 EXPECT_EQ(0x30, APInt(7, 0x6).reverseBits());
1813 EXPECT_EQ(0x5a, APInt(7, 0x2d).reverseBits());
1815 EXPECT_EQ(0x0f, APInt(8, 0xf0).reverseBits());
1816 EXPECT_EQ(0xf0, APInt(8, 0x0f).reverseBits());
1818 EXPECT_EQ(0x0f0f, APInt(16, 0xf0f0).reverseBits());
1819 EXPECT_EQ(0xf0f0, APInt(16, 0x0f0f).reverseBits());
1821 EXPECT_EQ(0x0f0f0f0f, APInt(32, 0xf0f0f0f0).reverseBits());
1822 EXPECT_EQ(0xf0f0f0f0, APInt(32, 0x0f0f0f0f).reverseBits());
1824 EXPECT_EQ(0x402880a0 >> 1, APInt(31, 0x05011402).reverseBits());
1826 EXPECT_EQ(0x0f0f0f0f, APInt(32, 0xf0f0f0f0).reverseBits());
1827 EXPECT_EQ(0xf0f0f0f0, APInt(32, 0x0f0f0f0f).reverseBits());
1829 EXPECT_EQ(0x0f0f0f0f0f0f0f0f, APInt(64, 0xf0f0f0f0f0f0f0f0).reverseBits());
1830 EXPECT_EQ(0xf0f0f0f0f0f0f0f0, APInt(64, 0x0f0f0f0f0f0f0f0f).reverseBits());
1837 EXPECT_EQ(Y, X.reverseBits());
1838 EXPECT_EQ(X, Y.reverseBits());
1849 EXPECT_EQ(static_cast<int64_t>(0x00123456ull), i31.getSExtValue());
1854 EXPECT_EQ(static_cast<int64_t>(0x012345600123456Full), i63.getSExtValue());
1859 EXPECT_EQ(static_cast<int64_t>(0xFFFFFF80123456FFull), i120.getSExtValue());
1864 EXPECT_EQ(i127.extractBits(64, 0).getZExtValue(), 0x3456FFFFFFFFFFFFull);
1865 EXPECT_EQ(i127.extractBits(63, 64).getZExtValue(), 0x7FFFFFFFFFFF8012ull);
1871 EXPECT_EQ(-1, i128.getSExtValue());
1877 EXPECT_EQ(0u, i256.getSExtValue());
1881 EXPECT_EQ(i257.extractBits(64, 0).getZExtValue(), 0x0000000000000000ull);
1882 EXPECT_EQ(i257.extractBits(64, 64).getZExtValue(), 0xFFFFFFFFFFFFFFFFull);
1883 EXPECT_EQ(i257.extractBits(64, 128).getZExtValue(), 0x00000000FFFFFFFFull);
1884 EXPECT_EQ(i257.extractBits(65, 192).getZExtValue(), 0x0000000000000000ull);
1889 EXPECT_EQ(i260.extractBits(64, 0).getZExtValue(), 0x8000000000007FFFull);
1890 EXPECT_EQ(i260.extractBits(64, 64).getZExtValue(), 0x0000000000000000ull);
1891 EXPECT_EQ(i260.extractBits(64, 128).getZExtValue(), 0xFFFFFFFFFFFF0000ull);
1892 EXPECT_EQ(i260.extractBits(64, 192).getZExtValue(), 0xFFFFFFFFFFFFFFFFull);
1893 EXPECT_EQ(i260.extractBits(4, 256).getZExtValue(), 0x000000000000000Full);
1903 EXPECT_EQ(static_cast<int64_t>(0x00123456ull), i31.getSExtValue());
1908 EXPECT_EQ(static_cast<int64_t>(0x012345600123456Full), i63.getSExtValue());
1913 EXPECT_EQ(static_cast<int64_t>(0xFFFFFF80123456FFull), i120.getSExtValue());
1918 EXPECT_EQ(i127.extractBits(64, 0).getZExtValue(), 0x3456FFFFFFFFFFFFull);
1919 EXPECT_EQ(i127.extractBits(63, 64).getZExtValue(), 0x7FFFFFFFFFFF8012ull);
1925 EXPECT_EQ(-1, i128.getSExtValue());
1934 EXPECT_EQ(0u, i256.getSExtValue());
1938 EXPECT_EQ(i257.extractBitsAsZExtValue(64, 0), 0x0000000000000000ull);
1939 EXPECT_EQ(i257.extractBitsAsZExtValue(64, 64), 0xFFFFFFFFFFFFFFFFull);
1940 EXPECT_EQ(i257.extractBitsAsZExtValue(64, 128), 0x00000000FFFFFFFFull);
1941 EXPECT_EQ(i257.extractBitsAsZExtValue(64, 192), 0x0000000000000000ull);
1942 EXPECT_EQ(i257.extractBitsAsZExtValue(1, 256), 0x0000000000000000ull);
1947 EXPECT_EQ(i260.extractBitsAsZExtValue(64, 0), 0x8000000000007FFFull);
1948 EXPECT_EQ(i260.extractBitsAsZExtValue(64, 64), 0x0000000000000000ull);
1949 EXPECT_EQ(i260.extractBitsAsZExtValue(64, 128), 0xFFFFFFFFFFFF0000ull);
1950 EXPECT_EQ(i260.extractBitsAsZExtValue(64, 192), 0xFFFFFFFFFFFFFFFFull);
1951 EXPECT_EQ(i260.extractBitsAsZExtValue(4, 256), 0x000000000000000Full);
1956 EXPECT_EQ(0x3456, i32.extractBits(16, 4));
1959 EXPECT_EQ(0xFFu, i257.extractBits(16, 0));
1960 EXPECT_EQ((0xFFu >> 1), i257.extractBits(16, 1));
1961 EXPECT_EQ(-1, i257.extractBits(32, 64).getSExtValue());
1962 EXPECT_EQ(-1, i257.extractBits(128, 128).getSExtValue());
1963 EXPECT_EQ(-1, i257.extractBits(66, 191).getSExtValue());
1964 EXPECT_EQ(static_cast<int64_t>(0xFFFFFFFFFF80007Full),
1966 EXPECT_EQ(static_cast<int64_t>(0xFFFFFFFFFF80007Full),
1969 EXPECT_EQ(APInt(48, 0),
1971 EXPECT_EQ(APInt(48, 0x0000ffffffffffffull),
1973 EXPECT_EQ(APInt(48, 0x00007fffffffffffull),
1980 EXPECT_EQ(0x3456u, i32.extractBitsAsZExtValue(16, 4));
1983 EXPECT_EQ(0xFFu, i257.extractBitsAsZExtValue(16, 0));
1984 EXPECT_EQ((0xFFu >> 1), i257.extractBitsAsZExtValue(16, 1));
1985 EXPECT_EQ(0xFFFFFFFFull, i257.extractBitsAsZExtValue(32, 64));
1986 EXPECT_EQ(0xFFFFFFFFFFFFFFFFull, i257.extractBitsAsZExtValue(64, 128));
1987 EXPECT_EQ(0xFFFFFFFFFFFFFFFFull, i257.extractBitsAsZExtValue(64, 192));
1988 EXPECT_EQ(0xFFFFFFFFFFFFFFFFull, i257.extractBitsAsZExtValue(64, 191));
1989 EXPECT_EQ(0x3u, i257.extractBitsAsZExtValue(2, 255));
1990 EXPECT_EQ(0xFFFFFFFFFF80007Full, i257.extractBitsAsZExtValue(64, 1));
1991 EXPECT_EQ(0xFFFFFFFFFFFFFFFFull, i257.extractBitsAsZExtValue(64, 65));
1992 EXPECT_EQ(0xFFFFFFFFFF80007Full, i257.extractBitsAsZExtValue(64, 1));
1993 EXPECT_EQ(0xFFFFFFFFFFFFFFFFull, i257.extractBitsAsZExtValue(64, 65));
1994 EXPECT_EQ(0x1ull, i257.extractBitsAsZExtValue(1, 129));
1996 EXPECT_EQ(APInt(48, 0),
1998 EXPECT_EQ(APInt(48, 0x0000ffffffffffffull),
2000 EXPECT_EQ(APInt(48, 0x00007fffffffffffull),
2006 EXPECT_EQ(0u, i128lo64.countLeadingOnes());
2007 EXPECT_EQ(64u, i128lo64.countLeadingZeros());
2008 EXPECT_EQ(64u, i128lo64.getActiveBits());
2009 EXPECT_EQ(0u, i128lo64.countTrailingZeros());
2010 EXPECT_EQ(64u, i128lo64.countTrailingOnes());
2011 EXPECT_EQ(64u, i128lo64.countPopulation());
2016 EXPECT_EQ(0u, i64hi1lo1.countLeadingOnes());
2017 EXPECT_EQ(1u, i64hi1lo1.countLeadingZeros());
2018 EXPECT_EQ(63u, i64hi1lo1.getActiveBits());
2019 EXPECT_EQ(1u, i64hi1lo1.countTrailingZeros());
2020 EXPECT_EQ(0u, i64hi1lo1.countTrailingOnes());
2021 EXPECT_EQ(62u, i64hi1lo1.countPopulation());
2024 EXPECT_EQ(0u, i127hi1lo1.countLeadingOnes());
2025 EXPECT_EQ(1u, i127hi1lo1.countLeadingZeros());
2026 EXPECT_EQ(126u, i127hi1lo1.getActiveBits());
2027 EXPECT_EQ(1u, i127hi1lo1.countTrailingZeros());
2028 EXPECT_EQ(0u, i127hi1lo1.countTrailingOnes());
2029 EXPECT_EQ(125u, i127hi1lo1.countPopulation());
2034 EXPECT_EQ(32u, i64hi32.countLeadingOnes());
2035 EXPECT_EQ(0u, i64hi32.countLeadingZeros());
2036 EXPECT_EQ(64u, i64hi32.getActiveBits());
2037 EXPECT_EQ(32u, i64hi32.countTrailingZeros());
2038 EXPECT_EQ(0u, i64hi32.countTrailingOnes());
2039 EXPECT_EQ(32u, i64hi32.countPopulation());
2044 EXPECT_EQ(31u, i64hi31.countLeadingOnes());
2045 EXPECT_EQ(0u, i64hi31.countLeadingZeros());
2046 EXPECT_EQ(64u, i64hi31.getActiveBits());
2047 EXPECT_EQ(33u, i64hi31.countTrailingZeros());
2048 EXPECT_EQ(0u, i64hi31.countTrailingOnes());
2049 EXPECT_EQ(31u, i64hi31.countPopulation());
2055 EXPECT_EQ(0u, i64lo32.countLeadingOnes());
2056 EXPECT_EQ(32u, i64lo32.countLeadingZeros());
2057 EXPECT_EQ(32u, i64lo32.getActiveBits());
2058 EXPECT_EQ(0u, i64lo32.countTrailingZeros());
2059 EXPECT_EQ(32u, i64lo32.countTrailingOnes());
2060 EXPECT_EQ(32u, i64lo32.countPopulation());
2064 EXPECT_EQ(0u, i128lo64.countLeadingOnes());
2065 EXPECT_EQ(64u, i128lo64.countLeadingZeros());
2066 EXPECT_EQ(64u, i128lo64.getActiveBits());
2067 EXPECT_EQ(0u, i128lo64.countTrailingZeros());
2068 EXPECT_EQ(64u, i128lo64.countTrailingOnes());
2069 EXPECT_EQ(64u, i128lo64.countPopulation());
2073 EXPECT_EQ(0u, i128lo24.countLeadingOnes());
2074 EXPECT_EQ(104u, i128lo24.countLeadingZeros());
2075 EXPECT_EQ(24u, i128lo24.getActiveBits());
2076 EXPECT_EQ(0u, i128lo24.countTrailingZeros());
2077 EXPECT_EQ(24u, i128lo24.countTrailingOnes());
2078 EXPECT_EQ(24u, i128lo24.countPopulation());
2082 EXPECT_EQ(0u, i128lo104.countLeadingOnes());
2083 EXPECT_EQ(24u, i128lo104.countLeadingZeros());
2084 EXPECT_EQ(104u, i128lo104.getActiveBits());
2085 EXPECT_EQ(0u, i128lo104.countTrailingZeros());
2086 EXPECT_EQ(104u, i128lo104.countTrailingOnes());
2087 EXPECT_EQ(104u, i128lo104.countPopulation());
2091 EXPECT_EQ(0u, i128lo0.countLeadingOnes());
2092 EXPECT_EQ(128u, i128lo0.countLeadingZeros());
2093 EXPECT_EQ(0u, i128lo0.getActiveBits());
2094 EXPECT_EQ(128u, i128lo0.countTrailingZeros());
2095 EXPECT_EQ(0u, i128lo0.countTrailingOnes());
2096 EXPECT_EQ(0u, i128lo0.countPopulation());
2100 EXPECT_EQ(0u, i80lo79.countLeadingOnes());
2101 EXPECT_EQ(1u, i80lo79.countLeadingZeros());
2102 EXPECT_EQ(79u, i80lo79.getActiveBits());
2103 EXPECT_EQ(0u, i80lo79.countTrailingZeros());
2104 EXPECT_EQ(79u, i80lo79.countTrailingOnes());
2105 EXPECT_EQ(79u, i80lo79.countPopulation());
2111 EXPECT_EQ(32u, i64hi32.countLeadingOnes());
2112 EXPECT_EQ(0u, i64hi32.countLeadingZeros());
2113 EXPECT_EQ(64u, i64hi32.getActiveBits());
2114 EXPECT_EQ(32u, i64hi32.countTrailingZeros());
2115 EXPECT_EQ(0u, i64hi32.countTrailingOnes());
2116 EXPECT_EQ(32u, i64hi32.countPopulation());
2120 EXPECT_EQ(64u, i128hi64.countLeadingOnes());
2121 EXPECT_EQ(0u, i128hi64.countLeadingZeros());
2122 EXPECT_EQ(128u, i128hi64.getActiveBits());
2123 EXPECT_EQ(64u, i128hi64.countTrailingZeros());
2124 EXPECT_EQ(0u, i128hi64.countTrailingOnes());
2125 EXPECT_EQ(64u, i128hi64.countPopulation());
2129 EXPECT_EQ(24u, i128hi24.countLeadingOnes());
2130 EXPECT_EQ(0u, i128hi24.countLeadingZeros());
2131 EXPECT_EQ(128u, i128hi24.getActiveBits());
2132 EXPECT_EQ(104u, i128hi24.countTrailingZeros());
2133 EXPECT_EQ(0u, i128hi24.countTrailingOnes());
2134 EXPECT_EQ(24u, i128hi24.countPopulation());
2138 EXPECT_EQ(104u, i128hi104.countLeadingOnes());
2139 EXPECT_EQ(0u, i128hi104.countLeadingZeros());
2140 EXPECT_EQ(128u, i128hi104.getActiveBits());
2141 EXPECT_EQ(24u, i128hi104.countTrailingZeros());
2142 EXPECT_EQ(0u, i128hi104.countTrailingOnes());
2143 EXPECT_EQ(104u, i128hi104.countPopulation());
2147 EXPECT_EQ(0u, i128hi0.countLeadingOnes());
2148 EXPECT_EQ(128u, i128hi0.countLeadingZeros());
2149 EXPECT_EQ(0u, i128hi0.getActiveBits());
2150 EXPECT_EQ(128u, i128hi0.countTrailingZeros());
2151 EXPECT_EQ(0u, i128hi0.countTrailingOnes());
2152 EXPECT_EQ(0u, i128hi0.countPopulation());
2156 EXPECT_EQ(1u, i80hi1.countLeadingOnes());
2157 EXPECT_EQ(0u, i80hi1.countLeadingZeros());
2158 EXPECT_EQ(80u, i80hi1.getActiveBits());
2159 EXPECT_EQ(79u, i80hi1.countTrailingZeros());
2160 EXPECT_EQ(0u, i80hi1.countTrailingOnes());
2161 EXPECT_EQ(1u, i80hi1.countPopulation());
2165 EXPECT_EQ(16u, i32hi16.countLeadingOnes());
2166 EXPECT_EQ(0u, i32hi16.countLeadingZeros());
2167 EXPECT_EQ(32u, i32hi16.getActiveBits());
2168 EXPECT_EQ(16u, i32hi16.countTrailingZeros());
2169 EXPECT_EQ(0u, i32hi16.countTrailingOnes());
2170 EXPECT_EQ(16u, i32hi16.countPopulation());
2176 EXPECT_EQ(1u, i64from63.countLeadingOnes());
2177 EXPECT_EQ(0u, i64from63.countLeadingZeros());
2178 EXPECT_EQ(64u, i64from63.getActiveBits());
2179 EXPECT_EQ(63u, i64from63.countTrailingZeros());
2180 EXPECT_EQ(0u, i64from63.countTrailingOnes());
2181 EXPECT_EQ(1u, i64from63.countPopulation());
2187 EXPECT_EQ(32u, i32.countLeadingOnes());
2188 EXPECT_EQ(0u, i32.countLeadingZeros());
2189 EXPECT_EQ(32u, i32.getActiveBits());
2190 EXPECT_EQ(0u, i32.countTrailingZeros());
2191 EXPECT_EQ(32u, i32.countTrailingOnes());
2192 EXPECT_EQ(32u, i32.countPopulation());
2196 EXPECT_EQ(64u, i64.countLeadingOnes());
2197 EXPECT_EQ(0u, i64.countLeadingZeros());
2198 EXPECT_EQ(64u, i64.getActiveBits());
2199 EXPECT_EQ(0u, i64.countTrailingZeros());
2200 EXPECT_EQ(64u, i64.countTrailingOnes());
2201 EXPECT_EQ(64u, i64.countPopulation());
2205 EXPECT_EQ(96u, i96.countLeadingOnes());
2206 EXPECT_EQ(0u, i96.countLeadingZeros());
2207 EXPECT_EQ(96u, i96.getActiveBits());
2208 EXPECT_EQ(0u, i96.countTrailingZeros());
2209 EXPECT_EQ(96u, i96.countTrailingOnes());
2210 EXPECT_EQ(96u, i96.countPopulation());
2214 EXPECT_EQ(128u, i128.countLeadingOnes());
2215 EXPECT_EQ(0u, i128.countLeadingZeros());
2216 EXPECT_EQ(128u, i128.getActiveBits());
2217 EXPECT_EQ(0u, i128.countTrailingZeros());
2218 EXPECT_EQ(128u, i128.countTrailingOnes());
2219 EXPECT_EQ(128u, i128.countPopulation());
2225 EXPECT_EQ(0xa, i32.getLoBits(4));
2228 EXPECT_EQ(0xa, i128.getLoBits(4));
2234 EXPECT_EQ(0xc, i32.getHiBits(4));
2237 EXPECT_EQ(0xc, i128.getHiBits(4));
2243 EXPECT_EQ(32u, i64hi32.countLeadingOnes());
2244 EXPECT_EQ(0u, i64hi32.countLeadingZeros());
2245 EXPECT_EQ(64u, i64hi32.getActiveBits());
2246 EXPECT_EQ(32u, i64hi32.countTrailingZeros());
2247 EXPECT_EQ(0u, i64hi32.countTrailingOnes());
2248 EXPECT_EQ(32u, i64hi32.countPopulation());
2252 EXPECT_EQ(64u, i128hi64.countLeadingOnes());
2253 EXPECT_EQ(0u, i128hi64.countLeadingZeros());
2254 EXPECT_EQ(128u, i128hi64.getActiveBits());
2255 EXPECT_EQ(64u, i128hi64.countTrailingZeros());
2256 EXPECT_EQ(0u, i128hi64.countTrailingOnes());
2257 EXPECT_EQ(64u, i128hi64.countPopulation());
2261 EXPECT_EQ(24u, i128hi24.countLeadingOnes());
2262 EXPECT_EQ(0u, i128hi24.countLeadingZeros());
2263 EXPECT_EQ(128u, i128hi24.getActiveBits());
2264 EXPECT_EQ(104u, i128hi24.countTrailingZeros());
2265 EXPECT_EQ(0u, i128hi24.countTrailingOnes());
2266 EXPECT_EQ(24u, i128hi24.countPopulation());
2270 EXPECT_EQ(104u, i128hi104.countLeadingOnes());
2271 EXPECT_EQ(0u, i128hi104.countLeadingZeros());
2272 EXPECT_EQ(128u, i128hi104.getActiveBits());
2273 EXPECT_EQ(24u, i128hi104.countTrailingZeros());
2274 EXPECT_EQ(0u, i128hi104.countTrailingOnes());
2275 EXPECT_EQ(104u, i128hi104.countPopulation());
2279 EXPECT_EQ(0u, i128hi0.countLeadingOnes());
2280 EXPECT_EQ(128u, i128hi0.countLeadingZeros());
2281 EXPECT_EQ(0u, i128hi0.getActiveBits());
2282 EXPECT_EQ(128u, i128hi0.countTrailingZeros());
2283 EXPECT_EQ(0u, i128hi0.countTrailingOnes());
2284 EXPECT_EQ(0u, i128hi0.countPopulation());
2288 EXPECT_EQ(1u, i80hi1.countLeadingOnes());
2289 EXPECT_EQ(0u, i80hi1.countLeadingZeros());
2290 EXPECT_EQ(80u, i80hi1.getActiveBits());
2291 EXPECT_EQ(79u, i80hi1.countTrailingZeros());
2292 EXPECT_EQ(0u, i80hi1.countTrailingOnes());
2293 EXPECT_EQ(1u, i80hi1.countPopulation());
2297 EXPECT_EQ(16u, i32hi16.countLeadingOnes());
2298 EXPECT_EQ(0u, i32hi16.countLeadingZeros());
2299 EXPECT_EQ(32u, i32hi16.getActiveBits());
2300 EXPECT_EQ(16u, i32hi16.countTrailingZeros());
2301 EXPECT_EQ(0u, i32hi16.countTrailingOnes());
2302 EXPECT_EQ(16u, i32hi16.countPopulation());
2311 EXPECT_EQ(GreatestCommonDivisor(Zero, Zero), Zero);
2312 EXPECT_EQ(GreatestCommonDivisor(Zero, One), One);
2313 EXPECT_EQ(GreatestCommonDivisor(One, Zero), One);
2314 EXPECT_EQ(GreatestCommonDivisor(One, One), One);
2318 EXPECT_EQ(GreatestCommonDivisor(Zero, Two), Two);
2319 EXPECT_EQ(GreatestCommonDivisor(One, Two), One);
2320 EXPECT_EQ(GreatestCommonDivisor(Two, Two), Two);
2325 EXPECT_EQ(GreatestCommonDivisor(Zero, Max), Max);
2326 EXPECT_EQ(GreatestCommonDivisor(One, Max), One);
2327 EXPECT_EQ(GreatestCommonDivisor(Two, Max), One);
2328 EXPECT_EQ(GreatestCommonDivisor(Max, Max), Max);
2331 EXPECT_EQ(GreatestCommonDivisor(MaxOver2, Max), One);
2333 EXPECT_EQ(GreatestCommonDivisor(MaxOver2, Max - 1), MaxOver2);
2345 EXPECT_EQ(C, HugePrime);
2352 EXPECT_EQ(1U, i256.countLeadingZeros());
2353 EXPECT_EQ(253U, i256.countTrailingZeros());
2354 EXPECT_EQ(2U, i256.countPopulation());
2357 EXPECT_EQ(63U, i256.countLeadingZeros());
2358 EXPECT_EQ(191U, i256.countTrailingZeros());
2359 EXPECT_EQ(2U, i256.countPopulation());
2362 EXPECT_EQ(128U, i256.countLeadingZeros());
2363 EXPECT_EQ(126U, i256.countTrailingZeros());
2364 EXPECT_EQ(2U, i256.countPopulation());
2367 EXPECT_EQ(192U, i256.countLeadingZeros());
2368 EXPECT_EQ(62U, i256.countTrailingZeros());
2369 EXPECT_EQ(2U, i256.countPopulation());
2372 EXPECT_EQ(255U, i256.countLeadingZeros());
2373 EXPECT_EQ(0U, i256.countTrailingZeros());
2374 EXPECT_EQ(1U, i256.countPopulation());
2378 EXPECT_EQ(0, neg_one.lshr(128));
2384 EXPECT_EQ(47U, i72.countLeadingOnes());
2385 EXPECT_EQ(25U, i72.countTrailingZeros());
2386 EXPECT_EQ(47U, i72.countPopulation());
2390 EXPECT_EQ(65U, i72.countLeadingOnes());
2391 EXPECT_EQ(7U, i72.countTrailingZeros());
2392 EXPECT_EQ(65U, i72.countPopulation());
2396 EXPECT_EQ(65U, i128.countLeadingOnes());
2397 EXPECT_EQ(63U, i128.countTrailingZeros());
2398 EXPECT_EQ(65U, i128.countPopulation());
2406 EXPECT_EQ(0, umax32.ashr(32));
2414 EXPECT_EQ(0, umax128.ashr(128));
2421 EXPECT_EQ(253U, i256.countLeadingZeros());
2422 EXPECT_EQ(1U, i256.countTrailingZeros());
2423 EXPECT_EQ(2U, i256.countPopulation());
2426 EXPECT_EQ(191U, i256.countLeadingZeros());
2427 EXPECT_EQ(63U, i256.countTrailingZeros());
2428 EXPECT_EQ(2U, i256.countPopulation());
2431 EXPECT_EQ(126U, i256.countLeadingZeros());
2432 EXPECT_EQ(128U, i256.countTrailingZeros());
2433 EXPECT_EQ(2U, i256.countPopulation());
2436 EXPECT_EQ(62U, i256.countLeadingZeros());
2437 EXPECT_EQ(192U, i256.countTrailingZeros());
2438 EXPECT_EQ(2U, i256.countPopulation());
2441 EXPECT_EQ(0U, i256.countLeadingZeros());
2442 EXPECT_EQ(255U, i256.countTrailingZeros());
2443 EXPECT_EQ(1U, i256.countPopulation());
2447 EXPECT_EQ(0, neg_one.shl(128));
2480 EXPECT_EQ(0, APInt(1, 0).sext(64));
2481 EXPECT_EQ(~uint64_t(0), APInt(1, 1).sext(64));
2484 EXPECT_EQ(32U, i32_max.countLeadingZeros());
2485 EXPECT_EQ(0U, i32_max.countTrailingZeros());
2486 EXPECT_EQ(31U, i32_max.countPopulation());
2489 EXPECT_EQ(32U, i32_min.countLeadingOnes());
2490 EXPECT_EQ(31U, i32_min.countTrailingZeros());
2491 EXPECT_EQ(32U, i32_min.countPopulation());
2494 EXPECT_EQ(63U, i32_neg1.countLeadingOnes());
2495 EXPECT_EQ(0U, i32_neg1.countTrailingZeros());
2496 EXPECT_EQ(63U, i32_neg1.countPopulation());
2502 EXPECT_EQ(7006652, i64 * 5678);
2503 EXPECT_EQ(7006652, 5678 * i64);
2508 EXPECT_EQ(i128_1234, i128 * 1234);
2509 EXPECT_EQ(i128_1234, 1234 * i128);
2513 EXPECT_EQ(32U, i96.countLeadingOnes());
2514 EXPECT_EQ(32U, i96.countPopulation());
2515 EXPECT_EQ(64U, i96.countTrailingZeros());
2522 EXPECT_EQ(0, APIntOps::RoundingUDiv(Zero, A, APInt::Rounding::UP));
2523 EXPECT_EQ(0, APIntOps::RoundingUDiv(Zero, A, APInt::Rounding::DOWN));
2524 EXPECT_EQ(0, APIntOps::RoundingUDiv(Zero, A, APInt::Rounding::TOWARD_ZERO));
2538 EXPECT_EQ(Quo, APIntOps::RoundingUDiv(A, B, APInt::Rounding::TOWARD_ZERO));
2539 EXPECT_EQ(Quo, APIntOps::RoundingUDiv(A, B, APInt::Rounding::DOWN));
2551 EXPECT_EQ(0, APIntOps::RoundingSDiv(Zero, A, APInt::Rounding::UP));
2552 EXPECT_EQ(0, APIntOps::RoundingSDiv(Zero, A, APInt::Rounding::DOWN));
2553 EXPECT_EQ(0, APIntOps::RoundingSDiv(Zero, A, APInt::Rounding::TOWARD_ZERO));
2579 EXPECT_EQ(Quo, APIntOps::RoundingSDiv(A, B, APInt::Rounding::TOWARD_ZERO));
2727 EXPECT_EQ(APIntOps::GetMostSignificantDifferentBit(APInt(8, 0), APInt(8, 0)),
2729 EXPECT_EQ(
2732 EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 0), APInt(8, 1)),
2734 EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 0), APInt(8, 2)),
2736 EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 0), APInt(8, 3)),
2738 EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 1), APInt(8, 0)),
2740 EXPECT_EQ(APIntOps::GetMostSignificantDifferentBit(APInt(8, 1), APInt(8, 1)),
2742 EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 1), APInt(8, 2)),
2744 EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 1), APInt(8, 3)),
2746 EXPECT_EQ(
2773 EXPECT_EQ(Bit, GetHighestDifferentBitBruteforce(A, B));
2776 EXPECT_EQ(A, B);
2787 EXPECT_EQ(Adash, Bdash);
unittests/ADT/APSIntTest.cpp 31 EXPECT_EQ(Bits, D.getRawData()); // Verify that "Wide" was really moved.
40 EXPECT_EQ(Bits, A.getRawData()); // Verify that "Wide" was really moved.
45 EXPECT_EQ(64u, APSInt::get(7).getBitWidth());
46 EXPECT_EQ(7u, APSInt::get(7).getZExtValue());
47 EXPECT_EQ(7, APSInt::get(7).getSExtValue());
49 EXPECT_EQ(64u, APSInt::get(-7).getBitWidth());
50 EXPECT_EQ(-7, APSInt::get(-7).getSExtValue());
51 EXPECT_EQ(UINT64_C(0) - 7, APSInt::get(-7).getZExtValue());
56 EXPECT_EQ(64u, APSInt::getUnsigned(7).getBitWidth());
57 EXPECT_EQ(7u, APSInt::getUnsigned(7).getZExtValue());
58 EXPECT_EQ(7, APSInt::getUnsigned(7).getSExtValue());
60 EXPECT_EQ(64u, APSInt::getUnsigned(-7).getBitWidth());
61 EXPECT_EQ(-7, APSInt::getUnsigned(-7).getSExtValue());
62 EXPECT_EQ(UINT64_C(0) - 7, APSInt::getUnsigned(-7).getZExtValue());
72 EXPECT_EQ(7, APSInt(APInt(3, 7), true).getExtValue());
73 EXPECT_EQ(-1, APSInt(APInt(3, 7), false).getExtValue());
74 EXPECT_EQ(7, APSInt(APInt(4, 7), true).getExtValue());
75 EXPECT_EQ(7, APSInt(APInt(4, 7), false).getExtValue());
76 EXPECT_EQ(9, APSInt(APInt(4, -7), true).getExtValue());
77 EXPECT_EQ(-7, APSInt(APInt(4, -7), false).getExtValue());
146 EXPECT_EQ(APSInt("1").getExtValue(), 1);
147 EXPECT_EQ(APSInt("-1").getExtValue(), -1);
148 EXPECT_EQ(APSInt("0").getExtValue(), 0);
149 EXPECT_EQ(APSInt("56789").getExtValue(), 56789);
150 EXPECT_EQ(APSInt("-1234").getExtValue(), -1234);
unittests/ADT/AnyTest.cpp 86 EXPECT_EQ(7, llvm::any_cast<int>(B));
87 EXPECT_EQ(7, llvm::any_cast<int>(B));
92 EXPECT_EQ('x', llvm::any_cast<char>(E));
93 EXPECT_EQ('x', llvm::any_cast<char>(E));
96 EXPECT_EQ(7, llvm::any_cast<int>(F));
97 EXPECT_EQ(7, llvm::any_cast<int>(F));
100 EXPECT_EQ(8, llvm::any_cast<int>(G));
101 EXPECT_EQ(8, llvm::any_cast<int>(G));
104 EXPECT_EQ(7, llvm::any_cast<int>(A));
105 EXPECT_EQ(7, llvm::any_cast<int>(A));
108 EXPECT_EQ(8, llvm::any_cast<int>(E));
109 EXPECT_EQ(8, llvm::any_cast<int>(E));
113 EXPECT_EQ(8, llvm::any_cast<int>(std::move(E)));
118 EXPECT_EQ(7, *llvm::any_cast<int>(&A));
121 EXPECT_EQ(42, llvm::any_cast<int>(A));
126 EXPECT_EQ(43, llvm::any_cast<int>(A));
141 EXPECT_EQ(0, T1.Copies);
142 EXPECT_EQ(2, T1.Moves);
147 EXPECT_EQ(1, T2.Copies);
148 EXPECT_EQ(1, T2.Moves);
152 EXPECT_EQ(0, T3.Copies);
153 EXPECT_EQ(2, T3.Moves);
unittests/ADT/ArrayRefTest.cpp 74 EXPECT_EQ(makeArrayRef(Array3Src), Array3Copy);
84 EXPECT_EQ(1U, AR.drop_back(AR.size() - 1).size());
87 EXPECT_EQ(1U, AR.drop_front(AR.size() - 1).size());
90 EXPECT_EQ(1U, AR.slice(AR.size() - 1).size());
91 EXPECT_EQ(AR.size() - 1, AR.slice(1, AR.size() - 1).size());
112 EXPECT_EQ(Expected, AR1.drop_while([](const int &N) { return N % 2 == 1; }));
114 EXPECT_EQ(AR1, AR1.drop_while([](const int &N) { return N < 0; }));
115 EXPECT_EQ(ArrayRef<int>(),
123 EXPECT_EQ(Expected, AR1.drop_until([](const int &N) { return N % 2 == 0; }));
125 EXPECT_EQ(ArrayRef<int>(),
127 EXPECT_EQ(AR1, AR1.drop_until([](const int &N) { return N > 0; }));
148 EXPECT_EQ(Expected, AR1.take_while([](const int &N) { return N % 2 == 1; }));
150 EXPECT_EQ(ArrayRef<int>(),
152 EXPECT_EQ(AR1, AR1.take_while([](const int &N) { return N > 0; }));
159 EXPECT_EQ(Expected, AR1.take_until([](const int &N) { return N % 2 == 0; }));
161 EXPECT_EQ(AR1, AR1.take_until([](const int &N) { return N < 0; }));
162 EXPECT_EQ(ArrayRef<int>(),
205 EXPECT_EQ(2U, A.size());
206 EXPECT_EQ(1, A[0]);
207 EXPECT_EQ(2, A[1]);
214 EXPECT_EQ(i, A[i]);
218 EXPECT_EQ(1, A[0]);
219 EXPECT_EQ(2, A[1]);
239 EXPECT_EQ(&AR1, &AR1Ref);
252 EXPECT_EQ(A.data(), nullptr);
259 EXPECT_EQ(A1.size(), A2.size());
261 EXPECT_EQ(A1[i], A2[i]);
unittests/ADT/BitVectorTest.cpp 27 EXPECT_EQ(0U, Vec.count());
28 EXPECT_EQ(0U, Vec.size());
35 EXPECT_EQ(5U, Vec.count());
36 EXPECT_EQ(5U, Vec.size());
43 EXPECT_EQ(5U, Vec.count());
44 EXPECT_EQ(11U, Vec.size());
52 EXPECT_EQ(6U, Inv.count());
53 EXPECT_EQ(11U, Inv.size());
78 EXPECT_EQ(Count, Vec.count());
79 EXPECT_EQ(Count, 23u);
108 EXPECT_EQ(Count, Vec.count());
109 EXPECT_EQ(Count, 42u);
117 EXPECT_EQ(Count + 1, Vec.count());
120 EXPECT_EQ(Count, Vec.count());
124 EXPECT_EQ(Count - 1, Vec.count());
127 EXPECT_EQ(Count, Vec.count());
130 EXPECT_EQ(Vec.size() - Count, Vec.count());
133 EXPECT_EQ(0U, Vec.count());
134 EXPECT_EQ(130U, Vec.size());
141 EXPECT_EQ(130U, Vec.count());
142 EXPECT_EQ(130U, Vec.size());
149 EXPECT_EQ(64U, Vec.count());
150 EXPECT_EQ(64U, Vec.size());
157 EXPECT_EQ(0U, Vec.count());
158 EXPECT_EQ(64U, Vec.size());
165 EXPECT_EQ(0U, Inv.count());
166 EXPECT_EQ(0U, Inv.size());
173 EXPECT_EQ(0U, Vec.count());
174 EXPECT_EQ(0U, Vec.size());
190 EXPECT_EQ(75, A.find_last());
191 EXPECT_EQ(12, A.find_first());
192 EXPECT_EQ(13, A.find_next(12));
193 EXPECT_EQ(75, A.find_next(13));
194 EXPECT_EQ(-1, A.find_next(75));
196 EXPECT_EQ(-1, A.find_prev(12));
197 EXPECT_EQ(12, A.find_prev(13));
198 EXPECT_EQ(13, A.find_prev(75));
199 EXPECT_EQ(75, A.find_prev(90));
201 EXPECT_EQ(0, A.find_first_unset());
202 EXPECT_EQ(99, A.find_last_unset());
203 EXPECT_EQ(14, A.find_next_unset(11));
204 EXPECT_EQ(14, A.find_next_unset(12));
205 EXPECT_EQ(14, A.find_next_unset(13));
206 EXPECT_EQ(16, A.find_next_unset(15));
207 EXPECT_EQ(76, A.find_next_unset(74));
208 EXPECT_EQ(76, A.find_next_unset(75));
209 EXPECT_EQ(-1, A.find_next_unset(99));
212 EXPECT_EQ(100U, A.count());
213 EXPECT_EQ(0, A.find_first());
214 EXPECT_EQ(-1, A.find_first_unset());
215 EXPECT_EQ(-1, A.find_last_unset());
216 EXPECT_EQ(99, A.find_last());
217 EXPECT_EQ(99, A.find_next(98));
220 EXPECT_EQ(0U, A.count());
221 EXPECT_EQ(-1, A.find_first());
222 EXPECT_EQ(-1, A.find_last());
223 EXPECT_EQ(0, A.find_first_unset());
224 EXPECT_EQ(99, A.find_last_unset());
225 EXPECT_EQ(99, A.find_next_unset(98));
238 EXPECT_EQ(47, A.find_last());
239 EXPECT_EQ(12, A.find_first());
240 EXPECT_EQ(13, A.find_next(12));
241 EXPECT_EQ(47, A.find_next(13));
242 EXPECT_EQ(-1, A.find_next(47));
244 EXPECT_EQ(-1, A.find_prev(12));
245 EXPECT_EQ(12, A.find_prev(13));
246 EXPECT_EQ(13, A.find_prev(47));
247 EXPECT_EQ(47, A.find_prev(56));
249 EXPECT_EQ(0, A.find_first_unset());
250 EXPECT_EQ(56, A.find_last_unset());
251 EXPECT_EQ(14, A.find_next_unset(11));
252 EXPECT_EQ(14, A.find_next_unset(12));
253 EXPECT_EQ(14, A.find_next_unset(13));
254 EXPECT_EQ(16, A.find_next_unset(15));
255 EXPECT_EQ(48, A.find_next_unset(46));
256 EXPECT_EQ(48, A.find_next_unset(47));
257 EXPECT_EQ(-1, A.find_next_unset(56));
275 EXPECT_EQ(-1, A.find_first());
276 EXPECT_EQ(-1, A.find_last());
277 EXPECT_EQ(-1, A.find_first_unset());
278 EXPECT_EQ(-1, A.find_last_unset());
285 EXPECT_EQ(16, A.find_last());
286 EXPECT_EQ(3, A.find_first());
287 EXPECT_EQ(3, A.find_next(1));
288 EXPECT_EQ(4, A.find_next(3));
289 EXPECT_EQ(16, A.find_next(4));
290 EXPECT_EQ(-1, A.find_next(16));
292 EXPECT_EQ(-1, A.find_prev(3));
293 EXPECT_EQ(3, A.find_prev(4));
294 EXPECT_EQ(4, A.find_prev(16));
295 EXPECT_EQ(16, A.find_prev(18));
297 EXPECT_EQ(0, A.find_first_unset());
298 EXPECT_EQ(19, A.find_last_unset());
299 EXPECT_EQ(5, A.find_next_unset(3));
300 EXPECT_EQ(5, A.find_next_unset(4));
301 EXPECT_EQ(13, A.find_next_unset(12));
302 EXPECT_EQ(17, A.find_next_unset(15));
317 EXPECT_EQ(-1, Vec.find_first_in(0, 0));
318 EXPECT_EQ(-1, Vec.find_first_in(24, 24));
319 EXPECT_EQ(-1, Vec.find_first_in(7, 24));
321 EXPECT_EQ(3, Vec.find_first_in(0, 10));
322 EXPECT_EQ(4, Vec.find_first_in(4, 10));
323 EXPECT_EQ(150, Vec.find_first_in(100, 200));
324 EXPECT_EQ(152, Vec.find_first_in(151, 200));
325 EXPECT_EQ(154, Vec.find_first_in(153, 200));
327 EXPECT_EQ(-1, Vec.find_first_in(155, 200));
329 EXPECT_EQ(199, Vec.find_first_in(199, 200));
333 EXPECT_EQ(-1, Vec.find_last_in(0, 0));
334 EXPECT_EQ(-1, Vec.find_last_in(24, 24));
335 EXPECT_EQ(-1, Vec.find_last_in(7, 24));
337 EXPECT_EQ(6, Vec.find_last_in(0, 10));
338 EXPECT_EQ(5, Vec.find_last_in(0, 6));
339 EXPECT_EQ(154, Vec.find_last_in(100, 155));
340 EXPECT_EQ(152, Vec.find_last_in(100, 154));
341 EXPECT_EQ(150, Vec.find_last_in(100, 152));
342 EXPECT_EQ(-1, Vec.find_last_in(100, 150));
344 EXPECT_EQ(199, Vec.find_last_in(199, 200));
348 EXPECT_EQ(-1, Vec.find_first_unset_in(0, 0));
349 EXPECT_EQ(-1, Vec.find_first_unset_in(23, 23));
350 EXPECT_EQ(-1, Vec.find_first_unset_in(24, 35));
352 EXPECT_EQ(0, Vec.find_first_unset_in(0, 10));
353 EXPECT_EQ(1, Vec.find_first_unset_in(1, 10));
354 EXPECT_EQ(7, Vec.find_first_unset_in(5, 25));
355 EXPECT_EQ(151, Vec.find_first_unset_in(150, 200));
356 EXPECT_EQ(151, Vec.find_first_unset_in(151, 200));
357 EXPECT_EQ(153, Vec.find_first_unset_in(152, 200));
358 EXPECT_EQ(153, Vec.find_first_unset_in(153, 200));
359 EXPECT_EQ(155, Vec.find_first_unset_in(154, 200));
360 EXPECT_EQ(155, Vec.find_first_unset_in(155, 200));
361 EXPECT_EQ(199, Vec.find_first_unset_in(199, 200));
364 EXPECT_EQ(-1, Vec.find_last_unset_in(0, 0));
365 EXPECT_EQ(-1, Vec.find_last_unset_in(23, 23));
366 EXPECT_EQ(-1, Vec.find_last_unset_in(24, 35));
368 EXPECT_EQ(9, Vec.find_last_unset_in(0, 10));
369 EXPECT_EQ(8, Vec.find_last_unset_in(0, 9));
370 EXPECT_EQ(2, Vec.find_last_unset_in(0, 7));
371 EXPECT_EQ(149, Vec.find_last_unset_in(100, 151));
372 EXPECT_EQ(151, Vec.find_last_unset_in(100, 152));
373 EXPECT_EQ(151, Vec.find_last_unset_in(100, 153));
374 EXPECT_EQ(153, Vec.find_last_unset_in(100, 154));
375 EXPECT_EQ(153, Vec.find_last_unset_in(100, 155));
376 EXPECT_EQ(155, Vec.find_last_unset_in(100, 156));
377 EXPECT_EQ(199, Vec.find_last_unset_in(199, 200));
395 EXPECT_EQ(-1, Vec.find_first_in(0, 0));
396 EXPECT_EQ(-1, Vec.find_first_in(24, 24));
397 EXPECT_EQ(-1, Vec.find_first_in(9, 12));
399 EXPECT_EQ(2, Vec.find_first_in(0, 10));
400 EXPECT_EQ(6, Vec.find_first_in(4, 10));
401 EXPECT_EQ(19, Vec.find_first_in(18, 25));
402 EXPECT_EQ(21, Vec.find_first_in(20, 25));
403 EXPECT_EQ(23, Vec.find_first_in(22, 25));
404 EXPECT_EQ(-1, Vec.find_first_in(24, 25));
407 EXPECT_EQ(-1, Vec.find_last_in(0, 0));
408 EXPECT_EQ(-1, Vec.find_last_in(24, 24));
409 EXPECT_EQ(-1, Vec.find_last_in(9, 12));
411 EXPECT_EQ(8, Vec.find_last_in(0, 10));
412 EXPECT_EQ(3, Vec.find_last_in(0, 6));
413 EXPECT_EQ(23, Vec.find_last_in(18, 25));
414 EXPECT_EQ(21, Vec.find_last_in(18, 23));
415 EXPECT_EQ(19, Vec.find_last_in(18, 21));
416 EXPECT_EQ(-1, Vec.find_last_in(18, 19));
419 EXPECT_EQ(-1, Vec.find_first_unset_in(0, 0));
420 EXPECT_EQ(-1, Vec.find_first_unset_in(23, 23));
421 EXPECT_EQ(-1, Vec.find_first_unset_in(6, 9));
423 EXPECT_EQ(0, Vec.find_first_unset_in(0, 6));
424 EXPECT_EQ(1, Vec.find_first_unset_in(1, 6));
425 EXPECT_EQ(9, Vec.find_first_unset_in(7, 13));
426 EXPECT_EQ(18, Vec.find_first_unset_in(18, 25));
427 EXPECT_EQ(20, Vec.find_first_unset_in(19, 25));
428 EXPECT_EQ(20, Vec.find_first_unset_in(20, 25));
429 EXPECT_EQ(22, Vec.find_first_unset_in(21, 25));
430 EXPECT_EQ(22, Vec.find_first_unset_in(22, 25));
431 EXPECT_EQ(24, Vec.find_first_unset_in(23, 25));
432 EXPECT_EQ(24, Vec.find_first_unset_in(24, 25));
435 EXPECT_EQ(-1, Vec.find_last_unset_in(0, 0));
436 EXPECT_EQ(-1, Vec.find_last_unset_in(23, 23));
437 EXPECT_EQ(-1, Vec.find_last_unset_in(6, 9));
439 EXPECT_EQ(5, Vec.find_last_unset_in(0, 6));
440 EXPECT_EQ(4, Vec.find_last_unset_in(0, 5));
441 EXPECT_EQ(1, Vec.find_last_unset_in(0, 4));
442 EXPECT_EQ(11, Vec.find_last_unset_in(7, 13));
443 EXPECT_EQ(24, Vec.find_last_unset_in(18, 25));
444 EXPECT_EQ(22, Vec.find_last_unset_in(18, 24));
445 EXPECT_EQ(22, Vec.find_last_unset_in(18, 23));
446 EXPECT_EQ(20, Vec.find_last_unset_in(18, 22));
447 EXPECT_EQ(20, Vec.find_last_unset_in(18, 21));
448 EXPECT_EQ(18, Vec.find_last_unset_in(18, 20));
449 EXPECT_EQ(18, Vec.find_last_unset_in(18, 19));
468 EXPECT_EQ(4U, A.count());
469 EXPECT_EQ(50U, A.size());
480 EXPECT_EQ(2U, A.count());
481 EXPECT_EQ(50U, A.size());
489 EXPECT_EQ(98U, A.count());
490 EXPECT_EQ(100U, A.size());
511 EXPECT_EQ(1u, Small.count());
534 EXPECT_EQ(1u, Big.count());
560 EXPECT_EQ(4u, Small.count());
561 EXPECT_EQ(20u, Small.size());
583 EXPECT_EQ(4u, Big.count());
584 EXPECT_EQ(20u, Big.size());
605 EXPECT_EQ(3u, Small.count());
606 EXPECT_EQ(20u, Small.size());
627 EXPECT_EQ(3u, Big.count());
628 EXPECT_EQ(20u, Big.size());
647 EXPECT_EQ(1u, Small.count());
648 EXPECT_EQ(10u, Small.size());
668 EXPECT_EQ(2u, Big.count());
669 EXPECT_EQ(20u, Big.size());
733 EXPECT_EQ(Vec.size(), Vec.count());
744 EXPECT_EQ(10u, A.size());
751 EXPECT_EQ(1u, A.count());
755 EXPECT_EQ(1u, A.count());
757 EXPECT_EQ(1u, A.count());
761 EXPECT_EQ(2u, A.count());
765 EXPECT_EQ(4u, A.count());
768 EXPECT_EQ(32u+3u, A.count());
771 EXPECT_EQ(65u, A.count());
774 EXPECT_EQ(65u, A.count());
779 EXPECT_EQ(96u-5u, A.count());
782 EXPECT_EQ(64-4u, A.count());
835 EXPECT_EQ(4U, A.count());
842 EXPECT_EQ(createBitVector<TypeParam>(12, {{1, 3}, {7, 9}}), A);
845 EXPECT_EQ(B, A);
848 EXPECT_EQ(createBitVector<TypeParam>(12, {}), A);
852 EXPECT_EQ(createBitVector<TypeParam>(12, {}), A);
860 EXPECT_EQ(40U, A.size());
861 EXPECT_EQ(22U, A.count());
870 EXPECT_EQ(createBitVector<TypeParam>(40, {{9, 21}, {34, 40}}), A);
879 EXPECT_EQ(createBitVector<TypeParam>(40, {{3, 15}, {28, 34}}), A);
888 EXPECT_EQ(createBitVector<TypeParam>(40, {{0, 5}, {18, 24}}), A);
893 EXPECT_EQ(createBitVector<TypeParam>(
911 EXPECT_EQ(Expected, A);
917 EXPECT_EQ(createBitVector<TypeParam>(
925 EXPECT_EQ(
932 EXPECT_EQ(
1025 EXPECT_EQ(50, C.find_first());
1038 EXPECT_EQ(C, A);
1039 EXPECT_EQ(C, B);
1051 EXPECT_EQ(C, A);
1052 EXPECT_EQ(C, B);
1058 EXPECT_EQ((size_t)0, A.size());
1059 EXPECT_EQ((size_t)0, A.count());
1063 EXPECT_EQ(-1, A.find_first());
1064 EXPECT_EQ(A, TypeParam());
1097 EXPECT_EQ(Bit, Counter++);
1100 EXPECT_EQ(Empty.set_bits_begin(), Empty.set_bits_end());
1109 EXPECT_EQ(++ToFill.set_bits_begin(), ToFill.set_bits_end());
1110 EXPECT_EQ(*ToFill.set_bits_begin(), 0U);
1112 EXPECT_EQ(ToFill.set_bits_begin(), ToFill.set_bits_end());
1119 EXPECT_EQ(List[i++], Bit);
1124 EXPECT_EQ(-1, Vec.find_first());
1125 EXPECT_EQ(10U, Vec.size());
1126 EXPECT_EQ(0U, Vec.count());
1129 EXPECT_EQ(10, Vec.find_first());
1130 EXPECT_EQ(11U, Vec.size());
1131 EXPECT_EQ(1U, Vec.count());
1134 EXPECT_EQ(10, Vec.find_first());
1135 EXPECT_EQ(12U, Vec.size());
1136 EXPECT_EQ(1U, Vec.count());
1139 EXPECT_EQ(10, Vec.find_first());
1140 EXPECT_EQ(13U, Vec.size());
1141 EXPECT_EQ(2U, Vec.count());
1148 EXPECT_EQ(10, Vec.find_first());
1149 EXPECT_EQ(213U, Vec.size());
1150 EXPECT_EQ(102U, Vec.count());
unittests/ADT/BitmaskEnumTest.cpp 26 EXPECT_EQ(3, f);
29 EXPECT_EQ(7, f);
35 EXPECT_EQ(5, f);
40 EXPECT_EQ(F1, f);
45 EXPECT_EQ(F2, f);
48 EXPECT_EQ(6, f);
54 EXPECT_EQ(3, f);
58 EXPECT_EQ(F3, f);
63 EXPECT_EQ(5, f);
66 EXPECT_EQ(4, f);
72 EXPECT_EQ(9, f);
76 EXPECT_EQ(F3, f);
81 EXPECT_EQ(14, f); // Largest value for f is 15.
82 EXPECT_EQ(15, ~F0);
96 EXPECT_EQ(7, static_cast<int>(f));
109 TEST(BitmaskEnumTest, EnumInStruct) { EXPECT_EQ(3, Container::getFlags()); }
131 EXPECT_EQ(7, f);
unittests/ADT/BreadthFirstIteratorTest.cpp 27 EXPECT_EQ(It.getLevel(), 0U);
28 EXPECT_EQ(*It, G.AccessNode(0));
30 EXPECT_EQ(It.getLevel(), 1U);
31 EXPECT_EQ(*It, G.AccessNode(1));
33 EXPECT_EQ(It.getLevel(), 1U);
34 EXPECT_EQ(*It, G.AccessNode(2));
36 EXPECT_EQ(It.getLevel(), 2U);
37 EXPECT_EQ(*It, G.AccessNode(3));
39 EXPECT_EQ(It, End);
58 EXPECT_EQ(It.getLevel(), 0U);
59 EXPECT_EQ(*It, G.AccessNode(0));
61 EXPECT_EQ(It.getLevel(), 1U);
62 EXPECT_EQ(*It, G.AccessNode(1));
64 EXPECT_EQ(It.getLevel(), 2U);
65 EXPECT_EQ(*It, G.AccessNode(2));
67 EXPECT_EQ(It.getLevel(), 3U);
68 EXPECT_EQ(*It, G.AccessNode(3));
70 EXPECT_EQ(It, End);
unittests/ADT/BumpPtrListTest.cpp 58 EXPECT_EQ(N, *I++);
59 EXPECT_EQ(I, L.end());
63 EXPECT_EQ(N, L.back());
79 EXPECT_EQ(N, *I++);
80 EXPECT_EQ(I, L.rend());
84 EXPECT_EQ(N, L.front());
95 EXPECT_EQ(N, L.back().V);
107 EXPECT_EQ(N, L.front().V);
120 EXPECT_EQ(N1s[I], L.back().V1);
121 EXPECT_EQ(N2s[I], L.back().V2);
134 EXPECT_EQ(N1s[I], L.front().V1);
135 EXPECT_EQ(N2s[I], L.front().V2);
159 EXPECT_EQ(N, *I++);
160 EXPECT_EQ(I, L2.end());
167 EXPECT_EQ(N, *I++);
168 EXPECT_EQ(I, L1.end());
178 EXPECT_EQ(3u, L.size());
179 EXPECT_EQ(0u, CountsDestructors::NumCalls);
181 EXPECT_EQ(1u, CountsDestructors::NumCalls);
183 EXPECT_EQ(3u, CountsDestructors::NumCalls);
191 EXPECT_EQ(1u, L1.size());
192 EXPECT_EQ(2, L1.front());
193 EXPECT_EQ(0u, L2.size());
200 EXPECT_EQ(0u, CountsDestructors::NumCalls);
202 EXPECT_EQ(1u, CountsDestructors::NumCalls);
210 EXPECT_EQ(1u, L1.size());
211 EXPECT_EQ(2, L1.front());
212 EXPECT_EQ(1u, L2.size());
213 EXPECT_EQ(2, L2.front());
220 EXPECT_EQ(0u, CountsDestructors::NumCalls);
222 EXPECT_EQ(1u, CountsDestructors::NumCalls);
unittests/ADT/DAGDeltaAlgorithmTest.cpp 71 EXPECT_EQ(fixed_set(4, 1, 3, 5, 7), FDA.Run(range(20), Deps));
90 EXPECT_EQ(fixed_set(4, 0, 1, 2, 3), FDA2.Run(range(5), Deps));
99 EXPECT_EQ(fixed_set(2, 0, 4), FDA3.Run(range(5), Deps));
unittests/ADT/DeltaAlgorithmTest.cpp 79 EXPECT_EQ(fixed_set(3, 3, 5, 7), FDA.Run(range(20)));
84 EXPECT_EQ(range(10,20), FDA.Run(range(10,20)));
94 EXPECT_EQ(range(4), FDA.Run(range(4)));
95 EXPECT_EQ(11U, FDA.getNumTests());
unittests/ADT/DenseMapTest.cpp 50 EXPECT_EQ(1u, Constructed.erase(this));
113 EXPECT_EQ(0u, this->Map.size());
122 EXPECT_EQ(typename TypeParam::mapped_type(),
129 EXPECT_EQ(0u, ConstMap.size());
139 EXPECT_EQ(1u, this->Map.size());
145 EXPECT_EQ(this->getKey(), it->first);
146 EXPECT_EQ(this->getValue(), it->second);
153 EXPECT_EQ(this->getValue(), this->Map.lookup(this->getKey()));
154 EXPECT_EQ(this->getValue(), this->Map[this->getKey()]);
162 EXPECT_EQ(0u, this->Map.size());
172 EXPECT_EQ(0u, this->Map.size());
182 EXPECT_EQ(0u, this->Map.size());
190 EXPECT_EQ(1u, this->Map.size());
191 EXPECT_EQ(this->getValue(), this->Map[this->getKey()]);
199 EXPECT_EQ(1u, copyMap.size());
200 EXPECT_EQ(this->getValue(), copyMap[this->getKey()]);
209 EXPECT_EQ(5u, copyMap.size());
211 EXPECT_EQ(this->getValue(Key), copyMap[this->getKey(Key)]);
236 EXPECT_EQ(1u, copyMap.size());
237 EXPECT_EQ(this->getValue(), copyMap[this->getKey()]);
241 EXPECT_EQ(1u, copyMap.size());
242 EXPECT_EQ(this->getValue(), copyMap[this->getKey()]);
250 EXPECT_EQ(5u, copyMap.size());
252 EXPECT_EQ(this->getValue(Key), copyMap[this->getKey(Key)]);
256 EXPECT_EQ(5u, copyMap.size());
258 EXPECT_EQ(this->getValue(Key), copyMap[this->getKey(Key)]);
267 EXPECT_EQ(0u, this->Map.size());
269 EXPECT_EQ(1u, otherMap.size());
270 EXPECT_EQ(this->getValue(), otherMap[this->getKey()]);
273 EXPECT_EQ(0u, otherMap.size());
275 EXPECT_EQ(1u, this->Map.size());
276 EXPECT_EQ(this->getValue(), this->Map[this->getKey()]);
283 EXPECT_EQ(0u, this->Map.size());
285 EXPECT_EQ(100u, otherMap.size());
287 EXPECT_EQ(this->getValue(i), otherMap[this->getKey(i)]);
290 EXPECT_EQ(0u, otherMap.size());
292 EXPECT_EQ(100u, this->Map.size());
294 EXPECT_EQ(this->getValue(i), this->Map[this->getKey(i)]);
358 EXPECT_EQ(2u, M.size());
359 EXPECT_EQ(1u, M.count(0));
360 EXPECT_EQ(0, M[0]);
361 EXPECT_EQ(1u, M.count(1));
362 EXPECT_EQ(2, M[1]);
371 EXPECT_EQ(M1, M2);
394 EXPECT_EQ(MemorySize, Map.getMemorySize());
396 EXPECT_EQ(ExpectedMaxInitialEntries, CountCopyAndMove::Move);
398 EXPECT_EQ(0, CountCopyAndMove::Copy);
411 EXPECT_EQ(0, CountCopyAndMove::Copy);
432 EXPECT_EQ(MemorySize, Map.getMemorySize());
434 EXPECT_EQ(Size, CountCopyAndMove::Move);
436 EXPECT_EQ(0, CountCopyAndMove::Copy);
452 EXPECT_EQ(0, CountCopyAndMove::Move);
454 EXPECT_EQ(Count, CountCopyAndMove::Copy);
476 EXPECT_EQ(MemorySize, Map.getMemorySize());
478 EXPECT_EQ(Size, CountCopyAndMove::Move);
480 EXPECT_EQ(0, CountCopyAndMove::Copy);
492 EXPECT_EQ(3u, M.size());
493 EXPECT_EQ(1, M.lookup("a"));
494 EXPECT_EQ(2, M.lookup("b"));
495 EXPECT_EQ(3, M.lookup("c"));
497 EXPECT_EQ(0, M.lookup("q"));
500 EXPECT_EQ(0, M.lookup(""));
501 EXPECT_EQ(0, M.lookup(StringRef()));
502 EXPECT_EQ(0, M.lookup(StringRef("a", 0)));
504 EXPECT_EQ(42, M.lookup(""));
505 EXPECT_EQ(42, M.lookup(StringRef()));
506 EXPECT_EQ(42, M.lookup(StringRef("a", 0)));
534 EXPECT_EQ(3u, map.size());
537 EXPECT_EQ(1u, map.count(1));
538 EXPECT_EQ(1u, map.find(0)->second);
539 EXPECT_EQ(2u, map.find(1)->second);
540 EXPECT_EQ(3u, map.find(2)->second);
544 EXPECT_EQ(1u, map.find_as("a")->second);
545 EXPECT_EQ(2u, map.find_as("b")->second);
546 EXPECT_EQ(3u, map.find_as("c")->second);
574 EXPECT_EQ(22u, map.size());
590 EXPECT_EQ(Try1.first, Try2.first);
602 EXPECT_EQ(Map.count(B), 1u);
603 EXPECT_EQ(Map.count(C), 1u);
unittests/ADT/DenseSetTest.cpp 30 EXPECT_EQ(0u, set.count(2));
75 EXPECT_EQ(3u, set.size());
76 EXPECT_EQ(1u, set.count(1));
77 EXPECT_EQ(1u, set.count(2));
78 EXPECT_EQ(1u, set.count(4));
79 EXPECT_EQ(0u, set.count(3));
84 EXPECT_EQ(3u, set.size());
85 EXPECT_EQ(1u, set.count(1));
86 EXPECT_EQ(1u, set.count(2));
87 EXPECT_EQ(1u, set.count(3));
93 EXPECT_EQ(set.begin(), cset.begin());
94 EXPECT_EQ(set.end(), cset.end());
102 EXPECT_EQ(I, J);
103 EXPECT_EQ(CI, CJ);
108 EXPECT_EQ(0u, set.size());
109 EXPECT_EQ(0u, set.count(0));
115 EXPECT_EQ(3u, set.size());
118 EXPECT_EQ(1u, set.count(1));
119 EXPECT_EQ(0u, *set.find(0));
120 EXPECT_EQ(1u, *set.find(1));
121 EXPECT_EQ(2u, *set.find(2));
125 EXPECT_EQ(0u, *set.find_as("a"));
126 EXPECT_EQ(1u, *set.find_as("b"));
127 EXPECT_EQ(2u, *set.find_as("c"));
136 EXPECT_EQ(set1, set2);
204 EXPECT_EQ(MemorySize, Set.getMemorySize());
206 EXPECT_EQ(Size, CountCopyAndMove::Move);
208 EXPECT_EQ(0, CountCopyAndMove::Copy);
219 EXPECT_EQ(Map.count(B), 1u);
220 EXPECT_EQ(Map.count(C), 1u);
unittests/ADT/DepthFirstIteratorTest.cpp 51 EXPECT_EQ(3, S.InsertVisited);
unittests/ADT/DirectedGraphTest.cpp 130 EXPECT_EQ(DG.findNode(N4), DG.end());
136 EXPECT_EQ(*EL[0], E1);
160 EXPECT_EQ(E1.getTargetNode(), N1);
161 EXPECT_EQ(E2.getTargetNode(), N2);
162 EXPECT_EQ(E3.getTargetNode(), N3);
182 EXPECT_EQ(*EL[0], E2);
231 EXPECT_EQ(DG.findNode(N1), DG.end());
unittests/ADT/FallibleIteratorTest.cpp 287 EXPECT_EQ(I, E);
unittests/ADT/FoldingSet.cpp 34 EXPECT_EQ(a.ComputeHash(), b.ComputeHash());
53 EXPECT_EQ(&C1, Set.GetOrInsertNode(&C1));
54 EXPECT_EQ(&C2, Set.GetOrInsertNode(&C2));
55 EXPECT_EQ(2U, Set.size());
79 EXPECT_EQ(&T, N);
80 EXPECT_EQ(nullptr, InsertPos);
94 EXPECT_EQ(nullptr, N);
103 EXPECT_EQ(Trivial.size(), 1U);
107 EXPECT_EQ(0U, Trivial.size());
116 EXPECT_EQ(0U, Trivial.size());
124 EXPECT_EQ(&T, N);
134 EXPECT_EQ(&T, N);
148 EXPECT_EQ(1U, Trivial.size());
188 EXPECT_EQ(Trivial.capacity(), OldCapacity);
unittests/ADT/FunctionExtrasTest.cpp 20 EXPECT_EQ(Sum(1, 2), 3);
23 EXPECT_EQ(Sum2(1, 2), 3);
27 EXPECT_EQ(Sum2(1, 2), 3);
30 EXPECT_EQ(Sum2(1, 2), 3);
34 EXPECT_EQ(Sum2(1, 2), 3);
43 EXPECT_EQ(X, 43);
54 EXPECT_EQ(ReadAndDeallocByRef(std::move(Ptr)), 13);
58 EXPECT_EQ(ReadAndDeallocByRef(std::unique_ptr<int>(new int(42))), 42);
68 EXPECT_EQ(ReadAndDeallocByVal(std::move(Ptr)), 13);
71 EXPECT_EQ(ReadAndDeallocByVal(std::unique_ptr<int>(new int(42))), 42);
80 EXPECT_EQ(C1(), 1);
82 EXPECT_EQ(Tmp(), 1);
85 EXPECT_EQ(C2(), 3);
87 EXPECT_EQ(Tmp(), 3);
90 EXPECT_EQ(C3(), 6);
92 EXPECT_EQ(Tmp(), 6);
95 EXPECT_EQ(C4(), 10);
97 EXPECT_EQ(Tmp(), 10);
100 EXPECT_EQ(C5(), 15);
102 EXPECT_EQ(Tmp(), 15);
112 EXPECT_EQ(Small(2), 3);
114 EXPECT_EQ(Small2(2), 3);
126 EXPECT_EQ(Large(), 15);
128 EXPECT_EQ(Large2(), 15);
144 EXPECT_EQ(1, CopyCount);
151 EXPECT_EQ(2, CopyCount);
159 EXPECT_EQ(0, CopyCount);
166 EXPECT_EQ(0, CopyCount);
192 EXPECT_EQ(1, MoveCount);
199 EXPECT_EQ(2, MoveCount);
205 EXPECT_EQ(0, MoveCount);
212 EXPECT_EQ(0, MoveCount);
unittests/ADT/FunctionRefTest.cpp 38 EXPECT_EQ(1, Y());
unittests/ADT/HashingTest.cpp 65 EXPECT_EQ(hash_value(42), hash_value(x));
66 EXPECT_EQ(hash_value(42), hash_value(TE_Foo));
70 EXPECT_EQ(hash_value(71), hash_value(i));
71 EXPECT_EQ(hash_value(71), hash_value(ci));
72 EXPECT_EQ(hash_value(71), hash_value(vi));
73 EXPECT_EQ(hash_value(71), hash_value(cvi));
74 EXPECT_EQ(hash_value(c), hash_value('x'));
75 EXPECT_EQ(hash_value('4'), hash_value('0' + 4));
76 EXPECT_EQ(hash_value(addr), hash_value(&y));
80 EXPECT_EQ(hash_combine(42, 43), hash_value(std::make_pair(42, 43)));
88 EXPECT_EQ(hash_combine(42, 43, 44),
90 EXPECT_EQ(hash_value(std::make_pair(42, std::make_pair(43, 44))),
95 EXPECT_EQ(hash_combine('0', hash_combine(1ull, '2')),
100 EXPECT_EQ(hash_combine(obj1, hash_combine(obj2, obj3)),
106 EXPECT_EQ(hash_combine_range(s.c_str(), s.c_str() + s.size()), hash_value(s));
107 EXPECT_EQ(hash_combine_range(s.c_str(), s.c_str() + s.size() - 1),
109 EXPECT_EQ(hash_combine_range(s.c_str() + 1, s.c_str() + s.size() - 1),
113 EXPECT_EQ(hash_combine_range(ws.c_str(), ws.c_str() + ws.size()),
115 EXPECT_EQ(hash_combine_range(ws.c_str(), ws.c_str() + ws.size() - 1),
117 EXPECT_EQ(hash_combine_range(ws.c_str() + 1, ws.c_str() + ws.size() - 1),
138 EXPECT_EQ(arr1_hash, hash_combine_range(begin(arr1), end(arr1)));
141 EXPECT_EQ(arr1_hash, hash_combine_range(vec.begin(), vec.end()));
144 EXPECT_EQ(arr1_hash, hash_combine_range(list.begin(), list.end()));
147 EXPECT_EQ(arr1_hash, hash_combine_range(deque.begin(), deque.end()));
168 EXPECT_EQ(arr5_hash, d_arr5_hash);
180 EXPECT_EQ(Idx, I->second);
188 EXPECT_EQ(Idx, I->second);
196 EXPECT_EQ(Idx, I->second);
204 EXPECT_EQ(Idx, I->second);
275 EXPECT_EQ(static_cast<size_t>(golden_data[i].hash),
284 EXPECT_EQ(hash_combine_range(arr1, arr1 + 1), hash_combine(i1));
285 EXPECT_EQ(hash_combine_range(arr1, arr1 + 2), hash_combine(i1, i2));
286 EXPECT_EQ(hash_combine_range(arr1, arr1 + 3), hash_combine(i1, i2, i3));
287 EXPECT_EQ(hash_combine_range(arr1, arr1 + 4), hash_combine(i1, i2, i3, i4));
288 EXPECT_EQ(hash_combine_range(arr1, arr1 + 5),
290 EXPECT_EQ(hash_combine_range(arr1, arr1 + 6),
299 EXPECT_EQ(hash_combine_range(begin(arr2), end(arr2)),
301 EXPECT_EQ(hash_combine(s1, s2, s3), hash_combine(s1, s2, d3));
302 EXPECT_EQ(hash_combine(s1, s2, s3), hash_combine(s1, d2, s3));
303 EXPECT_EQ(hash_combine(s1, s2, s3), hash_combine(d1, s2, s3));
304 EXPECT_EQ(hash_combine(s1, s2, s3), hash_combine(d1, d2, s3));
305 EXPECT_EQ(hash_combine(s1, s2, s3), hash_combine(d1, d2, d3));
353 EXPECT_EQ(hash_combine_range(begin(bigarr), end(bigarr)),
355 EXPECT_EQ(hash_combine_range(bigarr, bigarr + 9),
357 EXPECT_EQ(hash_combine_range(bigarr, bigarr + 10),
359 EXPECT_EQ(hash_combine_range(bigarr, bigarr + 17),
361 EXPECT_EQ(hash_combine_range(bigarr, bigarr + 18),
363 EXPECT_EQ(hash_combine_range(bigarr, bigarr + 18),
365 EXPECT_EQ(hash_combine_range(bigarr, bigarr + 20),
unittests/ADT/IListBaseTest.cpp 36 EXPECT_EQ(&A, S.getPrev());
37 EXPECT_EQ(&S, A.getPrev());
38 EXPECT_EQ(&A, S.getNext());
39 EXPECT_EQ(&S, A.getNext());
43 EXPECT_EQ(&B, S.getPrev());
44 EXPECT_EQ(&A, B.getPrev());
45 EXPECT_EQ(&S, A.getPrev());
46 EXPECT_EQ(&A, S.getNext());
47 EXPECT_EQ(&B, A.getNext());
48 EXPECT_EQ(&S, B.getNext());
65 EXPECT_EQ(&B, S.getPrev());
66 EXPECT_EQ(&S, B.getPrev());
67 EXPECT_EQ(&B, S.getNext());
68 EXPECT_EQ(&S, B.getNext());
69 EXPECT_EQ(nullptr, A.getPrev());
70 EXPECT_EQ(nullptr, A.getNext());
74 EXPECT_EQ(&S, S.getPrev());
75 EXPECT_EQ(&S, S.getNext());
76 EXPECT_EQ(nullptr, B.getPrev());
77 EXPECT_EQ(nullptr, B.getNext());
96 EXPECT_EQ(&D, S.getPrev());
97 EXPECT_EQ(&A, D.getPrev());
98 EXPECT_EQ(&S, A.getPrev());
99 EXPECT_EQ(&A, S.getNext());
100 EXPECT_EQ(&D, A.getNext());
101 EXPECT_EQ(&S, D.getNext());
102 EXPECT_EQ(nullptr, B.getPrev());
103 EXPECT_EQ(nullptr, C.getNext());
120 EXPECT_EQ(&S, S.getPrev());
121 EXPECT_EQ(&S, S.getNext());
122 EXPECT_EQ(nullptr, A.getPrev());
123 EXPECT_EQ(nullptr, B.getNext());
147 EXPECT_EQ(&C, S1.getPrev());
148 EXPECT_EQ(&S1, C.getPrev());
149 EXPECT_EQ(&C, S1.getNext());
150 EXPECT_EQ(&S1, C.getNext());
153 EXPECT_EQ(&E, S2.getPrev());
154 EXPECT_EQ(&D, E.getPrev());
155 EXPECT_EQ(&B, D.getPrev());
156 EXPECT_EQ(&A, B.getPrev());
157 EXPECT_EQ(&S2, A.getPrev());
158 EXPECT_EQ(&A, S2.getNext());
159 EXPECT_EQ(&B, A.getNext());
160 EXPECT_EQ(&D, B.getNext());
161 EXPECT_EQ(&E, D.getNext());
162 EXPECT_EQ(&S2, E.getNext());
unittests/ADT/IListIteratorTest.cpp 23 EXPECT_EQ(nullptr, I.getNodePtr());
24 EXPECT_EQ(nullptr, CI.getNodePtr());
25 EXPECT_EQ(nullptr, RI.getNodePtr());
26 EXPECT_EQ(nullptr, CRI.getNodePtr());
27 EXPECT_EQ(I, I);
28 EXPECT_EQ(I, CI);
29 EXPECT_EQ(CI, I);
30 EXPECT_EQ(CI, CI);
31 EXPECT_EQ(RI, RI);
32 EXPECT_EQ(RI, CRI);
33 EXPECT_EQ(CRI, RI);
34 EXPECT_EQ(CRI, CRI);
35 EXPECT_EQ(I, RI.getReverse());
36 EXPECT_EQ(RI, I.getReverse());
43 EXPECT_EQ(L.begin(), L.end());
44 EXPECT_EQ(L.rbegin(), L.rend());
47 EXPECT_EQ(L.end(), L.rend().getReverse());
48 EXPECT_EQ(L.rend(), L.end().getReverse());
65 EXPECT_EQ(&A, &*L.begin());
66 EXPECT_EQ(&A, &*L.rbegin());
69 EXPECT_EQ(L.rbegin().getNodePtr(), L.begin().getNodePtr());
72 EXPECT_EQ(L.end(), ++L.begin());
73 EXPECT_EQ(L.begin(), --L.end());
74 EXPECT_EQ(L.rend(), ++L.rbegin());
75 EXPECT_EQ(L.rbegin(), --L.rend());
78 EXPECT_EQ(L.rbegin(), L.begin().getReverse());
79 EXPECT_EQ(L.begin(), L.rbegin().getReverse());
89 EXPECT_EQ(&A, &*L.begin());
90 EXPECT_EQ(&B, &*++L.begin());
91 EXPECT_EQ(L.end(), ++++L.begin());
92 EXPECT_EQ(&B, &*L.rbegin());
93 EXPECT_EQ(&A, &*++L.rbegin());
94 EXPECT_EQ(L.rend(), ++++L.rbegin());
97 EXPECT_EQ(++L.rbegin(), L.begin().getReverse());
98 EXPECT_EQ(L.rbegin(), (++L.begin()).getReverse());
99 EXPECT_EQ(++L.begin(), L.rbegin().getReverse());
100 EXPECT_EQ(L.begin(), (++L.rbegin()).getReverse());
111 EXPECT_EQ(&A, &*I);
113 EXPECT_EQ(&B, &*I);
115 EXPECT_EQ(L.end(), I);
126 EXPECT_EQ(&B, &*RI);
128 EXPECT_EQ(&A, &*RI);
130 EXPECT_EQ(L.rend(), RI);
147 EXPECT_EQ(L.begin(), iterator(L.rend()));
148 EXPECT_EQ(++L.begin(), iterator(++L.rbegin()));
149 EXPECT_EQ(L.end(), iterator(L.rbegin()));
150 EXPECT_EQ(L.rbegin(), reverse_iterator(L.end()));
151 EXPECT_EQ(++L.rbegin(), reverse_iterator(++L.begin()));
152 EXPECT_EQ(L.rend(), reverse_iterator(L.begin()));
155 EXPECT_EQ(CL.begin(), const_iterator(L.rend()));
156 EXPECT_EQ(CL.begin(), const_iterator(CL.rend()));
157 EXPECT_EQ(CL.rbegin(), const_reverse_iterator(L.end()));
158 EXPECT_EQ(CL.rbegin(), const_reverse_iterator(CL.end()));
unittests/ADT/IListNodeBaseTest.cpp 21 EXPECT_EQ(nullptr, A.getPrev());
22 EXPECT_EQ(nullptr, A.getNext());
26 EXPECT_EQ(nullptr, TA.getPrev());
27 EXPECT_EQ(nullptr, TA.getNext());
35 EXPECT_EQ(&B, A.getPrev());
36 EXPECT_EQ(nullptr, A.getNext());
37 EXPECT_EQ(nullptr, B.getPrev());
38 EXPECT_EQ(nullptr, B.getNext());
39 EXPECT_EQ(nullptr, C.getPrev());
40 EXPECT_EQ(nullptr, C.getNext());
43 EXPECT_EQ(&B, A.getPrev());
44 EXPECT_EQ(&C, A.getNext());
45 EXPECT_EQ(nullptr, B.getPrev());
46 EXPECT_EQ(nullptr, B.getNext());
47 EXPECT_EQ(nullptr, C.getPrev());
48 EXPECT_EQ(nullptr, C.getNext());
52 EXPECT_EQ(&TB, TA.getPrev());
53 EXPECT_EQ(nullptr, TA.getNext());
54 EXPECT_EQ(nullptr, TB.getPrev());
55 EXPECT_EQ(nullptr, TB.getNext());
56 EXPECT_EQ(nullptr, TC.getPrev());
57 EXPECT_EQ(nullptr, TC.getNext());
60 EXPECT_EQ(&TB, TA.getPrev());
61 EXPECT_EQ(&TC, TA.getNext());
62 EXPECT_EQ(nullptr, TB.getPrev());
63 EXPECT_EQ(nullptr, TB.getNext());
64 EXPECT_EQ(nullptr, TC.getPrev());
65 EXPECT_EQ(nullptr, TC.getNext());
74 EXPECT_EQ(&B, A.getPrev());
75 EXPECT_EQ(&B, A.getNext());
79 EXPECT_EQ(&B, A.getPrev());
80 EXPECT_EQ(&B, A.getNext());
88 EXPECT_EQ(&TB, TA.getPrev());
89 EXPECT_EQ(&TB, TA.getNext());
95 EXPECT_EQ(&TB, TA.getPrev());
96 EXPECT_EQ(&TB, TA.getNext());
unittests/ADT/IListSentinelTest.cpp 37 EXPECT_EQ(&S, LocalAccess::getPrev(S));
38 EXPECT_EQ(&S, LocalAccess::getNext(S));
54 EXPECT_EQ(nullptr, LocalAccess::getPrev(N));
55 EXPECT_EQ(nullptr, LocalAccess::getNext(N));
unittests/ADT/IListTest.cpp 31 EXPECT_EQ(1, List.back().Value);
32 EXPECT_EQ(nullptr, List.getPrevNode(List.back()));
33 EXPECT_EQ(nullptr, List.getNextNode(List.back()));
36 EXPECT_EQ(2, List.back().Value);
37 EXPECT_EQ(2, List.getNextNode(List.front())->Value);
38 EXPECT_EQ(1, List.getPrevNode(List.back())->Value);
41 EXPECT_EQ(2, ConstList.back().Value);
42 EXPECT_EQ(2, ConstList.getNextNode(ConstList.front())->Value);
43 EXPECT_EQ(1, ConstList.getPrevNode(ConstList.back())->Value);
62 EXPECT_EQ(2u, L1.size());
63 EXPECT_EQ(&L1Nodes[0], &L1.front());
64 EXPECT_EQ(&L1Nodes[1], &L1.back());
65 EXPECT_EQ(2u, L2.size());
66 EXPECT_EQ(&L2Nodes[0], &L2.front());
67 EXPECT_EQ(&L2Nodes[1], &L2.back());
68 EXPECT_EQ(2u, L3.size());
69 EXPECT_EQ(0, L3.front().Value);
70 EXPECT_EQ(1, L3.back().Value);
83 EXPECT_EQ(1u, List.size());
84 EXPECT_EQ(1, List.front().Value);
91 EXPECT_EQ(3u, List.size());
92 EXPECT_EQ(1, List.front().Value);
93 EXPECT_EQ(2, std::next(List.begin())->Value);
94 EXPECT_EQ(3, List.back().Value);
103 EXPECT_EQ(0, L.front().Value);
104 EXPECT_EQ(1, L.back().Value);
107 EXPECT_EQ(1, L.front().Value);
108 EXPECT_EQ(0, L.back().Value);
119 EXPECT_EQ(0, L.front().Value);
120 EXPECT_EQ(1, L.back().Value);
123 EXPECT_EQ(1, L.front().Value);
124 EXPECT_EQ(0, L.back().Value);
134 EXPECT_EQ(0u, List.size());
139 EXPECT_EQ(0u, List.size());
147 EXPECT_EQ(1, N->Value);
149 EXPECT_EQ(0u, List.size());
157 EXPECT_EQ(5, List.front().Value);
158 EXPECT_EQ(6, List.back().Value);
unittests/ADT/ImmutableListTest.cpp 45 EXPECT_EQ(nullptr, L.getTail().getInternalPointer());
67 EXPECT_EQ(3, L2.getHead());
76 EXPECT_EQ(2, L3.getHead());
120 EXPECT_EQ(3, L2.getHead());
148 EXPECT_EQ(5, L2.getHead());
149 EXPECT_EQ(4, L2.getTail().getHead());
150 EXPECT_EQ(3, L2.getTail().getTail().getHead());
160 EXPECT_EQ(43, L3.getHead());
161 EXPECT_EQ(20, L3.getTail().getHead());
162 EXPECT_EQ(9, L3.getTail().getTail().getHead());
208 EXPECT_EQ(3, L2.getHead());
214 EXPECT_EQ(2, L3.getHead());
218 EXPECT_EQ(1, L4.getHead());
unittests/ADT/ImmutableMapTest.cpp 24 EXPECT_EQ(0u, S.getHeight());
38 EXPECT_EQ(nullptr, S.lookup(3));
39 EXPECT_EQ(nullptr, S.lookup(9));
41 EXPECT_EQ(10, *S2.lookup(3));
42 EXPECT_EQ(11, *S2.lookup(4));
43 EXPECT_EQ(12, *S2.lookup(5));
45 EXPECT_EQ(5, S2.getMaxElement()->first);
46 EXPECT_EQ(3U, S2.getHeight());
unittests/ADT/ImmutableSetTest.cpp 44 EXPECT_EQ(0u, S.getHeight());
unittests/ADT/IntEqClassesTest.cpp 24 EXPECT_EQ(0u, ec.findLeader(0));
25 EXPECT_EQ(0u, ec.findLeader(1));
26 EXPECT_EQ(2u, ec.findLeader(2));
27 EXPECT_EQ(2u, ec.findLeader(3));
28 EXPECT_EQ(4u, ec.findLeader(4));
29 EXPECT_EQ(4u, ec.findLeader(5));
30 EXPECT_EQ(6u, ec.findLeader(6));
31 EXPECT_EQ(6u, ec.findLeader(7));
32 EXPECT_EQ(8u, ec.findLeader(8));
33 EXPECT_EQ(9u, ec.findLeader(9));
38 EXPECT_EQ(0u, ec.findLeader(0));
39 EXPECT_EQ(0u, ec.findLeader(1));
40 EXPECT_EQ(0u, ec.findLeader(2));
41 EXPECT_EQ(0u, ec.findLeader(3));
42 EXPECT_EQ(4u, ec.findLeader(4));
43 EXPECT_EQ(4u, ec.findLeader(5));
44 EXPECT_EQ(6u, ec.findLeader(6));
45 EXPECT_EQ(6u, ec.findLeader(7));
46 EXPECT_EQ(8u, ec.findLeader(8));
47 EXPECT_EQ(9u, ec.findLeader(9));
52 EXPECT_EQ(0u, ec.findLeader(0));
53 EXPECT_EQ(0u, ec.findLeader(1));
54 EXPECT_EQ(0u, ec.findLeader(2));
55 EXPECT_EQ(0u, ec.findLeader(3));
56 EXPECT_EQ(4u, ec.findLeader(4));
57 EXPECT_EQ(4u, ec.findLeader(5));
58 EXPECT_EQ(6u, ec.findLeader(6));
59 EXPECT_EQ(6u, ec.findLeader(7));
60 EXPECT_EQ(4u, ec.findLeader(8));
61 EXPECT_EQ(9u, ec.findLeader(9));
66 EXPECT_EQ(0u, ec.findLeader(0));
67 EXPECT_EQ(0u, ec.findLeader(1));
68 EXPECT_EQ(0u, ec.findLeader(2));
69 EXPECT_EQ(0u, ec.findLeader(3));
70 EXPECT_EQ(4u, ec.findLeader(4));
71 EXPECT_EQ(4u, ec.findLeader(5));
72 EXPECT_EQ(6u, ec.findLeader(6));
73 EXPECT_EQ(6u, ec.findLeader(7));
74 EXPECT_EQ(4u, ec.findLeader(8));
75 EXPECT_EQ(0u, ec.findLeader(9));
79 EXPECT_EQ(3u, ec.getNumClasses());
81 EXPECT_EQ(0u, ec[0]);
82 EXPECT_EQ(0u, ec[1]);
83 EXPECT_EQ(0u, ec[2]);
84 EXPECT_EQ(0u, ec[3]);
85 EXPECT_EQ(1u, ec[4]);
86 EXPECT_EQ(1u, ec[5]);
87 EXPECT_EQ(2u, ec[6]);
88 EXPECT_EQ(2u, ec[7]);
89 EXPECT_EQ(1u, ec[8]);
90 EXPECT_EQ(0u, ec[9]);
94 EXPECT_EQ(0u, ec.findLeader(0));
95 EXPECT_EQ(0u, ec.findLeader(1));
96 EXPECT_EQ(0u, ec.findLeader(2));
97 EXPECT_EQ(0u, ec.findLeader(3));
98 EXPECT_EQ(4u, ec.findLeader(4));
99 EXPECT_EQ(4u, ec.findLeader(5));
100 EXPECT_EQ(6u, ec.findLeader(6));
101 EXPECT_EQ(6u, ec.findLeader(7));
102 EXPECT_EQ(4u, ec.findLeader(8));
103 EXPECT_EQ(0u, ec.findLeader(9));
unittests/ADT/IntervalMapTest.cpp 27 EXPECT_EQ(0u, map.lookup(0));
28 EXPECT_EQ(7u, map.lookup(0, 7));
29 EXPECT_EQ(0u, map.lookup(~0u-1));
30 EXPECT_EQ(7u, map.lookup(~0u-1, 7));
62 EXPECT_EQ(0u, map.lookup(0));
63 EXPECT_EQ(0u, map.lookup(99));
64 EXPECT_EQ(1u, map.lookup(100));
65 EXPECT_EQ(1u, map.lookup(101));
66 EXPECT_EQ(1u, map.lookup(125));
67 EXPECT_EQ(1u, map.lookup(149));
68 EXPECT_EQ(1u, map.lookup(150));
69 EXPECT_EQ(0u, map.lookup(151));
70 EXPECT_EQ(0u, map.lookup(200));
71 EXPECT_EQ(0u, map.lookup(~0u-1));
83 EXPECT_EQ(100u, I.start());
84 EXPECT_EQ(150u, I.stop());
85 EXPECT_EQ(1u, I.value());
96 EXPECT_EQ(100u, I.start());
97 EXPECT_EQ(150u, I.stop());
98 EXPECT_EQ(1u, I.value());
105 EXPECT_EQ(100u, I.start());
106 EXPECT_EQ(150u, I.stop());
107 EXPECT_EQ(2u, I.value());
112 EXPECT_EQ(0u, I.start());
113 EXPECT_EQ(150u, I.stop());
114 EXPECT_EQ(2u, I.value());
118 EXPECT_EQ(0u, I.start());
119 EXPECT_EQ(200u, I.stop());
120 EXPECT_EQ(2u, I.value());
125 EXPECT_EQ(150u, I.start());
126 EXPECT_EQ(200u, I.stop());
127 EXPECT_EQ(2u, I.value());
132 EXPECT_EQ(150u, I.start());
133 EXPECT_EQ(150u, I.stop());
134 EXPECT_EQ(2u, I.value());
138 EXPECT_EQ(150u, I.start());
139 EXPECT_EQ(160u, I.stop());
140 EXPECT_EQ(2u, I.value());
145 EXPECT_EQ(160u, I.start());
146 EXPECT_EQ(160u, I.stop());
147 EXPECT_EQ(2u, I.value());
152 EXPECT_EQ(0, std::distance(map.begin(), map.end()));
168 EXPECT_EQ(149u, I.start());
169 EXPECT_EQ(150u, I.stop());
170 EXPECT_EQ(1u, I.value());
174 EXPECT_EQ(149u, I.start());
175 EXPECT_EQ(160u, I.stop());
176 EXPECT_EQ(1u, I.value());
181 EXPECT_EQ(149u, I.start());
182 EXPECT_EQ(150u, I.stop());
183 EXPECT_EQ(1u, I.value());
194 EXPECT_EQ(1, std::distance(map.begin(), map.end()));
195 EXPECT_EQ(90u, map.start());
196 EXPECT_EQ(150u, map.stop());
200 EXPECT_EQ(1, std::distance(map.begin(), map.end()));
201 EXPECT_EQ(90u, map.start());
202 EXPECT_EQ(200u, map.stop());
206 EXPECT_EQ(2, std::distance(map.begin(), map.end()));
207 EXPECT_EQ(60u, map.start());
208 EXPECT_EQ(200u, map.stop());
209 EXPECT_EQ(2u, map.lookup(89));
210 EXPECT_EQ(1u, map.lookup(90));
213 EXPECT_EQ(60u, I.start());
214 EXPECT_EQ(89u, I.stop());
215 EXPECT_EQ(2u, I.value());
217 EXPECT_EQ(90u, I.start());
218 EXPECT_EQ(200u, I.stop());
219 EXPECT_EQ(1u, I.value());
225 EXPECT_EQ(3, std::distance(map.begin(), map.end()));
226 EXPECT_EQ(60u, map.start());
227 EXPECT_EQ(210u, map.stop());
228 EXPECT_EQ(2u, map.lookup(201));
229 EXPECT_EQ(1u, map.lookup(200));
233 EXPECT_EQ(2, std::distance(map.begin(), map.end()));
234 EXPECT_EQ(90u, map.start());
235 EXPECT_EQ(210u, map.stop());
239 EXPECT_EQ(1, std::distance(map.begin(), map.end()));
240 EXPECT_EQ(90u, map.start());
241 EXPECT_EQ(200u, map.stop());
246 EXPECT_EQ(3, std::distance(map.begin(), map.end()));
248 EXPECT_EQ(1, std::distance(map.begin(), map.end()));
251 EXPECT_EQ(80u, I.start());
252 EXPECT_EQ(210u, I.stop());
253 EXPECT_EQ(2u, I.value());
264 EXPECT_EQ(4, std::distance(map.begin(), map.end()));
265 EXPECT_EQ(100u, map.start());
266 EXPECT_EQ(170u, map.stop());
270 EXPECT_EQ(100u, I.start());
271 EXPECT_EQ(110u, I.stop());
273 EXPECT_EQ(120u, I.start());
274 EXPECT_EQ(130u, I.stop());
276 EXPECT_EQ(140u, I.start());
277 EXPECT_EQ(150u, I.stop());
279 EXPECT_EQ(160u, I.start());
280 EXPECT_EQ(170u, I.stop());
288 EXPECT_EQ(140u, I.start());
289 EXPECT_EQ(150u, I.stop());
293 EXPECT_EQ(140u, I.start());
294 EXPECT_EQ(150u, I.stop());
307 EXPECT_EQ(100u, I.start());
308 EXPECT_EQ(115u, I.stop());
311 EXPECT_EQ(120u, I.start());
312 EXPECT_EQ(130u, I.stop());
315 EXPECT_EQ(140u, I.start());
316 EXPECT_EQ(150u, I.stop());
319 EXPECT_EQ(160u, I.start());
320 EXPECT_EQ(170u, I.stop());
329 EXPECT_EQ(100u, I.start());
330 EXPECT_EQ(115u, I.stop());
333 EXPECT_EQ(120u, I.start());
334 EXPECT_EQ(130u, I.stop());
337 EXPECT_EQ(135u, I.start());
338 EXPECT_EQ(150u, I.stop());
341 EXPECT_EQ(160u, I.start());
342 EXPECT_EQ(170u, I.stop());
351 EXPECT_EQ(100u, I.start());
352 EXPECT_EQ(115u, I.stop());
355 EXPECT_EQ(120u, I.start());
356 EXPECT_EQ(150u, I.stop());
359 EXPECT_EQ(160u, I.start());
360 EXPECT_EQ(170u, I.stop());
379 EXPECT_EQ(10u, map.start());
380 EXPECT_EQ(10*i+5, map.stop());
385 EXPECT_EQ(10u, map.start());
386 EXPECT_EQ(995u, map.stop());
390 EXPECT_EQ(0u, map.lookup(10*i-1));
391 EXPECT_EQ(i, map.lookup(10*i));
392 EXPECT_EQ(i, map.lookup(10*i+5));
393 EXPECT_EQ(0u, map.lookup(10*i+6));
400 EXPECT_EQ(10*i, I.start());
401 EXPECT_EQ(10*i+5, I.stop());
402 EXPECT_EQ(i, *I);
412 EXPECT_EQ(10*i, I.start());
413 EXPECT_EQ(10*i+5, I.stop());
414 EXPECT_EQ(i, *I);
421 EXPECT_EQ(20u, I.start());
422 EXPECT_EQ(25u, I.stop());
427 EXPECT_EQ(20u, I.start());
428 EXPECT_EQ(25u, I.stop());
429 EXPECT_EQ(0u, I.value());
434 EXPECT_EQ(20u, I.start());
435 EXPECT_EQ(29u, I.stop());
436 EXPECT_EQ(0u, I.value());
441 EXPECT_EQ(20u, I.start());
442 EXPECT_EQ(29u, I.stop());
443 EXPECT_EQ(2u, I.value());
448 EXPECT_EQ(20u, I.start());
449 EXPECT_EQ(35u, I.stop());
450 EXPECT_EQ(3u, I.value());
457 EXPECT_EQ(20u, I.start());
458 EXPECT_EQ(45u, I.stop());
459 EXPECT_EQ(4u, I.value());
464 EXPECT_EQ(200u, I.start());
465 EXPECT_EQ(205u, I.stop());
470 EXPECT_EQ(196u, I.start());
471 EXPECT_EQ(205u, I.stop());
472 EXPECT_EQ(20u, I.value());
477 EXPECT_EQ(196u, I.start());
478 EXPECT_EQ(205u, I.stop());
479 EXPECT_EQ(0u, I.value());
484 EXPECT_EQ(190u, I.start());
485 EXPECT_EQ(205u, I.stop());
486 EXPECT_EQ(19u, I.value());
493 EXPECT_EQ(180u, I.start());
494 EXPECT_EQ(205u, I.stop());
495 EXPECT_EQ(18u, I.value());
503 EXPECT_EQ(I.start(), map.start());
504 EXPECT_EQ(995u, map.stop());
524 EXPECT_EQ(10u, map.start());
525 EXPECT_EQ(9995u, map.stop());
529 EXPECT_EQ(0u, map.lookup(10*i-1));
530 EXPECT_EQ(i, map.lookup(10*i));
531 EXPECT_EQ(i, map.lookup(10*i+5));
532 EXPECT_EQ(0u, map.lookup(10*i+6));
539 EXPECT_EQ(10*i, I.start());
540 EXPECT_EQ(10*i+5, I.stop());
541 EXPECT_EQ(i, *I);
551 EXPECT_EQ(10*i, I.start());
552 EXPECT_EQ(10*i+5, I.stop());
553 EXPECT_EQ(i, *I);
560 EXPECT_EQ(20u, I.start());
561 EXPECT_EQ(25u, I.stop());
566 EXPECT_EQ(200u, I.start());
567 EXPECT_EQ(205u, I.stop());
572 EXPECT_EQ(2000u, I.start());
573 EXPECT_EQ(2005u, I.stop());
607 EXPECT_EQ(0u, map.start());
608 EXPECT_EQ(40959u, map.stop());
609 EXPECT_EQ(1, std::distance(map.begin(), map.end()));
684 EXPECT_EQ(4u, AB.a().start());
685 EXPECT_EQ(3u, AB.b().start());
691 EXPECT_EQ(3u, BA.a().start());
692 EXPECT_EQ(4u, BA.b().start());
727 EXPECT_EQ(400u, AB.a().start());
728 EXPECT_EQ(400u, AB.b().start());
731 EXPECT_EQ(400u, AB.a().start());
732 EXPECT_EQ(401u, AB.b().start());
735 EXPECT_EQ(400u, AB.a().start());
736 EXPECT_EQ(402u, AB.b().start());
739 EXPECT_EQ(410u, AB.a().start());
740 EXPECT_EQ(402u, AB.b().start());
743 EXPECT_EQ(420u, AB.a().start());
744 EXPECT_EQ(402u, AB.b().start());
747 EXPECT_EQ(600u, AB.a().start());
748 EXPECT_EQ(600u, AB.b().start());
756 EXPECT_EQ(410u, AB2.a().start());
757 EXPECT_EQ(402u, AB2.b().start());
762 EXPECT_EQ(410u, AB2.a().start());
763 EXPECT_EQ(402u, AB2.b().start());
768 EXPECT_EQ(400u, BA.b().start());
769 EXPECT_EQ(400u, BA.a().start());
772 EXPECT_EQ(400u, BA.b().start());
773 EXPECT_EQ(401u, BA.a().start());
776 EXPECT_EQ(400u, BA.b().start());
777 EXPECT_EQ(402u, BA.a().start());
780 EXPECT_EQ(410u, BA.b().start());
781 EXPECT_EQ(402u, BA.a().start());
784 EXPECT_EQ(420u, BA.b().start());
785 EXPECT_EQ(402u, BA.a().start());
788 EXPECT_EQ(600u, BA.b().start());
789 EXPECT_EQ(600u, BA.a().start());
797 EXPECT_EQ(410u, BA2.b().start());
798 EXPECT_EQ(402u, BA2.a().start());
802 EXPECT_EQ(410u, BA2.b().start());
803 EXPECT_EQ(402u, BA2.a().start());
unittests/ADT/IntrusiveRefCntPtrTest.cpp 28 EXPECT_EQ(0, SimpleRefCounted::NumInstances);
34 EXPECT_EQ(2, SimpleRefCounted::NumInstances);
36 EXPECT_EQ(0, SimpleRefCounted::NumInstances);
unittests/ADT/IteratorTest.cpp 83 EXPECT_EQ(*V[i], *I);
85 EXPECT_EQ(I, Begin + i);
86 EXPECT_EQ(I, std::next(Begin, i));
89 EXPECT_EQ(I, J);
90 EXPECT_EQ(*V[i], Begin[i]);
98 EXPECT_EQ(i, I - Begin);
99 EXPECT_EQ(i, std::distance(Begin, I));
100 EXPECT_EQ(Begin, I - i);
103 EXPECT_EQ(K, std::prev(I));
105 EXPECT_EQ(End, I);
125 EXPECT_EQ(*V[i], *I);
127 EXPECT_EQ(I, Begin + i);
128 EXPECT_EQ(I, std::next(Begin, i));
131 EXPECT_EQ(I, J);
132 EXPECT_EQ(*V[i], Begin[i]);
140 EXPECT_EQ(i, I - Begin);
141 EXPECT_EQ(i, std::distance(Begin, I));
142 EXPECT_EQ(Begin, I - i);
145 EXPECT_EQ(K, std::prev(I));
147 EXPECT_EQ(End, I);
156 EXPECT_EQ(A[I++], II);
169 EXPECT_EQ(*V[j], *I);
178 EXPECT_EQ((SmallVector<int, 3>{1, 3, 5}), Actual);
196 EXPECT_EQ(2, Counter);
199 EXPECT_EQ((SmallVector<int, 3>{1, 3, 5}), Actual);
207 EXPECT_EQ((SmallVector<int, 3>{1, 3, 5}), Actual);
221 EXPECT_EQ((SmallVector<int, 3>{1, 3, 5}), Actual);
239 EXPECT_EQ((SmallVector<int, 3>{1, 3, 5}), Actual);
249 EXPECT_EQ((SmallVector<int, 3>{5, 3, 1}), Actual);
254 EXPECT_EQ((SmallVector<int, 3>{1, 3, 5}), Actual2);
259 EXPECT_EQ((SmallVector<int, 0>{}), Actual3);
266 EXPECT_EQ((SmallVector<int, 4>{6, 4, 2, 0}), Actual4);
272 EXPECT_EQ(A, *Begin);
274 EXPECT_EQ(A + 1, *Begin);
276 EXPECT_EQ(A + 2, *Begin);
278 EXPECT_EQ(A + 3, *Begin);
280 EXPECT_EQ(Begin, End);
286 EXPECT_EQ(A, *Begin);
287 EXPECT_EQ(A + 1, std::next(*Begin, 1));
288 EXPECT_EQ(A + 2, std::next(*Begin, 2));
289 EXPECT_EQ(A + 3, std::next(*Begin, 3));
290 EXPECT_EQ(A + 4, std::next(*Begin, 4));
297 EXPECT_EQ(A + I++, P);
307 EXPECT_EQ(get<0>(tup) & 0x01, get<1>(tup));
308 EXPECT_EQ(get<0>(tup) & 0x01 ? 'y' : 'n', get<2>(tup));
313 EXPECT_EQ(get<0>(tup) & 0x01, get<1>(tup));
323 EXPECT_EQ(get<0>(tup), get<1>(tup) & 0x01);
327 EXPECT_EQ(iters, 4u);
343 EXPECT_EQ(tup, expected[iters]);
346 EXPECT_EQ(iters, expected.size());
357 EXPECT_EQ(tup, expected[iters]);
360 EXPECT_EQ(iters, expected.size());
370 EXPECT_EQ(get<1>(tup), get<2>(tup));
376 EXPECT_EQ(get<0>(tup), get<1>(tup));
390 EXPECT_EQ(iters, 4u);
393 EXPECT_EQ(get<0>(tup), get<1>(tup));
406 EXPECT_EQ(get<0>(tup) & 0x01, get<1>(tup));
412 EXPECT_EQ(iters, 5u);
428 EXPECT_EQ(get<0>(tup) & 0x01, get<1>(tup));
448 EXPECT_EQ(std::distance(v1.begin(), v1.end()), size(v1));
449 EXPECT_EQ(std::distance(v2.begin(), v2.end()), size(v2));
458 EXPECT_EQ(v, i);
461 EXPECT_EQ(i, 5);
unittests/ADT/MakeUniqueTest.cpp 19 EXPECT_EQ(0, *p0);
23 EXPECT_EQ(5, *p1);
27 EXPECT_EQ(std::make_tuple(0, 1), *p2);
31 EXPECT_EQ(std::make_tuple(0, 1, 2), *p3);
35 EXPECT_EQ(std::make_tuple(0, 1, 2, 3), *p4);
39 EXPECT_EQ(std::make_tuple(0, 1, 2, 3, 4), *p5);
44 EXPECT_EQ(std::make_tuple(0, 1, 2, 3, 4, 5), *p6);
49 EXPECT_EQ(std::make_tuple(0, 1, 2, 3, 4, 5, 6), *p7);
54 EXPECT_EQ(std::make_tuple(0, 1, 2, 3, 4, 5, 6, 7), *p8);
60 EXPECT_EQ(std::make_tuple(0, 1, 2, 3, 4, 5, 6, 7, 8), *p9);
66 EXPECT_EQ(std::make_tuple(0, 1, 2, 3, 4, 5, 6, 7, 8, 9), *p10);
72 EXPECT_EQ(0, p1[0]);
73 EXPECT_EQ(0, p1[1]);
unittests/ADT/MapVectorTest.cpp 22 EXPECT_EQ(R.first->first, 1);
23 EXPECT_EQ(R.first->second, 2);
37 EXPECT_EQ(I->first, 1);
38 EXPECT_EQ(I->second, 2);
47 EXPECT_EQ(R.first->first, 1);
48 EXPECT_EQ(R.first->second, 2);
53 EXPECT_EQ(R.first->first, 1);
54 EXPECT_EQ(R.first->second, 2);
59 EXPECT_EQ(R.first->first, 4);
60 EXPECT_EQ(R.first->second, 5);
63 EXPECT_EQ(MV.size(), 2u);
64 EXPECT_EQ(MV[1], 2);
65 EXPECT_EQ(MV[4], 5);
68 EXPECT_EQ(MV.size(), 1u);
69 EXPECT_EQ(MV[1], 2);
73 EXPECT_EQ(R.first->first, 4);
74 EXPECT_EQ(R.first->second, 7);
77 EXPECT_EQ(MV.size(), 2u);
78 EXPECT_EQ(MV[1], 2);
79 EXPECT_EQ(MV[4], 7);
178 EXPECT_EQ(R.first->first, 1);
179 EXPECT_EQ(R.first->second, 2);
185 EXPECT_EQ(R.first->first, 1);
186 EXPECT_EQ(R.first->second, 2);
190 EXPECT_EQ(value, 0);
193 EXPECT_EQ(MV.size(), 2u);
194 EXPECT_EQ(MV[1], 2);
195 EXPECT_EQ(MV[4], 5);
204 EXPECT_EQ(R.first->first, 1);
205 EXPECT_EQ(R.first->second, 2);
210 EXPECT_EQ(R.first->first, 1);
211 EXPECT_EQ(R.first->second, 2);
216 EXPECT_EQ(R.first->first, 4);
217 EXPECT_EQ(R.first->second, 5);
220 EXPECT_EQ(MV.size(), 2u);
221 EXPECT_EQ(MV[1], 2);
222 EXPECT_EQ(MV[4], 5);
225 EXPECT_EQ(MV.size(), 1u);
226 EXPECT_EQ(MV[1], 2);
230 EXPECT_EQ(R.first->first, 4);
231 EXPECT_EQ(R.first->second, 7);
234 EXPECT_EQ(MV.size(), 2u);
235 EXPECT_EQ(MV[1], 2);
236 EXPECT_EQ(MV[4], 7);
322 EXPECT_EQ(R.first->first, 1);
323 EXPECT_EQ(R.first->second, 2);
328 EXPECT_EQ(R.first->first, 1);
329 EXPECT_EQ(R.first->second, 2);
334 EXPECT_EQ(R.first->first, 4);
335 EXPECT_EQ(R.first->second, 5);
338 EXPECT_EQ(MV.size(), 2u);
339 EXPECT_EQ(MV[1], 2);
340 EXPECT_EQ(MV[4], 5);
343 EXPECT_EQ(MV.size(), 1u);
344 EXPECT_EQ(MV[1], 2);
348 EXPECT_EQ(R.first->first, 4);
349 EXPECT_EQ(R.first->second, 7);
352 EXPECT_EQ(MV.size(), 2u);
353 EXPECT_EQ(MV[1], 2);
354 EXPECT_EQ(MV[4], 7);
unittests/ADT/MappedIteratorTest.cpp 21 EXPECT_EQ(*I, 1) << "should have applied function in dereference";
37 EXPECT_EQ(Y.Z, 42) << "should have applied function during arrow";
47 EXPECT_EQ(M[1], 42) << "assignment should have modified M";
unittests/ADT/OptionalTest.cpp 71 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
72 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
73 EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
76 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
77 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
78 EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
84 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
85 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
86 EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
93 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
94 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
95 EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
98 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
99 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
100 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
103 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
104 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
105 EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
113 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
114 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
115 EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
118 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
119 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
120 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
123 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
124 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
125 EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
133 EXPECT_EQ(2u, NonDefaultConstructible::CopyConstructions);
134 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
135 EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
138 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
139 EXPECT_EQ(1u, NonDefaultConstructible::CopyAssignments);
140 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
143 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
144 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
145 EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
153 EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
154 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
155 EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
158 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
159 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
160 EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
163 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
164 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
165 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
173 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
174 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
175 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
178 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
179 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
180 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
183 EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
184 EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
185 EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
190 EXPECT_EQ(42, A.getValueOr(42));
193 EXPECT_EQ(5, A.getValueOr(42));
227 EXPECT_EQ(1, A->x);
228 EXPECT_EQ(2, A->y);
229 EXPECT_EQ(0u, MultiArgConstructor::Destructions);
233 EXPECT_EQ(5, A->x);
234 EXPECT_EQ(-5, A->y);
235 EXPECT_EQ(1u, MultiArgConstructor::Destructions);
274 EXPECT_EQ(0u, MoveOnly::MoveConstructions);
275 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
276 EXPECT_EQ(0u, MoveOnly::Destructions);
283 EXPECT_EQ(3, O->val);
284 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
285 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
286 EXPECT_EQ(1u, MoveOnly::Destructions);
295 EXPECT_EQ(3, B->val);
296 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
297 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
298 EXPECT_EQ(0u, MoveOnly::Destructions);
306 EXPECT_EQ(3, O->val);
307 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
308 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
309 EXPECT_EQ(1u, MoveOnly::Destructions);
319 EXPECT_EQ(3, B->val);
320 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
321 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
322 EXPECT_EQ(0u, MoveOnly::Destructions);
332 EXPECT_EQ(0u, MoveOnly::MoveConstructions);
333 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
334 EXPECT_EQ(1u, MoveOnly::Destructions);
344 EXPECT_EQ(3, B->val);
345 EXPECT_EQ(0u, MoveOnly::MoveConstructions);
346 EXPECT_EQ(1u, MoveOnly::MoveAssignments);
347 EXPECT_EQ(0u, MoveOnly::Destructions);
380 EXPECT_EQ(4, A->val);
381 EXPECT_EQ(1u, Immovable::Constructions);
382 EXPECT_EQ(0u, Immovable::Destructions);
391 EXPECT_EQ(42, std::move(A).getValueOr(MoveOnly(42)).val);
392 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
393 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
394 EXPECT_EQ(2u, MoveOnly::Destructions);
398 EXPECT_EQ(5, std::move(A).getValueOr(MoveOnly(42)).val);
399 EXPECT_EQ(1u, MoveOnly::MoveConstructions);
400 EXPECT_EQ(0u, MoveOnly::MoveAssignments);
401 EXPECT_EQ(2u, MoveOnly::Destructions);
445 EXPECT_EQ(Expected, OperatorT::apply(Lhs, Rhs));
448 EXPECT_EQ(Expected, OperatorT::apply(*Lhs, Rhs));
450 EXPECT_EQ(Expected, OperatorT::apply(None, Rhs));
453 EXPECT_EQ(Expected, OperatorT::apply(Lhs, *Rhs));
455 EXPECT_EQ(Expected, OperatorT::apply(Lhs, None));
464 EXPECT_EQ(&*EqualityLhs, &Lhs);
465 EXPECT_EQ(&*EqualityRhs, &Rhs);
497 EXPECT_EQ(&*InequalityLhs, &Lhs);
498 EXPECT_EQ(&*InequalityRhs, &Rhs);
568 EXPECT_EQ("ComparableAndStreamable",
570 EXPECT_EQ("None", to_string(None));
583 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(llvm::None, ComparableAndStreamable::get()),
591 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(llvm::None, Comparable::get()), "object");
unittests/ADT/PackedVectorTest.cpp 22 EXPECT_EQ(0U, Vec.size());
26 EXPECT_EQ(5U, Vec.size());
30 EXPECT_EQ(11U, Vec.size());
34 EXPECT_EQ(3U, Vec2.size());
38 EXPECT_EQ(0U, Vec.size());
46 EXPECT_EQ(2U, Vec[0]);
47 EXPECT_EQ(0U, Vec[1]);
48 EXPECT_EQ(1U, Vec[2]);
49 EXPECT_EQ(3U, Vec[3]);
61 EXPECT_EQ(3U, Vec[1]);
unittests/ADT/PointerEmbeddedIntTest.cpp 18 EXPECT_EQ(42, I);
19 EXPECT_EQ(43, I + 1);
20 EXPECT_EQ(sizeof(uintptr_t) * CHAR_BIT - CHAR_BIT,
47 EXPECT_EQ(42, IPos);
48 EXPECT_EQ(-42, INeg);
51 EXPECT_EQ(42U, U);
52 EXPECT_EQ(255U, USaturated);
57 EXPECT_EQ(std::numeric_limits<intptr_t>::max() >> 1, IMax);
58 EXPECT_EQ(std::numeric_limits<intptr_t>::min() >> 1, IMin);
63 EXPECT_EQ(std::numeric_limits<uintptr_t>::max() >> 1, UMax);
64 EXPECT_EQ(std::numeric_limits<uintptr_t>::min() >> 1, UMin);
70 EXPECT_EQ(42, ITraits::getFromVoidPointer(ITraits::getAsVoidPointer(I)));
75 EXPECT_EQ(std::numeric_limits<uintptr_t>::max() >> 1,
unittests/ADT/PointerIntPairTest.cpp 23 EXPECT_EQ(&s, Pair.getPointer());
24 EXPECT_EQ(1U, Pair.getInt());
27 EXPECT_EQ(&s, Pair.getPointer());
28 EXPECT_EQ(2U, Pair.getInt());
31 EXPECT_EQ(nullptr, Pair.getPointer());
32 EXPECT_EQ(2U, Pair.getInt());
35 EXPECT_EQ(&s, Pair.getPointer());
36 EXPECT_EQ(3U, Pair.getInt());
50 EXPECT_EQ(&s, Pair2.getPointer());
51 EXPECT_EQ(E::Case1, Pair2.getInt());
54 EXPECT_EQ(&s, Pair2.getPointer());
55 EXPECT_EQ(E::Case2, Pair2.getInt());
58 EXPECT_EQ(nullptr, Pair2.getPointer());
59 EXPECT_EQ(E::Case2, Pair2.getInt());
62 EXPECT_EQ(&s, Pair2.getPointer());
63 EXPECT_EQ(E::Case3, Pair2.getInt());
71 EXPECT_EQ(nullptr, Pair.getPointer());
72 EXPECT_EQ(0U, Pair.getInt());
93 EXPECT_EQ((uintptr_t)0, pair.getPointer().Value);
97 EXPECT_EQ((uintptr_t)0x7FFFFFFF, pair.getPointer().Value);
100 EXPECT_EQ(FixnumPointerTraits::NumLowBitsAvailable - 1,
unittests/ADT/PointerSumTypeTest.cpp 39 EXPECT_EQ(Float, a.getTag());
40 EXPECT_EQ(Int1, b.getTag());
41 EXPECT_EQ(Int2, c.getTag());
42 EXPECT_EQ((Kinds)0, n.getTag());
58 EXPECT_EQ(&f, a.get<Float>());
59 EXPECT_EQ(nullptr, a.get<Int1>());
60 EXPECT_EQ(nullptr, a.get<Int2>());
61 EXPECT_EQ(nullptr, b.get<Float>());
62 EXPECT_EQ(&i1, b.get<Int1>());
63 EXPECT_EQ(nullptr, b.get<Int2>());
64 EXPECT_EQ(nullptr, c.get<Float>());
65 EXPECT_EQ(nullptr, c.get<Int1>());
66 EXPECT_EQ(&i2, c.get<Int2>());
70 EXPECT_EQ(nullptr, n.get<Float>());
71 EXPECT_EQ(nullptr, n.get<Int1>());
72 EXPECT_EQ(nullptr, n.get<Int2>());
76 EXPECT_EQ(&f, a.cast<Float>());
77 EXPECT_EQ(&i1, b.cast<Int1>());
78 EXPECT_EQ(&i2, c.cast<Int2>());
83 EXPECT_EQ(nullptr, b.get<Float>());
84 EXPECT_EQ(nullptr, b.get<Int1>());
85 EXPECT_EQ(&i2, b.get<Int2>());
88 EXPECT_EQ(nullptr, b.get<Float>());
89 EXPECT_EQ(nullptr, b.get<Int1>());
90 EXPECT_EQ(&i1, b.get<Int2>());
94 EXPECT_EQ(&Local, b.get<Float>());
95 EXPECT_EQ(nullptr, b.get<Int1>());
96 EXPECT_EQ(nullptr, b.get<Int2>());
100 EXPECT_EQ(nullptr, n.get<Float>());
101 EXPECT_EQ(&i2, n.get<Int1>());
102 EXPECT_EQ(nullptr, n.get<Int2>());
106 EXPECT_EQ(nullptr, n.get<Float>());
107 EXPECT_EQ(nullptr, n.get<Int1>());
108 EXPECT_EQ(nullptr, n.get<Int2>());
unittests/ADT/PointerUnionTest.cpp 74 EXPECT_EQ(b, c);
76 EXPECT_EQ(n, b);
112 EXPECT_EQ(a.get<float *>(), &f);
113 EXPECT_EQ(b.get<int *>(), &i);
114 EXPECT_EQ(n.get<int *>(), (int *)nullptr);
136 EXPECT_EQ(a.dyn_cast<Aligned<0>*>(), &a0);
137 EXPECT_EQ(*a.getAddrOfPtr1(), &a0);
148 EXPECT_EQ(a.dyn_cast<Aligned<7>*>(), &a7);
unittests/ADT/PriorityWorklistTest.cpp 30 EXPECT_EQ(0u, W.size());
38 EXPECT_EQ(3u, W.size());
42 EXPECT_EQ(3u, W.size());
43 EXPECT_EQ(17, W.back());
47 EXPECT_EQ(2u, W.size());
48 EXPECT_EQ(42, W.back());
52 EXPECT_EQ(0u, W.size());
60 EXPECT_EQ(4u, W.size());
61 EXPECT_EQ(17, W.back());
65 EXPECT_EQ(3u, W.size());
66 EXPECT_EQ(17, W.back());
69 EXPECT_EQ(3u, W.size());
70 EXPECT_EQ(42, W.pop_back_val());
71 EXPECT_EQ(17, W.pop_back_val());
72 EXPECT_EQ(21, W.pop_back_val());
84 EXPECT_EQ(8, W.pop_back_val());
85 EXPECT_EQ(7, W.pop_back_val());
86 EXPECT_EQ(42, W.pop_back_val());
87 EXPECT_EQ(13, W.pop_back_val());
88 EXPECT_EQ(4, W.pop_back_val());
89 EXPECT_EQ(2, W.pop_back_val());
97 EXPECT_EQ(5, W.pop_back_val());
98 EXPECT_EQ(7, W.pop_back_val());
99 EXPECT_EQ(2, W.pop_back_val());
107 EXPECT_EQ(5, W.pop_back_val());
108 EXPECT_EQ(7, W.pop_back_val());
109 EXPECT_EQ(2, W.pop_back_val());
116 EXPECT_EQ(7, W.pop_back_val());
117 EXPECT_EQ(2, W.pop_back_val());
131 EXPECT_EQ(6u, W.size());
134 EXPECT_EQ(6u, W.size());
135 EXPECT_EQ(42, W.back());
141 EXPECT_EQ(3u, W.size());
147 EXPECT_EQ(23, W.pop_back_val());
148 EXPECT_EQ(47, W.pop_back_val());
149 EXPECT_EQ(13, W.pop_back_val());
unittests/ADT/RangeAdapterTest.cpp 124 EXPECT_EQ(i, counter--);
unittests/ADT/SCCIteratorTest.cpp 116 EXPECT_EQ(NodesInSomeSCC, G.NodesReachableFrom(0));
unittests/ADT/STLExtrasTest.cpp 27 EXPECT_EQ(0, f(rank<0>()));
28 EXPECT_EQ(1, f(rank<1>()));
29 EXPECT_EQ(2, f(rank<2>()));
32 EXPECT_EQ(2, f(rank<3>()));
35 EXPECT_EQ(4, f(rank<4>()));
38 EXPECT_EQ(4, f(rank<5>()));
39 EXPECT_EQ(4, f(rank<6>()));
53 EXPECT_EQ(CharPairType(0u, 'a'), CharResults[0]);
54 EXPECT_EQ(CharPairType(1u, 'b'), CharResults[1]);
55 EXPECT_EQ(CharPairType(2u, 'c'), CharResults[2]);
65 EXPECT_EQ(IntPairType(0u, 1), IntResults[0]);
66 EXPECT_EQ(IntPairType(1u, 2), IntResults[1]);
67 EXPECT_EQ(IntPairType(2u, 3), IntResults[2]);
86 EXPECT_EQ('b', foo[0]);
87 EXPECT_EQ('c', foo[1]);
88 EXPECT_EQ('d', foo[2]);
103 EXPECT_EQ(PairType(0u, 1), Results[0]);
104 EXPECT_EQ(PairType(1u, 2), Results[1]);
105 EXPECT_EQ(PairType(2u, 3), Results[2]);
121 EXPECT_EQ(PairType(0u, '2'), Results[0]);
122 EXPECT_EQ(PairType(1u, '3'), Results[1]);
123 EXPECT_EQ(PairType(2u, '4'), Results[2]);
171 EXPECT_EQ(0, Copies);
172 EXPECT_EQ(1, Moves);
173 EXPECT_EQ(1, Destructors);
175 EXPECT_EQ(0, Copies);
176 EXPECT_EQ(1, Moves);
177 EXPECT_EQ(2, Destructors);
186 EXPECT_EQ(0, Copies);
187 EXPECT_EQ(0, Moves);
188 EXPECT_EQ(0, Destructors);
190 EXPECT_EQ(0, Copies);
191 EXPECT_EQ(0, Moves);
192 EXPECT_EQ(0, Destructors);
201 EXPECT_EQ(-2, std::get<0>(U));
202 EXPECT_EQ(-4, std::get<1>(U));
203 EXPECT_EQ(6, std::get<2>(U));
213 EXPECT_EQ(std::make_pair(1, 'B'), std::get<0>(V));
214 EXPECT_EQ(std::make_pair(3, 'D'), std::get<1>(V));
215 EXPECT_EQ(std::make_pair(7, 'H'), std::get<2>(V));
235 EXPECT_EQ(2, std::get<0>(Values));
236 EXPECT_EQ("Tes", std::get<1>(Values));
237 EXPECT_EQ('Y', std::get<2>(Values));
251 EXPECT_EQ(3, count(v, 1));
252 EXPECT_EQ(2, count(v, 2));
253 EXPECT_EQ(1, count(v, 3));
254 EXPECT_EQ(1, count(v, 4));
262 EXPECT_EQ(5, count);
270 EXPECT_EQ(I, Enumerated[I].index());
271 EXPECT_EQ(v[I], Enumerated[I].value());
287 EXPECT_EQ(Expected, Test);
294 EXPECT_EQ(Expected, Test);
307 EXPECT_EQ(2, V[0]);
308 EXPECT_EQ(4, V[1]);
309 EXPECT_EQ(6, V[2]);
310 EXPECT_EQ(8, V[3]);
311 EXPECT_EQ(1, V[4]);
312 EXPECT_EQ(3, V[5]);
313 EXPECT_EQ(5, V[6]);
314 EXPECT_EQ(7, V[7]);
321 EXPECT_EQ(4u, V.size());
322 EXPECT_EQ(1, V[0]);
323 EXPECT_EQ(3, V[1]);
324 EXPECT_EQ(5, V[2]);
325 EXPECT_EQ(7, V[3]);
354 EXPECT_EQ(*adl_begin(s), 1);
355 EXPECT_EQ(*(adl_end(s) - 1), 5);
358 EXPECT_EQ(s.swap_val, "lhs");
359 EXPECT_EQ(s2.swap_val, "rhs");
363 EXPECT_EQ(5, count);
392 EXPECT_EQ(1, *I);
411 EXPECT_EQ(2, *I);
424 EXPECT_EQ(3, *I);
429 EXPECT_EQ(4, *I);
431 EXPECT_EQ(EIR.end(), I);
451 EXPECT_EQ(V1, to_address(V1));
455 EXPECT_EQ(V2.get(), to_address(V2));
458 EXPECT_EQ(V1, to_address(V2));
464 EXPECT_EQ(V3.get(), V4.get());
465 EXPECT_EQ(V3.get(), to_address(V3));
466 EXPECT_EQ(V4.get(), to_address(V4));
469 EXPECT_EQ(V1, to_address(V3));
476 EXPECT_EQ(V.begin() + 3,
478 EXPECT_EQ(V.begin(), partition_point(V, [](unsigned X) { return X < 1; }));
479 EXPECT_EQ(V.end(), partition_point(V, [](unsigned X) { return X < 50; }));
unittests/ADT/ScopeExitTest.cpp 38 EXPECT_EQ(0, Count);
40 EXPECT_EQ(1, Count);
45 EXPECT_EQ(1, Count);
unittests/ADT/SequenceTest.cpp 21 EXPECT_EQ(x, i);
24 EXPECT_EQ(10, x);
27 EXPECT_EQ(4, my_seq.end() - my_seq.begin());
29 EXPECT_EQ(i, (int)my_seq.begin()[i]);
36 EXPECT_EQ(2, *adjusted_begin);
37 EXPECT_EQ(2, *adjusted_end);
unittests/ADT/SetVectorTest.cpp 28 EXPECT_EQ(std::next(S.begin()), I);
29 EXPECT_EQ(2u, S.size());
30 EXPECT_EQ(0, *S.begin());
31 EXPECT_EQ(2, *std::next(S.begin()));
unittests/ADT/SimpleIListTest.cpp 25 EXPECT_EQ(L.begin(), L.end());
27 EXPECT_EQ(0u, L.size());
35 EXPECT_EQ(&A, &L.front());
36 EXPECT_EQ(&B, &L.back());
38 EXPECT_EQ(2u, L.size());
42 EXPECT_EQ(&B, &L.front());
54 EXPECT_EQ(&A, &L.front());
55 EXPECT_EQ(&B, &L.back());
57 EXPECT_EQ(2u, L.size());
61 EXPECT_EQ(&A, &L.back());
75 EXPECT_EQ(0u, L1.size());
76 EXPECT_EQ(&A, &L2.front());
77 EXPECT_EQ(&B, &L2.back());
79 EXPECT_EQ(2u, L2.size());
87 EXPECT_EQ(&A, &L.front());
88 EXPECT_EQ(&B, &L.back());
90 EXPECT_EQ(2u, L.size());
98 EXPECT_EQ(&A, &L.front());
99 EXPECT_EQ(&B, &L.back());
101 EXPECT_EQ(2u, L.size());
110 EXPECT_EQ(&A, &L.front());
111 EXPECT_EQ(&B, &*++L.begin());
112 EXPECT_EQ(&C, &L.back());
113 EXPECT_EQ(3u, L.size());
116 EXPECT_EQ(&A, &L.front());
117 EXPECT_EQ(&C, &L.back());
118 EXPECT_EQ(2u, L.size());
121 EXPECT_EQ(&C, &L.front());
122 EXPECT_EQ(1u, L.size());
135 EXPECT_EQ(&A, &L.front());
136 EXPECT_EQ(B, &*++L.begin());
137 EXPECT_EQ(&C, &L.back());
138 EXPECT_EQ(3u, L.size());
141 EXPECT_EQ(&A, &L.front());
142 EXPECT_EQ(&C, &L.back());
143 EXPECT_EQ(2u, L.size());
152 EXPECT_EQ(&A, &L.front());
153 EXPECT_EQ(&B, &*++L.begin());
154 EXPECT_EQ(&C, &L.back());
155 EXPECT_EQ(3u, L.size());
158 EXPECT_EQ(&A, &L.front());
159 EXPECT_EQ(&C, &L.back());
160 EXPECT_EQ(2u, L.size());
169 EXPECT_EQ(&A, &L.front());
170 EXPECT_EQ(&B, &*++L.begin());
171 EXPECT_EQ(&C, &L.back());
172 EXPECT_EQ(3u, L.size());
174 EXPECT_EQ(C.getIterator(), L.erase(B.getIterator()));
175 EXPECT_EQ(&A, &L.front());
176 EXPECT_EQ(&C, &L.back());
177 EXPECT_EQ(2u, L.size());
188 EXPECT_EQ(C.getReverseIterator(), ReverseIter);
190 EXPECT_EQ(B.getReverseIterator(), ReverseIter);
192 EXPECT_EQ(A.getReverseIterator(), ReverseIter);
194 EXPECT_EQ(L.rend(), ReverseIter);
204 EXPECT_EQ(&A, &L.front());
205 EXPECT_EQ(B, &*++L.begin());
206 EXPECT_EQ(&C, &L.back());
207 EXPECT_EQ(3u, L.size());
210 EXPECT_EQ(&A, &L.front());
211 EXPECT_EQ(&C, &L.back());
212 EXPECT_EQ(2u, L.size());
221 EXPECT_EQ(&A, &L.front());
222 EXPECT_EQ(&B, &*++L.begin());
223 EXPECT_EQ(&C, &L.back());
224 EXPECT_EQ(3u, L.size());
227 EXPECT_EQ(&A, &L.front());
228 EXPECT_EQ(&C, &L.back());
229 EXPECT_EQ(2u, L.size());
241 EXPECT_EQ(&A, &*I++);
242 EXPECT_EQ(&B, &*I++);
243 EXPECT_EQ(&C, &*I++);
244 EXPECT_EQ(&D, &*I++);
245 EXPECT_EQ(&E, &*I++);
246 EXPECT_EQ(L.end(), I);
247 EXPECT_EQ(5u, L.size());
250 EXPECT_EQ(E.getIterator(), L.erase(B.getIterator(), E.getIterator()));
251 EXPECT_EQ(&A, &L.front());
252 EXPECT_EQ(&E, &L.back());
253 EXPECT_EQ(2u, L.size());
265 EXPECT_EQ(&A, &*I++);
266 EXPECT_EQ(B, &*I++);
267 EXPECT_EQ(C, &*I++);
268 EXPECT_EQ(D, &*I++);
269 EXPECT_EQ(&E, &*I++);
270 EXPECT_EQ(L.end(), I);
271 EXPECT_EQ(5u, L.size());
274 EXPECT_EQ(E.getIterator(),
276 EXPECT_EQ(&A, &L.front());
277 EXPECT_EQ(&E, &L.back());
278 EXPECT_EQ(2u, L.size());
290 EXPECT_EQ(&A, &*I++);
291 EXPECT_EQ(&B, &*I++);
292 EXPECT_EQ(&C, &*I++);
293 EXPECT_EQ(&D, &*I++);
294 EXPECT_EQ(&E, &*I++);
295 EXPECT_EQ(L.end(), I);
296 EXPECT_EQ(5u, L.size());
299 EXPECT_EQ(E.getIterator(),
301 EXPECT_EQ(&A, &L.front());
302 EXPECT_EQ(&E, &L.back());
303 EXPECT_EQ(2u, L.size());
313 EXPECT_EQ(0u, L.size());
324 EXPECT_EQ(0u, L.size());
334 EXPECT_EQ(0u, L.size());
352 EXPECT_EQ(4u, L1.size());
354 EXPECT_EQ(&A, &*I++);
355 EXPECT_EQ(&B, &*I++);
356 EXPECT_EQ(&C, &*I++);
357 EXPECT_EQ(&D, &*I++);
358 EXPECT_EQ(L1.end(), I);
377 EXPECT_EQ(&A, &*I++);
378 EXPECT_EQ(&B, &*I++);
379 EXPECT_EQ(&C, &*I++);
380 EXPECT_EQ(L1.end(), I);
383 EXPECT_EQ(&D, &*I++);
384 EXPECT_EQ(&E, &*I++);
385 EXPECT_EQ(L2.end(), I);
405 EXPECT_EQ(&A, &*I++);
406 EXPECT_EQ(&B, &*I++);
407 EXPECT_EQ(&C, &*I++);
408 EXPECT_EQ(&D, &*I++);
409 EXPECT_EQ(L1.end(), I);
412 EXPECT_EQ(&E, &*I++);
413 EXPECT_EQ(&F, &*I++);
414 EXPECT_EQ(L2.end(), I);
437 EXPECT_EQ(4u, L1.size());
438 EXPECT_EQ(6u, L2.size());
451 EXPECT_EQ(&N, &*I++);
452 EXPECT_EQ(LHS.end(), I);
474 EXPECT_EQ(3u, L1.size());
475 EXPECT_EQ(2u, L2.size());
487 EXPECT_EQ(&Ns[0], &*I++);
488 EXPECT_EQ(&Ns[3], &*I++);
489 EXPECT_EQ(&Ns[4], &*I++);
490 EXPECT_EQ(&Ns[1], &*I++);
491 EXPECT_EQ(&Ns[2], &*I++);
492 EXPECT_EQ(L1.end(), I);
502 EXPECT_EQ(&Ns[1], &*I++);
503 EXPECT_EQ(&Ns[2], &*I++);
504 EXPECT_EQ(&Ns[0], &*I++);
505 EXPECT_EQ(&Ns[3], &*I++);
506 EXPECT_EQ(&Ns[4], &*I++);
507 EXPECT_EQ(L2.end(), I);
522 EXPECT_EQ(4u, L1.size());
535 EXPECT_EQ(&N, &*I++);
536 EXPECT_EQ(LHS.end(), I);
556 EXPECT_EQ(10u, L.size());
564 EXPECT_EQ(&N, &*I++);
565 EXPECT_EQ(L.end(), I);
583 EXPECT_EQ(10u, L.size());
591 EXPECT_EQ(&Ns[O], &*I++);
593 EXPECT_EQ(&Ns[O], &*I++);
594 EXPECT_EQ(L.end(), I);
636 EXPECT_EQ(sizeof(Order1) / sizeof(int), L1.size());
639 EXPECT_EQ(Ns[I].getIterator1(), I1);
640 EXPECT_EQ(&Ns[I], &*I1++);
642 EXPECT_EQ(L1.end(), I1);
644 EXPECT_EQ(sizeof(Order2) / sizeof(int), L2.size());
647 EXPECT_EQ(Ns[I].getIterator2(), I2);
648 EXPECT_EQ(&Ns[I], &*I2++);
650 EXPECT_EQ(L2.end(), I2);
unittests/ADT/SmallPtrSetTest.cpp 33 EXPECT_EQ(4U, s1.size());
63 EXPECT_EQ(4U, s.size());
68 EXPECT_EQ(4, i);
70 EXPECT_EQ(i<4?1:0,buf[i]);
80 EXPECT_EQ(8, i);
85 EXPECT_EQ(4U, s.size());
90 EXPECT_EQ(4, i);
92 EXPECT_EQ(i<4?3:1,buf[i]);
97 EXPECT_EQ(8U, s.size());
101 EXPECT_EQ(1,buf[i]);
114 EXPECT_EQ(4U, s1.size());
122 EXPECT_EQ(4U, s2.size());
130 EXPECT_EQ(4U, s1.size());
131 EXPECT_EQ(4U, s2.size());
139 EXPECT_EQ(4U, s3.size());
154 EXPECT_EQ(8U, s1.size());
161 EXPECT_EQ(8U, s3.size());
162 EXPECT_EQ(8U, s1.size());
177 EXPECT_EQ(2U, a.size());
178 EXPECT_EQ(1U, b.size());
190 EXPECT_EQ(1U, a.size());
191 EXPECT_EQ(2U, b.size());
204 EXPECT_EQ(3U, a.size());
205 EXPECT_EQ(1U, b.size());
217 EXPECT_EQ(1U, a.size());
218 EXPECT_EQ(3U, b.size());
234 EXPECT_EQ(3U, a.size());
235 EXPECT_EQ(4U, b.size());
268 EXPECT_EQ(B, S.begin());
269 EXPECT_EQ(M, std::next(B));
270 EXPECT_EQ(E, S.end());
271 EXPECT_EQ(std::next(M), E);
289 EXPECT_EQ(&I, *S.insert(&I).first);
290 EXPECT_EQ(&I, *S.find(&I));
303 EXPECT_EQ(F - Found + 1, *F);
314 EXPECT_EQ(IntSet.count(B), 1u);
315 EXPECT_EQ(IntSet.count(C), 1u);
329 EXPECT_EQ(IntSet.count(Pair), 1u);
unittests/ADT/SmallSetTest.cpp 29 EXPECT_EQ(4u, s1.size());
32 EXPECT_EQ(1u, s1.count(i));
34 EXPECT_EQ(0u, s1.count(4));
43 EXPECT_EQ(8u, s1.size());
46 EXPECT_EQ(1u, s1.count(i));
48 EXPECT_EQ(0u, s1.count(8));
57 EXPECT_EQ(8u, s1.size());
61 EXPECT_EQ(1u, s1.count(i));
63 EXPECT_EQ(0u, s1.count(i));
64 EXPECT_EQ(8u - i - 1, s1.size());
66 EXPECT_EQ(1u, s1.count(j));
69 EXPECT_EQ(0u, s1.count(8));
83 EXPECT_EQ(i, V[i]);
94 EXPECT_EQ(i, V[i]);
108 EXPECT_EQ(2u, s1.size());
109 EXPECT_EQ("str 1", V[0]);
110 EXPECT_EQ("str 2", V[1]);
119 EXPECT_EQ(4u, s1.size());
120 EXPECT_EQ("str 0", V[0]);
121 EXPECT_EQ("str 1", V[1]);
122 EXPECT_EQ("str 2", V[2]);
123 EXPECT_EQ("str 4", V[3]);
135 EXPECT_EQ("str 1", *Iter);
137 EXPECT_EQ("str 2", *Iter);
143 EXPECT_EQ("str 0", *Iter);
unittests/ADT/SmallStringTest.cpp 32 EXPECT_EQ(0u, v.size());
48 EXPECT_EQ(3u, theString.size());
55 EXPECT_EQ(3u, theString.size());
62 EXPECT_EQ(3u, theString.size());
70 EXPECT_EQ(3u, theString.size());
78 EXPECT_EQ(6u, theString.size());
86 EXPECT_EQ(6u, theString.size());
95 EXPECT_EQ(6u, theString.size());
101 EXPECT_EQ("lo", theString.substr(3));
102 EXPECT_EQ("", theString.substr(100));
103 EXPECT_EQ("hello", theString.substr(0, 100));
104 EXPECT_EQ("o", theString.substr(4, 10));
109 EXPECT_EQ("l", theString.slice(2, 3));
110 EXPECT_EQ("ell", theString.slice(1, 4));
111 EXPECT_EQ("llo", theString.slice(2, 100));
112 EXPECT_EQ("", theString.slice(2, 1));
113 EXPECT_EQ("", theString.slice(10, 20));
118 EXPECT_EQ(2U, theString.find('l'));
119 EXPECT_EQ(StringRef::npos, theString.find('z'));
120 EXPECT_EQ(StringRef::npos, theString.find("helloworld"));
121 EXPECT_EQ(0U, theString.find("hello"));
122 EXPECT_EQ(1U, theString.find("ello"));
123 EXPECT_EQ(StringRef::npos, theString.find("zz"));
124 EXPECT_EQ(2U, theString.find("ll", 2));
125 EXPECT_EQ(StringRef::npos, theString.find("ll", 3));
126 EXPECT_EQ(0U, theString.find(""));
128 EXPECT_EQ(3U, theString.rfind('l'));
129 EXPECT_EQ(StringRef::npos, theString.rfind('z'));
130 EXPECT_EQ(StringRef::npos, theString.rfind("helloworld"));
131 EXPECT_EQ(0U, theString.rfind("hello"));
132 EXPECT_EQ(1U, theString.rfind("ello"));
133 EXPECT_EQ(StringRef::npos, theString.rfind("zz"));
135 EXPECT_EQ(2U, theString.find_first_of('l'));
136 EXPECT_EQ(1U, theString.find_first_of("el"));
137 EXPECT_EQ(StringRef::npos, theString.find_first_of("xyz"));
139 EXPECT_EQ(1U, theString.find_first_not_of('h'));
140 EXPECT_EQ(4U, theString.find_first_not_of("hel"));
141 EXPECT_EQ(StringRef::npos, theString.find_first_not_of("hello"));
144 EXPECT_EQ(36U, theString.find("hello"));
145 EXPECT_EQ(28U, theString.find("foo"));
146 EXPECT_EQ(12U, theString.find("hell", 2));
147 EXPECT_EQ(0U, theString.find(""));
152 EXPECT_EQ(2U, theString.count('l'));
153 EXPECT_EQ(1U, theString.count('o'));
154 EXPECT_EQ(0U, theString.count('z'));
155 EXPECT_EQ(0U, theString.count("helloworld"));
156 EXPECT_EQ(1U, theString.count("hello"));
157 EXPECT_EQ(1U, theString.count("ello"));
158 EXPECT_EQ(0U, theString.count("zz"));
164 EXPECT_EQ("abcd", theString);
169 EXPECT_EQ("abcdyyy", theString.slice(0, 7));
173 EXPECT_EQ(-1, SmallString<10>("aab").compare("aad"));
174 EXPECT_EQ( 0, SmallString<10>("aab").compare("aab"));
175 EXPECT_EQ( 1, SmallString<10>("aab").compare("aaa"));
176 EXPECT_EQ(-1, SmallString<10>("aab").compare("aabb"));
177 EXPECT_EQ( 1, SmallString<10>("aab").compare("aa"));
178 EXPECT_EQ( 1, SmallString<10>("\xFF").compare("\1"));
180 EXPECT_EQ(-1, SmallString<10>("AaB").compare_lower("aAd"));
181 EXPECT_EQ( 0, SmallString<10>("AaB").compare_lower("aab"));
182 EXPECT_EQ( 1, SmallString<10>("AaB").compare_lower("AAA"));
183 EXPECT_EQ(-1, SmallString<10>("AaB").compare_lower("aaBb"));
184 EXPECT_EQ( 1, SmallString<10>("AaB").compare_lower("aA"));
185 EXPECT_EQ( 1, SmallString<10>("\xFF").compare_lower("\1"));
187 EXPECT_EQ(-1, SmallString<10>("aab").compare_numeric("aad"));
188 EXPECT_EQ( 0, SmallString<10>("aab").compare_numeric("aab"));
189 EXPECT_EQ( 1, SmallString<10>("aab").compare_numeric("aaa"));
190 EXPECT_EQ(-1, SmallString<10>("aab").compare_numeric("aabb"));
191 EXPECT_EQ( 1, SmallString<10>("aab").compare_numeric("aa"));
192 EXPECT_EQ(-1, SmallString<10>("1").compare_numeric("10"));
193 EXPECT_EQ( 0, SmallString<10>("10").compare_numeric("10"));
194 EXPECT_EQ( 0, SmallString<10>("10a").compare_numeric("10a"));
195 EXPECT_EQ( 1, SmallString<10>("2").compare_numeric("1"));
196 EXPECT_EQ( 0, SmallString<10>("llvm_v1i64_ty").compare_numeric("llvm_v1i64_ty"));
197 EXPECT_EQ( 1, SmallString<10>("\xFF").compare_numeric("\1"));
198 EXPECT_EQ( 1, SmallString<10>("V16").compare_numeric("V1_q0"));
199 EXPECT_EQ(-1, SmallString<10>("V1_q0").compare_numeric("V16"));
200 EXPECT_EQ(-1, SmallString<10>("V8_q0").compare_numeric("V16"));
201 EXPECT_EQ( 1, SmallString<10>("V16").compare_numeric("V8_q0"));
202 EXPECT_EQ(-1, SmallString<10>("V1_q0").compare_numeric("V8_q0"));
203 EXPECT_EQ( 1, SmallString<10>("V8_q0").compare_numeric("V1_q0"));
209 EXPECT_EQ(R"("foo")", ::testing::PrintToString(SmallString<1>("foo")));
211 EXPECT_EQ(R"("foo")", ::testing::PrintToString(ErasedSmallString));
unittests/ADT/SmallVectorTest.cpp 163 EXPECT_EQ(0u, v.size());
173 EXPECT_EQ(size, v.size());
179 EXPECT_EQ(value, v[i].getValue());
232 EXPECT_EQ(0, Constructable::getNumConstructorCalls());
233 EXPECT_EQ(0, Constructable::getNumDestructorCalls());
272 EXPECT_EQ(5, Constructable::getNumConstructorCalls());
273 EXPECT_EQ(5, Constructable::getNumDestructorCalls());
278 EXPECT_EQ(Constructable::getNumConstructorCalls(),
292 EXPECT_EQ(4, Constructable::getNumConstructorCalls());
293 EXPECT_EQ(4, Constructable::getNumDestructorCalls());
305 EXPECT_EQ(6, Constructable::getNumConstructorCalls());
306 EXPECT_EQ(5, Constructable::getNumDestructorCalls());
315 EXPECT_EQ(2, Constructable::getNumConstructorCalls());
316 EXPECT_EQ(0, Constructable::getNumDestructorCalls());
317 EXPECT_EQ(2u, this->theVector.size());
351 EXPECT_EQ(10u, this->theVector.size());
353 EXPECT_EQ(i+1, this->theVector[i].getValue());
370 EXPECT_EQ(1, it->getValue());
374 EXPECT_EQ(2, it->getValue());
379 EXPECT_EQ(2, it->getValue());
382 EXPECT_EQ(1, it->getValue());
387 EXPECT_EQ(2, rit->getValue());
390 EXPECT_EQ(1, rit->getValue());
395 EXPECT_EQ(1, rit->getValue());
398 EXPECT_EQ(2, rit->getValue());
509 EXPECT_EQ(Constructable::getNumConstructorCalls()-2,
514 EXPECT_EQ(Constructable::getNumConstructorCalls(),
545 EXPECT_EQ(this->theVector.begin() + 1, I);
557 EXPECT_EQ(this->theVector.begin() + 1, I);
577 EXPECT_EQ(1, Constructable::getNumMoveAssignmentCalls());
579 EXPECT_EQ(2, Constructable::getNumCopyAssignmentCalls());
581 EXPECT_EQ(0, Constructable::getNumCopyConstructorCalls());
582 EXPECT_EQ(this->theVector.begin() + 1, I);
592 EXPECT_EQ(this->theVector.begin() + 1, I);
603 EXPECT_EQ(2, Constructable::getNumCopyConstructorCalls());
608 EXPECT_EQ(0, Constructable::getNumCopyAssignmentCalls());
609 EXPECT_EQ(0, Constructable::getNumMoveAssignmentCalls());
611 EXPECT_EQ(this->theVector.begin() + 4, I);
621 EXPECT_EQ(this->theVector.end(),
624 EXPECT_EQ(this->theVector.begin() + 1,
647 EXPECT_EQ(2, Constructable::getNumCopyAssignmentCalls());
649 EXPECT_EQ(1, Constructable::getNumCopyConstructorCalls());
650 EXPECT_EQ(this->theVector.begin() + 1, I);
667 EXPECT_EQ(3, Constructable::getNumCopyConstructorCalls());
669 EXPECT_EQ(0, Constructable::getNumCopyAssignmentCalls());
674 EXPECT_EQ(0, Constructable::getNumMoveAssignmentCalls());
675 EXPECT_EQ(this->theVector.begin() + 3, I);
686 EXPECT_EQ(this->theVector.end(),
690 EXPECT_EQ(this->theVector.begin() + 1,
717 EXPECT_EQ(0u, constVector.size());
724 EXPECT_EQ(0u, this->theVector.size());
727 EXPECT_EQ(0, Constructable::getNumConstructorCalls());
732 EXPECT_EQ(4u, this->theVector.size());
733 EXPECT_EQ(8, Constructable::getNumConstructorCalls());
734 EXPECT_EQ(1, this->theVector[0].getValue());
735 EXPECT_EQ(2, this->theVector[1].getValue());
736 EXPECT_EQ(3, this->theVector[2].getValue());
737 EXPECT_EQ(4, this->theVector[3].getValue());
789 EXPECT_EQ(Constructable::getNumConstructorCalls()-4,
799 EXPECT_EQ(Constructable::getNumConstructorCalls(),
803 EXPECT_EQ(Constructable::getNumCopyConstructorCalls(), 0);
816 EXPECT_EQ(42, vec.pop_back_val().x);
979 EXPECT_EQ(2U, V.size());
980 EXPECT_EQ(0, V[0]);
981 EXPECT_EQ(42, V[1]);
unittests/ADT/SparseBitVectorTest.cpp 18 EXPECT_EQ(0U, Vec.count());
153 EXPECT_EQ(1, Vec.find_first());
154 EXPECT_EQ(1, Vec.find_last());
157 EXPECT_EQ(1, Vec.find_first());
158 EXPECT_EQ(2, Vec.find_last());
162 EXPECT_EQ(0, Vec.find_first());
163 EXPECT_EQ(3, Vec.find_last());
168 EXPECT_EQ(2, Vec.find_first());
169 EXPECT_EQ(2, Vec.find_last());
178 EXPECT_EQ(500, Vec.find_first());
179 EXPECT_EQ(4000, Vec.find_last());
184 EXPECT_EQ(2000, Vec.find_first());
185 EXPECT_EQ(2000, Vec.find_last());
unittests/ADT/SparseMultiSetTest.cpp 22 EXPECT_EQ(0u, Set.size());
33 EXPECT_EQ(0u, CSet.size());
48 EXPECT_EQ(1u, Set.size());
66 EXPECT_EQ(2u, Set.size());
67 EXPECT_EQ(5u, *Set.find(5));
91 EXPECT_EQ(7u, Set.size());
95 EXPECT_EQ(6u, Set.size());
100 EXPECT_EQ(3u, Set.count(5));
103 EXPECT_EQ(5u, Set.size());
104 EXPECT_EQ(2u, Set.count(5));
108 EXPECT_EQ(7u, Set.size());
114 EXPECT_EQ(6u, Set.size());
117 EXPECT_EQ(2u, Set.count(5));
122 EXPECT_EQ(1u, Set.count(5));
123 EXPECT_EQ(5u, *I);
126 EXPECT_EQ(0u, Set.count(5));
135 EXPECT_EQ(5, std::distance(Set.getHead(8), Set.end()));
137 EXPECT_EQ(0, std::distance(Set.getHead(8), Set.end()));
141 EXPECT_EQ(0u, Set.size());
153 EXPECT_EQ(1u, Set.count(i));
157 EXPECT_EQ(700u, Set.size());
177 EXPECT_EQ(3, std::distance(B, E));
178 EXPECT_EQ(B, --(--(--E)));
179 EXPECT_EQ(++(++(++E)), Set.end());
180 EXPECT_EQ(B, --(--(--E)));
181 EXPECT_EQ(++(++(++E)), Set.end());
185 EXPECT_EQ(B, --(--(--(--E))));
186 EXPECT_EQ(++(++(++(++E))), Set.end());
187 EXPECT_EQ(B, --(--(--(--E))));
188 EXPECT_EQ(++(++(++(++E))), Set.end());
192 EXPECT_EQ(Erased, E);
193 EXPECT_EQ(B, --(--(--E)));
201 EXPECT_EQ(Set2.getHead(3), Set2.getTail(3));
202 EXPECT_EQ(Set2.getHead(0), Set2.getTail(0));
204 EXPECT_EQ(Set2.find(3), --(++B));
221 EXPECT_EQ(1005u, I->Value);
227 EXPECT_EQ(1006u, I->Value);
unittests/ADT/SparseSetTest.cpp 23 EXPECT_EQ(0u, Set.size());
35 EXPECT_EQ(0u, CSet.size());
52 EXPECT_EQ(1u, Set.size());
67 EXPECT_EQ(1u, Set.size());
68 EXPECT_EQ(5u, *Set.begin());
88 EXPECT_EQ(5u, Set.size());
92 EXPECT_EQ(5u, *I);
94 EXPECT_EQ(3u, *I);
96 EXPECT_EQ(2u, *I);
98 EXPECT_EQ(1u, *I);
100 EXPECT_EQ(4u, *I);
111 EXPECT_EQ(4u, Set.size());
114 EXPECT_EQ(4u, Set.size());
121 EXPECT_EQ(3u, Set.size());
124 EXPECT_EQ(3u, Set.size());
129 EXPECT_EQ(5u, Set.size());
134 EXPECT_EQ(4u, Set.size());
157 EXPECT_EQ(700u, Set.size());
174 EXPECT_EQ(1005u, I->Value);
180 EXPECT_EQ(1006u, I->Value);
unittests/ADT/StatisticTest.cpp 39 EXPECT_EQ(Counter, 0u);
43 EXPECT_EQ(Counter, 2u);
49 EXPECT_EQ(AlwaysCounter, 0u);
52 EXPECT_EQ(AlwaysCounter, 2u);
60 EXPECT_EQ(Counter, 2u);
66 EXPECT_EQ(AlwaysCounter, 2u);
75 EXPECT_EQ(Counter, 0u);
79 EXPECT_EQ(Counter, 2u);
88 EXPECT_EQ(Range1.begin() + 1, Range1.end());
94 EXPECT_EQ(S1.hasValue(), true);
95 EXPECT_EQ(S2.hasValue(), false);
104 EXPECT_EQ(Range.begin() + 2, Range.end());
110 EXPECT_EQ(S1.hasValue(), true);
111 EXPECT_EQ(S2.hasValue(), true);
113 EXPECT_EQ(S1->first, "Counter");
114 EXPECT_EQ(S1->second, 2u);
116 EXPECT_EQ(S2->first, "Counter2");
117 EXPECT_EQ(S2->second, 1u);
131 EXPECT_EQ(Range.begin(), Range.end());
132 EXPECT_EQ(Counter, 0u);
133 EXPECT_EQ(Counter2, 0u);
137 EXPECT_EQ(S1.hasValue(), false);
138 EXPECT_EQ(S2.hasValue(), false);
147 EXPECT_EQ(Range.begin() + 2, Range.end());
148 EXPECT_EQ(Counter, 1u);
149 EXPECT_EQ(Counter2, 1u);
155 EXPECT_EQ(S1.hasValue(), true);
156 EXPECT_EQ(S2.hasValue(), true);
158 EXPECT_EQ(S1->first, "Counter");
159 EXPECT_EQ(S1->second, 1u);
161 EXPECT_EQ(S2->first, "Counter2");
162 EXPECT_EQ(S2->second, 1u);
unittests/ADT/StringExtrasTest.cpp 28 EXPECT_EQ("", join(Items.begin(), Items.end(), " <sep> "));
31 EXPECT_EQ("foo", join(Items.begin(), Items.end(), " <sep> "));
34 EXPECT_EQ("foo <sep> bar", join(Items.begin(), Items.end(), " <sep> "));
37 EXPECT_EQ("foo <sep> bar <sep> baz",
47 EXPECT_EQ("", join_items(" <sep> "));
48 EXPECT_EQ("", join_items('/'));
50 EXPECT_EQ("foo", join_items(" <sep> ", Foo));
51 EXPECT_EQ("foo", join_items('/', Foo));
53 EXPECT_EQ("foo <sep> bar", join_items(" <sep> ", Foo, Bar));
54 EXPECT_EQ("foo/bar", join_items('/', Foo, Bar));
56 EXPECT_EQ("foo <sep> bar <sep> baz", join_items(" <sep> ", Foo, Bar, Baz));
57 EXPECT_EQ("foo/bar/baz", join_items('/', Foo, Bar, Baz));
59 EXPECT_EQ("foo <sep> bar <sep> baz <sep> x",
62 EXPECT_EQ("foo/bar/baz/x", join_items('/', Foo, Bar, Baz, X));
70 EXPECT_EQ(OddStr, toHex(OddData));
71 EXPECT_EQ(OddData, fromHex(StringRef(OddStr).drop_front()));
72 EXPECT_EQ(StringRef(OddStr).lower(), toHex(OddData, true));
78 EXPECT_EQ(EvenStr, toHex(EvenData));
79 EXPECT_EQ(EvenData, fromHex(EvenStr));
80 EXPECT_EQ(StringRef(EvenStr).lower(), toHex(EvenData, true));
105 EXPECT_EQ("abcdefg01234.,&!~`'}\"", OS.str());
112 EXPECT_EQ("ABCdef123&<>\\\\\\22'\\09", OS.str());
119 EXPECT_EQ("ABCdef123&<>"'", OS.str());
unittests/ADT/StringMapTest.cpp 32 EXPECT_EQ(0u, testMap.size());
39 EXPECT_EQ(0u, testMap.count(testKey));
40 EXPECT_EQ(0u, testMap.count(StringRef(testKeyFirst, testKeyLength)));
41 EXPECT_EQ(0u, testMap.count(testKeyStr));
50 EXPECT_EQ(1u, testMap.size());
57 EXPECT_EQ(testValue, it->second);
62 EXPECT_EQ(1u, testMap.count(testKey));
63 EXPECT_EQ(1u, testMap.count(StringRef(testKeyFirst, testKeyLength)));
64 EXPECT_EQ(1u, testMap.count(testKeyStr));
98 EXPECT_EQ(0u, constTestMap.size());
105 EXPECT_EQ(0u, constTestMap.count(testKey));
106 EXPECT_EQ(0u, constTestMap.count(StringRef(testKeyFirst, testKeyLength)));
107 EXPECT_EQ(0u, constTestMap.count(testKeyStr));
163 EXPECT_EQ(3u, Map.size());
164 EXPECT_EQ(0, Map.lookup("eins"));
165 EXPECT_EQ(2, Map.lookup("zwei"));
166 EXPECT_EQ(0, Map.lookup("drei"));
167 EXPECT_EQ(4, Map.lookup("veir"));
168 EXPECT_EQ(5, Map.lookup("funf"));
182 EXPECT_EQ(3u, Map.size());
183 EXPECT_EQ(0, Map.lookup("eins"));
184 EXPECT_EQ(2, Map.lookup("zwei"));
185 EXPECT_EQ(0, Map.lookup("drei"));
186 EXPECT_EQ(4, Map.lookup("veir"));
187 EXPECT_EQ(5, Map.lookup("funf"));
190 EXPECT_EQ(3u, Map2.size());
191 EXPECT_EQ(0, Map2.lookup("eins"));
192 EXPECT_EQ(2, Map2.lookup("zwei"));
193 EXPECT_EQ(0, Map2.lookup("drei"));
194 EXPECT_EQ(4, Map2.lookup("veir"));
195 EXPECT_EQ(5, Map2.lookup("funf"));
231 EXPECT_EQ(1u, entry->second);
251 EXPECT_EQ(1u, testMap.size());
252 EXPECT_EQ(testValue, testMap[testKeyFirst]);
253 EXPECT_EQ(testKeyFirst, NewIt->first());
254 EXPECT_EQ(testValue, NewIt->second);
260 EXPECT_EQ(1u, testMap.size());
261 EXPECT_EQ(testValue, testMap[testKeyFirst]);
263 EXPECT_EQ(NewIt, ExistingIt);
273 EXPECT_EQ(0u, t.getNumBuckets());
277 EXPECT_EQ(16u, t.getNumBuckets());
278 EXPECT_EQ("abcdef", It->first());
279 EXPECT_EQ(42u, It->second);
291 EXPECT_EQ(1, try1.first->second.v);
292 EXPECT_EQ(1, try1.first->second.move);
296 EXPECT_EQ(2, try2.first->second.v);
297 EXPECT_EQ(2, try1.first->second.move);
299 EXPECT_EQ(try1.first, try2.first);
300 EXPECT_EQ(0, try1.first->second.copy);
314 EXPECT_EQ(Expected, Keys);
474 EXPECT_EQ((unsigned)Size * 2, CountCtorCopyAndMove::Move);
476 EXPECT_EQ(0u, CountCtorCopyAndMove::Copy);
478 EXPECT_EQ(Map.getNumBuckets(), NumBuckets);
486 EXPECT_EQ(1u, CountCtorCopyAndMove::Ctor);
490 EXPECT_EQ(0u, CountCtorCopyAndMove::Ctor);
507 EXPECT_EQ(1u, Map.count("abcd"));
508 EXPECT_EQ(42, Map["abcd"].Data);
521 EXPECT_EQ(LargeValue, LargeBase.getKeyLength());
527 EXPECT_EQ(LargeValue, LargerBase.getKeyLength());
541 EXPECT_EQ(LargeValue, Key.size());
547 EXPECT_EQ(LargeValue, Key.size());
unittests/ADT/StringRefTest.cpp 58 EXPECT_EQ("", StringRef());
59 EXPECT_EQ("hello", StringRef("hello"));
60 EXPECT_EQ("hello", StringRef("hello world", 5));
61 EXPECT_EQ("hello", StringRef(std::string("hello")));
76 EXPECT_EQ(*it, *p);
81 EXPECT_EQ(p, StringRef(p, 0).data());
83 EXPECT_EQ((size_t) 5, StringRef("hello").size());
84 EXPECT_EQ(-1, StringRef("aab").compare("aad"));
85 EXPECT_EQ( 0, StringRef("aab").compare("aab"));
86 EXPECT_EQ( 1, StringRef("aab").compare("aaa"));
87 EXPECT_EQ(-1, StringRef("aab").compare("aabb"));
88 EXPECT_EQ( 1, StringRef("aab").compare("aa"));
89 EXPECT_EQ( 1, StringRef("\xFF").compare("\1"));
91 EXPECT_EQ(-1, StringRef("AaB").compare_lower("aAd"));
92 EXPECT_EQ( 0, StringRef("AaB").compare_lower("aab"));
93 EXPECT_EQ( 1, StringRef("AaB").compare_lower("AAA"));
94 EXPECT_EQ(-1, StringRef("AaB").compare_lower("aaBb"));
95 EXPECT_EQ(-1, StringRef("AaB").compare_lower("bb"));
96 EXPECT_EQ( 1, StringRef("aaBb").compare_lower("AaB"));
97 EXPECT_EQ( 1, StringRef("bb").compare_lower("AaB"));
98 EXPECT_EQ( 1, StringRef("AaB").compare_lower("aA"));
99 EXPECT_EQ( 1, StringRef("\xFF").compare_lower("\1"));
101 EXPECT_EQ(-1, StringRef("aab").compare_numeric("aad"));
102 EXPECT_EQ( 0, StringRef("aab").compare_numeric("aab"));
103 EXPECT_EQ( 1, StringRef("aab").compare_numeric("aaa"));
104 EXPECT_EQ(-1, StringRef("aab").compare_numeric("aabb"));
105 EXPECT_EQ( 1, StringRef("aab").compare_numeric("aa"));
106 EXPECT_EQ(-1, StringRef("1").compare_numeric("10"));
107 EXPECT_EQ( 0, StringRef("10").compare_numeric("10"));
108 EXPECT_EQ( 0, StringRef("10a").compare_numeric("10a"));
109 EXPECT_EQ( 1, StringRef("2").compare_numeric("1"));
110 EXPECT_EQ( 0, StringRef("llvm_v1i64_ty").compare_numeric("llvm_v1i64_ty"));
111 EXPECT_EQ( 1, StringRef("\xFF").compare_numeric("\1"));
112 EXPECT_EQ( 1, StringRef("V16").compare_numeric("V1_q0"));
113 EXPECT_EQ(-1, StringRef("V1_q0").compare_numeric("V16"));
114 EXPECT_EQ(-1, StringRef("V8_q0").compare_numeric("V16"));
115 EXPECT_EQ( 1, StringRef("V16").compare_numeric("V8_q0"));
116 EXPECT_EQ(-1, StringRef("V1_q0").compare_numeric("V8_q0"));
117 EXPECT_EQ( 1, StringRef("V8_q0").compare_numeric("V1_q0"));
121 EXPECT_EQ("", StringRef());
130 EXPECT_EQ(StringRef("aab"), StringRef("aab"));
134 EXPECT_EQ('a', StringRef("aab")[1]);
139 EXPECT_EQ("lo", Str.substr(3));
140 EXPECT_EQ("", Str.substr(100));
141 EXPECT_EQ("hello", Str.substr(0, 100));
142 EXPECT_EQ("o", Str.substr(4, 10));
147 EXPECT_EQ("l", Str.slice(2, 3));
148 EXPECT_EQ("ell", Str.slice(1, 4));
149 EXPECT_EQ("llo", Str.slice(2, 100));
150 EXPECT_EQ("", Str.slice(2, 1));
151 EXPECT_EQ("", Str.slice(10, 20));
156 EXPECT_EQ(std::make_pair(StringRef("hello"), StringRef("")),
158 EXPECT_EQ(std::make_pair(StringRef("h"), StringRef("llo")),
160 EXPECT_EQ(std::make_pair(StringRef(""), StringRef("ello")),
162 EXPECT_EQ(std::make_pair(StringRef("he"), StringRef("lo")),
164 EXPECT_EQ(std::make_pair(StringRef("hell"), StringRef("")),
167 EXPECT_EQ(std::make_pair(StringRef("hello"), StringRef("")),
169 EXPECT_EQ(std::make_pair(StringRef("h"), StringRef("llo")),
171 EXPECT_EQ(std::make_pair(StringRef(""), StringRef("ello")),
173 EXPECT_EQ(std::make_pair(StringRef("hel"), StringRef("o")),
175 EXPECT_EQ(std::make_pair(StringRef("hell"), StringRef("")),
178 EXPECT_EQ(std::make_pair(StringRef("he"), StringRef("o")),
180 EXPECT_EQ(std::make_pair(StringRef(""), StringRef("ello")),
182 EXPECT_EQ(std::make_pair(StringRef("hell"), StringRef("")),
184 EXPECT_EQ(std::make_pair(StringRef("hello"), StringRef("")),
186 EXPECT_EQ(std::make_pair(StringRef("hel"), StringRef("o")),
328 EXPECT_EQ(StringRef("hello"), Str0.rtrim());
329 EXPECT_EQ(StringRef(" hello"), Str1.rtrim());
330 EXPECT_EQ(StringRef(" hello"), Str2.rtrim());
331 EXPECT_EQ(StringRef("hello"), Str0.ltrim());
332 EXPECT_EQ(StringRef("hello "), Str1.ltrim());
333 EXPECT_EQ(StringRef("hello "), Str2.ltrim());
334 EXPECT_EQ(StringRef("hello"), Str0.trim());
335 EXPECT_EQ(StringRef("hello"), Str1.trim());
336 EXPECT_EQ(StringRef("hello"), Str2.trim());
338 EXPECT_EQ(StringRef("ello"), Str0.trim("hhhhhhhhhhh"));
340 EXPECT_EQ(StringRef(""), StringRef("").trim());
341 EXPECT_EQ(StringRef(""), StringRef(" ").trim());
342 EXPECT_EQ(StringRef("\0", 1), StringRef(" \0 ", 3).trim());
343 EXPECT_EQ(StringRef("\0\0", 2), StringRef("\0\0", 2).trim());
344 EXPECT_EQ(StringRef("x"), StringRef("\0\0x\0\0", 5).trim('\0'));
368 EXPECT_EQ("hello", Str);
370 EXPECT_EQ("llo", Str);
372 EXPECT_EQ("llo", Str);
374 EXPECT_EQ("llo", Str);
376 EXPECT_EQ("", Str);
403 EXPECT_EQ("hello", Str);
405 EXPECT_EQ("hel", Str);
407 EXPECT_EQ("hel", Str);
409 EXPECT_EQ("hel", Str);
411 EXPECT_EQ("", Str);
459 EXPECT_EQ(E.Pos, E.Str.find(E.C, E.From));
460 EXPECT_EQ(E.LowerPos, E.Str.find_lower(E.C, E.From));
461 EXPECT_EQ(E.LowerPos, E.Str.find_lower(toupper(E.C), E.From));
465 EXPECT_EQ(E.Pos, E.Str.find(E.S, E.From));
466 EXPECT_EQ(E.LowerPos, E.Str.find_lower(E.S, E.From));
467 EXPECT_EQ(E.LowerPos, E.Str.find_lower(E.S.upper(), E.From));
470 EXPECT_EQ(3U, Str.rfind('l'));
471 EXPECT_EQ(StringRef::npos, Str.rfind('z'));
472 EXPECT_EQ(StringRef::npos, Str.rfind("helloworld"));
473 EXPECT_EQ(0U, Str.rfind("hello"));
474 EXPECT_EQ(1U, Str.rfind("ello"));
475 EXPECT_EQ(StringRef::npos, Str.rfind("zz"));
477 EXPECT_EQ(8U, Str.rfind_lower('l'));
478 EXPECT_EQ(8U, Str.rfind_lower('L'));
479 EXPECT_EQ(StringRef::npos, Str.rfind_lower('z'));
480 EXPECT_EQ(StringRef::npos, Str.rfind_lower("HELLOWORLD"));
481 EXPECT_EQ(5U, Str.rfind("HELLO"));
482 EXPECT_EQ(6U, Str.rfind("ELLO"));
483 EXPECT_EQ(StringRef::npos, Str.rfind("ZZ"));
485 EXPECT_EQ(2U, Str.find_first_of('l'));
486 EXPECT_EQ(1U, Str.find_first_of("el"));
487 EXPECT_EQ(StringRef::npos, Str.find_first_of("xyz"));
490 EXPECT_EQ(1U, Str.find_first_not_of('h'));
491 EXPECT_EQ(4U, Str.find_first_not_of("hel"));
492 EXPECT_EQ(StringRef::npos, Str.find_first_not_of("hello"));
494 EXPECT_EQ(3U, Str.find_last_not_of('o'));
495 EXPECT_EQ(1U, Str.find_last_not_of("lo"));
496 EXPECT_EQ(StringRef::npos, Str.find_last_not_of("helo"));
501 EXPECT_EQ(2U, Str.count('l'));
502 EXPECT_EQ(1U, Str.count('o'));
503 EXPECT_EQ(0U, Str.count('z'));
504 EXPECT_EQ(0U, Str.count("helloworld"));
505 EXPECT_EQ(1U, Str.count("hello"));
506 EXPECT_EQ(1U, Str.count("ello"));
507 EXPECT_EQ(0U, Str.count("zz"));
512 EXPECT_EQ(2U, Hello.edit_distance("hill"));
515 EXPECT_EQ(6U, Industry.edit_distance("interest"));
518 EXPECT_EQ(19U, Soylent.edit_distance("people soiled our green"));
519 EXPECT_EQ(26U, Soylent.edit_distance("people soiled our green",
521 EXPECT_EQ(9U, Soylent.edit_distance("people soiled our green",
524 EXPECT_EQ(53U, Soylent.edit_distance("people soiled our green "
533 EXPECT_EQ("hello", OS.str());
537 EXPECT_EQ(hash_value(std::string()), hash_value(StringRef()));
538 EXPECT_EQ(hash_value(std::string()), hash_value(StringRef("")));
541 EXPECT_EQ(H, hash_value(StringRef("hello world")));
542 EXPECT_EQ(H, hash_value(StringRef(S)));
544 EXPECT_EQ(hash_value(std::string("hello worl")),
547 EXPECT_EQ(hash_value(std::string("hello world ")),
549 EXPECT_EQ(H, hash_value(StringRef("hello world\0")));
608 EXPECT_EQ(U8, Unsigned[i].Expected);
615 EXPECT_EQ(U16, Unsigned[i].Expected);
622 EXPECT_EQ(U32, Unsigned[i].Expected);
629 EXPECT_EQ(U64, Unsigned[i].Expected);
644 EXPECT_EQ(S8, Signed[i].Expected);
651 EXPECT_EQ(S16, Signed[i].Expected);
658 EXPECT_EQ(S32, Signed[i].Expected);
665 EXPECT_EQ(S64, Signed[i].Expected);
779 EXPECT_EQ(U8, ConsumeUnsigned[i].Expected);
780 EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover);
790 EXPECT_EQ(U16, ConsumeUnsigned[i].Expected);
791 EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover);
801 EXPECT_EQ(U32, ConsumeUnsigned[i].Expected);
802 EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover);
812 EXPECT_EQ(U64, ConsumeUnsigned[i].Expected);
813 EXPECT_EQ(Str, ConsumeUnsigned[i].Leftover);
832 EXPECT_EQ(S8, ConsumeSigned[i].Expected);
833 EXPECT_EQ(Str, ConsumeSigned[i].Leftover);
843 EXPECT_EQ(S16, ConsumeSigned[i].Expected);
844 EXPECT_EQ(Str, ConsumeSigned[i].Leftover);
854 EXPECT_EQ(S32, ConsumeSigned[i].Expected);
855 EXPECT_EQ(Str, ConsumeSigned[i].Leftover);
865 EXPECT_EQ(S64, ConsumeSigned[i].Expected);
866 EXPECT_EQ(Str, ConsumeSigned[i].Leftover);
893 EXPECT_EQ(Entry.ShouldFail, S.getAsDouble(Result, Entry.AllowInexact));
895 EXPECT_EQ(Result, Entry.D);
938 EXPECT_EQ(StrEmptyc.data(), nullptr);
939 EXPECT_EQ(StrEmptyc.size(), 0u);
940 EXPECT_EQ(Alloc.getTotalMemory(), 0u);
956 EXPECT_EQ(Dropped, "gRefTest::Drop");
959 EXPECT_EQ(Dropped, "StringRefTest:");
962 EXPECT_EQ(Dropped, Test);
965 EXPECT_EQ(Dropped, Test);
978 EXPECT_EQ(Taken, "Strin");
981 EXPECT_EQ(Taken, ":Take");
984 EXPECT_EQ(Taken, Test);
987 EXPECT_EQ(Taken, Test);
1003 EXPECT_EQ(4U, Punct.find_if(IsPunct));
1004 EXPECT_EQ(StringRef::npos, NoPunct.find_if(IsPunct));
1005 EXPECT_EQ(StringRef::npos, Empty.find_if(IsPunct));
1007 EXPECT_EQ(4U, Punct.find_if_not(IsAlpha));
1008 EXPECT_EQ(StringRef::npos, NoPunct.find_if_not(IsAlpha));
1009 EXPECT_EQ(StringRef::npos, Empty.find_if_not(IsAlpha));
1016 EXPECT_EQ("", Taken);
1019 EXPECT_EQ("String With ", Taken);
1022 EXPECT_EQ(Test, Taken);
1025 EXPECT_EQ("", Taken);
1029 EXPECT_EQ("", Taken);
1036 EXPECT_EQ(Test, Taken);
1039 EXPECT_EQ("1 Number", Taken);
1042 EXPECT_EQ("", Taken);
1045 EXPECT_EQ(Test, Taken);
1049 EXPECT_EQ("", Taken);
1054 EXPECT_EQ(StringRef("Foo"), StringRefs[0]);
1055 EXPECT_EQ(StringRef("Bar"), StringRefs[1]);
1058 EXPECT_EQ(StringRef("Foo"), Strings[0]);
1059 EXPECT_EQ(StringRef("Bar"), Strings[1]);
1065 EXPECT_EQ(R"("foo")", ::testing::PrintToString(StringRef("foo")));
unittests/ADT/StringSetTest.cpp 29 EXPECT_EQ(Expected, Keys);
40 EXPECT_EQ(Expected, Count);
unittests/ADT/StringSwitchTest.cpp 35 EXPECT_EQ(1, Translate("1"));
36 EXPECT_EQ(2, Translate("2"));
37 EXPECT_EQ(11, Translate("B"));
38 EXPECT_EQ(-1, Translate("b"));
39 EXPECT_EQ(-1, Translate(""));
40 EXPECT_EQ(-1, Translate("Test"));
64 EXPECT_EQ(1, Translate("1"));
65 EXPECT_EQ(2, Translate("2"));
66 EXPECT_EQ(11, Translate("B"));
67 EXPECT_EQ(11, Translate("b"));
69 EXPECT_EQ(-1, Translate(""));
70 EXPECT_EQ(-1, Translate("Test"));
83 EXPECT_EQ(15, Translate("adder")(10, 5));
84 EXPECT_EQ(5, Translate("subtracter")(10, 5));
85 EXPECT_EQ(50, Translate("multiplier")(10, 5));
86 EXPECT_EQ(2, Translate("divider")(10, 5));
88 EXPECT_EQ(0, Translate("nothing")(10, 5));
89 EXPECT_EQ(0, Translate("ADDER")(10, 5));
102 EXPECT_EQ(15, Translate("adder")(10, 5));
103 EXPECT_EQ(5, Translate("subtracter")(10, 5));
104 EXPECT_EQ(50, Translate("multiplier")(10, 5));
105 EXPECT_EQ(2, Translate("divider")(10, 5));
107 EXPECT_EQ(15, Translate("AdDeR")(10, 5));
108 EXPECT_EQ(5, Translate("SuBtRaCtEr")(10, 5));
109 EXPECT_EQ(50, Translate("MuLtIpLiEr")(10, 5));
110 EXPECT_EQ(2, Translate("DiViDeR")(10, 5));
112 EXPECT_EQ(0, Translate("nothing")(10, 5));
127 EXPECT_EQ(Suffix::Possible, Translate("optimizable"));
128 EXPECT_EQ(Suffix::PastTense, Translate("optimized"));
129 EXPECT_EQ(Suffix::Process, Translate("optimization"));
130 EXPECT_EQ(Suffix::InProgressAction, Translate("optimizing"));
131 EXPECT_EQ(Suffix::Unknown, Translate("optimizer"));
132 EXPECT_EQ(Suffix::Unknown, Translate("OPTIMIZABLE"));
147 EXPECT_EQ(Suffix::Possible, Translate("optimizable"));
148 EXPECT_EQ(Suffix::Possible, Translate("OPTIMIZABLE"));
149 EXPECT_EQ(Suffix::PastTense, Translate("optimized"));
150 EXPECT_EQ(Suffix::Process, Translate("optimization"));
151 EXPECT_EQ(Suffix::InProgressAction, Translate("optimizing"));
152 EXPECT_EQ(Suffix::Unknown, Translate("optimizer"));
166 EXPECT_EQ(OSType::Windows, Translate(llvm::StringRef("wind\0ws", 7)));
167 EXPECT_EQ(OSType::Windows, Translate("win32"));
168 EXPECT_EQ(OSType::Windows, Translate("winnt"));
170 EXPECT_EQ(OSType::Linux, Translate("linux"));
171 EXPECT_EQ(OSType::Linux, Translate("unix"));
172 EXPECT_EQ(OSType::Linux, Translate("*nix"));
173 EXPECT_EQ(OSType::Linux, Translate("posix"));
177 EXPECT_EQ(OSType::Unknown, Translate("wind"));
178 EXPECT_EQ(OSType::Unknown, Translate("Windows"));
179 EXPECT_EQ(OSType::Unknown, Translate(""));
193 EXPECT_EQ(OSType::Windows, Translate(llvm::StringRef("WIND\0WS", 7)));
194 EXPECT_EQ(OSType::Windows, Translate("WIN32"));
195 EXPECT_EQ(OSType::Windows, Translate("WINNT"));
197 EXPECT_EQ(OSType::Linux, Translate("LINUX"));
198 EXPECT_EQ(OSType::Linux, Translate("UNIX"));
199 EXPECT_EQ(OSType::Linux, Translate("*NIX"));
200 EXPECT_EQ(OSType::Linux, Translate("POSIX"));
202 EXPECT_EQ(OSType::Windows, Translate(llvm::StringRef("wind\0ws", 7)));
203 EXPECT_EQ(OSType::Linux, Translate("linux"));
205 EXPECT_EQ(OSType::Unknown, Translate("wind"));
206 EXPECT_EQ(OSType::Unknown, Translate(""));
unittests/ADT/TinyPtrVectorTest.cpp 73 EXPECT_EQ(Values.empty(), V.empty());
74 EXPECT_EQ(Values.size(), V.size());
76 EXPECT_EQ(Values[i], V[i]);
77 EXPECT_EQ(Values[i], *std::next(V.begin(), i));
79 EXPECT_EQ(V.end(), std::next(V.begin(), Values.size()));
unittests/ADT/TripleTest.cpp 20 EXPECT_EQ("", T.getArchName().str());
21 EXPECT_EQ("", T.getVendorName().str());
22 EXPECT_EQ("", T.getOSName().str());
23 EXPECT_EQ("", T.getEnvironmentName().str());
26 EXPECT_EQ("", T.getArchName().str());
27 EXPECT_EQ("", T.getVendorName().str());
28 EXPECT_EQ("", T.getOSName().str());
29 EXPECT_EQ("", T.getEnvironmentName().str());
32 EXPECT_EQ("", T.getArchName().str());
33 EXPECT_EQ("", T.getVendorName().str());
34 EXPECT_EQ("", T.getOSName().str());
35 EXPECT_EQ("", T.getEnvironmentName().str());
38 EXPECT_EQ("", T.getArchName().str());
39 EXPECT_EQ("", T.getVendorName().str());
40 EXPECT_EQ("", T.getOSName().str());
41 EXPECT_EQ("", T.getEnvironmentName().str());
44 EXPECT_EQ("", T.getArchName().str());
45 EXPECT_EQ("", T.getVendorName().str());
46 EXPECT_EQ("", T.getOSName().str());
47 EXPECT_EQ("-", T.getEnvironmentName().str());
50 EXPECT_EQ("a", T.getArchName().str());
51 EXPECT_EQ("", T.getVendorName().str());
52 EXPECT_EQ("", T.getOSName().str());
53 EXPECT_EQ("", T.getEnvironmentName().str());
56 EXPECT_EQ("a", T.getArchName().str());
57 EXPECT_EQ("b", T.getVendorName().str());
58 EXPECT_EQ("", T.getOSName().str());
59 EXPECT_EQ("", T.getEnvironmentName().str());
62 EXPECT_EQ("a", T.getArchName().str());
63 EXPECT_EQ("b", T.getVendorName().str());
64 EXPECT_EQ("c", T.getOSName().str());
65 EXPECT_EQ("", T.getEnvironmentName().str());
68 EXPECT_EQ("a", T.getArchName().str());
69 EXPECT_EQ("b", T.getVendorName().str());
70 EXPECT_EQ("c", T.getOSName().str());
71 EXPECT_EQ("d", T.getEnvironmentName().str());
78 EXPECT_EQ(Triple::x86, T.getArch());
79 EXPECT_EQ(Triple::Apple, T.getVendor());
80 EXPECT_EQ(Triple::Darwin, T.getOS());
81 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
84 EXPECT_EQ(Triple::x86, T.getArch());
85 EXPECT_EQ(Triple::PC, T.getVendor());
86 EXPECT_EQ(Triple::ELFIAMCU, T.getOS());
87 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
90 EXPECT_EQ(Triple::x86, T.getArch());
91 EXPECT_EQ(Triple::PC, T.getVendor());
92 EXPECT_EQ(Triple::Contiki, T.getOS());
93 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
96 EXPECT_EQ(Triple::x86, T.getArch());
97 EXPECT_EQ(Triple::PC, T.getVendor());
98 EXPECT_EQ(Triple::Hurd, T.getOS());
99 EXPECT_EQ(Triple::GNU, T.getEnvironment());
102 EXPECT_EQ(Triple::x86_64, T.getArch());
103 EXPECT_EQ(Triple::PC, T.getVendor());
104 EXPECT_EQ(Triple::Linux, T.getOS());
105 EXPECT_EQ(Triple::GNU, T.getEnvironment());
108 EXPECT_EQ(Triple::x86_64, T.getArch());
109 EXPECT_EQ(Triple::PC, T.getVendor());
110 EXPECT_EQ(Triple::Linux, T.getOS());
111 EXPECT_EQ(Triple::Musl, T.getEnvironment());
114 EXPECT_EQ(Triple::ppc, T.getArch());
115 EXPECT_EQ(Triple::BGP, T.getVendor());
116 EXPECT_EQ(Triple::Linux, T.getOS());
117 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
120 EXPECT_EQ(Triple::ppc, T.getArch());
121 EXPECT_EQ(Triple::BGP, T.getVendor());
122 EXPECT_EQ(Triple::CNK, T.getOS());
123 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
126 EXPECT_EQ(Triple::ppc, T.getArch());
127 EXPECT_EQ(Triple::BGP, T.getVendor());
128 EXPECT_EQ(Triple::Linux, T.getOS());
129 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
132 EXPECT_EQ(Triple::ppc, T.getArch());
133 EXPECT_EQ(Triple::BGP, T.getVendor());
134 EXPECT_EQ(Triple::Linux, T.getOS());
135 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
138 EXPECT_EQ(Triple::ppc64, T.getArch());
139 EXPECT_EQ(Triple::BGQ, T.getVendor());
140 EXPECT_EQ(Triple::Linux, T.getOS());
141 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
144 EXPECT_EQ(Triple::ppc64, T.getArch());
145 EXPECT_EQ(Triple::BGQ, T.getVendor());
146 EXPECT_EQ(Triple::Linux, T.getOS());
149 EXPECT_EQ(Triple::ppc, T.getArch());
150 EXPECT_EQ(Triple::IBM, T.getVendor());
151 EXPECT_EQ(Triple::AIX, T.getOS());
152 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
155 EXPECT_EQ(Triple::ppc64, T.getArch());
156 EXPECT_EQ(Triple::IBM, T.getVendor());
157 EXPECT_EQ(Triple::AIX, T.getOS());
158 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
161 EXPECT_EQ(Triple::ppc, T.getArch());
162 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
163 EXPECT_EQ(Triple::UnknownOS, T.getOS());
164 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
167 EXPECT_EQ(Triple::arm, T.getArch());
168 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
169 EXPECT_EQ(Triple::UnknownOS, T.getOS());
170 EXPECT_EQ(Triple::EABI, T.getEnvironment());
173 EXPECT_EQ(Triple::arm, T.getArch());
174 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
175 EXPECT_EQ(Triple::Linux, T.getOS());
176 EXPECT_EQ(Triple::MuslEABI, T.getEnvironment());
179 EXPECT_EQ(Triple::arm, T.getArch());
180 EXPECT_EQ(Triple::Linux, T.getOS());
181 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
182 EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
185 EXPECT_EQ(Triple::arm, T.getArch());
186 EXPECT_EQ(Triple::Linux, T.getOS());
187 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
188 EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
191 EXPECT_EQ(Triple::amdil, T.getArch());
192 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
193 EXPECT_EQ(Triple::UnknownOS, T.getOS());
196 EXPECT_EQ(Triple::amdil64, T.getArch());
197 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
198 EXPECT_EQ(Triple::UnknownOS, T.getOS());
201 EXPECT_EQ(Triple::hsail, T.getArch());
202 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
203 EXPECT_EQ(Triple::UnknownOS, T.getOS());
206 EXPECT_EQ(Triple::hsail64, T.getArch());
207 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
208 EXPECT_EQ(Triple::UnknownOS, T.getOS());
211 EXPECT_EQ(Triple::sparcel, T.getArch());
212 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
213 EXPECT_EQ(Triple::UnknownOS, T.getOS());
216 EXPECT_EQ(Triple::spir, T.getArch());
217 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
218 EXPECT_EQ(Triple::UnknownOS, T.getOS());
221 EXPECT_EQ(Triple::spir64, T.getArch());
222 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
223 EXPECT_EQ(Triple::UnknownOS, T.getOS());
226 EXPECT_EQ(Triple::x86_64, T.getArch());
227 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
228 EXPECT_EQ(Triple::Ananas, T.getOS());
229 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
232 EXPECT_EQ(Triple::x86_64, T.getArch());
233 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
234 EXPECT_EQ(Triple::CloudABI, T.getOS());
235 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
238 EXPECT_EQ(Triple::x86_64, T.getArch());
239 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
240 EXPECT_EQ(Triple::Fuchsia, T.getOS());
241 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
244 EXPECT_EQ(Triple::x86_64, T.getArch());
245 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
246 EXPECT_EQ(Triple::HermitCore, T.getOS());
247 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
250 EXPECT_EQ(Triple::wasm32, T.getArch());
251 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
252 EXPECT_EQ(Triple::UnknownOS, T.getOS());
253 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
256 EXPECT_EQ(Triple::wasm32, T.getArch());
257 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
258 EXPECT_EQ(Triple::WASI, T.getOS());
259 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
262 EXPECT_EQ(Triple::wasm64, T.getArch());
263 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
264 EXPECT_EQ(Triple::UnknownOS, T.getOS());
265 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
268 EXPECT_EQ(Triple::wasm64, T.getArch());
269 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
270 EXPECT_EQ(Triple::WASI, T.getOS());
271 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
274 EXPECT_EQ(Triple::avr, T.getArch());
275 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
276 EXPECT_EQ(Triple::UnknownOS, T.getOS());
277 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
280 EXPECT_EQ(Triple::avr, T.getArch());
281 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
282 EXPECT_EQ(Triple::UnknownOS, T.getOS());
283 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
286 EXPECT_EQ(Triple::lanai, T.getArch());
287 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
288 EXPECT_EQ(Triple::UnknownOS, T.getOS());
289 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
292 EXPECT_EQ(Triple::lanai, T.getArch());
293 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
294 EXPECT_EQ(Triple::UnknownOS, T.getOS());
295 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
298 EXPECT_EQ(Triple::amdgcn, T.getArch());
299 EXPECT_EQ(Triple::Mesa, T.getVendor());
300 EXPECT_EQ(Triple::Mesa3D, T.getOS());
301 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
304 EXPECT_EQ(Triple::amdgcn, T.getArch());
305 EXPECT_EQ(Triple::AMD, T.getVendor());
306 EXPECT_EQ(Triple::AMDHSA, T.getOS());
307 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
310 EXPECT_EQ(Triple::amdgcn, T.getArch());
311 EXPECT_EQ(Triple::AMD, T.getVendor());
312 EXPECT_EQ(Triple::AMDPAL, T.getOS());
313 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
316 EXPECT_EQ(Triple::riscv32, T.getArch());
317 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
318 EXPECT_EQ(Triple::UnknownOS, T.getOS());
319 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
322 EXPECT_EQ(Triple::riscv64, T.getArch());
323 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
324 EXPECT_EQ(Triple::Linux, T.getOS());
325 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
328 EXPECT_EQ(Triple::riscv64, T.getArch());
329 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
330 EXPECT_EQ(Triple::FreeBSD, T.getOS());
331 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
334 EXPECT_EQ(Triple::riscv64, T.getArch());
335 EXPECT_EQ(Triple::SUSE, T.getVendor());
336 EXPECT_EQ(Triple::Linux, T.getOS());
337 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
340 EXPECT_EQ(Triple::arm, T.getArch());
341 EXPECT_EQ(Triple::SUSE, T.getVendor());
342 EXPECT_EQ(Triple::Linux, T.getOS());
343 EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
346 EXPECT_EQ(Triple::x86, T.getArch());
347 EXPECT_EQ(Triple::PC, T.getVendor());
348 EXPECT_EQ(Triple::Haiku, T.getOS());
349 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
352 EXPECT_EQ(Triple::x86_64, T.getArch());
353 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
354 EXPECT_EQ(Triple::Haiku, T.getOS());
355 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
358 EXPECT_EQ(Triple::mips, T.getArch());
359 EXPECT_EQ(Triple::MipsTechnologies, T.getVendor());
360 EXPECT_EQ(Triple::Linux, T.getOS());
361 EXPECT_EQ(Triple::GNU, T.getEnvironment());
364 EXPECT_EQ(Triple::mipsel, T.getArch());
365 EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
366 EXPECT_EQ(Triple::Linux, T.getOS());
367 EXPECT_EQ(Triple::GNU, T.getEnvironment());
370 EXPECT_EQ(Triple::mips64, T.getArch());
371 EXPECT_EQ(Triple::MipsTechnologies, T.getVendor());
372 EXPECT_EQ(Triple::Linux, T.getOS());
373 EXPECT_EQ(Triple::GNU, T.getEnvironment());
376 EXPECT_EQ(Triple::mips64el, T.getArch());
377 EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
378 EXPECT_EQ(Triple::Linux, T.getOS());
379 EXPECT_EQ(Triple::GNU, T.getEnvironment());
382 EXPECT_EQ(Triple::mips64el, T.getArch());
383 EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
384 EXPECT_EQ(Triple::Linux, T.getOS());
385 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
388 EXPECT_EQ(Triple::mips64el, T.getArch());
389 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
390 EXPECT_EQ(Triple::Linux, T.getOS());
391 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
392 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
394 EXPECT_EQ(Triple::mips64el, T.getArch());
395 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
396 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
397 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
400 EXPECT_EQ(Triple::mips64, T.getArch());
401 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
402 EXPECT_EQ(Triple::Linux, T.getOS());
403 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
404 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
406 EXPECT_EQ(Triple::mips64, T.getArch());
407 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
408 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
409 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
412 EXPECT_EQ(Triple::mips64el, T.getArch());
413 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
414 EXPECT_EQ(Triple::Linux, T.getOS());
415 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
416 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
418 EXPECT_EQ(Triple::mips64el, T.getArch());
419 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
420 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
421 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
423 EXPECT_EQ(Triple::mips64el, T.getArch());
424 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
425 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
426 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
429 EXPECT_EQ(Triple::mips64, T.getArch());
430 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
431 EXPECT_EQ(Triple::Linux, T.getOS());
432 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
433 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
435 EXPECT_EQ(Triple::mips64, T.getArch());
436 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
437 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
438 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
440 EXPECT_EQ(Triple::mips64, T.getArch());
441 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
442 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
443 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
446 EXPECT_EQ(Triple::mips64el, T.getArch());
447 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
448 EXPECT_EQ(Triple::Linux, T.getOS());
449 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
450 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
452 EXPECT_EQ(Triple::mips64el, T.getArch());
453 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
454 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
455 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
458 EXPECT_EQ(Triple::mips64, T.getArch());
459 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
460 EXPECT_EQ(Triple::Linux, T.getOS());
461 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
462 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
464 EXPECT_EQ(Triple::mips64, T.getArch());
465 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
466 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
467 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
470 EXPECT_EQ(Triple::mips64el, T.getArch());
471 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
472 EXPECT_EQ(Triple::Linux, T.getOS());
473 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
474 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
476 EXPECT_EQ(Triple::mips64el, T.getArch());
477 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
478 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
479 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
482 EXPECT_EQ(Triple::mips64, T.getArch());
483 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
484 EXPECT_EQ(Triple::Linux, T.getOS());
485 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
486 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
488 EXPECT_EQ(Triple::mips64, T.getArch());
489 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
490 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
491 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
494 EXPECT_EQ(Triple::mipsel, T.getArch());
495 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
496 EXPECT_EQ(Triple::Linux, T.getOS());
497 EXPECT_EQ(Triple::GNU, T.getEnvironment());
498 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
500 EXPECT_EQ(Triple::mipsel, T.getArch());
501 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
502 EXPECT_EQ(Triple::GNU, T.getEnvironment());
503 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
506 EXPECT_EQ(Triple::mips, T.getArch());
507 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
508 EXPECT_EQ(Triple::Linux, T.getOS());
509 EXPECT_EQ(Triple::GNU, T.getEnvironment());
510 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
512 EXPECT_EQ(Triple::mips, T.getArch());
513 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
514 EXPECT_EQ(Triple::GNU, T.getEnvironment());
515 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
518 EXPECT_EQ(Triple::mipsel, T.getArch());
519 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
520 EXPECT_EQ(Triple::Linux, T.getOS());
521 EXPECT_EQ(Triple::GNU, T.getEnvironment());
522 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
524 EXPECT_EQ(Triple::mipsel, T.getArch());
525 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
526 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
528 EXPECT_EQ(Triple::mipsel, T.getArch());
529 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
530 EXPECT_EQ(Triple::GNU, T.getEnvironment());
531 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
534 EXPECT_EQ(Triple::mips, T.getArch());
535 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
536 EXPECT_EQ(Triple::Linux, T.getOS());
537 EXPECT_EQ(Triple::GNU, T.getEnvironment());
538 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
540 EXPECT_EQ(Triple::mips, T.getArch());
541 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
542 EXPECT_EQ(Triple::GNU, T.getEnvironment());
543 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
545 EXPECT_EQ(Triple::mips, T.getArch());
546 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
547 EXPECT_EQ(Triple::GNU, T.getEnvironment());
548 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
551 EXPECT_EQ(Triple::arm, T.getArch());
552 EXPECT_EQ(Triple::OpenEmbedded, T.getVendor());
553 EXPECT_EQ(Triple::Linux, T.getOS());
554 EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
557 EXPECT_EQ(Triple::aarch64, T.getArch());
558 EXPECT_EQ(Triple::OpenEmbedded, T.getVendor());
559 EXPECT_EQ(Triple::Linux, T.getOS());
560 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
564 EXPECT_EQ(Triple::aarch64_32, T.getArch());
565 EXPECT_EQ(Triple::IOS, T.getOS());
566 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
570 EXPECT_EQ(Triple::UnknownArch, T.getArch());
595 EXPECT_EQ("unknown", Triple::normalize(""));
596 EXPECT_EQ("unknown-unknown", Triple::normalize("-"));
597 EXPECT_EQ("unknown-unknown-unknown", Triple::normalize("--"));
598 EXPECT_EQ("unknown-unknown-unknown-unknown", Triple::normalize("---"));
599 EXPECT_EQ("unknown-unknown-unknown-unknown-unknown",
602 EXPECT_EQ("a", Triple::normalize("a"));
603 EXPECT_EQ("a-b", Triple::normalize("a-b"));
604 EXPECT_EQ("a-b-c", Triple::normalize("a-b-c"));
605 EXPECT_EQ("a-b-c-d", Triple::normalize("a-b-c-d"));
607 EXPECT_EQ("i386-b-c", Triple::normalize("i386-b-c"));
608 EXPECT_EQ("i386-a-c", Triple::normalize("a-i386-c"));
609 EXPECT_EQ("i386-a-b", Triple::normalize("a-b-i386"));
610 EXPECT_EQ("i386-a-b-c", Triple::normalize("a-b-c-i386"));
612 EXPECT_EQ("a-pc-c", Triple::normalize("a-pc-c"));
613 EXPECT_EQ("unknown-pc-b-c", Triple::normalize("pc-b-c"));
614 EXPECT_EQ("a-pc-b", Triple::normalize("a-b-pc"));
615 EXPECT_EQ("a-pc-b-c", Triple::normalize("a-b-c-pc"));
617 EXPECT_EQ("a-b-linux", Triple::normalize("a-b-linux"));
618 EXPECT_EQ("unknown-unknown-linux-b-c", Triple::normalize("linux-b-c"));
619 EXPECT_EQ("a-unknown-linux-c", Triple::normalize("a-linux-c"));
621 EXPECT_EQ("i386-pc-a", Triple::normalize("a-pc-i386"));
622 EXPECT_EQ("i386-pc-unknown", Triple::normalize("-pc-i386"));
623 EXPECT_EQ("unknown-pc-linux-c", Triple::normalize("linux-pc-c"));
624 EXPECT_EQ("unknown-pc-linux", Triple::normalize("linux-pc-"));
626 EXPECT_EQ("i386", Triple::normalize("i386"));
627 EXPECT_EQ("unknown-pc", Triple::normalize("pc"));
628 EXPECT_EQ("unknown-unknown-linux", Triple::normalize("linux"));
630 EXPECT_EQ("x86_64-unknown-linux-gnu", Triple::normalize("x86_64-gnu-linux"));
655 EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
660 EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
670 EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
675 EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
686 EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
691 EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
700 EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
706 EXPECT_EQ("i386-unknown-windows-gnu",
708 EXPECT_EQ("x86_64-unknown-linux-gnu",
710 EXPECT_EQ("i486-unknown-linux-gnu",
712 EXPECT_EQ("i386-redhat-linux",
714 EXPECT_EQ("i686-unknown-linux",
716 EXPECT_EQ("arm-none-unknown-eabi",
718 EXPECT_EQ("wasm32-unknown-wasi",
720 EXPECT_EQ("wasm64-unknown-wasi",
726 EXPECT_EQ(Triple::UnknownArch, T.getArch());
727 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
728 EXPECT_EQ(Triple::UnknownOS, T.getOS());
729 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
732 EXPECT_EQ(Triple::x86, T.getArch());
733 EXPECT_EQ("i386--", T.getTriple());
736 EXPECT_EQ(Triple::x86, T.getArch());
737 EXPECT_EQ(Triple::PC, T.getVendor());
738 EXPECT_EQ("i386-pc-", T.getTriple());
741 EXPECT_EQ(Triple::x86, T.getArch());
742 EXPECT_EQ(Triple::PC, T.getVendor());
743 EXPECT_EQ(Triple::Linux, T.getOS());
744 EXPECT_EQ("i386-pc-linux", T.getTriple());
747 EXPECT_EQ(Triple::x86, T.getArch());
748 EXPECT_EQ(Triple::PC, T.getVendor());
749 EXPECT_EQ(Triple::Linux, T.getOS());
750 EXPECT_EQ("i386-pc-linux-gnu", T.getTriple());
753 EXPECT_EQ(Triple::x86, T.getArch());
754 EXPECT_EQ(Triple::PC, T.getVendor());
755 EXPECT_EQ(Triple::FreeBSD, T.getOS());
756 EXPECT_EQ("i386-pc-freebsd-gnu", T.getTriple());
759 EXPECT_EQ(Triple::x86, T.getArch());
760 EXPECT_EQ(Triple::PC, T.getVendor());
761 EXPECT_EQ(Triple::Darwin, T.getOS());
762 EXPECT_EQ("i386-pc-darwin", T.getTriple());
896 EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
897 EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
900 EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
901 EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
904 EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
905 EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
908 EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
909 EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
912 EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
913 EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
916 EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
917 EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
920 EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
921 EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
924 EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
925 EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
928 EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
929 EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
932 EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
933 EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
936 EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
937 EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
940 EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
941 EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
944 EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
945 EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
948 EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
949 EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
952 EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
953 EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
956 EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
957 EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
960 EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
961 EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
964 EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
965 EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
968 EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
969 EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
972 EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
973 EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
976 EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
977 EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
980 EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
981 EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
984 EXPECT_EQ(Triple::riscv32, T.get32BitArchVariant().getArch());
985 EXPECT_EQ(Triple::riscv64, T.get64BitArchVariant().getArch());
988 EXPECT_EQ(Triple::riscv32, T.get32BitArchVariant().getArch());
989 EXPECT_EQ(Triple::riscv64, T.get64BitArchVariant().getArch());
992 EXPECT_EQ(Triple::thumbeb, T.get32BitArchVariant().getArch());
993 EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
996 EXPECT_EQ(Triple::thumb, T.get32BitArchVariant().getArch());
997 EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
1000 EXPECT_EQ(Triple::arm, T.get32BitArchVariant().getArch());
1001 EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
1004 EXPECT_EQ(Triple::armeb, T.get32BitArchVariant().getArch());
1005 EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
1008 EXPECT_EQ(Triple::renderscript32, T.get32BitArchVariant().getArch());
1009 EXPECT_EQ(Triple::renderscript64, T.get64BitArchVariant().getArch());
1012 EXPECT_EQ(Triple::renderscript32, T.get32BitArchVariant().getArch());
1013 EXPECT_EQ(Triple::renderscript64, T.get64BitArchVariant().getArch());
1016 EXPECT_EQ(Triple::le32, T.get32BitArchVariant().getArch());
1017 EXPECT_EQ(Triple::le64, T.get64BitArchVariant().getArch());
1020 EXPECT_EQ(Triple::le32, T.get32BitArchVariant().getArch());
1021 EXPECT_EQ(Triple::le64, T.get64BitArchVariant().getArch());
1024 EXPECT_EQ(Triple::armeb, T.get32BitArchVariant().getArch());
1025 EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
1028 EXPECT_EQ(Triple::arm, T.get32BitArchVariant().getArch());
1029 EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
1032 EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
1033 EXPECT_EQ(Triple::systemz, T.get64BitArchVariant().getArch());
1036 EXPECT_EQ(Triple::xcore, T.get32BitArchVariant().getArch());
1037 EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
1042 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1043 EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
1046 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1047 EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
1050 EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
1051 EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
1054 EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
1055 EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
1058 EXPECT_EQ(Triple::armeb, T.getBigEndianArchVariant().getArch());
1059 EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
1062 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1063 EXPECT_EQ(Triple::arm, T.getLittleEndianArchVariant().getArch());
1074 EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
1075 EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
1078 EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
1079 EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
1082 EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
1083 EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
1086 EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
1087 EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
1090 EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
1091 EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
1094 EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
1095 EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
1098 EXPECT_EQ(Triple::ppc, T.getBigEndianArchVariant().getArch());
1099 EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
1102 EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
1103 EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
1106 EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
1107 EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
1110 EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
1111 EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
1114 EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
1115 EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
1118 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1119 EXPECT_EQ(Triple::thumb, T.getLittleEndianArchVariant().getArch());
1122 EXPECT_EQ(Triple::thumbeb, T.getBigEndianArchVariant().getArch());
1123 EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
1126 EXPECT_EQ(Triple::lanai, T.getBigEndianArchVariant().getArch());
1127 EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
1130 EXPECT_EQ(Triple::tce, T.getBigEndianArchVariant().getArch());
1131 EXPECT_EQ(Triple::tcele, T.getLittleEndianArchVariant().getArch());
1134 EXPECT_EQ(Triple::tce, T.getBigEndianArchVariant().getArch());
1135 EXPECT_EQ(Triple::tcele, T.getLittleEndianArchVariant().getArch());
1138 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1139 EXPECT_EQ(Triple::le32, T.getLittleEndianArchVariant().getArch());
1142 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1143 EXPECT_EQ(Triple::le64, T.getLittleEndianArchVariant().getArch());
1157 EXPECT_EQ((unsigned)10, Major);
1158 EXPECT_EQ((unsigned)5, Minor);
1159 EXPECT_EQ((unsigned)0, Micro);
1161 EXPECT_EQ((unsigned)5, Major);
1162 EXPECT_EQ((unsigned)0, Minor);
1163 EXPECT_EQ((unsigned)0, Micro);
1172 EXPECT_EQ((unsigned)10, Major);
1173 EXPECT_EQ((unsigned)5, Minor);
1174 EXPECT_EQ((unsigned)0, Micro);
1176 EXPECT_EQ((unsigned)5, Major);
1177 EXPECT_EQ((unsigned)0, Minor);
1178 EXPECT_EQ((unsigned)0, Micro);
1187 EXPECT_EQ((unsigned)10, Major);
1188 EXPECT_EQ((unsigned)4, Minor);
1189 EXPECT_EQ((unsigned)0, Micro);
1191 EXPECT_EQ((unsigned)5, Major);
1192 EXPECT_EQ((unsigned)0, Minor);
1193 EXPECT_EQ((unsigned)0, Micro);
1202 EXPECT_EQ((unsigned)10, Major);
1203 EXPECT_EQ((unsigned)7, Minor);
1204 EXPECT_EQ((unsigned)0, Micro);
1206 EXPECT_EQ((unsigned)5, Major);
1207 EXPECT_EQ((unsigned)0, Minor);
1208 EXPECT_EQ((unsigned)0, Micro);
1217 EXPECT_EQ((unsigned)10, Major);
1218 EXPECT_EQ((unsigned)4, Minor);
1219 EXPECT_EQ((unsigned)0, Micro);
1221 EXPECT_EQ((unsigned)5, Major);
1222 EXPECT_EQ((unsigned)0, Minor);
1223 EXPECT_EQ((unsigned)0, Micro);
1232 EXPECT_EQ((unsigned)10, Major);
1233 EXPECT_EQ((unsigned)4, Minor);
1234 EXPECT_EQ((unsigned)0, Micro);
1236 EXPECT_EQ((unsigned)7, Major);
1237 EXPECT_EQ((unsigned)0, Minor);
1238 EXPECT_EQ((unsigned)0, Micro);
1244 EXPECT_EQ((unsigned)10, Major);
1245 EXPECT_EQ((unsigned)3, Minor);
1246 EXPECT_EQ((unsigned)0, Micro);
1253 EXPECT_EQ((unsigned)13, Major);
1254 EXPECT_EQ((unsigned)0, Minor);
1255 EXPECT_EQ((unsigned)0, Micro);
1262 EXPECT_EQ(Triple::ELF, Triple("i686-unknown-linux-gnu").getObjectFormat());
1263 EXPECT_EQ(Triple::ELF, Triple("i686-unknown-freebsd").getObjectFormat());
1264 EXPECT_EQ(Triple::ELF, Triple("i686-unknown-netbsd").getObjectFormat());
1265 EXPECT_EQ(Triple::ELF, Triple("i686--win32-elf").getObjectFormat());
1266 EXPECT_EQ(Triple::ELF, Triple("i686---elf").getObjectFormat());
1268 EXPECT_EQ(Triple::MachO, Triple("i686-apple-macosx").getObjectFormat());
1269 EXPECT_EQ(Triple::MachO, Triple("i686-apple-ios").getObjectFormat());
1270 EXPECT_EQ(Triple::MachO, Triple("i686---macho").getObjectFormat());
1272 EXPECT_EQ(Triple::COFF, Triple("i686--win32").getObjectFormat());
1274 EXPECT_EQ(Triple::ELF, Triple("i686-pc-windows-msvc-elf").getObjectFormat());
1275 EXPECT_EQ(Triple::ELF, Triple("i686-pc-cygwin-elf").getObjectFormat());
1277 EXPECT_EQ(Triple::Wasm, Triple("wasm32-unknown-unknown").getObjectFormat());
1278 EXPECT_EQ(Triple::Wasm, Triple("wasm64-unknown-unknown").getObjectFormat());
1279 EXPECT_EQ(Triple::Wasm, Triple("wasm32-wasi").getObjectFormat());
1280 EXPECT_EQ(Triple::Wasm, Triple("wasm64-wasi").getObjectFormat());
1281 EXPECT_EQ(Triple::Wasm, Triple("wasm32-unknown-wasi").getObjectFormat());
1282 EXPECT_EQ(Triple::Wasm, Triple("wasm64-unknown-wasi").getObjectFormat());
1284 EXPECT_EQ(Triple::Wasm,
1286 EXPECT_EQ(Triple::Wasm,
1288 EXPECT_EQ(Triple::Wasm,
1290 EXPECT_EQ(Triple::Wasm,
1292 EXPECT_EQ(Triple::Wasm,
1294 EXPECT_EQ(Triple::Wasm,
1297 EXPECT_EQ(Triple::XCOFF, Triple("powerpc-ibm-aix").getObjectFormat());
1298 EXPECT_EQ(Triple::XCOFF, Triple("powerpc64-ibm-aix").getObjectFormat());
1299 EXPECT_EQ(Triple::XCOFF, Triple("powerpc---xcoff").getObjectFormat());
1300 EXPECT_EQ(Triple::XCOFF, Triple("powerpc64---xcoff").getObjectFormat());
1303 EXPECT_EQ(Triple::ELF, MSVCNormalized.getObjectFormat());
1306 EXPECT_EQ(Triple::ELF, GNUWindowsNormalized.getObjectFormat());
1309 EXPECT_EQ(Triple::ELF, CygnusNormalised.getObjectFormat());
1312 EXPECT_EQ(Triple::ELF, CygwinNormalized.getObjectFormat());
1316 EXPECT_EQ(Triple::ELF, T.getObjectFormat());
1319 EXPECT_EQ(Triple::MachO, T.getObjectFormat());
1322 EXPECT_EQ(Triple::XCOFF, T.getObjectFormat());
1326 EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-win32"));
1327 EXPECT_EQ("i686-unknown-windows-msvc", Triple::normalize("i686-win32"));
1328 EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32"));
1329 EXPECT_EQ("i686-unknown-windows-gnu", Triple::normalize("i686-mingw32"));
1330 EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32-w64"));
1331 EXPECT_EQ("i686-unknown-windows-gnu", Triple::normalize("i686-mingw32-w64"));
1332 EXPECT_EQ("i686-pc-windows-cygnus", Triple::normalize("i686-pc-cygwin"));
1333 EXPECT_EQ("i686-unknown-windows-cygnus", Triple::normalize("i686-cygwin"));
1335 EXPECT_EQ("x86_64-pc-windows-msvc", Triple::normalize("x86_64-pc-win32"));
1336 EXPECT_EQ("x86_64-unknown-windows-msvc", Triple::normalize("x86_64-win32"));
1337 EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32"));
1338 EXPECT_EQ("x86_64-unknown-windows-gnu", Triple::normalize("x86_64-mingw32"));
1339 EXPECT_EQ("x86_64-pc-windows-gnu",
1341 EXPECT_EQ("x86_64-unknown-windows-gnu",
1344 EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-win32-elf"));
1345 EXPECT_EQ("i686-unknown-windows-elf", Triple::normalize("i686-win32-elf"));
1346 EXPECT_EQ("i686-pc-windows-macho", Triple::normalize("i686-pc-win32-macho"));
1347 EXPECT_EQ("i686-unknown-windows-macho",
1350 EXPECT_EQ("x86_64-pc-windows-elf", Triple::normalize("x86_64-pc-win32-elf"));
1351 EXPECT_EQ("x86_64-unknown-windows-elf",
1353 EXPECT_EQ("x86_64-pc-windows-macho",
1355 EXPECT_EQ("x86_64-unknown-windows-macho",
1358 EXPECT_EQ("i686-pc-windows-cygnus",
1360 EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-windows-gnu"));
1361 EXPECT_EQ("i686-pc-windows-itanium",
1363 EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-windows-msvc"));
1365 EXPECT_EQ("i686-pc-windows-elf",
1375 EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch());
1379 EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch());
1383 EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
1387 EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
1391 EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
1395 EXPECT_EQ("cortex-a9", Triple.getARMCPUForArch());
1400 EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
1404 EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
1408 EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
1413 EXPECT_EQ("arm7tdmi", Triple.getARMCPUForArch());
1417 EXPECT_EQ("", Triple.getARMCPUForArch());
1421 EXPECT_EQ("", Triple.getARMCPUForArch());
1426 EXPECT_EQ("xscale", Triple.getARMCPUForArch());
1430 EXPECT_EQ("", Triple.getARMCPUForArch());
1435 EXPECT_EQ("armv6-unknown-netbsd-eabi",
1437 EXPECT_EQ("armv7-unknown-netbsd-eabi",
1439 EXPECT_EQ("armv6eb-unknown-netbsd-eabi",
1441 EXPECT_EQ("armv7eb-unknown-netbsd-eabi",
1443 EXPECT_EQ("armv6-unknown-netbsd-eabihf",
1445 EXPECT_EQ("armv7-unknown-netbsd-eabihf",
1447 EXPECT_EQ("armv6eb-unknown-netbsd-eabihf",
1449 EXPECT_EQ("armv7eb-unknown-netbsd-eabihf",
1452 EXPECT_EQ("armv7-suse-linux-gnueabihf",
1457 EXPECT_EQ(Triple::arm, T.getArch());
1459 EXPECT_EQ(Triple::armeb, T.getArch());
1461 EXPECT_EQ(Triple::GNUEABIHF, T.getEnvironment());
1468 EXPECT_EQ(Triple::arm, T.getArch());
1472 EXPECT_EQ(Triple::armeb, T.getArch());
1477 EXPECT_EQ(Triple::thumb, T.getArch());
1481 EXPECT_EQ(Triple::thumbeb, T.getArch());
1486 EXPECT_EQ(Triple::aarch64, T.getArch());
1490 EXPECT_EQ(Triple::aarch64_32, T.getArch());
1494 EXPECT_EQ(Triple::aarch64, T.getArch());
1498 EXPECT_EQ(Triple::aarch64_be, T.getArch());
unittests/ADT/TwineTest.cpp 27 EXPECT_EQ("", Twine().str());
28 EXPECT_EQ("hi", Twine("hi").str());
29 EXPECT_EQ("hi", Twine(std::string("hi")).str());
30 EXPECT_EQ("hi", Twine(StringRef("hi")).str());
31 EXPECT_EQ("hi", Twine(StringRef(std::string("hi"))).str());
32 EXPECT_EQ("hi", Twine(StringRef("hithere", 2)).str());
33 EXPECT_EQ("hi", Twine(SmallString<4>("hi")).str());
34 EXPECT_EQ("hi", Twine(formatv("{0}", "hi")).str());
38 EXPECT_EQ("123", Twine(123U).str());
39 EXPECT_EQ("123", Twine(123).str());
40 EXPECT_EQ("-123", Twine(-123).str());
41 EXPECT_EQ("123", Twine(123).str());
42 EXPECT_EQ("-123", Twine(-123).str());
44 EXPECT_EQ("7b", Twine::utohexstr(123).str());
48 EXPECT_EQ("x", Twine('x').str());
49 EXPECT_EQ("x", Twine(static_cast<unsigned char>('x')).str());
50 EXPECT_EQ("x", Twine(static_cast<signed char>('x')).str());
58 EXPECT_EQ("(Twine null empty)",
60 EXPECT_EQ("(Twine null empty)",
64 EXPECT_EQ("(Twine cstring:\"hi\" empty)",
66 EXPECT_EQ("(Twine cstring:\"hi\" empty)",
68 EXPECT_EQ("(Twine smallstring:\"hi\" empty)",
70 EXPECT_EQ("(Twine formatv:\"howdy\" empty)",
72 EXPECT_EQ("(Twine formatv:\"howdy\" empty)",
74 EXPECT_EQ("(Twine smallstring:\"hey\" cstring:\"there\")",
78 EXPECT_EQ("(Twine cstring:\"a\" cstring:\"b\")",
82 EXPECT_EQ("(Twine rope:(Twine cstring:\"a\" cstring:\"b\") cstring:\"c\")",
84 EXPECT_EQ("(Twine cstring:\"a\" rope:(Twine cstring:\"b\" cstring:\"c\"))",
86 EXPECT_EQ("(Twine cstring:\"a\" rope:(Twine smallstring:\"b\" cstring:\"c\"))",
92 EXPECT_EQ(0, *Twine("hello").toNullTerminatedStringRef(storage).end());
93 EXPECT_EQ(0,
95 EXPECT_EQ(0, *Twine(SmallString<11>("hello"))
98 EXPECT_EQ(0, *Twine(formatv("{0}{1}", "how", "dy"))
114 EXPECT_EQ(0, Count);
116 EXPECT_EQ(1, Count);
unittests/Analysis/AliasAnalysisTest.cpp 194 EXPECT_EQ(AA.getModRefInfo(Store1, MemoryLocation()), ModRefInfo::Mod);
195 EXPECT_EQ(AA.getModRefInfo(Store1, None), ModRefInfo::Mod);
196 EXPECT_EQ(AA.getModRefInfo(Load1, MemoryLocation()), ModRefInfo::Ref);
197 EXPECT_EQ(AA.getModRefInfo(Load1, None), ModRefInfo::Ref);
198 EXPECT_EQ(AA.getModRefInfo(Add1, MemoryLocation()), ModRefInfo::NoModRef);
199 EXPECT_EQ(AA.getModRefInfo(Add1, None), ModRefInfo::NoModRef);
200 EXPECT_EQ(AA.getModRefInfo(VAArg1, MemoryLocation()), ModRefInfo::ModRef);
201 EXPECT_EQ(AA.getModRefInfo(VAArg1, None), ModRefInfo::ModRef);
202 EXPECT_EQ(AA.getModRefInfo(CmpXChg1, MemoryLocation()), ModRefInfo::ModRef);
203 EXPECT_EQ(AA.getModRefInfo(CmpXChg1, None), ModRefInfo::ModRef);
204 EXPECT_EQ(AA.getModRefInfo(AtomicRMW, MemoryLocation()), ModRefInfo::ModRef);
205 EXPECT_EQ(AA.getModRefInfo(AtomicRMW, None), ModRefInfo::ModRef);
unittests/Analysis/BlockFrequencyInfoTest.cpp 74 EXPECT_EQ(BB0Freq, BB3Freq);
75 EXPECT_EQ(BB0Freq, BB1Freq + BB2Freq);
76 EXPECT_EQ(BB0Freq, BB3Freq);
78 EXPECT_EQ(BFI.getBlockProfileCount(&BB0).getValue(), UINT64_C(100));
79 EXPECT_EQ(BFI.getBlockProfileCount(BB3).getValue(), UINT64_C(100));
80 EXPECT_EQ(BFI.getBlockProfileCount(BB1).getValue(),
82 EXPECT_EQ(BFI.getBlockProfileCount(BB2).getValue(),
88 EXPECT_EQ(BFI.getBlockFreq(&BB0).getFrequency(), 2 * BB0Freq);
89 EXPECT_EQ(BFI.getBlockFreq(BB1).getFrequency(), 2 * BB1Freq);
90 EXPECT_EQ(BFI.getBlockFreq(BB2).getFrequency(), 2 * BB2Freq);
91 EXPECT_EQ(BFI.getBlockFreq(BB3).getFrequency(), BB3Freq);
unittests/Analysis/CFGTest.cpp 102 EXPECT_EQ(isPotentiallyReachable(A, B, &ExclusionSet, nullptr, nullptr),
104 EXPECT_EQ(isPotentiallyReachable(A, B, &ExclusionSet, DT, nullptr),
106 EXPECT_EQ(isPotentiallyReachable(A, B, &ExclusionSet, nullptr, LI),
108 EXPECT_EQ(isPotentiallyReachable(A, B, &ExclusionSet, DT, LI),
unittests/Analysis/CGSCCPassManagerTest.cpp 326 EXPECT_EQ(4, SCCPassRunCount1);
327 EXPECT_EQ(6, FunctionPassRunCount1);
328 EXPECT_EQ(6, FunctionPassRunCount2);
329 EXPECT_EQ(6, FunctionPassRunCount3);
331 EXPECT_EQ(1, ModuleAnalysisRuns);
332 EXPECT_EQ(4, SCCAnalysisRuns);
333 EXPECT_EQ(6, FunctionAnalysisRuns);
334 EXPECT_EQ(6, ImmutableFunctionAnalysisRuns);
336 EXPECT_EQ(14, AnalyzedInstrCount1);
337 EXPECT_EQ(6, AnalyzedSCCFunctionCount1);
338 EXPECT_EQ(4 * 6, AnalyzedModuleFunctionCount1);
413 EXPECT_EQ(1, ModuleAnalysisRuns);
414 EXPECT_EQ(4, CountFoundModuleAnalysis1);
415 EXPECT_EQ(4, CountFoundModuleAnalysis2);
416 EXPECT_EQ(0, CountFoundModuleAnalysis3);
497 EXPECT_EQ(1, ModuleAnalysisRuns);
538 EXPECT_EQ(2 * 4, SCCAnalysisRuns);
577 EXPECT_EQ(4, SCCAnalysisRuns);
612 EXPECT_EQ(2 * 4, SCCAnalysisRuns);
657 EXPECT_EQ(2, FunctionAnalysisRuns);
705 EXPECT_EQ(1, FunctionAnalysisRuns);
752 EXPECT_EQ(2 * 6, FunctionAnalysisRuns);
795 EXPECT_EQ(6, FunctionAnalysisRuns);
833 EXPECT_EQ(2 * 6, FunctionAnalysisRuns);
1096 EXPECT_EQ(7, SCCAnalysisRuns);
1098 EXPECT_EQ(2, ModuleAnalysisRuns);
1101 EXPECT_EQ(3 * 4, IndirectSCCAnalysisRuns);
1102 EXPECT_EQ(3 * 4, DoublyIndirectSCCAnalysisRuns);
1107 EXPECT_EQ(6 + 5 + 6, IndirectFunctionAnalysisRuns);
1110 EXPECT_EQ(4 * 6, FunctionCount);
1260 EXPECT_EQ(4 + 3 + 1 + 3, SCCAnalysisRuns);
1262 EXPECT_EQ(3, ModuleAnalysisRuns);
1267 EXPECT_EQ(4 + 2 + 7 + 1 + 3 + 4, IndirectSCCAnalysisRuns);
1268 EXPECT_EQ(4 + 2 + 7 + 1 + 3 + 4, DoublyIndirectSCCAnalysisRuns);
1275 EXPECT_EQ(6 + 3 + 6 + 3 + 3 + 2 + 6, FunctionAnalysisRuns);
1282 EXPECT_EQ(6 + 3 + 6 + 3 + 3 + 2 + 6, IndirectFunctionAnalysisRuns);
unittests/Analysis/DivergenceAnalysisTest.cpp 88 EXPECT_EQ(DA.getRegionLoop(), nullptr);
unittests/Analysis/DomTreeUpdaterTest.cpp 91 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 3u);
99 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 2u);
183 EXPECT_EQ(F->begin()->getName(), NewEntry->getName());
194 EXPECT_EQ(NewEntry->getTerminator()->getNumSuccessors(), 1u);
197 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 1u);
271 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 4u);
274 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 2u);
299 EXPECT_EQ(BB3->getParent(), F);
369 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 3u);
372 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 2u);
393 EXPECT_EQ(BB2->getParent(), F);
403 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 2u);
406 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 1u);
416 EXPECT_EQ(BB1->getParent(), F);
488 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 4u);
491 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 2u);
506 EXPECT_EQ(BB3->getParent(), F);
558 EXPECT_EQ(F->begin()->getName(), NewEntry->getName());
572 EXPECT_EQ(NewEntry->getTerminator()->getNumSuccessors(), 1u);
575 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 1u);
591 EXPECT_EQ(BB0->getParent(), F);
655 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 5u);
663 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 4u);
758 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 1u);
761 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 1u);
778 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 1u);
791 EXPECT_EQ(BB0->getTerminator()->getNumSuccessors(), 1u);
unittests/Analysis/GlobalsModRefTest.cpp 42 EXPECT_EQ(++I, funcs.end());
52 EXPECT_EQ(FMRB_UnknownModRefBehavior, AAR.getModRefBehavior(&F1));
53 EXPECT_EQ(FMRB_DoesNotAccessMemory, AAR.getModRefBehavior(&F2));
54 EXPECT_EQ(FMRB_OnlyReadsMemory, AAR.getModRefBehavior(&F3));
unittests/Analysis/IVDescriptorsTest.cpp 96 EXPECT_EQ(IndDesc.getInductionBinOp(), Inst_inc);
98 EXPECT_EQ(IndDesc.getUnsafeAlgebraInst(), nullptr);
unittests/Analysis/LazyCallGraphTest.cpp 237 EXPECT_EQ("a1", A1.getFunction().getName());
239 EXPECT_EQ("a2", A2.getFunction().getName());
241 EXPECT_EQ("a3", A3.getFunction().getName());
243 EXPECT_EQ("b1", B1.getFunction().getName());
245 EXPECT_EQ("b2", B2.getFunction().getName());
247 EXPECT_EQ("b3", B3.getFunction().getName());
249 EXPECT_EQ("c1", C1.getFunction().getName());
251 EXPECT_EQ("c2", C2.getFunction().getName());
253 EXPECT_EQ("c3", C3.getFunction().getName());
255 EXPECT_EQ("d1", D1.getFunction().getName());
257 EXPECT_EQ("d2", D2.getFunction().getName());
259 EXPECT_EQ("d3", D3.getFunction().getName());
260 EXPECT_EQ(CG.end(), I);
269 EXPECT_EQ("a2", Nodes[0]);
270 EXPECT_EQ("b2", Nodes[1]);
271 EXPECT_EQ("c3", Nodes[2]);
275 EXPECT_EQ(A2->end(), std::next(A2->begin()));
276 EXPECT_EQ("a3", A2->begin()->getFunction().getName());
278 EXPECT_EQ(A3->end(), std::next(A3->begin()));
279 EXPECT_EQ("a1", A3->begin()->getFunction().getName());
284 EXPECT_EQ("b2", Nodes[0]);
285 EXPECT_EQ("d3", Nodes[1]);
289 EXPECT_EQ(B2->end(), std::next(B2->begin()));
290 EXPECT_EQ("b3", B2->begin()->getFunction().getName());
292 EXPECT_EQ(B3->end(), std::next(B3->begin()));
293 EXPECT_EQ("b1", B3->begin()->getFunction().getName());
298 EXPECT_EQ("c2", Nodes[0]);
299 EXPECT_EQ("d2", Nodes[1]);
303 EXPECT_EQ(C2->end(), std::next(C2->begin()));
304 EXPECT_EQ("c3", C2->begin()->getFunction().getName());
306 EXPECT_EQ(C3->end(), std::next(C3->begin()));
307 EXPECT_EQ("c1", C3->begin()->getFunction().getName());
310 EXPECT_EQ(D1->end(), std::next(D1->begin()));
311 EXPECT_EQ("d2", D1->begin()->getFunction().getName());
313 EXPECT_EQ(D2->end(), std::next(D2->begin()));
314 EXPECT_EQ("d3", D2->begin()->getFunction().getName());
316 EXPECT_EQ(D3->end(), std::next(D3->begin()));
317 EXPECT_EQ("d1", D3->begin()->getFunction().getName());
328 EXPECT_EQ(3u, Nodes.size());
329 EXPECT_EQ("d1", Nodes[0]);
330 EXPECT_EQ("d2", Nodes[1]);
331 EXPECT_EQ("d3", Nodes[2]);
337 EXPECT_EQ(&D, &*CG.postorder_ref_scc_begin());
344 EXPECT_EQ(3u, Nodes.size());
345 EXPECT_EQ("c1", Nodes[0]);
346 EXPECT_EQ("c2", Nodes[1]);
347 EXPECT_EQ("c3", Nodes[2]);
353 EXPECT_EQ(&C, &*std::next(CG.postorder_ref_scc_begin()));
360 EXPECT_EQ(3u, Nodes.size());
361 EXPECT_EQ("b1", Nodes[0]);
362 EXPECT_EQ("b2", Nodes[1]);
363 EXPECT_EQ("b3", Nodes[2]);
371 EXPECT_EQ(&B, &*std::next(CG.postorder_ref_scc_begin(), 2));
378 EXPECT_EQ(3u, Nodes.size());
379 EXPECT_EQ("a1", Nodes[0]);
380 EXPECT_EQ("a2", Nodes[1]);
381 EXPECT_EQ("a3", Nodes[2]);
389 EXPECT_EQ(&A, &*std::next(CG.postorder_ref_scc_begin(), 3));
391 EXPECT_EQ(CG.postorder_ref_scc_end(), J);
392 EXPECT_EQ(J, std::next(CG.postorder_ref_scc_begin(), 4));
423 EXPECT_EQ(2, std::distance(A->begin(), A->end()));
425 EXPECT_EQ(0, std::distance(B->begin(), B->end()));
430 EXPECT_EQ(1, std::distance(B->begin(), B->end()));
431 EXPECT_EQ(0, std::distance(C->begin(), C->end()));
434 EXPECT_EQ(1, std::distance(C->begin(), C->end()));
435 EXPECT_EQ(&B, &C->begin()->getNode());
438 EXPECT_EQ(2, std::distance(C->begin(), C->end()));
439 EXPECT_EQ(&B, &C->begin()->getNode());
440 EXPECT_EQ(&C, &std::next(C->begin())->getNode());
443 EXPECT_EQ(1, std::distance(C->begin(), C->end()));
444 EXPECT_EQ(&C, &C->begin()->getNode());
447 EXPECT_EQ(0, std::distance(C->begin(), C->end()));
450 EXPECT_EQ(0, std::distance(B->begin(), B->end()));
474 EXPECT_EQ(CG.postorder_ref_scc_end(), I);
482 EXPECT_EQ(3u, Nodes.size());
483 EXPECT_EQ("d1", Nodes[0]);
484 EXPECT_EQ("d2", Nodes[1]);
485 EXPECT_EQ("d3", Nodes[2]);
492 EXPECT_EQ(3u, Nodes.size());
493 EXPECT_EQ("b1", Nodes[0]);
494 EXPECT_EQ("b2", Nodes[1]);
495 EXPECT_EQ("b3", Nodes[2]);
502 EXPECT_EQ(3u, Nodes.size());
503 EXPECT_EQ("c1", Nodes[0]);
504 EXPECT_EQ("c2", Nodes[1]);
505 EXPECT_EQ("c3", Nodes[2]);
512 EXPECT_EQ(3u, Nodes.size());
513 EXPECT_EQ("a1", Nodes[0]);
514 EXPECT_EQ("a2", Nodes[1]);
515 EXPECT_EQ("a3", Nodes[2]);
518 EXPECT_EQ(RC.end(), J);
559 EXPECT_EQ(CG.postorder_ref_scc_end(), I);
566 EXPECT_EQ(&RC, CG.lookupRefSCC(N1));
567 EXPECT_EQ(&RC, CG.lookupRefSCC(N2));
568 EXPECT_EQ(&RC, CG.lookupRefSCC(N3));
569 EXPECT_EQ(&RC, CG.lookupRefSCC(N4));
570 EXPECT_EQ(&RC, CG.lookupRefSCC(N5));
575 EXPECT_EQ(&C, CG.lookupSCC(N1));
576 EXPECT_EQ(&C, CG.lookupSCC(N2));
577 EXPECT_EQ(&C, CG.lookupSCC(N3));
578 EXPECT_EQ(&C, CG.lookupSCC(N4));
579 EXPECT_EQ(&C, CG.lookupSCC(N5));
640 EXPECT_EQ(2, std::distance(A->begin(), A->end()));
642 EXPECT_EQ(3, std::distance(A->begin(), A->end()));
646 EXPECT_EQ(&D, &NewE.getNode());
658 EXPECT_EQ(&AC, CG.lookupSCC(A));
659 EXPECT_EQ(&BC, CG.lookupSCC(B));
660 EXPECT_EQ(&CC, CG.lookupSCC(C));
661 EXPECT_EQ(&DC, CG.lookupSCC(D));
662 EXPECT_EQ(&ARC, CG.lookupRefSCC(A));
663 EXPECT_EQ(&BRC, CG.lookupRefSCC(B));
664 EXPECT_EQ(&CRC, CG.lookupRefSCC(C));
665 EXPECT_EQ(&DRC, CG.lookupRefSCC(D));
679 EXPECT_EQ(&AC, CG.lookupSCC(A));
680 EXPECT_EQ(&BC, CG.lookupSCC(B));
681 EXPECT_EQ(&CC, CG.lookupSCC(C));
682 EXPECT_EQ(&DC, CG.lookupSCC(D));
683 EXPECT_EQ(&ARC, CG.lookupRefSCC(A));
684 EXPECT_EQ(&BRC, CG.lookupRefSCC(B));
685 EXPECT_EQ(&CRC, CG.lookupRefSCC(C));
686 EXPECT_EQ(&DRC, CG.lookupRefSCC(D));
700 EXPECT_EQ(&AC, CG.lookupSCC(A));
701 EXPECT_EQ(&BC, CG.lookupSCC(B));
702 EXPECT_EQ(&CC, CG.lookupSCC(C));
703 EXPECT_EQ(&DC, CG.lookupSCC(D));
704 EXPECT_EQ(&ARC, CG.lookupRefSCC(A));
705 EXPECT_EQ(&BRC, CG.lookupRefSCC(B));
706 EXPECT_EQ(&CRC, CG.lookupRefSCC(C));
707 EXPECT_EQ(&DRC, CG.lookupRefSCC(D));
710 EXPECT_EQ(2, std::distance(A->begin(), A->end()));
721 EXPECT_EQ(&AC, CG.lookupSCC(A));
722 EXPECT_EQ(&BC, CG.lookupSCC(B));
723 EXPECT_EQ(&CC, CG.lookupSCC(C));
724 EXPECT_EQ(&DC, CG.lookupSCC(D));
725 EXPECT_EQ(&ARC, CG.lookupRefSCC(A));
726 EXPECT_EQ(&BRC, CG.lookupRefSCC(B));
727 EXPECT_EQ(&CRC, CG.lookupRefSCC(C));
728 EXPECT_EQ(&DRC, CG.lookupRefSCC(D));
801 EXPECT_EQ(&C2, &E.getNode());
804 EXPECT_EQ(1u, MergedRCs.size());
805 EXPECT_EQ(&DRC, MergedRCs[0]);
808 EXPECT_EQ(&ARC, CG.lookupRefSCC(A1));
809 EXPECT_EQ(&ARC, CG.lookupRefSCC(A2));
810 EXPECT_EQ(&ARC, CG.lookupRefSCC(A3));
811 EXPECT_EQ(&BRC, CG.lookupRefSCC(B1));
812 EXPECT_EQ(&BRC, CG.lookupRefSCC(B2));
813 EXPECT_EQ(&BRC, CG.lookupRefSCC(B3));
814 EXPECT_EQ(&CRC, CG.lookupRefSCC(C1));
815 EXPECT_EQ(&CRC, CG.lookupRefSCC(C2));
816 EXPECT_EQ(&CRC, CG.lookupRefSCC(C3));
817 EXPECT_EQ(&CRC, CG.lookupRefSCC(D1));
818 EXPECT_EQ(&CRC, CG.lookupRefSCC(D2));
819 EXPECT_EQ(&CRC, CG.lookupRefSCC(D3));
828 EXPECT_EQ(&CRC, &*I) << "Actual RefSCC: " << *I;
830 EXPECT_EQ(&BRC, &*I) << "Actual RefSCC: " << *I;
832 EXPECT_EQ(&ARC, &*I) << "Actual RefSCC: " << *I;
833 EXPECT_EQ(++I, E);
893 EXPECT_EQ(&C2, &E.getNode());
896 EXPECT_EQ(1u, MergedRCs.size());
897 EXPECT_EQ(&DRC, MergedRCs[0]);
900 EXPECT_EQ(&ARC, CG.lookupRefSCC(A1));
901 EXPECT_EQ(&ARC, CG.lookupRefSCC(A2));
902 EXPECT_EQ(&ARC, CG.lookupRefSCC(A3));
903 EXPECT_EQ(&BRC, CG.lookupRefSCC(B1));
904 EXPECT_EQ(&BRC, CG.lookupRefSCC(B2));
905 EXPECT_EQ(&BRC, CG.lookupRefSCC(B3));
906 EXPECT_EQ(&CRC, CG.lookupRefSCC(C1));
907 EXPECT_EQ(&CRC, CG.lookupRefSCC(C2));
908 EXPECT_EQ(&CRC, CG.lookupRefSCC(C3));
909 EXPECT_EQ(&CRC, CG.lookupRefSCC(D1));
910 EXPECT_EQ(&CRC, CG.lookupRefSCC(D2));
911 EXPECT_EQ(&CRC, CG.lookupRefSCC(D3));
920 EXPECT_EQ(&CRC, &*I) << "Actual RefSCC: " << *I;
922 EXPECT_EQ(&BRC, &*I) << "Actual RefSCC: " << *I;
924 EXPECT_EQ(&ARC, &*I) << "Actual RefSCC: " << *I;
925 EXPECT_EQ(++I, E);
973 EXPECT_EQ(&A, &D->begin()->getNode());
976 EXPECT_EQ(3u, MergedRCs.size());
982 EXPECT_EQ(&ARC, CG.lookupRefSCC(A));
983 EXPECT_EQ(&ARC, CG.lookupRefSCC(B));
984 EXPECT_EQ(&ARC, CG.lookupRefSCC(C));
985 EXPECT_EQ(&ARC, CG.lookupRefSCC(D));
988 EXPECT_EQ(4, ARC.size());
989 EXPECT_EQ(&DC, &ARC[0]);
990 EXPECT_EQ(&CC, &ARC[1]);
991 EXPECT_EQ(&BC, &ARC[2]);
992 EXPECT_EQ(&AC, &ARC[3]);
997 EXPECT_EQ(&ARC, &*I) << "Actual RefSCC: " << *I;
998 EXPECT_EQ(++I, E);
1047 EXPECT_EQ(&A, &D->begin()->getNode());
1050 EXPECT_EQ(3u, MergedRCs.size());
1056 EXPECT_EQ(&ARC, CG.lookupRefSCC(A));
1057 EXPECT_EQ(&ARC, CG.lookupRefSCC(B));
1058 EXPECT_EQ(&ARC, CG.lookupRefSCC(C));
1059 EXPECT_EQ(&ARC, CG.lookupRefSCC(D));
1064 EXPECT_EQ(&ARC, &*I) << "Actual RefSCC: " << *I;
1065 EXPECT_EQ(++I, End);
1165 EXPECT_EQ(&DC, CG.lookupSCC(D2));
1166 EXPECT_EQ(NewCs.end(), std::next(NewCs.begin()));
1168 EXPECT_EQ(&NewDC, CG.lookupSCC(D1));
1169 EXPECT_EQ(&NewDC, CG.lookupSCC(D3));
1173 EXPECT_EQ(&NewDRC, CG.lookupRefSCC(D1));
1174 EXPECT_EQ(&NewDRC, CG.lookupRefSCC(D3));
1176 EXPECT_EQ(&D2RC, CG.lookupRefSCC(D2));
1190 EXPECT_EQ(&ARC, CG.lookupRefSCC(A1));
1191 EXPECT_EQ(&ARC, CG.lookupRefSCC(A2));
1192 EXPECT_EQ(&ARC, CG.lookupRefSCC(A3));
1193 EXPECT_EQ(&BRC, CG.lookupRefSCC(B1));
1194 EXPECT_EQ(&BRC, CG.lookupRefSCC(B2));
1195 EXPECT_EQ(&BRC, CG.lookupRefSCC(B3));
1196 EXPECT_EQ(&CRC, CG.lookupRefSCC(C1));
1197 EXPECT_EQ(&CRC, CG.lookupRefSCC(C2));
1198 EXPECT_EQ(&CRC, CG.lookupRefSCC(C3));
1199 EXPECT_EQ(&NewDRC, CG.lookupRefSCC(D1));
1200 EXPECT_EQ(&NewDRC, CG.lookupRefSCC(D3));
1206 EXPECT_EQ(&NewDRC, &*I) << "Actual RefSCC: " << *I;
1208 EXPECT_EQ(&CRC, &*I) << "Actual RefSCC: " << *I;
1210 EXPECT_EQ(&BRC, &*I) << "Actual RefSCC: " << *I;
1212 EXPECT_EQ(&ARC, &*I) << "Actual RefSCC: " << *I;
1213 EXPECT_EQ(++I, E);
1239 EXPECT_EQ(CG.postorder_ref_scc_end(), I);
1244 EXPECT_EQ(&RC, CG.lookupRefSCC(A));
1245 EXPECT_EQ(&RC, CG.lookupRefSCC(B));
1246 EXPECT_EQ(&RC, CG.lookupRefSCC(C));
1247 EXPECT_EQ(1, RC.size());
1248 EXPECT_EQ(&*RC.begin(), CG.lookupSCC(A));
1249 EXPECT_EQ(&*RC.begin(), CG.lookupSCC(B));
1250 EXPECT_EQ(&*RC.begin(), CG.lookupSCC(C));
1254 EXPECT_EQ(2, std::distance(A->begin(), A->end()));
1255 EXPECT_EQ(&RC, CG.lookupRefSCC(A));
1256 EXPECT_EQ(&RC, CG.lookupRefSCC(B));
1257 EXPECT_EQ(&RC, CG.lookupRefSCC(C));
1258 EXPECT_EQ(1, RC.size());
1259 EXPECT_EQ(&*RC.begin(), CG.lookupSCC(A));
1260 EXPECT_EQ(&*RC.begin(), CG.lookupSCC(B));
1261 EXPECT_EQ(&*RC.begin(), CG.lookupSCC(C));
1267 EXPECT_EQ(&RC, CG.lookupRefSCC(A));
1268 EXPECT_EQ(&RC, CG.lookupRefSCC(B));
1269 EXPECT_EQ(&RC, CG.lookupRefSCC(C));
1274 EXPECT_EQ(&*J++, CG.lookupSCC(B));
1275 EXPECT_EQ(&*J++, CG.lookupSCC(A));
1276 EXPECT_EQ(&*J++, CG.lookupSCC(C));
1277 EXPECT_EQ(RC.end(), J);
1280 EXPECT_EQ(RC.begin(), NewCs.begin());
1281 EXPECT_EQ(std::prev(RC.end()), NewCs.end());
1291 EXPECT_EQ(&AC, MergedCs[0]);
1293 EXPECT_EQ(2, CC.size());
1294 EXPECT_EQ(&CC, CG.lookupSCC(A));
1295 EXPECT_EQ(&CC, CG.lookupSCC(C));
1297 EXPECT_EQ(&*J++, CG.lookupSCC(B));
1298 EXPECT_EQ(&*J++, CG.lookupSCC(C));
1299 EXPECT_EQ(RC.end(), J);
1333 EXPECT_EQ(E, std::next(I));
1338 EXPECT_EQ(&RC, CG.lookupRefSCC(A));
1339 EXPECT_EQ(&RC, CG.lookupRefSCC(B));
1340 EXPECT_EQ(&RC, CG.lookupRefSCC(C));
1346 EXPECT_EQ(0u, NewRCs.size());
1347 EXPECT_EQ(&RC, CG.lookupRefSCC(A));
1348 EXPECT_EQ(&RC, CG.lookupRefSCC(B));
1349 EXPECT_EQ(&RC, CG.lookupRefSCC(C));
1351 EXPECT_EQ(I, J);
1352 EXPECT_EQ(&RC, &*J);
1353 EXPECT_EQ(E, std::next(J));
1365 EXPECT_EQ(&ARC, CG.lookupRefSCC(A));
1366 EXPECT_EQ(1, std::distance(ARC.begin(), ARC.end()));
1367 EXPECT_EQ(&BCRC, CG.lookupRefSCC(B));
1368 EXPECT_EQ(&BCRC, CG.lookupRefSCC(C));
1371 EXPECT_EQ(&BCRC, &*J);
1374 EXPECT_EQ(&ARC, &*J);
1376 EXPECT_EQ(I, J);
1377 EXPECT_EQ(E, J);
1411 EXPECT_EQ(E, std::next(I));
1416 EXPECT_EQ(&RC, CG.lookupRefSCC(A));
1417 EXPECT_EQ(&RC, CG.lookupRefSCC(B));
1418 EXPECT_EQ(&RC, CG.lookupRefSCC(C));
1431 EXPECT_EQ(&BRC, CG.lookupRefSCC(B));
1432 EXPECT_EQ(1, std::distance(BRC.begin(), BRC.end()));
1433 EXPECT_EQ(&ACRC, CG.lookupRefSCC(A));
1434 EXPECT_EQ(&ACRC, CG.lookupRefSCC(C));
1437 EXPECT_EQ(&BRC, &*J);
1440 EXPECT_EQ(&ACRC, &*J);
1442 EXPECT_EQ(I, J);
1443 EXPECT_EQ(E, J);
1478 EXPECT_EQ(E, std::next(I));
1481 EXPECT_EQ(RC.end(), std::next(RC.begin()));
1486 EXPECT_EQ(&RC, CG.lookupRefSCC(AN));
1487 EXPECT_EQ(&RC, CG.lookupRefSCC(BN));
1488 EXPECT_EQ(&RC, CG.lookupRefSCC(CN));
1489 EXPECT_EQ(&C, CG.lookupSCC(AN));
1490 EXPECT_EQ(&C, CG.lookupSCC(BN));
1491 EXPECT_EQ(&C, CG.lookupSCC(CN));
1496 EXPECT_EQ(0u, NewRCs.size());
1497 EXPECT_EQ(&RC, CG.lookupRefSCC(AN));
1498 EXPECT_EQ(&RC, CG.lookupRefSCC(BN));
1499 EXPECT_EQ(&RC, CG.lookupRefSCC(CN));
1500 EXPECT_EQ(&C, CG.lookupSCC(AN));
1501 EXPECT_EQ(&C, CG.lookupSCC(BN));
1502 EXPECT_EQ(&C, CG.lookupSCC(CN));
1504 EXPECT_EQ(I, J);
1505 EXPECT_EQ(&RC, &*J);
1506 EXPECT_EQ(E, std::next(J));
1512 EXPECT_EQ(0u, NewRCs.size());
1513 EXPECT_EQ(&RC, CG.lookupRefSCC(AN));
1514 EXPECT_EQ(&RC, CG.lookupRefSCC(BN));
1515 EXPECT_EQ(&RC, CG.lookupRefSCC(CN));
1516 EXPECT_EQ(&C, CG.lookupSCC(AN));
1517 EXPECT_EQ(&C, CG.lookupSCC(BN));
1518 EXPECT_EQ(&C, CG.lookupSCC(CN));
1520 EXPECT_EQ(I, J);
1521 EXPECT_EQ(&RC, &*J);
1522 EXPECT_EQ(E, std::next(J));
1555 EXPECT_EQ(CG.postorder_ref_scc_end(), I);
1557 EXPECT_EQ(1, RC.size());
1563 EXPECT_EQ(&AC, CG.lookupSCC(AN));
1564 EXPECT_EQ(&AC, CG.lookupSCC(BN));
1565 EXPECT_EQ(&AC, CG.lookupSCC(CN));
1571 EXPECT_EQ(NewCs.begin(), NewCs.end());
1572 EXPECT_EQ(1, RC.size());
1573 EXPECT_EQ(&AC, CG.lookupSCC(AN));
1574 EXPECT_EQ(&AC, CG.lookupSCC(BN));
1575 EXPECT_EQ(&AC, CG.lookupSCC(CN));
1580 EXPECT_EQ(1, std::distance(NewCs.begin(), NewCs.end()));
1581 EXPECT_EQ(2, RC.size());
1582 EXPECT_EQ(&AC, CG.lookupSCC(AN));
1585 EXPECT_EQ(&BC, CG.lookupSCC(CN));
1587 EXPECT_EQ(&AC, &*J);
1589 EXPECT_EQ(&BC, &*J);
1590 EXPECT_EQ(RC.begin(), J);
1591 EXPECT_EQ(J, NewCs.begin());
1596 EXPECT_EQ(1, std::distance(NewCs.begin(), NewCs.end()));
1597 EXPECT_EQ(3, RC.size());
1598 EXPECT_EQ(&AC, CG.lookupSCC(AN));
1599 EXPECT_EQ(&BC, CG.lookupSCC(BN));
1604 EXPECT_EQ(&AC, &*J);
1606 EXPECT_EQ(&BC, &*J);
1608 EXPECT_EQ(&CC, &*J);
1609 EXPECT_EQ(RC.begin(), J);
1610 EXPECT_EQ(J, NewCs.begin());
1648 EXPECT_EQ(CG.postorder_ref_scc_end(), I);
1662 EXPECT_EQ(&DC, &RC[0]);
1663 EXPECT_EQ(&BC, &RC[1]);
1664 EXPECT_EQ(&CC, &RC[2]);
1665 EXPECT_EQ(&AC, &RC[3]);
1671 EXPECT_EQ(&DC, &RC[0]);
1672 EXPECT_EQ(&BC, &RC[1]);
1673 EXPECT_EQ(&CC, &RC[2]);
1674 EXPECT_EQ(&AC, &RC[3]);
1680 EXPECT_EQ(&DC, &RC[0]);
1681 EXPECT_EQ(&CC, &RC[1]);
1682 EXPECT_EQ(&BC, &RC[2]);
1683 EXPECT_EQ(&AC, &RC[3]);
1688 EXPECT_EQ(&CC, MergedCs[0]);
1691 EXPECT_EQ(&DC, &RC[0]);
1692 EXPECT_EQ(&BC, &RC[1]);
1693 EXPECT_EQ(&AC, &RC[2]);
1694 EXPECT_EQ(2, BC.size());
1695 EXPECT_EQ(&BC, CG.lookupSCC(B));
1696 EXPECT_EQ(&BC, CG.lookupSCC(C));
1760 EXPECT_EQ(CG.postorder_ref_scc_end(), I);
1790 EXPECT_EQ(&DC, &RC[0]);
1791 EXPECT_EQ(&C3C, &RC[1]);
1792 EXPECT_EQ(&B3C, &RC[2]);
1793 EXPECT_EQ(&C2C, &RC[3]);
1794 EXPECT_EQ(&B2C, &RC[4]);
1795 EXPECT_EQ(&C1C, &RC[5]);
1796 EXPECT_EQ(&B1C, &RC[6]);
1797 EXPECT_EQ(&AC, &RC[7]);
1804 EXPECT_EQ(&DC, &RC[0]);
1805 EXPECT_EQ(&B3C, &RC[1]);
1806 EXPECT_EQ(&B2C, &RC[2]);
1807 EXPECT_EQ(&B1C, &RC[3]);
1808 EXPECT_EQ(&C3C, &RC[4]);
1809 EXPECT_EQ(&C2C, &RC[5]);
1810 EXPECT_EQ(&C1C, &RC[6]);
1811 EXPECT_EQ(&AC, &RC[7]);
1890 EXPECT_EQ(CG.postorder_ref_scc_end(), I);
1914 EXPECT_EQ(&GC, &RC[0]);
1915 EXPECT_EQ(&FC, &RC[1]);
1916 EXPECT_EQ(&EC, &RC[2]);
1917 EXPECT_EQ(&DC, &RC[3]);
1918 EXPECT_EQ(&CC, &RC[4]);
1919 EXPECT_EQ(&BC, &RC[5]);
1920 EXPECT_EQ(&AC, &RC[6]);
1936 EXPECT_EQ(&FC, MergedCs[0]);
1937 EXPECT_EQ(&DC, MergedCs[1]);
1939 EXPECT_EQ(3, BC.size());
1943 EXPECT_EQ(&GC, &RC[0]);
1944 EXPECT_EQ(&CC, &RC[1]);
1945 EXPECT_EQ(&BC, &RC[2]);
1946 EXPECT_EQ(&EC, &RC[3]);
1947 EXPECT_EQ(&AC, &RC[4]);
1973 EXPECT_EQ(CG.postorder_ref_scc_end(), I);
1977 EXPECT_EQ(&FRC, CG.lookupRefSCC(F));
1978 EXPECT_EQ(&GRC, CG.lookupRefSCC(G));
2001 EXPECT_EQ(CG.postorder_ref_scc_end(), I);
2005 EXPECT_EQ(&FRC, CG.lookupRefSCC(F));
2006 EXPECT_EQ(&GRC, CG.lookupRefSCC(G));
2051 EXPECT_EQ(CG.postorder_ref_scc_end(), I);
2061 EXPECT_EQ(&C1, CG.lookupSCC(DN));
2062 EXPECT_EQ(&C1, CG.lookupSCC(CN));
2063 EXPECT_EQ(&C2, CG.lookupSCC(BN));
2064 EXPECT_EQ(&RC1, CG.lookupRefSCC(DN));
2065 EXPECT_EQ(&RC1, CG.lookupRefSCC(CN));
2066 EXPECT_EQ(&RC1, CG.lookupRefSCC(BN));
2067 EXPECT_EQ(&RC2, CG.lookupRefSCC(AN));
2087 EXPECT_EQ(&E, &DN.getFunction());
2088 EXPECT_EQ(&DN, &(*CN)[DN].getNode());
2089 EXPECT_EQ(&DN, &(*BN)[DN].getNode());
2146 EXPECT_EQ(CG.postorder_ref_scc_end(), I);
2152 EXPECT_EQ(&DeadRC, CG.lookupRefSCC(DeadN));
2153 EXPECT_EQ(&C1, CG.lookupSCC(DN));
2154 EXPECT_EQ(&C1, CG.lookupSCC(CN));
2155 EXPECT_EQ(&C2, CG.lookupSCC(BN));
2156 EXPECT_EQ(&RC1, CG.lookupRefSCC(DN));
2157 EXPECT_EQ(&RC1, CG.lookupRefSCC(CN));
2158 EXPECT_EQ(&RC1, CG.lookupRefSCC(BN));
2159 EXPECT_EQ(&RC2, CG.lookupRefSCC(AN));
2168 EXPECT_EQ(&RC1, &*I++);
2169 EXPECT_EQ(&RC2, &*I++);
2170 EXPECT_EQ(CG.postorder_ref_scc_end(), I);
unittests/Analysis/LoopInfoTest.cpp 149 EXPECT_EQ(L->getLoopID(), NewLoopID);
153 EXPECT_EQ(L->getLoopID(), OldLoopID);
212 EXPECT_EQ(&L_0, Preorder[0]);
213 EXPECT_EQ(&L_0_0, Preorder[1]);
214 EXPECT_EQ(&L_0_1, Preorder[2]);
215 EXPECT_EQ(&L_0_2, Preorder[3]);
216 EXPECT_EQ(&L_1, Preorder[4]);
217 EXPECT_EQ(&L_1_0, Preorder[5]);
218 EXPECT_EQ(&L_1_1, Preorder[6]);
219 EXPECT_EQ(&L_1_2, Preorder[7]);
223 EXPECT_EQ(&L_1, ReverseSiblingPreorder[0]);
224 EXPECT_EQ(&L_1_2, ReverseSiblingPreorder[1]);
225 EXPECT_EQ(&L_1_1, ReverseSiblingPreorder[2]);
226 EXPECT_EQ(&L_1_0, ReverseSiblingPreorder[3]);
227 EXPECT_EQ(&L_0, ReverseSiblingPreorder[4]);
228 EXPECT_EQ(&L_0_2, ReverseSiblingPreorder[5]);
229 EXPECT_EQ(&L_0_1, ReverseSiblingPreorder[6]);
230 EXPECT_EQ(&L_0_0, ReverseSiblingPreorder[7]);
277 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
281 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
282 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
283 EXPECT_EQ(Bounds->getDirection(),
285 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
286 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
335 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
339 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
340 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
341 EXPECT_EQ(Bounds->getDirection(),
343 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
344 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
393 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
397 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
398 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
399 EXPECT_EQ(Bounds->getDirection(),
401 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
402 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
451 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
455 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
456 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
457 EXPECT_EQ(Bounds->getDirection(),
459 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
460 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
509 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
513 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
514 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
515 EXPECT_EQ(Bounds->getDirection(),
517 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
518 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
568 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
572 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ubPlusOne");
573 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
574 EXPECT_EQ(Bounds->getDirection(),
576 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
577 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
626 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
627 EXPECT_EQ(Bounds->getStepValue()->getName(), "step");
628 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
629 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
630 EXPECT_EQ(Bounds->getDirection(), Loop::LoopBounds::Direction::Unknown);
631 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
632 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
681 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
685 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
686 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_ULT);
687 EXPECT_EQ(Bounds->getDirection(),
689 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
690 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
736 EXPECT_EQ(Bounds->getInitialIVValue().getName(), "ub");
737 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
740 EXPECT_EQ(StepValue, nullptr);
744 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SGT);
745 EXPECT_EQ(Bounds->getDirection(),
747 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
748 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
798 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
799 EXPECT_EQ(Bounds->getStepValue()->getName(), "step");
800 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
801 EXPECT_EQ(Bounds->getCanonicalPredicate(),
803 EXPECT_EQ(Bounds->getDirection(), Loop::LoopBounds::Direction::Unknown);
804 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
805 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
857 EXPECT_EQ(Bounds->getStepInst().getName(), "indvars.iv.next");
861 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "wide.trip.count");
862 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_NE);
863 EXPECT_EQ(Bounds->getDirection(),
865 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "indvars.iv");
866 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
917 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
921 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
922 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
923 EXPECT_EQ(Bounds->getDirection(),
925 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
926 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
977 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
981 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
982 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
983 EXPECT_EQ(Bounds->getDirection(),
985 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
986 EXPECT_EQ(L->getLoopGuardBranch(), nullptr);
1029 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
1033 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
1034 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
1035 EXPECT_EQ(Bounds->getDirection(),
1037 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
1038 EXPECT_EQ(L->getLoopGuardBranch(), nullptr);
1086 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
1090 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
1091 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
1092 EXPECT_EQ(Bounds->getDirection(),
1094 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
1095 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
1156 EXPECT_EQ(Bounds->getStepInst().getName(), "inc.outer");
1160 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
1161 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
1162 EXPECT_EQ(Bounds->getDirection(),
1164 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "j");
1165 EXPECT_EQ(L->getLoopGuardBranch(), OuterGuard);
1181 EXPECT_EQ(InnerBounds->getStepInst().getName(), "inc");
1184 EXPECT_EQ(InnerBounds->getFinalIVValue().getName(), "ub");
1185 EXPECT_EQ(InnerBounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
1186 EXPECT_EQ(InnerBounds->getDirection(),
1188 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
1189 EXPECT_EQ(L->getLoopGuardBranch(), InnerGuard);
1247 EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
1251 EXPECT_EQ(Bounds->getFinalIVValue().getName(), "ub");
1252 EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SLT);
1253 EXPECT_EQ(Bounds->getDirection(),
1255 EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
1270 EXPECT_EQ(L->getLoopGuardBranch(), Guard);
1307 EXPECT_EQ(L->getLoopGuardBranch(), nullptr);
1352 EXPECT_EQ(L->getLoopLatch(), Latch);
1355 EXPECT_EQ(L->getLoopGuardBranch(), nullptr);
unittests/Analysis/MemorySSATest.cpp 145 EXPECT_EQ(MP, nullptr);
153 EXPECT_EQ(FirstLoadAccess->getDefiningAccess(), EntryStoreAccess);
179 EXPECT_EQ(MergePhi->getIncomingValue(0), EntryStoreAccess);
180 EXPECT_EQ(MergePhi->getIncomingValue(1), LeftStoreAccess);
190 EXPECT_EQ(FirstLoadAccess->getDefiningAccess(), MergePhi);
194 EXPECT_EQ(MergePhi->getIncomingValue(0), SecondEntryStoreAccess);
195 EXPECT_EQ(MergePhi->getIncomingValue(1), LeftStoreAccess);
364 EXPECT_EQ(MergePhi->getIncomingValue(1), EntryStoreAccess);
365 EXPECT_EQ(MergePhi->getIncomingValue(0), SideStoreAccess);
369 EXPECT_EQ(MergePhi->getIncomingValue(0), NewStoreAccess);
370 EXPECT_EQ(MergePhi->getIncomingValue(1), NewStoreAccess);
407 EXPECT_EQ(MergePhi->getIncomingValue(1), EntryStoreAccess);
408 EXPECT_EQ(MergePhi->getIncomingValue(0), SideStoreAccess);
412 EXPECT_EQ(MergePhi->getIncomingValue(0), SideStoreAccess);
413 EXPECT_EQ(MergePhi->getIncomingValue(1), SideStoreAccess);
451 EXPECT_EQ(MergePhi->getIncomingValue(1), EntryStoreAccess);
452 EXPECT_EQ(MergePhi->getIncomingValue(0), SideStoreAccess);
457 EXPECT_EQ(MergePhi->getIncomingValue(0), EntryStoreAccess);
458 EXPECT_EQ(MergePhi->getIncomingValue(1), EntryStoreAccess);
464 EXPECT_EQ(MergePhi->getIncomingValue(0), EntryStoreAccess);
465 EXPECT_EQ(MergePhi->getIncomingValue(1), SideStoreAccess);
469 EXPECT_EQ(MergePhi->getIncomingValue(0), EntryStoreAccess);
470 EXPECT_EQ(MergePhi->getIncomingValue(1), EntryStoreAccess);
553 EXPECT_EQ(DefiningAccess, Walker->getClobberingMemoryAccess(LoadInst));
558 EXPECT_EQ(DefiningAccess, LoadAccess->getDefiningAccess());
615 EXPECT_EQ(DefiningAccess, WalkerClobber)
641 EXPECT_EQ(LoadClobber, MSSA.getMemoryAccess(SI));
675 EXPECT_EQ(Clobber, StoreAccess);
681 EXPECT_EQ(Clobber, StoreAccess);
739 EXPECT_EQ(ALoadMA->getDefiningAccess(), MSSA.getMemoryAccess(BStore));
745 EXPECT_EQ(MSSA.getMemoryAccess(FirstStore), Load0Clobber);
752 EXPECT_EQ(BottomClobber, Phi);
757 EXPECT_EQ(UseClobber, MSSA.getMemoryAccess(FirstStore));
782 EXPECT_EQ(LoadMA->getDefiningAccess(), StoreMA);
790 EXPECT_EQ(LoadClobber, MSSA.getLiveOnEntryDef());
812 EXPECT_EQ(LoadClobber, MSSA.getMemoryAccess(SIA));
820 EXPECT_EQ(Walker->getClobberingMemoryAccess(NewLoadAccess), LoadClobber);
821 EXPECT_EQ(NewLoadAccess->getDefiningAccess(), LoadClobber);
854 EXPECT_EQ(MSSA.getMemoryAccess(StoreB)->getDefiningAccess(),
856 EXPECT_EQ(MSSA.getMemoryAccess(StoreC)->getDefiningAccess(),
858 EXPECT_EQ(MSSA.getMemoryAccess(StoreA2)->getDefiningAccess(),
860 EXPECT_EQ(Walker.getClobberingMemoryAccess(LoadB),
862 EXPECT_EQ(Walker.getClobberingMemoryAccess(LoadC),
947 EXPECT_EQ(DefB->getDefiningAccess(), MSSA.getLiveOnEntryDef());
949 EXPECT_EQ(MSSA.getWalker()->getClobberingMemoryAccess(DefB),
989 EXPECT_EQ(DefX2->getDefiningAccess(), DefY);
996 EXPECT_EQ(DefX2->getDefiningAccess(), DefY);
997 EXPECT_EQ(MSSA.getWalker()->getClobberingMemoryAccess(DefX2),
1029 EXPECT_EQ(MemUse->getOptimizedAccessType(), None)
1037 EXPECT_EQ(MemUse->getOptimizedAccessType(), MustAlias)
1067 EXPECT_EQ(MemDef->isOptimized(), false)
1069 EXPECT_EQ(MemDef->getOptimizedAccessType(), MayAlias)
1080 EXPECT_EQ(MemDef->isOptimized(), true)
1083 EXPECT_EQ(MemDef->getOptimizedAccessType(), None)
1086 EXPECT_EQ(MemDef->getOptimizedAccessType(), MustAlias)
1120 EXPECT_EQ(MemUse->getOptimizedAccessType(), MayAlias)
1128 EXPECT_EQ(MemUse->getOptimizedAccessType(), MustAlias)
1171 EXPECT_EQ(MemDef->isOptimized(), false)
1173 EXPECT_EQ(MemDef->getOptimizedAccessType(), MayAlias)
1185 EXPECT_EQ(MemDef->isOptimized(), true)
1188 EXPECT_EQ(MemDef->getOptimizedAccessType(), MayAlias)
1191 EXPECT_EQ(MemDef->getOptimizedAccessType(), None)
1194 EXPECT_EQ(MemDef->getOptimizedAccessType(), MustAlias)
1261 EXPECT_EQ(FooClobber, LifetimeStartAccess);
1265 EXPECT_EQ(BarClobber, LifetimeStartAccess);
1381 EXPECT_EQ(SortedUserList(StoreAAccess),
1384 EXPECT_EQ(SortedUserList(StoreBAccess),
1390 EXPECT_EQ(SortedUserList(cast<MemoryDef>(MSSA.getLiveOnEntryDef())),
1437 EXPECT_EQ(Phi, Walker->getClobberingMemoryAccess(S1));
1447 EXPECT_EQ(Phi, Walker->getClobberingMemoryAccess(S1));
1499 EXPECT_EQ(DefS1, Walker->getClobberingMemoryAccess(S2));
1511 EXPECT_EQ(Phi, Walker->getClobberingMemoryAccess(S2));
1584 EXPECT_EQ(MPD, MPE->getIncomingValueForBlock(DBlock));
unittests/Analysis/PhiValuesTest.cpp 57 EXPECT_EQ(Vals.size(), 2u);
61 EXPECT_EQ(Vals.size(), 2u);
69 EXPECT_EQ(Vals.size(), 2u);
73 EXPECT_EQ(Vals.size(), 2u);
81 EXPECT_EQ(Vals.size(), 2u);
133 EXPECT_EQ(Vals.size(), 2u);
137 EXPECT_EQ(Vals.size(), 2u);
141 EXPECT_EQ(Vals.size(), 3u);
150 EXPECT_EQ(Vals.size(), 2u);
154 EXPECT_EQ(Vals.size(), 2u);
158 EXPECT_EQ(Vals.size(), 3u);
167 EXPECT_EQ(Vals.size(), 2u);
171 EXPECT_EQ(Vals.size(), 2u);
175 EXPECT_EQ(Vals.size(), 2u);
183 EXPECT_EQ(Vals.size(), 2u);
187 EXPECT_EQ(Vals.size(), 2u);
191 EXPECT_EQ(Vals.size(), 3u);
202 EXPECT_EQ(Vals.size(), 2u);
206 EXPECT_EQ(Vals.size(), 2u);
unittests/Analysis/ScalarEvolutionTest.cpp 95 EXPECT_EQ(cast<SCEVConstant>(M0->getOperand(0))->getValue()->getZExtValue(),
97 EXPECT_EQ(cast<SCEVConstant>(M1->getOperand(0))->getValue()->getZExtValue(),
99 EXPECT_EQ(cast<SCEVConstant>(M2->getOperand(0))->getValue()->getZExtValue(),
103 EXPECT_EQ(cast<SCEVUnknown>(M0->getOperand(1))->getValue(), V0);
104 EXPECT_EQ(cast<SCEVUnknown>(M1->getOperand(1))->getValue(), V1);
105 EXPECT_EQ(cast<SCEVUnknown>(M2->getOperand(1))->getValue(), V2);
112 EXPECT_EQ(cast<SCEVUnknown>(M0->getOperand(1))->getValue(), V0);
113 EXPECT_EQ(cast<SCEVUnknown>(M1->getOperand(1))->getValue(), V0);
114 EXPECT_EQ(cast<SCEVUnknown>(M2->getOperand(1))->getValue(), V0);
140 EXPECT_EQ(S1, ZeroConst);
141 EXPECT_EQ(S1, S2);
206 EXPECT_EQ(cast<ConstantInt>(Gep->getOperand(1))->getSExtValue(), -1);
300 EXPECT_EQ(SE.getMulExpr(A, B), SE.getMulExpr(B, A));
301 EXPECT_EQ(SE.getMulExpr(B, C), SE.getMulExpr(C, B));
302 EXPECT_EQ(SE.getMulExpr(A, C), SE.getMulExpr(C, A));
318 EXPECT_EQ(Mul0, Mul1) << "Expected " << *Mul0 << " == " << *Mul1;
319 EXPECT_EQ(Mul1, Mul2) << "Expected " << *Mul1 << " == " << *Mul2;
320 EXPECT_EQ(Mul2, Mul3) << "Expected " << *Mul2 << " == " << *Mul3;
321 EXPECT_EQ(Mul3, Mul4) << "Expected " << *Mul3 << " == " << *Mul4;
322 EXPECT_EQ(Mul4, Mul5) << "Expected " << *Mul4 << " == " << *Mul5;
542 EXPECT_EQ(S0, D0) << *S0 << " " << *D0;
549 EXPECT_EQ(S1, D1) << *S1 << " " << *D1;
618 EXPECT_EQ(S, D) << "S = " << *S << " D = " << *D << " N = " << *N;
626 EXPECT_EQ(S, N) << "S = " << *S << " N = " << *N;
864 EXPECT_EQ(cast<SCEVConstant>(EC)->getAPInt().getLimitedValue(), 999u);
874 EXPECT_EQ(cast<SCEVConstant>(ARAtLoopExit)->getAPInt().getLimitedValue(),
888 EXPECT_EQ(cast<SCEVConstant>(NewEC)->getAPInt().getLimitedValue(), 1999u);
892 EXPECT_EQ(cast<SCEVConstant>(NewARAtLoopExit)->getAPInt().getLimitedValue(),
977 EXPECT_EQ(cast<SCEVConstant>(NewEC)->getAPInt().getLimitedValue(), 1999u);
1122 EXPECT_EQ(Expr, ZeroConst);
1445 EXPECT_EQ(AS->getExpressionSize(), 1u);
1446 EXPECT_EQ(BS->getExpressionSize(), 1u);
1447 EXPECT_EQ(CS->getExpressionSize(), 1u);
1448 EXPECT_EQ(S1S->getExpressionSize(), 3u);
1449 EXPECT_EQ(S2S->getExpressionSize(), 5u);
1491 EXPECT_EQ(CanonicalIVBitWidth, ExpectedCanonicalIVWidth);
1526 EXPECT_EQ(CanonicalIV, &GetInstByName(F, "canonical.iv"));
1560 EXPECT_EQ(NextBinOp->getOpcode(), Instruction::Add);
1561 EXPECT_EQ(NextBinOp->getOperand(0), NewCanonicalIV);
1568 EXPECT_EQ(NewCanonicalIVBitWidth, ExpectedCanonicalIVWidth);
1606 EXPECT_EQ(&CanonicalIV, Loop->getCanonicalInductionVariable());
1611 EXPECT_EQ(ARBitWidth, SE.getTypeSizeInBits(AR->getType()));
1612 EXPECT_EQ(CanonicalIVBitWidth, ARBitWidth);
1669 EXPECT_EQ(I->getOpcode(), Instruction::Shl);
1731 EXPECT_EQ(diff(ScevV3, ScevV0), 3);
1732 EXPECT_EQ(diff(ScevV0, ScevV3), -3);
1733 EXPECT_EQ(diff(ScevV0, ScevV0), 0);
1734 EXPECT_EQ(diff(ScevV3, ScevV3), 0);
1735 EXPECT_EQ(diff(ScevIV, ScevIV), 0);
1736 EXPECT_EQ(diff(ScevXA, ScevXB), 0);
1737 EXPECT_EQ(diff(ScevXA, ScevYY), -3);
1738 EXPECT_EQ(diff(ScevYY, ScevXB), 3);
1739 EXPECT_EQ(diff(ScevIV, ScevIVNext), -1);
1740 EXPECT_EQ(diff(ScevIVNext, ScevIV), 1);
1741 EXPECT_EQ(diff(ScevIVNext, ScevIVNext), 0);
1742 EXPECT_EQ(diff(ScevV0, ScevIV), None);
1743 EXPECT_EQ(diff(ScevIVNext, ScevV3), None);
1744 EXPECT_EQ(diff(ScevYY, ScevV3), None);
1789 EXPECT_EQ(AR, ExpandedAR);
1823 EXPECT_EQ(CanonicalIV, &GetInstByName(F, "canonical.iv"));
1838 EXPECT_EQ(AR, ExpandedAR);
1876 EXPECT_EQ(&CanonicalIV, Loop->getCanonicalInductionVariable());
1882 EXPECT_EQ(ARBitWidth, SE.getTypeSizeInBits(AR->getType()));
1883 EXPECT_EQ(CanonicalIVBitWidth, ARBitWidth);
1890 EXPECT_EQ(AR, ExpandedAR);
unittests/Analysis/TBAATest.cpp 80 EXPECT_EQ(GenericMD, nullptr);
unittests/Analysis/UnrollAnalyzerTest.cpp 108 EXPECT_EQ(cast<ConstantInt>((*I1).second)->getZExtValue(), 1U);
119 EXPECT_EQ(cast<ConstantInt>((*I1).second)->getZExtValue(), TripCount);
217 EXPECT_EQ(cast<ConstantInt>((*I1).second)->getZExtValue(), 5U);
220 EXPECT_EQ(cast<ConstantInt>((*I2).second)->getZExtValue(), 1U);
262 EXPECT_EQ(cast<ConstantInt>((*I1).second)->getZExtValue(), 0U);
312 EXPECT_EQ(cast<ConstantInt>((*I1).second)->getZExtValue(), 259U);
315 EXPECT_EQ(cast<ConstantInt>((*I2).second)->getZExtValue(), 259U);
318 EXPECT_EQ(cast<ConstantInt>((*I3).second)->getZExtValue(), 3U);
unittests/Analysis/ValueLatticeTest.cpp 54 EXPECT_EQ(LV1.asConstantInteger().getValue().getLimitedValue(), 1U);
60 EXPECT_EQ(LV1.getConstantRange().getLower().getLimitedValue(), 1U);
61 EXPECT_EQ(LV1.getConstantRange().getUpper().getLimitedValue(), 100U);
66 EXPECT_EQ(LV1.getConstantRange().getLower().getLimitedValue(), 1U);
67 EXPECT_EQ(LV1.getConstantRange().getUpper().getLimitedValue(), 100U);
73 EXPECT_EQ(LV1.getConstantRange().getLower().getLimitedValue(), 1U);
74 EXPECT_EQ(LV1.getConstantRange().getUpper().getLimitedValue(), 100U);
76 EXPECT_EQ(LV2.getConstantRange().getLower().getLimitedValue(), 1U);
77 EXPECT_EQ(LV2.getConstantRange().getUpper().getLimitedValue(), 100U);
117 EXPECT_EQ(LV2.getCompare(CmpInst::ICMP_SLT, I1Ty, LV3), nullptr);
118 EXPECT_EQ(LV2.getCompare(CmpInst::ICMP_SLE, I1Ty, LV3), nullptr);
119 EXPECT_EQ(LV2.getCompare(CmpInst::ICMP_NE, I1Ty, LV3), nullptr);
120 EXPECT_EQ(LV2.getCompare(CmpInst::ICMP_EQ, I1Ty, LV3), nullptr);
121 EXPECT_EQ(LV2.getCompare(CmpInst::ICMP_SGE, I1Ty, LV3), nullptr);
122 EXPECT_EQ(LV2.getCompare(CmpInst::ICMP_SGT, I1Ty, LV3), nullptr);
127 EXPECT_EQ(LV3.getCompare(CmpInst::ICMP_SLT, I1Ty, LV4), nullptr);
128 EXPECT_EQ(LV3.getCompare(CmpInst::ICMP_SLE, I1Ty, LV4), nullptr);
129 EXPECT_EQ(LV3.getCompare(CmpInst::ICMP_NE, I1Ty, LV4), nullptr);
130 EXPECT_EQ(LV3.getCompare(CmpInst::ICMP_EQ, I1Ty, LV4), nullptr);
131 EXPECT_EQ(LV3.getCompare(CmpInst::ICMP_SGE, I1Ty, LV4), nullptr);
132 EXPECT_EQ(LV3.getCompare(CmpInst::ICMP_SGT, I1Ty, LV4), nullptr);
153 EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OEQ, I1Ty, LV2), nullptr);
154 EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OGE, I1Ty, LV2), nullptr);
155 EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OLE, I1Ty, LV2), nullptr);
156 EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_ONE, I1Ty, LV2), nullptr);
157 EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OLT, I1Ty, LV2), nullptr);
158 EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OGT, I1Ty, LV2), nullptr);
unittests/Analysis/ValueTrackingTest.cpp 68 EXPECT_EQ(P.Flavor, R.Flavor);
69 EXPECT_EQ(P.NaNBehavior, R.NaNBehavior);
70 EXPECT_EQ(P.Ordered, R.Ordered);
79 EXPECT_EQ(Known.One.getZExtValue(), One);
80 EXPECT_EQ(Known.Zero.getZExtValue(), Zero);
512 EXPECT_EQ(isGuaranteedToTransferExecutionToSuccessor(&I),
525 EXPECT_EQ(ComputeNumSignBits(A, M->getDataLayout()), 1u);
535 EXPECT_EQ(ComputeNumSignBits(A, M->getDataLayout()), 1u);
547 EXPECT_EQ(ComputeNumSignBits(A, M->getDataLayout()), 1u);
947 EXPECT_EQ(GetParam().first, S.str());
unittests/Analysis/VectorFunctionABITest.cpp 50 EXPECT_EQ(VFS.Shape.Parameters.size(), (unsigned)5);
51 EXPECT_EQ(VFS.Shape.Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
52 EXPECT_EQ(VFS.Shape.Parameters[1],
54 EXPECT_EQ(VFS.Shape.Parameters[2],
56 EXPECT_EQ(VFS.Shape.Parameters[3],
58 EXPECT_EQ(VFS.Shape.Parameters[4],
70 EXPECT_EQ(A.getValue().ScalarName, "sin");
71 EXPECT_EQ(B.getValue().ScalarName, "sin");
72 EXPECT_EQ(C.getValue().ScalarName, "__sin_sin_sin");
73 EXPECT_EQ(A.getValue().VectorName, "_ZGVnM2v_sin");
74 EXPECT_EQ(B.getValue().VectorName, "UserFunc");
75 EXPECT_EQ(C.getValue().VectorName, "_ZGVnM2v___sin_sin_sin");
123 EXPECT_EQ(VF, (unsigned)2);
125 EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
127 EXPECT_EQ(Parameters.size(), (unsigned)9);
128 EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
129 EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_LinearPos, 2}));
130 EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_LinearValPos, 27}));
131 EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::OMP_LinearUValPos, 4}));
132 EXPECT_EQ(Parameters[4], VFParameter({4, VFParamKind::OMP_LinearRefPos, 5}));
133 EXPECT_EQ(Parameters[5], VFParameter({5, VFParamKind::OMP_Linear, 1}));
134 EXPECT_EQ(Parameters[6], VFParameter({6, VFParamKind::OMP_LinearVal, 10}));
135 EXPECT_EQ(Parameters[7], VFParameter({7, VFParamKind::OMP_LinearUVal, 100}));
136 EXPECT_EQ(Parameters[8], VFParameter({8, VFParamKind::OMP_LinearRef, 1000}));
137 EXPECT_EQ(ScalarName, "sin");
138 EXPECT_EQ(VectorName, "_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000_sin");
143 EXPECT_EQ(VF, (unsigned)2);
146 EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
147 EXPECT_EQ(Parameters.size(), (unsigned)1);
148 EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
149 EXPECT_EQ(ScalarName, "sin");
150 EXPECT_EQ(VectorName, "my_v_sin");
155 EXPECT_EQ(VF, (unsigned)2);
157 EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
159 EXPECT_EQ(Parameters.size(), (unsigned)4);
160 EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Linear, -1}));
161 EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_LinearVal, -10}));
162 EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_LinearUVal, -100}));
163 EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::OMP_LinearRef, -1000}));
164 EXPECT_EQ(ScalarName, "sin");
165 EXPECT_EQ(VectorName, "_ZGVnN2ln1Ln10Un100Rn1000_sin");
170 EXPECT_EQ(VF, (unsigned)0);
173 EXPECT_EQ(ISA, VFISAKind::SVE);
174 EXPECT_EQ(ScalarName, "sin");
175 EXPECT_EQ(VectorName, "_ZGVsMxv_sin");
180 EXPECT_EQ(VF, (unsigned)2);
183 EXPECT_EQ(ISA, VFISAKind::SVE);
184 EXPECT_EQ(ScalarName, "sin");
185 EXPECT_EQ(VectorName, "_ZGVsM2v_sin");
210 EXPECT_EQ(Parameters.size(), (unsigned)8);
211 EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Linear, 1}));
212 EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_LinearVal, 1}));
213 EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_LinearRef, 1}));
214 EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::OMP_LinearUVal, 1}));
215 EXPECT_EQ(Parameters[4], VFParameter({4, VFParamKind::OMP_Linear, -1}));
216 EXPECT_EQ(Parameters[5], VFParameter({5, VFParamKind::OMP_LinearVal, -1}));
217 EXPECT_EQ(Parameters[6], VFParameter({6, VFParamKind::OMP_LinearRef, -1}));
218 EXPECT_EQ(Parameters[7], VFParameter({7, VFParamKind::OMP_LinearUVal, -1}));
223 EXPECT_EQ(ISA, VFISAKind::Unknown);
226 EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
229 EXPECT_EQ(ISA, VFISAKind::SVE);
232 EXPECT_EQ(ISA, VFISAKind::SSE);
235 EXPECT_EQ(ISA, VFISAKind::AVX);
238 EXPECT_EQ(ISA, VFISAKind::AVX2);
241 EXPECT_EQ(ISA, VFISAKind::AVX512);
254 EXPECT_EQ(Parameters.size(), (unsigned)1);
255 EXPECT_EQ(Parameters[0].Alignment, Align(2));
272 EXPECT_EQ(VF, (unsigned)2);
274 EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
276 EXPECT_EQ(Parameters.size(), (unsigned)1);
277 EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Uniform, 0}));
278 EXPECT_EQ(ScalarName, "sin");
279 EXPECT_EQ(VectorName, "_ZGVnN2u0_sin");
313 EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
315 EXPECT_EQ(VectorName, "_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
319 EXPECT_EQ(ISA, VFISAKind::SVE);
321 EXPECT_EQ(VectorName, "_ZGVsN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
325 EXPECT_EQ(ISA, VFISAKind::SSE);
327 EXPECT_EQ(VectorName, "_ZGVbN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
331 EXPECT_EQ(ISA, VFISAKind::AVX);
333 EXPECT_EQ(VectorName, "_ZGVcN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
337 EXPECT_EQ(ISA, VFISAKind::AVX2);
339 EXPECT_EQ(VectorName, "_ZGVdN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
343 EXPECT_EQ(ISA, VFISAKind::AVX512);
345 EXPECT_EQ(VectorName, "_ZGVeN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
350 EXPECT_EQ(ISA, VFISAKind::Unknown);
352 EXPECT_EQ(VectorName, "_ZGVqN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
371 EXPECT_EQ(VF, (unsigned)2);
374 EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
375 EXPECT_EQ(Parameters.size(), (unsigned)2);
376 EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
377 EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
378 EXPECT_EQ(ScalarName, "sin");
383 EXPECT_EQ(VF, (unsigned)2);
386 EXPECT_EQ(ISA, VFISAKind::SVE);
387 EXPECT_EQ(Parameters.size(), (unsigned)2);
388 EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
389 EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
390 EXPECT_EQ(ScalarName, "sin");
395 EXPECT_EQ(VF, (unsigned)2);
398 EXPECT_EQ(ISA, VFISAKind::SSE);
399 EXPECT_EQ(Parameters.size(), (unsigned)2);
400 EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
401 EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
402 EXPECT_EQ(ScalarName, "sin");
407 EXPECT_EQ(VF, (unsigned)2);
410 EXPECT_EQ(ISA, VFISAKind::AVX);
411 EXPECT_EQ(Parameters.size(), (unsigned)2);
412 EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
413 EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
414 EXPECT_EQ(ScalarName, "sin");
419 EXPECT_EQ(VF, (unsigned)2);
422 EXPECT_EQ(ISA, VFISAKind::AVX2);
423 EXPECT_EQ(Parameters.size(), (unsigned)2);
424 EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
425 EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
426 EXPECT_EQ(ScalarName, "sin");
431 EXPECT_EQ(VF, (unsigned)2);
434 EXPECT_EQ(ISA, VFISAKind::AVX512);
435 EXPECT_EQ(Parameters.size(), (unsigned)2);
436 EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
437 EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
438 EXPECT_EQ(ScalarName, "sin");
unittests/Analysis/VectorUtilsTest.cpp 258 EXPECT_EQ(getSplatValue(A)->getName(), "x");
268 EXPECT_EQ(getSplatValue(A), nullptr);
280 EXPECT_EQ(getSplatValue(A), nullptr);
unittests/AsmParser/AsmParserTest.cpp 61 EXPECT_EQ(Mapping.MetadataNodes.size(), 2u);
62 EXPECT_EQ(Mapping.MetadataNodes.count(0), 1u);
63 EXPECT_EQ(Mapping.MetadataNodes.count(42), 1u);
64 EXPECT_EQ(Mapping.MetadataNodes.count(1), 0u);
106 EXPECT_EQ(Error.getMessage(), "expected type");
109 EXPECT_EQ(Error.getMessage(), "floating point constant invalid for type");
112 EXPECT_EQ(Error.getMessage(), "expected a constant value");
115 EXPECT_EQ(Error.getMessage(), "expected end of string");
unittests/BinaryFormat/DwarfTest.cpp 21 EXPECT_EQ(StringRef(), TagString(DW_TAG_invalid));
25 EXPECT_EQ(StringRef(), TagString(DW_TAG_lo_user));
26 EXPECT_EQ(StringRef(), TagString(DW_TAG_hi_user));
27 EXPECT_EQ(StringRef(), TagString(DW_TAG_user_base));
32 EXPECT_EQ(DW_TAG_array_type, getTag("DW_TAG_array_type"));
33 EXPECT_EQ(DW_TAG_module, getTag("DW_TAG_module"));
36 EXPECT_EQ(DW_TAG_invalid, getTag("DW_TAG_invalid"));
37 EXPECT_EQ(DW_TAG_invalid, getTag("DW_TAG_madeuptag"));
38 EXPECT_EQ(DW_TAG_invalid, getTag("something else"));
41 EXPECT_EQ(DW_TAG_invalid, getTag("DW_TAG_lo_user"));
42 EXPECT_EQ(DW_TAG_invalid, getTag("DW_TAG_hi_user"));
43 EXPECT_EQ(DW_TAG_invalid, getTag("DW_TAG_user_base"));
48 EXPECT_EQ(DW_OP_deref, getOperationEncoding("DW_OP_deref"));
49 EXPECT_EQ(DW_OP_bit_piece, getOperationEncoding("DW_OP_bit_piece"));
52 EXPECT_EQ(0u, getOperationEncoding("DW_OP_otherthings"));
53 EXPECT_EQ(0u, getOperationEncoding("other"));
56 EXPECT_EQ(0u, getOperationEncoding("DW_OP_lo_user"));
57 EXPECT_EQ(0u, getOperationEncoding("DW_OP_hi_user"));
62 EXPECT_EQ(StringRef(), LanguageString(0));
66 EXPECT_EQ(StringRef(), LanguageString(DW_LANG_lo_user));
67 EXPECT_EQ(StringRef(), LanguageString(DW_LANG_hi_user));
72 EXPECT_EQ(DW_LANG_C89, getLanguage("DW_LANG_C89"));
73 EXPECT_EQ(DW_LANG_C_plus_plus_11, getLanguage("DW_LANG_C_plus_plus_11"));
74 EXPECT_EQ(DW_LANG_OCaml, getLanguage("DW_LANG_OCaml"));
75 EXPECT_EQ(DW_LANG_Mips_Assembler, getLanguage("DW_LANG_Mips_Assembler"));
78 EXPECT_EQ(0u, getLanguage("DW_LANG_invalid"));
79 EXPECT_EQ(0u, getLanguage("DW_TAG_array_type"));
80 EXPECT_EQ(0u, getLanguage("something else"));
83 EXPECT_EQ(0u, getLanguage("DW_LANG_lo_user"));
84 EXPECT_EQ(0u, getLanguage("DW_LANG_hi_user"));
89 EXPECT_EQ(StringRef(), AttributeEncodingString(0));
93 EXPECT_EQ(StringRef(), AttributeEncodingString(DW_ATE_lo_user));
94 EXPECT_EQ(StringRef(), AttributeEncodingString(DW_ATE_hi_user));
99 EXPECT_EQ(DW_ATE_boolean, getAttributeEncoding("DW_ATE_boolean"));
100 EXPECT_EQ(DW_ATE_imaginary_float,
104 EXPECT_EQ(0u, getAttributeEncoding("DW_ATE_invalid"));
105 EXPECT_EQ(0u, getAttributeEncoding("DW_TAG_array_type"));
106 EXPECT_EQ(0u, getAttributeEncoding("something else"));
109 EXPECT_EQ(0u, getAttributeEncoding("DW_ATE_lo_user"));
110 EXPECT_EQ(0u, getAttributeEncoding("DW_ATE_hi_user"));
114 EXPECT_EQ(StringRef("DW_VIRTUALITY_none"),
116 EXPECT_EQ(StringRef("DW_VIRTUALITY_virtual"),
118 EXPECT_EQ(StringRef("DW_VIRTUALITY_pure_virtual"),
122 EXPECT_EQ(StringRef("DW_VIRTUALITY_pure_virtual"),
126 EXPECT_EQ(StringRef(), VirtualityString(DW_VIRTUALITY_max + 1));
127 EXPECT_EQ(StringRef(), VirtualityString(DW_VIRTUALITY_max + 77));
131 EXPECT_EQ(DW_VIRTUALITY_none, getVirtuality("DW_VIRTUALITY_none"));
132 EXPECT_EQ(DW_VIRTUALITY_virtual, getVirtuality("DW_VIRTUALITY_virtual"));
133 EXPECT_EQ(DW_VIRTUALITY_pure_virtual,
137 EXPECT_EQ(DW_VIRTUALITY_invalid, getVirtuality("DW_VIRTUALITY_invalid"));
138 EXPECT_EQ(DW_VIRTUALITY_invalid, getVirtuality("DW_VIRTUALITY_max"));
139 EXPECT_EQ(DW_VIRTUALITY_invalid, getVirtuality("something else"));
152 EXPECT_EQ(*RefSize, *AddrSize);
160 EXPECT_EQ(*RefSize, *AddrSize);
166 EXPECT_EQ(*RefSize, 4);
171 EXPECT_EQ(*RefSize, 4);
176 EXPECT_EQ(*RefSize, 4);
182 EXPECT_EQ(*RefSize, 8);
187 EXPECT_EQ(*RefSize, 8);
192 EXPECT_EQ(*RefSize, 8);
196 EXPECT_EQ("DW_AT_name", formatv("{0}", DW_AT_name).str());
197 EXPECT_EQ("DW_AT_unknown_3fff", formatv("{0}", DW_AT_hi_user).str());
198 EXPECT_EQ("DW_FORM_addr", formatv("{0}", DW_FORM_addr).str());
199 EXPECT_EQ("DW_FORM_unknown_1f00", formatv("{0}", DW_FORM_lo_user).str());
200 EXPECT_EQ("DW_IDX_compile_unit", formatv("{0}", DW_IDX_compile_unit).str());
201 EXPECT_EQ("DW_IDX_unknown_3fff", formatv("{0}", DW_IDX_hi_user).str());
202 EXPECT_EQ("DW_TAG_compile_unit", formatv("{0}", DW_TAG_compile_unit).str());
203 EXPECT_EQ("DW_TAG_unknown_ffff", formatv("{0}", DW_TAG_hi_user).str());
unittests/BinaryFormat/MsgPackReaderTest.cpp 28 EXPECT_EQ(Obj.Kind, Type::Nil);
34 EXPECT_EQ(Obj.Kind, Type::Boolean);
35 EXPECT_EQ(Obj.Bool, false);
50 EXPECT_EQ(Obj.Kind, Type::Nil);
59 EXPECT_EQ(Obj.Kind, Type::Boolean);
60 EXPECT_EQ(Obj.Bool, false);
69 EXPECT_EQ(Obj.Kind, Type::Boolean);
70 EXPECT_EQ(Obj.Bool, true);
84 EXPECT_EQ(Obj.Kind, Type::Int);
85 EXPECT_EQ(Obj.Int, i);
95 EXPECT_EQ(Obj.Kind, Type::Int);
96 EXPECT_EQ(Obj.Int, INT8_MAX);
105 EXPECT_EQ(Obj.Kind, Type::Int);
106 EXPECT_EQ(Obj.Int, 0);
115 EXPECT_EQ(Obj.Kind, Type::Int);
116 EXPECT_EQ(Obj.Int, INT8_MIN);
125 EXPECT_EQ(Obj.Kind, Type::Int);
126 EXPECT_EQ(Obj.Int, INT16_MAX);
135 EXPECT_EQ(Obj.Kind, Type::Int);
136 EXPECT_EQ(Obj.Int, 0);
145 EXPECT_EQ(Obj.Kind, Type::Int);
146 EXPECT_EQ(Obj.Int, INT16_MIN);
155 EXPECT_EQ(Obj.Kind, Type::Int);
156 EXPECT_EQ(Obj.Int, INT32_MAX);
165 EXPECT_EQ(Obj.Kind, Type::Int);
166 EXPECT_EQ(Obj.Int, 0);
175 EXPECT_EQ(Obj.Kind, Type::Int);
176 EXPECT_EQ(Obj.Int, INT32_MIN);
185 EXPECT_EQ(Obj.Kind, Type::Int);
186 EXPECT_EQ(Obj.Int, INT64_MAX);
195 EXPECT_EQ(Obj.Kind, Type::Int);
196 EXPECT_EQ(Obj.Int, 0);
205 EXPECT_EQ(Obj.Kind, Type::Int);
206 EXPECT_EQ(Obj.Int, INT64_MIN);
218 EXPECT_EQ(Obj.Kind, Type::UInt);
219 EXPECT_EQ(Obj.UInt, u);
229 EXPECT_EQ(Obj.Kind, Type::UInt);
230 EXPECT_EQ(Obj.UInt, 0u);
239 EXPECT_EQ(Obj.Kind, Type::UInt);
240 EXPECT_EQ(Obj.UInt, 1u);
249 EXPECT_EQ(Obj.Kind, Type::UInt);
250 EXPECT_EQ(Obj.UInt, static_cast<uint8_t>(UINT8_MAX));
259 EXPECT_EQ(Obj.Kind, Type::UInt);
260 EXPECT_EQ(Obj.UInt, 0u);
269 EXPECT_EQ(Obj.Kind, Type::UInt);
270 EXPECT_EQ(Obj.UInt, 1u);
279 EXPECT_EQ(Obj.Kind, Type::UInt);
280 EXPECT_EQ(Obj.UInt, static_cast<uint16_t>(UINT16_MAX));
289 EXPECT_EQ(Obj.Kind, Type::UInt);
290 EXPECT_EQ(Obj.UInt, 0u);
299 EXPECT_EQ(Obj.Kind, Type::UInt);
300 EXPECT_EQ(Obj.UInt, 1u);
309 EXPECT_EQ(Obj.Kind, Type::UInt);
310 EXPECT_EQ(Obj.UInt, static_cast<uint32_t>(UINT32_MAX));
319 EXPECT_EQ(Obj.Kind, Type::UInt);
320 EXPECT_EQ(Obj.UInt, 0u);
329 EXPECT_EQ(Obj.Kind, Type::UInt);
330 EXPECT_EQ(Obj.UInt, 1u);
339 EXPECT_EQ(Obj.Kind, Type::UInt);
340 EXPECT_EQ(Obj.UInt, static_cast<uint64_t>(UINT64_MAX));
349 EXPECT_EQ(Obj.Kind, Type::Float);
350 EXPECT_EQ(Obj.Float, -3.6973142664068907e+28f);
359 EXPECT_EQ(Obj.Kind, Type::Float);
360 EXPECT_EQ(Obj.Float, -2.2899894549927042e+226);
369 EXPECT_EQ(Obj.Kind, Type::String);
370 EXPECT_EQ(Obj.Raw, StringRef());
380 EXPECT_EQ(Obj.Kind, Type::String);
381 EXPECT_EQ(Obj.Raw, Result);
392 EXPECT_EQ(Obj.Kind, Type::String);
393 EXPECT_EQ(Obj.Raw, Result);
402 EXPECT_EQ(Obj.Kind, Type::String);
403 EXPECT_EQ(Obj.Raw, StringRef());
413 EXPECT_EQ(Obj.Kind, Type::String);
414 EXPECT_EQ(Obj.Raw, Result);
424 EXPECT_EQ(Obj.Kind, Type::String);
425 EXPECT_EQ(Obj.Raw, Result);
434 EXPECT_EQ(Obj.Kind, Type::String);
435 EXPECT_EQ(Obj.Raw, StringRef());
445 EXPECT_EQ(Obj.Kind, Type::String);
446 EXPECT_EQ(Obj.Raw, Result);
456 EXPECT_EQ(Obj.Kind, Type::String);
457 EXPECT_EQ(Obj.Raw, Result);
466 EXPECT_EQ(Obj.Kind, Type::String);
467 EXPECT_EQ(Obj.Raw, StringRef());
477 EXPECT_EQ(Obj.Kind, Type::String);
478 EXPECT_EQ(Obj.Raw, Result);
488 EXPECT_EQ(Obj.Kind, Type::String);
489 EXPECT_EQ(Obj.Raw, Result);
498 EXPECT_EQ(Obj.Kind, Type::Binary);
499 EXPECT_EQ(Obj.Raw, StringRef());
509 EXPECT_EQ(Obj.Kind, Type::Binary);
510 EXPECT_EQ(Obj.Raw, Result);
520 EXPECT_EQ(Obj.Kind, Type::Binary);
521 EXPECT_EQ(Obj.Raw, Result);
530 EXPECT_EQ(Obj.Kind, Type::Binary);
531 EXPECT_EQ(Obj.Raw, StringRef());
541 EXPECT_EQ(Obj.Kind, Type::Binary);
542 EXPECT_EQ(Obj.Raw, Result);
552 EXPECT_EQ(Obj.Kind, Type::Binary);
553 EXPECT_EQ(Obj.Raw, Result);
562 EXPECT_EQ(Obj.Kind, Type::Binary);
563 EXPECT_EQ(Obj.Raw, StringRef());
573 EXPECT_EQ(Obj.Kind, Type::Binary);
574 EXPECT_EQ(Obj.Raw, Result);
584 EXPECT_EQ(Obj.Kind, Type::Binary);
585 EXPECT_EQ(Obj.Raw, Result);
594 EXPECT_EQ(Obj.Kind, Type::Array);
595 EXPECT_EQ(Obj.Length, 0u);
604 EXPECT_EQ(Obj.Kind, Type::Array);
605 EXPECT_EQ(Obj.Length, 1u);
614 EXPECT_EQ(Obj.Kind, Type::Array);
616 EXPECT_EQ(Obj.Length, 15u);
625 EXPECT_EQ(Obj.Kind, Type::Array);
626 EXPECT_EQ(Obj.Length, 0u);
635 EXPECT_EQ(Obj.Kind, Type::Array);
636 EXPECT_EQ(Obj.Length, 1u);
645 EXPECT_EQ(Obj.Kind, Type::Array);
646 EXPECT_EQ(Obj.Length, static_cast<uint16_t>(UINT16_MAX));
655 EXPECT_EQ(Obj.Kind, Type::Array);
656 EXPECT_EQ(Obj.Length, 0u);
665 EXPECT_EQ(Obj.Kind, Type::Array);
666 EXPECT_EQ(Obj.Length, 1u);
675 EXPECT_EQ(Obj.Kind, Type::Array);
676 EXPECT_EQ(Obj.Length, static_cast<uint32_t>(UINT32_MAX));
685 EXPECT_EQ(Obj.Kind, Type::Map);
686 EXPECT_EQ(Obj.Length, 0u);
695 EXPECT_EQ(Obj.Kind, Type::Map);
696 EXPECT_EQ(Obj.Length, 1u);
705 EXPECT_EQ(Obj.Kind, Type::Map);
707 EXPECT_EQ(Obj.Length, 15u);
716 EXPECT_EQ(Obj.Kind, Type::Map);
717 EXPECT_EQ(Obj.Length, 0u);
726 EXPECT_EQ(Obj.Kind, Type::Map);
727 EXPECT_EQ(Obj.Length, 1u);
736 EXPECT_EQ(Obj.Kind, Type::Map);
737 EXPECT_EQ(Obj.Length, static_cast<uint16_t>(UINT16_MAX));
746 EXPECT_EQ(Obj.Kind, Type::Map);
747 EXPECT_EQ(Obj.Length, 0u);
756 EXPECT_EQ(Obj.Kind, Type::Map);
757 EXPECT_EQ(Obj.Length, 1u);
766 EXPECT_EQ(Obj.Kind, Type::Map);
767 EXPECT_EQ(Obj.Length, static_cast<uint32_t>(UINT32_MAX));
779 EXPECT_EQ(Obj.Kind, Type::Extension);
780 EXPECT_EQ(Obj.Extension.Type, 0x01);
781 EXPECT_EQ(Obj.Extension.Bytes, Result);
791 EXPECT_EQ(Obj.Kind, Type::Extension);
792 EXPECT_EQ(Obj.Extension.Type, 0x01);
793 EXPECT_EQ(Obj.Extension.Bytes, Result);
803 EXPECT_EQ(Obj.Kind, Type::Extension);
804 EXPECT_EQ(Obj.Extension.Type, 0x01);
805 EXPECT_EQ(Obj.Extension.Bytes, Result);
815 EXPECT_EQ(Obj.Kind, Type::Extension);
816 EXPECT_EQ(Obj.Extension.Type, 0x01);
817 EXPECT_EQ(Obj.Extension.Bytes, Result);
827 EXPECT_EQ(Obj.Kind, Type::Extension);
828 EXPECT_EQ(Obj.Extension.Type, 0x01);
829 EXPECT_EQ(Obj.Extension.Bytes, Result);
839 EXPECT_EQ(Obj.Kind, Type::Extension);
840 EXPECT_EQ(Obj.Extension.Type, 0x01);
841 EXPECT_EQ(Obj.Extension.Bytes, StringRef());
851 EXPECT_EQ(Obj.Kind, Type::Extension);
852 EXPECT_EQ(Obj.Extension.Type, 0x01);
853 EXPECT_EQ(Obj.Extension.Bytes, Result);
863 EXPECT_EQ(Obj.Kind, Type::Extension);
864 EXPECT_EQ(Obj.Extension.Type, 0x01);
865 EXPECT_EQ(Obj.Extension.Bytes, Result);
875 EXPECT_EQ(Obj.Kind, Type::Extension);
876 EXPECT_EQ(Obj.Extension.Type, 0x01);
877 EXPECT_EQ(Obj.Extension.Bytes, Result);
887 EXPECT_EQ(Obj.Kind, Type::Extension);
888 EXPECT_EQ(Obj.Extension.Type, 0x01);
889 EXPECT_EQ(Obj.Extension.Bytes, Result);
unittests/BinaryFormat/MsgPackWriterTest.cpp 26 EXPECT_EQ(OStream.str(), "\xc0");
32 EXPECT_EQ(OStream.str(), "\xc3\xc2");
42 EXPECT_EQ(Output.size(), 1u);
43 EXPECT_EQ(Output.data()[0], static_cast<uint8_t>(u));
51 EXPECT_EQ(OStream.str(), "\xcc\x80");
57 EXPECT_EQ(OStream.str(), "\xcc\xdd");
63 EXPECT_EQ(OStream.str(), "\xcc\xff");
69 EXPECT_EQ(OStream.str(), std::string("\xcd\x01\x00", 3));
75 EXPECT_EQ(OStream.str(), "\xcd\xab\xcd");
81 EXPECT_EQ(OStream.str(), "\xcd\xff\xff");
87 EXPECT_EQ(OStream.str(), std::string("\xce\x00\x01\x00\x00", 5));
93 EXPECT_EQ(OStream.str(), "\xce\xab\xcd\xef\xba");
99 EXPECT_EQ(OStream.str(), "\xce\xff\xff\xff\xff");
105 EXPECT_EQ(OStream.str(),
112 EXPECT_EQ(OStream.str(), "\xcf\x01\x02\x03\x04\x05\x06\x07\x4a");
118 EXPECT_EQ(OStream.str(), "\xcf\xff\xff\xff\xff\xff\xff\xff\xff");
130 EXPECT_EQ(Output.size(), 1u);
131 EXPECT_EQ(static_cast<int8_t>(Output.data()[0]), static_cast<int8_t>(i));
139 EXPECT_EQ(OStream.str(), "\xd0\xdf");
145 EXPECT_EQ(OStream.str(), "\xd0\xd8");
151 EXPECT_EQ(OStream.str(), "\xd0\x80");
157 EXPECT_EQ(OStream.str(), "\xd1\xff\x7f");
163 EXPECT_EQ(OStream.str(), "\xd1\xee\xef");
169 EXPECT_EQ(OStream.str(), std::string("\xd1\x80\x00", 3));
175 EXPECT_EQ(OStream.str(), "\xd2\xff\xff\x7f\xff");
181 EXPECT_EQ(OStream.str(), "\xd2\xee\xee\xee\xef");
187 EXPECT_EQ(OStream.str(), std::string("\xd2\x80\x00\x00\x00", 5));
193 EXPECT_EQ(OStream.str(), "\xd3\xff\xff\xff\xff\x7f\xff\xff\xff");
199 EXPECT_EQ(OStream.str(), "\xd3\xee\xee\xee\xee\xee\xee\xee\xef");
205 EXPECT_EQ(OStream.str(),
212 EXPECT_EQ(OStream.str(), "\xca\xee\xee\xee\xef");
218 EXPECT_EQ(OStream.str(), "\xcb\xee\xee\xee\xee\xee\xee\xee\xef");
224 EXPECT_EQ(OStream.str(), "\xa0");
230 EXPECT_EQ(OStream.str(), "\xa3"
238 EXPECT_EQ(OStream.str(), std::string("\xbf") + s);
245 EXPECT_EQ(OStream.str(), std::string("\xd9\x20") + s);
251 EXPECT_EQ(OStream.str(), std::string("\xd9\x21") + s);
257 EXPECT_EQ(OStream.str(), std::string("\xd9\xff") + s);
263 EXPECT_EQ(OStream.str(), std::string("\xda\x01\x00", 3) + s);
269 EXPECT_EQ(OStream.str(), std::string("\xda\x01\xff") + s);
275 EXPECT_EQ(OStream.str(), std::string("\xda\xff\xff") + s);
281 EXPECT_EQ(OStream.str(), std::string("\xdb\x00\x01\x00\x00", 5) + s);
287 EXPECT_EQ(OStream.str(), std::string("\xdb\x00\x01\xff\xff", 5) + s);
293 EXPECT_EQ(OStream.str(), std::string("\xc4\x00", 2) + s);
299 EXPECT_EQ(OStream.str(), std::string("\xc4\x05") + s);
305 EXPECT_EQ(OStream.str(), std::string("\xc4\xff") + s);
311 EXPECT_EQ(OStream.str(), std::string("\xc5\x01\x00", 3) + s);
317 EXPECT_EQ(OStream.str(), "\xc5\x01\xff" + s);
323 EXPECT_EQ(OStream.str(), std::string("\xc5\xff\xff") + s);
329 EXPECT_EQ(OStream.str(), std::string("\xc6\x00\x01\x00\x00", 5) + s);
335 EXPECT_EQ(OStream.str(), std::string("\xc6\x00\x01\xff\xff", 5) + s);
340 EXPECT_EQ(OStream.str(), "\x90");
345 EXPECT_EQ(OStream.str(), "\x94");
351 EXPECT_EQ(OStream.str(), "\x9f");
357 EXPECT_EQ(OStream.str(), std::string("\xdc\x00\x10", 3));
362 EXPECT_EQ(OStream.str(), "\xdc\x01\x11");
367 EXPECT_EQ(OStream.str(), "\xdc\xff\xff");
372 EXPECT_EQ(OStream.str(), std::string("\xdd\x00\x01\x00\x00", 5));
377 EXPECT_EQ(OStream.str(), std::string("\xdd\x00\x01\xff\xff", 5));
382 EXPECT_EQ(OStream.str(), "\xdd\xff\xff\xff\xff");
387 EXPECT_EQ(OStream.str(), "\x80");
392 EXPECT_EQ(OStream.str(), "\x84");
398 EXPECT_EQ(OStream.str(), "\x8f");
404 EXPECT_EQ(OStream.str(), std::string("\xde\x00\x10", 3));
409 EXPECT_EQ(OStream.str(), "\xde\x01\x11");
414 EXPECT_EQ(OStream.str(), "\xde\xff\xff");
419 EXPECT_EQ(OStream.str(), std::string("\xdf\x00\x01\x00\x00", 5));
424 EXPECT_EQ(OStream.str(), std::string("\xdf\x00\x01\xff\xff", 5));
429 EXPECT_EQ(OStream.str(), std::string("\xdf\xff\xff\xff\xff", 5));
437 EXPECT_EQ(OStream.str(), std::string("\xd4\x01") + s);
443 EXPECT_EQ(OStream.str(), std::string("\xd5\x01") + s);
449 EXPECT_EQ(OStream.str(), std::string("\xd6\x01") + s);
455 EXPECT_EQ(OStream.str(), std::string("\xd7\x01") + s);
461 EXPECT_EQ(OStream.str(), std::string("\xd8\x01") + s);
467 EXPECT_EQ(OStream.str(), std::string("\xc7\x00\x01", 3) + s);
473 EXPECT_EQ(OStream.str(), std::string("\xc7\x2a\x01") + s);
479 EXPECT_EQ(OStream.str(), std::string("\xc7\xff\x01") + s);
485 EXPECT_EQ(OStream.str(), std::string("\xc8\x01\x00\x02", 4) + s);
491 EXPECT_EQ(OStream.str(), std::string("\xc8\x01\x11\x01") + s);
497 EXPECT_EQ(OStream.str(), std::string("\xc8\xff\xff\x01") + s);
503 EXPECT_EQ(OStream.str(), std::string("\xc9\x00\x01\x00\x00\x02", 6) + s);
510 EXPECT_EQ(OStream.str(), std::string("\xda\x00\x20", 3) + s);
unittests/BinaryFormat/TestFileMagic.cpp 136 EXPECT_EQ(i->magic, identify_magic(magic));
unittests/Bitcode/DataLayoutUpgradeTest.cpp 24 EXPECT_EQ(DL1, "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64"
26 EXPECT_EQ(DL2, "e-m:w-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64"
28 EXPECT_EQ(DL3, "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128"
43 EXPECT_EQ(DL1, "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64"
46 EXPECT_EQ(DL2, "e-p:32:32");
47 EXPECT_EQ(DL3, "e-m:e-i64:64-n32:64");
48 EXPECT_EQ(DL4, "e-m:o-i64:64-i128:128-n32:64-S128");
55 EXPECT_EQ(DL1, "");
56 EXPECT_EQ(DL2, "e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128");
unittests/Bitstream/BitstreamReaderTest.cpp 60 EXPECT_EQ(I / 8, Cursor.getCurrentByteNo());
64 EXPECT_EQ(4u, Cursor.getCurrentByteNo());
72 EXPECT_EQ(Bytes + I, Cursor.getPointerToByte(I, 1));
81 EXPECT_EQ(Bytes + I, Cursor.getPointerToBit(I * 8, 1));
150 EXPECT_EQ(BlobIn, BlobOut);
160 EXPECT_EQ(8ull, MaybeRead.get());
unittests/Bitstream/BitstreamWriterTest.cpp 22 EXPECT_EQ(StringRef("str\0", 4), Buffer);
41 EXPECT_EQ(StringRef(Expected), Buffer);
48 EXPECT_EQ(StringRef(""), Buffer);
55 EXPECT_EQ(StringRef("str0"), Buffer);
unittests/CodeGen/AArch64SelectionDAGTest.cpp 121 EXPECT_EQ(DAG->ComputeNumSignBits(Op, DemandedElts), 15u);
135 EXPECT_EQ(DAG->ComputeNumSignBits(Op, DemandedElts), 7u);
155 EXPECT_EQ(TL.SimplifyDemandedVectorElts(Op, DemandedElts, KnownUndef,
177 EXPECT_EQ(Known.Zero, APInt(8, 0x20));
178 EXPECT_EQ(Known.One, APInt(8, 0x55));
198 EXPECT_EQ(Known.Zero, APInt(8, 0x80));
199 EXPECT_EQ(Known.One, APInt(8, 0x1));
unittests/CodeGen/GlobalISel/CSETest.cpp 34 EXPECT_EQ(MIBAddCopy->getOpcode(), TargetOpcode::COPY);
62 EXPECT_EQ(TargetOpcode::G_BUILD_VECTOR, Splat0->getOpcode());
63 EXPECT_EQ(Splat0->getOperand(1).getReg(), Splat0->getOperand(2).getReg());
64 EXPECT_EQ(&*MIBCst, MRI->getVRegDef(Splat0->getOperand(1).getReg()));
67 EXPECT_EQ(TargetOpcode::G_BUILD_VECTOR, FSplat->getOpcode());
68 EXPECT_EQ(FSplat->getOperand(1).getReg(), FSplat->getOperand(2).getReg());
69 EXPECT_EQ(&*MIBFP0, MRI->getVRegDef(FSplat->getOperand(1).getReg()));
unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp 33 EXPECT_EQ(Cst, 1);
40 EXPECT_EQ(Cst, 1);
52 EXPECT_EQ(Cst, 0);
60 EXPECT_EQ(1, Cst);
68 EXPECT_EQ(-0x80, Cst);
87 EXPECT_EQ(25ULL, FoldGAddInt.getValue().getLimitedValue());
92 EXPECT_EQ(1073741840ULL, FoldGAddMix.getValue().getLimitedValue());
99 EXPECT_EQ(0ULL, FoldGAndInt.getValue().getLimitedValue());
104 EXPECT_EQ(1ULL, FoldGAndMix.getValue().getLimitedValue());
111 EXPECT_EQ(0ULL, FoldGAShrInt.getValue().getLimitedValue());
116 EXPECT_EQ(2097152ULL, FoldGAShrMix.getValue().getLimitedValue());
123 EXPECT_EQ(0ULL, FoldGLShrInt.getValue().getLimitedValue());
128 EXPECT_EQ(2080768ULL, FoldGLShrMix.getValue().getLimitedValue());
135 EXPECT_EQ(144ULL, FoldGMulInt.getValue().getLimitedValue());
140 EXPECT_EQ(0ULL, FoldGMulMix.getValue().getLimitedValue());
147 EXPECT_EQ(25ULL, FoldGOrInt.getValue().getLimitedValue());
152 EXPECT_EQ(1073741840ULL, FoldGOrMix.getValue().getLimitedValue());
159 EXPECT_EQ(8192ULL, FoldGShlInt.getValue().getLimitedValue());
164 EXPECT_EQ(0ULL, FoldGShlMix.getValue().getLimitedValue());
171 EXPECT_EQ(7ULL, FoldGSubInt.getValue().getLimitedValue());
176 EXPECT_EQ(3221225488ULL, FoldGSubMix.getValue().getLimitedValue());
183 EXPECT_EQ(25ULL, FoldGXorInt.getValue().getLimitedValue());
188 EXPECT_EQ(1073741840ULL, FoldGXorMix.getValue().getLimitedValue());
195 EXPECT_EQ(1ULL, FoldGUdivInt.getValue().getLimitedValue());
200 EXPECT_EQ(0ULL, FoldGUdivMix.getValue().getLimitedValue());
207 EXPECT_EQ(1ULL, FoldGSdivInt.getValue().getLimitedValue());
212 EXPECT_EQ(0ULL, FoldGSdivMix.getValue().getLimitedValue());
219 EXPECT_EQ(1ULL, FoldGUremInt.getValue().getLimitedValue());
224 EXPECT_EQ(0ULL, FoldGUremMix.getValue().getLimitedValue());
231 EXPECT_EQ(7ULL, FoldGSremInt.getValue().getLimitedValue());
236 EXPECT_EQ(16ULL, FoldGSremMix.getValue().getLimitedValue());
unittests/CodeGen/GlobalISel/KnownBitsTest.cpp 25 EXPECT_EQ((uint64_t)1, Res.One.getZExtValue());
26 EXPECT_EQ((uint64_t)0xfe, Res.Zero.getZExtValue());
29 EXPECT_EQ(Res.One.getZExtValue(), Res2.One.getZExtValue());
30 EXPECT_EQ(Res.Zero.getZExtValue(), Res2.Zero.getZExtValue());
47 EXPECT_EQ((uint64_t)1, Res.getBitWidth());
48 EXPECT_EQ((uint64_t)0, Res.One.getZExtValue());
49 EXPECT_EQ((uint64_t)0, Res.Zero.getZExtValue());
54 EXPECT_EQ((uint64_t)32, Res2.getBitWidth());
55 EXPECT_EQ(Res.One.getZExtValue(), Res2.One.getZExtValue());
56 EXPECT_EQ(Res.Zero.getZExtValue(), Res2.Zero.getZExtValue());
72 EXPECT_EQ(256u, Res.One.getZExtValue());
73 EXPECT_EQ(0xfffffeffu, Res.Zero.getZExtValue());
88 EXPECT_EQ(3u, Res.One.getZExtValue());
89 EXPECT_EQ(252u, Res.Zero.getZExtValue());
116 EXPECT_EQ(0u, Known.One.getZExtValue());
117 EXPECT_EQ(31u, Known.Zero.getZExtValue());
119 EXPECT_EQ(Known.Zero, Zeroes);
unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp 143 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
176 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
640 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
720 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
780 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
782 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
825 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
827 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
829 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
831 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
834 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
836 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
838 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
840 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
899 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
901 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
968 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
970 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
974 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
1042 EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp 62 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(8)}}),
64 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(16)}}),
66 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(32)}}),
68 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(64)}}),
72 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(128)}}),
75 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(1)}}),
77 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(31)}}),
79 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(33)}}),
81 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(63)}}),
83 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(65)}}),
108 EXPECT_EQ(L.getAction({G_ADD, {LLT::vector(8, 8)}}),
110 EXPECT_EQ(L.getAction({G_ADD, {LLT::vector(8, 7)}}),
112 EXPECT_EQ(L.getAction({G_ADD, {LLT::vector(2, 8)}}),
114 EXPECT_EQ(L.getAction({G_ADD, {LLT::vector(8, 32)}}),
117 EXPECT_EQ(L.getAction({G_ADD, {LLT::vector(3, 3)}}),
119 EXPECT_EQ(L.getAction({G_ADD, {LLT::vector(3, 8)}}),
139 EXPECT_EQ(L.getAction({G_PTRTOINT, {s64, p0}}),
143 EXPECT_EQ(
146 EXPECT_EQ(
164 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(16)}}),
166 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(32)}}),
182 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(Size)}}),
185 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(2)}}),
187 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(7)}}),
189 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(9)}}),
191 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(17)}}),
193 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(31)}}),
195 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(33)}}),
unittests/CodeGen/GlobalISel/PatternMatchTest.cpp 41 EXPECT_EQ(Cst, 42);
58 EXPECT_EQ(Src0, Copies[0]);
59 EXPECT_EQ(Src1, Copies[1]);
68 EXPECT_EQ(Src0, MIBAdd->getOperand(0).getReg());
69 EXPECT_EQ(Src1, Copies[2]);
75 EXPECT_EQ(Src0, Copies[0]);
76 EXPECT_EQ(Src1, Copies[1]);
77 EXPECT_EQ(Src2, Copies[2]);
87 EXPECT_EQ(Cst, 42);
88 EXPECT_EQ(Src0, Copies[0]);
102 EXPECT_EQ(Cst, 42);
103 EXPECT_EQ(Src0, Copies[0]);
111 EXPECT_EQ(Src0, Copies[0]);
119 EXPECT_EQ(Src0, Copies[0]);
120 EXPECT_EQ(Src1, Copies[1]);
128 EXPECT_EQ(Src0, Copies[0]);
129 EXPECT_EQ(Src1, Copies[1]);
151 EXPECT_EQ(Src, Copy0s32->getOperand(0).getReg());
155 EXPECT_EQ(Src, Copy0s32->getOperand(0).getReg());
165 EXPECT_EQ(CFP, TmpFP);
176 EXPECT_EQ(CFP64, TmpFP64);
190 EXPECT_EQ(TmpFP16, CFP16);
210 EXPECT_EQ(Src0, Copies[0]);
214 EXPECT_EQ(Src0, MIBTrunc->getOperand(0).getReg());
218 EXPECT_EQ(Src0, MIBTrunc->getOperand(0).getReg());
222 EXPECT_EQ(Src0, MIBTrunc->getOperand(0).getReg());
228 EXPECT_EQ(Src0, Copies[0]);
233 EXPECT_EQ(Src0, Copies[0]);
238 EXPECT_EQ(Src0, Copies[0]);
275 EXPECT_EQ(Src0, Copies[0]);
291 EXPECT_EQ(Src0, Copies[0]);
292 EXPECT_EQ(Src1, Copies[1]);
302 EXPECT_EQ(Src0, Copies[0]);
303 EXPECT_EQ(Src1, Copies[1]);
unittests/CodeGen/LowLevelTypeTest.cpp 35 EXPECT_EQ(S, Ty.getSizeInBits());
36 EXPECT_EQ(S, Ty.getScalarSizeInBits());
44 EXPECT_EQ(Ty, getLLTForType(*IRTy, DL));
60 EXPECT_EQ(VTy, VSTy);
64 EXPECT_EQ(STy, VTy.getElementType());
74 EXPECT_EQ(S * Elts, VTy.getSizeInBits());
75 EXPECT_EQ(S, VTy.getScalarSizeInBits());
76 EXPECT_EQ(Elts, VTy.getNumElements());
89 EXPECT_EQ(VTy, getLLTForType(*IRTy, DL));
96 EXPECT_EQ(LLT::scalar(32), LLT::scalarOrVector(1, 32));
97 EXPECT_EQ(LLT::vector(2, 32), LLT::scalarOrVector(2, 32));
100 EXPECT_EQ(LLT::scalar(32), LLT::scalarOrVector(1, LLT::scalar(32)));
101 EXPECT_EQ(LLT::vector(2, 32), LLT::scalarOrVector(2, LLT::scalar(32)));
104 EXPECT_EQ(LLT::pointer(1, 32), LLT::scalarOrVector(1, LLT::pointer(1, 32)));
105 EXPECT_EQ(LLT::vector(2, LLT::pointer(1, 32)),
122 EXPECT_EQ(S64, S32.changeElementType(S64));
123 EXPECT_EQ(S32, S32.changeElementType(S32));
125 EXPECT_EQ(S32, S64.changeElementSize(32));
126 EXPECT_EQ(S32, S32.changeElementSize(32));
128 EXPECT_EQ(V2S64, V2S32.changeElementType(S64));
129 EXPECT_EQ(V2S32, V2S64.changeElementType(S32));
131 EXPECT_EQ(V2S64, V2S32.changeElementSize(64));
132 EXPECT_EQ(V2S32, V2S64.changeElementSize(32));
134 EXPECT_EQ(P0, S32.changeElementType(P0));
135 EXPECT_EQ(S32, P0.changeElementType(S32));
137 EXPECT_EQ(V2P1, V2P0.changeElementType(P1));
138 EXPECT_EQ(V2S32, V2P0.changeElementType(S32));
186 EXPECT_EQ(Ty, VTy.getElementType());
187 EXPECT_EQ(Ty.getSizeInBits(), VTy.getScalarSizeInBits());
190 EXPECT_EQ(AS, Ty.getAddressSpace());
191 EXPECT_EQ(AS, VTy.getElementType().getAddressSpace());
201 EXPECT_EQ(Ty, getLLTForType(*IRTy, DL));
204 EXPECT_EQ(VTy, getLLTForType(*IRVTy, DL));
unittests/CodeGen/MachineInstrBundleIteratorTest.cpp 170 EXPECT_EQ(begin(), iterator(rend()));
171 EXPECT_EQ(++begin(), iterator(++rbegin()));
172 EXPECT_EQ(end(), iterator(rbegin()));
173 EXPECT_EQ(rbegin(), reverse_iterator(end()));
174 EXPECT_EQ(++rbegin(), reverse_iterator(++begin()));
175 EXPECT_EQ(rend(), reverse_iterator(begin()));
178 EXPECT_EQ(cbegin(), const_iterator(rend()));
179 EXPECT_EQ(cbegin(), const_iterator(crend()));
180 EXPECT_EQ(crbegin(), const_reverse_iterator(end()));
181 EXPECT_EQ(crbegin(), const_reverse_iterator(cend()));
unittests/CodeGen/ScalableVectorMVTsTest.cpp 61 EXPECT_EQ(Vnx2i32.widenIntegerVectorElementType(Ctx), Vnx2i64);
62 EXPECT_EQ(Vnx4i32.getHalfNumVectorElementsVT(Ctx), Vnx2i32);
65 EXPECT_EQ(EVT::getVectorVT(Ctx, MVT::i64, EltCnt * 2), MVT::nxv4i64);
66 EXPECT_EQ(EVT::getVectorVT(Ctx, MVT::i64, EltCnt / 2), MVT::nxv1i64);
70 EXPECT_EQ(Vnx2f64.changeTypeToInteger(), Vnx2i64);
74 EXPECT_EQ(EltCnt.Min, 4U);
85 EXPECT_EQ(EltCnt.Min, 8U);
unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp 220 EXPECT_EQ(8u, Types.size());
225 EXPECT_EQ(3u, TestState->Callbacks.count());
249 EXPECT_EQ(8u, Types.size());
254 EXPECT_EQ(3u, TestState->Callbacks.count());
278 EXPECT_EQ(8u, Types.size());
283 EXPECT_EQ(3u, TestState->Callbacks.count());
309 EXPECT_EQ(8u, Types.size());
314 EXPECT_EQ(3u, TestState->Callbacks.count());
339 EXPECT_EQ(5u, Types.size());
344 EXPECT_EQ(2u, TestState->Callbacks.count());
397 EXPECT_EQ("const FooClass", Name);
unittests/DebugInfo/CodeView/TypeHashingTest.cpp 150 EXPECT_EQ(hash_of(Hashes1, IntPP[0]), hash_of(Hashes2, IntPP[1]));
151 EXPECT_EQ(hash_of(Hashes1, IntPPP[0]), hash_of(Hashes2, IntPPP[1]));
152 EXPECT_EQ(hash_of(Hashes1, CharPP[0]), hash_of(Hashes2, CharPP[1]));
153 EXPECT_EQ(hash_of(Hashes1, Args[0]), hash_of(Hashes2, Args[1]));
154 EXPECT_EQ(hash_of(Hashes1, Proc[0]), hash_of(Hashes2, Proc[1]));
unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp 41 EXPECT_EQ(sizeof...(Indices), countRefs(RecordIndex));
unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp 232 EXPECT_EQ(NumCUs, 1u);
241 EXPECT_EQ(AddrValue, toAddress(DieDG.find(Attr_DW_FORM_addr), 0));
255 EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
263 EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
271 EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
279 EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
289 EXPECT_EQ(ExtractedBlockData.size(), 16u);
296 EXPECT_EQ(Data1, toUnsigned(DieDG.find(Attr_DW_FORM_data1), 0));
297 EXPECT_EQ(Data2, toUnsigned(DieDG.find(Attr_DW_FORM_data2), 0));
298 EXPECT_EQ(Data4, toUnsigned(DieDG.find(Attr_DW_FORM_data4), 0));
299 EXPECT_EQ(Data8, toUnsigned(DieDG.find(Attr_DW_FORM_data8), 0));
337 EXPECT_EQ(RefAddr, toReference(DieDG.find(Attr_DW_FORM_ref_addr), 0));
338 EXPECT_EQ(Data1, toReference(DieDG.find(Attr_DW_FORM_ref1), 0));
339 EXPECT_EQ(Data2, toReference(DieDG.find(Attr_DW_FORM_ref2), 0));
340 EXPECT_EQ(Data4, toReference(DieDG.find(Attr_DW_FORM_ref4), 0));
341 EXPECT_EQ(Data8, toReference(DieDG.find(Attr_DW_FORM_ref8), 0));
343 EXPECT_EQ(Data8_2, toReference(DieDG.find(Attr_DW_FORM_ref_sig8), 0));
345 EXPECT_EQ(UData[0], toReference(DieDG.find(Attr_DW_FORM_ref_udata), 0));
350 EXPECT_EQ(1ULL, toUnsigned(DieDG.find(Attr_DW_FORM_flag_true), 0));
351 EXPECT_EQ(0ULL, toUnsigned(DieDG.find(Attr_DW_FORM_flag_false), 1));
353 EXPECT_EQ(1ULL, toUnsigned(DieDG.find(Attr_DW_FORM_flag_present), 0));
359 EXPECT_EQ(SData, toSigned(DieDG.find(Attr_DW_FORM_sdata), 0));
361 EXPECT_EQ(ICSData, toSigned(DieDG.find(Attr_DW_FORM_implicit_const), 0));
367 EXPECT_EQ(UData[0], toUnsigned(DieDG.find(Attr_DW_FORM_udata), 0));
372 EXPECT_EQ(Dwarf32Values[0],
375 EXPECT_EQ(Dwarf32Values[1],
382 EXPECT_EQ(AddrValue, toAddress(DieDG.find(Attr_Last), 0));
498 EXPECT_EQ(NumCUs, 1u);
509 EXPECT_EQ(SubprogramDieDG.getTag(), DW_TAG_subprogram);
514 EXPECT_EQ(ArgcDieDG.getTag(), DW_TAG_formal_parameter);
520 EXPECT_EQ(NullDieDG.getTag(), DW_TAG_null);
528 EXPECT_EQ(IntDieDG.getTag(), DW_TAG_base_type);
534 EXPECT_EQ(NullDieDG.getTag(), DW_TAG_null);
542 EXPECT_EQ(IntDieDG.getTag(), DW_TAG_base_type);
675 EXPECT_EQ(NumCUs, 2u);
691 EXPECT_EQ(CU1TypeDieDG.getTag(), DW_TAG_base_type);
692 EXPECT_EQ(DW_ATE_signed, toUnsigned(CU1TypeDieDG.find(DW_AT_encoding), 0));
697 EXPECT_EQ(CU2TypeDieDG.getTag(), DW_TAG_base_type);
698 EXPECT_EQ(DW_ATE_float, toUnsigned(CU2TypeDieDG.find(DW_AT_encoding), 0));
704 EXPECT_EQ(CU1Ref1DieDG.getTag(), DW_TAG_variable);
705 EXPECT_EQ(CU1TypeDieDG.getOffset(),
711 EXPECT_EQ(CU1Ref2DieDG.getTag(), DW_TAG_variable);
712 EXPECT_EQ(CU1TypeDieDG.getOffset(),
719 EXPECT_EQ(CU1Ref4DieDG.getTag(), DW_TAG_variable);
720 EXPECT_EQ(CU1TypeDieDG.getOffset(),
727 EXPECT_EQ(CU1Ref8DieDG.getTag(), DW_TAG_variable);
728 EXPECT_EQ(CU1TypeDieDG.getOffset(),
735 EXPECT_EQ(CU1RefAddrDieDG.getTag(), DW_TAG_variable);
736 EXPECT_EQ(CU1TypeDieDG.getOffset(),
743 EXPECT_EQ(CU1ToCU2RefAddrDieDG.getTag(), DW_TAG_variable);
744 EXPECT_EQ(CU2TypeDieDG.getOffset(),
751 EXPECT_EQ(CU2Ref1DieDG.getTag(), DW_TAG_variable);
752 EXPECT_EQ(CU2TypeDieDG.getOffset(),
758 EXPECT_EQ(CU2Ref2DieDG.getTag(), DW_TAG_variable);
759 EXPECT_EQ(CU2TypeDieDG.getOffset(),
766 EXPECT_EQ(CU2Ref4DieDG.getTag(), DW_TAG_variable);
767 EXPECT_EQ(CU2TypeDieDG.getOffset(),
774 EXPECT_EQ(CU2Ref8DieDG.getTag(), DW_TAG_variable);
775 EXPECT_EQ(CU2TypeDieDG.getOffset(),
782 EXPECT_EQ(CU2RefAddrDieDG.getTag(), DW_TAG_variable);
783 EXPECT_EQ(CU2TypeDieDG.getOffset(),
790 EXPECT_EQ(CU2ToCU1RefAddrDieDG.getTag(), DW_TAG_variable);
791 EXPECT_EQ(CU1TypeDieDG.getOffset(),
885 EXPECT_EQ(NumCUs, 1u);
899 EXPECT_EQ(SubprogramDieNoPC.getTag(), DW_TAG_subprogram);
918 EXPECT_EQ(SubprogramDieLowPC.getTag(), DW_TAG_subprogram);
921 EXPECT_EQ(OptU64.getValue(), ActualLowPC);
935 EXPECT_EQ(SubprogramDieLowHighPC.getTag(), DW_TAG_subprogram);
938 EXPECT_EQ(OptU64.getValue(), ActualLowPC);
946 EXPECT_EQ(OptU64.getValue(), ActualHighPC);
953 EXPECT_EQ(OptU64.getValue(), ActualHighPCOffset);
960 EXPECT_EQ(OptU64.getValue(), ActualHighPC);
963 EXPECT_EQ(LowPC, ActualLowPC);
964 EXPECT_EQ(HighPC, ActualHighPC);
1060 EXPECT_EQ(0u, Form2->getRawUValue());
1067 EXPECT_EQ(1u, Form3->getRawUValue());
1154 EXPECT_EQ(NumCUs, 1u);
1181 EXPECT_EQ(A.getTag(), (dwarf::Tag)Tag::A);
1182 EXPECT_EQ(B.getTag(), (dwarf::Tag)Tag::B);
1183 EXPECT_EQ(C.getTag(), (dwarf::Tag)Tag::C);
1184 EXPECT_EQ(D.getTag(), (dwarf::Tag)Tag::D);
1194 EXPECT_EQ(A.getParent(), CUDie);
1199 EXPECT_EQ(B.getParent(), A);
1202 EXPECT_EQ(C.getParent(), A);
1205 EXPECT_EQ(D.getParent(), A);
1216 EXPECT_EQ(C1.getTag(), (dwarf::Tag)Tag::C1);
1217 EXPECT_EQ(C2.getTag(), (dwarf::Tag)Tag::C2);
1220 EXPECT_EQ(C1.getParent(), C);
1221 EXPECT_EQ(C2.getParent(), C);
1230 EXPECT_EQ(A.rbegin().base(), A.end());
1231 EXPECT_EQ(A.rend().base(), A.begin());
1239 EXPECT_EQ(It, Begin);
1240 EXPECT_EQ(*It, B);
1242 EXPECT_EQ(*It, C);
1244 EXPECT_EQ(*It, D);
1246 EXPECT_EQ(It, End);
1248 EXPECT_EQ(*It, D);
1250 EXPECT_EQ(*It, C);
1252 EXPECT_EQ(*It, B);
1253 EXPECT_EQ(It, Begin);
1262 EXPECT_EQ(It, Begin);
1263 EXPECT_EQ(*It, D);
1265 EXPECT_EQ(*It, C);
1267 EXPECT_EQ(*It, B);
1269 EXPECT_EQ(It, End);
1271 EXPECT_EQ(*It, B);
1273 EXPECT_EQ(*It, C);
1275 EXPECT_EQ(*It, D);
1276 EXPECT_EQ(It, Begin);
1326 EXPECT_EQ(NumCUs, 1u);
1346 EXPECT_EQ(A.getTag(), (dwarf::Tag)Tag::A);
1347 EXPECT_EQ(B.getTag(), (dwarf::Tag)Tag::B);
1351 EXPECT_EQ(A.begin(), A.end());
1361 EXPECT_EQ(begin, end);
1389 EXPECT_EQ(NumCUs, 1u);
1400 EXPECT_EQ(CUDie.begin(), CUDie.end());
1437 EXPECT_EQ(NumCUs, 1u);
1450 EXPECT_EQ(I->Attr, DW_AT_name);
1452 EXPECT_EQ(CUPath, *ActualCUPath);
1455 EXPECT_EQ(I->Attr, DW_AT_declaration);
1456 EXPECT_EQ(1ull, *I->Value.getAsUnsignedConstant());
1459 EXPECT_EQ(I->Attr, DW_AT_low_pc);
1460 EXPECT_EQ(CULowPC, *I->Value.getAsAddress());
1462 EXPECT_EQ(E, ++I);
1506 EXPECT_EQ(NumCUs, 1u);
1533 EXPECT_EQ(SpecDieName, StringOpt.getValueOr(nullptr));
1535 EXPECT_EQ(SpecDieName, toString(NameOpt, nullptr));
1538 EXPECT_EQ(SpecLinkageName, toString(LinkageNameOpt).getValueOr(nullptr));
1552 EXPECT_EQ(AbsDieName, StringOpt.getValueOr(nullptr));
1571 EXPECT_EQ(nullptr, toString(FormValOpt1, nullptr));
1572 EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt1, InvalidU64));
1573 EXPECT_EQ(InvalidU64, toReference(FormValOpt1, InvalidU64));
1574 EXPECT_EQ(InvalidU64, toAddress(FormValOpt1, InvalidU64));
1575 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt1, InvalidU64));
1576 EXPECT_EQ(InvalidS64, toSigned(FormValOpt1, InvalidS64));
1590 EXPECT_EQ(nullptr, toString(FormValOpt2, nullptr));
1591 EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt2, InvalidU64));
1592 EXPECT_EQ(InvalidU64, toReference(FormValOpt2, InvalidU64));
1593 EXPECT_EQ(Address, toAddress(FormValOpt2, InvalidU64));
1594 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt2, InvalidU64));
1595 EXPECT_EQ(InvalidS64, toSigned(FormValOpt2, InvalidU64));
1609 EXPECT_EQ(nullptr, toString(FormValOpt3, nullptr));
1610 EXPECT_EQ(UData8, toUnsigned(FormValOpt3, InvalidU64));
1611 EXPECT_EQ(InvalidU64, toReference(FormValOpt3, InvalidU64));
1612 EXPECT_EQ(InvalidU64, toAddress(FormValOpt3, InvalidU64));
1613 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt3, InvalidU64));
1614 EXPECT_EQ((int64_t)UData8, toSigned(FormValOpt3, InvalidU64));
1628 EXPECT_EQ(nullptr, toString(FormValOpt4, nullptr));
1629 EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt4, InvalidU64));
1630 EXPECT_EQ(RefData, toReference(FormValOpt4, InvalidU64));
1631 EXPECT_EQ(InvalidU64, toAddress(FormValOpt4, InvalidU64));
1632 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt4, InvalidU64));
1633 EXPECT_EQ(InvalidS64, toSigned(FormValOpt4, InvalidU64));
1647 EXPECT_EQ(nullptr, toString(FormValOpt5, nullptr));
1648 EXPECT_EQ((uint64_t)SData8, toUnsigned(FormValOpt5, InvalidU64));
1649 EXPECT_EQ(InvalidU64, toReference(FormValOpt5, InvalidU64));
1650 EXPECT_EQ(InvalidU64, toAddress(FormValOpt5, InvalidU64));
1651 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt5, InvalidU64));
1652 EXPECT_EQ(SData8, toSigned(FormValOpt5, InvalidU64));
1668 EXPECT_EQ(*BlockOpt, Array);
1669 EXPECT_EQ(nullptr, toString(FormValOpt6, nullptr));
1670 EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt6, InvalidU64));
1671 EXPECT_EQ(InvalidU64, toReference(FormValOpt6, InvalidU64));
1672 EXPECT_EQ(InvalidU64, toAddress(FormValOpt6, InvalidU64));
1673 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt6, InvalidU64));
1674 EXPECT_EQ(InvalidS64, toSigned(FormValOpt6, InvalidU64));
1709 EXPECT_EQ(NumCUs, 1u);
1739 EXPECT_EQ(DieMangled, toString(NameOpt, ""));
1788 EXPECT_EQ(A, Attr);
1792 EXPECT_EQ(FormValue->getForm(), dwarf::DW_FORM_implicit_const);
1806 EXPECT_EQ(Val, *V);
1811 EXPECT_EQ(Val1Abbrev, Abbrevs->end());
1816 EXPECT_EQ(Val2Abbrev, Abbrevs->end());
1851 EXPECT_EQ(DIEs.count(Val1), 2u);
1852 EXPECT_EQ(DIEs.count(Val2), 1u);
1855 EXPECT_EQ(it->second, AbbrevPtrVal1);
1856 EXPECT_EQ(DIEs.find(Val2)->second, AbbrevPtrVal2);
unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp 103 EXPECT_EQ(Actual.message(), ExpectedMsgs[WhichMsg++].str());
105 EXPECT_EQ(WhichMsg, ExpectedMsgs.size());
170 EXPECT_EQ(Prologue.MaxOpsPerInst, 1u);
180 EXPECT_EQ(Prologue.getAddressSize(), 8u);
181 EXPECT_EQ(Prologue.SegSelectorSize, 0u);
188 EXPECT_EQ(Prologue.TotalLength, UnitLength);
189 EXPECT_EQ(Prologue.PrologueLength, PrologueLength);
190 EXPECT_EQ(Prologue.MinInstLength, 1u);
191 EXPECT_EQ(Prologue.DefaultIsStmt, 1u);
192 EXPECT_EQ(Prologue.LineBase, -5);
193 EXPECT_EQ(Prologue.LineRange, 14u);
194 EXPECT_EQ(Prologue.OpcodeBase, 13u);
196 EXPECT_EQ(Prologue.StandardOpcodeLengths, ExpectedLengths);
264 EXPECT_EQ(Expected->Sequences.size(), 1u);
275 EXPECT_EQ(Expected2->Sequences.size(), 2u);
286 EXPECT_EQ(Expected, *ExpectedLineTable3);
293 EXPECT_EQ(Expected2, *ExpectedLineTable4);
479 EXPECT_EQ((*ExpectedLineTable)->Rows.size(), 6u);
481 EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u);
490 EXPECT_EQ(Parser.getOffset(), 0u);
496 EXPECT_EQ(Parsed.Sequences.size(), 1u);
497 EXPECT_EQ(Parser.getOffset(), 62u);
503 EXPECT_EQ(Parsed2.Sequences.size(), 1u);
504 EXPECT_EQ(Parser.getOffset(), 136u);
517 EXPECT_EQ(Parser.getOffset(), 0u);
521 EXPECT_EQ(Parser.getOffset(), 62u);
525 EXPECT_EQ(Parser.getOffset(), 136u);
553 EXPECT_EQ(Parser.getOffset(), 4u);
574 EXPECT_EQ(Parser.getOffset(), 4u);
unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp 80 EXPECT_EQ(Sign1.getAsSignedConstant().getValue(), -123);
81 EXPECT_EQ(Sign2.getAsSignedConstant().getValue(), -12345);
82 EXPECT_EQ(Sign4.getAsSignedConstant().getValue(), -123456789);
83 EXPECT_EQ(Sign8.getAsSignedConstant().getValue(), -1);
89 EXPECT_EQ(UMax.getAsSignedConstant().getValue(), LLONG_MAX);
90 EXPECT_EQ(TooBig.getAsSignedConstant().hasValue(), false);
101 EXPECT_EQ(Data1.getAsSignedConstant().getValue(), 120);
102 EXPECT_EQ(Data2.getAsSignedConstant().getValue(), 32000);
103 EXPECT_EQ(Data4.getAsSignedConstant().getValue(), 2000000000);
104 EXPECT_EQ(Data8.getAsSignedConstant().getValue(), 0x1234567812345678LL);
105 EXPECT_EQ(LEBMin.getAsSignedConstant().getValue(), LLONG_MIN);
106 EXPECT_EQ(LEBMax.getAsSignedConstant().getValue(), LLONG_MAX);
107 EXPECT_EQ(LEB1.getAsSignedConstant().getValue(), -42);
108 EXPECT_EQ(LEB2.getAsSignedConstant().getValue(), 42);
120 EXPECT_EQ(memcmp(Str.data(), "000102030405060708090a0b0c0d0e0f", 32), 0);
unittests/DebugInfo/GSYM/GSYMTest.cpp 38 EXPECT_EQ(Actual.message(), ExpectedMsgs[WhichMsg++]);
40 EXPECT_EQ(WhichMsg, ExpectedMsgs.size());
52 EXPECT_EQ(empty1.Dir, 0u);
53 EXPECT_EQ(empty1.Base, 0u);
58 EXPECT_EQ(empty1, empty2);
59 EXPECT_EQ(a1, a2);
68 EXPECT_EQ(R.first->second, Index1);
71 EXPECT_EQ(R.first->second, Index1);
74 EXPECT_EQ(R.first->second, Index2);
77 EXPECT_EQ(R.first->second, Index2);
92 EXPECT_EQ(FI.startAddress(), StartAddr);
93 EXPECT_EQ(FI.endAddress(), EndAddr);
94 EXPECT_EQ(FI.size(), Size);
108 EXPECT_EQ(A1, A2);
257 EXPECT_EQ(FI, Decoded.get());
332 EXPECT_EQ(Inline, Decoded.get());
535 EXPECT_EQ(E1, E2);
548 EXPECT_EQ(Range.size(), EndAddr - StartAddr);
563 EXPECT_EQ(Range, RangeSame);
639 EXPECT_EQ(Ranges.size(), 1u);
640 EXPECT_EQ(Ranges[0], AddressRange(0x1100, 0x1F00));
644 EXPECT_EQ(Ranges.size(), 1u);
645 EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x1F00));
649 EXPECT_EQ(Ranges.size(), 1u);
650 EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x2000));
654 EXPECT_EQ(Ranges.size(), 2u);
655 EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x2000));
656 EXPECT_EQ(Ranges[1], AddressRange(0x2000, 0x3000));
660 EXPECT_EQ(Ranges.size(), 1u);
661 EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x3000));
666 EXPECT_EQ(Ranges.size(), 1u);
667 EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x5000));
673 EXPECT_EQ(StrTab.getString(0), "");
674 EXPECT_EQ(StrTab.getString(1), "Hello");
675 EXPECT_EQ(StrTab.getString(7), "World");
676 EXPECT_EQ(StrTab.getString(8), "orld");
678 EXPECT_EQ(StrTab.getString(12), "");
680 EXPECT_EQ(StrTab.getString(13), "");
715 EXPECT_EQ(Data.getU8(&Offset), U8);
716 EXPECT_EQ(Data.getU16(&Offset), U16);
717 EXPECT_EQ(Data.getU32(&Offset), U32);
718 EXPECT_EQ(Data.getU64(&Offset), U64);
720 EXPECT_EQ(Data.getU32(&Offset), U32);
721 EXPECT_EQ(Data.getSLEB128(&Offset), MinSLEB);
722 EXPECT_EQ(Data.getSLEB128(&Offset), MaxSLEB);
723 EXPECT_EQ(Data.getULEB128(&Offset), MinULEB);
724 EXPECT_EQ(Data.getULEB128(&Offset), MaxULEB);
725 EXPECT_EQ(Data.getCStrRef(&Offset), StringRef(Hello));
755 EXPECT_EQ(Range1, DecodedRange1);
756 EXPECT_EQ(Range2, DecodedRange2);
774 EXPECT_EQ(Ranges, DecodedRanges);
813 EXPECT_EQ(LT, Decoded.get());
1042 EXPECT_EQ(H, Decoded.get());
1120 EXPECT_EQ(FI, *DecodedFI);
1137 EXPECT_EQ(Hdr.Version, Version);
1138 EXPECT_EQ(Hdr.AddrOffSize, AddrOffSize);
1139 EXPECT_EQ(Hdr.UUIDSize, UUID.size());
1140 EXPECT_EQ(Hdr.BaseAddress, BaseAddress);
1141 EXPECT_EQ(Hdr.NumAddresses, NumAddresses);
1142 EXPECT_EQ(ArrayRef<uint8_t>(Hdr.UUID, Hdr.UUIDSize), UUID);
unittests/DebugInfo/MSF/MSFBuilderTest.cpp 119 EXPECT_EQ(1U, OldDirBlocks.size());
126 EXPECT_EQ(1U, Msf2.getNumStreams());
127 EXPECT_EQ(4000U, Msf2.getStreamSize(0));
129 EXPECT_EQ(1U, Blocks.size());
135 EXPECT_EQ(1U, NewDirBlocks.size());
155 EXPECT_EQ(2U, DirBlocks.size());
166 EXPECT_EQ(1024U, Msf.getStreamSize(0));
168 EXPECT_EQ(1U, OldStreamBlocks.size());
171 EXPECT_EQ(2048U, Msf.getStreamSize(0));
173 EXPECT_EQ(1U, NewStreamBlocks.size());
175 EXPECT_EQ(OldStreamBlocks, NewStreamBlocks);
188 EXPECT_EQ(2048U, Msf.getStreamSize(0));
190 EXPECT_EQ(1U, OldStreamBlocks.size());
193 EXPECT_EQ(6144U, Msf.getStreamSize(0));
195 EXPECT_EQ(2U, NewStreamBlocks.size());
197 EXPECT_EQ(OldStreamBlocks[0], NewStreamBlocks[0]);
209 EXPECT_EQ(2048U, Msf.getStreamSize(0));
211 EXPECT_EQ(1U, OldStreamBlocks.size());
214 EXPECT_EQ(1024U, Msf.getStreamSize(0));
216 EXPECT_EQ(1U, NewStreamBlocks.size());
218 EXPECT_EQ(OldStreamBlocks, NewStreamBlocks);
230 EXPECT_EQ(6144U, Msf.getStreamSize(0));
232 EXPECT_EQ(2U, OldStreamBlocks.size());
235 EXPECT_EQ(2048U, Msf.getStreamSize(0));
237 EXPECT_EQ(1U, NewStreamBlocks.size());
239 EXPECT_EQ(OldStreamBlocks[0], NewStreamBlocks[0]);
264 EXPECT_EQ(msf::getMinimumBlockCount(), NumUsedBlocks);
265 EXPECT_EQ(0U, Msf.getNumFreeBlocks());
271 EXPECT_EQ(NumUsedBlocks, Msf.getNumUsedBlocks());
272 EXPECT_EQ(0U, Msf.getNumFreeBlocks());
294 EXPECT_EQ(4096U, L.SB->BlockSize);
295 EXPECT_EQ(ExpectedNumBlocks, L.SB->NumBlocks);
297 EXPECT_EQ(1U, L.DirectoryBlocks.size());
299 EXPECT_EQ(3U, L.StreamMap.size());
300 EXPECT_EQ(3U, L.StreamSizes.size());
302 EXPECT_EQ(StreamSizes[I], L.StreamSizes[I]);
304 EXPECT_EQ(ExpectedNumBlocks, L.StreamMap[I].size());
321 EXPECT_EQ(msf::getMinimumBlockCount() + 2, L.SB->NumBlocks);
322 EXPECT_EQ(1U, L.DirectoryBlocks.size());
323 EXPECT_EQ(1U, L.StreamMap[0].size());
325 EXPECT_EQ(B + 1, L.DirectoryBlocks[0]);
326 EXPECT_EQ(B + 2, L.StreamMap[0].front());
343 EXPECT_EQ(2U, L.DirectoryBlocks.size());
344 EXPECT_EQ(B + 1, L.DirectoryBlocks[0]);
361 EXPECT_EQ(1U, L.DirectoryBlocks.size());
362 EXPECT_EQ(B + 1, L.DirectoryBlocks[0]);
383 EXPECT_EQ(StreamSize, L.StreamSizes[*SN]);
unittests/DebugInfo/MSF/MSFCommonTest.cpp 18 EXPECT_EQ(0ULL, bytesToBlocks(0, 4096));
19 EXPECT_EQ(1ULL, bytesToBlocks(12, 4096));
20 EXPECT_EQ(1ULL, bytesToBlocks(4096, 4096));
21 EXPECT_EQ(2ULL, bytesToBlocks(4097, 4096));
22 EXPECT_EQ(2ULL, bytesToBlocks(600, 512));
34 EXPECT_EQ(1u, getNumFpmIntervals(L, false));
36 EXPECT_EQ(1u, getNumFpmIntervals(L, false));
38 EXPECT_EQ(1u, getNumFpmIntervals(L, false));
40 EXPECT_EQ(1u, getNumFpmIntervals(L, false));
42 EXPECT_EQ(2u, getNumFpmIntervals(L, false));
45 EXPECT_EQ(1u, getNumFpmIntervals(L, true));
47 EXPECT_EQ(1u, getNumFpmIntervals(L, true));
49 EXPECT_EQ(8u, getNumFpmIntervals(L, true));
64 EXPECT_EQ(1U, getNumFpmIntervals(4096, I, true, 1));
65 EXPECT_EQ(1U, getNumFpmIntervals(4096, I, false, 1));
68 EXPECT_EQ(1U, getNumFpmIntervals(4096, I, true, 2));
69 EXPECT_EQ(1U, getNumFpmIntervals(4096, I, false, 2));
74 EXPECT_EQ(2U, getNumFpmIntervals(4096, 4098, true, 1));
75 EXPECT_EQ(1U, getNumFpmIntervals(4096, 4098, false, 1));
78 EXPECT_EQ(1U, getNumFpmIntervals(4096, 4098, true, 2));
79 EXPECT_EQ(1U, getNumFpmIntervals(4096, 4098, false, 2));
83 EXPECT_EQ(2U, getNumFpmIntervals(4096, 4099, true, 1));
84 EXPECT_EQ(1U, getNumFpmIntervals(4096, 4099, false, 1));
87 EXPECT_EQ(2U, getNumFpmIntervals(4096, 4099, true, 2));
88 EXPECT_EQ(1U, getNumFpmIntervals(4096, 4099, false, 2));
106 EXPECT_EQ(1000u, SL.Length);
107 EXPECT_EQ(1u, SL.Blocks.size());
108 EXPECT_EQ(SB.FreeBlockMapBlock, SL.Blocks.front());
111 EXPECT_EQ(1000u, SL.Length);
112 EXPECT_EQ(1u, SL.Blocks.size());
113 EXPECT_EQ(3u - SB.FreeBlockMapBlock, SL.Blocks.front());
118 EXPECT_EQ(SB.BlockSize + 1, SL.Length);
119 EXPECT_EQ(2u, SL.Blocks.size());
120 EXPECT_EQ(SB.FreeBlockMapBlock, SL.Blocks[0]);
121 EXPECT_EQ(SB.FreeBlockMapBlock + SB.BlockSize, SL.Blocks[1]);
124 EXPECT_EQ(SB.BlockSize + 1, SL.Length);
125 EXPECT_EQ(2u, SL.Blocks.size());
126 EXPECT_EQ(3u - SB.FreeBlockMapBlock, SL.Blocks[0]);
127 EXPECT_EQ(3u - SB.FreeBlockMapBlock + SB.BlockSize, SL.Blocks[1]);
134 EXPECT_EQ(SB.BlockSize * 9, SL.Length);
135 EXPECT_EQ(9u, SL.Blocks.size());
137 EXPECT_EQ(I * SB.BlockSize + SB.FreeBlockMapBlock, SL.Blocks[I]);
unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp 80 EXPECT_EQ(F.block_size(), S->getBlockSize());
81 EXPECT_EQ(F.layout().Blocks.size(), S->getNumBlocks());
110 EXPECT_EQ(Str, StringRef("A"));
111 EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
124 EXPECT_EQ(Str, StringRef("AB"));
125 EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
129 EXPECT_EQ(Str, StringRef("GHIJ"));
130 EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
143 EXPECT_EQ(Str, StringRef("ABCDEFGHIJ"));
144 EXPECT_EQ(10U, F.Allocator.getBytesAllocated());
158 EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
172 EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
185 EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
197 EXPECT_EQ(Str, StringRef("A"));
198 EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
212 EXPECT_EQ(Str1, StringRef("ABCDEFG"));
213 EXPECT_EQ(7U, F.Allocator.getBytesAllocated());
217 EXPECT_EQ(Str2, StringRef("CDE"));
218 EXPECT_EQ(Str1.data() + 2, Str2.data());
219 EXPECT_EQ(7U, F.Allocator.getBytesAllocated());
233 EXPECT_EQ(Str1, StringRef("ABCDEF"));
234 EXPECT_EQ(6U, F.Allocator.getBytesAllocated());
238 EXPECT_EQ(Str2, StringRef("EFGH"));
239 EXPECT_EQ(10U, F.Allocator.getBytesAllocated());
269 EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
271 EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
277 EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
279 EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
285 EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
287 EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
304 EXPECT_EQ(ArrayRef<uint8_t>(Data), ArrayRef<uint8_t>(Expected));
307 EXPECT_EQ(Buffer, ArrayRef<uint8_t>(TestData));
340 EXPECT_EQ(u16[0], u16[1]);
341 EXPECT_EQ(std::vector<uint8_t>({0, 0x7A, 0xEC, 0, 0, 0, 0, 0, 0, 0}),
349 EXPECT_EQ(u32[0], u32[1]);
350 EXPECT_EQ(std::vector<uint8_t>({0x17, 0x5C, 0x50, 0, 0, 0, 0x35, 0, 0, 0}),
358 EXPECT_EQ(Enum[0], Enum[1]);
359 EXPECT_EQ(std::vector<uint8_t>({0x2C, 0x60, 0x4A, 0, 0, 0, 0, 0, 0, 0}),
367 EXPECT_EQ(ZStr[0], ZStr[1]);
368 EXPECT_EQ(
378 EXPECT_EQ(FStr[0], FStr[1]);
379 EXPECT_EQ(
389 EXPECT_EQ(byteArray[0], byteArray[1]);
390 EXPECT_EQ(std::vector<uint8_t>({0, 0x32, 0x31, 0, 0, 0, 0, 0, 0, 0}),
399 EXPECT_EQ(intArray[0], intArray[1]);
418 EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>(
424 EXPECT_EQ(DestDataBytes, std::vector<uint8_t>(
431 EXPECT_EQ(Result, "Test Str");
454 EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>(
460 EXPECT_EQ(DestDataBytes, std::vector<uint8_t>(
467 EXPECT_EQ(Result, "Test Str");
487 EXPECT_EQ(Str[0], Str[1]);
490 EXPECT_EQ(Str[0], Str[1]);
521 EXPECT_EQ(2048u, FpmStream->getLength());
522 EXPECT_EQ(1u, FpmStream->getStreamLayout().Blocks.size());
523 EXPECT_EQ(1u, FpmStream->getStreamLayout().Blocks[0]);
536 EXPECT_EQ(2048u, FpmStream->getLength());
537 EXPECT_EQ(1u, FpmStream->getStreamLayout().Blocks.size());
538 EXPECT_EQ(2u, FpmStream->getStreamLayout().Blocks[0]);
unittests/DebugInfo/PDB/HashTableTest.cpp 47 EXPECT_EQ(0u, Table.size());
52 EXPECT_EQ(1u, Table.size());
54 EXPECT_EQ(7u, Table.get(3u, Traits));
59 EXPECT_EQ(0u, Table.size());
71 EXPECT_EQ(2u, Table.size());
75 EXPECT_EQ(7u, Table.get(N1, Traits));
76 EXPECT_EQ(12u, Table.get(N2, Traits));
81 EXPECT_EQ(0u, Table.size());
87 EXPECT_EQ(2u, Table.size());
91 EXPECT_EQ(2u, Table.get(1u, Traits));
92 EXPECT_EQ(4u, Table.get(3u, Traits));
97 EXPECT_EQ(0u, Table.size());
111 EXPECT_EQ(3u, Table.size());
116 EXPECT_EQ(7u, Table.get(N1, Traits));
117 EXPECT_EQ(11u, Table.get(N2, Traits));
118 EXPECT_EQ(13u, Table.get(N3, Traits));
132 EXPECT_EQ(OldCapacity, Table.size());
136 EXPECT_EQ(I * 2 + 3, Table.get(OldCapacity + I * 2 + 1, Traits));
153 EXPECT_EQ(Buffer.size(), Writer.getOffset());
159 EXPECT_EQ(Buffer.size(), Reader.getOffset());
161 EXPECT_EQ(Table.size(), Table2.size());
162 EXPECT_EQ(Table.capacity(), Table2.capacity());
163 EXPECT_EQ(Table.Buckets, Table2.Buckets);
164 EXPECT_EQ(Table.Present, Table2.Present);
165 EXPECT_EQ(Table.Deleted, Table2.Deleted);
182 EXPECT_EQ(Streams.size(), NSM.size());
186 EXPECT_EQ(1U, N);
189 EXPECT_EQ(2U, N);
192 EXPECT_EQ(3U, N);
195 EXPECT_EQ(4U, N);
198 EXPECT_EQ(5U, N);
201 EXPECT_EQ(6U, N);
204 EXPECT_EQ(7U, N);
257 EXPECT_EQ(Buffer.size(), Writer.getOffset());
263 EXPECT_EQ(Buffer.size(), Reader.getOffset());
265 EXPECT_EQ(Table.size(), Table2.size());
266 EXPECT_EQ(Table.capacity(), Table2.capacity());
267 EXPECT_EQ(Table.Buckets, Table2.Buckets);
268 EXPECT_EQ(Table.Present, Table2.Present);
269 EXPECT_EQ(Table.Deleted, Table2.Deleted);
unittests/DebugInfo/PDB/NativeSymbolReuseTest.cpp 43 EXPECT_EQ(GlobalId, Id2);
50 EXPECT_EQ(GlobalId, Id3);
80 EXPECT_EQ(CompilandIds, Ids2);
92 EXPECT_EQ(CompilandIds, Ids3);
127 EXPECT_EQ(CompilandIds, Reversed);
unittests/DebugInfo/PDB/PDBApiTest.cpp 449 EXPECT_EQ(item->first == Tag, llvm::isa<ExpectedType>(*item->second));
459 EXPECT_EQ(should_match, llvm::isa<PDBSymbolUnknown>(*item->second));
unittests/DebugInfo/PDB/StringTableBuilderTest.cpp 38 EXPECT_EQ(FooID, Builder.insert("foo"));
39 EXPECT_EQ(BarID, Builder.insert("bar"));
40 EXPECT_EQ(BazID, Builder.insert("baz"));
41 EXPECT_EQ(BuzzID, Builder.insert("buzz"));
42 EXPECT_EQ(BazzID, Builder.insert("bazz"));
43 EXPECT_EQ(BarrID, Builder.insert("barr"));
47 EXPECT_EQ(6U, Distinct.size());
60 EXPECT_EQ(6U, Table.getNameCount());
61 EXPECT_EQ(1U, Table.getHashVersion());
unittests/Demangle/DemangleTest.cpp 15 EXPECT_EQ(demangle("_"), "_");
16 EXPECT_EQ(demangle("_Z3fooi"), "foo(int)");
17 EXPECT_EQ(demangle("__Z3fooi"), "foo(int)");
18 EXPECT_EQ(demangle("___Z3fooi_block_invoke"),
20 EXPECT_EQ(demangle("____Z3fooi_block_invoke"),
22 EXPECT_EQ(demangle("?foo@@YAXH@Z"), "void __cdecl foo(int)");
23 EXPECT_EQ(demangle("foo"), "foo");
unittests/Demangle/PartialDemangleTest.cpp 164 EXPECT_EQ(OriginalBuf, Res);
165 EXPECT_EQ(strlen(Res) + 1, N);
177 EXPECT_EQ(strlen(Res) + 1, N);
188 EXPECT_EQ(nullptr, Res);
189 EXPECT_EQ(OriginalSize, N);
unittests/ExecutionEngine/ExecutionEngineTest.cpp 55 EXPECT_EQ(&Mem1, Engine->getPointerToGlobalIfAvailable(G1));
56 EXPECT_EQ(&Mem1, Engine->getPointerToGlobalIfAvailable("Global1"));
59 EXPECT_EQ(&Mem2, Engine->getPointerToGlobalIfAvailable(G1));
61 EXPECT_EQ(nullptr, Engine->getPointerToGlobalIfAvailable(G1));
63 EXPECT_EQ(&Mem2, Engine->getPointerToGlobalIfAvailable(G1));
66 EXPECT_EQ(nullptr, Engine->getPointerToGlobalIfAvailable(G2))
71 EXPECT_EQ(&Mem1, Engine->getPointerToGlobalIfAvailable(G2));
72 EXPECT_EQ(&Mem2, Engine->getPointerToGlobalIfAvailable(G1))
81 EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem1));
84 EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem1));
85 EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem2));
89 EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem1));
90 EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem2));
92 EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem1))
94 EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem2));
96 EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem1));
97 EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem2))
107 EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem1));
111 EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem1));
117 EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem1));
125 EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem1));
129 EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem1));
146 EXPECT_EQ(reinterpret_cast<uint64_t>(&_x),
unittests/ExecutionEngine/JITLink/MachO_x86_64_Tests.cpp 52 EXPECT_EQ(B.edges_size(), 1U) << "Incorrect number of edges for pointer";
56 EXPECT_EQ(E.getOffset(), 0U) << "Expected edge offset of zero";
57 EXPECT_EQ(E.getKind(), Pointer64)
59 EXPECT_EQ(&E.getTarget(), &Target) << "Expected edge to point at target";
65 EXPECT_EQ(E.getAddend(), 0U) << "Expected GOT load to have a zero addend";
76 EXPECT_EQ(E.getKind(), Branch32) << "Edge is not a Branch32";
77 EXPECT_EQ(E.getAddend(), 0U) << "Expected no addend on stub call";
78 EXPECT_EQ(&E.getTarget(), &Callee)
91 EXPECT_EQ(E.getKind(), PCRel32) << "Edge is not a PCRel32";
92 EXPECT_EQ(E.getAddend(), 0) << "Expected no addend on stub cal";
116 EXPECT_EQ(StubBlock.edges_size(), 1U)
176 EXPECT_EQ(P.getBlock().edges_size(), 1U)
178 EXPECT_EQ(P.getBlock().edges().begin()->getKind(), Pointer64)
190 EXPECT_EQ(Bar.getBlock().edges_size(), 1U)
192 EXPECT_EQ(Bar.getBlock().edges().begin()->getKind(), Branch32)
200 EXPECT_EQ(Foo.getBlock().edges_size(), 1U)
202 EXPECT_EQ(Foo.getBlock().edges().begin()->getKind(), Branch32);
209 EXPECT_EQ(Foo_1.getBlock().edges_size(), 1U)
211 EXPECT_EQ(Foo_1.getBlock().edges().begin()->getKind(), PCRel32);
217 EXPECT_EQ(Foo_2.getBlock().edges_size(), 1U)
219 EXPECT_EQ(Foo_2.getBlock().edges().begin()->getKind(), PCRel32);
unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp 344 EXPECT_EQ(42, functionPointer());
362 EXPECT_EQ(42, *usable);
376 EXPECT_EQ(42, usable());
391 EXPECT_EQ(42, functionPointer());
411 EXPECT_EQ(42, functionPointer());
446 EXPECT_EQ(789, GetGlobalFct());
467 EXPECT_EQ(42, functionPointer());
506 EXPECT_EQ(42, usable());
unittests/ExecutionEngine/MCJIT/MCJITMemoryManagerTest.cpp 39 EXPECT_EQ(1, code1[i]);
40 EXPECT_EQ(2, code2[i]);
41 EXPECT_EQ(3, data1[i]);
42 EXPECT_EQ(4, data2[i]);
72 EXPECT_EQ(1, code1[i]);
73 EXPECT_EQ(2, code2[i]);
74 EXPECT_EQ(3, data1[i]);
75 EXPECT_EQ(4, data2[i]);
108 EXPECT_EQ(ExpectedCode, code[i][j]);
109 EXPECT_EQ(ExpectedData, data[i][j]);
148 EXPECT_EQ((uintptr_t)0, CodeAlign);
149 EXPECT_EQ((uintptr_t)0, DataAlign);
158 EXPECT_EQ(ExpectedCode, code[i][j]);
163 EXPECT_EQ(ExpectedData, data[i][j]);
unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp 47 EXPECT_EQ(0, AddPtr(0, 0));
48 EXPECT_EQ(1, AddPtr(1, 0));
49 EXPECT_EQ(3, AddPtr(1, 2));
50 EXPECT_EQ(-5, AddPtr(-2, -3));
51 EXPECT_EQ(30, AddPtr(10, 20));
52 EXPECT_EQ(-30, AddPtr(-10, -20));
53 EXPECT_EQ(-40, AddPtr(-10, -30));
59 EXPECT_EQ(0, FPtr(0));
60 EXPECT_EQ(1, FPtr(1));
61 EXPECT_EQ(3, FPtr(2));
62 EXPECT_EQ(6, FPtr(3));
63 EXPECT_EQ(10, FPtr(4));
64 EXPECT_EQ(15, FPtr(5));
225 EXPECT_EQ(GVA, TheJIT->FindGlobalVariableNamed("GVA"));
226 EXPECT_EQ(GVB, TheJIT->FindGlobalVariableNamed("GVB"));
227 EXPECT_EQ(GVC, TheJIT->FindGlobalVariableNamed("GVC",true));
228 EXPECT_EQ(nullptr, TheJIT->FindGlobalVariableNamed("GVC"));
234 EXPECT_EQ(initialNum, FuncPtr())
240 EXPECT_EQ(initialNum, FuncPtr())
421 EXPECT_EQ(FA, TheJIT->FindFunctionNamed(FA->getName().data()));
422 EXPECT_EQ(FB1, TheJIT->FindFunctionNamed(FB1->getName().data()));
unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp 104 EXPECT_EQ(returnCode, ExpectedRC);
134 EXPECT_EQ(nullptr, ObjBuffer);
212 EXPECT_EQ(nullptr, ObjBuffer);
unittests/ExecutionEngine/MCJIT/MCJITTest.cpp 56 EXPECT_EQ(initialValue, *(int32_t*)globalPtr)
71 EXPECT_EQ(0, AddPtr(0, 0));
72 EXPECT_EQ(1, AddPtr(1, 0));
73 EXPECT_EQ(3, AddPtr(1, 2));
74 EXPECT_EQ(-5, AddPtr(-2, -3));
75 EXPECT_EQ(30, AddPtr(10, 20));
76 EXPECT_EQ(-30, AddPtr(-10, -20));
77 EXPECT_EQ(-40, AddPtr(-10, -30));
92 EXPECT_EQ(returnCode, rc);
112 EXPECT_EQ(initialNum, FuncPtr())
190 EXPECT_EQ(innerRetVal, FuncPtr())
206 EXPECT_EQ(A, B) << "Repeat calls to getPointerToFunction fail.";
247 EXPECT_EQ(UnresolvedExternal, "Foo");
289 EXPECT_EQ(UnresolvedExternals.size(), 2u);
unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp 33 EXPECT_EQ(I->second.getAddress(), FooAddr)
66 EXPECT_EQ(Msg, "xyz") << "Resolution returned incorrect result";
116 EXPECT_EQ(Name, Bar) << "Expected \"Bar\" to be discarded";
206 EXPECT_EQ(Result.size(), 2U) << "Unexpected number of results";
207 EXPECT_EQ(Result.count(Foo), 1U) << "Missing result for \"Foo\"";
208 EXPECT_EQ(Result.count(Bar), 1U) << "Missing result for \"Bar\"";
209 EXPECT_EQ(Result[Bar].getAddress(), QuxSym.getAddress())
233 EXPECT_EQ(SymbolFlags.size(), 2U)
235 EXPECT_EQ(SymbolFlags.count(Foo), 1U) << "Missing lookupFlags result for Foo";
236 EXPECT_EQ(SymbolFlags[Foo], FooSym.getFlags())
238 EXPECT_EQ(SymbolFlags.count(Bar), 1U)
240 EXPECT_EQ(SymbolFlags[Bar], BarSym.getFlags())
274 EXPECT_EQ(Result->count(Baz), 1U) << "No result for \"baz\"";
275 EXPECT_EQ(Result->count(Qux), 1U) << "No result for \"qux\"";
276 EXPECT_EQ((*Result)[Baz].getAddress(), FooSym.getAddress())
278 EXPECT_EQ((*Result)[Qux].getAddress(), QuxSym.getAddress())
289 EXPECT_EQ(Result->count(Bar), 1U) << "No result for \"bar\"";
290 EXPECT_EQ(Result->count(Baz), 1U) << "No result for \"baz\"";
291 EXPECT_EQ((*Result)[Bar].getAddress(), FooSym.getAddress())
293 EXPECT_EQ((*Result)[Baz].getAddress(), FooSym.getAddress())
307 EXPECT_EQ(Result.getAddress(), FooSym.getAddress())
333 EXPECT_EQ(Result.getAddress(), FooSym.getAddress())
350 EXPECT_EQ(Flags.size(), 1U) << "Unexpected number of results";
351 EXPECT_EQ(Flags[Foo], FooSym.getFlags()) << "Unexpected flags for Foo";
355 EXPECT_EQ(Result.getAddress(), FooSym.getAddress())
850 EXPECT_EQ(Name, Bar) << "Expected Name to be Bar";
865 EXPECT_EQ(I->second.getAddress(), FooSym.getAddress())
899 EXPECT_EQ(Name, Bar) << "Expected \"Bar\" to be discarded";
948 EXPECT_EQ(BarResult.getAddress(), BarSym.getAddress())
982 EXPECT_EQ(Result.count(Bar), 1U) << "Expected to find fallback def for 'bar'";
983 EXPECT_EQ(Result[Bar].getAddress(), BarSym.getAddress())
1007 EXPECT_EQ(F.getSymbols().find(&JD)->second, Names)
1093 EXPECT_EQ(FooLookupResult.getAddress(), FooSym.getAddress())
1095 EXPECT_EQ(FooLookupResult.getFlags(), FooSym.getFlags())
1114 EXPECT_EQ(FooLookupResult.getAddress(), FooSym.getAddress())
1116 EXPECT_EQ(FooLookupResult.getFlags(), FooSym.getFlags())
1136 EXPECT_EQ(Requested.size(), 1U) << "Expected one symbol requested";
1137 EXPECT_EQ(*Requested.begin(), Foo) << "Expected \"Foo\" requested";
1162 EXPECT_EQ(FooSymResult.getAddress(), FooSym.getAddress())
1170 EXPECT_EQ(BarSymResult.getAddress(), BarSym.getAddress())
1192 EXPECT_EQ(Result->count(Foo), 1U) << "\"Foo\" entry missing";
1193 EXPECT_EQ(Result->count(Bar), 1U) << "\"Bar\" entry missing";
1194 EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
1196 EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())
unittests/ExecutionEngine/Orc/GlobalMappingLayerTest.cpp 37 EXPECT_EQ(H, 42) << "Incorrect result from addModule";
45 EXPECT_EQ(cantFail(BarSym.getAddress()),
52 EXPECT_EQ(cantFail(FooSym2.getAddress()),
unittests/ExecutionEngine/Orc/LazyCallThroughAndReexportsTest.cpp 73 EXPECT_EQ(NotifyResolvedCount, 1U)
75 EXPECT_EQ(Result, 42) << "Failed to call through to target";
unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp 40 EXPECT_EQ(RS.size(), 1U)
42 EXPECT_EQ(RS.count(Bar), 1U)
50 EXPECT_EQ(Result->size(), 2U) << "Unexpected number of resolved symbols";
51 EXPECT_EQ(Result->count(Foo), 1U) << "Missing lookup result for foo";
52 EXPECT_EQ(Result->count(Bar), 1U) << "Missing lookup result for bar";
53 EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
55 EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())
64 EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol";
65 EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to not be resolved";
93 EXPECT_EQ(RS->size(), 1U) << "Wrong number of symbols returned";
94 EXPECT_EQ(RS->count(Bar), 1U) << "Incorrect responsibility set returned";
103 EXPECT_EQ(Result->size(), 2U) << "Wrong number of symbols resolved";
104 EXPECT_EQ(Result->count(Foo), 1U) << "Result for foo missing";
105 EXPECT_EQ(Result->count(Bar), 1U) << "Result for bar missing";
106 EXPECT_EQ((*Result)[Foo].getAddress(), FooAddr) << "Wrong address for foo";
107 EXPECT_EQ((*Result)[Foo].getFlags(), FooSym.getFlags())
109 EXPECT_EQ((*Result)[Bar].getAddress(), BarAddr) << "Wrong address for bar";
110 EXPECT_EQ((*Result)[Bar].getFlags(), BarSym.getFlags())
119 EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol";
120 EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to be unresolved";
unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp 105 EXPECT_EQ(DebugSectionSeen, false)
116 EXPECT_EQ(DebugSectionSeen, true)
208 EXPECT_EQ(MM->FinalizationCount, 1)
276 EXPECT_EQ(MM->NeedsToReserveAllocationSpaceCount, 1)
unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp 50 EXPECT_EQ(MockKey, K) << "Key should pass through";
51 EXPECT_EQ(MockObject + 1, *Obj) << "Transform should be applied";
62 EXPECT_EQ("addObject", LastCalled);
67 EXPECT_EQ(MockKey, K);
74 EXPECT_EQ("removeObject", LastCalled);
80 EXPECT_EQ(MockName, Name) << "Name should pass through";
81 EXPECT_EQ(MockBool, ExportedSymbolsOnly) << "Flag should pass through";
91 EXPECT_EQ("findSymbol", LastCalled);
92 EXPECT_EQ(cantFail(MockSymbol.getAddress()),
100 EXPECT_EQ(MockKey, K) << "VModuleKey should pass through";
101 EXPECT_EQ(MockName, Name) << "Name should pass through";
102 EXPECT_EQ(MockBool, ExportedSymbolsOnly) << "Flag should pass through";
114 EXPECT_EQ("findSymbolIn", LastCalled);
115 EXPECT_EQ(cantFail(MockSymbol.getAddress()),
122 EXPECT_EQ(MockKey, K) << "VModuleKey should pass through";
130 EXPECT_EQ("emitAndFinalize", LastCalled);
136 EXPECT_EQ(MockKey, K);
137 EXPECT_EQ(MockLocalAddress, LocalAddress);
138 EXPECT_EQ(MockTargetAddress, TargetAddr);
148 EXPECT_EQ("mapSectionAddress", LastCalled);
212 EXPECT_EQ(223, *Obj2) << "Expected mutation";
248 EXPECT_EQ(*Mutatee, *Out) << "Expected in-place transform";
249 EXPECT_EQ(278, *Mutatee) << "Expected incrementing transform";
255 EXPECT_EQ(289, *OwnedObj) << "Expected incrementing transform";
unittests/ExecutionEngine/Orc/OrcCAPITest.cpp 114 EXPECT_EQ(Result, 42)
124 EXPECT_EQ(Result, 42)
151 EXPECT_EQ(Result, 42)
176 EXPECT_EQ(Result, 42)
205 EXPECT_EQ(Result, 42)
unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp 184 EXPECT_EQ(B, true)
222 EXPECT_EQ(Channels.first->SendCalls, 2U)
227 EXPECT_EQ(Channels.second->SendCalls, 2U)
239 EXPECT_EQ(X, 21) << "Server int(int) receieved unexpected result";
260 EXPECT_EQ(*Result, 42)
285 EXPECT_EQ(B, true) << "Server void(bool) receieved unexpected result";
330 EXPECT_EQ(X, 21) << "Server int(int) receieved unexpected result";
351 EXPECT_EQ(*Result, 42)
376 EXPECT_EQ(X, 21) << "Server int(int) receieved unexpected result";
402 EXPECT_EQ(*Result, 42)
426 EXPECT_EQ(S, "hello")
472 EXPECT_EQ(S8, -101) << "int8_t serialization broken";
473 EXPECT_EQ(U8, 250) << "uint8_t serialization broken";
474 EXPECT_EQ(S16, -10000) << "int16_t serialization broken";
475 EXPECT_EQ(U16, 10000) << "uint16_t serialization broken";
476 EXPECT_EQ(S32, -1000000000) << "int32_t serialization broken";
477 EXPECT_EQ(U32, 1000000000ULL) << "uint32_t serialization broken";
478 EXPECT_EQ(S64, -10000000000) << "int64_t serialization broken";
479 EXPECT_EQ(U64, 10000000000ULL) << "uint64_t serialization broken";
480 EXPECT_EQ(B, true) << "bool serialization broken";
481 EXPECT_EQ(S, "foo") << "std::string serialization broken";
482 EXPECT_EQ(V, std::vector<int>({42, 7}))
484 EXPECT_EQ(S2, std::set<int>({7, 42})) << "std::set serialization broken";
485 EXPECT_EQ(M, (std::map<int, bool>({{7, false}, {42, true}})))
670 EXPECT_EQ(DE.getValue(), 42ULL)
702 EXPECT_EQ(*ValOrErr, 42ULL)
740 EXPECT_EQ(DE.getValue(), 7ULL)
813 EXPECT_EQ(A, 2) << "First parallel call returned bogus result";
814 EXPECT_EQ(B, 4) << "Second parallel call returned bogus result";
815 EXPECT_EQ(C, 6) << "Third parallel call returned bogus result";
876 EXPECT_EQ(B, true)
889 EXPECT_EQ(B, true)
unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp 140 EXPECT_EQ(RPCObjContents.size(), ObjContents.size())
179 EXPECT_EQ(ErrMsg, "AddObjectFailure - Test Message")
215 EXPECT_EQ(ErrMsg, "AddObjectFailure - Test Message")
281 EXPECT_EQ(ErrMsg, "Object handle 42 not found")
319 EXPECT_EQ(ErrMsg, "Object handle 42 not found")
337 EXPECT_EQ(ErrMsg, "Could not find symbol 'badsymbol'")
382 EXPECT_EQ(cantFail(Sym1.getAddress()), 0x12348765ULL)
392 EXPECT_EQ(ErrMsg, "Could not find symbol 'badsymbol'")
419 EXPECT_EQ(ErrMsg, "Could not find symbol 'barbaz'")
471 EXPECT_EQ(cantFail(Sym1.getAddress()), 0x12348765ULL)
479 EXPECT_EQ(ErrMsg, "Could not find symbol 'barbaz'")
545 EXPECT_EQ(ErrMsg, "Object handle 1 not found")
581 EXPECT_EQ(ErrMsg, "Object handle 1 not found")
unittests/ExecutionEngine/Orc/SymbolStringPoolTest.cpp 27 EXPECT_EQ(P1, P2) << "Failed to unique entries";
39 EXPECT_EQ(*Foo, "foo") << "Equality on dereferenced string failed";
unittests/IR/AsmWriterTest.cpp 46 EXPECT_EQ(S, "i32 <badref>");
61 EXPECT_EQ("!DIExpression(DW_OP_constu, 4, DW_OP_minus, DW_OP_deref)",
unittests/IR/AttributesTest.cpp 22 EXPECT_EQ(AttrA, AttrB);
29 EXPECT_EQ(SetA, SetB);
147 EXPECT_EQ(Align(8), AL.getParamAlignment(0));
148 EXPECT_EQ(Align(32), AL.getParamAlignment(1));
154 EXPECT_EQ(Align(8), AL.getParamAlignment(0));
155 EXPECT_EQ(Align(32), AL.getParamAlignment(1));
171 EXPECT_EQ(2U, AL.getNumAttrSets());
180 EXPECT_EQ(A.getAsString(), "byval(%mystruct)");
183 EXPECT_EQ(A.getAsString(), "byval");
186 EXPECT_EQ(A.getAsString(), "byval(i32)");
unittests/IR/BasicBlockTest.cpp 75 EXPECT_EQ(std::distance(Phis.begin(), Phis.end()), 3);
76 EXPECT_EQ(&*Phis.begin(), P1);
77 EXPECT_EQ(std::distance(ReversedPhis.begin(), ReversedPhis.end()), 3);
78 EXPECT_EQ(&*ReversedPhis.begin(), P3);
82 EXPECT_EQ(BB.get(), PN.getIncomingBlock(0));
83 EXPECT_EQ(BB1.get(), PN.getIncomingBlock(1));
84 EXPECT_EQ(BB2.get(), PN.getIncomingBlock(2));
125 EXPECT_EQ(static_cast<size_t>(BB1->sizeWithoutDebug()), Exp.size());
126 EXPECT_EQ(static_cast<size_t>(BBConst->sizeWithoutDebug()), Exp.size());
unittests/IR/CFGBuilder.cpp 180 EXPECT_EQ(DSwitch->getNumCases(), 2U);
198 EXPECT_EQ(i, NumUpdates);
208 EXPECT_EQ(DSwitch->getNumCases(), 2U);
232 EXPECT_EQ(UpdateC->Action, CFGBuilder::ActionKind::Delete);
233 EXPECT_EQ(UpdateC->Edge.From, "c");
234 EXPECT_EQ(UpdateC->Edge.To, "d");
240 EXPECT_EQ(i, NumUpdates);
262 EXPECT_EQ(i, NumUpdates);
unittests/IR/ConstantRangeTest.cpp 94 EXPECT_EQ(Exact, CR);
131 EXPECT_EQ(Exact, CR);
193 EXPECT_EQ(Full, Full);
194 EXPECT_EQ(Empty, Empty);
195 EXPECT_EQ(One, One);
196 EXPECT_EQ(Some, Some);
197 EXPECT_EQ(Wrap, Wrap);
211 EXPECT_EQ(Full.getSingleElement(), static_cast<APInt *>(nullptr));
212 EXPECT_EQ(Empty.getSingleElement(), static_cast<APInt *>(nullptr));
213 EXPECT_EQ(Full.getSingleMissingElement(), static_cast<APInt *>(nullptr));
214 EXPECT_EQ(Empty.getSingleMissingElement(), static_cast<APInt *>(nullptr));
216 EXPECT_EQ(*One.getSingleElement(), APInt(16, 0xa));
217 EXPECT_EQ(Some.getSingleElement(), static_cast<APInt *>(nullptr));
218 EXPECT_EQ(Wrap.getSingleElement(), static_cast<APInt *>(nullptr));
220 EXPECT_EQ(One.getSingleMissingElement(), static_cast<APInt *>(nullptr));
221 EXPECT_EQ(Some.getSingleMissingElement(), static_cast<APInt *>(nullptr));
224 EXPECT_EQ(*OneInverse.getSingleMissingElement(), *One.getSingleElement());
234 EXPECT_EQ(Full.getUnsignedMax(), APInt(16, UINT16_MAX));
235 EXPECT_EQ(One.getUnsignedMax(), APInt(16, 0xa));
236 EXPECT_EQ(Some.getUnsignedMax(), APInt(16, 0xaa9));
237 EXPECT_EQ(Wrap.getUnsignedMax(), APInt(16, UINT16_MAX));
239 EXPECT_EQ(Full.getUnsignedMin(), APInt(16, 0));
240 EXPECT_EQ(One.getUnsignedMin(), APInt(16, 0xa));
241 EXPECT_EQ(Some.getUnsignedMin(), APInt(16, 0xa));
242 EXPECT_EQ(Wrap.getUnsignedMin(), APInt(16, 0));
244 EXPECT_EQ(Full.getSignedMax(), APInt(16, INT16_MAX));
245 EXPECT_EQ(One.getSignedMax(), APInt(16, 0xa));
246 EXPECT_EQ(Some.getSignedMax(), APInt(16, 0xaa9));
247 EXPECT_EQ(Wrap.getSignedMax(), APInt(16, INT16_MAX));
249 EXPECT_EQ(Full.getSignedMin(), APInt(16, (uint64_t)INT16_MIN));
250 EXPECT_EQ(One.getSignedMin(), APInt(16, 0xa));
251 EXPECT_EQ(Some.getSignedMin(), APInt(16, 0xa));
252 EXPECT_EQ(Wrap.getSignedMin(), APInt(16, (uint64_t)INT16_MIN));
255 EXPECT_EQ(ConstantRange(APInt(4, 7), APInt(4, 0)).getSignedMax(),
306 EXPECT_EQ(TOne, ConstantRange(One.getLower().trunc(10),
313 EXPECT_EQ(TwoFive.truncate(2), ConstantRange(APInt(2, 2), APInt(2, 1)));
321 EXPECT_EQ(FiveSeven.truncate(2), ConstantRange(APInt(2, 1), APInt(2, 3)));
325 EXPECT_EQ(SevenOne.truncate(2), ConstantRange(APInt(2, 3), APInt(2, 1)));
334 EXPECT_EQ(ZFull, ConstantRange(APInt(20, 0), APInt(20, 0x10000)));
336 EXPECT_EQ(ZOne, ConstantRange(One.getLower().zext(20),
338 EXPECT_EQ(ZSome, ConstantRange(Some.getLower().zext(20),
340 EXPECT_EQ(ZWrap, ConstantRange(APInt(20, 0), APInt(20, 0x10000)));
344 EXPECT_EQ(FiveZero.zeroExtend(7), ConstantRange(APInt(7, 5), APInt(7, 8)));
353 EXPECT_EQ(SFull, ConstantRange(APInt(20, (uint64_t)INT16_MIN, true),
356 EXPECT_EQ(SOne, ConstantRange(One.getLower().sext(20),
358 EXPECT_EQ(SSome, ConstantRange(Some.getLower().sext(20),
360 EXPECT_EQ(SWrap, ConstantRange(APInt(20, (uint64_t)INT16_MIN, true),
363 EXPECT_EQ(ConstantRange(APInt(8, 120), APInt(8, 140)).signExtend(16),
366 EXPECT_EQ(ConstantRange(APInt(16, 0x0200), APInt(16, 0x8000)).signExtend(19),
371 EXPECT_EQ(Empty.intersectWith(Full), Empty);
372 EXPECT_EQ(Empty.intersectWith(Empty), Empty);
373 EXPECT_EQ(Empty.intersectWith(One), Empty);
374 EXPECT_EQ(Empty.intersectWith(Some), Empty);
375 EXPECT_EQ(Empty.intersectWith(Wrap), Empty);
376 EXPECT_EQ(Full.intersectWith(Full), Full);
377 EXPECT_EQ(Some.intersectWith(Some), Some);
378 EXPECT_EQ(Some.intersectWith(One), One);
379 EXPECT_EQ(Full.intersectWith(One), One);
380 EXPECT_EQ(Full.intersectWith(Some), Some);
381 EXPECT_EQ(Some.intersectWith(Wrap), Empty);
382 EXPECT_EQ(One.intersectWith(Wrap), Empty);
383 EXPECT_EQ(One.intersectWith(Wrap), Wrap.intersectWith(One));
395 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 2)));
400 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 2), APInt(32, 0)));
405 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 4), APInt(32, 0)));
410 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 5), APInt(32, 1)));
415 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 7), APInt(32, 4)));
420 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 4), APInt(32, 2)));
425 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 15), APInt(32, 0)));
494 EXPECT_EQ(Expected, SmallestCR);
495 EXPECT_EQ(Expected, UnsignedCR);
496 EXPECT_EQ(Expected, SignedCR);
520 EXPECT_EQ(Variant1, SmallestCR);
522 EXPECT_EQ(Variant2, SmallestCR);
530 EXPECT_EQ(Variant1, UnsignedCR);
532 EXPECT_EQ(Variant2, UnsignedCR);
534 EXPECT_EQ(Variant1, UnsignedCR);
536 EXPECT_EQ(Variant2, UnsignedCR);
544 EXPECT_EQ(Variant1, SignedCR);
546 EXPECT_EQ(Variant2, SignedCR);
548 EXPECT_EQ(Variant1, SignedCR);
550 EXPECT_EQ(Variant2, SignedCR);
579 EXPECT_EQ(Wrap.unionWith(One),
581 EXPECT_EQ(One.unionWith(Wrap), Wrap.unionWith(One));
582 EXPECT_EQ(Empty.unionWith(Empty), Empty);
583 EXPECT_EQ(Full.unionWith(Full), Full);
584 EXPECT_EQ(Some.unionWith(Wrap), Full);
587 EXPECT_EQ(ConstantRange(APInt(16, 14), APInt(16, 1)).unionWith(
590 EXPECT_EQ(ConstantRange(APInt(16, 6), APInt(16, 4)).unionWith(
593 EXPECT_EQ(ConstantRange(APInt(16, 1), APInt(16, 0)).unionWith(
599 EXPECT_EQ(Full.difference(Empty), Full);
600 EXPECT_EQ(Full.difference(Full), Empty);
601 EXPECT_EQ(Empty.difference(Empty), Empty);
602 EXPECT_EQ(Empty.difference(Full), Empty);
610 EXPECT_EQ(A.difference(B), C);
611 EXPECT_EQ(B.difference(A), D);
612 EXPECT_EQ(E.difference(A), F);
616 EXPECT_EQ(Full.subtract(APInt(16, 4)), Full);
617 EXPECT_EQ(Empty.subtract(APInt(16, 4)), Empty);
618 EXPECT_EQ(Some.subtract(APInt(16, 4)),
620 EXPECT_EQ(Wrap.subtract(APInt(16, 4)),
622 EXPECT_EQ(One.subtract(APInt(16, 4)),
627 EXPECT_EQ(Full.add(APInt(16, 4)), Full);
628 EXPECT_EQ(Full.add(Full), Full);
629 EXPECT_EQ(Full.add(Empty), Empty);
630 EXPECT_EQ(Full.add(One), Full);
631 EXPECT_EQ(Full.add(Some), Full);
632 EXPECT_EQ(Full.add(Wrap), Full);
633 EXPECT_EQ(Empty.add(Empty), Empty);
634 EXPECT_EQ(Empty.add(One), Empty);
635 EXPECT_EQ(Empty.add(Some), Empty);
636 EXPECT_EQ(Empty.add(Wrap), Empty);
637 EXPECT_EQ(Empty.add(APInt(16, 4)), Empty);
638 EXPECT_EQ(Some.add(APInt(16, 4)),
640 EXPECT_EQ(Wrap.add(APInt(16, 4)),
642 EXPECT_EQ(One.add(APInt(16, 4)),
674 EXPECT_EQ(Exact, CR);
708 EXPECT_EQ(Exact, CR);
754 EXPECT_EQ(Exact, CR);
761 EXPECT_EQ(Empty.addWithNoWrap(Some, OBO::NoSignedWrap), Empty);
762 EXPECT_EQ(Some.addWithNoWrap(Empty, OBO::NoSignedWrap), Empty);
763 EXPECT_EQ(Full.addWithNoWrap(Full, OBO::NoSignedWrap), Full);
766 EXPECT_EQ(Full.addWithNoWrap(ConstantRange(APInt(16, 1), APInt(16, 2)),
769 EXPECT_EQ(ConstantRange(APInt(16, 1), APInt(16, 2))
772 EXPECT_EQ(Full.addWithNoWrap(ConstantRange(APInt(16, -1), APInt(16, 0)),
775 EXPECT_EQ(ConstantRange(APInt(8, 100), APInt(8, 120))
779 EXPECT_EQ(ConstantRange(APInt(8, -120), APInt(8, -100))
783 EXPECT_EQ(ConstantRange(APInt(8, 0), APInt(8, 101))
787 EXPECT_EQ(ConstantRange(APInt(8, 0), APInt(8, 101))
791 EXPECT_EQ(ConstantRange(APInt(8, -50), APInt(8, 50))
795 EXPECT_EQ(ConstantRange(APInt(8, 10), APInt(8, 20))
799 EXPECT_EQ(ConstantRange(APInt(8, 120), APInt(8, -10))
803 EXPECT_EQ(ConstantRange(APInt(8, 5), APInt(8, 20))
816 EXPECT_EQ(Empty.addWithNoWrap(Some, OBO::NoUnsignedWrap), Empty);
817 EXPECT_EQ(Some.addWithNoWrap(Empty, OBO::NoUnsignedWrap), Empty);
818 EXPECT_EQ(Full.addWithNoWrap(Full, OBO::NoUnsignedWrap), Full);
821 EXPECT_EQ(Full.addWithNoWrap(ConstantRange(APInt(16, 1), APInt(16, 2)),
824 EXPECT_EQ(ConstantRange(APInt(16, 1), APInt(16, 2))
827 EXPECT_EQ(ConstantRange(APInt(8, 200), APInt(8, 220))
831 EXPECT_EQ(ConstantRange(APInt(8, 0), APInt(8, 101))
835 EXPECT_EQ(ConstantRange(APInt(8, 0), APInt(8, 101))
839 EXPECT_EQ(ConstantRange(APInt(8, 20), APInt(8, 10))
843 EXPECT_EQ(ConstantRange(APInt(8, 10), APInt(8, 20))
847 EXPECT_EQ(ConstantRange(APInt(8, 20), APInt(8, -30))
851 EXPECT_EQ(ConstantRange(APInt(8, 5), APInt(8, 20))
864 EXPECT_EQ(ConstantRange(APInt(8, 50), APInt(8, 100))
868 EXPECT_EQ(ConstantRange(APInt(8, 50), APInt(8, 100))
872 EXPECT_EQ(ConstantRange(APInt(8, 50), APInt(8, 100))
877 EXPECT_EQ(ConstantRange(APInt(8, -100), APInt(8, -50))
881 EXPECT_EQ(ConstantRange(APInt(8, -100), APInt(8, -50))
885 EXPECT_EQ(ConstantRange(APInt(8, -100), APInt(8, -50))
903 EXPECT_EQ(Full.sub(APInt(16, 4)), Full);
904 EXPECT_EQ(Full.sub(Full), Full);
905 EXPECT_EQ(Full.sub(Empty), Empty);
906 EXPECT_EQ(Full.sub(One), Full);
907 EXPECT_EQ(Full.sub(Some), Full);
908 EXPECT_EQ(Full.sub(Wrap), Full);
909 EXPECT_EQ(Empty.sub(Empty), Empty);
910 EXPECT_EQ(Empty.sub(One), Empty);
911 EXPECT_EQ(Empty.sub(Some), Empty);
912 EXPECT_EQ(Empty.sub(Wrap), Empty);
913 EXPECT_EQ(Empty.sub(APInt(16, 4)), Empty);
914 EXPECT_EQ(Some.sub(APInt(16, 4)),
916 EXPECT_EQ(Some.sub(Some),
918 EXPECT_EQ(Wrap.sub(APInt(16, 4)),
920 EXPECT_EQ(One.sub(APInt(16, 4)),
925 EXPECT_EQ(Full.multiply(Full), Full);
926 EXPECT_EQ(Full.multiply(Empty), Empty);
927 EXPECT_EQ(Full.multiply(One), Full);
928 EXPECT_EQ(Full.multiply(Some), Full);
929 EXPECT_EQ(Full.multiply(Wrap), Full);
930 EXPECT_EQ(Empty.multiply(Empty), Empty);
931 EXPECT_EQ(Empty.multiply(One), Empty);
932 EXPECT_EQ(Empty.multiply(Some), Empty);
933 EXPECT_EQ(Empty.multiply(Wrap), Empty);
934 EXPECT_EQ(One.multiply(One), ConstantRange(APInt(16, 0xa*0xa),
936 EXPECT_EQ(One.multiply(Some), ConstantRange(APInt(16, 0xa*0xa),
938 EXPECT_EQ(One.multiply(Wrap), Full);
939 EXPECT_EQ(Some.multiply(Some), Full);
940 EXPECT_EQ(Some.multiply(Wrap), Full);
941 EXPECT_EQ(Wrap.multiply(Wrap), Full);
944 EXPECT_EQ(Zero.multiply(Full), Zero);
945 EXPECT_EQ(Zero.multiply(Some), Zero);
946 EXPECT_EQ(Zero.multiply(Wrap), Zero);
947 EXPECT_EQ(Full.multiply(Zero), Zero);
948 EXPECT_EQ(Some.multiply(Zero), Zero);
949 EXPECT_EQ(Wrap.multiply(Zero), Zero);
952 EXPECT_EQ(ConstantRange(APInt(4, 1), APInt(4, 6)).multiply(
956 EXPECT_EQ(ConstantRange(APInt(8, 254), APInt(8, 0)).multiply(
959 EXPECT_EQ(ConstantRange(APInt(8, 254), APInt(8, 255)).multiply(
964 EXPECT_EQ(ConstantRange(APInt(8, -2)).multiply(
970 EXPECT_EQ(Full.umax(Full), Full);
971 EXPECT_EQ(Full.umax(Empty), Empty);
972 EXPECT_EQ(Full.umax(Some), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
973 EXPECT_EQ(Full.umax(Wrap), Full);
974 EXPECT_EQ(Full.umax(Some), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
975 EXPECT_EQ(Empty.umax(Empty), Empty);
976 EXPECT_EQ(Empty.umax(Some), Empty);
977 EXPECT_EQ(Empty.umax(Wrap), Empty);
978 EXPECT_EQ(Empty.umax(One), Empty);
979 EXPECT_EQ(Some.umax(Some), Some);
980 EXPECT_EQ(Some.umax(Wrap), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
981 EXPECT_EQ(Some.umax(One), Some);
983 EXPECT_EQ(Wrap.umax(Wrap), Full);
984 EXPECT_EQ(Wrap.umax(One), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
985 EXPECT_EQ(One.umax(One), One);
989 EXPECT_EQ(Full.smax(Full), Full);
990 EXPECT_EQ(Full.smax(Empty), Empty);
991 EXPECT_EQ(Full.smax(Some), ConstantRange(APInt(16, 0xa),
993 EXPECT_EQ(Full.smax(Wrap), Full);
994 EXPECT_EQ(Full.smax(One), ConstantRange(APInt(16, 0xa),
996 EXPECT_EQ(Empty.smax(Empty), Empty);
997 EXPECT_EQ(Empty.smax(Some), Empty);
998 EXPECT_EQ(Empty.smax(Wrap), Empty);
999 EXPECT_EQ(Empty.smax(One), Empty);
1000 EXPECT_EQ(Some.smax(Some), Some);
1001 EXPECT_EQ(Some.smax(Wrap), ConstantRange(APInt(16, 0xa),
1003 EXPECT_EQ(Some.smax(One), Some);
1004 EXPECT_EQ(Wrap.smax(One), ConstantRange(APInt(16, 0xa),
1006 EXPECT_EQ(One.smax(One), One);
1010 EXPECT_EQ(Full.umin(Full), Full);
1011 EXPECT_EQ(Full.umin(Empty), Empty);
1012 EXPECT_EQ(Full.umin(Some), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
1013 EXPECT_EQ(Full.umin(Wrap), Full);
1014 EXPECT_EQ(Empty.umin(Empty), Empty);
1015 EXPECT_EQ(Empty.umin(Some), Empty);
1016 EXPECT_EQ(Empty.umin(Wrap), Empty);
1017 EXPECT_EQ(Empty.umin(One), Empty);
1018 EXPECT_EQ(Some.umin(Some), Some);
1019 EXPECT_EQ(Some.umin(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
1020 EXPECT_EQ(Some.umin(One), One);
1022 EXPECT_EQ(Wrap.umin(Wrap), Full);
1023 EXPECT_EQ(Wrap.umin(One), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
1024 EXPECT_EQ(One.umin(One), One);
1028 EXPECT_EQ(Full.smin(Full), Full);
1029 EXPECT_EQ(Full.smin(Empty), Empty);
1030 EXPECT_EQ(Full.smin(Some), ConstantRange(APInt(16, (uint64_t)INT16_MIN),
1032 EXPECT_EQ(Full.smin(Wrap), Full);
1033 EXPECT_EQ(Empty.smin(Empty), Empty);
1034 EXPECT_EQ(Empty.smin(Some), Empty);
1035 EXPECT_EQ(Empty.smin(Wrap), Empty);
1036 EXPECT_EQ(Empty.smin(One), Empty);
1037 EXPECT_EQ(Some.smin(Some), Some);
1038 EXPECT_EQ(Some.smin(Wrap), ConstantRange(APInt(16, (uint64_t)INT16_MIN),
1040 EXPECT_EQ(Some.smin(One), One);
1042 EXPECT_EQ(Wrap.smin(Wrap), Full);
1043 EXPECT_EQ(Wrap.smin(One), ConstantRange(APInt(16, (uint64_t)INT16_MIN),
1045 EXPECT_EQ(One.smin(One), One);
1049 EXPECT_EQ(Full.udiv(Full), Full);
1050 EXPECT_EQ(Full.udiv(Empty), Empty);
1051 EXPECT_EQ(Full.udiv(One), ConstantRange(APInt(16, 0),
1053 EXPECT_EQ(Full.udiv(Some), ConstantRange(APInt(16, 0),
1055 EXPECT_EQ(Full.udiv(Wrap), Full);
1056 EXPECT_EQ(Empty.udiv(Empty), Empty);
1057 EXPECT_EQ(Empty.udiv(One), Empty);
1058 EXPECT_EQ(Empty.udiv(Some), Empty);
1059 EXPECT_EQ(Empty.udiv(Wrap), Empty);
1060 EXPECT_EQ(One.udiv(One), ConstantRange(APInt(16, 1)));
1061 EXPECT_EQ(One.udiv(Some), ConstantRange(APInt(16, 0), APInt(16, 2)));
1062 EXPECT_EQ(One.udiv(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
1063 EXPECT_EQ(Some.udiv(Some), ConstantRange(APInt(16, 0), APInt(16, 0x111)));
1064 EXPECT_EQ(Some.udiv(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
1065 EXPECT_EQ(Wrap.udiv(Wrap), Full);
1069 EXPECT_EQ(Zero.udiv(One), Zero);
1070 EXPECT_EQ(Zero.udiv(Full), Zero);
1072 EXPECT_EQ(ConstantRange(APInt(16, 0), APInt(16, 99)).udiv(Full),
1074 EXPECT_EQ(ConstantRange(APInt(16, 10), APInt(16, 99)).udiv(Full),
1112 EXPECT_EQ(Envelope, CR);
1131 EXPECT_EQ(Wrapped, CR);
1136 EXPECT_EQ(Full.urem(Empty), Empty);
1137 EXPECT_EQ(Empty.urem(Full), Empty);
1139 EXPECT_EQ(Full.urem(ConstantRange(APInt(16, 0))), Empty);
1141 EXPECT_EQ(Full.urem(Full), ConstantRange(APInt(16, 0), APInt(16, 0xffff)));
1143 EXPECT_EQ(Full.urem(ConstantRange(APInt(16, 0), APInt(16, 123))),
1146 EXPECT_EQ(ConstantRange(APInt(16, 0), APInt(16, 123)).urem(Full),
1149 EXPECT_EQ(ConstantRange(APInt(16, 10), APInt(16, 20))
1153 EXPECT_EQ(ConstantRange(APInt(16, 10), APInt(16, 20))
1157 EXPECT_EQ(ConstantRange(APInt(16, 12), APInt(16, 15))
1172 EXPECT_EQ(Full.srem(Empty), Empty);
1173 EXPECT_EQ(Empty.srem(Full), Empty);
1175 EXPECT_EQ(Full.srem(ConstantRange(APInt(16, 0))), Empty);
1177 EXPECT_EQ(Full.srem(Full), ConstantRange(APInt::getSignedMinValue(16) + 1,
1189 EXPECT_EQ(PosLargeLHS.srem(PosMod), Expected);
1190 EXPECT_EQ(PosLargeLHS.srem(NegMod), Expected);
1193 EXPECT_EQ(NegLargeLHS.srem(PosMod), Expected);
1194 EXPECT_EQ(NegLargeLHS.srem(NegMod), Expected);
1197 EXPECT_EQ(PosNegLargeLHS.srem(PosMod), Expected);
1198 EXPECT_EQ(PosNegLargeLHS.srem(NegMod), Expected);
1202 EXPECT_EQ(PosLHS.srem(PosMod), PosLHS);
1203 EXPECT_EQ(PosLHS.srem(NegMod), PosLHS);
1204 EXPECT_EQ(PosLHS.srem(IntMinMod), PosLHS);
1206 EXPECT_EQ(NegLHS.srem(PosMod), NegLHS);
1207 EXPECT_EQ(NegLHS.srem(NegMod), NegLHS);
1208 EXPECT_EQ(NegLHS.srem(IntMinMod), NegLHS);
1210 EXPECT_EQ(PosNegLHS.srem(PosMod), PosNegLHS);
1211 EXPECT_EQ(PosNegLHS.srem(NegMod), PosNegLHS);
1212 EXPECT_EQ(PosNegLHS.srem(IntMinMod), PosNegLHS);
1216 EXPECT_EQ(PosSmallLHS.srem(PosMod), PosSmallLHS);
1217 EXPECT_EQ(PosSmallLHS.srem(NegMod), PosSmallLHS);
1218 EXPECT_EQ(PosSmallLHS.srem(IntMinMod), PosSmallLHS);
1220 EXPECT_EQ(NegSmallLHS.srem(PosMod), NegSmallLHS);
1221 EXPECT_EQ(NegSmallLHS.srem(NegMod), NegSmallLHS);
1222 EXPECT_EQ(NegSmallLHS.srem(IntMinMod), NegSmallLHS);
1224 EXPECT_EQ(PosNegSmallLHS.srem(PosMod), PosNegSmallLHS);
1225 EXPECT_EQ(PosNegSmallLHS.srem(NegMod), PosNegSmallLHS);
1226 EXPECT_EQ(PosNegSmallLHS.srem(IntMinMod), PosNegSmallLHS);
1230 EXPECT_EQ(ConstantRange(APInt(16, 12), APInt(16, 15))
1247 EXPECT_EQ(Full.shl(Full), Full);
1248 EXPECT_EQ(Full.shl(Empty), Empty);
1249 EXPECT_EQ(Full.shl(One), Full); // TODO: [0, (-1 << 0xa) + 1)
1250 EXPECT_EQ(Full.shl(Some), Full); // TODO: [0, (-1 << 0xa) + 1)
1251 EXPECT_EQ(Full.shl(Wrap), Full);
1252 EXPECT_EQ(Empty.shl(Empty), Empty);
1253 EXPECT_EQ(Empty.shl(One), Empty);
1254 EXPECT_EQ(Empty.shl(Some), Empty);
1255 EXPECT_EQ(Empty.shl(Wrap), Empty);
1256 EXPECT_EQ(One.shl(One), ConstantRange(APInt(16, 0xa << 0xa),
1258 EXPECT_EQ(One.shl(Some), Full); // TODO: [0xa << 0xa, 0)
1259 EXPECT_EQ(One.shl(Wrap), Full); // TODO: [0xa, 0xa << 14 + 1)
1260 EXPECT_EQ(Some.shl(Some), Full); // TODO: [0xa << 0xa, 0xfc01)
1261 EXPECT_EQ(Some.shl(Wrap), Full); // TODO: [0xa, 0x7ff << 0x5 + 1)
1262 EXPECT_EQ(Wrap.shl(Wrap), Full);
1263 EXPECT_EQ(
1266 EXPECT_EQ(One.shl(WrapNullMax), Full);
1270 EXPECT_EQ(Full.lshr(Full), Full);
1271 EXPECT_EQ(Full.lshr(Empty), Empty);
1272 EXPECT_EQ(Full.lshr(One), ConstantRange(APInt(16, 0),
1274 EXPECT_EQ(Full.lshr(Some), ConstantRange(APInt(16, 0),
1276 EXPECT_EQ(Full.lshr(Wrap), Full);
1277 EXPECT_EQ(Empty.lshr(Empty), Empty);
1278 EXPECT_EQ(Empty.lshr(One), Empty);
1279 EXPECT_EQ(Empty.lshr(Some), Empty);
1280 EXPECT_EQ(Empty.lshr(Wrap), Empty);
1281 EXPECT_EQ(One.lshr(One), ConstantRange(APInt(16, 0)));
1282 EXPECT_EQ(One.lshr(Some), ConstantRange(APInt(16, 0)));
1283 EXPECT_EQ(One.lshr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
1284 EXPECT_EQ(Some.lshr(Some), ConstantRange(APInt(16, 0),
1286 EXPECT_EQ(Some.lshr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
1287 EXPECT_EQ(Wrap.lshr(Wrap), Full);
1291 EXPECT_EQ(Full.ashr(Full), Full);
1292 EXPECT_EQ(Full.ashr(Empty), Empty);
1293 EXPECT_EQ(Full.ashr(One), ConstantRange(APInt(16, 0xffe0),
1296 EXPECT_EQ(Full.ashr(Small), ConstantRange(APInt(16, 0xffe0),
1298 EXPECT_EQ(Full.ashr(Some), ConstantRange(APInt(16, 0xffe0),
1300 EXPECT_EQ(Full.ashr(Wrap), Full);
1301 EXPECT_EQ(Empty.ashr(Empty), Empty);
1302 EXPECT_EQ(Empty.ashr(One), Empty);
1303 EXPECT_EQ(Empty.ashr(Some), Empty);
1304 EXPECT_EQ(Empty.ashr(Wrap), Empty);
1305 EXPECT_EQ(One.ashr(One), ConstantRange(APInt(16, 0)));
1306 EXPECT_EQ(One.ashr(Some), ConstantRange(APInt(16, 0)));
1307 EXPECT_EQ(One.ashr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
1308 EXPECT_EQ(Some.ashr(Some), ConstantRange(APInt(16, 0),
1310 EXPECT_EQ(Some.ashr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
1311 EXPECT_EQ(Wrap.ashr(Wrap), Full);
1313 EXPECT_EQ(Neg.ashr(Small), ConstantRange(APInt(16, 0xfffc, true),
1329 EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_NE, LowHalf),
1332 EXPECT_EQ(
1341 EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_ULT,
1345 EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_ULE,
1349 EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_UGT,
1353 EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_UGE,
1359 EXPECT_EQ(
1363 EXPECT_EQ(
1367 EXPECT_EQ(
1371 EXPECT_EQ(
1471 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1475 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1478 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1482 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1487 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1491 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1494 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1498 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1504 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1508 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1511 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1515 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1521 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1525 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1528 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1532 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1538 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1542 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1546 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1549 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1553 EXPECT_EQ(
1558 EXPECT_EQ(
1565 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1568 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1572 EXPECT_EQ(
1579 EXPECT_EQ(
1587 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1592 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1621 EXPECT_EQ(NoOverflow, NoWrap.contains(N1));
1625 EXPECT_EQ(Overflow, !NoWrap.contains(N1));
1698 EXPECT_EQ(Pred, CmpInst::ICMP_ULT);
1699 EXPECT_EQ(RHS, APInt(32, 100));
1703 EXPECT_EQ(Pred, CmpInst::ICMP_SLT);
1704 EXPECT_EQ(RHS, APInt(32, 100));
1708 EXPECT_EQ(Pred, CmpInst::ICMP_UGE);
1709 EXPECT_EQ(RHS, APInt(32, 100));
1713 EXPECT_EQ(Pred, CmpInst::ICMP_SGE);
1714 EXPECT_EQ(RHS, APInt(32, 100));
1718 EXPECT_EQ(Pred, CmpInst::ICMP_UGE);
1719 EXPECT_EQ(RHS, APInt(32, 0));
1723 EXPECT_EQ(Pred, CmpInst::ICMP_ULT);
1724 EXPECT_EQ(RHS, APInt(32, 0));
1738 EXPECT_EQ(Pred, CmpInst::ICMP_EQ);
1739 EXPECT_EQ(RHS, APInt(32, 100));
1743 EXPECT_EQ(Pred, CmpInst::ICMP_NE);
1744 EXPECT_EQ(RHS, APInt(32, 100));
1748 EXPECT_EQ(Pred, CmpInst::ICMP_NE);
1749 EXPECT_EQ(RHS, APInt(512, 100));
1756 EXPECT_EQ(Pred, CmpInst::ICMP_EQ);
1757 EXPECT_EQ(RHS, APInt(32, 0));
1761 EXPECT_EQ(Pred, CmpInst::ICMP_NE);
1762 EXPECT_EQ(RHS, APInt(32, 0));
1765 EXPECT_EQ(Pred, CmpInst::ICMP_EQ);
1766 EXPECT_EQ(RHS, APInt(32, -1));
1770 EXPECT_EQ(Pred, CmpInst::ICMP_NE);
1771 EXPECT_EQ(RHS, APInt(32, -1));
2070 EXPECT_EQ(Full, ConstantRange::fromKnownBits(Unknown, /*signed*/false));
2071 EXPECT_EQ(Full, ConstantRange::fromKnownBits(Unknown, /*signed*/true));
2080 EXPECT_EQ(Unsigned, ConstantRange::fromKnownBits(Known, /*signed*/false));
2081 EXPECT_EQ(Signed, ConstantRange::fromKnownBits(Known, /*signed*/true));
2087 EXPECT_EQ(CR1, ConstantRange::fromKnownBits(Known, /*signed*/false));
2088 EXPECT_EQ(CR1, ConstantRange::fromKnownBits(Known, /*signed*/true));
2094 EXPECT_EQ(CR2, ConstantRange::fromKnownBits(Known, /*signed*/false));
2095 EXPECT_EQ(CR2, ConstantRange::fromKnownBits(Known, /*signed*/true));
2126 EXPECT_EQ(UnsignedCR, ConstantRange::fromKnownBits(Known, false));
2127 EXPECT_EQ(SignedCR, ConstantRange::fromKnownBits(Known, true));
2154 EXPECT_EQ(AllNegative, CR.isAllNegative());
2155 EXPECT_EQ(AllNonNegative, CR.isAllNonNegative());
2221 EXPECT_EQ(Exact, AbsCR);
unittests/IR/ConstantsTest.cpp 29 EXPECT_EQ(NegOne, ConstantInt::getSigned(Int1, -1));
34 EXPECT_EQ(Zero, ConstantExpr::getAdd(One, One));
38 EXPECT_EQ(Zero, ConstantExpr::getAdd(NegOne, One));
42 EXPECT_EQ(Zero, ConstantExpr::getAdd(NegOne, NegOne));
46 EXPECT_EQ(Zero, ConstantExpr::getSub(NegOne, One));
50 EXPECT_EQ(Zero, ConstantExpr::getSub(One, NegOne));
54 EXPECT_EQ(Zero, ConstantExpr::getSub(One, One));
58 EXPECT_EQ(Undef, ConstantExpr::getShl(One, One));
62 EXPECT_EQ(One, ConstantExpr::getShl(One, Zero));
66 EXPECT_EQ(Undef, ConstantExpr::getLShr(One, One));
70 EXPECT_EQ(Undef, ConstantExpr::getAShr(One, One));
74 EXPECT_EQ(One, ConstantExpr::getMul(NegOne, One));
78 EXPECT_EQ(One, ConstantExpr::getSDiv(NegOne, One));
82 EXPECT_EQ(One, ConstantExpr::getSDiv(One, NegOne));
86 EXPECT_EQ(One, ConstantExpr::getUDiv(NegOne, One));
90 EXPECT_EQ(One, ConstantExpr::getUDiv(One, NegOne));
94 EXPECT_EQ(Zero, ConstantExpr::getSRem(NegOne, One));
98 EXPECT_EQ(Zero, ConstantExpr::getURem(NegOne, One));
102 EXPECT_EQ(Zero, ConstantExpr::getSRem(One, NegOne));
108 EXPECT_EQ(100, ConstantInt::get(Int8Ty, 100, false)->getSExtValue());
109 EXPECT_EQ(100, ConstantInt::get(Int8Ty, 100, true)->getSExtValue());
110 EXPECT_EQ(100, ConstantInt::getSigned(Int8Ty, 100)->getSExtValue());
111 EXPECT_EQ(-50, ConstantInt::get(Int8Ty, 206)->getSExtValue());
112 EXPECT_EQ(-50, ConstantInt::getSigned(Int8Ty, -50)->getSExtValue());
113 EXPECT_EQ(206U, ConstantInt::getSigned(Int8Ty, -50)->getZExtValue());
116 EXPECT_EQ(0x3b, ConstantInt::get(Int8Ty, 0x13b)->getSExtValue());
139 EXPECT_EQ(Constant::getNullValue(Int64Ty),
144 EXPECT_EQ(Constant::getNullValue(Int32PtrTy),
149 EXPECT_EQ(Constant::getNullValue(Int64VecTy),
154 EXPECT_EQ(Constant::getNullValue(Int32PtrVecTy),
291 EXPECT_EQ(Undef16, ConstantExpr::getExtractElement(P6, Two));
292 EXPECT_EQ(Undef16, ConstantExpr::getExtractElement(P6, Big));
293 EXPECT_EQ(Undef16, ConstantExpr::getExtractElement(P6, Undef64));
295 EXPECT_EQ(Elt, ConstantExpr::getExtractElement(
297 EXPECT_EQ(UndefV16, ConstantExpr::getInsertElement(P6, Elt, Two));
298 EXPECT_EQ(UndefV16, ConstantExpr::getInsertElement(P6, Elt, Big));
299 EXPECT_EQ(UndefV16, ConstantExpr::getInsertElement(P6, Elt, Undef64));
unittests/IR/DataLayoutTest.cpp 19 EXPECT_EQ(MaybeAlign(0), DataLayout("").getFunctionPtrAlign());
20 EXPECT_EQ(MaybeAlign(1), DataLayout("Fi8").getFunctionPtrAlign());
21 EXPECT_EQ(MaybeAlign(2), DataLayout("Fi16").getFunctionPtrAlign());
22 EXPECT_EQ(MaybeAlign(4), DataLayout("Fi32").getFunctionPtrAlign());
23 EXPECT_EQ(MaybeAlign(8), DataLayout("Fi64").getFunctionPtrAlign());
24 EXPECT_EQ(MaybeAlign(1), DataLayout("Fn8").getFunctionPtrAlign());
25 EXPECT_EQ(MaybeAlign(2), DataLayout("Fn16").getFunctionPtrAlign());
26 EXPECT_EQ(MaybeAlign(4), DataLayout("Fn32").getFunctionPtrAlign());
27 EXPECT_EQ(MaybeAlign(8), DataLayout("Fn64").getFunctionPtrAlign());
28 EXPECT_EQ(DataLayout::FunctionPtrAlignType::Independent, \
30 EXPECT_EQ(DataLayout::FunctionPtrAlignType::Independent, \
32 EXPECT_EQ(DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign, \
34 EXPECT_EQ(DataLayout("Fi8"), DataLayout("Fi8"));
44 EXPECT_EQ(a, b);
46 EXPECT_EQ(a, c);
53 EXPECT_EQ(Align(16),
55 EXPECT_EQ(Align(4),
unittests/IR/DebugInfoTest.cpp 18 EXPECT_EQ(DINode::FlagPublic, DINode::getFlag("DIFlagPublic"));
19 EXPECT_EQ(DINode::FlagProtected, DINode::getFlag("DIFlagProtected"));
20 EXPECT_EQ(DINode::FlagPrivate, DINode::getFlag("DIFlagPrivate"));
21 EXPECT_EQ(DINode::FlagVector, DINode::getFlag("DIFlagVector"));
22 EXPECT_EQ(DINode::FlagRValueReference,
26 EXPECT_EQ(0u, DINode::getFlag("DIFlagAccessibility"));
29 EXPECT_EQ(0u, DINode::getFlag("FlagVector"));
30 EXPECT_EQ(0u, DINode::getFlag("Vector"));
31 EXPECT_EQ(0u, DINode::getFlag("other things"));
32 EXPECT_EQ(0u, DINode::getFlag("DIFlagOther"));
37 EXPECT_EQ(StringRef("DIFlagPublic"),
39 EXPECT_EQ(StringRef("DIFlagProtected"),
41 EXPECT_EQ(StringRef("DIFlagPrivate"),
43 EXPECT_EQ(StringRef("DIFlagVector"),
45 EXPECT_EQ(StringRef("DIFlagRValueReference"),
49 EXPECT_EQ(StringRef("DIFlagPublic"),
53 EXPECT_EQ(StringRef(),
55 EXPECT_EQ(StringRef(), DINode::getFlagString(DINode::FlagFwdDecl |
57 EXPECT_EQ(StringRef(),
unittests/IR/DebugTypeODRUniquingTest.cpp 42 EXPECT_EQ(UUID.getString(), CT.getIdentifier());
45 EXPECT_EQ(&CT, DICompositeType::getODRTypeIfExists(Context, UUID));
46 EXPECT_EQ(&CT, DICompositeType::getODRType(
50 EXPECT_EQ(&CT,
74 EXPECT_EQ(&CT, DICompositeType::getODRTypeIfExists(Context, UUID));
75 EXPECT_EQ(dwarf::DW_TAG_class_type, CT.getTag());
78 EXPECT_EQ(&CT, DICompositeType::buildODRType(
81 EXPECT_EQ(dwarf::DW_TAG_class_type, CT.getTag());
84 EXPECT_EQ(&CT, DICompositeType::buildODRType(
88 EXPECT_EQ(dwarf::DW_TAG_structure_type, CT.getTag());
91 EXPECT_EQ(&CT, DICompositeType::buildODRType(
94 EXPECT_EQ(dwarf::DW_TAG_structure_type, CT.getTag());
95 EXPECT_EQ(&CT, DICompositeType::buildODRType(
99 EXPECT_EQ(dwarf::DW_TAG_structure_type, CT.getTag());
139 EXPECT_EQ(&CT,
154 EXPECT_EQ(DINode::FlagArtificial, CT.getFlags());
155 EXPECT_EQ(&UUID, CT.getRawIdentifier());
unittests/IR/DominatorTreeBatchUpdatesTest.cpp 64 EXPECT_EQ(Legalized.size(), 3UL);
87 EXPECT_EQ(Legalized.size(), 3UL);
unittests/IR/DominatorTreeTest.cpp 211 EXPECT_EQ(DominatedBBs.size(), 4UL);
212 EXPECT_EQ(PostDominatedBBs.size(), 1UL);
219 EXPECT_EQ(DominatedBBs.size(), 0UL);
220 EXPECT_EQ(PostDominatedBBs.size(), 0UL);
224 EXPECT_EQ(DT->getNode(BB0)->getDFSNumIn(), 0UL);
225 EXPECT_EQ(DT->getNode(BB0)->getDFSNumOut(), 7UL);
226 EXPECT_EQ(DT->getNode(BB1)->getDFSNumIn(), 1UL);
227 EXPECT_EQ(DT->getNode(BB1)->getDFSNumOut(), 2UL);
228 EXPECT_EQ(DT->getNode(BB2)->getDFSNumIn(), 5UL);
229 EXPECT_EQ(DT->getNode(BB2)->getDFSNumOut(), 6UL);
230 EXPECT_EQ(DT->getNode(BB4)->getDFSNumIn(), 3UL);
231 EXPECT_EQ(DT->getNode(BB4)->getDFSNumOut(), 4UL);
234 EXPECT_EQ(DT->getNode(BB0)->getLevel(), 0U);
235 EXPECT_EQ(DT->getNode(BB1)->getLevel(), 1U);
236 EXPECT_EQ(DT->getNode(BB2)->getLevel(), 1U);
237 EXPECT_EQ(DT->getNode(BB4)->getLevel(), 1U);
246 EXPECT_EQ(DT->getNode(BB0)->getDFSNumIn(), 0UL);
247 EXPECT_EQ(DT->getNode(BB0)->getDFSNumOut(), 9UL);
248 EXPECT_EQ(DT->getNode(BB1)->getDFSNumIn(), 1UL);
249 EXPECT_EQ(DT->getNode(BB1)->getDFSNumOut(), 4UL);
250 EXPECT_EQ(DT->getNode(BB2)->getDFSNumIn(), 7UL);
251 EXPECT_EQ(DT->getNode(BB2)->getDFSNumOut(), 8UL);
252 EXPECT_EQ(DT->getNode(BB3)->getDFSNumIn(), 2UL);
253 EXPECT_EQ(DT->getNode(BB3)->getDFSNumOut(), 3UL);
254 EXPECT_EQ(DT->getNode(BB4)->getDFSNumIn(), 5UL);
255 EXPECT_EQ(DT->getNode(BB4)->getDFSNumOut(), 6UL);
258 EXPECT_EQ(DT->getNode(BB0)->getLevel(), 0U);
259 EXPECT_EQ(DT->getNode(BB1)->getLevel(), 1U);
260 EXPECT_EQ(DT->getNode(BB2)->getLevel(), 1U);
261 EXPECT_EQ(DT->getNode(BB3)->getLevel(), 2U);
262 EXPECT_EQ(DT->getNode(BB4)->getLevel(), 1U);
269 EXPECT_EQ(F.begin()->getName(), NewEntry->getName());
405 EXPECT_EQ(DT->compare(NDT), 0);
408 EXPECT_EQ(PDT->compare(NPDT), 0);
497 EXPECT_EQ(DT->compare(NDT), 0);
500 EXPECT_EQ(PDT->compare(NPDT), 0);
581 EXPECT_EQ(DT->getNode(C2), nullptr);
592 EXPECT_EQ(DT->compare(NDT), 0);
595 EXPECT_EQ(PDT->compare(NPDT), 0);
659 EXPECT_EQ(IDFBlocks.size(), 2UL);
660 EXPECT_EQ(DT->getNode(A)->getDFSNumIn(), 0UL);
661 EXPECT_EQ(IDFBlocks[0], D);
662 EXPECT_EQ(IDFBlocks[1], E);
696 EXPECT_EQ(LastUpdate->Action, Insert);
723 EXPECT_EQ(LastUpdate->Action, Insert);
750 EXPECT_EQ(LastUpdate->Action, Insert);
772 EXPECT_EQ(LastUpdate->Action, Insert);
801 EXPECT_EQ(LastUpdate->Action, Insert);
831 EXPECT_EQ(LastUpdate->Action, Insert);
858 EXPECT_EQ(LastUpdate->Action, Delete);
884 EXPECT_EQ(LastUpdate->Action, Delete);
unittests/IR/FunctionTest.cpp 30 EXPECT_EQ(2u, F->arg_size());
40 EXPECT_EQ(&A, F->getArg(i));
71 EXPECT_EQ(2u, Args.size());
82 EXPECT_EQ(Args[I], &A);
85 EXPECT_EQ(2u, I);
94 EXPECT_EQ(2u, I);
106 EXPECT_EQ(Args[I], &A);
109 EXPECT_EQ(2u, I);
146 EXPECT_EQ(MaybeAlign(), Func->getPointerAlignment(DataLayout("")));
147 EXPECT_EQ(Align(1), Func->getPointerAlignment(DataLayout("Fi8")));
148 EXPECT_EQ(Align(1), Func->getPointerAlignment(DataLayout("Fn8")));
149 EXPECT_EQ(Align(2), Func->getPointerAlignment(DataLayout("Fi16")));
150 EXPECT_EQ(Align(2), Func->getPointerAlignment(DataLayout("Fn16")));
151 EXPECT_EQ(Align(4), Func->getPointerAlignment(DataLayout("Fi32")));
152 EXPECT_EQ(Align(4), Func->getPointerAlignment(DataLayout("Fn32")));
156 EXPECT_EQ(MaybeAlign(), Func->getPointerAlignment(DataLayout("")));
157 EXPECT_EQ(Align(1), Func->getPointerAlignment(DataLayout("Fi8")));
158 EXPECT_EQ(Align(4), Func->getPointerAlignment(DataLayout("Fn8")));
159 EXPECT_EQ(Align(2), Func->getPointerAlignment(DataLayout("Fi16")));
160 EXPECT_EQ(Align(4), Func->getPointerAlignment(DataLayout("Fn16")));
161 EXPECT_EQ(Align(4), Func->getPointerAlignment(DataLayout("Fi32")));
162 EXPECT_EQ(Align(4), Func->getPointerAlignment(DataLayout("Fn32")));
unittests/IR/IRBuilderTest.cpp 64 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::minnum);
68 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::maxnum);
72 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::minimum);
76 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::maximum);
80 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::readcyclecounter);
84 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fabs);
90 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fabs);
96 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::pow);
102 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::pow);
108 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fma);
114 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fma);
120 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fma);
144 EXPECT_EQ(FTy->getReturnType(), DstVecTy);
146 EXPECT_EQ(FTy->getParamType(i), ArgTys[i]->getType());
165 EXPECT_EQ(FTy->getReturnType(), VecTy);
167 EXPECT_EQ(FTy->getParamType(i), ArgTys[i]->getType());
190 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fadd);
195 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fsub);
200 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fmul);
205 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fdiv);
210 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_frem);
215 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fptoui);
220 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fptosi);
225 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fptrunc);
230 EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fpext);
234 EXPECT_EQ(CallAttrs.hasAttribute(Attribute::StrictFP), true);
239 EXPECT_EQ(FnAttrs.hasAttribute(Attribute::StrictFP), true);
288 EXPECT_EQ(CII->getIntrinsicID(), Intrinsic::experimental_constrained_fadd);
307 EXPECT_EQ(Start1->getArgOperand(0), Builder.getInt64(-1));
308 EXPECT_EQ(Start2->getArgOperand(0), Builder.getInt64(-1));
309 EXPECT_EQ(Start3->getArgOperand(0), Builder.getInt64(100));
311 EXPECT_EQ(Start1->getArgOperand(1), Var1);
313 EXPECT_EQ(Start3->getArgOperand(1), Var3);
322 EXPECT_EQ(II_Start1->getIntrinsicID(), Intrinsic::lifetime_start);
324 EXPECT_EQ(II_End1->getIntrinsicID(), Intrinsic::lifetime_end);
334 EXPECT_EQ(BI, TI);
335 EXPECT_EQ(2u, TI->getNumSuccessors());
336 EXPECT_EQ(TBB, TI->getSuccessor(0));
337 EXPECT_EQ(FBB, TI->getSuccessor(1));
343 EXPECT_EQ(BI, TI);
344 EXPECT_EQ(2u, TI->getNumSuccessors());
345 EXPECT_EQ(TBB, TI->getSuccessor(0));
346 EXPECT_EQ(FBB, TI->getSuccessor(1));
347 EXPECT_EQ(Weights, TI->getMetadata(LLVMContext::MD_prof));
353 EXPECT_EQ(LP->getName(), "LP");
367 EXPECT_EQ(Ty1, IntegerType::get(Ctx, 1));
372 EXPECT_EQ(IntPtrTy, IntegerType::get(Ctx, IntPtrBitSize));
651 EXPECT_EQ(FPMathB, Builder.getDefaultFPMathTag());
655 EXPECT_EQ(FPMathA, Builder.getDefaultFPMathTag());
662 EXPECT_EQ(F, &*Builder.GetInsertPoint());
665 EXPECT_EQ(BB->end(), Builder.GetInsertPoint());
666 EXPECT_EQ(BB, Builder.GetInsertBlock());
744 EXPECT_EQ(SP->getFile(), GSP->getFile());
745 EXPECT_EQ(SP->getType(), GSP->getType());
746 EXPECT_EQ(SP->getLine(), GSP->getLine());
747 EXPECT_EQ(SP->getScopeLine(), GSP->getScopeLine());
762 EXPECT_EQ("foo", SP->getName());
763 EXPECT_EQ("foo", GSP->getName());
779 EXPECT_EQ(Elt1, X1);
780 EXPECT_EQ(Elt2, X2);
821 EXPECT_EQ(DL1, Builder.getCurrentDebugLocation());
823 EXPECT_EQ(DL1, Call1->getDebugLoc());
827 EXPECT_EQ(DL2, Builder.getCurrentDebugLocation());
829 EXPECT_EQ(DL2, Call2->getDebugLoc());
871 EXPECT_EQ(dwarf::DW_MACINFO_define, MDef1->getMacinfoType());
872 EXPECT_EQ(3u, MDef1->getLine());
873 EXPECT_EQ("M1", MDef1->getName());
874 EXPECT_EQ("V1", MDef1->getValue());
876 EXPECT_EQ(dwarf::DW_MACINFO_undef, MUndef1->getMacinfoType());
877 EXPECT_EQ(7u, MUndef1->getLine());
878 EXPECT_EQ("M1", MUndef1->getName());
879 EXPECT_EQ("", MUndef1->getValue());
881 EXPECT_EQ(dwarf::DW_MACINFO_start_file, TMF2->getMacinfoType());
882 EXPECT_EQ(5u, TMF2->getLine());
883 EXPECT_EQ(File2, TMF2->getFile());
903 EXPECT_EQ(MN0, CU->getRawMacros());
910 EXPECT_EQ(MN1, MF1->getRawElements());
915 EXPECT_EQ(MN2, MF2->getRawElements());
unittests/IR/InstructionsTest.cpp 45 EXPECT_EQ(r0->getNumOperands(), 0U);
46 EXPECT_EQ(r0->op_begin(), r0->op_end());
51 EXPECT_EQ(1U, r1->getNumOperands());
54 EXPECT_EQ(One, *b);
55 EXPECT_EQ(One, r1->getOperand(0));
57 EXPECT_EQ(r1->op_end(), b);
92 EXPECT_EQ(FArgTypes[Idx], Arg->getType());
93 EXPECT_EQ(Call->getArgOperand(Idx)->getType(), Arg->getType());
110 EXPECT_EQ(FArgTypes[Idx], Arg->getType());
111 EXPECT_EQ(Invoke->getArgOperand(Idx)->getType(), Arg->getType());
128 EXPECT_EQ(1U, b0->getNumSuccessors());
131 EXPECT_EQ(1U, b0->getNumOperands());
134 EXPECT_EQ(b0->op_end(), std::next(b0->op_begin()));
136 EXPECT_EQ(b0->op_end(), std::next(b0->op_begin()));
146 EXPECT_EQ(2U, b1->getNumSuccessors());
149 EXPECT_EQ(3U, b1->getNumOperands());
155 EXPECT_EQ(One, *b);
156 EXPECT_EQ(One, b1->getOperand(0));
157 EXPECT_EQ(One, b1->getCondition());
161 EXPECT_EQ(bb1, *b);
162 EXPECT_EQ(bb1, b1->getOperand(1));
163 EXPECT_EQ(bb1, b1->getSuccessor(1));
167 EXPECT_EQ(bb0, *b);
168 EXPECT_EQ(bb0, b1->getOperand(2));
169 EXPECT_EQ(bb0, b1->getSuccessor(0));
172 EXPECT_EQ(b1->op_end(), b);
226 EXPECT_EQ(CastInst::Trunc, CastInst::getCastOpcode(c64, true, V8x8Ty, true));
227 EXPECT_EQ(CastInst::SExt, CastInst::getCastOpcode(c8, true, V8x64Ty, true));
242 EXPECT_EQ(CastInst::AddrSpaceCast, CastInst::getCastOpcode(v2ptr32, true,
374 EXPECT_EQ(GepII0->getNumIndices(), 1u);
375 EXPECT_EQ(GepII1->getNumIndices(), 1u);
376 EXPECT_EQ(GepII2->getNumIndices(), 1u);
377 EXPECT_EQ(GepII3->getNumIndices(), 1u);
417 EXPECT_EQ(O1->getFPAccuracy(), 1.0);
432 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt,
440 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt,
448 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt,
455 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
462 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
481 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
488 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::AddrSpaceCast,
495 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
523 EXPECT_EQ(Call->getTailCallKind(), Clone->getTailCallKind());
555 EXPECT_EQ(Call->getNumArgOperands(), Clone->getNumArgOperands());
556 EXPECT_EQ(Call->getArgOperand(0), Clone->getArgOperand(0));
557 EXPECT_EQ(Call->getCallingConv(), Clone->getCallingConv());
558 EXPECT_EQ(Call->getTailCallKind(), Clone->getTailCallKind());
560 EXPECT_EQ(Call->getDebugLoc(), Clone->getDebugLoc());
561 EXPECT_EQ(Clone->getNumOperandBundles(), 1U);
586 EXPECT_EQ(Invoke->getNormalDest(), Clone->getNormalDest());
587 EXPECT_EQ(Invoke->getUnwindDest(), Clone->getUnwindDest());
588 EXPECT_EQ(Invoke->getNumArgOperands(), Clone->getNumArgOperands());
589 EXPECT_EQ(Invoke->getArgOperand(0), Clone->getArgOperand(0));
590 EXPECT_EQ(Invoke->getCallingConv(), Clone->getCallingConv());
592 EXPECT_EQ(Invoke->getDebugLoc(), Clone->getDebugLoc());
593 EXPECT_EQ(Clone->getNumOperandBundles(), 1U);
675 EXPECT_EQ(Indices[0], GEPI->idx_begin()[0]);
676 EXPECT_EQ(Indices[1], GEPI->idx_begin()[1]);
677 EXPECT_EQ(Indices[2], GEPI->idx_begin()[2]);
678 EXPECT_EQ(GEPI->idx_begin(), GEPI->indices().begin());
679 EXPECT_EQ(GEPI->idx_end(), GEPI->indices().end());
684 EXPECT_EQ(Indices[0], CGEPI->idx_begin()[0]);
685 EXPECT_EQ(Indices[1], CGEPI->idx_begin()[1]);
686 EXPECT_EQ(Indices[2], CGEPI->idx_begin()[2]);
687 EXPECT_EQ(CGEPI->idx_begin(), CGEPI->indices().begin());
688 EXPECT_EQ(CGEPI->idx_end(), CGEPI->indices().end());
715 EXPECT_EQ(1, CI->getCaseValue()->getSExtValue());
716 EXPECT_EQ(BB1.get(), CI->getCaseSuccessor());
717 EXPECT_EQ(2, (CI + 1)->getCaseValue()->getSExtValue());
718 EXPECT_EQ(BB2.get(), (CI + 1)->getCaseSuccessor());
719 EXPECT_EQ(3, (CI + 2)->getCaseValue()->getSExtValue());
720 EXPECT_EQ(BB3.get(), (CI + 2)->getCaseSuccessor());
721 EXPECT_EQ(CI + 1, std::next(CI));
722 EXPECT_EQ(CI + 2, std::next(CI, 2));
723 EXPECT_EQ(CI + 3, std::next(CI, 3));
724 EXPECT_EQ(SI->case_end(), CI + 3);
725 EXPECT_EQ(0, CI - CI);
726 EXPECT_EQ(1, (CI + 1) - CI);
727 EXPECT_EQ(2, (CI + 2) - CI);
728 EXPECT_EQ(3, SI->case_end() - CI);
729 EXPECT_EQ(3, std::distance(CI, SI->case_end()));
734 EXPECT_EQ(1, CCI->getCaseValue()->getSExtValue());
735 EXPECT_EQ(BB1.get(), CCI->getCaseSuccessor());
736 EXPECT_EQ(2, (CCI + 1)->getCaseValue()->getSExtValue());
737 EXPECT_EQ(BB2.get(), (CCI + 1)->getCaseSuccessor());
738 EXPECT_EQ(3, (CCI + 2)->getCaseValue()->getSExtValue());
739 EXPECT_EQ(BB3.get(), (CCI + 2)->getCaseSuccessor());
740 EXPECT_EQ(CCI + 1, std::next(CCI));
741 EXPECT_EQ(CCI + 2, std::next(CCI, 2));
742 EXPECT_EQ(CCI + 3, std::next(CCI, 3));
743 EXPECT_EQ(CCE, CCI + 3);
744 EXPECT_EQ(0, CCI - CCI);
745 EXPECT_EQ(1, (CCI + 1) - CCI);
746 EXPECT_EQ(2, (CCI + 2) - CCI);
747 EXPECT_EQ(3, CCE - CCI);
748 EXPECT_EQ(3, std::distance(CCI, CCE));
752 EXPECT_EQ(1, Handle.getCaseValue()->getSExtValue());
753 EXPECT_EQ(BB1.get(), Handle.getCaseSuccessor());
779 EXPECT_EQ(*SIW.getSuccessorWeight(0), 9u);
780 EXPECT_EQ(*SIW.getSuccessorWeight(1), 1u);
781 EXPECT_EQ(*SIW.getSuccessorWeight(2), 22u);
784 EXPECT_EQ(*SIW.getSuccessorWeight(0), 99u);
785 EXPECT_EQ(*SIW.getSuccessorWeight(1), 11u);
786 EXPECT_EQ(*SIW.getSuccessorWeight(2), 22u);
791 EXPECT_EQ(*SIW.getSuccessorWeight(0), 99u);
792 EXPECT_EQ(*SIW.getSuccessorWeight(1), 11u);
793 EXPECT_EQ(*SIW.getSuccessorWeight(2), 22u);
1030 EXPECT_EQ(Term, BB.begin()->getNextNonDebugInstruction());
1031 EXPECT_EQ(Term->getIterator(), skipDebugIntrinsics(BB.begin()));
1034 EXPECT_EQ(nullptr, Term->getNextNonDebugInstruction());
1099 EXPECT_EQ(&BranchTestExit, CBI.getIndirectDest(0));
1101 EXPECT_EQ(&IfThen, CBI.getIndirectDest(0));
1108 EXPECT_EQ(IndirectBA, ArgBA)
1114 EXPECT_EQ(IndirectBA->getBasicBlock(), &IfThen);
1115 EXPECT_EQ(ArgBA->getBasicBlock(), &IfThen);
unittests/IR/IntrinsicsTest.cpp 26 EXPECT_EQ(0, I);
28 EXPECT_EQ(0, I);
30 EXPECT_EQ(2, I);
32 EXPECT_EQ(3, I);
34 EXPECT_EQ(4, I);
36 EXPECT_EQ(4, I);
unittests/IR/LegacyPassManagerTest.cpp 117 EXPECT_EQ(0, allocated);
127 EXPECT_EQ(run, runc);
161 EXPECT_EQ(0, PassTestBase<P>::allocated);
199 EXPECT_EQ(run, initcount);
200 EXPECT_EQ(finalized, fincount);
229 EXPECT_EQ(inited, N);
230 EXPECT_EQ(fin, N);
256 EXPECT_EQ(0, allocated);
303 EXPECT_EQ(1, mNDM->run);
304 EXPECT_EQ(1, mNDNM->run);
305 EXPECT_EQ(1, mDNM->run);
306 EXPECT_EQ(1, mNDM2->run);
328 EXPECT_EQ(2, mNDM->run);
329 EXPECT_EQ(1, mNDNM->run);
330 EXPECT_EQ(1, mNDM2->run);
331 EXPECT_EQ(1, mDNM->run);
456 EXPECT_EQ(1, mOpt0->run);
459 EXPECT_EQ(0, mOpt1->run);
462 EXPECT_EQ(1, mOpt2->run);
unittests/IR/MDBuilderTest.cpp 28 EXPECT_EQ(Str0->getString(), StringRef(""));
29 EXPECT_EQ(Str1->getString(), StringRef("string"));
35 EXPECT_EQ(MD0, (MDNode *)nullptr);
37 EXPECT_EQ(MD1->getNumOperands(), 1U);
49 EXPECT_EQ(R0, (MDNode *)nullptr);
51 EXPECT_EQ(R1->getNumOperands(), 2U);
56 EXPECT_EQ(C0->getValue(), A);
57 EXPECT_EQ(C1->getValue(), B);
66 EXPECT_EQ(R0->getOperand(0), R0);
67 EXPECT_EQ(R1->getOperand(0), R1);
75 EXPECT_EQ(R0, R1);
78 EXPECT_EQ(cast<MDString>(R0->getOperand(0))->getString(), "Root");
88 EXPECT_EQ(N0, N3);
97 EXPECT_EQ(cast<MDString>(N0->getOperand(0))->getString(), "Node");
98 EXPECT_EQ(cast<MDString>(N1->getOperand(0))->getString(), "edoN");
99 EXPECT_EQ(cast<MDString>(N2->getOperand(0))->getString(), "Node");
100 EXPECT_EQ(N0->getOperand(1), R);
101 EXPECT_EQ(N1->getOperand(1), R);
102 EXPECT_EQ(N2->getOperand(1), R);
104 EXPECT_EQ(mdconst::extract<ConstantInt>(N2->getOperand(2))->getZExtValue(),
unittests/IR/ManglerTest.cpp 53 EXPECT_EQ(mangleStr("foo", Mang, DL), "_foo");
54 EXPECT_EQ(mangleStr("\01foo", Mang, DL), "foo");
55 EXPECT_EQ(mangleStr("?foo", Mang, DL), "_?foo");
56 EXPECT_EQ(mangleFunc("foo", llvm::GlobalValue::ExternalLinkage,
59 EXPECT_EQ(mangleFunc("?foo", llvm::GlobalValue::ExternalLinkage,
62 EXPECT_EQ(mangleFunc("foo", llvm::GlobalValue::PrivateLinkage,
73 EXPECT_EQ(mangleStr("foo", Mang, DL), "_foo");
74 EXPECT_EQ(mangleStr("\01foo", Mang, DL), "foo");
75 EXPECT_EQ(mangleStr("?foo", Mang, DL), "?foo");
76 EXPECT_EQ(mangleFunc("foo", llvm::GlobalValue::ExternalLinkage,
79 EXPECT_EQ(mangleFunc("?foo", llvm::GlobalValue::ExternalLinkage,
82 EXPECT_EQ(mangleFunc("foo", llvm::GlobalValue::PrivateLinkage,
87 EXPECT_EQ(mangleFunc("stdcall", llvm::GlobalValue::ExternalLinkage,
90 EXPECT_EQ(mangleFunc("fastcall", llvm::GlobalValue::ExternalLinkage,
93 EXPECT_EQ(mangleFunc("vectorcall", llvm::GlobalValue::ExternalLinkage,
98 EXPECT_EQ(mangleFunc("?fastcall", llvm::GlobalValue::ExternalLinkage,
109 EXPECT_EQ(mangleStr("foo", Mang, DL), "foo");
110 EXPECT_EQ(mangleStr("\01foo", Mang, DL), "foo");
111 EXPECT_EQ(mangleStr("?foo", Mang, DL), "?foo");
112 EXPECT_EQ(mangleFunc("foo", llvm::GlobalValue::ExternalLinkage,
115 EXPECT_EQ(mangleFunc("?foo", llvm::GlobalValue::ExternalLinkage,
118 EXPECT_EQ(mangleFunc("foo", llvm::GlobalValue::PrivateLinkage,
123 EXPECT_EQ(mangleFunc("stdcall", llvm::GlobalValue::ExternalLinkage,
126 EXPECT_EQ(mangleFunc("fastcall", llvm::GlobalValue::ExternalLinkage,
129 EXPECT_EQ(mangleFunc("vectorcall", llvm::GlobalValue::ExternalLinkage,
134 EXPECT_EQ(mangleFunc("?vectorcall", llvm::GlobalValue::ExternalLinkage,
unittests/IR/MetadataTest.cpp 30 EXPECT_EQ(&Context, &CRU.getContext());
38 EXPECT_EQ(&Context, &CRU.getContext());
47 EXPECT_EQ(&Context, &CRU.getContext());
58 EXPECT_EQ(&Context, &CRU.getContext());
61 EXPECT_EQ(Ptr, ReplaceableUses.get());
145 EXPECT_EQ(s1, s2);
196 EXPECT_EQ(n1, n3);
197 EXPECT_EQ(n4, n1);
198 EXPECT_EQ(n5, n2);
199 EXPECT_EQ(n6, (Metadata *)nullptr);
201 EXPECT_EQ(3u, n1->getNumOperands());
202 EXPECT_EQ(s1, n1->getOperand(0));
203 EXPECT_EQ(CI, n1->getOperand(1));
204 EXPECT_EQ(s2, n1->getOperand(2));
206 EXPECT_EQ(1u, n2->getNumOperands());
207 EXPECT_EQ(n1, n2->getOperand(0));
218 EXPECT_EQ(n, wvh);
239 EXPECT_EQ(Ref1, Ref2);
257 EXPECT_EQ(Ref1, Ref2);
291 EXPECT_EQ(Expected, Actual);
443 EXPECT_EQ(N, NullOp);
563 EXPECT_EQ(Temp.get(), Distinct->getOperand(0));
568 EXPECT_EQ(Empty, Distinct->getOperand(0));
628 EXPECT_EQ(N4, N1->getOperand(0));
629 EXPECT_EQ(N1, N4->getOperand(0));
630 EXPECT_EQ(N1, N5->getOperand(0));
631 EXPECT_EQ(N4, N6->getOperand(0));
645 EXPECT_EQ(nullptr, N->getOperand(0));
650 EXPECT_EQ(Empty, N->getOperand(0));
654 EXPECT_EQ(Temp.get(), N->getOperand(0));
673 EXPECT_EQ(Current, FirstUniqued);
684 EXPECT_EQ(FirstUniqued, Uniqued);
786 EXPECT_EQ(Current, Distinct);
799 EXPECT_EQ(Current, Distinct);
824 EXPECT_EQ(N, T);
828 EXPECT_EQ(U, MDTuple::get(Context, N));
833 EXPECT_EQ(U, MDNode::replaceWithPermanent(MDTuple::getTemporary(Context, N)));
839 EXPECT_EQ(V, MDNode::replaceWithPermanent(std::move(Temp2)));
841 EXPECT_EQ(U, V->getOperand(0));
846 EXPECT_EQ(nullptr, Ref.get());
850 EXPECT_EQ(Temp.get(), Ref.get());
852 EXPECT_EQ(nullptr, Ref.get());
861 EXPECT_EQ(2u, L->getLine());
862 EXPECT_EQ(7u, L->getColumn());
867 EXPECT_EQ(UINT32_MAX, L->getLine());
868 EXPECT_EQ(U16 - 1, L->getColumn());
872 EXPECT_EQ(UINT32_MAX, L->getLine());
873 EXPECT_EQ(0u, L->getColumn());
877 EXPECT_EQ(UINT32_MAX, L->getLine());
878 EXPECT_EQ(0u, L->getColumn());
891 EXPECT_EQ(2u, M->getLine());
892 EXPECT_EQ(7u, M->getColumn());
893 EXPECT_EQ(N, M->getScope());
901 EXPECT_EQ(0u, M->getLine()); // FIXME: Should this be 2?
902 EXPECT_EQ(0u, M->getColumn()); // FIXME: Should this be 7?
903 EXPECT_EQ(N, M->getScope());
911 EXPECT_EQ(0u, M->getLine());
912 EXPECT_EQ(0u, M->getColumn());
913 EXPECT_EQ(N, M->getScope());
921 EXPECT_EQ(0u, M->getLine());
922 EXPECT_EQ(0u, M->getColumn());
923 EXPECT_EQ(N, M->getScope());
940 EXPECT_EQ(0u, M->getLine());
941 EXPECT_EQ(0u, M->getColumn());
943 EXPECT_EQ(I, M->getInlinedAt());
952 EXPECT_EQ(0u, M->getLine());
953 EXPECT_EQ(0u, M->getColumn());
955 EXPECT_EQ(S, M->getScope());
956 EXPECT_EQ(nullptr, M->getInlinedAt());
966 EXPECT_EQ(L1, DILocation::get(Context, 2, 7, N));
985 EXPECT_EQ(0U, DILocation::encodeDiscriminator(0, 0, 0).getValue());
989 EXPECT_EQ(2U, DILocation::encodeDiscriminator(1, 0, 0).getValue());
994 EXPECT_EQ(5U, DILocation::encodeDiscriminator(0, 1, 0).getValue());
998 EXPECT_EQ(0xbU, DILocation::encodeDiscriminator(0, 0, 1).getValue());
1004 EXPECT_EQ(0xfffbU, DILocation::encodeDiscriminator(0, 0, 0xfff).getValue());
1006 EXPECT_EQ(0x102U, DILocation::encodeDiscriminator(1, 1, 0).getValue());
1008 EXPECT_EQ(0x13eU, DILocation::encodeDiscriminator(0x1f, 1, 0).getValue());
1010 EXPECT_EQ(0x87feU, DILocation::encodeDiscriminator(0x1ff, 1, 0).getValue());
1012 EXPECT_EQ(0x1f3eU, DILocation::encodeDiscriminator(0x1f, 0x1f, 0).getValue());
1014 EXPECT_EQ(0x3ff3eU,
1017 EXPECT_EQ(0x1ff87feU,
1020 EXPECT_EQ(0xfff9f3eU,
1023 EXPECT_EQ(0xffc3ff3eU,
1026 EXPECT_EQ(0xffcf87feU,
1029 EXPECT_EQ(0xe1ff87feU,
1034 EXPECT_EQ(None, DILocation::encodeDiscriminator(0, 0, 0x1000));
1035 EXPECT_EQ(None, DILocation::encodeDiscriminator(0x1000, 0, 0));
1036 EXPECT_EQ(None, DILocation::encodeDiscriminator(0, 0x1000, 0));
1037 EXPECT_EQ(None, DILocation::encodeDiscriminator(0, 0, 0x1000));
1038 EXPECT_EQ(None, DILocation::encodeDiscriminator(0x1ff, 0x1ff, 8));
1039 EXPECT_EQ(None,
1050 EXPECT_EQ(0U, L1->getBaseDiscriminator());
1051 EXPECT_EQ(1U, L1->getDuplicationFactor());
1053 EXPECT_EQ(L1, L1->cloneWithBaseDiscriminator(0).getValue());
1054 EXPECT_EQ(L1, L1->cloneByMultiplyingDuplicationFactor(0).getValue());
1055 EXPECT_EQ(L1, L1->cloneByMultiplyingDuplicationFactor(1).getValue());
1058 EXPECT_EQ(0U, L1->getBaseDiscriminator());
1059 EXPECT_EQ(1U, L1->getDuplicationFactor());
1061 EXPECT_EQ(1U, L2->getBaseDiscriminator());
1062 EXPECT_EQ(1U, L2->getDuplicationFactor());
1065 EXPECT_EQ(1U, L3->getBaseDiscriminator());
1066 EXPECT_EQ(2U, L3->getDuplicationFactor());
1068 EXPECT_EQ(L2, L2->cloneByMultiplyingDuplicationFactor(1).getValue());
1071 EXPECT_EQ(1U, L4->getBaseDiscriminator());
1072 EXPECT_EQ(8U, L4->getDuplicationFactor());
1075 EXPECT_EQ(2U, L5->getBaseDiscriminator());
1076 EXPECT_EQ(8U, L5->getDuplicationFactor());
1080 EXPECT_EQ(0xfffU, L6->getBaseDiscriminator());
1081 EXPECT_EQ(0xfffU, L6->cloneByMultiplyingDuplicationFactor(0xfff)
1086 EXPECT_EQ(None, L4->cloneWithBaseDiscriminator(0x1000));
1087 EXPECT_EQ(None, L4->cloneByMultiplyingDuplicationFactor(0x1000));
1098 EXPECT_EQ(15u, N->getTag());
1099 EXPECT_EQ(2u, N->getNumOperands());
1100 EXPECT_EQ(Header, N->getHeader());
1101 EXPECT_EQ(MDString::get(Context, Header), N->getOperand(0));
1102 EXPECT_EQ(1u, N->getNumDwarfOperands());
1103 EXPECT_EQ(Empty, N->getDwarfOperand(0));
1104 EXPECT_EQ(Empty, N->getOperand(1));
1107 EXPECT_EQ(N, GenericDINode::get(Context, 15, Header, Ops1));
1110 EXPECT_EQ(15u, N->getTag());
1111 EXPECT_EQ(Header, N->getHeader());
1112 EXPECT_EQ(nullptr, N->getDwarfOperand(0));
1116 EXPECT_EQ(N, GenericDINode::get(Context, 15, Header, Ops2));
1119 EXPECT_EQ(15u, N->getTag());
1120 EXPECT_EQ(Header, N->getHeader());
1121 EXPECT_EQ(Empty, N->getDwarfOperand(0));
1123 EXPECT_EQ(N, GenericDINode::get(Context, 15, Header, Ops1));
1126 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1132 EXPECT_EQ(StringRef(), N->getHeader());
1133 EXPECT_EQ(nullptr, N->getOperand(0));
1141 EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());
1144 EXPECT_EQ(5, Count.get<ConstantInt*>()->getSExtValue());
1145 EXPECT_EQ(7, N->getLowerBound());
1146 EXPECT_EQ(N, DISubrange::get(Context, 5, 7));
1147 EXPECT_EQ(DISubrange::get(Context, 5, 0), DISubrange::get(Context, 5));
1150 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1156 EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());
1159 EXPECT_EQ(-1, Count.get<ConstantInt*>()->getSExtValue());
1160 EXPECT_EQ(0, N->getLowerBound());
1161 EXPECT_EQ(N, DISubrange::get(Context, -1, 0));
1176 EXPECT_EQ(VlaExpr, Count.get<DIVariable*>());
1178 EXPECT_EQ(0, N->getLowerBound());
1179 EXPECT_EQ("vla_expr", Count.get<DIVariable*>()->getName());
1180 EXPECT_EQ(N, DISubrange::get(Context, VlaExpr, 0));
1187 EXPECT_EQ(dwarf::DW_TAG_enumerator, N->getTag());
1188 EXPECT_EQ(7, N->getValue());
1190 EXPECT_EQ("name", N->getName());
1191 EXPECT_EQ(N, DIEnumerator::get(Context, 7, false, "name"));
1198 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1207 EXPECT_EQ(dwarf::DW_TAG_base_type, N->getTag());
1208 EXPECT_EQ("special", N->getName());
1209 EXPECT_EQ(33u, N->getSizeInBits());
1210 EXPECT_EQ(26u, N->getAlignInBits());
1211 EXPECT_EQ(7u, N->getEncoding());
1212 EXPECT_EQ(0u, N->getLine());
1213 EXPECT_EQ(DINode::FlagZero, N->getFlags());
1214 EXPECT_EQ(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
1234 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1240 EXPECT_EQ(UINT64_MAX, N->getSizeInBits());
1241 EXPECT_EQ(UINT32_MAX - 1, N->getAlignInBits());
1247 EXPECT_EQ(dwarf::DW_TAG_unspecified_type, N->getTag());
1248 EXPECT_EQ("unspecified", N->getName());
1249 EXPECT_EQ(0u, N->getSizeInBits());
1250 EXPECT_EQ(0u, N->getAlignInBits());
1251 EXPECT_EQ(0u, N->getEncoding());
1252 EXPECT_EQ(0u, N->getLine());
1253 EXPECT_EQ(DINode::FlagZero, N->getFlags());
1264 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1274 EXPECT_EQ(DINode::FlagZero, D->getFlags());
1276 EXPECT_EQ(DINode::FlagRValueReference, D2->getFlags());
1277 EXPECT_EQ(DINode::FlagZero, D->getFlags());
1281 EXPECT_EQ(DINode::FlagZero, T->getFlags());
1283 EXPECT_EQ(DINode::FlagRValueReference, T2->getFlags());
1284 EXPECT_EQ(DINode::FlagZero, T->getFlags());
1302 EXPECT_EQ(dwarf::DW_TAG_pointer_type, N->getTag());
1303 EXPECT_EQ("something", N->getName());
1304 EXPECT_EQ(File, N->getFile());
1305 EXPECT_EQ(1u, N->getLine());
1306 EXPECT_EQ(Scope, N->getScope());
1307 EXPECT_EQ(BaseType, N->getBaseType());
1308 EXPECT_EQ(2u, N->getSizeInBits());
1309 EXPECT_EQ(3u, N->getAlignInBits());
1310 EXPECT_EQ(4u, N->getOffsetInBits());
1311 EXPECT_EQ(DWARFAddressSpace, N->getDWARFAddressSpace().getValue());
1312 EXPECT_EQ(5u, N->getFlags());
1313 EXPECT_EQ(ExtraData, N->getExtraData());
1314 EXPECT_EQ(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
1358 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1372 EXPECT_EQ(UINT64_MAX, N->getSizeInBits());
1373 EXPECT_EQ(UINT32_MAX - 1, N->getAlignInBits());
1374 EXPECT_EQ(UINT64_MAX - 2, N->getOffsetInBits());
1375 EXPECT_EQ(UINT32_MAX - 3, N->getDWARFAddressSpace().getValue());
1401 EXPECT_EQ(Tag, N->getTag());
1402 EXPECT_EQ(Name, N->getName());
1403 EXPECT_EQ(File, N->getFile());
1404 EXPECT_EQ(Line, N->getLine());
1405 EXPECT_EQ(Scope, N->getScope());
1406 EXPECT_EQ(BaseType, N->getBaseType());
1407 EXPECT_EQ(SizeInBits, N->getSizeInBits());
1408 EXPECT_EQ(AlignInBits, N->getAlignInBits());
1409 EXPECT_EQ(OffsetInBits, N->getOffsetInBits());
1410 EXPECT_EQ(Flags, N->getFlags());
1411 EXPECT_EQ(Elements, N->getElements().get());
1412 EXPECT_EQ(RuntimeLang, N->getRuntimeLang());
1413 EXPECT_EQ(VTableHolder, N->getVTableHolder());
1414 EXPECT_EQ(TemplateParams, N->getTemplateParams().get());
1415 EXPECT_EQ(Identifier, N->getIdentifier());
1417 EXPECT_EQ(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1497 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1521 EXPECT_EQ(SizeInBits, N->getSizeInBits());
1522 EXPECT_EQ(AlignInBits, N->getAlignInBits());
1523 EXPECT_EQ(OffsetInBits, N->getOffsetInBits());
1545 EXPECT_EQ(nullptr, N->getElements().get());
1547 EXPECT_EQ(Elements, N->getElements().get());
1549 EXPECT_EQ(nullptr, N->getElements().get());
1552 EXPECT_EQ(nullptr, N->getVTableHolder());
1554 EXPECT_EQ(VTableHolder, N->getVTableHolder());
1559 EXPECT_EQ(BasicType, N->getVTableHolder());
1561 EXPECT_EQ(nullptr, N->getVTableHolder());
1564 EXPECT_EQ(nullptr, N->getTemplateParams().get());
1566 EXPECT_EQ(TemplateParams, N->getTemplateParams().get());
1568 EXPECT_EQ(nullptr, N->getTemplateParams().get());
1608 EXPECT_EQ(N, Same);
1613 EXPECT_EQ(N->getDiscriminator(), Discriminator);
1624 EXPECT_EQ(dwarf::DW_TAG_subroutine_type, N->getTag());
1625 EXPECT_EQ(Flags, N->getFlags());
1626 EXPECT_EQ(TypeArray, N->getTypeArray().get());
1627 EXPECT_EQ(N, DISubroutineType::get(Context, Flags, 0, TypeArray));
1637 EXPECT_EQ(Fast,
1640 EXPECT_EQ(Std, DISubroutineType::get(
1648 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1651 EXPECT_EQ(nullptr, N->getScope());
1652 EXPECT_EQ(nullptr, N->getFile());
1653 EXPECT_EQ("", N->getName());
1667 EXPECT_EQ(dwarf::DW_TAG_file_type, N->getTag());
1668 EXPECT_EQ(Filename, N->getFilename());
1669 EXPECT_EQ(Directory, N->getDirectory());
1670 EXPECT_EQ(Checksum, N->getChecksum());
1671 EXPECT_EQ(Source, N->getSource());
1672 EXPECT_EQ(N, DIFile::get(Context, Filename, Directory, Checksum, Source));
1685 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1691 EXPECT_EQ(N, N->getFile());
1717 EXPECT_EQ(dwarf::DW_TAG_compile_unit, N->getTag());
1718 EXPECT_EQ(SourceLanguage, N->getSourceLanguage());
1719 EXPECT_EQ(File, N->getFile());
1720 EXPECT_EQ(Producer, N->getProducer());
1721 EXPECT_EQ(IsOptimized, N->isOptimized());
1722 EXPECT_EQ(Flags, N->getFlags());
1723 EXPECT_EQ(RuntimeVersion, N->getRuntimeVersion());
1724 EXPECT_EQ(SplitDebugFilename, N->getSplitDebugFilename());
1725 EXPECT_EQ(EmissionKind, N->getEmissionKind());
1726 EXPECT_EQ(EnumTypes, N->getEnumTypes().get());
1727 EXPECT_EQ(RetainedTypes, N->getRetainedTypes().get());
1728 EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());
1729 EXPECT_EQ(ImportedEntities, N->getImportedEntities().get());
1730 EXPECT_EQ(Macros, N->getMacros().get());
1731 EXPECT_EQ(DWOId, N->getDWOId());
1734 EXPECT_EQ(dwarf::DW_TAG_compile_unit, Temp->getTag());
1735 EXPECT_EQ(SourceLanguage, Temp->getSourceLanguage());
1736 EXPECT_EQ(File, Temp->getFile());
1737 EXPECT_EQ(Producer, Temp->getProducer());
1738 EXPECT_EQ(IsOptimized, Temp->isOptimized());
1739 EXPECT_EQ(Flags, Temp->getFlags());
1740 EXPECT_EQ(RuntimeVersion, Temp->getRuntimeVersion());
1741 EXPECT_EQ(SplitDebugFilename, Temp->getSplitDebugFilename());
1742 EXPECT_EQ(EmissionKind, Temp->getEmissionKind());
1743 EXPECT_EQ(EnumTypes, Temp->getEnumTypes().get());
1744 EXPECT_EQ(RetainedTypes, Temp->getRetainedTypes().get());
1745 EXPECT_EQ(GlobalVariables, Temp->getGlobalVariables().get());
1746 EXPECT_EQ(ImportedEntities, Temp->getImportedEntities().get());
1747 EXPECT_EQ(Macros, Temp->getMacros().get());
1748 EXPECT_EQ(DWOId, Temp->getDWOId());
1753 EXPECT_EQ(TempAddress, Clone);
1776 EXPECT_EQ(nullptr, N->getGlobalVariables().get());
1778 EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());
1780 EXPECT_EQ(nullptr, N->getGlobalVariables().get());
1783 EXPECT_EQ(nullptr, N->getMacros().get());
1785 EXPECT_EQ(Macros, N->getMacros().get());
1787 EXPECT_EQ(nullptr, N->getMacros().get());
1824 EXPECT_EQ(dwarf::DW_TAG_subprogram, N->getTag());
1825 EXPECT_EQ(Scope, N->getScope());
1826 EXPECT_EQ(Name, N->getName());
1827 EXPECT_EQ(LinkageName, N->getLinkageName());
1828 EXPECT_EQ(File, N->getFile());
1829 EXPECT_EQ(Line, N->getLine());
1830 EXPECT_EQ(Type, N->getType());
1831 EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
1832 EXPECT_EQ(IsDefinition, N->isDefinition());
1833 EXPECT_EQ(ScopeLine, N->getScopeLine());
1834 EXPECT_EQ(ContainingType, N->getContainingType());
1835 EXPECT_EQ(Virtuality, N->getVirtuality());
1836 EXPECT_EQ(VirtualIndex, N->getVirtualIndex());
1837 EXPECT_EQ(ThisAdjustment, N->getThisAdjustment());
1838 EXPECT_EQ(Flags, N->getFlags());
1839 EXPECT_EQ(IsOptimized, N->isOptimized());
1840 EXPECT_EQ(Unit, N->getUnit());
1841 EXPECT_EQ(TemplateParams, N->getTemplateParams().get());
1842 EXPECT_EQ(Declaration, N->getDeclaration());
1843 EXPECT_EQ(RetainedNodes, N->getRetainedNodes().get());
1844 EXPECT_EQ(ThrownTypes, N->getThrownTypes().get());
1845 EXPECT_EQ(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1942 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1955 EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
1956 EXPECT_EQ(Scope, N->getScope());
1957 EXPECT_EQ(File, N->getFile());
1958 EXPECT_EQ(Line, N->getLine());
1959 EXPECT_EQ(Column, N->getColumn());
1960 EXPECT_EQ(N, DILexicalBlock::get(Context, Scope, File, Line, Column));
1969 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1977 EXPECT_EQ(2u, LB->getLine());
1978 EXPECT_EQ(7u, LB->getColumn());
1983 EXPECT_EQ(UINT32_MAX, LB->getLine());
1984 EXPECT_EQ(U16 - 1, LB->getColumn());
1988 EXPECT_EQ(UINT32_MAX, LB->getLine());
1989 EXPECT_EQ(0u, LB->getColumn());
1993 EXPECT_EQ(UINT32_MAX, LB->getLine());
1994 EXPECT_EQ(0u, LB->getColumn());
2007 EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
2008 EXPECT_EQ(Scope, N->getScope());
2009 EXPECT_EQ(File, N->getFile());
2010 EXPECT_EQ(Discriminator, N->getDiscriminator());
2011 EXPECT_EQ(N, DILexicalBlockFile::get(Context, Scope, File, Discriminator));
2021 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2033 EXPECT_EQ(dwarf::DW_TAG_namespace, N->getTag());
2034 EXPECT_EQ(Scope, N->getScope());
2035 EXPECT_EQ(Name, N->getName());
2036 EXPECT_EQ(N, DINamespace::get(Context, Scope, Name, ExportSymbols));
2042 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2056 EXPECT_EQ(dwarf::DW_TAG_module, N->getTag());
2057 EXPECT_EQ(Scope, N->getScope());
2058 EXPECT_EQ(Name, N->getName());
2059 EXPECT_EQ(ConfigMacro, N->getConfigurationMacros());
2060 EXPECT_EQ(Includes, N->getIncludePath());
2061 EXPECT_EQ(Sysroot, N->getISysRoot());
2062 EXPECT_EQ(N, DIModule::get(Context, Scope, Name,
2076 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2087 EXPECT_EQ(dwarf::DW_TAG_template_type_parameter, N->getTag());
2088 EXPECT_EQ(Name, N->getName());
2089 EXPECT_EQ(Type, N->getType());
2090 EXPECT_EQ(N, DITemplateTypeParameter::get(Context, Name, Type));
2097 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2109 EXPECT_EQ(Tag, N->getTag());
2110 EXPECT_EQ(Name, N->getName());
2111 EXPECT_EQ(Type, N->getType());
2112 EXPECT_EQ(Value, N->getValue());
2113 EXPECT_EQ(N, DITemplateValueParameter::get(Context, Tag, Name, Type, Value));
2126 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2150 EXPECT_EQ(dwarf::DW_TAG_variable, N->getTag());
2151 EXPECT_EQ(Scope, N->getScope());
2152 EXPECT_EQ(Name, N->getName());
2153 EXPECT_EQ(LinkageName, N->getLinkageName());
2154 EXPECT_EQ(File, N->getFile());
2155 EXPECT_EQ(Line, N->getLine());
2156 EXPECT_EQ(Type, N->getType());
2157 EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
2158 EXPECT_EQ(IsDefinition, N->isDefinition());
2159 EXPECT_EQ(StaticDataMemberDeclaration, N->getStaticDataMemberDeclaration());
2160 EXPECT_EQ(templateParams, N->getTemplateParams());
2161 EXPECT_EQ(AlignInBits, N->getAlignInBits());
2162 EXPECT_EQ(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
2213 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2242 EXPECT_EQ(Var, N->getVariable());
2243 EXPECT_EQ(Expr, N->getExpression());
2244 EXPECT_EQ(N, DIGlobalVariableExpression::get(Context, Var, Expr));
2249 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2268 EXPECT_EQ(Scope, N->getScope());
2269 EXPECT_EQ(Name, N->getName());
2270 EXPECT_EQ(File, N->getFile());
2271 EXPECT_EQ(Line, N->getLine());
2272 EXPECT_EQ(Type, N->getType());
2273 EXPECT_EQ(Arg, N->getArg());
2274 EXPECT_EQ(Flags, N->getFlags());
2275 EXPECT_EQ(AlignInBits, N->getAlignInBits());
2276 EXPECT_EQ(N, DILocalVariable::get(Context, Scope, Name, File, Line, Type, Arg,
2298 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2302 EXPECT_EQ(255u, DILocalVariable::get(Context, getSubprogram(), "", getFile(),
2305 EXPECT_EQ(256u, DILocalVariable::get(Context, getSubprogram(), "", getFile(),
2308 EXPECT_EQ(257u, DILocalVariable::get(Context, getSubprogram(), "", getFile(),
2312 EXPECT_EQ(Max, DILocalVariable::get(Context, getSubprogram(), "", getFile(),
2322 EXPECT_EQ(makeArrayRef(Elements), N->getElements());
2323 EXPECT_EQ(N, DIExpression::get(Context, Elements));
2325 EXPECT_EQ(5u, N->getNumElements());
2326 EXPECT_EQ(2u, N->getElement(0));
2327 EXPECT_EQ(6u, N->getElement(1));
2328 EXPECT_EQ(9u, N->getElement(2));
2329 EXPECT_EQ(78u, N->getElement(3));
2330 EXPECT_EQ(0u, N->getElement(4));
2333 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2349 EXPECT_EQ(N0WithPrependedOps, N1);
2355 EXPECT_EQ(N0WithPrependedOps, N2);
2411 EXPECT_EQ(dwarf::DW_TAG_APPLE_property, N->getTag());
2412 EXPECT_EQ(Name, N->getName());
2413 EXPECT_EQ(File, N->getFile());
2414 EXPECT_EQ(Line, N->getLine());
2415 EXPECT_EQ(GetterName, N->getGetterName());
2416 EXPECT_EQ(SetterName, N->getSetterName());
2417 EXPECT_EQ(Attributes, N->getAttributes());
2418 EXPECT_EQ(Type, N->getType());
2419 EXPECT_EQ(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,
2439 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2455 EXPECT_EQ(Tag, N->getTag());
2456 EXPECT_EQ(Scope, N->getScope());
2457 EXPECT_EQ(Entity, N->getEntity());
2458 EXPECT_EQ(File, N->getFile());
2459 EXPECT_EQ(Line, N->getLine());
2460 EXPECT_EQ(Name, N->getName());
2461 EXPECT_EQ(
2479 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2488 EXPECT_EQ(N, V->getMetadata());
2491 EXPECT_EQ(V, V2);
2500 EXPECT_EQ(N2, V->getMetadata());
2503 EXPECT_EQ(V, V2);
2508 EXPECT_EQ(N, V3->getMetadata());
2519 EXPECT_EQ(MD, V->getMetadata());
2522 EXPECT_EQ(MD, V2->getMetadata());
2523 EXPECT_EQ(V, V2);
2553 EXPECT_EQ(N->getOperand(0), Temp2.get());
2579 EXPECT_EQ(nullptr, N2->getOperand(0));
2580 EXPECT_EQ(nullptr, N2->getOperand(1));
2581 EXPECT_EQ(Temp.get(), N2->getOperand(2));
2647 EXPECT_EQ(nullptr, F->getMetadata(LLVMContext::MD_dbg));
2648 EXPECT_EQ(nullptr, F->getMetadata("dbg"));
2649 EXPECT_EQ(nullptr, F->getMetadata("other"));
2657 EXPECT_EQ(SP1, F->getMetadata(LLVMContext::MD_dbg));
2658 EXPECT_EQ(SP1, F->getMetadata("dbg"));
2659 EXPECT_EQ(nullptr, F->getMetadata("other"));
2663 EXPECT_EQ(SP2, F->getMetadata(LLVMContext::MD_dbg));
2664 EXPECT_EQ(SP2, F->getMetadata("dbg"));
2665 EXPECT_EQ(nullptr, F->getMetadata("other"));
2669 EXPECT_EQ(nullptr, F->getMetadata(LLVMContext::MD_dbg));
2670 EXPECT_EQ(nullptr, F->getMetadata("dbg"));
2671 EXPECT_EQ(nullptr, F->getMetadata("other"));
2680 EXPECT_EQ(T1, F->getMetadata("other1"));
2681 EXPECT_EQ(T2, F->getMetadata("other2"));
2682 EXPECT_EQ(nullptr, F->getMetadata("dbg"));
2686 EXPECT_EQ(T2, F->getMetadata("other1"));
2687 EXPECT_EQ(T1, F->getMetadata("other2"));
2692 EXPECT_EQ(nullptr, F->getMetadata("other1"));
2693 EXPECT_EQ(nullptr, F->getMetadata("other2"));
2714 EXPECT_EQ(LLVMContext::MD_dbg, MDs[0].first);
2715 EXPECT_EQ(LLVMContext::MD_prof, MDs[1].first);
2716 EXPECT_EQ(Context.getMDKindID("other1"), MDs[2].first);
2717 EXPECT_EQ(Context.getMDKindID("other2"), MDs[3].first);
2718 EXPECT_EQ(SP, MDs[0].second);
2719 EXPECT_EQ(P, MDs[1].second);
2720 EXPECT_EQ(T1, MDs[2].second);
2721 EXPECT_EQ(T2, MDs[3].second);
2752 EXPECT_EQ(12304u, Count.getCount());
2753 EXPECT_EQ(Function::PCT_Real, Count.getType());
2761 EXPECT_EQ(123u, Count.getCount());
2762 EXPECT_EQ(Function::PCT_Synthetic, Count.getType());
2772 EXPECT_EQ(SP, static_cast<DISubprogram *>(F->getSubprogram()));
2773 EXPECT_EQ(SP, F->getMetadata("dbg"));
2774 EXPECT_EQ(SP, F->getMetadata(LLVMContext::MD_dbg));
2779 EXPECT_EQ(7u, DistinctMDOperandPlaceholder(7).getID());
2799 EXPECT_EQ(N0, D->getOperand(0));
2800 EXPECT_EQ(N1, D->getOperand(1));
2801 EXPECT_EQ(nullptr, D->getOperand(2));
unittests/IR/PassManagerTest.cpp 491 EXPECT_EQ(1, ModulePassRunCount);
494 EXPECT_EQ(3, FunctionPassRunCount1);
495 EXPECT_EQ(5, AnalyzedInstrCount1);
496 EXPECT_EQ(0, AnalyzedFunctionCount1);
497 EXPECT_EQ(3, FunctionPassRunCount2);
498 EXPECT_EQ(5, AnalyzedInstrCount2);
499 EXPECT_EQ(0, AnalyzedFunctionCount2);
500 EXPECT_EQ(3, FunctionPassRunCount3);
501 EXPECT_EQ(5, AnalyzedInstrCount3);
502 EXPECT_EQ(0, AnalyzedFunctionCount3);
503 EXPECT_EQ(3, FunctionPassRunCount4);
504 EXPECT_EQ(5, AnalyzedInstrCount4);
505 EXPECT_EQ(9, AnalyzedFunctionCount4);
506 EXPECT_EQ(3, FunctionPassRunCount5);
507 EXPECT_EQ(2, AnalyzedInstrCount5); // Only 'g' and 'h' were cached.
508 EXPECT_EQ(9, AnalyzedFunctionCount5);
516 EXPECT_EQ(7, FunctionAnalysisRuns);
518 EXPECT_EQ(1, ModuleAnalysisRuns);
577 EXPECT_EQ(42 * (int)M->size(), Result);
767 EXPECT_EQ(5, FunctionAnalysisRuns);
769 EXPECT_EQ(2, ModuleAnalysisRuns);
772 EXPECT_EQ(9, IndirectAnalysisRuns);
773 EXPECT_EQ(9, DoublyIndirectAnalysisRuns);
777 EXPECT_EQ(5 * 4, InstrCount);
781 EXPECT_EQ(3 * 4 * 3, FunctionCount);
unittests/IR/PatternMatch.cpp 62 EXPECT_EQ(One, V);
558 EXPECT_EQ(tX, X);
570 EXPECT_EQ(tX, X);
571 EXPECT_EQ(tY, Y);
589 EXPECT_EQ(L, MatchL);
590 EXPECT_EQ(R, MatchR);
595 EXPECT_EQ(L, MatchL);
596 EXPECT_EQ(R, MatchR);
618 EXPECT_EQ(L, MatchL);
619 EXPECT_EQ(R, MatchR);
626 EXPECT_EQ(L, MatchL);
627 EXPECT_EQ(R, MatchR);
639 EXPECT_EQ(L, MatchL);
640 EXPECT_EQ(R, MatchR);
645 EXPECT_EQ(L, MatchL);
646 EXPECT_EQ(R, MatchR);
669 EXPECT_EQ(L, MatchL);
670 EXPECT_EQ(R, MatchR);
677 EXPECT_EQ(L, MatchL);
678 EXPECT_EQ(R, MatchR);
690 EXPECT_EQ(L, MatchL);
691 EXPECT_EQ(R, MatchR);
696 EXPECT_EQ(L, MatchL);
697 EXPECT_EQ(R, MatchR);
719 EXPECT_EQ(L, MatchL);
720 EXPECT_EQ(R, MatchR);
727 EXPECT_EQ(L, MatchL);
728 EXPECT_EQ(R, MatchR);
740 EXPECT_EQ(L, MatchL);
741 EXPECT_EQ(R, MatchR);
746 EXPECT_EQ(L, MatchL);
747 EXPECT_EQ(R, MatchR);
769 EXPECT_EQ(L, MatchL);
770 EXPECT_EQ(R, MatchR);
777 EXPECT_EQ(L, MatchL);
778 EXPECT_EQ(R, MatchR);
788 EXPECT_EQ(L, MatchL);
789 EXPECT_EQ(R, MatchR);
793 EXPECT_EQ(L, MatchL);
794 EXPECT_EQ(R, MatchR);
798 EXPECT_EQ(L, MatchL);
799 EXPECT_EQ(R, MatchR);
803 EXPECT_EQ(L, MatchL);
804 EXPECT_EQ(R, MatchR);
808 EXPECT_EQ(L, MatchL);
809 EXPECT_EQ(R, MatchR);
813 EXPECT_EQ(L, MatchL);
814 EXPECT_EQ(R, MatchR);
818 EXPECT_EQ(L, MatchL);
819 EXPECT_EQ(R, MatchR);
823 EXPECT_EQ(L, MatchL);
824 EXPECT_EQ(R, MatchR);
869 EXPECT_EQ(Alloca, MatchLoad);
877 EXPECT_EQ(FourtyTwo, MatchStoreVal);
878 EXPECT_EQ(Alloca, MatchStorePointer);
1068 EXPECT_EQ(One, Match);
1072 EXPECT_EQ(One, Match);
1078 EXPECT_EQ(One, Match);
1093 EXPECT_EQ(TrueBB, A);
1094 EXPECT_EQ(FalseBB, B);
1135 EXPECT_EQ(L, MatchL);
1136 EXPECT_EQ(R, MatchR);
unittests/IR/TypesTest.cpp 21 EXPECT_EQ("FooBar", Struct->getName());
23 EXPECT_EQ("Foo", Struct->getName());
unittests/IR/UseTest.cpp 52 EXPECT_EQ(vnbuf, U->getName());
62 EXPECT_EQ(vnbuf, U->getName());
97 EXPECT_EQ(vnbuf, U->getName());
105 EXPECT_EQ(vnbuf, U->getName());
unittests/IR/UserTest.cpp 84 EXPECT_EQ(10, std::distance(P.value_op_begin(), P.value_op_end()));
100 EXPECT_EQ(10, std::distance(IP->value_op_begin(), IP->value_op_end()));
104 EXPECT_EQ(std::next(P.value_op_begin(), 3), I);
105 EXPECT_EQ(P.getOperand(3), *I);
107 EXPECT_EQ(P.getOperand(6), I[2]);
108 EXPECT_EQ(P.value_op_end(), (I - 2) + 8);
113 EXPECT_EQ(std::next(IP->value_op_begin(), 3), CI);
114 EXPECT_EQ(IP->getOperand(3), *CI);
116 EXPECT_EQ(IP->getOperand(6), CI[2]);
117 EXPECT_EQ(IP->value_op_end(), (CI - 2) + 8);
134 EXPECT_EQ(*PersonalityUsers, TestF);
135 EXPECT_EQ(++PersonalityUsers, PersonalityF->user_end());
unittests/IR/ValueHandleTest.cpp 38 EXPECT_EQ(BitcastV.get(), WVH);
40 EXPECT_EQ(ConstantV, WVH);
44 EXPECT_EQ(Type::getInt32Ty(Context), WVH->getType());
45 EXPECT_EQ(Type::getInt32Ty(Context), (*WVH).getType());
49 EXPECT_EQ(WVH, BitcastV.get());
51 EXPECT_EQ(WVH, nullptr);
56 EXPECT_EQ(BitcastV.get(), WVH);
58 EXPECT_EQ(ConstantV, WVH);
62 EXPECT_EQ(Type::getInt32Ty(Context), WVH->getType());
63 EXPECT_EQ(Type::getInt32Ty(Context), (*WVH).getType());
83 EXPECT_EQ(BV < CV, BitcastWVH < ConstantWVH);
84 EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantWVH);
85 EXPECT_EQ(BV > CV, BitcastWVH > ConstantWVH);
86 EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantWVH);
88 EXPECT_EQ(BV < CV, BitcastV.get() < ConstantWVH);
89 EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantWVH);
90 EXPECT_EQ(BV > CV, BitcastV.get() > ConstantWVH);
91 EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantWVH);
93 EXPECT_EQ(BV < CV, BitcastWVH < ConstantV);
94 EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantV);
95 EXPECT_EQ(BV > CV, BitcastWVH > ConstantV);
96 EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantV);
104 EXPECT_EQ(ConstantV, WVH);
105 EXPECT_EQ(ConstantV, WVH_Copy);
106 EXPECT_EQ(ConstantV, WVH_Recreated);
115 EXPECT_EQ(null_value, WVH);
116 EXPECT_EQ(null_value, WVH_Copy);
117 EXPECT_EQ(null_value, WVH_Recreated);
127 EXPECT_EQ(BitcastV.get(), GenericAVH);
129 EXPECT_EQ(ConstantV, GenericAVH);
161 EXPECT_EQ(BV < CV, BitcastAVH < ConstantAVH);
162 EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantAVH);
163 EXPECT_EQ(BV > CV, BitcastAVH > ConstantAVH);
164 EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantAVH);
166 EXPECT_EQ(BV < CV, BitcastV.get() < ConstantAVH);
167 EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantAVH);
168 EXPECT_EQ(BV > CV, BitcastV.get() > ConstantAVH);
169 EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantAVH);
171 EXPECT_EQ(BV < CV, BitcastAVH < ConstantV);
172 EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantV);
173 EXPECT_EQ(BV > CV, BitcastAVH > ConstantV);
174 EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantV);
180 EXPECT_EQ(BitcastV.get(), AVH);
211 EXPECT_EQ(BitcastV.get(), CVH);
213 EXPECT_EQ(ConstantV, CVH);
217 EXPECT_EQ(Type::getInt32Ty(Context), CVH->getType());
218 EXPECT_EQ(Type::getInt32Ty(Context), (*CVH).getType());
238 EXPECT_EQ(BV < CV, BitcastCVH < ConstantCVH);
239 EXPECT_EQ(BV <= CV, BitcastCVH <= ConstantCVH);
240 EXPECT_EQ(BV > CV, BitcastCVH > ConstantCVH);
241 EXPECT_EQ(BV >= CV, BitcastCVH >= ConstantCVH);
243 EXPECT_EQ(BV < CV, BitcastV.get() < ConstantCVH);
244 EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantCVH);
245 EXPECT_EQ(BV > CV, BitcastV.get() > ConstantCVH);
246 EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantCVH);
248 EXPECT_EQ(BV < CV, BitcastCVH < ConstantV);
249 EXPECT_EQ(BV <= CV, BitcastCVH <= ConstantV);
250 EXPECT_EQ(BV > CV, BitcastCVH > ConstantV);
251 EXPECT_EQ(BV >= CV, BitcastCVH >= ConstantV);
273 EXPECT_EQ(0, RVH.DeletedCalls);
274 EXPECT_EQ(0, RVH.AURWCalls);
276 EXPECT_EQ(1, RVH.DeletedCalls);
277 EXPECT_EQ(0, RVH.AURWCalls);
296 EXPECT_EQ(nullptr, AURWArgument);
303 EXPECT_EQ(0, RVH.DeletedCalls);
304 EXPECT_EQ(nullptr, RVH.AURWArgument);
306 EXPECT_EQ(0, RVH.DeletedCalls);
307 EXPECT_EQ(ConstantV, RVH.AURWArgument);
332 EXPECT_EQ(1U, getValPtr()->getNumUses());
333 EXPECT_EQ(nullptr, AURWArgument);
344 EXPECT_EQ(BitcastV.get(), BitcastUser->getOperand(0));
346 EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(Context)),
348 EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(Context)),
386 EXPECT_EQ(ConstantV, static_cast<Value*>(ShouldBeVisited1));
387 EXPECT_EQ(ConstantV, static_cast<Value*>(ShouldBeVisited2));
396 EXPECT_EQ(nullptr, static_cast<Value*>(ShouldBeVisited1));
397 EXPECT_EQ(nullptr, static_cast<Value*>(ShouldBeVisited2));
438 EXPECT_EQ(BitcastV.get(), GenericVH);
440 EXPECT_EQ(ConstantV, GenericVH);
472 EXPECT_EQ(BV < CV, BitcastVH < ConstantVH);
473 EXPECT_EQ(BV <= CV, BitcastVH <= ConstantVH);
474 EXPECT_EQ(BV > CV, BitcastVH > ConstantVH);
475 EXPECT_EQ(BV >= CV, BitcastVH >= ConstantVH);
477 EXPECT_EQ(BV < CV, BitcastV.get() < ConstantVH);
478 EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantVH);
479 EXPECT_EQ(BV > CV, BitcastV.get() > ConstantVH);
480 EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantVH);
482 EXPECT_EQ(BV < CV, BitcastVH < ConstantV);
483 EXPECT_EQ(BV <= CV, BitcastVH <= ConstantV);
484 EXPECT_EQ(BV > CV, BitcastVH > ConstantV);
485 EXPECT_EQ(BV >= CV, BitcastVH >= ConstantV);
505 EXPECT_EQ(VH, ConstantV);
unittests/IR/ValueMapTest.cpp 43 EXPECT_EQ(7, VM1.lookup(nullptr));
49 EXPECT_EQ(7, VM.lookup(this->BitcastV.get()));
50 EXPECT_EQ(0u, VM.count(this->AddV.get()));
52 EXPECT_EQ(7, VM.lookup(this->AddV.get()));
53 EXPECT_EQ(0u, VM.count(this->BitcastV.get()));
55 EXPECT_EQ(0u, VM.count(this->AddV.get()));
56 EXPECT_EQ(0u, VM.count(this->BitcastV.get()));
57 EXPECT_EQ(0U, VM.size());
73 EXPECT_EQ(this->BitcastV.get(), I->first);
74 EXPECT_EQ(7, I->second);
82 EXPECT_EQ(this->BitcastV.get(), CI->first);
83 EXPECT_EQ(7, CI->second);
89 EXPECT_EQ(this->AddV.get(), InsertResult1.first->first);
90 EXPECT_EQ(3, InsertResult1.first->second);
92 EXPECT_EQ(1u, VM.count(this->AddV.get()));
95 EXPECT_EQ(this->AddV.get(), InsertResult2.first->first);
96 EXPECT_EQ(3, InsertResult2.first->second);
101 EXPECT_EQ(0U, VM.count(this->AddV.get()));
102 EXPECT_EQ(1U, VM.count(this->BitcastV.get()));
104 EXPECT_EQ(0U, VM.count(this->BitcastV.get()));
105 EXPECT_EQ(0U, VM.size());
112 EXPECT_EQ(1, VM.lookup(this->AddV.get()));
113 EXPECT_EQ(2, VM.lookup(this->BitcastV.get()));
133 EXPECT_EQ(this->BitcastV.get(), I->first);
136 EXPECT_EQ(this->AddV.get(), I->first);
142 EXPECT_EQ(2U, size);
143 EXPECT_EQ(5, VM[this->BitcastV.get()]);
144 EXPECT_EQ(6, VM[this->AddV.get()]);
155 EXPECT_EQ(this->BitcastV.get(), I->first);
157 EXPECT_EQ(this->AddV.get(), I->first);
162 EXPECT_EQ(2U, size);
171 EXPECT_EQ(0u, VM.count(this->BitcastV.get()));
172 EXPECT_EQ(9, VM.lookup(this->AddV.get()));
220 EXPECT_EQ(7, VM.lookup(this->BitcastV.get()));
221 EXPECT_EQ(0u, VM.count(this->AddV.get()));
223 EXPECT_EQ(7, VM.lookup(this->BitcastV.get()));
224 EXPECT_EQ(0, VM.lookup(this->AddV.get()));
226 EXPECT_EQ(7, VM.lookup(this->BitcastV.get()));
227 EXPECT_EQ(0, VM.lookup(this->AddV.get()));
229 EXPECT_EQ(0, VM.lookup(this->BitcastV.get()));
230 EXPECT_EQ(0, VM.lookup(this->AddV.get()));
231 EXPECT_EQ(0U, VM.size());
255 EXPECT_EQ(0, Deletions);
256 EXPECT_EQ(1, RAUWs);
258 EXPECT_EQ(1, Deletions);
259 EXPECT_EQ(1, RAUWs);
261 EXPECT_EQ(1, Deletions);
262 EXPECT_EQ(1, RAUWs);
287 EXPECT_EQ(0u, VM.count(this->BitcastV.get()));
288 EXPECT_EQ(0u, VM.count(this->AddV.get()));
291 EXPECT_EQ(0u, VM.count(this->AddV.get()));
unittests/IR/ValueTest.cpp 65 EXPECT_EQ(Dummy0->getAlignment(), 536870912U);
69 EXPECT_EQ(Dummy0, Dummy1);
70 EXPECT_EQ(1u, Dummy1->getType()->getPointerAddressSpace());
87 EXPECT_EQ(1u, DummyCast1->getType()->getPointerAddressSpace());
219 EXPECT_EQ(MST.getLocalSlot(I0), 0);
220 EXPECT_EQ(MST.getLocalSlot(I1), 1);
221 EXPECT_EQ(MST.getLocalSlot(&EntryBB), -1);
222 EXPECT_EQ(MST.getLocalSlot(BB2), 2);
unittests/IR/VectorTypesTest.cpp 27 EXPECT_EQ(V8Int32Ty->getNumElements(), 8U);
28 EXPECT_EQ(V8Int32Ty->getElementType()->getScalarSizeInBits(), 32U);
32 EXPECT_EQ(V8Int16Ty->getNumElements(), 8U);
33 EXPECT_EQ(V8Int16Ty->getElementType()->getScalarSizeInBits(), 16U);
38 EXPECT_EQ(V4Int64Ty->getNumElements(), 4U);
39 EXPECT_EQ(V4Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
43 EXPECT_EQ(V2Int64Ty->getNumElements(), 2U);
44 EXPECT_EQ(V2Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
48 EXPECT_EQ(V8Int64Ty->getNumElements(), 8U);
49 EXPECT_EQ(V8Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
53 EXPECT_EQ(V4Float64Ty->getNumElements(), 4U);
54 EXPECT_EQ(V4Float64Ty->getElementType()->getScalarSizeInBits(), 64U);
57 EXPECT_EQ(ExtTy, V8Int32Ty);
59 EXPECT_EQ(ExtTy->getNumElements(), 8U);
60 EXPECT_EQ(ExtTy->getElementType()->getScalarSizeInBits(), 32U);
63 EXPECT_EQ(TruncTy, V8Int16Ty);
65 EXPECT_EQ(TruncTy->getNumElements(), 8U);
66 EXPECT_EQ(TruncTy->getElementType()->getScalarSizeInBits(), 16U);
69 EXPECT_EQ(HalvedTy, V2Int64Ty);
71 EXPECT_EQ(HalvedTy->getNumElements(), 2U);
72 EXPECT_EQ(HalvedTy->getElementType()->getScalarSizeInBits(), 64U);
75 EXPECT_EQ(DoubledTy, V8Int64Ty);
77 EXPECT_EQ(DoubledTy->getNumElements(), 8U);
78 EXPECT_EQ(DoubledTy->getElementType()->getScalarSizeInBits(), 64U);
81 EXPECT_EQ(ConvTy, V4Int64Ty);
83 EXPECT_EQ(ConvTy->getNumElements(), 4U);
84 EXPECT_EQ(ConvTy->getElementType()->getScalarSizeInBits(), 64U);
87 EXPECT_EQ(EltCnt.Min, 8U);
101 EXPECT_EQ(ScV8Int32Ty->getNumElements(), 8U);
102 EXPECT_EQ(ScV8Int32Ty->getElementType()->getScalarSizeInBits(), 32U);
106 EXPECT_EQ(ScV8Int16Ty->getNumElements(), 8U);
107 EXPECT_EQ(ScV8Int16Ty->getElementType()->getScalarSizeInBits(), 16U);
112 EXPECT_EQ(ScV4Int64Ty->getNumElements(), 4U);
113 EXPECT_EQ(ScV4Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
117 EXPECT_EQ(ScV2Int64Ty->getNumElements(), 2U);
118 EXPECT_EQ(ScV2Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
122 EXPECT_EQ(ScV8Int64Ty->getNumElements(), 8U);
123 EXPECT_EQ(ScV8Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
127 EXPECT_EQ(ScV4Float64Ty->getNumElements(), 4U);
128 EXPECT_EQ(ScV4Float64Ty->getElementType()->getScalarSizeInBits(), 64U);
131 EXPECT_EQ(ExtTy, ScV8Int32Ty);
133 EXPECT_EQ(ExtTy->getNumElements(), 8U);
134 EXPECT_EQ(ExtTy->getElementType()->getScalarSizeInBits(), 32U);
137 EXPECT_EQ(TruncTy, ScV8Int16Ty);
139 EXPECT_EQ(TruncTy->getNumElements(), 8U);
140 EXPECT_EQ(TruncTy->getElementType()->getScalarSizeInBits(), 16U);
143 EXPECT_EQ(HalvedTy, ScV2Int64Ty);
145 EXPECT_EQ(HalvedTy->getNumElements(), 2U);
146 EXPECT_EQ(HalvedTy->getElementType()->getScalarSizeInBits(), 64U);
149 EXPECT_EQ(DoubledTy, ScV8Int64Ty);
151 EXPECT_EQ(DoubledTy->getNumElements(), 8U);
152 EXPECT_EQ(DoubledTy->getElementType()->getScalarSizeInBits(), 64U);
155 EXPECT_EQ(ConvTy, ScV4Int64Ty);
157 EXPECT_EQ(ConvTy->getNumElements(), 4U);
158 EXPECT_EQ(ConvTy->getElementType()->getScalarSizeInBits(), 64U);
161 EXPECT_EQ(EltCnt.Min, 8U);
178 EXPECT_EQ(V2I32Len.getKnownMinSize(), 64U);
185 EXPECT_EQ(V4Int32Ty->getPrimitiveSizeInBits(),
191 EXPECT_EQ(V2Int64Ty->getPrimitiveSizeInBits().getFixedSize(),
195 EXPECT_EQ(DL.getTypeSizeInBits(V2Int64Ty),
197 EXPECT_EQ(DL.getTypeSizeInBits(V2Int32Ty), 64U);
198 EXPECT_EQ(DL.getTypeSizeInBits(V2Int64Ty), 128U);
199 EXPECT_EQ(DL.getTypeStoreSize(V2Int64Ty),
203 EXPECT_EQ(DL.getTypeStoreSizeInBits(V2Int32Ty), 64U);
204 EXPECT_EQ(DL.getTypeStoreSize(V2Int64Ty), 16U);
205 EXPECT_EQ(DL.getTypeAllocSize(V4Int32Ty),
209 EXPECT_EQ(DL.getTypeAllocSizeInBits(V4Int32Ty), 128U);
210 EXPECT_EQ(DL.getTypeAllocSize(V2Int32Ty), 8U);
227 EXPECT_EQ(ScV2I32Len.getKnownMinSize(), 64U);
234 EXPECT_EQ(ScV4Int32Ty->getPrimitiveSizeInBits(),
240 EXPECT_EQ(DL.getTypeSizeInBits(ScV2Int64Ty),
242 EXPECT_EQ(DL.getTypeSizeInBits(ScV2Int32Ty).getKnownMinSize(), 64U);
243 EXPECT_EQ(DL.getTypeStoreSize(ScV2Int64Ty),
247 EXPECT_EQ(DL.getTypeStoreSizeInBits(ScV2Int32Ty).getKnownMinSize(), 64U);
248 EXPECT_EQ(DL.getTypeStoreSize(ScV2Int64Ty).getKnownMinSize(), 16U);
249 EXPECT_EQ(DL.getTypeAllocSize(ScV4Int32Ty),
253 EXPECT_EQ(DL.getTypeAllocSizeInBits(ScV4Int32Ty).getKnownMinSize(), 128U);
254 EXPECT_EQ(DL.getTypeAllocSize(ScV2Int32Ty).getKnownMinSize(), 8U);
271 EXPECT_EQ(V4Int32Ty->getPrimitiveSizeInBits().getKnownMinSize(),
unittests/IR/WaymarkTest.cpp 38 EXPECT_EQ(A, U->getUser());
49 EXPECT_EQ(reinterpret_cast<User *>(Ue + 1), U->getUser());
unittests/LineEditor/LineEditor.cpp 51 EXPECT_EQ(0u, Pos);
62 EXPECT_EQ(LineEditor::CompletionAction::AK_Insert, CA.Kind);
63 EXPECT_EQ("foo", CA.Text);
68 EXPECT_EQ(LineEditor::CompletionAction::AK_ShowCompletions, CA.Kind);
80 EXPECT_EQ(LineEditor::CompletionAction::AK_Insert, CA.Kind);
81 EXPECT_EQ("f", CA.Text);
unittests/Linker/LinkModulesTest.cpp 113 EXPECT_EQ(AT, Init->getType());
117 EXPECT_EQ(cast<BlockAddress>(Elem)->getFunction(),
119 EXPECT_EQ(cast<BlockAddress>(Elem)->getBasicBlock()->getParent(),
124 EXPECT_EQ(cast<BlockAddress>(Elem)->getFunction(),
126 EXPECT_EQ(cast<BlockAddress>(Elem)->getBasicBlock()->getParent(),
200 EXPECT_EQ(M1->getNamedGlobal("t1")->getType(),
209 EXPECT_EQ(0, Result);
231 EXPECT_EQ(1, Result);
232 EXPECT_EQ("Linking globals named 'foo': symbol multiply defined!", Err);
277 EXPECT_EQ(M3, M4->getOperand(0));
293 EXPECT_EQ(M0, F->getMetadata("attach"));
294 EXPECT_EQ(M1, cast<MetadataAsValue>(CI->getArgOperand(0))->getMetadata());
295 EXPECT_EQ(M2, RI->getMetadata("attach"));
296 EXPECT_EQ(M3, NMD->getOperand(0));
297 EXPECT_EQ(M4, NMD->getOperand(1));
305 EXPECT_EQ(M3, M4->getOperand(0));
unittests/MC/Disassembler.cpp 43 EXPECT_EQ(InstSize, 1U);
44 EXPECT_EQ(StringRef(OutString), "\tnop");
51 EXPECT_EQ(InstSize, 1U);
52 EXPECT_EQ(StringRef(OutString), "\tnop");
59 EXPECT_EQ(InstSize, 2U);
60 EXPECT_EQ(StringRef(OutString), "\tjmp\t0x1");
85 EXPECT_EQ(InstSize, 1U);
86 EXPECT_EQ(StringRef(OutString), "\ti32.add ");
93 EXPECT_EQ(InstSize, 2U);
94 EXPECT_EQ(StringRef(OutString), "\ti64.const\t-1");
102 EXPECT_EQ(InstSize, 3U);
103 EXPECT_EQ(StringRef(OutString), "\ti64.load32_u\t16:p2align=1");
unittests/MC/DwarfLineTables.cpp 62 EXPECT_EQ(ExpectedEncoding, arrayRefFromStringRef(Buffer));
unittests/MC/MCInstPrinter.cpp 65 EXPECT_EQ("0x1", formatHex<int64_t>(1));
66 EXPECT_EQ("0x7fffffffffffffff",
68 EXPECT_EQ("-0x8000000000000000",
unittests/MC/StringTableBuilderTest.cpp 39 EXPECT_EQ(Expected, Data);
40 EXPECT_EQ(1U, B.getOffset("foobar"));
41 EXPECT_EQ(4U, B.getOffset("bar"));
42 EXPECT_EQ(8U, B.getOffset("foo"));
57 EXPECT_EQ(ExpectedSize, B.getSize());
73 EXPECT_EQ(Expected, Data);
74 EXPECT_EQ(4U, B.getOffset("pygmy hippopotamus"));
75 EXPECT_EQ(10U, B.getOffset("hippopotamus"));
76 EXPECT_EQ(23U, B.getOffset("river horse"));
81 EXPECT_EQ(1U, B.add("foo"));
82 EXPECT_EQ(5U, B.add("bar"));
83 EXPECT_EQ(9U, B.add("foobar"));
100 EXPECT_EQ(Expected, Data);
101 EXPECT_EQ(1U, B.getOffset("foo"));
102 EXPECT_EQ(5U, B.getOffset("bar"));
103 EXPECT_EQ(9U, B.getOffset("foobar"));
unittests/Object/MinidumpTest.cpp 41 EXPECT_EQ(Header::MagicSignature, H.Signature);
42 EXPECT_EQ(Header::MagicVersion, H.Version);
43 EXPECT_EQ(1u, H.NumberOfStreams);
44 EXPECT_EQ(0x20u, H.StreamDirectoryRVA);
45 EXPECT_EQ(0x03020100u, H.Checksum);
46 EXPECT_EQ(0x07060504u, H.TimeDateStamp);
47 EXPECT_EQ(uint64_t(0x0504030201000908), H.Flags);
51 EXPECT_EQ(StreamType::LinuxCPUInfo, Stream0.Type);
52 EXPECT_EQ(7u, Stream0.Location.DataSize);
53 EXPECT_EQ(0x2cu, Stream0.Location.RVA);
55 EXPECT_EQ("CPUINFO", toStringRef(File.getRawStream(Stream0)));
56 EXPECT_EQ("CPUINFO",
201 EXPECT_EQ(StreamType::Unused, File.streams()[0].Type);
202 EXPECT_EQ(StreamType::Unused, File.streams()[1].Type);
203 EXPECT_EQ(None, File.getRawStream(StreamType::Unused));
234 EXPECT_EQ(ProcessorArchitecture::X86, Info.ProcessorArch);
235 EXPECT_EQ(0x0201, Info.ProcessorLevel);
236 EXPECT_EQ(0x0403, Info.ProcessorRevision);
237 EXPECT_EQ(5, Info.NumberOfProcessors);
238 EXPECT_EQ(6, Info.ProductType);
239 EXPECT_EQ(0x00090807u, Info.MajorVersion);
240 EXPECT_EQ(0x04030201u, Info.MinorVersion);
241 EXPECT_EQ(0x08070605u, Info.BuildNumber);
242 EXPECT_EQ(OSPlatform::Win32NT, Info.PlatformId);
243 EXPECT_EQ(0x04030201u, Info.CSDVersionRVA);
244 EXPECT_EQ(0x0605u, Info.SuiteMask);
245 EXPECT_EQ(0x0807u, Info.Reserved);
246 EXPECT_EQ("LLVMLLVMLLVM", llvm::StringRef(Info.CPU.X86.VendorID,
248 EXPECT_EQ(0x04030201u, Info.CPU.X86.VersionInfo);
249 EXPECT_EQ(0x08070605u, Info.CPU.X86.FeatureInfo);
250 EXPECT_EQ(0x02010009u, Info.CPU.X86.AMDExtendedFeatures);
354 EXPECT_EQ(0x0807060504030201u, M.BaseOfImage);
355 EXPECT_EQ(0x02010009u, M.SizeOfImage);
356 EXPECT_EQ(0x06050403u, M.Checksum);
357 EXPECT_EQ(0x00090807u, M.TimeDateStamp);
358 EXPECT_EQ(0x04030201u, M.ModuleNameRVA);
359 EXPECT_EQ(0x04030201u, M.CvRecord.DataSize);
360 EXPECT_EQ(0x08070605u, M.CvRecord.RVA);
361 EXPECT_EQ(0x02010009u, M.MiscRecord.DataSize);
362 EXPECT_EQ(0x06050403u, M.MiscRecord.RVA);
363 EXPECT_EQ(0x0403020100090807u, M.Reserved0);
364 EXPECT_EQ(0x0201000908070605u, M.Reserved1);
454 EXPECT_EQ(0x04030201u, T.ThreadId);
455 EXPECT_EQ(0x08070605u, T.SuspendCount);
456 EXPECT_EQ(0x02010009u, T.PriorityClass);
457 EXPECT_EQ(0x06050403u, T.Priority);
458 EXPECT_EQ(0x0403020100090807u, T.EnvironmentBlock);
459 EXPECT_EQ(0x0201000908070605u, T.Stack.StartOfMemoryRange);
460 EXPECT_EQ(0x06050403u, T.Stack.Memory.DataSize);
461 EXPECT_EQ(0x00090807u, T.Stack.Memory.RVA);
462 EXPECT_EQ(0x04030201u, T.Context.DataSize);
463 EXPECT_EQ(0x08070605u, T.Context.RVA);
509 EXPECT_EQ(0x0201000908070605u, MD.StartOfMemoryRange);
510 EXPECT_EQ(0x06050403u, MD.Memory.DataSize);
511 EXPECT_EQ(0x00090807u, MD.Memory.RVA);
594 EXPECT_EQ(0x0706050403020100u, Info.BaseAddress);
595 EXPECT_EQ(0x0504030201000908u, Info.AllocationBase);
596 EXPECT_EQ(MemoryProtection::Execute, Info.AllocationProtect);
597 EXPECT_EQ(0x09080706u, Info.Reserved0);
598 EXPECT_EQ(0x0706050403020100u, Info.RegionSize);
599 EXPECT_EQ(MemoryState::Commit, Info.State);
600 EXPECT_EQ(MemoryProtection::ExecuteRead, Info.Protect);
601 EXPECT_EQ(MemoryType::Private, Info.Type);
602 EXPECT_EQ(0x01000908u, Info.Reserved1);
757 EXPECT_EQ(0x04030201u, ExpectedStream->ThreadId);
759 EXPECT_EQ(0x02040302u, Exception.ExceptionCode);
760 EXPECT_EQ(0x09080807u, Exception.ExceptionFlags);
761 EXPECT_EQ(0x0a09080706050403u, Exception.ExceptionRecord);
762 EXPECT_EQ(0x0102030405060708u, Exception.ExceptionAddress);
763 EXPECT_EQ(4u, Exception.NumberParameters);
765 EXPECT_EQ(0x1716151413121110u + index * 0x1010101010101010u,
768 EXPECT_EQ(0x84838281, ExpectedStream->ThreadContext.DataSize);
769 EXPECT_EQ(0x88878685, ExpectedStream->ThreadContext.RVA);
unittests/Object/SymbolicFileTest.cpp 40 EXPECT_EQ(Expected, s);
unittests/ObjectYAML/MinidumpYAMLTest.cpp 52 EXPECT_EQ(StreamType::SystemInfo, File.streams()[0].Type);
56 EXPECT_EQ(ProcessorArchitecture::ARM64, SysInfo.ProcessorArch);
57 EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
58 EXPECT_EQ(0x05060708u, SysInfo.CPU.Arm.CPUID);
60 EXPECT_EQ(StreamType::LinuxMaps, File.streams()[1].Type);
61 EXPECT_EQ("400d9000-400db000 r-xp 00000000 b3:04 227 "
67 EXPECT_EQ(StreamType::LinuxAuxv, File.streams()[2].Type);
68 EXPECT_EQ((ArrayRef<uint8_t>{0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD, 0xF0, 0x0D}),
83 EXPECT_EQ(
109 EXPECT_EQ(ProcessorArchitecture::X86, SysInfo.ProcessorArch);
110 EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
111 EXPECT_EQ("LLVMLLVMLLVM", StringRef(SysInfo.CPU.X86.VendorID,
113 EXPECT_EQ(0x01020304u, SysInfo.CPU.X86.VersionInfo);
114 EXPECT_EQ(0x05060708u, SysInfo.CPU.X86.FeatureInfo);
115 EXPECT_EQ(0x09000102u, SysInfo.CPU.X86.AMDExtendedFeatures);
136 EXPECT_EQ(ProcessorArchitecture::PPC, SysInfo.ProcessorArch);
137 EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
138 EXPECT_EQ(
171 EXPECT_EQ(0x7u, Stream.ThreadId);
173 EXPECT_EQ(0x23u, Exception.ExceptionCode);
174 EXPECT_EQ(0x5u, Exception.ExceptionFlags);
175 EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
176 EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
177 EXPECT_EQ(2u, Exception.NumberParameters);
178 EXPECT_EQ(0x22u, Exception.ExceptionInformation[0]);
179 EXPECT_EQ(0x24u, Exception.ExceptionInformation[1]);
184 EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
214 EXPECT_EQ(0x7u, Stream.ThreadId);
216 EXPECT_EQ(0x23u, Exception.ExceptionCode);
217 EXPECT_EQ(0x5u, Exception.ExceptionFlags);
218 EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
219 EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
220 EXPECT_EQ(0u, Exception.NumberParameters);
225 EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
270 EXPECT_EQ(0x8u, Stream.ThreadId);
272 EXPECT_EQ(0x0u, Exception.ExceptionCode);
273 EXPECT_EQ(0x0u, Exception.ExceptionFlags);
274 EXPECT_EQ(0x00u, Exception.ExceptionRecord);
275 EXPECT_EQ(0x0u, Exception.ExceptionAddress);
276 EXPECT_EQ(16u, Exception.NumberParameters);
277 EXPECT_EQ(0x0u, Exception.ExceptionInformation[0]);
279 EXPECT_EQ(0x110u - Index * 0x11, Exception.ExceptionInformation[Index]);
285 EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
321 EXPECT_EQ(0x7u, Stream.ThreadId);
323 EXPECT_EQ(0x23u, Exception.ExceptionCode);
324 EXPECT_EQ(0x5u, Exception.ExceptionFlags);
325 EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
326 EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
327 EXPECT_EQ(2u, Exception.NumberParameters);
328 EXPECT_EQ(0x99u, Exception.ExceptionInformation[0]);
329 EXPECT_EQ(0x23u, Exception.ExceptionInformation[1]);
330 EXPECT_EQ(0x42u, Exception.ExceptionInformation[2]);
335 EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
unittests/Option/OptionParsingTest.cpp 82 EXPECT_EQ("hi", AL.getLastArgValue(OPT_B));
83 EXPECT_EQ("bye", AL.getLastArgValue(OPT_C));
84 EXPECT_EQ("adena", AL.getLastArgValue(OPT_D));
86 EXPECT_EQ("apple", Es[0]);
87 EXPECT_EQ("bloom", Es[1]);
88 EXPECT_EQ("42", AL.getLastArgValue(OPT_F));
90 EXPECT_EQ("chuu", Gs[0]);
91 EXPECT_EQ("2", Gs[1]);
106 EXPECT_EQ("desu", StringRef((*Cs.begin())->getValue()));
110 EXPECT_EQ("-C", StringRef(ASL[0]));
111 EXPECT_EQ("desu", StringRef(ASL[1]));
138 EXPECT_EQ("foo", AL.getLastArgValue(OPT_SLASH_C));
139 EXPECT_EQ("bar", AL.getLastArgValue(OPT_C));
158 EXPECT_EQ("foo", AL.getAllArgValues(OPT_B)[0]);
159 EXPECT_EQ("bar", AL.getAllArgValues(OPT_B)[1]);
190 EXPECT_EQ(0U, AL.getAllArgValues(OPT_Slurp).size());
199 EXPECT_EQ(AL.size(), 2U);
203 EXPECT_EQ(3U, AL.getAllArgValues(OPT_Slurp).size());
204 EXPECT_EQ("-B", AL.getAllArgValues(OPT_Slurp)[0]);
205 EXPECT_EQ("--", AL.getAllArgValues(OPT_Slurp)[1]);
206 EXPECT_EQ("foo", AL.getAllArgValues(OPT_Slurp)[2]);
217 EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined).size(), 0U);
228 EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined).size(), 1U);
229 EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined)[0], "foo");
240 EXPECT_EQ(3U, AL.getAllArgValues(OPT_SlurpJoined).size());
241 EXPECT_EQ("foo", AL.getAllArgValues(OPT_SlurpJoined)[0]);
242 EXPECT_EQ("bar", AL.getAllArgValues(OPT_SlurpJoined)[1]);
243 EXPECT_EQ("baz", AL.getAllArgValues(OPT_SlurpJoined)[2]);
254 EXPECT_EQ(3U, AL.getAllArgValues(OPT_SlurpJoined).size());
255 EXPECT_EQ("foo", AL.getAllArgValues(OPT_SlurpJoined)[0]);
256 EXPECT_EQ("bar", AL.getAllArgValues(OPT_SlurpJoined)[1]);
257 EXPECT_EQ("baz", AL.getAllArgValues(OPT_SlurpJoined)[2]);
267 EXPECT_EQ(AL.size(), 1U);
269 EXPECT_EQ(1U, AL.getAllArgValues(OPT_B).size());
270 EXPECT_EQ("", AL.getAllArgValues(OPT_B)[0]);
285 EXPECT_EQ(1U, T.findNearest("-blorb", Nearest));
286 EXPECT_EQ(Nearest, "-blorp");
287 EXPECT_EQ(1U, T.findNearest("--blorm", Nearest));
288 EXPECT_EQ(Nearest, "--blorp");
289 EXPECT_EQ(1U, T.findNearest("-blarg", Nearest));
290 EXPECT_EQ(Nearest, "-blarn");
291 EXPECT_EQ(1U, T.findNearest("--blarm", Nearest));
292 EXPECT_EQ(Nearest, "--blarn");
293 EXPECT_EQ(1U, T.findNearest("-fjormp", Nearest));
294 EXPECT_EQ(Nearest, "--fjormp");
298 EXPECT_EQ(1U, T.findNearest("/framb:foo", Nearest));
299 EXPECT_EQ(Nearest, "/cramb:foo");
303 EXPECT_EQ(Nearest, "--glorrmp=");
304 EXPECT_EQ(0U, T.findNearest("--glorrmp=foo", Nearest));
308 EXPECT_EQ(1U, T.findNearest("--blurmps", Nearest));
309 EXPECT_EQ(Nearest, "--blurmp");
312 EXPECT_EQ(1U, T.findNearest("--blurmps=foo", Nearest));
313 EXPECT_EQ(Nearest, "--blurmp=foo");
316 EXPECT_EQ(1U, T.findNearest("-doopf", Nearest, /*FlagsToInclude=*/OptFlag2));
317 EXPECT_EQ(Nearest, "-doopf2");
318 EXPECT_EQ(1U, T.findNearest("-doopf", Nearest,
321 EXPECT_EQ(Nearest, "-doopf1");
331 EXPECT_EQ(1U, T.findNearest("--erbghFoo", Nearest));
332 EXPECT_EQ(Nearest, "--ermghFoo");
unittests/ProfileData/CoverageMappingTest.cpp 303 EXPECT_EQ(FileNames[Output.Regions[I].LineStart],
327 EXPECT_EQ(I, Data.begin()->Line);
351 EXPECT_EQ(2, std::distance(FunctionRecords.begin(), FunctionRecords.end()));
357 EXPECT_EQ(CoverageSegment(1, 1, 10, true), Segments[0]);
358 EXPECT_EQ(CoverageSegment(5, 5, false), Segments[1]);
361 EXPECT_EQ(CoverageSegment(2, 2, 20, true), Segments[0]);
362 EXPECT_EQ(CoverageSegment(6, 6, false), Segments[1]);
384 EXPECT_EQ(CoverageSegment(1, 1, 6, true), Segments[0]);
385 EXPECT_EQ(CoverageSegment(2, 2, false), Segments[1]);
402 EXPECT_EQ(CoverageSegment(1, 1, 1, true), Segments[0]);
403 EXPECT_EQ(CoverageSegment(5, 1, true), Segments[1]);
404 EXPECT_EQ(CoverageSegment(5, 5, false), Segments[2]);
458 EXPECT_EQ(CoverageSegment(1, 1, 1, true), Segments[0]);
459 EXPECT_EQ(CoverageSegment(3, 5, 1, true), Segments[1]);
460 EXPECT_EQ(CoverageSegment(5, 4, 0, false), Segments[2]);
461 EXPECT_EQ(CoverageSegment(7, 3, 0, true), Segments[3]);
462 EXPECT_EQ(CoverageSegment(7, 7, 0, true), Segments[4]);
463 EXPECT_EQ(CoverageSegment(9, 2, 0, false), Segments[5]);
464 EXPECT_EQ(CoverageSegment(9, 7, 1, false), Segments[6]);
465 EXPECT_EQ(CoverageSegment(9, 9, false), Segments[7]);
486 EXPECT_EQ(CoverageSegment(2, 1, 1, true), Segments[0]);
487 EXPECT_EQ(CoverageSegment(8, 10, 0, true), Segments[1]);
488 EXPECT_EQ(CoverageSegment(8, 12, 0, true), Segments[2]);
489 EXPECT_EQ(CoverageSegment(9, 1, 1, true), Segments[3]);
490 EXPECT_EQ(CoverageSegment(11, 13, 2, true), Segments[4]);
492 EXPECT_EQ(CoverageSegment(11, 14, 1, false), Segments[5]);
493 EXPECT_EQ(CoverageSegment(18, 2, false), Segments[6]);
511 EXPECT_EQ(CoverageSegment(1, 1, 1, true), Segments[0]);
512 EXPECT_EQ(CoverageSegment(2, 2, 1, true), Segments[1]);
513 EXPECT_EQ(CoverageSegment(3, 3, 1, true), Segments[2]);
514 EXPECT_EQ(CoverageSegment(4, 4, 1, false), Segments[3]);
517 EXPECT_EQ(CoverageSegment(6, 6, false), Segments[4]);
536 EXPECT_EQ(CoverageSegment(1, 1, 1, true), Segments[0]);
537 EXPECT_EQ(CoverageSegment(2, 2, 1, true), Segments[1]);
538 EXPECT_EQ(CoverageSegment(3, 3, 1, true), Segments[2]);
539 EXPECT_EQ(CoverageSegment(6, 5, 1, true), Segments[3]);
543 EXPECT_EQ(CoverageSegment(7, 7, false), Segments[4]);
563 EXPECT_EQ(CoverageSegment(1, 1, true), Segments[0]);
586 EXPECT_EQ(CoverageSegment(1, 5, 2, true), Segments[0]);
587 EXPECT_EQ(CoverageSegment(1, 9, 1, true), Segments[1]);
588 EXPECT_EQ(CoverageSegment(1, 50, 2, false), Segments[2]);
589 EXPECT_EQ(CoverageSegment(2, 7, 1, true), Segments[3]);
590 EXPECT_EQ(CoverageSegment(2, 34, 2, false), Segments[4]);
591 EXPECT_EQ(CoverageSegment(3, 5, 1, true), Segments[5]);
592 EXPECT_EQ(CoverageSegment(3, 21, 2, true), Segments[6]);
595 EXPECT_EQ(CoverageSegment(4, 4, false), Segments[7]);
597 EXPECT_EQ(CoverageSegment(4, 12, 1, true), Segments[8]);
598 EXPECT_EQ(CoverageSegment(4, 17, false), Segments[9]);
617 EXPECT_EQ(CoverageSegment(1, 1, 1, true), Segments[0]);
618 EXPECT_EQ(CoverageSegment(2, 2, 2, true), Segments[1]);
619 EXPECT_EQ(CoverageSegment(3, 3, 3, true), Segments[2]);
620 EXPECT_EQ(CoverageSegment(4, 4, 2, false), Segments[3]);
621 EXPECT_EQ(CoverageSegment(5, 5, 1, false), Segments[4]);
622 EXPECT_EQ(CoverageSegment(6, 6, 4, true), Segments[5]);
623 EXPECT_EQ(CoverageSegment(7, 7, 1, false), Segments[6]);
624 EXPECT_EQ(CoverageSegment(8, 8, false), Segments[7]);
744 EXPECT_EQ(CoverageSegment(1, 1, 30, true), Segments[0]);
745 EXPECT_EQ(CoverageSegment(3, 3, 40, true), Segments[1]);
746 EXPECT_EQ(CoverageSegment(5, 5, 30, false), Segments[2]);
747 EXPECT_EQ(CoverageSegment(9, 9, false), Segments[3]);
788 EXPECT_EQ(CoverageSegment(1, 1, 2, true), Segments[0]);
789 EXPECT_EQ(CoverageSegment(3, 1, 10, true), Segments[1]);
790 EXPECT_EQ(CoverageSegment(3, 5, 2, false), Segments[2]);
791 EXPECT_EQ(CoverageSegment(5, 5, false), Segments[3]);
854 EXPECT_EQ(CoverageSegment(1, 1, 10, true), Segments[0]);
855 EXPECT_EQ(CoverageSegment(1, 10, false), Segments[1]);
unittests/ProfileData/InstrProfTest.cpp 1008 EXPECT_EQ(1u, Counts[0]);
1009 EXPECT_EQ(2u, Counts[1]);
1010 EXPECT_EQ(3u, Counts[2]);
1011 EXPECT_EQ(4u, Counts[3]);
1018 EXPECT_EQ(5u, Counts[0]);
1019 EXPECT_EQ(6u, Counts[1]);
1020 EXPECT_EQ(7u, Counts[2]);
unittests/Remarks/BitstreamRemarksFormatTest.cpp 19 EXPECT_EQ(remarks::ContainerMagic, "RMRK");
24 EXPECT_EQ(remarks::CurrentContainerVersion, 0UL);
30 EXPECT_EQ(remarks::META_BLOCK_ID, 8);
31 EXPECT_EQ(remarks::REMARK_BLOCK_ID, 9);
37 EXPECT_EQ(remarks::RECORD_FIRST, 1);
38 EXPECT_EQ(remarks::RECORD_META_CONTAINER_INFO, 1);
39 EXPECT_EQ(remarks::RECORD_META_REMARK_VERSION, 2);
40 EXPECT_EQ(remarks::RECORD_META_STRTAB, 3);
41 EXPECT_EQ(remarks::RECORD_META_EXTERNAL_FILE, 4);
42 EXPECT_EQ(remarks::RECORD_REMARK_HEADER, 5);
43 EXPECT_EQ(remarks::RECORD_REMARK_DEBUG_LOC, 6);
44 EXPECT_EQ(remarks::RECORD_REMARK_HOTNESS, 7);
45 EXPECT_EQ(remarks::RECORD_REMARK_ARG_WITH_DEBUGLOC, 8);
46 EXPECT_EQ(remarks::RECORD_REMARK_ARG_WITHOUT_DEBUGLOC, 9);
47 EXPECT_EQ(remarks::RECORD_LAST, 9);
unittests/Remarks/BitstreamRemarksParsingTest.cpp 75 EXPECT_EQ(*FromYAMLRemark, *FromBSRemark);
139 EXPECT_EQ(StrLen, ExpectedLen);
171 EXPECT_EQ(Remark.RemarkType, remarks::Type::Missed);
172 EXPECT_EQ(checkStr(Remark.PassName, 6), "inline");
173 EXPECT_EQ(checkStr(Remark.RemarkName, 12), "NoDefinition");
174 EXPECT_EQ(checkStr(Remark.FunctionName, 3), "foo");
177 EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
178 EXPECT_EQ(RL.SourceLine, 3U);
179 EXPECT_EQ(RL.SourceColumn, 12U);
181 EXPECT_EQ(*Remark.Hotness, 4U);
182 EXPECT_EQ(Remark.Args.size(), 4U);
188 EXPECT_EQ(checkStr(Arg.Key, 6), "Callee");
189 EXPECT_EQ(checkStr(Arg.Val, 3), "bar");
193 EXPECT_EQ(checkStr(Arg.Key, 6), "String");
194 EXPECT_EQ(checkStr(Arg.Val, 26), " will not be inlined into ");
198 EXPECT_EQ(checkStr(Arg.Key, 6), "Caller");
199 EXPECT_EQ(checkStr(Arg.Val, 3), "foo");
202 EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
203 EXPECT_EQ(RL.SourceLine, 2U);
204 EXPECT_EQ(RL.SourceColumn, 0U);
208 EXPECT_EQ(checkStr(Arg.Key, 6), "String");
209 EXPECT_EQ(checkStr(Arg.Val, 38),
229 EXPECT_EQ(StrLen, ExpectedLen);
270 EXPECT_EQ(LLVMRemarkEntryGetType(Remark), LLVMRemarkTypeMissed);
271 EXPECT_EQ(checkStr(LLVMRemarkEntryGetPassName(Remark), 6), "inline");
272 EXPECT_EQ(checkStr(LLVMRemarkEntryGetRemarkName(Remark), 12), "NoDefinition");
273 EXPECT_EQ(checkStr(LLVMRemarkEntryGetFunctionName(Remark), 3), "foo");
275 EXPECT_EQ(checkStr(LLVMRemarkDebugLocGetSourceFilePath(DL), 6), "file.c");
276 EXPECT_EQ(LLVMRemarkDebugLocGetSourceLine(DL), 3U);
277 EXPECT_EQ(LLVMRemarkDebugLocGetSourceColumn(DL), 12U);
278 EXPECT_EQ(LLVMRemarkEntryGetHotness(Remark), 0U);
279 EXPECT_EQ(LLVMRemarkEntryGetNumArgs(Remark), 4U);
286 EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "Callee");
287 EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 3), "bar");
288 EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
291 EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "String");
292 EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 26),
294 EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
297 EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "Caller");
298 EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 3), "foo");
300 EXPECT_EQ(checkStr(LLVMRemarkDebugLocGetSourceFilePath(DL), 6), "file.c");
301 EXPECT_EQ(LLVMRemarkDebugLocGetSourceLine(DL), 2U);
302 EXPECT_EQ(LLVMRemarkDebugLocGetSourceColumn(DL), 0U);
306 EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "String");
307 EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 38),
309 EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
319 EXPECT_EQ(LLVMRemarkParserGetNext(Parser), nullptr);
333 EXPECT_EQ(ErrorMsg, toString(BSRemark.takeError())); // Expect an error.
unittests/Remarks/BitstreamRemarksSerializerTest.cpp 32 EXPECT_EQ(OutputOS.str(), Expected);
unittests/Remarks/RemarksAPITest.cpp 32 EXPECT_EQ(R, R);
63 EXPECT_EQ(R, R2);
77 EXPECT_EQ(R.getArgsAsMsg(), "can not do this because of that.");
84 EXPECT_EQ(StrTab.SerializedSize, 0UL);
112 EXPECT_EQ(StrTab.add(R.PassName).second.data(), R2.PassName.data());
113 EXPECT_EQ(StrTab.add(R.RemarkName).second.data(), R2.RemarkName.data());
114 EXPECT_EQ(StrTab.add(R.FunctionName).second.data(), R2.FunctionName.data());
115 EXPECT_EQ(StrTab.add(R.Loc->SourceFilePath).second.data(),
117 EXPECT_EQ(StrTab.add(R.Args.back().Key).second.data(),
119 EXPECT_EQ(StrTab.add(R.Args.back().Val).second.data(),
121 EXPECT_EQ(StrTab.add(R.Args.back().Loc->SourceFilePath).second.data(),
unittests/Remarks/RemarksStrTabParsingTest.cpp 20 EXPECT_EQ(toString(Nothing.takeError()),
29 EXPECT_EQ(*Result, "str1");
32 EXPECT_EQ(*Result, "str2");
35 EXPECT_EQ(*Result, "str3");
38 EXPECT_EQ(*Result, "str4");
unittests/Remarks/YAMLRemarksParsingTest.cpp 86 EXPECT_EQ(StringRef(Stream.str()).lower(), StringRef(Error).lower());
381 EXPECT_EQ(StrLen, ExpectedLen);
413 EXPECT_EQ(Remark.RemarkType, remarks::Type::Missed);
414 EXPECT_EQ(checkStr(Remark.PassName, 6), "inline");
415 EXPECT_EQ(checkStr(Remark.RemarkName, 12), "NoDefinition");
416 EXPECT_EQ(checkStr(Remark.FunctionName, 3), "foo");
419 EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
420 EXPECT_EQ(RL.SourceLine, 3U);
421 EXPECT_EQ(RL.SourceColumn, 12U);
423 EXPECT_EQ(*Remark.Hotness, 4U);
424 EXPECT_EQ(Remark.Args.size(), 4U);
430 EXPECT_EQ(checkStr(Arg.Key, 6), "Callee");
431 EXPECT_EQ(checkStr(Arg.Val, 3), "bar");
435 EXPECT_EQ(checkStr(Arg.Key, 6), "String");
436 EXPECT_EQ(checkStr(Arg.Val, 26), " will not be inlined into ");
440 EXPECT_EQ(checkStr(Arg.Key, 6), "Caller");
441 EXPECT_EQ(checkStr(Arg.Val, 3), "foo");
444 EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
445 EXPECT_EQ(RL.SourceLine, 2U);
446 EXPECT_EQ(RL.SourceColumn, 0U);
450 EXPECT_EQ(checkStr(Arg.Key, 6), "String");
451 EXPECT_EQ(checkStr(Arg.Val, 38),
471 EXPECT_EQ(StrLen, ExpectedLen);
494 EXPECT_EQ(LLVMRemarkEntryGetType(Remark), LLVMRemarkTypeMissed);
495 EXPECT_EQ(checkStr(LLVMRemarkEntryGetPassName(Remark), 6), "inline");
496 EXPECT_EQ(checkStr(LLVMRemarkEntryGetRemarkName(Remark), 12), "NoDefinition");
497 EXPECT_EQ(checkStr(LLVMRemarkEntryGetFunctionName(Remark), 3), "foo");
499 EXPECT_EQ(checkStr(LLVMRemarkDebugLocGetSourceFilePath(DL), 6), "file.c");
500 EXPECT_EQ(LLVMRemarkDebugLocGetSourceLine(DL), 3U);
501 EXPECT_EQ(LLVMRemarkDebugLocGetSourceColumn(DL), 12U);
502 EXPECT_EQ(LLVMRemarkEntryGetHotness(Remark), 0U);
503 EXPECT_EQ(LLVMRemarkEntryGetNumArgs(Remark), 4U);
510 EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "Callee");
511 EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 3), "bar");
512 EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
515 EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "String");
516 EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 26),
518 EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
521 EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "Caller");
522 EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 3), "foo");
524 EXPECT_EQ(checkStr(LLVMRemarkDebugLocGetSourceFilePath(DL), 6), "file.c");
525 EXPECT_EQ(LLVMRemarkDebugLocGetSourceLine(DL), 2U);
526 EXPECT_EQ(LLVMRemarkDebugLocGetSourceColumn(DL), 0U);
530 EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "String");
531 EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 38),
533 EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
543 EXPECT_EQ(LLVMRemarkParserGetNext(Parser), nullptr);
585 EXPECT_EQ(Remark.RemarkType, remarks::Type::Missed);
586 EXPECT_EQ(checkStr(Remark.PassName, 6), "inline");
587 EXPECT_EQ(checkStr(Remark.RemarkName, 12), "NoDefinition");
588 EXPECT_EQ(checkStr(Remark.FunctionName, 3), "foo");
591 EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
592 EXPECT_EQ(RL.SourceLine, 3U);
593 EXPECT_EQ(RL.SourceColumn, 12U);
595 EXPECT_EQ(*Remark.Hotness, 4U);
596 EXPECT_EQ(Remark.Args.size(), 4U);
602 EXPECT_EQ(checkStr(Arg.Key, 6), "Callee");
603 EXPECT_EQ(checkStr(Arg.Val, 3), "bar");
607 EXPECT_EQ(checkStr(Arg.Key, 6), "String");
608 EXPECT_EQ(checkStr(Arg.Val, 26), " will not be inlined into ");
612 EXPECT_EQ(checkStr(Arg.Key, 6), "Caller");
613 EXPECT_EQ(checkStr(Arg.Val, 3), "foo");
616 EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
617 EXPECT_EQ(RL.SourceLine, 2U);
618 EXPECT_EQ(RL.SourceColumn, 0U);
622 EXPECT_EQ(checkStr(Arg.Key, 6), "String");
623 EXPECT_EQ(checkStr(Arg.Val, 38),
unittests/Remarks/YAMLRemarksSerializerTest.cpp 43 EXPECT_EQ(OS.str(), ExpectedR);
50 EXPECT_EQ(OS.str(), *ExpectedMeta);
unittests/Support/AlignOfTest.cpp 104 EXPECT_EQ(1u, (alignof(AlignedCharArrayUnion<A1>)));
105 EXPECT_EQ(2u, (alignof(AlignedCharArrayUnion<A1, A2>)));
106 EXPECT_EQ(4u, (alignof(AlignedCharArrayUnion<A1, A2, A4>)));
107 EXPECT_EQ(8u, (alignof(AlignedCharArrayUnion<A1, A2, A4, A8>)));
109 EXPECT_EQ(1u, sizeof(AlignedCharArrayUnion<A1>));
110 EXPECT_EQ(2u, sizeof(AlignedCharArrayUnion<A1, A2>));
111 EXPECT_EQ(4u, sizeof(AlignedCharArrayUnion<A1, A2, A4>));
112 EXPECT_EQ(8u, sizeof(AlignedCharArrayUnion<A1, A2, A4, A8>));
114 EXPECT_EQ(1u, (alignof(AlignedCharArrayUnion<A1[1]>)));
115 EXPECT_EQ(2u, (alignof(AlignedCharArrayUnion<A1[2], A2[1]>)));
116 EXPECT_EQ(4u, (alignof(AlignedCharArrayUnion<A1[42], A2[55], A4[13]>)));
117 EXPECT_EQ(8u, (alignof(AlignedCharArrayUnion<A1[2], A2[1], A4, A8>)));
119 EXPECT_EQ(1u, sizeof(AlignedCharArrayUnion<A1[1]>));
120 EXPECT_EQ(2u, sizeof(AlignedCharArrayUnion<A1[2], A2[1]>));
121 EXPECT_EQ(4u, sizeof(AlignedCharArrayUnion<A1[3], A2[2], A4>));
122 EXPECT_EQ(16u, sizeof(AlignedCharArrayUnion<A1, A2[3],
128 EXPECT_EQ(alignof(T<char>), alignof(AlignedCharArrayUnion<char>));
129 EXPECT_EQ(alignof(T<short>), alignof(AlignedCharArrayUnion<short>));
130 EXPECT_EQ(alignof(T<int>), alignof(AlignedCharArrayUnion<int>));
131 EXPECT_EQ(alignof(T<long>), alignof(AlignedCharArrayUnion<long>));
132 EXPECT_EQ(alignof(T<long long>), alignof(AlignedCharArrayUnion<long long>));
133 EXPECT_EQ(alignof(T<float>), alignof(AlignedCharArrayUnion<float>));
134 EXPECT_EQ(alignof(T<double>), alignof(AlignedCharArrayUnion<double>));
135 EXPECT_EQ(alignof(T<long double>),
137 EXPECT_EQ(alignof(T<void *>), alignof(AlignedCharArrayUnion<void *>));
138 EXPECT_EQ(alignof(T<int *>), alignof(AlignedCharArrayUnion<int *>));
139 EXPECT_EQ(alignof(T<double (*)(double)>),
141 EXPECT_EQ(alignof(T<double (S6::*)()>),
143 EXPECT_EQ(alignof(S1), alignof(AlignedCharArrayUnion<S1>));
144 EXPECT_EQ(alignof(S2), alignof(AlignedCharArrayUnion<S2>));
145 EXPECT_EQ(alignof(S3), alignof(AlignedCharArrayUnion<S3>));
146 EXPECT_EQ(alignof(S4), alignof(AlignedCharArrayUnion<S4>));
147 EXPECT_EQ(alignof(S5), alignof(AlignedCharArrayUnion<S5>));
148 EXPECT_EQ(alignof(S6), alignof(AlignedCharArrayUnion<S6>));
149 EXPECT_EQ(alignof(D1), alignof(AlignedCharArrayUnion<D1>));
150 EXPECT_EQ(alignof(D2), alignof(AlignedCharArrayUnion<D2>));
151 EXPECT_EQ(alignof(D3), alignof(AlignedCharArrayUnion<D3>));
152 EXPECT_EQ(alignof(D4), alignof(AlignedCharArrayUnion<D4>));
153 EXPECT_EQ(alignof(D5), alignof(AlignedCharArrayUnion<D5>));
154 EXPECT_EQ(alignof(D6), alignof(AlignedCharArrayUnion<D6>));
155 EXPECT_EQ(alignof(D7), alignof(AlignedCharArrayUnion<D7>));
156 EXPECT_EQ(alignof(D8), alignof(AlignedCharArrayUnion<D8>));
157 EXPECT_EQ(alignof(D9), alignof(AlignedCharArrayUnion<D9>));
158 EXPECT_EQ(alignof(V1), alignof(AlignedCharArrayUnion<V1>));
159 EXPECT_EQ(alignof(V2), alignof(AlignedCharArrayUnion<V2>));
160 EXPECT_EQ(alignof(V3), alignof(AlignedCharArrayUnion<V3>));
161 EXPECT_EQ(alignof(V4), alignof(AlignedCharArrayUnion<V4>));
162 EXPECT_EQ(alignof(V5), alignof(AlignedCharArrayUnion<V5>));
163 EXPECT_EQ(alignof(V6), alignof(AlignedCharArrayUnion<V6>));
164 EXPECT_EQ(alignof(V7), alignof(AlignedCharArrayUnion<V7>));
169 EXPECT_EQ(alignof(V8), alignof(AlignedCharArrayUnion<V8>));
172 EXPECT_EQ(sizeof(char), sizeof(AlignedCharArrayUnion<char>));
173 EXPECT_EQ(sizeof(char[1]), sizeof(AlignedCharArrayUnion<char[1]>));
174 EXPECT_EQ(sizeof(char[2]), sizeof(AlignedCharArrayUnion<char[2]>));
175 EXPECT_EQ(sizeof(char[3]), sizeof(AlignedCharArrayUnion<char[3]>));
176 EXPECT_EQ(sizeof(char[4]), sizeof(AlignedCharArrayUnion<char[4]>));
177 EXPECT_EQ(sizeof(char[5]), sizeof(AlignedCharArrayUnion<char[5]>));
178 EXPECT_EQ(sizeof(char[8]), sizeof(AlignedCharArrayUnion<char[8]>));
179 EXPECT_EQ(sizeof(char[13]), sizeof(AlignedCharArrayUnion<char[13]>));
180 EXPECT_EQ(sizeof(char[16]), sizeof(AlignedCharArrayUnion<char[16]>));
181 EXPECT_EQ(sizeof(char[21]), sizeof(AlignedCharArrayUnion<char[21]>));
182 EXPECT_EQ(sizeof(char[32]), sizeof(AlignedCharArrayUnion<char[32]>));
183 EXPECT_EQ(sizeof(short), sizeof(AlignedCharArrayUnion<short>));
184 EXPECT_EQ(sizeof(int), sizeof(AlignedCharArrayUnion<int>));
185 EXPECT_EQ(sizeof(long), sizeof(AlignedCharArrayUnion<long>));
186 EXPECT_EQ(sizeof(long long),
188 EXPECT_EQ(sizeof(float), sizeof(AlignedCharArrayUnion<float>));
189 EXPECT_EQ(sizeof(double), sizeof(AlignedCharArrayUnion<double>));
190 EXPECT_EQ(sizeof(long double),
192 EXPECT_EQ(sizeof(void *), sizeof(AlignedCharArrayUnion<void *>));
193 EXPECT_EQ(sizeof(int *), sizeof(AlignedCharArrayUnion<int *>));
194 EXPECT_EQ(sizeof(double (*)(double)),
196 EXPECT_EQ(sizeof(double (S6::*)()),
198 EXPECT_EQ(sizeof(S1), sizeof(AlignedCharArrayUnion<S1>));
199 EXPECT_EQ(sizeof(S2), sizeof(AlignedCharArrayUnion<S2>));
200 EXPECT_EQ(sizeof(S3), sizeof(AlignedCharArrayUnion<S3>));
201 EXPECT_EQ(sizeof(S4), sizeof(AlignedCharArrayUnion<S4>));
202 EXPECT_EQ(sizeof(S5), sizeof(AlignedCharArrayUnion<S5>));
203 EXPECT_EQ(sizeof(S6), sizeof(AlignedCharArrayUnion<S6>));
204 EXPECT_EQ(sizeof(D1), sizeof(AlignedCharArrayUnion<D1>));
205 EXPECT_EQ(sizeof(D2), sizeof(AlignedCharArrayUnion<D2>));
206 EXPECT_EQ(sizeof(D3), sizeof(AlignedCharArrayUnion<D3>));
207 EXPECT_EQ(sizeof(D4), sizeof(AlignedCharArrayUnion<D4>));
208 EXPECT_EQ(sizeof(D5), sizeof(AlignedCharArrayUnion<D5>));
209 EXPECT_EQ(sizeof(D6), sizeof(AlignedCharArrayUnion<D6>));
210 EXPECT_EQ(sizeof(D7), sizeof(AlignedCharArrayUnion<D7>));
211 EXPECT_EQ(sizeof(D8), sizeof(AlignedCharArrayUnion<D8>));
212 EXPECT_EQ(sizeof(D9), sizeof(AlignedCharArrayUnion<D9>));
213 EXPECT_EQ(sizeof(D9[1]), sizeof(AlignedCharArrayUnion<D9[1]>));
214 EXPECT_EQ(sizeof(D9[2]), sizeof(AlignedCharArrayUnion<D9[2]>));
215 EXPECT_EQ(sizeof(D9[3]), sizeof(AlignedCharArrayUnion<D9[3]>));
216 EXPECT_EQ(sizeof(D9[4]), sizeof(AlignedCharArrayUnion<D9[4]>));
217 EXPECT_EQ(sizeof(D9[5]), sizeof(AlignedCharArrayUnion<D9[5]>));
218 EXPECT_EQ(sizeof(D9[8]), sizeof(AlignedCharArrayUnion<D9[8]>));
219 EXPECT_EQ(sizeof(D9[13]), sizeof(AlignedCharArrayUnion<D9[13]>));
220 EXPECT_EQ(sizeof(D9[16]), sizeof(AlignedCharArrayUnion<D9[16]>));
221 EXPECT_EQ(sizeof(D9[21]), sizeof(AlignedCharArrayUnion<D9[21]>));
222 EXPECT_EQ(sizeof(D9[32]), sizeof(AlignedCharArrayUnion<D9[32]>));
223 EXPECT_EQ(sizeof(V1), sizeof(AlignedCharArrayUnion<V1>));
224 EXPECT_EQ(sizeof(V2), sizeof(AlignedCharArrayUnion<V2>));
225 EXPECT_EQ(sizeof(V3), sizeof(AlignedCharArrayUnion<V3>));
226 EXPECT_EQ(sizeof(V4), sizeof(AlignedCharArrayUnion<V4>));
227 EXPECT_EQ(sizeof(V5), sizeof(AlignedCharArrayUnion<V5>));
228 EXPECT_EQ(sizeof(V6), sizeof(AlignedCharArrayUnion<V6>));
229 EXPECT_EQ(sizeof(V7), sizeof(AlignedCharArrayUnion<V7>));
234 EXPECT_EQ(sizeof(V8), sizeof(AlignedCharArrayUnion<V8>));
unittests/Support/AlignmentTest.cpp 25 EXPECT_EQ(Align::Of<uint8_t>(), Align(alignof(uint8_t)));
26 EXPECT_EQ(Align::Of<uint16_t>(), Align(alignof(uint16_t)));
27 EXPECT_EQ(Align::Of<uint32_t>(), Align(alignof(uint32_t)));
28 EXPECT_EQ(Align::Of<uint64_t>(), Align(alignof(uint64_t)));
32 EXPECT_EQ(Align::Constant<1>(), Align(1));
33 EXPECT_EQ(Align::Constant<2>(), Align(2));
34 EXPECT_EQ(Align::Constant<4>(), Align(4));
35 EXPECT_EQ(Align::Constant<8>(), Align(8));
36 EXPECT_EQ(Align::Constant<16>(), Align(16));
37 EXPECT_EQ(Align::Constant<32>(), Align(32));
38 EXPECT_EQ(Align::Constant<64>(), Align(64));
43 EXPECT_EQ(Align(alignof(uint64_t)), kConstantAlign);
54 EXPECT_EQ(Align().value(), 1ULL);
55 EXPECT_EQ(Align::None().value(), 1ULL);
64 EXPECT_EQ(Align(Value).value(), Value);
65 EXPECT_EQ((*MaybeAlign(Value)).value(), Value);
81 EXPECT_EQ(Align(Value) / 2, Value / 2);
82 EXPECT_EQ(MaybeAlign(Value) / 2, Value / 2);
85 EXPECT_EQ(MaybeAlign(0) / 2, MaybeAlign(0));
120 EXPECT_EQ(alignTo(T.offset, A), T.rounded);
123 EXPECT_EQ(alignTo(T.offset, A.getValue()), T.rounded);
124 EXPECT_EQ(alignAddr(T.forgedAddr(), A.getValue()), T.rounded);
131 EXPECT_EQ(Log2(Align(Value)), Log2_64(Value));
132 EXPECT_EQ(Log2(MaybeAlign(Value)), Log2_64(Value));
151 EXPECT_EQ(commonAlignment(MaybeAlign(T.A), MaybeAlign(T.B)), T.MinAlign);
152 EXPECT_EQ(MinAlign(T.A, T.B), T.MinAlign);
154 EXPECT_EQ(commonAlignment(Align(T.A), MaybeAlign(T.B)), T.MinAlign);
157 EXPECT_EQ(commonAlignment(MaybeAlign(T.A), Align(T.B)), T.MinAlign);
160 EXPECT_EQ(commonAlignment(Align(T.A), Align(T.B)), T.MinAlign);
170 EXPECT_EQ(Expected, Actual);
175 EXPECT_EQ(Expected, Actual);
180 EXPECT_EQ(Expected, Actual);
201 EXPECT_EQ(isAligned(A, T.offset), T.isAligned);
204 EXPECT_EQ(isAligned(A.getValue(), T.offset), T.isAligned);
205 EXPECT_EQ(isAddrAligned(A.getValue(), T.forgedAddr()), T.isAligned);
226 EXPECT_EQ(offsetToAlignment(T.offset, A), T.alignedOffset);
227 EXPECT_EQ(offsetToAlignedAddr(T.forgedAddr(), A), T.alignedOffset);
238 EXPECT_EQ(A, A);
247 EXPECT_EQ(A, A.value());
256 EXPECT_EQ(std::max(A, B), B);
257 EXPECT_EQ(std::min(A, B), A);
261 EXPECT_EQ(MA, MA);
270 EXPECT_EQ(MA, MA ? (*MA).value() : 0);
279 EXPECT_EQ(std::max(A, B), B);
280 EXPECT_EQ(std::min(A, B), A);
289 EXPECT_EQ(max(MaybeAlign(), Align(2)), Align(2));
290 EXPECT_EQ(max(Align(2), MaybeAlign()), Align(2));
292 EXPECT_EQ(max(MaybeAlign(1), Align(2)), Align(2));
293 EXPECT_EQ(max(Align(2), MaybeAlign(1)), Align(2));
295 EXPECT_EQ(max(MaybeAlign(2), Align(2)), Align(2));
296 EXPECT_EQ(max(Align(2), MaybeAlign(2)), Align(2));
298 EXPECT_EQ(max(MaybeAlign(4), Align(2)), Align(4));
299 EXPECT_EQ(max(Align(2), MaybeAlign(4)), Align(4));
302 EXPECT_EQ(max(Align(2), Align(4)), Align(4));
303 EXPECT_EQ(max(MaybeAlign(2), MaybeAlign(4)), MaybeAlign(4));
304 EXPECT_EQ(max(MaybeAlign(), MaybeAlign()), MaybeAlign());
308 EXPECT_EQ(assumeAligned(0), Align(1));
309 EXPECT_EQ(assumeAligned(0), Align());
310 EXPECT_EQ(assumeAligned(1), Align(1));
311 EXPECT_EQ(assumeAligned(1), Align());
unittests/Support/AllocatorTest.cpp 26 EXPECT_EQ(1, *a);
27 EXPECT_EQ(2, b[0]);
28 EXPECT_EQ(2, b[9]);
29 EXPECT_EQ(3, *c);
30 EXPECT_EQ(1U, Alloc.GetNumSlabs());
33 EXPECT_EQ(0U, Alloc.GetNumSlabs());
34 EXPECT_EQ(1U, Alloc2.GetNumSlabs());
38 EXPECT_EQ(1, *a);
39 EXPECT_EQ(2, b[0]);
40 EXPECT_EQ(2, b[9]);
41 EXPECT_EQ(3, *c);
44 EXPECT_EQ(0U, Alloc2.GetNumSlabs());
45 EXPECT_EQ(1U, Alloc.GetNumSlabs());
52 EXPECT_EQ(1U, Alloc.GetNumSlabs());
54 EXPECT_EQ(2U, Alloc.GetNumSlabs());
56 EXPECT_EQ(3U, Alloc.GetNumSlabs());
68 EXPECT_EQ(0u, Alloc.GetNumSlabs());
71 EXPECT_EQ(1U, Alloc.GetNumSlabs());
73 EXPECT_EQ(2U, Alloc.GetNumSlabs());
75 EXPECT_EQ(1U, Alloc.GetNumSlabs());
77 EXPECT_EQ(1U, Alloc.GetNumSlabs());
79 EXPECT_EQ(2U, Alloc.GetNumSlabs());
87 EXPECT_EQ(0U, a & 1);
89 EXPECT_EQ(0U, a & 3);
91 EXPECT_EQ(0U, a & 7);
93 EXPECT_EQ(0U, a & 15);
95 EXPECT_EQ(0U, a & 31);
97 EXPECT_EQ(0U, a & 63);
99 EXPECT_EQ(0U, a & 127);
109 EXPECT_EQ(1U, Alloc.GetNumSlabs());
113 EXPECT_EQ(2U, Alloc.GetNumSlabs());
121 EXPECT_EQ(1U, Alloc.GetNumSlabs());
134 EXPECT_EQ(2U, Alloc.GetNumSlabs());
unittests/Support/AnnotationsTest.cpp 24 EXPECT_EQ(llvm::Annotations("foo^bar$nnn[[baz$^[[qux]]]]").code(),
30 EXPECT_EQ(llvm::Annotations("^ab").point(), 0u);
31 EXPECT_EQ(llvm::Annotations("a^b").point(), 1u);
32 EXPECT_EQ(llvm::Annotations("ab^").point(), 2u);
47 EXPECT_EQ(llvm::Annotations("[[a]]bc").range(), range(0, 1));
48 EXPECT_EQ(llvm::Annotations("a[[bc]]d").range(), range(1, 3));
49 EXPECT_EQ(llvm::Annotations("ab[[cd]]").range(), range(2, 4));
52 EXPECT_EQ(llvm::Annotations("[[]]ab").range(), range(0, 0));
53 EXPECT_EQ(llvm::Annotations("a[[]]b").range(), range(1, 1));
54 EXPECT_EQ(llvm::Annotations("ab[[]]").range(), range(2, 2));
73 EXPECT_EQ(llvm::Annotations("a$foo^b").point("foo"), 1u);
74 EXPECT_EQ(llvm::Annotations("a$foo[[b]]cdef").range("foo"), range(1, 2));
77 EXPECT_EQ(llvm::Annotations("a$^b").point(""), 1u);
78 EXPECT_EQ(llvm::Annotations("a$[[b]]cdef").range(""), range(1, 2));
84 EXPECT_EQ(Annotated.point("p2"), 4u);
unittests/Support/ArrayRecyclerTest.cpp 34 EXPECT_EQ(PrevSize, Cap.getSize());
67 EXPECT_EQ(21, A1[0].Num);
68 EXPECT_EQ(17, A1[7].Num);
69 EXPECT_EQ(121, A2[0].Num);
70 EXPECT_EQ(117, A2[7].Num);
71 EXPECT_EQ(221, A3[0].Num);
72 EXPECT_EQ(217, A3[7].Num);
77 EXPECT_EQ(21, A1[0].Num);
78 EXPECT_EQ(17, A1[7].Num);
79 EXPECT_EQ(221, A3[0].Num);
80 EXPECT_EQ(217, A3[7].Num);
84 EXPECT_EQ(A2, A2x);
93 EXPECT_EQ(A3, A3x);
95 EXPECT_EQ(A1, A1x);
97 EXPECT_EQ(A2, A2y);
unittests/Support/BinaryStreamTest.cpp 206 EXPECT_EQ(makeArrayRef(InputData).slice(2, 1), Buffer);
208 EXPECT_EQ(makeArrayRef(InputData).slice(0, 4), Buffer);
226 EXPECT_EQ(makeArrayRef(InputData).slice(2, 1), Buffer);
231 EXPECT_EQ(makeArrayRef(InputData).slice(2), Buffer);
244 EXPECT_EQ(makeArrayRef(InputData).slice(3, 1), Buffer);
251 EXPECT_EQ(makeArrayRef(InputData).slice(3), Buffer);
263 EXPECT_EQ(makeArrayRef(InputData).take_back(), Buffer);
279 EXPECT_EQ(0U, ConstRef.getLength());
285 EXPECT_EQ(2U, ConstRef.getLength());
290 EXPECT_EQ(Str, Strings[0]);
296 EXPECT_EQ(1U, Dropped.getLength());
299 EXPECT_EQ(4U, ConstRef.getLength());
300 EXPECT_EQ(3U, Dropped.getLength());
306 EXPECT_EQ(6U, ConstRef.getLength());
307 EXPECT_EQ(5U, Dropped.getLength());
313 EXPECT_EQ(8U, ConstRef.getLength());
314 EXPECT_EQ(4U, Dropped.getLength());
328 EXPECT_EQ(RefData, Result);
333 EXPECT_EQ(RefData.drop_front(2), Result);
338 EXPECT_EQ(RefData.drop_back(2), Result);
343 EXPECT_EQ(RefData.take_front(2), Result);
348 EXPECT_EQ(RefData.take_back(2), Result);
353 EXPECT_EQ(RefData.drop_front(2).drop_back(2), Result);
386 EXPECT_EQ(makeArrayRef(InputData).drop_front(Offset), Data2);
397 EXPECT_EQ(0U, Stream.getLength());
406 EXPECT_EQ(Test, Stream.data());
411 EXPECT_EQ(MutableArrayRef<uint8_t>(InputData), Stream.data());
508 EXPECT_EQ(0U, Reader.bytesRemaining());
517 EXPECT_EQ(Bytes.size(), Reader.bytesRemaining());
558 EXPECT_EQ(Little, *Little2);
559 EXPECT_EQ(Big, *Big2);
560 EXPECT_EQ(NS, NS2);
561 EXPECT_EQ(NI, NI2);
562 EXPECT_EQ(NUL, NUL2);
578 EXPECT_EQ(makeArrayRef(Ints), IntsRef);
607 EXPECT_EQ(Enums[I], Value);
643 EXPECT_EQ(TestValues[I], Results[I]);
680 EXPECT_EQ(TestValues[I], Results[I]);
713 EXPECT_EQ(0U, Reader.bytesRemaining());
714 EXPECT_EQ(Foos[0], *FPtrOut);
715 EXPECT_EQ(Foos[1], *GPtrOut);
716 EXPECT_EQ(Foos[2], *HPtrOut);
739 EXPECT_EQ("One", S1);
740 EXPECT_EQ("Two", S2);
741 EXPECT_EQ("Three", S3);
742 EXPECT_EQ("Four", S4);
756 EXPECT_EQ("One", S1);
757 EXPECT_EQ("Two", S2);
758 EXPECT_EQ("Three", S3);
759 EXPECT_EQ("Four", S4);
770 EXPECT_EQ(5U, Writer.bytesRemaining());
772 EXPECT_EQ(0U, Writer.bytesRemaining());
806 EXPECT_EQ(makeArrayRef(SourceInts), Ints2);
830 EXPECT_EQ(makeArrayRef(Strings), makeArrayRef(InStrings));
847 EXPECT_EQ(Str, S);
901 EXPECT_EQ(F.X, F2->X);
unittests/Support/BlockFrequencyTest.cpp 23 EXPECT_EQ(Freq.getFrequency(), 0u);
27 EXPECT_EQ(Freq.getFrequency(), 0u);
34 EXPECT_EQ(Freq.getFrequency(), 1u);
38 EXPECT_EQ(Freq.getFrequency(), 1u);
45 EXPECT_EQ(Freq.getFrequency(), 1u);
49 EXPECT_EQ(Freq.getFrequency(), 1u);
56 EXPECT_EQ(Freq.getFrequency(), 9223372036854775807ULL);
60 EXPECT_EQ(Freq.getFrequency(), 9223372036854775807ULL);
69 EXPECT_EQ(Freq.getFrequency(), Big);
73 EXPECT_EQ(Freq.getFrequency(), Big);
80 EXPECT_EQ(Freq.getFrequency(), UINT64_MAX);
87 EXPECT_EQ(Freq.getFrequency(), UINT64_MAX);
92 EXPECT_EQ((Freq1 - Freq2).getFrequency(), 0u);
93 EXPECT_EQ((Freq2 - Freq1).getFrequency(), 1u);
99 EXPECT_EQ(Freq.getFrequency(), 0x6666666666666666ULL);
105 EXPECT_EQ(Freq.getFrequency(), 0x9999999866666668ULL);
107 EXPECT_EQ(Freq.getFrequency(), UINT64_MAX);
111 EXPECT_EQ(Freq.getFrequency(), UINT64_MAX);
116 EXPECT_EQ(33527736066704712ULL, Freq.getFrequency());
122 EXPECT_EQ(Freq.getFrequency(), 0x4020ULL);
124 EXPECT_EQ(Freq.getFrequency(), 0x1ULL);
unittests/Support/BranchProbabilityTest.cpp 24 EXPECT_EQ(306783378u, BP(1, 7).getNumerator());
25 EXPECT_EQ(1u << 31, BP(1, 7).getDenominator());
26 EXPECT_EQ(0u, BP::getZero().getNumerator());
27 EXPECT_EQ(1u << 31, BP::getZero().getDenominator());
28 EXPECT_EQ(1u << 31, BP::getOne().getNumerator());
29 EXPECT_EQ(1u << 31, BP::getOne().getDenominator());
124 EXPECT_EQ(Z + O, O);
125 EXPECT_EQ(H + Z, H);
126 EXPECT_EQ(H + H, O);
127 EXPECT_EQ(Q + H, Q3);
128 EXPECT_EQ(Q + Q3, O);
129 EXPECT_EQ(H + Q3, O);
130 EXPECT_EQ(Q3 + Q3, O);
132 EXPECT_EQ(Z - O, Z);
133 EXPECT_EQ(O - Z, O);
134 EXPECT_EQ(O - H, H);
135 EXPECT_EQ(O - Q, Q3);
136 EXPECT_EQ(Q3 - H, Q);
137 EXPECT_EQ(Q - H, Z);
138 EXPECT_EQ(Q - Q3, Z);
140 EXPECT_EQ(Z * O, Z);
141 EXPECT_EQ(H * H, Q);
142 EXPECT_EQ(Q * O, Q);
143 EXPECT_EQ(O * O, O);
144 EXPECT_EQ(Z * Z, Z);
146 EXPECT_EQ(Z * 3, Z);
147 EXPECT_EQ(Q * 3, Q3);
148 EXPECT_EQ(H * 3, O);
149 EXPECT_EQ(Q3 * 2, O);
150 EXPECT_EQ(O * UINT32_MAX, O);
152 EXPECT_EQ(Z / 4, Z);
153 EXPECT_EQ(O / 4, Q);
154 EXPECT_EQ(Q3 / 3, Q);
155 EXPECT_EQ(H / 2, Q);
156 EXPECT_EQ(O / 2, H);
157 EXPECT_EQ(H / UINT32_MAX, Z);
161 EXPECT_EQ(O / UINT32_MAX, Z);
162 EXPECT_EQ(Min * UINT32_MAX, O);
166 EXPECT_EQ(BP(5, 7), BP(2, 7).getCompl());
167 EXPECT_EQ(BP(2, 7), BP(5, 7).getCompl());
168 EXPECT_EQ(BP::getZero(), BP(7, 7).getCompl());
169 EXPECT_EQ(BP::getOne(), BP(0, 7).getCompl());
174 EXPECT_EQ(UINT64_MAX, BP(1, 1).scale(UINT64_MAX));
175 EXPECT_EQ(UINT64_MAX, BP(7, 7).scale(UINT64_MAX));
176 EXPECT_EQ(UINT32_MAX, BP(1, 1).scale(UINT32_MAX));
177 EXPECT_EQ(UINT32_MAX, BP(7, 7).scale(UINT32_MAX));
178 EXPECT_EQ(0u, BP(1, 1).scale(0));
179 EXPECT_EQ(0u, BP(7, 7).scale(0));
182 EXPECT_EQ(0u, BP(0, 1).scale(UINT64_MAX));
183 EXPECT_EQ(0u, BP(0, 1).scale(UINT64_MAX));
184 EXPECT_EQ(0u, BP(0, 1).scale(0));
190 EXPECT_EQ(Two63 - 1, BP(1, 2).scale(UINT64_MAX));
193 EXPECT_EQ(1u, BP(Two31, UINT32_MAX).scale(2));
194 EXPECT_EQ(Two31, BP(Two31, UINT32_MAX).scale(Two31 * 2));
195 EXPECT_EQ(9223372036854775807ULL, BP(Two31, UINT32_MAX).scale(UINT64_MAX));
198 EXPECT_EQ(UINT64_C(9223372045444710399),
204 EXPECT_EQ(UINT64_MAX, BP(1, 1).scaleByInverse(UINT64_MAX));
205 EXPECT_EQ(UINT64_MAX, BP(7, 7).scaleByInverse(UINT64_MAX));
206 EXPECT_EQ(UINT32_MAX, BP(1, 1).scaleByInverse(UINT32_MAX));
207 EXPECT_EQ(UINT32_MAX, BP(7, 7).scaleByInverse(UINT32_MAX));
208 EXPECT_EQ(0u, BP(1, 1).scaleByInverse(0));
209 EXPECT_EQ(0u, BP(7, 7).scaleByInverse(0));
214 EXPECT_EQ(UINT64_MAX, BP(1, UINT32_MAX).scaleByInverse(UINT64_MAX));
215 EXPECT_EQ(uint64_t(UINT32_MAX) * MAX_DENOMINATOR,
217 EXPECT_EQ(MAX_DENOMINATOR, BP(1, MAX_DENOMINATOR).scaleByInverse(1));
223 EXPECT_EQ(UINT64_MAX - 1, BP(1, 2).scaleByInverse(Two63 - 1));
224 EXPECT_EQ(UINT64_MAX, BP(1, 2).scaleByInverse(Two63));
227 EXPECT_EQ(2u, BP(Two31, UINT32_MAX).scaleByInverse(1));
228 EXPECT_EQ(2u, BP(Two31 - 1, UINT32_MAX).scaleByInverse(1));
229 EXPECT_EQ(Two31 * 2, BP(Two31, UINT32_MAX).scaleByInverse(Two31));
230 EXPECT_EQ(Two31 * 2, BP(Two31 - 1, UINT32_MAX).scaleByInverse(Two31));
231 EXPECT_EQ(UINT64_MAX, BP(Two31, UINT32_MAX).scaleByInverse(Two63 + Two31));
235 EXPECT_EQ(UINT64_C(18446744060824649767),
238 EXPECT_EQ(UINT64_C(18446744060824649739),
333 EXPECT_EQ(T.Result, BP(T.Prob[0], T.Prob[1]).scale(T.Num));
342 EXPECT_EQ(BranchProbability::getDenominator() / 2, Probs[0].getNumerator());
343 EXPECT_EQ(BranchProbability::getDenominator() / 2, Probs[1].getNumerator());
348 EXPECT_EQ(0u, Probs[0].getNumerator());
349 EXPECT_EQ(BranchProbability::getDenominator(), Probs[1].getNumerator());
354 EXPECT_EQ(BranchProbability::getDenominator() / 2, Probs[0].getNumerator());
355 EXPECT_EQ(BranchProbability::getDenominator() / 2, Probs[1].getNumerator());
360 EXPECT_EQ(BranchProbability::getDenominator() / 2, Probs[0].getNumerator());
361 EXPECT_EQ(BranchProbability::getDenominator() / 2, Probs[1].getNumerator());
366 EXPECT_EQ(BranchProbability::getDenominator() / 3 + 1,
368 EXPECT_EQ(BranchProbability::getDenominator() / 3 + 1,
370 EXPECT_EQ(BranchProbability::getDenominator() / 3 + 1,
376 EXPECT_EQ(0U, Probs[0].getNumerator());
377 EXPECT_EQ(BranchProbability::getDenominator(), Probs[1].getNumerator());
382 EXPECT_EQ(BranchProbability::getDenominator(), Probs[0].getNumerator());
383 EXPECT_EQ(0U, Probs[1].getNumerator());
388 EXPECT_EQ(BranchProbability::getDenominator() / 2, Probs[0].getNumerator());
389 EXPECT_EQ(BranchProbability::getDenominator() / 2, Probs[1].getNumerator());
395 EXPECT_EQ(BranchProbability::getDenominator() / 3 + 1,
397 EXPECT_EQ(BranchProbability::getDenominator() / 3 + 1,
399 EXPECT_EQ(BranchProbability::getDenominator() / 3 + 1,
401 EXPECT_EQ(0U, Probs[3].getNumerator());
unittests/Support/CRCTest.cpp 22 EXPECT_EQ(0x414FA339U, llvm::crc32(arrayRefFromStringRef(
27 EXPECT_EQ(0xCBF43926U, llvm::crc32(arrayRefFromStringRef("123456789")));
40 EXPECT_EQ(crc, ~llvm::crc32(0xFFFFFFFFU, byte));
unittests/Support/CachePruningTest.cpp 18 EXPECT_EQ(std::chrono::seconds(1200), P->Interval);
19 EXPECT_EQ(std::chrono::hours(7 * 24), P->Expiration);
20 EXPECT_EQ(75u, P->MaxSizePercentageOfAvailableSpace);
26 EXPECT_EQ(std::chrono::seconds(1), P->Interval);
29 EXPECT_EQ(std::chrono::minutes(2), *P->Interval);
32 EXPECT_EQ(std::chrono::hours(3), *P->Interval);
38 EXPECT_EQ(std::chrono::seconds(1), P->Expiration);
44 EXPECT_EQ(100u, P->MaxSizePercentageOfAvailableSpace);
45 EXPECT_EQ(0u, P->MaxSizeBytes);
51 EXPECT_EQ(75u, P->MaxSizePercentageOfAvailableSpace);
52 EXPECT_EQ(1u, P->MaxSizeBytes);
55 EXPECT_EQ(75u, P->MaxSizePercentageOfAvailableSpace);
56 EXPECT_EQ(2u * 1024u, P->MaxSizeBytes);
59 EXPECT_EQ(75u, P->MaxSizePercentageOfAvailableSpace);
60 EXPECT_EQ(3u * 1024u * 1024u, P->MaxSizeBytes);
63 EXPECT_EQ(75u, P->MaxSizePercentageOfAvailableSpace);
64 EXPECT_EQ(4ull * 1024ull * 1024ull * 1024ull, P->MaxSizeBytes);
70 EXPECT_EQ(std::chrono::seconds(1200), P->Interval);
71 EXPECT_EQ(std::chrono::seconds(1), P->Expiration);
72 EXPECT_EQ(50u, P->MaxSizePercentageOfAvailableSpace);
76 EXPECT_EQ("Duration must not be empty",
78 EXPECT_EQ("'foo' not an integer",
80 EXPECT_EQ("'24x' must end with one of 's', 'm' or 'h'",
82 EXPECT_EQ("'foo' must be a percentage",
84 EXPECT_EQ("'foo' not an integer",
86 EXPECT_EQ("'101' must be between 0 and 100",
88 EXPECT_EQ(
91 EXPECT_EQ(
94 EXPECT_EQ("Unknown key: 'foo'",
unittests/Support/Casting.cpp 160 EXPECT_EQ(F14, null_foo);
166 EXPECT_EQ(FP.get(), null_foo);
191 EXPECT_EQ(F4, null_foo);
245 EXPECT_EQ(nullptr, F2);
unittests/Support/CheckedArithmeticTest.cpp 11 EXPECT_EQ(checkedAdd<int64_t>(Max, Max), None);
12 EXPECT_EQ(checkedAdd<int64_t>(Min, -1), None);
13 EXPECT_EQ(checkedAdd<int64_t>(Max, 1), None);
14 EXPECT_EQ(checkedAdd<int64_t>(10, 1), Optional<int64_t>(11));
20 EXPECT_EQ(checkedAdd<int16_t>(Max, Max), None);
21 EXPECT_EQ(checkedAdd<int16_t>(Min, -1), None);
22 EXPECT_EQ(checkedAdd<int16_t>(Max, 1), None);
23 EXPECT_EQ(checkedAdd<int16_t>(10, 1), Optional<int64_t>(11));
29 EXPECT_EQ(checkedMul<int64_t>(Max, 2), None);
30 EXPECT_EQ(checkedMul<int64_t>(Max, Max), None);
31 EXPECT_EQ(checkedMul<int64_t>(Min, 2), None);
32 EXPECT_EQ(checkedMul<int64_t>(10, 2), Optional<int64_t>(20));
38 EXPECT_EQ(checkedMulAdd<int64_t>(Max, 1, 2), None);
39 EXPECT_EQ(checkedMulAdd<int64_t>(1, 1, Max), None);
40 EXPECT_EQ(checkedMulAdd<int64_t>(1, -1, Min), None);
41 EXPECT_EQ(checkedMulAdd<int64_t>(10, 2, 3), Optional<int64_t>(23));
47 EXPECT_EQ(checkedMul<int16_t>(Max, 2), None);
48 EXPECT_EQ(checkedMul<int16_t>(Max, Max), None);
49 EXPECT_EQ(checkedMul<int16_t>(Min, 2), None);
50 EXPECT_EQ(checkedMul<int16_t>(10, 2), Optional<int16_t>(20));
56 EXPECT_EQ(checkedMulAdd<int16_t>(Max, 1, 2), None);
57 EXPECT_EQ(checkedMulAdd<int16_t>(1, 1, Max), None);
58 EXPECT_EQ(checkedMulAdd<int16_t>(1, -1, Min), None);
59 EXPECT_EQ(checkedMulAdd<int16_t>(10, 2, 3), Optional<int16_t>(23));
64 EXPECT_EQ(checkedAddUnsigned<uint64_t>(Max, Max), None);
65 EXPECT_EQ(checkedAddUnsigned<uint64_t>(Max, 1), None);
66 EXPECT_EQ(checkedAddUnsigned<uint64_t>(10, 1), Optional<uint64_t>(11));
71 EXPECT_EQ(checkedMulUnsigned<uint64_t>(Max, 2), llvm::None);
72 EXPECT_EQ(checkedMulUnsigned<uint64_t>(Max, Max), llvm::None);
73 EXPECT_EQ(checkedMulUnsigned<uint64_t>(10, 2), Optional<uint64_t>(20));
78 EXPECT_EQ(checkedMulAddUnsigned<uint64_t>(Max, 1, 2), None);
79 EXPECT_EQ(checkedMulAddUnsigned<uint64_t>(1, 1, Max), None);
80 EXPECT_EQ(checkedMulAddUnsigned<uint64_t>(10, 2, 3), Optional<uint64_t>(23));
unittests/Support/Chrono.cpp 21 EXPECT_EQ(time_t(0), toTimeT(toTimePoint(time_t(0))));
22 EXPECT_EQ(time_t(1), toTimeT(toTimePoint(time_t(1))));
23 EXPECT_EQ(time_t(47), toTimeT(toTimePoint(time_t(47))));
26 EXPECT_EQ(TP, toTimePoint(toTimeT(TP)));
28 EXPECT_EQ(TP, toTimePoint(toTimeT(TP)));
30 EXPECT_EQ(TP, toTimePoint(toTimeT(TP)));
50 EXPECT_EQ("2006-01-02 15:04:05.123456789", OS.str());
53 EXPECT_EQ("2006-01-02 15:04:05.123456789", formatv("{0}", T).str());
55 EXPECT_EQ("15:04:05", formatv("{0:%H:%M:%S}", T).str());
57 EXPECT_EQ("123", formatv("{0:%L}", T).str());
58 EXPECT_EQ("123456", formatv("{0:%f}", T).str());
59 EXPECT_EQ("123456789", formatv("{0:%N}", T).str());
61 EXPECT_EQ("%foo", formatv("{0:%%foo}", T).str());
72 EXPECT_EQ(Sec, Milli);
73 EXPECT_EQ(Sec, Micro);
74 EXPECT_EQ(Sec, Nano);
75 EXPECT_EQ(TimeT, toTimeT(Sec));
76 EXPECT_EQ(TimeT, toTimeT(Milli));
77 EXPECT_EQ(TimeT, toTimeT(Micro));
78 EXPECT_EQ(TimeT, toTimeT(Nano));
82 EXPECT_EQ("1 h", formatv("{0}", hours(1)).str());
83 EXPECT_EQ("1 m", formatv("{0}", minutes(1)).str());
84 EXPECT_EQ("1 s", formatv("{0}", seconds(1)).str());
85 EXPECT_EQ("1 ms", formatv("{0}", milliseconds(1)).str());
86 EXPECT_EQ("1 us", formatv("{0}", microseconds(1)).str());
87 EXPECT_EQ("1 ns", formatv("{0}", nanoseconds(1)).str());
89 EXPECT_EQ("1 s", formatv("{0:+}", seconds(1)).str());
90 EXPECT_EQ("1", formatv("{0:-}", seconds(1)).str());
92 EXPECT_EQ("1000 ms", formatv("{0:ms}", seconds(1)).str());
93 EXPECT_EQ("1000000 us", formatv("{0:us}", seconds(1)).str());
94 EXPECT_EQ("1000", formatv("{0:ms-}", seconds(1)).str());
96 EXPECT_EQ("1,000 ms", formatv("{0:+n}", milliseconds(1000)).str());
97 EXPECT_EQ("0x3e8", formatv("{0:-x}", milliseconds(1000)).str());
98 EXPECT_EQ("010", formatv("{0:-3}", milliseconds(10)).str());
99 EXPECT_EQ("10,000", formatv("{0:ms-n}", seconds(10)).str());
101 EXPECT_EQ("1.00 s", formatv("{0}", duration<float>(1)).str());
102 EXPECT_EQ("0.123 s", formatv("{0:+3}", duration<float>(0.123f)).str());
103 EXPECT_EQ("1.230e-01 s", formatv("{0:+e3}", duration<float>(0.123f)).str());
107 EXPECT_EQ("1.00", formatv("{0:-}", microfortnights(1)).str());
108 EXPECT_EQ("1209.60 ms", formatv("{0:ms}", microfortnights(1)).str());
unittests/Support/CommandLineTest.cpp 34 EXPECT_EQ(nullptr, old_value) << old_value;
136 EXPECT_EQ("", EnvironmentTestOption);
138 EXPECT_EQ("hello", EnvironmentTestOption);
153 EXPECT_EQ("", EnvironmentTestOptionLocal);
155 EXPECT_EQ("hello-local", EnvironmentTestOptionLocal);
225 EXPECT_EQ(OutputSize, Actual.size());
356 EXPECT_EQ("x", Actual);
357 EXPECT_EQ(0, Input.getNumOccurrences());
368 EXPECT_EQ("x", Option);
369 EXPECT_EQ(1, Option.getNumOccurrences());
663 EXPECT_EQ("sc1", S->getName());
674 EXPECT_EQ("sc2", S->getName());
719 EXPECT_EQ("sc1", S->getName());
735 EXPECT_EQ("sc2", S->getName());
835 EXPECT_EQ(Argv.size(), 13U);
911 EXPECT_EQ(Argv.size(), 9U);
1039 EXPECT_EQ(Argv.size(), 4U);
1177 EXPECT_EQ(Output, (" --" + Opt + "=<value> - " + HelpText + "\n"
1189 EXPECT_EQ(Output,
1203 EXPECT_EQ(Output, (" --" + Opt + " - " + HelpText + "\n"
1217 EXPECT_EQ(Output, (" --" + Opt + "=<value> - " + HelpText + "\n"
1229 EXPECT_EQ(Output,
1256 EXPECT_EQ(
1264 EXPECT_EQ(
1273 EXPECT_EQ(
1284 EXPECT_EQ(runTest("a", cl::values(clEnumValN(OptionValue::Val, "b", "help"),
1298 EXPECT_EQ(runTest(ArgName, cl::ValueOptional,
1310 EXPECT_EQ(runTest("a", cl::ValueRequired,
1444 EXPECT_EQ(1, OptO.getNumOccurrences());
1445 EXPECT_EQ(1, OptB.getNumOccurrences());
unittests/Support/ConvertUTFTest.cpp 25 EXPECT_EQ(Expected, Result);
36 EXPECT_EQ(Expected, Result);
49 EXPECT_EQ(Expected[I], Result[I]);
89 EXPECT_EQ(Expected, Result);
99 EXPECT_EQ(Expected, Result);
103 EXPECT_EQ(Expected, Result);
113 EXPECT_EQ(Expected, Result);
unittests/Support/CrashRecoveryTest.cpp 31 EXPECT_EQ(1, GlobalInt);
52 EXPECT_EQ(1, GlobalInt);
60 EXPECT_EQ(1, GlobalInt);
unittests/Support/DJBTest.cpp 54 EXPECT_EQ(caseFoldingDjbHash(T.One), caseFoldingDjbHash(T.Two));
76 EXPECT_EQ(T.Hash, djbHash(T.Text));
77 EXPECT_EQ(T.Hash, caseFoldingDjbHash(T.Text));
78 EXPECT_EQ(T.Hash, caseFoldingDjbHash(T.Text.upper()));
83 EXPECT_EQ(5866553u, djbHash(u8"\u0130"));
84 EXPECT_EQ(177678u, caseFoldingDjbHash(u8"\u0130"));
85 EXPECT_EQ(
90 EXPECT_EQ(
unittests/Support/DataExtractorTest.cpp 30 EXPECT_EQ(0x80U, DE.getU8(&offset));
31 EXPECT_EQ(1U, offset);
33 EXPECT_EQ(0x8090U, DE.getU16(&offset));
34 EXPECT_EQ(2U, offset);
36 EXPECT_EQ(0x8090FFFFU, DE.getU32(&offset));
37 EXPECT_EQ(4U, offset);
39 EXPECT_EQ(0x8090FFFF80000000ULL, DE.getU64(&offset));
40 EXPECT_EQ(8U, offset);
42 EXPECT_EQ(0x8090FFFF80000000ULL, DE.getAddress(&offset));
43 EXPECT_EQ(8U, offset);
47 EXPECT_EQ(data, DE.getU32(&offset, data, 2));
48 EXPECT_EQ(0x8090FFFFU, data[0]);
49 EXPECT_EQ(0x80000000U, data[1]);
50 EXPECT_EQ(8U, offset);
55 EXPECT_EQ(0x9080U, DE.getU16(&offset));
56 EXPECT_EQ(2U, offset);
58 EXPECT_EQ(0xFFFF9080U, DE.getU32(&offset));
59 EXPECT_EQ(4U, offset);
61 EXPECT_EQ(0x80FFFF9080ULL, DE.getU64(&offset));
62 EXPECT_EQ(8U, offset);
64 EXPECT_EQ(0xFFFF9080U, DE.getAddress(&offset));
65 EXPECT_EQ(4U, offset);
68 EXPECT_EQ(data, DE.getU32(&offset, data, 2));
69 EXPECT_EQ(0xFFFF9080U, data[0]);
70 EXPECT_EQ(0x80U, data[1]);
71 EXPECT_EQ(8U, offset);
78 EXPECT_EQ(-128, DE.getSigned(&offset, 1));
79 EXPECT_EQ(1U, offset);
81 EXPECT_EQ(-32624, DE.getSigned(&offset, 2));
82 EXPECT_EQ(2U, offset);
84 EXPECT_EQ(-2137980929, DE.getSigned(&offset, 4));
85 EXPECT_EQ(4U, offset);
87 EXPECT_EQ(-9182558167379214336LL, DE.getSigned(&offset, 8));
88 EXPECT_EQ(8U, offset);
95 EXPECT_EQ(stringData, DE.getCStr(&offset));
96 EXPECT_EQ(11U, offset);
97 EXPECT_EQ(nullptr, DE.getCStr(&offset));
98 EXPECT_EQ(11U, offset);
105 EXPECT_EQ(9382ULL, DE.getULEB128(&offset));
106 EXPECT_EQ(2U, offset);
108 EXPECT_EQ(-7002LL, DE.getSLEB128(&offset));
109 EXPECT_EQ(2U, offset);
113 EXPECT_EQ(42218325750568106ULL, BDE.getULEB128(&offset));
114 EXPECT_EQ(8U, offset);
116 EXPECT_EQ(-29839268287359830LL, BDE.getSLEB128(&offset));
117 EXPECT_EQ(8U, offset);
123 EXPECT_EQ(0U, DE.getULEB128(&Offset));
124 EXPECT_EQ(0U, Offset);
127 EXPECT_EQ(0U, DE.getSLEB128(&Offset));
128 EXPECT_EQ(0U, Offset);
135 EXPECT_EQ('A', DE.getU8(C));
136 EXPECT_EQ(1u, C.tell());
139 EXPECT_EQ(0u, DE.getU16(C));
140 EXPECT_EQ(1u, C.tell());
143 EXPECT_EQ(0, DE.getU8(C));
144 EXPECT_EQ(1u, C.tell());
156 EXPECT_EQ('A', DE.getU8(C));
160 EXPECT_EQ(0u, DE.getU32(C));
164 EXPECT_EQ(0u, DE.getU32(C));
165 EXPECT_EQ(0, DE.getU8(C));
169 EXPECT_EQ('B', DE.getU8(C));
178 EXPECT_EQ('A', DE.getU8(C));
179 EXPECT_EQ('B', DE.getU8(C));
180 EXPECT_EQ('C', DE.getU8(C));
181 EXPECT_EQ('D', DE.getU8(C));
196 EXPECT_EQ(0u, DE.getU32(*C));
204 EXPECT_EQ('A', DE.getU8(*C));
213 EXPECT_EQ('A', DE.getU8(*C));
214 EXPECT_EQ(0u, DE.getU32(*C));
221 EXPECT_EQ(0u, DE.getU32(*C));
222 EXPECT_EQ(0, DE.getU8(*C));
238 EXPECT_EQ("", toStringRef(S));
242 EXPECT_EQ("AB", toStringRef(S));
251 EXPECT_EQ(0u, C.tell());
255 EXPECT_EQ(2u, C.tell());
264 EXPECT_EQ(0, DE.getU16(C));
268 EXPECT_EQ('A', DE.getU8(C));
unittests/Support/DebugCounterTest.cpp 27 EXPECT_EQ(0, DebugCounter::getCounterValue(TestCounter));
30 EXPECT_EQ(1, DebugCounter::getCounterValue(TestCounter));
unittests/Support/DebugTest.cpp 26 EXPECT_EQ("AB", os1.str());
31 EXPECT_EQ("A", os2.str());
unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp 71 EXPECT_EQ(StdString(GS()), "LibCall");
75 EXPECT_EQ(StdString(GS()), "LibCall");
84 EXPECT_EQ(StdString(GS()), "ProcessCall");
88 EXPECT_EQ(StdString(GS()), "ProcessCall");
94 EXPECT_EQ(StdString(GS()), "LibCall");
102 EXPECT_EQ(StdString(GS()), "OverloadCall");
127 EXPECT_EQ(B, "Local::Local(PipSqueak)");
151 EXPECT_EQ(B, "Local::Local(SecondLib)");
156 EXPECT_EQ(A, "Global::~Global");
157 EXPECT_EQ(B, "Local::~Local");
162 EXPECT_EQ(Order.size(), 2UL);
163 EXPECT_EQ(Order.front(), "SecondLib");
164 EXPECT_EQ(Order.back(), "PipSqueak");
unittests/Support/EndianStreamTest.cpp 27 EXPECT_EQ(static_cast<uint8_t>(data[0]), 0xCD);
28 EXPECT_EQ(static_cast<uint8_t>(data[1]), 0xB6);
29 EXPECT_EQ(static_cast<uint8_t>(data[2]), 0xCA);
30 EXPECT_EQ(static_cast<uint8_t>(data[3]), 0xAE);
42 EXPECT_EQ(static_cast<uint8_t>(data[0]), 0xAE);
43 EXPECT_EQ(static_cast<uint8_t>(data[1]), 0xCA);
44 EXPECT_EQ(static_cast<uint8_t>(data[2]), 0xB6);
45 EXPECT_EQ(static_cast<uint8_t>(data[3]), 0xCD);
58 EXPECT_EQ(static_cast<uint8_t>(data[0]), 0x00);
59 EXPECT_EQ(static_cast<uint8_t>(data[1]), 0xE4);
60 EXPECT_EQ(static_cast<uint8_t>(data[2]), 0x40);
61 EXPECT_EQ(static_cast<uint8_t>(data[3]), 0x46);
73 EXPECT_EQ(static_cast<uint8_t>(data[0]), 0x46);
74 EXPECT_EQ(static_cast<uint8_t>(data[1]), 0x40);
75 EXPECT_EQ(static_cast<uint8_t>(data[2]), 0xE4);
76 EXPECT_EQ(static_cast<uint8_t>(data[3]), 0x00);
88 EXPECT_EQ(static_cast<uint8_t>(data[0]), 0xCD);
89 EXPECT_EQ(static_cast<uint8_t>(data[1]), 0xAB);
90 EXPECT_EQ(static_cast<uint8_t>(data[2]), 0xED);
91 EXPECT_EQ(static_cast<uint8_t>(data[3]), 0x1B);
92 EXPECT_EQ(static_cast<uint8_t>(data[4]), 0x33);
93 EXPECT_EQ(static_cast<uint8_t>(data[5]), 0xF6);
94 EXPECT_EQ(static_cast<uint8_t>(data[6]), 0x1B);
95 EXPECT_EQ(static_cast<uint8_t>(data[7]), 0xFE);
107 EXPECT_EQ(static_cast<uint8_t>(data[0]), 0xFE);
108 EXPECT_EQ(static_cast<uint8_t>(data[1]), 0x1B);
109 EXPECT_EQ(static_cast<uint8_t>(data[2]), 0xF6);
110 EXPECT_EQ(static_cast<uint8_t>(data[3]), 0x33);
111 EXPECT_EQ(static_cast<uint8_t>(data[4]), 0x1B);
112 EXPECT_EQ(static_cast<uint8_t>(data[5]), 0xED);
113 EXPECT_EQ(static_cast<uint8_t>(data[6]), 0xAB);
114 EXPECT_EQ(static_cast<uint8_t>(data[7]), 0xCD);
126 EXPECT_EQ(static_cast<uint8_t>(data[0]), 0x20);
127 EXPECT_EQ(static_cast<uint8_t>(data[1]), 0x98);
128 EXPECT_EQ(static_cast<uint8_t>(data[2]), 0xD2);
129 EXPECT_EQ(static_cast<uint8_t>(data[3]), 0x98);
130 EXPECT_EQ(static_cast<uint8_t>(data[4]), 0xC5);
131 EXPECT_EQ(static_cast<uint8_t>(data[5]), 0x80);
132 EXPECT_EQ(static_cast<uint8_t>(data[6]), 0xE1);
133 EXPECT_EQ(static_cast<uint8_t>(data[7]), 0xC1);
145 EXPECT_EQ(static_cast<uint8_t>(data[0]), 0xC1);
146 EXPECT_EQ(static_cast<uint8_t>(data[1]), 0xE1);
147 EXPECT_EQ(static_cast<uint8_t>(data[2]), 0x80);
148 EXPECT_EQ(static_cast<uint8_t>(data[3]), 0xC5);
149 EXPECT_EQ(static_cast<uint8_t>(data[4]), 0x98);
150 EXPECT_EQ(static_cast<uint8_t>(data[5]), 0xD2);
151 EXPECT_EQ(static_cast<uint8_t>(data[6]), 0x98);
152 EXPECT_EQ(static_cast<uint8_t>(data[7]), 0x20);
164 EXPECT_EQ(static_cast<uint8_t>(Data[0]), 0x34);
165 EXPECT_EQ(static_cast<uint8_t>(Data[1]), 0x12);
166 EXPECT_EQ(static_cast<uint8_t>(Data[2]), 0x78);
167 EXPECT_EQ(static_cast<uint8_t>(Data[3]), 0x56);
180 EXPECT_EQ(static_cast<uint8_t>(Data[0]), 0x34);
181 EXPECT_EQ(static_cast<uint8_t>(Data[1]), 0x12);
182 EXPECT_EQ(static_cast<uint8_t>(Data[2]), 0x78);
183 EXPECT_EQ(static_cast<uint8_t>(Data[3]), 0x56);
195 EXPECT_EQ(static_cast<uint8_t>(Data[0]), 0x00);
196 EXPECT_EQ(static_cast<uint8_t>(Data[1]), 0xE4);
197 EXPECT_EQ(static_cast<uint8_t>(Data[2]), 0x40);
198 EXPECT_EQ(static_cast<uint8_t>(Data[3]), 0x46);
200 EXPECT_EQ(static_cast<uint8_t>(Data[4]), 0x00);
201 EXPECT_EQ(static_cast<uint8_t>(Data[5]), 0xE8);
202 EXPECT_EQ(static_cast<uint8_t>(Data[6]), 0x40);
203 EXPECT_EQ(static_cast<uint8_t>(Data[7]), 0x46);
unittests/Support/EndianTest.cpp 26 EXPECT_EQ(BigAsHost, (endian::read<int32_t, big, unaligned>(bigval)));
28 EXPECT_EQ(LittleAsHost,(endian::read<int32_t, little, unaligned>(littleval)));
30 EXPECT_EQ((endian::read<int32_t, big, unaligned>(bigval + 1)),
38 EXPECT_EQ(
41 EXPECT_EQ((endian::readAtBitAlignment<int, big, unaligned>(&bigval[0], 6)),
47 EXPECT_EQ(
50 EXPECT_EQ((endian::readAtBitAlignment<int, big, unaligned>(&bigval2[0], 4)),
53 EXPECT_EQ(
56 EXPECT_EQ((endian::readAtBitAlignment<int, big, unaligned>(&bigval2[0], 1)),
63 EXPECT_EQ((endian::readAtBitAlignment<int64_t, little, unaligned>(
66 EXPECT_EQ(
77 EXPECT_EQ(bigval[0], 0xff);
78 EXPECT_EQ(bigval[1], 0xfa);
79 EXPECT_EQ(bigval[2], 0xaa);
80 EXPECT_EQ(bigval[3], 0xa0);
81 EXPECT_EQ(bigval[4], 0x00);
82 EXPECT_EQ(bigval[5], 0x00);
83 EXPECT_EQ(bigval[6], 0x00);
84 EXPECT_EQ(bigval[7], 0x0f);
89 EXPECT_EQ(littleval[0], 0xa0);
90 EXPECT_EQ(littleval[1], 0xaa);
91 EXPECT_EQ(littleval[2], 0xfa);
92 EXPECT_EQ(littleval[3], 0xff);
93 EXPECT_EQ(littleval[4], 0x0f);
94 EXPECT_EQ(littleval[5], 0x00);
95 EXPECT_EQ(littleval[6], 0x00);
96 EXPECT_EQ(littleval[7], 0x00);
103 EXPECT_EQ(bigval2[0], 0xff);
104 EXPECT_EQ(bigval2[1], 0xff);
105 EXPECT_EQ(bigval2[2], 0xff);
106 EXPECT_EQ(bigval2[3], 0xfe);
107 EXPECT_EQ(bigval2[4], 0x00);
108 EXPECT_EQ(bigval2[5], 0x00);
109 EXPECT_EQ(bigval2[6], 0x00);
110 EXPECT_EQ(bigval2[7], 0x01);
115 EXPECT_EQ(littleval2[0], 0xfe);
116 EXPECT_EQ(littleval2[1], 0xff);
117 EXPECT_EQ(littleval2[2], 0xff);
118 EXPECT_EQ(littleval2[3], 0xff);
119 EXPECT_EQ(littleval2[4], 0x01);
120 EXPECT_EQ(littleval2[5], 0x00);
121 EXPECT_EQ(littleval2[6], 0x00);
122 EXPECT_EQ(littleval2[7], 0x00);
128 EXPECT_EQ(bigval64[0], 0xff);
129 EXPECT_EQ(bigval64[1], 0xff);
130 EXPECT_EQ(bigval64[2], 0xff);
131 EXPECT_EQ(bigval64[3], 0xff);
132 EXPECT_EQ(bigval64[4], 0xff);
133 EXPECT_EQ(bigval64[5], 0xff);
134 EXPECT_EQ(bigval64[6], 0xff);
135 EXPECT_EQ(bigval64[7], 0xfe);
136 EXPECT_EQ(bigval64[8], 0x00);
137 EXPECT_EQ(bigval64[9], 0x00);
138 EXPECT_EQ(bigval64[10], 0x00);
139 EXPECT_EQ(bigval64[11], 0x00);
140 EXPECT_EQ(bigval64[12], 0x00);
141 EXPECT_EQ(bigval64[13], 0x00);
142 EXPECT_EQ(bigval64[14], 0x00);
143 EXPECT_EQ(bigval64[15], 0x01);
148 EXPECT_EQ(littleval64[0], 0xfe);
149 EXPECT_EQ(littleval64[1], 0xff);
150 EXPECT_EQ(littleval64[2], 0xff);
151 EXPECT_EQ(littleval64[3], 0xff);
152 EXPECT_EQ(littleval64[4], 0xff);
153 EXPECT_EQ(littleval64[5], 0xff);
154 EXPECT_EQ(littleval64[6], 0xff);
155 EXPECT_EQ(littleval64[7], 0xff);
156 EXPECT_EQ(littleval64[8], 0x01);
157 EXPECT_EQ(littleval64[9], 0x00);
158 EXPECT_EQ(littleval64[10], 0x00);
159 EXPECT_EQ(littleval64[11], 0x00);
160 EXPECT_EQ(littleval64[12], 0x00);
161 EXPECT_EQ(littleval64[13], 0x00);
162 EXPECT_EQ(littleval64[14], 0x00);
163 EXPECT_EQ(littleval64[15], 0x00);
169 EXPECT_EQ(data[0], 0xAE);
170 EXPECT_EQ(data[1], 0xCA);
171 EXPECT_EQ(data[2], 0xB6);
172 EXPECT_EQ(data[3], 0xCD);
174 EXPECT_EQ(data[1], 0xAE);
175 EXPECT_EQ(data[2], 0xCA);
176 EXPECT_EQ(data[3], 0xB6);
177 EXPECT_EQ(data[4], 0xCD);
180 EXPECT_EQ(data[0], 0xCD);
181 EXPECT_EQ(data[1], 0xB6);
182 EXPECT_EQ(data[2], 0xCA);
183 EXPECT_EQ(data[3], 0xAE);
185 EXPECT_EQ(data[1], 0xCD);
186 EXPECT_EQ(data[2], 0xB6);
187 EXPECT_EQ(data[3], 0xCA);
188 EXPECT_EQ(data[4], 0xAE);
200 EXPECT_EQ(*big_val, *little_val);
208 EXPECT_EQ(Test::TWOONE, *reinterpret_cast<LittleTest *>(bytes));
209 EXPECT_EQ(Test::ONETWO, *reinterpret_cast<BigTest *>(bytes));
unittests/Support/ErrnoTest.cpp 15 EXPECT_EQ(1, RetryAfterSignal(-1, [] { return 1; }));
17 EXPECT_EQ(-1, RetryAfterSignal(-1, [] {
21 EXPECT_EQ(EAGAIN, errno);
24 EXPECT_EQ(1, RetryAfterSignal(-1, [&calls] {
29 EXPECT_EQ(2u, calls);
31 EXPECT_EQ(1, RetryAfterSignal(-1, [](int x) { return x; }, 1));
34 EXPECT_EQ(47, *P);
37 EXPECT_EQ(-1, RetryAfterSignal(-1, [] { return -1; }));
unittests/Support/ErrorOrTest.cpp 26 EXPECT_EQ(1, *a);
29 EXPECT_EQ(1, *b);
33 EXPECT_EQ(a.getError(), errc::invalid_argument);
47 EXPECT_EQ(42, x);
50 EXPECT_EQ(3, **t3());
70 EXPECT_EQ(x, errc::no_such_file_or_directory);
unittests/Support/ErrorTest.cpp 314 EXPECT_EQ(CustomErrorInfo2, 0)
335 EXPECT_EQ(Sum, 21) << "Failed to correctly append error to error list.";
349 EXPECT_EQ(Sum, 21) << "Failed to correctly prepend error to error list.";
366 EXPECT_EQ(Sum, 28) << "Failed to correctly concatenate error lists.";
431 EXPECT_EQ(ErrorInfo, 7)
440 EXPECT_EQ(S.str(), "foo42\n") << "Unexpected StringError log result";
444 EXPECT_EQ(EC, errc::invalid_argument)
455 EXPECT_EQ(S.str(), "foobar10xff\n")
461 EXPECT_EQ(S.str(), "bar\n")
467 EXPECT_EQ(Res, EC)
483 EXPECT_EQ(ExitOnErr(Expected<int>(7)), 7)
488 EXPECT_EQ(&A, &B) << "ExitOnError failed to propagate reference";
505 EXPECT_EQ(X, 42) << "Expected value modified by cantFail";
509 EXPECT_EQ(&Dummy, &Y) << "Reference mangled by cantFail";
539 EXPECT_EQ(*A, 7) << "Incorrect Expected non-error value";
549 EXPECT_EQ(&A, &C) << "Expected failed to propagate reference";
644 EXPECT_EQ(*ValOrErr, 42)
686 EXPECT_EQ(*ValOrErr, 42)
692 EXPECT_EQ(errorToErrorCode(errorCodeToError(std::error_code())),
697 EXPECT_EQ(errorToErrorCode(errorCodeToError(errc::invalid_argument)),
708 EXPECT_EQ(*Orig, *RoundTripped)
720 EXPECT_EQ(Orig.getError(), RoundTripped.getError())
728 EXPECT_EQ(toString(Error::success()).compare(""), 0);
731 EXPECT_EQ(toString(std::move(E1)).compare("CustomError {0}"), 0);
735 EXPECT_EQ(CE.message().compare("CustomError {0}"), 0);
739 EXPECT_EQ(toString(std::move(E3))
751 EXPECT_EQ("success", S.str());
759 EXPECT_EQ("CustomError {0}", S.str());
847 EXPECT_EQ(LLVMGetErrorTypeId(Err), LLVMGetStringErrorTypeId())
883 EXPECT_EQ(toString(std::move(FE1)).compare("'file.bin': CustomError {1}"), 0);
888 EXPECT_EQ(F.message().compare("'file.bin': CustomError {2}"), 0);
897 EXPECT_EQ(C.message().compare("CustomError {3}"), 0);
903 EXPECT_EQ(toString(std::move(FE4))
960 EXPECT_EQ(toString(std::move(E1)).compare("Error 1."), 0);
964 EXPECT_EQ(toString(std::move(E2)).compare("Error 1. Detailed information"),
969 EXPECT_EQ(F.message().compare("Error 2."), 0);
975 EXPECT_EQ(toString(std::move(E4))
unittests/Support/FileCheckTest.cpp 25 EXPECT_EQ(10U, *Value);
31 EXPECT_EQ(std::numeric_limits<uint64_t>::max(), *Value);
66 EXPECT_EQ("FOO", FooVar.getName());
78 EXPECT_EQ(42U, *Value);
81 EXPECT_EQ(42U, *EvalResult);
106 EXPECT_EQ(60U, *Value);
150 EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
157 EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
164 EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
179 EXPECT_EQ(VarName, OrigVarName.substr(1));
180 EXPECT_EQ(ParsedVarResult->Name, "B");
186 EXPECT_EQ(VarName, OrigVarName.substr(1));
187 EXPECT_EQ(ParsedVarResult->Name, "B");
193 EXPECT_EQ(VarName, "+");
194 EXPECT_EQ(ParsedVarResult->Name, "BadVar");
200 EXPECT_EQ(VarName, "-");
201 EXPECT_EQ(ParsedVarResult->Name, "BadVar");
207 EXPECT_EQ(VarName, ":");
208 EXPECT_EQ(ParsedVarResult->Name, "BadVar");
429 EXPECT_EQ("42", *SubstValue);
432 EXPECT_EQ("10", *SubstValue);
450 EXPECT_EQ("BAR", *SubstValue);
524 EXPECT_EQ(*LocalVar, "FOO");
530 EXPECT_EQ(*ExpressionVal, 18U);
538 EXPECT_EQ(*ExpressionVal, 20U);
540 EXPECT_EQ(*EmptyVar, "");
579 EXPECT_EQ(*GlobalVar, "BAR");
587 EXPECT_EQ(*ExpressionVal, 36U);
599 EXPECT_EQ(*ExpressionVal, 36U);
unittests/Support/FileCollectorTest.cpp 112 EXPECT_EQ(FileCollector.Root, root_fs);
unittests/Support/FormatVariadicTest.cpp 40 EXPECT_EQ(0U, Replacements.size());
47 EXPECT_EQ(kFormatString, Replacements[0].Spec);
48 EXPECT_EQ(ReplacementType::Literal, Replacements[0].Type);
55 EXPECT_EQ("{", Replacements[0].Spec);
56 EXPECT_EQ(ReplacementType::Literal, Replacements[0].Type);
61 EXPECT_EQ("{{{", Replacements[0].Spec);
62 EXPECT_EQ(ReplacementType::Literal, Replacements[0].Type);
69 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
70 EXPECT_EQ(0u, Replacements[0].Index);
71 EXPECT_EQ(0u, Replacements[0].Align);
72 EXPECT_EQ("", Replacements[0].Options);
76 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
77 EXPECT_EQ(1u, Replacements[0].Index);
78 EXPECT_EQ(0u, Replacements[0].Align);
79 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);
80 EXPECT_EQ("", Replacements[0].Options);
85 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
86 EXPECT_EQ(0u, Replacements[0].Index);
87 EXPECT_EQ(3u, Replacements[0].Align);
88 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);
89 EXPECT_EQ("", Replacements[0].Options);
94 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
95 EXPECT_EQ(0u, Replacements[0].Index);
96 EXPECT_EQ(3u, Replacements[0].Align);
97 EXPECT_EQ(AlignStyle::Left, Replacements[0].Where);
98 EXPECT_EQ("", Replacements[0].Options);
103 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
104 EXPECT_EQ(0u, Replacements[0].Index);
105 EXPECT_EQ(3u, Replacements[0].Align);
106 EXPECT_EQ(AlignStyle::Center, Replacements[0].Where);
107 EXPECT_EQ("", Replacements[0].Options);
112 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
113 EXPECT_EQ(0u, Replacements[0].Index);
114 EXPECT_EQ(0u, Replacements[0].Align);
115 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);
116 EXPECT_EQ("foo", Replacements[0].Options);
121 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
122 EXPECT_EQ(0u, Replacements[0].Index);
123 EXPECT_EQ(3u, Replacements[0].Align);
124 EXPECT_EQ(AlignStyle::Left, Replacements[0].Where);
125 EXPECT_EQ("foo", Replacements[0].Options);
130 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
131 EXPECT_EQ(0u, Replacements[0].Index);
132 EXPECT_EQ(3u, Replacements[0].Align);
133 EXPECT_EQ(AlignStyle::Left, Replacements[0].Where);
134 EXPECT_EQ("foo", Replacements[0].Options);
140 EXPECT_EQ("0:0:1", Replacements[0].Spec);
141 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
142 EXPECT_EQ(0u, Replacements[0].Index);
143 EXPECT_EQ(0u, Replacements[0].Align);
144 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);
145 EXPECT_EQ("0:1", Replacements[0].Options);
150 EXPECT_EQ("0,p+4:foo", Replacements[0].Spec);
151 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
152 EXPECT_EQ(0u, Replacements[0].Index);
153 EXPECT_EQ(4u, Replacements[0].Align);
154 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);
155 EXPECT_EQ('p', Replacements[0].Pad);
156 EXPECT_EQ("foo", Replacements[0].Options);
161 EXPECT_EQ("0,-+4:foo", Replacements[0].Spec);
162 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
163 EXPECT_EQ(0u, Replacements[0].Index);
164 EXPECT_EQ(4u, Replacements[0].Align);
165 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);
166 EXPECT_EQ('-', Replacements[0].Pad);
167 EXPECT_EQ("foo", Replacements[0].Options);
171 EXPECT_EQ("0,+-4:foo", Replacements[0].Spec);
172 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
173 EXPECT_EQ(0u, Replacements[0].Index);
174 EXPECT_EQ(4u, Replacements[0].Align);
175 EXPECT_EQ(AlignStyle::Left, Replacements[0].Where);
176 EXPECT_EQ('+', Replacements[0].Pad);
177 EXPECT_EQ("foo", Replacements[0].Options);
181 EXPECT_EQ("0,==4:foo", Replacements[0].Spec);
182 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
183 EXPECT_EQ(0u, Replacements[0].Index);
184 EXPECT_EQ(4u, Replacements[0].Align);
185 EXPECT_EQ(AlignStyle::Center, Replacements[0].Where);
186 EXPECT_EQ('=', Replacements[0].Pad);
187 EXPECT_EQ("foo", Replacements[0].Options);
191 EXPECT_EQ("0,:=4:foo", Replacements[0].Spec);
192 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
193 EXPECT_EQ(0u, Replacements[0].Index);
194 EXPECT_EQ(4u, Replacements[0].Align);
195 EXPECT_EQ(AlignStyle::Center, Replacements[0].Where);
196 EXPECT_EQ(':', Replacements[0].Pad);
197 EXPECT_EQ("foo", Replacements[0].Options);
204 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
205 EXPECT_EQ(0u, Replacements[0].Index);
206 EXPECT_EQ(3u, Replacements[0].Align);
207 EXPECT_EQ("", Replacements[0].Options);
212 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
213 EXPECT_EQ(0u, Replacements[0].Index);
214 EXPECT_EQ(3u, Replacements[0].Align);
215 EXPECT_EQ("", Replacements[0].Options);
220 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
221 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);
222 EXPECT_EQ(' ', Replacements[0].Pad);
223 EXPECT_EQ(0u, Replacements[0].Index);
224 EXPECT_EQ(0u, Replacements[0].Align);
225 EXPECT_EQ("foo", Replacements[0].Options);
233 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
234 EXPECT_EQ(0u, Replacements[0].Index);
235 EXPECT_EQ(0u, Replacements[0].Align);
236 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);
237 EXPECT_EQ("", Replacements[0].Options);
240 EXPECT_EQ(ReplacementType::Literal, Replacements[1].Type);
241 EXPECT_EQ(" ", Replacements[1].Spec);
244 EXPECT_EQ(ReplacementType::Format, Replacements[2].Type);
245 EXPECT_EQ(1u, Replacements[2].Index);
246 EXPECT_EQ(0u, Replacements[2].Align);
247 EXPECT_EQ(AlignStyle::Right, Replacements[2].Where);
248 EXPECT_EQ("foo", Replacements[2].Options);
251 EXPECT_EQ(ReplacementType::Literal, Replacements[3].Type);
252 EXPECT_EQ("-", Replacements[3].Spec);
255 EXPECT_EQ(ReplacementType::Format, Replacements[4].Type);
256 EXPECT_EQ(2u, Replacements[4].Index);
257 EXPECT_EQ(3u, Replacements[4].Align);
258 EXPECT_EQ(AlignStyle::Left, Replacements[4].Where);
259 EXPECT_EQ("bar", Replacements[4].Options);
263 EXPECT_EQ("", formatv("").str());
264 EXPECT_EQ("Test", formatv("Test").str());
268 EXPECT_EQ("1", formatv("{0}", 1).str());
269 EXPECT_EQ("c", formatv("{0}", 'c').str());
270 EXPECT_EQ("-3", formatv("{0}", -3).str());
271 EXPECT_EQ("Test", formatv("{0}", "Test").str());
272 EXPECT_EQ("Test2", formatv("{0}", StringRef("Test2")).str());
273 EXPECT_EQ("Test3", formatv("{0}", std::string("Test3")).str());
278 EXPECT_EQ("0", formatv("{0}", 0).str());
279 EXPECT_EQ("2748", formatv("{0}", 0xABC).str());
280 EXPECT_EQ("-2748", formatv("{0}", -0xABC).str());
283 EXPECT_EQ("0xFF", formatv("{0:X}", 255).str());
284 EXPECT_EQ("0xFF", formatv("{0:X+}", 255).str());
285 EXPECT_EQ("0xff", formatv("{0:x}", 255).str());
286 EXPECT_EQ("0xff", formatv("{0:x+}", 255).str());
287 EXPECT_EQ("FF", formatv("{0:X-}", 255).str());
288 EXPECT_EQ("ff", formatv("{0:x-}", 255).str());
292 EXPECT_EQ("0xFF", formatv("{0:X2}", 255).str());
293 EXPECT_EQ("0xFF", formatv("{0:X+2}", 255).str());
294 EXPECT_EQ("0x0ff", formatv("{0:x3}", 255).str());
295 EXPECT_EQ("0x0ff", formatv("{0:x+3}", 255).str());
296 EXPECT_EQ("00FF", formatv("{0:X-4}", 255).str());
297 EXPECT_EQ("00ff", formatv("{0:x-4}", 255).str());
300 EXPECT_EQ("0xDEADBEEFDEADBEEF",
302 EXPECT_EQ("0xFEEBDAEDFEEBDAED",
304 EXPECT_EQ("0x00000000DEADBEEF", formatv("{0:X16}", 0xDEADBEEF).str());
307 EXPECT_EQ("0xff", formatv("{0,4:x}", 255).str());
308 EXPECT_EQ(" 0xff", formatv("{0,5:x+}", 255).str());
309 EXPECT_EQ(" FF", formatv("{0,4:X-}", 255).str());
310 EXPECT_EQ(" ff", formatv("{0,5:x-}", 255).str());
313 EXPECT_EQ(" 0x0ff", formatv("{0,7:x3}", 255).str());
314 EXPECT_EQ(" 0x00ff", formatv("{0,7:x+4}", 255).str());
315 EXPECT_EQ(" 000FF", formatv("{0,7:X-5}", 255).str());
316 EXPECT_EQ(" 0000ff", formatv("{0,7:x-6}", 255).str());
319 EXPECT_EQ(" 255", formatv("{0,7:3}", 255).str());
320 EXPECT_EQ(" 0255", formatv("{0,7:4}", 255).str());
321 EXPECT_EQ(" 00255", formatv("{0,7:5}", 255).str());
322 EXPECT_EQ(" 000255", formatv("{0,7:6}", 255).str());
328 EXPECT_EQ("0x00000000", formatv("{0}", (void *)0).str());
329 EXPECT_EQ("0x00000ABC", formatv("{0}", (void *)0xABC).str());
331 EXPECT_EQ("0x0000000000000000", formatv("{0}", (void *)0).str());
332 EXPECT_EQ("0x0000000000000ABC", formatv("{0}", (void *)0xABC).str());
336 EXPECT_EQ("0x0", formatv("{0:0}", (void *)0).str());
337 EXPECT_EQ("0xABC", formatv("{0:0}", (void *)0xABC).str());
338 EXPECT_EQ("0x0000", formatv("{0:4}", (void *)0).str());
339 EXPECT_EQ("0x0ABC", formatv("{0:4}", (void *)0xABC).str());
342 EXPECT_EQ("0x0ABC", formatv("{0:X4}", (void *)0xABC).str());
343 EXPECT_EQ("0x0abc", formatv("{0:x4}", (void *)0xABC).str());
344 EXPECT_EQ("0ABC", formatv("{0:X-4}", (void *)0xABC).str());
345 EXPECT_EQ("0abc", formatv("{0:x-4}", (void *)0xABC).str());
350 EXPECT_EQ("0", formatv("{0:N}", 0).str());
351 EXPECT_EQ("10", formatv("{0:N}", 10).str());
352 EXPECT_EQ("100", formatv("{0:N}", 100).str());
353 EXPECT_EQ("1,000", formatv("{0:N}", 1000).str());
354 EXPECT_EQ("1,234,567,890", formatv("{0:N}", 1234567890).str());
355 EXPECT_EQ("-10", formatv("{0:N}", -10).str());
356 EXPECT_EQ("-100", formatv("{0:N}", -100).str());
357 EXPECT_EQ("-1,000", formatv("{0:N}", -1000).str());
358 EXPECT_EQ("-1,234,567,890", formatv("{0:N}", -1234567890).str());
362 EXPECT_EQ(" 1", formatv("{0,2:N}", 1).str());
366 EXPECT_EQ(" 1,000", formatv("{0,6:N}", 1000).str());
367 EXPECT_EQ(" -1,000", formatv("{0,7:N}", -1000).str());
370 EXPECT_EQ(" 1,000", formatv("{0,11:N}", 1000).str());
371 EXPECT_EQ(" -1,000", formatv("{0,11:N}", -1000).str());
372 EXPECT_EQ(" -100,000", formatv("{0,11:N}", -100000).str());
382 EXPECT_EQ(FooArray, formatv("{0}", FooArray).str());
383 EXPECT_EQ(FooPtr, formatv("{0}", FooPtr).str());
384 EXPECT_EQ(FooRef, formatv("{0}", FooRef).str());
385 EXPECT_EQ(FooLiteral, formatv("{0}", FooLiteral).str());
386 EXPECT_EQ(FooString, formatv("{0}", FooString).str());
390 EXPECT_EQ("FooA", formatv("{0:4}", FooArray).str());
391 EXPECT_EQ("FooP", formatv("{0:4}", FooPtr).str());
392 EXPECT_EQ("FooR", formatv("{0:4}", FooRef).str());
393 EXPECT_EQ("FooS", formatv("{0:4}", FooString).str());
396 EXPECT_EQ(" FooA", formatv("{0,6:4}", FooArray).str());
397 EXPECT_EQ(" FooP", formatv("{0,6:4}", FooPtr).str());
398 EXPECT_EQ(" FooR", formatv("{0,6:4}", FooRef).str());
399 EXPECT_EQ(" FooS", formatv("{0,6:4}", FooString).str());
404 EXPECT_EQ("C", formatv("{0}", 'C').str());
405 EXPECT_EQ(" C", formatv("{0,3}", 'C').str());
410 EXPECT_EQ("37", formatv("{0:D}", (char)37).str());
411 EXPECT_EQ(" 037", formatv("{0,5:D3}", (char)37).str());
416 EXPECT_EQ("true", formatv("{0}", true).str());
417 EXPECT_EQ("false", formatv("{0}", false).str());
418 EXPECT_EQ("true", formatv("{0:t}", true).str());
419 EXPECT_EQ("false", formatv("{0:t}", false).str());
422 EXPECT_EQ("TRUE", formatv("{0:T}", true).str());
423 EXPECT_EQ("FALSE", formatv("{0:T}", false).str());
426 EXPECT_EQ("1", formatv("{0:D}", true).str());
427 EXPECT_EQ("0", formatv("{0:D}", false).str());
428 EXPECT_EQ("1", formatv("{0:d}", true).str());
429 EXPECT_EQ("0", formatv("{0:d}", false).str());
432 EXPECT_EQ("YES", formatv("{0:Y}", true).str());
433 EXPECT_EQ("NO", formatv("{0:Y}", false).str());
436 EXPECT_EQ("yes", formatv("{0:y}", true).str());
437 EXPECT_EQ("no", formatv("{0:y}", false).str());
444 EXPECT_EQ("0.000000E+00", formatv("{0:E}", 0.0).str());
445 EXPECT_EQ("-0.000000E+00", formatv("{0:E}", -0.0).str());
446 EXPECT_EQ("1.100000E+00", formatv("{0:E}", 1.1).str());
447 EXPECT_EQ("-1.100000E+00", formatv("{0:E}", -1.1).str());
448 EXPECT_EQ("1.234568E+03", formatv("{0:E}", 1234.5678).str());
449 EXPECT_EQ("-1.234568E+03", formatv("{0:E}", -1234.5678).str());
450 EXPECT_EQ("1.234568E-03", formatv("{0:E}", .0012345678).str());
451 EXPECT_EQ("-1.234568E-03", formatv("{0:E}", -.0012345678).str());
454 EXPECT_EQ(" 0.000E+00", formatv("{0,11:E3}", 0.0).str());
455 EXPECT_EQ(" -1.100E+00", formatv("{0,11:E3}", -1.1).str());
456 EXPECT_EQ(" 1.235E+03", formatv("{0,11:E3}", 1234.5678).str());
457 EXPECT_EQ(" -1.235E-03", formatv("{0,11:E3}", -.0012345678).str());
460 EXPECT_EQ("0.00", formatv("{0:F}", 0.0).str());
461 EXPECT_EQ("-0.00", formatv("{0:F}", -0.0).str());
462 EXPECT_EQ("1.10", formatv("{0:F}", 1.1).str());
463 EXPECT_EQ("-1.10", formatv("{0:F}", -1.1).str());
464 EXPECT_EQ("1234.57", formatv("{0:F}", 1234.5678).str());
465 EXPECT_EQ("-1234.57", formatv("{0:F}", -1234.5678).str());
466 EXPECT_EQ("0.00", formatv("{0:F}", .0012345678).str());
467 EXPECT_EQ("-0.00", formatv("{0:F}", -.0012345678).str());
470 EXPECT_EQ(" 0.000", formatv("{0,8:F3}", 0.0).str());
471 EXPECT_EQ(" -1.100", formatv("{0,8:F3}", -1.1).str());
472 EXPECT_EQ("1234.568", formatv("{0,8:F3}", 1234.5678).str());
473 EXPECT_EQ(" -0.001", formatv("{0,8:F3}", -.0012345678).str());
478 EXPECT_EQ("==123", formatv("{0,=+5}", 123).str());
479 EXPECT_EQ("=123=", formatv("{0,==5}", 123).str());
480 EXPECT_EQ("123==", formatv("{0,=-5}", 123).str());
483 EXPECT_EQ("=00123=", formatv("{0,==7:5}", 123).str());
539 EXPECT_EQ(Expected, S);
546 EXPECT_EQ("1, 1, 2, 3, 5, 8, 13",
548 EXPECT_EQ("1, 2, 3, 5, 8",
553 EXPECT_EQ(
558 EXPECT_EQ(
563 EXPECT_EQ(
570 EXPECT_EQ(
574 EXPECT_EQ(
578 EXPECT_EQ(
584 EXPECT_EQ("", formatv("{0:$[+]@[x]}",
589 EXPECT_EQ("11235813",
601 EXPECT_EQ("-7", formatv("{0}", Negative(7)).str());
605 EXPECT_EQ(" 171 ",
607 EXPECT_EQ("--171--",
609 EXPECT_EQ(" 171 ", formatv("{0}", fmt_pad(N, 1, 3)).str());
610 EXPECT_EQ("171171171171171", formatv("{0}", fmt_repeat(N, 5)).str());
612 EXPECT_EQ(" ABABABABAB ",
614 EXPECT_EQ(" AB AB AB AB AB ",
622 EXPECT_EQ("1 2", S);
626 EXPECT_EQ("1 2", S);
629 EXPECT_EQ("1 2", S2);
633 EXPECT_EQ("Format", formatv("{0}", Format(1)).str());
636 EXPECT_EQ("Format", formatv("{0}", var).str());
637 EXPECT_EQ("Format", formatv("{0}", std::move(var)).str());
645 EXPECT_EQ("Format", formatv("F{0}t", formatv("o{0}a", "rm")).str());
646 EXPECT_EQ("[ ! ]", formatv("[{0,+5}]", formatv("{0,-2}", "!")).str());
668 EXPECT_EQ("0C 0M", formatv("{0}", R).str());
669 EXPECT_EQ("0C 3M", formatv("{0}", std::move(R)).str());
670 EXPECT_EQ("0C 3M", formatv("{0}", Recorder()).str());
671 EXPECT_EQ(0, R.Copied);
672 EXPECT_EQ(0, R.Moved);
681 EXPECT_EQ("X", formatv("{0}", X).str());
686 EXPECT_EQ("X", formatv("{0}", E1).str());
688 EXPECT_EQ("X", formatv("{0}", fmt_consume(std::move(E1))).str());
unittests/Support/Host.cpp 83 EXPECT_EQ(sys::detail::getHostCPUNameForARM(CortexA9ProcCpuinfo),
85 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x41\n"
89 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x40\n"
92 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x51\n"
98 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x41\n"
102 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x40\n"
105 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x51\n"
108 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x51\n"
111 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x51\n"
114 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x51\n"
117 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x51\n"
140 EXPECT_EQ(sys::detail::getHostCPUNameForARM(MSM8992ProcCpuInfo),
159 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ExynosProcCpuInfo +
164 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ExynosProcCpuInfo +
169 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ExynosProcCpuInfo +
185 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
190 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
195 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
200 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
205 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
210 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
215 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
220 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderX2T99ProcCpuInfo +
236 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderXT88ProcCpuInfo +
241 EXPECT_EQ(sys::detail::getHostCPUNameForARM(ThunderXT88ProcCpuInfo +
247 EXPECT_EQ(sys::detail::getHostCPUNameForARM("CPU implementer : 0x48\n"
unittests/Support/ItaniumManglingCanonicalizerTest.cpp 288 EXPECT_EQ(Result, EquivalenceError::Success)
311 EXPECT_EQ(ThisKey, ClassKey)
340 EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "", "1X"),
342 EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1X", "1ab"),
344 EXPECT_EQ(Canonicalizer.canonicalize("_Z3fooE"),
346 EXPECT_EQ(Canonicalizer.canonicalize("foo"),
354 EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Name, "N1XcvT_I1AEE",
361 EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "N1P1XE", "N1Q1XE"),
363 EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1P", "1Q"),
366 EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "N1C1XE", "N1A1YE"),
368 EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1A", "1B"),
370 EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1C", "1D"),
372 EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1B", "1D"),
unittests/Support/JSONTest.cpp 24 EXPECT_EQ("true", s(true));
25 EXPECT_EQ("null", s(nullptr));
26 EXPECT_EQ("2.5", s(2.5));
27 EXPECT_EQ(R"("foo")", s("foo"));
28 EXPECT_EQ("[1,2,3]", s({1, 2, 3}));
29 EXPECT_EQ(R"({"x":10,"y":20})", s(Object{{"x", 10}, {"y", 20}}));
42 EXPECT_EQ("[[[3]]]", s({{{3}}}));
43 EXPECT_EQ("[[[]]]", s({{{}}}));
44 EXPECT_EQ("[[{}]]", s({{Object{}}}));
45 EXPECT_EQ(R"({"A":{"B":{}}})", s(Object{{"A", Object{{"B", Object{}}}}}));
46 EXPECT_EQ(R"({"A":{"B":{"X":"Y"}}})",
48 EXPECT_EQ("null", s(llvm::Optional<double>()));
49 EXPECT_EQ("2.5", s(llvm::Optional<double>(2.5)));
50 EXPECT_EQ("[[2.5,null]]", s(std::vector<std::vector<llvm::Optional<double>>>{
58 EXPECT_EQ(R"("Hallo")", s(Alias));
63 EXPECT_EQ(R"("Hello")", s(Copy));
68 EXPECT_EQ(R"({"a":1,"b":2,"c":3})", s(Object{{"a", 1}, {"c", 3}, {"b", 2}}));
69 EXPECT_EQ(R"(["a","c","b"])", s({"a", "c", "b"}));
70 EXPECT_EQ("3", s(3.0));
86 EXPECT_EQ(teststring, s(test));
88 EXPECT_EQ(R"({"object keys are\nescaped":true})",
109 EXPECT_EQ(str, sp(Object{
127 EXPECT_EQ(*E, Expected);
128 EXPECT_EQ(sp(*E), sp(Expected));
205 EXPECT_EQ(fixUTF8(Valid), Valid);
217 EXPECT_EQ(fixUTF8(Invalid.first), Invalid.second);
241 EXPECT_EQ(O->getNumber("number"), llvm::Optional<double>(2.78));
243 EXPECT_EQ(O->getString("string"), llvm::Optional<llvm::StringRef>("json"));
247 EXPECT_EQ(*O->getObject("object"), (Object{{"fruit", "banana"}}));
251 EXPECT_EQ((*A)[1].getAsBoolean(), llvm::Optional<bool>(true));
253 EXPECT_EQ(*(*A)[4].getAsArray(), (Array{1, 2, 3}));
254 EXPECT_EQ((*(*A)[4].getAsArray())[1].getAsInteger(),
260 EXPECT_EQ(E.getAsObject()->getString("time"),
317 EXPECT_EQ(T.Str, s(T.Val)) << T.Desc;
320 EXPECT_EQ(Doc->getAsInteger(), T.AsInt) << T.Desc;
321 EXPECT_EQ(Doc->getAsNumber(), T.AsNumber) << T.Desc;
322 EXPECT_EQ(T.Val, *Doc) << T.Desc;
323 EXPECT_EQ(T.Str, s(*Doc)) << T.Desc;
376 EXPECT_EQ(R, Expected);
410 EXPECT_EQ(Plain, StreamStuff(0));
422 EXPECT_EQ(Pretty, StreamStuff(2));
unittests/Support/KnownBitsTest.cpp 74 EXPECT_EQ(Known.Zero, KnownComputed.Zero);
75 EXPECT_EQ(Known.One, KnownComputed.One);
112 EXPECT_EQ(Known.Zero, KnownComputed.Zero);
113 EXPECT_EQ(Known.One, KnownComputed.One);
unittests/Support/LEB128Test.cpp 185 EXPECT_EQ(1u, getSLEB128Size(0x0LL));
186 EXPECT_EQ(1u, getSLEB128Size(0x1LL));
187 EXPECT_EQ(1u, getSLEB128Size(0x3fLL));
188 EXPECT_EQ(1u, getSLEB128Size(0x3fLL));
189 EXPECT_EQ(2u, getSLEB128Size(0x40LL));
191 EXPECT_EQ(2u, getSLEB128Size(0x7fLL));
192 EXPECT_EQ(2u, getSLEB128Size(0x80LL));
193 EXPECT_EQ(2u, getSLEB128Size(0x1f80LL));
194 EXPECT_EQ(2u, getSLEB128Size(0x1fffLL));
195 EXPECT_EQ(3u, getSLEB128Size(0x2000LL));
197 EXPECT_EQ(3u, getSLEB128Size(0x3fffLL));
198 EXPECT_EQ(3u, getSLEB128Size(0x4000LL));
199 EXPECT_EQ(3u, getSLEB128Size(0xfc000LL));
200 EXPECT_EQ(3u, getSLEB128Size(0xfffffLL));
201 EXPECT_EQ(4u, getSLEB128Size(0x100000LL));
203 EXPECT_EQ(4u, getSLEB128Size(0x1fffffLL));
204 EXPECT_EQ(4u, getSLEB128Size(0x200000LL));
205 EXPECT_EQ(4u, getSLEB128Size(0x7e00000LL));
206 EXPECT_EQ(4u, getSLEB128Size(0x7ffffffLL));
207 EXPECT_EQ(5u, getSLEB128Size(0x8000000LL));
209 EXPECT_EQ(5u, getSLEB128Size(0xfffffffLL));
210 EXPECT_EQ(5u, getSLEB128Size(0x10000000LL));
211 EXPECT_EQ(5u, getSLEB128Size(0x3f0000000LL));
212 EXPECT_EQ(5u, getSLEB128Size(0x3ffffffffLL));
213 EXPECT_EQ(6u, getSLEB128Size(0x400000000LL));
215 EXPECT_EQ(6u, getSLEB128Size(0x7ffffffffLL));
216 EXPECT_EQ(6u, getSLEB128Size(0x800000000LL));
217 EXPECT_EQ(6u, getSLEB128Size(0x1f800000000LL));
218 EXPECT_EQ(6u, getSLEB128Size(0x1ffffffffffLL));
219 EXPECT_EQ(7u, getSLEB128Size(0x20000000000LL));
221 EXPECT_EQ(7u, getSLEB128Size(0x3ffffffffffLL));
222 EXPECT_EQ(7u, getSLEB128Size(0x40000000000LL));
223 EXPECT_EQ(7u, getSLEB128Size(0xfc0000000000LL));
224 EXPECT_EQ(7u, getSLEB128Size(0xffffffffffffLL));
225 EXPECT_EQ(8u, getSLEB128Size(0x1000000000000LL));
227 EXPECT_EQ(8u, getSLEB128Size(0x1ffffffffffffLL));
228 EXPECT_EQ(8u, getSLEB128Size(0x2000000000000LL));
229 EXPECT_EQ(8u, getSLEB128Size(0x7e000000000000LL));
230 EXPECT_EQ(8u, getSLEB128Size(0x7fffffffffffffLL));
231 EXPECT_EQ(9u, getSLEB128Size(0x80000000000000LL));
233 EXPECT_EQ(9u, getSLEB128Size(0xffffffffffffffLL));
234 EXPECT_EQ(9u, getSLEB128Size(0x100000000000000LL));
235 EXPECT_EQ(9u, getSLEB128Size(0x3f00000000000000LL));
236 EXPECT_EQ(9u, getSLEB128Size(0x3fffffffffffffffLL));
237 EXPECT_EQ(10u, getSLEB128Size(0x4000000000000000LL));
239 EXPECT_EQ(10u, getSLEB128Size(0x7fffffffffffffffLL));
240 EXPECT_EQ(10u, getSLEB128Size(INT64_MAX));
250 EXPECT_EQ(1u, getSLEB128Size(0x0LL));
251 EXPECT_EQ(1u, getSLEB128Size(-0x1LL));
252 EXPECT_EQ(1u, getSLEB128Size(-0x3fLL));
253 EXPECT_EQ(1u, getSLEB128Size(-0x40LL));
254 EXPECT_EQ(1u, getSLEB128Size(-0x40LL)); // special case
255 EXPECT_EQ(2u, getSLEB128Size(-0x41LL));
257 EXPECT_EQ(2u, getSLEB128Size(-0x7fLL));
258 EXPECT_EQ(2u, getSLEB128Size(-0x80LL));
259 EXPECT_EQ(2u, getSLEB128Size(-0x1f80LL));
260 EXPECT_EQ(2u, getSLEB128Size(-0x2000LL));
261 EXPECT_EQ(3u, getSLEB128Size(-0x207fLL));
262 EXPECT_EQ(3u, getSLEB128Size(-0x2080LL));
264 EXPECT_EQ(3u, getSLEB128Size(-0x3fffLL));
265 EXPECT_EQ(3u, getSLEB128Size(-0x4000LL));
266 EXPECT_EQ(3u, getSLEB128Size(-0xfc000LL));
267 EXPECT_EQ(3u, getSLEB128Size(-0x100000LL));
268 EXPECT_EQ(4u, getSLEB128Size(-0x103fffLL));
269 EXPECT_EQ(4u, getSLEB128Size(-0x104000LL));
271 EXPECT_EQ(4u, getSLEB128Size(-0x1fffffLL));
272 EXPECT_EQ(4u, getSLEB128Size(-0x200000LL));
273 EXPECT_EQ(4u, getSLEB128Size(-0x7e00000LL));
274 EXPECT_EQ(4u, getSLEB128Size(-0x8000000LL));
275 EXPECT_EQ(5u, getSLEB128Size(-0x81fffffLL));
276 EXPECT_EQ(5u, getSLEB128Size(-0x8200000LL));
278 EXPECT_EQ(5u, getSLEB128Size(-0xfffffffLL));
279 EXPECT_EQ(5u, getSLEB128Size(-0x10000000LL));
280 EXPECT_EQ(5u, getSLEB128Size(-0x3f0000000LL));
281 EXPECT_EQ(5u, getSLEB128Size(-0x400000000LL));
282 EXPECT_EQ(6u, getSLEB128Size(-0x40fffffffLL));
283 EXPECT_EQ(6u, getSLEB128Size(-0x410000000LL));
285 EXPECT_EQ(6u, getSLEB128Size(-0x7ffffffffLL));
286 EXPECT_EQ(6u, getSLEB128Size(-0x800000000LL));
287 EXPECT_EQ(6u, getSLEB128Size(-0x1f800000000LL));
288 EXPECT_EQ(6u, getSLEB128Size(-0x20000000000LL));
289 EXPECT_EQ(7u, getSLEB128Size(-0x207ffffffffLL));
290 EXPECT_EQ(7u, getSLEB128Size(-0x20800000000LL));
292 EXPECT_EQ(7u, getSLEB128Size(-0x3ffffffffffLL));
293 EXPECT_EQ(7u, getSLEB128Size(-0x40000000000LL));
294 EXPECT_EQ(7u, getSLEB128Size(-0xfc0000000000LL));
295 EXPECT_EQ(7u, getSLEB128Size(-0x1000000000000LL));
296 EXPECT_EQ(8u, getSLEB128Size(-0x103ffffffffffLL));
297 EXPECT_EQ(8u, getSLEB128Size(-0x1040000000000LL));
299 EXPECT_EQ(8u, getSLEB128Size(-0x1ffffffffffffLL));
300 EXPECT_EQ(8u, getSLEB128Size(-0x2000000000000LL));
301 EXPECT_EQ(8u, getSLEB128Size(-0x7e000000000000LL));
302 EXPECT_EQ(8u, getSLEB128Size(-0x80000000000000LL));
303 EXPECT_EQ(9u, getSLEB128Size(-0x81ffffffffffffLL));
304 EXPECT_EQ(9u, getSLEB128Size(-0x82000000000000LL));
306 EXPECT_EQ(9u, getSLEB128Size(-0xffffffffffffffLL));
307 EXPECT_EQ(9u, getSLEB128Size(-0x100000000000000LL));
308 EXPECT_EQ(9u, getSLEB128Size(-0x3f00000000000000LL));
309 EXPECT_EQ(9u, getSLEB128Size(-0x4000000000000000LL));
310 EXPECT_EQ(10u, getSLEB128Size(-0x40ffffffffffffffLL));
311 EXPECT_EQ(10u, getSLEB128Size(-0x4100000000000000LL));
313 EXPECT_EQ(10u, getSLEB128Size(-0x7fffffffffffffffLL));
314 EXPECT_EQ(10u, getSLEB128Size(-0x8000000000000000LL));
315 EXPECT_EQ(10u, getSLEB128Size(INT64_MIN));
324 EXPECT_EQ(1u, getULEB128Size(0)); // special case
326 EXPECT_EQ(1u, getULEB128Size(0x1ULL));
327 EXPECT_EQ(1u, getULEB128Size(0x40ULL));
328 EXPECT_EQ(1u, getULEB128Size(0x7fULL));
330 EXPECT_EQ(2u, getULEB128Size(0x80ULL));
331 EXPECT_EQ(2u, getULEB128Size(0x2000ULL));
332 EXPECT_EQ(2u, getULEB128Size(0x3fffULL));
334 EXPECT_EQ(3u, getULEB128Size(0x4000ULL));
335 EXPECT_EQ(3u, getULEB128Size(0x100000ULL));
336 EXPECT_EQ(3u, getULEB128Size(0x1fffffULL));
338 EXPECT_EQ(4u, getULEB128Size(0x200000ULL));
339 EXPECT_EQ(4u, getULEB128Size(0x8000000ULL));
340 EXPECT_EQ(4u, getULEB128Size(0xfffffffULL));
342 EXPECT_EQ(5u, getULEB128Size(0x10000000ULL));
343 EXPECT_EQ(5u, getULEB128Size(0x400000000ULL));
344 EXPECT_EQ(5u, getULEB128Size(0x7ffffffffULL));
346 EXPECT_EQ(6u, getULEB128Size(0x800000000ULL));
347 EXPECT_EQ(6u, getULEB128Size(0x20000000000ULL));
348 EXPECT_EQ(6u, getULEB128Size(0x3ffffffffffULL));
350 EXPECT_EQ(7u, getULEB128Size(0x40000000000ULL));
351 EXPECT_EQ(7u, getULEB128Size(0x1000000000000ULL));
352 EXPECT_EQ(7u, getULEB128Size(0x1ffffffffffffULL));
354 EXPECT_EQ(8u, getULEB128Size(0x2000000000000ULL));
355 EXPECT_EQ(8u, getULEB128Size(0x80000000000000ULL));
356 EXPECT_EQ(8u, getULEB128Size(0xffffffffffffffULL));
358 EXPECT_EQ(9u, getULEB128Size(0x100000000000000ULL));
359 EXPECT_EQ(9u, getULEB128Size(0x4000000000000000ULL));
360 EXPECT_EQ(9u, getULEB128Size(0x7fffffffffffffffULL));
362 EXPECT_EQ(10u, getULEB128Size(0x8000000000000000ULL));
364 EXPECT_EQ(10u, getULEB128Size(UINT64_MAX));
unittests/Support/LineIteratorTest.cpp 28 EXPECT_EQ("line 1", *I);
29 EXPECT_EQ(1, I.line_number());
31 EXPECT_EQ("line 2", *I);
32 EXPECT_EQ(2, I.line_number());
34 EXPECT_EQ("line 3", *I);
35 EXPECT_EQ(3, I.line_number());
39 EXPECT_EQ(E, I);
57 EXPECT_EQ("line 1", *I);
58 EXPECT_EQ(1, I.line_number());
60 EXPECT_EQ("line 2", *I);
61 EXPECT_EQ(2, I.line_number());
63 EXPECT_EQ("line 5", *I);
64 EXPECT_EQ(5, I.line_number());
68 EXPECT_EQ(E, I);
87 EXPECT_EQ("line 1", *I);
88 EXPECT_EQ(1, I.line_number());
90 EXPECT_EQ("line 2", *I);
91 EXPECT_EQ(2, I.line_number());
93 EXPECT_EQ("", *I);
94 EXPECT_EQ(5, I.line_number());
96 EXPECT_EQ("line 6", *I);
97 EXPECT_EQ(6, I.line_number());
99 EXPECT_EQ("", *I);
100 EXPECT_EQ(7, I.line_number());
104 EXPECT_EQ(E, I);
120 EXPECT_EQ("line 1", *I);
121 EXPECT_EQ(4, I.line_number());
123 EXPECT_EQ("line 2", *I);
124 EXPECT_EQ(8, I.line_number());
128 EXPECT_EQ(E, I);
142 EXPECT_EQ("", *I);
143 EXPECT_EQ(1, I.line_number());
145 EXPECT_EQ("", *I);
146 EXPECT_EQ(2, I.line_number());
148 EXPECT_EQ("line 3", *I);
149 EXPECT_EQ(3, I.line_number());
151 EXPECT_EQ("", *I);
152 EXPECT_EQ(4, I.line_number());
154 EXPECT_EQ("line 5", *I);
155 EXPECT_EQ(5, I.line_number());
157 EXPECT_EQ("", *I);
158 EXPECT_EQ(6, I.line_number());
160 EXPECT_EQ("", *I);
161 EXPECT_EQ(7, I.line_number());
165 EXPECT_EQ(E, I);
171 EXPECT_EQ(line_iterator(), line_iterator(*Buffer));
173 EXPECT_EQ(line_iterator(), line_iterator(*Buffer, false));
177 EXPECT_EQ(line_iterator(), line_iterator(*Buffer));
183 EXPECT_EQ(line_iterator(), line_iterator(*Buffer, true, '#'));
189 EXPECT_EQ(line_iterator(), line_iterator(*Buffer, true, '#'));
unittests/Support/LockFileManagerTest.cpp 31 EXPECT_EQ(LockFileManager::LFS_Owned, Locked1.getState());
78 EXPECT_EQ(LockFileManager::LFS_Owned, Locked.getState());
109 EXPECT_EQ(LockFileManager::LFS_Owned, Locked.getState());
unittests/Support/MD5Test.cpp 29 EXPECT_EQ(Res, Final);
39 EXPECT_EQ(Res, Final);
67 EXPECT_EQ(Res, "c3fcd3d76192e4007dfb496cca67e13b");
68 EXPECT_EQ(0x3be167ca6c49fb7dULL, MD5Res.high());
69 EXPECT_EQ(0x00e49261d7d3fcc3ULL, MD5Res.low());
unittests/Support/ManagedStatic.cpp 97 EXPECT_EQ(42, *Custom);
unittests/Support/MathExtrasTest.cpp 21 EXPECT_EQ(8u, countTrailingZeros(Z8));
22 EXPECT_EQ(16u, countTrailingZeros(Z16));
23 EXPECT_EQ(32u, countTrailingZeros(Z32));
24 EXPECT_EQ(64u, countTrailingZeros(Z64));
30 EXPECT_EQ(1u, countTrailingZeros(NZ8));
31 EXPECT_EQ(1u, countTrailingZeros(NZ16));
32 EXPECT_EQ(1u, countTrailingZeros(NZ32));
33 EXPECT_EQ(1u, countTrailingZeros(NZ64));
41 EXPECT_EQ(8u, countLeadingZeros(Z8));
42 EXPECT_EQ(16u, countLeadingZeros(Z16));
43 EXPECT_EQ(32u, countLeadingZeros(Z32));
44 EXPECT_EQ(64u, countLeadingZeros(Z64));
50 EXPECT_EQ(2u, countLeadingZeros(NZ8));
51 EXPECT_EQ(10u, countLeadingZeros(NZ16));
52 EXPECT_EQ(26u, countLeadingZeros(NZ32));
53 EXPECT_EQ(58u, countLeadingZeros(NZ64));
55 EXPECT_EQ(8u, countLeadingZeros(0x00F000FFu));
56 EXPECT_EQ(8u, countLeadingZeros(0x00F12345u));
58 EXPECT_EQ(31 - i, countLeadingZeros(1u << i));
61 EXPECT_EQ(8u, countLeadingZeros(0x00F1234500F12345ULL));
62 EXPECT_EQ(1u, countLeadingZeros(1ULL << 62));
64 EXPECT_EQ(63 - i, countLeadingZeros(1ULL << i));
69 EXPECT_EQ(0U, maskLeadingOnes<uint8_t>(0));
70 EXPECT_EQ(0U, maskTrailingOnes<uint8_t>(0));
71 EXPECT_EQ(0U, maskLeadingOnes<uint16_t>(0));
72 EXPECT_EQ(0U, maskTrailingOnes<uint16_t>(0));
73 EXPECT_EQ(0U, maskLeadingOnes<uint32_t>(0));
74 EXPECT_EQ(0U, maskTrailingOnes<uint32_t>(0));
75 EXPECT_EQ(0U, maskLeadingOnes<uint64_t>(0));
76 EXPECT_EQ(0U, maskTrailingOnes<uint64_t>(0));
78 EXPECT_EQ(0x00000003U, maskTrailingOnes<uint32_t>(2U));
79 EXPECT_EQ(0xC0000000U, maskLeadingOnes<uint32_t>(2U));
81 EXPECT_EQ(0x000007FFU, maskTrailingOnes<uint32_t>(11U));
82 EXPECT_EQ(0xFFE00000U, maskLeadingOnes<uint32_t>(11U));
84 EXPECT_EQ(0xFFFFFFFFU, maskTrailingOnes<uint32_t>(32U));
85 EXPECT_EQ(0xFFFFFFFFU, maskLeadingOnes<uint32_t>(32U));
86 EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, maskTrailingOnes<uint64_t>(64U));
87 EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, maskLeadingOnes<uint64_t>(64U));
89 EXPECT_EQ(0x0000FFFFFFFFFFFFULL, maskTrailingOnes<uint64_t>(48U));
90 EXPECT_EQ(0xFFFFFFFFFFFF0000ULL, maskLeadingOnes<uint64_t>(48U));
98 EXPECT_EQ(0xFFULL, findFirstSet(Z8));
99 EXPECT_EQ(0xFFFFULL, findFirstSet(Z16));
100 EXPECT_EQ(0xFFFFFFFFULL, findFirstSet(Z32));
101 EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, findFirstSet(Z64));
107 EXPECT_EQ(1u, findFirstSet(NZ8));
108 EXPECT_EQ(1u, findFirstSet(NZ16));
109 EXPECT_EQ(1u, findFirstSet(NZ32));
110 EXPECT_EQ(1u, findFirstSet(NZ64));
118 EXPECT_EQ(0xFFULL, findLastSet(Z8));
119 EXPECT_EQ(0xFFFFULL, findLastSet(Z16));
120 EXPECT_EQ(0xFFFFFFFFULL, findLastSet(Z32));
121 EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, findLastSet(Z64));
127 EXPECT_EQ(5u, findLastSet(NZ8));
128 EXPECT_EQ(5u, findLastSet(NZ16));
129 EXPECT_EQ(5u, findLastSet(NZ32));
130 EXPECT_EQ(5u, findLastSet(NZ64));
146 EXPECT_EQ(32767, maxIntN(16));
147 EXPECT_EQ(2147483647, maxIntN(32));
148 EXPECT_EQ(std::numeric_limits<int32_t>::max(), maxIntN(32));
149 EXPECT_EQ(std::numeric_limits<int64_t>::max(), maxIntN(64));
153 EXPECT_EQ(-32768LL, minIntN(16));
154 EXPECT_EQ(-64LL, minIntN(7));
155 EXPECT_EQ(std::numeric_limits<int32_t>::min(), minIntN(32));
156 EXPECT_EQ(std::numeric_limits<int64_t>::min(), minIntN(64));
160 EXPECT_EQ(0xffffULL, maxUIntN(16));
161 EXPECT_EQ(0xffffffffULL, maxUIntN(32));
162 EXPECT_EQ(0xffffffffffffffffULL, maxUIntN(64));
163 EXPECT_EQ(1ULL, maxUIntN(1));
164 EXPECT_EQ(0x0fULL, maxUIntN(4));
172 EXPECT_EQ(0x54ULL, reverseBits(NZ8));
173 EXPECT_EQ(0x5400ULL, reverseBits(NZ16));
174 EXPECT_EQ(0x54000000ULL, reverseBits(NZ32));
175 EXPECT_EQ(0x5400000000000000ULL, reverseBits(NZ64));
195 EXPECT_EQ(0U, PowerOf2Ceil(0U));
196 EXPECT_EQ(8U, PowerOf2Ceil(8U));
197 EXPECT_EQ(8U, PowerOf2Ceil(7U));
201 EXPECT_EQ(0U, PowerOf2Floor(0U));
202 EXPECT_EQ(8U, PowerOf2Floor(8U));
203 EXPECT_EQ(4U, PowerOf2Floor(7U));
207 EXPECT_EQ(CTLog2<1ULL << 0>(), 0U);
208 EXPECT_EQ(CTLog2<1ULL << 1>(), 1U);
209 EXPECT_EQ(CTLog2<1ULL << 2>(), 2U);
210 EXPECT_EQ(CTLog2<1ULL << 3>(), 3U);
211 EXPECT_EQ(CTLog2<1ULL << 4>(), 4U);
212 EXPECT_EQ(CTLog2<1ULL << 5>(), 5U);
213 EXPECT_EQ(CTLog2<1ULL << 6>(), 6U);
214 EXPECT_EQ(CTLog2<1ULL << 7>(), 7U);
215 EXPECT_EQ(CTLog2<1ULL << 8>(), 8U);
216 EXPECT_EQ(CTLog2<1ULL << 9>(), 9U);
217 EXPECT_EQ(CTLog2<1ULL << 10>(), 10U);
218 EXPECT_EQ(CTLog2<1ULL << 11>(), 11U);
219 EXPECT_EQ(CTLog2<1ULL << 12>(), 12U);
220 EXPECT_EQ(CTLog2<1ULL << 13>(), 13U);
221 EXPECT_EQ(CTLog2<1ULL << 14>(), 14U);
222 EXPECT_EQ(CTLog2<1ULL << 15>(), 15U);
226 EXPECT_EQ(0x44332211u, ByteSwap_32(0x11223344));
227 EXPECT_EQ(0xDDCCBBAAu, ByteSwap_32(0xAABBCCDD));
231 EXPECT_EQ(0x8877665544332211ULL, ByteSwap_64(0x1122334455667788LL));
232 EXPECT_EQ(0x1100FFEEDDCCBBAAULL, ByteSwap_64(0xAABBCCDDEEFF0011LL));
238 EXPECT_EQ(31u - i, countLeadingOnes(0xFFFFFFFF ^ (1 << i)));
242 EXPECT_EQ(63u - i, countLeadingOnes(0xFFFFFFFFFFFFFFFFULL ^ (1LL << i)));
246 EXPECT_EQ(31u - i, countLeadingOnes(0xFFFFFFFF ^ (1 << i)));
261 EXPECT_EQ(1u, MinAlign(2, 3));
262 EXPECT_EQ(2u, MinAlign(2, 4));
263 EXPECT_EQ(1u, MinAlign(17, 64));
264 EXPECT_EQ(256u, MinAlign(256, 512));
268 EXPECT_EQ(4u, NextPowerOf2(3));
269 EXPECT_EQ(16u, NextPowerOf2(15));
270 EXPECT_EQ(256u, NextPowerOf2(128));
274 EXPECT_EQ(8u, alignTo(5, 8));
275 EXPECT_EQ(24u, alignTo(17, 8));
276 EXPECT_EQ(0u, alignTo(~0LL, 8));
278 EXPECT_EQ(7u, alignTo(5, 8, 7));
279 EXPECT_EQ(17u, alignTo(17, 8, 1));
280 EXPECT_EQ(3u, alignTo(~0LL, 8, 3));
281 EXPECT_EQ(552u, alignTo(321, 255, 42));
290 EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2)));
291 EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2), &ResultOverflowed));
294 EXPECT_EQ(Max, SaturatingAdd(Max, T(1)));
295 EXPECT_EQ(Max, SaturatingAdd(Max, T(1), &ResultOverflowed));
298 EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1)));
299 EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1), &ResultOverflowed));
302 EXPECT_EQ(Max, SaturatingAdd(T(1), Max));
303 EXPECT_EQ(Max, SaturatingAdd(T(1), Max, &ResultOverflowed));
306 EXPECT_EQ(Max, SaturatingAdd(Max, Max));
307 EXPECT_EQ(Max, SaturatingAdd(Max, Max, &ResultOverflowed));
325 EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3)));
326 EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3), &ResultOverflowed));
329 EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2)));
330 EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2), &ResultOverflowed));
334 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0)));
335 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0), &ResultOverflowed));
338 EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0)));
339 EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0), &ResultOverflowed));
342 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1)));
343 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1), &ResultOverflowed));
346 EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0)));
347 EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0), &ResultOverflowed));
350 EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max));
351 EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max, &ResultOverflowed));
355 EXPECT_EQ(Max, SaturatingMultiply(Max, T(2)));
356 EXPECT_EQ(Max, SaturatingMultiply(Max, T(2), &ResultOverflowed));
359 EXPECT_EQ(Max, SaturatingMultiply(T(2), Max));
360 EXPECT_EQ(Max, SaturatingMultiply(T(2), Max, &ResultOverflowed));
363 EXPECT_EQ(Max, SaturatingMultiply(Max, Max));
364 EXPECT_EQ(Max, SaturatingMultiply(Max, Max, &ResultOverflowed));
379 EXPECT_EQ(Max, SaturatingMultiply(X, Y));
380 EXPECT_EQ(Max, SaturatingMultiply(X, Y, &ResultOverflowed));
383 EXPECT_EQ(X * Y, SaturatingMultiply(X, Y));
384 EXPECT_EQ(X * Y, SaturatingMultiply(X, Y, &ResultOverflowed));
405 EXPECT_EQ(T(16), SaturatingMultiplyAdd(T(2), T(3), T(10)));
406 EXPECT_EQ(T(16), SaturatingMultiplyAdd(T(2), T(3), T(10), &ResultOverflowed));
410 EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, T(0), &ResultOverflowed));
414 EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), T(1), Max, &ResultOverflowed));
418 EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), T(1), Max, &ResultOverflowed));
421 EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), Max, T(1), &ResultOverflowed));
424 EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, T(1), &ResultOverflowed));
427 EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, Max, &ResultOverflowed));
431 EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(1), T(1), T(0), &ResultOverflowed));
434 EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(1), T(0), T(1), &ResultOverflowed));
437 EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(0), T(0), T(1), &ResultOverflowed));
440 EXPECT_EQ(T(0), SaturatingMultiplyAdd(T(0), T(0), T(0), &ResultOverflowed));
501 EXPECT_EQ(Result, TypeParam(3));
508 EXPECT_EQ(Result, TypeParam(-2));
515 EXPECT_EQ(Result, std::numeric_limits<TypeParam>::min());
522 EXPECT_EQ(Result, TypeParam(0));
529 EXPECT_EQ(Result, std::numeric_limits<TypeParam>::max());
535 EXPECT_EQ(Result, TypeParam(-1));
542 EXPECT_EQ(Result, MinValue);
549 EXPECT_EQ(Result, MinValue);
557 EXPECT_EQ(Result, TypeParam(-1));
565 EXPECT_EQ(Result, TypeParam(1));
571 EXPECT_EQ(Result, 2);
573 EXPECT_EQ(Result, -3);
575 EXPECT_EQ(Result, -8);
577 EXPECT_EQ(Result, 30);
585 EXPECT_EQ(Result, MaxValue);
592 EXPECT_EQ(Result, MinValue);
600 EXPECT_EQ(Result, 0);
602 EXPECT_EQ(Result, 1);
608 EXPECT_EQ(Result, TypeParam(0));
610 EXPECT_EQ(Result, TypeParam(0));
612 EXPECT_EQ(Result, TypeParam(0));
614 EXPECT_EQ(Result, TypeParam(0));
unittests/Support/MemoryBufferTest.cpp 87 EXPECT_EQ(MB1->getBufferStart(), MB2->getBufferStart());
88 EXPECT_EQ(MB2->getBufferStart(), MB3->getBufferStart());
94 EXPECT_EQ("this is some data", data);
116 EXPECT_EQ("123456", MB.get()->getBuffer());
147 EXPECT_EQ('f', BufData[4095]);
148 EXPECT_EQ('\0', BufData[4096]);
192 EXPECT_EQ(MB.get()->getBuffer(), "foofoofoofoofoo");
213 EXPECT_EQ(0, Three->getBufferStart()[0]);
219 EXPECT_EQ(0, Four->getBufferStart()[0]);
254 EXPECT_EQ(BufData.size(), 40000U);
255 EXPECT_EQ(BufData[0], '0');
256 EXPECT_EQ(BufData[9], '9');
271 EXPECT_EQ(MB->getBufferStart(), MBR.getBufferStart());
272 EXPECT_EQ(MB->getBufferIdentifier(), MBR.getBufferIdentifier());
298 EXPECT_EQ(0x4000UL, MB.get()->getBufferSize());
313 EXPECT_EQ(0x3000UL, MB2.get()->getBufferSize());
352 EXPECT_EQ("0123456789abcdef", MB.getBuffer().substr(i, 0x10)) << "i: " << i;
381 EXPECT_EQ("xxxxxxxxxxxxxxxx", MB.getBuffer());
unittests/Support/MemoryTest.cpp 100 EXPECT_EQ(std::error_code(), EC);
113 EXPECT_EQ(std::error_code(), EC);
128 EXPECT_EQ(std::error_code(), EC);
130 EXPECT_EQ(std::error_code(), EC);
132 EXPECT_EQ(std::error_code(), EC);
148 EXPECT_EQ(std::error_code(), EC);
164 EXPECT_EQ(std::error_code(), EC);
171 EXPECT_EQ(1, *a);
186 EXPECT_EQ(std::error_code(), EC);
189 EXPECT_EQ(std::error_code(), EC);
192 EXPECT_EQ(std::error_code(), EC);
216 EXPECT_EQ(1, *x);
217 EXPECT_EQ(7, y[7]);
218 EXPECT_EQ(42, *z);
225 EXPECT_EQ(std::error_code(), EC);
230 EXPECT_EQ(4, *x);
235 EXPECT_EQ(i, y[i]);
249 EXPECT_EQ(std::error_code(), EC);
252 EXPECT_EQ(std::error_code(), EC);
255 EXPECT_EQ(std::error_code(), EC);
281 EXPECT_EQ(1, *x);
282 EXPECT_EQ(7, y[7]);
283 EXPECT_EQ(42, *z);
287 EXPECT_EQ(6, y[6]);
290 EXPECT_EQ(std::error_code(), EC);
293 EXPECT_EQ(std::error_code(),
297 EXPECT_EQ(4, *x);
306 EXPECT_EQ(std::error_code(), EC);
308 EXPECT_EQ(std::error_code(), EC);
310 EXPECT_EQ(std::error_code(), EC);
333 EXPECT_EQ(std::error_code(), EC);
335 EXPECT_EQ(std::error_code(), EC);
337 EXPECT_EQ(std::error_code(), EC);
356 EXPECT_EQ(std::error_code(), EC);
358 EXPECT_EQ(std::error_code(), EC);
360 EXPECT_EQ(std::error_code(), EC);
383 EXPECT_EQ(std::error_code(), EC);
385 EXPECT_EQ(std::error_code(), EC);
387 EXPECT_EQ(std::error_code(), EC);
410 EXPECT_EQ(std::error_code(), EC);
unittests/Support/NativeFormatTests.cpp 50 EXPECT_EQ("0", format_number(0, IntegerStyle::Integer));
51 EXPECT_EQ("2425", format_number(2425, IntegerStyle::Integer));
52 EXPECT_EQ("-2425", format_number(-2425, IntegerStyle::Integer));
54 EXPECT_EQ("0", format_number(0LL, IntegerStyle::Integer));
55 EXPECT_EQ("257257257235709",
57 EXPECT_EQ("-257257257235709",
61 EXPECT_EQ("0", format_number(0, IntegerStyle::Number));
62 EXPECT_EQ("2,425", format_number(2425, IntegerStyle::Number));
63 EXPECT_EQ("-2,425", format_number(-2425, IntegerStyle::Number));
64 EXPECT_EQ("257,257,257,235,709",
66 EXPECT_EQ("-257,257,257,235,709",
71 EXPECT_EQ("0x0", format_number(0, HexPrintStyle::PrefixLower));
72 EXPECT_EQ("0xbeef", format_number(0xbeefLL, HexPrintStyle::PrefixLower));
73 EXPECT_EQ("0xdeadbeef",
77 EXPECT_EQ("0x0", format_number(0, HexPrintStyle::PrefixUpper));
78 EXPECT_EQ("0xBEEF", format_number(0xbeefLL, HexPrintStyle::PrefixUpper));
79 EXPECT_EQ("0xDEADBEEF",
83 EXPECT_EQ("0", format_number(0, HexPrintStyle::Lower));
84 EXPECT_EQ("beef", format_number(0xbeefLL, HexPrintStyle::Lower));
85 EXPECT_EQ("deadbeef", format_number(0xdeadbeefLL, HexPrintStyle::Lower));
88 EXPECT_EQ("0", format_number(0, HexPrintStyle::Upper));
89 EXPECT_EQ("BEEF", format_number(0xbeef, HexPrintStyle::Upper));
90 EXPECT_EQ("DEADBEEF", format_number(0xdeadbeef, HexPrintStyle::Upper));
97 EXPECT_EQ("0.000000e+00", format_number(0.0, FloatStyle::Exponent));
98 EXPECT_EQ("-0.000000e+00", format_number(-0.0, FloatStyle::Exponent));
99 EXPECT_EQ("1.100000e+00", format_number(1.1, FloatStyle::Exponent));
100 EXPECT_EQ("1.100000E+00", format_number(1.1, FloatStyle::ExponentUpper));
103 EXPECT_EQ("1.10", format_number(1.1, FloatStyle::Fixed));
104 EXPECT_EQ("1.34", format_number(1.34, FloatStyle::Fixed));
105 EXPECT_EQ("1.34", format_number(1.344, FloatStyle::Fixed));
106 EXPECT_EQ("1.35", format_number(1.346, FloatStyle::Fixed));
112 EXPECT_EQ("18446744073709551615",
115 EXPECT_EQ("9223372036854775807",
117 EXPECT_EQ("-9223372036854775808",
120 EXPECT_EQ("4294967295", format_number(UINT32_MAX, IntegerStyle::Integer));
121 EXPECT_EQ("2147483647", format_number(INT32_MAX, IntegerStyle::Integer));
122 EXPECT_EQ("-2147483648", format_number(INT32_MIN, IntegerStyle::Integer));
124 EXPECT_EQ("nan", format_number(std::numeric_limits<double>::quiet_NaN(),
126 EXPECT_EQ("INF", format_number(std::numeric_limits<double>::infinity(),
134 EXPECT_EQ("0x0", format_number(0, HexPrintStyle::PrefixLower, 0));
135 EXPECT_EQ("0xabcde", format_number(0xABCDE, HexPrintStyle::PrefixLower, 3));
141 EXPECT_EQ("0x000", format_number(0, HexPrintStyle::PrefixLower, 5));
142 EXPECT_EQ("0x0abcde", format_number(0xABCDE, HexPrintStyle::PrefixLower, 8));
144 EXPECT_EQ("00000", format_number(0, HexPrintStyle::Lower, 5));
145 EXPECT_EQ("000abcde", format_number(0xABCDE, HexPrintStyle::Lower, 8));
148 EXPECT_EQ("0x00000000000000abcde",
153 EXPECT_EQ("-10", format_number(-10, IntegerStyle::Integer));
154 EXPECT_EQ("-100", format_number(-100, IntegerStyle::Integer));
155 EXPECT_EQ("-1000", format_number(-1000, IntegerStyle::Integer));
156 EXPECT_EQ("-1234567890", format_number(-1234567890, IntegerStyle::Integer));
157 EXPECT_EQ("10", format_number(10, IntegerStyle::Integer));
158 EXPECT_EQ("100", format_number(100, IntegerStyle::Integer));
159 EXPECT_EQ("1000", format_number(1000, IntegerStyle::Integer));
160 EXPECT_EQ("1234567890", format_number(1234567890, IntegerStyle::Integer));
164 EXPECT_EQ("0", format_number(0, IntegerStyle::Number));
165 EXPECT_EQ("10", format_number(10, IntegerStyle::Number));
166 EXPECT_EQ("100", format_number(100, IntegerStyle::Number));
167 EXPECT_EQ("1,000", format_number(1000, IntegerStyle::Number));
168 EXPECT_EQ("1,234,567,890", format_number(1234567890, IntegerStyle::Number));
170 EXPECT_EQ("-10", format_number(-10, IntegerStyle::Number));
171 EXPECT_EQ("-100", format_number(-100, IntegerStyle::Number));
172 EXPECT_EQ("-1,000", format_number(-1000, IntegerStyle::Number));
173 EXPECT_EQ("-1,234,567,890", format_number(-1234567890, IntegerStyle::Number));
unittests/Support/Path.cpp 185 EXPECT_EQ(*sys::path::rbegin(filename), (stem + ext).str());
206 EXPECT_EQ("/", path::filename("/"));
207 EXPECT_EQ("", path::parent_path("/"));
209 EXPECT_EQ("\\", path::filename("c:\\", path::Style::windows));
210 EXPECT_EQ("c:", path::parent_path("c:\\", path::Style::windows));
212 EXPECT_EQ("/", path::filename("///"));
213 EXPECT_EQ("", path::parent_path("///"));
215 EXPECT_EQ("\\", path::filename("c:\\\\", path::Style::windows));
216 EXPECT_EQ("c:", path::parent_path("c:\\\\", path::Style::windows));
218 EXPECT_EQ("bar", path::filename("/foo/bar"));
219 EXPECT_EQ("/foo", path::parent_path("/foo/bar"));
221 EXPECT_EQ("foo", path::filename("/foo"));
222 EXPECT_EQ("/", path::parent_path("/foo"));
224 EXPECT_EQ("foo", path::filename("foo"));
225 EXPECT_EQ("", path::parent_path("foo"));
227 EXPECT_EQ(".", path::filename("foo/"));
228 EXPECT_EQ("foo", path::parent_path("foo/"));
230 EXPECT_EQ("//net", path::filename("//net"));
231 EXPECT_EQ("", path::parent_path("//net"));
233 EXPECT_EQ("/", path::filename("//net/"));
234 EXPECT_EQ("//net", path::parent_path("//net/"));
236 EXPECT_EQ("foo", path::filename("//net/foo"));
237 EXPECT_EQ("//net/", path::parent_path("//net/foo"));
243 EXPECT_EQ("/", path::filename("//"));
244 EXPECT_EQ("", path::parent_path("//"));
246 EXPECT_EQ("\\", path::filename("\\\\", path::Style::windows));
247 EXPECT_EQ("", path::parent_path("\\\\", path::Style::windows));
249 EXPECT_EQ("\\", path::filename("\\\\\\", path::Style::windows));
250 EXPECT_EQ("", path::parent_path("\\\\\\", path::Style::windows));
289 EXPECT_EQ(".", LastComponent);
302 EXPECT_EQ(1u, LastComponent.size());
326 EXPECT_EQ(expected, HomeDir);
346 EXPECT_EQ(nullptr, ::getenv("HOME"));
352 EXPECT_EQ(PwDir, HomeDir);
526 EXPECT_EQ(Expected, Actual);
535 EXPECT_EQ(Expected, Actual);
537 EXPECT_EQ(Expected, Actual);
554 EXPECT_EQ(Expected, Actual);
564 EXPECT_EQ(Expected, Actual);
641 EXPECT_EQ(EC, errc::no_such_file_or_directory);
642 EXPECT_EQ(B.type(), fs::file_type::file_not_found);
727 EXPECT_EQ(Successes, 16);
899 EXPECT_EQ(I.level(), l);
901 EXPECT_EQ(I, E);
1118 EXPECT_EQ(StringRef(mfr.const_data()), Val);
1144 EXPECT_EQ(std::get<1>(T), Win);
1145 EXPECT_EQ(std::get<2>(T), Posix);
1181 EXPECT_EQ(Path1, "foolz/wat");
1183 EXPECT_EQ(Path2, "");
1194 EXPECT_EQ("foolz\\wat",
1196 EXPECT_EQ("", remove_dots(".\\\\\\\\\\", false, path::Style::windows));
1198 EXPECT_EQ("a\\..\\b\\c",
1200 EXPECT_EQ("b\\c", remove_dots(".\\a\\..\\b\\c", true, path::Style::windows));
1201 EXPECT_EQ("c", remove_dots(".\\.\\c", true, path::Style::windows));
1202 EXPECT_EQ("..\\a\\c",
1204 EXPECT_EQ("..\\..\\a\\c",
1209 EXPECT_EQ("c", Path1);
1211 EXPECT_EQ("foolz/wat",
1213 EXPECT_EQ("", remove_dots("./////", false, path::Style::posix));
1215 EXPECT_EQ("a/../b/c", remove_dots("./a/../b/c", false, path::Style::posix));
1216 EXPECT_EQ("b/c", remove_dots("./a/../b/c", true, path::Style::posix));
1217 EXPECT_EQ("c", remove_dots("././c", true, path::Style::posix));
1218 EXPECT_EQ("../a/c", remove_dots("../a/b/../c", true, path::Style::posix));
1219 EXPECT_EQ("../../a/c",
1221 EXPECT_EQ("/a/c", remove_dots("/../../a/c", true, path::Style::posix));
1222 EXPECT_EQ("/a/c",
1227 EXPECT_EQ("c", Path2);
1240 EXPECT_EQ(Path, "/foo");
1243 EXPECT_EQ(Path, "/new/foo");
1246 EXPECT_EQ(Path, "/longernew/foo");
1249 EXPECT_EQ(Path, "/new/foo");
1252 EXPECT_EQ(Path, "/foo");
1348 EXPECT_EQ(0ULL, Status.getSize());
1564 EXPECT_EQ(TestDirectoryIsLocal, fs::is_local(TestDirectory));
1577 EXPECT_EQ(TempFileIsLocal, fs::is_local(FD));
1582 EXPECT_EQ(TestDirectoryIsLocal, TempFileIsLocal);
1591 EXPECT_EQ(CurrentMask, 0022U)
1593 EXPECT_EQ(::umask(OldMask), 0022U) << "getUmask() may have changed umask()";
1611 EXPECT_EQ(Perms.get(), AllRWE) << "Should have ignored umask by default";
1617 EXPECT_EQ(Perms.get(), AllRWE) << "Should have ignored umask";
1623 EXPECT_EQ(Perms.get(), static_cast<fs::perms>(0755))
1632 EXPECT_EQ(Perms.get(), static_cast<fs::perms>(0720))
1677 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_all), NoError);
1680 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read | fs::all_exe), NoError);
1757 EXPECT_EQ(fs::setPermissions(TempPath, fs::no_perms), NoError);
1760 EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_read), NoError);
1763 EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_write), NoError);
1766 EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_exe), NoError);
1769 EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_all), NoError);
1772 EXPECT_EQ(fs::setPermissions(TempPath, fs::group_read), NoError);
1775 EXPECT_EQ(fs::setPermissions(TempPath, fs::group_write), NoError);
1778 EXPECT_EQ(fs::setPermissions(TempPath, fs::group_exe), NoError);
1781 EXPECT_EQ(fs::setPermissions(TempPath, fs::group_all), NoError);
1784 EXPECT_EQ(fs::setPermissions(TempPath, fs::others_read), NoError);
1787 EXPECT_EQ(fs::setPermissions(TempPath, fs::others_write), NoError);
1790 EXPECT_EQ(fs::setPermissions(TempPath, fs::others_exe), NoError);
1793 EXPECT_EQ(fs::setPermissions(TempPath, fs::others_all), NoError);
1796 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read), NoError);
1799 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_write), NoError);
1802 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_exe), NoError);
1805 EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe), NoError);
1808 EXPECT_EQ(fs::setPermissions(TempPath, fs::set_gid_on_exe), NoError);
1816 EXPECT_EQ(fs::setPermissions(TempPath, fs::sticky_bit), NoError);
1819 EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe |
1826 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read | fs::set_uid_on_exe |
1833 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_perms), NoError);
1837 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_perms & ~fs::sticky_bit),
unittests/Support/ProgramTest.cpp 189 EXPECT_EQ(0, rc);
227 EXPECT_EQ(LoopCount, 1u) << "LoopCount should be 1";
unittests/Support/RegexTest.cpp 29 EXPECT_EQ(1u, Matches.size());
30 EXPECT_EQ("216", Matches[0].str());
34 EXPECT_EQ(3u, Matches.size());
35 EXPECT_EQ("9a:513", Matches[0].str());
36 EXPECT_EQ("a", Matches[1].str());
37 EXPECT_EQ("513", Matches[2].str());
40 EXPECT_EQ(3u, Matches.size());
41 EXPECT_EQ("9:513", Matches[0].str());
42 EXPECT_EQ("", Matches[1].str());
43 EXPECT_EQ("513", Matches[2].str());
50 EXPECT_EQ(1u, Matches.size());
51 EXPECT_EQ(String, Matches[0].str());
67 EXPECT_EQ(2u, Matches.size());
72 EXPECT_EQ(2u, Matches.size());
73 EXPECT_EQ("4", Matches[1].str());
78 EXPECT_EQ(3u, Matches.size());
79 EXPECT_EQ("6", Matches[1].str());
80 EXPECT_EQ("z", Matches[2].str());
88 EXPECT_EQ("aNUMber", Regex("[0-9]+").sub("NUM", "a1234ber"));
91 EXPECT_EQ("a\\ber", Regex("[0-9]+").sub("\\\\", "a1234ber", &Error));
92 EXPECT_EQ("", Error);
93 EXPECT_EQ("a\nber", Regex("[0-9]+").sub("\\n", "a1234ber", &Error));
94 EXPECT_EQ("", Error);
95 EXPECT_EQ("a\tber", Regex("[0-9]+").sub("\\t", "a1234ber", &Error));
96 EXPECT_EQ("", Error);
97 EXPECT_EQ("ajber", Regex("[0-9]+").sub("\\j", "a1234ber", &Error));
98 EXPECT_EQ("", Error);
100 EXPECT_EQ("aber", Regex("[0-9]+").sub("\\", "a1234ber", &Error));
101 EXPECT_EQ(Error, "replacement string contained trailing backslash");
104 EXPECT_EQ("aa1234bber", Regex("a[0-9]+b").sub("a\\0b", "a1234ber", &Error));
105 EXPECT_EQ("", Error);
107 EXPECT_EQ("a1234ber", Regex("a([0-9]+)b").sub("a\\1b", "a1234ber", &Error));
108 EXPECT_EQ("", Error);
110 EXPECT_EQ("aber", Regex("a[0-9]+b").sub("a\\100b", "a1234ber", &Error));
111 EXPECT_EQ(Error, "invalid backreference string '100'");
130 EXPECT_EQ("a\\[bc\\]", Regex::escape("a[bc]"));
131 EXPECT_EQ("abc\\{1\\\\,2\\}", Regex::escape("abc{1\\,2}"));
137 EXPECT_EQ("parentheses not balanced", Error);
139 EXPECT_EQ("invalid character range", Error);
161 EXPECT_EQ("invalid regular expression", Error);
unittests/Support/ScaledNumberTest.cpp 42 EXPECT_EQ(getRounded32(0, 0, false), SP32(0, 0));
43 EXPECT_EQ(getRounded32(0, 0, true), SP32(1, 0));
44 EXPECT_EQ(getRounded32(20, 21, true), SP32(21, 21));
45 EXPECT_EQ(getRounded32(UINT32_MAX, 0, false), SP32(UINT32_MAX, 0));
46 EXPECT_EQ(getRounded32(UINT32_MAX, 0, true), SP32(1 << 31, 1));
48 EXPECT_EQ(getRounded64(0, 0, false), SP64(0, 0));
49 EXPECT_EQ(getRounded64(0, 0, true), SP64(1, 0));
50 EXPECT_EQ(getRounded64(20, 21, true), SP64(21, 21));
51 EXPECT_EQ(getRounded64(UINT32_MAX, 0, false), SP64(UINT32_MAX, 0));
52 EXPECT_EQ(getRounded64(UINT32_MAX, 0, true), SP64(UINT64_C(1) << 32, 0));
53 EXPECT_EQ(getRounded64(UINT64_MAX, 0, false), SP64(UINT64_MAX, 0));
54 EXPECT_EQ(getRounded64(UINT64_MAX, 0, true), SP64(UINT64_C(1) << 63, 1));
59 EXPECT_EQ(getAdjusted32(0), SP32(0, 0));
60 EXPECT_EQ(getAdjusted32(0, 5), SP32(0, 5));
61 EXPECT_EQ(getAdjusted32(UINT32_MAX), SP32(UINT32_MAX, 0));
62 EXPECT_EQ(getAdjusted32(Max32In64 << 1), SP32(UINT32_MAX, 1));
63 EXPECT_EQ(getAdjusted32(Max32In64 << 1, 1), SP32(UINT32_MAX, 2));
64 EXPECT_EQ(getAdjusted32(Max32In64 << 31), SP32(UINT32_MAX, 31));
65 EXPECT_EQ(getAdjusted32(Max32In64 << 32), SP32(UINT32_MAX, 32));
66 EXPECT_EQ(getAdjusted32(Max32In64 + 1), SP32(1u << 31, 1));
67 EXPECT_EQ(getAdjusted32(UINT64_MAX), SP32(1u << 31, 33));
69 EXPECT_EQ(getAdjusted64(0), SP64(0, 0));
70 EXPECT_EQ(getAdjusted64(0, 5), SP64(0, 5));
71 EXPECT_EQ(getAdjusted64(UINT32_MAX), SP64(UINT32_MAX, 0));
72 EXPECT_EQ(getAdjusted64(Max32In64 << 1), SP64(Max32In64 << 1, 0));
73 EXPECT_EQ(getAdjusted64(Max32In64 << 1, 1), SP64(Max32In64 << 1, 1));
74 EXPECT_EQ(getAdjusted64(Max32In64 << 31), SP64(Max32In64 << 31, 0));
75 EXPECT_EQ(getAdjusted64(Max32In64 << 32), SP64(Max32In64 << 32, 0));
76 EXPECT_EQ(getAdjusted64(Max32In64 + 1), SP64(Max32In64 + 1, 0));
77 EXPECT_EQ(getAdjusted64(UINT64_MAX), SP64(UINT64_MAX, 0));
82 EXPECT_EQ(SP32(0, 0), getProduct32(0, 0));
83 EXPECT_EQ(SP32(0, 0), getProduct32(0, 1));
84 EXPECT_EQ(SP32(0, 0), getProduct32(0, 33));
87 EXPECT_EQ(SP32(6, 0), getProduct32(2, 3));
88 EXPECT_EQ(SP32(UINT16_MAX / 3 * UINT16_MAX / 5 * 2, 0),
96 EXPECT_EQ(SP32(0xf00f1001, 4), getProduct32(0xf00010, 0x1001));
103 EXPECT_EQ(SP32(0xf00f0700, 8), getProduct32(0xf000070, 0x1001));
110 EXPECT_EQ(SP32(0xf00f0801, 8), getProduct32(0xf000080, 0x1001));
113 EXPECT_EQ(SP32(0, 0), getProduct32(1, 0));
114 EXPECT_EQ(SP32(0, 0), getProduct32(33, 0));
115 EXPECT_EQ(SP32(6, 0), getProduct32(3, 2));
116 EXPECT_EQ(SP32(UINT16_MAX / 3 * UINT16_MAX / 5 * 2, 0),
118 EXPECT_EQ(SP32(0xf00f1001, 4), getProduct32(0x1001, 0xf00010));
119 EXPECT_EQ(SP32(0xf00f0700, 8), getProduct32(0x1001, 0xf000070));
120 EXPECT_EQ(SP32(0xf00f0801, 8), getProduct32(0x1001, 0xf000080));
123 EXPECT_EQ(SP64(UINT64_C(1) << 63, 64),
128 EXPECT_EQ(SP64(UINT64_C(9223372036854775810), 64),
135 EXPECT_EQ(SP32(0, 0), getQuotient32(0, 0));
136 EXPECT_EQ(SP32(0, 0), getQuotient32(0, 1));
137 EXPECT_EQ(SP32(0, 0), getQuotient32(0, 73));
138 EXPECT_EQ(SP32(UINT32_MAX, MaxScale), getQuotient32(1, 0));
139 EXPECT_EQ(SP32(UINT32_MAX, MaxScale), getQuotient32(6, 0));
142 EXPECT_EQ(SP32(1u << 31, -31), getQuotient32(1, 1));
143 EXPECT_EQ(SP32(1u << 31, -30), getQuotient32(2, 1));
144 EXPECT_EQ(SP32(1u << 31, -33), getQuotient32(4, 16));
145 EXPECT_EQ(SP32(7u << 29, -29), getQuotient32(7, 1));
146 EXPECT_EQ(SP32(7u << 29, -30), getQuotient32(7, 2));
147 EXPECT_EQ(SP32(7u << 29, -33), getQuotient32(7, 16));
150 EXPECT_EQ(SP32(3u << 30, -30), getQuotient32(9, 3));
151 EXPECT_EQ(SP32(9u << 28, -28), getQuotient32(63, 7));
154 EXPECT_EQ(SP32(0xaaaaaaab, -33), getQuotient32(1, 3));
155 EXPECT_EQ(SP32(0xd5555555, -31), getQuotient32(5, 3));
169 EXPECT_EQ(SP64(0, 0), getQuotient64(0, 0));
170 EXPECT_EQ(SP64(0, 0), getQuotient64(0, 1));
171 EXPECT_EQ(SP64(0, 0), getQuotient64(0, 73));
172 EXPECT_EQ(SP64(UINT64_MAX, MaxScale), getQuotient64(1, 0));
173 EXPECT_EQ(SP64(UINT64_MAX, MaxScale), getQuotient64(6, 0));
176 EXPECT_EQ(SP64(1, 0), getQuotient64(1, 1));
177 EXPECT_EQ(SP64(2, 0), getQuotient64(2, 1));
178 EXPECT_EQ(SP64(4, -4), getQuotient64(4, 16));
179 EXPECT_EQ(SP64(7, 0), getQuotient64(7, 1));
180 EXPECT_EQ(SP64(7, -1), getQuotient64(7, 2));
181 EXPECT_EQ(SP64(7, -4), getQuotient64(7, 16));
184 EXPECT_EQ(SP64(UINT64_C(3) << 60, -60), getQuotient64(9, 3));
185 EXPECT_EQ(SP64(UINT64_C(9) << 58, -58), getQuotient64(63, 7));
188 EXPECT_EQ(SP64(0xaaaaaaaaaaaaaaab, -65), getQuotient64(1, 3));
189 EXPECT_EQ(SP64(0xd555555555555555, -63), getQuotient64(5, 3));
193 EXPECT_EQ(0, getLg(UINT32_C(1), 0));
194 EXPECT_EQ(1, getLg(UINT32_C(1), 1));
195 EXPECT_EQ(1, getLg(UINT32_C(2), 0));
196 EXPECT_EQ(3, getLg(UINT32_C(1), 3));
197 EXPECT_EQ(3, getLg(UINT32_C(7), 0));
198 EXPECT_EQ(3, getLg(UINT32_C(8), 0));
199 EXPECT_EQ(3, getLg(UINT32_C(9), 0));
200 EXPECT_EQ(3, getLg(UINT32_C(64), -3));
201 EXPECT_EQ(31, getLg((UINT32_MAX >> 1) + 2, 0));
202 EXPECT_EQ(32, getLg(UINT32_MAX, 0));
203 EXPECT_EQ(-1, getLg(UINT32_C(1), -1));
204 EXPECT_EQ(-1, getLg(UINT32_C(2), -2));
205 EXPECT_EQ(INT32_MIN, getLg(UINT32_C(0), -1));
206 EXPECT_EQ(INT32_MIN, getLg(UINT32_C(0), 0));
207 EXPECT_EQ(INT32_MIN, getLg(UINT32_C(0), 1));
209 EXPECT_EQ(0, getLg(UINT64_C(1), 0));
210 EXPECT_EQ(1, getLg(UINT64_C(1), 1));
211 EXPECT_EQ(1, getLg(UINT64_C(2), 0));
212 EXPECT_EQ(3, getLg(UINT64_C(1), 3));
213 EXPECT_EQ(3, getLg(UINT64_C(7), 0));
214 EXPECT_EQ(3, getLg(UINT64_C(8), 0));
215 EXPECT_EQ(3, getLg(UINT64_C(9), 0));
216 EXPECT_EQ(3, getLg(UINT64_C(64), -3));
217 EXPECT_EQ(63, getLg((UINT64_MAX >> 1) + 2, 0));
218 EXPECT_EQ(64, getLg(UINT64_MAX, 0));
219 EXPECT_EQ(-1, getLg(UINT64_C(1), -1));
220 EXPECT_EQ(-1, getLg(UINT64_C(2), -2));
221 EXPECT_EQ(INT32_MIN, getLg(UINT64_C(0), -1));
222 EXPECT_EQ(INT32_MIN, getLg(UINT64_C(0), 0));
223 EXPECT_EQ(INT32_MIN, getLg(UINT64_C(0), 1));
227 EXPECT_EQ(0, getLgFloor(UINT32_C(1), 0));
228 EXPECT_EQ(1, getLgFloor(UINT32_C(1), 1));
229 EXPECT_EQ(1, getLgFloor(UINT32_C(2), 0));
230 EXPECT_EQ(2, getLgFloor(UINT32_C(7), 0));
231 EXPECT_EQ(3, getLgFloor(UINT32_C(1), 3));
232 EXPECT_EQ(3, getLgFloor(UINT32_C(8), 0));
233 EXPECT_EQ(3, getLgFloor(UINT32_C(9), 0));
234 EXPECT_EQ(3, getLgFloor(UINT32_C(64), -3));
235 EXPECT_EQ(31, getLgFloor((UINT32_MAX >> 1) + 2, 0));
236 EXPECT_EQ(31, getLgFloor(UINT32_MAX, 0));
237 EXPECT_EQ(INT32_MIN, getLgFloor(UINT32_C(0), -1));
238 EXPECT_EQ(INT32_MIN, getLgFloor(UINT32_C(0), 0));
239 EXPECT_EQ(INT32_MIN, getLgFloor(UINT32_C(0), 1));
241 EXPECT_EQ(0, getLgFloor(UINT64_C(1), 0));
242 EXPECT_EQ(1, getLgFloor(UINT64_C(1), 1));
243 EXPECT_EQ(1, getLgFloor(UINT64_C(2), 0));
244 EXPECT_EQ(2, getLgFloor(UINT64_C(7), 0));
245 EXPECT_EQ(3, getLgFloor(UINT64_C(1), 3));
246 EXPECT_EQ(3, getLgFloor(UINT64_C(8), 0));
247 EXPECT_EQ(3, getLgFloor(UINT64_C(9), 0));
248 EXPECT_EQ(3, getLgFloor(UINT64_C(64), -3));
249 EXPECT_EQ(63, getLgFloor((UINT64_MAX >> 1) + 2, 0));
250 EXPECT_EQ(63, getLgFloor(UINT64_MAX, 0));
251 EXPECT_EQ(INT32_MIN, getLgFloor(UINT64_C(0), -1));
252 EXPECT_EQ(INT32_MIN, getLgFloor(UINT64_C(0), 0));
253 EXPECT_EQ(INT32_MIN, getLgFloor(UINT64_C(0), 1));
257 EXPECT_EQ(0, getLgCeiling(UINT32_C(1), 0));
258 EXPECT_EQ(1, getLgCeiling(UINT32_C(1), 1));
259 EXPECT_EQ(1, getLgCeiling(UINT32_C(2), 0));
260 EXPECT_EQ(3, getLgCeiling(UINT32_C(1), 3));
261 EXPECT_EQ(3, getLgCeiling(UINT32_C(7), 0));
262 EXPECT_EQ(3, getLgCeiling(UINT32_C(8), 0));
263 EXPECT_EQ(3, getLgCeiling(UINT32_C(64), -3));
264 EXPECT_EQ(4, getLgCeiling(UINT32_C(9), 0));
265 EXPECT_EQ(32, getLgCeiling(UINT32_MAX, 0));
266 EXPECT_EQ(32, getLgCeiling((UINT32_MAX >> 1) + 2, 0));
267 EXPECT_EQ(INT32_MIN, getLgCeiling(UINT32_C(0), -1));
268 EXPECT_EQ(INT32_MIN, getLgCeiling(UINT32_C(0), 0));
269 EXPECT_EQ(INT32_MIN, getLgCeiling(UINT32_C(0), 1));
271 EXPECT_EQ(0, getLgCeiling(UINT64_C(1), 0));
272 EXPECT_EQ(1, getLgCeiling(UINT64_C(1), 1));
273 EXPECT_EQ(1, getLgCeiling(UINT64_C(2), 0));
274 EXPECT_EQ(3, getLgCeiling(UINT64_C(1), 3));
275 EXPECT_EQ(3, getLgCeiling(UINT64_C(7), 0));
276 EXPECT_EQ(3, getLgCeiling(UINT64_C(8), 0));
277 EXPECT_EQ(3, getLgCeiling(UINT64_C(64), -3));
278 EXPECT_EQ(4, getLgCeiling(UINT64_C(9), 0));
279 EXPECT_EQ(64, getLgCeiling((UINT64_MAX >> 1) + 2, 0));
280 EXPECT_EQ(64, getLgCeiling(UINT64_MAX, 0));
281 EXPECT_EQ(INT32_MIN, getLgCeiling(UINT64_C(0), -1));
282 EXPECT_EQ(INT32_MIN, getLgCeiling(UINT64_C(0), 0));
283 EXPECT_EQ(INT32_MIN, getLgCeiling(UINT64_C(0), 1));
287 EXPECT_EQ(0, compare(UINT32_C(0), 0, UINT32_C(0), 1));
288 EXPECT_EQ(0, compare(UINT32_C(0), 0, UINT32_C(0), -10));
289 EXPECT_EQ(0, compare(UINT32_C(0), 0, UINT32_C(0), 20));
290 EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(64), -3));
291 EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(32), -2));
292 EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(16), -1));
293 EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(8), 0));
294 EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(4), 1));
295 EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(2), 2));
296 EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(1), 3));
297 EXPECT_EQ(-1, compare(UINT32_C(0), 0, UINT32_C(1), 3));
298 EXPECT_EQ(-1, compare(UINT32_C(7), 0, UINT32_C(1), 3));
299 EXPECT_EQ(-1, compare(UINT32_C(7), 0, UINT32_C(64), -3));
300 EXPECT_EQ(1, compare(UINT32_C(9), 0, UINT32_C(1), 3));
301 EXPECT_EQ(1, compare(UINT32_C(9), 0, UINT32_C(64), -3));
302 EXPECT_EQ(1, compare(UINT32_C(9), 0, UINT32_C(0), 0));
304 EXPECT_EQ(0, compare(UINT64_C(0), 0, UINT64_C(0), 1));
305 EXPECT_EQ(0, compare(UINT64_C(0), 0, UINT64_C(0), -10));
306 EXPECT_EQ(0, compare(UINT64_C(0), 0, UINT64_C(0), 20));
307 EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(64), -3));
308 EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(32), -2));
309 EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(16), -1));
310 EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(8), 0));
311 EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(4), 1));
312 EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(2), 2));
313 EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(1), 3));
314 EXPECT_EQ(-1, compare(UINT64_C(0), 0, UINT64_C(1), 3));
315 EXPECT_EQ(-1, compare(UINT64_C(7), 0, UINT64_C(1), 3));
316 EXPECT_EQ(-1, compare(UINT64_C(7), 0, UINT64_C(64), -3));
317 EXPECT_EQ(1, compare(UINT64_C(9), 0, UINT64_C(1), 3));
318 EXPECT_EQ(1, compare(UINT64_C(9), 0, UINT64_C(64), -3));
319 EXPECT_EQ(1, compare(UINT64_C(9), 0, UINT64_C(0), 0));
320 EXPECT_EQ(-1, compare(UINT64_MAX, 0, UINT64_C(1), 64));
388 EXPECT_EQ(SP32(1, 0), getSum32(0, 0, 1, 0));
389 EXPECT_EQ(SP32(8, -3), getSum32(0, 0, 8, -3));
390 EXPECT_EQ(SP32(UINT32_MAX, 0), getSum32(0, 0, UINT32_MAX, 0));
393 EXPECT_EQ(SP32(2, 0), getSum32(1, 0, 1, 0));
394 EXPECT_EQ(SP32(3, 0), getSum32(1, 0, 2, 0));
395 EXPECT_EQ(SP32(67, 0), getSum32(7, 0, 60, 0));
398 EXPECT_EQ(SP32(3, 0), getSum32(1, 0, 1, 1));
399 EXPECT_EQ(SP32(4, 0), getSum32(2, 0, 1, 1));
402 EXPECT_EQ(SP32(UINT32_C(1) << 31, 1), getSum32(1, 32, 1, 0));
403 EXPECT_EQ(SP32(UINT32_C(1) << 31, -31), getSum32(1, -32, 1, 0));
406 EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, 1), getSum32(1, 32, 1, 1));
407 EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, -32), getSum32(1, -32, 1, -1));
410 EXPECT_EQ(SP32(UINT32_C(1) << 31, 1), getSum32(1, 0, UINT32_MAX, 0));
413 EXPECT_EQ(SP32(1, 0), getSum32(1, 0, 0, 0));
414 EXPECT_EQ(SP32(8, -3), getSum32(8, -3, 0, 0));
415 EXPECT_EQ(SP32(UINT32_MAX, 0), getSum32(UINT32_MAX, 0, 0, 0));
416 EXPECT_EQ(SP32(3, 0), getSum32(2, 0, 1, 0));
417 EXPECT_EQ(SP32(67, 0), getSum32(60, 0, 7, 0));
418 EXPECT_EQ(SP32(3, 0), getSum32(1, 1, 1, 0));
419 EXPECT_EQ(SP32(4, 0), getSum32(1, 1, 2, 0));
420 EXPECT_EQ(SP32(UINT32_C(1) << 31, 1), getSum32(1, 0, 1, 32));
421 EXPECT_EQ(SP32(UINT32_C(1) << 31, -31), getSum32(1, 0, 1, -32));
422 EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, 1), getSum32(1, 1, 1, 32));
423 EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, -32), getSum32(1, -1, 1, -32));
424 EXPECT_EQ(SP32(UINT32_C(1) << 31, 1), getSum32(UINT32_MAX, 0, 1, 0));
427 EXPECT_EQ(SP64(1, 0), getSum64(0, 0, 1, 0));
428 EXPECT_EQ(SP64(8, -3), getSum64(0, 0, 8, -3));
429 EXPECT_EQ(SP64(UINT64_MAX, 0), getSum64(0, 0, UINT64_MAX, 0));
432 EXPECT_EQ(SP64(2, 0), getSum64(1, 0, 1, 0));
433 EXPECT_EQ(SP64(3, 0), getSum64(1, 0, 2, 0));
434 EXPECT_EQ(SP64(67, 0), getSum64(7, 0, 60, 0));
437 EXPECT_EQ(SP64(3, 0), getSum64(1, 0, 1, 1));
438 EXPECT_EQ(SP64(4, 0), getSum64(2, 0, 1, 1));
441 EXPECT_EQ(SP64(UINT64_C(1) << 63, 1), getSum64(1, 64, 1, 0));
442 EXPECT_EQ(SP64(UINT64_C(1) << 63, -63), getSum64(1, -64, 1, 0));
445 EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, 1), getSum64(1, 64, 1, 1));
446 EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, -64), getSum64(1, -64, 1, -1));
449 EXPECT_EQ(SP64(UINT64_C(1) << 63, 1), getSum64(1, 0, UINT64_MAX, 0));
452 EXPECT_EQ(SP64(1, 0), getSum64(1, 0, 0, 0));
453 EXPECT_EQ(SP64(8, -3), getSum64(8, -3, 0, 0));
454 EXPECT_EQ(SP64(UINT64_MAX, 0), getSum64(UINT64_MAX, 0, 0, 0));
455 EXPECT_EQ(SP64(3, 0), getSum64(2, 0, 1, 0));
456 EXPECT_EQ(SP64(67, 0), getSum64(60, 0, 7, 0));
457 EXPECT_EQ(SP64(3, 0), getSum64(1, 1, 1, 0));
458 EXPECT_EQ(SP64(4, 0), getSum64(1, 1, 2, 0));
459 EXPECT_EQ(SP64(UINT64_C(1) << 63, 1), getSum64(1, 0, 1, 64));
460 EXPECT_EQ(SP64(UINT64_C(1) << 63, -63), getSum64(1, 0, 1, -64));
461 EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, 1), getSum64(1, 1, 1, 64));
462 EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, -64), getSum64(1, -1, 1, -64));
463 EXPECT_EQ(SP64(UINT64_C(1) << 63, 1), getSum64(UINT64_MAX, 0, 1, 0));
468 EXPECT_EQ(SP32(0, 0), getDifference32(1, 0, 1, 0));
469 EXPECT_EQ(SP32(1, 0), getDifference32(2, 0, 1, 0));
470 EXPECT_EQ(SP32(53, 0), getDifference32(60, 0, 7, 0));
473 EXPECT_EQ(SP32(0, 0), getDifference32(2, 0, 1, 1));
476 EXPECT_EQ(SP32(1, 0), getDifference32(1, 0, 0, 0));
477 EXPECT_EQ(SP32(8, -3), getDifference32(8, -3, 0, 0));
478 EXPECT_EQ(SP32(UINT32_MAX, 0), getDifference32(UINT32_MAX, 0, 0, 0));
481 EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, 1),
483 EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, -31),
487 EXPECT_EQ(SP32(UINT32_MAX, 0), getDifference32(1, 32, 1, 0));
488 EXPECT_EQ(SP32(UINT32_MAX, -32), getDifference32(1, 0, 1, -32));
491 EXPECT_EQ(SP32(0, 0), getDifference32(0, 0, 1, 0));
492 EXPECT_EQ(SP32(0, 0), getDifference32(0, 0, 8, -3));
493 EXPECT_EQ(SP32(0, 0), getDifference32(0, 0, UINT32_MAX, 0));
494 EXPECT_EQ(SP32(0, 0), getDifference32(7, 0, 60, 0));
495 EXPECT_EQ(SP32(0, 0), getDifference32(1, 0, 1, 1));
496 EXPECT_EQ(SP32(0, 0), getDifference32(1, -32, 1, 0));
497 EXPECT_EQ(SP32(0, 0), getDifference32(1, -32, 1, -1));
500 EXPECT_EQ(SP32(UINT32_C(1) << 26, -31),
504 EXPECT_EQ(SP64(0, 0), getDifference64(1, 0, 1, 0));
505 EXPECT_EQ(SP64(1, 0), getDifference64(2, 0, 1, 0));
506 EXPECT_EQ(SP64(53, 0), getDifference64(60, 0, 7, 0));
509 EXPECT_EQ(SP64(0, 0), getDifference64(2, 0, 1, 1));
512 EXPECT_EQ(SP64(1, 0), getDifference64(1, 0, 0, 0));
513 EXPECT_EQ(SP64(8, -3), getDifference64(8, -3, 0, 0));
514 EXPECT_EQ(SP64(UINT64_MAX, 0), getDifference64(UINT64_MAX, 0, 0, 0));
517 EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, 1),
519 EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, -63),
523 EXPECT_EQ(SP64(UINT64_MAX, 0), getDifference64(1, 64, 1, 0));
524 EXPECT_EQ(SP64(UINT64_MAX, -64), getDifference64(1, 0, 1, -64));
527 EXPECT_EQ(SP64(0, 0), getDifference64(0, 0, 1, 0));
528 EXPECT_EQ(SP64(0, 0), getDifference64(0, 0, 8, -3));
529 EXPECT_EQ(SP64(0, 0), getDifference64(0, 0, UINT64_MAX, 0));
530 EXPECT_EQ(SP64(0, 0), getDifference64(7, 0, 60, 0));
531 EXPECT_EQ(SP64(0, 0), getDifference64(1, 0, 1, 1));
532 EXPECT_EQ(SP64(0, 0), getDifference64(1, -64, 1, 0));
533 EXPECT_EQ(SP64(0, 0), getDifference64(1, -64, 1, -1));
537 EXPECT_EQ(ScaledNumber<uint32_t>(10, 0),
539 EXPECT_EQ(ScaledNumber<uint32_t>(6, 0),
541 EXPECT_EQ(ScaledNumber<uint32_t>(2, 3),
543 EXPECT_EQ(ScaledNumber<uint32_t>(1, 2),
545 EXPECT_EQ(ScaledNumber<uint32_t>(1, 2), ScaledNumber<uint32_t>(1, 3) >> 1);
546 EXPECT_EQ(ScaledNumber<uint32_t>(1, 4), ScaledNumber<uint32_t>(1, 3) << 1);
548 EXPECT_EQ(ScaledNumber<uint64_t>(10, 0),
550 EXPECT_EQ(ScaledNumber<uint64_t>(6, 0),
552 EXPECT_EQ(ScaledNumber<uint64_t>(2, 3),
554 EXPECT_EQ(ScaledNumber<uint64_t>(1, 2),
556 EXPECT_EQ(ScaledNumber<uint64_t>(1, 2), ScaledNumber<uint64_t>(1, 3) >> 1);
557 EXPECT_EQ(ScaledNumber<uint64_t>(1, 4), ScaledNumber<uint64_t>(1, 3) << 1);
562 EXPECT_EQ(1u, (n * n).toInt<uint32_t>());
unittests/Support/SourceMgrTest.cpp 53 EXPECT_EQ("file.in:1:5: error: message\n"
63 EXPECT_EQ("file.in:1:5: warning: message\n"
73 EXPECT_EQ("file.in:1:5: remark: message\n"
83 EXPECT_EQ("file.in:1:5: note: message\n"
93 EXPECT_EQ("file.in:1:7: error: message\n"
103 EXPECT_EQ("file.in:1:8: error: message\n"
113 EXPECT_EQ("file.in:1:1: error: message\n"
123 EXPECT_EQ("file.in:1:1: error: message\n"
133 EXPECT_EQ("file.in:2:1: error: message\n"
143 EXPECT_EQ("file.in:1:4: error: message\n"
153 EXPECT_EQ("file.in:1:4: error: message\n"
163 EXPECT_EQ("file.in:1:5: error: message\n"
173 EXPECT_EQ("file.in:2:1: error: message\n"
183 EXPECT_EQ("file.in:2:1: error: message\n"
193 EXPECT_EQ("file.in:2:5: error: message\n"
222 EXPECT_EQ("file.in:24:1: error: message\n"
233 EXPECT_EQ("file.in:24:2: error: message\n"
244 EXPECT_EQ("file.in:24:3: error: message\n"
255 EXPECT_EQ("file.in:24:1: error: message\n"
266 EXPECT_EQ("file.in:24:2: error: message\n"
277 EXPECT_EQ("file.in:25:1: error: message\n"
292 EXPECT_EQ("file.in:24:2: error: message\n"
303 EXPECT_EQ("file.in:24:3: error: message\n"
314 EXPECT_EQ("file.in:24:4: error: message\n"
325 EXPECT_EQ("file.in:24:2: error: message\n"
336 EXPECT_EQ("file.in:24:3: error: message\n"
347 EXPECT_EQ("file.in:25:1: error: message\n"
362 EXPECT_EQ("file.in:24:3: error: message\n"
373 EXPECT_EQ("file.in:24:4: error: message\n"
384 EXPECT_EQ("file.in:24:5: error: message\n"
395 EXPECT_EQ("file.in:24:3: error: message\n"
406 EXPECT_EQ("file.in:24:4: error: message\n"
417 EXPECT_EQ("file.in:25:1: error: message\n"
427 EXPECT_EQ("file.in:1:5: error: message\n"
437 EXPECT_EQ("file.in:1:5: error: message\n"
447 EXPECT_EQ("file.in:1:5: error: message\n"
458 EXPECT_EQ("file.in:1:5: error: message\n"
469 EXPECT_EQ("file.in:1:5: error: message\n"
480 EXPECT_EQ("file.in:1:5: error: message\n"
492 EXPECT_EQ("file.in:1:4: error: message\n"
unittests/Support/SpecialCaseListTest.cpp 61 EXPECT_EQ(3u, SCL->inSectionBlame("", "src", "hello"));
62 EXPECT_EQ(4u, SCL->inSectionBlame("", "src", "bye"));
63 EXPECT_EQ(5u, SCL->inSectionBlame("", "src", "hi", "category"));
64 EXPECT_EQ(6u, SCL->inSectionBlame("", "src", "zzzz", "category"));
65 EXPECT_EQ(0u, SCL->inSectionBlame("", "src", "hi"));
66 EXPECT_EQ(0u, SCL->inSectionBlame("", "fun", "hello"));
67 EXPECT_EQ(0u, SCL->inSectionBlame("", "src", "hello", "category"));
72 EXPECT_EQ(nullptr, makeSpecialCaseList("# This is a comment.\n"
79 EXPECT_EQ(nullptr, makeSpecialCaseList("\n\n\n"
88 EXPECT_EQ(makeSpecialCaseList("[address", Error), nullptr);
91 EXPECT_EQ(makeSpecialCaseList("[[]", Error), nullptr);
94 EXPECT_EQ(makeSpecialCaseList("src:=", Error), nullptr);
153 EXPECT_EQ(nullptr, makeSpecialCaseList("badline", Error));
154 EXPECT_EQ("malformed line 1: 'badline'", Error);
155 EXPECT_EQ(nullptr, makeSpecialCaseList("src:bad[a-", Error));
156 EXPECT_EQ("malformed regex in line 1: 'bad[a-': invalid character range",
158 EXPECT_EQ(nullptr, makeSpecialCaseList("src:a.c\n"
161 EXPECT_EQ("malformed regex in line 2: 'fun(a': parentheses not balanced",
164 EXPECT_EQ(nullptr, SpecialCaseList::create(Files, Error));
165 EXPECT_EQ(0U, Error.find("can't open file 'unexisting':"));
unittests/Support/SwapByteOrderTest.cpp 28 EXPECT_EQ(original_uint8,
32 EXPECT_EQ(original_uint16,
36 EXPECT_EQ(original_uint32,
40 EXPECT_EQ(original_uint64,
53 EXPECT_EQ(original_int8,
57 EXPECT_EQ(original_int16,
61 EXPECT_EQ(original_int32,
65 EXPECT_EQ(original_int64,
72 EXPECT_EQ(original_int8,
76 EXPECT_EQ(original_int16,
80 EXPECT_EQ(original_int32,
84 EXPECT_EQ(original_int64,
94 EXPECT_EQ(uint8_t(0x11), sys::getSwappedBytes(uint8_t(0x11)));
98 EXPECT_EQ(uint16_t(0x1122), sys::getSwappedBytes(uint16_t(0x2211)));
102 EXPECT_EQ(uint32_t(0x11223344), sys::getSwappedBytes(uint32_t(0x44332211)));
106 EXPECT_EQ(uint64_t(0x1122334455667788ULL),
111 EXPECT_EQ(int8_t(0x11), sys::getSwappedBytes(int8_t(0x11)));
115 EXPECT_EQ(int16_t(0x1122), sys::getSwappedBytes(int16_t(0x2211)));
119 EXPECT_EQ(int32_t(0x11223344), sys::getSwappedBytes(int32_t(0x44332211)));
123 EXPECT_EQ(int64_t(0x1122334455667788LL),
128 EXPECT_EQ(1.79366203433576585078237386661e-43f, sys::getSwappedBytes(-0.0f));
130 EXPECT_EQ(7.1653228759765625e2f, sys::getSwappedBytes(1.2795344e-28f));
134 EXPECT_EQ(6.32404026676795576546008054871e-322, sys::getSwappedBytes(-0.0));
136 EXPECT_EQ(-7.08687663657301358331704585496e-268,
143 EXPECT_EQ(uint8_t(0x11), value);
149 EXPECT_EQ(uint16_t(0x1122), value);
155 EXPECT_EQ(uint32_t(0x11223344), value);
161 EXPECT_EQ(uint64_t(0x1122334455667788ULL), value);
167 EXPECT_EQ(int8_t(0x11), value);
173 EXPECT_EQ(int16_t(0x1122), value);
179 EXPECT_EQ(int32_t(0x11223344), value);
185 EXPECT_EQ(int64_t(0x1122334455667788LL), value);
191 EXPECT_EQ(1.2795344e-28f, value);
197 EXPECT_EQ(3.84141202447173065923064450234e-226, value);
unittests/Support/SymbolRemappingReaderTest.cpp 37 EXPECT_EQ(readWithErrors("error", "foo.map"),
41 EXPECT_EQ(readWithErrors("error m1 m2", "foo.map"),
47 EXPECT_EQ(readWithErrors("type i banana", "foo.map"),
50 EXPECT_EQ(readWithErrors("name i 1X", "foo.map"),
53 EXPECT_EQ(readWithErrors("name 1X 1fv", "foo.map"),
56 EXPECT_EQ(readWithErrors("encoding 1fv 1f1gE", "foo.map"),
69 EXPECT_EQ(readWithErrors(Map, "foo.map"),
89 EXPECT_EQ(Key, Reader.lookup("_ZN1A3foo3bazIlEEvv"));
94 EXPECT_EQ(Key, Reader.lookup("_Z1gIlEvv"));
unittests/Support/TarWriterTest.cpp 77 EXPECT_EQ("ustar", StringRef(Hdr.Magic));
78 EXPECT_EQ("00", StringRef(Hdr.Version, 2));
79 EXPECT_EQ("base/file", StringRef(Hdr.Name));
80 EXPECT_EQ("00000000010", StringRef(Hdr.Size));
90 EXPECT_EQ("/" + x154, StringRef(Hdr1.Prefix));
91 EXPECT_EQ(y99, StringRef(Hdr1.Name));
94 EXPECT_EQ("", StringRef(Hdr2.Prefix));
95 EXPECT_EQ("", StringRef(Hdr2.Name));
98 EXPECT_EQ("", StringRef(Hdr3.Prefix));
99 EXPECT_EQ("", StringRef(Hdr3.Name));
102 EXPECT_EQ("", StringRef(Hdr4.Prefix));
103 EXPECT_EQ("", StringRef(Hdr4.Name));
107 EXPECT_EQ("/" + x154, StringRef(Hdr5.Prefix));
108 EXPECT_EQ(yz, StringRef(Hdr5.Name));
116 EXPECT_EQ("", StringRef(Hdr->Prefix));
117 EXPECT_EQ("", StringRef(Hdr->Name));
138 EXPECT_EQ(TarSize, 2048ULL);
157 EXPECT_EQ(TarSize, 3072ULL);
176 EXPECT_EQ(TarSize, 2048ULL);
unittests/Support/TargetParserTest.cpp 320 EXPECT_EQ(List.size(), NumARMCPUArchs);
329 EXPECT_EQ(ARM::parseArch(InvalidArch), ARM::ArchKind::INVALID);
545 EXPECT_EQ(ARM::FPUVersion::NONE, ARM::getFPUVersion(FK));
556 EXPECT_EQ(ARM::NeonSupportLevel::None,
570 EXPECT_EQ(ARM::FPURestriction::None, ARM::getFPURestriction(FK));
644 EXPECT_EQ(StringRef(ArchExt[i][2]), ARM::getArchExtFeature(ArchExt[i][0]));
645 EXPECT_EQ(StringRef(ArchExt[i][3]), ARM::getArchExtFeature(ArchExt[i][1]));
675 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(arm_1));
676 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(arm_2));
677 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian(arm_3));
679 EXPECT_EQ(ARM::ISAKind::ARM, ARM::parseArchISA(arm_1));
680 EXPECT_EQ(ARM::ISAKind::ARM, ARM::parseArchISA(arm_2));
681 EXPECT_EQ(ARM::ISAKind::ARM, ARM::parseArchISA(arm_3));
683 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(thumb_1));
684 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(thumb_2));
685 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian(thumb_3));
687 EXPECT_EQ(ARM::ISAKind::THUMB, ARM::parseArchISA(thumb_1));
688 EXPECT_EQ(ARM::ISAKind::THUMB, ARM::parseArchISA(thumb_2));
689 EXPECT_EQ(ARM::ISAKind::THUMB, ARM::parseArchISA(thumb_3));
693 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian("aarch64"));
694 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian("arm64_32"));
695 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian("aarch64_be"));
697 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("aarch64"));
698 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("aarch64_be"));
699 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("arm64"));
700 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("arm64_be"));
701 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("arm64_32"));
702 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("aarch64_32"));
714 EXPECT_EQ(ARM::ProfileKind::M, ARM::parseArchProfile(ARMArch[i]));
718 EXPECT_EQ(ARM::ProfileKind::R, ARM::parseArchProfile(ARMArch[i]));
729 EXPECT_EQ(ARM::ProfileKind::A, ARM::parseArchProfile(ARMArch[i]));
732 EXPECT_EQ(ARM::ProfileKind::INVALID, ARM::parseArchProfile(ARMArch[i]));
741 EXPECT_EQ((ARMArch[i][4] - 48u), ARM::parseArchVersion(ARMArch[i]));
743 EXPECT_EQ(5u, ARM::parseArchVersion(ARMArch[i]));
919 EXPECT_EQ(List.size(), NumAArch64CPUArchs);
1163 EXPECT_EQ(StringRef(ArchExt[i][2]),
1165 EXPECT_EQ(StringRef(ArchExt[i][3]),
unittests/Support/ThreadLocalTest.cpp 32 EXPECT_EQ(nullptr, x.get());
36 EXPECT_EQ(&s, x.get());
39 EXPECT_EQ(nullptr, x.get());
47 EXPECT_EQ(nullptr, y.get());
50 EXPECT_EQ(&s, y.get());
53 EXPECT_EQ(nullptr, y.get());
unittests/Support/TrailingObjectsTest.cpp 110 EXPECT_EQ(sizeof(Class1), sizeof(unsigned));
111 EXPECT_EQ(Class1::additionalSizeToAlloc<short>(1), sizeof(short));
112 EXPECT_EQ(Class1::additionalSizeToAlloc<short>(3), sizeof(short) * 3);
114 EXPECT_EQ(alignof(Class1),
116 EXPECT_EQ(sizeof(Class1::FixedSizeStorage<short>::with_counts<1>::type),
118 EXPECT_EQ(Class1::totalSizeToAlloc<short>(1), sizeof(Class1) + sizeof(short));
120 EXPECT_EQ(alignof(Class1),
122 EXPECT_EQ(sizeof(Class1::FixedSizeStorage<short>::with_counts<3>::type),
124 EXPECT_EQ(Class1::totalSizeToAlloc<short>(3),
127 EXPECT_EQ(C->getTrailingObjects<short>(), reinterpret_cast<short *>(C + 1));
128 EXPECT_EQ(C->get(0), 1);
129 EXPECT_EQ(C->get(2), 3);
137 EXPECT_EQ(sizeof(Class2), llvm::alignTo(sizeof(bool) * 2, alignof(double)));
138 EXPECT_EQ(alignof(Class2), alignof(double));
140 EXPECT_EQ((Class2::additionalSizeToAlloc<double, short>(1, 0)),
142 EXPECT_EQ((Class2::additionalSizeToAlloc<double, short>(0, 1)),
144 EXPECT_EQ((Class2::additionalSizeToAlloc<double, short>(3, 1)),
147 EXPECT_EQ(
151 EXPECT_EQ(
155 EXPECT_EQ((Class2::totalSizeToAlloc<double, short>(1, 1)),
158 EXPECT_EQ(C1->getDouble(), 0);
159 EXPECT_EQ(C1->getShort(), 4);
160 EXPECT_EQ(C1->getTrailingObjects<double>(),
162 EXPECT_EQ(C1->getTrailingObjects<short>(), reinterpret_cast<short *>(C1 + 1));
164 EXPECT_EQ(C2->getDouble(), 4.2);
165 EXPECT_EQ(C2->getShort(), 0);
166 EXPECT_EQ(C2->getTrailingObjects<double>(),
168 EXPECT_EQ(C2->getTrailingObjects<short>(),
186 EXPECT_EQ((Class3::additionalSizeToAlloc<double, short, bool>(1, 1, 3)),
188 EXPECT_EQ(sizeof(Class3), llvm::alignTo(1, alignof(double)));
190 EXPECT_EQ(
194 EXPECT_EQ(
202 EXPECT_EQ(C->getTrailingObjects<double>(), reinterpret_cast<double *>(C + 1));
203 EXPECT_EQ(C->getTrailingObjects<short>(),
205 EXPECT_EQ(
218 EXPECT_EQ((Class4::additionalSizeToAlloc<char, long>(1, 1)),
220 EXPECT_EQ(sizeof(Class4), llvm::alignTo(1, alignof(long)));
222 EXPECT_EQ(
225 EXPECT_EQ(
232 EXPECT_EQ(C->getTrailingObjects<char>(), reinterpret_cast<char *>(C + 1));
233 EXPECT_EQ(C->getTrailingObjects<long>(),
unittests/Support/UnicodeTest.cpp 18 EXPECT_EQ(0, columnWidthUTF8(""));
19 EXPECT_EQ(1, columnWidthUTF8(" "));
20 EXPECT_EQ(1, columnWidthUTF8("a"));
21 EXPECT_EQ(1, columnWidthUTF8("~"));
23 EXPECT_EQ(6, columnWidthUTF8("abcdef"));
25 EXPECT_EQ(-1, columnWidthUTF8("\x01"));
26 EXPECT_EQ(-1, columnWidthUTF8("aaaaaaaaaa\x01"));
27 EXPECT_EQ(-1, columnWidthUTF8("\342\200\213")); // 200B ZERO WIDTH SPACE
33 EXPECT_EQ(1, columnWidthUTF8("\302\255"));
35 EXPECT_EQ(0, columnWidthUTF8("\314\200")); // 0300 COMBINING GRAVE ACCENT
36 EXPECT_EQ(1, columnWidthUTF8("\340\270\201")); // 0E01 THAI CHARACTER KO KAI
37 EXPECT_EQ(2, columnWidthUTF8("\344\270\200")); // CJK UNIFIED IDEOGRAPH-4E00
39 EXPECT_EQ(4, columnWidthUTF8("\344\270\200\344\270\200"));
40 EXPECT_EQ(3, columnWidthUTF8("q\344\270\200"));
41 EXPECT_EQ(3, columnWidthUTF8("\314\200\340\270\201\344\270\200"));
44 EXPECT_EQ(-2, columnWidthUTF8("\344"));
45 EXPECT_EQ(-2, columnWidthUTF8("\344\270"));
46 EXPECT_EQ(-2, columnWidthUTF8("\344\270\033"));
47 EXPECT_EQ(-2, columnWidthUTF8("\344\270\300"));
48 EXPECT_EQ(-2, columnWidthUTF8("\377\366\355"));
50 EXPECT_EQ(-2, columnWidthUTF8("qwer\344"));
51 EXPECT_EQ(-2, columnWidthUTF8("qwer\344\270"));
52 EXPECT_EQ(-2, columnWidthUTF8("qwer\344\270\033"));
53 EXPECT_EQ(-2, columnWidthUTF8("qwer\344\270\300"));
54 EXPECT_EQ(-2, columnWidthUTF8("qwer\377\366\355"));
58 EXPECT_EQ(-2, columnWidthUTF8("\370\200\200\200\200")); // U+200000
59 EXPECT_EQ(-2, columnWidthUTF8("\374\200\200\200\200\200")); // U+4000000
unittests/Support/VersionTupleTest.cpp 15 EXPECT_EQ("0", VersionTuple().getAsString());
16 EXPECT_EQ("1", VersionTuple(1).getAsString());
17 EXPECT_EQ("1.2", VersionTuple(1, 2).getAsString());
18 EXPECT_EQ("1.2.3", VersionTuple(1, 2, 3).getAsString());
19 EXPECT_EQ("1.2.3.4", VersionTuple(1, 2, 3, 4).getAsString());
26 EXPECT_EQ("1", VT.getAsString());
29 EXPECT_EQ("1.2", VT.getAsString());
32 EXPECT_EQ("1.2.3", VT.getAsString());
35 EXPECT_EQ("1.2.3.4", VT.getAsString());
unittests/Support/VirtualFileSystemTest.cpp 257 EXPECT_EQ(RealPath.str(), "/foo");
261 EXPECT_EQ(RealPath.str(), "/symlink");
264 EXPECT_EQ(O->getRealPath("/upper_link", RealPath),
270 EXPECT_EQ(RealPath.str(), "/symlink");
349 EXPECT_EQ(0740, Status->getPermissions());
356 EXPECT_EQ(0400, Status->getPermissions());
359 EXPECT_EQ(0200, Status->getPermissions());
389 EXPECT_EQ(it, end);
409 EXPECT_EQ(it, end);
486 EXPECT_EQ(vfs::directory_iterator(), I); // empty directory is empty
503 EXPECT_EQ(vfs::directory_iterator(), I);
519 EXPECT_EQ(BDir.Path, *BFS->getCurrentWorkingDirectory());
520 EXPECT_EQ(C.Path, *CFS->getCurrentWorkingDirectory());
525 EXPECT_EQ("bbbb", (*BBuf)->getBuffer());
529 EXPECT_EQ("aaaa", (*ABuf)->getBuffer());
534 EXPECT_EQ("bb", BStat->getName());
538 EXPECT_EQ("aa", AStat->getName()); // unresolved name
543 EXPECT_EQ(BB.Path, BPath);
547 EXPECT_EQ(AA.Path, APath); // Reports resolved name.
554 EXPECT_EQ((BDir.Path + "/./bb").str(), BIt->path());
562 EXPECT_EQ((ADir.Path + "/./aa").str(), CIt->path()); // Partly resolved name!
602 EXPECT_EQ(vfs::recursive_directory_iterator(), I); // empty directory is empty
620 EXPECT_EQ(4U, Contents.size());
628 EXPECT_EQ(1, Counts[0]); // a
629 EXPECT_EQ(1, Counts[1]); // b
630 EXPECT_EQ(1, Counts[2]); // c
631 EXPECT_EQ(1, Counts[3]); // d
669 EXPECT_EQ(7U, Contents.size());
695 EXPECT_EQ(4U, Contents.size());
703 EXPECT_EQ(1, Counts[0]); // a
704 EXPECT_EQ(0, Counts[1]); // b
705 EXPECT_EQ(1, Counts[2]); // c
706 EXPECT_EQ(0, Counts[3]); // d
707 EXPECT_EQ(1, Counts[4]); // e
708 EXPECT_EQ(0, Counts[5]); // f
709 EXPECT_EQ(1, Counts[6]); // g
763 EXPECT_EQ(InputToCheck.size(), Expected.size());
767 EXPECT_EQ(StringRef(InputToCheck[Idx]), Expected[Idx]);
886 EXPECT_EQ(sys::fs::file_type::regular_file, I->type());
895 EXPECT_EQ(sys::fs::file_type::regular_file, I->type());
911 EXPECT_EQ("test", (*(*File)->getBuffer("ignored"))->getBuffer());
1092 EXPECT_EQ(FS.getRealPath("b", Path), errc::operation_not_permitted);
1102 EXPECT_EQ(GetRealPath("b"), "a/b");
1103 EXPECT_EQ(GetRealPath("../b"), "b");
1104 EXPECT_EQ(GetRealPath("b/./c"), "a/b/c");
1107 EXPECT_EQ(GetRealPath("b"), "/a/b");
1108 EXPECT_EQ(GetRealPath("../b"), "/b");
1109 EXPECT_EQ(GetRealPath("b/./c"), "/a/b/c");
1371 EXPECT_EQ(nullptr, FS.get());
1373 EXPECT_EQ(nullptr, FS.get());
1375 EXPECT_EQ(nullptr, FS.get());
1376 EXPECT_EQ(3, NumDiagnostics);
1411 EXPECT_EQ("//root/foo/bar/a", S->getName());
1415 EXPECT_EQ("//root/foo/bar/a", SLower->getName());
1424 EXPECT_EQ("//root/foo/bar/a", OpenedS->getName());
1434 EXPECT_EQ(O->status("//root/file2").getError(),
1436 EXPECT_EQ(0, NumDiagnostics);
1472 EXPECT_EQ(0, NumDiagnostics);
1499 EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory);
1501 EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory);
1503 EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory);
1504 EXPECT_EQ(0, NumDiagnostics);
1512 EXPECT_EQ(nullptr, FS.get());
1519 EXPECT_EQ(nullptr, FS.get());
1523 EXPECT_EQ(nullptr, FS.get());
1525 EXPECT_EQ(nullptr, FS.get());
1529 EXPECT_EQ(nullptr, FS.get());
1531 EXPECT_EQ(nullptr, FS.get());
1536 EXPECT_EQ(nullptr, FS.get());
1540 EXPECT_EQ(nullptr, FS.get());
1544 EXPECT_EQ(nullptr, FS.get());
1548 EXPECT_EQ(nullptr, FS.get());
1552 EXPECT_EQ(nullptr, FS.get());
1556 EXPECT_EQ(nullptr, FS.get());
1560 EXPECT_EQ(nullptr, FS.get());
1564 EXPECT_EQ(nullptr, FS.get());
1567 EXPECT_EQ(nullptr, FS.get());
1569 EXPECT_EQ(nullptr, FS.get());
1573 EXPECT_EQ(nullptr, FS.get());
1577 EXPECT_EQ(nullptr, FS.get());
1582 EXPECT_EQ(nullptr, FS.get());
1586 EXPECT_EQ(nullptr, FS.get());
1590 EXPECT_EQ(nullptr, FS.get());
1592 EXPECT_EQ(nullptr, FS.get());
1594 EXPECT_EQ(nullptr, FS.get());
1595 EXPECT_EQ(24, NumDiagnostics);
1620 EXPECT_EQ("//root/external/file", FS->status("//root/A")->getName());
1622 EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName());
1623 EXPECT_EQ("//root/C", FS->status("//root/C")->getName());
1644 EXPECT_EQ("//root/A", FS->status("//root/A")->getName());
1646 EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName());
1647 EXPECT_EQ("//root/C", FS->status("//root/C")->getName());
1844 EXPECT_EQ(I.level(), l);
1846 EXPECT_EQ(I, E);
1859 EXPECT_EQ(nullptr, FS.get());
1868 EXPECT_EQ(nullptr, FS.get());
1878 EXPECT_EQ(nullptr, FS.get());
1880 EXPECT_EQ(3, NumDiagnostics);
2000 EXPECT_EQ(RealPath.str(), "/foo");
2004 EXPECT_EQ(RealPath.str(), "/symlink");
2008 EXPECT_EQ(RealPath.str(), "//dir/");
2011 EXPECT_EQ(FS->getRealPath("/non_existing", RealPath),
2043 EXPECT_EQ(*WorkingDir, "//root/bar");
2058 EXPECT_EQ(*WorkingDir, "//root/bar");
2064 EXPECT_EQ(*WorkingDir, "//root/");
2070 EXPECT_EQ(*WorkingDir, "//root/bar");
unittests/Support/YAMLIOTest.cpp 86 EXPECT_EQ(doc.foo, 3);
87 EXPECT_EQ(doc.bar, 5);
95 EXPECT_EQ(doc.foo, 3);
96 EXPECT_EQ(doc.bar, 5);
116 EXPECT_EQ(seq.size(), 2UL);
119 EXPECT_EQ(map1.foo, 3);
120 EXPECT_EQ(map1.bar, 5);
121 EXPECT_EQ(map2.foo, 7);
122 EXPECT_EQ(map2.bar, 9);
135 EXPECT_EQ(cont.fbs.size(), 2UL);
136 EXPECT_EQ(cont.fbs[0].foo, 3);
137 EXPECT_EQ(cont.fbs[0].bar, 5);
138 EXPECT_EQ(cont.fbs[1].foo, 7);
139 EXPECT_EQ(cont.fbs[1].bar, 9);
148 EXPECT_EQ(cont.fbs.size(), 0UL);
157 EXPECT_EQ(cont.fbs.size(), 0UL);
166 EXPECT_EQ(cont.fbs.size(), 0UL);
175 EXPECT_EQ(cont.fbs.size(), 0UL);
190 EXPECT_EQ(cont.fbs.size(), 0UL);
199 EXPECT_EQ(cont.fbs.size(), 0UL);
230 EXPECT_EQ(seq2.size(), 2UL);
233 EXPECT_EQ(map1.foo, 10);
234 EXPECT_EQ(map1.bar, -3);
235 EXPECT_EQ(map2.foo, 257);
236 EXPECT_EQ(map2.bar, 0);
244 EXPECT_EQ(Error.getFilename(), "foo.yaml");
304 EXPECT_EQ(Original.str1, Deserialized.str1);
305 EXPECT_EQ(Original.str2, Deserialized.str2);
306 EXPECT_EQ(Original.str3, Deserialized.str3);
404 EXPECT_EQ(map.u64, 5000000000ULL);
405 EXPECT_EQ(map.u32, 4000000000U);
406 EXPECT_EQ(map.u16, 65000);
407 EXPECT_EQ(map.u8, 255);
408 EXPECT_EQ(map.b, false);
409 EXPECT_EQ(map.s64, -5000000000LL);
410 EXPECT_EQ(map.s32, -2000000000L);
411 EXPECT_EQ(map.s16, -32000);
412 EXPECT_EQ(map.s8, -127);
413 EXPECT_EQ(map.f, 137.125);
414 EXPECT_EQ(map.d, -2.8625);
415 EXPECT_EQ(map.h8, Hex8(255));
416 EXPECT_EQ(map.h16, Hex16(0x8765));
417 EXPECT_EQ(map.h32, Hex32(0xFEDCBA98));
418 EXPECT_EQ(map.h64, Hex64(0xFEDCBA9876543210LL));
460 EXPECT_EQ(map.u64, 6000000000ULL);
461 EXPECT_EQ(map.u32, 3000000000U);
462 EXPECT_EQ(map.u16, 50000);
463 EXPECT_EQ(map.u8, 254);
464 EXPECT_EQ(map.b, true);
465 EXPECT_EQ(map.s64, -6000000000LL);
466 EXPECT_EQ(map.s32, -2000000000L);
467 EXPECT_EQ(map.s16, -32000);
468 EXPECT_EQ(map.s8, -128);
469 EXPECT_EQ(map.f, 3.25);
470 EXPECT_EQ(map.d, -2.8625);
471 EXPECT_EQ(map.h8, Hex8(254));
472 EXPECT_EQ(map.h16, Hex16(50000));
473 EXPECT_EQ(map.h32, Hex32(3000000000U));
474 EXPECT_EQ(map.h64, Hex64(6000000000LL));
535 EXPECT_EQ(map.u64, 5000000000ULL);
536 EXPECT_EQ(map.u32, 4000000000U);
537 EXPECT_EQ(map.u16, 65000);
538 EXPECT_EQ(map.s64, -5000000000LL);
539 EXPECT_EQ(map.s32, -2000000000L);
540 EXPECT_EQ(map.s16, -32000);
541 EXPECT_EQ(map.f, 3.25f);
542 EXPECT_EQ(map.d, -2.8625);
572 EXPECT_EQ(map.u64, 6000000000ULL);
573 EXPECT_EQ(map.u32, 3000000000U);
574 EXPECT_EQ(map.u16, 50000);
575 EXPECT_EQ(map.s64, -6000000000LL);
576 EXPECT_EQ(map.s32, -2000000000L);
577 EXPECT_EQ(map.s16, -32000);
578 EXPECT_EQ(map.f, 3.25f);
579 EXPECT_EQ(map.d, -2.8625);
634 EXPECT_EQ(Enum::One, map.LittleEnum);
635 EXPECT_EQ(Enum::Two, map.BigEnum);
636 EXPECT_EQ(BitsetEnum::ZeroOne, map.LittleBitset);
637 EXPECT_EQ(BitsetEnum::ZeroOne | BitsetEnum::OneZero, map.BigBitset);
660 EXPECT_EQ(Enum::Two, map.LittleEnum);
661 EXPECT_EQ(Enum::One, map.BigEnum);
662 EXPECT_EQ(BitsetEnum::OneZero | BitsetEnum::ZeroOne, map.LittleBitset);
663 EXPECT_EQ(BitsetEnum::OneZero, map.BigBitset);
801 EXPECT_EQ(std::string("\0a\0b\0", 5), map.stdstr13);
865 EXPECT_EQ(cBlue, map.c1);
866 EXPECT_EQ(cRed, map.c2);
867 EXPECT_EQ(cGreen, map.c3);
868 EXPECT_EQ(cBlue, map.c4); // tests default
869 EXPECT_EQ(cYellow,map.c5); // tests overridden
870 EXPECT_EQ(cRed, map.c6); // tests default
936 EXPECT_EQ(flagBig, map.f1);
937 EXPECT_EQ(flagRound|flagFlat, map.f2);
938 EXPECT_EQ(flagNone, map.f3); // check empty set
939 EXPECT_EQ(flagRound, map.f4); // check optional key
966 EXPECT_EQ(flagBig, map2.f1);
967 EXPECT_EQ(flagRound|flagFlat, map2.f2);
968 EXPECT_EQ(flagNone, map2.f3);
1057 EXPECT_EQ(1, map2.f1.length);
1058 EXPECT_EQ(4, map2.f1.width);
1059 EXPECT_EQ(100, map2.f2.length);
1060 EXPECT_EQ(400, map2.f2.width);
1061 EXPECT_EQ(10, map2.f3);
1146 EXPECT_EQ(map2.name.str, "An Item\n");
1147 EXPECT_EQ(map2.description.str, "Hello\nWorld\n");
1148 EXPECT_EQ(map2.ingredients.str, "SubItem 1\nSub Item 2\n\nSub Item 3\n");
1149 EXPECT_EQ(map2.recipes.str, "\n\nTest 1\n");
1152 EXPECT_EQ(map2.price, 350);
1181 EXPECT_EQ(documents2.size(), size_t(1));
1182 EXPECT_EQ(documents2[0].str, "Hello\nWorld\n");
1202 EXPECT_EQ(doc.str, "Just a block\nscalar doc\n");
1324 EXPECT_EQ(map2.strings.size(), 2UL);
1327 EXPECT_EQ(map2.single.size(), 1UL);
1328 EXPECT_EQ(1, map2.single[0]);
1329 EXPECT_EQ(map2.numbers.size(), 3UL);
1330 EXPECT_EQ(10, map2.numbers[0]);
1331 EXPECT_EQ(-30, map2.numbers[1]);
1332 EXPECT_EQ(1024, map2.numbers[2]);
1371 EXPECT_EQ(map2.sequenceOfNumbers.size(), 3UL);
1372 EXPECT_EQ(map2.sequenceOfNumbers[0].size(), 1UL);
1373 EXPECT_EQ(0, map2.sequenceOfNumbers[0][0]);
1374 EXPECT_EQ(map2.sequenceOfNumbers[1].size(), 3UL);
1375 EXPECT_EQ(12, map2.sequenceOfNumbers[1][0]);
1376 EXPECT_EQ(1, map2.sequenceOfNumbers[1][1]);
1377 EXPECT_EQ(-512, map2.sequenceOfNumbers[1][2]);
1438 EXPECT_EQ(seq.size(), 2UL);
1439 EXPECT_EQ(seq[0], 3605U);
1440 EXPECT_EQ(seq[1], 59U);
1465 EXPECT_EQ(seq2.size(), 3UL);
1466 EXPECT_EQ(seq2[0], 4000U);
1467 EXPECT_EQ(seq2[1], 500U);
1468 EXPECT_EQ(seq2[2], 59U);
1560 EXPECT_EQ(seq.size(), 2UL);
1561 EXPECT_EQ(seq[0].kind, kindA);
1562 EXPECT_EQ(seq[0].flags, (uint32_t)a2);
1563 EXPECT_EQ(seq[1].kind, kindB);
1564 EXPECT_EQ(seq[1].flags, (uint32_t)b1);
1590 EXPECT_EQ(seq2.size(), 5UL);
1591 EXPECT_EQ(seq2[0].kind, kindA);
1592 EXPECT_EQ(seq2[0].flags, (uint32_t)a1);
1593 EXPECT_EQ(seq2[1].kind, kindB);
1594 EXPECT_EQ(seq2[1].flags, (uint32_t)b1);
1595 EXPECT_EQ(seq2[2].kind, kindA);
1596 EXPECT_EQ(seq2[2].flags, (uint32_t)a2);
1597 EXPECT_EQ(seq2[3].kind, kindB);
1598 EXPECT_EQ(seq2[3].flags, (uint32_t)b2);
1599 EXPECT_EQ(seq2[4].kind, kindA);
1600 EXPECT_EQ(seq2[4].flags, (uint32_t)a3);
1640 EXPECT_EQ(doc.foo, 3);
1641 EXPECT_EQ(doc.bar,5);
1674 EXPECT_EQ(docList2.size(), 2UL);
1677 EXPECT_EQ(map1.foo, 10);
1678 EXPECT_EQ(map1.bar, -3);
1679 EXPECT_EQ(map2.foo, 257);
1680 EXPECT_EQ(map2.bar, 0);
1732 EXPECT_EQ(docList.size(), 2UL);
1733 EXPECT_EQ(docList[0].value, 3.0);
1734 EXPECT_EQ(docList[1].value, 4.5);
1762 EXPECT_EQ(docList2.size(), 2UL);
1763 EXPECT_EQ(docList2[0].value, 10.25);
1764 EXPECT_EQ(docList2[1].value, -3.75);
1882 EXPECT_EQ(doc2.attribute.foo, 42);
1883 EXPECT_EQ(doc2.attribute.bar, 907);
1884 EXPECT_EQ(doc2.seq.size(), 3UL);
1885 EXPECT_EQ(doc2.seq[0].foo, 1);
1886 EXPECT_EQ(doc2.seq[0].bar, 2);
1887 EXPECT_EQ(doc2.seq[1].foo, 0);
1888 EXPECT_EQ(doc2.seq[1].bar, 0);
1889 EXPECT_EQ(doc2.seq[2].foo, -1);
1890 EXPECT_EQ(doc2.seq[2].bar, 1024);
2331 EXPECT_EQ(4UL, Seq2.Tests.size());
2336 EXPECT_EQ(1, Seq2.Tests[2].Numbers[0]);
2337 EXPECT_EQ(2, Seq2.Tests[2].Numbers[1]);
2338 EXPECT_EQ(3, Seq2.Tests[2].Numbers[2]);
2424 EXPECT_EQ(out,
2434 EXPECT_EQ(out,
2448 EXPECT_EQ(out,
2457 EXPECT_EQ(out,
2470 EXPECT_EQ(out,
2478 EXPECT_EQ(out,
2529 EXPECT_EQ(1, Context.A);
2530 EXPECT_EQ("---\n"
2544 EXPECT_EQ(2, Context.A);
2545 EXPECT_EQ("---\n"
2566 EXPECT_EQ("---\n"
2577 EXPECT_EQ("---\n"
2586 EXPECT_EQ(2ul, y.size());
2587 EXPECT_EQ(1, y["foo"]);
2588 EXPECT_EQ(2, y["bar"]);
2606 EXPECT_EQ("---\n"
2619 EXPECT_EQ(2ul, y.size());
2620 EXPECT_EQ(1, y["foo"].foo);
2621 EXPECT_EQ(2, y["foo"].bar);
2622 EXPECT_EQ(3, y["bar"].foo);
2623 EXPECT_EQ(4, y["bar"].bar);
2646 EXPECT_EQ(OS.str(), "---\nfbm: {}\n...\n");
2655 EXPECT_EQ(OS.str(), "---\nfbs: []\n...\n");
2670 EXPECT_EQ(Expected, Got);
2969 EXPECT_EQ(first->SKind, Scalar::SK_Bool);
2973 EXPECT_EQ(second->SKind, Scalar::SK_Double);
2974 EXPECT_EQ(second->DoubleValue, 1.0);
3000 EXPECT_EQ(foo->SKind, Scalar::SK_Bool);
3004 EXPECT_EQ(bar->SKind, Scalar::SK_Double);
3005 EXPECT_EQ(bar->DoubleValue, 2.0);
unittests/Support/YAMLParserTest.cpp 166 EXPECT_EQ(Value, "Hello\nWorld\n");
167 EXPECT_EQ(Value.data()[Value.size()], '\0');
198 EXPECT_EQ(String, ParsedString.str());
231 EXPECT_EQ(6, std::distance(Array->begin(), Array->end()));
244 EXPECT_EQ("YAML", GeneratedDiag.getFilename());
259 EXPECT_EQ("buffername.yaml", GeneratedDiag.getFilename());
unittests/Support/formatted_raw_ostream_test.cpp 28 EXPECT_EQ(100*(i+1), (unsigned) C.tell());
unittests/Support/raw_ostream_test.cpp 52 EXPECT_EQ("c", printToString('c'));
55 EXPECT_EQ("hello", printToString("hello"));
56 EXPECT_EQ("hello", printToString(std::string("hello")));
59 EXPECT_EQ("0", printToString(0));
60 EXPECT_EQ("2425", printToString(2425));
61 EXPECT_EQ("-2425", printToString(-2425));
64 EXPECT_EQ("0", printToString(0LL));
65 EXPECT_EQ("257257257235709", printToString(257257257235709LL));
66 EXPECT_EQ("-257257257235709", printToString(-257257257235709LL));
69 EXPECT_EQ("1.100000e+00", printToString(1.1));
72 EXPECT_EQ("0x0", printToString((void*) nullptr));
73 EXPECT_EQ("0xbeef", printToString((void*) 0xbeefLL));
74 EXPECT_EQ("0xdeadbeef", printToString((void*) 0xdeadbeefLL));
77 EXPECT_EQ("18446744073709551615", printToString(UINT64_MAX));
78 EXPECT_EQ("-9223372036854775808", printToString(INT64_MIN));
83 EXPECT_EQ("c", printToStringUnbuffered('c'));
86 EXPECT_EQ("hello", printToStringUnbuffered("hello"));
87 EXPECT_EQ("hello", printToStringUnbuffered(std::string("hello")));
90 EXPECT_EQ("0", printToStringUnbuffered(0));
91 EXPECT_EQ("2425", printToStringUnbuffered(2425));
92 EXPECT_EQ("-2425", printToStringUnbuffered(-2425));
95 EXPECT_EQ("0", printToStringUnbuffered(0LL));
96 EXPECT_EQ("257257257235709", printToStringUnbuffered(257257257235709LL));
97 EXPECT_EQ("-257257257235709", printToStringUnbuffered(-257257257235709LL));
100 EXPECT_EQ("1.100000e+00", printToStringUnbuffered(1.1));
103 EXPECT_EQ("0x0", printToStringUnbuffered((void*) nullptr));
104 EXPECT_EQ("0xbeef", printToStringUnbuffered((void*) 0xbeefLL));
105 EXPECT_EQ("0xdeadbeef", printToStringUnbuffered((void*) 0xdeadbeefLL));
108 EXPECT_EQ("18446744073709551615", printToStringUnbuffered(UINT64_MAX));
109 EXPECT_EQ("-9223372036854775808", printToStringUnbuffered(INT64_MIN));
113 EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 1));
114 EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 2));
115 EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 3));
116 EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 4));
117 EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 10));
127 EXPECT_EQ("hello1world", OS.str());
135 EXPECT_EQ("hi", Str);
139 EXPECT_EQ("\\\\\\t\\n\\\"", Str);
143 EXPECT_EQ("\\001\\010\\200", Str);
147 EXPECT_EQ("xyz ", printToString(left_justify("xyz", 6), 6));
148 EXPECT_EQ("abc", printToString(left_justify("abc", 3), 3));
149 EXPECT_EQ("big", printToString(left_justify("big", 1), 3));
150 EXPECT_EQ(" xyz", printToString(right_justify("xyz", 6), 6));
151 EXPECT_EQ("abc", printToString(right_justify("abc", 3), 3));
152 EXPECT_EQ("big", printToString(right_justify("big", 1), 3));
153 EXPECT_EQ(" on ", printToString(center_justify("on", 9), 9));
154 EXPECT_EQ(" off ", printToString(center_justify("off", 10), 10));
155 EXPECT_EQ("single ", printToString(center_justify("single", 7), 7));
156 EXPECT_EQ("none", printToString(center_justify("none", 1), 4));
157 EXPECT_EQ("none", printToString(center_justify("none", 1), 1));
161 EXPECT_EQ("0x1234", printToString(format_hex(0x1234, 6), 6));
162 EXPECT_EQ("0x001234", printToString(format_hex(0x1234, 8), 8));
163 EXPECT_EQ("0x00001234", printToString(format_hex(0x1234, 10), 10));
164 EXPECT_EQ("0x1234", printToString(format_hex(0x1234, 4), 6));
165 EXPECT_EQ("0xff", printToString(format_hex(255, 4), 4));
166 EXPECT_EQ("0xFF", printToString(format_hex(255, 4, true), 4));
167 EXPECT_EQ("0x1", printToString(format_hex(1, 3), 3));
168 EXPECT_EQ("0x12", printToString(format_hex(0x12, 3), 4));
169 EXPECT_EQ("0x123", printToString(format_hex(0x123, 3), 5));
170 EXPECT_EQ("FF", printToString(format_hex_no_prefix(0xFF, 2, true), 4));
171 EXPECT_EQ("ABCD", printToString(format_hex_no_prefix(0xABCD, 2, true), 4));
172 EXPECT_EQ("0xffffffffffffffff",
174 EXPECT_EQ("0x8000000000000000",
179 EXPECT_EQ(" 0", printToString(format_decimal(0, 4), 4));
180 EXPECT_EQ(" -1", printToString(format_decimal(-1, 4), 4));
181 EXPECT_EQ(" -1", printToString(format_decimal(-1, 6), 6));
182 EXPECT_EQ("1234567890", printToString(format_decimal(1234567890, 10), 10));
183 EXPECT_EQ(" 9223372036854775807",
185 EXPECT_EQ(" -9223372036854775808",
219 EXPECT_EQ("", formatted_bytes_str(ArrayRef<uint8_t>()));
220 EXPECT_EQ("", format_bytes_with_ascii_str(ArrayRef<uint8_t>()));
224 EXPECT_EQ("61", formatted_bytes_str(B.take_front()));
225 EXPECT_EQ("61626364 65", formatted_bytes_str(B.take_front(5)));
227 EXPECT_EQ("61626364 65666768 696a6b6c 6d6e6f70",
230 EXPECT_EQ("61626364 65666768 696a6b6c 6d6e6f70\n71",
233 EXPECT_EQ("61\n62\n63\n64\n65\n66",
236 EXPECT_EQ("61626364 656667\n68696a6b 6c6d6e\n6f7071",
239 EXPECT_EQ("61626364 65666768\n696a6b6c 6d6e6f70\n71",
244 EXPECT_EQ("61 62 63 64 65",
247 EXPECT_EQ("61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70",
250 EXPECT_EQ("61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70\n71",
253 EXPECT_EQ("61 62 63 64 65 66 67\n68 69 6a 6b 6c 6d 6e\n6f 70 71",
256 EXPECT_EQ("61 62 63 64 65 66 67 68\n69 6a 6b 6c 6d 6e 6f 70\n71",
262 EXPECT_EQ("6162 6364 65", formatted_bytes_str(B.take_front(5), None, 16, 2));
264 EXPECT_EQ("6162 6364 6566 6768 696a 6b6c 6d6e 6f70",
267 EXPECT_EQ("6162 6364 6566 6768 696a 6b6c 6d6e 6f70\n71",
270 EXPECT_EQ("6162 6364 6566 67\n6869 6a6b 6c6d 6e\n6f70 71",
273 EXPECT_EQ("6162 6364 6566 6768\n696a 6b6c 6d6e 6f70\n71",
279 EXPECT_EQ("0000: 61", formatted_bytes_str(B.take_front(), 0x0));
280 EXPECT_EQ("1000: 61", formatted_bytes_str(B.take_front(), 0x1000));
281 EXPECT_EQ("1000: 61\n1001: 62",
286 EXPECT_EQ("61626364 65666768 696a6b6c 6d6e6f70 |abcdefghijklmnop|",
288 EXPECT_EQ("61626364 65666768 |abcdefgh|\n"
291 EXPECT_EQ("61626364 65666768 |abcdefgh|\n696a6b6c |ijkl|",
297 EXPECT_EQ("611e621f |a.b.|",
302 EXPECT_EQ("0000: 61626364 65666768 "
305 EXPECT_EQ("0000: 61626364 65666768 |abcdefgh|\n"
308 EXPECT_EQ("0000: 61626364 656667 |abcdefg|\n"
315 EXPECT_EQ("0000: 6162 6364 6566 6768 "
318 EXPECT_EQ("0000: 6162 6364 6566 6768 |abcdefgh|\n"
321 EXPECT_EQ("0000: 6162 6364 6566 67 |abcdefg|\n"
328 EXPECT_EQ("0000: 61 62 63 64 65 66 67 68 "
331 EXPECT_EQ("0000: 61 62 63 64 65 66 67 68 |abcdefgh|\n"
334 EXPECT_EQ("0000: 61 62 63 64 65 66 67 |abcdefg|\n"
unittests/Support/raw_pwrite_stream_test.cpp 37 EXPECT_EQ(Test, OS.str());
unittests/Support/xxhashTest.cpp 15 EXPECT_EQ(0x33bf00a859c4ba3fU, xxHash64("foo"));
16 EXPECT_EQ(0x48a37c90ad27a659U, xxHash64("bar"));
17 EXPECT_EQ(0x69196c1b3af0bff9U,
unittests/TableGen/CodeExpanderTest.cpp 38 EXPECT_EQ(Received.size(), Expected.size());
40 EXPECT_EQ(Received[i].getLoc(), Expected[i].getLoc());
41 EXPECT_EQ(Received[i].getFilename(), Expected[i].getFilename());
42 EXPECT_EQ(Received[i].getKind(), Expected[i].getKind());
43 EXPECT_EQ(Received[i].getLineNo(), Expected[i].getLineNo());
44 EXPECT_EQ(Received[i].getColumnNo(), Expected[i].getColumnNo());
45 EXPECT_EQ(Received[i].getMessage(), Expected[i].getMessage());
46 EXPECT_EQ(Received[i].getLineContents(), Expected[i].getLineContents());
47 EXPECT_EQ(Received[i].getRanges(), Expected[i].getRanges());
76 EXPECT_EQ(OS.str(), "No expansions");
89 EXPECT_EQ(OS.str(), "No expansions\n second line\n third line");
101 EXPECT_EQ(OS.str(), "\\a$");
114 EXPECT_EQ(OS.str(), " $foo");
128 EXPECT_EQ(OS.str(), "$foo");
139 EXPECT_EQ(OS.str(), "${foo");
150 EXPECT_EQ(OS.str(), "${foo}");
162 EXPECT_EQ(OS.str(), "expansion");
181 EXPECT_EQ(OS.str(), "Padding expansion");
199 EXPECT_EQ(OS.str(), " expansion");
unittests/Target/AArch64/InstSizes.cpp 90 EXPECT_EQ(16u, II.getInstSizeInBytes(*I));
92 EXPECT_EQ(32u, II.getInstSizeInBytes(*I));
105 EXPECT_EQ(16u, II.getInstSizeInBytes(*I));
107 EXPECT_EQ(32u, II.getInstSizeInBytes(*I));
121 EXPECT_EQ(16u, II.getInstSizeInBytes(*I));
unittests/Target/AArch64/TestStackOffset.cpp 16 EXPECT_EQ(1, A.getBytes());
19 EXPECT_EQ(8, B.getBytes());
22 EXPECT_EQ(64, C.getBytes());
25 EXPECT_EQ(64, D.getScalableBytes());
28 EXPECT_EQ(0, E.getScalableBytes());
31 EXPECT_EQ(0, F.getBytes());
38 EXPECT_EQ(12, C.getBytes());
42 EXPECT_EQ(12, D.getBytes());
46 EXPECT_EQ(12, F.getBytes());
47 EXPECT_EQ(4, F.getScalableBytes());
54 EXPECT_EQ(4, C.getBytes());
58 EXPECT_EQ(0, D.getBytes());
63 EXPECT_EQ(4, F.getBytes());
64 EXPECT_EQ(4, F.getScalableBytes());
103 EXPECT_EQ(12, ByteSized);
104 EXPECT_EQ(1, VLSized);
105 EXPECT_EQ(0, PLSized);
111 EXPECT_EQ(0, ByteSized);
112 EXPECT_EQ(0, VLSized);
113 EXPECT_EQ(9, PLSized);
118 EXPECT_EQ(0, ByteSized);
119 EXPECT_EQ(0, VLSized);
120 EXPECT_EQ(33, PLSized);
128 EXPECT_EQ(0, ByteSized);
129 EXPECT_EQ(8, VLSized);
130 EXPECT_EQ(1, PLSized);
unittests/Target/WebAssembly/WebAssemblyExceptionInfoTest.cpp 183 EXPECT_EQ(WE0->getEHPad(), MBB2);
184 EXPECT_EQ(WE0->getParentException(), nullptr);
185 EXPECT_EQ(WE0->getExceptionDepth(), (unsigned)1);
190 EXPECT_EQ(WE0_0->getEHPad(), MBB3);
191 EXPECT_EQ(WE0_0->getParentException(), WE0);
192 EXPECT_EQ(WE0_0->getExceptionDepth(), (unsigned)2);
197 EXPECT_EQ(WE0_0->getEHPad(), MBB3);
202 EXPECT_EQ(WE0_0->getEHPad(), MBB3);
207 EXPECT_EQ(WE0_0->getEHPad(), MBB3);
212 EXPECT_EQ(WE0_0->getEHPad(), MBB3);
217 EXPECT_EQ(WE0_0_0->getEHPad(), MBB8);
218 EXPECT_EQ(WE0_0_0->getParentException(), WE0_0);
219 EXPECT_EQ(WE0_0_0->getExceptionDepth(), (unsigned)3);
224 EXPECT_EQ(WE0_1->getEHPad(), MBB9);
225 EXPECT_EQ(WE0_1->getParentException(), WE0);
226 EXPECT_EQ(WE0_1->getExceptionDepth(), (unsigned)2);
358 EXPECT_EQ(WE0->getEHPad(), MBB1);
359 EXPECT_EQ(WE0->getParentException(), nullptr);
360 EXPECT_EQ(WE0->getExceptionDepth(), (unsigned)1);
365 EXPECT_EQ(WE0->getEHPad(), MBB1);
370 EXPECT_EQ(WE0->getEHPad(), MBB1);
375 EXPECT_EQ(WE0->getEHPad(), MBB1);
380 EXPECT_EQ(WE0_0->getEHPad(), MBB3);
381 EXPECT_EQ(WE0_0->getParentException(), WE0);
382 EXPECT_EQ(WE0_0->getExceptionDepth(), (unsigned)2);
387 EXPECT_EQ(WE0_0->getEHPad(), MBB3);
392 EXPECT_EQ(WE0_0->getEHPad(), MBB3);
397 EXPECT_EQ(WE0_0->getEHPad(), MBB3);
402 EXPECT_EQ(WE0_0->getEHPad(), MBB3);
407 EXPECT_EQ(WE0_0_0->getEHPad(), MBB10);
408 EXPECT_EQ(WE0_0_0->getParentException(), WE0_0);
409 EXPECT_EQ(WE0_0_0->getExceptionDepth(), (unsigned)3);
414 EXPECT_EQ(WE0_1->getEHPad(), MBB11);
415 EXPECT_EQ(WE0_1->getParentException(), WE0);
416 EXPECT_EQ(WE0_1->getExceptionDepth(), (unsigned)2);
unittests/TextAPI/ELFYAMLTest.cpp 49 EXPECT_EQ(Stub->Arch, (uint16_t)llvm::ELF::EM_X86_64);
50 EXPECT_EQ(Stub->NeededLibs.size(), 3u);
75 EXPECT_EQ(Stub->Symbols.size(), 5u);
80 EXPECT_EQ(SymBar.Size, 42u);
81 EXPECT_EQ(SymBar.Type, ELFSymbolType::Object);
88 EXPECT_EQ(SymBaz.Size, 3u);
89 EXPECT_EQ(SymBaz.Type, ELFSymbolType::TLS);
96 EXPECT_EQ(SymFoo.Size, 0u);
97 EXPECT_EQ(SymFoo.Type, ELFSymbolType::Func);
105 EXPECT_EQ(SymNor.Size, 0u);
106 EXPECT_EQ(SymNor.Type, ELFSymbolType::NoType);
113 EXPECT_EQ(SymNot.Size, 111u);
114 EXPECT_EQ(SymNot.Type, ELFSymbolType::Unknown);
132 EXPECT_EQ(0u, Stub->Symbols.size());
unittests/TextAPI/TextStubV1Tests.cpp 88 EXPECT_EQ(FileType::TBD_V1, File->getFileType());
94 EXPECT_EQ(Archs, File->getArchitectures());
95 EXPECT_EQ(File->getPlatforms().size(), 1U);
96 EXPECT_EQ(Platform, *File->getPlatforms().begin());
97 EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
98 EXPECT_EQ(PackedVersion(2, 3, 4), File->getCurrentVersion());
99 EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
100 EXPECT_EQ(2U, File->getSwiftABIVersion());
101 EXPECT_EQ(ObjCConstraintType::None, File->getObjCConstraint());
107 EXPECT_EQ(1U, File->allowableClients().size());
108 EXPECT_EQ(client, File->allowableClients().front());
109 EXPECT_EQ(1U, File->reexportedLibraries().size());
110 EXPECT_EQ(reexport, File->reexportedLibraries().front());
122 EXPECT_EQ(sizeof(TBDv1Symbols) / sizeof(ExportedSymbol), Exports.size());
141 EXPECT_EQ(FileType::TBD_V1, File->getFileType());
147 EXPECT_EQ(Archs, File->getArchitectures());
148 EXPECT_EQ(File->getPlatforms().size(), 1U);
149 EXPECT_EQ(Platform, *File->getPlatforms().begin());
150 EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
151 EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());
152 EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
153 EXPECT_EQ(0U, File->getSwiftABIVersion());
154 EXPECT_EQ(ObjCConstraintType::None, File->getObjCConstraint());
158 EXPECT_EQ(0U, File->allowableClients().size());
159 EXPECT_EQ(0U, File->reexportedLibraries().size());
227 EXPECT_EQ(FileType::TBD_V1, File->getFileType());
228 EXPECT_EQ(File->getPlatforms().size(), 1U);
229 EXPECT_EQ(Platform, *File->getPlatforms().begin());
244 EXPECT_EQ(FileType::TBD_V1, File->getFileType());
245 EXPECT_EQ(File->getPlatforms().size(), 1U);
246 EXPECT_EQ(Platform, *File->getPlatforms().begin());
261 EXPECT_EQ(FileType::TBD_V1, File->getFileType());
262 EXPECT_EQ(File->getPlatforms().size(), 1U);
263 EXPECT_EQ(Platform, *File->getPlatforms().begin());
278 EXPECT_EQ(FileType::TBD_V1, File->getFileType());
279 EXPECT_EQ(File->getPlatforms().size(), 1U);
280 EXPECT_EQ(Platform, *File->getPlatforms().begin());
295 EXPECT_EQ(FileType::TBD_V1, File->getFileType());
296 EXPECT_EQ(File->getPlatforms().size(), 1U);
297 EXPECT_EQ(Platform, *File->getPlatforms().begin());
312 EXPECT_EQ(FileType::TBD_V1, File->getFileType());
313 EXPECT_EQ(1U, File->getSwiftABIVersion());
328 EXPECT_EQ(FileType::TBD_V1, File->getFileType());
329 EXPECT_EQ(2U, File->getSwiftABIVersion());
344 EXPECT_EQ(FileType::TBD_V1, File->getFileType());
345 EXPECT_EQ(3U, File->getSwiftABIVersion());
360 EXPECT_EQ(FileType::TBD_V1, File->getFileType());
361 EXPECT_EQ(4U, File->getSwiftABIVersion());
376 EXPECT_EQ("malformed file\nTest.tbd:5:16: error: invalid Swift ABI "
392 EXPECT_EQ(FileType::TBD_V1, File->getFileType());
393 EXPECT_EQ(5U, File->getSwiftABIVersion());
408 EXPECT_EQ(FileType::TBD_V1, File->getFileType());
409 EXPECT_EQ(99U, File->getSwiftABIVersion());
435 EXPECT_EQ("malformed file\nTest.tbd:3:11: error: unknown platform\nplatform: "
unittests/TextAPI/TextStubV2Tests.cpp 90 EXPECT_EQ(FileType::TBD_V2, File->getFileType());
96 EXPECT_EQ(Archs, File->getArchitectures());
97 EXPECT_EQ(File->getPlatforms().size(), 1U);
98 EXPECT_EQ(Platform, *File->getPlatforms().begin());
99 EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
100 EXPECT_EQ(PackedVersion(2, 3, 4), File->getCurrentVersion());
101 EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
102 EXPECT_EQ(2U, File->getSwiftABIVersion());
103 EXPECT_EQ(ObjCConstraintType::Retain_Release, File->getObjCConstraint());
109 EXPECT_EQ(1U, File->allowableClients().size());
110 EXPECT_EQ(client, File->allowableClients().front());
111 EXPECT_EQ(1U, File->reexportedLibraries().size());
112 EXPECT_EQ(reexport, File->reexportedLibraries().front());
124 EXPECT_EQ(sizeof(TBDv2Symbols) / sizeof(ExportedSymbol), Exports.size());
161 EXPECT_EQ(FileType::TBD_V2, File->getFileType());
167 EXPECT_EQ(Archs, File->getArchitectures());
168 EXPECT_EQ(File->getPlatforms().size(), 1U);
169 EXPECT_EQ(Platform, *File->getPlatforms().begin());
170 EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
171 EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());
172 EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
173 EXPECT_EQ(2U, File->getSwiftABIVersion());
174 EXPECT_EQ(ObjCConstraintType::Retain_Release, File->getObjCConstraint());
178 EXPECT_EQ(0U, File->allowableClients().size());
179 EXPECT_EQ(0U, File->reexportedLibraries().size());
248 EXPECT_EQ(FileType::TBD_V2, File->getFileType());
249 EXPECT_EQ(File->getPlatforms().size(), 1U);
250 EXPECT_EQ(Platform, *File->getPlatforms().begin());
265 EXPECT_EQ(FileType::TBD_V2, File->getFileType());
266 EXPECT_EQ(File->getPlatforms().size(), 1U);
267 EXPECT_EQ(Platform, *File->getPlatforms().begin());
282 EXPECT_EQ(FileType::TBD_V2, File->getFileType());
283 EXPECT_EQ(File->getPlatforms().size(), 1U);
284 EXPECT_EQ(Platform, *File->getPlatforms().begin());
299 EXPECT_EQ(FileType::TBD_V2, File->getFileType());
300 EXPECT_EQ(File->getPlatforms().size(), 1U);
301 EXPECT_EQ(Platform, *File->getPlatforms().begin());
316 EXPECT_EQ(FileType::TBD_V2, File->getFileType());
317 EXPECT_EQ(File->getPlatforms().size(), 1U);
318 EXPECT_EQ(Platform, *File->getPlatforms().begin());
333 EXPECT_EQ(FileType::TBD_V2, File->getFileType());
334 EXPECT_EQ(1U, File->getSwiftABIVersion());
349 EXPECT_EQ(FileType::TBD_V2, File->getFileType());
350 EXPECT_EQ(2U, File->getSwiftABIVersion());
365 EXPECT_EQ(FileType::TBD_V2, File->getFileType());
366 EXPECT_EQ(3U, File->getSwiftABIVersion());
381 EXPECT_EQ(FileType::TBD_V2, File->getFileType());
382 EXPECT_EQ(4U, File->getSwiftABIVersion());
397 EXPECT_EQ("malformed file\nTest.tbd:5:16: error: invalid Swift ABI "
413 EXPECT_EQ(FileType::TBD_V2, File->getFileType());
414 EXPECT_EQ(5U, File->getSwiftABIVersion());
429 EXPECT_EQ(FileType::TBD_V2, File->getFileType());
430 EXPECT_EQ(99U, File->getSwiftABIVersion());
455 EXPECT_EQ("malformed file\nTest.tbd:3:11: error: unknown platform\nplatform: "
472 EXPECT_EQ("malformed file\nTest.tbd:3:11: error: invalid platform\nplatform: "
unittests/TextAPI/TextStubV3Tests.cpp 94 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
100 EXPECT_EQ(Archs, File->getArchitectures());
105 EXPECT_EQ(Uuids, File->uuids());
106 EXPECT_EQ(File->getPlatforms().size(), 1U);
107 EXPECT_EQ(Platform, *File->getPlatforms().begin());
108 EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
109 EXPECT_EQ(PackedVersion(2, 3, 4), File->getCurrentVersion());
110 EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
111 EXPECT_EQ(2U, File->getSwiftABIVersion());
112 EXPECT_EQ(ObjCConstraintType::Retain_Release, File->getObjCConstraint());
118 EXPECT_EQ(1U, File->allowableClients().size());
119 EXPECT_EQ(client, File->allowableClients().front());
120 EXPECT_EQ(1U, File->reexportedLibraries().size());
121 EXPECT_EQ(reexport, File->reexportedLibraries().front());
133 EXPECT_EQ(sizeof(TBDv3Symbols) / sizeof(ExportedSymbol), Exports.size());
204 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
205 EXPECT_EQ(File->getPlatforms().size(), 1U);
206 EXPECT_EQ(Platform, *File->getPlatforms().begin());
221 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
222 EXPECT_EQ(File->getPlatforms().size(), 1U);
223 EXPECT_EQ(Platform, *File->getPlatforms().begin());
238 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
239 EXPECT_EQ(File->getPlatforms().size(), 1U);
240 EXPECT_EQ(Platform, *File->getPlatforms().begin());
255 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
256 EXPECT_EQ(File->getPlatforms().size(), 1U);
257 EXPECT_EQ(Platform, *File->getPlatforms().begin());
272 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
273 EXPECT_EQ(File->getPlatforms().size(), 1U);
274 EXPECT_EQ(Platform, *File->getPlatforms().begin());
289 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
290 EXPECT_EQ(Platform, *File->getPlatforms().begin());
304 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
309 EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
311 EXPECT_EQ(Platforms.count(Platform), 1U);
326 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
327 EXPECT_EQ(1U, File->getSwiftABIVersion());
342 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
343 EXPECT_EQ(2U, File->getSwiftABIVersion());
358 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
359 EXPECT_EQ(3U, File->getSwiftABIVersion());
374 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
375 EXPECT_EQ(4U, File->getSwiftABIVersion());
390 EXPECT_EQ("malformed file\nTest.tbd:5:20: error: invalid Swift ABI "
406 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
407 EXPECT_EQ(5U, File->getSwiftABIVersion());
422 EXPECT_EQ(FileType::TBD_V3, File->getFileType());
423 EXPECT_EQ(99U, File->getSwiftABIVersion());
449 EXPECT_EQ("malformed file\nTest.tbd:3:11: error: unknown platform\nplatform: "
unittests/TextAPI/TextStubV4Tests.cpp 111 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
124 EXPECT_EQ(Archs, File->getArchitectures());
125 EXPECT_EQ(uuids, File->uuids());
126 EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
128 EXPECT_EQ(Platforms.count(Platform), 1U);
129 EXPECT_EQ(std::string("Umbrella.framework/Umbrella"), File->getInstallName());
130 EXPECT_EQ(PackedVersion(1, 2, 3), File->getCurrentVersion());
131 EXPECT_EQ(PackedVersion(1, 2, 0), File->getCompatibilityVersion());
132 EXPECT_EQ(5U, File->getSwiftABIVersion());
139 EXPECT_EQ(1U, File->allowableClients().size());
140 EXPECT_EQ(client, File->allowableClients().front());
141 EXPECT_EQ(1U, File->reexportedLibraries().size());
142 EXPECT_EQ(reexport, File->reexportedLibraries().front());
160 EXPECT_EQ(sizeof(TBDv4ExportedSymbols) / sizeof(ExampleSymbol),
162 EXPECT_EQ(sizeof(TBDv4ReexportedSymbols) / sizeof(ExampleSymbol),
164 EXPECT_EQ(sizeof(TBDv4UndefinedSymbols) / sizeof(ExampleSymbol),
253 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
254 EXPECT_EQ(AK_x86_64 | AK_arm64 | AK_i386, File->getArchitectures());
255 EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
257 EXPECT_EQ(Platforms.count(Platform), 1U);
275 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
276 EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
277 EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
279 EXPECT_EQ(Platforms.count(Platform), 1U);
294 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
295 EXPECT_EQ(AK_arm64 | AK_armv7k, File->getArchitectures());
296 EXPECT_EQ(File->getPlatforms().size(), 1U);
297 EXPECT_EQ(PlatformKind::iOS, *File->getPlatforms().begin());
312 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
313 EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
314 EXPECT_EQ(File->getPlatforms().size(), 1U);
315 EXPECT_EQ(PlatformKind::macCatalyst, *File->getPlatforms().begin());
329 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
330 EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
331 EXPECT_EQ(File->getPlatforms().size(), 1U);
332 EXPECT_EQ(PlatformKind::iOS, *File->getPlatforms().begin());
346 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
347 EXPECT_EQ(File->getPlatforms().size(), 1U);
348 EXPECT_EQ(PlatformKind::bridgeOS, *File->getPlatforms().begin());
349 EXPECT_EQ(ArchitectureSet(AK_armv7k), File->getArchitectures());
362 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
363 EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
364 EXPECT_EQ(File->getPlatforms().size(), 1U);
365 EXPECT_EQ(PlatformKind::macOS, *File->getPlatforms().begin());
379 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
380 EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
381 EXPECT_EQ(File->getPlatforms().size(), 1U);
382 EXPECT_EQ(PlatformKind::iOSSimulator, *File->getPlatforms().begin());
397 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
398 EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
399 EXPECT_EQ(File->getPlatforms().size(), 1U);
400 EXPECT_EQ(PlatformKind::tvOSSimulator, *File->getPlatforms().begin());
415 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
416 EXPECT_EQ(ArchitectureSet(AK_i386), File->getArchitectures());
417 EXPECT_EQ(File->getPlatforms().size(), 1U);
418 EXPECT_EQ(PlatformKind::watchOSSimulator, *File->getPlatforms().begin());
432 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
433 EXPECT_EQ(1U, File->getSwiftABIVersion());
447 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
448 EXPECT_EQ(2U, File->getSwiftABIVersion());
462 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
463 EXPECT_EQ(5U, File->getSwiftABIVersion());
477 EXPECT_EQ(FileType::TBD_V4, File->getFileType());
478 EXPECT_EQ(99U, File->getSwiftABIVersion());
493 EXPECT_EQ("malformed file\nTest.tbd:3:12: error: unknown "
510 EXPECT_EQ("malformed file\nTest.tbd:3:12: error: unknown platform\ntargets: "
559 EXPECT_EQ("malformed file\nTest.tbd:5:20: error: invalid Swift ABI "
unittests/Transforms/IPO/LowerTypeTests.cpp 60 EXPECT_EQ(T.Bits, BSI.Bits);
61 EXPECT_EQ(T.ByteOffset, BSI.ByteOffset);
62 EXPECT_EQ(T.BitSize, BSI.BitSize);
63 EXPECT_EQ(T.AlignLog2, BSI.AlignLog2);
64 EXPECT_EQ(T.IsSingleOffset, BSI.isSingleOffset());
65 EXPECT_EQ(T.IsAllOnes, BSI.isAllOnes());
105 EXPECT_EQ(T.WantLayout, ComputedLayout);
149 EXPECT_EQ(A.WantByteOffset, GotByteOffset);
150 EXPECT_EQ(A.WantMask, GotMask);
153 EXPECT_EQ(T.WantBytes, BABuilder.Bytes);
unittests/Transforms/IPO/WholeProgramDevirt.cpp 34 EXPECT_EQ(2ull, findLowestOffset(Targets, /*IsAfter=*/false, 1));
35 EXPECT_EQ(66ull, findLowestOffset(Targets, /*IsAfter=*/true, 1));
37 EXPECT_EQ(8ull, findLowestOffset(Targets, /*IsAfter=*/false, 8));
38 EXPECT_EQ(72ull, findLowestOffset(Targets, /*IsAfter=*/true, 8));
41 EXPECT_EQ(33ull, findLowestOffset(Targets, /*IsAfter=*/false, 1));
42 EXPECT_EQ(65ull, findLowestOffset(Targets, /*IsAfter=*/true, 1));
44 EXPECT_EQ(40ull, findLowestOffset(Targets, /*IsAfter=*/false, 8));
45 EXPECT_EQ(72ull, findLowestOffset(Targets, /*IsAfter=*/true, 8));
49 EXPECT_EQ(66ull, findLowestOffset(Targets, /*IsAfter=*/false, 1));
50 EXPECT_EQ(2ull, findLowestOffset(Targets, /*IsAfter=*/true, 1));
52 EXPECT_EQ(72ull, findLowestOffset(Targets, /*IsAfter=*/false, 8));
53 EXPECT_EQ(8ull, findLowestOffset(Targets, /*IsAfter=*/true, 8));
57 EXPECT_EQ(16ull, findLowestOffset(Targets, /*IsAfter=*/true, 16));
58 EXPECT_EQ(40ull, findLowestOffset(Targets, /*IsAfter=*/true, 32));
84 EXPECT_EQ(-5ll, OffsetByte);
85 EXPECT_EQ(0ull, OffsetBit);
86 EXPECT_EQ(std::vector<uint8_t>{1}, VT1.Before.Bytes);
87 EXPECT_EQ(std::vector<uint8_t>{1}, VT1.Before.BytesUsed);
88 EXPECT_EQ(std::vector<uint8_t>{0}, VT2.Before.Bytes);
89 EXPECT_EQ(std::vector<uint8_t>{1}, VT2.Before.BytesUsed);
94 EXPECT_EQ(-5ll, OffsetByte);
95 EXPECT_EQ(7ull, OffsetBit);
96 EXPECT_EQ(std::vector<uint8_t>{1}, VT1.Before.Bytes);
97 EXPECT_EQ(std::vector<uint8_t>{0x81}, VT1.Before.BytesUsed);
98 EXPECT_EQ(std::vector<uint8_t>{0x80}, VT2.Before.Bytes);
99 EXPECT_EQ(std::vector<uint8_t>{0x81}, VT2.Before.BytesUsed);
104 EXPECT_EQ(-6ll, OffsetByte);
105 EXPECT_EQ(0ull, OffsetBit);
106 EXPECT_EQ((std::vector<uint8_t>{1, 12}), VT1.Before.Bytes);
107 EXPECT_EQ((std::vector<uint8_t>{0x81, 0xff}), VT1.Before.BytesUsed);
108 EXPECT_EQ((std::vector<uint8_t>{0x80, 34}), VT2.Before.Bytes);
109 EXPECT_EQ((std::vector<uint8_t>{0x81, 0xff}), VT2.Before.BytesUsed);
114 EXPECT_EQ(-8ll, OffsetByte);
115 EXPECT_EQ(0ull, OffsetBit);
116 EXPECT_EQ((std::vector<uint8_t>{1, 12, 0, 56}), VT1.Before.Bytes);
117 EXPECT_EQ((std::vector<uint8_t>{0x81, 0xff, 0xff, 0xff}),
119 EXPECT_EQ((std::vector<uint8_t>{0x80, 34, 0, 78}), VT2.Before.Bytes);
120 EXPECT_EQ((std::vector<uint8_t>{0x81, 0xff, 0xff, 0xff}),
126 EXPECT_EQ(4ll, OffsetByte);
127 EXPECT_EQ(0ull, OffsetBit);
128 EXPECT_EQ(std::vector<uint8_t>{1}, VT1.After.Bytes);
129 EXPECT_EQ(std::vector<uint8_t>{1}, VT1.After.BytesUsed);
130 EXPECT_EQ(std::vector<uint8_t>{0}, VT2.After.Bytes);
131 EXPECT_EQ(std::vector<uint8_t>{1}, VT2.After.BytesUsed);
136 EXPECT_EQ(4ll, OffsetByte);
137 EXPECT_EQ(7ull, OffsetBit);
138 EXPECT_EQ(std::vector<uint8_t>{1}, VT1.After.Bytes);
139 EXPECT_EQ(std::vector<uint8_t>{0x81}, VT1.After.BytesUsed);
140 EXPECT_EQ(std::vector<uint8_t>{0x80}, VT2.After.Bytes);
141 EXPECT_EQ(std::vector<uint8_t>{0x81}, VT2.After.BytesUsed);
146 EXPECT_EQ(5ll, OffsetByte);
147 EXPECT_EQ(0ull, OffsetBit);
148 EXPECT_EQ((std::vector<uint8_t>{1, 12}), VT1.After.Bytes);
149 EXPECT_EQ((std::vector<uint8_t>{0x81, 0xff}), VT1.After.BytesUsed);
150 EXPECT_EQ((std::vector<uint8_t>{0x80, 34}), VT2.After.Bytes);
151 EXPECT_EQ((std::vector<uint8_t>{0x81, 0xff}), VT2.After.BytesUsed);
156 EXPECT_EQ(6ll, OffsetByte);
157 EXPECT_EQ(0ull, OffsetBit);
158 EXPECT_EQ((std::vector<uint8_t>{1, 12, 56, 0}), VT1.After.Bytes);
159 EXPECT_EQ((std::vector<uint8_t>{0x81, 0xff, 0xff, 0xff}),
161 EXPECT_EQ((std::vector<uint8_t>{0x80, 34, 78, 0}), VT2.After.Bytes);
162 EXPECT_EQ((std::vector<uint8_t>{0x81, 0xff, 0xff, 0xff}),
unittests/Transforms/Utils/BasicBlockUtilsTest.cpp 51 EXPECT_EQ(F->size(), (size_t)4);
54 EXPECT_EQ(F->size(), (size_t)3);
79 EXPECT_EQ(F->size(), (size_t)3);
82 EXPECT_EQ(F->size(), (size_t)3);
135 EXPECT_EQ(1u, SplitAllCriticalEdges(*F, CESO));
unittests/Transforms/Utils/CloningTest.cpp 203 EXPECT_EQ(CallingConv::Cold, F2->getCallingConv());
236 EXPECT_EQ(Mapping.size(), 2u);
242 EXPECT_EQ(AddSplit->getOperand(0), V);
243 EXPECT_EQ(AddSplit->getOperand(1), V);
244 EXPECT_EQ(AddSplit->getParent(), Split);
248 EXPECT_EQ(MulSplit->getOperand(0), AddSplit);
249 EXPECT_EQ(MulSplit->getOperand(1), V);
250 EXPECT_EQ(MulSplit->getParent(), Split);
252 EXPECT_EQ(AddSplit->getNextNode(), MulSplit);
253 EXPECT_EQ(MulSplit->getNextNode(), Split->getTerminator());
285 EXPECT_EQ(Mapping.size(), 3u);
292 EXPECT_EQ(AddSplit->getOperand(0), V);
293 EXPECT_EQ(AddSplit->getOperand(1), V);
294 EXPECT_EQ(AddSplit->getParent(), Split);
298 EXPECT_EQ(MulSplit->getOperand(0), AddSplit);
299 EXPECT_EQ(MulSplit->getOperand(1), V);
300 EXPECT_EQ(MulSplit->getParent(), Split);
303 EXPECT_EQ(MulSplit->getNextNode(), SubSplit);
304 EXPECT_EQ(SubSplit->getNextNode(), Split->getTerminator());
305 EXPECT_EQ(Split->getSingleSuccessor(), BB2);
306 EXPECT_EQ(BB2->getSingleSuccessor(), Split);
338 EXPECT_EQ(Mapping.size(), 2u);
344 EXPECT_EQ(AddSplit->getOperand(0), V);
345 EXPECT_EQ(AddSplit->getOperand(1), V);
346 EXPECT_EQ(AddSplit->getParent(), Split);
350 EXPECT_EQ(MulSplit->getOperand(0), AddSplit);
351 EXPECT_EQ(MulSplit->getOperand(1), V);
352 EXPECT_EQ(MulSplit->getParent(), Split);
353 EXPECT_EQ(MulSplit->getNextNode(), Split->getTerminator());
354 EXPECT_EQ(Split->getSingleSuccessor(), BB2);
355 EXPECT_EQ(BB2->getSingleSuccessor(), Split);
427 EXPECT_EQ(Header, L->getHeader());
428 EXPECT_EQ(Preheader, L->getLoopPreheader());
435 EXPECT_EQ(NewLoop->getSubLoops().size(), 1u);
560 EXPECT_EQ(3U, Finder->subprogram_count());
578 EXPECT_EQ(OldI.hasMetadata(), NewI.hasMetadata());
584 EXPECT_EQ(OldDL.getLine(), NewDL.getLine());
585 EXPECT_EQ(OldDL.getCol(), NewDL.getCol());
590 EXPECT_EQ(OldFunc->getSubprogram(), OldSubprogram);
591 EXPECT_EQ(NewFunc->getSubprogram(), NewSubprogram);
597 EXPECT_EQ(OldEnd, OldIter);
598 EXPECT_EQ(NewEnd, NewIter);
618 EXPECT_EQ(OldFunc, cast<AllocaInst>(OldIntrin->getAddress())->
621 EXPECT_EQ(NewFunc, cast<AllocaInst>(NewIntrin->getAddress())->
627 EXPECT_EQ(OldIntrin->getVariable(), NewIntrin->getVariable());
630 EXPECT_EQ(OldFunc->getSubprogram(),
633 EXPECT_EQ(NewFunc->getSubprogram(),
642 EXPECT_EQ(OldFunc->getSubprogram(),
645 EXPECT_EQ(NewFunc->getSubprogram(),
791 EXPECT_EQ(1U, Finder.subprogram_count());
798 EXPECT_EQ(SP->getName(), "f");
799 EXPECT_EQ(SP->getFile()->getFilename(), "filename.c");
800 EXPECT_EQ(SP->getLine(), (unsigned)4);
815 EXPECT_EQ(GVs.size(), 1U);
821 EXPECT_EQ(GV->getName(), "gv");
822 EXPECT_EQ(GV->getLine(), 1U);
828 EXPECT_EQ(GV->getScope(), SP);
835 EXPECT_EQ(NMD->getNumOperands(), 1U);
843 EXPECT_EQ(SP->getUnit(), CU);
847 EXPECT_EQ(GlobalArray.size(), 2U);
850 EXPECT_EQ(GV->getScope(), SP);
858 EXPECT_EQ("comdat", CD->getName());
859 EXPECT_EQ(Comdat::ExactMatch, CD->getSelectionKind());
862 EXPECT_EQ(CD, NewF->getComdat());
unittests/Transforms/Utils/FunctionComparatorTest.cpp 118 EXPECT_EQ(Cmp.testCompare(), -1);
119 EXPECT_EQ(Cmp.testCompareSignature(), 0);
120 EXPECT_EQ(Cmp.testCmpBasicBlocks(F1.BB, F2.BB), -1);
121 EXPECT_EQ(Cmp.testCmpConstants(F1.C, F2.C), -1);
122 EXPECT_EQ(Cmp.testCmpGlobalValues(F1.F, F2.F), -1);
123 EXPECT_EQ(Cmp.testCmpValues(F1.I, F2.I), 0);
125 EXPECT_EQ(Cmp.testCmpOperations(F1.I, F2.I, needToCmpOperands), 0);
127 EXPECT_EQ(Cmp.testCmpTypes(F1.T, F2.T), 0);
128 EXPECT_EQ(Cmp.testCmpPrimitives(), -4);
unittests/Transforms/Utils/LocalTest.cpp 48 EXPECT_EQ(&bb0->front(), br0);
49 EXPECT_EQ(&bb1->front(), br1);
102 EXPECT_EQ(3U, BB->size());
163 EXPECT_EQ(2, Declares);
558 EXPECT_EQ(DI->getVariable()->getName(), "x");
621 EXPECT_EQ(changeToUnreachable(&A, /*UseLLVMTrap*/false), 1U);
629 EXPECT_EQ(DLA, DLB);
736 EXPECT_EQ(2U, CDbgVals.size());
748 EXPECT_EQ(2U, DDbgVals.size());
760 EXPECT_EQ(ConstantInt::get(A.getType(), 0), ADbgVal->getVariableLocation());
767 EXPECT_EQ(0U, FDbgVals.size());
779 EXPECT_EQ(6U, ADbgVals.size());
unittests/Transforms/Utils/SSAUpdaterBulkTest.cpp 93 EXPECT_EQ(UpdatePhiA->getIncomingValueForBlock(TrueBB), AddOp1);
94 EXPECT_EQ(UpdatePhiA->getIncomingValueForBlock(FalseBB), AddOp2);
95 EXPECT_EQ(UpdatePhiA, dyn_cast_or_null<PHINode>(I1->getOperand(0)));
99 EXPECT_EQ(UpdatePhiB->getIncomingValueForBlock(TrueBB), SubOp1);
100 EXPECT_EQ(UpdatePhiB->getIncomingValueForBlock(FalseBB), SubOp2);
101 EXPECT_EQ(UpdatePhiB, dyn_cast_or_null<PHINode>(I3->getOperand(1)));
104 EXPECT_EQ(I4->getOperand(0), SubOp1);
105 EXPECT_EQ(I4->getOperand(1), SubOp2);
183 EXPECT_EQ(Inserted.size(), 1u);
186 EXPECT_EQ(I1->getOperand(0), AddOp1);
187 EXPECT_EQ(Return->getOperand(0), FirstArg);
192 EXPECT_EQ(UpdatePhi->getIncomingValueForBlock(LoopStartBB), AddOp2);
193 EXPECT_EQ(UpdatePhi->getIncomingValueForBlock(IfBB), UndefValue::get(I32Ty));
unittests/Transforms/Utils/ValueMapperTest.cpp 27 EXPECT_EQ(U, ValueMapper(VM).mapMDNode(*U));
48 EXPECT_EQ(U1, U0->getOperand(0));
49 EXPECT_EQ(U0, U1->getOperand(0));
54 EXPECT_EQ(U0, ValueMapper(VM).mapMDNode(*U0));
55 EXPECT_EQ(U1, ValueMapper(VM).mapMDNode(*U1));
61 EXPECT_EQ(U1, ValueMapper(VM).mapMDNode(*U1));
62 EXPECT_EQ(U0, ValueMapper(VM).mapMDNode(*U0));
100 EXPECT_EQ(ConstantAsMetadata::get(G1.get()), MappedN1->getOperand(1));
112 EXPECT_EQ(T.get(), ValueMapper(VM, RF_NoModuleLevelChanges).mapMDNode(*T));
127 EXPECT_EQ(D, ValueMapper(VM, RF_MoveDistinctMDs).mapMDNode(*D));
142 EXPECT_EQ(D, ValueMapper(VM, RF_MoveDistinctMDs).mapMDNode(*D));
143 EXPECT_EQ(New, D->getOperand(0));
152 EXPECT_EQ(None, VM.getMappedMD(D));
155 EXPECT_EQ(D, *VM.getMappedMD(D));
156 EXPECT_EQ(D, ValueMapper(VM).mapMDNode(*D));
165 EXPECT_EQ(None, VM.getMappedMD(D));
168 EXPECT_EQ(nullptr, *VM.getMappedMD(D));
169 EXPECT_EQ(nullptr, ValueMapper(VM).mapMDNode(*D));
181 EXPECT_EQ(nullptr, ValueMapper(VM, Flags).mapValue(*F));
190 EXPECT_EQ(S1, ValueMapper(VM).mapMetadata(*S1));
191 EXPECT_EQ(None, VM.getMappedMD(S1));
196 EXPECT_EQ(S2, ValueMapper(VM).mapMetadata(*S1));
207 EXPECT_EQ(N0, ValueMapper(VM).mapMetadata(*N0));
208 EXPECT_EQ(N1, ValueMapper(VM).mapMetadata(*N1));
212 EXPECT_EQ(N0, *VM.getMappedMD(N0));
213 EXPECT_EQ(N1, *VM.getMappedMD(N1));
224 EXPECT_EQ(N0, ValueMapper(VM, RF_NoModuleLevelChanges).mapMetadata(*N0));
225 EXPECT_EQ(N1, ValueMapper(VM, RF_NoModuleLevelChanges).mapMetadata(*N1));
227 EXPECT_EQ(None, VM.getMappedMD(N0));
228 EXPECT_EQ(None, VM.getMappedMD(N1));
242 EXPECT_EQ(CAM, ValueMapper(VM).mapMetadata(*CAM));
244 EXPECT_EQ(CAM, ValueMapper(VM, RF_IgnoreMissingLocals).mapMetadata(*CAM));
250 EXPECT_EQ(N, ValueMapper(VM).mapMetadata(*CAM));
251 EXPECT_EQ(N, ValueMapper(VM, RF_IgnoreMissingLocals).mapMetadata(*CAM));
261 EXPECT_EQ(F2.get(), cast<ConstantAsMetadata>(F2MD)->getValue());
308 EXPECT_EQ(N0AV, ValueMapper(VM).mapValue(*MAV));
309 EXPECT_EQ(nullptr, ValueMapper(VM, RF_IgnoreMissingLocals).mapValue(*MAV));
312 EXPECT_EQ(None, VM.getMappedMD(LAM));
315 EXPECT_EQ(MAV, ValueMapper(VM).mapValue(*MAV));
316 EXPECT_EQ(MAV, ValueMapper(VM, RF_IgnoreMissingLocals).mapValue(*MAV));
321 EXPECT_EQ(&A, ValueMapper(VM).mapValue(*MAV));
322 EXPECT_EQ(&A, ValueMapper(VM, RF_IgnoreMissingLocals).mapValue(*MAV));
345 EXPECT_EQ(&C, ValueMapper(VM).mapValue(A));
346 EXPECT_EQ(MDC, ValueMapper(VM).mapValue(*MDA));
unittests/Transforms/Vectorize/VPlanDominatorTreeTest.cpp 152 EXPECT_EQ(PH, VPDT.findNearestCommonDominator(PH, PH));
153 EXPECT_EQ(PH, VPDT.findNearestCommonDominator(PH, H));
154 EXPECT_EQ(PH, VPDT.findNearestCommonDominator(PH, IfThen));
155 EXPECT_EQ(PH, VPDT.findNearestCommonDominator(PH, IfElse));
156 EXPECT_EQ(PH, VPDT.findNearestCommonDominator(PH, Latch));
157 EXPECT_EQ(PH, VPDT.findNearestCommonDominator(PH, Exit));
159 EXPECT_EQ(PH, VPDT.findNearestCommonDominator(H, PH));
160 EXPECT_EQ(H, VPDT.findNearestCommonDominator(H, H));
161 EXPECT_EQ(H, VPDT.findNearestCommonDominator(H, IfThen));
162 EXPECT_EQ(H, VPDT.findNearestCommonDominator(H, IfElse));
163 EXPECT_EQ(H, VPDT.findNearestCommonDominator(H, Latch));
164 EXPECT_EQ(H, VPDT.findNearestCommonDominator(H, Exit));
166 EXPECT_EQ(PH, VPDT.findNearestCommonDominator(IfThen, PH));
167 EXPECT_EQ(H, VPDT.findNearestCommonDominator(IfThen, H));
168 EXPECT_EQ(IfThen, VPDT.findNearestCommonDominator(IfThen, IfThen));
169 EXPECT_EQ(H, VPDT.findNearestCommonDominator(IfThen, IfElse));
170 EXPECT_EQ(H, VPDT.findNearestCommonDominator(IfThen, Latch));
171 EXPECT_EQ(H, VPDT.findNearestCommonDominator(IfThen, Exit));
173 EXPECT_EQ(PH, VPDT.findNearestCommonDominator(IfElse, PH));
174 EXPECT_EQ(H, VPDT.findNearestCommonDominator(IfElse, H));
175 EXPECT_EQ(H, VPDT.findNearestCommonDominator(IfElse, IfThen));
176 EXPECT_EQ(IfElse, VPDT.findNearestCommonDominator(IfElse, IfElse));
177 EXPECT_EQ(H, VPDT.findNearestCommonDominator(IfElse, Latch));
178 EXPECT_EQ(H, VPDT.findNearestCommonDominator(IfElse, Exit));
180 EXPECT_EQ(PH, VPDT.findNearestCommonDominator(Latch, PH));
181 EXPECT_EQ(H, VPDT.findNearestCommonDominator(Latch, H));
182 EXPECT_EQ(H, VPDT.findNearestCommonDominator(Latch, IfThen));
183 EXPECT_EQ(H, VPDT.findNearestCommonDominator(Latch, IfElse));
184 EXPECT_EQ(Latch, VPDT.findNearestCommonDominator(Latch, Latch));
185 EXPECT_EQ(Latch, VPDT.findNearestCommonDominator(Latch, Exit));
187 EXPECT_EQ(PH, VPDT.findNearestCommonDominator(Exit, PH));
188 EXPECT_EQ(H, VPDT.findNearestCommonDominator(Exit, H));
189 EXPECT_EQ(H, VPDT.findNearestCommonDominator(Exit, IfThen));
190 EXPECT_EQ(H, VPDT.findNearestCommonDominator(Exit, IfElse));
191 EXPECT_EQ(Latch, VPDT.findNearestCommonDominator(Exit, Latch));
192 EXPECT_EQ(Exit, VPDT.findNearestCommonDominator(Exit, Exit));
unittests/Transforms/Vectorize/VPlanHCFGTest.cpp 45 EXPECT_EQ(0u, Entry->getNumPredecessors());
46 EXPECT_EQ(1u, Entry->getNumSuccessors());
47 EXPECT_EQ(nullptr, Entry->getCondBit());
50 EXPECT_EQ(7u, VecBB->size());
51 EXPECT_EQ(2u, VecBB->getNumPredecessors());
52 EXPECT_EQ(2u, VecBB->getNumSuccessors());
56 EXPECT_EQ(Instruction::PHI, Phi->getOpcode());
59 EXPECT_EQ(Instruction::GetElementPtr, Idx->getOpcode());
60 EXPECT_EQ(2u, Idx->getNumOperands());
61 EXPECT_EQ(Phi, Idx->getOperand(1));
64 EXPECT_EQ(Instruction::Load, Load->getOpcode());
65 EXPECT_EQ(1u, Load->getNumOperands());
66 EXPECT_EQ(Idx, Load->getOperand(0));
69 EXPECT_EQ(Instruction::Add, Add->getOpcode());
70 EXPECT_EQ(2u, Add->getNumOperands());
71 EXPECT_EQ(Load, Add->getOperand(0));
74 EXPECT_EQ(Instruction::Store, Store->getOpcode());
75 EXPECT_EQ(2u, Store->getNumOperands());
76 EXPECT_EQ(Add, Store->getOperand(0));
77 EXPECT_EQ(Idx, Store->getOperand(1));
80 EXPECT_EQ(Instruction::Add, IndvarAdd->getOpcode());
81 EXPECT_EQ(2u, IndvarAdd->getNumOperands());
82 EXPECT_EQ(Phi, IndvarAdd->getOperand(0));
85 EXPECT_EQ(Instruction::ICmp, ICmp->getOpcode());
86 EXPECT_EQ(2u, ICmp->getNumOperands());
87 EXPECT_EQ(IndvarAdd, ICmp->getOperand(0));
88 EXPECT_EQ(VecBB->getCondBit(), ICmp);
127 EXPECT_EQ(0u, Entry->getNumPredecessors());
128 EXPECT_EQ(1u, Entry->getNumSuccessors());
131 EXPECT_EQ(6u, VecBB->size());
132 EXPECT_EQ(2u, VecBB->getNumPredecessors());
133 EXPECT_EQ(2u, VecBB->getNumSuccessors());
153 EXPECT_EQ(VecBB->end(), Iter);
unittests/Transforms/Vectorize/VPlanLoopInfoTest.cpp 61 EXPECT_EQ(1, std::distance(VPLI.begin(), VPLI.end()));
66 EXPECT_EQ(nullptr, VPLI.getLoopFor(PH));
68 EXPECT_EQ(VPLp, VPLI.getLoopFor(H));
70 EXPECT_EQ(VPLp, VPLI.getLoopFor(IfThen));
72 EXPECT_EQ(VPLp, VPLI.getLoopFor(IfElse));
74 EXPECT_EQ(VPLp, VPLI.getLoopFor(Latch));
76 EXPECT_EQ(nullptr, VPLI.getLoopFor(Exit));
79 EXPECT_EQ(PH, VPLp->getLoopPreheader());
80 EXPECT_EQ(H, VPLp->getHeader());
81 EXPECT_EQ(Latch, VPLp->getLoopLatch());
82 EXPECT_EQ(Latch, VPLp->getExitingBlock());
83 EXPECT_EQ(Exit, VPLp->getExitBlock());
unittests/Transforms/Vectorize/VPlanPredicatorTest.cpp 95 EXPECT_EQ(CBV1, OuterIfPred);
96 EXPECT_EQ(InnerAnd->getOpcode(), Instruction::And);
97 EXPECT_EQ(InnerAnd->getOperand(0), CBV1);
98 EXPECT_EQ(InnerAnd->getOperand(1), CBV2);
99 EXPECT_EQ(InnerIfPred, InnerAnd);
102 EXPECT_EQ(InnerLoopLinSucc, OuterIf);
103 EXPECT_EQ(OuterIfLinSucc, InnerIf);
104 EXPECT_EQ(InnerIfLinSucc, InnerLoopLatch);
196 EXPECT_EQ(And->getOpcode(), Instruction::And);
197 EXPECT_EQ(NotAnd->getOpcode(), Instruction::And);
198 EXPECT_EQ(Not->getOpcode(), VPInstruction::Not);
200 EXPECT_EQ(And->getOperand(0), OuterCBV);
201 EXPECT_EQ(And->getOperand(1), InnerCBV);
203 EXPECT_EQ(Not->getOperand(0), InnerCBV);
205 EXPECT_EQ(NotAnd->getOperand(0), OuterCBV);
206 EXPECT_EQ(NotAnd->getOperand(1), Not);
208 EXPECT_EQ(InnerIfTSucc->getPredicate(), And);
209 EXPECT_EQ(InnerIfFSucc->getPredicate(), NotAnd);
211 EXPECT_EQ(TSuccSucc, FSuccSucc);
212 EXPECT_EQ(Or->getOpcode(), Instruction::Or);
213 EXPECT_EQ(TSuccSucc->getPredicate(), Or);
unittests/Transforms/Vectorize/VPlanSlpTest.cpp 110 EXPECT_EQ(64u, Slp.getWidestBundleBits());
111 EXPECT_EQ(VPInstruction::SLPStore, CombinedStore->getOpcode());
114 EXPECT_EQ(Instruction::Add, CombinedAdd->getOpcode());
118 EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadA->getOpcode());
119 EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadB->getOpcode());
179 EXPECT_EQ(64u, Slp.getWidestBundleBits());
180 EXPECT_EQ(VPInstruction::SLPStore, CombinedStore->getOpcode());
183 EXPECT_EQ(Instruction::Add, CombinedAdd->getOpcode());
187 EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadA->getOpcode());
188 EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadB->getOpcode());
192 EXPECT_EQ(GetA, CombinedLoadA->getOperand(0));
193 EXPECT_EQ(GetB, CombinedLoadB->getOperand(0));
244 EXPECT_EQ(64u, Slp.getWidestBundleBits());
245 EXPECT_EQ(VPInstruction::SLPStore, CombinedStore->getOpcode());
248 EXPECT_EQ(Instruction::Add, CombinedAdd->getOpcode());
251 EXPECT_EQ(CombinedLoadA, CombinedAdd->getOperand(1));
252 EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadA->getOpcode());
314 EXPECT_EQ(CombinedStore->getOpcode(), VPInstruction::SLPStore);
318 EXPECT_EQ(CombinedAdd->getOpcode(), Instruction::Add);
324 EXPECT_EQ(CombinedMulAB->getOpcode(), Instruction::Mul);
328 EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadA->getOpcode());
331 EXPECT_EQ(LoadvA0->getOperand(0), CombinedLoadA->getOperand(0));
332 EXPECT_EQ(LoadvA1->getOperand(0), CombinedLoadA->getOperand(1));
336 EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadB->getOpcode());
339 EXPECT_EQ(LoadvB0->getOperand(0), CombinedLoadB->getOperand(0));
340 EXPECT_EQ(LoadvB1->getOperand(0), CombinedLoadB->getOperand(1));
342 EXPECT_EQ(CombinedMulCD->getOpcode(), Instruction::Mul);
346 EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadC->getOpcode());
349 EXPECT_EQ(LoadvC0->getOperand(0), CombinedLoadC->getOperand(0));
350 EXPECT_EQ(LoadvC1->getOperand(0), CombinedLoadC->getOperand(1));
354 EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadD->getOpcode());
357 EXPECT_EQ(LoadvD0->getOperand(0), CombinedLoadD->getOperand(0));
358 EXPECT_EQ(LoadvD1->getOperand(0), CombinedLoadD->getOperand(1));
575 EXPECT_EQ(nullptr, Slp.buildGraph(StoreRoot));
712 EXPECT_EQ(nullptr, Slp.buildGraph(StoreRoot));
713 EXPECT_EQ(0u, Slp.getWidestBundleBits());
775 EXPECT_EQ(nullptr, Slp.buildGraph(StoreRoot));
776 EXPECT_EQ(0u, Slp.getWidestBundleBits());
834 EXPECT_EQ(nullptr, Slp.buildGraph(StoreRoot));
unittests/XRay/FDRProducerConsumerTest.cpp 157 EXPECT_EQ(Data2.substr(sizeof(XRayFileHeader)),
198 EXPECT_EQ(Data2.substr(sizeof(XRayFileHeader)),
unittests/XRay/GraphTest.cpp 68 EXPECT_EQ(V.size(), G.vertices().size());
73 EXPECT_EQ(1u, G.count(u));
74 EXPECT_EQ(VA[u], EVV->VA);
82 EXPECT_EQ(1u, V.count(VVT.first));
83 EXPECT_EQ(VA[VVT.first], VVT.second.VA);
94 EXPECT_EQ(E.size(), G.edges().size());
99 EXPECT_EQ(1u, G.count(u));
100 EXPECT_EQ(VA[u.first] * VA[u.second] * ((u.first > u.second) ? 2 : 1),
109 EXPECT_EQ(1u, E.count(EV.first));
110 EXPECT_EQ(VA[EV.first.first] * VA[EV.first.second] *
129 EXPECT_EQ(G.inEdges(EV.first.first).end(), It);
136 EXPECT_EQ(G.outEdges(EV.first.second).end(), It);
184 EXPECT_EQ(0u, G.count(0u));
185 EXPECT_EQ(0u, G.count({0u, 1u}));
194 EXPECT_EQ(G.vertices().begin(), G.vertices().end());
195 EXPECT_EQ(G.edges().begin(), G.edges().end());
203 EXPECT_EQ(1u, MG[0u].VA);
204 EXPECT_EQ(1u, G.count(0u));
205 EXPECT_EQ(0u, G.count(1u));
206 EXPECT_EQ(1u, MG[0u].VA);
209 EXPECT_EQ(1u, T->VA);
211 EXPECT_EQ(1u, G.vertices().size());
212 EXPECT_EQ(0u, G.edges().size());
216 EXPECT_EQ(G.edges().begin(), G.edges().end());
217 EXPECT_EQ(1u, G.vertices().begin()->second.VA);
218 EXPECT_EQ(0u, G.vertices().begin()->first);
219 EXPECT_EQ(0u, G.outEdges(0u).size());
221 EXPECT_EQ(G.outEdges(0u).begin(), G.outEdges(0u).end());
222 EXPECT_EQ(0u, G.inEdges(0u).size());
224 EXPECT_EQ(G.inEdges(0u).begin(), G.inEdges(0u).end());
233 EXPECT_EQ(2u, MG[EdgeIdent].EA);
234 EXPECT_EQ(1u, G.count({0u, 0u}));
235 EXPECT_EQ(0u, G.count({0u, 1u}));
236 EXPECT_EQ(1u, G.count(0u));
240 EXPECT_EQ(1u, G.edges().size());
241 EXPECT_EQ(1u, G.vertices().size());
245 EXPECT_EQ(EI(0u, 0u), G.edges().begin()->first);
246 EXPECT_EQ(2u, G.edges().begin()->second.EA);
247 EXPECT_EQ(1u, G.outEdges(0u).size());
250 EXPECT_EQ(EI(0u, 0u), G.outEdges(0u).begin()->first);
251 EXPECT_EQ(2u, G.outEdges(0u).begin()->second.EA);
252 EXPECT_EQ(++(G.outEdges(0u).begin()), G.outEdges(0u).end());
253 EXPECT_EQ(1u, G.inEdges(0u).size());
256 EXPECT_EQ(EI(0u, 0u), G.inEdges(0u).begin()->first);
257 EXPECT_EQ(2u, G.inEdges(0u).begin()->second.EA);
258 EXPECT_EQ(++(G.inEdges(0u).begin()), G.inEdges(0u).end());
unittests/tools/llvm-cfi-verify/FileAnalysis.cpp 111 EXPECT_EQ(nullptr, Analysis.getInstruction(0x0));
112 EXPECT_EQ(nullptr, Analysis.getInstruction(0x1000));
117 EXPECT_EQ(0xDEADBEEF, InstrMeta->VMAddress);
118 EXPECT_EQ(1u, InstrMeta->InstructionSize);
122 EXPECT_EQ(nullptr, Analysis.getPrevInstructionSequential(*InstrMeta));
128 EXPECT_EQ(NextInstrMeta, InstrMeta);
129 EXPECT_EQ(0xDEADBEEF + 1, InstrMeta->VMAddress);
130 EXPECT_EQ(2u, InstrMeta->InstructionSize);
134 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta));
140 EXPECT_EQ(NextInstrMeta, InstrMeta);
141 EXPECT_EQ(0xDEADBEEF + 3, InstrMeta->VMAddress);
142 EXPECT_EQ(3u, InstrMeta->InstructionSize);
146 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta));
152 EXPECT_EQ(NextInstrMeta, InstrMeta);
153 EXPECT_EQ(0xDEADBEEF + 6, InstrMeta->VMAddress);
154 EXPECT_EQ(4u, InstrMeta->InstructionSize);
158 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta));
164 EXPECT_EQ(NextInstrMeta, InstrMeta);
165 EXPECT_EQ(0xDEADBEEF + 10, InstrMeta->VMAddress);
166 EXPECT_EQ(10u, InstrMeta->InstructionSize);
169 EXPECT_EQ(nullptr, Analysis.getNextInstructionSequential(*InstrMeta));
170 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta));
176 EXPECT_EQ(0xDEADBEEF + 20, InstrMeta->VMAddress);
177 EXPECT_EQ(1u, InstrMeta->InstructionSize);
180 EXPECT_EQ(nullptr, Analysis.getNextInstructionSequential(*InstrMeta));
181 EXPECT_EQ(PrevInstrMeta, Analysis.getPrevInstructionSequential(*InstrMeta));
186 EXPECT_EQ(0xDEADBEEF + 21, InstrMeta->VMAddress);
187 EXPECT_EQ(2u, InstrMeta->InstructionSize);
190 EXPECT_EQ(nullptr, Analysis.getNextInstructionSequential(*InstrMeta));
191 EXPECT_EQ(nullptr, Analysis.getPrevInstructionSequential(*InstrMeta));
196 EXPECT_EQ(0xDEADBEEF + 23, InstrMeta->VMAddress);
197 EXPECT_EQ(5u, InstrMeta->InstructionSize);
200 EXPECT_EQ(nullptr, Analysis.getNextInstructionSequential(*InstrMeta));
201 EXPECT_EQ(nullptr, Analysis.getPrevInstructionSequential(*InstrMeta));
218 EXPECT_EQ(0xDEADBEEF, GoodInstrMeta->VMAddress);
219 EXPECT_EQ(1u, GoodInstrMeta->InstructionSize);
223 EXPECT_EQ(0xDEADBEEF + 2, GoodInstrMeta->VMAddress);
224 EXPECT_EQ(1u, GoodInstrMeta->InstructionSize);
330 EXPECT_EQ(0xDEADBEEF + 1, Next->VMAddress);
333 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current));
336 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current));
339 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current));
342 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current));
347 EXPECT_EQ(0xDEADBEEF + 10, Next->VMAddress);
352 EXPECT_EQ(0xDEADBEEF + 17, Next->VMAddress);
357 EXPECT_EQ(0xDEADBEEF + 17, Next->VMAddress);
361 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current));
367 EXPECT_EQ(0xDEADBEEF + 31, Next->VMAddress);
370 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current));
372 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current));
374 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current));
376 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current));
381 EXPECT_EQ(0xDEADBEEF + 1, Next->VMAddress);
384 EXPECT_EQ(nullptr, Analysis.getDefiniteNextInstruction(*Current));
389 EXPECT_EQ(0xDEADBEEF + 4, Next->VMAddress);
509 EXPECT_EQ(CFIProtectionStatus::FAIL_NOT_INDIRECT_CF,
512 EXPECT_EQ(CFIProtectionStatus::FAIL_NOT_INDIRECT_CF,
515 EXPECT_EQ(CFIProtectionStatus::FAIL_NOT_INDIRECT_CF,
518 EXPECT_EQ(CFIProtectionStatus::FAIL_INVALID_INSTRUCTION,
534 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
550 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
569 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
587 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
611 EXPECT_EQ(CFIProtectionStatus::FAIL_ORPHANS,
636 EXPECT_EQ(CFIProtectionStatus::FAIL_BAD_CONDITIONAL_BRANCH,
655 EXPECT_EQ(CFIProtectionStatus::FAIL_ORPHANS,
672 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
702 EXPECT_EQ(CFIProtectionStatus::FAIL_ORPHANS,
721 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
752 EXPECT_EQ(CFIProtectionStatus::FAIL_BAD_CONDITIONAL_BRANCH,
756 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
760 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
778 EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
795 EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
812 EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
831 EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
845 EXPECT_EQ(CFIProtectionStatus::FAIL_ORPHANS,
861 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
878 EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
895 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
913 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
931 EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
949 EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
967 EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
985 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
1003 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
1020 EXPECT_EQ(CFIProtectionStatus::FAIL_ORPHANS,
1040 EXPECT_EQ(CFIProtectionStatus::PROTECTED,
1061 EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
1082 EXPECT_EQ(CFIProtectionStatus::FAIL_REGISTER_CLOBBERED,
unittests/tools/llvm-exegesis/AArch64/TargetTest.cpp 70 EXPECT_EQ(ExegesisTarget_->getPfmCounters("").CycleCounter, Expected);
71 EXPECT_EQ(ExegesisTarget_->getPfmCounters("unknown_cpu").CycleCounter,
unittests/tools/llvm-exegesis/BenchmarkRunnerTest.cpp 20 EXPECT_EQ(reinterpret_cast<intptr_t>(Space.ptr()) %
26 EXPECT_EQ(Space.ptr()[0], 0);
27 EXPECT_EQ(Space.ptr()[BenchmarkRunner::ScratchSpace::kSize - 1], 0);
unittests/tools/llvm-exegesis/ClusteringTest.cpp 61 EXPECT_EQ(Clustering.get().getClusterIdForPoint(2),
63 EXPECT_EQ(Clustering.get().getClusterIdForPoint(5),
65 EXPECT_EQ(Clustering.get().getClusterIdForPoint(0),
67 EXPECT_EQ(Clustering.get().getClusterIdForPoint(1),
unittests/tools/llvm-exegesis/Mips/TargetTest.cpp 82 EXPECT_EQ(State.getExegesisTarget().getPfmCounters("").CycleCounter,
84 EXPECT_EQ(
unittests/tools/llvm-exegesis/PowerPC/TargetTest.cpp 62 EXPECT_EQ(ExegesisTarget_->getPfmCounters("").CycleCounter, Expected);
63 EXPECT_EQ(ExegesisTarget_->getPfmCounters("unknown_cpu").CycleCounter,
unittests/tools/llvm-exegesis/X86/BenchmarkResultTest.cpp 99 EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
100 EXPECT_EQ(FromDisk.Mode, ToDisk.Mode);
101 EXPECT_EQ(FromDisk.CpuName, ToDisk.CpuName);
102 EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);
103 EXPECT_EQ(FromDisk.NumRepetitions, ToDisk.NumRepetitions);
106 EXPECT_EQ(FromDisk.Info, ToDisk.Info);
116 EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
117 EXPECT_EQ(FromDisk.Mode, ToDisk.Mode);
118 EXPECT_EQ(FromDisk.CpuName, ToDisk.CpuName);
119 EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);
120 EXPECT_EQ(FromDisk.NumRepetitions, ToDisk.NumRepetitions);
123 EXPECT_EQ(FromDisk.Info, ToDisk.Info);
133 EXPECT_EQ(Stats.min(), -1.0);
134 EXPECT_EQ(Stats.max(), 1.5);
135 EXPECT_EQ(Stats.avg(), 0.25); // (0.5+1.5-1.0+0.0) / 4
unittests/tools/llvm-exegesis/X86/SnippetGeneratorTest.cpp 330 EXPECT_EQ(IT.VariableValues[2].getImm(), 1);
331 EXPECT_EQ(IT.VariableValues[3].getReg(), 0u);
332 EXPECT_EQ(IT.VariableValues[4].getImm(), 0);
333 EXPECT_EQ(IT.VariableValues[5].getReg(), 0u);