name string | code string | asm string | file string |
|---|---|---|---|
testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations() | void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
const auto& ignored = *GetIgnoredParameterizedTestSuites();
for (const auto& testcase : suites_) {
if (testcase.second.instantiated) continue;
if (ignored.find(testcase.first) != ignored.end()) continue;
std::string message =
"... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %r15
callq 0xb8c6
movq 0x18(%r15), %r14
addq $0x8, %r15
cmpq %r15, %r14
je 0xcfe4
movq 0x4115e(%rip), %rax # 0x4dc00
leaq 0x130(%rax), %rcx
movq %rcx, -0x138(%rbp)
addq $0x138, %ra... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::GetArgvs[abi:cxx11]() | ::std::vector<std::string> GetArgvs() {
#if defined(GTEST_CUSTOM_GET_ARGVS_)
// GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or
// ::string. This code converts it to the appropriate type.
const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
return ::std::vector<std::string>(custom.begin(), custom.... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40987(%rip), %rsi # 0x4dba0
callq 0x2d744
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::GetCurrentExecutableName() | FilePath GetCurrentExecutableName() {
FilePath result;
#if GTEST_OS_WINDOWS || GTEST_OS_OS2
result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
#else
result.Set(FilePath(GetArgvs()[0]));
#endif // GTEST_OS_WINDOWS
return result.RemoveDirectoryName();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x4094d(%rip), %rsi # 0x4dba0
leaq -0x70(%rbp), %rdi
callq 0x2d744
movq -0x70(%rbp), %rax
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::FilePath::RemoveDirectoryName() const | FilePath FilePath::RemoveDirectoryName() const {
const char* const last_sep = FindLastPathSeparator();
return last_sep ? FilePath(last_sep + 1) : *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %r15
movq %r15, %rdi
movl $0x2f, %esi
callq 0x85c0
movq %rax, %r14
testq %rax, %rax
setne %r13b
je 0xd3e8
leaq 0x1(%r14), %r15
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
mov... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc |
testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile[abi:cxx11]() | std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
std::string format = GetOutputFormat();
if (format.empty())
format = std::string(kDefaultOutputFormat);
const char* const colon = strchr(gtest_output_flag, ':');
if (colon == nu... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
movq 0x4062a(%rip), %r14 # 0x4db20
leaq -0x110(%rbp), %r15
movq %r15, %rdi
callq 0xd46a
cmpq $0x0, 0x8(%r15)
jne 0xd553
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x2b310(%rip), %rsi # 0x38... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::FilePath::MakeFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, int, char const*) | FilePath FilePath::MakeFileName(const FilePath& directory,
const FilePath& base_name,
int number,
const char* extension) {
std::string file;
if (number == 0) {
file = base_name.string() + "." + extension;
} else {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, -0x6c(%rbp)
leaq -0xc0(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
testl %ecx, %ecx
je 0xddf7
leaq -0x80(%rbp), %r12
movq %r12, -0x1... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::IsAbsolutePath() const | bool FilePath::IsAbsolutePath() const {
const char* const name = pathname_.c_str();
#if GTEST_OS_WINDOWS
return pathname_.length() >= 3 &&
((name[0] >= 'a' && name[0] <= 'z') ||
(name[0] >= 'A' && name[0] <= 'Z')) &&
name[1] == ':' &&
IsPathSeparator(name[2]);
#else
return IsPathSeparator(nam... | pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
cmpb $0x2f, (%rax)
sete %al
popq %rbp
retq
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::GenerateUniqueFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, char const*) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
const FilePath& base_name,
const char* extension) {
FilePath full_pathname;
int number = 0;
do {
full_pathname.Set(MakeFileName(directory, base_name, number+... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r13d, %r13d
leaq -0xc8(%rbp), %r14
mov... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc |
testing::TestSuite::successful_test_count() const | int TestSuite::successful_test_count() const {
return CountIf(test_info_list_, TestPassed);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %r15
cmpq 0x38(%rdi), %r15
je 0xf1da
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%r15), %rdi
callq 0x2f452
movzbl %al, %eax
addl %eax, %r14d
addq $0x8, %r15
cmpq 0x38(%rbx), %r15
jne 0xf1c0
jmp 0xf1dd
xorl %r14d, %r14d
movl %r14d, %eax
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::failed_test_count() const | int UnitTestImpl::failed_test_count() const {
return SumOverTestSuiteList(test_suites_, &TestSuite::failed_test_count);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xb8(%rdi), %rax
cmpq %rax, 0xc0(%rdi)
je 0xf2f4
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
movq (%rax,%r15,8), %rdi
callq 0xf306
addl %eax, %r14d
incq %r15
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cm... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestSuite::failed_test_count() const | int TestSuite::failed_test_count() const {
return CountIf(test_info_list_, TestFailed);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %r15
cmpq 0x38(%rdi), %r15
je 0xf34f
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%r15), %rdi
cmpb $0x1, 0x80(%rdi)
movl $0x0, %eax
jne 0xf340
addq $0x90, %rdi
callq 0x131a6
movzbl %al, %eax
addl %eax, %r14d
addq $0x8, %r15
cmpq 0x38(%rb... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::os_stack_trace_getter() | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
if (os_stack_trace_getter_ == nullptr) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
os_stack_trace_getter_ = new OsStackTraceGetter;
#endif // GTEST_OS_STACK_TRACE_GETTER_
}
ret... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x210(%rdi)
jne 0xf694
movl $0x8, %edi
callq 0x84f0
leaq 0x3c9de(%rip), %rcx # 0x4c068
movq %rcx, (%rax)
movq %rax, 0x210(%rbx)
movq 0x210(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*) | void SplitString(const ::std::string& str, char delimiter,
::std::vector< ::std::string>* dest) {
::std::vector< ::std::string> parsed;
::std::string::size_type pos = 0;
while (::testing::internal::AlwaysTrue()) {
const ::std::string::size_type colon = str.find(delimiter, pos);
if (colon ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %r15d, %r15d
movsbl %sil, %r12d
leaq -0x48(%rbp), %r13
movq %r14, %rdi
movl %r12d, %esi
movq... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::AlwaysTrue() | bool AlwaysTrue() {
#if GTEST_HAS_EXCEPTIONS
// This condition is always false so AlwaysTrue() never actually throws,
// but it makes the compiler think that it may throw.
if (IsTrue(false))
throw ClassUniqueToAlwaysTrue();
#endif // GTEST_HAS_EXCEPTIONS
return true;
} | pushq %rbp
movq %rsp, %rbp
movb $0x1, %al
popq %rbp
retq
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::StringStreamToString(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*) | std::string StringStreamToString(::std::stringstream* ss) {
const ::std::string& str = ss->str();
const char* const start = str.c_str();
const char* const end = start + str.length();
std::string result;
result.reserve(static_cast<size_t>(2 * (end - start)));
for (const char* ch = start; ch != end; ++ch) {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x18, %rsi
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x8950
movq (%r14), %r12
movq 0x8(%r14), %r13
leaq 0x10(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::AssertionResult::AssertionResult(testing::AssertionResult const&) | AssertionResult::AssertionResult(const AssertionResult& other)
: success_(other.success_),
message_(other.message_.get() != nullptr
? new ::std::string(*other.message_)
: static_cast< ::std::string*>(nullptr)) {} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rsi), %al
movb %al, (%rdi)
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0xfbfe
movl $0x20, %edi
callq 0x84f0
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::AssertionResult::swap(testing::AssertionResult&) | void AssertionResult::swap(AssertionResult& other) {
using std::swap;
swap(success_, other.success_);
swap(message_, other.message_);
} | pushq %rbp
movq %rsp, %rbp
movb (%rdi), %al
movb (%rsi), %cl
movb %cl, (%rdi)
movb %al, (%rsi)
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x8(%rsi)
popq %rbp
retq
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::AssertionFailure(testing::Message const&) | AssertionResult AssertionFailure(const Message& message) {
return AssertionFailure() << message;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq -0x18(%rbp), %rbx
movb $0x0, -0x8(%rbx)
movq $0x0, (%rbx)
leaq -0x20(%rbp), %rdi
callq 0x2d7e6
movq %r14, %rdi
movq %rax, %rsi
callq 0xfbbc
movq -0x18(%rbp), %rsi
testq %rsi, %rsi
je 0xfd07
movq %rbx, %rdi
callq 0x31c6c
movq %r14, %r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::InternalStrings::GetId(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | size_t GetId(const std::string& str) {
IdMap::iterator it = ids_.find(str);
if (it != ids_.end()) return it->second;
size_t id = ids_.size();
return ids_[str] = id;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x31e8c
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x1035c
movq 0x40(%rax), %r15
jmp 0x1036e
movq 0x28(%r14), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31e0c
movq %r15, (%rax)
movq %r15, %rax
addq $0x8, %rsp
pop... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::edit_distance::CreateUnifiedDiff(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std... | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
const std::vector<std::string>& right,
size_t context) {
const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
size_t l_i = 0, r_i = 0, edit_i = 0;
std::stringstream s... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rcx, -0x38(%rbp)
movq %rdi, -0xd8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rsi, -0xd0(%rbp)
movq %rdx, -0xe0(%rbp)
callq 0x10178
leaq -0x268(%rbp), %rdi
callq 0x8370
leaq -0xa0(%rbp), %r12
leaq -... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::Hunk::PushLine(char, char const*) | void PushLine(char edit, const char* line) {
switch (edit) {
case ' ':
++common_;
FlushEdits();
hunk_.push_back(std::make_pair(' ', line));
break;
case '-':
++removes_;
hunk_removes_.push_back(std::make_pair('-', line));
break;
case '+':
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x2d, %esi
je 0x1096c
cmpl $0x2b, %r15d
je 0x1095a
cmpl $0x20, %r15d
jne 0x109a0
incq 0x20(%rbx)
movq %rbx, %rdi
callq 0x2bd3c
movl $0x38, %r13d
movl $0x28, %r12d
jmp 0x109... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::Hunk::~Hunk() | Hunk(size_t left_start, size_t right_start)
: left_start_(left_start),
right_start_(right_start),
adds_(),
removes_(),
common_() {} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
movq 0x58(%rdi), %rdi
cmpq %r14, %rdi
je 0x109df
movq (%rdi), %r15
movl $0x20, %esi
callq 0x8520
movq %r15, %rdi
cmpq %r14, %r15
jne 0x109ca
leaq 0x40(%rbx), %r14
movq 0x40(%rbx), %rdi
cmpq %r14, %rdi
je 0x10a01... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::EqFailure(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | AssertionResult EqFailure(const char* lhs_expression,
const char* rhs_expression,
const std::string& lhs_value,
const std::string& rhs_value,
bool ignoring_case) {
Message msg;
msg << "Expected equality of these ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, -0x34(%rbp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, -0x60(%rbp)
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0xf840
movq (%r12), %rdi
addq $0x10, %rdi
leaq 0x29265(%rip), %rsi ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::SplitEscapedString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::vector<std::string> SplitEscapedString(const std::string& str) {
std::vector<std::string> lines;
size_t start = 0, end = str.size();
if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
++start;
--end;
}
bool escaped = false;
for (size_t i = start; i + 1 < end; ++i) {
if (escaped) {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
cmpq $0x3, %r15
jb 0x10d86
movq (%r14), %rax
cmpb $0x22, (%rax)
jne 0x10d86
xorl %edx, %edx
cmpb $0x22, -0... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::GetBoolAssertionFailureMessage[abi:cxx11](testing::AssertionResult const&, char const*, char const*, char const*) | std::string GetBoolAssertionFailureMessage(
const AssertionResult& assertion_result,
const char* expression_text,
const char* actual_predicate_value,
const char* expected_predicate_value) {
const char* actual_message = assertion_result.message();
Message msg;
msg << "Value of: " << expression_text... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, -0x30(%rbp)
movq 0x8(%rsi), %rax
testq %rax, %rax
movq %r8, -0x38(%rbp)
je 0x10eb0
movq (%rax), %r13
jmp 0x10eb7
leaq 0x295fa(%rip), %r13 # 0x3a4b1
leaq -0x40(%rbp), %r14
mov... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::CmpHelperSTRCASEEQ(char const*, char const*, char const*, char const*) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
const char* rhs_expression,
const char* lhs,
const char* rhs) {
if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
return AssertionSuccess();
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0x114ff
testq %r8, %r8
je 0x11510
movq %rcx, %rdi
movq %r8, %rsi
callq 0x85a0
testl %eax, %eax
sete %al
te... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::CmpHelperSTRNE(char const*, char const*, char const*, char const*) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
const char* s2_expression,
const char* s1,
const char* s2) {
if (!String::CStringEquals(s1, s2)) {
return AssertionSuccess();
} else {
return AssertionFailur... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsi, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x28(%rbp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0x11635
testq %r8, %r8
je 0x116e7
movq %rcx, %rdi
movq %r8, %rsi
callq 0x8810
testl %eax, %eax
sete %al... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::CmpHelperSTRCASENE(char const*, char const*, char const*, char const*) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
const char* s2_expression,
const char* s1,
const char* s2) {
if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
return AssertionSuccess();
} el... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsi, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x28(%rbp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0x1175c
testq %r8, %r8
je 0x1180e
movq %rcx, %rdi
movq %r8, %rsi
callq 0x85a0
testl %eax, %eax
sete %al... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<char const*>(bool, char const*, char const*, char const* const&, char const* const&) | AssertionResult IsSubstringImpl(
bool expected_to_be_substring,
const char* needle_expr, const char* haystack_expr,
const StringType& needle, const StringType& haystack) {
if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
return AssertionSuccess();
const bool is_wide_string = sizeo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r15
movq %r8, %r13
movl %esi, %r12d
movq %rdi, %rbx
movq %rdx, -0x50(%rbp)
movq %rcx, -0x48(%rbp)
movq (%r8), %rsi
movq (%r9), %rdi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %cl, %al
jne 0x118... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<wchar_t const*>(bool, char const*, char const*, wchar_t const* const&, wchar_t const* const&) | AssertionResult IsSubstringImpl(
bool expected_to_be_substring,
const char* needle_expr, const char* haystack_expr,
const StringType& needle, const StringType& haystack) {
if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
return AssertionSuccess();
const bool is_wide_string = sizeo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r15
movq %r8, %r13
movl %esi, %r12d
movq %rdi, %rbx
movq %rdx, -0x50(%rbp)
movq %rcx, -0x48(%rbp)
movq (%r8), %rsi
movq (%r9), %rdi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %cl, %al
jne 0x11a... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(bool, char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_trait... | AssertionResult IsSubstringImpl(
bool expected_to_be_substring,
const char* needle_expr, const char* haystack_expr,
const StringType& needle, const StringType& haystack) {
if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
return AssertionSuccess();
const bool is_wide_string = sizeo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r15
movq %r8, %r13
movl %esi, %r12d
movq %rdi, %rbx
movq %rdx, -0x50(%rbp)
movq %rcx, -0x48(%rbp)
movq (%r8), %rsi
movq 0x8(%r8), %rcx
movq %r9, %rdi
xorl %edx, %edx
callq 0x8a00
cmpq $-0x1, %rax
setne %al
xorb... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>(bool, char const*, char const*, std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, std::__cxx11::basic_string<wch... | AssertionResult IsSubstringImpl(
bool expected_to_be_substring,
const char* needle_expr, const char* haystack_expr,
const StringType& needle, const StringType& haystack) {
if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
return AssertionSuccess();
const bool is_wide_string = sizeo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r15
movq %r8, %r13
movl %esi, %r12d
movq %rdi, %rbx
movq %rdx, -0x50(%rbp)
movq %rcx, -0x48(%rbp)
movq (%r8), %rsi
movq 0x8(%r8), %rcx
movq %r9, %rdi
xorl %edx, %edx
callq 0x8a20
cmpq $-0x1, %rax
setne %al
xorb... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::CodePointToUtf8[abi:cxx11](unsigned int) | std::string CodePointToUtf8(uint32_t code_point) {
if (code_point > kMaxCodePoint4) {
return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) + ")";
}
char str[5]; // Big enough for the largest valid code point.
if (code_point <= kMaxCodePoint1) {
str[1] = '\0';
str[0] = static_cast<cha... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpl $0x200000, %esi # imm = 0x200000
jb 0x120f2
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x12286
leaq 0x27def(%rip), %rcx # 0x39eab
movl $0x13, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85f0
leaq -0x20(... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::String::FormatHexUInt32[abi:cxx11](unsigned int) | std::string String::FormatHexUInt32(uint32_t value) {
std::stringstream ss;
ss << std::hex << std::uppercase << value;
return ss.str();
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x198(%rbp), %rdi
callq 0x8370
leaq -0x188(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movl -0x170(%rbp,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, -0x170(%rbp,%rcx)
mo... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::WideStringToUtf8[abi:cxx11](wchar_t const*, int) | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
if (num_chars == -1)
num_chars = static_cast<int>(wcslen(str));
::std::stringstream stream;
for (int i = 0; i < num_chars; ++i) {
uint32_t unicode_code_point;
if (str[i] == L'\0') {
break;
} else if (i + 1 < num_chars && IsU... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, -0x50(%rbp)
cmpl $-0x1, %edx
jne 0x12374
movq %r14, %rdi
callq 0x8430
movq %rax, %r12
leaq -0x1d8(%rbp), %rdi
callq 0x8370
testl %r12d, %r12d
jle 0x123... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::CmpHelperSTREQ(char const*, char const*, wchar_t const*, wchar_t const*) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
const char* rhs_expression,
const wchar_t* lhs,
const wchar_t* rhs) {
if (String::WideCStringEquals(lhs, rhs)) {
return AssertionSuccess();
}
return EqFailur... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0x124df
testq %r8, %r8
je 0x124f0
movq %rcx, %rdi
movq %r8, %rsi
callq 0x8750
testl %eax, %eax
sete %al
te... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::CmpHelperSTRNE(char const*, char const*, wchar_t const*, wchar_t const*) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
const char* s2_expression,
const wchar_t* s1,
const wchar_t* s2) {
if (!String::WideCStringEquals(s1, s2)) {
return AssertionSuccess();
}
return AssertionFail... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
movq %rsi, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x30(%rbp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0x125e9
testq %r8, %r8
je 0x126e3
movq %rcx, %rdi
movq %r8, %rsi
callq 0x8750
testl %eax, %e... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::String::CaseInsensitiveWideCStringEquals(wchar_t const*, wchar_t const*) | bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
const wchar_t* rhs) {
if (lhs == nullptr) return rhs == nullptr;
if (rhs == nullptr) return false;
#if GTEST_OS_WINDOWS
return _wcsicmp(lhs, rhs) == 0;
#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movq %rdi, %rax
orq %rsi, %rax
sete %al
testb %cl, %cl
jne 0x12784
pushq %rbp
movq %rsp, %rbp
callq 0x8ae0
testl %eax, %eax
sete %al
popq %rbp
retq
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::String::FormatIntWidthN[abi:cxx11](int, int) | std::string String::FormatIntWidthN(int value, int width) {
std::stringstream ss;
ss << std::setfill('0') << std::setw(width) << value;
return ss.str();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x1a8(%rbp), %r12
movq %r12, %rdi
callq 0x8370
movq 0x10(%r12), %rax
movq -0x18(%rax), %rax
leaq (%rax,%rbp), %r12
addq $-0x198, %r12 # imm ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestResult::GetTestPartResult(int) const | const TestPartResult& TestResult::GetTestPartResult(int i) const {
if (i < 0 || i >= total_part_count())
internal::posix::Abort();
return test_part_results_.at(static_cast<size_t>(i));
} | pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
js 0x12ac0
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
imull $0xb6db6db7, %ecx, %ecx # imm = 0xB6DB6DB7
cmpl %esi, %ecx
jle 0x12ac0
movl %esi, %esi
movq 0x40(%rdi), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $0x6db6db6db6db6db7, %rdx # imm = ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestResult::GetTestProperty(int) const | const TestProperty& TestResult::GetTestProperty(int i) const {
if (i < 0 || i >= test_property_count())
internal::posix::Abort();
return test_properties_.at(static_cast<size_t>(i));
} | pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
js 0x12b22
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
subq %rax, %rcx
shrq $0x6, %rcx
cmpl %esi, %ecx
jle 0x12b22
movl %esi, %esi
movq 0x58(%rdi), %rdx
subq %rax, %rdx
sarq $0x6, %rdx
cmpq %rsi, %rdx
jbe 0x12b27
shlq $0x6, %rsi
addq %rsi, %rax
popq %rbp
retq
callq 0x2ea5f
le... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestResult::RecordProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&) | void TestResult::RecordProperty(const std::string& xml_element,
const TestProperty& test_property) {
if (!ValidateTestProperty(xml_element, test_property)) {
return;
}
internal::MutexLock lock(&test_properties_mutex_);
const std::vector<TestProperty>::iterator property_with_m... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x12cca
testb %al, %al
je 0x12c53
movq %rbx, %rdi
callq 0x31ca6
movq 0x50(%rbx), %r15
movq 0x58(%rbx), %r12
movq (%r14), %rsi
leaq -0x50(%rbp), %rdi
le... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestResult::ValidateTestProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&) | bool TestResult::ValidateTestProperty(const std::string& xml_element,
const TestProperty& test_property) {
return ValidateTestPropertyName(test_property.key(),
GetReservedAttributesForElement(xml_element));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0xb8(%rbp), %rdi
leaq -0x31(%rbp), %rdx
callq 0x2d590
leaq 0x27a99(%rip), %rsi # 0x3a794
movq %rbx, %rdi
callq 0x8170
testl %eax, %eax
je 0x12db0
leaq 0x27956(%rip), %rsi # ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestResult::Clear() | void TestResult::Clear() {
test_part_results_.clear();
test_properties_.clear();
death_test_count_ = 0;
elapsed_time_ = 0;
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x38(%rbx), %rsi
callq 0x35d6e
leaq 0x50(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x366b6
movl $0x0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestResult::Failed() const | bool TestResult::Failed() const {
for (int i = 0; i < total_part_count(); ++i) {
if (GetTestPartResult(i).failed())
return true;
}
return false;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x40(%rdi), %rax
subq 0x38(%rdi), %rax
shrq $0x4, %rax
imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7
testl %eax, %eax
setg %r14b
jle 0x13215
movq %rdi, %rbx
xorl %esi, %esi
callq 0x12a76
movl (%rax), %eax
decl %eax
cmpl $0x2, %eax
jb 0x13215... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::Test::RecordProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void Test::RecordProperty(const std::string& key, int value) {
Message value_message;
value_message << value;
RecordProperty(key, value_message.GetString().c_str());
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, %r15d
movq %rdi, %r14
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
callq 0xf840
movq (%rbx), %rbx
leaq 0x10(%rbx), %rdi
movl %r15d, %esi
callq 0x89f0
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0xfac9
movq -0x40(%rbp), %rsi
leaq -0x60(%r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::ReportFailureInUnknownLocation(testing::TestPartResult::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
const std::string& message) {
// This function is a friend of UnitTest and as such has access to
// AddTestPartResult.
UnitTest::GetInstance()->AddTestPartResult(
result_type,
nullptr, // No info... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl %edi, %r14d
callq 0xb8c6
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x26ff0(%rip), %rdx # 0x3a4b1
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x3470e
leaq 0x3a6e9(%rip), %rdi # 0... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::GoogleTestFailureException::GoogleTestFailureException(testing::TestPartResult const&) | GoogleTestFailureException::GoogleTestFailureException(
const TestPartResult& failure)
: ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x139a9
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x8b00
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13972
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x8520
leaq 0x38cdf(%rip),... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::PrintTestPartResultToString[abi:cxx11](testing::TestPartResult const&) | static std::string PrintTestPartResultToString(
const TestPartResult& test_part_result) {
return (Message()
<< internal::FormatFileLocation(test_part_result.file_name(),
test_part_result.line_number())
<< " " << TestPartResultTypeToString(test_part_res... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x30(%rbp), %rdi
callq 0xf840
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x139d6
movq 0x8(%r15), %rsi
movl 0x28(%r15), %edx
leaq -0x50(%rbp), %rdi
callq 0x14421
movq -0x30(%rbp), %r14
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::Test::Run() | void Test::Run() {
if (!HasSameFixtureClass()) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
// We will run the test only if SetUp() was successful and ... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1352e
testb %al, %al
je 0x13c03
callq 0xb8c6
movq 0x3a0eb(%rip), %r14 # 0x4dc00
cmpq $0x0, 0x210(%r14)
jne 0x13b3a
movl $0x8, %edi
callq 0x84f0
leaq 0x38538(%rip), %rcx # 0x4c068
movq %rcx, (%rax)
movq %rax, 0x210(%r14)
movq 0x210(%r14), %... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::Test::HasFatalFailure() | bool Test::HasFatalFailure() {
return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
} | pushq %rbp
movq %rsp, %rbp
callq 0xb8c6
movq 0x39fe8(%rip), %rcx # 0x4dc00
movq 0x170(%rcx), %rax
testq %rax, %rax
je 0x13c2c
addq $0x90, %rax
jmp 0x13c4a
movq 0x168(%rcx), %rax
testq %rax, %rax
je 0x13c40
addq $0x88, %rax
jmp 0x13c4a
addq $0x178, %rcx # imm = 0x178
movq %rcx, %rax
movq 0x38(%rax), %rcx
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::Test::IsSkipped() | bool Test::IsSkipped() {
return internal::GetUnitTestImpl()->current_test_result()->Skipped();
} | pushq %rbp
movq %rsp, %rbp
callq 0xb8c6
movq 0x39f7c(%rip), %rax # 0x4dc00
movq 0x170(%rax), %rdi
testq %rdi, %rdi
je 0x13c99
addq $0x90, %rdi
jmp 0x13cb7
movq 0x168(%rax), %rdi
testq %rdi, %rdi
je 0x13cae
addq $0x88, %rdi
jmp 0x13cb7
addq $0x178, %rax # imm = 0x178
movq %rax, %rdi
popq %rbp
jmp 0x13160
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::Test::HasNonfatalFailure() | bool Test::HasNonfatalFailure() {
return internal::GetUnitTestImpl()->current_test_result()->
HasNonfatalFailure();
} | pushq %rbp
movq %rsp, %rbp
callq 0xb8c6
movq 0x39f32(%rip), %rcx # 0x4dc00
movq 0x170(%rcx), %rax
testq %rax, %rax
je 0x13ce2
addq $0x90, %rax
jmp 0x13d00
movq 0x168(%rcx), %rax
testq %rax, %rax
je 0x13cf6
addq $0x88, %rax
jmp 0x13d00
addq $0x178, %rcx # imm = 0x178
movq %rcx, %rax
movq 0x38(%rax), %rcx
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestInfo::TestInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const*, testing::internal::CodeLocation, void const*, testing::internal::TestFactoryBase*) | TestInfo::TestInfo(const std::string& a_test_suite_name,
const std::string& a_name, const char* a_type_param,
const char* a_value_param,
internal::CodeLocation a_code_location,
internal::TypeId fixture_class_id,
internal::Tes... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0xa... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::MakeAndRegisterTestInfo(char const*, char const*, char const*, char const*, testing::internal::CodeLocation, void const*, void (*)(), void (*)(), testing::internal::TestFactoryBase*) | TestInfo* MakeAndRegisterTestInfo(
const char* test_suite_name, const char* name, const char* type_param,
const char* value_param, CodeLocation code_location,
TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
TestInfo* const test_inf... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, -0x40(%rbp)
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x110, %edi # imm = 0x110
callq 0x84f0
movq %rax, -0x38(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x2a(%rbp), ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::ReportInvalidTestSuiteType(char const*, testing::internal::CodeLocation) | void ReportInvalidTestSuiteType(const char* test_suite_name,
CodeLocation code_location) {
Message errors;
errors
<< "Attempted redefinition of test suite " << test_suite_name << ".\n"
<< "All tests in the same test suite must use the same test fixture\n"
<< "class.... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0xf840
movq (%rbx), %rbx
leaq 0x10(%rbx), %r15
leaq 0x25f5f(%rip), %rsi # 0x3a13e
movl $0x25, %edx
movq %r15, %rdi
callq 0x8620
testq %r12, %r12
je 0x1... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::FormatFileLocation[abi:cxx11](char const*, int) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
const std::string file_name(file == nullptr ? kUnknownFile : file);
if (line < 0) {
return file_name + ":";
}
#ifdef _MSC_VER
return file_name + "(" + StreamableToString(line) + "):";
#else
return file_name + ":" + StreamableToStri... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, -0x24(%rbp)
testq %rsi, %rsi
leaq 0x244ba(%rip), %rax # 0x38900
cmoveq %rax, %r14
leaq -0x98(%rbp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x8230
leaq (%rax,%r14), %rdx
leaq ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc |
testing::internal::UnitTestImpl::RegisterParameterizedTests() | void UnitTestImpl::RegisterParameterizedTests() {
if (!parameterized_tests_registered_) {
parameterized_test_registry_.RegisterTests();
type_parameterized_test_registry_.CheckForInstantiations();
parameterized_tests_registered_ = true;
}
} | cmpb $0x0, 0x160(%rdi)
jne 0x1473b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe8(%rdi), %r14
movq 0xf0(%rdi), %r15
cmpq %r15, %r14
je 0x1471e
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x8, %r14
jmp 0x1470a
leaq 0x100(%rbx), %rdi
callq 0xca6e
movb $0x1... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestSuite::TestSuite(char const*, char const*, void (*)(), void (*)()) | TestSuite::TestSuite(const char* a_name, const char* a_type_param,
internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc)
: name_(a_name),
type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
set_up_tc_(set_up_tc),
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x373c5(%rip), %rax # 0x4bdc8
movq %rax, (%rdi)
addq $0x8, %rdi
leaq -0x29(%rbp), %rdx
callq 0x2d590
testq %r12, %r12
je 0x14a46
movl $0x20, %edi
callq 0x8... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestSuite::~TestSuite() | TestSuite::~TestSuite() {
// Deletes every Test in the collection.
ForEach(test_info_list_, internal::Delete<TestInfo>);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x3729d(%rip), %rax # 0x4bdc8
movq %rax, (%rdi)
movq 0x30(%rdi), %r15
movq 0x38(%rdi), %r12
cmpq %r12, %r15
je 0x14b5e
movq (%r15), %r14
testq %r14, %r14
je 0x14b58
movq %r14, %rdi
callq 0x13f44
movl $0x110, %esi ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestSuite::GetTestInfo(int) const | const TestInfo* TestSuite::GetTestInfo(int i) const {
const int index = GetElementOr(test_indices_, i, -1);
return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
} | pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %esi, %esi
js 0x14c39
movq 0x48(%rdi), %rcx
movq 0x50(%rdi), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x14c39
movl %esi, %eax
movl (%rcx,%rax,4), %eax
testl %eax, %eax
js 0x14c49
movl %eax, %eax
movq 0x30(%rdi), %rcx
movq (... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestSuite::GetMutableTestInfo(int) | TestInfo* TestSuite::GetMutableTestInfo(int i) {
const int index = GetElementOr(test_indices_, i, -1);
return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
} | pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %esi, %esi
js 0x14c73
movq 0x48(%rdi), %rcx
movq 0x50(%rdi), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x14c73
movl %esi, %eax
movl (%rcx,%rax,4), %eax
testl %eax, %eax
js 0x14c83
movl %eax, %eax
movq 0x30(%rdi), %rcx
movq (... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestSuite::AddTestInfo(testing::TestInfo*) | void TestSuite::AddTestInfo(TestInfo* test_info) {
test_info_list_.push_back(test_info);
test_indices_.push_back(static_cast<int>(test_indices_.size()));
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, -0x18(%rbp)
movq 0x38(%rdi), %rsi
cmpq 0x40(%rdi), %rsi
je 0x14caf
movq %rax, (%rsi)
addq $0x8, 0x38(%rbx)
jmp 0x14cbc
leaq 0x30(%rbx), %rdi
leaq -0x18(%rbp), %rdx
callq 0x368dc
movq 0x50(%rbx), %rsi
movq %rsi, %rax
subq 0... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestSuite::Run() | void TestSuite::Run() {
if (!should_run_) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->set_current_test_suite(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
// Call both legacy and the new API
repeater->OnTestSuiteStart(*this);
// ... | cmpb $0x1, 0x70(%rdi)
jne 0x14f72
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xb8c6
movq 0x38ede(%rip), %r15 # 0x4dc00
movq %rbx, 0x168(%r15)
callq 0xb8c6
movq 0x38ecb(%rip), %rax # 0x4dc00
movq 0x1f8(%rax), %r14
movq (%r14), %rax
mov... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestSuite::Skip() | void TestSuite::Skip() {
if (!should_run_) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->set_current_test_suite(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
// Call both legacy and the new API
repeater->OnTestSuiteStart(*this);
//... | cmpb $0x1, 0x70(%rdi)
jne 0x15050
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0xb8c6
movq 0x38c68(%rip), %r15 # 0x4dc00
movq %rbx, 0x168(%r15)
callq 0xb8c6
movq 0x38c55(%rip), %rax # 0x4dc00
movq 0x1f8(%rax), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::TestSuite::ClearResult() | void TestSuite::ClearResult() {
ad_hoc_test_result_.Clear();
ForEach(test_info_list_, TestInfo::ClearTestResult);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0xc0, %rdi
movq 0xc0(%rbx), %rsi
callq 0x35d6e
leaq 0xd8(%rbx), %rdi
movq 0xd8(%rbx), %rsi
callq 0x366b6
movl $0x0, 0xf0(%rbx)
movq $0x0, 0x100(%rbx)
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %rbx
cmpq %rbx, %r14
je 0x150ec
movq (... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(testing::UnitTest const&, int) | void PrettyUnitTestResultPrinter::OnTestIterationStart(
const UnitTest& unit_test, int iteration) {
if (GTEST_FLAG(repeat) != 1)
printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
const char* const filter = GTEST_FLAG(filter).c_str();
// Prints the filter if it's not *. This remin... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
cmpl $0x1, 0x387a1(%rip) # 0x4db48
je 0x153bb
incl %edx
leaq 0x24fa9(%rip), %rdi # 0x3a35b
movl %edx, %esi
xorl %eax, %eax
callq 0x8080
movq 0x38736(%rip), %r14 # 0x4daf8
testq %r14, %r14
je 0x153da
leaq 0x23418(%rip), %rsi ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::ShouldShard(char const*, char const*, bool) | bool ShouldShard(const char* total_shards_env,
const char* shard_index_env,
bool in_subprocess_for_death_test) {
if (in_subprocess_for_death_test) {
return false;
}
const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
const int32_t shard_index = Int32FromE... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
testl %edx, %edx
jne 0x156d2
movq %rsi, %r14
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x15a7b
movl %eax, %ebx
movq %r14, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x15a7b
movl %eax, %r14d
andl %ebx, %eax
cmpl $-0x... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::Int32FromEnvOrDie(char const*, int) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
const char* str_val = posix::GetEnv(var);
if (str_val == nullptr) {
return default_val;
}
int32_t result;
if (!ParseInt32(Message() << "The value of environment variable " << var,
str_val, &result)) {
exit(EXIT_FAILUR... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r15
callq 0x86e0
testq %rax, %rax
je 0x15b15
movq %rax, %r14
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0xf840
movq (%rbx), %rbx
leaq 0x10(%rbx), %r12
leaq 0x2516b(%rip), %rsi # 0x3ac21
movl $0x22, ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::UnitTest::test_suite_to_run_count() const | int UnitTest::test_suite_to_run_count() const {
return impl()->test_suite_to_run_count();
} | pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rax
movq 0xb8(%rax), %rcx
movq 0xc0(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x15b92
movq (%rcx), %rsi
movzbl 0x70(%rsi), %esi
addl %esi, %eax
addq $0x8, %rcx
jmp 0x15b7e
popq %rbp
retq
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestSuite const&) | void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(GTestColor::kGreen, "[----------] ");
printf("%s from %s", counts.c_str(), test_case.name());
if (test_case.type_para... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x15bf7
movq (%rax), %rdx
movzbl 0x80(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x15be0
leaq 0x2536b(%rip), %rdx # 0x3af69
leaq 0x2482e(%rip), %rcx ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::FormatCountableNoun[abi:cxx11](int, char const*, char const*) | static std::string FormatCountableNoun(int count,
const char * singular_form,
const char * plural_form) {
return internal::StreamableToString(count) + " " +
(count == 1 ? singular_form : plural_form);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq -0x24(%rbp), %rax
movl %esi, (%rax)
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x2f6a1
leaq 0x2401e(%rip), %rsi # 0x39cf8
movq %r12, %rdi
callq 0x8b10
leaq -... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void PrettyUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
switch (result.type()) {
// If the test part succeeded, we don't need to do anything.
case TestPartResult::kSuccess:
return;
default:
// Print failure message from the assertion
// (e.g. expected this... | cmpl $0x0, (%rsi)
je 0x15e67
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rdi
callq 0x15e68
movq 0x3710a(%rip), %rax # 0x4cf68
movq (%rax), %rdi
popq %rbp
jmp 0x8670
retq
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::PrintTestPartResult(testing::TestPartResult const&) | static void PrintTestPartResult(const TestPartResult& test_part_result) {
const std::string& result =
PrintTestPartResultToString(test_part_result);
printf("%s\n", result.c_str());
fflush(stdout);
// If the test program runs in Visual Studio or a debugger, the
// following statements add the test part r... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rsi
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x139a9
movq (%rbx), %rdi
callq 0x8900
movq 0x370d9(%rip), %rax # 0x4cf68
movq (%rax), %rdi
callq 0x8670
movq (%rbx), %rdi
leaq -0x18(%rbp), %rax
cmpq %rax, %rdi
je 0x15eaf
movq -0x18(%rbp), %rsi
incq... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&) | void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
if (test_info.result()->Passed()) {
ColoredPrintf(GTestColor::kGreen, "[ OK ] ");
} else if (test_info.result()->Skipped()) {
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
} else {
ColoredPrintf(GTestColor::kRed, "[ ... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %r14
movq %r14, %rdi
callq 0x13160
testb %al, %al
jne 0x15ee3
movq %r14, %rdi
callq 0x131a6
testb %al, %al
je 0x15f06
movq %r14, %rdi
callq 0x13160
testb %al, %al
je 0x15ef8
leaq 0x2457b(%rip), %rsi # 0x3a471
jmp 0x15... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::PrintFullTestCommentIfPresent(testing::TestInfo const&) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
const char* const type_param = test_info.type_param();
const char* const value_param = test_info.value_param();
if (type_param != nullptr || value_param != nullptr) {
printf(", where ");
if (type_param != nullptr) {
printf("%s =... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x15fc7
movq (%rax), %r14
jmp 0x15fca
xorl %r14d, %r14d
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x15fd8
movq (%rax), %rbx
jmp 0x15fda
xorl %ebx, %ebx
movq %r14, %rax
orq %rbx, %rax
je 0x16041
leaq 0x2570c(%rip), %rdi # 0x3b... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseEnd(testing::TestSuite const&) | void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
if (!GTEST_FLAG(print_time)) return;
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(GTestColor::kGreen, "[----------] ");
printf("%s from %s (%s ms total)\n\n", coun... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpb $0x1, 0x37ae7(%rip) # 0x4db41
jne 0x16128
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x16084
movq (%rax), %rdx
movzbl 0x80(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x1606d
lea... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::PrintFailedTests(testing::UnitTest const&) | void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
const int failed_test_count = unit_test.failed_test_count();
ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
for (int i = 0; i < unit_test.total_test_suit... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x40(%rdi), %rdi
callq 0xf2a6
movl %eax, %r15d
leaq 0x242cc(%rip), %rsi # 0x3a47f
movl $0x1, %edi
xorl %eax, %eax
callq 0x15576
leaq 0x24da3(%rip), %rdx # 0x3af69
leaq 0x24266(%rip), %rcx ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::UnitTest::GetTestSuite(int) const | inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
: v[static_cast<size_t>(i)];
} | testl %esi, %esi
js 0x163f4
pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rax
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x163f0
movl %esi, %edx
cmpl $0x0, (%rcx,%rdx,4)
js 0x163f0
movq 0xb8(%rax), %rax
movq (%rax,%rdx,8), %rax
jmp 0x163f2
xorl %eax, %eax
popq %rbp
re... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h |
testing::internal::PrettyUnitTestResultPrinter::PrintSkippedTests(testing::UnitTest const&) | void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) {
const int skipped_test_count = unit_test.skipped_test_count();
if (skipped_test_count == 0) {
return;
}
for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
const TestSuite& test_suite = *unit_test.GetTestSuite(i... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0xf1ec
testl %eax, %eax
je 0x16688
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x16688
xorl %r13d, %r13d
mov... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("%s from %s ran.",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTest... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
leaq 0x23d43(%rip), %rsi # 0x3a402
xorl %r14d, %r14d
movl $0x2, %edi
xorl %eax, %eax
callq 0x15576
movq 0x40(%rbx), %rdi
callq 0xf5d0
leaq 0x2488b(%rip), %rdx # 0x3af69
leaq 0x23d4e(%rip), %rcx # 0x3a433
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void BriefUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
switch (result.type()) {
// If the test part succeeded, we don't need to do anything.
case TestPartResult::kSuccess:
return;
default:
// Print failure message from the assertion
// (e.g. expected this ... | cmpl $0x0, (%rsi)
je 0x169b9
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rdi
callq 0x15e68
movq 0x365b8(%rip), %rax # 0x4cf68
movq (%rax), %rdi
popq %rbp
jmp 0x8670
retq
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&) | void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
if (test_info.result()->Failed()) {
ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
PrintTestName(test_info.test_suite_name(), test_info.name());
PrintFullTestCommentIfPresent(test_info);
if (GTEST_FLAG(print_time)) {
pri... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %rdi
callq 0x131a6
testb %al, %al
je 0x16a71
leaq 0x23a9e(%rip), %rsi # 0x3a47f
movl $0x1, %edi
xorl %eax, %eax
callq 0x15576
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x23aca(%rip), %rdi # 0x3a4c5
xorl %eax, %eax
callq 0... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("%s from %s ran.",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestSu... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
leaq 0x23971(%rip), %rsi # 0x3a402
xorl %r14d, %r14d
movl $0x2, %edi
xorl %eax, %eax
callq 0x15576
movq 0x40(%rbx), %rdi
callq 0xf5d0
leaq 0x244b9(%rip), %rdx # 0x3af69
leaq 0x2397c(%rip), %rcx # 0x3a433
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::~TestEventRepeater() | TestEventRepeater::~TestEventRepeater() {
ForEach(listeners_, Delete<TestEventListener>);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x350cc(%rip), %rax # 0x4bde8
movq %rax, (%rdi)
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x16d40
movq (%r14), %rdi
testq %rdi, %rdi
je 0x16d3a
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x16... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::Release(testing::TestEventListener*) | TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
for (size_t i = 0; i < listeners_.size(); ++i) {
if (listeners_[i] == listener) {
listeners_.erase(listeners_.begin() + static_cast<int>(i));
return listener;
}
}
return nullptr;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq 0x18(%r14), %rdx
movq %rdx, %rax
subq %rdi, %rax
je 0x16e0b
movq %rsi, %rbx
sarq $0x3, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
movabsq $0x100000000, %rsi # imm = 0x100000000
xorl %ecx, %ecx
xorl %r8d, %r8d
cmpq %rbx, (%rdi,%r8... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::OnTestIterationStart(testing::UnitTest const&, int) | void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
int iteration) {
if (forwarding_enabled_) {
for (size_t i = 0; i < listeners_.size(); i++) {
listeners_[i]->OnTestIterationStart(unit_test, iteration);
}
}
} | cmpb $0x1, 0x8(%rdi)
jne 0x17272
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x1726a
movl %edx, %ebx
movq %rsi, %r14
xorl %r12d, %r12d
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x18(%rax)
in... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::OnTestIterationEnd(testing::UnitTest const&, int) | void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
int iteration) {
if (forwarding_enabled_) {
for (size_t i = listeners_.size(); i > 0; i--) {
listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration);
}
}
} | cmpb $0x1, 0x8(%rdi)
jne 0x172bc
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
movq 0x18(%rdi), %r12
subq 0x10(%rdi), %r12
je 0x172b4
movl %edx, %ebx
movq %rsi, %r14
sarq $0x3, %r12
movq 0x10(%r15), %rax
movq -0x8(%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(char const*) | XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
: output_file_(output_file) {
if (output_file_.empty()) {
GTEST_LOG_(FATAL) << "XML output file may not be null";
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x34bad(%rip), %rax # 0x4be80
movq %rax, (%rdi)
addq $0x8, %rdi
leaq -0x11(%rbp), %rdx
callq 0x2d590
cmpq $0x0, 0x10(%rbx)
jne 0x17325
leaq 0x225bb(%rip), %rdx # 0x398ac
leaq -0x18(%rbp), %rdi
movl $0x3, %esi
movl $0xf87, %ec... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* xmlout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintXmlUnitTest(&stream, unit_test);
fprintf(xmlout, "%s", StringStreamToString(&stream)... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
addq $0x8, %rdi
callq 0x1742c
movq %rax, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x8370
leaq -0x1a8(%rbp), %rdi
movq %r14, %rsi
callq 0x175c6
leaq -0x30(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xfac9
leaq -0x20(%rbp... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::OpenFileForWriting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static FILE* OpenFileForWriting(const std::string& output_file) {
FILE* fileout = nullptr;
FilePath output_file_path(output_file);
FilePath output_dir(output_file_path.RemoveFileName());
if (output_dir.CreateDirectoriesRecursively()) {
fileout = posix::FOpen(output_file.c_str(), "w");
}
if (fileout == ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0xa940
movq (%r14), %rax
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x17494
xorl %e... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream*, testing::UnitTest const&) | void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
const UnitTest& unit_test) {
const std::string kTestsuites = "testsuites";
*stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
*stream << "<" << kTestsuites;
OutputXmlAttribute(stream, ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x80(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x231a8(%rip), %rsi # 0x3a794
leaq 0x231ab(%rip), %rdx # 0x3a79e
leaq -0x90(%rbp), %rdi
callq 0x3470e
leaq 0x23199(%rip), %rsi ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
const std::string& str) {
std::string output;
output.reserve(str.size());
for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
if (IsValidXmlCharacter(*it))
output.push_back(*it);
return output;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x8930
cmpq $0x0, 0x8(%r14)
je 0x181c9
movq (%r14), %r12
movl $0x2600, %r13d ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::FormatTimeInMillisAsSeconds[abi:cxx11](long) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
::std::stringstream ss;
ss << (static_cast<double>(ms) * 1e-3);
return ss.str();
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x198(%rbp), %rdi
callq 0x8370
leaq -0x188(%rbp), %rdi
cvtsi2sd %r14, %xmm0
mulsd 0x20429(%rip), %xmm0 # 0x38658
callq 0x8970
leaq -0x180(%rbp), %rsi
movq %rbx, %rdi
callq 0x8950
movq 0x3... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::FormatEpochTimeInMillisAsIso8601[abi:cxx11](long) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
struct tm time_struct;
if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
return "";
// YYYY-MM-DDThh:mm:ss.sss
return StreamableToString(time_struct.tm_year + 1900) + "-" +
String::FormatIntWidth2(time_struct.tm_mon + ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rsi, %r14
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
movq %rsi, %rax
imulq %rcx
movq %rdx, %r15
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %r15
addq %rax,... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*) | void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
const char* data) {
const char* segment = data;
*stream << "<![CDATA[";
for (;;) {
const char* const next_segment = strstr(segment, "]]>");
if (next_segment != nullptr) {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x216b4(%rip), %rsi # 0x3a5c9
movl $0x9, %edx
callq 0x8620
leaq 0x21696(%rip), %r14 # 0x3a5bc
leaq 0x21693(%rip), %r12 # 0x3a5c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x8110
movq... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlAttribute(std::ostream*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::alloc... | void XmlUnitTestResultPrinter::OutputXmlAttribute(
std::ostream* stream,
const std::string& element_name,
const std::string& name,
const std::string& value) {
const std::vector<std::string>& allowed_names =
GetReservedOutputAttributesForElement(element_name);
GTEST_CHECK_(std::find(allowed_na... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq -0x60(%rbp), %r13
movq %r13, %rdi
callq 0x1918d
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r15, %rdx
callq 0x36589
cmpq -0x58(%rbp), %rax
jne 0x190a7
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::GetReservedOutputAttributesForElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::vector<std::string> GetReservedOutputAttributesForElement(
const std::string& xml_element) {
if (xml_element == "testsuites") {
return ArrayAsVector(kReservedTestSuitesAttributes);
} else if (xml_element == "testsuite") {
return ArrayAsVector(kReservedTestSuiteAttributes);
} else if (xml_e... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x215ef(%rip), %rsi # 0x3a794
movq %r14, %rdi
callq 0x8170
testl %eax, %eax
je 0x19259
leaq 0x214ac(%rip), %rsi # 0x3a668
movq %r14, %rdi
callq 0x8170
testl %eax, %eax
je 0x1926d
leaq 0x214df(%rip), %rsi #... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult(std::ostream*, testing::TestResult const&) | void XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult(
::std::ostream* stream, const TestResult& result) {
// Output the boilerplate for a minimal test suite with one test.
*stream << " <testsuite";
OutputXmlAttribute(stream, "testsuite", "name", "NonTestSuiteFailure");
OutputXmlAttribute(stream, ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2138b(%rip), %rsi # 0x3a665
movl $0xc, %edx
callq 0x8620
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x21375(%rip), %rsi # 0x3a668
leaq 0x21377(%rip), %rdx # 0x3a6... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(std::ostream*, char const*, testing::TestInfo const&) | void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
const char* test_suite_name,
const TestInfo& test_info) {
const TestResult& result = *test_info.result();
const std::string kTestsuite = "testcas... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x80(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x201e9(%rip), %rsi # 0x3a6b2
leaq 0x201ea(%rip), %rdx # 0x3a6ba
leaq -0x90(%rbp), %rdi
callq 0x3470e
cmpb $0x0, 0... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.