name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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 =
"Type parameterized test suite " + testcase.first +
" is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated "
"via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run."
"\n\n"
"Ideally, TYPED_TEST_P definitions should only ever be included as "
"part of binaries that intend to use them. (As opposed to, for "
"example, being placed in a library that may be linked in to get other "
"utilities.)"
"\n\n"
"To suppress this error for this test suite, insert the following line "
"(in a non-header) in the namespace it is defined in:"
"\n\n"
"GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
testcase.first + ");";
std::string full_name =
"UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">";
RegisterTest( //
"GoogleTestVerification", full_name.c_str(),
nullptr, // No type parameter.
nullptr, // No value parameter.
testcase.second.code_location.file.c_str(),
testcase.second.code_location.line, [message, testcase] {
return new FailureTest(testcase.second.code_location, message,
kErrorOnUninstantiatedTypeParameterizedTest);
});
}
}
|
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, %rax # imm = 0x138
movq %rax, -0x140(%rbp)
leaq -0x118(%rbp), %rbx
movq %r15, -0x130(%rbp)
cmpb $0x0, 0x68(%r14)
jne 0xcfd0
leaq 0x20(%r14), %r13
movq -0x138(%rbp), %rdi
movq %r13, %rsi
callq 0x34d88
cmpq -0x140(%rbp), %rax
jne 0xcfd0
leaq -0x78(%rbp), %r12
movq %r12, %rdi
leaq 0x2cf7e(%rip), %rsi # 0x39a82
movq %r13, %rdx
callq 0x2d5cd
movq %r12, %rdi
leaq 0x2cf8b(%rip), %rsi # 0x39aa1
callq 0x8b10
leaq -0x48(%rbp), %rsi
movq %rsi, -0x58(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xcb3f
movq %rdx, -0x58(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x48(%rbp)
jmp 0xcb45
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, -0x50(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
leaq -0x58(%rbp), %rdi
callq 0x8180
movq %rbx, -0x128(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
leaq -0x128(%rbp), %rdi
je 0xcb9d
movq %rdx, -0x128(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x118(%rbp)
jmp 0xcba3
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, -0x120(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x2ce57(%rip), %rsi # 0x39a1b
callq 0x8b10
leaq -0x88(%rbp), %rsi
movq %rsi, -0x98(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xcbf9
movq %rdx, -0x98(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x88(%rbp)
jmp 0xcbff
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, -0x90(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x128(%rbp), %rdi
cmpq %rbx, %rdi
je 0xcc34
movq -0x118(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xcc4d
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0xcc66
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x128(%rbp), %r12
movq %r12, %rdi
leaq 0x2d032(%rip), %rsi # 0x39ca9
movq %r13, %rdx
callq 0x2d5cd
movq %r12, %rdi
leaq 0x2dabe(%rip), %rsi # 0x3a747
callq 0x8b10
leaq -0xa8(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xccbe
movq %rdx, -0xb8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xa8(%rbp)
jmp 0xccc4
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, -0xb0(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x128(%rbp), %rdi
cmpq %rbx, %rdi
je 0xccf9
movq -0x118(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0xb8(%rbp), %r12
movq 0x40(%r14), %r15
movl 0x60(%r14), %ebx
leaq -0x1a0(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
addq %rsi, %rdx
leaq -0x1b0(%rbp), %rdi
callq 0xa940
leaq -0x190(%rbp), %rdi
movq %r13, %rsi
callq 0x2d660
leaq -0x78(%rbp), %rdi
movq %r15, %rsi
leaq -0x29(%rbp), %rdx
callq 0x2d590
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0xa940
movl %ebx, -0x38(%rbp)
movl $0x78, %edi
callq 0x84f0
movq %rax, %r13
leaq -0x118(%rbp), %rbx
movq %rbx, -0x128(%rbp)
movq -0x1b0(%rbp), %rax
leaq -0x1a0(%rbp), %rcx
cmpq %rcx, %rax
je 0xcdb6
movq %rax, -0x128(%rbp)
movq -0x1a0(%rbp), %rax
movq %rax, -0x118(%rbp)
jmp 0xcdbc
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq -0x1a8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq %rcx, -0x1b0(%rbp)
movq $0x0, -0x1a8(%rbp)
movb $0x0, -0x1a0(%rbp)
leaq -0x108(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x2d660
leaq 0x3f81b(%rip), %rax # 0x4c618
movq %rax, (%r13)
leaq 0x18(%r13), %r15
movq %r15, 0x8(%r13)
movq -0x128(%rbp), %rax
cmpq %rbx, %rax
je 0xce26
movq %rax, 0x8(%r13)
movq -0x118(%rbp), %rax
movq %rax, 0x18(%r13)
jmp 0xce2d
movups (%rbx), %xmm0
movups %xmm0, (%r15)
movq -0x120(%rbp), %rax
movq %rax, 0x10(%r13)
movq %rbx, -0x128(%rbp)
movq $0x0, -0x120(%rbp)
movb $0x0, -0x118(%rbp)
movq %r13, %rdi
addq $0x28, %rdi
leaq -0x108(%rbp), %rsi
callq 0x2d660
movq %r13, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
leaq 0x2cbcd(%rip), %rdi # 0x39a44
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
leaq -0x58(%rbp), %r8
leaq 0x40e27(%rip), %r9 # 0x4dcb0
callq 0x1400b
movq -0xe8(%rbp), %rdi
leaq -0xd8(%rbp), %rax
cmpq %rax, %rdi
movq -0x130(%rbp), %r15
je 0xceb7
movq -0xd8(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x108(%rbp), %rdi
leaq -0xf8(%rbp), %rax
cmpq %rax, %rdi
je 0xced9
movq -0xf8(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x128(%rbp), %rdi
cmpq %rbx, %rdi
je 0xcef4
movq -0x118(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xcf0d
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0xcf26
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x170(%rbp), %rdi
leaq -0x160(%rbp), %rax
cmpq %rax, %rdi
je 0xcf48
movq -0x160(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x190(%rbp), %rdi
leaq -0x180(%rbp), %rax
cmpq %rax, %rdi
je 0xcf6a
movq -0x180(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x1b0(%rbp), %rdi
leaq -0x1a0(%rbp), %rax
cmpq %rax, %rdi
je 0xcf8c
movq -0x1a0(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rax
cmpq %rax, %rdi
je 0xcfae
movq -0xa8(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0xcfd0
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x8520
movq %r14, %rdi
callq 0x8360
movq %rax, %r14
cmpq %r15, %rax
jne 0xcacb
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xd139
movq %rbx, %rcx
movq %rax, %rbx
movq -0x128(%rbp), %rdi
cmpq %rcx, %rdi
je 0xd15b
movq -0x118(%rbp), %rsi
jmp 0xd153
movq %rax, %rbx
jmp 0xd15b
movq %rbx, %rcx
movq %rax, %rbx
movq -0x128(%rbp), %rdi
cmpq %rcx, %rdi
je 0xd04e
movq -0x118(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xd04e
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xd06c
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xd06c
movq %rax, %rbx
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0xd17d
movq -0x68(%rbp), %rsi
jmp 0xd175
movq %rax, %rbx
xorl %r14d, %r14d
jmp 0xd0a8
movq %rax, %rbx
movq 0x8(%r13), %rdi
movb $0x1, %r14b
cmpq %r15, %rdi
je 0xd0a8
movq (%r15), %rsi
incq %rsi
callq 0x8520
leaq -0x128(%rbp), %rdi
callq 0xd1ac
jmp 0xd0da
movq %rbx, %rcx
movq %rax, %rbx
movq -0x128(%rbp), %rdi
movb $0x1, %r14b
cmpq %rcx, %rdi
je 0xd0da
movq -0x118(%rbp), %rsi
incq %rsi
callq 0x8520
testb %r14b, %r14b
je 0xd0f1
movl $0x78, %esi
movq %r13, %rdi
callq 0x8520
jmp 0xd0f1
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xd10f
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xd10f
movq %rax, %rbx
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0xd12d
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xd12d
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0xd1ac
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rax
cmpq %rax, %rdi
je 0xd15b
movq -0xa8(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0xd17d
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
movq %rax, %rbx
movq -0x1b0(%rbp), %rdi
leaq -0x1a0(%rbp), %rax
cmpq %rax, %rdi
je 0xd139
movq -0x1a0(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xd139
|
/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.end());
#else // defined(GTEST_CUSTOM_GET_ARGVS_)
return g_argvs;
#endif // defined(GTEST_CUSTOM_GET_ARGVS_)
}
|
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(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0xa940
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdx
testq %rdx, %rdx
je 0xd2b6
xorl %esi, %esi
movq %rax, %rcx
movb (%rax,%rsi), %dil
cmpb $0x2f, %dil
jne 0xd2a6
movb $0x2f, %dil
cmpq -0x38(%rbp), %rcx
je 0xd2a6
cmpb $0x2f, -0x1(%rcx)
je 0xd2ac
movb %dil, (%rcx)
incq %rcx
incq %rsi
cmpq %rsi, %rdx
jne 0xd28d
jmp 0xd2b9
movq %rax, %rcx
leaq -0x38(%rbp), %rsi
movq %rcx, %rax
subq (%rsi), %rax
movq %rax, 0x8(%rsi)
movb $0x0, (%rcx)
leaq -0x58(%rbp), %rdi
callq 0x82c0
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xd2e8
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x70(%rbp), %rdi
callq 0x2d6da
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0xd36a
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0xd312
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd34a
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xd33f
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xd33f
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2d6da
jmp 0xd34d
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0xd362
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
|
/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)
movq %r15, %rdi
callq 0x8230
leaq (%r14,%rax), %rdx
incq %rdx
leaq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0x3470e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xa940
movq %rbx, %rdi
callq 0x29334
jmp 0xd402
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%r12), %rdx
addq %r15, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa940
testq %r14, %r14
je 0xd420
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd420
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %r13b
jmp 0xd45e
movq %rax, %rbx
testq %r14, %r14
je 0xd45e
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
movb $0x1, %r13b
cmpq %rax, %rdi
je 0xd45e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
testb %r13b, %r13b
movq %rbx, %rdi
callq 0x8a30
nop
|
/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 == nullptr)
return internal::FilePath::MakeFileName(
internal::FilePath(
UnitTest::GetInstance()->original_working_dir()),
internal::FilePath(kDefaultOutputFile), 0,
format.c_str()).string();
internal::FilePath output_name(colon + 1);
if (!output_name.IsAbsolutePath())
output_name = internal::FilePath::ConcatPaths(
internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
internal::FilePath(colon + 1));
if (!output_name.IsDirectory())
return output_name.string();
internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
output_name, internal::GetCurrentExecutableName(),
GetOutputFormat().c_str()));
return result.string();
}
|
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 # 0x3882c
leaq 0x2b30c(%rip), %rdx # 0x3882f
leaq -0x70(%rbp), %rdi
callq 0x3470e
leaq -0x110(%rbp), %rdi
leaq -0x70(%rbp), %r15
movq %r15, %rsi
callq 0x86f0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xd553
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x8520
movq %r14, %rdi
movl $0x3a, %esi
callq 0x8200
testq %rax, %rax
je 0xd5f2
movq %rax, %r15
leaq 0x1(%rax), %r14
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq %r14, %rdi
callq 0x8230
leaq (%r15,%rax), %rdx
incq %rdx
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x3470e
leaq -0x60(%rbp), %r13
movq %r13, -0x10(%r13)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0xa940
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
testq %rcx, %rcx
je 0xd679
xorl %esi, %esi
movq %rax, %rdx
movb (%rax,%rsi), %dil
cmpb $0x2f, %dil
jne 0xd5df
movb $0x2f, %dil
cmpq -0x70(%rbp), %rdx
je 0xd5df
cmpb $0x2f, -0x1(%rdx)
je 0xd5e5
movb %dil, (%rdx)
incq %rdx
incq %rsi
cmpq %rsi, %rcx
jne 0xd5c6
jmp 0xd67c
callq 0xb8c6
movq 0x40602(%rip), %rax # 0x4dc00
movq 0x10(%rax), %rsi
leaq -0x90(%rbp), %rdi
leaq -0xf0(%rbp), %rdx
callq 0x2d590
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0xa940
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
testq %rcx, %rcx
je 0xd73c
xorl %esi, %esi
movq %rax, %rdx
movb (%rax,%rsi), %dil
cmpb $0x2f, %dil
jne 0xd666
movb $0x2f, %dil
cmpq -0x48(%rbp), %rdx
je 0xd666
cmpb $0x2f, -0x1(%rdx)
je 0xd66c
movb %dil, (%rdx)
incq %rdx
incq %rsi
cmpq %rsi, %rcx
jne 0xd64d
jmp 0xd73f
movq %rax, %rdx
movq %rdx, %rax
subq -0x70(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, (%rdx)
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xd69f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x70(%rbp), %rax
cmpb $0x2f, (%rax)
je 0xda07
callq 0xb8c6
movq 0x40548(%rip), %rax # 0x4dc00
movq 0x10(%rax), %rsi
leaq -0xb0(%rbp), %rdi
leaq -0x49(%rbp), %rdx
callq 0x2d590
leaq -0x80(%rbp), %rax
movq %rax, -0x10(%rax)
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
addq %rsi, %rdx
leaq -0x90(%rbp), %rdi
callq 0xa940
movq -0x90(%rbp), %rax
movq -0x88(%rbp), %rcx
testq %rcx, %rcx
je 0xd8a4
xorl %esi, %esi
movq %rax, %rdx
movb (%rax,%rsi), %dil
cmpb $0x2f, %dil
jne 0xd729
movb $0x2f, %dil
cmpq -0x90(%rbp), %rdx
je 0xd729
cmpb $0x2f, -0x1(%rdx)
je 0xd72f
movb %dil, (%rdx)
incq %rdx
incq %rsi
cmpq %rsi, %rcx
jne 0xd70d
jmp 0xd8a7
movq %rax, %rdx
movq %rdx, %rax
subq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, (%rdx)
leaq -0xc0(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b07b(%rip), %rsi # 0x387da
leaq 0x2b07f(%rip), %rdx # 0x387e5
leaq -0xd0(%rbp), %rdi
callq 0x3470e
leaq -0xa0(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
addq %rsi, %rdx
leaq -0xb0(%rbp), %rdi
callq 0xa940
movq -0xb0(%rbp), %rax
movq -0xa8(%rbp), %rdx
testq %rdx, %rdx
je 0xd7df
xorl %esi, %esi
movq %rax, %rcx
movb (%rax,%rsi), %dil
cmpb $0x2f, %dil
jne 0xd7cf
movb $0x2f, %dil
cmpq -0xb0(%rbp), %rcx
je 0xd7cf
cmpb $0x2f, -0x1(%rcx)
je 0xd7d5
movb %dil, (%rcx)
incq %rcx
incq %rsi
cmpq %rsi, %rdx
jne 0xd7b3
jmp 0xd7e2
movq %rax, %rcx
leaq -0xb0(%rbp), %rdx
movq %rcx, %rax
subq (%rdx), %rax
movq %rax, 0x8(%rdx)
movb $0x0, (%rcx)
movq -0x110(%rbp), %r8
leaq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
xorl %ecx, %ecx
callq 0xdd18
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xa940
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd83f
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0xb0(%rbp), %rdi
cmpq %r12, %rdi
je 0xd85a
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0xd0(%rbp), %rdi
cmpq %r15, %rdi
je 0xd875
movq -0xc0(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xd88a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdaea
movq -0x80(%rbp), %rsi
jmp 0xdae2
movq %rax, %rdx
movq %rdx, %rax
subq -0x90(%rbp), %rax
movq %rax, -0x88(%rbp)
movb $0x0, (%rdx)
leaq -0xe0(%rbp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x8230
leaq (%rax,%r14), %rdx
leaq -0xf0(%rbp), %rdi
movq %r14, %rsi
callq 0x3470e
leaq -0xc0(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
addq %rsi, %rdx
leaq -0xd0(%rbp), %rdi
callq 0xa940
movq -0xd0(%rbp), %rax
movq -0xc8(%rbp), %rdx
testq %rdx, %rdx
je 0xd94d
xorl %esi, %esi
movq %rax, %rcx
movb (%rax,%rsi), %dil
cmpb $0x2f, %dil
jne 0xd93d
movb $0x2f, %dil
cmpq -0xd0(%rbp), %rcx
je 0xd93d
cmpb $0x2f, -0x1(%rcx)
je 0xd943
movb %dil, (%rcx)
incq %rcx
incq %rsi
cmpq %rsi, %rdx
jne 0xd921
jmp 0xd950
movq %rax, %rcx
leaq -0xd0(%rbp), %rdx
movq %rcx, %rax
subq (%rdx), %rax
movq %rax, 0x8(%rdx)
movb $0x0, (%rcx)
leaq -0x48(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xe246
leaq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x82c0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xd996
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0xd0(%rbp), %rdi
cmpq %r14, %rdi
je 0xd9b1
movq -0xc0(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0xf0(%rbp), %rdi
cmpq %r15, %rdi
je 0xd9cc
movq -0xe0(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0xd9e8
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xda07
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdx
testq %rdx, %rdx
je 0xdabf
movq -0x70(%rbp), %rax
cmpb $0x2f, -0x1(%rax,%rdx)
jne 0xdabf
leaq -0x90(%rbp), %rdi
callq 0xd228
leaq -0xb0(%rbp), %rdi
callq 0xd46a
movq -0xb0(%rbp), %rcx
leaq -0x48(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0xe402
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xda75
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xda8e
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x8520
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xa940
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xdad5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xdad5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x70(%rbp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xa940
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0xdaea
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x100(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdb09
movq -0x100(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xdcc4
movq -0x38(%rbp), %rsi
jmp 0xdc16
movq %rax, %rbx
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdb5e
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xdb5e
movq %rax, %rbx
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdcc4
movq -0x80(%rbp), %rsi
jmp 0xdc16
jmp 0xdcc1
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xdb9a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xdb9a
movq %rax, %rbx
movq -0xd0(%rbp), %rdi
cmpq %r14, %rdi
je 0xdbba
movq -0xc0(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xdbba
movq %rax, %rbx
movq -0xf0(%rbp), %rdi
cmpq %r15, %rdi
je 0xdbda
movq -0xe0(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xdbda
movq %rax, %rbx
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0xdbfb
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xdbfb
movq %rax, %rbx
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdcc4
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xdcc4
jmp 0xdcc1
jmp 0xdcc1
movq %rax, %rbx
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdc4e
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xdc4e
movq %rax, %rbx
movq -0xb0(%rbp), %rdi
cmpq %r12, %rdi
je 0xdc6e
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xdc6e
movq %rax, %rbx
movq -0xd0(%rbp), %rdi
cmpq %r15, %rdi
je 0xdc8e
movq -0xc0(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xdc8e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xdca8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xdca8
movq %rax, %rbx
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdcf0
movq -0x80(%rbp), %rsi
jmp 0xdcd1
jmp 0xdced
jmp 0xdced
jmp 0xdced
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0xdcf0
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xdcf0
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xdcf0
movq -0x38(%rbp), %rsi
jmp 0xdcd1
movq %rax, %rbx
leaq -0x100(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdd0f
movq -0x100(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
nop
|
/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 {
file = base_name.string() + "_" + StreamableToString(number)
+ "." + extension;
}
return ConcatPaths(directory, FilePath(file));
}
|
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, -0x10(%r12)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq -0x90(%rbp), %rdi
callq 0xa940
leaq 0x2d40c(%rip), %rsi # 0x3b188
leaq -0x90(%rbp), %rdi
callq 0x8b10
leaq -0xf0(%rbp), %rdi
leaq -0x6c(%rbp), %rsi
callq 0x2f6a1
movq -0x90(%rbp), %rcx
movq -0x88(%rbp), %r8
movq -0xe8(%rbp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0xddbf
movq -0x80(%rbp), %rsi
cmpq %rsi, %rax
jbe 0xdde2
leaq -0xe0(%rbp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0xdddd
movq -0xe0(%rbp), %rsi
cmpq %rsi, %rax
jbe 0xde5a
movq -0xf0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x8180
jmp 0xde6a
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0xa940
leaq 0x2ca35(%rip), %rsi # 0x3a84e
leaq -0x68(%rbp), %rdi
callq 0x8b10
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x8b10
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xe00a
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0xe012
leaq -0xf0(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85f0
leaq -0xa0(%rbp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0xde94
movq %rsi, -0xb0(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xa0(%rbp)
jmp 0xde9a
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, -0xa8(%rbp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x2c98e(%rip), %rsi # 0x3a84e
leaq -0xb0(%rbp), %rdi
callq 0x8b10
movq %rbx, -0xf8(%rbp)
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
movq %r14, %rbx
cmpq %rcx, %rdx
je 0xdefa
movq %rdx, -0x68(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
jmp 0xdf02
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq %r12, %r14
movq 0x8(%rax), %rdx
leaq -0x68(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r15, %rsi
callq 0x8b10
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xdf4d
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0xdf55
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq -0x48(%rbp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0xd0(%rbp), %rdi
movq %r15, %rsi
callq 0x86f0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xdf93
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xdfa8
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdfc7
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0xe0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdfe6
movq -0xe0(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0xdffe
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %r14
movq -0xf8(%rbp), %rbx
jmp 0xe065
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq -0x48(%rbp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0xd0(%rbp), %rdi
movq %r15, %rsi
callq 0x86f0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xe050
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xe065
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0xa940
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdx
testq %rdx, %rdx
je 0xe0c2
xorl %esi, %esi
movq %rax, %rcx
movb (%rax,%rsi), %dil
cmpb $0x2f, %dil
jne 0xe0b2
movb $0x2f, %dil
cmpq -0x48(%rbp), %rcx
je 0xe0b2
cmpb $0x2f, -0x1(%rcx)
je 0xe0b8
movb %dil, (%rcx)
incq %rcx
incq %rsi
cmpq %rsi, %rdx
jne 0xe099
jmp 0xe0c5
movq %rax, %rcx
leaq -0x48(%rbp), %rdx
movq %rcx, %rax
subq (%rdx), %rax
movq %rax, 0x8(%rdx)
movb $0x0, (%rcx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe246
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xe0f6
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
je 0xe118
movq -0xc0(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe12f
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xe1fd
movq -0x58(%rbp), %rsi
jmp 0xe1f0
jmp 0xe1fa
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xe16d
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xe16d
movq %r12, %r14
movq %rax, %rbx
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe194
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xe194
movq %r12, %r14
movq %rax, %rbx
leaq -0xe0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe1bb
movq -0xe0(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xe1bb
movq %r12, %r14
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
jne 0xe1d8
jmp 0xe1fd
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r12, %rdi
je 0xe1fd
movq -0x80(%rbp), %rsi
jmp 0xe1f0
jmp 0xe1fa
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xe1fd
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xe1fd
movq %rax, %rbx
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
je 0xe21f
movq -0xc0(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
nop
|
/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(name[0]);
#endif
}
|
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++, extension));
} while (full_pathname.FileOrDirectoryExists());
return full_pathname;
}
|
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
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r13d, %ecx
movq -0x38(%rbp), %r8
callq 0xdd18
movq %rbx, %rdi
movq %r14, %rsi
callq 0x82c0
movq -0xc8(%rbp), %rdi
leaq -0xb8(%rbp), %rax
cmpq %rax, %rdi
je 0xe486
movq -0xb8(%rbp), %rsi
incq %rsi
callq 0x8520
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x82e0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x8470
incl %r13d
testl %eax, %eax
je 0xe444
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xe4e6
movq %rax, %r14
movq -0xc8(%rbp), %rdi
leaq -0xb8(%rbp), %rax
cmpq %rax, %rdi
je 0xe4e6
movq -0xb8(%rbp), %rsi
incq %rsi
callq 0x8520
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0xe4fe
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8520
movq %r14, %rdi
callq 0x8a30
|
/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
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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
cmpq %rcx, %r15
jb 0xf2c9
jmp 0xf2f7
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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(%rbx), %r15
jne 0xf320
jmp 0xf352
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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_
}
return os_stack_trace_getter_;
}
|
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 == ::std::string::npos) {
parsed.push_back(str.substr(pos));
break;
} else {
parsed.push_back(str.substr(pos, colon - pos));
pos = colon + 1;
}
}
dest->swap(parsed);
}
|
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 %r15, %rdx
callq 0x8790
movq %rax, %rbx
cmpq $-0x1, %rax
je 0xf77e
movq %rbx, %rcx
subq %r15, %rcx
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8550
leaq -0x70(%rbp), %rdi
movq %r13, %rsi
callq 0x35320
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xf778
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq 0x1(%rbx), %r15
jmp 0xf7b8
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0x8550
leaq -0x70(%rbp), %rdi
movq %r13, %rsi
callq 0x35320
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xf7b8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
cmpq $-0x1, %rbx
jne 0xf728
movq -0x50(%rbp), %rdx
movups (%rdx), %xmm0
movq 0x10(%rdx), %rax
leaq -0x70(%rbp), %rdi
movq (%rdi), %rcx
movq %rcx, (%rdx)
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rdx)
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rdx)
movaps %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
callq 0x2d6da
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf824
jmp 0xf806
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xf827
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xf827
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2d6da
movq %rbx, %rdi
callq 0x8a30
|
/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) {
if (*ch == '\0') {
result += "\\0"; // Replaces NUL with "\\0";
} else {
result += *ch;
}
}
return result;
}
|
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, 0x10(%rbx)
leaq (,%r13,2), %rsi
movq %rbx, %rdi
callq 0x8930
testq %r13, %r13
je 0xfb52
xorl %r15d, %r15d
leaq 0x2a395(%rip), %r14 # 0x39ebf
movb (%r12,%r15), %al
testb %al, %al
je 0xfb3f
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8440
jmp 0xfb4a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8b10
incq %r15
cmpq %r15, %r13
jne 0xfb2a
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfb6b
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfb7f
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0xfb9a
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8520
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfbb3
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
movq %r14, %rdi
callq 0x8a30
nop
|
/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
callq 0xa940
jmp 0xfc01
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
|
/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, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq -0x18(%rbp), %rsi
testq %rsi, %rsi
je 0xfd27
movq %rbx, %rdi
callq 0x31c6c
movq %r14, %rdi
callq 0x8a30
|
/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
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, unsigned long)
|
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 ss;
while (edit_i < edits.size()) {
// Find first edit.
while (edit_i < edits.size() && edits[edit_i] == kMatch) {
++l_i;
++r_i;
++edit_i;
}
// Find the first line to include in the hunk.
const size_t prefix_context = std::min(l_i, context);
Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);
for (size_t i = prefix_context; i > 0; --i) {
hunk.PushLine(' ', left[l_i - i].c_str());
}
// Iterate the edits until we found enough suffix for the hunk or the input
// is over.
size_t n_suffix = 0;
for (; edit_i < edits.size(); ++edit_i) {
if (n_suffix >= context) {
// Continue only if the next hunk is very close.
auto it = edits.begin() + static_cast<int>(edit_i);
while (it != edits.end() && *it == kMatch) ++it;
if (it == edits.end() ||
static_cast<size_t>(it - edits.begin()) - edit_i >= context) {
// There is no next edit or it is too far away.
break;
}
}
EditType edit = edits[edit_i];
// Reset count when a non match is found.
n_suffix = edit == kMatch ? n_suffix + 1 : 0;
if (edit == kMatch || edit == kRemove || edit == kReplace) {
hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str());
}
if (edit == kAdd || edit == kReplace) {
hunk.PushLine('+', right[r_i].c_str());
}
// Advance indices, depending on edit type.
l_i += edit != kAdd;
r_i += edit != kRemove;
}
if (!hunk.has_edits()) {
// We are done. We don't want this hunk.
break;
}
hunk.PrintTo(&ss);
}
return ss.str();
}
|
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 -0x88(%rbp), %r13
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %edi, %edi
movq -0x58(%rbp), %rcx
movq -0x50(%rbp), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %rax, %r14
jae 0x1085d
leaq (%r15,%rax), %rdx
subq %r14, %rdx
leaq (%rdi,%rax), %rsi
subq %r14, %rsi
cmpl $0x0, (%rcx,%r14,4)
jne 0x1041a
incq %r15
incq %rdi
incq %r14
cmpq %r14, %rax
jne 0x103fa
movq %rdx, %r15
movq %rax, %r14
movq %rsi, %rcx
jmp 0x1041d
movq %rdi, %rcx
movq -0x38(%rbp), %rbx
cmpq %rbx, %r15
cmovbq %r15, %rbx
movq %r15, %rax
subq %rbx, %rax
incq %rax
movq %rcx, -0x40(%rbp)
subq %rbx, %rcx
incq %rcx
movq %rax, -0xc8(%rbp)
movq %rcx, -0xc0(%rbp)
leaq -0xb8(%rbp), %rax
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r12, -0x98(%rbp)
movq %r12, -0xa0(%rbp)
movq %rcx, -0x90(%rbp)
movq %r13, -0x80(%rbp)
movq %r13, -0x88(%rbp)
movq %rcx, -0x78(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movq %rcx, -0x60(%rbp)
testq %rbx, %rbx
leaq -0xc8(%rbp), %r13
je 0x104d1
movq %r15, %r12
shlq $0x5, %r12
movq %rbx, %rax
shlq $0x5, %rax
subq %rax, %r12
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq (%rax,%r12), %rdx
movq %r13, %rdi
movl $0x20, %esi
callq 0x10918
addq $0x20, %r12
decq %rbx
jne 0x104ad
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rdx, %r14
jae 0x105fc
xorl %ebx, %ebx
cmpq -0x38(%rbp), %rbx
jb 0x10528
movslq %r14d, %rdx
leaq (%rax,%rdx,4), %rdx
cmpq %rcx, %rdx
je 0x1050b
cmpl $0x0, (%rdx)
jne 0x1050b
addq $0x4, %rdx
jmp 0x104fb
cmpq %rcx, %rdx
je 0x105fc
subq %rax, %rdx
sarq $0x2, %rdx
subq %r14, %rdx
cmpq -0x38(%rbp), %rdx
jae 0x105fc
movl (%rax,%r14,4), %r12d
incq %rbx
testl %r12d, %r12d
movl $0x0, %eax
cmovneq %rax, %rbx
cmpl $0x3, %r12d
ja 0x10578
cmpl $0x1, %r12d
je 0x10578
movq %r15, %rax
shlq $0x5, %rax
testl %r12d, %r12d
movq -0xd0(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx,%rax), %rdx
movl $0x2d, %esi
movl $0x20, %eax
cmovel %eax, %esi
leaq -0xc8(%rbp), %rdi
callq 0x10918
movl %r12d, %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x105c5
movq -0xe0(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %r13
incq -0xb8(%rbp)
movl $0x20, %edi
callq 0x84f0
movb $0x2b, 0x10(%rax)
movq %r13, 0x18(%rax)
movq %rax, %rdi
leaq -0x88(%rbp), %rsi
callq 0x80a0
incq -0x78(%rbp)
xorl %eax, %eax
cmpl $0x1, %r12d
setne %al
addq %rax, %r15
xorl %eax, %eax
cmpl $0x2, %r12d
setne %al
addq %rax, -0x40(%rbp)
incq %r14
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rdx, %r14
jb 0x104ee
movq -0xb0(%rbp), %rax
orq -0xb8(%rbp), %rax
setne -0x29(%rbp)
leaq -0x88(%rbp), %r13
je 0x107e4
movl $0x3, %edx
leaq -0x258(%rbp), %rdi
leaq 0x2ae8d(%rip), %rsi # 0x3b4bb
callq 0x8620
cmpq $0x0, -0xb0(%rbp)
je 0x10695
movl $0x1, %edx
leaq -0x258(%rbp), %rdi
leaq 0x2a61a(%rip), %rsi # 0x3ac6a
callq 0x8620
movq -0xc8(%rbp), %rsi
leaq -0x258(%rbp), %rdi
callq 0x8340
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2ae45(%rip), %rsi # 0x3b4bf
callq 0x8620
movq -0xa8(%rbp), %rsi
addq -0xb0(%rbp), %rsi
movq %rbx, %rdi
callq 0x8340
cmpq $0x0, -0xb0(%rbp)
je 0x106c1
cmpq $0x0, -0xb8(%rbp)
je 0x106c1
movl $0x1, %edx
leaq -0x258(%rbp), %rdi
leaq 0x2963c(%rip), %rsi # 0x39cf8
callq 0x8620
cmpq $0x0, -0xb8(%rbp)
je 0x10723
movl $0x1, %edx
leaq -0x258(%rbp), %rdi
leaq 0x2aba0(%rip), %rsi # 0x3b27e
callq 0x8620
movq -0xc0(%rbp), %rsi
leaq -0x258(%rbp), %rdi
callq 0x8340
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2adb7(%rip), %rsi # 0x3b4bf
callq 0x8620
movq -0xa8(%rbp), %rsi
addq -0xb8(%rbp), %rsi
movq %rbx, %rdi
callq 0x8340
movl $0x4, %edx
leaq -0x258(%rbp), %rdi
leaq 0x2ad8b(%rip), %rsi # 0x3b4c1
callq 0x8620
leaq -0xc8(%rbp), %rdi
callq 0x2bd3c
movq -0xa0(%rbp), %r12
leaq -0xa0(%rbp), %rax
cmpq %rax, %r12
je 0x107e4
movb 0x10(%r12), %al
movb %al, -0x2a(%rbp)
movl $0x1, %edx
leaq -0x258(%rbp), %rdi
leaq -0x2a(%rbp), %rsi
callq 0x8620
movq %rax, %rbx
movq 0x18(%r12), %r13
testq %r13, %r13
je 0x107a7
movq %r13, %rdi
callq 0x8230
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x8620
leaq -0x88(%rbp), %r13
jmp 0x107c7
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x89c0
leaq -0x88(%rbp), %r13
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x29cda(%rip), %rsi # 0x3a4b0
callq 0x8620
movq (%r12), %r12
jmp 0x1074e
movq -0x70(%rbp), %rdi
leaq -0x70(%rbp), %r12
cmpq %r12, %rdi
je 0x10806
movq (%rdi), %rbx
movl $0x20, %esi
callq 0x8520
movq %rbx, %rdi
cmpq %r12, %rbx
jne 0x107f1
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
leaq -0xa0(%rbp), %r12
je 0x1082e
movq (%rdi), %rbx
movl $0x20, %esi
callq 0x8520
movq %rbx, %rdi
cmpq %r13, %rbx
jne 0x10819
movq -0xa0(%rbp), %rdi
cmpq %r12, %rdi
je 0x1084f
movq (%rdi), %rbx
movl $0x20, %esi
callq 0x8520
movq %rbx, %rdi
cmpq %r12, %rbx
jne 0x1083a
cmpb $0x0, -0x29(%rbp)
movq -0x40(%rbp), %rdi
jne 0x103d4
leaq -0x250(%rbp), %rsi
movq -0xd8(%rbp), %rbx
movq %rbx, %rdi
callq 0x8950
movq 0x3c6f6(%rip), %rsi # 0x4cf70
leaq -0x268(%rbp), %rdi
callq 0x83c0
leaq -0x1e8(%rbp), %rdi
callq 0x81b0
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x108a7
movq -0x48(%rbp), %rsi
subq %rdi, %rsi
callq 0x8520
movq %rbx, %rax
addq $0x248, %rsp # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x108db
movq %rax, %rbx
jmp 0x108fa
jmp 0x108cc
jmp 0x108cc
jmp 0x108cc
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x109b0
movq 0x3c68e(%rip), %rsi # 0x4cf70
leaq -0x268(%rbp), %rdi
callq 0x83c0
leaq -0x1e8(%rbp), %rdi
callq 0x81b0
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x1090f
movq -0x48(%rbp), %rsi
subq %rdi, %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
nop
|
/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 '+':
++adds_;
hunk_adds_.push_back(std::make_pair('+', line));
break;
}
}
|
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 0x1097c
incq 0x10(%rbx)
movl $0x50, %r13d
movl $0x40, %r12d
jmp 0x1097c
incq 0x18(%rbx)
movl $0x68, %r13d
movl $0x58, %r12d
addq %rbx, %r12
movl $0x20, %edi
callq 0x84f0
movb %r15b, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x80a0
incq (%rbx,%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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
movq (%rdi), %r15
movl $0x20, %esi
callq 0x8520
movq %r15, %rdi
cmpq %r14, %r15
jne 0x109ec
movq 0x28(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x10a23
movq (%rdi), %r14
movl $0x20, %esi
callq 0x8520
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x10a0e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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 values:";
msg << "\n " << lhs_expression;
if (lhs_value != lhs_expression) {
msg << "\n Which is: " << lhs_value;
}
msg << "\n " << rhs_expression;
if (rhs_value != rhs_expression) {
msg << "\n Which is: " << rhs_value;
}
if (ignoring_case) {
msg << "\nIgnoring case";
}
if (!lhs_value.empty() && !rhs_value.empty()) {
const std::vector<std::string> lhs_lines =
SplitEscapedString(lhs_value);
const std::vector<std::string> rhs_lines =
SplitEscapedString(rhs_value);
if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
msg << "\nWith diff:\n"
<< edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
}
}
return AssertionFailure() << msg;
}
|
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 # 0x39cd3
movl $0x22, %edx
callq 0x8620
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq 0x2926f(%rip), %rsi # 0x39cf6
movl $0x3, %edx
callq 0x8620
movq -0x30(%rbp), %r12
addq $0x10, %r12
testq %rbx, %rbx
je 0x10aae
movq %rbx, %rdi
callq 0x8230
movq %rax, %rdx
movq %rbx, %rsi
jmp 0x10aba
movl $0x6, %edx
leaq 0x27a77(%rip), %rsi # 0x38531
movq %r12, %rdi
callq 0x8620
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8170
testl %eax, %eax
je 0x10afe
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq 0x2921a(%rip), %rsi # 0x39cfa
movl $0xf, %edx
callq 0x8620
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq (%r15), %rsi
movq 0x8(%r15), %rdx
callq 0x8620
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq 0x291e9(%rip), %rsi # 0x39cf6
movl $0x3, %edx
callq 0x8620
movq -0x30(%rbp), %rbx
addq $0x10, %rbx
testq %r13, %r13
je 0x10b34
movq %r13, %rdi
callq 0x8230
movq %rax, %rdx
movq %r13, %rsi
jmp 0x10b40
movl $0x6, %edx
leaq 0x279f1(%rip), %rsi # 0x38531
movq %rbx, %rdi
callq 0x8620
movq %r14, %rdi
movq %r13, %rsi
callq 0x8170
testl %eax, %eax
je 0x10b84
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq 0x29194(%rip), %rsi # 0x39cfa
movl $0xf, %edx
callq 0x8620
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x8620
cmpb $0x0, -0x34(%rbp)
je 0x10ba3
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq 0x29171(%rip), %rsi # 0x39d0a
movl $0xe, %edx
callq 0x8620
cmpq $0x0, 0x8(%r15)
movq -0x60(%rbp), %rbx
je 0x10c6f
cmpq $0x0, 0x8(%r14)
je 0x10c6f
leaq -0x90(%rbp), %rdi
movq %r15, %rsi
callq 0x10d3a
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x10d3a
movq -0x88(%rbp), %rax
subq -0x90(%rbp), %rax
cmpq $0x20, %rax
ja 0x10bfa
movq -0x70(%rbp), %rax
subq -0x78(%rbp), %rax
cmpq $0x21, %rax
jb 0x10c5a
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq 0x29110(%rip), %rsi # 0x39d19
movl $0xc, %edx
callq 0x8620
leaq -0x58(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x78(%rbp), %rdx
movl $0x2, %ecx
callq 0x1037c
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x8620
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10c5a
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x78(%rbp), %rdi
callq 0x2d6da
leaq -0x90(%rbp), %rdi
callq 0x2d6da
leaq -0x50(%rbp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2d7e6
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbbc
movq -0x50(%rbp), %rsi
testq %rsi, %rsi
je 0x10ca8
movq %r14, %rdi
callq 0x31c6c
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x10cb7
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10cec
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x10cec
jmp 0x10ce9
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x2d6da
jmp 0x10cfa
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x2d6da
jmp 0x10d23
jmp 0x10d20
movq %rax, %rbx
movq -0x50(%rbp), %rsi
testq %rsi, %rsi
je 0x10d23
movq %r14, %rdi
callq 0x31c6c
jmp 0x10d23
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x10d32
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a30
|
/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) {
escaped = false;
if (str[i] == 'n') {
lines.push_back(str.substr(start, i - start - 1));
start = i + 1;
}
} else {
escaped = str[i] == '\\';
}
}
lines.push_back(str.substr(start, end - start));
return lines;
}
|
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, -0x1(%rax,%r15)
leaq -0x1(%r15), %rax
sete %dl
cmoveq %rax, %r15
jmp 0x10d88
xorl %edx, %edx
leaq 0x1(%rdx), %r13
cmpq %r15, %r13
jae 0x10dfa
xorl %eax, %eax
leaq -0x48(%rbp), %r12
movq (%r14), %rcx
movb -0x1(%rcx,%r13), %cl
testb $0x1, %al
je 0x10de8
cmpb $0x6e, %cl
jne 0x10df0
movq %r13, %rcx
subq %rdx, %rcx
addq $-0x2, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x8550
movq %rbx, %rdi
movq %r12, %rsi
callq 0x35320
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x10de1
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
xorl %eax, %eax
movq %r13, %rdx
jmp 0x10df2
cmpb $0x5c, %cl
sete %al
jmp 0x10df2
xorl %eax, %eax
incq %r13
cmpq %r13, %r15
jne 0x10d97
subq %rdx, %r15
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x8550
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x35320
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10e31
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
jmp 0x10e5d
jmp 0x10e70
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x10e73
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x10e73
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d6da
movq %r14, %rdi
callq 0x8a30
|
/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
<< "\n Actual: " << actual_predicate_value;
if (actual_message[0] != '\0')
msg << " (" << actual_message << ")";
msg << "\nExpected: " << expected_predicate_value;
return msg.GetString();
}
|
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
movq %r14, %rdi
callq 0xf840
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x28e55(%rip), %rsi # 0x39d26
movl $0xa, %edx
movq %r12, %rdi
callq 0x8620
testq %r15, %r15
je 0x10ef0
movq %r15, %rdi
callq 0x8230
movq %rax, %rdx
jmp 0x10efc
movl $0x6, %edx
leaq 0x27635(%rip), %r15 # 0x38531
movq %r12, %rdi
movq %r15, %rsi
callq 0x8620
leaq 0x28e23(%rip), %rsi # 0x39d31
movl $0xb, %edx
movq %r12, %rdi
callq 0x8620
testq %rbx, %rbx
je 0x10f2d
movq %rbx, %rdi
callq 0x8230
movq %rax, %rdx
jmp 0x10f39
movl $0x6, %edx
leaq 0x275f8(%rip), %rbx # 0x38531
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8620
cmpb $0x0, (%r13)
je 0x10f89
leaq 0x275c8(%rip), %rsi # 0x3851a
movl $0x2, %edx
movq %r12, %rdi
callq 0x8620
movq %r13, %rdi
callq 0x8230
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x8620
leaq 0x29354(%rip), %rsi # 0x3a2d0
movl $0x1, %edx
movq %r12, %rdi
callq 0x8620
leaq 0x28dad(%rip), %rsi # 0x39d3d
movl $0xb, %edx
movq %r12, %rdi
callq 0x8620
movq -0x38(%rbp), %rbx
testq %rbx, %rbx
je 0x10fb3
movq %rbx, %rdi
callq 0x8230
movq %rax, %rdx
jmp 0x10fbf
movl $0x6, %edx
leaq 0x27572(%rip), %rbx # 0x38531
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8620
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0xfac9
testq %r14, %r14
je 0x10fe4
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0x11008
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a30
|
/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();
}
return EqFailure(lhs_expression,
rhs_expression,
PrintToString(lhs),
PrintToString(rhs),
true);
}
|
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
testb %al, %al
je 0x11510
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x11578
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2e69d
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2e69d
leaq -0x68(%rbp), %rcx
leaq -0x48(%rbp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x1, %r9d
callq 0x10a2e
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1155f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11578
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x115a7
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x115a7
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x115c0
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
|
/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 AssertionFailure() << "Expected: (" << s1_expression << ") != ("
<< s2_expression << "), actual: \""
<< s1 << "\" vs \"" << s2 << "\"";
}
}
|
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
testb %al, %al
je 0x116e7
leaq -0x18(%rbp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x26ebd(%rip), %rsi # 0x38511
leaq -0x20(%rbp), %rdi
callq 0xae58
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x28810(%rip), %rsi # 0x39e80
movq %rax, %rdi
callq 0x2e012
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x28813(%rip), %rsi # 0x39e9e
movq %rax, %rdi
callq 0x2e734
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x287e1(%rip), %rsi # 0x39e87
movq %rax, %rdi
callq 0x2e012
leaq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x291de(%rip), %rsi # 0x3a89f
movq %rax, %rdi
callq 0x2e08e
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbbc
movq -0x18(%rbp), %rsi
testq %rsi, %rsi
je 0x116f2
movq %r14, %rdi
callq 0x31c6c
jmp 0x116f2
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x18(%rbp), %rsi
testq %rsi, %rsi
je 0x11712
movq %r14, %rdi
callq 0x31c6c
movq %rbx, %rdi
callq 0x8a30
|
/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();
} else {
return AssertionFailure()
<< "Expected: (" << s1_expression << ") != ("
<< s2_expression << ") (ignoring case), actual: \""
<< s1 << "\" vs \"" << s2 << "\"";
}
}
|
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
testb %al, %al
je 0x1180e
leaq -0x18(%rbp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x26d96(%rip), %rsi # 0x38511
leaq -0x20(%rbp), %rdi
callq 0xae58
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x286e9(%rip), %rsi # 0x39e80
movq %rax, %rdi
callq 0x2e012
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x286dc(%rip), %rsi # 0x39e8e
movq %rax, %rdi
callq 0x2e7b0
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x286ba(%rip), %rsi # 0x39e87
movq %rax, %rdi
callq 0x2e012
leaq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x290b7(%rip), %rsi # 0x3a89f
movq %rax, %rdi
callq 0x2e08e
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbbc
movq -0x18(%rbp), %rsi
testq %rsi, %rsi
je 0x11819
movq %r14, %rdi
callq 0x31c6c
jmp 0x11819
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x18(%rbp), %rsi
testq %rsi, %rsi
je 0x11839
movq %r14, %rdi
callq 0x31c6c
movq %rbx, %rdi
callq 0x8a30
|
/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 = sizeof(needle[0]) > 1;
const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
return AssertionFailure()
<< "Value of: " << needle_expr << "\n"
<< " Actual: " << begin_string_quote << needle << "\"\n"
<< "Expected: " << (expected_to_be_substring ? "" : "not ")
<< "a substring of " << haystack_expr << "\n"
<< "Which is: " << begin_string_quote << haystack << "\"";
}
|
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 0x118be
cmpq %rdi, %rsi
sete %al
jmp 0x118c9
callq 0x8110
testq %rax, %rax
setne %al
cmpb %r12b, %al
je 0x119fd
leaq 0x28fc6(%rip), %rax # 0x3a89f
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x28432(%rip), %rsi # 0x39d26
leaq -0x40(%rbp), %rdi
callq 0x31b06
leaq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x28ba0(%rip), %rsi # 0x3a4b0
movq %rax, %rdi
callq 0x2e08e
leaq 0x28413(%rip), %rsi # 0x39d32
movq %rax, %rdi
callq 0x31b06
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
movq %rax, %rdi
movq %r13, %rsi
callq 0xaed6
leaq 0x28f6d(%rip), %rsi # 0x3a8b2
movq %rax, %rdi
callq 0xaf66
leaq 0x283ea(%rip), %rsi # 0x39d3e
movq %rax, %rdi
callq 0x31b06
leaq 0x28b4e(%rip), %rcx # 0x3a4b1
leaq 0x2a507(%rip), %rdx # 0x3be71
testb %r12b, %r12b
cmovneq %rcx, %rdx
leaq -0x58(%rbp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0xaed6
leaq 0x2a4ef(%rip), %rsi # 0x3be76
movq %rax, %rdi
callq 0x35bc6
leaq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x28b0e(%rip), %rsi # 0x3a4b0
movq %rax, %rdi
callq 0x2e08e
leaq 0x2834e(%rip), %rsi # 0x39cff
movq %rax, %rdi
callq 0x31b06
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
movq %rax, %rdi
movq %r15, %rsi
callq 0xaed6
leaq 0x28ec8(%rip), %rsi # 0x3a89f
movq %rax, %rdi
callq 0x2e08e
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbbc
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x11a08
movq %r14, %rdi
callq 0x31c6c
jmp 0x11a08
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11a1c
movq %rax, %rbx
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x11a30
movq %r14, %rdi
callq 0x31c6c
movq %rbx, %rdi
callq 0x8a30
|
/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 = sizeof(needle[0]) > 1;
const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
return AssertionFailure()
<< "Value of: " << needle_expr << "\n"
<< " Actual: " << begin_string_quote << needle << "\"\n"
<< "Expected: " << (expected_to_be_substring ? "" : "not ")
<< "a substring of " << haystack_expr << "\n"
<< "Which is: " << begin_string_quote << haystack << "\"";
}
|
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 0x11ab5
cmpq %rdi, %rsi
sete %al
jmp 0x11ac0
callq 0x86b0
testq %rax, %rax
setne %al
cmpb %r12b, %al
je 0x11bf4
leaq 0x2a3b6(%rip), %rax # 0x3be86
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x2823b(%rip), %rsi # 0x39d26
leaq -0x40(%rbp), %rdi
callq 0x31b06
leaq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x289a9(%rip), %rsi # 0x3a4b0
movq %rax, %rdi
callq 0x2e08e
leaq 0x2821c(%rip), %rsi # 0x39d32
movq %rax, %rdi
callq 0x31b06
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
movq %rax, %rdi
movq %r13, %rsi
callq 0x35c42
leaq 0x28d76(%rip), %rsi # 0x3a8b2
movq %rax, %rdi
callq 0xaf66
leaq 0x281f3(%rip), %rsi # 0x39d3e
movq %rax, %rdi
callq 0x31b06
leaq 0x28957(%rip), %rcx # 0x3a4b1
leaq 0x2a310(%rip), %rdx # 0x3be71
testb %r12b, %r12b
cmovneq %rcx, %rdx
leaq -0x58(%rbp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0xaed6
leaq 0x2a2f8(%rip), %rsi # 0x3be76
movq %rax, %rdi
callq 0x35bc6
leaq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x28917(%rip), %rsi # 0x3a4b0
movq %rax, %rdi
callq 0x2e08e
leaq 0x28157(%rip), %rsi # 0x39cff
movq %rax, %rdi
callq 0x31b06
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
movq %rax, %rdi
movq %r15, %rsi
callq 0x35c42
leaq 0x28cd1(%rip), %rsi # 0x3a89f
movq %rax, %rdi
callq 0x2e08e
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbbc
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x11bff
movq %r14, %rdi
callq 0x31c6c
jmp 0x11bff
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11c13
movq %rax, %rbx
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x11c27
movq %r14, %rdi
callq 0x31c6c
movq %rbx, %rdi
callq 0x8a30
|
/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_traits<char>, std::allocator<char>> 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 = sizeof(needle[0]) > 1;
const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
return AssertionFailure()
<< "Value of: " << needle_expr << "\n"
<< " Actual: " << begin_string_quote << needle << "\"\n"
<< "Expected: " << (expected_to_be_substring ? "" : "not ")
<< "a substring of " << haystack_expr << "\n"
<< "Which is: " << begin_string_quote << haystack << "\"";
}
|
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 %r12b, %al
je 0x11e37
leaq 0x28b8c(%rip), %rax # 0x3a89f
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x27ff8(%rip), %rsi # 0x39d26
leaq -0x40(%rbp), %rdi
callq 0x31b06
leaq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x28766(%rip), %rsi # 0x3a4b0
movq %rax, %rdi
callq 0x2e08e
leaq 0x27fd9(%rip), %rsi # 0x39d32
movq %rax, %rdi
callq 0x31b06
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
movq %rax, %rdi
movq %r13, %rsi
callq 0xafe4
leaq 0x28b33(%rip), %rsi # 0x3a8b2
movq %rax, %rdi
callq 0xaf66
leaq 0x27fb0(%rip), %rsi # 0x39d3e
movq %rax, %rdi
callq 0x31b06
leaq 0x28714(%rip), %rcx # 0x3a4b1
leaq 0x2a0cd(%rip), %rdx # 0x3be71
testb %r12b, %r12b
cmovneq %rcx, %rdx
leaq -0x58(%rbp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0xaed6
leaq 0x2a0b5(%rip), %rsi # 0x3be76
movq %rax, %rdi
callq 0x35bc6
leaq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x286d4(%rip), %rsi # 0x3a4b0
movq %rax, %rdi
callq 0x2e08e
leaq 0x27f14(%rip), %rsi # 0x39cff
movq %rax, %rdi
callq 0x31b06
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
movq %rax, %rdi
movq %r15, %rsi
callq 0xafe4
leaq 0x28a8e(%rip), %rsi # 0x3a89f
movq %rax, %rdi
callq 0x2e08e
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbbc
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x11e42
movq %r14, %rdi
callq 0x31c6c
jmp 0x11e42
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11e56
movq %rax, %rbx
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x11e6a
movq %r14, %rdi
callq 0x31c6c
movq %rbx, %rdi
callq 0x8a30
|
/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<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> 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 = sizeof(needle[0]) > 1;
const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
return AssertionFailure()
<< "Value of: " << needle_expr << "\n"
<< " Actual: " << begin_string_quote << needle << "\"\n"
<< "Expected: " << (expected_to_be_substring ? "" : "not ")
<< "a substring of " << haystack_expr << "\n"
<< "Which is: " << begin_string_quote << haystack << "\"";
}
|
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 %r12b, %al
je 0x12032
leaq 0x29f78(%rip), %rax # 0x3be86
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x27dfd(%rip), %rsi # 0x39d26
leaq -0x40(%rbp), %rdi
callq 0x31b06
leaq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x2856b(%rip), %rsi # 0x3a4b0
movq %rax, %rdi
callq 0x2e08e
leaq 0x27dde(%rip), %rsi # 0x39d32
movq %rax, %rdi
callq 0x31b06
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
movq %rax, %rdi
movq %r13, %rsi
callq 0x35cac
leaq 0x28938(%rip), %rsi # 0x3a8b2
movq %rax, %rdi
callq 0xaf66
leaq 0x27db5(%rip), %rsi # 0x39d3e
movq %rax, %rdi
callq 0x31b06
leaq 0x28519(%rip), %rcx # 0x3a4b1
leaq 0x29ed2(%rip), %rdx # 0x3be71
testb %r12b, %r12b
cmovneq %rcx, %rdx
leaq -0x58(%rbp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0xaed6
leaq 0x29eba(%rip), %rsi # 0x3be76
movq %rax, %rdi
callq 0x35bc6
leaq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x284d9(%rip), %rsi # 0x3a4b0
movq %rax, %rdi
callq 0x2e08e
leaq 0x27d19(%rip), %rsi # 0x39cff
movq %rax, %rdi
callq 0x31b06
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
movq %rax, %rdi
movq %r15, %rsi
callq 0x35cac
leaq 0x28893(%rip), %rsi # 0x3a89f
movq %rax, %rdi
callq 0x2e08e
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbbc
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x1203d
movq %r14, %rdi
callq 0x31c6c
jmp 0x1203d
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12051
movq %rax, %rbx
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x12065
movq %r14, %rdi
callq 0x31c6c
movq %rbx, %rdi
callq 0x8a30
|
/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<char>(code_point); // 0xxxxxxx
} else if (code_point <= kMaxCodePoint2) {
str[2] = '\0';
str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
str[0] = static_cast<char>(0xC0 | code_point); // 110xxxxx
} else if (code_point <= kMaxCodePoint3) {
str[3] = '\0';
str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
str[0] = static_cast<char>(0xE0 | code_point); // 1110xxxx
} else { // code_point <= kMaxCodePoint4
str[4] = '\0';
str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx
str[0] = static_cast<char>(0xF0 | code_point); // 11110xxx
}
return str;
}
|
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(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1212c
movq %rdx, -0x30(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x20(%rbp)
jmp 0x12133
cmpl $0x7f, %esi
ja 0x12104
movb $0x0, -0x2f(%rbp)
movb %sil, -0x30(%rbp)
jmp 0x121f8
cmpl $0x7ff, %esi # imm = 0x7FF
ja 0x121c9
movb $0x0, -0x2e(%rbp)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, -0x2f(%rbp)
orb $-0x40, %al
jmp 0x121f5
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq -0x30(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x2817b(%rip), %rsi # 0x3a2d0
callq 0x8b10
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x1217c
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x12182
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x121ae
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1221e
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x1221e
movl %esi, %ecx
shrl $0x6, %ecx
movl %esi, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movl %esi, %eax
shrl $0xc, %eax
andb $0x3f, %cl
orb $-0x80, %cl
cmpl $0xffff, %esi # imm = 0xFFFF
ja 0x1222a
movb $0x0, -0x2d(%rbp)
movb %dl, -0x2e(%rbp)
movb %cl, -0x2f(%rbp)
orb $-0x20, %al
movb %al, -0x30(%rbp)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x8230
leaq (%rax,%rbp), %rdx
addq $-0x30, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3470e
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movb $0x0, -0x2c(%rbp)
movb %dl, -0x2d(%rbp)
movb %cl, -0x2e(%rbp)
shrl $0x12, %esi
andb $0x3f, %al
orb $-0x80, %al
movb %al, -0x2f(%rbp)
orb $-0x10, %sil
jmp 0x120fb
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x12264
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x12264
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1227d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
nop
|
/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)
movq -0x18(%rax), %rax
orl $0x4000, -0x170(%rbp,%rax) # imm = 0x4000
movl %r14d, %esi
callq 0x8340
leaq -0x180(%rbp), %rsi
movq %rbx, %rdi
callq 0x8950
movq 0x3ac7b(%rip), %rsi # 0x4cf70
leaq -0x198(%rbp), %rdi
callq 0x83c0
leaq -0x118(%rbp), %rdi
callq 0x81b0
movq %rbx, %rax
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x3ac4a(%rip), %rsi # 0x4cf70
leaq -0x198(%rbp), %rdi
callq 0x83c0
leaq -0x118(%rbp), %rdi
callq 0x81b0
movq %rbx, %rdi
callq 0x8a30
|
/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 && IsUtf16SurrogatePair(str[i], str[i + 1])) {
unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
str[i + 1]);
i++;
} else {
unicode_code_point = static_cast<uint32_t>(str[i]);
}
stream << CodePointToUtf8(unicode_code_point);
}
return StringStreamToString(&stream);
}
|
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 0x123e4
movl %r12d, %ebx
decq %rbx
xorl %r15d, %r15d
leaq -0x48(%rbp), %r12
movl (%r14,%r15,4), %r13d
testl %r13d, %r13d
je 0x123e4
movq %r12, %rdi
movl %r13d, %esi
callq 0x12093
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x1c8(%rbp), %rdi
callq 0x8620
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x123d3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
testl %r13d, %r13d
je 0x123e4
leaq 0x1(%r15), %rax
cmpq %r15, %rbx
movq %rax, %r15
jne 0x12392
leaq -0x1d8(%rbp), %rsi
movq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0xfac9
movq 0x3ab72(%rip), %rsi # 0x4cf70
leaq -0x1d8(%rbp), %rdi
callq 0x83c0
leaq -0x158(%rbp), %rdi
callq 0x81b0
movq %rbx, %rax
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1244b
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1244e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x1244e
movq %rax, %r14
movq 0x3ab1b(%rip), %rsi # 0x4cf70
leaq -0x1d8(%rbp), %rdi
callq 0x83c0
leaq -0x158(%rbp), %rdi
callq 0x81b0
movq %r14, %rdi
callq 0x8a30
nop
|
/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 EqFailure(lhs_expression,
rhs_expression,
PrintToString(lhs),
PrintToString(rhs),
false);
}
|
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
testb %al, %al
je 0x124f0
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x12555
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2e82c
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2e82c
leaq -0x68(%rbp), %rcx
leaq -0x48(%rbp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x10a2e
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1253c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12555
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12584
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x12584
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1259d
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
|
/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 AssertionFailure() << "Expected: (" << s1_expression << ") != ("
<< s2_expression << "), actual: "
<< PrintToString(s1)
<< " vs " << PrintToString(s2);
}
|
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, %eax
sete %al
testb %al, %al
je 0x126e3
leaq -0x20(%rbp), %rbx
movb $0x0, -0x8(%rbx)
movq $0x0, (%rbx)
leaq 0x25f0a(%rip), %rsi # 0x38511
leaq -0x28(%rbp), %rdi
callq 0xae58
leaq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x2785d(%rip), %rsi # 0x39e80
movq %rax, %rdi
callq 0x2e012
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0xaed6
leaq 0x25ee2(%rip), %rsi # 0x38520
movq %rax, %rdi
callq 0xae58
movq %rax, %r15
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2e82c
leaq -0x88(%rbp), %rsi
movq %r15, %rdi
callq 0xafe4
leaq 0x25ebd(%rip), %rsi # 0x3852c
movq %rax, %rdi
callq 0xb058
movq %rax, %r15
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2e82c
leaq -0x68(%rbp), %rsi
movq %r15, %rdi
callq 0xafe4
movq %r14, %rdi
movq %rax, %rsi
callq 0xfbbc
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x126b7
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x126d0
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x20(%rbp), %rsi
testq %rsi, %rsi
je 0x126ef
movq %rbx, %rdi
callq 0x31c6c
jmp 0x126ef
movb $0x1, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1271f
jmp 0x1273d
movq %rax, %r14
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12722
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x12722
movq %rax, %r14
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12740
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x12740
movq %rax, %r14
movq -0x20(%rbp), %rsi
testq %rsi, %rsi
je 0x12751
movq %rbx, %rdi
callq 0x31c6c
movq %r14, %rdi
callq 0x8a30
nop
|
/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
return wcscasecmp(lhs, rhs) == 0;
#else
// Android, Mac OS X and Cygwin don't define wcscasecmp.
// Other unknown OSes may not define it either.
wint_t left, right;
do {
left = towlower(static_cast<wint_t>(*lhs++));
right = towlower(static_cast<wint_t>(*rhs++));
} while (left && left == right);
return left == right;
#endif // OS selector
}
|
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 = 0xFE68
cmpb $0x0, 0xe1(%r12)
jne 0x12855
movq %r12, %rdi
movl $0x20, %esi
callq 0x84c0
movb %al, 0xe0(%r12)
movb $0x1, 0xe1(%r12)
leaq -0x198(%rbp), %rdi
movb $0x30, 0xe0(%r12)
movq (%rdi), %rax
movq -0x18(%rax), %rax
movslq %r15d, %rcx
movq %rcx, -0x188(%rbp,%rax)
movl %r14d, %esi
callq 0x89f0
leaq -0x190(%rbp), %rsi
movq %rbx, %rdi
callq 0x8950
movq 0x3a6db(%rip), %rsi # 0x4cf70
leaq -0x1a8(%rbp), %rdi
callq 0x83c0
leaq -0x128(%rbp), %rdi
callq 0x81b0
movq %rbx, %rax
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x3a6a6(%rip), %rsi # 0x4cf70
leaq -0x1a8(%rbp), %rdi
callq 0x83c0
leaq -0x128(%rbp), %rdi
callq 0x81b0
movq %rbx, %rdi
callq 0x8a30
|
/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 = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x12ac5
imulq $0x70, %rsi, %rcx
addq %rcx, %rax
popq %rbp
retq
callq 0x2ea5f
leaq 0x293bd(%rip), %rdi # 0x3be89
xorl %eax, %eax
callq 0x88d0
nop
|
/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
leaq 0x2935b(%rip), %rdi # 0x3be89
xorl %eax, %eax
callq 0x88d0
nop
|
/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_matching_key =
std::find_if(test_properties_.begin(), test_properties_.end(),
internal::TestPropertyKeyIs(test_property.key()));
if (property_with_matching_key == test_properties_.end()) {
test_properties_.push_back(test_property);
return;
}
property_with_matching_key->SetValue(test_property.value());
}
|
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
leaq -0x29(%rbp), %rdx
callq 0x2d590
leaq -0x60(%rbp), %r13
movq %r13, -0x10(%r13)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0xa940
leaq -0x70(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2eaa0
movq %rax, %r15
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x12be7
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x40(%rbp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x12c01
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
cmpq 0x58(%rbx), %r15
je 0x12c3f
movq 0x20(%r14), %rsi
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x2d590
addq $0x20, %r15
leaq -0x50(%rbp), %rsi
movq %r15, %rdi
callq 0x82c0
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x12c4b
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x12c4b
leaq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x2ec14
movq %rbx, %rdi
callq 0x31d4c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12cae
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
jne 0x12ca0
jmp 0x12cb1
jmp 0x12cae
jmp 0x12cc1
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x12c93
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x12c93
movq %rax, %r14
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12cb1
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x12cb1
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d4c
movq %r14, %rdi
callq 0x8a30
movq %rax, %rdi
callq 0x2d7d8
nop
|
/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 # 0x3a668
movq %rbx, %rdi
callq 0x8170
testl %eax, %eax
je 0x12dcd
leaq 0x27989(%rip), %rsi # 0x3a6b2
movq %rbx, %rdi
callq 0x8170
testl %eax, %eax
je 0x12dea
leaq 0x26b6c(%rip), %rdx # 0x398ac
leaq -0x78(%rbp), %rdi
movl $0x3, %esi
movl $0x8fb, %ecx # imm = 0x8FB
callq 0x2a45a
movq 0x3a28e(%rip), %rdi # 0x4cfe8
leaq 0x287e3(%rip), %rsi # 0x3b544
movl $0x18, %edx
callq 0x8620
movq 0x3a276(%rip), %rdi # 0x4cfe8
leaq 0x287e4(%rip), %rsi # 0x3b55d
movl $0x23, %edx
callq 0x8620
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x3a257(%rip), %rdi # 0x4cfe8
callq 0x8620
leaq -0x78(%rbp), %rdi
callq 0x2a5a0
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
jmp 0x12e05
leaq 0x396a9(%rip), %rsi # 0x4c460
leaq 0x396e2(%rip), %rdx # 0x4c4a0
leaq -0x50(%rbp), %rdi
leaq -0x78(%rbp), %rcx
callq 0x322e4
jmp 0x12e05
leaq 0x396cc(%rip), %rsi # 0x4c4a0
leaq 0x39705(%rip), %rdx # 0x4c4e0
leaq -0x50(%rbp), %rdi
leaq -0x78(%rbp), %rcx
callq 0x322e4
jmp 0x12e05
leaq 0x396ef(%rip), %rsi # 0x4c4e0
leaq 0x39728(%rip), %rdx # 0x4c520
leaq -0x50(%rbp), %rdi
leaq -0x78(%rbp), %rcx
callq 0x322e4
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x36589
movq %rax, %rbx
movq -0x48(%rbp), %r14
cmpq %r14, %rax
je 0x13043
leaq -0x80(%rbp), %rdi
callq 0xf840
movq -0x80(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x10(%rax), %r15
leaq 0x286c5(%rip), %rsi # 0x3b50a
movl $0x27, %edx
movq %r15, %rdi
callq 0x8620
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
movq %r15, %rdi
callq 0x8620
leaq 0x256ab(%rip), %rsi # 0x3851a
movl $0x2, %edx
movq %r15, %rdi
callq 0x8620
movq %r15, -0x90(%rbp)
movq %r14, -0x98(%rbp)
movq %rbx, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf840
movq -0x48(%rbp), %rax
subq -0x50(%rbp), %rax
je 0x12f65
sarq $0x5, %rax
movq -0x30(%rbp), %r12
addq $0x10, %r12
movl $0x8, %r15d
xorl %r13d, %r13d
leaq 0x26e9e(%rip), %rbx # 0x39d62
leaq 0x26bb5(%rip), %r14 # 0x39a80
testq %r13, %r13
sete %cl
cmpq $0x3, %rax
setb %al
orb %cl, %al
jne 0x12ef0
movl $0x2, %edx
movq %r12, %rdi
leaq 0x290d7(%rip), %rsi # 0x3bfc2
callq 0x8620
movq -0x48(%rbp), %rax
subq -0x50(%rbp), %rax
sarq $0x5, %rax
decq %rax
cmpq %rax, %r13
jne 0x12f14
movl $0x4, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8620
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x8620
movq -0x50(%rbp), %rax
movq -0x8(%rax,%r15), %rsi
movq (%rax,%r15), %rdx
movq %r12, %rdi
callq 0x8620
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x8620
movq -0x48(%rbp), %rax
subq -0x50(%rbp), %rax
incq %r13
sarq $0x5, %rax
addq $0x20, %r15
cmpq %rax, %r13
jb 0x12ecb
movq -0x30(%rbp), %rbx
leaq -0x78(%rbp), %rdi
movq %rbx, %rsi
callq 0xfac9
testq %rbx, %rbx
movq -0x90(%rbp), %r15
je 0x12f8a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq %r15, %rdi
callq 0x8620
movq -0x98(%rbp), %r14
leaq 0x2858a(%rip), %rsi # 0x3b532
movl $0x11, %edx
movq %r15, %rdi
callq 0x8620
leaq 0x273e1(%rip), %rsi # 0x3a39d
movl $0xb, %edx
movq %r15, %rdi
callq 0x8620
leaq 0x27300(%rip), %rsi # 0x3a2d0
movl $0x1, %edx
movq %r15, %rdi
callq 0x8620
leaq 0x268c8(%rip), %rdx # 0x398ac
leaq 0x26ff6(%rip), %r8 # 0x39fe1
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movl $0x924, %ecx # imm = 0x924
callq 0xb720
movq -0x88(%rbp), %rbx
leaq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xb7d8
leaq -0x30(%rbp), %rdi
callq 0xb798
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13034
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x13043
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x50(%rbp), %rdi
callq 0x2d6da
leaq -0xa8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1306b
movq -0xa8(%rbp), %rsi
incq %rsi
callq 0x8520
cmpq %r14, %rbx
sete %al
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0xb798
jmp 0x130b7
jmp 0x130b4
jmp 0x130d2
jmp 0x130af
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x2a5a0
jmp 0x130fe
movq %rax, %r14
jmp 0x130fe
movq %rax, %r14
jmp 0x130f5
movq %rax, %r14
jmp 0x130e4
movq %rax, %r14
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x130e4
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x130e4
movq %rax, %r14
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x130e4
movq (%rdi), %rax
callq *0x8(%rax)
cmpq $0x0, -0x58(%rbp)
je 0x130f5
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x50(%rbp), %rdi
callq 0x2d6da
leaq -0xa8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1311d
movq -0xa8(%rbp), %rsi
incq %rsi
callq 0x8520
movq %r14, %rdi
callq 0x8a30
nop
|
/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
movl $0x1, %r15d
movq 0x40(%rbx), %rax
subq 0x38(%rbx), %rax
shrq $0x4, %rax
imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7
cmpl %eax, %r15d
setl %r14b
jge 0x13215
movq %rbx, %rdi
movl %r15d, %esi
callq 0x12a76
movl (%rax), %eax
decl %eax
incl %r15d
cmpl $0x1, %eax
ja 0x131e3
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x2d590
callq 0xb8c6
leaq 0x3a7d7(%rip), %rdi # 0x4dbc0
leaq -0x60(%rbp), %rdx
movq %r14, %rsi
callq 0x1331c
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1340e
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13427
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
testq %rbx, %rbx
je 0x13435
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x13468
jmp 0x13447
movq %rax, %r14
jmp 0x13481
movq %rax, %r14
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13468
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13481
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
testq %rbx, %rbx
je 0x1348f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x8a30
|
/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 about the source file where the exception occurred.
-1, // We have no info on which line caused the exception.
message,
""); // No stack trace, either.
}
|
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 # 0x4dbc0
movl %r14d, %esi
xorl %edx, %edx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movq %rbx, %r8
movq %r15, %r9
callq 0xb940
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x13501
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x13526
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
|
/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), %rax # 0x4c658
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x139a1
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
|
/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_result.type())
<< test_part_result.message()).GetString();
}
|
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
leaq 0x10(%r14), %r12
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %r12, %rdi
callq 0x8620
leaq 0x262f6(%rip), %rsi # 0x39cf8
movl $0x1, %edx
movq %r12, %rdi
callq 0x8620
movl (%r15), %eax
cmpq $0x3, %rax
ja 0x13a28
leaq 0x25da5(%rip), %rcx # 0x397c4
movslq (%rcx,%rax,4), %r13
addq %rcx, %r13
jmp 0x13a2f
leaq 0x27c8a(%rip), %r13 # 0x3b6b9
movq %r13, %rdi
callq 0x8230
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x8620
movq 0x50(%r15), %r15
testq %r15, %r15
je 0x13a5b
movq %r15, %rdi
callq 0x8230
movq %rax, %rdx
jmp 0x13a67
movl $0x6, %edx
leaq 0x24aca(%rip), %r15 # 0x38531
movq %r12, %rdi
movq %r15, %rsi
callq 0x8620
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfac9
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13a96
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
testq %r14, %r14
je 0x13aa4
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13abf
movq %rax, %rbx
jmp 0x13adb
jmp 0x13abf
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13adb
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x13aea
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a30
|
/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 didn't call
// GTEST_SKIP().
if (!HasFatalFailure() && !IsSkipped()) {
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(
this, &Test::TestBody, "the test body");
}
// However, we want to clean up as much as possible. Hence we will
// always call TearDown(), even if SetUp() or the test body has
// failed.
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(
this, &Test::TearDown, "TearDown()");
}
|
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), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x265cf(%rip), %rcx # 0x3a11d
movl $0x11, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2ef03
callq 0x13c08
testb %al, %al
jne 0x13bb7
callq 0x13c74
testb %al, %al
jne 0x13bb7
cmpq $0x0, 0x210(%r14)
jne 0x13b94
movl $0x8, %edi
callq 0x84f0
leaq 0x384de(%rip), %rcx # 0x4c068
movq %rcx, (%rax)
movq %rax, 0x210(%r14)
movq 0x210(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x2657d(%rip), %rcx # 0x3a125
movl $0x21, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2ef03
cmpq $0x0, 0x210(%r14)
jne 0x13bdc
movl $0x8, %edi
callq 0x84f0
leaq 0x38496(%rip), %rcx # 0x4c068
movq %rcx, (%rax)
movq %rax, 0x210(%r14)
movq 0x210(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x26543(%rip), %rcx # 0x3a133
movl $0x19, %esi
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x2ef03
popq %rbx
popq %r14
popq %rbp
retq
|
/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
movq 0x40(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x13c72
xorl %esi, %esi
cmpl $0x2, (%rcx)
sete %sil
addl %esi, %eax
addq $0x70, %rcx
cmpq %rdx, %rcx
jne 0x13c59
testl %eax, %eax
setne %al
popq %rbp
retq
|
/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
nop
|
/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
movq 0x40(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x13d28
xorl %esi, %esi
cmpl $0x1, (%rcx)
sete %sil
addl %esi, %eax
addq $0x70, %rcx
cmpq %rdx, %rcx
jne 0x13d0f
testl %eax, %eax
setne %al
popq %rbp
retq
|
/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::TestFactoryBase* factory)
: test_suite_name_(a_test_suite_name),
name_(a_name),
type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
location_(a_code_location),
fixture_class_id_(fixture_class_id),
should_run_(false),
is_disabled_(false),
matches_filter_(false),
is_in_another_shard_(false),
factory_(factory),
result_() {}
|
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 0xa940
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x20(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rdi, -0x40(%rbp)
callq 0xa940
testq %r13, %r13
je 0x13dbc
movl $0x20, %edi
callq 0x84f0
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq %r13, %rdi
callq 0x8230
leaq (%rax,%r13), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x3470e
jmp 0x13dbf
xorl %r14d, %r14d
movq %r14, 0x40(%rbx)
testq %r12, %r12
je 0x13df5
movl $0x20, %edi
callq 0x84f0
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq %r12, %rdi
callq 0x8230
leaq (%rax,%r12), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x3470e
jmp 0x13df8
xorl %r14d, %r14d
movq %r14, 0x48(%rbx)
leaq 0x50(%rbx), %r14
leaq 0x60(%rbx), %r12
movq %r12, 0x50(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xa940
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rcx
movl 0x20(%r15), %edx
movl %edx, 0x70(%rbx)
movq %rcx, 0x78(%rbx)
movl $0x0, 0x80(%rbx)
movq %rax, 0x88(%rbx)
leaq 0x90(%rbx), %rdi
callq 0x2e8c2
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xd8(%rbx)
movups %xmm0, 0xc8(%rbx)
movl $0x0, 0xf8(%rbx)
movups %xmm0, 0x100(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x20, %esi
movq %r14, %rdi
callq 0x8520
jmp 0x13ee7
movq %rax, %r15
jmp 0x13ee7
movq %rax, %r15
movl $0x20, %esi
movq %r14, %rdi
callq 0x8520
jmp 0x13f02
movq %rax, %r15
jmp 0x13f02
movq %rax, %r15
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x13ecc
movq (%r12), %rsi
incq %rsi
callq 0x8520
jmp 0x13ecc
movq %rax, %r15
leaq 0x48(%rbx), %r14
movq (%r14), %rsi
testq %rsi, %rsi
je 0x13ee0
movq %r14, %rdi
callq 0x368a2
movq $0x0, (%r14)
leaq 0x40(%rbx), %r14
movq (%r14), %rsi
testq %rsi, %rsi
je 0x13efb
movq %r14, %rdi
callq 0x368a2
movq $0x0, (%r14)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x13f23
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8520
jmp 0x13f23
movq %rax, %r15
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0x13f3b
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8520
movq %r15, %rdi
callq 0x8a30
nop
|
/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_info =
new TestInfo(test_suite_name, name, type_param, value_param,
code_location, fixture_class_id, factory);
GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
return test_info;
}
|
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), %rdx
movq %r14, %rsi
callq 0x2d590
leaq -0x60(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %rbx, %rsi
callq 0x2d590
leaq -0x98(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0xa8(%rbp), %rdi
callq 0xa940
movq 0x20(%rbp), %rax
movl 0x20(%r13), %ecx
leaq -0xa8(%rbp), %r9
movl %ecx, 0x20(%r9)
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq -0x38(%rbp), %r13
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
pushq %rax
pushq -0x40(%rbp)
callq 0x13d2a
addq $0x10, %rsp
movq -0xa8(%rbp), %rdi
cmpq %rbx, %rdi
je 0x140d2
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x140eb
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x8520
movq 0x18(%rbp), %rbx
movq 0x10(%rbp), %r14
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1410c
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x8520
callq 0xb8c6
movq 0x39ae8(%rip), %rdi # 0x4dc00
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x2f086
movq %r13, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0xa8(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1415e
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x1415e
movq %rax, %r14
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1417c
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x1417c
movq %rax, %r14
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1419a
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x1419a
movq %rax, %r14
movl $0x110, %esi # imm = 0x110
movq -0x38(%rbp), %rdi
callq 0x8520
movq %r14, %rdi
callq 0x8a30
|
/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. However, in test suite " << test_suite_name << ", you tried\n"
<< "to define a test using a fixture class different from the one\n"
<< "used earlier. This can happen if the two fixture classes are\n"
<< "from different namespaces and have the same name. You should\n"
<< "probably rename one of the classes to put the tests into different\n"
<< "test suites.";
GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),
code_location.line)
<< " " << errors.GetString();
}
|
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 0x14201
movq %r12, %rdi
callq 0x8230
movq %rax, %rdx
movq %r12, %rsi
jmp 0x1420d
movl $0x6, %edx
leaq 0x24324(%rip), %rsi # 0x38531
movq %r15, %rdi
callq 0x8620
leaq 0x261e3(%rip), %rsi # 0x3a3ff
movl $0x2, %edx
movq %r15, %rdi
callq 0x8620
leaq 0x25c92(%rip), %rsi # 0x39ec2
movl $0x40, %edx
movq %r15, %rdi
callq 0x8620
leaq 0x25da4(%rip), %rsi # 0x39fe8
movl $0x1f, %edx
movq %r15, %rdi
callq 0x8620
testq %r12, %r12
je 0x14263
movq %r12, %rdi
callq 0x8230
movq %rax, %rdx
jmp 0x1426f
movl $0x6, %edx
leaq 0x242c2(%rip), %r12 # 0x38531
movq %r15, %rdi
movq %r12, %rsi
callq 0x8620
leaq 0x25ee3(%rip), %rsi # 0x3a164
movl $0xc, %edx
movq %r15, %rdi
callq 0x8620
leaq 0x25edc(%rip), %rsi # 0x3a171
movl $0x3e, %edx
movq %r15, %rdi
callq 0x8620
leaq 0x25f07(%rip), %rsi # 0x3a1b0
movl $0x3d, %edx
movq %r15, %rdi
callq 0x8620
leaq 0x25f31(%rip), %rsi # 0x3a1ee
movl $0x3d, %edx
movq %r15, %rdi
callq 0x8620
leaq 0x25f5b(%rip), %rsi # 0x3a22c
movl $0x43, %edx
movq %r15, %rdi
callq 0x8620
leaq 0x25e2b(%rip), %rsi # 0x3a110
movl $0xc, %edx
movq %r15, %rdi
callq 0x8620
leaq 0x255b3(%rip), %rdx # 0x398ac
leaq -0x24(%rbp), %rdi
movl $0x2, %esi
movl $0xadd, %ecx # imm = 0xADD
callq 0x2a45a
movq (%r14), %rsi
movl 0x20(%r14), %edx
leaq -0x70(%rbp), %rdi
callq 0x14421
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq 0x38cbd(%rip), %rdi # 0x4cfe8
callq 0x8620
movq %rax, %r14
leaq 0x259be(%rip), %rsi # 0x39cf8
movl $0x1, %edx
movq %rax, %rdi
callq 0x8620
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0xfac9
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %r14, %rdi
callq 0x8620
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1437c
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14395
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x24(%rbp), %rdi
callq 0x2a5a0
testq %rbx, %rbx
je 0x143ac
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x143e3
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x143e3
jmp 0x143e0
movq %rax, %rbx
jmp 0x143fc
jmp 0x14407
movq %rax, %rbx
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x143fc
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x24(%rbp), %rdi
callq 0x2a5a0
jmp 0x1440a
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x14419
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a30
|
/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 + ":" + StreamableToString(line) + ":";
#endif // _MSC_VER
}
|
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 -0xa8(%rbp), %rdi
movq %r14, %rsi
callq 0x3470e
cmpl $0x0, -0x24(%rbp)
js 0x1450a
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0xa940
leaq 0x264fb(%rip), %rsi # 0x3a99f
leaq -0x48(%rbp), %rdi
callq 0x8b10
leaq -0x88(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x2f6a1
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x80(%rbp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x144db
movq -0x38(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x144f8
leaq -0x78(%rbp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x144f3
movq -0x78(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x1453e
movq -0x88(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x8180
jmp 0x1454e
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xa940
leaq 0x2646e(%rip), %rsi # 0x3a99f
movq %rbx, %rdi
callq 0x8b10
jmp 0x14627
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85f0
leaq -0x58(%rbp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x1456f
movq %rsi, -0x68(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
jmp 0x14575
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, -0x60(%rbp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x26407(%rip), %rsi # 0x3a99f
leaq -0x68(%rbp), %rdi
callq 0x8b10
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x145c3
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x145c9
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x145f9
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14612
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x14627
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0xa8(%rbp), %rdi
cmpq %r15, %rdi
je 0x14642
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x146c3
movq (%r12), %rsi
jmp 0x146b6
jmp 0x146c0
movq %rax, %r14
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14689
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x14689
movq %rax, %r14
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x146a9
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x146a9
jmp 0x146a6
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x146c3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x146c3
movq %rax, %r14
movq -0xa8(%rbp), %rdi
cmpq %r15, %rdi
je 0x146de
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x8520
movq %r14, %rdi
callq 0x8a30
|
/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, 0x160(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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),
tear_down_tc_(tear_down_tc),
should_run_(false),
start_timestamp_(0),
elapsed_time_(0) {}
|
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 0x84f0
movq %rax, %r13
addq $0x10, %rax
movq %rax, (%r13)
movq %r12, %rdi
callq 0x8230
leaq (%rax,%r12), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x3470e
jmp 0x14a49
xorl %r13d, %r13d
leaq 0x28(%rbx), %r12
movq %r13, 0x28(%rbx)
leaq 0x30(%rbx), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movq %r15, 0x60(%rbx)
movq %r14, 0x68(%rbx)
movb $0x0, 0x70(%rbx)
leaq 0x88(%rbx), %rdi
movups %xmm0, 0x78(%rbx)
callq 0x2e8c2
xorps %xmm0, %xmm0
movups %xmm0, 0xe0(%rbx)
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xc0(%rbx)
movl $0x0, 0xf0(%rbx)
movups %xmm0, 0xf8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x20, %esi
movq %r13, %rdi
callq 0x8520
jmp 0x14af5
movq %rax, %r14
jmp 0x14af5
movq %rax, %r14
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x14ae7
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x8520
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x8b82
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x14b0d
movq (%rbx), %rsi
incq %rsi
callq 0x8520
movq %r14, %rdi
callq 0x8a30
nop
|
/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 # imm = 0x110
movq %r14, %rdi
callq 0x8520
addq $0x8, %r15
jmp 0x14b36
leaq 0x88(%rbx), %r14
leaq 0xd8(%rbx), %rdi
callq 0x2e962
leaq 0xc0(%rbx), %rdi
callq 0x2e9a0
movq %r14, %rdi
callq 0x2e9de
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x14b9a
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x8520
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x14baf
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x8520
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x14bc1
leaq 0x28(%rbx), %rdi
callq 0x368a2
movq $0x0, 0x28(%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x14be9
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8520
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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 (%rcx,%rax,8), %rax
jmp 0x14c4b
xorl %eax, %eax
popq %rbp
retq
nop
|
/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 (%rcx,%rax,8), %rax
jmp 0x14c85
xorl %eax, %eax
popq %rbp
retq
nop
|
/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 0x48(%rbx), %rax
shrq $0x2, %rax
movl %eax, -0xc(%rbp)
cmpq 0x58(%rbx), %rsi
je 0x14ce0
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%rbx)
jmp 0x14cf0
addq $0x48, %rbx
leaq -0xc(%rbp), %rdx
movq %rbx, %rdi
callq 0x36a1c
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
|
/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);
// Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
repeater->OnTestCaseStart(*this);
#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(
this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");
start_timestamp_ = internal::GetTimeInMillis();
internal::Timer timer;
for (int i = 0; i < total_test_count(); i++) {
GetMutableTestInfo(i)->Run();
if (GTEST_FLAG(fail_fast) && GetMutableTestInfo(i)->result()->Failed()) {
for (int j = i + 1; j < total_test_count(); j++) {
GetMutableTestInfo(j)->Skip();
}
break;
}
}
elapsed_time_ = timer.Elapsed();
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(
this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");
// Call both legacy and the new API
repeater->OnTestSuiteEnd(*this);
// Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
repeater->OnTestCaseEnd(*this);
#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
impl->set_current_test_suite(nullptr);
}
|
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
movq %r14, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
cmpq $0x0, 0x210(%r15)
jne 0x14d79
movl $0x8, %edi
callq 0x84f0
leaq 0x372f9(%rip), %rcx # 0x4c068
movq %rcx, (%rax)
movq %rax, 0x210(%r15)
movq %r15, -0x38(%rbp)
movq 0x210(%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x1a881(%rip), %rsi # 0x2f612
leaq 0x25515(%rip), %rcx # 0x3a2ad
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2f48f
callq 0x8090
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
movq %rdx, 0x78(%rbx)
callq 0x87b0
movq %rax, -0x30(%rbp)
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x14ec8
movl $0x1, %r13d
movl $0x90, %r15d
leaq -0x1(%r13), %r12
movq 0x48(%rbx), %rcx
movq 0x50(%rbx), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rsi, %r12
jge 0x14e17
movl -0x4(%rcx,%r13,4), %edx
movl %edx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1473c
cmpb $0x1, 0x38ca9(%rip) # 0x4dad2
jne 0x14e62
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movslq %ecx, %rdx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rdx, %r12
jge 0x14e4c
movl -0x4(%rax,%r13,4), %ecx
movl %ecx, %eax
movq 0x30(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
addq %r15, %rdi
callq 0x131a6
testb %al, %al
jne 0x14eb4
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
leaq 0x1(%r13), %rdx
cmpq %rcx, %r13
movq %rdx, %r13
jl 0x14df2
jmp 0x14ec8
movq 0x48(%rbx), %rcx
movq 0x50(%rbx), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rsi, %r13
jge 0x14ea6
movl (%rcx,%r13,4), %edx
movl %edx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x148d4
incq %r13
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %ecx, %r13d
jl 0x14e86
callq 0x87b0
subq -0x30(%rbp), %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
movq %rdx, 0x80(%rbx)
movq -0x38(%rbp), %r15
cmpq $0x0, 0x210(%r15)
jne 0x14f1c
movl $0x8, %edi
callq 0x84f0
leaq 0x37156(%rip), %rcx # 0x4c068
movq %rcx, (%rax)
movq %rax, 0x210(%r15)
movq 0x210(%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x1a6f4(%rip), %rsi # 0x2f624
leaq 0x25387(%rip), %rcx # 0x3a2be
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2f48f
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x58(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x60(%rax)
movq $0x0, 0x168(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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);
// Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
repeater->OnTestCaseStart(*this);
#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
for (int i = 0; i < total_test_count(); i++) {
GetMutableTestInfo(i)->Skip();
}
// Call both legacy and the new API
repeater->OnTestSuiteEnd(*this);
// Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
repeater->OnTestCaseEnd(*this);
#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
impl->set_current_test_suite(nullptr);
}
|
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
callq *0x30(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x15025
xorl %r12d, %r12d
movq 0x48(%rbx), %rcx
movq 0x50(%rbx), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rsi, %r12
jge 0x15000
movl (%rcx,%r12,4), %edx
movl %edx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x148d4
incq %r12
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jl 0x14fe0
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x58(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x60(%rax)
movq $0x0, 0x168(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 (%r14), %r15
leaq 0xc8(%r15), %rdi
movq 0xc8(%r15), %rsi
callq 0x35d6e
leaq 0xe0(%r15), %rdi
movq 0xe0(%r15), %rsi
callq 0x366b6
movl $0x0, 0xf8(%r15)
movq $0x0, 0x108(%r15)
addq $0x8, %r14
jmp 0x150a2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 reminds the user that some
// tests may be skipped.
if (!String::CStringEquals(filter, kUniversalFilter)) {
ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_,
filter);
}
if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n",
static_cast<int>(shard_index) + 1,
internal::posix::GetEnv(kTestTotalShards));
}
if (GTEST_FLAG(shuffle)) {
ColoredPrintf(GTestColor::kYellow,
"Note: Randomizing tests' orders with a seed of %d .\n",
unit_test.random_seed());
}
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("Running %s from %s.\n",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
fflush(stdout);
}
|
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 # 0x387e6
movq %r14, %rdi
callq 0x8810
testl %eax, %eax
je 0x153f7
leaq 0x24fa6(%rip), %rsi # 0x3a387
leaq 0x24fb5(%rip), %rdx # 0x3a39d
movl $0x3, %edi
movq %r14, %rcx
xorl %eax, %eax
callq 0x15576
leaq 0x233f2(%rip), %rdi # 0x387f0
leaq 0x2340b(%rip), %rsi # 0x38810
xorl %edx, %edx
callq 0x1565b
testb %al, %al
je 0x1544a
leaq 0x233f9(%rip), %rdi # 0x38810
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x15a7b
leal 0x1(%rax), %r14d
leaq 0x233c4(%rip), %rdi # 0x387f0
callq 0x86e0
leaq 0x24f71(%rip), %rsi # 0x3a3a9
movl $0x3, %edi
movl %r14d, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x15576
cmpb $0x1, 0x386fc(%rip) # 0x4db4d
jne 0x15470
movq 0x40(%rbx), %rax
movl 0x21c(%rax), %edx
leaq 0x24f69(%rip), %rsi # 0x3a3cd
movl $0x3, %edi
xorl %eax, %eax
callq 0x15576
leaq 0x24f8b(%rip), %rsi # 0x3a402
xorl %r14d, %r14d
movl $0x2, %edi
xorl %eax, %eax
callq 0x15576
movq 0x40(%rbx), %rdi
callq 0xf5d0
leaq 0x25ad3(%rip), %rdx # 0x3af69
leaq 0x24f96(%rip), %rcx # 0x3a433
leaq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x15ca6
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
cmpq %rcx, %rax
je 0x154d5
xorl %r14d, %r14d
movq (%rax), %rdx
movzbl 0x70(%rdx), %edx
addl %edx, %r14d
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x154c2
movq -0x30(%rbp), %rbx
leaq 0x261fe(%rip), %rdx # 0x3b6de
leaq 0x26202(%rip), %rcx # 0x3b6e9
leaq -0x50(%rbp), %rdi
movl %r14d, %esi
callq 0x15ca6
leaq -0x40(%rbp), %r14
movq -0x10(%r14), %rdx
leaq 0x24f0e(%rip), %rdi # 0x3a410
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8080
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x15521
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1553a
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x8520
movq 0x37a27(%rip), %rax # 0x4cf68
movq (%rax), %rdi
callq 0x8670
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1556e
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
|
/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 = Int32FromEnvOrDie(shard_index_env, -1);
if (total_shards == -1 && shard_index == -1) {
return false;
} else if (total_shards == -1 && shard_index != -1) {
const Message msg = Message()
<< "Invalid environment variables: you have "
<< kTestShardIndex << " = " << shard_index
<< ", but have left " << kTestTotalShards << " unset.\n";
ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
fflush(stdout);
exit(EXIT_FAILURE);
} else if (total_shards != -1 && shard_index == -1) {
const Message msg = Message()
<< "Invalid environment variables: you have "
<< kTestTotalShards << " = " << total_shards
<< ", but have left " << kTestShardIndex << " unset.\n";
ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
fflush(stdout);
exit(EXIT_FAILURE);
} else if (shard_index < 0 || shard_index >= total_shards) {
const Message msg = Message()
<< "Invalid environment variables: we require 0 <= "
<< kTestShardIndex << " < " << kTestTotalShards
<< ", but you have " << kTestShardIndex << "=" << shard_index
<< ", " << kTestTotalShards << "=" << total_shards << ".\n";
ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
fflush(stdout);
exit(EXIT_FAILURE);
}
return total_shards > 1;
}
|
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 $-0x1, %eax
je 0x156d2
cmpl $-0x1, %ebx
setne %al
cmpl $-0x1, %r14d
sete %cl
orb %al, %cl
je 0x156df
cmpl $-0x1, %r14d
setne %al
cmpl $-0x1, %ebx
sete %cl
orb %al, %cl
je 0x157be
testl %r14d, %r14d
js 0x158d2
cmpl %ebx, %r14d
jge 0x158d2
cmpl $0x2, %ebx
setge %al
jmp 0x156d4
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0xf840
movq (%rbx), %rdi
addq $0x10, %rdi
leaq 0x254a1(%rip), %rsi # 0x3ab9a
movl $0x28, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x230fe(%rip), %rsi # 0x38810
movl $0x11, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x25523(%rip), %rsi # 0x3ac4e
movl $0x3, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movl %r14d, %esi
callq 0x89f0
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x2546f(%rip), %rsi # 0x3abc3
movl $0x10, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x23083(%rip), %rsi # 0x387f0
movl $0x12, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x2544e(%rip), %rsi # 0x3abd4
movl $0x8, %edx
callq 0x8620
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3008c
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x157ac
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xfac9
jmp 0x1589b
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0xf840
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x253c2(%rip), %rsi # 0x3ab9a
movl $0x28, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x22fff(%rip), %rsi # 0x387f0
movl $0x12, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x25444(%rip), %rsi # 0x3ac4e
movl $0x3, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movl %ebx, %esi
callq 0x89f0
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x25391(%rip), %rsi # 0x3abc3
movl $0x10, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x22fc5(%rip), %rsi # 0x38810
movl $0x11, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x25370(%rip), %rsi # 0x3abd4
movl $0x8, %edx
callq 0x8620
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3008c
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x1588a
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xfac9
leaq -0x40(%rbp), %rbx
movq (%rbx), %rdx
leaq 0x253af(%rip), %rsi # 0x3ac54
movl $0x1, %edi
xorl %eax, %eax
callq 0x15576
movq %rbx, %rdi
callq 0x8b58
movq 0x376a8(%rip), %rax # 0x4cf68
movq (%rax), %rdi
callq 0x8670
movl $0x1, %edi
callq 0x86d0
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0xf840
movq (%r15), %rdi
addq $0x10, %rdi
leaq 0x252f1(%rip), %rsi # 0x3abdd
movl $0x2f, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x22f0b(%rip), %rsi # 0x38810
movl $0x11, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x252ef(%rip), %rsi # 0x3ac0d
movl $0x3, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x22eb9(%rip), %rsi # 0x387f0
movl $0x12, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x252c1(%rip), %rsi # 0x3ac11
movl $0xf, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x22ea7(%rip), %rsi # 0x38810
movl $0x11, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x22b8d(%rip), %rsi # 0x3850f
movl $0x1, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movl %r14d, %esi
callq 0x89f0
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x26617(%rip), %rsi # 0x3bfc2
movl $0x2, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x22e2c(%rip), %rsi # 0x387f0
movl $0x12, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x22b32(%rip), %rsi # 0x3850f
movl $0x1, %edx
callq 0x8620
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movl %ebx, %esi
callq 0x89f0
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq 0x249fa(%rip), %rsi # 0x3a3ff
movl $0x2, %edx
callq 0x8620
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3008c
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x15a2b
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xfac9
jmp 0x15897
jmp 0x15a41
jmp 0x15a41
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x15a53
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x20(%rbp)
jmp 0x15a73
jmp 0x15a61
jmp 0x15a61
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x15a73
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a30
|
/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_FAILURE);
}
return result;
}
|
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, %edx
movq %r12, %rdi
callq 0x8620
testq %r15, %r15
je 0x15ad5
movq %r15, %rdi
callq 0x8230
movq %rax, %rdx
jmp 0x15ae1
movl $0x6, %edx
leaq 0x22a50(%rip), %r15 # 0x38531
movq %r12, %rdi
movq %r15, %rsi
callq 0x8620
leaq -0x30(%rbp), %rdi
leaq -0x24(%rbp), %rdx
movq %r14, %rsi
callq 0x21fed
movl %eax, %r14d
testq %rbx, %rbx
je 0x15b0d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
testb %r14b, %r14b
je 0x15b24
movl -0x24(%rbp), %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x86d0
movq %rax, %r14
testq %rbx, %rbx
je 0x15b3f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x8a30
nop
|
/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_param() == nullptr) {
printf("\n");
} else {
printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
}
fflush(stdout);
}
|
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 # 0x3a433
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x15ca6
leaq 0x2480d(%rip), %rsi # 0x3a425
movl $0x2, %edi
xorl %eax, %eax
callq 0x15576
movq (%r14), %rsi
movq 0x8(%rbx), %rdx
leaq 0x24807(%rip), %rdi # 0x3a439
xorl %eax, %eax
callq 0x8080
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x15c52
cmpq $0x0, (%rax)
je 0x15c52
testq %rax, %rax
je 0x15c5e
movq (%rax), %rdx
jmp 0x15c60
movl $0xa, %edi
callq 0x8800
jmp 0x15c75
xorl %edx, %edx
leaq 0x247dd(%rip), %rdi # 0x3a444
leaq 0x22bb4(%rip), %rsi # 0x38822
xorl %eax, %eax
callq 0x8080
movq 0x372ec(%rip), %rax # 0x4cf68
movq (%rax), %rdi
callq 0x8670
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15c9d
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x8520
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/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 -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x15d07
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x15d0f
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq -0x48(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
cmpl $0x1, -0x24(%rbp)
cmoveq %r15, %r14
movq %r14, %rsi
callq 0x8b10
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x15d5c
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x15d62
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x15d8e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15da7
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x15dd4
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x15dd4
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15ded
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
nop
|
/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 and got that).
PrintTestPartResult(result);
fflush(stdout);
}
}
|
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 result message to the Output
// window such that the user can double-click on it to jump to the
// corresponding source code location; otherwise they do nothing.
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
// We don't call OutputDebugString*() on Windows Mobile, as printing
// to stdout is done by OutputDebugString() there already - we don't
// want the same message printed twice.
::OutputDebugStringA(result.c_str());
::OutputDebugStringA("\n");
#endif
}
|
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 %rsi
callq 0x8520
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
|
/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, "[ FAILED ] ");
}
PrintTestName(test_info.test_suite_name(), test_info.name());
if (test_info.result()->Failed())
PrintFullTestCommentIfPresent(test_info);
if (GTEST_FLAG(print_time)) {
printf(" (%s ms)\n", internal::StreamableToString(
test_info.result()->elapsed_time()).c_str());
} else {
printf("\n");
}
fflush(stdout);
}
|
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 0x15f0d
leaq 0x24580(%rip), %rsi # 0x3a47f
movl $0x1, %edi
jmp 0x15f12
leaq 0x24556(%rip), %rsi # 0x3a463
movl $0x2, %edi
xorl %eax, %eax
callq 0x15576
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x2459e(%rip), %rdi # 0x3a4c5
xorl %eax, %eax
callq 0x8080
movq %r14, %rdi
callq 0x131a6
testb %al, %al
je 0x15f42
movq %rbx, %rdi
callq 0x15fb2
cmpb $0x1, 0x37bf8(%rip) # 0x4db41
jne 0x15f90
movq 0x108(%rbx), %rax
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f636
movq (%rbx), %rsi
leaq 0x2451e(%rip), %rdi # 0x3a48d
xorl %eax, %eax
callq 0x8080
movq (%rbx), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x15f9a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x15f9a
movl $0xa, %edi
callq 0x8800
movq 0x36fc7(%rip), %rax # 0x4cf68
movq (%rax), %rdi
callq 0x8670
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/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 = %s", kTypeParamLabel, type_param);
if (value_param != nullptr) printf(" and ");
}
if (value_param != nullptr) {
printf("%s = %s", kValueParamLabel, value_param);
}
}
}
|
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 # 0x3b6f5
xorl %eax, %eax
callq 0x8080
testq %r14, %r14
je 0x16020
leaq 0x25702(%rip), %rdi # 0x3b6fe
leaq 0x2281f(%rip), %rsi # 0x38822
movq %r14, %rdx
xorl %eax, %eax
callq 0x8080
testq %rbx, %rbx
je 0x16041
leaq 0x23d48(%rip), %rdi # 0x39d61
xorl %eax, %eax
callq 0x8080
testq %rbx, %rbx
je 0x16041
leaq 0x256d2(%rip), %rdi # 0x3b6fe
leaq 0x22855(%rip), %rsi # 0x38888
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x8080
popq %rbx
popq %r14
popq %rbp
retq
|
/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", counts.c_str(), test_case.name(),
internal::StreamableToString(test_case.elapsed_time()).c_str());
fflush(stdout);
}
|
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
leaq 0x24ede(%rip), %rdx # 0x3af69
leaq 0x243a1(%rip), %rcx # 0x3a433
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x15ca6
leaq 0x24380(%rip), %rsi # 0x3a425
movl $0x2, %edi
xorl %eax, %eax
callq 0x15576
movq (%r14), %r14
movq 0x8(%rbx), %r15
movq 0x80(%rbx), %rax
leaq -0x40(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0x2f636
leaq -0x50(%rbp), %rbx
movq -0x10(%rbx), %rcx
leaq 0x243b9(%rip), %rdi # 0x3a497
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8080
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x16100
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x8520
movq 0x36e61(%rip), %rax # 0x4cf68
movq (%rax), %rdi
callq 0x8670
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16128
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x8520
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1614f
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
nop
|
/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_suite_count(); ++i) {
const TestSuite& test_suite = *unit_test.GetTestSuite(i);
if (!test_suite.should_run() || (test_suite.failed_test_count() == 0)) {
continue;
}
for (int j = 0; j < test_suite.total_test_count(); ++j) {
const TestInfo& test_info = *test_suite.GetTestInfo(j);
if (!test_info.should_run() || !test_info.result()->Failed()) {
continue;
}
ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
printf("%s.%s", test_suite.name(), test_info.name());
PrintFullTestCommentIfPresent(test_info);
printf("\n");
}
}
printf("\n%2d FAILED %s\n", failed_test_count,
failed_test_count == 1 ? "TEST" : "TESTS");
}
|
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 # 0x3a433
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
movl %r15d, -0x2c(%rbp)
movl %r15d, %esi
callq 0x15ca6
movq (%rbx), %rsi
leaq 0x242c8(%rip), %rdi # 0x3a4b2
xorl %eax, %eax
callq 0x8080
movq (%rbx), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x16209
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
movq 0x40(%r14), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x16357
xorl %r15d, %r15d
movq 0xd0(%rcx), %rdx
movq 0xd8(%rcx), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jge 0x16257
cmpl $0x0, (%rdx,%r15,4)
js 0x16257
movq (%rax,%r15,8), %r13
jmp 0x1625a
xorl %r13d, %r13d
cmpb $0x1, 0x70(%r13)
jne 0x1632f
movq %r13, %rdi
callq 0xf306
testl %eax, %eax
je 0x1632f
movq 0x30(%r13), %rax
movq 0x38(%r13), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x1632f
xorl %r12d, %r12d
movq 0x48(%r13), %rcx
movq 0x50(%r13), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rsi, %r12
jge 0x162af
movl (%rcx,%r12,4), %edx
testl %edx, %edx
js 0x162bb
movl %edx, %ecx
movq (%rax,%rcx,8), %rbx
jmp 0x162bd
xorl %ebx, %ebx
cmpb $0x1, 0x80(%rbx)
jne 0x16311
leaq 0x90(%rbx), %rdi
callq 0x131a6
testb %al, %al
je 0x16311
movl $0x1, %edi
leaq 0x2419d(%rip), %rsi # 0x3a47f
xorl %eax, %eax
callq 0x15576
movq 0x8(%r13), %rsi
movq 0x20(%rbx), %rdx
leaq 0x241cd(%rip), %rdi # 0x3a4c5
xorl %eax, %eax
callq 0x8080
movq %rbx, %rdi
callq 0x15fb2
movl $0xa, %edi
callq 0x8800
incq %r12
movq 0x30(%r13), %rax
movq 0x38(%r13), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jl 0x1628f
incq %r15
movq 0x40(%r14), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r15
jl 0x1622d
movl -0x2c(%rbp), %esi
cmpl $0x1, %esi
leaq 0x24177(%rip), %rax # 0x3a4db
leaq 0x24175(%rip), %rdx # 0x3a4e0
cmoveq %rax, %rdx
leaq 0x24155(%rip), %rdi # 0x3a4cb
xorl %eax, %eax
callq 0x8080
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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
retq
xorl %eax, %eax
retq
nop
|
/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);
if (!test_suite.should_run() || (test_suite.skipped_test_count() == 0)) {
continue;
}
for (int j = 0; j < test_suite.total_test_count(); ++j) {
const TestInfo& test_info = *test_suite.GetTestInfo(j);
if (!test_info.should_run() || !test_info.result()->Skipped()) {
continue;
}
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
printf("%s.%s", test_suite.name(), test_info.name());
printf("\n");
}
}
}
|
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
movq 0xd0(%rcx), %rdx
movq 0xd8(%rcx), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r13
jge 0x16586
cmpl $0x0, (%rdx,%r13,4)
js 0x16586
movq (%rax,%r13,8), %r12
jmp 0x16589
xorl %r12d, %r12d
cmpb $0x1, 0x70(%r12)
jne 0x16660
movq %r12, %rdi
callq 0xf24c
testl %eax, %eax
je 0x16660
movq 0x30(%r12), %rax
movq 0x38(%r12), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x16660
xorl %r14d, %r14d
movq 0x48(%r12), %rcx
movq 0x50(%r12), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rsi, %r14
jge 0x165e3
movl (%rcx,%r14,4), %edx
testl %edx, %edx
js 0x165ef
movl %edx, %ecx
movq (%rax,%rcx,8), %r15
jmp 0x165f2
xorl %r15d, %r15d
cmpb $0x1, 0x80(%r15)
jne 0x16640
leaq 0x90(%r15), %rdi
callq 0x13160
testb %al, %al
je 0x16640
movl $0x2, %edi
leaq 0x23e59(%rip), %rsi # 0x3a471
xorl %eax, %eax
callq 0x15576
movq 0x8(%r12), %rsi
movq 0x20(%r15), %rdx
leaq 0x23e96(%rip), %rdi # 0x3a4c5
xorl %eax, %eax
callq 0x8080
movl $0xa, %edi
callq 0x8800
incq %r14
movq 0x30(%r12), %rax
movq 0x38(%r12), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r14
jl 0x165c1
incq %r13
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r13
jl 0x1655c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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(),
FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
if (GTEST_FLAG(print_time)) {
printf(" (%s ms total)",
internal::StreamableToString(unit_test.elapsed_time()).c_str());
}
printf("\n");
ColoredPrintf(GTestColor::kGreen, "[ PASSED ] ");
printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
const int skipped_test_count = unit_test.skipped_test_count();
if (skipped_test_count > 0) {
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
printf("%s, listed below:\n", FormatTestCount(skipped_test_count).c_str());
PrintSkippedTests(unit_test);
}
if (!unit_test.Passed()) {
PrintFailedTests(unit_test);
PrintFailedTestSuites(unit_test);
}
int num_disabled = unit_test.reportable_disabled_test_count();
if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
if (unit_test.Passed()) {
printf("\n"); // Add a spacer if no FAILURE banner is displayed.
}
ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n",
num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
}
// Ensure that Google Test output is printed before, e.g., heapchecker output.
fflush(stdout);
}
|
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
leaq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x15ca6
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
cmpq %rcx, %rax
je 0x1671d
xorl %r14d, %r14d
movq (%rax), %rdx
movzbl 0x70(%rdx), %edx
addl %edx, %r14d
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x1670a
movq -0x40(%rbp), %r15
leaq 0x24fb6(%rip), %rdx # 0x3b6de
leaq 0x24fba(%rip), %rcx # 0x3b6e9
leaq -0x60(%rbp), %rdi
movl %r14d, %esi
callq 0x15ca6
leaq -0x50(%rbp), %r14
movq -0x10(%r14), %rdx
leaq 0x23de7(%rip), %rdi # 0x3a531
movq %r15, %rsi
xorl %eax, %eax
callq 0x8080
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x16769
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x30(%rbp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x16783
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
cmpb $0x1, 0x373b7(%rip) # 0x4db41
jne 0x167cf
movq 0x40(%rbx), %rax
movq 0x230(%rax), %rax
leaq -0x60(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x2f636
movq (%r14), %rsi
leaq 0x23d8d(%rip), %rdi # 0x3a541
xorl %eax, %eax
callq 0x8080
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x167cf
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
movl $0xa, %edi
callq 0x8800
leaq 0x23d70(%rip), %rsi # 0x3a550
movl $0x2, %edi
xorl %eax, %eax
callq 0x15576
movq 0x40(%rbx), %rdi
callq 0xf146
leaq 0x2476d(%rip), %rdx # 0x3af69
leaq 0x23c30(%rip), %rcx # 0x3a433
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x15ca6
movq (%r14), %rsi
leaq 0x23bad(%rip), %rdi # 0x3a3c8
xorl %eax, %eax
callq 0x8080
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x16836
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
movq 0x40(%rbx), %rdi
callq 0xf1ec
testl %eax, %eax
jle 0x168a3
movl %eax, %r14d
leaq 0x23c24(%rip), %rsi # 0x3a471
movl $0x2, %edi
xorl %eax, %eax
callq 0x15576
leaq 0x24709(%rip), %rdx # 0x3af69
leaq 0x23bcc(%rip), %rcx # 0x3a433
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0x15ca6
movq (%r15), %rsi
leaq 0x23c32(%rip), %rdi # 0x3a4b2
xorl %eax, %eax
callq 0x8080
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1689b
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x16516
movq 0x40(%rbx), %rdi
callq 0x2f70c
testb %al, %al
jne 0x168c0
movq %rbx, %rdi
callq 0x1618c
movq %rbx, %rdi
callq 0x163f8
movq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0xf360
testl %eax, %eax
je 0x1691b
cmpb $0x0, 0x371fc(%rip) # 0x4dad3
jne 0x1691b
movl %eax, %ebx
movq %r14, %rdi
callq 0x2f70c
testb %al, %al
je 0x168f1
movl $0xa, %edi
callq 0x8800
cmpl $0x1, %ebx
leaq 0x23be0(%rip), %rax # 0x3a4db
leaq 0x23bde(%rip), %rcx # 0x3a4e0
cmoveq %rax, %rcx
leaq 0x23c51(%rip), %rsi # 0x3a55e
movl $0x3, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x15576
movq 0x36646(%rip), %rax # 0x4cf68
movq (%rax), %rdi
callq 0x8670
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16953
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
nop
|
/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 and got that).
PrintTestPartResult(result);
fflush(stdout);
}
}
|
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)) {
printf(" (%s ms)\n",
internal::StreamableToString(test_info.result()->elapsed_time())
.c_str());
} else {
printf("\n");
}
fflush(stdout);
}
}
|
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 0x8080
movq %rbx, %rdi
callq 0x15fb2
cmpb $0x1, 0x37130(%rip) # 0x4db41
jne 0x16a58
movq 0x108(%rbx), %rax
leaq -0x10(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f636
movq (%rbx), %rsi
leaq 0x23a56(%rip), %rdi # 0x3a48d
xorl %eax, %eax
callq 0x8080
movq (%rbx), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x16a62
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x16a62
movl $0xa, %edi
callq 0x8800
movq 0x364ff(%rip), %rax # 0x4cf68
movq (%rax), %rdi
callq 0x8670
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
|
/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(),
FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
if (GTEST_FLAG(print_time)) {
printf(" (%s ms total)",
internal::StreamableToString(unit_test.elapsed_time()).c_str());
}
printf("\n");
ColoredPrintf(GTestColor::kGreen, "[ PASSED ] ");
printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
const int skipped_test_count = unit_test.skipped_test_count();
if (skipped_test_count > 0) {
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
printf("%s.\n", FormatTestCount(skipped_test_count).c_str());
}
int num_disabled = unit_test.reportable_disabled_test_count();
if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
if (unit_test.Passed()) {
printf("\n"); // Add a spacer if no FAILURE banner is displayed.
}
ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n",
num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
}
// Ensure that Google Test output is printed before, e.g., heapchecker output.
fflush(stdout);
}
|
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
leaq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x15ca6
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
cmpq %rcx, %rax
je 0x16aef
xorl %r14d, %r14d
movq (%rax), %rdx
movzbl 0x70(%rdx), %edx
addl %edx, %r14d
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x16adc
movq -0x40(%rbp), %r15
leaq 0x24be4(%rip), %rdx # 0x3b6de
leaq 0x24be8(%rip), %rcx # 0x3b6e9
leaq -0x60(%rbp), %rdi
movl %r14d, %esi
callq 0x15ca6
leaq -0x50(%rbp), %r14
movq -0x10(%r14), %rdx
leaq 0x23a15(%rip), %rdi # 0x3a531
movq %r15, %rsi
xorl %eax, %eax
callq 0x8080
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x16b3b
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x30(%rbp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x16b55
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
cmpb $0x1, 0x36fe5(%rip) # 0x4db41
jne 0x16ba1
movq 0x40(%rbx), %rax
movq 0x230(%rax), %rax
leaq -0x60(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x2f636
movq (%r14), %rsi
leaq 0x239bb(%rip), %rdi # 0x3a541
xorl %eax, %eax
callq 0x8080
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x16ba1
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
movl $0xa, %edi
callq 0x8800
leaq 0x2399e(%rip), %rsi # 0x3a550
movl $0x2, %edi
xorl %eax, %eax
callq 0x15576
movq 0x40(%rbx), %rdi
callq 0xf146
leaq 0x2439b(%rip), %rdx # 0x3af69
leaq 0x2385e(%rip), %rcx # 0x3a433
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x15ca6
movq (%r14), %rsi
leaq 0x237db(%rip), %rdi # 0x3a3c8
xorl %eax, %eax
callq 0x8080
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x16c08
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
movq 0x40(%rbx), %rdi
callq 0xf1ec
testl %eax, %eax
jle 0x16c6d
movl %eax, %r14d
leaq 0x23852(%rip), %rsi # 0x3a471
movl $0x2, %edi
xorl %eax, %eax
callq 0x15576
leaq 0x24337(%rip), %rdx # 0x3af69
leaq 0x237fa(%rip), %rcx # 0x3a433
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0x15ca6
movq (%r15), %rsi
leaq 0x23776(%rip), %rdi # 0x3a3c8
xorl %eax, %eax
callq 0x8080
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x16c6d
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
movq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0xf360
testl %eax, %eax
je 0x16cc8
cmpb $0x0, 0x36e4f(%rip) # 0x4dad3
jne 0x16cc8
movl %eax, %ebx
movq %r14, %rdi
callq 0x2f70c
testb %al, %al
je 0x16c9e
movl $0xa, %edi
callq 0x8800
cmpl $0x1, %ebx
leaq 0x23833(%rip), %rax # 0x3a4db
leaq 0x23831(%rip), %rcx # 0x3a4e0
cmoveq %rax, %rcx
leaq 0x238a4(%rip), %rsi # 0x3a55e
movl $0x3, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x15576
movq 0x36299(%rip), %rax # 0x4cf68
movq (%rax), %rdi
callq 0x8670
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16d00
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
|
/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 0x16d27
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x16d5f
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8520
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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,8)
je 0x16e0f
incq %r8
addq %rsi, %rcx
cmpq %r8, %rax
jne 0x16dfa
xorl %ebx, %ebx
jmp 0x16e30
sarq $0x1d, %rcx
leaq (%rdi,%rcx), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x16e2b
addq %rcx, %rdi
subq %rsi, %rdx
callq 0x8980
addq $-0x8, 0x18(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
|
/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)
incq %r12
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jb 0x17244
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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, %edx
callq *0x78(%rax)
decq %r12
jne 0x1729b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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, %ecx # imm = 0xF87
callq 0x2a45a
movq 0x35cdd(%rip), %rdi # 0x4cfe8
leaq 0x23268(%rip), %rsi # 0x3a57a
movl $0x1f, %edx
callq 0x8620
leaq -0x18(%rbp), %rdi
callq 0x2a5a0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x18(%rbp), %rdi
callq 0x2a5a0
jmp 0x1733f
movq %rax, %r14
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x17357
movq (%rbx), %rsi
incq %rsi
callq 0x8520
movq %r14, %rdi
callq 0x8a30
nop
|
/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).c_str());
fclose(xmlout);
}
|
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), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x85e0
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x173cd
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x84e0
movq 0x35b94(%rip), %rsi # 0x4cf70
leaq -0x1b8(%rbp), %rdi
callq 0x83c0
leaq -0x138(%rbp), %rdi
callq 0x81b0
addq $0x1b0, %rsp # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x17402
movq %rax, %rbx
movq 0x35b64(%rip), %rsi # 0x4cf70
leaq -0x1b8(%rbp), %rdi
callq 0x83c0
leaq -0x138(%rbp), %rdi
callq 0x81b0
movq %rbx, %rdi
callq 0x8a30
|
/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 == nullptr) {
GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
}
return 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 %esi, %esi
movq %rax, %rcx
movb (%rax,%rsi), %dil
cmpb $0x2f, %dil
jne 0x17484
movb $0x2f, %dil
cmpq -0x40(%rbp), %rcx
je 0x17484
cmpb $0x2f, -0x1(%rcx)
je 0x1748a
movb %dil, (%rcx)
incq %rcx
incq %rsi
cmpq %rsi, %rdx
jne 0x1746b
jmp 0x17497
movq %rax, %rcx
leaq -0x40(%rbp), %rsi
movq %rcx, %rax
subq (%rsi), %rax
movq %rax, 0x8(%rsi)
movb $0x0, (%rcx)
leaq -0x60(%rbp), %rdi
callq 0x28f1c
leaq -0x60(%rbp), %rdi
callq 0x2918e
testb %al, %al
je 0x174d2
movq (%rbx), %rdi
leaq 0x23672(%rip), %rsi # 0x3ab3a
callq 0x8680
movq %rax, %r14
jmp 0x174d5
xorl %r14d, %r14d
testq %r14, %r14
jne 0x1753c
leaq 0x223cb(%rip), %rdx # 0x398ac
leaq -0x1c(%rbp), %rdi
movl $0x3, %esi
movl $0xbe, %ecx
callq 0x2a45a
movq 0x35aed(%rip), %rdi # 0x4cfe8
leaq 0x24204(%rip), %rsi # 0x3b706
movl $0x15, %edx
callq 0x8620
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x35ace(%rip), %rdi # 0x4cfe8
callq 0x8620
leaq 0x23379(%rip), %rsi # 0x3a89f
movl $0x1, %edx
movq %rax, %rdi
callq 0x8620
leaq -0x1c(%rbp), %rdi
callq 0x2a5a0
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17555
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1756a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1757a
movq %rax, %rbx
jmp 0x17590
movq %rax, %rbx
jmp 0x175a9
movq %rax, %rbx
leaq -0x1c(%rbp), %rdi
callq 0x2a5a0
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x175a9
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x175be
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
|
/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, kTestsuites, "tests",
StreamableToString(unit_test.reportable_test_count()));
OutputXmlAttribute(stream, kTestsuites, "failures",
StreamableToString(unit_test.failed_test_count()));
OutputXmlAttribute(
stream, kTestsuites, "disabled",
StreamableToString(unit_test.reportable_disabled_test_count()));
OutputXmlAttribute(stream, kTestsuites, "errors", "0");
OutputXmlAttribute(stream, kTestsuites, "time",
FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
OutputXmlAttribute(
stream, kTestsuites, "timestamp",
FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
if (GTEST_FLAG(shuffle)) {
OutputXmlAttribute(stream, kTestsuites, "random_seed",
StreamableToString(unit_test.random_seed()));
}
*stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());
OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
*stream << ">\n";
for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
if (unit_test.GetTestSuite(i)->reportable_test_count() > 0)
PrintXmlTestSuite(stream, *unit_test.GetTestSuite(i));
}
// If there was a test failure outside of one of the test suites (like in a
// test environment) include that in the output.
if (unit_test.ad_hoc_test_result().Failed()) {
OutputXmlTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
}
*stream << "</" << kTestsuites << ">\n";
}
|
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 # 0x3a79f
movl $0x27, %edx
movq %rbx, %rdi
callq 0x8620
leaq 0x23173(%rip), %rsi # 0x3a78d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8620
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq %rbx, %rdi
callq 0x8620
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x22de6(%rip), %rsi # 0x3a433
leaq 0x22de4(%rip), %rdx # 0x3a438
leaq -0x48(%rbp), %rdi
callq 0x3470e
movq 0x40(%r14), %rdi
callq 0xf4bc
leaq -0x6c(%rbp), %rsi
movl %eax, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0x2f6a1
leaq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x68(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
leaq -0x58(%rbp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x176a5
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x176ba
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x48(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x23ce5(%rip), %rsi # 0x3b3ad
leaq 0x23ce6(%rip), %rdx # 0x3b3b5
callq 0x3470e
movq 0x40(%r14), %rdi
callq 0xf2a6
leaq -0x6c(%rbp), %rsi
movl %eax, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0x2f6a1
leaq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x68(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x17718
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1772d
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x48(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x22f4b(%rip), %rsi # 0x3a686
leaq 0x22f4c(%rip), %rdx # 0x3a68e
callq 0x3470e
movq 0x40(%r14), %rdi
callq 0xf360
leaq -0x6c(%rbp), %rsi
movl %eax, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0x2f6a1
leaq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x68(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x1778b
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x177a0
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x48(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x22ee9(%rip), %rsi # 0x3a697
leaq 0x22ee8(%rip), %rdx # 0x3a69d
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r13, (%rdi)
leaq 0x2450b(%rip), %rsi # 0x3bcd3
leaq 0x24505(%rip), %rdx # 0x3bcd4
callq 0x3470e
leaq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x68(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x17800
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x17815
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x48(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x22e7b(%rip), %rsi # 0x3a69e
leaq 0x22e78(%rip), %rdx # 0x3a6a2
callq 0x3470e
movq 0x40(%r14), %rax
movq 0x230(%rax), %rsi
leaq -0x68(%rbp), %rdi
callq 0x181fb
leaq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x68(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x1786f
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x17884
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x48(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x22e11(%rip), %rsi # 0x3a6a3
leaq 0x22e13(%rip), %rdx # 0x3a6ac
callq 0x3470e
movq 0x40(%r14), %rax
movq 0x228(%rax), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1829b
leaq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x68(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x178de
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x178f3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
cmpb $0x1, 0x36253(%rip) # 0x4db4d
jne 0x17970
leaq -0x48(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x20e57(%rip), %rsi # 0x38761
leaq 0x20e5b(%rip), %rdx # 0x3876c
callq 0x3470e
movq 0x40(%r14), %rax
movl 0x21c(%rax), %eax
leaq -0x6c(%rbp), %rsi
movl %eax, (%rsi)
leaq -0x68(%rbp), %rdi
callq 0x2f6a1
leaq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x68(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x1795b
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x17970
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movl $0x178, %esi # imm = 0x178
addq 0x40(%r14), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1b6a4
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x8620
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x179a7
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x48(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x22d23(%rip), %rsi # 0x3a6d8
leaq 0x22d20(%rip), %rdx # 0x3a6dc
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r13, (%rdi)
leaq 0x22df8(%rip), %rsi # 0x3a7c7
leaq 0x22df9(%rip), %rdx # 0x3a7cf
callq 0x3470e
leaq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x68(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x17a07
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x17a1c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq 0x22ced(%rip), %rsi # 0x3a710
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8620
movq 0x40(%r14), %rdi
movq 0xb8(%rdi), %rax
movq 0xc0(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x17ac0
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rax,%r13,8), %rdx
movq 0x30(%rdx), %rcx
movq 0x38(%rdx), %rdx
cmpq %rdx, %rcx
je 0x17a9c
xorl %esi, %esi
movq (%rcx), %rdi
movzbl 0x83(%rdi), %r8d
xorl $0x1, %r8d
cmpb $0x0, 0x82(%rdi)
cmovel %r12d, %r8d
addl %r8d, %esi
addq $0x8, %rcx
cmpq %rdx, %rcx
jne 0x17a66
testl %esi, %esi
je 0x17a9c
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
callq 0x1b07c
incq %r13
movq 0x40(%r14), %rdi
movq 0xb8(%rdi), %rax
movq 0xc0(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r13
jl 0x17a53
addq $0x178, %rdi # imm = 0x178
callq 0x131a6
testb %al, %al
je 0x17ae1
movl $0x178, %esi # imm = 0x178
addq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x192bc
leaq 0x22ca9(%rip), %rsi # 0x3a791
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8620
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq %rbx, %rdi
callq 0x8620
leaq 0x22bfe(%rip), %rsi # 0x3a710
movl $0x2, %edx
movq %rax, %rdi
callq 0x8620
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x17b37
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x8520
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17b6e
jmp 0x17ba0
jmp 0x17bbc
jmp 0x17b6e
jmp 0x17ba0
jmp 0x17bbc
jmp 0x17ba0
jmp 0x17bbc
jmp 0x17b6e
jmp 0x17ba0
jmp 0x17bbc
jmp 0x17b6e
jmp 0x17ba0
jmp 0x17bbc
jmp 0x17b6e
jmp 0x17ba0
jmp 0x17bbc
jmp 0x17b6e
jmp 0x17ba0
jmp 0x17bbc
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x17ba3
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x17ba3
jmp 0x17bbc
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x17b7a
jmp 0x17ba3
jmp 0x17ba0
jmp 0x17bbc
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x17bbf
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x17bbf
jmp 0x17bbc
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x17bd7
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
nop
|
/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 # imm = 0x2600
movb (%r12), %al
cmpb $0x1f, %al
jg 0x181af
cmpb $0xd, %al
ja 0x181ba
movzbl %al, %ecx
btl %ecx, %r13d
jae 0x181ba
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8440
incq %r12
movq (%r14), %rax
addq 0x8(%r14), %rax
cmpq %rax, %r12
jne 0x1819a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x181dd
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x181f3
movq (%r15), %rsi
incq %rsi
callq 0x8520
movq %r14, %rdi
callq 0x8a30
|
/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 0x34d26(%rip), %rsi # 0x4cf70
leaq -0x198(%rbp), %rdi
callq 0x83c0
leaq -0x118(%rbp), %rdi
callq 0x81b0
movq %rbx, %rax
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x34cf5(%rip), %rsi # 0x4cf70
leaq -0x198(%rbp), %rdi
callq 0x83c0
leaq -0x118(%rbp), %rdi
callq 0x81b0
movq %rbx, %rdi
callq 0x8a30
|
/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 + 1) + "-" +
String::FormatIntWidth2(time_struct.tm_mday) + "T" +
String::FormatIntWidth2(time_struct.tm_hour) + ":" +
String::FormatIntWidth2(time_struct.tm_min) + ":" +
String::FormatIntWidth2(time_struct.tm_sec) + "." +
String::FormatIntWidthN(static_cast<int>(ms % 1000), 3);
}
|
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, %r15
leaq -0x148(%rbp), %rdi
movq %r15, (%rdi)
leaq -0x2a8(%rbp), %rsi
callq 0x8290
testq %rax, %rax
je 0x18348
movl $0x76c, %eax # imm = 0x76C
addl -0x294(%rbp), %eax
leaq -0x24c(%rbp), %rsi
movl %eax, (%rsi)
leaq -0x270(%rbp), %r12
movq %r12, %rdi
callq 0x2f6a1
leaq 0x2294f(%rip), %rsi # 0x3ac6a
movq %r12, %rdi
callq 0x8b10
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x18366
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x1836e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2215b(%rip), %rdx # 0x3a4b1
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3470e
jmp 0x18c5c
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl -0x298(%rbp), %esi
incl %esi
leaq -0x248(%rbp), %rdi
movl $0x2, %edx
callq 0x127ee
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x240(%rbp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x183bf
movq -0x38(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x183e2
leaq -0x238(%rbp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x183dd
movq -0x238(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x183f4
movq -0x248(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x8180
jmp 0x18404
leaq -0x248(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85f0
leaq -0x98(%rbp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x1842e
movq %rsi, -0xa8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x98(%rbp)
jmp 0x18434
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, -0xa0(%rbp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x22810(%rip), %rsi # 0x3ac6a
leaq -0xa8(%rbp), %rdi
callq 0x8b10
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1848b
movq %rdx, -0x68(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
jmp 0x18493
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, -0x60(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl -0x29c(%rbp), %esi
leaq -0x228(%rbp), %rdi
movl $0x2, %edx
callq 0x127ee
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %r8
movq -0x220(%rbp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x184e2
movq -0x58(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x18505
leaq -0x218(%rbp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x18500
movq -0x218(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x18517
movq -0x228(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x8180
jmp 0x18527
leaq -0x228(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85f0
leaq -0xb8(%rbp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x18551
movq %rsi, -0xc8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xb8(%rbp)
jmp 0x18557
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, -0xc0(%rbp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x22df4(%rip), %rsi # 0x3b371
leaq -0xc8(%rbp), %rdi
callq 0x8b10
leaq -0x158(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x185b6
movq %rdx, -0x168(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x158(%rbp)
jmp 0x185be
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, -0x160(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl -0x2a0(%rbp), %esi
leaq -0x208(%rbp), %rdi
movl $0x2, %edx
callq 0x127ee
movq -0x168(%rbp), %rcx
movq -0x160(%rbp), %r8
movq -0x200(%rbp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r13, %rcx
je 0x18619
movq -0x158(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x1863c
leaq -0x1f8(%rbp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x18637
movq -0x1f8(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x18651
movq -0x208(%rbp), %rsi
leaq -0x168(%rbp), %rdi
callq 0x8180
jmp 0x18661
leaq -0x208(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85f0
leaq -0xd8(%rbp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x1868b
movq %rsi, -0xe8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xd8(%rbp)
jmp 0x18691
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, -0xe0(%rbp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x222e8(%rip), %rsi # 0x3a99f
leaq -0xe8(%rbp), %rdi
callq 0x8b10
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x186eb
movq %rdx, -0x88(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x78(%rbp)
jmp 0x186f3
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, -0x80(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl -0x2a4(%rbp), %esi
leaq -0x1e8(%rbp), %rdi
movl $0x2, %edx
callq 0x127ee
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %r8
movq -0x1e0(%rbp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x18745
movq -0x78(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x18768
leaq -0x1d8(%rbp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x18763
movq -0x1d8(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x1877d
movq -0x1e8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x8180
jmp 0x1878d
leaq -0x1e8(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85f0
leaq -0xf8(%rbp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x187b7
movq %rsi, -0x108(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xf8(%rbp)
jmp 0x187bd
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, -0x100(%rbp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x221bc(%rip), %rsi # 0x3a99f
leaq -0x108(%rbp), %rdi
callq 0x8b10
leaq -0x178(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1881d
movq %rdx, -0x188(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x178(%rbp)
jmp 0x18825
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, -0x180(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl -0x2a8(%rbp), %esi
leaq -0x1c8(%rbp), %rdi
movl $0x2, %edx
callq 0x127ee
movq -0x188(%rbp), %rcx
movq -0x180(%rbp), %r8
movq -0x1c0(%rbp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x18880
movq -0x178(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x188a3
leaq -0x1b8(%rbp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x1889e
movq -0x1b8(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x188b8
movq -0x1c8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0x8180
jmp 0x188c8
leaq -0x1c8(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85f0
leaq -0x118(%rbp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x188f2
movq %rsi, -0x128(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x118(%rbp)
jmp 0x188f8
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, -0x120(%rbp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x21f30(%rip), %rsi # 0x3a84e
leaq -0x128(%rbp), %rdi
callq 0x8b10
imulq $0x3e8, %r15, %rcx # imm = 0x3E8
subq %rcx, %r14
leaq -0x138(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x18961
movq %rdx, -0x148(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x138(%rbp)
jmp 0x18968
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, -0x140(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x1a8(%rbp), %rdi
movl %r14d, %esi
movl $0x3, %edx
callq 0x127ee
movq -0x148(%rbp), %rcx
movq -0x140(%rbp), %r8
movq -0x1a0(%rbp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r15, %rcx
je 0x189c0
movq -0x138(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x189e3
leaq -0x198(%rbp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x189de
movq -0x198(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x189f8
movq -0x1a8(%rbp), %rsi
leaq -0x148(%rbp), %rdi
callq 0x8180
jmp 0x18a08
leaq -0x1a8(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85f0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x18a27
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x18a2d
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq -0x198(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18a68
movq -0x198(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x148(%rbp), %rdi
cmpq %r15, %rdi
je 0x18a83
movq -0x138(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x118(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18aa2
movq -0x118(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x1b8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18ac1
movq -0x1b8(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x188(%rbp), %rdi
cmpq %r12, %rdi
je 0x18adc
movq -0x178(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0xf8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
leaq -0x38(%rbp), %r14
leaq -0x58(%rbp), %r15
leaq -0x78(%rbp), %r12
je 0x18b07
movq -0xf8(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x1d8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18b26
movq -0x1d8(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x18b3e
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0xd8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18b5d
movq -0xd8(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x1f8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18b7c
movq -0x1f8(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x168(%rbp), %rdi
cmpq %r13, %rdi
je 0x18b97
movq -0x158(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0xb8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18bb6
movq -0xb8(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x218(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18bd5
movq -0x218(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x18bea
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18c09
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x238(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18c28
movq -0x238(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x18c3d
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x260(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18c5c
movq -0x260(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rax
addq $0x288, %rsp # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x198(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18c98
movq -0x198(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x18c98
movq %rax, %rbx
movq -0x148(%rbp), %rdi
cmpq %r15, %rdi
je 0x18cb8
movq -0x138(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x18cb8
movq %rax, %rbx
leaq -0x118(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18cdc
movq -0x118(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x18cdc
movq %rax, %rbx
leaq -0x1b8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18d00
movq -0x1b8(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x18d00
movq %rax, %rbx
movq -0x188(%rbp), %rdi
cmpq %r12, %rdi
je 0x18d20
movq -0x178(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x18d20
movq %rax, %rbx
leaq -0xf8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18d44
movq -0xf8(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x18d44
movq %rax, %rbx
leaq -0x1d8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18d68
movq -0x1d8(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x18d68
movq %rax, %rbx
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x18d89
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x18d89
movq %rax, %rbx
leaq -0xd8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18da8
movq -0xd8(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x1f8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18dc7
movq -0x1f8(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x168(%rbp), %rdi
cmpq %r13, %rdi
je 0x18de2
movq -0x158(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0xb8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18e01
movq -0xb8(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x218(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18e20
movq -0x218(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x18e39
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18e58
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x238(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18e77
movq -0x238(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x18e90
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x260(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18eaf
movq -0x260(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
movq %rax, %rbx
jmp 0x18da8
movq %rax, %rbx
jmp 0x18dc7
movq %rax, %rbx
jmp 0x18de2
movq %rax, %rbx
jmp 0x18e01
movq %rax, %rbx
jmp 0x18e20
movq %rax, %rbx
jmp 0x18e39
movq %rax, %rbx
jmp 0x18e58
movq %rax, %rbx
jmp 0x18e77
movq %rax, %rbx
jmp 0x18e90
nop
|
/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) {
stream->write(
segment, static_cast<std::streamsize>(next_segment - segment));
*stream << "]]>]]><![CDATA[";
segment = next_segment + strlen("]]>");
} else {
*stream << segment;
break;
}
}
*stream << "]]>";
}
|
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 %rax, %r13
testq %rax, %rax
je 0x18f67
movq %r13, %rdx
subq %r15, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x87a0
movl $0x12, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8620
leaq 0x3(%r13), %r15
jmp 0x18f9b
testq %r15, %r15
je 0x18f84
movq %r15, %rdi
callq 0x8230
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8620
jmp 0x18f9b
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x89c0
testq %r13, %r13
jne 0x18f2d
leaq 0x21615(%rip), %rsi # 0x3a5bc
movl $0x3, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8620
|
/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::allocator<char>> const&)
|
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_names.begin(), allowed_names.end(), name) !=
allowed_names.end())
<< "Attribute " << name << " is not allowed for element <" << element_name
<< ">.";
*stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
}
|
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
leaq 0x208a0(%rip), %rdx # 0x398ac
leaq -0x48(%rbp), %rdi
movl $0x3, %esi
movl $0x1039, %ecx # imm = 0x1039
callq 0x2a45a
movq 0x33fc2(%rip), %rdi # 0x4cfe8
leaq 0x215a6(%rip), %rsi # 0x3a5d3
movl $0x65, %edx
callq 0x8620
movq 0x33faa(%rip), %rdi # 0x4cfe8
leaq 0x215f4(%rip), %rsi # 0x3a639
movl $0xa, %edx
callq 0x8620
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x33f8b(%rip), %rdi # 0x4cfe8
callq 0x8620
movq %rax, %r13
leaq 0x215d8(%rip), %rsi # 0x3a644
movl $0x1d, %edx
movq %rax, %rdi
callq 0x8620
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0x8620
leaq 0x215d1(%rip), %rsi # 0x3a662
movl $0x2, %edx
movq %rax, %rdi
callq 0x8620
leaq -0x48(%rbp), %rdi
callq 0x2a5a0
leaq 0x20c4a(%rip), %rsi # 0x39cf8
movl $0x1, %edx
movq %r14, %rdi
callq 0x8620
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x8620
movq %rax, %r14
leaq 0x21697(%rip), %rsi # 0x3a76b
movl $0x2, %edx
movq %rax, %rdi
callq 0x8620
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x17f46
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r14, %rdi
callq 0x8620
leaq 0x21796(%rip), %rsi # 0x3a89f
movl $0x1, %edx
movq %rax, %rdi
callq 0x8620
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1912f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x60(%rbp), %rdi
callq 0x2d6da
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19179
jmp 0x19179
jmp 0x19179
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1917c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x1917c
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2a5a0
jmp 0x1917c
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2d6da
movq %rbx, %rdi
callq 0x8a30
|
/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_element == "testcase") {
return ArrayAsVector(kReservedOutputTestCaseAttributes);
} else {
GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
}
// This code is unreachable but some compilers may not realizes that.
return std::vector<std::string>();
}
|
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 # 0x3a6b2
movq %r14, %rdi
callq 0x8170
testl %eax, %eax
je 0x19281
leaq 0x206c2(%rip), %rdx # 0x398ac
leaq -0x18(%rbp), %rdi
movl $0x3, %esi
movl $0x90b, %ecx # imm = 0x90B
callq 0x2a45a
movq 0x33de4(%rip), %rdi # 0x4cfe8
leaq 0x22339(%rip), %rsi # 0x3b544
movl $0x18, %edx
callq 0x8620
movq 0x33dcc(%rip), %rdi # 0x4cfe8
leaq 0x2233a(%rip), %rsi # 0x3b55d
movl $0x23, %edx
callq 0x8620
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x33dad(%rip), %rdi # 0x4cfe8
callq 0x8620
leaq -0x18(%rbp), %rdi
callq 0x2a5a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x1929b
leaq 0x33200(%rip), %rsi # 0x4c460
leaq 0x33239(%rip), %rdx # 0x4c4a0
leaq -0x11(%rbp), %rcx
jmp 0x19293
leaq 0x3322c(%rip), %rsi # 0x4c4a0
leaq 0x33265(%rip), %rdx # 0x4c4e0
leaq -0x12(%rbp), %rcx
jmp 0x19293
leaq 0x33298(%rip), %rsi # 0x4c520
leaq 0x332e1(%rip), %rdx # 0x4c570
leaq -0x13(%rbp), %rcx
movq %rbx, %rdi
callq 0x322e4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x2a5a0
movq %rbx, %rdi
callq 0x8a30
nop
|
/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, "testsuite", "tests", "1");
OutputXmlAttribute(stream, "testsuite", "failures", "1");
OutputXmlAttribute(stream, "testsuite", "disabled", "0");
OutputXmlAttribute(stream, "testsuite", "skipped", "0");
OutputXmlAttribute(stream, "testsuite", "errors", "0");
OutputXmlAttribute(stream, "testsuite", "time",
FormatTimeInMillisAsSeconds(result.elapsed_time()));
OutputXmlAttribute(
stream, "testsuite", "timestamp",
FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
*stream << ">";
// Output the boilerplate for a minimal test case with a single test.
*stream << " <testcase";
OutputXmlAttribute(stream, "testcase", "name", "");
OutputXmlAttribute(stream, "testcase", "status", "run");
OutputXmlAttribute(stream, "testcase", "result", "completed");
OutputXmlAttribute(stream, "testcase", "classname", "");
OutputXmlAttribute(stream, "testcase", "time",
FormatTimeInMillisAsSeconds(result.elapsed_time()));
OutputXmlAttribute(
stream, "testcase", "timestamp",
FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
// Output the actual test result.
OutputXmlTestResult(stream, result);
// Complete the test suite.
*stream << " </testsuite>\n";
}
|
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 # 0x3a671
leaq -0x88(%rbp), %rdi
callq 0x3470e
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x213c2(%rip), %rsi # 0x3a6d8
leaq 0x213bf(%rip), %rdx # 0x3a6dc
leaq -0x68(%rbp), %rdi
callq 0x3470e
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x2133d(%rip), %rsi # 0x3a672
leaq 0x21349(%rip), %rdx # 0x3a685
leaq -0x48(%rbp), %rdi
callq 0x3470e
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x19371
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x19386
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x1939e
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x88(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x212b9(%rip), %rsi # 0x3a668
leaq 0x212bb(%rip), %rdx # 0x3a671
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x2106a(%rip), %rsi # 0x3a433
leaq 0x21068(%rip), %rdx # 0x3a438
callq 0x3470e
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
leaq 0x21c1b(%rip), %rsi # 0x3affe
leaq 0x21c15(%rip), %rdx # 0x3afff
callq 0x3470e
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1941b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x19430
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x19448
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x88(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x2120f(%rip), %rsi # 0x3a668
leaq 0x21211(%rip), %rdx # 0x3a671
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x21f3a(%rip), %rsi # 0x3b3ad
leaq 0x21f3b(%rip), %rdx # 0x3b3b5
callq 0x3470e
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
leaq 0x21b71(%rip), %rsi # 0x3affe
leaq 0x21b6b(%rip), %rdx # 0x3afff
callq 0x3470e
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x194c5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x194da
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x194f2
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x88(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x21165(%rip), %rsi # 0x3a668
leaq 0x21167(%rip), %rdx # 0x3a671
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x21169(%rip), %rsi # 0x3a686
leaq 0x2116a(%rip), %rdx # 0x3a68e
callq 0x3470e
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
leaq 0x2279c(%rip), %rsi # 0x3bcd3
leaq 0x22796(%rip), %rdx # 0x3bcd4
callq 0x3470e
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1956f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x19584
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x1959c
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x88(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x210bb(%rip), %rsi # 0x3a668
leaq 0x210bd(%rip), %rdx # 0x3a671
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x210c8(%rip), %rsi # 0x3a68f
leaq 0x210c8(%rip), %rdx # 0x3a696
callq 0x3470e
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
leaq 0x226f2(%rip), %rsi # 0x3bcd3
leaq 0x226ec(%rip), %rdx # 0x3bcd4
callq 0x3470e
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x19619
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1962e
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x19646
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x88(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x21011(%rip), %rsi # 0x3a668
leaq 0x21013(%rip), %rdx # 0x3a671
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x21026(%rip), %rsi # 0x3a697
leaq 0x21025(%rip), %rdx # 0x3a69d
callq 0x3470e
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
leaq 0x22648(%rip), %rsi # 0x3bcd3
leaq 0x22642(%rip), %rdx # 0x3bcd4
callq 0x3470e
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x196c3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x196d8
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x196f0
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x88(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x20f67(%rip), %rsi # 0x3a668
leaq 0x20f69(%rip), %rdx # 0x3a671
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x20f83(%rip), %rsi # 0x3a69e
leaq 0x20f80(%rip), %rdx # 0x3a6a2
callq 0x3470e
movq 0x78(%r14), %rsi
leaq -0x48(%rbp), %rdi
callq 0x181fb
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x19760
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x19775
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x1978d
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x88(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x20eca(%rip), %rsi # 0x3a668
leaq 0x20ecc(%rip), %rdx # 0x3a671
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x20eeb(%rip), %rsi # 0x3a6a3
leaq 0x20eed(%rip), %rdx # 0x3a6ac
callq 0x3470e
movq 0x70(%r14), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1829b
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x197fd
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x19812
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x1982a
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq 0x20f16(%rip), %rsi # 0x3a747
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8620
leaq 0x20e68(%rip), %rsi # 0x3a6ad
movl $0xd, %edx
movq %rbx, %rdi
callq 0x8620
leaq -0x88(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x20e4f(%rip), %rsi # 0x3a6b2
leaq 0x20e50(%rip), %rdx # 0x3a6ba
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x20e5b(%rip), %rsi # 0x3a6d8
leaq 0x20e58(%rip), %rdx # 0x3a6dc
callq 0x3470e
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
leaq 0x20c1a(%rip), %rdx # 0x3a4b1
movq %rdx, %rsi
callq 0x3470e
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x198cb
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x198e0
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x198f8
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x88(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x20da9(%rip), %rsi # 0x3a6b2
leaq 0x20daa(%rip), %rdx # 0x3a6ba
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x20d98(%rip), %rsi # 0x3a6bb
leaq 0x20d97(%rip), %rdx # 0x3a6c1
callq 0x3470e
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
leaq 0x20dd9(%rip), %rsi # 0x3a716
leaq 0x20dd5(%rip), %rdx # 0x3a719
callq 0x3470e
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x19975
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1998a
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x199a2
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x88(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x20cff(%rip), %rsi # 0x3a6b2
leaq 0x20d00(%rip), %rdx # 0x3a6ba
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x20cf5(%rip), %rsi # 0x3a6c2
leaq 0x20cf4(%rip), %rdx # 0x3a6c8
callq 0x3470e
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
leaq 0x20ce2(%rip), %rsi # 0x3a6c9
leaq 0x20ce4(%rip), %rdx # 0x3a6d2
callq 0x3470e
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x19a1f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x19a34
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x19a4c
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x88(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x20c55(%rip), %rsi # 0x3a6b2
leaq 0x20c56(%rip), %rdx # 0x3a6ba
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x20c5c(%rip), %rsi # 0x3a6d3
leaq 0x20c5e(%rip), %rdx # 0x3a6dc
callq 0x3470e
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
leaq 0x20a20(%rip), %rdx # 0x3a4b1
movq %rdx, %rsi
callq 0x3470e
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x19ac5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x19ada
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x19af2
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x88(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x20baf(%rip), %rsi # 0x3a6b2
leaq 0x20bb0(%rip), %rdx # 0x3a6ba
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x20b81(%rip), %rsi # 0x3a69e
leaq 0x20b7e(%rip), %rdx # 0x3a6a2
callq 0x3470e
movq 0x78(%r14), %rsi
leaq -0x48(%rbp), %rdi
callq 0x181fb
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x19b62
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x19b77
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x19b8f
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x88(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x20b12(%rip), %rsi # 0x3a6b2
leaq 0x20b13(%rip), %rdx # 0x3a6ba
callq 0x3470e
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x20ae9(%rip), %rsi # 0x3a6a3
leaq 0x20aeb(%rip), %rdx # 0x3a6ac
callq 0x3470e
movq 0x70(%r14), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1829b
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x19bff
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x19c14
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x19c2c
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19d4c
leaq 0x20a9f(%rip), %rsi # 0x3a6dd
movl $0xf, %edx
movq %rbx, %rdi
callq 0x8620
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19cef
jmp 0x19d09
jmp 0x19d23
jmp 0x19d40
jmp 0x19cef
jmp 0x19d09
jmp 0x19d23
jmp 0x19d40
jmp 0x19cef
jmp 0x19d09
jmp 0x19d23
jmp 0x19d40
jmp 0x19cef
jmp 0x19d09
jmp 0x19d23
jmp 0x19d40
jmp 0x19cef
jmp 0x19d09
jmp 0x19d23
jmp 0x19d40
jmp 0x19cef
jmp 0x19d09
jmp 0x19d23
jmp 0x19d40
jmp 0x19cef
jmp 0x19d09
jmp 0x19d23
jmp 0x19d40
jmp 0x19cef
jmp 0x19d09
jmp 0x19d23
jmp 0x19d40
jmp 0x19cef
jmp 0x19d09
jmp 0x19d23
jmp 0x19d40
jmp 0x19cef
jmp 0x19d09
jmp 0x19d23
jmp 0x19d40
jmp 0x19cef
jmp 0x19d09
jmp 0x19d23
jmp 0x19d40
jmp 0x19cef
jmp 0x19d09
jmp 0x19d23
jmp 0x19d40
jmp 0x19cef
jmp 0x19d09
jmp 0x19d23
jmp 0x19d40
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x19d0c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x19d0c
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x19d26
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x19d26
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x19d43
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x19d43
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8a30
nop
|
/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 = "testcase";
if (test_info.is_in_another_shard()) {
return;
}
*stream << " <testcase";
OutputXmlAttribute(stream, kTestsuite, "name", test_info.name());
if (test_info.value_param() != nullptr) {
OutputXmlAttribute(stream, kTestsuite, "value_param",
test_info.value_param());
}
if (test_info.type_param() != nullptr) {
OutputXmlAttribute(stream, kTestsuite, "type_param",
test_info.type_param());
}
if (GTEST_FLAG(list_tests)) {
OutputXmlAttribute(stream, kTestsuite, "file", test_info.file());
OutputXmlAttribute(stream, kTestsuite, "line",
StreamableToString(test_info.line()));
*stream << " />\n";
return;
}
OutputXmlAttribute(stream, kTestsuite, "status",
test_info.should_run() ? "run" : "notrun");
OutputXmlAttribute(stream, kTestsuite, "result",
test_info.should_run()
? (result.Skipped() ? "skipped" : "completed")
: "suppressed");
OutputXmlAttribute(stream, kTestsuite, "time",
FormatTimeInMillisAsSeconds(result.elapsed_time()));
OutputXmlAttribute(
stream, kTestsuite, "timestamp",
FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name);
OutputXmlTestResult(stream, result);
}
|
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, 0x83(%r14)
jne 0x1aa5f
leaq 0x201bc(%rip), %rsi # 0x3a6ad
movl $0xd, %edx
movq %rbx, %rdi
callq 0x8620
movq %r12, -0xa0(%rbp)
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x201c3(%rip), %rsi # 0x3a6d8
leaq 0x201c0(%rip), %rdx # 0x3a6dc
leaq -0x68(%rbp), %rdi
callq 0x3470e
movq 0x20(%r14), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x6c(%rbp), %rdx
callq 0x2d590
leaq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a566
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1a57b
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x1a60a
cmpq $0x0, (%rax)
je 0x1a60a
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x20151(%rip), %rsi # 0x3a6ed
leaq 0x20155(%rip), %rdx # 0x3a6f8
callq 0x3470e
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x1a5b6
movq (%rax), %rsi
jmp 0x1a5b8
xorl %esi, %esi
leaq -0x48(%rbp), %rdi
leaq -0x6c(%rbp), %rdx
callq 0x2d590
leaq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1a5f5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1a60a
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x1a699
cmpq $0x0, (%rax)
je 0x1a699
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x200ce(%rip), %rsi # 0x3a6f9
leaq 0x200d1(%rip), %rdx # 0x3a703
callq 0x3470e
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x1a645
movq (%rax), %rsi
jmp 0x1a647
xorl %esi, %esi
leaq -0x48(%rbp), %rdi
leaq -0x6c(%rbp), %rdx
callq 0x2d590
leaq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1a684
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1a699
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
cmpb $0x1, 0x33479(%rip) # 0x4db19
jne 0x1a7a1
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x20050(%rip), %rsi # 0x3a704
leaq 0x2004d(%rip), %rdx # 0x3a708
callq 0x3470e
movq 0x50(%r14), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x6c(%rbp), %rdx
callq 0x2d590
leaq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1a701
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1a716
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x1ffe5(%rip), %rsi # 0x3a709
leaq 0x1ffe2(%rip), %rdx # 0x3a70d
callq 0x3470e
movl 0x70(%r14), %eax
leaq -0x6c(%rbp), %rsi
movl %eax, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0x2f6a1
leaq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1a773
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1a788
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
leaq 0x1ff7f(%rip), %rsi # 0x3a70e
movl $0x4, %edx
movq %rbx, %rdi
callq 0x8620
jmp 0x1aa5f
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x1ff0c(%rip), %rsi # 0x3a6bb
leaq 0x1ff0b(%rip), %rdx # 0x3a6c1
callq 0x3470e
movzbl 0x80(%r14), %eax
leaq 0x1ff4c(%rip), %rcx # 0x3a716
leaq 0x1ff42(%rip), %rsi # 0x3a713
testq %rax, %rax
cmovneq %rcx, %rsi
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rcx
movq %rcx, (%rdi)
xorq $0x1, %rax
leaq (%rax,%rax,2), %rax
leaq (%rsi,%rax), %rdx
addq $0x3, %rdx
callq 0x3470e
leaq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1a828
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1a83d
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x1fe77(%rip), %rsi # 0x3a6c2
leaq 0x1fe76(%rip), %rdx # 0x3a6c8
callq 0x3470e
leaq 0x90(%r14), %r15
cmpb $0x1, 0x80(%r14)
movq %r15, -0x98(%rbp)
jne 0x1a88d
movq %r15, %rdi
callq 0x13160
leaq 0x1fe11(%rip), %rcx # 0x3a68f
leaq 0x1fe44(%rip), %r13 # 0x3a6c9
testb %al, %al
cmovneq %rcx, %r13
jmp 0x1a894
leaq 0x1fe86(%rip), %r13 # 0x3a71a
leaq -0x48(%rbp), %r15
leaq -0x38(%rbp), %rax
movq %rax, (%r15)
movq %r13, %rdi
callq 0x8230
leaq (%rax,%r13), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x3470e
leaq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
leaq -0x80(%rbp), %r15
je 0x1a8ea
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1a8ff
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x1fd91(%rip), %rsi # 0x3a69e
leaq 0x1fd8e(%rip), %rdx # 0x3a6a2
callq 0x3470e
movq 0x108(%r14), %rsi
leaq -0x48(%rbp), %rdi
callq 0x181fb
leaq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1a959
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1a96e
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x1fd27(%rip), %rsi # 0x3a6a3
leaq 0x1fd29(%rip), %rdx # 0x3a6ac
callq 0x3470e
movq 0x100(%r14), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1829b
leaq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1a9c8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1a9dd
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x68(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x1fce8(%rip), %rsi # 0x3a6d3
leaq 0x1fcea(%rip), %rdx # 0x3a6dc
callq 0x3470e
leaq -0x48(%rbp), %rdi
leaq -0x6c(%rbp), %rdx
movq -0xa0(%rbp), %rsi
callq 0x2d590
leaq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
callq 0x18fc2
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1aa3b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1aa50
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
movq -0x98(%rbp), %rsi
callq 0x19d4c
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x1aa77
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x8520
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1aae7
jmp 0x1aab4
jmp 0x1aae7
jmp 0x1aab4
jmp 0x1ab03
jmp 0x1aae7
jmp 0x1ab03
jmp 0x1aab4
jmp 0x1aae7
jmp 0x1ab03
jmp 0x1aab4
jmp 0x1aae7
jmp 0x1ab03
jmp 0x1aab4
jmp 0x1aae7
jmp 0x1ab03
jmp 0x1aab4
jmp 0x1aab4
jmp 0x1aae7
jmp 0x1aae7
jmp 0x1ab03
jmp 0x1ab03
jmp 0x1aab4
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1aaea
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x1aaea
jmp 0x1aae7
jmp 0x1aae7
jmp 0x1ab03
jmp 0x1ab03
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
jmp 0x1aabf
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1ab06
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0x1ab06
jmp 0x1ab03
movq %rax, %rbx
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x1ab22
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.